datepicker_datepickerdialog - CSDN
精华内容
参与话题
  • datepicker 属性设置 以及方法和事件

    千次阅读 2016-12-08 17:01:42
    DatePicker支持鼠标点选日期,同时还可以通过键盘控制选择: page up/down - 上一月、下一月  ctrl+page up/down - 上一年、下一年  ctrl+home - 当前月或最后一次打开的日期  ctrl+left/right - 上一天、...

    点击打开链接

    DatePicker支持鼠标点选日期,同时还可以通过键盘控制选择:

    page up/down - 上一月、下一月 
    ctrl+page up/down - 上一年、下一年 
    ctrl+home - 当前月或最后一次打开的日期 
    ctrl+left/right - 上一天、下一天 
    ctrl+up/down - 上一周、下一周 
    enter - 确定选择日期 
    ctrl+end - 关闭并清除已选择的日期 
    escape - 关闭并取消选择

     

    实用功能:

    $.datepicker.setDefaults( settings ) - 全局设置日期选择插件的参数. 
    $.datepicker.formatDate( format, date, settings ) - 格式化显示的日期字符串 
    $.datepicker.iso8601Week( date ) - 给出一个日期,确实他是一年中的第几周 
    $.datepicker.parseDate( format, value, settings ) - 按照指定格式获取日期字符串

     

    日期格式:

    d - 每月的第几天 (没有前导零) 
    dd - 每月的第几天 (两位数字) 
    o - 一年中的第几天 (没有前导零) 
    oo - 一年中的第几天 (三位数字) 
    D - day name short 
    DD - day name long 
    m - 月份 (没有前导零) 
    mm - 月份 (两位数字) 
    M - month name short 
    MM - month name long 
    y - 年份 (两位数字) 
    yy - 年份 (四位数字) 
    @ - Unix 时间戳 (从 01/01/1970 开始) 
    '...' - 文本 
    '' - 单引号 
    (其它) - 文本

     

    其它标准日期格式:

    ATOM - 'yy-mm-dd' (Same as RFC 3339/ISO 8601) 
    COOKIE - 'D, dd M yy' 
    ISO_8601 - 'yy-mm-dd' 
    RFC_822 - 'D, d M y' 
    RFC_850 - 'DD, dd-M-y' 
    RFC_1036 - 'D, d M y 
    RFC_1123 - 'D, d M yy' 
    RFC_2822 - 'D, d M yy' 
    RSS - 'D, d M y' 
    TIMESTAMP - '@' 
    W3C - 'yy-mm-dd'

     

    参数(参数名 : 参数类型 : 默认值)

    altField : String : '' 
      将选择的日期同步到另一个域中,配合altFormat可以显示不同格式的日期字符串。 
      初始:$('.selector').datepicker({ altField: '#actualDate' }); 
      获取:var altField = $('.selector').datepicker('option', 'altField'); 
      设置:$('.selector').datepicker('option', 'altField', '#actualDate'); 

    altFormat : String : '' 
      当设置了altField的情况下,显示在另一个域中的日期格式。 
      初始:$('.selector').datepicker({ altFormat: 'yy-mm-dd' }); 
      获取:var altFormat = $('.selector').datepicker('option', 'altFormat'); 
      设置:$('.selector').datepicker('option', 'altFormat', 'yy-mm-dd'); 

    appendText : String : '' 
      在日期插件的所属域后面添加指定的字符串。 
      初始:$('.selector').datepicker({ appendText: '(yyyy-mm-dd)' }); 
      获取:var appendText = $('.selector').datepicker('option', 'appendText'); 
      设置:$('.selector').datepicker('option', 'appendText', '(yyyy-mm-dd)'); 

    buttonImage : String : '' 
      设置弹出按钮的图片,如果非空,则按钮的文本将成为alt属性,不直接显示。 
      初始:$('.selector').datepicker({ buttonImage: '/images/datepicker.gif' }); 
      获取:var buttonImage = $('.selector').datepicker('option', 'buttonImage'); 
      设置:$('.selector').datepicker('option', 'buttonImage', '/images/datepicker.gif'); 

    buttonImageOnly : Boolean : false 
      Set to true to place an image after the field to use as the trigger without it appearing on a button. 
      初始:$('.selector').datepicker({ buttonImageOnly: true }); 
      获取:var buttonImageOnly = $('.selector').datepicker('option', 'buttonImageOnly'); 
      设置:$('.selector').datepicker('option', 'buttonImageOnly', true); 

    buttonText : String : '...' 
      设置触发按钮的文本内容。 
      初始:$('.selector').datepicker({ buttonText: 'Choose' }); 
      获取:var buttonText = $('.selector').datepicker('option', 'buttonText'); 
      设置:$('.selector').datepicker('option', 'buttonText', 'Choose'); 

    changeMonth : Boolean : false 
      设置允许通过下拉框列表选取月份。 
      初始:$('.selector').datepicker({ changeMonth: true }); 
      获取:var changeMonth = $('.selector').datepicker('option', 'changeMonth'); 
      设置:$('.selector').datepicker('option', 'changeMonth', true); 

    changeYear : Boolean : false 
      设置允许通过下拉框列表选取年份。 
      初始:$('.selector').datepicker({ changeYear: true }); 
      获取:var changeYear = $('.selector').datepicker('option', 'changeYear'); 
      设置:$('.selector').datepicker('option', 'changeYear', true); 

    closeTextType: StringDefault: 'Done' 
      设置关闭按钮的文本内容,此按钮需要通过showButtonPanel参数的设置才显示。 
      初始:$('.selector').datepicker({ closeText: 'X' }); 
      获取:var closeText = $('.selector').datepicker('option', 'closeText'); 
      设置:$('.selector').datepicker('option', 'closeText', 'X'); 

    constrainInput : Boolean : true 
      如果设置为true,则约束当前输入的日期格式。 
      初始:$('.selector').datepicker({ constrainInput: false }); 
      获取:var constrainInput = $('.selector').datepicker('option', 'constrainInput'); 
      设置:$('.selector').datepicker('option', 'constrainInput', false); 

    currentText : String : 'Today' 
      设置当天按钮的文本内容,此按钮需要通过showButtonPanel参数的设置才显示。 
      初始:$('.selector').datepicker({ currentText: 'Now' }); 
      获取:var currentText = $('.selector').datepicker('option', 'currentText'); 
      设置:$('.selector').datepicker('option', 'currentText', 'Now'); 

    dateFormat : String : 'mm/dd/yy' 
      设置日期字符串的显示格式。 
      初始:$('.selector').datepicker({ dateFormat: 'yy-mm-dd' }); 
      获取:var dateFormat = $('.selector').datepicker('option', 'dateFormat'); 
      设置:$('.selector').datepicker('option', 'dateFormat', 'yy-mm-dd'); 

    dayNames : Array : ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] 
      设置一星期中每天的名称,从星期天开始。此内容用于dateFormat时显示,以及日历中当鼠标移至行头时显示。 
      初始:$('.selector').datepicker({ dayNames: ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi'] }); 
      获取:var dayNames = $('.selector').datepicker('option', 'dayNames'); 
      设置:$('.selector').datepicker('option', 'dayNames', ['Dimanche', 'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi']); 

    dayNamesMin : Array : ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'] 
      设置一星期中每天的缩语,从星期天开始,此内容用于dateFormat时显示,以前日历中的行头显示。 
      初始:$('.selector').datepicker({ dayNamesMin: ['Di', 'Lu', 'Ma', 'Me', 'Je', 'Ve', 'Sa'] }); 
      获取:var dayNamesMin = $('.selector').datepicker('option', 'dayNamesMin'); 
      设置:$('.selector').datepicker('option', 'dayNamesMin', ['Di', 'Lu', 'Ma', 'Me', 'Je', 'Ve', 'Sa']); 

    dayNamesShort : Array : ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'] 
      设置一星期中每天的缩语,从星期天开始,此内容用于dateFormat时显示,以前日历中的行头显示。 
      初始:$('.selector').datepicker({ dayNamesShort: ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam'] }); 
      获取:var dayNamesShort = $('.selector').datepicker('option', 'dayNamesShort'); 
      设置:$('.selector').datepicker('option', 'dayNamesShort', ['Dim', 'Lun', 'Mar', 'Mer', 'Jeu', 'Ven', 'Sam']); 

    defaultDate : Date, Number, String : null 
      设置默认加载完后第一次显示时选中的日期。可以是Date对象,或者是数字(从今天算起,例如+7),或者有效的字符串('y'代表年, 'm'代表月, 'w'代表周, 'd'代表日, 例如:'+1m +7d')。 
      初始:$('.selector').datepicker({ defaultDate: +7 }); 
      获取:var defaultDate = $('.selector').datepicker('option', 'defaultDate'); 
      设置:$('.selector').datepicker('option', 'defaultDate', +7); 

    duration : String, Number : 'normal' 
      设置日期控件展开动画的显示时间,可选是"slow", "normal", "fast",''代表立刻,数字代表毫秒数。 
      初始:$('.selector').datepicker({ duration: 'slow' }); 
      获取:var duration = $('.selector').datepicker('option', 'duration'); 
      设置:$('.selector').datepicker('option', 'duration', 'slow'); 

    firstDay : Number : 0 
      设置一周中的第一天。星期天为0,星期一为1,以此类推。 
      初始:$('.selector').datepicker({ firstDay: 1 }); 
      获取:var firstDay = $('.selector').datepicker('option', 'firstDay'); 
      设置:$('.selector').datepicker('option', 'firstDay', 1); 

    gotoCurrent : Boolean : false 
      如果设置为true,则点击当天按钮时,将移至当前已选中的日期,而不是今天。 
      初始:$('.selector').datepicker({ gotoCurrent: true }); 
      获取:var gotoCurrent = $('.selector').datepicker('option', 'gotoCurrent'); 
      设置:$('.selector').datepicker('option', 'gotoCurrent', true); 

    hideIfNoPrevNext : Boolean : false 
      设置当没有上一个/下一个可选择的情况下,隐藏掉相应的按钮。(默认为不可用) 
      初始:$('.selector').datepicker({ hideIfNoPrevNext: true }); 
      获取:var hideIfNoPrevNext = $('.selector').datepicker('option', 'hideIfNoPrevNext'); 
      设置:$('.selector').datepicker('option', 'hideIfNoPrevNext', true); 

    isRTL : Boolean : false 
      如果设置为true,则所有文字是从右自左。 
      初始:$('.selector').datepicker({ isRTL: true }); 
      获取:var isRTL = $('.selector').datepicker('option', 'isRTL'); 
      设置:$('.selector').datepicker('option', 'isRTL', true); 

    maxDate : Date, Number, String : null 
      设置一个最大的可选日期。可以是Date对象,或者是数字(从今天算起,例如+7),或者有效的字符串('y'代表年, 'm'代表月, 'w'代表周, 'd'代表日, 例如:'+1m +7d')。 
      初始:$('.selector').datepicker({ maxDate: '+1m +1w' }); 
      获取:var maxDate = $('.selector').datepicker('option', 'maxDate'); 
      设置:$('.selector').datepicker('option', 'maxDate', '+1m +1w'); 
           $('.selector').datepicker('option', 'maxDate', '12/25/2012'); 

    minDate : Date, Number, String : null 
      设置一个最小的可选日期。可以是Date对象,或者是数字(从今天算起,例如+7),或者有效的字符串('y'代表年, 'm'代表月, 'w'代表周, 'd'代表日, 例如:'+1m +7d')。 
      初始:$('.selector').datepicker({ minDate: new Date(2007, 1 - 1, 1) }); 
      获取:var minDate = $('.selector').datepicker('option', 'minDate'); 
      设置:$('.selector').datepicker('option', 'minDate', new Date(2007, 1 - 1, 1)); 
           $('.selector').datepicker('option', 'minDate', '12/25/2012'); 

    monthNames : Array : ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'] 
      设置所有月份的名称。 
      初始:$('.selector').datepicker({monthNames:['Januar','Februar','Marts','April','Maj','Juni','Juli','August','September','Oktober','November','December']}); 
      获取:var monthNames = $('.selector').datepicker('option', 'monthNames'); 
      设置:$('.selector').datepicker('option', 'monthNames', ['Januar','Februar','Marts','April','Maj','Juni','Juli','August','September','Oktober','November','December']); 

    monthNamesShort : Array : ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] 
      设置所有月份的缩写。 
      初始:$('.selector').datepicker({monthNamesShort:['Jan','Feb','Mar','Apr','Maj','Jun','Jul','Aug','Sep','Okt','Nov','Dec']}); 
      获取:var monthNamesShort = $('.selector').datepicker('option', 'monthNamesShort'); 
      设置:$('.selector').datepicker('option', 'monthNamesShort', ['Jan','Feb','Mar','Apr','Maj','Jun','Jul','Aug','Sep','Okt','Nov','Dec']); 

    navigationAsDateFormat : Boolean : false 
      如果设置为true,则formatDate函数将应用到 prevText,nextText和currentText的值中显示,例如显示为月份名称。 
      初始:$('.selector').datepicker({ navigationAsDateFormat: true }); 
      获取:var navigationAsDateFormat = $('.selector').datepicker('option', 'navigationAsDateFormat'); 
      设置:$('.selector').datepicker('option', 'navigationAsDateFormat', true); 

    nextText : String : 'Next' 
      设置“下个月”链接的显示文字。 
      初始:$('.selector').datepicker({ nextText: 'Later' }); 
      获取:var nextText = $('.selector').datepicker('option', 'nextText'); 
      设置:$('.selector').datepicker('option', 'nextText', 'Later'); 

    numberOfMonths : Number, Array : 1 
      设置一次要显示多少个月份。如果为整数则是显示月份的数量,如果是数组,则是显示的行与列的数量。 
      初始:$('.selector').datepicker({ numberOfMonths: [2, 3] }); 
      获取:var numberOfMonths = $('.selector').datepicker('option', 'numberOfMonths'); 
      设置:$('.selector').datepicker('option', 'numberOfMonths', [2, 3]); 

    prevText : String : 'Prev' 
      设置“上个月”链接的显示文字。 
      初始:$('.selector').datepicker({ prevText: 'Earlier' }); 
      获取:var prevText = $('.selector').datepicker('option', 'prevText'); 
      设置:$('.selector').datepicker('option', 'prevText', 'Earlier'); 

    shortYearCutoff : String, Number : '+10' 
      设置截止年份的值。如果是(0-99)的数字则以当前年份开始算起,如果为字符串,则相应的转为数字后再与当前年份相加。当超过截止年份时,则被认为是上个世纪。 
      初始:$('.selector').datepicker({ shortYearCutoff: 50 }); 
      获取:var shortYearCutoff = $('.selector').datepicker('option', 'shortYearCutoff'); 
      设置:$('.selector').datepicker('option', 'shortYearCutoff', 50); 

    showAnim : String : 'show' 
      设置显示、隐藏日期插件的动画的名称。 
      初始:$('.selector').datepicker({ showAnim: 'fold' }); 
      获取:var showAnim = $('.selector').datepicker('option', 'showAnim'); 
      设置:$('.selector').datepicker('option', 'showAnim', 'fold'); 

    showButtonPanel : Boolean : false 
      设置是否在面板上显示相关的按钮。 
      初始:$('.selector').datepicker({ showButtonPanel: true }); 
      获取:var showButtonPanel = $('.selector').datepicker('option', 'showButtonPanel'); 
      设置:$('.selector').datepicker('option', 'showButtonPanel', true); 

    showCurrentAtPos : Number : 0 
      设置当多月份显示的情况下,当前月份显示的位置。自顶部/左边开始第x位。 
      初始:$('.selector').datepicker({ showCurrentAtPos: 3 }); 
      获取:var showCurrentAtPos = $('.selector').datepicker('option', 'showCurrentAtPos'); 
      设置:$('.selector').datepicker('option', 'showCurrentAtPos', 3); 

    showMonthAfterYear : Boolean : false 
      是否在面板的头部年份后面显示月份。 
      初始:$('.selector').datepicker({ showMonthAfterYear: true }); 
      获取:var showMonthAfterYear = $('.selector').datepicker('option', 'showMonthAfterYear'); 
      设置:$('.selector').datepicker('option', 'showMonthAfterYear', true); 

    showOn : String : 'focus' 
      设置什么事件触发显示日期插件的面板,可选值:focus, button, both 
      初始:$('.selector').datepicker({ showOn: 'both' }); 
      获取:var showOn = $('.selector').datepicker('option', 'showOn'); 
      设置:$('.selector').datepicker('option', 'showOn', 'both'); 

    showOptions : Options : {} 
      如果使用showAnim来显示动画效果的话,可以通过此参数来增加一些附加的参数设置。 
      初始:$('.selector').datepicker({ showOptions: {direction: 'up' }); 
      获取:var showOptions = $('.selector').datepicker('option', 'showOptions'); 
      设置:$('.selector').datepicker('option', 'showOptions', {direction: 'up'); 

    showOtherMonths : Boolean : false 
      是否在当前面板显示上、下两个月的一些日期数(不可选)。 
      初始:$('.selector').datepicker({ showOtherMonths: true }); 
      获取:var showOtherMonths = $('.selector').datepicker('option', 'showOtherMonths'); 
      设置:$('.selector').datepicker('option', 'showOtherMonths', true); 

    stepMonths : Number : 1 
      当点击上/下一月时,一次翻几个月。 
      初始:$('.selector').datepicker({ stepMonths: 3 }); 
      获取:var stepMonths = $('.selector').datepicker('option', 'stepMonths'); 
      设置:$('.selector').datepicker('option', 'stepMonths', 3); 

    yearRange : String : '-10:+10' 
      控制年份的下拉列表中显示的年份数量,可以是相对当前年(-nn:+nn),也可以是绝对值 (-nnnn:+nnnn) 
      初始:$('.selector').datepicker({ yearRange: '2000:2010' }); 
      获取:var yearRange = $('.selector').datepicker('option', 'yearRange'); 
      设置:$('.selector').datepicker('option', 'yearRange', '2000:2010');

     

    事件

    beforeShow : function(input) 
      在日期控件显示面板之前,触发此事件,并返回当前触发事件的控件的实例对象。 
      初始:$('.selector').datepicker({ beforeShow: function(input) { ... } }); 

    beforeShowDay : function(date) 
      在日期控件显示面板之前,每个面板上的日期绑定时都触发此事件,参数为触发事件的日期。调用函数后,必须返回一个数组:[0]此日期是否可选(true/false),[1]此日期的CSS样式名称(""表示默认),[2]当鼠标移至上面出现一段提示的内容。 
      初始:$('.selector').datepicker({ beforeShowDay: function(date) { ... } }); 

    onChangeMonthYear : function(year, month, inst) 
      当年份或月份改变时触发此事件,参数为改变后的年份月份和当前日期插件的实例。 
      初始:$('.selector').datepicker({ onChangeMonthYear: function(year, month, inst) { ... } }); 

    onClose : function(dateText, inst) 
      当日期面板关闭后触发此事件(无论是否有选择日期),参数为选择的日期和当前日期插件的实例。 
      初始:$('.selector').datepicker({ onClose: function(dateText, inst) { ... } }); 

    onSelect : function(dateText, inst) 
      当在日期面板选中一个日期后触发此事件,参数为选择的日期和当前日期插件的实例。 
      $('.selector').datepicker({ onSelect: function(dateText, inst) { ... } });

     

    方法:

    destory 
      从元素中移除拖拽功能。 
      用法:.datepicker( 'destroy' ) 

    disable 
      禁用元素的拖拽功能。 
      用法:.datepicker( 'disable' ) 

    enable 
      启用元素的拖拽功能。 
      用法:.datepicker( 'enable' ) 

    option 
      获取或设置元素的参数。 
      用法:.datepicker( 'option' , optionName , [value] ) 

    dialog 
      在dialog插件中打开一个日期插件。 
      用法:.datepicker( 'dialog' , dateText , [onSelect] , [settings] , [pos] ) 

    isDisabled 
      确实日期插件是否已被禁用。 
      用法:.datepicker( 'isDisabled' ) 

    hide 
      隐藏(关闭)之前已经打开的日期面板。 
      用法:.datepicker( 'hide' , [speed] )  

    show 
    .datepicker( 'show' ) 
      显示日期插件。 
      用法:.datepicker( 'show' ) 

    getDate 
      返回当前日期插件选择的日期。 
      用法:.datepicker( 'getDate' ) 

    setDate 
      设置日期插件当前的日期。date参数可以是数字(从今天算起,例如+7),或者有效的字符串('y'代表年, 'm'代表月, 'w'代表周, 'd'代表日, 例如:'+1m +7d'),null表示当天。 
      用法:.datepicker( 'setDate' , date )

     


    展开全文
  • jQuery Datepicker用到的js和CSS文件

    千次下载 热门讨论 2020-07-30 23:32:43
    jQuery Datepicker用到的js和CSS文件 jquery-ui.css jquery-ui-timepicker-addon.css jquery-1.7.2.js jquery-ui.min.js jquery-ui-timepicker-addon.js jquery-ui-sliderAccess.js jquery-ui-timepicker-zh-CN.js
  • DatePicker日期控件

    千次阅读 2012-07-12 09:38:18
    WdatePicker.js 配置文件,在调用的地方仅需使用该文件 powered by ...My97DatePicker.htm 临时页面文件,不可删除 目录lang 存放语言文件 目录skin 存放皮肤的相关文件 当WdatePicker.js里的属性:$wdate=true时,在
    WdatePicker.js 配置文件,在调用的地方仅需使用该文件 powered by 25175.net
    config.js 语言和皮肤配置文件
    calendar.js 日期库主文件)
    My97DatePicker.htm 临时页面文件,不可删除
    目录lang 存放语言文件
    目录skin 存放皮肤的相关文件 当WdatePicker.js里的属性:$wdate=true时,在input里加上class="Wdate"就会在选择框右边出现日期图标,如果您不喜欢这个样式,可以把class="Wdate"去掉,另外也可以通过修改skin目录下的WdatePicker.css文件来修改样式

    3. 支持的浏览器

    IE 6.0+ , Firefox 2.0+ , Opera 9.5+ , Safari 3.0+

    二. 功能及示例

    1. 常规功能

    1. 支持多种调用模式

      除了支持常规在input单击或获得焦点调用外,还支持使用其他的元素如:<img><div>等触发WdatePicker函数来调用弹出日期框

      示例1-1-1 常规调用


      <input id="d11" type="text" onClick="WdatePicker()"/>

      示例1-1-2 图标触发


      <input id="d12" type="text"/>
      <img οnclick="WdatePicker({el:$dp.$('d12')})" src="../../../../skin/datePicker.gif" width="16" height="22" align="absmiddle">
      注:$dp.$ 相当于 document.getElementById
      $dp.$ 的详细用法可以参考
      内置函数

    2. 下拉,输入,导航选择日期

      年月时分秒输入框都具备以下三种特性
      1. 通过导航图标选择


      2. 直接使用键盘输入数字


      3. 直接从弹出的下拉框中选择


      另:年份输入框有智能提示功能,当用户连续点击同一个导航按钮5次时,会自动弹出年份下拉框

    3. 支持周显示

      可以通过配置isShowWeek属性决定是否限制周,并且在返回日期的时候还可以通过自带的自定义事件和API函数返回选择的周


      示例1-2-1 周显示简单应用


      <input id="d121" type="text" οnfοcus="WdatePicker({isShowWeek:true})"/>

      示例1-2-2 利用onpicked事件把周赋值给另外的文本框

         您选择了第 (W格式)周, 另外您可以使用WW格式:
      <input type="text" class="Wdate" id="d122" onFocus="WdatePicker({isShowWeek:true,onpicked:function() {$dp.$('d122_1').value=$dp.cal.getP('W','W');$dp.$('d122_2').value=$dp.cal.getP('W','WW');}})"/>

      onpicked 用法详见
      自定义事件
      $dp.cal.getP 用法详见内置函数

    4. 只读开关,高亮周末功能

      设置readOnly属性 true 或 false 可指定日期框是否只读
      设置highLineWeekDay属性 ture 或 false 可指定是否高亮周末

    5. 操作按钮自定义

      清空按钮和今天按钮,可以根据需要进行自定义,它们分别对应 isShowClear 和 isShowToday 默认值都是true

      示例1-5 禁用清空功能

      最好把readOnly置为true,否则即使隐藏了清空按钮,用户依然可以在输入框里把值delete掉

      <input class="Wdate" type="text" id="d15" onFocus="WdatePicker({isShowClear:false,readOnly:true})"/>

    6. 自动选择显示位置

      当控件处在页面边界时,它会自动选择显示的位置,所以没有必要担心弹出框会被页面边界遮住的问题了.

    7. 自定义弹出位置

      当控件处在页面边界时,它会自动选择显示的位置.此外你还可以使用position参数对弹出位置做调整.


      示例1-6 通过position属性,自定义弹出位置

      使用positon属性指定,弹出日期的坐标为{left:100,top:50}

      <input class="Wdate" type="text" id="d16" οnfοcus="WdatePicker({position:{left:100,top:50}})"/>

      position属性的详细用法详见
      属性表

    2. 特色功能

    1. 平面显示

      日期控件支持平面显示功能,只要设置一下eCont属性就可以把它当作日历来使用了,无需触发条件,直接显示在页面上


      示例2-1 平面显示演示

      <div id="div1"></div>
      <script>
      WdatePicker({eCont:'div1',onpicked:function(dp){alert('你选择的日期是:'+dp.cal.getDateStr())}})
      </script>

      $dp.cal.getDateStr 用法详见
      内置函数

    2. 支持多种容器

      除了可以将值返回给input以外,还可以通过配置el属性将值返回给其他的元素(如:textarea,div,span)等,带有innerHTML属性的HTML元素

      示例2-2 将日期返回到<span>中

      2008-01-01

      代码:
      <span id="demospan">2008-01-01</span>
      <img onClick="WdatePicker({el:'demospan'})" src="../../../../../My97DatePicker/skin/datePicker.gif" width="16" height="22" align="absmiddle" style="cursor:pointer" />

    3. 起始日期功能
      注意:日期格式必须与 realDateFmt 和 realTimeFmt 一致

      有时在项目中需要选择生日之类的日期,而默认点开始日期都是当前日期,导致年份选择非常麻烦,你可以通过起始日期功能加上配置alwaysUseStartDate属性轻松解决此类问题

      示例2-3-1 起始日期简单应用

      默认的起始日期为 1980-05-01
      当日期框为空值时,将使用 1980-05-01 做为起始日期


      <input type="text" id="d221" onFocus="WdatePicker({startDate:'1980-05-01'})"/>

      示例2-3-2 alwaysUseStartDate属性应用

      默认的起始日期为 1980-05-01
      当日期框无论是何值,始终使用 1980-05-01 做为起始日期


      <input type="text" id="d222" onFocus="WdatePicker({startDate:'1980-05-01',alwaysUseStartDate:true})"/>

      示例2-3-3 使用内置参数

      除了使用静态的日期值以外,还可以使用动态参数(如:%y,%M分别表示当前年和月)

      下例演示,年月日使用当年当月的1日,时分秒使用00:00:00作为起始时间


      <input type="text" id="d233" onFocus="WdatePicker({startDate:'%y-%M-01 00:00:00',dateFmt:'yyyy-MM-dd HH:mm:ss',alwaysUseStartDate:true})"/>

    4. 自定义格式

      yMdHmswW分别代表年月日时分秒星期周,你可以任意组合这些元素来自定义你个性化的日期格式.


      日期格式表
      格式 说明
      y 将年份表示为最多两位数字。如果年份多于两位数,则结果中仅显示两位低位数。
      yy 同上,如果小于两位数,前面补零。
      yyy 将年份表示为三位数字。如果少于三位数,前面补零。
      yyyy 将年份表示为四位数字。如果少于四位数,前面补零。
      M 将月份表示为从 1 至 12 的数字
      MM 同上,如果小于两位数,前面补零。
      d 将月中日期表示为从 1 至 31 的数字。
      dd 同上,如果小于两位数,前面补零。
      H 将小时表示为从 0 至 23 的数字。
      HH 同上,如果小于两位数,前面补零。
      m 将分钟表示为从 0 至 59 的数字。
      mm 同上,如果小于两位数,前面补零。
      s 将秒表示为从 0 至 59 的数字。
      ss 同上,如果小于两位数,前面补零。
      w 返回星期对应的数字 0 (星期天) - 6 (星期六) 。
      D 返回星期的缩写 一 至 六 (英文状态下 Sun to Sat) 。
      W 返回周对应的数字 (1 - 53) 。
      WW 同上,如果小于两位数,前面补零 (01 - 53) 。

      示例
      格式字符串
      yyyy-MM-dd HH:mm:ss 2008-03-12 19:20:00
      yy年M月 08年3月
      yyyyMMdd 20080312
      今天是:yyyy年M年d HH时mm分 今天是:2008年3月12日 19时20分
      H:m:s 19:20:0
      y年 8年

      示例 2-4-1: 年月日时分秒


      <input type="text" id="d241" οnfοcus="WdatePicker({dateFmt:'yyyy年MM月dd日 HH时mm分ss秒'})" class="Wdate" style="width:300px"/>

      示例 2-4-2 时分秒


      <input type="text" id="d242" οnfοcus="WdatePicker({skin:'whyGreen',dateFmt:'H:mm:ss'})" class="Wdate"/>

      注意:这里提前使用了皮肤(skin)属性,所以你会看到一个不同的皮肤,皮肤属性详见
      自定义和动态切换皮肤

      示例 2-4-3 年月


      <input type="text" id="d243" οnfοcus="WdatePicker({skin:'whyGreen',dateFmt:'yyyy年MM月'})" class="Wdate"/>

      示例 2-4-4 取得系统可识别的日期值(重要)

      类似于 1999年7月5日 这样的日期是不能够被系统识别的,他必须转换为能够识别的类型如 1999-07-05

      真实的日期值是:
      <input id="d244" type="text" class="Wdate" οnfοcus="WdatePicker({dateFmt:'yyyy年M月d日',vel:'d244_2'})"/>
      <input id="d244_2" type="text" />

      注意:在实际应用中,一般会把vel指定为一个hidden控件,这里是为了把真实值展示出来,所以使用文本框
      关键属性: vel 指定一个控件或控件的ID,必须具有value属性(如input),用于存储真实值(也就是realDateFmt和realTimeFmt格式化后的值)

    5. 编辑功能

      当日期框里面有值时,修改完某个属性后,只要点击这个按钮就可以实现时间和日期的编辑

      示例2-5 日期和时间的编辑演示

      您可以尝试对下面框中的月份改为1,然后点击更新,你会发现日期由 2000-02-29 01:00:00 变为 2000-01-29 01:00:00

    6. 自动纠错功能

      纠错处理可设置为3种模式:提示(默认) 自动纠错 标记,当日期框中的值不符合格式时,系统会尝试自动修复,如果修复失败会根据您设置的纠错处理模式进行处理,错误判断功能非常智能它可以保证用户输入的值是一个合法的值

      示例2-6-1 不合法的日期演示

      请在下面的日期框中填入一个不合法的日期(如:1997-02-29),再尝试离开焦点
      使用默认容错模式 提示模式 errDealMode = 0 在输入错误日期时,会先提示


      注意:1997年不是闰年哦

      示例2-6-2 超出日期限制范围的日期也被认为是一个不合法的日期

      最大日期是2000-01-10 ,如果在下框中填入的日期 大于 2000-01-10(如2000-01-12)也会被认为是不合法的日期
      自动纠错模式 errDealMode = 1 在输入错误日期时,自动恢复前一次正确的值

      示例2-6-3 使用无效天和无效日期功能限制的日期也被认为是一个不合法的日期

      如:
      2008-02-20 无效日期限制
      2008-02-02 2008-02-09 2008-02-16 2008-02-23 无效天限制
      都是无效日期
      您可以尝试在下框中输入这些日期,并离开焦点

      标记模式 errDealMode = 2 在输入错误日期时,不做提示和更改,只是做一个标记,但此时日期框不会马上隐藏


      注意:标记类:WdateFmtErr是在skin目录下WdatePicker.css中定义的

    7. 跨无限级框架显示

      无论你把日期控件放在哪里,你都不需要担心会被外层的iframe所遮挡进而影响客户体验,因为My97日期控件是可以跨无限级框架显示的

      示例2-7 跨无限级框架演示

      可无限跨越框架iframe,无论怎么嵌套框架都不必担心了,即使有滚动条也不怕

    8. 民国年日历和其他特殊日历

      当年份格式设置为yyy格式时,利用年份差量属性yearOffset(默认值1911民国元年),可实现民国年日历和其他特殊日历

      示例2-8 民国年演示


      <input type="text" id="d28" onClick="WdatePicker({dateFmt:'yyy/MM/dd'})"/>

      注意:年份格式设置成yyy时,真正的日期将会减去一个差量yearOffset(默认值为:1911),如果是民国年使用默认值即可无需另外配置,如果是其他的差量,可以通过参数的形式配置

    9. 为编程带来方便

      如果el的值是this,可省略,即所有的el:this都可以不写
      日期框设置为disabled时,禁止更改日期(不弹出选择框)
      如果没有定义onpicked事件,自动触发文本框的onchange事件
      如果没有定义oncleared事件,清空时,自动触发onchange事件

    10. 其他属性

      设置readOnly属性,可指定日期框是否只读
      设置highLineWeekDay属性,可指定是否高亮周末
      设置isShowOthers属性,可指定是否显示其他月的日期
      加上class="Wdate"就会在选择框右边出现日期图标

    3. 多语言和自定义皮肤


    1. 多语言支持

      通过lang属性,可以为每个日期控件单独配置语言,当然也可以通过WdatePicker.js配置全局的语言
      语言列表和语言安装说明详见
      语言配置

      示例3-1 多语言示例

      繁体中文:
      <input id="d311" class="Wdate" type="text" onFocus="WdatePicker({lang:'zh-tw'})"/>

      英文:
      <input id="d312" class="Wdate" type="text" onFocus="WdatePicker({lang:'en'})"/>

      简体中文:
      <input id="d313" class="Wdate" type="text" onFocus="WdatePicker({lang:'zh-cn'})"/>

      注意:默认情况lang='auto',即根据浏览器的语言自动选择语言.

    2. 自定义和动态切换皮肤 立刻转到皮肤中心

      通过skin属性,可以为每个日期控件单独配置皮肤,当然也可以通过WdatePicker.js配置全局的皮肤
      皮肤列表和皮肤安装说明详见
      皮肤配置

      示例3-2 皮肤演示

      默认皮肤default: skin:'default'

      <input id="d321" class="Wdate" type="text" οnfοcus="WdatePicker()"/>

      注意:在WdatePicker里配置了skin='default',所以此处可省略,同理,如果你把WdatePicker里的skin配置成'whyGreen'那么在不指定皮肤的情况下都使用'whyGreen'皮肤了


      whyGreen皮肤: skin:'whyGreen'

      <input id="d322" class="Wdate" type="text" οnfοcus="WdatePicker({skin:'whyGreen'})"/>

      注意:更多皮肤,请到
      皮肤中心下载

    4. 日期范围限制

    1. 静态限制
      注意:日期格式必须与 realDateFmt 和 realTimeFmt 一致

      你可以给通过配置minDate(最小日期),maxDate(最大日期)为静态日期值,来限定日期的范围

      示例4-1-1 限制日期的范围是 2006-09-10到2008-12-20


      <input id="d411" class="Wdate" type="text" οnfοcus="WdatePicker({skin:'whyGreen',minDate:'2006-09-10',maxDate:'2008-12-20'})"/>

      示例4-1-2 限制日期的范围是 2008-3-8 11:30:00 到 2008-3-10 20:59:30


      <input type="text" class="Wdate" id="d412" οnfοcus="WdatePicker({skin:'whyGreen',dateFmt:'yyyy-MM-dd HH:mm:ss',minDate:'2008-03-08 11:30:00',maxDate:'2008-03-10 20:59:30'})" value="2008-03-09 11:00:00"/>

      示例4-1-3 限制日期的范围是 2008年2月 到 2008年10月


      <input type="text" class="Wdate" id="d413" οnfοcus="WdatePicker({dateFmt:'yyyy年M月',minDate:'2008-2',maxDate:'2008-10'})"/>

      示例4-1-4 限制日期的范围是 8:00:00 到 11:30:00


      <input type="text" class="Wdate" id="d414" οnfοcus="WdatePicker({dateFmt:'H:mm:ss',minDate:'8:00:00',maxDate:'11:30:00'})"/>

    2. 动态限制
      注意:日期格式必须与 realDateFmt 和 realTimeFmt 一致

      你可以通过系统给出的动态变量,如%y(当前年),%M(当前月)等来限度日期范围,你还可以通过#{}进行表达式运算,如:#{%d+1}:表示明天

      动态变量表

      格式 说明
      %y 当前年
      %M 当前月
      %d 当前日
      %ld 本月最后一天
      %H 当前时
      %m 当前分
      %s 当前秒
      #{} 运算表达式,如:#{%d+1}:表示明天
      #F{} {}之间是函数可写自定义JS代码

      示例4-2-1 只能选择今天以前的日期(包括今天)


      <input id="d421" class="Wdate" type="text" οnfοcus="WdatePicker({skin:'whyGreen',maxDate:'%y-%M-%d'})"/>

      示例4-2-2 使用了运算表达式 只能选择今天以后的日期(不包括今天)


      <input id="d422" class="Wdate" type="text" οnfοcus="WdatePicker({minDate:'%y-%M-#{%d+1}'})"/>

      示例4-2-3 只能选择本月的日期1号至本月最后一天


      <input id="d423" class="Wdate" type="text" οnfοcus="WdatePicker({minDate:'%y-%M-01',maxDate:'%y-%M-%ld'})"/>

      示例4-2-4 只能选择今天7:00:00至明天21:00:00的日期


      <input id="d424" class="Wdate" type="text" οnfοcus="WdatePicker({dateFmt:'yyyy-M-d H:mm:ss',minDate:'%y-%M-%d 7:00:00',maxDate:'%y-%M-#{%d+1} 21:00:00'})"/>

      示例4-2-5 使用了运算表达式 只能选择 20小时前 至 30小时后 的日期


      <input id="d425" class="Wdate" type="text" onClick="WdatePicker({dateFmt:'yyyy-MM-dd HH:mm',minDate:'%y-%M-%d #{%H-20}:%m:%s',maxDate:'%y-%M-%d #{%H+30}:%m:%s'})"/>

    3. 脚本自定义限制
      注意:日期格式必须与 realDateFmt 和 realTimeFmt 一致

      系统提供了$dp.$D和$dp.$DV这两个API来辅助你进行日期运算,此外你还可以通过在 #F{} 中填入你自定义的脚本,做任何你想做的日期限制

      示例4-3-1 前面的日期不能大于后面的日期且两个日期都不能大于 2020-10-01

      合同有效期从
      <input id="d4311" class="Wdate" type="text" onFocus="WdatePicker({maxDate:'#F{$dp.$D(\'d4312\')||\'2020-10-01\'}'})"/>
      <input id="d4312" class="Wdate" type="text" onFocus="WdatePicker({minDate:'#F{$dp.$D(\'d4311\')}',maxDate:'2020-10-01'})"/>

      注意:
      两个日期的日期格式必须相同

      $dp.$ 相当于 document.getElementById 函数.
      那么为什么里面的 ' 使用 \' 呢? 那是因为 " 和 ' 都被外围的函数使用了,故使用转义符 \ ,否则会提示JS语法错误.
      所以您在其他地方使用时注意把 \' 改成 " 或者 ' 来使用.

      #F{$dp.$D(\'d4312\')||\'2020-10-01\'} 表示当 d4312 为空时, 采用 2020-10-01 的值作为最大值

      示例4-3-2 前面的日期+3天 不能大于 后面的日期

      日期从
      <input type="text" class="Wdate" id="d4321" onFocus="WdatePicker({maxDate:'#F{$dp.$D(\'d4322\',{d:-3});}'})"/>
      <input type="text" class="Wdate" id="d4322" onFocus="WdatePicker({minDate:'#F{$dp.$D(\'d4321\',{d:3});}'})"/>

      使用 $dp.$D 函数 可以将日期框中的值,加上定义的日期差量:
      两个参数: id={字符类型}需要处理的文本框的id值 , obj={对象类型}日期差量
      日期差量用法:
      属性y,M,d,H,m,s分别代表年月日时分秒

      为空时,表示直接取值,不做差量(示例4-3-1中的参数就是空的)
      {M:5,d:7} 表示 五个月零7天
      {y:1,d:-3} 表示 1年少3天
      {d:1,H:1} 表示一天多1小时

      示例4-3-3 前面的日期+3月零2天 不能大于 后面的日期 且 前面日期都不能大于 2020-4-3减去3月零2天 后面日期 不能大于 2020-4-3

      住店日期从
      <input type="text" class="Wdate" id="d4331" onFocus="WdatePicker({maxDate:'#F{$dp.$D(\'d4332\',{M:-3,d:-2})||$dp.$DV(\'2020-4-3\',{M:-3,d:-2})}'})"/>
      <input type="text" class="Wdate" id="d4332" onFocus="WdatePicker({minDate:'#F{$dp.$D(\'d4331\',{M:3,d:2});}',maxDate:'2020-4-3'})"/>

      注意:
      #F{$dp.$D(\'d4332\',{M:-3,d:-2}) || $dp.$DV(\'2020-4-3\',{M:-3,d:-2})}
      表示当 d4332 为空时, 采用 $dp.$DV(\'2020-4-3\',{M:-3,d:-2})} 的值作为最大值

      使用 $dp.$DV 函数 可以将显式传入的值,加上定义的日期差量:
      两个参数: value={字符类型}需要处理的值 , obj={对象类型}日期差量
      用法同上面的 $dp.$D 类似,如 $dp.$DV(\'2020-4-3\',{M:-3,d:-2}) 表示 2020-4-3减去3月零2天

      示例4-3-4 发挥你的JS才能,定义任何你想要的日期限制

      自动转到随机生成的一天,当然,此示例没有实际的用途,只是为演示目的

      <script>
      //返回一个随机的日期
      function randomDate(){
      var Y = 2000 + Math.round(Math.random() * 10);
      var M = 1 + Math.round(Math.random() * 11);
      var D = 1 + Math.round(Math.random() * 27);
      return Y+'-'+M+'-'+D;
      }
      </script>
      <input type="text" class="Wdate" id="d434" onFocus="var date=randomDate();WdatePicker({minDate:date,maxDate:date})"/>

    4. 无效天

      可以使用此功能禁用周日至周六所对应的日期,相关属性:disabledDays (0至6 分别代表 周日至周六)

      示例4-4-1 禁用 周六 所对应的日期


      <input id="d441" type="text" class="Wdate" onFocus="WdatePicker({disabledDays:[6]})"/>

      示例4-4-2 通过position属性,自定义弹出位置


      <input id="d442" type="text" class="Wdate" onFocus="WdatePicker({disabledDays:[0,6]})"/>

    5. 无效日期
      注意:日期格式必须与 realDateFmt 和 realTimeFmt 一致

      可以使用此功能禁用,所指定的一个或多个日期,只要你熟悉正则表达式,你可以尽情发挥

      用法(正则匹配):
      如果你熟悉正则表达式,会很容易理解下面的匹配用法
      如果不熟悉,可以参考下面的常用示例
      ['2008-02-01','2008-02-29'] 表示禁用 2008-02-01 和 2008-02-29
      ['2008-..-01','2008-02-29'] 表示禁用 2008-所有月份-01 和 2008-02-29
      ['200[0-8]]-02-01','2008-02-29'] 表示禁用 [2000至2008]-02-01 和 2008-02-29
      ['^2006'] 表示禁用 2006年的所有日期

      此外,您还可以使用 %y %M %d %H %m %s 等变量, 用法同动态日期限制 注意:%ld不能使用
      ['....-..-01','%y-%M-%d'] 表示禁用 所有年份和所有月份的第一天和今天
      ['%y-%M-#{%d-1}','%y-%M-#{%d+1}'] 表示禁用 昨天和明天

      当然,除了可以限制日期以外,您还可以限制时间
      ['....-..-.. 10\:00\:00'] 表示禁用 每天10点 (注意 : 需要 使用 \: )

      不再多举例了,尽情发挥你的正则才能吧!

      示例4-5-1 禁用 每个月份的 5日 15日 25日


      <input id="d451" type="text" class="Wdate" onFocus="WdatePicker({disabledDates:['5$']})"/>

      注意 :'5$' 表示以 5 结尾 注意 $ 的用法

      示例4-5-2 禁用 所有早于2000-01-01的日期


      <input id="d452" type="text" class="Wdate" onFocus="WdatePicker({disabledDates:['^19']})"/>

      注意:'^19' 表示以 19 开头 注意 ^ 的用法
      当然,可以使用minDate实现类似的功能 这里主要是 在演示 ^ 的用法

      示例4-5-3 配合min/maxDate使用,可以把可选择的日期分隔成多段

      本示例本月可用日期分隔成五段 分别是: 1-3 8-10 16-24 26,27 29-月末

      <input id="d453" type="text" class="Wdate" onFocus="WdatePicker({minDate:'%y-%M-01',maxDate:'%y-%M-%ld',disabledDates:['0[4-7]$','1[1-5]$','2[58]$']})"/>

      示例4-5-4 min/maxDate disabledDays disabledDates 配合使用 即使在要求非常苛刻的情况下也能满足需求


      <input id="d454" type="text" class="Wdate" onFocus="WdatePicker({minDate:'%y-%M-01',maxDate:'%y-%M-%ld',disabledDates:['0[4-7]$','1[1-5]$','2[58]$'],disabledDays:[1,3,6]})"/>

      示例4-5-5 禁用前一个小时和后一个小时内所有时间 使用 %y %M %d %H %m %s 等变量

      鼠标点击 小时输入框时,你会发现当然时间对应的前一个小时和后一个小时是灰色的

      <input id="d2a25" type="text" class="Wdate" onFocus="WdatePicker({dateFmt:'yyyy-MM-dd HH:mm:ss',disabledDates:['%y-%M-%d #{%H-1}\:..\:..','%y-%M-%d #{%H+1}\:..\:..']})"/>

      注意:%y %M %d等详见
      动态变量表

      示例4-5-6 #F{}也是可以使用的

      本示例利用自定义函数 随机禁用0-23中的任何一个小时
      打开小时选择框,你会发现有一个小时被禁用的,而且每次禁用的小时都不同

      <script>
      function randomH(){
      //产生一个随机的数字 0-23
      var H = Math.round(Math.random() * 23);
      if(H<10) H='0'+H;
      //返回 '^' + 数字
      return '^'+H;
      }
      </script>
      <input type="text" class="Wdate" id="d456" onFocus="WdatePicker({dateFmt:'HH:mm:ss',disabledDates:['#F{randomH()}']})"/>

    6. 有效天与有效日期

      使用无效天和无效日期可以很方便的禁用不可用的日期,但是在只需要启用少部分日期的情况下,有效天和有效日期的功能就非常适合了.
      关键属性: opposite 默认为false, 为true时,无效天和无效日期变成有效天和有效日期

      示例4-6 只启用 每个月份的 5日 15日 25日


      <input id="d46" type="text" class="Wdate" onFocus="WdatePicker({opposite:true,disabledDates:['5$']})"/>

      注意 :'5$' 表示以 5 结尾 注意 $ 的用法

    5. 自定义事件

    1. 自定义事件

      如果你需要做一些附加的操作,你也不必担心,日期控件自带的自定义事件可以满足你的需求.此外,你还可以在自定义事件中调用提供的API库来做更多的运算和扩展,绝对可以通过很少的代码满足你及其个性化的需求.

      注意下面几个重要的指针,将对你的编程带来很多便利
      this: 指向文本框
      dp: 指向$dp
      dp.cal: 指向日期控件对象

      注意:函数原型必须使用类似 function(dp){} 的模式,这样子,在函数内部才可以使用dp

    2. onpicking 和 onpicked 事件

      示例5-2-1 onpicking事件演示


      <input type="text" id="5421" onFocus="WdatePicker({onpicking:function(dp){if(!confirm('日期框原来的值为: '+dp.cal.getDateStr()+', 要覆盖吗?')) return true;}})" class="Wdate"/>

      注意:dp.cal.getDateStr是一个
      内置函数

      示例5-2-2 使用onpicked实现日期选择联动

      选择第一个日期的时候,第二个日期选择框自动弹出
      日期从:

      注意:下面第一个控件代码的写法
      <input id="d5221" class="Wdate" type="text" onFocus="var d5222=$dp.$('d5222');WdatePicker({onpicked:function(){d5222.focus();},maxDate:'#F{$dp.$D(\'d5222\')}'})"/>

      <input id="d5222" class="Wdate" type="text" onFocus="WdatePicker({minDate:'#F{$dp.$D(\'d5221\')}'})"/>

      注意:$dp.$是一个
      内置函数,相当于document.getElementById

      示例5-2-3 将选择的值拆分到文本框


      <input type="text" id="d523_y" size="5"/> 年
      <input type="text" id="d523_M" size="3"/> 月
      <input type="text" id="d523_d" size="3"/> 日
      <input type="text" id="d523_HH" size="3"/> 时
      <input type="text" id="d523_mm" size="3"/> 分
      <input type="text" id="d523_ss" size="3"/> 秒
      <img οnclick="WdatePicker({el:'d523',dateFmt:'yyyy-MM-dd HH:mm:ss',onpicked:pickedFunc})" src="../../../../../My97DatePicker/skin/datePicker.gif" width="16" height="22" align="absmiddle" style="cursor:pointer"/>
      <script>
      function pickedFunc(){
      $dp.$('d523_y').value=$dp.cal.getP('y');
      $dp.$('d523_M').value=$dp.cal.getP('M');
      $dp.$('d523_d').value=$dp.cal.getP('d');
      $dp.$('d523_HH').value=$dp.cal.getP('H');
      $dp.$('d523_mm').value=$dp.cal.getP('m');
      $dp.$('d523_ss').value=$dp.cal.getP('s');
      }
      </script>

      注意:el:'d523'中,如果你不需要d523这个框,你可以把他改成hidden,但是el属性必须指定
      $dp.$和$dp.cal.getP都是
      内置函数

    3. onclearing 和 oncleared 事件

      示例5-3-1 使用onclearing事件取消清空操作


      <input type="text" class="Wdate" id="d531" onFocus="WdatePicker({onclearing:function(){if(!confirm('日期框的值为:'+this.value+', 确实要清空吗?'))return true;}})"/>

      注意:当onclearing函数返回true时,系统的清空事件将被取消,
      函数体里面没有引用$dp,所以函数原型里面可以省略参数dp

      示例5-3-2 使用cal对象取得当前日期所选择的月份(使用了 dp.cal)


      <input type="text" class="Wdate" id="d532" onFocus="WdatePicker({oncleared:function(dp){alert('当前日期所选择的月份为:'+dp.cal.date.M);}})"/>

      示例5-3-3 综合使用两个事件


      <script>
      function d533_focus(element){
      var clearingFunc = function(){ if(!confirm('日期框的值为:'+this.value+', 确实要清空吗?')) return true; }
      var clearedFunc = function(){ alert('日期框已被清空'); }
      WdatePicker({el:element,onclearing:clearingFunc,oncleared:clearedFunc})
      }
      </script>
      <input type="text" class="Wdate" id="d533" onFocus="d533_focus(this)"/>

    6. 快速选择功能

    此功能允许指定5个最常用的日期,可以方便用户选择,如果不指定,系统将自动生成
    相关属性:
    qsEnabled 是否启用快速选择功能
    quickSel 快速选择数据,可以传入5个快速选择日期,日期格式同min/maxDate

    注意:
    日期格式必须与 realDateFmt realTimeFmt 相匹配
    除了使用静态的日期值以外,还可以使用动态参数(如:%y,%M分别表示当前年和月)

    示例6-1 传入2个静态日期


    <input class="Wdate" type="text" οnfοcus="WdatePicker({dateFmt:'yyyy年MM月dd日',qsEnabled:true,quickSel:['2000-1-10','2000-2-20']})"/>

    注意:当传入的数据不足5个时,系统将自动补全

    示例6-2 传入2个动态日期,1个静态日期


    <input type="text" class="Wdate" onFocus="WdatePicker({dateFmt:'yyyy年MM月dd日',qsEnabled:true,quickSel:['2000-10-01','%y-%M-01','%y-%M-%ld']})"/>

    注意:当传入的数据不足5个时,系统将自动补全

    三. 配置说明

    1. 属性配置

    1. 属性表
      属性 类型 默认值 说明
      静态属性:只能在WdatePicker.js中配置,一般情况下,不建议您修改静态属性的值
      $wdate bool true 是否自动引入Wdate类 设置为true时,可直接在引入WdatePicker.js的页面里使用 class="Wdate"
      Wdate可在skin目录下的WdatePicker.css文件中定义
      建议使用默认值
      $dpPath string '' 是否显示指定程序包的绝对位置,一般情况下为空即可(程序自动创建),该属性是为防止极其少数的情况下程序创建出错而设置的
      设置方法:
      如果,程序包所在http中的地址为 http://localhost/proName/My97DatePicker/
      则 $dpPath = '/proName/My97DatePicker/';
      建议使用默认值
      可配置属性:可以在WdatePicker方法是配置
      el Element 或 String null 指定一个控件或控件的ID,必须具有value或innerHTML属性(如input,textarea,span,div,p等标签都可以),用户存储日期显示值(也就是dateFmt格式化后的值)
      vel Element 或 String null 指定一个控件或控件的ID,必须具有value属性(如input),用于存储真实值(也就是realDateFmt和realTimeFmt格式化后的值)
      position object {} 日期选择框显示位置
      注意:坐标默认单位是px,是相对当前框架坐标(不受滚动条),left属性只接受数字,top属性除接受数字外还可以接受 'above' 上方显示, 'under' 下方显示, 'auto' 系统根据页面大小自动选择(默认)
      如:
      {left:100,top:50}表示固定坐标[100,50]
      {top:50}表示横坐标自动生成,纵坐标指定为 50
      {left:100}表示纵坐标自动生成,横坐标指定为 100
      {top:'above'}表示上方显示
      {top:'under'}表示下方显示
      请参考示例
      lang string 'auto' 当值为'auto'时 自动根据客户端浏览器的语言自动选择语言
      当值为 其他 时 从langList中选择对应的语言
      你可以参考
      语言配置
      skin string 'default' 皮肤名称 默认自带 default和whyGreen两个皮肤
      另外如果你的css够强的话,可以自己做皮肤
      你可以参考
      皮肤配置
      dateFmt string 'yyyy-MM-dd' 日期显示格式
      你可以参考
      自定义格式
      realDateFmt string 'yyyy-MM-dd' 计算机可识别的,真正的日期格式
      无效日期设置(disabledDates),最大日期(maxDate),最小日期(minDate)以及快速日期都必须与它们相匹配
      建议使用默认值
      realTimeFmt string 'HH:mm:ss'
      realFullFmt string '%Date %Time'
      minDate string '1900-01-01 00:00:00' 最小日期(注意要与上面的real日期相匹配)
      maxDate string '2099-12-31 23:59:59' 最大日期(注意要与上面的real日期相匹配)
      startDate string '' 起始日期,既点击日期框时显示的起始日期
      为空时,使用今天作为起始日期(默认值)
      否则使用传入的日期作为起始日期(注意要与上面的real日期相匹配)
      你可以参考
      起始日期示例
      isShowWeek bool false 是否显示周
      你可以参考
      周显示示例
      highLineWeekDay bool true 是否高亮显示 周六 周日
      isShowClear bool true 是否显示清空按钮
      isShowToday bool true 是否显示今天按钮
      isShowOthers bool true 为true时,第一行空白处显示上月的日期,末行空白处显示下月的日期,否则不显示
      readOnly bool false 是否只读
      errDealMode int 0 纠错模式设置 可设置3中模式 0 - 提示 1 - 自动纠错 2 - 标记
      autoPickDate bool null 为false时 点日期的时候不自动输入,而是要通过确定才能输入
      为true时 即点击日期即可返回日期值
      为null时(推荐使用) 如果有时间置为false 否则置为true
      qsEnabled bool true 是否启用快速选择功能
      quickSel Array null 快速选择数据,可以传入5个快速选择日期
      注意:日期格式必须与 realDateFmt realTimeFmt realFullFmt 相匹配
      你可以参考
      快速选择示例
      disabledDays Array null 可以使用此功能禁用周日至周六所对应的日期
      0至6 分别代表 周日至周六
      你可以参考
      无效天示例
      disabledDates Array null 可以使用此功能禁用所指定的一个或多个日期
      你可以参考
      无效日期示例
      opposite bool false 默认为false, 为true时,无效天和无效日期变成有效天和有效日期
      你可以参考
      有效天与有效日期示例
      onpicking function null 此四个参数为事件参数
      你可以参考
      自定义事件示例
      onpicked function null
      onclearing function null
      oncleared function null
    2. 配置全局默认值

      通过配置WdatePicker.js的属性可以避免每次调用都传入配置值,为变成带来很多方便.
      在默认情况下My97为每个属性都配置了默认值,这些默认值都可以在WdatePicker.js中修改的
      你可以根据你个人的喜好更改这些值

      比如你比较不喜欢默认的皮肤default 而更喜欢 whyGreen 这个皮肤,
      你可以直接在WdatePicker.js把skin值改为 whyGreen
      这样,你就不必每次调用控件的时候都传入 skin:'whyGreen' 了
      你学会了吗?

    3. 配置单个控件

      在控件里面你可以使用 onfocus 或 onclick 事件来调用WdatePicker函数来触发日期控件
      WdatePicker({})其中{}中的内容都是只对当前实例有效,你可以任意配置属性表里有的所有属性
      你可以随意的组合这些属性,达到你的需求
      My97日期控件在这方面是做得非常灵活的.

    4. 多套配置快速切换

      您可以设置多个WdatePicker.js文件,如 cn_WdatePicker.js,en_WdatePicker.js,simple_WdatePicker.js等
      在不同的页面引入不同的 WdatePicker.js 达到配置快速切换的目的.
      注意:文件必须以 _WdatePicker.js(大小写不限制) 为后缀,形如 <yourname>_WdatePicker.js

    2. 语言配置

    1. 语言列表

      My97DatePicker目录下有个config.js,里面有段代码:
      var langList =
      [
      {name:'en', charset:'UTF-8'},
      {name:'zh-cn', charset:'gb2312'},
      {name:'zh-tw', charset:'GBK'}
      ];

      这就是语言列表,每个项有name和charset两个属性.
      name 表示语言的名称(必须与浏览器的语言字符串命名相同),在配置的时候,lang属性只能是配置列表里面已有的项,否则将自动返回第一项
      charset 表示对应语言目录下的js文件所对应的编码格式

    2. 语言安装说明

      分两步轻松实现:
      1 将语言文件拷贝到 lang 目录
      2 打开 config.js 配置语言列表

    3. 皮肤配置

    1. 皮肤列表

      My97DatePicker目录下有个config.js,里面有段代码:
      var skinList =
      [
      {name:'default', charset:'gb2312'},
      {name:'whyGreen', charset:'gb2312'},
      {name:'blue', charset:'gb2312'},
      {name:'simple', charset:'gb2312'}
      ];

      这就是皮肤列表,每个项有name和charset两个属性.
      name 表示皮肤的名称,在配置的时候,skin属性只能是配置列表里面已有的项,否则将自动返回第一项
      charset 表示对应皮肤目录下的css文件:datepicker.css所对应的编码格式

    2. 皮肤安装说明

      分两步轻松实现:
      1 将皮肤文件包拷贝到 skin 目录
      2 打开 config.js 配置皮肤列表

      注意:安装过多的皮肤会影响效率,一般5个以下比较适宜

    四. 如何使用

    1. 在使用该日期控件的文件中加入JS库(仅这一个文件即可,其他文件会自动引入,请勿删除或改名), 代码如下 <script language="javascript" type="text/javascript" src="datepicker/WdatePicker.js"></script>
    注:src="../../../datepicker/WdatePicker.js" 请根据你的实际情况改变路径

    2. 加上主调函数 WdatePicker
    关于 WdatePicker 的用法:


    如果您是新手,对js还不是很了解的话
    一定要多看看这份文档
    基本上每一个演示的示例下面都有相关代码,并且 关键属性用蓝字标出,关键值用红字标出 应该很容易看明白

    如果您有一定的水准
    希望能从头到尾把功能介绍好好看一遍,这样大部分功能你都会用了

    如果您是高手
    建议您通读配置说明和内置函数

    五. 内置函数

    函数名 返回值类型 作用域 参数 描述
    $dp.$ Element 全局 el [string]: 对象的ID 相当于document.getElementById
    参考 示例 1-1-2
    $dp.show void 全局 显示日期选择框
    $dp.hide void 全局 隐藏日期选择框
    $dp.$D String 全局 id [string]: 对象的ID
    arg [object]: 日期差量,可以设置成
    {y:[值],M:[值],d:[值],H:[值],m:[值],s:[值]}
    属性 y,M,d,H,m,s 分别代表 年月日时分秒
    {M:3,d:7} 表示 3个月零7天
    {d:1,H:1} 表示1天多1小时
    将id对应的日期框中的日期字符串,加上定义的日期差量,返回使用real格式化后的日期串
    参考 示例 4-3-2
    $dp.$DV String 全局 v [string]: 日期字符串
    arg [object]: 同上例的arg
    将传入的日期字符串,加上定义的日期差量,返回使用real格式化后的日期串
    参考 示例 4-3-3
    以下函数只在事件自定义函数中有效
    $dp.cal.getP String 事件function p [string]: 属性名称 yMdHmswWD分别代表年,月,日,时,分,秒,星期(0-6),周(1-52),星期(一-六)
    f [string]: format 格式字符串
    设置方法参考 1.4 自定义格式
    返回所指定属性被格式字符串格式化后的值[单属性]
    参考 示例 1-2-2
    dp.cal.getDateStr String 事件function f [string]: 格式字符串,为空时使用dateFmt
    返回所指定属性被格式字符串格式化后的值[整个值]
    完善中 完善中 完善中 完善中 完善中

     

    展开全文
  • Android-使用DatePicker选择时间和日期(时间选择器)

    万次阅读 热门讨论 2018-07-31 16:35:25
    Android-使用DatePicker选择时间和日期(年 月 日嵌套在DatePickerView中) 在安卓App里面,选择时间日期也是很常见的,比如在大部分APP里面填写个人信息的时候,会让你选择 你的出生日期,所以在项目中用到性好大: ...

    Android-使用DatePicker选择时间和日期(年 月 日嵌套在DatePickerView中)

    在安卓App里面,选择时间日期也是很常见的,比如在大部分APP里面填写个人信息的时候,会让你选择
    你的出生日期,所以在项目中用到性好大:

    注:

    效果图  (注弹出弹出的方式,由底部向上弹出,消失 由上到底部) 

    本人写了两篇时间选择器  这篇不适合您的需求,来看看这里  链接

      

    接下来我们开看看主要代码:

    首先CustomDatePicker类:
    /**
     * 创建人:lwd
     * 时  间:2018/4/24 10:12
     */
    public class CustomDatePicker {
    
        /**
         * 定义结果回调接口
         */
        public interface ResultHandler {
            void handle(String time);
        }
    
        public enum SCROLL_TYPE {
            HOUR(1),
            MINUTE(2);
    
            SCROLL_TYPE(int value) {
                this.value = value;
            }
    
            public int value;
        }
    
        private int scrollUnits = SCROLL_TYPE.HOUR.value + SCROLL_TYPE.MINUTE.value;
        private ResultHandler handler;
        private Context context;
        private boolean canAccess = false;
    
        private Dialog datePickerDialog;
        private DatePickerView year_pv, month_pv, day_pv, hour_pv, minute_pv;
    
        private static final int MAX_MINUTE = 59;
        private static final int MAX_HOUR = 23;
        private static final int MIN_MINUTE = 0;
        private static final int MIN_HOUR = 0;
        private static final int MAX_MONTH = 12;
    
        private ArrayList<String> year, month, day, hour, minute;
        private int startYear, startMonth, startDay, startHour, startMinute, endYear, endMonth, endDay, endHour, endMinute;
        private boolean spanYear, spanMon, spanDay, spanHour, spanMin;
        private Calendar selectedCalender, startCalendar, endCalendar;
        private TextView tv_cancle, tv_select;
    
        public CustomDatePicker(Context context, ResultHandler resultHandler, String startDate, String endDate) {
            if (isValidDate(startDate, "yyyy-MM-dd HH:mm") && isValidDate(endDate, "yyyy-MM-dd HH:mm")) {
                canAccess = true;
                this.context = context;
                this.handler = resultHandler;
                selectedCalender = Calendar.getInstance();
                startCalendar = Calendar.getInstance();
                endCalendar = Calendar.getInstance();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
                try {
                    startCalendar.setTime(sdf.parse(startDate));
                    endCalendar.setTime(sdf.parse(endDate));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                initDialog();
                initView();
            }
        }
    
        private void initDialog() {
            if (datePickerDialog == null) {
                datePickerDialog = new Dialog(context, R.style.time_dialog);
                datePickerDialog.setCancelable(false);
                datePickerDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
                datePickerDialog.setContentView(R.layout.custom_date_picker);
                Window window = datePickerDialog.getWindow();
                window.setGravity(Gravity.BOTTOM);
                datePickerDialog.setCanceledOnTouchOutside(true);
                WindowManager manager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
                DisplayMetrics dm = new DisplayMetrics();
                manager.getDefaultDisplay().getMetrics(dm);
                window.setWindowAnimations(R.style.dialogstyle); // 添加动画
                WindowManager.LayoutParams lp = window.getAttributes();
                lp.width = dm.widthPixels;
                window.setAttributes(lp);
            }
        }
    
        private void initView() {
            year_pv = (DatePickerView) datePickerDialog.findViewById(R.id.year_pv);
            month_pv = (DatePickerView) datePickerDialog.findViewById(R.id.month_pv);
            day_pv = (DatePickerView) datePickerDialog.findViewById(R.id.day_pv);
            hour_pv = (DatePickerView) datePickerDialog.findViewById(R.id.hour_pv);
            minute_pv = (DatePickerView) datePickerDialog.findViewById(R.id.minute_pv);
            tv_cancle = (TextView) datePickerDialog.findViewById(R.id.tv_cancle);
            tv_select = (TextView) datePickerDialog.findViewById(R.id.tv_select);
    
            tv_cancle.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    datePickerDialog.dismiss();
                }
            });
    
            tv_select.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
                    Log.d("jjjjj",sdf.format(selectedCalender.getTime())+"");
                    handler.handle(sdf.format(selectedCalender.getTime()));
                    datePickerDialog.dismiss();
                }
            });
        }
    
        private void initParameter() {
            startYear = startCalendar.get(Calendar.YEAR);
            startMonth = startCalendar.get(Calendar.MONTH) + 1;
            startDay = startCalendar.get(Calendar.DAY_OF_MONTH);
            startHour = startCalendar.get(Calendar.HOUR_OF_DAY);
            startMinute = startCalendar.get(Calendar.MINUTE);
            endYear = endCalendar.get(Calendar.YEAR);
            endMonth = endCalendar.get(Calendar.MONTH) + 1;
            endDay = endCalendar.get(Calendar.DAY_OF_MONTH);
            endHour = endCalendar.get(Calendar.HOUR_OF_DAY);
            endMinute = endCalendar.get(Calendar.MINUTE);
            spanYear = startYear != endYear;
            spanMon = (!spanYear) && (startMonth != endMonth);
            spanDay = (!spanMon) && (startDay != endDay);
            spanHour = (!spanDay) && (startHour != endHour);
            spanMin = (!spanHour) && (startMinute != endMinute);
            selectedCalender.setTime(startCalendar.getTime());
        }
    
        private void initTimer() {
            initArrayList();
            if (spanYear) {
                for (int i = startYear; i <= endYear; i++) {
                    year.add(String.valueOf(i)+"年");
                }
                for (int i = startMonth; i <= MAX_MONTH; i++) {
                    month.add(formatTimeUnit(i));
                }
                for (int i = startDay; i <= startCalendar.getActualMaximum(Calendar.DAY_OF_MONTH); i++) {
                    day.add(formatTimeUnit(i)+"日");
                }
    
                if ((scrollUnits & SCROLL_TYPE.HOUR.value) != SCROLL_TYPE.HOUR.value) {
                    hour.add(formatTimeUnit(startHour));
                } else {
                    for (int i = startHour; i <= MAX_HOUR; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                }
    
                if ((scrollUnits & SCROLL_TYPE.MINUTE.value) != SCROLL_TYPE.MINUTE.value) {
                    minute.add(formatTimeUnit(startMinute));
                } else {
                    for (int i = startMinute; i <= MAX_MINUTE; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                }
            } else if (spanMon) {
                year.add(String.valueOf(startYear)+"年");
                for (int i = startMonth; i <= endMonth; i++) {
                    month.add(formatTimeUnit(i)+"月");
                }
                for (int i = startDay; i <= startCalendar.getActualMaximum(Calendar.DAY_OF_MONTH); i++) {
                    day.add(formatTimeUnit(i)+"日");
                }
    
                if ((scrollUnits & SCROLL_TYPE.HOUR.value) != SCROLL_TYPE.HOUR.value) {
                    hour.add(formatTimeUnit(startHour));
                } else {
                    for (int i = startHour; i <= MAX_HOUR; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                }
    
                if ((scrollUnits & SCROLL_TYPE.MINUTE.value) != SCROLL_TYPE.MINUTE.value) {
                    minute.add(formatTimeUnit(startMinute));
                } else {
                    for (int i = startMinute; i <= MAX_MINUTE; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                }
            } else if (spanDay) {
                year.add(String.valueOf(startYear)+"年");
                month.add(formatTimeUnit(startMonth)+"月");
                for (int i = startDay; i <= endDay; i++) {
                    day.add(formatTimeUnit(i)+"日");
                }
    
                if ((scrollUnits & SCROLL_TYPE.HOUR.value) != SCROLL_TYPE.HOUR.value) {
                    hour.add(formatTimeUnit(startHour));
                } else {
                    for (int i = startHour; i <= MAX_HOUR; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                }
    
                if ((scrollUnits & SCROLL_TYPE.MINUTE.value) != SCROLL_TYPE.MINUTE.value) {
                    minute.add(formatTimeUnit(startMinute));
                } else {
                    for (int i = startMinute; i <= MAX_MINUTE; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                }
            } else if (spanHour) {
                year.add(String.valueOf(startYear)+"年");
                month.add(formatTimeUnit(startMonth)+"月");
                day.add(formatTimeUnit(startDay)+"日");
    
                if ((scrollUnits & SCROLL_TYPE.HOUR.value) != SCROLL_TYPE.HOUR.value) {
                    hour.add(formatTimeUnit(startHour));
                } else {
                    for (int i = startHour; i <= endHour; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                }
    
                if ((scrollUnits & SCROLL_TYPE.MINUTE.value) != SCROLL_TYPE.MINUTE.value) {
                    minute.add(formatTimeUnit(startMinute));
                } else {
                    for (int i = startMinute; i <= MAX_MINUTE; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                }
            } else if (spanMin) {
                year.add(String.valueOf(startYear)+"年");
                month.add(formatTimeUnit(startMonth)+"月");
                day.add(formatTimeUnit(startDay)+"日");
                hour.add(formatTimeUnit(startHour));
    
                if ((scrollUnits & SCROLL_TYPE.MINUTE.value) != SCROLL_TYPE.MINUTE.value) {
                    minute.add(formatTimeUnit(startMinute));
                } else {
                    for (int i = startMinute; i <= endMinute; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                }
            }
            loadComponent();
        }
    
        /**
         * 将“0-9”转换为“00-09”
         */
        private String formatTimeUnit(int unit) {
            return unit < 10 ? "0" + String.valueOf(unit) : String.valueOf(unit);
        }
    
        private void initArrayList() {
            if (year == null) year = new ArrayList<>();
            if (month == null) month = new ArrayList<>();
            if (day == null) day = new ArrayList<>();
            if (hour == null) hour = new ArrayList<>();
            if (minute == null) minute = new ArrayList<>();
            year.clear();
            month.clear();
            day.clear();
            hour.clear();
            minute.clear();
        }
    
        private void loadComponent() {
            year_pv.setData(year);
            month_pv.setData(month);
            day_pv.setData(day);
            hour_pv.setData(hour);
            minute_pv.setData(minute);
            year_pv.setSelected(0);
            month_pv.setSelected(0);
            day_pv.setSelected(0);
            hour_pv.setSelected(0);
            minute_pv.setSelected(0);
            executeScroll();
        }
    
        private void addListener() {
            year_pv.setOnSelectListener(new DatePickerView.onSelectListener() {
                @Override
                public void onSelect(String year) {
                    //截取年
                    selectedCalender.set(Calendar.YEAR, Integer.parseInt(year.substring(0,year.indexOf("年"))));
                    monthChange();
    
                }
            });
    
            month_pv.setOnSelectListener(new DatePickerView.onSelectListener() {
                @Override
                public void onSelect(String month) {
                    selectedCalender.set(Calendar.DAY_OF_MONTH, 1);
                    selectedCalender.set(Calendar.MONTH, Integer.parseInt(month.substring(0,month.indexOf("月"))) - 1);
                    dayChange();
                }
            });
    
            day_pv.setOnSelectListener(new DatePickerView.onSelectListener() {
                @Override
                public void onSelect(String day) {
                    selectedCalender.set(Calendar.DAY_OF_MONTH, Integer.parseInt(day.substring(0,day.indexOf("日"))));
                    //hourChange();
                }
            });
    
            hour_pv.setOnSelectListener(new DatePickerView.onSelectListener() {
                @Override
                public void onSelect(String text) {
                    selectedCalender.set(Calendar.HOUR_OF_DAY, Integer.parseInt(text));
                    //minuteChange();
                }
            });
    
            minute_pv.setOnSelectListener(new DatePickerView.onSelectListener() {
                @Override
                public void onSelect(String text) {
                    //selectedCalender.set(Calendar.MINUTE, Integer.parseInt(text));
                }
            });
        }
    
        private void monthChange() {
            month.clear();
            int selectedYear = selectedCalender.get(Calendar.YEAR);
            if (selectedYear == startYear) {
                for (int i = startMonth; i <= MAX_MONTH; i++) {
                    month.add(formatTimeUnit(i)+"月");
                }
            } else if (selectedYear == endYear) {
                for (int i = 1; i <= endMonth; i++) {
                    month.add(formatTimeUnit(i)+"月");
                }
            } else {
                for (int i = 1; i <= MAX_MONTH; i++) {
                    month.add(formatTimeUnit(i)+"月");
                }
            }
    
            selectedCalender.set(Calendar.MONTH, Integer.parseInt(month.get(0).substring(0,month.get(0).indexOf("月"))) - 1);
            month_pv.setData(month);
            month_pv.setSelected(0);
            executeAnimator(month_pv);
            month_pv.postDelayed(new Runnable() {
                @Override
                public void run() {
                    dayChange();
                }
            }, 100);
        }
    
        private void dayChange() {
            day.clear();
            int selectedYear = selectedCalender.get(Calendar.YEAR);
            int selectedMonth = selectedCalender.get(Calendar.MONTH) + 1;
            if (selectedYear == startYear && selectedMonth == startMonth) {
                for (int i = startDay; i <= selectedCalender.getActualMaximum(Calendar.DAY_OF_MONTH); i++) {
                    day.add(formatTimeUnit(i)+"日");
                }
            } else if (selectedYear == endYear && selectedMonth == endMonth) {
                for (int i = 1; i <= endDay; i++) {
                    day.add(formatTimeUnit(i)+"日");
                }
            } else {
                for (int i = 1; i <= selectedCalender.getActualMaximum(Calendar.DAY_OF_MONTH); i++) {
                    day.add(formatTimeUnit(i)+"日");
                }
            }
            selectedCalender.set(Calendar.DAY_OF_MONTH, Integer.parseInt(day.get(0).substring(0,day.get(0).indexOf("日"))));
            day_pv.setData(day);
            day_pv.setSelected(0);
            executeAnimator(day_pv);
    
            day_pv.postDelayed(new Runnable() {
                @Override
                public void run() {
                    hourChange();
                }
            }, 100);
        }
    
        private void hourChange() {
            if ((scrollUnits & SCROLL_TYPE.HOUR.value) == SCROLL_TYPE.HOUR.value) {
                hour.clear();
                int selectedYear = selectedCalender.get(Calendar.YEAR);
                int selectedMonth = selectedCalender.get(Calendar.MONTH) + 1;
                int selectedDay = selectedCalender.get(Calendar.DAY_OF_MONTH);
                if (selectedYear == startYear && selectedMonth == startMonth && selectedDay == startDay) {
                    for (int i = startHour; i <= MAX_HOUR; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                } else if (selectedYear == endYear && selectedMonth == endMonth && selectedDay == endDay) {
                    for (int i = MIN_HOUR; i <= endHour; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                } else {
                    for (int i = MIN_HOUR; i <= MAX_HOUR; i++) {
                        hour.add(formatTimeUnit(i));
                    }
                }
                selectedCalender.set(Calendar.HOUR_OF_DAY, Integer.parseInt(hour.get(0)));
                hour_pv.setData(hour);
                hour_pv.setSelected(0);
                executeAnimator(hour_pv);
            }
    
            hour_pv.postDelayed(new Runnable() {
                @Override
                public void run() {
                    minuteChange();
                }
            }, 100);
        }
    
        private void minuteChange() {
            if ((scrollUnits & SCROLL_TYPE.MINUTE.value) == SCROLL_TYPE.MINUTE.value) {
                minute.clear();
                int selectedYear = selectedCalender.get(Calendar.YEAR);
                int selectedMonth = selectedCalender.get(Calendar.MONTH) + 1;
                int selectedDay = selectedCalender.get(Calendar.DAY_OF_MONTH);
                int selectedHour = selectedCalender.get(Calendar.HOUR_OF_DAY);
                if (selectedYear == startYear && selectedMonth == startMonth && selectedDay == startDay && selectedHour == startHour) {
                    for (int i = startMinute; i <= MAX_MINUTE; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                } else if (selectedYear == endYear && selectedMonth == endMonth && selectedDay == endDay && selectedHour == endHour) {
                    for (int i = MIN_MINUTE; i <= endMinute; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                } else {
                    for (int i = MIN_MINUTE; i <= MAX_MINUTE; i++) {
                        minute.add(formatTimeUnit(i));
                    }
                }
                selectedCalender.set(Calendar.MINUTE, Integer.parseInt(minute.get(0)));
                minute_pv.setData(minute);
                minute_pv.setSelected(0);
                executeAnimator(minute_pv);
            }
            executeScroll();
        }
    
        private void executeAnimator(View view) {
            PropertyValuesHolder pvhX = PropertyValuesHolder.ofFloat("alpha", 1f, 0f, 1f);
            PropertyValuesHolder pvhY = PropertyValuesHolder.ofFloat("scaleX", 1f, 1.3f, 1f);
            PropertyValuesHolder pvhZ = PropertyValuesHolder.ofFloat("scaleY", 1f, 1.3f, 1f);
            ObjectAnimator.ofPropertyValuesHolder(view, pvhX, pvhY, pvhZ).setDuration(200).start();
        }
    
        private void executeScroll() {
            year_pv.setCanScroll(year.size() > 1);
            month_pv.setCanScroll(month.size() > 1);
            day_pv.setCanScroll(day.size() > 1);
            hour_pv.setCanScroll(hour.size() > 1 && (scrollUnits & SCROLL_TYPE.HOUR.value) == SCROLL_TYPE.HOUR.value);
            minute_pv.setCanScroll(minute.size() > 1 && (scrollUnits & SCROLL_TYPE.MINUTE.value) == SCROLL_TYPE.MINUTE.value);
        }
    
        private int disScrollUnit(SCROLL_TYPE... scroll_types) {
            if (scroll_types == null || scroll_types.length == 0) {
                scrollUnits = SCROLL_TYPE.HOUR.value + SCROLL_TYPE.MINUTE.value;
            } else {
                for (SCROLL_TYPE scroll_type : scroll_types) {
                    scrollUnits ^= scroll_type.value;
                }
            }
            return scrollUnits;
        }
    
        public void show(String time) {
            if (canAccess) {
                if (isValidDate(time, "yyyy-MM-dd")) {
                    if (startCalendar.getTime().getTime() < endCalendar.getTime().getTime()) {
                        canAccess = true;
                        initParameter();
                        initTimer();
                        //滑动监听
                        addListener();
                        setSelectedTime(time);
                        datePickerDialog.show();
                    }
                } else {
                    canAccess = false;
                }
            }
        }
    
        /**
         * 设置日期控件是否显示时和分
         */
        public void showSpecificTime(boolean show) {
            if (canAccess) {
                if (show) {
                    disScrollUnit();
                    hour_pv.setVisibility(View.VISIBLE);
    
                    minute_pv.setVisibility(View.VISIBLE);
    
                } else {
                    disScrollUnit(SCROLL_TYPE.HOUR, SCROLL_TYPE.MINUTE);
                    hour_pv.setVisibility(View.GONE);
                    minute_pv.setVisibility(View.GONE);
                }
            }
        }
    
        /**
         * 设置日期控件是否可以循环滚动
         */
        public void setIsLoop(boolean isLoop) {
            if (canAccess) {
                this.year_pv.setIsLoop(isLoop);
                this.month_pv.setIsLoop(isLoop);
                this.day_pv.setIsLoop(isLoop);
                this.hour_pv.setIsLoop(isLoop);
                this.minute_pv.setIsLoop(isLoop);
            }
        }
    
        /**
         * 设置日期控件默认选中的时间
         */
        public void setSelectedTime(String time) {
            if (canAccess) {
                String[] str = time.split(" ");
                String data = str[0];
                Log.d("tttt",data.substring(0,4)+","+data.substring(5,7)+","+data.substring(8,data.length()));
                year_pv.setSelected(data.substring(0,4)+"年");
                selectedCalender.set(Calendar.YEAR, Integer.parseInt(data.substring(0,4)));
                month.clear();
                int selectedYear = selectedCalender.get(Calendar.YEAR);
                if (selectedYear == startYear) {
                    for (int i = startMonth; i <= MAX_MONTH; i++) {
                        month.add(formatTimeUnit(i)+"月");
                    }
                } else if (selectedYear == endYear) {
                    for (int i = 1; i <= endMonth; i++) {
                        month.add(formatTimeUnit(i)+"月");
                    }
                } else {
                    for (int i = 1; i <= MAX_MONTH; i++) {
                        month.add(formatTimeUnit(i)+"月");
                    }
                }
                month_pv.setData(month);
                month_pv.setSelected(data.substring(5,7)+"月");
                selectedCalender.set(Calendar.MONTH, Integer.parseInt(data.substring(5,7)) - 1);
                executeAnimator(month_pv);
                day.clear();
                int selectedMonth = selectedCalender.get(Calendar.MONTH) + 1;
                if (selectedYear == startYear && selectedMonth == startMonth) {
                    for (int i = startDay; i <= selectedCalender.getActualMaximum(Calendar.DAY_OF_MONTH); i++) {
                        day.add(formatTimeUnit(i)+"日");
                    }
                } else if (selectedYear == endYear && selectedMonth == endMonth) {
                    for (int i = 1; i <= endDay; i++) {
                        day.add(formatTimeUnit(i)+"日");
                    }
                } else {
                    for (int i = 1; i <= selectedCalender.getActualMaximum(Calendar.DAY_OF_MONTH); i++) {
                        day.add(formatTimeUnit(i)+"日");
                    }
                }
                day_pv.setData(day);
                day_pv.setSelected(data.substring(8,data.length())+"日");
                selectedCalender.set(Calendar.DAY_OF_MONTH, Integer.parseInt(data.substring(8,data.length())));
                executeAnimator(day_pv);
                if (str.length == 2) {
                    String[] timeStr = str[1].split(":");
                    if ((scrollUnits & SCROLL_TYPE.HOUR.value) == SCROLL_TYPE.HOUR.value) {
                        hour.clear();
                        int selectedDay = selectedCalender.get(Calendar.DAY_OF_MONTH);
                        if (selectedYear == startYear && selectedMonth == startMonth && selectedDay == startDay) {
                            for (int i = startHour; i <= MAX_HOUR; i++) {
                                hour.add(formatTimeUnit(i));
                            }
                        } else if (selectedYear == endYear && selectedMonth == endMonth && selectedDay == endDay) {
                            for (int i = MIN_HOUR; i <= endHour; i++) {
                                hour.add(formatTimeUnit(i));
                            }
                        } else {
                            for (int i = MIN_HOUR; i <= MAX_HOUR; i++) {
                                hour.add(formatTimeUnit(i));
                            }
                        }
                        hour_pv.setData(hour);
                        hour_pv.setSelected(timeStr[0]);
                        selectedCalender.set(Calendar.HOUR_OF_DAY, Integer.parseInt(timeStr[0]));
                        executeAnimator(hour_pv);
                    }
    
                    if ((scrollUnits & SCROLL_TYPE.MINUTE.value) == SCROLL_TYPE.MINUTE.value) {
                        minute.clear();
                        int selectedDay = selectedCalender.get(Calendar.DAY_OF_MONTH);
                        int selectedHour = selectedCalender.get(Calendar.HOUR_OF_DAY);
                        if (selectedYear == startYear && selectedMonth == startMonth && selectedDay == startDay && selectedHour == startHour) {
                            for (int i = startMinute; i <= MAX_MINUTE; i++) {
                                minute.add(formatTimeUnit(i));
                            }
                        } else if (selectedYear == endYear && selectedMonth == endMonth && selectedDay == endDay && selectedHour == endHour) {
                            for (int i = MIN_MINUTE; i <= endMinute; i++) {
                                minute.add(formatTimeUnit(i));
                            }
                        } else {
                            for (int i = MIN_MINUTE; i <= MAX_MINUTE; i++) {
                                minute.add(formatTimeUnit(i));
                            }
                        }
                        minute_pv.setData(minute);
                        minute_pv.setSelected(timeStr[1]);
                        selectedCalender.set(Calendar.MINUTE, Integer.parseInt(timeStr[1]));
                        executeAnimator(minute_pv);
                    }
                }
                executeScroll();
            }
        }
    
        /**
         * 验证字符串是否是一个合法的日期格式
         */
        private boolean isValidDate(String date, String template) {
            boolean convertSuccess = true;
            // 指定日期格式
            SimpleDateFormat format = new SimpleDateFormat(template, Locale.CHINA);
            try {
                // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期,比如2015/02/29会被接受,并转换成2015/03/01
                format.setLenient(false);
                format.parse(date);
            } catch (Exception e) {
                // 如果throw java.text.ParseException或者NullPointerException,就说明格式不对
                convertSuccess = false;
            }
            return convertSuccess;
        }
    
    }
    

      DatePickerView类

    
    /**
     * 创建人:lwd
     * 时  间:2018/4/24 15:30
     */
    public class DatePickerView extends View {
    
        private Context context;
        /**
         * 新增字段 控制是否首尾相接循环显示 默认为循环显示
         */
        private boolean loop = true;
        /**
         * text之间间距和minTextSize之比
         */
        public static final float MARGIN_ALPHA = 2.8f;
        /**
         * 自动回滚到中间的速度
         */
        public static final float SPEED = 10;
        private List<String> mDataList;
        /**
         * 选中的位置,这个位置是mDataList的中心位置,一直不变
         */
        private int mCurrentSelected;
        private Paint mPaint, nPaint;
        private float mMaxTextSize = 80;
        private float mMinTextSize = 40;
        private float mMaxTextAlpha = 255;
        private float mMinTextAlpha = 120;
        private int mViewHeight;
        private int mViewWidth;
        private float mLastDownY;
        /**
         * 滑动的距离
         */
        private float mMoveLen = 0;
        private boolean isInit = false;
        private boolean canScroll = true;
        private onSelectListener mSelectListener;
        private Timer timer;
        private MyTimerTask mTask;
    
        private Handler updateHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                if (Math.abs(mMoveLen) < SPEED) {
                    mMoveLen = 0;
                    if (mTask != null) {
                        mTask.cancel();
                        mTask = null;
                        performSelect();
                    }
                } else {
                    // 这里mMoveLen / Math.abs(mMoveLen)是为了保有mMoveLen的正负号,以实现上滚或下滚
                    mMoveLen = mMoveLen - mMoveLen / Math.abs(mMoveLen) * SPEED;
                }
                invalidate();
            }
        };
    
        public DatePickerView(Context context, AttributeSet attrs) {
            super(context, attrs);
            this.context = context;
            init();
        }
    
        public void setOnSelectListener(onSelectListener listener) {
            mSelectListener = listener;
        }
    
        private void performSelect() {
            if (mSelectListener != null) {
                mSelectListener.onSelect(mDataList.get(mCurrentSelected));
            }
        }
    
        public void setData(List<String> datas) {
            mDataList = datas;
            mCurrentSelected = datas.size() / 4;
            invalidate();
        }
    
        /**
         * 选择选中的item的index
         */
        public void setSelected(int selected) {
            mCurrentSelected = selected;
            if (loop) {
                int distance = mDataList.size() / 2 - mCurrentSelected;
                if (distance < 0) {
                    for (int i = 0; i < -distance; i++) {
                        moveHeadToTail();
                        mCurrentSelected--;
                    }
                } else if (distance > 0) {
                    for (int i = 0; i < distance; i++) {
                        moveTailToHead();
                        mCurrentSelected++;
                    }
                }
            }
            invalidate();
        }
        /**
         * 选择选中的内容
         */
        public void setSelected(String mSelectItem) {
            for (int i = 0; i < mDataList.size(); i++) {
                if (mDataList.get(i).equals(mSelectItem)) {
                    setSelected(i);
                    break;
                }
            }
        }
    
        private void moveHeadToTail() {
            if (loop) {
                String head = mDataList.get(0);
                mDataList.remove(0);
                mDataList.add(head);
            }
        }
    
        private void moveTailToHead() {
            if (loop) {
                String tail = mDataList.get(mDataList.size() - 1);
                mDataList.remove(mDataList.size() - 1);
                mDataList.add(0, tail);
            }
        }
    
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            mViewHeight = getMeasuredHeight();
            mViewWidth = getMeasuredWidth();
            // 按照View的高度计算字体大小
            mMaxTextSize = mViewHeight / 7f;
            mMinTextSize = mMaxTextSize / 2.0f;
            isInit = true;
            invalidate();
        }
    
        private void init() {
            timer = new Timer();
            mDataList = new ArrayList<>();
            //第一个paint(选中)
            mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
            //mPaint.setStyle(Style.FILL);
            mPaint.setTextAlign(Align.CENTER);
            mPaint.setColor(ContextCompat.getColor(context, R.color.color_393b42));
            //第二个paint(未选中)
            nPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
            //nPaint.setStyle(Style.FILL);
            nPaint.setTextAlign(Align.CENTER);
            nPaint.setColor(ContextCompat.getColor(context, R.color.color_999999));
        }
    
        @Override
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            // 根据index绘制view
            if (isInit) {
                drawData(canvas);
            }
        }
    
        private void drawData(Canvas canvas) {
            // 先绘制选中的text再往上往下绘制其余的text
            float scale = parabola(mViewHeight / 4.0f, mMoveLen);
            float size = (mMaxTextSize - mMinTextSize) * scale + mMinTextSize-10;
            Log.d("gggg",size+"");
            mPaint.setTextSize(size);
            //mPaint.setTextSize(30);
            mPaint.setAlpha((int) ((mMaxTextAlpha - mMinTextAlpha) * scale + mMinTextAlpha));
            // text居中绘制,注意baseline的计算才能达到居中,y值是text中心坐标
            float x = (float) (mViewWidth / 2.0);
            float y = (float) (mViewHeight / 2.0 + mMoveLen);
            FontMetricsInt fmi = mPaint.getFontMetricsInt();
            float baseline = (float) (y - (fmi.bottom / 2.0 + fmi.top / 2.0));
    
            canvas.drawText(mDataList.get(mCurrentSelected), x, baseline, mPaint);
            // 绘制上方data
            for (int i = 1; (mCurrentSelected - i) >= 0; i++) {
                drawOtherText(canvas, i, -1);
            }
            // 绘制下方data
            for (int i = 1; (mCurrentSelected + i) < mDataList.size(); i++) {
                drawOtherText(canvas, i, 1);
            }
        }
    
        /**
         * @param position 距离mCurrentSelected的差值
         * @param type     1表示向下绘制,-1表示向上绘制
         */
        private void drawOtherText(Canvas canvas, int position, int type) {
            float d = MARGIN_ALPHA * mMinTextSize * position + type * mMoveLen;
            float scale = parabola(mViewHeight / 4.0f, d);
            float size = (mMaxTextSize - mMinTextSize) * scale + mMinTextSize-10;
            nPaint.setTextSize(size);
            //nPaint.setTextSize(28);
            nPaint.setAlpha((int) ((mMaxTextAlpha - mMinTextAlpha) * scale + mMinTextAlpha));
            float y = (float) (mViewHeight / 2.0 + type * d);
            FontMetricsInt fmi = nPaint.getFontMetricsInt();
            float baseline = (float) (y - (fmi.bottom / 2.0 + fmi.top / 2.0));
            canvas.drawText(mDataList.get(mCurrentSelected + type * position),
                    (float) (mViewWidth / 2.0), baseline, nPaint);
        }
    
        /**
         * 抛物线
         *
         * @param zero 零点坐标
         * @param x    偏移量
         */
        private float parabola(float zero, float x) {
            float f = (float) (1 - Math.pow(x / zero, 2));
            return f < 0 ? 0 : f;
        }
    
        @Override
        public boolean onTouchEvent(MotionEvent event) {
            switch (event.getActionMasked()) {
                case MotionEvent.ACTION_DOWN:
                    doDown(event);
                    break;
    
                case MotionEvent.ACTION_MOVE:
                    mMoveLen += (event.getY() - mLastDownY);
                    if (mMoveLen > MARGIN_ALPHA * mMinTextSize / 2) {
                        if (!loop && mCurrentSelected == 0) {
                            mLastDownY = event.getY();
                            invalidate();
                            return true;
                        }
                        if (!loop) {
                            mCurrentSelected--;
                        }
                        // 往下滑超过离开距离
                        moveTailToHead();
                        mMoveLen = mMoveLen - MARGIN_ALPHA * mMinTextSize;
                    } else if (mMoveLen < -MARGIN_ALPHA * mMinTextSize / 2) {
                        if (mCurrentSelected == mDataList.size() - 1) {
                            mLastDownY = event.getY();
                            invalidate();
                            return true;
                        }
                        if (!loop) {
                            mCurrentSelected++;
                        }
                        // 往上滑超过离开距离
                        moveHeadToTail();
                        mMoveLen = mMoveLen + MARGIN_ALPHA * mMinTextSize;
                    }
                    mLastDownY = event.getY();
                    invalidate();
                    break;
    
                case MotionEvent.ACTION_UP:
                    doUp();
                    break;
            }
            return true;
        }
    
        private void doDown(MotionEvent event) {
            if (mTask != null) {
                mTask.cancel();
                mTask = null;
            }
            mLastDownY = event.getY();
        }
    
        private void doUp() {
            // 抬起手后mCurrentSelected的位置由当前位置move到中间选中位置
            if (Math.abs(mMoveLen) < 0.0001) {
                mMoveLen = 0;
                return;
            }
            if (mTask != null) {
                mTask.cancel();
                mTask = null;
            }
            mTask = new MyTimerTask(updateHandler);
            timer.schedule(mTask, 0, 10);
        }
    
        class MyTimerTask extends TimerTask {
            Handler handler;
    
            public MyTimerTask(Handler handler) {
                this.handler = handler;
            }
    
            @Override
            public void run() {
                handler.sendMessage(handler.obtainMessage());
            }
        }
    
        public interface onSelectListener {
            void onSelect(String text);
        }
    
        public void setCanScroll(boolean canScroll) {
            this.canScroll = canScroll;
        }
    
        @Override
        public boolean dispatchTouchEvent(MotionEvent event) {
            return canScroll && super.dispatchTouchEvent(event);
        }
    
        /**
         * 控制内容是否首尾相连
         */
        public void setIsLoop(boolean isLoop) {
            loop = isLoop;
        }
    
    }

        主要是这两个类,而CustomDatePicker中的年 月 日是添加在每个Picker中

        MainActivity主类:
      

    
    public class MainActivity extends Activity implements View.OnClickListener{
        private CustomDatePicker customDatePicker;
        private String now;
        private TextView tv;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            tv = findViewById(R.id.tv);
            findViewById(R.id.bt).setOnClickListener(this);
            DatePicker();
        }
        /**
         * 显示时间
         */
        private void DatePicker() {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA);
            //获取当前时间
            now = sdf.format(new Date());
            //tvElectricalTime.setText(now.split(" ")[0]);
            customDatePicker = new CustomDatePicker(this, new CustomDatePicker.ResultHandler() {
                @Override
                public void handle(String time) { // 回调接口,获得选中的时间
                    Log.d("yyyyy", time);
                    tv.setText(time.split(" ")[0]);
    
                }
            }, "1990-01-01 00:00", now); // 初始化日期格式请用:yyyy-MM-dd HH:mm,否则不能正常运行
            customDatePicker.showSpecificTime(false); // 不显示时和分
            customDatePicker.setIsLoop(false); // 不允许循环滚动
        }
    
        @Override
        public void onClick(View view) {
            if (TextUtils.isEmpty(tv.getText().toString().trim()))
                customDatePicker.show(now);
            else  // 日期格式为yyyy-MM-dd
                customDatePicker.show(tv.getText().toString());
    
        }
    }
    

    接下来我们来看下布局文件: custom_date_picker.xml(这用的Autolayout来做的界面适配)

    <?xml version="1.0" encoding="utf-8"?>
    <com.zhy.autolayout.AutoLinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
        <com.zhy.autolayout.AutoRelativeLayout
            android:layout_width="match_parent"
            android:layout_height="90px"
            android:background="@color/color_ffffff">
    
            <TextView
                android:id="@+id/tv_cancle"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerVertical="true"
                android:padding="20px"
                android:text="@string/cancle"
                android:textColor="@color/red"
                android:textSize="30px"
                android:layout_marginLeft="20px"/>
    
            <TextView
                android:id="@+id/tv_title"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerInParent="true"
                android:text="@string/title"
                android:textColor="@color/color_232326"
                android:textSize="30px" />
    
            <TextView
                android:id="@+id/tv_select"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignParentEnd="true"
                android:layout_centerVertical="true"
                android:padding="20px"
                android:text="@string/commit"
                android:textColor="@color/red"
                android:textSize="30px"
                android:layout_marginRight="20px"/>
    
        </com.zhy.autolayout.AutoRelativeLayout>
    
        <View
            android:layout_width="match_parent"
            android:layout_height="1px"
            android:background="#f1f3f6" />
    
        <com.zhy.autolayout.AutoRelativeLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content">
    
            <com.zhy.autolayout.AutoLinearLayout
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginBottom="10px"
                android:background="@color/color_ffffff"
                android:orientation="horizontal"
                android:paddingBottom="30px"
                android:paddingLeft="40px"
                android:paddingRight="40px"
                android:paddingTop="30px">
    
                <com.dayo.map.selectime.DatePickerView
                    android:id="@+id/year_pv"
                    android:layout_width="0px"
                    android:layout_height="320px"
                    android:layout_weight="1"
                    />
    
                <com.dayo.map.selectime.DatePickerView
                    android:id="@+id/month_pv"
                    android:layout_width="0px"
                    android:layout_height="320px"
                    android:layout_weight="1" />
    
                <com.dayo.map.selectime.DatePickerView
                    android:id="@+id/day_pv"
                    android:layout_width="0px"
                    android:layout_height="320px"
                    android:layout_weight="1" />
    
                <com.dayo.map.selectime.DatePickerView
                    android:id="@+id/hour_pv"
                    android:layout_width="0px"
                    android:layout_height="320px"
                    android:layout_weight="1" />
    
                <com.dayo.map.selectime.DatePickerView
                    android:id="@+id/minute_pv"
                    android:layout_width="0px"
                    android:layout_height="320px"
                    android:layout_weight="1" />
    
            </com.zhy.autolayout.AutoLinearLayout>
    
        </com.zhy.autolayout.AutoRelativeLayout>
    
    </com.zhy.autolayout.AutoLinearLayout>

       activity_main.xml类就没有什么东西了,但是我们还是贴出来吧

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context="com.dayo.map.selectime.MainActivity">
    
      <Button
          android:id="@+id/bt"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="时间选择器"
          android:layout_centerHorizontal="true"/>
      <TextView
          android:id="@+id/tv"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:layout_below="@+id/bt"
          android:layout_marginTop="30px"
          android:layout_centerHorizontal="true"/>
    </RelativeLayout>
    

    到这里所有代码基本都已经贴出,还有一些辅助的文件就不一一贴出了,希望能帮到大家

    点我有代码哦

    展开全文
  • 时间选择框datepicker的使用

    千次阅读 2019-05-06 20:30:39
    bootstrap框架中的一个重要内容,时间选择框datepicker。 如,想要实现选择从某天到某天的两个输入框: 在HTML中写如下内容 <div class="input-daterange date-picker input-group" id="datepicker"> <...

    bootstrap框架中的一个重要内容,时间选择框datepicker。
    如,想要实现选择从某天到某天的两个输入框:
    在HTML中写如下内容

    <div class="input-daterange date-picker input-group" id="datepicker">
        <input type="text" class="input-sm form-control" name="start" id="start-date" value=""/>
        <span class="input-group-addon">到</span>
        <input type="text" class="input-sm form-control" name="end" id="end-date" value=""/>
    </div>
    

    input-daterange是指一个输入一个时间范围,也就说需要有两个输入框,默认后一个框的时间必须大于前一个框的 date-picker就规定了里面的input是时间选择的框框,后面还可以加data-date-format="yyyy-mm-dd"来规定时间格式

    在JS中写如下内容

    /*
    	 * 没有如下内容,输入框是不会弹出时间选择的框框的
    	 * autoclose是自动关闭框框的意思
    	 * 可以加属性language: "zh-CN",来规定语言为中文
    	 */
        $('#data_5 .input-daterange').datepicker({
            keyboardNavigation: false,
            forceParse: false,
            autoclose: true
        });
    
        $('#data_6 .input-daterange').datepicker({
            keyboardNavigation: false,
            forceParse: false,
            autoclose: true
        });
    

    还有在js中设置输入框中的时间

    // 默认查询时间今天
        var curDate = new Date();
        var yearNow = curDate.getFullYear();
        var monthNow = curDate.getMonth();
        var dayNow = curDate.getDate();
        var curDateFormat = getFormatDate(yearNow, monthNow, dayNow);
        // 默认30天
        var preDate = new Date(curDate.getTime() - 30 * 24 * 60 * 60 * 1000); // 前30天
        var preDateFormat = getFormatDate(preDate.getFullYear(), preDate.getMonth(), preDate.getDate());
        // 日期初始化
        document.getElementById("start-date").value = preDateFormat;
        document.getElementById("end-date").value = curDateFormat;
    

    如果只是想实现一个时间输入框
    如下:

    <input type="text" class="datepicker" placeholder="请选择日期" />
    
    <script type="text/javascript">
        $(function () {
            $(".datepicker").datepicker({
                language: "zh-CN",
                autoclose: true,//选中之后自动隐藏日期选择框
                clearBtn: true,//清除按钮
                todayBtn: true,//今日按钮
                format: "yyyy-mm-dd"//日期格式
            });
        });
    </script>
    

    参考:
    https://www.cnblogs.com/mymint/p/4512463.html

    展开全文
  • 时间插件WdatePicker的用法总结

    千次阅读 2018-10-09 15:31:29
    用时引入js文件即可: &lt;script src="WdatePicker/WdatePicker.js"&gt;&lt;/script&...的用处是加上class的会有个时间的小图标,如图所示: ... 你可以给通过配置minDat...
  • datepicker的一些常用方法

    千次阅读 2018-08-30 11:39:33
    $('.startTime').datepicker('setDate', formatDate(new Date(), "yyyy-MM-dd")); 2、初始化时间 $("#todo-task-modal .input-group.date").datepicker({ startDate: new Date(), format: ...
  • WdatePicker 使用默认时间

    万次阅读 2018-08-13 11:41:43
    除了使用静态的日期值以外,还可以使用动态参数(如:%y,%M分别表示当前年和月) 下例演示,年月日使用当年当月的1日,时分秒使用00:00:00作为起始时间 &lt;input type="text" id="...
  • WdatePicker使用方法

    千次阅读 2019-08-14 13:51:33
    转载:https://www.cnblogs.com/goloving/p/7163697.html 只需要引入js文件即可: 自己试了个小实例: 复制代码 <!... ... 其中class="Wdate"加与不加,会在页面上有所差异,加上class的如图示会有个时间的小图...
  • datepicker的使用方法

    万次阅读 2018-12-26 17:19:12
    而非被划为
  • jQuery-ui插件datepicker的参数使用详解

    千次阅读 2018-11-13 08:46:54
    概述日期选择插件是一个配置灵活的插件,你可以定义它的展示方式,包括日期格式、语言、限制选择日期范围、添加相关按钮以及其它导航等。同时,你还可以通过键盘控制它:page up/down - 上一月、下一月ctrl+page up/...
  • 【Vue】DatePicker 设置默认日期

    万次阅读 热门讨论 2019-05-14 11:35:35
    利用DatePicker组件设置默认日期为当天或一个月后 效果图: 实现代码 <template> <card> <label>开始时间</label> <DatePicker v-model="startTime" type="datetime" :editable=...
  • JS日历插件 - My97 DatePicker

    千次阅读 2019-02-26 14:52:42
    文章整理之My97 DatePicker官网,使用版本为4.8 Beta4.   My97DatePicker基本用法 1. My97DatePicker是一款非常灵活好用的日期控件。使用非常简单。  1、下载My97DatePicker组件包  下载地址:...
  • My97DatePicker基本用法

    万次阅读 多人点赞 2015-01-20 16:09:56
    My97DatePicker是一款非常灵活好用的日期控件。使用非常简单。  1、下载My97DatePicker组件包  2、在页面中引入该组件js文件:    3、例子 My97DatePicker日期控件使用 My97DatePicker日期控件...
  • My97DatePicker包(WdatePicker.js文件加了详细备注)

    千次下载 热门讨论 2020-07-30 23:33:23
    My97DatePicker目录是一个整体,不可破坏里面的目录结构,也不可对里面的文件改名,可以改目录名 My97DatePicker.htm是必须文件,不可删除(4.8以后不存在此文件) 各目录及文件的用途: WdatePicker.js 配置文件,在调用的...
  • bootstrap-datepicker限定可选时间范围

    万次阅读 多人点赞 2020-04-07 12:29:57
    一、应用场景 实际应用中可能会根据日期字段查询某个日期范围内的数据,则需要对日期选择器可选时间进行限制, 如:开始时间不能大于结束时间,结束时间不能小于开始时间,...引入bootstrap-datepicker.js和boot...
  • bootstrap datepicker是一款不错的日期插件,而且在国际化方面也有不错的支持。 在日常开发中使用的非常多,简单好用。 1,datepicker介绍 detepicker的效果: 官网的例子: &amp;amp;lt;!doctype ...
  • JQuery UI Datepicker SetDate

    2019-10-30 15:27:00
    <p>I use the popular JQuery UI Datepicker to add/modify events on my web site. I am having a problem with getting the date to show up right using setDate. The incorrect date seems to always show up no...
  • My97DatePicker时间控件的使用 在eclipse中先把My97DatePicker时间控件文件放在WebContent文件下,最好建立一个文件。比如:js。 在jsp文件中添加&amp;amp;lt;script src=&amp;quot;${pageContext....
  • my97DatePicker日期控件

    2020-07-07 19:44:58
    1、下载My97DatePicker组件包 下载地址:http://download.csdn.net/detail/emoven/8249073 2、在页面中引入该组件js文件: <script type="text/JavaScript" src="My97DatePicker/WdatePicker.js"></script&...
1 2 3 4 5 ... 20
收藏数 28,507
精华内容 11,402
关键字:

datepicker