1. Add FlipView similar to existing RotateView.
2. Add flipPhoto() similar to existing rotatePhoto() in PhotoView, and
add setRenderToFlip() in RendererUtils.
3. Make FlipAction use FlipView/PhotoView similar to how RotateAction
uses RotateView/PhotoView.
Change-Id: I5642266adbc248c0b8eda48ddc29558ae9cbd21e
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2010 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.
+-->
+
+<com.android.gallery3d.photoeditor.actions.FlipView
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:id="@+id/fullscreen_effect_tool"
+ style="@style/FullscreenToolView"/>
}
/**
+ * Flips displayed photo; this method must be queued for GL thread.
+ */
+ public void flipPhoto(float horizontalDegrees, float verticalDegrees) {
+ renderer.flipPhoto(horizontalDegrees, verticalDegrees);
+ }
+
+ /**
* Renderer that renders the GL surface-view and only be called from the GL thread.
*/
private class PhotoRenderer implements GLSurfaceView.Renderer {
int viewWidth;
int viewHeight;
float rotatedDegrees;
+ float flippedHorizontalDegrees;
+ float flippedVerticalDegrees;
void setPhoto(Photo photo, boolean clearTransform) {
int width = (photo != null) ? photo.width() : 0;
}
void updateSurface(boolean clearTransform, boolean sizeChanged) {
- boolean transformed = (rotatedDegrees != 0);
+ boolean flipped = (flippedHorizontalDegrees != 0) || (flippedVerticalDegrees != 0);
+ boolean transformed = (rotatedDegrees != 0) || flipped;
if ((clearTransform && transformed) || (sizeChanged && !transformed)) {
// Fit photo when clearing existing transforms or changing surface/photo sizes.
if (photo != null) {
RendererUtils.setRenderToFit(renderContext, photo.width(), photo.height(),
viewWidth, viewHeight);
rotatedDegrees = 0;
+ flippedHorizontalDegrees = 0;
+ flippedVerticalDegrees = 0;
}
} else {
// Restore existing transformations for orientation changes or awaking from sleep.
if (rotatedDegrees != 0) {
rotatePhoto(rotatedDegrees);
+ } else if (flipped) {
+ flipPhoto(flippedHorizontalDegrees, flippedVerticalDegrees);
}
}
}
}
}
+ void flipPhoto(float horizontalDegrees, float verticalDegrees) {
+ if (photo != null) {
+ RendererUtils.setRenderToFlip(renderContext, photo.width(), photo.height(),
+ viewWidth, viewHeight, horizontalDegrees, verticalDegrees);
+ flippedHorizontalDegrees = horizontalDegrees;
+ flippedVerticalDegrees = verticalDegrees;
+ }
+ }
+
@Override
public void onDrawFrame(GL10 gl) {
Runnable r = null;
checkGlError("glDeleteTextures");
}
- public static void setRenderToFit(RenderContext context, int srcWidth, int srcHeight,
- int dstWidth, int dstHeight) {
+ private static float[] getFitVertices(int srcWidth, int srcHeight, int dstWidth,
+ int dstHeight) {
float srcAspectRatio = ((float) srcWidth) / srcHeight;
float dstAspectRatio = ((float) dstWidth) / dstHeight;
float relativeAspectRatio = dstAspectRatio / srcAspectRatio;
- float vertices[] = new float[8];
+ float[] vertices = new float[8];
System.arraycopy(POS_VERTICES, 0, vertices, 0, vertices.length);
if (relativeAspectRatio > 1.0f) {
// Screen is wider than the camera, scale down X
vertices[5] *= relativeAspectRatio;
vertices[7] *= relativeAspectRatio;
}
- context.posVertices = createVerticesBuffer(vertices);
+ return vertices;
+ }
+
+ public static void setRenderToFit(RenderContext context, int srcWidth, int srcHeight,
+ int dstWidth, int dstHeight) {
+ context.posVertices = createVerticesBuffer(
+ getFitVertices(srcWidth, srcHeight, dstWidth, dstHeight));
}
public static void setRenderToRotate(RenderContext context, int srcWidth, int srcHeight,
int dstWidth, int dstHeight, float degrees) {
- float cosTheta = (float) Math.cos(-degrees * DEGREE_TO_RADIAN);
- float sinTheta = (float) Math.sin(-degrees * DEGREE_TO_RADIAN);
+ float radian = -degrees * DEGREE_TO_RADIAN;
+ float cosTheta = (float) Math.cos(radian);
+ float sinTheta = (float) Math.sin(radian);
float cosWidth = cosTheta * srcWidth;
float sinWidth = sinTheta * srcWidth;
float cosHeight = cosTheta * srcHeight;
context.posVertices = createVerticesBuffer(vertices);
}
+ public static void setRenderToFlip(RenderContext context, int srcWidth, int srcHeight,
+ int dstWidth, int dstHeight, float horizontalDegrees, float verticalDegrees) {
+ // Calculate the base flip coordinates.
+ float[] base = getFitVertices(srcWidth, srcHeight, dstWidth, dstHeight);
+ int horizontalRounds = (int) horizontalDegrees / 180;
+ if (horizontalRounds % 2 != 0) {
+ base[0] = -base[0];
+ base[4] = base[0];
+ base[2] = -base[2];
+ base[6] = base[2];
+ }
+ int verticalRounds = (int) verticalDegrees / 180;
+ if (verticalRounds % 2 != 0) {
+ base[1] = -base[1];
+ base[3] = base[1];
+ base[5] = -base[5];
+ base[7] = base[5];
+ }
+
+ float length = 5;
+ float[] vertices = new float[8];
+ System.arraycopy(base, 0, vertices, 0, vertices.length);
+ if (horizontalDegrees % 180f != 0) {
+ float radian = (horizontalDegrees - horizontalRounds * 180) * DEGREE_TO_RADIAN;
+ float cosTheta = (float) Math.cos(radian);
+ float sinTheta = (float) Math.sin(radian);
+
+ float scale = length / (length + sinTheta * base[0]);
+ vertices[0] = cosTheta * base[0] * scale;
+ vertices[1] = base[1] * scale;
+ vertices[4] = vertices[0];
+ vertices[5] = base[5] * scale;
+
+ scale = length / (length + sinTheta * base[2]);
+ vertices[2] = cosTheta * base[2] * scale;
+ vertices[3] = base[3] * scale;
+ vertices[6] = vertices[2];
+ vertices[7] = base[7] * scale;
+ }
+
+ if (verticalDegrees % 180f != 0) {
+ float radian = (verticalDegrees - verticalRounds * 180) * DEGREE_TO_RADIAN;
+ float cosTheta = (float) Math.cos(radian);
+ float sinTheta = (float) Math.sin(radian);
+
+ float scale = length / (length + sinTheta * base[1]);
+ vertices[0] = base[0] * scale;
+ vertices[1] = cosTheta * base[1] * scale;
+ vertices[2] = base[2] * scale;
+ vertices[3] = vertices[1];
+
+ scale = length / (length + sinTheta * base[5]);
+ vertices[4] = base[4] * scale;
+ vertices[5] = cosTheta * base[5] * scale;
+ vertices[6] = base[6] * scale;
+ vertices[7] = vertices[5];
+ }
+ context.posVertices = createVerticesBuffer(vertices);
+ }
+
public static void renderBackground() {
GLES20.glClearColor(0, 0, 0, 1);
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
return (TouchView) createFullscreenTool(R.layout.photoeditor_touch_view);
}
+ public FlipView createFlipView() {
+ return (FlipView) createFullscreenTool(R.layout.photoeditor_flip_view);
+ }
+
public RotateView createRotateView() {
return (RotateView) createFullscreenTool(R.layout.photoeditor_rotate_view);
}
import android.content.Context;
import android.util.AttributeSet;
+import com.android.gallery3d.R;
+import com.android.gallery3d.photoeditor.PhotoView;
import com.android.gallery3d.photoeditor.filters.FlipFilter;
/**
*/
public class FlipAction extends EffectAction {
- private boolean flipHorizontal;
- private boolean flipVertical;
- private TouchView touchView;
+ private static final float DEFAULT_ANGLE = 0.0f;
+ private static final float DEFAULT_FLIP_SPAN = 180.0f;
+
+ private FlipFilter filter;
+ private float horizontalFlipDegrees;
+ private float verticalFlipDegrees;
+ private Runnable queuedFlipChange;
+ private FlipView flipView;
public FlipAction(Context context, AttributeSet attrs) {
super(context, attrs);
@Override
public void doBegin() {
- final FlipFilter filter = new FlipFilter();
+ filter = new FlipFilter();
+
+ flipView = factory.createFlipView();
+ flipView.setOnFlipChangeListener(new FlipView.OnFlipChangeListener() {
- touchView = factory.createTouchView();
- touchView.setSwipeListener(new TouchView.SwipeListener() {
+ // Directly transform photo-view because running the flip filter isn't fast enough.
+ PhotoView photoView = (PhotoView) flipView.getRootView().findViewById(
+ R.id.photo_view);
@Override
- public void onSwipeDown() {
- flipFilterVertically(filter);
+ public void onAngleChanged(float horizontalDegrees, float verticalDegrees,
+ boolean fromUser) {
+ if (fromUser) {
+ horizontalFlipDegrees = horizontalDegrees;
+ verticalFlipDegrees = verticalDegrees;
+ updateFlipFilter(false);
+ transformPhotoView(horizontalDegrees, verticalDegrees);
+ }
}
@Override
- public void onSwipeLeft() {
- flipFilterHorizontally(filter);
+ public void onStartTrackingTouch() {
+ // no-op
}
@Override
- public void onSwipeRight() {
- flipFilterHorizontally(filter);
+ public void onStopTrackingTouch() {
+ roundFlipDegrees();
+ updateFlipFilter(false);
+ transformPhotoView(horizontalFlipDegrees, verticalFlipDegrees);
+ flipView.setFlippedAngles(horizontalFlipDegrees, verticalFlipDegrees);
}
- @Override
- public void onSwipeUp() {
- flipFilterVertically(filter);
+ private void transformPhotoView(final float horizontalDegrees,
+ final float verticalDegrees) {
+ // Remove the outdated flip change before queuing a new one.
+ if (queuedFlipChange != null) {
+ photoView.remove(queuedFlipChange);
+ }
+ queuedFlipChange = new Runnable() {
+
+ @Override
+ public void run() {
+ photoView.flipPhoto(horizontalDegrees, verticalDegrees);
+ }
+ };
+ photoView.queue(queuedFlipChange);
}
});
-
- flipHorizontal = false;
- flipVertical = false;
- flipFilterHorizontally(filter);
+ flipView.setFlippedAngles(DEFAULT_ANGLE, DEFAULT_ANGLE);
+ flipView.setFlipSpan(DEFAULT_FLIP_SPAN);
+ horizontalFlipDegrees = 0;
+ verticalFlipDegrees = 0;
+ queuedFlipChange = null;
}
@Override
public void doEnd() {
- touchView.setSwipeListener(null);
+ flipView.setOnFlipChangeListener(null);
+ // Round the current flip degrees in case flip tracking has not stopped yet.
+ roundFlipDegrees();
+ updateFlipFilter(true);
}
- private void flipFilterHorizontally(final FlipFilter filter) {
- flipHorizontal = !flipHorizontal;
- filter.setFlip(flipHorizontal, flipVertical);
- notifyFilterChanged(filter, true);
+ /**
+ * Rounds flip degrees to multiples of 180 degrees.
+ */
+ private void roundFlipDegrees() {
+ if (horizontalFlipDegrees % 180 != 0) {
+ horizontalFlipDegrees = Math.round(horizontalFlipDegrees / 180) * 180;
+ }
+ if (verticalFlipDegrees % 180 != 0) {
+ verticalFlipDegrees = Math.round(verticalFlipDegrees / 180) * 180;
+ }
}
- private void flipFilterVertically(final FlipFilter filter) {
- flipVertical = !flipVertical;
- filter.setFlip(flipHorizontal, flipVertical);
- notifyFilterChanged(filter, true);
+ private void updateFlipFilter(boolean outputFilter) {
+ // Flip the filter if the flipped degrees are at the opposite directions.
+ filter.setFlip(((int) horizontalFlipDegrees / 180) % 2 != 0,
+ ((int) verticalFlipDegrees / 180) % 2 != 0);
+ notifyFilterChanged(filter, outputFilter);
}
}
--- /dev/null
+/*
+ * Copyright (C) 2010 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.gallery3d.photoeditor.actions;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+/**
+ * View that handles touch-events to track flipping directions and angles.
+ */
+class FlipView extends FullscreenToolView {
+
+ /**
+ * Listens to flip changes.
+ */
+ public interface OnFlipChangeListener {
+
+ void onAngleChanged(float horizontalDegrees, float verticalDegrees, boolean fromUser);
+
+ void onStartTrackingTouch();
+
+ void onStopTrackingTouch();
+ }
+
+ private static final float FIXED_DIRECTION_THRESHOLD = 20;
+
+ private OnFlipChangeListener listener;
+ private float maxFlipSpan;
+ private float touchStartX;
+ private float touchStartY;
+ private float currentHorizontalDegrees;
+ private float currentVerticalDegrees;
+ private float lastHorizontalDegrees;
+ private float lastVerticalDegrees;
+ private boolean fixedDirection;
+ private boolean fixedDirectionHorizontal;
+
+ public FlipView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ public void setOnFlipChangeListener(OnFlipChangeListener listener) {
+ this.listener = listener;
+ }
+
+ public void setFlippedAngles(float horizontalDegrees, float verticalDegrees) {
+ refreshAngle(horizontalDegrees, verticalDegrees, false);
+ }
+
+ /**
+ * Sets allowed degrees for every flip before flipping the view.
+ */
+ public void setFlipSpan(float degrees) {
+ // Flip-span limits allowed flipping degrees of every flip for usability purpose; the max.
+ // flipped angles could be accumulated and larger than allowed flip-span.
+ maxFlipSpan = degrees;
+ }
+
+ private float calculateAngle(boolean flipHorizontal, float x, float y) {
+ // Use partial length along the moving direction to calculate the flip angle.
+ float maxDistance = (flipHorizontal ? getWidth() : getHeight()) * 0.35f;
+ float moveDistance = flipHorizontal ? (x - touchStartX) : (touchStartY - y);
+
+ if (Math.abs(moveDistance) > maxDistance) {
+ moveDistance = (moveDistance > 0) ? maxDistance : -maxDistance;
+
+ if (flipHorizontal) {
+ touchStartX = x - moveDistance;
+ } else {
+ touchStartY = moveDistance + y;
+ }
+ }
+ return (moveDistance / maxDistance) * maxFlipSpan;
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent ev) {
+ super.onTouchEvent(ev);
+
+ if (isEnabled()) {
+ switch (ev.getAction()) {
+ case MotionEvent.ACTION_DOWN:
+ fixedDirection = false;
+ lastHorizontalDegrees = currentHorizontalDegrees;
+ lastVerticalDegrees = currentVerticalDegrees;
+ touchStartX = ev.getX();
+ touchStartY = ev.getY();
+
+ if (listener != null) {
+ listener.onStartTrackingTouch();
+ }
+ break;
+
+ case MotionEvent.ACTION_MOVE:
+ // Allow only one direction for flipping during movements, and make the
+ // direction fixed once it exceeds threshold.
+ float x = ev.getX();
+ float y = ev.getY();
+ boolean flipHorizontal = fixedDirection ? fixedDirectionHorizontal
+ : (Math.abs(x - touchStartX) >= Math.abs(y - touchStartY));
+ float degrees = calculateAngle(flipHorizontal, x, y);
+ if (!fixedDirection && (Math.abs(degrees) > FIXED_DIRECTION_THRESHOLD)) {
+ fixedDirection = true;
+ fixedDirectionHorizontal = flipHorizontal;
+ }
+
+ if (flipHorizontal) {
+ refreshAngle(lastHorizontalDegrees + degrees, lastVerticalDegrees, true);
+ } else {
+ refreshAngle(lastHorizontalDegrees, lastVerticalDegrees + degrees, true);
+ }
+ break;
+
+ case MotionEvent.ACTION_CANCEL:
+ case MotionEvent.ACTION_UP:
+ if (listener != null) {
+ listener.onStopTrackingTouch();
+ }
+ break;
+ }
+ }
+ return true;
+ }
+
+ private void refreshAngle(float horizontalDegrees, float verticalDegrees, boolean fromUser) {
+ currentHorizontalDegrees = horizontalDegrees;
+ currentVerticalDegrees = verticalDegrees;
+ if (listener != null) {
+ listener.onAngleChanged(horizontalDegrees, verticalDegrees, fromUser);
+ }
+ }
+}
filter = new RotateFilter();
rotateView = factory.createRotateView();
- rotateView.setOnAngleChangeListener(new RotateView.OnRotateChangeListener() {
+ rotateView.setOnRotateChangeListener(new RotateView.OnRotateChangeListener() {
- // Directly transform photo-view because running the rotation filter isn't fast enough.
+ // Directly transform photo-view because running the rotate filter isn't fast enough.
PhotoView photoView = (PhotoView) rotateView.getRootView().findViewById(
R.id.photo_view);
public void onAngleChanged(float degrees, boolean fromUser){
if (fromUser) {
rotateDegrees = degrees;
- filter.setAngle(degrees);
- notifyFilterChanged(filter, false);
+ updateRotateFilter(false);
transformPhotoView(degrees);
}
}
@Override
public void onStopTrackingTouch() {
- if (roundFilterRotationDegrees()) {
- notifyFilterChanged(filter, false);
- transformPhotoView(rotateDegrees);
- rotateView.setRotatedAngle(rotateDegrees);
- }
+ roundRotateDegrees();
+ updateRotateFilter(false);
+ transformPhotoView(rotateDegrees);
+ rotateView.setRotatedAngle(rotateDegrees);
}
private void transformPhotoView(final float degrees) {
@Override
public void doEnd() {
- rotateView.setOnAngleChangeListener(null);
+ rotateView.setOnRotateChangeListener(null);
// Round the current rotation degrees in case rotation tracking has not stopped yet.
- roundFilterRotationDegrees();
- notifyFilterChanged(filter, true);
+ roundRotateDegrees();
+ updateRotateFilter(true);
}
/**
- * Rounds filter rotation degrees to multiples of 90 degrees.
- *
- * @return true if the rotation degrees has been changed.
+ * Rounds rotate degrees to multiples of 90 degrees.
*/
- private boolean roundFilterRotationDegrees() {
+ private void roundRotateDegrees() {
if (rotateDegrees % 90 != 0) {
rotateDegrees = Math.round(rotateDegrees / 90) * 90;
- filter.setAngle(rotateDegrees);
- return true;
}
- return false;
+ }
+
+ private void updateRotateFilter(boolean outputFilter) {
+ filter.setAngle(rotateDegrees);
+ notifyFilterChanged(filter, outputFilter);
}
}
minRotatedAngle = -maxRotatedAngle;
}
- public void setOnAngleChangeListener(OnRotateChangeListener listener) {
+ public void setOnRotateChangeListener(OnRotateChangeListener listener) {
this.listener = listener;
}
final StraightenFilter filter = new StraightenFilter();
rotateView = factory.createRotateView();
- rotateView.setOnAngleChangeListener(new RotateView.OnRotateChangeListener() {
+ rotateView.setOnRotateChangeListener(new RotateView.OnRotateChangeListener() {
@Override
public void onAngleChanged(float degrees, boolean fromUser){
@Override
public void doEnd() {
- rotateView.setOnAngleChangeListener(null);
+ rotateView.setOnRotateChangeListener(null);
}
}
OSDN Git Service
