自定义控件之(上下左右)侧滑页面

最新推荐文章于 2024-07-05 23:22:02 发布
最新推荐文章于 2024-07-05 23:22:02 发布
阅读量382 收藏
点赞数
分类专栏： Android系列 文章标签： 侧滑界面 自定义控件实现android侧滑栏 android侧滑栏上下左右方向滑入滑出 android侧滑栏的简单实现 如何实现android侧滑栏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33429583/article/details/77600320
版权

1.效果图（还有顶部及底部就省略）

2.代码实现

 

1）java代码
/**
 * Created by 刘强lq
 *
 * 自定义控件 上下左右滑出界面
 */
public class SliderPager extends FrameLayout {

    //右边侧滑
    public static final int MODEL_RIGHT = 0;

    //左边侧滑
    public static final int MODEL_LEFT = 1;

    //顶部滑出
    public static final int MODEL_TOP = 2;

    //低部滑出
    public static final int MODEL_BUTTOM = 3;

    /**
     * 存放主页内容的View
     */
    private ViewGroup mContentView;
    /**
     * 存放侧滑栏内容的View
     */
    private ViewGroup mSiderView;
    /**
     * 存放侧滑栏内容View宽
     */
    private int mSiderViewWidth;
    /**
     * 存放侧滑栏内容View高
     */
    private int mSiderViewHeight;
    /**
     * SliderPager布局的宽
     */
    private int mSliderPagerWidth;
    /**
     * SliderPager布局的高
     */
    private int mSliderPagerHeight;
    /**
     * 侧滑栏显示的模式
     */
    private int mSlidingModel;
    /**
     * 显示部分
     */
    private int mSlidingShowLeftOrRightValue = 0;
    /**
     * 平滑者
     */
    private Scroller mScroller;

    /**
     * 侧滑页面是否打开 默认是关闭的状态
     */
    private boolean mIsOpenPager = false;

    /**
     * 如果mContentView中存在ViewPager的话 针对于左右滑动
     */
    private ViewPager mViewPager;

    /**
     * 记录当前mViewPager选中的第几个item（如果存在ViewPager的话）
     */
    private int mCurrentViewPagerPosition = 0;

    /**
     * 如果mSiderView中存在ListView的话 针对于上下滑动
     */
    private ListView mListView;

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

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

    public SliderPager(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mScroller = new Scroller(context);
        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.SliderPager);
        int indexCount = typedArray.getIndexCount();
        for (int i = 0; i < indexCount; i++) {
            int index = typedArray.getIndex(i);
            switch (index) {
                case R.styleable.SliderPager_slidingModel:
                    mSlidingModel = typedArray.getInt(index, 0);
                    break;
                case R.styleable.SliderPager_slidingShowLeftOrRight:
                    mSlidingShowLeftOrRightValue = typedArray.getDimensionPixelSize(index, (int) TypedValue.applyDimension(
                            TypedValue.COMPLEX_UNIT_SP, 16, getResources().getDisplayMetrics()));
                    break;
                default:
                    break;
            }
        }
        typedArray.recycle();
    }

    /**
     * 孩子View的定位
     */
    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);
        switch (mSlidingModel) {
            case 0: //侧滑在右边
                mSiderView.layout(mSliderPagerWidth, 0, mSliderPagerWidth + mSiderViewWidth, mSiderViewHeight);
                break;
            case 1:  //侧滑在左边
                mSiderView.layout(0 - mSiderViewWidth, 0, 0, mSiderViewHeight);
                break;
            case 2://侧滑在上边
                mSiderView.layout(0, 0 - mSiderViewHeight, mSliderPagerWidth, 0);
                break;
            case 3://侧滑在下边
                mSiderView.layout(0, mSiderViewHeight, mSliderPagerWidth, mSliderPagerHeight + mSiderViewHeight);
                break;
            default:
                break;
        }
    }

    /**
     * 获取宽高
     *
     * @param widthMeasureSpec
     * @param heightMeasureSpec
     */
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        mSiderViewWidth = mSiderView.getMeasuredWidth() - mSlidingShowLeftOrRightValue;
        mSiderViewHeight = mSiderView.getMeasuredHeight();
        mSliderPagerWidth = getMeasuredWidth();
        mSliderPagerHeight = getMeasuredHeight();
    }

    /**
     * 加载布局完后回调
     */
    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
        mContentView = (ViewGroup) getChildAt(0);
        //如果mContentView中包含ViewPager 取出
        for (int i = 0; i < mContentView.getChildCount(); i++) {
            View childView = mContentView.getChildAt(i);
            if (childView instanceof ViewPager) {
                mViewPager = (ViewPager) childView;
            }
        }
        mSiderView = (ViewGroup) getChildAt(1);
        //如果mSiderView中包含ListView 取出
        for (int i = 0; i < mSiderView.getChildCount(); i++) {
            View childView = mSiderView.getChildAt(i);
            if (childView instanceof ListView) {
                mListView = (ListView) childView;
            }
        }
        mContentView.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                // Log.e("liuqiang", "isOpenPager:" + mIsOpenPager);
                if (mIsOpenPager) {
                    closeSlidePager();
                }
            }
        });
        if (mViewPager != null) {
            mViewPager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {
                @Override
                public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
                    mCurrentViewPagerPosition = position;
                }

                @Override
                public void onPageSelected(int position) {
                    mCurrentViewPagerPosition = position;
                }

                @Override
                public void onPageScrollStateChanged(int state) {
                }
            });
        }
    }

    /**
     * 记录手指按下开始的X轴的位置
     */
    private float mStartX;
    /**
     * 记录手指按下开始的Y轴的位置
     */
    private float mStartY;

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        super.onTouchEvent(event);
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mStartX = event.getX();
                mStartY = event.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                float endX = event.getX();
                float endY = event.getY();
                //得到X轴的偏移量
                int distanceX = (int) (endX - mStartX);
                int scrollToX = getScrollX() - distanceX;
                //得到Y轴的偏移量
                int distanceY = (int) (endY - mStartY);
                int scrollToY = getScrollY() - distanceY;
                switch (mSlidingModel) {
                    case 0://从右往左
                        if (scrollToX < -50) {
                            scrollToX = 0;
                        } else if (scrollToX > mSiderViewWidth) {
                            scrollToX = mSiderViewWidth;
                        }
                        scrollTo(scrollToX, getScrollY());
                        break;
                    case 1://从左往右
                        if (scrollToX > 50) {
                            scrollToX = 0;
                        } else if (scrollToX < -mSiderViewWidth) {
                            scrollToX = -mSiderViewWidth;
                        }

                        scrollTo(scrollToX, getScrollY());
                        break;
                    case 2://从上往下
                        if (scrollToY > 50) {
                            scrollToY = 0;
                        } else if (scrollToY < -mSiderViewHeight) {
                            scrollToY = -mSiderViewHeight;
                        }
                        scrollTo(getScrollX(), scrollToY);
                        break;
                    case 3://从下往上
                        if (scrollToY < -50) {
                            scrollToY = 0;
                        } else if (scrollToY > mSiderViewHeight) {
                            scrollToY = mSiderViewHeight;
                        }
                        scrollTo(getScrollX(), scrollToY);
                        break;
                    default:
                        break;
                }
                mStartX = endX;
                mStartY = endY;
                break;
            case MotionEvent.ACTION_UP:
                int scrollX = getScrollX();
                int scrollY = getScrollY();
                switch (mSlidingModel) {
                    case 0:
                        if (scrollX > mSiderViewWidth / 2) {
                            mScroller.startScroll(getScrollX(), getScrollY(), mSiderViewWidth - getScrollX(), getScrollY()
                                    , Math.abs(mSiderViewWidth - getScrollX()));
                            mIsOpenPager = true;
                            mIntercept = false;
                        } else {
                            mScroller.startScroll(getScrollX(), getScrollY(), 0 - getScrollX(), getScrollY(), Math.abs(0 - getScrollX()));
                            mIsOpenPager = false;
                            mIntercept = false;
                        }
                        break;
                    case 1:
                        if (scrollX < -(mSiderViewWidth / 2)) {
                            mScroller.startScroll(getScrollX(), getScrollY(), -mSiderViewWidth - getScrollX(), getScrollY(),
                                    Math.abs(-mSiderViewWidth - getScrollX()));
                            mIsOpenPager = true;
                            mIntercept = false;
                        } else {
                            mScroller.startScroll(getScrollX(), getScrollY(), 0 - getScrollX(), getScrollY(), Math.abs(0 - getScrollX()));
                            mIsOpenPager = false;
                            mIntercept = false;
                        }
                        break;
                    case 2:
                        if (scrollY < -(mSiderViewHeight / 2)) {
                            mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), -mSiderViewHeight - getScrollY(),
                                    Math.abs(-mSiderViewHeight - getScrollY()));
                            mIsOpenPager = true;
                            mIntercept = false;
                        } else {
                            mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), 0 - getScrollY(), Math.abs(0 - getScrollY()));
                            mIsOpenPager = false;
                            mIntercept = false;
                        }
                        break;
                    case 3:
                        if (scrollY > mSiderViewHeight / 2) {
                            mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), mSiderViewHeight - getScrollY()
                                    , Math.abs(mSiderViewHeight - getScrollY()));
                            mIsOpenPager = true;
                            mIntercept = false;
                        } else {
                            mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), 0 - getScrollY(), Math.abs(0 - getScrollY()));
                            mIsOpenPager = false;
                            mIntercept = false;
                        }
                        break;
                    default:
                        break;
                }
                invalidate();
                break;
        }
        return onInterceptTouchEvent(event);
    }

    /**
     * mScrollerd的回调
     */
    @Override
    public void computeScroll() {
        if (mScroller.computeScrollOffset()) {
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
            invalidate();
        }
    }

    /**
     * 事件拦截 记录手指按下开始的X，Y轴的位置
     */
    private float mInterceptStartX;
    private float mInterceptStartY;

    /**
     * 事件是否拦截 默认不拦截
     */
    private boolean mIntercept = false;

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mInterceptStartX = ev.getX();
                mInterceptStartY = ev.getY();
                break;
            case MotionEvent.ACTION_MOVE:
                float interceptEndX = ev.getX();
                float interceptEndY = ev.getY();
                int distanceX = (int) (interceptEndX - mInterceptStartX);
                int distanceY = (int) (interceptEndY - mInterceptStartY);

                //对每一个滑动的模式进行拦截判断
                switch (mSlidingModel) {
                    case 0: //从右滑出
                        if (mIsOpenPager) { //要关闭的时候
                            if (distanceX > 0) {
                                mIntercept = true;
                            } else if (distanceX < 0) {
                                mIntercept = false;
                            } else if (Math.abs(distanceY) > 50) {
                                mIntercept = false;
                            }
                        } else { //要打开的时候
                            if (distanceX > 0) {
                                mIntercept = false;
                            } else if (distanceX < 0) {
                                if (mViewPager != null) {
                                    if (mCurrentViewPagerPosition == mViewPager.getChildCount()) {
                                        mIntercept = true;
                                    } else {
                                        mIntercept = false;
                                    }
                                } else {
                                    mIntercept = true;
                                }
                            } else if (Math.abs(distanceY) > 50) {
                                mIntercept = false;
                            }
                        }

                        break;
                    case 1:
                        //左滑动的情况下处理事件的拦截
                        //对左滑动的页面中嵌套scrollView等等控件时的拦截
                        if (mIsOpenPager) { //要关闭的时候
                            if (distanceX > 0) {
                                mIntercept = false;
                            } else if (distanceX < 0) {
                                mIntercept = true;
                            } else if (Math.abs(distanceY) > 50) {
                                mIntercept = true;
                            }
                        } else { //要打开的时候
                            if (distanceX > 0) {
                                if (mCurrentViewPagerPosition == 0) {
                                    mIntercept = true;
                                } else {
                                    mIntercept = false;
                                }
                            } else if (distanceX < 0) {
                                mIntercept = false;
                            } else if (Math.abs(distanceY) > 50) {
                                mIntercept = false;
                            }
                        }
                        break;
                    case 2: //顶部滑出
                        if (distanceY < 0) { //从下往上滑
                            if (mListView != null) {
                                if (mListView.getLastVisiblePosition() == (mListView.getCount() - 1) && mListView.getChildCount() > 0) {
                                    //判定滑动到了当前一屏显示的ListView最后个条目
                                    mIntercept = true;
                                } else {
                                    mIntercept = false;
                                }
                            }
                        } else {
                            mIntercept = false;
                        }
                        break;
                    case 3:
                        if (distanceY > 0) { //从上往下滑
                            if (mListView != null) {
                                if (mListView.getFirstVisiblePosition() == 0 && mListView.getChildCount() > 0) {
                                    //判定滑动到了当前一屏显示的ListView第一个条目
                                    mIntercept = true;
                                } else {
                                    mIntercept = false;
                                }
                            }
                        } else {
                            mIntercept = false;
                        }
                        break;
                }

                mInterceptStartX = interceptEndX;
                mInterceptStartY = interceptEndY;
                break;
            case MotionEvent.ACTION_UP:
                break;
        }
        return mIntercept;
    }

    /**
     * 打开侧滑页面
     */
    public void openSlidePager() {
        switch (mSlidingModel) {
            case 0:
                mScroller.startScroll(getScrollX(), getScrollY(), mSiderViewWidth - getScrollX(), getScrollY()
                        , Math.abs(mSiderViewWidth - getScrollX()));
                break;
            case 1:
                mScroller.startScroll(getScrollX(), getScrollY(), -mSiderViewWidth - getScrollX(), getScrollY(),
                        Math.abs(-mSiderViewWidth - getScrollX()));
                break;
            case 2:
                mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), -mSiderViewHeight - getScrollY(),
                        Math.abs(-mSiderViewHeight - getScrollY()));
                break;
            case 3:
                mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), mSiderViewHeight - getScrollY()
                        , Math.abs(mSiderViewHeight - getScrollY()));
                break;
            default:
                break;
        }
        invalidate();
        mIsOpenPager = true;
    }

    /**
     * 关闭侧滑页面
     */
    public void closeSlidePager() {
        switch (mSlidingModel) {
            case 0:
                mScroller.startScroll(getScrollX(), getScrollY(), 0 - getScrollX(), getScrollY(),
                        Math.abs(0 - getScrollX()));
                invalidate();
                break;
            case 1:
                mScroller.startScroll(getScrollX(), getScrollY(), 0 - getScrollX(), getScrollY(), Math.abs(0 - getScrollX()));
                invalidate();
                break;
            case 2:
                mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), 0 - getScrollY(), Math.abs(0 - getScrollY()));
                invalidate();
                break;
            case 3:
                mScroller.startScroll(getScrollX(), getScrollY(), getScrollX(), 0 - getScrollY(), Math.abs(0 - getScrollY()));
                invalidate();
                break;
            default:
                break;
        }
        mIsOpenPager = false;
    }

    /**
     * 获取滑动方向
     *
     * @return
     */
    public int getSlidingModel() {
        return mSlidingModel;
    }

    /**
     * 设置滑动方向
     *
     * @param slidingModel
     */
    public void setSlidingModel(int slidingModel) {
        mSlidingModel = slidingModel;
        invalidate();
    }

    /**
     * 获取左右页面滑出留的的距离
     *
     * @return
     */
    public int getSlidingShowLeftOrRightValue() {
        return mSlidingShowLeftOrRightValue;
    }

    /**
     * 设置左右滑出页面留的的距离
     *
     * @param slidingShowLeftOrRightValue
     */
    public void setSlidingShowLeftOrRightValue(int slidingShowLeftOrRightValue) {
        mSlidingShowLeftOrRightValue = px2dp(slidingShowLeftOrRightValue);
        invalidate();
    }

    /**
     * 当前打开滑动页面的状态
     *
     * @return
     */
    public boolean isOpenPager() {
        return mIsOpenPager;
    }

    /**
     * 将px转化为dip
     *
     * @param pxValue
     * @return
     */
    private int px2dp(int pxValue) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                pxValue, getResources().getDisplayMetrics());
    }
}
 
2）属性
 
<declare-styleable name="SliderPager">
    <attr name="slidingModel" format="enum">
        <enum name="sliding_right" value="0"/>
        <enum name="sliding_left" value="1"/>
        <enum name="sliding_top" value="2"/>
        <enum name="sliding_buttom" value="3"/>
    </attr>
    <attr name="slidingShowLeftOrRight" format="dimension"/>
</declare-styleable>

 

由于时间问题，只能将就,先......

 

 

LQ-刘强
关注
专栏目录
java 抽屉效果_侧滑-抽屉界面在主界面的左边或者右边,拉出来的效果
weixin_42498643的博客
02-27 251
public class MainActivity extendsActivity{privateDrawerLayout drawerLayout;privateFrameLayout content_frame;privateListView drawer_list;@Overrideprotected voidonCreate(Bundle savedInstanceState) {supe...
自定义的菜单键+DrawerLayout(抽屉控件)实现侧滑
ysnhzk的博客
10-30 555
上章讲了自定义菜单键的实现 ，本章结合DrawerLayout实现侧滑功能。 主界面布局 &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match...
懒人原生移动网页侧滑栏滑动效果
06-12
效果描述： 闲来无事，给大家写了一个首页网页常见的侧栏滑动效果 点击左上角按钮，侧栏可以显示或者隐藏 本效果主要采用CSS3中的transform预计translate属性实现，点击按钮分别给侧栏增加或者删除对应的class名称，然后移动body的位置，看起来是不是很简单？ 另外，在这里跟大伙儿声明下，以后懒人原创的移动效果，将逐步屏蔽掉jQuery插件，因为这家伙太影响移动网页性能了。本效果亦是采用原生的JavaScript代码实现，不依赖任何插件 使用方法： 1、将head中的CSS样式引入到你的网页中 2、将body中的代码部分拷贝到你需要的网页中即可
左右滑动自定义控件
奋斗
04-27 5115
最近做了一个外包项目，用了滑动的按钮显示的部分
b站材料1-代码之侧滑界面的java文件
weixin_43589465的博客
06-03 1万+
说明 b站教学视频略过了这个部分，考虑到讲解难度和大家看b站号也是为了快速掌握，所以这个部分我直接把代码贴到这。 这份代码我应该是借鉴的某位大佬的写法，具体来源我不记得了，如果有侵权的，请联系我删除。 代码 package com.example.eva; import android.content.Context; import android.util.AttributeSet; import android.view.MotionEvent; import android.view.View;
java滑动_java实现菜单滑动效果
weixin_39657444的博客
02-12 127
public class MenuScrollerActivity extends BaseGameActivity implements IScrollDetectorListener, IOnSceneTouchListener, IClickDetectorListener {// =======================================================...
用ViewDragHelper自定义侧滑菜单——浅析源码解决与ScrollView的滑动冲突
大尧的博客
04-11 935
上篇博文带大家分析学习了关于ViewDragHelper的简单基本用法，本篇将带大家用ViewDragHelper做一个简单侧滑菜单的Demo，并通过对ViewDragHelper源码的简单分析，找到其与ScrollView滑动事件冲突的原因与解决方法。闲话少说，直入正题，首先来看一下运行效果。 首先，我们先看一下布局文件，以便整体了解界面布局结构： <LinearLayout xml
android 控件拖拽功能,一个可拖拽，移动，自由组合子控件的视图控件，让开发更简单...
weixin_28844235的博客
05-25 1627
今天给大家推荐一个自由拖拽，自由组合的控件，这个控件是我自定义写的。通过它，我们可以自由拖拽，自由组合实现一个界面，满足一个用户自由组合界面的需求。这里不是通过自由拖拽控件，来快速开发一个界面，而且更人性化的让用户去自由组合一个界面。前言最近有一个项目，有一个主界面，界面上有很多控件或者有多个 fragment 组成，大小不一，而且由于用户需要，需要自由拖动和自由组合，形成用户自己需要的组合成的模...
Android中自定上下拖动Viewpager
renkchina
08-03 814
我们在淘宝上购物的时候，在浏览商品页面时，有看到有”继续拖动，查看图文详情”，实则就是纵向拖动的Viewpager。今天我们就要来实现它。先上效果图。 要实现上面的效果，我们今天必须学习两样东西，一个就是ViewDragHelper，另外一个就是GestureDetectorCompat。好了，我们先，来看看View的拖动工具类。ViewDragHelper的基本用法很简单。官方自带的Draw
详解RecyclerView+BGARefreshLayout实现自定义下拉刷新、上拉加载和侧滑删除效果
热门推荐
Mr.Feng
12-08 1万+
使用Recycler+BGARefreshLayout实现自定义下拉刷新、上拉加载和侧滑删除效果，适用于任何布局
走马灯效果（左右的，上下的）
09-12
这是两个不同的走马灯效果，一个是上下滚动的，一个事左右滚动的，都是用div层实现的，直接用txt文档打开就可以看代码了！！
控件内容从右向左排列
加你油的专栏
03-05 2209
写一个小程序时有一个这样的需求： 需要让stackpanel中的控件的排列顺序为从右向左排列。可是不知道设置什么属性，后来搜到非stackpanel控件有可以设置属性FlowDirection="RightToLeft"来实现内容从右向左排列。当然很多控件都有这个属性，包括stackpanel。
构建滑块组件_第 1 部分
最新发布
分享学习网络的点点滴滴
07-05 331
● 本次将和大家一起学习实现滑块的功能● 由于这有些错乱，我们将用图片来代替，以实现功能● 这里我们简单的说一下原理，如下图所示，通过改变tanslateX的值来达到滑动的效果，所以最核心的就是我们需要通过JavaScript来改变图片的切换。
Android自定义控件7----滑动动画scrollTo/scrollBy使用
翟浩浩Android专栏
11-06 2345
#移动动画的三种方式：   1使用scrollTo/scrollBy    用于做View的滑动，它可以比较方便实现滑动的效果，并且不影响内部元素的点击事件；它只能滑动View的内容，并不能滑动View本身。    调用View的scrollTo()和scrollBy()是用于滑动View中的内容，而不是把某个View的位置进行改变。如果想改变莫个View在屏幕中的位置，可以使用如下
Android自定义控件6----继承ViewGroup自定义侧滑删除菜单
翟浩浩Android专栏
11-05 320
效果图： 项目结构： 核心代码： MainActivity中 package com.example.cehua; import android.app.Activity; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.widget.L
关于view.getScrollX()和view.getScrollY()以及OnGestureListener.onScroll()中distanceX,distanceY的说明
yizunda的专栏
12-24 1433
关于view.getScrollX()和view.getScrollY()首先来看源码说明： view.getScrollX(): Return the scrolled left position of this view. This is the left edge of the displayed part of your view. You do not need to draw any
关于getScrollX的理解
kenzo0的博客
01-30 785
对getScroll这个函数一直不太理解，今天做了点小实验，记录一下。场景描述：类似qq菜单那种界面，右划回出现一个抽屉菜单那种东西实验1：对着屏幕不同地方点击，log打出getScrollX坐标，得到的结果一样。 实验二：对着屏幕不同地方点击，log打出getX坐标。得到不同结果 而且，当手指在屏幕边缘时，getX的值就为0： 根据以上实验，能得出的结论： 1、getX的范围就是在这个
getScrollX()的理解
u014520797的专栏
08-30 4776
1、我在一个ViewGroup中添加图片。实际上ViewGroup的大小是超过屏幕的大小的 所以必然会隐藏了View，我缩写的demo是初始状态后， 首先只能向右滑动，然后才能向左滑动，回到初始状态。 2、初始点击时的x坐标-移动时得到的x坐标，movex是滑动的时候跟着变化的一个值，所以diff也是一个变化的值当手从A（20，80）向右 滑到
自定义button,实现图片和文字上下排列，左右排列等等
fql_zlyy的专栏
05-21 2356
public class AlImageButtonView extends LinearLayout { private ImageView mButtonImage = null; private TextView mButtonText = null; private Context mContext; public AlImageButtonView(C
Android自定义控件：简易实现侧滑菜单教程
本文档详细介绍了如何在Android开发中利用自定义控件实现一个简单且直观的侧滑菜单效果。作者首先强调了传统的侧滑菜单实现方式往往涉及复杂的ViewGroup管理和滑动逻辑，如Scroller的使用以及处理滑动冲突。然而，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值