android 垂直 SeekBar 源代码(VerticalSeekBar)[转]

主要是继承 AbsSeekBar 然后修改下面这些方法

onProgressRefresh（） //当进度条数据更新的时候，例如我们拖动滑动条的时候，这个方法被调用

setThumbPos（） //这个方法是设置Thumb的位置

onDraw（） //这个是负责画界面

onSizeChanged（） //更新画布尺寸

onTouchEvent（） //当触摸屏幕的时候被调用

trackTouchEvent（） //当拖动滑动条的时候，这个被调用

还有就是添加一个接口这个接口是SeekBar 的一个内部接口 public interface OnSeekBarChangeListener

里面有三个方法:

public void onProgressChanged(VerticalSeekBar vBar, int progress,boolean fromUser);
public void onStartTrackingTouch(VerticalSeekBar vBar);
public void onStopTrackingTouch(VerticalSeekBar vBar);

这个接口主要是为外部提供监听。多说无益,大家看源代码明白一点。

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.widget.AbsSeekBar;
import android.widget.SeekBar;  

public class VerticalSeekBar extends AbsSeekBar {   

    private int height = -1;
    private int width = -1;
    public interface OnSeekBarChangeListener
    {
        public void onProgressChanged(VerticalSeekBar vBar, int progress,boolean fromUser);
        public void onStartTrackingTouch(VerticalSeekBar vBar);
        public void onStopTrackingTouch(VerticalSeekBar vBar);
    }  

    private OnSeekBarChangeListener mOnSeekBarChangeListener;
    public VerticalSeekBar(Context context)
    {
        this(context, null);
    }  

    public VerticalSeekBar(Context context, AttributeSet attrs)
    {
        this(context, attrs, android.R.attr.seekBarStyle);
    }  

    public VerticalSeekBar(Context context, AttributeSet attrs, int defstyle)
    {
        super(context, attrs, defstyle);
    }  

    public void setOnSeekBarChangeListener(OnSeekBarChangeListener l)
    {
        mOnSeekBarChangeListener = l;
    }  

    void onStartTrackingTouch()
    {
        if (mOnSeekBarChangeListener != null)
        {
            mOnSeekBarChangeListener.onStartTrackingTouch(this);
        }
    }  

    void onStopTrackingTouch()
    {
        if (mOnSeekBarChangeListener != null)
        {
            mOnSeekBarChangeListener.onStopTrackingTouch(this);
        }
    }  

    void onProgressRefresh(float scale, boolean fromUser)
    {
        Drawable thumb = null;
        try
        {
            Field mThumb_f = this.getClass().getSuperclass().getDeclaredField("mThumb");
            mThumb_f.setAccessible(true);
            thumb = (Drawable)mThumb_f.get(this);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }  

        setThumbPos(getWidth(), thumb, scale, Integer.MIN_VALUE);  

        invalidate();  

        if (mOnSeekBarChangeListener != null) {
            mOnSeekBarChangeListener.onProgressChanged(this, getProgress(), fromUser);
        }
    }  

    private void setThumbPos(int w, Drawable thumb, float scale, int gap)
    {
        int available = 0;
        try
        {  

            int up = getPaddingTop();
            int bottom = getPaddingBottom();  

            available = getHeight() - up - bottom;
            int thumbWidth = thumb.getIntrinsicWidth();
            int thumbHeight = thumb.getIntrinsicHeight();
            available -= thumbWidth;  

            //The extra space for the thumb to move on the track
            available += getThumbOffset() * 2;  

            int thumbPos = (int) (scale * available);  

            int topBound, bottomBound;
            if (gap == Integer.MIN_VALUE) {
                Rect oldBounds = thumb.getBounds();
                topBound = oldBounds.top;
                bottomBound = oldBounds.bottom;
            } else {
                topBound = gap;
                bottomBound = gap + thumbHeight;
            }
            // Canvas will be translated, so 0,0 is where we start drawing
            thumb.setBounds(thumbPos, topBound, thumbPos + thumbWidth, bottomBound);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }  

    }  

     protected synchronized void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
     {
         width = 30;
         height = View.MeasureSpec.getSize(heightMeasureSpec);  

         this.setMeasuredDimension(width, height);
     }   

    protected void onDraw(Canvas c)
    {
        c.rotate(-90);
        c.translate(-height,0);
        super.onDraw(c);
    }  

    protected void onSizeChanged(int w, int h, int oldw, int oldh)
    {
        super.onSizeChanged(h, w, oldw, oldh);
    }   

    @Override
    public boolean onTouchEvent(MotionEvent event)
    {  

        boolean mIsUserSeekable=true;
        try
        {
            Field mIsUserSeekable_f = this.getClass().getSuperclass().getDeclaredField("mIsUserSeekable");
            mIsUserSeekable_f.setAccessible(true);  

            mIsUserSeekable = mIsUserSeekable_f.getBoolean(this);
        }
        catch (Exception e1)
        {
            e1.printStackTrace();
        }  

        if (!mIsUserSeekable || !isEnabled()) {
            return false;
        }  

        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                setPressed(true);
                onStartTrackingTouch();
                trackTouchEvent(event);
                break;  

            case MotionEvent.ACTION_MOVE:
                trackTouchEvent(event);
                Method attemptClaimDrag;
                try
                {
                    attemptClaimDrag = this.getClass().getSuperclass().getDeclaredMethod("attemptClaimDrag");
                    attemptClaimDrag.setAccessible(true);
                    attemptClaimDrag.invoke(this);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                break;  

            case MotionEvent.ACTION_UP:
                trackTouchEvent(event);
                onStopTrackingTouch();
                setPressed(false);
                // ProgressBar doesn't know to repaint the thumb drawable
                // in its inactive state when the touch stops (because the
                // value has not apparently changed)
                invalidate();
                break;  

            case MotionEvent.ACTION_CANCEL:
                onStopTrackingTouch();
                setPressed(false);
                invalidate(); // see above explanation
                break;
        }
        return true;
    }  

    protected void trackTouchEvent(MotionEvent event)
    {  

        final int height = getHeight();
        final int available = height - getPaddingLeft() - getPaddingRight();
        int y = (int)(height - event.getY());
        float scale;
        float progress = 0;
        if (y < getPaddingLeft()) {
            scale = 0.0f;
        } else if (y > height - getPaddingRight()) {
            scale = 1.0f;
        } else {
            scale = (float)(y - getPaddingLeft()) / (float)available;
            float mTouchProgressOffset = 0.0f;
            try
            {
                Field mTouchProgressOffset_f = this.getClass().getSuperclass().getDeclaredField("mTouchProgressOffset");
                mTouchProgressOffset_f.setAccessible(true);
                mTouchProgressOffset = mTouchProgressOffset_f.getFloat(this);
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
            progress = mTouchProgressOffset;
        }  

        final int max = getMax();
        progress += scale * max;  

        try
        {
            Method setProgress = this.getClass().getSuperclass().getSuperclass().getDeclaredMethod("setProgress", int.class,boolean.class);
            setProgress.setAccessible(true);
            setProgress.invoke(this, (int)progress, true);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
}  

[转载链接地址]http://blog.csdn.net/failure01/article/details/8577675