Android Open Source - minimalnoter Quick Action

• Back to App/note  ↑

From Project

Back to project page minimalnoter.

License

The source code is released under:

MIT License

Java Source Code

package com.softnuke.noter;
/* w  ww  .j a  v a  2 s .c  o m*/
import android.content.Context;

import android.graphics.Rect;
import android.graphics.drawable.Drawable;

import android.widget.ImageView;
import android.widget.TextView;
import android.widget.ScrollView;
import android.widget.RelativeLayout;
import android.widget.PopupWindow.OnDismissListener;

import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup.LayoutParams;
import android.view.ViewGroup;

import java.util.List;
import java.util.ArrayList;

/**
 * QuickAction dialog, shows action list as icon and text like the one in Gallery3D app. Currently supports vertical 
 * and horizontal layout.
 * 
 * @author Lorensius W. L. T <lorenz@londatiga.net>
 * 
 * Contributors:
 * - Kevin Peck <kevinwpeck@gmail.com>
 */
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 vertical 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();
  }
}

Java Source Code List

• Back to App/note  ↑