src/com/android/gallery3d/filtershow/crop/CropView.java

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.gallery3d.filtershow.crop;
  18
  19 import android.content.Context;
  20 import android.content.res.Resources;
  21 import android.graphics.Bitmap;
  22 import android.graphics.Canvas;
  23 import android.graphics.DashPathEffect;
  24 import android.graphics.Matrix;
  25 import android.graphics.Paint;
  26 import android.graphics.Rect;
  27 import android.graphics.RectF;
  28 import android.graphics.drawable.Drawable;
  29 import android.graphics.drawable.NinePatchDrawable;
  30 import android.util.AttributeSet;
  31 import android.util.Log;
  32 import android.view.MotionEvent;
  33 import android.view.View;
  34
  35 import com.android.gallery3d.R;
  36
  37
  38 public class CropView extends View {
  39     private static final String LOGTAG = "CropView";
  40
  41     private RectF mImageBounds = new RectF();
  42     private RectF mScreenBounds = new RectF();
  43     private RectF mScreenImageBounds = new RectF();
  44     private RectF mScreenCropBounds = new RectF();
  45     private Rect mShadowBounds = new Rect();
  46
  47     private Bitmap mBitmap;
  48     private Paint mPaint = new Paint();
  49
  50     private NinePatchDrawable mShadow;
  51     private CropObject mCropObj = null;
  52     private Drawable mCropIndicator;
  53     private int mIndicatorSize;
  54     private int mRotation = 0;
  55     private boolean mMovingBlock = false;
  56     private Matrix mDisplayMatrix = null;
  57     private Matrix mDisplayMatrixInverse = null;
  58     private boolean mDirty = false;
  59
  60     private float mPrevX = 0;
  61     private float mPrevY = 0;
  62     private float mSpotX = 0;
  63     private float mSpotY = 0;
  64     private boolean mDoSpot = false;
  65
  66     private int mShadowMargin = 15;
  67     private int mMargin = 32;
  68     private int mOverlayShadowColor = 0xCF000000;
  69     private int mOverlayWPShadowColor = 0x5F000000;
  70     private int mWPMarkerColor = 0x7FFFFFFF;
  71     private int mMinSideSize = 90;
  72     private int mTouchTolerance = 40;
  73     private float mDashOnLength = 20;
  74     private float mDashOffLength = 10;
  75
  76     private enum Mode {
  77         NONE, MOVE
  78     }
  79
  80     private Mode mState = Mode.NONE;
  81
  82     public CropView(Context context) {
  83         super(context);
  84         setup(context);
  85     }
  86
  87     public CropView(Context context, AttributeSet attrs) {
  88         super(context, attrs);
  89         setup(context);
  90     }
  91
  92     public CropView(Context context, AttributeSet attrs, int defStyle) {
  93         super(context, attrs, defStyle);
  94         setup(context);
  95     }
  96
  97     private void setup(Context context) {
  98         Resources rsc = context.getResources();
  99         mShadow = (NinePatchDrawable) rsc.getDrawable(R.drawable.geometry_shadow);
 100         mCropIndicator = rsc.getDrawable(R.drawable.camera_crop);
 101         mIndicatorSize = (int) rsc.getDimension(R.dimen.crop_indicator_size);
 102         mShadowMargin = (int) rsc.getDimension(R.dimen.shadow_margin);
 103         mMargin = (int) rsc.getDimension(R.dimen.preview_margin);
 104         mMinSideSize = (int) rsc.getDimension(R.dimen.crop_min_side);
 105         mTouchTolerance = (int) rsc.getDimension(R.dimen.crop_touch_tolerance);
 106         mOverlayShadowColor = (int) rsc.getColor(R.color.crop_shadow_color);
 107         mOverlayWPShadowColor = (int) rsc.getColor(R.color.crop_shadow_wp_color);
 108         mWPMarkerColor = (int) rsc.getColor(R.color.crop_wp_markers);
 109         mDashOnLength = rsc.getDimension(R.dimen.wp_selector_dash_length);
 110         mDashOffLength = rsc.getDimension(R.dimen.wp_selector_off_length);
 111     }
 112
 113     public void initialize(Bitmap image, RectF newCropBounds, RectF newPhotoBounds, int rotation) {
 114         mBitmap = image;
 115         if (mCropObj != null) {
 116             RectF crop = mCropObj.getInnerBounds();
 117             RectF containing = mCropObj.getOuterBounds();
 118             if (crop != newCropBounds || containing != newPhotoBounds
 119                     || mRotation != rotation) {
 120                 mRotation = rotation;
 121                 mCropObj.resetBoundsTo(newCropBounds, newPhotoBounds);
 122                 clearDisplay();
 123             }
 124         } else {
 125             mRotation = rotation;
 126             mCropObj = new CropObject(newPhotoBounds, newCropBounds, 0);
 127             clearDisplay();
 128         }
 129     }
 130
 131     public RectF getCrop() {
 132         return mCropObj.getInnerBounds();
 133     }
 134
 135     public RectF getPhoto() {
 136         return mCropObj.getOuterBounds();
 137     }
 138
 139     @Override
 140     public boolean onTouchEvent(MotionEvent event) {
 141         float x = event.getX();
 142         float y = event.getY();
 143         if (mDisplayMatrix == null || mDisplayMatrixInverse == null) {
 144             return true;
 145         }
 146         float[] touchPoint = {
 147                 x, y
 148         };
 149         mDisplayMatrixInverse.mapPoints(touchPoint);
 150         x = touchPoint[0];
 151         y = touchPoint[1];
 152         switch (event.getActionMasked()) {
 153             case (MotionEvent.ACTION_DOWN):
 154                 if (mState == Mode.NONE) {
 155                     if (!mCropObj.selectEdge(x, y)) {
 156                         mMovingBlock = mCropObj.selectEdge(CropObject.MOVE_BLOCK);
 157                     }
 158                     mPrevX = x;
 159                     mPrevY = y;
 160                     mState = Mode.MOVE;
 161                 }
 162                 break;
 163             case (MotionEvent.ACTION_UP):
 164                 if (mState == Mode.MOVE) {
 165                     mCropObj.selectEdge(CropObject.MOVE_NONE);
 166                     mMovingBlock = false;
 167                     mPrevX = x;
 168                     mPrevY = y;
 169                     mState = Mode.NONE;
 170                 }
 171                 break;
 172             case (MotionEvent.ACTION_MOVE):
 173                 if (mState == Mode.MOVE) {
 174                     float dx = x - mPrevX;
 175                     float dy = y - mPrevY;
 176                     mCropObj.moveCurrentSelection(dx, dy);
 177                     mPrevX = x;
 178                     mPrevY = y;
 179                 }
 180                 break;
 181             default:
 182                 break;
 183         }
 184         invalidate();
 185         return true;
 186     }
 187
 188     private void reset() {
 189         Log.w(LOGTAG, "crop reset called");
 190         mState = Mode.NONE;
 191         mCropObj = null;
 192         mRotation = 0;
 193         mMovingBlock = false;
 194         clearDisplay();
 195     }
 196
 197     private void clearDisplay() {
 198         mDisplayMatrix = null;
 199         mDisplayMatrixInverse = null;
 200         invalidate();
 201     }
 202
 203     protected void configChanged() {
 204         mDirty = true;
 205     }
 206
 207     public void applyFreeAspect() {
 208         mCropObj.unsetAspectRatio();
 209         invalidate();
 210     }
 211
 212     public void applyOriginalAspect() {
 213         RectF outer = mCropObj.getOuterBounds();
 214         float w = outer.width();
 215         float h = outer.height();
 216         if (w > 0 && h > 0) {
 217             applyAspect(w, h);
 218             mCropObj.resetBoundsTo(outer, outer);
 219         } else {
 220             Log.w(LOGTAG, "failed to set aspect ratio original");
 221         }
 222     }
 223
 224     public void applySquareAspect() {
 225         applyAspect(1, 1);
 226     }
 227
 228     public void applyAspect(float x, float y) {
 229         if (x <= 0 || y <= 0) {
 230             throw new IllegalArgumentException("Bad arguments to applyAspect");
 231         }
 232         // If we are rotated by 90 degrees from horizontal, swap x and y
 233         if (((mRotation < 0) ? -mRotation : mRotation) % 180 == 90) {
 234             float tmp = x;
 235             x = y;
 236             y = tmp;
 237         }
 238         if (!mCropObj.setInnerAspectRatio(x, y)) {
 239             Log.w(LOGTAG, "failed to set aspect ratio");
 240         }
 241         invalidate();
 242     }
 243
 244     public void setWallpaperSpotlight(float spotlightX, float spotlightY) {
 245         mSpotX = spotlightX;
 246         mSpotY = spotlightY;
 247         if (mSpotX > 0 && mSpotY > 0) {
 248             mDoSpot = true;
 249         }
 250     }
 251
 252     public void unsetWallpaperSpotlight() {
 253         mDoSpot = false;
 254     }
 255
 256     /**
 257      * Rotates first d bits in integer x to the left some number of times.
 258      */
 259     private int bitCycleLeft(int x, int times, int d) {
 260         int mask = (1 << d) - 1;
 261         int mout = x & mask;
 262         times %= d;
 263         int hi = mout >> (d - times);
 264         int low = (mout << times) & mask;
 265         int ret = x & ~mask;
 266         ret |= low;
 267         ret |= hi;
 268         return ret;
 269     }
 270
 271     /**
 272      * Find the selected edge or corner in screen coordinates.
 273      */
 274     private int decode(int movingEdges, float rotation) {
 275         int rot = CropMath.constrainedRotation(rotation);
 276         switch (rot) {
 277             case 90:
 278                 return bitCycleLeft(movingEdges, 1, 4);
 279             case 180:
 280                 return bitCycleLeft(movingEdges, 2, 4);
 281             case 270:
 282                 return bitCycleLeft(movingEdges, 3, 4);
 283             default:
 284                 return movingEdges;
 285         }
 286     }
 287
 288     @Override
 289     public void onDraw(Canvas canvas) {
 290         if (mBitmap == null) {
 291             return;
 292         }
 293         if (mDirty) {
 294             mDirty = false;
 295             clearDisplay();
 296         }
 297
 298         mImageBounds = new RectF(0, 0, mBitmap.getWidth(), mBitmap.getHeight());
 299         mScreenBounds = new RectF(0, 0, canvas.getWidth(), canvas.getHeight());
 300         mScreenBounds.inset(mMargin, mMargin);
 301
 302         // If crop object doesn't exist, create it and update it from master
 303         // state
 304         if (mCropObj == null) {
 305             reset();
 306             mCropObj = new CropObject(mImageBounds, mImageBounds, 0);
 307         }
 308
 309         // If display matrix doesn't exist, create it and its dependencies
 310         if (mDisplayMatrix == null || mDisplayMatrixInverse == null) {
 311             mDisplayMatrix = new Matrix();
 312             mDisplayMatrix.reset();
 313             if (!CropDrawingUtils.setImageToScreenMatrix(mDisplayMatrix, mImageBounds, mScreenBounds,
 314                     mRotation)) {
 315                 Log.w(LOGTAG, "failed to get screen matrix");
 316                 mDisplayMatrix = null;
 317                 return;
 318             }
 319             mDisplayMatrixInverse = new Matrix();
 320             mDisplayMatrixInverse.reset();
 321             if (!mDisplayMatrix.invert(mDisplayMatrixInverse)) {
 322                 Log.w(LOGTAG, "could not invert display matrix");
 323                 mDisplayMatrixInverse = null;
 324                 return;
 325             }
 326             // Scale min side and tolerance by display matrix scale factor
 327             mCropObj.setMinInnerSideSize(mDisplayMatrixInverse.mapRadius(mMinSideSize));
 328             mCropObj.setTouchTolerance(mDisplayMatrixInverse.mapRadius(mTouchTolerance));
 329         }
 330
 331         mScreenImageBounds.set(mImageBounds);
 332
 333         // Draw background shadow
 334         if (mDisplayMatrix.mapRect(mScreenImageBounds)) {
 335             int margin = (int) mDisplayMatrix.mapRadius(mShadowMargin);
 336             mScreenImageBounds.roundOut(mShadowBounds);
 337             mShadowBounds.set(mShadowBounds.left - margin, mShadowBounds.top -
 338                     margin, mShadowBounds.right + margin, mShadowBounds.bottom + margin);
 339             mShadow.setBounds(mShadowBounds);
 340             mShadow.draw(canvas);
 341         }
 342
 343         mPaint.setAntiAlias(true);
 344         mPaint.setFilterBitmap(true);
 345         // Draw actual bitmap
 346         canvas.drawBitmap(mBitmap, mDisplayMatrix, mPaint);
 347
 348         mCropObj.getInnerBounds(mScreenCropBounds);
 349
 350         if (mDisplayMatrix.mapRect(mScreenCropBounds)) {
 351
 352             // Draw overlay shadows
 353             Paint p = new Paint();
 354             p.setColor(mOverlayShadowColor);
 355             p.setStyle(Paint.Style.FILL);
 356             CropDrawingUtils.drawShadows(canvas, p, mScreenCropBounds, mScreenImageBounds);
 357
 358             // Draw crop rect and markers
 359             CropDrawingUtils.drawCropRect(canvas, mScreenCropBounds);
 360             if (!mDoSpot) {
 361                 CropDrawingUtils.drawRuleOfThird(canvas, mScreenCropBounds);
 362             } else {
 363                 Paint wpPaint = new Paint();
 364                 wpPaint.setColor(mWPMarkerColor);
 365                 wpPaint.setStrokeWidth(3);
 366                 wpPaint.setStyle(Paint.Style.STROKE);
 367                 wpPaint.setPathEffect(new DashPathEffect(new float[]
 368                         {mDashOnLength, mDashOnLength + mDashOffLength}, 0));
 369                 p.setColor(mOverlayWPShadowColor);
 370                 CropDrawingUtils.drawWallpaperSelectionFrame(canvas, mScreenCropBounds,
 371                         mSpotX, mSpotY, wpPaint, p);
 372             }
 373             CropDrawingUtils.drawIndicators(canvas, mCropIndicator, mIndicatorSize,
 374                     mScreenCropBounds, mCropObj.isFixedAspect(), decode(mCropObj.getSelectState(), mRotation));
 375         }
 376
 377     }
 378 }