devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

android 时间滚动控件 底部弹出_android timepickerdialog底部弹出

作者：从前慢现在也慢 | 2024-03-21 05:31:51

赞

踩

android timepickerdialog底部弹出

下载地址：http://download.csdn.net/detail/ldd119/7440895 转载请说明出处

先上个效果图


第一步：先自定义一个View

  1. package com.wheel.widget;
  2.  
  3. import java.util.LinkedList;
  4. import java.util.List;
  5. import java.util.logging.Level;
  6. import java.util.logging.Logger;
  7.  
  8. import com.example.mywheel.R;
  9.  
  10. import android.content.Context;
  11. import android.graphics.Canvas;
  12. import android.graphics.Paint;
  13. import android.graphics.Rect;
  14. import android.graphics.drawable.Drawable;
  15. import android.graphics.drawable.GradientDrawable;
  16. import android.graphics.drawable.GradientDrawable.Orientation;
  17. import android.os.Handler;
  18. import android.os.Message;
  19. import android.text.Layout;
  20. import android.text.StaticLayout;
  21. import android.text.TextPaint;
  22. import android.util.AttributeSet;
  23. import android.util.DisplayMetrics;
  24. import android.util.FloatMath;
  25. import android.view.GestureDetector;
  26. import android.view.GestureDetector.SimpleOnGestureListener;
  27. import android.view.MotionEvent;
  28. import android.view.View;
  29. import android.view.animation.Interpolator;
  30. import android.widget.Scroller;
  31.  
  32. public class WheelView extends View {
  33. 	/** Scrolling duration */
  34. 	private static final int SCROLLING_DURATION = 400;
  35.  
  36. 	/** Minimum delta for scrolling */
  37. 	private static final int MIN_DELTA_FOR_SCROLLING = 1;
  38.  
  39. 	/** Current value & label text color */
  40. 	public static int VALUE_TEXT_COLOR = 0xe0000000;
  41. 	/** Items text color */
  42. 	private static final int ITEMS_TEXT_COLOR = 0xe0000000;
  43.  
  44. 	/** Top and bottom shadows colors */
  45. 	private static final int[] SHADOWS_COLORS = new int[] { 0x00000000,
  46. 		0x00000000, 0x00000000 };
  47.  
  48. 	/** Additional items height (is added to standard text item height) */
  49. 	private static final int ADDITIONAL_ITEM_HEIGHT = 15;
  50.  
  51. 	/** Text size */
  52. 	private static final int TEXT_SIZE = 15;
  53.  
  54. 	/** Top and bottom items offset (to hide that) */
  55. 	private static final int ITEM_OFFSET = TEXT_SIZE / 5;
  56.  
  57. 	/** Additional width for items layout */
  58. 	private static final int ADDITIONAL_ITEMS_SPACE = 10;
  59.  
  60. 	/** Label offset */
  61. 	private static final int LABEL_OFFSET = 8;
  62.  
  63. 	/** Left and right padding value */
  64. 	private static final int PADDING = 5;
  65.  
  66. 	/** Default count of visible items */
  67. 	private static final int DEF_VISIBLE_ITEMS = 5;
  68.  
  69. 	// Wheel Values
  70. 	private WheelAdapter adapter = null;
  71. 	private int currentItem = 0;
  72. 	
  73. 	// Widths
  74. 	private int itemsWidth = 0;
  75. 	private int labelWidth = 0;
  76.  
  77. 	// Count of visible items
  78. 	private int visibleItems = DEF_VISIBLE_ITEMS;
  79. 	
  80. 	// Item height
  81. 	private int itemHeight = 0;
  82.  
  83. 	// Text paints
  84. 	private TextPaint itemsPaint;
  85. 	private TextPaint valuePaint;
  86.  
  87. 	// Layouts
  88. 	private StaticLayout itemsLayout;
  89. 	private StaticLayout labelLayout;
  90. 	private StaticLayout valueLayout;
  91.  
  92. 	// Label & background
  93. 	private String label;
  94. 	private Drawable centerDrawable;
  95.  
  96. 	// Shadows drawables
  97. 	private GradientDrawable topShadow;
  98. 	private GradientDrawable bottomShadow;
  99.  
  100. 	// Scrolling
  101. 	private boolean isScrollingPerformed; 
  102. 	private int scrollingOffset;
  103.  
  104. 	// Scrolling animation
  105. 	private GestureDetector gestureDetector;
  106. 	private Scroller scroller;
  107. 	private int lastScrollY;
  108.  
  109. 	// Cyclic
  110. 	boolean isCyclic = true;
  111. 	
  112. 	// Listeners
  113. 	private List<OnWheelChangedListener> changingListeners = new LinkedList<OnWheelChangedListener>();
  114. 	private List<OnWheelScrollListener> scrollingListeners = new LinkedList<OnWheelScrollListener>();
  115.  
  116. 	/**
  117. 	 * Constructor
  118. 	 */
  119. 	public WheelView(Context context, AttributeSet attrs, int defStyle) {
  120. 		super(context, attrs, defStyle);
  121. 		initData(context);
  122. 	}
  123.  
  124. 	/**
  125. 	 * Constructor
  126. 	 */
  127. 	public WheelView(Context context, AttributeSet attrs) {
  128. 		super(context, attrs);
  129. 		initData(context);
  130. 	}
  131.  
  132. 	/**
  133. 	 * Constructor
  134. 	 */
  135. 	public WheelView(Context context) {
  136. 		super(context);
  137. 		initData(context);
  138. 	}
  139. 	
  140. 	/**
  141. 	 * Initializes class data
  142. 	 * @param context the context
  143. 	 */
  144. 	private void initData(Context context) {
  145. 		gestureDetector = new GestureDetector(context, gestureListener);
  146. 		gestureDetector.setIsLongpressEnabled(false);
  147. 		
  148. 		scroller = new Scroller(context);
  149. 	}
  150. 	
  151. 	/**
  152. 	 * Gets wheel adapter
  153. 	 * @return the adapter
  154. 	 */
  155. 	public WheelAdapter getAdapter() {
  156. 		return adapter;
  157. 	}
  158. 	
  159. 	/**
  160. 	 * Sets wheel adapter
  161. 	 * @param adapter the new wheel adapter
  162. 	 */
  163. 	public void setAdapter(WheelAdapter adapter) {
  164. 		this.adapter = adapter;
  165. 		invalidateLayouts();
  166. 		invalidate();
  167. 	}
  168. 	
  169. 	/**
  170. 	 * Set the the specified scrolling interpolator
  171. 	 * @param interpolator the interpolator
  172. 	 */
  173. 	public void setInterpolator(Interpolator interpolator) {
  174. 		scroller.forceFinished(true);
  175. 		scroller = new Scroller(getContext(), interpolator);
  176. 	}
  177. 	
  178. 	/**
  179. 	 * Gets count of visible items
  180. 	 * 
  181. 	 * @return the count of visible items
  182. 	 */
  183. 	public int getVisibleItems() {
  184. 		return visibleItems;
  185. 	}
  186.  
  187. 	/**
  188. 	 * Sets count of visible items
  189. 	 * 
  190. 	 * @param count
  191. 	 *            the new count
  192. 	 */
  193. 	public void setVisibleItems(int count) {
  194. 		visibleItems = count;
  195. 		invalidate();
  196. 	}
  197.  
  198. 	/**
  199. 	 * Gets label
  200. 	 * 
  201. 	 * @return the label
  202. 	 */
  203. 	public String getLabel() {
  204. 		return label;
  205. 	}
  206.  
  207. 	/**
  208. 	 * Sets label
  209. 	 * 
  210. 	 * @param newLabel
  211. 	 *            the label to set
  212. 	 */
  213. 	public void setLabel(String newLabel) {
  214. 		if (label == null || !label.equals(newLabel)) {
  215. 			label = newLabel;
  216. 			labelLayout = null;
  217. 			invalidate();
  218. 		}
  219. 	}
  220. 	
  221. 	/**
  222. 	 * Adds wheel changing listener
  223. 	 * @param listener the listener 
  224. 	 */
  225. 	public void addChangingListener(OnWheelChangedListener listener) {
  226. 		changingListeners.add(listener);
  227. 	}
  228.  
  229. 	/**
  230. 	 * Removes wheel changing listener
  231. 	 * @param listener the listener
  232. 	 */
  233. 	public void removeChangingListener(OnWheelChangedListener listener) {
  234. 		changingListeners.remove(listener);
  235. 	}
  236. 	
  237. 	/**
  238. 	 * Notifies changing listeners
  239. 	 * @param oldValue the old wheel value
  240. 	 * @param newValue the new wheel value
  241. 	 */
  242. 	protected void notifyChangingListeners(int oldValue, int newValue) {
  243. 		for (OnWheelChangedListener listener : changingListeners) {
  244. 			listener.onChanged(this, oldValue, newValue);
  245. 		}
  246. 	}
  247.  
  248. 	/**
  249. 	 * Adds wheel scrolling listener
  250. 	 * @param listener the listener 
  251. 	 */
  252. 	public void addScrollingListener(OnWheelScrollListener listener) {
  253. 		scrollingListeners.add(listener);
  254. 	}
  255.  
  256. 	/**
  257. 	 * Removes wheel scrolling listener
  258. 	 * @param listener the listener
  259. 	 */
  260. 	public void removeScrollingListener(OnWheelScrollListener listener) {
  261. 		scrollingListeners.remove(listener);
  262. 	}
  263. 	
  264. 	/**
  265. 	 * Notifies listeners about starting scrolling
  266. 	 */
  267. 	protected void notifyScrollingListenersAboutStart() {
  268. 		for (OnWheelScrollListener listener : scrollingListeners) {
  269. 			listener.onScrollingStarted(this);
  270. 		}
  271. 	}
  272.  
  273. 	/**
  274. 	 * Notifies listeners about ending scrolling
  275. 	 */
  276. 	protected void notifyScrollingListenersAboutEnd() {
  277. 		for (OnWheelScrollListener listener : scrollingListeners) {
  278. 			listener.onScrollingFinished(this);
  279. 		}
  280. 	}
  281.  
  282. 	/**
  283. 	 * Gets current value
  284. 	 * 
  285. 	 * @return the current value
  286. 	 */
  287. 	public int getCurrentItem() {
  288. 		return currentItem;
  289. 	}
  290.  
  291. 	/**
  292. 	 * Sets the current item. Does nothing when index is wrong.
  293. 	 * 
  294. 	 * @param index the item index
  295. 	 * @param animated the animation flag
  296. 	 */
  297. 	public void setCurrentItem(int index, boolean animated) {
  298. 		if (adapter == null || adapter.getItemsCount() == 0) {
  299. 			return; // throw?
  300. 		}
  301. 		if (index < 0 || index >= adapter.getItemsCount()) {
  302. 			if (isCyclic) {
  303. 				while (index < 0) {
  304. 					index += adapter.getItemsCount();
  305. 				}
  306. 				index %= adapter.getItemsCount();
  307. 			} else{
  308. 				return; // throw?
  309. 			}
  310. 		}
  311. 		if (index != currentItem) {
  312. 			if (animated) {
  313. 				scroll(index - currentItem, SCROLLING_DURATION);
  314. 			} else {
  315. 				invalidateLayouts();
  316. 			
  317. 				int old = currentItem;
  318. 				currentItem = index;
  319. 			
  320. 				notifyChangingListeners(old, currentItem);
  321. 			
  322. 				invalidate();
  323. 			}
  324. 		}
  325. 	}
  326.  
  327. 	/**
  328. 	 * Sets the current item w/o animation. Does nothing when index is wrong.
  329. 	 * 
  330. 	 * @param index the item index
  331. 	 */
  332. 	public void setCurrentItem(int index) {
  333. 		setCurrentItem(index, false);
  334. 	}	
  335. 	
  336. 	/**
  337. 	 * Tests if wheel is cyclic. That means before the 1st item there is shown the last one
  338. 	 * @return true if wheel is cyclic
  339. 	 */
  340. 	public boolean isCyclic() {
  341. 		return isCyclic;
  342. 	}
  343.  
  344. 	/**
  345. 	 * Set wheel cyclic flag
  346. 	 * @param isCyclic the flag to set
  347. 	 */
  348. 	public void setCyclic(boolean isCyclic) {
  349. 		this.isCyclic = isCyclic;
  350. 		
  351. 		invalidate();
  352. 		invalidateLayouts();
  353. 	}
  354.  
  355. 	/**
  356. 	 * Invalidates layouts
  357. 	 */
  358. 	private void invalidateLayouts() {
  359. 		itemsLayout = null;
  360. 		valueLayout = null;
  361. 		scrollingOffset = 0;
  362. 	}
  363.  
  364. 	/**
  365. 	 * Initializes resources
  366. 	 */
  367. 	private void initResourcesIfNecessary() {
  368. 		DisplayMetrics dm = this.getResources().getDisplayMetrics();
  369. 		int textsize = (int) (TEXT_SIZE* dm.density);
  370. 		
  371. 		if (itemsPaint == null) {
  372. 			itemsPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG
  373. 					| Paint.FAKE_BOLD_TEXT_FLAG);
  374. 			itemsPaint.density = getResources().getDisplayMetrics().density;
  375. 			
  376. 			itemsPaint.setTextSize(textsize);
  377. 		}
  378.  
  379. 		if (valuePaint == null) {
  380. 			valuePaint = new TextPaint(Paint.ANTI_ALIAS_FLAG
  381. 					| Paint.FAKE_BOLD_TEXT_FLAG | Paint.DITHER_FLAG);
  382. 			//valuePaint.density = getResources().getDisplayMetrics().density;
  383. 			valuePaint.setTextSize(textsize);
  384. 			valuePaint.setShadowLayer(0.1f, 0, 0.1f, 0xFFC0C0C0);
  385. 		}
  386.  
  387. 		if (centerDrawable == null) {
  388. 			centerDrawable = getContext().getResources().getDrawable(R.drawable.wheel_val);
  389. 		}
  390.  
  391. 		if (topShadow == null) {
  392. 			topShadow = new GradientDrawable(Orientation.TOP_BOTTOM, SHADOWS_COLORS);
  393. 		}
  394.  
  395. 		if (bottomShadow == null) {
  396. 			bottomShadow = new GradientDrawable(Orientation.BOTTOM_TOP, SHADOWS_COLORS);
  397. 		}
  398.  
  399. 		setBackgroundResource(R.drawable.wheel_bg);
  400. 	}
  401.  
  402. 	/**
  403. 	 * Calculates desired height for layout
  404. 	 * 
  405. 	 * @param layout
  406. 	 *            the source layout
  407. 	 * @return the desired layout height
  408. 	 */
  409. 	private int getDesiredHeight(Layout layout) {
  410. 		if (layout == null) {
  411. 			return 0;
  412. 		}
  413. 		DisplayMetrics dm = this.getResources().getDisplayMetrics();
  414. 		int height = (int) (ADDITIONAL_ITEM_HEIGHT* dm.density);
  415. 		int desired = getItemHeight() * visibleItems - ITEM_OFFSET * 2
  416. 				- height;
  417.  
  418. 		// Check against our minimum height
  419. 		desired = Math.max(desired, getSuggestedMinimumHeight());
  420.  
  421. 		return desired;
  422. 	}
  423.  
  424. 	/**
  425. 	 * Returns text item by index
  426. 	 * @param index the item index
  427. 	 * @return the item or null
  428. 	 */
  429. 	private String getTextItem(int index) {
  430. 		if (adapter == null || adapter.getItemsCount() == 0) {
  431. 			return null;
  432. 		}
  433. 		int count = adapter.getItemsCount();
  434. 		if ((index < 0 || index >= count) && !isCyclic) {
  435. 			return null;
  436. 		} else {
  437. 			while (index < 0) {
  438. 				index = count + index;
  439. 			}
  440. 		}
  441. 		
  442. 		index %= count;
  443. 		return adapter.getItem(index);
  444. 	}
  445. 	
  446. 	/**
  447. 	 * Builds text depending on current value
  448. 	 * 
  449. 	 * @param useCurrentValue
  450. 	 * @return the text
  451. 	 */
  452. 	private String buildText(boolean useCurrentValue) {
  453. 		StringBuilder itemsText = new StringBuilder();
  454. 		int addItems = visibleItems / 2 + 1;
  455.  
  456. 		for (int i = currentItem - addItems; i <= currentItem + addItems; i++) {
  457. 			if (useCurrentValue || i != currentItem) {
  458. 				String text = getTextItem(i);
  459. 				if (text != null) {
  460. 					itemsText.append(text);
  461. 				}
  462. 			}
  463. 			if (i < currentItem + addItems) {
  464. 				itemsText.append("\n");
  465. 			}
  466. 		}
  467. 		
  468. 		return itemsText.toString();
  469. 	}
  470.  
  471. 	/**
  472. 	 * Returns the max item length that can be present
  473. 	 * @return the max length
  474. 	 */
  475. 	private int getMaxTextLength() {
  476. 		WheelAdapter adapter = getAdapter();
  477. 		if (adapter == null) {
  478. 			return 0;
  479. 		}
  480. 		
  481. 		int adapterLength = adapter.getMaximumLength();
  482. 		if (adapterLength > 0) {
  483. 			return adapterLength;
  484. 		}
  485.  
  486. 		String maxText = null;
  487. 		int addItems = visibleItems / 2;
  488. 		for (int i = Math.max(currentItem - addItems, 0);
  489. 				i < Math.min(currentItem + visibleItems, adapter.getItemsCount()); i++) {
  490. 			String text = adapter.getItem(i);
  491. 			if (text != null && (maxText == null || maxText.length() < text.length())) {
  492. 				maxText = text;
  493. 			}
  494. 		}
  495.  
  496. 		return maxText != null ? maxText.length() : 0;
  497. 	}
  498.  
  499. 	/**
  500. 	 * Returns height of wheel item
  501. 	 * @return the item height
  502. 	 */
  503. 	private int getItemHeight() {
  504. 		if (itemHeight != 0) {
  505. 			return itemHeight;
  506. 		} else if (itemsLayout != null && itemsLayout.getLineCount() > 2) {
  507. 			itemHeight = itemsLayout.getLineTop(2) - itemsLayout.getLineTop(1);
  508. 			return itemHeight;
  509. 		}
  510. 		
  511. 		return getHeight() / visibleItems;
  512. 	}
  513.  
  514. 	/**
  515. 	 * Calculates control width and creates text layouts
  516. 	 * @param widthSize the input layout width
  517. 	 * @param mode the layout mode
  518. 	 * @return the calculated control width
  519. 	 */
  520. 	private int calculateLayoutWidth(int widthSize, int mode) {
  521. 		initResourcesIfNecessary();
  522.  
  523. 		int width = widthSize;
  524.  
  525. 		int maxLength = getMaxTextLength();
  526. 		if (maxLength > 0) {
  527. 			float textWidth = FloatMath.ceil(Layout.getDesiredWidth("0", itemsPaint));
  528. 			itemsWidth = (int) (maxLength * textWidth);
  529. 		} else {
  530. 			itemsWidth = 0;
  531. 		}
  532. 		itemsWidth += ADDITIONAL_ITEMS_SPACE; // make it some more
  533.  
  534. 		labelWidth = 0;
  535. 		if (label != null && label.length() > 0) {
  536. 			labelWidth = (int) FloatMath.ceil(Layout.getDesiredWidth(label, valuePaint));
  537. 		}
  538.  
  539. 		boolean recalculate = false;
  540. 		if (mode == MeasureSpec.EXACTLY) {
  541. 			width = widthSize;
  542. 			recalculate = true;
  543. 		} else {
  544. 			width = itemsWidth + labelWidth + 2 * PADDING;
  545. 			if (labelWidth > 0) {
  546. 				width += LABEL_OFFSET;
  547. 			}
  548.  
  549. 			// Check against our minimum width
  550. 			width = Math.max(width, getSuggestedMinimumWidth());
  551.  
  552. 			if (mode == MeasureSpec.AT_MOST && widthSize < width) {
  553. 				width = widthSize;
  554. 				recalculate = true;
  555. 			}
  556. 		}
  557.  
  558. 		if (recalculate) {
  559. 			// recalculate width
  560. 			int pureWidth = width - LABEL_OFFSET - 2 * PADDING;
  561. 			if (pureWidth <= 0) {
  562. 				itemsWidth = labelWidth = 0;
  563. 			}
  564. 			if (labelWidth > 0) {
  565. 				double newWidthItems = (double) itemsWidth * pureWidth
  566. 						/ (itemsWidth + labelWidth);
  567. 				itemsWidth = (int) newWidthItems;
  568. 				labelWidth = pureWidth - itemsWidth;
  569. 			} else {
  570. 				itemsWidth = pureWidth + LABEL_OFFSET; // no label
  571. 			}
  572. 		}
  573.  
  574. 		if (itemsWidth > 0) {
  575. 			createLayouts(itemsWidth, labelWidth);
  576. 		}
  577.  
  578. 		return width;
  579. 	}
  580.  
  581. 	/**
  582. 	 * Creates layouts
  583. 	 * @param widthItems width of items layout
  584. 	 * @param widthLabel width of label layout
  585. 	 */
  586. 	private void createLayouts(int widthItems, int widthLabel) {
  587. 		DisplayMetrics dm = this.getResources().getDisplayMetrics();
  588. 		int height = (int) (ADDITIONAL_ITEM_HEIGHT* dm.density);
  589. 		if (itemsLayout == null || itemsLayout.getWidth() > widthItems) {
  590. 			itemsLayout = new StaticLayout(buildText(isScrollingPerformed), itemsPaint, widthItems,
  591. 					widthLabel > 0 ? Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER,
  592. 					1, height, false);
  593. 		} else {
  594. 			itemsLayout.increaseWidthTo(widthItems);
  595. 		}
  596.  
  597. 		if (!isScrollingPerformed && (valueLayout == null || valueLayout.getWidth() > widthItems)) {
  598. 			String text = getAdapter() != null ? getAdapter().getItem(currentItem) : null;
  599. 			valueLayout = new StaticLayout(text != null ? text : "",
  600. 					valuePaint, widthItems, widthLabel > 0 ?
  601. 							Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER,
  602. 							1, height, false);
  603. 		} else if (isScrollingPerformed) {
  604. 			valueLayout = null;
  605. 		} else {
  606. 			valueLayout.increaseWidthTo(widthItems);
  607. 		}
  608.  
  609. 		if (widthLabel > 0) {
  610. 			if (labelLayout == null || labelLayout.getWidth() > widthLabel) {
  611. 				labelLayout = new StaticLayout(label, valuePaint,
  612. 						widthLabel, Layout.Alignment.ALIGN_NORMAL, 1,
  613. 						height, false);
  614. 			} else {
  615. 				labelLayout.increaseWidthTo(widthLabel);
  616. 			}
  617. 		}
  618. 	}
  619.  
  620. 	@Override
  621. 	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  622. 		int widthMode = MeasureSpec.getMode(widthMeasureSpec);
  623. 		int heightMode = MeasureSpec.getMode(heightMeasureSpec);
  624. 		int widthSize = MeasureSpec.getSize(widthMeasureSpec);
  625. 		int heightSize = MeasureSpec.getSize(heightMeasureSpec);
  626.  
  627. 		int width = calculateLayoutWidth(widthSize, widthMode);
  628.  
  629. 		int height;
  630. 		if (heightMode == MeasureSpec.EXACTLY) {
  631. 			height = heightSize;
  632. 		} else {
  633. 			height = getDesiredHeight(itemsLayout);
  634.  
  635. 			if (heightMode == MeasureSpec.AT_MOST) {
  636. 				height = Math.min(height, heightSize);
  637. 			}
  638. 		}
  639.  
  640. 		setMeasuredDimension(width, height);
  641. 	}
  642.  
  643. 	@Override
  644. 	protected void onDraw(Canvas canvas) {
  645. 		super.onDraw(canvas);
  646. 		
  647. 		if (itemsLayout == null) {
  648. 			if (itemsWidth == 0) {
  649. 				calculateLayoutWidth(getWidth(), MeasureSpec.EXACTLY);
  650. 			} else {
  651. 				createLayouts(itemsWidth, labelWidth);
  652. 			}
  653. 		}
  654.  
  655. 		if (itemsWidth > 0) {
  656. 			canvas.save();
  657. 			// Skip padding space and hide a part of top and bottom items
  658. 			canvas.translate(PADDING, -ITEM_OFFSET);
  659. 			drawItems(canvas);
  660. 			drawValue(canvas);
  661. 			canvas.restore();
  662. 		}
  663.  
  664. 		drawCenterRect(canvas);
  665. 		drawShadows(canvas);
  666. 	}
  667.  
  668. 	/**
  669. 	 * Draws shadows on top and bottom of control
  670. 	 * @param canvas the canvas for drawing
  671. 	 */
  672. 	private void drawShadows(Canvas canvas) {
  673. 		topShadow.setBounds(0, 0, getWidth(), getHeight() / visibleItems);
  674. 		topShadow.draw(canvas);
  675.  
  676. 		bottomShadow.setBounds(0, getHeight() - getHeight() / visibleItems,
  677. 				getWidth(), getHeight());
  678. 		bottomShadow.draw(canvas);
  679. 	}
  680.  
  681. 	/**
  682. 	 * Draws value and label layout
  683. 	 * @param canvas the canvas for drawing
  684. 	 */
  685. 	private void drawValue(Canvas canvas) {
  686. 		valuePaint.setColor(VALUE_TEXT_COLOR);
  687. 		valuePaint.drawableState = getDrawableState();
  688.  
  689. 		Rect bounds = new Rect();
  690. 		itemsLayout.getLineBounds(visibleItems / 2, bounds);
  691.  
  692. 		// draw label
  693. 		if (labelLayout != null) {
  694. 			canvas.save();
  695. 			canvas.translate(itemsLayout.getWidth() + LABEL_OFFSET, bounds.top);
  696. 			labelLayout.draw(canvas);
  697. 			canvas.restore();
  698. 		}
  699.  
  700. 		// draw current value
  701. 		if (valueLayout != null) {
  702. 			canvas.save();
  703. 			canvas.translate(0, bounds.top + scrollingOffset);
  704. 			valueLayout.draw(canvas);
  705. 			canvas.restore();
  706. 		}
  707. 	}
  708.  
  709. 	/**
  710. 	 * Draws items
  711. 	 * @param canvas the canvas for drawing
  712. 	 */
  713. 	private void drawItems(Canvas canvas) {
  714. 		canvas.save();
  715. 		
  716. 		int top = itemsLayout.getLineTop(1);
  717. 		canvas.translate(0, - top + scrollingOffset);
  718. 		Logger.getLogger(WheelView.class.getName()).log(Level.WARNING, ".....top....>>"+top);
  719. 		Logger.getLogger(WheelView.class.getName()).log(Level.WARNING, "....scrollingOffset...>>"+scrollingOffset);
  720. 		itemsPaint.setColor(ITEMS_TEXT_COLOR);
  721. 		itemsPaint.drawableState = getDrawableState();
  722. 		itemsLayout.draw(canvas);
  723. 		
  724. 		canvas.restore();
  725. 	}
  726.  
  727. 	/**
  728. 	 * Draws rect for current value
  729. 	 * @param canvas the canvas for drawing
  730. 	 */
  731. 	private void drawCenterRect(Canvas canvas) {
  732. 		int center = getHeight() / 2;
  733. 		int offset = getItemHeight() / 2;
  734. 		centerDrawable.setBounds(0, center - offset, getWidth(), center + offset);
  735. 		centerDrawable.draw(canvas);
  736. 	}
  737.  
  738. 	@Override
  739. 	public boolean onTouchEvent(MotionEvent event) {
  740. 		WheelAdapter adapter = getAdapter();
  741. 		if (adapter == null) {
  742. 			return true;
  743. 		}
  744. 		
  745. 			if (!gestureDetector.onTouchEvent(event) && event.getAction() == MotionEvent.ACTION_UP) {
  746. 			justify();
  747. 		}
  748. 		return true;
  749. 	}
  750. 	
  751. 	/**
  752. 	 * Scrolls the wheel
  753. 	 * @param delta the scrolling value
  754. 	 */
  755. 	private void doScroll(int delta) {
  756. 		scrollingOffset += delta;
  757. 		
  758. 		int count = scrollingOffset / getItemHeight();
  759. 		int pos = currentItem - count;
  760. 		if (isCyclic && adapter.getItemsCount() > 0) {
  761. 			// fix position by rotating
  762. 			while (pos < 0) {
  763. 				pos += adapter.getItemsCount();
  764. 			}
  765. 			pos %= adapter.getItemsCount();
  766. 		} else if (isScrollingPerformed) {
  767. 			// 
  768. 			if (pos < 0) {
  769. 				count = currentItem;
  770. 				pos = 0;
  771. 			} else if (pos >= adapter.getItemsCount()) {
  772. 				count = currentItem - adapter.getItemsCount() + 1;
  773. 				pos = adapter.getItemsCount() - 1;
  774. 			}
  775. 		} else {
  776. 			// fix position
  777. 			pos = Math.max(pos, 0);
  778. 			pos = Math.min(pos, adapter.getItemsCount() - 1);
  779. 		}
  780. 		
  781. 		int offset = scrollingOffset;
  782. 		if (pos != currentItem) {
  783. 			setCurrentItem(pos, false);
  784. 		} else {
  785. 			invalidate();
  786. 		}
  787. 		
  788. 		// update offset
  789. 		scrollingOffset = offset - count * getItemHeight();
  790. 		if (scrollingOffset > getHeight()) {
  791. 			scrollingOffset = scrollingOffset % getHeight() + getHeight();
  792. 		}
  793. 	}
  794. 	
  795. 	// gesture listener
  796. 	private SimpleOnGestureListener gestureListener = new SimpleOnGestureListener() {
  797. 		public boolean onDown(MotionEvent e) {
  798. 			if (isScrollingPerformed) {
  799. 				scroller.forceFinished(true);
  800. 				clearMessages();
  801. 				return true;
  802. 			}
  803. 			return false;
  804. 		}
  805. 		
  806. 		public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
  807. 			startScrolling();
  808. 			doScroll((int)-distanceY);
  809. 			return true;
  810. 		}
  811. 		
  812. 		public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
  813. 			lastScrollY = currentItem * getItemHeight() + scrollingOffset;
  814. 			int maxY = isCyclic ? 0x7FFFFFFF : adapter.getItemsCount() * getItemHeight();
  815. 			int minY = isCyclic ? -maxY : 0;
  816. 			scroller.fling(0, lastScrollY, 0, (int) -velocityY / 2, 0, 0, minY, maxY);
  817. 			setNextMessage(MESSAGE_SCROLL);
  818. 			return true;
  819. 		}
  820. 	};
  821.  
  822. 	// Messages
  823. 	private final int MESSAGE_SCROLL = 0;
  824. 	private final int MESSAGE_JUSTIFY = 1;
  825. 	
  826. 	/**
  827. 	 * Set next message to queue. Clears queue before.
  828. 	 * 
  829. 	 * @param message the message to set
  830. 	 */
  831. 	private void setNextMessage(int message) {
  832. 		clearMessages();
  833. 		animationHandler.sendEmptyMessage(message);
  834. 	}
  835.  
  836. 	/**
  837. 	 * Clears messages from queue
  838. 	 */
  839. 	private void clearMessages() {
  840. 		animationHandler.removeMessages(MESSAGE_SCROLL);
  841. 		animationHandler.removeMessages(MESSAGE_JUSTIFY);
  842. 	}
  843. 	
  844. 	// animation handler
  845. 	private Handler animationHandler = new Handler() {
  846. 		public void handleMessage(Message msg) {
  847. 			scroller.computeScrollOffset();
  848. 			int currY = scroller.getCurrY();
  849. 			int delta = lastScrollY - currY;
  850. 			lastScrollY = currY;
  851. 			if (delta != 0) {
  852. 				doScroll(delta);
  853. 			}
  854. 			
  855. 			// scrolling is not finished when it comes to final Y
  856. 			// so, finish it manually 
  857. 			if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
  858. 				currY = scroller.getFinalY();
  859. 				scroller.forceFinished(true);
  860. 			}
  861. 			if (!scroller.isFinished()) {
  862. 				animationHandler.sendEmptyMessage(msg.what);
  863. 			} else if (msg.what == MESSAGE_SCROLL) {
  864. 				justify();
  865. 			} else {
  866. 				finishScrolling();
  867. 			}
  868. 		}
  869. 	};
  870. 	
  871. 	/**
  872. 	 * Justifies wheel
  873. 	 */
  874. 	private void justify() {
  875. 		if (adapter == null) {
  876. 			return;
  877. 		}
  878. 		
  879. 		lastScrollY = 0;
  880. 		int offset = scrollingOffset;
  881. 		int itemHeight = getItemHeight();
  882. 		boolean needToIncrease = offset > 0 ? currentItem < adapter.getItemsCount() : currentItem > 0; 
  883. 		if ((isCyclic || needToIncrease) && Math.abs((float) offset) > (float) itemHeight / 2) {
  884. 			if (offset < 0)
  885. 				offset += itemHeight + MIN_DELTA_FOR_SCROLLING;
  886. 			else
  887. 				offset -= itemHeight + MIN_DELTA_FOR_SCROLLING;
  888. 		}
  889. 		if (Math.abs(offset) > MIN_DELTA_FOR_SCROLLING) {
  890. 			scroller.startScroll(0, 0, 0, offset, SCROLLING_DURATION);
  891. 			setNextMessage(MESSAGE_JUSTIFY);
  892. 		} else {
  893. 			finishScrolling();
  894. 		}
  895. 	}
  896. 	
  897. 	/**
  898. 	 * Starts scrolling
  899. 	 */
  900. 	private void startScrolling() {
  901. 		if (!isScrollingPerformed) {
  902. 			isScrollingPerformed = true;
  903. 			notifyScrollingListenersAboutStart();
  904. 		}
  905. 	}
  906.  
  907. 	/**
  908. 	 * Finishes scrolling
  909. 	 */
  910. 	void finishScrolling() {
  911. 		if (isScrollingPerformed) {
  912. 			notifyScrollingListenersAboutEnd();
  913. 			isScrollingPerformed = false;
  914. 		}
  915. 		invalidateLayouts();
  916. 		invalidate();
  917. 	}
  918. 	
  919. 	
  920. 	/**
  921. 	 * Scroll the wheel
  922. 	 * @param itemsToSkip items to scroll
  923. 	 * @param time scrolling duration
  924. 	 */
  925. 	public void scroll(int itemsToScroll, int time) {
  926. 		scroller.forceFinished(true);
  927.  
  928. 		lastScrollY = scrollingOffset;
  929. 		int offset = itemsToScroll * getItemHeight();
  930. 		
  931. 		scroller.startScroll(0, lastScrollY, 0, offset - lastScrollY, time);
  932. 		setNextMessage(MESSAGE_SCROLL);
  933. 		
  934. 		startScrolling();
  935. 	}
  936. 	
  937. 	public int getScroolingOffset(){
  938. 		
  939. 		return scrollingOffset;
  940. 	}
  941.  
  942. }
里面可以修改字体大小颜色 间距等等

第二步，创建一个适配器

  1. package com.wheel.widget;
  2.  
  3. /**
  4.  * Numeric Wheel adapter.
  5.  */
  6. public class NumericWheelAdapter implements WheelAdapter {
  7.  
  8. 	/** The default min value */
  9. 	public static final int DEFAULT_MAX_VALUE = 9;
  10.  
  11. 	/** The default max value */
  12. 	private static final int DEFAULT_MIN_VALUE = 0;
  13.  
  14. 	// Values
  15. 	private int minValue;
  16. 	private int maxValue;
  17.  
  18. 	// Values
  19. 	private double minValue1;
  20. 	private double maxValue1;
  21. 	// format
  22. 	private String format;
  23.  
  24. 	private String values = null;
  25.  
  26. 	private String data[] = new String[215];
  27.  
  28. 	/**
  29. 	 * Constructor
  30. 	 * 
  31. 	 * @param minValue
  32. 	 *            the wheel min value
  33. 	 * @param maxValue
  34. 	 *            the wheel max value
  35. 	 */
  36. 	public NumericWheelAdapter(int minValue, int maxValue) {
  37. 		this.minValue = minValue;
  38. 		this.maxValue = maxValue;
  39. 	}
  40.  
  41. 	/**
  42. 	 * Constructor
  43. 	 * 
  44. 	 * @param minValue
  45. 	 *            the wheel min value
  46. 	 * @param maxValue
  47. 	 *            the wheel max value
  48. 	 * @param format
  49. 	 *            the format string
  50. 	 */
  51. 	public NumericWheelAdapter(int minValue, int maxValue, String format) {
  52. 		this.minValue = minValue;
  53. 		this.maxValue = maxValue;
  54. 		this.format = format;
  55. 	}
  56.  
  57. 	public String getItem(int index) {
  58. 		if (index >= 0 && index < getItemsCount()) {
  59. 			int value = minValue + index;
  60. 			values = (format != null ? String.format(format, value) : Integer
  61. 					.toString(value));
  62. 			setValue(values);
  63. 			return values;
  64. 		}
  65. 		return null;
  66. 	}
  67.  
  68. 	// 杩斿洖褰撳墠閫変腑鐨勫?
  69. 	public String getValues() {
  70. 		return values;
  71. 	}
  72.  
  73. 	public void setValue(String value) {
  74. 		this.values = value;
  75. 	}
  76.  
  77. 	public int getItemsCount() {
  78. 		return maxValue - minValue + 1;
  79. 	}
  80.  
  81. 	// 得到最大项目长度。它是用来确定轮宽度。
  82. 	// 如果返回1,将使用默认轮宽度
  83.  
  84. 	public int getMaximumLength() {
  85. 		int max = Math.max(Math.abs(maxValue), Math.abs(minValue));
  86. 		int maxLen = Integer.toString(max).length();
  87. 		if (minValue < 0) {
  88. 			maxLen++;
  89. 		}
  90. 		return maxValue - minValue + 1;
  91. 	}
  92.  
  93. }

第三步：布局文件 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     android:layout_width="fill_parent"
  4.     android:layout_height="wrap_content"
  5.     android:orientation="vertical" >
  6.  
  7.     <LinearLayout
  8.         android:id="@+id/top_layout"
  9.         android:layout_width="fill_parent"
  10.         android:layout_height="wrap_content"
  11.         android:background="@color/green"
  12.         android:gravity="center"
  13.         android:orientation="horizontal" >
  14.  
  15.         <Button
  16.             android:id="@+id/confirm_btn"
  17.             android:layout_width="wrap_content"
  18.             android:layout_height="45dp"
  19.             android:layout_weight="0.3"
  20.             android:background="@null"
  21.             android:text="@string/confirm"
  22.             android:textColor="@color/white"
  23.             android:textSize="16sp" />
  24.  
  25.         <TextView
  26.             android:id="@+id/diaolog_title_tv"
  27.             android:layout_width="wrap_content"
  28.             android:layout_height="45dp"
  29.             android:layout_weight="1.5"
  30.             android:gravity="center"
  31.             android:padding="10dp"
  32.             android:text="生日"
  33.             android:textColor="@color/white"
  34.             android:textSize="16sp" />
  35.  
  36.         <Button
  37.             android:id="@+id/cancel_btn"
  38.             android:layout_width="wrap_content"
  39.             android:layout_height="45dp"
  40.             android:layout_weight="0.3"
  41.             android:background="@null"
  42.             android:text="@string/cancel"
  43.             android:textColor="@color/white"
  44.             android:textSize="16sp" />
  45.     </LinearLayout>
  46.  
  47.     <ImageView
  48.         android:layout_width="fill_parent"
  49.         android:layout_height="1px"
  50.         android:background="@color/black"
  51.         android:padding="1dp" />
  52.  
  53.     <LinearLayout
  54.         android:id="@+id/date_selelct_layout"
  55.         android:layout_width="fill_parent"
  56.         android:layout_height="fill_parent"
  57.         android:background="@color/white"
  58.         android:orientation="horizontal" >
  59.  
  60.         <com.wheel.widget.WheelView
  61.             android:id="@+id/year"
  62.             android:layout_width="fill_parent"
  63.             android:layout_height="wrap_content"
  64.             android:layout_gravity="center_vertical"
  65.             android:layout_margin="5dp"
  66.             android:layout_weight="1"
  67.             android:padding="5dp" />
  68.  
  69.         <com.wheel.widget.WheelView
  70.             android:id="@+id/month"
  71.             android:layout_width="fill_parent"
  72.             android:layout_height="wrap_content"
  73.             android:layout_gravity="center_vertical"
  74.             android:layout_marginTop="5dp"
  75.             android:layout_marginBottom="5dp"
  76.             android:layout_weight="1"
  77.             android:padding="5dp" />
  78.  
  79.         <com.wheel.widget.WheelView
  80.             android:id="@+id/day"
  81.             android:layout_width="fill_parent"
  82.             android:layout_height="wrap_content"
  83.             android:layout_gravity="center_vertical"
  84.             android:layout_margin="5dp"
  85.             android:layout_weight="1"
  86.             android:padding="5dp" />
  87.  
  88.         <com.wheel.widget.WheelView
  89.             android:id="@+id/hours"
  90.             android:layout_width="fill_parent"
  91.             android:layout_height="wrap_content"
  92.             android:layout_gravity="center_vertical"
  93.             android:layout_marginTop="5dp"
  94.             android:layout_marginBottom="5dp"
  95.             android:layout_weight="1"
  96.             android:padding="5dp" />
  97.  
  98.         <com.wheel.widget.WheelView
  99.             android:id="@+id/mins"
  100.             android:layout_width="fill_parent"
  101.             android:layout_height="wrap_content"
  102.             android:layout_gravity="center_vertical"
  103.             android:layout_margin="5dp"
  104.             android:layout_weight="1"
  105.             android:padding="5dp" />
  106.  
  107.         <com.wheel.widget.WheelView
  108.             android:id="@+id/seconds"
  109.             android:layout_width="fill_parent"
  110.             android:layout_height="wrap_content"
  111.             android:layout_gravity="center_vertical"
  112.             android:layout_marginTop="5dp"
  113.             android:layout_marginBottom="5dp"
  114.             android:layout_marginRight="5dp"
  115.             android:layout_weight="1"
  116.             android:padding="5dp" />
  117.     </LinearLayout>
  118.  
  119. </LinearLayout>
第四步 ： 自定义一个dialog 

  1. package com.wheel.view;
  2.  
  3. import java.util.Arrays;
  4. import java.util.Calendar;
  5. import java.util.List;
  6.  
  7. import android.app.Dialog;
  8. import android.content.Context;
  9. import android.os.Bundle;
  10. import android.util.Log;
  11. import android.view.View;
  12. import android.view.Window;
  13. import android.widget.Button;
  14. import android.widget.LinearLayout;
  15. import android.widget.LinearLayout.LayoutParams;
  16. import android.widget.TextView;
  17.  
  18. import com.example.mywheel.R;
  19. import com.wheel.widget.NumericWheelAdapter;
  20. import com.wheel.widget.OnWheelChangedListener;
  21. import com.wheel.widget.WheelView;
  22.  
  23. /**
  24.  * 日期选择�?
  25.  * 
  26.  * @author Administrator
  27.  * 
  28.  */
  29. public class BirthDateDialog extends Dialog implements
  30. 		android.view.View.OnClickListener {
  31. 	/**
  32. 	 * 自定义Dialog监听�?
  33. 	 */
  34. 	public interface PriorityListener {
  35. 		/**
  36. 		 * 回调函数，用于在Dialog的监听事件触发后刷新Activity的UI显示
  37. 		 */
  38. 		public void refreshPriorityUI(String year, String month, String day,
  39. 				String hours, String mins);
  40. 	}
  41.  
  42. 	private PriorityListener lis;
  43. 	private boolean scrolling = false;
  44. 	private Context context = null;
  45. 	public Button softInfo = null;
  46. 	public Button softInfoButton = null;
  47. 	private NumericWheelAdapter year_adapter = null;
  48. 	private NumericWheelAdapter month_adapter = null;
  49. 	private NumericWheelAdapter day_adapter = null;
  50. 	private NumericWheelAdapter hours_adapter = null;
  51. 	private NumericWheelAdapter mins_adapter = null;
  52. 	private NumericWheelAdapter seconds_adapter = null;
  53. 	private Button btn_sure = null;
  54. 	private Button btn_cancel = null;
  55. 	private int curYear = 0;
  56. 	private int curMonth = 0;
  57. 	private int curDay = 0;
  58. 	private int hours = 0;
  59. 	private int mins = 0;
  60. 	private int seconds = 0;
  61. 	private WheelView monthview = null;
  62. 	private WheelView yearview = null;
  63. 	private WheelView dayview = null;
  64. 	private WheelView hoursview = null;
  65. 	private WheelView minsview = null;
  66. 	private WheelView secondsview = null;
  67. 	private static int theme = R.style.myDialog;// 主题
  68. 	private LinearLayout date_layout;
  69. 	private int width, height;// 对话框宽高
  70. 	private TextView title_tv;
  71. 	private String title;
  72.  
  73. 	public BirthDateDialog(final Context context,
  74. 			final PriorityListener listener, int currentyear, int currentmonth,
  75. 			int currentday, int hours, int mins, int seconds, int width,
  76. 			int height, String title) {
  77. 		super(context, theme);
  78. 		this.context = context;
  79. 		lis = listener;
  80. 		this.curYear = currentyear;
  81. 		this.curMonth = currentmonth;
  82. 		this.curDay = currentday;
  83. 		this.width = width;
  84. 		this.title = title;
  85. 		this.hours = hours;
  86. 		this.mins = mins;
  87. 		this.height = height;
  88. 		this.seconds = seconds;
  89. 	}
  90.  
  91. 	@Override
  92. 	protected void onCreate(Bundle savedInstanceState) {
  93. 		// TODO Auto-generated method stub
  94. 		super.onCreate(savedInstanceState);
  95. 		setContentView(R.layout.date_select_wheel);
  96. 		btn_sure = (Button) findViewById(R.id.confirm_btn);
  97. 		btn_sure.setOnClickListener(this);
  98. 		btn_cancel = (Button) findViewById(R.id.cancel_btn);
  99. 		btn_cancel.setOnClickListener(this);
  100. 		date_layout = (LinearLayout) findViewById(R.id.date_selelct_layout);
  101. 		LayoutParams lparams_hours = new LayoutParams(width, height / 3 + 10);
  102. 		date_layout.setLayoutParams(lparams_hours);
  103. 		title_tv = (TextView) findViewById(R.id.diaolog_title_tv);
  104. 		title_tv.setText(title);
  105. 		yearview = (WheelView) findViewById(R.id.year);
  106. 		monthview = (WheelView) findViewById(R.id.month);
  107. 		dayview = (WheelView) findViewById(R.id.day);
  108. 		hoursview = (WheelView) findViewById(R.id.hours);
  109. 		minsview = (WheelView) findViewById(R.id.mins);
  110. 		secondsview = (WheelView) findViewById(R.id.seconds);
  111. 		OnWheelChangedListener listener = new OnWheelChangedListener() {
  112. 			public void onChanged(WheelView wheel, int oldValue, int newValue) {
  113. 				if (!scrolling) {
  114. 					updateDays(yearview, monthview, dayview);
  115. 				}
  116. 			}
  117. 		};
  118. 		monthview.addChangingListener(listener);
  119. 		yearview.addChangingListener(listener);
  120. 		Calendar calendar = Calendar.getInstance();
  121. 		if (this.curYear == 0 || this.curMonth == 0) {
  122. 			curYear = calendar.get(Calendar.YEAR);
  123. 			curMonth = calendar.get(Calendar.MONTH) + 1;
  124. 			curDay = calendar.get(Calendar.DAY_OF_MONTH);
  125. 		}
  126. 		// 初始化数�?�?
  127. 		year_adapter = new NumericWheelAdapter(1900, 2100);
  128. 		yearview.setAdapter(year_adapter);
  129. 		int cc = curYear - 1900;// 按下标来�?
  130. 		yearview.setCurrentItem(cc);// 传�?过去的是下标
  131. 		yearview.setVisibleItems(5);
  132. 		month_adapter = new NumericWheelAdapter(1, 12, "%02d");
  133. 		monthview.setAdapter(month_adapter);
  134. 		monthview.setCurrentItem(curMonth - 1);
  135. 		monthview.setCyclic(false);
  136. 		monthview.setVisibleItems(5);
  137. 		updateDays(yearview, monthview, dayview);
  138. 		dayview.setCyclic(false);
  139. 		dayview.setVisibleItems(5);
  140. 		hours_adapter = new NumericWheelAdapter(0, 23, "%02d");
  141. 		hoursview.setAdapter(hours_adapter);
  142. 		hoursview.setCurrentItem(hours);
  143. 		hoursview.setCyclic(false);
  144. 		hoursview.setVisibleItems(5);
  145. 		mins_adapter = new NumericWheelAdapter(0, 59, "%02d");
  146. 		minsview.setAdapter(mins_adapter);
  147. 		minsview.setCurrentItem(mins);
  148. 		minsview.setCyclic(false);
  149. 		minsview.setVisibleItems(5);
  150. 		seconds_adapter = new NumericWheelAdapter(0, 59, "%02d");
  151. 		secondsview.setAdapter(seconds_adapter);
  152. 		secondsview.setCurrentItem(seconds);
  153. 		secondsview.setCyclic(false);
  154. 		secondsview.setVisibleItems(5);
  155. 	}
  156.  
  157. 	/**
  158. 	 * 根据年份和月份来更新日期
  159. 	 */
  160. 	private void updateDays(WheelView year, WheelView month, WheelView day) {
  161. 		// 添加大小月月份并将其转换为list,方便之后的判�?
  162. 		String[] months_big = { "1", "3", "5", "7", "8", "10", "12" };
  163. 		String[] months_little = { "4", "6", "9", "11" };
  164.  
  165. 		final List<String> list_big = Arrays.asList(months_big);
  166. 		final List<String> list_little = Arrays.asList(months_little);
  167. 		int year_num = year.getCurrentItem() + 1900;
  168. 		// 判断大小月及是否闰年,用来确定"�?的数�?
  169. 		if (list_big.contains(String.valueOf(month.getCurrentItem() + 1))) {
  170. 			day_adapter = new NumericWheelAdapter(1, 31, "%02d");
  171. 		} else if (list_little
  172. 				.contains(String.valueOf(month.getCurrentItem() + 1))) {
  173. 			day_adapter = new NumericWheelAdapter(1, 30, "%02d");
  174. 		} else {
  175. 			if ((year_num % 4 == 0 && year_num % 100 != 0)
  176. 					|| year_num % 400 == 0)
  177. 				day_adapter = new NumericWheelAdapter(1, 29, "%02d");
  178. 			else
  179. 				day_adapter = new NumericWheelAdapter(1, 28, "%02d");
  180. 		}
  181. 		dayview.setAdapter(day_adapter);
  182. 		dayview.setCurrentItem(curDay - 1);
  183. 	}
  184.  
  185. 	public BirthDateDialog(Context context, PriorityListener listener) {
  186. 		super(context, theme);
  187. 		this.context = context;
  188. 	}
  189.  
  190. 	public BirthDateDialog(Context context, String birthDate) {
  191. 		super(context, theme);
  192. 		this.context = context;
  193.  
  194. 	}
  195.  
  196. 	@Override
  197. 	public void onClick(View v) {
  198. 		switch (v.getId()) {
  199. 		case R.id.confirm_btn:
  200. 			lis.refreshPriorityUI(year_adapter.getValues(),
  201. 					month_adapter.getValues(), day_adapter.getValues(),
  202. 					hours_adapter.getValues(), mins_adapter.getValues());
  203.  
  204. 			this.dismiss();
  205. 			break;
  206. 		case R.id.cancel_btn:
  207. 			this.dismiss();
  208. 			break;
  209. 		default:
  210. 			break;
  211. 		}
  212. 	}
  213.  
  214. 	@Override
  215. 	public void dismiss() {
  216. 		super.dismiss();
  217. 	}
  218.  
  219. 	@Override
  220. 	protected void onStop() {
  221. 		super.onStop();
  222. 	}
  223. }

第五步：dialog样式 在底部 

  1. // 时间
  2. 	public void getDate() {
  3. 		DisplayMetrics dm = new DisplayMetrics();
  4. 		this.getWindowManager().getDefaultDisplay().getMetrics(dm);
  5. 		int width = dm.widthPixels;
  6. 		int height = dm.heightPixels;
  7. 		String curDate = date_tv.getText().toString();
  8. 		int[] date = getYMDArray(curDate, "-");
  9. 		int[] time = getYMDArray(time_tv.getText().toString(), ":");
  10. 		BirthDateDialog birthDiolog = new BirthDateDialog(this,
  11. 				new PriorityListener() {
  12. 					@Override
  13. 					public void refreshPriorityUI(String year, String month,
  14. 							String day, String hours, String mins) {
  15. 						date_tv.setText(year + "-" + month + "-" + day);
  16. 						time_tv.setText(hours + ":" + mins);
  17. 					}
  18. 				}, date[0], date[1], date[2], time[0], time[1], time[2], width,
  19. 				height, "测量时间");
  20. 		Window window = birthDiolog.getWindow();
  21. 		window.setGravity(Gravity.BOTTOM); // 此处可以设置dialog显示的位置
  22. 		window.setWindowAnimations(R.style.dialogstyle); // 添加动画
  23. 		birthDiolog.setCancelable(true);
  24. 		birthDiolog.show();
  25. 	}


以上就是关键代码，待会会把整个项目贴上来  有不足之处 请多多谅解



声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/278828?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号