android仿iphone滚轮控件显示效果

/* 
* Android Wheel Control. 
* https://code.google.com/p/android-wheel/ 
*  
* Copyright 2010 Yuri Kanivets 
* 
* 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 kankan.wheel.widget; 
import java.util.LinkedList; 
import java.util.List; 
import android.content.Context; 
import android.graphics.Canvas; 
import android.graphics.Paint; 
import android.graphics.Rect; 
import android.graphics.drawable.Drawable; 
import android.graphics.drawable.GradientDrawable; 
import android.graphics.drawable.GradientDrawable.Orientation; 
import android.os.Handler; 
import android.os.Message; 
import android.text.Layout; 
import android.text.StaticLayout; 
import android.text.TextPaint; 
import android.util.AttributeSet; 
import android.util.FloatMath; 
import android.view.GestureDetector; 
import android.view.GestureDetector.SimpleOnGestureListener; 
import android.view.MotionEvent; 
import android.view.View; 
import android.view.animation.Interpolator; 
import android.widget.Scroller; 
import com.shao.pwd.R; 
/** 
* Numeric wheel view. 
* 
* @author Yuri Kanivets 
*/ 
public class WheelView extends View { 
/** Scrolling duration */ 
private static final int SCROLLING_DURATION = 400; 
/** Minimum delta for scrolling */ 
private static final int MIN_DELTA_FOR_SCROLLING = 1; 
/** Current value & label text color */ 
private static final int VALUE_TEXT_COLOR = 0xF0000000; 
/** Items text color */ 
private static final int ITEMS_TEXT_COLOR = 0xFF000000; 
/** Top and bottom shadows colors */ 
private static final int[] SHADOWS_COLORS = new int[] { 0xFF111111, 
0x00AAAAAA, 0x00AAAAAA }; 
/** Additional items height (is added to standard text item height) */ 
private static final int ADDITIONAL_ITEM_HEIGHT = 15; 
/** Text size */ 
private static final int TEXT_SIZE = 24; 
/** Top and bottom items offset (to hide that) */ 
private static final int ITEM_OFFSET = TEXT_SIZE / 5; 
/** Additional width for items layout */ 
private static final int ADDITIONAL_ITEMS_SPACE = 10; 
/** Label offset */ 
private static final int LABEL_OFFSET = 8; 
/** Left and right padding value */ 
private static final int PADDING = 10; 
/** Default count of visible items */ 
private static final int DEF_VISIBLE_ITEMS = 5; 
// Wheel Values 
private WheelAdapter adapter = null; 
private int currentItem = 0; 
// Widths 
private int itemsWidth = 0; 
private int labelWidth = 0; 
// Count of visible items 
private int visibleItems = DEF_VISIBLE_ITEMS; 
// Item height 
private int itemHeight = 0; 
// Text paints 
private TextPaint itemsPaint; 
private TextPaint valuePaint; 
// Layouts 
private StaticLayout itemsLayout; 
private StaticLayout labelLayout; 
private StaticLayout valueLayout; 
// Label & background 
private String label; 
private Drawable centerDrawable; 
// Shadows drawables 
private GradientDrawable topShadow; 
private GradientDrawable bottomShadow; 
// Scrolling 
private boolean isScrollingPerformed;  
private int scrollingOffset; 
// Scrolling animation 
private GestureDetector gestureDetector; 
private Scroller scroller; 
private int lastScrollY; 
// Cyclic 
boolean isCyclic = false; 
// Listeners 
private List<OnWheelChangedListener  changingListeners = new LinkedList<OnWheelChangedListener (); 
private List<OnWheelScrollListener  scrollingListeners = new LinkedList<OnWheelScrollListener (); 
/** 
* Constructor 
*/ 
public WheelView(Context context, AttributeSet attrs, int defStyle) { 
super(context, attrs, defStyle); 
initData(context); 
} 
/** 
* Constructor 
*/ 
public WheelView(Context context, AttributeSet attrs) { 
super(context, attrs); 
initData(context); 
} 
/** 
* Constructor 
*/ 
public WheelView(Context context) { 
super(context); 
initData(context); 
} 
/** 
* Initializes class data 
* @param context the context 
*/ 
private void initData(Context context) { 
gestureDetector = new GestureDetector(context, gestureListener); 
gestureDetector.setIsLongpressEnabled(false); 
scroller = new Scroller(context); 
} 
/** 
* Gets wheel adapter 
* @return the adapter 
*/ 
public WheelAdapter getAdapter() { 
return adapter; 
} 
/** 
* Sets wheel adapter 
* @param adapter the new wheel adapter 
*/ 
public void setAdapter(WheelAdapter adapter) { 
this.adapter = adapter; 
invalidateLayouts(); 
invalidate(); 
} 
/** 
* Set the the specified scrolling interpolator 
* @param interpolator the interpolator 
*/ 
public void setInterpolator(Interpolator interpolator) { 
scroller.forceFinished(true); 
scroller = new Scroller(getContext(), interpolator); 
} 
/** 
* Gets count of visible items 
* 
* @return the count of visible items 
*/ 
public int getVisibleItems() { 
return visibleItems; 
} 
/** 
* Sets count of visible items 
* 
* @param count 
*      the new count 
*/ 
public void setVisibleItems(int count) { 
visibleItems = count; 
invalidate(); 
} 
/** 
* Gets label 
* 
* @return the label 
*/ 
public String getLabel() { 
return label; 
} 
/** 
* Sets label 
* 
* @param newLabel 
*      the label to set 
*/ 
public void setLabel(String newLabel) { 
if (label == null || !label.equals(newLabel)) { 
label = newLabel; 
labelLayout = null; 
invalidate(); 
} 
} 
/** 
* Adds wheel changing listener 
* @param listener the listener 
*/ 
public void addChangingListener(OnWheelChangedListener listener) { 
changingListeners.add(listener); 
} 
/** 
* Removes wheel changing listener 
* @param listener the listener 
*/ 
public void removeChangingListener(OnWheelChangedListener listener) { 
changingListeners.remove(listener); 
} 
/** 
* Notifies changing listeners 
* @param oldValue the old wheel value 
* @param newValue the new wheel value 
*/ 
protected void notifyChangingListeners(int oldValue, int newValue) { 
for (OnWheelChangedListener listener : changingListeners) { 
listener.onChanged(this, oldValue, newValue); 
} 
} 
/** 
* Adds wheel scrolling listener 
* @param listener the listener 
*/ 
public void addScrollingListener(OnWheelScrollListener listener) { 
scrollingListeners.add(listener); 
} 
/** 
* Removes wheel scrolling listener 
* @param listener the listener 
*/ 
public void removeScrollingListener(OnWheelScrollListener listener) { 
scrollingListeners.remove(listener); 
} 
/** 
* Notifies listeners about starting scrolling 
*/ 
protected void notifyScrollingListenersAboutStart() { 
for (OnWheelScrollListener listener : scrollingListeners) { 
listener.onScrollingStarted(this); 
} 
} 
/** 
* Notifies listeners about ending scrolling 
*/ 
protected void notifyScrollingListenersAboutEnd() { 
for (OnWheelScrollListener listener : scrollingListeners) { 
listener.onScrollingFinished(this); 
} 
} 
/** 
* Gets current value 
* 
* @return the current value 
*/ 
public int getCurrentItem() { 
return currentItem; 
} 
/** 
* Sets the current item. Does nothing when index is wrong. 
* 
* @param index the item index 
* @param animated the animation flag 
*/ 
public void setCurrentItem(int index, boolean animated) { 
if (adapter == null || adapter.getItemsCount() == 0) { 
return; // throw? 
} 
if (index < 0 || index  = adapter.getItemsCount()) { 
if (isCyclic) { 
while (index < 0) { 
index += adapter.getItemsCount(); 
} 
index %= adapter.getItemsCount(); 
} else{ 
return; // throw? 
} 
} 
if (index != currentItem) { 
if (animated) { 
scroll(index - currentItem, SCROLLING_DURATION); 
} else { 
invalidateLayouts(); 
int old = currentItem; 
currentItem = index; 
notifyChangingListeners(old, currentItem); 
invalidate(); 
} 
} 
} 
/** 
* Sets the current item w/o animation. Does nothing when index is wrong. 
* 
* @param index the item index 
*/ 
public void setCurrentItem(int index) { 
setCurrentItem(index, false); 
}   
/** 
* Tests if wheel is cyclic. That means before the 1st item there is shown the last one 
* @return true if wheel is cyclic 
*/ 
public boolean isCyclic() { 
return isCyclic; 
} 
/** 
* Set wheel cyclic flag 
* @param isCyclic the flag to set 
*/ 
public void setCyclic(boolean isCyclic) { 
this.isCyclic = isCyclic; 
invalidate(); 
invalidateLayouts(); 
} 
/** 
* Invalidates layouts 
*/ 
private void invalidateLayouts() { 
itemsLayout = null; 
valueLayout = null; 
scrollingOffset = 0; 
} 
/** 
* Initializes resources 
*/ 
private void initResourcesIfNecessary() { 
if (itemsPaint == null) { 
itemsPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG 
| Paint.FAKE_BOLD_TEXT_FLAG); 
//itemsPaint.density = getResources().getDisplayMetrics().density; 
itemsPaint.setTextSize(TEXT_SIZE); 
} 
if (valuePaint == null) { 
valuePaint = new TextPaint(Paint.ANTI_ALIAS_FLAG 
| Paint.FAKE_BOLD_TEXT_FLAG | Paint.DITHER_FLAG); 
//valuePaint.density = getResources().getDisplayMetrics().density; 
valuePaint.setTextSize(TEXT_SIZE); 
valuePaint.setShadowLayer(0.1f, 0, 0.1f, 0xFFC0C0C0); 
} 
if (centerDrawable == null) { 
centerDrawable = getContext().getResources().getDrawable(R.drawable.wheel_val); 
} 
if (topShadow == null) { 
topShadow = new GradientDrawable(Orientation.TOP_BOTTOM, SHADOWS_COLORS); 
} 
if (bottomShadow == null) { 
bottomShadow = new GradientDrawable(Orientation.BOTTOM_TOP, SHADOWS_COLORS); 
} 
setBackgroundResource(R.drawable.wheel_bg); 
} 
/** 
* Calculates desired height for layout 
* 
* @param layout 
*      the source layout 
* @return the desired layout height 
*/ 
private int getDesiredHeight(Layout layout) { 
if (layout == null) { 
return 0; 
} 
int desired = getItemHeight() * visibleItems - ITEM_OFFSET * 2 
- ADDITIONAL_ITEM_HEIGHT; 
// Check against our minimum height 
desired = Math.max(desired, getSuggestedMinimumHeight()); 
return desired; 
} 
/** 
* Returns text item by index 
* @param index the item index 
* @return the item or null 
*/ 
private String getTextItem(int index) { 
if (adapter == null || adapter.getItemsCount() == 0) { 
return null; 
} 
int count = adapter.getItemsCount(); 
if ((index < 0 || index  = count) && !isCyclic) { 
return null; 
} else { 
while (index < 0) { 
index = count + index; 
} 
} 
index %= count; 
return adapter.getItem(index); 
} 
/** 
* Builds text depending on current value 
* 
* @param useCurrentValue 
* @return the text 
*/ 
private String buildText(boolean useCurrentValue) { 
StringBuilder itemsText = new StringBuilder(); 
int addItems = visibleItems / 2 + 1; 
for (int i = currentItem - addItems; i <= currentItem + addItems; i++) { 
if (useCurrentValue || i != currentItem) { 
String text = getTextItem(i); 
if (text != null) { 
itemsText.append(text); 
} 
} 
if (i < currentItem + addItems) { 
itemsText.append("\n"); 
} 
} 
return itemsText.toString(); 
} 
/** 
* Returns the max item length that can be present 
* @return the max length 
*/ 
private int getMaxTextLength() { 
WheelAdapter adapter = getAdapter(); 
if (adapter == null) { 
return 0; 
} 
int adapterLength = adapter.getMaximumLength(); 
if (adapterLength   0) { 
return adapterLength; 
} 
String maxText = null; 
int addItems = visibleItems / 2; 
for (int i = Math.max(currentItem - addItems, 0); 
i < Math.min(currentItem + visibleItems, adapter.getItemsCount()); i++) { 
String text = adapter.getItem(i); 
if (text != null && (maxText == null || maxText.length() < text.length())) { 
maxText = text; 
} 
} 
return maxText != null ? maxText.length() : 0; 
} 
/** 
* Returns height of wheel item 
* @return the item height 
*/ 
private int getItemHeight() { 
if (itemHeight != 0) { 
return itemHeight; 
} else if (itemsLayout != null && itemsLayout.getLineCount()   2) { 
itemHeight = itemsLayout.getLineTop(2) - itemsLayout.getLineTop(1); 
return itemHeight; 
} 
return getHeight() / visibleItems; 
} 
/** 
* Calculates control width and creates text layouts 
* @param widthSize the input layout width 
* @param mode the layout mode 
* @return the calculated control width 
*/ 
private int calculateLayoutWidth(int widthSize, int mode) { 
initResourcesIfNecessary(); 
int width = widthSize; 
int maxLength = getMaxTextLength(); 
if (maxLength   0) { 
float textWidth = FloatMath.ceil(Layout.getDesiredWidth("0", itemsPaint)); 
itemsWidth = (int) (maxLength * textWidth); 
} else { 
itemsWidth = 0; 
} 
itemsWidth += ADDITIONAL_ITEMS_SPACE; // make it some more 
labelWidth = 0; 
if (label != null && label.length()   0) { 
labelWidth = (int) FloatMath.ceil(Layout.getDesiredWidth(label, valuePaint)); 
} 
boolean recalculate = false; 
if (mode == MeasureSpec.EXACTLY) { 
width = widthSize; 
recalculate = true; 
} else { 
width = itemsWidth + labelWidth + 2 * PADDING; 
if (labelWidth   0) { 
width += LABEL_OFFSET; 
} 
// Check against our minimum width 
width = Math.max(width, getSuggestedMinimumWidth()); 
if (mode == MeasureSpec.AT_MOST && widthSize < width) { 
width = widthSize; 
recalculate = true; 
} 
} 
if (recalculate) { 
// recalculate width 
int pureWidth = width - LABEL_OFFSET - 2 * PADDING; 
if (pureWidth <= 0) { 
itemsWidth = labelWidth = 0; 
} 
if (labelWidth   0) { 
double newWidthItems = (double) itemsWidth * pureWidth 
/ (itemsWidth + labelWidth); 
itemsWidth = (int) newWidthItems; 
labelWidth = pureWidth - itemsWidth; 
} else { 
itemsWidth = pureWidth + LABEL_OFFSET; // no label 
} 
} 
if (itemsWidth   0) { 
createLayouts(itemsWidth, labelWidth); 
} 
return width; 
} 
/** 
* Creates layouts 
* @param widthItems width of items layout 
* @param widthLabel width of label layout 
*/ 
private void createLayouts(int widthItems, int widthLabel) { 
if (itemsLayout == null || itemsLayout.getWidth()   widthItems) { 
itemsLayout = new StaticLayout(buildText(isScrollingPerformed), itemsPaint, widthItems, 
widthLabel   0 ? Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER, 
1, ADDITIONAL_ITEM_HEIGHT, false); 
} else { 
itemsLayout.increaseWidthTo(widthItems); 
} 
if (!isScrollingPerformed && (valueLayout == null || valueLayout.getWidth()   widthItems)) { 
String text = getAdapter() != null ? getAdapter().getItem(currentItem) : null; 
valueLayout = new StaticLayout(text != null ? text : "", 
valuePaint, widthItems, widthLabel   0 ? 
Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER, 
1, ADDITIONAL_ITEM_HEIGHT, false); 
} else if (isScrollingPerformed) { 
valueLayout = null; 
} else { 
valueLayout.increaseWidthTo(widthItems); 
} 
if (widthLabel   0) { 
if (labelLayout == null || labelLayout.getWidth()   widthLabel) { 
labelLayout = new StaticLayout(label, valuePaint, 
widthLabel, Layout.Alignment.ALIGN_NORMAL, 1, 
ADDITIONAL_ITEM_HEIGHT, false); 
} else { 
labelLayout.increaseWidthTo(widthLabel); 
} 
} 
} 
@Override 
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 
int widthMode = MeasureSpec.getMode(widthMeasureSpec); 
int heightMode = MeasureSpec.getMode(heightMeasureSpec); 
int widthSize = MeasureSpec.getSize(widthMeasureSpec); 
int heightSize = MeasureSpec.getSize(heightMeasureSpec); 
int width = calculateLayoutWidth(widthSize, widthMode); 
int height; 
if (heightMode == MeasureSpec.EXACTLY) { 
height = heightSize; 
} else { 
height = getDesiredHeight(itemsLayout); 
if (heightMode == MeasureSpec.AT_MOST) { 
height = Math.min(height, heightSize); 
} 
} 
setMeasuredDimension(width, height); 
} 
@Override 
protected void onDraw(Canvas canvas) { 
super.onDraw(canvas); 
if (itemsLayout == null) { 
if (itemsWidth == 0) { 
calculateLayoutWidth(getWidth(), MeasureSpec.EXACTLY); 
} else { 
createLayouts(itemsWidth, labelWidth); 
} 
} 
if (itemsWidth   0) { 
canvas.save(); 
// Skip padding space and hide a part of top and bottom items 
canvas.translate(PADDING, -ITEM_OFFSET); 
drawItems(canvas); 
drawValue(canvas); 
canvas.restore(); 
} 
drawCenterRect(canvas); 
drawShadows(canvas); 
} 
/** 
* Draws shadows on top and bottom of control 
* @param canvas the canvas for drawing 
*/ 
private void drawShadows(Canvas canvas) { 
topShadow.setBounds(0, 0, getWidth(), getHeight() / visibleItems); 
topShadow.draw(canvas); 
bottomShadow.setBounds(0, getHeight() - getHeight() / visibleItems, 
getWidth(), getHeight()); 
bottomShadow.draw(canvas); 
} 
/** 
* Draws value and label layout 
* @param canvas the canvas for drawing 
*/ 
private void drawValue(Canvas canvas) { 
valuePaint.setColor(VALUE_TEXT_COLOR); 
valuePaint.drawableState = getDrawableState(); 
Rect bounds = new Rect(); 
itemsLayout.getLineBounds(visibleItems / 2, bounds); 
// draw label 
if (labelLayout != null) { 
canvas.save(); 
canvas.translate(itemsLayout.getWidth() + LABEL_OFFSET, bounds.top); 
labelLayout.draw(canvas); 
canvas.restore(); 
} 
// draw current value 
if (valueLayout != null) { 
canvas.save(); 
canvas.translate(0, bounds.top + scrollingOffset); 
valueLayout.draw(canvas); 
canvas.restore(); 
} 
} 
/** 
* Draws items 
* @param canvas the canvas for drawing 
*/ 
private void drawItems(Canvas canvas) { 
canvas.save(); 
int top = itemsLayout.getLineTop(1); 
canvas.translate(0, - top + scrollingOffset); 
itemsPaint.setColor(ITEMS_TEXT_COLOR); 
itemsPaint.drawableState = getDrawableState(); 
itemsLayout.draw(canvas); 
canvas.restore(); 
} 
/** 
* Draws rect for current value 
* @param canvas the canvas for drawing 
*/ 
private void drawCenterRect(Canvas canvas) { 
int center = getHeight() / 2; 
int offset = getItemHeight() / 2; 
centerDrawable.setBounds(0, center - offset, getWidth(), center + offset); 
centerDrawable.draw(canvas); 
} 
@Override 
public boolean onTouchEvent(MotionEvent event) { 
WheelAdapter adapter = getAdapter(); 
if (adapter == null) { 
return true; 
} 
if (!gestureDetector.onTouchEvent(event) && event.getAction() == MotionEvent.ACTION_UP) { 
justify(); 
} 
return true; 
} 
/** 
* Scrolls the wheel 
* @param delta the scrolling value 
*/ 
private void doScroll(int delta) { 
scrollingOffset += delta; 
int count = scrollingOffset / getItemHeight(); 
int pos = currentItem - count; 
if (isCyclic && adapter.getItemsCount()   0) { 
// fix position by rotating 
while (pos < 0) { 
pos += adapter.getItemsCount(); 
} 
pos %= adapter.getItemsCount(); 
} else if (isScrollingPerformed) { 
//  
if (pos < 0) { 
count = currentItem; 
pos = 0; 
} else if (pos  = adapter.getItemsCount()) { 
count = currentItem - adapter.getItemsCount() + 1; 
pos = adapter.getItemsCount() - 1; 
} 
} else { 
// fix position 
pos = Math.max(pos, 0); 
pos = Math.min(pos, adapter.getItemsCount() - 1); 
} 
int offset = scrollingOffset; 
if (pos != currentItem) { 
setCurrentItem(pos, false); 
} else { 
invalidate(); 
} 
// update offset 
scrollingOffset = offset - count * getItemHeight(); 
if (scrollingOffset   getHeight()) { 
scrollingOffset = scrollingOffset % getHeight() + getHeight(); 
} 
} 
// gesture listener 
private SimpleOnGestureListener gestureListener = new SimpleOnGestureListener() { 
public boolean onDown(MotionEvent e) { 
if (isScrollingPerformed) { 
scroller.forceFinished(true); 
clearMessages(); 
return true; 
} 
return false; 
} 
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) { 
startScrolling(); 
doScroll((int)-distanceY); 
return true; 
} 
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { 
lastScrollY = currentItem * getItemHeight() + scrollingOffset; 
int maxY = isCyclic ? 0x7FFFFFFF : adapter.getItemsCount() * getItemHeight(); 
int minY = isCyclic ? -maxY : 0; 
scroller.fling(0, lastScrollY, 0, (int) -velocityY / 2, 0, 0, minY, maxY); 
setNextMessage(MESSAGE_SCROLL); 
return true; 
} 
}; 
// Messages 
private final int MESSAGE_SCROLL = 0; 
private final int MESSAGE_JUSTIFY = 1; 
/** 
* Set next message to queue. Clears queue before. 
* 
* @param message the message to set 
*/ 
private void setNextMessage(int message) { 
clearMessages(); 
animationHandler.sendEmptyMessage(message); 
} 
/** 
* Clears messages from queue 
*/ 
private void clearMessages() { 
animationHandler.removeMessages(MESSAGE_SCROLL); 
animationHandler.removeMessages(MESSAGE_JUSTIFY); 
} 
// animation handler 
private Handler animationHandler = new Handler() { 
public void handleMessage(Message msg) { 
scroller.computeScrollOffset(); 
int currY = scroller.getCurrY(); 
int delta = lastScrollY - currY; 
lastScrollY = currY; 
if (delta != 0) { 
doScroll(delta); 
} 
// scrolling is not finished when it comes to final Y 
// so, finish it manually  
if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) { 
currY = scroller.getFinalY(); 
scroller.forceFinished(true); 
} 
if (!scroller.isFinished()) { 
animationHandler.sendEmptyMessage(msg.what); 
} else if (msg.what == MESSAGE_SCROLL) { 
justify(); 
} else { 
finishScrolling(); 
} 
} 
}; 
/** 
* Justifies wheel 
*/ 
private void justify() { 
if (adapter == null) { 
return; 
} 
lastScrollY = 0; 
int offset = scrollingOffset; 
int itemHeight = getItemHeight(); 
boolean needToIncrease = offset   0 ? currentItem < adapter.getItemsCount() : currentItem   0;  
if ((isCyclic || needToIncrease) && Math.abs((float) offset)   (float) itemHeight / 2) { 
if (offset < 0) 
offset += itemHeight + MIN_DELTA_FOR_SCROLLING; 
else 
offset -= itemHeight + MIN_DELTA_FOR_SCROLLING; 
} 
if (Math.abs(offset)   MIN_DELTA_FOR_SCROLLING) { 
scroller.startScroll(0, 0, 0, offset, SCROLLING_DURATION); 
setNextMessage(MESSAGE_JUSTIFY); 
} else { 
finishScrolling(); 
} 
} 
/** 
* Starts scrolling 
*/ 
private void startScrolling() { 
if (!isScrollingPerformed) { 
isScrollingPerformed = true; 
notifyScrollingListenersAboutStart(); 
} 
} 
/** 
* Finishes scrolling 
*/ 
void finishScrolling() { 
if (isScrollingPerformed) { 
notifyScrollingListenersAboutEnd(); 
isScrollingPerformed = false; 
} 
invalidateLayouts(); 
invalidate(); 
} 
/** 
* Scroll the wheel 
* @param itemsToSkip items to scroll 
* @param time scrolling duration 
*/ 
public void scroll(int itemsToScroll, int time) { 
scroller.forceFinished(true); 
lastScrollY = scrollingOffset; 
int offset = itemsToScroll * getItemHeight(); 
scroller.startScroll(0, lastScrollY, 0, offset - lastScrollY, time); 
setNextMessage(MESSAGE_SCROLL); 
startScrolling(); 
} 
} 

<?xml version="1.0" encoding="utf-8"?  
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
android:layout_height="wrap_content" 
android:orientation="vertical" 
android:background="@drawable/layout_bg" 
android:layout_width="fill_parent"  
<TextView 
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:layout_marginTop="24dp" 
android:layout_gravity="center_horizontal" 
android:textSize="20sp" 
android:textStyle="bold" 
android:text="Please enter PIN"/  
<LinearLayout 
android:layout_marginTop="24dp" 
android:layout_gravity="center_horizontal" 
android:layout_width="wrap_content" 
android:layout_height="wrap_content"  
<kankan.wheel.widget.WheelView android:id="@+id/passw_1" 
android:layout_height="wrap_content" 
android:layout_width="wrap_content"/  
<kankan.wheel.widget.WheelView android:id="@+id/passw_2" 
android:layout_height="wrap_content" 
android:layout_width="wrap_content"/  
<kankan.wheel.widget.WheelView android:id="@+id/passw_3" 
android:layout_height="wrap_content" 
android:layout_width="wrap_content"/  
<kankan.wheel.widget.WheelView android:id="@+id/passw_4" 
android:layout_height="wrap_content" 
android:layout_width="wrap_content"/  
<kankan.wheel.widget.WheelView android:id="@+id/passw_5" 
android:layout_height="wrap_content" 
android:layout_width="wrap_content"/  
<kankan.wheel.widget.WheelView android:id="@+id/passw_6" 
android:layout_height="wrap_content" 
android:layout_width="wrap_content"/  
</LinearLayout  
<TextView android:id="@+id/pwd_status" 
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:layout_marginTop="24dp" 
android:layout_gravity="center_horizontal" 
android:textSize="18sp" 
android:textColor="#FFF" 
android:text="Wrong PIN"/  
<Button android:id="@+id/btn_mix" 
android:layout_width="wrap_content" 
android:layout_height="wrap_content" 
android:layout_gravity="center_horizontal" 
android:layout_marginTop="12dp" 
android:textSize="18sp" 
android:text="  Mix "/  
</LinearLayout  

/* 
* Copyright 2010 Yuri Kanivets 
* 
* 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 kankan.wheel.widget; 
public interface WheelAdapter { 
/** 
* Gets items count 
* @return the count of wheel items 
*/ 
public int getItemsCount(); 
/** 
* Gets a wheel item by index. 
* 
* @param index the item index 
* @return the wheel item text or null 
*/ 
public String getItem(int index); 
/** 
* Gets maximum item length. It is used to determine the wheel width. 
* If -1 is returned there will be used the default wheel width. 
* 
* @return the maximum item length or -1 
*/ 
public int getMaximumLength(); 
} 

/* 
* Copyright 2010 Yuri Kanivets 
* 
* 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 kankan.wheel.widget; 
/** 
* Numeric Wheel adapter. 
*/ 
public class NumericWheelAdapter implements WheelAdapter { 
/** The default min value */ 
public static final int DEFAULT_MAX_VALUE = 9; 
/** The default max value */ 
private static final int DEFAULT_MIN_VALUE = 0; 
// Values 
private int minValue; 
private int maxValue; 
// format 
private String format; 
/** 
* Default constructor 
*/ 
public NumericWheelAdapter() { 
this(DEFAULT_MIN_VALUE, DEFAULT_MAX_VALUE); 
} 
/** 
* Constructor 
* @param minValue the wheel min value 
* @param maxValue the wheel max value 
*/ 
public NumericWheelAdapter(int minValue, int maxValue) { 
this(minValue, maxValue, null); 
} 
/** 
* Constructor 
* @param minValue the wheel min value 
* @param maxValue the wheel max value 
* @param format the format string 
*/ 
public NumericWheelAdapter(int minValue, int maxValue, String format) { 
this.minValue = minValue; 
this.maxValue = maxValue; 
this.format = format; 
} 
@Override 
public String getItem(int index) { 
if (index  = 0 && index < getItemsCount()) { 
int value = minValue + index; 
return format != null ? String.format(format, value) : Integer.toString(value); 
} 
return null; 
} 
@Override 
public int getItemsCount() { 
return maxValue - minValue + 1; 
} 
@Override 
public int getMaximumLength() { 
int max = Math.max(Math.abs(maxValue), Math.abs(minValue)); 
int maxLen = Integer.toString(max).length(); 
if (minValue < 0) { 
maxLen++; 
} 
return maxLen; 
} 
} 

/* 
* Copyright 2010 Yuri Kanivets 
* 
* 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 kankan.wheel.widget; 
/** 
* Wheel scrolled listener interface. 
*/ 
public interface OnWheelScrollListener { 
/** 
* Callback method to be invoked when scrolling started. 
* @param wheel the wheel view whose state has changed. 
*/ 
void onScrollingStarted(WheelView wheel); 
/** 
* Callback method to be invoked when scrolling ended. 
* @param wheel the wheel view whose state has changed. 
*/ 
void onScrollingFinished(WheelView wheel); 
} 

/* 
* Copyright 2010 Yuri Kanivets 
* 
* 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 kankan.wheel.widget; 
/** 
* Wheel changed listener interface. 
* <p The currentItemChanged() method is called whenever current wheel positions is changed: 
* <li  New Wheel position is set 
* <li  Wheel view is scrolled 
*/ 
public interface OnWheelChangedListener { 
/** 
* Callback method to be invoked when current item changed 
* @param wheel the wheel view whose state has changed 
* @param oldValue the old value of current item 
* @param newValue the new value of current item 
*/ 
void onChanged(WheelView wheel, int oldValue, int newValue); 
}