Android：PowerPopMenu——加强版的PopupWindow菜单

最新推荐文章于 2021-05-26 03:34:18 发布
最新推荐文章于 2021-05-26 03:34:18 发布
阅读量3.1k 收藏 2
点赞数 1
分类专栏： Android 文章标签： Android PowerPopMenu 加强版 PopupWindow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HMYANG314/article/details/50718455
版权

在项目的开发过程中，经常需要弹出PopupWindow样式的菜单，大体上有两种弹出位置：


第一种、弹出菜单依附于点击的位置，同时也会分为上下，菜单方向是水平还是竖直，如下图：



第二种、无论在屏幕的任何位置点击，都只从最底部弹出，如下图：




首先，用于列表显示的控件是RecyclerView，要用android-support-v7-recyclerview.jar包，这个在网上能比较容易找到。


代码结构如下：



既然要用RecyclerView，那就会说到 RecyclerView.Adapter<VH> 和 ViewHolder，在我之前的一篇博客

Android：BaseRecyclerViewAdapter（RecyclerView 之 BaseAdapter）已经写了RecyclerView.Adapter的使用，并且将其与ViewHolder都抽出了一个基类，提高开发效率。


在这里用到的是PowerPopMenuAdapter来显示菜单列表，能自动适配传入数据是否有图标，是横向显示还是纵向显示的，代码如下：

注：PowerPopMenuAdapter是PowerPopMenu的一种满足一般情况下的显示样式，如果不满足自己的需求，可以通过mPowerPopMenu.setAdapter(adapter)设置，这里的adapter必须继承于BaseRecyclerViewAdapter，同样是为了规范。


package com.hmy.powerpopmenu;

import android.content.Context;
import android.support.v7.widget.LinearLayoutManager;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.hmy.adapter.BaseRecyclerViewAdapter;
import com.hmy.adapter.BaseViewHolder;
import com.hmy.utils.DensityUtil;


/**
 * Created by HMY on 2015/12/25.
 */
public class PowerPopMenuAdapter extends BaseRecyclerViewAdapter<PowerPopMenuModel> {

    private static final int ITEM_VIEW_HEIGHT = 50;
    private int mOrientation = LinearLayoutManager.HORIZONTAL;
    private boolean mIsShowIcon = false;

    public PowerPopMenuAdapter(Context context) {
        super(context);
    }

    /**
     * @param orientation 水平:LinearLayoutManager.HORIZONTAL，竖直:LinearLayoutManager.VERTICAL
     */
    public void setOrientation(int orientation) {
        if (orientation == LinearLayoutManager.HORIZONTAL
                || orientation == LinearLayoutManager.VERTICAL) {
            mOrientation = orientation;
        }
    }

    public void setIsShowIcon(boolean isShowIcon) {
        mIsShowIcon = isShowIcon;
    }

    @Override
    public int getItemViewHeight() {
        return DensityUtil.dip2px(mContext, ITEM_VIEW_HEIGHT);
    }

    @Override
    public BaseViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
        View v = LayoutInflater.from(mContext).inflate(R.layout.item_power_pop_menu, viewGroup, false);
        PowerPopViewHolder viewHolder = new PowerPopViewHolder(v);
        return viewHolder;
    }

    @Override
    public void onBindViewHolder(BaseViewHolder baseViewHolder, int i) {
        super.onBindViewHolder(baseViewHolder, i);
        PowerPopViewHolder holder = (PowerPopViewHolder) baseViewHolder;

        // 文本
        holder.textTv.setText(mList.get(i).text);

        // 图标显示
        if (mIsShowIcon) {
            int resid = mList.get(i).resid;
            if (resid != 0) {
                holder.iconIv.setImageResource(resid);
                holder.iconIv.setVisibility(View.VISIBLE);
            } else {
                holder.iconIv.setVisibility(View.INVISIBLE);
            }
        } else {
            holder.iconIv.setVisibility(View.GONE);
        }

        // 分割线
        if (mOrientation == LinearLayoutManager.VERTICAL) {
            holder.vLine.setVisibility(View.GONE);
            if (i < mList.size() - 1) {
                holder.hLine.setVisibility(View.VISIBLE);
            } else {
                holder.hLine.setVisibility(View.GONE);
            }
        } else {
            holder.hLine.setVisibility(View.GONE);
            if (i < mList.size() - 1) {
                holder.vLine.setVisibility(View.VISIBLE);
            } else {
                holder.vLine.setVisibility(View.GONE);
            }
        }

    }

    private class PowerPopViewHolder extends BaseViewHolder {
        public LinearLayout layout;
        public ImageView iconIv;
        public TextView textTv;
        public View vLine;
        public View hLine;

        public PowerPopViewHolder(View itemView) {
            super(itemView);
            layout = (LinearLayout) itemView.findViewById(R.id.layout);
            iconIv = (ImageView) itemView.findViewById(R.id.iv_icon);
            textTv = (TextView) itemView.findViewById(R.id.tv_text);
            vLine = itemView.findViewById(R.id.v_line);
            hLine = itemView.findViewById(R.id.h_line);
        }
    }
}


由于菜单列表一般显示的是图标和文本，所以我这里写了个PowerPopMenuModel用于默认样式显示的使用，代码如下：

package com.hmy.powerpopmenu;

import java.io.Serializable;

/**
 * Created by HMY on 2015/12/25.
 */
public class PowerPopMenuModel implements Serializable {

    public int resid = 0;
    public String text = "";
}



PowerPopMenu：这是最核心的部分，所有的显示实现都是在这里面完成的，代码如下： 

package com.hmy.powerpopmenu;

import android.app.Activity;
import android.content.Context;
import android.graphics.Color;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.view.animation.TranslateAnimation;
import android.widget.LinearLayout;
import android.widget.LinearLayout.LayoutParams;
import android.widget.PopupWindow;

import com.hmy.adapter.BaseRecyclerViewAdapter;
import com.hmy.utils.DensityUtil;
import com.hmy.utils.ScreenUtils;

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

/**
 * Created by HMY on 2015/12/22.
 */
public class PowerPopMenu {

    private Context mContext;

    private View mParent;
    private LinearLayout mPopWindowLayout;
    private LinearLayout mContentLayout;
    private RecyclerView mRecyclerView;
    private LinearLayoutManager mLayoutManager;
    private PopupWindow mPopupWindow;

    private int mAnimationTime = 300;
    /**
     * pop从上往下弹
     */
    public static final int POP_UP_TO_DOWN = 1;
    /**
     * pop从下往上弹
     */
    public static final int POP_DOWN_TO_UP = 2;
    /**
     * pop在上方或下方
     */
    private int mUpOrDown = POP_DOWN_TO_UP;
    /**
     * RecyclerView 水平或者竖直显示
     */
    private int mOrientation = LinearLayoutManager.HORIZONTAL;

    private BaseRecyclerViewAdapter mAdapter;
    private List<PowerPopMenuModel> mList = new ArrayList<>();
    private boolean mIsShowIcon = false;

    private View mControlView = null;
    private Animation mControlViewOpenAnimation;
    private Animation mControlViewCloseAnimation;
    private boolean mIsShowControlViewAnim;

    private static final String POWER_POP_MENU_DEFAULT_BG_COLOR = "#60000000";
    /**
     * 默认风格，及使用RecyclerView
     */
    private static final int CONTENT_LAYOUT_STYLE_DEFAULT = 1;
    /**
     * 自定义view风格，及添加的view
     */
    private static final int CONTENT_LAYOUT_STYLE_ADD_VIEW = 2;
    private int mContentLayoutStyle = CONTENT_LAYOUT_STYLE_DEFAULT;

    private static final int CONTENT_LAYOUT_DEFAULT_WIDTH = 150;
    private static final int CONTENT_LAYOUT_DEFAULT_HEIGHT = 50;
    private int mContentLayoutWidth = CONTENT_LAYOUT_DEFAULT_WIDTH;
    private int mContentLayoutHeight = CONTENT_LAYOUT_DEFAULT_HEIGHT;

    private int mScreenH = 0;
    private int mScreenW = 0;
    private Animation mPopMenuCloseContentAnimation = null;
    private Animation mUpToDownAnimation = null;
    private Animation mDownToUpAnimation = null;
    private int mStyleId;
    private PopupWindow.OnDismissListener mOnDismissListener;

    public PowerPopMenu(Context context) {
        mContext = context;
        initData();
        initView();
    }

    /**
     * @param context
     * @param orientation LinearLayoutManager.HORIZONTAL 水平，LinearLayoutManager.VERTICAL
     *                    竖直
     * @param upOrDown    PowerPopMenu.POP_UP_TO_DOWN pop从上往下弹，PowerPopMenu.POP_DOWN_TO_UP pop从下往上弹
     */
    public PowerPopMenu(Context context, int orientation, int upOrDown) {
        mContext = context;
        setPopWindowPlace(orientation, upOrDown);
        initData();
        initView();
    }

    private void setPopWindowPlace(int orientation, int upOrDown) {
        if (orientation == LinearLayoutManager.HORIZONTAL || orientation == LinearLayoutManager.VERTICAL) {
            mOrientation = orientation;
        }
        if (upOrDown == POP_UP_TO_DOWN || upOrDown == POP_DOWN_TO_UP) {
            mUpOrDown = upOrDown;
        }
    }

    @SuppressWarnings("deprecation")
    private void initData() {
        mScreenW = ScreenUtils.getScreemWidth(mContext);
        mScreenH = ScreenUtils.getScreemHeight(mContext);

        initAnimation();
    }

    private void initView() {
        mPopWindowLayout = (LinearLayout) View.inflate(mContext, R.layout.view_power_pop_menu, null);
        mContentLayout = (LinearLayout) mPopWindowLayout.findViewById(R.id.layout_content);
        mParent = ((Activity) mContext).findViewById(android.R.id.content);

        initRecyclerView();
    }

    private void initRecyclerView() {
        mLayoutManager = new LinearLayoutManager(mContext);
        mLayoutManager.setOrientation(mOrientation);

        mRecyclerView = new RecyclerView(mContext);
        mRecyclerView.setHasFixedSize(true);
        mRecyclerView.setLayoutManager(mLayoutManager);
        setRecyclerViewBackgroundColor(Color.WHITE);

        setRecyclerViewLayoutParams();
    }

    private void initAnimation() {
        mStyleId = R.style.popupwindow_fade;
        initPopMenuCloseContentAnimation();

        //开启动画
        mUpToDownAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.0f, Animation
                .RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, -1, Animation.RELATIVE_TO_SELF, 0);
        mUpToDownAnimation.setDuration(mAnimationTime);
        mDownToUpAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.0f,
                Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, 1.0f, Animation.RELATIVE_TO_SELF, 0.0f);
        mDownToUpAnimation.setDuration(mAnimationTime);
    }

    private void initPopMenuCloseContentAnimation() {
        if (mUpOrDown == POP_UP_TO_DOWN) {
            mPopMenuCloseContentAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.0f, Animation
                    .RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, -1.0f);

        } else if (mUpOrDown == POP_DOWN_TO_UP) {
            mPopMenuCloseContentAnimation = new TranslateAnimation(Animation.RELATIVE_TO_SELF, 0.0f, Animation
                    .RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, 0.0f, Animation.RELATIVE_TO_SELF, 1.0f);
        }
        mPopMenuCloseContentAnimation.setDuration(mAnimationTime);
        mPopMenuCloseContentAnimation.setAnimationListener(new Animation.AnimationListener() {
            @Override
            public void onAnimationStart(Animation animation) {
            }

            @Override
            public void onAnimationEnd(Animation animation) {
                mPopupWindow.dismiss();
            }

            @Override
            public void onAnimationRepeat(Animation animation) {
            }
        });
    }

    private void setRecyclerViewLayoutParams() {
        if (mOrientation == LinearLayoutManager.HORIZONTAL) {
            mContentLayoutWidth = LayoutParams.MATCH_PARENT;
            mContentLayoutHeight = DensityUtil.dip2px(mContext, CONTENT_LAYOUT_DEFAULT_HEIGHT);
        } else if (mOrientation == LinearLayoutManager.VERTICAL) {
            mContentLayoutHeight = LayoutParams.WRAP_CONTENT;
        }
        mRecyclerView.setLayoutParams(new RecyclerView.LayoutParams(mContentLayoutWidth, mContentLayoutHeight));
    }

    private void create(int w, int h) {
        mPopupWindow = new PopupWindow(mPopWindowLayout, w, h, true);
        mPopupWindow.setFocusable(true);
        mPopWindowLayout.setFocusable(true);
        mPopWindowLayout.setFocusableInTouchMode(true);

        mPopWindowLayout.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                dismiss();
                return true;
            }
        });

        mPopWindowLayout.setOnKeyListener(new View.OnKeyListener() {
            @Override
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                if (keyCode == KeyEvent.KEYCODE_BACK) {
                    dismiss();
                    return true;
                }
                return false;
            }
        });
        mPopupWindow.setAnimationStyle(mStyleId);
        if (mOnDismissListener != null) {
            mPopupWindow.setOnDismissListener(mOnDismissListener);
        }
    }

    @SuppressWarnings("unchecked")
    private void initAdapter() {
        mAdapter = new PowerPopMenuAdapter(mContext);
        mAdapter.setList(mList);
        ((PowerPopMenuAdapter) mAdapter).setIsShowIcon(getIsShowIcon());
        ((PowerPopMenuAdapter) mAdapter).setOrientation(mOrientation);

        setAdapter(mAdapter);
    }

    public void setAnimationTime(int time) {
        mAnimationTime = time;
    }

    public int getAnimationTime() {
        return mAnimationTime;
    }

    public void setOpenAnimation(int animId) {
        if (mUpOrDown == POP_UP_TO_DOWN) {
            mUpToDownAnimation = AnimationUtils.loadAnimation(mContext, animId);
        } else if (mUpOrDown == POP_DOWN_TO_UP) {
            mDownToUpAnimation = AnimationUtils.loadAnimation(mContext, animId);
        }
    }

    public void setCloseAnimation(int animId) {
        mPopMenuCloseContentAnimation = AnimationUtils.loadAnimation(mContext, animId);
    }

    public void setUpOpenPopMenuAnimation(Animation animation) {
        mUpToDownAnimation = animation;
    }

    public void setDownOpenPopMenuAnimation(Animation animation) {
        mDownToUpAnimation = animation;
    }

    public void setPopMenuAnimationStyle(int id) {
        mStyleId = id;
    }

    public void setPopMenuCloseContentAnimation(Animation animation) {
        mPopMenuCloseContentAnimation = animation;
    }

    public void setRecyclerViewBackgroundColor(int color) {
        mRecyclerView.setBackgroundColor(color);
    }

    public void setRecyclerViewBackgroundResource(int resid) {
        mRecyclerView.setBackgroundResource(resid);
    }

    public void setPopMenuBackgroundColor(int color) {
        mContentLayout.setBackgroundColor(color);
    }

    public void setPopMenuBackgroundResource(int resid) {
        mContentLayout.setBackgroundResource(resid);
    }

    public void setPopMenuBackgroundTransparent(boolean isTransparent) {
        if (isTransparent) {
            mPopWindowLayout.setBackgroundColor(Color.TRANSPARENT);
        } else {
            mPopWindowLayout.setBackgroundColor(Color.parseColor(POWER_POP_MENU_DEFAULT_BG_COLOR));
        }
    }

    /**
     * 使用默认的PowerPopAdapter才有效
     *
     * @param l
     */
    public void setOnItemClickListener(BaseRecyclerViewAdapter.OnItemClickListener l) {
        if (mAdapter != null && mAdapter instanceof BaseRecyclerViewAdapter) {
            mAdapter.setOnItemClickListener(l);
        }
    }

    /**
     * 使用默认的PowerPopAdapter才有效
     *
     * @param l
     */
    public void setOnItemLongClickListener(BaseRecyclerViewAdapter.OnItemLongClickListener l) {
        if (mAdapter != null && mAdapter instanceof BaseRecyclerViewAdapter) {
            mAdapter.setOnItemLongClickListener(l);
        }
    }

    public void setAdapter(BaseRecyclerViewAdapter adapter) {
        mAdapter = adapter;
        mRecyclerView.setAdapter(adapter);
        mContentLayout.addView(mRecyclerView);
    }

    public void setIsShowIcon(boolean isShowIcon) {
        mIsShowIcon = isShowIcon;
    }

    public boolean getIsShowIcon() {
        return mIsShowIcon;
    }

    public void setWidth(int width) {
        if (mContentLayoutStyle == CONTENT_LAYOUT_STYLE_DEFAULT) {
            RecyclerView.LayoutParams params = (RecyclerView.LayoutParams) mRecyclerView.getLayoutParams();
            params.width = mContentLayoutWidth = width;
            mRecyclerView.setLayoutParams(params);
        }
    }

    public void setView(View view) {
        mContentLayoutStyle = CONTENT_LAYOUT_STYLE_ADD_VIEW;
        mContentLayout.removeAllViews();
        addView(view);
    }

    public void addView(View view) {
        mContentLayoutStyle = CONTENT_LAYOUT_STYLE_ADD_VIEW;
        ViewGroup parent = (ViewGroup) view.getParent();
        if (parent != null) {
            parent.removeView(view);
        }
        mContentLayout.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup
                .LayoutParams.WRAP_CONTENT));
        mContentLayout.setOrientation(LinearLayout.VERTICAL);
        mContentLayout.addView(view);
    }

    public void addView(View view, int width, int height) {
        view.setLayoutParams(new ViewGroup.LayoutParams(width, height));
        addView(view);
    }

    /**
     * @param view
     * @param params 设置view的宽高
     */
    public void addView(View view, ViewGroup.LayoutParams params) {
        view.setLayoutParams(params);
        addView(view);
    }

    /**
     * 批量添加菜单项
     */
    public void setListResource(List<PowerPopMenuModel> list) {
        if (list == null) {
            return;
        }
        mList = list;

        mContentLayoutStyle = CONTENT_LAYOUT_STYLE_DEFAULT;
        initAdapter();
    }

    /**
     * 单个添加菜单项
     */
    public void addListItemResource(PowerPopMenuModel item) {
        if (item == null) {
            return;
        }
        mList.add(item);

        mContentLayoutStyle = CONTENT_LAYOUT_STYLE_DEFAULT;
        initAdapter();
    }

    /**
     * 设置控制控件的动画
     *
     * @param view       控制控件
     * @param openAnim   打开动画
     * @param closeAnim  关闭动画
     * @param isShowAnim 是否显示动画
     */
    public void setControlViewAnim(View view, Animation openAnim, Animation closeAnim, boolean isShowAnim) {
        mControlView = view;
        mControlViewOpenAnimation = openAnim;
        mControlViewCloseAnimation = closeAnim;
        mIsShowControlViewAnim = isShowAnim;
    }

    /**
     * @param view        控制控件
     * @param openAnimId  打开动画id
     * @param closeAnimId 关闭动画id
     * @param isShowAnim  是否显示动画
     */
    public void setControlViewAnim(View view, int openAnimId, int closeAnimId, boolean isShowAnim) {
        Animation openAnim = AnimationUtils.loadAnimation(mContext, openAnimId);
        Animation closeAnim = AnimationUtils.loadAnimation(mContext, closeAnimId);
        setControlViewAnim(view, openAnim, closeAnim, isShowAnim);
    }

    /**
     * 控制控件的开启动画
     */
    private void controlViewOpenAnim() {
        if (mControlView == null || !mIsShowControlViewAnim) {
            return;
        }
        mControlView.startAnimation(mControlViewOpenAnimation);
    }

    /**
     * 控制控件的关闭动画
     */
    private void controlViewCloseAnim() {
        if (mControlView == null || !mIsShowControlViewAnim) {
            return;
        }
        mControlView.startAnimation(mControlViewCloseAnimation);
    }

    public void dismiss() {
        if (mPopupWindow == null || !mPopupWindow.isShowing()) {
            return;
        }
        controlViewCloseAnim();
        mContentLayout.startAnimation(mPopMenuCloseContentAnimation);
//        mPopWindowLayout.startAnimation(mPopMenuCloseBackgroundAnimation);
    }

    public void show() {
        mIsShowControlViewAnim = false;
        mUpOrDown = POP_DOWN_TO_UP;
        initPopMenuCloseContentAnimation();
        View parent = mParent;
        refreshContentPlace(parent);
        create(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
        controlViewOpenAnim();
        setRecyclerViewVerticalHeight(null);
        mPopupWindow.showAtLocation(parent, Gravity.NO_GRAVITY, 0, 0);
        mContentLayout.startAnimation(mDownToUpAnimation);
    }

    public void show(View parent) {
        refreshContentPlace(parent);

        if (mOrientation == LinearLayoutManager.HORIZONTAL) {
            if (mUpOrDown == POP_UP_TO_DOWN) {
                operationUpHorizonatal(parent);
            } else if (mUpOrDown == POP_DOWN_TO_UP) {
                operationDownHorizonatal(parent);
            }
        } else if (mOrientation == LinearLayoutManager.VERTICAL) {
            if (mUpOrDown == POP_UP_TO_DOWN) {
                operationUpVertical(parent);
            } else if (mUpOrDown == POP_DOWN_TO_UP) {
                operationDownVertical(parent);
            }
        }
    }

    private void refreshContentPlace(View parent) {
        if (mUpOrDown == POP_UP_TO_DOWN) {
            mPopWindowLayout.setGravity(Gravity.TOP);
        } else if (mUpOrDown == POP_DOWN_TO_UP) {
            mPopWindowLayout.setGravity(Gravity.BOTTOM);
        }
    }

    private void operationUpHorizonatal(View parent) {
        create(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
        controlViewOpenAnim();
        mPopupWindow.showAsDropDown(parent);
        mContentLayout.startAnimation(mUpToDownAnimation);
    }

    private void operationUpVertical(View parent) {
        create(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);

        controlViewOpenAnim();
        setRecyclerViewVerticalHeight(parent);

        mPopupWindow.showAsDropDown(parent, 0, 0);
        mContentLayout.startAnimation(mUpToDownAnimation);

        updateContentLayoutPlace(parent);
    }

    private void operationDownHorizonatal(View parent) {
        int[] location = new int[2];
        parent.getLocationOnScreen(location);
        int y = location[1];
        create(LayoutParams.MATCH_PARENT, y);

        controlViewOpenAnim();
        mPopupWindow.showAtLocation(parent, Gravity.NO_GRAVITY, 0, 0);
        mContentLayout.startAnimation(mDownToUpAnimation);
    }

    private void operationDownVertical(View parent) {
        int[] location = new int[2];
        parent.getLocationOnScreen(location);
        int y = location[1];
        create(LayoutParams.MATCH_PARENT, y);

        controlViewOpenAnim();
        setRecyclerViewVerticalHeight(parent);
        mPopupWindow.showAtLocation(parent, Gravity.NO_GRAVITY, 0, 0);
        mContentLayout.startAnimation(mDownToUpAnimation);

        updateContentLayoutPlace(parent);
    }


    @SuppressWarnings("deprecation")
    private void setRecyclerViewVerticalHeight(View btnView) {
        if (mAdapter == null || mOrientation == LinearLayoutManager.HORIZONTAL || mContentLayoutStyle !=
                CONTENT_LAYOUT_STYLE_DEFAULT) {
            return;
        }
        int totalHeight = 0;
        int viewCount = mAdapter.getItemCount();
        totalHeight = mAdapter.getItemViewHeight() * viewCount;
        // 可以显示的区域高度
        int canShowHeight = ScreenUtils.getScreemHeight(mContext) - ScreenUtils.getStatusBarHeight(mContext)
                - ScreenUtils.getTitleBarHeight(mContext);
        if (btnView != null) {
            canShowHeight = canShowHeight - btnView.getHeight();
        }

        if (totalHeight > canShowHeight) {
            totalHeight = canShowHeight;
        }
        ViewGroup.LayoutParams params = mRecyclerView.getLayoutParams();
        params.height = mContentLayoutHeight = totalHeight;
        mRecyclerView.setLayoutParams(params);
    }

    private void updateContentLayoutPlace(final View parent) {
        if (mOrientation != LinearLayoutManager.VERTICAL) {
            return;
        }
        mContentLayout.post(new Runnable() {
            @Override
            public void run() {
                int[] location = new int[2];
                parent.getLocationOnScreen(location);
                int x = location[0];

                LinearLayout.LayoutParams contentParams = (LayoutParams) mContentLayout.getLayoutParams();
                int contentLayoutW = mContentLayout.getMeasuredWidth();

                if (x + contentLayoutW >= mScreenW) {
                    int gravity = Gravity.RIGHT;
                    if (mUpOrDown == POP_UP_TO_DOWN) {
                        gravity = Gravity.RIGHT;
                    } else if (mUpOrDown == POP_DOWN_TO_UP) {
                        gravity = Gravity.RIGHT | Gravity.BOTTOM;
                    }
                    mPopWindowLayout.setGravity(gravity);
                } else {
                    contentParams.leftMargin = x;
                    mContentLayout.setLayoutParams(contentParams);
                }
            }
        });
    }

    public void setOnDismissListener(PopupWindow.OnDismissListener l) {
        mOnDismissListener = l;
        if (mPopupWindow != null) {
            mPopupWindow.setOnDismissListener(l);
        }
    }

}

现在介绍主要使用的方法：

setListResource(List<PowerPopMenuModel> list) 设置多个选项数据

addListItemResource(PowerPopMenuModel item) 添加一个选项数据

setIsShowIcon(boolean isShowIcon) 设置是否显示选项的图标，默认为false，要在前两个设置数据方法之前执行

setView(View view) 用于设置自定义样式的View

addView(View view)
addView(View view, int width, int height)
addView(View view, ViewGroup.LayoutParams params)

上面3个addView都是添加View


show() 用该方法只在屏幕下方弹出

show(View v) 用该方法依附于传入的 v 的位置显示



代码下载：http://download.csdn.net/detail/hmyang314/9444909

gitHub：https://github.com/HMY314/PowerPopMenu


知信行
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对话框样式的PopMenu
sunquan1982的专栏
01-12 879
android原生控件有spinnner作为弹出菜单。但是项目中需要更灵活的样式，包括可以点击按钮弹出活着点击listview等弹出下拉菜单。 通过ListPopupWindow，实现对话框样式的菜单的对话框背景样式菜单。 要实现该效果首先要将对话框背景按点9图片配置好拉伸区域和文字显示区域。 然后关键就时如何判断当前的弹出菜单是在菜单持有者的上方还时下方。通过源码分析。发现实际上，Li
android菜单键变成箭头,Android：DropPopMenu — 显示位置跟随操作按钮显示的带箭头的弹出菜单(转载,写的很好)...
weixin_36085931的博客
05-26 462
显示位置跟随操作按钮显示的带箭头的弹出菜单 一，介绍本项目是对带箭头的下拉弹出菜单进行了封装，使用简单，同时有如下特点：1、可以动态修改菜单的背景；2、弹出位置是依赖于操作按钮的位置显示，处理了按钮在边界位置引起的菜单显示错位问题；3、菜单宽度以文字的最大长度作为宽度动态计算了；4、菜单默认弹窗方向是在操作按钮下面，当操作按钮在屏幕底部时，或者菜单的高度不能完全显示时，菜单是显示在操作按钮上面的二...
android开发步步为营之64:PopupWindow实现自定义弹出菜单
飞在江湖的专栏
06-25 1488
打开PopupWindow的源码，你会发现它其实也是通过WindowManager来添加view的。 private void invokePopup(WindowManager.LayoutParams p) { if (mContext != null) { p.packageName = mContext.getPackageName();
Android：DropPopMenu — 显示位置跟随操作按钮显示的带箭头的弹出菜单(转载,写的很好)
你好邱林和的专栏
03-07 1990
 Android：DropPopMenu — 显示位置跟随操作按钮显示的带箭头的弹出菜单标签： DropPopMenu Android2017年04月28日 17:13:24 1245人阅读 评论(0) 收藏 举报 分类：Android（214）  Android_控件相关（20） 版权声明：本文为博主原创文章，未经博主允许不得转载。 http://blog.csdn.net/HMYANG314/...
Android PopupWindow实现从顶部弹出下拉菜单左、中、右
qq_31020171的博客
01-10 2810
本文转载至：https://blog.csdn.net/u013693649/article/details/49252963 感觉写的非常不错 特此记录下 本实例的自定义下拉菜单主要是继承PopupWindow类来实现的弹出窗体，各种布局效果可以根据自己定义设计。弹出的动画效果主要用到了translate、alpha、scale，具体实现步骤如下： 先上效果图如下：左边下拉菜单、中间下拉菜单、右边下拉菜单 ...
Android7.0&8.0 Power Menu 添加截屏选项
Aaron121314的博客
07-12 2938
1.在Power Menu添加新的选项 在frameworks/base/core/res/res/values/config.xml，中添加新的选项。 <!-- Defines the default set of global actions. Actions may still be disabled or hidden based on the current sta
android 自定义菜单 使用PopupWindow实现菜单的各种效果
键盘上的舞者
07-16 204
转于：http://blog.csdn.net/tangron/article/details/20907243   -------------------------------------------------------------------------------------------------    随着android手机的不断发展，可以在android手机上实现的菜...
安卓Android源码——仿微信popupwindow.zip
10-11
安卓Android源码——仿微信popupwindow.zip
安卓Android源码——Android之用PopupWindow实现弹出菜单.zip
10-09
安卓Android源码——Android之用PopupWindow实现弹出菜单.zip
Android源码——PopupWindow实现弹出菜单.zip
10-08
Android源码——PopupWindow实现弹出菜单.zip
安卓Android源码——用PopupWindow实现弹出菜单.zip
10-14
安卓Android源码——用PopupWindow实现弹出菜单.zip
android弹出自定义layout菜单,Android：PopWindow — 对Android的底部弹窗、顶部弹窗菜单及自定义界面的使用封装...
weixin_31283549的博客
05-25 1001
转载请注明出处：http：//blog..net/hmyang314/article/details/70613478PopWindow对Android的底部弹窗，顶部弹窗菜单及自定义界面的使用封装。GitHub：https：//github.com/HMY314/PopWindow一，介绍主要是用于在弹窗中显示一些有限的菜单项，也支持添加自定义View，有如下3中弹出方式：1、底部弹出，主要参...
使用PopupWindow布置复合菜单
孤云博客
12-21 1643
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) MainActivity： package com.home.testpopwindow; import java.util.ArrayList; import java.util.List; import...
PopMenu的使用
飞翔的熊blabla
09-28 639
PopupMenu menu = new PopupMenu(mContext, v); menu.inflate(R.menu.artist_overflow_menu); //menu.setOnMenuItemClickListener(popupMenuItemClickListener); mName = (String) v.getTag(R.string.artist); me
android调用菜单,Android 使用PopupWindow实现弹出更多的菜单实例详解
weixin_28724661的博客
05-26 329
最近想要做一个弹出更多的菜单，而原生的弹出菜单却不是我们想要的效果，所以必然要自定义菜单咯。本人也是借鉴网上的资料进行封装的，感觉还蛮不错的。原生的菜单如下图：自定义之后的效果图：是不是看到这里之后，对比可知，原生的效果不太理想，所以还是再自己定义吧！1、PopupWindow可以说是一个浮动在Activity之上的容器，通常用来显示自定义的视图。弹出菜单的封装PopMenuMore/*** 对弹...
android 更多 弹窗,Android 使用PopupWindow实现弹出更多的菜单实例详解
weixin_36190812的博客
05-26 577
Android 使用PopupWindow实现弹出更多的菜单实例详解发布时间：2020-09-24 21:29:22来源：脚本之家阅读：190作者：Android_SoBan最近想要做一个弹出更多的菜单，而原生的弹出菜单却不是我们想要的效果，所以必然要自定义菜单咯。本人也是借鉴网上的资料进行封装的，感觉还蛮不错的。原生的菜单如下图：自定义之后的效果图：是不是看到这里之后，对比可知，原生的效果不太理...
popupWindow 实现菜单
wx19930125的博客
11-02 565
使用popupWindow来完成菜单
Android 这样获取popupwindow
最新发布
05-13
获取 PopupWindow 的方式比较简单，具体步骤如下： 1. 首先创建一个 PopupWindow 对象，例如： ```java PopupWindow popupWindow = new PopupWindow(context); ``` 2. 接下来，你需要设置 PopupWindow 的布局和一些属性，例如： ```java popupWindow.setContentView(view); // 设置 PopupWindow 的布局 popupWindow.setWidth(width); // 设置 PopupWindow 的宽度 popupWindow.setHeight(height); // 设置 PopupWindow 的高度 popupWindow.setFocusable(true); // 设置 PopupWindow 是否可以获取焦点 popupWindow.setOutsideTouchable(true); // 设置 PopupWindow 点击外部是否可以关闭 ``` 3. 最后，你可以通过调用 `popupWindow.showAsDropDown(view, x, y)` 方法来显示 PopupWindow，其中 `view` 参数是 PopupWindow 的锚点 View，`x` 和 `y` 是 PopupWindow 在锚点 View 上的偏移量。 ```java popupWindow.showAsDropDown(anchorView, x, y); ``` 注意事项： - 如果 PopupWindow 中有 EditText 等可编辑控件，需要设置 `popupWindow.setFocusable(true)` 才能正常弹出软键盘。 - 如果 PopupWindow 没有设置宽度和高度，会默认使用 `WindowManager.LayoutParams.WRAP_CONTENT` 和 `WindowManager.LayoutParams.WRAP_CONTENT`，即自适应内容大小。 - 如果 PopupWindow 不想点击外部关闭，可以设置 `popupWindow.setOutsideTouchable(false)`。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值