使用自定义ui元素查找栏功能

Question

我正在寻找具有s搜索栏功能的海关滑块组件。

我一直在关注本教程 http://www.androidenea.com/2011/10/creating-custom-view-part-1-graphics.html

然而，我希望使用我自己的图形，而不是.9.png图形。我还需要调整搜索栏和滑块的大小。

如果有人可以提供帮助，我会非常感激。我把它调到一个阶段，我调整了大小并改变了图形，然而，当我用手指向上滑动时，我需要滑动到屏幕顶部，以便我的seebar到达框架的顶部。 / p>

请提供任何帮助，这是我迄今为止实施的内容：

package com.enea.training.customview;

import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;

public class CustomSlider extends View {
    interface CustomSliderPositionListener {
        void onPositionChange(float newPosition);
    }

    private final Drawable               mIndicator;
    private final Drawable               mBackground;
    private float                        mMin;
    private float                        mMax;
    private float                        mPosition;
    private Rect                         mViewRect;
    private int                          mIndicatorOffset;
    private int                          mIndicatorMaxPos;
    private int                          mIndicatorMinPos;
    private CustomSliderPositionListener mPositionListener;
    private boolean                      mIsVertical;

    public CustomSlider(final Context context) {
        this(context, null, 0);
    }

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

    public CustomSlider(final Context context, final AttributeSet attrs,
                        final int defStyle) {
        super(context, attrs, defStyle);

        final TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.CustomSlider);
        final int vertical = a.getInt(R.styleable.CustomSlider_orientation, 0);
        mIsVertical = (vertical != 0);

        final float max = a.getFloat(R.styleable.CustomSlider_max, 1.0f);
        final float min = a.getFloat(R.styleable.CustomSlider_min, -1.0f);
        setMinMax(min, max);

        final Resources res = context.getResources();
        if (mIsVertical) {
            mIndicator = res.getDrawable(R.drawable.beer_with_arrows);
            mBackground = res.getDrawable(R.drawable.glass);
        } else {
            mIndicator = res.getDrawable(R.drawable.indicator_horizontal);
            mBackground = res.getDrawable(R.drawable.background_horizontal);
        }

        mPosition =(mMax - 1) ;/// 2 + mMin;
        mPositionListener = null;
        setOnTouchListener(new OnTouchListener() {
            public boolean onTouch(final View v, final MotionEvent event) {
                final float pos;
                if (mIsVertical) {
                    float divisor = mIndicatorMinPos-mIndicatorMaxPos;
                    pos = (mMax - ((mMax - mMin) / divisor)
                            * event.getY());
                } else {
                    pos = (mMin + ((mMax - mMin) / (mIndicatorMaxPos - mIndicatorMinPos))
                            * event.getX());
                }
                setPosition(pos);
                return true;
            }
        });
    }

    @Override
    protected void onDraw(final Canvas canvas) {
        if (mViewRect == null) {
            mViewRect = new Rect();
            mViewRect.set(20,20,20,20);
            getDrawingRect(mViewRect);
            if (mIsVertical) {
                mIndicatorOffset = mIndicator.getIntrinsicHeight();
                mIndicatorMaxPos = mViewRect.top + mIndicatorOffset;
                mIndicatorMinPos = mViewRect.bottom - mIndicatorOffset;
            } else {
                mIndicatorOffset = mIndicator.getIntrinsicWidth();
                mIndicatorMaxPos = mViewRect.right - mIndicatorOffset;
                mIndicatorMinPos = mViewRect.left + mIndicatorOffset;
            }
            mBackground.setBounds(mViewRect.left, mViewRect.top, mViewRect.right,
                    mViewRect.bottom);
        }

        final float pos;
        final int left;
        final int right;
        final int top;
        final int bottom;
        if (mIsVertical) {
            pos = mIndicatorMaxPos
                    + ((mIndicatorMinPos - mIndicatorMaxPos) / (mMax - mMin))
                    * (mMax - mPosition);
            left = mViewRect.centerX() - (mIndicator.getIntrinsicWidth() / 2);
            top = (int) pos - (mBackground.getIntrinsicHeight() / 2);
        } else {
            pos = mIndicatorMinPos
                    + ((mIndicatorMaxPos - mIndicatorMinPos) / (mMax - mMin))
                    * (mPosition - mMin);
            left = (int) pos - (mIndicator.getIntrinsicWidth() / 2);
            top = mViewRect.centerY() - (mIndicator.getIntrinsicHeight() / 2);
        }
        right = left + mIndicator.getIntrinsicWidth();
        bottom = top + mIndicator.getIntrinsicHeight();
        mIndicator.setBounds(left, top, right, bottom);
        mIndicator.draw(canvas);
        mBackground.draw(canvas);

    }

    @Override
    protected void onMeasure(final int widthMeasureSpec,
                             final int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        if (mIsVertical) {
            int desiredWidth = 100;
            int desiredHeight = 100;

            int widthMode = MeasureSpec.getMode(widthMeasureSpec);
            int widthSize = MeasureSpec.getSize(widthMeasureSpec);
            int heightMode = MeasureSpec.getMode(heightMeasureSpec);
            int heightSize = MeasureSpec.getSize(heightMeasureSpec);

            int width;
            int height;

            //Measure Width
            if (widthMode == MeasureSpec.EXACTLY) {
                //Must be this size
                width = widthSize;
            } else if (widthMode == MeasureSpec.AT_MOST) {
                //Can't be bigger than...
                width = Math.min(desiredWidth, widthSize);
            } else {
                //Be whatever you want
                width = desiredWidth;
            }

            //Measure Height
            if (heightMode == MeasureSpec.EXACTLY) {
                //Must be this size
                height = heightSize;
            } else if (heightMode == MeasureSpec.AT_MOST) {
                //Can't be bigger than...
                height = Math.min(desiredHeight, heightSize);
            } else {
                //Be whatever you want
                height = desiredHeight;
            }

            //MUST CALL THIS
            setMeasuredDimension(width, height);


            //setMeasuredDimension(getSuggestedMinimumWidth(),getSuggestedMinimumHeight());
            //  setMeasuredDimension(mIndicator.getIntrinsicWidth(), getMeasuredHeight());
        } else {
            setMeasuredDimension(getMeasuredWidth(), mBackground.getIntrinsicHeight());
        }
    }

    public float getMin() {
        return mMin;
    }

    public float getMax() {
        return mMax;
    }

    public float getPosition() {
        return mPosition;
    }

    public void setPosition(float position) {
        position = within(position, mMin, mMax);
        if (position != mPosition) {
            mPosition = position;
            invalidate();
            if (mPositionListener != null) {
                mPositionListener.onPositionChange(mPosition);
            }
        }
    }

    private static float within(float position, final float min, final float max) {
        if (position < min) {
            position = min;
        }
        if (position > max) {
            position = max;
        }
        return position;
    }

    public void setMinMax(final float min, final float max) {
        if ((min != mMin) || (max != mMax)) {
            if (min > max) {
                throw new IllegalArgumentException(
                        "setMinMax: min must be smaller than max.");
            }
            mMin = min;
            mMax = max;
            setPosition(mPosition);
            invalidate();
        }
    }

    public void setPositionListener(final CustomSliderPositionListener listener) {
        mPositionListener = listener;
    }
}

**** **** EDIT

所以下面我已经做了一个粗略的图片来展示我正在尝试做的事情。所以我的自定义视图包括滑块和框架（背景和指示器）。用户在红色背景内上下拖动滑块（指示器）..

到目前为止，我会提供任何帮助并感谢您的帮助......

我