xref: /packages/apps/VideoEditor/src/com/android/videoeditor/widgets/ImageViewTouchBase.java

/*
 * Copyright (C) 2009 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.videoeditor.widgets;


import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.widget.ImageView;

/**
 * An image view which can be panned and zoomed.
 */
public class ImageViewTouchBase extends ImageView {
    private static final float SCALE_RATE = 1.25F;
    // Zoom scale is applied after the transform that fits the image screen,
    // so 1.0 is a perfect fit and it doesn't make sense to allow smaller
    // values.
    private static final float MIN_ZOOM_SCALE = 1.0f;

    // This is the base transformation which is used to show the image
    // initially.  The current computation for this shows the image in
    // it's entirety, letterboxing as needed.  One could choose to
    // show the image as cropped instead.
    //
    // This matrix is recomputed when we go from the thumbnail image to
    // the full size image.
    private Matrix mBaseMatrix = new Matrix();

    // This is the supplementary transformation which reflects what
    // the user has done in terms of zooming and panning.
    //
    // This matrix remains the same when we go from the thumbnail image
    // to the full size image.
    private Matrix mSuppMatrix = new Matrix();

    // This is the final matrix which is computed as the concatenation
    // of the base matrix and the supplementary matrix.
    private final Matrix mDisplayMatrix = new Matrix();

    // Temporary buffer used for getting the values out of a matrix.
    private final float[] mMatrixValues = new float[9];

    // The current bitmap being displayed.
    private Bitmap mBitmapDisplayed;

    // The width and height of the view
    private int mThisWidth = -1, mThisHeight = -1;

    private boolean mStretch = true;
    // The zoom scale
    private float mMaxZoom;
    private Runnable mOnLayoutRunnable = null;
    private ImageTouchEventListener mEventListener;

    /**
     * Touch interface
     */
    public interface ImageTouchEventListener {
        public boolean onImageTouchEvent(MotionEvent ev);
    }
    /**
     * Constructor
     *
     * @param context The context
     */
    public ImageViewTouchBase(Context context) {
        super(context);
        setScaleType(ImageView.ScaleType.MATRIX);
    }

    /**
     * Constructor
     *
     * @param context The context
     * @param attrs The attributes
     */
    public ImageViewTouchBase(Context context, AttributeSet attrs) {
        super(context, attrs);
        setScaleType(ImageView.ScaleType.MATRIX);
    }

    /**
     * Constructor
     *
     * @param context The context
     * @param attrs The attributes
     * @param defStyle The default style
     */
    public ImageViewTouchBase(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        setScaleType(ImageView.ScaleType.MATRIX);
    }

    /*
     * {@inheritDoc}
     */
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        mThisWidth = right - left;
        mThisHeight = bottom - top;
        final Runnable r = mOnLayoutRunnable;
        if (r != null) {
            mOnLayoutRunnable = null;
            r.run();
        } else {
            if (mBitmapDisplayed != null) {
                getProperBaseMatrix(mBitmapDisplayed, mBaseMatrix);
                setImageMatrix(getImageViewMatrix());
            }
        }
    }

    /*
     * {@inheritDoc}
     */
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (mEventListener != null) {
            return mEventListener.onImageTouchEvent(ev);
        } else {
            return false;
        }
    }

    /*
     * {@inheritDoc}
     */
    @Override
    public void setImageBitmap(Bitmap bitmap) {
        super.setImageBitmap(bitmap);

        final Drawable d = getDrawable();
        if (d != null) {
            d.setDither(true);
        }

        mBitmapDisplayed = bitmap;
    }

    /**
     * @param listener The listener
     */
    public void setEventListener(ImageTouchEventListener listener) {
        mEventListener = listener;
    }

    /**
     * @return The image bitmap
     */
    public Bitmap getImageBitmap() {
        return mBitmapDisplayed;
    }

    /**
     * If the view has not yet been measured delay the method
     *
     * @param bitmap The bitmap
     * @param resetSupp true to reset the transform matrix
     */
    public void setImageBitmapResetBase(final Bitmap bitmap, final boolean resetSupp) {
        mStretch = true;
        final int viewWidth = getWidth();
        if (viewWidth <= 0) {
            mOnLayoutRunnable = new Runnable() {
                @Override
                public void run() {
                    setImageBitmapResetBase(bitmap, resetSupp);
                }
            };
            return;
        }

        if (bitmap != null) {
            getProperBaseMatrix(bitmap, mBaseMatrix);
            setImageBitmap(bitmap);
        } else {
            mBaseMatrix.reset();
            setImageBitmap(null);
        }

        if (resetSupp) {
            mSuppMatrix.reset();
        }

        setImageMatrix(getImageViewMatrix());
        mMaxZoom = maxZoom();
    }

    /**
     * Reset the transform of the current image
     */
    public void reset() {
        if (mBitmapDisplayed != null) {
            setImageBitmapResetBase(mBitmapDisplayed, true);
        }
    }

    /**
     * Pan
     *
     * @param dx The horizontal offset
     * @param dy The vertical offset
     */
    public void postTranslateCenter(float dx, float dy) {
        mSuppMatrix.postTranslate(dx, dy);

        center(true, true);
    }

    /**
     * Pan by the specified horizontal and vertical amount
     *
     * @param dx Pan by this horizontal amount
     * @param dy Pan by this vertical amount
     */
    private void panBy(float dx, float dy) {
        mSuppMatrix.postTranslate(dx, dy);

        setImageMatrix(getImageViewMatrix());
    }

    /**
     * @return The scale
     */
    public float getScale() {
        return getValue(mSuppMatrix, Matrix.MSCALE_X);
    }

    /**
     * @param rect The input/output rectangle
     */
    public void mapRect(RectF rect) {
        mSuppMatrix.mapRect(rect);
    }

    /**
     * Setup the base matrix so that the image is centered and scaled properly.
     *
     * @param bitmap The bitmap
     * @param matrix The matrix
     */
    private void getProperBaseMatrix(Bitmap bitmap, Matrix matrix) {
        final float viewWidth = getWidth();
        final float viewHeight = getHeight();

        final float w = bitmap.getWidth();
        final float h = bitmap.getHeight();
        matrix.reset();

        if (mStretch) {
            // We limit up-scaling to 10x otherwise the result may look bad if
            // it's a small icon.
            float widthScale = Math.min(viewWidth / w, 10.0f);
            float heightScale = Math.min(viewHeight / h, 10.0f);
            float scale = Math.min(widthScale, heightScale);
            matrix.postScale(scale, scale);
            matrix.postTranslate((viewWidth - w * scale) / 2F, (viewHeight - h * scale) / 2F);
        } else {
            matrix.postTranslate((viewWidth - w) / 2F, (viewHeight - h) / 2F);
        }
    }

    /**
     * Combine the base matrix and the supp matrix to make the final matrix.
     */
    private Matrix getImageViewMatrix() {
        // The final matrix is computed as the concatenation of the base matrix
        // and the supplementary matrix.
        mDisplayMatrix.set(mBaseMatrix);
        mDisplayMatrix.postConcat(mSuppMatrix);
        return mDisplayMatrix;
    }

    /**
     * @return The maximum zoom
     */
    public float getMaxZoom() {
        return mMaxZoom;
    }

    /**
     * Sets the maximum zoom, which is a scale relative to the base matrix. It
     * is calculated to show the image at 400% zoom regardless of screen or
     * image orientation. If in the future we decode the full 3 megapixel
     * image, rather than the current 1024x768, this should be changed down
     * to 200%.
     */
    private float maxZoom() {
        if (mBitmapDisplayed == null) {
            return 1F;
        }

        final float fw = (float)mBitmapDisplayed.getWidth() / mThisWidth;
        final float fh = (float)mBitmapDisplayed.getHeight() / mThisHeight;

        return Math.max(fw, fh) * 4;
    }

    /**
     * Sets the maximum zoom, which is a scale relative to the base matrix. It
     * is calculated to show the image at 400% zoom regardless of screen or
     * image orientation. If in the future we decode the full 3 megapixel
     * image, rather than the current 1024x768, this should be changed down
     * to 200%.
     */
    public static float maxZoom(int bitmapWidth, int bitmapHeight, int viewWidth, int viewHeight) {
        final float fw = (float)bitmapWidth / viewWidth;
        final float fh = (float)bitmapHeight / viewHeight;

        return Math.max(fw, fh) * 4;
    }

    /**
     * Ensure the scale factor is within limits
     *
     * @param scale The scale factor
     *
     * @return The corrected scaled factor
     */
    private float correctedZoomScale(float scale) {
        float result = scale;
        if (result > mMaxZoom) {
            result = mMaxZoom;
        } else if (result < MIN_ZOOM_SCALE) {
            result = MIN_ZOOM_SCALE;
        }

        return result;
    }

    /**
     * Zoom to the specified scale factor
     *
     * @param scale The scale factor
     * @param centerX The horizontal center
     * @param centerY The vertical center
     */
    public void zoomTo(float scale, float centerX, float centerY) {
        float correctedScale = correctedZoomScale(scale);

        float oldScale = getScale();
        float deltaScale = correctedScale / oldScale;

        mSuppMatrix.postScale(deltaScale, deltaScale, centerX, centerY);
        setImageMatrix(getImageViewMatrix());
        center(true, true);
    }

    /**
     * Zoom to the specified scale factor
     *
     * @param scale The scale factor
     */
    public void zoomTo(float scale) {
        final float cx = getWidth() / 2F;
        final float cy = getHeight() / 2F;

        zoomTo(scale, cx, cy);
    }

    /**
     * Zoom to the specified scale factor and center point
     *
     * @param scale The scale factor
     * @param pointX The horizontal position
     * @param pointY The vertical position
     */
    public void zoomToPoint(float scale, float pointX, float pointY) {
        final float cx = getWidth() / 2F;
        final float cy = getHeight() / 2F;

        panBy(cx - pointX, cy - pointY);
        zoomTo(scale, cx, cy);
    }

    /**
     * Zoom to the specified scale factor and point
     *
     * @param scale The scale factor
     * @param pointX The horizontal position
     * @param pointY The vertical position
     */
    public void zoomToOffset(float scale, float pointX, float pointY) {

        float correctedScale = correctedZoomScale(scale);

        float oldScale = getScale();
        float deltaScale = correctedScale / oldScale;

        mSuppMatrix.postScale(deltaScale, deltaScale);
        setImageMatrix(getImageViewMatrix());

        panBy(-pointX, -pointY);
    }

    /**
     * Zoom in by a preset scale rate
     */
    public void zoomIn() {
        zoomIn(SCALE_RATE);
    }

    /**
     * Zoom in by the specified scale rate
     *
     * @param rate The scale rate
     */
    public void zoomIn(float rate) {
        if (getScale() < mMaxZoom && mBitmapDisplayed != null) {
            float cx = getWidth() / 2F;
            float cy = getHeight() / 2F;

            mSuppMatrix.postScale(rate, rate, cx, cy);
            setImageMatrix(getImageViewMatrix());
        }
    }

    /**
     * Zoom out by a preset scale rate
     */
    public void zoomOut() {
        zoomOut(SCALE_RATE);
    }

    /**
     * Zoom out by the specified scale rate
     *
     * @param rate The scale rate
     */
    public void zoomOut(float rate) {
        if (getScale() > MIN_ZOOM_SCALE && mBitmapDisplayed != null) {
            float cx = getWidth() / 2F;
            float cy = getHeight() / 2F;

            // Zoom out to at most 1x.
            Matrix tmp = new Matrix(mSuppMatrix);
            tmp.postScale(1F / rate, 1F / rate, cx, cy);

            if (getValue(tmp, Matrix.MSCALE_X) < 1F) {
                mSuppMatrix.setScale(1F, 1F, cx, cy);
            } else {
                mSuppMatrix.postScale(1F / rate, 1F / rate, cx, cy);
            }
            setImageMatrix(getImageViewMatrix());
            center(true, true);
        }
    }

    /**
     * Center as much as possible in one or both axis. Centering is
     * defined as follows: if the image is scaled down below the
     * view's dimensions then center it (literally). If the image
     * is scaled larger than the view and is translated out of view
     * then translate it back into view (i.e. eliminate black bars).
     */
    private void center(boolean horizontal, boolean vertical) {
        if (mBitmapDisplayed == null) {
            return;
        }

        final Matrix m = getImageViewMatrix();
        final RectF rect = new RectF(0, 0, mBitmapDisplayed.getWidth(),
                mBitmapDisplayed.getHeight());

        m.mapRect(rect);

        final float height = rect.height();
        final float width = rect.width();
        float deltaX = 0, deltaY = 0;

        if (vertical) {
            int viewHeight = getHeight();
            if (height < viewHeight) {
                deltaY = (viewHeight - height) / 2 - rect.top;
            } else if (rect.top > 0) {
                deltaY = -rect.top;
            } else if (rect.bottom < viewHeight) {
                deltaY = getHeight() - rect.bottom;
            }
        }

        if (horizontal) {
            int viewWidth = getWidth();
            if (width < viewWidth) {
                deltaX = (viewWidth - width) / 2 - rect.left;
            } else if (rect.left > 0) {
                deltaX = -rect.left;
            } else if (rect.right < viewWidth) {
                deltaX = viewWidth - rect.right;
            }
        }

        mSuppMatrix.postTranslate(deltaX, deltaY);

        setImageMatrix(getImageViewMatrix());
    }

    /**
     * Get a matrix transform value
     *
     * @param matrix The matrix
     * @param whichValue Which value
     * @return The value
     */
    private float getValue(Matrix matrix, int whichValue) {
        matrix.getValues(mMatrixValues);
        return mMatrixValues[whichValue];
    }
}