src/com/android/musicfx/seekbar/AbsSeekBar.java - platform/packages/apps/MusicFX - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.musicfx.seekbar;

 import android.content.Context;
 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.KeyEvent;
 import android.view.MotionEvent;

 public abstract class AbsSeekBar extends ProgressBar {
     private Drawable mThumb;
     private int mThumbOffset;

     /**
      * On touch, this offset plus the scaled value from the position of the
      * touch will form the progress value. Usually 0.
      */
     float mTouchProgressOffset;

     /**
      * Whether this is user seekable.
      */
     boolean mIsUserSeekable = true;

     boolean mIsVertical = false;
     /**
      * On key presses (right or left), the amount to increment/decrement the
      * progress.
      */
     private int mKeyProgressIncrement = 1;

     private static final int NO_ALPHA = 0xFF;
     private float mDisabledAlpha;

     public AbsSeekBar(Context context) {
         super(context);
     }

     public AbsSeekBar(Context context, AttributeSet attrs) {
         super(context, attrs);
     }

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

         TypedArray a = context.obtainStyledAttributes(attrs,
                 com.android.internal.R.styleable.SeekBar, defStyle, 0);
         Drawable thumb = a.getDrawable(com.android.internal.R.styleable.SeekBar_thumb);
         setThumb(thumb); // will guess mThumbOffset if thumb != null...
         // ...but allow layout to override this
         int thumbOffset = a.getDimensionPixelOffset(
                 com.android.internal.R.styleable.SeekBar_thumbOffset, getThumbOffset());
         setThumbOffset(thumbOffset);
         a.recycle();

         a = context.obtainStyledAttributes(attrs,
                 com.android.internal.R.styleable.Theme, 0, 0);
         mDisabledAlpha = a.getFloat(com.android.internal.R.styleable.Theme_disabledAlpha, 0.5f);
         a.recycle();
     }

     /**
      * Sets the thumb that will be drawn at the end of the progress meter within the SeekBar.
      * <p>
      * If the thumb is a valid drawable (i.e. not null), half its width will be
      * used as the new thumb offset (@see #setThumbOffset(int)).
      *
      * @param thumb Drawable representing the thumb
      */
     public void setThumb(Drawable thumb) {
         boolean needUpdate;
         // This way, calling setThumb again with the same bitmap will result in
         // it recalcuating mThumbOffset (if for example it the bounds of the
         // drawable changed)
         if (mThumb != null && thumb != mThumb) {
             mThumb.setCallback(null);
             needUpdate = true;
         } else {
             needUpdate = false;
         }
         if (thumb != null) {
             thumb.setCallback(this);

             // Assuming the thumb drawable is symmetric, set the thumb offset
             // such that the thumb will hang halfway off either edge of the
             // progress bar.
             if (mIsVertical) {
                 mThumbOffset = thumb.getIntrinsicHeight() / 2;
             } else {
                 mThumbOffset = thumb.getIntrinsicWidth() / 2;
             }

             // If we're updating get the new states
             if (needUpdate &&
                     (thumb.getIntrinsicWidth() != mThumb.getIntrinsicWidth()
                         || thumb.getIntrinsicHeight() != mThumb.getIntrinsicHeight())) {
                 requestLayout();
             }
         }
         mThumb = thumb;
         invalidate();
         if (needUpdate) {
             updateThumbPos(getWidth(), getHeight());
             if (thumb.isStateful()) {
                 // Note that if the states are different this won't work.
                 // For now, let's consider that an app bug.
                 int[] state = getDrawableState();
                 thumb.setState(state);
             }
         }
     }

     /**
      * @see #setThumbOffset(int)
      */
     public int getThumbOffset() {
         return mThumbOffset;
     }

     /**
      * Sets the thumb offset that allows the thumb to extend out of the range of
      * the track.
      *
      * @param thumbOffset The offset amount in pixels.
      */
     public void setThumbOffset(int thumbOffset) {
         mThumbOffset = thumbOffset;
         invalidate();
     }

     /**
      * Sets the amount of progress changed via the arrow keys.
      *
      * @param increment The amount to increment or decrement when the user
      *            presses the arrow keys.
      */
     public void setKeyProgressIncrement(int increment) {
         mKeyProgressIncrement = increment < 0 ? -increment : increment;
     }

     /**
      * Returns the amount of progress changed via the arrow keys.
      * <p>
      * By default, this will be a value that is derived from the max progress.
      *
      * @return The amount to increment or decrement when the user presses the
      *         arrow keys. This will be positive.
      */
     public int getKeyProgressIncrement() {
         return mKeyProgressIncrement;
     }

     @Override
     public synchronized void setMax(int max) {
         super.setMax(max);

         if ((mKeyProgressIncrement == 0) || (getMax() / mKeyProgressIncrement > 20)) {
             // It will take the user too long to change this via keys, change it
             // to something more reasonable
             setKeyProgressIncrement(Math.max(1, Math.round((float) getMax() / 20)));
         }
     }

     @Override
     protected boolean verifyDrawable(Drawable who) {
         return who == mThumb || super.verifyDrawable(who);
     }

     @Override
     public void jumpDrawablesToCurrentState() {
         super.jumpDrawablesToCurrentState();
         if (mThumb != null) mThumb.jumpToCurrentState();
     }

     @Override
     protected void drawableStateChanged() {
         super.drawableStateChanged();

         Drawable progressDrawable = getProgressDrawable();
         if (progressDrawable != null) {
             progressDrawable.setAlpha(isEnabled() ? NO_ALPHA : (int) (NO_ALPHA * mDisabledAlpha));
         }

         if (mThumb != null && mThumb.isStateful()) {
             int[] state = getDrawableState();
             mThumb.setState(state);
         }
     }

     @Override
     void onProgressRefresh(float scale, boolean fromUser) {
         super.onProgressRefresh(scale, fromUser);
         Drawable thumb = mThumb;
         if (thumb != null) {
             setThumbPos(getWidth(), getHeight(), thumb, scale, Integer.MIN_VALUE);
             /*
              * Since we draw translated, the drawable's bounds that it signals
              * for invalidation won't be the actual bounds we want invalidated,
              * so just invalidate this whole view.
              */
             invalidate();
         }
     }


     @Override
     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
         updateThumbPos(w, h);
     }

     private void updateThumbPos(int w, int h) {
         Drawable d = getCurrentDrawable();
         Drawable thumb = mThumb;
         if (mIsVertical) {
             int thumbWidth = thumb == null ? 0 : thumb.getIntrinsicWidth();
             // The max width does not incorporate padding, whereas the width
             // parameter does
             int trackWidth = Math.min(mMaxWidth, w - mPaddingLeft - mPaddingRight);

             int max = getMax();
             float scale = max > 0 ? (float) getProgress() / (float) max : 0;

             if (thumbWidth > trackWidth) {
                 if (thumb != null) {
                     setThumbPos(w, h, thumb, scale, 0);
                 }
                 int gapForCenteringTrack = (thumbWidth - trackWidth) / 2;
                 if (d != null) {
                     // Canvas will be translated by the padding, so 0,0 is where we start drawing
                     d.setBounds(gapForCenteringTrack, 0,
                             w - mPaddingRight - gapForCenteringTrack - mPaddingLeft,
                             h - mPaddingBottom - mPaddingTop);
                 }
             } else {
                 if (d != null) {
                     // Canvas will be translated by the padding, so 0,0 is where we start drawing
                     d.setBounds(0, 0, w - mPaddingRight - mPaddingLeft, h - mPaddingBottom
                             - mPaddingTop);
                 }
                 int gap = (trackWidth - thumbWidth) / 2;
                 if (thumb != null) {
                     setThumbPos(w, h, thumb, scale, gap);
                 }
             }
         } else {
             int thumbHeight = thumb == null ? 0 : thumb.getIntrinsicHeight();
             // The max height does not incorporate padding, whereas the height
             // parameter does
             int trackHeight = Math.min(mMaxHeight, h - mPaddingTop - mPaddingBottom);

             int max = getMax();
             float scale = max > 0 ? (float) getProgress() / (float) max : 0;

             if (thumbHeight > trackHeight) {
                 if (thumb != null) {
                     setThumbPos(w, h, thumb, scale, 0);
                 }
                 int gapForCenteringTrack = (thumbHeight - trackHeight) / 2;
                 if (d != null) {
                     // Canvas will be translated by the padding, so 0,0 is where we start drawing
                     d.setBounds(0, gapForCenteringTrack,
                             w - mPaddingRight - mPaddingLeft, h - mPaddingBottom - gapForCenteringTrack
                             - mPaddingTop);
                 }
             } else {
                 if (d != null) {
                     // Canvas will be translated by the padding, so 0,0 is where we start drawing
                     d.setBounds(0, 0, w - mPaddingRight - mPaddingLeft, h - mPaddingBottom
                             - mPaddingTop);
                 }
                 int gap = (trackHeight - thumbHeight) / 2;
                 if (thumb != null) {
                     setThumbPos(w, h, thumb, scale, gap);
                 }
             }
         }
     }

     /**
      * @param gap If set to {@link Integer#MIN_VALUE}, this will be ignored and
      */
     private void setThumbPos(int w, int h, Drawable thumb, float scale, int gap) {
         int available;
         int thumbWidth = thumb.getIntrinsicWidth();
         int thumbHeight = thumb.getIntrinsicHeight();
         if (mIsVertical) {
             available = h - mPaddingTop - mPaddingBottom - thumbHeight;
         } else {
             available = w - mPaddingLeft - mPaddingRight - thumbWidth;
         }

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


         if (mIsVertical) {
             int thumbPos = (int) ((1.0f - scale) * available);
             int leftBound, rightBound;
             if (gap == Integer.MIN_VALUE) {
                 Rect oldBounds = thumb.getBounds();
                 leftBound = oldBounds.left;
                 rightBound = oldBounds.right;
             } else {
                 leftBound = gap;
                 rightBound = gap + thumbWidth;
             }

             // Canvas will be translated, so 0,0 is where we start drawing
             thumb.setBounds(leftBound, thumbPos, rightBound, thumbPos + thumbHeight);
         } else {
             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);
         }
     }

     @Override
     protected synchronized void onDraw(Canvas canvas) {
         super.onDraw(canvas);
         if (mThumb != null) {
             canvas.save();
             // Translate the padding. For the x/y, we need to allow the thumb to
             // draw in its extra space
             if (mIsVertical) {
                 canvas.translate(mPaddingLeft, mPaddingTop - mThumbOffset);
                 mThumb.draw(canvas);
                 canvas.restore();
             } else {
                 canvas.translate(mPaddingLeft - mThumbOffset, mPaddingTop);
                 mThumb.draw(canvas);
                 canvas.restore();
             }
         }
     }

     @Override
     protected synchronized void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         Drawable d = getCurrentDrawable();

         int thumbHeight = mThumb == null ? 0 : mThumb.getIntrinsicHeight();
         int dw = 0;
         int dh = 0;
         if (d != null) {
             dw = Math.max(mMinWidth, Math.min(mMaxWidth, d.getIntrinsicWidth()));
             dh = Math.max(mMinHeight, Math.min(mMaxHeight, d.getIntrinsicHeight()));
             dh = Math.max(thumbHeight, dh);
         }
         dw += mPaddingLeft + mPaddingRight;
         dh += mPaddingTop + mPaddingBottom;

         setMeasuredDimension(resolveSizeAndState(dw, widthMeasureSpec, 0),
                 resolveSizeAndState(dh, heightMeasureSpec, 0));

         // TODO should probably make this an explicit attribute instead of implicitly
         // setting it based on the size
         if (getMeasuredHeight() > getMeasuredWidth()) {
             mIsVertical = true;
         }
     }

     @Override
     public boolean onTouchEvent(MotionEvent event) {
         if (!mIsUserSeekable || !isEnabled()) {
             return false;
         }

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

             case MotionEvent.ACTION_MOVE:
                 trackTouchEvent(event);
                 attemptClaimDrag();
                 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;
     }

     private void trackTouchEvent(MotionEvent event) {
         float progress = 0;
         if (mIsVertical) {
             final int height = getHeight();
             final int available = height - mPaddingTop - mPaddingBottom;
             int y = (int)event.getY();
             float scale;
             if (y < mPaddingTop) {
                 scale = 1.0f;
             } else if (y > height - mPaddingBottom) {
                 scale = 0.0f;
             } else {
                 scale = 1.0f - (float)(y - mPaddingTop) / (float)available;
                 progress = mTouchProgressOffset;
             }

             final int max = getMax();
             progress += scale * max;
         } else {
             final int width = getWidth();
             final int available = width - mPaddingLeft - mPaddingRight;
             int x = (int)event.getX();
             float scale;
             if (x < mPaddingLeft) {
                 scale = 0.0f;
             } else if (x > width - mPaddingRight) {
                 scale = 1.0f;
             } else {
                 scale = (float)(x - mPaddingLeft) / (float)available;
                 progress = mTouchProgressOffset;
             }

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

         setProgress((int) progress, true);
     }

     /**
      * Tries to claim the user's drag motion, and requests disallowing any
      * ancestors from stealing events in the drag.
      */
     private void attemptClaimDrag() {
         if (mParent != null) {
             mParent.requestDisallowInterceptTouchEvent(true);
         }
     }

     /**
      * This is called when the user has started touching this widget.
      */
     void onStartTrackingTouch() {
     }

     /**
      * This is called when the user either releases his touch or the touch is
      * canceled.
      */
     void onStopTrackingTouch() {
     }

     /**
      * Called when the user changes the seekbar's progress by using a key event.
      */
     void onKeyChange() {
     }

     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         if (isEnabled()) {
             int progress = getProgress();
             if ((keyCode == KeyEvent.KEYCODE_DPAD_LEFT && !mIsVertical)
                     || (keyCode == KeyEvent.KEYCODE_DPAD_DOWN && mIsVertical)) {
                 if (progress > 0) {
                     setProgress(progress - mKeyProgressIncrement, true);
                     onKeyChange();
                     return true;
                 }
             } else if ((keyCode == KeyEvent.KEYCODE_DPAD_RIGHT && !mIsVertical)
                     || (keyCode == KeyEvent.KEYCODE_DPAD_UP && mIsVertical)) {
                 if (progress < getMax()) {
                     setProgress(progress + mKeyProgressIncrement, true);
                     onKeyChange();
                     return true;
                 }
             }
         }

         return super.onKeyDown(keyCode, event);
     }

 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.musicfx.seekbar;

	import android.content.Context;
	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.KeyEvent;
	import android.view.MotionEvent;

	public abstract class AbsSeekBar extends ProgressBar {
	private Drawable mThumb;
	private int mThumbOffset;

	/**
	* On touch, this offset plus the scaled value from the position of the
	* touch will form the progress value. Usually 0.
	*/
	float mTouchProgressOffset;

	/**
	* Whether this is user seekable.
	*/
	boolean mIsUserSeekable = true;

	boolean mIsVertical = false;
	/**
	* On key presses (right or left), the amount to increment/decrement the
	* progress.
	*/
	private int mKeyProgressIncrement = 1;

	private static final int NO_ALPHA = 0xFF;
	private float mDisabledAlpha;

	public AbsSeekBar(Context context) {
	super(context);
	}

	public AbsSeekBar(Context context, AttributeSet attrs) {
	super(context, attrs);
	}

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

	TypedArray a = context.obtainStyledAttributes(attrs,
	com.android.internal.R.styleable.SeekBar, defStyle, 0);
	Drawable thumb = a.getDrawable(com.android.internal.R.styleable.SeekBar_thumb);
	setThumb(thumb); // will guess mThumbOffset if thumb != null...
	// ...but allow layout to override this
	int thumbOffset = a.getDimensionPixelOffset(
	com.android.internal.R.styleable.SeekBar_thumbOffset, getThumbOffset());
	setThumbOffset(thumbOffset);
	a.recycle();

	a = context.obtainStyledAttributes(attrs,
	com.android.internal.R.styleable.Theme, 0, 0);
	mDisabledAlpha = a.getFloat(com.android.internal.R.styleable.Theme_disabledAlpha, 0.5f);
	a.recycle();
	}

	/**
	* Sets the thumb that will be drawn at the end of the progress meter within the SeekBar.
	* <p>
	* If the thumb is a valid drawable (i.e. not null), half its width will be
	* used as the new thumb offset (@see #setThumbOffset(int)).
	*
	* @param thumb Drawable representing the thumb
	*/
	public void setThumb(Drawable thumb) {
	boolean needUpdate;
	// This way, calling setThumb again with the same bitmap will result in
	// it recalcuating mThumbOffset (if for example it the bounds of the
	// drawable changed)
	if (mThumb != null && thumb != mThumb) {
	mThumb.setCallback(null);
	needUpdate = true;
	} else {
	needUpdate = false;
	}
	if (thumb != null) {
	thumb.setCallback(this);

	// Assuming the thumb drawable is symmetric, set the thumb offset
	// such that the thumb will hang halfway off either edge of the
	// progress bar.
	if (mIsVertical) {
	mThumbOffset = thumb.getIntrinsicHeight() / 2;
	} else {
	mThumbOffset = thumb.getIntrinsicWidth() / 2;
	}

	// If we're updating get the new states
	if (needUpdate &&
	(thumb.getIntrinsicWidth() != mThumb.getIntrinsicWidth()
	\|\| thumb.getIntrinsicHeight() != mThumb.getIntrinsicHeight())) {
	requestLayout();
	}
	}
	mThumb = thumb;
	invalidate();
	if (needUpdate) {
	updateThumbPos(getWidth(), getHeight());
	if (thumb.isStateful()) {
	// Note that if the states are different this won't work.
	// For now, let's consider that an app bug.
	int[] state = getDrawableState();
	thumb.setState(state);
	}
	}
	}

	/**
	* @see #setThumbOffset(int)
	*/
	public int getThumbOffset() {
	return mThumbOffset;
	}

	/**
	* Sets the thumb offset that allows the thumb to extend out of the range of
	* the track.
	*
	* @param thumbOffset The offset amount in pixels.
	*/
	public void setThumbOffset(int thumbOffset) {
	mThumbOffset = thumbOffset;
	invalidate();
	}

	/**
	* Sets the amount of progress changed via the arrow keys.
	*
	* @param increment The amount to increment or decrement when the user
	* presses the arrow keys.
	*/
	public void setKeyProgressIncrement(int increment) {
	mKeyProgressIncrement = increment < 0 ? -increment : increment;
	}

	/**
	* Returns the amount of progress changed via the arrow keys.
	* <p>
	* By default, this will be a value that is derived from the max progress.
	*
	* @return The amount to increment or decrement when the user presses the
	* arrow keys. This will be positive.
	*/
	public int getKeyProgressIncrement() {
	return mKeyProgressIncrement;
	}

	@Override
	public synchronized void setMax(int max) {
	super.setMax(max);

	if ((mKeyProgressIncrement == 0) \|\| (getMax() / mKeyProgressIncrement > 20)) {
	// It will take the user too long to change this via keys, change it
	// to something more reasonable
	setKeyProgressIncrement(Math.max(1, Math.round((float) getMax() / 20)));
	}
	}

	@Override
	protected boolean verifyDrawable(Drawable who) {
	return who == mThumb \|\| super.verifyDrawable(who);
	}

	@Override
	public void jumpDrawablesToCurrentState() {
	super.jumpDrawablesToCurrentState();
	if (mThumb != null) mThumb.jumpToCurrentState();
	}

	@Override
	protected void drawableStateChanged() {
	super.drawableStateChanged();

	Drawable progressDrawable = getProgressDrawable();
	if (progressDrawable != null) {
	progressDrawable.setAlpha(isEnabled() ? NO_ALPHA : (int) (NO_ALPHA * mDisabledAlpha));
	}

	if (mThumb != null && mThumb.isStateful()) {
	int[] state = getDrawableState();
	mThumb.setState(state);
	}
	}

	@Override
	void onProgressRefresh(float scale, boolean fromUser) {
	super.onProgressRefresh(scale, fromUser);
	Drawable thumb = mThumb;
	if (thumb != null) {
	setThumbPos(getWidth(), getHeight(), thumb, scale, Integer.MIN_VALUE);
	/*
	* Since we draw translated, the drawable's bounds that it signals
	* for invalidation won't be the actual bounds we want invalidated,
	* so just invalidate this whole view.
	*/
	invalidate();
	}
	}


	@Override
	protected void onSizeChanged(int w, int h, int oldw, int oldh) {
	updateThumbPos(w, h);
	}

	private void updateThumbPos(int w, int h) {
	Drawable d = getCurrentDrawable();
	Drawable thumb = mThumb;
	if (mIsVertical) {
	int thumbWidth = thumb == null ? 0 : thumb.getIntrinsicWidth();
	// The max width does not incorporate padding, whereas the width
	// parameter does
	int trackWidth = Math.min(mMaxWidth, w - mPaddingLeft - mPaddingRight);

	int max = getMax();
	float scale = max > 0 ? (float) getProgress() / (float) max : 0;

	if (thumbWidth > trackWidth) {
	if (thumb != null) {
	setThumbPos(w, h, thumb, scale, 0);
	}
	int gapForCenteringTrack = (thumbWidth - trackWidth) / 2;
	if (d != null) {
	// Canvas will be translated by the padding, so 0,0 is where we start drawing
	d.setBounds(gapForCenteringTrack, 0,
	w - mPaddingRight - gapForCenteringTrack - mPaddingLeft,
	h - mPaddingBottom - mPaddingTop);
	}
	} else {
	if (d != null) {
	// Canvas will be translated by the padding, so 0,0 is where we start drawing
	d.setBounds(0, 0, w - mPaddingRight - mPaddingLeft, h - mPaddingBottom
	- mPaddingTop);
	}
	int gap = (trackWidth - thumbWidth) / 2;
	if (thumb != null) {
	setThumbPos(w, h, thumb, scale, gap);
	}
	}
	} else {
	int thumbHeight = thumb == null ? 0 : thumb.getIntrinsicHeight();
	// The max height does not incorporate padding, whereas the height
	// parameter does
	int trackHeight = Math.min(mMaxHeight, h - mPaddingTop - mPaddingBottom);

	int max = getMax();
	float scale = max > 0 ? (float) getProgress() / (float) max : 0;

	if (thumbHeight > trackHeight) {
	if (thumb != null) {
	setThumbPos(w, h, thumb, scale, 0);
	}
	int gapForCenteringTrack = (thumbHeight - trackHeight) / 2;
	if (d != null) {
	// Canvas will be translated by the padding, so 0,0 is where we start drawing
	d.setBounds(0, gapForCenteringTrack,
	w - mPaddingRight - mPaddingLeft, h - mPaddingBottom - gapForCenteringTrack
	- mPaddingTop);
	}
	} else {
	if (d != null) {
	// Canvas will be translated by the padding, so 0,0 is where we start drawing
	d.setBounds(0, 0, w - mPaddingRight - mPaddingLeft, h - mPaddingBottom
	- mPaddingTop);
	}
	int gap = (trackHeight - thumbHeight) / 2;
	if (thumb != null) {
	setThumbPos(w, h, thumb, scale, gap);
	}
	}
	}
	}

	/**
	* @param gap If set to {@link Integer#MIN_VALUE}, this will be ignored and
	*/
	private void setThumbPos(int w, int h, Drawable thumb, float scale, int gap) {
	int available;
	int thumbWidth = thumb.getIntrinsicWidth();
	int thumbHeight = thumb.getIntrinsicHeight();
	if (mIsVertical) {
	available = h - mPaddingTop - mPaddingBottom - thumbHeight;
	} else {
	available = w - mPaddingLeft - mPaddingRight - thumbWidth;
	}

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


	if (mIsVertical) {
	int thumbPos = (int) ((1.0f - scale) * available);
	int leftBound, rightBound;
	if (gap == Integer.MIN_VALUE) {
	Rect oldBounds = thumb.getBounds();
	leftBound = oldBounds.left;
	rightBound = oldBounds.right;
	} else {
	leftBound = gap;
	rightBound = gap + thumbWidth;
	}

	// Canvas will be translated, so 0,0 is where we start drawing
	thumb.setBounds(leftBound, thumbPos, rightBound, thumbPos + thumbHeight);
	} else {
	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);
	}
	}

	@Override
	protected synchronized void onDraw(Canvas canvas) {
	super.onDraw(canvas);
	if (mThumb != null) {
	canvas.save();
	// Translate the padding. For the x/y, we need to allow the thumb to
	// draw in its extra space
	if (mIsVertical) {
	canvas.translate(mPaddingLeft, mPaddingTop - mThumbOffset);
	mThumb.draw(canvas);
	canvas.restore();
	} else {
	canvas.translate(mPaddingLeft - mThumbOffset, mPaddingTop);
	mThumb.draw(canvas);
	canvas.restore();
	}
	}
	}

	@Override
	protected synchronized void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	Drawable d = getCurrentDrawable();

	int thumbHeight = mThumb == null ? 0 : mThumb.getIntrinsicHeight();
	int dw = 0;
	int dh = 0;
	if (d != null) {
	dw = Math.max(mMinWidth, Math.min(mMaxWidth, d.getIntrinsicWidth()));
	dh = Math.max(mMinHeight, Math.min(mMaxHeight, d.getIntrinsicHeight()));
	dh = Math.max(thumbHeight, dh);
	}
	dw += mPaddingLeft + mPaddingRight;
	dh += mPaddingTop + mPaddingBottom;

	setMeasuredDimension(resolveSizeAndState(dw, widthMeasureSpec, 0),
	resolveSizeAndState(dh, heightMeasureSpec, 0));

	// TODO should probably make this an explicit attribute instead of implicitly
	// setting it based on the size
	if (getMeasuredHeight() > getMeasuredWidth()) {
	mIsVertical = true;
	}
	}

	@Override
	public boolean onTouchEvent(MotionEvent event) {
	if (!mIsUserSeekable \|\| !isEnabled()) {
	return false;
	}

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

	case MotionEvent.ACTION_MOVE:
	trackTouchEvent(event);
	attemptClaimDrag();
	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;
	}

	private void trackTouchEvent(MotionEvent event) {
	float progress = 0;
	if (mIsVertical) {
	final int height = getHeight();
	final int available = height - mPaddingTop - mPaddingBottom;
	int y = (int)event.getY();
	float scale;
	if (y < mPaddingTop) {
	scale = 1.0f;
	} else if (y > height - mPaddingBottom) {
	scale = 0.0f;
	} else {
	scale = 1.0f - (float)(y - mPaddingTop) / (float)available;
	progress = mTouchProgressOffset;
	}

	final int max = getMax();
	progress += scale * max;
	} else {
	final int width = getWidth();
	final int available = width - mPaddingLeft - mPaddingRight;
	int x = (int)event.getX();
	float scale;
	if (x < mPaddingLeft) {
	scale = 0.0f;
	} else if (x > width - mPaddingRight) {
	scale = 1.0f;
	} else {
	scale = (float)(x - mPaddingLeft) / (float)available;
	progress = mTouchProgressOffset;
	}

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

	setProgress((int) progress, true);
	}

	/**
	* Tries to claim the user's drag motion, and requests disallowing any
	* ancestors from stealing events in the drag.
	*/
	private void attemptClaimDrag() {
	if (mParent != null) {
	mParent.requestDisallowInterceptTouchEvent(true);
	}
	}

	/**
	* This is called when the user has started touching this widget.
	*/
	void onStartTrackingTouch() {
	}

	/**
	* This is called when the user either releases his touch or the touch is
	* canceled.
	*/
	void onStopTrackingTouch() {
	}

	/**
	* Called when the user changes the seekbar's progress by using a key event.
	*/
	void onKeyChange() {
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
	if (isEnabled()) {
	int progress = getProgress();
	if ((keyCode == KeyEvent.KEYCODE_DPAD_LEFT && !mIsVertical)
	\|\| (keyCode == KeyEvent.KEYCODE_DPAD_DOWN && mIsVertical)) {
	if (progress > 0) {
	setProgress(progress - mKeyProgressIncrement, true);
	onKeyChange();
	return true;
	}
	} else if ((keyCode == KeyEvent.KEYCODE_DPAD_RIGHT && !mIsVertical)
	\|\| (keyCode == KeyEvent.KEYCODE_DPAD_UP && mIsVertical)) {
	if (progress < getMax()) {
	setProgress(progress + mKeyProgressIncrement, true);
	onKeyChange();
	return true;
	}
	}
	}

	return super.onKeyDown(keyCode, event);
	}

	}