src/com/android/gallery3d/filtershow/imageshow/ImageShow.java

   1 /*
   2  * Copyright (C) 2012 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.imageshow;
  18
  19 import android.animation.Animator;
  20 import android.animation.ValueAnimator;
  21 import android.content.Context;
  22 import android.content.res.Resources;
  23 import android.graphics.Bitmap;
  24 import android.graphics.BitmapFactory;
  25 import android.graphics.BitmapShader;
  26 import android.graphics.Canvas;
  27 import android.graphics.Color;
  28 import android.graphics.Matrix;
  29 import android.graphics.Paint;
  30 import android.graphics.Point;
  31 import android.graphics.Rect;
  32 import android.graphics.RectF;
  33 import android.graphics.Shader;
  34 import android.graphics.drawable.NinePatchDrawable;
  35 import android.support.v4.widget.EdgeEffectCompat;
  36 import android.util.AttributeSet;
  37 import android.util.Log;
  38 import android.view.GestureDetector;
  39 import android.view.GestureDetector.OnDoubleTapListener;
  40 import android.view.GestureDetector.OnGestureListener;
  41 import android.view.MotionEvent;
  42 import android.view.ScaleGestureDetector;
  43 import android.view.View;
  44 import android.widget.LinearLayout;
  45
  46 import com.android.gallery3d.R;
  47 import com.android.gallery3d.filtershow.FilterShowActivity;
  48 import com.android.gallery3d.filtershow.filters.FilterMirrorRepresentation;
  49 import com.android.gallery3d.filtershow.filters.FilterRepresentation;
  50 import com.android.gallery3d.filtershow.filters.ImageFilter;
  51 import com.android.gallery3d.filtershow.pipeline.ImagePreset;
  52 import com.android.gallery3d.filtershow.tools.SaveImage;
  53
  54 import java.io.File;
  55 import java.util.ArrayList;
  56
  57 public class ImageShow extends View implements OnGestureListener,
  58         ScaleGestureDetector.OnScaleGestureListener,
  59         OnDoubleTapListener {
  60
  61     private static final String LOGTAG = "ImageShow";
  62     private static final boolean ENABLE_ZOOMED_COMPARISON = false;
  63
  64     protected Paint mPaint = new Paint();
  65     protected int mTextSize;
  66     protected int mTextPadding;
  67
  68     protected int mBackgroundColor;
  69
  70     private GestureDetector mGestureDetector = null;
  71     private ScaleGestureDetector mScaleGestureDetector = null;
  72
  73     protected Rect mImageBounds = new Rect();
  74     private boolean mOriginalDisabled = false;
  75     private boolean mTouchShowOriginal = false;
  76     private long mTouchShowOriginalDate = 0;
  77     private final long mTouchShowOriginalDelayMin = 200; // 200ms
  78     private int mShowOriginalDirection = 0;
  79     private static int UNVEIL_HORIZONTAL = 1;
  80     private static int UNVEIL_VERTICAL = 2;
  81
  82     private NinePatchDrawable mShadow = null;
  83     private Rect mShadowBounds = new Rect();
  84     private int mShadowMargin = 15; // not scaled, fixed in the asset
  85     private boolean mShadowDrawn = false;
  86
  87     private Point mTouchDown = new Point();
  88     private Point mTouch = new Point();
  89     private boolean mFinishedScalingOperation = false;
  90
  91     private int mOriginalTextMargin;
  92     private int mOriginalTextSize;
  93     private String mOriginalText;
  94     private boolean mZoomIn = false;
  95     Point mOriginalTranslation = new Point();
  96     float mOriginalScale;
  97     float mStartFocusX, mStartFocusY;
  98
  99     private EdgeEffectCompat mEdgeEffect = null;
 100     private static final int EDGE_LEFT = 1;
 101     private static final int EDGE_TOP = 2;
 102     private static final int EDGE_RIGHT = 3;
 103     private static final int EDGE_BOTTOM = 4;
 104     private int mCurrentEdgeEffect = 0;
 105     private int mEdgeSize = 100;
 106
 107     private static final int mAnimationSnapDelay = 200;
 108     private static final int mAnimationZoomDelay = 400;
 109     private ValueAnimator mAnimatorScale = null;
 110     private ValueAnimator mAnimatorTranslateX = null;
 111     private ValueAnimator mAnimatorTranslateY = null;
 112
 113     private enum InteractionMode {
 114         NONE,
 115         SCALE,
 116         MOVE
 117     }
 118     InteractionMode mInteractionMode = InteractionMode.NONE;
 119
 120     private static Bitmap sMask;
 121     private Paint mMaskPaint = new Paint();
 122     private Matrix mShaderMatrix = new Matrix();
 123     private boolean mDidStartAnimation = false;
 124
 125     private static Bitmap convertToAlphaMask(Bitmap b) {
 126         Bitmap a = Bitmap.createBitmap(b.getWidth(), b.getHeight(), Bitmap.Config.ALPHA_8);
 127         Canvas c = new Canvas(a);
 128         c.drawBitmap(b, 0.0f, 0.0f, null);
 129         return a;
 130     }
 131
 132     private static Shader createShader(Bitmap b) {
 133         return new BitmapShader(b, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
 134     }
 135
 136     private FilterShowActivity mActivity = null;
 137
 138     public FilterShowActivity getActivity() {
 139         return mActivity;
 140     }
 141
 142     public boolean hasModifications() {
 143         return MasterImage.getImage().hasModifications();
 144     }
 145
 146     public void resetParameter() {
 147         // TODO: implement reset
 148     }
 149
 150     public void onNewValue(int parameter) {
 151         invalidate();
 152     }
 153
 154     public ImageShow(Context context, AttributeSet attrs, int defStyle) {
 155         super(context, attrs, defStyle);
 156         setupImageShow(context);
 157     }
 158
 159     public ImageShow(Context context, AttributeSet attrs) {
 160         super(context, attrs);
 161         setupImageShow(context);
 162
 163     }
 164
 165     public ImageShow(Context context) {
 166         super(context);
 167         setupImageShow(context);
 168     }
 169
 170     private void setupImageShow(Context context) {
 171         Resources res = context.getResources();
 172         mTextSize = res.getDimensionPixelSize(R.dimen.photoeditor_text_size);
 173         mTextPadding = res.getDimensionPixelSize(R.dimen.photoeditor_text_padding);
 174         mOriginalTextMargin = res.getDimensionPixelSize(R.dimen.photoeditor_original_text_margin);
 175         mOriginalTextSize = res.getDimensionPixelSize(R.dimen.photoeditor_original_text_size);
 176         mBackgroundColor = res.getColor(R.color.background_screen);
 177         mOriginalText = res.getString(R.string.original_picture_text);
 178         mShadow = (NinePatchDrawable) res.getDrawable(R.drawable.geometry_shadow);
 179         setupGestureDetector(context);
 180         mActivity = (FilterShowActivity) context;
 181         if (sMask == null) {
 182             Bitmap mask = BitmapFactory.decodeResource(res, R.drawable.spot_mask);
 183             sMask = convertToAlphaMask(mask);
 184         }
 185         mEdgeEffect = new EdgeEffectCompat(context);
 186         mEdgeSize = res.getDimensionPixelSize(R.dimen.edge_glow_size);
 187     }
 188
 189     public void attach() {
 190         MasterImage.getImage().addObserver(this);
 191         bindAsImageLoadListener();
 192         MasterImage.getImage().resetGeometryImages(false);
 193     }
 194
 195     public void detach() {
 196         MasterImage.getImage().removeObserver(this);
 197         mMaskPaint.reset();
 198     }
 199
 200     public void setupGestureDetector(Context context) {
 201         mGestureDetector = new GestureDetector(context, this);
 202         mScaleGestureDetector = new ScaleGestureDetector(context, this);
 203     }
 204
 205     @Override
 206     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 207         int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
 208         int parentHeight = MeasureSpec.getSize(heightMeasureSpec);
 209         setMeasuredDimension(parentWidth, parentHeight);
 210     }
 211
 212     public ImageFilter getCurrentFilter() {
 213         return MasterImage.getImage().getCurrentFilter();
 214     }
 215
 216     /* consider moving the following 2 methods into a subclass */
 217     /**
 218      * This function calculates a Image to Screen Transformation matrix
 219      *
 220      * @param reflectRotation set true if you want the rotation encoded
 221      * @return Image to Screen transformation matrix
 222      */
 223     protected Matrix getImageToScreenMatrix(boolean reflectRotation) {
 224         MasterImage master = MasterImage.getImage();
 225         if (master.getOriginalBounds() == null) {
 226             return new Matrix();
 227         }
 228         Matrix m = GeometryMathUtils.getImageToScreenMatrix(master.getPreset().getGeometryFilters(),
 229                 reflectRotation, master.getOriginalBounds(), getWidth(), getHeight());
 230         Point translate = master.getTranslation();
 231         float scaleFactor = master.getScaleFactor();
 232         m.postTranslate(translate.x, translate.y);
 233         m.postScale(scaleFactor, scaleFactor, getWidth() / 2.0f, getHeight() / 2.0f);
 234         return m;
 235     }
 236
 237     /**
 238      * This function calculates a to Screen Image Transformation matrix
 239      *
 240      * @param reflectRotation set true if you want the rotation encoded
 241      * @return Screen to Image transformation matrix
 242      */
 243     protected Matrix getScreenToImageMatrix(boolean reflectRotation) {
 244         Matrix m = getImageToScreenMatrix(reflectRotation);
 245         Matrix invert = new Matrix();
 246         m.invert(invert);
 247         return invert;
 248     }
 249
 250     public ImagePreset getImagePreset() {
 251         return MasterImage.getImage().getPreset();
 252     }
 253
 254     @Override
 255     public void onDraw(Canvas canvas) {
 256         mPaint.reset();
 257         mPaint.setAntiAlias(true);
 258         mPaint.setFilterBitmap(true);
 259         MasterImage.getImage().setImageShowSize(
 260                 getWidth() - 2*mShadowMargin,
 261                 getHeight() - 2*mShadowMargin);
 262
 263         MasterImage img = MasterImage.getImage();
 264         // Hide the loading indicator as needed
 265         if (mActivity.isLoadingVisible() && getFilteredImage() != null) {
 266             if ((img.getLoadedPreset() == null)
 267                     || (img.getLoadedPreset() != null
 268                     && img.getLoadedPreset().equals(img.getCurrentPreset()))) {
 269                 mActivity.stopLoadingIndicator();
 270             } else if (img.getLoadedPreset() != null) {
 271                 return;
 272             }
 273             mActivity.stopLoadingIndicator();
 274         }
 275
 276         canvas.save();
 277
 278         mShadowDrawn = false;
 279
 280         Bitmap highresPreview = MasterImage.getImage().getHighresImage();
 281         Bitmap fullHighres = MasterImage.getImage().getPartialImage();
 282
 283         boolean isDoingNewLookAnimation = MasterImage.getImage().onGoingNewLookAnimation();
 284
 285         if (highresPreview == null || isDoingNewLookAnimation) {
 286             drawImageAndAnimate(canvas, getFilteredImage());
 287         } else {
 288             drawImageAndAnimate(canvas, highresPreview);
 289         }
 290
 291         drawHighresImage(canvas, fullHighres);
 292         drawCompareImage(canvas, getGeometryOnlyImage());
 293
 294         canvas.restore();
 295
 296         if (!mEdgeEffect.isFinished()) {
 297             canvas.save();
 298             float dx = (getHeight() - getWidth()) / 2f;
 299             if (getWidth() > getHeight()) {
 300                 dx = - (getWidth() - getHeight()) / 2f;
 301             }
 302             if (mCurrentEdgeEffect == EDGE_BOTTOM) {
 303                 canvas.rotate(180, getWidth()/2, getHeight()/2);
 304             } else if (mCurrentEdgeEffect == EDGE_RIGHT) {
 305                 canvas.rotate(90, getWidth()/2, getHeight()/2);
 306                 canvas.translate(0, dx);
 307             } else if (mCurrentEdgeEffect == EDGE_LEFT) {
 308                 canvas.rotate(270, getWidth()/2, getHeight()/2);
 309                 canvas.translate(0, dx);
 310             }
 311             if (mCurrentEdgeEffect != 0) {
 312                 mEdgeEffect.draw(canvas);
 313             }
 314             canvas.restore();
 315             invalidate();
 316         } else {
 317             mCurrentEdgeEffect = 0;
 318         }
 319     }
 320
 321     private void drawHighresImage(Canvas canvas, Bitmap fullHighres) {
 322         Matrix originalToScreen = MasterImage.getImage().originalImageToScreen();
 323         if (fullHighres != null && originalToScreen != null) {
 324             Matrix screenToOriginal = new Matrix();
 325             originalToScreen.invert(screenToOriginal);
 326             Rect rBounds = new Rect();
 327             rBounds.set(MasterImage.getImage().getPartialBounds());
 328             if (fullHighres != null) {
 329                 originalToScreen.preTranslate(rBounds.left, rBounds.top);
 330                 canvas.clipRect(mImageBounds);
 331                 canvas.drawBitmap(fullHighres, originalToScreen, mPaint);
 332             }
 333         }
 334     }
 335
 336     public void resetImageCaches(ImageShow caller) {
 337         MasterImage.getImage().invalidatePreview();
 338     }
 339
 340     public Bitmap getFiltersOnlyImage() {
 341         return MasterImage.getImage().getFiltersOnlyImage();
 342     }
 343
 344     public Bitmap getGeometryOnlyImage() {
 345         return MasterImage.getImage().getGeometryOnlyImage();
 346     }
 347
 348     public Bitmap getFilteredImage() {
 349         return MasterImage.getImage().getFilteredImage();
 350     }
 351
 352     public void drawImageAndAnimate(Canvas canvas,
 353                                     Bitmap image) {
 354         if (image == null) {
 355             return;
 356         }
 357         MasterImage master = MasterImage.getImage();
 358         Matrix m = master.computeImageToScreen(image, 0, false);
 359         if (m == null) {
 360             return;
 361         }
 362
 363         canvas.save();
 364
 365         RectF d = new RectF(0, 0, image.getWidth(), image.getHeight());
 366         m.mapRect(d);
 367         d.roundOut(mImageBounds);
 368
 369         if (master.onGoingNewLookAnimation()) {
 370             mDidStartAnimation = true;
 371             canvas.save();
 372
 373             // Animation uses the image before the change
 374             Bitmap previousImage = master.getPreviousImage();
 375             Matrix mp = master.computeImageToScreen(previousImage, 0, false);
 376             RectF dp = new RectF(0, 0, previousImage.getWidth(), previousImage.getHeight());
 377             mp.mapRect(dp);
 378             Rect previousBounds = new Rect();
 379             dp.roundOut(previousBounds);
 380             float centerX = dp.centerX();
 381             float centerY = dp.centerY();
 382             boolean needsToDrawImage = true;
 383
 384             if (master.getCurrentLookAnimation()
 385                     == MasterImage.CIRCLE_ANIMATION) {
 386                 float maskScale = MasterImage.getImage().getMaskScale();
 387                 if (maskScale >= 0.0f) {
 388                     float maskW = sMask.getWidth() / 2.0f;
 389                     float maskH = sMask.getHeight() / 2.0f;
 390                     Point point = mActivity.hintTouchPoint(this);
 391                     float maxMaskScale = 2 * Math.max(getWidth(), getHeight())
 392                             / Math.min(maskW, maskH);
 393                     maskScale = maskScale * maxMaskScale;
 394                     float x = point.x - maskW * maskScale;
 395                     float y = point.y - maskH * maskScale;
 396
 397                     // Prepare the shader
 398                     mShaderMatrix.reset();
 399                     mShaderMatrix.setScale(1.0f / maskScale, 1.0f / maskScale);
 400                     mShaderMatrix.preTranslate(-x + mImageBounds.left, -y + mImageBounds.top);
 401                     float scaleImageX = mImageBounds.width() / (float) image.getWidth();
 402                     float scaleImageY = mImageBounds.height() / (float) image.getHeight();
 403                     mShaderMatrix.preScale(scaleImageX, scaleImageY);
 404                     mMaskPaint.reset();
 405                     mMaskPaint.setShader(createShader(image));
 406                     mMaskPaint.getShader().setLocalMatrix(mShaderMatrix);
 407
 408                     drawShadow(canvas, mImageBounds); // as needed
 409                     canvas.drawBitmap(previousImage, m, mPaint);
 410                     canvas.clipRect(mImageBounds);
 411                     canvas.translate(x, y);
 412                     canvas.scale(maskScale, maskScale);
 413                     canvas.drawBitmap(sMask, 0, 0, mMaskPaint);
 414                     needsToDrawImage = false;
 415                 }
 416             } else if (master.getCurrentLookAnimation()
 417                     == MasterImage.ROTATE_ANIMATION) {
 418                 Rect d1 = computeImageBounds(master.getPreviousImage().getHeight(),
 419                         master.getPreviousImage().getWidth());
 420                 Rect d2 = computeImageBounds(master.getPreviousImage().getWidth(),
 421                         master.getPreviousImage().getHeight());
 422                 float finalScale = d1.width() / (float) d2.height();
 423                 finalScale = (1.0f * (1.0f - master.getAnimFraction()))
 424                         + (finalScale * master.getAnimFraction());
 425                 canvas.rotate(master.getAnimRotationValue(), centerX, centerY);
 426                 canvas.scale(finalScale, finalScale, centerX, centerY);
 427             } else if (master.getCurrentLookAnimation()
 428                     == MasterImage.MIRROR_ANIMATION) {
 429                 if (master.getCurrentFilterRepresentation()
 430                         instanceof FilterMirrorRepresentation) {
 431                     FilterMirrorRepresentation rep =
 432                             (FilterMirrorRepresentation) master.getCurrentFilterRepresentation();
 433
 434                     ImagePreset preset = master.getPreset();
 435                     ArrayList<FilterRepresentation> geometry =
 436                             (ArrayList<FilterRepresentation>) preset.getGeometryFilters();
 437                     GeometryMathUtils.GeometryHolder holder = null;
 438                     holder = GeometryMathUtils.unpackGeometry(geometry);
 439
 440                     if (holder.rotation.value() == 90 || holder.rotation.value() == 270) {
 441                         if (rep.isHorizontal() && !rep.isVertical()) {
 442                             canvas.scale(1, master.getAnimRotationValue(), centerX, centerY);
 443                         } else if (rep.isVertical() && !rep.isHorizontal()) {
 444                             canvas.scale(1, master.getAnimRotationValue(), centerX, centerY);
 445                         } else if (rep.isHorizontal() && rep.isVertical()) {
 446                             canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY);
 447                         } else {
 448                             canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY);
 449                         }
 450                     } else {
 451                         if (rep.isHorizontal() && !rep.isVertical()) {
 452                             canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY);
 453                         } else if (rep.isVertical() && !rep.isHorizontal()) {
 454                             canvas.scale(master.getAnimRotationValue(), 1, centerX, centerY);
 455                         } else  if (rep.isHorizontal() && rep.isVertical()) {
 456                             canvas.scale(1, master.getAnimRotationValue(), centerX, centerY);
 457                         } else {
 458                             canvas.scale(1, master.getAnimRotationValue(), centerX, centerY);
 459                         }
 460                     }
 461                 }
 462             }
 463
 464             if (needsToDrawImage) {
 465                 drawShadow(canvas, previousBounds); // as needed
 466                 canvas.drawBitmap(previousImage, mp, mPaint);
 467             }
 468
 469             canvas.restore();
 470         } else {
 471             drawShadow(canvas, mImageBounds); // as needed
 472             canvas.drawBitmap(image, m, mPaint);
 473         }
 474
 475         if (!master.onGoingNewLookAnimation()
 476                 && mDidStartAnimation
 477                 && !master.getPreviousPreset().equals(master.getCurrentPreset())) {
 478             mDidStartAnimation = false;
 479             MasterImage.getImage().resetAnimBitmap();
 480             invalidate();
 481         }
 482
 483         canvas.restore();
 484     }
 485
 486     private Rect computeImageBounds(int imageWidth, int imageHeight) {
 487         float scale = GeometryMathUtils.scale(imageWidth, imageHeight,
 488                 getWidth(), getHeight());
 489
 490         float w = imageWidth * scale;
 491         float h = imageHeight * scale;
 492         float ty = (getHeight() - h) / 2.0f;
 493         float tx = (getWidth() - w) / 2.0f;
 494         return new Rect((int) tx + mShadowMargin,
 495                 (int) ty + mShadowMargin,
 496                 (int) (w + tx) - mShadowMargin,
 497                 (int) (h + ty) - mShadowMargin);
 498     }
 499
 500     private void drawShadow(Canvas canvas, Rect d) {
 501         if (!mShadowDrawn) {
 502             mShadowBounds.set(d.left - mShadowMargin, d.top - mShadowMargin,
 503                     d.right + mShadowMargin, d.bottom + mShadowMargin);
 504             mShadow.setBounds(mShadowBounds);
 505             mShadow.draw(canvas);
 506             mShadowDrawn = true;
 507         }
 508     }
 509
 510     public void drawCompareImage(Canvas canvas, Bitmap image) {
 511         MasterImage master = MasterImage.getImage();
 512         boolean showsOriginal = master.showsOriginal();
 513         if (!showsOriginal && !mTouchShowOriginal)
 514             return;
 515         canvas.save();
 516         if (image != null) {
 517             if (mShowOriginalDirection == 0) {
 518                 if (Math.abs(mTouch.y - mTouchDown.y) > Math.abs(mTouch.x - mTouchDown.x)) {
 519                     mShowOriginalDirection = UNVEIL_VERTICAL;
 520                 } else {
 521                     mShowOriginalDirection = UNVEIL_HORIZONTAL;
 522                 }
 523             }
 524
 525             int px = 0;
 526             int py = 0;
 527             if (mShowOriginalDirection == UNVEIL_VERTICAL) {
 528                 px = mImageBounds.width();
 529                 py = mTouch.y - mImageBounds.top;
 530             } else {
 531                 px = mTouch.x - mImageBounds.left;
 532                 py = mImageBounds.height();
 533                 if (showsOriginal) {
 534                     px = mImageBounds.width();
 535                 }
 536             }
 537
 538             Rect d = new Rect(mImageBounds.left, mImageBounds.top,
 539                     mImageBounds.left + px, mImageBounds.top + py);
 540             if (mShowOriginalDirection == UNVEIL_HORIZONTAL) {
 541                 if (mTouchDown.x - mTouch.x > 0) {
 542                     d.set(mImageBounds.left + px, mImageBounds.top,
 543                             mImageBounds.right, mImageBounds.top + py);
 544                 }
 545             } else {
 546                 if (mTouchDown.y - mTouch.y > 0) {
 547                     d.set(mImageBounds.left, mImageBounds.top + py,
 548                             mImageBounds.left + px, mImageBounds.bottom);
 549                 }
 550             }
 551             canvas.clipRect(d);
 552             Matrix m = master.computeImageToScreen(image, 0, false);
 553             canvas.drawBitmap(image, m, mPaint);
 554             Paint paint = new Paint();
 555             paint.setColor(Color.BLACK);
 556             paint.setStrokeWidth(3);
 557
 558             if (mShowOriginalDirection == UNVEIL_VERTICAL) {
 559                 canvas.drawLine(mImageBounds.left, mTouch.y,
 560                         mImageBounds.right, mTouch.y, paint);
 561             } else {
 562                 canvas.drawLine(mTouch.x, mImageBounds.top,
 563                         mTouch.x, mImageBounds.bottom, paint);
 564             }
 565
 566             Rect bounds = new Rect();
 567             paint.setAntiAlias(true);
 568             paint.setTextSize(mOriginalTextSize);
 569             paint.getTextBounds(mOriginalText, 0, mOriginalText.length(), bounds);
 570             paint.setColor(Color.BLACK);
 571             paint.setStyle(Paint.Style.STROKE);
 572             paint.setStrokeWidth(3);
 573             canvas.drawText(mOriginalText, mImageBounds.left + mOriginalTextMargin,
 574                     mImageBounds.top + bounds.height() + mOriginalTextMargin, paint);
 575             paint.setStyle(Paint.Style.FILL);
 576             paint.setStrokeWidth(1);
 577             paint.setColor(Color.WHITE);
 578             canvas.drawText(mOriginalText, mImageBounds.left + mOriginalTextMargin,
 579                     mImageBounds.top + bounds.height() + mOriginalTextMargin, paint);
 580         }
 581         canvas.restore();
 582     }
 583
 584     public void bindAsImageLoadListener() {
 585         MasterImage.getImage().addListener(this);
 586     }
 587
 588     public void updateImage() {
 589         invalidate();
 590     }
 591
 592     public void imageLoaded() {
 593         updateImage();
 594     }
 595
 596     public void saveImage(FilterShowActivity filterShowActivity, File file) {
 597         SaveImage.saveImage(getImagePreset(), filterShowActivity, file);
 598     }
 599
 600
 601     public boolean scaleInProgress() {
 602         return mScaleGestureDetector.isInProgress();
 603     }
 604
 605     @Override
 606     public boolean onTouchEvent(MotionEvent event) {
 607         super.onTouchEvent(event);
 608         int action = event.getAction();
 609         action = action & MotionEvent.ACTION_MASK;
 610
 611         mGestureDetector.onTouchEvent(event);
 612         boolean scaleInProgress = scaleInProgress();
 613         mScaleGestureDetector.onTouchEvent(event);
 614         if (mInteractionMode == InteractionMode.SCALE) {
 615             return true;
 616         }
 617         if (!scaleInProgress() && scaleInProgress) {
 618             // If we were scaling, the scale will stop but we will
 619             // still issue an ACTION_UP. Let the subclasses know.
 620             mFinishedScalingOperation = true;
 621         }
 622
 623         int ex = (int) event.getX();
 624         int ey = (int) event.getY();
 625         if (action == MotionEvent.ACTION_DOWN) {
 626             mInteractionMode = InteractionMode.MOVE;
 627             mTouchDown.x = ex;
 628             mTouchDown.y = ey;
 629             mTouchShowOriginalDate = System.currentTimeMillis();
 630             mShowOriginalDirection = 0;
 631             MasterImage.getImage().setOriginalTranslation(MasterImage.getImage().getTranslation());
 632         }
 633
 634         if (action == MotionEvent.ACTION_MOVE && mInteractionMode == InteractionMode.MOVE) {
 635             mTouch.x = ex;
 636             mTouch.y = ey;
 637
 638             float scaleFactor = MasterImage.getImage().getScaleFactor();
 639             if (scaleFactor > 1 && (!ENABLE_ZOOMED_COMPARISON || event.getPointerCount() == 2)) {
 640                 float translateX = (mTouch.x - mTouchDown.x) / scaleFactor;
 641                 float translateY = (mTouch.y - mTouchDown.y) / scaleFactor;
 642                 Point originalTranslation = MasterImage.getImage().getOriginalTranslation();
 643                 Point translation = MasterImage.getImage().getTranslation();
 644                 translation.x = (int) (originalTranslation.x + translateX);
 645                 translation.y = (int) (originalTranslation.y + translateY);
 646                 MasterImage.getImage().setTranslation(translation);
 647                 mTouchShowOriginal = false;
 648             } else if (enableComparison() && !mOriginalDisabled
 649                     && (System.currentTimeMillis() - mTouchShowOriginalDate
 650                             > mTouchShowOriginalDelayMin)
 651                     && event.getPointerCount() == 1) {
 652                 mTouchShowOriginal = true;
 653             }
 654         }
 655
 656         if (action == MotionEvent.ACTION_UP
 657                 || action == MotionEvent.ACTION_CANCEL
 658                 || action == MotionEvent.ACTION_OUTSIDE) {
 659             mInteractionMode = InteractionMode.NONE;
 660             mTouchShowOriginal = false;
 661             mTouchDown.x = 0;
 662             mTouchDown.y = 0;
 663             mTouch.x = 0;
 664             mTouch.y = 0;
 665             if (MasterImage.getImage().getScaleFactor() <= 1) {
 666                 MasterImage.getImage().setScaleFactor(1);
 667                 MasterImage.getImage().resetTranslation();
 668             }
 669         }
 670
 671         float scaleFactor = MasterImage.getImage().getScaleFactor();
 672         Point translation = MasterImage.getImage().getTranslation();
 673         constrainTranslation(translation, scaleFactor);
 674         MasterImage.getImage().setTranslation(translation);
 675
 676         invalidate();
 677         return true;
 678     }
 679
 680     private void startAnimTranslation(int fromX, int toX,
 681                                       int fromY, int toY, int delay) {
 682         if (fromX == toX && fromY == toY) {
 683             return;
 684         }
 685         if (mAnimatorTranslateX != null) {
 686             mAnimatorTranslateX.cancel();
 687         }
 688         if (mAnimatorTranslateY != null) {
 689             mAnimatorTranslateY.cancel();
 690         }
 691         mAnimatorTranslateX = ValueAnimator.ofInt(fromX, toX);
 692         mAnimatorTranslateY = ValueAnimator.ofInt(fromY, toY);
 693         mAnimatorTranslateX.setDuration(delay);
 694         mAnimatorTranslateY.setDuration(delay);
 695         mAnimatorTranslateX.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
 696             @Override
 697             public void onAnimationUpdate(ValueAnimator animation) {
 698                 Point translation = MasterImage.getImage().getTranslation();
 699                 translation.x = (Integer) animation.getAnimatedValue();
 700                 MasterImage.getImage().setTranslation(translation);
 701                 invalidate();
 702             }
 703         });
 704         mAnimatorTranslateY.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
 705             @Override
 706             public void onAnimationUpdate(ValueAnimator animation) {
 707                 Point translation = MasterImage.getImage().getTranslation();
 708                 translation.y = (Integer) animation.getAnimatedValue();
 709                 MasterImage.getImage().setTranslation(translation);
 710                 invalidate();
 711             }
 712         });
 713         mAnimatorTranslateX.start();
 714         mAnimatorTranslateY.start();
 715     }
 716
 717     private void applyTranslationConstraints() {
 718         float scaleFactor = MasterImage.getImage().getScaleFactor();
 719         Point translation = MasterImage.getImage().getTranslation();
 720         int x = translation.x;
 721         int y = translation.y;
 722         constrainTranslation(translation, scaleFactor);
 723
 724         if (x != translation.x || y != translation.y) {
 725             startAnimTranslation(x, translation.x,
 726                                  y, translation.y,
 727                                  mAnimationSnapDelay);
 728         }
 729     }
 730
 731     protected boolean enableComparison() {
 732         return true;
 733     }
 734
 735     @Override
 736     public boolean onDoubleTap(MotionEvent arg0) {
 737         mZoomIn = !mZoomIn;
 738         float scale = 1.0f;
 739         final float x = arg0.getX();
 740         final float y = arg0.getY();
 741         if (mZoomIn) {
 742             scale = MasterImage.getImage().getMaxScaleFactor();
 743         }
 744         if (scale != MasterImage.getImage().getScaleFactor()) {
 745             if (mAnimatorScale != null) {
 746                 mAnimatorScale.cancel();
 747             }
 748             mAnimatorScale = ValueAnimator.ofFloat(
 749                     MasterImage.getImage().getScaleFactor(),
 750                     scale
 751             );
 752             float translateX = (getWidth() / 2 - x);
 753             float translateY = (getHeight() / 2 - y);
 754             Point translation = MasterImage.getImage().getTranslation();
 755             int startTranslateX = translation.x;
 756             int startTranslateY = translation.y;
 757             if (scale != 1.0f) {
 758                 translation.x = (int) (mOriginalTranslation.x + translateX);
 759                 translation.y = (int) (mOriginalTranslation.y + translateY);
 760             } else {
 761                 translation.x = 0;
 762                 translation.y = 0;
 763             }
 764             constrainTranslation(translation, scale);
 765
 766             startAnimTranslation(startTranslateX, translation.x,
 767                                  startTranslateY, translation.y,
 768                                  mAnimationZoomDelay);
 769             mAnimatorScale.setDuration(mAnimationZoomDelay);
 770             mAnimatorScale.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
 771                 @Override
 772                 public void onAnimationUpdate(ValueAnimator animation) {
 773                     MasterImage.getImage().setScaleFactor((Float) animation.getAnimatedValue());
 774                     invalidate();
 775                 }
 776             });
 777             mAnimatorScale.addListener(new Animator.AnimatorListener() {
 778                 @Override
 779                 public void onAnimationStart(Animator animation) {
 780                 }
 781
 782                 @Override
 783                 public void onAnimationEnd(Animator animation) {
 784                     applyTranslationConstraints();
 785                     MasterImage.getImage().needsUpdatePartialPreview();
 786                     invalidate();
 787                 }
 788
 789                 @Override
 790                 public void onAnimationCancel(Animator animation) {
 791
 792                 }
 793
 794                 @Override
 795                 public void onAnimationRepeat(Animator animation) {
 796
 797                 }
 798             });
 799             mAnimatorScale.start();
 800         }
 801         return true;
 802     }
 803
 804     private void constrainTranslation(Point translation, float scale) {
 805         int currentEdgeEffect = 0;
 806         if (scale <= 1) {
 807             mCurrentEdgeEffect = 0;
 808             mEdgeEffect.finish();
 809             return;
 810         }
 811
 812         Matrix originalToScreen = MasterImage.getImage().originalImageToScreen();
 813         Rect originalBounds = MasterImage.getImage().getOriginalBounds();
 814         RectF screenPos = new RectF(originalBounds);
 815         originalToScreen.mapRect(screenPos);
 816
 817         boolean rightConstraint = screenPos.right < getWidth() - mShadowMargin;
 818         boolean leftConstraint = screenPos.left > mShadowMargin;
 819         boolean topConstraint = screenPos.top > mShadowMargin;
 820         boolean bottomConstraint = screenPos.bottom < getHeight() - mShadowMargin;
 821
 822         if (screenPos.width() > getWidth()) {
 823             if (rightConstraint && !leftConstraint) {
 824                 float tx = screenPos.right - translation.x * scale;
 825                 translation.x = (int) ((getWidth() - mShadowMargin - tx) / scale);
 826                 currentEdgeEffect = EDGE_RIGHT;
 827             } else if (leftConstraint && !rightConstraint) {
 828                 float tx = screenPos.left - translation.x * scale;
 829                 translation.x = (int) ((mShadowMargin - tx) / scale);
 830                 currentEdgeEffect = EDGE_LEFT;
 831             }
 832         } else {
 833             float tx = screenPos.right - translation.x * scale;
 834             float dx = (getWidth() - 2 * mShadowMargin - screenPos.width()) / 2f;
 835             translation.x = (int) ((getWidth() - mShadowMargin - tx - dx) / scale);
 836         }
 837
 838         if (screenPos.height() > getHeight()) {
 839             if (bottomConstraint && !topConstraint) {
 840                 float ty = screenPos.bottom - translation.y * scale;
 841                 translation.y = (int) ((getHeight() - mShadowMargin - ty) / scale);
 842                 currentEdgeEffect = EDGE_BOTTOM;
 843             } else if (topConstraint && !bottomConstraint) {
 844                 float ty = screenPos.top - translation.y * scale;
 845                 translation.y = (int) ((mShadowMargin - ty) / scale);
 846                 currentEdgeEffect = EDGE_TOP;
 847             }
 848         } else {
 849             float ty = screenPos.bottom - translation.y * scale;
 850             float dy = (getHeight()- 2 * mShadowMargin - screenPos.height()) / 2f;
 851             translation.y = (int) ((getHeight() - mShadowMargin - ty - dy) / scale);
 852         }
 853
 854         if (mCurrentEdgeEffect != currentEdgeEffect) {
 855             if (mCurrentEdgeEffect == 0 || currentEdgeEffect != 0) {
 856                 mCurrentEdgeEffect = currentEdgeEffect;
 857                 mEdgeEffect.finish();
 858             }
 859             mEdgeEffect.setSize(getWidth(), mEdgeSize);
 860         }
 861         if (currentEdgeEffect != 0) {
 862             mEdgeEffect.onPull(mEdgeSize);
 863         }
 864     }
 865
 866     @Override
 867     public boolean onDoubleTapEvent(MotionEvent arg0) {
 868         return false;
 869     }
 870
 871     @Override
 872     public boolean onSingleTapConfirmed(MotionEvent arg0) {
 873         return false;
 874     }
 875
 876     @Override
 877     public boolean onDown(MotionEvent arg0) {
 878         return false;
 879     }
 880
 881     @Override
 882     public boolean onFling(MotionEvent startEvent, MotionEvent endEvent, float arg2, float arg3) {
 883         if (mActivity == null) {
 884             return false;
 885         }
 886         if (endEvent.getPointerCount() == 2) {
 887             return false;
 888         }
 889         return true;
 890     }
 891
 892     @Override
 893     public void onLongPress(MotionEvent arg0) {
 894     }
 895
 896     @Override
 897     public boolean onScroll(MotionEvent arg0, MotionEvent arg1, float arg2, float arg3) {
 898         return false;
 899     }
 900
 901     @Override
 902     public void onShowPress(MotionEvent arg0) {
 903     }
 904
 905     @Override
 906     public boolean onSingleTapUp(MotionEvent arg0) {
 907         return false;
 908     }
 909
 910     public boolean useUtilityPanel() {
 911         return false;
 912     }
 913
 914     public void openUtilityPanel(final LinearLayout accessoryViewList) {
 915     }
 916
 917     @Override
 918     public boolean onScale(ScaleGestureDetector detector) {
 919         MasterImage img = MasterImage.getImage();
 920         float scaleFactor = img.getScaleFactor();
 921
 922         scaleFactor = scaleFactor * detector.getScaleFactor();
 923         if (scaleFactor > MasterImage.getImage().getMaxScaleFactor()) {
 924             scaleFactor = MasterImage.getImage().getMaxScaleFactor();
 925         }
 926         if (scaleFactor < 1.0f) {
 927             scaleFactor = 1.0f;
 928         }
 929         MasterImage.getImage().setScaleFactor(scaleFactor);
 930         scaleFactor = img.getScaleFactor();
 931         float focusx = detector.getFocusX();
 932         float focusy = detector.getFocusY();
 933         float translateX = (focusx - mStartFocusX) / scaleFactor;
 934         float translateY = (focusy - mStartFocusY) / scaleFactor;
 935         Point translation = MasterImage.getImage().getTranslation();
 936         translation.x = (int) (mOriginalTranslation.x + translateX);
 937         translation.y = (int) (mOriginalTranslation.y + translateY);
 938         MasterImage.getImage().setTranslation(translation);
 939         invalidate();
 940         return true;
 941     }
 942
 943     @Override
 944     public boolean onScaleBegin(ScaleGestureDetector detector) {
 945         Point pos = MasterImage.getImage().getTranslation();
 946         mOriginalTranslation.x = pos.x;
 947         mOriginalTranslation.y = pos.y;
 948         mOriginalScale = MasterImage.getImage().getScaleFactor();
 949         mStartFocusX = detector.getFocusX();
 950         mStartFocusY = detector.getFocusY();
 951         mInteractionMode = InteractionMode.SCALE;
 952         return true;
 953     }
 954
 955     @Override
 956     public void onScaleEnd(ScaleGestureDetector detector) {
 957         mInteractionMode = InteractionMode.NONE;
 958         if (MasterImage.getImage().getScaleFactor() < 1) {
 959             MasterImage.getImage().setScaleFactor(1);
 960             invalidate();
 961         }
 962     }
 963
 964     public boolean didFinishScalingOperation() {
 965         if (mFinishedScalingOperation) {
 966             mFinishedScalingOperation = false;
 967             return true;
 968         }
 969         return false;
 970     }
 971
 972 }