Android SlidingMenu 史上最简单实现方式

最新推荐文章于 2020-09-10 10:31:42 发布
最新推荐文章于 2020-09-10 10:31:42 发布
阅读量3.6k 收藏 7
点赞数 3
分类专栏： Android 文章标签： android slidingmen
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxy_blog/article/details/50523598
版权

1.#概述#

目前的开发中，有很项目中都会要求使用侧滑菜单，当然现在在CSDN上面也是有很多篇文章都是讲述侧滑菜单的实现尤其是弘扬大神的文章更是有很多(弘扬大神博客地址：点这里)；此文的绝大部分想法都是学习于弘扬大神，只是进行简单的整理便于使用，那么在这里就给大家讲述一篇比较简单实现侧滑的案例，希望可以帮到想要用的人。

2.#效果展示#
(1).QQ效果
仿QQ5.0效果
(2) 抽屉效果
抽屉式效果
(3)普通效果
普通效果
3.#代码展示区#

（1）. 左边菜单left_menu.xml;

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">
    <ListView
        android:dividerHeight="1dp"
        android:scrollbars="none"
        android:id="@+id/menu_list" 
        android:divider="#b2b2b2"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />
</RelativeLayout>

（2） 左边菜单区域menu_item.xml;

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="vertical" >

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="56dp" >

        <ImageView
            android:id="@+id/id_item_img"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerVertical="true"
            android:padding="16dp"
            />

        <TextView
            android:id="@+id/id_item_name"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_centerVertical="true"
            android:layout_toRightOf="@+id/id_item_img"
            android:paddingBottom="16dp"
            android:paddingLeft="2dp"
            android:paddingTop="16dp"
            android:textSize="16sp" />
    </RelativeLayout>

</LinearLayout>

（3）内容区域 content_main.xml，这个也比较简单只是为了相应的演示功能。

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    android:background="#197dec"
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:onClick="toggle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="切换菜单"
        />
    <TextView
        android:textColor="#fff"
        android:textSize="36sp"
        android:gravity="center"
        android:text="内容区域"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />
</RelativeLayout>

（4）下面是主配置文件 main.xml,因为在这里有使用自定义的属性，因此必须要添加命名空间在老版本中是xmlns:yourcustonname=”http://schemas.android.com/apk/应用的namespace” 新版本中是xmlns:yourcustonname=”http://schemas.android.com/apk/res-auto”

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:sliding="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <!--
        普通模式
        <enum name="ordinary" value="0"/>
        抽屉模式
        <enum name="drawer" value="1"/>
        仿QQ模式
        <enum name="imitationQQ" value="2"/>
        这个是设置滑动完成后，菜单区域的右边距
        sliding:mMenuRightPadding="100dp"
    -->
    <cn.hxy.com.menu.HSlideMenu
        android:id="@+id/sliding_menu"
        android:background="#ffffff"
        sliding:mType="ordinary"
        sliding:mMenuRightPadding="100dp"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="wrap_content"
            android:layout_height="match_parent">

            <include layout="@layout/left_menu"/>

            <include layout="@layout/content_main"/>

        </LinearLayout>

    </cn.hxy.com.menu.HSlideMenu>

</LinearLayout>

（5）,自定义的类 HSlideMenu.java代码展示。注释添加的比较详细，有不懂得的问题可以留言。

package cn.hxy.com.menu;

import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.HorizontalScrollView;
import com.nineoldandroids.view.ViewHelper;
import cn.hxy.com.R;
import cn.hxy.com.utils.ConvertUtils;
import cn.hxy.com.utils.ScreenUtil;

/**
 * Created by admin on 2016/1/11.
 */
public class HSlideMenu extends HorizontalScrollView
{
    // 普通菜单
    private static final int TYPE_ORDINARY = 0;
    // 抽屉式菜单
    private static final int TYPE_DRAWER = 1;
    // 仿 5.0 QQ菜单
    private static final int TYPE_IMITATION = 2;
    /**
     * 标识当前的菜单样式选项
     */
    private enum Type
    {
        TYPE_ORDINARY,TYPE_DRAWER,TYPE_IMITATION
    }
    /**
     * HorizontalScrollView 主内容区域唯一控件
     */
    private ViewGroup mWapper;
    /**
     * 左边菜单
     */
    private ViewGroup mMenu;
    /**
     * 主菜单menu的宽度
     */
    private int mMenuWidth;
    /**
     * 菜单距离右边的距离
     */
    private int mMenuRightPadding = 70;
    /**
     * 内容区域
     */
    private ViewGroup mContent;
    /**
     * 定义初始化方法只进行一次
     */
    private boolean isFirst;
    /**
     * 定义屏幕的大小
     */
    private int[] mScreenSize;
    /**
     * 设置默认的菜单样式为
     * 抽屉式菜单
     */
    private Type mType = Type.TYPE_DRAWER;
    /**
     * 标识当前菜单界面是否打开
     */
    private boolean isMenuOpen = false;

    public HSlideMenu(Context context)
    {
        this(context,null);
    }

    public HSlideMenu(Context context, AttributeSet attrs)
    {
        this(context, attrs,0);
    }

    public HSlideMenu(Context context, AttributeSet attrs, int defStyleAttr)
    {
        super(context, attrs, defStyleAttr);
        init(context,attrs,defStyleAttr);
    }
    /**
     * 初始化参数，并获取自定义参数
     * @param context
     */
    private void init(Context context, AttributeSet attrs, int defStyleAttr)
    {
        TypedArray mCustomParams = context.
                obtainStyledAttributes(attrs, R.styleable.HSlideMenu,defStyleAttr,0);
        int count = mCustomParams.getIndexCount();
        for (int i = 0; i < count; i++)
        {
            int attr = mCustomParams.getIndex(i);
            if (attr == R.styleable.HSlideMenu_mMenuRightPadding)
            {
                mMenuRightPadding =
                        mCustomParams.getDimensionPixelSize(attr,
                                ConvertUtils.dp2px(context, 70));

            }
            else if (attr == R.styleable.HSlideMenu_mType)
            {
                int mTypeValue = mCustomParams.getInteger(attr, TYPE_DRAWER);
                switch (mTypeValue)
                {
                    case TYPE_ORDINARY:
                        mType = Type.TYPE_ORDINARY;
                        break;
                    case TYPE_DRAWER:
                        mType = Type.TYPE_DRAWER;
                        break;
                    case TYPE_IMITATION:
                        mType = Type.TYPE_IMITATION;
                        break;
                }

            }
        }
        mCustomParams.recycle();
        mScreenSize = ScreenUtil.getScreenSize(context);
    }
    /**
     * 初始化控件 以及计算控件的宽高
     * @param widthMeasureSpec
     * @param heightMeasureSpec
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
    {
        if(!isFirst)
        {
            mWapper = (ViewGroup) this.getChildAt(0);
            mMenu = (ViewGroup) mWapper.getChildAt(0);
            mContent = (ViewGroup) mWapper.getChildAt(1);
            mContent.setOnClickListener(new OnClickListener()
            {
                @Override
                public void onClick(View v)
                {
                    if (isMenuOpen)
                    {
                        closeMenu();
                    }
                }
            });
            /**
             * 设置菜单的宽度
             */
            mMenu.getLayoutParams().width = mMenuWidth = mScreenSize[0] - mMenuRightPadding;
            /**
             * 设置朱内容区域宽度
             */
            mContent.getLayoutParams().width = mScreenSize[0];
            isFirst = true;
        }
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
    }

    /**
     * 设置menu控件初始隐藏
     * @param changed
     * @param l
     * @param t
     * @param r
     * @param b
     */
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b)
    {
        super.onLayout(changed, l, t, r, b);
        /**
         * 设置默认显示内容区域
         */
        if (changed)
        {
            this.scrollTo(mMenuWidth,0);
        }
    }

    /**
     * 用户滑动时对菜单进行隐藏和展示
     * @param ev
     * @return
     */
    @Override
    public boolean onTouchEvent(MotionEvent ev)
    {
        int action = ev.getAction();
        switch (action)
        {
            case MotionEvent.ACTION_UP:
                /**
                 * 用户拖动时候动态获取
                 * 隐藏在屏幕左边的距离的值
                 */
                int mScrollX = getScrollX();
                if (mScrollX >= mMenuWidth / 2)
                {
                    /**
                     * 当隐藏的距离大于等于菜单界面的一半时隐藏菜单
                     */
                    this.smoothScrollTo(mMenuWidth,0);
                    isMenuOpen = false;
                }
                else
                {
                    this.smoothScrollTo(0,0);
                    isMenuOpen = true;
                }
                return true;
        }
        return super.onTouchEvent(ev);
    }

    /**
     * 关闭菜单
     */
    private void closeMenu()
    {
        if (!isMenuOpen)
        {
            return;
        }
        /**
         * 做关闭菜单的操作
         */
        this.smoothScrollTo(mMenuWidth,0);
        isMenuOpen = false;
    }

    /**
     * 打开菜单
     */
    private void openMenu()
    {
        if (isMenuOpen)
        {
            return;
        }
        /**
         * 做打开菜单的操作
         */
        this.smoothScrollTo(0,0);
        isMenuOpen = true;
    }

    /**
     * 切换菜单
     */
    public void toggle()
    {
        if (isMenuOpen)
        {
            closeMenu();
        }
        else
        {
            openMenu();
        }
    }

    /**
     * 设置控件的动画效果
     * @param l
     * @param t
     * @param oldl
     * @param oldt
     */
    @Override
    protected void onScrollChanged(int l, int t, int oldl, int oldt)
    {
        super.onScrollChanged(l, t, oldl, oldt);
        /**
         * scale 为隐藏在屏幕左边的值和菜单界面的比例
         * 取值范围为 1.0 ~~~ 0.0
         */
        float scale = 1.0f * l / mMenuWidth;
        /**
         * 此处的 l 值即表示隐藏在屏幕左边的值
         */
        switch (mType)
        {
            case TYPE_ORDINARY:
                /**
                 * 普通的 不做任何操作
                 */
                break;
            case TYPE_DRAWER:
                /**
                 * 抽屉菜单
                 * 1.用户在拖动的时候，菜单其实已经在当前内容区域的后面
                 */
                ViewHelper.setTranslationX(mMenu,mMenuWidth * scale);
                break;
            case TYPE_IMITATION:
                /**
                 * mMenuWidth * scale 默认为mMenuWidth
                 * 意思为 用户在滑动的时候菜单界面已经移动到内容区域下方
                 * mMenuWidth * scale * 0.7f
                 * 意思为  在内容区域界面的下方已经有课70% 另外30% 还隐藏在屏幕左边
                 */
                ViewHelper.setTranslationX(mMenu,mMenuWidth * scale * 0.7f);
                /**
                 * 仿QQ
                 * 1.内容区域宽和高分别缩小至屏幕的80%
                 * (缩放中心点默认为mContent的中心点 --  这样会导致内容区域缩放异常
                 * 因此 在缩放之前需要设置缩放中心点为 (0,screenHeight / 2))
                 * 2.左侧菜单区域有0.6 ~~ 1.0 透明度效果
                 * 3.左侧菜单 0.7 ~~ 1.0 缩放效果
                 */
                ViewHelper.setPivotX(mContent,0);
                ViewHelper.setPivotY(mContent,mScreenSize[1] / 2);
                /**
                 * 这里需要计算
                 * 1.内容区域缩放的范围为 1.0 ~~ 0.75
                 * mContentScale = 0.75f + 0.25f * scale
                 * 2.菜单区域透明度取值范围为  0.6 ~~ 1.0
                 * mMenuAlpha = 0.6f + 0.4f *(1 - scale)
                 * 3.菜单区域缩放动画范围为  0.7 ~~ 1.0
                 * mMenuScale = 0.7f + 0.3f * (1 - scale)
                 * mMenuScale = 1.0f - 0.3f * scale
                 */
                float mContentScale = 0.75f + 0.25f * scale;
                float mMenuAlpha = 0.6f + 0.4f *(1 - scale);
                float mMenuScale = 1.0f - 0.3f * scale;
                ViewHelper.setScaleX(mContent,mContentScale);
                ViewHelper.setScaleY(mContent,mContentScale);
                ViewHelper.setAlpha(mMenu,mMenuAlpha);
                ViewHelper.setScaleX(mMenu,mMenuScale);
                ViewHelper.setScaleY(mMenu,mMenuScale);
                break;
        }
    }
}

(5) 自定义的属性attr.xml,

<?xml version="1.0" encoding="utf-8"?>
<resources>

    <attr name="mMenuRightPadding" format="dimension"/>
    <attr name="mType" format="integer">
        <enum name="ordinary" value="0"/>
        <enum name="drawer" value="1"/>
        <enum name="imitationQQ" value="2"/>
    </attr>

    <declare-styleable name="HSlideMenu">
        <attr name="mMenuRightPadding"/>
        <attr name="mType"/>
    </declare-styleable>

</resources>

（6.）工具类 ScreenUtils代码。

package cn.hxy.com.utils;

import android.content.Context;
import android.util.DisplayMetrics;
import android.view.WindowManager;

/**
 * Created by admin on 2016/1/11.
 */
public class ScreenUtil
{
    /**
     * 获取手机屏幕宽高
     * @param mContext
     * @return
     */
    public static int[] getScreenSize(Context mContext)
    {
        WindowManager mManager = (WindowManager)
                mContext.getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics mOutMetrics = new DisplayMetrics();
        mManager.getDefaultDisplay().getMetrics(mOutMetrics);

        return new int[]{mOutMetrics.widthPixels,mOutMetrics.heightPixels};
    }

}

(7) ConvertUtils.xml源码展示:

package cn.hxy.com.utils;

import android.content.Context;
import android.util.TypedValue;

/**
 * 参数转换实体类
 * @author Master
 */
public class ConvertUtils 
{
    /**
     * 将dp值转化为像素px值
     * @param mContext 
     * @param convertValue
     * @return px像素值
     */
    public static int dp2px(Context mContext , float convertValue)
    {
        final float density = mContext.getResources().getDisplayMetrics().density;
        return (int) (convertValue * density + 0.5f);
    }

    /**
     * 系统的方法将dp值转换为px像素值
     * @param convertValue
     * @param mContext
     * @return
     */
    public static int dp2px(float convertValue,Context mContext) 
    {
        return (int) TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP
                ,convertValue
                ,mContext.getResources().getDisplayMetrics());
    }

    /**
     * 将px像素值转换成dp值
     * @param mContext
     * @param convertValue
     * @return
     */
    public static int px2dp(Context mContext , float convertValue)
    {
        final float density = mContext.getResources().getDisplayMetrics().density;
        return (int) (convertValue / density + 0.5f);
    }

    /**
     * 将px像素值转换为sp字体大小
     * @param mContext
     * @param convertValue
     * @return
     */
    public static int px2sp(Context mContext,float convertValue)
    {
        final float fontScale = mContext.getResources().getDisplayMetrics().scaledDensity;
        return (int) (convertValue / fontScale + 0.5f);
    }

    /**
     * 将sp字体大小转换为px像素值 
     * @param mContext
     * @param convertValue
     * @return
     */
    public static int sp2px(Context mContext , float convertValue) 
    {
        final float fontScale = mContext.getResources().getDisplayMetrics().scaledDensity;
        return (int) (convertValue * fontScale + 0.5f);
    }

    /**
     * 系统方法将sp字体大小值转换为px像素值
     * @param convertValue
     * @param mContext
     * @return
     */
    public static int sp2px(float convertValue,Context mContext) 
    {
        return (int) TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_SP
                ,convertValue
                ,mContext.getResources().getDisplayMetrics());
    }

}

(8) MainActivity代码。

package com.example.slidingmenu;

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

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.widget.BaseAdapter;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;


public class MainActivity extends Activity {

    private HSlideMenu sliding_menu;

    private ListView menu_list;
    private List<MenuItem> menuItems;

    @Override
    protected void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(R.layout.main);

        initMenuItem();

        sliding_menu = (HSlideMenu) findViewById(R.id.sliding_menu);
        menu_list = (ListView) findViewById(R.id.menu_list);
        menu_list.setAdapter(new BaseAdapter() 
        {
            @Override
            public View getView(int position, View convertView, ViewGroup parent)
            {
                ViewHolder viewHolder = null;
                MenuItem menuItem = getItem(position);
                if (convertView == null)
                {
                    convertView = getLayoutInflater().inflate(R.layout.menu_item, parent,false);
                    viewHolder = new ViewHolder();
                    viewHolder.itemImg = (ImageView) convertView.findViewById(R.id.id_item_img);
                    viewHolder.itemName = (TextView) convertView.findViewById(R.id.id_item_name);
                    convertView.setTag(viewHolder);
                }
                else
                {
                    viewHolder = (ViewHolder) convertView.getTag();
                }
                viewHolder.itemName.setText(menuItem.getItemName());
                viewHolder.itemImg.setImageResource(menuItem.getItemImg());
                return convertView;
            }

            @Override
            public long getItemId(int position) {
                return position;
            }

            @Override
            public MenuItem getItem(int position) {
                return menuItems.get(position);
            }

            @Override
            public int getCount() {
                return menuItems.size();
            }
            class ViewHolder
            {
                ImageView itemImg;
                TextView itemName;
            }
        });
    }

    private void initMenuItem()
    {
        menuItems = new ArrayList<MenuItem>();
        for (int i = 0; i < 15; i++)
        {
            menuItems.add(new MenuItem(R.drawable.btn_about_us,"Item " + i));
        }
    }

    public void toggle(View view)
    {
        sliding_menu.toggle();
    }
}

到此本篇博客就结束了。愿大家越来越棒。
在这里感谢弘扬大神。谢谢。

三种效果展示下载链接

源码下载

若有问题欢迎留言。

hxy_blog
关注
专栏目录
github上很火的一个Android UI框架，SlidingMenu
07-15
github上很火的一个Android UI框架，SlidingMenu.已经将所需要的Actionbarssherlock和SlidingMenu库打包好。下载后解压并且，将Actionbarssherlock，SlidingMenu和SlidingMenuExample这三个文件夹import到eclipse中，然后直接选中SlidingMenuExample中一个java文件进行运行即可。如果报The container 'Android Dependencies' references non existing library 'xxxxxxx' 错误，则右击library project，选择Build Path->Configure Build Path->Order and Export->Select All将所有包都选上
Android 打造史上最简单的侧滑菜单
09-10
本文将深入探讨如何利用Android SDK来打造一个史上最简单的侧滑菜单，同时也会涉及到一些相关的炫酷效果。 首先，侧滑菜单的基本原理是通过触摸事件监听用户的滑动操作，然后动态调整布局中的视图位置。在Android中...
Android自定义控件——开源组件SlidingMenu的项目集成
Vincent的专栏
09-27 7522
在实际项目开发中，定制一个菜单，能让用户得到更好的用户体验，诚然菜单的样式各种各样，但是有一种菜单——滑动菜单，是被众多应用广泛使用的。关于这种滑动菜单的实现，我在前面的博文中也介绍了如何自定义去实现，请参考Android自定义控件——侧滑菜单，这篇博文描述的是如何从无到有创建一个侧滑菜单的控件，里面的代码不多，但是处理的逻辑和各种效果比较复杂，如果稍有不慎，这种自定义控件就要BUG不断，难以在项目中使用，而且实现的效果比较单一。
Android SlidingMenu 使用详解
weixin_30417487的博客
07-03 485
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/36677279 很多APP都有侧滑菜单的功能，部分APP左右都是侧滑菜单~SlidingMenu 这个开源项目可以很好帮助我们实现侧滑功能，如果对SlidingMenu 还不是很了解的童鞋，可以参考下本篇博客。将侧滑菜单引入项目的方式很多中，本博客先通过例子介绍各种引入方...
Android之SlidingMenu
feihaixin的专栏
04-30 532
SlidingMenu一般称作：侧滑菜单，可以实现比较绚丽的界面，在很多APP中都有应用。 首先要理清思路：SlidingMenu和MainActivity其实使用了两个Layout文件，主页面使用一个，SlidingMenu有个方法setMenu(Layout layout)需要指定一个layout文件。
Android开源库——SlidingMenu
旧日灯塔
05-16 2262
SlidingMenu 概述 一款侧滑菜单的开源类库~ SlidingMenu is an Open Source Android library that allows developers to easily create applications with sliding menus like those made popular in the Google+, YouTube, a...
Android使用自定义控件HorizontalScrollView打造史上最简单的侧滑菜单
01-05
多少都有点复杂，完成以后还需要对滑动冲突等进行处理~~今天给大家带来一个简单的实现，史上最简单有点夸张，但是的确是我目前遇到过的最简单的一种实现~~~ 1、原理分析 既然是侧滑，无非就是在巴掌大的屏幕，塞入...
安卓SlidingMenu各种菜单侧滑菜单相关-史上最牛最完美的slidingMenu沉浸式源代码.rar
07-29
本资源名为“史上最牛、最完美的slidingMenu沉浸式源代码”，提供了实现此类功能的源代码，旨在帮助开发者深入理解并应用SlidingMenu。 SlidingMenu库在Android开发中被广泛使用，它允许开发者轻松地将侧滑菜单集成...
安卓SlidingMenu各种菜单侧滑菜单相关-鸿翔大神的史上简单侧滑据说是史上最简单。确实很简单而且还有福利。我在项目中使用发现还有收缩特效.rar
07-29
在这个项目中，开发者鸿翔大神声称他的实现方法是“史上最简单”，并且包含了一些额外的功能，如收缩特效。 首先，让我们理解一下SlidingMenu的基本概念。它通常被用作Activity的布局，通过手势（通常是向左或向右...
Android SlidingMenu使用教程
haohaiwangji的博客
09-10 445
SlidingMenu使用 在百度找资料时，发现SlidingMenu不能直接使用gradle引入，于是找了好多资料，在GitHub下载，用library导入，还是不行，于是我又琢磨寻找导入的方法，终于在找到gradle导入的方法了。 compile group: 'com.github.thekhaeng', name: 'sliding-menu', version: '1.0.0' 效果图 使用SlidingMenu <RelativeLayout xmlns:android="http:/
android slide menu(左右滑动菜单)
07-18
android slide menu 左右滑动菜单
Android 侧滑菜单 SlidingMenu 简单实现
10-23
该实例用于博客《Android侧滑菜单（SlidingMenu）的简单实现》 http://www.cnblogs.com/scetopcsa/p/4046546.html 该例子中文件夹“ActionBarSherlock”和“SlidingMenulibrary”是开源库，需要被添加到工程文件"test_SlidingMenu"中。
Android 最简单的仿右侧slidemenu
08-09
Android 仿slidemenu，其实就是用布局动画的效果没啥技巧 喜欢拿走。
Android SlidingMenu demo
10-17
AS写的SlidingMenu demo blog:http://blog.csdn.net/shenyuanqing/article/details/49207487
Android中SlidingMenu插件(已封装JAR,无需配置,直接运行)
05-21
SlidingMenu菜单插件,无需再像网上那样配置,导入，已经完美封装为JAR，代码中有使用注释,其它项目直接导入libs中即可使用
集成Android SlidingMenu（SlideMenu）
Zhang Phil
03-05 3294
 左右效果图如下： 左边 右边 Android SlidingMenu（SlideMenu）是一个开源项目框架。在git上的下载地址：https://github.com/jfeinstein10/SlidingMenu 现在基于Fragment给出一个简单的左边+右边的SlidingMenu（SlideMenu） 。首先要引入第三方库，这不比多说，现到git
Android实现滑动菜单—SlidingMenu
v5browser
05-09 103
近期在整理一套Android开发包RTCommon，主要集成一些工具类封装成公共API，同时集成一些第三方控件或是工具包，力图提高Android开发效率和速度，目前编写和集成工作正在逐步进行中，待公共开发包完成时，大家可以使用我的工程作为依赖工程引入自己的项目，使用我封装的一些工具类来提高自己的开发效率。今天要说明的一个第三方控件滑动菜单也是我即将要添加到公共开发包中的一个控件。本Demo是借助j...
Android SlideMenu
weixin_34218579的博客
08-02 152
第三方组件 SlideMenu 实现步骤与主要方法： 1、构建SlidingMenu menu=new SlidingMenu（context） 2、设置模式为左侧边栏 menu.setMode(SlidingMenu.LEFT); 3、设置菜单 View menuView=LayoutInflater.from(this).inflate(news...
【Android UI设计与开发】第16期：滑动菜单栏（一）开源项目SlidingMenu的使用
热门推荐
我是一条寻水的鱼
07-06 5万+
由于最近的工作确实比较忙的原因，所以这个系列的教程有一段时间没有更新了，也请各位读者见谅。 这期博主要给大家带来的是关于滑动菜单栏的实现效果。      一、SlidingMenu简介        相信大家对SlidingMenu都不陌生了，它是一种比较新的设置界面或配置界面的效果，在主界面左滑或者右滑出现设置界面效果，能方便的进行各种操作。很多优秀的应用都采用了这
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值