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

Android自定义日期滚动控件_datechoosewheelview

作者：很楠不爱3 | 2024-03-21 05:31:58

赞

踩

datechoosewheelview

今天公司让做一个滚动选择日期的功能，在网上搜到了很多，但一放到自己的项目中就变成了按钮点击的效果，后来发现只要设置Theme滚动效果就会消失。

滚动控件参考：

http://www.cnblogs.com/tiantianbyconan/p/3819304.html

https://github.com/wangjiegulu/WheelView

源代码中还需要引入两个依赖工程，这里通过提取依赖工程的代码对其进行了简化。

1、滚动控件WheelView代码：

  1. package com.cx.datechoosedialog;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import android.app.Activity;
  7. import android.content.Context;
  8. import android.graphics.Canvas;
  9. import android.graphics.Color;
  10. import android.graphics.ColorFilter;
  11. import android.graphics.Paint;
  12. import android.graphics.drawable.Drawable;
  13. import android.util.AttributeSet;
  14. import android.util.TypedValue;
  15. import android.view.Gravity;
  16. import android.view.MotionEvent;
  17. import android.view.ViewGroup;
  18. import android.widget.LinearLayout;
  19. import android.widget.ScrollView;
  20. import android.widget.TextView;
  21.  
  22. /**
  23.  * Author: wangjie
  24.  * Email: tiantian.china.2@gmail.com
  25.  * Date: 7/1/14.
  26.  */
  27. public class WheelView extends ScrollView {
  28.     public static final String TAG = WheelView.class.getSimpleName();
  29.  
  30.     public static class OnWheelViewListener {
  31.         public void onSelected(int selectedIndex, String item) {
  32.         }
  33.  
  34.         ;
  35.     }
  36.  
  37.  
  38.     private Context context;
  39. //    private ScrollView scrollView;
  40.  
  41.     private LinearLayout views;
  42.  
  43.     public WheelView(Context context) {
  44.         super(context);
  45.         init(context);
  46.     }
  47.  
  48.     public WheelView(Context context, AttributeSet attrs) {
  49.         super(context, attrs);
  50.         init(context);
  51.     }
  52.  
  53.     public WheelView(Context context, AttributeSet attrs, int defStyle) {
  54.         super(context, attrs, defStyle);
  55.         init(context);
  56.     }
  57.  
  58.     //    String[] items;
  59.     List<String> items;
  60.  
  61.     private List<String> getItems() {
  62.         return items;
  63.     }
  64.  
  65.     public void setItems(List<String> list) {
  66. //        if (null == items) {
  67.             items = new ArrayList<String>();
  68. //        }
  69.         items.clear();
  70.         items.addAll(list);
  71.  
  72.         // 前面和后面补全
  73.         for (int i = 0; i < offset; i++) {
  74.             items.add(0, "");
  75.             items.add("");
  76.         }
  77.  
  78.         initData();
  79.  
  80.     }
  81.  
  82.  
  83.     public static final int OFF_SET_DEFAULT = 1;
  84.     int offset = OFF_SET_DEFAULT; // 偏移量（需要在最前面和最后面补全）
  85.  
  86.     public int getOffset() {
  87.         return offset;
  88.     }
  89.  
  90.     public void setOffset(int offset) {
  91.         this.offset = offset;
  92.     }
  93.  
  94.     int displayItemCount; // 每页显示的数量
  95.  
  96.     int selectedIndex = 1;
  97.  
  98.  
  99.     private void init(Context context) {
  100.         this.context = context;
  101.  
  102.         this.setVerticalScrollBarEnabled(false);
  103.  
  104.         views = new LinearLayout(context);
  105.         views.setOrientation(LinearLayout.VERTICAL);
  106.         this.addView(views);
  107.  
  108.         scrollerTask = new Runnable() {
  109.  
  110.             public void run() {
  111.  
  112.                 int newY = getScrollY();
  113.                 if (initialY - newY == 0) { // stopped
  114.                     final int remainder = initialY % itemHeight;
  115.                     final int divided = initialY / itemHeight;
  116.                     if (remainder == 0) {
  117.                         selectedIndex = divided + offset;
  118.  
  119.                         onSeletedCallBack();
  120.                     } else {
  121.                         if (remainder > itemHeight / 2) {
  122.                             WheelView.this.post(new Runnable() {
  123.                                 @Override
  124.                                 public void run() {
  125.                                     WheelView.this.smoothScrollTo(0, initialY - remainder + itemHeight);
  126.                                     selectedIndex = divided + offset + 1;
  127.                                     onSeletedCallBack();
  128.                                 }
  129.                             });
  130.                         } else {
  131.                             WheelView.this.post(new Runnable() {
  132.                                 @Override
  133.                                 public void run() {
  134.                                     WheelView.this.smoothScrollTo(0, initialY - remainder);
  135.                                     selectedIndex = divided + offset;
  136.                                     onSeletedCallBack();
  137.                                 }
  138.                             });
  139.                         }
  140.  
  141.  
  142.                     }
  143.  
  144.  
  145.                 } else {
  146.                     initialY = getScrollY();
  147.                     WheelView.this.postDelayed(scrollerTask, newCheck);
  148.                 }
  149.             }
  150.         };
  151.  
  152.  
  153.     }
  154.  
  155.     int initialY;
  156.  
  157.     Runnable scrollerTask;
  158.     int newCheck = 50;
  159.  
  160.     public void startScrollerTask() {
  161.  
  162.         initialY = getScrollY();
  163.         this.postDelayed(scrollerTask, newCheck);
  164.     }
  165.  
  166.     private void initData() {
  167.     	views.removeAllViews();
  168.     
  169.         displayItemCount = offset * 2 + 1;
  170.  
  171.         for (String item : items) {
  172.             views.addView(createView(item));
  173.         }
  174.  
  175.         refreshItemView(0);
  176.     }
  177.  
  178.     int itemHeight = 0;
  179.  
  180.     private TextView createView(String item) {
  181.         TextView tv = new TextView(context);
  182.         tv.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
  183.         tv.setSingleLine(true);
  184.         tv.setTextSize(TypedValue.COMPLEX_UNIT_SP, 20);
  185.         tv.setText(item);
  186.         tv.setGravity(Gravity.CENTER);
  187.         int padding = Utility.dip2px(context, 15);
  188.         tv.setPadding(padding, padding, padding, padding);
  189.         if (0 == itemHeight) {
  190.             itemHeight = Utility.getViewMeasuredHeight(tv);
  191.             views.setLayoutParams(new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, itemHeight * displayItemCount));
  192.             LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) this.getLayoutParams();
  193.             this.setLayoutParams(new LinearLayout.LayoutParams(lp.width, itemHeight * displayItemCount));
  194.         }
  195.         return tv;
  196.     }
  197.  
  198.     @Override
  199.     protected void onScrollChanged(int l, int t, int oldl, int oldt) {
  200.         super.onScrollChanged(l, t, oldl, oldt);
  201.  
  202.         refreshItemView(t);
  203.  
  204.         if (t > oldt) {
  205. //            Logger.d(TAG, "向下滚动");
  206.             scrollDirection = SCROLL_DIRECTION_DOWN;
  207.         } else {
  208. //            Logger.d(TAG, "向上滚动");
  209.             scrollDirection = SCROLL_DIRECTION_UP;
  210.  
  211.         }
  212.  
  213.  
  214.     }
  215.  
  216.     private void refreshItemView(int y) {
  217.         int position = y / itemHeight + offset;
  218.         int remainder = y % itemHeight;
  219.         int divided = y / itemHeight;
  220.  
  221.         if (remainder == 0) {
  222.             position = divided + offset;
  223.         } else {
  224.             if (remainder > itemHeight / 2) {
  225.                 position = divided + offset + 1;
  226.             }
  227.         }
  228.  
  229.         int childSize = views.getChildCount();
  230.         for (int i = 0; i < childSize; i++) {
  231.             TextView itemView = (TextView) views.getChildAt(i);
  232.             if (null == itemView) {
  233.                 return;
  234.             }
  235.             if (position == i) {
  236.                 itemView.setTextColor(Color.parseColor("#0288ce"));
  237.             } else {
  238.                 itemView.setTextColor(Color.parseColor("#bbbbbb"));
  239.             }
  240.         }
  241.     }
  242.  
  243.     /**
  244.      * 获取选中区域的边界
  245.      */
  246.     int[] selectedAreaBorder;
  247.  
  248.     private int[] obtainSelectedAreaBorder() {
  249.         if (null == selectedAreaBorder) {
  250.             selectedAreaBorder = new int[2];
  251.             selectedAreaBorder[0] = itemHeight * offset;
  252.             selectedAreaBorder[1] = itemHeight * (offset + 1);
  253.         }
  254.         return selectedAreaBorder;
  255.     }
  256.  
  257.  
  258.     private int scrollDirection = -1;
  259.     private static final int SCROLL_DIRECTION_UP = 0;
  260.     private static final int SCROLL_DIRECTION_DOWN = 1;
  261.  
  262.     Paint paint;
  263.     int viewWidth;
  264.  
  265.     @Override
  266.     public void setBackgroundDrawable(Drawable background) {
  267.  
  268.         if (viewWidth == 0) {
  269.             viewWidth = ((Activity) context).getWindowManager().getDefaultDisplay().getWidth();
  270.         }
  271.  
  272.         if (null == paint) {
  273.             paint = new Paint();
  274.             paint.setColor(Color.parseColor("#83cde6"));
  275.             paint.setStrokeWidth(Utility.dip2px(context, 1f));
  276.         }
  277.  
  278.         background = new Drawable() {
  279.             @Override
  280.             public void draw(Canvas canvas) {
  281.                 canvas.drawLine(viewWidth * 1 / 6, obtainSelectedAreaBorder()[0], viewWidth * 5 / 6, obtainSelectedAreaBorder()[0], paint);
  282.                 canvas.drawLine(viewWidth * 1 / 6, obtainSelectedAreaBorder()[1], viewWidth * 5 / 6, obtainSelectedAreaBorder()[1], paint);
  283.             }
  284.  
  285.             @Override
  286.             public void setAlpha(int alpha) {
  287.  
  288.             }
  289.  
  290.             @Override
  291.             public void setColorFilter(ColorFilter cf) {
  292.  
  293.             }
  294.  
  295.             @Override
  296.             public int getOpacity() {
  297.                 return 0;
  298.             }
  299.         };
  300.  
  301.  
  302.         super.setBackgroundDrawable(background);
  303.  
  304.     }
  305.  
  306.     @Override
  307.     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
  308.         super.onSizeChanged(w, h, oldw, oldh);
  309.         viewWidth = w;
  310.         setBackgroundDrawable(null);
  311.     }
  312.  
  313.     /**
  314.      * 选中回调
  315.      */
  316.     private void onSeletedCallBack() {
  317.         if (null != onWheelViewListener) {
  318.             onWheelViewListener.onSelected(selectedIndex, items.get(selectedIndex));
  319.         }
  320.  
  321.     }
  322.  
  323.     public void setSeletion(int position) {
  324.         final int p = position;
  325.         selectedIndex = p + offset;
  326.         this.post(new Runnable() {
  327.             @Override
  328.             public void run() {
  329.                 WheelView.this.smoothScrollTo(0, p * itemHeight);
  330.             }
  331.         });
  332.  
  333.     }
  334.  
  335.     public String getSeletedItem() {
  336.         return items.get(selectedIndex);
  337.     }
  338.  
  339.     public int getSeletedIndex() {
  340.         return selectedIndex - offset;
  341.     }
  342.  
  343.  
  344.     @Override
  345.     public void fling(int velocityY) {
  346.         super.fling(velocityY / 3);
  347.     }
  348.  
  349.     @Override
  350.     public boolean onTouchEvent(MotionEvent ev) {
  351.         if (ev.getAction() == MotionEvent.ACTION_UP) {
  352.  
  353.             startScrollerTask();
  354.         }
  355.         return super.onTouchEvent(ev);
  356.     }
  357.  
  358.     private OnWheelViewListener onWheelViewListener;
  359.  
  360.     public OnWheelViewListener getOnWheelViewListener() {
  361.         return onWheelViewListener;
  362.     }
  363.  
  364.     public void setOnWheelViewListener(OnWheelViewListener onWheelViewListener) {
  365.         this.onWheelViewListener = onWheelViewListener;
  366.     }
  367.  
  368.  
  369. }
  370.
2、依赖工程中提取的方法 
  1. package com.cx.datechoosedialog;
  2.  
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Calendar;
  6. import java.util.Date;
  7.  
  8. import android.annotation.SuppressLint;
  9. import android.content.Context;
  10. import android.view.View;
  11.  
  12. @SuppressLint("SimpleDateFormat")
  13. public class Utility {
  14.  
  15. 	/**
  16.      * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
  17.      */
  18.     public static int dip2px(Context context, float dpValue) {
  19.         final float scale = context.getResources().getDisplayMetrics().density;
  20.         return (int) (dpValue * scale + 0.5f);
  21.     }
  22.     
  23.     /**
  24.      * 获取控件的高度，如果获取的高度为0，则重新计算尺寸后再返回高度
  25.      *
  26.      * @param view
  27.      * @return
  28.      */
  29.     public static int getViewMeasuredHeight(View view) {
  30.         calcViewMeasure(view);
  31.         return view.getMeasuredHeight();
  32.     }
  33.     
  34.     /**
  35.      * 测量控件的尺寸
  36.      *
  37.      * @param view
  38.      */
  39.     public static void calcViewMeasure(View view) {
  40.         int width = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED);
  41.         int expandSpec = View.MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, View.MeasureSpec.AT_MOST);
  42.         view.measure(width, expandSpec);
  43.     }
  44.     
  45.     public static String dateFormat(Date date) {  
  46.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");  
  47.         return sdf.format(date);  
  48.     }
  49.     
  50.     public static String dateFormatDay(Date date) {  
  51.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
  52.         return sdf.format(date);  
  53.     }
  54.     
  55.     /**** 
  56.      * 获取月末最后一天 
  57.      *  
  58.      * @param sDate 
  59.      *            2014-11-24 
  60.      * @return 30 
  61.      */  
  62.     public static String getMonthMaxDay(String sDate) {  
  63.         SimpleDateFormat sdf_full = new SimpleDateFormat("yyyy-MM-dd");  
  64.         Calendar cal = Calendar.getInstance();  
  65.         Date date = null;  
  66.         try {  
  67.             date = sdf_full.parse(sDate + "-01");  
  68.         } catch (ParseException e) {  
  69.             e.printStackTrace();  
  70.         }  
  71.         cal.setTime(date);  
  72.         int last = cal.getActualMaximum(Calendar.DATE);  
  73.         return String.valueOf(last);  
  74.     }
  75. }
通过自定义Dialog实现日期选择控件，这里也可以控制日期的可选范围 

  1. package com.cx.datechoosedialog;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Date;
  5. import java.util.List;
  6.  
  7. import android.annotation.SuppressLint;
  8. import android.app.Dialog;
  9. import android.content.Context;
  10. import android.content.DialogInterface;
  11. import android.view.LayoutInflater;
  12. import android.view.View;
  13. import android.view.ViewGroup.LayoutParams;
  14. import android.widget.Button;
  15. import android.widget.TextView;
  16.  
  17. import com.cx.datechoosedialog.WheelView.OnWheelViewListener;
  18.  
  19. public class DateChooseDialog extends Dialog {
  20.  
  21. 	public DateChooseDialog(Context context) {
  22. 		super(context);
  23. 		// TODO Auto-generated constructor stub
  24. 	}
  25. 	
  26. 	public DateChooseDialog(Context context, int theme) {  
  27.         super(context, theme);  
  28.     }  
  29.  
  30. 	@SuppressLint("NewApi")
  31. 	public static class Builder{  
  32.         private Context context;  
  33.         private String title;  
  34.         private int yearsSeletion;
  35.         private int monthSeletion;
  36.         private int daySeletion;
  37.         private List<String> yearsItems;
  38.         private List<String> monthItems;
  39.         private List<String> dayItems;
  40.         private TextView textView;
  41.         private TextView tvTime;  
  42.         private WheelView wheelView1, wheelView2, wheelView3;
  43.         private Button positiveButton, negativeButton;
  44.         private DialogInterface.OnClickListener positiveButtonClickListener;  
  45.         private DialogInterface.OnClickListener negativeButtonClickListener;
  46.         private String years;
  47.         private String month;
  48.         private String day;
  49.   
  50.         public Builder(Context context) {  
  51.             this.context = context;  
  52.             yearsItems = new ArrayList<String>();
  53.             monthItems = new ArrayList<String>();
  54.             dayItems = new ArrayList<String>();
  55.             
  56.             String date = Utility.dateFormatDay(new Date());
  57.             years = date.split("-")[0];
  58.             month = date.split("-")[1];
  59.             day = date.split("-")[2];
  60.             
  61.             for(int i = 2000; i < 2030; i++){
  62.             	yearsItems.add(i + "");
  63.             }
  64.             for(int i = 0; i < 12; i++){
  65.             	if(1 + i < 10){
  66.             		monthItems.add("0" + (1 + i));
  67.             	}else{
  68.             		monthItems.add(1 + i + "");
  69.             	}
  70.             }
  71.             for(int i = 0; i < Integer.valueOf(Utility.getMonthMaxDay(Utility.dateFormat(new Date()))); i++){
  72.             	if(1 + i < 10){
  73.             		dayItems.add("0" + (1 + i));
  74.             	}else{
  75.             		dayItems.add(1 + i + "");
  76.             	}
  77.             }
  78.             yearsSeletion = Integer.valueOf(date.split("-")[0]) - 2000;
  79.             monthSeletion = Integer.valueOf(date.split("-")[1]) - 1;
  80.             daySeletion = Integer.valueOf(date.split("-")[2]) - 1;
  81.         }  
  82.   
  83.         /** 
  84.          * Set the Dialog title from resource 
  85.          *  
  86.          * @param title 
  87.          * @return 
  88.          */  
  89.         public Builder setTitle(int title) {  
  90.             this.title = (String) context.getText(title);  
  91.             return this;  
  92.         }  
  93.   
  94.         /** 
  95.          * Set the Dialog title from String 
  96.          *  
  97.          * @param title 
  98.          * @return 
  99.          */  
  100.   
  101.         public Builder setTitle(String title) {  
  102.             this.title = title;  
  103.             return this;  
  104.         }
  105.         
  106.         public Builder setYearsItems(List<String> list){
  107.         	this.yearsItems = list;  
  108.             return this;
  109.         }
  110.         
  111.         public Builder setMonthItems(List<String> list){
  112.         	this.monthItems = list;  
  113.             return this;
  114.         }
  115.         
  116.         public Builder setTextView(TextView tv) {  
  117.             this.textView = tv;  
  118.             return this;  
  119.         }
  120.   
  121.         /** 
  122.          * Set the positive button resource and it's listener 
  123.          *  
  124.          * @param positiveButtonText 
  125.          * @return 
  126.          */  
  127.         public Builder setPositiveButton(int positiveButtonText,  
  128.                 DialogInterface.OnClickListener listener) {  
  129.             this.positiveButtonClickListener = listener;  
  130.             return this;  
  131.         }  
  132.         
  133.         public Builder setPositiveButton(String positiveButtonText,  
  134.                 DialogInterface.OnClickListener listener) {  
  135.             this.positiveButtonClickListener = listener;  
  136.             return this;  
  137.         }
  138.   
  139.         public Builder setNegativeButton(int negativeButtonText,  
  140.                 DialogInterface.OnClickListener listener) {  
  141.             this.negativeButtonClickListener = listener;  
  142.             return this;  
  143.         }  
  144.         
  145.         public Builder setNegativeButton(String negativeButtonText,  
  146.                 DialogInterface.OnClickListener listener) {  
  147.             this.negativeButtonClickListener = listener;  
  148.             return this;  
  149.         } 
  150.   
  151.         public DateChooseDialog create() {  
  152.             LayoutInflater inflater = (LayoutInflater) context  
  153.                     .getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
  154.             // instantiate the dialog with the custom Theme  
  155.             final DateChooseDialog dialog = new DateChooseDialog(context, R.style.Dialog);  
  156.             View layout = inflater.inflate(R.layout.date_choose_dialog, null);  
  157.             tvTime = (TextView) layout.findViewById(R.id.title);
  158.             wheelView1 = (WheelView)layout.findViewById(R.id.wheelview1);
  159.             wheelView2 = (WheelView)layout.findViewById(R.id.wheelview2);
  160.             wheelView3 = (WheelView)layout.findViewById(R.id.wheelview3);
  161.             positiveButton = (Button) layout.findViewById(R.id.positiveButton);
  162.             negativeButton = (Button) layout.findViewById(R.id.negativeButton);
  163.             
  164.             dialog.addContentView(layout, new LayoutParams(  
  165.                     LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT));  
  166.             // set the dialog title  
  167.             tvTime.setText(title);  
  168.             // set the confirm button  
  169.             positiveButton.setOnClickListener(new View.OnClickListener() {  
  170.                 public void onClick(View v) {  
  171.             		textView.setText(years + "-" 
  172.             				+ month + "-"
  173.             				+ day);
  174.             		
  175.                     positiveButtonClickListener.onClick(dialog,  
  176.                             DialogInterface.BUTTON_POSITIVE);  
  177.                 }  
  178.             });  
  179.             negativeButton.setOnClickListener(new View.OnClickListener() {  
  180.                 public void onClick(View v) {  
  181.                     negativeButtonClickListener.onClick(dialog,  
  182.                             DialogInterface.BUTTON_NEGATIVE);  
  183.                 }  
  184.             }); 
  185.             
  186.             // set the content message  
  187.             wheelView1.setOffset(1);
  188.             wheelView1.setItems(yearsItems);
  189.             wheelView1.setSeletion(yearsSeletion);
  190.             wheelView1.setOnWheelViewListener(new OnWheelViewListener(){
  191. 	           	 public void onSelected(int selectedIndex, String item) {
  192. 	        			years = item;
  193.         				wheelView2.setItems(monthItems);
  194.         				ArrayList<String> items = new ArrayList<String>();
  195.                 		for(int i = 0; i < Integer.valueOf(Utility.getMonthMaxDay(years + "-" + month)); i++){
  196.                          	if(1 + i < 10){
  197.                          		items.add("0" + (1 + i));
  198.                          	}else{
  199.                          		items.add(1 + i + "");
  200.                          	}
  201.                         }
  202.                 		wheelView3.setItems(items);
  203. 	             }
  204.             });
  205.             
  206.             wheelView2.setOffset(1);
  207.         	wheelView2.setItems(monthItems);
  208.             wheelView2.setSeletion(monthSeletion);
  209.             wheelView2.setOnWheelViewListener(new OnWheelViewListener(){
  210.             	 public void onSelected(int selectedIndex, String item) {
  211.             		 month = item;
  212.             		 int maxDay =  Integer.valueOf(Utility.getMonthMaxDay(years + "-" + item));
  213.         			 ArrayList<String> items = new ArrayList<String>();
  214.             		 for(int i = 0; i < maxDay; i++){
  215.                      	if(1 + i < 10){
  216.                      		items.add("0" + (1 + i));
  217.                      	}else{
  218.                      		items.add(1 + i + "");
  219.                      	}
  220.                      }
  221.                  	 wheelView3.setItems(items);
  222.                  	 if(Integer.valueOf(day) > maxDay){
  223. 	           			 day = maxDay + "";
  224. 	           			 wheelView3.setSeletion(maxDay);
  225.                  	 }
  226.                  }
  227.             });
  228.             
  229.         	wheelView3.setOffset(1);
  230.         	wheelView3.setItems(dayItems);
  231.             wheelView3.setSeletion(daySeletion);
  232.             wheelView3.setOnWheelViewListener(new OnWheelViewListener(){
  233.            	 	public void onSelected(int selectedIndex, String item) {
  234.            	 		day = item;
  235.                 }
  236.             });
  237.                 
  238.             dialog.setContentView(layout);  
  239.             return dialog;  
  240.         }
  241.     }  
  242. }
弹出日期选择框代码 
  1. package com.cx.datechoosedialog;
  2.  
  3. import android.content.DialogInterface;
  4. import android.os.Bundle;
  5. import android.support.v7.app.ActionBarActivity;
  6. import android.view.View;
  7. import android.view.View.OnClickListener;
  8. import android.widget.TextView;
  9.  
  10. public class MainActivity extends ActionBarActivity {
  11.  
  12. 	@Override
  13. 	protected void onCreate(Bundle savedInstanceState) {
  14. 		super.onCreate(savedInstanceState);
  15. 		setContentView(R.layout.activity_main);
  16. 		
  17. 		findViewById(R.id.text).setOnClickListener(new OnClickListener() {
  18. 			
  19. 			@Override
  20. 			public void onClick(View arg0) {
  21. 				// TODO Auto-generated method stub
  22. 				DateChooseDialog.Builder builder = new DateChooseDialog.Builder(MainActivity.this);  
  23. 				builder.setTitle("选择日期");  
  24. 				builder.setTextView((TextView)findViewById(R.id.text));
  25. 				builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {  
  26. 					public void onClick(DialogInterface dialog, int which) {  
  27. 						dialog.dismiss();  
  28. 						//设置你的操作事项  
  29. 					}
  30. 				});
  31.  
  32. 				builder.setNegativeButton("取消",  
  33. 						new android.content.DialogInterface.OnClickListener() {  
  34. 					public void onClick(DialogInterface dialog, int which) {  
  35. 						dialog.dismiss();  
  36. 					}  
  37. 				});  
  38. 				builder.create().show();
  39. 			}
  40. 		});
  41. 	}
  42.  
  43. }
效果图：


源码下载

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

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

  

闽ICP备14008679号