|
5
|
1 /*! jQuery UI - v1.10.4 - 2014-01-17
|
|
|
2 * http://jqueryui.com
|
|
|
3 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.effect.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.progressbar.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.slider.js, jquery.ui.sortable.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
|
|
|
4 * Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */
|
|
|
5
|
|
|
6 (function( $, undefined ) {
|
|
|
7
|
|
|
8 var uuid = 0,
|
|
|
9 runiqueId = /^ui-id-\d+$/;
|
|
|
10
|
|
|
11 // $.ui might exist from components with no dependencies, e.g., $.ui.position
|
|
|
12 $.ui = $.ui || {};
|
|
|
13
|
|
|
14 $.extend( $.ui, {
|
|
|
15 version: "1.10.4",
|
|
|
16
|
|
|
17 keyCode: {
|
|
|
18 BACKSPACE: 8,
|
|
|
19 COMMA: 188,
|
|
|
20 DELETE: 46,
|
|
|
21 DOWN: 40,
|
|
|
22 END: 35,
|
|
|
23 ENTER: 13,
|
|
|
24 ESCAPE: 27,
|
|
|
25 HOME: 36,
|
|
|
26 LEFT: 37,
|
|
|
27 NUMPAD_ADD: 107,
|
|
|
28 NUMPAD_DECIMAL: 110,
|
|
|
29 NUMPAD_DIVIDE: 111,
|
|
|
30 NUMPAD_ENTER: 108,
|
|
|
31 NUMPAD_MULTIPLY: 106,
|
|
|
32 NUMPAD_SUBTRACT: 109,
|
|
|
33 PAGE_DOWN: 34,
|
|
|
34 PAGE_UP: 33,
|
|
|
35 PERIOD: 190,
|
|
|
36 RIGHT: 39,
|
|
|
37 SPACE: 32,
|
|
|
38 TAB: 9,
|
|
|
39 UP: 38
|
|
|
40 }
|
|
|
41 });
|
|
|
42
|
|
|
43 // plugins
|
|
|
44 $.fn.extend({
|
|
|
45 focus: (function( orig ) {
|
|
|
46 return function( delay, fn ) {
|
|
|
47 return typeof delay === "number" ?
|
|
|
48 this.each(function() {
|
|
|
49 var elem = this;
|
|
|
50 setTimeout(function() {
|
|
|
51 $( elem ).focus();
|
|
|
52 if ( fn ) {
|
|
|
53 fn.call( elem );
|
|
|
54 }
|
|
|
55 }, delay );
|
|
|
56 }) :
|
|
|
57 orig.apply( this, arguments );
|
|
|
58 };
|
|
|
59 })( $.fn.focus ),
|
|
|
60
|
|
|
61 scrollParent: function() {
|
|
|
62 var scrollParent;
|
|
|
63 if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
|
|
|
64 scrollParent = this.parents().filter(function() {
|
|
|
65 return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
|
|
|
66 }).eq(0);
|
|
|
67 } else {
|
|
|
68 scrollParent = this.parents().filter(function() {
|
|
|
69 return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
|
|
|
70 }).eq(0);
|
|
|
71 }
|
|
|
72
|
|
|
73 return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
|
|
|
74 },
|
|
|
75
|
|
|
76 zIndex: function( zIndex ) {
|
|
|
77 if ( zIndex !== undefined ) {
|
|
|
78 return this.css( "zIndex", zIndex );
|
|
|
79 }
|
|
|
80
|
|
|
81 if ( this.length ) {
|
|
|
82 var elem = $( this[ 0 ] ), position, value;
|
|
|
83 while ( elem.length && elem[ 0 ] !== document ) {
|
|
|
84 // Ignore z-index if position is set to a value where z-index is ignored by the browser
|
|
|
85 // This makes behavior of this function consistent across browsers
|
|
|
86 // WebKit always returns auto if the element is positioned
|
|
|
87 position = elem.css( "position" );
|
|
|
88 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
|
|
|
89 // IE returns 0 when zIndex is not specified
|
|
|
90 // other browsers return a string
|
|
|
91 // we ignore the case of nested elements with an explicit value of 0
|
|
|
92 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
|
|
|
93 value = parseInt( elem.css( "zIndex" ), 10 );
|
|
|
94 if ( !isNaN( value ) && value !== 0 ) {
|
|
|
95 return value;
|
|
|
96 }
|
|
|
97 }
|
|
|
98 elem = elem.parent();
|
|
|
99 }
|
|
|
100 }
|
|
|
101
|
|
|
102 return 0;
|
|
|
103 },
|
|
|
104
|
|
|
105 uniqueId: function() {
|
|
|
106 return this.each(function() {
|
|
|
107 if ( !this.id ) {
|
|
|
108 this.id = "ui-id-" + (++uuid);
|
|
|
109 }
|
|
|
110 });
|
|
|
111 },
|
|
|
112
|
|
|
113 removeUniqueId: function() {
|
|
|
114 return this.each(function() {
|
|
|
115 if ( runiqueId.test( this.id ) ) {
|
|
|
116 $( this ).removeAttr( "id" );
|
|
|
117 }
|
|
|
118 });
|
|
|
119 }
|
|
|
120 });
|
|
|
121
|
|
|
122 // selectors
|
|
|
123 function focusable( element, isTabIndexNotNaN ) {
|
|
|
124 var map, mapName, img,
|
|
|
125 nodeName = element.nodeName.toLowerCase();
|
|
|
126 if ( "area" === nodeName ) {
|
|
|
127 map = element.parentNode;
|
|
|
128 mapName = map.name;
|
|
|
129 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
|
|
|
130 return false;
|
|
|
131 }
|
|
|
132 img = $( "img[usemap=#" + mapName + "]" )[0];
|
|
|
133 return !!img && visible( img );
|
|
|
134 }
|
|
|
135 return ( /input|select|textarea|button|object/.test( nodeName ) ?
|
|
|
136 !element.disabled :
|
|
|
137 "a" === nodeName ?
|
|
|
138 element.href || isTabIndexNotNaN :
|
|
|
139 isTabIndexNotNaN) &&
|
|
|
140 // the element and all of its ancestors must be visible
|
|
|
141 visible( element );
|
|
|
142 }
|
|
|
143
|
|
|
144 function visible( element ) {
|
|
|
145 return $.expr.filters.visible( element ) &&
|
|
|
146 !$( element ).parents().addBack().filter(function() {
|
|
|
147 return $.css( this, "visibility" ) === "hidden";
|
|
|
148 }).length;
|
|
|
149 }
|
|
|
150
|
|
|
151 $.extend( $.expr[ ":" ], {
|
|
|
152 data: $.expr.createPseudo ?
|
|
|
153 $.expr.createPseudo(function( dataName ) {
|
|
|
154 return function( elem ) {
|
|
|
155 return !!$.data( elem, dataName );
|
|
|
156 };
|
|
|
157 }) :
|
|
|
158 // support: jQuery <1.8
|
|
|
159 function( elem, i, match ) {
|
|
|
160 return !!$.data( elem, match[ 3 ] );
|
|
|
161 },
|
|
|
162
|
|
|
163 focusable: function( element ) {
|
|
|
164 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
|
|
|
165 },
|
|
|
166
|
|
|
167 tabbable: function( element ) {
|
|
|
168 var tabIndex = $.attr( element, "tabindex" ),
|
|
|
169 isTabIndexNaN = isNaN( tabIndex );
|
|
|
170 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
|
|
|
171 }
|
|
|
172 });
|
|
|
173
|
|
|
174 // support: jQuery <1.8
|
|
|
175 if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
|
|
|
176 $.each( [ "Width", "Height" ], function( i, name ) {
|
|
|
177 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
|
|
|
178 type = name.toLowerCase(),
|
|
|
179 orig = {
|
|
|
180 innerWidth: $.fn.innerWidth,
|
|
|
181 innerHeight: $.fn.innerHeight,
|
|
|
182 outerWidth: $.fn.outerWidth,
|
|
|
183 outerHeight: $.fn.outerHeight
|
|
|
184 };
|
|
|
185
|
|
|
186 function reduce( elem, size, border, margin ) {
|
|
|
187 $.each( side, function() {
|
|
|
188 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
|
|
|
189 if ( border ) {
|
|
|
190 size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
|
|
|
191 }
|
|
|
192 if ( margin ) {
|
|
|
193 size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
|
|
|
194 }
|
|
|
195 });
|
|
|
196 return size;
|
|
|
197 }
|
|
|
198
|
|
|
199 $.fn[ "inner" + name ] = function( size ) {
|
|
|
200 if ( size === undefined ) {
|
|
|
201 return orig[ "inner" + name ].call( this );
|
|
|
202 }
|
|
|
203
|
|
|
204 return this.each(function() {
|
|
|
205 $( this ).css( type, reduce( this, size ) + "px" );
|
|
|
206 });
|
|
|
207 };
|
|
|
208
|
|
|
209 $.fn[ "outer" + name] = function( size, margin ) {
|
|
|
210 if ( typeof size !== "number" ) {
|
|
|
211 return orig[ "outer" + name ].call( this, size );
|
|
|
212 }
|
|
|
213
|
|
|
214 return this.each(function() {
|
|
|
215 $( this).css( type, reduce( this, size, true, margin ) + "px" );
|
|
|
216 });
|
|
|
217 };
|
|
|
218 });
|
|
|
219 }
|
|
|
220
|
|
|
221 // support: jQuery <1.8
|
|
|
222 if ( !$.fn.addBack ) {
|
|
|
223 $.fn.addBack = function( selector ) {
|
|
|
224 return this.add( selector == null ?
|
|
|
225 this.prevObject : this.prevObject.filter( selector )
|
|
|
226 );
|
|
|
227 };
|
|
|
228 }
|
|
|
229
|
|
|
230 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
|
|
|
231 if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
|
|
|
232 $.fn.removeData = (function( removeData ) {
|
|
|
233 return function( key ) {
|
|
|
234 if ( arguments.length ) {
|
|
|
235 return removeData.call( this, $.camelCase( key ) );
|
|
|
236 } else {
|
|
|
237 return removeData.call( this );
|
|
|
238 }
|
|
|
239 };
|
|
|
240 })( $.fn.removeData );
|
|
|
241 }
|
|
|
242
|
|
|
243
|
|
|
244
|
|
|
245
|
|
|
246
|
|
|
247 // deprecated
|
|
|
248 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
|
|
|
249
|
|
|
250 $.support.selectstart = "onselectstart" in document.createElement( "div" );
|
|
|
251 $.fn.extend({
|
|
|
252 disableSelection: function() {
|
|
|
253 return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
|
|
|
254 ".ui-disableSelection", function( event ) {
|
|
|
255 event.preventDefault();
|
|
|
256 });
|
|
|
257 },
|
|
|
258
|
|
|
259 enableSelection: function() {
|
|
|
260 return this.unbind( ".ui-disableSelection" );
|
|
|
261 }
|
|
|
262 });
|
|
|
263
|
|
|
264 $.extend( $.ui, {
|
|
|
265 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
|
|
|
266 plugin: {
|
|
|
267 add: function( module, option, set ) {
|
|
|
268 var i,
|
|
|
269 proto = $.ui[ module ].prototype;
|
|
|
270 for ( i in set ) {
|
|
|
271 proto.plugins[ i ] = proto.plugins[ i ] || [];
|
|
|
272 proto.plugins[ i ].push( [ option, set[ i ] ] );
|
|
|
273 }
|
|
|
274 },
|
|
|
275 call: function( instance, name, args ) {
|
|
|
276 var i,
|
|
|
277 set = instance.plugins[ name ];
|
|
|
278 if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
|
|
|
279 return;
|
|
|
280 }
|
|
|
281
|
|
|
282 for ( i = 0; i < set.length; i++ ) {
|
|
|
283 if ( instance.options[ set[ i ][ 0 ] ] ) {
|
|
|
284 set[ i ][ 1 ].apply( instance.element, args );
|
|
|
285 }
|
|
|
286 }
|
|
|
287 }
|
|
|
288 },
|
|
|
289
|
|
|
290 // only used by resizable
|
|
|
291 hasScroll: function( el, a ) {
|
|
|
292
|
|
|
293 //If overflow is hidden, the element might have extra content, but the user wants to hide it
|
|
|
294 if ( $( el ).css( "overflow" ) === "hidden") {
|
|
|
295 return false;
|
|
|
296 }
|
|
|
297
|
|
|
298 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
|
|
|
299 has = false;
|
|
|
300
|
|
|
301 if ( el[ scroll ] > 0 ) {
|
|
|
302 return true;
|
|
|
303 }
|
|
|
304
|
|
|
305 // TODO: determine which cases actually cause this to happen
|
|
|
306 // if the element doesn't have the scroll set, see if it's possible to
|
|
|
307 // set the scroll
|
|
|
308 el[ scroll ] = 1;
|
|
|
309 has = ( el[ scroll ] > 0 );
|
|
|
310 el[ scroll ] = 0;
|
|
|
311 return has;
|
|
|
312 }
|
|
|
313 });
|
|
|
314
|
|
|
315 })( jQuery );
|
|
|
316 (function( $, undefined ) {
|
|
|
317
|
|
|
318 var uuid = 0,
|
|
|
319 slice = Array.prototype.slice,
|
|
|
320 _cleanData = $.cleanData;
|
|
|
321 $.cleanData = function( elems ) {
|
|
|
322 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
|
323 try {
|
|
|
324 $( elem ).triggerHandler( "remove" );
|
|
|
325 // http://bugs.jquery.com/ticket/8235
|
|
|
326 } catch( e ) {}
|
|
|
327 }
|
|
|
328 _cleanData( elems );
|
|
|
329 };
|
|
|
330
|
|
|
331 $.widget = function( name, base, prototype ) {
|
|
|
332 var fullName, existingConstructor, constructor, basePrototype,
|
|
|
333 // proxiedPrototype allows the provided prototype to remain unmodified
|
|
|
334 // so that it can be used as a mixin for multiple widgets (#8876)
|
|
|
335 proxiedPrototype = {},
|
|
|
336 namespace = name.split( "." )[ 0 ];
|
|
|
337
|
|
|
338 name = name.split( "." )[ 1 ];
|
|
|
339 fullName = namespace + "-" + name;
|
|
|
340
|
|
|
341 if ( !prototype ) {
|
|
|
342 prototype = base;
|
|
|
343 base = $.Widget;
|
|
|
344 }
|
|
|
345
|
|
|
346 // create selector for plugin
|
|
|
347 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
|
|
|
348 return !!$.data( elem, fullName );
|
|
|
349 };
|
|
|
350
|
|
|
351 $[ namespace ] = $[ namespace ] || {};
|
|
|
352 existingConstructor = $[ namespace ][ name ];
|
|
|
353 constructor = $[ namespace ][ name ] = function( options, element ) {
|
|
|
354 // allow instantiation without "new" keyword
|
|
|
355 if ( !this._createWidget ) {
|
|
|
356 return new constructor( options, element );
|
|
|
357 }
|
|
|
358
|
|
|
359 // allow instantiation without initializing for simple inheritance
|
|
|
360 // must use "new" keyword (the code above always passes args)
|
|
|
361 if ( arguments.length ) {
|
|
|
362 this._createWidget( options, element );
|
|
|
363 }
|
|
|
364 };
|
|
|
365 // extend with the existing constructor to carry over any static properties
|
|
|
366 $.extend( constructor, existingConstructor, {
|
|
|
367 version: prototype.version,
|
|
|
368 // copy the object used to create the prototype in case we need to
|
|
|
369 // redefine the widget later
|
|
|
370 _proto: $.extend( {}, prototype ),
|
|
|
371 // track widgets that inherit from this widget in case this widget is
|
|
|
372 // redefined after a widget inherits from it
|
|
|
373 _childConstructors: []
|
|
|
374 });
|
|
|
375
|
|
|
376 basePrototype = new base();
|
|
|
377 // we need to make the options hash a property directly on the new instance
|
|
|
378 // otherwise we'll modify the options hash on the prototype that we're
|
|
|
379 // inheriting from
|
|
|
380 basePrototype.options = $.widget.extend( {}, basePrototype.options );
|
|
|
381 $.each( prototype, function( prop, value ) {
|
|
|
382 if ( !$.isFunction( value ) ) {
|
|
|
383 proxiedPrototype[ prop ] = value;
|
|
|
384 return;
|
|
|
385 }
|
|
|
386 proxiedPrototype[ prop ] = (function() {
|
|
|
387 var _super = function() {
|
|
|
388 return base.prototype[ prop ].apply( this, arguments );
|
|
|
389 },
|
|
|
390 _superApply = function( args ) {
|
|
|
391 return base.prototype[ prop ].apply( this, args );
|
|
|
392 };
|
|
|
393 return function() {
|
|
|
394 var __super = this._super,
|
|
|
395 __superApply = this._superApply,
|
|
|
396 returnValue;
|
|
|
397
|
|
|
398 this._super = _super;
|
|
|
399 this._superApply = _superApply;
|
|
|
400
|
|
|
401 returnValue = value.apply( this, arguments );
|
|
|
402
|
|
|
403 this._super = __super;
|
|
|
404 this._superApply = __superApply;
|
|
|
405
|
|
|
406 return returnValue;
|
|
|
407 };
|
|
|
408 })();
|
|
|
409 });
|
|
|
410 constructor.prototype = $.widget.extend( basePrototype, {
|
|
|
411 // TODO: remove support for widgetEventPrefix
|
|
|
412 // always use the name + a colon as the prefix, e.g., draggable:start
|
|
|
413 // don't prefix for widgets that aren't DOM-based
|
|
|
414 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
|
|
|
415 }, proxiedPrototype, {
|
|
|
416 constructor: constructor,
|
|
|
417 namespace: namespace,
|
|
|
418 widgetName: name,
|
|
|
419 widgetFullName: fullName
|
|
|
420 });
|
|
|
421
|
|
|
422 // If this widget is being redefined then we need to find all widgets that
|
|
|
423 // are inheriting from it and redefine all of them so that they inherit from
|
|
|
424 // the new version of this widget. We're essentially trying to replace one
|
|
|
425 // level in the prototype chain.
|
|
|
426 if ( existingConstructor ) {
|
|
|
427 $.each( existingConstructor._childConstructors, function( i, child ) {
|
|
|
428 var childPrototype = child.prototype;
|
|
|
429
|
|
|
430 // redefine the child widget using the same prototype that was
|
|
|
431 // originally used, but inherit from the new version of the base
|
|
|
432 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
|
|
|
433 });
|
|
|
434 // remove the list of existing child constructors from the old constructor
|
|
|
435 // so the old child constructors can be garbage collected
|
|
|
436 delete existingConstructor._childConstructors;
|
|
|
437 } else {
|
|
|
438 base._childConstructors.push( constructor );
|
|
|
439 }
|
|
|
440
|
|
|
441 $.widget.bridge( name, constructor );
|
|
|
442 };
|
|
|
443
|
|
|
444 $.widget.extend = function( target ) {
|
|
|
445 var input = slice.call( arguments, 1 ),
|
|
|
446 inputIndex = 0,
|
|
|
447 inputLength = input.length,
|
|
|
448 key,
|
|
|
449 value;
|
|
|
450 for ( ; inputIndex < inputLength; inputIndex++ ) {
|
|
|
451 for ( key in input[ inputIndex ] ) {
|
|
|
452 value = input[ inputIndex ][ key ];
|
|
|
453 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
|
|
|
454 // Clone objects
|
|
|
455 if ( $.isPlainObject( value ) ) {
|
|
|
456 target[ key ] = $.isPlainObject( target[ key ] ) ?
|
|
|
457 $.widget.extend( {}, target[ key ], value ) :
|
|
|
458 // Don't extend strings, arrays, etc. with objects
|
|
|
459 $.widget.extend( {}, value );
|
|
|
460 // Copy everything else by reference
|
|
|
461 } else {
|
|
|
462 target[ key ] = value;
|
|
|
463 }
|
|
|
464 }
|
|
|
465 }
|
|
|
466 }
|
|
|
467 return target;
|
|
|
468 };
|
|
|
469
|
|
|
470 $.widget.bridge = function( name, object ) {
|
|
|
471 var fullName = object.prototype.widgetFullName || name;
|
|
|
472 $.fn[ name ] = function( options ) {
|
|
|
473 var isMethodCall = typeof options === "string",
|
|
|
474 args = slice.call( arguments, 1 ),
|
|
|
475 returnValue = this;
|
|
|
476
|
|
|
477 // allow multiple hashes to be passed on init
|
|
|
478 options = !isMethodCall && args.length ?
|
|
|
479 $.widget.extend.apply( null, [ options ].concat(args) ) :
|
|
|
480 options;
|
|
|
481
|
|
|
482 if ( isMethodCall ) {
|
|
|
483 this.each(function() {
|
|
|
484 var methodValue,
|
|
|
485 instance = $.data( this, fullName );
|
|
|
486 if ( !instance ) {
|
|
|
487 return $.error( "cannot call methods on " + name + " prior to initialization; " +
|
|
|
488 "attempted to call method '" + options + "'" );
|
|
|
489 }
|
|
|
490 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
|
|
|
491 return $.error( "no such method '" + options + "' for " + name + " widget instance" );
|
|
|
492 }
|
|
|
493 methodValue = instance[ options ].apply( instance, args );
|
|
|
494 if ( methodValue !== instance && methodValue !== undefined ) {
|
|
|
495 returnValue = methodValue && methodValue.jquery ?
|
|
|
496 returnValue.pushStack( methodValue.get() ) :
|
|
|
497 methodValue;
|
|
|
498 return false;
|
|
|
499 }
|
|
|
500 });
|
|
|
501 } else {
|
|
|
502 this.each(function() {
|
|
|
503 var instance = $.data( this, fullName );
|
|
|
504 if ( instance ) {
|
|
|
505 instance.option( options || {} )._init();
|
|
|
506 } else {
|
|
|
507 $.data( this, fullName, new object( options, this ) );
|
|
|
508 }
|
|
|
509 });
|
|
|
510 }
|
|
|
511
|
|
|
512 return returnValue;
|
|
|
513 };
|
|
|
514 };
|
|
|
515
|
|
|
516 $.Widget = function( /* options, element */ ) {};
|
|
|
517 $.Widget._childConstructors = [];
|
|
|
518
|
|
|
519 $.Widget.prototype = {
|
|
|
520 widgetName: "widget",
|
|
|
521 widgetEventPrefix: "",
|
|
|
522 defaultElement: "<div>",
|
|
|
523 options: {
|
|
|
524 disabled: false,
|
|
|
525
|
|
|
526 // callbacks
|
|
|
527 create: null
|
|
|
528 },
|
|
|
529 _createWidget: function( options, element ) {
|
|
|
530 element = $( element || this.defaultElement || this )[ 0 ];
|
|
|
531 this.element = $( element );
|
|
|
532 this.uuid = uuid++;
|
|
|
533 this.eventNamespace = "." + this.widgetName + this.uuid;
|
|
|
534 this.options = $.widget.extend( {},
|
|
|
535 this.options,
|
|
|
536 this._getCreateOptions(),
|
|
|
537 options );
|
|
|
538
|
|
|
539 this.bindings = $();
|
|
|
540 this.hoverable = $();
|
|
|
541 this.focusable = $();
|
|
|
542
|
|
|
543 if ( element !== this ) {
|
|
|
544 $.data( element, this.widgetFullName, this );
|
|
|
545 this._on( true, this.element, {
|
|
|
546 remove: function( event ) {
|
|
|
547 if ( event.target === element ) {
|
|
|
548 this.destroy();
|
|
|
549 }
|
|
|
550 }
|
|
|
551 });
|
|
|
552 this.document = $( element.style ?
|
|
|
553 // element within the document
|
|
|
554 element.ownerDocument :
|
|
|
555 // element is window or document
|
|
|
556 element.document || element );
|
|
|
557 this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
|
|
|
558 }
|
|
|
559
|
|
|
560 this._create();
|
|
|
561 this._trigger( "create", null, this._getCreateEventData() );
|
|
|
562 this._init();
|
|
|
563 },
|
|
|
564 _getCreateOptions: $.noop,
|
|
|
565 _getCreateEventData: $.noop,
|
|
|
566 _create: $.noop,
|
|
|
567 _init: $.noop,
|
|
|
568
|
|
|
569 destroy: function() {
|
|
|
570 this._destroy();
|
|
|
571 // we can probably remove the unbind calls in 2.0
|
|
|
572 // all event bindings should go through this._on()
|
|
|
573 this.element
|
|
|
574 .unbind( this.eventNamespace )
|
|
|
575 // 1.9 BC for #7810
|
|
|
576 // TODO remove dual storage
|
|
|
577 .removeData( this.widgetName )
|
|
|
578 .removeData( this.widgetFullName )
|
|
|
579 // support: jquery <1.6.3
|
|
|
580 // http://bugs.jquery.com/ticket/9413
|
|
|
581 .removeData( $.camelCase( this.widgetFullName ) );
|
|
|
582 this.widget()
|
|
|
583 .unbind( this.eventNamespace )
|
|
|
584 .removeAttr( "aria-disabled" )
|
|
|
585 .removeClass(
|
|
|
586 this.widgetFullName + "-disabled " +
|
|
|
587 "ui-state-disabled" );
|
|
|
588
|
|
|
589 // clean up events and states
|
|
|
590 this.bindings.unbind( this.eventNamespace );
|
|
|
591 this.hoverable.removeClass( "ui-state-hover" );
|
|
|
592 this.focusable.removeClass( "ui-state-focus" );
|
|
|
593 },
|
|
|
594 _destroy: $.noop,
|
|
|
595
|
|
|
596 widget: function() {
|
|
|
597 return this.element;
|
|
|
598 },
|
|
|
599
|
|
|
600 option: function( key, value ) {
|
|
|
601 var options = key,
|
|
|
602 parts,
|
|
|
603 curOption,
|
|
|
604 i;
|
|
|
605
|
|
|
606 if ( arguments.length === 0 ) {
|
|
|
607 // don't return a reference to the internal hash
|
|
|
608 return $.widget.extend( {}, this.options );
|
|
|
609 }
|
|
|
610
|
|
|
611 if ( typeof key === "string" ) {
|
|
|
612 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
|
|
|
613 options = {};
|
|
|
614 parts = key.split( "." );
|
|
|
615 key = parts.shift();
|
|
|
616 if ( parts.length ) {
|
|
|
617 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
|
|
|
618 for ( i = 0; i < parts.length - 1; i++ ) {
|
|
|
619 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
|
|
|
620 curOption = curOption[ parts[ i ] ];
|
|
|
621 }
|
|
|
622 key = parts.pop();
|
|
|
623 if ( arguments.length === 1 ) {
|
|
|
624 return curOption[ key ] === undefined ? null : curOption[ key ];
|
|
|
625 }
|
|
|
626 curOption[ key ] = value;
|
|
|
627 } else {
|
|
|
628 if ( arguments.length === 1 ) {
|
|
|
629 return this.options[ key ] === undefined ? null : this.options[ key ];
|
|
|
630 }
|
|
|
631 options[ key ] = value;
|
|
|
632 }
|
|
|
633 }
|
|
|
634
|
|
|
635 this._setOptions( options );
|
|
|
636
|
|
|
637 return this;
|
|
|
638 },
|
|
|
639 _setOptions: function( options ) {
|
|
|
640 var key;
|
|
|
641
|
|
|
642 for ( key in options ) {
|
|
|
643 this._setOption( key, options[ key ] );
|
|
|
644 }
|
|
|
645
|
|
|
646 return this;
|
|
|
647 },
|
|
|
648 _setOption: function( key, value ) {
|
|
|
649 this.options[ key ] = value;
|
|
|
650
|
|
|
651 if ( key === "disabled" ) {
|
|
|
652 this.widget()
|
|
|
653 .toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
|
|
|
654 .attr( "aria-disabled", value );
|
|
|
655 this.hoverable.removeClass( "ui-state-hover" );
|
|
|
656 this.focusable.removeClass( "ui-state-focus" );
|
|
|
657 }
|
|
|
658
|
|
|
659 return this;
|
|
|
660 },
|
|
|
661
|
|
|
662 enable: function() {
|
|
|
663 return this._setOption( "disabled", false );
|
|
|
664 },
|
|
|
665 disable: function() {
|
|
|
666 return this._setOption( "disabled", true );
|
|
|
667 },
|
|
|
668
|
|
|
669 _on: function( suppressDisabledCheck, element, handlers ) {
|
|
|
670 var delegateElement,
|
|
|
671 instance = this;
|
|
|
672
|
|
|
673 // no suppressDisabledCheck flag, shuffle arguments
|
|
|
674 if ( typeof suppressDisabledCheck !== "boolean" ) {
|
|
|
675 handlers = element;
|
|
|
676 element = suppressDisabledCheck;
|
|
|
677 suppressDisabledCheck = false;
|
|
|
678 }
|
|
|
679
|
|
|
680 // no element argument, shuffle and use this.element
|
|
|
681 if ( !handlers ) {
|
|
|
682 handlers = element;
|
|
|
683 element = this.element;
|
|
|
684 delegateElement = this.widget();
|
|
|
685 } else {
|
|
|
686 // accept selectors, DOM elements
|
|
|
687 element = delegateElement = $( element );
|
|
|
688 this.bindings = this.bindings.add( element );
|
|
|
689 }
|
|
|
690
|
|
|
691 $.each( handlers, function( event, handler ) {
|
|
|
692 function handlerProxy() {
|
|
|
693 // allow widgets to customize the disabled handling
|
|
|
694 // - disabled as an array instead of boolean
|
|
|
695 // - disabled class as method for disabling individual parts
|
|
|
696 if ( !suppressDisabledCheck &&
|
|
|
697 ( instance.options.disabled === true ||
|
|
|
698 $( this ).hasClass( "ui-state-disabled" ) ) ) {
|
|
|
699 return;
|
|
|
700 }
|
|
|
701 return ( typeof handler === "string" ? instance[ handler ] : handler )
|
|
|
702 .apply( instance, arguments );
|
|
|
703 }
|
|
|
704
|
|
|
705 // copy the guid so direct unbinding works
|
|
|
706 if ( typeof handler !== "string" ) {
|
|
|
707 handlerProxy.guid = handler.guid =
|
|
|
708 handler.guid || handlerProxy.guid || $.guid++;
|
|
|
709 }
|
|
|
710
|
|
|
711 var match = event.match( /^(\w+)\s*(.*)$/ ),
|
|
|
712 eventName = match[1] + instance.eventNamespace,
|
|
|
713 selector = match[2];
|
|
|
714 if ( selector ) {
|
|
|
715 delegateElement.delegate( selector, eventName, handlerProxy );
|
|
|
716 } else {
|
|
|
717 element.bind( eventName, handlerProxy );
|
|
|
718 }
|
|
|
719 });
|
|
|
720 },
|
|
|
721
|
|
|
722 _off: function( element, eventName ) {
|
|
|
723 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
|
|
|
724 element.unbind( eventName ).undelegate( eventName );
|
|
|
725 },
|
|
|
726
|
|
|
727 _delay: function( handler, delay ) {
|
|
|
728 function handlerProxy() {
|
|
|
729 return ( typeof handler === "string" ? instance[ handler ] : handler )
|
|
|
730 .apply( instance, arguments );
|
|
|
731 }
|
|
|
732 var instance = this;
|
|
|
733 return setTimeout( handlerProxy, delay || 0 );
|
|
|
734 },
|
|
|
735
|
|
|
736 _hoverable: function( element ) {
|
|
|
737 this.hoverable = this.hoverable.add( element );
|
|
|
738 this._on( element, {
|
|
|
739 mouseenter: function( event ) {
|
|
|
740 $( event.currentTarget ).addClass( "ui-state-hover" );
|
|
|
741 },
|
|
|
742 mouseleave: function( event ) {
|
|
|
743 $( event.currentTarget ).removeClass( "ui-state-hover" );
|
|
|
744 }
|
|
|
745 });
|
|
|
746 },
|
|
|
747
|
|
|
748 _focusable: function( element ) {
|
|
|
749 this.focusable = this.focusable.add( element );
|
|
|
750 this._on( element, {
|
|
|
751 focusin: function( event ) {
|
|
|
752 $( event.currentTarget ).addClass( "ui-state-focus" );
|
|
|
753 },
|
|
|
754 focusout: function( event ) {
|
|
|
755 $( event.currentTarget ).removeClass( "ui-state-focus" );
|
|
|
756 }
|
|
|
757 });
|
|
|
758 },
|
|
|
759
|
|
|
760 _trigger: function( type, event, data ) {
|
|
|
761 var prop, orig,
|
|
|
762 callback = this.options[ type ];
|
|
|
763
|
|
|
764 data = data || {};
|
|
|
765 event = $.Event( event );
|
|
|
766 event.type = ( type === this.widgetEventPrefix ?
|
|
|
767 type :
|
|
|
768 this.widgetEventPrefix + type ).toLowerCase();
|
|
|
769 // the original event may come from any element
|
|
|
770 // so we need to reset the target on the new event
|
|
|
771 event.target = this.element[ 0 ];
|
|
|
772
|
|
|
773 // copy original event properties over to the new event
|
|
|
774 orig = event.originalEvent;
|
|
|
775 if ( orig ) {
|
|
|
776 for ( prop in orig ) {
|
|
|
777 if ( !( prop in event ) ) {
|
|
|
778 event[ prop ] = orig[ prop ];
|
|
|
779 }
|
|
|
780 }
|
|
|
781 }
|
|
|
782
|
|
|
783 this.element.trigger( event, data );
|
|
|
784 return !( $.isFunction( callback ) &&
|
|
|
785 callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
|
|
|
786 event.isDefaultPrevented() );
|
|
|
787 }
|
|
|
788 };
|
|
|
789
|
|
|
790 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
|
|
|
791 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
|
|
|
792 if ( typeof options === "string" ) {
|
|
|
793 options = { effect: options };
|
|
|
794 }
|
|
|
795 var hasOptions,
|
|
|
796 effectName = !options ?
|
|
|
797 method :
|
|
|
798 options === true || typeof options === "number" ?
|
|
|
799 defaultEffect :
|
|
|
800 options.effect || defaultEffect;
|
|
|
801 options = options || {};
|
|
|
802 if ( typeof options === "number" ) {
|
|
|
803 options = { duration: options };
|
|
|
804 }
|
|
|
805 hasOptions = !$.isEmptyObject( options );
|
|
|
806 options.complete = callback;
|
|
|
807 if ( options.delay ) {
|
|
|
808 element.delay( options.delay );
|
|
|
809 }
|
|
|
810 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
|
|
|
811 element[ method ]( options );
|
|
|
812 } else if ( effectName !== method && element[ effectName ] ) {
|
|
|
813 element[ effectName ]( options.duration, options.easing, callback );
|
|
|
814 } else {
|
|
|
815 element.queue(function( next ) {
|
|
|
816 $( this )[ method ]();
|
|
|
817 if ( callback ) {
|
|
|
818 callback.call( element[ 0 ] );
|
|
|
819 }
|
|
|
820 next();
|
|
|
821 });
|
|
|
822 }
|
|
|
823 };
|
|
|
824 });
|
|
|
825
|
|
|
826 })( jQuery );
|
|
|
827 (function( $, undefined ) {
|
|
|
828
|
|
|
829 var mouseHandled = false;
|
|
|
830 $( document ).mouseup( function() {
|
|
|
831 mouseHandled = false;
|
|
|
832 });
|
|
|
833
|
|
|
834 $.widget("ui.mouse", {
|
|
|
835 version: "1.10.4",
|
|
|
836 options: {
|
|
|
837 cancel: "input,textarea,button,select,option",
|
|
|
838 distance: 1,
|
|
|
839 delay: 0
|
|
|
840 },
|
|
|
841 _mouseInit: function() {
|
|
|
842 var that = this;
|
|
|
843
|
|
|
844 this.element
|
|
|
845 .bind("mousedown."+this.widgetName, function(event) {
|
|
|
846 return that._mouseDown(event);
|
|
|
847 })
|
|
|
848 .bind("click."+this.widgetName, function(event) {
|
|
|
849 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
|
|
|
850 $.removeData(event.target, that.widgetName + ".preventClickEvent");
|
|
|
851 event.stopImmediatePropagation();
|
|
|
852 return false;
|
|
|
853 }
|
|
|
854 });
|
|
|
855
|
|
|
856 this.started = false;
|
|
|
857 },
|
|
|
858
|
|
|
859 // TODO: make sure destroying one instance of mouse doesn't mess with
|
|
|
860 // other instances of mouse
|
|
|
861 _mouseDestroy: function() {
|
|
|
862 this.element.unbind("."+this.widgetName);
|
|
|
863 if ( this._mouseMoveDelegate ) {
|
|
|
864 $(document)
|
|
|
865 .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
|
|
|
866 .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
|
|
|
867 }
|
|
|
868 },
|
|
|
869
|
|
|
870 _mouseDown: function(event) {
|
|
|
871 // don't let more than one widget handle mouseStart
|
|
|
872 if( mouseHandled ) { return; }
|
|
|
873
|
|
|
874 // we may have missed mouseup (out of window)
|
|
|
875 (this._mouseStarted && this._mouseUp(event));
|
|
|
876
|
|
|
877 this._mouseDownEvent = event;
|
|
|
878
|
|
|
879 var that = this,
|
|
|
880 btnIsLeft = (event.which === 1),
|
|
|
881 // event.target.nodeName works around a bug in IE 8 with
|
|
|
882 // disabled inputs (#7620)
|
|
|
883 elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
|
|
|
884 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
|
|
|
885 return true;
|
|
|
886 }
|
|
|
887
|
|
|
888 this.mouseDelayMet = !this.options.delay;
|
|
|
889 if (!this.mouseDelayMet) {
|
|
|
890 this._mouseDelayTimer = setTimeout(function() {
|
|
|
891 that.mouseDelayMet = true;
|
|
|
892 }, this.options.delay);
|
|
|
893 }
|
|
|
894
|
|
|
895 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
|
|
|
896 this._mouseStarted = (this._mouseStart(event) !== false);
|
|
|
897 if (!this._mouseStarted) {
|
|
|
898 event.preventDefault();
|
|
|
899 return true;
|
|
|
900 }
|
|
|
901 }
|
|
|
902
|
|
|
903 // Click event may never have fired (Gecko & Opera)
|
|
|
904 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
|
|
|
905 $.removeData(event.target, this.widgetName + ".preventClickEvent");
|
|
|
906 }
|
|
|
907
|
|
|
908 // these delegates are required to keep context
|
|
|
909 this._mouseMoveDelegate = function(event) {
|
|
|
910 return that._mouseMove(event);
|
|
|
911 };
|
|
|
912 this._mouseUpDelegate = function(event) {
|
|
|
913 return that._mouseUp(event);
|
|
|
914 };
|
|
|
915 $(document)
|
|
|
916 .bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
|
|
|
917 .bind("mouseup."+this.widgetName, this._mouseUpDelegate);
|
|
|
918
|
|
|
919 event.preventDefault();
|
|
|
920
|
|
|
921 mouseHandled = true;
|
|
|
922 return true;
|
|
|
923 },
|
|
|
924
|
|
|
925 _mouseMove: function(event) {
|
|
|
926 // IE mouseup check - mouseup happened when mouse was out of window
|
|
|
927 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
|
|
|
928 return this._mouseUp(event);
|
|
|
929 }
|
|
|
930
|
|
|
931 if (this._mouseStarted) {
|
|
|
932 this._mouseDrag(event);
|
|
|
933 return event.preventDefault();
|
|
|
934 }
|
|
|
935
|
|
|
936 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
|
|
|
937 this._mouseStarted =
|
|
|
938 (this._mouseStart(this._mouseDownEvent, event) !== false);
|
|
|
939 (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
|
|
|
940 }
|
|
|
941
|
|
|
942 return !this._mouseStarted;
|
|
|
943 },
|
|
|
944
|
|
|
945 _mouseUp: function(event) {
|
|
|
946 $(document)
|
|
|
947 .unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
|
|
|
948 .unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
|
|
|
949
|
|
|
950 if (this._mouseStarted) {
|
|
|
951 this._mouseStarted = false;
|
|
|
952
|
|
|
953 if (event.target === this._mouseDownEvent.target) {
|
|
|
954 $.data(event.target, this.widgetName + ".preventClickEvent", true);
|
|
|
955 }
|
|
|
956
|
|
|
957 this._mouseStop(event);
|
|
|
958 }
|
|
|
959
|
|
|
960 return false;
|
|
|
961 },
|
|
|
962
|
|
|
963 _mouseDistanceMet: function(event) {
|
|
|
964 return (Math.max(
|
|
|
965 Math.abs(this._mouseDownEvent.pageX - event.pageX),
|
|
|
966 Math.abs(this._mouseDownEvent.pageY - event.pageY)
|
|
|
967 ) >= this.options.distance
|
|
|
968 );
|
|
|
969 },
|
|
|
970
|
|
|
971 _mouseDelayMet: function(/* event */) {
|
|
|
972 return this.mouseDelayMet;
|
|
|
973 },
|
|
|
974
|
|
|
975 // These are placeholder methods, to be overriden by extending plugin
|
|
|
976 _mouseStart: function(/* event */) {},
|
|
|
977 _mouseDrag: function(/* event */) {},
|
|
|
978 _mouseStop: function(/* event */) {},
|
|
|
979 _mouseCapture: function(/* event */) { return true; }
|
|
|
980 });
|
|
|
981
|
|
|
982 })(jQuery);
|
|
|
983 (function( $, undefined ) {
|
|
|
984
|
|
|
985 $.ui = $.ui || {};
|
|
|
986
|
|
|
987 var cachedScrollbarWidth,
|
|
|
988 max = Math.max,
|
|
|
989 abs = Math.abs,
|
|
|
990 round = Math.round,
|
|
|
991 rhorizontal = /left|center|right/,
|
|
|
992 rvertical = /top|center|bottom/,
|
|
|
993 roffset = /[\+\-]\d+(\.[\d]+)?%?/,
|
|
|
994 rposition = /^\w+/,
|
|
|
995 rpercent = /%$/,
|
|
|
996 _position = $.fn.position;
|
|
|
997
|
|
|
998 function getOffsets( offsets, width, height ) {
|
|
|
999 return [
|
|
|
1000 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
|
|
|
1001 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
|
|
|
1002 ];
|
|
|
1003 }
|
|
|
1004
|
|
|
1005 function parseCss( element, property ) {
|
|
|
1006 return parseInt( $.css( element, property ), 10 ) || 0;
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 function getDimensions( elem ) {
|
|
|
1010 var raw = elem[0];
|
|
|
1011 if ( raw.nodeType === 9 ) {
|
|
|
1012 return {
|
|
|
1013 width: elem.width(),
|
|
|
1014 height: elem.height(),
|
|
|
1015 offset: { top: 0, left: 0 }
|
|
|
1016 };
|
|
|
1017 }
|
|
|
1018 if ( $.isWindow( raw ) ) {
|
|
|
1019 return {
|
|
|
1020 width: elem.width(),
|
|
|
1021 height: elem.height(),
|
|
|
1022 offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
|
|
|
1023 };
|
|
|
1024 }
|
|
|
1025 if ( raw.preventDefault ) {
|
|
|
1026 return {
|
|
|
1027 width: 0,
|
|
|
1028 height: 0,
|
|
|
1029 offset: { top: raw.pageY, left: raw.pageX }
|
|
|
1030 };
|
|
|
1031 }
|
|
|
1032 return {
|
|
|
1033 width: elem.outerWidth(),
|
|
|
1034 height: elem.outerHeight(),
|
|
|
1035 offset: elem.offset()
|
|
|
1036 };
|
|
|
1037 }
|
|
|
1038
|
|
|
1039 $.position = {
|
|
|
1040 scrollbarWidth: function() {
|
|
|
1041 if ( cachedScrollbarWidth !== undefined ) {
|
|
|
1042 return cachedScrollbarWidth;
|
|
|
1043 }
|
|
|
1044 var w1, w2,
|
|
|
1045 div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
|
|
|
1046 innerDiv = div.children()[0];
|
|
|
1047
|
|
|
1048 $( "body" ).append( div );
|
|
|
1049 w1 = innerDiv.offsetWidth;
|
|
|
1050 div.css( "overflow", "scroll" );
|
|
|
1051
|
|
|
1052 w2 = innerDiv.offsetWidth;
|
|
|
1053
|
|
|
1054 if ( w1 === w2 ) {
|
|
|
1055 w2 = div[0].clientWidth;
|
|
|
1056 }
|
|
|
1057
|
|
|
1058 div.remove();
|
|
|
1059
|
|
|
1060 return (cachedScrollbarWidth = w1 - w2);
|
|
|
1061 },
|
|
|
1062 getScrollInfo: function( within ) {
|
|
|
1063 var overflowX = within.isWindow || within.isDocument ? "" :
|
|
|
1064 within.element.css( "overflow-x" ),
|
|
|
1065 overflowY = within.isWindow || within.isDocument ? "" :
|
|
|
1066 within.element.css( "overflow-y" ),
|
|
|
1067 hasOverflowX = overflowX === "scroll" ||
|
|
|
1068 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
|
|
|
1069 hasOverflowY = overflowY === "scroll" ||
|
|
|
1070 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
|
|
|
1071 return {
|
|
|
1072 width: hasOverflowY ? $.position.scrollbarWidth() : 0,
|
|
|
1073 height: hasOverflowX ? $.position.scrollbarWidth() : 0
|
|
|
1074 };
|
|
|
1075 },
|
|
|
1076 getWithinInfo: function( element ) {
|
|
|
1077 var withinElement = $( element || window ),
|
|
|
1078 isWindow = $.isWindow( withinElement[0] ),
|
|
|
1079 isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
|
|
|
1080 return {
|
|
|
1081 element: withinElement,
|
|
|
1082 isWindow: isWindow,
|
|
|
1083 isDocument: isDocument,
|
|
|
1084 offset: withinElement.offset() || { left: 0, top: 0 },
|
|
|
1085 scrollLeft: withinElement.scrollLeft(),
|
|
|
1086 scrollTop: withinElement.scrollTop(),
|
|
|
1087 width: isWindow ? withinElement.width() : withinElement.outerWidth(),
|
|
|
1088 height: isWindow ? withinElement.height() : withinElement.outerHeight()
|
|
|
1089 };
|
|
|
1090 }
|
|
|
1091 };
|
|
|
1092
|
|
|
1093 $.fn.position = function( options ) {
|
|
|
1094 if ( !options || !options.of ) {
|
|
|
1095 return _position.apply( this, arguments );
|
|
|
1096 }
|
|
|
1097
|
|
|
1098 // make a copy, we don't want to modify arguments
|
|
|
1099 options = $.extend( {}, options );
|
|
|
1100
|
|
|
1101 var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
|
|
|
1102 target = $( options.of ),
|
|
|
1103 within = $.position.getWithinInfo( options.within ),
|
|
|
1104 scrollInfo = $.position.getScrollInfo( within ),
|
|
|
1105 collision = ( options.collision || "flip" ).split( " " ),
|
|
|
1106 offsets = {};
|
|
|
1107
|
|
|
1108 dimensions = getDimensions( target );
|
|
|
1109 if ( target[0].preventDefault ) {
|
|
|
1110 // force left top to allow flipping
|
|
|
1111 options.at = "left top";
|
|
|
1112 }
|
|
|
1113 targetWidth = dimensions.width;
|
|
|
1114 targetHeight = dimensions.height;
|
|
|
1115 targetOffset = dimensions.offset;
|
|
|
1116 // clone to reuse original targetOffset later
|
|
|
1117 basePosition = $.extend( {}, targetOffset );
|
|
|
1118
|
|
|
1119 // force my and at to have valid horizontal and vertical positions
|
|
|
1120 // if a value is missing or invalid, it will be converted to center
|
|
|
1121 $.each( [ "my", "at" ], function() {
|
|
|
1122 var pos = ( options[ this ] || "" ).split( " " ),
|
|
|
1123 horizontalOffset,
|
|
|
1124 verticalOffset;
|
|
|
1125
|
|
|
1126 if ( pos.length === 1) {
|
|
|
1127 pos = rhorizontal.test( pos[ 0 ] ) ?
|
|
|
1128 pos.concat( [ "center" ] ) :
|
|
|
1129 rvertical.test( pos[ 0 ] ) ?
|
|
|
1130 [ "center" ].concat( pos ) :
|
|
|
1131 [ "center", "center" ];
|
|
|
1132 }
|
|
|
1133 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
|
|
|
1134 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
|
|
|
1135
|
|
|
1136 // calculate offsets
|
|
|
1137 horizontalOffset = roffset.exec( pos[ 0 ] );
|
|
|
1138 verticalOffset = roffset.exec( pos[ 1 ] );
|
|
|
1139 offsets[ this ] = [
|
|
|
1140 horizontalOffset ? horizontalOffset[ 0 ] : 0,
|
|
|
1141 verticalOffset ? verticalOffset[ 0 ] : 0
|
|
|
1142 ];
|
|
|
1143
|
|
|
1144 // reduce to just the positions without the offsets
|
|
|
1145 options[ this ] = [
|
|
|
1146 rposition.exec( pos[ 0 ] )[ 0 ],
|
|
|
1147 rposition.exec( pos[ 1 ] )[ 0 ]
|
|
|
1148 ];
|
|
|
1149 });
|
|
|
1150
|
|
|
1151 // normalize collision option
|
|
|
1152 if ( collision.length === 1 ) {
|
|
|
1153 collision[ 1 ] = collision[ 0 ];
|
|
|
1154 }
|
|
|
1155
|
|
|
1156 if ( options.at[ 0 ] === "right" ) {
|
|
|
1157 basePosition.left += targetWidth;
|
|
|
1158 } else if ( options.at[ 0 ] === "center" ) {
|
|
|
1159 basePosition.left += targetWidth / 2;
|
|
|
1160 }
|
|
|
1161
|
|
|
1162 if ( options.at[ 1 ] === "bottom" ) {
|
|
|
1163 basePosition.top += targetHeight;
|
|
|
1164 } else if ( options.at[ 1 ] === "center" ) {
|
|
|
1165 basePosition.top += targetHeight / 2;
|
|
|
1166 }
|
|
|
1167
|
|
|
1168 atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
|
|
|
1169 basePosition.left += atOffset[ 0 ];
|
|
|
1170 basePosition.top += atOffset[ 1 ];
|
|
|
1171
|
|
|
1172 return this.each(function() {
|
|
|
1173 var collisionPosition, using,
|
|
|
1174 elem = $( this ),
|
|
|
1175 elemWidth = elem.outerWidth(),
|
|
|
1176 elemHeight = elem.outerHeight(),
|
|
|
1177 marginLeft = parseCss( this, "marginLeft" ),
|
|
|
1178 marginTop = parseCss( this, "marginTop" ),
|
|
|
1179 collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
|
|
|
1180 collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
|
|
|
1181 position = $.extend( {}, basePosition ),
|
|
|
1182 myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
|
|
|
1183
|
|
|
1184 if ( options.my[ 0 ] === "right" ) {
|
|
|
1185 position.left -= elemWidth;
|
|
|
1186 } else if ( options.my[ 0 ] === "center" ) {
|
|
|
1187 position.left -= elemWidth / 2;
|
|
|
1188 }
|
|
|
1189
|
|
|
1190 if ( options.my[ 1 ] === "bottom" ) {
|
|
|
1191 position.top -= elemHeight;
|
|
|
1192 } else if ( options.my[ 1 ] === "center" ) {
|
|
|
1193 position.top -= elemHeight / 2;
|
|
|
1194 }
|
|
|
1195
|
|
|
1196 position.left += myOffset[ 0 ];
|
|
|
1197 position.top += myOffset[ 1 ];
|
|
|
1198
|
|
|
1199 // if the browser doesn't support fractions, then round for consistent results
|
|
|
1200 if ( !$.support.offsetFractions ) {
|
|
|
1201 position.left = round( position.left );
|
|
|
1202 position.top = round( position.top );
|
|
|
1203 }
|
|
|
1204
|
|
|
1205 collisionPosition = {
|
|
|
1206 marginLeft: marginLeft,
|
|
|
1207 marginTop: marginTop
|
|
|
1208 };
|
|
|
1209
|
|
|
1210 $.each( [ "left", "top" ], function( i, dir ) {
|
|
|
1211 if ( $.ui.position[ collision[ i ] ] ) {
|
|
|
1212 $.ui.position[ collision[ i ] ][ dir ]( position, {
|
|
|
1213 targetWidth: targetWidth,
|
|
|
1214 targetHeight: targetHeight,
|
|
|
1215 elemWidth: elemWidth,
|
|
|
1216 elemHeight: elemHeight,
|
|
|
1217 collisionPosition: collisionPosition,
|
|
|
1218 collisionWidth: collisionWidth,
|
|
|
1219 collisionHeight: collisionHeight,
|
|
|
1220 offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
|
|
|
1221 my: options.my,
|
|
|
1222 at: options.at,
|
|
|
1223 within: within,
|
|
|
1224 elem : elem
|
|
|
1225 });
|
|
|
1226 }
|
|
|
1227 });
|
|
|
1228
|
|
|
1229 if ( options.using ) {
|
|
|
1230 // adds feedback as second argument to using callback, if present
|
|
|
1231 using = function( props ) {
|
|
|
1232 var left = targetOffset.left - position.left,
|
|
|
1233 right = left + targetWidth - elemWidth,
|
|
|
1234 top = targetOffset.top - position.top,
|
|
|
1235 bottom = top + targetHeight - elemHeight,
|
|
|
1236 feedback = {
|
|
|
1237 target: {
|
|
|
1238 element: target,
|
|
|
1239 left: targetOffset.left,
|
|
|
1240 top: targetOffset.top,
|
|
|
1241 width: targetWidth,
|
|
|
1242 height: targetHeight
|
|
|
1243 },
|
|
|
1244 element: {
|
|
|
1245 element: elem,
|
|
|
1246 left: position.left,
|
|
|
1247 top: position.top,
|
|
|
1248 width: elemWidth,
|
|
|
1249 height: elemHeight
|
|
|
1250 },
|
|
|
1251 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
|
|
|
1252 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
|
|
|
1253 };
|
|
|
1254 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
|
|
|
1255 feedback.horizontal = "center";
|
|
|
1256 }
|
|
|
1257 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
|
|
|
1258 feedback.vertical = "middle";
|
|
|
1259 }
|
|
|
1260 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
|
|
|
1261 feedback.important = "horizontal";
|
|
|
1262 } else {
|
|
|
1263 feedback.important = "vertical";
|
|
|
1264 }
|
|
|
1265 options.using.call( this, props, feedback );
|
|
|
1266 };
|
|
|
1267 }
|
|
|
1268
|
|
|
1269 elem.offset( $.extend( position, { using: using } ) );
|
|
|
1270 });
|
|
|
1271 };
|
|
|
1272
|
|
|
1273 $.ui.position = {
|
|
|
1274 fit: {
|
|
|
1275 left: function( position, data ) {
|
|
|
1276 var within = data.within,
|
|
|
1277 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
|
|
|
1278 outerWidth = within.width,
|
|
|
1279 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
|
|
|
1280 overLeft = withinOffset - collisionPosLeft,
|
|
|
1281 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
|
|
|
1282 newOverRight;
|
|
|
1283
|
|
|
1284 // element is wider than within
|
|
|
1285 if ( data.collisionWidth > outerWidth ) {
|
|
|
1286 // element is initially over the left side of within
|
|
|
1287 if ( overLeft > 0 && overRight <= 0 ) {
|
|
|
1288 newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
|
|
|
1289 position.left += overLeft - newOverRight;
|
|
|
1290 // element is initially over right side of within
|
|
|
1291 } else if ( overRight > 0 && overLeft <= 0 ) {
|
|
|
1292 position.left = withinOffset;
|
|
|
1293 // element is initially over both left and right sides of within
|
|
|
1294 } else {
|
|
|
1295 if ( overLeft > overRight ) {
|
|
|
1296 position.left = withinOffset + outerWidth - data.collisionWidth;
|
|
|
1297 } else {
|
|
|
1298 position.left = withinOffset;
|
|
|
1299 }
|
|
|
1300 }
|
|
|
1301 // too far left -> align with left edge
|
|
|
1302 } else if ( overLeft > 0 ) {
|
|
|
1303 position.left += overLeft;
|
|
|
1304 // too far right -> align with right edge
|
|
|
1305 } else if ( overRight > 0 ) {
|
|
|
1306 position.left -= overRight;
|
|
|
1307 // adjust based on position and margin
|
|
|
1308 } else {
|
|
|
1309 position.left = max( position.left - collisionPosLeft, position.left );
|
|
|
1310 }
|
|
|
1311 },
|
|
|
1312 top: function( position, data ) {
|
|
|
1313 var within = data.within,
|
|
|
1314 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
|
|
|
1315 outerHeight = data.within.height,
|
|
|
1316 collisionPosTop = position.top - data.collisionPosition.marginTop,
|
|
|
1317 overTop = withinOffset - collisionPosTop,
|
|
|
1318 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
|
|
|
1319 newOverBottom;
|
|
|
1320
|
|
|
1321 // element is taller than within
|
|
|
1322 if ( data.collisionHeight > outerHeight ) {
|
|
|
1323 // element is initially over the top of within
|
|
|
1324 if ( overTop > 0 && overBottom <= 0 ) {
|
|
|
1325 newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
|
|
|
1326 position.top += overTop - newOverBottom;
|
|
|
1327 // element is initially over bottom of within
|
|
|
1328 } else if ( overBottom > 0 && overTop <= 0 ) {
|
|
|
1329 position.top = withinOffset;
|
|
|
1330 // element is initially over both top and bottom of within
|
|
|
1331 } else {
|
|
|
1332 if ( overTop > overBottom ) {
|
|
|
1333 position.top = withinOffset + outerHeight - data.collisionHeight;
|
|
|
1334 } else {
|
|
|
1335 position.top = withinOffset;
|
|
|
1336 }
|
|
|
1337 }
|
|
|
1338 // too far up -> align with top
|
|
|
1339 } else if ( overTop > 0 ) {
|
|
|
1340 position.top += overTop;
|
|
|
1341 // too far down -> align with bottom edge
|
|
|
1342 } else if ( overBottom > 0 ) {
|
|
|
1343 position.top -= overBottom;
|
|
|
1344 // adjust based on position and margin
|
|
|
1345 } else {
|
|
|
1346 position.top = max( position.top - collisionPosTop, position.top );
|
|
|
1347 }
|
|
|
1348 }
|
|
|
1349 },
|
|
|
1350 flip: {
|
|
|
1351 left: function( position, data ) {
|
|
|
1352 var within = data.within,
|
|
|
1353 withinOffset = within.offset.left + within.scrollLeft,
|
|
|
1354 outerWidth = within.width,
|
|
|
1355 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
|
|
|
1356 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
|
|
|
1357 overLeft = collisionPosLeft - offsetLeft,
|
|
|
1358 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
|
|
|
1359 myOffset = data.my[ 0 ] === "left" ?
|
|
|
1360 -data.elemWidth :
|
|
|
1361 data.my[ 0 ] === "right" ?
|
|
|
1362 data.elemWidth :
|
|
|
1363 0,
|
|
|
1364 atOffset = data.at[ 0 ] === "left" ?
|
|
|
1365 data.targetWidth :
|
|
|
1366 data.at[ 0 ] === "right" ?
|
|
|
1367 -data.targetWidth :
|
|
|
1368 0,
|
|
|
1369 offset = -2 * data.offset[ 0 ],
|
|
|
1370 newOverRight,
|
|
|
1371 newOverLeft;
|
|
|
1372
|
|
|
1373 if ( overLeft < 0 ) {
|
|
|
1374 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
|
|
|
1375 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
|
|
|
1376 position.left += myOffset + atOffset + offset;
|
|
|
1377 }
|
|
|
1378 }
|
|
|
1379 else if ( overRight > 0 ) {
|
|
|
1380 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
|
|
|
1381 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
|
|
|
1382 position.left += myOffset + atOffset + offset;
|
|
|
1383 }
|
|
|
1384 }
|
|
|
1385 },
|
|
|
1386 top: function( position, data ) {
|
|
|
1387 var within = data.within,
|
|
|
1388 withinOffset = within.offset.top + within.scrollTop,
|
|
|
1389 outerHeight = within.height,
|
|
|
1390 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
|
|
|
1391 collisionPosTop = position.top - data.collisionPosition.marginTop,
|
|
|
1392 overTop = collisionPosTop - offsetTop,
|
|
|
1393 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
|
|
|
1394 top = data.my[ 1 ] === "top",
|
|
|
1395 myOffset = top ?
|
|
|
1396 -data.elemHeight :
|
|
|
1397 data.my[ 1 ] === "bottom" ?
|
|
|
1398 data.elemHeight :
|
|
|
1399 0,
|
|
|
1400 atOffset = data.at[ 1 ] === "top" ?
|
|
|
1401 data.targetHeight :
|
|
|
1402 data.at[ 1 ] === "bottom" ?
|
|
|
1403 -data.targetHeight :
|
|
|
1404 0,
|
|
|
1405 offset = -2 * data.offset[ 1 ],
|
|
|
1406 newOverTop,
|
|
|
1407 newOverBottom;
|
|
|
1408 if ( overTop < 0 ) {
|
|
|
1409 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
|
|
|
1410 if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
|
|
|
1411 position.top += myOffset + atOffset + offset;
|
|
|
1412 }
|
|
|
1413 }
|
|
|
1414 else if ( overBottom > 0 ) {
|
|
|
1415 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
|
|
|
1416 if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
|
|
|
1417 position.top += myOffset + atOffset + offset;
|
|
|
1418 }
|
|
|
1419 }
|
|
|
1420 }
|
|
|
1421 },
|
|
|
1422 flipfit: {
|
|
|
1423 left: function() {
|
|
|
1424 $.ui.position.flip.left.apply( this, arguments );
|
|
|
1425 $.ui.position.fit.left.apply( this, arguments );
|
|
|
1426 },
|
|
|
1427 top: function() {
|
|
|
1428 $.ui.position.flip.top.apply( this, arguments );
|
|
|
1429 $.ui.position.fit.top.apply( this, arguments );
|
|
|
1430 }
|
|
|
1431 }
|
|
|
1432 };
|
|
|
1433
|
|
|
1434 // fraction support test
|
|
|
1435 (function () {
|
|
|
1436 var testElement, testElementParent, testElementStyle, offsetLeft, i,
|
|
|
1437 body = document.getElementsByTagName( "body" )[ 0 ],
|
|
|
1438 div = document.createElement( "div" );
|
|
|
1439
|
|
|
1440 //Create a "fake body" for testing based on method used in jQuery.support
|
|
|
1441 testElement = document.createElement( body ? "div" : "body" );
|
|
|
1442 testElementStyle = {
|
|
|
1443 visibility: "hidden",
|
|
|
1444 width: 0,
|
|
|
1445 height: 0,
|
|
|
1446 border: 0,
|
|
|
1447 margin: 0,
|
|
|
1448 background: "none"
|
|
|
1449 };
|
|
|
1450 if ( body ) {
|
|
|
1451 $.extend( testElementStyle, {
|
|
|
1452 position: "absolute",
|
|
|
1453 left: "-1000px",
|
|
|
1454 top: "-1000px"
|
|
|
1455 });
|
|
|
1456 }
|
|
|
1457 for ( i in testElementStyle ) {
|
|
|
1458 testElement.style[ i ] = testElementStyle[ i ];
|
|
|
1459 }
|
|
|
1460 testElement.appendChild( div );
|
|
|
1461 testElementParent = body || document.documentElement;
|
|
|
1462 testElementParent.insertBefore( testElement, testElementParent.firstChild );
|
|
|
1463
|
|
|
1464 div.style.cssText = "position: absolute; left: 10.7432222px;";
|
|
|
1465
|
|
|
1466 offsetLeft = $( div ).offset().left;
|
|
|
1467 $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
|
|
|
1468
|
|
|
1469 testElement.innerHTML = "";
|
|
|
1470 testElementParent.removeChild( testElement );
|
|
|
1471 })();
|
|
|
1472
|
|
|
1473 }( jQuery ) );
|
|
|
1474 (function( $, undefined ) {
|
|
|
1475
|
|
|
1476 var uid = 0,
|
|
|
1477 hideProps = {},
|
|
|
1478 showProps = {};
|
|
|
1479
|
|
|
1480 hideProps.height = hideProps.paddingTop = hideProps.paddingBottom =
|
|
|
1481 hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide";
|
|
|
1482 showProps.height = showProps.paddingTop = showProps.paddingBottom =
|
|
|
1483 showProps.borderTopWidth = showProps.borderBottomWidth = "show";
|
|
|
1484
|
|
|
1485 $.widget( "ui.accordion", {
|
|
|
1486 version: "1.10.4",
|
|
|
1487 options: {
|
|
|
1488 active: 0,
|
|
|
1489 animate: {},
|
|
|
1490 collapsible: false,
|
|
|
1491 event: "click",
|
|
|
1492 header: "> li > :first-child,> :not(li):even",
|
|
|
1493 heightStyle: "auto",
|
|
|
1494 icons: {
|
|
|
1495 activeHeader: "ui-icon-triangle-1-s",
|
|
|
1496 header: "ui-icon-triangle-1-e"
|
|
|
1497 },
|
|
|
1498
|
|
|
1499 // callbacks
|
|
|
1500 activate: null,
|
|
|
1501 beforeActivate: null
|
|
|
1502 },
|
|
|
1503
|
|
|
1504 _create: function() {
|
|
|
1505 var options = this.options;
|
|
|
1506 this.prevShow = this.prevHide = $();
|
|
|
1507 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
|
|
|
1508 // ARIA
|
|
|
1509 .attr( "role", "tablist" );
|
|
|
1510
|
|
|
1511 // don't allow collapsible: false and active: false / null
|
|
|
1512 if ( !options.collapsible && (options.active === false || options.active == null) ) {
|
|
|
1513 options.active = 0;
|
|
|
1514 }
|
|
|
1515
|
|
|
1516 this._processPanels();
|
|
|
1517 // handle negative values
|
|
|
1518 if ( options.active < 0 ) {
|
|
|
1519 options.active += this.headers.length;
|
|
|
1520 }
|
|
|
1521 this._refresh();
|
|
|
1522 },
|
|
|
1523
|
|
|
1524 _getCreateEventData: function() {
|
|
|
1525 return {
|
|
|
1526 header: this.active,
|
|
|
1527 panel: !this.active.length ? $() : this.active.next(),
|
|
|
1528 content: !this.active.length ? $() : this.active.next()
|
|
|
1529 };
|
|
|
1530 },
|
|
|
1531
|
|
|
1532 _createIcons: function() {
|
|
|
1533 var icons = this.options.icons;
|
|
|
1534 if ( icons ) {
|
|
|
1535 $( "<span>" )
|
|
|
1536 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
|
|
|
1537 .prependTo( this.headers );
|
|
|
1538 this.active.children( ".ui-accordion-header-icon" )
|
|
|
1539 .removeClass( icons.header )
|
|
|
1540 .addClass( icons.activeHeader );
|
|
|
1541 this.headers.addClass( "ui-accordion-icons" );
|
|
|
1542 }
|
|
|
1543 },
|
|
|
1544
|
|
|
1545 _destroyIcons: function() {
|
|
|
1546 this.headers
|
|
|
1547 .removeClass( "ui-accordion-icons" )
|
|
|
1548 .children( ".ui-accordion-header-icon" )
|
|
|
1549 .remove();
|
|
|
1550 },
|
|
|
1551
|
|
|
1552 _destroy: function() {
|
|
|
1553 var contents;
|
|
|
1554
|
|
|
1555 // clean up main element
|
|
|
1556 this.element
|
|
|
1557 .removeClass( "ui-accordion ui-widget ui-helper-reset" )
|
|
|
1558 .removeAttr( "role" );
|
|
|
1559
|
|
|
1560 // clean up headers
|
|
|
1561 this.headers
|
|
|
1562 .removeClass( "ui-accordion-header ui-accordion-header-active ui-helper-reset ui-state-default ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
|
|
|
1563 .removeAttr( "role" )
|
|
|
1564 .removeAttr( "aria-expanded" )
|
|
|
1565 .removeAttr( "aria-selected" )
|
|
|
1566 .removeAttr( "aria-controls" )
|
|
|
1567 .removeAttr( "tabIndex" )
|
|
|
1568 .each(function() {
|
|
|
1569 if ( /^ui-accordion/.test( this.id ) ) {
|
|
|
1570 this.removeAttribute( "id" );
|
|
|
1571 }
|
|
|
1572 });
|
|
|
1573 this._destroyIcons();
|
|
|
1574
|
|
|
1575 // clean up content panels
|
|
|
1576 contents = this.headers.next()
|
|
|
1577 .css( "display", "" )
|
|
|
1578 .removeAttr( "role" )
|
|
|
1579 .removeAttr( "aria-hidden" )
|
|
|
1580 .removeAttr( "aria-labelledby" )
|
|
|
1581 .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
|
|
|
1582 .each(function() {
|
|
|
1583 if ( /^ui-accordion/.test( this.id ) ) {
|
|
|
1584 this.removeAttribute( "id" );
|
|
|
1585 }
|
|
|
1586 });
|
|
|
1587 if ( this.options.heightStyle !== "content" ) {
|
|
|
1588 contents.css( "height", "" );
|
|
|
1589 }
|
|
|
1590 },
|
|
|
1591
|
|
|
1592 _setOption: function( key, value ) {
|
|
|
1593 if ( key === "active" ) {
|
|
|
1594 // _activate() will handle invalid values and update this.options
|
|
|
1595 this._activate( value );
|
|
|
1596 return;
|
|
|
1597 }
|
|
|
1598
|
|
|
1599 if ( key === "event" ) {
|
|
|
1600 if ( this.options.event ) {
|
|
|
1601 this._off( this.headers, this.options.event );
|
|
|
1602 }
|
|
|
1603 this._setupEvents( value );
|
|
|
1604 }
|
|
|
1605
|
|
|
1606 this._super( key, value );
|
|
|
1607
|
|
|
1608 // setting collapsible: false while collapsed; open first panel
|
|
|
1609 if ( key === "collapsible" && !value && this.options.active === false ) {
|
|
|
1610 this._activate( 0 );
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 if ( key === "icons" ) {
|
|
|
1614 this._destroyIcons();
|
|
|
1615 if ( value ) {
|
|
|
1616 this._createIcons();
|
|
|
1617 }
|
|
|
1618 }
|
|
|
1619
|
|
|
1620 // #5332 - opacity doesn't cascade to positioned elements in IE
|
|
|
1621 // so we need to add the disabled class to the headers and panels
|
|
|
1622 if ( key === "disabled" ) {
|
|
|
1623 this.headers.add( this.headers.next() )
|
|
|
1624 .toggleClass( "ui-state-disabled", !!value );
|
|
|
1625 }
|
|
|
1626 },
|
|
|
1627
|
|
|
1628 _keydown: function( event ) {
|
|
|
1629 if ( event.altKey || event.ctrlKey ) {
|
|
|
1630 return;
|
|
|
1631 }
|
|
|
1632
|
|
|
1633 var keyCode = $.ui.keyCode,
|
|
|
1634 length = this.headers.length,
|
|
|
1635 currentIndex = this.headers.index( event.target ),
|
|
|
1636 toFocus = false;
|
|
|
1637
|
|
|
1638 switch ( event.keyCode ) {
|
|
|
1639 case keyCode.RIGHT:
|
|
|
1640 case keyCode.DOWN:
|
|
|
1641 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
|
|
|
1642 break;
|
|
|
1643 case keyCode.LEFT:
|
|
|
1644 case keyCode.UP:
|
|
|
1645 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
|
|
|
1646 break;
|
|
|
1647 case keyCode.SPACE:
|
|
|
1648 case keyCode.ENTER:
|
|
|
1649 this._eventHandler( event );
|
|
|
1650 break;
|
|
|
1651 case keyCode.HOME:
|
|
|
1652 toFocus = this.headers[ 0 ];
|
|
|
1653 break;
|
|
|
1654 case keyCode.END:
|
|
|
1655 toFocus = this.headers[ length - 1 ];
|
|
|
1656 break;
|
|
|
1657 }
|
|
|
1658
|
|
|
1659 if ( toFocus ) {
|
|
|
1660 $( event.target ).attr( "tabIndex", -1 );
|
|
|
1661 $( toFocus ).attr( "tabIndex", 0 );
|
|
|
1662 toFocus.focus();
|
|
|
1663 event.preventDefault();
|
|
|
1664 }
|
|
|
1665 },
|
|
|
1666
|
|
|
1667 _panelKeyDown : function( event ) {
|
|
|
1668 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
|
|
|
1669 $( event.currentTarget ).prev().focus();
|
|
|
1670 }
|
|
|
1671 },
|
|
|
1672
|
|
|
1673 refresh: function() {
|
|
|
1674 var options = this.options;
|
|
|
1675 this._processPanels();
|
|
|
1676
|
|
|
1677 // was collapsed or no panel
|
|
|
1678 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
|
|
|
1679 options.active = false;
|
|
|
1680 this.active = $();
|
|
|
1681 // active false only when collapsible is true
|
|
|
1682 } else if ( options.active === false ) {
|
|
|
1683 this._activate( 0 );
|
|
|
1684 // was active, but active panel is gone
|
|
|
1685 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
|
|
|
1686 // all remaining panel are disabled
|
|
|
1687 if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
|
|
|
1688 options.active = false;
|
|
|
1689 this.active = $();
|
|
|
1690 // activate previous panel
|
|
|
1691 } else {
|
|
|
1692 this._activate( Math.max( 0, options.active - 1 ) );
|
|
|
1693 }
|
|
|
1694 // was active, active panel still exists
|
|
|
1695 } else {
|
|
|
1696 // make sure active index is correct
|
|
|
1697 options.active = this.headers.index( this.active );
|
|
|
1698 }
|
|
|
1699
|
|
|
1700 this._destroyIcons();
|
|
|
1701
|
|
|
1702 this._refresh();
|
|
|
1703 },
|
|
|
1704
|
|
|
1705 _processPanels: function() {
|
|
|
1706 this.headers = this.element.find( this.options.header )
|
|
|
1707 .addClass( "ui-accordion-header ui-helper-reset ui-state-default ui-corner-all" );
|
|
|
1708
|
|
|
1709 this.headers.next()
|
|
|
1710 .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
|
|
|
1711 .filter(":not(.ui-accordion-content-active)")
|
|
|
1712 .hide();
|
|
|
1713 },
|
|
|
1714
|
|
|
1715 _refresh: function() {
|
|
|
1716 var maxHeight,
|
|
|
1717 options = this.options,
|
|
|
1718 heightStyle = options.heightStyle,
|
|
|
1719 parent = this.element.parent(),
|
|
|
1720 accordionId = this.accordionId = "ui-accordion-" +
|
|
|
1721 (this.element.attr( "id" ) || ++uid);
|
|
|
1722
|
|
|
1723 this.active = this._findActive( options.active )
|
|
|
1724 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
|
|
|
1725 .removeClass( "ui-corner-all" );
|
|
|
1726 this.active.next()
|
|
|
1727 .addClass( "ui-accordion-content-active" )
|
|
|
1728 .show();
|
|
|
1729
|
|
|
1730 this.headers
|
|
|
1731 .attr( "role", "tab" )
|
|
|
1732 .each(function( i ) {
|
|
|
1733 var header = $( this ),
|
|
|
1734 headerId = header.attr( "id" ),
|
|
|
1735 panel = header.next(),
|
|
|
1736 panelId = panel.attr( "id" );
|
|
|
1737 if ( !headerId ) {
|
|
|
1738 headerId = accordionId + "-header-" + i;
|
|
|
1739 header.attr( "id", headerId );
|
|
|
1740 }
|
|
|
1741 if ( !panelId ) {
|
|
|
1742 panelId = accordionId + "-panel-" + i;
|
|
|
1743 panel.attr( "id", panelId );
|
|
|
1744 }
|
|
|
1745 header.attr( "aria-controls", panelId );
|
|
|
1746 panel.attr( "aria-labelledby", headerId );
|
|
|
1747 })
|
|
|
1748 .next()
|
|
|
1749 .attr( "role", "tabpanel" );
|
|
|
1750
|
|
|
1751 this.headers
|
|
|
1752 .not( this.active )
|
|
|
1753 .attr({
|
|
|
1754 "aria-selected": "false",
|
|
|
1755 "aria-expanded": "false",
|
|
|
1756 tabIndex: -1
|
|
|
1757 })
|
|
|
1758 .next()
|
|
|
1759 .attr({
|
|
|
1760 "aria-hidden": "true"
|
|
|
1761 })
|
|
|
1762 .hide();
|
|
|
1763
|
|
|
1764 // make sure at least one header is in the tab order
|
|
|
1765 if ( !this.active.length ) {
|
|
|
1766 this.headers.eq( 0 ).attr( "tabIndex", 0 );
|
|
|
1767 } else {
|
|
|
1768 this.active.attr({
|
|
|
1769 "aria-selected": "true",
|
|
|
1770 "aria-expanded": "true",
|
|
|
1771 tabIndex: 0
|
|
|
1772 })
|
|
|
1773 .next()
|
|
|
1774 .attr({
|
|
|
1775 "aria-hidden": "false"
|
|
|
1776 });
|
|
|
1777 }
|
|
|
1778
|
|
|
1779 this._createIcons();
|
|
|
1780
|
|
|
1781 this._setupEvents( options.event );
|
|
|
1782
|
|
|
1783 if ( heightStyle === "fill" ) {
|
|
|
1784 maxHeight = parent.height();
|
|
|
1785 this.element.siblings( ":visible" ).each(function() {
|
|
|
1786 var elem = $( this ),
|
|
|
1787 position = elem.css( "position" );
|
|
|
1788
|
|
|
1789 if ( position === "absolute" || position === "fixed" ) {
|
|
|
1790 return;
|
|
|
1791 }
|
|
|
1792 maxHeight -= elem.outerHeight( true );
|
|
|
1793 });
|
|
|
1794
|
|
|
1795 this.headers.each(function() {
|
|
|
1796 maxHeight -= $( this ).outerHeight( true );
|
|
|
1797 });
|
|
|
1798
|
|
|
1799 this.headers.next()
|
|
|
1800 .each(function() {
|
|
|
1801 $( this ).height( Math.max( 0, maxHeight -
|
|
|
1802 $( this ).innerHeight() + $( this ).height() ) );
|
|
|
1803 })
|
|
|
1804 .css( "overflow", "auto" );
|
|
|
1805 } else if ( heightStyle === "auto" ) {
|
|
|
1806 maxHeight = 0;
|
|
|
1807 this.headers.next()
|
|
|
1808 .each(function() {
|
|
|
1809 maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
|
|
|
1810 })
|
|
|
1811 .height( maxHeight );
|
|
|
1812 }
|
|
|
1813 },
|
|
|
1814
|
|
|
1815 _activate: function( index ) {
|
|
|
1816 var active = this._findActive( index )[ 0 ];
|
|
|
1817
|
|
|
1818 // trying to activate the already active panel
|
|
|
1819 if ( active === this.active[ 0 ] ) {
|
|
|
1820 return;
|
|
|
1821 }
|
|
|
1822
|
|
|
1823 // trying to collapse, simulate a click on the currently active header
|
|
|
1824 active = active || this.active[ 0 ];
|
|
|
1825
|
|
|
1826 this._eventHandler({
|
|
|
1827 target: active,
|
|
|
1828 currentTarget: active,
|
|
|
1829 preventDefault: $.noop
|
|
|
1830 });
|
|
|
1831 },
|
|
|
1832
|
|
|
1833 _findActive: function( selector ) {
|
|
|
1834 return typeof selector === "number" ? this.headers.eq( selector ) : $();
|
|
|
1835 },
|
|
|
1836
|
|
|
1837 _setupEvents: function( event ) {
|
|
|
1838 var events = {
|
|
|
1839 keydown: "_keydown"
|
|
|
1840 };
|
|
|
1841 if ( event ) {
|
|
|
1842 $.each( event.split(" "), function( index, eventName ) {
|
|
|
1843 events[ eventName ] = "_eventHandler";
|
|
|
1844 });
|
|
|
1845 }
|
|
|
1846
|
|
|
1847 this._off( this.headers.add( this.headers.next() ) );
|
|
|
1848 this._on( this.headers, events );
|
|
|
1849 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
|
|
|
1850 this._hoverable( this.headers );
|
|
|
1851 this._focusable( this.headers );
|
|
|
1852 },
|
|
|
1853
|
|
|
1854 _eventHandler: function( event ) {
|
|
|
1855 var options = this.options,
|
|
|
1856 active = this.active,
|
|
|
1857 clicked = $( event.currentTarget ),
|
|
|
1858 clickedIsActive = clicked[ 0 ] === active[ 0 ],
|
|
|
1859 collapsing = clickedIsActive && options.collapsible,
|
|
|
1860 toShow = collapsing ? $() : clicked.next(),
|
|
|
1861 toHide = active.next(),
|
|
|
1862 eventData = {
|
|
|
1863 oldHeader: active,
|
|
|
1864 oldPanel: toHide,
|
|
|
1865 newHeader: collapsing ? $() : clicked,
|
|
|
1866 newPanel: toShow
|
|
|
1867 };
|
|
|
1868
|
|
|
1869 event.preventDefault();
|
|
|
1870
|
|
|
1871 if (
|
|
|
1872 // click on active header, but not collapsible
|
|
|
1873 ( clickedIsActive && !options.collapsible ) ||
|
|
|
1874 // allow canceling activation
|
|
|
1875 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
|
|
|
1876 return;
|
|
|
1877 }
|
|
|
1878
|
|
|
1879 options.active = collapsing ? false : this.headers.index( clicked );
|
|
|
1880
|
|
|
1881 // when the call to ._toggle() comes after the class changes
|
|
|
1882 // it causes a very odd bug in IE 8 (see #6720)
|
|
|
1883 this.active = clickedIsActive ? $() : clicked;
|
|
|
1884 this._toggle( eventData );
|
|
|
1885
|
|
|
1886 // switch classes
|
|
|
1887 // corner classes on the previously active header stay after the animation
|
|
|
1888 active.removeClass( "ui-accordion-header-active ui-state-active" );
|
|
|
1889 if ( options.icons ) {
|
|
|
1890 active.children( ".ui-accordion-header-icon" )
|
|
|
1891 .removeClass( options.icons.activeHeader )
|
|
|
1892 .addClass( options.icons.header );
|
|
|
1893 }
|
|
|
1894
|
|
|
1895 if ( !clickedIsActive ) {
|
|
|
1896 clicked
|
|
|
1897 .removeClass( "ui-corner-all" )
|
|
|
1898 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
|
|
|
1899 if ( options.icons ) {
|
|
|
1900 clicked.children( ".ui-accordion-header-icon" )
|
|
|
1901 .removeClass( options.icons.header )
|
|
|
1902 .addClass( options.icons.activeHeader );
|
|
|
1903 }
|
|
|
1904
|
|
|
1905 clicked
|
|
|
1906 .next()
|
|
|
1907 .addClass( "ui-accordion-content-active" );
|
|
|
1908 }
|
|
|
1909 },
|
|
|
1910
|
|
|
1911 _toggle: function( data ) {
|
|
|
1912 var toShow = data.newPanel,
|
|
|
1913 toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
|
|
|
1914
|
|
|
1915 // handle activating a panel during the animation for another activation
|
|
|
1916 this.prevShow.add( this.prevHide ).stop( true, true );
|
|
|
1917 this.prevShow = toShow;
|
|
|
1918 this.prevHide = toHide;
|
|
|
1919
|
|
|
1920 if ( this.options.animate ) {
|
|
|
1921 this._animate( toShow, toHide, data );
|
|
|
1922 } else {
|
|
|
1923 toHide.hide();
|
|
|
1924 toShow.show();
|
|
|
1925 this._toggleComplete( data );
|
|
|
1926 }
|
|
|
1927
|
|
|
1928 toHide.attr({
|
|
|
1929 "aria-hidden": "true"
|
|
|
1930 });
|
|
|
1931 toHide.prev().attr( "aria-selected", "false" );
|
|
|
1932 // if we're switching panels, remove the old header from the tab order
|
|
|
1933 // if we're opening from collapsed state, remove the previous header from the tab order
|
|
|
1934 // if we're collapsing, then keep the collapsing header in the tab order
|
|
|
1935 if ( toShow.length && toHide.length ) {
|
|
|
1936 toHide.prev().attr({
|
|
|
1937 "tabIndex": -1,
|
|
|
1938 "aria-expanded": "false"
|
|
|
1939 });
|
|
|
1940 } else if ( toShow.length ) {
|
|
|
1941 this.headers.filter(function() {
|
|
|
1942 return $( this ).attr( "tabIndex" ) === 0;
|
|
|
1943 })
|
|
|
1944 .attr( "tabIndex", -1 );
|
|
|
1945 }
|
|
|
1946
|
|
|
1947 toShow
|
|
|
1948 .attr( "aria-hidden", "false" )
|
|
|
1949 .prev()
|
|
|
1950 .attr({
|
|
|
1951 "aria-selected": "true",
|
|
|
1952 tabIndex: 0,
|
|
|
1953 "aria-expanded": "true"
|
|
|
1954 });
|
|
|
1955 },
|
|
|
1956
|
|
|
1957 _animate: function( toShow, toHide, data ) {
|
|
|
1958 var total, easing, duration,
|
|
|
1959 that = this,
|
|
|
1960 adjust = 0,
|
|
|
1961 down = toShow.length &&
|
|
|
1962 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
|
|
|
1963 animate = this.options.animate || {},
|
|
|
1964 options = down && animate.down || animate,
|
|
|
1965 complete = function() {
|
|
|
1966 that._toggleComplete( data );
|
|
|
1967 };
|
|
|
1968
|
|
|
1969 if ( typeof options === "number" ) {
|
|
|
1970 duration = options;
|
|
|
1971 }
|
|
|
1972 if ( typeof options === "string" ) {
|
|
|
1973 easing = options;
|
|
|
1974 }
|
|
|
1975 // fall back from options to animation in case of partial down settings
|
|
|
1976 easing = easing || options.easing || animate.easing;
|
|
|
1977 duration = duration || options.duration || animate.duration;
|
|
|
1978
|
|
|
1979 if ( !toHide.length ) {
|
|
|
1980 return toShow.animate( showProps, duration, easing, complete );
|
|
|
1981 }
|
|
|
1982 if ( !toShow.length ) {
|
|
|
1983 return toHide.animate( hideProps, duration, easing, complete );
|
|
|
1984 }
|
|
|
1985
|
|
|
1986 total = toShow.show().outerHeight();
|
|
|
1987 toHide.animate( hideProps, {
|
|
|
1988 duration: duration,
|
|
|
1989 easing: easing,
|
|
|
1990 step: function( now, fx ) {
|
|
|
1991 fx.now = Math.round( now );
|
|
|
1992 }
|
|
|
1993 });
|
|
|
1994 toShow
|
|
|
1995 .hide()
|
|
|
1996 .animate( showProps, {
|
|
|
1997 duration: duration,
|
|
|
1998 easing: easing,
|
|
|
1999 complete: complete,
|
|
|
2000 step: function( now, fx ) {
|
|
|
2001 fx.now = Math.round( now );
|
|
|
2002 if ( fx.prop !== "height" ) {
|
|
|
2003 adjust += fx.now;
|
|
|
2004 } else if ( that.options.heightStyle !== "content" ) {
|
|
|
2005 fx.now = Math.round( total - toHide.outerHeight() - adjust );
|
|
|
2006 adjust = 0;
|
|
|
2007 }
|
|
|
2008 }
|
|
|
2009 });
|
|
|
2010 },
|
|
|
2011
|
|
|
2012 _toggleComplete: function( data ) {
|
|
|
2013 var toHide = data.oldPanel;
|
|
|
2014
|
|
|
2015 toHide
|
|
|
2016 .removeClass( "ui-accordion-content-active" )
|
|
|
2017 .prev()
|
|
|
2018 .removeClass( "ui-corner-top" )
|
|
|
2019 .addClass( "ui-corner-all" );
|
|
|
2020
|
|
|
2021 // Work around for rendering bug in IE (#5421)
|
|
|
2022 if ( toHide.length ) {
|
|
|
2023 toHide.parent()[0].className = toHide.parent()[0].className;
|
|
|
2024 }
|
|
|
2025 this._trigger( "activate", null, data );
|
|
|
2026 }
|
|
|
2027 });
|
|
|
2028
|
|
|
2029 })( jQuery );
|
|
|
2030 (function( $, undefined ) {
|
|
|
2031
|
|
|
2032 $.widget( "ui.autocomplete", {
|
|
|
2033 version: "1.10.4",
|
|
|
2034 defaultElement: "<input>",
|
|
|
2035 options: {
|
|
|
2036 appendTo: null,
|
|
|
2037 autoFocus: false,
|
|
|
2038 delay: 300,
|
|
|
2039 minLength: 1,
|
|
|
2040 position: {
|
|
|
2041 my: "left top",
|
|
|
2042 at: "left bottom",
|
|
|
2043 collision: "none"
|
|
|
2044 },
|
|
|
2045 source: null,
|
|
|
2046
|
|
|
2047 // callbacks
|
|
|
2048 change: null,
|
|
|
2049 close: null,
|
|
|
2050 focus: null,
|
|
|
2051 open: null,
|
|
|
2052 response: null,
|
|
|
2053 search: null,
|
|
|
2054 select: null
|
|
|
2055 },
|
|
|
2056
|
|
|
2057 requestIndex: 0,
|
|
|
2058 pending: 0,
|
|
|
2059
|
|
|
2060 _create: function() {
|
|
|
2061 // Some browsers only repeat keydown events, not keypress events,
|
|
|
2062 // so we use the suppressKeyPress flag to determine if we've already
|
|
|
2063 // handled the keydown event. #7269
|
|
|
2064 // Unfortunately the code for & in keypress is the same as the up arrow,
|
|
|
2065 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
|
|
|
2066 // events when we know the keydown event was used to modify the
|
|
|
2067 // search term. #7799
|
|
|
2068 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
|
|
|
2069 nodeName = this.element[0].nodeName.toLowerCase(),
|
|
|
2070 isTextarea = nodeName === "textarea",
|
|
|
2071 isInput = nodeName === "input";
|
|
|
2072
|
|
|
2073 this.isMultiLine =
|
|
|
2074 // Textareas are always multi-line
|
|
|
2075 isTextarea ? true :
|
|
|
2076 // Inputs are always single-line, even if inside a contentEditable element
|
|
|
2077 // IE also treats inputs as contentEditable
|
|
|
2078 isInput ? false :
|
|
|
2079 // All other element types are determined by whether or not they're contentEditable
|
|
|
2080 this.element.prop( "isContentEditable" );
|
|
|
2081
|
|
|
2082 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
|
|
|
2083 this.isNewMenu = true;
|
|
|
2084
|
|
|
2085 this.element
|
|
|
2086 .addClass( "ui-autocomplete-input" )
|
|
|
2087 .attr( "autocomplete", "off" );
|
|
|
2088
|
|
|
2089 this._on( this.element, {
|
|
|
2090 keydown: function( event ) {
|
|
|
2091 if ( this.element.prop( "readOnly" ) ) {
|
|
|
2092 suppressKeyPress = true;
|
|
|
2093 suppressInput = true;
|
|
|
2094 suppressKeyPressRepeat = true;
|
|
|
2095 return;
|
|
|
2096 }
|
|
|
2097
|
|
|
2098 suppressKeyPress = false;
|
|
|
2099 suppressInput = false;
|
|
|
2100 suppressKeyPressRepeat = false;
|
|
|
2101 var keyCode = $.ui.keyCode;
|
|
|
2102 switch( event.keyCode ) {
|
|
|
2103 case keyCode.PAGE_UP:
|
|
|
2104 suppressKeyPress = true;
|
|
|
2105 this._move( "previousPage", event );
|
|
|
2106 break;
|
|
|
2107 case keyCode.PAGE_DOWN:
|
|
|
2108 suppressKeyPress = true;
|
|
|
2109 this._move( "nextPage", event );
|
|
|
2110 break;
|
|
|
2111 case keyCode.UP:
|
|
|
2112 suppressKeyPress = true;
|
|
|
2113 this._keyEvent( "previous", event );
|
|
|
2114 break;
|
|
|
2115 case keyCode.DOWN:
|
|
|
2116 suppressKeyPress = true;
|
|
|
2117 this._keyEvent( "next", event );
|
|
|
2118 break;
|
|
|
2119 case keyCode.ENTER:
|
|
|
2120 case keyCode.NUMPAD_ENTER:
|
|
|
2121 // when menu is open and has focus
|
|
|
2122 if ( this.menu.active ) {
|
|
|
2123 // #6055 - Opera still allows the keypress to occur
|
|
|
2124 // which causes forms to submit
|
|
|
2125 suppressKeyPress = true;
|
|
|
2126 event.preventDefault();
|
|
|
2127 this.menu.select( event );
|
|
|
2128 }
|
|
|
2129 break;
|
|
|
2130 case keyCode.TAB:
|
|
|
2131 if ( this.menu.active ) {
|
|
|
2132 this.menu.select( event );
|
|
|
2133 }
|
|
|
2134 break;
|
|
|
2135 case keyCode.ESCAPE:
|
|
|
2136 if ( this.menu.element.is( ":visible" ) ) {
|
|
|
2137 this._value( this.term );
|
|
|
2138 this.close( event );
|
|
|
2139 // Different browsers have different default behavior for escape
|
|
|
2140 // Single press can mean undo or clear
|
|
|
2141 // Double press in IE means clear the whole form
|
|
|
2142 event.preventDefault();
|
|
|
2143 }
|
|
|
2144 break;
|
|
|
2145 default:
|
|
|
2146 suppressKeyPressRepeat = true;
|
|
|
2147 // search timeout should be triggered before the input value is changed
|
|
|
2148 this._searchTimeout( event );
|
|
|
2149 break;
|
|
|
2150 }
|
|
|
2151 },
|
|
|
2152 keypress: function( event ) {
|
|
|
2153 if ( suppressKeyPress ) {
|
|
|
2154 suppressKeyPress = false;
|
|
|
2155 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
|
|
|
2156 event.preventDefault();
|
|
|
2157 }
|
|
|
2158 return;
|
|
|
2159 }
|
|
|
2160 if ( suppressKeyPressRepeat ) {
|
|
|
2161 return;
|
|
|
2162 }
|
|
|
2163
|
|
|
2164 // replicate some key handlers to allow them to repeat in Firefox and Opera
|
|
|
2165 var keyCode = $.ui.keyCode;
|
|
|
2166 switch( event.keyCode ) {
|
|
|
2167 case keyCode.PAGE_UP:
|
|
|
2168 this._move( "previousPage", event );
|
|
|
2169 break;
|
|
|
2170 case keyCode.PAGE_DOWN:
|
|
|
2171 this._move( "nextPage", event );
|
|
|
2172 break;
|
|
|
2173 case keyCode.UP:
|
|
|
2174 this._keyEvent( "previous", event );
|
|
|
2175 break;
|
|
|
2176 case keyCode.DOWN:
|
|
|
2177 this._keyEvent( "next", event );
|
|
|
2178 break;
|
|
|
2179 }
|
|
|
2180 },
|
|
|
2181 input: function( event ) {
|
|
|
2182 if ( suppressInput ) {
|
|
|
2183 suppressInput = false;
|
|
|
2184 event.preventDefault();
|
|
|
2185 return;
|
|
|
2186 }
|
|
|
2187 this._searchTimeout( event );
|
|
|
2188 },
|
|
|
2189 focus: function() {
|
|
|
2190 this.selectedItem = null;
|
|
|
2191 this.previous = this._value();
|
|
|
2192 },
|
|
|
2193 blur: function( event ) {
|
|
|
2194 if ( this.cancelBlur ) {
|
|
|
2195 delete this.cancelBlur;
|
|
|
2196 return;
|
|
|
2197 }
|
|
|
2198
|
|
|
2199 clearTimeout( this.searching );
|
|
|
2200 this.close( event );
|
|
|
2201 this._change( event );
|
|
|
2202 }
|
|
|
2203 });
|
|
|
2204
|
|
|
2205 this._initSource();
|
|
|
2206 this.menu = $( "<ul>" )
|
|
|
2207 .addClass( "ui-autocomplete ui-front" )
|
|
|
2208 .appendTo( this._appendTo() )
|
|
|
2209 .menu({
|
|
|
2210 // disable ARIA support, the live region takes care of that
|
|
|
2211 role: null
|
|
|
2212 })
|
|
|
2213 .hide()
|
|
|
2214 .data( "ui-menu" );
|
|
|
2215
|
|
|
2216 this._on( this.menu.element, {
|
|
|
2217 mousedown: function( event ) {
|
|
|
2218 // prevent moving focus out of the text field
|
|
|
2219 event.preventDefault();
|
|
|
2220
|
|
|
2221 // IE doesn't prevent moving focus even with event.preventDefault()
|
|
|
2222 // so we set a flag to know when we should ignore the blur event
|
|
|
2223 this.cancelBlur = true;
|
|
|
2224 this._delay(function() {
|
|
|
2225 delete this.cancelBlur;
|
|
|
2226 });
|
|
|
2227
|
|
|
2228 // clicking on the scrollbar causes focus to shift to the body
|
|
|
2229 // but we can't detect a mouseup or a click immediately afterward
|
|
|
2230 // so we have to track the next mousedown and close the menu if
|
|
|
2231 // the user clicks somewhere outside of the autocomplete
|
|
|
2232 var menuElement = this.menu.element[ 0 ];
|
|
|
2233 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
|
|
|
2234 this._delay(function() {
|
|
|
2235 var that = this;
|
|
|
2236 this.document.one( "mousedown", function( event ) {
|
|
|
2237 if ( event.target !== that.element[ 0 ] &&
|
|
|
2238 event.target !== menuElement &&
|
|
|
2239 !$.contains( menuElement, event.target ) ) {
|
|
|
2240 that.close();
|
|
|
2241 }
|
|
|
2242 });
|
|
|
2243 });
|
|
|
2244 }
|
|
|
2245 },
|
|
|
2246 menufocus: function( event, ui ) {
|
|
|
2247 // support: Firefox
|
|
|
2248 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
|
|
|
2249 if ( this.isNewMenu ) {
|
|
|
2250 this.isNewMenu = false;
|
|
|
2251 if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
|
|
|
2252 this.menu.blur();
|
|
|
2253
|
|
|
2254 this.document.one( "mousemove", function() {
|
|
|
2255 $( event.target ).trigger( event.originalEvent );
|
|
|
2256 });
|
|
|
2257
|
|
|
2258 return;
|
|
|
2259 }
|
|
|
2260 }
|
|
|
2261
|
|
|
2262 var item = ui.item.data( "ui-autocomplete-item" );
|
|
|
2263 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
|
|
|
2264 // use value to match what will end up in the input, if it was a key event
|
|
|
2265 if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
|
|
|
2266 this._value( item.value );
|
|
|
2267 }
|
|
|
2268 } else {
|
|
|
2269 // Normally the input is populated with the item's value as the
|
|
|
2270 // menu is navigated, causing screen readers to notice a change and
|
|
|
2271 // announce the item. Since the focus event was canceled, this doesn't
|
|
|
2272 // happen, so we update the live region so that screen readers can
|
|
|
2273 // still notice the change and announce it.
|
|
|
2274 this.liveRegion.text( item.value );
|
|
|
2275 }
|
|
|
2276 },
|
|
|
2277 menuselect: function( event, ui ) {
|
|
|
2278 var item = ui.item.data( "ui-autocomplete-item" ),
|
|
|
2279 previous = this.previous;
|
|
|
2280
|
|
|
2281 // only trigger when focus was lost (click on menu)
|
|
|
2282 if ( this.element[0] !== this.document[0].activeElement ) {
|
|
|
2283 this.element.focus();
|
|
|
2284 this.previous = previous;
|
|
|
2285 // #6109 - IE triggers two focus events and the second
|
|
|
2286 // is asynchronous, so we need to reset the previous
|
|
|
2287 // term synchronously and asynchronously :-(
|
|
|
2288 this._delay(function() {
|
|
|
2289 this.previous = previous;
|
|
|
2290 this.selectedItem = item;
|
|
|
2291 });
|
|
|
2292 }
|
|
|
2293
|
|
|
2294 if ( false !== this._trigger( "select", event, { item: item } ) ) {
|
|
|
2295 this._value( item.value );
|
|
|
2296 }
|
|
|
2297 // reset the term after the select event
|
|
|
2298 // this allows custom select handling to work properly
|
|
|
2299 this.term = this._value();
|
|
|
2300
|
|
|
2301 this.close( event );
|
|
|
2302 this.selectedItem = item;
|
|
|
2303 }
|
|
|
2304 });
|
|
|
2305
|
|
|
2306 this.liveRegion = $( "<span>", {
|
|
|
2307 role: "status",
|
|
|
2308 "aria-live": "polite"
|
|
|
2309 })
|
|
|
2310 .addClass( "ui-helper-hidden-accessible" )
|
|
|
2311 .insertBefore( this.element );
|
|
|
2312
|
|
|
2313 // turning off autocomplete prevents the browser from remembering the
|
|
|
2314 // value when navigating through history, so we re-enable autocomplete
|
|
|
2315 // if the page is unloaded before the widget is destroyed. #7790
|
|
|
2316 this._on( this.window, {
|
|
|
2317 beforeunload: function() {
|
|
|
2318 this.element.removeAttr( "autocomplete" );
|
|
|
2319 }
|
|
|
2320 });
|
|
|
2321 },
|
|
|
2322
|
|
|
2323 _destroy: function() {
|
|
|
2324 clearTimeout( this.searching );
|
|
|
2325 this.element
|
|
|
2326 .removeClass( "ui-autocomplete-input" )
|
|
|
2327 .removeAttr( "autocomplete" );
|
|
|
2328 this.menu.element.remove();
|
|
|
2329 this.liveRegion.remove();
|
|
|
2330 },
|
|
|
2331
|
|
|
2332 _setOption: function( key, value ) {
|
|
|
2333 this._super( key, value );
|
|
|
2334 if ( key === "source" ) {
|
|
|
2335 this._initSource();
|
|
|
2336 }
|
|
|
2337 if ( key === "appendTo" ) {
|
|
|
2338 this.menu.element.appendTo( this._appendTo() );
|
|
|
2339 }
|
|
|
2340 if ( key === "disabled" && value && this.xhr ) {
|
|
|
2341 this.xhr.abort();
|
|
|
2342 }
|
|
|
2343 },
|
|
|
2344
|
|
|
2345 _appendTo: function() {
|
|
|
2346 var element = this.options.appendTo;
|
|
|
2347
|
|
|
2348 if ( element ) {
|
|
|
2349 element = element.jquery || element.nodeType ?
|
|
|
2350 $( element ) :
|
|
|
2351 this.document.find( element ).eq( 0 );
|
|
|
2352 }
|
|
|
2353
|
|
|
2354 if ( !element ) {
|
|
|
2355 element = this.element.closest( ".ui-front" );
|
|
|
2356 }
|
|
|
2357
|
|
|
2358 if ( !element.length ) {
|
|
|
2359 element = this.document[0].body;
|
|
|
2360 }
|
|
|
2361
|
|
|
2362 return element;
|
|
|
2363 },
|
|
|
2364
|
|
|
2365 _initSource: function() {
|
|
|
2366 var array, url,
|
|
|
2367 that = this;
|
|
|
2368 if ( $.isArray(this.options.source) ) {
|
|
|
2369 array = this.options.source;
|
|
|
2370 this.source = function( request, response ) {
|
|
|
2371 response( $.ui.autocomplete.filter( array, request.term ) );
|
|
|
2372 };
|
|
|
2373 } else if ( typeof this.options.source === "string" ) {
|
|
|
2374 url = this.options.source;
|
|
|
2375 this.source = function( request, response ) {
|
|
|
2376 if ( that.xhr ) {
|
|
|
2377 that.xhr.abort();
|
|
|
2378 }
|
|
|
2379 that.xhr = $.ajax({
|
|
|
2380 url: url,
|
|
|
2381 data: request,
|
|
|
2382 dataType: "json",
|
|
|
2383 success: function( data ) {
|
|
|
2384 response( data );
|
|
|
2385 },
|
|
|
2386 error: function() {
|
|
|
2387 response( [] );
|
|
|
2388 }
|
|
|
2389 });
|
|
|
2390 };
|
|
|
2391 } else {
|
|
|
2392 this.source = this.options.source;
|
|
|
2393 }
|
|
|
2394 },
|
|
|
2395
|
|
|
2396 _searchTimeout: function( event ) {
|
|
|
2397 clearTimeout( this.searching );
|
|
|
2398 this.searching = this._delay(function() {
|
|
|
2399 // only search if the value has changed
|
|
|
2400 if ( this.term !== this._value() ) {
|
|
|
2401 this.selectedItem = null;
|
|
|
2402 this.search( null, event );
|
|
|
2403 }
|
|
|
2404 }, this.options.delay );
|
|
|
2405 },
|
|
|
2406
|
|
|
2407 search: function( value, event ) {
|
|
|
2408 value = value != null ? value : this._value();
|
|
|
2409
|
|
|
2410 // always save the actual value, not the one passed as an argument
|
|
|
2411 this.term = this._value();
|
|
|
2412
|
|
|
2413 if ( value.length < this.options.minLength ) {
|
|
|
2414 return this.close( event );
|
|
|
2415 }
|
|
|
2416
|
|
|
2417 if ( this._trigger( "search", event ) === false ) {
|
|
|
2418 return;
|
|
|
2419 }
|
|
|
2420
|
|
|
2421 return this._search( value );
|
|
|
2422 },
|
|
|
2423
|
|
|
2424 _search: function( value ) {
|
|
|
2425 this.pending++;
|
|
|
2426 this.element.addClass( "ui-autocomplete-loading" );
|
|
|
2427 this.cancelSearch = false;
|
|
|
2428
|
|
|
2429 this.source( { term: value }, this._response() );
|
|
|
2430 },
|
|
|
2431
|
|
|
2432 _response: function() {
|
|
|
2433 var index = ++this.requestIndex;
|
|
|
2434
|
|
|
2435 return $.proxy(function( content ) {
|
|
|
2436 if ( index === this.requestIndex ) {
|
|
|
2437 this.__response( content );
|
|
|
2438 }
|
|
|
2439
|
|
|
2440 this.pending--;
|
|
|
2441 if ( !this.pending ) {
|
|
|
2442 this.element.removeClass( "ui-autocomplete-loading" );
|
|
|
2443 }
|
|
|
2444 }, this );
|
|
|
2445 },
|
|
|
2446
|
|
|
2447 __response: function( content ) {
|
|
|
2448 if ( content ) {
|
|
|
2449 content = this._normalize( content );
|
|
|
2450 }
|
|
|
2451 this._trigger( "response", null, { content: content } );
|
|
|
2452 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
|
|
|
2453 this._suggest( content );
|
|
|
2454 this._trigger( "open" );
|
|
|
2455 } else {
|
|
|
2456 // use ._close() instead of .close() so we don't cancel future searches
|
|
|
2457 this._close();
|
|
|
2458 }
|
|
|
2459 },
|
|
|
2460
|
|
|
2461 close: function( event ) {
|
|
|
2462 this.cancelSearch = true;
|
|
|
2463 this._close( event );
|
|
|
2464 },
|
|
|
2465
|
|
|
2466 _close: function( event ) {
|
|
|
2467 if ( this.menu.element.is( ":visible" ) ) {
|
|
|
2468 this.menu.element.hide();
|
|
|
2469 this.menu.blur();
|
|
|
2470 this.isNewMenu = true;
|
|
|
2471 this._trigger( "close", event );
|
|
|
2472 }
|
|
|
2473 },
|
|
|
2474
|
|
|
2475 _change: function( event ) {
|
|
|
2476 if ( this.previous !== this._value() ) {
|
|
|
2477 this._trigger( "change", event, { item: this.selectedItem } );
|
|
|
2478 }
|
|
|
2479 },
|
|
|
2480
|
|
|
2481 _normalize: function( items ) {
|
|
|
2482 // assume all items have the right format when the first item is complete
|
|
|
2483 if ( items.length && items[0].label && items[0].value ) {
|
|
|
2484 return items;
|
|
|
2485 }
|
|
|
2486 return $.map( items, function( item ) {
|
|
|
2487 if ( typeof item === "string" ) {
|
|
|
2488 return {
|
|
|
2489 label: item,
|
|
|
2490 value: item
|
|
|
2491 };
|
|
|
2492 }
|
|
|
2493 return $.extend({
|
|
|
2494 label: item.label || item.value,
|
|
|
2495 value: item.value || item.label
|
|
|
2496 }, item );
|
|
|
2497 });
|
|
|
2498 },
|
|
|
2499
|
|
|
2500 _suggest: function( items ) {
|
|
|
2501 var ul = this.menu.element.empty();
|
|
|
2502 this._renderMenu( ul, items );
|
|
|
2503 this.isNewMenu = true;
|
|
|
2504 this.menu.refresh();
|
|
|
2505
|
|
|
2506 // size and position menu
|
|
|
2507 ul.show();
|
|
|
2508 this._resizeMenu();
|
|
|
2509 ul.position( $.extend({
|
|
|
2510 of: this.element
|
|
|
2511 }, this.options.position ));
|
|
|
2512
|
|
|
2513 if ( this.options.autoFocus ) {
|
|
|
2514 this.menu.next();
|
|
|
2515 }
|
|
|
2516 },
|
|
|
2517
|
|
|
2518 _resizeMenu: function() {
|
|
|
2519 var ul = this.menu.element;
|
|
|
2520 ul.outerWidth( Math.max(
|
|
|
2521 // Firefox wraps long text (possibly a rounding bug)
|
|
|
2522 // so we add 1px to avoid the wrapping (#7513)
|
|
|
2523 ul.width( "" ).outerWidth() + 1,
|
|
|
2524 this.element.outerWidth()
|
|
|
2525 ) );
|
|
|
2526 },
|
|
|
2527
|
|
|
2528 _renderMenu: function( ul, items ) {
|
|
|
2529 var that = this;
|
|
|
2530 $.each( items, function( index, item ) {
|
|
|
2531 that._renderItemData( ul, item );
|
|
|
2532 });
|
|
|
2533 },
|
|
|
2534
|
|
|
2535 _renderItemData: function( ul, item ) {
|
|
|
2536 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
|
|
|
2537 },
|
|
|
2538
|
|
|
2539 _renderItem: function( ul, item ) {
|
|
|
2540 return $( "<li>" )
|
|
|
2541 .append( $( "<a>" ).text( item.label ) )
|
|
|
2542 .appendTo( ul );
|
|
|
2543 },
|
|
|
2544
|
|
|
2545 _move: function( direction, event ) {
|
|
|
2546 if ( !this.menu.element.is( ":visible" ) ) {
|
|
|
2547 this.search( null, event );
|
|
|
2548 return;
|
|
|
2549 }
|
|
|
2550 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
|
|
|
2551 this.menu.isLastItem() && /^next/.test( direction ) ) {
|
|
|
2552 this._value( this.term );
|
|
|
2553 this.menu.blur();
|
|
|
2554 return;
|
|
|
2555 }
|
|
|
2556 this.menu[ direction ]( event );
|
|
|
2557 },
|
|
|
2558
|
|
|
2559 widget: function() {
|
|
|
2560 return this.menu.element;
|
|
|
2561 },
|
|
|
2562
|
|
|
2563 _value: function() {
|
|
|
2564 return this.valueMethod.apply( this.element, arguments );
|
|
|
2565 },
|
|
|
2566
|
|
|
2567 _keyEvent: function( keyEvent, event ) {
|
|
|
2568 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
|
|
|
2569 this._move( keyEvent, event );
|
|
|
2570
|
|
|
2571 // prevents moving cursor to beginning/end of the text field in some browsers
|
|
|
2572 event.preventDefault();
|
|
|
2573 }
|
|
|
2574 }
|
|
|
2575 });
|
|
|
2576
|
|
|
2577 $.extend( $.ui.autocomplete, {
|
|
|
2578 escapeRegex: function( value ) {
|
|
|
2579 return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
|
|
|
2580 },
|
|
|
2581 filter: function(array, term) {
|
|
|
2582 var matcher = new RegExp( $.ui.autocomplete.escapeRegex(term), "i" );
|
|
|
2583 return $.grep( array, function(value) {
|
|
|
2584 return matcher.test( value.label || value.value || value );
|
|
|
2585 });
|
|
|
2586 }
|
|
|
2587 });
|
|
|
2588
|
|
|
2589
|
|
|
2590 // live region extension, adding a `messages` option
|
|
|
2591 // NOTE: This is an experimental API. We are still investigating
|
|
|
2592 // a full solution for string manipulation and internationalization.
|
|
|
2593 $.widget( "ui.autocomplete", $.ui.autocomplete, {
|
|
|
2594 options: {
|
|
|
2595 messages: {
|
|
|
2596 noResults: "No search results.",
|
|
|
2597 results: function( amount ) {
|
|
|
2598 return amount + ( amount > 1 ? " results are" : " result is" ) +
|
|
|
2599 " available, use up and down arrow keys to navigate.";
|
|
|
2600 }
|
|
|
2601 }
|
|
|
2602 },
|
|
|
2603
|
|
|
2604 __response: function( content ) {
|
|
|
2605 var message;
|
|
|
2606 this._superApply( arguments );
|
|
|
2607 if ( this.options.disabled || this.cancelSearch ) {
|
|
|
2608 return;
|
|
|
2609 }
|
|
|
2610 if ( content && content.length ) {
|
|
|
2611 message = this.options.messages.results( content.length );
|
|
|
2612 } else {
|
|
|
2613 message = this.options.messages.noResults;
|
|
|
2614 }
|
|
|
2615 this.liveRegion.text( message );
|
|
|
2616 }
|
|
|
2617 });
|
|
|
2618
|
|
|
2619 }( jQuery ));
|
|
|
2620 (function( $, undefined ) {
|
|
|
2621
|
|
|
2622 var lastActive,
|
|
|
2623 baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
|
|
|
2624 typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
|
|
|
2625 formResetHandler = function() {
|
|
|
2626 var form = $( this );
|
|
|
2627 setTimeout(function() {
|
|
|
2628 form.find( ":ui-button" ).button( "refresh" );
|
|
|
2629 }, 1 );
|
|
|
2630 },
|
|
|
2631 radioGroup = function( radio ) {
|
|
|
2632 var name = radio.name,
|
|
|
2633 form = radio.form,
|
|
|
2634 radios = $( [] );
|
|
|
2635 if ( name ) {
|
|
|
2636 name = name.replace( /'/g, "\\'" );
|
|
|
2637 if ( form ) {
|
|
|
2638 radios = $( form ).find( "[name='" + name + "']" );
|
|
|
2639 } else {
|
|
|
2640 radios = $( "[name='" + name + "']", radio.ownerDocument )
|
|
|
2641 .filter(function() {
|
|
|
2642 return !this.form;
|
|
|
2643 });
|
|
|
2644 }
|
|
|
2645 }
|
|
|
2646 return radios;
|
|
|
2647 };
|
|
|
2648
|
|
|
2649 $.widget( "ui.button", {
|
|
|
2650 version: "1.10.4",
|
|
|
2651 defaultElement: "<button>",
|
|
|
2652 options: {
|
|
|
2653 disabled: null,
|
|
|
2654 text: true,
|
|
|
2655 label: null,
|
|
|
2656 icons: {
|
|
|
2657 primary: null,
|
|
|
2658 secondary: null
|
|
|
2659 }
|
|
|
2660 },
|
|
|
2661 _create: function() {
|
|
|
2662 this.element.closest( "form" )
|
|
|
2663 .unbind( "reset" + this.eventNamespace )
|
|
|
2664 .bind( "reset" + this.eventNamespace, formResetHandler );
|
|
|
2665
|
|
|
2666 if ( typeof this.options.disabled !== "boolean" ) {
|
|
|
2667 this.options.disabled = !!this.element.prop( "disabled" );
|
|
|
2668 } else {
|
|
|
2669 this.element.prop( "disabled", this.options.disabled );
|
|
|
2670 }
|
|
|
2671
|
|
|
2672 this._determineButtonType();
|
|
|
2673 this.hasTitle = !!this.buttonElement.attr( "title" );
|
|
|
2674
|
|
|
2675 var that = this,
|
|
|
2676 options = this.options,
|
|
|
2677 toggleButton = this.type === "checkbox" || this.type === "radio",
|
|
|
2678 activeClass = !toggleButton ? "ui-state-active" : "";
|
|
|
2679
|
|
|
2680 if ( options.label === null ) {
|
|
|
2681 options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
|
|
|
2682 }
|
|
|
2683
|
|
|
2684 this._hoverable( this.buttonElement );
|
|
|
2685
|
|
|
2686 this.buttonElement
|
|
|
2687 .addClass( baseClasses )
|
|
|
2688 .attr( "role", "button" )
|
|
|
2689 .bind( "mouseenter" + this.eventNamespace, function() {
|
|
|
2690 if ( options.disabled ) {
|
|
|
2691 return;
|
|
|
2692 }
|
|
|
2693 if ( this === lastActive ) {
|
|
|
2694 $( this ).addClass( "ui-state-active" );
|
|
|
2695 }
|
|
|
2696 })
|
|
|
2697 .bind( "mouseleave" + this.eventNamespace, function() {
|
|
|
2698 if ( options.disabled ) {
|
|
|
2699 return;
|
|
|
2700 }
|
|
|
2701 $( this ).removeClass( activeClass );
|
|
|
2702 })
|
|
|
2703 .bind( "click" + this.eventNamespace, function( event ) {
|
|
|
2704 if ( options.disabled ) {
|
|
|
2705 event.preventDefault();
|
|
|
2706 event.stopImmediatePropagation();
|
|
|
2707 }
|
|
|
2708 });
|
|
|
2709
|
|
|
2710 // Can't use _focusable() because the element that receives focus
|
|
|
2711 // and the element that gets the ui-state-focus class are different
|
|
|
2712 this._on({
|
|
|
2713 focus: function() {
|
|
|
2714 this.buttonElement.addClass( "ui-state-focus" );
|
|
|
2715 },
|
|
|
2716 blur: function() {
|
|
|
2717 this.buttonElement.removeClass( "ui-state-focus" );
|
|
|
2718 }
|
|
|
2719 });
|
|
|
2720
|
|
|
2721 if ( toggleButton ) {
|
|
|
2722 this.element.bind( "change" + this.eventNamespace, function() {
|
|
|
2723 that.refresh();
|
|
|
2724 });
|
|
|
2725 }
|
|
|
2726
|
|
|
2727 if ( this.type === "checkbox" ) {
|
|
|
2728 this.buttonElement.bind( "click" + this.eventNamespace, function() {
|
|
|
2729 if ( options.disabled ) {
|
|
|
2730 return false;
|
|
|
2731 }
|
|
|
2732 });
|
|
|
2733 } else if ( this.type === "radio" ) {
|
|
|
2734 this.buttonElement.bind( "click" + this.eventNamespace, function() {
|
|
|
2735 if ( options.disabled ) {
|
|
|
2736 return false;
|
|
|
2737 }
|
|
|
2738 $( this ).addClass( "ui-state-active" );
|
|
|
2739 that.buttonElement.attr( "aria-pressed", "true" );
|
|
|
2740
|
|
|
2741 var radio = that.element[ 0 ];
|
|
|
2742 radioGroup( radio )
|
|
|
2743 .not( radio )
|
|
|
2744 .map(function() {
|
|
|
2745 return $( this ).button( "widget" )[ 0 ];
|
|
|
2746 })
|
|
|
2747 .removeClass( "ui-state-active" )
|
|
|
2748 .attr( "aria-pressed", "false" );
|
|
|
2749 });
|
|
|
2750 } else {
|
|
|
2751 this.buttonElement
|
|
|
2752 .bind( "mousedown" + this.eventNamespace, function() {
|
|
|
2753 if ( options.disabled ) {
|
|
|
2754 return false;
|
|
|
2755 }
|
|
|
2756 $( this ).addClass( "ui-state-active" );
|
|
|
2757 lastActive = this;
|
|
|
2758 that.document.one( "mouseup", function() {
|
|
|
2759 lastActive = null;
|
|
|
2760 });
|
|
|
2761 })
|
|
|
2762 .bind( "mouseup" + this.eventNamespace, function() {
|
|
|
2763 if ( options.disabled ) {
|
|
|
2764 return false;
|
|
|
2765 }
|
|
|
2766 $( this ).removeClass( "ui-state-active" );
|
|
|
2767 })
|
|
|
2768 .bind( "keydown" + this.eventNamespace, function(event) {
|
|
|
2769 if ( options.disabled ) {
|
|
|
2770 return false;
|
|
|
2771 }
|
|
|
2772 if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
|
|
|
2773 $( this ).addClass( "ui-state-active" );
|
|
|
2774 }
|
|
|
2775 })
|
|
|
2776 // see #8559, we bind to blur here in case the button element loses
|
|
|
2777 // focus between keydown and keyup, it would be left in an "active" state
|
|
|
2778 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
|
|
|
2779 $( this ).removeClass( "ui-state-active" );
|
|
|
2780 });
|
|
|
2781
|
|
|
2782 if ( this.buttonElement.is("a") ) {
|
|
|
2783 this.buttonElement.keyup(function(event) {
|
|
|
2784 if ( event.keyCode === $.ui.keyCode.SPACE ) {
|
|
|
2785 // TODO pass through original event correctly (just as 2nd argument doesn't work)
|
|
|
2786 $( this ).click();
|
|
|
2787 }
|
|
|
2788 });
|
|
|
2789 }
|
|
|
2790 }
|
|
|
2791
|
|
|
2792 // TODO: pull out $.Widget's handling for the disabled option into
|
|
|
2793 // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
|
|
|
2794 // be overridden by individual plugins
|
|
|
2795 this._setOption( "disabled", options.disabled );
|
|
|
2796 this._resetButton();
|
|
|
2797 },
|
|
|
2798
|
|
|
2799 _determineButtonType: function() {
|
|
|
2800 var ancestor, labelSelector, checked;
|
|
|
2801
|
|
|
2802 if ( this.element.is("[type=checkbox]") ) {
|
|
|
2803 this.type = "checkbox";
|
|
|
2804 } else if ( this.element.is("[type=radio]") ) {
|
|
|
2805 this.type = "radio";
|
|
|
2806 } else if ( this.element.is("input") ) {
|
|
|
2807 this.type = "input";
|
|
|
2808 } else {
|
|
|
2809 this.type = "button";
|
|
|
2810 }
|
|
|
2811
|
|
|
2812 if ( this.type === "checkbox" || this.type === "radio" ) {
|
|
|
2813 // we don't search against the document in case the element
|
|
|
2814 // is disconnected from the DOM
|
|
|
2815 ancestor = this.element.parents().last();
|
|
|
2816 labelSelector = "label[for='" + this.element.attr("id") + "']";
|
|
|
2817 this.buttonElement = ancestor.find( labelSelector );
|
|
|
2818 if ( !this.buttonElement.length ) {
|
|
|
2819 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
|
|
|
2820 this.buttonElement = ancestor.filter( labelSelector );
|
|
|
2821 if ( !this.buttonElement.length ) {
|
|
|
2822 this.buttonElement = ancestor.find( labelSelector );
|
|
|
2823 }
|
|
|
2824 }
|
|
|
2825 this.element.addClass( "ui-helper-hidden-accessible" );
|
|
|
2826
|
|
|
2827 checked = this.element.is( ":checked" );
|
|
|
2828 if ( checked ) {
|
|
|
2829 this.buttonElement.addClass( "ui-state-active" );
|
|
|
2830 }
|
|
|
2831 this.buttonElement.prop( "aria-pressed", checked );
|
|
|
2832 } else {
|
|
|
2833 this.buttonElement = this.element;
|
|
|
2834 }
|
|
|
2835 },
|
|
|
2836
|
|
|
2837 widget: function() {
|
|
|
2838 return this.buttonElement;
|
|
|
2839 },
|
|
|
2840
|
|
|
2841 _destroy: function() {
|
|
|
2842 this.element
|
|
|
2843 .removeClass( "ui-helper-hidden-accessible" );
|
|
|
2844 this.buttonElement
|
|
|
2845 .removeClass( baseClasses + " ui-state-active " + typeClasses )
|
|
|
2846 .removeAttr( "role" )
|
|
|
2847 .removeAttr( "aria-pressed" )
|
|
|
2848 .html( this.buttonElement.find(".ui-button-text").html() );
|
|
|
2849
|
|
|
2850 if ( !this.hasTitle ) {
|
|
|
2851 this.buttonElement.removeAttr( "title" );
|
|
|
2852 }
|
|
|
2853 },
|
|
|
2854
|
|
|
2855 _setOption: function( key, value ) {
|
|
|
2856 this._super( key, value );
|
|
|
2857 if ( key === "disabled" ) {
|
|
|
2858 this.element.prop( "disabled", !!value );
|
|
|
2859 if ( value ) {
|
|
|
2860 this.buttonElement.removeClass( "ui-state-focus" );
|
|
|
2861 }
|
|
|
2862 return;
|
|
|
2863 }
|
|
|
2864 this._resetButton();
|
|
|
2865 },
|
|
|
2866
|
|
|
2867 refresh: function() {
|
|
|
2868 //See #8237 & #8828
|
|
|
2869 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
|
|
|
2870
|
|
|
2871 if ( isDisabled !== this.options.disabled ) {
|
|
|
2872 this._setOption( "disabled", isDisabled );
|
|
|
2873 }
|
|
|
2874 if ( this.type === "radio" ) {
|
|
|
2875 radioGroup( this.element[0] ).each(function() {
|
|
|
2876 if ( $( this ).is( ":checked" ) ) {
|
|
|
2877 $( this ).button( "widget" )
|
|
|
2878 .addClass( "ui-state-active" )
|
|
|
2879 .attr( "aria-pressed", "true" );
|
|
|
2880 } else {
|
|
|
2881 $( this ).button( "widget" )
|
|
|
2882 .removeClass( "ui-state-active" )
|
|
|
2883 .attr( "aria-pressed", "false" );
|
|
|
2884 }
|
|
|
2885 });
|
|
|
2886 } else if ( this.type === "checkbox" ) {
|
|
|
2887 if ( this.element.is( ":checked" ) ) {
|
|
|
2888 this.buttonElement
|
|
|
2889 .addClass( "ui-state-active" )
|
|
|
2890 .attr( "aria-pressed", "true" );
|
|
|
2891 } else {
|
|
|
2892 this.buttonElement
|
|
|
2893 .removeClass( "ui-state-active" )
|
|
|
2894 .attr( "aria-pressed", "false" );
|
|
|
2895 }
|
|
|
2896 }
|
|
|
2897 },
|
|
|
2898
|
|
|
2899 _resetButton: function() {
|
|
|
2900 if ( this.type === "input" ) {
|
|
|
2901 if ( this.options.label ) {
|
|
|
2902 this.element.val( this.options.label );
|
|
|
2903 }
|
|
|
2904 return;
|
|
|
2905 }
|
|
|
2906 var buttonElement = this.buttonElement.removeClass( typeClasses ),
|
|
|
2907 buttonText = $( "<span></span>", this.document[0] )
|
|
|
2908 .addClass( "ui-button-text" )
|
|
|
2909 .html( this.options.label )
|
|
|
2910 .appendTo( buttonElement.empty() )
|
|
|
2911 .text(),
|
|
|
2912 icons = this.options.icons,
|
|
|
2913 multipleIcons = icons.primary && icons.secondary,
|
|
|
2914 buttonClasses = [];
|
|
|
2915
|
|
|
2916 if ( icons.primary || icons.secondary ) {
|
|
|
2917 if ( this.options.text ) {
|
|
|
2918 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
|
|
|
2919 }
|
|
|
2920
|
|
|
2921 if ( icons.primary ) {
|
|
|
2922 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
|
|
|
2923 }
|
|
|
2924
|
|
|
2925 if ( icons.secondary ) {
|
|
|
2926 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
|
|
|
2927 }
|
|
|
2928
|
|
|
2929 if ( !this.options.text ) {
|
|
|
2930 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
|
|
|
2931
|
|
|
2932 if ( !this.hasTitle ) {
|
|
|
2933 buttonElement.attr( "title", $.trim( buttonText ) );
|
|
|
2934 }
|
|
|
2935 }
|
|
|
2936 } else {
|
|
|
2937 buttonClasses.push( "ui-button-text-only" );
|
|
|
2938 }
|
|
|
2939 buttonElement.addClass( buttonClasses.join( " " ) );
|
|
|
2940 }
|
|
|
2941 });
|
|
|
2942
|
|
|
2943 $.widget( "ui.buttonset", {
|
|
|
2944 version: "1.10.4",
|
|
|
2945 options: {
|
|
|
2946 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
|
|
|
2947 },
|
|
|
2948
|
|
|
2949 _create: function() {
|
|
|
2950 this.element.addClass( "ui-buttonset" );
|
|
|
2951 },
|
|
|
2952
|
|
|
2953 _init: function() {
|
|
|
2954 this.refresh();
|
|
|
2955 },
|
|
|
2956
|
|
|
2957 _setOption: function( key, value ) {
|
|
|
2958 if ( key === "disabled" ) {
|
|
|
2959 this.buttons.button( "option", key, value );
|
|
|
2960 }
|
|
|
2961
|
|
|
2962 this._super( key, value );
|
|
|
2963 },
|
|
|
2964
|
|
|
2965 refresh: function() {
|
|
|
2966 var rtl = this.element.css( "direction" ) === "rtl";
|
|
|
2967
|
|
|
2968 this.buttons = this.element.find( this.options.items )
|
|
|
2969 .filter( ":ui-button" )
|
|
|
2970 .button( "refresh" )
|
|
|
2971 .end()
|
|
|
2972 .not( ":ui-button" )
|
|
|
2973 .button()
|
|
|
2974 .end()
|
|
|
2975 .map(function() {
|
|
|
2976 return $( this ).button( "widget" )[ 0 ];
|
|
|
2977 })
|
|
|
2978 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
|
|
|
2979 .filter( ":first" )
|
|
|
2980 .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
|
|
|
2981 .end()
|
|
|
2982 .filter( ":last" )
|
|
|
2983 .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
|
|
|
2984 .end()
|
|
|
2985 .end();
|
|
|
2986 },
|
|
|
2987
|
|
|
2988 _destroy: function() {
|
|
|
2989 this.element.removeClass( "ui-buttonset" );
|
|
|
2990 this.buttons
|
|
|
2991 .map(function() {
|
|
|
2992 return $( this ).button( "widget" )[ 0 ];
|
|
|
2993 })
|
|
|
2994 .removeClass( "ui-corner-left ui-corner-right" )
|
|
|
2995 .end()
|
|
|
2996 .button( "destroy" );
|
|
|
2997 }
|
|
|
2998 });
|
|
|
2999
|
|
|
3000 }( jQuery ) );
|
|
|
3001 (function( $, undefined ) {
|
|
|
3002
|
|
|
3003 $.extend($.ui, { datepicker: { version: "1.10.4" } });
|
|
|
3004
|
|
|
3005 var PROP_NAME = "datepicker",
|
|
|
3006 instActive;
|
|
|
3007
|
|
|
3008 /* Date picker manager.
|
|
|
3009 Use the singleton instance of this class, $.datepicker, to interact with the date picker.
|
|
|
3010 Settings for (groups of) date pickers are maintained in an instance object,
|
|
|
3011 allowing multiple different settings on the same page. */
|
|
|
3012
|
|
|
3013 function Datepicker() {
|
|
|
3014 this._curInst = null; // The current instance in use
|
|
|
3015 this._keyEvent = false; // If the last event was a key event
|
|
|
3016 this._disabledInputs = []; // List of date picker inputs that have been disabled
|
|
|
3017 this._datepickerShowing = false; // True if the popup picker is showing , false if not
|
|
|
3018 this._inDialog = false; // True if showing within a "dialog", false if not
|
|
|
3019 this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
|
|
|
3020 this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
|
|
|
3021 this._appendClass = "ui-datepicker-append"; // The name of the append marker class
|
|
|
3022 this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
|
|
|
3023 this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
|
|
|
3024 this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
|
|
|
3025 this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
|
|
|
3026 this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
|
|
|
3027 this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
|
|
|
3028 this.regional = []; // Available regional settings, indexed by language code
|
|
|
3029 this.regional[""] = { // Default regional settings
|
|
|
3030 closeText: "Done", // Display text for close link
|
|
|
3031 prevText: "Prev", // Display text for previous month link
|
|
|
3032 nextText: "Next", // Display text for next month link
|
|
|
3033 currentText: "Today", // Display text for current month link
|
|
|
3034 monthNames: ["January","February","March","April","May","June",
|
|
|
3035 "July","August","September","October","November","December"], // Names of months for drop-down and formatting
|
|
|
3036 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
|
|
|
3037 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
|
|
|
3038 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
|
|
|
3039 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
|
|
|
3040 weekHeader: "Wk", // Column header for week of the year
|
|
|
3041 dateFormat: "mm/dd/yy", // See format options on parseDate
|
|
|
3042 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
|
|
|
3043 isRTL: false, // True if right-to-left language, false if left-to-right
|
|
|
3044 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
|
|
|
3045 yearSuffix: "" // Additional text to append to the year in the month headers
|
|
|
3046 };
|
|
|
3047 this._defaults = { // Global defaults for all the date picker instances
|
|
|
3048 showOn: "focus", // "focus" for popup on focus,
|
|
|
3049 // "button" for trigger button, or "both" for either
|
|
|
3050 showAnim: "fadeIn", // Name of jQuery animation for popup
|
|
|
3051 showOptions: {}, // Options for enhanced animations
|
|
|
3052 defaultDate: null, // Used when field is blank: actual date,
|
|
|
3053 // +/-number for offset from today, null for today
|
|
|
3054 appendText: "", // Display text following the input box, e.g. showing the format
|
|
|
3055 buttonText: "...", // Text for trigger button
|
|
|
3056 buttonImage: "", // URL for trigger button image
|
|
|
3057 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
|
|
|
3058 hideIfNoPrevNext: false, // True to hide next/previous month links
|
|
|
3059 // if not applicable, false to just disable them
|
|
|
3060 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
|
|
|
3061 gotoCurrent: false, // True if today link goes back to current selection instead
|
|
|
3062 changeMonth: false, // True if month can be selected directly, false if only prev/next
|
|
|
3063 changeYear: false, // True if year can be selected directly, false if only prev/next
|
|
|
3064 yearRange: "c-10:c+10", // Range of years to display in drop-down,
|
|
|
3065 // either relative to today's year (-nn:+nn), relative to currently displayed year
|
|
|
3066 // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
|
|
|
3067 showOtherMonths: false, // True to show dates in other months, false to leave blank
|
|
|
3068 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
|
|
|
3069 showWeek: false, // True to show week of the year, false to not show it
|
|
|
3070 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
|
|
|
3071 // takes a Date and returns the number of the week for it
|
|
|
3072 shortYearCutoff: "+10", // Short year values < this are in the current century,
|
|
|
3073 // > this are in the previous century,
|
|
|
3074 // string value starting with "+" for current year + value
|
|
|
3075 minDate: null, // The earliest selectable date, or null for no limit
|
|
|
3076 maxDate: null, // The latest selectable date, or null for no limit
|
|
|
3077 duration: "fast", // Duration of display/closure
|
|
|
3078 beforeShowDay: null, // Function that takes a date and returns an array with
|
|
|
3079 // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
|
|
|
3080 // [2] = cell title (optional), e.g. $.datepicker.noWeekends
|
|
|
3081 beforeShow: null, // Function that takes an input field and
|
|
|
3082 // returns a set of custom settings for the date picker
|
|
|
3083 onSelect: null, // Define a callback function when a date is selected
|
|
|
3084 onChangeMonthYear: null, // Define a callback function when the month or year is changed
|
|
|
3085 onClose: null, // Define a callback function when the datepicker is closed
|
|
|
3086 numberOfMonths: 1, // Number of months to show at a time
|
|
|
3087 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
|
|
|
3088 stepMonths: 1, // Number of months to step back/forward
|
|
|
3089 stepBigMonths: 12, // Number of months to step back/forward for the big links
|
|
|
3090 altField: "", // Selector for an alternate field to store selected dates into
|
|
|
3091 altFormat: "", // The date format to use for the alternate field
|
|
|
3092 constrainInput: true, // The input is constrained by the current date format
|
|
|
3093 showButtonPanel: false, // True to show button panel, false to not show it
|
|
|
3094 autoSize: false, // True to size the input for the date format, false to leave as is
|
|
|
3095 disabled: false // The initial disabled state
|
|
|
3096 };
|
|
|
3097 $.extend(this._defaults, this.regional[""]);
|
|
|
3098 this.dpDiv = bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
|
|
|
3099 }
|
|
|
3100
|
|
|
3101 $.extend(Datepicker.prototype, {
|
|
|
3102 /* Class name added to elements to indicate already configured with a date picker. */
|
|
|
3103 markerClassName: "hasDatepicker",
|
|
|
3104
|
|
|
3105 //Keep track of the maximum number of rows displayed (see #7043)
|
|
|
3106 maxRows: 4,
|
|
|
3107
|
|
|
3108 // TODO rename to "widget" when switching to widget factory
|
|
|
3109 _widgetDatepicker: function() {
|
|
|
3110 return this.dpDiv;
|
|
|
3111 },
|
|
|
3112
|
|
|
3113 /* Override the default settings for all instances of the date picker.
|
|
|
3114 * @param settings object - the new settings to use as defaults (anonymous object)
|
|
|
3115 * @return the manager object
|
|
|
3116 */
|
|
|
3117 setDefaults: function(settings) {
|
|
|
3118 extendRemove(this._defaults, settings || {});
|
|
|
3119 return this;
|
|
|
3120 },
|
|
|
3121
|
|
|
3122 /* Attach the date picker to a jQuery selection.
|
|
|
3123 * @param target element - the target input field or division or span
|
|
|
3124 * @param settings object - the new settings to use for this date picker instance (anonymous)
|
|
|
3125 */
|
|
|
3126 _attachDatepicker: function(target, settings) {
|
|
|
3127 var nodeName, inline, inst;
|
|
|
3128 nodeName = target.nodeName.toLowerCase();
|
|
|
3129 inline = (nodeName === "div" || nodeName === "span");
|
|
|
3130 if (!target.id) {
|
|
|
3131 this.uuid += 1;
|
|
|
3132 target.id = "dp" + this.uuid;
|
|
|
3133 }
|
|
|
3134 inst = this._newInst($(target), inline);
|
|
|
3135 inst.settings = $.extend({}, settings || {});
|
|
|
3136 if (nodeName === "input") {
|
|
|
3137 this._connectDatepicker(target, inst);
|
|
|
3138 } else if (inline) {
|
|
|
3139 this._inlineDatepicker(target, inst);
|
|
|
3140 }
|
|
|
3141 },
|
|
|
3142
|
|
|
3143 /* Create a new instance object. */
|
|
|
3144 _newInst: function(target, inline) {
|
|
|
3145 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
|
|
|
3146 return {id: id, input: target, // associated target
|
|
|
3147 selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
|
|
|
3148 drawMonth: 0, drawYear: 0, // month being drawn
|
|
|
3149 inline: inline, // is datepicker inline or not
|
|
|
3150 dpDiv: (!inline ? this.dpDiv : // presentation div
|
|
|
3151 bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
|
|
|
3152 },
|
|
|
3153
|
|
|
3154 /* Attach the date picker to an input field. */
|
|
|
3155 _connectDatepicker: function(target, inst) {
|
|
|
3156 var input = $(target);
|
|
|
3157 inst.append = $([]);
|
|
|
3158 inst.trigger = $([]);
|
|
|
3159 if (input.hasClass(this.markerClassName)) {
|
|
|
3160 return;
|
|
|
3161 }
|
|
|
3162 this._attachments(input, inst);
|
|
|
3163 input.addClass(this.markerClassName).keydown(this._doKeyDown).
|
|
|
3164 keypress(this._doKeyPress).keyup(this._doKeyUp);
|
|
|
3165 this._autoSize(inst);
|
|
|
3166 $.data(target, PROP_NAME, inst);
|
|
|
3167 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
|
|
|
3168 if( inst.settings.disabled ) {
|
|
|
3169 this._disableDatepicker( target );
|
|
|
3170 }
|
|
|
3171 },
|
|
|
3172
|
|
|
3173 /* Make attachments based on settings. */
|
|
|
3174 _attachments: function(input, inst) {
|
|
|
3175 var showOn, buttonText, buttonImage,
|
|
|
3176 appendText = this._get(inst, "appendText"),
|
|
|
3177 isRTL = this._get(inst, "isRTL");
|
|
|
3178
|
|
|
3179 if (inst.append) {
|
|
|
3180 inst.append.remove();
|
|
|
3181 }
|
|
|
3182 if (appendText) {
|
|
|
3183 inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
|
|
|
3184 input[isRTL ? "before" : "after"](inst.append);
|
|
|
3185 }
|
|
|
3186
|
|
|
3187 input.unbind("focus", this._showDatepicker);
|
|
|
3188
|
|
|
3189 if (inst.trigger) {
|
|
|
3190 inst.trigger.remove();
|
|
|
3191 }
|
|
|
3192
|
|
|
3193 showOn = this._get(inst, "showOn");
|
|
|
3194 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
|
|
|
3195 input.focus(this._showDatepicker);
|
|
|
3196 }
|
|
|
3197 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
|
|
|
3198 buttonText = this._get(inst, "buttonText");
|
|
|
3199 buttonImage = this._get(inst, "buttonImage");
|
|
|
3200 inst.trigger = $(this._get(inst, "buttonImageOnly") ?
|
|
|
3201 $("<img/>").addClass(this._triggerClass).
|
|
|
3202 attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
|
|
|
3203 $("<button type='button'></button>").addClass(this._triggerClass).
|
|
|
3204 html(!buttonImage ? buttonText : $("<img/>").attr(
|
|
|
3205 { src:buttonImage, alt:buttonText, title:buttonText })));
|
|
|
3206 input[isRTL ? "before" : "after"](inst.trigger);
|
|
|
3207 inst.trigger.click(function() {
|
|
|
3208 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
|
|
|
3209 $.datepicker._hideDatepicker();
|
|
|
3210 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
|
|
|
3211 $.datepicker._hideDatepicker();
|
|
|
3212 $.datepicker._showDatepicker(input[0]);
|
|
|
3213 } else {
|
|
|
3214 $.datepicker._showDatepicker(input[0]);
|
|
|
3215 }
|
|
|
3216 return false;
|
|
|
3217 });
|
|
|
3218 }
|
|
|
3219 },
|
|
|
3220
|
|
|
3221 /* Apply the maximum length for the date format. */
|
|
|
3222 _autoSize: function(inst) {
|
|
|
3223 if (this._get(inst, "autoSize") && !inst.inline) {
|
|
|
3224 var findMax, max, maxI, i,
|
|
|
3225 date = new Date(2009, 12 - 1, 20), // Ensure double digits
|
|
|
3226 dateFormat = this._get(inst, "dateFormat");
|
|
|
3227
|
|
|
3228 if (dateFormat.match(/[DM]/)) {
|
|
|
3229 findMax = function(names) {
|
|
|
3230 max = 0;
|
|
|
3231 maxI = 0;
|
|
|
3232 for (i = 0; i < names.length; i++) {
|
|
|
3233 if (names[i].length > max) {
|
|
|
3234 max = names[i].length;
|
|
|
3235 maxI = i;
|
|
|
3236 }
|
|
|
3237 }
|
|
|
3238 return maxI;
|
|
|
3239 };
|
|
|
3240 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
|
|
|
3241 "monthNames" : "monthNamesShort"))));
|
|
|
3242 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
|
|
|
3243 "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
|
|
|
3244 }
|
|
|
3245 inst.input.attr("size", this._formatDate(inst, date).length);
|
|
|
3246 }
|
|
|
3247 },
|
|
|
3248
|
|
|
3249 /* Attach an inline date picker to a div. */
|
|
|
3250 _inlineDatepicker: function(target, inst) {
|
|
|
3251 var divSpan = $(target);
|
|
|
3252 if (divSpan.hasClass(this.markerClassName)) {
|
|
|
3253 return;
|
|
|
3254 }
|
|
|
3255 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
|
|
|
3256 $.data(target, PROP_NAME, inst);
|
|
|
3257 this._setDate(inst, this._getDefaultDate(inst), true);
|
|
|
3258 this._updateDatepicker(inst);
|
|
|
3259 this._updateAlternate(inst);
|
|
|
3260 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
|
|
|
3261 if( inst.settings.disabled ) {
|
|
|
3262 this._disableDatepicker( target );
|
|
|
3263 }
|
|
|
3264 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
|
|
|
3265 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
|
|
|
3266 inst.dpDiv.css( "display", "block" );
|
|
|
3267 },
|
|
|
3268
|
|
|
3269 /* Pop-up the date picker in a "dialog" box.
|
|
|
3270 * @param input element - ignored
|
|
|
3271 * @param date string or Date - the initial date to display
|
|
|
3272 * @param onSelect function - the function to call when a date is selected
|
|
|
3273 * @param settings object - update the dialog date picker instance's settings (anonymous object)
|
|
|
3274 * @param pos int[2] - coordinates for the dialog's position within the screen or
|
|
|
3275 * event - with x/y coordinates or
|
|
|
3276 * leave empty for default (screen centre)
|
|
|
3277 * @return the manager object
|
|
|
3278 */
|
|
|
3279 _dialogDatepicker: function(input, date, onSelect, settings, pos) {
|
|
|
3280 var id, browserWidth, browserHeight, scrollX, scrollY,
|
|
|
3281 inst = this._dialogInst; // internal instance
|
|
|
3282
|
|
|
3283 if (!inst) {
|
|
|
3284 this.uuid += 1;
|
|
|
3285 id = "dp" + this.uuid;
|
|
|
3286 this._dialogInput = $("<input type='text' id='" + id +
|
|
|
3287 "' style='position: absolute; top: -100px; width: 0px;'/>");
|
|
|
3288 this._dialogInput.keydown(this._doKeyDown);
|
|
|
3289 $("body").append(this._dialogInput);
|
|
|
3290 inst = this._dialogInst = this._newInst(this._dialogInput, false);
|
|
|
3291 inst.settings = {};
|
|
|
3292 $.data(this._dialogInput[0], PROP_NAME, inst);
|
|
|
3293 }
|
|
|
3294 extendRemove(inst.settings, settings || {});
|
|
|
3295 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
|
|
|
3296 this._dialogInput.val(date);
|
|
|
3297
|
|
|
3298 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
|
|
|
3299 if (!this._pos) {
|
|
|
3300 browserWidth = document.documentElement.clientWidth;
|
|
|
3301 browserHeight = document.documentElement.clientHeight;
|
|
|
3302 scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
|
|
|
3303 scrollY = document.documentElement.scrollTop || document.body.scrollTop;
|
|
|
3304 this._pos = // should use actual width/height below
|
|
|
3305 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
|
|
|
3306 }
|
|
|
3307
|
|
|
3308 // move input on screen for focus, but hidden behind dialog
|
|
|
3309 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
|
|
|
3310 inst.settings.onSelect = onSelect;
|
|
|
3311 this._inDialog = true;
|
|
|
3312 this.dpDiv.addClass(this._dialogClass);
|
|
|
3313 this._showDatepicker(this._dialogInput[0]);
|
|
|
3314 if ($.blockUI) {
|
|
|
3315 $.blockUI(this.dpDiv);
|
|
|
3316 }
|
|
|
3317 $.data(this._dialogInput[0], PROP_NAME, inst);
|
|
|
3318 return this;
|
|
|
3319 },
|
|
|
3320
|
|
|
3321 /* Detach a datepicker from its control.
|
|
|
3322 * @param target element - the target input field or division or span
|
|
|
3323 */
|
|
|
3324 _destroyDatepicker: function(target) {
|
|
|
3325 var nodeName,
|
|
|
3326 $target = $(target),
|
|
|
3327 inst = $.data(target, PROP_NAME);
|
|
|
3328
|
|
|
3329 if (!$target.hasClass(this.markerClassName)) {
|
|
|
3330 return;
|
|
|
3331 }
|
|
|
3332
|
|
|
3333 nodeName = target.nodeName.toLowerCase();
|
|
|
3334 $.removeData(target, PROP_NAME);
|
|
|
3335 if (nodeName === "input") {
|
|
|
3336 inst.append.remove();
|
|
|
3337 inst.trigger.remove();
|
|
|
3338 $target.removeClass(this.markerClassName).
|
|
|
3339 unbind("focus", this._showDatepicker).
|
|
|
3340 unbind("keydown", this._doKeyDown).
|
|
|
3341 unbind("keypress", this._doKeyPress).
|
|
|
3342 unbind("keyup", this._doKeyUp);
|
|
|
3343 } else if (nodeName === "div" || nodeName === "span") {
|
|
|
3344 $target.removeClass(this.markerClassName).empty();
|
|
|
3345 }
|
|
|
3346 },
|
|
|
3347
|
|
|
3348 /* Enable the date picker to a jQuery selection.
|
|
|
3349 * @param target element - the target input field or division or span
|
|
|
3350 */
|
|
|
3351 _enableDatepicker: function(target) {
|
|
|
3352 var nodeName, inline,
|
|
|
3353 $target = $(target),
|
|
|
3354 inst = $.data(target, PROP_NAME);
|
|
|
3355
|
|
|
3356 if (!$target.hasClass(this.markerClassName)) {
|
|
|
3357 return;
|
|
|
3358 }
|
|
|
3359
|
|
|
3360 nodeName = target.nodeName.toLowerCase();
|
|
|
3361 if (nodeName === "input") {
|
|
|
3362 target.disabled = false;
|
|
|
3363 inst.trigger.filter("button").
|
|
|
3364 each(function() { this.disabled = false; }).end().
|
|
|
3365 filter("img").css({opacity: "1.0", cursor: ""});
|
|
|
3366 } else if (nodeName === "div" || nodeName === "span") {
|
|
|
3367 inline = $target.children("." + this._inlineClass);
|
|
|
3368 inline.children().removeClass("ui-state-disabled");
|
|
|
3369 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
|
|
|
3370 prop("disabled", false);
|
|
|
3371 }
|
|
|
3372 this._disabledInputs = $.map(this._disabledInputs,
|
|
|
3373 function(value) { return (value === target ? null : value); }); // delete entry
|
|
|
3374 },
|
|
|
3375
|
|
|
3376 /* Disable the date picker to a jQuery selection.
|
|
|
3377 * @param target element - the target input field or division or span
|
|
|
3378 */
|
|
|
3379 _disableDatepicker: function(target) {
|
|
|
3380 var nodeName, inline,
|
|
|
3381 $target = $(target),
|
|
|
3382 inst = $.data(target, PROP_NAME);
|
|
|
3383
|
|
|
3384 if (!$target.hasClass(this.markerClassName)) {
|
|
|
3385 return;
|
|
|
3386 }
|
|
|
3387
|
|
|
3388 nodeName = target.nodeName.toLowerCase();
|
|
|
3389 if (nodeName === "input") {
|
|
|
3390 target.disabled = true;
|
|
|
3391 inst.trigger.filter("button").
|
|
|
3392 each(function() { this.disabled = true; }).end().
|
|
|
3393 filter("img").css({opacity: "0.5", cursor: "default"});
|
|
|
3394 } else if (nodeName === "div" || nodeName === "span") {
|
|
|
3395 inline = $target.children("." + this._inlineClass);
|
|
|
3396 inline.children().addClass("ui-state-disabled");
|
|
|
3397 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
|
|
|
3398 prop("disabled", true);
|
|
|
3399 }
|
|
|
3400 this._disabledInputs = $.map(this._disabledInputs,
|
|
|
3401 function(value) { return (value === target ? null : value); }); // delete entry
|
|
|
3402 this._disabledInputs[this._disabledInputs.length] = target;
|
|
|
3403 },
|
|
|
3404
|
|
|
3405 /* Is the first field in a jQuery collection disabled as a datepicker?
|
|
|
3406 * @param target element - the target input field or division or span
|
|
|
3407 * @return boolean - true if disabled, false if enabled
|
|
|
3408 */
|
|
|
3409 _isDisabledDatepicker: function(target) {
|
|
|
3410 if (!target) {
|
|
|
3411 return false;
|
|
|
3412 }
|
|
|
3413 for (var i = 0; i < this._disabledInputs.length; i++) {
|
|
|
3414 if (this._disabledInputs[i] === target) {
|
|
|
3415 return true;
|
|
|
3416 }
|
|
|
3417 }
|
|
|
3418 return false;
|
|
|
3419 },
|
|
|
3420
|
|
|
3421 /* Retrieve the instance data for the target control.
|
|
|
3422 * @param target element - the target input field or division or span
|
|
|
3423 * @return object - the associated instance data
|
|
|
3424 * @throws error if a jQuery problem getting data
|
|
|
3425 */
|
|
|
3426 _getInst: function(target) {
|
|
|
3427 try {
|
|
|
3428 return $.data(target, PROP_NAME);
|
|
|
3429 }
|
|
|
3430 catch (err) {
|
|
|
3431 throw "Missing instance data for this datepicker";
|
|
|
3432 }
|
|
|
3433 },
|
|
|
3434
|
|
|
3435 /* Update or retrieve the settings for a date picker attached to an input field or division.
|
|
|
3436 * @param target element - the target input field or division or span
|
|
|
3437 * @param name object - the new settings to update or
|
|
|
3438 * string - the name of the setting to change or retrieve,
|
|
|
3439 * when retrieving also "all" for all instance settings or
|
|
|
3440 * "defaults" for all global defaults
|
|
|
3441 * @param value any - the new value for the setting
|
|
|
3442 * (omit if above is an object or to retrieve a value)
|
|
|
3443 */
|
|
|
3444 _optionDatepicker: function(target, name, value) {
|
|
|
3445 var settings, date, minDate, maxDate,
|
|
|
3446 inst = this._getInst(target);
|
|
|
3447
|
|
|
3448 if (arguments.length === 2 && typeof name === "string") {
|
|
|
3449 return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
|
|
|
3450 (inst ? (name === "all" ? $.extend({}, inst.settings) :
|
|
|
3451 this._get(inst, name)) : null));
|
|
|
3452 }
|
|
|
3453
|
|
|
3454 settings = name || {};
|
|
|
3455 if (typeof name === "string") {
|
|
|
3456 settings = {};
|
|
|
3457 settings[name] = value;
|
|
|
3458 }
|
|
|
3459
|
|
|
3460 if (inst) {
|
|
|
3461 if (this._curInst === inst) {
|
|
|
3462 this._hideDatepicker();
|
|
|
3463 }
|
|
|
3464
|
|
|
3465 date = this._getDateDatepicker(target, true);
|
|
|
3466 minDate = this._getMinMaxDate(inst, "min");
|
|
|
3467 maxDate = this._getMinMaxDate(inst, "max");
|
|
|
3468 extendRemove(inst.settings, settings);
|
|
|
3469 // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
|
|
|
3470 if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
|
|
|
3471 inst.settings.minDate = this._formatDate(inst, minDate);
|
|
|
3472 }
|
|
|
3473 if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
|
|
|
3474 inst.settings.maxDate = this._formatDate(inst, maxDate);
|
|
|
3475 }
|
|
|
3476 if ( "disabled" in settings ) {
|
|
|
3477 if ( settings.disabled ) {
|
|
|
3478 this._disableDatepicker(target);
|
|
|
3479 } else {
|
|
|
3480 this._enableDatepicker(target);
|
|
|
3481 }
|
|
|
3482 }
|
|
|
3483 this._attachments($(target), inst);
|
|
|
3484 this._autoSize(inst);
|
|
|
3485 this._setDate(inst, date);
|
|
|
3486 this._updateAlternate(inst);
|
|
|
3487 this._updateDatepicker(inst);
|
|
|
3488 }
|
|
|
3489 },
|
|
|
3490
|
|
|
3491 // change method deprecated
|
|
|
3492 _changeDatepicker: function(target, name, value) {
|
|
|
3493 this._optionDatepicker(target, name, value);
|
|
|
3494 },
|
|
|
3495
|
|
|
3496 /* Redraw the date picker attached to an input field or division.
|
|
|
3497 * @param target element - the target input field or division or span
|
|
|
3498 */
|
|
|
3499 _refreshDatepicker: function(target) {
|
|
|
3500 var inst = this._getInst(target);
|
|
|
3501 if (inst) {
|
|
|
3502 this._updateDatepicker(inst);
|
|
|
3503 }
|
|
|
3504 },
|
|
|
3505
|
|
|
3506 /* Set the dates for a jQuery selection.
|
|
|
3507 * @param target element - the target input field or division or span
|
|
|
3508 * @param date Date - the new date
|
|
|
3509 */
|
|
|
3510 _setDateDatepicker: function(target, date) {
|
|
|
3511 var inst = this._getInst(target);
|
|
|
3512 if (inst) {
|
|
|
3513 this._setDate(inst, date);
|
|
|
3514 this._updateDatepicker(inst);
|
|
|
3515 this._updateAlternate(inst);
|
|
|
3516 }
|
|
|
3517 },
|
|
|
3518
|
|
|
3519 /* Get the date(s) for the first entry in a jQuery selection.
|
|
|
3520 * @param target element - the target input field or division or span
|
|
|
3521 * @param noDefault boolean - true if no default date is to be used
|
|
|
3522 * @return Date - the current date
|
|
|
3523 */
|
|
|
3524 _getDateDatepicker: function(target, noDefault) {
|
|
|
3525 var inst = this._getInst(target);
|
|
|
3526 if (inst && !inst.inline) {
|
|
|
3527 this._setDateFromField(inst, noDefault);
|
|
|
3528 }
|
|
|
3529 return (inst ? this._getDate(inst) : null);
|
|
|
3530 },
|
|
|
3531
|
|
|
3532 /* Handle keystrokes. */
|
|
|
3533 _doKeyDown: function(event) {
|
|
|
3534 var onSelect, dateStr, sel,
|
|
|
3535 inst = $.datepicker._getInst(event.target),
|
|
|
3536 handled = true,
|
|
|
3537 isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
|
|
|
3538
|
|
|
3539 inst._keyEvent = true;
|
|
|
3540 if ($.datepicker._datepickerShowing) {
|
|
|
3541 switch (event.keyCode) {
|
|
|
3542 case 9: $.datepicker._hideDatepicker();
|
|
|
3543 handled = false;
|
|
|
3544 break; // hide on tab out
|
|
|
3545 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
|
|
|
3546 $.datepicker._currentClass + ")", inst.dpDiv);
|
|
|
3547 if (sel[0]) {
|
|
|
3548 $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
|
|
|
3549 }
|
|
|
3550
|
|
|
3551 onSelect = $.datepicker._get(inst, "onSelect");
|
|
|
3552 if (onSelect) {
|
|
|
3553 dateStr = $.datepicker._formatDate(inst);
|
|
|
3554
|
|
|
3555 // trigger custom callback
|
|
|
3556 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
|
|
|
3557 } else {
|
|
|
3558 $.datepicker._hideDatepicker();
|
|
|
3559 }
|
|
|
3560
|
|
|
3561 return false; // don't submit the form
|
|
|
3562 case 27: $.datepicker._hideDatepicker();
|
|
|
3563 break; // hide on escape
|
|
|
3564 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
|
|
|
3565 -$.datepicker._get(inst, "stepBigMonths") :
|
|
|
3566 -$.datepicker._get(inst, "stepMonths")), "M");
|
|
|
3567 break; // previous month/year on page up/+ ctrl
|
|
|
3568 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
|
|
|
3569 +$.datepicker._get(inst, "stepBigMonths") :
|
|
|
3570 +$.datepicker._get(inst, "stepMonths")), "M");
|
|
|
3571 break; // next month/year on page down/+ ctrl
|
|
|
3572 case 35: if (event.ctrlKey || event.metaKey) {
|
|
|
3573 $.datepicker._clearDate(event.target);
|
|
|
3574 }
|
|
|
3575 handled = event.ctrlKey || event.metaKey;
|
|
|
3576 break; // clear on ctrl or command +end
|
|
|
3577 case 36: if (event.ctrlKey || event.metaKey) {
|
|
|
3578 $.datepicker._gotoToday(event.target);
|
|
|
3579 }
|
|
|
3580 handled = event.ctrlKey || event.metaKey;
|
|
|
3581 break; // current on ctrl or command +home
|
|
|
3582 case 37: if (event.ctrlKey || event.metaKey) {
|
|
|
3583 $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
|
|
|
3584 }
|
|
|
3585 handled = event.ctrlKey || event.metaKey;
|
|
|
3586 // -1 day on ctrl or command +left
|
|
|
3587 if (event.originalEvent.altKey) {
|
|
|
3588 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
|
|
|
3589 -$.datepicker._get(inst, "stepBigMonths") :
|
|
|
3590 -$.datepicker._get(inst, "stepMonths")), "M");
|
|
|
3591 }
|
|
|
3592 // next month/year on alt +left on Mac
|
|
|
3593 break;
|
|
|
3594 case 38: if (event.ctrlKey || event.metaKey) {
|
|
|
3595 $.datepicker._adjustDate(event.target, -7, "D");
|
|
|
3596 }
|
|
|
3597 handled = event.ctrlKey || event.metaKey;
|
|
|
3598 break; // -1 week on ctrl or command +up
|
|
|
3599 case 39: if (event.ctrlKey || event.metaKey) {
|
|
|
3600 $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
|
|
|
3601 }
|
|
|
3602 handled = event.ctrlKey || event.metaKey;
|
|
|
3603 // +1 day on ctrl or command +right
|
|
|
3604 if (event.originalEvent.altKey) {
|
|
|
3605 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
|
|
|
3606 +$.datepicker._get(inst, "stepBigMonths") :
|
|
|
3607 +$.datepicker._get(inst, "stepMonths")), "M");
|
|
|
3608 }
|
|
|
3609 // next month/year on alt +right
|
|
|
3610 break;
|
|
|
3611 case 40: if (event.ctrlKey || event.metaKey) {
|
|
|
3612 $.datepicker._adjustDate(event.target, +7, "D");
|
|
|
3613 }
|
|
|
3614 handled = event.ctrlKey || event.metaKey;
|
|
|
3615 break; // +1 week on ctrl or command +down
|
|
|
3616 default: handled = false;
|
|
|
3617 }
|
|
|
3618 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
|
|
|
3619 $.datepicker._showDatepicker(this);
|
|
|
3620 } else {
|
|
|
3621 handled = false;
|
|
|
3622 }
|
|
|
3623
|
|
|
3624 if (handled) {
|
|
|
3625 event.preventDefault();
|
|
|
3626 event.stopPropagation();
|
|
|
3627 }
|
|
|
3628 },
|
|
|
3629
|
|
|
3630 /* Filter entered characters - based on date format. */
|
|
|
3631 _doKeyPress: function(event) {
|
|
|
3632 var chars, chr,
|
|
|
3633 inst = $.datepicker._getInst(event.target);
|
|
|
3634
|
|
|
3635 if ($.datepicker._get(inst, "constrainInput")) {
|
|
|
3636 chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
|
|
|
3637 chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
|
|
|
3638 return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
|
|
|
3639 }
|
|
|
3640 },
|
|
|
3641
|
|
|
3642 /* Synchronise manual entry and field/alternate field. */
|
|
|
3643 _doKeyUp: function(event) {
|
|
|
3644 var date,
|
|
|
3645 inst = $.datepicker._getInst(event.target);
|
|
|
3646
|
|
|
3647 if (inst.input.val() !== inst.lastVal) {
|
|
|
3648 try {
|
|
|
3649 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
|
|
|
3650 (inst.input ? inst.input.val() : null),
|
|
|
3651 $.datepicker._getFormatConfig(inst));
|
|
|
3652
|
|
|
3653 if (date) { // only if valid
|
|
|
3654 $.datepicker._setDateFromField(inst);
|
|
|
3655 $.datepicker._updateAlternate(inst);
|
|
|
3656 $.datepicker._updateDatepicker(inst);
|
|
|
3657 }
|
|
|
3658 }
|
|
|
3659 catch (err) {
|
|
|
3660 }
|
|
|
3661 }
|
|
|
3662 return true;
|
|
|
3663 },
|
|
|
3664
|
|
|
3665 /* Pop-up the date picker for a given input field.
|
|
|
3666 * If false returned from beforeShow event handler do not show.
|
|
|
3667 * @param input element - the input field attached to the date picker or
|
|
|
3668 * event - if triggered by focus
|
|
|
3669 */
|
|
|
3670 _showDatepicker: function(input) {
|
|
|
3671 input = input.target || input;
|
|
|
3672 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
|
|
|
3673 input = $("input", input.parentNode)[0];
|
|
|
3674 }
|
|
|
3675
|
|
|
3676 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
|
|
|
3677 return;
|
|
|
3678 }
|
|
|
3679
|
|
|
3680 var inst, beforeShow, beforeShowSettings, isFixed,
|
|
|
3681 offset, showAnim, duration;
|
|
|
3682
|
|
|
3683 inst = $.datepicker._getInst(input);
|
|
|
3684 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
|
|
|
3685 $.datepicker._curInst.dpDiv.stop(true, true);
|
|
|
3686 if ( inst && $.datepicker._datepickerShowing ) {
|
|
|
3687 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
|
|
|
3688 }
|
|
|
3689 }
|
|
|
3690
|
|
|
3691 beforeShow = $.datepicker._get(inst, "beforeShow");
|
|
|
3692 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
|
|
|
3693 if(beforeShowSettings === false){
|
|
|
3694 return;
|
|
|
3695 }
|
|
|
3696 extendRemove(inst.settings, beforeShowSettings);
|
|
|
3697
|
|
|
3698 inst.lastVal = null;
|
|
|
3699 $.datepicker._lastInput = input;
|
|
|
3700 $.datepicker._setDateFromField(inst);
|
|
|
3701
|
|
|
3702 if ($.datepicker._inDialog) { // hide cursor
|
|
|
3703 input.value = "";
|
|
|
3704 }
|
|
|
3705 if (!$.datepicker._pos) { // position below input
|
|
|
3706 $.datepicker._pos = $.datepicker._findPos(input);
|
|
|
3707 $.datepicker._pos[1] += input.offsetHeight; // add the height
|
|
|
3708 }
|
|
|
3709
|
|
|
3710 isFixed = false;
|
|
|
3711 $(input).parents().each(function() {
|
|
|
3712 isFixed |= $(this).css("position") === "fixed";
|
|
|
3713 return !isFixed;
|
|
|
3714 });
|
|
|
3715
|
|
|
3716 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
|
|
|
3717 $.datepicker._pos = null;
|
|
|
3718 //to avoid flashes on Firefox
|
|
|
3719 inst.dpDiv.empty();
|
|
|
3720 // determine sizing offscreen
|
|
|
3721 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
|
|
|
3722 $.datepicker._updateDatepicker(inst);
|
|
|
3723 // fix width for dynamic number of date pickers
|
|
|
3724 // and adjust position before showing
|
|
|
3725 offset = $.datepicker._checkOffset(inst, offset, isFixed);
|
|
|
3726 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
|
|
|
3727 "static" : (isFixed ? "fixed" : "absolute")), display: "none",
|
|
|
3728 left: offset.left + "px", top: offset.top + "px"});
|
|
|
3729
|
|
|
3730 if (!inst.inline) {
|
|
|
3731 showAnim = $.datepicker._get(inst, "showAnim");
|
|
|
3732 duration = $.datepicker._get(inst, "duration");
|
|
|
3733 inst.dpDiv.zIndex($(input).zIndex()+1);
|
|
|
3734 $.datepicker._datepickerShowing = true;
|
|
|
3735
|
|
|
3736 if ( $.effects && $.effects.effect[ showAnim ] ) {
|
|
|
3737 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
|
|
|
3738 } else {
|
|
|
3739 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
|
|
|
3740 }
|
|
|
3741
|
|
|
3742 if ( $.datepicker._shouldFocusInput( inst ) ) {
|
|
|
3743 inst.input.focus();
|
|
|
3744 }
|
|
|
3745
|
|
|
3746 $.datepicker._curInst = inst;
|
|
|
3747 }
|
|
|
3748 },
|
|
|
3749
|
|
|
3750 /* Generate the date picker content. */
|
|
|
3751 _updateDatepicker: function(inst) {
|
|
|
3752 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
|
|
|
3753 instActive = inst; // for delegate hover events
|
|
|
3754 inst.dpDiv.empty().append(this._generateHTML(inst));
|
|
|
3755 this._attachHandlers(inst);
|
|
|
3756 inst.dpDiv.find("." + this._dayOverClass + " a").mouseover();
|
|
|
3757
|
|
|
3758 var origyearshtml,
|
|
|
3759 numMonths = this._getNumberOfMonths(inst),
|
|
|
3760 cols = numMonths[1],
|
|
|
3761 width = 17;
|
|
|
3762
|
|
|
3763 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
|
|
|
3764 if (cols > 1) {
|
|
|
3765 inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
|
|
|
3766 }
|
|
|
3767 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
|
|
|
3768 "Class"]("ui-datepicker-multi");
|
|
|
3769 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
|
|
|
3770 "Class"]("ui-datepicker-rtl");
|
|
|
3771
|
|
|
3772 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
|
|
|
3773 inst.input.focus();
|
|
|
3774 }
|
|
|
3775
|
|
|
3776 // deffered render of the years select (to avoid flashes on Firefox)
|
|
|
3777 if( inst.yearshtml ){
|
|
|
3778 origyearshtml = inst.yearshtml;
|
|
|
3779 setTimeout(function(){
|
|
|
3780 //assure that inst.yearshtml didn't change.
|
|
|
3781 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
|
|
|
3782 inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
|
|
|
3783 }
|
|
|
3784 origyearshtml = inst.yearshtml = null;
|
|
|
3785 }, 0);
|
|
|
3786 }
|
|
|
3787 },
|
|
|
3788
|
|
|
3789 // #6694 - don't focus the input if it's already focused
|
|
|
3790 // this breaks the change event in IE
|
|
|
3791 // Support: IE and jQuery <1.9
|
|
|
3792 _shouldFocusInput: function( inst ) {
|
|
|
3793 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
|
|
|
3794 },
|
|
|
3795
|
|
|
3796 /* Check positioning to remain on screen. */
|
|
|
3797 _checkOffset: function(inst, offset, isFixed) {
|
|
|
3798 var dpWidth = inst.dpDiv.outerWidth(),
|
|
|
3799 dpHeight = inst.dpDiv.outerHeight(),
|
|
|
3800 inputWidth = inst.input ? inst.input.outerWidth() : 0,
|
|
|
3801 inputHeight = inst.input ? inst.input.outerHeight() : 0,
|
|
|
3802 viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
|
|
|
3803 viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
|
|
|
3804
|
|
|
3805 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
|
|
|
3806 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
|
|
|
3807 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
|
|
|
3808
|
|
|
3809 // now check if datepicker is showing outside window viewport - move to a better place if so.
|
|
|
3810 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
|
|
|
3811 Math.abs(offset.left + dpWidth - viewWidth) : 0);
|
|
|
3812 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
|
|
|
3813 Math.abs(dpHeight + inputHeight) : 0);
|
|
|
3814
|
|
|
3815 return offset;
|
|
|
3816 },
|
|
|
3817
|
|
|
3818 /* Find an object's position on the screen. */
|
|
|
3819 _findPos: function(obj) {
|
|
|
3820 var position,
|
|
|
3821 inst = this._getInst(obj),
|
|
|
3822 isRTL = this._get(inst, "isRTL");
|
|
|
3823
|
|
|
3824 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
|
|
|
3825 obj = obj[isRTL ? "previousSibling" : "nextSibling"];
|
|
|
3826 }
|
|
|
3827
|
|
|
3828 position = $(obj).offset();
|
|
|
3829 return [position.left, position.top];
|
|
|
3830 },
|
|
|
3831
|
|
|
3832 /* Hide the date picker from view.
|
|
|
3833 * @param input element - the input field attached to the date picker
|
|
|
3834 */
|
|
|
3835 _hideDatepicker: function(input) {
|
|
|
3836 var showAnim, duration, postProcess, onClose,
|
|
|
3837 inst = this._curInst;
|
|
|
3838
|
|
|
3839 if (!inst || (input && inst !== $.data(input, PROP_NAME))) {
|
|
|
3840 return;
|
|
|
3841 }
|
|
|
3842
|
|
|
3843 if (this._datepickerShowing) {
|
|
|
3844 showAnim = this._get(inst, "showAnim");
|
|
|
3845 duration = this._get(inst, "duration");
|
|
|
3846 postProcess = function() {
|
|
|
3847 $.datepicker._tidyDialog(inst);
|
|
|
3848 };
|
|
|
3849
|
|
|
3850 // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
|
|
|
3851 if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
|
|
|
3852 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
|
|
|
3853 } else {
|
|
|
3854 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
|
|
|
3855 (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
|
|
|
3856 }
|
|
|
3857
|
|
|
3858 if (!showAnim) {
|
|
|
3859 postProcess();
|
|
|
3860 }
|
|
|
3861 this._datepickerShowing = false;
|
|
|
3862
|
|
|
3863 onClose = this._get(inst, "onClose");
|
|
|
3864 if (onClose) {
|
|
|
3865 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
|
|
|
3866 }
|
|
|
3867
|
|
|
3868 this._lastInput = null;
|
|
|
3869 if (this._inDialog) {
|
|
|
3870 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
|
|
|
3871 if ($.blockUI) {
|
|
|
3872 $.unblockUI();
|
|
|
3873 $("body").append(this.dpDiv);
|
|
|
3874 }
|
|
|
3875 }
|
|
|
3876 this._inDialog = false;
|
|
|
3877 }
|
|
|
3878 },
|
|
|
3879
|
|
|
3880 /* Tidy up after a dialog display. */
|
|
|
3881 _tidyDialog: function(inst) {
|
|
|
3882 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
|
|
|
3883 },
|
|
|
3884
|
|
|
3885 /* Close date picker if clicked elsewhere. */
|
|
|
3886 _checkExternalClick: function(event) {
|
|
|
3887 if (!$.datepicker._curInst) {
|
|
|
3888 return;
|
|
|
3889 }
|
|
|
3890
|
|
|
3891 var $target = $(event.target),
|
|
|
3892 inst = $.datepicker._getInst($target[0]);
|
|
|
3893
|
|
|
3894 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
|
|
|
3895 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
|
|
|
3896 !$target.hasClass($.datepicker.markerClassName) &&
|
|
|
3897 !$target.closest("." + $.datepicker._triggerClass).length &&
|
|
|
3898 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
|
|
|
3899 ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
|
|
|
3900 $.datepicker._hideDatepicker();
|
|
|
3901 }
|
|
|
3902 },
|
|
|
3903
|
|
|
3904 /* Adjust one of the date sub-fields. */
|
|
|
3905 _adjustDate: function(id, offset, period) {
|
|
|
3906 var target = $(id),
|
|
|
3907 inst = this._getInst(target[0]);
|
|
|
3908
|
|
|
3909 if (this._isDisabledDatepicker(target[0])) {
|
|
|
3910 return;
|
|
|
3911 }
|
|
|
3912 this._adjustInstDate(inst, offset +
|
|
|
3913 (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
|
|
|
3914 period);
|
|
|
3915 this._updateDatepicker(inst);
|
|
|
3916 },
|
|
|
3917
|
|
|
3918 /* Action for current link. */
|
|
|
3919 _gotoToday: function(id) {
|
|
|
3920 var date,
|
|
|
3921 target = $(id),
|
|
|
3922 inst = this._getInst(target[0]);
|
|
|
3923
|
|
|
3924 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
|
|
|
3925 inst.selectedDay = inst.currentDay;
|
|
|
3926 inst.drawMonth = inst.selectedMonth = inst.currentMonth;
|
|
|
3927 inst.drawYear = inst.selectedYear = inst.currentYear;
|
|
|
3928 } else {
|
|
|
3929 date = new Date();
|
|
|
3930 inst.selectedDay = date.getDate();
|
|
|
3931 inst.drawMonth = inst.selectedMonth = date.getMonth();
|
|
|
3932 inst.drawYear = inst.selectedYear = date.getFullYear();
|
|
|
3933 }
|
|
|
3934 this._notifyChange(inst);
|
|
|
3935 this._adjustDate(target);
|
|
|
3936 },
|
|
|
3937
|
|
|
3938 /* Action for selecting a new month/year. */
|
|
|
3939 _selectMonthYear: function(id, select, period) {
|
|
|
3940 var target = $(id),
|
|
|
3941 inst = this._getInst(target[0]);
|
|
|
3942
|
|
|
3943 inst["selected" + (period === "M" ? "Month" : "Year")] =
|
|
|
3944 inst["draw" + (period === "M" ? "Month" : "Year")] =
|
|
|
3945 parseInt(select.options[select.selectedIndex].value,10);
|
|
|
3946
|
|
|
3947 this._notifyChange(inst);
|
|
|
3948 this._adjustDate(target);
|
|
|
3949 },
|
|
|
3950
|
|
|
3951 /* Action for selecting a day. */
|
|
|
3952 _selectDay: function(id, month, year, td) {
|
|
|
3953 var inst,
|
|
|
3954 target = $(id);
|
|
|
3955
|
|
|
3956 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
|
|
|
3957 return;
|
|
|
3958 }
|
|
|
3959
|
|
|
3960 inst = this._getInst(target[0]);
|
|
|
3961 inst.selectedDay = inst.currentDay = $("a", td).html();
|
|
|
3962 inst.selectedMonth = inst.currentMonth = month;
|
|
|
3963 inst.selectedYear = inst.currentYear = year;
|
|
|
3964 this._selectDate(id, this._formatDate(inst,
|
|
|
3965 inst.currentDay, inst.currentMonth, inst.currentYear));
|
|
|
3966 },
|
|
|
3967
|
|
|
3968 /* Erase the input field and hide the date picker. */
|
|
|
3969 _clearDate: function(id) {
|
|
|
3970 var target = $(id);
|
|
|
3971 this._selectDate(target, "");
|
|
|
3972 },
|
|
|
3973
|
|
|
3974 /* Update the input field with the selected date. */
|
|
|
3975 _selectDate: function(id, dateStr) {
|
|
|
3976 var onSelect,
|
|
|
3977 target = $(id),
|
|
|
3978 inst = this._getInst(target[0]);
|
|
|
3979
|
|
|
3980 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
|
|
|
3981 if (inst.input) {
|
|
|
3982 inst.input.val(dateStr);
|
|
|
3983 }
|
|
|
3984 this._updateAlternate(inst);
|
|
|
3985
|
|
|
3986 onSelect = this._get(inst, "onSelect");
|
|
|
3987 if (onSelect) {
|
|
|
3988 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
|
|
|
3989 } else if (inst.input) {
|
|
|
3990 inst.input.trigger("change"); // fire the change event
|
|
|
3991 }
|
|
|
3992
|
|
|
3993 if (inst.inline){
|
|
|
3994 this._updateDatepicker(inst);
|
|
|
3995 } else {
|
|
|
3996 this._hideDatepicker();
|
|
|
3997 this._lastInput = inst.input[0];
|
|
|
3998 if (typeof(inst.input[0]) !== "object") {
|
|
|
3999 inst.input.focus(); // restore focus
|
|
|
4000 }
|
|
|
4001 this._lastInput = null;
|
|
|
4002 }
|
|
|
4003 },
|
|
|
4004
|
|
|
4005 /* Update any alternate field to synchronise with the main field. */
|
|
|
4006 _updateAlternate: function(inst) {
|
|
|
4007 var altFormat, date, dateStr,
|
|
|
4008 altField = this._get(inst, "altField");
|
|
|
4009
|
|
|
4010 if (altField) { // update alternate field too
|
|
|
4011 altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
|
|
|
4012 date = this._getDate(inst);
|
|
|
4013 dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
|
|
|
4014 $(altField).each(function() { $(this).val(dateStr); });
|
|
|
4015 }
|
|
|
4016 },
|
|
|
4017
|
|
|
4018 /* Set as beforeShowDay function to prevent selection of weekends.
|
|
|
4019 * @param date Date - the date to customise
|
|
|
4020 * @return [boolean, string] - is this date selectable?, what is its CSS class?
|
|
|
4021 */
|
|
|
4022 noWeekends: function(date) {
|
|
|
4023 var day = date.getDay();
|
|
|
4024 return [(day > 0 && day < 6), ""];
|
|
|
4025 },
|
|
|
4026
|
|
|
4027 /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
|
|
|
4028 * @param date Date - the date to get the week for
|
|
|
4029 * @return number - the number of the week within the year that contains this date
|
|
|
4030 */
|
|
|
4031 iso8601Week: function(date) {
|
|
|
4032 var time,
|
|
|
4033 checkDate = new Date(date.getTime());
|
|
|
4034
|
|
|
4035 // Find Thursday of this week starting on Monday
|
|
|
4036 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
|
|
|
4037
|
|
|
4038 time = checkDate.getTime();
|
|
|
4039 checkDate.setMonth(0); // Compare with Jan 1
|
|
|
4040 checkDate.setDate(1);
|
|
|
4041 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
|
|
|
4042 },
|
|
|
4043
|
|
|
4044 /* Parse a string value into a date object.
|
|
|
4045 * See formatDate below for the possible formats.
|
|
|
4046 *
|
|
|
4047 * @param format string - the expected format of the date
|
|
|
4048 * @param value string - the date in the above format
|
|
|
4049 * @param settings Object - attributes include:
|
|
|
4050 * shortYearCutoff number - the cutoff year for determining the century (optional)
|
|
|
4051 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
|
|
|
4052 * dayNames string[7] - names of the days from Sunday (optional)
|
|
|
4053 * monthNamesShort string[12] - abbreviated names of the months (optional)
|
|
|
4054 * monthNames string[12] - names of the months (optional)
|
|
|
4055 * @return Date - the extracted date value or null if value is blank
|
|
|
4056 */
|
|
|
4057 parseDate: function (format, value, settings) {
|
|
|
4058 if (format == null || value == null) {
|
|
|
4059 throw "Invalid arguments";
|
|
|
4060 }
|
|
|
4061
|
|
|
4062 value = (typeof value === "object" ? value.toString() : value + "");
|
|
|
4063 if (value === "") {
|
|
|
4064 return null;
|
|
|
4065 }
|
|
|
4066
|
|
|
4067 var iFormat, dim, extra,
|
|
|
4068 iValue = 0,
|
|
|
4069 shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
|
|
|
4070 shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
|
|
|
4071 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
|
|
|
4072 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
|
|
|
4073 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
|
|
|
4074 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
|
|
|
4075 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
|
|
|
4076 year = -1,
|
|
|
4077 month = -1,
|
|
|
4078 day = -1,
|
|
|
4079 doy = -1,
|
|
|
4080 literal = false,
|
|
|
4081 date,
|
|
|
4082 // Check whether a format character is doubled
|
|
|
4083 lookAhead = function(match) {
|
|
|
4084 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
|
|
|
4085 if (matches) {
|
|
|
4086 iFormat++;
|
|
|
4087 }
|
|
|
4088 return matches;
|
|
|
4089 },
|
|
|
4090 // Extract a number from the string value
|
|
|
4091 getNumber = function(match) {
|
|
|
4092 var isDoubled = lookAhead(match),
|
|
|
4093 size = (match === "@" ? 14 : (match === "!" ? 20 :
|
|
|
4094 (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
|
|
|
4095 digits = new RegExp("^\\d{1," + size + "}"),
|
|
|
4096 num = value.substring(iValue).match(digits);
|
|
|
4097 if (!num) {
|
|
|
4098 throw "Missing number at position " + iValue;
|
|
|
4099 }
|
|
|
4100 iValue += num[0].length;
|
|
|
4101 return parseInt(num[0], 10);
|
|
|
4102 },
|
|
|
4103 // Extract a name from the string value and convert to an index
|
|
|
4104 getName = function(match, shortNames, longNames) {
|
|
|
4105 var index = -1,
|
|
|
4106 names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
|
|
|
4107 return [ [k, v] ];
|
|
|
4108 }).sort(function (a, b) {
|
|
|
4109 return -(a[1].length - b[1].length);
|
|
|
4110 });
|
|
|
4111
|
|
|
4112 $.each(names, function (i, pair) {
|
|
|
4113 var name = pair[1];
|
|
|
4114 if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
|
|
|
4115 index = pair[0];
|
|
|
4116 iValue += name.length;
|
|
|
4117 return false;
|
|
|
4118 }
|
|
|
4119 });
|
|
|
4120 if (index !== -1) {
|
|
|
4121 return index + 1;
|
|
|
4122 } else {
|
|
|
4123 throw "Unknown name at position " + iValue;
|
|
|
4124 }
|
|
|
4125 },
|
|
|
4126 // Confirm that a literal character matches the string value
|
|
|
4127 checkLiteral = function() {
|
|
|
4128 if (value.charAt(iValue) !== format.charAt(iFormat)) {
|
|
|
4129 throw "Unexpected literal at position " + iValue;
|
|
|
4130 }
|
|
|
4131 iValue++;
|
|
|
4132 };
|
|
|
4133
|
|
|
4134 for (iFormat = 0; iFormat < format.length; iFormat++) {
|
|
|
4135 if (literal) {
|
|
|
4136 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
|
|
|
4137 literal = false;
|
|
|
4138 } else {
|
|
|
4139 checkLiteral();
|
|
|
4140 }
|
|
|
4141 } else {
|
|
|
4142 switch (format.charAt(iFormat)) {
|
|
|
4143 case "d":
|
|
|
4144 day = getNumber("d");
|
|
|
4145 break;
|
|
|
4146 case "D":
|
|
|
4147 getName("D", dayNamesShort, dayNames);
|
|
|
4148 break;
|
|
|
4149 case "o":
|
|
|
4150 doy = getNumber("o");
|
|
|
4151 break;
|
|
|
4152 case "m":
|
|
|
4153 month = getNumber("m");
|
|
|
4154 break;
|
|
|
4155 case "M":
|
|
|
4156 month = getName("M", monthNamesShort, monthNames);
|
|
|
4157 break;
|
|
|
4158 case "y":
|
|
|
4159 year = getNumber("y");
|
|
|
4160 break;
|
|
|
4161 case "@":
|
|
|
4162 date = new Date(getNumber("@"));
|
|
|
4163 year = date.getFullYear();
|
|
|
4164 month = date.getMonth() + 1;
|
|
|
4165 day = date.getDate();
|
|
|
4166 break;
|
|
|
4167 case "!":
|
|
|
4168 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
|
|
|
4169 year = date.getFullYear();
|
|
|
4170 month = date.getMonth() + 1;
|
|
|
4171 day = date.getDate();
|
|
|
4172 break;
|
|
|
4173 case "'":
|
|
|
4174 if (lookAhead("'")){
|
|
|
4175 checkLiteral();
|
|
|
4176 } else {
|
|
|
4177 literal = true;
|
|
|
4178 }
|
|
|
4179 break;
|
|
|
4180 default:
|
|
|
4181 checkLiteral();
|
|
|
4182 }
|
|
|
4183 }
|
|
|
4184 }
|
|
|
4185
|
|
|
4186 if (iValue < value.length){
|
|
|
4187 extra = value.substr(iValue);
|
|
|
4188 if (!/^\s+/.test(extra)) {
|
|
|
4189 throw "Extra/unparsed characters found in date: " + extra;
|
|
|
4190 }
|
|
|
4191 }
|
|
|
4192
|
|
|
4193 if (year === -1) {
|
|
|
4194 year = new Date().getFullYear();
|
|
|
4195 } else if (year < 100) {
|
|
|
4196 year += new Date().getFullYear() - new Date().getFullYear() % 100 +
|
|
|
4197 (year <= shortYearCutoff ? 0 : -100);
|
|
|
4198 }
|
|
|
4199
|
|
|
4200 if (doy > -1) {
|
|
|
4201 month = 1;
|
|
|
4202 day = doy;
|
|
|
4203 do {
|
|
|
4204 dim = this._getDaysInMonth(year, month - 1);
|
|
|
4205 if (day <= dim) {
|
|
|
4206 break;
|
|
|
4207 }
|
|
|
4208 month++;
|
|
|
4209 day -= dim;
|
|
|
4210 } while (true);
|
|
|
4211 }
|
|
|
4212
|
|
|
4213 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
|
|
|
4214 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
|
|
|
4215 throw "Invalid date"; // E.g. 31/02/00
|
|
|
4216 }
|
|
|
4217 return date;
|
|
|
4218 },
|
|
|
4219
|
|
|
4220 /* Standard date formats. */
|
|
|
4221 ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
|
|
|
4222 COOKIE: "D, dd M yy",
|
|
|
4223 ISO_8601: "yy-mm-dd",
|
|
|
4224 RFC_822: "D, d M y",
|
|
|
4225 RFC_850: "DD, dd-M-y",
|
|
|
4226 RFC_1036: "D, d M y",
|
|
|
4227 RFC_1123: "D, d M yy",
|
|
|
4228 RFC_2822: "D, d M yy",
|
|
|
4229 RSS: "D, d M y", // RFC 822
|
|
|
4230 TICKS: "!",
|
|
|
4231 TIMESTAMP: "@",
|
|
|
4232 W3C: "yy-mm-dd", // ISO 8601
|
|
|
4233
|
|
|
4234 _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
|
|
|
4235 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
|
|
|
4236
|
|
|
4237 /* Format a date object into a string value.
|
|
|
4238 * The format can be combinations of the following:
|
|
|
4239 * d - day of month (no leading zero)
|
|
|
4240 * dd - day of month (two digit)
|
|
|
4241 * o - day of year (no leading zeros)
|
|
|
4242 * oo - day of year (three digit)
|
|
|
4243 * D - day name short
|
|
|
4244 * DD - day name long
|
|
|
4245 * m - month of year (no leading zero)
|
|
|
4246 * mm - month of year (two digit)
|
|
|
4247 * M - month name short
|
|
|
4248 * MM - month name long
|
|
|
4249 * y - year (two digit)
|
|
|
4250 * yy - year (four digit)
|
|
|
4251 * @ - Unix timestamp (ms since 01/01/1970)
|
|
|
4252 * ! - Windows ticks (100ns since 01/01/0001)
|
|
|
4253 * "..." - literal text
|
|
|
4254 * '' - single quote
|
|
|
4255 *
|
|
|
4256 * @param format string - the desired format of the date
|
|
|
4257 * @param date Date - the date value to format
|
|
|
4258 * @param settings Object - attributes include:
|
|
|
4259 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
|
|
|
4260 * dayNames string[7] - names of the days from Sunday (optional)
|
|
|
4261 * monthNamesShort string[12] - abbreviated names of the months (optional)
|
|
|
4262 * monthNames string[12] - names of the months (optional)
|
|
|
4263 * @return string - the date in the above format
|
|
|
4264 */
|
|
|
4265 formatDate: function (format, date, settings) {
|
|
|
4266 if (!date) {
|
|
|
4267 return "";
|
|
|
4268 }
|
|
|
4269
|
|
|
4270 var iFormat,
|
|
|
4271 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
|
|
|
4272 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
|
|
|
4273 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
|
|
|
4274 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
|
|
|
4275 // Check whether a format character is doubled
|
|
|
4276 lookAhead = function(match) {
|
|
|
4277 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
|
|
|
4278 if (matches) {
|
|
|
4279 iFormat++;
|
|
|
4280 }
|
|
|
4281 return matches;
|
|
|
4282 },
|
|
|
4283 // Format a number, with leading zero if necessary
|
|
|
4284 formatNumber = function(match, value, len) {
|
|
|
4285 var num = "" + value;
|
|
|
4286 if (lookAhead(match)) {
|
|
|
4287 while (num.length < len) {
|
|
|
4288 num = "0" + num;
|
|
|
4289 }
|
|
|
4290 }
|
|
|
4291 return num;
|
|
|
4292 },
|
|
|
4293 // Format a name, short or long as requested
|
|
|
4294 formatName = function(match, value, shortNames, longNames) {
|
|
|
4295 return (lookAhead(match) ? longNames[value] : shortNames[value]);
|
|
|
4296 },
|
|
|
4297 output = "",
|
|
|
4298 literal = false;
|
|
|
4299
|
|
|
4300 if (date) {
|
|
|
4301 for (iFormat = 0; iFormat < format.length; iFormat++) {
|
|
|
4302 if (literal) {
|
|
|
4303 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
|
|
|
4304 literal = false;
|
|
|
4305 } else {
|
|
|
4306 output += format.charAt(iFormat);
|
|
|
4307 }
|
|
|
4308 } else {
|
|
|
4309 switch (format.charAt(iFormat)) {
|
|
|
4310 case "d":
|
|
|
4311 output += formatNumber("d", date.getDate(), 2);
|
|
|
4312 break;
|
|
|
4313 case "D":
|
|
|
4314 output += formatName("D", date.getDay(), dayNamesShort, dayNames);
|
|
|
4315 break;
|
|
|
4316 case "o":
|
|
|
4317 output += formatNumber("o",
|
|
|
4318 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
|
|
|
4319 break;
|
|
|
4320 case "m":
|
|
|
4321 output += formatNumber("m", date.getMonth() + 1, 2);
|
|
|
4322 break;
|
|
|
4323 case "M":
|
|
|
4324 output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
|
|
|
4325 break;
|
|
|
4326 case "y":
|
|
|
4327 output += (lookAhead("y") ? date.getFullYear() :
|
|
|
4328 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
|
|
|
4329 break;
|
|
|
4330 case "@":
|
|
|
4331 output += date.getTime();
|
|
|
4332 break;
|
|
|
4333 case "!":
|
|
|
4334 output += date.getTime() * 10000 + this._ticksTo1970;
|
|
|
4335 break;
|
|
|
4336 case "'":
|
|
|
4337 if (lookAhead("'")) {
|
|
|
4338 output += "'";
|
|
|
4339 } else {
|
|
|
4340 literal = true;
|
|
|
4341 }
|
|
|
4342 break;
|
|
|
4343 default:
|
|
|
4344 output += format.charAt(iFormat);
|
|
|
4345 }
|
|
|
4346 }
|
|
|
4347 }
|
|
|
4348 }
|
|
|
4349 return output;
|
|
|
4350 },
|
|
|
4351
|
|
|
4352 /* Extract all possible characters from the date format. */
|
|
|
4353 _possibleChars: function (format) {
|
|
|
4354 var iFormat,
|
|
|
4355 chars = "",
|
|
|
4356 literal = false,
|
|
|
4357 // Check whether a format character is doubled
|
|
|
4358 lookAhead = function(match) {
|
|
|
4359 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
|
|
|
4360 if (matches) {
|
|
|
4361 iFormat++;
|
|
|
4362 }
|
|
|
4363 return matches;
|
|
|
4364 };
|
|
|
4365
|
|
|
4366 for (iFormat = 0; iFormat < format.length; iFormat++) {
|
|
|
4367 if (literal) {
|
|
|
4368 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
|
|
|
4369 literal = false;
|
|
|
4370 } else {
|
|
|
4371 chars += format.charAt(iFormat);
|
|
|
4372 }
|
|
|
4373 } else {
|
|
|
4374 switch (format.charAt(iFormat)) {
|
|
|
4375 case "d": case "m": case "y": case "@":
|
|
|
4376 chars += "0123456789";
|
|
|
4377 break;
|
|
|
4378 case "D": case "M":
|
|
|
4379 return null; // Accept anything
|
|
|
4380 case "'":
|
|
|
4381 if (lookAhead("'")) {
|
|
|
4382 chars += "'";
|
|
|
4383 } else {
|
|
|
4384 literal = true;
|
|
|
4385 }
|
|
|
4386 break;
|
|
|
4387 default:
|
|
|
4388 chars += format.charAt(iFormat);
|
|
|
4389 }
|
|
|
4390 }
|
|
|
4391 }
|
|
|
4392 return chars;
|
|
|
4393 },
|
|
|
4394
|
|
|
4395 /* Get a setting value, defaulting if necessary. */
|
|
|
4396 _get: function(inst, name) {
|
|
|
4397 return inst.settings[name] !== undefined ?
|
|
|
4398 inst.settings[name] : this._defaults[name];
|
|
|
4399 },
|
|
|
4400
|
|
|
4401 /* Parse existing date and initialise date picker. */
|
|
|
4402 _setDateFromField: function(inst, noDefault) {
|
|
|
4403 if (inst.input.val() === inst.lastVal) {
|
|
|
4404 return;
|
|
|
4405 }
|
|
|
4406
|
|
|
4407 var dateFormat = this._get(inst, "dateFormat"),
|
|
|
4408 dates = inst.lastVal = inst.input ? inst.input.val() : null,
|
|
|
4409 defaultDate = this._getDefaultDate(inst),
|
|
|
4410 date = defaultDate,
|
|
|
4411 settings = this._getFormatConfig(inst);
|
|
|
4412
|
|
|
4413 try {
|
|
|
4414 date = this.parseDate(dateFormat, dates, settings) || defaultDate;
|
|
|
4415 } catch (event) {
|
|
|
4416 dates = (noDefault ? "" : dates);
|
|
|
4417 }
|
|
|
4418 inst.selectedDay = date.getDate();
|
|
|
4419 inst.drawMonth = inst.selectedMonth = date.getMonth();
|
|
|
4420 inst.drawYear = inst.selectedYear = date.getFullYear();
|
|
|
4421 inst.currentDay = (dates ? date.getDate() : 0);
|
|
|
4422 inst.currentMonth = (dates ? date.getMonth() : 0);
|
|
|
4423 inst.currentYear = (dates ? date.getFullYear() : 0);
|
|
|
4424 this._adjustInstDate(inst);
|
|
|
4425 },
|
|
|
4426
|
|
|
4427 /* Retrieve the default date shown on opening. */
|
|
|
4428 _getDefaultDate: function(inst) {
|
|
|
4429 return this._restrictMinMax(inst,
|
|
|
4430 this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
|
|
|
4431 },
|
|
|
4432
|
|
|
4433 /* A date may be specified as an exact value or a relative one. */
|
|
|
4434 _determineDate: function(inst, date, defaultDate) {
|
|
|
4435 var offsetNumeric = function(offset) {
|
|
|
4436 var date = new Date();
|
|
|
4437 date.setDate(date.getDate() + offset);
|
|
|
4438 return date;
|
|
|
4439 },
|
|
|
4440 offsetString = function(offset) {
|
|
|
4441 try {
|
|
|
4442 return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
|
|
|
4443 offset, $.datepicker._getFormatConfig(inst));
|
|
|
4444 }
|
|
|
4445 catch (e) {
|
|
|
4446 // Ignore
|
|
|
4447 }
|
|
|
4448
|
|
|
4449 var date = (offset.toLowerCase().match(/^c/) ?
|
|
|
4450 $.datepicker._getDate(inst) : null) || new Date(),
|
|
|
4451 year = date.getFullYear(),
|
|
|
4452 month = date.getMonth(),
|
|
|
4453 day = date.getDate(),
|
|
|
4454 pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
|
|
|
4455 matches = pattern.exec(offset);
|
|
|
4456
|
|
|
4457 while (matches) {
|
|
|
4458 switch (matches[2] || "d") {
|
|
|
4459 case "d" : case "D" :
|
|
|
4460 day += parseInt(matches[1],10); break;
|
|
|
4461 case "w" : case "W" :
|
|
|
4462 day += parseInt(matches[1],10) * 7; break;
|
|
|
4463 case "m" : case "M" :
|
|
|
4464 month += parseInt(matches[1],10);
|
|
|
4465 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
|
|
|
4466 break;
|
|
|
4467 case "y": case "Y" :
|
|
|
4468 year += parseInt(matches[1],10);
|
|
|
4469 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
|
|
|
4470 break;
|
|
|
4471 }
|
|
|
4472 matches = pattern.exec(offset);
|
|
|
4473 }
|
|
|
4474 return new Date(year, month, day);
|
|
|
4475 },
|
|
|
4476 newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
|
|
|
4477 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
|
|
|
4478
|
|
|
4479 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
|
|
|
4480 if (newDate) {
|
|
|
4481 newDate.setHours(0);
|
|
|
4482 newDate.setMinutes(0);
|
|
|
4483 newDate.setSeconds(0);
|
|
|
4484 newDate.setMilliseconds(0);
|
|
|
4485 }
|
|
|
4486 return this._daylightSavingAdjust(newDate);
|
|
|
4487 },
|
|
|
4488
|
|
|
4489 /* Handle switch to/from daylight saving.
|
|
|
4490 * Hours may be non-zero on daylight saving cut-over:
|
|
|
4491 * > 12 when midnight changeover, but then cannot generate
|
|
|
4492 * midnight datetime, so jump to 1AM, otherwise reset.
|
|
|
4493 * @param date (Date) the date to check
|
|
|
4494 * @return (Date) the corrected date
|
|
|
4495 */
|
|
|
4496 _daylightSavingAdjust: function(date) {
|
|
|
4497 if (!date) {
|
|
|
4498 return null;
|
|
|
4499 }
|
|
|
4500 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
|
|
|
4501 return date;
|
|
|
4502 },
|
|
|
4503
|
|
|
4504 /* Set the date(s) directly. */
|
|
|
4505 _setDate: function(inst, date, noChange) {
|
|
|
4506 var clear = !date,
|
|
|
4507 origMonth = inst.selectedMonth,
|
|
|
4508 origYear = inst.selectedYear,
|
|
|
4509 newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
|
|
|
4510
|
|
|
4511 inst.selectedDay = inst.currentDay = newDate.getDate();
|
|
|
4512 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
|
|
|
4513 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
|
|
|
4514 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
|
|
|
4515 this._notifyChange(inst);
|
|
|
4516 }
|
|
|
4517 this._adjustInstDate(inst);
|
|
|
4518 if (inst.input) {
|
|
|
4519 inst.input.val(clear ? "" : this._formatDate(inst));
|
|
|
4520 }
|
|
|
4521 },
|
|
|
4522
|
|
|
4523 /* Retrieve the date(s) directly. */
|
|
|
4524 _getDate: function(inst) {
|
|
|
4525 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
|
|
|
4526 this._daylightSavingAdjust(new Date(
|
|
|
4527 inst.currentYear, inst.currentMonth, inst.currentDay)));
|
|
|
4528 return startDate;
|
|
|
4529 },
|
|
|
4530
|
|
|
4531 /* Attach the onxxx handlers. These are declared statically so
|
|
|
4532 * they work with static code transformers like Caja.
|
|
|
4533 */
|
|
|
4534 _attachHandlers: function(inst) {
|
|
|
4535 var stepMonths = this._get(inst, "stepMonths"),
|
|
|
4536 id = "#" + inst.id.replace( /\\\\/g, "\\" );
|
|
|
4537 inst.dpDiv.find("[data-handler]").map(function () {
|
|
|
4538 var handler = {
|
|
|
4539 prev: function () {
|
|
|
4540 $.datepicker._adjustDate(id, -stepMonths, "M");
|
|
|
4541 },
|
|
|
4542 next: function () {
|
|
|
4543 $.datepicker._adjustDate(id, +stepMonths, "M");
|
|
|
4544 },
|
|
|
4545 hide: function () {
|
|
|
4546 $.datepicker._hideDatepicker();
|
|
|
4547 },
|
|
|
4548 today: function () {
|
|
|
4549 $.datepicker._gotoToday(id);
|
|
|
4550 },
|
|
|
4551 selectDay: function () {
|
|
|
4552 $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
|
|
|
4553 return false;
|
|
|
4554 },
|
|
|
4555 selectMonth: function () {
|
|
|
4556 $.datepicker._selectMonthYear(id, this, "M");
|
|
|
4557 return false;
|
|
|
4558 },
|
|
|
4559 selectYear: function () {
|
|
|
4560 $.datepicker._selectMonthYear(id, this, "Y");
|
|
|
4561 return false;
|
|
|
4562 }
|
|
|
4563 };
|
|
|
4564 $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
|
|
|
4565 });
|
|
|
4566 },
|
|
|
4567
|
|
|
4568 /* Generate the HTML for the current state of the date picker. */
|
|
|
4569 _generateHTML: function(inst) {
|
|
|
4570 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
|
|
|
4571 controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
|
|
|
4572 monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
|
|
|
4573 selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
|
|
|
4574 cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
|
|
|
4575 printDate, dRow, tbody, daySettings, otherMonth, unselectable,
|
|
|
4576 tempDate = new Date(),
|
|
|
4577 today = this._daylightSavingAdjust(
|
|
|
4578 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
|
|
|
4579 isRTL = this._get(inst, "isRTL"),
|
|
|
4580 showButtonPanel = this._get(inst, "showButtonPanel"),
|
|
|
4581 hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
|
|
|
4582 navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
|
|
|
4583 numMonths = this._getNumberOfMonths(inst),
|
|
|
4584 showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
|
|
|
4585 stepMonths = this._get(inst, "stepMonths"),
|
|
|
4586 isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
|
|
|
4587 currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
|
|
|
4588 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
|
|
|
4589 minDate = this._getMinMaxDate(inst, "min"),
|
|
|
4590 maxDate = this._getMinMaxDate(inst, "max"),
|
|
|
4591 drawMonth = inst.drawMonth - showCurrentAtPos,
|
|
|
4592 drawYear = inst.drawYear;
|
|
|
4593
|
|
|
4594 if (drawMonth < 0) {
|
|
|
4595 drawMonth += 12;
|
|
|
4596 drawYear--;
|
|
|
4597 }
|
|
|
4598 if (maxDate) {
|
|
|
4599 maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
|
|
|
4600 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
|
|
|
4601 maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
|
|
|
4602 while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
|
|
|
4603 drawMonth--;
|
|
|
4604 if (drawMonth < 0) {
|
|
|
4605 drawMonth = 11;
|
|
|
4606 drawYear--;
|
|
|
4607 }
|
|
|
4608 }
|
|
|
4609 }
|
|
|
4610 inst.drawMonth = drawMonth;
|
|
|
4611 inst.drawYear = drawYear;
|
|
|
4612
|
|
|
4613 prevText = this._get(inst, "prevText");
|
|
|
4614 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
|
|
|
4615 this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
|
|
|
4616 this._getFormatConfig(inst)));
|
|
|
4617
|
|
|
4618 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
|
|
|
4619 "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
|
|
|
4620 " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
|
|
|
4621 (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>"));
|
|
|
4622
|
|
|
4623 nextText = this._get(inst, "nextText");
|
|
|
4624 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
|
|
|
4625 this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
|
|
|
4626 this._getFormatConfig(inst)));
|
|
|
4627
|
|
|
4628 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
|
|
|
4629 "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
|
|
|
4630 " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
|
|
|
4631 (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>"));
|
|
|
4632
|
|
|
4633 currentText = this._get(inst, "currentText");
|
|
|
4634 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
|
|
|
4635 currentText = (!navigationAsDateFormat ? currentText :
|
|
|
4636 this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
|
|
|
4637
|
|
|
4638 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'>" +
|
|
|
4639 this._get(inst, "closeText") + "</button>" : "");
|
|
|
4640
|
|
|
4641 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
|
|
|
4642 (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'" +
|
|
|
4643 ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
|
|
|
4644
|
|
|
4645 firstDay = parseInt(this._get(inst, "firstDay"),10);
|
|
|
4646 firstDay = (isNaN(firstDay) ? 0 : firstDay);
|
|
|
4647
|
|
|
4648 showWeek = this._get(inst, "showWeek");
|
|
|
4649 dayNames = this._get(inst, "dayNames");
|
|
|
4650 dayNamesMin = this._get(inst, "dayNamesMin");
|
|
|
4651 monthNames = this._get(inst, "monthNames");
|
|
|
4652 monthNamesShort = this._get(inst, "monthNamesShort");
|
|
|
4653 beforeShowDay = this._get(inst, "beforeShowDay");
|
|
|
4654 showOtherMonths = this._get(inst, "showOtherMonths");
|
|
|
4655 selectOtherMonths = this._get(inst, "selectOtherMonths");
|
|
|
4656 defaultDate = this._getDefaultDate(inst);
|
|
|
4657 html = "";
|
|
|
4658 dow;
|
|
|
4659 for (row = 0; row < numMonths[0]; row++) {
|
|
|
4660 group = "";
|
|
|
4661 this.maxRows = 4;
|
|
|
4662 for (col = 0; col < numMonths[1]; col++) {
|
|
|
4663 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
|
|
|
4664 cornerClass = " ui-corner-all";
|
|
|
4665 calender = "";
|
|
|
4666 if (isMultiMonth) {
|
|
|
4667 calender += "<div class='ui-datepicker-group";
|
|
|
4668 if (numMonths[1] > 1) {
|
|
|
4669 switch (col) {
|
|
|
4670 case 0: calender += " ui-datepicker-group-first";
|
|
|
4671 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
|
|
|
4672 case numMonths[1]-1: calender += " ui-datepicker-group-last";
|
|
|
4673 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
|
|
|
4674 default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
|
|
|
4675 }
|
|
|
4676 }
|
|
|
4677 calender += "'>";
|
|
|
4678 }
|
|
|
4679 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
|
|
|
4680 (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
|
|
|
4681 (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
|
|
|
4682 this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
|
|
|
4683 row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
|
|
|
4684 "</div><table class='ui-datepicker-calendar'><thead>" +
|
|
|
4685 "<tr>";
|
|
|
4686 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
|
|
|
4687 for (dow = 0; dow < 7; dow++) { // days of the week
|
|
|
4688 day = (dow + firstDay) % 7;
|
|
|
4689 thead += "<th" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
|
|
|
4690 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
|
|
|
4691 }
|
|
|
4692 calender += thead + "</tr></thead><tbody>";
|
|
|
4693 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
|
|
|
4694 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
|
|
|
4695 inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
|
|
|
4696 }
|
|
|
4697 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
|
|
|
4698 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
|
|
|
4699 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
|
|
|
4700 this.maxRows = numRows;
|
|
|
4701 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
|
|
|
4702 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
|
|
|
4703 calender += "<tr>";
|
|
|
4704 tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
|
|
|
4705 this._get(inst, "calculateWeek")(printDate) + "</td>");
|
|
|
4706 for (dow = 0; dow < 7; dow++) { // create date picker days
|
|
|
4707 daySettings = (beforeShowDay ?
|
|
|
4708 beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
|
|
|
4709 otherMonth = (printDate.getMonth() !== drawMonth);
|
|
|
4710 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
|
|
|
4711 (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
|
|
|
4712 tbody += "<td class='" +
|
|
|
4713 ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
|
|
|
4714 (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
|
|
|
4715 ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
|
|
|
4716 (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
|
|
|
4717 // or defaultDate is current printedDate and defaultDate is selectedDate
|
|
|
4718 " " + this._dayOverClass : "") + // highlight selected day
|
|
|
4719 (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
|
|
|
4720 (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
|
|
|
4721 (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
|
|
|
4722 (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
|
|
|
4723 ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "'") + "'" : "") + // cell title
|
|
|
4724 (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
|
|
|
4725 (otherMonth && !showOtherMonths ? " " : // display for other months
|
|
|
4726 (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
|
|
|
4727 (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
|
|
|
4728 (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
|
|
|
4729 (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
|
|
|
4730 "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
|
|
|
4731 printDate.setDate(printDate.getDate() + 1);
|
|
|
4732 printDate = this._daylightSavingAdjust(printDate);
|
|
|
4733 }
|
|
|
4734 calender += tbody + "</tr>";
|
|
|
4735 }
|
|
|
4736 drawMonth++;
|
|
|
4737 if (drawMonth > 11) {
|
|
|
4738 drawMonth = 0;
|
|
|
4739 drawYear++;
|
|
|
4740 }
|
|
|
4741 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
|
|
|
4742 ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
|
|
|
4743 group += calender;
|
|
|
4744 }
|
|
|
4745 html += group;
|
|
|
4746 }
|
|
|
4747 html += buttonPanel;
|
|
|
4748 inst._keyEvent = false;
|
|
|
4749 return html;
|
|
|
4750 },
|
|
|
4751
|
|
|
4752 /* Generate the month and year header. */
|
|
|
4753 _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
|
|
|
4754 secondary, monthNames, monthNamesShort) {
|
|
|
4755
|
|
|
4756 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
|
|
|
4757 changeMonth = this._get(inst, "changeMonth"),
|
|
|
4758 changeYear = this._get(inst, "changeYear"),
|
|
|
4759 showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
|
|
|
4760 html = "<div class='ui-datepicker-title'>",
|
|
|
4761 monthHtml = "";
|
|
|
4762
|
|
|
4763 // month selection
|
|
|
4764 if (secondary || !changeMonth) {
|
|
|
4765 monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
|
|
|
4766 } else {
|
|
|
4767 inMinYear = (minDate && minDate.getFullYear() === drawYear);
|
|
|
4768 inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
|
|
|
4769 monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
|
|
|
4770 for ( month = 0; month < 12; month++) {
|
|
|
4771 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
|
|
|
4772 monthHtml += "<option value='" + month + "'" +
|
|
|
4773 (month === drawMonth ? " selected='selected'" : "") +
|
|
|
4774 ">" + monthNamesShort[month] + "</option>";
|
|
|
4775 }
|
|
|
4776 }
|
|
|
4777 monthHtml += "</select>";
|
|
|
4778 }
|
|
|
4779
|
|
|
4780 if (!showMonthAfterYear) {
|
|
|
4781 html += monthHtml + (secondary || !(changeMonth && changeYear) ? " " : "");
|
|
|
4782 }
|
|
|
4783
|
|
|
4784 // year selection
|
|
|
4785 if ( !inst.yearshtml ) {
|
|
|
4786 inst.yearshtml = "";
|
|
|
4787 if (secondary || !changeYear) {
|
|
|
4788 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
|
|
|
4789 } else {
|
|
|
4790 // determine range of years to display
|
|
|
4791 years = this._get(inst, "yearRange").split(":");
|
|
|
4792 thisYear = new Date().getFullYear();
|
|
|
4793 determineYear = function(value) {
|
|
|
4794 var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
|
|
|
4795 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
|
|
|
4796 parseInt(value, 10)));
|
|
|
4797 return (isNaN(year) ? thisYear : year);
|
|
|
4798 };
|
|
|
4799 year = determineYear(years[0]);
|
|
|
4800 endYear = Math.max(year, determineYear(years[1] || ""));
|
|
|
4801 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
|
|
|
4802 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
|
|
|
4803 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
|
|
|
4804 for (; year <= endYear; year++) {
|
|
|
4805 inst.yearshtml += "<option value='" + year + "'" +
|
|
|
4806 (year === drawYear ? " selected='selected'" : "") +
|
|
|
4807 ">" + year + "</option>";
|
|
|
4808 }
|
|
|
4809 inst.yearshtml += "</select>";
|
|
|
4810
|
|
|
4811 html += inst.yearshtml;
|
|
|
4812 inst.yearshtml = null;
|
|
|
4813 }
|
|
|
4814 }
|
|
|
4815
|
|
|
4816 html += this._get(inst, "yearSuffix");
|
|
|
4817 if (showMonthAfterYear) {
|
|
|
4818 html += (secondary || !(changeMonth && changeYear) ? " " : "") + monthHtml;
|
|
|
4819 }
|
|
|
4820 html += "</div>"; // Close datepicker_header
|
|
|
4821 return html;
|
|
|
4822 },
|
|
|
4823
|
|
|
4824 /* Adjust one of the date sub-fields. */
|
|
|
4825 _adjustInstDate: function(inst, offset, period) {
|
|
|
4826 var year = inst.drawYear + (period === "Y" ? offset : 0),
|
|
|
4827 month = inst.drawMonth + (period === "M" ? offset : 0),
|
|
|
4828 day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
|
|
|
4829 date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
|
|
|
4830
|
|
|
4831 inst.selectedDay = date.getDate();
|
|
|
4832 inst.drawMonth = inst.selectedMonth = date.getMonth();
|
|
|
4833 inst.drawYear = inst.selectedYear = date.getFullYear();
|
|
|
4834 if (period === "M" || period === "Y") {
|
|
|
4835 this._notifyChange(inst);
|
|
|
4836 }
|
|
|
4837 },
|
|
|
4838
|
|
|
4839 /* Ensure a date is within any min/max bounds. */
|
|
|
4840 _restrictMinMax: function(inst, date) {
|
|
|
4841 var minDate = this._getMinMaxDate(inst, "min"),
|
|
|
4842 maxDate = this._getMinMaxDate(inst, "max"),
|
|
|
4843 newDate = (minDate && date < minDate ? minDate : date);
|
|
|
4844 return (maxDate && newDate > maxDate ? maxDate : newDate);
|
|
|
4845 },
|
|
|
4846
|
|
|
4847 /* Notify change of month/year. */
|
|
|
4848 _notifyChange: function(inst) {
|
|
|
4849 var onChange = this._get(inst, "onChangeMonthYear");
|
|
|
4850 if (onChange) {
|
|
|
4851 onChange.apply((inst.input ? inst.input[0] : null),
|
|
|
4852 [inst.selectedYear, inst.selectedMonth + 1, inst]);
|
|
|
4853 }
|
|
|
4854 },
|
|
|
4855
|
|
|
4856 /* Determine the number of months to show. */
|
|
|
4857 _getNumberOfMonths: function(inst) {
|
|
|
4858 var numMonths = this._get(inst, "numberOfMonths");
|
|
|
4859 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
|
|
|
4860 },
|
|
|
4861
|
|
|
4862 /* Determine the current maximum date - ensure no time components are set. */
|
|
|
4863 _getMinMaxDate: function(inst, minMax) {
|
|
|
4864 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
|
|
|
4865 },
|
|
|
4866
|
|
|
4867 /* Find the number of days in a given month. */
|
|
|
4868 _getDaysInMonth: function(year, month) {
|
|
|
4869 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
|
|
|
4870 },
|
|
|
4871
|
|
|
4872 /* Find the day of the week of the first of a month. */
|
|
|
4873 _getFirstDayOfMonth: function(year, month) {
|
|
|
4874 return new Date(year, month, 1).getDay();
|
|
|
4875 },
|
|
|
4876
|
|
|
4877 /* Determines if we should allow a "next/prev" month display change. */
|
|
|
4878 _canAdjustMonth: function(inst, offset, curYear, curMonth) {
|
|
|
4879 var numMonths = this._getNumberOfMonths(inst),
|
|
|
4880 date = this._daylightSavingAdjust(new Date(curYear,
|
|
|
4881 curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
|
|
|
4882
|
|
|
4883 if (offset < 0) {
|
|
|
4884 date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
|
|
|
4885 }
|
|
|
4886 return this._isInRange(inst, date);
|
|
|
4887 },
|
|
|
4888
|
|
|
4889 /* Is the given date in the accepted range? */
|
|
|
4890 _isInRange: function(inst, date) {
|
|
|
4891 var yearSplit, currentYear,
|
|
|
4892 minDate = this._getMinMaxDate(inst, "min"),
|
|
|
4893 maxDate = this._getMinMaxDate(inst, "max"),
|
|
|
4894 minYear = null,
|
|
|
4895 maxYear = null,
|
|
|
4896 years = this._get(inst, "yearRange");
|
|
|
4897 if (years){
|
|
|
4898 yearSplit = years.split(":");
|
|
|
4899 currentYear = new Date().getFullYear();
|
|
|
4900 minYear = parseInt(yearSplit[0], 10);
|
|
|
4901 maxYear = parseInt(yearSplit[1], 10);
|
|
|
4902 if ( yearSplit[0].match(/[+\-].*/) ) {
|
|
|
4903 minYear += currentYear;
|
|
|
4904 }
|
|
|
4905 if ( yearSplit[1].match(/[+\-].*/) ) {
|
|
|
4906 maxYear += currentYear;
|
|
|
4907 }
|
|
|
4908 }
|
|
|
4909
|
|
|
4910 return ((!minDate || date.getTime() >= minDate.getTime()) &&
|
|
|
4911 (!maxDate || date.getTime() <= maxDate.getTime()) &&
|
|
|
4912 (!minYear || date.getFullYear() >= minYear) &&
|
|
|
4913 (!maxYear || date.getFullYear() <= maxYear));
|
|
|
4914 },
|
|
|
4915
|
|
|
4916 /* Provide the configuration settings for formatting/parsing. */
|
|
|
4917 _getFormatConfig: function(inst) {
|
|
|
4918 var shortYearCutoff = this._get(inst, "shortYearCutoff");
|
|
|
4919 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
|
|
|
4920 new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
|
|
|
4921 return {shortYearCutoff: shortYearCutoff,
|
|
|
4922 dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
|
|
|
4923 monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
|
|
|
4924 },
|
|
|
4925
|
|
|
4926 /* Format the given date for display. */
|
|
|
4927 _formatDate: function(inst, day, month, year) {
|
|
|
4928 if (!day) {
|
|
|
4929 inst.currentDay = inst.selectedDay;
|
|
|
4930 inst.currentMonth = inst.selectedMonth;
|
|
|
4931 inst.currentYear = inst.selectedYear;
|
|
|
4932 }
|
|
|
4933 var date = (day ? (typeof day === "object" ? day :
|
|
|
4934 this._daylightSavingAdjust(new Date(year, month, day))) :
|
|
|
4935 this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
|
|
|
4936 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
|
|
|
4937 }
|
|
|
4938 });
|
|
|
4939
|
|
|
4940 /*
|
|
|
4941 * Bind hover events for datepicker elements.
|
|
|
4942 * Done via delegate so the binding only occurs once in the lifetime of the parent div.
|
|
|
4943 * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
|
|
|
4944 */
|
|
|
4945 function bindHover(dpDiv) {
|
|
|
4946 var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
|
|
|
4947 return dpDiv.delegate(selector, "mouseout", function() {
|
|
|
4948 $(this).removeClass("ui-state-hover");
|
|
|
4949 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
|
|
|
4950 $(this).removeClass("ui-datepicker-prev-hover");
|
|
|
4951 }
|
|
|
4952 if (this.className.indexOf("ui-datepicker-next") !== -1) {
|
|
|
4953 $(this).removeClass("ui-datepicker-next-hover");
|
|
|
4954 }
|
|
|
4955 })
|
|
|
4956 .delegate(selector, "mouseover", function(){
|
|
|
4957 if (!$.datepicker._isDisabledDatepicker( instActive.inline ? dpDiv.parent()[0] : instActive.input[0])) {
|
|
|
4958 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
|
|
|
4959 $(this).addClass("ui-state-hover");
|
|
|
4960 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
|
|
|
4961 $(this).addClass("ui-datepicker-prev-hover");
|
|
|
4962 }
|
|
|
4963 if (this.className.indexOf("ui-datepicker-next") !== -1) {
|
|
|
4964 $(this).addClass("ui-datepicker-next-hover");
|
|
|
4965 }
|
|
|
4966 }
|
|
|
4967 });
|
|
|
4968 }
|
|
|
4969
|
|
|
4970 /* jQuery extend now ignores nulls! */
|
|
|
4971 function extendRemove(target, props) {
|
|
|
4972 $.extend(target, props);
|
|
|
4973 for (var name in props) {
|
|
|
4974 if (props[name] == null) {
|
|
|
4975 target[name] = props[name];
|
|
|
4976 }
|
|
|
4977 }
|
|
|
4978 return target;
|
|
|
4979 }
|
|
|
4980
|
|
|
4981 /* Invoke the datepicker functionality.
|
|
|
4982 @param options string - a command, optionally followed by additional parameters or
|
|
|
4983 Object - settings for attaching new datepicker functionality
|
|
|
4984 @return jQuery object */
|
|
|
4985 $.fn.datepicker = function(options){
|
|
|
4986
|
|
|
4987 /* Verify an empty collection wasn't passed - Fixes #6976 */
|
|
|
4988 if ( !this.length ) {
|
|
|
4989 return this;
|
|
|
4990 }
|
|
|
4991
|
|
|
4992 /* Initialise the date picker. */
|
|
|
4993 if (!$.datepicker.initialized) {
|
|
|
4994 $(document).mousedown($.datepicker._checkExternalClick);
|
|
|
4995 $.datepicker.initialized = true;
|
|
|
4996 }
|
|
|
4997
|
|
|
4998 /* Append datepicker main container to body if not exist. */
|
|
|
4999 if ($("#"+$.datepicker._mainDivId).length === 0) {
|
|
|
5000 $("body").append($.datepicker.dpDiv);
|
|
|
5001 }
|
|
|
5002
|
|
|
5003 var otherArgs = Array.prototype.slice.call(arguments, 1);
|
|
|
5004 if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
|
|
|
5005 return $.datepicker["_" + options + "Datepicker"].
|
|
|
5006 apply($.datepicker, [this[0]].concat(otherArgs));
|
|
|
5007 }
|
|
|
5008 if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
|
|
|
5009 return $.datepicker["_" + options + "Datepicker"].
|
|
|
5010 apply($.datepicker, [this[0]].concat(otherArgs));
|
|
|
5011 }
|
|
|
5012 return this.each(function() {
|
|
|
5013 typeof options === "string" ?
|
|
|
5014 $.datepicker["_" + options + "Datepicker"].
|
|
|
5015 apply($.datepicker, [this].concat(otherArgs)) :
|
|
|
5016 $.datepicker._attachDatepicker(this, options);
|
|
|
5017 });
|
|
|
5018 };
|
|
|
5019
|
|
|
5020 $.datepicker = new Datepicker(); // singleton instance
|
|
|
5021 $.datepicker.initialized = false;
|
|
|
5022 $.datepicker.uuid = new Date().getTime();
|
|
|
5023 $.datepicker.version = "1.10.4";
|
|
|
5024
|
|
|
5025 })(jQuery);
|
|
|
5026 (function( $, undefined ) {
|
|
|
5027
|
|
|
5028 var sizeRelatedOptions = {
|
|
|
5029 buttons: true,
|
|
|
5030 height: true,
|
|
|
5031 maxHeight: true,
|
|
|
5032 maxWidth: true,
|
|
|
5033 minHeight: true,
|
|
|
5034 minWidth: true,
|
|
|
5035 width: true
|
|
|
5036 },
|
|
|
5037 resizableRelatedOptions = {
|
|
|
5038 maxHeight: true,
|
|
|
5039 maxWidth: true,
|
|
|
5040 minHeight: true,
|
|
|
5041 minWidth: true
|
|
|
5042 };
|
|
|
5043
|
|
|
5044 $.widget( "ui.dialog", {
|
|
|
5045 version: "1.10.4",
|
|
|
5046 options: {
|
|
|
5047 appendTo: "body",
|
|
|
5048 autoOpen: true,
|
|
|
5049 buttons: [],
|
|
|
5050 closeOnEscape: true,
|
|
|
5051 closeText: "close",
|
|
|
5052 dialogClass: "",
|
|
|
5053 draggable: true,
|
|
|
5054 hide: null,
|
|
|
5055 height: "auto",
|
|
|
5056 maxHeight: null,
|
|
|
5057 maxWidth: null,
|
|
|
5058 minHeight: 150,
|
|
|
5059 minWidth: 150,
|
|
|
5060 modal: false,
|
|
|
5061 position: {
|
|
|
5062 my: "center",
|
|
|
5063 at: "center",
|
|
|
5064 of: window,
|
|
|
5065 collision: "fit",
|
|
|
5066 // Ensure the titlebar is always visible
|
|
|
5067 using: function( pos ) {
|
|
|
5068 var topOffset = $( this ).css( pos ).offset().top;
|
|
|
5069 if ( topOffset < 0 ) {
|
|
|
5070 $( this ).css( "top", pos.top - topOffset );
|
|
|
5071 }
|
|
|
5072 }
|
|
|
5073 },
|
|
|
5074 resizable: true,
|
|
|
5075 show: null,
|
|
|
5076 title: null,
|
|
|
5077 width: 300,
|
|
|
5078
|
|
|
5079 // callbacks
|
|
|
5080 beforeClose: null,
|
|
|
5081 close: null,
|
|
|
5082 drag: null,
|
|
|
5083 dragStart: null,
|
|
|
5084 dragStop: null,
|
|
|
5085 focus: null,
|
|
|
5086 open: null,
|
|
|
5087 resize: null,
|
|
|
5088 resizeStart: null,
|
|
|
5089 resizeStop: null
|
|
|
5090 },
|
|
|
5091
|
|
|
5092 _create: function() {
|
|
|
5093 this.originalCss = {
|
|
|
5094 display: this.element[0].style.display,
|
|
|
5095 width: this.element[0].style.width,
|
|
|
5096 minHeight: this.element[0].style.minHeight,
|
|
|
5097 maxHeight: this.element[0].style.maxHeight,
|
|
|
5098 height: this.element[0].style.height
|
|
|
5099 };
|
|
|
5100 this.originalPosition = {
|
|
|
5101 parent: this.element.parent(),
|
|
|
5102 index: this.element.parent().children().index( this.element )
|
|
|
5103 };
|
|
|
5104 this.originalTitle = this.element.attr("title");
|
|
|
5105 this.options.title = this.options.title || this.originalTitle;
|
|
|
5106
|
|
|
5107 this._createWrapper();
|
|
|
5108
|
|
|
5109 this.element
|
|
|
5110 .show()
|
|
|
5111 .removeAttr("title")
|
|
|
5112 .addClass("ui-dialog-content ui-widget-content")
|
|
|
5113 .appendTo( this.uiDialog );
|
|
|
5114
|
|
|
5115 this._createTitlebar();
|
|
|
5116 this._createButtonPane();
|
|
|
5117
|
|
|
5118 if ( this.options.draggable && $.fn.draggable ) {
|
|
|
5119 this._makeDraggable();
|
|
|
5120 }
|
|
|
5121 if ( this.options.resizable && $.fn.resizable ) {
|
|
|
5122 this._makeResizable();
|
|
|
5123 }
|
|
|
5124
|
|
|
5125 this._isOpen = false;
|
|
|
5126 },
|
|
|
5127
|
|
|
5128 _init: function() {
|
|
|
5129 if ( this.options.autoOpen ) {
|
|
|
5130 this.open();
|
|
|
5131 }
|
|
|
5132 },
|
|
|
5133
|
|
|
5134 _appendTo: function() {
|
|
|
5135 var element = this.options.appendTo;
|
|
|
5136 if ( element && (element.jquery || element.nodeType) ) {
|
|
|
5137 return $( element );
|
|
|
5138 }
|
|
|
5139 return this.document.find( element || "body" ).eq( 0 );
|
|
|
5140 },
|
|
|
5141
|
|
|
5142 _destroy: function() {
|
|
|
5143 var next,
|
|
|
5144 originalPosition = this.originalPosition;
|
|
|
5145
|
|
|
5146 this._destroyOverlay();
|
|
|
5147
|
|
|
5148 this.element
|
|
|
5149 .removeUniqueId()
|
|
|
5150 .removeClass("ui-dialog-content ui-widget-content")
|
|
|
5151 .css( this.originalCss )
|
|
|
5152 // Without detaching first, the following becomes really slow
|
|
|
5153 .detach();
|
|
|
5154
|
|
|
5155 this.uiDialog.stop( true, true ).remove();
|
|
|
5156
|
|
|
5157 if ( this.originalTitle ) {
|
|
|
5158 this.element.attr( "title", this.originalTitle );
|
|
|
5159 }
|
|
|
5160
|
|
|
5161 next = originalPosition.parent.children().eq( originalPosition.index );
|
|
|
5162 // Don't try to place the dialog next to itself (#8613)
|
|
|
5163 if ( next.length && next[0] !== this.element[0] ) {
|
|
|
5164 next.before( this.element );
|
|
|
5165 } else {
|
|
|
5166 originalPosition.parent.append( this.element );
|
|
|
5167 }
|
|
|
5168 },
|
|
|
5169
|
|
|
5170 widget: function() {
|
|
|
5171 return this.uiDialog;
|
|
|
5172 },
|
|
|
5173
|
|
|
5174 disable: $.noop,
|
|
|
5175 enable: $.noop,
|
|
|
5176
|
|
|
5177 close: function( event ) {
|
|
|
5178 var activeElement,
|
|
|
5179 that = this;
|
|
|
5180
|
|
|
5181 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
|
|
|
5182 return;
|
|
|
5183 }
|
|
|
5184
|
|
|
5185 this._isOpen = false;
|
|
|
5186 this._destroyOverlay();
|
|
|
5187
|
|
|
5188 if ( !this.opener.filter(":focusable").focus().length ) {
|
|
|
5189
|
|
|
5190 // support: IE9
|
|
|
5191 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
|
|
|
5192 try {
|
|
|
5193 activeElement = this.document[ 0 ].activeElement;
|
|
|
5194
|
|
|
5195 // Support: IE9, IE10
|
|
|
5196 // If the <body> is blurred, IE will switch windows, see #4520
|
|
|
5197 if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
|
|
|
5198
|
|
|
5199 // Hiding a focused element doesn't trigger blur in WebKit
|
|
|
5200 // so in case we have nothing to focus on, explicitly blur the active element
|
|
|
5201 // https://bugs.webkit.org/show_bug.cgi?id=47182
|
|
|
5202 $( activeElement ).blur();
|
|
|
5203 }
|
|
|
5204 } catch ( error ) {}
|
|
|
5205 }
|
|
|
5206
|
|
|
5207 this._hide( this.uiDialog, this.options.hide, function() {
|
|
|
5208 that._trigger( "close", event );
|
|
|
5209 });
|
|
|
5210 },
|
|
|
5211
|
|
|
5212 isOpen: function() {
|
|
|
5213 return this._isOpen;
|
|
|
5214 },
|
|
|
5215
|
|
|
5216 moveToTop: function() {
|
|
|
5217 this._moveToTop();
|
|
|
5218 },
|
|
|
5219
|
|
|
5220 _moveToTop: function( event, silent ) {
|
|
|
5221 var moved = !!this.uiDialog.nextAll(":visible").insertBefore( this.uiDialog ).length;
|
|
|
5222 if ( moved && !silent ) {
|
|
|
5223 this._trigger( "focus", event );
|
|
|
5224 }
|
|
|
5225 return moved;
|
|
|
5226 },
|
|
|
5227
|
|
|
5228 open: function() {
|
|
|
5229 var that = this;
|
|
|
5230 if ( this._isOpen ) {
|
|
|
5231 if ( this._moveToTop() ) {
|
|
|
5232 this._focusTabbable();
|
|
|
5233 }
|
|
|
5234 return;
|
|
|
5235 }
|
|
|
5236
|
|
|
5237 this._isOpen = true;
|
|
|
5238 this.opener = $( this.document[0].activeElement );
|
|
|
5239
|
|
|
5240 this._size();
|
|
|
5241 this._position();
|
|
|
5242 this._createOverlay();
|
|
|
5243 this._moveToTop( null, true );
|
|
|
5244 this._show( this.uiDialog, this.options.show, function() {
|
|
|
5245 that._focusTabbable();
|
|
|
5246 that._trigger("focus");
|
|
|
5247 });
|
|
|
5248
|
|
|
5249 this._trigger("open");
|
|
|
5250 },
|
|
|
5251
|
|
|
5252 _focusTabbable: function() {
|
|
|
5253 // Set focus to the first match:
|
|
|
5254 // 1. First element inside the dialog matching [autofocus]
|
|
|
5255 // 2. Tabbable element inside the content element
|
|
|
5256 // 3. Tabbable element inside the buttonpane
|
|
|
5257 // 4. The close button
|
|
|
5258 // 5. The dialog itself
|
|
|
5259 var hasFocus = this.element.find("[autofocus]");
|
|
|
5260 if ( !hasFocus.length ) {
|
|
|
5261 hasFocus = this.element.find(":tabbable");
|
|
|
5262 }
|
|
|
5263 if ( !hasFocus.length ) {
|
|
|
5264 hasFocus = this.uiDialogButtonPane.find(":tabbable");
|
|
|
5265 }
|
|
|
5266 if ( !hasFocus.length ) {
|
|
|
5267 hasFocus = this.uiDialogTitlebarClose.filter(":tabbable");
|
|
|
5268 }
|
|
|
5269 if ( !hasFocus.length ) {
|
|
|
5270 hasFocus = this.uiDialog;
|
|
|
5271 }
|
|
|
5272 hasFocus.eq( 0 ).focus();
|
|
|
5273 },
|
|
|
5274
|
|
|
5275 _keepFocus: function( event ) {
|
|
|
5276 function checkFocus() {
|
|
|
5277 var activeElement = this.document[0].activeElement,
|
|
|
5278 isActive = this.uiDialog[0] === activeElement ||
|
|
|
5279 $.contains( this.uiDialog[0], activeElement );
|
|
|
5280 if ( !isActive ) {
|
|
|
5281 this._focusTabbable();
|
|
|
5282 }
|
|
|
5283 }
|
|
|
5284 event.preventDefault();
|
|
|
5285 checkFocus.call( this );
|
|
|
5286 // support: IE
|
|
|
5287 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
|
|
|
5288 // so we check again later
|
|
|
5289 this._delay( checkFocus );
|
|
|
5290 },
|
|
|
5291
|
|
|
5292 _createWrapper: function() {
|
|
|
5293 this.uiDialog = $("<div>")
|
|
|
5294 .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
|
|
|
5295 this.options.dialogClass )
|
|
|
5296 .hide()
|
|
|
5297 .attr({
|
|
|
5298 // Setting tabIndex makes the div focusable
|
|
|
5299 tabIndex: -1,
|
|
|
5300 role: "dialog"
|
|
|
5301 })
|
|
|
5302 .appendTo( this._appendTo() );
|
|
|
5303
|
|
|
5304 this._on( this.uiDialog, {
|
|
|
5305 keydown: function( event ) {
|
|
|
5306 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
|
|
|
5307 event.keyCode === $.ui.keyCode.ESCAPE ) {
|
|
|
5308 event.preventDefault();
|
|
|
5309 this.close( event );
|
|
|
5310 return;
|
|
|
5311 }
|
|
|
5312
|
|
|
5313 // prevent tabbing out of dialogs
|
|
|
5314 if ( event.keyCode !== $.ui.keyCode.TAB ) {
|
|
|
5315 return;
|
|
|
5316 }
|
|
|
5317 var tabbables = this.uiDialog.find(":tabbable"),
|
|
|
5318 first = tabbables.filter(":first"),
|
|
|
5319 last = tabbables.filter(":last");
|
|
|
5320
|
|
|
5321 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
|
|
|
5322 first.focus( 1 );
|
|
|
5323 event.preventDefault();
|
|
|
5324 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
|
|
|
5325 last.focus( 1 );
|
|
|
5326 event.preventDefault();
|
|
|
5327 }
|
|
|
5328 },
|
|
|
5329 mousedown: function( event ) {
|
|
|
5330 if ( this._moveToTop( event ) ) {
|
|
|
5331 this._focusTabbable();
|
|
|
5332 }
|
|
|
5333 }
|
|
|
5334 });
|
|
|
5335
|
|
|
5336 // We assume that any existing aria-describedby attribute means
|
|
|
5337 // that the dialog content is marked up properly
|
|
|
5338 // otherwise we brute force the content as the description
|
|
|
5339 if ( !this.element.find("[aria-describedby]").length ) {
|
|
|
5340 this.uiDialog.attr({
|
|
|
5341 "aria-describedby": this.element.uniqueId().attr("id")
|
|
|
5342 });
|
|
|
5343 }
|
|
|
5344 },
|
|
|
5345
|
|
|
5346 _createTitlebar: function() {
|
|
|
5347 var uiDialogTitle;
|
|
|
5348
|
|
|
5349 this.uiDialogTitlebar = $("<div>")
|
|
|
5350 .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
|
|
|
5351 .prependTo( this.uiDialog );
|
|
|
5352 this._on( this.uiDialogTitlebar, {
|
|
|
5353 mousedown: function( event ) {
|
|
|
5354 // Don't prevent click on close button (#8838)
|
|
|
5355 // Focusing a dialog that is partially scrolled out of view
|
|
|
5356 // causes the browser to scroll it into view, preventing the click event
|
|
|
5357 if ( !$( event.target ).closest(".ui-dialog-titlebar-close") ) {
|
|
|
5358 // Dialog isn't getting focus when dragging (#8063)
|
|
|
5359 this.uiDialog.focus();
|
|
|
5360 }
|
|
|
5361 }
|
|
|
5362 });
|
|
|
5363
|
|
|
5364 // support: IE
|
|
|
5365 // Use type="button" to prevent enter keypresses in textboxes from closing the
|
|
|
5366 // dialog in IE (#9312)
|
|
|
5367 this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
|
|
|
5368 .button({
|
|
|
5369 label: this.options.closeText,
|
|
|
5370 icons: {
|
|
|
5371 primary: "ui-icon-closethick"
|
|
|
5372 },
|
|
|
5373 text: false
|
|
|
5374 })
|
|
|
5375 .addClass("ui-dialog-titlebar-close")
|
|
|
5376 .appendTo( this.uiDialogTitlebar );
|
|
|
5377 this._on( this.uiDialogTitlebarClose, {
|
|
|
5378 click: function( event ) {
|
|
|
5379 event.preventDefault();
|
|
|
5380 this.close( event );
|
|
|
5381 }
|
|
|
5382 });
|
|
|
5383
|
|
|
5384 uiDialogTitle = $("<span>")
|
|
|
5385 .uniqueId()
|
|
|
5386 .addClass("ui-dialog-title")
|
|
|
5387 .prependTo( this.uiDialogTitlebar );
|
|
|
5388 this._title( uiDialogTitle );
|
|
|
5389
|
|
|
5390 this.uiDialog.attr({
|
|
|
5391 "aria-labelledby": uiDialogTitle.attr("id")
|
|
|
5392 });
|
|
|
5393 },
|
|
|
5394
|
|
|
5395 _title: function( title ) {
|
|
|
5396 if ( !this.options.title ) {
|
|
|
5397 title.html(" ");
|
|
|
5398 }
|
|
|
5399 title.text( this.options.title );
|
|
|
5400 },
|
|
|
5401
|
|
|
5402 _createButtonPane: function() {
|
|
|
5403 this.uiDialogButtonPane = $("<div>")
|
|
|
5404 .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
|
|
|
5405
|
|
|
5406 this.uiButtonSet = $("<div>")
|
|
|
5407 .addClass("ui-dialog-buttonset")
|
|
|
5408 .appendTo( this.uiDialogButtonPane );
|
|
|
5409
|
|
|
5410 this._createButtons();
|
|
|
5411 },
|
|
|
5412
|
|
|
5413 _createButtons: function() {
|
|
|
5414 var that = this,
|
|
|
5415 buttons = this.options.buttons;
|
|
|
5416
|
|
|
5417 // if we already have a button pane, remove it
|
|
|
5418 this.uiDialogButtonPane.remove();
|
|
|
5419 this.uiButtonSet.empty();
|
|
|
5420
|
|
|
5421 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
|
|
|
5422 this.uiDialog.removeClass("ui-dialog-buttons");
|
|
|
5423 return;
|
|
|
5424 }
|
|
|
5425
|
|
|
5426 $.each( buttons, function( name, props ) {
|
|
|
5427 var click, buttonOptions;
|
|
|
5428 props = $.isFunction( props ) ?
|
|
|
5429 { click: props, text: name } :
|
|
|
5430 props;
|
|
|
5431 // Default to a non-submitting button
|
|
|
5432 props = $.extend( { type: "button" }, props );
|
|
|
5433 // Change the context for the click callback to be the main element
|
|
|
5434 click = props.click;
|
|
|
5435 props.click = function() {
|
|
|
5436 click.apply( that.element[0], arguments );
|
|
|
5437 };
|
|
|
5438 buttonOptions = {
|
|
|
5439 icons: props.icons,
|
|
|
5440 text: props.showText
|
|
|
5441 };
|
|
|
5442 delete props.icons;
|
|
|
5443 delete props.showText;
|
|
|
5444 $( "<button></button>", props )
|
|
|
5445 .button( buttonOptions )
|
|
|
5446 .appendTo( that.uiButtonSet );
|
|
|
5447 });
|
|
|
5448 this.uiDialog.addClass("ui-dialog-buttons");
|
|
|
5449 this.uiDialogButtonPane.appendTo( this.uiDialog );
|
|
|
5450 },
|
|
|
5451
|
|
|
5452 _makeDraggable: function() {
|
|
|
5453 var that = this,
|
|
|
5454 options = this.options;
|
|
|
5455
|
|
|
5456 function filteredUi( ui ) {
|
|
|
5457 return {
|
|
|
5458 position: ui.position,
|
|
|
5459 offset: ui.offset
|
|
|
5460 };
|
|
|
5461 }
|
|
|
5462
|
|
|
5463 this.uiDialog.draggable({
|
|
|
5464 cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
|
|
|
5465 handle: ".ui-dialog-titlebar",
|
|
|
5466 containment: "document",
|
|
|
5467 start: function( event, ui ) {
|
|
|
5468 $( this ).addClass("ui-dialog-dragging");
|
|
|
5469 that._blockFrames();
|
|
|
5470 that._trigger( "dragStart", event, filteredUi( ui ) );
|
|
|
5471 },
|
|
|
5472 drag: function( event, ui ) {
|
|
|
5473 that._trigger( "drag", event, filteredUi( ui ) );
|
|
|
5474 },
|
|
|
5475 stop: function( event, ui ) {
|
|
|
5476 options.position = [
|
|
|
5477 ui.position.left - that.document.scrollLeft(),
|
|
|
5478 ui.position.top - that.document.scrollTop()
|
|
|
5479 ];
|
|
|
5480 $( this ).removeClass("ui-dialog-dragging");
|
|
|
5481 that._unblockFrames();
|
|
|
5482 that._trigger( "dragStop", event, filteredUi( ui ) );
|
|
|
5483 }
|
|
|
5484 });
|
|
|
5485 },
|
|
|
5486
|
|
|
5487 _makeResizable: function() {
|
|
|
5488 var that = this,
|
|
|
5489 options = this.options,
|
|
|
5490 handles = options.resizable,
|
|
|
5491 // .ui-resizable has position: relative defined in the stylesheet
|
|
|
5492 // but dialogs have to use absolute or fixed positioning
|
|
|
5493 position = this.uiDialog.css("position"),
|
|
|
5494 resizeHandles = typeof handles === "string" ?
|
|
|
5495 handles :
|
|
|
5496 "n,e,s,w,se,sw,ne,nw";
|
|
|
5497
|
|
|
5498 function filteredUi( ui ) {
|
|
|
5499 return {
|
|
|
5500 originalPosition: ui.originalPosition,
|
|
|
5501 originalSize: ui.originalSize,
|
|
|
5502 position: ui.position,
|
|
|
5503 size: ui.size
|
|
|
5504 };
|
|
|
5505 }
|
|
|
5506
|
|
|
5507 this.uiDialog.resizable({
|
|
|
5508 cancel: ".ui-dialog-content",
|
|
|
5509 containment: "document",
|
|
|
5510 alsoResize: this.element,
|
|
|
5511 maxWidth: options.maxWidth,
|
|
|
5512 maxHeight: options.maxHeight,
|
|
|
5513 minWidth: options.minWidth,
|
|
|
5514 minHeight: this._minHeight(),
|
|
|
5515 handles: resizeHandles,
|
|
|
5516 start: function( event, ui ) {
|
|
|
5517 $( this ).addClass("ui-dialog-resizing");
|
|
|
5518 that._blockFrames();
|
|
|
5519 that._trigger( "resizeStart", event, filteredUi( ui ) );
|
|
|
5520 },
|
|
|
5521 resize: function( event, ui ) {
|
|
|
5522 that._trigger( "resize", event, filteredUi( ui ) );
|
|
|
5523 },
|
|
|
5524 stop: function( event, ui ) {
|
|
|
5525 options.height = $( this ).height();
|
|
|
5526 options.width = $( this ).width();
|
|
|
5527 $( this ).removeClass("ui-dialog-resizing");
|
|
|
5528 that._unblockFrames();
|
|
|
5529 that._trigger( "resizeStop", event, filteredUi( ui ) );
|
|
|
5530 }
|
|
|
5531 })
|
|
|
5532 .css( "position", position );
|
|
|
5533 },
|
|
|
5534
|
|
|
5535 _minHeight: function() {
|
|
|
5536 var options = this.options;
|
|
|
5537
|
|
|
5538 return options.height === "auto" ?
|
|
|
5539 options.minHeight :
|
|
|
5540 Math.min( options.minHeight, options.height );
|
|
|
5541 },
|
|
|
5542
|
|
|
5543 _position: function() {
|
|
|
5544 // Need to show the dialog to get the actual offset in the position plugin
|
|
|
5545 var isVisible = this.uiDialog.is(":visible");
|
|
|
5546 if ( !isVisible ) {
|
|
|
5547 this.uiDialog.show();
|
|
|
5548 }
|
|
|
5549 this.uiDialog.position( this.options.position );
|
|
|
5550 if ( !isVisible ) {
|
|
|
5551 this.uiDialog.hide();
|
|
|
5552 }
|
|
|
5553 },
|
|
|
5554
|
|
|
5555 _setOptions: function( options ) {
|
|
|
5556 var that = this,
|
|
|
5557 resize = false,
|
|
|
5558 resizableOptions = {};
|
|
|
5559
|
|
|
5560 $.each( options, function( key, value ) {
|
|
|
5561 that._setOption( key, value );
|
|
|
5562
|
|
|
5563 if ( key in sizeRelatedOptions ) {
|
|
|
5564 resize = true;
|
|
|
5565 }
|
|
|
5566 if ( key in resizableRelatedOptions ) {
|
|
|
5567 resizableOptions[ key ] = value;
|
|
|
5568 }
|
|
|
5569 });
|
|
|
5570
|
|
|
5571 if ( resize ) {
|
|
|
5572 this._size();
|
|
|
5573 this._position();
|
|
|
5574 }
|
|
|
5575 if ( this.uiDialog.is(":data(ui-resizable)") ) {
|
|
|
5576 this.uiDialog.resizable( "option", resizableOptions );
|
|
|
5577 }
|
|
|
5578 },
|
|
|
5579
|
|
|
5580 _setOption: function( key, value ) {
|
|
|
5581 var isDraggable, isResizable,
|
|
|
5582 uiDialog = this.uiDialog;
|
|
|
5583
|
|
|
5584 if ( key === "dialogClass" ) {
|
|
|
5585 uiDialog
|
|
|
5586 .removeClass( this.options.dialogClass )
|
|
|
5587 .addClass( value );
|
|
|
5588 }
|
|
|
5589
|
|
|
5590 if ( key === "disabled" ) {
|
|
|
5591 return;
|
|
|
5592 }
|
|
|
5593
|
|
|
5594 this._super( key, value );
|
|
|
5595
|
|
|
5596 if ( key === "appendTo" ) {
|
|
|
5597 this.uiDialog.appendTo( this._appendTo() );
|
|
|
5598 }
|
|
|
5599
|
|
|
5600 if ( key === "buttons" ) {
|
|
|
5601 this._createButtons();
|
|
|
5602 }
|
|
|
5603
|
|
|
5604 if ( key === "closeText" ) {
|
|
|
5605 this.uiDialogTitlebarClose.button({
|
|
|
5606 // Ensure that we always pass a string
|
|
|
5607 label: "" + value
|
|
|
5608 });
|
|
|
5609 }
|
|
|
5610
|
|
|
5611 if ( key === "draggable" ) {
|
|
|
5612 isDraggable = uiDialog.is(":data(ui-draggable)");
|
|
|
5613 if ( isDraggable && !value ) {
|
|
|
5614 uiDialog.draggable("destroy");
|
|
|
5615 }
|
|
|
5616
|
|
|
5617 if ( !isDraggable && value ) {
|
|
|
5618 this._makeDraggable();
|
|
|
5619 }
|
|
|
5620 }
|
|
|
5621
|
|
|
5622 if ( key === "position" ) {
|
|
|
5623 this._position();
|
|
|
5624 }
|
|
|
5625
|
|
|
5626 if ( key === "resizable" ) {
|
|
|
5627 // currently resizable, becoming non-resizable
|
|
|
5628 isResizable = uiDialog.is(":data(ui-resizable)");
|
|
|
5629 if ( isResizable && !value ) {
|
|
|
5630 uiDialog.resizable("destroy");
|
|
|
5631 }
|
|
|
5632
|
|
|
5633 // currently resizable, changing handles
|
|
|
5634 if ( isResizable && typeof value === "string" ) {
|
|
|
5635 uiDialog.resizable( "option", "handles", value );
|
|
|
5636 }
|
|
|
5637
|
|
|
5638 // currently non-resizable, becoming resizable
|
|
|
5639 if ( !isResizable && value !== false ) {
|
|
|
5640 this._makeResizable();
|
|
|
5641 }
|
|
|
5642 }
|
|
|
5643
|
|
|
5644 if ( key === "title" ) {
|
|
|
5645 this._title( this.uiDialogTitlebar.find(".ui-dialog-title") );
|
|
|
5646 }
|
|
|
5647 },
|
|
|
5648
|
|
|
5649 _size: function() {
|
|
|
5650 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
|
|
|
5651 // divs will both have width and height set, so we need to reset them
|
|
|
5652 var nonContentHeight, minContentHeight, maxContentHeight,
|
|
|
5653 options = this.options;
|
|
|
5654
|
|
|
5655 // Reset content sizing
|
|
|
5656 this.element.show().css({
|
|
|
5657 width: "auto",
|
|
|
5658 minHeight: 0,
|
|
|
5659 maxHeight: "none",
|
|
|
5660 height: 0
|
|
|
5661 });
|
|
|
5662
|
|
|
5663 if ( options.minWidth > options.width ) {
|
|
|
5664 options.width = options.minWidth;
|
|
|
5665 }
|
|
|
5666
|
|
|
5667 // reset wrapper sizing
|
|
|
5668 // determine the height of all the non-content elements
|
|
|
5669 nonContentHeight = this.uiDialog.css({
|
|
|
5670 height: "auto",
|
|
|
5671 width: options.width
|
|
|
5672 })
|
|
|
5673 .outerHeight();
|
|
|
5674 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
|
|
|
5675 maxContentHeight = typeof options.maxHeight === "number" ?
|
|
|
5676 Math.max( 0, options.maxHeight - nonContentHeight ) :
|
|
|
5677 "none";
|
|
|
5678
|
|
|
5679 if ( options.height === "auto" ) {
|
|
|
5680 this.element.css({
|
|
|
5681 minHeight: minContentHeight,
|
|
|
5682 maxHeight: maxContentHeight,
|
|
|
5683 height: "auto"
|
|
|
5684 });
|
|
|
5685 } else {
|
|
|
5686 this.element.height( Math.max( 0, options.height - nonContentHeight ) );
|
|
|
5687 }
|
|
|
5688
|
|
|
5689 if (this.uiDialog.is(":data(ui-resizable)") ) {
|
|
|
5690 this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
|
|
|
5691 }
|
|
|
5692 },
|
|
|
5693
|
|
|
5694 _blockFrames: function() {
|
|
|
5695 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
|
|
|
5696 var iframe = $( this );
|
|
|
5697
|
|
|
5698 return $( "<div>" )
|
|
|
5699 .css({
|
|
|
5700 position: "absolute",
|
|
|
5701 width: iframe.outerWidth(),
|
|
|
5702 height: iframe.outerHeight()
|
|
|
5703 })
|
|
|
5704 .appendTo( iframe.parent() )
|
|
|
5705 .offset( iframe.offset() )[0];
|
|
|
5706 });
|
|
|
5707 },
|
|
|
5708
|
|
|
5709 _unblockFrames: function() {
|
|
|
5710 if ( this.iframeBlocks ) {
|
|
|
5711 this.iframeBlocks.remove();
|
|
|
5712 delete this.iframeBlocks;
|
|
|
5713 }
|
|
|
5714 },
|
|
|
5715
|
|
|
5716 _allowInteraction: function( event ) {
|
|
|
5717 if ( $( event.target ).closest(".ui-dialog").length ) {
|
|
|
5718 return true;
|
|
|
5719 }
|
|
|
5720
|
|
|
5721 // TODO: Remove hack when datepicker implements
|
|
|
5722 // the .ui-front logic (#8989)
|
|
|
5723 return !!$( event.target ).closest(".ui-datepicker").length;
|
|
|
5724 },
|
|
|
5725
|
|
|
5726 _createOverlay: function() {
|
|
|
5727 if ( !this.options.modal ) {
|
|
|
5728 return;
|
|
|
5729 }
|
|
|
5730
|
|
|
5731 var that = this,
|
|
|
5732 widgetFullName = this.widgetFullName;
|
|
|
5733 if ( !$.ui.dialog.overlayInstances ) {
|
|
|
5734 // Prevent use of anchors and inputs.
|
|
|
5735 // We use a delay in case the overlay is created from an
|
|
|
5736 // event that we're going to be cancelling. (#2804)
|
|
|
5737 this._delay(function() {
|
|
|
5738 // Handle .dialog().dialog("close") (#4065)
|
|
|
5739 if ( $.ui.dialog.overlayInstances ) {
|
|
|
5740 this.document.bind( "focusin.dialog", function( event ) {
|
|
|
5741 if ( !that._allowInteraction( event ) ) {
|
|
|
5742 event.preventDefault();
|
|
|
5743 $(".ui-dialog:visible:last .ui-dialog-content")
|
|
|
5744 .data( widgetFullName )._focusTabbable();
|
|
|
5745 }
|
|
|
5746 });
|
|
|
5747 }
|
|
|
5748 });
|
|
|
5749 }
|
|
|
5750
|
|
|
5751 this.overlay = $("<div>")
|
|
|
5752 .addClass("ui-widget-overlay ui-front")
|
|
|
5753 .appendTo( this._appendTo() );
|
|
|
5754 this._on( this.overlay, {
|
|
|
5755 mousedown: "_keepFocus"
|
|
|
5756 });
|
|
|
5757 $.ui.dialog.overlayInstances++;
|
|
|
5758 },
|
|
|
5759
|
|
|
5760 _destroyOverlay: function() {
|
|
|
5761 if ( !this.options.modal ) {
|
|
|
5762 return;
|
|
|
5763 }
|
|
|
5764
|
|
|
5765 if ( this.overlay ) {
|
|
|
5766 $.ui.dialog.overlayInstances--;
|
|
|
5767
|
|
|
5768 if ( !$.ui.dialog.overlayInstances ) {
|
|
|
5769 this.document.unbind( "focusin.dialog" );
|
|
|
5770 }
|
|
|
5771 this.overlay.remove();
|
|
|
5772 this.overlay = null;
|
|
|
5773 }
|
|
|
5774 }
|
|
|
5775 });
|
|
|
5776
|
|
|
5777 $.ui.dialog.overlayInstances = 0;
|
|
|
5778
|
|
|
5779 // DEPRECATED
|
|
|
5780 if ( $.uiBackCompat !== false ) {
|
|
|
5781 // position option with array notation
|
|
|
5782 // just override with old implementation
|
|
|
5783 $.widget( "ui.dialog", $.ui.dialog, {
|
|
|
5784 _position: function() {
|
|
|
5785 var position = this.options.position,
|
|
|
5786 myAt = [],
|
|
|
5787 offset = [ 0, 0 ],
|
|
|
5788 isVisible;
|
|
|
5789
|
|
|
5790 if ( position ) {
|
|
|
5791 if ( typeof position === "string" || (typeof position === "object" && "0" in position ) ) {
|
|
|
5792 myAt = position.split ? position.split(" ") : [ position[0], position[1] ];
|
|
|
5793 if ( myAt.length === 1 ) {
|
|
|
5794 myAt[1] = myAt[0];
|
|
|
5795 }
|
|
|
5796
|
|
|
5797 $.each( [ "left", "top" ], function( i, offsetPosition ) {
|
|
|
5798 if ( +myAt[ i ] === myAt[ i ] ) {
|
|
|
5799 offset[ i ] = myAt[ i ];
|
|
|
5800 myAt[ i ] = offsetPosition;
|
|
|
5801 }
|
|
|
5802 });
|
|
|
5803
|
|
|
5804 position = {
|
|
|
5805 my: myAt[0] + (offset[0] < 0 ? offset[0] : "+" + offset[0]) + " " +
|
|
|
5806 myAt[1] + (offset[1] < 0 ? offset[1] : "+" + offset[1]),
|
|
|
5807 at: myAt.join(" ")
|
|
|
5808 };
|
|
|
5809 }
|
|
|
5810
|
|
|
5811 position = $.extend( {}, $.ui.dialog.prototype.options.position, position );
|
|
|
5812 } else {
|
|
|
5813 position = $.ui.dialog.prototype.options.position;
|
|
|
5814 }
|
|
|
5815
|
|
|
5816 // need to show the dialog to get the actual offset in the position plugin
|
|
|
5817 isVisible = this.uiDialog.is(":visible");
|
|
|
5818 if ( !isVisible ) {
|
|
|
5819 this.uiDialog.show();
|
|
|
5820 }
|
|
|
5821 this.uiDialog.position( position );
|
|
|
5822 if ( !isVisible ) {
|
|
|
5823 this.uiDialog.hide();
|
|
|
5824 }
|
|
|
5825 }
|
|
|
5826 });
|
|
|
5827 }
|
|
|
5828
|
|
|
5829 }( jQuery ) );
|
|
|
5830 (function( $, undefined ) {
|
|
|
5831
|
|
|
5832 $.widget("ui.draggable", $.ui.mouse, {
|
|
|
5833 version: "1.10.4",
|
|
|
5834 widgetEventPrefix: "drag",
|
|
|
5835 options: {
|
|
|
5836 addClasses: true,
|
|
|
5837 appendTo: "parent",
|
|
|
5838 axis: false,
|
|
|
5839 connectToSortable: false,
|
|
|
5840 containment: false,
|
|
|
5841 cursor: "auto",
|
|
|
5842 cursorAt: false,
|
|
|
5843 grid: false,
|
|
|
5844 handle: false,
|
|
|
5845 helper: "original",
|
|
|
5846 iframeFix: false,
|
|
|
5847 opacity: false,
|
|
|
5848 refreshPositions: false,
|
|
|
5849 revert: false,
|
|
|
5850 revertDuration: 500,
|
|
|
5851 scope: "default",
|
|
|
5852 scroll: true,
|
|
|
5853 scrollSensitivity: 20,
|
|
|
5854 scrollSpeed: 20,
|
|
|
5855 snap: false,
|
|
|
5856 snapMode: "both",
|
|
|
5857 snapTolerance: 20,
|
|
|
5858 stack: false,
|
|
|
5859 zIndex: false,
|
|
|
5860
|
|
|
5861 // callbacks
|
|
|
5862 drag: null,
|
|
|
5863 start: null,
|
|
|
5864 stop: null
|
|
|
5865 },
|
|
|
5866 _create: function() {
|
|
|
5867
|
|
|
5868 if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
|
|
|
5869 this.element[0].style.position = "relative";
|
|
|
5870 }
|
|
|
5871 if (this.options.addClasses){
|
|
|
5872 this.element.addClass("ui-draggable");
|
|
|
5873 }
|
|
|
5874 if (this.options.disabled){
|
|
|
5875 this.element.addClass("ui-draggable-disabled");
|
|
|
5876 }
|
|
|
5877
|
|
|
5878 this._mouseInit();
|
|
|
5879
|
|
|
5880 },
|
|
|
5881
|
|
|
5882 _destroy: function() {
|
|
|
5883 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
|
|
|
5884 this._mouseDestroy();
|
|
|
5885 },
|
|
|
5886
|
|
|
5887 _mouseCapture: function(event) {
|
|
|
5888
|
|
|
5889 var o = this.options;
|
|
|
5890
|
|
|
5891 // among others, prevent a drag on a resizable-handle
|
|
|
5892 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
|
|
|
5893 return false;
|
|
|
5894 }
|
|
|
5895
|
|
|
5896 //Quit if we're not on a valid handle
|
|
|
5897 this.handle = this._getHandle(event);
|
|
|
5898 if (!this.handle) {
|
|
|
5899 return false;
|
|
|
5900 }
|
|
|
5901
|
|
|
5902 $(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
|
|
|
5903 $("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
|
|
|
5904 .css({
|
|
|
5905 width: this.offsetWidth+"px", height: this.offsetHeight+"px",
|
|
|
5906 position: "absolute", opacity: "0.001", zIndex: 1000
|
|
|
5907 })
|
|
|
5908 .css($(this).offset())
|
|
|
5909 .appendTo("body");
|
|
|
5910 });
|
|
|
5911
|
|
|
5912 return true;
|
|
|
5913
|
|
|
5914 },
|
|
|
5915
|
|
|
5916 _mouseStart: function(event) {
|
|
|
5917
|
|
|
5918 var o = this.options;
|
|
|
5919
|
|
|
5920 //Create and append the visible helper
|
|
|
5921 this.helper = this._createHelper(event);
|
|
|
5922
|
|
|
5923 this.helper.addClass("ui-draggable-dragging");
|
|
|
5924
|
|
|
5925 //Cache the helper size
|
|
|
5926 this._cacheHelperProportions();
|
|
|
5927
|
|
|
5928 //If ddmanager is used for droppables, set the global draggable
|
|
|
5929 if($.ui.ddmanager) {
|
|
|
5930 $.ui.ddmanager.current = this;
|
|
|
5931 }
|
|
|
5932
|
|
|
5933 /*
|
|
|
5934 * - Position generation -
|
|
|
5935 * This block generates everything position related - it's the core of draggables.
|
|
|
5936 */
|
|
|
5937
|
|
|
5938 //Cache the margins of the original element
|
|
|
5939 this._cacheMargins();
|
|
|
5940
|
|
|
5941 //Store the helper's css position
|
|
|
5942 this.cssPosition = this.helper.css( "position" );
|
|
|
5943 this.scrollParent = this.helper.scrollParent();
|
|
|
5944 this.offsetParent = this.helper.offsetParent();
|
|
|
5945 this.offsetParentCssPosition = this.offsetParent.css( "position" );
|
|
|
5946
|
|
|
5947 //The element's absolute position on the page minus margins
|
|
|
5948 this.offset = this.positionAbs = this.element.offset();
|
|
|
5949 this.offset = {
|
|
|
5950 top: this.offset.top - this.margins.top,
|
|
|
5951 left: this.offset.left - this.margins.left
|
|
|
5952 };
|
|
|
5953
|
|
|
5954 //Reset scroll cache
|
|
|
5955 this.offset.scroll = false;
|
|
|
5956
|
|
|
5957 $.extend(this.offset, {
|
|
|
5958 click: { //Where the click happened, relative to the element
|
|
|
5959 left: event.pageX - this.offset.left,
|
|
|
5960 top: event.pageY - this.offset.top
|
|
|
5961 },
|
|
|
5962 parent: this._getParentOffset(),
|
|
|
5963 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
|
|
|
5964 });
|
|
|
5965
|
|
|
5966 //Generate the original position
|
|
|
5967 this.originalPosition = this.position = this._generatePosition(event);
|
|
|
5968 this.originalPageX = event.pageX;
|
|
|
5969 this.originalPageY = event.pageY;
|
|
|
5970
|
|
|
5971 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
|
|
|
5972 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
|
|
|
5973
|
|
|
5974 //Set a containment if given in the options
|
|
|
5975 this._setContainment();
|
|
|
5976
|
|
|
5977 //Trigger event + callbacks
|
|
|
5978 if(this._trigger("start", event) === false) {
|
|
|
5979 this._clear();
|
|
|
5980 return false;
|
|
|
5981 }
|
|
|
5982
|
|
|
5983 //Recache the helper size
|
|
|
5984 this._cacheHelperProportions();
|
|
|
5985
|
|
|
5986 //Prepare the droppable offsets
|
|
|
5987 if ($.ui.ddmanager && !o.dropBehaviour) {
|
|
|
5988 $.ui.ddmanager.prepareOffsets(this, event);
|
|
|
5989 }
|
|
|
5990
|
|
|
5991
|
|
|
5992 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
|
|
|
5993
|
|
|
5994 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
|
|
|
5995 if ( $.ui.ddmanager ) {
|
|
|
5996 $.ui.ddmanager.dragStart(this, event);
|
|
|
5997 }
|
|
|
5998
|
|
|
5999 return true;
|
|
|
6000 },
|
|
|
6001
|
|
|
6002 _mouseDrag: function(event, noPropagation) {
|
|
|
6003 // reset any necessary cached properties (see #5009)
|
|
|
6004 if ( this.offsetParentCssPosition === "fixed" ) {
|
|
|
6005 this.offset.parent = this._getParentOffset();
|
|
|
6006 }
|
|
|
6007
|
|
|
6008 //Compute the helpers position
|
|
|
6009 this.position = this._generatePosition(event);
|
|
|
6010 this.positionAbs = this._convertPositionTo("absolute");
|
|
|
6011
|
|
|
6012 //Call plugins and callbacks and use the resulting position if something is returned
|
|
|
6013 if (!noPropagation) {
|
|
|
6014 var ui = this._uiHash();
|
|
|
6015 if(this._trigger("drag", event, ui) === false) {
|
|
|
6016 this._mouseUp({});
|
|
|
6017 return false;
|
|
|
6018 }
|
|
|
6019 this.position = ui.position;
|
|
|
6020 }
|
|
|
6021
|
|
|
6022 if(!this.options.axis || this.options.axis !== "y") {
|
|
|
6023 this.helper[0].style.left = this.position.left+"px";
|
|
|
6024 }
|
|
|
6025 if(!this.options.axis || this.options.axis !== "x") {
|
|
|
6026 this.helper[0].style.top = this.position.top+"px";
|
|
|
6027 }
|
|
|
6028 if($.ui.ddmanager) {
|
|
|
6029 $.ui.ddmanager.drag(this, event);
|
|
|
6030 }
|
|
|
6031
|
|
|
6032 return false;
|
|
|
6033 },
|
|
|
6034
|
|
|
6035 _mouseStop: function(event) {
|
|
|
6036
|
|
|
6037 //If we are using droppables, inform the manager about the drop
|
|
|
6038 var that = this,
|
|
|
6039 dropped = false;
|
|
|
6040 if ($.ui.ddmanager && !this.options.dropBehaviour) {
|
|
|
6041 dropped = $.ui.ddmanager.drop(this, event);
|
|
|
6042 }
|
|
|
6043
|
|
|
6044 //if a drop comes from outside (a sortable)
|
|
|
6045 if(this.dropped) {
|
|
|
6046 dropped = this.dropped;
|
|
|
6047 this.dropped = false;
|
|
|
6048 }
|
|
|
6049
|
|
|
6050 //if the original element is no longer in the DOM don't bother to continue (see #8269)
|
|
|
6051 if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
|
|
|
6052 return false;
|
|
|
6053 }
|
|
|
6054
|
|
|
6055 if((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
|
|
|
6056 $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
|
|
|
6057 if(that._trigger("stop", event) !== false) {
|
|
|
6058 that._clear();
|
|
|
6059 }
|
|
|
6060 });
|
|
|
6061 } else {
|
|
|
6062 if(this._trigger("stop", event) !== false) {
|
|
|
6063 this._clear();
|
|
|
6064 }
|
|
|
6065 }
|
|
|
6066
|
|
|
6067 return false;
|
|
|
6068 },
|
|
|
6069
|
|
|
6070 _mouseUp: function(event) {
|
|
|
6071 //Remove frame helpers
|
|
|
6072 $("div.ui-draggable-iframeFix").each(function() {
|
|
|
6073 this.parentNode.removeChild(this);
|
|
|
6074 });
|
|
|
6075
|
|
|
6076 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
|
|
|
6077 if( $.ui.ddmanager ) {
|
|
|
6078 $.ui.ddmanager.dragStop(this, event);
|
|
|
6079 }
|
|
|
6080
|
|
|
6081 return $.ui.mouse.prototype._mouseUp.call(this, event);
|
|
|
6082 },
|
|
|
6083
|
|
|
6084 cancel: function() {
|
|
|
6085
|
|
|
6086 if(this.helper.is(".ui-draggable-dragging")) {
|
|
|
6087 this._mouseUp({});
|
|
|
6088 } else {
|
|
|
6089 this._clear();
|
|
|
6090 }
|
|
|
6091
|
|
|
6092 return this;
|
|
|
6093
|
|
|
6094 },
|
|
|
6095
|
|
|
6096 _getHandle: function(event) {
|
|
|
6097 return this.options.handle ?
|
|
|
6098 !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
|
|
|
6099 true;
|
|
|
6100 },
|
|
|
6101
|
|
|
6102 _createHelper: function(event) {
|
|
|
6103
|
|
|
6104 var o = this.options,
|
|
|
6105 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
|
|
|
6106
|
|
|
6107 if(!helper.parents("body").length) {
|
|
|
6108 helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
|
|
|
6109 }
|
|
|
6110
|
|
|
6111 if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
|
|
|
6112 helper.css("position", "absolute");
|
|
|
6113 }
|
|
|
6114
|
|
|
6115 return helper;
|
|
|
6116
|
|
|
6117 },
|
|
|
6118
|
|
|
6119 _adjustOffsetFromHelper: function(obj) {
|
|
|
6120 if (typeof obj === "string") {
|
|
|
6121 obj = obj.split(" ");
|
|
|
6122 }
|
|
|
6123 if ($.isArray(obj)) {
|
|
|
6124 obj = {left: +obj[0], top: +obj[1] || 0};
|
|
|
6125 }
|
|
|
6126 if ("left" in obj) {
|
|
|
6127 this.offset.click.left = obj.left + this.margins.left;
|
|
|
6128 }
|
|
|
6129 if ("right" in obj) {
|
|
|
6130 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
|
|
|
6131 }
|
|
|
6132 if ("top" in obj) {
|
|
|
6133 this.offset.click.top = obj.top + this.margins.top;
|
|
|
6134 }
|
|
|
6135 if ("bottom" in obj) {
|
|
|
6136 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
|
|
|
6137 }
|
|
|
6138 },
|
|
|
6139
|
|
|
6140 _getParentOffset: function() {
|
|
|
6141
|
|
|
6142 //Get the offsetParent and cache its position
|
|
|
6143 var po = this.offsetParent.offset();
|
|
|
6144
|
|
|
6145 // This is a special case where we need to modify a offset calculated on start, since the following happened:
|
|
|
6146 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
|
|
|
6147 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
|
|
|
6148 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
|
|
|
6149 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
|
|
|
6150 po.left += this.scrollParent.scrollLeft();
|
|
|
6151 po.top += this.scrollParent.scrollTop();
|
|
|
6152 }
|
|
|
6153
|
|
|
6154 //This needs to be actually done for all browsers, since pageX/pageY includes this information
|
|
|
6155 //Ugly IE fix
|
|
|
6156 if((this.offsetParent[0] === document.body) ||
|
|
|
6157 (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
|
|
|
6158 po = { top: 0, left: 0 };
|
|
|
6159 }
|
|
|
6160
|
|
|
6161 return {
|
|
|
6162 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
|
|
|
6163 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
|
|
|
6164 };
|
|
|
6165
|
|
|
6166 },
|
|
|
6167
|
|
|
6168 _getRelativeOffset: function() {
|
|
|
6169
|
|
|
6170 if(this.cssPosition === "relative") {
|
|
|
6171 var p = this.element.position();
|
|
|
6172 return {
|
|
|
6173 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
|
|
|
6174 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
|
|
|
6175 };
|
|
|
6176 } else {
|
|
|
6177 return { top: 0, left: 0 };
|
|
|
6178 }
|
|
|
6179
|
|
|
6180 },
|
|
|
6181
|
|
|
6182 _cacheMargins: function() {
|
|
|
6183 this.margins = {
|
|
|
6184 left: (parseInt(this.element.css("marginLeft"),10) || 0),
|
|
|
6185 top: (parseInt(this.element.css("marginTop"),10) || 0),
|
|
|
6186 right: (parseInt(this.element.css("marginRight"),10) || 0),
|
|
|
6187 bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
|
|
|
6188 };
|
|
|
6189 },
|
|
|
6190
|
|
|
6191 _cacheHelperProportions: function() {
|
|
|
6192 this.helperProportions = {
|
|
|
6193 width: this.helper.outerWidth(),
|
|
|
6194 height: this.helper.outerHeight()
|
|
|
6195 };
|
|
|
6196 },
|
|
|
6197
|
|
|
6198 _setContainment: function() {
|
|
|
6199
|
|
|
6200 var over, c, ce,
|
|
|
6201 o = this.options;
|
|
|
6202
|
|
|
6203 if ( !o.containment ) {
|
|
|
6204 this.containment = null;
|
|
|
6205 return;
|
|
|
6206 }
|
|
|
6207
|
|
|
6208 if ( o.containment === "window" ) {
|
|
|
6209 this.containment = [
|
|
|
6210 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
|
|
|
6211 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
|
|
|
6212 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
|
|
|
6213 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
|
|
|
6214 ];
|
|
|
6215 return;
|
|
|
6216 }
|
|
|
6217
|
|
|
6218 if ( o.containment === "document") {
|
|
|
6219 this.containment = [
|
|
|
6220 0,
|
|
|
6221 0,
|
|
|
6222 $( document ).width() - this.helperProportions.width - this.margins.left,
|
|
|
6223 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
|
|
|
6224 ];
|
|
|
6225 return;
|
|
|
6226 }
|
|
|
6227
|
|
|
6228 if ( o.containment.constructor === Array ) {
|
|
|
6229 this.containment = o.containment;
|
|
|
6230 return;
|
|
|
6231 }
|
|
|
6232
|
|
|
6233 if ( o.containment === "parent" ) {
|
|
|
6234 o.containment = this.helper[ 0 ].parentNode;
|
|
|
6235 }
|
|
|
6236
|
|
|
6237 c = $( o.containment );
|
|
|
6238 ce = c[ 0 ];
|
|
|
6239
|
|
|
6240 if( !ce ) {
|
|
|
6241 return;
|
|
|
6242 }
|
|
|
6243
|
|
|
6244 over = c.css( "overflow" ) !== "hidden";
|
|
|
6245
|
|
|
6246 this.containment = [
|
|
|
6247 ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
|
|
|
6248 ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
|
|
|
6249 ( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) - ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) - this.helperProportions.width - this.margins.left - this.margins.right,
|
|
|
6250 ( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) - ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) - this.helperProportions.height - this.margins.top - this.margins.bottom
|
|
|
6251 ];
|
|
|
6252 this.relative_container = c;
|
|
|
6253 },
|
|
|
6254
|
|
|
6255 _convertPositionTo: function(d, pos) {
|
|
|
6256
|
|
|
6257 if(!pos) {
|
|
|
6258 pos = this.position;
|
|
|
6259 }
|
|
|
6260
|
|
|
6261 var mod = d === "absolute" ? 1 : -1,
|
|
|
6262 scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
|
|
|
6263
|
|
|
6264 //Cache the scroll
|
|
|
6265 if (!this.offset.scroll) {
|
|
|
6266 this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
|
|
|
6267 }
|
|
|
6268
|
|
|
6269 return {
|
|
|
6270 top: (
|
|
|
6271 pos.top + // The absolute mouse position
|
|
|
6272 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
6273 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
|
|
|
6274 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
|
|
|
6275 ),
|
|
|
6276 left: (
|
|
|
6277 pos.left + // The absolute mouse position
|
|
|
6278 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
6279 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
|
|
|
6280 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
|
|
|
6281 )
|
|
|
6282 };
|
|
|
6283
|
|
|
6284 },
|
|
|
6285
|
|
|
6286 _generatePosition: function(event) {
|
|
|
6287
|
|
|
6288 var containment, co, top, left,
|
|
|
6289 o = this.options,
|
|
|
6290 scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
|
|
|
6291 pageX = event.pageX,
|
|
|
6292 pageY = event.pageY;
|
|
|
6293
|
|
|
6294 //Cache the scroll
|
|
|
6295 if (!this.offset.scroll) {
|
|
|
6296 this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
|
|
|
6297 }
|
|
|
6298
|
|
|
6299 /*
|
|
|
6300 * - Position constraining -
|
|
|
6301 * Constrain the position to a mix of grid, containment.
|
|
|
6302 */
|
|
|
6303
|
|
|
6304 // If we are not dragging yet, we won't check for options
|
|
|
6305 if ( this.originalPosition ) {
|
|
|
6306 if ( this.containment ) {
|
|
|
6307 if ( this.relative_container ){
|
|
|
6308 co = this.relative_container.offset();
|
|
|
6309 containment = [
|
|
|
6310 this.containment[ 0 ] + co.left,
|
|
|
6311 this.containment[ 1 ] + co.top,
|
|
|
6312 this.containment[ 2 ] + co.left,
|
|
|
6313 this.containment[ 3 ] + co.top
|
|
|
6314 ];
|
|
|
6315 }
|
|
|
6316 else {
|
|
|
6317 containment = this.containment;
|
|
|
6318 }
|
|
|
6319
|
|
|
6320 if(event.pageX - this.offset.click.left < containment[0]) {
|
|
|
6321 pageX = containment[0] + this.offset.click.left;
|
|
|
6322 }
|
|
|
6323 if(event.pageY - this.offset.click.top < containment[1]) {
|
|
|
6324 pageY = containment[1] + this.offset.click.top;
|
|
|
6325 }
|
|
|
6326 if(event.pageX - this.offset.click.left > containment[2]) {
|
|
|
6327 pageX = containment[2] + this.offset.click.left;
|
|
|
6328 }
|
|
|
6329 if(event.pageY - this.offset.click.top > containment[3]) {
|
|
|
6330 pageY = containment[3] + this.offset.click.top;
|
|
|
6331 }
|
|
|
6332 }
|
|
|
6333
|
|
|
6334 if(o.grid) {
|
|
|
6335 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
|
|
|
6336 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
|
|
|
6337 pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
|
|
|
6338
|
|
|
6339 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
|
|
|
6340 pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
|
|
|
6341 }
|
|
|
6342
|
|
|
6343 }
|
|
|
6344
|
|
|
6345 return {
|
|
|
6346 top: (
|
|
|
6347 pageY - // The absolute mouse position
|
|
|
6348 this.offset.click.top - // Click offset (relative to the element)
|
|
|
6349 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
6350 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
|
|
|
6351 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
|
|
|
6352 ),
|
|
|
6353 left: (
|
|
|
6354 pageX - // The absolute mouse position
|
|
|
6355 this.offset.click.left - // Click offset (relative to the element)
|
|
|
6356 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
6357 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
|
|
|
6358 ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
|
|
|
6359 )
|
|
|
6360 };
|
|
|
6361
|
|
|
6362 },
|
|
|
6363
|
|
|
6364 _clear: function() {
|
|
|
6365 this.helper.removeClass("ui-draggable-dragging");
|
|
|
6366 if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
|
|
|
6367 this.helper.remove();
|
|
|
6368 }
|
|
|
6369 this.helper = null;
|
|
|
6370 this.cancelHelperRemoval = false;
|
|
|
6371 },
|
|
|
6372
|
|
|
6373 // From now on bulk stuff - mainly helpers
|
|
|
6374
|
|
|
6375 _trigger: function(type, event, ui) {
|
|
|
6376 ui = ui || this._uiHash();
|
|
|
6377 $.ui.plugin.call(this, type, [event, ui]);
|
|
|
6378 //The absolute position has to be recalculated after plugins
|
|
|
6379 if(type === "drag") {
|
|
|
6380 this.positionAbs = this._convertPositionTo("absolute");
|
|
|
6381 }
|
|
|
6382 return $.Widget.prototype._trigger.call(this, type, event, ui);
|
|
|
6383 },
|
|
|
6384
|
|
|
6385 plugins: {},
|
|
|
6386
|
|
|
6387 _uiHash: function() {
|
|
|
6388 return {
|
|
|
6389 helper: this.helper,
|
|
|
6390 position: this.position,
|
|
|
6391 originalPosition: this.originalPosition,
|
|
|
6392 offset: this.positionAbs
|
|
|
6393 };
|
|
|
6394 }
|
|
|
6395
|
|
|
6396 });
|
|
|
6397
|
|
|
6398 $.ui.plugin.add("draggable", "connectToSortable", {
|
|
|
6399 start: function(event, ui) {
|
|
|
6400
|
|
|
6401 var inst = $(this).data("ui-draggable"), o = inst.options,
|
|
|
6402 uiSortable = $.extend({}, ui, { item: inst.element });
|
|
|
6403 inst.sortables = [];
|
|
|
6404 $(o.connectToSortable).each(function() {
|
|
|
6405 var sortable = $.data(this, "ui-sortable");
|
|
|
6406 if (sortable && !sortable.options.disabled) {
|
|
|
6407 inst.sortables.push({
|
|
|
6408 instance: sortable,
|
|
|
6409 shouldRevert: sortable.options.revert
|
|
|
6410 });
|
|
|
6411 sortable.refreshPositions(); // Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
|
|
|
6412 sortable._trigger("activate", event, uiSortable);
|
|
|
6413 }
|
|
|
6414 });
|
|
|
6415
|
|
|
6416 },
|
|
|
6417 stop: function(event, ui) {
|
|
|
6418
|
|
|
6419 //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
|
|
|
6420 var inst = $(this).data("ui-draggable"),
|
|
|
6421 uiSortable = $.extend({}, ui, { item: inst.element });
|
|
|
6422
|
|
|
6423 $.each(inst.sortables, function() {
|
|
|
6424 if(this.instance.isOver) {
|
|
|
6425
|
|
|
6426 this.instance.isOver = 0;
|
|
|
6427
|
|
|
6428 inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
|
|
|
6429 this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
|
|
|
6430
|
|
|
6431 //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
|
|
|
6432 if(this.shouldRevert) {
|
|
|
6433 this.instance.options.revert = this.shouldRevert;
|
|
|
6434 }
|
|
|
6435
|
|
|
6436 //Trigger the stop of the sortable
|
|
|
6437 this.instance._mouseStop(event);
|
|
|
6438
|
|
|
6439 this.instance.options.helper = this.instance.options._helper;
|
|
|
6440
|
|
|
6441 //If the helper has been the original item, restore properties in the sortable
|
|
|
6442 if(inst.options.helper === "original") {
|
|
|
6443 this.instance.currentItem.css({ top: "auto", left: "auto" });
|
|
|
6444 }
|
|
|
6445
|
|
|
6446 } else {
|
|
|
6447 this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
|
|
|
6448 this.instance._trigger("deactivate", event, uiSortable);
|
|
|
6449 }
|
|
|
6450
|
|
|
6451 });
|
|
|
6452
|
|
|
6453 },
|
|
|
6454 drag: function(event, ui) {
|
|
|
6455
|
|
|
6456 var inst = $(this).data("ui-draggable"), that = this;
|
|
|
6457
|
|
|
6458 $.each(inst.sortables, function() {
|
|
|
6459
|
|
|
6460 var innermostIntersecting = false,
|
|
|
6461 thisSortable = this;
|
|
|
6462
|
|
|
6463 //Copy over some variables to allow calling the sortable's native _intersectsWith
|
|
|
6464 this.instance.positionAbs = inst.positionAbs;
|
|
|
6465 this.instance.helperProportions = inst.helperProportions;
|
|
|
6466 this.instance.offset.click = inst.offset.click;
|
|
|
6467
|
|
|
6468 if(this.instance._intersectsWith(this.instance.containerCache)) {
|
|
|
6469 innermostIntersecting = true;
|
|
|
6470 $.each(inst.sortables, function () {
|
|
|
6471 this.instance.positionAbs = inst.positionAbs;
|
|
|
6472 this.instance.helperProportions = inst.helperProportions;
|
|
|
6473 this.instance.offset.click = inst.offset.click;
|
|
|
6474 if (this !== thisSortable &&
|
|
|
6475 this.instance._intersectsWith(this.instance.containerCache) &&
|
|
|
6476 $.contains(thisSortable.instance.element[0], this.instance.element[0])
|
|
|
6477 ) {
|
|
|
6478 innermostIntersecting = false;
|
|
|
6479 }
|
|
|
6480 return innermostIntersecting;
|
|
|
6481 });
|
|
|
6482 }
|
|
|
6483
|
|
|
6484
|
|
|
6485 if(innermostIntersecting) {
|
|
|
6486 //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
|
|
|
6487 if(!this.instance.isOver) {
|
|
|
6488
|
|
|
6489 this.instance.isOver = 1;
|
|
|
6490 //Now we fake the start of dragging for the sortable instance,
|
|
|
6491 //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
|
|
|
6492 //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
|
|
|
6493 this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
|
|
|
6494 this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
|
|
|
6495 this.instance.options.helper = function() { return ui.helper[0]; };
|
|
|
6496
|
|
|
6497 event.target = this.instance.currentItem[0];
|
|
|
6498 this.instance._mouseCapture(event, true);
|
|
|
6499 this.instance._mouseStart(event, true, true);
|
|
|
6500
|
|
|
6501 //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
|
|
|
6502 this.instance.offset.click.top = inst.offset.click.top;
|
|
|
6503 this.instance.offset.click.left = inst.offset.click.left;
|
|
|
6504 this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
|
|
|
6505 this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
|
|
|
6506
|
|
|
6507 inst._trigger("toSortable", event);
|
|
|
6508 inst.dropped = this.instance.element; //draggable revert needs that
|
|
|
6509 //hack so receive/update callbacks work (mostly)
|
|
|
6510 inst.currentItem = inst.element;
|
|
|
6511 this.instance.fromOutside = inst;
|
|
|
6512
|
|
|
6513 }
|
|
|
6514
|
|
|
6515 //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
|
|
|
6516 if(this.instance.currentItem) {
|
|
|
6517 this.instance._mouseDrag(event);
|
|
|
6518 }
|
|
|
6519
|
|
|
6520 } else {
|
|
|
6521
|
|
|
6522 //If it doesn't intersect with the sortable, and it intersected before,
|
|
|
6523 //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
|
|
|
6524 if(this.instance.isOver) {
|
|
|
6525
|
|
|
6526 this.instance.isOver = 0;
|
|
|
6527 this.instance.cancelHelperRemoval = true;
|
|
|
6528
|
|
|
6529 //Prevent reverting on this forced stop
|
|
|
6530 this.instance.options.revert = false;
|
|
|
6531
|
|
|
6532 // The out event needs to be triggered independently
|
|
|
6533 this.instance._trigger("out", event, this.instance._uiHash(this.instance));
|
|
|
6534
|
|
|
6535 this.instance._mouseStop(event, true);
|
|
|
6536 this.instance.options.helper = this.instance.options._helper;
|
|
|
6537
|
|
|
6538 //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
|
|
|
6539 this.instance.currentItem.remove();
|
|
|
6540 if(this.instance.placeholder) {
|
|
|
6541 this.instance.placeholder.remove();
|
|
|
6542 }
|
|
|
6543
|
|
|
6544 inst._trigger("fromSortable", event);
|
|
|
6545 inst.dropped = false; //draggable revert needs that
|
|
|
6546 }
|
|
|
6547
|
|
|
6548 }
|
|
|
6549
|
|
|
6550 });
|
|
|
6551
|
|
|
6552 }
|
|
|
6553 });
|
|
|
6554
|
|
|
6555 $.ui.plugin.add("draggable", "cursor", {
|
|
|
6556 start: function() {
|
|
|
6557 var t = $("body"), o = $(this).data("ui-draggable").options;
|
|
|
6558 if (t.css("cursor")) {
|
|
|
6559 o._cursor = t.css("cursor");
|
|
|
6560 }
|
|
|
6561 t.css("cursor", o.cursor);
|
|
|
6562 },
|
|
|
6563 stop: function() {
|
|
|
6564 var o = $(this).data("ui-draggable").options;
|
|
|
6565 if (o._cursor) {
|
|
|
6566 $("body").css("cursor", o._cursor);
|
|
|
6567 }
|
|
|
6568 }
|
|
|
6569 });
|
|
|
6570
|
|
|
6571 $.ui.plugin.add("draggable", "opacity", {
|
|
|
6572 start: function(event, ui) {
|
|
|
6573 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
|
|
|
6574 if(t.css("opacity")) {
|
|
|
6575 o._opacity = t.css("opacity");
|
|
|
6576 }
|
|
|
6577 t.css("opacity", o.opacity);
|
|
|
6578 },
|
|
|
6579 stop: function(event, ui) {
|
|
|
6580 var o = $(this).data("ui-draggable").options;
|
|
|
6581 if(o._opacity) {
|
|
|
6582 $(ui.helper).css("opacity", o._opacity);
|
|
|
6583 }
|
|
|
6584 }
|
|
|
6585 });
|
|
|
6586
|
|
|
6587 $.ui.plugin.add("draggable", "scroll", {
|
|
|
6588 start: function() {
|
|
|
6589 var i = $(this).data("ui-draggable");
|
|
|
6590 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
|
|
|
6591 i.overflowOffset = i.scrollParent.offset();
|
|
|
6592 }
|
|
|
6593 },
|
|
|
6594 drag: function( event ) {
|
|
|
6595
|
|
|
6596 var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
|
|
|
6597
|
|
|
6598 if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
|
|
|
6599
|
|
|
6600 if(!o.axis || o.axis !== "x") {
|
|
|
6601 if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
|
|
|
6602 i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
|
|
|
6603 } else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
|
|
|
6604 i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
|
|
|
6605 }
|
|
|
6606 }
|
|
|
6607
|
|
|
6608 if(!o.axis || o.axis !== "y") {
|
|
|
6609 if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
|
|
|
6610 i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
|
|
|
6611 } else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
|
|
|
6612 i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
|
|
|
6613 }
|
|
|
6614 }
|
|
|
6615
|
|
|
6616 } else {
|
|
|
6617
|
|
|
6618 if(!o.axis || o.axis !== "x") {
|
|
|
6619 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
|
|
|
6620 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
|
|
|
6621 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
|
|
|
6622 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
|
|
|
6623 }
|
|
|
6624 }
|
|
|
6625
|
|
|
6626 if(!o.axis || o.axis !== "y") {
|
|
|
6627 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
|
|
|
6628 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
|
|
|
6629 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
|
|
|
6630 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
|
|
|
6631 }
|
|
|
6632 }
|
|
|
6633
|
|
|
6634 }
|
|
|
6635
|
|
|
6636 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
|
|
|
6637 $.ui.ddmanager.prepareOffsets(i, event);
|
|
|
6638 }
|
|
|
6639
|
|
|
6640 }
|
|
|
6641 });
|
|
|
6642
|
|
|
6643 $.ui.plugin.add("draggable", "snap", {
|
|
|
6644 start: function() {
|
|
|
6645
|
|
|
6646 var i = $(this).data("ui-draggable"),
|
|
|
6647 o = i.options;
|
|
|
6648
|
|
|
6649 i.snapElements = [];
|
|
|
6650
|
|
|
6651 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
|
|
|
6652 var $t = $(this),
|
|
|
6653 $o = $t.offset();
|
|
|
6654 if(this !== i.element[0]) {
|
|
|
6655 i.snapElements.push({
|
|
|
6656 item: this,
|
|
|
6657 width: $t.outerWidth(), height: $t.outerHeight(),
|
|
|
6658 top: $o.top, left: $o.left
|
|
|
6659 });
|
|
|
6660 }
|
|
|
6661 });
|
|
|
6662
|
|
|
6663 },
|
|
|
6664 drag: function(event, ui) {
|
|
|
6665
|
|
|
6666 var ts, bs, ls, rs, l, r, t, b, i, first,
|
|
|
6667 inst = $(this).data("ui-draggable"),
|
|
|
6668 o = inst.options,
|
|
|
6669 d = o.snapTolerance,
|
|
|
6670 x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
|
|
|
6671 y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
|
|
|
6672
|
|
|
6673 for (i = inst.snapElements.length - 1; i >= 0; i--){
|
|
|
6674
|
|
|
6675 l = inst.snapElements[i].left;
|
|
|
6676 r = l + inst.snapElements[i].width;
|
|
|
6677 t = inst.snapElements[i].top;
|
|
|
6678 b = t + inst.snapElements[i].height;
|
|
|
6679
|
|
|
6680 if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
|
|
|
6681 if(inst.snapElements[i].snapping) {
|
|
|
6682 (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
|
|
|
6683 }
|
|
|
6684 inst.snapElements[i].snapping = false;
|
|
|
6685 continue;
|
|
|
6686 }
|
|
|
6687
|
|
|
6688 if(o.snapMode !== "inner") {
|
|
|
6689 ts = Math.abs(t - y2) <= d;
|
|
|
6690 bs = Math.abs(b - y1) <= d;
|
|
|
6691 ls = Math.abs(l - x2) <= d;
|
|
|
6692 rs = Math.abs(r - x1) <= d;
|
|
|
6693 if(ts) {
|
|
|
6694 ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
|
|
|
6695 }
|
|
|
6696 if(bs) {
|
|
|
6697 ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
|
|
|
6698 }
|
|
|
6699 if(ls) {
|
|
|
6700 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
|
|
|
6701 }
|
|
|
6702 if(rs) {
|
|
|
6703 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
|
|
|
6704 }
|
|
|
6705 }
|
|
|
6706
|
|
|
6707 first = (ts || bs || ls || rs);
|
|
|
6708
|
|
|
6709 if(o.snapMode !== "outer") {
|
|
|
6710 ts = Math.abs(t - y1) <= d;
|
|
|
6711 bs = Math.abs(b - y2) <= d;
|
|
|
6712 ls = Math.abs(l - x1) <= d;
|
|
|
6713 rs = Math.abs(r - x2) <= d;
|
|
|
6714 if(ts) {
|
|
|
6715 ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
|
|
|
6716 }
|
|
|
6717 if(bs) {
|
|
|
6718 ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
|
|
|
6719 }
|
|
|
6720 if(ls) {
|
|
|
6721 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
|
|
|
6722 }
|
|
|
6723 if(rs) {
|
|
|
6724 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
|
|
|
6725 }
|
|
|
6726 }
|
|
|
6727
|
|
|
6728 if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
|
|
|
6729 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
|
|
|
6730 }
|
|
|
6731 inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
|
|
|
6732
|
|
|
6733 }
|
|
|
6734
|
|
|
6735 }
|
|
|
6736 });
|
|
|
6737
|
|
|
6738 $.ui.plugin.add("draggable", "stack", {
|
|
|
6739 start: function() {
|
|
|
6740 var min,
|
|
|
6741 o = this.data("ui-draggable").options,
|
|
|
6742 group = $.makeArray($(o.stack)).sort(function(a,b) {
|
|
|
6743 return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
|
|
|
6744 });
|
|
|
6745
|
|
|
6746 if (!group.length) { return; }
|
|
|
6747
|
|
|
6748 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
|
|
|
6749 $(group).each(function(i) {
|
|
|
6750 $(this).css("zIndex", min + i);
|
|
|
6751 });
|
|
|
6752 this.css("zIndex", (min + group.length));
|
|
|
6753 }
|
|
|
6754 });
|
|
|
6755
|
|
|
6756 $.ui.plugin.add("draggable", "zIndex", {
|
|
|
6757 start: function(event, ui) {
|
|
|
6758 var t = $(ui.helper), o = $(this).data("ui-draggable").options;
|
|
|
6759 if(t.css("zIndex")) {
|
|
|
6760 o._zIndex = t.css("zIndex");
|
|
|
6761 }
|
|
|
6762 t.css("zIndex", o.zIndex);
|
|
|
6763 },
|
|
|
6764 stop: function(event, ui) {
|
|
|
6765 var o = $(this).data("ui-draggable").options;
|
|
|
6766 if(o._zIndex) {
|
|
|
6767 $(ui.helper).css("zIndex", o._zIndex);
|
|
|
6768 }
|
|
|
6769 }
|
|
|
6770 });
|
|
|
6771
|
|
|
6772 })(jQuery);
|
|
|
6773 (function( $, undefined ) {
|
|
|
6774
|
|
|
6775 function isOverAxis( x, reference, size ) {
|
|
|
6776 return ( x > reference ) && ( x < ( reference + size ) );
|
|
|
6777 }
|
|
|
6778
|
|
|
6779 $.widget("ui.droppable", {
|
|
|
6780 version: "1.10.4",
|
|
|
6781 widgetEventPrefix: "drop",
|
|
|
6782 options: {
|
|
|
6783 accept: "*",
|
|
|
6784 activeClass: false,
|
|
|
6785 addClasses: true,
|
|
|
6786 greedy: false,
|
|
|
6787 hoverClass: false,
|
|
|
6788 scope: "default",
|
|
|
6789 tolerance: "intersect",
|
|
|
6790
|
|
|
6791 // callbacks
|
|
|
6792 activate: null,
|
|
|
6793 deactivate: null,
|
|
|
6794 drop: null,
|
|
|
6795 out: null,
|
|
|
6796 over: null
|
|
|
6797 },
|
|
|
6798 _create: function() {
|
|
|
6799
|
|
|
6800 var proportions,
|
|
|
6801 o = this.options,
|
|
|
6802 accept = o.accept;
|
|
|
6803
|
|
|
6804 this.isover = false;
|
|
|
6805 this.isout = true;
|
|
|
6806
|
|
|
6807 this.accept = $.isFunction(accept) ? accept : function(d) {
|
|
|
6808 return d.is(accept);
|
|
|
6809 };
|
|
|
6810
|
|
|
6811 this.proportions = function( /* valueToWrite */ ) {
|
|
|
6812 if ( arguments.length ) {
|
|
|
6813 // Store the droppable's proportions
|
|
|
6814 proportions = arguments[ 0 ];
|
|
|
6815 } else {
|
|
|
6816 // Retrieve or derive the droppable's proportions
|
|
|
6817 return proportions ?
|
|
|
6818 proportions :
|
|
|
6819 proportions = {
|
|
|
6820 width: this.element[ 0 ].offsetWidth,
|
|
|
6821 height: this.element[ 0 ].offsetHeight
|
|
|
6822 };
|
|
|
6823 }
|
|
|
6824 };
|
|
|
6825
|
|
|
6826 // Add the reference and positions to the manager
|
|
|
6827 $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
|
|
|
6828 $.ui.ddmanager.droppables[o.scope].push(this);
|
|
|
6829
|
|
|
6830 (o.addClasses && this.element.addClass("ui-droppable"));
|
|
|
6831
|
|
|
6832 },
|
|
|
6833
|
|
|
6834 _destroy: function() {
|
|
|
6835 var i = 0,
|
|
|
6836 drop = $.ui.ddmanager.droppables[this.options.scope];
|
|
|
6837
|
|
|
6838 for ( ; i < drop.length; i++ ) {
|
|
|
6839 if ( drop[i] === this ) {
|
|
|
6840 drop.splice(i, 1);
|
|
|
6841 }
|
|
|
6842 }
|
|
|
6843
|
|
|
6844 this.element.removeClass("ui-droppable ui-droppable-disabled");
|
|
|
6845 },
|
|
|
6846
|
|
|
6847 _setOption: function(key, value) {
|
|
|
6848
|
|
|
6849 if(key === "accept") {
|
|
|
6850 this.accept = $.isFunction(value) ? value : function(d) {
|
|
|
6851 return d.is(value);
|
|
|
6852 };
|
|
|
6853 }
|
|
|
6854 $.Widget.prototype._setOption.apply(this, arguments);
|
|
|
6855 },
|
|
|
6856
|
|
|
6857 _activate: function(event) {
|
|
|
6858 var draggable = $.ui.ddmanager.current;
|
|
|
6859 if(this.options.activeClass) {
|
|
|
6860 this.element.addClass(this.options.activeClass);
|
|
|
6861 }
|
|
|
6862 if(draggable){
|
|
|
6863 this._trigger("activate", event, this.ui(draggable));
|
|
|
6864 }
|
|
|
6865 },
|
|
|
6866
|
|
|
6867 _deactivate: function(event) {
|
|
|
6868 var draggable = $.ui.ddmanager.current;
|
|
|
6869 if(this.options.activeClass) {
|
|
|
6870 this.element.removeClass(this.options.activeClass);
|
|
|
6871 }
|
|
|
6872 if(draggable){
|
|
|
6873 this._trigger("deactivate", event, this.ui(draggable));
|
|
|
6874 }
|
|
|
6875 },
|
|
|
6876
|
|
|
6877 _over: function(event) {
|
|
|
6878
|
|
|
6879 var draggable = $.ui.ddmanager.current;
|
|
|
6880
|
|
|
6881 // Bail if draggable and droppable are same element
|
|
|
6882 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
|
|
|
6883 return;
|
|
|
6884 }
|
|
|
6885
|
|
|
6886 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
|
|
|
6887 if(this.options.hoverClass) {
|
|
|
6888 this.element.addClass(this.options.hoverClass);
|
|
|
6889 }
|
|
|
6890 this._trigger("over", event, this.ui(draggable));
|
|
|
6891 }
|
|
|
6892
|
|
|
6893 },
|
|
|
6894
|
|
|
6895 _out: function(event) {
|
|
|
6896
|
|
|
6897 var draggable = $.ui.ddmanager.current;
|
|
|
6898
|
|
|
6899 // Bail if draggable and droppable are same element
|
|
|
6900 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
|
|
|
6901 return;
|
|
|
6902 }
|
|
|
6903
|
|
|
6904 if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
|
|
|
6905 if(this.options.hoverClass) {
|
|
|
6906 this.element.removeClass(this.options.hoverClass);
|
|
|
6907 }
|
|
|
6908 this._trigger("out", event, this.ui(draggable));
|
|
|
6909 }
|
|
|
6910
|
|
|
6911 },
|
|
|
6912
|
|
|
6913 _drop: function(event,custom) {
|
|
|
6914
|
|
|
6915 var draggable = custom || $.ui.ddmanager.current,
|
|
|
6916 childrenIntersection = false;
|
|
|
6917
|
|
|
6918 // Bail if draggable and droppable are same element
|
|
|
6919 if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
|
|
|
6920 return false;
|
|
|
6921 }
|
|
|
6922
|
|
|
6923 this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
|
|
|
6924 var inst = $.data(this, "ui-droppable");
|
|
|
6925 if(
|
|
|
6926 inst.options.greedy &&
|
|
|
6927 !inst.options.disabled &&
|
|
|
6928 inst.options.scope === draggable.options.scope &&
|
|
|
6929 inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
|
|
|
6930 $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
|
|
|
6931 ) { childrenIntersection = true; return false; }
|
|
|
6932 });
|
|
|
6933 if(childrenIntersection) {
|
|
|
6934 return false;
|
|
|
6935 }
|
|
|
6936
|
|
|
6937 if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
|
|
|
6938 if(this.options.activeClass) {
|
|
|
6939 this.element.removeClass(this.options.activeClass);
|
|
|
6940 }
|
|
|
6941 if(this.options.hoverClass) {
|
|
|
6942 this.element.removeClass(this.options.hoverClass);
|
|
|
6943 }
|
|
|
6944 this._trigger("drop", event, this.ui(draggable));
|
|
|
6945 return this.element;
|
|
|
6946 }
|
|
|
6947
|
|
|
6948 return false;
|
|
|
6949
|
|
|
6950 },
|
|
|
6951
|
|
|
6952 ui: function(c) {
|
|
|
6953 return {
|
|
|
6954 draggable: (c.currentItem || c.element),
|
|
|
6955 helper: c.helper,
|
|
|
6956 position: c.position,
|
|
|
6957 offset: c.positionAbs
|
|
|
6958 };
|
|
|
6959 }
|
|
|
6960
|
|
|
6961 });
|
|
|
6962
|
|
|
6963 $.ui.intersect = function(draggable, droppable, toleranceMode) {
|
|
|
6964
|
|
|
6965 if (!droppable.offset) {
|
|
|
6966 return false;
|
|
|
6967 }
|
|
|
6968
|
|
|
6969 var draggableLeft, draggableTop,
|
|
|
6970 x1 = (draggable.positionAbs || draggable.position.absolute).left,
|
|
|
6971 y1 = (draggable.positionAbs || draggable.position.absolute).top,
|
|
|
6972 x2 = x1 + draggable.helperProportions.width,
|
|
|
6973 y2 = y1 + draggable.helperProportions.height,
|
|
|
6974 l = droppable.offset.left,
|
|
|
6975 t = droppable.offset.top,
|
|
|
6976 r = l + droppable.proportions().width,
|
|
|
6977 b = t + droppable.proportions().height;
|
|
|
6978
|
|
|
6979 switch (toleranceMode) {
|
|
|
6980 case "fit":
|
|
|
6981 return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
|
|
|
6982 case "intersect":
|
|
|
6983 return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
|
|
|
6984 x2 - (draggable.helperProportions.width / 2) < r && // Left Half
|
|
|
6985 t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
|
|
|
6986 y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
|
|
|
6987 case "pointer":
|
|
|
6988 draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
|
|
|
6989 draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
|
|
|
6990 return isOverAxis( draggableTop, t, droppable.proportions().height ) && isOverAxis( draggableLeft, l, droppable.proportions().width );
|
|
|
6991 case "touch":
|
|
|
6992 return (
|
|
|
6993 (y1 >= t && y1 <= b) || // Top edge touching
|
|
|
6994 (y2 >= t && y2 <= b) || // Bottom edge touching
|
|
|
6995 (y1 < t && y2 > b) // Surrounded vertically
|
|
|
6996 ) && (
|
|
|
6997 (x1 >= l && x1 <= r) || // Left edge touching
|
|
|
6998 (x2 >= l && x2 <= r) || // Right edge touching
|
|
|
6999 (x1 < l && x2 > r) // Surrounded horizontally
|
|
|
7000 );
|
|
|
7001 default:
|
|
|
7002 return false;
|
|
|
7003 }
|
|
|
7004
|
|
|
7005 };
|
|
|
7006
|
|
|
7007 /*
|
|
|
7008 This manager tracks offsets of draggables and droppables
|
|
|
7009 */
|
|
|
7010 $.ui.ddmanager = {
|
|
|
7011 current: null,
|
|
|
7012 droppables: { "default": [] },
|
|
|
7013 prepareOffsets: function(t, event) {
|
|
|
7014
|
|
|
7015 var i, j,
|
|
|
7016 m = $.ui.ddmanager.droppables[t.options.scope] || [],
|
|
|
7017 type = event ? event.type : null, // workaround for #2317
|
|
|
7018 list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
|
|
|
7019
|
|
|
7020 droppablesLoop: for (i = 0; i < m.length; i++) {
|
|
|
7021
|
|
|
7022 //No disabled and non-accepted
|
|
|
7023 if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
|
|
|
7024 continue;
|
|
|
7025 }
|
|
|
7026
|
|
|
7027 // Filter out elements in the current dragged item
|
|
|
7028 for (j=0; j < list.length; j++) {
|
|
|
7029 if(list[j] === m[i].element[0]) {
|
|
|
7030 m[i].proportions().height = 0;
|
|
|
7031 continue droppablesLoop;
|
|
|
7032 }
|
|
|
7033 }
|
|
|
7034
|
|
|
7035 m[i].visible = m[i].element.css("display") !== "none";
|
|
|
7036 if(!m[i].visible) {
|
|
|
7037 continue;
|
|
|
7038 }
|
|
|
7039
|
|
|
7040 //Activate the droppable if used directly from draggables
|
|
|
7041 if(type === "mousedown") {
|
|
|
7042 m[i]._activate.call(m[i], event);
|
|
|
7043 }
|
|
|
7044
|
|
|
7045 m[ i ].offset = m[ i ].element.offset();
|
|
|
7046 m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
|
|
|
7047
|
|
|
7048 }
|
|
|
7049
|
|
|
7050 },
|
|
|
7051 drop: function(draggable, event) {
|
|
|
7052
|
|
|
7053 var dropped = false;
|
|
|
7054 // Create a copy of the droppables in case the list changes during the drop (#9116)
|
|
|
7055 $.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
|
|
|
7056
|
|
|
7057 if(!this.options) {
|
|
|
7058 return;
|
|
|
7059 }
|
|
|
7060 if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
|
|
|
7061 dropped = this._drop.call(this, event) || dropped;
|
|
|
7062 }
|
|
|
7063
|
|
|
7064 if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
|
|
|
7065 this.isout = true;
|
|
|
7066 this.isover = false;
|
|
|
7067 this._deactivate.call(this, event);
|
|
|
7068 }
|
|
|
7069
|
|
|
7070 });
|
|
|
7071 return dropped;
|
|
|
7072
|
|
|
7073 },
|
|
|
7074 dragStart: function( draggable, event ) {
|
|
|
7075 //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
|
|
|
7076 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
|
|
|
7077 if( !draggable.options.refreshPositions ) {
|
|
|
7078 $.ui.ddmanager.prepareOffsets( draggable, event );
|
|
|
7079 }
|
|
|
7080 });
|
|
|
7081 },
|
|
|
7082 drag: function(draggable, event) {
|
|
|
7083
|
|
|
7084 //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
|
|
|
7085 if(draggable.options.refreshPositions) {
|
|
|
7086 $.ui.ddmanager.prepareOffsets(draggable, event);
|
|
|
7087 }
|
|
|
7088
|
|
|
7089 //Run through all droppables and check their positions based on specific tolerance options
|
|
|
7090 $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
|
|
|
7091
|
|
|
7092 if(this.options.disabled || this.greedyChild || !this.visible) {
|
|
|
7093 return;
|
|
|
7094 }
|
|
|
7095
|
|
|
7096 var parentInstance, scope, parent,
|
|
|
7097 intersects = $.ui.intersect(draggable, this, this.options.tolerance),
|
|
|
7098 c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
|
|
|
7099 if(!c) {
|
|
|
7100 return;
|
|
|
7101 }
|
|
|
7102
|
|
|
7103 if (this.options.greedy) {
|
|
|
7104 // find droppable parents with same scope
|
|
|
7105 scope = this.options.scope;
|
|
|
7106 parent = this.element.parents(":data(ui-droppable)").filter(function () {
|
|
|
7107 return $.data(this, "ui-droppable").options.scope === scope;
|
|
|
7108 });
|
|
|
7109
|
|
|
7110 if (parent.length) {
|
|
|
7111 parentInstance = $.data(parent[0], "ui-droppable");
|
|
|
7112 parentInstance.greedyChild = (c === "isover");
|
|
|
7113 }
|
|
|
7114 }
|
|
|
7115
|
|
|
7116 // we just moved into a greedy child
|
|
|
7117 if (parentInstance && c === "isover") {
|
|
|
7118 parentInstance.isover = false;
|
|
|
7119 parentInstance.isout = true;
|
|
|
7120 parentInstance._out.call(parentInstance, event);
|
|
|
7121 }
|
|
|
7122
|
|
|
7123 this[c] = true;
|
|
|
7124 this[c === "isout" ? "isover" : "isout"] = false;
|
|
|
7125 this[c === "isover" ? "_over" : "_out"].call(this, event);
|
|
|
7126
|
|
|
7127 // we just moved out of a greedy child
|
|
|
7128 if (parentInstance && c === "isout") {
|
|
|
7129 parentInstance.isout = false;
|
|
|
7130 parentInstance.isover = true;
|
|
|
7131 parentInstance._over.call(parentInstance, event);
|
|
|
7132 }
|
|
|
7133 });
|
|
|
7134
|
|
|
7135 },
|
|
|
7136 dragStop: function( draggable, event ) {
|
|
|
7137 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
|
|
|
7138 //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
|
|
|
7139 if( !draggable.options.refreshPositions ) {
|
|
|
7140 $.ui.ddmanager.prepareOffsets( draggable, event );
|
|
|
7141 }
|
|
|
7142 }
|
|
|
7143 };
|
|
|
7144
|
|
|
7145 })(jQuery);
|
|
|
7146 (function($, undefined) {
|
|
|
7147
|
|
|
7148 var dataSpace = "ui-effects-";
|
|
|
7149
|
|
|
7150 $.effects = {
|
|
|
7151 effect: {}
|
|
|
7152 };
|
|
|
7153
|
|
|
7154 /*!
|
|
|
7155 * jQuery Color Animations v2.1.2
|
|
|
7156 * https://github.com/jquery/jquery-color
|
|
|
7157 *
|
|
|
7158 * Copyright 2013 jQuery Foundation and other contributors
|
|
|
7159 * Released under the MIT license.
|
|
|
7160 * http://jquery.org/license
|
|
|
7161 *
|
|
|
7162 * Date: Wed Jan 16 08:47:09 2013 -0600
|
|
|
7163 */
|
|
|
7164 (function( jQuery, undefined ) {
|
|
|
7165
|
|
|
7166 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
|
|
|
7167
|
|
|
7168 // plusequals test for += 100 -= 100
|
|
|
7169 rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
|
|
|
7170 // a set of RE's that can match strings and generate color tuples.
|
|
|
7171 stringParsers = [{
|
|
|
7172 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
|
|
|
7173 parse: function( execResult ) {
|
|
|
7174 return [
|
|
|
7175 execResult[ 1 ],
|
|
|
7176 execResult[ 2 ],
|
|
|
7177 execResult[ 3 ],
|
|
|
7178 execResult[ 4 ]
|
|
|
7179 ];
|
|
|
7180 }
|
|
|
7181 }, {
|
|
|
7182 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
|
|
|
7183 parse: function( execResult ) {
|
|
|
7184 return [
|
|
|
7185 execResult[ 1 ] * 2.55,
|
|
|
7186 execResult[ 2 ] * 2.55,
|
|
|
7187 execResult[ 3 ] * 2.55,
|
|
|
7188 execResult[ 4 ]
|
|
|
7189 ];
|
|
|
7190 }
|
|
|
7191 }, {
|
|
|
7192 // this regex ignores A-F because it's compared against an already lowercased string
|
|
|
7193 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
|
|
|
7194 parse: function( execResult ) {
|
|
|
7195 return [
|
|
|
7196 parseInt( execResult[ 1 ], 16 ),
|
|
|
7197 parseInt( execResult[ 2 ], 16 ),
|
|
|
7198 parseInt( execResult[ 3 ], 16 )
|
|
|
7199 ];
|
|
|
7200 }
|
|
|
7201 }, {
|
|
|
7202 // this regex ignores A-F because it's compared against an already lowercased string
|
|
|
7203 re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
|
|
|
7204 parse: function( execResult ) {
|
|
|
7205 return [
|
|
|
7206 parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
|
|
|
7207 parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
|
|
|
7208 parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
|
|
|
7209 ];
|
|
|
7210 }
|
|
|
7211 }, {
|
|
|
7212 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
|
|
|
7213 space: "hsla",
|
|
|
7214 parse: function( execResult ) {
|
|
|
7215 return [
|
|
|
7216 execResult[ 1 ],
|
|
|
7217 execResult[ 2 ] / 100,
|
|
|
7218 execResult[ 3 ] / 100,
|
|
|
7219 execResult[ 4 ]
|
|
|
7220 ];
|
|
|
7221 }
|
|
|
7222 }],
|
|
|
7223
|
|
|
7224 // jQuery.Color( )
|
|
|
7225 color = jQuery.Color = function( color, green, blue, alpha ) {
|
|
|
7226 return new jQuery.Color.fn.parse( color, green, blue, alpha );
|
|
|
7227 },
|
|
|
7228 spaces = {
|
|
|
7229 rgba: {
|
|
|
7230 props: {
|
|
|
7231 red: {
|
|
|
7232 idx: 0,
|
|
|
7233 type: "byte"
|
|
|
7234 },
|
|
|
7235 green: {
|
|
|
7236 idx: 1,
|
|
|
7237 type: "byte"
|
|
|
7238 },
|
|
|
7239 blue: {
|
|
|
7240 idx: 2,
|
|
|
7241 type: "byte"
|
|
|
7242 }
|
|
|
7243 }
|
|
|
7244 },
|
|
|
7245
|
|
|
7246 hsla: {
|
|
|
7247 props: {
|
|
|
7248 hue: {
|
|
|
7249 idx: 0,
|
|
|
7250 type: "degrees"
|
|
|
7251 },
|
|
|
7252 saturation: {
|
|
|
7253 idx: 1,
|
|
|
7254 type: "percent"
|
|
|
7255 },
|
|
|
7256 lightness: {
|
|
|
7257 idx: 2,
|
|
|
7258 type: "percent"
|
|
|
7259 }
|
|
|
7260 }
|
|
|
7261 }
|
|
|
7262 },
|
|
|
7263 propTypes = {
|
|
|
7264 "byte": {
|
|
|
7265 floor: true,
|
|
|
7266 max: 255
|
|
|
7267 },
|
|
|
7268 "percent": {
|
|
|
7269 max: 1
|
|
|
7270 },
|
|
|
7271 "degrees": {
|
|
|
7272 mod: 360,
|
|
|
7273 floor: true
|
|
|
7274 }
|
|
|
7275 },
|
|
|
7276 support = color.support = {},
|
|
|
7277
|
|
|
7278 // element for support tests
|
|
|
7279 supportElem = jQuery( "<p>" )[ 0 ],
|
|
|
7280
|
|
|
7281 // colors = jQuery.Color.names
|
|
|
7282 colors,
|
|
|
7283
|
|
|
7284 // local aliases of functions called often
|
|
|
7285 each = jQuery.each;
|
|
|
7286
|
|
|
7287 // determine rgba support immediately
|
|
|
7288 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
|
|
|
7289 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
|
|
|
7290
|
|
|
7291 // define cache name and alpha properties
|
|
|
7292 // for rgba and hsla spaces
|
|
|
7293 each( spaces, function( spaceName, space ) {
|
|
|
7294 space.cache = "_" + spaceName;
|
|
|
7295 space.props.alpha = {
|
|
|
7296 idx: 3,
|
|
|
7297 type: "percent",
|
|
|
7298 def: 1
|
|
|
7299 };
|
|
|
7300 });
|
|
|
7301
|
|
|
7302 function clamp( value, prop, allowEmpty ) {
|
|
|
7303 var type = propTypes[ prop.type ] || {};
|
|
|
7304
|
|
|
7305 if ( value == null ) {
|
|
|
7306 return (allowEmpty || !prop.def) ? null : prop.def;
|
|
|
7307 }
|
|
|
7308
|
|
|
7309 // ~~ is an short way of doing floor for positive numbers
|
|
|
7310 value = type.floor ? ~~value : parseFloat( value );
|
|
|
7311
|
|
|
7312 // IE will pass in empty strings as value for alpha,
|
|
|
7313 // which will hit this case
|
|
|
7314 if ( isNaN( value ) ) {
|
|
|
7315 return prop.def;
|
|
|
7316 }
|
|
|
7317
|
|
|
7318 if ( type.mod ) {
|
|
|
7319 // we add mod before modding to make sure that negatives values
|
|
|
7320 // get converted properly: -10 -> 350
|
|
|
7321 return (value + type.mod) % type.mod;
|
|
|
7322 }
|
|
|
7323
|
|
|
7324 // for now all property types without mod have min and max
|
|
|
7325 return 0 > value ? 0 : type.max < value ? type.max : value;
|
|
|
7326 }
|
|
|
7327
|
|
|
7328 function stringParse( string ) {
|
|
|
7329 var inst = color(),
|
|
|
7330 rgba = inst._rgba = [];
|
|
|
7331
|
|
|
7332 string = string.toLowerCase();
|
|
|
7333
|
|
|
7334 each( stringParsers, function( i, parser ) {
|
|
|
7335 var parsed,
|
|
|
7336 match = parser.re.exec( string ),
|
|
|
7337 values = match && parser.parse( match ),
|
|
|
7338 spaceName = parser.space || "rgba";
|
|
|
7339
|
|
|
7340 if ( values ) {
|
|
|
7341 parsed = inst[ spaceName ]( values );
|
|
|
7342
|
|
|
7343 // if this was an rgba parse the assignment might happen twice
|
|
|
7344 // oh well....
|
|
|
7345 inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
|
|
|
7346 rgba = inst._rgba = parsed._rgba;
|
|
|
7347
|
|
|
7348 // exit each( stringParsers ) here because we matched
|
|
|
7349 return false;
|
|
|
7350 }
|
|
|
7351 });
|
|
|
7352
|
|
|
7353 // Found a stringParser that handled it
|
|
|
7354 if ( rgba.length ) {
|
|
|
7355
|
|
|
7356 // if this came from a parsed string, force "transparent" when alpha is 0
|
|
|
7357 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
|
|
|
7358 if ( rgba.join() === "0,0,0,0" ) {
|
|
|
7359 jQuery.extend( rgba, colors.transparent );
|
|
|
7360 }
|
|
|
7361 return inst;
|
|
|
7362 }
|
|
|
7363
|
|
|
7364 // named colors
|
|
|
7365 return colors[ string ];
|
|
|
7366 }
|
|
|
7367
|
|
|
7368 color.fn = jQuery.extend( color.prototype, {
|
|
|
7369 parse: function( red, green, blue, alpha ) {
|
|
|
7370 if ( red === undefined ) {
|
|
|
7371 this._rgba = [ null, null, null, null ];
|
|
|
7372 return this;
|
|
|
7373 }
|
|
|
7374 if ( red.jquery || red.nodeType ) {
|
|
|
7375 red = jQuery( red ).css( green );
|
|
|
7376 green = undefined;
|
|
|
7377 }
|
|
|
7378
|
|
|
7379 var inst = this,
|
|
|
7380 type = jQuery.type( red ),
|
|
|
7381 rgba = this._rgba = [];
|
|
|
7382
|
|
|
7383 // more than 1 argument specified - assume ( red, green, blue, alpha )
|
|
|
7384 if ( green !== undefined ) {
|
|
|
7385 red = [ red, green, blue, alpha ];
|
|
|
7386 type = "array";
|
|
|
7387 }
|
|
|
7388
|
|
|
7389 if ( type === "string" ) {
|
|
|
7390 return this.parse( stringParse( red ) || colors._default );
|
|
|
7391 }
|
|
|
7392
|
|
|
7393 if ( type === "array" ) {
|
|
|
7394 each( spaces.rgba.props, function( key, prop ) {
|
|
|
7395 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
|
|
|
7396 });
|
|
|
7397 return this;
|
|
|
7398 }
|
|
|
7399
|
|
|
7400 if ( type === "object" ) {
|
|
|
7401 if ( red instanceof color ) {
|
|
|
7402 each( spaces, function( spaceName, space ) {
|
|
|
7403 if ( red[ space.cache ] ) {
|
|
|
7404 inst[ space.cache ] = red[ space.cache ].slice();
|
|
|
7405 }
|
|
|
7406 });
|
|
|
7407 } else {
|
|
|
7408 each( spaces, function( spaceName, space ) {
|
|
|
7409 var cache = space.cache;
|
|
|
7410 each( space.props, function( key, prop ) {
|
|
|
7411
|
|
|
7412 // if the cache doesn't exist, and we know how to convert
|
|
|
7413 if ( !inst[ cache ] && space.to ) {
|
|
|
7414
|
|
|
7415 // if the value was null, we don't need to copy it
|
|
|
7416 // if the key was alpha, we don't need to copy it either
|
|
|
7417 if ( key === "alpha" || red[ key ] == null ) {
|
|
|
7418 return;
|
|
|
7419 }
|
|
|
7420 inst[ cache ] = space.to( inst._rgba );
|
|
|
7421 }
|
|
|
7422
|
|
|
7423 // this is the only case where we allow nulls for ALL properties.
|
|
|
7424 // call clamp with alwaysAllowEmpty
|
|
|
7425 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
|
|
|
7426 });
|
|
|
7427
|
|
|
7428 // everything defined but alpha?
|
|
|
7429 if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
|
|
|
7430 // use the default of 1
|
|
|
7431 inst[ cache ][ 3 ] = 1;
|
|
|
7432 if ( space.from ) {
|
|
|
7433 inst._rgba = space.from( inst[ cache ] );
|
|
|
7434 }
|
|
|
7435 }
|
|
|
7436 });
|
|
|
7437 }
|
|
|
7438 return this;
|
|
|
7439 }
|
|
|
7440 },
|
|
|
7441 is: function( compare ) {
|
|
|
7442 var is = color( compare ),
|
|
|
7443 same = true,
|
|
|
7444 inst = this;
|
|
|
7445
|
|
|
7446 each( spaces, function( _, space ) {
|
|
|
7447 var localCache,
|
|
|
7448 isCache = is[ space.cache ];
|
|
|
7449 if (isCache) {
|
|
|
7450 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
|
|
|
7451 each( space.props, function( _, prop ) {
|
|
|
7452 if ( isCache[ prop.idx ] != null ) {
|
|
|
7453 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
|
|
|
7454 return same;
|
|
|
7455 }
|
|
|
7456 });
|
|
|
7457 }
|
|
|
7458 return same;
|
|
|
7459 });
|
|
|
7460 return same;
|
|
|
7461 },
|
|
|
7462 _space: function() {
|
|
|
7463 var used = [],
|
|
|
7464 inst = this;
|
|
|
7465 each( spaces, function( spaceName, space ) {
|
|
|
7466 if ( inst[ space.cache ] ) {
|
|
|
7467 used.push( spaceName );
|
|
|
7468 }
|
|
|
7469 });
|
|
|
7470 return used.pop();
|
|
|
7471 },
|
|
|
7472 transition: function( other, distance ) {
|
|
|
7473 var end = color( other ),
|
|
|
7474 spaceName = end._space(),
|
|
|
7475 space = spaces[ spaceName ],
|
|
|
7476 startColor = this.alpha() === 0 ? color( "transparent" ) : this,
|
|
|
7477 start = startColor[ space.cache ] || space.to( startColor._rgba ),
|
|
|
7478 result = start.slice();
|
|
|
7479
|
|
|
7480 end = end[ space.cache ];
|
|
|
7481 each( space.props, function( key, prop ) {
|
|
|
7482 var index = prop.idx,
|
|
|
7483 startValue = start[ index ],
|
|
|
7484 endValue = end[ index ],
|
|
|
7485 type = propTypes[ prop.type ] || {};
|
|
|
7486
|
|
|
7487 // if null, don't override start value
|
|
|
7488 if ( endValue === null ) {
|
|
|
7489 return;
|
|
|
7490 }
|
|
|
7491 // if null - use end
|
|
|
7492 if ( startValue === null ) {
|
|
|
7493 result[ index ] = endValue;
|
|
|
7494 } else {
|
|
|
7495 if ( type.mod ) {
|
|
|
7496 if ( endValue - startValue > type.mod / 2 ) {
|
|
|
7497 startValue += type.mod;
|
|
|
7498 } else if ( startValue - endValue > type.mod / 2 ) {
|
|
|
7499 startValue -= type.mod;
|
|
|
7500 }
|
|
|
7501 }
|
|
|
7502 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
|
|
|
7503 }
|
|
|
7504 });
|
|
|
7505 return this[ spaceName ]( result );
|
|
|
7506 },
|
|
|
7507 blend: function( opaque ) {
|
|
|
7508 // if we are already opaque - return ourself
|
|
|
7509 if ( this._rgba[ 3 ] === 1 ) {
|
|
|
7510 return this;
|
|
|
7511 }
|
|
|
7512
|
|
|
7513 var rgb = this._rgba.slice(),
|
|
|
7514 a = rgb.pop(),
|
|
|
7515 blend = color( opaque )._rgba;
|
|
|
7516
|
|
|
7517 return color( jQuery.map( rgb, function( v, i ) {
|
|
|
7518 return ( 1 - a ) * blend[ i ] + a * v;
|
|
|
7519 }));
|
|
|
7520 },
|
|
|
7521 toRgbaString: function() {
|
|
|
7522 var prefix = "rgba(",
|
|
|
7523 rgba = jQuery.map( this._rgba, function( v, i ) {
|
|
|
7524 return v == null ? ( i > 2 ? 1 : 0 ) : v;
|
|
|
7525 });
|
|
|
7526
|
|
|
7527 if ( rgba[ 3 ] === 1 ) {
|
|
|
7528 rgba.pop();
|
|
|
7529 prefix = "rgb(";
|
|
|
7530 }
|
|
|
7531
|
|
|
7532 return prefix + rgba.join() + ")";
|
|
|
7533 },
|
|
|
7534 toHslaString: function() {
|
|
|
7535 var prefix = "hsla(",
|
|
|
7536 hsla = jQuery.map( this.hsla(), function( v, i ) {
|
|
|
7537 if ( v == null ) {
|
|
|
7538 v = i > 2 ? 1 : 0;
|
|
|
7539 }
|
|
|
7540
|
|
|
7541 // catch 1 and 2
|
|
|
7542 if ( i && i < 3 ) {
|
|
|
7543 v = Math.round( v * 100 ) + "%";
|
|
|
7544 }
|
|
|
7545 return v;
|
|
|
7546 });
|
|
|
7547
|
|
|
7548 if ( hsla[ 3 ] === 1 ) {
|
|
|
7549 hsla.pop();
|
|
|
7550 prefix = "hsl(";
|
|
|
7551 }
|
|
|
7552 return prefix + hsla.join() + ")";
|
|
|
7553 },
|
|
|
7554 toHexString: function( includeAlpha ) {
|
|
|
7555 var rgba = this._rgba.slice(),
|
|
|
7556 alpha = rgba.pop();
|
|
|
7557
|
|
|
7558 if ( includeAlpha ) {
|
|
|
7559 rgba.push( ~~( alpha * 255 ) );
|
|
|
7560 }
|
|
|
7561
|
|
|
7562 return "#" + jQuery.map( rgba, function( v ) {
|
|
|
7563
|
|
|
7564 // default to 0 when nulls exist
|
|
|
7565 v = ( v || 0 ).toString( 16 );
|
|
|
7566 return v.length === 1 ? "0" + v : v;
|
|
|
7567 }).join("");
|
|
|
7568 },
|
|
|
7569 toString: function() {
|
|
|
7570 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
|
|
|
7571 }
|
|
|
7572 });
|
|
|
7573 color.fn.parse.prototype = color.fn;
|
|
|
7574
|
|
|
7575 // hsla conversions adapted from:
|
|
|
7576 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
|
|
|
7577
|
|
|
7578 function hue2rgb( p, q, h ) {
|
|
|
7579 h = ( h + 1 ) % 1;
|
|
|
7580 if ( h * 6 < 1 ) {
|
|
|
7581 return p + (q - p) * h * 6;
|
|
|
7582 }
|
|
|
7583 if ( h * 2 < 1) {
|
|
|
7584 return q;
|
|
|
7585 }
|
|
|
7586 if ( h * 3 < 2 ) {
|
|
|
7587 return p + (q - p) * ((2/3) - h) * 6;
|
|
|
7588 }
|
|
|
7589 return p;
|
|
|
7590 }
|
|
|
7591
|
|
|
7592 spaces.hsla.to = function ( rgba ) {
|
|
|
7593 if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
|
|
|
7594 return [ null, null, null, rgba[ 3 ] ];
|
|
|
7595 }
|
|
|
7596 var r = rgba[ 0 ] / 255,
|
|
|
7597 g = rgba[ 1 ] / 255,
|
|
|
7598 b = rgba[ 2 ] / 255,
|
|
|
7599 a = rgba[ 3 ],
|
|
|
7600 max = Math.max( r, g, b ),
|
|
|
7601 min = Math.min( r, g, b ),
|
|
|
7602 diff = max - min,
|
|
|
7603 add = max + min,
|
|
|
7604 l = add * 0.5,
|
|
|
7605 h, s;
|
|
|
7606
|
|
|
7607 if ( min === max ) {
|
|
|
7608 h = 0;
|
|
|
7609 } else if ( r === max ) {
|
|
|
7610 h = ( 60 * ( g - b ) / diff ) + 360;
|
|
|
7611 } else if ( g === max ) {
|
|
|
7612 h = ( 60 * ( b - r ) / diff ) + 120;
|
|
|
7613 } else {
|
|
|
7614 h = ( 60 * ( r - g ) / diff ) + 240;
|
|
|
7615 }
|
|
|
7616
|
|
|
7617 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
|
|
|
7618 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
|
|
|
7619 if ( diff === 0 ) {
|
|
|
7620 s = 0;
|
|
|
7621 } else if ( l <= 0.5 ) {
|
|
|
7622 s = diff / add;
|
|
|
7623 } else {
|
|
|
7624 s = diff / ( 2 - add );
|
|
|
7625 }
|
|
|
7626 return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
|
|
|
7627 };
|
|
|
7628
|
|
|
7629 spaces.hsla.from = function ( hsla ) {
|
|
|
7630 if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
|
|
|
7631 return [ null, null, null, hsla[ 3 ] ];
|
|
|
7632 }
|
|
|
7633 var h = hsla[ 0 ] / 360,
|
|
|
7634 s = hsla[ 1 ],
|
|
|
7635 l = hsla[ 2 ],
|
|
|
7636 a = hsla[ 3 ],
|
|
|
7637 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
|
|
|
7638 p = 2 * l - q;
|
|
|
7639
|
|
|
7640 return [
|
|
|
7641 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
|
|
|
7642 Math.round( hue2rgb( p, q, h ) * 255 ),
|
|
|
7643 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
|
|
|
7644 a
|
|
|
7645 ];
|
|
|
7646 };
|
|
|
7647
|
|
|
7648
|
|
|
7649 each( spaces, function( spaceName, space ) {
|
|
|
7650 var props = space.props,
|
|
|
7651 cache = space.cache,
|
|
|
7652 to = space.to,
|
|
|
7653 from = space.from;
|
|
|
7654
|
|
|
7655 // makes rgba() and hsla()
|
|
|
7656 color.fn[ spaceName ] = function( value ) {
|
|
|
7657
|
|
|
7658 // generate a cache for this space if it doesn't exist
|
|
|
7659 if ( to && !this[ cache ] ) {
|
|
|
7660 this[ cache ] = to( this._rgba );
|
|
|
7661 }
|
|
|
7662 if ( value === undefined ) {
|
|
|
7663 return this[ cache ].slice();
|
|
|
7664 }
|
|
|
7665
|
|
|
7666 var ret,
|
|
|
7667 type = jQuery.type( value ),
|
|
|
7668 arr = ( type === "array" || type === "object" ) ? value : arguments,
|
|
|
7669 local = this[ cache ].slice();
|
|
|
7670
|
|
|
7671 each( props, function( key, prop ) {
|
|
|
7672 var val = arr[ type === "object" ? key : prop.idx ];
|
|
|
7673 if ( val == null ) {
|
|
|
7674 val = local[ prop.idx ];
|
|
|
7675 }
|
|
|
7676 local[ prop.idx ] = clamp( val, prop );
|
|
|
7677 });
|
|
|
7678
|
|
|
7679 if ( from ) {
|
|
|
7680 ret = color( from( local ) );
|
|
|
7681 ret[ cache ] = local;
|
|
|
7682 return ret;
|
|
|
7683 } else {
|
|
|
7684 return color( local );
|
|
|
7685 }
|
|
|
7686 };
|
|
|
7687
|
|
|
7688 // makes red() green() blue() alpha() hue() saturation() lightness()
|
|
|
7689 each( props, function( key, prop ) {
|
|
|
7690 // alpha is included in more than one space
|
|
|
7691 if ( color.fn[ key ] ) {
|
|
|
7692 return;
|
|
|
7693 }
|
|
|
7694 color.fn[ key ] = function( value ) {
|
|
|
7695 var vtype = jQuery.type( value ),
|
|
|
7696 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
|
|
|
7697 local = this[ fn ](),
|
|
|
7698 cur = local[ prop.idx ],
|
|
|
7699 match;
|
|
|
7700
|
|
|
7701 if ( vtype === "undefined" ) {
|
|
|
7702 return cur;
|
|
|
7703 }
|
|
|
7704
|
|
|
7705 if ( vtype === "function" ) {
|
|
|
7706 value = value.call( this, cur );
|
|
|
7707 vtype = jQuery.type( value );
|
|
|
7708 }
|
|
|
7709 if ( value == null && prop.empty ) {
|
|
|
7710 return this;
|
|
|
7711 }
|
|
|
7712 if ( vtype === "string" ) {
|
|
|
7713 match = rplusequals.exec( value );
|
|
|
7714 if ( match ) {
|
|
|
7715 value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
|
|
|
7716 }
|
|
|
7717 }
|
|
|
7718 local[ prop.idx ] = value;
|
|
|
7719 return this[ fn ]( local );
|
|
|
7720 };
|
|
|
7721 });
|
|
|
7722 });
|
|
|
7723
|
|
|
7724 // add cssHook and .fx.step function for each named hook.
|
|
|
7725 // accept a space separated string of properties
|
|
|
7726 color.hook = function( hook ) {
|
|
|
7727 var hooks = hook.split( " " );
|
|
|
7728 each( hooks, function( i, hook ) {
|
|
|
7729 jQuery.cssHooks[ hook ] = {
|
|
|
7730 set: function( elem, value ) {
|
|
|
7731 var parsed, curElem,
|
|
|
7732 backgroundColor = "";
|
|
|
7733
|
|
|
7734 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
|
|
|
7735 value = color( parsed || value );
|
|
|
7736 if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
|
|
|
7737 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
|
|
|
7738 while (
|
|
|
7739 (backgroundColor === "" || backgroundColor === "transparent") &&
|
|
|
7740 curElem && curElem.style
|
|
|
7741 ) {
|
|
|
7742 try {
|
|
|
7743 backgroundColor = jQuery.css( curElem, "backgroundColor" );
|
|
|
7744 curElem = curElem.parentNode;
|
|
|
7745 } catch ( e ) {
|
|
|
7746 }
|
|
|
7747 }
|
|
|
7748
|
|
|
7749 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
|
|
|
7750 backgroundColor :
|
|
|
7751 "_default" );
|
|
|
7752 }
|
|
|
7753
|
|
|
7754 value = value.toRgbaString();
|
|
|
7755 }
|
|
|
7756 try {
|
|
|
7757 elem.style[ hook ] = value;
|
|
|
7758 } catch( e ) {
|
|
|
7759 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
|
|
|
7760 }
|
|
|
7761 }
|
|
|
7762 };
|
|
|
7763 jQuery.fx.step[ hook ] = function( fx ) {
|
|
|
7764 if ( !fx.colorInit ) {
|
|
|
7765 fx.start = color( fx.elem, hook );
|
|
|
7766 fx.end = color( fx.end );
|
|
|
7767 fx.colorInit = true;
|
|
|
7768 }
|
|
|
7769 jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
|
|
|
7770 };
|
|
|
7771 });
|
|
|
7772
|
|
|
7773 };
|
|
|
7774
|
|
|
7775 color.hook( stepHooks );
|
|
|
7776
|
|
|
7777 jQuery.cssHooks.borderColor = {
|
|
|
7778 expand: function( value ) {
|
|
|
7779 var expanded = {};
|
|
|
7780
|
|
|
7781 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
|
|
|
7782 expanded[ "border" + part + "Color" ] = value;
|
|
|
7783 });
|
|
|
7784 return expanded;
|
|
|
7785 }
|
|
|
7786 };
|
|
|
7787
|
|
|
7788 // Basic color names only.
|
|
|
7789 // Usage of any of the other color names requires adding yourself or including
|
|
|
7790 // jquery.color.svg-names.js.
|
|
|
7791 colors = jQuery.Color.names = {
|
|
|
7792 // 4.1. Basic color keywords
|
|
|
7793 aqua: "#00ffff",
|
|
|
7794 black: "#000000",
|
|
|
7795 blue: "#0000ff",
|
|
|
7796 fuchsia: "#ff00ff",
|
|
|
7797 gray: "#808080",
|
|
|
7798 green: "#008000",
|
|
|
7799 lime: "#00ff00",
|
|
|
7800 maroon: "#800000",
|
|
|
7801 navy: "#000080",
|
|
|
7802 olive: "#808000",
|
|
|
7803 purple: "#800080",
|
|
|
7804 red: "#ff0000",
|
|
|
7805 silver: "#c0c0c0",
|
|
|
7806 teal: "#008080",
|
|
|
7807 white: "#ffffff",
|
|
|
7808 yellow: "#ffff00",
|
|
|
7809
|
|
|
7810 // 4.2.3. "transparent" color keyword
|
|
|
7811 transparent: [ null, null, null, 0 ],
|
|
|
7812
|
|
|
7813 _default: "#ffffff"
|
|
|
7814 };
|
|
|
7815
|
|
|
7816 })( jQuery );
|
|
|
7817
|
|
|
7818
|
|
|
7819 /******************************************************************************/
|
|
|
7820 /****************************** CLASS ANIMATIONS ******************************/
|
|
|
7821 /******************************************************************************/
|
|
|
7822 (function() {
|
|
|
7823
|
|
|
7824 var classAnimationActions = [ "add", "remove", "toggle" ],
|
|
|
7825 shorthandStyles = {
|
|
|
7826 border: 1,
|
|
|
7827 borderBottom: 1,
|
|
|
7828 borderColor: 1,
|
|
|
7829 borderLeft: 1,
|
|
|
7830 borderRight: 1,
|
|
|
7831 borderTop: 1,
|
|
|
7832 borderWidth: 1,
|
|
|
7833 margin: 1,
|
|
|
7834 padding: 1
|
|
|
7835 };
|
|
|
7836
|
|
|
7837 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
|
|
|
7838 $.fx.step[ prop ] = function( fx ) {
|
|
|
7839 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
|
|
|
7840 jQuery.style( fx.elem, prop, fx.end );
|
|
|
7841 fx.setAttr = true;
|
|
|
7842 }
|
|
|
7843 };
|
|
|
7844 });
|
|
|
7845
|
|
|
7846 function getElementStyles( elem ) {
|
|
|
7847 var key, len,
|
|
|
7848 style = elem.ownerDocument.defaultView ?
|
|
|
7849 elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
|
|
|
7850 elem.currentStyle,
|
|
|
7851 styles = {};
|
|
|
7852
|
|
|
7853 if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
|
|
|
7854 len = style.length;
|
|
|
7855 while ( len-- ) {
|
|
|
7856 key = style[ len ];
|
|
|
7857 if ( typeof style[ key ] === "string" ) {
|
|
|
7858 styles[ $.camelCase( key ) ] = style[ key ];
|
|
|
7859 }
|
|
|
7860 }
|
|
|
7861 // support: Opera, IE <9
|
|
|
7862 } else {
|
|
|
7863 for ( key in style ) {
|
|
|
7864 if ( typeof style[ key ] === "string" ) {
|
|
|
7865 styles[ key ] = style[ key ];
|
|
|
7866 }
|
|
|
7867 }
|
|
|
7868 }
|
|
|
7869
|
|
|
7870 return styles;
|
|
|
7871 }
|
|
|
7872
|
|
|
7873
|
|
|
7874 function styleDifference( oldStyle, newStyle ) {
|
|
|
7875 var diff = {},
|
|
|
7876 name, value;
|
|
|
7877
|
|
|
7878 for ( name in newStyle ) {
|
|
|
7879 value = newStyle[ name ];
|
|
|
7880 if ( oldStyle[ name ] !== value ) {
|
|
|
7881 if ( !shorthandStyles[ name ] ) {
|
|
|
7882 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
|
|
|
7883 diff[ name ] = value;
|
|
|
7884 }
|
|
|
7885 }
|
|
|
7886 }
|
|
|
7887 }
|
|
|
7888
|
|
|
7889 return diff;
|
|
|
7890 }
|
|
|
7891
|
|
|
7892 // support: jQuery <1.8
|
|
|
7893 if ( !$.fn.addBack ) {
|
|
|
7894 $.fn.addBack = function( selector ) {
|
|
|
7895 return this.add( selector == null ?
|
|
|
7896 this.prevObject : this.prevObject.filter( selector )
|
|
|
7897 );
|
|
|
7898 };
|
|
|
7899 }
|
|
|
7900
|
|
|
7901 $.effects.animateClass = function( value, duration, easing, callback ) {
|
|
|
7902 var o = $.speed( duration, easing, callback );
|
|
|
7903
|
|
|
7904 return this.queue( function() {
|
|
|
7905 var animated = $( this ),
|
|
|
7906 baseClass = animated.attr( "class" ) || "",
|
|
|
7907 applyClassChange,
|
|
|
7908 allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
|
|
|
7909
|
|
|
7910 // map the animated objects to store the original styles.
|
|
|
7911 allAnimations = allAnimations.map(function() {
|
|
|
7912 var el = $( this );
|
|
|
7913 return {
|
|
|
7914 el: el,
|
|
|
7915 start: getElementStyles( this )
|
|
|
7916 };
|
|
|
7917 });
|
|
|
7918
|
|
|
7919 // apply class change
|
|
|
7920 applyClassChange = function() {
|
|
|
7921 $.each( classAnimationActions, function(i, action) {
|
|
|
7922 if ( value[ action ] ) {
|
|
|
7923 animated[ action + "Class" ]( value[ action ] );
|
|
|
7924 }
|
|
|
7925 });
|
|
|
7926 };
|
|
|
7927 applyClassChange();
|
|
|
7928
|
|
|
7929 // map all animated objects again - calculate new styles and diff
|
|
|
7930 allAnimations = allAnimations.map(function() {
|
|
|
7931 this.end = getElementStyles( this.el[ 0 ] );
|
|
|
7932 this.diff = styleDifference( this.start, this.end );
|
|
|
7933 return this;
|
|
|
7934 });
|
|
|
7935
|
|
|
7936 // apply original class
|
|
|
7937 animated.attr( "class", baseClass );
|
|
|
7938
|
|
|
7939 // map all animated objects again - this time collecting a promise
|
|
|
7940 allAnimations = allAnimations.map(function() {
|
|
|
7941 var styleInfo = this,
|
|
|
7942 dfd = $.Deferred(),
|
|
|
7943 opts = $.extend({}, o, {
|
|
|
7944 queue: false,
|
|
|
7945 complete: function() {
|
|
|
7946 dfd.resolve( styleInfo );
|
|
|
7947 }
|
|
|
7948 });
|
|
|
7949
|
|
|
7950 this.el.animate( this.diff, opts );
|
|
|
7951 return dfd.promise();
|
|
|
7952 });
|
|
|
7953
|
|
|
7954 // once all animations have completed:
|
|
|
7955 $.when.apply( $, allAnimations.get() ).done(function() {
|
|
|
7956
|
|
|
7957 // set the final class
|
|
|
7958 applyClassChange();
|
|
|
7959
|
|
|
7960 // for each animated element,
|
|
|
7961 // clear all css properties that were animated
|
|
|
7962 $.each( arguments, function() {
|
|
|
7963 var el = this.el;
|
|
|
7964 $.each( this.diff, function(key) {
|
|
|
7965 el.css( key, "" );
|
|
|
7966 });
|
|
|
7967 });
|
|
|
7968
|
|
|
7969 // this is guarnteed to be there if you use jQuery.speed()
|
|
|
7970 // it also handles dequeuing the next anim...
|
|
|
7971 o.complete.call( animated[ 0 ] );
|
|
|
7972 });
|
|
|
7973 });
|
|
|
7974 };
|
|
|
7975
|
|
|
7976 $.fn.extend({
|
|
|
7977 addClass: (function( orig ) {
|
|
|
7978 return function( classNames, speed, easing, callback ) {
|
|
|
7979 return speed ?
|
|
|
7980 $.effects.animateClass.call( this,
|
|
|
7981 { add: classNames }, speed, easing, callback ) :
|
|
|
7982 orig.apply( this, arguments );
|
|
|
7983 };
|
|
|
7984 })( $.fn.addClass ),
|
|
|
7985
|
|
|
7986 removeClass: (function( orig ) {
|
|
|
7987 return function( classNames, speed, easing, callback ) {
|
|
|
7988 return arguments.length > 1 ?
|
|
|
7989 $.effects.animateClass.call( this,
|
|
|
7990 { remove: classNames }, speed, easing, callback ) :
|
|
|
7991 orig.apply( this, arguments );
|
|
|
7992 };
|
|
|
7993 })( $.fn.removeClass ),
|
|
|
7994
|
|
|
7995 toggleClass: (function( orig ) {
|
|
|
7996 return function( classNames, force, speed, easing, callback ) {
|
|
|
7997 if ( typeof force === "boolean" || force === undefined ) {
|
|
|
7998 if ( !speed ) {
|
|
|
7999 // without speed parameter
|
|
|
8000 return orig.apply( this, arguments );
|
|
|
8001 } else {
|
|
|
8002 return $.effects.animateClass.call( this,
|
|
|
8003 (force ? { add: classNames } : { remove: classNames }),
|
|
|
8004 speed, easing, callback );
|
|
|
8005 }
|
|
|
8006 } else {
|
|
|
8007 // without force parameter
|
|
|
8008 return $.effects.animateClass.call( this,
|
|
|
8009 { toggle: classNames }, force, speed, easing );
|
|
|
8010 }
|
|
|
8011 };
|
|
|
8012 })( $.fn.toggleClass ),
|
|
|
8013
|
|
|
8014 switchClass: function( remove, add, speed, easing, callback) {
|
|
|
8015 return $.effects.animateClass.call( this, {
|
|
|
8016 add: add,
|
|
|
8017 remove: remove
|
|
|
8018 }, speed, easing, callback );
|
|
|
8019 }
|
|
|
8020 });
|
|
|
8021
|
|
|
8022 })();
|
|
|
8023
|
|
|
8024 /******************************************************************************/
|
|
|
8025 /*********************************** EFFECTS **********************************/
|
|
|
8026 /******************************************************************************/
|
|
|
8027
|
|
|
8028 (function() {
|
|
|
8029
|
|
|
8030 $.extend( $.effects, {
|
|
|
8031 version: "1.10.4",
|
|
|
8032
|
|
|
8033 // Saves a set of properties in a data storage
|
|
|
8034 save: function( element, set ) {
|
|
|
8035 for( var i=0; i < set.length; i++ ) {
|
|
|
8036 if ( set[ i ] !== null ) {
|
|
|
8037 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
|
|
|
8038 }
|
|
|
8039 }
|
|
|
8040 },
|
|
|
8041
|
|
|
8042 // Restores a set of previously saved properties from a data storage
|
|
|
8043 restore: function( element, set ) {
|
|
|
8044 var val, i;
|
|
|
8045 for( i=0; i < set.length; i++ ) {
|
|
|
8046 if ( set[ i ] !== null ) {
|
|
|
8047 val = element.data( dataSpace + set[ i ] );
|
|
|
8048 // support: jQuery 1.6.2
|
|
|
8049 // http://bugs.jquery.com/ticket/9917
|
|
|
8050 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
|
|
|
8051 // We can't differentiate between "" and 0 here, so we just assume
|
|
|
8052 // empty string since it's likely to be a more common value...
|
|
|
8053 if ( val === undefined ) {
|
|
|
8054 val = "";
|
|
|
8055 }
|
|
|
8056 element.css( set[ i ], val );
|
|
|
8057 }
|
|
|
8058 }
|
|
|
8059 },
|
|
|
8060
|
|
|
8061 setMode: function( el, mode ) {
|
|
|
8062 if (mode === "toggle") {
|
|
|
8063 mode = el.is( ":hidden" ) ? "show" : "hide";
|
|
|
8064 }
|
|
|
8065 return mode;
|
|
|
8066 },
|
|
|
8067
|
|
|
8068 // Translates a [top,left] array into a baseline value
|
|
|
8069 // this should be a little more flexible in the future to handle a string & hash
|
|
|
8070 getBaseline: function( origin, original ) {
|
|
|
8071 var y, x;
|
|
|
8072 switch ( origin[ 0 ] ) {
|
|
|
8073 case "top": y = 0; break;
|
|
|
8074 case "middle": y = 0.5; break;
|
|
|
8075 case "bottom": y = 1; break;
|
|
|
8076 default: y = origin[ 0 ] / original.height;
|
|
|
8077 }
|
|
|
8078 switch ( origin[ 1 ] ) {
|
|
|
8079 case "left": x = 0; break;
|
|
|
8080 case "center": x = 0.5; break;
|
|
|
8081 case "right": x = 1; break;
|
|
|
8082 default: x = origin[ 1 ] / original.width;
|
|
|
8083 }
|
|
|
8084 return {
|
|
|
8085 x: x,
|
|
|
8086 y: y
|
|
|
8087 };
|
|
|
8088 },
|
|
|
8089
|
|
|
8090 // Wraps the element around a wrapper that copies position properties
|
|
|
8091 createWrapper: function( element ) {
|
|
|
8092
|
|
|
8093 // if the element is already wrapped, return it
|
|
|
8094 if ( element.parent().is( ".ui-effects-wrapper" )) {
|
|
|
8095 return element.parent();
|
|
|
8096 }
|
|
|
8097
|
|
|
8098 // wrap the element
|
|
|
8099 var props = {
|
|
|
8100 width: element.outerWidth(true),
|
|
|
8101 height: element.outerHeight(true),
|
|
|
8102 "float": element.css( "float" )
|
|
|
8103 },
|
|
|
8104 wrapper = $( "<div></div>" )
|
|
|
8105 .addClass( "ui-effects-wrapper" )
|
|
|
8106 .css({
|
|
|
8107 fontSize: "100%",
|
|
|
8108 background: "transparent",
|
|
|
8109 border: "none",
|
|
|
8110 margin: 0,
|
|
|
8111 padding: 0
|
|
|
8112 }),
|
|
|
8113 // Store the size in case width/height are defined in % - Fixes #5245
|
|
|
8114 size = {
|
|
|
8115 width: element.width(),
|
|
|
8116 height: element.height()
|
|
|
8117 },
|
|
|
8118 active = document.activeElement;
|
|
|
8119
|
|
|
8120 // support: Firefox
|
|
|
8121 // Firefox incorrectly exposes anonymous content
|
|
|
8122 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
|
|
|
8123 try {
|
|
|
8124 active.id;
|
|
|
8125 } catch( e ) {
|
|
|
8126 active = document.body;
|
|
|
8127 }
|
|
|
8128
|
|
|
8129 element.wrap( wrapper );
|
|
|
8130
|
|
|
8131 // Fixes #7595 - Elements lose focus when wrapped.
|
|
|
8132 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
|
|
|
8133 $( active ).focus();
|
|
|
8134 }
|
|
|
8135
|
|
|
8136 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
|
|
|
8137
|
|
|
8138 // transfer positioning properties to the wrapper
|
|
|
8139 if ( element.css( "position" ) === "static" ) {
|
|
|
8140 wrapper.css({ position: "relative" });
|
|
|
8141 element.css({ position: "relative" });
|
|
|
8142 } else {
|
|
|
8143 $.extend( props, {
|
|
|
8144 position: element.css( "position" ),
|
|
|
8145 zIndex: element.css( "z-index" )
|
|
|
8146 });
|
|
|
8147 $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
|
|
|
8148 props[ pos ] = element.css( pos );
|
|
|
8149 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
|
|
|
8150 props[ pos ] = "auto";
|
|
|
8151 }
|
|
|
8152 });
|
|
|
8153 element.css({
|
|
|
8154 position: "relative",
|
|
|
8155 top: 0,
|
|
|
8156 left: 0,
|
|
|
8157 right: "auto",
|
|
|
8158 bottom: "auto"
|
|
|
8159 });
|
|
|
8160 }
|
|
|
8161 element.css(size);
|
|
|
8162
|
|
|
8163 return wrapper.css( props ).show();
|
|
|
8164 },
|
|
|
8165
|
|
|
8166 removeWrapper: function( element ) {
|
|
|
8167 var active = document.activeElement;
|
|
|
8168
|
|
|
8169 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
|
|
|
8170 element.parent().replaceWith( element );
|
|
|
8171
|
|
|
8172 // Fixes #7595 - Elements lose focus when wrapped.
|
|
|
8173 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
|
|
|
8174 $( active ).focus();
|
|
|
8175 }
|
|
|
8176 }
|
|
|
8177
|
|
|
8178
|
|
|
8179 return element;
|
|
|
8180 },
|
|
|
8181
|
|
|
8182 setTransition: function( element, list, factor, value ) {
|
|
|
8183 value = value || {};
|
|
|
8184 $.each( list, function( i, x ) {
|
|
|
8185 var unit = element.cssUnit( x );
|
|
|
8186 if ( unit[ 0 ] > 0 ) {
|
|
|
8187 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
|
|
|
8188 }
|
|
|
8189 });
|
|
|
8190 return value;
|
|
|
8191 }
|
|
|
8192 });
|
|
|
8193
|
|
|
8194 // return an effect options object for the given parameters:
|
|
|
8195 function _normalizeArguments( effect, options, speed, callback ) {
|
|
|
8196
|
|
|
8197 // allow passing all options as the first parameter
|
|
|
8198 if ( $.isPlainObject( effect ) ) {
|
|
|
8199 options = effect;
|
|
|
8200 effect = effect.effect;
|
|
|
8201 }
|
|
|
8202
|
|
|
8203 // convert to an object
|
|
|
8204 effect = { effect: effect };
|
|
|
8205
|
|
|
8206 // catch (effect, null, ...)
|
|
|
8207 if ( options == null ) {
|
|
|
8208 options = {};
|
|
|
8209 }
|
|
|
8210
|
|
|
8211 // catch (effect, callback)
|
|
|
8212 if ( $.isFunction( options ) ) {
|
|
|
8213 callback = options;
|
|
|
8214 speed = null;
|
|
|
8215 options = {};
|
|
|
8216 }
|
|
|
8217
|
|
|
8218 // catch (effect, speed, ?)
|
|
|
8219 if ( typeof options === "number" || $.fx.speeds[ options ] ) {
|
|
|
8220 callback = speed;
|
|
|
8221 speed = options;
|
|
|
8222 options = {};
|
|
|
8223 }
|
|
|
8224
|
|
|
8225 // catch (effect, options, callback)
|
|
|
8226 if ( $.isFunction( speed ) ) {
|
|
|
8227 callback = speed;
|
|
|
8228 speed = null;
|
|
|
8229 }
|
|
|
8230
|
|
|
8231 // add options to effect
|
|
|
8232 if ( options ) {
|
|
|
8233 $.extend( effect, options );
|
|
|
8234 }
|
|
|
8235
|
|
|
8236 speed = speed || options.duration;
|
|
|
8237 effect.duration = $.fx.off ? 0 :
|
|
|
8238 typeof speed === "number" ? speed :
|
|
|
8239 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
|
|
|
8240 $.fx.speeds._default;
|
|
|
8241
|
|
|
8242 effect.complete = callback || options.complete;
|
|
|
8243
|
|
|
8244 return effect;
|
|
|
8245 }
|
|
|
8246
|
|
|
8247 function standardAnimationOption( option ) {
|
|
|
8248 // Valid standard speeds (nothing, number, named speed)
|
|
|
8249 if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
|
|
|
8250 return true;
|
|
|
8251 }
|
|
|
8252
|
|
|
8253 // Invalid strings - treat as "normal" speed
|
|
|
8254 if ( typeof option === "string" && !$.effects.effect[ option ] ) {
|
|
|
8255 return true;
|
|
|
8256 }
|
|
|
8257
|
|
|
8258 // Complete callback
|
|
|
8259 if ( $.isFunction( option ) ) {
|
|
|
8260 return true;
|
|
|
8261 }
|
|
|
8262
|
|
|
8263 // Options hash (but not naming an effect)
|
|
|
8264 if ( typeof option === "object" && !option.effect ) {
|
|
|
8265 return true;
|
|
|
8266 }
|
|
|
8267
|
|
|
8268 // Didn't match any standard API
|
|
|
8269 return false;
|
|
|
8270 }
|
|
|
8271
|
|
|
8272 $.fn.extend({
|
|
|
8273 effect: function( /* effect, options, speed, callback */ ) {
|
|
|
8274 var args = _normalizeArguments.apply( this, arguments ),
|
|
|
8275 mode = args.mode,
|
|
|
8276 queue = args.queue,
|
|
|
8277 effectMethod = $.effects.effect[ args.effect ];
|
|
|
8278
|
|
|
8279 if ( $.fx.off || !effectMethod ) {
|
|
|
8280 // delegate to the original method (e.g., .show()) if possible
|
|
|
8281 if ( mode ) {
|
|
|
8282 return this[ mode ]( args.duration, args.complete );
|
|
|
8283 } else {
|
|
|
8284 return this.each( function() {
|
|
|
8285 if ( args.complete ) {
|
|
|
8286 args.complete.call( this );
|
|
|
8287 }
|
|
|
8288 });
|
|
|
8289 }
|
|
|
8290 }
|
|
|
8291
|
|
|
8292 function run( next ) {
|
|
|
8293 var elem = $( this ),
|
|
|
8294 complete = args.complete,
|
|
|
8295 mode = args.mode;
|
|
|
8296
|
|
|
8297 function done() {
|
|
|
8298 if ( $.isFunction( complete ) ) {
|
|
|
8299 complete.call( elem[0] );
|
|
|
8300 }
|
|
|
8301 if ( $.isFunction( next ) ) {
|
|
|
8302 next();
|
|
|
8303 }
|
|
|
8304 }
|
|
|
8305
|
|
|
8306 // If the element already has the correct final state, delegate to
|
|
|
8307 // the core methods so the internal tracking of "olddisplay" works.
|
|
|
8308 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
|
|
|
8309 elem[ mode ]();
|
|
|
8310 done();
|
|
|
8311 } else {
|
|
|
8312 effectMethod.call( elem[0], args, done );
|
|
|
8313 }
|
|
|
8314 }
|
|
|
8315
|
|
|
8316 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
|
|
|
8317 },
|
|
|
8318
|
|
|
8319 show: (function( orig ) {
|
|
|
8320 return function( option ) {
|
|
|
8321 if ( standardAnimationOption( option ) ) {
|
|
|
8322 return orig.apply( this, arguments );
|
|
|
8323 } else {
|
|
|
8324 var args = _normalizeArguments.apply( this, arguments );
|
|
|
8325 args.mode = "show";
|
|
|
8326 return this.effect.call( this, args );
|
|
|
8327 }
|
|
|
8328 };
|
|
|
8329 })( $.fn.show ),
|
|
|
8330
|
|
|
8331 hide: (function( orig ) {
|
|
|
8332 return function( option ) {
|
|
|
8333 if ( standardAnimationOption( option ) ) {
|
|
|
8334 return orig.apply( this, arguments );
|
|
|
8335 } else {
|
|
|
8336 var args = _normalizeArguments.apply( this, arguments );
|
|
|
8337 args.mode = "hide";
|
|
|
8338 return this.effect.call( this, args );
|
|
|
8339 }
|
|
|
8340 };
|
|
|
8341 })( $.fn.hide ),
|
|
|
8342
|
|
|
8343 toggle: (function( orig ) {
|
|
|
8344 return function( option ) {
|
|
|
8345 if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
|
|
|
8346 return orig.apply( this, arguments );
|
|
|
8347 } else {
|
|
|
8348 var args = _normalizeArguments.apply( this, arguments );
|
|
|
8349 args.mode = "toggle";
|
|
|
8350 return this.effect.call( this, args );
|
|
|
8351 }
|
|
|
8352 };
|
|
|
8353 })( $.fn.toggle ),
|
|
|
8354
|
|
|
8355 // helper functions
|
|
|
8356 cssUnit: function(key) {
|
|
|
8357 var style = this.css( key ),
|
|
|
8358 val = [];
|
|
|
8359
|
|
|
8360 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
|
|
|
8361 if ( style.indexOf( unit ) > 0 ) {
|
|
|
8362 val = [ parseFloat( style ), unit ];
|
|
|
8363 }
|
|
|
8364 });
|
|
|
8365 return val;
|
|
|
8366 }
|
|
|
8367 });
|
|
|
8368
|
|
|
8369 })();
|
|
|
8370
|
|
|
8371 /******************************************************************************/
|
|
|
8372 /*********************************** EASING ***********************************/
|
|
|
8373 /******************************************************************************/
|
|
|
8374
|
|
|
8375 (function() {
|
|
|
8376
|
|
|
8377 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
|
|
|
8378
|
|
|
8379 var baseEasings = {};
|
|
|
8380
|
|
|
8381 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
|
|
|
8382 baseEasings[ name ] = function( p ) {
|
|
|
8383 return Math.pow( p, i + 2 );
|
|
|
8384 };
|
|
|
8385 });
|
|
|
8386
|
|
|
8387 $.extend( baseEasings, {
|
|
|
8388 Sine: function ( p ) {
|
|
|
8389 return 1 - Math.cos( p * Math.PI / 2 );
|
|
|
8390 },
|
|
|
8391 Circ: function ( p ) {
|
|
|
8392 return 1 - Math.sqrt( 1 - p * p );
|
|
|
8393 },
|
|
|
8394 Elastic: function( p ) {
|
|
|
8395 return p === 0 || p === 1 ? p :
|
|
|
8396 -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
|
|
|
8397 },
|
|
|
8398 Back: function( p ) {
|
|
|
8399 return p * p * ( 3 * p - 2 );
|
|
|
8400 },
|
|
|
8401 Bounce: function ( p ) {
|
|
|
8402 var pow2,
|
|
|
8403 bounce = 4;
|
|
|
8404
|
|
|
8405 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
|
|
|
8406 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
|
|
|
8407 }
|
|
|
8408 });
|
|
|
8409
|
|
|
8410 $.each( baseEasings, function( name, easeIn ) {
|
|
|
8411 $.easing[ "easeIn" + name ] = easeIn;
|
|
|
8412 $.easing[ "easeOut" + name ] = function( p ) {
|
|
|
8413 return 1 - easeIn( 1 - p );
|
|
|
8414 };
|
|
|
8415 $.easing[ "easeInOut" + name ] = function( p ) {
|
|
|
8416 return p < 0.5 ?
|
|
|
8417 easeIn( p * 2 ) / 2 :
|
|
|
8418 1 - easeIn( p * -2 + 2 ) / 2;
|
|
|
8419 };
|
|
|
8420 });
|
|
|
8421
|
|
|
8422 })();
|
|
|
8423
|
|
|
8424 })(jQuery);
|
|
|
8425 (function( $, undefined ) {
|
|
|
8426
|
|
|
8427 var rvertical = /up|down|vertical/,
|
|
|
8428 rpositivemotion = /up|left|vertical|horizontal/;
|
|
|
8429
|
|
|
8430 $.effects.effect.blind = function( o, done ) {
|
|
|
8431 // Create element
|
|
|
8432 var el = $( this ),
|
|
|
8433 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
|
|
|
8434 mode = $.effects.setMode( el, o.mode || "hide" ),
|
|
|
8435 direction = o.direction || "up",
|
|
|
8436 vertical = rvertical.test( direction ),
|
|
|
8437 ref = vertical ? "height" : "width",
|
|
|
8438 ref2 = vertical ? "top" : "left",
|
|
|
8439 motion = rpositivemotion.test( direction ),
|
|
|
8440 animation = {},
|
|
|
8441 show = mode === "show",
|
|
|
8442 wrapper, distance, margin;
|
|
|
8443
|
|
|
8444 // if already wrapped, the wrapper's properties are my property. #6245
|
|
|
8445 if ( el.parent().is( ".ui-effects-wrapper" ) ) {
|
|
|
8446 $.effects.save( el.parent(), props );
|
|
|
8447 } else {
|
|
|
8448 $.effects.save( el, props );
|
|
|
8449 }
|
|
|
8450 el.show();
|
|
|
8451 wrapper = $.effects.createWrapper( el ).css({
|
|
|
8452 overflow: "hidden"
|
|
|
8453 });
|
|
|
8454
|
|
|
8455 distance = wrapper[ ref ]();
|
|
|
8456 margin = parseFloat( wrapper.css( ref2 ) ) || 0;
|
|
|
8457
|
|
|
8458 animation[ ref ] = show ? distance : 0;
|
|
|
8459 if ( !motion ) {
|
|
|
8460 el
|
|
|
8461 .css( vertical ? "bottom" : "right", 0 )
|
|
|
8462 .css( vertical ? "top" : "left", "auto" )
|
|
|
8463 .css({ position: "absolute" });
|
|
|
8464
|
|
|
8465 animation[ ref2 ] = show ? margin : distance + margin;
|
|
|
8466 }
|
|
|
8467
|
|
|
8468 // start at 0 if we are showing
|
|
|
8469 if ( show ) {
|
|
|
8470 wrapper.css( ref, 0 );
|
|
|
8471 if ( ! motion ) {
|
|
|
8472 wrapper.css( ref2, margin + distance );
|
|
|
8473 }
|
|
|
8474 }
|
|
|
8475
|
|
|
8476 // Animate
|
|
|
8477 wrapper.animate( animation, {
|
|
|
8478 duration: o.duration,
|
|
|
8479 easing: o.easing,
|
|
|
8480 queue: false,
|
|
|
8481 complete: function() {
|
|
|
8482 if ( mode === "hide" ) {
|
|
|
8483 el.hide();
|
|
|
8484 }
|
|
|
8485 $.effects.restore( el, props );
|
|
|
8486 $.effects.removeWrapper( el );
|
|
|
8487 done();
|
|
|
8488 }
|
|
|
8489 });
|
|
|
8490
|
|
|
8491 };
|
|
|
8492
|
|
|
8493 })(jQuery);
|
|
|
8494 (function( $, undefined ) {
|
|
|
8495
|
|
|
8496 $.effects.effect.bounce = function( o, done ) {
|
|
|
8497 var el = $( this ),
|
|
|
8498 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
|
|
|
8499
|
|
|
8500 // defaults:
|
|
|
8501 mode = $.effects.setMode( el, o.mode || "effect" ),
|
|
|
8502 hide = mode === "hide",
|
|
|
8503 show = mode === "show",
|
|
|
8504 direction = o.direction || "up",
|
|
|
8505 distance = o.distance,
|
|
|
8506 times = o.times || 5,
|
|
|
8507
|
|
|
8508 // number of internal animations
|
|
|
8509 anims = times * 2 + ( show || hide ? 1 : 0 ),
|
|
|
8510 speed = o.duration / anims,
|
|
|
8511 easing = o.easing,
|
|
|
8512
|
|
|
8513 // utility:
|
|
|
8514 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
|
|
|
8515 motion = ( direction === "up" || direction === "left" ),
|
|
|
8516 i,
|
|
|
8517 upAnim,
|
|
|
8518 downAnim,
|
|
|
8519
|
|
|
8520 // we will need to re-assemble the queue to stack our animations in place
|
|
|
8521 queue = el.queue(),
|
|
|
8522 queuelen = queue.length;
|
|
|
8523
|
|
|
8524 // Avoid touching opacity to prevent clearType and PNG issues in IE
|
|
|
8525 if ( show || hide ) {
|
|
|
8526 props.push( "opacity" );
|
|
|
8527 }
|
|
|
8528
|
|
|
8529 $.effects.save( el, props );
|
|
|
8530 el.show();
|
|
|
8531 $.effects.createWrapper( el ); // Create Wrapper
|
|
|
8532
|
|
|
8533 // default distance for the BIGGEST bounce is the outer Distance / 3
|
|
|
8534 if ( !distance ) {
|
|
|
8535 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
|
|
|
8536 }
|
|
|
8537
|
|
|
8538 if ( show ) {
|
|
|
8539 downAnim = { opacity: 1 };
|
|
|
8540 downAnim[ ref ] = 0;
|
|
|
8541
|
|
|
8542 // if we are showing, force opacity 0 and set the initial position
|
|
|
8543 // then do the "first" animation
|
|
|
8544 el.css( "opacity", 0 )
|
|
|
8545 .css( ref, motion ? -distance * 2 : distance * 2 )
|
|
|
8546 .animate( downAnim, speed, easing );
|
|
|
8547 }
|
|
|
8548
|
|
|
8549 // start at the smallest distance if we are hiding
|
|
|
8550 if ( hide ) {
|
|
|
8551 distance = distance / Math.pow( 2, times - 1 );
|
|
|
8552 }
|
|
|
8553
|
|
|
8554 downAnim = {};
|
|
|
8555 downAnim[ ref ] = 0;
|
|
|
8556 // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
|
|
|
8557 for ( i = 0; i < times; i++ ) {
|
|
|
8558 upAnim = {};
|
|
|
8559 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
|
|
|
8560
|
|
|
8561 el.animate( upAnim, speed, easing )
|
|
|
8562 .animate( downAnim, speed, easing );
|
|
|
8563
|
|
|
8564 distance = hide ? distance * 2 : distance / 2;
|
|
|
8565 }
|
|
|
8566
|
|
|
8567 // Last Bounce when Hiding
|
|
|
8568 if ( hide ) {
|
|
|
8569 upAnim = { opacity: 0 };
|
|
|
8570 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
|
|
|
8571
|
|
|
8572 el.animate( upAnim, speed, easing );
|
|
|
8573 }
|
|
|
8574
|
|
|
8575 el.queue(function() {
|
|
|
8576 if ( hide ) {
|
|
|
8577 el.hide();
|
|
|
8578 }
|
|
|
8579 $.effects.restore( el, props );
|
|
|
8580 $.effects.removeWrapper( el );
|
|
|
8581 done();
|
|
|
8582 });
|
|
|
8583
|
|
|
8584 // inject all the animations we just queued to be first in line (after "inprogress")
|
|
|
8585 if ( queuelen > 1) {
|
|
|
8586 queue.splice.apply( queue,
|
|
|
8587 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
|
|
|
8588 }
|
|
|
8589 el.dequeue();
|
|
|
8590
|
|
|
8591 };
|
|
|
8592
|
|
|
8593 })(jQuery);
|
|
|
8594 (function( $, undefined ) {
|
|
|
8595
|
|
|
8596 $.effects.effect.clip = function( o, done ) {
|
|
|
8597 // Create element
|
|
|
8598 var el = $( this ),
|
|
|
8599 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
|
|
|
8600 mode = $.effects.setMode( el, o.mode || "hide" ),
|
|
|
8601 show = mode === "show",
|
|
|
8602 direction = o.direction || "vertical",
|
|
|
8603 vert = direction === "vertical",
|
|
|
8604 size = vert ? "height" : "width",
|
|
|
8605 position = vert ? "top" : "left",
|
|
|
8606 animation = {},
|
|
|
8607 wrapper, animate, distance;
|
|
|
8608
|
|
|
8609 // Save & Show
|
|
|
8610 $.effects.save( el, props );
|
|
|
8611 el.show();
|
|
|
8612
|
|
|
8613 // Create Wrapper
|
|
|
8614 wrapper = $.effects.createWrapper( el ).css({
|
|
|
8615 overflow: "hidden"
|
|
|
8616 });
|
|
|
8617 animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
|
|
|
8618 distance = animate[ size ]();
|
|
|
8619
|
|
|
8620 // Shift
|
|
|
8621 if ( show ) {
|
|
|
8622 animate.css( size, 0 );
|
|
|
8623 animate.css( position, distance / 2 );
|
|
|
8624 }
|
|
|
8625
|
|
|
8626 // Create Animation Object:
|
|
|
8627 animation[ size ] = show ? distance : 0;
|
|
|
8628 animation[ position ] = show ? 0 : distance / 2;
|
|
|
8629
|
|
|
8630 // Animate
|
|
|
8631 animate.animate( animation, {
|
|
|
8632 queue: false,
|
|
|
8633 duration: o.duration,
|
|
|
8634 easing: o.easing,
|
|
|
8635 complete: function() {
|
|
|
8636 if ( !show ) {
|
|
|
8637 el.hide();
|
|
|
8638 }
|
|
|
8639 $.effects.restore( el, props );
|
|
|
8640 $.effects.removeWrapper( el );
|
|
|
8641 done();
|
|
|
8642 }
|
|
|
8643 });
|
|
|
8644
|
|
|
8645 };
|
|
|
8646
|
|
|
8647 })(jQuery);
|
|
|
8648 (function( $, undefined ) {
|
|
|
8649
|
|
|
8650 $.effects.effect.drop = function( o, done ) {
|
|
|
8651
|
|
|
8652 var el = $( this ),
|
|
|
8653 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
|
|
|
8654 mode = $.effects.setMode( el, o.mode || "hide" ),
|
|
|
8655 show = mode === "show",
|
|
|
8656 direction = o.direction || "left",
|
|
|
8657 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
|
|
|
8658 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
|
|
|
8659 animation = {
|
|
|
8660 opacity: show ? 1 : 0
|
|
|
8661 },
|
|
|
8662 distance;
|
|
|
8663
|
|
|
8664 // Adjust
|
|
|
8665 $.effects.save( el, props );
|
|
|
8666 el.show();
|
|
|
8667 $.effects.createWrapper( el );
|
|
|
8668
|
|
|
8669 distance = o.distance || el[ ref === "top" ? "outerHeight": "outerWidth" ]( true ) / 2;
|
|
|
8670
|
|
|
8671 if ( show ) {
|
|
|
8672 el
|
|
|
8673 .css( "opacity", 0 )
|
|
|
8674 .css( ref, motion === "pos" ? -distance : distance );
|
|
|
8675 }
|
|
|
8676
|
|
|
8677 // Animation
|
|
|
8678 animation[ ref ] = ( show ?
|
|
|
8679 ( motion === "pos" ? "+=" : "-=" ) :
|
|
|
8680 ( motion === "pos" ? "-=" : "+=" ) ) +
|
|
|
8681 distance;
|
|
|
8682
|
|
|
8683 // Animate
|
|
|
8684 el.animate( animation, {
|
|
|
8685 queue: false,
|
|
|
8686 duration: o.duration,
|
|
|
8687 easing: o.easing,
|
|
|
8688 complete: function() {
|
|
|
8689 if ( mode === "hide" ) {
|
|
|
8690 el.hide();
|
|
|
8691 }
|
|
|
8692 $.effects.restore( el, props );
|
|
|
8693 $.effects.removeWrapper( el );
|
|
|
8694 done();
|
|
|
8695 }
|
|
|
8696 });
|
|
|
8697 };
|
|
|
8698
|
|
|
8699 })(jQuery);
|
|
|
8700 (function( $, undefined ) {
|
|
|
8701
|
|
|
8702 $.effects.effect.explode = function( o, done ) {
|
|
|
8703
|
|
|
8704 var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
|
|
|
8705 cells = rows,
|
|
|
8706 el = $( this ),
|
|
|
8707 mode = $.effects.setMode( el, o.mode || "hide" ),
|
|
|
8708 show = mode === "show",
|
|
|
8709
|
|
|
8710 // show and then visibility:hidden the element before calculating offset
|
|
|
8711 offset = el.show().css( "visibility", "hidden" ).offset(),
|
|
|
8712
|
|
|
8713 // width and height of a piece
|
|
|
8714 width = Math.ceil( el.outerWidth() / cells ),
|
|
|
8715 height = Math.ceil( el.outerHeight() / rows ),
|
|
|
8716 pieces = [],
|
|
|
8717
|
|
|
8718 // loop
|
|
|
8719 i, j, left, top, mx, my;
|
|
|
8720
|
|
|
8721 // children animate complete:
|
|
|
8722 function childComplete() {
|
|
|
8723 pieces.push( this );
|
|
|
8724 if ( pieces.length === rows * cells ) {
|
|
|
8725 animComplete();
|
|
|
8726 }
|
|
|
8727 }
|
|
|
8728
|
|
|
8729 // clone the element for each row and cell.
|
|
|
8730 for( i = 0; i < rows ; i++ ) { // ===>
|
|
|
8731 top = offset.top + i * height;
|
|
|
8732 my = i - ( rows - 1 ) / 2 ;
|
|
|
8733
|
|
|
8734 for( j = 0; j < cells ; j++ ) { // |||
|
|
|
8735 left = offset.left + j * width;
|
|
|
8736 mx = j - ( cells - 1 ) / 2 ;
|
|
|
8737
|
|
|
8738 // Create a clone of the now hidden main element that will be absolute positioned
|
|
|
8739 // within a wrapper div off the -left and -top equal to size of our pieces
|
|
|
8740 el
|
|
|
8741 .clone()
|
|
|
8742 .appendTo( "body" )
|
|
|
8743 .wrap( "<div></div>" )
|
|
|
8744 .css({
|
|
|
8745 position: "absolute",
|
|
|
8746 visibility: "visible",
|
|
|
8747 left: -j * width,
|
|
|
8748 top: -i * height
|
|
|
8749 })
|
|
|
8750
|
|
|
8751 // select the wrapper - make it overflow: hidden and absolute positioned based on
|
|
|
8752 // where the original was located +left and +top equal to the size of pieces
|
|
|
8753 .parent()
|
|
|
8754 .addClass( "ui-effects-explode" )
|
|
|
8755 .css({
|
|
|
8756 position: "absolute",
|
|
|
8757 overflow: "hidden",
|
|
|
8758 width: width,
|
|
|
8759 height: height,
|
|
|
8760 left: left + ( show ? mx * width : 0 ),
|
|
|
8761 top: top + ( show ? my * height : 0 ),
|
|
|
8762 opacity: show ? 0 : 1
|
|
|
8763 }).animate({
|
|
|
8764 left: left + ( show ? 0 : mx * width ),
|
|
|
8765 top: top + ( show ? 0 : my * height ),
|
|
|
8766 opacity: show ? 1 : 0
|
|
|
8767 }, o.duration || 500, o.easing, childComplete );
|
|
|
8768 }
|
|
|
8769 }
|
|
|
8770
|
|
|
8771 function animComplete() {
|
|
|
8772 el.css({
|
|
|
8773 visibility: "visible"
|
|
|
8774 });
|
|
|
8775 $( pieces ).remove();
|
|
|
8776 if ( !show ) {
|
|
|
8777 el.hide();
|
|
|
8778 }
|
|
|
8779 done();
|
|
|
8780 }
|
|
|
8781 };
|
|
|
8782
|
|
|
8783 })(jQuery);
|
|
|
8784 (function( $, undefined ) {
|
|
|
8785
|
|
|
8786 $.effects.effect.fade = function( o, done ) {
|
|
|
8787 var el = $( this ),
|
|
|
8788 mode = $.effects.setMode( el, o.mode || "toggle" );
|
|
|
8789
|
|
|
8790 el.animate({
|
|
|
8791 opacity: mode
|
|
|
8792 }, {
|
|
|
8793 queue: false,
|
|
|
8794 duration: o.duration,
|
|
|
8795 easing: o.easing,
|
|
|
8796 complete: done
|
|
|
8797 });
|
|
|
8798 };
|
|
|
8799
|
|
|
8800 })( jQuery );
|
|
|
8801 (function( $, undefined ) {
|
|
|
8802
|
|
|
8803 $.effects.effect.fold = function( o, done ) {
|
|
|
8804
|
|
|
8805 // Create element
|
|
|
8806 var el = $( this ),
|
|
|
8807 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
|
|
|
8808 mode = $.effects.setMode( el, o.mode || "hide" ),
|
|
|
8809 show = mode === "show",
|
|
|
8810 hide = mode === "hide",
|
|
|
8811 size = o.size || 15,
|
|
|
8812 percent = /([0-9]+)%/.exec( size ),
|
|
|
8813 horizFirst = !!o.horizFirst,
|
|
|
8814 widthFirst = show !== horizFirst,
|
|
|
8815 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
|
|
|
8816 duration = o.duration / 2,
|
|
|
8817 wrapper, distance,
|
|
|
8818 animation1 = {},
|
|
|
8819 animation2 = {};
|
|
|
8820
|
|
|
8821 $.effects.save( el, props );
|
|
|
8822 el.show();
|
|
|
8823
|
|
|
8824 // Create Wrapper
|
|
|
8825 wrapper = $.effects.createWrapper( el ).css({
|
|
|
8826 overflow: "hidden"
|
|
|
8827 });
|
|
|
8828 distance = widthFirst ?
|
|
|
8829 [ wrapper.width(), wrapper.height() ] :
|
|
|
8830 [ wrapper.height(), wrapper.width() ];
|
|
|
8831
|
|
|
8832 if ( percent ) {
|
|
|
8833 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
|
|
|
8834 }
|
|
|
8835 if ( show ) {
|
|
|
8836 wrapper.css( horizFirst ? {
|
|
|
8837 height: 0,
|
|
|
8838 width: size
|
|
|
8839 } : {
|
|
|
8840 height: size,
|
|
|
8841 width: 0
|
|
|
8842 });
|
|
|
8843 }
|
|
|
8844
|
|
|
8845 // Animation
|
|
|
8846 animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
|
|
|
8847 animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
|
|
|
8848
|
|
|
8849 // Animate
|
|
|
8850 wrapper
|
|
|
8851 .animate( animation1, duration, o.easing )
|
|
|
8852 .animate( animation2, duration, o.easing, function() {
|
|
|
8853 if ( hide ) {
|
|
|
8854 el.hide();
|
|
|
8855 }
|
|
|
8856 $.effects.restore( el, props );
|
|
|
8857 $.effects.removeWrapper( el );
|
|
|
8858 done();
|
|
|
8859 });
|
|
|
8860
|
|
|
8861 };
|
|
|
8862
|
|
|
8863 })(jQuery);
|
|
|
8864 (function( $, undefined ) {
|
|
|
8865
|
|
|
8866 $.effects.effect.highlight = function( o, done ) {
|
|
|
8867 var elem = $( this ),
|
|
|
8868 props = [ "backgroundImage", "backgroundColor", "opacity" ],
|
|
|
8869 mode = $.effects.setMode( elem, o.mode || "show" ),
|
|
|
8870 animation = {
|
|
|
8871 backgroundColor: elem.css( "backgroundColor" )
|
|
|
8872 };
|
|
|
8873
|
|
|
8874 if (mode === "hide") {
|
|
|
8875 animation.opacity = 0;
|
|
|
8876 }
|
|
|
8877
|
|
|
8878 $.effects.save( elem, props );
|
|
|
8879
|
|
|
8880 elem
|
|
|
8881 .show()
|
|
|
8882 .css({
|
|
|
8883 backgroundImage: "none",
|
|
|
8884 backgroundColor: o.color || "#ffff99"
|
|
|
8885 })
|
|
|
8886 .animate( animation, {
|
|
|
8887 queue: false,
|
|
|
8888 duration: o.duration,
|
|
|
8889 easing: o.easing,
|
|
|
8890 complete: function() {
|
|
|
8891 if ( mode === "hide" ) {
|
|
|
8892 elem.hide();
|
|
|
8893 }
|
|
|
8894 $.effects.restore( elem, props );
|
|
|
8895 done();
|
|
|
8896 }
|
|
|
8897 });
|
|
|
8898 };
|
|
|
8899
|
|
|
8900 })(jQuery);
|
|
|
8901 (function( $, undefined ) {
|
|
|
8902
|
|
|
8903 $.effects.effect.pulsate = function( o, done ) {
|
|
|
8904 var elem = $( this ),
|
|
|
8905 mode = $.effects.setMode( elem, o.mode || "show" ),
|
|
|
8906 show = mode === "show",
|
|
|
8907 hide = mode === "hide",
|
|
|
8908 showhide = ( show || mode === "hide" ),
|
|
|
8909
|
|
|
8910 // showing or hiding leaves of the "last" animation
|
|
|
8911 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
|
|
|
8912 duration = o.duration / anims,
|
|
|
8913 animateTo = 0,
|
|
|
8914 queue = elem.queue(),
|
|
|
8915 queuelen = queue.length,
|
|
|
8916 i;
|
|
|
8917
|
|
|
8918 if ( show || !elem.is(":visible")) {
|
|
|
8919 elem.css( "opacity", 0 ).show();
|
|
|
8920 animateTo = 1;
|
|
|
8921 }
|
|
|
8922
|
|
|
8923 // anims - 1 opacity "toggles"
|
|
|
8924 for ( i = 1; i < anims; i++ ) {
|
|
|
8925 elem.animate({
|
|
|
8926 opacity: animateTo
|
|
|
8927 }, duration, o.easing );
|
|
|
8928 animateTo = 1 - animateTo;
|
|
|
8929 }
|
|
|
8930
|
|
|
8931 elem.animate({
|
|
|
8932 opacity: animateTo
|
|
|
8933 }, duration, o.easing);
|
|
|
8934
|
|
|
8935 elem.queue(function() {
|
|
|
8936 if ( hide ) {
|
|
|
8937 elem.hide();
|
|
|
8938 }
|
|
|
8939 done();
|
|
|
8940 });
|
|
|
8941
|
|
|
8942 // We just queued up "anims" animations, we need to put them next in the queue
|
|
|
8943 if ( queuelen > 1 ) {
|
|
|
8944 queue.splice.apply( queue,
|
|
|
8945 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
|
|
|
8946 }
|
|
|
8947 elem.dequeue();
|
|
|
8948 };
|
|
|
8949
|
|
|
8950 })(jQuery);
|
|
|
8951 (function( $, undefined ) {
|
|
|
8952
|
|
|
8953 $.effects.effect.puff = function( o, done ) {
|
|
|
8954 var elem = $( this ),
|
|
|
8955 mode = $.effects.setMode( elem, o.mode || "hide" ),
|
|
|
8956 hide = mode === "hide",
|
|
|
8957 percent = parseInt( o.percent, 10 ) || 150,
|
|
|
8958 factor = percent / 100,
|
|
|
8959 original = {
|
|
|
8960 height: elem.height(),
|
|
|
8961 width: elem.width(),
|
|
|
8962 outerHeight: elem.outerHeight(),
|
|
|
8963 outerWidth: elem.outerWidth()
|
|
|
8964 };
|
|
|
8965
|
|
|
8966 $.extend( o, {
|
|
|
8967 effect: "scale",
|
|
|
8968 queue: false,
|
|
|
8969 fade: true,
|
|
|
8970 mode: mode,
|
|
|
8971 complete: done,
|
|
|
8972 percent: hide ? percent : 100,
|
|
|
8973 from: hide ?
|
|
|
8974 original :
|
|
|
8975 {
|
|
|
8976 height: original.height * factor,
|
|
|
8977 width: original.width * factor,
|
|
|
8978 outerHeight: original.outerHeight * factor,
|
|
|
8979 outerWidth: original.outerWidth * factor
|
|
|
8980 }
|
|
|
8981 });
|
|
|
8982
|
|
|
8983 elem.effect( o );
|
|
|
8984 };
|
|
|
8985
|
|
|
8986 $.effects.effect.scale = function( o, done ) {
|
|
|
8987
|
|
|
8988 // Create element
|
|
|
8989 var el = $( this ),
|
|
|
8990 options = $.extend( true, {}, o ),
|
|
|
8991 mode = $.effects.setMode( el, o.mode || "effect" ),
|
|
|
8992 percent = parseInt( o.percent, 10 ) ||
|
|
|
8993 ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
|
|
|
8994 direction = o.direction || "both",
|
|
|
8995 origin = o.origin,
|
|
|
8996 original = {
|
|
|
8997 height: el.height(),
|
|
|
8998 width: el.width(),
|
|
|
8999 outerHeight: el.outerHeight(),
|
|
|
9000 outerWidth: el.outerWidth()
|
|
|
9001 },
|
|
|
9002 factor = {
|
|
|
9003 y: direction !== "horizontal" ? (percent / 100) : 1,
|
|
|
9004 x: direction !== "vertical" ? (percent / 100) : 1
|
|
|
9005 };
|
|
|
9006
|
|
|
9007 // We are going to pass this effect to the size effect:
|
|
|
9008 options.effect = "size";
|
|
|
9009 options.queue = false;
|
|
|
9010 options.complete = done;
|
|
|
9011
|
|
|
9012 // Set default origin and restore for show/hide
|
|
|
9013 if ( mode !== "effect" ) {
|
|
|
9014 options.origin = origin || ["middle","center"];
|
|
|
9015 options.restore = true;
|
|
|
9016 }
|
|
|
9017
|
|
|
9018 options.from = o.from || ( mode === "show" ? {
|
|
|
9019 height: 0,
|
|
|
9020 width: 0,
|
|
|
9021 outerHeight: 0,
|
|
|
9022 outerWidth: 0
|
|
|
9023 } : original );
|
|
|
9024 options.to = {
|
|
|
9025 height: original.height * factor.y,
|
|
|
9026 width: original.width * factor.x,
|
|
|
9027 outerHeight: original.outerHeight * factor.y,
|
|
|
9028 outerWidth: original.outerWidth * factor.x
|
|
|
9029 };
|
|
|
9030
|
|
|
9031 // Fade option to support puff
|
|
|
9032 if ( options.fade ) {
|
|
|
9033 if ( mode === "show" ) {
|
|
|
9034 options.from.opacity = 0;
|
|
|
9035 options.to.opacity = 1;
|
|
|
9036 }
|
|
|
9037 if ( mode === "hide" ) {
|
|
|
9038 options.from.opacity = 1;
|
|
|
9039 options.to.opacity = 0;
|
|
|
9040 }
|
|
|
9041 }
|
|
|
9042
|
|
|
9043 // Animate
|
|
|
9044 el.effect( options );
|
|
|
9045
|
|
|
9046 };
|
|
|
9047
|
|
|
9048 $.effects.effect.size = function( o, done ) {
|
|
|
9049
|
|
|
9050 // Create element
|
|
|
9051 var original, baseline, factor,
|
|
|
9052 el = $( this ),
|
|
|
9053 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
|
|
|
9054
|
|
|
9055 // Always restore
|
|
|
9056 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
|
|
|
9057
|
|
|
9058 // Copy for children
|
|
|
9059 props2 = [ "width", "height", "overflow" ],
|
|
|
9060 cProps = [ "fontSize" ],
|
|
|
9061 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
|
|
|
9062 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
|
|
|
9063
|
|
|
9064 // Set options
|
|
|
9065 mode = $.effects.setMode( el, o.mode || "effect" ),
|
|
|
9066 restore = o.restore || mode !== "effect",
|
|
|
9067 scale = o.scale || "both",
|
|
|
9068 origin = o.origin || [ "middle", "center" ],
|
|
|
9069 position = el.css( "position" ),
|
|
|
9070 props = restore ? props0 : props1,
|
|
|
9071 zero = {
|
|
|
9072 height: 0,
|
|
|
9073 width: 0,
|
|
|
9074 outerHeight: 0,
|
|
|
9075 outerWidth: 0
|
|
|
9076 };
|
|
|
9077
|
|
|
9078 if ( mode === "show" ) {
|
|
|
9079 el.show();
|
|
|
9080 }
|
|
|
9081 original = {
|
|
|
9082 height: el.height(),
|
|
|
9083 width: el.width(),
|
|
|
9084 outerHeight: el.outerHeight(),
|
|
|
9085 outerWidth: el.outerWidth()
|
|
|
9086 };
|
|
|
9087
|
|
|
9088 if ( o.mode === "toggle" && mode === "show" ) {
|
|
|
9089 el.from = o.to || zero;
|
|
|
9090 el.to = o.from || original;
|
|
|
9091 } else {
|
|
|
9092 el.from = o.from || ( mode === "show" ? zero : original );
|
|
|
9093 el.to = o.to || ( mode === "hide" ? zero : original );
|
|
|
9094 }
|
|
|
9095
|
|
|
9096 // Set scaling factor
|
|
|
9097 factor = {
|
|
|
9098 from: {
|
|
|
9099 y: el.from.height / original.height,
|
|
|
9100 x: el.from.width / original.width
|
|
|
9101 },
|
|
|
9102 to: {
|
|
|
9103 y: el.to.height / original.height,
|
|
|
9104 x: el.to.width / original.width
|
|
|
9105 }
|
|
|
9106 };
|
|
|
9107
|
|
|
9108 // Scale the css box
|
|
|
9109 if ( scale === "box" || scale === "both" ) {
|
|
|
9110
|
|
|
9111 // Vertical props scaling
|
|
|
9112 if ( factor.from.y !== factor.to.y ) {
|
|
|
9113 props = props.concat( vProps );
|
|
|
9114 el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
|
|
|
9115 el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
|
|
|
9116 }
|
|
|
9117
|
|
|
9118 // Horizontal props scaling
|
|
|
9119 if ( factor.from.x !== factor.to.x ) {
|
|
|
9120 props = props.concat( hProps );
|
|
|
9121 el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
|
|
|
9122 el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
|
|
|
9123 }
|
|
|
9124 }
|
|
|
9125
|
|
|
9126 // Scale the content
|
|
|
9127 if ( scale === "content" || scale === "both" ) {
|
|
|
9128
|
|
|
9129 // Vertical props scaling
|
|
|
9130 if ( factor.from.y !== factor.to.y ) {
|
|
|
9131 props = props.concat( cProps ).concat( props2 );
|
|
|
9132 el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
|
|
|
9133 el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
|
|
|
9134 }
|
|
|
9135 }
|
|
|
9136
|
|
|
9137 $.effects.save( el, props );
|
|
|
9138 el.show();
|
|
|
9139 $.effects.createWrapper( el );
|
|
|
9140 el.css( "overflow", "hidden" ).css( el.from );
|
|
|
9141
|
|
|
9142 // Adjust
|
|
|
9143 if (origin) { // Calculate baseline shifts
|
|
|
9144 baseline = $.effects.getBaseline( origin, original );
|
|
|
9145 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
|
|
|
9146 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
|
|
|
9147 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
|
|
|
9148 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
|
|
|
9149 }
|
|
|
9150 el.css( el.from ); // set top & left
|
|
|
9151
|
|
|
9152 // Animate
|
|
|
9153 if ( scale === "content" || scale === "both" ) { // Scale the children
|
|
|
9154
|
|
|
9155 // Add margins/font-size
|
|
|
9156 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
|
|
|
9157 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
|
|
|
9158 props2 = props0.concat(vProps).concat(hProps);
|
|
|
9159
|
|
|
9160 el.find( "*[width]" ).each( function(){
|
|
|
9161 var child = $( this ),
|
|
|
9162 c_original = {
|
|
|
9163 height: child.height(),
|
|
|
9164 width: child.width(),
|
|
|
9165 outerHeight: child.outerHeight(),
|
|
|
9166 outerWidth: child.outerWidth()
|
|
|
9167 };
|
|
|
9168 if (restore) {
|
|
|
9169 $.effects.save(child, props2);
|
|
|
9170 }
|
|
|
9171
|
|
|
9172 child.from = {
|
|
|
9173 height: c_original.height * factor.from.y,
|
|
|
9174 width: c_original.width * factor.from.x,
|
|
|
9175 outerHeight: c_original.outerHeight * factor.from.y,
|
|
|
9176 outerWidth: c_original.outerWidth * factor.from.x
|
|
|
9177 };
|
|
|
9178 child.to = {
|
|
|
9179 height: c_original.height * factor.to.y,
|
|
|
9180 width: c_original.width * factor.to.x,
|
|
|
9181 outerHeight: c_original.height * factor.to.y,
|
|
|
9182 outerWidth: c_original.width * factor.to.x
|
|
|
9183 };
|
|
|
9184
|
|
|
9185 // Vertical props scaling
|
|
|
9186 if ( factor.from.y !== factor.to.y ) {
|
|
|
9187 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
|
|
|
9188 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
|
|
|
9189 }
|
|
|
9190
|
|
|
9191 // Horizontal props scaling
|
|
|
9192 if ( factor.from.x !== factor.to.x ) {
|
|
|
9193 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
|
|
|
9194 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
|
|
|
9195 }
|
|
|
9196
|
|
|
9197 // Animate children
|
|
|
9198 child.css( child.from );
|
|
|
9199 child.animate( child.to, o.duration, o.easing, function() {
|
|
|
9200
|
|
|
9201 // Restore children
|
|
|
9202 if ( restore ) {
|
|
|
9203 $.effects.restore( child, props2 );
|
|
|
9204 }
|
|
|
9205 });
|
|
|
9206 });
|
|
|
9207 }
|
|
|
9208
|
|
|
9209 // Animate
|
|
|
9210 el.animate( el.to, {
|
|
|
9211 queue: false,
|
|
|
9212 duration: o.duration,
|
|
|
9213 easing: o.easing,
|
|
|
9214 complete: function() {
|
|
|
9215 if ( el.to.opacity === 0 ) {
|
|
|
9216 el.css( "opacity", el.from.opacity );
|
|
|
9217 }
|
|
|
9218 if( mode === "hide" ) {
|
|
|
9219 el.hide();
|
|
|
9220 }
|
|
|
9221 $.effects.restore( el, props );
|
|
|
9222 if ( !restore ) {
|
|
|
9223
|
|
|
9224 // we need to calculate our new positioning based on the scaling
|
|
|
9225 if ( position === "static" ) {
|
|
|
9226 el.css({
|
|
|
9227 position: "relative",
|
|
|
9228 top: el.to.top,
|
|
|
9229 left: el.to.left
|
|
|
9230 });
|
|
|
9231 } else {
|
|
|
9232 $.each([ "top", "left" ], function( idx, pos ) {
|
|
|
9233 el.css( pos, function( _, str ) {
|
|
|
9234 var val = parseInt( str, 10 ),
|
|
|
9235 toRef = idx ? el.to.left : el.to.top;
|
|
|
9236
|
|
|
9237 // if original was "auto", recalculate the new value from wrapper
|
|
|
9238 if ( str === "auto" ) {
|
|
|
9239 return toRef + "px";
|
|
|
9240 }
|
|
|
9241
|
|
|
9242 return val + toRef + "px";
|
|
|
9243 });
|
|
|
9244 });
|
|
|
9245 }
|
|
|
9246 }
|
|
|
9247
|
|
|
9248 $.effects.removeWrapper( el );
|
|
|
9249 done();
|
|
|
9250 }
|
|
|
9251 });
|
|
|
9252
|
|
|
9253 };
|
|
|
9254
|
|
|
9255 })(jQuery);
|
|
|
9256 (function( $, undefined ) {
|
|
|
9257
|
|
|
9258 $.effects.effect.shake = function( o, done ) {
|
|
|
9259
|
|
|
9260 var el = $( this ),
|
|
|
9261 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
|
|
|
9262 mode = $.effects.setMode( el, o.mode || "effect" ),
|
|
|
9263 direction = o.direction || "left",
|
|
|
9264 distance = o.distance || 20,
|
|
|
9265 times = o.times || 3,
|
|
|
9266 anims = times * 2 + 1,
|
|
|
9267 speed = Math.round(o.duration/anims),
|
|
|
9268 ref = (direction === "up" || direction === "down") ? "top" : "left",
|
|
|
9269 positiveMotion = (direction === "up" || direction === "left"),
|
|
|
9270 animation = {},
|
|
|
9271 animation1 = {},
|
|
|
9272 animation2 = {},
|
|
|
9273 i,
|
|
|
9274
|
|
|
9275 // we will need to re-assemble the queue to stack our animations in place
|
|
|
9276 queue = el.queue(),
|
|
|
9277 queuelen = queue.length;
|
|
|
9278
|
|
|
9279 $.effects.save( el, props );
|
|
|
9280 el.show();
|
|
|
9281 $.effects.createWrapper( el );
|
|
|
9282
|
|
|
9283 // Animation
|
|
|
9284 animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
|
|
|
9285 animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
|
|
|
9286 animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
|
|
|
9287
|
|
|
9288 // Animate
|
|
|
9289 el.animate( animation, speed, o.easing );
|
|
|
9290
|
|
|
9291 // Shakes
|
|
|
9292 for ( i = 1; i < times; i++ ) {
|
|
|
9293 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
|
|
|
9294 }
|
|
|
9295 el
|
|
|
9296 .animate( animation1, speed, o.easing )
|
|
|
9297 .animate( animation, speed / 2, o.easing )
|
|
|
9298 .queue(function() {
|
|
|
9299 if ( mode === "hide" ) {
|
|
|
9300 el.hide();
|
|
|
9301 }
|
|
|
9302 $.effects.restore( el, props );
|
|
|
9303 $.effects.removeWrapper( el );
|
|
|
9304 done();
|
|
|
9305 });
|
|
|
9306
|
|
|
9307 // inject all the animations we just queued to be first in line (after "inprogress")
|
|
|
9308 if ( queuelen > 1) {
|
|
|
9309 queue.splice.apply( queue,
|
|
|
9310 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
|
|
|
9311 }
|
|
|
9312 el.dequeue();
|
|
|
9313
|
|
|
9314 };
|
|
|
9315
|
|
|
9316 })(jQuery);
|
|
|
9317 (function( $, undefined ) {
|
|
|
9318
|
|
|
9319 $.effects.effect.slide = function( o, done ) {
|
|
|
9320
|
|
|
9321 // Create element
|
|
|
9322 var el = $( this ),
|
|
|
9323 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
|
|
|
9324 mode = $.effects.setMode( el, o.mode || "show" ),
|
|
|
9325 show = mode === "show",
|
|
|
9326 direction = o.direction || "left",
|
|
|
9327 ref = (direction === "up" || direction === "down") ? "top" : "left",
|
|
|
9328 positiveMotion = (direction === "up" || direction === "left"),
|
|
|
9329 distance,
|
|
|
9330 animation = {};
|
|
|
9331
|
|
|
9332 // Adjust
|
|
|
9333 $.effects.save( el, props );
|
|
|
9334 el.show();
|
|
|
9335 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
|
|
|
9336
|
|
|
9337 $.effects.createWrapper( el ).css({
|
|
|
9338 overflow: "hidden"
|
|
|
9339 });
|
|
|
9340
|
|
|
9341 if ( show ) {
|
|
|
9342 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
|
|
|
9343 }
|
|
|
9344
|
|
|
9345 // Animation
|
|
|
9346 animation[ ref ] = ( show ?
|
|
|
9347 ( positiveMotion ? "+=" : "-=") :
|
|
|
9348 ( positiveMotion ? "-=" : "+=")) +
|
|
|
9349 distance;
|
|
|
9350
|
|
|
9351 // Animate
|
|
|
9352 el.animate( animation, {
|
|
|
9353 queue: false,
|
|
|
9354 duration: o.duration,
|
|
|
9355 easing: o.easing,
|
|
|
9356 complete: function() {
|
|
|
9357 if ( mode === "hide" ) {
|
|
|
9358 el.hide();
|
|
|
9359 }
|
|
|
9360 $.effects.restore( el, props );
|
|
|
9361 $.effects.removeWrapper( el );
|
|
|
9362 done();
|
|
|
9363 }
|
|
|
9364 });
|
|
|
9365 };
|
|
|
9366
|
|
|
9367 })(jQuery);
|
|
|
9368 (function( $, undefined ) {
|
|
|
9369
|
|
|
9370 $.effects.effect.transfer = function( o, done ) {
|
|
|
9371 var elem = $( this ),
|
|
|
9372 target = $( o.to ),
|
|
|
9373 targetFixed = target.css( "position" ) === "fixed",
|
|
|
9374 body = $("body"),
|
|
|
9375 fixTop = targetFixed ? body.scrollTop() : 0,
|
|
|
9376 fixLeft = targetFixed ? body.scrollLeft() : 0,
|
|
|
9377 endPosition = target.offset(),
|
|
|
9378 animation = {
|
|
|
9379 top: endPosition.top - fixTop ,
|
|
|
9380 left: endPosition.left - fixLeft ,
|
|
|
9381 height: target.innerHeight(),
|
|
|
9382 width: target.innerWidth()
|
|
|
9383 },
|
|
|
9384 startPosition = elem.offset(),
|
|
|
9385 transfer = $( "<div class='ui-effects-transfer'></div>" )
|
|
|
9386 .appendTo( document.body )
|
|
|
9387 .addClass( o.className )
|
|
|
9388 .css({
|
|
|
9389 top: startPosition.top - fixTop ,
|
|
|
9390 left: startPosition.left - fixLeft ,
|
|
|
9391 height: elem.innerHeight(),
|
|
|
9392 width: elem.innerWidth(),
|
|
|
9393 position: targetFixed ? "fixed" : "absolute"
|
|
|
9394 })
|
|
|
9395 .animate( animation, o.duration, o.easing, function() {
|
|
|
9396 transfer.remove();
|
|
|
9397 done();
|
|
|
9398 });
|
|
|
9399 };
|
|
|
9400
|
|
|
9401 })(jQuery);
|
|
|
9402 (function( $, undefined ) {
|
|
|
9403
|
|
|
9404 $.widget( "ui.menu", {
|
|
|
9405 version: "1.10.4",
|
|
|
9406 defaultElement: "<ul>",
|
|
|
9407 delay: 300,
|
|
|
9408 options: {
|
|
|
9409 icons: {
|
|
|
9410 submenu: "ui-icon-carat-1-e"
|
|
|
9411 },
|
|
|
9412 menus: "ul",
|
|
|
9413 position: {
|
|
|
9414 my: "left top",
|
|
|
9415 at: "right top"
|
|
|
9416 },
|
|
|
9417 role: "menu",
|
|
|
9418
|
|
|
9419 // callbacks
|
|
|
9420 blur: null,
|
|
|
9421 focus: null,
|
|
|
9422 select: null
|
|
|
9423 },
|
|
|
9424
|
|
|
9425 _create: function() {
|
|
|
9426 this.activeMenu = this.element;
|
|
|
9427 // flag used to prevent firing of the click handler
|
|
|
9428 // as the event bubbles up through nested menus
|
|
|
9429 this.mouseHandled = false;
|
|
|
9430 this.element
|
|
|
9431 .uniqueId()
|
|
|
9432 .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
|
|
|
9433 .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
|
|
|
9434 .attr({
|
|
|
9435 role: this.options.role,
|
|
|
9436 tabIndex: 0
|
|
|
9437 })
|
|
|
9438 // need to catch all clicks on disabled menu
|
|
|
9439 // not possible through _on
|
|
|
9440 .bind( "click" + this.eventNamespace, $.proxy(function( event ) {
|
|
|
9441 if ( this.options.disabled ) {
|
|
|
9442 event.preventDefault();
|
|
|
9443 }
|
|
|
9444 }, this ));
|
|
|
9445
|
|
|
9446 if ( this.options.disabled ) {
|
|
|
9447 this.element
|
|
|
9448 .addClass( "ui-state-disabled" )
|
|
|
9449 .attr( "aria-disabled", "true" );
|
|
|
9450 }
|
|
|
9451
|
|
|
9452 this._on({
|
|
|
9453 // Prevent focus from sticking to links inside menu after clicking
|
|
|
9454 // them (focus should always stay on UL during navigation).
|
|
|
9455 "mousedown .ui-menu-item > a": function( event ) {
|
|
|
9456 event.preventDefault();
|
|
|
9457 },
|
|
|
9458 "click .ui-state-disabled > a": function( event ) {
|
|
|
9459 event.preventDefault();
|
|
|
9460 },
|
|
|
9461 "click .ui-menu-item:has(a)": function( event ) {
|
|
|
9462 var target = $( event.target ).closest( ".ui-menu-item" );
|
|
|
9463 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
|
|
|
9464 this.select( event );
|
|
|
9465
|
|
|
9466 // Only set the mouseHandled flag if the event will bubble, see #9469.
|
|
|
9467 if ( !event.isPropagationStopped() ) {
|
|
|
9468 this.mouseHandled = true;
|
|
|
9469 }
|
|
|
9470
|
|
|
9471 // Open submenu on click
|
|
|
9472 if ( target.has( ".ui-menu" ).length ) {
|
|
|
9473 this.expand( event );
|
|
|
9474 } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
|
|
|
9475
|
|
|
9476 // Redirect focus to the menu
|
|
|
9477 this.element.trigger( "focus", [ true ] );
|
|
|
9478
|
|
|
9479 // If the active item is on the top level, let it stay active.
|
|
|
9480 // Otherwise, blur the active item since it is no longer visible.
|
|
|
9481 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
|
|
|
9482 clearTimeout( this.timer );
|
|
|
9483 }
|
|
|
9484 }
|
|
|
9485 }
|
|
|
9486 },
|
|
|
9487 "mouseenter .ui-menu-item": function( event ) {
|
|
|
9488 var target = $( event.currentTarget );
|
|
|
9489 // Remove ui-state-active class from siblings of the newly focused menu item
|
|
|
9490 // to avoid a jump caused by adjacent elements both having a class with a border
|
|
|
9491 target.siblings().children( ".ui-state-active" ).removeClass( "ui-state-active" );
|
|
|
9492 this.focus( event, target );
|
|
|
9493 },
|
|
|
9494 mouseleave: "collapseAll",
|
|
|
9495 "mouseleave .ui-menu": "collapseAll",
|
|
|
9496 focus: function( event, keepActiveItem ) {
|
|
|
9497 // If there's already an active item, keep it active
|
|
|
9498 // If not, activate the first item
|
|
|
9499 var item = this.active || this.element.children( ".ui-menu-item" ).eq( 0 );
|
|
|
9500
|
|
|
9501 if ( !keepActiveItem ) {
|
|
|
9502 this.focus( event, item );
|
|
|
9503 }
|
|
|
9504 },
|
|
|
9505 blur: function( event ) {
|
|
|
9506 this._delay(function() {
|
|
|
9507 if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
|
|
|
9508 this.collapseAll( event );
|
|
|
9509 }
|
|
|
9510 });
|
|
|
9511 },
|
|
|
9512 keydown: "_keydown"
|
|
|
9513 });
|
|
|
9514
|
|
|
9515 this.refresh();
|
|
|
9516
|
|
|
9517 // Clicks outside of a menu collapse any open menus
|
|
|
9518 this._on( this.document, {
|
|
|
9519 click: function( event ) {
|
|
|
9520 if ( !$( event.target ).closest( ".ui-menu" ).length ) {
|
|
|
9521 this.collapseAll( event );
|
|
|
9522 }
|
|
|
9523
|
|
|
9524 // Reset the mouseHandled flag
|
|
|
9525 this.mouseHandled = false;
|
|
|
9526 }
|
|
|
9527 });
|
|
|
9528 },
|
|
|
9529
|
|
|
9530 _destroy: function() {
|
|
|
9531 // Destroy (sub)menus
|
|
|
9532 this.element
|
|
|
9533 .removeAttr( "aria-activedescendant" )
|
|
|
9534 .find( ".ui-menu" ).addBack()
|
|
|
9535 .removeClass( "ui-menu ui-widget ui-widget-content ui-corner-all ui-menu-icons" )
|
|
|
9536 .removeAttr( "role" )
|
|
|
9537 .removeAttr( "tabIndex" )
|
|
|
9538 .removeAttr( "aria-labelledby" )
|
|
|
9539 .removeAttr( "aria-expanded" )
|
|
|
9540 .removeAttr( "aria-hidden" )
|
|
|
9541 .removeAttr( "aria-disabled" )
|
|
|
9542 .removeUniqueId()
|
|
|
9543 .show();
|
|
|
9544
|
|
|
9545 // Destroy menu items
|
|
|
9546 this.element.find( ".ui-menu-item" )
|
|
|
9547 .removeClass( "ui-menu-item" )
|
|
|
9548 .removeAttr( "role" )
|
|
|
9549 .removeAttr( "aria-disabled" )
|
|
|
9550 .children( "a" )
|
|
|
9551 .removeUniqueId()
|
|
|
9552 .removeClass( "ui-corner-all ui-state-hover" )
|
|
|
9553 .removeAttr( "tabIndex" )
|
|
|
9554 .removeAttr( "role" )
|
|
|
9555 .removeAttr( "aria-haspopup" )
|
|
|
9556 .children().each( function() {
|
|
|
9557 var elem = $( this );
|
|
|
9558 if ( elem.data( "ui-menu-submenu-carat" ) ) {
|
|
|
9559 elem.remove();
|
|
|
9560 }
|
|
|
9561 });
|
|
|
9562
|
|
|
9563 // Destroy menu dividers
|
|
|
9564 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
|
|
|
9565 },
|
|
|
9566
|
|
|
9567 _keydown: function( event ) {
|
|
|
9568 var match, prev, character, skip, regex,
|
|
|
9569 preventDefault = true;
|
|
|
9570
|
|
|
9571 function escape( value ) {
|
|
|
9572 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
|
|
|
9573 }
|
|
|
9574
|
|
|
9575 switch ( event.keyCode ) {
|
|
|
9576 case $.ui.keyCode.PAGE_UP:
|
|
|
9577 this.previousPage( event );
|
|
|
9578 break;
|
|
|
9579 case $.ui.keyCode.PAGE_DOWN:
|
|
|
9580 this.nextPage( event );
|
|
|
9581 break;
|
|
|
9582 case $.ui.keyCode.HOME:
|
|
|
9583 this._move( "first", "first", event );
|
|
|
9584 break;
|
|
|
9585 case $.ui.keyCode.END:
|
|
|
9586 this._move( "last", "last", event );
|
|
|
9587 break;
|
|
|
9588 case $.ui.keyCode.UP:
|
|
|
9589 this.previous( event );
|
|
|
9590 break;
|
|
|
9591 case $.ui.keyCode.DOWN:
|
|
|
9592 this.next( event );
|
|
|
9593 break;
|
|
|
9594 case $.ui.keyCode.LEFT:
|
|
|
9595 this.collapse( event );
|
|
|
9596 break;
|
|
|
9597 case $.ui.keyCode.RIGHT:
|
|
|
9598 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
|
|
|
9599 this.expand( event );
|
|
|
9600 }
|
|
|
9601 break;
|
|
|
9602 case $.ui.keyCode.ENTER:
|
|
|
9603 case $.ui.keyCode.SPACE:
|
|
|
9604 this._activate( event );
|
|
|
9605 break;
|
|
|
9606 case $.ui.keyCode.ESCAPE:
|
|
|
9607 this.collapse( event );
|
|
|
9608 break;
|
|
|
9609 default:
|
|
|
9610 preventDefault = false;
|
|
|
9611 prev = this.previousFilter || "";
|
|
|
9612 character = String.fromCharCode( event.keyCode );
|
|
|
9613 skip = false;
|
|
|
9614
|
|
|
9615 clearTimeout( this.filterTimer );
|
|
|
9616
|
|
|
9617 if ( character === prev ) {
|
|
|
9618 skip = true;
|
|
|
9619 } else {
|
|
|
9620 character = prev + character;
|
|
|
9621 }
|
|
|
9622
|
|
|
9623 regex = new RegExp( "^" + escape( character ), "i" );
|
|
|
9624 match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
|
|
|
9625 return regex.test( $( this ).children( "a" ).text() );
|
|
|
9626 });
|
|
|
9627 match = skip && match.index( this.active.next() ) !== -1 ?
|
|
|
9628 this.active.nextAll( ".ui-menu-item" ) :
|
|
|
9629 match;
|
|
|
9630
|
|
|
9631 // If no matches on the current filter, reset to the last character pressed
|
|
|
9632 // to move down the menu to the first item that starts with that character
|
|
|
9633 if ( !match.length ) {
|
|
|
9634 character = String.fromCharCode( event.keyCode );
|
|
|
9635 regex = new RegExp( "^" + escape( character ), "i" );
|
|
|
9636 match = this.activeMenu.children( ".ui-menu-item" ).filter(function() {
|
|
|
9637 return regex.test( $( this ).children( "a" ).text() );
|
|
|
9638 });
|
|
|
9639 }
|
|
|
9640
|
|
|
9641 if ( match.length ) {
|
|
|
9642 this.focus( event, match );
|
|
|
9643 if ( match.length > 1 ) {
|
|
|
9644 this.previousFilter = character;
|
|
|
9645 this.filterTimer = this._delay(function() {
|
|
|
9646 delete this.previousFilter;
|
|
|
9647 }, 1000 );
|
|
|
9648 } else {
|
|
|
9649 delete this.previousFilter;
|
|
|
9650 }
|
|
|
9651 } else {
|
|
|
9652 delete this.previousFilter;
|
|
|
9653 }
|
|
|
9654 }
|
|
|
9655
|
|
|
9656 if ( preventDefault ) {
|
|
|
9657 event.preventDefault();
|
|
|
9658 }
|
|
|
9659 },
|
|
|
9660
|
|
|
9661 _activate: function( event ) {
|
|
|
9662 if ( !this.active.is( ".ui-state-disabled" ) ) {
|
|
|
9663 if ( this.active.children( "a[aria-haspopup='true']" ).length ) {
|
|
|
9664 this.expand( event );
|
|
|
9665 } else {
|
|
|
9666 this.select( event );
|
|
|
9667 }
|
|
|
9668 }
|
|
|
9669 },
|
|
|
9670
|
|
|
9671 refresh: function() {
|
|
|
9672 var menus,
|
|
|
9673 icon = this.options.icons.submenu,
|
|
|
9674 submenus = this.element.find( this.options.menus );
|
|
|
9675
|
|
|
9676 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
|
|
|
9677
|
|
|
9678 // Initialize nested menus
|
|
|
9679 submenus.filter( ":not(.ui-menu)" )
|
|
|
9680 .addClass( "ui-menu ui-widget ui-widget-content ui-corner-all" )
|
|
|
9681 .hide()
|
|
|
9682 .attr({
|
|
|
9683 role: this.options.role,
|
|
|
9684 "aria-hidden": "true",
|
|
|
9685 "aria-expanded": "false"
|
|
|
9686 })
|
|
|
9687 .each(function() {
|
|
|
9688 var menu = $( this ),
|
|
|
9689 item = menu.prev( "a" ),
|
|
|
9690 submenuCarat = $( "<span>" )
|
|
|
9691 .addClass( "ui-menu-icon ui-icon " + icon )
|
|
|
9692 .data( "ui-menu-submenu-carat", true );
|
|
|
9693
|
|
|
9694 item
|
|
|
9695 .attr( "aria-haspopup", "true" )
|
|
|
9696 .prepend( submenuCarat );
|
|
|
9697 menu.attr( "aria-labelledby", item.attr( "id" ) );
|
|
|
9698 });
|
|
|
9699
|
|
|
9700 menus = submenus.add( this.element );
|
|
|
9701
|
|
|
9702 // Don't refresh list items that are already adapted
|
|
|
9703 menus.children( ":not(.ui-menu-item):has(a)" )
|
|
|
9704 .addClass( "ui-menu-item" )
|
|
|
9705 .attr( "role", "presentation" )
|
|
|
9706 .children( "a" )
|
|
|
9707 .uniqueId()
|
|
|
9708 .addClass( "ui-corner-all" )
|
|
|
9709 .attr({
|
|
|
9710 tabIndex: -1,
|
|
|
9711 role: this._itemRole()
|
|
|
9712 });
|
|
|
9713
|
|
|
9714 // Initialize unlinked menu-items containing spaces and/or dashes only as dividers
|
|
|
9715 menus.children( ":not(.ui-menu-item)" ).each(function() {
|
|
|
9716 var item = $( this );
|
|
|
9717 // hyphen, em dash, en dash
|
|
|
9718 if ( !/[^\-\u2014\u2013\s]/.test( item.text() ) ) {
|
|
|
9719 item.addClass( "ui-widget-content ui-menu-divider" );
|
|
|
9720 }
|
|
|
9721 });
|
|
|
9722
|
|
|
9723 // Add aria-disabled attribute to any disabled menu item
|
|
|
9724 menus.children( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
|
|
|
9725
|
|
|
9726 // If the active item has been removed, blur the menu
|
|
|
9727 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
|
|
|
9728 this.blur();
|
|
|
9729 }
|
|
|
9730 },
|
|
|
9731
|
|
|
9732 _itemRole: function() {
|
|
|
9733 return {
|
|
|
9734 menu: "menuitem",
|
|
|
9735 listbox: "option"
|
|
|
9736 }[ this.options.role ];
|
|
|
9737 },
|
|
|
9738
|
|
|
9739 _setOption: function( key, value ) {
|
|
|
9740 if ( key === "icons" ) {
|
|
|
9741 this.element.find( ".ui-menu-icon" )
|
|
|
9742 .removeClass( this.options.icons.submenu )
|
|
|
9743 .addClass( value.submenu );
|
|
|
9744 }
|
|
|
9745 this._super( key, value );
|
|
|
9746 },
|
|
|
9747
|
|
|
9748 focus: function( event, item ) {
|
|
|
9749 var nested, focused;
|
|
|
9750 this.blur( event, event && event.type === "focus" );
|
|
|
9751
|
|
|
9752 this._scrollIntoView( item );
|
|
|
9753
|
|
|
9754 this.active = item.first();
|
|
|
9755 focused = this.active.children( "a" ).addClass( "ui-state-focus" );
|
|
|
9756 // Only update aria-activedescendant if there's a role
|
|
|
9757 // otherwise we assume focus is managed elsewhere
|
|
|
9758 if ( this.options.role ) {
|
|
|
9759 this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
|
|
|
9760 }
|
|
|
9761
|
|
|
9762 // Highlight active parent menu item, if any
|
|
|
9763 this.active
|
|
|
9764 .parent()
|
|
|
9765 .closest( ".ui-menu-item" )
|
|
|
9766 .children( "a:first" )
|
|
|
9767 .addClass( "ui-state-active" );
|
|
|
9768
|
|
|
9769 if ( event && event.type === "keydown" ) {
|
|
|
9770 this._close();
|
|
|
9771 } else {
|
|
|
9772 this.timer = this._delay(function() {
|
|
|
9773 this._close();
|
|
|
9774 }, this.delay );
|
|
|
9775 }
|
|
|
9776
|
|
|
9777 nested = item.children( ".ui-menu" );
|
|
|
9778 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
|
|
|
9779 this._startOpening(nested);
|
|
|
9780 }
|
|
|
9781 this.activeMenu = item.parent();
|
|
|
9782
|
|
|
9783 this._trigger( "focus", event, { item: item } );
|
|
|
9784 },
|
|
|
9785
|
|
|
9786 _scrollIntoView: function( item ) {
|
|
|
9787 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
|
|
|
9788 if ( this._hasScroll() ) {
|
|
|
9789 borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
|
|
|
9790 paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
|
|
|
9791 offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
|
|
|
9792 scroll = this.activeMenu.scrollTop();
|
|
|
9793 elementHeight = this.activeMenu.height();
|
|
|
9794 itemHeight = item.height();
|
|
|
9795
|
|
|
9796 if ( offset < 0 ) {
|
|
|
9797 this.activeMenu.scrollTop( scroll + offset );
|
|
|
9798 } else if ( offset + itemHeight > elementHeight ) {
|
|
|
9799 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
|
|
|
9800 }
|
|
|
9801 }
|
|
|
9802 },
|
|
|
9803
|
|
|
9804 blur: function( event, fromFocus ) {
|
|
|
9805 if ( !fromFocus ) {
|
|
|
9806 clearTimeout( this.timer );
|
|
|
9807 }
|
|
|
9808
|
|
|
9809 if ( !this.active ) {
|
|
|
9810 return;
|
|
|
9811 }
|
|
|
9812
|
|
|
9813 this.active.children( "a" ).removeClass( "ui-state-focus" );
|
|
|
9814 this.active = null;
|
|
|
9815
|
|
|
9816 this._trigger( "blur", event, { item: this.active } );
|
|
|
9817 },
|
|
|
9818
|
|
|
9819 _startOpening: function( submenu ) {
|
|
|
9820 clearTimeout( this.timer );
|
|
|
9821
|
|
|
9822 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
|
|
|
9823 // shift in the submenu position when mousing over the carat icon
|
|
|
9824 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
|
|
|
9825 return;
|
|
|
9826 }
|
|
|
9827
|
|
|
9828 this.timer = this._delay(function() {
|
|
|
9829 this._close();
|
|
|
9830 this._open( submenu );
|
|
|
9831 }, this.delay );
|
|
|
9832 },
|
|
|
9833
|
|
|
9834 _open: function( submenu ) {
|
|
|
9835 var position = $.extend({
|
|
|
9836 of: this.active
|
|
|
9837 }, this.options.position );
|
|
|
9838
|
|
|
9839 clearTimeout( this.timer );
|
|
|
9840 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
|
|
|
9841 .hide()
|
|
|
9842 .attr( "aria-hidden", "true" );
|
|
|
9843
|
|
|
9844 submenu
|
|
|
9845 .show()
|
|
|
9846 .removeAttr( "aria-hidden" )
|
|
|
9847 .attr( "aria-expanded", "true" )
|
|
|
9848 .position( position );
|
|
|
9849 },
|
|
|
9850
|
|
|
9851 collapseAll: function( event, all ) {
|
|
|
9852 clearTimeout( this.timer );
|
|
|
9853 this.timer = this._delay(function() {
|
|
|
9854 // If we were passed an event, look for the submenu that contains the event
|
|
|
9855 var currentMenu = all ? this.element :
|
|
|
9856 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
|
|
|
9857
|
|
|
9858 // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
|
|
|
9859 if ( !currentMenu.length ) {
|
|
|
9860 currentMenu = this.element;
|
|
|
9861 }
|
|
|
9862
|
|
|
9863 this._close( currentMenu );
|
|
|
9864
|
|
|
9865 this.blur( event );
|
|
|
9866 this.activeMenu = currentMenu;
|
|
|
9867 }, this.delay );
|
|
|
9868 },
|
|
|
9869
|
|
|
9870 // With no arguments, closes the currently active menu - if nothing is active
|
|
|
9871 // it closes all menus. If passed an argument, it will search for menus BELOW
|
|
|
9872 _close: function( startMenu ) {
|
|
|
9873 if ( !startMenu ) {
|
|
|
9874 startMenu = this.active ? this.active.parent() : this.element;
|
|
|
9875 }
|
|
|
9876
|
|
|
9877 startMenu
|
|
|
9878 .find( ".ui-menu" )
|
|
|
9879 .hide()
|
|
|
9880 .attr( "aria-hidden", "true" )
|
|
|
9881 .attr( "aria-expanded", "false" )
|
|
|
9882 .end()
|
|
|
9883 .find( "a.ui-state-active" )
|
|
|
9884 .removeClass( "ui-state-active" );
|
|
|
9885 },
|
|
|
9886
|
|
|
9887 collapse: function( event ) {
|
|
|
9888 var newItem = this.active &&
|
|
|
9889 this.active.parent().closest( ".ui-menu-item", this.element );
|
|
|
9890 if ( newItem && newItem.length ) {
|
|
|
9891 this._close();
|
|
|
9892 this.focus( event, newItem );
|
|
|
9893 }
|
|
|
9894 },
|
|
|
9895
|
|
|
9896 expand: function( event ) {
|
|
|
9897 var newItem = this.active &&
|
|
|
9898 this.active
|
|
|
9899 .children( ".ui-menu " )
|
|
|
9900 .children( ".ui-menu-item" )
|
|
|
9901 .first();
|
|
|
9902
|
|
|
9903 if ( newItem && newItem.length ) {
|
|
|
9904 this._open( newItem.parent() );
|
|
|
9905
|
|
|
9906 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
|
|
|
9907 this._delay(function() {
|
|
|
9908 this.focus( event, newItem );
|
|
|
9909 });
|
|
|
9910 }
|
|
|
9911 },
|
|
|
9912
|
|
|
9913 next: function( event ) {
|
|
|
9914 this._move( "next", "first", event );
|
|
|
9915 },
|
|
|
9916
|
|
|
9917 previous: function( event ) {
|
|
|
9918 this._move( "prev", "last", event );
|
|
|
9919 },
|
|
|
9920
|
|
|
9921 isFirstItem: function() {
|
|
|
9922 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
|
|
|
9923 },
|
|
|
9924
|
|
|
9925 isLastItem: function() {
|
|
|
9926 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
|
|
|
9927 },
|
|
|
9928
|
|
|
9929 _move: function( direction, filter, event ) {
|
|
|
9930 var next;
|
|
|
9931 if ( this.active ) {
|
|
|
9932 if ( direction === "first" || direction === "last" ) {
|
|
|
9933 next = this.active
|
|
|
9934 [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
|
|
|
9935 .eq( -1 );
|
|
|
9936 } else {
|
|
|
9937 next = this.active
|
|
|
9938 [ direction + "All" ]( ".ui-menu-item" )
|
|
|
9939 .eq( 0 );
|
|
|
9940 }
|
|
|
9941 }
|
|
|
9942 if ( !next || !next.length || !this.active ) {
|
|
|
9943 next = this.activeMenu.children( ".ui-menu-item" )[ filter ]();
|
|
|
9944 }
|
|
|
9945
|
|
|
9946 this.focus( event, next );
|
|
|
9947 },
|
|
|
9948
|
|
|
9949 nextPage: function( event ) {
|
|
|
9950 var item, base, height;
|
|
|
9951
|
|
|
9952 if ( !this.active ) {
|
|
|
9953 this.next( event );
|
|
|
9954 return;
|
|
|
9955 }
|
|
|
9956 if ( this.isLastItem() ) {
|
|
|
9957 return;
|
|
|
9958 }
|
|
|
9959 if ( this._hasScroll() ) {
|
|
|
9960 base = this.active.offset().top;
|
|
|
9961 height = this.element.height();
|
|
|
9962 this.active.nextAll( ".ui-menu-item" ).each(function() {
|
|
|
9963 item = $( this );
|
|
|
9964 return item.offset().top - base - height < 0;
|
|
|
9965 });
|
|
|
9966
|
|
|
9967 this.focus( event, item );
|
|
|
9968 } else {
|
|
|
9969 this.focus( event, this.activeMenu.children( ".ui-menu-item" )
|
|
|
9970 [ !this.active ? "first" : "last" ]() );
|
|
|
9971 }
|
|
|
9972 },
|
|
|
9973
|
|
|
9974 previousPage: function( event ) {
|
|
|
9975 var item, base, height;
|
|
|
9976 if ( !this.active ) {
|
|
|
9977 this.next( event );
|
|
|
9978 return;
|
|
|
9979 }
|
|
|
9980 if ( this.isFirstItem() ) {
|
|
|
9981 return;
|
|
|
9982 }
|
|
|
9983 if ( this._hasScroll() ) {
|
|
|
9984 base = this.active.offset().top;
|
|
|
9985 height = this.element.height();
|
|
|
9986 this.active.prevAll( ".ui-menu-item" ).each(function() {
|
|
|
9987 item = $( this );
|
|
|
9988 return item.offset().top - base + height > 0;
|
|
|
9989 });
|
|
|
9990
|
|
|
9991 this.focus( event, item );
|
|
|
9992 } else {
|
|
|
9993 this.focus( event, this.activeMenu.children( ".ui-menu-item" ).first() );
|
|
|
9994 }
|
|
|
9995 },
|
|
|
9996
|
|
|
9997 _hasScroll: function() {
|
|
|
9998 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
|
|
|
9999 },
|
|
|
10000
|
|
|
10001 select: function( event ) {
|
|
|
10002 // TODO: It should never be possible to not have an active item at this
|
|
|
10003 // point, but the tests don't trigger mouseenter before click.
|
|
|
10004 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
|
|
|
10005 var ui = { item: this.active };
|
|
|
10006 if ( !this.active.has( ".ui-menu" ).length ) {
|
|
|
10007 this.collapseAll( event, true );
|
|
|
10008 }
|
|
|
10009 this._trigger( "select", event, ui );
|
|
|
10010 }
|
|
|
10011 });
|
|
|
10012
|
|
|
10013 }( jQuery ));
|
|
|
10014 (function( $, undefined ) {
|
|
|
10015
|
|
|
10016 $.widget( "ui.progressbar", {
|
|
|
10017 version: "1.10.4",
|
|
|
10018 options: {
|
|
|
10019 max: 100,
|
|
|
10020 value: 0,
|
|
|
10021
|
|
|
10022 change: null,
|
|
|
10023 complete: null
|
|
|
10024 },
|
|
|
10025
|
|
|
10026 min: 0,
|
|
|
10027
|
|
|
10028 _create: function() {
|
|
|
10029 // Constrain initial value
|
|
|
10030 this.oldValue = this.options.value = this._constrainedValue();
|
|
|
10031
|
|
|
10032 this.element
|
|
|
10033 .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
|
|
|
10034 .attr({
|
|
|
10035 // Only set static values, aria-valuenow and aria-valuemax are
|
|
|
10036 // set inside _refreshValue()
|
|
|
10037 role: "progressbar",
|
|
|
10038 "aria-valuemin": this.min
|
|
|
10039 });
|
|
|
10040
|
|
|
10041 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
|
|
|
10042 .appendTo( this.element );
|
|
|
10043
|
|
|
10044 this._refreshValue();
|
|
|
10045 },
|
|
|
10046
|
|
|
10047 _destroy: function() {
|
|
|
10048 this.element
|
|
|
10049 .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
|
|
|
10050 .removeAttr( "role" )
|
|
|
10051 .removeAttr( "aria-valuemin" )
|
|
|
10052 .removeAttr( "aria-valuemax" )
|
|
|
10053 .removeAttr( "aria-valuenow" );
|
|
|
10054
|
|
|
10055 this.valueDiv.remove();
|
|
|
10056 },
|
|
|
10057
|
|
|
10058 value: function( newValue ) {
|
|
|
10059 if ( newValue === undefined ) {
|
|
|
10060 return this.options.value;
|
|
|
10061 }
|
|
|
10062
|
|
|
10063 this.options.value = this._constrainedValue( newValue );
|
|
|
10064 this._refreshValue();
|
|
|
10065 },
|
|
|
10066
|
|
|
10067 _constrainedValue: function( newValue ) {
|
|
|
10068 if ( newValue === undefined ) {
|
|
|
10069 newValue = this.options.value;
|
|
|
10070 }
|
|
|
10071
|
|
|
10072 this.indeterminate = newValue === false;
|
|
|
10073
|
|
|
10074 // sanitize value
|
|
|
10075 if ( typeof newValue !== "number" ) {
|
|
|
10076 newValue = 0;
|
|
|
10077 }
|
|
|
10078
|
|
|
10079 return this.indeterminate ? false :
|
|
|
10080 Math.min( this.options.max, Math.max( this.min, newValue ) );
|
|
|
10081 },
|
|
|
10082
|
|
|
10083 _setOptions: function( options ) {
|
|
|
10084 // Ensure "value" option is set after other values (like max)
|
|
|
10085 var value = options.value;
|
|
|
10086 delete options.value;
|
|
|
10087
|
|
|
10088 this._super( options );
|
|
|
10089
|
|
|
10090 this.options.value = this._constrainedValue( value );
|
|
|
10091 this._refreshValue();
|
|
|
10092 },
|
|
|
10093
|
|
|
10094 _setOption: function( key, value ) {
|
|
|
10095 if ( key === "max" ) {
|
|
|
10096 // Don't allow a max less than min
|
|
|
10097 value = Math.max( this.min, value );
|
|
|
10098 }
|
|
|
10099
|
|
|
10100 this._super( key, value );
|
|
|
10101 },
|
|
|
10102
|
|
|
10103 _percentage: function() {
|
|
|
10104 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
|
|
|
10105 },
|
|
|
10106
|
|
|
10107 _refreshValue: function() {
|
|
|
10108 var value = this.options.value,
|
|
|
10109 percentage = this._percentage();
|
|
|
10110
|
|
|
10111 this.valueDiv
|
|
|
10112 .toggle( this.indeterminate || value > this.min )
|
|
|
10113 .toggleClass( "ui-corner-right", value === this.options.max )
|
|
|
10114 .width( percentage.toFixed(0) + "%" );
|
|
|
10115
|
|
|
10116 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
|
|
|
10117
|
|
|
10118 if ( this.indeterminate ) {
|
|
|
10119 this.element.removeAttr( "aria-valuenow" );
|
|
|
10120 if ( !this.overlayDiv ) {
|
|
|
10121 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
|
|
|
10122 }
|
|
|
10123 } else {
|
|
|
10124 this.element.attr({
|
|
|
10125 "aria-valuemax": this.options.max,
|
|
|
10126 "aria-valuenow": value
|
|
|
10127 });
|
|
|
10128 if ( this.overlayDiv ) {
|
|
|
10129 this.overlayDiv.remove();
|
|
|
10130 this.overlayDiv = null;
|
|
|
10131 }
|
|
|
10132 }
|
|
|
10133
|
|
|
10134 if ( this.oldValue !== value ) {
|
|
|
10135 this.oldValue = value;
|
|
|
10136 this._trigger( "change" );
|
|
|
10137 }
|
|
|
10138 if ( value === this.options.max ) {
|
|
|
10139 this._trigger( "complete" );
|
|
|
10140 }
|
|
|
10141 }
|
|
|
10142 });
|
|
|
10143
|
|
|
10144 })( jQuery );
|
|
|
10145 (function( $, undefined ) {
|
|
|
10146
|
|
|
10147 function num(v) {
|
|
|
10148 return parseInt(v, 10) || 0;
|
|
|
10149 }
|
|
|
10150
|
|
|
10151 function isNumber(value) {
|
|
|
10152 return !isNaN(parseInt(value, 10));
|
|
|
10153 }
|
|
|
10154
|
|
|
10155 $.widget("ui.resizable", $.ui.mouse, {
|
|
|
10156 version: "1.10.4",
|
|
|
10157 widgetEventPrefix: "resize",
|
|
|
10158 options: {
|
|
|
10159 alsoResize: false,
|
|
|
10160 animate: false,
|
|
|
10161 animateDuration: "slow",
|
|
|
10162 animateEasing: "swing",
|
|
|
10163 aspectRatio: false,
|
|
|
10164 autoHide: false,
|
|
|
10165 containment: false,
|
|
|
10166 ghost: false,
|
|
|
10167 grid: false,
|
|
|
10168 handles: "e,s,se",
|
|
|
10169 helper: false,
|
|
|
10170 maxHeight: null,
|
|
|
10171 maxWidth: null,
|
|
|
10172 minHeight: 10,
|
|
|
10173 minWidth: 10,
|
|
|
10174 // See #7960
|
|
|
10175 zIndex: 90,
|
|
|
10176
|
|
|
10177 // callbacks
|
|
|
10178 resize: null,
|
|
|
10179 start: null,
|
|
|
10180 stop: null
|
|
|
10181 },
|
|
|
10182 _create: function() {
|
|
|
10183
|
|
|
10184 var n, i, handle, axis, hname,
|
|
|
10185 that = this,
|
|
|
10186 o = this.options;
|
|
|
10187 this.element.addClass("ui-resizable");
|
|
|
10188
|
|
|
10189 $.extend(this, {
|
|
|
10190 _aspectRatio: !!(o.aspectRatio),
|
|
|
10191 aspectRatio: o.aspectRatio,
|
|
|
10192 originalElement: this.element,
|
|
|
10193 _proportionallyResizeElements: [],
|
|
|
10194 _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
|
|
|
10195 });
|
|
|
10196
|
|
|
10197 //Wrap the element if it cannot hold child nodes
|
|
|
10198 if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
|
|
|
10199
|
|
|
10200 //Create a wrapper element and set the wrapper to the new current internal element
|
|
|
10201 this.element.wrap(
|
|
|
10202 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
|
|
|
10203 position: this.element.css("position"),
|
|
|
10204 width: this.element.outerWidth(),
|
|
|
10205 height: this.element.outerHeight(),
|
|
|
10206 top: this.element.css("top"),
|
|
|
10207 left: this.element.css("left")
|
|
|
10208 })
|
|
|
10209 );
|
|
|
10210
|
|
|
10211 //Overwrite the original this.element
|
|
|
10212 this.element = this.element.parent().data(
|
|
|
10213 "ui-resizable", this.element.data("ui-resizable")
|
|
|
10214 );
|
|
|
10215
|
|
|
10216 this.elementIsWrapper = true;
|
|
|
10217
|
|
|
10218 //Move margins to the wrapper
|
|
|
10219 this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
|
|
|
10220 this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
|
|
|
10221
|
|
|
10222 //Prevent Safari textarea resize
|
|
|
10223 this.originalResizeStyle = this.originalElement.css("resize");
|
|
|
10224 this.originalElement.css("resize", "none");
|
|
|
10225
|
|
|
10226 //Push the actual element to our proportionallyResize internal array
|
|
|
10227 this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
|
|
|
10228
|
|
|
10229 // avoid IE jump (hard set the margin)
|
|
|
10230 this.originalElement.css({ margin: this.originalElement.css("margin") });
|
|
|
10231
|
|
|
10232 // fix handlers offset
|
|
|
10233 this._proportionallyResize();
|
|
|
10234
|
|
|
10235 }
|
|
|
10236
|
|
|
10237 this.handles = o.handles || (!$(".ui-resizable-handle", this.element).length ? "e,s,se" : { n: ".ui-resizable-n", e: ".ui-resizable-e", s: ".ui-resizable-s", w: ".ui-resizable-w", se: ".ui-resizable-se", sw: ".ui-resizable-sw", ne: ".ui-resizable-ne", nw: ".ui-resizable-nw" });
|
|
|
10238 if(this.handles.constructor === String) {
|
|
|
10239
|
|
|
10240 if ( this.handles === "all") {
|
|
|
10241 this.handles = "n,e,s,w,se,sw,ne,nw";
|
|
|
10242 }
|
|
|
10243
|
|
|
10244 n = this.handles.split(",");
|
|
|
10245 this.handles = {};
|
|
|
10246
|
|
|
10247 for(i = 0; i < n.length; i++) {
|
|
|
10248
|
|
|
10249 handle = $.trim(n[i]);
|
|
|
10250 hname = "ui-resizable-"+handle;
|
|
|
10251 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
|
|
|
10252
|
|
|
10253 // Apply zIndex to all handles - see #7960
|
|
|
10254 axis.css({ zIndex: o.zIndex });
|
|
|
10255
|
|
|
10256 //TODO : What's going on here?
|
|
|
10257 if ("se" === handle) {
|
|
|
10258 axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
|
|
|
10259 }
|
|
|
10260
|
|
|
10261 //Insert into internal handles object and append to element
|
|
|
10262 this.handles[handle] = ".ui-resizable-"+handle;
|
|
|
10263 this.element.append(axis);
|
|
|
10264 }
|
|
|
10265
|
|
|
10266 }
|
|
|
10267
|
|
|
10268 this._renderAxis = function(target) {
|
|
|
10269
|
|
|
10270 var i, axis, padPos, padWrapper;
|
|
|
10271
|
|
|
10272 target = target || this.element;
|
|
|
10273
|
|
|
10274 for(i in this.handles) {
|
|
|
10275
|
|
|
10276 if(this.handles[i].constructor === String) {
|
|
|
10277 this.handles[i] = $(this.handles[i], this.element).show();
|
|
|
10278 }
|
|
|
10279
|
|
|
10280 //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
|
|
|
10281 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
|
|
|
10282
|
|
|
10283 axis = $(this.handles[i], this.element);
|
|
|
10284
|
|
|
10285 //Checking the correct pad and border
|
|
|
10286 padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
|
|
|
10287
|
|
|
10288 //The padding type i have to apply...
|
|
|
10289 padPos = [ "padding",
|
|
|
10290 /ne|nw|n/.test(i) ? "Top" :
|
|
|
10291 /se|sw|s/.test(i) ? "Bottom" :
|
|
|
10292 /^e$/.test(i) ? "Right" : "Left" ].join("");
|
|
|
10293
|
|
|
10294 target.css(padPos, padWrapper);
|
|
|
10295
|
|
|
10296 this._proportionallyResize();
|
|
|
10297
|
|
|
10298 }
|
|
|
10299
|
|
|
10300 //TODO: What's that good for? There's not anything to be executed left
|
|
|
10301 if(!$(this.handles[i]).length) {
|
|
|
10302 continue;
|
|
|
10303 }
|
|
|
10304 }
|
|
|
10305 };
|
|
|
10306
|
|
|
10307 //TODO: make renderAxis a prototype function
|
|
|
10308 this._renderAxis(this.element);
|
|
|
10309
|
|
|
10310 this._handles = $(".ui-resizable-handle", this.element)
|
|
|
10311 .disableSelection();
|
|
|
10312
|
|
|
10313 //Matching axis name
|
|
|
10314 this._handles.mouseover(function() {
|
|
|
10315 if (!that.resizing) {
|
|
|
10316 if (this.className) {
|
|
|
10317 axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
|
|
|
10318 }
|
|
|
10319 //Axis, default = se
|
|
|
10320 that.axis = axis && axis[1] ? axis[1] : "se";
|
|
|
10321 }
|
|
|
10322 });
|
|
|
10323
|
|
|
10324 //If we want to auto hide the elements
|
|
|
10325 if (o.autoHide) {
|
|
|
10326 this._handles.hide();
|
|
|
10327 $(this.element)
|
|
|
10328 .addClass("ui-resizable-autohide")
|
|
|
10329 .mouseenter(function() {
|
|
|
10330 if (o.disabled) {
|
|
|
10331 return;
|
|
|
10332 }
|
|
|
10333 $(this).removeClass("ui-resizable-autohide");
|
|
|
10334 that._handles.show();
|
|
|
10335 })
|
|
|
10336 .mouseleave(function(){
|
|
|
10337 if (o.disabled) {
|
|
|
10338 return;
|
|
|
10339 }
|
|
|
10340 if (!that.resizing) {
|
|
|
10341 $(this).addClass("ui-resizable-autohide");
|
|
|
10342 that._handles.hide();
|
|
|
10343 }
|
|
|
10344 });
|
|
|
10345 }
|
|
|
10346
|
|
|
10347 //Initialize the mouse interaction
|
|
|
10348 this._mouseInit();
|
|
|
10349
|
|
|
10350 },
|
|
|
10351
|
|
|
10352 _destroy: function() {
|
|
|
10353
|
|
|
10354 this._mouseDestroy();
|
|
|
10355
|
|
|
10356 var wrapper,
|
|
|
10357 _destroy = function(exp) {
|
|
|
10358 $(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
|
|
|
10359 .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
|
|
|
10360 };
|
|
|
10361
|
|
|
10362 //TODO: Unwrap at same DOM position
|
|
|
10363 if (this.elementIsWrapper) {
|
|
|
10364 _destroy(this.element);
|
|
|
10365 wrapper = this.element;
|
|
|
10366 this.originalElement.css({
|
|
|
10367 position: wrapper.css("position"),
|
|
|
10368 width: wrapper.outerWidth(),
|
|
|
10369 height: wrapper.outerHeight(),
|
|
|
10370 top: wrapper.css("top"),
|
|
|
10371 left: wrapper.css("left")
|
|
|
10372 }).insertAfter( wrapper );
|
|
|
10373 wrapper.remove();
|
|
|
10374 }
|
|
|
10375
|
|
|
10376 this.originalElement.css("resize", this.originalResizeStyle);
|
|
|
10377 _destroy(this.originalElement);
|
|
|
10378
|
|
|
10379 return this;
|
|
|
10380 },
|
|
|
10381
|
|
|
10382 _mouseCapture: function(event) {
|
|
|
10383 var i, handle,
|
|
|
10384 capture = false;
|
|
|
10385
|
|
|
10386 for (i in this.handles) {
|
|
|
10387 handle = $(this.handles[i])[0];
|
|
|
10388 if (handle === event.target || $.contains(handle, event.target)) {
|
|
|
10389 capture = true;
|
|
|
10390 }
|
|
|
10391 }
|
|
|
10392
|
|
|
10393 return !this.options.disabled && capture;
|
|
|
10394 },
|
|
|
10395
|
|
|
10396 _mouseStart: function(event) {
|
|
|
10397
|
|
|
10398 var curleft, curtop, cursor,
|
|
|
10399 o = this.options,
|
|
|
10400 iniPos = this.element.position(),
|
|
|
10401 el = this.element;
|
|
|
10402
|
|
|
10403 this.resizing = true;
|
|
|
10404
|
|
|
10405 // bugfix for http://dev.jquery.com/ticket/1749
|
|
|
10406 if ( (/absolute/).test( el.css("position") ) ) {
|
|
|
10407 el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
|
|
|
10408 } else if (el.is(".ui-draggable")) {
|
|
|
10409 el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
|
|
|
10410 }
|
|
|
10411
|
|
|
10412 this._renderProxy();
|
|
|
10413
|
|
|
10414 curleft = num(this.helper.css("left"));
|
|
|
10415 curtop = num(this.helper.css("top"));
|
|
|
10416
|
|
|
10417 if (o.containment) {
|
|
|
10418 curleft += $(o.containment).scrollLeft() || 0;
|
|
|
10419 curtop += $(o.containment).scrollTop() || 0;
|
|
|
10420 }
|
|
|
10421
|
|
|
10422 //Store needed variables
|
|
|
10423 this.offset = this.helper.offset();
|
|
|
10424 this.position = { left: curleft, top: curtop };
|
|
|
10425 this.size = this._helper ? { width: this.helper.width(), height: this.helper.height() } : { width: el.width(), height: el.height() };
|
|
|
10426 this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
|
|
|
10427 this.originalPosition = { left: curleft, top: curtop };
|
|
|
10428 this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
|
|
|
10429 this.originalMousePosition = { left: event.pageX, top: event.pageY };
|
|
|
10430
|
|
|
10431 //Aspect Ratio
|
|
|
10432 this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
|
|
|
10433
|
|
|
10434 cursor = $(".ui-resizable-" + this.axis).css("cursor");
|
|
|
10435 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
|
|
|
10436
|
|
|
10437 el.addClass("ui-resizable-resizing");
|
|
|
10438 this._propagate("start", event);
|
|
|
10439 return true;
|
|
|
10440 },
|
|
|
10441
|
|
|
10442 _mouseDrag: function(event) {
|
|
|
10443
|
|
|
10444 //Increase performance, avoid regex
|
|
|
10445 var data,
|
|
|
10446 el = this.helper, props = {},
|
|
|
10447 smp = this.originalMousePosition,
|
|
|
10448 a = this.axis,
|
|
|
10449 prevTop = this.position.top,
|
|
|
10450 prevLeft = this.position.left,
|
|
|
10451 prevWidth = this.size.width,
|
|
|
10452 prevHeight = this.size.height,
|
|
|
10453 dx = (event.pageX-smp.left)||0,
|
|
|
10454 dy = (event.pageY-smp.top)||0,
|
|
|
10455 trigger = this._change[a];
|
|
|
10456
|
|
|
10457 if (!trigger) {
|
|
|
10458 return false;
|
|
|
10459 }
|
|
|
10460
|
|
|
10461 // Calculate the attrs that will be change
|
|
|
10462 data = trigger.apply(this, [event, dx, dy]);
|
|
|
10463
|
|
|
10464 // Put this in the mouseDrag handler since the user can start pressing shift while resizing
|
|
|
10465 this._updateVirtualBoundaries(event.shiftKey);
|
|
|
10466 if (this._aspectRatio || event.shiftKey) {
|
|
|
10467 data = this._updateRatio(data, event);
|
|
|
10468 }
|
|
|
10469
|
|
|
10470 data = this._respectSize(data, event);
|
|
|
10471
|
|
|
10472 this._updateCache(data);
|
|
|
10473
|
|
|
10474 // plugins callbacks need to be called first
|
|
|
10475 this._propagate("resize", event);
|
|
|
10476
|
|
|
10477 if (this.position.top !== prevTop) {
|
|
|
10478 props.top = this.position.top + "px";
|
|
|
10479 }
|
|
|
10480 if (this.position.left !== prevLeft) {
|
|
|
10481 props.left = this.position.left + "px";
|
|
|
10482 }
|
|
|
10483 if (this.size.width !== prevWidth) {
|
|
|
10484 props.width = this.size.width + "px";
|
|
|
10485 }
|
|
|
10486 if (this.size.height !== prevHeight) {
|
|
|
10487 props.height = this.size.height + "px";
|
|
|
10488 }
|
|
|
10489 el.css(props);
|
|
|
10490
|
|
|
10491 if (!this._helper && this._proportionallyResizeElements.length) {
|
|
|
10492 this._proportionallyResize();
|
|
|
10493 }
|
|
|
10494
|
|
|
10495 // Call the user callback if the element was resized
|
|
|
10496 if ( ! $.isEmptyObject(props) ) {
|
|
|
10497 this._trigger("resize", event, this.ui());
|
|
|
10498 }
|
|
|
10499
|
|
|
10500 return false;
|
|
|
10501 },
|
|
|
10502
|
|
|
10503 _mouseStop: function(event) {
|
|
|
10504
|
|
|
10505 this.resizing = false;
|
|
|
10506 var pr, ista, soffseth, soffsetw, s, left, top,
|
|
|
10507 o = this.options, that = this;
|
|
|
10508
|
|
|
10509 if(this._helper) {
|
|
|
10510
|
|
|
10511 pr = this._proportionallyResizeElements;
|
|
|
10512 ista = pr.length && (/textarea/i).test(pr[0].nodeName);
|
|
|
10513 soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
|
|
|
10514 soffsetw = ista ? 0 : that.sizeDiff.width;
|
|
|
10515
|
|
|
10516 s = { width: (that.helper.width() - soffsetw), height: (that.helper.height() - soffseth) };
|
|
|
10517 left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
|
|
|
10518 top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
|
|
|
10519
|
|
|
10520 if (!o.animate) {
|
|
|
10521 this.element.css($.extend(s, { top: top, left: left }));
|
|
|
10522 }
|
|
|
10523
|
|
|
10524 that.helper.height(that.size.height);
|
|
|
10525 that.helper.width(that.size.width);
|
|
|
10526
|
|
|
10527 if (this._helper && !o.animate) {
|
|
|
10528 this._proportionallyResize();
|
|
|
10529 }
|
|
|
10530 }
|
|
|
10531
|
|
|
10532 $("body").css("cursor", "auto");
|
|
|
10533
|
|
|
10534 this.element.removeClass("ui-resizable-resizing");
|
|
|
10535
|
|
|
10536 this._propagate("stop", event);
|
|
|
10537
|
|
|
10538 if (this._helper) {
|
|
|
10539 this.helper.remove();
|
|
|
10540 }
|
|
|
10541
|
|
|
10542 return false;
|
|
|
10543
|
|
|
10544 },
|
|
|
10545
|
|
|
10546 _updateVirtualBoundaries: function(forceAspectRatio) {
|
|
|
10547 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
|
|
|
10548 o = this.options;
|
|
|
10549
|
|
|
10550 b = {
|
|
|
10551 minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
|
|
|
10552 maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
|
|
|
10553 minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
|
|
|
10554 maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
|
|
|
10555 };
|
|
|
10556
|
|
|
10557 if(this._aspectRatio || forceAspectRatio) {
|
|
|
10558 // We want to create an enclosing box whose aspect ration is the requested one
|
|
|
10559 // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
|
|
|
10560 pMinWidth = b.minHeight * this.aspectRatio;
|
|
|
10561 pMinHeight = b.minWidth / this.aspectRatio;
|
|
|
10562 pMaxWidth = b.maxHeight * this.aspectRatio;
|
|
|
10563 pMaxHeight = b.maxWidth / this.aspectRatio;
|
|
|
10564
|
|
|
10565 if(pMinWidth > b.minWidth) {
|
|
|
10566 b.minWidth = pMinWidth;
|
|
|
10567 }
|
|
|
10568 if(pMinHeight > b.minHeight) {
|
|
|
10569 b.minHeight = pMinHeight;
|
|
|
10570 }
|
|
|
10571 if(pMaxWidth < b.maxWidth) {
|
|
|
10572 b.maxWidth = pMaxWidth;
|
|
|
10573 }
|
|
|
10574 if(pMaxHeight < b.maxHeight) {
|
|
|
10575 b.maxHeight = pMaxHeight;
|
|
|
10576 }
|
|
|
10577 }
|
|
|
10578 this._vBoundaries = b;
|
|
|
10579 },
|
|
|
10580
|
|
|
10581 _updateCache: function(data) {
|
|
|
10582 this.offset = this.helper.offset();
|
|
|
10583 if (isNumber(data.left)) {
|
|
|
10584 this.position.left = data.left;
|
|
|
10585 }
|
|
|
10586 if (isNumber(data.top)) {
|
|
|
10587 this.position.top = data.top;
|
|
|
10588 }
|
|
|
10589 if (isNumber(data.height)) {
|
|
|
10590 this.size.height = data.height;
|
|
|
10591 }
|
|
|
10592 if (isNumber(data.width)) {
|
|
|
10593 this.size.width = data.width;
|
|
|
10594 }
|
|
|
10595 },
|
|
|
10596
|
|
|
10597 _updateRatio: function( data ) {
|
|
|
10598
|
|
|
10599 var cpos = this.position,
|
|
|
10600 csize = this.size,
|
|
|
10601 a = this.axis;
|
|
|
10602
|
|
|
10603 if (isNumber(data.height)) {
|
|
|
10604 data.width = (data.height * this.aspectRatio);
|
|
|
10605 } else if (isNumber(data.width)) {
|
|
|
10606 data.height = (data.width / this.aspectRatio);
|
|
|
10607 }
|
|
|
10608
|
|
|
10609 if (a === "sw") {
|
|
|
10610 data.left = cpos.left + (csize.width - data.width);
|
|
|
10611 data.top = null;
|
|
|
10612 }
|
|
|
10613 if (a === "nw") {
|
|
|
10614 data.top = cpos.top + (csize.height - data.height);
|
|
|
10615 data.left = cpos.left + (csize.width - data.width);
|
|
|
10616 }
|
|
|
10617
|
|
|
10618 return data;
|
|
|
10619 },
|
|
|
10620
|
|
|
10621 _respectSize: function( data ) {
|
|
|
10622
|
|
|
10623 var o = this._vBoundaries,
|
|
|
10624 a = this.axis,
|
|
|
10625 ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
|
|
|
10626 isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
|
|
|
10627 dw = this.originalPosition.left + this.originalSize.width,
|
|
|
10628 dh = this.position.top + this.size.height,
|
|
|
10629 cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
|
|
|
10630 if (isminw) {
|
|
|
10631 data.width = o.minWidth;
|
|
|
10632 }
|
|
|
10633 if (isminh) {
|
|
|
10634 data.height = o.minHeight;
|
|
|
10635 }
|
|
|
10636 if (ismaxw) {
|
|
|
10637 data.width = o.maxWidth;
|
|
|
10638 }
|
|
|
10639 if (ismaxh) {
|
|
|
10640 data.height = o.maxHeight;
|
|
|
10641 }
|
|
|
10642
|
|
|
10643 if (isminw && cw) {
|
|
|
10644 data.left = dw - o.minWidth;
|
|
|
10645 }
|
|
|
10646 if (ismaxw && cw) {
|
|
|
10647 data.left = dw - o.maxWidth;
|
|
|
10648 }
|
|
|
10649 if (isminh && ch) {
|
|
|
10650 data.top = dh - o.minHeight;
|
|
|
10651 }
|
|
|
10652 if (ismaxh && ch) {
|
|
|
10653 data.top = dh - o.maxHeight;
|
|
|
10654 }
|
|
|
10655
|
|
|
10656 // fixing jump error on top/left - bug #2330
|
|
|
10657 if (!data.width && !data.height && !data.left && data.top) {
|
|
|
10658 data.top = null;
|
|
|
10659 } else if (!data.width && !data.height && !data.top && data.left) {
|
|
|
10660 data.left = null;
|
|
|
10661 }
|
|
|
10662
|
|
|
10663 return data;
|
|
|
10664 },
|
|
|
10665
|
|
|
10666 _proportionallyResize: function() {
|
|
|
10667
|
|
|
10668 if (!this._proportionallyResizeElements.length) {
|
|
|
10669 return;
|
|
|
10670 }
|
|
|
10671
|
|
|
10672 var i, j, borders, paddings, prel,
|
|
|
10673 element = this.helper || this.element;
|
|
|
10674
|
|
|
10675 for ( i=0; i < this._proportionallyResizeElements.length; i++) {
|
|
|
10676
|
|
|
10677 prel = this._proportionallyResizeElements[i];
|
|
|
10678
|
|
|
10679 if (!this.borderDif) {
|
|
|
10680 this.borderDif = [];
|
|
|
10681 borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
|
|
|
10682 paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
|
|
|
10683
|
|
|
10684 for ( j = 0; j < borders.length; j++ ) {
|
|
|
10685 this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
|
|
|
10686 }
|
|
|
10687 }
|
|
|
10688
|
|
|
10689 prel.css({
|
|
|
10690 height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
|
|
|
10691 width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
|
|
|
10692 });
|
|
|
10693
|
|
|
10694 }
|
|
|
10695
|
|
|
10696 },
|
|
|
10697
|
|
|
10698 _renderProxy: function() {
|
|
|
10699
|
|
|
10700 var el = this.element, o = this.options;
|
|
|
10701 this.elementOffset = el.offset();
|
|
|
10702
|
|
|
10703 if(this._helper) {
|
|
|
10704
|
|
|
10705 this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
|
|
|
10706
|
|
|
10707 this.helper.addClass(this._helper).css({
|
|
|
10708 width: this.element.outerWidth() - 1,
|
|
|
10709 height: this.element.outerHeight() - 1,
|
|
|
10710 position: "absolute",
|
|
|
10711 left: this.elementOffset.left +"px",
|
|
|
10712 top: this.elementOffset.top +"px",
|
|
|
10713 zIndex: ++o.zIndex //TODO: Don't modify option
|
|
|
10714 });
|
|
|
10715
|
|
|
10716 this.helper
|
|
|
10717 .appendTo("body")
|
|
|
10718 .disableSelection();
|
|
|
10719
|
|
|
10720 } else {
|
|
|
10721 this.helper = this.element;
|
|
|
10722 }
|
|
|
10723
|
|
|
10724 },
|
|
|
10725
|
|
|
10726 _change: {
|
|
|
10727 e: function(event, dx) {
|
|
|
10728 return { width: this.originalSize.width + dx };
|
|
|
10729 },
|
|
|
10730 w: function(event, dx) {
|
|
|
10731 var cs = this.originalSize, sp = this.originalPosition;
|
|
|
10732 return { left: sp.left + dx, width: cs.width - dx };
|
|
|
10733 },
|
|
|
10734 n: function(event, dx, dy) {
|
|
|
10735 var cs = this.originalSize, sp = this.originalPosition;
|
|
|
10736 return { top: sp.top + dy, height: cs.height - dy };
|
|
|
10737 },
|
|
|
10738 s: function(event, dx, dy) {
|
|
|
10739 return { height: this.originalSize.height + dy };
|
|
|
10740 },
|
|
|
10741 se: function(event, dx, dy) {
|
|
|
10742 return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
|
|
|
10743 },
|
|
|
10744 sw: function(event, dx, dy) {
|
|
|
10745 return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
|
|
|
10746 },
|
|
|
10747 ne: function(event, dx, dy) {
|
|
|
10748 return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
|
|
|
10749 },
|
|
|
10750 nw: function(event, dx, dy) {
|
|
|
10751 return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
|
|
|
10752 }
|
|
|
10753 },
|
|
|
10754
|
|
|
10755 _propagate: function(n, event) {
|
|
|
10756 $.ui.plugin.call(this, n, [event, this.ui()]);
|
|
|
10757 (n !== "resize" && this._trigger(n, event, this.ui()));
|
|
|
10758 },
|
|
|
10759
|
|
|
10760 plugins: {},
|
|
|
10761
|
|
|
10762 ui: function() {
|
|
|
10763 return {
|
|
|
10764 originalElement: this.originalElement,
|
|
|
10765 element: this.element,
|
|
|
10766 helper: this.helper,
|
|
|
10767 position: this.position,
|
|
|
10768 size: this.size,
|
|
|
10769 originalSize: this.originalSize,
|
|
|
10770 originalPosition: this.originalPosition
|
|
|
10771 };
|
|
|
10772 }
|
|
|
10773
|
|
|
10774 });
|
|
|
10775
|
|
|
10776 /*
|
|
|
10777 * Resizable Extensions
|
|
|
10778 */
|
|
|
10779
|
|
|
10780 $.ui.plugin.add("resizable", "animate", {
|
|
|
10781
|
|
|
10782 stop: function( event ) {
|
|
|
10783 var that = $(this).data("ui-resizable"),
|
|
|
10784 o = that.options,
|
|
|
10785 pr = that._proportionallyResizeElements,
|
|
|
10786 ista = pr.length && (/textarea/i).test(pr[0].nodeName),
|
|
|
10787 soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
|
|
|
10788 soffsetw = ista ? 0 : that.sizeDiff.width,
|
|
|
10789 style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
|
|
|
10790 left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
|
|
|
10791 top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
|
|
|
10792
|
|
|
10793 that.element.animate(
|
|
|
10794 $.extend(style, top && left ? { top: top, left: left } : {}), {
|
|
|
10795 duration: o.animateDuration,
|
|
|
10796 easing: o.animateEasing,
|
|
|
10797 step: function() {
|
|
|
10798
|
|
|
10799 var data = {
|
|
|
10800 width: parseInt(that.element.css("width"), 10),
|
|
|
10801 height: parseInt(that.element.css("height"), 10),
|
|
|
10802 top: parseInt(that.element.css("top"), 10),
|
|
|
10803 left: parseInt(that.element.css("left"), 10)
|
|
|
10804 };
|
|
|
10805
|
|
|
10806 if (pr && pr.length) {
|
|
|
10807 $(pr[0]).css({ width: data.width, height: data.height });
|
|
|
10808 }
|
|
|
10809
|
|
|
10810 // propagating resize, and updating values for each animation step
|
|
|
10811 that._updateCache(data);
|
|
|
10812 that._propagate("resize", event);
|
|
|
10813
|
|
|
10814 }
|
|
|
10815 }
|
|
|
10816 );
|
|
|
10817 }
|
|
|
10818
|
|
|
10819 });
|
|
|
10820
|
|
|
10821 $.ui.plugin.add("resizable", "containment", {
|
|
|
10822
|
|
|
10823 start: function() {
|
|
|
10824 var element, p, co, ch, cw, width, height,
|
|
|
10825 that = $(this).data("ui-resizable"),
|
|
|
10826 o = that.options,
|
|
|
10827 el = that.element,
|
|
|
10828 oc = o.containment,
|
|
|
10829 ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
|
|
|
10830
|
|
|
10831 if (!ce) {
|
|
|
10832 return;
|
|
|
10833 }
|
|
|
10834
|
|
|
10835 that.containerElement = $(ce);
|
|
|
10836
|
|
|
10837 if (/document/.test(oc) || oc === document) {
|
|
|
10838 that.containerOffset = { left: 0, top: 0 };
|
|
|
10839 that.containerPosition = { left: 0, top: 0 };
|
|
|
10840
|
|
|
10841 that.parentData = {
|
|
|
10842 element: $(document), left: 0, top: 0,
|
|
|
10843 width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
|
|
|
10844 };
|
|
|
10845 }
|
|
|
10846
|
|
|
10847 // i'm a node, so compute top, left, right, bottom
|
|
|
10848 else {
|
|
|
10849 element = $(ce);
|
|
|
10850 p = [];
|
|
|
10851 $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
|
|
|
10852
|
|
|
10853 that.containerOffset = element.offset();
|
|
|
10854 that.containerPosition = element.position();
|
|
|
10855 that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
|
|
|
10856
|
|
|
10857 co = that.containerOffset;
|
|
|
10858 ch = that.containerSize.height;
|
|
|
10859 cw = that.containerSize.width;
|
|
|
10860 width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
|
|
|
10861 height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
|
|
|
10862
|
|
|
10863 that.parentData = {
|
|
|
10864 element: ce, left: co.left, top: co.top, width: width, height: height
|
|
|
10865 };
|
|
|
10866 }
|
|
|
10867 },
|
|
|
10868
|
|
|
10869 resize: function( event ) {
|
|
|
10870 var woset, hoset, isParent, isOffsetRelative,
|
|
|
10871 that = $(this).data("ui-resizable"),
|
|
|
10872 o = that.options,
|
|
|
10873 co = that.containerOffset, cp = that.position,
|
|
|
10874 pRatio = that._aspectRatio || event.shiftKey,
|
|
|
10875 cop = { top:0, left:0 }, ce = that.containerElement;
|
|
|
10876
|
|
|
10877 if (ce[0] !== document && (/static/).test(ce.css("position"))) {
|
|
|
10878 cop = co;
|
|
|
10879 }
|
|
|
10880
|
|
|
10881 if (cp.left < (that._helper ? co.left : 0)) {
|
|
|
10882 that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
|
|
|
10883 if (pRatio) {
|
|
|
10884 that.size.height = that.size.width / that.aspectRatio;
|
|
|
10885 }
|
|
|
10886 that.position.left = o.helper ? co.left : 0;
|
|
|
10887 }
|
|
|
10888
|
|
|
10889 if (cp.top < (that._helper ? co.top : 0)) {
|
|
|
10890 that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
|
|
|
10891 if (pRatio) {
|
|
|
10892 that.size.width = that.size.height * that.aspectRatio;
|
|
|
10893 }
|
|
|
10894 that.position.top = that._helper ? co.top : 0;
|
|
|
10895 }
|
|
|
10896
|
|
|
10897 that.offset.left = that.parentData.left+that.position.left;
|
|
|
10898 that.offset.top = that.parentData.top+that.position.top;
|
|
|
10899
|
|
|
10900 woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
|
|
|
10901 hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
|
|
|
10902
|
|
|
10903 isParent = that.containerElement.get(0) === that.element.parent().get(0);
|
|
|
10904 isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
|
|
|
10905
|
|
|
10906 if ( isParent && isOffsetRelative ) {
|
|
|
10907 woset -= Math.abs( that.parentData.left );
|
|
|
10908 }
|
|
|
10909
|
|
|
10910 if (woset + that.size.width >= that.parentData.width) {
|
|
|
10911 that.size.width = that.parentData.width - woset;
|
|
|
10912 if (pRatio) {
|
|
|
10913 that.size.height = that.size.width / that.aspectRatio;
|
|
|
10914 }
|
|
|
10915 }
|
|
|
10916
|
|
|
10917 if (hoset + that.size.height >= that.parentData.height) {
|
|
|
10918 that.size.height = that.parentData.height - hoset;
|
|
|
10919 if (pRatio) {
|
|
|
10920 that.size.width = that.size.height * that.aspectRatio;
|
|
|
10921 }
|
|
|
10922 }
|
|
|
10923 },
|
|
|
10924
|
|
|
10925 stop: function(){
|
|
|
10926 var that = $(this).data("ui-resizable"),
|
|
|
10927 o = that.options,
|
|
|
10928 co = that.containerOffset,
|
|
|
10929 cop = that.containerPosition,
|
|
|
10930 ce = that.containerElement,
|
|
|
10931 helper = $(that.helper),
|
|
|
10932 ho = helper.offset(),
|
|
|
10933 w = helper.outerWidth() - that.sizeDiff.width,
|
|
|
10934 h = helper.outerHeight() - that.sizeDiff.height;
|
|
|
10935
|
|
|
10936 if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
|
|
|
10937 $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
|
|
|
10938 }
|
|
|
10939
|
|
|
10940 if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
|
|
|
10941 $(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
|
|
|
10942 }
|
|
|
10943
|
|
|
10944 }
|
|
|
10945 });
|
|
|
10946
|
|
|
10947 $.ui.plugin.add("resizable", "alsoResize", {
|
|
|
10948
|
|
|
10949 start: function () {
|
|
|
10950 var that = $(this).data("ui-resizable"),
|
|
|
10951 o = that.options,
|
|
|
10952 _store = function (exp) {
|
|
|
10953 $(exp).each(function() {
|
|
|
10954 var el = $(this);
|
|
|
10955 el.data("ui-resizable-alsoresize", {
|
|
|
10956 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
|
|
|
10957 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
|
|
|
10958 });
|
|
|
10959 });
|
|
|
10960 };
|
|
|
10961
|
|
|
10962 if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
|
|
|
10963 if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
|
|
|
10964 else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
|
|
|
10965 }else{
|
|
|
10966 _store(o.alsoResize);
|
|
|
10967 }
|
|
|
10968 },
|
|
|
10969
|
|
|
10970 resize: function (event, ui) {
|
|
|
10971 var that = $(this).data("ui-resizable"),
|
|
|
10972 o = that.options,
|
|
|
10973 os = that.originalSize,
|
|
|
10974 op = that.originalPosition,
|
|
|
10975 delta = {
|
|
|
10976 height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
|
|
|
10977 top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
|
|
|
10978 },
|
|
|
10979
|
|
|
10980 _alsoResize = function (exp, c) {
|
|
|
10981 $(exp).each(function() {
|
|
|
10982 var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
|
|
|
10983 css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
|
|
|
10984
|
|
|
10985 $.each(css, function (i, prop) {
|
|
|
10986 var sum = (start[prop]||0) + (delta[prop]||0);
|
|
|
10987 if (sum && sum >= 0) {
|
|
|
10988 style[prop] = sum || null;
|
|
|
10989 }
|
|
|
10990 });
|
|
|
10991
|
|
|
10992 el.css(style);
|
|
|
10993 });
|
|
|
10994 };
|
|
|
10995
|
|
|
10996 if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
|
|
|
10997 $.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
|
|
|
10998 }else{
|
|
|
10999 _alsoResize(o.alsoResize);
|
|
|
11000 }
|
|
|
11001 },
|
|
|
11002
|
|
|
11003 stop: function () {
|
|
|
11004 $(this).removeData("resizable-alsoresize");
|
|
|
11005 }
|
|
|
11006 });
|
|
|
11007
|
|
|
11008 $.ui.plugin.add("resizable", "ghost", {
|
|
|
11009
|
|
|
11010 start: function() {
|
|
|
11011
|
|
|
11012 var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
|
|
|
11013
|
|
|
11014 that.ghost = that.originalElement.clone();
|
|
|
11015 that.ghost
|
|
|
11016 .css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
|
|
|
11017 .addClass("ui-resizable-ghost")
|
|
|
11018 .addClass(typeof o.ghost === "string" ? o.ghost : "");
|
|
|
11019
|
|
|
11020 that.ghost.appendTo(that.helper);
|
|
|
11021
|
|
|
11022 },
|
|
|
11023
|
|
|
11024 resize: function(){
|
|
|
11025 var that = $(this).data("ui-resizable");
|
|
|
11026 if (that.ghost) {
|
|
|
11027 that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
|
|
|
11028 }
|
|
|
11029 },
|
|
|
11030
|
|
|
11031 stop: function() {
|
|
|
11032 var that = $(this).data("ui-resizable");
|
|
|
11033 if (that.ghost && that.helper) {
|
|
|
11034 that.helper.get(0).removeChild(that.ghost.get(0));
|
|
|
11035 }
|
|
|
11036 }
|
|
|
11037
|
|
|
11038 });
|
|
|
11039
|
|
|
11040 $.ui.plugin.add("resizable", "grid", {
|
|
|
11041
|
|
|
11042 resize: function() {
|
|
|
11043 var that = $(this).data("ui-resizable"),
|
|
|
11044 o = that.options,
|
|
|
11045 cs = that.size,
|
|
|
11046 os = that.originalSize,
|
|
|
11047 op = that.originalPosition,
|
|
|
11048 a = that.axis,
|
|
|
11049 grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
|
|
|
11050 gridX = (grid[0]||1),
|
|
|
11051 gridY = (grid[1]||1),
|
|
|
11052 ox = Math.round((cs.width - os.width) / gridX) * gridX,
|
|
|
11053 oy = Math.round((cs.height - os.height) / gridY) * gridY,
|
|
|
11054 newWidth = os.width + ox,
|
|
|
11055 newHeight = os.height + oy,
|
|
|
11056 isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
|
|
|
11057 isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
|
|
|
11058 isMinWidth = o.minWidth && (o.minWidth > newWidth),
|
|
|
11059 isMinHeight = o.minHeight && (o.minHeight > newHeight);
|
|
|
11060
|
|
|
11061 o.grid = grid;
|
|
|
11062
|
|
|
11063 if (isMinWidth) {
|
|
|
11064 newWidth = newWidth + gridX;
|
|
|
11065 }
|
|
|
11066 if (isMinHeight) {
|
|
|
11067 newHeight = newHeight + gridY;
|
|
|
11068 }
|
|
|
11069 if (isMaxWidth) {
|
|
|
11070 newWidth = newWidth - gridX;
|
|
|
11071 }
|
|
|
11072 if (isMaxHeight) {
|
|
|
11073 newHeight = newHeight - gridY;
|
|
|
11074 }
|
|
|
11075
|
|
|
11076 if (/^(se|s|e)$/.test(a)) {
|
|
|
11077 that.size.width = newWidth;
|
|
|
11078 that.size.height = newHeight;
|
|
|
11079 } else if (/^(ne)$/.test(a)) {
|
|
|
11080 that.size.width = newWidth;
|
|
|
11081 that.size.height = newHeight;
|
|
|
11082 that.position.top = op.top - oy;
|
|
|
11083 } else if (/^(sw)$/.test(a)) {
|
|
|
11084 that.size.width = newWidth;
|
|
|
11085 that.size.height = newHeight;
|
|
|
11086 that.position.left = op.left - ox;
|
|
|
11087 } else {
|
|
|
11088 if ( newHeight - gridY > 0 ) {
|
|
|
11089 that.size.height = newHeight;
|
|
|
11090 that.position.top = op.top - oy;
|
|
|
11091 } else {
|
|
|
11092 that.size.height = gridY;
|
|
|
11093 that.position.top = op.top + os.height - gridY;
|
|
|
11094 }
|
|
|
11095 if ( newWidth - gridX > 0 ) {
|
|
|
11096 that.size.width = newWidth;
|
|
|
11097 that.position.left = op.left - ox;
|
|
|
11098 } else {
|
|
|
11099 that.size.width = gridX;
|
|
|
11100 that.position.left = op.left + os.width - gridX;
|
|
|
11101 }
|
|
|
11102 }
|
|
|
11103 }
|
|
|
11104
|
|
|
11105 });
|
|
|
11106
|
|
|
11107 })(jQuery);
|
|
|
11108 (function( $, undefined ) {
|
|
|
11109
|
|
|
11110 $.widget("ui.selectable", $.ui.mouse, {
|
|
|
11111 version: "1.10.4",
|
|
|
11112 options: {
|
|
|
11113 appendTo: "body",
|
|
|
11114 autoRefresh: true,
|
|
|
11115 distance: 0,
|
|
|
11116 filter: "*",
|
|
|
11117 tolerance: "touch",
|
|
|
11118
|
|
|
11119 // callbacks
|
|
|
11120 selected: null,
|
|
|
11121 selecting: null,
|
|
|
11122 start: null,
|
|
|
11123 stop: null,
|
|
|
11124 unselected: null,
|
|
|
11125 unselecting: null
|
|
|
11126 },
|
|
|
11127 _create: function() {
|
|
|
11128 var selectees,
|
|
|
11129 that = this;
|
|
|
11130
|
|
|
11131 this.element.addClass("ui-selectable");
|
|
|
11132
|
|
|
11133 this.dragged = false;
|
|
|
11134
|
|
|
11135 // cache selectee children based on filter
|
|
|
11136 this.refresh = function() {
|
|
|
11137 selectees = $(that.options.filter, that.element[0]);
|
|
|
11138 selectees.addClass("ui-selectee");
|
|
|
11139 selectees.each(function() {
|
|
|
11140 var $this = $(this),
|
|
|
11141 pos = $this.offset();
|
|
|
11142 $.data(this, "selectable-item", {
|
|
|
11143 element: this,
|
|
|
11144 $element: $this,
|
|
|
11145 left: pos.left,
|
|
|
11146 top: pos.top,
|
|
|
11147 right: pos.left + $this.outerWidth(),
|
|
|
11148 bottom: pos.top + $this.outerHeight(),
|
|
|
11149 startselected: false,
|
|
|
11150 selected: $this.hasClass("ui-selected"),
|
|
|
11151 selecting: $this.hasClass("ui-selecting"),
|
|
|
11152 unselecting: $this.hasClass("ui-unselecting")
|
|
|
11153 });
|
|
|
11154 });
|
|
|
11155 };
|
|
|
11156 this.refresh();
|
|
|
11157
|
|
|
11158 this.selectees = selectees.addClass("ui-selectee");
|
|
|
11159
|
|
|
11160 this._mouseInit();
|
|
|
11161
|
|
|
11162 this.helper = $("<div class='ui-selectable-helper'></div>");
|
|
|
11163 },
|
|
|
11164
|
|
|
11165 _destroy: function() {
|
|
|
11166 this.selectees
|
|
|
11167 .removeClass("ui-selectee")
|
|
|
11168 .removeData("selectable-item");
|
|
|
11169 this.element
|
|
|
11170 .removeClass("ui-selectable ui-selectable-disabled");
|
|
|
11171 this._mouseDestroy();
|
|
|
11172 },
|
|
|
11173
|
|
|
11174 _mouseStart: function(event) {
|
|
|
11175 var that = this,
|
|
|
11176 options = this.options;
|
|
|
11177
|
|
|
11178 this.opos = [event.pageX, event.pageY];
|
|
|
11179
|
|
|
11180 if (this.options.disabled) {
|
|
|
11181 return;
|
|
|
11182 }
|
|
|
11183
|
|
|
11184 this.selectees = $(options.filter, this.element[0]);
|
|
|
11185
|
|
|
11186 this._trigger("start", event);
|
|
|
11187
|
|
|
11188 $(options.appendTo).append(this.helper);
|
|
|
11189 // position helper (lasso)
|
|
|
11190 this.helper.css({
|
|
|
11191 "left": event.pageX,
|
|
|
11192 "top": event.pageY,
|
|
|
11193 "width": 0,
|
|
|
11194 "height": 0
|
|
|
11195 });
|
|
|
11196
|
|
|
11197 if (options.autoRefresh) {
|
|
|
11198 this.refresh();
|
|
|
11199 }
|
|
|
11200
|
|
|
11201 this.selectees.filter(".ui-selected").each(function() {
|
|
|
11202 var selectee = $.data(this, "selectable-item");
|
|
|
11203 selectee.startselected = true;
|
|
|
11204 if (!event.metaKey && !event.ctrlKey) {
|
|
|
11205 selectee.$element.removeClass("ui-selected");
|
|
|
11206 selectee.selected = false;
|
|
|
11207 selectee.$element.addClass("ui-unselecting");
|
|
|
11208 selectee.unselecting = true;
|
|
|
11209 // selectable UNSELECTING callback
|
|
|
11210 that._trigger("unselecting", event, {
|
|
|
11211 unselecting: selectee.element
|
|
|
11212 });
|
|
|
11213 }
|
|
|
11214 });
|
|
|
11215
|
|
|
11216 $(event.target).parents().addBack().each(function() {
|
|
|
11217 var doSelect,
|
|
|
11218 selectee = $.data(this, "selectable-item");
|
|
|
11219 if (selectee) {
|
|
|
11220 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
|
|
|
11221 selectee.$element
|
|
|
11222 .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
|
|
|
11223 .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
|
|
|
11224 selectee.unselecting = !doSelect;
|
|
|
11225 selectee.selecting = doSelect;
|
|
|
11226 selectee.selected = doSelect;
|
|
|
11227 // selectable (UN)SELECTING callback
|
|
|
11228 if (doSelect) {
|
|
|
11229 that._trigger("selecting", event, {
|
|
|
11230 selecting: selectee.element
|
|
|
11231 });
|
|
|
11232 } else {
|
|
|
11233 that._trigger("unselecting", event, {
|
|
|
11234 unselecting: selectee.element
|
|
|
11235 });
|
|
|
11236 }
|
|
|
11237 return false;
|
|
|
11238 }
|
|
|
11239 });
|
|
|
11240
|
|
|
11241 },
|
|
|
11242
|
|
|
11243 _mouseDrag: function(event) {
|
|
|
11244
|
|
|
11245 this.dragged = true;
|
|
|
11246
|
|
|
11247 if (this.options.disabled) {
|
|
|
11248 return;
|
|
|
11249 }
|
|
|
11250
|
|
|
11251 var tmp,
|
|
|
11252 that = this,
|
|
|
11253 options = this.options,
|
|
|
11254 x1 = this.opos[0],
|
|
|
11255 y1 = this.opos[1],
|
|
|
11256 x2 = event.pageX,
|
|
|
11257 y2 = event.pageY;
|
|
|
11258
|
|
|
11259 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
|
|
|
11260 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
|
|
|
11261 this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
|
|
|
11262
|
|
|
11263 this.selectees.each(function() {
|
|
|
11264 var selectee = $.data(this, "selectable-item"),
|
|
|
11265 hit = false;
|
|
|
11266
|
|
|
11267 //prevent helper from being selected if appendTo: selectable
|
|
|
11268 if (!selectee || selectee.element === that.element[0]) {
|
|
|
11269 return;
|
|
|
11270 }
|
|
|
11271
|
|
|
11272 if (options.tolerance === "touch") {
|
|
|
11273 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
|
|
|
11274 } else if (options.tolerance === "fit") {
|
|
|
11275 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
|
|
|
11276 }
|
|
|
11277
|
|
|
11278 if (hit) {
|
|
|
11279 // SELECT
|
|
|
11280 if (selectee.selected) {
|
|
|
11281 selectee.$element.removeClass("ui-selected");
|
|
|
11282 selectee.selected = false;
|
|
|
11283 }
|
|
|
11284 if (selectee.unselecting) {
|
|
|
11285 selectee.$element.removeClass("ui-unselecting");
|
|
|
11286 selectee.unselecting = false;
|
|
|
11287 }
|
|
|
11288 if (!selectee.selecting) {
|
|
|
11289 selectee.$element.addClass("ui-selecting");
|
|
|
11290 selectee.selecting = true;
|
|
|
11291 // selectable SELECTING callback
|
|
|
11292 that._trigger("selecting", event, {
|
|
|
11293 selecting: selectee.element
|
|
|
11294 });
|
|
|
11295 }
|
|
|
11296 } else {
|
|
|
11297 // UNSELECT
|
|
|
11298 if (selectee.selecting) {
|
|
|
11299 if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
|
|
|
11300 selectee.$element.removeClass("ui-selecting");
|
|
|
11301 selectee.selecting = false;
|
|
|
11302 selectee.$element.addClass("ui-selected");
|
|
|
11303 selectee.selected = true;
|
|
|
11304 } else {
|
|
|
11305 selectee.$element.removeClass("ui-selecting");
|
|
|
11306 selectee.selecting = false;
|
|
|
11307 if (selectee.startselected) {
|
|
|
11308 selectee.$element.addClass("ui-unselecting");
|
|
|
11309 selectee.unselecting = true;
|
|
|
11310 }
|
|
|
11311 // selectable UNSELECTING callback
|
|
|
11312 that._trigger("unselecting", event, {
|
|
|
11313 unselecting: selectee.element
|
|
|
11314 });
|
|
|
11315 }
|
|
|
11316 }
|
|
|
11317 if (selectee.selected) {
|
|
|
11318 if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
|
|
|
11319 selectee.$element.removeClass("ui-selected");
|
|
|
11320 selectee.selected = false;
|
|
|
11321
|
|
|
11322 selectee.$element.addClass("ui-unselecting");
|
|
|
11323 selectee.unselecting = true;
|
|
|
11324 // selectable UNSELECTING callback
|
|
|
11325 that._trigger("unselecting", event, {
|
|
|
11326 unselecting: selectee.element
|
|
|
11327 });
|
|
|
11328 }
|
|
|
11329 }
|
|
|
11330 }
|
|
|
11331 });
|
|
|
11332
|
|
|
11333 return false;
|
|
|
11334 },
|
|
|
11335
|
|
|
11336 _mouseStop: function(event) {
|
|
|
11337 var that = this;
|
|
|
11338
|
|
|
11339 this.dragged = false;
|
|
|
11340
|
|
|
11341 $(".ui-unselecting", this.element[0]).each(function() {
|
|
|
11342 var selectee = $.data(this, "selectable-item");
|
|
|
11343 selectee.$element.removeClass("ui-unselecting");
|
|
|
11344 selectee.unselecting = false;
|
|
|
11345 selectee.startselected = false;
|
|
|
11346 that._trigger("unselected", event, {
|
|
|
11347 unselected: selectee.element
|
|
|
11348 });
|
|
|
11349 });
|
|
|
11350 $(".ui-selecting", this.element[0]).each(function() {
|
|
|
11351 var selectee = $.data(this, "selectable-item");
|
|
|
11352 selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
|
|
|
11353 selectee.selecting = false;
|
|
|
11354 selectee.selected = true;
|
|
|
11355 selectee.startselected = true;
|
|
|
11356 that._trigger("selected", event, {
|
|
|
11357 selected: selectee.element
|
|
|
11358 });
|
|
|
11359 });
|
|
|
11360 this._trigger("stop", event);
|
|
|
11361
|
|
|
11362 this.helper.remove();
|
|
|
11363
|
|
|
11364 return false;
|
|
|
11365 }
|
|
|
11366
|
|
|
11367 });
|
|
|
11368
|
|
|
11369 })(jQuery);
|
|
|
11370 (function( $, undefined ) {
|
|
|
11371
|
|
|
11372 // number of pages in a slider
|
|
|
11373 // (how many times can you page up/down to go through the whole range)
|
|
|
11374 var numPages = 5;
|
|
|
11375
|
|
|
11376 $.widget( "ui.slider", $.ui.mouse, {
|
|
|
11377 version: "1.10.4",
|
|
|
11378 widgetEventPrefix: "slide",
|
|
|
11379
|
|
|
11380 options: {
|
|
|
11381 animate: false,
|
|
|
11382 distance: 0,
|
|
|
11383 max: 100,
|
|
|
11384 min: 0,
|
|
|
11385 orientation: "horizontal",
|
|
|
11386 range: false,
|
|
|
11387 step: 1,
|
|
|
11388 value: 0,
|
|
|
11389 values: null,
|
|
|
11390
|
|
|
11391 // callbacks
|
|
|
11392 change: null,
|
|
|
11393 slide: null,
|
|
|
11394 start: null,
|
|
|
11395 stop: null
|
|
|
11396 },
|
|
|
11397
|
|
|
11398 _create: function() {
|
|
|
11399 this._keySliding = false;
|
|
|
11400 this._mouseSliding = false;
|
|
|
11401 this._animateOff = true;
|
|
|
11402 this._handleIndex = null;
|
|
|
11403 this._detectOrientation();
|
|
|
11404 this._mouseInit();
|
|
|
11405
|
|
|
11406 this.element
|
|
|
11407 .addClass( "ui-slider" +
|
|
|
11408 " ui-slider-" + this.orientation +
|
|
|
11409 " ui-widget" +
|
|
|
11410 " ui-widget-content" +
|
|
|
11411 " ui-corner-all");
|
|
|
11412
|
|
|
11413 this._refresh();
|
|
|
11414 this._setOption( "disabled", this.options.disabled );
|
|
|
11415
|
|
|
11416 this._animateOff = false;
|
|
|
11417 },
|
|
|
11418
|
|
|
11419 _refresh: function() {
|
|
|
11420 this._createRange();
|
|
|
11421 this._createHandles();
|
|
|
11422 this._setupEvents();
|
|
|
11423 this._refreshValue();
|
|
|
11424 },
|
|
|
11425
|
|
|
11426 _createHandles: function() {
|
|
|
11427 var i, handleCount,
|
|
|
11428 options = this.options,
|
|
|
11429 existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
|
|
|
11430 handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
|
|
|
11431 handles = [];
|
|
|
11432
|
|
|
11433 handleCount = ( options.values && options.values.length ) || 1;
|
|
|
11434
|
|
|
11435 if ( existingHandles.length > handleCount ) {
|
|
|
11436 existingHandles.slice( handleCount ).remove();
|
|
|
11437 existingHandles = existingHandles.slice( 0, handleCount );
|
|
|
11438 }
|
|
|
11439
|
|
|
11440 for ( i = existingHandles.length; i < handleCount; i++ ) {
|
|
|
11441 handles.push( handle );
|
|
|
11442 }
|
|
|
11443
|
|
|
11444 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
|
|
|
11445
|
|
|
11446 this.handle = this.handles.eq( 0 );
|
|
|
11447
|
|
|
11448 this.handles.each(function( i ) {
|
|
|
11449 $( this ).data( "ui-slider-handle-index", i );
|
|
|
11450 });
|
|
|
11451 },
|
|
|
11452
|
|
|
11453 _createRange: function() {
|
|
|
11454 var options = this.options,
|
|
|
11455 classes = "";
|
|
|
11456
|
|
|
11457 if ( options.range ) {
|
|
|
11458 if ( options.range === true ) {
|
|
|
11459 if ( !options.values ) {
|
|
|
11460 options.values = [ this._valueMin(), this._valueMin() ];
|
|
|
11461 } else if ( options.values.length && options.values.length !== 2 ) {
|
|
|
11462 options.values = [ options.values[0], options.values[0] ];
|
|
|
11463 } else if ( $.isArray( options.values ) ) {
|
|
|
11464 options.values = options.values.slice(0);
|
|
|
11465 }
|
|
|
11466 }
|
|
|
11467
|
|
|
11468 if ( !this.range || !this.range.length ) {
|
|
|
11469 this.range = $( "<div></div>" )
|
|
|
11470 .appendTo( this.element );
|
|
|
11471
|
|
|
11472 classes = "ui-slider-range" +
|
|
|
11473 // note: this isn't the most fittingly semantic framework class for this element,
|
|
|
11474 // but worked best visually with a variety of themes
|
|
|
11475 " ui-widget-header ui-corner-all";
|
|
|
11476 } else {
|
|
|
11477 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
|
|
|
11478 // Handle range switching from true to min/max
|
|
|
11479 .css({
|
|
|
11480 "left": "",
|
|
|
11481 "bottom": ""
|
|
|
11482 });
|
|
|
11483 }
|
|
|
11484
|
|
|
11485 this.range.addClass( classes +
|
|
|
11486 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
|
|
|
11487 } else {
|
|
|
11488 if ( this.range ) {
|
|
|
11489 this.range.remove();
|
|
|
11490 }
|
|
|
11491 this.range = null;
|
|
|
11492 }
|
|
|
11493 },
|
|
|
11494
|
|
|
11495 _setupEvents: function() {
|
|
|
11496 var elements = this.handles.add( this.range ).filter( "a" );
|
|
|
11497 this._off( elements );
|
|
|
11498 this._on( elements, this._handleEvents );
|
|
|
11499 this._hoverable( elements );
|
|
|
11500 this._focusable( elements );
|
|
|
11501 },
|
|
|
11502
|
|
|
11503 _destroy: function() {
|
|
|
11504 this.handles.remove();
|
|
|
11505 if ( this.range ) {
|
|
|
11506 this.range.remove();
|
|
|
11507 }
|
|
|
11508
|
|
|
11509 this.element
|
|
|
11510 .removeClass( "ui-slider" +
|
|
|
11511 " ui-slider-horizontal" +
|
|
|
11512 " ui-slider-vertical" +
|
|
|
11513 " ui-widget" +
|
|
|
11514 " ui-widget-content" +
|
|
|
11515 " ui-corner-all" );
|
|
|
11516
|
|
|
11517 this._mouseDestroy();
|
|
|
11518 },
|
|
|
11519
|
|
|
11520 _mouseCapture: function( event ) {
|
|
|
11521 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
|
|
|
11522 that = this,
|
|
|
11523 o = this.options;
|
|
|
11524
|
|
|
11525 if ( o.disabled ) {
|
|
|
11526 return false;
|
|
|
11527 }
|
|
|
11528
|
|
|
11529 this.elementSize = {
|
|
|
11530 width: this.element.outerWidth(),
|
|
|
11531 height: this.element.outerHeight()
|
|
|
11532 };
|
|
|
11533 this.elementOffset = this.element.offset();
|
|
|
11534
|
|
|
11535 position = { x: event.pageX, y: event.pageY };
|
|
|
11536 normValue = this._normValueFromMouse( position );
|
|
|
11537 distance = this._valueMax() - this._valueMin() + 1;
|
|
|
11538 this.handles.each(function( i ) {
|
|
|
11539 var thisDistance = Math.abs( normValue - that.values(i) );
|
|
|
11540 if (( distance > thisDistance ) ||
|
|
|
11541 ( distance === thisDistance &&
|
|
|
11542 (i === that._lastChangedValue || that.values(i) === o.min ))) {
|
|
|
11543 distance = thisDistance;
|
|
|
11544 closestHandle = $( this );
|
|
|
11545 index = i;
|
|
|
11546 }
|
|
|
11547 });
|
|
|
11548
|
|
|
11549 allowed = this._start( event, index );
|
|
|
11550 if ( allowed === false ) {
|
|
|
11551 return false;
|
|
|
11552 }
|
|
|
11553 this._mouseSliding = true;
|
|
|
11554
|
|
|
11555 this._handleIndex = index;
|
|
|
11556
|
|
|
11557 closestHandle
|
|
|
11558 .addClass( "ui-state-active" )
|
|
|
11559 .focus();
|
|
|
11560
|
|
|
11561 offset = closestHandle.offset();
|
|
|
11562 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
|
|
|
11563 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
|
|
|
11564 left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
|
|
|
11565 top: event.pageY - offset.top -
|
|
|
11566 ( closestHandle.height() / 2 ) -
|
|
|
11567 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
|
|
|
11568 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
|
|
|
11569 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
|
|
|
11570 };
|
|
|
11571
|
|
|
11572 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
|
|
|
11573 this._slide( event, index, normValue );
|
|
|
11574 }
|
|
|
11575 this._animateOff = true;
|
|
|
11576 return true;
|
|
|
11577 },
|
|
|
11578
|
|
|
11579 _mouseStart: function() {
|
|
|
11580 return true;
|
|
|
11581 },
|
|
|
11582
|
|
|
11583 _mouseDrag: function( event ) {
|
|
|
11584 var position = { x: event.pageX, y: event.pageY },
|
|
|
11585 normValue = this._normValueFromMouse( position );
|
|
|
11586
|
|
|
11587 this._slide( event, this._handleIndex, normValue );
|
|
|
11588
|
|
|
11589 return false;
|
|
|
11590 },
|
|
|
11591
|
|
|
11592 _mouseStop: function( event ) {
|
|
|
11593 this.handles.removeClass( "ui-state-active" );
|
|
|
11594 this._mouseSliding = false;
|
|
|
11595
|
|
|
11596 this._stop( event, this._handleIndex );
|
|
|
11597 this._change( event, this._handleIndex );
|
|
|
11598
|
|
|
11599 this._handleIndex = null;
|
|
|
11600 this._clickOffset = null;
|
|
|
11601 this._animateOff = false;
|
|
|
11602
|
|
|
11603 return false;
|
|
|
11604 },
|
|
|
11605
|
|
|
11606 _detectOrientation: function() {
|
|
|
11607 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
|
|
|
11608 },
|
|
|
11609
|
|
|
11610 _normValueFromMouse: function( position ) {
|
|
|
11611 var pixelTotal,
|
|
|
11612 pixelMouse,
|
|
|
11613 percentMouse,
|
|
|
11614 valueTotal,
|
|
|
11615 valueMouse;
|
|
|
11616
|
|
|
11617 if ( this.orientation === "horizontal" ) {
|
|
|
11618 pixelTotal = this.elementSize.width;
|
|
|
11619 pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
|
|
|
11620 } else {
|
|
|
11621 pixelTotal = this.elementSize.height;
|
|
|
11622 pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
|
|
|
11623 }
|
|
|
11624
|
|
|
11625 percentMouse = ( pixelMouse / pixelTotal );
|
|
|
11626 if ( percentMouse > 1 ) {
|
|
|
11627 percentMouse = 1;
|
|
|
11628 }
|
|
|
11629 if ( percentMouse < 0 ) {
|
|
|
11630 percentMouse = 0;
|
|
|
11631 }
|
|
|
11632 if ( this.orientation === "vertical" ) {
|
|
|
11633 percentMouse = 1 - percentMouse;
|
|
|
11634 }
|
|
|
11635
|
|
|
11636 valueTotal = this._valueMax() - this._valueMin();
|
|
|
11637 valueMouse = this._valueMin() + percentMouse * valueTotal;
|
|
|
11638
|
|
|
11639 return this._trimAlignValue( valueMouse );
|
|
|
11640 },
|
|
|
11641
|
|
|
11642 _start: function( event, index ) {
|
|
|
11643 var uiHash = {
|
|
|
11644 handle: this.handles[ index ],
|
|
|
11645 value: this.value()
|
|
|
11646 };
|
|
|
11647 if ( this.options.values && this.options.values.length ) {
|
|
|
11648 uiHash.value = this.values( index );
|
|
|
11649 uiHash.values = this.values();
|
|
|
11650 }
|
|
|
11651 return this._trigger( "start", event, uiHash );
|
|
|
11652 },
|
|
|
11653
|
|
|
11654 _slide: function( event, index, newVal ) {
|
|
|
11655 var otherVal,
|
|
|
11656 newValues,
|
|
|
11657 allowed;
|
|
|
11658
|
|
|
11659 if ( this.options.values && this.options.values.length ) {
|
|
|
11660 otherVal = this.values( index ? 0 : 1 );
|
|
|
11661
|
|
|
11662 if ( ( this.options.values.length === 2 && this.options.range === true ) &&
|
|
|
11663 ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
|
|
|
11664 ) {
|
|
|
11665 newVal = otherVal;
|
|
|
11666 }
|
|
|
11667
|
|
|
11668 if ( newVal !== this.values( index ) ) {
|
|
|
11669 newValues = this.values();
|
|
|
11670 newValues[ index ] = newVal;
|
|
|
11671 // A slide can be canceled by returning false from the slide callback
|
|
|
11672 allowed = this._trigger( "slide", event, {
|
|
|
11673 handle: this.handles[ index ],
|
|
|
11674 value: newVal,
|
|
|
11675 values: newValues
|
|
|
11676 } );
|
|
|
11677 otherVal = this.values( index ? 0 : 1 );
|
|
|
11678 if ( allowed !== false ) {
|
|
|
11679 this.values( index, newVal );
|
|
|
11680 }
|
|
|
11681 }
|
|
|
11682 } else {
|
|
|
11683 if ( newVal !== this.value() ) {
|
|
|
11684 // A slide can be canceled by returning false from the slide callback
|
|
|
11685 allowed = this._trigger( "slide", event, {
|
|
|
11686 handle: this.handles[ index ],
|
|
|
11687 value: newVal
|
|
|
11688 } );
|
|
|
11689 if ( allowed !== false ) {
|
|
|
11690 this.value( newVal );
|
|
|
11691 }
|
|
|
11692 }
|
|
|
11693 }
|
|
|
11694 },
|
|
|
11695
|
|
|
11696 _stop: function( event, index ) {
|
|
|
11697 var uiHash = {
|
|
|
11698 handle: this.handles[ index ],
|
|
|
11699 value: this.value()
|
|
|
11700 };
|
|
|
11701 if ( this.options.values && this.options.values.length ) {
|
|
|
11702 uiHash.value = this.values( index );
|
|
|
11703 uiHash.values = this.values();
|
|
|
11704 }
|
|
|
11705
|
|
|
11706 this._trigger( "stop", event, uiHash );
|
|
|
11707 },
|
|
|
11708
|
|
|
11709 _change: function( event, index ) {
|
|
|
11710 if ( !this._keySliding && !this._mouseSliding ) {
|
|
|
11711 var uiHash = {
|
|
|
11712 handle: this.handles[ index ],
|
|
|
11713 value: this.value()
|
|
|
11714 };
|
|
|
11715 if ( this.options.values && this.options.values.length ) {
|
|
|
11716 uiHash.value = this.values( index );
|
|
|
11717 uiHash.values = this.values();
|
|
|
11718 }
|
|
|
11719
|
|
|
11720 //store the last changed value index for reference when handles overlap
|
|
|
11721 this._lastChangedValue = index;
|
|
|
11722
|
|
|
11723 this._trigger( "change", event, uiHash );
|
|
|
11724 }
|
|
|
11725 },
|
|
|
11726
|
|
|
11727 value: function( newValue ) {
|
|
|
11728 if ( arguments.length ) {
|
|
|
11729 this.options.value = this._trimAlignValue( newValue );
|
|
|
11730 this._refreshValue();
|
|
|
11731 this._change( null, 0 );
|
|
|
11732 return;
|
|
|
11733 }
|
|
|
11734
|
|
|
11735 return this._value();
|
|
|
11736 },
|
|
|
11737
|
|
|
11738 values: function( index, newValue ) {
|
|
|
11739 var vals,
|
|
|
11740 newValues,
|
|
|
11741 i;
|
|
|
11742
|
|
|
11743 if ( arguments.length > 1 ) {
|
|
|
11744 this.options.values[ index ] = this._trimAlignValue( newValue );
|
|
|
11745 this._refreshValue();
|
|
|
11746 this._change( null, index );
|
|
|
11747 return;
|
|
|
11748 }
|
|
|
11749
|
|
|
11750 if ( arguments.length ) {
|
|
|
11751 if ( $.isArray( arguments[ 0 ] ) ) {
|
|
|
11752 vals = this.options.values;
|
|
|
11753 newValues = arguments[ 0 ];
|
|
|
11754 for ( i = 0; i < vals.length; i += 1 ) {
|
|
|
11755 vals[ i ] = this._trimAlignValue( newValues[ i ] );
|
|
|
11756 this._change( null, i );
|
|
|
11757 }
|
|
|
11758 this._refreshValue();
|
|
|
11759 } else {
|
|
|
11760 if ( this.options.values && this.options.values.length ) {
|
|
|
11761 return this._values( index );
|
|
|
11762 } else {
|
|
|
11763 return this.value();
|
|
|
11764 }
|
|
|
11765 }
|
|
|
11766 } else {
|
|
|
11767 return this._values();
|
|
|
11768 }
|
|
|
11769 },
|
|
|
11770
|
|
|
11771 _setOption: function( key, value ) {
|
|
|
11772 var i,
|
|
|
11773 valsLength = 0;
|
|
|
11774
|
|
|
11775 if ( key === "range" && this.options.range === true ) {
|
|
|
11776 if ( value === "min" ) {
|
|
|
11777 this.options.value = this._values( 0 );
|
|
|
11778 this.options.values = null;
|
|
|
11779 } else if ( value === "max" ) {
|
|
|
11780 this.options.value = this._values( this.options.values.length-1 );
|
|
|
11781 this.options.values = null;
|
|
|
11782 }
|
|
|
11783 }
|
|
|
11784
|
|
|
11785 if ( $.isArray( this.options.values ) ) {
|
|
|
11786 valsLength = this.options.values.length;
|
|
|
11787 }
|
|
|
11788
|
|
|
11789 $.Widget.prototype._setOption.apply( this, arguments );
|
|
|
11790
|
|
|
11791 switch ( key ) {
|
|
|
11792 case "orientation":
|
|
|
11793 this._detectOrientation();
|
|
|
11794 this.element
|
|
|
11795 .removeClass( "ui-slider-horizontal ui-slider-vertical" )
|
|
|
11796 .addClass( "ui-slider-" + this.orientation );
|
|
|
11797 this._refreshValue();
|
|
|
11798 break;
|
|
|
11799 case "value":
|
|
|
11800 this._animateOff = true;
|
|
|
11801 this._refreshValue();
|
|
|
11802 this._change( null, 0 );
|
|
|
11803 this._animateOff = false;
|
|
|
11804 break;
|
|
|
11805 case "values":
|
|
|
11806 this._animateOff = true;
|
|
|
11807 this._refreshValue();
|
|
|
11808 for ( i = 0; i < valsLength; i += 1 ) {
|
|
|
11809 this._change( null, i );
|
|
|
11810 }
|
|
|
11811 this._animateOff = false;
|
|
|
11812 break;
|
|
|
11813 case "min":
|
|
|
11814 case "max":
|
|
|
11815 this._animateOff = true;
|
|
|
11816 this._refreshValue();
|
|
|
11817 this._animateOff = false;
|
|
|
11818 break;
|
|
|
11819 case "range":
|
|
|
11820 this._animateOff = true;
|
|
|
11821 this._refresh();
|
|
|
11822 this._animateOff = false;
|
|
|
11823 break;
|
|
|
11824 }
|
|
|
11825 },
|
|
|
11826
|
|
|
11827 //internal value getter
|
|
|
11828 // _value() returns value trimmed by min and max, aligned by step
|
|
|
11829 _value: function() {
|
|
|
11830 var val = this.options.value;
|
|
|
11831 val = this._trimAlignValue( val );
|
|
|
11832
|
|
|
11833 return val;
|
|
|
11834 },
|
|
|
11835
|
|
|
11836 //internal values getter
|
|
|
11837 // _values() returns array of values trimmed by min and max, aligned by step
|
|
|
11838 // _values( index ) returns single value trimmed by min and max, aligned by step
|
|
|
11839 _values: function( index ) {
|
|
|
11840 var val,
|
|
|
11841 vals,
|
|
|
11842 i;
|
|
|
11843
|
|
|
11844 if ( arguments.length ) {
|
|
|
11845 val = this.options.values[ index ];
|
|
|
11846 val = this._trimAlignValue( val );
|
|
|
11847
|
|
|
11848 return val;
|
|
|
11849 } else if ( this.options.values && this.options.values.length ) {
|
|
|
11850 // .slice() creates a copy of the array
|
|
|
11851 // this copy gets trimmed by min and max and then returned
|
|
|
11852 vals = this.options.values.slice();
|
|
|
11853 for ( i = 0; i < vals.length; i+= 1) {
|
|
|
11854 vals[ i ] = this._trimAlignValue( vals[ i ] );
|
|
|
11855 }
|
|
|
11856
|
|
|
11857 return vals;
|
|
|
11858 } else {
|
|
|
11859 return [];
|
|
|
11860 }
|
|
|
11861 },
|
|
|
11862
|
|
|
11863 // returns the step-aligned value that val is closest to, between (inclusive) min and max
|
|
|
11864 _trimAlignValue: function( val ) {
|
|
|
11865 if ( val <= this._valueMin() ) {
|
|
|
11866 return this._valueMin();
|
|
|
11867 }
|
|
|
11868 if ( val >= this._valueMax() ) {
|
|
|
11869 return this._valueMax();
|
|
|
11870 }
|
|
|
11871 var step = ( this.options.step > 0 ) ? this.options.step : 1,
|
|
|
11872 valModStep = (val - this._valueMin()) % step,
|
|
|
11873 alignValue = val - valModStep;
|
|
|
11874
|
|
|
11875 if ( Math.abs(valModStep) * 2 >= step ) {
|
|
|
11876 alignValue += ( valModStep > 0 ) ? step : ( -step );
|
|
|
11877 }
|
|
|
11878
|
|
|
11879 // Since JavaScript has problems with large floats, round
|
|
|
11880 // the final value to 5 digits after the decimal point (see #4124)
|
|
|
11881 return parseFloat( alignValue.toFixed(5) );
|
|
|
11882 },
|
|
|
11883
|
|
|
11884 _valueMin: function() {
|
|
|
11885 return this.options.min;
|
|
|
11886 },
|
|
|
11887
|
|
|
11888 _valueMax: function() {
|
|
|
11889 return this.options.max;
|
|
|
11890 },
|
|
|
11891
|
|
|
11892 _refreshValue: function() {
|
|
|
11893 var lastValPercent, valPercent, value, valueMin, valueMax,
|
|
|
11894 oRange = this.options.range,
|
|
|
11895 o = this.options,
|
|
|
11896 that = this,
|
|
|
11897 animate = ( !this._animateOff ) ? o.animate : false,
|
|
|
11898 _set = {};
|
|
|
11899
|
|
|
11900 if ( this.options.values && this.options.values.length ) {
|
|
|
11901 this.handles.each(function( i ) {
|
|
|
11902 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
|
|
|
11903 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
|
|
|
11904 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
|
|
|
11905 if ( that.options.range === true ) {
|
|
|
11906 if ( that.orientation === "horizontal" ) {
|
|
|
11907 if ( i === 0 ) {
|
|
|
11908 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
|
|
|
11909 }
|
|
|
11910 if ( i === 1 ) {
|
|
|
11911 that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
|
|
|
11912 }
|
|
|
11913 } else {
|
|
|
11914 if ( i === 0 ) {
|
|
|
11915 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
|
|
|
11916 }
|
|
|
11917 if ( i === 1 ) {
|
|
|
11918 that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
|
|
|
11919 }
|
|
|
11920 }
|
|
|
11921 }
|
|
|
11922 lastValPercent = valPercent;
|
|
|
11923 });
|
|
|
11924 } else {
|
|
|
11925 value = this.value();
|
|
|
11926 valueMin = this._valueMin();
|
|
|
11927 valueMax = this._valueMax();
|
|
|
11928 valPercent = ( valueMax !== valueMin ) ?
|
|
|
11929 ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
|
|
|
11930 0;
|
|
|
11931 _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
|
|
|
11932 this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
|
|
|
11933
|
|
|
11934 if ( oRange === "min" && this.orientation === "horizontal" ) {
|
|
|
11935 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
|
|
|
11936 }
|
|
|
11937 if ( oRange === "max" && this.orientation === "horizontal" ) {
|
|
|
11938 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
|
|
|
11939 }
|
|
|
11940 if ( oRange === "min" && this.orientation === "vertical" ) {
|
|
|
11941 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
|
|
|
11942 }
|
|
|
11943 if ( oRange === "max" && this.orientation === "vertical" ) {
|
|
|
11944 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
|
|
|
11945 }
|
|
|
11946 }
|
|
|
11947 },
|
|
|
11948
|
|
|
11949 _handleEvents: {
|
|
|
11950 keydown: function( event ) {
|
|
|
11951 var allowed, curVal, newVal, step,
|
|
|
11952 index = $( event.target ).data( "ui-slider-handle-index" );
|
|
|
11953
|
|
|
11954 switch ( event.keyCode ) {
|
|
|
11955 case $.ui.keyCode.HOME:
|
|
|
11956 case $.ui.keyCode.END:
|
|
|
11957 case $.ui.keyCode.PAGE_UP:
|
|
|
11958 case $.ui.keyCode.PAGE_DOWN:
|
|
|
11959 case $.ui.keyCode.UP:
|
|
|
11960 case $.ui.keyCode.RIGHT:
|
|
|
11961 case $.ui.keyCode.DOWN:
|
|
|
11962 case $.ui.keyCode.LEFT:
|
|
|
11963 event.preventDefault();
|
|
|
11964 if ( !this._keySliding ) {
|
|
|
11965 this._keySliding = true;
|
|
|
11966 $( event.target ).addClass( "ui-state-active" );
|
|
|
11967 allowed = this._start( event, index );
|
|
|
11968 if ( allowed === false ) {
|
|
|
11969 return;
|
|
|
11970 }
|
|
|
11971 }
|
|
|
11972 break;
|
|
|
11973 }
|
|
|
11974
|
|
|
11975 step = this.options.step;
|
|
|
11976 if ( this.options.values && this.options.values.length ) {
|
|
|
11977 curVal = newVal = this.values( index );
|
|
|
11978 } else {
|
|
|
11979 curVal = newVal = this.value();
|
|
|
11980 }
|
|
|
11981
|
|
|
11982 switch ( event.keyCode ) {
|
|
|
11983 case $.ui.keyCode.HOME:
|
|
|
11984 newVal = this._valueMin();
|
|
|
11985 break;
|
|
|
11986 case $.ui.keyCode.END:
|
|
|
11987 newVal = this._valueMax();
|
|
|
11988 break;
|
|
|
11989 case $.ui.keyCode.PAGE_UP:
|
|
|
11990 newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
|
|
|
11991 break;
|
|
|
11992 case $.ui.keyCode.PAGE_DOWN:
|
|
|
11993 newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
|
|
|
11994 break;
|
|
|
11995 case $.ui.keyCode.UP:
|
|
|
11996 case $.ui.keyCode.RIGHT:
|
|
|
11997 if ( curVal === this._valueMax() ) {
|
|
|
11998 return;
|
|
|
11999 }
|
|
|
12000 newVal = this._trimAlignValue( curVal + step );
|
|
|
12001 break;
|
|
|
12002 case $.ui.keyCode.DOWN:
|
|
|
12003 case $.ui.keyCode.LEFT:
|
|
|
12004 if ( curVal === this._valueMin() ) {
|
|
|
12005 return;
|
|
|
12006 }
|
|
|
12007 newVal = this._trimAlignValue( curVal - step );
|
|
|
12008 break;
|
|
|
12009 }
|
|
|
12010
|
|
|
12011 this._slide( event, index, newVal );
|
|
|
12012 },
|
|
|
12013 click: function( event ) {
|
|
|
12014 event.preventDefault();
|
|
|
12015 },
|
|
|
12016 keyup: function( event ) {
|
|
|
12017 var index = $( event.target ).data( "ui-slider-handle-index" );
|
|
|
12018
|
|
|
12019 if ( this._keySliding ) {
|
|
|
12020 this._keySliding = false;
|
|
|
12021 this._stop( event, index );
|
|
|
12022 this._change( event, index );
|
|
|
12023 $( event.target ).removeClass( "ui-state-active" );
|
|
|
12024 }
|
|
|
12025 }
|
|
|
12026 }
|
|
|
12027
|
|
|
12028 });
|
|
|
12029
|
|
|
12030 }(jQuery));
|
|
|
12031 (function( $, undefined ) {
|
|
|
12032
|
|
|
12033 function isOverAxis( x, reference, size ) {
|
|
|
12034 return ( x > reference ) && ( x < ( reference + size ) );
|
|
|
12035 }
|
|
|
12036
|
|
|
12037 function isFloating(item) {
|
|
|
12038 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
|
|
|
12039 }
|
|
|
12040
|
|
|
12041 $.widget("ui.sortable", $.ui.mouse, {
|
|
|
12042 version: "1.10.4",
|
|
|
12043 widgetEventPrefix: "sort",
|
|
|
12044 ready: false,
|
|
|
12045 options: {
|
|
|
12046 appendTo: "parent",
|
|
|
12047 axis: false,
|
|
|
12048 connectWith: false,
|
|
|
12049 containment: false,
|
|
|
12050 cursor: "auto",
|
|
|
12051 cursorAt: false,
|
|
|
12052 dropOnEmpty: true,
|
|
|
12053 forcePlaceholderSize: false,
|
|
|
12054 forceHelperSize: false,
|
|
|
12055 grid: false,
|
|
|
12056 handle: false,
|
|
|
12057 helper: "original",
|
|
|
12058 items: "> *",
|
|
|
12059 opacity: false,
|
|
|
12060 placeholder: false,
|
|
|
12061 revert: false,
|
|
|
12062 scroll: true,
|
|
|
12063 scrollSensitivity: 20,
|
|
|
12064 scrollSpeed: 20,
|
|
|
12065 scope: "default",
|
|
|
12066 tolerance: "intersect",
|
|
|
12067 zIndex: 1000,
|
|
|
12068
|
|
|
12069 // callbacks
|
|
|
12070 activate: null,
|
|
|
12071 beforeStop: null,
|
|
|
12072 change: null,
|
|
|
12073 deactivate: null,
|
|
|
12074 out: null,
|
|
|
12075 over: null,
|
|
|
12076 receive: null,
|
|
|
12077 remove: null,
|
|
|
12078 sort: null,
|
|
|
12079 start: null,
|
|
|
12080 stop: null,
|
|
|
12081 update: null
|
|
|
12082 },
|
|
|
12083 _create: function() {
|
|
|
12084
|
|
|
12085 var o = this.options;
|
|
|
12086 this.containerCache = {};
|
|
|
12087 this.element.addClass("ui-sortable");
|
|
|
12088
|
|
|
12089 //Get the items
|
|
|
12090 this.refresh();
|
|
|
12091
|
|
|
12092 //Let's determine if the items are being displayed horizontally
|
|
|
12093 this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
|
|
|
12094
|
|
|
12095 //Let's determine the parent's offset
|
|
|
12096 this.offset = this.element.offset();
|
|
|
12097
|
|
|
12098 //Initialize mouse events for interaction
|
|
|
12099 this._mouseInit();
|
|
|
12100
|
|
|
12101 //We're ready to go
|
|
|
12102 this.ready = true;
|
|
|
12103
|
|
|
12104 },
|
|
|
12105
|
|
|
12106 _destroy: function() {
|
|
|
12107 this.element
|
|
|
12108 .removeClass("ui-sortable ui-sortable-disabled");
|
|
|
12109 this._mouseDestroy();
|
|
|
12110
|
|
|
12111 for ( var i = this.items.length - 1; i >= 0; i-- ) {
|
|
|
12112 this.items[i].item.removeData(this.widgetName + "-item");
|
|
|
12113 }
|
|
|
12114
|
|
|
12115 return this;
|
|
|
12116 },
|
|
|
12117
|
|
|
12118 _setOption: function(key, value){
|
|
|
12119 if ( key === "disabled" ) {
|
|
|
12120 this.options[ key ] = value;
|
|
|
12121
|
|
|
12122 this.widget().toggleClass( "ui-sortable-disabled", !!value );
|
|
|
12123 } else {
|
|
|
12124 // Don't call widget base _setOption for disable as it adds ui-state-disabled class
|
|
|
12125 $.Widget.prototype._setOption.apply(this, arguments);
|
|
|
12126 }
|
|
|
12127 },
|
|
|
12128
|
|
|
12129 _mouseCapture: function(event, overrideHandle) {
|
|
|
12130 var currentItem = null,
|
|
|
12131 validHandle = false,
|
|
|
12132 that = this;
|
|
|
12133
|
|
|
12134 if (this.reverting) {
|
|
|
12135 return false;
|
|
|
12136 }
|
|
|
12137
|
|
|
12138 if(this.options.disabled || this.options.type === "static") {
|
|
|
12139 return false;
|
|
|
12140 }
|
|
|
12141
|
|
|
12142 //We have to refresh the items data once first
|
|
|
12143 this._refreshItems(event);
|
|
|
12144
|
|
|
12145 //Find out if the clicked node (or one of its parents) is a actual item in this.items
|
|
|
12146 $(event.target).parents().each(function() {
|
|
|
12147 if($.data(this, that.widgetName + "-item") === that) {
|
|
|
12148 currentItem = $(this);
|
|
|
12149 return false;
|
|
|
12150 }
|
|
|
12151 });
|
|
|
12152 if($.data(event.target, that.widgetName + "-item") === that) {
|
|
|
12153 currentItem = $(event.target);
|
|
|
12154 }
|
|
|
12155
|
|
|
12156 if(!currentItem) {
|
|
|
12157 return false;
|
|
|
12158 }
|
|
|
12159 if(this.options.handle && !overrideHandle) {
|
|
|
12160 $(this.options.handle, currentItem).find("*").addBack().each(function() {
|
|
|
12161 if(this === event.target) {
|
|
|
12162 validHandle = true;
|
|
|
12163 }
|
|
|
12164 });
|
|
|
12165 if(!validHandle) {
|
|
|
12166 return false;
|
|
|
12167 }
|
|
|
12168 }
|
|
|
12169
|
|
|
12170 this.currentItem = currentItem;
|
|
|
12171 this._removeCurrentsFromItems();
|
|
|
12172 return true;
|
|
|
12173
|
|
|
12174 },
|
|
|
12175
|
|
|
12176 _mouseStart: function(event, overrideHandle, noActivation) {
|
|
|
12177
|
|
|
12178 var i, body,
|
|
|
12179 o = this.options;
|
|
|
12180
|
|
|
12181 this.currentContainer = this;
|
|
|
12182
|
|
|
12183 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
|
|
|
12184 this.refreshPositions();
|
|
|
12185
|
|
|
12186 //Create and append the visible helper
|
|
|
12187 this.helper = this._createHelper(event);
|
|
|
12188
|
|
|
12189 //Cache the helper size
|
|
|
12190 this._cacheHelperProportions();
|
|
|
12191
|
|
|
12192 /*
|
|
|
12193 * - Position generation -
|
|
|
12194 * This block generates everything position related - it's the core of draggables.
|
|
|
12195 */
|
|
|
12196
|
|
|
12197 //Cache the margins of the original element
|
|
|
12198 this._cacheMargins();
|
|
|
12199
|
|
|
12200 //Get the next scrolling parent
|
|
|
12201 this.scrollParent = this.helper.scrollParent();
|
|
|
12202
|
|
|
12203 //The element's absolute position on the page minus margins
|
|
|
12204 this.offset = this.currentItem.offset();
|
|
|
12205 this.offset = {
|
|
|
12206 top: this.offset.top - this.margins.top,
|
|
|
12207 left: this.offset.left - this.margins.left
|
|
|
12208 };
|
|
|
12209
|
|
|
12210 $.extend(this.offset, {
|
|
|
12211 click: { //Where the click happened, relative to the element
|
|
|
12212 left: event.pageX - this.offset.left,
|
|
|
12213 top: event.pageY - this.offset.top
|
|
|
12214 },
|
|
|
12215 parent: this._getParentOffset(),
|
|
|
12216 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
|
|
|
12217 });
|
|
|
12218
|
|
|
12219 // Only after we got the offset, we can change the helper's position to absolute
|
|
|
12220 // TODO: Still need to figure out a way to make relative sorting possible
|
|
|
12221 this.helper.css("position", "absolute");
|
|
|
12222 this.cssPosition = this.helper.css("position");
|
|
|
12223
|
|
|
12224 //Generate the original position
|
|
|
12225 this.originalPosition = this._generatePosition(event);
|
|
|
12226 this.originalPageX = event.pageX;
|
|
|
12227 this.originalPageY = event.pageY;
|
|
|
12228
|
|
|
12229 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
|
|
|
12230 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
|
|
|
12231
|
|
|
12232 //Cache the former DOM position
|
|
|
12233 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
|
|
|
12234
|
|
|
12235 //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
|
|
|
12236 if(this.helper[0] !== this.currentItem[0]) {
|
|
|
12237 this.currentItem.hide();
|
|
|
12238 }
|
|
|
12239
|
|
|
12240 //Create the placeholder
|
|
|
12241 this._createPlaceholder();
|
|
|
12242
|
|
|
12243 //Set a containment if given in the options
|
|
|
12244 if(o.containment) {
|
|
|
12245 this._setContainment();
|
|
|
12246 }
|
|
|
12247
|
|
|
12248 if( o.cursor && o.cursor !== "auto" ) { // cursor option
|
|
|
12249 body = this.document.find( "body" );
|
|
|
12250
|
|
|
12251 // support: IE
|
|
|
12252 this.storedCursor = body.css( "cursor" );
|
|
|
12253 body.css( "cursor", o.cursor );
|
|
|
12254
|
|
|
12255 this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
|
|
|
12256 }
|
|
|
12257
|
|
|
12258 if(o.opacity) { // opacity option
|
|
|
12259 if (this.helper.css("opacity")) {
|
|
|
12260 this._storedOpacity = this.helper.css("opacity");
|
|
|
12261 }
|
|
|
12262 this.helper.css("opacity", o.opacity);
|
|
|
12263 }
|
|
|
12264
|
|
|
12265 if(o.zIndex) { // zIndex option
|
|
|
12266 if (this.helper.css("zIndex")) {
|
|
|
12267 this._storedZIndex = this.helper.css("zIndex");
|
|
|
12268 }
|
|
|
12269 this.helper.css("zIndex", o.zIndex);
|
|
|
12270 }
|
|
|
12271
|
|
|
12272 //Prepare scrolling
|
|
|
12273 if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
|
|
|
12274 this.overflowOffset = this.scrollParent.offset();
|
|
|
12275 }
|
|
|
12276
|
|
|
12277 //Call callbacks
|
|
|
12278 this._trigger("start", event, this._uiHash());
|
|
|
12279
|
|
|
12280 //Recache the helper size
|
|
|
12281 if(!this._preserveHelperProportions) {
|
|
|
12282 this._cacheHelperProportions();
|
|
|
12283 }
|
|
|
12284
|
|
|
12285
|
|
|
12286 //Post "activate" events to possible containers
|
|
|
12287 if( !noActivation ) {
|
|
|
12288 for ( i = this.containers.length - 1; i >= 0; i-- ) {
|
|
|
12289 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
|
|
|
12290 }
|
|
|
12291 }
|
|
|
12292
|
|
|
12293 //Prepare possible droppables
|
|
|
12294 if($.ui.ddmanager) {
|
|
|
12295 $.ui.ddmanager.current = this;
|
|
|
12296 }
|
|
|
12297
|
|
|
12298 if ($.ui.ddmanager && !o.dropBehaviour) {
|
|
|
12299 $.ui.ddmanager.prepareOffsets(this, event);
|
|
|
12300 }
|
|
|
12301
|
|
|
12302 this.dragging = true;
|
|
|
12303
|
|
|
12304 this.helper.addClass("ui-sortable-helper");
|
|
|
12305 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
|
|
|
12306 return true;
|
|
|
12307
|
|
|
12308 },
|
|
|
12309
|
|
|
12310 _mouseDrag: function(event) {
|
|
|
12311 var i, item, itemElement, intersection,
|
|
|
12312 o = this.options,
|
|
|
12313 scrolled = false;
|
|
|
12314
|
|
|
12315 //Compute the helpers position
|
|
|
12316 this.position = this._generatePosition(event);
|
|
|
12317 this.positionAbs = this._convertPositionTo("absolute");
|
|
|
12318
|
|
|
12319 if (!this.lastPositionAbs) {
|
|
|
12320 this.lastPositionAbs = this.positionAbs;
|
|
|
12321 }
|
|
|
12322
|
|
|
12323 //Do scrolling
|
|
|
12324 if(this.options.scroll) {
|
|
|
12325 if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
|
|
|
12326
|
|
|
12327 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
|
|
|
12328 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
|
|
|
12329 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
|
|
|
12330 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
|
|
|
12331 }
|
|
|
12332
|
|
|
12333 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
|
|
|
12334 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
|
|
|
12335 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
|
|
|
12336 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
|
|
|
12337 }
|
|
|
12338
|
|
|
12339 } else {
|
|
|
12340
|
|
|
12341 if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
|
|
|
12342 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
|
|
|
12343 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
|
|
|
12344 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
|
|
|
12345 }
|
|
|
12346
|
|
|
12347 if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
|
|
|
12348 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
|
|
|
12349 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
|
|
|
12350 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
|
|
|
12351 }
|
|
|
12352
|
|
|
12353 }
|
|
|
12354
|
|
|
12355 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
|
|
|
12356 $.ui.ddmanager.prepareOffsets(this, event);
|
|
|
12357 }
|
|
|
12358 }
|
|
|
12359
|
|
|
12360 //Regenerate the absolute position used for position checks
|
|
|
12361 this.positionAbs = this._convertPositionTo("absolute");
|
|
|
12362
|
|
|
12363 //Set the helper position
|
|
|
12364 if(!this.options.axis || this.options.axis !== "y") {
|
|
|
12365 this.helper[0].style.left = this.position.left+"px";
|
|
|
12366 }
|
|
|
12367 if(!this.options.axis || this.options.axis !== "x") {
|
|
|
12368 this.helper[0].style.top = this.position.top+"px";
|
|
|
12369 }
|
|
|
12370
|
|
|
12371 //Rearrange
|
|
|
12372 for (i = this.items.length - 1; i >= 0; i--) {
|
|
|
12373
|
|
|
12374 //Cache variables and intersection, continue if no intersection
|
|
|
12375 item = this.items[i];
|
|
|
12376 itemElement = item.item[0];
|
|
|
12377 intersection = this._intersectsWithPointer(item);
|
|
|
12378 if (!intersection) {
|
|
|
12379 continue;
|
|
|
12380 }
|
|
|
12381
|
|
|
12382 // Only put the placeholder inside the current Container, skip all
|
|
|
12383 // items from other containers. This works because when moving
|
|
|
12384 // an item from one container to another the
|
|
|
12385 // currentContainer is switched before the placeholder is moved.
|
|
|
12386 //
|
|
|
12387 // Without this, moving items in "sub-sortables" can cause
|
|
|
12388 // the placeholder to jitter beetween the outer and inner container.
|
|
|
12389 if (item.instance !== this.currentContainer) {
|
|
|
12390 continue;
|
|
|
12391 }
|
|
|
12392
|
|
|
12393 // cannot intersect with itself
|
|
|
12394 // no useless actions that have been done before
|
|
|
12395 // no action if the item moved is the parent of the item checked
|
|
|
12396 if (itemElement !== this.currentItem[0] &&
|
|
|
12397 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
|
|
|
12398 !$.contains(this.placeholder[0], itemElement) &&
|
|
|
12399 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
|
|
|
12400 ) {
|
|
|
12401
|
|
|
12402 this.direction = intersection === 1 ? "down" : "up";
|
|
|
12403
|
|
|
12404 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
|
|
|
12405 this._rearrange(event, item);
|
|
|
12406 } else {
|
|
|
12407 break;
|
|
|
12408 }
|
|
|
12409
|
|
|
12410 this._trigger("change", event, this._uiHash());
|
|
|
12411 break;
|
|
|
12412 }
|
|
|
12413 }
|
|
|
12414
|
|
|
12415 //Post events to containers
|
|
|
12416 this._contactContainers(event);
|
|
|
12417
|
|
|
12418 //Interconnect with droppables
|
|
|
12419 if($.ui.ddmanager) {
|
|
|
12420 $.ui.ddmanager.drag(this, event);
|
|
|
12421 }
|
|
|
12422
|
|
|
12423 //Call callbacks
|
|
|
12424 this._trigger("sort", event, this._uiHash());
|
|
|
12425
|
|
|
12426 this.lastPositionAbs = this.positionAbs;
|
|
|
12427 return false;
|
|
|
12428
|
|
|
12429 },
|
|
|
12430
|
|
|
12431 _mouseStop: function(event, noPropagation) {
|
|
|
12432
|
|
|
12433 if(!event) {
|
|
|
12434 return;
|
|
|
12435 }
|
|
|
12436
|
|
|
12437 //If we are using droppables, inform the manager about the drop
|
|
|
12438 if ($.ui.ddmanager && !this.options.dropBehaviour) {
|
|
|
12439 $.ui.ddmanager.drop(this, event);
|
|
|
12440 }
|
|
|
12441
|
|
|
12442 if(this.options.revert) {
|
|
|
12443 var that = this,
|
|
|
12444 cur = this.placeholder.offset(),
|
|
|
12445 axis = this.options.axis,
|
|
|
12446 animation = {};
|
|
|
12447
|
|
|
12448 if ( !axis || axis === "x" ) {
|
|
|
12449 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
|
|
|
12450 }
|
|
|
12451 if ( !axis || axis === "y" ) {
|
|
|
12452 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
|
|
|
12453 }
|
|
|
12454 this.reverting = true;
|
|
|
12455 $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
|
|
|
12456 that._clear(event);
|
|
|
12457 });
|
|
|
12458 } else {
|
|
|
12459 this._clear(event, noPropagation);
|
|
|
12460 }
|
|
|
12461
|
|
|
12462 return false;
|
|
|
12463
|
|
|
12464 },
|
|
|
12465
|
|
|
12466 cancel: function() {
|
|
|
12467
|
|
|
12468 if(this.dragging) {
|
|
|
12469
|
|
|
12470 this._mouseUp({ target: null });
|
|
|
12471
|
|
|
12472 if(this.options.helper === "original") {
|
|
|
12473 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
|
|
|
12474 } else {
|
|
|
12475 this.currentItem.show();
|
|
|
12476 }
|
|
|
12477
|
|
|
12478 //Post deactivating events to containers
|
|
|
12479 for (var i = this.containers.length - 1; i >= 0; i--){
|
|
|
12480 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
|
|
|
12481 if(this.containers[i].containerCache.over) {
|
|
|
12482 this.containers[i]._trigger("out", null, this._uiHash(this));
|
|
|
12483 this.containers[i].containerCache.over = 0;
|
|
|
12484 }
|
|
|
12485 }
|
|
|
12486
|
|
|
12487 }
|
|
|
12488
|
|
|
12489 if (this.placeholder) {
|
|
|
12490 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
|
|
|
12491 if(this.placeholder[0].parentNode) {
|
|
|
12492 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
|
|
|
12493 }
|
|
|
12494 if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
|
|
|
12495 this.helper.remove();
|
|
|
12496 }
|
|
|
12497
|
|
|
12498 $.extend(this, {
|
|
|
12499 helper: null,
|
|
|
12500 dragging: false,
|
|
|
12501 reverting: false,
|
|
|
12502 _noFinalSort: null
|
|
|
12503 });
|
|
|
12504
|
|
|
12505 if(this.domPosition.prev) {
|
|
|
12506 $(this.domPosition.prev).after(this.currentItem);
|
|
|
12507 } else {
|
|
|
12508 $(this.domPosition.parent).prepend(this.currentItem);
|
|
|
12509 }
|
|
|
12510 }
|
|
|
12511
|
|
|
12512 return this;
|
|
|
12513
|
|
|
12514 },
|
|
|
12515
|
|
|
12516 serialize: function(o) {
|
|
|
12517
|
|
|
12518 var items = this._getItemsAsjQuery(o && o.connected),
|
|
|
12519 str = [];
|
|
|
12520 o = o || {};
|
|
|
12521
|
|
|
12522 $(items).each(function() {
|
|
|
12523 var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
|
|
|
12524 if (res) {
|
|
|
12525 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
|
|
|
12526 }
|
|
|
12527 });
|
|
|
12528
|
|
|
12529 if(!str.length && o.key) {
|
|
|
12530 str.push(o.key + "=");
|
|
|
12531 }
|
|
|
12532
|
|
|
12533 return str.join("&");
|
|
|
12534
|
|
|
12535 },
|
|
|
12536
|
|
|
12537 toArray: function(o) {
|
|
|
12538
|
|
|
12539 var items = this._getItemsAsjQuery(o && o.connected),
|
|
|
12540 ret = [];
|
|
|
12541
|
|
|
12542 o = o || {};
|
|
|
12543
|
|
|
12544 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
|
|
|
12545 return ret;
|
|
|
12546
|
|
|
12547 },
|
|
|
12548
|
|
|
12549 /* Be careful with the following core functions */
|
|
|
12550 _intersectsWith: function(item) {
|
|
|
12551
|
|
|
12552 var x1 = this.positionAbs.left,
|
|
|
12553 x2 = x1 + this.helperProportions.width,
|
|
|
12554 y1 = this.positionAbs.top,
|
|
|
12555 y2 = y1 + this.helperProportions.height,
|
|
|
12556 l = item.left,
|
|
|
12557 r = l + item.width,
|
|
|
12558 t = item.top,
|
|
|
12559 b = t + item.height,
|
|
|
12560 dyClick = this.offset.click.top,
|
|
|
12561 dxClick = this.offset.click.left,
|
|
|
12562 isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
|
|
|
12563 isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
|
|
|
12564 isOverElement = isOverElementHeight && isOverElementWidth;
|
|
|
12565
|
|
|
12566 if ( this.options.tolerance === "pointer" ||
|
|
|
12567 this.options.forcePointerForContainers ||
|
|
|
12568 (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
|
|
|
12569 ) {
|
|
|
12570 return isOverElement;
|
|
|
12571 } else {
|
|
|
12572
|
|
|
12573 return (l < x1 + (this.helperProportions.width / 2) && // Right Half
|
|
|
12574 x2 - (this.helperProportions.width / 2) < r && // Left Half
|
|
|
12575 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
|
|
|
12576 y2 - (this.helperProportions.height / 2) < b ); // Top Half
|
|
|
12577
|
|
|
12578 }
|
|
|
12579 },
|
|
|
12580
|
|
|
12581 _intersectsWithPointer: function(item) {
|
|
|
12582
|
|
|
12583 var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
|
|
|
12584 isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
|
|
|
12585 isOverElement = isOverElementHeight && isOverElementWidth,
|
|
|
12586 verticalDirection = this._getDragVerticalDirection(),
|
|
|
12587 horizontalDirection = this._getDragHorizontalDirection();
|
|
|
12588
|
|
|
12589 if (!isOverElement) {
|
|
|
12590 return false;
|
|
|
12591 }
|
|
|
12592
|
|
|
12593 return this.floating ?
|
|
|
12594 ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
|
|
|
12595 : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
|
|
|
12596
|
|
|
12597 },
|
|
|
12598
|
|
|
12599 _intersectsWithSides: function(item) {
|
|
|
12600
|
|
|
12601 var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
|
|
|
12602 isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
|
|
|
12603 verticalDirection = this._getDragVerticalDirection(),
|
|
|
12604 horizontalDirection = this._getDragHorizontalDirection();
|
|
|
12605
|
|
|
12606 if (this.floating && horizontalDirection) {
|
|
|
12607 return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
|
|
|
12608 } else {
|
|
|
12609 return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
|
|
|
12610 }
|
|
|
12611
|
|
|
12612 },
|
|
|
12613
|
|
|
12614 _getDragVerticalDirection: function() {
|
|
|
12615 var delta = this.positionAbs.top - this.lastPositionAbs.top;
|
|
|
12616 return delta !== 0 && (delta > 0 ? "down" : "up");
|
|
|
12617 },
|
|
|
12618
|
|
|
12619 _getDragHorizontalDirection: function() {
|
|
|
12620 var delta = this.positionAbs.left - this.lastPositionAbs.left;
|
|
|
12621 return delta !== 0 && (delta > 0 ? "right" : "left");
|
|
|
12622 },
|
|
|
12623
|
|
|
12624 refresh: function(event) {
|
|
|
12625 this._refreshItems(event);
|
|
|
12626 this.refreshPositions();
|
|
|
12627 return this;
|
|
|
12628 },
|
|
|
12629
|
|
|
12630 _connectWith: function() {
|
|
|
12631 var options = this.options;
|
|
|
12632 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
|
|
|
12633 },
|
|
|
12634
|
|
|
12635 _getItemsAsjQuery: function(connected) {
|
|
|
12636
|
|
|
12637 var i, j, cur, inst,
|
|
|
12638 items = [],
|
|
|
12639 queries = [],
|
|
|
12640 connectWith = this._connectWith();
|
|
|
12641
|
|
|
12642 if(connectWith && connected) {
|
|
|
12643 for (i = connectWith.length - 1; i >= 0; i--){
|
|
|
12644 cur = $(connectWith[i]);
|
|
|
12645 for ( j = cur.length - 1; j >= 0; j--){
|
|
|
12646 inst = $.data(cur[j], this.widgetFullName);
|
|
|
12647 if(inst && inst !== this && !inst.options.disabled) {
|
|
|
12648 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
|
|
|
12649 }
|
|
|
12650 }
|
|
|
12651 }
|
|
|
12652 }
|
|
|
12653
|
|
|
12654 queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
|
|
|
12655
|
|
|
12656 function addItems() {
|
|
|
12657 items.push( this );
|
|
|
12658 }
|
|
|
12659 for (i = queries.length - 1; i >= 0; i--){
|
|
|
12660 queries[i][0].each( addItems );
|
|
|
12661 }
|
|
|
12662
|
|
|
12663 return $(items);
|
|
|
12664
|
|
|
12665 },
|
|
|
12666
|
|
|
12667 _removeCurrentsFromItems: function() {
|
|
|
12668
|
|
|
12669 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
|
|
|
12670
|
|
|
12671 this.items = $.grep(this.items, function (item) {
|
|
|
12672 for (var j=0; j < list.length; j++) {
|
|
|
12673 if(list[j] === item.item[0]) {
|
|
|
12674 return false;
|
|
|
12675 }
|
|
|
12676 }
|
|
|
12677 return true;
|
|
|
12678 });
|
|
|
12679
|
|
|
12680 },
|
|
|
12681
|
|
|
12682 _refreshItems: function(event) {
|
|
|
12683
|
|
|
12684 this.items = [];
|
|
|
12685 this.containers = [this];
|
|
|
12686
|
|
|
12687 var i, j, cur, inst, targetData, _queries, item, queriesLength,
|
|
|
12688 items = this.items,
|
|
|
12689 queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
|
|
|
12690 connectWith = this._connectWith();
|
|
|
12691
|
|
|
12692 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
|
|
|
12693 for (i = connectWith.length - 1; i >= 0; i--){
|
|
|
12694 cur = $(connectWith[i]);
|
|
|
12695 for (j = cur.length - 1; j >= 0; j--){
|
|
|
12696 inst = $.data(cur[j], this.widgetFullName);
|
|
|
12697 if(inst && inst !== this && !inst.options.disabled) {
|
|
|
12698 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
|
|
|
12699 this.containers.push(inst);
|
|
|
12700 }
|
|
|
12701 }
|
|
|
12702 }
|
|
|
12703 }
|
|
|
12704
|
|
|
12705 for (i = queries.length - 1; i >= 0; i--) {
|
|
|
12706 targetData = queries[i][1];
|
|
|
12707 _queries = queries[i][0];
|
|
|
12708
|
|
|
12709 for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
|
|
|
12710 item = $(_queries[j]);
|
|
|
12711
|
|
|
12712 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
|
|
|
12713
|
|
|
12714 items.push({
|
|
|
12715 item: item,
|
|
|
12716 instance: targetData,
|
|
|
12717 width: 0, height: 0,
|
|
|
12718 left: 0, top: 0
|
|
|
12719 });
|
|
|
12720 }
|
|
|
12721 }
|
|
|
12722
|
|
|
12723 },
|
|
|
12724
|
|
|
12725 refreshPositions: function(fast) {
|
|
|
12726
|
|
|
12727 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
|
|
|
12728 if(this.offsetParent && this.helper) {
|
|
|
12729 this.offset.parent = this._getParentOffset();
|
|
|
12730 }
|
|
|
12731
|
|
|
12732 var i, item, t, p;
|
|
|
12733
|
|
|
12734 for (i = this.items.length - 1; i >= 0; i--){
|
|
|
12735 item = this.items[i];
|
|
|
12736
|
|
|
12737 //We ignore calculating positions of all connected containers when we're not over them
|
|
|
12738 if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
|
|
|
12739 continue;
|
|
|
12740 }
|
|
|
12741
|
|
|
12742 t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
|
|
|
12743
|
|
|
12744 if (!fast) {
|
|
|
12745 item.width = t.outerWidth();
|
|
|
12746 item.height = t.outerHeight();
|
|
|
12747 }
|
|
|
12748
|
|
|
12749 p = t.offset();
|
|
|
12750 item.left = p.left;
|
|
|
12751 item.top = p.top;
|
|
|
12752 }
|
|
|
12753
|
|
|
12754 if(this.options.custom && this.options.custom.refreshContainers) {
|
|
|
12755 this.options.custom.refreshContainers.call(this);
|
|
|
12756 } else {
|
|
|
12757 for (i = this.containers.length - 1; i >= 0; i--){
|
|
|
12758 p = this.containers[i].element.offset();
|
|
|
12759 this.containers[i].containerCache.left = p.left;
|
|
|
12760 this.containers[i].containerCache.top = p.top;
|
|
|
12761 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
|
|
|
12762 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
|
|
|
12763 }
|
|
|
12764 }
|
|
|
12765
|
|
|
12766 return this;
|
|
|
12767 },
|
|
|
12768
|
|
|
12769 _createPlaceholder: function(that) {
|
|
|
12770 that = that || this;
|
|
|
12771 var className,
|
|
|
12772 o = that.options;
|
|
|
12773
|
|
|
12774 if(!o.placeholder || o.placeholder.constructor === String) {
|
|
|
12775 className = o.placeholder;
|
|
|
12776 o.placeholder = {
|
|
|
12777 element: function() {
|
|
|
12778
|
|
|
12779 var nodeName = that.currentItem[0].nodeName.toLowerCase(),
|
|
|
12780 element = $( "<" + nodeName + ">", that.document[0] )
|
|
|
12781 .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
|
|
|
12782 .removeClass("ui-sortable-helper");
|
|
|
12783
|
|
|
12784 if ( nodeName === "tr" ) {
|
|
|
12785 that.currentItem.children().each(function() {
|
|
|
12786 $( "<td> </td>", that.document[0] )
|
|
|
12787 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
|
|
|
12788 .appendTo( element );
|
|
|
12789 });
|
|
|
12790 } else if ( nodeName === "img" ) {
|
|
|
12791 element.attr( "src", that.currentItem.attr( "src" ) );
|
|
|
12792 }
|
|
|
12793
|
|
|
12794 if ( !className ) {
|
|
|
12795 element.css( "visibility", "hidden" );
|
|
|
12796 }
|
|
|
12797
|
|
|
12798 return element;
|
|
|
12799 },
|
|
|
12800 update: function(container, p) {
|
|
|
12801
|
|
|
12802 // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
|
|
|
12803 // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
|
|
|
12804 if(className && !o.forcePlaceholderSize) {
|
|
|
12805 return;
|
|
|
12806 }
|
|
|
12807
|
|
|
12808 //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
|
|
|
12809 if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
|
|
|
12810 if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
|
|
|
12811 }
|
|
|
12812 };
|
|
|
12813 }
|
|
|
12814
|
|
|
12815 //Create the placeholder
|
|
|
12816 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
|
|
|
12817
|
|
|
12818 //Append it after the actual current item
|
|
|
12819 that.currentItem.after(that.placeholder);
|
|
|
12820
|
|
|
12821 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
|
|
|
12822 o.placeholder.update(that, that.placeholder);
|
|
|
12823
|
|
|
12824 },
|
|
|
12825
|
|
|
12826 _contactContainers: function(event) {
|
|
|
12827 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
|
|
|
12828 innermostContainer = null,
|
|
|
12829 innermostIndex = null;
|
|
|
12830
|
|
|
12831 // get innermost container that intersects with item
|
|
|
12832 for (i = this.containers.length - 1; i >= 0; i--) {
|
|
|
12833
|
|
|
12834 // never consider a container that's located within the item itself
|
|
|
12835 if($.contains(this.currentItem[0], this.containers[i].element[0])) {
|
|
|
12836 continue;
|
|
|
12837 }
|
|
|
12838
|
|
|
12839 if(this._intersectsWith(this.containers[i].containerCache)) {
|
|
|
12840
|
|
|
12841 // if we've already found a container and it's more "inner" than this, then continue
|
|
|
12842 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
|
|
|
12843 continue;
|
|
|
12844 }
|
|
|
12845
|
|
|
12846 innermostContainer = this.containers[i];
|
|
|
12847 innermostIndex = i;
|
|
|
12848
|
|
|
12849 } else {
|
|
|
12850 // container doesn't intersect. trigger "out" event if necessary
|
|
|
12851 if(this.containers[i].containerCache.over) {
|
|
|
12852 this.containers[i]._trigger("out", event, this._uiHash(this));
|
|
|
12853 this.containers[i].containerCache.over = 0;
|
|
|
12854 }
|
|
|
12855 }
|
|
|
12856
|
|
|
12857 }
|
|
|
12858
|
|
|
12859 // if no intersecting containers found, return
|
|
|
12860 if(!innermostContainer) {
|
|
|
12861 return;
|
|
|
12862 }
|
|
|
12863
|
|
|
12864 // move the item into the container if it's not there already
|
|
|
12865 if(this.containers.length === 1) {
|
|
|
12866 if (!this.containers[innermostIndex].containerCache.over) {
|
|
|
12867 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
|
|
|
12868 this.containers[innermostIndex].containerCache.over = 1;
|
|
|
12869 }
|
|
|
12870 } else {
|
|
|
12871
|
|
|
12872 //When entering a new container, we will find the item with the least distance and append our item near it
|
|
|
12873 dist = 10000;
|
|
|
12874 itemWithLeastDistance = null;
|
|
|
12875 floating = innermostContainer.floating || isFloating(this.currentItem);
|
|
|
12876 posProperty = floating ? "left" : "top";
|
|
|
12877 sizeProperty = floating ? "width" : "height";
|
|
|
12878 base = this.positionAbs[posProperty] + this.offset.click[posProperty];
|
|
|
12879 for (j = this.items.length - 1; j >= 0; j--) {
|
|
|
12880 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
|
|
|
12881 continue;
|
|
|
12882 }
|
|
|
12883 if(this.items[j].item[0] === this.currentItem[0]) {
|
|
|
12884 continue;
|
|
|
12885 }
|
|
|
12886 if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
|
|
|
12887 continue;
|
|
|
12888 }
|
|
|
12889 cur = this.items[j].item.offset()[posProperty];
|
|
|
12890 nearBottom = false;
|
|
|
12891 if(Math.abs(cur - base) > Math.abs(cur + this.items[j][sizeProperty] - base)){
|
|
|
12892 nearBottom = true;
|
|
|
12893 cur += this.items[j][sizeProperty];
|
|
|
12894 }
|
|
|
12895
|
|
|
12896 if(Math.abs(cur - base) < dist) {
|
|
|
12897 dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
|
|
|
12898 this.direction = nearBottom ? "up": "down";
|
|
|
12899 }
|
|
|
12900 }
|
|
|
12901
|
|
|
12902 //Check if dropOnEmpty is enabled
|
|
|
12903 if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
|
|
|
12904 return;
|
|
|
12905 }
|
|
|
12906
|
|
|
12907 if(this.currentContainer === this.containers[innermostIndex]) {
|
|
|
12908 return;
|
|
|
12909 }
|
|
|
12910
|
|
|
12911 itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
|
|
|
12912 this._trigger("change", event, this._uiHash());
|
|
|
12913 this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
|
|
|
12914 this.currentContainer = this.containers[innermostIndex];
|
|
|
12915
|
|
|
12916 //Update the placeholder
|
|
|
12917 this.options.placeholder.update(this.currentContainer, this.placeholder);
|
|
|
12918
|
|
|
12919 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
|
|
|
12920 this.containers[innermostIndex].containerCache.over = 1;
|
|
|
12921 }
|
|
|
12922
|
|
|
12923
|
|
|
12924 },
|
|
|
12925
|
|
|
12926 _createHelper: function(event) {
|
|
|
12927
|
|
|
12928 var o = this.options,
|
|
|
12929 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
|
|
|
12930
|
|
|
12931 //Add the helper to the DOM if that didn't happen already
|
|
|
12932 if(!helper.parents("body").length) {
|
|
|
12933 $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
|
|
|
12934 }
|
|
|
12935
|
|
|
12936 if(helper[0] === this.currentItem[0]) {
|
|
|
12937 this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
|
|
|
12938 }
|
|
|
12939
|
|
|
12940 if(!helper[0].style.width || o.forceHelperSize) {
|
|
|
12941 helper.width(this.currentItem.width());
|
|
|
12942 }
|
|
|
12943 if(!helper[0].style.height || o.forceHelperSize) {
|
|
|
12944 helper.height(this.currentItem.height());
|
|
|
12945 }
|
|
|
12946
|
|
|
12947 return helper;
|
|
|
12948
|
|
|
12949 },
|
|
|
12950
|
|
|
12951 _adjustOffsetFromHelper: function(obj) {
|
|
|
12952 if (typeof obj === "string") {
|
|
|
12953 obj = obj.split(" ");
|
|
|
12954 }
|
|
|
12955 if ($.isArray(obj)) {
|
|
|
12956 obj = {left: +obj[0], top: +obj[1] || 0};
|
|
|
12957 }
|
|
|
12958 if ("left" in obj) {
|
|
|
12959 this.offset.click.left = obj.left + this.margins.left;
|
|
|
12960 }
|
|
|
12961 if ("right" in obj) {
|
|
|
12962 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
|
|
|
12963 }
|
|
|
12964 if ("top" in obj) {
|
|
|
12965 this.offset.click.top = obj.top + this.margins.top;
|
|
|
12966 }
|
|
|
12967 if ("bottom" in obj) {
|
|
|
12968 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
|
|
|
12969 }
|
|
|
12970 },
|
|
|
12971
|
|
|
12972 _getParentOffset: function() {
|
|
|
12973
|
|
|
12974
|
|
|
12975 //Get the offsetParent and cache its position
|
|
|
12976 this.offsetParent = this.helper.offsetParent();
|
|
|
12977 var po = this.offsetParent.offset();
|
|
|
12978
|
|
|
12979 // This is a special case where we need to modify a offset calculated on start, since the following happened:
|
|
|
12980 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
|
|
|
12981 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
|
|
|
12982 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
|
|
|
12983 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
|
|
|
12984 po.left += this.scrollParent.scrollLeft();
|
|
|
12985 po.top += this.scrollParent.scrollTop();
|
|
|
12986 }
|
|
|
12987
|
|
|
12988 // This needs to be actually done for all browsers, since pageX/pageY includes this information
|
|
|
12989 // with an ugly IE fix
|
|
|
12990 if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
|
|
|
12991 po = { top: 0, left: 0 };
|
|
|
12992 }
|
|
|
12993
|
|
|
12994 return {
|
|
|
12995 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
|
|
|
12996 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
|
|
|
12997 };
|
|
|
12998
|
|
|
12999 },
|
|
|
13000
|
|
|
13001 _getRelativeOffset: function() {
|
|
|
13002
|
|
|
13003 if(this.cssPosition === "relative") {
|
|
|
13004 var p = this.currentItem.position();
|
|
|
13005 return {
|
|
|
13006 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
|
|
|
13007 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
|
|
|
13008 };
|
|
|
13009 } else {
|
|
|
13010 return { top: 0, left: 0 };
|
|
|
13011 }
|
|
|
13012
|
|
|
13013 },
|
|
|
13014
|
|
|
13015 _cacheMargins: function() {
|
|
|
13016 this.margins = {
|
|
|
13017 left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
|
|
|
13018 top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
|
|
|
13019 };
|
|
|
13020 },
|
|
|
13021
|
|
|
13022 _cacheHelperProportions: function() {
|
|
|
13023 this.helperProportions = {
|
|
|
13024 width: this.helper.outerWidth(),
|
|
|
13025 height: this.helper.outerHeight()
|
|
|
13026 };
|
|
|
13027 },
|
|
|
13028
|
|
|
13029 _setContainment: function() {
|
|
|
13030
|
|
|
13031 var ce, co, over,
|
|
|
13032 o = this.options;
|
|
|
13033 if(o.containment === "parent") {
|
|
|
13034 o.containment = this.helper[0].parentNode;
|
|
|
13035 }
|
|
|
13036 if(o.containment === "document" || o.containment === "window") {
|
|
|
13037 this.containment = [
|
|
|
13038 0 - this.offset.relative.left - this.offset.parent.left,
|
|
|
13039 0 - this.offset.relative.top - this.offset.parent.top,
|
|
|
13040 $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
|
|
|
13041 ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
|
|
|
13042 ];
|
|
|
13043 }
|
|
|
13044
|
|
|
13045 if(!(/^(document|window|parent)$/).test(o.containment)) {
|
|
|
13046 ce = $(o.containment)[0];
|
|
|
13047 co = $(o.containment).offset();
|
|
|
13048 over = ($(ce).css("overflow") !== "hidden");
|
|
|
13049
|
|
|
13050 this.containment = [
|
|
|
13051 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
|
|
|
13052 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
|
|
|
13053 co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
|
|
|
13054 co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
|
|
|
13055 ];
|
|
|
13056 }
|
|
|
13057
|
|
|
13058 },
|
|
|
13059
|
|
|
13060 _convertPositionTo: function(d, pos) {
|
|
|
13061
|
|
|
13062 if(!pos) {
|
|
|
13063 pos = this.position;
|
|
|
13064 }
|
|
|
13065 var mod = d === "absolute" ? 1 : -1,
|
|
|
13066 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
|
|
|
13067 scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
|
|
|
13068
|
|
|
13069 return {
|
|
|
13070 top: (
|
|
|
13071 pos.top + // The absolute mouse position
|
|
|
13072 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
13073 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
|
|
|
13074 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
|
|
|
13075 ),
|
|
|
13076 left: (
|
|
|
13077 pos.left + // The absolute mouse position
|
|
|
13078 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
13079 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
|
|
|
13080 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
|
|
|
13081 )
|
|
|
13082 };
|
|
|
13083
|
|
|
13084 },
|
|
|
13085
|
|
|
13086 _generatePosition: function(event) {
|
|
|
13087
|
|
|
13088 var top, left,
|
|
|
13089 o = this.options,
|
|
|
13090 pageX = event.pageX,
|
|
|
13091 pageY = event.pageY,
|
|
|
13092 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
|
|
|
13093
|
|
|
13094 // This is another very weird special case that only happens for relative elements:
|
|
|
13095 // 1. If the css position is relative
|
|
|
13096 // 2. and the scroll parent is the document or similar to the offset parent
|
|
|
13097 // we have to refresh the relative offset during the scroll so there are no jumps
|
|
|
13098 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
|
|
|
13099 this.offset.relative = this._getRelativeOffset();
|
|
|
13100 }
|
|
|
13101
|
|
|
13102 /*
|
|
|
13103 * - Position constraining -
|
|
|
13104 * Constrain the position to a mix of grid, containment.
|
|
|
13105 */
|
|
|
13106
|
|
|
13107 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
|
|
|
13108
|
|
|
13109 if(this.containment) {
|
|
|
13110 if(event.pageX - this.offset.click.left < this.containment[0]) {
|
|
|
13111 pageX = this.containment[0] + this.offset.click.left;
|
|
|
13112 }
|
|
|
13113 if(event.pageY - this.offset.click.top < this.containment[1]) {
|
|
|
13114 pageY = this.containment[1] + this.offset.click.top;
|
|
|
13115 }
|
|
|
13116 if(event.pageX - this.offset.click.left > this.containment[2]) {
|
|
|
13117 pageX = this.containment[2] + this.offset.click.left;
|
|
|
13118 }
|
|
|
13119 if(event.pageY - this.offset.click.top > this.containment[3]) {
|
|
|
13120 pageY = this.containment[3] + this.offset.click.top;
|
|
|
13121 }
|
|
|
13122 }
|
|
|
13123
|
|
|
13124 if(o.grid) {
|
|
|
13125 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
|
|
|
13126 pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
|
|
|
13127
|
|
|
13128 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
|
|
|
13129 pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
|
|
|
13130 }
|
|
|
13131
|
|
|
13132 }
|
|
|
13133
|
|
|
13134 return {
|
|
|
13135 top: (
|
|
|
13136 pageY - // The absolute mouse position
|
|
|
13137 this.offset.click.top - // Click offset (relative to the element)
|
|
|
13138 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
13139 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
|
|
|
13140 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
|
|
|
13141 ),
|
|
|
13142 left: (
|
|
|
13143 pageX - // The absolute mouse position
|
|
|
13144 this.offset.click.left - // Click offset (relative to the element)
|
|
|
13145 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
|
|
|
13146 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
|
|
|
13147 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
|
|
|
13148 )
|
|
|
13149 };
|
|
|
13150
|
|
|
13151 },
|
|
|
13152
|
|
|
13153 _rearrange: function(event, i, a, hardRefresh) {
|
|
|
13154
|
|
|
13155 a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
|
|
|
13156
|
|
|
13157 //Various things done here to improve the performance:
|
|
|
13158 // 1. we create a setTimeout, that calls refreshPositions
|
|
|
13159 // 2. on the instance, we have a counter variable, that get's higher after every append
|
|
|
13160 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
|
|
|
13161 // 4. this lets only the last addition to the timeout stack through
|
|
|
13162 this.counter = this.counter ? ++this.counter : 1;
|
|
|
13163 var counter = this.counter;
|
|
|
13164
|
|
|
13165 this._delay(function() {
|
|
|
13166 if(counter === this.counter) {
|
|
|
13167 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
|
|
|
13168 }
|
|
|
13169 });
|
|
|
13170
|
|
|
13171 },
|
|
|
13172
|
|
|
13173 _clear: function(event, noPropagation) {
|
|
|
13174
|
|
|
13175 this.reverting = false;
|
|
|
13176 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
|
|
|
13177 // everything else normalized again
|
|
|
13178 var i,
|
|
|
13179 delayedTriggers = [];
|
|
|
13180
|
|
|
13181 // We first have to update the dom position of the actual currentItem
|
|
|
13182 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
|
|
|
13183 if(!this._noFinalSort && this.currentItem.parent().length) {
|
|
|
13184 this.placeholder.before(this.currentItem);
|
|
|
13185 }
|
|
|
13186 this._noFinalSort = null;
|
|
|
13187
|
|
|
13188 if(this.helper[0] === this.currentItem[0]) {
|
|
|
13189 for(i in this._storedCSS) {
|
|
|
13190 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
|
|
|
13191 this._storedCSS[i] = "";
|
|
|
13192 }
|
|
|
13193 }
|
|
|
13194 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
|
|
|
13195 } else {
|
|
|
13196 this.currentItem.show();
|
|
|
13197 }
|
|
|
13198
|
|
|
13199 if(this.fromOutside && !noPropagation) {
|
|
|
13200 delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
|
|
|
13201 }
|
|
|
13202 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
|
|
|
13203 delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
|
|
|
13204 }
|
|
|
13205
|
|
|
13206 // Check if the items Container has Changed and trigger appropriate
|
|
|
13207 // events.
|
|
|
13208 if (this !== this.currentContainer) {
|
|
|
13209 if(!noPropagation) {
|
|
|
13210 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
|
|
|
13211 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
|
|
|
13212 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
|
|
|
13213 }
|
|
|
13214 }
|
|
|
13215
|
|
|
13216
|
|
|
13217 //Post events to containers
|
|
|
13218 function delayEvent( type, instance, container ) {
|
|
|
13219 return function( event ) {
|
|
|
13220 container._trigger( type, event, instance._uiHash( instance ) );
|
|
|
13221 };
|
|
|
13222 }
|
|
|
13223 for (i = this.containers.length - 1; i >= 0; i--){
|
|
|
13224 if (!noPropagation) {
|
|
|
13225 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
|
|
|
13226 }
|
|
|
13227 if(this.containers[i].containerCache.over) {
|
|
|
13228 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
|
|
|
13229 this.containers[i].containerCache.over = 0;
|
|
|
13230 }
|
|
|
13231 }
|
|
|
13232
|
|
|
13233 //Do what was originally in plugins
|
|
|
13234 if ( this.storedCursor ) {
|
|
|
13235 this.document.find( "body" ).css( "cursor", this.storedCursor );
|
|
|
13236 this.storedStylesheet.remove();
|
|
|
13237 }
|
|
|
13238 if(this._storedOpacity) {
|
|
|
13239 this.helper.css("opacity", this._storedOpacity);
|
|
|
13240 }
|
|
|
13241 if(this._storedZIndex) {
|
|
|
13242 this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
|
|
|
13243 }
|
|
|
13244
|
|
|
13245 this.dragging = false;
|
|
|
13246 if(this.cancelHelperRemoval) {
|
|
|
13247 if(!noPropagation) {
|
|
|
13248 this._trigger("beforeStop", event, this._uiHash());
|
|
|
13249 for (i=0; i < delayedTriggers.length; i++) {
|
|
|
13250 delayedTriggers[i].call(this, event);
|
|
|
13251 } //Trigger all delayed events
|
|
|
13252 this._trigger("stop", event, this._uiHash());
|
|
|
13253 }
|
|
|
13254
|
|
|
13255 this.fromOutside = false;
|
|
|
13256 return false;
|
|
|
13257 }
|
|
|
13258
|
|
|
13259 if(!noPropagation) {
|
|
|
13260 this._trigger("beforeStop", event, this._uiHash());
|
|
|
13261 }
|
|
|
13262
|
|
|
13263 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
|
|
|
13264 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
|
|
|
13265
|
|
|
13266 if(this.helper[0] !== this.currentItem[0]) {
|
|
|
13267 this.helper.remove();
|
|
|
13268 }
|
|
|
13269 this.helper = null;
|
|
|
13270
|
|
|
13271 if(!noPropagation) {
|
|
|
13272 for (i=0; i < delayedTriggers.length; i++) {
|
|
|
13273 delayedTriggers[i].call(this, event);
|
|
|
13274 } //Trigger all delayed events
|
|
|
13275 this._trigger("stop", event, this._uiHash());
|
|
|
13276 }
|
|
|
13277
|
|
|
13278 this.fromOutside = false;
|
|
|
13279 return true;
|
|
|
13280
|
|
|
13281 },
|
|
|
13282
|
|
|
13283 _trigger: function() {
|
|
|
13284 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
|
|
|
13285 this.cancel();
|
|
|
13286 }
|
|
|
13287 },
|
|
|
13288
|
|
|
13289 _uiHash: function(_inst) {
|
|
|
13290 var inst = _inst || this;
|
|
|
13291 return {
|
|
|
13292 helper: inst.helper,
|
|
|
13293 placeholder: inst.placeholder || $([]),
|
|
|
13294 position: inst.position,
|
|
|
13295 originalPosition: inst.originalPosition,
|
|
|
13296 offset: inst.positionAbs,
|
|
|
13297 item: inst.currentItem,
|
|
|
13298 sender: _inst ? _inst.element : null
|
|
|
13299 };
|
|
|
13300 }
|
|
|
13301
|
|
|
13302 });
|
|
|
13303
|
|
|
13304 })(jQuery);
|
|
|
13305 (function( $ ) {
|
|
|
13306
|
|
|
13307 function modifier( fn ) {
|
|
|
13308 return function() {
|
|
|
13309 var previous = this.element.val();
|
|
|
13310 fn.apply( this, arguments );
|
|
|
13311 this._refresh();
|
|
|
13312 if ( previous !== this.element.val() ) {
|
|
|
13313 this._trigger( "change" );
|
|
|
13314 }
|
|
|
13315 };
|
|
|
13316 }
|
|
|
13317
|
|
|
13318 $.widget( "ui.spinner", {
|
|
|
13319 version: "1.10.4",
|
|
|
13320 defaultElement: "<input>",
|
|
|
13321 widgetEventPrefix: "spin",
|
|
|
13322 options: {
|
|
|
13323 culture: null,
|
|
|
13324 icons: {
|
|
|
13325 down: "ui-icon-triangle-1-s",
|
|
|
13326 up: "ui-icon-triangle-1-n"
|
|
|
13327 },
|
|
|
13328 incremental: true,
|
|
|
13329 max: null,
|
|
|
13330 min: null,
|
|
|
13331 numberFormat: null,
|
|
|
13332 page: 10,
|
|
|
13333 step: 1,
|
|
|
13334
|
|
|
13335 change: null,
|
|
|
13336 spin: null,
|
|
|
13337 start: null,
|
|
|
13338 stop: null
|
|
|
13339 },
|
|
|
13340
|
|
|
13341 _create: function() {
|
|
|
13342 // handle string values that need to be parsed
|
|
|
13343 this._setOption( "max", this.options.max );
|
|
|
13344 this._setOption( "min", this.options.min );
|
|
|
13345 this._setOption( "step", this.options.step );
|
|
|
13346
|
|
|
13347 // Only format if there is a value, prevents the field from being marked
|
|
|
13348 // as invalid in Firefox, see #9573.
|
|
|
13349 if ( this.value() !== "" ) {
|
|
|
13350 // Format the value, but don't constrain.
|
|
|
13351 this._value( this.element.val(), true );
|
|
|
13352 }
|
|
|
13353
|
|
|
13354 this._draw();
|
|
|
13355 this._on( this._events );
|
|
|
13356 this._refresh();
|
|
|
13357
|
|
|
13358 // turning off autocomplete prevents the browser from remembering the
|
|
|
13359 // value when navigating through history, so we re-enable autocomplete
|
|
|
13360 // if the page is unloaded before the widget is destroyed. #7790
|
|
|
13361 this._on( this.window, {
|
|
|
13362 beforeunload: function() {
|
|
|
13363 this.element.removeAttr( "autocomplete" );
|
|
|
13364 }
|
|
|
13365 });
|
|
|
13366 },
|
|
|
13367
|
|
|
13368 _getCreateOptions: function() {
|
|
|
13369 var options = {},
|
|
|
13370 element = this.element;
|
|
|
13371
|
|
|
13372 $.each( [ "min", "max", "step" ], function( i, option ) {
|
|
|
13373 var value = element.attr( option );
|
|
|
13374 if ( value !== undefined && value.length ) {
|
|
|
13375 options[ option ] = value;
|
|
|
13376 }
|
|
|
13377 });
|
|
|
13378
|
|
|
13379 return options;
|
|
|
13380 },
|
|
|
13381
|
|
|
13382 _events: {
|
|
|
13383 keydown: function( event ) {
|
|
|
13384 if ( this._start( event ) && this._keydown( event ) ) {
|
|
|
13385 event.preventDefault();
|
|
|
13386 }
|
|
|
13387 },
|
|
|
13388 keyup: "_stop",
|
|
|
13389 focus: function() {
|
|
|
13390 this.previous = this.element.val();
|
|
|
13391 },
|
|
|
13392 blur: function( event ) {
|
|
|
13393 if ( this.cancelBlur ) {
|
|
|
13394 delete this.cancelBlur;
|
|
|
13395 return;
|
|
|
13396 }
|
|
|
13397
|
|
|
13398 this._stop();
|
|
|
13399 this._refresh();
|
|
|
13400 if ( this.previous !== this.element.val() ) {
|
|
|
13401 this._trigger( "change", event );
|
|
|
13402 }
|
|
|
13403 },
|
|
|
13404 mousewheel: function( event, delta ) {
|
|
|
13405 if ( !delta ) {
|
|
|
13406 return;
|
|
|
13407 }
|
|
|
13408 if ( !this.spinning && !this._start( event ) ) {
|
|
|
13409 return false;
|
|
|
13410 }
|
|
|
13411
|
|
|
13412 this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
|
|
|
13413 clearTimeout( this.mousewheelTimer );
|
|
|
13414 this.mousewheelTimer = this._delay(function() {
|
|
|
13415 if ( this.spinning ) {
|
|
|
13416 this._stop( event );
|
|
|
13417 }
|
|
|
13418 }, 100 );
|
|
|
13419 event.preventDefault();
|
|
|
13420 },
|
|
|
13421 "mousedown .ui-spinner-button": function( event ) {
|
|
|
13422 var previous;
|
|
|
13423
|
|
|
13424 // We never want the buttons to have focus; whenever the user is
|
|
|
13425 // interacting with the spinner, the focus should be on the input.
|
|
|
13426 // If the input is focused then this.previous is properly set from
|
|
|
13427 // when the input first received focus. If the input is not focused
|
|
|
13428 // then we need to set this.previous based on the value before spinning.
|
|
|
13429 previous = this.element[0] === this.document[0].activeElement ?
|
|
|
13430 this.previous : this.element.val();
|
|
|
13431 function checkFocus() {
|
|
|
13432 var isActive = this.element[0] === this.document[0].activeElement;
|
|
|
13433 if ( !isActive ) {
|
|
|
13434 this.element.focus();
|
|
|
13435 this.previous = previous;
|
|
|
13436 // support: IE
|
|
|
13437 // IE sets focus asynchronously, so we need to check if focus
|
|
|
13438 // moved off of the input because the user clicked on the button.
|
|
|
13439 this._delay(function() {
|
|
|
13440 this.previous = previous;
|
|
|
13441 });
|
|
|
13442 }
|
|
|
13443 }
|
|
|
13444
|
|
|
13445 // ensure focus is on (or stays on) the text field
|
|
|
13446 event.preventDefault();
|
|
|
13447 checkFocus.call( this );
|
|
|
13448
|
|
|
13449 // support: IE
|
|
|
13450 // IE doesn't prevent moving focus even with event.preventDefault()
|
|
|
13451 // so we set a flag to know when we should ignore the blur event
|
|
|
13452 // and check (again) if focus moved off of the input.
|
|
|
13453 this.cancelBlur = true;
|
|
|
13454 this._delay(function() {
|
|
|
13455 delete this.cancelBlur;
|
|
|
13456 checkFocus.call( this );
|
|
|
13457 });
|
|
|
13458
|
|
|
13459 if ( this._start( event ) === false ) {
|
|
|
13460 return;
|
|
|
13461 }
|
|
|
13462
|
|
|
13463 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
|
|
|
13464 },
|
|
|
13465 "mouseup .ui-spinner-button": "_stop",
|
|
|
13466 "mouseenter .ui-spinner-button": function( event ) {
|
|
|
13467 // button will add ui-state-active if mouse was down while mouseleave and kept down
|
|
|
13468 if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
|
|
|
13469 return;
|
|
|
13470 }
|
|
|
13471
|
|
|
13472 if ( this._start( event ) === false ) {
|
|
|
13473 return false;
|
|
|
13474 }
|
|
|
13475 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
|
|
|
13476 },
|
|
|
13477 // TODO: do we really want to consider this a stop?
|
|
|
13478 // shouldn't we just stop the repeater and wait until mouseup before
|
|
|
13479 // we trigger the stop event?
|
|
|
13480 "mouseleave .ui-spinner-button": "_stop"
|
|
|
13481 },
|
|
|
13482
|
|
|
13483 _draw: function() {
|
|
|
13484 var uiSpinner = this.uiSpinner = this.element
|
|
|
13485 .addClass( "ui-spinner-input" )
|
|
|
13486 .attr( "autocomplete", "off" )
|
|
|
13487 .wrap( this._uiSpinnerHtml() )
|
|
|
13488 .parent()
|
|
|
13489 // add buttons
|
|
|
13490 .append( this._buttonHtml() );
|
|
|
13491
|
|
|
13492 this.element.attr( "role", "spinbutton" );
|
|
|
13493
|
|
|
13494 // button bindings
|
|
|
13495 this.buttons = uiSpinner.find( ".ui-spinner-button" )
|
|
|
13496 .attr( "tabIndex", -1 )
|
|
|
13497 .button()
|
|
|
13498 .removeClass( "ui-corner-all" );
|
|
|
13499
|
|
|
13500 // IE 6 doesn't understand height: 50% for the buttons
|
|
|
13501 // unless the wrapper has an explicit height
|
|
|
13502 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
|
|
|
13503 uiSpinner.height() > 0 ) {
|
|
|
13504 uiSpinner.height( uiSpinner.height() );
|
|
|
13505 }
|
|
|
13506
|
|
|
13507 // disable spinner if element was already disabled
|
|
|
13508 if ( this.options.disabled ) {
|
|
|
13509 this.disable();
|
|
|
13510 }
|
|
|
13511 },
|
|
|
13512
|
|
|
13513 _keydown: function( event ) {
|
|
|
13514 var options = this.options,
|
|
|
13515 keyCode = $.ui.keyCode;
|
|
|
13516
|
|
|
13517 switch ( event.keyCode ) {
|
|
|
13518 case keyCode.UP:
|
|
|
13519 this._repeat( null, 1, event );
|
|
|
13520 return true;
|
|
|
13521 case keyCode.DOWN:
|
|
|
13522 this._repeat( null, -1, event );
|
|
|
13523 return true;
|
|
|
13524 case keyCode.PAGE_UP:
|
|
|
13525 this._repeat( null, options.page, event );
|
|
|
13526 return true;
|
|
|
13527 case keyCode.PAGE_DOWN:
|
|
|
13528 this._repeat( null, -options.page, event );
|
|
|
13529 return true;
|
|
|
13530 }
|
|
|
13531
|
|
|
13532 return false;
|
|
|
13533 },
|
|
|
13534
|
|
|
13535 _uiSpinnerHtml: function() {
|
|
|
13536 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
|
|
|
13537 },
|
|
|
13538
|
|
|
13539 _buttonHtml: function() {
|
|
|
13540 return "" +
|
|
|
13541 "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
|
|
|
13542 "<span class='ui-icon " + this.options.icons.up + "'>▲</span>" +
|
|
|
13543 "</a>" +
|
|
|
13544 "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
|
|
|
13545 "<span class='ui-icon " + this.options.icons.down + "'>▼</span>" +
|
|
|
13546 "</a>";
|
|
|
13547 },
|
|
|
13548
|
|
|
13549 _start: function( event ) {
|
|
|
13550 if ( !this.spinning && this._trigger( "start", event ) === false ) {
|
|
|
13551 return false;
|
|
|
13552 }
|
|
|
13553
|
|
|
13554 if ( !this.counter ) {
|
|
|
13555 this.counter = 1;
|
|
|
13556 }
|
|
|
13557 this.spinning = true;
|
|
|
13558 return true;
|
|
|
13559 },
|
|
|
13560
|
|
|
13561 _repeat: function( i, steps, event ) {
|
|
|
13562 i = i || 500;
|
|
|
13563
|
|
|
13564 clearTimeout( this.timer );
|
|
|
13565 this.timer = this._delay(function() {
|
|
|
13566 this._repeat( 40, steps, event );
|
|
|
13567 }, i );
|
|
|
13568
|
|
|
13569 this._spin( steps * this.options.step, event );
|
|
|
13570 },
|
|
|
13571
|
|
|
13572 _spin: function( step, event ) {
|
|
|
13573 var value = this.value() || 0;
|
|
|
13574
|
|
|
13575 if ( !this.counter ) {
|
|
|
13576 this.counter = 1;
|
|
|
13577 }
|
|
|
13578
|
|
|
13579 value = this._adjustValue( value + step * this._increment( this.counter ) );
|
|
|
13580
|
|
|
13581 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
|
|
|
13582 this._value( value );
|
|
|
13583 this.counter++;
|
|
|
13584 }
|
|
|
13585 },
|
|
|
13586
|
|
|
13587 _increment: function( i ) {
|
|
|
13588 var incremental = this.options.incremental;
|
|
|
13589
|
|
|
13590 if ( incremental ) {
|
|
|
13591 return $.isFunction( incremental ) ?
|
|
|
13592 incremental( i ) :
|
|
|
13593 Math.floor( i*i*i/50000 - i*i/500 + 17*i/200 + 1 );
|
|
|
13594 }
|
|
|
13595
|
|
|
13596 return 1;
|
|
|
13597 },
|
|
|
13598
|
|
|
13599 _precision: function() {
|
|
|
13600 var precision = this._precisionOf( this.options.step );
|
|
|
13601 if ( this.options.min !== null ) {
|
|
|
13602 precision = Math.max( precision, this._precisionOf( this.options.min ) );
|
|
|
13603 }
|
|
|
13604 return precision;
|
|
|
13605 },
|
|
|
13606
|
|
|
13607 _precisionOf: function( num ) {
|
|
|
13608 var str = num.toString(),
|
|
|
13609 decimal = str.indexOf( "." );
|
|
|
13610 return decimal === -1 ? 0 : str.length - decimal - 1;
|
|
|
13611 },
|
|
|
13612
|
|
|
13613 _adjustValue: function( value ) {
|
|
|
13614 var base, aboveMin,
|
|
|
13615 options = this.options;
|
|
|
13616
|
|
|
13617 // make sure we're at a valid step
|
|
|
13618 // - find out where we are relative to the base (min or 0)
|
|
|
13619 base = options.min !== null ? options.min : 0;
|
|
|
13620 aboveMin = value - base;
|
|
|
13621 // - round to the nearest step
|
|
|
13622 aboveMin = Math.round(aboveMin / options.step) * options.step;
|
|
|
13623 // - rounding is based on 0, so adjust back to our base
|
|
|
13624 value = base + aboveMin;
|
|
|
13625
|
|
|
13626 // fix precision from bad JS floating point math
|
|
|
13627 value = parseFloat( value.toFixed( this._precision() ) );
|
|
|
13628
|
|
|
13629 // clamp the value
|
|
|
13630 if ( options.max !== null && value > options.max) {
|
|
|
13631 return options.max;
|
|
|
13632 }
|
|
|
13633 if ( options.min !== null && value < options.min ) {
|
|
|
13634 return options.min;
|
|
|
13635 }
|
|
|
13636
|
|
|
13637 return value;
|
|
|
13638 },
|
|
|
13639
|
|
|
13640 _stop: function( event ) {
|
|
|
13641 if ( !this.spinning ) {
|
|
|
13642 return;
|
|
|
13643 }
|
|
|
13644
|
|
|
13645 clearTimeout( this.timer );
|
|
|
13646 clearTimeout( this.mousewheelTimer );
|
|
|
13647 this.counter = 0;
|
|
|
13648 this.spinning = false;
|
|
|
13649 this._trigger( "stop", event );
|
|
|
13650 },
|
|
|
13651
|
|
|
13652 _setOption: function( key, value ) {
|
|
|
13653 if ( key === "culture" || key === "numberFormat" ) {
|
|
|
13654 var prevValue = this._parse( this.element.val() );
|
|
|
13655 this.options[ key ] = value;
|
|
|
13656 this.element.val( this._format( prevValue ) );
|
|
|
13657 return;
|
|
|
13658 }
|
|
|
13659
|
|
|
13660 if ( key === "max" || key === "min" || key === "step" ) {
|
|
|
13661 if ( typeof value === "string" ) {
|
|
|
13662 value = this._parse( value );
|
|
|
13663 }
|
|
|
13664 }
|
|
|
13665 if ( key === "icons" ) {
|
|
|
13666 this.buttons.first().find( ".ui-icon" )
|
|
|
13667 .removeClass( this.options.icons.up )
|
|
|
13668 .addClass( value.up );
|
|
|
13669 this.buttons.last().find( ".ui-icon" )
|
|
|
13670 .removeClass( this.options.icons.down )
|
|
|
13671 .addClass( value.down );
|
|
|
13672 }
|
|
|
13673
|
|
|
13674 this._super( key, value );
|
|
|
13675
|
|
|
13676 if ( key === "disabled" ) {
|
|
|
13677 if ( value ) {
|
|
|
13678 this.element.prop( "disabled", true );
|
|
|
13679 this.buttons.button( "disable" );
|
|
|
13680 } else {
|
|
|
13681 this.element.prop( "disabled", false );
|
|
|
13682 this.buttons.button( "enable" );
|
|
|
13683 }
|
|
|
13684 }
|
|
|
13685 },
|
|
|
13686
|
|
|
13687 _setOptions: modifier(function( options ) {
|
|
|
13688 this._super( options );
|
|
|
13689 this._value( this.element.val() );
|
|
|
13690 }),
|
|
|
13691
|
|
|
13692 _parse: function( val ) {
|
|
|
13693 if ( typeof val === "string" && val !== "" ) {
|
|
|
13694 val = window.Globalize && this.options.numberFormat ?
|
|
|
13695 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
|
|
|
13696 }
|
|
|
13697 return val === "" || isNaN( val ) ? null : val;
|
|
|
13698 },
|
|
|
13699
|
|
|
13700 _format: function( value ) {
|
|
|
13701 if ( value === "" ) {
|
|
|
13702 return "";
|
|
|
13703 }
|
|
|
13704 return window.Globalize && this.options.numberFormat ?
|
|
|
13705 Globalize.format( value, this.options.numberFormat, this.options.culture ) :
|
|
|
13706 value;
|
|
|
13707 },
|
|
|
13708
|
|
|
13709 _refresh: function() {
|
|
|
13710 this.element.attr({
|
|
|
13711 "aria-valuemin": this.options.min,
|
|
|
13712 "aria-valuemax": this.options.max,
|
|
|
13713 // TODO: what should we do with values that can't be parsed?
|
|
|
13714 "aria-valuenow": this._parse( this.element.val() )
|
|
|
13715 });
|
|
|
13716 },
|
|
|
13717
|
|
|
13718 // update the value without triggering change
|
|
|
13719 _value: function( value, allowAny ) {
|
|
|
13720 var parsed;
|
|
|
13721 if ( value !== "" ) {
|
|
|
13722 parsed = this._parse( value );
|
|
|
13723 if ( parsed !== null ) {
|
|
|
13724 if ( !allowAny ) {
|
|
|
13725 parsed = this._adjustValue( parsed );
|
|
|
13726 }
|
|
|
13727 value = this._format( parsed );
|
|
|
13728 }
|
|
|
13729 }
|
|
|
13730 this.element.val( value );
|
|
|
13731 this._refresh();
|
|
|
13732 },
|
|
|
13733
|
|
|
13734 _destroy: function() {
|
|
|
13735 this.element
|
|
|
13736 .removeClass( "ui-spinner-input" )
|
|
|
13737 .prop( "disabled", false )
|
|
|
13738 .removeAttr( "autocomplete" )
|
|
|
13739 .removeAttr( "role" )
|
|
|
13740 .removeAttr( "aria-valuemin" )
|
|
|
13741 .removeAttr( "aria-valuemax" )
|
|
|
13742 .removeAttr( "aria-valuenow" );
|
|
|
13743 this.uiSpinner.replaceWith( this.element );
|
|
|
13744 },
|
|
|
13745
|
|
|
13746 stepUp: modifier(function( steps ) {
|
|
|
13747 this._stepUp( steps );
|
|
|
13748 }),
|
|
|
13749 _stepUp: function( steps ) {
|
|
|
13750 if ( this._start() ) {
|
|
|
13751 this._spin( (steps || 1) * this.options.step );
|
|
|
13752 this._stop();
|
|
|
13753 }
|
|
|
13754 },
|
|
|
13755
|
|
|
13756 stepDown: modifier(function( steps ) {
|
|
|
13757 this._stepDown( steps );
|
|
|
13758 }),
|
|
|
13759 _stepDown: function( steps ) {
|
|
|
13760 if ( this._start() ) {
|
|
|
13761 this._spin( (steps || 1) * -this.options.step );
|
|
|
13762 this._stop();
|
|
|
13763 }
|
|
|
13764 },
|
|
|
13765
|
|
|
13766 pageUp: modifier(function( pages ) {
|
|
|
13767 this._stepUp( (pages || 1) * this.options.page );
|
|
|
13768 }),
|
|
|
13769
|
|
|
13770 pageDown: modifier(function( pages ) {
|
|
|
13771 this._stepDown( (pages || 1) * this.options.page );
|
|
|
13772 }),
|
|
|
13773
|
|
|
13774 value: function( newVal ) {
|
|
|
13775 if ( !arguments.length ) {
|
|
|
13776 return this._parse( this.element.val() );
|
|
|
13777 }
|
|
|
13778 modifier( this._value ).call( this, newVal );
|
|
|
13779 },
|
|
|
13780
|
|
|
13781 widget: function() {
|
|
|
13782 return this.uiSpinner;
|
|
|
13783 }
|
|
|
13784 });
|
|
|
13785
|
|
|
13786 }( jQuery ) );
|
|
|
13787 (function( $, undefined ) {
|
|
|
13788
|
|
|
13789 var tabId = 0,
|
|
|
13790 rhash = /#.*$/;
|
|
|
13791
|
|
|
13792 function getNextTabId() {
|
|
|
13793 return ++tabId;
|
|
|
13794 }
|
|
|
13795
|
|
|
13796 function isLocal( anchor ) {
|
|
|
13797 // support: IE7
|
|
|
13798 // IE7 doesn't normalize the href property when set via script (#9317)
|
|
|
13799 anchor = anchor.cloneNode( false );
|
|
|
13800
|
|
|
13801 return anchor.hash.length > 1 &&
|
|
|
13802 decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
|
|
|
13803 decodeURIComponent( location.href.replace( rhash, "" ) );
|
|
|
13804 }
|
|
|
13805
|
|
|
13806 $.widget( "ui.tabs", {
|
|
|
13807 version: "1.10.4",
|
|
|
13808 delay: 300,
|
|
|
13809 options: {
|
|
|
13810 active: null,
|
|
|
13811 collapsible: false,
|
|
|
13812 event: "click",
|
|
|
13813 heightStyle: "content",
|
|
|
13814 hide: null,
|
|
|
13815 show: null,
|
|
|
13816
|
|
|
13817 // callbacks
|
|
|
13818 activate: null,
|
|
|
13819 beforeActivate: null,
|
|
|
13820 beforeLoad: null,
|
|
|
13821 load: null
|
|
|
13822 },
|
|
|
13823
|
|
|
13824 _create: function() {
|
|
|
13825 var that = this,
|
|
|
13826 options = this.options;
|
|
|
13827
|
|
|
13828 this.running = false;
|
|
|
13829
|
|
|
13830 this.element
|
|
|
13831 .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
|
|
|
13832 .toggleClass( "ui-tabs-collapsible", options.collapsible )
|
|
|
13833 // Prevent users from focusing disabled tabs via click
|
|
|
13834 .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
|
|
|
13835 if ( $( this ).is( ".ui-state-disabled" ) ) {
|
|
|
13836 event.preventDefault();
|
|
|
13837 }
|
|
|
13838 })
|
|
|
13839 // support: IE <9
|
|
|
13840 // Preventing the default action in mousedown doesn't prevent IE
|
|
|
13841 // from focusing the element, so if the anchor gets focused, blur.
|
|
|
13842 // We don't have to worry about focusing the previously focused
|
|
|
13843 // element since clicking on a non-focusable element should focus
|
|
|
13844 // the body anyway.
|
|
|
13845 .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
|
|
|
13846 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
|
|
|
13847 this.blur();
|
|
|
13848 }
|
|
|
13849 });
|
|
|
13850
|
|
|
13851 this._processTabs();
|
|
|
13852 options.active = this._initialActive();
|
|
|
13853
|
|
|
13854 // Take disabling tabs via class attribute from HTML
|
|
|
13855 // into account and update option properly.
|
|
|
13856 if ( $.isArray( options.disabled ) ) {
|
|
|
13857 options.disabled = $.unique( options.disabled.concat(
|
|
|
13858 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
|
|
|
13859 return that.tabs.index( li );
|
|
|
13860 })
|
|
|
13861 ) ).sort();
|
|
|
13862 }
|
|
|
13863
|
|
|
13864 // check for length avoids error when initializing empty list
|
|
|
13865 if ( this.options.active !== false && this.anchors.length ) {
|
|
|
13866 this.active = this._findActive( options.active );
|
|
|
13867 } else {
|
|
|
13868 this.active = $();
|
|
|
13869 }
|
|
|
13870
|
|
|
13871 this._refresh();
|
|
|
13872
|
|
|
13873 if ( this.active.length ) {
|
|
|
13874 this.load( options.active );
|
|
|
13875 }
|
|
|
13876 },
|
|
|
13877
|
|
|
13878 _initialActive: function() {
|
|
|
13879 var active = this.options.active,
|
|
|
13880 collapsible = this.options.collapsible,
|
|
|
13881 locationHash = location.hash.substring( 1 );
|
|
|
13882
|
|
|
13883 if ( active === null ) {
|
|
|
13884 // check the fragment identifier in the URL
|
|
|
13885 if ( locationHash ) {
|
|
|
13886 this.tabs.each(function( i, tab ) {
|
|
|
13887 if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
|
|
|
13888 active = i;
|
|
|
13889 return false;
|
|
|
13890 }
|
|
|
13891 });
|
|
|
13892 }
|
|
|
13893
|
|
|
13894 // check for a tab marked active via a class
|
|
|
13895 if ( active === null ) {
|
|
|
13896 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
|
|
|
13897 }
|
|
|
13898
|
|
|
13899 // no active tab, set to false
|
|
|
13900 if ( active === null || active === -1 ) {
|
|
|
13901 active = this.tabs.length ? 0 : false;
|
|
|
13902 }
|
|
|
13903 }
|
|
|
13904
|
|
|
13905 // handle numbers: negative, out of range
|
|
|
13906 if ( active !== false ) {
|
|
|
13907 active = this.tabs.index( this.tabs.eq( active ) );
|
|
|
13908 if ( active === -1 ) {
|
|
|
13909 active = collapsible ? false : 0;
|
|
|
13910 }
|
|
|
13911 }
|
|
|
13912
|
|
|
13913 // don't allow collapsible: false and active: false
|
|
|
13914 if ( !collapsible && active === false && this.anchors.length ) {
|
|
|
13915 active = 0;
|
|
|
13916 }
|
|
|
13917
|
|
|
13918 return active;
|
|
|
13919 },
|
|
|
13920
|
|
|
13921 _getCreateEventData: function() {
|
|
|
13922 return {
|
|
|
13923 tab: this.active,
|
|
|
13924 panel: !this.active.length ? $() : this._getPanelForTab( this.active )
|
|
|
13925 };
|
|
|
13926 },
|
|
|
13927
|
|
|
13928 _tabKeydown: function( event ) {
|
|
|
13929 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
|
|
|
13930 selectedIndex = this.tabs.index( focusedTab ),
|
|
|
13931 goingForward = true;
|
|
|
13932
|
|
|
13933 if ( this._handlePageNav( event ) ) {
|
|
|
13934 return;
|
|
|
13935 }
|
|
|
13936
|
|
|
13937 switch ( event.keyCode ) {
|
|
|
13938 case $.ui.keyCode.RIGHT:
|
|
|
13939 case $.ui.keyCode.DOWN:
|
|
|
13940 selectedIndex++;
|
|
|
13941 break;
|
|
|
13942 case $.ui.keyCode.UP:
|
|
|
13943 case $.ui.keyCode.LEFT:
|
|
|
13944 goingForward = false;
|
|
|
13945 selectedIndex--;
|
|
|
13946 break;
|
|
|
13947 case $.ui.keyCode.END:
|
|
|
13948 selectedIndex = this.anchors.length - 1;
|
|
|
13949 break;
|
|
|
13950 case $.ui.keyCode.HOME:
|
|
|
13951 selectedIndex = 0;
|
|
|
13952 break;
|
|
|
13953 case $.ui.keyCode.SPACE:
|
|
|
13954 // Activate only, no collapsing
|
|
|
13955 event.preventDefault();
|
|
|
13956 clearTimeout( this.activating );
|
|
|
13957 this._activate( selectedIndex );
|
|
|
13958 return;
|
|
|
13959 case $.ui.keyCode.ENTER:
|
|
|
13960 // Toggle (cancel delayed activation, allow collapsing)
|
|
|
13961 event.preventDefault();
|
|
|
13962 clearTimeout( this.activating );
|
|
|
13963 // Determine if we should collapse or activate
|
|
|
13964 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
|
|
|
13965 return;
|
|
|
13966 default:
|
|
|
13967 return;
|
|
|
13968 }
|
|
|
13969
|
|
|
13970 // Focus the appropriate tab, based on which key was pressed
|
|
|
13971 event.preventDefault();
|
|
|
13972 clearTimeout( this.activating );
|
|
|
13973 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
|
|
|
13974
|
|
|
13975 // Navigating with control key will prevent automatic activation
|
|
|
13976 if ( !event.ctrlKey ) {
|
|
|
13977 // Update aria-selected immediately so that AT think the tab is already selected.
|
|
|
13978 // Otherwise AT may confuse the user by stating that they need to activate the tab,
|
|
|
13979 // but the tab will already be activated by the time the announcement finishes.
|
|
|
13980 focusedTab.attr( "aria-selected", "false" );
|
|
|
13981 this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
|
|
|
13982
|
|
|
13983 this.activating = this._delay(function() {
|
|
|
13984 this.option( "active", selectedIndex );
|
|
|
13985 }, this.delay );
|
|
|
13986 }
|
|
|
13987 },
|
|
|
13988
|
|
|
13989 _panelKeydown: function( event ) {
|
|
|
13990 if ( this._handlePageNav( event ) ) {
|
|
|
13991 return;
|
|
|
13992 }
|
|
|
13993
|
|
|
13994 // Ctrl+up moves focus to the current tab
|
|
|
13995 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
|
|
|
13996 event.preventDefault();
|
|
|
13997 this.active.focus();
|
|
|
13998 }
|
|
|
13999 },
|
|
|
14000
|
|
|
14001 // Alt+page up/down moves focus to the previous/next tab (and activates)
|
|
|
14002 _handlePageNav: function( event ) {
|
|
|
14003 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
|
|
|
14004 this._activate( this._focusNextTab( this.options.active - 1, false ) );
|
|
|
14005 return true;
|
|
|
14006 }
|
|
|
14007 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
|
|
|
14008 this._activate( this._focusNextTab( this.options.active + 1, true ) );
|
|
|
14009 return true;
|
|
|
14010 }
|
|
|
14011 },
|
|
|
14012
|
|
|
14013 _findNextTab: function( index, goingForward ) {
|
|
|
14014 var lastTabIndex = this.tabs.length - 1;
|
|
|
14015
|
|
|
14016 function constrain() {
|
|
|
14017 if ( index > lastTabIndex ) {
|
|
|
14018 index = 0;
|
|
|
14019 }
|
|
|
14020 if ( index < 0 ) {
|
|
|
14021 index = lastTabIndex;
|
|
|
14022 }
|
|
|
14023 return index;
|
|
|
14024 }
|
|
|
14025
|
|
|
14026 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
|
|
|
14027 index = goingForward ? index + 1 : index - 1;
|
|
|
14028 }
|
|
|
14029
|
|
|
14030 return index;
|
|
|
14031 },
|
|
|
14032
|
|
|
14033 _focusNextTab: function( index, goingForward ) {
|
|
|
14034 index = this._findNextTab( index, goingForward );
|
|
|
14035 this.tabs.eq( index ).focus();
|
|
|
14036 return index;
|
|
|
14037 },
|
|
|
14038
|
|
|
14039 _setOption: function( key, value ) {
|
|
|
14040 if ( key === "active" ) {
|
|
|
14041 // _activate() will handle invalid values and update this.options
|
|
|
14042 this._activate( value );
|
|
|
14043 return;
|
|
|
14044 }
|
|
|
14045
|
|
|
14046 if ( key === "disabled" ) {
|
|
|
14047 // don't use the widget factory's disabled handling
|
|
|
14048 this._setupDisabled( value );
|
|
|
14049 return;
|
|
|
14050 }
|
|
|
14051
|
|
|
14052 this._super( key, value);
|
|
|
14053
|
|
|
14054 if ( key === "collapsible" ) {
|
|
|
14055 this.element.toggleClass( "ui-tabs-collapsible", value );
|
|
|
14056 // Setting collapsible: false while collapsed; open first panel
|
|
|
14057 if ( !value && this.options.active === false ) {
|
|
|
14058 this._activate( 0 );
|
|
|
14059 }
|
|
|
14060 }
|
|
|
14061
|
|
|
14062 if ( key === "event" ) {
|
|
|
14063 this._setupEvents( value );
|
|
|
14064 }
|
|
|
14065
|
|
|
14066 if ( key === "heightStyle" ) {
|
|
|
14067 this._setupHeightStyle( value );
|
|
|
14068 }
|
|
|
14069 },
|
|
|
14070
|
|
|
14071 _tabId: function( tab ) {
|
|
|
14072 return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
|
|
|
14073 },
|
|
|
14074
|
|
|
14075 _sanitizeSelector: function( hash ) {
|
|
|
14076 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
|
|
|
14077 },
|
|
|
14078
|
|
|
14079 refresh: function() {
|
|
|
14080 var options = this.options,
|
|
|
14081 lis = this.tablist.children( ":has(a[href])" );
|
|
|
14082
|
|
|
14083 // get disabled tabs from class attribute from HTML
|
|
|
14084 // this will get converted to a boolean if needed in _refresh()
|
|
|
14085 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
|
|
|
14086 return lis.index( tab );
|
|
|
14087 });
|
|
|
14088
|
|
|
14089 this._processTabs();
|
|
|
14090
|
|
|
14091 // was collapsed or no tabs
|
|
|
14092 if ( options.active === false || !this.anchors.length ) {
|
|
|
14093 options.active = false;
|
|
|
14094 this.active = $();
|
|
|
14095 // was active, but active tab is gone
|
|
|
14096 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
|
|
|
14097 // all remaining tabs are disabled
|
|
|
14098 if ( this.tabs.length === options.disabled.length ) {
|
|
|
14099 options.active = false;
|
|
|
14100 this.active = $();
|
|
|
14101 // activate previous tab
|
|
|
14102 } else {
|
|
|
14103 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
|
|
|
14104 }
|
|
|
14105 // was active, active tab still exists
|
|
|
14106 } else {
|
|
|
14107 // make sure active index is correct
|
|
|
14108 options.active = this.tabs.index( this.active );
|
|
|
14109 }
|
|
|
14110
|
|
|
14111 this._refresh();
|
|
|
14112 },
|
|
|
14113
|
|
|
14114 _refresh: function() {
|
|
|
14115 this._setupDisabled( this.options.disabled );
|
|
|
14116 this._setupEvents( this.options.event );
|
|
|
14117 this._setupHeightStyle( this.options.heightStyle );
|
|
|
14118
|
|
|
14119 this.tabs.not( this.active ).attr({
|
|
|
14120 "aria-selected": "false",
|
|
|
14121 tabIndex: -1
|
|
|
14122 });
|
|
|
14123 this.panels.not( this._getPanelForTab( this.active ) )
|
|
|
14124 .hide()
|
|
|
14125 .attr({
|
|
|
14126 "aria-expanded": "false",
|
|
|
14127 "aria-hidden": "true"
|
|
|
14128 });
|
|
|
14129
|
|
|
14130 // Make sure one tab is in the tab order
|
|
|
14131 if ( !this.active.length ) {
|
|
|
14132 this.tabs.eq( 0 ).attr( "tabIndex", 0 );
|
|
|
14133 } else {
|
|
|
14134 this.active
|
|
|
14135 .addClass( "ui-tabs-active ui-state-active" )
|
|
|
14136 .attr({
|
|
|
14137 "aria-selected": "true",
|
|
|
14138 tabIndex: 0
|
|
|
14139 });
|
|
|
14140 this._getPanelForTab( this.active )
|
|
|
14141 .show()
|
|
|
14142 .attr({
|
|
|
14143 "aria-expanded": "true",
|
|
|
14144 "aria-hidden": "false"
|
|
|
14145 });
|
|
|
14146 }
|
|
|
14147 },
|
|
|
14148
|
|
|
14149 _processTabs: function() {
|
|
|
14150 var that = this;
|
|
|
14151
|
|
|
14152 this.tablist = this._getList()
|
|
|
14153 .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
|
|
|
14154 .attr( "role", "tablist" );
|
|
|
14155
|
|
|
14156 this.tabs = this.tablist.find( "> li:has(a[href])" )
|
|
|
14157 .addClass( "ui-state-default ui-corner-top" )
|
|
|
14158 .attr({
|
|
|
14159 role: "tab",
|
|
|
14160 tabIndex: -1
|
|
|
14161 });
|
|
|
14162
|
|
|
14163 this.anchors = this.tabs.map(function() {
|
|
|
14164 return $( "a", this )[ 0 ];
|
|
|
14165 })
|
|
|
14166 .addClass( "ui-tabs-anchor" )
|
|
|
14167 .attr({
|
|
|
14168 role: "presentation",
|
|
|
14169 tabIndex: -1
|
|
|
14170 });
|
|
|
14171
|
|
|
14172 this.panels = $();
|
|
|
14173
|
|
|
14174 this.anchors.each(function( i, anchor ) {
|
|
|
14175 var selector, panel, panelId,
|
|
|
14176 anchorId = $( anchor ).uniqueId().attr( "id" ),
|
|
|
14177 tab = $( anchor ).closest( "li" ),
|
|
|
14178 originalAriaControls = tab.attr( "aria-controls" );
|
|
|
14179
|
|
|
14180 // inline tab
|
|
|
14181 if ( isLocal( anchor ) ) {
|
|
|
14182 selector = anchor.hash;
|
|
|
14183 panel = that.element.find( that._sanitizeSelector( selector ) );
|
|
|
14184 // remote tab
|
|
|
14185 } else {
|
|
|
14186 panelId = that._tabId( tab );
|
|
|
14187 selector = "#" + panelId;
|
|
|
14188 panel = that.element.find( selector );
|
|
|
14189 if ( !panel.length ) {
|
|
|
14190 panel = that._createPanel( panelId );
|
|
|
14191 panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
|
|
|
14192 }
|
|
|
14193 panel.attr( "aria-live", "polite" );
|
|
|
14194 }
|
|
|
14195
|
|
|
14196 if ( panel.length) {
|
|
|
14197 that.panels = that.panels.add( panel );
|
|
|
14198 }
|
|
|
14199 if ( originalAriaControls ) {
|
|
|
14200 tab.data( "ui-tabs-aria-controls", originalAriaControls );
|
|
|
14201 }
|
|
|
14202 tab.attr({
|
|
|
14203 "aria-controls": selector.substring( 1 ),
|
|
|
14204 "aria-labelledby": anchorId
|
|
|
14205 });
|
|
|
14206 panel.attr( "aria-labelledby", anchorId );
|
|
|
14207 });
|
|
|
14208
|
|
|
14209 this.panels
|
|
|
14210 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
|
|
|
14211 .attr( "role", "tabpanel" );
|
|
|
14212 },
|
|
|
14213
|
|
|
14214 // allow overriding how to find the list for rare usage scenarios (#7715)
|
|
|
14215 _getList: function() {
|
|
|
14216 return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
|
|
|
14217 },
|
|
|
14218
|
|
|
14219 _createPanel: function( id ) {
|
|
|
14220 return $( "<div>" )
|
|
|
14221 .attr( "id", id )
|
|
|
14222 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
|
|
|
14223 .data( "ui-tabs-destroy", true );
|
|
|
14224 },
|
|
|
14225
|
|
|
14226 _setupDisabled: function( disabled ) {
|
|
|
14227 if ( $.isArray( disabled ) ) {
|
|
|
14228 if ( !disabled.length ) {
|
|
|
14229 disabled = false;
|
|
|
14230 } else if ( disabled.length === this.anchors.length ) {
|
|
|
14231 disabled = true;
|
|
|
14232 }
|
|
|
14233 }
|
|
|
14234
|
|
|
14235 // disable tabs
|
|
|
14236 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
|
|
|
14237 if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
|
|
|
14238 $( li )
|
|
|
14239 .addClass( "ui-state-disabled" )
|
|
|
14240 .attr( "aria-disabled", "true" );
|
|
|
14241 } else {
|
|
|
14242 $( li )
|
|
|
14243 .removeClass( "ui-state-disabled" )
|
|
|
14244 .removeAttr( "aria-disabled" );
|
|
|
14245 }
|
|
|
14246 }
|
|
|
14247
|
|
|
14248 this.options.disabled = disabled;
|
|
|
14249 },
|
|
|
14250
|
|
|
14251 _setupEvents: function( event ) {
|
|
|
14252 var events = {
|
|
|
14253 click: function( event ) {
|
|
|
14254 event.preventDefault();
|
|
|
14255 }
|
|
|
14256 };
|
|
|
14257 if ( event ) {
|
|
|
14258 $.each( event.split(" "), function( index, eventName ) {
|
|
|
14259 events[ eventName ] = "_eventHandler";
|
|
|
14260 });
|
|
|
14261 }
|
|
|
14262
|
|
|
14263 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
|
|
|
14264 this._on( this.anchors, events );
|
|
|
14265 this._on( this.tabs, { keydown: "_tabKeydown" } );
|
|
|
14266 this._on( this.panels, { keydown: "_panelKeydown" } );
|
|
|
14267
|
|
|
14268 this._focusable( this.tabs );
|
|
|
14269 this._hoverable( this.tabs );
|
|
|
14270 },
|
|
|
14271
|
|
|
14272 _setupHeightStyle: function( heightStyle ) {
|
|
|
14273 var maxHeight,
|
|
|
14274 parent = this.element.parent();
|
|
|
14275
|
|
|
14276 if ( heightStyle === "fill" ) {
|
|
|
14277 maxHeight = parent.height();
|
|
|
14278 maxHeight -= this.element.outerHeight() - this.element.height();
|
|
|
14279
|
|
|
14280 this.element.siblings( ":visible" ).each(function() {
|
|
|
14281 var elem = $( this ),
|
|
|
14282 position = elem.css( "position" );
|
|
|
14283
|
|
|
14284 if ( position === "absolute" || position === "fixed" ) {
|
|
|
14285 return;
|
|
|
14286 }
|
|
|
14287 maxHeight -= elem.outerHeight( true );
|
|
|
14288 });
|
|
|
14289
|
|
|
14290 this.element.children().not( this.panels ).each(function() {
|
|
|
14291 maxHeight -= $( this ).outerHeight( true );
|
|
|
14292 });
|
|
|
14293
|
|
|
14294 this.panels.each(function() {
|
|
|
14295 $( this ).height( Math.max( 0, maxHeight -
|
|
|
14296 $( this ).innerHeight() + $( this ).height() ) );
|
|
|
14297 })
|
|
|
14298 .css( "overflow", "auto" );
|
|
|
14299 } else if ( heightStyle === "auto" ) {
|
|
|
14300 maxHeight = 0;
|
|
|
14301 this.panels.each(function() {
|
|
|
14302 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
|
|
|
14303 }).height( maxHeight );
|
|
|
14304 }
|
|
|
14305 },
|
|
|
14306
|
|
|
14307 _eventHandler: function( event ) {
|
|
|
14308 var options = this.options,
|
|
|
14309 active = this.active,
|
|
|
14310 anchor = $( event.currentTarget ),
|
|
|
14311 tab = anchor.closest( "li" ),
|
|
|
14312 clickedIsActive = tab[ 0 ] === active[ 0 ],
|
|
|
14313 collapsing = clickedIsActive && options.collapsible,
|
|
|
14314 toShow = collapsing ? $() : this._getPanelForTab( tab ),
|
|
|
14315 toHide = !active.length ? $() : this._getPanelForTab( active ),
|
|
|
14316 eventData = {
|
|
|
14317 oldTab: active,
|
|
|
14318 oldPanel: toHide,
|
|
|
14319 newTab: collapsing ? $() : tab,
|
|
|
14320 newPanel: toShow
|
|
|
14321 };
|
|
|
14322
|
|
|
14323 event.preventDefault();
|
|
|
14324
|
|
|
14325 if ( tab.hasClass( "ui-state-disabled" ) ||
|
|
|
14326 // tab is already loading
|
|
|
14327 tab.hasClass( "ui-tabs-loading" ) ||
|
|
|
14328 // can't switch durning an animation
|
|
|
14329 this.running ||
|
|
|
14330 // click on active header, but not collapsible
|
|
|
14331 ( clickedIsActive && !options.collapsible ) ||
|
|
|
14332 // allow canceling activation
|
|
|
14333 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
|
|
|
14334 return;
|
|
|
14335 }
|
|
|
14336
|
|
|
14337 options.active = collapsing ? false : this.tabs.index( tab );
|
|
|
14338
|
|
|
14339 this.active = clickedIsActive ? $() : tab;
|
|
|
14340 if ( this.xhr ) {
|
|
|
14341 this.xhr.abort();
|
|
|
14342 }
|
|
|
14343
|
|
|
14344 if ( !toHide.length && !toShow.length ) {
|
|
|
14345 $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
|
|
|
14346 }
|
|
|
14347
|
|
|
14348 if ( toShow.length ) {
|
|
|
14349 this.load( this.tabs.index( tab ), event );
|
|
|
14350 }
|
|
|
14351 this._toggle( event, eventData );
|
|
|
14352 },
|
|
|
14353
|
|
|
14354 // handles show/hide for selecting tabs
|
|
|
14355 _toggle: function( event, eventData ) {
|
|
|
14356 var that = this,
|
|
|
14357 toShow = eventData.newPanel,
|
|
|
14358 toHide = eventData.oldPanel;
|
|
|
14359
|
|
|
14360 this.running = true;
|
|
|
14361
|
|
|
14362 function complete() {
|
|
|
14363 that.running = false;
|
|
|
14364 that._trigger( "activate", event, eventData );
|
|
|
14365 }
|
|
|
14366
|
|
|
14367 function show() {
|
|
|
14368 eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
|
|
|
14369
|
|
|
14370 if ( toShow.length && that.options.show ) {
|
|
|
14371 that._show( toShow, that.options.show, complete );
|
|
|
14372 } else {
|
|
|
14373 toShow.show();
|
|
|
14374 complete();
|
|
|
14375 }
|
|
|
14376 }
|
|
|
14377
|
|
|
14378 // start out by hiding, then showing, then completing
|
|
|
14379 if ( toHide.length && this.options.hide ) {
|
|
|
14380 this._hide( toHide, this.options.hide, function() {
|
|
|
14381 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
|
|
|
14382 show();
|
|
|
14383 });
|
|
|
14384 } else {
|
|
|
14385 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
|
|
|
14386 toHide.hide();
|
|
|
14387 show();
|
|
|
14388 }
|
|
|
14389
|
|
|
14390 toHide.attr({
|
|
|
14391 "aria-expanded": "false",
|
|
|
14392 "aria-hidden": "true"
|
|
|
14393 });
|
|
|
14394 eventData.oldTab.attr( "aria-selected", "false" );
|
|
|
14395 // If we're switching tabs, remove the old tab from the tab order.
|
|
|
14396 // If we're opening from collapsed state, remove the previous tab from the tab order.
|
|
|
14397 // If we're collapsing, then keep the collapsing tab in the tab order.
|
|
|
14398 if ( toShow.length && toHide.length ) {
|
|
|
14399 eventData.oldTab.attr( "tabIndex", -1 );
|
|
|
14400 } else if ( toShow.length ) {
|
|
|
14401 this.tabs.filter(function() {
|
|
|
14402 return $( this ).attr( "tabIndex" ) === 0;
|
|
|
14403 })
|
|
|
14404 .attr( "tabIndex", -1 );
|
|
|
14405 }
|
|
|
14406
|
|
|
14407 toShow.attr({
|
|
|
14408 "aria-expanded": "true",
|
|
|
14409 "aria-hidden": "false"
|
|
|
14410 });
|
|
|
14411 eventData.newTab.attr({
|
|
|
14412 "aria-selected": "true",
|
|
|
14413 tabIndex: 0
|
|
|
14414 });
|
|
|
14415 },
|
|
|
14416
|
|
|
14417 _activate: function( index ) {
|
|
|
14418 var anchor,
|
|
|
14419 active = this._findActive( index );
|
|
|
14420
|
|
|
14421 // trying to activate the already active panel
|
|
|
14422 if ( active[ 0 ] === this.active[ 0 ] ) {
|
|
|
14423 return;
|
|
|
14424 }
|
|
|
14425
|
|
|
14426 // trying to collapse, simulate a click on the current active header
|
|
|
14427 if ( !active.length ) {
|
|
|
14428 active = this.active;
|
|
|
14429 }
|
|
|
14430
|
|
|
14431 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
|
|
|
14432 this._eventHandler({
|
|
|
14433 target: anchor,
|
|
|
14434 currentTarget: anchor,
|
|
|
14435 preventDefault: $.noop
|
|
|
14436 });
|
|
|
14437 },
|
|
|
14438
|
|
|
14439 _findActive: function( index ) {
|
|
|
14440 return index === false ? $() : this.tabs.eq( index );
|
|
|
14441 },
|
|
|
14442
|
|
|
14443 _getIndex: function( index ) {
|
|
|
14444 // meta-function to give users option to provide a href string instead of a numerical index.
|
|
|
14445 if ( typeof index === "string" ) {
|
|
|
14446 index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
|
|
|
14447 }
|
|
|
14448
|
|
|
14449 return index;
|
|
|
14450 },
|
|
|
14451
|
|
|
14452 _destroy: function() {
|
|
|
14453 if ( this.xhr ) {
|
|
|
14454 this.xhr.abort();
|
|
|
14455 }
|
|
|
14456
|
|
|
14457 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
|
|
|
14458
|
|
|
14459 this.tablist
|
|
|
14460 .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
|
|
|
14461 .removeAttr( "role" );
|
|
|
14462
|
|
|
14463 this.anchors
|
|
|
14464 .removeClass( "ui-tabs-anchor" )
|
|
|
14465 .removeAttr( "role" )
|
|
|
14466 .removeAttr( "tabIndex" )
|
|
|
14467 .removeUniqueId();
|
|
|
14468
|
|
|
14469 this.tabs.add( this.panels ).each(function() {
|
|
|
14470 if ( $.data( this, "ui-tabs-destroy" ) ) {
|
|
|
14471 $( this ).remove();
|
|
|
14472 } else {
|
|
|
14473 $( this )
|
|
|
14474 .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
|
|
|
14475 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
|
|
|
14476 .removeAttr( "tabIndex" )
|
|
|
14477 .removeAttr( "aria-live" )
|
|
|
14478 .removeAttr( "aria-busy" )
|
|
|
14479 .removeAttr( "aria-selected" )
|
|
|
14480 .removeAttr( "aria-labelledby" )
|
|
|
14481 .removeAttr( "aria-hidden" )
|
|
|
14482 .removeAttr( "aria-expanded" )
|
|
|
14483 .removeAttr( "role" );
|
|
|
14484 }
|
|
|
14485 });
|
|
|
14486
|
|
|
14487 this.tabs.each(function() {
|
|
|
14488 var li = $( this ),
|
|
|
14489 prev = li.data( "ui-tabs-aria-controls" );
|
|
|
14490 if ( prev ) {
|
|
|
14491 li
|
|
|
14492 .attr( "aria-controls", prev )
|
|
|
14493 .removeData( "ui-tabs-aria-controls" );
|
|
|
14494 } else {
|
|
|
14495 li.removeAttr( "aria-controls" );
|
|
|
14496 }
|
|
|
14497 });
|
|
|
14498
|
|
|
14499 this.panels.show();
|
|
|
14500
|
|
|
14501 if ( this.options.heightStyle !== "content" ) {
|
|
|
14502 this.panels.css( "height", "" );
|
|
|
14503 }
|
|
|
14504 },
|
|
|
14505
|
|
|
14506 enable: function( index ) {
|
|
|
14507 var disabled = this.options.disabled;
|
|
|
14508 if ( disabled === false ) {
|
|
|
14509 return;
|
|
|
14510 }
|
|
|
14511
|
|
|
14512 if ( index === undefined ) {
|
|
|
14513 disabled = false;
|
|
|
14514 } else {
|
|
|
14515 index = this._getIndex( index );
|
|
|
14516 if ( $.isArray( disabled ) ) {
|
|
|
14517 disabled = $.map( disabled, function( num ) {
|
|
|
14518 return num !== index ? num : null;
|
|
|
14519 });
|
|
|
14520 } else {
|
|
|
14521 disabled = $.map( this.tabs, function( li, num ) {
|
|
|
14522 return num !== index ? num : null;
|
|
|
14523 });
|
|
|
14524 }
|
|
|
14525 }
|
|
|
14526 this._setupDisabled( disabled );
|
|
|
14527 },
|
|
|
14528
|
|
|
14529 disable: function( index ) {
|
|
|
14530 var disabled = this.options.disabled;
|
|
|
14531 if ( disabled === true ) {
|
|
|
14532 return;
|
|
|
14533 }
|
|
|
14534
|
|
|
14535 if ( index === undefined ) {
|
|
|
14536 disabled = true;
|
|
|
14537 } else {
|
|
|
14538 index = this._getIndex( index );
|
|
|
14539 if ( $.inArray( index, disabled ) !== -1 ) {
|
|
|
14540 return;
|
|
|
14541 }
|
|
|
14542 if ( $.isArray( disabled ) ) {
|
|
|
14543 disabled = $.merge( [ index ], disabled ).sort();
|
|
|
14544 } else {
|
|
|
14545 disabled = [ index ];
|
|
|
14546 }
|
|
|
14547 }
|
|
|
14548 this._setupDisabled( disabled );
|
|
|
14549 },
|
|
|
14550
|
|
|
14551 load: function( index, event ) {
|
|
|
14552 index = this._getIndex( index );
|
|
|
14553 var that = this,
|
|
|
14554 tab = this.tabs.eq( index ),
|
|
|
14555 anchor = tab.find( ".ui-tabs-anchor" ),
|
|
|
14556 panel = this._getPanelForTab( tab ),
|
|
|
14557 eventData = {
|
|
|
14558 tab: tab,
|
|
|
14559 panel: panel
|
|
|
14560 };
|
|
|
14561
|
|
|
14562 // not remote
|
|
|
14563 if ( isLocal( anchor[ 0 ] ) ) {
|
|
|
14564 return;
|
|
|
14565 }
|
|
|
14566
|
|
|
14567 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
|
|
|
14568
|
|
|
14569 // support: jQuery <1.8
|
|
|
14570 // jQuery <1.8 returns false if the request is canceled in beforeSend,
|
|
|
14571 // but as of 1.8, $.ajax() always returns a jqXHR object.
|
|
|
14572 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
|
|
|
14573 tab.addClass( "ui-tabs-loading" );
|
|
|
14574 panel.attr( "aria-busy", "true" );
|
|
|
14575
|
|
|
14576 this.xhr
|
|
|
14577 .success(function( response ) {
|
|
|
14578 // support: jQuery <1.8
|
|
|
14579 // http://bugs.jquery.com/ticket/11778
|
|
|
14580 setTimeout(function() {
|
|
|
14581 panel.html( response );
|
|
|
14582 that._trigger( "load", event, eventData );
|
|
|
14583 }, 1 );
|
|
|
14584 })
|
|
|
14585 .complete(function( jqXHR, status ) {
|
|
|
14586 // support: jQuery <1.8
|
|
|
14587 // http://bugs.jquery.com/ticket/11778
|
|
|
14588 setTimeout(function() {
|
|
|
14589 if ( status === "abort" ) {
|
|
|
14590 that.panels.stop( false, true );
|
|
|
14591 }
|
|
|
14592
|
|
|
14593 tab.removeClass( "ui-tabs-loading" );
|
|
|
14594 panel.removeAttr( "aria-busy" );
|
|
|
14595
|
|
|
14596 if ( jqXHR === that.xhr ) {
|
|
|
14597 delete that.xhr;
|
|
|
14598 }
|
|
|
14599 }, 1 );
|
|
|
14600 });
|
|
|
14601 }
|
|
|
14602 },
|
|
|
14603
|
|
|
14604 _ajaxSettings: function( anchor, event, eventData ) {
|
|
|
14605 var that = this;
|
|
|
14606 return {
|
|
|
14607 url: anchor.attr( "href" ),
|
|
|
14608 beforeSend: function( jqXHR, settings ) {
|
|
|
14609 return that._trigger( "beforeLoad", event,
|
|
|
14610 $.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
|
|
|
14611 }
|
|
|
14612 };
|
|
|
14613 },
|
|
|
14614
|
|
|
14615 _getPanelForTab: function( tab ) {
|
|
|
14616 var id = $( tab ).attr( "aria-controls" );
|
|
|
14617 return this.element.find( this._sanitizeSelector( "#" + id ) );
|
|
|
14618 }
|
|
|
14619 });
|
|
|
14620
|
|
|
14621 })( jQuery );
|
|
|
14622 (function( $ ) {
|
|
|
14623
|
|
|
14624 var increments = 0;
|
|
|
14625
|
|
|
14626 function addDescribedBy( elem, id ) {
|
|
|
14627 var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
|
|
|
14628 describedby.push( id );
|
|
|
14629 elem
|
|
|
14630 .data( "ui-tooltip-id", id )
|
|
|
14631 .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
|
|
|
14632 }
|
|
|
14633
|
|
|
14634 function removeDescribedBy( elem ) {
|
|
|
14635 var id = elem.data( "ui-tooltip-id" ),
|
|
|
14636 describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
|
|
|
14637 index = $.inArray( id, describedby );
|
|
|
14638 if ( index !== -1 ) {
|
|
|
14639 describedby.splice( index, 1 );
|
|
|
14640 }
|
|
|
14641
|
|
|
14642 elem.removeData( "ui-tooltip-id" );
|
|
|
14643 describedby = $.trim( describedby.join( " " ) );
|
|
|
14644 if ( describedby ) {
|
|
|
14645 elem.attr( "aria-describedby", describedby );
|
|
|
14646 } else {
|
|
|
14647 elem.removeAttr( "aria-describedby" );
|
|
|
14648 }
|
|
|
14649 }
|
|
|
14650
|
|
|
14651 $.widget( "ui.tooltip", {
|
|
|
14652 version: "1.10.4",
|
|
|
14653 options: {
|
|
|
14654 content: function() {
|
|
|
14655 // support: IE<9, Opera in jQuery <1.7
|
|
|
14656 // .text() can't accept undefined, so coerce to a string
|
|
|
14657 var title = $( this ).attr( "title" ) || "";
|
|
|
14658 // Escape title, since we're going from an attribute to raw HTML
|
|
|
14659 return $( "<a>" ).text( title ).html();
|
|
|
14660 },
|
|
|
14661 hide: true,
|
|
|
14662 // Disabled elements have inconsistent behavior across browsers (#8661)
|
|
|
14663 items: "[title]:not([disabled])",
|
|
|
14664 position: {
|
|
|
14665 my: "left top+15",
|
|
|
14666 at: "left bottom",
|
|
|
14667 collision: "flipfit flip"
|
|
|
14668 },
|
|
|
14669 show: true,
|
|
|
14670 tooltipClass: null,
|
|
|
14671 track: false,
|
|
|
14672
|
|
|
14673 // callbacks
|
|
|
14674 close: null,
|
|
|
14675 open: null
|
|
|
14676 },
|
|
|
14677
|
|
|
14678 _create: function() {
|
|
|
14679 this._on({
|
|
|
14680 mouseover: "open",
|
|
|
14681 focusin: "open"
|
|
|
14682 });
|
|
|
14683
|
|
|
14684 // IDs of generated tooltips, needed for destroy
|
|
|
14685 this.tooltips = {};
|
|
|
14686 // IDs of parent tooltips where we removed the title attribute
|
|
|
14687 this.parents = {};
|
|
|
14688
|
|
|
14689 if ( this.options.disabled ) {
|
|
|
14690 this._disable();
|
|
|
14691 }
|
|
|
14692 },
|
|
|
14693
|
|
|
14694 _setOption: function( key, value ) {
|
|
|
14695 var that = this;
|
|
|
14696
|
|
|
14697 if ( key === "disabled" ) {
|
|
|
14698 this[ value ? "_disable" : "_enable" ]();
|
|
|
14699 this.options[ key ] = value;
|
|
|
14700 // disable element style changes
|
|
|
14701 return;
|
|
|
14702 }
|
|
|
14703
|
|
|
14704 this._super( key, value );
|
|
|
14705
|
|
|
14706 if ( key === "content" ) {
|
|
|
14707 $.each( this.tooltips, function( id, element ) {
|
|
|
14708 that._updateContent( element );
|
|
|
14709 });
|
|
|
14710 }
|
|
|
14711 },
|
|
|
14712
|
|
|
14713 _disable: function() {
|
|
|
14714 var that = this;
|
|
|
14715
|
|
|
14716 // close open tooltips
|
|
|
14717 $.each( this.tooltips, function( id, element ) {
|
|
|
14718 var event = $.Event( "blur" );
|
|
|
14719 event.target = event.currentTarget = element[0];
|
|
|
14720 that.close( event, true );
|
|
|
14721 });
|
|
|
14722
|
|
|
14723 // remove title attributes to prevent native tooltips
|
|
|
14724 this.element.find( this.options.items ).addBack().each(function() {
|
|
|
14725 var element = $( this );
|
|
|
14726 if ( element.is( "[title]" ) ) {
|
|
|
14727 element
|
|
|
14728 .data( "ui-tooltip-title", element.attr( "title" ) )
|
|
|
14729 .attr( "title", "" );
|
|
|
14730 }
|
|
|
14731 });
|
|
|
14732 },
|
|
|
14733
|
|
|
14734 _enable: function() {
|
|
|
14735 // restore title attributes
|
|
|
14736 this.element.find( this.options.items ).addBack().each(function() {
|
|
|
14737 var element = $( this );
|
|
|
14738 if ( element.data( "ui-tooltip-title" ) ) {
|
|
|
14739 element.attr( "title", element.data( "ui-tooltip-title" ) );
|
|
|
14740 }
|
|
|
14741 });
|
|
|
14742 },
|
|
|
14743
|
|
|
14744 open: function( event ) {
|
|
|
14745 var that = this,
|
|
|
14746 target = $( event ? event.target : this.element )
|
|
|
14747 // we need closest here due to mouseover bubbling,
|
|
|
14748 // but always pointing at the same event target
|
|
|
14749 .closest( this.options.items );
|
|
|
14750
|
|
|
14751 // No element to show a tooltip for or the tooltip is already open
|
|
|
14752 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
|
|
|
14753 return;
|
|
|
14754 }
|
|
|
14755
|
|
|
14756 if ( target.attr( "title" ) ) {
|
|
|
14757 target.data( "ui-tooltip-title", target.attr( "title" ) );
|
|
|
14758 }
|
|
|
14759
|
|
|
14760 target.data( "ui-tooltip-open", true );
|
|
|
14761
|
|
|
14762 // kill parent tooltips, custom or native, for hover
|
|
|
14763 if ( event && event.type === "mouseover" ) {
|
|
|
14764 target.parents().each(function() {
|
|
|
14765 var parent = $( this ),
|
|
|
14766 blurEvent;
|
|
|
14767 if ( parent.data( "ui-tooltip-open" ) ) {
|
|
|
14768 blurEvent = $.Event( "blur" );
|
|
|
14769 blurEvent.target = blurEvent.currentTarget = this;
|
|
|
14770 that.close( blurEvent, true );
|
|
|
14771 }
|
|
|
14772 if ( parent.attr( "title" ) ) {
|
|
|
14773 parent.uniqueId();
|
|
|
14774 that.parents[ this.id ] = {
|
|
|
14775 element: this,
|
|
|
14776 title: parent.attr( "title" )
|
|
|
14777 };
|
|
|
14778 parent.attr( "title", "" );
|
|
|
14779 }
|
|
|
14780 });
|
|
|
14781 }
|
|
|
14782
|
|
|
14783 this._updateContent( target, event );
|
|
|
14784 },
|
|
|
14785
|
|
|
14786 _updateContent: function( target, event ) {
|
|
|
14787 var content,
|
|
|
14788 contentOption = this.options.content,
|
|
|
14789 that = this,
|
|
|
14790 eventType = event ? event.type : null;
|
|
|
14791
|
|
|
14792 if ( typeof contentOption === "string" ) {
|
|
|
14793 return this._open( event, target, contentOption );
|
|
|
14794 }
|
|
|
14795
|
|
|
14796 content = contentOption.call( target[0], function( response ) {
|
|
|
14797 // ignore async response if tooltip was closed already
|
|
|
14798 if ( !target.data( "ui-tooltip-open" ) ) {
|
|
|
14799 return;
|
|
|
14800 }
|
|
|
14801 // IE may instantly serve a cached response for ajax requests
|
|
|
14802 // delay this call to _open so the other call to _open runs first
|
|
|
14803 that._delay(function() {
|
|
|
14804 // jQuery creates a special event for focusin when it doesn't
|
|
|
14805 // exist natively. To improve performance, the native event
|
|
|
14806 // object is reused and the type is changed. Therefore, we can't
|
|
|
14807 // rely on the type being correct after the event finished
|
|
|
14808 // bubbling, so we set it back to the previous value. (#8740)
|
|
|
14809 if ( event ) {
|
|
|
14810 event.type = eventType;
|
|
|
14811 }
|
|
|
14812 this._open( event, target, response );
|
|
|
14813 });
|
|
|
14814 });
|
|
|
14815 if ( content ) {
|
|
|
14816 this._open( event, target, content );
|
|
|
14817 }
|
|
|
14818 },
|
|
|
14819
|
|
|
14820 _open: function( event, target, content ) {
|
|
|
14821 var tooltip, events, delayedShow,
|
|
|
14822 positionOption = $.extend( {}, this.options.position );
|
|
|
14823
|
|
|
14824 if ( !content ) {
|
|
|
14825 return;
|
|
|
14826 }
|
|
|
14827
|
|
|
14828 // Content can be updated multiple times. If the tooltip already
|
|
|
14829 // exists, then just update the content and bail.
|
|
|
14830 tooltip = this._find( target );
|
|
|
14831 if ( tooltip.length ) {
|
|
|
14832 tooltip.find( ".ui-tooltip-content" ).html( content );
|
|
|
14833 return;
|
|
|
14834 }
|
|
|
14835
|
|
|
14836 // if we have a title, clear it to prevent the native tooltip
|
|
|
14837 // we have to check first to avoid defining a title if none exists
|
|
|
14838 // (we don't want to cause an element to start matching [title])
|
|
|
14839 //
|
|
|
14840 // We use removeAttr only for key events, to allow IE to export the correct
|
|
|
14841 // accessible attributes. For mouse events, set to empty string to avoid
|
|
|
14842 // native tooltip showing up (happens only when removing inside mouseover).
|
|
|
14843 if ( target.is( "[title]" ) ) {
|
|
|
14844 if ( event && event.type === "mouseover" ) {
|
|
|
14845 target.attr( "title", "" );
|
|
|
14846 } else {
|
|
|
14847 target.removeAttr( "title" );
|
|
|
14848 }
|
|
|
14849 }
|
|
|
14850
|
|
|
14851 tooltip = this._tooltip( target );
|
|
|
14852 addDescribedBy( target, tooltip.attr( "id" ) );
|
|
|
14853 tooltip.find( ".ui-tooltip-content" ).html( content );
|
|
|
14854
|
|
|
14855 function position( event ) {
|
|
|
14856 positionOption.of = event;
|
|
|
14857 if ( tooltip.is( ":hidden" ) ) {
|
|
|
14858 return;
|
|
|
14859 }
|
|
|
14860 tooltip.position( positionOption );
|
|
|
14861 }
|
|
|
14862 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
|
|
|
14863 this._on( this.document, {
|
|
|
14864 mousemove: position
|
|
|
14865 });
|
|
|
14866 // trigger once to override element-relative positioning
|
|
|
14867 position( event );
|
|
|
14868 } else {
|
|
|
14869 tooltip.position( $.extend({
|
|
|
14870 of: target
|
|
|
14871 }, this.options.position ) );
|
|
|
14872 }
|
|
|
14873
|
|
|
14874 tooltip.hide();
|
|
|
14875
|
|
|
14876 this._show( tooltip, this.options.show );
|
|
|
14877 // Handle tracking tooltips that are shown with a delay (#8644). As soon
|
|
|
14878 // as the tooltip is visible, position the tooltip using the most recent
|
|
|
14879 // event.
|
|
|
14880 if ( this.options.show && this.options.show.delay ) {
|
|
|
14881 delayedShow = this.delayedShow = setInterval(function() {
|
|
|
14882 if ( tooltip.is( ":visible" ) ) {
|
|
|
14883 position( positionOption.of );
|
|
|
14884 clearInterval( delayedShow );
|
|
|
14885 }
|
|
|
14886 }, $.fx.interval );
|
|
|
14887 }
|
|
|
14888
|
|
|
14889 this._trigger( "open", event, { tooltip: tooltip } );
|
|
|
14890
|
|
|
14891 events = {
|
|
|
14892 keyup: function( event ) {
|
|
|
14893 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
|
|
|
14894 var fakeEvent = $.Event(event);
|
|
|
14895 fakeEvent.currentTarget = target[0];
|
|
|
14896 this.close( fakeEvent, true );
|
|
|
14897 }
|
|
|
14898 },
|
|
|
14899 remove: function() {
|
|
|
14900 this._removeTooltip( tooltip );
|
|
|
14901 }
|
|
|
14902 };
|
|
|
14903 if ( !event || event.type === "mouseover" ) {
|
|
|
14904 events.mouseleave = "close";
|
|
|
14905 }
|
|
|
14906 if ( !event || event.type === "focusin" ) {
|
|
|
14907 events.focusout = "close";
|
|
|
14908 }
|
|
|
14909 this._on( true, target, events );
|
|
|
14910 },
|
|
|
14911
|
|
|
14912 close: function( event ) {
|
|
|
14913 var that = this,
|
|
|
14914 target = $( event ? event.currentTarget : this.element ),
|
|
|
14915 tooltip = this._find( target );
|
|
|
14916
|
|
|
14917 // disabling closes the tooltip, so we need to track when we're closing
|
|
|
14918 // to avoid an infinite loop in case the tooltip becomes disabled on close
|
|
|
14919 if ( this.closing ) {
|
|
|
14920 return;
|
|
|
14921 }
|
|
|
14922
|
|
|
14923 // Clear the interval for delayed tracking tooltips
|
|
|
14924 clearInterval( this.delayedShow );
|
|
|
14925
|
|
|
14926 // only set title if we had one before (see comment in _open())
|
|
|
14927 if ( target.data( "ui-tooltip-title" ) ) {
|
|
|
14928 target.attr( "title", target.data( "ui-tooltip-title" ) );
|
|
|
14929 }
|
|
|
14930
|
|
|
14931 removeDescribedBy( target );
|
|
|
14932
|
|
|
14933 tooltip.stop( true );
|
|
|
14934 this._hide( tooltip, this.options.hide, function() {
|
|
|
14935 that._removeTooltip( $( this ) );
|
|
|
14936 });
|
|
|
14937
|
|
|
14938 target.removeData( "ui-tooltip-open" );
|
|
|
14939 this._off( target, "mouseleave focusout keyup" );
|
|
|
14940 // Remove 'remove' binding only on delegated targets
|
|
|
14941 if ( target[0] !== this.element[0] ) {
|
|
|
14942 this._off( target, "remove" );
|
|
|
14943 }
|
|
|
14944 this._off( this.document, "mousemove" );
|
|
|
14945
|
|
|
14946 if ( event && event.type === "mouseleave" ) {
|
|
|
14947 $.each( this.parents, function( id, parent ) {
|
|
|
14948 $( parent.element ).attr( "title", parent.title );
|
|
|
14949 delete that.parents[ id ];
|
|
|
14950 });
|
|
|
14951 }
|
|
|
14952
|
|
|
14953 this.closing = true;
|
|
|
14954 this._trigger( "close", event, { tooltip: tooltip } );
|
|
|
14955 this.closing = false;
|
|
|
14956 },
|
|
|
14957
|
|
|
14958 _tooltip: function( element ) {
|
|
|
14959 var id = "ui-tooltip-" + increments++,
|
|
|
14960 tooltip = $( "<div>" )
|
|
|
14961 .attr({
|
|
|
14962 id: id,
|
|
|
14963 role: "tooltip"
|
|
|
14964 })
|
|
|
14965 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
|
|
|
14966 ( this.options.tooltipClass || "" ) );
|
|
|
14967 $( "<div>" )
|
|
|
14968 .addClass( "ui-tooltip-content" )
|
|
|
14969 .appendTo( tooltip );
|
|
|
14970 tooltip.appendTo( this.document[0].body );
|
|
|
14971 this.tooltips[ id ] = element;
|
|
|
14972 return tooltip;
|
|
|
14973 },
|
|
|
14974
|
|
|
14975 _find: function( target ) {
|
|
|
14976 var id = target.data( "ui-tooltip-id" );
|
|
|
14977 return id ? $( "#" + id ) : $();
|
|
|
14978 },
|
|
|
14979
|
|
|
14980 _removeTooltip: function( tooltip ) {
|
|
|
14981 tooltip.remove();
|
|
|
14982 delete this.tooltips[ tooltip.attr( "id" ) ];
|
|
|
14983 },
|
|
|
14984
|
|
|
14985 _destroy: function() {
|
|
|
14986 var that = this;
|
|
|
14987
|
|
|
14988 // close open tooltips
|
|
|
14989 $.each( this.tooltips, function( id, element ) {
|
|
|
14990 // Delegate to close method to handle common cleanup
|
|
|
14991 var event = $.Event( "blur" );
|
|
|
14992 event.target = event.currentTarget = element[0];
|
|
|
14993 that.close( event, true );
|
|
|
14994
|
|
|
14995 // Remove immediately; destroying an open tooltip doesn't use the
|
|
|
14996 // hide animation
|
|
|
14997 $( "#" + id ).remove();
|
|
|
14998
|
|
|
14999 // Restore the title
|
|
|
15000 if ( element.data( "ui-tooltip-title" ) ) {
|
|
|
15001 element.attr( "title", element.data( "ui-tooltip-title" ) );
|
|
|
15002 element.removeData( "ui-tooltip-title" );
|
|
|
15003 }
|
|
|
15004 });
|
|
|
15005 }
|
|
|
15006 });
|
|
|
15007
|
|
|
15008 }( jQuery ) );
|
