|
| |
1
| +/*! jQuery UI - v1.12.1 - 2017-08-04 |
|
| |
2
| +* http://jqueryui.com |
|
| |
3
| +* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-1-7.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/datepicker.js |
|
| |
4
| +* Copyright jQuery Foundation and other contributors; Licensed MIT */ |
|
| |
5
| + |
|
| |
6
| +(function( factory ) { |
|
| |
7
| + if ( typeof define === "function" && define.amd ) { |
|
| |
8
| + |
|
| |
9
| + // AMD. Register as an anonymous module. |
|
| |
10
| + define([ "jquery" ], factory ); |
|
| |
11
| + } else { |
|
| |
12
| + |
|
| |
13
| + // Browser globals |
|
| |
14
| + factory( jQuery ); |
|
| |
15
| + } |
|
| |
16
| +}(function( $ ) { |
|
| |
17
| + |
|
| |
18
| +$.ui = $.ui || {}; |
|
| |
19
| + |
|
| |
20
| +var version = $.ui.version = "1.12.1"; |
|
| |
21
| + |
|
| |
22
| + |
|
| |
23
| +/*! |
|
| |
24
| + * jQuery UI Widget 1.12.1 |
|
| |
25
| + * http://jqueryui.com |
|
| |
26
| + * |
|
| |
27
| + * Copyright jQuery Foundation and other contributors |
|
| |
28
| + * Released under the MIT license. |
|
| |
29
| + * http://jquery.org/license |
|
| |
30
| + */ |
|
| |
31
| + |
|
| |
32
| +//>>label: Widget |
|
| |
33
| +//>>group: Core |
|
| |
34
| +//>>description: Provides a factory for creating stateful widgets with a common API. |
|
| |
35
| +//>>docs: http://api.jqueryui.com/jQuery.widget/ |
|
| |
36
| +//>>demos: http://jqueryui.com/widget/ |
|
| |
37
| + |
|
| |
38
| + |
|
| |
39
| + |
|
| |
40
| +var widgetUuid = 0; |
|
| |
41
| +var widgetSlice = Array.prototype.slice; |
|
| |
42
| + |
|
| |
43
| +$.cleanData = ( function( orig ) { |
|
| |
44
| + return function( elems ) { |
|
| |
45
| + var events, elem, i; |
|
| |
46
| + for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) { |
|
| |
47
| + try { |
|
| |
48
| + |
|
| |
49
| + // Only trigger remove when necessary to save time |
|
| |
50
| + events = $._data( elem, "events" ); |
|
| |
51
| + if ( events && events.remove ) { |
|
| |
52
| + $( elem ).triggerHandler( "remove" ); |
|
| |
53
| + } |
|
| |
54
| + |
|
| |
55
| + // Http://bugs.jquery.com/ticket/8235 |
|
| |
56
| + } catch ( e ) {} |
|
| |
57
| + } |
|
| |
58
| + orig( elems ); |
|
| |
59
| + }; |
|
| |
60
| +} )( $.cleanData ); |
|
| |
61
| + |
|
| |
62
| +$.widget = function( name, base, prototype ) { |
|
| |
63
| + var existingConstructor, constructor, basePrototype; |
|
| |
64
| + |
|
| |
65
| + // ProxiedPrototype allows the provided prototype to remain unmodified |
|
| |
66
| + // so that it can be used as a mixin for multiple widgets (#8876) |
|
| |
67
| + var proxiedPrototype = {}; |
|
| |
68
| + |
|
| |
69
| + var namespace = name.split( "." )[ 0 ]; |
|
| |
70
| + name = name.split( "." )[ 1 ]; |
|
| |
71
| + var fullName = namespace + "-" + name; |
|
| |
72
| + |
|
| |
73
| + if ( !prototype ) { |
|
| |
74
| + prototype = base; |
|
| |
75
| + base = $.Widget; |
|
| |
76
| + } |
|
| |
77
| + |
|
| |
78
| + if ( $.isArray( prototype ) ) { |
|
| |
79
| + prototype = $.extend.apply( null, [ {} ].concat( prototype ) ); |
|
| |
80
| + } |
|
| |
81
| + |
|
| |
82
| + // Create selector for plugin |
|
| |
83
| + $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) { |
|
| |
84
| + return !!$.data( elem, fullName ); |
|
| |
85
| + }; |
|
| |
86
| + |
|
| |
87
| + $[ namespace ] = $[ namespace ] || {}; |
|
| |
88
| + existingConstructor = $[ namespace ][ name ]; |
|
| |
89
| + constructor = $[ namespace ][ name ] = function( options, element ) { |
|
| |
90
| + |
|
| |
91
| + // Allow instantiation without "new" keyword |
|
| |
92
| + if ( !this._createWidget ) { |
|
| |
93
| + return new constructor( options, element ); |
|
| |
94
| + } |
|
| |
95
| + |
|
| |
96
| + // Allow instantiation without initializing for simple inheritance |
|
| |
97
| + // must use "new" keyword (the code above always passes args) |
|
| |
98
| + if ( arguments.length ) { |
|
| |
99
| + this._createWidget( options, element ); |
|
| |
100
| + } |
|
| |
101
| + }; |
|
| |
102
| + |
|
| |
103
| + // Extend with the existing constructor to carry over any static properties |
|
| |
104
| + $.extend( constructor, existingConstructor, { |
|
| |
105
| + version: prototype.version, |
|
| |
106
| + |
|
| |
107
| + // Copy the object used to create the prototype in case we need to |
|
| |
108
| + // redefine the widget later |
|
| |
109
| + _proto: $.extend( {}, prototype ), |
|
| |
110
| + |
|
| |
111
| + // Track widgets that inherit from this widget in case this widget is |
|
| |
112
| + // redefined after a widget inherits from it |
|
| |
113
| + _childConstructors: [] |
|
| |
114
| + } ); |
|
| |
115
| + |
|
| |
116
| + basePrototype = new base(); |
|
| |
117
| + |
|
| |
118
| + // We need to make the options hash a property directly on the new instance |
|
| |
119
| + // otherwise we'll modify the options hash on the prototype that we're |
|
| |
120
| + // inheriting from |
|
| |
121
| + basePrototype.options = $.widget.extend( {}, basePrototype.options ); |
|
| |
122
| + $.each( prototype, function( prop, value ) { |
|
| |
123
| + if ( !$.isFunction( value ) ) { |
|
| |
124
| + proxiedPrototype[ prop ] = value; |
|
| |
125
| + return; |
|
| |
126
| + } |
|
| |
127
| + proxiedPrototype[ prop ] = ( function() { |
|
| |
128
| + function _super() { |
|
| |
129
| + return base.prototype[ prop ].apply( this, arguments ); |
|
| |
130
| + } |
|
| |
131
| + |
|
| |
132
| + function _superApply( args ) { |
|
| |
133
| + return base.prototype[ prop ].apply( this, args ); |
|
| |
134
| + } |
|
| |
135
| + |
|
| |
136
| + return function() { |
|
| |
137
| + var __super = this._super; |
|
| |
138
| + var __superApply = this._superApply; |
|
| |
139
| + var returnValue; |
|
| |
140
| + |
|
| |
141
| + this._super = _super; |
|
| |
142
| + this._superApply = _superApply; |
|
| |
143
| + |
|
| |
144
| + returnValue = value.apply( this, arguments ); |
|
| |
145
| + |
|
| |
146
| + this._super = __super; |
|
| |
147
| + this._superApply = __superApply; |
|
| |
148
| + |
|
| |
149
| + return returnValue; |
|
| |
150
| + }; |
|
| |
151
| + } )(); |
|
| |
152
| + } ); |
|
| |
153
| + constructor.prototype = $.widget.extend( basePrototype, { |
|
| |
154
| + |
|
| |
155
| + // TODO: remove support for widgetEventPrefix |
|
| |
156
| + // always use the name + a colon as the prefix, e.g., draggable:start |
|
| |
157
| + // don't prefix for widgets that aren't DOM-based |
|
| |
158
| + widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name |
|
| |
159
| + }, proxiedPrototype, { |
|
| |
160
| + constructor: constructor, |
|
| |
161
| + namespace: namespace, |
|
| |
162
| + widgetName: name, |
|
| |
163
| + widgetFullName: fullName |
|
| |
164
| + } ); |
|
| |
165
| + |
|
| |
166
| + // If this widget is being redefined then we need to find all widgets that |
|
| |
167
| + // are inheriting from it and redefine all of them so that they inherit from |
|
| |
168
| + // the new version of this widget. We're essentially trying to replace one |
|
| |
169
| + // level in the prototype chain. |
|
| |
170
| + if ( existingConstructor ) { |
|
| |
171
| + $.each( existingConstructor._childConstructors, function( i, child ) { |
|
| |
172
| + var childPrototype = child.prototype; |
|
| |
173
| + |
|
| |
174
| + // Redefine the child widget using the same prototype that was |
|
| |
175
| + // originally used, but inherit from the new version of the base |
|
| |
176
| + $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, |
|
| |
177
| + child._proto ); |
|
| |
178
| + } ); |
|
| |
179
| + |
|
| |
180
| + // Remove the list of existing child constructors from the old constructor |
|
| |
181
| + // so the old child constructors can be garbage collected |
|
| |
182
| + delete existingConstructor._childConstructors; |
|
| |
183
| + } else { |
|
| |
184
| + base._childConstructors.push( constructor ); |
|
| |
185
| + } |
|
| |
186
| + |
|
| |
187
| + $.widget.bridge( name, constructor ); |
|
| |
188
| + |
|
| |
189
| + return constructor; |
|
| |
190
| +}; |
|
| |
191
| + |
|
| |
192
| +$.widget.extend = function( target ) { |
|
| |
193
| + var input = widgetSlice.call( arguments, 1 ); |
|
| |
194
| + var inputIndex = 0; |
|
| |
195
| + var inputLength = input.length; |
|
| |
196
| + var key; |
|
| |
197
| + var value; |
|
| |
198
| + |
|
| |
199
| + for ( ; inputIndex < inputLength; inputIndex++ ) { |
|
| |
200
| + for ( key in input[ inputIndex ] ) { |
|
| |
201
| + value = input[ inputIndex ][ key ]; |
|
| |
202
| + if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) { |
|
| |
203
| + |
|
| |
204
| + // Clone objects |
|
| |
205
| + if ( $.isPlainObject( value ) ) { |
|
| |
206
| + target[ key ] = $.isPlainObject( target[ key ] ) ? |
|
| |
207
| + $.widget.extend( {}, target[ key ], value ) : |
|
| |
208
| + |
|
| |
209
| + // Don't extend strings, arrays, etc. with objects |
|
| |
210
| + $.widget.extend( {}, value ); |
|
| |
211
| + |
|
| |
212
| + // Copy everything else by reference |
|
| |
213
| + } else { |
|
| |
214
| + target[ key ] = value; |
|
| |
215
| + } |
|
| |
216
| + } |
|
| |
217
| + } |
|
| |
218
| + } |
|
| |
219
| + return target; |
|
| |
220
| +}; |
|
| |
221
| + |
|
| |
222
| +$.widget.bridge = function( name, object ) { |
|
| |
223
| + var fullName = object.prototype.widgetFullName || name; |
|
| |
224
| + $.fn[ name ] = function( options ) { |
|
| |
225
| + var isMethodCall = typeof options === "string"; |
|
| |
226
| + var args = widgetSlice.call( arguments, 1 ); |
|
| |
227
| + var returnValue = this; |
|
| |
228
| + |
|
| |
229
| + if ( isMethodCall ) { |
|
| |
230
| + |
|
| |
231
| + // If this is an empty collection, we need to have the instance method |
|
| |
232
| + // return undefined instead of the jQuery instance |
|
| |
233
| + if ( !this.length && options === "instance" ) { |
|
| |
234
| + returnValue = undefined; |
|
| |
235
| + } else { |
|
| |
236
| + this.each( function() { |
|
| |
237
| + var methodValue; |
|
| |
238
| + var instance = $.data( this, fullName ); |
|
| |
239
| + |
|
| |
240
| + if ( options === "instance" ) { |
|
| |
241
| + returnValue = instance; |
|
| |
242
| + return false; |
|
| |
243
| + } |
|
| |
244
| + |
|
| |
245
| + if ( !instance ) { |
|
| |
246
| + return $.error( "cannot call methods on " + name + |
|
| |
247
| + " prior to initialization; " + |
|
| |
248
| + "attempted to call method '" + options + "'" ); |
|
| |
249
| + } |
|
| |
250
| + |
|
| |
251
| + if ( !$.isFunction( instance[ options ] ) || options.charAt( 0 ) === "_" ) { |
|
| |
252
| + return $.error( "no such method '" + options + "' for " + name + |
|
| |
253
| + " widget instance" ); |
|
| |
254
| + } |
|
| |
255
| + |
|
| |
256
| + methodValue = instance[ options ].apply( instance, args ); |
|
| |
257
| + |
|
| |
258
| + if ( methodValue !== instance && methodValue !== undefined ) { |
|
| |
259
| + returnValue = methodValue && methodValue.jquery ? |
|
| |
260
| + returnValue.pushStack( methodValue.get() ) : |
|
| |
261
| + methodValue; |
|
| |
262
| + return false; |
|
| |
263
| + } |
|
| |
264
| + } ); |
|
| |
265
| + } |
|
| |
266
| + } else { |
|
| |
267
| + |
|
| |
268
| + // Allow multiple hashes to be passed on init |
|
| |
269
| + if ( args.length ) { |
|
| |
270
| + options = $.widget.extend.apply( null, [ options ].concat( args ) ); |
|
| |
271
| + } |
|
| |
272
| + |
|
| |
273
| + this.each( function() { |
|
| |
274
| + var instance = $.data( this, fullName ); |
|
| |
275
| + if ( instance ) { |
|
| |
276
| + instance.option( options || {} ); |
|
| |
277
| + if ( instance._init ) { |
|
| |
278
| + instance._init(); |
|
| |
279
| + } |
|
| |
280
| + } else { |
|
| |
281
| + $.data( this, fullName, new object( options, this ) ); |
|
| |
282
| + } |
|
| |
283
| + } ); |
|
| |
284
| + } |
|
| |
285
| + |
|
| |
286
| + return returnValue; |
|
| |
287
| + }; |
|
| |
288
| +}; |
|
| |
289
| + |
|
| |
290
| +$.Widget = function( /* options, element */ ) {}; |
|
| |
291
| +$.Widget._childConstructors = []; |
|
| |
292
| + |
|
| |
293
| +$.Widget.prototype = { |
|
| |
294
| + widgetName: "widget", |
|
| |
295
| + widgetEventPrefix: "", |
|
| |
296
| + defaultElement: "<div>", |
|
| |
297
| + |
|
| |
298
| + options: { |
|
| |
299
| + classes: {}, |
|
| |
300
| + disabled: false, |
|
| |
301
| + |
|
| |
302
| + // Callbacks |
|
| |
303
| + create: null |
|
| |
304
| + }, |
|
| |
305
| + |
|
| |
306
| + _createWidget: function( options, element ) { |
|
| |
307
| + element = $( element || this.defaultElement || this )[ 0 ]; |
|
| |
308
| + this.element = $( element ); |
|
| |
309
| + this.uuid = widgetUuid++; |
|
| |
310
| + this.eventNamespace = "." + this.widgetName + this.uuid; |
|
| |
311
| + |
|
| |
312
| + this.bindings = $(); |
|
| |
313
| + this.hoverable = $(); |
|
| |
314
| + this.focusable = $(); |
|
| |
315
| + this.classesElementLookup = {}; |
|
| |
316
| + |
|
| |
317
| + if ( element !== this ) { |
|
| |
318
| + $.data( element, this.widgetFullName, this ); |
|
| |
319
| + this._on( true, this.element, { |
|
| |
320
| + remove: function( event ) { |
|
| |
321
| + if ( event.target === element ) { |
|
| |
322
| + this.destroy(); |
|
| |
323
| + } |
|
| |
324
| + } |
|
| |
325
| + } ); |
|
| |
326
| + this.document = $( element.style ? |
|
| |
327
| + |
|
| |
328
| + // Element within the document |
|
| |
329
| + element.ownerDocument : |
|
| |
330
| + |
|
| |
331
| + // Element is window or document |
|
| |
332
| + element.document || element ); |
|
| |
333
| + this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow ); |
|
| |
334
| + } |
|
| |
335
| + |
|
| |
336
| + this.options = $.widget.extend( {}, |
|
| |
337
| + this.options, |
|
| |
338
| + this._getCreateOptions(), |
|
| |
339
| + options ); |
|
| |
340
| + |
|
| |
341
| + this._create(); |
|
| |
342
| + |
|
| |
343
| + if ( this.options.disabled ) { |
|
| |
344
| + this._setOptionDisabled( this.options.disabled ); |
|
| |
345
| + } |
|
| |
346
| + |
|
| |
347
| + this._trigger( "create", null, this._getCreateEventData() ); |
|
| |
348
| + this._init(); |
|
| |
349
| + }, |
|
| |
350
| + |
|
| |
351
| + _getCreateOptions: function() { |
|
| |
352
| + return {}; |
|
| |
353
| + }, |
|
| |
354
| + |
|
| |
355
| + _getCreateEventData: $.noop, |
|
| |
356
| + |
|
| |
357
| + _create: $.noop, |
|
| |
358
| + |
|
| |
359
| + _init: $.noop, |
|
| |
360
| + |
|
| |
361
| + destroy: function() { |
|
| |
362
| + var that = this; |
|
| |
363
| + |
|
| |
364
| + this._destroy(); |
|
| |
365
| + $.each( this.classesElementLookup, function( key, value ) { |
|
| |
366
| + that._removeClass( value, key ); |
|
| |
367
| + } ); |
|
| |
368
| + |
|
| |
369
| + // We can probably remove the unbind calls in 2.0 |
|
| |
370
| + // all event bindings should go through this._on() |
|
| |
371
| + this.element |
|
| |
372
| + .off( this.eventNamespace ) |
|
| |
373
| + .removeData( this.widgetFullName ); |
|
| |
374
| + this.widget() |
|
| |
375
| + .off( this.eventNamespace ) |
|
| |
376
| + .removeAttr( "aria-disabled" ); |
|
| |
377
| + |
|
| |
378
| + // Clean up events and states |
|
| |
379
| + this.bindings.off( this.eventNamespace ); |
|
| |
380
| + }, |
|
| |
381
| + |
|
| |
382
| + _destroy: $.noop, |
|
| |
383
| + |
|
| |
384
| + widget: function() { |
|
| |
385
| + return this.element; |
|
| |
386
| + }, |
|
| |
387
| + |
|
| |
388
| + option: function( key, value ) { |
|
| |
389
| + var options = key; |
|
| |
390
| + var parts; |
|
| |
391
| + var curOption; |
|
| |
392
| + var i; |
|
| |
393
| + |
|
| |
394
| + if ( arguments.length === 0 ) { |
|
| |
395
| + |
|
| |
396
| + // Don't return a reference to the internal hash |
|
| |
397
| + return $.widget.extend( {}, this.options ); |
|
| |
398
| + } |
|
| |
399
| + |
|
| |
400
| + if ( typeof key === "string" ) { |
|
| |
401
| + |
|
| |
402
| + // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } } |
|
| |
403
| + options = {}; |
|
| |
404
| + parts = key.split( "." ); |
|
| |
405
| + key = parts.shift(); |
|
| |
406
| + if ( parts.length ) { |
|
| |
407
| + curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] ); |
|
| |
408
| + for ( i = 0; i < parts.length - 1; i++ ) { |
|
| |
409
| + curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {}; |
|
| |
410
| + curOption = curOption[ parts[ i ] ]; |
|
| |
411
| + } |
|
| |
412
| + key = parts.pop(); |
|
| |
413
| + if ( arguments.length === 1 ) { |
|
| |
414
| + return curOption[ key ] === undefined ? null : curOption[ key ]; |
|
| |
415
| + } |
|
| |
416
| + curOption[ key ] = value; |
|
| |
417
| + } else { |
|
| |
418
| + if ( arguments.length === 1 ) { |
|
| |
419
| + return this.options[ key ] === undefined ? null : this.options[ key ]; |
|
| |
420
| + } |
|
| |
421
| + options[ key ] = value; |
|
| |
422
| + } |
|
| |
423
| + } |
|
| |
424
| + |
|
| |
425
| + this._setOptions( options ); |
|
| |
426
| + |
|
| |
427
| + return this; |
|
| |
428
| + }, |
|
| |
429
| + |
|
| |
430
| + _setOptions: function( options ) { |
|
| |
431
| + var key; |
|
| |
432
| + |
|
| |
433
| + for ( key in options ) { |
|
| |
434
| + this._setOption( key, options[ key ] ); |
|
| |
435
| + } |
|
| |
436
| + |
|
| |
437
| + return this; |
|
| |
438
| + }, |
|
| |
439
| + |
|
| |
440
| + _setOption: function( key, value ) { |
|
| |
441
| + if ( key === "classes" ) { |
|
| |
442
| + this._setOptionClasses( value ); |
|
| |
443
| + } |
|
| |
444
| + |
|
| |
445
| + this.options[ key ] = value; |
|
| |
446
| + |
|
| |
447
| + if ( key === "disabled" ) { |
|
| |
448
| + this._setOptionDisabled( value ); |
|
| |
449
| + } |
|
| |
450
| + |
|
| |
451
| + return this; |
|
| |
452
| + }, |
|
| |
453
| + |
|
| |
454
| + _setOptionClasses: function( value ) { |
|
| |
455
| + var classKey, elements, currentElements; |
|
| |
456
| + |
|
| |
457
| + for ( classKey in value ) { |
|
| |
458
| + currentElements = this.classesElementLookup[ classKey ]; |
|
| |
459
| + if ( value[ classKey ] === this.options.classes[ classKey ] || |
|
| |
460
| + !currentElements || |
|
| |
461
| + !currentElements.length ) { |
|
| |
462
| + continue; |
|
| |
463
| + } |
|
| |
464
| + |
|
| |
465
| + // We are doing this to create a new jQuery object because the _removeClass() call |
|
| |
466
| + // on the next line is going to destroy the reference to the current elements being |
|
| |
467
| + // tracked. We need to save a copy of this collection so that we can add the new classes |
|
| |
468
| + // below. |
|
| |
469
| + elements = $( currentElements.get() ); |
|
| |
470
| + this._removeClass( currentElements, classKey ); |
|
| |
471
| + |
|
| |
472
| + // We don't use _addClass() here, because that uses this.options.classes |
|
| |
473
| + // for generating the string of classes. We want to use the value passed in from |
|
| |
474
| + // _setOption(), this is the new value of the classes option which was passed to |
|
| |
475
| + // _setOption(). We pass this value directly to _classes(). |
|
| |
476
| + elements.addClass( this._classes( { |
|
| |
477
| + element: elements, |
|
| |
478
| + keys: classKey, |
|
| |
479
| + classes: value, |
|
| |
480
| + add: true |
|
| |
481
| + } ) ); |
|
| |
482
| + } |
|
| |
483
| + }, |
|
| |
484
| + |
|
| |
485
| + _setOptionDisabled: function( value ) { |
|
| |
486
| + this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value ); |
|
| |
487
| + |
|
| |
488
| + // If the widget is becoming disabled, then nothing is interactive |
|
| |
489
| + if ( value ) { |
|
| |
490
| + this._removeClass( this.hoverable, null, "ui-state-hover" ); |
|
| |
491
| + this._removeClass( this.focusable, null, "ui-state-focus" ); |
|
| |
492
| + } |
|
| |
493
| + }, |
|
| |
494
| + |
|
| |
495
| + enable: function() { |
|
| |
496
| + return this._setOptions( { disabled: false } ); |
|
| |
497
| + }, |
|
| |
498
| + |
|
| |
499
| + disable: function() { |
|
| |
500
| + return this._setOptions( { disabled: true } ); |
|
| |
501
| + }, |
|
| |
502
| + |
|
| |
503
| + _classes: function( options ) { |
|
| |
504
| + var full = []; |
|
| |
505
| + var that = this; |
|
| |
506
| + |
|
| |
507
| + options = $.extend( { |
|
| |
508
| + element: this.element, |
|
| |
509
| + classes: this.options.classes || {} |
|
| |
510
| + }, options ); |
|
| |
511
| + |
|
| |
512
| + function processClassString( classes, checkOption ) { |
|
| |
513
| + var current, i; |
|
| |
514
| + for ( i = 0; i < classes.length; i++ ) { |
|
| |
515
| + current = that.classesElementLookup[ classes[ i ] ] || $(); |
|
| |
516
| + if ( options.add ) { |
|
| |
517
| + current = $( $.unique( current.get().concat( options.element.get() ) ) ); |
|
| |
518
| + } else { |
|
| |
519
| + current = $( current.not( options.element ).get() ); |
|
| |
520
| + } |
|
| |
521
| + that.classesElementLookup[ classes[ i ] ] = current; |
|
| |
522
| + full.push( classes[ i ] ); |
|
| |
523
| + if ( checkOption && options.classes[ classes[ i ] ] ) { |
|
| |
524
| + full.push( options.classes[ classes[ i ] ] ); |
|
| |
525
| + } |
|
| |
526
| + } |
|
| |
527
| + } |
|
| |
528
| + |
|
| |
529
| + this._on( options.element, { |
|
| |
530
| + "remove": "_untrackClassesElement" |
|
| |
531
| + } ); |
|
| |
532
| + |
|
| |
533
| + if ( options.keys ) { |
|
| |
534
| + processClassString( options.keys.match( /\S+/g ) || [], true ); |
|
| |
535
| + } |
|
| |
536
| + if ( options.extra ) { |
|
| |
537
| + processClassString( options.extra.match( /\S+/g ) || [] ); |
|
| |
538
| + } |
|
| |
539
| + |
|
| |
540
| + return full.join( " " ); |
|
| |
541
| + }, |
|
| |
542
| + |
|
| |
543
| + _untrackClassesElement: function( event ) { |
|
| |
544
| + var that = this; |
|
| |
545
| + $.each( that.classesElementLookup, function( key, value ) { |
|
| |
546
| + if ( $.inArray( event.target, value ) !== -1 ) { |
|
| |
547
| + that.classesElementLookup[ key ] = $( value.not( event.target ).get() ); |
|
| |
548
| + } |
|
| |
549
| + } ); |
|
| |
550
| + }, |
|
| |
551
| + |
|
| |
552
| + _removeClass: function( element, keys, extra ) { |
|
| |
553
| + return this._toggleClass( element, keys, extra, false ); |
|
| |
554
| + }, |
|
| |
555
| + |
|
| |
556
| + _addClass: function( element, keys, extra ) { |
|
| |
557
| + return this._toggleClass( element, keys, extra, true ); |
|
| |
558
| + }, |
|
| |
559
| + |
|
| |
560
| + _toggleClass: function( element, keys, extra, add ) { |
|
| |
561
| + add = ( typeof add === "boolean" ) ? add : extra; |
|
| |
562
| + var shift = ( typeof element === "string" || element === null ), |
|
| |
563
| + options = { |
|
| |
564
| + extra: shift ? keys : extra, |
|
| |
565
| + keys: shift ? element : keys, |
|
| |
566
| + element: shift ? this.element : element, |
|
| |
567
| + add: add |
|
| |
568
| + }; |
|
| |
569
| + options.element.toggleClass( this._classes( options ), add ); |
|
| |
570
| + return this; |
|
| |
571
| + }, |
|
| |
572
| + |
|
| |
573
| + _on: function( suppressDisabledCheck, element, handlers ) { |
|
| |
574
| + var delegateElement; |
|
| |
575
| + var instance = this; |
|
| |
576
| + |
|
| |
577
| + // No suppressDisabledCheck flag, shuffle arguments |
|
| |
578
| + if ( typeof suppressDisabledCheck !== "boolean" ) { |
|
| |
579
| + handlers = element; |
|
| |
580
| + element = suppressDisabledCheck; |
|
| |
581
| + suppressDisabledCheck = false; |
|
| |
582
| + } |
|
| |
583
| + |
|
| |
584
| + // No element argument, shuffle and use this.element |
|
| |
585
| + if ( !handlers ) { |
|
| |
586
| + handlers = element; |
|
| |
587
| + element = this.element; |
|
| |
588
| + delegateElement = this.widget(); |
|
| |
589
| + } else { |
|
| |
590
| + element = delegateElement = $( element ); |
|
| |
591
| + this.bindings = this.bindings.add( element ); |
|
| |
592
| + } |
|
| |
593
| + |
|
| |
594
| + $.each( handlers, function( event, handler ) { |
|
| |
595
| + function handlerProxy() { |
|
| |
596
| + |
|
| |
597
| + // Allow widgets to customize the disabled handling |
|
| |
598
| + // - disabled as an array instead of boolean |
|
| |
599
| + // - disabled class as method for disabling individual parts |
|
| |
600
| + if ( !suppressDisabledCheck && |
|
| |
601
| + ( instance.options.disabled === true || |
|
| |
602
| + $( this ).hasClass( "ui-state-disabled" ) ) ) { |
|
| |
603
| + return; |
|
| |
604
| + } |
|
| |
605
| + return ( typeof handler === "string" ? instance[ handler ] : handler ) |
|
| |
606
| + .apply( instance, arguments ); |
|
| |
607
| + } |
|
| |
608
| + |
|
| |
609
| + // Copy the guid so direct unbinding works |
|
| |
610
| + if ( typeof handler !== "string" ) { |
|
| |
611
| + handlerProxy.guid = handler.guid = |
|
| |
612
| + handler.guid || handlerProxy.guid || $.guid++; |
|
| |
613
| + } |
|
| |
614
| + |
|
| |
615
| + var match = event.match( /^([\w:-]*)\s*(.*)$/ ); |
|
| |
616
| + var eventName = match[ 1 ] + instance.eventNamespace; |
|
| |
617
| + var selector = match[ 2 ]; |
|
| |
618
| + |
|
| |
619
| + if ( selector ) { |
|
| |
620
| + delegateElement.on( eventName, selector, handlerProxy ); |
|
| |
621
| + } else { |
|
| |
622
| + element.on( eventName, handlerProxy ); |
|
| |
623
| + } |
|
| |
624
| + } ); |
|
| |
625
| + }, |
|
| |
626
| + |
|
| |
627
| + _off: function( element, eventName ) { |
|
| |
628
| + eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) + |
|
| |
629
| + this.eventNamespace; |
|
| |
630
| + element.off( eventName ).off( eventName ); |
|
| |
631
| + |
|
| |
632
| + // Clear the stack to avoid memory leaks (#10056) |
|
| |
633
| + this.bindings = $( this.bindings.not( element ).get() ); |
|
| |
634
| + this.focusable = $( this.focusable.not( element ).get() ); |
|
| |
635
| + this.hoverable = $( this.hoverable.not( element ).get() ); |
|
| |
636
| + }, |
|
| |
637
| + |
|
| |
638
| + _delay: function( handler, delay ) { |
|
| |
639
| + function handlerProxy() { |
|
| |
640
| + return ( typeof handler === "string" ? instance[ handler ] : handler ) |
|
| |
641
| + .apply( instance, arguments ); |
|
| |
642
| + } |
|
| |
643
| + var instance = this; |
|
| |
644
| + return setTimeout( handlerProxy, delay || 0 ); |
|
| |
645
| + }, |
|
| |
646
| + |
|
| |
647
| + _hoverable: function( element ) { |
|
| |
648
| + this.hoverable = this.hoverable.add( element ); |
|
| |
649
| + this._on( element, { |
|
| |
650
| + mouseenter: function( event ) { |
|
| |
651
| + this._addClass( $( event.currentTarget ), null, "ui-state-hover" ); |
|
| |
652
| + }, |
|
| |
653
| + mouseleave: function( event ) { |
|
| |
654
| + this._removeClass( $( event.currentTarget ), null, "ui-state-hover" ); |
|
| |
655
| + } |
|
| |
656
| + } ); |
|
| |
657
| + }, |
|
| |
658
| + |
|
| |
659
| + _focusable: function( element ) { |
|
| |
660
| + this.focusable = this.focusable.add( element ); |
|
| |
661
| + this._on( element, { |
|
| |
662
| + focusin: function( event ) { |
|
| |
663
| + this._addClass( $( event.currentTarget ), null, "ui-state-focus" ); |
|
| |
664
| + }, |
|
| |
665
| + focusout: function( event ) { |
|
| |
666
| + this._removeClass( $( event.currentTarget ), null, "ui-state-focus" ); |
|
| |
667
| + } |
|
| |
668
| + } ); |
|
| |
669
| + }, |
|
| |
670
| + |
|
| |
671
| + _trigger: function( type, event, data ) { |
|
| |
672
| + var prop, orig; |
|
| |
673
| + var callback = this.options[ type ]; |
|
| |
674
| + |
|
| |
675
| + data = data || {}; |
|
| |
676
| + event = $.Event( event ); |
|
| |
677
| + event.type = ( type === this.widgetEventPrefix ? |
|
| |
678
| + type : |
|
| |
679
| + this.widgetEventPrefix + type ).toLowerCase(); |
|
| |
680
| + |
|
| |
681
| + // The original event may come from any element |
|
| |
682
| + // so we need to reset the target on the new event |
|
| |
683
| + event.target = this.element[ 0 ]; |
|
| |
684
| + |
|
| |
685
| + // Copy original event properties over to the new event |
|
| |
686
| + orig = event.originalEvent; |
|
| |
687
| + if ( orig ) { |
|
| |
688
| + for ( prop in orig ) { |
|
| |
689
| + if ( !( prop in event ) ) { |
|
| |
690
| + event[ prop ] = orig[ prop ]; |
|
| |
691
| + } |
|
| |
692
| + } |
|
| |
693
| + } |
|
| |
694
| + |
|
| |
695
| + this.element.trigger( event, data ); |
|
| |
696
| + return !( $.isFunction( callback ) && |
|
| |
697
| + callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false || |
|
| |
698
| + event.isDefaultPrevented() ); |
|
| |
699
| + } |
|
| |
700
| +}; |
|
| |
701
| + |
|
| |
702
| +$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) { |
|
| |
703
| + $.Widget.prototype[ "_" + method ] = function( element, options, callback ) { |
|
| |
704
| + if ( typeof options === "string" ) { |
|
| |
705
| + options = { effect: options }; |
|
| |
706
| + } |
|
| |
707
| + |
|
| |
708
| + var hasOptions; |
|
| |
709
| + var effectName = !options ? |
|
| |
710
| + method : |
|
| |
711
| + options === true || typeof options === "number" ? |
|
| |
712
| + defaultEffect : |
|
| |
713
| + options.effect || defaultEffect; |
|
| |
714
| + |
|
| |
715
| + options = options || {}; |
|
| |
716
| + if ( typeof options === "number" ) { |
|
| |
717
| + options = { duration: options }; |
|
| |
718
| + } |
|
| |
719
| + |
|
| |
720
| + hasOptions = !$.isEmptyObject( options ); |
|
| |
721
| + options.complete = callback; |
|
| |
722
| + |
|
| |
723
| + if ( options.delay ) { |
|
| |
724
| + element.delay( options.delay ); |
|
| |
725
| + } |
|
| |
726
| + |
|
| |
727
| + if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) { |
|
| |
728
| + element[ method ]( options ); |
|
| |
729
| + } else if ( effectName !== method && element[ effectName ] ) { |
|
| |
730
| + element[ effectName ]( options.duration, options.easing, callback ); |
|
| |
731
| + } else { |
|
| |
732
| + element.queue( function( next ) { |
|
| |
733
| + $( this )[ method ](); |
|
| |
734
| + if ( callback ) { |
|
| |
735
| + callback.call( element[ 0 ] ); |
|
| |
736
| + } |
|
| |
737
| + next(); |
|
| |
738
| + } ); |
|
| |
739
| + } |
|
| |
740
| + }; |
|
| |
741
| +} ); |
|
| |
742
| + |
|
| |
743
| +var widget = $.widget; |
|
| |
744
| + |
|
| |
745
| + |
|
| |
746
| +/*! |
|
| |
747
| + * jQuery UI Position 1.12.1 |
|
| |
748
| + * http://jqueryui.com |
|
| |
749
| + * |
|
| |
750
| + * Copyright jQuery Foundation and other contributors |
|
| |
751
| + * Released under the MIT license. |
|
| |
752
| + * http://jquery.org/license |
|
| |
753
| + * |
|
| |
754
| + * http://api.jqueryui.com/position/ |
|
| |
755
| + */ |
|
| |
756
| + |
|
| |
757
| +//>>label: Position |
|
| |
758
| +//>>group: Core |
|
| |
759
| +//>>description: Positions elements relative to other elements. |
|
| |
760
| +//>>docs: http://api.jqueryui.com/position/ |
|
| |
761
| +//>>demos: http://jqueryui.com/position/ |
|
| |
762
| + |
|
| |
763
| + |
|
| |
764
| +( function() { |
|
| |
765
| +var cachedScrollbarWidth, |
|
| |
766
| + max = Math.max, |
|
| |
767
| + abs = Math.abs, |
|
| |
768
| + rhorizontal = /left|center|right/, |
|
| |
769
| + rvertical = /top|center|bottom/, |
|
| |
770
| + roffset = /[\+\-]\d+(\.[\d]+)?%?/, |
|
| |
771
| + rposition = /^\w+/, |
|
| |
772
| + rpercent = /%$/, |
|
| |
773
| + _position = $.fn.position; |
|
| |
774
| + |
|
| |
775
| +function getOffsets( offsets, width, height ) { |
|
| |
776
| + return [ |
|
| |
777
| + parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ), |
|
| |
778
| + parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 ) |
|
| |
779
| + ]; |
|
| |
780
| +} |
|
| |
781
| + |
|
| |
782
| +function parseCss( element, property ) { |
|
| |
783
| + return parseInt( $.css( element, property ), 10 ) || 0; |
|
| |
784
| +} |
|
| |
785
| + |
|
| |
786
| +function getDimensions( elem ) { |
|
| |
787
| + var raw = elem[ 0 ]; |
|
| |
788
| + if ( raw.nodeType === 9 ) { |
|
| |
789
| + return { |
|
| |
790
| + width: elem.width(), |
|
| |
791
| + height: elem.height(), |
|
| |
792
| + offset: { top: 0, left: 0 } |
|
| |
793
| + }; |
|
| |
794
| + } |
|
| |
795
| + if ( $.isWindow( raw ) ) { |
|
| |
796
| + return { |
|
| |
797
| + width: elem.width(), |
|
| |
798
| + height: elem.height(), |
|
| |
799
| + offset: { top: elem.scrollTop(), left: elem.scrollLeft() } |
|
| |
800
| + }; |
|
| |
801
| + } |
|
| |
802
| + if ( raw.preventDefault ) { |
|
| |
803
| + return { |
|
| |
804
| + width: 0, |
|
| |
805
| + height: 0, |
|
| |
806
| + offset: { top: raw.pageY, left: raw.pageX } |
|
| |
807
| + }; |
|
| |
808
| + } |
|
| |
809
| + return { |
|
| |
810
| + width: elem.outerWidth(), |
|
| |
811
| + height: elem.outerHeight(), |
|
| |
812
| + offset: elem.offset() |
|
| |
813
| + }; |
|
| |
814
| +} |
|
| |
815
| + |
|
| |
816
| +$.position = { |
|
| |
817
| + scrollbarWidth: function() { |
|
| |
818
| + if ( cachedScrollbarWidth !== undefined ) { |
|
| |
819
| + return cachedScrollbarWidth; |
|
| |
820
| + } |
|
| |
821
| + var w1, w2, |
|
| |
822
| + div = $( "<div " + |
|
| |
823
| + "style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'>" + |
|
| |
824
| + "<div style='height:100px;width:auto;'></div></div>" ), |
|
| |
825
| + innerDiv = div.children()[ 0 ]; |
|
| |
826
| + |
|
| |
827
| + $( "body" ).append( div ); |
|
| |
828
| + w1 = innerDiv.offsetWidth; |
|
| |
829
| + div.css( "overflow", "scroll" ); |
|
| |
830
| + |
|
| |
831
| + w2 = innerDiv.offsetWidth; |
|
| |
832
| + |
|
| |
833
| + if ( w1 === w2 ) { |
|
| |
834
| + w2 = div[ 0 ].clientWidth; |
|
| |
835
| + } |
|
| |
836
| + |
|
| |
837
| + div.remove(); |
|
| |
838
| + |
|
| |
839
| + return ( cachedScrollbarWidth = w1 - w2 ); |
|
| |
840
| + }, |
|
| |
841
| + getScrollInfo: function( within ) { |
|
| |
842
| + var overflowX = within.isWindow || within.isDocument ? "" : |
|
| |
843
| + within.element.css( "overflow-x" ), |
|
| |
844
| + overflowY = within.isWindow || within.isDocument ? "" : |
|
| |
845
| + within.element.css( "overflow-y" ), |
|
| |
846
| + hasOverflowX = overflowX === "scroll" || |
|
| |
847
| + ( overflowX === "auto" && within.width < within.element[ 0 ].scrollWidth ), |
|
| |
848
| + hasOverflowY = overflowY === "scroll" || |
|
| |
849
| + ( overflowY === "auto" && within.height < within.element[ 0 ].scrollHeight ); |
|
| |
850
| + return { |
|
| |
851
| + width: hasOverflowY ? $.position.scrollbarWidth() : 0, |
|
| |
852
| + height: hasOverflowX ? $.position.scrollbarWidth() : 0 |
|
| |
853
| + }; |
|
| |
854
| + }, |
|
| |
855
| + getWithinInfo: function( element ) { |
|
| |
856
| + var withinElement = $( element || window ), |
|
| |
857
| + isWindow = $.isWindow( withinElement[ 0 ] ), |
|
| |
858
| + isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9, |
|
| |
859
| + hasOffset = !isWindow && !isDocument; |
|
| |
860
| + return { |
|
| |
861
| + element: withinElement, |
|
| |
862
| + isWindow: isWindow, |
|
| |
863
| + isDocument: isDocument, |
|
| |
864
| + offset: hasOffset ? $( element ).offset() : { left: 0, top: 0 }, |
|
| |
865
| + scrollLeft: withinElement.scrollLeft(), |
|
| |
866
| + scrollTop: withinElement.scrollTop(), |
|
| |
867
| + width: withinElement.outerWidth(), |
|
| |
868
| + height: withinElement.outerHeight() |
|
| |
869
| + }; |
|
| |
870
| + } |
|
| |
871
| +}; |
|
| |
872
| + |
|
| |
873
| +$.fn.position = function( options ) { |
|
| |
874
| + if ( !options || !options.of ) { |
|
| |
875
| + return _position.apply( this, arguments ); |
|
| |
876
| + } |
|
| |
877
| + |
|
| |
878
| + // Make a copy, we don't want to modify arguments |
|
| |
879
| + options = $.extend( {}, options ); |
|
| |
880
| + |
|
| |
881
| + var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions, |
|
| |
882
| + target = $( options.of ), |
|
| |
883
| + within = $.position.getWithinInfo( options.within ), |
|
| |
884
| + scrollInfo = $.position.getScrollInfo( within ), |
|
| |
885
| + collision = ( options.collision || "flip" ).split( " " ), |
|
| |
886
| + offsets = {}; |
|
| |
887
| + |
|
| |
888
| + dimensions = getDimensions( target ); |
|
| |
889
| + if ( target[ 0 ].preventDefault ) { |
|
| |
890
| + |
|
| |
891
| + // Force left top to allow flipping |
|
| |
892
| + options.at = "left top"; |
|
| |
893
| + } |
|
| |
894
| + targetWidth = dimensions.width; |
|
| |
895
| + targetHeight = dimensions.height; |
|
| |
896
| + targetOffset = dimensions.offset; |
|
| |
897
| + |
|
| |
898
| + // Clone to reuse original targetOffset later |
|
| |
899
| + basePosition = $.extend( {}, targetOffset ); |
|
| |
900
| + |
|
| |
901
| + // Force my and at to have valid horizontal and vertical positions |
|
| |
902
| + // if a value is missing or invalid, it will be converted to center |
|
| |
903
| + $.each( [ "my", "at" ], function() { |
|
| |
904
| + var pos = ( options[ this ] || "" ).split( " " ), |
|
| |
905
| + horizontalOffset, |
|
| |
906
| + verticalOffset; |
|
| |
907
| + |
|
| |
908
| + if ( pos.length === 1 ) { |
|
| |
909
| + pos = rhorizontal.test( pos[ 0 ] ) ? |
|
| |
910
| + pos.concat( [ "center" ] ) : |
|
| |
911
| + rvertical.test( pos[ 0 ] ) ? |
|
| |
912
| + [ "center" ].concat( pos ) : |
|
| |
913
| + [ "center", "center" ]; |
|
| |
914
| + } |
|
| |
915
| + pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center"; |
|
| |
916
| + pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center"; |
|
| |
917
| + |
|
| |
918
| + // Calculate offsets |
|
| |
919
| + horizontalOffset = roffset.exec( pos[ 0 ] ); |
|
| |
920
| + verticalOffset = roffset.exec( pos[ 1 ] ); |
|
| |
921
| + offsets[ this ] = [ |
|
| |
922
| + horizontalOffset ? horizontalOffset[ 0 ] : 0, |
|
| |
923
| + verticalOffset ? verticalOffset[ 0 ] : 0 |
|
| |
924
| + ]; |
|
| |
925
| + |
|
| |
926
| + // Reduce to just the positions without the offsets |
|
| |
927
| + options[ this ] = [ |
|
| |
928
| + rposition.exec( pos[ 0 ] )[ 0 ], |
|
| |
929
| + rposition.exec( pos[ 1 ] )[ 0 ] |
|
| |
930
| + ]; |
|
| |
931
| + } ); |
|
| |
932
| + |
|
| |
933
| + // Normalize collision option |
|
| |
934
| + if ( collision.length === 1 ) { |
|
| |
935
| + collision[ 1 ] = collision[ 0 ]; |
|
| |
936
| + } |
|
| |
937
| + |
|
| |
938
| + if ( options.at[ 0 ] === "right" ) { |
|
| |
939
| + basePosition.left += targetWidth; |
|
| |
940
| + } else if ( options.at[ 0 ] === "center" ) { |
|
| |
941
| + basePosition.left += targetWidth / 2; |
|
| |
942
| + } |
|
| |
943
| + |
|
| |
944
| + if ( options.at[ 1 ] === "bottom" ) { |
|
| |
945
| + basePosition.top += targetHeight; |
|
| |
946
| + } else if ( options.at[ 1 ] === "center" ) { |
|
| |
947
| + basePosition.top += targetHeight / 2; |
|
| |
948
| + } |
|
| |
949
| + |
|
| |
950
| + atOffset = getOffsets( offsets.at, targetWidth, targetHeight ); |
|
| |
951
| + basePosition.left += atOffset[ 0 ]; |
|
| |
952
| + basePosition.top += atOffset[ 1 ]; |
|
| |
953
| + |
|
| |
954
| + return this.each( function() { |
|
| |
955
| + var collisionPosition, using, |
|
| |
956
| + elem = $( this ), |
|
| |
957
| + elemWidth = elem.outerWidth(), |
|
| |
958
| + elemHeight = elem.outerHeight(), |
|
| |
959
| + marginLeft = parseCss( this, "marginLeft" ), |
|
| |
960
| + marginTop = parseCss( this, "marginTop" ), |
|
| |
961
| + collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + |
|
| |
962
| + scrollInfo.width, |
|
| |
963
| + collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + |
|
| |
964
| + scrollInfo.height, |
|
| |
965
| + position = $.extend( {}, basePosition ), |
|
| |
966
| + myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() ); |
|
| |
967
| + |
|
| |
968
| + if ( options.my[ 0 ] === "right" ) { |
|
| |
969
| + position.left -= elemWidth; |
|
| |
970
| + } else if ( options.my[ 0 ] === "center" ) { |
|
| |
971
| + position.left -= elemWidth / 2; |
|
| |
972
| + } |
|
| |
973
| + |
|
| |
974
| + if ( options.my[ 1 ] === "bottom" ) { |
|
| |
975
| + position.top -= elemHeight; |
|
| |
976
| + } else if ( options.my[ 1 ] === "center" ) { |
|
| |
977
| + position.top -= elemHeight / 2; |
|
| |
978
| + } |
|
| |
979
| + |
|
| |
980
| + position.left += myOffset[ 0 ]; |
|
| |
981
| + position.top += myOffset[ 1 ]; |
|
| |
982
| + |
|
| |
983
| + collisionPosition = { |
|
| |
984
| + marginLeft: marginLeft, |
|
| |
985
| + marginTop: marginTop |
|
| |
986
| + }; |
|
| |
987
| + |
|
| |
988
| + $.each( [ "left", "top" ], function( i, dir ) { |
|
| |
989
| + if ( $.ui.position[ collision[ i ] ] ) { |
|
| |
990
| + $.ui.position[ collision[ i ] ][ dir ]( position, { |
|
| |
991
| + targetWidth: targetWidth, |
|
| |
992
| + targetHeight: targetHeight, |
|
| |
993
| + elemWidth: elemWidth, |
|
| |
994
| + elemHeight: elemHeight, |
|
| |
995
| + collisionPosition: collisionPosition, |
|
| |
996
| + collisionWidth: collisionWidth, |
|
| |
997
| + collisionHeight: collisionHeight, |
|
| |
998
| + offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ], |
|
| |
999
| + my: options.my, |
|
| |
1000
| + at: options.at, |
|
| |
1001
| + within: within, |
|
| |
1002
| + elem: elem |
|
| |
1003
| + } ); |
|
| |
1004
| + } |
|
| |
1005
| + } ); |
|
| |
1006
| + |
|
| |
1007
| + if ( options.using ) { |
|
| |
1008
| + |
|
| |
1009
| + // Adds feedback as second argument to using callback, if present |
|
| |
1010
| + using = function( props ) { |
|
| |
1011
| + var left = targetOffset.left - position.left, |
|
| |
1012
| + right = left + targetWidth - elemWidth, |
|
| |
1013
| + top = targetOffset.top - position.top, |
|
| |
1014
| + bottom = top + targetHeight - elemHeight, |
|
| |
1015
| + feedback = { |
|
| |
1016
| + target: { |
|
| |
1017
| + element: target, |
|
| |
1018
| + left: targetOffset.left, |
|
| |
1019
| + top: targetOffset.top, |
|
| |
1020
| + width: targetWidth, |
|
| |
1021
| + height: targetHeight |
|
| |
1022
| + }, |
|
| |
1023
| + element: { |
|
| |
1024
| + element: elem, |
|
| |
1025
| + left: position.left, |
|
| |
1026
| + top: position.top, |
|
| |
1027
| + width: elemWidth, |
|
| |
1028
| + height: elemHeight |
|
| |
1029
| + }, |
|
| |
1030
| + horizontal: right < 0 ? "left" : left > 0 ? "right" : "center", |
|
| |
1031
| + vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle" |
|
| |
1032
| + }; |
|
| |
1033
| + if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) { |
|
| |
1034
| + feedback.horizontal = "center"; |
|
| |
1035
| + } |
|
| |
1036
| + if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) { |
|
| |
1037
| + feedback.vertical = "middle"; |
|
| |
1038
| + } |
|
| |
1039
| + if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) { |
|
| |
1040
| + feedback.important = "horizontal"; |
|
| |
1041
| + } else { |
|
| |
1042
| + feedback.important = "vertical"; |
|
| |
1043
| + } |
|
| |
1044
| + options.using.call( this, props, feedback ); |
|
| |
1045
| + }; |
|
| |
1046
| + } |
|
| |
1047
| + |
|
| |
1048
| + elem.offset( $.extend( position, { using: using } ) ); |
|
| |
1049
| + } ); |
|
| |
1050
| +}; |
|
| |
1051
| + |
|
| |
1052
| +$.ui.position = { |
|
| |
1053
| + fit: { |
|
| |
1054
| + left: function( position, data ) { |
|
| |
1055
| + var within = data.within, |
|
| |
1056
| + withinOffset = within.isWindow ? within.scrollLeft : within.offset.left, |
|
| |
1057
| + outerWidth = within.width, |
|
| |
1058
| + collisionPosLeft = position.left - data.collisionPosition.marginLeft, |
|
| |
1059
| + overLeft = withinOffset - collisionPosLeft, |
|
| |
1060
| + overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset, |
|
| |
1061
| + newOverRight; |
|
| |
1062
| + |
|
| |
1063
| + // Element is wider than within |
|
| |
1064
| + if ( data.collisionWidth > outerWidth ) { |
|
| |
1065
| + |
|
| |
1066
| + // Element is initially over the left side of within |
|
| |
1067
| + if ( overLeft > 0 && overRight <= 0 ) { |
|
| |
1068
| + newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - |
|
| |
1069
| + withinOffset; |
|
| |
1070
| + position.left += overLeft - newOverRight; |
|
| |
1071
| + |
|
| |
1072
| + // Element is initially over right side of within |
|
| |
1073
| + } else if ( overRight > 0 && overLeft <= 0 ) { |
|
| |
1074
| + position.left = withinOffset; |
|
| |
1075
| + |
|
| |
1076
| + // Element is initially over both left and right sides of within |
|
| |
1077
| + } else { |
|
| |
1078
| + if ( overLeft > overRight ) { |
|
| |
1079
| + position.left = withinOffset + outerWidth - data.collisionWidth; |
|
| |
1080
| + } else { |
|
| |
1081
| + position.left = withinOffset; |
|
| |
1082
| + } |
|
| |
1083
| + } |
|
| |
1084
| + |
|
| |
1085
| + // Too far left -> align with left edge |
|
| |
1086
| + } else if ( overLeft > 0 ) { |
|
| |
1087
| + position.left += overLeft; |
|
| |
1088
| + |
|
| |
1089
| + // Too far right -> align with right edge |
|
| |
1090
| + } else if ( overRight > 0 ) { |
|
| |
1091
| + position.left -= overRight; |
|
| |
1092
| + |
|
| |
1093
| + // Adjust based on position and margin |
|
| |
1094
| + } else { |
|
| |
1095
| + position.left = max( position.left - collisionPosLeft, position.left ); |
|
| |
1096
| + } |
|
| |
1097
| + }, |
|
| |
1098
| + top: function( position, data ) { |
|
| |
1099
| + var within = data.within, |
|
| |
1100
| + withinOffset = within.isWindow ? within.scrollTop : within.offset.top, |
|
| |
1101
| + outerHeight = data.within.height, |
|
| |
1102
| + collisionPosTop = position.top - data.collisionPosition.marginTop, |
|
| |
1103
| + overTop = withinOffset - collisionPosTop, |
|
| |
1104
| + overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset, |
|
| |
1105
| + newOverBottom; |
|
| |
1106
| + |
|
| |
1107
| + // Element is taller than within |
|
| |
1108
| + if ( data.collisionHeight > outerHeight ) { |
|
| |
1109
| + |
|
| |
1110
| + // Element is initially over the top of within |
|
| |
1111
| + if ( overTop > 0 && overBottom <= 0 ) { |
|
| |
1112
| + newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - |
|
| |
1113
| + withinOffset; |
|
| |
1114
| + position.top += overTop - newOverBottom; |
|
| |
1115
| + |
|
| |
1116
| + // Element is initially over bottom of within |
|
| |
1117
| + } else if ( overBottom > 0 && overTop <= 0 ) { |
|
| |
1118
| + position.top = withinOffset; |
|
| |
1119
| + |
|
| |
1120
| + // Element is initially over both top and bottom of within |
|
| |
1121
| + } else { |
|
| |
1122
| + if ( overTop > overBottom ) { |
|
| |
1123
| + position.top = withinOffset + outerHeight - data.collisionHeight; |
|
| |
1124
| + } else { |
|
| |
1125
| + position.top = withinOffset; |
|
| |
1126
| + } |
|
| |
1127
| + } |
|
| |
1128
| + |
|
| |
1129
| + // Too far up -> align with top |
|
| |
1130
| + } else if ( overTop > 0 ) { |
|
| |
1131
| + position.top += overTop; |
|
| |
1132
| + |
|
| |
1133
| + // Too far down -> align with bottom edge |
|
| |
1134
| + } else if ( overBottom > 0 ) { |
|
| |
1135
| + position.top -= overBottom; |
|
| |
1136
| + |
|
| |
1137
| + // Adjust based on position and margin |
|
| |
1138
| + } else { |
|
| |
1139
| + position.top = max( position.top - collisionPosTop, position.top ); |
|
| |
1140
| + } |
|
| |
1141
| + } |
|
| |
1142
| + }, |
|
| |
1143
| + flip: { |
|
| |
1144
| + left: function( position, data ) { |
|
| |
1145
| + var within = data.within, |
|
| |
1146
| + withinOffset = within.offset.left + within.scrollLeft, |
|
| |
1147
| + outerWidth = within.width, |
|
| |
1148
| + offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left, |
|
| |
1149
| + collisionPosLeft = position.left - data.collisionPosition.marginLeft, |
|
| |
1150
| + overLeft = collisionPosLeft - offsetLeft, |
|
| |
1151
| + overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft, |
|
| |
1152
| + myOffset = data.my[ 0 ] === "left" ? |
|
| |
1153
| + -data.elemWidth : |
|
| |
1154
| + data.my[ 0 ] === "right" ? |
|
| |
1155
| + data.elemWidth : |
|
| |
1156
| + 0, |
|
| |
1157
| + atOffset = data.at[ 0 ] === "left" ? |
|
| |
1158
| + data.targetWidth : |
|
| |
1159
| + data.at[ 0 ] === "right" ? |
|
| |
1160
| + -data.targetWidth : |
|
| |
1161
| + 0, |
|
| |
1162
| + offset = -2 * data.offset[ 0 ], |
|
| |
1163
| + newOverRight, |
|
| |
1164
| + newOverLeft; |
|
| |
1165
| + |
|
| |
1166
| + if ( overLeft < 0 ) { |
|
| |
1167
| + newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - |
|
| |
1168
| + outerWidth - withinOffset; |
|
| |
1169
| + if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) { |
|
| |
1170
| + position.left += myOffset + atOffset + offset; |
|
| |
1171
| + } |
|
| |
1172
| + } else if ( overRight > 0 ) { |
|
| |
1173
| + newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + |
|
| |
1174
| + atOffset + offset - offsetLeft; |
|
| |
1175
| + if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) { |
|
| |
1176
| + position.left += myOffset + atOffset + offset; |
|
| |
1177
| + } |
|
| |
1178
| + } |
|
| |
1179
| + }, |
|
| |
1180
| + top: function( position, data ) { |
|
| |
1181
| + var within = data.within, |
|
| |
1182
| + withinOffset = within.offset.top + within.scrollTop, |
|
| |
1183
| + outerHeight = within.height, |
|
| |
1184
| + offsetTop = within.isWindow ? within.scrollTop : within.offset.top, |
|
| |
1185
| + collisionPosTop = position.top - data.collisionPosition.marginTop, |
|
| |
1186
| + overTop = collisionPosTop - offsetTop, |
|
| |
1187
| + overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop, |
|
| |
1188
| + top = data.my[ 1 ] === "top", |
|
| |
1189
| + myOffset = top ? |
|
| |
1190
| + -data.elemHeight : |
|
| |
1191
| + data.my[ 1 ] === "bottom" ? |
|
| |
1192
| + data.elemHeight : |
|
| |
1193
| + 0, |
|
| |
1194
| + atOffset = data.at[ 1 ] === "top" ? |
|
| |
1195
| + data.targetHeight : |
|
| |
1196
| + data.at[ 1 ] === "bottom" ? |
|
| |
1197
| + -data.targetHeight : |
|
| |
1198
| + 0, |
|
| |
1199
| + offset = -2 * data.offset[ 1 ], |
|
| |
1200
| + newOverTop, |
|
| |
1201
| + newOverBottom; |
|
| |
1202
| + if ( overTop < 0 ) { |
|
| |
1203
| + newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - |
|
| |
1204
| + outerHeight - withinOffset; |
|
| |
1205
| + if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) { |
|
| |
1206
| + position.top += myOffset + atOffset + offset; |
|
| |
1207
| + } |
|
| |
1208
| + } else if ( overBottom > 0 ) { |
|
| |
1209
| + newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + |
|
| |
1210
| + offset - offsetTop; |
|
| |
1211
| + if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) { |
|
| |
1212
| + position.top += myOffset + atOffset + offset; |
|
| |
1213
| + } |
|
| |
1214
| + } |
|
| |
1215
| + } |
|
| |
1216
| + }, |
|
| |
1217
| + flipfit: { |
|
| |
1218
| + left: function() { |
|
| |
1219
| + $.ui.position.flip.left.apply( this, arguments ); |
|
| |
1220
| + $.ui.position.fit.left.apply( this, arguments ); |
|
| |
1221
| + }, |
|
| |
1222
| + top: function() { |
|
| |
1223
| + $.ui.position.flip.top.apply( this, arguments ); |
|
| |
1224
| + $.ui.position.fit.top.apply( this, arguments ); |
|
| |
1225
| + } |
|
| |
1226
| + } |
|
| |
1227
| +}; |
|
| |
1228
| + |
|
| |
1229
| +} )(); |
|
| |
1230
| + |
|
| |
1231
| +var position = $.ui.position; |
|
| |
1232
| + |
|
| |
1233
| + |
|
| |
1234
| +/*! |
|
| |
1235
| + * jQuery UI :data 1.12.1 |
|
| |
1236
| + * http://jqueryui.com |
|
| |
1237
| + * |
|
| |
1238
| + * Copyright jQuery Foundation and other contributors |
|
| |
1239
| + * Released under the MIT license. |
|
| |
1240
| + * http://jquery.org/license |
|
| |
1241
| + */ |
|
| |
1242
| + |
|
| |
1243
| +//>>label: :data Selector |
|
| |
1244
| +//>>group: Core |
|
| |
1245
| +//>>description: Selects elements which have data stored under the specified key. |
|
| |
1246
| +//>>docs: http://api.jqueryui.com/data-selector/ |
|
| |
1247
| + |
|
| |
1248
| + |
|
| |
1249
| +var data = $.extend( $.expr[ ":" ], { |
|
| |
1250
| + data: $.expr.createPseudo ? |
|
| |
1251
| + $.expr.createPseudo( function( dataName ) { |
|
| |
1252
| + return function( elem ) { |
|
| |
1253
| + return !!$.data( elem, dataName ); |
|
| |
1254
| + }; |
|
| |
1255
| + } ) : |
|
| |
1256
| + |
|
| |
1257
| + // Support: jQuery <1.8 |
|
| |
1258
| + function( elem, i, match ) { |
|
| |
1259
| + return !!$.data( elem, match[ 3 ] ); |
|
| |
1260
| + } |
|
| |
1261
| +} ); |
|
| |
1262
| + |
|
| |
1263
| +/*! |
|
| |
1264
| + * jQuery UI Disable Selection 1.12.1 |
|
| |
1265
| + * http://jqueryui.com |
|
| |
1266
| + * |
|
| |
1267
| + * Copyright jQuery Foundation and other contributors |
|
| |
1268
| + * Released under the MIT license. |
|
| |
1269
| + * http://jquery.org/license |
|
| |
1270
| + */ |
|
| |
1271
| + |
|
| |
1272
| +//>>label: disableSelection |
|
| |
1273
| +//>>group: Core |
|
| |
1274
| +//>>description: Disable selection of text content within the set of matched elements. |
|
| |
1275
| +//>>docs: http://api.jqueryui.com/disableSelection/ |
|
| |
1276
| + |
|
| |
1277
| +// This file is deprecated |
|
| |
1278
| + |
|
| |
1279
| + |
|
| |
1280
| +var disableSelection = $.fn.extend( { |
|
| |
1281
| + disableSelection: ( function() { |
|
| |
1282
| + var eventType = "onselectstart" in document.createElement( "div" ) ? |
|
| |
1283
| + "selectstart" : |
|
| |
1284
| + "mousedown"; |
|
| |
1285
| + |
|
| |
1286
| + return function() { |
|
| |
1287
| + return this.on( eventType + ".ui-disableSelection", function( event ) { |
|
| |
1288
| + event.preventDefault(); |
|
| |
1289
| + } ); |
|
| |
1290
| + }; |
|
| |
1291
| + } )(), |
|
| |
1292
| + |
|
| |
1293
| + enableSelection: function() { |
|
| |
1294
| + return this.off( ".ui-disableSelection" ); |
|
| |
1295
| + } |
|
| |
1296
| +} ); |
|
| |
1297
| + |
|
| |
1298
| + |
|
| |
1299
| +/*! |
|
| |
1300
| + * jQuery UI Focusable 1.12.1 |
|
| |
1301
| + * http://jqueryui.com |
|
| |
1302
| + * |
|
| |
1303
| + * Copyright jQuery Foundation and other contributors |
|
| |
1304
| + * Released under the MIT license. |
|
| |
1305
| + * http://jquery.org/license |
|
| |
1306
| + */ |
|
| |
1307
| + |
|
| |
1308
| +//>>label: :focusable Selector |
|
| |
1309
| +//>>group: Core |
|
| |
1310
| +//>>description: Selects elements which can be focused. |
|
| |
1311
| +//>>docs: http://api.jqueryui.com/focusable-selector/ |
|
| |
1312
| + |
|
| |
1313
| + |
|
| |
1314
| + |
|
| |
1315
| +// Selectors |
|
| |
1316
| +$.ui.focusable = function( element, hasTabindex ) { |
|
| |
1317
| + var map, mapName, img, focusableIfVisible, fieldset, |
|
| |
1318
| + nodeName = element.nodeName.toLowerCase(); |
|
| |
1319
| + |
|
| |
1320
| + if ( "area" === nodeName ) { |
|
| |
1321
| + map = element.parentNode; |
|
| |
1322
| + mapName = map.name; |
|
| |
1323
| + if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) { |
|
| |
1324
| + return false; |
|
| |
1325
| + } |
|
| |
1326
| + img = $( "img[usemap='#" + mapName + "']" ); |
|
| |
1327
| + return img.length > 0 && img.is( ":visible" ); |
|
| |
1328
| + } |
|
| |
1329
| + |
|
| |
1330
| + if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) { |
|
| |
1331
| + focusableIfVisible = !element.disabled; |
|
| |
1332
| + |
|
| |
1333
| + if ( focusableIfVisible ) { |
|
| |
1334
| + |
|
| |
1335
| + // Form controls within a disabled fieldset are disabled. |
|
| |
1336
| + // However, controls within the fieldset's legend do not get disabled. |
|
| |
1337
| + // Since controls generally aren't placed inside legends, we skip |
|
| |
1338
| + // this portion of the check. |
|
| |
1339
| + fieldset = $( element ).closest( "fieldset" )[ 0 ]; |
|
| |
1340
| + if ( fieldset ) { |
|
| |
1341
| + focusableIfVisible = !fieldset.disabled; |
|
| |
1342
| + } |
|
| |
1343
| + } |
|
| |
1344
| + } else if ( "a" === nodeName ) { |
|
| |
1345
| + focusableIfVisible = element.href || hasTabindex; |
|
| |
1346
| + } else { |
|
| |
1347
| + focusableIfVisible = hasTabindex; |
|
| |
1348
| + } |
|
| |
1349
| + |
|
| |
1350
| + return focusableIfVisible && $( element ).is( ":visible" ) && visible( $( element ) ); |
|
| |
1351
| +}; |
|
| |
1352
| + |
|
| |
1353
| +// Support: IE 8 only |
|
| |
1354
| +// IE 8 doesn't resolve inherit to visible/hidden for computed values |
|
| |
1355
| +function visible( element ) { |
|
| |
1356
| + var visibility = element.css( "visibility" ); |
|
| |
1357
| + while ( visibility === "inherit" ) { |
|
| |
1358
| + element = element.parent(); |
|
| |
1359
| + visibility = element.css( "visibility" ); |
|
| |
1360
| + } |
|
| |
1361
| + return visibility !== "hidden"; |
|
| |
1362
| +} |
|
| |
1363
| + |
|
| |
1364
| +$.extend( $.expr[ ":" ], { |
|
| |
1365
| + focusable: function( element ) { |
|
| |
1366
| + return $.ui.focusable( element, $.attr( element, "tabindex" ) != null ); |
|
| |
1367
| + } |
|
| |
1368
| +} ); |
|
| |
1369
| + |
|
| |
1370
| +var focusable = $.ui.focusable; |
|
| |
1371
| + |
|
| |
1372
| + |
|
| |
1373
| + |
|
| |
1374
| + |
|
| |
1375
| +// Support: IE8 Only |
|
| |
1376
| +// IE8 does not support the form attribute and when it is supplied. It overwrites the form prop |
|
| |
1377
| +// with a string, so we need to find the proper form. |
|
| |
1378
| +var form = $.fn.form = function() { |
|
| |
1379
| + return typeof this[ 0 ].form === "string" ? this.closest( "form" ) : $( this[ 0 ].form ); |
|
| |
1380
| +}; |
|
| |
1381
| + |
|
| |
1382
| + |
|
| |
1383
| +/*! |
|
| |
1384
| + * jQuery UI Form Reset Mixin 1.12.1 |
|
| |
1385
| + * http://jqueryui.com |
|
| |
1386
| + * |
|
| |
1387
| + * Copyright jQuery Foundation and other contributors |
|
| |
1388
| + * Released under the MIT license. |
|
| |
1389
| + * http://jquery.org/license |
|
| |
1390
| + */ |
|
| |
1391
| + |
|
| |
1392
| +//>>label: Form Reset Mixin |
|
| |
1393
| +//>>group: Core |
|
| |
1394
| +//>>description: Refresh input widgets when their form is reset |
|
| |
1395
| +//>>docs: http://api.jqueryui.com/form-reset-mixin/ |
|
| |
1396
| + |
|
| |
1397
| + |
|
| |
1398
| + |
|
| |
1399
| +var formResetMixin = $.ui.formResetMixin = { |
|
| |
1400
| + _formResetHandler: function() { |
|
| |
1401
| + var form = $( this ); |
|
| |
1402
| + |
|
| |
1403
| + // Wait for the form reset to actually happen before refreshing |
|
| |
1404
| + setTimeout( function() { |
|
| |
1405
| + var instances = form.data( "ui-form-reset-instances" ); |
|
| |
1406
| + $.each( instances, function() { |
|
| |
1407
| + this.refresh(); |
|
| |
1408
| + } ); |
|
| |
1409
| + } ); |
|
| |
1410
| + }, |
|
| |
1411
| + |
|
| |
1412
| + _bindFormResetHandler: function() { |
|
| |
1413
| + this.form = this.element.form(); |
|
| |
1414
| + if ( !this.form.length ) { |
|
| |
1415
| + return; |
|
| |
1416
| + } |
|
| |
1417
| + |
|
| |
1418
| + var instances = this.form.data( "ui-form-reset-instances" ) || []; |
|
| |
1419
| + if ( !instances.length ) { |
|
| |
1420
| + |
|
| |
1421
| + // We don't use _on() here because we use a single event handler per form |
|
| |
1422
| + this.form.on( "reset.ui-form-reset", this._formResetHandler ); |
|
| |
1423
| + } |
|
| |
1424
| + instances.push( this ); |
|
| |
1425
| + this.form.data( "ui-form-reset-instances", instances ); |
|
| |
1426
| + }, |
|
| |
1427
| + |
|
| |
1428
| + _unbindFormResetHandler: function() { |
|
| |
1429
| + if ( !this.form.length ) { |
|
| |
1430
| + return; |
|
| |
1431
| + } |
|
| |
1432
| + |
|
| |
1433
| + var instances = this.form.data( "ui-form-reset-instances" ); |
|
| |
1434
| + instances.splice( $.inArray( this, instances ), 1 ); |
|
| |
1435
| + if ( instances.length ) { |
|
| |
1436
| + this.form.data( "ui-form-reset-instances", instances ); |
|
| |
1437
| + } else { |
|
| |
1438
| + this.form |
|
| |
1439
| + .removeData( "ui-form-reset-instances" ) |
|
| |
1440
| + .off( "reset.ui-form-reset" ); |
|
| |
1441
| + } |
|
| |
1442
| + } |
|
| |
1443
| +}; |
|
| |
1444
| + |
|
| |
1445
| + |
|
| |
1446
| +/*! |
|
| |
1447
| + * jQuery UI Support for jQuery core 1.7.x 1.12.1 |
|
| |
1448
| + * http://jqueryui.com |
|
| |
1449
| + * |
|
| |
1450
| + * Copyright jQuery Foundation and other contributors |
|
| |
1451
| + * Released under the MIT license. |
|
| |
1452
| + * http://jquery.org/license |
|
| |
1453
| + * |
|
| |
1454
| + */ |
|
| |
1455
| + |
|
| |
1456
| +//>>label: jQuery 1.7 Support |
|
| |
1457
| +//>>group: Core |
|
| |
1458
| +//>>description: Support version 1.7.x of jQuery core |
|
| |
1459
| + |
|
| |
1460
| + |
|
| |
1461
| + |
|
| |
1462
| +// Support: jQuery 1.7 only |
|
| |
1463
| +// Not a great way to check versions, but since we only support 1.7+ and only |
|
| |
1464
| +// need to detect <1.8, this is a simple check that should suffice. Checking |
|
| |
1465
| +// for "1.7." would be a bit safer, but the version string is 1.7, not 1.7.0 |
|
| |
1466
| +// and we'll never reach 1.70.0 (if we do, we certainly won't be supporting |
|
| |
1467
| +// 1.7 anymore). See #11197 for why we're not using feature detection. |
|
| |
1468
| +if ( $.fn.jquery.substring( 0, 3 ) === "1.7" ) { |
|
| |
1469
| + |
|
| |
1470
| + // Setters for .innerWidth(), .innerHeight(), .outerWidth(), .outerHeight() |
|
| |
1471
| + // Unlike jQuery Core 1.8+, these only support numeric values to set the |
|
| |
1472
| + // dimensions in pixels |
|
| |
1473
| + $.each( [ "Width", "Height" ], function( i, name ) { |
|
| |
1474
| + var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ], |
|
| |
1475
| + type = name.toLowerCase(), |
|
| |
1476
| + orig = { |
|
| |
1477
| + innerWidth: $.fn.innerWidth, |
|
| |
1478
| + innerHeight: $.fn.innerHeight, |
|
| |
1479
| + outerWidth: $.fn.outerWidth, |
|
| |
1480
| + outerHeight: $.fn.outerHeight |
|
| |
1481
| + }; |
|
| |
1482
| + |
|
| |
1483
| + function reduce( elem, size, border, margin ) { |
|
| |
1484
| + $.each( side, function() { |
|
| |
1485
| + size -= parseFloat( $.css( elem, "padding" + this ) ) || 0; |
|
| |
1486
| + if ( border ) { |
|
| |
1487
| + size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0; |
|
| |
1488
| + } |
|
| |
1489
| + if ( margin ) { |
|
| |
1490
| + size -= parseFloat( $.css( elem, "margin" + this ) ) || 0; |
|
| |
1491
| + } |
|
| |
1492
| + } ); |
|
| |
1493
| + return size; |
|
| |
1494
| + } |
|
| |
1495
| + |
|
| |
1496
| + $.fn[ "inner" + name ] = function( size ) { |
|
| |
1497
| + if ( size === undefined ) { |
|
| |
1498
| + return orig[ "inner" + name ].call( this ); |
|
| |
1499
| + } |
|
| |
1500
| + |
|
| |
1501
| + return this.each( function() { |
|
| |
1502
| + $( this ).css( type, reduce( this, size ) + "px" ); |
|
| |
1503
| + } ); |
|
| |
1504
| + }; |
|
| |
1505
| + |
|
| |
1506
| + $.fn[ "outer" + name ] = function( size, margin ) { |
|
| |
1507
| + if ( typeof size !== "number" ) { |
|
| |
1508
| + return orig[ "outer" + name ].call( this, size ); |
|
| |
1509
| + } |
|
| |
1510
| + |
|
| |
1511
| + return this.each( function() { |
|
| |
1512
| + $( this ).css( type, reduce( this, size, true, margin ) + "px" ); |
|
| |
1513
| + } ); |
|
| |
1514
| + }; |
|
| |
1515
| + } ); |
|
| |
1516
| + |
|
| |
1517
| + $.fn.addBack = function( selector ) { |
|
| |
1518
| + return this.add( selector == null ? |
|
| |
1519
| + this.prevObject : this.prevObject.filter( selector ) |
|
| |
1520
| + ); |
|
| |
1521
| + }; |
|
| |
1522
| +} |
|
| |
1523
| + |
|
| |
1524
| +; |
|
| |
1525
| +/*! |
|
| |
1526
| + * jQuery UI Keycode 1.12.1 |
|
| |
1527
| + * http://jqueryui.com |
|
| |
1528
| + * |
|
| |
1529
| + * Copyright jQuery Foundation and other contributors |
|
| |
1530
| + * Released under the MIT license. |
|
| |
1531
| + * http://jquery.org/license |
|
| |
1532
| + */ |
|
| |
1533
| + |
|
| |
1534
| +//>>label: Keycode |
|
| |
1535
| +//>>group: Core |
|
| |
1536
| +//>>description: Provide keycodes as keynames |
|
| |
1537
| +//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/ |
|
| |
1538
| + |
|
| |
1539
| + |
|
| |
1540
| +var keycode = $.ui.keyCode = { |
|
| |
1541
| + BACKSPACE: 8, |
|
| |
1542
| + COMMA: 188, |
|
| |
1543
| + DELETE: 46, |
|
| |
1544
| + DOWN: 40, |
|
| |
1545
| + END: 35, |
|
| |
1546
| + ENTER: 13, |
|
| |
1547
| + ESCAPE: 27, |
|
| |
1548
| + HOME: 36, |
|
| |
1549
| + LEFT: 37, |
|
| |
1550
| + PAGE_DOWN: 34, |
|
| |
1551
| + PAGE_UP: 33, |
|
| |
1552
| + PERIOD: 190, |
|
| |
1553
| + RIGHT: 39, |
|
| |
1554
| + SPACE: 32, |
|
| |
1555
| + TAB: 9, |
|
| |
1556
| + UP: 38 |
|
| |
1557
| +}; |
|
| |
1558
| + |
|
| |
1559
| + |
|
| |
1560
| + |
|
| |
1561
| + |
|
| |
1562
| +// Internal use only |
|
| |
1563
| +var escapeSelector = $.ui.escapeSelector = ( function() { |
|
| |
1564
| + var selectorEscape = /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g; |
|
| |
1565
| + return function( selector ) { |
|
| |
1566
| + return selector.replace( selectorEscape, "\\$1" ); |
|
| |
1567
| + }; |
|
| |
1568
| +} )(); |
|
| |
1569
| + |
|
| |
1570
| + |
|
| |
1571
| +/*! |
|
| |
1572
| + * jQuery UI Labels 1.12.1 |
|
| |
1573
| + * http://jqueryui.com |
|
| |
1574
| + * |
|
| |
1575
| + * Copyright jQuery Foundation and other contributors |
|
| |
1576
| + * Released under the MIT license. |
|
| |
1577
| + * http://jquery.org/license |
|
| |
1578
| + */ |
|
| |
1579
| + |
|
| |
1580
| +//>>label: labels |
|
| |
1581
| +//>>group: Core |
|
| |
1582
| +//>>description: Find all the labels associated with a given input |
|
| |
1583
| +//>>docs: http://api.jqueryui.com/labels/ |
|
| |
1584
| + |
|
| |
1585
| + |
|
| |
1586
| + |
|
| |
1587
| +var labels = $.fn.labels = function() { |
|
| |
1588
| + var ancestor, selector, id, labels, ancestors; |
|
| |
1589
| + |
|
| |
1590
| + // Check control.labels first |
|
| |
1591
| + if ( this[ 0 ].labels && this[ 0 ].labels.length ) { |
|
| |
1592
| + return this.pushStack( this[ 0 ].labels ); |
|
| |
1593
| + } |
|
| |
1594
| + |
|
| |
1595
| + // Support: IE <= 11, FF <= 37, Android <= 2.3 only |
|
| |
1596
| + // Above browsers do not support control.labels. Everything below is to support them |
|
| |
1597
| + // as well as document fragments. control.labels does not work on document fragments |
|
| |
1598
| + labels = this.eq( 0 ).parents( "label" ); |
|
| |
1599
| + |
|
| |
1600
| + // Look for the label based on the id |
|
| |
1601
| + id = this.attr( "id" ); |
|
| |
1602
| + if ( id ) { |
|
| |
1603
| + |
|
| |
1604
| + // We don't search against the document in case the element |
|
| |
1605
| + // is disconnected from the DOM |
|
| |
1606
| + ancestor = this.eq( 0 ).parents().last(); |
|
| |
1607
| + |
|
| |
1608
| + // Get a full set of top level ancestors |
|
| |
1609
| + ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() ); |
|
| |
1610
| + |
|
| |
1611
| + // Create a selector for the label based on the id |
|
| |
1612
| + selector = "label[for='" + $.ui.escapeSelector( id ) + "']"; |
|
| |
1613
| + |
|
| |
1614
| + labels = labels.add( ancestors.find( selector ).addBack( selector ) ); |
|
| |
1615
| + |
|
| |
1616
| + } |
|
| |
1617
| + |
|
| |
1618
| + // Return whatever we have found for labels |
|
| |
1619
| + return this.pushStack( labels ); |
|
| |
1620
| +}; |
|
| |
1621
| + |
|
| |
1622
| + |
|
| |
1623
| +/*! |
|
| |
1624
| + * jQuery UI Scroll Parent 1.12.1 |
|
| |
1625
| + * http://jqueryui.com |
|
| |
1626
| + * |
|
| |
1627
| + * Copyright jQuery Foundation and other contributors |
|
| |
1628
| + * Released under the MIT license. |
|
| |
1629
| + * http://jquery.org/license |
|
| |
1630
| + */ |
|
| |
1631
| + |
|
| |
1632
| +//>>label: scrollParent |
|
| |
1633
| +//>>group: Core |
|
| |
1634
| +//>>description: Get the closest ancestor element that is scrollable. |
|
| |
1635
| +//>>docs: http://api.jqueryui.com/scrollParent/ |
|
| |
1636
| + |
|
| |
1637
| + |
|
| |
1638
| + |
|
| |
1639
| +var scrollParent = $.fn.scrollParent = function( includeHidden ) { |
|
| |
1640
| + var position = this.css( "position" ), |
|
| |
1641
| + excludeStaticParent = position === "absolute", |
|
| |
1642
| + overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/, |
|
| |
1643
| + scrollParent = this.parents().filter( function() { |
|
| |
1644
| + var parent = $( this ); |
|
| |
1645
| + if ( excludeStaticParent && parent.css( "position" ) === "static" ) { |
|
| |
1646
| + return false; |
|
| |
1647
| + } |
|
| |
1648
| + return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + |
|
| |
1649
| + parent.css( "overflow-x" ) ); |
|
| |
1650
| + } ).eq( 0 ); |
|
| |
1651
| + |
|
| |
1652
| + return position === "fixed" || !scrollParent.length ? |
|
| |
1653
| + $( this[ 0 ].ownerDocument || document ) : |
|
| |
1654
| + scrollParent; |
|
| |
1655
| +}; |
|
| |
1656
| + |
|
| |
1657
| + |
|
| |
1658
| +/*! |
|
| |
1659
| + * jQuery UI Tabbable 1.12.1 |
|
| |
1660
| + * http://jqueryui.com |
|
| |
1661
| + * |
|
| |
1662
| + * Copyright jQuery Foundation and other contributors |
|
| |
1663
| + * Released under the MIT license. |
|
| |
1664
| + * http://jquery.org/license |
|
| |
1665
| + */ |
|
| |
1666
| + |
|
| |
1667
| +//>>label: :tabbable Selector |
|
| |
1668
| +//>>group: Core |
|
| |
1669
| +//>>description: Selects elements which can be tabbed to. |
|
| |
1670
| +//>>docs: http://api.jqueryui.com/tabbable-selector/ |
|
| |
1671
| + |
|
| |
1672
| + |
|
| |
1673
| + |
|
| |
1674
| +var tabbable = $.extend( $.expr[ ":" ], { |
|
| |
1675
| + tabbable: function( element ) { |
|
| |
1676
| + var tabIndex = $.attr( element, "tabindex" ), |
|
| |
1677
| + hasTabindex = tabIndex != null; |
|
| |
1678
| + return ( !hasTabindex || tabIndex >= 0 ) && $.ui.focusable( element, hasTabindex ); |
|
| |
1679
| + } |
|
| |
1680
| +} ); |
|
| |
1681
| + |
|
| |
1682
| + |
|
| |
1683
| +/*! |
|
| |
1684
| + * jQuery UI Unique ID 1.12.1 |
|
| |
1685
| + * http://jqueryui.com |
|
| |
1686
| + * |
|
| |
1687
| + * Copyright jQuery Foundation and other contributors |
|
| |
1688
| + * Released under the MIT license. |
|
| |
1689
| + * http://jquery.org/license |
|
| |
1690
| + */ |
|
| |
1691
| + |
|
| |
1692
| +//>>label: uniqueId |
|
| |
1693
| +//>>group: Core |
|
| |
1694
| +//>>description: Functions to generate and remove uniqueId's |
|
| |
1695
| +//>>docs: http://api.jqueryui.com/uniqueId/ |
|
| |
1696
| + |
|
| |
1697
| + |
|
| |
1698
| + |
|
| |
1699
| +var uniqueId = $.fn.extend( { |
|
| |
1700
| + uniqueId: ( function() { |
|
| |
1701
| + var uuid = 0; |
|
| |
1702
| + |
|
| |
1703
| + return function() { |
|
| |
1704
| + return this.each( function() { |
|
| |
1705
| + if ( !this.id ) { |
|
| |
1706
| + this.id = "ui-id-" + ( ++uuid ); |
|
| |
1707
| + } |
|
| |
1708
| + } ); |
|
| |
1709
| + }; |
|
| |
1710
| + } )(), |
|
| |
1711
| + |
|
| |
1712
| + removeUniqueId: function() { |
|
| |
1713
| + return this.each( function() { |
|
| |
1714
| + if ( /^ui-id-\d+$/.test( this.id ) ) { |
|
| |
1715
| + $( this ).removeAttr( "id" ); |
|
| |
1716
| + } |
|
| |
1717
| + } ); |
|
| |
1718
| + } |
|
| |
1719
| +} ); |
|
| |
1720
| + |
|
| |
1721
| + |
|
| |
1722
| +// jscs:disable maximumLineLength |
|
| |
1723
| +/* jscs:disable requireCamelCaseOrUpperCaseIdentifiers */ |
|
| |
1724
| +/*! |
|
| |
1725
| + * jQuery UI Datepicker 1.12.1 |
|
| |
1726
| + * http://jqueryui.com |
|
| |
1727
| + * |
|
| |
1728
| + * Copyright jQuery Foundation and other contributors |
|
| |
1729
| + * Released under the MIT license. |
|
| |
1730
| + * http://jquery.org/license |
|
| |
1731
| + */ |
|
| |
1732
| + |
|
| |
1733
| +//>>label: Datepicker |
|
| |
1734
| +//>>group: Widgets |
|
| |
1735
| +//>>description: Displays a calendar from an input or inline for selecting dates. |
|
| |
1736
| +//>>docs: http://api.jqueryui.com/datepicker/ |
|
| |
1737
| +//>>demos: http://jqueryui.com/datepicker/ |
|
| |
1738
| +//>>css.structure: ../../themes/base/core.css |
|
| |
1739
| +//>>css.structure: ../../themes/base/datepicker.css |
|
| |
1740
| +//>>css.theme: ../../themes/base/theme.css |
|
| |
1741
| + |
|
| |
1742
| + |
|
| |
1743
| + |
|
| |
1744
| +$.extend( $.ui, { datepicker: { version: "1.12.1" } } ); |
|
| |
1745
| + |
|
| |
1746
| +var datepicker_instActive; |
|
| |
1747
| + |
|
| |
1748
| +function datepicker_getZindex( elem ) { |
|
| |
1749
| + var position, value; |
|
| |
1750
| + while ( elem.length && elem[ 0 ] !== document ) { |
|
| |
1751
| + |
|
| |
1752
| + // Ignore z-index if position is set to a value where z-index is ignored by the browser |
|
| |
1753
| + // This makes behavior of this function consistent across browsers |
|
| |
1754
| + // WebKit always returns auto if the element is positioned |
|
| |
1755
| + position = elem.css( "position" ); |
|
| |
1756
| + if ( position === "absolute" || position === "relative" || position === "fixed" ) { |
|
| |
1757
| + |
|
| |
1758
| + // IE returns 0 when zIndex is not specified |
|
| |
1759
| + // other browsers return a string |
|
| |
1760
| + // we ignore the case of nested elements with an explicit value of 0 |
|
| |
1761
| + // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> |
|
| |
1762
| + value = parseInt( elem.css( "zIndex" ), 10 ); |
|
| |
1763
| + if ( !isNaN( value ) && value !== 0 ) { |
|
| |
1764
| + return value; |
|
| |
1765
| + } |
|
| |
1766
| + } |
|
| |
1767
| + elem = elem.parent(); |
|
| |
1768
| + } |
|
| |
1769
| + |
|
| |
1770
| + return 0; |
|
| |
1771
| +} |
|
| |
1772
| +/* Date picker manager. |
|
| |
1773
| + Use the singleton instance of this class, $.datepicker, to interact with the date picker. |
|
| |
1774
| + Settings for (groups of) date pickers are maintained in an instance object, |
|
| |
1775
| + allowing multiple different settings on the same page. */ |
|
| |
1776
| + |
|
| |
1777
| +function Datepicker() { |
|
| |
1778
| + this._curInst = null; // The current instance in use |
|
| |
1779
| + this._keyEvent = false; // If the last event was a key event |
|
| |
1780
| + this._disabledInputs = []; // List of date picker inputs that have been disabled |
|
| |
1781
| + this._datepickerShowing = false; // True if the popup picker is showing , false if not |
|
| |
1782
| + this._inDialog = false; // True if showing within a "dialog", false if not |
|
| |
1783
| + this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division |
|
| |
1784
| + this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class |
|
| |
1785
| + this._appendClass = "ui-datepicker-append"; // The name of the append marker class |
|
| |
1786
| + this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class |
|
| |
1787
| + this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class |
|
| |
1788
| + this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class |
|
| |
1789
| + this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class |
|
| |
1790
| + this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class |
|
| |
1791
| + this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class |
|
| |
1792
| + this.regional = []; // Available regional settings, indexed by language code |
|
| |
1793
| + this.regional[ "" ] = { // Default regional settings |
|
| |
1794
| + closeText: "Done", // Display text for close link |
|
| |
1795
| + prevText: "Prev", // Display text for previous month link |
|
| |
1796
| + nextText: "Next", // Display text for next month link |
|
| |
1797
| + currentText: "Today", // Display text for current month link |
|
| |
1798
| + monthNames: [ "January","February","March","April","May","June", |
|
| |
1799
| + "July","August","September","October","November","December" ], // Names of months for drop-down and formatting |
|
| |
1800
| + monthNamesShort: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ], // For formatting |
|
| |
1801
| + dayNames: [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ], // For formatting |
|
| |
1802
| + dayNamesShort: [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ], // For formatting |
|
| |
1803
| + dayNamesMin: [ "Su","Mo","Tu","We","Th","Fr","Sa" ], // Column headings for days starting at Sunday |
|
| |
1804
| + weekHeader: "Wk", // Column header for week of the year |
|
| |
1805
| + dateFormat: "mm/dd/yy", // See format options on parseDate |
|
| |
1806
| + firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ... |
|
| |
1807
| + isRTL: false, // True if right-to-left language, false if left-to-right |
|
| |
1808
| + showMonthAfterYear: false, // True if the year select precedes month, false for month then year |
|
| |
1809
| + yearSuffix: "" // Additional text to append to the year in the month headers |
|
| |
1810
| + }; |
|
| |
1811
| + this._defaults = { // Global defaults for all the date picker instances |
|
| |
1812
| + showOn: "focus", // "focus" for popup on focus, |
|
| |
1813
| + // "button" for trigger button, or "both" for either |
|
| |
1814
| + showAnim: "fadeIn", // Name of jQuery animation for popup |
|
| |
1815
| + showOptions: {}, // Options for enhanced animations |
|
| |
1816
| + defaultDate: null, // Used when field is blank: actual date, |
|
| |
1817
| + // +/-number for offset from today, null for today |
|
| |
1818
| + appendText: "", // Display text following the input box, e.g. showing the format |
|
| |
1819
| + buttonText: "...", // Text for trigger button |
|
| |
1820
| + buttonImage: "", // URL for trigger button image |
|
| |
1821
| + buttonImageOnly: false, // True if the image appears alone, false if it appears on a button |
|
| |
1822
| + hideIfNoPrevNext: false, // True to hide next/previous month links |
|
| |
1823
| + // if not applicable, false to just disable them |
|
| |
1824
| + navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links |
|
| |
1825
| + gotoCurrent: false, // True if today link goes back to current selection instead |
|
| |
1826
| + changeMonth: false, // True if month can be selected directly, false if only prev/next |
|
| |
1827
| + changeYear: false, // True if year can be selected directly, false if only prev/next |
|
| |
1828
| + yearRange: "c-10:c+10", // Range of years to display in drop-down, |
|
| |
1829
| + // either relative to today's year (-nn:+nn), relative to currently displayed year |
|
| |
1830
| + // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n) |
|
| |
1831
| + showOtherMonths: false, // True to show dates in other months, false to leave blank |
|
| |
1832
| + selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable |
|
| |
1833
| + showWeek: false, // True to show week of the year, false to not show it |
|
| |
1834
| + calculateWeek: this.iso8601Week, // How to calculate the week of the year, |
|
| |
1835
| + // takes a Date and returns the number of the week for it |
|
| |
1836
| + shortYearCutoff: "+10", // Short year values < this are in the current century, |
|
| |
1837
| + // > this are in the previous century, |
|
| |
1838
| + // string value starting with "+" for current year + value |
|
| |
1839
| + minDate: null, // The earliest selectable date, or null for no limit |
|
| |
1840
| + maxDate: null, // The latest selectable date, or null for no limit |
|
| |
1841
| + duration: "fast", // Duration of display/closure |
|
| |
1842
| + beforeShowDay: null, // Function that takes a date and returns an array with |
|
| |
1843
| + // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "", |
|
| |
1844
| + // [2] = cell title (optional), e.g. $.datepicker.noWeekends |
|
| |
1845
| + beforeShow: null, // Function that takes an input field and |
|
| |
1846
| + // returns a set of custom settings for the date picker |
|
| |
1847
| + onSelect: null, // Define a callback function when a date is selected |
|
| |
1848
| + onChangeMonthYear: null, // Define a callback function when the month or year is changed |
|
| |
1849
| + onClose: null, // Define a callback function when the datepicker is closed |
|
| |
1850
| + numberOfMonths: 1, // Number of months to show at a time |
|
| |
1851
| + showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0) |
|
| |
1852
| + stepMonths: 1, // Number of months to step back/forward |
|
| |
1853
| + stepBigMonths: 12, // Number of months to step back/forward for the big links |
|
| |
1854
| + altField: "", // Selector for an alternate field to store selected dates into |
|
| |
1855
| + altFormat: "", // The date format to use for the alternate field |
|
| |
1856
| + constrainInput: true, // The input is constrained by the current date format |
|
| |
1857
| + showButtonPanel: false, // True to show button panel, false to not show it |
|
| |
1858
| + autoSize: false, // True to size the input for the date format, false to leave as is |
|
| |
1859
| + disabled: false // The initial disabled state |
|
| |
1860
| + }; |
|
| |
1861
| + $.extend( this._defaults, this.regional[ "" ] ); |
|
| |
1862
| + this.regional.en = $.extend( true, {}, this.regional[ "" ] ); |
|
| |
1863
| + this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en ); |
|
| |
1864
| + this.dpDiv = datepicker_bindHover( $( "<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>" ) ); |
|
| |
1865
| +} |
|
| |
1866
| + |
|
| |
1867
| +$.extend( Datepicker.prototype, { |
|
| |
1868
| + /* Class name added to elements to indicate already configured with a date picker. */ |
|
| |
1869
| + markerClassName: "hasDatepicker", |
|
| |
1870
| + |
|
| |
1871
| + //Keep track of the maximum number of rows displayed (see #7043) |
|
| |
1872
| + maxRows: 4, |
|
| |
1873
| + |
|
| |
1874
| + // TODO rename to "widget" when switching to widget factory |
|
| |
1875
| + _widgetDatepicker: function() { |
|
| |
1876
| + return this.dpDiv; |
|
| |
1877
| + }, |
|
| |
1878
| + |
|
| |
1879
| + /* Override the default settings for all instances of the date picker. |
|
| |
1880
| + * @param settings object - the new settings to use as defaults (anonymous object) |
|
| |
1881
| + * @return the manager object |
|
| |
1882
| + */ |
|
| |
1883
| + setDefaults: function( settings ) { |
|
| |
1884
| + datepicker_extendRemove( this._defaults, settings || {} ); |
|
| |
1885
| + return this; |
|
| |
1886
| + }, |
|
| |
1887
| + |
|
| |
1888
| + /* Attach the date picker to a jQuery selection. |
|
| |
1889
| + * @param target element - the target input field or division or span |
|
| |
1890
| + * @param settings object - the new settings to use for this date picker instance (anonymous) |
|
| |
1891
| + */ |
|
| |
1892
| + _attachDatepicker: function( target, settings ) { |
|
| |
1893
| + var nodeName, inline, inst; |
|
| |
1894
| + nodeName = target.nodeName.toLowerCase(); |
|
| |
1895
| + inline = ( nodeName === "div" || nodeName === "span" ); |
|
| |
1896
| + if ( !target.id ) { |
|
| |
1897
| + this.uuid += 1; |
|
| |
1898
| + target.id = "dp" + this.uuid; |
|
| |
1899
| + } |
|
| |
1900
| + inst = this._newInst( $( target ), inline ); |
|
| |
1901
| + inst.settings = $.extend( {}, settings || {} ); |
|
| |
1902
| + if ( nodeName === "input" ) { |
|
| |
1903
| + this._connectDatepicker( target, inst ); |
|
| |
1904
| + } else if ( inline ) { |
|
| |
1905
| + this._inlineDatepicker( target, inst ); |
|
| |
1906
| + } |
|
| |
1907
| + }, |
|
| |
1908
| + |
|
| |
1909
| + /* Create a new instance object. */ |
|
| |
1910
| + _newInst: function( target, inline ) { |
|
| |
1911
| + var id = target[ 0 ].id.replace( /([^A-Za-z0-9_\-])/g, "\\\\$1" ); // escape jQuery meta chars |
|
| |
1912
| + return { id: id, input: target, // associated target |
|
| |
1913
| + selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection |
|
| |
1914
| + drawMonth: 0, drawYear: 0, // month being drawn |
|
| |
1915
| + inline: inline, // is datepicker inline or not |
|
| |
1916
| + dpDiv: ( !inline ? this.dpDiv : // presentation div |
|
| |
1917
| + datepicker_bindHover( $( "<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>" ) ) ) }; |
|
| |
1918
| + }, |
|
| |
1919
| + |
|
| |
1920
| + /* Attach the date picker to an input field. */ |
|
| |
1921
| + _connectDatepicker: function( target, inst ) { |
|
| |
1922
| + var input = $( target ); |
|
| |
1923
| + inst.append = $( [] ); |
|
| |
1924
| + inst.trigger = $( [] ); |
|
| |
1925
| + if ( input.hasClass( this.markerClassName ) ) { |
|
| |
1926
| + return; |
|
| |
1927
| + } |
|
| |
1928
| + this._attachments( input, inst ); |
|
| |
1929
| + input.addClass( this.markerClassName ).on( "keydown", this._doKeyDown ). |
|
| |
1930
| + on( "keypress", this._doKeyPress ).on( "keyup", this._doKeyUp ); |
|
| |
1931
| + this._autoSize( inst ); |
|
| |
1932
| + $.data( target, "datepicker", inst ); |
|
| |
1933
| + |
|
| |
1934
| + //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665) |
|
| |
1935
| + if ( inst.settings.disabled ) { |
|
| |
1936
| + this._disableDatepicker( target ); |
|
| |
1937
| + } |
|
| |
1938
| + }, |
|
| |
1939
| + |
|
| |
1940
| + /* Make attachments based on settings. */ |
|
| |
1941
| + _attachments: function( input, inst ) { |
|
| |
1942
| + var showOn, buttonText, buttonImage, |
|
| |
1943
| + appendText = this._get( inst, "appendText" ), |
|
| |
1944
| + isRTL = this._get( inst, "isRTL" ); |
|
| |
1945
| + |
|
| |
1946
| + if ( inst.append ) { |
|
| |
1947
| + inst.append.remove(); |
|
| |
1948
| + } |
|
| |
1949
| + if ( appendText ) { |
|
| |
1950
| + inst.append = $( "<span class='" + this._appendClass + "'>" + appendText + "</span>" ); |
|
| |
1951
| + input[ isRTL ? "before" : "after" ]( inst.append ); |
|
| |
1952
| + } |
|
| |
1953
| + |
|
| |
1954
| + input.off( "focus", this._showDatepicker ); |
|
| |
1955
| + |
|
| |
1956
| + if ( inst.trigger ) { |
|
| |
1957
| + inst.trigger.remove(); |
|
| |
1958
| + } |
|
| |
1959
| + |
|
| |
1960
| + showOn = this._get( inst, "showOn" ); |
|
| |
1961
| + if ( showOn === "focus" || showOn === "both" ) { // pop-up date picker when in the marked field |
|
| |
1962
| + input.on( "focus", this._showDatepicker ); |
|
| |
1963
| + } |
|
| |
1964
| + if ( showOn === "button" || showOn === "both" ) { // pop-up date picker when button clicked |
|
| |
1965
| + buttonText = this._get( inst, "buttonText" ); |
|
| |
1966
| + buttonImage = this._get( inst, "buttonImage" ); |
|
| |
1967
| + inst.trigger = $( this._get( inst, "buttonImageOnly" ) ? |
|
| |
1968
| + $( "<img/>" ).addClass( this._triggerClass ). |
|
| |
1969
| + attr( { src: buttonImage, alt: buttonText, title: buttonText } ) : |
|
| |
1970
| + $( "<button type='button'></button>" ).addClass( this._triggerClass ). |
|
| |
1971
| + html( !buttonImage ? buttonText : $( "<img/>" ).attr( |
|
| |
1972
| + { src:buttonImage, alt:buttonText, title:buttonText } ) ) ); |
|
| |
1973
| + input[ isRTL ? "before" : "after" ]( inst.trigger ); |
|
| |
1974
| + inst.trigger.on( "click", function() { |
|
| |
1975
| + if ( $.datepicker._datepickerShowing && $.datepicker._lastInput === input[ 0 ] ) { |
|
| |
1976
| + $.datepicker._hideDatepicker(); |
|
| |
1977
| + } else if ( $.datepicker._datepickerShowing && $.datepicker._lastInput !== input[ 0 ] ) { |
|
| |
1978
| + $.datepicker._hideDatepicker(); |
|
| |
1979
| + $.datepicker._showDatepicker( input[ 0 ] ); |
|
| |
1980
| + } else { |
|
| |
1981
| + $.datepicker._showDatepicker( input[ 0 ] ); |
|
| |
1982
| + } |
|
| |
1983
| + return false; |
|
| |
1984
| + } ); |
|
| |
1985
| + } |
|
| |
1986
| + }, |
|
| |
1987
| + |
|
| |
1988
| + /* Apply the maximum length for the date format. */ |
|
| |
1989
| + _autoSize: function( inst ) { |
|
| |
1990
| + if ( this._get( inst, "autoSize" ) && !inst.inline ) { |
|
| |
1991
| + var findMax, max, maxI, i, |
|
| |
1992
| + date = new Date( 2009, 12 - 1, 20 ), // Ensure double digits |
|
| |
1993
| + dateFormat = this._get( inst, "dateFormat" ); |
|
| |
1994
| + |
|
| |
1995
| + if ( dateFormat.match( /[DM]/ ) ) { |
|
| |
1996
| + findMax = function( names ) { |
|
| |
1997
| + max = 0; |
|
| |
1998
| + maxI = 0; |
|
| |
1999
| + for ( i = 0; i < names.length; i++ ) { |
|
| |
2000
| + if ( names[ i ].length > max ) { |
|
| |
2001
| + max = names[ i ].length; |
|
| |
2002
| + maxI = i; |
|
| |
2003
| + } |
|
| |
2004
| + } |
|
| |
2005
| + return maxI; |
|
| |
2006
| + }; |
|
| |
2007
| + date.setMonth( findMax( this._get( inst, ( dateFormat.match( /MM/ ) ? |
|
| |
2008
| + "monthNames" : "monthNamesShort" ) ) ) ); |
|
| |
2009
| + date.setDate( findMax( this._get( inst, ( dateFormat.match( /DD/ ) ? |
|
| |
2010
| + "dayNames" : "dayNamesShort" ) ) ) + 20 - date.getDay() ); |
|
| |
2011
| + } |
|
| |
2012
| + inst.input.attr( "size", this._formatDate( inst, date ).length ); |
|
| |
2013
| + } |
|
| |
2014
| + }, |
|
| |
2015
| + |
|
| |
2016
| + /* Attach an inline date picker to a div. */ |
|
| |
2017
| + _inlineDatepicker: function( target, inst ) { |
|
| |
2018
| + var divSpan = $( target ); |
|
| |
2019
| + if ( divSpan.hasClass( this.markerClassName ) ) { |
|
| |
2020
| + return; |
|
| |
2021
| + } |
|
| |
2022
| + divSpan.addClass( this.markerClassName ).append( inst.dpDiv ); |
|
| |
2023
| + $.data( target, "datepicker", inst ); |
|
| |
2024
| + this._setDate( inst, this._getDefaultDate( inst ), true ); |
|
| |
2025
| + this._updateDatepicker( inst ); |
|
| |
2026
| + this._updateAlternate( inst ); |
|
| |
2027
| + |
|
| |
2028
| + //If disabled option is true, disable the datepicker before showing it (see ticket #5665) |
|
| |
2029
| + if ( inst.settings.disabled ) { |
|
| |
2030
| + this._disableDatepicker( target ); |
|
| |
2031
| + } |
|
| |
2032
| + |
|
| |
2033
| + // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements |
|
| |
2034
| + // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height |
|
| |
2035
| + inst.dpDiv.css( "display", "block" ); |
|
| |
2036
| + }, |
|
| |
2037
| + |
|
| |
2038
| + /* Pop-up the date picker in a "dialog" box. |
|
| |
2039
| + * @param input element - ignored |
|
| |
2040
| + * @param date string or Date - the initial date to display |
|
| |
2041
| + * @param onSelect function - the function to call when a date is selected |
|
| |
2042
| + * @param settings object - update the dialog date picker instance's settings (anonymous object) |
|
| |
2043
| + * @param pos int[2] - coordinates for the dialog's position within the screen or |
|
| |
2044
| + * event - with x/y coordinates or |
|
| |
2045
| + * leave empty for default (screen centre) |
|
| |
2046
| + * @return the manager object |
|
| |
2047
| + */ |
|
| |
2048
| + _dialogDatepicker: function( input, date, onSelect, settings, pos ) { |
|
| |
2049
| + var id, browserWidth, browserHeight, scrollX, scrollY, |
|
| |
2050
| + inst = this._dialogInst; // internal instance |
|
| |
2051
| + |
|
| |
2052
| + if ( !inst ) { |
|
| |
2053
| + this.uuid += 1; |
|
| |
2054
| + id = "dp" + this.uuid; |
|
| |
2055
| + this._dialogInput = $( "<input type='text' id='" + id + |
|
| |
2056
| + "' style='position: absolute; top: -100px; width: 0px;'/>" ); |
|
| |
2057
| + this._dialogInput.on( "keydown", this._doKeyDown ); |
|
| |
2058
| + $( "body" ).append( this._dialogInput ); |
|
| |
2059
| + inst = this._dialogInst = this._newInst( this._dialogInput, false ); |
|
| |
2060
| + inst.settings = {}; |
|
| |
2061
| + $.data( this._dialogInput[ 0 ], "datepicker", inst ); |
|
| |
2062
| + } |
|
| |
2063
| + datepicker_extendRemove( inst.settings, settings || {} ); |
|
| |
2064
| + date = ( date && date.constructor === Date ? this._formatDate( inst, date ) : date ); |
|
| |
2065
| + this._dialogInput.val( date ); |
|
| |
2066
| + |
|
| |
2067
| + this._pos = ( pos ? ( pos.length ? pos : [ pos.pageX, pos.pageY ] ) : null ); |
|
| |
2068
| + if ( !this._pos ) { |
|
| |
2069
| + browserWidth = document.documentElement.clientWidth; |
|
| |
2070
| + browserHeight = document.documentElement.clientHeight; |
|
| |
2071
| + scrollX = document.documentElement.scrollLeft || document.body.scrollLeft; |
|
| |
2072
| + scrollY = document.documentElement.scrollTop || document.body.scrollTop; |
|
| |
2073
| + this._pos = // should use actual width/height below |
|
| |
2074
| + [ ( browserWidth / 2 ) - 100 + scrollX, ( browserHeight / 2 ) - 150 + scrollY ]; |
|
| |
2075
| + } |
|
| |
2076
| + |
|
| |
2077
| + // Move input on screen for focus, but hidden behind dialog |
|
| |
2078
| + this._dialogInput.css( "left", ( this._pos[ 0 ] + 20 ) + "px" ).css( "top", this._pos[ 1 ] + "px" ); |
|
| |
2079
| + inst.settings.onSelect = onSelect; |
|
| |
2080
| + this._inDialog = true; |
|
| |
2081
| + this.dpDiv.addClass( this._dialogClass ); |
|
| |
2082
| + this._showDatepicker( this._dialogInput[ 0 ] ); |
|
| |
2083
| + if ( $.blockUI ) { |
|
| |
2084
| + $.blockUI( this.dpDiv ); |
|
| |
2085
| + } |
|
| |
2086
| + $.data( this._dialogInput[ 0 ], "datepicker", inst ); |
|
| |
2087
| + return this; |
|
| |
2088
| + }, |
|
| |
2089
| + |
|
| |
2090
| + /* Detach a datepicker from its control. |
|
| |
2091
| + * @param target element - the target input field or division or span |
|
| |
2092
| + */ |
|
| |
2093
| + _destroyDatepicker: function( target ) { |
|
| |
2094
| + var nodeName, |
|
| |
2095
| + $target = $( target ), |
|
| |
2096
| + inst = $.data( target, "datepicker" ); |
|
| |
2097
| + |
|
| |
2098
| + if ( !$target.hasClass( this.markerClassName ) ) { |
|
| |
2099
| + return; |
|
| |
2100
| + } |
|
| |
2101
| + |
|
| |
2102
| + nodeName = target.nodeName.toLowerCase(); |
|
| |
2103
| + $.removeData( target, "datepicker" ); |
|
| |
2104
| + if ( nodeName === "input" ) { |
|
| |
2105
| + inst.append.remove(); |
|
| |
2106
| + inst.trigger.remove(); |
|
| |
2107
| + $target.removeClass( this.markerClassName ). |
|
| |
2108
| + off( "focus", this._showDatepicker ). |
|
| |
2109
| + off( "keydown", this._doKeyDown ). |
|
| |
2110
| + off( "keypress", this._doKeyPress ). |
|
| |
2111
| + off( "keyup", this._doKeyUp ); |
|
| |
2112
| + } else if ( nodeName === "div" || nodeName === "span" ) { |
|
| |
2113
| + $target.removeClass( this.markerClassName ).empty(); |
|
| |
2114
| + } |
|
| |
2115
| + |
|
| |
2116
| + if ( datepicker_instActive === inst ) { |
|
| |
2117
| + datepicker_instActive = null; |
|
| |
2118
| + } |
|
| |
2119
| + }, |
|
| |
2120
| + |
|
| |
2121
| + /* Enable the date picker to a jQuery selection. |
|
| |
2122
| + * @param target element - the target input field or division or span |
|
| |
2123
| + */ |
|
| |
2124
| + _enableDatepicker: function( target ) { |
|
| |
2125
| + var nodeName, inline, |
|
| |
2126
| + $target = $( target ), |
|
| |
2127
| + inst = $.data( target, "datepicker" ); |
|
| |
2128
| + |
|
| |
2129
| + if ( !$target.hasClass( this.markerClassName ) ) { |
|
| |
2130
| + return; |
|
| |
2131
| + } |
|
| |
2132
| + |
|
| |
2133
| + nodeName = target.nodeName.toLowerCase(); |
|
| |
2134
| + if ( nodeName === "input" ) { |
|
| |
2135
| + target.disabled = false; |
|
| |
2136
| + inst.trigger.filter( "button" ). |
|
| |
2137
| + each( function() { this.disabled = false; } ).end(). |
|
| |
2138
| + filter( "img" ).css( { opacity: "1.0", cursor: "" } ); |
|
| |
2139
| + } else if ( nodeName === "div" || nodeName === "span" ) { |
|
| |
2140
| + inline = $target.children( "." + this._inlineClass ); |
|
| |
2141
| + inline.children().removeClass( "ui-state-disabled" ); |
|
| |
2142
| + inline.find( "select.ui-datepicker-month, select.ui-datepicker-year" ). |
|
| |
2143
| + prop( "disabled", false ); |
|
| |
2144
| + } |
|
| |
2145
| + this._disabledInputs = $.map( this._disabledInputs, |
|
| |
2146
| + function( value ) { return ( value === target ? null : value ); } ); // delete entry |
|
| |
2147
| + }, |
|
| |
2148
| + |
|
| |
2149
| + /* Disable the date picker to a jQuery selection. |
|
| |
2150
| + * @param target element - the target input field or division or span |
|
| |
2151
| + */ |
|
| |
2152
| + _disableDatepicker: function( target ) { |
|
| |
2153
| + var nodeName, inline, |
|
| |
2154
| + $target = $( target ), |
|
| |
2155
| + inst = $.data( target, "datepicker" ); |
|
| |
2156
| + |
|
| |
2157
| + if ( !$target.hasClass( this.markerClassName ) ) { |
|
| |
2158
| + return; |
|
| |
2159
| + } |
|
| |
2160
| + |
|
| |
2161
| + nodeName = target.nodeName.toLowerCase(); |
|
| |
2162
| + if ( nodeName === "input" ) { |
|
| |
2163
| + target.disabled = true; |
|
| |
2164
| + inst.trigger.filter( "button" ). |
|
| |
2165
| + each( function() { this.disabled = true; } ).end(). |
|
| |
2166
| + filter( "img" ).css( { opacity: "0.5", cursor: "default" } ); |
|
| |
2167
| + } else if ( nodeName === "div" || nodeName === "span" ) { |
|
| |
2168
| + inline = $target.children( "." + this._inlineClass ); |
|
| |
2169
| + inline.children().addClass( "ui-state-disabled" ); |
|
| |
2170
| + inline.find( "select.ui-datepicker-month, select.ui-datepicker-year" ). |
|
| |
2171
| + prop( "disabled", true ); |
|
| |
2172
| + } |
|
| |
2173
| + this._disabledInputs = $.map( this._disabledInputs, |
|
| |
2174
| + function( value ) { return ( value === target ? null : value ); } ); // delete entry |
|
| |
2175
| + this._disabledInputs[ this._disabledInputs.length ] = target; |
|
| |
2176
| + }, |
|
| |
2177
| + |
|
| |
2178
| + /* Is the first field in a jQuery collection disabled as a datepicker? |
|
| |
2179
| + * @param target element - the target input field or division or span |
|
| |
2180
| + * @return boolean - true if disabled, false if enabled |
|
| |
2181
| + */ |
|
| |
2182
| + _isDisabledDatepicker: function( target ) { |
|
| |
2183
| + if ( !target ) { |
|
| |
2184
| + return false; |
|
| |
2185
| + } |
|
| |
2186
| + for ( var i = 0; i < this._disabledInputs.length; i++ ) { |
|
| |
2187
| + if ( this._disabledInputs[ i ] === target ) { |
|
| |
2188
| + return true; |
|
| |
2189
| + } |
|
| |
2190
| + } |
|
| |
2191
| + return false; |
|
| |
2192
| + }, |
|
| |
2193
| + |
|
| |
2194
| + /* Retrieve the instance data for the target control. |
|
| |
2195
| + * @param target element - the target input field or division or span |
|
| |
2196
| + * @return object - the associated instance data |
|
| |
2197
| + * @throws error if a jQuery problem getting data |
|
| |
2198
| + */ |
|
| |
2199
| + _getInst: function( target ) { |
|
| |
2200
| + try { |
|
| |
2201
| + return $.data( target, "datepicker" ); |
|
| |
2202
| + } |
|
| |
2203
| + catch ( err ) { |
|
| |
2204
| + throw "Missing instance data for this datepicker"; |
|
| |
2205
| + } |
|
| |
2206
| + }, |
|
| |
2207
| + |
|
| |
2208
| + /* Update or retrieve the settings for a date picker attached to an input field or division. |
|
| |
2209
| + * @param target element - the target input field or division or span |
|
| |
2210
| + * @param name object - the new settings to update or |
|
| |
2211
| + * string - the name of the setting to change or retrieve, |
|
| |
2212
| + * when retrieving also "all" for all instance settings or |
|
| |
2213
| + * "defaults" for all global defaults |
|
| |
2214
| + * @param value any - the new value for the setting |
|
| |
2215
| + * (omit if above is an object or to retrieve a value) |
|
| |
2216
| + */ |
|
| |
2217
| + _optionDatepicker: function( target, name, value ) { |
|
| |
2218
| + var settings, date, minDate, maxDate, |
|
| |
2219
| + inst = this._getInst( target ); |
|
| |
2220
| + |
|
| |
2221
| + if ( arguments.length === 2 && typeof name === "string" ) { |
|
| |
2222
| + return ( name === "defaults" ? $.extend( {}, $.datepicker._defaults ) : |
|
| |
2223
| + ( inst ? ( name === "all" ? $.extend( {}, inst.settings ) : |
|
| |
2224
| + this._get( inst, name ) ) : null ) ); |
|
| |
2225
| + } |
|
| |
2226
| + |
|
| |
2227
| + settings = name || {}; |
|
| |
2228
| + if ( typeof name === "string" ) { |
|
| |
2229
| + settings = {}; |
|
| |
2230
| + settings[ name ] = value; |
|
| |
2231
| + } |
|
| |
2232
| + |
|
| |
2233
| + if ( inst ) { |
|
| |
2234
| + if ( this._curInst === inst ) { |
|
| |
2235
| + this._hideDatepicker(); |
|
| |
2236
| + } |
|
| |
2237
| + |
|
| |
2238
| + date = this._getDateDatepicker( target, true ); |
|
| |
2239
| + minDate = this._getMinMaxDate( inst, "min" ); |
|
| |
2240
| + maxDate = this._getMinMaxDate( inst, "max" ); |
|
| |
2241
| + datepicker_extendRemove( inst.settings, settings ); |
|
| |
2242
| + |
|
| |
2243
| + // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided |
|
| |
2244
| + if ( minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined ) { |
|
| |
2245
| + inst.settings.minDate = this._formatDate( inst, minDate ); |
|
| |
2246
| + } |
|
| |
2247
| + if ( maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined ) { |
|
| |
2248
| + inst.settings.maxDate = this._formatDate( inst, maxDate ); |
|
| |
2249
| + } |
|
| |
2250
| + if ( "disabled" in settings ) { |
|
| |
2251
| + if ( settings.disabled ) { |
|
| |
2252
| + this._disableDatepicker( target ); |
|
| |
2253
| + } else { |
|
| |
2254
| + this._enableDatepicker( target ); |
|
| |
2255
| + } |
|
| |
2256
| + } |
|
| |
2257
| + this._attachments( $( target ), inst ); |
|
| |
2258
| + this._autoSize( inst ); |
|
| |
2259
| + this._setDate( inst, date ); |
|
| |
2260
| + this._updateAlternate( inst ); |
|
| |
2261
| + this._updateDatepicker( inst ); |
|
| |
2262
| + } |
|
| |
2263
| + }, |
|
| |
2264
| + |
|
| |
2265
| + // Change method deprecated |
|
| |
2266
| + _changeDatepicker: function( target, name, value ) { |
|
| |
2267
| + this._optionDatepicker( target, name, value ); |
|
| |
2268
| + }, |
|
| |
2269
| + |
|
| |
2270
| + /* Redraw the date picker attached to an input field or division. |
|
| |
2271
| + * @param target element - the target input field or division or span |
|
| |
2272
| + */ |
|
| |
2273
| + _refreshDatepicker: function( target ) { |
|
| |
2274
| + var inst = this._getInst( target ); |
|
| |
2275
| + if ( inst ) { |
|
| |
2276
| + this._updateDatepicker( inst ); |
|
| |
2277
| + } |
|
| |
2278
| + }, |
|
| |
2279
| + |
|
| |
2280
| + /* Set the dates for a jQuery selection. |
|
| |
2281
| + * @param target element - the target input field or division or span |
|
| |
2282
| + * @param date Date - the new date |
|
| |
2283
| + */ |
|
| |
2284
| + _setDateDatepicker: function( target, date ) { |
|
| |
2285
| + var inst = this._getInst( target ); |
|
| |
2286
| + if ( inst ) { |
|
| |
2287
| + this._setDate( inst, date ); |
|
| |
2288
| + this._updateDatepicker( inst ); |
|
| |
2289
| + this._updateAlternate( inst ); |
|
| |
2290
| + } |
|
| |
2291
| + }, |
|
| |
2292
| + |
|
| |
2293
| + /* Get the date(s) for the first entry in a jQuery selection. |
|
| |
2294
| + * @param target element - the target input field or division or span |
|
| |
2295
| + * @param noDefault boolean - true if no default date is to be used |
|
| |
2296
| + * @return Date - the current date |
|
| |
2297
| + */ |
|
| |
2298
| + _getDateDatepicker: function( target, noDefault ) { |
|
| |
2299
| + var inst = this._getInst( target ); |
|
| |
2300
| + if ( inst && !inst.inline ) { |
|
| |
2301
| + this._setDateFromField( inst, noDefault ); |
|
| |
2302
| + } |
|
| |
2303
| + return ( inst ? this._getDate( inst ) : null ); |
|
| |
2304
| + }, |
|
| |
2305
| + |
|
| |
2306
| + /* Handle keystrokes. */ |
|
| |
2307
| + _doKeyDown: function( event ) { |
|
| |
2308
| + var onSelect, dateStr, sel, |
|
| |
2309
| + inst = $.datepicker._getInst( event.target ), |
|
| |
2310
| + handled = true, |
|
| |
2311
| + isRTL = inst.dpDiv.is( ".ui-datepicker-rtl" ); |
|
| |
2312
| + |
|
| |
2313
| + inst._keyEvent = true; |
|
| |
2314
| + if ( $.datepicker._datepickerShowing ) { |
|
| |
2315
| + switch ( event.keyCode ) { |
|
| |
2316
| + case 9: $.datepicker._hideDatepicker(); |
|
| |
2317
| + handled = false; |
|
| |
2318
| + break; // hide on tab out |
|
| |
2319
| + case 13: sel = $( "td." + $.datepicker._dayOverClass + ":not(." + |
|
| |
2320
| + $.datepicker._currentClass + ")", inst.dpDiv ); |
|
| |
2321
| + if ( sel[ 0 ] ) { |
|
| |
2322
| + $.datepicker._selectDay( event.target, inst.selectedMonth, inst.selectedYear, sel[ 0 ] ); |
|
| |
2323
| + } |
|
| |
2324
| + |
|
| |
2325
| + onSelect = $.datepicker._get( inst, "onSelect" ); |
|
| |
2326
| + if ( onSelect ) { |
|
| |
2327
| + dateStr = $.datepicker._formatDate( inst ); |
|
| |
2328
| + |
|
| |
2329
| + // Trigger custom callback |
|
| |
2330
| + onSelect.apply( ( inst.input ? inst.input[ 0 ] : null ), [ dateStr, inst ] ); |
|
| |
2331
| + } else { |
|
| |
2332
| + $.datepicker._hideDatepicker(); |
|
| |
2333
| + } |
|
| |
2334
| + |
|
| |
2335
| + return false; // don't submit the form |
|
| |
2336
| + case 27: $.datepicker._hideDatepicker(); |
|
| |
2337
| + break; // hide on escape |
|
| |
2338
| + case 33: $.datepicker._adjustDate( event.target, ( event.ctrlKey ? |
|
| |
2339
| + -$.datepicker._get( inst, "stepBigMonths" ) : |
|
| |
2340
| + -$.datepicker._get( inst, "stepMonths" ) ), "M" ); |
|
| |
2341
| + break; // previous month/year on page up/+ ctrl |
|
| |
2342
| + case 34: $.datepicker._adjustDate( event.target, ( event.ctrlKey ? |
|
| |
2343
| + +$.datepicker._get( inst, "stepBigMonths" ) : |
|
| |
2344
| + +$.datepicker._get( inst, "stepMonths" ) ), "M" ); |
|
| |
2345
| + break; // next month/year on page down/+ ctrl |
|
| |
2346
| + case 35: if ( event.ctrlKey || event.metaKey ) { |
|
| |
2347
| + $.datepicker._clearDate( event.target ); |
|
| |
2348
| + } |
|
| |
2349
| + handled = event.ctrlKey || event.metaKey; |
|
| |
2350
| + break; // clear on ctrl or command +end |
|
| |
2351
| + case 36: if ( event.ctrlKey || event.metaKey ) { |
|
| |
2352
| + $.datepicker._gotoToday( event.target ); |
|
| |
2353
| + } |
|
| |
2354
| + handled = event.ctrlKey || event.metaKey; |
|
| |
2355
| + break; // current on ctrl or command +home |
|
| |
2356
| + case 37: if ( event.ctrlKey || event.metaKey ) { |
|
| |
2357
| + $.datepicker._adjustDate( event.target, ( isRTL ? +1 : -1 ), "D" ); |
|
| |
2358
| + } |
|
| |
2359
| + handled = event.ctrlKey || event.metaKey; |
|
| |
2360
| + |
|
| |
2361
| + // -1 day on ctrl or command +left |
|
| |
2362
| + if ( event.originalEvent.altKey ) { |
|
| |
2363
| + $.datepicker._adjustDate( event.target, ( event.ctrlKey ? |
|
| |
2364
| + -$.datepicker._get( inst, "stepBigMonths" ) : |
|
| |
2365
| + -$.datepicker._get( inst, "stepMonths" ) ), "M" ); |
|
| |
2366
| + } |
|
| |
2367
| + |
|
| |
2368
| + // next month/year on alt +left on Mac |
|
| |
2369
| + break; |
|
| |
2370
| + case 38: if ( event.ctrlKey || event.metaKey ) { |
|
| |
2371
| + $.datepicker._adjustDate( event.target, -7, "D" ); |
|
| |
2372
| + } |
|
| |
2373
| + handled = event.ctrlKey || event.metaKey; |
|
| |
2374
| + break; // -1 week on ctrl or command +up |
|
| |
2375
| + case 39: if ( event.ctrlKey || event.metaKey ) { |
|
| |
2376
| + $.datepicker._adjustDate( event.target, ( isRTL ? -1 : +1 ), "D" ); |
|
| |
2377
| + } |
|
| |
2378
| + handled = event.ctrlKey || event.metaKey; |
|
| |
2379
| + |
|
| |
2380
| + // +1 day on ctrl or command +right |
|
| |
2381
| + if ( event.originalEvent.altKey ) { |
|
| |
2382
| + $.datepicker._adjustDate( event.target, ( event.ctrlKey ? |
|
| |
2383
| + +$.datepicker._get( inst, "stepBigMonths" ) : |
|
| |
2384
| + +$.datepicker._get( inst, "stepMonths" ) ), "M" ); |
|
| |
2385
| + } |
|
| |
2386
| + |
|
| |
2387
| + // next month/year on alt +right |
|
| |
2388
| + break; |
|
| |
2389
| + case 40: if ( event.ctrlKey || event.metaKey ) { |
|
| |
2390
| + $.datepicker._adjustDate( event.target, +7, "D" ); |
|
| |
2391
| + } |
|
| |
2392
| + handled = event.ctrlKey || event.metaKey; |
|
| |
2393
| + break; // +1 week on ctrl or command +down |
|
| |
2394
| + default: handled = false; |
|
| |
2395
| + } |
|
| |
2396
| + } else if ( event.keyCode === 36 && event.ctrlKey ) { // display the date picker on ctrl+home |
|
| |
2397
| + $.datepicker._showDatepicker( this ); |
|
| |
2398
| + } else { |
|
| |
2399
| + handled = false; |
|
| |
2400
| + } |
|
| |
2401
| + |
|
| |
2402
| + if ( handled ) { |
|
| |
2403
| + event.preventDefault(); |
|
| |
2404
| + event.stopPropagation(); |
|
| |
2405
| + } |
|
| |
2406
| + }, |
|
| |
2407
| + |
|
| |
2408
| + /* Filter entered characters - based on date format. */ |
|
| |
2409
| + _doKeyPress: function( event ) { |
|
| |
2410
| + var chars, chr, |
|
| |
2411
| + inst = $.datepicker._getInst( event.target ); |
|
| |
2412
| + |
|
| |
2413
| + if ( $.datepicker._get( inst, "constrainInput" ) ) { |
|
| |
2414
| + chars = $.datepicker._possibleChars( $.datepicker._get( inst, "dateFormat" ) ); |
|
| |
2415
| + chr = String.fromCharCode( event.charCode == null ? event.keyCode : event.charCode ); |
|
| |
2416
| + return event.ctrlKey || event.metaKey || ( chr < " " || !chars || chars.indexOf( chr ) > -1 ); |
|
| |
2417
| + } |
|
| |
2418
| + }, |
|
| |
2419
| + |
|
| |
2420
| + /* Synchronise manual entry and field/alternate field. */ |
|
| |
2421
| + _doKeyUp: function( event ) { |
|
| |
2422
| + var date, |
|
| |
2423
| + inst = $.datepicker._getInst( event.target ); |
|
| |
2424
| + |
|
| |
2425
| + if ( inst.input.val() !== inst.lastVal ) { |
|
| |
2426
| + try { |
|
| |
2427
| + date = $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ), |
|
| |
2428
| + ( inst.input ? inst.input.val() : null ), |
|
| |
2429
| + $.datepicker._getFormatConfig( inst ) ); |
|
| |
2430
| + |
|
| |
2431
| + if ( date ) { // only if valid |
|
| |
2432
| + $.datepicker._setDateFromField( inst ); |
|
| |
2433
| + $.datepicker._updateAlternate( inst ); |
|
| |
2434
| + $.datepicker._updateDatepicker( inst ); |
|
| |
2435
| + } |
|
| |
2436
| + } |
|
| |
2437
| + catch ( err ) { |
|
| |
2438
| + } |
|
| |
2439
| + } |
|
| |
2440
| + return true; |
|
| |
2441
| + }, |
|
| |
2442
| + |
|
| |
2443
| + /* Pop-up the date picker for a given input field. |
|
| |
2444
| + * If false returned from beforeShow event handler do not show. |
|
| |
2445
| + * @param input element - the input field attached to the date picker or |
|
| |
2446
| + * event - if triggered by focus |
|
| |
2447
| + */ |
|
| |
2448
| + _showDatepicker: function( input ) { |
|
| |
2449
| + input = input.target || input; |
|
| |
2450
| + if ( input.nodeName.toLowerCase() !== "input" ) { // find from button/image trigger |
|
| |
2451
| + input = $( "input", input.parentNode )[ 0 ]; |
|
| |
2452
| + } |
|
| |
2453
| + |
|
| |
2454
| + if ( $.datepicker._isDisabledDatepicker( input ) || $.datepicker._lastInput === input ) { // already here |
|
| |
2455
| + return; |
|
| |
2456
| + } |
|
| |
2457
| + |
|
| |
2458
| + var inst, beforeShow, beforeShowSettings, isFixed, |
|
| |
2459
| + offset, showAnim, duration; |
|
| |
2460
| + |
|
| |
2461
| + inst = $.datepicker._getInst( input ); |
|
| |
2462
| + if ( $.datepicker._curInst && $.datepicker._curInst !== inst ) { |
|
| |
2463
| + $.datepicker._curInst.dpDiv.stop( true, true ); |
|
| |
2464
| + if ( inst && $.datepicker._datepickerShowing ) { |
|
| |
2465
| + $.datepicker._hideDatepicker( $.datepicker._curInst.input[ 0 ] ); |
|
| |
2466
| + } |
|
| |
2467
| + } |
|
| |
2468
| + |
|
| |
2469
| + beforeShow = $.datepicker._get( inst, "beforeShow" ); |
|
| |
2470
| + beforeShowSettings = beforeShow ? beforeShow.apply( input, [ input, inst ] ) : {}; |
|
| |
2471
| + if ( beforeShowSettings === false ) { |
|
| |
2472
| + return; |
|
| |
2473
| + } |
|
| |
2474
| + datepicker_extendRemove( inst.settings, beforeShowSettings ); |
|
| |
2475
| + |
|
| |
2476
| + inst.lastVal = null; |
|
| |
2477
| + $.datepicker._lastInput = input; |
|
| |
2478
| + $.datepicker._setDateFromField( inst ); |
|
| |
2479
| + |
|
| |
2480
| + if ( $.datepicker._inDialog ) { // hide cursor |
|
| |
2481
| + input.value = ""; |
|
| |
2482
| + } |
|
| |
2483
| + if ( !$.datepicker._pos ) { // position below input |
|
| |
2484
| + $.datepicker._pos = $.datepicker._findPos( input ); |
|
| |
2485
| + $.datepicker._pos[ 1 ] += input.offsetHeight; // add the height |
|
| |
2486
| + } |
|
| |
2487
| + |
|
| |
2488
| + isFixed = false; |
|
| |
2489
| + $( input ).parents().each( function() { |
|
| |
2490
| + isFixed |= $( this ).css( "position" ) === "fixed"; |
|
| |
2491
| + return !isFixed; |
|
| |
2492
| + } ); |
|
| |
2493
| + |
|
| |
2494
| + offset = { left: $.datepicker._pos[ 0 ], top: $.datepicker._pos[ 1 ] }; |
|
| |
2495
| + $.datepicker._pos = null; |
|
| |
2496
| + |
|
| |
2497
| + //to avoid flashes on Firefox |
|
| |
2498
| + inst.dpDiv.empty(); |
|
| |
2499
| + |
|
| |
2500
| + // determine sizing offscreen |
|
| |
2501
| + inst.dpDiv.css( { position: "absolute", display: "block", top: "-1000px" } ); |
|
| |
2502
| + $.datepicker._updateDatepicker( inst ); |
|
| |
2503
| + |
|
| |
2504
| + // fix width for dynamic number of date pickers |
|
| |
2505
| + // and adjust position before showing |
|
| |
2506
| + offset = $.datepicker._checkOffset( inst, offset, isFixed ); |
|
| |
2507
| + inst.dpDiv.css( { position: ( $.datepicker._inDialog && $.blockUI ? |
|
| |
2508
| + "static" : ( isFixed ? "fixed" : "absolute" ) ), display: "none", |
|
| |
2509
| + left: offset.left + "px", top: offset.top + "px" } ); |
|
| |
2510
| + |
|
| |
2511
| + if ( !inst.inline ) { |
|
| |
2512
| + showAnim = $.datepicker._get( inst, "showAnim" ); |
|
| |
2513
| + duration = $.datepicker._get( inst, "duration" ); |
|
| |
2514
| + inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 ); |
|
| |
2515
| + $.datepicker._datepickerShowing = true; |
|
| |
2516
| + |
|
| |
2517
| + if ( $.effects && $.effects.effect[ showAnim ] ) { |
|
| |
2518
| + inst.dpDiv.show( showAnim, $.datepicker._get( inst, "showOptions" ), duration ); |
|
| |
2519
| + } else { |
|
| |
2520
| + inst.dpDiv[ showAnim || "show" ]( showAnim ? duration : null ); |
|
| |
2521
| + } |
|
| |
2522
| + |
|
| |
2523
| + if ( $.datepicker._shouldFocusInput( inst ) ) { |
|
| |
2524
| + inst.input.trigger( "focus" ); |
|
| |
2525
| + } |
|
| |
2526
| + |
|
| |
2527
| + $.datepicker._curInst = inst; |
|
| |
2528
| + } |
|
| |
2529
| + }, |
|
| |
2530
| + |
|
| |
2531
| + /* Generate the date picker content. */ |
|
| |
2532
| + _updateDatepicker: function( inst ) { |
|
| |
2533
| + this.maxRows = 4; //Reset the max number of rows being displayed (see #7043) |
|
| |
2534
| + datepicker_instActive = inst; // for delegate hover events |
|
| |
2535
| + inst.dpDiv.empty().append( this._generateHTML( inst ) ); |
|
| |
2536
| + this._attachHandlers( inst ); |
|
| |
2537
| + |
|
| |
2538
| + var origyearshtml, |
|
| |
2539
| + numMonths = this._getNumberOfMonths( inst ), |
|
| |
2540
| + cols = numMonths[ 1 ], |
|
| |
2541
| + width = 17, |
|
| |
2542
| + activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" ); |
|
| |
2543
| + |
|
| |
2544
| + if ( activeCell.length > 0 ) { |
|
| |
2545
| + datepicker_handleMouseover.apply( activeCell.get( 0 ) ); |
|
| |
2546
| + } |
|
| |
2547
| + |
|
| |
2548
| + inst.dpDiv.removeClass( "ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4" ).width( "" ); |
|
| |
2549
| + if ( cols > 1 ) { |
|
| |
2550
| + inst.dpDiv.addClass( "ui-datepicker-multi-" + cols ).css( "width", ( width * cols ) + "em" ); |
|
| |
2551
| + } |
|
| |
2552
| + inst.dpDiv[ ( numMonths[ 0 ] !== 1 || numMonths[ 1 ] !== 1 ? "add" : "remove" ) + |
|
| |
2553
| + "Class" ]( "ui-datepicker-multi" ); |
|
| |
2554
| + inst.dpDiv[ ( this._get( inst, "isRTL" ) ? "add" : "remove" ) + |
|
| |
2555
| + "Class" ]( "ui-datepicker-rtl" ); |
|
| |
2556
| + |
|
| |
2557
| + if ( inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) { |
|
| |
2558
| + inst.input.trigger( "focus" ); |
|
| |
2559
| + } |
|
| |
2560
| + |
|
| |
2561
| + // Deffered render of the years select (to avoid flashes on Firefox) |
|
| |
2562
| + if ( inst.yearshtml ) { |
|
| |
2563
| + origyearshtml = inst.yearshtml; |
|
| |
2564
| + setTimeout( function() { |
|
| |
2565
| + |
|
| |
2566
| + //assure that inst.yearshtml didn't change. |
|
| |
2567
| + if ( origyearshtml === inst.yearshtml && inst.yearshtml ) { |
|
| |
2568
| + inst.dpDiv.find( "select.ui-datepicker-year:first" ).replaceWith( inst.yearshtml ); |
|
| |
2569
| + } |
|
| |
2570
| + origyearshtml = inst.yearshtml = null; |
|
| |
2571
| + }, 0 ); |
|
| |
2572
| + } |
|
| |
2573
| + }, |
|
| |
2574
| + |
|
| |
2575
| + // #6694 - don't focus the input if it's already focused |
|
| |
2576
| + // this breaks the change event in IE |
|
| |
2577
| + // Support: IE and jQuery <1.9 |
|
| |
2578
| + _shouldFocusInput: function( inst ) { |
|
| |
2579
| + return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" ); |
|
| |
2580
| + }, |
|
| |
2581
| + |
|
| |
2582
| + /* Check positioning to remain on screen. */ |
|
| |
2583
| + _checkOffset: function( inst, offset, isFixed ) { |
|
| |
2584
| + var dpWidth = inst.dpDiv.outerWidth(), |
|
| |
2585
| + dpHeight = inst.dpDiv.outerHeight(), |
|
| |
2586
| + inputWidth = inst.input ? inst.input.outerWidth() : 0, |
|
| |
2587
| + inputHeight = inst.input ? inst.input.outerHeight() : 0, |
|
| |
2588
| + viewWidth = document.documentElement.clientWidth + ( isFixed ? 0 : $( document ).scrollLeft() ), |
|
| |
2589
| + viewHeight = document.documentElement.clientHeight + ( isFixed ? 0 : $( document ).scrollTop() ); |
|
| |
2590
| + |
|
| |
2591
| + offset.left -= ( this._get( inst, "isRTL" ) ? ( dpWidth - inputWidth ) : 0 ); |
|
| |
2592
| + offset.left -= ( isFixed && offset.left === inst.input.offset().left ) ? $( document ).scrollLeft() : 0; |
|
| |
2593
| + offset.top -= ( isFixed && offset.top === ( inst.input.offset().top + inputHeight ) ) ? $( document ).scrollTop() : 0; |
|
| |
2594
| + |
|
| |
2595
| + // Now check if datepicker is showing outside window viewport - move to a better place if so. |
|
| |
2596
| + offset.left -= Math.min( offset.left, ( offset.left + dpWidth > viewWidth && viewWidth > dpWidth ) ? |
|
| |
2597
| + Math.abs( offset.left + dpWidth - viewWidth ) : 0 ); |
|
| |
2598
| + offset.top -= Math.min( offset.top, ( offset.top + dpHeight > viewHeight && viewHeight > dpHeight ) ? |
|
| |
2599
| + Math.abs( dpHeight + inputHeight ) : 0 ); |
|
| |
2600
| + |
|
| |
2601
| + return offset; |
|
| |
2602
| + }, |
|
| |
2603
| + |
|
| |
2604
| + /* Find an object's position on the screen. */ |
|
| |
2605
| + _findPos: function( obj ) { |
|
| |
2606
| + var position, |
|
| |
2607
| + inst = this._getInst( obj ), |
|
| |
2608
| + isRTL = this._get( inst, "isRTL" ); |
|
| |
2609
| + |
|
| |
2610
| + while ( obj && ( obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden( obj ) ) ) { |
|
| |
2611
| + obj = obj[ isRTL ? "previousSibling" : "nextSibling" ]; |
|
| |
2612
| + } |
|
| |
2613
| + |
|
| |
2614
| + position = $( obj ).offset(); |
|
| |
2615
| + return [ position.left, position.top ]; |
|
| |
2616
| + }, |
|
| |
2617
| + |
|
| |
2618
| + /* Hide the date picker from view. |
|
| |
2619
| + * @param input element - the input field attached to the date picker |
|
| |
2620
| + */ |
|
| |
2621
| + _hideDatepicker: function( input ) { |
|
| |
2622
| + var showAnim, duration, postProcess, onClose, |
|
| |
2623
| + inst = this._curInst; |
|
| |
2624
| + |
|
| |
2625
| + if ( !inst || ( input && inst !== $.data( input, "datepicker" ) ) ) { |
|
| |
2626
| + return; |
|
| |
2627
| + } |
|
| |
2628
| + |
|
| |
2629
| + if ( this._datepickerShowing ) { |
|
| |
2630
| + showAnim = this._get( inst, "showAnim" ); |
|
| |
2631
| + duration = this._get( inst, "duration" ); |
|
| |
2632
| + postProcess = function() { |
|
| |
2633
| + $.datepicker._tidyDialog( inst ); |
|
| |
2634
| + }; |
|
| |
2635
| + |
|
| |
2636
| + // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed |
|
| |
2637
| + if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) { |
|
| |
2638
| + inst.dpDiv.hide( showAnim, $.datepicker._get( inst, "showOptions" ), duration, postProcess ); |
|
| |
2639
| + } else { |
|
| |
2640
| + inst.dpDiv[ ( showAnim === "slideDown" ? "slideUp" : |
|
| |
2641
| + ( showAnim === "fadeIn" ? "fadeOut" : "hide" ) ) ]( ( showAnim ? duration : null ), postProcess ); |
|
| |
2642
| + } |
|
| |
2643
| + |
|
| |
2644
| + if ( !showAnim ) { |
|
| |
2645
| + postProcess(); |
|
| |
2646
| + } |
|
| |
2647
| + this._datepickerShowing = false; |
|
| |
2648
| + |
|
| |
2649
| + onClose = this._get( inst, "onClose" ); |
|
| |
2650
| + if ( onClose ) { |
|
| |
2651
| + onClose.apply( ( inst.input ? inst.input[ 0 ] : null ), [ ( inst.input ? inst.input.val() : "" ), inst ] ); |
|
| |
2652
| + } |
|
| |
2653
| + |
|
| |
2654
| + this._lastInput = null; |
|
| |
2655
| + if ( this._inDialog ) { |
|
| |
2656
| + this._dialogInput.css( { position: "absolute", left: "0", top: "-100px" } ); |
|
| |
2657
| + if ( $.blockUI ) { |
|
| |
2658
| + $.unblockUI(); |
|
| |
2659
| + $( "body" ).append( this.dpDiv ); |
|
| |
2660
| + } |
|
| |
2661
| + } |
|
| |
2662
| + this._inDialog = false; |
|
| |
2663
| + } |
|
| |
2664
| + }, |
|
| |
2665
| + |
|
| |
2666
| + /* Tidy up after a dialog display. */ |
|
| |
2667
| + _tidyDialog: function( inst ) { |
|
| |
2668
| + inst.dpDiv.removeClass( this._dialogClass ).off( ".ui-datepicker-calendar" ); |
|
| |
2669
| + }, |
|
| |
2670
| + |
|
| |
2671
| + /* Close date picker if clicked elsewhere. */ |
|
| |
2672
| + _checkExternalClick: function( event ) { |
|
| |
2673
| + if ( !$.datepicker._curInst ) { |
|
| |
2674
| + return; |
|
| |
2675
| + } |
|
| |
2676
| + |
|
| |
2677
| + var $target = $( event.target ), |
|
| |
2678
| + inst = $.datepicker._getInst( $target[ 0 ] ); |
|
| |
2679
| + |
|
| |
2680
| + if ( ( ( $target[ 0 ].id !== $.datepicker._mainDivId && |
|
| |
2681
| + $target.parents( "#" + $.datepicker._mainDivId ).length === 0 && |
|
| |
2682
| + !$target.hasClass( $.datepicker.markerClassName ) && |
|
| |
2683
| + !$target.closest( "." + $.datepicker._triggerClass ).length && |
|
| |
2684
| + $.datepicker._datepickerShowing && !( $.datepicker._inDialog && $.blockUI ) ) ) || |
|
| |
2685
| + ( $target.hasClass( $.datepicker.markerClassName ) && $.datepicker._curInst !== inst ) ) { |
|
| |
2686
| + $.datepicker._hideDatepicker(); |
|
| |
2687
| + } |
|
| |
2688
| + }, |
|
| |
2689
| + |
|
| |
2690
| + /* Adjust one of the date sub-fields. */ |
|
| |
2691
| + _adjustDate: function( id, offset, period ) { |
|
| |
2692
| + var target = $( id ), |
|
| |
2693
| + inst = this._getInst( target[ 0 ] ); |
|
| |
2694
| + |
|
| |
2695
| + if ( this._isDisabledDatepicker( target[ 0 ] ) ) { |
|
| |
2696
| + return; |
|
| |
2697
| + } |
|
| |
2698
| + this._adjustInstDate( inst, offset + |
|
| |
2699
| + ( period === "M" ? this._get( inst, "showCurrentAtPos" ) : 0 ), // undo positioning |
|
| |
2700
| + period ); |
|
| |
2701
| + this._updateDatepicker( inst ); |
|
| |
2702
| + }, |
|
| |
2703
| + |
|
| |
2704
| + /* Action for current link. */ |
|
| |
2705
| + _gotoToday: function( id ) { |
|
| |
2706
| + var date, |
|
| |
2707
| + target = $( id ), |
|
| |
2708
| + inst = this._getInst( target[ 0 ] ); |
|
| |
2709
| + |
|
| |
2710
| + if ( this._get( inst, "gotoCurrent" ) && inst.currentDay ) { |
|
| |
2711
| + inst.selectedDay = inst.currentDay; |
|
| |
2712
| + inst.drawMonth = inst.selectedMonth = inst.currentMonth; |
|
| |
2713
| + inst.drawYear = inst.selectedYear = inst.currentYear; |
|
| |
2714
| + } else { |
|
| |
2715
| + date = new Date(); |
|
| |
2716
| + inst.selectedDay = date.getDate(); |
|
| |
2717
| + inst.drawMonth = inst.selectedMonth = date.getMonth(); |
|
| |
2718
| + inst.drawYear = inst.selectedYear = date.getFullYear(); |
|
| |
2719
| + } |
|
| |
2720
| + this._notifyChange( inst ); |
|
| |
2721
| + this._adjustDate( target ); |
|
| |
2722
| + }, |
|
| |
2723
| + |
|
| |
2724
| + /* Action for selecting a new month/year. */ |
|
| |
2725
| + _selectMonthYear: function( id, select, period ) { |
|
| |
2726
| + var target = $( id ), |
|
| |
2727
| + inst = this._getInst( target[ 0 ] ); |
|
| |
2728
| + |
|
| |
2729
| + inst[ "selected" + ( period === "M" ? "Month" : "Year" ) ] = |
|
| |
2730
| + inst[ "draw" + ( period === "M" ? "Month" : "Year" ) ] = |
|
| |
2731
| + parseInt( select.options[ select.selectedIndex ].value, 10 ); |
|
| |
2732
| + |
|
| |
2733
| + this._notifyChange( inst ); |
|
| |
2734
| + this._adjustDate( target ); |
|
| |
2735
| + }, |
|
| |
2736
| + |
|
| |
2737
| + /* Action for selecting a day. */ |
|
| |
2738
| + _selectDay: function( id, month, year, td ) { |
|
| |
2739
| + var inst, |
|
| |
2740
| + target = $( id ); |
|
| |
2741
| + |
|
| |
2742
| + if ( $( td ).hasClass( this._unselectableClass ) || this._isDisabledDatepicker( target[ 0 ] ) ) { |
|
| |
2743
| + return; |
|
| |
2744
| + } |
|
| |
2745
| + |
|
| |
2746
| + inst = this._getInst( target[ 0 ] ); |
|
| |
2747
| + inst.selectedDay = inst.currentDay = $( "a", td ).html(); |
|
| |
2748
| + inst.selectedMonth = inst.currentMonth = month; |
|
| |
2749
| + inst.selectedYear = inst.currentYear = year; |
|
| |
2750
| + this._selectDate( id, this._formatDate( inst, |
|
| |
2751
| + inst.currentDay, inst.currentMonth, inst.currentYear ) ); |
|
| |
2752
| + }, |
|
| |
2753
| + |
|
| |
2754
| + /* Erase the input field and hide the date picker. */ |
|
| |
2755
| + _clearDate: function( id ) { |
|
| |
2756
| + var target = $( id ); |
|
| |
2757
| + this._selectDate( target, "" ); |
|
| |
2758
| + }, |
|
| |
2759
| + |
|
| |
2760
| + /* Update the input field with the selected date. */ |
|
| |
2761
| + _selectDate: function( id, dateStr ) { |
|
| |
2762
| + var onSelect, |
|
| |
2763
| + target = $( id ), |
|
| |
2764
| + inst = this._getInst( target[ 0 ] ); |
|
| |
2765
| + |
|
| |
2766
| + dateStr = ( dateStr != null ? dateStr : this._formatDate( inst ) ); |
|
| |
2767
| + if ( inst.input ) { |
|
| |
2768
| + inst.input.val( dateStr ); |
|
| |
2769
| + } |
|
| |
2770
| + this._updateAlternate( inst ); |
|
| |
2771
| + |
|
| |
2772
| + onSelect = this._get( inst, "onSelect" ); |
|
| |
2773
| + if ( onSelect ) { |
|
| |
2774
| + onSelect.apply( ( inst.input ? inst.input[ 0 ] : null ), [ dateStr, inst ] ); // trigger custom callback |
|
| |
2775
| + } else if ( inst.input ) { |
|
| |
2776
| + inst.input.trigger( "change" ); // fire the change event |
|
| |
2777
| + } |
|
| |
2778
| + |
|
| |
2779
| + if ( inst.inline ) { |
|
| |
2780
| + this._updateDatepicker( inst ); |
|
| |
2781
| + } else { |
|
| |
2782
| + this._hideDatepicker(); |
|
| |
2783
| + this._lastInput = inst.input[ 0 ]; |
|
| |
2784
| + if ( typeof( inst.input[ 0 ] ) !== "object" ) { |
|
| |
2785
| + inst.input.trigger( "focus" ); // restore focus |
|
| |
2786
| + } |
|
| |
2787
| + this._lastInput = null; |
|
| |
2788
| + } |
|
| |
2789
| + }, |
|
| |
2790
| + |
|
| |
2791
| + /* Update any alternate field to synchronise with the main field. */ |
|
| |
2792
| + _updateAlternate: function( inst ) { |
|
| |
2793
| + var altFormat, date, dateStr, |
|
| |
2794
| + altField = this._get( inst, "altField" ); |
|
| |
2795
| + |
|
| |
2796
| + if ( altField ) { // update alternate field too |
|
| |
2797
| + altFormat = this._get( inst, "altFormat" ) || this._get( inst, "dateFormat" ); |
|
| |
2798
| + date = this._getDate( inst ); |
|
| |
2799
| + dateStr = this.formatDate( altFormat, date, this._getFormatConfig( inst ) ); |
|
| |
2800
| + $( altField ).val( dateStr ); |
|
| |
2801
| + } |
|
| |
2802
| + }, |
|
| |
2803
| + |
|
| |
2804
| + /* Set as beforeShowDay function to prevent selection of weekends. |
|
| |
2805
| + * @param date Date - the date to customise |
|
| |
2806
| + * @return [boolean, string] - is this date selectable?, what is its CSS class? |
|
| |
2807
| + */ |
|
| |
2808
| + noWeekends: function( date ) { |
|
| |
2809
| + var day = date.getDay(); |
|
| |
2810
| + return [ ( day > 0 && day < 6 ), "" ]; |
|
| |
2811
| + }, |
|
| |
2812
| + |
|
| |
2813
| + /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition. |
|
| |
2814
| + * @param date Date - the date to get the week for |
|
| |
2815
| + * @return number - the number of the week within the year that contains this date |
|
| |
2816
| + */ |
|
| |
2817
| + iso8601Week: function( date ) { |
|
| |
2818
| + var time, |
|
| |
2819
| + checkDate = new Date( date.getTime() ); |
|
| |
2820
| + |
|
| |
2821
| + // Find Thursday of this week starting on Monday |
|
| |
2822
| + checkDate.setDate( checkDate.getDate() + 4 - ( checkDate.getDay() || 7 ) ); |
|
| |
2823
| + |
|
| |
2824
| + time = checkDate.getTime(); |
|
| |
2825
| + checkDate.setMonth( 0 ); // Compare with Jan 1 |
|
| |
2826
| + checkDate.setDate( 1 ); |
|
| |
2827
| + return Math.floor( Math.round( ( time - checkDate ) / 86400000 ) / 7 ) + 1; |
|
| |
2828
| + }, |
|
| |
2829
| + |
|
| |
2830
| + /* Parse a string value into a date object. |
|
| |
2831
| + * See formatDate below for the possible formats. |
|
| |
2832
| + * |
|
| |
2833
| + * @param format string - the expected format of the date |
|
| |
2834
| + * @param value string - the date in the above format |
|
| |
2835
| + * @param settings Object - attributes include: |
|
| |
2836
| + * shortYearCutoff number - the cutoff year for determining the century (optional) |
|
| |
2837
| + * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional) |
|
| |
2838
| + * dayNames string[7] - names of the days from Sunday (optional) |
|
| |
2839
| + * monthNamesShort string[12] - abbreviated names of the months (optional) |
|
| |
2840
| + * monthNames string[12] - names of the months (optional) |
|
| |
2841
| + * @return Date - the extracted date value or null if value is blank |
|
| |
2842
| + */ |
|
| |
2843
| + parseDate: function( format, value, settings ) { |
|
| |
2844
| + if ( format == null || value == null ) { |
|
| |
2845
| + throw "Invalid arguments"; |
|
| |
2846
| + } |
|
| |
2847
| + |
|
| |
2848
| + value = ( typeof value === "object" ? value.toString() : value + "" ); |
|
| |
2849
| + if ( value === "" ) { |
|
| |
2850
| + return null; |
|
| |
2851
| + } |
|
| |
2852
| + |
|
| |
2853
| + var iFormat, dim, extra, |
|
| |
2854
| + iValue = 0, |
|
| |
2855
| + shortYearCutoffTemp = ( settings ? settings.shortYearCutoff : null ) || this._defaults.shortYearCutoff, |
|
| |
2856
| + shortYearCutoff = ( typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp : |
|
| |
2857
| + new Date().getFullYear() % 100 + parseInt( shortYearCutoffTemp, 10 ) ), |
|
| |
2858
| + dayNamesShort = ( settings ? settings.dayNamesShort : null ) || this._defaults.dayNamesShort, |
|
| |
2859
| + dayNames = ( settings ? settings.dayNames : null ) || this._defaults.dayNames, |
|
| |
2860
| + monthNamesShort = ( settings ? settings.monthNamesShort : null ) || this._defaults.monthNamesShort, |
|
| |
2861
| + monthNames = ( settings ? settings.monthNames : null ) || this._defaults.monthNames, |
|
| |
2862
| + year = -1, |
|
| |
2863
| + month = -1, |
|
| |
2864
| + day = -1, |
|
| |
2865
| + doy = -1, |
|
| |
2866
| + literal = false, |
|
| |
2867
| + date, |
|
| |
2868
| + |
|
| |
2869
| + // Check whether a format character is doubled |
|
| |
2870
| + lookAhead = function( match ) { |
|
| |
2871
| + var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match ); |
|
| |
2872
| + if ( matches ) { |
|
| |
2873
| + iFormat++; |
|
| |
2874
| + } |
|
| |
2875
| + return matches; |
|
| |
2876
| + }, |
|
| |
2877
| + |
|
| |
2878
| + // Extract a number from the string value |
|
| |
2879
| + getNumber = function( match ) { |
|
| |
2880
| + var isDoubled = lookAhead( match ), |
|
| |
2881
| + size = ( match === "@" ? 14 : ( match === "!" ? 20 : |
|
| |
2882
| + ( match === "y" && isDoubled ? 4 : ( match === "o" ? 3 : 2 ) ) ) ), |
|
| |
2883
| + minSize = ( match === "y" ? size : 1 ), |
|
| |
2884
| + digits = new RegExp( "^\\d{" + minSize + "," + size + "}" ), |
|
| |
2885
| + num = value.substring( iValue ).match( digits ); |
|
| |
2886
| + if ( !num ) { |
|
| |
2887
| + throw "Missing number at position " + iValue; |
|
| |
2888
| + } |
|
| |
2889
| + iValue += num[ 0 ].length; |
|
| |
2890
| + return parseInt( num[ 0 ], 10 ); |
|
| |
2891
| + }, |
|
| |
2892
| + |
|
| |
2893
| + // Extract a name from the string value and convert to an index |
|
| |
2894
| + getName = function( match, shortNames, longNames ) { |
|
| |
2895
| + var index = -1, |
|
| |
2896
| + names = $.map( lookAhead( match ) ? longNames : shortNames, function( v, k ) { |
|
| |
2897
| + return [ [ k, v ] ]; |
|
| |
2898
| + } ).sort( function( a, b ) { |
|
| |
2899
| + return -( a[ 1 ].length - b[ 1 ].length ); |
|
| |
2900
| + } ); |
|
| |
2901
| + |
|
| |
2902
| + $.each( names, function( i, pair ) { |
|
| |
2903
| + var name = pair[ 1 ]; |
|
| |
2904
| + if ( value.substr( iValue, name.length ).toLowerCase() === name.toLowerCase() ) { |
|
| |
2905
| + index = pair[ 0 ]; |
|
| |
2906
| + iValue += name.length; |
|
| |
2907
| + return false; |
|
| |
2908
| + } |
|
| |
2909
| + } ); |
|
| |
2910
| + if ( index !== -1 ) { |
|
| |
2911
| + return index + 1; |
|
| |
2912
| + } else { |
|
| |
2913
| + throw "Unknown name at position " + iValue; |
|
| |
2914
| + } |
|
| |
2915
| + }, |
|
| |
2916
| + |
|
| |
2917
| + // Confirm that a literal character matches the string value |
|
| |
2918
| + checkLiteral = function() { |
|
| |
2919
| + if ( value.charAt( iValue ) !== format.charAt( iFormat ) ) { |
|
| |
2920
| + throw "Unexpected literal at position " + iValue; |
|
| |
2921
| + } |
|
| |
2922
| + iValue++; |
|
| |
2923
| + }; |
|
| |
2924
| + |
|
| |
2925
| + for ( iFormat = 0; iFormat < format.length; iFormat++ ) { |
|
| |
2926
| + if ( literal ) { |
|
| |
2927
| + if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) { |
|
| |
2928
| + literal = false; |
|
| |
2929
| + } else { |
|
| |
2930
| + checkLiteral(); |
|
| |
2931
| + } |
|
| |
2932
| + } else { |
|
| |
2933
| + switch ( format.charAt( iFormat ) ) { |
|
| |
2934
| + case "d": |
|
| |
2935
| + day = getNumber( "d" ); |
|
| |
2936
| + break; |
|
| |
2937
| + case "D": |
|
| |
2938
| + getName( "D", dayNamesShort, dayNames ); |
|
| |
2939
| + break; |
|
| |
2940
| + case "o": |
|
| |
2941
| + doy = getNumber( "o" ); |
|
| |
2942
| + break; |
|
| |
2943
| + case "m": |
|
| |
2944
| + month = getNumber( "m" ); |
|
| |
2945
| + break; |
|
| |
2946
| + case "M": |
|
| |
2947
| + month = getName( "M", monthNamesShort, monthNames ); |
|
| |
2948
| + break; |
|
| |
2949
| + case "y": |
|
| |
2950
| + year = getNumber( "y" ); |
|
| |
2951
| + break; |
|
| |
2952
| + case "@": |
|
| |
2953
| + date = new Date( getNumber( "@" ) ); |
|
| |
2954
| + year = date.getFullYear(); |
|
| |
2955
| + month = date.getMonth() + 1; |
|
| |
2956
| + day = date.getDate(); |
|
| |
2957
| + break; |
|
| |
2958
| + case "!": |
|
| |
2959
| + date = new Date( ( getNumber( "!" ) - this._ticksTo1970 ) / 10000 ); |
|
| |
2960
| + year = date.getFullYear(); |
|
| |
2961
| + month = date.getMonth() + 1; |
|
| |
2962
| + day = date.getDate(); |
|
| |
2963
| + break; |
|
| |
2964
| + case "'": |
|
| |
2965
| + if ( lookAhead( "'" ) ) { |
|
| |
2966
| + checkLiteral(); |
|
| |
2967
| + } else { |
|
| |
2968
| + literal = true; |
|
| |
2969
| + } |
|
| |
2970
| + break; |
|
| |
2971
| + default: |
|
| |
2972
| + checkLiteral(); |
|
| |
2973
| + } |
|
| |
2974
| + } |
|
| |
2975
| + } |
|
| |
2976
| + |
|
| |
2977
| + if ( iValue < value.length ) { |
|
| |
2978
| + extra = value.substr( iValue ); |
|
| |
2979
| + if ( !/^\s+/.test( extra ) ) { |
|
| |
2980
| + throw "Extra/unparsed characters found in date: " + extra; |
|
| |
2981
| + } |
|
| |
2982
| + } |
|
| |
2983
| + |
|
| |
2984
| + if ( year === -1 ) { |
|
| |
2985
| + year = new Date().getFullYear(); |
|
| |
2986
| + } else if ( year < 100 ) { |
|
| |
2987
| + year += new Date().getFullYear() - new Date().getFullYear() % 100 + |
|
| |
2988
| + ( year <= shortYearCutoff ? 0 : -100 ); |
|
| |
2989
| + } |
|
| |
2990
| + |
|
| |
2991
| + if ( doy > -1 ) { |
|
| |
2992
| + month = 1; |
|
| |
2993
| + day = doy; |
|
| |
2994
| + do { |
|
| |
2995
| + dim = this._getDaysInMonth( year, month - 1 ); |
|
| |
2996
| + if ( day <= dim ) { |
|
| |
2997
| + break; |
|
| |
2998
| + } |
|
| |
2999
| + month++; |
|
| |
3000
| + day -= dim; |
|
| |
3001
| + } while ( true ); |
|
| |
3002
| + } |
|
| |
3003
| + |
|
| |
3004
| + date = this._daylightSavingAdjust( new Date( year, month - 1, day ) ); |
|
| |
3005
| + if ( date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day ) { |
|
| |
3006
| + throw "Invalid date"; // E.g. 31/02/00 |
|
| |
3007
| + } |
|
| |
3008
| + return date; |
|
| |
3009
| + }, |
|
| |
3010
| + |
|
| |
3011
| + /* Standard date formats. */ |
|
| |
3012
| + ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601) |
|
| |
3013
| + COOKIE: "D, dd M yy", |
|
| |
3014
| + ISO_8601: "yy-mm-dd", |
|
| |
3015
| + RFC_822: "D, d M y", |
|
| |
3016
| + RFC_850: "DD, dd-M-y", |
|
| |
3017
| + RFC_1036: "D, d M y", |
|
| |
3018
| + RFC_1123: "D, d M yy", |
|
| |
3019
| + RFC_2822: "D, d M yy", |
|
| |
3020
| + RSS: "D, d M y", // RFC 822 |
|
| |
3021
| + TICKS: "!", |
|
| |
3022
| + TIMESTAMP: "@", |
|
| |
3023
| + W3C: "yy-mm-dd", // ISO 8601 |
|
| |
3024
| + |
|
| |
3025
| + _ticksTo1970: ( ( ( 1970 - 1 ) * 365 + Math.floor( 1970 / 4 ) - Math.floor( 1970 / 100 ) + |
|
| |
3026
| + Math.floor( 1970 / 400 ) ) * 24 * 60 * 60 * 10000000 ), |
|
| |
3027
| + |
|
| |
3028
| + /* Format a date object into a string value. |
|
| |
3029
| + * The format can be combinations of the following: |
|
| |
3030
| + * d - day of month (no leading zero) |
|
| |
3031
| + * dd - day of month (two digit) |
|
| |
3032
| + * o - day of year (no leading zeros) |
|
| |
3033
| + * oo - day of year (three digit) |
|
| |
3034
| + * D - day name short |
|
| |
3035
| + * DD - day name long |
|
| |
3036
| + * m - month of year (no leading zero) |
|
| |
3037
| + * mm - month of year (two digit) |
|
| |
3038
| + * M - month name short |
|
| |
3039
| + * MM - month name long |
|
| |
3040
| + * y - year (two digit) |
|
| |
3041
| + * yy - year (four digit) |
|
| |
3042
| + * @ - Unix timestamp (ms since 01/01/1970) |
|
| |
3043
| + * ! - Windows ticks (100ns since 01/01/0001) |
|
| |
3044
| + * "..." - literal text |
|
| |
3045
| + * '' - single quote |
|
| |
3046
| + * |
|
| |
3047
| + * @param format string - the desired format of the date |
|
| |
3048
| + * @param date Date - the date value to format |
|
| |
3049
| + * @param settings Object - attributes include: |
|
| |
3050
| + * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional) |
|
| |
3051
| + * dayNames string[7] - names of the days from Sunday (optional) |
|
| |
3052
| + * monthNamesShort string[12] - abbreviated names of the months (optional) |
|
| |
3053
| + * monthNames string[12] - names of the months (optional) |
|
| |
3054
| + * @return string - the date in the above format |
|
| |
3055
| + */ |
|
| |
3056
| + formatDate: function( format, date, settings ) { |
|
| |
3057
| + if ( !date ) { |
|
| |
3058
| + return ""; |
|
| |
3059
| + } |
|
| |
3060
| + |
|
| |
3061
| + var iFormat, |
|
| |
3062
| + dayNamesShort = ( settings ? settings.dayNamesShort : null ) || this._defaults.dayNamesShort, |
|
| |
3063
| + dayNames = ( settings ? settings.dayNames : null ) || this._defaults.dayNames, |
|
| |
3064
| + monthNamesShort = ( settings ? settings.monthNamesShort : null ) || this._defaults.monthNamesShort, |
|
| |
3065
| + monthNames = ( settings ? settings.monthNames : null ) || this._defaults.monthNames, |
|
| |
3066
| + |
|
| |
3067
| + // Check whether a format character is doubled |
|
| |
3068
| + lookAhead = function( match ) { |
|
| |
3069
| + var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match ); |
|
| |
3070
| + if ( matches ) { |
|
| |
3071
| + iFormat++; |
|
| |
3072
| + } |
|
| |
3073
| + return matches; |
|
| |
3074
| + }, |
|
| |
3075
| + |
|
| |
3076
| + // Format a number, with leading zero if necessary |
|
| |
3077
| + formatNumber = function( match, value, len ) { |
|
| |
3078
| + var num = "" + value; |
|
| |
3079
| + if ( lookAhead( match ) ) { |
|
| |
3080
| + while ( num.length < len ) { |
|
| |
3081
| + num = "0" + num; |
|
| |
3082
| + } |
|
| |
3083
| + } |
|
| |
3084
| + return num; |
|
| |
3085
| + }, |
|
| |
3086
| + |
|
| |
3087
| + // Format a name, short or long as requested |
|
| |
3088
| + formatName = function( match, value, shortNames, longNames ) { |
|
| |
3089
| + return ( lookAhead( match ) ? longNames[ value ] : shortNames[ value ] ); |
|
| |
3090
| + }, |
|
| |
3091
| + output = "", |
|
| |
3092
| + literal = false; |
|
| |
3093
| + |
|
| |
3094
| + if ( date ) { |
|
| |
3095
| + for ( iFormat = 0; iFormat < format.length; iFormat++ ) { |
|
| |
3096
| + if ( literal ) { |
|
| |
3097
| + if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) { |
|
| |
3098
| + literal = false; |
|
| |
3099
| + } else { |
|
| |
3100
| + output += format.charAt( iFormat ); |
|
| |
3101
| + } |
|
| |
3102
| + } else { |
|
| |
3103
| + switch ( format.charAt( iFormat ) ) { |
|
| |
3104
| + case "d": |
|
| |
3105
| + output += formatNumber( "d", date.getDate(), 2 ); |
|
| |
3106
| + break; |
|
| |
3107
| + case "D": |
|
| |
3108
| + output += formatName( "D", date.getDay(), dayNamesShort, dayNames ); |
|
| |
3109
| + break; |
|
| |
3110
| + case "o": |
|
| |
3111
| + output += formatNumber( "o", |
|
| |
3112
| + Math.round( ( new Date( date.getFullYear(), date.getMonth(), date.getDate() ).getTime() - new Date( date.getFullYear(), 0, 0 ).getTime() ) / 86400000 ), 3 ); |
|
| |
3113
| + break; |
|
| |
3114
| + case "m": |
|
| |
3115
| + output += formatNumber( "m", date.getMonth() + 1, 2 ); |
|
| |
3116
| + break; |
|
| |
3117
| + case "M": |
|
| |
3118
| + output += formatName( "M", date.getMonth(), monthNamesShort, monthNames ); |
|
| |
3119
| + break; |
|
| |
3120
| + case "y": |
|
| |
3121
| + output += ( lookAhead( "y" ) ? date.getFullYear() : |
|
| |
3122
| + ( date.getFullYear() % 100 < 10 ? "0" : "" ) + date.getFullYear() % 100 ); |
|
| |
3123
| + break; |
|
| |
3124
| + case "@": |
|
| |
3125
| + output += date.getTime(); |
|
| |
3126
| + break; |
|
| |
3127
| + case "!": |
|
| |
3128
| + output += date.getTime() * 10000 + this._ticksTo1970; |
|
| |
3129
| + break; |
|
| |
3130
| + case "'": |
|
| |
3131
| + if ( lookAhead( "'" ) ) { |
|
| |
3132
| + output += "'"; |
|
| |
3133
| + } else { |
|
| |
3134
| + literal = true; |
|
| |
3135
| + } |
|
| |
3136
| + break; |
|
| |
3137
| + default: |
|
| |
3138
| + output += format.charAt( iFormat ); |
|
| |
3139
| + } |
|
| |
3140
| + } |
|
| |
3141
| + } |
|
| |
3142
| + } |
|
| |
3143
| + return output; |
|
| |
3144
| + }, |
|
| |
3145
| + |
|
| |
3146
| + /* Extract all possible characters from the date format. */ |
|
| |
3147
| + _possibleChars: function( format ) { |
|
| |
3148
| + var iFormat, |
|
| |
3149
| + chars = "", |
|
| |
3150
| + literal = false, |
|
| |
3151
| + |
|
| |
3152
| + // Check whether a format character is doubled |
|
| |
3153
| + lookAhead = function( match ) { |
|
| |
3154
| + var matches = ( iFormat + 1 < format.length && format.charAt( iFormat + 1 ) === match ); |
|
| |
3155
| + if ( matches ) { |
|
| |
3156
| + iFormat++; |
|
| |
3157
| + } |
|
| |
3158
| + return matches; |
|
| |
3159
| + }; |
|
| |
3160
| + |
|
| |
3161
| + for ( iFormat = 0; iFormat < format.length; iFormat++ ) { |
|
| |
3162
| + if ( literal ) { |
|
| |
3163
| + if ( format.charAt( iFormat ) === "'" && !lookAhead( "'" ) ) { |
|
| |
3164
| + literal = false; |
|
| |
3165
| + } else { |
|
| |
3166
| + chars += format.charAt( iFormat ); |
|
| |
3167
| + } |
|
| |
3168
| + } else { |
|
| |
3169
| + switch ( format.charAt( iFormat ) ) { |
|
| |
3170
| + case "d": case "m": case "y": case "@": |
|
| |
3171
| + chars += "0123456789"; |
|
| |
3172
| + break; |
|
| |
3173
| + case "D": case "M": |
|
| |
3174
| + return null; // Accept anything |
|
| |
3175
| + case "'": |
|
| |
3176
| + if ( lookAhead( "'" ) ) { |
|
| |
3177
| + chars += "'"; |
|
| |
3178
| + } else { |
|
| |
3179
| + literal = true; |
|
| |
3180
| + } |
|
| |
3181
| + break; |
|
| |
3182
| + default: |
|
| |
3183
| + chars += format.charAt( iFormat ); |
|
| |
3184
| + } |
|
| |
3185
| + } |
|
| |
3186
| + } |
|
| |
3187
| + return chars; |
|
| |
3188
| + }, |
|
| |
3189
| + |
|
| |
3190
| + /* Get a setting value, defaulting if necessary. */ |
|
| |
3191
| + _get: function( inst, name ) { |
|
| |
3192
| + return inst.settings[ name ] !== undefined ? |
|
| |
3193
| + inst.settings[ name ] : this._defaults[ name ]; |
|
| |
3194
| + }, |
|
| |
3195
| + |
|
| |
3196
| + /* Parse existing date and initialise date picker. */ |
|
| |
3197
| + _setDateFromField: function( inst, noDefault ) { |
|
| |
3198
| + if ( inst.input.val() === inst.lastVal ) { |
|
| |
3199
| + return; |
|
| |
3200
| + } |
|
| |
3201
| + |
|
| |
3202
| + var dateFormat = this._get( inst, "dateFormat" ), |
|
| |
3203
| + dates = inst.lastVal = inst.input ? inst.input.val() : null, |
|
| |
3204
| + defaultDate = this._getDefaultDate( inst ), |
|
| |
3205
| + date = defaultDate, |
|
| |
3206
| + settings = this._getFormatConfig( inst ); |
|
| |
3207
| + |
|
| |
3208
| + try { |
|
| |
3209
| + date = this.parseDate( dateFormat, dates, settings ) || defaultDate; |
|
| |
3210
| + } catch ( event ) { |
|
| |
3211
| + dates = ( noDefault ? "" : dates ); |
|
| |
3212
| + } |
|
| |
3213
| + inst.selectedDay = date.getDate(); |
|
| |
3214
| + inst.drawMonth = inst.selectedMonth = date.getMonth(); |
|
| |
3215
| + inst.drawYear = inst.selectedYear = date.getFullYear(); |
|
| |
3216
| + inst.currentDay = ( dates ? date.getDate() : 0 ); |
|
| |
3217
| + inst.currentMonth = ( dates ? date.getMonth() : 0 ); |
|
| |
3218
| + inst.currentYear = ( dates ? date.getFullYear() : 0 ); |
|
| |
3219
| + this._adjustInstDate( inst ); |
|
| |
3220
| + }, |
|
| |
3221
| + |
|
| |
3222
| + /* Retrieve the default date shown on opening. */ |
|
| |
3223
| + _getDefaultDate: function( inst ) { |
|
| |
3224
| + return this._restrictMinMax( inst, |
|
| |
3225
| + this._determineDate( inst, this._get( inst, "defaultDate" ), new Date() ) ); |
|
| |
3226
| + }, |
|
| |
3227
| + |
|
| |
3228
| + /* A date may be specified as an exact value or a relative one. */ |
|
| |
3229
| + _determineDate: function( inst, date, defaultDate ) { |
|
| |
3230
| + var offsetNumeric = function( offset ) { |
|
| |
3231
| + var date = new Date(); |
|
| |
3232
| + date.setDate( date.getDate() + offset ); |
|
| |
3233
| + return date; |
|
| |
3234
| + }, |
|
| |
3235
| + offsetString = function( offset ) { |
|
| |
3236
| + try { |
|
| |
3237
| + return $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ), |
|
| |
3238
| + offset, $.datepicker._getFormatConfig( inst ) ); |
|
| |
3239
| + } |
|
| |
3240
| + catch ( e ) { |
|
| |
3241
| + |
|
| |
3242
| + // Ignore |
|
| |
3243
| + } |
|
| |
3244
| + |
|
| |
3245
| + var date = ( offset.toLowerCase().match( /^c/ ) ? |
|
| |
3246
| + $.datepicker._getDate( inst ) : null ) || new Date(), |
|
| |
3247
| + year = date.getFullYear(), |
|
| |
3248
| + month = date.getMonth(), |
|
| |
3249
| + day = date.getDate(), |
|
| |
3250
| + pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g, |
|
| |
3251
| + matches = pattern.exec( offset ); |
|
| |
3252
| + |
|
| |
3253
| + while ( matches ) { |
|
| |
3254
| + switch ( matches[ 2 ] || "d" ) { |
|
| |
3255
| + case "d" : case "D" : |
|
| |
3256
| + day += parseInt( matches[ 1 ], 10 ); break; |
|
| |
3257
| + case "w" : case "W" : |
|
| |
3258
| + day += parseInt( matches[ 1 ], 10 ) * 7; break; |
|
| |
3259
| + case "m" : case "M" : |
|
| |
3260
| + month += parseInt( matches[ 1 ], 10 ); |
|
| |
3261
| + day = Math.min( day, $.datepicker._getDaysInMonth( year, month ) ); |
|
| |
3262
| + break; |
|
| |
3263
| + case "y": case "Y" : |
|
| |
3264
| + year += parseInt( matches[ 1 ], 10 ); |
|
| |
3265
| + day = Math.min( day, $.datepicker._getDaysInMonth( year, month ) ); |
|
| |
3266
| + break; |
|
| |
3267
| + } |
|
| |
3268
| + matches = pattern.exec( offset ); |
|
| |
3269
| + } |
|
| |
3270
| + return new Date( year, month, day ); |
|
| |
3271
| + }, |
|
| |
3272
| + newDate = ( date == null || date === "" ? defaultDate : ( typeof date === "string" ? offsetString( date ) : |
|
| |
3273
| + ( typeof date === "number" ? ( isNaN( date ) ? defaultDate : offsetNumeric( date ) ) : new Date( date.getTime() ) ) ) ); |
|
| |
3274
| + |
|
| |
3275
| + newDate = ( newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate ); |
|
| |
3276
| + if ( newDate ) { |
|
| |
3277
| + newDate.setHours( 0 ); |
|
| |
3278
| + newDate.setMinutes( 0 ); |
|
| |
3279
| + newDate.setSeconds( 0 ); |
|
| |
3280
| + newDate.setMilliseconds( 0 ); |
|
| |
3281
| + } |
|
| |
3282
| + return this._daylightSavingAdjust( newDate ); |
|
| |
3283
| + }, |
|
| |
3284
| + |
|
| |
3285
| + /* Handle switch to/from daylight saving. |
|
| |
3286
| + * Hours may be non-zero on daylight saving cut-over: |
|
| |
3287
| + * > 12 when midnight changeover, but then cannot generate |
|
| |
3288
| + * midnight datetime, so jump to 1AM, otherwise reset. |
|
| |
3289
| + * @param date (Date) the date to check |
|
| |
3290
| + * @return (Date) the corrected date |
|
| |
3291
| + */ |
|
| |
3292
| + _daylightSavingAdjust: function( date ) { |
|
| |
3293
| + if ( !date ) { |
|
| |
3294
| + return null; |
|
| |
3295
| + } |
|
| |
3296
| + date.setHours( date.getHours() > 12 ? date.getHours() + 2 : 0 ); |
|
| |
3297
| + return date; |
|
| |
3298
| + }, |
|
| |
3299
| + |
|
| |
3300
| + /* Set the date(s) directly. */ |
|
| |
3301
| + _setDate: function( inst, date, noChange ) { |
|
| |
3302
| + var clear = !date, |
|
| |
3303
| + origMonth = inst.selectedMonth, |
|
| |
3304
| + origYear = inst.selectedYear, |
|
| |
3305
| + newDate = this._restrictMinMax( inst, this._determineDate( inst, date, new Date() ) ); |
|
| |
3306
| + |
|
| |
3307
| + inst.selectedDay = inst.currentDay = newDate.getDate(); |
|
| |
3308
| + inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth(); |
|
| |
3309
| + inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear(); |
|
| |
3310
| + if ( ( origMonth !== inst.selectedMonth || origYear !== inst.selectedYear ) && !noChange ) { |
|
| |
3311
| + this._notifyChange( inst ); |
|
| |
3312
| + } |
|
| |
3313
| + this._adjustInstDate( inst ); |
|
| |
3314
| + if ( inst.input ) { |
|
| |
3315
| + inst.input.val( clear ? "" : this._formatDate( inst ) ); |
|
| |
3316
| + } |
|
| |
3317
| + }, |
|
| |
3318
| + |
|
| |
3319
| + /* Retrieve the date(s) directly. */ |
|
| |
3320
| + _getDate: function( inst ) { |
|
| |
3321
| + var startDate = ( !inst.currentYear || ( inst.input && inst.input.val() === "" ) ? null : |
|
| |
3322
| + this._daylightSavingAdjust( new Date( |
|
| |
3323
| + inst.currentYear, inst.currentMonth, inst.currentDay ) ) ); |
|
| |
3324
| + return startDate; |
|
| |
3325
| + }, |
|
| |
3326
| + |
|
| |
3327
| + /* Attach the onxxx handlers. These are declared statically so |
|
| |
3328
| + * they work with static code transformers like Caja. |
|
| |
3329
| + */ |
|
| |
3330
| + _attachHandlers: function( inst ) { |
|
| |
3331
| + var stepMonths = this._get( inst, "stepMonths" ), |
|
| |
3332
| + id = "#" + inst.id.replace( /\\\\/g, "\\" ); |
|
| |
3333
| + inst.dpDiv.find( "[data-handler]" ).map( function() { |
|
| |
3334
| + var handler = { |
|
| |
3335
| + prev: function() { |
|
| |
3336
| + $.datepicker._adjustDate( id, -stepMonths, "M" ); |
|
| |
3337
| + }, |
|
| |
3338
| + next: function() { |
|
| |
3339
| + $.datepicker._adjustDate( id, +stepMonths, "M" ); |
|
| |
3340
| + }, |
|
| |
3341
| + hide: function() { |
|
| |
3342
| + $.datepicker._hideDatepicker(); |
|
| |
3343
| + }, |
|
| |
3344
| + today: function() { |
|
| |
3345
| + $.datepicker._gotoToday( id ); |
|
| |
3346
| + }, |
|
| |
3347
| + selectDay: function() { |
|
| |
3348
| + $.datepicker._selectDay( id, +this.getAttribute( "data-month" ), +this.getAttribute( "data-year" ), this ); |
|
| |
3349
| + return false; |
|
| |
3350
| + }, |
|
| |
3351
| + selectMonth: function() { |
|
| |
3352
| + $.datepicker._selectMonthYear( id, this, "M" ); |
|
| |
3353
| + return false; |
|
| |
3354
| + }, |
|
| |
3355
| + selectYear: function() { |
|
| |
3356
| + $.datepicker._selectMonthYear( id, this, "Y" ); |
|
| |
3357
| + return false; |
|
| |
3358
| + } |
|
| |
3359
| + }; |
|
| |
3360
| + $( this ).on( this.getAttribute( "data-event" ), handler[ this.getAttribute( "data-handler" ) ] ); |
|
| |
3361
| + } ); |
|
| |
3362
| + }, |
|
| |
3363
| + |
|
| |
3364
| + /* Generate the HTML for the current state of the date picker. */ |
|
| |
3365
| + _generateHTML: function( inst ) { |
|
| |
3366
| + var maxDraw, prevText, prev, nextText, next, currentText, gotoDate, |
|
| |
3367
| + controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin, |
|
| |
3368
| + monthNames, monthNamesShort, beforeShowDay, showOtherMonths, |
|
| |
3369
| + selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate, |
|
| |
3370
| + cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows, |
|
| |
3371
| + printDate, dRow, tbody, daySettings, otherMonth, unselectable, |
|
| |
3372
| + tempDate = new Date(), |
|
| |
3373
| + today = this._daylightSavingAdjust( |
|
| |
3374
| + new Date( tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate() ) ), // clear time |
|
| |
3375
| + isRTL = this._get( inst, "isRTL" ), |
|
| |
3376
| + showButtonPanel = this._get( inst, "showButtonPanel" ), |
|
| |
3377
| + hideIfNoPrevNext = this._get( inst, "hideIfNoPrevNext" ), |
|
| |
3378
| + navigationAsDateFormat = this._get( inst, "navigationAsDateFormat" ), |
|
| |
3379
| + numMonths = this._getNumberOfMonths( inst ), |
|
| |
3380
| + showCurrentAtPos = this._get( inst, "showCurrentAtPos" ), |
|
| |
3381
| + stepMonths = this._get( inst, "stepMonths" ), |
|
| |
3382
| + isMultiMonth = ( numMonths[ 0 ] !== 1 || numMonths[ 1 ] !== 1 ), |
|
| |
3383
| + currentDate = this._daylightSavingAdjust( ( !inst.currentDay ? new Date( 9999, 9, 9 ) : |
|
| |
3384
| + new Date( inst.currentYear, inst.currentMonth, inst.currentDay ) ) ), |
|
| |
3385
| + minDate = this._getMinMaxDate( inst, "min" ), |
|
| |
3386
| + maxDate = this._getMinMaxDate( inst, "max" ), |
|
| |
3387
| + drawMonth = inst.drawMonth - showCurrentAtPos, |
|
| |
3388
| + drawYear = inst.drawYear; |
|
| |
3389
| + |
|
| |
3390
| + if ( drawMonth < 0 ) { |
|
| |
3391
| + drawMonth += 12; |
|
| |
3392
| + drawYear--; |
|
| |
3393
| + } |
|
| |
3394
| + if ( maxDate ) { |
|
| |
3395
| + maxDraw = this._daylightSavingAdjust( new Date( maxDate.getFullYear(), |
|
| |
3396
| + maxDate.getMonth() - ( numMonths[ 0 ] * numMonths[ 1 ] ) + 1, maxDate.getDate() ) ); |
|
| |
3397
| + maxDraw = ( minDate && maxDraw < minDate ? minDate : maxDraw ); |
|
| |
3398
| + while ( this._daylightSavingAdjust( new Date( drawYear, drawMonth, 1 ) ) > maxDraw ) { |
|
| |
3399
| + drawMonth--; |
|
| |
3400
| + if ( drawMonth < 0 ) { |
|
| |
3401
| + drawMonth = 11; |
|
| |
3402
| + drawYear--; |
|
| |
3403
| + } |
|
| |
3404
| + } |
|
| |
3405
| + } |
|
| |
3406
| + inst.drawMonth = drawMonth; |
|
| |
3407
| + inst.drawYear = drawYear; |
|
| |
3408
| + |
|
| |
3409
| + prevText = this._get( inst, "prevText" ); |
|
| |
3410
| + prevText = ( !navigationAsDateFormat ? prevText : this.formatDate( prevText, |
|
| |
3411
| + this._daylightSavingAdjust( new Date( drawYear, drawMonth - stepMonths, 1 ) ), |
|
| |
3412
| + this._getFormatConfig( inst ) ) ); |
|
| |
3413
| + |
|
| |
3414
| + prev = ( this._canAdjustMonth( inst, -1, drawYear, drawMonth ) ? |
|
| |
3415
| + "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" + |
|
| |
3416
| + " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w" ) + "'>" + prevText + "</span></a>" : |
|
| |
3417
| + ( hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w" ) + "'>" + prevText + "</span></a>" ) ); |
|
| |
3418
| + |
|
| |
3419
| + nextText = this._get( inst, "nextText" ); |
|
| |
3420
| + nextText = ( !navigationAsDateFormat ? nextText : this.formatDate( nextText, |
|
| |
3421
| + this._daylightSavingAdjust( new Date( drawYear, drawMonth + stepMonths, 1 ) ), |
|
| |
3422
| + this._getFormatConfig( inst ) ) ); |
|
| |
3423
| + |
|
| |
3424
| + next = ( this._canAdjustMonth( inst, +1, drawYear, drawMonth ) ? |
|
| |
3425
| + "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" + |
|
| |
3426
| + " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e" ) + "'>" + nextText + "</span></a>" : |
|
| |
3427
| + ( hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e" ) + "'>" + nextText + "</span></a>" ) ); |
|
| |
3428
| + |
|
| |
3429
| + currentText = this._get( inst, "currentText" ); |
|
| |
3430
| + gotoDate = ( this._get( inst, "gotoCurrent" ) && inst.currentDay ? currentDate : today ); |
|
| |
3431
| + currentText = ( !navigationAsDateFormat ? currentText : |
|
| |
3432
| + this.formatDate( currentText, gotoDate, this._getFormatConfig( inst ) ) ); |
|
| |
3433
| + |
|
| |
3434
| + controls = ( !inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" + |
|
| |
3435
| + this._get( inst, "closeText" ) + "</button>" : "" ); |
|
| |
3436
| + |
|
| |
3437
| + buttonPanel = ( showButtonPanel ) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + ( isRTL ? controls : "" ) + |
|
| |
3438
| + ( this._isInRange( inst, gotoDate ) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" + |
|
| |
3439
| + ">" + currentText + "</button>" : "" ) + ( isRTL ? "" : controls ) + "</div>" : ""; |
|
| |
3440
| + |
|
| |
3441
| + firstDay = parseInt( this._get( inst, "firstDay" ), 10 ); |
|
| |
3442
| + firstDay = ( isNaN( firstDay ) ? 0 : firstDay ); |
|
| |
3443
| + |
|
| |
3444
| + showWeek = this._get( inst, "showWeek" ); |
|
| |
3445
| + dayNames = this._get( inst, "dayNames" ); |
|
| |
3446
| + dayNamesMin = this._get( inst, "dayNamesMin" ); |
|
| |
3447
| + monthNames = this._get( inst, "monthNames" ); |
|
| |
3448
| + monthNamesShort = this._get( inst, "monthNamesShort" ); |
|
| |
3449
| + beforeShowDay = this._get( inst, "beforeShowDay" ); |
|
| |
3450
| + showOtherMonths = this._get( inst, "showOtherMonths" ); |
|
| |
3451
| + selectOtherMonths = this._get( inst, "selectOtherMonths" ); |
|
| |
3452
| + defaultDate = this._getDefaultDate( inst ); |
|
| |
3453
| + html = ""; |
|
| |
3454
| + |
|
| |
3455
| + for ( row = 0; row < numMonths[ 0 ]; row++ ) { |
|
| |
3456
| + group = ""; |
|
| |
3457
| + this.maxRows = 4; |
|
| |
3458
| + for ( col = 0; col < numMonths[ 1 ]; col++ ) { |
|
| |
3459
| + selectedDate = this._daylightSavingAdjust( new Date( drawYear, drawMonth, inst.selectedDay ) ); |
|
| |
3460
| + cornerClass = " ui-corner-all"; |
|
| |
3461
| + calender = ""; |
|
| |
3462
| + if ( isMultiMonth ) { |
|
| |
3463
| + calender += "<div class='ui-datepicker-group"; |
|
| |
3464
| + if ( numMonths[ 1 ] > 1 ) { |
|
| |
3465
| + switch ( col ) { |
|
| |
3466
| + case 0: calender += " ui-datepicker-group-first"; |
|
| |
3467
| + cornerClass = " ui-corner-" + ( isRTL ? "right" : "left" ); break; |
|
| |
3468
| + case numMonths[ 1 ] - 1: calender += " ui-datepicker-group-last"; |
|
| |
3469
| + cornerClass = " ui-corner-" + ( isRTL ? "left" : "right" ); break; |
|
| |
3470
| + default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break; |
|
| |
3471
| + } |
|
| |
3472
| + } |
|
| |
3473
| + calender += "'>"; |
|
| |
3474
| + } |
|
| |
3475
| + calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" + |
|
| |
3476
| + ( /all|left/.test( cornerClass ) && row === 0 ? ( isRTL ? next : prev ) : "" ) + |
|
| |
3477
| + ( /all|right/.test( cornerClass ) && row === 0 ? ( isRTL ? prev : next ) : "" ) + |
|
| |
3478
| + this._generateMonthYearHeader( inst, drawMonth, drawYear, minDate, maxDate, |
|
| |
3479
| + row > 0 || col > 0, monthNames, monthNamesShort ) + // draw month headers |
|
| |
3480
| + "</div><table class='ui-datepicker-calendar'><thead>" + |
|
| |
3481
| + "<tr>"; |
|
| |
3482
| + thead = ( showWeek ? "<th class='ui-datepicker-week-col'>" + this._get( inst, "weekHeader" ) + "</th>" : "" ); |
|
| |
3483
| + for ( dow = 0; dow < 7; dow++ ) { // days of the week |
|
| |
3484
| + day = ( dow + firstDay ) % 7; |
|
| |
3485
| + thead += "<th scope='col'" + ( ( dow + firstDay + 6 ) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "" ) + ">" + |
|
| |
3486
| + "<span title='" + dayNames[ day ] + "'>" + dayNamesMin[ day ] + "</span></th>"; |
|
| |
3487
| + } |
|
| |
3488
| + calender += thead + "</tr></thead><tbody>"; |
|
| |
3489
| + daysInMonth = this._getDaysInMonth( drawYear, drawMonth ); |
|
| |
3490
| + if ( drawYear === inst.selectedYear && drawMonth === inst.selectedMonth ) { |
|
| |
3491
| + inst.selectedDay = Math.min( inst.selectedDay, daysInMonth ); |
|
| |
3492
| + } |
|
| |
3493
| + leadDays = ( this._getFirstDayOfMonth( drawYear, drawMonth ) - firstDay + 7 ) % 7; |
|
| |
3494
| + curRows = Math.ceil( ( leadDays + daysInMonth ) / 7 ); // calculate the number of rows to generate |
|
| |
3495
| + numRows = ( isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows ); //If multiple months, use the higher number of rows (see #7043) |
|
| |
3496
| + this.maxRows = numRows; |
|
| |
3497
| + printDate = this._daylightSavingAdjust( new Date( drawYear, drawMonth, 1 - leadDays ) ); |
|
| |
3498
| + for ( dRow = 0; dRow < numRows; dRow++ ) { // create date picker rows |
|
| |
3499
| + calender += "<tr>"; |
|
| |
3500
| + tbody = ( !showWeek ? "" : "<td class='ui-datepicker-week-col'>" + |
|
| |
3501
| + this._get( inst, "calculateWeek" )( printDate ) + "</td>" ); |
|
| |
3502
| + for ( dow = 0; dow < 7; dow++ ) { // create date picker days |
|
| |
3503
| + daySettings = ( beforeShowDay ? |
|
| |
3504
| + beforeShowDay.apply( ( inst.input ? inst.input[ 0 ] : null ), [ printDate ] ) : [ true, "" ] ); |
|
| |
3505
| + otherMonth = ( printDate.getMonth() !== drawMonth ); |
|
| |
3506
| + unselectable = ( otherMonth && !selectOtherMonths ) || !daySettings[ 0 ] || |
|
| |
3507
| + ( minDate && printDate < minDate ) || ( maxDate && printDate > maxDate ); |
|
| |
3508
| + tbody += "<td class='" + |
|
| |
3509
| + ( ( dow + firstDay + 6 ) % 7 >= 5 ? " ui-datepicker-week-end" : "" ) + // highlight weekends |
|
| |
3510
| + ( otherMonth ? " ui-datepicker-other-month" : "" ) + // highlight days from other months |
|
| |
3511
| + ( ( printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent ) || // user pressed key |
|
| |
3512
| + ( defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime() ) ? |
|
| |
3513
| + |
|
| |
3514
| + // or defaultDate is current printedDate and defaultDate is selectedDate |
|
| |
3515
| + " " + this._dayOverClass : "" ) + // highlight selected day |
|
| |
3516
| + ( unselectable ? " " + this._unselectableClass + " ui-state-disabled" : "" ) + // highlight unselectable days |
|
| |
3517
| + ( otherMonth && !showOtherMonths ? "" : " " + daySettings[ 1 ] + // highlight custom dates |
|
| |
3518
| + ( printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "" ) + // highlight selected day |
|
| |
3519
| + ( printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "" ) ) + "'" + // highlight today (if different) |
|
| |
3520
| + ( ( !otherMonth || showOtherMonths ) && daySettings[ 2 ] ? " title='" + daySettings[ 2 ].replace( /'/g, "'" ) + "'" : "" ) + // cell title |
|
| |
3521
| + ( unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'" ) + ">" + // actions |
|
| |
3522
| + ( otherMonth && !showOtherMonths ? " " : // display for other months |
|
| |
3523
| + ( unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" + |
|
| |
3524
| + ( printDate.getTime() === today.getTime() ? " ui-state-highlight" : "" ) + |
|
| |
3525
| + ( printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "" ) + // highlight selected day |
|
| |
3526
| + ( otherMonth ? " ui-priority-secondary" : "" ) + // distinguish dates from other months |
|
| |
3527
| + "' href='#'>" + printDate.getDate() + "</a>" ) ) + "</td>"; // display selectable date |
|
| |
3528
| + printDate.setDate( printDate.getDate() + 1 ); |
|
| |
3529
| + printDate = this._daylightSavingAdjust( printDate ); |
|
| |
3530
| + } |
|
| |
3531
| + calender += tbody + "</tr>"; |
|
| |
3532
| + } |
|
| |
3533
| + drawMonth++; |
|
| |
3534
| + if ( drawMonth > 11 ) { |
|
| |
3535
| + drawMonth = 0; |
|
| |
3536
| + drawYear++; |
|
| |
3537
| + } |
|
| |
3538
| + calender += "</tbody></table>" + ( isMultiMonth ? "</div>" + |
|
| |
3539
| + ( ( numMonths[ 0 ] > 0 && col === numMonths[ 1 ] - 1 ) ? "<div class='ui-datepicker-row-break'></div>" : "" ) : "" ); |
|
| |
3540
| + group += calender; |
|
| |
3541
| + } |
|
| |
3542
| + html += group; |
|
| |
3543
| + } |
|
| |
3544
| + html += buttonPanel; |
|
| |
3545
| + inst._keyEvent = false; |
|
| |
3546
| + return html; |
|
| |
3547
| + }, |
|
| |
3548
| + |
|
| |
3549
| + /* Generate the month and year header. */ |
|
| |
3550
| + _generateMonthYearHeader: function( inst, drawMonth, drawYear, minDate, maxDate, |
|
| |
3551
| + secondary, monthNames, monthNamesShort ) { |
|
| |
3552
| + |
|
| |
3553
| + var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear, |
|
| |
3554
| + changeMonth = this._get( inst, "changeMonth" ), |
|
| |
3555
| + changeYear = this._get( inst, "changeYear" ), |
|
| |
3556
| + showMonthAfterYear = this._get( inst, "showMonthAfterYear" ), |
|
| |
3557
| + html = "<div class='ui-datepicker-title'>", |
|
| |
3558
| + monthHtml = ""; |
|
| |
3559
| + |
|
| |
3560
| + // Month selection |
|
| |
3561
| + if ( secondary || !changeMonth ) { |
|
| |
3562
| + monthHtml += "<span class='ui-datepicker-month'>" + monthNames[ drawMonth ] + "</span>"; |
|
| |
3563
| + } else { |
|
| |
3564
| + inMinYear = ( minDate && minDate.getFullYear() === drawYear ); |
|
| |
3565
| + inMaxYear = ( maxDate && maxDate.getFullYear() === drawYear ); |
|
| |
3566
| + monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>"; |
|
| |
3567
| + for ( month = 0; month < 12; month++ ) { |
|
| |
3568
| + if ( ( !inMinYear || month >= minDate.getMonth() ) && ( !inMaxYear || month <= maxDate.getMonth() ) ) { |
|
| |
3569
| + monthHtml += "<option value='" + month + "'" + |
|
| |
3570
| + ( month === drawMonth ? " selected='selected'" : "" ) + |
|
| |
3571
| + ">" + monthNamesShort[ month ] + "</option>"; |
|
| |
3572
| + } |
|
| |
3573
| + } |
|
| |
3574
| + monthHtml += "</select>"; |
|
| |
3575
| + } |
|
| |
3576
| + |
|
| |
3577
| + if ( !showMonthAfterYear ) { |
|
| |
3578
| + html += monthHtml + ( secondary || !( changeMonth && changeYear ) ? " " : "" ); |
|
| |
3579
| + } |
|
| |
3580
| + |
|
| |
3581
| + // Year selection |
|
| |
3582
| + if ( !inst.yearshtml ) { |
|
| |
3583
| + inst.yearshtml = ""; |
|
| |
3584
| + if ( secondary || !changeYear ) { |
|
| |
3585
| + html += "<span class='ui-datepicker-year'>" + drawYear + "</span>"; |
|
| |
3586
| + } else { |
|
| |
3587
| + |
|
| |
3588
| + // determine range of years to display |
|
| |
3589
| + years = this._get( inst, "yearRange" ).split( ":" ); |
|
| |
3590
| + thisYear = new Date().getFullYear(); |
|
| |
3591
| + determineYear = function( value ) { |
|
| |
3592
| + var year = ( value.match( /c[+\-].*/ ) ? drawYear + parseInt( value.substring( 1 ), 10 ) : |
|
| |
3593
| + ( value.match( /[+\-].*/ ) ? thisYear + parseInt( value, 10 ) : |
|
| |
3594
| + parseInt( value, 10 ) ) ); |
|
| |
3595
| + return ( isNaN( year ) ? thisYear : year ); |
|
| |
3596
| + }; |
|
| |
3597
| + year = determineYear( years[ 0 ] ); |
|
| |
3598
| + endYear = Math.max( year, determineYear( years[ 1 ] || "" ) ); |
|
| |
3599
| + year = ( minDate ? Math.max( year, minDate.getFullYear() ) : year ); |
|
| |
3600
| + endYear = ( maxDate ? Math.min( endYear, maxDate.getFullYear() ) : endYear ); |
|
| |
3601
| + inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>"; |
|
| |
3602
| + for ( ; year <= endYear; year++ ) { |
|
| |
3603
| + inst.yearshtml += "<option value='" + year + "'" + |
|
| |
3604
| + ( year === drawYear ? " selected='selected'" : "" ) + |
|
| |
3605
| + ">" + year + "</option>"; |
|
| |
3606
| + } |
|
| |
3607
| + inst.yearshtml += "</select>"; |
|
| |
3608
| + |
|
| |
3609
| + html += inst.yearshtml; |
|
| |
3610
| + inst.yearshtml = null; |
|
| |
3611
| + } |
|
| |
3612
| + } |
|
| |
3613
| + |
|
| |
3614
| + html += this._get( inst, "yearSuffix" ); |
|
| |
3615
| + if ( showMonthAfterYear ) { |
|
| |
3616
| + html += ( secondary || !( changeMonth && changeYear ) ? " " : "" ) + monthHtml; |
|
| |
3617
| + } |
|
| |
3618
| + html += "</div>"; // Close datepicker_header |
|
| |
3619
| + return html; |
|
| |
3620
| + }, |
|
| |
3621
| + |
|
| |
3622
| + /* Adjust one of the date sub-fields. */ |
|
| |
3623
| + _adjustInstDate: function( inst, offset, period ) { |
|
| |
3624
| + var year = inst.selectedYear + ( period === "Y" ? offset : 0 ), |
|
| |
3625
| + month = inst.selectedMonth + ( period === "M" ? offset : 0 ), |
|
| |
3626
| + day = Math.min( inst.selectedDay, this._getDaysInMonth( year, month ) ) + ( period === "D" ? offset : 0 ), |
|
| |
3627
| + date = this._restrictMinMax( inst, this._daylightSavingAdjust( new Date( year, month, day ) ) ); |
|
| |
3628
| + |
|
| |
3629
| + inst.selectedDay = date.getDate(); |
|
| |
3630
| + inst.drawMonth = inst.selectedMonth = date.getMonth(); |
|
| |
3631
| + inst.drawYear = inst.selectedYear = date.getFullYear(); |
|
| |
3632
| + if ( period === "M" || period === "Y" ) { |
|
| |
3633
| + this._notifyChange( inst ); |
|
| |
3634
| + } |
|
| |
3635
| + }, |
|
| |
3636
| + |
|
| |
3637
| + /* Ensure a date is within any min/max bounds. */ |
|
| |
3638
| + _restrictMinMax: function( inst, date ) { |
|
| |
3639
| + var minDate = this._getMinMaxDate( inst, "min" ), |
|
| |
3640
| + maxDate = this._getMinMaxDate( inst, "max" ), |
|
| |
3641
| + newDate = ( minDate && date < minDate ? minDate : date ); |
|
| |
3642
| + return ( maxDate && newDate > maxDate ? maxDate : newDate ); |
|
| |
3643
| + }, |
|
| |
3644
| + |
|
| |
3645
| + /* Notify change of month/year. */ |
|
| |
3646
| + _notifyChange: function( inst ) { |
|
| |
3647
| + var onChange = this._get( inst, "onChangeMonthYear" ); |
|
| |
3648
| + if ( onChange ) { |
|
| |
3649
| + onChange.apply( ( inst.input ? inst.input[ 0 ] : null ), |
|
| |
3650
| + [ inst.selectedYear, inst.selectedMonth + 1, inst ] ); |
|
| |
3651
| + } |
|
| |
3652
| + }, |
|
| |
3653
| + |
|
| |
3654
| + /* Determine the number of months to show. */ |
|
| |
3655
| + _getNumberOfMonths: function( inst ) { |
|
| |
3656
| + var numMonths = this._get( inst, "numberOfMonths" ); |
|
| |
3657
| + return ( numMonths == null ? [ 1, 1 ] : ( typeof numMonths === "number" ? [ 1, numMonths ] : numMonths ) ); |
|
| |
3658
| + }, |
|
| |
3659
| + |
|
| |
3660
| + /* Determine the current maximum date - ensure no time components are set. */ |
|
| |
3661
| + _getMinMaxDate: function( inst, minMax ) { |
|
| |
3662
| + return this._determineDate( inst, this._get( inst, minMax + "Date" ), null ); |
|
| |
3663
| + }, |
|
| |
3664
| + |
|
| |
3665
| + /* Find the number of days in a given month. */ |
|
| |
3666
| + _getDaysInMonth: function( year, month ) { |
|
| |
3667
| + return 32 - this._daylightSavingAdjust( new Date( year, month, 32 ) ).getDate(); |
|
| |
3668
| + }, |
|
| |
3669
| + |
|
| |
3670
| + /* Find the day of the week of the first of a month. */ |
|
| |
3671
| + _getFirstDayOfMonth: function( year, month ) { |
|
| |
3672
| + return new Date( year, month, 1 ).getDay(); |
|
| |
3673
| + }, |
|
| |
3674
| + |
|
| |
3675
| + /* Determines if we should allow a "next/prev" month display change. */ |
|
| |
3676
| + _canAdjustMonth: function( inst, offset, curYear, curMonth ) { |
|
| |
3677
| + var numMonths = this._getNumberOfMonths( inst ), |
|
| |
3678
| + date = this._daylightSavingAdjust( new Date( curYear, |
|
| |
3679
| + curMonth + ( offset < 0 ? offset : numMonths[ 0 ] * numMonths[ 1 ] ), 1 ) ); |
|
| |
3680
| + |
|
| |
3681
| + if ( offset < 0 ) { |
|
| |
3682
| + date.setDate( this._getDaysInMonth( date.getFullYear(), date.getMonth() ) ); |
|
| |
3683
| + } |
|
| |
3684
| + return this._isInRange( inst, date ); |
|
| |
3685
| + }, |
|
| |
3686
| + |
|
| |
3687
| + /* Is the given date in the accepted range? */ |
|
| |
3688
| + _isInRange: function( inst, date ) { |
|
| |
3689
| + var yearSplit, currentYear, |
|
| |
3690
| + minDate = this._getMinMaxDate( inst, "min" ), |
|
| |
3691
| + maxDate = this._getMinMaxDate( inst, "max" ), |
|
| |
3692
| + minYear = null, |
|
| |
3693
| + maxYear = null, |
|
| |
3694
| + years = this._get( inst, "yearRange" ); |
|
| |
3695
| + if ( years ) { |
|
| |
3696
| + yearSplit = years.split( ":" ); |
|
| |
3697
| + currentYear = new Date().getFullYear(); |
|
| |
3698
| + minYear = parseInt( yearSplit[ 0 ], 10 ); |
|
| |
3699
| + maxYear = parseInt( yearSplit[ 1 ], 10 ); |
|
| |
3700
| + if ( yearSplit[ 0 ].match( /[+\-].*/ ) ) { |
|
| |
3701
| + minYear += currentYear; |
|
| |
3702
| + } |
|
| |
3703
| + if ( yearSplit[ 1 ].match( /[+\-].*/ ) ) { |
|
| |
3704
| + maxYear += currentYear; |
|
| |
3705
| + } |
|
| |
3706
| + } |
|
| |
3707
| + |
|
| |
3708
| + return ( ( !minDate || date.getTime() >= minDate.getTime() ) && |
|
| |
3709
| + ( !maxDate || date.getTime() <= maxDate.getTime() ) && |
|
| |
3710
| + ( !minYear || date.getFullYear() >= minYear ) && |
|
| |
3711
| + ( !maxYear || date.getFullYear() <= maxYear ) ); |
|
| |
3712
| + }, |
|
| |
3713
| + |
|
| |
3714
| + /* Provide the configuration settings for formatting/parsing. */ |
|
| |
3715
| + _getFormatConfig: function( inst ) { |
|
| |
3716
| + var shortYearCutoff = this._get( inst, "shortYearCutoff" ); |
|
| |
3717
| + shortYearCutoff = ( typeof shortYearCutoff !== "string" ? shortYearCutoff : |
|
| |
3718
| + new Date().getFullYear() % 100 + parseInt( shortYearCutoff, 10 ) ); |
|
| |
3719
| + return { shortYearCutoff: shortYearCutoff, |
|
| |
3720
| + dayNamesShort: this._get( inst, "dayNamesShort" ), dayNames: this._get( inst, "dayNames" ), |
|
| |
3721
| + monthNamesShort: this._get( inst, "monthNamesShort" ), monthNames: this._get( inst, "monthNames" ) }; |
|
| |
3722
| + }, |
|
| |
3723
| + |
|
| |
3724
| + /* Format the given date for display. */ |
|
| |
3725
| + _formatDate: function( inst, day, month, year ) { |
|
| |
3726
| + if ( !day ) { |
|
| |
3727
| + inst.currentDay = inst.selectedDay; |
|
| |
3728
| + inst.currentMonth = inst.selectedMonth; |
|
| |
3729
| + inst.currentYear = inst.selectedYear; |
|
| |
3730
| + } |
|
| |
3731
| + var date = ( day ? ( typeof day === "object" ? day : |
|
| |
3732
| + this._daylightSavingAdjust( new Date( year, month, day ) ) ) : |
|
| |
3733
| + this._daylightSavingAdjust( new Date( inst.currentYear, inst.currentMonth, inst.currentDay ) ) ); |
|
| |
3734
| + return this.formatDate( this._get( inst, "dateFormat" ), date, this._getFormatConfig( inst ) ); |
|
| |
3735
| + } |
|
| |
3736
| +} ); |
|
| |
3737
| + |
|
| |
3738
| +/* |
|
| |
3739
| + * Bind hover events for datepicker elements. |
|
| |
3740
| + * Done via delegate so the binding only occurs once in the lifetime of the parent div. |
|
| |
3741
| + * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker. |
|
| |
3742
| + */ |
|
| |
3743
| +function datepicker_bindHover( dpDiv ) { |
|
| |
3744
| + var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a"; |
|
| |
3745
| + return dpDiv.on( "mouseout", selector, function() { |
|
| |
3746
| + $( this ).removeClass( "ui-state-hover" ); |
|
| |
3747
| + if ( this.className.indexOf( "ui-datepicker-prev" ) !== -1 ) { |
|
| |
3748
| + $( this ).removeClass( "ui-datepicker-prev-hover" ); |
|
| |
3749
| + } |
|
| |
3750
| + if ( this.className.indexOf( "ui-datepicker-next" ) !== -1 ) { |
|
| |
3751
| + $( this ).removeClass( "ui-datepicker-next-hover" ); |
|
| |
3752
| + } |
|
| |
3753
| + } ) |
|
| |
3754
| + .on( "mouseover", selector, datepicker_handleMouseover ); |
|
| |
3755
| +} |
|
| |
3756
| + |
|
| |
3757
| +function datepicker_handleMouseover() { |
|
| |
3758
| + if ( !$.datepicker._isDisabledDatepicker( datepicker_instActive.inline ? datepicker_instActive.dpDiv.parent()[ 0 ] : datepicker_instActive.input[ 0 ] ) ) { |
|
| |
3759
| + $( this ).parents( ".ui-datepicker-calendar" ).find( "a" ).removeClass( "ui-state-hover" ); |
|
| |
3760
| + $( this ).addClass( "ui-state-hover" ); |
|
| |
3761
| + if ( this.className.indexOf( "ui-datepicker-prev" ) !== -1 ) { |
|
| |
3762
| + $( this ).addClass( "ui-datepicker-prev-hover" ); |
|
| |
3763
| + } |
|
| |
3764
| + if ( this.className.indexOf( "ui-datepicker-next" ) !== -1 ) { |
|
| |
3765
| + $( this ).addClass( "ui-datepicker-next-hover" ); |
|
| |
3766
| + } |
|
| |
3767
| + } |
|
| |
3768
| +} |
|
| |
3769
| + |
|
| |
3770
| +/* jQuery extend now ignores nulls! */ |
|
| |
3771
| +function datepicker_extendRemove( target, props ) { |
|
| |
3772
| + $.extend( target, props ); |
|
| |
3773
| + for ( var name in props ) { |
|
| |
3774
| + if ( props[ name ] == null ) { |
|
| |
3775
| + target[ name ] = props[ name ]; |
|
| |
3776
| + } |
|
| |
3777
| + } |
|
| |
3778
| + return target; |
|
| |
3779
| +} |
|
| |
3780
| + |
|
| |
3781
| +/* Invoke the datepicker functionality. |
|
| |
3782
| + @param options string - a command, optionally followed by additional parameters or |
|
| |
3783
| + Object - settings for attaching new datepicker functionality |
|
| |
3784
| + @return jQuery object */ |
|
| |
3785
| +$.fn.datepicker = function( options ) { |
|
| |
3786
| + |
|
| |
3787
| + /* Verify an empty collection wasn't passed - Fixes #6976 */ |
|
| |
3788
| + if ( !this.length ) { |
|
| |
3789
| + return this; |
|
| |
3790
| + } |
|
| |
3791
| + |
|
| |
3792
| + /* Initialise the date picker. */ |
|
| |
3793
| + if ( !$.datepicker.initialized ) { |
|
| |
3794
| + $( document ).on( "mousedown", $.datepicker._checkExternalClick ); |
|
| |
3795
| + $.datepicker.initialized = true; |
|
| |
3796
| + } |
|
| |
3797
| + |
|
| |
3798
| + /* Append datepicker main container to body if not exist. */ |
|
| |
3799
| + if ( $( "#" + $.datepicker._mainDivId ).length === 0 ) { |
|
| |
3800
| + $( "body" ).append( $.datepicker.dpDiv ); |
|
| |
3801
| + } |
|
| |
3802
| + |
|
| |
3803
| + var otherArgs = Array.prototype.slice.call( arguments, 1 ); |
|
| |
3804
| + if ( typeof options === "string" && ( options === "isDisabled" || options === "getDate" || options === "widget" ) ) { |
|
| |
3805
| + return $.datepicker[ "_" + options + "Datepicker" ]. |
|
| |
3806
| + apply( $.datepicker, [ this[ 0 ] ].concat( otherArgs ) ); |
|
| |
3807
| + } |
|
| |
3808
| + if ( options === "option" && arguments.length === 2 && typeof arguments[ 1 ] === "string" ) { |
|
| |
3809
| + return $.datepicker[ "_" + options + "Datepicker" ]. |
|
| |
3810
| + apply( $.datepicker, [ this[ 0 ] ].concat( otherArgs ) ); |
|
| |
3811
| + } |
|
| |
3812
| + return this.each( function() { |
|
| |
3813
| + typeof options === "string" ? |
|
| |
3814
| + $.datepicker[ "_" + options + "Datepicker" ]. |
|
| |
3815
| + apply( $.datepicker, [ this ].concat( otherArgs ) ) : |
|
| |
3816
| + $.datepicker._attachDatepicker( this, options ); |
|
| |
3817
| + } ); |
|
| |
3818
| +}; |
|
| |
3819
| + |
|
| |
3820
| +$.datepicker = new Datepicker(); // singleton instance |
|
| |
3821
| +$.datepicker.initialized = false; |
|
| |
3822
| +$.datepicker.uuid = new Date().getTime(); |
|
| |
3823
| +$.datepicker.version = "1.12.1"; |
|
| |
3824
| + |
|
| |
3825
| +var widgetsDatepicker = $.datepicker; |
|
| |
3826
| + |
|
| |
3827
| + |
|
| |
3828
| + |
|
| |
3829
| + |
|
| |
3830
| +})); |
|
0
| \ No newline at end of file |
3831
| \ No newline at end of file |
