auto import from //depot/cupcake/@135843
diff --git a/src/com/android/launcher/DragLayer.java b/src/com/android/launcher/DragLayer.java
new file mode 100644
index 0000000..b542de6
--- /dev/null
+++ b/src/com/android/launcher/DragLayer.java
@@ -0,0 +1,547 @@
+/*
+ * 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.launcher;
+
+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.graphics.Paint;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.PorterDuff;
+import android.os.Vibrator;
+import android.os.SystemClock;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.KeyEvent;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.FrameLayout;
+
+/**
+ * A ViewGroup that coordinated dragging across its dscendants
+ */
+public class DragLayer extends FrameLayout implements DragController {
+ private static final int SCROLL_DELAY = 600;
+ private static final int SCROLL_ZONE = 20;
+ private static final int VIBRATE_DURATION = 35;
+ private static final int ANIMATION_SCALE_UP_DURATION = 110;
+
+ private static final boolean PROFILE_DRAWING_DURING_DRAG = false;
+
+ // Number of pixels to add to the dragged item for scaling
+ private static final float DRAG_SCALE = 24.0f;
+
+ private boolean mDragging = false;
+ private boolean mShouldDrop;
+ private float mLastMotionX;
+ private float mLastMotionY;
+
+ /**
+ * The bitmap that is currently being dragged
+ */
+ private Bitmap mDragBitmap = null;
+ private View mOriginator;
+
+ private int mBitmapOffsetX;
+ private int mBitmapOffsetY;
+
+ /**
+ * X offset from where we touched on the cell to its upper-left corner
+ */
+ private float mTouchOffsetX;
+
+ /**
+ * Y offset from where we touched on the cell to its upper-left corner
+ */
+ private float mTouchOffsetY;
+
+ /**
+ * Utility rectangle
+ */
+ private Rect mDragRect = new Rect();
+
+ /**
+ * Where the drag originated
+ */
+ private DragSource mDragSource;
+
+ /**
+ * The data associated with the object being dragged
+ */
+ private Object mDragInfo;
+
+ private final Rect mRect = new Rect();
+ private final int[] mDropCoordinates = new int[2];
+
+ private final Vibrator mVibrator = new Vibrator();
+
+ private DragListener mListener;
+
+ private DragScroller mDragScroller;
+
+ 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 int mScrollState = SCROLL_OUTSIDE_ZONE;
+
+ private ScrollRunnable mScrollRunnable = new ScrollRunnable();
+ private View mIgnoredDropTarget;
+
+ private RectF mDragRegion;
+ private boolean mEnteredRegion;
+ private DropTarget mLastDropTarget;
+
+ private final Paint mTrashPaint = new Paint();
+ private Paint mDragPaint;
+
+ private static final int ANIMATION_STATE_STARTING = 1;
+ private static final int ANIMATION_STATE_RUNNING = 2;
+ private static final int ANIMATION_STATE_DONE = 3;
+
+ private static final int ANIMATION_TYPE_SCALE = 1;
+
+ private float mAnimationFrom;
+ private float mAnimationTo;
+ private int mAnimationDuration;
+ private long mAnimationStartTime;
+ private int mAnimationType;
+ private int mAnimationState = ANIMATION_STATE_DONE;
+
+ private InputMethodManager mInputMethodManager;
+
+ /**
+ * 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 DragLayer(Context context, AttributeSet attrs) {
+ super(context, attrs);
+
+ final int srcColor = context.getResources().getColor(R.color.delete_color_filter);
+ mTrashPaint.setColorFilter(new PorterDuffColorFilter(srcColor, PorterDuff.Mode.SRC_ATOP));
+ }
+
+ public void startDrag(View v, 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)
+ getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+ }
+ mInputMethodManager.hideSoftInputFromWindow(getWindowToken(), 0);
+
+ if (mListener != null) {
+ mListener.onDragStart(v, source, dragInfo, dragAction);
+ }
+
+ Rect r = mDragRect;
+ r.set(v.getScrollX(), v.getScrollY(), 0, 0);
+
+ offsetDescendantRectToMyCoords(v, r);
+ mTouchOffsetX = mLastMotionX - r.left;
+ mTouchOffsetY = mLastMotionY - r.top;
+
+ v.clearFocus();
+ v.setPressed(false);
+
+ boolean willNotCache = v.willNotCacheDrawing();
+ v.setWillNotCacheDrawing(false);
+ v.buildDrawingCache();
+
+ Bitmap viewBitmap = v.getDrawingCache();
+ int width = viewBitmap.getWidth();
+ int height = viewBitmap.getHeight();
+
+ Matrix scale = new Matrix();
+ float scaleFactor = v.getWidth();
+ scaleFactor = (scaleFactor + DRAG_SCALE) /scaleFactor;
+ scale.setScale(scaleFactor, scaleFactor);
+
+ mAnimationTo = 1.0f;
+ mAnimationFrom = 1.0f / scaleFactor;
+ mAnimationDuration = ANIMATION_SCALE_UP_DURATION;
+ mAnimationState = ANIMATION_STATE_STARTING;
+ mAnimationType = ANIMATION_TYPE_SCALE;
+
+ mDragBitmap = Bitmap.createBitmap(viewBitmap, 0, 0, width, height, scale, true);
+ v.destroyDrawingCache();
+ v.setWillNotCacheDrawing(willNotCache);
+
+ final Bitmap dragBitmap = mDragBitmap;
+ mBitmapOffsetX = (dragBitmap.getWidth() - width) / 2;
+ mBitmapOffsetY = (dragBitmap.getHeight() - height) / 2;
+
+ if (dragAction == DRAG_ACTION_MOVE) {
+ v.setVisibility(GONE);
+ }
+
+ mDragPaint = null;
+ mDragging = true;
+ mShouldDrop = true;
+ mOriginator = v;
+ mDragSource = source;
+ mDragInfo = dragInfo;
+
+ mVibrator.vibrate(VIBRATE_DURATION);
+
+ mEnteredRegion = false;
+
+ invalidate();
+ }
+
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+ return mDragging || super.dispatchKeyEvent(event);
+ }
+
+ @Override
+ protected void dispatchDraw(Canvas canvas) {
+ super.dispatchDraw(canvas);
+
+ if (mDragging && mDragBitmap != null) {
+ if (mAnimationState == ANIMATION_STATE_STARTING) {
+ mAnimationStartTime = SystemClock.uptimeMillis();
+ mAnimationState = ANIMATION_STATE_RUNNING;
+ }
+
+ if (mAnimationState == ANIMATION_STATE_RUNNING) {
+ float normalized = (float) (SystemClock.uptimeMillis() - mAnimationStartTime) /
+ mAnimationDuration;
+ if (normalized >= 1.0f) {
+ mAnimationState = ANIMATION_STATE_DONE;
+ }
+ normalized = Math.min(normalized, 1.0f);
+ final float value = mAnimationFrom + (mAnimationTo - mAnimationFrom) * normalized;
+
+ switch (mAnimationType) {
+ case ANIMATION_TYPE_SCALE:
+ final Bitmap dragBitmap = mDragBitmap;
+ canvas.save();
+ canvas.translate(mScrollX + mLastMotionX - mTouchOffsetX - mBitmapOffsetX,
+ mScrollY + mLastMotionY - mTouchOffsetY - mBitmapOffsetY);
+ canvas.translate((dragBitmap.getWidth() * (1.0f - value)) / 2,
+ (dragBitmap.getHeight() * (1.0f - value)) / 2);
+ canvas.scale(value, value);
+ canvas.drawBitmap(dragBitmap, 0.0f, 0.0f, mDragPaint);
+ canvas.restore();
+ break;
+ }
+ } else {
+ canvas.drawBitmap(mDragBitmap,
+ mScrollX + mLastMotionX - mTouchOffsetX - mBitmapOffsetX,
+ mScrollY + mLastMotionY - mTouchOffsetY - mBitmapOffsetY, mDragPaint);
+ }
+ }
+ }
+
+ private void endDrag() {
+ if (mDragging) {
+ mDragging = false;
+ if (mDragBitmap != null) {
+ mDragBitmap.recycle();
+ }
+ if (mOriginator != null) {
+ mOriginator.setVisibility(VISIBLE);
+ }
+ if (mListener != null) {
+ mListener.onDragEnd();
+ }
+ }
+ }
+
+ @Override
+ public boolean onInterceptTouchEvent(MotionEvent ev) {
+ final int action = ev.getAction();
+
+ final float x = ev.getX();
+ final float y = ev.getY();
+
+ switch (action) {
+ case MotionEvent.ACTION_MOVE:
+ break;
+
+ case MotionEvent.ACTION_DOWN:
+ // Remember location of down touch
+ mLastMotionX = x;
+ mLastMotionY = y;
+ mLastDropTarget = null;
+ break;
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP:
+ if (mShouldDrop && drop(x, y)) {
+ mShouldDrop = false;
+ }
+ endDrag();
+ break;
+ }
+
+ return mDragging;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ if (!mDragging) {
+ return false;
+ }
+
+ final int action = ev.getAction();
+ final float x = ev.getX();
+ final float y = ev.getY();
+
+ switch (action) {
+ case MotionEvent.ACTION_DOWN:
+
+ // Remember where the motion event started
+ mLastMotionX = x;
+ mLastMotionY = y;
+
+ if ((x < SCROLL_ZONE) || (x > getWidth() - SCROLL_ZONE)) {
+ mScrollState = SCROLL_WAITING_IN_ZONE;
+ postDelayed(mScrollRunnable, SCROLL_DELAY);
+ } else {
+ mScrollState = SCROLL_OUTSIDE_ZONE;
+ }
+
+ break;
+ case MotionEvent.ACTION_MOVE:
+ final int scrollX = mScrollX;
+ final int scrollY = mScrollY;
+
+ final float touchX = mTouchOffsetX;
+ final float touchY = mTouchOffsetY;
+
+ final int offsetX = mBitmapOffsetX;
+ final int offsetY = mBitmapOffsetY;
+
+ int left = (int) (scrollX + mLastMotionX - touchX - offsetX);
+ int top = (int) (scrollY + mLastMotionY - touchY - offsetY);
+
+ final Bitmap dragBitmap = mDragBitmap;
+ final int width = dragBitmap.getWidth();
+ final int height = dragBitmap.getHeight();
+
+ final Rect rect = mRect;
+ rect.set(left - 1, top - 1, left + width + 1, top + height + 1);
+
+ mLastMotionX = x;
+ mLastMotionY = y;
+
+ left = (int) (scrollX + x - touchX - offsetX);
+ top = (int) (scrollY + y - touchY - offsetY);
+
+ rect.union(left - 1, top - 1, left + width + 1, top + height + 1);
+ invalidate(rect);
+
+ final int[] coordinates = mDropCoordinates;
+ DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);
+ if (dropTarget != null) {
+ if (mLastDropTarget == dropTarget) {
+ dropTarget.onDragOver(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo);
+ } else {
+ if (mLastDropTarget != null) {
+ mLastDropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo);
+ }
+ dropTarget.onDragEnter(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo);
+ }
+ } else {
+ if (mLastDropTarget != null) {
+ mLastDropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo);
+ }
+ }
+ mLastDropTarget = dropTarget;
+
+ boolean inDragRegion = false;
+ if (mDragRegion != null) {
+ final RectF region = mDragRegion;
+ final boolean inRegion = region.contains(ev.getRawX(), ev.getRawY());
+ if (!mEnteredRegion && inRegion) {
+ mDragPaint = mTrashPaint;
+ mEnteredRegion = true;
+ inDragRegion = true;
+ } else if (mEnteredRegion && !inRegion) {
+ mDragPaint = null;
+ mEnteredRegion = false;
+ }
+ }
+
+ if (!inDragRegion && x < SCROLL_ZONE) {
+ if (mScrollState == SCROLL_OUTSIDE_ZONE) {
+ mScrollState = SCROLL_WAITING_IN_ZONE;
+ mScrollRunnable.setDirection(SCROLL_LEFT);
+ postDelayed(mScrollRunnable, SCROLL_DELAY);
+ }
+ } else if (!inDragRegion && x > getWidth() - SCROLL_ZONE) {
+ if (mScrollState == SCROLL_OUTSIDE_ZONE) {
+ mScrollState = SCROLL_WAITING_IN_ZONE;
+ mScrollRunnable.setDirection(SCROLL_RIGHT);
+ postDelayed(mScrollRunnable, SCROLL_DELAY);
+ }
+ } else {
+ if (mScrollState == SCROLL_WAITING_IN_ZONE) {
+ mScrollState = SCROLL_OUTSIDE_ZONE;
+ mScrollRunnable.setDirection(SCROLL_RIGHT);
+ removeCallbacks(mScrollRunnable);
+ }
+ }
+
+ break;
+ case MotionEvent.ACTION_UP:
+ removeCallbacks(mScrollRunnable);
+ if (mShouldDrop) {
+ drop(x, y);
+ mShouldDrop = false;
+ }
+ endDrag();
+
+ break;
+ case MotionEvent.ACTION_CANCEL:
+ endDrag();
+ }
+
+ return true;
+ }
+
+ private boolean drop(float x, float y) {
+ invalidate();
+
+ final int[] coordinates = mDropCoordinates;
+ DropTarget dropTarget = findDropTarget((int) x, (int) y, coordinates);
+
+ if (dropTarget != null) {
+ dropTarget.onDragExit(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo);
+ if (dropTarget.acceptDrop(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo)) {
+ dropTarget.onDrop(mDragSource, coordinates[0], coordinates[1],
+ (int) mTouchOffsetX, (int) mTouchOffsetY, mDragInfo);
+ mDragSource.onDropCompleted((View) dropTarget, true);
+ return true;
+ } else {
+ mDragSource.onDropCompleted((View) dropTarget, false);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ DropTarget findDropTarget(int x, int y, int[] dropCoordinates) {
+ return findDropTarget(this, x, y, dropCoordinates);
+ }
+
+ private DropTarget findDropTarget(ViewGroup container, int x, int y, int[] dropCoordinates) {
+ final Rect r = mDragRect;
+ final int count = container.getChildCount();
+ final int scrolledX = x + container.getScrollX();
+ final int scrolledY = y + container.getScrollY();
+ final View ignoredDropTarget = mIgnoredDropTarget;
+
+ for (int i = count - 1; i >= 0; i--) {
+ final View child = container.getChildAt(i);
+ if (child.getVisibility() == VISIBLE && child != ignoredDropTarget) {
+ child.getHitRect(r);
+ if (r.contains(scrolledX, scrolledY)) {
+ DropTarget target = null;
+ if (child instanceof ViewGroup) {
+ x = scrolledX - child.getLeft();
+ y = scrolledY - child.getTop();
+ target = findDropTarget((ViewGroup) child, x, y, dropCoordinates);
+ }
+ if (target == null) {
+ if (child instanceof DropTarget) {
+ dropCoordinates[0] = x;
+ dropCoordinates[1] = y;
+ return (DropTarget) child;
+ }
+ } else {
+ return target;
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ public void setDragScoller(DragScroller scroller) {
+ mDragScroller = scroller;
+ }
+
+ public void setDragListener(DragListener l) {
+ mListener = l;
+ }
+
+ public void removeDragListener(DragListener l) {
+ mListener = null;
+ }
+
+ /**
+ * Specifies the view that must be ignored when looking for a drop target.
+ *
+ * @param view The view that will not be taken into account while looking
+ * for a drop target.
+ */
+ void setIgnoredDropTarget(View view) {
+ mIgnoredDropTarget = view;
+ }
+
+ /**
+ * Specifies the delete region.
+ *
+ * @param region The rectangle in screen coordinates of the delete region.
+ */
+ void setDeleteRegion(RectF region) {
+ mDragRegion = 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;
+ }
+ }
+}
