jquery-timepicker-addon-rails 1.2.3 → 1.4.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (4) hide show
  1. data/lib/jquery-timepicker-addon-rails/version.rb +1 -1
  2. data/vendor/assets/javascripts/jquery-ui-timepicker-addon.js +803 -585
  3. data/vendor/assets/stylesheets/jquery-ui-timepicker-addon.css +5 -4
  4. metadata +2 -2
data/lib/jquery-timepicker-addon-rails/version.rb CHANGED
@@ -2,7 +2,7 @@ module Jquery
2
2
  module Timepicker
3
3
  module Addon
4
4
  module Rails
5
- VERSION = "1.2.3"
5
+ VERSION = "1.4.1"
6
6
  end
7
7
  end
8
8
  end
data/vendor/assets/javascripts/jquery-ui-timepicker-addon.js CHANGED
@@ -1,18 +1,7 @@
1
- /*
2
- * jQuery timepicker addon
3
- * By: Trent Richardson [http://trentrichardson.com]
4
- * Version 1.2
5
- * Last Modified: 02/02/2013
6
- *
7
- * Copyright 2013 Trent Richardson
8
- * You may use this project under MIT or GPL licenses.
9
- * http://trentrichardson.com/Impromptu/GPL-LICENSE.txt
10
- * http://trentrichardson.com/Impromptu/MIT-LICENSE.txt
11
- */
12
-
13
- /*jslint evil: true, white: false, undef: false, nomen: false */
14
-
15
- (function($) {
1
+ /*! jQuery Timepicker Addon - v1.4.1 - 2013-11-10
2
+ * http://trentrichardson.com/examples/timepicker
3
+ * Copyright (c) 2013 Trent Richardson; Licensed MIT */
4
+ (function ($) {
16
5
 
17
6
  /*
18
7
  * Lets not redefine timepicker, Prevent "Uncaught RangeError: Maximum call stack size exceeded"
@@ -27,17 +16,17 @@
27
16
  */
28
17
  $.extend($.ui, {
29
18
  timepicker: {
30
- version: "1.2"
19
+ version: "1.4.1"
31
20
  }
32
21
  });
33
22
 
34
- /*
23
+ /*
35
24
  * Timepicker manager.
36
25
  * Use the singleton instance of this class, $.timepicker, to interact with the time picker.
37
26
  * Settings for (groups of) time pickers are maintained in an instance object,
38
27
  * allowing multiple different settings on the same page.
39
28
  */
40
- var Timepicker = function() {
29
+ var Timepicker = function () {
41
30
  this.regional = []; // Available regional settings, indexed by language code
42
31
  this.regional[''] = { // Default regional settings
43
32
  currentText: 'Now',
@@ -52,37 +41,41 @@
52
41
  minuteText: 'Minute',
53
42
  secondText: 'Second',
54
43
  millisecText: 'Millisecond',
44
+ microsecText: 'Microsecond',
55
45
  timezoneText: 'Time Zone',
56
46
  isRTL: false
57
47
  };
58
48
  this._defaults = { // Global defaults for all the datetime picker instances
59
49
  showButtonPanel: true,
60
50
  timeOnly: false,
61
- showHour: true,
62
- showMinute: true,
63
- showSecond: false,
64
- showMillisec: false,
65
- showTimezone: false,
51
+ showHour: null,
52
+ showMinute: null,
53
+ showSecond: null,
54
+ showMillisec: null,
55
+ showMicrosec: null,
56
+ showTimezone: null,
66
57
  showTime: true,
67
58
  stepHour: 1,
68
59
  stepMinute: 1,
69
60
  stepSecond: 1,
70
61
  stepMillisec: 1,
62
+ stepMicrosec: 1,
71
63
  hour: 0,
72
64
  minute: 0,
73
65
  second: 0,
74
66
  millisec: 0,
67
+ microsec: 0,
75
68
  timezone: null,
76
- useLocalTimezone: false,
77
- defaultTimezone: "+0000",
78
69
  hourMin: 0,
79
70
  minuteMin: 0,
80
71
  secondMin: 0,
81
72
  millisecMin: 0,
73
+ microsecMin: 0,
82
74
  hourMax: 23,
83
75
  minuteMax: 59,
84
76
  secondMax: 59,
85
77
  millisecMax: 999,
78
+ microsecMax: 999,
86
79
  minDateTime: null,
87
80
  maxDateTime: null,
88
81
  onSelect: null,
@@ -90,6 +83,7 @@
90
83
  minuteGrid: 0,
91
84
  secondGrid: 0,
92
85
  millisecGrid: 0,
86
+ microsecGrid: 0,
93
87
  alwaysSetTime: true,
94
88
  separator: ' ',
95
89
  altFieldTimeOnly: true,
@@ -99,7 +93,6 @@
99
93
  pickerTimeFormat: null,
100
94
  pickerTimeSuffix: null,
101
95
  showTimepicker: true,
102
- timezoneIso8601: false,
103
96
  timezoneList: null,
104
97
  addSliderAccess: false,
105
98
  sliderAccessArgs: null,
@@ -119,35 +112,39 @@
119
112
  minute_slider: null,
120
113
  second_slider: null,
121
114
  millisec_slider: null,
115
+ microsec_slider: null,
122
116
  timezone_select: null,
123
117
  hour: 0,
124
118
  minute: 0,
125
119
  second: 0,
126
120
  millisec: 0,
121
+ microsec: 0,
127
122
  timezone: null,
128
- defaultTimezone: "+0000",
129
123
  hourMinOriginal: null,
130
124
  minuteMinOriginal: null,
131
125
  secondMinOriginal: null,
132
126
  millisecMinOriginal: null,
127
+ microsecMinOriginal: null,
133
128
  hourMaxOriginal: null,
134
129
  minuteMaxOriginal: null,
135
130
  secondMaxOriginal: null,
136
131
  millisecMaxOriginal: null,
132
+ microsecMaxOriginal: null,
137
133
  ampm: '',
138
134
  formattedDate: '',
139
135
  formattedTime: '',
140
136
  formattedDateTime: '',
141
137
  timezoneList: null,
142
- units: ['hour','minute','second','millisec'],
138
+ units: ['hour', 'minute', 'second', 'millisec', 'microsec'],
139
+ support: {},
143
140
  control: null,
144
141
 
145
- /*
142
+ /*
146
143
  * Override the default settings for all instances of the time picker.
147
- * @param settings object - the new settings to use as defaults (anonymous object)
148
- * @return the manager object
144
+ * @param {Object} settings object - the new settings to use as defaults (anonymous object)
145
+ * @return {Object} the manager object
149
146
  */
150
- setDefaults: function(settings) {
147
+ setDefaults: function (settings) {
151
148
  extendRemove(this._defaults, settings || {});
152
149
  return this;
153
150
  },
@@ -155,14 +152,14 @@
155
152
  /*
156
153
  * Create a new Timepicker instance
157
154
  */
158
- _newInst: function($input, o) {
155
+ _newInst: function ($input, opts) {
159
156
  var tp_inst = new Timepicker(),
160
157
  inlineSettings = {},
161
- fns = {},
162
- overrides, i;
158
+ fns = {},
159
+ overrides, i;
163
160
 
164
161
  for (var attrName in this._defaults) {
165
- if(this._defaults.hasOwnProperty(attrName)){
162
+ if (this._defaults.hasOwnProperty(attrName)) {
166
163
  var attrValue = $input.attr('time:' + attrName);
167
164
  if (attrValue) {
168
165
  try {
@@ -173,85 +170,99 @@
173
170
  }
174
171
  }
175
172
  }
176
- overrides = {
177
- beforeShow: function (input, dp_inst) {
178
- if ($.isFunction(tp_inst._defaults.evnts.beforeShow)) {
179
- return tp_inst._defaults.evnts.beforeShow.call($input[0], input, dp_inst, tp_inst);
180
- }
181
- },
182
- onChangeMonthYear: function (year, month, dp_inst) {
183
- // Update the time as well : this prevents the time from disappearing from the $input field.
184
- tp_inst._updateDateTime(dp_inst);
185
- if ($.isFunction(tp_inst._defaults.evnts.onChangeMonthYear)) {
186
- tp_inst._defaults.evnts.onChangeMonthYear.call($input[0], year, month, dp_inst, tp_inst);
187
- }
188
- },
189
- onClose: function (dateText, dp_inst) {
190
- if (tp_inst.timeDefined === true && $input.val() !== '') {
191
- tp_inst._updateDateTime(dp_inst);
192
- }
193
- if ($.isFunction(tp_inst._defaults.evnts.onClose)) {
194
- tp_inst._defaults.evnts.onClose.call($input[0], dateText, dp_inst, tp_inst);
195
- }
196
- }
197
- };
198
- for (i in overrides) {
199
- if (overrides.hasOwnProperty(i)) {
200
- fns[i] = o[i] || null;
201
- }
202
- }
203
- tp_inst._defaults = $.extend({}, this._defaults, inlineSettings, o, overrides, {
204
- evnts:fns,
205
- timepicker: tp_inst // add timepicker as a property of datepicker: $.datepicker._get(dp_inst, 'timepicker');
206
- });
207
- tp_inst.amNames = $.map(tp_inst._defaults.amNames, function(val) {
173
+
174
+ overrides = {
175
+ beforeShow: function (input, dp_inst) {
176
+ if ($.isFunction(tp_inst._defaults.evnts.beforeShow)) {
177
+ return tp_inst._defaults.evnts.beforeShow.call($input[0], input, dp_inst, tp_inst);
178
+ }
179
+ },
180
+ onChangeMonthYear: function (year, month, dp_inst) {
181
+ // Update the time as well : this prevents the time from disappearing from the $input field.
182
+ tp_inst._updateDateTime(dp_inst);
183
+ if ($.isFunction(tp_inst._defaults.evnts.onChangeMonthYear)) {
184
+ tp_inst._defaults.evnts.onChangeMonthYear.call($input[0], year, month, dp_inst, tp_inst);
185
+ }
186
+ },
187
+ onClose: function (dateText, dp_inst) {
188
+ if (tp_inst.timeDefined === true && $input.val() !== '') {
189
+ tp_inst._updateDateTime(dp_inst);
190
+ }
191
+ if ($.isFunction(tp_inst._defaults.evnts.onClose)) {
192
+ tp_inst._defaults.evnts.onClose.call($input[0], dateText, dp_inst, tp_inst);
193
+ }
194
+ }
195
+ };
196
+ for (i in overrides) {
197
+ if (overrides.hasOwnProperty(i)) {
198
+ fns[i] = opts[i] || null;
199
+ }
200
+ }
201
+
202
+ tp_inst._defaults = $.extend({}, this._defaults, inlineSettings, opts, overrides, {
203
+ evnts: fns,
204
+ timepicker: tp_inst // add timepicker as a property of datepicker: $.datepicker._get(dp_inst, 'timepicker');
205
+ });
206
+ tp_inst.amNames = $.map(tp_inst._defaults.amNames, function (val) {
208
207
  return val.toUpperCase();
209
208
  });
210
- tp_inst.pmNames = $.map(tp_inst._defaults.pmNames, function(val) {
209
+ tp_inst.pmNames = $.map(tp_inst._defaults.pmNames, function (val) {
211
210
  return val.toUpperCase();
212
211
  });
213
212
 
213
+ // detect which units are supported
214
+ tp_inst.support = detectSupport(
215
+ tp_inst._defaults.timeFormat +
216
+ (tp_inst._defaults.pickerTimeFormat ? tp_inst._defaults.pickerTimeFormat : '') +
217
+ (tp_inst._defaults.altTimeFormat ? tp_inst._defaults.altTimeFormat : ''));
218
+
214
219
  // controlType is string - key to our this._controls
215
- if(typeof(tp_inst._defaults.controlType) === 'string'){
216
- if($.fn[tp_inst._defaults.controlType] === undefined){
220
+ if (typeof(tp_inst._defaults.controlType) === 'string') {
221
+ if (tp_inst._defaults.controlType === 'slider' && typeof($.ui.slider) === 'undefined') {
217
222
  tp_inst._defaults.controlType = 'select';
218
223
  }
219
224
  tp_inst.control = tp_inst._controls[tp_inst._defaults.controlType];
220
225
  }
221
226
  // controlType is an object and must implement create, options, value methods
222
- else{
227
+ else {
223
228
  tp_inst.control = tp_inst._defaults.controlType;
224
229
  }
225
230
 
226
- if (tp_inst._defaults.timezoneList === null) {
227
- var timezoneList = ['-1200', '-1100', '-1000', '-0930', '-0900', '-0800', '-0700', '-0600', '-0500', '-0430', '-0400', '-0330', '-0300', '-0200', '-0100', '+0000',
228
- '+0100', '+0200', '+0300', '+0330', '+0400', '+0430', '+0500', '+0530', '+0545', '+0600', '+0630', '+0700', '+0800', '+0845', '+0900', '+0930',
229
- '+1000', '+1030', '+1100', '+1130', '+1200', '+1245', '+1300', '+1400'];
230
-
231
- if (tp_inst._defaults.timezoneIso8601) {
232
- timezoneList = $.map(timezoneList, function(val) {
233
- return val == '+0000' ? 'Z' : (val.substring(0, 3) + ':' + val.substring(3));
234
- });
231
+ // prep the timezone options
232
+ var timezoneList = [-720, -660, -600, -570, -540, -480, -420, -360, -300, -270, -240, -210, -180, -120, -60,
233
+ 0, 60, 120, 180, 210, 240, 270, 300, 330, 345, 360, 390, 420, 480, 525, 540, 570, 600, 630, 660, 690, 720, 765, 780, 840];
234
+ if (tp_inst._defaults.timezoneList !== null) {
235
+ timezoneList = tp_inst._defaults.timezoneList;
236
+ }
237
+ var tzl = timezoneList.length, tzi = 0, tzv = null;
238
+ if (tzl > 0 && typeof timezoneList[0] !== 'object') {
239
+ for (; tzi < tzl; tzi++) {
240
+ tzv = timezoneList[tzi];
241
+ timezoneList[tzi] = { value: tzv, label: $.timepicker.timezoneOffsetString(tzv, tp_inst.support.iso8601) };
235
242
  }
236
- tp_inst._defaults.timezoneList = timezoneList;
237
243
  }
238
-
239
- tp_inst.timezone = tp_inst._defaults.timezone;
240
- tp_inst.hour = tp_inst._defaults.hour < tp_inst._defaults.hourMin? tp_inst._defaults.hourMin :
241
- tp_inst._defaults.hour > tp_inst._defaults.hourMax? tp_inst._defaults.hourMax : tp_inst._defaults.hour;
242
- tp_inst.minute = tp_inst._defaults.minute < tp_inst._defaults.minuteMin? tp_inst._defaults.minuteMin :
243
- tp_inst._defaults.minute > tp_inst._defaults.minuteMax? tp_inst._defaults.minuteMax : tp_inst._defaults.minute;
244
- tp_inst.second = tp_inst._defaults.second < tp_inst._defaults.secondMin? tp_inst._defaults.secondMin :
245
- tp_inst._defaults.second > tp_inst._defaults.secondMax? tp_inst._defaults.secondMax : tp_inst._defaults.second;
246
- tp_inst.millisec = tp_inst._defaults.millisec < tp_inst._defaults.millisecMin? tp_inst._defaults.millisecMin :
247
- tp_inst._defaults.millisec > tp_inst._defaults.millisecMax? tp_inst._defaults.millisecMax : tp_inst._defaults.millisec;
244
+ tp_inst._defaults.timezoneList = timezoneList;
245
+
246
+ // set the default units
247
+ tp_inst.timezone = tp_inst._defaults.timezone !== null ? $.timepicker.timezoneOffsetNumber(tp_inst._defaults.timezone) :
248
+ ((new Date()).getTimezoneOffset() * -1);
249
+ tp_inst.hour = tp_inst._defaults.hour < tp_inst._defaults.hourMin ? tp_inst._defaults.hourMin :
250
+ tp_inst._defaults.hour > tp_inst._defaults.hourMax ? tp_inst._defaults.hourMax : tp_inst._defaults.hour;
251
+ tp_inst.minute = tp_inst._defaults.minute < tp_inst._defaults.minuteMin ? tp_inst._defaults.minuteMin :
252
+ tp_inst._defaults.minute > tp_inst._defaults.minuteMax ? tp_inst._defaults.minuteMax : tp_inst._defaults.minute;
253
+ tp_inst.second = tp_inst._defaults.second < tp_inst._defaults.secondMin ? tp_inst._defaults.secondMin :
254
+ tp_inst._defaults.second > tp_inst._defaults.secondMax ? tp_inst._defaults.secondMax : tp_inst._defaults.second;
255
+ tp_inst.millisec = tp_inst._defaults.millisec < tp_inst._defaults.millisecMin ? tp_inst._defaults.millisecMin :
256
+ tp_inst._defaults.millisec > tp_inst._defaults.millisecMax ? tp_inst._defaults.millisecMax : tp_inst._defaults.millisec;
257
+ tp_inst.microsec = tp_inst._defaults.microsec < tp_inst._defaults.microsecMin ? tp_inst._defaults.microsecMin :
258
+ tp_inst._defaults.microsec > tp_inst._defaults.microsecMax ? tp_inst._defaults.microsecMax : tp_inst._defaults.microsec;
248
259
  tp_inst.ampm = '';
249
260
  tp_inst.$input = $input;
250
261
 
251
- if (o.altField) {
252
- tp_inst.$altInput = $(o.altField).css({
262
+ if (tp_inst._defaults.altField) {
263
+ tp_inst.$altInput = $(tp_inst._defaults.altField).css({
253
264
  cursor: 'pointer'
254
- }).focus(function() {
265
+ }).focus(function () {
255
266
  $input.trigger("focus");
256
267
  });
257
268
  }
@@ -276,7 +287,7 @@
276
287
  if (tp_inst._defaults.maxDateTime !== undefined && tp_inst._defaults.maxDateTime instanceof Date) {
277
288
  tp_inst._defaults.maxDate = new Date(tp_inst._defaults.maxDateTime.getTime());
278
289
  }
279
- tp_inst.$input.bind('focus', function() {
290
+ tp_inst.$input.bind('focus', function () {
280
291
  tp_inst._onFocus();
281
292
  });
282
293
 
@@ -286,7 +297,7 @@
286
297
  /*
287
298
  * add our sliders to the calendar
288
299
  */
289
- _addTimePicker: function(dp_inst) {
300
+ _addTimePicker: function (dp_inst) {
290
301
  var currDT = (this.$altInput && this._defaults.altFieldTimeOnly) ? this.$input.val() + ' ' + this.$altInput.val() : this.$input.val();
291
302
 
292
303
  this.timeDefined = this._parseTime(currDT);
@@ -297,7 +308,7 @@
297
308
  /*
298
309
  * parse the time string from input value or _setTime
299
310
  */
300
- _parseTime: function(timeString, withDate) {
311
+ _parseTime: function (timeString, withDate) {
301
312
  if (!this.inst) {
302
313
  this.inst = $.datepicker._getInst(this.$input[0]);
303
314
  }
@@ -331,49 +342,54 @@
331
342
  /*
332
343
  * generate and inject html for timepicker into ui datepicker
333
344
  */
334
- _injectTimePicker: function() {
345
+ _injectTimePicker: function () {
335
346
  var $dp = this.inst.dpDiv,
336
347
  o = this.inst.settings,
337
348
  tp_inst = this,
338
349
  litem = '',
339
350
  uitem = '',
351
+ show = null,
340
352
  max = {},
341
353
  gridSize = {},
342
- size = null;
354
+ size = null,
355
+ i = 0,
356
+ l = 0;
343
357
 
344
358
  // Prevent displaying twice
345
359
  if ($dp.find("div.ui-timepicker-div").length === 0 && o.showTimepicker) {
346
360
  var noDisplay = ' style="display:none;"',
347
- html = '<div class="ui-timepicker-div'+ (o.isRTL? ' ui-timepicker-rtl' : '') +'"><dl>' + '<dt class="ui_tpicker_time_label"' + ((o.showTime) ? '' : noDisplay) + '>' + o.timeText + '</dt>' +
361
+ html = '<div class="ui-timepicker-div' + (o.isRTL ? ' ui-timepicker-rtl' : '') + '"><dl>' + '<dt class="ui_tpicker_time_label"' + ((o.showTime) ? '' : noDisplay) + '>' + o.timeText + '</dt>' +
348
362
  '<dd class="ui_tpicker_time"' + ((o.showTime) ? '' : noDisplay) + '></dd>';
349
363
 
350
364
  // Create the markup
351
- for(var i=0,l=this.units.length; i<l; i++){
365
+ for (i = 0, l = this.units.length; i < l; i++) {
352
366
  litem = this.units[i];
353
- uitem = litem.substr(0,1).toUpperCase() + litem.substr(1);
367
+ uitem = litem.substr(0, 1).toUpperCase() + litem.substr(1);
368
+ show = o['show' + uitem] !== null ? o['show' + uitem] : this.support[litem];
369
+
354
370
  // Added by Peter Medeiros:
355
371
  // - Figure out what the hour/minute/second max should be based on the step values.
356
372
  // - Example: if stepMinute is 15, then minMax is 45.
357
- max[litem] = parseInt((o[litem+'Max'] - ((o[litem+'Max'] - o[litem+'Min']) % o['step'+uitem])), 10);
373
+ max[litem] = parseInt((o[litem + 'Max'] - ((o[litem + 'Max'] - o[litem + 'Min']) % o['step' + uitem])), 10);
358
374
  gridSize[litem] = 0;
359
375
 
360
- html += '<dt class="ui_tpicker_'+ litem +'_label"' + ((o['show'+uitem]) ? '' : noDisplay) + '>' + o[litem +'Text'] + '</dt>' +
361
- '<dd class="ui_tpicker_'+ litem +'"><div class="ui_tpicker_'+ litem +'_slider"' + ((o['show'+uitem]) ? '' : noDisplay) + '></div>';
376
+ html += '<dt class="ui_tpicker_' + litem + '_label"' + (show ? '' : noDisplay) + '>' + o[litem + 'Text'] + '</dt>' +
377
+ '<dd class="ui_tpicker_' + litem + '"><div class="ui_tpicker_' + litem + '_slider"' + (show ? '' : noDisplay) + '></div>';
362
378
 
363
- if (o['show'+uitem] && o[litem+'Grid'] > 0) {
379
+ if (show && o[litem + 'Grid'] > 0) {
364
380
  html += '<div style="padding-left: 1px"><table class="ui-tpicker-grid-label"><tr>';
365
381
 
366
- if(litem == 'hour'){
367
- for (var h = o[litem+'Min']; h <= max[litem]; h += parseInt(o[litem+'Grid'], 10)) {
382
+ if (litem === 'hour') {
383
+ for (var h = o[litem + 'Min']; h <= max[litem]; h += parseInt(o[litem + 'Grid'], 10)) {
368
384
  gridSize[litem]++;
369
- var tmph = $.datepicker.formatTime(useAmpm(o.pickerTimeFormat || o.timeFormat)? 'hht':'HH', {hour:h}, o);
370
- html += '<td data-for="'+litem+'">' + tmph + '</td>';
385
+ var tmph = $.datepicker.formatTime(this.support.ampm ? 'hht' : 'HH', {hour: h}, o);
386
+ html += '<td data-for="' + litem + '">' + tmph + '</td>';
371
387
  }
372
388
  }
373
- else{
374
- for (var m = o[litem+'Min']; m <= max[litem]; m += parseInt(o[litem+'Grid'], 10)) {
389
+ else {
390
+ for (var m = o[litem + 'Min']; m <= max[litem]; m += parseInt(o[litem + 'Grid'], 10)) {
375
391
  gridSize[litem]++;
376
- html += '<td data-for="'+litem+'">' + ((m < 10) ? '0' : '') + m + '</td>';
392
+ html += '<td data-for="' + litem + '">' + ((m < 10) ? '0' : '') + m + '</td>';
377
393
  }
378
394
  }
379
395
 
@@ -381,10 +397,11 @@
381
397
  }
382
398
  html += '</dd>';
383
399
  }
384
-
400
+
385
401
  // Timezone
386
- html += '<dt class="ui_tpicker_timezone_label"' + ((o.showTimezone) ? '' : noDisplay) + '>' + o.timezoneText + '</dt>';
387
- html += '<dd class="ui_tpicker_timezone" ' + ((o.showTimezone) ? '' : noDisplay) + '></dd>';
402
+ var showTz = o.showTimezone !== null ? o.showTimezone : this.support.timezone;
403
+ html += '<dt class="ui_tpicker_timezone_label"' + (showTz ? '' : noDisplay) + '>' + o.timezoneText + '</dt>';
404
+ html += '<dd class="ui_tpicker_timezone" ' + (showTz ? '' : noDisplay) + '></dd>';
388
405
 
389
406
  // Create the elements from string
390
407
  html += '</dl></div>';
@@ -395,47 +412,47 @@
395
412
  $tp.prepend('<div class="ui-widget-header ui-helper-clearfix ui-corner-all">' + '<div class="ui-datepicker-title">' + o.timeOnlyTitle + '</div>' + '</div>');
396
413
  $dp.find('.ui-datepicker-header, .ui-datepicker-calendar').hide();
397
414
  }
398
-
415
+
399
416
  // add sliders, adjust grids, add events
400
- for(var i=0,l=tp_inst.units.length; i<l; i++){
417
+ for (i = 0, l = tp_inst.units.length; i < l; i++) {
401
418
  litem = tp_inst.units[i];
402
- uitem = litem.substr(0,1).toUpperCase() + litem.substr(1);
419
+ uitem = litem.substr(0, 1).toUpperCase() + litem.substr(1);
420
+ show = o['show' + uitem] !== null ? o['show' + uitem] : this.support[litem];
403
421
 
404
422
  // add the slider
405
- tp_inst[litem+'_slider'] = tp_inst.control.create(tp_inst, $tp.find('.ui_tpicker_'+litem+'_slider'), litem, tp_inst[litem], o[litem+'Min'], max[litem], o['step'+uitem]);
423
+ tp_inst[litem + '_slider'] = tp_inst.control.create(tp_inst, $tp.find('.ui_tpicker_' + litem + '_slider'), litem, tp_inst[litem], o[litem + 'Min'], max[litem], o['step' + uitem]);
406
424
 
407
425
  // adjust the grid and add click event
408
- if (o['show'+uitem] && o[litem+'Grid'] > 0) {
409
- size = 100 * gridSize[litem] * o[litem+'Grid'] / (max[litem] - o[litem+'Min']);
410
- $tp.find('.ui_tpicker_'+litem+' table').css({
426
+ if (show && o[litem + 'Grid'] > 0) {
427
+ size = 100 * gridSize[litem] * o[litem + 'Grid'] / (max[litem] - o[litem + 'Min']);
428
+ $tp.find('.ui_tpicker_' + litem + ' table').css({
411
429
  width: size + "%",
412
- marginLeft: o.isRTL? '0' : ((size / (-2 * gridSize[litem])) + "%"),
413
- marginRight: o.isRTL? ((size / (-2 * gridSize[litem])) + "%") : '0',
430
+ marginLeft: o.isRTL ? '0' : ((size / (-2 * gridSize[litem])) + "%"),
431
+ marginRight: o.isRTL ? ((size / (-2 * gridSize[litem])) + "%") : '0',
414
432
  borderCollapse: 'collapse'
415
- }).find("td").click(function(e){
433
+ }).find("td").click(function (e) {
416
434
  var $t = $(this),
417
435
  h = $t.html(),
418
- n = parseInt(h.replace(/[^0-9]/g),10),
436
+ n = parseInt(h.replace(/[^0-9]/g), 10),
419
437
  ap = h.replace(/[^apm]/ig),
420
438
  f = $t.data('for'); // loses scope, so we use data-for
421
439
 
422
- if(f == 'hour'){
423
- if(ap.indexOf('p') !== -1 && n < 12){
440
+ if (f === 'hour') {
441
+ if (ap.indexOf('p') !== -1 && n < 12) {
424
442
  n += 12;
425
443
  }
426
- else{
427
- if(ap.indexOf('a') !== -1 && n === 12){
444
+ else {
445
+ if (ap.indexOf('a') !== -1 && n === 12) {
428
446
  n = 0;
429
447
  }
430
448
  }
431
449
  }
432
-
433
- tp_inst.control.value(tp_inst, tp_inst[f+'_slider'], litem, n);
450
+
451
+ tp_inst.control.value(tp_inst, tp_inst[f + '_slider'], litem, n);
434
452
 
435
453
  tp_inst._onTimeChange();
436
454
  tp_inst._onSelectHandler();
437
- })
438
- .css({
455
+ }).css({
439
456
  cursor: 'pointer',
440
457
  width: (100 / gridSize[litem]) + '%',
441
458
  textAlign: 'center',
@@ -447,31 +464,29 @@
447
464
  // Add timezone options
448
465
  this.timezone_select = $tp.find('.ui_tpicker_timezone').append('<select></select>').find("select");
449
466
  $.fn.append.apply(this.timezone_select,
450
- $.map(o.timezoneList, function(val, idx) {
451
- return $("<option />").val(typeof val == "object" ? val.value : val).text(typeof val == "object" ? val.label : val);
467
+ $.map(o.timezoneList, function (val, idx) {
468
+ return $("<option />").val(typeof val === "object" ? val.value : val).text(typeof val === "object" ? val.label : val);
452
469
  }));
453
- if (typeof(this.timezone) != "undefined" && this.timezone !== null && this.timezone !== "") {
454
- var local_date = new Date(this.inst.selectedYear, this.inst.selectedMonth, this.inst.selectedDay, 12);
455
- var local_timezone = $.timepicker.timeZoneOffsetString(local_date);
456
- if (local_timezone == this.timezone) {
457
- selectLocalTimeZone(tp_inst);
470
+ if (typeof(this.timezone) !== "undefined" && this.timezone !== null && this.timezone !== "") {
471
+ var local_timezone = (new Date(this.inst.selectedYear, this.inst.selectedMonth, this.inst.selectedDay, 12)).getTimezoneOffset() * -1;
472
+ if (local_timezone === this.timezone) {
473
+ selectLocalTimezone(tp_inst);
458
474
  } else {
459
475
  this.timezone_select.val(this.timezone);
460
476
  }
461
477
  } else {
462
- if (typeof(this.hour) != "undefined" && this.hour !== null && this.hour !== "") {
463
- this.timezone_select.val(o.defaultTimezone);
478
+ if (typeof(this.hour) !== "undefined" && this.hour !== null && this.hour !== "") {
479
+ this.timezone_select.val(o.timezone);
464
480
  } else {
465
- selectLocalTimeZone(tp_inst);
481
+ selectLocalTimezone(tp_inst);
466
482
  }
467
483
  }
468
- this.timezone_select.change(function() {
469
- tp_inst._defaults.useLocalTimezone = false;
484
+ this.timezone_select.change(function () {
470
485
  tp_inst._onTimeChange();
471
486
  tp_inst._onSelectHandler();
472
487
  });
473
488
  // End timezone options
474
-
489
+
475
490
  // inject timepicker into datepicker
476
491
  var $buttonPanel = $dp.find('.ui-datepicker-buttonpane');
477
492
  if ($buttonPanel.length) {
@@ -493,22 +508,22 @@
493
508
  var sliderAccessArgs = this._defaults.sliderAccessArgs,
494
509
  rtl = this._defaults.isRTL;
495
510
  sliderAccessArgs.isRTL = rtl;
496
-
497
- setTimeout(function() { // fix for inline mode
511
+
512
+ setTimeout(function () { // fix for inline mode
498
513
  if ($tp.find('.ui-slider-access').length === 0) {
499
514
  $tp.find('.ui-slider:visible').sliderAccess(sliderAccessArgs);
500
515
 
501
516
  // fix any grids since sliders are shorter
502
517
  var sliderAccessWidth = $tp.find('.ui-slider-access:eq(0)').outerWidth(true);
503
518
  if (sliderAccessWidth) {
504
- $tp.find('table:visible').each(function() {
519
+ $tp.find('table:visible').each(function () {
505
520
  var $g = $(this),
506
521
  oldWidth = $g.outerWidth(),
507
- oldMarginLeft = $g.css(rtl? 'marginRight':'marginLeft').toString().replace('%', ''),
522
+ oldMarginLeft = $g.css(rtl ? 'marginRight' : 'marginLeft').toString().replace('%', ''),
508
523
  newWidth = oldWidth - sliderAccessWidth,
509
524
  newMarginLeft = ((oldMarginLeft * newWidth) / oldWidth) + '%',
510
525
  css = { width: newWidth, marginRight: 0, marginLeft: 0 };
511
- css[rtl? 'marginRight':'marginLeft'] = newMarginLeft;
526
+ css[rtl ? 'marginRight' : 'marginLeft'] = newMarginLeft;
512
527
  $g.css(css);
513
528
  });
514
529
  }
@@ -517,6 +532,7 @@
517
532
  }
518
533
  // end slideAccess integration
519
534
 
535
+ tp_inst._limitMinMaxDateTime(this.inst, true);
520
536
  }
521
537
  },
522
538
 
@@ -524,7 +540,7 @@
524
540
  * This function tries to limit the ability to go outside the
525
541
  * min/max date range
526
542
  */
527
- _limitMinMaxDateTime: function(dp_inst, adjustSliders) {
543
+ _limitMinMaxDateTime: function (dp_inst, adjustSliders) {
528
544
  var o = this._defaults,
529
545
  dp_date = new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay);
530
546
 
@@ -536,14 +552,15 @@
536
552
  var minDateTime = $.datepicker._get(dp_inst, 'minDateTime'),
537
553
  minDateTimeDate = new Date(minDateTime.getFullYear(), minDateTime.getMonth(), minDateTime.getDate(), 0, 0, 0, 0);
538
554
 
539
- if (this.hourMinOriginal === null || this.minuteMinOriginal === null || this.secondMinOriginal === null || this.millisecMinOriginal === null) {
555
+ if (this.hourMinOriginal === null || this.minuteMinOriginal === null || this.secondMinOriginal === null || this.millisecMinOriginal === null || this.microsecMinOriginal === null) {
540
556
  this.hourMinOriginal = o.hourMin;
541
557
  this.minuteMinOriginal = o.minuteMin;
542
558
  this.secondMinOriginal = o.secondMin;
543
559
  this.millisecMinOriginal = o.millisecMin;
560
+ this.microsecMinOriginal = o.microsecMin;
544
561
  }
545
562
 
546
- if (dp_inst.settings.timeOnly || minDateTimeDate.getTime() == dp_date.getTime()) {
563
+ if (dp_inst.settings.timeOnly || minDateTimeDate.getTime() === dp_date.getTime()) {
547
564
  this._defaults.hourMin = minDateTime.getHours();
548
565
  if (this.hour <= this._defaults.hourMin) {
549
566
  this.hour = this._defaults.hourMin;
@@ -554,26 +571,36 @@
554
571
  if (this.second <= this._defaults.secondMin) {
555
572
  this.second = this._defaults.secondMin;
556
573
  this._defaults.millisecMin = minDateTime.getMilliseconds();
557
- } else {
558
- if (this.millisec < this._defaults.millisecMin) {
574
+ if (this.millisec <= this._defaults.millisecMin) {
559
575
  this.millisec = this._defaults.millisecMin;
576
+ this._defaults.microsecMin = minDateTime.getMicroseconds();
577
+ } else {
578
+ if (this.microsec < this._defaults.microsecMin) {
579
+ this.microsec = this._defaults.microsecMin;
580
+ }
581
+ this._defaults.microsecMin = this.microsecMinOriginal;
560
582
  }
583
+ } else {
561
584
  this._defaults.millisecMin = this.millisecMinOriginal;
585
+ this._defaults.microsecMin = this.microsecMinOriginal;
562
586
  }
563
587
  } else {
564
588
  this._defaults.secondMin = this.secondMinOriginal;
565
589
  this._defaults.millisecMin = this.millisecMinOriginal;
590
+ this._defaults.microsecMin = this.microsecMinOriginal;
566
591
  }
567
592
  } else {
568
593
  this._defaults.minuteMin = this.minuteMinOriginal;
569
594
  this._defaults.secondMin = this.secondMinOriginal;
570
595
  this._defaults.millisecMin = this.millisecMinOriginal;
596
+ this._defaults.microsecMin = this.microsecMinOriginal;
571
597
  }
572
598
  } else {
573
599
  this._defaults.hourMin = this.hourMinOriginal;
574
600
  this._defaults.minuteMin = this.minuteMinOriginal;
575
601
  this._defaults.secondMin = this.secondMinOriginal;
576
602
  this._defaults.millisecMin = this.millisecMinOriginal;
603
+ this._defaults.microsecMin = this.microsecMinOriginal;
577
604
  }
578
605
  }
579
606
 
@@ -581,14 +608,15 @@
581
608
  var maxDateTime = $.datepicker._get(dp_inst, 'maxDateTime'),
582
609
  maxDateTimeDate = new Date(maxDateTime.getFullYear(), maxDateTime.getMonth(), maxDateTime.getDate(), 0, 0, 0, 0);
583
610
 
584
- if (this.hourMaxOriginal === null || this.minuteMaxOriginal === null || this.secondMaxOriginal === null) {
611
+ if (this.hourMaxOriginal === null || this.minuteMaxOriginal === null || this.secondMaxOriginal === null || this.millisecMaxOriginal === null) {
585
612
  this.hourMaxOriginal = o.hourMax;
586
613
  this.minuteMaxOriginal = o.minuteMax;
587
614
  this.secondMaxOriginal = o.secondMax;
588
615
  this.millisecMaxOriginal = o.millisecMax;
616
+ this.microsecMaxOriginal = o.microsecMax;
589
617
  }
590
618
 
591
- if (dp_inst.settings.timeOnly || maxDateTimeDate.getTime() == dp_date.getTime()) {
619
+ if (dp_inst.settings.timeOnly || maxDateTimeDate.getTime() === dp_date.getTime()) {
592
620
  this._defaults.hourMax = maxDateTime.getHours();
593
621
  if (this.hour >= this._defaults.hourMax) {
594
622
  this.hour = this._defaults.hourMax;
@@ -599,26 +627,36 @@
599
627
  if (this.second >= this._defaults.secondMax) {
600
628
  this.second = this._defaults.secondMax;
601
629
  this._defaults.millisecMax = maxDateTime.getMilliseconds();
602
- } else {
603
- if (this.millisec > this._defaults.millisecMax) {
630
+ if (this.millisec >= this._defaults.millisecMax) {
604
631
  this.millisec = this._defaults.millisecMax;
632
+ this._defaults.microsecMax = maxDateTime.getMicroseconds();
633
+ } else {
634
+ if (this.microsec > this._defaults.microsecMax) {
635
+ this.microsec = this._defaults.microsecMax;
636
+ }
637
+ this._defaults.microsecMax = this.microsecMaxOriginal;
605
638
  }
639
+ } else {
606
640
  this._defaults.millisecMax = this.millisecMaxOriginal;
641
+ this._defaults.microsecMax = this.microsecMaxOriginal;
607
642
  }
608
643
  } else {
609
644
  this._defaults.secondMax = this.secondMaxOriginal;
610
645
  this._defaults.millisecMax = this.millisecMaxOriginal;
646
+ this._defaults.microsecMax = this.microsecMaxOriginal;
611
647
  }
612
648
  } else {
613
649
  this._defaults.minuteMax = this.minuteMaxOriginal;
614
650
  this._defaults.secondMax = this.secondMaxOriginal;
615
651
  this._defaults.millisecMax = this.millisecMaxOriginal;
652
+ this._defaults.microsecMax = this.microsecMaxOriginal;
616
653
  }
617
654
  } else {
618
655
  this._defaults.hourMax = this.hourMaxOriginal;
619
656
  this._defaults.minuteMax = this.minuteMaxOriginal;
620
657
  this._defaults.secondMax = this.secondMaxOriginal;
621
658
  this._defaults.millisecMax = this.millisecMaxOriginal;
659
+ this._defaults.microsecMax = this.microsecMaxOriginal;
622
660
  }
623
661
  }
624
662
 
@@ -626,7 +664,8 @@
626
664
  var hourMax = parseInt((this._defaults.hourMax - ((this._defaults.hourMax - this._defaults.hourMin) % this._defaults.stepHour)), 10),
627
665
  minMax = parseInt((this._defaults.minuteMax - ((this._defaults.minuteMax - this._defaults.minuteMin) % this._defaults.stepMinute)), 10),
628
666
  secMax = parseInt((this._defaults.secondMax - ((this._defaults.secondMax - this._defaults.secondMin) % this._defaults.stepSecond)), 10),
629
- millisecMax = parseInt((this._defaults.millisecMax - ((this._defaults.millisecMax - this._defaults.millisecMin) % this._defaults.stepMillisec)), 10);
667
+ millisecMax = parseInt((this._defaults.millisecMax - ((this._defaults.millisecMax - this._defaults.millisecMin) % this._defaults.stepMillisec)), 10),
668
+ microsecMax = parseInt((this._defaults.microsecMax - ((this._defaults.microsecMax - this._defaults.microsecMin) % this._defaults.stepMicrosec)), 10);
630
669
 
631
670
  if (this.hour_slider) {
632
671
  this.control.options(this, this.hour_slider, 'hour', { min: this._defaults.hourMin, max: hourMax });
@@ -644,6 +683,10 @@
644
683
  this.control.options(this, this.millisec_slider, 'millisec', { min: this._defaults.millisecMin, max: millisecMax });
645
684
  this.control.value(this, this.millisec_slider, 'millisec', this.millisec - (this.millisec % this._defaults.stepMillisec));
646
685
  }
686
+ if (this.microsec_slider) {
687
+ this.control.options(this, this.microsec_slider, 'microsec', { min: this._defaults.microsecMin, max: microsecMax });
688
+ this.control.value(this, this.microsec_slider, 'microsec', this.microsec - (this.microsec % this._defaults.stepMicrosec));
689
+ }
647
690
  }
648
691
 
649
692
  },
@@ -652,29 +695,36 @@
652
695
  * when a slider moves, set the internal time...
653
696
  * on time change is also called when the time is updated in the text field
654
697
  */
655
- _onTimeChange: function() {
698
+ _onTimeChange: function () {
699
+ if (!this._defaults.showTimepicker) {
700
+ return;
701
+ }
656
702
  var hour = (this.hour_slider) ? this.control.value(this, this.hour_slider, 'hour') : false,
657
703
  minute = (this.minute_slider) ? this.control.value(this, this.minute_slider, 'minute') : false,
658
704
  second = (this.second_slider) ? this.control.value(this, this.second_slider, 'second') : false,
659
705
  millisec = (this.millisec_slider) ? this.control.value(this, this.millisec_slider, 'millisec') : false,
706
+ microsec = (this.microsec_slider) ? this.control.value(this, this.microsec_slider, 'microsec') : false,
660
707
  timezone = (this.timezone_select) ? this.timezone_select.val() : false,
661
708
  o = this._defaults,
662
709
  pickerTimeFormat = o.pickerTimeFormat || o.timeFormat,
663
710
  pickerTimeSuffix = o.pickerTimeSuffix || o.timeSuffix;
664
711
 
665
- if (typeof(hour) == 'object') {
712
+ if (typeof(hour) === 'object') {
666
713
  hour = false;
667
714
  }
668
- if (typeof(minute) == 'object') {
715
+ if (typeof(minute) === 'object') {
669
716
  minute = false;
670
717
  }
671
- if (typeof(second) == 'object') {
718
+ if (typeof(second) === 'object') {
672
719
  second = false;
673
720
  }
674
- if (typeof(millisec) == 'object') {
721
+ if (typeof(millisec) === 'object') {
675
722
  millisec = false;
676
723
  }
677
- if (typeof(timezone) == 'object') {
724
+ if (typeof(microsec) === 'object') {
725
+ microsec = false;
726
+ }
727
+ if (typeof(timezone) === 'object') {
678
728
  timezone = false;
679
729
  }
680
730
 
@@ -690,14 +740,19 @@
690
740
  if (millisec !== false) {
691
741
  millisec = parseInt(millisec, 10);
692
742
  }
743
+ if (microsec !== false) {
744
+ microsec = parseInt(microsec, 10);
745
+ }
746
+ if (timezone !== false) {
747
+ timezone = parseInt(timezone, 10);
748
+ }
693
749
 
694
750
  var ampm = o[hour < 12 ? 'amNames' : 'pmNames'][0];
695
751
 
696
752
  // If the update was done in the input field, the input field should not be updated.
697
753
  // If the update was done using the sliders, update the input field.
698
- var hasChanged = (hour != this.hour || minute != this.minute || second != this.second || millisec != this.millisec
699
- || (this.ampm.length > 0 && (hour < 12) != ($.inArray(this.ampm.toUpperCase(), this.amNames) !== -1))
700
- || ((this.timezone === null && timezone != this.defaultTimezone) || (this.timezone !== null && timezone != this.timezone)));
754
+ var hasChanged = (hour !== this.hour || minute !== this.minute || second !== this.second || millisec !== this.millisec || microsec !== this.microsec ||
755
+ (this.ampm.length > 0 && (hour < 12) !== ($.inArray(this.ampm.toUpperCase(), this.amNames) !== -1)) || (this.timezone !== null && timezone !== this.timezone));
701
756
 
702
757
  if (hasChanged) {
703
758
 
@@ -713,6 +768,9 @@
713
768
  if (millisec !== false) {
714
769
  this.millisec = millisec;
715
770
  }
771
+ if (microsec !== false) {
772
+ this.microsec = microsec;
773
+ }
716
774
  if (timezone !== false) {
717
775
  this.timezone = timezone;
718
776
  }
@@ -723,17 +781,17 @@
723
781
 
724
782
  this._limitMinMaxDateTime(this.inst, true);
725
783
  }
726
- if (useAmpm(o.timeFormat)) {
784
+ if (this.support.ampm) {
727
785
  this.ampm = ampm;
728
786
  }
729
787
 
730
788
  // Updates the time within the timepicker
731
789
  this.formattedTime = $.datepicker.formatTime(o.timeFormat, this, o);
732
790
  if (this.$timeObj) {
733
- if(pickerTimeFormat === o.timeFormat){
791
+ if (pickerTimeFormat === o.timeFormat) {
734
792
  this.$timeObj.text(this.formattedTime + pickerTimeSuffix);
735
793
  }
736
- else{
794
+ else {
737
795
  this.$timeObj.text($.datepicker.formatTime(pickerTimeFormat, this, o) + pickerTimeSuffix);
738
796
  }
739
797
  }
@@ -748,7 +806,7 @@
748
806
  * call custom onSelect.
749
807
  * bind to sliders slidestop, and grid click.
750
808
  */
751
- _onSelectHandler: function() {
809
+ _onSelectHandler: function () {
752
810
  var onSelect = this._defaults.onSelect || this.inst.settings.onSelect;
753
811
  var inputEl = this.$input ? this.$input[0] : null;
754
812
  if (onSelect && inputEl) {
@@ -759,25 +817,30 @@
759
817
  /*
760
818
  * update our input with the new date time..
761
819
  */
762
- _updateDateTime: function(dp_inst) {
820
+ _updateDateTime: function (dp_inst) {
763
821
  dp_inst = this.inst || dp_inst;
764
- var dt = $.datepicker._daylightSavingAdjust(new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay)),
822
+ var dtTmp = (dp_inst.currentYear > 0?
823
+ new Date(dp_inst.currentYear, dp_inst.currentMonth, dp_inst.currentDay) :
824
+ new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay)),
825
+ dt = $.datepicker._daylightSavingAdjust(dtTmp),
826
+ //dt = $.datepicker._daylightSavingAdjust(new Date(dp_inst.selectedYear, dp_inst.selectedMonth, dp_inst.selectedDay)),
827
+ //dt = $.datepicker._daylightSavingAdjust(new Date(dp_inst.currentYear, dp_inst.currentMonth, dp_inst.currentDay)),
765
828
  dateFmt = $.datepicker._get(dp_inst, 'dateFormat'),
766
829
  formatCfg = $.datepicker._getFormatConfig(dp_inst),
767
830
  timeAvailable = dt !== null && this.timeDefined;
768
831
  this.formattedDate = $.datepicker.formatDate(dateFmt, (dt === null ? new Date() : dt), formatCfg);
769
832
  var formattedDateTime = this.formattedDate;
770
-
833
+
771
834
  // if a slider was changed but datepicker doesn't have a value yet, set it
772
- if(dp_inst.lastVal==""){
773
- dp_inst.currentYear=dp_inst.selectedYear;
774
- dp_inst.currentMonth=dp_inst.selectedMonth;
775
- dp_inst.currentDay=dp_inst.selectedDay;
835
+ if (dp_inst.lastVal === "") {
836
+ dp_inst.currentYear = dp_inst.selectedYear;
837
+ dp_inst.currentMonth = dp_inst.selectedMonth;
838
+ dp_inst.currentDay = dp_inst.selectedDay;
776
839
  }
777
840
 
778
841
  /*
779
842
  * remove following lines to force every changes in date picker to change the input value
780
- * Bug descriptions: when an input field has a default value, and click on the field to pop up the date picker.
843
+ * Bug descriptions: when an input field has a default value, and click on the field to pop up the date picker.
781
844
  * If the user manually empty the value in the input field, the date picker will never change selected value.
782
845
  */
783
846
  //if (dp_inst.lastVal !== undefined && (dp_inst.lastVal.length > 0 && this.$input.val().length === 0)) {
@@ -794,7 +857,7 @@
794
857
 
795
858
  if (!this._defaults.showTimepicker) {
796
859
  this.$input.val(this.formattedDate);
797
- } else if (this.$altInput && this._defaults.altFieldTimeOnly === true) {
860
+ } else if (this.$altInput && this._defaults.timeOnly === false && this._defaults.altFieldTimeOnly === true) {
798
861
  this.$altInput.val(this.formattedTime);
799
862
  this.$input.val(this.formattedDate);
800
863
  } else if (this.$altInput) {
@@ -803,11 +866,25 @@
803
866
  altSeparator = this._defaults.altSeparator ? this._defaults.altSeparator : this._defaults.separator,
804
867
  altTimeSuffix = this._defaults.altTimeSuffix ? this._defaults.altTimeSuffix : this._defaults.timeSuffix;
805
868
 
806
- if (this._defaults.altFormat) altFormattedDateTime = $.datepicker.formatDate(this._defaults.altFormat, (dt === null ? new Date() : dt), formatCfg);
807
- else altFormattedDateTime = this.formattedDate;
808
- if (altFormattedDateTime) altFormattedDateTime += altSeparator;
809
- if (this._defaults.altTimeFormat) altFormattedDateTime += $.datepicker.formatTime(this._defaults.altTimeFormat, this, this._defaults) + altTimeSuffix;
810
- else altFormattedDateTime += this.formattedTime + altTimeSuffix;
869
+ if (!this._defaults.timeOnly) {
870
+ if (this._defaults.altFormat) {
871
+ altFormattedDateTime = $.datepicker.formatDate(this._defaults.altFormat, (dt === null ? new Date() : dt), formatCfg);
872
+ }
873
+ else {
874
+ altFormattedDateTime = this.formattedDate;
875
+ }
876
+
877
+ if (altFormattedDateTime) {
878
+ altFormattedDateTime += altSeparator;
879
+ }
880
+ }
881
+
882
+ if (this._defaults.altTimeFormat) {
883
+ altFormattedDateTime += $.datepicker.formatTime(this._defaults.altTimeFormat, this, this._defaults) + altTimeSuffix;
884
+ }
885
+ else {
886
+ altFormattedDateTime += this.formattedTime + altTimeSuffix;
887
+ }
811
888
  this.$altInput.val(altFormattedDateTime);
812
889
  } else {
813
890
  this.$input.val(formattedDateTime);
@@ -816,13 +893,13 @@
816
893
  this.$input.trigger("change");
817
894
  },
818
895
 
819
- _onFocus: function() {
896
+ _onFocus: function () {
820
897
  if (!this.$input.val() && this._defaults.defaultValue) {
821
898
  this.$input.val(this._defaults.defaultValue);
822
899
  var inst = $.datepicker._getInst(this.$input.get(0)),
823
900
  tp_inst = $.datepicker._get(inst, 'timepicker');
824
901
  if (tp_inst) {
825
- if (tp_inst._defaults.timeOnly && (inst.input.val() != inst.lastVal)) {
902
+ if (tp_inst._defaults.timeOnly && (inst.input.val() !== inst.lastVal)) {
826
903
  try {
827
904
  $.datepicker._updateDatepicker(inst);
828
905
  } catch (err) {
@@ -840,98 +917,106 @@
840
917
  _controls: {
841
918
  // slider methods
842
919
  slider: {
843
- create: function(tp_inst, obj, unit, val, min, max, step){
920
+ create: function (tp_inst, obj, unit, val, min, max, step) {
844
921
  var rtl = tp_inst._defaults.isRTL; // if rtl go -60->0 instead of 0->60
845
922
  return obj.prop('slide', null).slider({
846
923
  orientation: "horizontal",
847
- value: rtl? val*-1 : val,
848
- min: rtl? max*-1 : min,
849
- max: rtl? min*-1 : max,
924
+ value: rtl ? val * -1 : val,
925
+ min: rtl ? max * -1 : min,
926
+ max: rtl ? min * -1 : max,
850
927
  step: step,
851
- slide: function(event, ui) {
852
- tp_inst.control.value(tp_inst, $(this), unit, rtl? ui.value*-1:ui.value);
928
+ slide: function (event, ui) {
929
+ tp_inst.control.value(tp_inst, $(this), unit, rtl ? ui.value * -1 : ui.value);
853
930
  tp_inst._onTimeChange();
854
931
  },
855
- stop: function(event, ui) {
932
+ stop: function (event, ui) {
856
933
  tp_inst._onSelectHandler();
857
934
  }
858
- });
935
+ });
859
936
  },
860
- options: function(tp_inst, obj, unit, opts, val){
861
- if(tp_inst._defaults.isRTL){
862
- if(typeof(opts) == 'string'){
863
- if(opts == 'min' || opts == 'max'){
864
- if(val !== undefined)
865
- return obj.slider(opts, val*-1);
937
+ options: function (tp_inst, obj, unit, opts, val) {
938
+ if (tp_inst._defaults.isRTL) {
939
+ if (typeof(opts) === 'string') {
940
+ if (opts === 'min' || opts === 'max') {
941
+ if (val !== undefined) {
942
+ return obj.slider(opts, val * -1);
943
+ }
866
944
  return Math.abs(obj.slider(opts));
867
945
  }
868
946
  return obj.slider(opts);
869
947
  }
870
- var min = opts.min,
948
+ var min = opts.min,
871
949
  max = opts.max;
872
950
  opts.min = opts.max = null;
873
- if(min !== undefined)
951
+ if (min !== undefined) {
874
952
  opts.max = min * -1;
875
- if(max !== undefined)
953
+ }
954
+ if (max !== undefined) {
876
955
  opts.min = max * -1;
956
+ }
877
957
  return obj.slider(opts);
878
958
  }
879
- if(typeof(opts) == 'string' && val !== undefined)
880
- return obj.slider(opts, val);
959
+ if (typeof(opts) === 'string' && val !== undefined) {
960
+ return obj.slider(opts, val);
961
+ }
881
962
  return obj.slider(opts);
882
963
  },
883
- value: function(tp_inst, obj, unit, val){
884
- if(tp_inst._defaults.isRTL){
885
- if(val !== undefined)
886
- return obj.slider('value', val*-1);
964
+ value: function (tp_inst, obj, unit, val) {
965
+ if (tp_inst._defaults.isRTL) {
966
+ if (val !== undefined) {
967
+ return obj.slider('value', val * -1);
968
+ }
887
969
  return Math.abs(obj.slider('value'));
888
970
  }
889
- if(val !== undefined)
971
+ if (val !== undefined) {
890
972
  return obj.slider('value', val);
973
+ }
891
974
  return obj.slider('value');
892
975
  }
893
976
  },
894
977
  // select methods
895
978
  select: {
896
- create: function(tp_inst, obj, unit, val, min, max, step){
897
- var sel = '<select class="ui-timepicker-select" data-unit="'+ unit +'" data-min="'+ min +'" data-max="'+ max +'" data-step="'+ step +'">',
898
- ul = tp_inst._defaults.timeFormat.indexOf('t') !== -1? 'toLowerCase':'toUpperCase',
899
- m = 0;
900
-
901
- for(var i=min; i<=max; i+=step){
902
- sel += '<option value="'+ i +'"'+ (i==val? ' selected':'') +'>';
903
- if(unit == 'hour' && useAmpm(tp_inst._defaults.pickerTimeFormat || tp_inst._defaults.timeFormat))
904
- sel += $.datepicker.formatTime("hh TT", {hour:i}, tp_inst._defaults);
905
- else if(unit == 'millisec' || i >= 10) sel += i;
906
- else sel += '0'+ i.toString();
979
+ create: function (tp_inst, obj, unit, val, min, max, step) {
980
+ var sel = '<select class="ui-timepicker-select" data-unit="' + unit + '" data-min="' + min + '" data-max="' + max + '" data-step="' + step + '">',
981
+ format = tp_inst._defaults.pickerTimeFormat || tp_inst._defaults.timeFormat;
982
+
983
+ for (var i = min; i <= max; i += step) {
984
+ sel += '<option value="' + i + '"' + (i === val ? ' selected' : '') + '>';
985
+ if (unit === 'hour') {
986
+ sel += $.datepicker.formatTime($.trim(format.replace(/[^ht ]/ig, '')), {hour: i}, tp_inst._defaults);
987
+ }
988
+ else if (unit === 'millisec' || unit === 'microsec' || i >= 10) { sel += i; }
989
+ else {sel += '0' + i.toString(); }
907
990
  sel += '</option>';
908
991
  }
909
992
  sel += '</select>';
910
993
 
911
994
  obj.children('select').remove();
912
995
 
913
- $(sel).appendTo(obj).change(function(e){
996
+ $(sel).appendTo(obj).change(function (e) {
914
997
  tp_inst._onTimeChange();
915
998
  tp_inst._onSelectHandler();
916
999
  });
917
1000
 
918
1001
  return obj;
919
1002
  },
920
- options: function(tp_inst, obj, unit, opts, val){
1003
+ options: function (tp_inst, obj, unit, opts, val) {
921
1004
  var o = {},
922
1005
  $t = obj.children('select');
923
- if(typeof(opts) == 'string'){
924
- if(val === undefined)
1006
+ if (typeof(opts) === 'string') {
1007
+ if (val === undefined) {
925
1008
  return $t.data(opts);
926
- o[opts] = val;
1009
+ }
1010
+ o[opts] = val;
927
1011
  }
928
- else o = opts;
1012
+ else { o = opts; }
929
1013
  return tp_inst.control.create(tp_inst, obj, $t.data('unit'), $t.val(), o.min || $t.data('min'), o.max || $t.data('max'), o.step || $t.data('step'));
930
1014
  },
931
- value: function(tp_inst, obj, unit, val){
1015
+ value: function (tp_inst, obj, unit, val) {
932
1016
  var $t = obj.children('select');
933
- if(val !== undefined)
1017
+ if (val !== undefined) {
934
1018
  return $t.val(val);
1019
+ }
935
1020
  return $t.val();
936
1021
  }
937
1022
  }
@@ -941,19 +1026,19 @@
941
1026
 
942
1027
  $.fn.extend({
943
1028
  /*
944
- * shorthand just to use timepicker..
1029
+ * shorthand just to use timepicker.
945
1030
  */
946
- timepicker: function(o) {
1031
+ timepicker: function (o) {
947
1032
  o = o || {};
948
1033
  var tmp_args = Array.prototype.slice.call(arguments);
949
1034
 
950
- if (typeof o == 'object') {
1035
+ if (typeof o === 'object') {
951
1036
  tmp_args[0] = $.extend(o, {
952
1037
  timeOnly: true
953
1038
  });
954
1039
  }
955
1040
 
956
- return $(this).each(function() {
1041
+ return $(this).each(function () {
957
1042
  $.fn.datetimepicker.apply($(this), tmp_args);
958
1043
  });
959
1044
  },
@@ -961,21 +1046,21 @@
961
1046
  /*
962
1047
  * extend timepicker to datepicker
963
1048
  */
964
- datetimepicker: function(o) {
1049
+ datetimepicker: function (o) {
965
1050
  o = o || {};
966
1051
  var tmp_args = arguments;
967
1052
 
968
- if (typeof(o) == 'string') {
969
- if (o == 'getDate') {
1053
+ if (typeof(o) === 'string') {
1054
+ if (o === 'getDate') {
970
1055
  return $.fn.datepicker.apply($(this[0]), tmp_args);
971
1056
  } else {
972
- return this.each(function() {
1057
+ return this.each(function () {
973
1058
  var $t = $(this);
974
1059
  $t.datepicker.apply($t, tmp_args);
975
1060
  });
976
1061
  }
977
1062
  } else {
978
- return this.each(function() {
1063
+ return this.each(function () {
979
1064
  var $t = $(this);
980
1065
  $t.datepicker($.timepicker._newInst($t, o)._defaults);
981
1066
  });
@@ -986,11 +1071,12 @@
986
1071
  /*
987
1072
  * Public Utility to parse date and time
988
1073
  */
989
- $.datepicker.parseDateTime = function(dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings) {
1074
+ $.datepicker.parseDateTime = function (dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings) {
990
1075
  var parseRes = parseDateTimeInternal(dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings);
991
1076
  if (parseRes.timeObj) {
992
1077
  var t = parseRes.timeObj;
993
1078
  parseRes.date.setHours(t.hour, t.minute, t.second, t.millisec);
1079
+ parseRes.date.setMicroseconds(t.microsec);
994
1080
  }
995
1081
 
996
1082
  return parseRes.date;
@@ -999,14 +1085,15 @@
999
1085
  /*
1000
1086
  * Public utility to parse time
1001
1087
  */
1002
- $.datepicker.parseTime = function(timeFormat, timeString, options) {
1003
- var o = extendRemove(extendRemove({}, $.timepicker._defaults), options || {});
1088
+ $.datepicker.parseTime = function (timeFormat, timeString, options) {
1089
+ var o = extendRemove(extendRemove({}, $.timepicker._defaults), options || {}),
1090
+ iso8601 = (timeFormat.replace(/\'.*?\'/g, '').indexOf('Z') !== -1);
1004
1091
 
1005
1092
  // Strict parse requires the timeString to match the timeFormat exactly
1006
- var strictParse = function(f, s, o){
1093
+ var strictParse = function (f, s, o) {
1007
1094
 
1008
1095
  // pattern for standard and localized AM/PM markers
1009
- var getPatternAmpm = function(amNames, pmNames) {
1096
+ var getPatternAmpm = function (amNames, pmNames) {
1010
1097
  var markers = [];
1011
1098
  if (amNames) {
1012
1099
  $.merge(markers, amNames);
@@ -1014,27 +1101,28 @@
1014
1101
  if (pmNames) {
1015
1102
  $.merge(markers, pmNames);
1016
1103
  }
1017
- markers = $.map(markers, function(val) {
1104
+ markers = $.map(markers, function (val) {
1018
1105
  return val.replace(/[.*+?|()\[\]{}\\]/g, '\\$&');
1019
1106
  });
1020
1107
  return '(' + markers.join('|') + ')?';
1021
1108
  };
1022
1109
 
1023
1110
  // figure out position of time elements.. cause js cant do named captures
1024
- var getFormatPositions = function(timeFormat) {
1025
- var finds = timeFormat.toLowerCase().match(/(h{1,2}|m{1,2}|s{1,2}|l{1}|t{1,2}|z|'.*?')/g),
1111
+ var getFormatPositions = function (timeFormat) {
1112
+ var finds = timeFormat.toLowerCase().match(/(h{1,2}|m{1,2}|s{1,2}|l{1}|c{1}|t{1,2}|z|'.*?')/g),
1026
1113
  orders = {
1027
1114
  h: -1,
1028
1115
  m: -1,
1029
1116
  s: -1,
1030
1117
  l: -1,
1118
+ c: -1,
1031
1119
  t: -1,
1032
1120
  z: -1
1033
1121
  };
1034
1122
 
1035
1123
  if (finds) {
1036
1124
  for (var i = 0; i < finds.length; i++) {
1037
- if (orders[finds[i].toString().charAt(0)] == -1) {
1125
+ if (orders[finds[i].toString().charAt(0)] === -1) {
1038
1126
  orders[finds[i].toString().charAt(0)] = i + 1;
1039
1127
  }
1040
1128
  }
@@ -1043,17 +1131,25 @@
1043
1131
  };
1044
1132
 
1045
1133
  var regstr = '^' + f.toString()
1046
- .replace(/([hH]{1,2}|mm?|ss?|[tT]{1,2}|[lz]|'.*?')/g, function (match) {
1134
+ .replace(/([hH]{1,2}|mm?|ss?|[tT]{1,2}|[zZ]|[lc]|'.*?')/g, function (match) {
1047
1135
  var ml = match.length;
1048
1136
  switch (match.charAt(0).toLowerCase()) {
1049
- case 'h': return ml === 1? '(\\d?\\d)':'(\\d{'+ml+'})';
1050
- case 'm': return ml === 1? '(\\d?\\d)':'(\\d{'+ml+'})';
1051
- case 's': return ml === 1? '(\\d?\\d)':'(\\d{'+ml+'})';
1052
- case 'l': return '(\\d?\\d?\\d)';
1053
- case 'z': return '(z|[-+]\\d\\d:?\\d\\d|\\S+)?';
1054
- case 't': return getPatternAmpm(o.amNames, o.pmNames);
1055
- default: // literal escaped in quotes
1056
- return '(' + match.replace(/\'/g, "").replace(/(\.|\$|\^|\\|\/|\(|\)|\[|\]|\?|\+|\*)/g, function (m) { return "\\" + m; }) + ')?';
1137
+ case 'h':
1138
+ return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
1139
+ case 'm':
1140
+ return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
1141
+ case 's':
1142
+ return ml === 1 ? '(\\d?\\d)' : '(\\d{' + ml + '})';
1143
+ case 'l':
1144
+ return '(\\d?\\d?\\d)';
1145
+ case 'c':
1146
+ return '(\\d?\\d?\\d)';
1147
+ case 'z':
1148
+ return '(z|[-+]\\d\\d:?\\d\\d|\\S+)?';
1149
+ case 't':
1150
+ return getPatternAmpm(o.amNames, o.pmNames);
1151
+ default: // literal escaped in quotes
1152
+ return '(' + match.replace(/\'/g, "").replace(/(\.|\$|\^|\\|\/|\(|\)|\[|\]|\?|\+|\*)/g, function (m) { return "\\" + m; }) + ')?';
1057
1153
  }
1058
1154
  })
1059
1155
  .replace(/\s/g, '\\s?') +
@@ -1068,7 +1164,8 @@
1068
1164
  hour: 0,
1069
1165
  minute: 0,
1070
1166
  second: 0,
1071
- millisec: 0
1167
+ millisec: 0,
1168
+ microsec: 0
1072
1169
  };
1073
1170
 
1074
1171
  if (treg) {
@@ -1078,15 +1175,15 @@
1078
1175
  resTime.ampm = '';
1079
1176
  } else {
1080
1177
  ampm = $.inArray(treg[order.t].toUpperCase(), o.amNames) !== -1 ? 'AM' : 'PM';
1081
- resTime.ampm = o[ampm == 'AM' ? 'amNames' : 'pmNames'][0];
1178
+ resTime.ampm = o[ampm === 'AM' ? 'amNames' : 'pmNames'][0];
1082
1179
  }
1083
1180
  }
1084
1181
 
1085
1182
  if (order.h !== -1) {
1086
- if (ampm == 'AM' && treg[order.h] == '12') {
1183
+ if (ampm === 'AM' && treg[order.h] === '12') {
1087
1184
  resTime.hour = 0; // 12am = 0 hour
1088
1185
  } else {
1089
- if (ampm == 'PM' && treg[order.h] != '12') {
1186
+ if (ampm === 'PM' && treg[order.h] !== '12') {
1090
1187
  resTime.hour = parseInt(treg[order.h], 10) + 12; // 12pm = 12 hour, any other pm = hour + 12
1091
1188
  } else {
1092
1189
  resTime.hour = Number(treg[order.h]);
@@ -1103,31 +1200,11 @@
1103
1200
  if (order.l !== -1) {
1104
1201
  resTime.millisec = Number(treg[order.l]);
1105
1202
  }
1203
+ if (order.c !== -1) {
1204
+ resTime.microsec = Number(treg[order.c]);
1205
+ }
1106
1206
  if (order.z !== -1 && treg[order.z] !== undefined) {
1107
- var tz = treg[order.z].toUpperCase();
1108
- switch (tz.length) {
1109
- case 1:
1110
- // Z
1111
- tz = o.timezoneIso8601 ? 'Z' : '+0000';
1112
- break;
1113
- case 5:
1114
- // +hhmm
1115
- if (o.timezoneIso8601) {
1116
- tz = tz.substring(1) == '0000' ? 'Z' : tz.substring(0, 3) + ':' + tz.substring(3);
1117
- }
1118
- break;
1119
- case 6:
1120
- // +hh:mm
1121
- if (!o.timezoneIso8601) {
1122
- tz = tz == 'Z' || tz.substring(1) == '00:00' ? '+0000' : tz.replace(/:/, '');
1123
- } else {
1124
- if (tz.substring(1) == '00:00') {
1125
- tz = 'Z';
1126
- }
1127
- }
1128
- break;
1129
- }
1130
- resTime.timezone = tz;
1207
+ resTime.timezone = $.timepicker.timezoneOffsetNumber(treg[order.z]);
1131
1208
  }
1132
1209
 
1133
1210
 
@@ -1137,15 +1214,15 @@
1137
1214
  };// end strictParse
1138
1215
 
1139
1216
  // First try JS Date, if that fails, use strictParse
1140
- var looseParse = function(f,s,o){
1141
- try{
1142
- var d = new Date('2012-01-01 '+ s);
1143
- if(isNaN(d.getTime())){
1144
- d = new Date('2012-01-01T'+ s);
1145
- if(isNaN(d.getTime())){
1146
- d = new Date('01/01/2012 '+ s);
1147
- if(isNaN(d.getTime())){
1148
- throw "Unable to parse time with native Date: "+ s;
1217
+ var looseParse = function (f, s, o) {
1218
+ try {
1219
+ var d = new Date('2012-01-01 ' + s);
1220
+ if (isNaN(d.getTime())) {
1221
+ d = new Date('2012-01-01T' + s);
1222
+ if (isNaN(d.getTime())) {
1223
+ d = new Date('01/01/2012 ' + s);
1224
+ if (isNaN(d.getTime())) {
1225
+ throw "Unable to parse time with native Date: " + s;
1149
1226
  }
1150
1227
  }
1151
1228
  }
@@ -1155,36 +1232,38 @@
1155
1232
  minute: d.getMinutes(),
1156
1233
  second: d.getSeconds(),
1157
1234
  millisec: d.getMilliseconds(),
1158
- timezone: $.timepicker.timeZoneOffsetString(d)
1235
+ microsec: d.getMicroseconds(),
1236
+ timezone: d.getTimezoneOffset() * -1
1159
1237
  };
1160
1238
  }
1161
- catch(err){
1162
- try{
1163
- return strictParse(f,s,o);
1239
+ catch (err) {
1240
+ try {
1241
+ return strictParse(f, s, o);
1242
+ }
1243
+ catch (err2) {
1244
+ $.timepicker.log("Unable to parse \ntimeString: " + s + "\ntimeFormat: " + f);
1164
1245
  }
1165
- catch(err2){
1166
- $.timepicker.log("Unable to parse \ntimeString: "+ s +"\ntimeFormat: "+ f);
1167
- }
1168
1246
  }
1169
1247
  return false;
1170
1248
  }; // end looseParse
1171
-
1172
- if(typeof o.parse === "function"){
1173
- return o.parse(timeFormat, timeString, o)
1249
+
1250
+ if (typeof o.parse === "function") {
1251
+ return o.parse(timeFormat, timeString, o);
1174
1252
  }
1175
- if(o.parse === 'loose'){
1253
+ if (o.parse === 'loose') {
1176
1254
  return looseParse(timeFormat, timeString, o);
1177
1255
  }
1178
1256
  return strictParse(timeFormat, timeString, o);
1179
1257
  };
1180
1258
 
1181
- /*
1182
- * Public utility to format the time
1183
- * format = string format of the time
1184
- * time = a {}, not a Date() for timezones
1185
- * options = essentially the regional[].. amNames, pmNames, ampm
1186
- */
1187
- $.datepicker.formatTime = function(format, time, options) {
1259
+ /**
1260
+ * Public utility to format the time
1261
+ * @param {string} format format of the time
1262
+ * @param {Object} time Object not a Date for timezones
1263
+ * @param {Object} [options] essentially the regional[].. amNames, pmNames, ampm
1264
+ * @returns {string} the formatted time
1265
+ */
1266
+ $.datepicker.formatTime = function (format, time, options) {
1188
1267
  options = options || {};
1189
1268
  options = $.extend({}, $.timepicker._defaults, options);
1190
1269
  time = $.extend({
@@ -1192,7 +1271,8 @@
1192
1271
  minute: 0,
1193
1272
  second: 0,
1194
1273
  millisec: 0,
1195
- timezone: '+0000'
1274
+ microsec: 0,
1275
+ timezone: null
1196
1276
  }, time);
1197
1277
 
1198
1278
  var tmptime = format,
@@ -1203,8 +1283,8 @@
1203
1283
  ampmName = options.pmNames[0];
1204
1284
  }
1205
1285
 
1206
- tmptime = tmptime.replace(/(?:HH?|hh?|mm?|ss?|[tT]{1,2}|[lz]|('.*?'|".*?"))/g, function(match) {
1207
- switch (match) {
1286
+ tmptime = tmptime.replace(/(?:HH?|hh?|mm?|ss?|[tT]{1,2}|[zZ]|[lc]|'.*?')/g, function (match) {
1287
+ switch (match) {
1208
1288
  case 'HH':
1209
1289
  return ('0' + hour).slice(-2);
1210
1290
  case 'H':
@@ -1223,31 +1303,34 @@
1223
1303
  return time.second;
1224
1304
  case 'l':
1225
1305
  return ('00' + time.millisec).slice(-3);
1306
+ case 'c':
1307
+ return ('00' + time.microsec).slice(-3);
1226
1308
  case 'z':
1227
- return time.timezone === null? options.defaultTimezone : time.timezone;
1228
- case 'T':
1309
+ return $.timepicker.timezoneOffsetString(time.timezone === null ? options.timezone : time.timezone, false);
1310
+ case 'Z':
1311
+ return $.timepicker.timezoneOffsetString(time.timezone === null ? options.timezone : time.timezone, true);
1312
+ case 'T':
1229
1313
  return ampmName.charAt(0).toUpperCase();
1230
- case 'TT':
1314
+ case 'TT':
1231
1315
  return ampmName.toUpperCase();
1232
1316
  case 't':
1233
1317
  return ampmName.charAt(0).toLowerCase();
1234
1318
  case 'tt':
1235
1319
  return ampmName.toLowerCase();
1236
1320
  default:
1237
- return match.replace(/\'/g, "") || "'";
1321
+ return match.replace(/'/g, "");
1238
1322
  }
1239
1323
  });
1240
1324
 
1241
- tmptime = $.trim(tmptime);
1242
1325
  return tmptime;
1243
1326
  };
1244
1327
 
1245
1328
  /*
1246
- * the bad hack :/ override datepicker so it doesnt close on select
1329
+ * the bad hack :/ override datepicker so it doesn't close on select
1247
1330
  // inspired: http://stackoverflow.com/questions/1252512/jquery-datepicker-prevent-closing-picker-when-clicking-a-date/1762378#1762378
1248
1331
  */
1249
1332
  $.datepicker._base_selectDate = $.datepicker._selectDate;
1250
- $.datepicker._selectDate = function(id, dateStr) {
1333
+ $.datepicker._selectDate = function (id, dateStr) {
1251
1334
  var inst = this._getInst($(id)[0]),
1252
1335
  tp_inst = this._get(inst, 'timepicker');
1253
1336
 
@@ -1269,11 +1352,11 @@
1269
1352
  * and does not redraw the datepicker on every selectDate event
1270
1353
  */
1271
1354
  $.datepicker._base_updateDatepicker = $.datepicker._updateDatepicker;
1272
- $.datepicker._updateDatepicker = function(inst) {
1355
+ $.datepicker._updateDatepicker = function (inst) {
1273
1356
 
1274
1357
  // don't popup the datepicker if there is another instance already opened
1275
1358
  var input = inst.input[0];
1276
- if ($.datepicker._curInst && $.datepicker._curInst != inst && $.datepicker._datepickerShowing && $.datepicker._lastInput != input) {
1359
+ if ($.datepicker._curInst && $.datepicker._curInst !== inst && $.datepicker._datepickerShowing && $.datepicker._lastInput !== input) {
1277
1360
  return;
1278
1361
  }
1279
1362
 
@@ -1285,12 +1368,6 @@
1285
1368
  var tp_inst = this._get(inst, 'timepicker');
1286
1369
  if (tp_inst) {
1287
1370
  tp_inst._addTimePicker(inst);
1288
-
1289
- // if (tp_inst._defaults.useLocalTimezone) { //checks daylight saving with the new date.
1290
- // var date = new Date(inst.selectedYear, inst.selectedMonth, inst.selectedDay, 12);
1291
- // selectLocalTimeZone(tp_inst, date);
1292
- // tp_inst._onTimeChange();
1293
- // }
1294
1371
  }
1295
1372
  }
1296
1373
  };
@@ -1299,13 +1376,14 @@
1299
1376
  * third bad hack :/ override datepicker so it allows spaces and colon in the input field
1300
1377
  */
1301
1378
  $.datepicker._base_doKeyPress = $.datepicker._doKeyPress;
1302
- $.datepicker._doKeyPress = function(event) {
1379
+ $.datepicker._doKeyPress = function (event) {
1303
1380
  var inst = $.datepicker._getInst(event.target),
1304
1381
  tp_inst = $.datepicker._get(inst, 'timepicker');
1305
1382
 
1306
1383
  if (tp_inst) {
1307
1384
  if ($.datepicker._get(inst, 'constrainInput')) {
1308
- var ampm = useAmpm(tp_inst._defaults.timeFormat),
1385
+ var ampm = tp_inst.support.ampm,
1386
+ tz = tp_inst._defaults.showTimezone !== null ? tp_inst._defaults.showTimezone : tp_inst.support.timezone,
1309
1387
  dateChars = $.datepicker._possibleChars($.datepicker._get(inst, 'dateFormat')),
1310
1388
  datetimeChars = tp_inst._defaults.timeFormat.toString()
1311
1389
  .replace(/[hms]/g, '')
@@ -1314,11 +1392,11 @@
1314
1392
  .replace(/tT/g, ampm ? 'AaPpMm' : '')
1315
1393
  .replace(/T/g, ampm ? 'AP' : '')
1316
1394
  .replace(/tt/g, ampm ? 'apm' : '')
1317
- .replace(/t/g, ampm ? 'ap' : '') +
1318
- " " + tp_inst._defaults.separator +
1319
- tp_inst._defaults.timeSuffix +
1320
- (tp_inst._defaults.showTimezone ? tp_inst._defaults.timezoneList.join('') : '') +
1321
- (tp_inst._defaults.amNames.join('')) + (tp_inst._defaults.pmNames.join('')) +
1395
+ .replace(/t/g, ampm ? 'ap' : '') +
1396
+ " " + tp_inst._defaults.separator +
1397
+ tp_inst._defaults.timeSuffix +
1398
+ (tz ? tp_inst._defaults.timezoneList.join('') : '') +
1399
+ (tp_inst._defaults.amNames.join('')) + (tp_inst._defaults.pmNames.join('')) +
1322
1400
  dateChars,
1323
1401
  chr = String.fromCharCode(event.charCode === undefined ? event.keyCode : event.charCode);
1324
1402
  return event.ctrlKey || (chr < ' ' || !dateChars || datetimeChars.indexOf(chr) > -1);
@@ -1330,32 +1408,35 @@
1330
1408
 
1331
1409
  /*
1332
1410
  * Fourth bad hack :/ override _updateAlternate function used in inline mode to init altField
1411
+ * Update any alternate field to synchronise with the main field.
1333
1412
  */
1334
1413
  $.datepicker._base_updateAlternate = $.datepicker._updateAlternate;
1335
- /* Update any alternate field to synchronise with the main field. */
1336
- $.datepicker._updateAlternate = function(inst) {
1414
+ $.datepicker._updateAlternate = function (inst) {
1337
1415
  var tp_inst = this._get(inst, 'timepicker');
1338
- if(tp_inst){
1416
+ if (tp_inst) {
1339
1417
  var altField = tp_inst._defaults.altField;
1340
1418
  if (altField) { // update alternate field too
1341
1419
  var altFormat = tp_inst._defaults.altFormat || tp_inst._defaults.dateFormat,
1342
1420
  date = this._getDate(inst),
1343
1421
  formatCfg = $.datepicker._getFormatConfig(inst),
1344
- altFormattedDateTime = '',
1345
- altSeparator = tp_inst._defaults.altSeparator ? tp_inst._defaults.altSeparator : tp_inst._defaults.separator,
1422
+ altFormattedDateTime = '',
1423
+ altSeparator = tp_inst._defaults.altSeparator ? tp_inst._defaults.altSeparator : tp_inst._defaults.separator,
1346
1424
  altTimeSuffix = tp_inst._defaults.altTimeSuffix ? tp_inst._defaults.altTimeSuffix : tp_inst._defaults.timeSuffix,
1347
1425
  altTimeFormat = tp_inst._defaults.altTimeFormat !== null ? tp_inst._defaults.altTimeFormat : tp_inst._defaults.timeFormat;
1348
-
1426
+
1349
1427
  altFormattedDateTime += $.datepicker.formatTime(altTimeFormat, tp_inst, tp_inst._defaults) + altTimeSuffix;
1350
- if(!tp_inst._defaults.timeOnly && !tp_inst._defaults.altFieldTimeOnly && date !== null){
1351
- if(tp_inst._defaults.altFormat)
1428
+ if (!tp_inst._defaults.timeOnly && !tp_inst._defaults.altFieldTimeOnly && date !== null) {
1429
+ if (tp_inst._defaults.altFormat) {
1352
1430
  altFormattedDateTime = $.datepicker.formatDate(tp_inst._defaults.altFormat, date, formatCfg) + altSeparator + altFormattedDateTime;
1353
- else altFormattedDateTime = tp_inst.formattedDate + altSeparator + altFormattedDateTime;
1431
+ }
1432
+ else {
1433
+ altFormattedDateTime = tp_inst.formattedDate + altSeparator + altFormattedDateTime;
1434
+ }
1354
1435
  }
1355
1436
  $(altField).val(altFormattedDateTime);
1356
1437
  }
1357
1438
  }
1358
- else{
1439
+ else {
1359
1440
  $.datepicker._base_updateAlternate(inst);
1360
1441
  }
1361
1442
  };
@@ -1364,12 +1445,12 @@
1364
1445
  * Override key up event to sync manual input changes.
1365
1446
  */
1366
1447
  $.datepicker._base_doKeyUp = $.datepicker._doKeyUp;
1367
- $.datepicker._doKeyUp = function(event) {
1448
+ $.datepicker._doKeyUp = function (event) {
1368
1449
  var inst = $.datepicker._getInst(event.target),
1369
1450
  tp_inst = $.datepicker._get(inst, 'timepicker');
1370
1451
 
1371
1452
  if (tp_inst) {
1372
- if (tp_inst._defaults.timeOnly && (inst.input.val() != inst.lastVal)) {
1453
+ if (tp_inst._defaults.timeOnly && (inst.input.val() !== inst.lastVal)) {
1373
1454
  try {
1374
1455
  $.datepicker._updateDatepicker(inst);
1375
1456
  } catch (err) {
@@ -1385,12 +1466,12 @@
1385
1466
  * override "Today" button to also grab the time.
1386
1467
  */
1387
1468
  $.datepicker._base_gotoToday = $.datepicker._gotoToday;
1388
- $.datepicker._gotoToday = function(id) {
1469
+ $.datepicker._gotoToday = function (id) {
1389
1470
  var inst = this._getInst($(id)[0]),
1390
1471
  $dp = inst.dpDiv;
1391
1472
  this._base_gotoToday(id);
1392
1473
  var tp_inst = this._get(inst, 'timepicker');
1393
- selectLocalTimeZone(tp_inst);
1474
+ selectLocalTimezone(tp_inst);
1394
1475
  var now = new Date();
1395
1476
  this._setTime(inst, now);
1396
1477
  $('.ui-datepicker-today', $dp).click();
@@ -1399,7 +1480,7 @@
1399
1480
  /*
1400
1481
  * Disable & enable the Time in the datetimepicker
1401
1482
  */
1402
- $.datepicker._disableTimepickerDatepicker = function(target) {
1483
+ $.datepicker._disableTimepickerDatepicker = function (target) {
1403
1484
  var inst = this._getInst(target);
1404
1485
  if (!inst) {
1405
1486
  return;
@@ -1408,12 +1489,13 @@
1408
1489
  var tp_inst = this._get(inst, 'timepicker');
1409
1490
  $(target).datepicker('getDate'); // Init selected[Year|Month|Day]
1410
1491
  if (tp_inst) {
1492
+ inst.settings.showTimepicker = false;
1411
1493
  tp_inst._defaults.showTimepicker = false;
1412
1494
  tp_inst._updateDateTime(inst);
1413
1495
  }
1414
1496
  };
1415
1497
 
1416
- $.datepicker._enableTimepickerDatepicker = function(target) {
1498
+ $.datepicker._enableTimepickerDatepicker = function (target) {
1417
1499
  var inst = this._getInst(target);
1418
1500
  if (!inst) {
1419
1501
  return;
@@ -1422,6 +1504,7 @@
1422
1504
  var tp_inst = this._get(inst, 'timepicker');
1423
1505
  $(target).datepicker('getDate'); // Init selected[Year|Month|Day]
1424
1506
  if (tp_inst) {
1507
+ inst.settings.showTimepicker = true;
1425
1508
  tp_inst._defaults.showTimepicker = true;
1426
1509
  tp_inst._addTimePicker(inst); // Could be disabled on page load
1427
1510
  tp_inst._updateDateTime(inst);
@@ -1431,7 +1514,7 @@
1431
1514
  /*
1432
1515
  * Create our own set time function
1433
1516
  */
1434
- $.datepicker._setTime = function(inst, date) {
1517
+ $.datepicker._setTime = function (inst, date) {
1435
1518
  var tp_inst = this._get(inst, 'timepicker');
1436
1519
  if (tp_inst) {
1437
1520
  var defaults = tp_inst._defaults;
@@ -1441,8 +1524,9 @@
1441
1524
  tp_inst.minute = date ? date.getMinutes() : defaults.minute;
1442
1525
  tp_inst.second = date ? date.getSeconds() : defaults.second;
1443
1526
  tp_inst.millisec = date ? date.getMilliseconds() : defaults.millisec;
1527
+ tp_inst.microsec = date ? date.getMicroseconds() : defaults.microsec;
1444
1528
 
1445
- //check if within min/max times..
1529
+ //check if within min/max times..
1446
1530
  tp_inst._limitMinMaxDateTime(inst, true);
1447
1531
 
1448
1532
  tp_inst._onTimeChange();
@@ -1453,7 +1537,7 @@
1453
1537
  /*
1454
1538
  * Create new public method to set only time, callable as $().datepicker('setTime', date)
1455
1539
  */
1456
- $.datepicker._setTimeDatepicker = function(target, date, withDate) {
1540
+ $.datepicker._setTimeDatepicker = function (target, date, withDate) {
1457
1541
  var inst = this._getInst(target);
1458
1542
  if (!inst) {
1459
1543
  return;
@@ -1465,14 +1549,16 @@
1465
1549
  this._setDateFromField(inst);
1466
1550
  var tp_date;
1467
1551
  if (date) {
1468
- if (typeof date == "string") {
1552
+ if (typeof date === "string") {
1469
1553
  tp_inst._parseTime(date, withDate);
1470
1554
  tp_date = new Date();
1471
1555
  tp_date.setHours(tp_inst.hour, tp_inst.minute, tp_inst.second, tp_inst.millisec);
1556
+ tp_date.setMicroseconds(tp_inst.microsec);
1472
1557
  } else {
1473
1558
  tp_date = new Date(date.getTime());
1559
+ tp_date.setMicroseconds(date.getMicroseconds());
1474
1560
  }
1475
- if (tp_date.toString() == 'Invalid Date') {
1561
+ if (tp_date.toString() === 'Invalid Date') {
1476
1562
  tp_date = undefined;
1477
1563
  }
1478
1564
  this._setTime(inst, tp_date);
@@ -1485,13 +1571,40 @@
1485
1571
  * override setDate() to allow setting time too within Date object
1486
1572
  */
1487
1573
  $.datepicker._base_setDateDatepicker = $.datepicker._setDateDatepicker;
1488
- $.datepicker._setDateDatepicker = function(target, date) {
1574
+ $.datepicker._setDateDatepicker = function (target, date) {
1489
1575
  var inst = this._getInst(target);
1490
1576
  if (!inst) {
1491
1577
  return;
1492
1578
  }
1493
1579
 
1494
- var tp_date = (date instanceof Date) ? new Date(date.getTime()) : date;
1580
+ if (typeof(date) === 'string') {
1581
+ date = new Date(date);
1582
+ if (!date.getTime()) {
1583
+ $.timepicker.log("Error creating Date object from string.");
1584
+ }
1585
+ }
1586
+
1587
+ var tp_inst = this._get(inst, 'timepicker');
1588
+ var tp_date;
1589
+ if (date instanceof Date) {
1590
+ tp_date = new Date(date.getTime());
1591
+ tp_date.setMicroseconds(date.getMicroseconds());
1592
+ } else {
1593
+ tp_date = date;
1594
+ }
1595
+
1596
+ // This is important if you are using the timezone option, javascript's Date
1597
+ // object will only return the timezone offset for the current locale, so we
1598
+ // adjust it accordingly. If not using timezone option this won't matter..
1599
+ // If a timezone is different in tp, keep the timezone as is
1600
+ if (tp_inst) {
1601
+ // look out for DST if tz wasn't specified
1602
+ if (!tp_inst.support.timezone && tp_inst._defaults.timezone === null) {
1603
+ tp_inst.timezone = tp_date.getTimezoneOffset() * -1;
1604
+ }
1605
+ date = $.timepicker.timezoneAdjust(date, tp_inst.timezone);
1606
+ tp_date = $.timepicker.timezoneAdjust(tp_date, tp_inst.timezone);
1607
+ }
1495
1608
 
1496
1609
  this._updateDatepicker(inst);
1497
1610
  this._base_setDateDatepicker.apply(this, arguments);
@@ -1502,7 +1615,7 @@
1502
1615
  * override getDate() to allow getting time too within Date object
1503
1616
  */
1504
1617
  $.datepicker._base_getDateDatepicker = $.datepicker._getDateDatepicker;
1505
- $.datepicker._getDateDatepicker = function(target, noDefault) {
1618
+ $.datepicker._getDateDatepicker = function (target, noDefault) {
1506
1619
  var inst = this._getInst(target);
1507
1620
  if (!inst) {
1508
1621
  return;
@@ -1512,13 +1625,25 @@
1512
1625
 
1513
1626
  if (tp_inst) {
1514
1627
  // if it hasn't yet been defined, grab from field
1515
- if(inst.lastVal === undefined){
1628
+ if (inst.lastVal === undefined) {
1516
1629
  this._setDateFromField(inst, noDefault);
1517
1630
  }
1518
1631
 
1519
1632
  var date = this._getDate(inst);
1520
1633
  if (date && tp_inst._parseTime($(target).val(), tp_inst.timeOnly)) {
1521
1634
  date.setHours(tp_inst.hour, tp_inst.minute, tp_inst.second, tp_inst.millisec);
1635
+ date.setMicroseconds(tp_inst.microsec);
1636
+
1637
+ // This is important if you are using the timezone option, javascript's Date
1638
+ // object will only return the timezone offset for the current locale, so we
1639
+ // adjust it accordingly. If not using timezone option this won't matter..
1640
+ if (tp_inst.timezone != null) {
1641
+ // look out for DST if tz wasn't specified
1642
+ if (!tp_inst.support.timezone && tp_inst._defaults.timezone === null) {
1643
+ tp_inst.timezone = date.getTimezoneOffset() * -1;
1644
+ }
1645
+ date = $.timepicker.timezoneAdjust(date, tp_inst.timezone);
1646
+ }
1522
1647
  }
1523
1648
  return date;
1524
1649
  }
@@ -1530,7 +1655,7 @@
1530
1655
  * An option in datapicker to ignore extra format characters would be nicer.
1531
1656
  */
1532
1657
  $.datepicker._base_parseDate = $.datepicker.parseDate;
1533
- $.datepicker.parseDate = function(format, value, settings) {
1658
+ $.datepicker.parseDate = function (format, value, settings) {
1534
1659
  var date;
1535
1660
  try {
1536
1661
  date = this._base_parseDate(format, value, settings);
@@ -1538,8 +1663,12 @@
1538
1663
  // Hack! The error message ends with a colon, a space, and
1539
1664
  // the "extra" characters. We rely on that instead of
1540
1665
  // attempting to perfectly reproduce the parsing algorithm.
1541
- date = this._base_parseDate(format, value.substring(0,value.length-(err.length-err.indexOf(':')-2)), settings);
1542
- $.timepicker.log("Error parsing the date string: " + err + "\ndate string = " + value + "\ndate format = " + format);
1666
+ if (err.indexOf(":") >= 0) {
1667
+ date = this._base_parseDate(format, value.substring(0, value.length - (err.length - err.indexOf(':') - 2)), settings);
1668
+ $.timepicker.log("Error parsing the date string: " + err + "\ndate string = " + value + "\ndate format = " + format);
1669
+ } else {
1670
+ throw err;
1671
+ }
1543
1672
  }
1544
1673
  return date;
1545
1674
  };
@@ -1548,7 +1677,7 @@
1548
1677
  * override formatDate to set date with time to the input
1549
1678
  */
1550
1679
  $.datepicker._base_formatDate = $.datepicker._formatDate;
1551
- $.datepicker._formatDate = function(inst, day, month, year) {
1680
+ $.datepicker._formatDate = function (inst, day, month, year) {
1552
1681
  var tp_inst = this._get(inst, 'timepicker');
1553
1682
  if (tp_inst) {
1554
1683
  tp_inst._updateDateTime(inst);
@@ -1561,9 +1690,9 @@
1561
1690
  * override options setter to add time to maxDate(Time) and minDate(Time). MaxDate
1562
1691
  */
1563
1692
  $.datepicker._base_optionDatepicker = $.datepicker._optionDatepicker;
1564
- $.datepicker._optionDatepicker = function(target, name, value) {
1693
+ $.datepicker._optionDatepicker = function (target, name, value) {
1565
1694
  var inst = this._getInst(target),
1566
- name_clone;
1695
+ name_clone;
1567
1696
  if (!inst) {
1568
1697
  return null;
1569
1698
  }
@@ -1576,77 +1705,78 @@
1576
1705
  overrides = tp_inst._defaults.evnts,
1577
1706
  fns = {},
1578
1707
  prop;
1579
- if (typeof name == 'string') { // if min/max was set with the string
1580
- if (name === 'minDate' || name === 'minDateTime') {
1581
- min = value;
1582
- } else if (name === 'maxDate' || name === 'maxDateTime') {
1583
- max = value;
1584
- } else if (name === 'onSelect') {
1585
- onselect = value;
1586
- } else if (overrides.hasOwnProperty(name)) {
1587
- if (typeof (value) === 'undefined') {
1588
- return overrides[name];
1589
- }
1590
- fns[name] = value;
1591
- name_clone = {}; //empty results in exiting function after overrides updated
1592
- }
1593
- } else if (typeof name == 'object') { //if min/max was set with the JSON
1594
- if (name.minDate) {
1595
- min = name.minDate;
1596
- } else if (name.minDateTime) {
1597
- min = name.minDateTime;
1598
- } else if (name.maxDate) {
1599
- max = name.maxDate;
1600
- } else if (name.maxDateTime) {
1601
- max = name.maxDateTime;
1602
- }
1603
- for (prop in overrides) {
1604
- if (overrides.hasOwnProperty(prop) && name[prop]) {
1605
- fns[prop] = name[prop];
1606
- }
1607
- }
1608
- }
1609
- for (prop in fns) {
1610
- if (fns.hasOwnProperty(prop)) {
1611
- overrides[prop] = fns[prop];
1612
- if (!name_clone) { name_clone = $.extend({}, name);}
1613
- delete name_clone[prop];
1614
- }
1615
- }
1616
- if (name_clone && isEmptyObject(name_clone)) { return; }
1617
- if (min) { //if min was set
1618
- if (min === 0) {
1619
- min = new Date();
1620
- } else {
1621
- min = new Date(min);
1622
- }
1623
- tp_inst._defaults.minDate = min;
1624
- tp_inst._defaults.minDateTime = min;
1625
- } else if (max) { //if max was set
1626
- if (max === 0) {
1627
- max = new Date();
1628
- } else {
1629
- max = new Date(max);
1630
- }
1631
- tp_inst._defaults.maxDate = max;
1632
- tp_inst._defaults.maxDateTime = max;
1633
- } else if (onselect) {
1634
- tp_inst._defaults.onSelect = onselect;
1635
- }
1708
+ if (typeof name === 'string') { // if min/max was set with the string
1709
+ if (name === 'minDate' || name === 'minDateTime') {
1710
+ min = value;
1711
+ } else if (name === 'maxDate' || name === 'maxDateTime') {
1712
+ max = value;
1713
+ } else if (name === 'onSelect') {
1714
+ onselect = value;
1715
+ } else if (overrides.hasOwnProperty(name)) {
1716
+ if (typeof (value) === 'undefined') {
1717
+ return overrides[name];
1718
+ }
1719
+ fns[name] = value;
1720
+ name_clone = {}; //empty results in exiting function after overrides updated
1721
+ }
1722
+ } else if (typeof name === 'object') { //if min/max was set with the JSON
1723
+ if (name.minDate) {
1724
+ min = name.minDate;
1725
+ } else if (name.minDateTime) {
1726
+ min = name.minDateTime;
1727
+ } else if (name.maxDate) {
1728
+ max = name.maxDate;
1729
+ } else if (name.maxDateTime) {
1730
+ max = name.maxDateTime;
1731
+ }
1732
+ for (prop in overrides) {
1733
+ if (overrides.hasOwnProperty(prop) && name[prop]) {
1734
+ fns[prop] = name[prop];
1735
+ }
1736
+ }
1737
+ }
1738
+ for (prop in fns) {
1739
+ if (fns.hasOwnProperty(prop)) {
1740
+ overrides[prop] = fns[prop];
1741
+ if (!name_clone) { name_clone = $.extend({}, name); }
1742
+ delete name_clone[prop];
1743
+ }
1744
+ }
1745
+ if (name_clone && isEmptyObject(name_clone)) { return; }
1746
+ if (min) { //if min was set
1747
+ if (min === 0) {
1748
+ min = new Date();
1749
+ } else {
1750
+ min = new Date(min);
1751
+ }
1752
+ tp_inst._defaults.minDate = min;
1753
+ tp_inst._defaults.minDateTime = min;
1754
+ } else if (max) { //if max was set
1755
+ if (max === 0) {
1756
+ max = new Date();
1757
+ } else {
1758
+ max = new Date(max);
1759
+ }
1760
+ tp_inst._defaults.maxDate = max;
1761
+ tp_inst._defaults.maxDateTime = max;
1762
+ } else if (onselect) {
1763
+ tp_inst._defaults.onSelect = onselect;
1764
+ }
1636
1765
  }
1637
1766
  if (value === undefined) {
1638
1767
  return this._base_optionDatepicker.call($.datepicker, target, name);
1639
1768
  }
1640
1769
  return this._base_optionDatepicker.call($.datepicker, target, name_clone || name, value);
1641
1770
  };
1771
+
1642
1772
  /*
1643
1773
  * jQuery isEmptyObject does not check hasOwnProperty - if someone has added to the object prototype,
1644
1774
  * it will return false for all objects
1645
1775
  */
1646
- var isEmptyObject = function(obj) {
1776
+ var isEmptyObject = function (obj) {
1647
1777
  var prop;
1648
1778
  for (prop in obj) {
1649
- if (obj.hasOwnProperty(obj)) {
1779
+ if (obj.hasOwnProperty(prop)) {
1650
1780
  return false;
1651
1781
  }
1652
1782
  }
@@ -1656,7 +1786,7 @@
1656
1786
  /*
1657
1787
  * jQuery extend now ignores nulls!
1658
1788
  */
1659
- var extendRemove = function(target, props) {
1789
+ var extendRemove = function (target, props) {
1660
1790
  $.extend(target, props);
1661
1791
  for (var name in props) {
1662
1792
  if (props[name] === null || props[name] === undefined) {
@@ -1667,253 +1797,341 @@
1667
1797
  };
1668
1798
 
1669
1799
  /*
1670
- * Determine by the time format if should use ampm
1671
- * Returns true if should use ampm, false if not
1800
+ * Determine by the time format which units are supported
1801
+ * Returns an object of booleans for each unit
1672
1802
  */
1673
- var useAmpm = function(timeFormat){
1674
- return (timeFormat.indexOf('t') !== -1 && timeFormat.indexOf('h') !== -1);
1803
+ var detectSupport = function (timeFormat) {
1804
+ var tf = timeFormat.replace(/'.*?'/g, '').toLowerCase(), // removes literals
1805
+ isIn = function (f, t) { // does the format contain the token?
1806
+ return f.indexOf(t) !== -1 ? true : false;
1807
+ };
1808
+ return {
1809
+ hour: isIn(tf, 'h'),
1810
+ minute: isIn(tf, 'm'),
1811
+ second: isIn(tf, 's'),
1812
+ millisec: isIn(tf, 'l'),
1813
+ microsec: isIn(tf, 'c'),
1814
+ timezone: isIn(tf, 'z'),
1815
+ ampm: isIn(tf, 't') && isIn(timeFormat, 'h'),
1816
+ iso8601: isIn(timeFormat, 'Z')
1817
+ };
1675
1818
  };
1676
1819
 
1677
1820
  /*
1678
1821
  * Converts 24 hour format into 12 hour
1679
1822
  * Returns 12 hour without leading 0
1680
1823
  */
1681
- var convert24to12 = function(hour) {
1682
- if (hour > 12) {
1683
- hour = hour - 12;
1684
- }
1824
+ var convert24to12 = function (hour) {
1825
+ hour %= 12;
1685
1826
 
1686
- if (hour == 0) {
1827
+ if (hour === 0) {
1687
1828
  hour = 12;
1688
1829
  }
1689
1830
 
1690
1831
  return String(hour);
1691
1832
  };
1692
1833
 
1834
+ var computeEffectiveSetting = function (settings, property) {
1835
+ return settings && settings[property] ? settings[property] : $.timepicker._defaults[property];
1836
+ };
1837
+
1693
1838
  /*
1694
- * Splits datetime string into date ans time substrings.
1839
+ * Splits datetime string into date and time substrings.
1695
1840
  * Throws exception when date can't be parsed
1696
- * Returns [dateString, timeString]
1841
+ * Returns {dateString: dateString, timeString: timeString}
1697
1842
  */
1698
- var splitDateTime = function(dateFormat, dateTimeString, dateSettings, timeSettings) {
1699
- try {
1700
- // The idea is to get the number separator occurances in datetime and the time format requested (since time has
1701
- // fewer unknowns, mostly numbers and am/pm). We will use the time pattern to split.
1702
- var separator = timeSettings && timeSettings.separator ? timeSettings.separator : $.timepicker._defaults.separator,
1703
- format = timeSettings && timeSettings.timeFormat ? timeSettings.timeFormat : $.timepicker._defaults.timeFormat,
1704
- timeParts = format.split(separator), // how many occurances of separator may be in our format?
1705
- timePartsLen = timeParts.length,
1706
- allParts = dateTimeString.split(separator),
1707
- allPartsLen = allParts.length;
1708
-
1709
- if (allPartsLen > 1) {
1710
- return [
1711
- allParts.splice(0,allPartsLen-timePartsLen).join(separator),
1712
- allParts.splice(0,timePartsLen).join(separator)
1713
- ];
1714
- }
1715
-
1716
- } catch (err) {
1717
- $.timepicker.log('Could not split the date from the time. Please check the following datetimepicker options' +
1718
- "\nthrown error: " + err +
1719
- "\ndateTimeString" + dateTimeString +
1720
- "\ndateFormat = " + dateFormat +
1721
- "\nseparator = " + timeSettings.separator +
1722
- "\ntimeFormat = " + timeSettings.timeFormat);
1723
-
1724
- if (err.indexOf(":") >= 0) {
1725
- // Hack! The error message ends with a colon, a space, and
1726
- // the "extra" characters. We rely on that instead of
1727
- // attempting to perfectly reproduce the parsing algorithm.
1728
- var dateStringLength = dateTimeString.length - (err.length - err.indexOf(':') - 2),
1729
- timeString = dateTimeString.substring(dateStringLength);
1730
-
1731
- return [$.trim(dateTimeString.substring(0, dateStringLength)), $.trim(dateTimeString.substring(dateStringLength))];
1732
-
1733
- } else {
1734
- throw err;
1735
- }
1843
+ var splitDateTime = function (dateTimeString, timeSettings) {
1844
+ // The idea is to get the number separator occurrences in datetime and the time format requested (since time has
1845
+ // fewer unknowns, mostly numbers and am/pm). We will use the time pattern to split.
1846
+ var separator = computeEffectiveSetting(timeSettings, 'separator'),
1847
+ format = computeEffectiveSetting(timeSettings, 'timeFormat'),
1848
+ timeParts = format.split(separator), // how many occurrences of separator may be in our format?
1849
+ timePartsLen = timeParts.length,
1850
+ allParts = dateTimeString.split(separator),
1851
+ allPartsLen = allParts.length;
1852
+
1853
+ if (allPartsLen > 1) {
1854
+ return {
1855
+ dateString: allParts.splice(0, allPartsLen - timePartsLen).join(separator),
1856
+ timeString: allParts.splice(0, timePartsLen).join(separator)
1857
+ };
1736
1858
  }
1737
- return [dateTimeString, ''];
1859
+
1860
+ return {
1861
+ dateString: dateTimeString,
1862
+ timeString: ''
1863
+ };
1738
1864
  };
1739
1865
 
1740
1866
  /*
1741
1867
  * Internal function to parse datetime interval
1742
1868
  * Returns: {date: Date, timeObj: Object}, where
1743
1869
  * date - parsed date without time (type Date)
1744
- * timeObj = {hour: , minute: , second: , millisec: } - parsed time. Optional
1870
+ * timeObj = {hour: , minute: , second: , millisec: , microsec: } - parsed time. Optional
1745
1871
  */
1746
- var parseDateTimeInternal = function(dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings) {
1747
- var date;
1748
- var splitRes = splitDateTime(dateFormat, dateTimeString, dateSettings, timeSettings);
1749
- date = $.datepicker._base_parseDate(dateFormat, splitRes[0], dateSettings);
1750
- if (splitRes[1] !== '') {
1751
- var timeString = splitRes[1],
1752
- parsedTime = $.datepicker.parseTime(timeFormat, timeString, timeSettings);
1872
+ var parseDateTimeInternal = function (dateFormat, timeFormat, dateTimeString, dateSettings, timeSettings) {
1873
+ var date,
1874
+ parts,
1875
+ parsedTime;
1753
1876
 
1754
- if (parsedTime === null) {
1755
- throw 'Wrong time format';
1756
- }
1757
- return {
1758
- date: date,
1759
- timeObj: parsedTime
1760
- };
1761
- } else {
1877
+ parts = splitDateTime(dateTimeString, timeSettings);
1878
+ date = $.datepicker._base_parseDate(dateFormat, parts.dateString, dateSettings);
1879
+
1880
+ if (parts.timeString === '') {
1762
1881
  return {
1763
1882
  date: date
1764
1883
  };
1765
1884
  }
1885
+
1886
+ parsedTime = $.datepicker.parseTime(timeFormat, parts.timeString, timeSettings);
1887
+
1888
+ if (!parsedTime) {
1889
+ throw 'Wrong time format';
1890
+ }
1891
+
1892
+ return {
1893
+ date: date,
1894
+ timeObj: parsedTime
1895
+ };
1766
1896
  };
1767
1897
 
1768
1898
  /*
1769
1899
  * Internal function to set timezone_select to the local timezone
1770
1900
  */
1771
- var selectLocalTimeZone = function(tp_inst, date) {
1901
+ var selectLocalTimezone = function (tp_inst, date) {
1772
1902
  if (tp_inst && tp_inst.timezone_select) {
1773
- tp_inst._defaults.useLocalTimezone = true;
1774
- var now = typeof date !== 'undefined' ? date : new Date();
1775
- var tzoffset = $.timepicker.timeZoneOffsetString(now);
1776
- if (tp_inst._defaults.timezoneIso8601) {
1777
- tzoffset = tzoffset.substring(0, 3) + ':' + tzoffset.substring(3);
1778
- }
1779
- tp_inst.timezone_select.val(tzoffset);
1903
+ var now = date || new Date();
1904
+ tp_inst.timezone_select.val(-now.getTimezoneOffset());
1780
1905
  }
1781
1906
  };
1782
1907
 
1783
1908
  /*
1784
- * Create a Singleton Insance
1909
+ * Create a Singleton Instance
1785
1910
  */
1786
1911
  $.timepicker = new Timepicker();
1787
1912
 
1788
1913
  /**
1789
1914
  * Get the timezone offset as string from a date object (eg '+0530' for UTC+5.5)
1790
- * @param date
1791
- * @return string
1915
+ * @param {number} tzMinutes if not a number, less than -720 (-1200), or greater than 840 (+1400) this value is returned
1916
+ * @param {boolean} iso8601 if true formats in accordance to iso8601 "+12:45"
1917
+ * @return {string}
1792
1918
  */
1793
- $.timepicker.timeZoneOffsetString = function(date) {
1794
- var off = date.getTimezoneOffset() * -1,
1919
+ $.timepicker.timezoneOffsetString = function (tzMinutes, iso8601) {
1920
+ if (isNaN(tzMinutes) || tzMinutes > 840 || tzMinutes < -720) {
1921
+ return tzMinutes;
1922
+ }
1923
+
1924
+ var off = tzMinutes,
1795
1925
  minutes = off % 60,
1796
- hours = (off - minutes) / 60;
1797
- return (off >= 0 ? '+' : '-') + ('0' + (hours * 101).toString()).slice(-2) + ('0' + (minutes * 101).toString()).slice(-2);
1926
+ hours = (off - minutes) / 60,
1927
+ iso = iso8601 ? ':' : '',
1928
+ tz = (off >= 0 ? '+' : '-') + ('0' + Math.abs(hours)).slice(-2) + iso + ('0' + Math.abs(minutes)).slice(-2);
1929
+
1930
+ if (tz === '+00:00') {
1931
+ return 'Z';
1932
+ }
1933
+ return tz;
1934
+ };
1935
+
1936
+ /**
1937
+ * Get the number in minutes that represents a timezone string
1938
+ * @param {string} tzString formatted like "+0500", "-1245", "Z"
1939
+ * @return {number} the offset minutes or the original string if it doesn't match expectations
1940
+ */
1941
+ $.timepicker.timezoneOffsetNumber = function (tzString) {
1942
+ var normalized = tzString.toString().replace(':', ''); // excuse any iso8601, end up with "+1245"
1943
+
1944
+ if (normalized.toUpperCase() === 'Z') { // if iso8601 with Z, its 0 minute offset
1945
+ return 0;
1946
+ }
1947
+
1948
+ if (!/^(\-|\+)\d{4}$/.test(normalized)) { // possibly a user defined tz, so just give it back
1949
+ return tzString;
1950
+ }
1951
+
1952
+ return ((normalized.substr(0, 1) === '-' ? -1 : 1) * // plus or minus
1953
+ ((parseInt(normalized.substr(1, 2), 10) * 60) + // hours (converted to minutes)
1954
+ parseInt(normalized.substr(3, 2), 10))); // minutes
1955
+ };
1956
+
1957
+ /**
1958
+ * No way to set timezone in js Date, so we must adjust the minutes to compensate. (think setDate, getDate)
1959
+ * @param {Date} date
1960
+ * @param {string} toTimezone formatted like "+0500", "-1245"
1961
+ * @return {Date}
1962
+ */
1963
+ $.timepicker.timezoneAdjust = function (date, toTimezone) {
1964
+ var toTz = $.timepicker.timezoneOffsetNumber(toTimezone);
1965
+ if (!isNaN(toTz)) {
1966
+ date.setMinutes(date.getMinutes() + -date.getTimezoneOffset() - toTz);
1967
+ }
1968
+ return date;
1798
1969
  };
1799
1970
 
1800
1971
  /**
1801
1972
  * Calls `timepicker()` on the `startTime` and `endTime` elements, and configures them to
1802
1973
  * enforce date range limits.
1803
1974
  * n.b. The input value must be correctly formatted (reformatting is not supported)
1804
- * @param Element startTime
1805
- * @param Element endTime
1806
- * @param obj options Options for the timepicker() call
1807
- * @return jQuery
1975
+ * @param {Element} startTime
1976
+ * @param {Element} endTime
1977
+ * @param {Object} options Options for the timepicker() call
1978
+ * @return {jQuery}
1808
1979
  */
1809
- $.timepicker.timeRange = function(startTime, endTime, options) {
1980
+ $.timepicker.timeRange = function (startTime, endTime, options) {
1810
1981
  return $.timepicker.handleRange('timepicker', startTime, endTime, options);
1811
1982
  };
1812
1983
 
1813
1984
  /**
1814
1985
  * Calls `datetimepicker` on the `startTime` and `endTime` elements, and configures them to
1815
1986
  * enforce date range limits.
1816
- * @param Element startTime
1817
- * @param Element endTime
1818
- * @param obj options Options for the `timepicker()` call. Also supports `reformat`,
1987
+ * @param {Element} startTime
1988
+ * @param {Element} endTime
1989
+ * @param {Object} options Options for the `timepicker()` call. Also supports `reformat`,
1819
1990
  * a boolean value that can be used to reformat the input values to the `dateFormat`.
1820
- * @param string method Can be used to specify the type of picker to be added
1821
- * @return jQuery
1991
+ * @param {string} method Can be used to specify the type of picker to be added
1992
+ * @return {jQuery}
1822
1993
  */
1823
- $.timepicker.dateTimeRange = function(startTime, endTime, options) {
1824
- $.timepicker.dateRange(startTime, endTime, options, 'datetimepicker');
1994
+ $.timepicker.datetimeRange = function (startTime, endTime, options) {
1995
+ $.timepicker.handleRange('datetimepicker', startTime, endTime, options);
1825
1996
  };
1826
1997
 
1827
1998
  /**
1828
- * Calls `method` on the `startTime` and `endTime` elements, and configures them to
1999
+ * Calls `datepicker` on the `startTime` and `endTime` elements, and configures them to
1829
2000
  * enforce date range limits.
1830
- * @param Element startTime
1831
- * @param Element endTime
1832
- * @param obj options Options for the `timepicker()` call. Also supports `reformat`,
2001
+ * @param {Element} startTime
2002
+ * @param {Element} endTime
2003
+ * @param {Object} options Options for the `timepicker()` call. Also supports `reformat`,
1833
2004
  * a boolean value that can be used to reformat the input values to the `dateFormat`.
1834
- * @param string method Can be used to specify the type of picker to be added
1835
- * @return jQuery
2005
+ * @return {jQuery}
1836
2006
  */
1837
- $.timepicker.dateRange = function(startTime, endTime, options, method) {
1838
- method = method || 'datepicker';
1839
- $.timepicker.handleRange(method, startTime, endTime, options);
2007
+ $.timepicker.dateRange = function (startTime, endTime, options) {
2008
+ $.timepicker.handleRange('datepicker', startTime, endTime, options);
1840
2009
  };
1841
2010
 
1842
2011
  /**
1843
2012
  * Calls `method` on the `startTime` and `endTime` elements, and configures them to
1844
2013
  * enforce date range limits.
1845
- * @param string method Can be used to specify the type of picker to be added
1846
- * @param Element startTime
1847
- * @param Element endTime
1848
- * @param obj options Options for the `timepicker()` call. Also supports `reformat`,
2014
+ * @param {string} method Can be used to specify the type of picker to be added
2015
+ * @param {Element} startTime
2016
+ * @param {Element} endTime
2017
+ * @param {Object} options Options for the `timepicker()` call. Also supports `reformat`,
1849
2018
  * a boolean value that can be used to reformat the input values to the `dateFormat`.
1850
- * @return jQuery
2019
+ * @return {jQuery}
1851
2020
  */
1852
- $.timepicker.handleRange = function(method, startTime, endTime, options) {
2021
+ $.timepicker.handleRange = function (method, startTime, endTime, options) {
2022
+ options = $.extend({}, {
2023
+ minInterval: 0, // min allowed interval in milliseconds
2024
+ maxInterval: 0, // max allowed interval in milliseconds
2025
+ start: {}, // options for start picker
2026
+ end: {} // options for end picker
2027
+ }, options);
2028
+
2029
+ function checkDates(changed, other) {
2030
+ var startdt = startTime[method]('getDate'),
2031
+ enddt = endTime[method]('getDate'),
2032
+ changeddt = changed[method]('getDate');
2033
+
2034
+ if (startdt !== null) {
2035
+ var minDate = new Date(startdt.getTime()),
2036
+ maxDate = new Date(startdt.getTime());
2037
+
2038
+ minDate.setMilliseconds(minDate.getMilliseconds() + options.minInterval);
2039
+ maxDate.setMilliseconds(maxDate.getMilliseconds() + options.maxInterval);
2040
+
2041
+ if (options.minInterval > 0 && minDate > enddt) { // minInterval check
2042
+ endTime[method]('setDate', minDate);
2043
+ }
2044
+ else if (options.maxInterval > 0 && maxDate < enddt) { // max interval check
2045
+ endTime[method]('setDate', maxDate);
2046
+ }
2047
+ else if (startdt > enddt) {
2048
+ other[method]('setDate', changeddt);
2049
+ }
2050
+ }
2051
+ }
2052
+
2053
+ function selected(changed, other, option) {
2054
+ if (!changed.val()) {
2055
+ return;
2056
+ }
2057
+ var date = changed[method].call(changed, 'getDate');
2058
+ if (date !== null && options.minInterval > 0) {
2059
+ if (option === 'minDate') {
2060
+ date.setMilliseconds(date.getMilliseconds() + options.minInterval);
2061
+ }
2062
+ if (option === 'maxDate') {
2063
+ date.setMilliseconds(date.getMilliseconds() - options.minInterval);
2064
+ }
2065
+ }
2066
+ if (date.getTime) {
2067
+ other[method].call(other, 'option', option, date);
2068
+ }
2069
+ }
2070
+
1853
2071
  $.fn[method].call(startTime, $.extend({
1854
- onClose: function(dateText, inst) {
1855
- checkDates(this, endTime, dateText);
2072
+ onClose: function (dateText, inst) {
2073
+ checkDates($(this), endTime);
1856
2074
  },
1857
- onSelect: function(selectedDateTime) {
1858
- selected(this, endTime, 'minDate');
2075
+ onSelect: function (selectedDateTime) {
2076
+ selected($(this), endTime, 'minDate');
1859
2077
  }
1860
2078
  }, options, options.start));
1861
2079
  $.fn[method].call(endTime, $.extend({
1862
- onClose: function(dateText, inst) {
1863
- checkDates(this, startTime, dateText);
2080
+ onClose: function (dateText, inst) {
2081
+ checkDates($(this), startTime);
1864
2082
  },
1865
- onSelect: function(selectedDateTime) {
1866
- selected(this, startTime, 'maxDate');
2083
+ onSelect: function (selectedDateTime) {
2084
+ selected($(this), startTime, 'maxDate');
1867
2085
  }
1868
2086
  }, options, options.end));
1869
- // timepicker doesn't provide access to its 'timeFormat' option,
1870
- // nor could I get datepicker.formatTime() to behave with times, so I
1871
- // have disabled reformatting for timepicker
1872
- if (method != 'timepicker' && options.reformat) {
1873
- $([startTime, endTime]).each(function() {
1874
- var format = $(this)[method].call($(this), 'option', 'dateFormat'),
1875
- date = new Date($(this).val());
1876
- if ($(this).val() && date) {
1877
- $(this).val($.datepicker.formatDate(format, date));
1878
- }
1879
- });
1880
- }
1881
- checkDates(startTime, endTime, startTime.val());
1882
2087
 
1883
- function checkDates(changed, other, dateText) {
1884
- if (other.val() && (new Date(startTime.val()) > new Date(endTime.val()))) {
1885
- other.val(dateText);
1886
- }
1887
- }
2088
+ checkDates(startTime, endTime);
1888
2089
  selected(startTime, endTime, 'minDate');
1889
2090
  selected(endTime, startTime, 'maxDate');
1890
-
1891
- function selected(changed, other, option) {
1892
- if (!$(changed).val()) {
1893
- return;
1894
- }
1895
- var date = $(changed)[method].call($(changed), 'getDate');
1896
- // timepicker doesn't implement 'getDate' and returns a jQuery
1897
- if (date.getTime) {
1898
- $(other)[method].call($(other), 'option', option, date);
1899
- }
1900
- }
1901
2091
  return $([startTime.get(0), endTime.get(0)]);
1902
2092
  };
1903
2093
 
1904
2094
  /**
1905
2095
  * Log error or data to the console during error or debugging
1906
- * @param Object err pass any type object to log to the console during error or debugging
1907
- * @return void
2096
+ * @param {Object} err pass any type object to log to the console during error or debugging
2097
+ * @return {void}
2098
+ */
2099
+ $.timepicker.log = function (err) {
2100
+ if (window.console) {
2101
+ window.console.log(err);
2102
+ }
2103
+ };
2104
+
2105
+ /*
2106
+ * Add util object to allow access to private methods for testability.
1908
2107
  */
1909
- $.timepicker.log = function(err){
1910
- if(window.console)
1911
- console.log(err);
2108
+ $.timepicker._util = {
2109
+ _extendRemove: extendRemove,
2110
+ _isEmptyObject: isEmptyObject,
2111
+ _convert24to12: convert24to12,
2112
+ _detectSupport: detectSupport,
2113
+ _selectLocalTimezone: selectLocalTimezone,
2114
+ _computeEffectiveSetting: computeEffectiveSetting,
2115
+ _splitDateTime: splitDateTime,
2116
+ _parseDateTimeInternal: parseDateTimeInternal
1912
2117
  };
1913
2118
 
2119
+ /*
2120
+ * Microsecond support
2121
+ */
2122
+ if (!Date.prototype.getMicroseconds) {
2123
+ Date.prototype.microseconds = 0;
2124
+ Date.prototype.getMicroseconds = function () { return this.microseconds; };
2125
+ Date.prototype.setMicroseconds = function (m) {
2126
+ this.setMilliseconds(this.getMilliseconds() + Math.floor(m / 1000));
2127
+ this.microseconds = m % 1000;
2128
+ return this;
2129
+ };
2130
+ }
2131
+
1914
2132
  /*
1915
2133
  * Keep up with the version
1916
2134
  */
1917
- $.timepicker.version = "1.2";
2135
+ $.timepicker.version = "1.4.1";
1918
2136
 
1919
2137
  })(jQuery);