安卓框架——SlidingMenu使用技巧

SlidingMenu的一些常用属性

原文转载http://blog.csdn.net/zwl5670/article/details/48274109

[java]  view plain  copy

 

1. //设置侧滑菜单的位置，可选值LEFT , RIGHT ,LEFT_RIGHT（两边都有菜单时设置）  
2. menu.setMode(SlidingMenu.LEFT_RIGHT);  
3. //设置触摸屏幕的模式，可选只MARGIN ,CONTENT   
4.        menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_MARGIN);  
5. //根据dimension资源文件的ID来设置阴影的宽度  
6.        menu.setShadowWidthRes(R.dimen.shadow_width);  
7. //根据资源文件ID来设置滑动菜单的阴影效果  
8.        menu.setShadowDrawable(R.drawable.shadow);  
9. //这两个都是设置滑动菜单视图的宽度，二选一  
10.     //设置SlidingMenu离屏幕的偏移量  
11.        menu.setBehindOffsetRes(R.dimen.slidingmenu_offset);  
12.        //设置宽度  
13.        menu.setBehindWidth()  
14. // 设置渐入渐出效果的值  
15.        menu.setFadeDegree(0.35f);  
16. //设置SlidingMenu与下方视图的移动的速度比，当为1时同时移动，取值0-1  
17.        menu.setBehindScrollScale(1.0f);  
18. //设置二级菜单的阴影效果  
19.        menu.setSecondaryShadowDrawable(R.drawable.shadow);  
20. //设置右边（二级）侧滑菜单  
21.        menu.setSecondaryMenu(R.layout.right_menu_frame);  
22. //为侧滑菜单设置布局  
23.        menu.setMenu(R.layout.leftmenu);  
24. //把滑动菜单添加进所有的Activity中，可选值SLIDING_CONTENT， SLIDING_WINDOW  
25.        menu.attachToActivity(this,SlidingMenu.SLIDING_CONTENT);  

1、在Activity中通过SlidingMenu构造方法，直接设置侧滑菜单

[java]  view plain  copy

 

1. public class MainActivity extends Activity{   
2.     @Override    
3.    protected void onCreate(BundlesavedInstanceState) {  
4.         super.onCreate(savedInstanceState);  
5.            setContentView(R.layout.activity_main);    
6.             SlidingMenu menu = new SlidingMenu(this);//初始化滑动菜单  
7.         menu.setMode(SlidingMenu.LEFT);//设置触摸屏幕的模式  
8.         menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_MARGIN);  
9.         menu.setShadowWidthRes(R.dimen.shadow_width);//设置阴影的宽度  
10.         menu.setShadowDrawable(R.drawable.shadow);//设置滑动菜单的阴影效果  
11.         // 设置滑动菜单视图的宽度  
12.         menu.setBehindOffsetRes(R.dimen.slidingmenu_offset);  
13.         // 设置渐入渐出效果的值  
14.         menu.setFadeDegree(0.35f);  
15.         /** 
16.          *SLIDING_WINDOW will include the Title/ActionBar in the content 
17.          *section of the SlidingMenu, while SLIDING_CONTENT does not. 
18.          */  
19.         // 把滑动菜单添加进所有的Activity中   
20.         menu.attachToActivity(this, SlidingMenu.SLIDING_CONTENT);  
21.         // 为侧滑菜单设置布局    
22.       menu.setMenu(R.layout.leftmenu);  
23.     }    
24. }    

2、通过把Activity继承SlidingActivity 

a、继承SlidingActivity

b、然后在onCreate中setBehindContentView(R.layout.leftmenu); 设置侧滑菜单的布局

c、通过getSlidingMenu()得到SlidingMenu对象，然后设置样式  

[java]  view plain  copy

 

1. public class MainActivity extends SlidingActivity  {    
2.     @Override    
3.     public void onCreate(Bundle savedInstanceState) {    
4.         super.onCreate(savedInstanceState);    
5.         setContentView(R.layout.activity_main);    
6.     
7.         setBehindContentView(R.layout.leftmenu);    
8.         // configure the SlidingMenu    
9.         SlidingMenu menu = getSlidingMenu();    
10.         menu.setMode(SlidingMenu.LEFT);    
11.         // 设置触摸屏幕的模式    
12.         menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN);    
13.         menu.setShadowWidthRes(R.dimen.shadow_width);    
14.         menu.setShadowDrawable(R.drawable.shadow);    
15.     
16.         // 设置滑动菜单视图的宽度    
17.         menu.setBehindOffsetRes(R.dimen.slidingmenu_offset);    
18.         // 设置渐入渐出效果的值    
19.         menu.setFadeDegree(0.35f);    
20.         /**  
21.          * SLIDING_WINDOW will include the Title/ActionBar in the content  
22.          * section of the SlidingMenu, while SLIDING_CONTENT does not.  
23.          */    
24.         // menu.attachToActivity(this, SlidingMenu.SLIDING_CONTENT);    
25.         // menu.setMenu(R.layout.leftmenu);    
26.     }    
27. }    

3、将SlidingMenu当作普通控件

可以把SlidingMenu作为普通的view，然后在布局中声明。

[java]  view plain  copy

 

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"    
2.     xmlns:tools="http://schemas.android.com/tools"    
3.     android:id="@+id/id_main_ly"    
4.     android:layout_width="match_parent"    
5.     android:layout_height="match_parent" >    
6.     
7.     <LinearLayout    
8.         android:layout_width="wrap_content"    
9.         android:layout_height="wrap_content"    
10.         android:layout_marginLeft="30dp"    
11.         android:layout_marginTop="30dp" >    
12.     
13.     
14.         <com.jeremyfeinstein.slidingmenu.lib.SlidingMenu    
15.             xmlns:sliding="http://schemas.android.com/apk/res-auto"    
16.             android:id="@+id/slidingmenulayout"    
17.             android:layout_width="120dp"    
18.             android:layout_height="170dp"    
19.             android:background="#ffffffff"    
20.             sliding:behindOffset="0dp"    
21.             sliding:behindScrollScale="1"    
22.             sliding:fadeDegree="0.3"    
23.             sliding:fadeEnabled="true"    
24.             sliding:touchModeAbove="fullscreen"    
25.             sliding:viewAbove="@layout/pic" />    
26.     </LinearLayout>    
27.     
28. </RelativeLayout>    

 

pic布局：

[plain]  view plain  copy

 

1. <?xml version="1.0" encoding="utf-8"?>    
2. <ImageView xmlns:android="http://schemas.android.com/apk/res/android"    
3.     android:layout_width="120dp"    
4.     android:layout_height="170dp"    
5.     android:src="@drawable/zhy" />    

 

MainActivity：

[java]  view plain  copy

 

1. package com.zhy.zhy_slidemenu_demo03;    
2.     
3. import android.app.Activity;    
4. import android.os.Bundle;    
5. import android.view.View;    
6. import android.view.View.OnClickListener;    
7.     
8. import com.jeremyfeinstein.slidingmenu.lib.SlidingMenu;    
9.     
10. public class MainActivity extends Activity    
11. {    
12.     private SlidingMenu mLeftMenu;    
13.     
14.     @Override    
15.     protected void onCreate(Bundle savedInstanceState)    
16.     {    
17.         super.onCreate(savedInstanceState);    
18.         setContentView(R.layout.activity_main);    
19.     
20.         mLeftMenu = (SlidingMenu) findViewById(R.id.slidingmenulayout);    
21.         // configure the SlidingMenu    
22.         // SlidingMenu menu = new SlidingMenu(this);    
23.         mLeftMenu.setMode(SlidingMenu.LEFT);    
24.         // 设置触摸屏幕的模式    
25.         mLeftMenu.setShadowWidthRes(R.dimen.shadow_width);    
26.         mLeftMenu.setShadowDrawable(R.drawable.shadow);    
27.     
28.         mLeftMenu.setMenu(R.layout.leftmenu);    
29.     
30.         mLeftMenu.setOnClickListener(new OnClickListener()    
31.         {    
32.             @Override    
33.             public void onClick(View v)    
34.             {    
35.                 if (mLeftMenu.isMenuShowing())    
36.                     mLeftMenu.toggle();    
37.             }    
38.         });    
39.         // 设置滑动菜单视图的宽度    
40.         // 设置渐入渐出效果的值    
41.         /**  
42.          * SLIDING_WINDOW will include the Title/ActionBar in the content  
43.          * section of the SlidingMenu, while SLIDING_CONTENT does not.  
44.          */    
45.     }    
46. }    

4、SlidingMenu设置左右侧滑菜单例子

上面3个方法，SlidingMenu的布局中控件的事件都需要写在Activity中，这样代码比较臃肿，一般会使用Fragment作为侧滑菜单的布局容器。

核心代码：

· 

[java]  view plain  copy

 

1.  Fragment leftMenuFragment = new MenuLeftFragment();    
2. ·          setBehindContentView(R.layout.left_menu_frame);    
3. ·          getSupportFragmentManager().beginTransaction()    
4. ·                  .replace(R.id.id_left_menu_frame, leftMenuFragment).commit();    
5. ·          SlidingMenu menu = getSlidingMenu();    
6. ·          menu.setMode(SlidingMenu.LEFT_RIGHT);    
7. ·          // 设置触摸屏幕的模式    
8. ·          menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_MARGIN);   

先给侧滑菜单通过 setBehindContentView(R.layout.left_menu_frame); 设置一个布局，此布局中只有一个FrameLayout，然后使用FragmentManager将Fragment替换掉此Fragment，这样这个 Fragment就作为我们侧滑菜单的布局了，我们的事件处理代码也可以写在Fragement中，而不是Activity中。

MenuLeftFragment

[java]  view plain  copy

 

1. package com.zhy.zhy_slidemenu_demo04;    
2.     
3. import java.util.Arrays;    
4. import java.util.List;    
5.     
6. import android.os.Bundle;    
7. import android.support.v4.app.Fragment;    
8. import android.view.LayoutInflater;    
9. import android.view.View;    
10. import android.view.ViewGroup;    
11. import android.widget.ArrayAdapter;    
12. import android.widget.ListAdapter;    
13. import android.widget.ListView;    
14.     
15. public class MenuLeftFragment extends Fragment    
16. {    
17.     private View mView;    
18.     private ListView mCategories;    
19.     private List<String> mDatas = Arrays    
20.             .asList("聊天", "发现", "通讯录", "朋友圈", "订阅号");    
21.     private ListAdapter mAdapter;    
22.     
23.     @Override    
24.     public View onCreateView(LayoutInflater inflater, ViewGroup container,    
25.             Bundle savedInstanceState)  {    
26.         if (mView == null)  {    
27.             initView(inflater, container);    
28.         }    
29.         return mView;    
30.     }    
31.     
32.     private void initView(LayoutInflater inflater, ViewGroup container)   {    
33.         mView = inflater.inflate(R.layout.left_menu, container, false);    
34.         mCategories = (ListView) mView    
35.                 .findViewById(R.id.id_listview_categories);    
36.         mAdapter = new ArrayAdapter<String>(getActivity(),    
37.                 android.R.layout.simple_list_item_1, mDatas);    
38.         mCategories.setAdapter(mAdapter);    
39.     }    
40. }    
41. MenuRightFragment  
42. package com.zhy.zhy_slidemenu_demo04;    
43.     
44. import android.os.Bundle;    
45. import android.support.v4.app.Fragment;    
46. import android.view.LayoutInflater;    
47. import android.view.View;    
48. import android.view.ViewGroup;    
49.     
50. public class MenuRightFragment extends Fragment {    
51.     private View mView;    
52.     
53.     @Override    
54.     public View onCreateView(LayoutInflater inflater, ViewGroup container,    
55.             Bundle savedInstanceState) {    
56.         if(mView == null) {    
57.             mView = inflater.inflate(R.layout.right_menu, container, false);    
58.         }    
59.         return mView ;    
60.     }    
61. }    

MainActivity  

[java]  view plain  copy

 

1. public class MainActivity extends SlidingFragmentActivity  {    
2.     
3.     private ViewPager mViewPager;    
4.     private FragmentPagerAdapter mAdapter;    
5.     private List<Fragment> mFragments = new ArrayList<Fragment>();    
6.     
7.     @Override    
8.     public void onCreate(Bundle savedInstanceState)  {    
9.         super.onCreate(savedInstanceState);    
10.         this.requestWindowFeature(Window.FEATURE_NO_TITLE);    
11.         setContentView(R.layout.activity_main);    
12.         // 初始化SlideMenu    
13.         initRightMenu();    
14.         // 初始化ViewPager    
15.         initViewPager();    
16.     }    
17.     
18.     private void initViewPager()   {    
19.         mViewPager = (ViewPager) findViewById(R.id.id_viewpager);    
20.         MainTab01 tab01 = new MainTab01();    
21.         MainTab02 tab02 = new MainTab02();    
22.         MainTab03 tab03 = new MainTab03();    
23.         mFragments.add(tab01);    
24.         mFragments.add(tab02);    
25.         mFragments.add(tab03);    
26.         /**  
27.          * 初始化Adapter  
28.          */    
29.         mAdapter = new FragmentPagerAdapter(getSupportFragmentManager())  {    
30.             @Override    
31.             public int getCount()   {    
32.                 return mFragments.size();    
33.             }    
34.     
35.             @Override    
36.             public Fragment getItem(int arg0)   {    
37.                 return mFragments.get(arg0);    
38.             }    
39.         };    
40.         mViewPager.setAdapter(mAdapter);    
41.     }    
42.     
43.     private void initRightMenu()  {    
44.         Fragment leftMenuFragment = new MenuLeftFragment();    
45.         setBehindContentView(R.layout.left_menu_frame);    
46.         getSupportFragmentManager().beginTransaction()    
47.                 .replace(R.id.id_left_menu_frame, leftMenuFragment).commit();    
48.         SlidingMenu menu = getSlidingMenu();    
49.         menu.setMode(SlidingMenu.LEFT_RIGHT);    
50.         // 设置触摸屏幕的模式    
51.         menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_MARGIN);    
52.         menu.setShadowWidthRes(R.dimen.shadow_width);    
53.         menu.setShadowDrawable(R.drawable.shadow);    
54.         // 设置滑动菜单视图的宽度    
55.         menu.setBehindOffsetRes(R.dimen.slidingmenu_offset);    
56.         // 设置渐入渐出效果的值    
57.         menu.setFadeDegree(0.35f);    
58.         // menu.setBehindScrollScale(1.0f);    
59.         menu.setSecondaryShadowDrawable(R.drawable.shadow);    
60.         //设置右边（二级）侧滑菜单    
61.         menu.setSecondaryMenu(R.layout.right_menu_frame);    
62.         Fragment rightMenuFragment = new MenuRightFragment();    
63.         getSupportFragmentManager().beginTransaction()    
64.                 .replace(R.id.id_right_menu_frame, rightMenuFragment).commit();    
65.     }    
66.     public void showLeftMenu(View view)   {    
67.         getSlidingMenu().showMenu();    
68.     }    
69.     public void showRightMenu(View view)  {    
70.         getSlidingMenu().showSecondaryMenu();    
71.     }    
72. }    

MainActivity继承的是SlidingFragmentActivity ，在Activity中FragmentPagerAdapter和viewPager作为主布局，然后分别初始化SlidingMenu的两边的菜单。