/*
* 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.browser.view;
import android.animation.Animator;
import android.animation.Animator.AnimatorListener;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.SoundEffectConstants;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.android.browser.R;
import java.util.ArrayList;
import java.util.List;
public class PieMenu extends FrameLayout {
private static final int MAX_LEVELS = 5;
private static final long ANIMATION = 80;
public interface PieController {
/**
* called before menu opens to customize menu
* returns if pie state has been changed
*/
public boolean onOpen();
public void stopEditingUrl();
}
/**
* A view like object that lives off of the pie menu
*/
public interface PieView {
public interface OnLayoutListener {
public void onLayout(int ax, int ay, boolean left);
}
public void setLayoutListener(OnLayoutListener l);
public void layout(int anchorX, int anchorY, boolean onleft, float angle,
int parentHeight);
public void draw(Canvas c);
public boolean onTouchEvent(MotionEvent evt);
}
private Point mCenter;
private int mRadius;
private int mRadiusInc;
private int mSlop;
private int mTouchOffset;
private Path mPath;
private boolean mOpen;
private PieController mController;
private List<PieItem> mItems;
private int mLevels;
private int[] mCounts;
private PieView mPieView = null;
// sub menus
private List<PieItem> mCurrentItems;
private PieItem mOpenItem;
private Drawable mBackground;
private Paint mNormalPaint;
private Paint mSelectedPaint;
private Paint mSubPaint;
// touch handling
private PieItem mCurrentItem;
private boolean mUseBackground;
private boolean mAnimating;
/**
* @param context
* @param attrs
* @param defStyle
*/
public PieMenu(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(context);
}
/**
* @param context
* @param attrs
*/
public PieMenu(Context context, AttributeSet attrs) {
super(context, attrs);
init(context);
}
/**
* @param context
*/
public PieMenu(Context context) {
super(context);
init(context);
}
private void init(Context ctx) {
mItems = new ArrayList<PieItem>();
mLevels = 0;
mCounts = new int[MAX_LEVELS];
Resources res = ctx.getResources();
mRadius = (int) res.getDimension(R.dimen.qc_radius_start);
mRadiusInc = (int) res.getDimension(R.dimen.qc_radius_increment);
mSlop = (int) res.getDimension(R.dimen.qc_slop);
mTouchOffset = (int) res.getDimension(R.dimen.qc_touch_offset);
mOpen = false;
setWillNotDraw(false);
setDrawingCacheEnabled(false);
mCenter = new Point(0,0);
mBackground = res.getDrawable(R.drawable.qc_background_normal);
mNormalPaint = new Paint();
mNormalPaint.setColor(res.getColor(R.color.qc_normal));
mNormalPaint.setAntiAlias(true);
mSelectedPaint = new Paint();
mSelectedPaint.setColor(res.getColor(R.color.qc_selected));
mSelectedPaint.setAntiAlias(true);
mSubPaint = new Paint();
mSubPaint.setAntiAlias(true);
mSubPaint.setColor(res.getColor(R.color.qc_sub));
}
public void setController(PieController ctl) {
mController = ctl;
}
public void setUseBackground(boolean useBackground) {
mUseBackground = useBackground;
}
public void addItem(PieItem item) {
// add the item to the pie itself
mItems.add(item);
int l = item.getLevel();
mLevels = Math.max(mLevels, l);
mCounts[l]++;
}
public void removeItem(PieItem item) {
mItems.remove(item);
}
public void clearItems() {
mItems.clear();
}
private boolean onTheLeft() {
return mCenter.x < mSlop;
}
/**
* guaranteed has center set
* @param show
*/
private void show(boolean show) {
mOpen = show;
if (mOpen) {
// ensure clean state
mAnimating = false;
mCurrentItem = null;
mOpenItem = null;
mPieView = null;
mController.stopEditingUrl();
mCurrentItems = mItems;
for (PieItem item : mCurrentItems) {
item.setSelected(false);
}
if (mController != null) {
boolean changed = mController.onOpen();
}
layoutPie();
animateOpen();
}
invalidate();
}
private void animateOpen() {
ValueAnimator anim = ValueAnimator.ofFloat(0, 1);
anim.addUpdateListener(new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
for (PieItem item : mCurrentItems) {
item.setAnimationAngle((1 - animation.getAnimatedFraction()) * (- item.getStart()));
}
invalidate();
}
});
anim.setDuration(2*ANIMATION);
anim.start();
}
private void setCenter(int x, int y) {
if (x < mSlop) {
mCenter.x = 0;
} else {
mCenter.x = getWidth();
}
mCenter.y = y;
}
private void layoutPie() {
float emptyangle = (float) Math.PI / 16;
int rgap = 2;
int inner = mRadius + rgap;
int outer = mRadius + mRadiusInc - rgap;
int gap = 1;
for (int i = 0; i < mLevels; i++) {
int level = i + 1;
float sweep = (float) (Math.PI - 2 * emptyangle) / mCounts[level];
float angle = emptyangle + sweep / 2;
mPath = makeSlice(getDegrees(0) - gap, getDegrees(sweep) + gap, outer, inner, mCenter);
for (PieItem item : mCurrentItems) {
if (item.getLevel() == level) {
View view = item.getView();
if (view != null) {
view.measure(view.getLayoutParams().width,
view.getLayoutParams().height);
int w = view.getMeasuredWidth();
int h = view.getMeasuredHeight();
int r = inner + (outer - inner) * 2 / 3;
int x = (int) (r * Math.sin(angle));
int y = mCenter.y - (int) (r * Math.cos(angle)) - h / 2;
if (onTheLeft()) {
x = mCenter.x + x - w / 2;
} else {
x = mCenter.x - x - w / 2;
}
view.layout(x, y, x + w, y + h);
}
float itemstart = angle - sweep / 2;
item.setGeometry(itemstart, sweep, inner, outer);
angle += sweep;
}
}
inner += mRadiusInc;
outer += mRadiusInc;
}
}
/**
* converts a
*
* @param angle from 0..PI to Android degrees (clockwise starting at 3
* o'clock)
* @return skia angle
*/
private float getDegrees(double angle) {
return (float) (270 - 180 * angle / Math.PI);
}
@Override
protected void onDraw(Canvas canvas) {
if (mOpen) {
int state;
if (mUseBackground) {
int w = mBackground.getIntrinsicWidth();
int h = mBackground.getIntrinsicHeight();
int left = mCenter.x - w;
int top = mCenter.y - h / 2;
mBackground.setBounds(left, top, left + w, top + h);
state = canvas.save();
if (onTheLeft()) {
canvas.scale(-1, 1);
}
mBackground.draw(canvas);
canvas.restoreToCount(state);
}
// draw base menu
PieItem last = mCurrentItem;
if (mOpenItem != null) {
last = mOpenItem;
}
for (PieItem item : mCurrentItems) {
if (item != last) {
drawItem(canvas, item);
}
}
if (last != null) {
drawItem(canvas, last);
}
if (mPieView != null) {
mPieView.draw(canvas);
}
}
}
private void drawItem(Canvas canvas, PieItem item) {
if (item.getView() != null) {
Paint p = item.isSelected() ? mSelectedPaint : mNormalPaint;
if (!mItems.contains(item)) {
p = item.isSelected() ? mSelectedPaint : mSubPaint;
}
int state = canvas.save();
if (onTheLeft()) {
canvas.scale(-1, 1);
}
float r = getDegrees(item.getStartAngle()) - 270; // degrees(0)
canvas.rotate(r, mCenter.x, mCenter.y);
canvas.drawPath(mPath, p);
canvas.restoreToCount(state);
// draw the item view
View view = item.getView();
state = canvas.save();
canvas.translate(view.getX(), view.getY());
view.draw(canvas);
canvas.restoreToCount(state);
}
}
private Path makeSlice(float start, float end, int outer, int inner, Point center) {
RectF bb =
new RectF(center.x - outer, center.y - outer, center.x + outer,
center.y + outer);
RectF bbi =
new RectF(center.x - inner, center.y - inner, center.x + inner,
center.y + inner);
Path path = new Path();
path.arcTo(bb, start, end - start, true);
path.arcTo(bbi, end, start - end);
path.close();
return path;
}
// touch handling for pie
@Override
public boolean onTouchEvent(MotionEvent evt) {
float x = evt.getX();
float y = evt.getY();
int action = evt.getActionMasked();
if (MotionEvent.ACTION_DOWN == action) {
if ((x > getWidth() - mSlop) || (x < mSlop)) {
setCenter((int) x, (int) y);
show(true);
return true;
}
} else if (MotionEvent.ACTION_UP == action) {
if (mOpen) {
boolean handled = false;
if (mPieView != null) {
handled = mPieView.onTouchEvent(evt);
}
PieItem item = mCurrentItem;
if (!mAnimating) {
deselect();
}
show(false);
if (!handled && (item != null) && (item.getView() != null)) {
if ((item == mOpenItem) || !mAnimating) {
item.getView().performClick();
}
}
return true;
}
} else if (MotionEvent.ACTION_CANCEL == action) {
if (mOpen) {
show(false);
}
if (!mAnimating) {
deselect();
invalidate();
}
return false;
} else if (MotionEvent.ACTION_MOVE == action) {
if (mAnimating) return false;
boolean handled = false;
PointF polar = getPolar(x, y);
int maxr = mRadius + mLevels * mRadiusInc + 50;
if (mPieView != null) {
handled = mPieView.onTouchEvent(evt);
}
if (handled) {
invalidate();
return false;
}
if (polar.y < mRadius) {
if (mOpenItem != null) {
closeSub();
} else if (!mAnimating) {
deselect();
invalidate();
}
return false;
}
if (polar.y > maxr) {
deselect();
show(false);
evt.setAction(MotionEvent.ACTION_DOWN);
if (getParent() != null) {
((ViewGroup) getParent()).dispatchTouchEvent(evt);
}
return false;
}
PieItem item = findItem(polar);
if (item == null) {
} else if (mCurrentItem != item) {
onEnter(item);
if ((item != null) && item.isPieView() && (item.getView() != null)) {
int cx = item.getView().getLeft() + (onTheLeft()
? item.getView().getWidth() : 0);
int cy = item.getView().getTop();
mPieView = item.getPieView();
layoutPieView(mPieView, cx, cy,
(item.getStartAngle() + item.getSweep()) / 2);
}
invalidate();
}
}
// always re-dispatch event
return false;
}
private void layoutPieView(PieView pv, int x, int y, float angle) {
pv.layout(x, y, onTheLeft(), angle, getHeight());
}
/**
* enter a slice for a view
* updates model only
* @param item
*/
private void onEnter(PieItem item) {
// deselect
if (mCurrentItem != null) {
mCurrentItem.setSelected(false);
}
if (item != null) {
// clear up stack
playSoundEffect(SoundEffectConstants.CLICK);
item.setSelected(true);
mPieView = null;
mCurrentItem = item;
if ((mCurrentItem != mOpenItem) && mCurrentItem.hasItems()) {
openSub(mCurrentItem);
mOpenItem = item;
}
} else {
mCurrentItem = null;
}
}
private void animateOut(final PieItem fixed, AnimatorListener listener) {
if ((mCurrentItems == null) || (fixed == null)) return;
final float target = fixed.getStartAngle();
ValueAnimator anim = ValueAnimator.ofFloat(0, 1);
anim.addUpdateListener(new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
for (PieItem item : mCurrentItems) {
if (item != fixed) {
item.setAnimationAngle(animation.getAnimatedFraction()
* (target - item.getStart()));
}
}
invalidate();
}
});
anim.setDuration(ANIMATION);
anim.addListener(listener);
anim.start();
}
private void animateIn(final PieItem fixed, AnimatorListener listener) {
if ((mCurrentItems == null) || (fixed == null)) return;
final float target = fixed.getStartAngle();
ValueAnimator anim = ValueAnimator.ofFloat(0, 1);
anim.addUpdateListener(new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
for (PieItem item : mCurrentItems) {
if (item != fixed) {
item.setAnimationAngle((1 - animation.getAnimatedFraction())
* (target - item.getStart()));
}
}
invalidate();
}
});
anim.setDuration(ANIMATION);
anim.addListener(listener);
anim.start();
}
private void openSub(final PieItem item) {
mAnimating = true;
animateOut(item, new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator a) {
for (PieItem item : mCurrentItems) {
item.setAnimationAngle(0);
}
mCurrentItems = new ArrayList<PieItem>(mItems.size());
int i = 0, j = 0;
while (i < mItems.size()) {
if (mItems.get(i) == item) {
mCurrentItems.add(item);
} else {
mCurrentItems.add(item.getItems().get(j++));
}
i++;
}
layoutPie();
animateIn(item, new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator a) {
for (PieItem item : mCurrentItems) {
item.setAnimationAngle(0);
}
mAnimating = false;
}
});
}
});
}
private void closeSub() {
mAnimating = true;
if (mCurrentItem != null) {
mCurrentItem.setSelected(false);
}
animateOut(mOpenItem, new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator a) {
for (PieItem item : mCurrentItems) {
item.setAnimationAngle(0);
}
mCurrentItems = mItems;
mPieView = null;
animateIn(mOpenItem, new AnimatorListenerAdapter() {
public void onAnimationEnd(Animator a) {
for (PieItem item : mCurrentItems) {
item.setAnimationAngle(0);
}
mAnimating = false;
mOpenItem = null;
mCurrentItem = null;
}
});
}
});
}
private void deselect() {
if (mCurrentItem != null) {
mCurrentItem.setSelected(false);
}
if (mOpenItem != null) {
mOpenItem = null;
mCurrentItems = mItems;
}
mCurrentItem = null;
mPieView = null;
}
private PointF getPolar(float x, float y) {
PointF res = new PointF();
// get angle and radius from x/y
res.x = (float) Math.PI / 2;
x = mCenter.x - x;
if (mCenter.x < mSlop) {
x = -x;
}
y = mCenter.y - y;
res.y = (float) Math.sqrt(x * x + y * y);
if (y > 0) {
res.x = (float) Math.asin(x / res.y);
} else if (y < 0) {
res.x = (float) (Math.PI - Math.asin(x / res.y ));
}
return res;
}
/**
*
* @param polar x: angle, y: dist
* @return the item at angle/dist or null
*/
private PieItem findItem(PointF polar) {
// find the matching item:
for (PieItem item : mCurrentItems) {
if (inside(polar, mTouchOffset, item)) {
return item;
}
}
return null;
}
private boolean inside(PointF polar, float offset, PieItem item) {
return (item.getInnerRadius() - offset < polar.y)
&& (item.getOuterRadius() - offset > polar.y)
&& (item.getStartAngle() < polar.x)
&& (item.getStartAngle() + item.getSweep() > polar.x);
}
}