| Methods Summary |
|---|
| public android.graphics.RectF | getCrop()
final RectF edges = mTempEdges;
getEdgesHelper(edges);
final float scale = mRenderer.scale;
float cropLeft = -edges.left / scale;
float cropTop = -edges.top / scale;
float cropRight = cropLeft + getWidth() / scale;
float cropBottom = cropTop + getHeight() / scale;
return new RectF(cropLeft, cropTop, cropRight, cropBottom);
|
| private void | getEdgesHelper(android.graphics.RectF edgesOut)
final float width = getWidth();
final float height = getHeight();
final float[] imageDims = getImageDims();
final float imageWidth = imageDims[0];
final float imageHeight = imageDims[1];
float initialCenterX = mRenderer.source.getImageWidth() / 2f;
float initialCenterY = mRenderer.source.getImageHeight() / 2f;
float[] rendererCenter = mTempRendererCenter;
rendererCenter[0] = mCenterX - initialCenterX;
rendererCenter[1] = mCenterY - initialCenterY;
mRotateMatrix.mapPoints(rendererCenter);
rendererCenter[0] += imageWidth / 2;
rendererCenter[1] += imageHeight / 2;
final float scale = mRenderer.scale;
float centerX = (width / 2f - rendererCenter[0] + (imageWidth - width) / 2f)
* scale + width / 2f;
float centerY = (height / 2f - rendererCenter[1] + (imageHeight - height) / 2f)
* scale + height / 2f;
float leftEdge = centerX - imageWidth / 2f * scale;
float rightEdge = centerX + imageWidth / 2f * scale;
float topEdge = centerY - imageHeight / 2f * scale;
float bottomEdge = centerY + imageHeight / 2f * scale;
edgesOut.left = leftEdge;
edgesOut.right = rightEdge;
edgesOut.top = topEdge;
edgesOut.bottom = bottomEdge;
|
| private float[] | getImageDims()
final float imageWidth = mRenderer.source.getImageWidth();
final float imageHeight = mRenderer.source.getImageHeight();
float[] imageDims = mTempImageDims;
imageDims[0] = imageWidth;
imageDims[1] = imageHeight;
mRotateMatrix.mapPoints(imageDims);
imageDims[0] = Math.abs(imageDims[0]);
imageDims[1] = Math.abs(imageDims[1]);
return imageDims;
|
| public int | getImageRotation()
return mRenderer.rotation;
|
| public android.graphics.Point | getSourceDimensions()
return new Point(mRenderer.source.getImageWidth(), mRenderer.source.getImageHeight());
|
| public void | moveToLeft()
if (getWidth() == 0 || getHeight() == 0) {
final ViewTreeObserver observer = getViewTreeObserver();
observer.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
public void onGlobalLayout() {
moveToLeft();
getViewTreeObserver().removeOnGlobalLayoutListener(this);
}
});
}
final RectF edges = mTempEdges;
getEdgesHelper(edges);
final float scale = mRenderer.scale;
mCenterX += Math.ceil(edges.left / scale);
updateCenter();
|
| public boolean | onScale(android.view.ScaleGestureDetector detector)
// Don't need the lock because this will only fire inside of
// onTouchEvent
mRenderer.scale *= detector.getScaleFactor();
mRenderer.scale = Math.max(mMinScale, mRenderer.scale);
invalidate();
return true;
|
| public boolean | onScaleBegin(android.view.ScaleGestureDetector detector)
return true;
|
| public void | onScaleEnd(android.view.ScaleGestureDetector detector)
|
| protected void | onSizeChanged(int w, int h, int oldw, int oldh)
updateMinScale(w, h, mRenderer.source, false);
|
| public boolean | onTouchEvent(android.view.MotionEvent event)
int action = event.getActionMasked();
final boolean pointerUp = action == MotionEvent.ACTION_POINTER_UP;
final int skipIndex = pointerUp ? event.getActionIndex() : -1;
// Determine focal point
float sumX = 0, sumY = 0;
final int count = event.getPointerCount();
for (int i = 0; i < count; i++) {
if (skipIndex == i)
continue;
sumX += event.getX(i);
sumY += event.getY(i);
}
final int div = pointerUp ? count - 1 : count;
float x = sumX / div;
float y = sumY / div;
if (action == MotionEvent.ACTION_DOWN) {
mFirstX = x;
mFirstY = y;
mTouchDownTime = System.currentTimeMillis();
if (mTouchCallback != null) {
mTouchCallback.onTouchDown();
}
} else if (action == MotionEvent.ACTION_UP) {
ViewConfiguration config = ViewConfiguration.get(getContext());
float squaredDist = (mFirstX - x) * (mFirstX - x) + (mFirstY - y) * (mFirstY - y);
float slop = config.getScaledTouchSlop() * config.getScaledTouchSlop();
long now = System.currentTimeMillis();
if (mTouchCallback != null) {
// only do this if it's a small movement
if (squaredDist < slop &&
now < mTouchDownTime + ViewConfiguration.getTapTimeout()) {
mTouchCallback.onTap();
}
mTouchCallback.onTouchUp();
}
}
if (!mTouchEnabled) {
return true;
}
synchronized (mLock) {
mScaleGestureDetector.onTouchEvent(event);
switch (action) {
case MotionEvent.ACTION_MOVE:
float[] point = mTempPoint;
point[0] = (mLastX - x) / mRenderer.scale;
point[1] = (mLastY - y) / mRenderer.scale;
mInverseRotateMatrix.mapPoints(point);
mCenterX += point[0];
mCenterY += point[1];
updateCenter();
invalidate();
break;
}
if (mRenderer.source != null) {
// Adjust position so that the wallpaper covers the entire area
// of the screen
final RectF edges = mTempEdges;
getEdgesHelper(edges);
final float scale = mRenderer.scale;
float[] coef = mTempCoef;
coef[0] = 1;
coef[1] = 1;
mRotateMatrix.mapPoints(coef);
float[] adjustment = mTempAdjustment;
mTempAdjustment[0] = 0;
mTempAdjustment[1] = 0;
if (edges.left > 0) {
adjustment[0] = edges.left / scale;
} else if (edges.right < getWidth()) {
adjustment[0] = (edges.right - getWidth()) / scale;
}
if (edges.top > 0) {
adjustment[1] = FloatMath.ceil(edges.top / scale);
} else if (edges.bottom < getHeight()) {
adjustment[1] = (edges.bottom - getHeight()) / scale;
}
for (int dim = 0; dim <= 1; dim++) {
if (coef[dim] > 0) adjustment[dim] = FloatMath.ceil(adjustment[dim]);
}
mInverseRotateMatrix.mapPoints(adjustment);
mCenterX += adjustment[0];
mCenterY += adjustment[1];
updateCenter();
}
}
mLastX = x;
mLastY = y;
return true;
|
| public void | setScale(float scale)
synchronized (mLock) {
mRenderer.scale = scale;
}
|
| public void | setTileSource(com.android.photos.views.TiledImageRenderer.TileSource source, java.lang.Runnable isReadyCallback)
super.setTileSource(source, isReadyCallback);
mCenterX = mRenderer.centerX;
mCenterY = mRenderer.centerY;
mRotateMatrix.reset();
mRotateMatrix.setRotate(mRenderer.rotation);
mInverseRotateMatrix.reset();
mInverseRotateMatrix.setRotate(-mRenderer.rotation);
updateMinScale(getWidth(), getHeight(), source, true);
|
| public void | setTouchCallback(com.android.wallpapercropper.CropView$TouchCallback cb)
mTouchCallback = cb;
|
| public void | setTouchEnabled(boolean enabled)
mTouchEnabled = enabled;
|
| private void | updateCenter()
mRenderer.centerX = Math.round(mCenterX);
mRenderer.centerY = Math.round(mCenterY);
|
| private void | updateMinScale(int w, int h, com.android.photos.views.TiledImageRenderer.TileSource source, boolean resetScale)
synchronized (mLock) {
if (resetScale) {
mRenderer.scale = 1;
}
if (source != null) {
final float[] imageDims = getImageDims();
final float imageWidth = imageDims[0];
final float imageHeight = imageDims[1];
mMinScale = Math.max(w / imageWidth, h / imageHeight);
mRenderer.scale =
Math.max(mMinScale, resetScale ? Float.MIN_VALUE : mRenderer.scale);
}
}
|
