Create Quick Action Menu

	//Main Activity
	public class QuickMenuActivity extends Activity {
	/** Called when the activity is first created. */
	private static final int ID_UP = 1;
	private static final int ID_DOWN = 2;
	private static final int ID_SEARCH = 3;
	private static final int ID_INFO = 4;
	private static final int ID_ERASE = 5;
	private static final int ID_OK = 6;
	@Override
	public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	ActionItem nextItem = new ActionItem(ID_DOWN, "Next", getResources()
	.getDrawable(R.drawable.menu_down_arrow));
	ActionItem prevItem = new ActionItem(ID_UP, "Prev", getResources()
	.getDrawable(R.drawable.menu_up_arrow));
	ActionItem searchItem = new ActionItem(ID_SEARCH, "Find",
	getResources().getDrawable(R.drawable.menu_search));
	ActionItem infoItem = new ActionItem(ID_INFO, "Info", getResources()
	.getDrawable(R.drawable.menu_info));
	ActionItem eraseItem = new ActionItem(ID_ERASE, "Clear", getResources()
	.getDrawable(R.drawable.menu_eraser));
	ActionItem okItem = new ActionItem(ID_OK, "OK", getResources()
	.getDrawable(R.drawable.menu_ok));
	// use setSticky(true) to disable QuickAction dialog being dismissed
	// after an item is clicked
	prevItem.setSticky(true);
	nextItem.setSticky(true);
	// create QuickAction. Use QuickAction.VERTICAL or
	// QuickAction.HORIZONTAL param to define layout
	// orientation
	final QuickAction quickAction = new QuickAction(this,
	QuickAction.VERTICAL);
	// add action items into QuickAction
	quickAction.addActionItem(nextItem);
	quickAction.addActionItem(prevItem);
	quickAction.addActionItem(searchItem);
	quickAction.addActionItem(infoItem);
	quickAction.addActionItem(eraseItem);
	quickAction.addActionItem(okItem);
	// Set listener for action item clicked
	quickAction
	.setOnActionItemClickListener(new QuickAction.OnActionItemClickListener() {
	@Override
	public void onItemClick(QuickAction source, int pos,
	int actionId) {
	ActionItem actionItem = quickAction.getActionItem(pos);
	// here we can filter which action item was clicked with
	// pos or actionId parameter
	if (actionId == ID_SEARCH) {
	Toast.makeText(getApplicationContext(),
	"Let's do some search action",
	Toast.LENGTH_SHORT).show();
	} else if (actionId == ID_INFO) {
	Toast.makeText(getApplicationContext(),
	"I have no info this time",
	Toast.LENGTH_SHORT).show();
	} else {
	Toast.makeText(getApplicationContext(),
	actionItem.getTitle() + " selected",
	Toast.LENGTH_SHORT).show();
	}
	}
	});
	// set listnener for on dismiss event, this listener will be called only
	// if QuickAction dialog was dismissed
	// by clicking the area outside the dialog.
	quickAction.setOnDismissListener(new QuickAction.OnDismissListener() {
	@Override
	public void onDismiss() {
	Toast.makeText(getApplicationContext(), "Dismissed",
	Toast.LENGTH_SHORT).show();
	}
	});
	// show on btn1
	Button btn1 = (Button) this.findViewById(R.id.btn1);
	btn1.setOnClickListener(new View.OnClickListener() {
	@Override
	public void onClick(View v) {
	quickAction.show(v);
	}
	});
	Button btn2 = (Button) this.findViewById(R.id.btn2);
	btn2.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	quickAction.show(v);
	}
	});
	Button btn3 = (Button) this.findViewById(R.id.btn3);
	btn3.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	quickAction.show(v);
	quickAction.setAnimStyle(QuickAction.ANIM_REFLECT);
	}
	});
	}
	}
	//Popup Window Open and Dismiss
	/**
	* QuickAction dialog, shows action list as icon and text like the one in Gallery3D app. Currently supports vertical
	* and horizontal layout.
	*
	*
	*/
	public class QuickAction extends PopupWindows implements OnDismissListener {
	private View mRootView;
	private ImageView mArrowUp;
	private ImageView mArrowDown;
	private LayoutInflater mInflater;
	private ViewGroup mTrack;
	private ScrollView mScroller;
	private OnActionItemClickListener mItemClickListener;
	private OnDismissListener mDismissListener;
	private List<ActionItem> actionItems = new ArrayList<ActionItem>();
	private boolean mDidAction;
	private int mChildPos;
	private int mInsertPos;
	private int mAnimStyle;
	private int mOrientation;
	private int rootWidth=0;
	public static final int HORIZONTAL = 0;
	public static final int VERTICAL = 1;
	public static final int ANIM_GROW_FROM_LEFT = 1;
	public static final int ANIM_GROW_FROM_RIGHT = 2;
	public static final int ANIM_GROW_FROM_CENTER = 3;
	public static final int ANIM_REFLECT = 4;
	public static final int ANIM_AUTO = 5;
	/**
	* Constructor for default vertical layout
	*
	* @param context Context
	*/
	public QuickAction(Context context) {
	this(context, VERTICAL);
	}
	/**
	* Constructor allowing orientation override
	*
	* @param context Context
	* @param orientation Layout orientation, can be vartical or horizontal
	*/
	public QuickAction(Context context, int orientation) {
	super(context);
	mOrientation = orientation;
	mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	if (mOrientation == HORIZONTAL) {
	setRootViewId(R.layout.popup_horizontal);
	} else {
	setRootViewId(R.layout.popup_vertical);
	}
	mAnimStyle = ANIM_AUTO;
	mChildPos = 0;
	}
	/**
	* Get action item at an index
	*
	* @param index Index of item (position from callback)
	*
	* @return Action Item at the position
	*/
	public ActionItem getActionItem(int index) {
	return actionItems.get(index);
	}
	/**
	* Set root view.
	*
	* @param id Layout resource id
	*/
	public void setRootViewId(int id) {
	mRootView = (ViewGroup) mInflater.inflate(id, null);
	mTrack = (ViewGroup) mRootView.findViewById(R.id.tracks);
	mArrowDown = (ImageView) mRootView.findViewById(R.id.arrow_down);
	mArrowUp = (ImageView) mRootView.findViewById(R.id.arrow_up);
	mScroller = (ScrollView) mRootView.findViewById(R.id.scroller);
	//This was previously defined on show() method, moved here to prevent force close that occured
	//when tapping fastly on a view to show quickaction dialog.
	//Thanx to zammbi (github.com/zammbi)
	mRootView.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
	setContentView(mRootView);
	}
	/**
	* Set animation style
	*
	* @param mAnimStyle animation style, default is set to ANIM_AUTO
	*/
	public void setAnimStyle(int mAnimStyle) {
	this.mAnimStyle = mAnimStyle;
	}
	/**
	* Set listener for action item clicked.
	*
	* @param listener Listener
	*/
	public void setOnActionItemClickListener(OnActionItemClickListener listener) {
	mItemClickListener = listener;
	}
	/**
	* Add action item
	*
	* @param action {@link ActionItem}
	*/
	public void addActionItem(ActionItem action) {
	actionItems.add(action);
	String title = action.getTitle();
	Drawable icon = action.getIcon();
	View container;
	if (mOrientation == HORIZONTAL) {
	container = mInflater.inflate(R.layout.action_item_horizontal, null);
	} else {
	container = mInflater.inflate(R.layout.action_item_vertical, null);
	}
	ImageView img = (ImageView) container.findViewById(R.id.iv_icon);
	TextView text = (TextView) container.findViewById(R.id.tv_title);
	if (icon != null) {
	img.setImageDrawable(icon);
	} else {
	img.setVisibility(View.GONE);
	}
	if (title != null) {
	text.setText(title);
	} else {
	text.setVisibility(View.GONE);
	}
	final int pos = mChildPos;
	final int actionId = action.getActionId();
	container.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	if (mItemClickListener != null) {
	mItemClickListener.onItemClick(QuickAction.this, pos, actionId);
	}
	if (!getActionItem(pos).isSticky()) {
	mDidAction = true;
	dismiss();
	}
	}
	});
	container.setFocusable(true);
	container.setClickable(true);
	if (mOrientation == HORIZONTAL && mChildPos != 0) {
	View separator = mInflater.inflate(R.layout.horiz_separator, null);
	RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.FILL_PARENT);
	separator.setLayoutParams(params);
	separator.setPadding(5, 0, 5, 0);
	mTrack.addView(separator, mInsertPos);
	mInsertPos++;
	}
	mTrack.addView(container, mInsertPos);
	mChildPos++;
	mInsertPos++;
	}
	/**
	* Show quickaction popup. Popup is automatically positioned, on top or bottom of anchor view.
	*
	*/
	public void show (View anchor) {
	preShow();
	int xPos, yPos, arrowPos;
	mDidAction = false;
	int[] location = new int[2];
	anchor.getLocationOnScreen(location);
	Rect anchorRect = new Rect(location[0], location[1], location[0] + anchor.getWidth(), location[1]
	+ anchor.getHeight());
	//mRootView.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
	mRootView.measure(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
	int rootHeight = mRootView.getMeasuredHeight();
	if (rootWidth == 0) {
	rootWidth = mRootView.getMeasuredWidth();
	}
	int screenWidth = mWindowManager.getDefaultDisplay().getWidth();
	int screenHeight = mWindowManager.getDefaultDisplay().getHeight();
	//automatically get X coord of popup (top left)
	if ((anchorRect.left + rootWidth) > screenWidth) {
	xPos = anchorRect.left - (rootWidth-anchor.getWidth());
	xPos = (xPos < 0) ? 0 : xPos;
	arrowPos = anchorRect.centerX()-xPos;
	} else {
	if (anchor.getWidth() > rootWidth) {
	xPos = anchorRect.centerX() - (rootWidth/2);
	} else {
	xPos = anchorRect.left;
	}
	arrowPos = anchorRect.centerX()-xPos;
	}
	int dyTop = anchorRect.top;
	int dyBottom = screenHeight - anchorRect.bottom;
	boolean onTop = (dyTop > dyBottom) ? true : false;
	if (onTop) {
	if (rootHeight > dyTop) {
	yPos = 15;
	LayoutParams l = mScroller.getLayoutParams();
	l.height = dyTop - anchor.getHeight();
	} else {
	yPos = anchorRect.top - rootHeight;
	}
	} else {
	yPos = anchorRect.bottom;
	if (rootHeight > dyBottom) {
	LayoutParams l = mScroller.getLayoutParams();
	l.height = dyBottom;
	}
	}
	showArrow(((onTop) ? R.id.arrow_down : R.id.arrow_up), arrowPos);
	setAnimationStyle(screenWidth, anchorRect.centerX(), onTop);
	mWindow.showAtLocation(anchor, Gravity.NO_GRAVITY, xPos, yPos);
	}
	/**
	* Set animation style
	*
	* @param screenWidth screen width
	* @param requestedX distance from left edge
	* @param onTop flag to indicate where the popup should be displayed. Set TRUE if displayed on top of anchor view
	* and vice versa
	*/
	private void setAnimationStyle(int screenWidth, int requestedX, boolean onTop) {
	int arrowPos = requestedX - mArrowUp.getMeasuredWidth()/2;
	switch (mAnimStyle) {
	case ANIM_GROW_FROM_LEFT:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Left : R.style.Animations_PopDownMenu_Left);
	break;
	case ANIM_GROW_FROM_RIGHT:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Right : R.style.Animations_PopDownMenu_Right);
	break;
	case ANIM_GROW_FROM_CENTER:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Center : R.style.Animations_PopDownMenu_Center);
	break;
	case ANIM_REFLECT:
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Reflect : R.style.Animations_PopDownMenu_Reflect);
	break;
	case ANIM_AUTO:
	if (arrowPos <= screenWidth/4) {
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Left : R.style.Animations_PopDownMenu_Left);
	} else if (arrowPos > screenWidth/4 && arrowPos < 3 * (screenWidth/4)) {
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Center : R.style.Animations_PopDownMenu_Center);
	} else {
	mWindow.setAnimationStyle((onTop) ? R.style.Animations_PopUpMenu_Right : R.style.Animations_PopDownMenu_Right);
	}
	break;
	}
	}
	/**
	* Show arrow
	*
	* @param whichArrow arrow type resource id
	* @param requestedX distance from left screen
	*/
	private void showArrow(int whichArrow, int requestedX) {
	final View showArrow = (whichArrow == R.id.arrow_up) ? mArrowUp : mArrowDown;
	final View hideArrow = (whichArrow == R.id.arrow_up) ? mArrowDown : mArrowUp;
	final int arrowWidth = mArrowUp.getMeasuredWidth();
	showArrow.setVisibility(View.VISIBLE);
	ViewGroup.MarginLayoutParams param = (ViewGroup.MarginLayoutParams)showArrow.getLayoutParams();
	param.leftMargin = requestedX - arrowWidth / 2;
	hideArrow.setVisibility(View.INVISIBLE);
	}
	/**
	* Set listener for window dismissed. This listener will only be fired if the quicakction dialog is dismissed
	* by clicking outside the dialog or clicking on sticky item.
	*/
	public void setOnDismissListener(QuickAction.OnDismissListener listener) {
	setOnDismissListener(this);
	mDismissListener = listener;
	}
	@Override
	public void onDismiss() {
	if (!mDidAction && mDismissListener != null) {
	mDismissListener.onDismiss();
	}
	}
	/**
	* Listener for item click
	*
	*/
	public interface OnActionItemClickListener {
	public abstract void onItemClick(QuickAction source, int pos, int actionId);
	}
	/**
	* Listener for window dismiss
	*
	*/
	public interface OnDismissListener {
	public abstract void onDismiss();
	}
	}
	//--------------- Create Another Class------------------------------------------------------------------------
	public class PopupWindows {
	protected Context mContext;
	protected PopupWindow mWindow;
	protected View mRootView;
	protected Drawable mBackground = null;
	protected WindowManager mWindowManager;
	/**
	* Constructor.
	*
	* @param context Context
	*/
	public PopupWindows(Context context) {
	mContext = context;
	mWindow = new PopupWindow(context);
	mWindow.setTouchInterceptor(new OnTouchListener() {
	@Override
	public boolean onTouch(View v, MotionEvent event) {
	if (event.getAction() == MotionEvent.ACTION_OUTSIDE) {
	mWindow.dismiss();
	return true;
	}
	return false;
	}
	});
	mWindowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
	}
	/**
	* On dismiss
	*/
	protected void onDismiss() {
	}
	/**
	* On show
	*/
	protected void onShow() {
	}
	/**
	* On pre show
	*/
	protected void preShow() {
	if (mRootView == null)
	throw new IllegalStateException("setContentView was not called with a view to display.");
	onShow();
	if (mBackground == null)
	mWindow.setBackgroundDrawable(new BitmapDrawable());
	else
	mWindow.setBackgroundDrawable(mBackground);
	mWindow.setWidth(WindowManager.LayoutParams.WRAP_CONTENT);
	mWindow.setHeight(WindowManager.LayoutParams.WRAP_CONTENT);
	mWindow.setTouchable(true);
	mWindow.setFocusable(true);
	mWindow.setOutsideTouchable(true);
	mWindow.setContentView(mRootView);
	}
	/**
	* Set background drawable.
	*
	* @param background Background drawable
	*/
	public void setBackgroundDrawable(Drawable background) {
	mBackground = background;
	}
	/**
	* Set content view.
	*
	* @param root Root view
	*/
	public void setContentView(View root) {
	mRootView = root;
	mWindow.setContentView(root);
	}
	/**
	* Set content view.
	*
	* @param layoutResID Resource id
	*/
	public void setContentView(int layoutResID) {
	LayoutInflater inflator = (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	setContentView(inflator.inflate(layoutResID, null));
	}
	/**
	* Set listener on window dismissed.
	*
	* @param listener
	*/
	public void setOnDismissListener(PopupWindow.OnDismissListener listener) {
	mWindow.setOnDismissListener(listener);
	}
	/**
	* Dismiss the popup window.
	*/
	public void dismiss() {
	mWindow.dismiss();
	}
	}
	//Defining Action Items with Quick menu
	/**
	* Action item, displayed as menu with icon and text.
	*/
	public class ActionItem {
	private Drawable icon;
	private Bitmap thumb;
	private String title;
	private int actionId = -1;
	private boolean selected;
	private boolean sticky;
	/**
	* Constructor
	*
	* @param actionId Action id for case statements
	* @param title Title
	* @param icon Icon to use
	*/
	public ActionItem(int actionId, String title, Drawable icon) {
	this.title = title;
	this.icon = icon;
	this.actionId = actionId;
	}
	/**
	* Constructor
	*/
	public ActionItem() {
	this(-1, null, null);
	}
	/**
	* Constructor
	*
	* @param actionId Action id of the item
	* @param title Text to show for the item
	*/
	public ActionItem(int actionId, String title) {
	this(actionId, title, null);
	}
	/**
	* Constructor
	*
	* @param icon {@link Drawable} action icon
	*/
	public ActionItem(Drawable icon) {
	this(-1, null, icon);
	}
	/**
	* Constructor
	*
	* @param actionId Action ID of item
	* @param icon {@link Drawable} action icon
	*/
	public ActionItem(int actionId, Drawable icon) {
	this(actionId, null, icon);
	}
	/**
	* Set action title
	*
	* @param title action title
	*/
	public void setTitle(String title) {
	this.title = title;
	}
	/**
	* Get action title
	*
	* @return action title
	*/
	public String getTitle() {
	return this.title;
	}
	/**
	* Set action icon
	*
	* @param icon {@link Drawable} action icon
	*/
	public void setIcon(Drawable icon) {
	this.icon = icon;
	}
	/**
	* Get action icon
	* @return {@link Drawable} action icon
	*/
	public Drawable getIcon() {
	return this.icon;
	}
	/**
	* Set action id
	*
	* @param actionId Action id for this action
	*/
	public void setActionId(int actionId) {
	this.actionId = actionId;
	}
	/**
	* @return Our action id
	*/
	public int getActionId() {
	return actionId;
	}
	/**
	* Set sticky status of button
	*
	* @param sticky true for sticky, pop up sends event but does not disappear
	*/
	public void setSticky(boolean sticky) {
	this.sticky = sticky;
	}
	/**
	* @return true if button is sticky, menu stays visible after press
	*/
	public boolean isSticky() {
	return sticky;
	}
	/**
	* Set selected flag;
	*
	* @param selected Flag to indicate the item is selected
	*/
	public void setSelected(boolean selected) {
	this.selected = selected;
	}
	/**
	* Check if item is selected
	*
	* @return true or false
	*/
	public boolean isSelected() {
	return this.selected;
	}
	/**
	* Set thumb
	*
	* @param thumb Thumb image
	*/
	public void setThumb(Bitmap thumb) {
	this.thumb = thumb;
	}
	/**
	* Get thumb image
	*
	* @return Thumb image
	*/
	public Bitmap getThumb() {
	return this.thumb;
	}
	}

view raw QuickMenuActivity.java hosted with ❤ by GitHub