zoukankan      html  css  js  c++  java

  • PopUpWindow使用方法

    个人使用建议,容易犯错:先设置属性再显示,而不是先出来了,再设置都没用了,显示一般是用showatlocation,或者showasdropdown

    个人建议2:popupWindow的显示的两个方法的位置一般是再某个组件的左下部或者用bottom属性,都是比较绝对的位置

    如果想显示再某个组件的上部,可以使用showAtLocation(anctor,gravity,0,a.getHight());其中a为该组件的名称

    转载:http://blog.csdn.net/harvic880925/article/details/49272285 


    先看一下我们要做的效果：

    这个效果很容易理解：当点击btn时，在底部弹出PopupWindow,然后点击各个item弹出对应toast。

    一、概述

    1、PopupWindow与AlertDialog的区别

    最关键的区别是AlertDialog不能指定显示位置，只能默认显示在屏幕最中间（当然也可以通过设置WindowManager参数来改变位置）。而PopupWindow是可以指定显示位置的，随便哪个位置都可以，更加灵活。
    有关Dialog的相关知识，大家可以参考我的系列博客：《详解Dialog（一）——基础元素构建》

    2、PopupWindow的相关函数

    （1）、构造函数：

    [java] view plain copy
    1. //方法一：  
    2. public PopupWindow (Context context)  
    3. //方法二：  
    4. public PopupWindow(View contentView)  
    5. //方法三：  
    6. public PopupWindow(View contentView, int width, int height)  
    7. //方法四：  
    8. public PopupWindow(View contentView, int width, int height, boolean focusable)  

    首要注意：看这里有四个构造函数，但要生成一个PopupWindow最基本的三个条件是一定要设置的：View contentView，int width, int height ；少任意一个就不可能弹出来PopupWindow！！！！
    所以，如果使用方法一来构造PopupWindow，那完整的构造代码应该是这样的：

    [java] view plain copy
    1. View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    2. PopupWindwo popWnd = PopupWindow (context);  
    3. popWnd.setContentView(contentView);  
    4. popWnd.setWidth(ViewGroup.LayoutParams.WRAP_CONTENT);  
    5. popWnd.setHeight(ViewGroup.LayoutParams.WRAP_CONTENT);  

    有关为什么一定要设置width和height的原因，我们后面会讲，这里说一下为什么样强制设置contentView；很简单的原因是因为PopupWindow没有默认布局，它不会像AlertDialog那样只setTitle,就能弹出来一个框。PopupWindow是没有默认布局的，它的布局只有通过我们自己设置才行。由于方法三中，含有了这三个必备条件，不用单独设置contentview或者width、height，所以构造方法三是用的最多的一个构造方法。
    最后，方法四中的focusable变量不是必须的，有关它的方法和意义，我们会在下一篇中细讲。

    （2）显示函数

    显示函数主要使用下面三个：

    [java] view plain copy
    1. //相对某个控件的位置（正左下方），无偏移  
    2. showAsDropDown(View anchor)：  
    3. //相对某个控件的位置，有偏移;xoff表示x轴的偏移，正值表示向左，负值表示向右；yoff表示相对y轴的偏移，正值是向下，负值是向上；  
    4. showAsDropDown(View anchor, int xoff, int yoff)：  
    5. //相对于父控件的位置（例如正中央Gravity.CENTER，下方Gravity.BOTTOM等），可以设置偏移或无偏移  
    6. showAtLocation(View parent, int gravity, int x, int y)：  

    这里有两种显示方式：
    1、显示在某个指定控件的下方
    showAsDropDown(View anchor)：
    showAsDropDown(View anchor, int xoff, int yoff)；
    2、指定父视图，显示在父控件的某个位置（Gravity.TOP,Gravity.RIGHT等）
    showAtLocation(View parent, int gravity, int x, int y)；

    （3）、其它函数

    [java] view plain copy
    1. public void dismiss()  
    2. //另外几个函数，这里不讲其意义，下篇细讲  
    3. public void setFocusable(boolean focusable)  
    4. public void setTouchable(boolean touchable)  
    5. public void setOutsideTouchable(boolean touchable)  
    6. public void setBackgroundDrawable(Drawable background)  

    这几个函数里，这篇只会用到dismiss()，用于不需要的时候，将窗体隐藏掉。

    好了，废话不多说了，我们就做一个上面的例子来看一下。

    二、简单示例（showAtLocation显示窗体）

    在这个例子中，我们实现两个功能，弹出popupWindow和Item点击响应

    1、主布局(main.xml)

    从效果图中也可以看到主布局只有一个button，什么都没有，所以它的布局代码哪下：

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.               android:orientation="vertical"  
    4.               android:layout_width="fill_parent"  
    5.               android:layout_height="fill_parent">  
    6.     <Button  
    7.             android:id="@+id/btn"  
    8.             android:layout_width="fill_parent"  
    9.             android:layout_height="wrap_content"  
    10.             android:text="show popWindow"/>  
    11. </LinearLayout>  

    2、PopupWindow布局（popuplayout.xml）


    在概述中，我们提到了，必须为PopupWindow设置布局，从效果图中，我也可以看到它的布局有三个item，中间用横线分开。所以这里布局使用Listview应该更合适，但为了减轻代码难度，我们直接使用TextView和分隔线来代替,代码如下：

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2.   
    3. <LinearLayout  
    4.         xmlns:android="http://schemas.android.com/apk/res/android"  
    5.         android:layout_width="fill_parent"  
    6.         android:layout_height="wrap_content"  
    7.         android:background="#ffffff"  
    8.         android:orientation="vertical"  
    9.         android:paddingBottom="2dp">  
    10.     <View  
    11.             android:layout_width="match_parent"  
    12.             android:layout_height="2.25dp"  
    13.             android:background="#fa7829"  
    14.             android:layout_alignParentTop="true"/>  
    15.   
    16.     <TextView  
    17.             android:id="@+id/pop_computer"  
    18.             android:layout_width="match_parent"  
    19.             android:layout_height="wrap_content"  
    20.             style="@style/pop_text_style"  
    21.             android:text="计算机"/>  
    22.   
    23.     <View  
    24.             android:layout_width="match_parent"  
    25.             android:layout_height="1dp"  
    26.             android:background="@drawable/list_line"/>  
    27.   
    28.     <TextView  
    29.             android:id="@+id/pop_financial"  
    30.             android:layout_width="match_parent"  
    31.             android:layout_height="wrap_content"  
    32.             style="@style/pop_text_style"  
    33.             android:text="金融"/>  
    34.   
    35.     <View  
    36.             android:layout_width="match_parent"  
    37.             android:layout_height="1dp"  
    38.             android:background="@drawable/list_line"/>  
    39.   
    40.     <TextView  
    41.             android:id="@+id/pop_manage"  
    42.             android:layout_width="match_parent"  
    43.             android:layout_height="wrap_content"  
    44.             style="@style/pop_text_style"  
    45.             android:text="管理"/>  
    46.   
    47.     <View  
    48.             android:layout_width="match_parent"  
    49.             android:layout_height="1dp"/>  
    50.   
    51. </LinearLayout>  

    3、MainActivity代码

    先贴出来完整代码，然后再逐步讲解：

    [java] view plain copy
    1. public class MainActivity extends Activity implements View.OnClickListener{  
    2.   
    3.     private PopupWindow mPopWindow;  
    4.   
    5.     @Override  
    6.     public void onCreate(Bundle savedInstanceState) {  
    7.         super.onCreate(savedInstanceState);  
    8.         setContentView(R.layout.main);  
    9.   
    10.         Button btn = (Button) findViewById(R.id.btn);  
    11.         btn.setOnClickListener(new View.OnClickListener() {  
    12.             @Override  
    13.             public void onClick(View v) {  
    14.                 showPopupWindow();  
    15.             }  
    16.         });  
    17.     }  
    18.   
    19.     private void showPopupWindow() {  
    20.         //设置contentView  
    21.         View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    22.         mPopWindow = new PopupWindow(contentView,  
    23.                 LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, true);  
    24.         mPopWindow.setContentView(contentView);  
    25.         //设置各个控件的点击响应  
    26.         TextView tv1 = (TextView)contentView.findViewById(R.id.pop_computer);  
    27.         TextView tv2 = (TextView)contentView.findViewById(R.id.pop_financial);  
    28.         TextView tv3 = (TextView)contentView.findViewById(R.id.pop_manage);  
    29.         tv1.setOnClickListener(this);  
    30.         tv2.setOnClickListener(this);  
    31.         tv3.setOnClickListener(this);  
    32.         //显示PopupWindow  
    33.         View rootview = LayoutInflater.from(MainActivity.this).inflate(R.layout.main, null);  
    34.         mPopWindow.showAtLocation(rootview, Gravity.BOTTOM, 0, 0);  
    35.   
    36.     }  
    37.   
    38.     @Override  
    39.     public void onClick(View v) {  
    40.         int id = v.getId();  
    41.         switch (id){  
    42.             case R.id.pop_computer:{  
    43.                 Toast.makeText(this,"clicked computer",Toast.LENGTH_SHORT).show();  
    44.                 mPopWindow.dismiss();  
    45.             }  
    46.             break;  
    47.             case R.id.pop_financial:{  
    48.                 Toast.makeText(this,"clicked financial",Toast.LENGTH_SHORT).show();  
    49.                 mPopWindow.dismiss();  
    50.             }  
    51.             break;  
    52.             case R.id.pop_manage:{  
    53.                 Toast.makeText(this,"clicked manage",Toast.LENGTH_SHORT).show();  
    54.                 mPopWindow.dismiss();  
    55.             }  
    56.             break;  
    57.         }  
    58.     }  
    59. }  

    (1)首先看OnCreate()

    在OnCreate()中只做了一个操作，当点击Button时，显示窗体：

    [java] view plain copy
    1. public void onCreate(Bundle savedInstanceState) {  
    2.     super.onCreate(savedInstanceState);  
    3.     setContentView(R.layout.main);  
    4.   
    5.     Button btn = (Button) findViewById(R.id.btn);  
    6.     btn.setOnClickListener(new View.OnClickListener() {  
    7.         @Override  
    8.         public void onClick(View v) {  
    9.             showPopupWindow();  
    10.         }  
    11.     });  
    12. }  

    (2)、显示PopupWindow

    下面是有关窗体操作的代码：

    [java] view plain copy
    1. private void showPopupWindow() {  
    2.      //设置contentView  
    3.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    4.     mPopWindow = new PopupWindow(contentView,  
    5.             LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, true);  
    6.  //设置各个控件的点击响应  
    7.     TextView tv1 = (TextView)contentView.findViewById(R.id.pop_computer);  
    8.     TextView tv2 = (TextView)contentView.findViewById(R.id.pop_financial);  
    9.     TextView tv3 = (TextView)contentView.findViewById(R.id.pop_manage);  
    10.     tv1.setOnClickListener(this);  
    11.     tv2.setOnClickListener(this);  
    12.     tv3.setOnClickListener(this);  
    13.     //显示PopupWindow  
    14.     View rootview = LayoutInflater.from(MainActivity.this).inflate(R.layout.main, null);  
    15.     mPopWindow.showAtLocation(rootview, Gravity.BOTTOM, 0, 0);  
    16.   
    17. }  

    这里同样分为三部分：
    第一部分：设置ContentView

    [java] view plain copy
    1. View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    2. mPopWindow = new PopupWindow(contentView,LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT, true);  

    利用LayoutInflater获取R.layout.popuplayout对应的View,然后利用我们上面所讲的构造函数三来生成mPopWindow；
    这里 要注意一个问题：在这个构造函数里，我们传进去了width和height全部都是WRAP_CONTENT；而在R.layout.popuplayou的根布局中，我们定义的width和height代码是：layout_width="fill_parent",layout_height="wrap_content";原代码如下：

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2.   
    3. <LinearLayout  
    4.         xmlns:android="http://schemas.android.com/apk/res/android"  
    5.         android:layout_width="fill_parent"  
    6.         android:layout_height="wrap_content"  
    7.         android:background="#ffffff"  
    8.         android:orientation="vertical"  
    9.         android:paddingBottom="2dp">  
    10.           
    11.         ………………  
    12. </LinearLayout>          

    这里就有冲突了，那显示出来的popupWindow是按哪个来的呢？
    从效果图中来看，明显PopupWindow宽度并没有全屏，显然是按代码中的布局为准。
    这说明了：
    **如果在代码中重新设置了popupWindow的宽和高，那就以代码中所设置为准。**（至于原因，下篇会讲）

    第二部分：设置各个控件的点击响应

    [java] view plain copy
    1. TextView tv1 = (TextView)contentView.findViewById(R.id.pop_computer);  
    2. TextView tv2 = (TextView)contentView.findViewById(R.id.pop_financial);  
    3. TextView tv3 = (TextView)contentView.findViewById(R.id.pop_manage);  
    4. tv1.setOnClickListener(this);  
    5. tv2.setOnClickListener(this);  
    6. tv3.setOnClickListener(this);  

    这部分没什么好讲了，设置PopupWindow中各个控件的点击响应，但一定要注意的是，PopupWindow中各个控件的所在的布局是contentView，而不是在Activity中，如果大家直接使用

    [java] view plain copy
    1. TextView tv1 = (TextView)findViewById(R.id.pop_computer);  

    肯定会报错，因为R.id.pop_computer这个ID值在当前Activtiy的布局文件中是找不到的。只有在R.layout.popuplayout的布局文件中才会有！所以，这就是为什么，要在findViewById(R.id.pop_computer)前指定contentView的原因！！！在实际项目中，很容易遇到像这种需要指定根布局的情况，大家需要注意。
    有关响应，就没什么好讲的了，因为我们在类顶部派生了View.OnClickListener，所以在OnClick函数中，直接处理即可，代码如下：(在点击不同的Item时，一边弹出不同的toast，一边将PopupWindow隐藏掉)

    [java] view plain copy
    1. @Override  
    2. public void onClick(View v) {  
    3.     int id = v.getId();  
    4.     switch (id){  
    5.         case R.id.pop_computer:{  
    6.             Toast.makeText(this,"clicked computer",Toast.LENGTH_SHORT).show();  
    7.             mPopWindow.dismiss();  
    8.         }  
    9.         break;  
    10.         case R.id.pop_financial:{  
    11.             Toast.makeText(this,"clicked financial",Toast.LENGTH_SHORT).show();  
    12.             mPopWindow.dismiss();  
    13.         }  
    14.         break;  
    15.         case R.id.pop_manage:{  
    16.             Toast.makeText(this,"clicked manage",Toast.LENGTH_SHORT).show();  
    17.             mPopWindow.dismiss();  
    18.         }  
    19.         break;  
    20.     }  
    21. }  

    第三部分：showAtLocation显示窗体

    [java] view plain copy
    1. View rootview = LayoutInflater.from(MainActivity.this).inflate(R.layout.main, null);  
    2. mPopWindow.showAtLocation(rootview, Gravity.BOTTOM, 0, 0);  

    showAtLocation的显示就将PopupWindow的实例放在一个父容器中，然后指定显示在父容器中的位置。
    由于，我们要将mPopWindow放在整个屏幕的最低部，所以我们将R.layout.main做为它的父容器。将其显示在BOTTOM的位置。

    到这里，有关PopupWindow的显示及其中控件响应基本都讲完了，下面，我们就讲讲showAsDropDown显示窗体的用法。

    源码在文章底部给出

    三、另一示例（showAsDropDown显示窗体）

    大家先看下面这个效果图：

    这个效果图演示的是，在点击标题栏右方的“菜单”按钮时，在其下方显示一个自定义的菜单列表。

    1、同样，我们先看看主布局代码（main.xml）

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.               android:orientation="vertical"  
    4.               android:layout_width="fill_parent"  
    5.               android:layout_height="fill_parent">  
    6.   
    7.     <RelativeLayout android:layout_width="fill_parent"  
    8.                     android:layout_height="wrap_content"  
    9.                     android:background="#ffffff">  
    10.   
    11.         <TextView android:layout_width="wrap_content"  
    12.                   android:layout_height="wrap_content"  
    13.                   android:layout_alignParentLeft="true"  
    14.                   android:textColor="#50484b"  
    15.                   android:padding="10dp"  
    16.                   android:text="返回"/>  
    17.   
    18.         <TextView  
    19.                 android:id="@+id/menu"  
    20.                 android:layout_width="wrap_content"  
    21.                 android:layout_height="wrap_content"  
    22.                 android:layout_alignParentRight="true"  
    23.                 android:textColor="#50484b"  
    24.                 android:padding="10dp"  
    25.                 android:text="菜单"/>  
    26.   
    27.     </RelativeLayout>  
    28. </LinearLayout>  

    这段代码的布局很简单，就是生成一个标题栏，上面有两个按钮，“返回”和“菜单”

    2、PopupWindow布局代码（popuplayout.xml）

    这部分布局也不难，只得利用纯代码硬生成一个列表的布局。在实际项目中，大家应该使用listview来动态生成列表，这样生成的popupWindow就是可以复用的了。有关布局就不再多讲，跟上面的布局基本一样，只是换了背景。

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout  
    3.         xmlns:android="http://schemas.android.com/apk/res/android"  
    4.         android:layout_width="fill_parent"  
    5.         android:layout_height="wrap_content"  
    6.         android:background="@drawable/pop_bg"  
    7.         android:orientation="vertical"  
    8.         android:paddingBottom="2dp">  
    9.   
    10.     <TextView  
    11.             android:id="@+id/pop_computer"  
    12.             android:layout_width="wrap_content"  
    13.             android:layout_height="wrap_content"  
    14.             style="@style/pop_text_style"  
    15.             android:text="计算机"/>  
    16.   
    17.     <View  
    18.             android:layout_width="match_parent"  
    19.             android:layout_height="1dp"  
    20.             android:background="@drawable/list_line"/>  
    21.   
    22.     <TextView  
    23.             android:id="@+id/pop_financial"  
    24.             android:layout_width="wrap_content"  
    25.             android:layout_height="wrap_content"  
    26.             style="@style/pop_text_style"  
    27.             android:text="金融"/>  
    28.   
    29.     <View  
    30.             android:layout_width="match_parent"  
    31.             android:layout_height="1dp"  
    32.             android:background="@drawable/list_line"/>  
    33.   
    34.     <TextView  
    35.             android:id="@+id/pop_manage"  
    36.             android:layout_width="wrap_content"  
    37.             android:layout_height="wrap_content"  
    38.             style="@style/pop_text_style"  
    39.             android:text="管理"/>  
    40.   
    41.     <View  
    42.             android:layout_width="match_parent"  
    43.             android:layout_height="1dp"/>  
    44.   
    45. </LinearLayout>  

    3、MainActivity代码

    同样是先贴出来完整代码，然后再细讲。

    [html] view plain copy
    1. public class MainActivity extends Activity implements View.OnClickListener{  
    2.     private PopupWindow mPopWindow;  
    3.     private TextView mMenuTv;  
    4.     @Override  
    5.     public void onCreate(Bundle savedInstanceState) {  
    6.         super.onCreate(savedInstanceState);  
    7.         setContentView(R.layout.main);  
    8.         mMenuTv = (TextView)findViewById(R.id.menu);  
    9.         mMenuTv.setOnClickListener(new View.OnClickListener() {  
    10.             @Override  
    11.             public void onClick(View v) {  
    12.                 showPopupWindow();  
    13.             }  
    14.         });  
    15.     }  
    16.     private void showPopupWindow() {  
    17.         View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    18.         mPopWindow = new PopupWindow(contentView);  
    19.         mPopWindow.setWidth(ViewGroup.LayoutParams.WRAP_CONTENT);  
    20.         mPopWindow.setHeight(ViewGroup.LayoutParams.WRAP_CONTENT);  
    21.   
    22.         TextView tv1 = (TextView)contentView.findViewById(R.id.pop_computer);  
    23.         TextView tv2 = (TextView)contentView.findViewById(R.id.pop_financial);  
    24.         TextView tv3 = (TextView)contentView.findViewById(R.id.pop_manage);  
    25.         tv1.setOnClickListener(this);  
    26.         tv2.setOnClickListener(this);  
    27.         tv3.setOnClickListener(this);  
    28.   
    29.         mPopWindow.showAsDropDown(mMenuTv);  
    30.     }  
    31.   
    32.     @Override  
    33.     public void onClick(View v) {  
    34.         int id = v.getId();  
    35.         switch (id){  
    36.             case R.id.pop_computer:{  
    37.                 Toast.makeText(this, "clicked computer", Toast.LENGTH_SHORT).show();  
    38.                 mPopWindow.dismiss();  
    39.             }  
    40.             break;  
    41.             case R.id.pop_financial:{  
    42.                 Toast.makeText(this,"clicked financial",Toast.LENGTH_SHORT).show();  
    43.                 mPopWindow.dismiss();  
    44.             }  
    45.             break;  
    46.             case R.id.pop_manage:{  
    47.                 Toast.makeText(this,"clicked manage",Toast.LENGTH_SHORT).show();  
    48.                 mPopWindow.dismiss();  
    49.             }  
    50.             break;  
    51.         }  
    52.     }  
    53. }  

    这段代码的意义就是点击menu弹出popupwindow,然后对各个item进行响应，我们主要讲讲showPopupWindow() 这部分，对于item响应的部分与上个示例都一样，就不再细讲。

    [html] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.WRAP_CONTENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.WRAP_CONTENT);  
    6.   
    7.     TextView tv1 = (TextView)contentView.findViewById(R.id.pop_computer);  
    8.     TextView tv2 = (TextView)contentView.findViewById(R.id.pop_financial);  
    9.     TextView tv3 = (TextView)contentView.findViewById(R.id.pop_manage);  
    10.     tv1.setOnClickListener(this);  
    11.     tv2.setOnClickListener(this);  
    12.     tv3.setOnClickListener(this);  
    13.   
    14.     mPopWindow.showAsDropDown(mMenuTv);  
    15. }  

    这里首先注意的一个地方，在这个示例中，我们是使用的构造方法二来生成的PopupWindow实例的,同样，再强调一遍：contentView，Width，Height这三个元素是必须设置的，缺一不可！至于为什么要显式设置Width，Height，我们下篇会讲到。

    [java] view plain copy
    1. View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    2. mPopWindow = new PopupWindow(contentView);  
    3. mPopWindow.setWidth(ViewGroup.LayoutParams.WRAP_CONTENT);  
    4. mPopWindow.setHeight(ViewGroup.LayoutParams.WRAP_CONTENT);  

    然后就是使用showAsDropDown（）显示PopupWindow：

    [java] view plain copy
    1. mPopWindow.showAsDropDown(mMenuTv);  

    大家也现样可以使用showAsDropDown(View anchor, int xoff, int yoff)：来添加相对x轴和y轴的位移量。具体用法就不再细讲，没什么难度，大家试一试即可。
    好了，这部分示例也讲完了，下面我们就在这个示例上升级一个功能：讲讲怎么在弹出PopupWindow的同时利用阴影把背景全部给遮罩起来。

    源码在文章底部给出

    四、提高：为菜单添加阴影

    这部分的效果图是下面这样的：

    从效果图中可以看出，这部分是上一个示例的升级版，就是在点出PopupWindow的同时，把背景用半透明黑色遮罩住，像弹出AlertDialog一样的效果。下面就来看看这个效果是怎么实现的吧。

    1、PopupWindow布局（popuplayout.xml）

    其实原理很简单，使PopupWindow的界面充满全屏，而实际的列表菜单只是其中的一个子布局即可，所以此时的PopupWindow的布局代码如下：

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <RelativeLayout  
    3.         xmlns:android="http://schemas.android.com/apk/res/android"  
    4.         android:layout_width="fill_parent"  
    5.         android:layout_height="fill_parent"  
    6.         android:background="#66000000">  
    7.     <LinearLayout  
    8.             android:layout_width="wrap_content"  
    9.             android:layout_height="wrap_content"  
    10.             android:background="@drawable/pop_bg"  
    11.             android:orientation="vertical"  
    12.             android:paddingBottom="2dp"  
    13.             android:layout_alignParentRight="true">  
    14.   
    15.         <TextView  
    16.                 android:id="@+id/pop_computer"  
    17.                 android:layout_width="wrap_content"  
    18.                 android:layout_height="wrap_content"  
    19.                 style="@style/pop_text_style"  
    20.                 android:text="计算机"/>  
    21.   
    22.         <View  
    23.                 android:layout_width="match_parent"  
    24.                 android:layout_height="1dp"  
    25.                 android:background="@drawable/list_line"/>  
    26.   
    27.         <TextView  
    28.                 android:id="@+id/pop_financial"  
    29.                 android:layout_width="wrap_content"  
    30.                 android:layout_height="wrap_content"  
    31.                 style="@style/pop_text_style"  
    32.                 android:text="金融"/>  
    33.   
    34.         <View  
    35.                 android:layout_width="match_parent"  
    36.                 android:layout_height="1dp"  
    37.                 android:background="@drawable/list_line"/>  
    38.   
    39.         <TextView  
    40.                 android:id="@+id/pop_manage"  
    41.                 android:layout_width="wrap_content"  
    42.                 android:layout_height="wrap_content"  
    43.                 style="@style/pop_text_style"  
    44.                 android:text="管理"/>  
    45.   
    46.         <View  
    47.                 android:layout_width="match_parent"  
    48.                 android:layout_height="1dp"/>  
    49.   
    50.     </LinearLayout>  
    51. </RelativeLayout>  

    可见在列表项外面又包了一层RelativeLayout，将列表的根布局LinearLayout靠父窗口右边显示即可。给RelativeLayout添加了半透明背景android:background="#66000000"
    这样要非常注意的是，根布局RelativeLayout设置的android:layout_width和android:layout_height是无意义的，因为我们会通过代码重新设置：

    [html] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.     
    7.     ………………//设置各控件点击响应  
    8.   
    9.     mPopWindow.showAsDropDown(mMenuTv);  
    10.   
    11. }  

    在这里，我们通过代码将PopupWindow的width和height设置为LayoutParams.FILL_PARENT。那大家可能会有疑问：为什么我在xml中布局中明明写好了根布局RelativeLayout的宽和高，为什么非要我们在代码中重新设置呢？不设置还显示不出来…………
    下篇，我们将会解答这个问题。
    好啦，这个示例关键部分讲完了，其它的大家就看源码吧。

    源码在文章底部给出

    五、为PopupWindow添加动画

    先看看效果：

    为PopupWindow添加动画并不难，只需要使用一个函数即可：

    [java] view plain copy
    1. //设置动画所对应的style  
    2. mPopWindow.setAnimationStyle(R.style.contextMenuAnim);  

    下面就来看看具体是如何添加动画的

    1、生成动画对应的style

    （1）、进入时的动画：(context_menu_enter.xml)

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <set xmlns:android="http://schemas.android.com/apk/res/android">  
    3.   
    4.     <translate  
    5.         android:duration="@android:integer/config_shortAnimTime"  
    6.         android:fromXDelta="0"  
    7.         android:fromYDelta="100%p"  
    8.         android:interpolator="@android:anim/accelerate_decelerate_interpolator"  
    9.         android:toXDelta="0"  
    10.         android:toYDelta="0"/>  
    11.   
    12. </set>  

    这段代码的意义就是从底部进入，即从Y轴100%的位置移动到0的位置。有关动画的知识，大家可以参考《Animation 动画详解（一）——alpha、scale、translate、rotate、set的xml属性及用法》      这个系列文章。

    （2）、退出时动画(context_menu_exit.xml)

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <set xmlns:android="http://schemas.android.com/apk/res/android" >  
    3.   
    4.     <translate  
    5.         android:duration="@android:integer/config_shortAnimTime"  
    6.         android:fromXDelta="0"  
    7.         android:fromYDelta="0"  
    8.         android:interpolator="@android:anim/accelerate_decelerate_interpolator"  
    9.         android:toXDelta="0"  
    10.         android:toYDelta="100%p" />  
    11.   
    12. </set>  

    效果是从上向下移动。

    （3）、最后，生成对应的style---contextMenuAnim

    [html] view plain copy
    1. <style name="contextMenuAnim" parent="@android:style/Animation.Activity">  
    2.     <item name="android:windowEnterAnimation">@anim/context_menu_enter</item>  
    3.     <item name="android:windowExitAnimation">@anim/context_menu_exit</item>  
    4. </style>  

    android:windowEnterAnimation设置进场动画，android:windowExitAnimation设置出场动画。

    2、使用AnimationStyle

    使用时非常简单，直接将对应的style通过setAnimationStyle设置进PopupWindow实例即可，代码如下，难度不大，不再细讲。

    [html] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.       
    7.     ………………//设置各子项点击响应  
    8.     mPopWindow.setAnimationStyle(R.style.contextMenuAnim);  
    9.   
    10.     mPopWindow.showAsDropDown(mMenuTv);  
    11. }  

    到这里，这个示例的代码就讲完了。源码在文章底部一起给出。这篇讲述了有关PopupWindow的基本使用方法，下篇将针对还未讲述的几个函数，以及问题点结合源码深入剖析。

    源码内容：

    1、《PopshowAtLocation》：第二部分：简单示例（showAtLocation显示窗体）对应源码

    2、《PopupShowAsDropDown》：第三部分：另一示例（showAsDropDown显示窗体） 对应源码

    3、《PopDropDownBg》：第四部分：提高：为菜单添加阴影  对应源码

    4、《PopupAnim》：第五部分：为PopupWindow添加动画  对应源码

    如果本文有帮到你，记得加关注哦

    源码下载地址：http://download.csdn.net/detail/harvic880925/9195255

    请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/49272285   谢谢

    另外:

    关于弹出的组件还有一个PopupMenu和PopupWindow

    PopupMenu显示效果类似上下文菜单(Menu)，而PopupWindow的显示效果实际上类似对话框(Dialog)，两者效果如下图所示：

    PopupMenu显示效果

    PopupWindow显示效果

    上篇为大家基本讲述了有关PopupWindow的基本使用，但还有几个相关函数还没有讲述，我们这篇将着重看看这几个函数的用法并结合源码来讲讲具体原因，最后是有关PopupWindow在使用时的疑问，给大家讲解一下。

    一、常用函数讲解

    这段将会给大家讲下下面几个函数的意义及用法，使用上篇那个带背景的例子为基础。

    [java] view plain copy
    1. public void setTouchable(boolean touchable)  
    2. public void setFocusable(boolean focusable)  
    3. public void setOutsideTouchable(boolean touchable)  
    4. public void setBackgroundDrawable(Drawable background)  

    1、setTouchable(boolean touchable)

    设置PopupWindow是否响应touch事件，默认是true，如果设置为false，即会是下面这个结果：(所有touch事件无响应，包括点击事件)

    对应代码：

    [java] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.   
    7.     mPopWindow.setTouchable(false);  
    8.   
    9.     ………………//单项点击  
    10.   
    11.     mPopWindow.showAsDropDown(mMenuTv);  
    12. }  

    2、setFocusable(boolean focusable)

    该函数的意义表示，PopupWindow是否具有获取焦点的能力，默认为False。一般来讲是没有用的，因为普通的控件是不需要获取焦点的，而对于EditText则不同，如果不能获取焦点，那么EditText将是无法编辑的。
    所以，我们在popuplayout.xml最底部添加一个EditText，分别演示两段不同的代码，即分别将setFocusable设置为false和设置为true；看看有什么不同：
    （1）setFocusable(true)
    代码如下：

    [html] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.   
    7.     //是否具有获取焦点的能力  
    8.     mPopWindow.setFocusable(true);  
    9.   
    10.    …………//各item点击响应  
    11.   
    12.   
    13.     mPopWindow.showAsDropDown(mMenuTv);  
    14. }  

    明显在点击EditText的时候，会弹出编辑框。

    （2）setFocusable(false)
    同样上面一段代码，那我们将setFocusable设置为false，会是怎样呢？

    [java] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.   
    7.     //是否具有获取焦点的能力  
    8.     mPopWindow.setFocusable(false);  
    9.   
    10.    …………//各item点击响应  
    11.   
    12.   
    13.     mPopWindow.showAsDropDown(mMenuTv);  
    14. }  

    效果图下：
    可见，点击EditText没有出现任何反应！所以如果PopupWindow没有获取焦点的能力，那么它其中的EditText当然是没办法获取焦点的，EditText无法获取焦点，那对它而言整个EditText控件就是不可用的。

    3、setOutsideTouchable(boolean touchable)

    这个函数的意义，就是指，PopupWindow以外的区域是否可点击，即如果点击PopupWindow以外的区域，PopupWindow是否会消失。
    下面这个是点击会消息的效果图：

    看看它对应的代码：

    [java] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.   
    7.     //外部是否可以点击  
    8.     mPopWindow.setBackgroundDrawable(new BitmapDrawable());  
    9.     mPopWindow.setOutsideTouchable(true);  
    10.   
    11.     …………//各ITEM点击响应  
    12.   
    13.     mPopWindow.showAsDropDown(mMenuTv);  
    14.   
    15. }  

    这里要非常注意的一点：

    [java] view plain copy
    1. mPopWindow.setBackgroundDrawable(new BitmapDrawable());  
    2. mPopWindow.setOutsideTouchable(true);  

    大家可能要疑问，为什么要加上mPopWindow.setBackgroundDrawable(new BitmapDrawable());这句呢，从代码来看没并没有真正设置Bitmap，而只是new了一个空的bitmap，好像并没起到什么作用。那如果我们把这句去掉会怎样：
    把代码改成这样子：（只使用setOutsideTouchable）

    [java] view plain copy
    1. private void showPopupWindow() {  
    2.     View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    3.     mPopWindow = new PopupWindow(contentView);  
    4.     mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    5.     mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  
    6.   
    7.     //外部是否可以点击  
    8.     mPopWindow.setOutsideTouchable(true);  
    9.   
    10.     …………//各ITEM点击响应  
    11.   
    12.     mPopWindow.showAsDropDown(mMenuTv);  
    13. }  


    看到了没，点击外部没反应………………这就有点坑了，至于原因，我们在setBackgroundDrawable（）中讲。

    4、setBackgroundDrawable(Drawable background)

    这个函数可是吊了，这个函数不只能设置背景……，因为你加上它之后，setOutsideTouchable（）才会生效;

    而且，只有加上它之后，PopupWindow才会对手机的返回按钮有响应：即，点击手机返回按钮，可以关闭PopupWindow；如果不加setBackgroundDrawable（）将关闭的PopupWindow所在的Activity.
    这个函数要怎么用，这里应该就不用讲了吧，可以填充进去各种Drawable,比如new BitmapDrawable()，new ColorDrawable(),等；
    我们这里主要从源码的角度来看看setBackgroundDrawable（）后，PopupWindow都做了些什么。
    首先看看setBackgroundDrawable（），将传进去的background赋值给mBackground；

    [java] view plain copy
    1. void setBackgroundDrawable(Drawable background) {  
    2.     mBackground = background;  
    3. }  

    然后再看看显示showAsDropDown（）显示的时候，都做了些什么。代码如下：

    [java] view plain copy
    1. public void showAsDropDown(View anchor, int xoff, int yoff) {  
    2.     …………  
    3.     //准备窗口  
    4.     WindowManager.LayoutParams p = createPopupLayout(anchor.getWindowToken());  
    5.     preparePopup(p);  
    6.   
    7.     …………  
    8.     //显示窗口  
    9.     invokePopup(p);  
    10. }  

    在这段代码中，先是准备窗口用来显示，然后再利用invokePopup（）来显示窗体。
    我们看看在preparePopup（p）中是怎么准备窗体的：

    [html] view plain copy
    1. private void preparePopup(WindowManager.LayoutParams p) {  
    2.     if (mBackground != null) {  
    3.         final ViewGroup.LayoutParams layoutParams = mContentView.getLayoutParams();  
    4.         int height = ViewGroup.LayoutParams.MATCH_PARENT;  
    5.         if (layoutParams != null &&  
    6.                 layoutParams.height == ViewGroup.LayoutParams.WRAP_CONTENT) {  
    7.             height = ViewGroup.LayoutParams.WRAP_CONTENT;  
    8.         }  
    9.   
    10.         // when a background is available, we embed the content view  
    11.         // within another view that owns the background drawable  
    12.         PopupViewContainer popupViewContainer = new PopupViewContainer(mContext);  
    13.         PopupViewContainer.LayoutParams listParams = new PopupViewContainer.LayoutParams(  
    14.                 ViewGroup.LayoutParams.MATCH_PARENT, height  
    15.         );  
    16.         popupViewContainer.setBackgroundDrawable(mBackground);  
    17.         popupViewContainer.addView(mContentView, listParams);  
    18.   
    19.         mPopupView = popupViewContainer;  
    20.     } else {  
    21.         mPopupView = mContentView;  
    22.     }  
    23.     mPopupWidth = p.width;  
    24.     mPopupHeight = p.height;  
    25. }  

    从上面可以看出，如果mBackground不这空，会首先生成一个PopupViewContainer的ViewContainer，然后把mContentView做为子布局add进去，然后把popupViewContainer做为PopupWindow做为根布局。

    [html] view plain copy
    1. popupViewContainer.addView(mContentView, listParams);  

    那如果mBackground不为空，那就直接把mContentView做为View传递给PopupWindow窗体。

    [java] view plain copy
    1. mPopupView = mContentView  

    到此，我们知道，如果mBackground不为空，会在我们设置的contentView外再包一层布局。
    那下面，我们再看看包的这层布局都干了什么：
    先列出来完整的代码，然后再分步讲（已做精简，如需知道更多，可参看源码）

    [java] view plain copy
    1. private class PopupViewContainer extends FrameLayout {  
    2.     private static final String TAG = "PopupWindow.PopupViewContainer";  
    3.   
    4.     public PopupViewContainer(Context context) {  
    5.         super(context);  
    6.     }  
    7.     …………  
    8.    @Override  
    9.    public boolean dispatchKeyEvent(KeyEvent event) {  
    10.        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {  
    11.            if (event.getAction() == KeyEvent.ACTION_DOWN  
    12.                    && event.getRepeatCount() == 0) {  
    13.                …………  
    14.            } else if (event.getAction() == KeyEvent.ACTION_UP) {  
    15.                KeyEvent.DispatcherState state = getKeyDispatcherState();  
    16.                if (state != null && state.isTracking(event) && !event.isCanceled()) {  
    17.                    dismiss();  
    18.                    return true;  
    19.                }  
    20.            }  
    21.            return super.dispatchKeyEvent(event);  
    22.        } else {  
    23.            return super.dispatchKeyEvent(event);  
    24.        }  
    25.    }  
    26.   
    27.     @Override  
    28.     public boolean onTouchEvent(MotionEvent event) {  
    29.         final int x = (int) event.getX();  
    30.         final int y = (int) event.getY();  
    31.           
    32.         if ((event.getAction() == MotionEvent.ACTION_DOWN)  
    33.                 && ((x < 0) || (x >= getWidth()) || (y < 0) || (y >= getHeight()))) {  
    34.             dismiss();  
    35.             return true;  
    36.         } else if (event.getAction() == MotionEvent.ACTION_OUTSIDE) {  
    37.             dismiss();  
    38.             return true;  
    39.         } else {  
    40.             return super.onTouchEvent(event);  
    41.         }  
    42.     }  
    43.     …………  
    44. }  

    这里总共需要注意三部分：
    （1）、PopupViewContainer派生自FrameLayout
    从PopupViewContainer声明上可以看到，PopupViewContainer派生自FrameLayout；所以，这也是它能将我们传进来的contentView添加为自己的子布局的原因。
    （2）、返回按钮捕捉

    [java] view plain copy
    1. public boolean dispatchKeyEvent(KeyEvent event) {  
    2.    if (event.getKeyCode() == KeyEvent.KEYCODE_BACK) {  
    3.        if (event.getAction() == KeyEvent.ACTION_DOWN  
    4.                && event.getRepeatCount() == 0) {  
    5.            …………  
    6.        } else if (event.getAction() == KeyEvent.ACTION_UP) {  
    7.            //抬起手指时  
    8.            KeyEvent.DispatcherState state = getKeyDispatcherState();  
    9.            if (state != null && state.isTracking(event) && !event.isCanceled()) {  
    10.                //隐藏窗体  
    11.                dismiss();  
    12.                return true;  
    13.            }  
    14.        }  
    15.        return super.dispatchKeyEvent(event);  
    16.    } else {  
    17.        return super.dispatchKeyEvent(event);  
    18.    }  
    19. }  

    从上面的代码来看，PopupViewContainer捕捉了KeyEvent.KEYCODE_BACK事件，并且在用户在点击back按钮，抬起手指的时候（event.getAction() == KeyEvent.ACTION_UP）将窗体隐藏掉。
    所以，添加上mBackground以后，可以在用户点击返回按钮时，隐藏窗体！
    （3）、捕捉Touch事件——onTouchEvent

    [java] view plain copy
    1. public boolean onTouchEvent(MotionEvent event) {  
    2.     final int x = (int) event.getX();  
    3.     final int y = (int) event.getY();  
    4.       
    5.     if ((event.getAction() == MotionEvent.ACTION_DOWN)  
    6.             && ((x < 0) || (x >= getWidth()) || (y < 0) || (y >= getHeight()))) {  
    7.         dismiss();  
    8.         return true;  
    9.     } else if (event.getAction() == MotionEvent.ACTION_OUTSIDE) {  
    10.         dismiss();  
    11.         return true;  
    12.     } else {  
    13.         return super.onTouchEvent(event);  
    14.     }  
    15. }  


    从这代码来看，PopupViewContainer捕捉了两种touch事件，MotionEvent.ACTION_DOWN和MotionEvent.ACTION_OUTSIDE；将接收到这两个事件时，会将窗体隐藏掉。
    MotionEvent.ACTION_DOWN的触发很好理解，即当用户点击到PopupViewContainer事件时，就隐藏掉；
    所以，下面的情况就来了：
    假如有一个TextView，我们没有对它设置点击响应。那只要加了background，那点击事件就会传给下层的PopupViewContainer，从而使窗体消失。
    那还有个问题，MotionEvent.ACTION_OUTSIDE是个什么鬼？它是怎么触发的。我们在下面开一段细讲。
    （4）MotionEvent.ACTION_OUTSIDE与setOutsideTouchable(boolean touchable)
    可能把这两个放在一块，大家可能就恍然大悟了，表着急，一个个来看。
    先看看setOutsideTouchable(boolean touchable)的代码：

    [java] view plain copy
    1. public void setOutsideTouchable(boolean touchable) {  
    2.    mOutsideTouchable = touchable;  
    3. }  

    然后再看看mOutsideTouchable哪里会用到
    下面代码，我做了严重精减，等下会再完整再讲这一块

    [java] view plain copy
    1. private int computeFlags(int curFlags) {  
    2.     curFlags &= ~(WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH);  
    3.     …………  
    4.     if (mOutsideTouchable) {  
    5.         curFlags |= WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;  
    6.     }  
    7.     …………  
    8.     return curFlags;  
    9. }  

    这段代码主要是用各种变量来设置window所使用的flag；
    首先，将curFlags所在运算的各种Flag,全部置为False;代码如下：

    [java] view plain copy
    1. curFlags &= ~(WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH);  

    然后，再根据用户设置的变量来开启：

    [java] view plain copy
    1. if (mOutsideTouchable) {  
    2.    curFlags |= WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;  
    3. }  

    既然讲到FLAG_WATCH_OUTSIDE_TOUCH，那我们来看看FLAG_WATCH_OUTSIDE_TOUCH所代表的意义：

    这段话的意思是说，如果窗体设置了FLAG_WATCH_OUTSIDE_TOUCH这个flag，那么 用户点击窗体以外的位置时，将会在窗体的MotionEvent中收到MotionEvetn.ACTION_OUTSIDE事件。
    参见：《WindowManager.LayoutParams》

    所以在PopupViewContainer中添加了对MotionEvent.ACTION_OUTSIDE的捕捉！当用户点击PopupViewContainer以外的区域时，将dismiss掉PopupWindow

    [java] view plain copy
    1. public boolean onTouchEvent(MotionEvent event) {  
    2.     final int x = (int) event.getX();  
    3.     final int y = (int) event.getY();  
    4.       
    5.     if ((event.getAction() == MotionEvent.ACTION_DOWN)  
    6.             && ((x < 0) || (x >= getWidth()) || (y < 0) || (y >= getHeight()))) {  
    7.         dismiss();  
    8.         return true;  
    9.     } else if (event.getAction() == MotionEvent.ACTION_OUTSIDE) {  
    10.         dismiss();  
    11.         return true;  
    12.     } else {  
    13.         return super.onTouchEvent(event);  
    14.     }  
    15. }  

    (5)重看PopupWindow的computeFlags(int curFlags)函数
    完整的computeFlags（）函数如下：

    [java] view plain copy
    1. private int computeFlags(int curFlags) {  
    2.     curFlags &= ~(  
    3.             WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES |  
    4.             WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |  
    5.             WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE |  
    6.             WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH |  
    7.             WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS |  
    8.             WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM |  
    9.             WindowManager.LayoutParams.FLAG_SPLIT_TOUCH);  
    10.     if(mIgnoreCheekPress) {  
    11.         curFlags |= WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES;  
    12.     }  
    13.     if (!mFocusable) {  
    14.         curFlags |= WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;  
    15.         if (mInputMethodMode == INPUT_METHOD_NEEDED) {  
    16.             curFlags |= WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;  
    17.         }  
    18.     } else if (mInputMethodMode == INPUT_METHOD_NOT_NEEDED) {  
    19.         curFlags |= WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;  
    20.     }  
    21.     if (!mTouchable) {  
    22.         curFlags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;  
    23.     }  
    24.     if (mOutsideTouchable) {  
    25.         curFlags |= WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH;  
    26.     }  
    27.     if (!mClippingEnabled) {  
    28.         curFlags |= WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS;  
    29.     }  
    30.     if (isSplitTouchEnabled()) {  
    31.         curFlags |= WindowManager.LayoutParams.FLAG_SPLIT_TOUCH;  
    32.     }  
    33.     if (mLayoutInScreen) {  
    34.         curFlags |= WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN;  
    35.     }  
    36.     if (mLayoutInsetDecor) {  
    37.         curFlags |= WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR;  
    38.     }  
    39.     if (mNotTouchModal) {  
    40.         curFlags |= WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;  
    41.     }  
    42.     return curFlags;  
    43. }  

    这段代码同样是分两段：
    第一段：将所有要计算的FLAG，全部在结果curFlags中置为FALSE;

    [java] view plain copy
    1. curFlags &= ~(  
    2.         WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES |  
    3.         WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |  
    4.         WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE |  
    5.         WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH |  
    6.         WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS |  
    7.         WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM |  
    8.         WindowManager.LayoutParams.FLAG_SPLIT_TOUCH);  

    第二段：然后根据用户设置的变量，逐个判断是否打开。比如下面这个：

    [java] view plain copy
    1. //看到了吧，我们的setTouchable(boolean touchable)最终也是通过在这里设置的  
    2. if (!mTouchable) {  
    3.     curFlags |= WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;  
    4. }  

    好了，结合源码就给大家讲到这里了。最后总结一下：
    **如果我们给PopupWindow添加了mBackground，那它将会：**

    • setOutsideTouchable(true)将生效，具有外部点击隐藏窗体的功能
    • 手机上的返回键将可以使窗体消失
    • 对于PopupWindow上层没有捕捉的点击事件，点击之后，仍然能使窗体消失。
    源码在文章底部给出

    二、为什么要强制代码设置PopupWindow的Height、Width

    在上篇，我们留了这么个疑问，设置contentView很容易理解，但width和height为什么要强制设置呢？我们在布局代码中不是已经写的很清楚了么？比如我们的popuplayout.xml的根布局：

    [html] view plain copy
    1. <RelativeLayout  
    2.         xmlns:android="http://schemas.android.com/apk/res/android"  
    3.         android:layout_width="fill_parent"  
    4.         android:layout_height="fill_parent"  
    5.         android:background="#66000000">  
    6.         …………  
    7. </RelativeLayout>     

    从根布局中，我们明明可以看到layout_width我们设置为了"fill_parent"，layout_height设置为了“fill_parent”；为什么非要我们在代码中还要再设置一遍：

    [java] view plain copy
    1. View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  
    2. mPopWindow = new PopupWindow(contentView);  
    3. mPopWindow.setWidth(ViewGroup.LayoutParams.FILL_PARENT);  
    4. mPopWindow.setHeight(ViewGroup.LayoutParams.FILL_PARENT);  

    带着这个疑问，我们从两个角度来分析，”源码角度”看看就好，关键的解答在第二部分：布局角度；

    1、源码角度

    首先，我们从源码我角度来分析为什么要设置Width和Height;我们就以setWidth（）为例来追根寻底下
    先看下setWidth（）：

    [java] view plain copy
    1. public void setWidth(int width) {  
    2.     mWidth = width;  
    3. }  

    然后再看看mWidth在哪里用到：

    [java] view plain copy
    1. private WindowManager.LayoutParams createPopupLayout(IBinder token) {  
    2.     // generates the layout parameters for the drop down  
    3.     // we want a fixed size view located at the bottom left of the anchor  
    4.     WindowManager.LayoutParams p = new WindowManager.LayoutParams();  
    5.     // these gravity settings put the view at the top left corner of the  
    6.     // screen. The view is then positioned to the appropriate location  
    7.     // by setting the x and y offsets to match the anchor's bottom  
    8.     // left corner  
    9.     p.gravity = Gravity.LEFT | Gravity.TOP;  
    10.     p.width = mLastWidth = mWidth;  
    11.     p.height = mLastHeight = mHeight;  
    12.     if (mBackground != null) {  
    13.         p.format = mBackground.getOpacity();  
    14.     } else {  
    15.         p.format = PixelFormat.TRANSLUCENT;  
    16.     }  
    17.     p.flags = computeFlags(p.flags);  
    18.     p.type = mWindowLayoutType;  
    19.     p.token = token;  
    20.     p.softInputMode = mSoftInputMode;  
    21.     p.setTitle("PopupWindow:" + Integer.toHexString(hashCode()));  
    22.   
    23.     return p;  
    24. }  

    上面是createPopupLayout的完整代码，我们提取一下：

    [java] view plain copy
    1. private WindowManager.LayoutParams createPopupLayout(IBinder token) {  
    2.     …………  
    3.     p.width = mLastWidth = mWidth;  
    4.     p.height = mLastHeight = mHeight;  
    5.     …………  
    6.     return p;  
    7. }  

    从这里便可以清晰的看到窗体的宽度和高度都是通过mWidth和mHeight来设置的。
    那问题来了，mWidth在哪里能设置呢：
    通篇代码中，总共只有三个函数能设置mWidth，分别如下:
    除了setWidth（）函数本身，就只有PopupWindow（）的两个构造函数了；

    [java] view plain copy
    1. public void setWidth(int width) {  
    2.     mWidth = width;  
    3. }  
    4. public PopupWindow(View contentView, int width, int height) {  
    5.     this(contentView, width, height, false);  
    6. }  
    7. public PopupWindow(View contentView, int width, int height, boolean focusable) {  
    8.    if (contentView != null) {  
    9.        mContext = contentView.getContext();  
    10.        mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);  
    11.    }  
    12.    setContentView(contentView);  
    13.    setWidth(width);  
    14.    setHeight(height);  
    15.    setFocusable(focusable);  
    16. }  

    那么问题来了，如果我们没有设置width和height那结果会如何呢？
    如果我们没有设置width和height，那mWidth和mHeight将会取默认值0！！！！所以当我们没有设置width和height时，并不是我们的窗体没有弹出来，而是因为他们的width和height都是0了！！！！
    **那么问题又来了：Google那帮老头，不能从我们contentView的根布局中取参数吗，非要我们自己设？**
    当然不是那帮老头的代码有问题，因为这牵涉了更深层次的内容：布局参数的设定问题！我们在下一部分，布局角度来解答。

    2、布局角度

    这部分我们着重讲一个问题：控件的布局参数从哪里来？
    我们看下面这段XML:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <RelativeLayout  
    3.         xmlns:android="http://schemas.android.com/apk/res/android"  
    4.         android:layout_width="fill_parent"  
    5.         android:layout_height="fill_parent">  
    6.     <LinearLayout  
    7.             android:layout_width="match_parent"  
    8.             android:layout_height="wrap_content"  
    9.             android:background="@drawable/pop_bg"  
    10.             android:orientation="vertical"  
    11.             android:paddingBottom="2dp"  
    12.             android:layout_alignParentRight="true">  
    13.   
    14.         <TextView  
    15.                 android:id="@+id/pop_computer"  
    16.                 android:layout_width="wrap_content"  
    17.                 android:layout_height="wrap_content"  
    18.                 style="@style/pop_text_style"  
    19.                 android:text="计算机"/>  
    20.     </LinearLayout>  
    21. </RelativeLayout>  

    很明显，这段代码是个三层结构，TextView是最终的子控件。
    那我现在要问了：TextView的显示大小是由谁来决定的？
    是由它自己的布局layout_width="wrap_content"、layout_height="wrap_content"来决定的吗？
    当然不是！！！！它的大小，应该是在它父控件的基础上决定的。即LinearLayout的显示大小确定了以后，才能确定TextView的大小。
    这好比，如果LinearLayout的大小是全屏的，那TextView的大小就由它自己来决定了，那如果LinearLayout的大小只有一像素呢？那TextView的所显示的大小无论它自己怎么设置，最大也就显示一像素！
    所以我们的结论来了：控件的大小，是建立在父控件大小确定的基础上的。
    那同样：LinearLayout的大小确定是要靠RelativeLayout来决定。
    那问题来了：RelativeLayout的大小靠谁决定呢？
    当然是它的父控件了。
    我们以前讲过ViewTree的概念，即在android中任何一个APP都会有一个根结点，然后它所有的Activity和Fragmentr所对应的布局都会加入到这个ViewTree中；在ViewTree中每一个控件是一个结点：
    比如下面这个ViewTree(画的很烂……)

    从上面的ViewTree中可以看到，每一个结点都是有父结点的（除了根结点，根结点不是应用的根结点，与我们应用无关），所以每一个控件都是可以找到父控件的的布局大小的。
    但我们的contentView是怎么来的呢？

    [java] view plain copy
    1. View contentView = LayoutInflater.from(MainActivity.this).inflate(R.layout.popuplayout, null);  

    直接inflate出来的，我们对它没有设置根结点！
    那问题来了？它的大小由谁来解决呢？
    好像没有谁能决定了，因为他没有父结点。那它到底是多大呢？未知！
    所以只有通过代码让用户去手动设置了！所以这就是为什么非要用户设置width和height的原因了。

    好了，到这里，有关PopupWIndow的东东也就讲完了，希望大家能学到东西。

    如果本文有帮到你，记得加关注哦

    源码下载地址：http://download.csdn.net/detail/harvic880925/9197073

    请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/49278705 谢谢
  • 相关阅读:
    .net c# gif动画如何添加图片水印
    Webbrowser控件设置所使用的内核
    WPF 用户控件不显示标记
    Spark应用场景以及与hadoop的比较
    Spark基本函数学习
    uniapp H5发布后在部分手机字体变大,导致页面错乱
    uni 小程序图片路径转base64
    uniapp px与upx(rpx)相互转换
    uniapp调用扫码功能
    uniapp 引入第三方字体
  • 原文地址：https://www.cnblogs.com/imqsl/p/6601117.html
Copyright © 2011-2022 走看看