| blob | 7b727e74350cbef7d079ea93d8da23a511eaa961 |
1 /*! jQuery UI - v1.10.3 - 2013-05-03
2 * http://jqueryui.com
3 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.effect.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.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.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
4 * Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
10 // $.ui might exist from components with no dependencies, e.g., $.ui.position
16 keyCode: {
39 }
40 });
42 // plugins
53 }
55 }) :
57 };
62 if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
64 return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
68 return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
70 }
72 return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
73 },
78 }
83 // Ignore z-index if position is set to a value where z-index is ignored by the browser
84 // This makes behavior of this function consistent across browsers
85 // WebKit always returns auto if the element is positioned
88 // IE returns 0 when zIndex is not specified
89 // other browsers return a string
90 // we ignore the case of nested elements with an explicit value of 0
91 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
95 }
96 }
98 }
99 }
102 },
108 }
109 });
110 },
116 }
117 });
118 }
119 });
121 // selectors
130 }
133 }
138 isTabIndexNotNaN) &&
139 // the element and all of its ancestors must be visible
141 }
148 }
155 };
156 }) :
157 // support: jQuery <1.8
160 },
164 },
170 }
171 });
173 // support: jQuery <1.8
178 orig = {
183 };
190 }
193 }
194 });
196 }
201 }
205 });
206 };
211 }
215 });
216 };
217 });
218 }
220 // support: jQuery <1.8
225 );
226 };
227 }
229 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
237 }
238 };
240 }
246 // deprecated
255 });
256 },
260 }
261 });
264 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
265 plugin: {
272 }
273 },
277 if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
279 }
284 }
285 }
286 }
287 },
289 // only used by resizable
292 //If overflow is hidden, the element might have extra content, but the user wants to hide it
295 }
302 }
304 // TODO: determine which cases actually cause this to happen
305 // if the element doesn't have the scroll set, see if it's possible to
306 // set the scroll
311 }
312 });
325 // http://bugs.jquery.com/ticket/8235
327 }
329 };
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 = {},
344 }
346 // create selector for plugin
349 };
354 // allow instantiation without "new" keyword
357 }
359 // allow instantiation without initializing for simple inheritance
360 // must use "new" keyword (the code above always passes args)
363 }
364 };
365 // extend with the existing constructor to carry over any static properties
368 // copy the object used to create the prototype in case we need to
369 // redefine the widget later
371 // track widgets that inherit from this widget in case this widget is
372 // redefined after a widget inherits from it
373 _childConstructors: []
374 });
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
385 }
389 },
392 };
396 returnValue;
407 };
408 })();
409 });
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
419 widgetFullName: fullName
420 });
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.
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
439 }
442 };
448 key,
449 value;
454 // Clone objects
458 // Don't extend strings, arrays, etc. with objects
460 // Copy everything else by reference
463 }
464 }
465 }
466 }
468 };
477 // allow multiple hashes to be passed on init
480 options;
489 }
492 }
497 methodValue;
499 }
500 });
508 }
509 });
510 }
513 };
514 };
523 options: {
526 // callbacks
528 },
537 options );
549 }
550 }
551 });
553 // element within the document
555 // element is window or document
558 }
563 },
571 // we can probably remove the unbind calls in 2.0
572 // all event bindings should go through this._on()
575 // 1.9 BC for #7810
576 // TODO remove dual storage
579 // support: jquery <1.6.3
580 // http://bugs.jquery.com/ticket/9413
589 // clean up events and states
593 },
598 },
602 parts,
603 curOption,
604 i;
607 // don't return a reference to the internal hash
609 }
612 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
613 options = {};
621 }
625 }
630 }
632 }
633 }
638 },
644 }
647 },
657 }
660 },
664 },
667 },
673 // no suppressDisabledCheck flag, shuffle arguments
678 }
680 // no element argument, shuffle and use this.element
686 // accept selectors, DOM elements
689 }
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
700 }
703 }
705 // copy the guid so direct unbinding works
709 }
718 }
719 });
720 },
723 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
725 },
731 }
734 },
741 },
744 }
745 });
746 },
753 },
756 }
757 });
758 },
767 type :
769 // the original event may come from any element
770 // so we need to reset the target on the new event
773 // copy original event properties over to the new event
779 }
780 }
781 }
787 }
788 };
794 }
797 method :
799 defaultEffect :
804 }
809 }
819 }
821 });
822 }
823 };
824 });
833 });
837 options: {
841 },
848 })
854 }
855 });
858 },
860 // TODO: make sure destroying one instance of mouse doesn't mess with
861 // other instances of mouse
868 }
869 },
872 // don't let more than one widget handle mouseStart
875 // we may have missed mouseup (out of window)
882 // event.target.nodeName works around a bug in IE 8 with
883 // disabled inputs (#7620)
884 elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
887 }
894 }
901 }
902 }
904 // Click event may never have fired (Gecko & Opera)
907 }
909 // these delegates are required to keep context
912 };
915 };
924 },
927 // IE mouseup check - mouseup happened when mouse was out of window
930 }
935 }
941 }
944 },
956 }
959 }
962 },
969 );
970 },
974 },
976 // These are placeholder methods, to be overriden by extending plugin
981 });
990 options: {
1016 // callbacks
1020 },
1023 if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
1025 }
1028 }
1031 }
1035 },
1040 },
1046 // among others, prevent a drag on a resizable-handle
1049 }
1051 //Quit if we're not on a valid handle
1055 }
1062 })
1065 });
1069 },
1075 //Create and append the visible helper
1080 //Cache the helper size
1083 //If ddmanager is used for droppables, set the global draggable
1086 }
1088 /*
1089 * - Position generation -
1090 * This block generates everything position related - it's the core of draggables.
1091 */
1093 //Cache the margins of the original element
1096 //Store the helper's css position
1102 //The element's absolute position on the page minus margins
1107 };
1109 //Reset scroll cache
1116 },
1118 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1119 });
1121 //Generate the original position
1126 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1129 //Set a containment if given in the options
1132 //Trigger event + callbacks
1136 }
1138 //Recache the helper size
1141 //Prepare the droppable offsets
1144 }
1147 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1149 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1152 }
1155 },
1158 // reset any necessary cached properties (see #5009)
1161 }
1163 //Compute the helpers position
1167 //Call plugins and callbacks and use the resulting position if something is returned
1173 }
1175 }
1179 }
1182 }
1185 }
1188 },
1192 //If we are using droppables, inform the manager about the drop
1197 }
1199 //if a drop comes from outside (a sortable)
1203 }
1205 //if the original element is no longer in the DOM don't bother to continue (see #8269)
1206 if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
1208 }
1210 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))) {
1211 $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1214 }
1215 });
1219 }
1220 }
1223 },
1226 //Remove frame helpers
1229 });
1231 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1234 }
1237 },
1245 }
1249 },
1255 },
1260 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1264 }
1268 }
1272 },
1277 }
1280 }
1283 }
1286 }
1289 }
1292 }
1293 },
1297 //Get the offsetParent and cache its position
1300 // This is a special case where we need to modify a offset calculated on start, since the following happened:
1301 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1302 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1303 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1304 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1307 }
1309 //This needs to be actually done for all browsers, since pageX/pageY includes this information
1310 //Ugly IE fix
1312 (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1314 }
1319 };
1321 },
1330 };
1333 }
1335 },
1343 };
1344 },
1350 };
1351 },
1361 }
1367 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
1368 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1369 ];
1371 }
1378 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1379 ];
1381 }
1386 }
1390 }
1397 }
1402 ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
1403 ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
1404 ( 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,
1405 ( 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
1406 ];
1408 },
1414 }
1417 scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
1419 //Cache the scroll
1422 }
1425 top: (
1427 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
1429 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
1430 ),
1431 left: (
1433 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
1435 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
1436 )
1437 };
1439 },
1445 scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
1449 //Cache the scroll
1452 }
1454 /*
1455 * - Position constraining -
1456 * Constrain the position to a mix of grid, containment.
1457 */
1459 // If we are not dragging yet, we won't check for options
1464 containment = [
1469 ];
1470 }
1473 }
1477 }
1480 }
1483 }
1486 }
1487 }
1490 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1491 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1492 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;
1494 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1495 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;
1496 }
1498 }
1501 top: (
1504 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
1507 ),
1508 left: (
1511 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
1514 )
1515 };
1517 },
1523 }
1526 },
1528 // From now on bulk stuff - mainly helpers
1533 //The absolute position has to be recalculated after plugins
1536 }
1538 },
1540 plugins: {},
1548 };
1549 }
1551 });
1565 });
1566 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).
1568 }
1569 });
1571 },
1574 //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
1584 this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
1586 //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
1589 }
1591 //Trigger the stop of the sortable
1596 //If the helper has been the original item, restore properties in the sortable
1599 }
1604 }
1606 });
1608 },
1618 //Copy over some variables to allow calling the sortable's native _intersectsWith
1632 ) {
1634 }
1636 });
1637 }
1641 //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
1645 //Now we fake the start of dragging for the sortable instance,
1646 //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
1647 //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)
1648 this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
1649 this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
1656 //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
1659 this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
1664 //hack so receive/update callbacks work (mostly)
1668 }
1670 //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
1673 }
1677 //If it doesn't intersect with the sortable, and it intersected before,
1678 //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
1684 //Prevent reverting on this forced stop
1687 // The out event needs to be triggered independently
1693 //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
1697 }
1701 }
1703 }
1705 });
1707 }
1708 });
1715 }
1717 },
1722 }
1723 }
1724 });
1731 }
1733 },
1738 }
1739 }
1740 });
1747 }
1748 },
1756 if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
1760 }
1761 }
1764 if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
1768 }
1769 }
1776 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
1778 }
1779 }
1784 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
1786 }
1787 }
1789 }
1793 }
1795 }
1796 });
1806 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
1814 });
1815 }
1816 });
1818 },
1835 if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
1837 (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1838 }
1841 }
1849 ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1850 }
1852 ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1853 }
1855 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1856 }
1858 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1859 }
1860 }
1870 ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1871 }
1873 ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1874 }
1876 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1877 }
1879 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1880 }
1881 }
1884 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1885 }
1888 }
1890 }
1891 });
1899 });
1906 });
1908 }
1909 });
1916 }
1918 },
1923 }
1924 }
1925 });
1933 }
1938 options: {
1947 // callbacks
1953 },
1964 };
1966 //Store the droppable's proportions
1967 this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1969 // Add the reference and positions to the manager
1975 },
1984 }
1985 }
1988 },
1995 };
1996 }
1998 },
2004 }
2007 }
2008 },
2014 }
2017 }
2018 },
2024 // Bail if draggable and droppable are same element
2027 }
2032 }
2034 }
2036 },
2042 // Bail if draggable and droppable are same element
2045 }
2050 }
2052 }
2054 },
2061 // Bail if draggable and droppable are same element
2064 }
2073 $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2075 });
2078 }
2083 }
2086 }
2089 }
2093 },
2101 };
2102 }
2104 });
2110 }
2113 x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2114 y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
2127 draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2128 draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2129 return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
2135 ) && (
2139 );
2142 }
2144 };
2146 /*
2147 This manager tracks offsets of draggables and droppables
2148 */
2161 //No disabled and non-accepted
2162 if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2164 }
2166 // Filter out elements in the current dragged item
2171 }
2172 }
2177 }
2179 //Activate the droppable if used directly from draggables
2182 }
2185 m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2187 }
2189 },
2193 // Create a copy of the droppables in case the list changes during the drop (#9116)
2198 }
2199 if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2201 }
2203 if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2207 }
2209 });
2212 },
2214 //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2218 }
2219 });
2220 },
2223 //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2226 }
2228 //Run through all droppables and check their positions based on specific tolerance options
2233 }
2240 }
2243 // find droppable parents with same scope
2247 });
2252 }
2253 }
2255 // we just moved into a greedy child
2260 }
2266 // we just moved out of a greedy child
2271 }
2272 });
2274 },
2277 //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2280 }
2281 }
2282 };
2290 }
2294 }
2299 options: {
2315 // See #7960
2318 // callbacks
2322 },
2334 _proportionallyResizeElements: [],
2336 });
2338 //Wrap the element if it cannot hold child nodes
2341 //Create a wrapper element and set the wrapper to the new current internal element
2349 })
2350 );
2352 //Overwrite the original this.element
2355 );
2359 //Move margins to the wrapper
2360 this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2363 //Prevent Safari textarea resize
2367 //Push the actual element to our proportionallyResize internal array
2368 this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2370 // avoid IE jump (hard set the margin)
2373 // fix handlers offset
2376 }
2378 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" });
2383 }
2394 // Apply zIndex to all handles - see #7960
2397 //TODO : What's going on here?
2400 }
2402 //Insert into internal handles object and append to element
2405 }
2407 }
2419 }
2421 //Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2422 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2426 //Checking the correct pad and border
2429 //The padding type i have to apply...
2439 }
2441 //TODO: What's that good for? There's not anything to be executed left
2444 }
2445 }
2446 };
2448 //TODO: make renderAxis a prototype function
2454 //Matching axis name
2459 }
2460 //Axis, default = se
2462 }
2463 });
2465 //If we want to auto hide the elements
2473 }
2476 })
2480 }
2484 }
2485 });
2486 }
2488 //Initialize the mouse interaction
2491 },
2500 .removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2501 };
2503 //TODO: Unwrap at same DOM position
2515 }
2521 },
2531 }
2532 }
2535 },
2546 // bugfix for http://dev.jquery.com/ticket/1749
2551 }
2561 }
2563 //Store needed variables
2566 this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2567 this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2569 this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2572 //Aspect Ratio
2573 this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2581 },
2585 //Increase performance, avoid regex
2600 }
2602 // Calculate the attrs that will be change
2605 // Put this in the mouseDrag handler since the user can start pressing shift while resizing
2609 }
2615 // plugins callbacks need to be called first
2620 }
2623 }
2626 }
2629 }
2634 }
2636 // Call the user callback if the element was resized
2639 }
2642 },
2654 soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2658 left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2659 top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2663 }
2670 }
2671 }
2681 }
2685 },
2691 b = {
2696 };
2699 // We want to create an enclosing box whose aspect ration is the requested one
2700 // First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2708 }
2711 }
2714 }
2717 }
2718 }
2720 },
2726 }
2729 }
2732 }
2735 }
2736 },
2748 }
2753 }
2757 }
2760 },
2766 ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2767 isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2773 }
2776 }
2779 }
2782 }
2786 }
2789 }
2792 }
2795 }
2797 // fixing jump error on top/left - bug #2330
2802 }
2805 },
2811 }
2822 borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2823 paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2826 this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2827 }
2828 }
2833 });
2835 }
2837 },
2855 });
2863 }
2865 },
2867 _change: {
2870 },
2874 },
2878 },
2881 },
2883 return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2884 },
2886 return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2887 },
2889 return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2890 },
2892 return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2893 }
2894 },
2899 },
2901 plugins: {},
2912 };
2913 }
2915 });
2917 /*
2918 * Resizable Extensions
2919 */
2928 soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2931 left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2932 top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2945 };
2949 }
2951 // propagating resize, and updating values for each animation step
2955 }
2956 }
2957 );
2958 }
2960 });
2974 }
2984 width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
2985 };
2986 }
2988 // i'm a node, so compute top, left, right, bottom
2991 p = [];
2992 $([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
2996 that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
3006 };
3007 }
3008 },
3020 }
3023 that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
3026 }
3028 }
3031 that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
3034 }
3036 }
3041 woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
3042 hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
3049 }
3055 }
3056 }
3062 }
3063 }
3064 },
3079 }
3083 }
3085 }
3086 });
3099 });
3100 });
3101 };
3108 }
3109 },
3116 delta = {
3119 },
3124 css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
3130 }
3131 });
3134 });
3135 };
3141 }
3142 },
3146 }
3147 });
3156 that.ghost
3157 .css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
3163 },
3169 }
3170 },
3176 }
3177 }
3179 });
3206 }
3209 }
3212 }
3215 }
3233 }
3234 }
3236 });
3244 options: {
3251 // callbacks
3258 },
3267 // cache selectee children based on filter
3285 });
3286 });
3287 };
3295 },
3304 },
3314 }
3321 // position helper (lasso)
3327 });
3331 }
3341 // selectable UNSELECTING callback
3344 });
3345 }
3346 });
3353 selectee.$element
3359 // selectable (UN)SELECTING callback
3363 });
3367 });
3368 }
3370 }
3371 });
3373 },
3381 }
3399 //prevent helper from being selected if appendTo: selectable
3402 }
3405 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
3407 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
3408 }
3411 // SELECT
3415 }
3419 }
3423 // selectable SELECTING callback
3426 });
3427 }
3429 // UNSELECT
3442 }
3443 // selectable UNSELECTING callback
3446 });
3447 }
3448 }
3456 // selectable UNSELECTING callback
3459 });
3460 }
3461 }
3462 }
3463 });
3466 },
3480 });
3481 });
3490 });
3491 });
3497 }
3499 });
3505 /*jshint loopfunc: true */
3509 }
3512 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
3513 }
3519 options: {
3543 // callbacks
3556 },
3563 //Get the items
3566 //Let's determine if the items are being displayed horizontally
3569 //Let's determine the parent's offset
3572 //Initialize mouse events for interaction
3575 //We're ready to go
3578 },
3587 }
3590 },
3598 // Don't call widget base _setOption for disable as it adds ui-state-disabled class
3600 }
3601 },
3610 }
3614 }
3616 //We have to refresh the items data once first
3619 //Find out if the clicked node (or one of its parents) is a actual item in this.items
3624 }
3625 });
3628 }
3632 }
3637 }
3638 });
3641 }
3642 }
3648 },
3657 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
3660 //Create and append the visible helper
3663 //Cache the helper size
3666 /*
3667 * - Position generation -
3668 * This block generates everything position related - it's the core of draggables.
3669 */
3671 //Cache the margins of the original element
3674 //Get the next scrolling parent
3677 //The element's absolute position on the page minus margins
3682 };
3688 },
3690 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
3691 });
3693 // Only after we got the offset, we can change the helper's position to absolute
3694 // TODO: Still need to figure out a way to make relative sorting possible
3698 //Generate the original position
3703 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
3706 //Cache the former DOM position
3709 //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
3712 }
3714 //Create the placeholder
3717 //Set a containment if given in the options
3720 }
3725 // support: IE
3729 this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
3730 }
3735 }
3737 }
3742 }
3744 }
3746 //Prepare scrolling
3749 }
3751 //Call callbacks
3754 //Recache the helper size
3757 }
3760 //Post "activate" events to possible containers
3764 }
3765 }
3767 //Prepare possible droppables
3770 }
3774 }
3779 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
3782 },
3789 //Compute the helpers position
3795 }
3797 //Do scrolling
3801 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
3805 }
3807 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
3811 }
3817 } else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
3819 }
3823 } else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
3825 }
3827 }
3831 }
3832 }
3834 //Regenerate the absolute position used for position checks
3837 //Set the helper position
3840 }
3843 }
3845 //Rearrange
3848 //Cache variables and intersection, continue if no intersection
3854 }
3856 // Only put the placeholder inside the current Container, skip all
3857 // items form other containers. This works because when moving
3858 // an item from one container to another the
3859 // currentContainer is switched before the placeholder is moved.
3860 //
3861 // Without this moving items in "sub-sortables" can cause the placeholder to jitter
3862 // beetween the outer and inner container.
3865 }
3867 // cannot intersect with itself
3868 // no useless actions that have been done before
3869 // no action if the item moved is the parent of the item checked
3874 ) {
3882 }
3886 }
3887 }
3889 //Post events to containers
3892 //Interconnect with droppables
3895 }
3897 //Call callbacks
3903 },
3909 }
3911 //If we are using droppables, inform the manager about the drop
3914 }
3920 animation = {};
3923 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
3924 }
3926 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
3927 }
3931 });
3934 }
3938 },
3950 }
3952 //Post deactivating events to containers
3958 }
3959 }
3961 }
3964 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3967 }
3970 }
3977 });
3983 }
3984 }
3988 },
3993 str = [];
3997 var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
4000 }
4001 });
4005 }
4009 },
4014 ret = [];
4021 },
4023 /* Be careful with the following core functions */
4036 isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
4037 isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
4042 (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
4043 ) {
4052 }
4053 },
4057 var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
4058 isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
4065 }
4068 ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
4071 },
4075 var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
4076 isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
4081 return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
4083 return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
4084 }
4086 },
4091 },
4096 },
4102 },
4106 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
4107 },
4112 items = [],
4113 queries = [],
4122 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]);
4123 }
4124 }
4125 }
4126 }
4128 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]);
4133 });
4134 }
4138 },
4148 }
4149 }
4151 });
4153 },
4162 queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
4165 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
4171 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
4173 }
4174 }
4175 }
4176 }
4192 });
4193 }
4194 }
4196 },
4200 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
4203 }
4210 //We ignore calculating positions of all connected containers when we're not over them
4211 if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
4213 }
4220 }
4225 }
4236 }
4237 }
4240 },
4262 });
4265 }
4269 }
4272 },
4275 // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
4276 // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
4279 }
4281 //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
4282 if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
4283 if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
4284 }
4285 };
4286 }
4288 //Create the placeholder
4291 //Append it after the actual current item
4294 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
4297 },
4300 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, base, cur, nearBottom, floating,
4304 // get innermost container that intersects with item
4307 // never consider a container that's located within the item itself
4310 }
4314 // if we've already found a container and it's more "inner" than this, then continue
4315 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
4317 }
4323 // container doesn't intersect. trigger "out" event if necessary
4327 }
4328 }
4330 }
4332 // if no intersecting containers found, return
4335 }
4337 // move the item into the container if it's not there already
4342 }
4345 //When entering a new container, we will find the item with the least distance and append our item near it
4355 }
4358 }
4359 if (floating && !isOverAxis(this.positionAbs.top + this.offset.click.top, this.items[j].top, this.items[j].height)) {
4361 }
4367 }
4372 }
4373 }
4375 //Check if dropOnEmpty is enabled
4378 }
4382 }
4384 itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
4389 //Update the placeholder
4394 }
4397 },
4402 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
4404 //Add the helper to the DOM if that didn't happen already
4406 $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
4407 }
4410 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") };
4411 }
4415 }
4418 }
4422 },
4427 }
4430 }
4433 }
4436 }
4439 }
4442 }
4443 },
4448 //Get the offsetParent and cache its position
4452 // This is a special case where we need to modify a offset calculated on start, since the following happened:
4453 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
4454 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
4455 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
4456 if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
4459 }
4461 // This needs to be actually done for all browsers, since pageX/pageY includes this information
4462 // with an ugly IE fix
4463 if( this.offsetParent[0] === document.body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
4465 }
4470 };
4472 },
4481 };
4484 }
4486 },
4492 };
4493 },
4499 };
4500 },
4508 }
4513 $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
4514 ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
4515 ];
4516 }
4524 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
4525 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
4526 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,
4527 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
4528 ];
4529 }
4531 },
4537 }
4539 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
4543 top: (
4545 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
4547 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
4548 ),
4549 left: (
4551 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
4553 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
4554 )
4555 };
4557 },
4565 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);
4567 // This is another very weird special case that only happens for relative elements:
4568 // 1. If the css position is relative
4569 // 2. and the scroll parent is the document or similar to the offset parent
4570 // we have to refresh the relative offset during the scroll so there are no jumps
4571 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== document && this.scrollParent[0] !== this.offsetParent[0])) {
4573 }
4575 /*
4576 * - Position constraining -
4577 * Constrain the position to a mix of grid, containment.
4578 */
4585 }
4588 }
4591 }
4594 }
4595 }
4599 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;
4602 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;
4603 }
4605 }
4608 top: (
4611 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
4613 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
4614 ),
4615 left: (
4618 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
4620 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
4621 )
4622 };
4624 },
4628 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));
4630 //Various things done here to improve the performance:
4631 // 1. we create a setTimeout, that calls refreshPositions
4632 // 2. on the instance, we have a counter variable, that get's higher after every append
4633 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
4634 // 4. this lets only the last addition to the timeout stack through
4641 }
4642 });
4644 },
4649 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
4650 // everything else normalized again
4652 delayedTriggers = [];
4654 // We first have to update the dom position of the actual currentItem
4655 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
4658 }
4665 }
4666 }
4670 }
4673 delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
4674 }
4675 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
4676 delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
4677 }
4679 // Check if the items Container has Changed and trigger appropriate
4680 // events.
4684 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
4685 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
4686 }
4687 }
4690 //Post events to containers
4693 delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); }; }).call(this, this.containers[i]));
4694 }
4696 delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); }; }).call(this, this.containers[i]));
4698 }
4699 }
4701 //Do what was originally in plugins
4705 }
4708 }
4711 }
4721 }
4725 }
4729 }
4731 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
4736 }
4744 }
4749 },
4754 }
4755 },
4767 };
4768 }
4770 });
4779 effect: {}
4780 };
4782 /*!
4783 * jQuery Color Animations v2.1.2
4784 * https://github.com/jquery/jquery-color
4785 *
4786 * Copyright 2013 jQuery Foundation and other contributors
4787 * Released under the MIT license.
4788 * http://jquery.org/license
4789 *
4790 * Date: Wed Jan 16 08:47:09 2013 -0600
4791 */
4794 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
4796 // plusequals test for += 100 -= 100
4798 // a set of RE's that can match strings and generate color tuples.
4799 stringParsers = [{
4807 ];
4808 }
4809 }, {
4810 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4817 ];
4818 }
4819 }, {
4820 // this regex ignores A-F because it's compared against an already lowercased string
4827 ];
4828 }
4829 }, {
4830 // this regex ignores A-F because it's compared against an already lowercased string
4837 ];
4838 }
4839 }, {
4840 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
4848 ];
4849 }
4850 }],
4852 // jQuery.Color( )
4855 },
4856 spaces = {
4857 rgba: {
4858 props: {
4859 red: {
4862 },
4863 green: {
4866 },
4867 blue: {
4870 }
4871 }
4872 },
4874 hsla: {
4875 props: {
4876 hue: {
4879 },
4880 saturation: {
4883 },
4884 lightness: {
4887 }
4888 }
4889 }
4890 },
4891 propTypes = {
4895 },
4898 },
4902 }
4903 },
4906 // element for support tests
4909 // colors = jQuery.Color.names
4910 colors,
4912 // local aliases of functions called often
4915 // determine rgba support immediately
4919 // define cache name and alpha properties
4920 // for rgba and hsla spaces
4927 };
4928 });
4935 }
4937 // ~~ is an short way of doing floor for positive numbers
4940 // IE will pass in empty strings as value for alpha,
4941 // which will hit this case
4944 }
4947 // we add mod before modding to make sure that negatives values
4948 // get converted properly: -10 -> 350
4950 }
4952 // for now all property types without mod have min and max
4954 }
4971 // if this was an rgba parse the assignment might happen twice
4972 // oh well....
4976 // exit each( stringParsers ) here because we matched
4978 }
4979 });
4981 // Found a stringParser that handled it
4984 // if this came from a parsed string, force "transparent" when alpha is 0
4985 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
4988 }
4990 }
4992 // named colors
4994 }
5001 }
5005 }
5011 // more than 1 argument specified - assume ( red, green, blue, alpha )
5015 }
5019 }
5024 });
5026 }
5033 }
5034 });
5040 // if the cache doesn't exist, and we know how to convert
5043 // if the value was null, we don't need to copy it
5044 // if the key was alpha, we don't need to copy it either
5047 }
5049 }
5051 // this is the only case where we allow nulls for ALL properties.
5052 // call clamp with alwaysAllowEmpty
5054 });
5056 // everything defined but alpha?
5058 // use the default of 1
5062 }
5063 }
5064 });
5065 }
5067 }
5068 },
5083 }
5084 });
5085 }
5087 });
5089 },
5096 }
5097 });
5099 },
5115 // if null, don't override start value
5118 }
5119 // if null - use end
5128 }
5129 }
5131 }
5132 });
5134 },
5136 // if we are already opaque - return ourself
5139 }
5147 }));
5148 },
5153 });
5158 }
5161 },
5167 }
5169 // catch 1 and 2
5172 }
5174 });
5179 }
5181 },
5188 }
5192 // default to 0 when nulls exist
5196 },
5199 }
5200 });
5203 // hsla conversions adapted from:
5204 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
5210 }
5213 }
5216 }
5218 }
5223 }
5243 }
5245 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
5246 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
5253 }
5255 };
5260 }
5272 a
5273 ];
5274 };
5283 // makes rgba() and hsla()
5286 // generate a cache for this space if it doesn't exist
5289 }
5292 }
5303 }
5305 });
5313 }
5314 };
5316 // makes red() green() blue() alpha() hue() saturation() lightness()
5318 // alpha is included in more than one space
5321 }
5327 match;
5331 }
5336 }
5339 }
5344 }
5345 }
5348 };
5349 });
5350 });
5352 // add cssHook and .fx.step function for each named hook.
5353 // accept a space separated string of properties
5362 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
5369 ) {
5374 }
5375 }
5378 backgroundColor :
5380 }
5383 }
5387 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
5388 }
5389 }
5390 };
5396 }
5398 };
5399 });
5401 };
5411 });
5413 }
5414 };
5416 // Basic color names only.
5417 // Usage of any of the other color names requires adding yourself or including
5418 // jquery.color.svg-names.js.
5420 // 4.1. Basic color keywords
5438 // 4.2.3. "transparent" color keyword
5442 };
5447 /******************************************************************************/
5448 /****************************** CLASS ANIMATIONS ******************************/
5449 /******************************************************************************/
5453 shorthandStyles = {
5463 };
5465 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
5470 }
5471 };
5472 });
5479 styles = {};
5487 }
5488 }
5489 // support: Opera, IE <9
5494 }
5495 }
5496 }
5499 }
5512 }
5513 }
5514 }
5515 }
5518 }
5520 // support: jQuery <1.8
5525 );
5526 };
5527 }
5535 applyClassChange,
5538 // map the animated objects to store the original styles.
5544 };
5545 });
5547 // apply class change
5552 }
5553 });
5554 };
5557 // map all animated objects again - calculate new styles and diff
5562 });
5564 // apply original class
5567 // map all animated objects again - this time collecting a promise
5575 }
5576 });
5580 });
5582 // once all animations have completed:
5585 // set the final class
5588 // for each animated element,
5589 // clear all css properties that were animated
5594 });
5595 });
5597 // this is guarnteed to be there if you use jQuery.speed()
5598 // it also handles dequeuing the next anim...
5600 });
5601 });
5602 };
5611 };
5620 };
5627 // without speed parameter
5633 }
5635 // without force parameter
5638 }
5639 };
5645 remove: remove
5647 }
5648 });
5650 })();
5652 /******************************************************************************/
5653 /*********************************** EFFECTS **********************************/
5654 /******************************************************************************/
5661 // Saves a set of properties in a data storage
5666 }
5667 }
5668 },
5670 // Restores a set of previously saved properties from a data storage
5676 // support: jQuery 1.6.2
5677 // http://bugs.jquery.com/ticket/9917
5678 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
5679 // We can't differentiate between "" and 0 here, so we just assume
5680 // empty string since it's likely to be a more common value...
5683 }
5685 }
5686 }
5687 },
5692 }
5694 },
5696 // Translates a [top,left] array into a baseline value
5697 // this should be a little more flexible in the future to handle a string & hash
5705 }
5711 }
5714 y: y
5715 };
5716 },
5718 // Wraps the element around a wrapper that copies position properties
5721 // if the element is already wrapped, return it
5724 }
5726 // wrap the element
5731 },
5740 }),
5741 // Store the size in case width/height are defined in % - Fixes #5245
5742 size = {
5745 },
5748 // support: Firefox
5749 // Firefox incorrectly exposes anonymous content
5750 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
5755 }
5759 // Fixes #7595 - Elements lose focus when wrapped.
5762 }
5764 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
5766 // transfer positioning properties to the wrapper
5774 });
5779 }
5780 });
5787 });
5788 }
5792 },
5800 // Fixes #7595 - Elements lose focus when wrapped.
5803 }
5804 }
5808 },
5816 }
5817 });
5819 }
5820 });
5822 // return an effect options object for the given parameters:
5825 // allow passing all options as the first parameter
5829 }
5831 // convert to an object
5834 // catch (effect, null, ...)
5836 options = {};
5837 }
5839 // catch (effect, callback)
5843 options = {};
5844 }
5846 // catch (effect, speed, ?)
5850 options = {};
5851 }
5853 // catch (effect, options, callback)
5857 }
5859 // add options to effect
5862 }
5873 }
5876 // Valid standard speeds (nothing, number, named speed)
5879 }
5881 // Invalid strings - treat as "normal" speed
5884 }
5886 // Complete callback
5889 }
5891 // Options hash (but not naming an effect)
5894 }
5896 // Didn't match any standard API
5898 }
5908 // delegate to the original method (e.g., .show()) if possible
5915 }
5916 });
5917 }
5918 }
5928 }
5931 }
5932 }
5934 // If the element already has the correct final state, delegate to
5935 // the core methods so the internal tracking of "olddisplay" works.
5941 }
5942 }
5945 },
5955 }
5956 };
5967 }
5968 };
5979 }
5980 };
5983 // helper functions
5986 val = [];
5991 }
5992 });
5994 }
5995 });
5997 })();
5999 /******************************************************************************/
6000 /*********************************** EASING ***********************************/
6001 /******************************************************************************/
6005 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
6012 };
6013 });
6018 },
6021 },
6025 },
6028 },
6035 }
6036 });
6042 };
6047 };
6048 });
6050 })();
6057 hideProps = {},
6058 showProps = {};
6067 options: {
6069 animate: {},
6074 icons: {
6077 },
6079 // callbacks
6082 },
6088 // ARIA
6091 // don't allow collapsible: false and active: false / null
6094 }
6097 // handle negative values
6100 }
6102 },
6109 };
6110 },
6122 }
6123 },
6130 },
6135 // clean up main element
6140 // clean up headers
6142 .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" )
6150 }
6151 });
6154 // clean up content panels
6161 .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled" )
6165 }
6166 });
6169 }
6170 },
6174 // _activate() will handle invalid values and update this.options
6177 }
6182 }
6184 }
6188 // setting collapsible: false while collapsed; open first panel
6191 }
6197 }
6198 }
6200 // #5332 - opacity doesn't cascade to positioned elements in IE
6201 // so we need to add the disabled class to the headers and panels
6205 }
6206 },
6209 /*jshint maxcomplexity:15*/
6212 }
6238 }
6245 }
6246 },
6251 }
6252 },
6258 // was collapsed or no panel
6262 // active false only when collapsible is true
6265 // was active, but active panel is gone
6267 // all remaining panel are disabled
6271 // activate previous panel
6274 }
6275 // was active, active panel still exists
6277 // make sure active index is correct
6279 }
6284 },
6294 },
6321 }
6325 }
6328 })
6337 })
6342 })
6345 // make sure at least one header is in the tab order
6352 })
6357 });
6358 }
6372 }
6374 });
6378 });
6384 })
6391 })
6393 }
6394 },
6399 // trying to activate the already active panel
6402 }
6404 // trying to collapse, simulate a click on the currently active header
6410 preventDefault: $.noop
6411 });
6412 },
6416 },
6421 };
6425 });
6426 }
6433 },
6443 eventData = {
6447 newPanel: toShow
6448 };
6453 // click on active header, but not collapsible
6455 // allow canceling activation
6458 }
6462 // when the call to ._toggle() comes after the class changes
6463 // it causes a very odd bug in IE 8 (see #6720)
6467 // switch classes
6468 // corner classes on the previously active header stay after the animation
6474 }
6477 clicked
6484 }
6486 clicked
6489 }
6490 },
6496 // handle activating a panel during the animation for another activation
6507 }
6512 });
6514 // if we're switching panels, remove the old header from the tab order
6515 // if we're opening from collapsed state, remove the previous header from the tab order
6516 // if we're collapsing, then keep the collapsing header in the tab order
6522 })
6524 }
6526 toShow
6530 })
6535 });
6536 },
6548 };
6552 }
6555 }
6556 // fall back from options to animation in case of partial down settings
6562 }
6565 }
6573 }
6574 });
6575 toShow
6588 }
6589 }
6590 });
6591 },
6596 toHide
6602 // Work around for rendering bug in IE (#5421)
6605 }
6608 }
6609 });
6615 // used to prevent race conditions with remote data sources
6621 options: {
6626 position: {
6630 },
6633 // callbacks
6641 },
6646 // Some browsers only repeat keydown events, not keypress events,
6647 // so we use the suppressKeyPress flag to determine if we've already
6648 // handled the keydown event. #7269
6649 // Unfortunately the code for & in keypress is the same as the up arrow,
6650 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
6651 // events when we know the keydown event was used to modify the
6652 // search term. #7799
6659 // Textareas are always multi-line
6661 // Inputs are always single-line, even if inside a contentEditable element
6662 // IE also treats inputs as contentEditable
6664 // All other element types are determined by whether or not they're contentEditable
6676 /*jshint maxcomplexity:15*/
6682 }
6707 // when menu is open and has focus
6709 // #6055 - Opera still allows the keypress to occur
6710 // which causes forms to submit
6714 }
6719 }
6725 // Different browsers have different default behavior for escape
6726 // Single press can mean undo or clear
6727 // Double press in IE means clear the whole form
6729 }
6733 // search timeout should be triggered before the input value is changed
6736 }
6737 },
6743 }
6745 }
6748 }
6750 // replicate some key handlers to allow them to repeat in Firefox and Opera
6765 }
6766 },
6772 }
6774 },
6778 },
6783 }
6788 }
6789 });
6796 // disable ARIA support, the live region takes care of that
6798 })
6804 // prevent moving focus out of the text field
6807 // IE doesn't prevent moving focus even with event.preventDefault()
6808 // so we set a flag to know when we should ignore the blur event
6812 });
6814 // clicking on the scrollbar causes focus to shift to the body
6815 // but we can't detect a mouseup or a click immediately afterward
6816 // so we have to track the next mousedown and close the menu if
6817 // the user clicks somewhere outside of the autocomplete
6827 }
6828 });
6829 });
6830 }
6831 },
6833 // support: Firefox
6834 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
6842 });
6845 }
6846 }
6850 // use value to match what will end up in the input, if it was a key event
6853 }
6855 // Normally the input is populated with the item's value as the
6856 // menu is navigated, causing screen readers to notice a change and
6857 // announce the item. Since the focus event was canceled, this doesn't
6858 // happen, so we update the live region so that screen readers can
6859 // still notice the change and announce it.
6861 }
6862 },
6867 // only trigger when focus was lost (click on menu)
6871 // #6109 - IE triggers two focus events and the second
6872 // is asynchronous, so we need to reset the previous
6873 // term synchronously and asynchronously :-(
6877 });
6878 }
6882 }
6883 // reset the term after the select event
6884 // this allows custom select handling to work properly
6889 }
6890 });
6895 })
6899 // turning off autocomplete prevents the browser from remembering the
6900 // value when navigating through history, so we re-enable autocomplete
6901 // if the page is unloaded before the widget is destroyed. #7790
6905 }
6906 });
6907 },
6916 },
6922 }
6925 }
6928 }
6929 },
6938 }
6942 }
6946 }
6949 },
6958 };
6964 }
6971 },
6974 }
6975 });
6976 };
6979 }
6980 },
6985 // only search if the value has changed
6989 }
6991 },
6996 // always save the actual value, not the one passed as an argument
7001 }
7005 }
7008 },
7016 },
7025 }
7030 }
7031 };
7032 },
7037 }
7043 // use ._close() instead of .close() so we don't cancel future searches
7045 }
7046 },
7051 },
7059 }
7060 },
7065 }
7066 },
7069 // assume all items have the right format when the first item is complete
7072 }
7077 value: item
7078 };
7079 }
7084 });
7085 },
7093 // size and position menu
7102 }
7103 },
7108 // Firefox wraps long text (possibly a rounding bug)
7109 // so we add 1px to avoid the wrapping (#7513)
7112 ) );
7113 },
7119 });
7120 },
7124 },
7130 },
7136 }
7142 }
7144 },
7148 },
7152 },
7158 // prevents moving cursor to beginning/end of the text field in some browsers
7160 }
7161 }
7162 });
7167 },
7172 });
7173 }
7174 });
7177 // live region extension, adding a `messages` option
7178 // NOTE: This is an experimental API. We are still investigating
7179 // a full solution for string manipulation and internationalization.
7181 options: {
7182 messages: {
7187 }
7188 }
7189 },
7196 }
7201 }
7203 }
7204 });
7213 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",
7219 },
7223 radios = $( [] );
7226 if ( form ) {
7228 } else {
7230 .filter(function() {
7231 return !this.form;
7232 });
7233 }
7234 }
7235 return radios;
7236 };
7241 options: {
7242 disabled: null,
7243 text: true,
7244 label: null,
7245 icons: {
7246 primary: null,
7247 secondary: null
7248 }
7249 },
7250 _create: function() {
7257 } else {
7259 }
7261 this._determineButtonType();
7264 var that = this,
7265 options = this.options,
7270 if ( options.label === null ) {
7271 options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
7272 }
7274 this._hoverable( this.buttonElement );
7276 this.buttonElement
7277 .addClass( baseClasses )
7280 if ( options.disabled ) {
7281 return;
7282 }
7283 if ( this === lastActive ) {
7285 }
7286 })
7288 if ( options.disabled ) {
7289 return;
7290 }
7291 $( this ).removeClass( activeClass );
7292 })
7294 if ( options.disabled ) {
7295 event.preventDefault();
7296 event.stopImmediatePropagation();
7297 }
7298 });
7300 this.element
7302 // no need to check disabled, focus won't be triggered anyway
7303 that.buttonElement.addClass( focusClass );
7304 })
7306 that.buttonElement.removeClass( focusClass );
7307 });
7309 if ( toggleButton ) {
7311 if ( clickDragged ) {
7312 return;
7313 }
7314 that.refresh();
7315 });
7316 // if mouse moves between mousedown and mouseup (drag) set clickDragged flag
7317 // prevents issue where button state changes but checkbox/radio checked state
7318 // does not in Firefox (see ticket #6970)
7319 this.buttonElement
7321 if ( options.disabled ) {
7322 return;
7323 }
7324 clickDragged = false;
7325 startXPos = event.pageX;
7326 startYPos = event.pageY;
7327 })
7329 if ( options.disabled ) {
7330 return;
7331 }
7332 if ( startXPos !== event.pageX || startYPos !== event.pageY ) {
7333 clickDragged = true;
7334 }
7335 });
7336 }
7340 if ( options.disabled || clickDragged ) {
7341 return false;
7342 }
7343 });
7346 if ( options.disabled || clickDragged ) {
7347 return false;
7348 }
7352 var radio = that.element[ 0 ];
7353 radioGroup( radio )
7354 .not( radio )
7355 .map(function() {
7357 })
7360 });
7361 } else {
7362 this.buttonElement
7364 if ( options.disabled ) {
7365 return false;
7366 }
7368 lastActive = this;
7370 lastActive = null;
7371 });
7372 })
7374 if ( options.disabled ) {
7375 return false;
7376 }
7378 })
7380 if ( options.disabled ) {
7381 return false;
7382 }
7383 if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
7385 }
7386 })
7387 // see #8559, we bind to blur here in case the button element loses
7391 });
7394 this.buttonElement.keyup(function(event) {
7395 if ( event.keyCode === $.ui.keyCode.SPACE ) {
7396 // TODO pass through original event correctly (just as 2nd argument doesn't work)
7397 $( this ).click();
7398 }
7399 });
7400 }
7401 }
7403 // TODO: pull out $.Widget's handling for the disabled option into
7404 // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
7405 // be overridden by individual plugins
7407 this._resetButton();
7408 },
7410 _determineButtonType: function() {
7411 var ancestor, labelSelector, checked;
7419 } else {
7421 }
7424 // we don't search against the document in case the element
7425 // is disconnected from the DOM
7426 ancestor = this.element.parents().last();
7428 this.buttonElement = ancestor.find( labelSelector );
7429 if ( !this.buttonElement.length ) {
7430 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
7431 this.buttonElement = ancestor.filter( labelSelector );
7432 if ( !this.buttonElement.length ) {
7433 this.buttonElement = ancestor.find( labelSelector );
7434 }
7435 }
7439 if ( checked ) {
7441 }
7443 } else {
7444 this.buttonElement = this.element;
7445 }
7446 },
7448 widget: function() {
7449 return this.buttonElement;
7450 },
7452 _destroy: function() {
7453 this.element
7455 this.buttonElement
7461 if ( !this.hasTitle ) {
7463 }
7464 },
7466 _setOption: function( key, value ) {
7467 this._super( key, value );
7469 if ( value ) {
7471 } else {
7473 }
7474 return;
7475 }
7476 this._resetButton();
7477 },
7479 refresh: function() {
7480 //See #8237 & #8828
7481 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
7483 if ( isDisabled !== this.options.disabled ) {
7485 }
7487 radioGroup( this.element[0] ).each(function() {
7492 } else {
7496 }
7497 });
7500 this.buttonElement
7503 } else {
7504 this.buttonElement
7507 }
7508 }
7509 },
7511 _resetButton: function() {
7513 if ( this.options.label ) {
7514 this.element.val( this.options.label );
7515 }
7516 return;
7517 }
7518 var buttonElement = this.buttonElement.removeClass( typeClasses ),
7521 .html( this.options.label )
7522 .appendTo( buttonElement.empty() )
7523 .text(),
7524 icons = this.options.icons,
7525 multipleIcons = icons.primary && icons.secondary,
7526 buttonClasses = [];
7528 if ( icons.primary || icons.secondary ) {
7529 if ( this.options.text ) {
7530 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
7531 }
7533 if ( icons.primary ) {
7534 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
7535 }
7537 if ( icons.secondary ) {
7538 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
7539 }
7541 if ( !this.options.text ) {
7544 if ( !this.hasTitle ) {
7546 }
7547 }
7548 } else {
7550 }
7552 }
7553 });
7557 options: {
7558 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
7559 },
7561 _create: function() {
7563 },
7565 _init: function() {
7566 this.refresh();
7567 },
7569 _setOption: function( key, value ) {
7572 }
7574 this._super( key, value );
7575 },
7577 refresh: function() {
7580 this.buttons = this.element.find( this.options.items )
7583 .end()
7585 .button()
7586 .end()
7587 .map(function() {
7589 })
7593 .end()
7596 .end()
7597 .end();
7598 },
7600 _destroy: function() {
7602 this.buttons
7603 .map(function() {
7605 })
7607 .end()
7609 }
7610 });
7612 }( jQuery ) );
7614 (function( $, undefined ) {
7619 instActive;
7621 /* Date picker manager.
7622 Use the singleton instance of this class, $.datepicker, to interact with the date picker.
7623 Settings for (groups of) date pickers are maintained in an instance object,
7624 allowing multiple different settings on the same page. */
7626 function Datepicker() {
7627 this._curInst = null; // The current instance in use
7628 this._keyEvent = false; // If the last event was a key event
7629 this._disabledInputs = []; // List of date picker inputs that have been disabled
7630 this._datepickerShowing = false; // True if the popup picker is showing , false if not
7637 this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
7638 this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
7641 this.regional = []; // Available regional settings, indexed by language code
7648 "July","August","September","October","November","December"], // Names of months for drop-down and formatting
7649 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
7650 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
7652 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
7655 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
7656 isRTL: false, // True if right-to-left language, false if left-to-right
7657 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
7659 };
7660 this._defaults = { // Global defaults for all the date picker instances
7664 showOptions: {}, // Options for enhanced animations
7665 defaultDate: null, // Used when field is blank: actual date,
7666 // +/-number for offset from today, null for today
7670 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
7671 hideIfNoPrevNext: false, // True to hide next/previous month links
7672 // if not applicable, false to just disable them
7673 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
7674 gotoCurrent: false, // True if today link goes back to current selection instead
7675 changeMonth: false, // True if month can be selected directly, false if only prev/next
7676 changeYear: false, // True if year can be selected directly, false if only prev/next
7678 // either relative to today's year (-nn:+nn), relative to currently displayed year
7679 // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
7680 showOtherMonths: false, // True to show dates in other months, false to leave blank
7681 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
7682 showWeek: false, // True to show week of the year, false to not show it
7683 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
7684 // takes a Date and returns the number of the week for it
7686 // > this are in the previous century,
7688 minDate: null, // The earliest selectable date, or null for no limit
7689 maxDate: null, // The latest selectable date, or null for no limit
7691 beforeShowDay: null, // Function that takes a date and returns an array with
7693 // [2] = cell title (optional), e.g. $.datepicker.noWeekends
7694 beforeShow: null, // Function that takes an input field and
7695 // returns a set of custom settings for the date picker
7696 onSelect: null, // Define a callback function when a date is selected
7697 onChangeMonthYear: null, // Define a callback function when the month or year is changed
7698 onClose: null, // Define a callback function when the datepicker is closed
7699 numberOfMonths: 1, // Number of months to show at a time
7700 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
7701 stepMonths: 1, // Number of months to step back/forward
7702 stepBigMonths: 12, // Number of months to step back/forward for the big links
7705 constrainInput: true, // The input is constrained by the current date format
7706 showButtonPanel: false, // True to show button panel, false to not show it
7707 autoSize: false, // True to size the input for the date format, false to leave as is
7708 disabled: false // The initial disabled state
7709 };
7711 this.dpDiv = bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
7712 }
7714 $.extend(Datepicker.prototype, {
7715 /* Class name added to elements to indicate already configured with a date picker. */
7718 //Keep track of the maximum number of rows displayed (see #7043)
7719 maxRows: 4,
7722 _widgetDatepicker: function() {
7723 return this.dpDiv;
7724 },
7726 /* Override the default settings for all instances of the date picker.
7727 * @param settings object - the new settings to use as defaults (anonymous object)
7728 * @return the manager object
7729 */
7730 setDefaults: function(settings) {
7731 extendRemove(this._defaults, settings || {});
7732 return this;
7733 },
7735 /* Attach the date picker to a jQuery selection.
7736 * @param target element - the target input field or division or span
7737 * @param settings object - the new settings to use for this date picker instance (anonymous)
7738 */
7739 _attachDatepicker: function(target, settings) {
7740 var nodeName, inline, inst;
7741 nodeName = target.nodeName.toLowerCase();
7743 if (!target.id) {
7744 this.uuid += 1;
7746 }
7747 inst = this._newInst($(target), inline);
7748 inst.settings = $.extend({}, settings || {});
7750 this._connectDatepicker(target, inst);
7751 } else if (inline) {
7752 this._inlineDatepicker(target, inst);
7753 }
7754 },
7756 /* Create a new instance object. */
7757 _newInst: function(target, inline) {
7759 return {id: id, input: target, // associated target
7760 selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
7761 drawMonth: 0, drawYear: 0, // month being drawn
7762 inline: inline, // is datepicker inline or not
7763 dpDiv: (!inline ? this.dpDiv : // presentation div
7764 bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
7765 },
7767 /* Attach the date picker to an input field. */
7768 _connectDatepicker: function(target, inst) {
7769 var input = $(target);
7770 inst.append = $([]);
7771 inst.trigger = $([]);
7772 if (input.hasClass(this.markerClassName)) {
7773 return;
7774 }
7775 this._attachments(input, inst);
7776 input.addClass(this.markerClassName).keydown(this._doKeyDown).
7777 keypress(this._doKeyPress).keyup(this._doKeyUp);
7778 this._autoSize(inst);
7779 $.data(target, PROP_NAME, inst);
7780 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
7781 if( inst.settings.disabled ) {
7782 this._disableDatepicker( target );
7783 }
7784 },
7786 /* Make attachments based on settings. */
7787 _attachments: function(input, inst) {
7788 var showOn, buttonText, buttonImage,
7792 if (inst.append) {
7793 inst.append.remove();
7794 }
7795 if (appendText) {
7798 }
7802 if (inst.trigger) {
7803 inst.trigger.remove();
7804 }
7808 input.focus(this._showDatepicker);
7809 }
7815 attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
7818 { src:buttonImage, alt:buttonText, title:buttonText })));
7820 inst.trigger.click(function() {
7821 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
7822 $.datepicker._hideDatepicker();
7823 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
7824 $.datepicker._hideDatepicker();
7825 $.datepicker._showDatepicker(input[0]);
7826 } else {
7827 $.datepicker._showDatepicker(input[0]);
7828 }
7829 return false;
7830 });
7831 }
7832 },
7834 /* Apply the maximum length for the date format. */
7835 _autoSize: function(inst) {
7837 var findMax, max, maxI, i,
7838 date = new Date(2009, 12 - 1, 20), // Ensure double digits
7841 if (dateFormat.match(/[DM]/)) {
7842 findMax = function(names) {
7843 max = 0;
7844 maxI = 0;
7845 for (i = 0; i < names.length; i++) {
7846 if (names[i].length > max) {
7847 max = names[i].length;
7848 maxI = i;
7849 }
7850 }
7851 return maxI;
7852 };
7853 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
7855 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
7857 }
7859 }
7860 },
7862 /* Attach an inline date picker to a div. */
7863 _inlineDatepicker: function(target, inst) {
7864 var divSpan = $(target);
7865 if (divSpan.hasClass(this.markerClassName)) {
7866 return;
7867 }
7868 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
7869 $.data(target, PROP_NAME, inst);
7870 this._setDate(inst, this._getDefaultDate(inst), true);
7871 this._updateDatepicker(inst);
7872 this._updateAlternate(inst);
7873 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
7874 if( inst.settings.disabled ) {
7875 this._disableDatepicker( target );
7876 }
7877 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
7878 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
7880 },
7883 * @param input element - ignored
7884 * @param date string or Date - the initial date to display
7885 * @param onSelect function - the function to call when a date is selected
7886 * @param settings object - update the dialog date picker instance's settings (anonymous object)
7887 * @param pos int[2] - coordinates for the dialog's position within the screen or
7888 * event - with x/y coordinates or
7889 * leave empty for default (screen centre)
7890 * @return the manager object
7891 */
7892 _dialogDatepicker: function(input, date, onSelect, settings, pos) {
7893 var id, browserWidth, browserHeight, scrollX, scrollY,
7894 inst = this._dialogInst; // internal instance
7896 if (!inst) {
7897 this.uuid += 1;
7901 this._dialogInput.keydown(this._doKeyDown);
7903 inst = this._dialogInst = this._newInst(this._dialogInput, false);
7904 inst.settings = {};
7905 $.data(this._dialogInput[0], PROP_NAME, inst);
7906 }
7907 extendRemove(inst.settings, settings || {});
7908 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
7909 this._dialogInput.val(date);
7911 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
7912 if (!this._pos) {
7913 browserWidth = document.documentElement.clientWidth;
7914 browserHeight = document.documentElement.clientHeight;
7915 scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
7916 scrollY = document.documentElement.scrollTop || document.body.scrollTop;
7917 this._pos = // should use actual width/height below
7918 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
7919 }
7921 // move input on screen for focus, but hidden behind dialog
7923 inst.settings.onSelect = onSelect;
7924 this._inDialog = true;
7925 this.dpDiv.addClass(this._dialogClass);
7926 this._showDatepicker(this._dialogInput[0]);
7927 if ($.blockUI) {
7928 $.blockUI(this.dpDiv);
7929 }
7930 $.data(this._dialogInput[0], PROP_NAME, inst);
7931 return this;
7932 },
7934 /* Detach a datepicker from its control.
7935 * @param target element - the target input field or division or span
7936 */
7937 _destroyDatepicker: function(target) {
7938 var nodeName,
7939 $target = $(target),
7940 inst = $.data(target, PROP_NAME);
7942 if (!$target.hasClass(this.markerClassName)) {
7943 return;
7944 }
7946 nodeName = target.nodeName.toLowerCase();
7947 $.removeData(target, PROP_NAME);
7949 inst.append.remove();
7950 inst.trigger.remove();
7951 $target.removeClass(this.markerClassName).
7957 $target.removeClass(this.markerClassName).empty();
7958 }
7959 },
7961 /* Enable the date picker to a jQuery selection.
7962 * @param target element - the target input field or division or span
7963 */
7964 _enableDatepicker: function(target) {
7965 var nodeName, inline,
7966 $target = $(target),
7967 inst = $.data(target, PROP_NAME);
7969 if (!$target.hasClass(this.markerClassName)) {
7970 return;
7971 }
7973 nodeName = target.nodeName.toLowerCase();
7975 target.disabled = false;
7977 each(function() { this.disabled = false; }).end().
7984 }
7985 this._disabledInputs = $.map(this._disabledInputs,
7986 function(value) { return (value === target ? null : value); }); // delete entry
7987 },
7989 /* Disable the date picker to a jQuery selection.
7990 * @param target element - the target input field or division or span
7991 */
7992 _disableDatepicker: function(target) {
7993 var nodeName, inline,
7994 $target = $(target),
7995 inst = $.data(target, PROP_NAME);
7997 if (!$target.hasClass(this.markerClassName)) {
7998 return;
7999 }
8001 nodeName = target.nodeName.toLowerCase();
8003 target.disabled = true;
8005 each(function() { this.disabled = true; }).end().
8012 }
8013 this._disabledInputs = $.map(this._disabledInputs,
8014 function(value) { return (value === target ? null : value); }); // delete entry
8015 this._disabledInputs[this._disabledInputs.length] = target;
8016 },
8018 /* Is the first field in a jQuery collection disabled as a datepicker?
8019 * @param target element - the target input field or division or span
8020 * @return boolean - true if disabled, false if enabled
8021 */
8022 _isDisabledDatepicker: function(target) {
8023 if (!target) {
8024 return false;
8025 }
8026 for (var i = 0; i < this._disabledInputs.length; i++) {
8027 if (this._disabledInputs[i] === target) {
8028 return true;
8029 }
8030 }
8031 return false;
8032 },
8034 /* Retrieve the instance data for the target control.
8035 * @param target element - the target input field or division or span
8036 * @return object - the associated instance data
8037 * @throws error if a jQuery problem getting data
8038 */
8039 _getInst: function(target) {
8040 try {
8041 return $.data(target, PROP_NAME);
8042 }
8043 catch (err) {
8045 }
8046 },
8048 /* Update or retrieve the settings for a date picker attached to an input field or division.
8049 * @param target element - the target input field or division or span
8050 * @param name object - the new settings to update or
8051 * string - the name of the setting to change or retrieve,
8054 * @param value any - the new value for the setting
8055 * (omit if above is an object or to retrieve a value)
8056 */
8057 _optionDatepicker: function(target, name, value) {
8058 var settings, date, minDate, maxDate,
8059 inst = this._getInst(target);
8064 this._get(inst, name)) : null));
8065 }
8067 settings = name || {};
8069 settings = {};
8070 settings[name] = value;
8071 }
8073 if (inst) {
8074 if (this._curInst === inst) {
8075 this._hideDatepicker();
8076 }
8078 date = this._getDateDatepicker(target, true);
8081 extendRemove(inst.settings, settings);
8082 // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
8083 if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
8084 inst.settings.minDate = this._formatDate(inst, minDate);
8085 }
8086 if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
8087 inst.settings.maxDate = this._formatDate(inst, maxDate);
8088 }
8090 if ( settings.disabled ) {
8091 this._disableDatepicker(target);
8092 } else {
8093 this._enableDatepicker(target);
8094 }
8095 }
8096 this._attachments($(target), inst);
8097 this._autoSize(inst);
8098 this._setDate(inst, date);
8099 this._updateAlternate(inst);
8100 this._updateDatepicker(inst);
8101 }
8102 },
8104 // change method deprecated
8105 _changeDatepicker: function(target, name, value) {
8106 this._optionDatepicker(target, name, value);
8107 },
8109 /* Redraw the date picker attached to an input field or division.
8110 * @param target element - the target input field or division or span
8111 */
8112 _refreshDatepicker: function(target) {
8113 var inst = this._getInst(target);
8114 if (inst) {
8115 this._updateDatepicker(inst);
8116 }
8117 },
8119 /* Set the dates for a jQuery selection.
8120 * @param target element - the target input field or division or span
8121 * @param date Date - the new date
8122 */
8123 _setDateDatepicker: function(target, date) {
8124 var inst = this._getInst(target);
8125 if (inst) {
8126 this._setDate(inst, date);
8127 this._updateDatepicker(inst);
8128 this._updateAlternate(inst);
8129 }
8130 },
8132 /* Get the date(s) for the first entry in a jQuery selection.
8133 * @param target element - the target input field or division or span
8134 * @param noDefault boolean - true if no default date is to be used
8135 * @return Date - the current date
8136 */
8137 _getDateDatepicker: function(target, noDefault) {
8138 var inst = this._getInst(target);
8139 if (inst && !inst.inline) {
8140 this._setDateFromField(inst, noDefault);
8141 }
8142 return (inst ? this._getDate(inst) : null);
8143 },
8145 /* Handle keystrokes. */
8146 _doKeyDown: function(event) {
8147 var onSelect, dateStr, sel,
8148 inst = $.datepicker._getInst(event.target),
8149 handled = true,
8152 inst._keyEvent = true;
8153 if ($.datepicker._datepickerShowing) {
8154 switch (event.keyCode) {
8155 case 9: $.datepicker._hideDatepicker();
8156 handled = false;
8157 break; // hide on tab out
8160 if (sel[0]) {
8161 $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
8162 }
8165 if (onSelect) {
8166 dateStr = $.datepicker._formatDate(inst);
8168 // trigger custom callback
8169 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
8170 } else {
8171 $.datepicker._hideDatepicker();
8172 }
8174 return false; // don't submit the form
8175 case 27: $.datepicker._hideDatepicker();
8176 break; // hide on escape
8177 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8180 break; // previous month/year on page up/+ ctrl
8181 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8184 break; // next month/year on page down/+ ctrl
8185 case 35: if (event.ctrlKey || event.metaKey) {
8186 $.datepicker._clearDate(event.target);
8187 }
8188 handled = event.ctrlKey || event.metaKey;
8189 break; // clear on ctrl or command +end
8190 case 36: if (event.ctrlKey || event.metaKey) {
8191 $.datepicker._gotoToday(event.target);
8192 }
8193 handled = event.ctrlKey || event.metaKey;
8194 break; // current on ctrl or command +home
8195 case 37: if (event.ctrlKey || event.metaKey) {
8197 }
8198 handled = event.ctrlKey || event.metaKey;
8199 // -1 day on ctrl or command +left
8200 if (event.originalEvent.altKey) {
8201 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8204 }
8205 // next month/year on alt +left on Mac
8206 break;
8207 case 38: if (event.ctrlKey || event.metaKey) {
8209 }
8210 handled = event.ctrlKey || event.metaKey;
8211 break; // -1 week on ctrl or command +up
8212 case 39: if (event.ctrlKey || event.metaKey) {
8214 }
8215 handled = event.ctrlKey || event.metaKey;
8216 // +1 day on ctrl or command +right
8217 if (event.originalEvent.altKey) {
8218 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
8221 }
8222 // next month/year on alt +right
8223 break;
8224 case 40: if (event.ctrlKey || event.metaKey) {
8226 }
8227 handled = event.ctrlKey || event.metaKey;
8228 break; // +1 week on ctrl or command +down
8229 default: handled = false;
8230 }
8231 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
8232 $.datepicker._showDatepicker(this);
8233 } else {
8234 handled = false;
8235 }
8237 if (handled) {
8238 event.preventDefault();
8239 event.stopPropagation();
8240 }
8241 },
8243 /* Filter entered characters - based on date format. */
8244 _doKeyPress: function(event) {
8245 var chars, chr,
8246 inst = $.datepicker._getInst(event.target);
8250 chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
8252 }
8253 },
8255 /* Synchronise manual entry and field/alternate field. */
8256 _doKeyUp: function(event) {
8257 var date,
8258 inst = $.datepicker._getInst(event.target);
8260 if (inst.input.val() !== inst.lastVal) {
8261 try {
8263 (inst.input ? inst.input.val() : null),
8264 $.datepicker._getFormatConfig(inst));
8266 if (date) { // only if valid
8267 $.datepicker._setDateFromField(inst);
8268 $.datepicker._updateAlternate(inst);
8269 $.datepicker._updateDatepicker(inst);
8270 }
8271 }
8272 catch (err) {
8273 }
8274 }
8275 return true;
8276 },
8278 /* Pop-up the date picker for a given input field.
8279 * If false returned from beforeShow event handler do not show.
8280 * @param input element - the input field attached to the date picker or
8281 * event - if triggered by focus
8282 */
8283 _showDatepicker: function(input) {
8284 input = input.target || input;
8287 }
8289 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
8290 return;
8291 }
8293 var inst, beforeShow, beforeShowSettings, isFixed,
8294 offset, showAnim, duration;
8296 inst = $.datepicker._getInst(input);
8297 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
8298 $.datepicker._curInst.dpDiv.stop(true, true);
8299 if ( inst && $.datepicker._datepickerShowing ) {
8300 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
8301 }
8302 }
8305 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
8306 if(beforeShowSettings === false){
8307 return;
8308 }
8309 extendRemove(inst.settings, beforeShowSettings);
8311 inst.lastVal = null;
8312 $.datepicker._lastInput = input;
8313 $.datepicker._setDateFromField(inst);
8315 if ($.datepicker._inDialog) { // hide cursor
8317 }
8318 if (!$.datepicker._pos) { // position below input
8319 $.datepicker._pos = $.datepicker._findPos(input);
8320 $.datepicker._pos[1] += input.offsetHeight; // add the height
8321 }
8323 isFixed = false;
8324 $(input).parents().each(function() {
8326 return !isFixed;
8327 });
8329 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
8330 $.datepicker._pos = null;
8331 //to avoid flashes on Firefox
8332 inst.dpDiv.empty();
8333 // determine sizing offscreen
8335 $.datepicker._updateDatepicker(inst);
8336 // fix width for dynamic number of date pickers
8337 // and adjust position before showing
8338 offset = $.datepicker._checkOffset(inst, offset, isFixed);
8339 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
8343 if (!inst.inline) {
8346 inst.dpDiv.zIndex($(input).zIndex()+1);
8347 $.datepicker._datepickerShowing = true;
8349 if ( $.effects && $.effects.effect[ showAnim ] ) {
8351 } else {
8353 }
8355 if ( $.datepicker._shouldFocusInput( inst ) ) {
8356 inst.input.focus();
8357 }
8359 $.datepicker._curInst = inst;
8360 }
8361 },
8363 /* Generate the date picker content. */
8364 _updateDatepicker: function(inst) {
8365 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
8366 instActive = inst; // for delegate hover events
8367 inst.dpDiv.empty().append(this._generateHTML(inst));
8368 this._attachHandlers(inst);
8371 var origyearshtml,
8372 numMonths = this._getNumberOfMonths(inst),
8373 cols = numMonths[1],
8374 width = 17;
8376 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
8377 if (cols > 1) {
8379 }
8385 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
8386 inst.input.focus();
8387 }
8389 // deffered render of the years select (to avoid flashes on Firefox)
8390 if( inst.yearshtml ){
8391 origyearshtml = inst.yearshtml;
8392 setTimeout(function(){
8393 //assure that inst.yearshtml didn't change.
8394 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
8396 }
8397 origyearshtml = inst.yearshtml = null;
8398 }, 0);
8399 }
8400 },
8402 // #6694 - don't focus the input if it's already focused
8403 // this breaks the change event in IE
8404 // Support: IE and jQuery <1.9
8405 _shouldFocusInput: function( inst ) {
8406 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
8407 },
8409 /* Check positioning to remain on screen. */
8410 _checkOffset: function(inst, offset, isFixed) {
8411 var dpWidth = inst.dpDiv.outerWidth(),
8412 dpHeight = inst.dpDiv.outerHeight(),
8413 inputWidth = inst.input ? inst.input.outerWidth() : 0,
8414 inputHeight = inst.input ? inst.input.outerHeight() : 0,
8415 viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
8416 viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
8419 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
8420 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
8422 // now check if datepicker is showing outside window viewport - move to a better place if so.
8423 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
8424 Math.abs(offset.left + dpWidth - viewWidth) : 0);
8425 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
8426 Math.abs(dpHeight + inputHeight) : 0);
8428 return offset;
8429 },
8431 /* Find an object's position on the screen. */
8432 _findPos: function(obj) {
8433 var position,
8434 inst = this._getInst(obj),
8439 }
8441 position = $(obj).offset();
8442 return [position.left, position.top];
8443 },
8445 /* Hide the date picker from view.
8446 * @param input element - the input field attached to the date picker
8447 */
8448 _hideDatepicker: function(input) {
8449 var showAnim, duration, postProcess, onClose,
8450 inst = this._curInst;
8452 if (!inst || (input && inst !== $.data(input, PROP_NAME))) {
8453 return;
8454 }
8456 if (this._datepickerShowing) {
8459 postProcess = function() {
8460 $.datepicker._tidyDialog(inst);
8461 };
8463 // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
8464 if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
8466 } else {
8469 }
8471 if (!showAnim) {
8472 postProcess();
8473 }
8474 this._datepickerShowing = false;
8477 if (onClose) {
8478 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
8479 }
8481 this._lastInput = null;
8482 if (this._inDialog) {
8484 if ($.blockUI) {
8485 $.unblockUI();
8487 }
8488 }
8489 this._inDialog = false;
8490 }
8491 },
8493 /* Tidy up after a dialog display. */
8494 _tidyDialog: function(inst) {
8496 },
8498 /* Close date picker if clicked elsewhere. */
8499 _checkExternalClick: function(event) {
8500 if (!$.datepicker._curInst) {
8501 return;
8502 }
8504 var $target = $(event.target),
8505 inst = $.datepicker._getInst($target[0]);
8507 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
8509 !$target.hasClass($.datepicker.markerClassName) &&
8511 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
8512 ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
8513 $.datepicker._hideDatepicker();
8514 }
8515 },
8517 /* Adjust one of the date sub-fields. */
8518 _adjustDate: function(id, offset, period) {
8519 var target = $(id),
8520 inst = this._getInst(target[0]);
8522 if (this._isDisabledDatepicker(target[0])) {
8523 return;
8524 }
8525 this._adjustInstDate(inst, offset +
8527 period);
8528 this._updateDatepicker(inst);
8529 },
8531 /* Action for current link. */
8532 _gotoToday: function(id) {
8533 var date,
8534 target = $(id),
8535 inst = this._getInst(target[0]);
8538 inst.selectedDay = inst.currentDay;
8539 inst.drawMonth = inst.selectedMonth = inst.currentMonth;
8540 inst.drawYear = inst.selectedYear = inst.currentYear;
8541 } else {
8542 date = new Date();
8543 inst.selectedDay = date.getDate();
8544 inst.drawMonth = inst.selectedMonth = date.getMonth();
8545 inst.drawYear = inst.selectedYear = date.getFullYear();
8546 }
8547 this._notifyChange(inst);
8548 this._adjustDate(target);
8549 },
8551 /* Action for selecting a new month/year. */
8552 _selectMonthYear: function(id, select, period) {
8553 var target = $(id),
8554 inst = this._getInst(target[0]);
8558 parseInt(select.options[select.selectedIndex].value,10);
8560 this._notifyChange(inst);
8561 this._adjustDate(target);
8562 },
8564 /* Action for selecting a day. */
8565 _selectDay: function(id, month, year, td) {
8566 var inst,
8567 target = $(id);
8569 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
8570 return;
8571 }
8573 inst = this._getInst(target[0]);
8575 inst.selectedMonth = inst.currentMonth = month;
8576 inst.selectedYear = inst.currentYear = year;
8577 this._selectDate(id, this._formatDate(inst,
8578 inst.currentDay, inst.currentMonth, inst.currentYear));
8579 },
8581 /* Erase the input field and hide the date picker. */
8582 _clearDate: function(id) {
8583 var target = $(id);
8585 },
8587 /* Update the input field with the selected date. */
8588 _selectDate: function(id, dateStr) {
8589 var onSelect,
8590 target = $(id),
8591 inst = this._getInst(target[0]);
8593 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
8594 if (inst.input) {
8595 inst.input.val(dateStr);
8596 }
8597 this._updateAlternate(inst);
8600 if (onSelect) {
8601 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
8602 } else if (inst.input) {
8604 }
8606 if (inst.inline){
8607 this._updateDatepicker(inst);
8608 } else {
8609 this._hideDatepicker();
8610 this._lastInput = inst.input[0];
8612 inst.input.focus(); // restore focus
8613 }
8614 this._lastInput = null;
8615 }
8616 },
8618 /* Update any alternate field to synchronise with the main field. */
8619 _updateAlternate: function(inst) {
8620 var altFormat, date, dateStr,
8623 if (altField) { // update alternate field too
8625 date = this._getDate(inst);
8626 dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
8627 $(altField).each(function() { $(this).val(dateStr); });
8628 }
8629 },
8631 /* Set as beforeShowDay function to prevent selection of weekends.
8632 * @param date Date - the date to customise
8633 * @return [boolean, string] - is this date selectable?, what is its CSS class?
8634 */
8635 noWeekends: function(date) {
8636 var day = date.getDay();
8638 },
8640 /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
8641 * @param date Date - the date to get the week for
8642 * @return number - the number of the week within the year that contains this date
8643 */
8644 iso8601Week: function(date) {
8645 var time,
8646 checkDate = new Date(date.getTime());
8648 // Find Thursday of this week starting on Monday
8649 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
8651 time = checkDate.getTime();
8652 checkDate.setMonth(0); // Compare with Jan 1
8653 checkDate.setDate(1);
8654 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
8655 },
8657 /* Parse a string value into a date object.
8658 * See formatDate below for the possible formats.
8659 *
8660 * @param format string - the expected format of the date
8661 * @param value string - the date in the above format
8662 * @param settings Object - attributes include:
8663 * shortYearCutoff number - the cutoff year for determining the century (optional)
8664 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
8665 * dayNames string[7] - names of the days from Sunday (optional)
8666 * monthNamesShort string[12] - abbreviated names of the months (optional)
8667 * monthNames string[12] - names of the months (optional)
8668 * @return Date - the extracted date value or null if value is blank
8669 */
8670 parseDate: function (format, value, settings) {
8671 if (format == null || value == null) {
8673 }
8677 return null;
8678 }
8680 var iFormat, dim, extra,
8681 iValue = 0,
8682 shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
8684 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
8685 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8686 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8687 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8688 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8689 year = -1,
8690 month = -1,
8691 day = -1,
8692 doy = -1,
8693 literal = false,
8694 date,
8695 // Check whether a format character is doubled
8696 lookAhead = function(match) {
8697 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8698 if (matches) {
8699 iFormat++;
8700 }
8701 return matches;
8702 },
8703 // Extract a number from the string value
8704 getNumber = function(match) {
8705 var isDoubled = lookAhead(match),
8709 num = value.substring(iValue).match(digits);
8710 if (!num) {
8712 }
8713 iValue += num[0].length;
8714 return parseInt(num[0], 10);
8715 },
8716 // Extract a name from the string value and convert to an index
8717 getName = function(match, shortNames, longNames) {
8718 var index = -1,
8719 names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
8720 return [ [k, v] ];
8721 }).sort(function (a, b) {
8722 return -(a[1].length - b[1].length);
8723 });
8725 $.each(names, function (i, pair) {
8726 var name = pair[1];
8727 if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
8728 index = pair[0];
8729 iValue += name.length;
8730 return false;
8731 }
8732 });
8733 if (index !== -1) {
8734 return index + 1;
8735 } else {
8737 }
8738 },
8739 // Confirm that a literal character matches the string value
8740 checkLiteral = function() {
8741 if (value.charAt(iValue) !== format.charAt(iFormat)) {
8743 }
8744 iValue++;
8745 };
8747 for (iFormat = 0; iFormat < format.length; iFormat++) {
8748 if (literal) {
8750 literal = false;
8751 } else {
8752 checkLiteral();
8753 }
8754 } else {
8755 switch (format.charAt(iFormat)) {
8758 break;
8761 break;
8764 break;
8767 break;
8770 break;
8773 break;
8776 year = date.getFullYear();
8777 month = date.getMonth() + 1;
8778 day = date.getDate();
8779 break;
8782 year = date.getFullYear();
8783 month = date.getMonth() + 1;
8784 day = date.getDate();
8785 break;
8788 checkLiteral();
8789 } else {
8790 literal = true;
8791 }
8792 break;
8793 default:
8794 checkLiteral();
8795 }
8796 }
8797 }
8799 if (iValue < value.length){
8800 extra = value.substr(iValue);
8801 if (!/^\s+/.test(extra)) {
8803 }
8804 }
8806 if (year === -1) {
8807 year = new Date().getFullYear();
8808 } else if (year < 100) {
8809 year += new Date().getFullYear() - new Date().getFullYear() % 100 +
8810 (year <= shortYearCutoff ? 0 : -100);
8811 }
8813 if (doy > -1) {
8814 month = 1;
8815 day = doy;
8816 do {
8817 dim = this._getDaysInMonth(year, month - 1);
8818 if (day <= dim) {
8819 break;
8820 }
8821 month++;
8822 day -= dim;
8823 } while (true);
8824 }
8826 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
8827 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
8829 }
8830 return date;
8831 },
8833 /* Standard date formats. */
8847 _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
8848 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
8850 /* Format a date object into a string value.
8851 * The format can be combinations of the following:
8852 * d - day of month (no leading zero)
8853 * dd - day of month (two digit)
8854 * o - day of year (no leading zeros)
8855 * oo - day of year (three digit)
8856 * D - day name short
8857 * DD - day name long
8858 * m - month of year (no leading zero)
8859 * mm - month of year (two digit)
8860 * M - month name short
8861 * MM - month name long
8862 * y - year (two digit)
8863 * yy - year (four digit)
8864 * @ - Unix timestamp (ms since 01/01/1970)
8865 * ! - Windows ticks (100ns since 01/01/0001)
8867 * '' - single quote
8868 *
8869 * @param format string - the desired format of the date
8870 * @param date Date - the date value to format
8871 * @param settings Object - attributes include:
8872 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
8873 * dayNames string[7] - names of the days from Sunday (optional)
8874 * monthNamesShort string[12] - abbreviated names of the months (optional)
8875 * monthNames string[12] - names of the months (optional)
8876 * @return string - the date in the above format
8877 */
8878 formatDate: function (format, date, settings) {
8879 if (!date) {
8881 }
8883 var iFormat,
8884 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
8885 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
8886 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
8887 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
8888 // Check whether a format character is doubled
8889 lookAhead = function(match) {
8890 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8891 if (matches) {
8892 iFormat++;
8893 }
8894 return matches;
8895 },
8896 // Format a number, with leading zero if necessary
8897 formatNumber = function(match, value, len) {
8899 if (lookAhead(match)) {
8900 while (num.length < len) {
8902 }
8903 }
8904 return num;
8905 },
8906 // Format a name, short or long as requested
8907 formatName = function(match, value, shortNames, longNames) {
8908 return (lookAhead(match) ? longNames[value] : shortNames[value]);
8909 },
8911 literal = false;
8913 if (date) {
8914 for (iFormat = 0; iFormat < format.length; iFormat++) {
8915 if (literal) {
8917 literal = false;
8918 } else {
8919 output += format.charAt(iFormat);
8920 }
8921 } else {
8922 switch (format.charAt(iFormat)) {
8925 break;
8928 break;
8931 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
8932 break;
8935 break;
8938 break;
8942 break;
8944 output += date.getTime();
8945 break;
8947 output += date.getTime() * 10000 + this._ticksTo1970;
8948 break;
8952 } else {
8953 literal = true;
8954 }
8955 break;
8956 default:
8957 output += format.charAt(iFormat);
8958 }
8959 }
8960 }
8961 }
8962 return output;
8963 },
8965 /* Extract all possible characters from the date format. */
8966 _possibleChars: function (format) {
8967 var iFormat,
8968 chars = "",
8969 literal = false,
8970 // Check whether a format character is doubled
8971 lookAhead = function(match) {
8972 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
8973 if (matches) {
8974 iFormat++;
8975 }
8976 return matches;
8977 };
8979 for (iFormat = 0; iFormat < format.length; iFormat++) {
8980 if (literal) {
8982 literal = false;
8983 } else {
8984 chars += format.charAt(iFormat);
8985 }
8986 } else {
8987 switch (format.charAt(iFormat)) {
8988 case "d": case "m": case "y": case "@":
8989 chars += "0123456789";
8990 break;
8991 case "D": case "M":
8992 return null; // Accept anything
8996 } else {
8997 literal = true;
8998 }
8999 break;
9000 default:
9001 chars += format.charAt(iFormat);
9002 }
9003 }
9004 }
9005 return chars;
9006 },
9008 /* Get a setting value, defaulting if necessary. */
9009 _get: function(inst, name) {
9010 return inst.settings[name] !== undefined ?
9011 inst.settings[name] : this._defaults[name];
9012 },
9014 /* Parse existing date and initialise date picker. */
9015 _setDateFromField: function(inst, noDefault) {
9016 if (inst.input.val() === inst.lastVal) {
9017 return;
9018 }
9021 dates = inst.lastVal = inst.input ? inst.input.val() : null,
9022 defaultDate = this._getDefaultDate(inst),
9023 date = defaultDate,
9024 settings = this._getFormatConfig(inst);
9026 try {
9027 date = this.parseDate(dateFormat, dates, settings) || defaultDate;
9028 } catch (event) {
9030 }
9031 inst.selectedDay = date.getDate();
9032 inst.drawMonth = inst.selectedMonth = date.getMonth();
9033 inst.drawYear = inst.selectedYear = date.getFullYear();
9034 inst.currentDay = (dates ? date.getDate() : 0);
9035 inst.currentMonth = (dates ? date.getMonth() : 0);
9036 inst.currentYear = (dates ? date.getFullYear() : 0);
9037 this._adjustInstDate(inst);
9038 },
9040 /* Retrieve the default date shown on opening. */
9041 _getDefaultDate: function(inst) {
9042 return this._restrictMinMax(inst,
9044 },
9046 /* A date may be specified as an exact value or a relative one. */
9047 _determineDate: function(inst, date, defaultDate) {
9048 var offsetNumeric = function(offset) {
9049 var date = new Date();
9050 date.setDate(date.getDate() + offset);
9051 return date;
9052 },
9053 offsetString = function(offset) {
9054 try {
9056 offset, $.datepicker._getFormatConfig(inst));
9057 }
9058 catch (e) {
9059 // Ignore
9060 }
9062 var date = (offset.toLowerCase().match(/^c/) ?
9063 $.datepicker._getDate(inst) : null) || new Date(),
9064 year = date.getFullYear(),
9065 month = date.getMonth(),
9066 day = date.getDate(),
9067 pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
9068 matches = pattern.exec(offset);
9070 while (matches) {
9073 day += parseInt(matches[1],10); break;
9075 day += parseInt(matches[1],10) * 7; break;
9077 month += parseInt(matches[1],10);
9078 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
9079 break;
9081 year += parseInt(matches[1],10);
9082 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
9083 break;
9084 }
9085 matches = pattern.exec(offset);
9086 }
9087 return new Date(year, month, day);
9088 },
9089 newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
9090 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
9093 if (newDate) {
9094 newDate.setHours(0);
9095 newDate.setMinutes(0);
9096 newDate.setSeconds(0);
9097 newDate.setMilliseconds(0);
9098 }
9099 return this._daylightSavingAdjust(newDate);
9100 },
9102 /* Handle switch to/from daylight saving.
9103 * Hours may be non-zero on daylight saving cut-over:
9104 * > 12 when midnight changeover, but then cannot generate
9105 * midnight datetime, so jump to 1AM, otherwise reset.
9106 * @param date (Date) the date to check
9107 * @return (Date) the corrected date
9108 */
9109 _daylightSavingAdjust: function(date) {
9110 if (!date) {
9111 return null;
9112 }
9113 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
9114 return date;
9115 },
9117 /* Set the date(s) directly. */
9118 _setDate: function(inst, date, noChange) {
9119 var clear = !date,
9120 origMonth = inst.selectedMonth,
9121 origYear = inst.selectedYear,
9122 newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
9124 inst.selectedDay = inst.currentDay = newDate.getDate();
9125 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
9126 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
9127 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
9128 this._notifyChange(inst);
9129 }
9130 this._adjustInstDate(inst);
9131 if (inst.input) {
9133 }
9134 },
9136 /* Retrieve the date(s) directly. */
9137 _getDate: function(inst) {
9139 this._daylightSavingAdjust(new Date(
9140 inst.currentYear, inst.currentMonth, inst.currentDay)));
9141 return startDate;
9142 },
9144 /* Attach the onxxx handlers. These are declared statically so
9145 * they work with static code transformers like Caja.
9146 */
9147 _attachHandlers: function(inst) {
9151 var handler = {
9152 prev: function () {
9154 },
9155 next: function () {
9157 },
9158 hide: function () {
9159 $.datepicker._hideDatepicker();
9160 },
9161 today: function () {
9162 $.datepicker._gotoToday(id);
9163 },
9164 selectDay: function () {
9165 $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
9166 return false;
9167 },
9168 selectMonth: function () {
9170 return false;
9171 },
9172 selectYear: function () {
9174 return false;
9175 }
9176 };
9178 });
9179 },
9181 /* Generate the HTML for the current state of the date picker. */
9182 _generateHTML: function(inst) {
9183 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
9184 controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
9185 monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
9186 selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
9187 cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
9188 printDate, dRow, tbody, daySettings, otherMonth, unselectable,
9189 tempDate = new Date(),
9190 today = this._daylightSavingAdjust(
9191 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
9196 numMonths = this._getNumberOfMonths(inst),
9199 isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
9200 currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
9201 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
9204 drawMonth = inst.drawMonth - showCurrentAtPos,
9205 drawYear = inst.drawYear;
9207 if (drawMonth < 0) {
9208 drawMonth += 12;
9209 drawYear--;
9210 }
9211 if (maxDate) {
9212 maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
9213 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
9214 maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
9215 while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
9216 drawMonth--;
9217 if (drawMonth < 0) {
9218 drawMonth = 11;
9219 drawYear--;
9220 }
9221 }
9222 }
9223 inst.drawMonth = drawMonth;
9224 inst.drawYear = drawYear;
9227 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
9228 this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
9229 this._getFormatConfig(inst)));
9231 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
9233 " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
9234 (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>"));
9237 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
9238 this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
9239 this._getFormatConfig(inst)));
9241 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
9243 " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
9244 (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>"));
9248 currentText = (!navigationAsDateFormat ? currentText :
9249 this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
9251 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'>" +
9254 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
9255 (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'" +
9259 firstDay = (isNaN(firstDay) ? 0 : firstDay);
9269 defaultDate = this._getDefaultDate(inst);
9271 dow;
9272 for (row = 0; row < numMonths[0]; row++) {
9274 this.maxRows = 4;
9275 for (col = 0; col < numMonths[1]; col++) {
9276 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
9279 if (isMultiMonth) {
9281 if (numMonths[1] > 1) {
9282 switch (col) {
9283 case 0: calender += " ui-datepicker-group-first";
9284 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
9285 case numMonths[1]-1: calender += " ui-datepicker-group-last";
9286 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
9287 default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
9288 }
9289 }
9291 }
9292 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
9295 this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
9296 row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
9299 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
9300 for (dow = 0; dow < 7; dow++) { // days of the week
9301 day = (dow + firstDay) % 7;
9302 thead += "<th" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
9304 }
9306 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
9307 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
9308 inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
9309 }
9310 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
9311 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
9312 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
9313 this.maxRows = numRows;
9314 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
9315 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
9319 for (dow = 0; dow < 7; dow++) { // create date picker days
9320 daySettings = (beforeShowDay ?
9322 otherMonth = (printDate.getMonth() !== drawMonth);
9323 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
9324 (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
9326 ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
9327 (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
9328 ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
9329 (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
9330 // or defaultDate is current printedDate and defaultDate is selectedDate
9331 " " + this._dayOverClass : "") + // highlight selected day
9332 (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
9333 (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
9334 (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
9335 (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
9336 ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "'") + "'" : "") + // cell title
9337 (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
9339 (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
9341 (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
9346 }
9348 }
9349 drawMonth++;
9352 drawYear++;
9353 }
9355 ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
9357 }
9359 }
9363 },
9365 /* Generate the month and year header. */
9376 // month selection
9382 monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
9384 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
9388 }
9389 }
9391 }
9395 }
9397 // year selection
9403 // determine range of years to display
9411 };
9416 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
9421 }
9426 }
9427 }
9432 }
9435 },
9437 /* Adjust one of the date sub-fields. */
9441 day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
9449 }
9450 },
9452 /* Ensure a date is within any min/max bounds. */
9453 _restrictMinMax: function(inst, date) {
9454 var minDate = this._getMinMaxDate(inst, "min"),
9455 maxDate = this._getMinMaxDate(inst, "max"),
9456 newDate = (minDate && date < minDate ? minDate : date);
9457 return (maxDate && newDate > maxDate ? maxDate : newDate);
9458 },
9460 /* Notify change of month/year. */
9461 _notifyChange: function(inst) {
9462 var onChange = this._get(inst, "onChangeMonthYear");
9463 if (onChange) {
9464 onChange.apply((inst.input ? inst.input[0] : null),
9465 [inst.selectedYear, inst.selectedMonth + 1, inst]);
9466 }
9467 },
9469 /* Determine the number of months to show. */
9472 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
9473 },
9475 /* Determine the current maximum date - ensure no time components are set. */
9478 },
9480 /* Find the number of days in a given month. */
9483 },
9485 /* Find the day of the week of the first of a month. */
9488 },
9490 /* Determines if we should allow a "next/prev" month display change. */
9491 _canAdjustMonth: function(inst, offset, curYear, curMonth) {
9492 var numMonths = this._getNumberOfMonths(inst),
9493 date = this._daylightSavingAdjust(new Date(curYear,
9494 curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
9496 if (offset < 0) {
9497 date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
9498 }
9499 return this._isInRange(inst, date);
9500 },
9502 /* Is the given date in the accepted range? */
9517 }
9520 }
9521 }
9527 },
9529 /* Provide the configuration settings for formatting/parsing. */
9530 _getFormatConfig: function(inst) {
9531 var shortYearCutoff = this._get(inst, "shortYearCutoff");
9532 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
9533 new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
9534 return {shortYearCutoff: shortYearCutoff,
9535 dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
9536 monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
9537 },
9539 /* Format the given date for display. */
9545 }
9550 }
9551 });
9553 /*
9554 * Bind hover events for datepicker elements.
9555 * Done via delegate so the binding only occurs once in the lifetime of the parent div.
9556 * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
9557 */
9559 var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
9564 }
9567 }
9568 })
9570 if (!$.datepicker._isDisabledDatepicker( instActive.inline ? dpDiv.parent()[0] : instActive.input[0])) {
9575 }
9578 }
9579 }
9580 });
9581 }
9583 /* jQuery extend now ignores nulls! */
9589 }
9590 }
9592 }
9594 /* Invoke the datepicker functionality.
9595 @param options string - a command, optionally followed by additional parameters or
9596 Object - settings for attaching new datepicker functionality
9597 @return jQuery object */
9600 /* Verify an empty collection wasn't passed - Fixes #6976 */
9603 }
9605 /* Initialise the date picker. */
9609 }
9611 /* Append datepicker main container to body if not exist. */
9614 }
9617 if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
9620 }
9624 }
9630 });
9631 };
9650 },
9651 resizableRelatedOptions = {
9656 };
9660 options: {
9663 buttons: [],
9675 position: {
9680 // Ensure the titlebar is always visible
9685 }
9686 }
9687 },
9693 // callbacks
9704 },
9713 };
9717 };
9734 }
9737 }
9740 },
9745 }
9746 },
9752 }
9754 },
9766 // Without detaching first, the following becomes really slow
9773 }
9776 // Don't try to place the dialog next to itself (#8613)
9781 }
9782 },
9786 },
9796 }
9802 // Hiding a focused element doesn't trigger blur in WebKit
9803 // so in case we have nothing to focus on, explicitly blur the active element
9804 // https://bugs.webkit.org/show_bug.cgi?id=47182
9806 }
9810 });
9811 },
9815 },
9819 },
9825 }
9827 },
9834 }
9836 }
9848 });
9851 },
9854 // Set focus to the first match:
9855 // 1. First element inside the dialog matching [autofocus]
9856 // 2. Tabbable element inside the content element
9857 // 3. Tabbable element inside the buttonpane
9858 // 4. The close button
9859 // 5. The dialog itself
9863 }
9866 }
9869 }
9872 }
9874 },
9883 }
9884 }
9887 // support: IE
9888 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
9889 // so we check again later
9891 },
9899 // Setting tabIndex makes the div focusable
9902 })
9912 }
9914 // prevent tabbing out of dialogs
9917 }
9925 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
9928 }
9929 },
9933 }
9934 }
9935 });
9937 // We assume that any existing aria-describedby attribute means
9938 // that the dialog content is marked up properly
9939 // otherwise we brute force the content as the description
9943 });
9944 }
9945 },
9955 // Don't prevent click on close button (#8838)
9956 // Focusing a dialog that is partially scrolled out of view
9957 // causes the browser to scroll it into view, preventing the click event
9959 // Dialog isn't getting focus when dragging (#8063)
9961 }
9962 }
9963 });
9968 icons: {
9970 },
9972 })
9979 }
9980 });
9990 });
9991 },
9996 }
9998 },
10009 },
10015 // if we already have a button pane, remove it
10022 }
10028 props;
10029 // Default to a non-submitting button
10031 // Change the context for the click callback to be the main element
10035 };
10036 buttonOptions = {
10039 };
10045 });
10048 },
10058 };
10059 }
10069 },
10072 },
10077 ];
10081 }
10082 });
10083 },
10089 // .ui-resizable has position: relative defined in the stylesheet
10090 // but dialogs have to use absolute or fixed positioning
10093 handles :
10102 };
10103 }
10118 },
10121 },
10128 }
10129 })
10131 },
10139 },
10142 // Need to show the dialog to get the actual offset in the position plugin
10146 }
10150 }
10151 },
10156 resizableOptions = {};
10163 }
10166 }
10167 });
10172 }
10175 }
10176 },
10179 /*jshint maxcomplexity:15*/
10184 uiDialog
10187 }
10191 }
10197 }
10201 }
10205 // Ensure that we always pass a string
10207 });
10208 }
10214 }
10218 }
10219 }
10223 }
10226 // currently resizable, becoming non-resizable
10230 }
10232 // currently resizable, changing handles
10235 }
10237 // currently non-resizable, becoming resizable
10240 }
10241 }
10245 }
10246 },
10249 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
10250 // divs will both have width and height set, so we need to reset them
10254 // Reset content sizing
10260 });
10264 }
10266 // reset wrapper sizing
10267 // determine the height of all the non-content elements
10271 })
10283 });
10286 }
10290 }
10291 },
10302 })
10305 });
10306 },
10312 }
10313 },
10318 }
10320 // TODO: Remove hack when datepicker implements
10321 // the .ui-front logic (#8989)
10323 },
10328 }
10333 // Prevent use of anchors and inputs.
10334 // We use a delay in case the overlay is created from an
10335 // event that we're going to be cancelling. (#2804)
10337 // Handle .dialog().dialog("close") (#4065)
10344 }
10345 });
10346 }
10347 });
10348 }
10355 });
10357 },
10362 }
10369 }
10372 }
10373 }
10374 });
10378 // DEPRECATED
10380 // position option with array notation
10381 // just override with old implementation
10385 myAt = [],
10387 isVisible;
10394 }
10400 }
10401 });
10403 position = {
10407 };
10408 }
10413 }
10415 // need to show the dialog to get the actual offset in the position plugin
10419 }
10423 }
10424 }
10425 });
10426 }
10436 // Create element
10445 animation = {},
10449 // if already wrapped, the wrapper's properties are my property. #6245
10454 }
10458 });
10465 el
10471 }
10473 // start at 0 if we are showing
10478 }
10479 }
10481 // Animate
10489 }
10493 }
10494 });
10496 };
10506 // defaults:
10514 // number of internal animations
10519 // utility:
10522 i,
10523 upAnim,
10524 downAnim,
10526 // we will need to re-assemble the queue to stack our animations in place
10530 // Avoid touching opacity to prevent clearType and PNG issues in IE
10533 }
10539 // default distance for the BIGGEST bounce is the outer Distance / 3
10542 }
10548 // if we are showing, force opacity 0 and set the initial position
10549 // then do the "first" animation
10553 }
10555 // start at the smallest distance if we are hiding
10558 }
10560 downAnim = {};
10562 // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10564 upAnim = {};
10571 }
10573 // Last Bounce when Hiding
10579 }
10584 }
10588 });
10590 // inject all the animations we just queued to be first in line (after "inprogress")
10594 }
10597 };
10604 // Create element
10613 animation = {},
10616 // Save & Show
10620 // Create Wrapper
10623 });
10627 // Shift
10631 }
10633 // Create Animation Object:
10637 // Animate
10645 }
10649 }
10650 });
10652 };
10667 animation = {
10669 },
10670 distance;
10672 // Adjust
10680 el
10683 }
10685 // Animation
10689 distance;
10691 // Animate
10699 }
10703 }
10704 });
10705 };
10719 // show and then visibility:hidden the element before calculating offset
10722 // width and height of a piece
10725 pieces = [],
10727 // loop
10730 // children animate complete:
10735 }
10736 }
10738 // clone the element for each row and cell.
10747 // Create a clone of the now hidden main element that will be absolute positioned
10748 // within a wrapper div off the -left and -top equal to size of our pieces
10749 el
10758 })
10760 // select the wrapper - make it overflow: hidden and absolute positioned based on
10761 // where the original was located +left and +top equal to the size of pieces
10777 }
10778 }
10783 });
10787 }
10789 }
10790 };
10801 opacity: mode
10802 }, {
10806 complete: done
10807 });
10808 };
10816 // Create element
10829 animation1 = {},
10830 animation2 = {};
10835 // Create Wrapper
10838 });
10845 }
10849 width: size
10850 } : {
10853 });
10854 }
10856 // Animation
10860 // Animate
10861 wrapper
10866 }
10870 });
10872 };
10882 animation = {
10884 };
10888 }
10892 elem
10897 })
10905 }
10908 }
10909 });
10910 };
10923 // showing or hiding leaves of the "last" animation
10929 i;
10934 }
10936 // anims - 1 opacity "toggles"
10939 opacity: animateTo
10942 }
10945 opacity: animateTo
10951 }
10953 });
10955 // We just queued up "anims" animations, we need to put them next in the queue
10959 }
10961 };
10973 original = {
10978 };
10988 original :
10989 {
10994 }
10995 });
10998 };
11002 // Create element
11010 original = {
11015 },
11016 factor = {
11019 };
11021 // We are going to pass this effect to the size effect:
11026 // Set default origin and restore for show/hide
11030 }
11043 };
11045 // Fade option to support puff
11050 }
11054 }
11055 }
11057 // Animate
11060 };
11064 // Create element
11067 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11069 // Always restore
11072 // Copy for children
11078 // Set options
11085 zero = {
11090 };
11094 }
11095 original = {
11100 };
11108 }
11110 // Set scaling factor
11111 factor = {
11115 },
11116 to: {
11119 }
11120 };
11122 // Scale the css box
11125 // Vertical props scaling
11130 }
11132 // Horizontal props scaling
11137 }
11138 }
11140 // Scale the content
11143 // Vertical props scaling
11148 }
11149 }
11156 // Adjust
11163 }
11166 // Animate
11169 // Add margins/font-size
11176 c_original = {
11181 };
11184 }
11191 };
11197 };
11199 // Vertical props scaling
11203 }
11205 // Horizontal props scaling
11209 }
11211 // Animate children
11215 // Restore children
11218 }
11219 });
11220 });
11221 }
11223 // Animate
11231 }
11234 }
11238 // we need to calculate our new positioning based on the scaling
11244 });
11251 // if original was "auto", recalculate the new value from wrapper
11254 }
11257 });
11258 });
11259 }
11260 }
11264 }
11265 });
11267 };
11285 animation = {},
11286 animation1 = {},
11287 animation2 = {},
11288 i,
11290 // we will need to re-assemble the queue to stack our animations in place
11298 // Animation
11303 // Animate
11306 // Shakes
11309 }
11310 el
11316 }
11320 });
11322 // inject all the animations we just queued to be first in line (after "inprogress")
11326 }
11329 };
11337 // Create element
11345 distance,
11346 animation = {};
11348 // Adjust
11355 });
11359 }
11361 // Animation
11365 distance;
11367 // Animate
11375 }
11379 }
11380 });
11381 };
11395 animation = {
11400 },
11411 })
11415 });
11416 };
11426 options: {
11427 icons: {
11429 },
11431 position: {
11434 },
11437 // callbacks
11441 },
11445 // flag used to prevent firing of the click handler
11446 // as the event bubbles up through nested menus
11455 })
11456 // need to catch all clicks on disabled menu
11457 // not possible through _on
11461 }
11468 }
11471 // Prevent focus from sticking to links inside menu after clicking
11472 // them (focus should always stay on UL during navigation).
11475 },
11478 },
11485 // Open submenu on click
11489 // Redirect focus to the menu
11492 // If the active item is on the top level, let it stay active.
11493 // Otherwise, blur the active item since it is no longer visible.
11496 }
11497 }
11498 }
11499 },
11502 // Remove ui-state-active class from siblings of the newly focused menu item
11503 // to avoid a jump caused by adjacent elements both having a class with a border
11506 },
11510 // If there's already an active item, keep it active
11511 // If not, activate the first item
11516 }
11517 },
11522 }
11523 });
11524 },
11526 });
11530 // Clicks outside of a menu collapse any open menus
11535 }
11537 // Reset the mouseHandled flag
11539 }
11540 });
11541 },
11544 // Destroy (sub)menus
11558 // Destroy menu items
11573 }
11574 });
11576 // Destroy menu dividers
11578 },
11581 /*jshint maxcomplexity:20*/
11587 }
11614 }
11635 }
11640 });
11643 match;
11645 // If no matches on the current filter, reset to the last character pressed
11646 // to move down the menu to the first item that starts with that character
11652 });
11653 }
11664 }
11667 }
11668 }
11672 }
11673 },
11681 }
11682 }
11683 },
11690 // Initialize nested menus
11698 })
11706 item
11710 });
11714 // Don't refresh list items that are already adapted
11724 });
11726 // Initialize unlinked menu-items containing spaces and/or dashes only as dividers
11729 // hyphen, em dash, en dash
11732 }
11733 });
11735 // Add aria-disabled attribute to any disabled menu item
11738 // If the active item has been removed, blur the menu
11741 }
11742 },
11749 },
11756 }
11758 },
11768 // Only update aria-activedescendant if there's a role
11769 // otherwise we assume focus is managed elsewhere
11772 }
11774 // Highlight active parent menu item, if any
11787 }
11792 }
11796 },
11812 }
11813 }
11814 },
11819 }
11823 }
11829 },
11834 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
11835 // shift in the submenu position when mousing over the carat icon
11838 }
11844 },
11856 submenu
11861 },
11866 // If we were passed an event, look for the submenu that contains the event
11870 // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
11873 }
11880 },
11882 // With no arguments, closes the currently active menu - if nothing is active
11883 // it closes all menus. If passed an argument, it will search for menus BELOW
11887 }
11889 startMenu
11897 },
11905 }
11906 },
11918 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
11921 });
11922 }
11923 },
11927 },
11931 },
11935 },
11939 },
11952 }
11953 }
11956 }
11959 },
11967 }
11970 }
11977 });
11983 }
11984 },
11991 }
11994 }
12001 });
12006 }
12007 },
12011 },
12014 // TODO: It should never be possible to not have an active item at this
12015 // point, but the tests don't trigger mouseenter before click.
12020 }
12022 }
12023 });
12046 ];
12047 }
12051 }
12060 };
12061 }
12067 };
12068 }
12074 };
12075 }
12080 };
12081 }
12087 }
12089 div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
12100 }
12105 },
12116 };
12117 },
12129 };
12130 }
12131 };
12136 }
12138 // make a copy, we don't want to modify arguments
12146 offsets = {};
12150 // force left top to allow flipping
12152 }
12156 // clone to reuse original targetOffset later
12159 // force my and at to have valid horizontal and vertical positions
12160 // if a value is missing or invalid, it will be converted to center
12163 horizontalOffset,
12164 verticalOffset;
12172 }
12176 // calculate offsets
12182 ];
12184 // reduce to just the positions without the offsets
12188 ];
12189 });
12191 // normalize collision option
12194 }
12200 }
12206 }
12220 collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
12228 }
12234 }
12239 // if the browser doesn't support fractions, then round for consistent results
12243 }
12245 collisionPosition = {
12247 marginTop: marginTop
12248 };
12264 elem : elem
12265 });
12266 }
12267 });
12270 // adds feedback as second argument to using callback, if present
12276 feedback = {
12277 target: {
12282 height: targetHeight
12283 },
12284 element: {
12289 height: elemHeight
12290 },
12293 };
12296 }
12299 }
12304 }
12306 };
12307 }
12310 });
12311 };
12314 fit: {
12322 newOverRight;
12324 // element is wider than within
12326 // element is initially over the left side of within
12330 // element is initially over right side of within
12333 // element is initially over both left and right sides of within
12339 }
12340 }
12341 // too far left -> align with left edge
12344 // too far right -> align with right edge
12347 // adjust based on position and margin
12350 }
12351 },
12359 newOverBottom;
12361 // element is taller than within
12363 // element is initially over the top of within
12367 // element is initially over bottom of within
12370 // element is initially over both top and bottom of within
12376 }
12377 }
12378 // too far up -> align with top
12381 // too far down -> align with bottom edge
12384 // adjust based on position and margin
12387 }
12388 }
12389 },
12390 flip: {
12410 newOverRight,
12411 newOverLeft;
12414 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
12417 }
12418 }
12420 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
12423 }
12424 }
12425 },
12446 newOverTop,
12447 newOverBottom;
12449 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
12450 if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
12452 }
12453 }
12455 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
12456 if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
12458 }
12459 }
12460 }
12461 },
12462 flipfit: {
12466 },
12470 }
12471 }
12472 };
12474 // fraction support test
12480 //Create a "fake body" for testing based on method used in jQuery.support
12482 testElementStyle = {
12489 };
12495 });
12496 }
12499 }
12511 })();
12519 options: {
12525 },
12530 // Constrain initial value
12536 // Only set static values, aria-valuenow and aria-valuemax are
12537 // set inside _refreshValue()
12540 });
12542 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
12546 },
12557 },
12562 }
12566 },
12571 }
12575 // sanitize value
12578 }
12582 },
12585 // Ensure "value" option is set after other values (like max)
12593 },
12597 // Don't allow a max less than min
12599 }
12602 },
12605 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
12606 },
12622 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
12623 }
12628 });
12632 }
12633 }
12638 }
12641 }
12642 }
12643 });
12649 // number of pages in a slider
12650 // (how many times can you page up/down to go through the whole range)
12657 options: {
12668 // callbacks
12673 },
12694 },
12701 },
12706 existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12708 handles = [];
12715 }
12719 }
12727 });
12728 },
12742 }
12743 }
12750 // note: this isn't the most fittingly semantic framework class for this element,
12751 // but worked best visually with a variety of themes
12755 // Handle range switching from true to min/max
12759 });
12760 }
12763 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12766 }
12767 },
12775 },
12790 },
12799 }
12804 };
12818 }
12819 });
12824 }
12829 closestHandle
12842 };
12846 }
12849 },
12853 },
12862 },
12876 },
12880 },
12884 pixelMouse,
12885 percentMouse,
12886 valueTotal,
12887 valueMouse;
12891 pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
12894 pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
12895 }
12900 }
12903 }
12906 }
12912 },
12918 };
12922 }
12924 },
12928 newValues,
12929 allowed;
12936 ) {
12938 }
12943 // A slide can be canceled by returning false from the slide callback
12947 values: newValues
12948 } );
12952 }
12953 }
12956 // A slide can be canceled by returning false from the slide callback
12959 value: newVal
12960 } );
12963 }
12964 }
12965 }
12966 },
12972 };
12976 }
12979 },
12986 };
12990 }
12992 //store the last changed value index for reference when handles overlap
12996 }
12997 },
13005 }
13008 },
13012 newValues,
13013 i;
13020 }
13029 }
13036 }
13037 }
13040 }
13041 },
13054 }
13055 }
13059 }
13082 }
13096 }
13097 },
13099 //internal value getter
13100 // _value() returns value trimmed by min and max, aligned by step
13106 },
13108 //internal values getter
13109 // _values() returns array of values trimmed by min and max, aligned by step
13110 // _values( index ) returns single value trimmed by min and max, aligned by step
13113 vals,
13114 i;
13122 // .slice() creates a copy of the array
13123 // this copy gets trimmed by min and max and then returned
13127 }
13132 }
13133 },
13135 // returns the step-aligned value that val is closest to, between (inclusive) min and max
13139 }
13142 }
13149 }
13151 // Since JavaScript has problems with large floats, round
13152 // the final value to 5 digits after the decimal point (see #4124)
13154 },
13158 },
13162 },
13170 _set = {};
13174 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13180 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13181 }
13183 that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13184 }
13187 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13188 }
13190 that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13191 }
13192 }
13193 }
13195 });
13207 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13208 }
13210 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13211 }
13213 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13214 }
13216 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13217 }
13218 }
13219 },
13221 _handleEvents: {
13223 /*jshint maxcomplexity:25*/
13243 }
13244 }
13246 }
13253 }
13263 newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
13266 newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
13272 }
13279 }
13282 }
13285 },
13288 },
13297 }
13298 }
13299 }
13301 });
13314 }
13315 };
13316 }
13322 options: {
13324 icons: {
13327 },
13339 },
13342 // handle string values that need to be parsed
13347 // format the value, but don't constrain
13354 // turning off autocomplete prevents the browser from remembering the
13355 // value when navigating through history, so we re-enable autocomplete
13356 // if the page is unloaded before the widget is destroyed. #7790
13360 }
13361 });
13362 },
13372 }
13373 });
13376 },
13378 _events: {
13382 }
13383 },
13387 },
13392 }
13398 }
13399 },
13403 }
13406 }
13413 }
13416 },
13420 // We never want the buttons to have focus; whenever the user is
13421 // interacting with the spinner, the focus should be on the input.
13422 // If the input is focused then this.previous is properly set from
13423 // when the input first received focus. If the input is not focused
13424 // then we need to set this.previous based on the value before spinning.
13432 // support: IE
13433 // IE sets focus asynchronously, so we need to check if focus
13434 // moved off of the input because the user clicked on the button.
13437 });
13438 }
13439 }
13441 // ensure focus is on (or stays on) the text field
13445 // support: IE
13446 // IE doesn't prevent moving focus even with event.preventDefault()
13447 // so we set a flag to know when we should ignore the blur event
13448 // and check (again) if focus moved off of the input.
13453 });
13457 }
13460 },
13463 // button will add ui-state-active if mouse was down while mouseleave and kept down
13466 }
13470 }
13472 },
13473 // TODO: do we really want to consider this a stop?
13474 // shouldn't we just stop the repeater and wait until mouseup before
13475 // we trigger the stop event?
13477 },
13485 // add buttons
13490 // button bindings
13496 // IE 6 doesn't understand height: 50% for the buttons
13497 // unless the wrapper has an explicit height
13501 }
13503 // disable spinner if element was already disabled
13506 }
13507 },
13526 }
13529 },
13533 },
13543 },
13548 }
13552 }
13555 },
13566 },
13573 }
13580 }
13581 },
13590 }
13593 },
13599 }
13601 },
13607 },
13613 // make sure we're at a valid step
13614 // - find out where we are relative to the base (min or 0)
13617 // - round to the nearest step
13619 // - rounding is based on 0, so adjust back to our base
13622 // fix precision from bad JS floating point math
13625 // clamp the value
13628 }
13631 }
13634 },
13639 }
13646 },
13654 }
13659 }
13660 }
13668 }
13679 }
13680 }
13681 },
13686 }),
13692 }
13694 },
13699 }
13702 value;
13703 },
13709 // TODO: what should we do with values that can't be parsed?
13711 });
13712 },
13714 // update the value without triggering change
13722 }
13724 }
13725 }
13728 },
13740 },
13744 }),
13749 }
13750 },
13754 }),
13759 }
13760 },
13764 }),
13768 }),
13773 }
13775 },
13779 }
13780 });
13791 }
13797 }
13802 options: {
13810 // callbacks
13815 },
13826 // Prevent users from focusing disabled tabs via click
13830 }
13831 })
13832 // support: IE <9
13833 // Preventing the default action in mousedown doesn't prevent IE
13834 // from focusing the element, so if the anchor gets focused, blur.
13835 // We don't have to worry about focusing the previously focused
13836 // element since clicking on a non-focusable element should focus
13837 // the body anyway.
13841 }
13842 });
13847 // Take disabling tabs via class attribute from HTML
13848 // into account and update option properly.
13853 })
13855 }
13857 // check for length avoids error when initializing empty list
13862 }
13868 }
13869 },
13877 // check the fragment identifier in the URL
13883 }
13884 });
13885 }
13887 // check for a tab marked active via a class
13890 }
13892 // no active tab, set to false
13895 }
13896 }
13898 // handle numbers: negative, out of range
13903 }
13904 }
13906 // don't allow collapsible: false and active: false
13909 }
13912 },
13918 };
13919 },
13922 /*jshint maxcomplexity:15*/
13929 }
13934 selectedIndex++;
13939 selectedIndex--;
13948 // Activate only, no collapsing
13954 // Toggle (cancel delayed activation, allow collapsing)
13957 // Determine if we should collapse or activate
13962 }
13964 // Focus the appropriate tab, based on which key was pressed
13969 // Navigating with control key will prevent automatic activation
13971 // Update aria-selected immediately so that AT think the tab is already selected.
13972 // Otherwise AT may confuse the user by stating that they need to activate the tab,
13973 // but the tab will already be activated by the time the announcement finishes.
13980 }
13981 },
13986 }
13988 // Ctrl+up moves focus to the current tab
13992 }
13993 },
13995 // Alt+page up/down moves focus to the previous/next tab (and activates)
14000 }
14004 }
14005 },
14013 }
14016 }
14018 }
14022 }
14025 },
14031 },
14035 // _activate() will handle invalid values and update this.options
14038 }
14041 // don't use the widget factory's disabled handling
14044 }
14050 // Setting collapsible: false while collapsed; open first panel
14053 }
14054 }
14058 }
14062 }
14063 },
14067 },
14071 },
14077 // get disabled tabs from class attribute from HTML
14078 // this will get converted to a boolean if needed in _refresh()
14081 });
14085 // was collapsed or no tabs
14089 // was active, but active tab is gone
14091 // all remaining tabs are disabled
14095 // activate previous tab
14098 }
14099 // was active, active tab still exists
14101 // make sure active index is correct
14103 }
14106 },
14116 });
14122 });
14124 // Make sure one tab is in the tab order
14133 });
14139 });
14140 }
14141 },
14155 });
14159 })
14164 });
14174 // inline tab
14178 // remote tab
14186 }
14188 }
14192 }
14195 }
14199 });
14201 });
14206 },
14208 // allow overriding how to find the list for rare usage scenarios (#7715)
14211 },
14218 },
14226 }
14227 }
14229 // disable tabs
14239 }
14240 }
14243 },
14249 }
14250 };
14254 });
14255 }
14264 },
14280 }
14282 });
14286 });
14291 })
14298 }
14299 },
14310 eventData = {
14314 newPanel: toShow
14315 };
14320 // tab is already loading
14322 // can't switch durning an animation
14324 // click on active header, but not collapsible
14326 // allow canceling activation
14329 }
14336 }
14340 }
14344 }
14346 },
14348 // handles show/hide for selecting tabs
14359 }
14369 }
14370 }
14372 // start out by hiding, then showing, then completing
14377 });
14382 }
14387 });
14389 // If we're switching tabs, remove the old tab from the tab order.
14390 // If we're opening from collapsed state, remove the previous tab from the tab order.
14391 // If we're collapsing, then keep the collapsing tab in the tab order.
14397 })
14399 }
14404 });
14408 });
14409 },
14415 // trying to activate the already active panel
14418 }
14420 // trying to collapse, simulate a click on the current active header
14423 }
14429 preventDefault: $.noop
14430 });
14431 },
14435 },
14438 // meta-function to give users option to provide a href string instead of a numerical index.
14441 }
14444 },
14449 }
14451 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
14454 .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
14478 }
14479 });
14485 li
14490 }
14491 });
14497 }
14498 },
14504 }
14513 });
14517 });
14518 }
14519 }
14521 },
14527 }
14535 }
14540 }
14541 }
14543 },
14551 eventData = {
14553 panel: panel
14554 };
14556 // not remote
14559 }
14563 // support: jQuery <1.8
14564 // jQuery <1.8 returns false if the request is canceled in beforeSend,
14565 // but as of 1.8, $.ajax() always returns a jqXHR object.
14572 // support: jQuery <1.8
14573 // http://bugs.jquery.com/ticket/11778
14578 })
14580 // support: jQuery <1.8
14581 // http://bugs.jquery.com/ticket/11778
14585 }
14592 }
14594 });
14595 }
14596 },
14605 }
14606 };
14607 },
14612 }
14613 });
14624 elem
14627 }
14635 }
14643 }
14644 }
14648 options: {
14650 // support: IE<9, Opera in jQuery <1.7
14651 // .text() can't accept undefined, so coerce to a string
14653 // Escape title, since we're going from an attribute to raw HTML
14655 },
14657 // Disabled elements have inconsistent behavior across browsers (#8661)
14659 position: {
14663 },
14668 // callbacks
14671 },
14677 });
14679 // IDs of generated tooltips, needed for destroy
14681 // IDs of parent tooltips where we removed the title attribute
14686 }
14687 },
14695 // disable element style changes
14697 }
14704 });
14705 }
14706 },
14711 // close open tooltips
14716 });
14718 // remove title attributes to prevent native tooltips
14722 element
14725 }
14726 });
14727 },
14730 // restore title attributes
14735 }
14736 });
14737 },
14742 // we need closest here due to mouseover bubbling,
14743 // but always pointing at the same event target
14746 // No element to show a tooltip for or the tooltip is already open
14749 }
14753 }
14757 // kill parent tooltips, custom or native, for hover
14761 blurEvent;
14766 }
14772 };
14774 }
14775 });
14776 }
14779 },
14789 }
14792 // ignore async response if tooltip was closed already
14795 }
14796 // IE may instantly serve a cached response for ajax requests
14797 // delay this call to _open so the other call to _open runs first
14799 // jQuery creates a special event for focusin when it doesn't
14800 // exist natively. To improve performance, the native event
14801 // object is reused and the type is changed. Therefore, we can't
14802 // rely on the type being correct after the event finished
14803 // bubbling, so we set it back to the previous value. (#8740)
14806 }
14808 });
14809 });
14812 }
14813 },
14821 }
14823 // Content can be updated multiple times. If the tooltip already
14824 // exists, then just update the content and bail.
14829 }
14831 // if we have a title, clear it to prevent the native tooltip
14832 // we have to check first to avoid defining a title if none exists
14833 // (we don't want to cause an element to start matching [title])
14834 //
14835 // We use removeAttr only for key events, to allow IE to export the correct
14836 // accessible attributes. For mouse events, set to empty string to avoid
14837 // native tooltip showing up (happens only when removing inside mouseover).
14843 }
14844 }
14854 }
14856 }
14859 mousemove: position
14860 });
14861 // trigger once to override element-relative positioning
14867 }
14872 // Handle tracking tooltips that are shown with a delay (#8644). As soon
14873 // as the tooltip is visible, position the tooltip using the most recent
14874 // event.
14880 }
14882 }
14886 events = {
14892 }
14893 },
14896 }
14897 };
14900 }
14903 }
14905 },
14912 // disabling closes the tooltip, so we need to track when we're closing
14913 // to avoid an infinite loop in case the tooltip becomes disabled on close
14916 }
14918 // Clear the interval for delayed tracking tooltips
14921 // only set title if we had one before (see comment in _open())
14924 }
14931 });
14935 // Remove 'remove' binding only on delegated targets
14938 }
14945 });
14946 }
14951 },
14959 })
14968 },
14973 },
14978 },
14983 // close open tooltips
14985 // Delegate to close method to handle common cleanup
14990 // Remove immediately; destroying an open tooltip doesn't use the
14991 // hide animation
14994 // Restore the title
14998 }
14999 });
15000 }
15001 });