[2] | 1 | /*! |
---|
| 2 | * jQuery UI 1.8.5 |
---|
| 3 | * |
---|
| 4 | * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about) |
---|
| 5 | * Dual licensed under the MIT or GPL Version 2 licenses. |
---|
| 6 | * http://jquery.org/license |
---|
| 7 | * |
---|
| 8 | * http://docs.jquery.com/UI |
---|
| 9 | */ |
---|
| 10 | (function( $, undefined ) { |
---|
| 11 | |
---|
| 12 | // prevent duplicate loading |
---|
| 13 | // this is only a problem because we proxy existing functions |
---|
| 14 | // and we don't want to double proxy them |
---|
| 15 | $.ui = $.ui || {}; |
---|
| 16 | if ( $.ui.version ) { |
---|
| 17 | return; |
---|
| 18 | } |
---|
| 19 | |
---|
| 20 | $.extend( $.ui, { |
---|
| 21 | version: "1.8.5", |
---|
| 22 | |
---|
| 23 | keyCode: { |
---|
| 24 | ALT: 18, |
---|
| 25 | BACKSPACE: 8, |
---|
| 26 | CAPS_LOCK: 20, |
---|
| 27 | COMMA: 188, |
---|
| 28 | COMMAND: 91, |
---|
| 29 | COMMAND_LEFT: 91, // COMMAND |
---|
| 30 | COMMAND_RIGHT: 93, |
---|
| 31 | CONTROL: 17, |
---|
| 32 | DELETE: 46, |
---|
| 33 | DOWN: 40, |
---|
| 34 | END: 35, |
---|
| 35 | ENTER: 13, |
---|
| 36 | ESCAPE: 27, |
---|
| 37 | HOME: 36, |
---|
| 38 | INSERT: 45, |
---|
| 39 | LEFT: 37, |
---|
| 40 | MENU: 93, // COMMAND_RIGHT |
---|
| 41 | NUMPAD_ADD: 107, |
---|
| 42 | NUMPAD_DECIMAL: 110, |
---|
| 43 | NUMPAD_DIVIDE: 111, |
---|
| 44 | NUMPAD_ENTER: 108, |
---|
| 45 | NUMPAD_MULTIPLY: 106, |
---|
| 46 | NUMPAD_SUBTRACT: 109, |
---|
| 47 | PAGE_DOWN: 34, |
---|
| 48 | PAGE_UP: 33, |
---|
| 49 | PERIOD: 190, |
---|
| 50 | RIGHT: 39, |
---|
| 51 | SHIFT: 16, |
---|
| 52 | SPACE: 32, |
---|
| 53 | TAB: 9, |
---|
| 54 | UP: 38, |
---|
| 55 | WINDOWS: 91 // COMMAND |
---|
| 56 | } |
---|
| 57 | }); |
---|
| 58 | |
---|
| 59 | // plugins |
---|
| 60 | $.fn.extend({ |
---|
| 61 | _focus: $.fn.focus, |
---|
| 62 | focus: function( delay, fn ) { |
---|
| 63 | return typeof delay === "number" ? |
---|
| 64 | this.each(function() { |
---|
| 65 | var elem = this; |
---|
| 66 | setTimeout(function() { |
---|
| 67 | $( elem ).focus(); |
---|
| 68 | if ( fn ) { |
---|
| 69 | fn.call( elem ); |
---|
| 70 | } |
---|
| 71 | }, delay ); |
---|
| 72 | }) : |
---|
| 73 | this._focus.apply( this, arguments ); |
---|
| 74 | }, |
---|
| 75 | |
---|
| 76 | scrollParent: function() { |
---|
| 77 | var scrollParent; |
---|
| 78 | if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) { |
---|
| 79 | scrollParent = this.parents().filter(function() { |
---|
| 80 | return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1)); |
---|
| 81 | }).eq(0); |
---|
| 82 | } else { |
---|
| 83 | scrollParent = this.parents().filter(function() { |
---|
| 84 | return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1)); |
---|
| 85 | }).eq(0); |
---|
| 86 | } |
---|
| 87 | |
---|
| 88 | return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent; |
---|
| 89 | }, |
---|
| 90 | |
---|
| 91 | zIndex: function( zIndex ) { |
---|
| 92 | if ( zIndex !== undefined ) { |
---|
| 93 | return this.css( "zIndex", zIndex ); |
---|
| 94 | } |
---|
| 95 | |
---|
| 96 | if ( this.length ) { |
---|
| 97 | var elem = $( this[ 0 ] ), position, value; |
---|
| 98 | while ( elem.length && elem[ 0 ] !== document ) { |
---|
| 99 | // Ignore z-index if position is set to a value where z-index is ignored by the browser |
---|
| 100 | // This makes behavior of this function consistent across browsers |
---|
| 101 | // WebKit always returns auto if the element is positioned |
---|
| 102 | position = elem.css( "position" ); |
---|
| 103 | if ( position === "absolute" || position === "relative" || position === "fixed" ) { |
---|
| 104 | // IE returns 0 when zIndex is not specified |
---|
| 105 | // other browsers return a string |
---|
| 106 | // we ignore the case of nested elements with an explicit value of 0 |
---|
| 107 | // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> |
---|
| 108 | value = parseInt( elem.css( "zIndex" ) ); |
---|
| 109 | if ( !isNaN( value ) && value != 0 ) { |
---|
| 110 | return value; |
---|
| 111 | } |
---|
| 112 | } |
---|
| 113 | elem = elem.parent(); |
---|
| 114 | } |
---|
| 115 | } |
---|
| 116 | |
---|
| 117 | return 0; |
---|
| 118 | }, |
---|
| 119 | |
---|
| 120 | disableSelection: function() { |
---|
| 121 | return this.bind( |
---|
| 122 | "mousedown.ui-disableSelection selectstart.ui-disableSelection", |
---|
| 123 | function( event ) { |
---|
| 124 | event.preventDefault(); |
---|
| 125 | }); |
---|
| 126 | }, |
---|
| 127 | |
---|
| 128 | enableSelection: function() { |
---|
| 129 | return this.unbind( ".ui-disableSelection" ); |
---|
| 130 | } |
---|
| 131 | }); |
---|
| 132 | |
---|
| 133 | $.each( [ "Width", "Height" ], function( i, name ) { |
---|
| 134 | var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ], |
---|
| 135 | type = name.toLowerCase(), |
---|
| 136 | orig = { |
---|
| 137 | innerWidth: $.fn.innerWidth, |
---|
| 138 | innerHeight: $.fn.innerHeight, |
---|
| 139 | outerWidth: $.fn.outerWidth, |
---|
| 140 | outerHeight: $.fn.outerHeight |
---|
| 141 | }; |
---|
| 142 | |
---|
| 143 | function reduce( elem, size, border, margin ) { |
---|
| 144 | $.each( side, function() { |
---|
| 145 | size -= parseFloat( $.curCSS( elem, "padding" + this, true) ) || 0; |
---|
| 146 | if ( border ) { |
---|
| 147 | size -= parseFloat( $.curCSS( elem, "border" + this + "Width", true) ) || 0; |
---|
| 148 | } |
---|
| 149 | if ( margin ) { |
---|
| 150 | size -= parseFloat( $.curCSS( elem, "margin" + this, true) ) || 0; |
---|
| 151 | } |
---|
| 152 | }); |
---|
| 153 | return size; |
---|
| 154 | } |
---|
| 155 | |
---|
| 156 | $.fn[ "inner" + name ] = function( size ) { |
---|
| 157 | if ( size === undefined ) { |
---|
| 158 | return orig[ "inner" + name ].call( this ); |
---|
| 159 | } |
---|
| 160 | |
---|
| 161 | return this.each(function() { |
---|
| 162 | $.style( this, type, reduce( this, size ) + "px" ); |
---|
| 163 | }); |
---|
| 164 | }; |
---|
| 165 | |
---|
| 166 | $.fn[ "outer" + name] = function( size, margin ) { |
---|
| 167 | if ( typeof size !== "number" ) { |
---|
| 168 | return orig[ "outer" + name ].call( this, size ); |
---|
| 169 | } |
---|
| 170 | |
---|
| 171 | return this.each(function() { |
---|
| 172 | $.style( this, type, reduce( this, size, true, margin ) + "px" ); |
---|
| 173 | }); |
---|
| 174 | }; |
---|
| 175 | }); |
---|
| 176 | |
---|
| 177 | // selectors |
---|
| 178 | function visible( element ) { |
---|
| 179 | return !$( element ).parents().andSelf().filter(function() { |
---|
| 180 | return $.curCSS( this, "visibility" ) === "hidden" || |
---|
| 181 | $.expr.filters.hidden( this ); |
---|
| 182 | }).length; |
---|
| 183 | } |
---|
| 184 | |
---|
| 185 | $.extend( $.expr[ ":" ], { |
---|
| 186 | data: function( elem, i, match ) { |
---|
| 187 | return !!$.data( elem, match[ 3 ] ); |
---|
| 188 | }, |
---|
| 189 | |
---|
| 190 | focusable: function( element ) { |
---|
| 191 | var nodeName = element.nodeName.toLowerCase(), |
---|
| 192 | tabIndex = $.attr( element, "tabindex" ); |
---|
| 193 | if ( "area" === nodeName ) { |
---|
| 194 | var map = element.parentNode, |
---|
| 195 | mapName = map.name, |
---|
| 196 | img; |
---|
| 197 | if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) { |
---|
| 198 | return false; |
---|
| 199 | } |
---|
| 200 | img = $( "img[usemap=#" + mapName + "]" )[0]; |
---|
| 201 | return !!img && visible( img ); |
---|
| 202 | } |
---|
| 203 | return ( /input|select|textarea|button|object/.test( nodeName ) |
---|
| 204 | ? !element.disabled |
---|
| 205 | : "a" == nodeName |
---|
| 206 | ? element.href || !isNaN( tabIndex ) |
---|
| 207 | : !isNaN( tabIndex )) |
---|
| 208 | // the element and all of its ancestors must be visible |
---|
| 209 | && visible( element ); |
---|
| 210 | }, |
---|
| 211 | |
---|
| 212 | tabbable: function( element ) { |
---|
| 213 | var tabIndex = $.attr( element, "tabindex" ); |
---|
| 214 | return ( isNaN( tabIndex ) || tabIndex >= 0 ) && $( element ).is( ":focusable" ); |
---|
| 215 | } |
---|
| 216 | }); |
---|
| 217 | |
---|
| 218 | // support |
---|
| 219 | $(function() { |
---|
| 220 | var div = document.createElement( "div" ), |
---|
| 221 | body = document.body; |
---|
| 222 | |
---|
| 223 | $.extend( div.style, { |
---|
| 224 | minHeight: "100px", |
---|
| 225 | height: "auto", |
---|
| 226 | padding: 0, |
---|
| 227 | borderWidth: 0 |
---|
| 228 | }); |
---|
| 229 | |
---|
| 230 | $.support.minHeight = body.appendChild( div ).offsetHeight === 100; |
---|
| 231 | // set display to none to avoid a layout bug in IE |
---|
| 232 | // http://dev.jquery.com/ticket/4014 |
---|
| 233 | body.removeChild( div ).style.display = "none"; |
---|
| 234 | }); |
---|
| 235 | |
---|
| 236 | |
---|
| 237 | |
---|
| 238 | |
---|
| 239 | |
---|
| 240 | // deprecated |
---|
| 241 | $.extend( $.ui, { |
---|
| 242 | // $.ui.plugin is deprecated. Use the proxy pattern instead. |
---|
| 243 | plugin: { |
---|
| 244 | add: function( module, option, set ) { |
---|
| 245 | var proto = $.ui[ module ].prototype; |
---|
| 246 | for ( var i in set ) { |
---|
| 247 | proto.plugins[ i ] = proto.plugins[ i ] || []; |
---|
| 248 | proto.plugins[ i ].push( [ option, set[ i ] ] ); |
---|
| 249 | } |
---|
| 250 | }, |
---|
| 251 | call: function( instance, name, args ) { |
---|
| 252 | var set = instance.plugins[ name ]; |
---|
| 253 | if ( !set || !instance.element[ 0 ].parentNode ) { |
---|
| 254 | return; |
---|
| 255 | } |
---|
| 256 | |
---|
| 257 | for ( var i = 0; i < set.length; i++ ) { |
---|
| 258 | if ( instance.options[ set[ i ][ 0 ] ] ) { |
---|
| 259 | set[ i ][ 1 ].apply( instance.element, args ); |
---|
| 260 | } |
---|
| 261 | } |
---|
| 262 | } |
---|
| 263 | }, |
---|
| 264 | |
---|
| 265 | // will be deprecated when we switch to jQuery 1.4 - use jQuery.contains() |
---|
| 266 | contains: function( a, b ) { |
---|
| 267 | return document.compareDocumentPosition ? |
---|
| 268 | a.compareDocumentPosition( b ) & 16 : |
---|
| 269 | a !== b && a.contains( b ); |
---|
| 270 | }, |
---|
| 271 | |
---|
| 272 | // only used by resizable |
---|
| 273 | hasScroll: function( el, a ) { |
---|
| 274 | |
---|
| 275 | //If overflow is hidden, the element might have extra content, but the user wants to hide it |
---|
| 276 | if ( $( el ).css( "overflow" ) === "hidden") { |
---|
| 277 | return false; |
---|
| 278 | } |
---|
| 279 | |
---|
| 280 | var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop", |
---|
| 281 | has = false; |
---|
| 282 | |
---|
| 283 | if ( el[ scroll ] > 0 ) { |
---|
| 284 | return true; |
---|
| 285 | } |
---|
| 286 | |
---|
| 287 | // TODO: determine which cases actually cause this to happen |
---|
| 288 | // if the element doesn't have the scroll set, see if it's possible to |
---|
| 289 | // set the scroll |
---|
| 290 | el[ scroll ] = 1; |
---|
| 291 | has = ( el[ scroll ] > 0 ); |
---|
| 292 | el[ scroll ] = 0; |
---|
| 293 | return has; |
---|
| 294 | }, |
---|
| 295 | |
---|
| 296 | // these are odd functions, fix the API or move into individual plugins |
---|
| 297 | isOverAxis: function( x, reference, size ) { |
---|
| 298 | //Determines when x coordinate is over "b" element axis |
---|
| 299 | return ( x > reference ) && ( x < ( reference + size ) ); |
---|
| 300 | }, |
---|
| 301 | isOver: function( y, x, top, left, height, width ) { |
---|
| 302 | //Determines when x, y coordinates is over "b" element |
---|
| 303 | return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width ); |
---|
| 304 | } |
---|
| 305 | }); |
---|
| 306 | |
---|
| 307 | })( jQuery ); |
---|
| 308 | /*! |
---|
| 309 | * jQuery UI Widget 1.8.5 |
---|
| 310 | * |
---|
| 311 | * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about) |
---|
| 312 | * Dual licensed under the MIT or GPL Version 2 licenses. |
---|
| 313 | * http://jquery.org/license |
---|
| 314 | * |
---|
| 315 | * http://docs.jquery.com/UI/Widget |
---|
| 316 | */ |
---|
| 317 | (function( $, undefined ) { |
---|
| 318 | |
---|
| 319 | // jQuery 1.4+ |
---|
| 320 | if ( $.cleanData ) { |
---|
| 321 | var _cleanData = $.cleanData; |
---|
| 322 | $.cleanData = function( elems ) { |
---|
| 323 | for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) { |
---|
| 324 | $( elem ).triggerHandler( "remove" ); |
---|
| 325 | } |
---|
| 326 | _cleanData( elems ); |
---|
| 327 | }; |
---|
| 328 | } else { |
---|
| 329 | var _remove = $.fn.remove; |
---|
| 330 | $.fn.remove = function( selector, keepData ) { |
---|
| 331 | return this.each(function() { |
---|
| 332 | if ( !keepData ) { |
---|
| 333 | if ( !selector || $.filter( selector, [ this ] ).length ) { |
---|
| 334 | $( "*", this ).add( [ this ] ).each(function() { |
---|
| 335 | $( this ).triggerHandler( "remove" ); |
---|
| 336 | }); |
---|
| 337 | } |
---|
| 338 | } |
---|
| 339 | return _remove.call( $(this), selector, keepData ); |
---|
| 340 | }); |
---|
| 341 | }; |
---|
| 342 | } |
---|
| 343 | |
---|
| 344 | $.widget = function( name, base, prototype ) { |
---|
| 345 | var namespace = name.split( "." )[ 0 ], |
---|
| 346 | fullName; |
---|
| 347 | name = name.split( "." )[ 1 ]; |
---|
| 348 | fullName = namespace + "-" + name; |
---|
| 349 | |
---|
| 350 | if ( !prototype ) { |
---|
| 351 | prototype = base; |
---|
| 352 | base = $.Widget; |
---|
| 353 | } |
---|
| 354 | |
---|
| 355 | // create selector for plugin |
---|
| 356 | $.expr[ ":" ][ fullName ] = function( elem ) { |
---|
| 357 | return !!$.data( elem, name ); |
---|
| 358 | }; |
---|
| 359 | |
---|
| 360 | $[ namespace ] = $[ namespace ] || {}; |
---|
| 361 | $[ namespace ][ name ] = function( options, element ) { |
---|
| 362 | // allow instantiation without initializing for simple inheritance |
---|
| 363 | if ( arguments.length ) { |
---|
| 364 | this._createWidget( options, element ); |
---|
| 365 | } |
---|
| 366 | }; |
---|
| 367 | |
---|
| 368 | var basePrototype = new base(); |
---|
| 369 | // we need to make the options hash a property directly on the new instance |
---|
| 370 | // otherwise we'll modify the options hash on the prototype that we're |
---|
| 371 | // inheriting from |
---|
| 372 | // $.each( basePrototype, function( key, val ) { |
---|
| 373 | // if ( $.isPlainObject(val) ) { |
---|
| 374 | // basePrototype[ key ] = $.extend( {}, val ); |
---|
| 375 | // } |
---|
| 376 | // }); |
---|
| 377 | basePrototype.options = $.extend( true, {}, basePrototype.options ); |
---|
| 378 | $[ namespace ][ name ].prototype = $.extend( true, basePrototype, { |
---|
| 379 | namespace: namespace, |
---|
| 380 | widgetName: name, |
---|
| 381 | widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name, |
---|
| 382 | widgetBaseClass: fullName |
---|
| 383 | }, prototype ); |
---|
| 384 | |
---|
| 385 | $.widget.bridge( name, $[ namespace ][ name ] ); |
---|
| 386 | }; |
---|
| 387 | |
---|
| 388 | $.widget.bridge = function( name, object ) { |
---|
| 389 | $.fn[ name ] = function( options ) { |
---|
| 390 | var isMethodCall = typeof options === "string", |
---|
| 391 | args = Array.prototype.slice.call( arguments, 1 ), |
---|
| 392 | returnValue = this; |
---|
| 393 | |
---|
| 394 | // allow multiple hashes to be passed on init |
---|
| 395 | options = !isMethodCall && args.length ? |
---|
| 396 | $.extend.apply( null, [ true, options ].concat(args) ) : |
---|
| 397 | options; |
---|
| 398 | |
---|
| 399 | // prevent calls to internal methods |
---|
| 400 | if ( isMethodCall && options.substring( 0, 1 ) === "_" ) { |
---|
| 401 | return returnValue; |
---|
| 402 | } |
---|
| 403 | |
---|
| 404 | if ( isMethodCall ) { |
---|
| 405 | this.each(function() { |
---|
| 406 | var instance = $.data( this, name ); |
---|
| 407 | if ( !instance ) { |
---|
| 408 | throw "cannot call methods on " + name + " prior to initialization; " + |
---|
| 409 | "attempted to call method '" + options + "'"; |
---|
| 410 | } |
---|
| 411 | if ( !$.isFunction( instance[options] ) ) { |
---|
| 412 | throw "no such method '" + options + "' for " + name + " widget instance"; |
---|
| 413 | } |
---|
| 414 | var methodValue = instance[ options ].apply( instance, args ); |
---|
| 415 | if ( methodValue !== instance && methodValue !== undefined ) { |
---|
| 416 | returnValue = methodValue; |
---|
| 417 | return false; |
---|
| 418 | } |
---|
| 419 | }); |
---|
| 420 | } else { |
---|
| 421 | this.each(function() { |
---|
| 422 | var instance = $.data( this, name ); |
---|
| 423 | if ( instance ) { |
---|
| 424 | instance.option( options || {} )._init(); |
---|
| 425 | } else { |
---|
| 426 | $.data( this, name, new object( options, this ) ); |
---|
| 427 | } |
---|
| 428 | }); |
---|
| 429 | } |
---|
| 430 | |
---|
| 431 | return returnValue; |
---|
| 432 | }; |
---|
| 433 | }; |
---|
| 434 | |
---|
| 435 | $.Widget = function( options, element ) { |
---|
| 436 | // allow instantiation without initializing for simple inheritance |
---|
| 437 | if ( arguments.length ) { |
---|
| 438 | this._createWidget( options, element ); |
---|
| 439 | } |
---|
| 440 | }; |
---|
| 441 | |
---|
| 442 | $.Widget.prototype = { |
---|
| 443 | widgetName: "widget", |
---|
| 444 | widgetEventPrefix: "", |
---|
| 445 | options: { |
---|
| 446 | disabled: false |
---|
| 447 | }, |
---|
| 448 | _createWidget: function( options, element ) { |
---|
| 449 | // $.widget.bridge stores the plugin instance, but we do it anyway |
---|
| 450 | // so that it's stored even before the _create function runs |
---|
| 451 | $.data( element, this.widgetName, this ); |
---|
| 452 | this.element = $( element ); |
---|
| 453 | this.options = $.extend( true, {}, |
---|
| 454 | this.options, |
---|
| 455 | $.metadata && $.metadata.get( element )[ this.widgetName ], |
---|
| 456 | options ); |
---|
| 457 | |
---|
| 458 | var self = this; |
---|
| 459 | this.element.bind( "remove." + this.widgetName, function() { |
---|
| 460 | self.destroy(); |
---|
| 461 | }); |
---|
| 462 | |
---|
| 463 | this._create(); |
---|
| 464 | this._init(); |
---|
| 465 | }, |
---|
| 466 | _create: function() {}, |
---|
| 467 | _init: function() {}, |
---|
| 468 | |
---|
| 469 | destroy: function() { |
---|
| 470 | this.element |
---|
| 471 | .unbind( "." + this.widgetName ) |
---|
| 472 | .removeData( this.widgetName ); |
---|
| 473 | this.widget() |
---|
| 474 | .unbind( "." + this.widgetName ) |
---|
| 475 | .removeAttr( "aria-disabled" ) |
---|
| 476 | .removeClass( |
---|
| 477 | this.widgetBaseClass + "-disabled " + |
---|
| 478 | "ui-state-disabled" ); |
---|
| 479 | }, |
---|
| 480 | |
---|
| 481 | widget: function() { |
---|
| 482 | return this.element; |
---|
| 483 | }, |
---|
| 484 | |
---|
| 485 | option: function( key, value ) { |
---|
| 486 | var options = key, |
---|
| 487 | self = this; |
---|
| 488 | |
---|
| 489 | if ( arguments.length === 0 ) { |
---|
| 490 | // don't return a reference to the internal hash |
---|
| 491 | return $.extend( {}, self.options ); |
---|
| 492 | } |
---|
| 493 | |
---|
| 494 | if (typeof key === "string" ) { |
---|
| 495 | if ( value === undefined ) { |
---|
| 496 | return this.options[ key ]; |
---|
| 497 | } |
---|
| 498 | options = {}; |
---|
| 499 | options[ key ] = value; |
---|
| 500 | } |
---|
| 501 | |
---|
| 502 | $.each( options, function( key, value ) { |
---|
| 503 | self._setOption( key, value ); |
---|
| 504 | }); |
---|
| 505 | |
---|
| 506 | return self; |
---|
| 507 | }, |
---|
| 508 | _setOption: function( key, value ) { |
---|
| 509 | this.options[ key ] = value; |
---|
| 510 | |
---|
| 511 | if ( key === "disabled" ) { |
---|
| 512 | this.widget() |
---|
| 513 | [ value ? "addClass" : "removeClass"]( |
---|
| 514 | this.widgetBaseClass + "-disabled" + " " + |
---|
| 515 | "ui-state-disabled" ) |
---|
| 516 | .attr( "aria-disabled", value ); |
---|
| 517 | } |
---|
| 518 | |
---|
| 519 | return this; |
---|
| 520 | }, |
---|
| 521 | |
---|
| 522 | enable: function() { |
---|
| 523 | return this._setOption( "disabled", false ); |
---|
| 524 | }, |
---|
| 525 | disable: function() { |
---|
| 526 | return this._setOption( "disabled", true ); |
---|
| 527 | }, |
---|
| 528 | |
---|
| 529 | _trigger: function( type, event, data ) { |
---|
| 530 | var callback = this.options[ type ]; |
---|
| 531 | |
---|
| 532 | event = $.Event( event ); |
---|
| 533 | event.type = ( type === this.widgetEventPrefix ? |
---|
| 534 | type : |
---|
| 535 | this.widgetEventPrefix + type ).toLowerCase(); |
---|
| 536 | data = data || {}; |
---|
| 537 | |
---|
| 538 | // copy original event properties over to the new event |
---|
| 539 | // this would happen if we could call $.event.fix instead of $.Event |
---|
| 540 | // but we don't have a way to force an event to be fixed multiple times |
---|
| 541 | if ( event.originalEvent ) { |
---|
| 542 | for ( var i = $.event.props.length, prop; i; ) { |
---|
| 543 | prop = $.event.props[ --i ]; |
---|
| 544 | event[ prop ] = event.originalEvent[ prop ]; |
---|
| 545 | } |
---|
| 546 | } |
---|
| 547 | |
---|
| 548 | this.element.trigger( event, data ); |
---|
| 549 | |
---|
| 550 | return !( $.isFunction(callback) && |
---|
| 551 | callback.call( this.element[0], event, data ) === false || |
---|
| 552 | event.isDefaultPrevented() ); |
---|
| 553 | } |
---|
| 554 | }; |
---|
| 555 | |
---|
| 556 | })( jQuery ); |
---|
| 557 | /*! |
---|
| 558 | * jQuery UI Mouse 1.8.5 |
---|
| 559 | * |
---|
| 560 | * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about) |
---|
| 561 | * Dual licensed under the MIT or GPL Version 2 licenses. |
---|
| 562 | * http://jquery.org/license |
---|
| 563 | * |
---|
| 564 | * http://docs.jquery.com/UI/Mouse |
---|
| 565 | * |
---|
| 566 | * Depends: |
---|
| 567 | * jquery.ui.widget.js |
---|
| 568 | */ |
---|
| 569 | (function( $, undefined ) { |
---|
| 570 | |
---|
| 571 | $.widget("ui.mouse", { |
---|
| 572 | options: { |
---|
| 573 | cancel: ':input,option', |
---|
| 574 | distance: 1, |
---|
| 575 | delay: 0 |
---|
| 576 | }, |
---|
| 577 | _mouseInit: function() { |
---|
| 578 | var self = this; |
---|
| 579 | |
---|
| 580 | this.element |
---|
| 581 | .bind('mousedown.'+this.widgetName, function(event) { |
---|
| 582 | return self._mouseDown(event); |
---|
| 583 | }) |
---|
| 584 | .bind('click.'+this.widgetName, function(event) { |
---|
| 585 | if(self._preventClickEvent) { |
---|
| 586 | self._preventClickEvent = false; |
---|
| 587 | event.stopImmediatePropagation(); |
---|
| 588 | return false; |
---|
| 589 | } |
---|
| 590 | }); |
---|
| 591 | |
---|
| 592 | this.started = false; |
---|
| 593 | }, |
---|
| 594 | |
---|
| 595 | // TODO: make sure destroying one instance of mouse doesn't mess with |
---|
| 596 | // other instances of mouse |
---|
| 597 | _mouseDestroy: function() { |
---|
| 598 | this.element.unbind('.'+this.widgetName); |
---|
| 599 | }, |
---|
| 600 | |
---|
| 601 | _mouseDown: function(event) { |
---|
| 602 | // don't let more than one widget handle mouseStart |
---|
| 603 | // TODO: figure out why we have to use originalEvent |
---|
| 604 | event.originalEvent = event.originalEvent || {}; |
---|
| 605 | if (event.originalEvent.mouseHandled) { return; } |
---|
| 606 | |
---|
| 607 | // we may have missed mouseup (out of window) |
---|
| 608 | (this._mouseStarted && this._mouseUp(event)); |
---|
| 609 | |
---|
| 610 | this._mouseDownEvent = event; |
---|
| 611 | |
---|
| 612 | var self = this, |
---|
| 613 | btnIsLeft = (event.which == 1), |
---|
| 614 | elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false); |
---|
| 615 | if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) { |
---|
| 616 | return true; |
---|
| 617 | } |
---|
| 618 | |
---|
| 619 | this.mouseDelayMet = !this.options.delay; |
---|
| 620 | if (!this.mouseDelayMet) { |
---|
| 621 | this._mouseDelayTimer = setTimeout(function() { |
---|
| 622 | self.mouseDelayMet = true; |
---|
| 623 | }, this.options.delay); |
---|
| 624 | } |
---|
| 625 | |
---|
| 626 | if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) { |
---|
| 627 | this._mouseStarted = (this._mouseStart(event) !== false); |
---|
| 628 | if (!this._mouseStarted) { |
---|
| 629 | event.preventDefault(); |
---|
| 630 | return true; |
---|
| 631 | } |
---|
| 632 | } |
---|
| 633 | |
---|
| 634 | // these delegates are required to keep context |
---|
| 635 | this._mouseMoveDelegate = function(event) { |
---|
| 636 | return self._mouseMove(event); |
---|
| 637 | }; |
---|
| 638 | this._mouseUpDelegate = function(event) { |
---|
| 639 | return self._mouseUp(event); |
---|
| 640 | }; |
---|
| 641 | $(document) |
---|
| 642 | .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate) |
---|
| 643 | .bind('mouseup.'+this.widgetName, this._mouseUpDelegate); |
---|
| 644 | |
---|
| 645 | // preventDefault() is used to prevent the selection of text here - |
---|
| 646 | // however, in Safari, this causes select boxes not to be selectable |
---|
| 647 | // anymore, so this fix is needed |
---|
| 648 | ($.browser.safari || event.preventDefault()); |
---|
| 649 | |
---|
| 650 | event.originalEvent.mouseHandled = true; |
---|
| 651 | return true; |
---|
| 652 | }, |
---|
| 653 | |
---|
| 654 | _mouseMove: function(event) { |
---|
| 655 | // IE mouseup check - mouseup happened when mouse was out of window |
---|
| 656 | if ($.browser.msie && !event.button) { |
---|
| 657 | return this._mouseUp(event); |
---|
| 658 | } |
---|
| 659 | |
---|
| 660 | if (this._mouseStarted) { |
---|
| 661 | this._mouseDrag(event); |
---|
| 662 | return event.preventDefault(); |
---|
| 663 | } |
---|
| 664 | |
---|
| 665 | if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) { |
---|
| 666 | this._mouseStarted = |
---|
| 667 | (this._mouseStart(this._mouseDownEvent, event) !== false); |
---|
| 668 | (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event)); |
---|
| 669 | } |
---|
| 670 | |
---|
| 671 | return !this._mouseStarted; |
---|
| 672 | }, |
---|
| 673 | |
---|
| 674 | _mouseUp: function(event) { |
---|
| 675 | $(document) |
---|
| 676 | .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate) |
---|
| 677 | .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate); |
---|
| 678 | |
---|
| 679 | if (this._mouseStarted) { |
---|
| 680 | this._mouseStarted = false; |
---|
| 681 | this._preventClickEvent = (event.target == this._mouseDownEvent.target); |
---|
| 682 | this._mouseStop(event); |
---|
| 683 | } |
---|
| 684 | |
---|
| 685 | return false; |
---|
| 686 | }, |
---|
| 687 | |
---|
| 688 | _mouseDistanceMet: function(event) { |
---|
| 689 | return (Math.max( |
---|
| 690 | Math.abs(this._mouseDownEvent.pageX - event.pageX), |
---|
| 691 | Math.abs(this._mouseDownEvent.pageY - event.pageY) |
---|
| 692 | ) >= this.options.distance |
---|
| 693 | ); |
---|
| 694 | }, |
---|
| 695 | |
---|
| 696 | _mouseDelayMet: function(event) { |
---|
| 697 | return this.mouseDelayMet; |
---|
| 698 | }, |
---|
| 699 | |
---|
| 700 | // These are placeholder methods, to be overriden by extending plugin |
---|
| 701 | _mouseStart: function(event) {}, |
---|
| 702 | _mouseDrag: function(event) {}, |
---|
| 703 | _mouseStop: function(event) {}, |
---|
| 704 | _mouseCapture: function(event) { return true; } |
---|
| 705 | }); |
---|
| 706 | |
---|
| 707 | })(jQuery); |
---|
| 708 | /* |
---|
| 709 | * jQuery UI Sortable 1.8.5 |
---|
| 710 | * |
---|
| 711 | * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about) |
---|
| 712 | * Dual licensed under the MIT or GPL Version 2 licenses. |
---|
| 713 | * http://jquery.org/license |
---|
| 714 | * |
---|
| 715 | * http://docs.jquery.com/UI/Sortables |
---|
| 716 | * |
---|
| 717 | * Depends: |
---|
| 718 | * jquery.ui.core.js |
---|
| 719 | * jquery.ui.mouse.js |
---|
| 720 | * jquery.ui.widget.js |
---|
| 721 | */ |
---|
| 722 | (function( $, undefined ) { |
---|
| 723 | |
---|
| 724 | $.widget("ui.sortable", $.ui.mouse, { |
---|
| 725 | widgetEventPrefix: "sort", |
---|
| 726 | options: { |
---|
| 727 | appendTo: "parent", |
---|
| 728 | axis: false, |
---|
| 729 | connectWith: false, |
---|
| 730 | containment: false, |
---|
| 731 | cursor: 'auto', |
---|
| 732 | cursorAt: false, |
---|
| 733 | dropOnEmpty: true, |
---|
| 734 | forcePlaceholderSize: false, |
---|
| 735 | forceHelperSize: false, |
---|
| 736 | grid: false, |
---|
| 737 | handle: false, |
---|
| 738 | helper: "original", |
---|
| 739 | items: '> *', |
---|
| 740 | opacity: false, |
---|
| 741 | placeholder: false, |
---|
| 742 | revert: false, |
---|
| 743 | scroll: true, |
---|
| 744 | scrollSensitivity: 20, |
---|
| 745 | scrollSpeed: 20, |
---|
| 746 | scope: "default", |
---|
| 747 | tolerance: "intersect", |
---|
| 748 | zIndex: 1000 |
---|
| 749 | }, |
---|
| 750 | _create: function() { |
---|
| 751 | |
---|
| 752 | var o = this.options; |
---|
| 753 | this.containerCache = {}; |
---|
| 754 | this.element.addClass("ui-sortable"); |
---|
| 755 | |
---|
| 756 | //Get the items |
---|
| 757 | this.refresh(); |
---|
| 758 | |
---|
| 759 | //Let's determine if the items are floating |
---|
| 760 | this.floating = this.items.length ? (/left|right/).test(this.items[0].item.css('float')) : false; |
---|
| 761 | |
---|
| 762 | //Let's determine the parent's offset |
---|
| 763 | this.offset = this.element.offset(); |
---|
| 764 | |
---|
| 765 | //Initialize mouse events for interaction |
---|
| 766 | this._mouseInit(); |
---|
| 767 | |
---|
| 768 | }, |
---|
| 769 | |
---|
| 770 | destroy: function() { |
---|
| 771 | this.element |
---|
| 772 | .removeClass("ui-sortable ui-sortable-disabled") |
---|
| 773 | .removeData("sortable") |
---|
| 774 | .unbind(".sortable"); |
---|
| 775 | this._mouseDestroy(); |
---|
| 776 | |
---|
| 777 | for ( var i = this.items.length - 1; i >= 0; i-- ) |
---|
| 778 | this.items[i].item.removeData("sortable-item"); |
---|
| 779 | |
---|
| 780 | return this; |
---|
| 781 | }, |
---|
| 782 | |
---|
| 783 | _setOption: function(key, value){ |
---|
| 784 | if ( key === "disabled" ) { |
---|
| 785 | this.options[ key ] = value; |
---|
| 786 | |
---|
| 787 | this.widget() |
---|
| 788 | [ value ? "addClass" : "removeClass"]( "ui-sortable-disabled" ); |
---|
| 789 | } else { |
---|
| 790 | // Don't call widget base _setOption for disable as it adds ui-state-disabled class |
---|
| 791 | $.Widget.prototype._setOption.apply(this, arguments); |
---|
| 792 | } |
---|
| 793 | }, |
---|
| 794 | |
---|
| 795 | _mouseCapture: function(event, overrideHandle) { |
---|
| 796 | |
---|
| 797 | if (this.reverting) { |
---|
| 798 | return false; |
---|
| 799 | } |
---|
| 800 | |
---|
| 801 | if(this.options.disabled || this.options.type == 'static') return false; |
---|
| 802 | |
---|
| 803 | //We have to refresh the items data once first |
---|
| 804 | this._refreshItems(event); |
---|
| 805 | |
---|
| 806 | //Find out if the clicked node (or one of its parents) is a actual item in this.items |
---|
| 807 | var currentItem = null, self = this, nodes = $(event.target).parents().each(function() { |
---|
| 808 | if($.data(this, 'sortable-item') == self) { |
---|
| 809 | currentItem = $(this); |
---|
| 810 | return false; |
---|
| 811 | } |
---|
| 812 | }); |
---|
| 813 | if($.data(event.target, 'sortable-item') == self) currentItem = $(event.target); |
---|
| 814 | |
---|
| 815 | if(!currentItem) return false; |
---|
| 816 | if(this.options.handle && !overrideHandle) { |
---|
| 817 | var validHandle = false; |
---|
| 818 | |
---|
| 819 | $(this.options.handle, currentItem).find("*").andSelf().each(function() { if(this == event.target) validHandle = true; }); |
---|
| 820 | if(!validHandle) return false; |
---|
| 821 | } |
---|
| 822 | |
---|
| 823 | this.currentItem = currentItem; |
---|
| 824 | this._removeCurrentsFromItems(); |
---|
| 825 | return true; |
---|
| 826 | |
---|
| 827 | }, |
---|
| 828 | |
---|
| 829 | _mouseStart: function(event, overrideHandle, noActivation) { |
---|
| 830 | |
---|
| 831 | var o = this.options, self = this; |
---|
| 832 | this.currentContainer = this; |
---|
| 833 | |
---|
| 834 | //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture |
---|
| 835 | this.refreshPositions(); |
---|
| 836 | |
---|
| 837 | //Create and append the visible helper |
---|
| 838 | this.helper = this._createHelper(event); |
---|
| 839 | |
---|
| 840 | //Cache the helper size |
---|
| 841 | this._cacheHelperProportions(); |
---|
| 842 | |
---|
| 843 | /* |
---|
| 844 | * - Position generation - |
---|
| 845 | * This block generates everything position related - it's the core of draggables. |
---|
| 846 | */ |
---|
| 847 | |
---|
| 848 | //Cache the margins of the original element |
---|
| 849 | this._cacheMargins(); |
---|
| 850 | |
---|
| 851 | //Get the next scrolling parent |
---|
| 852 | this.scrollParent = this.helper.scrollParent(); |
---|
| 853 | |
---|
| 854 | //The element's absolute position on the page minus margins |
---|
| 855 | this.offset = this.currentItem.offset(); |
---|
| 856 | this.offset = { |
---|
| 857 | top: this.offset.top - this.margins.top, |
---|
| 858 | left: this.offset.left - this.margins.left |
---|
| 859 | }; |
---|
| 860 | |
---|
| 861 | // Only after we got the offset, we can change the helper's position to absolute |
---|
| 862 | // TODO: Still need to figure out a way to make relative sorting possible |
---|
| 863 | this.helper.css("position", "absolute"); |
---|
| 864 | this.cssPosition = this.helper.css("position"); |
---|
| 865 | |
---|
| 866 | $.extend(this.offset, { |
---|
| 867 | click: { //Where the click happened, relative to the element |
---|
| 868 | left: event.pageX - this.offset.left, |
---|
| 869 | top: event.pageY - this.offset.top |
---|
| 870 | }, |
---|
| 871 | parent: this._getParentOffset(), |
---|
| 872 | relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper |
---|
| 873 | }); |
---|
| 874 | |
---|
| 875 | //Generate the original position |
---|
| 876 | this.originalPosition = this._generatePosition(event); |
---|
| 877 | this.originalPageX = event.pageX; |
---|
| 878 | this.originalPageY = event.pageY; |
---|
| 879 | |
---|
| 880 | //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied |
---|
| 881 | (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt)); |
---|
| 882 | |
---|
| 883 | //Cache the former DOM position |
---|
| 884 | this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] }; |
---|
| 885 | |
---|
| 886 | //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 |
---|
| 887 | if(this.helper[0] != this.currentItem[0]) { |
---|
| 888 | this.currentItem.hide(); |
---|
| 889 | } |
---|
| 890 | |
---|
| 891 | //Create the placeholder |
---|
| 892 | this._createPlaceholder(); |
---|
| 893 | |
---|
| 894 | //Set a containment if given in the options |
---|
| 895 | if(o.containment) |
---|
| 896 | this._setContainment(); |
---|
| 897 | |
---|
| 898 | if(o.cursor) { // cursor option |
---|
| 899 | if ($('body').css("cursor")) this._storedCursor = $('body').css("cursor"); |
---|
| 900 | $('body').css("cursor", o.cursor); |
---|
| 901 | } |
---|
| 902 | |
---|
| 903 | if(o.opacity) { // opacity option |
---|
| 904 | if (this.helper.css("opacity")) this._storedOpacity = this.helper.css("opacity"); |
---|
| 905 | this.helper.css("opacity", o.opacity); |
---|
| 906 | } |
---|
| 907 | |
---|
| 908 | if(o.zIndex) { // zIndex option |
---|
| 909 | if (this.helper.css("zIndex")) this._storedZIndex = this.helper.css("zIndex"); |
---|
| 910 | this.helper.css("zIndex", o.zIndex); |
---|
| 911 | } |
---|
| 912 | |
---|
| 913 | //Prepare scrolling |
---|
| 914 | if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') |
---|
| 915 | this.overflowOffset = this.scrollParent.offset(); |
---|
| 916 | |
---|
| 917 | //Call callbacks |
---|
| 918 | this._trigger("start", event, this._uiHash()); |
---|
| 919 | |
---|
| 920 | //Recache the helper size |
---|
| 921 | if(!this._preserveHelperProportions) |
---|
| 922 | this._cacheHelperProportions(); |
---|
| 923 | |
---|
| 924 | |
---|
| 925 | //Post 'activate' events to possible containers |
---|
| 926 | if(!noActivation) { |
---|
| 927 | for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i]._trigger("activate", event, self._uiHash(this)); } |
---|
| 928 | } |
---|
| 929 | |
---|
| 930 | //Prepare possible droppables |
---|
| 931 | if($.ui.ddmanager) |
---|
| 932 | $.ui.ddmanager.current = this; |
---|
| 933 | |
---|
| 934 | if ($.ui.ddmanager && !o.dropBehaviour) |
---|
| 935 | $.ui.ddmanager.prepareOffsets(this, event); |
---|
| 936 | |
---|
| 937 | this.dragging = true; |
---|
| 938 | |
---|
| 939 | this.helper.addClass("ui-sortable-helper"); |
---|
| 940 | this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position |
---|
| 941 | return true; |
---|
| 942 | |
---|
| 943 | }, |
---|
| 944 | |
---|
| 945 | _mouseDrag: function(event) { |
---|
| 946 | |
---|
| 947 | //Compute the helpers position |
---|
| 948 | this.position = this._generatePosition(event); |
---|
| 949 | this.positionAbs = this._convertPositionTo("absolute"); |
---|
| 950 | |
---|
| 951 | if (!this.lastPositionAbs) { |
---|
| 952 | this.lastPositionAbs = this.positionAbs; |
---|
| 953 | } |
---|
| 954 | |
---|
| 955 | //Do scrolling |
---|
| 956 | if(this.options.scroll) { |
---|
| 957 | var o = this.options, scrolled = false; |
---|
| 958 | if(this.scrollParent[0] != document && this.scrollParent[0].tagName != 'HTML') { |
---|
| 959 | |
---|
| 960 | if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) |
---|
| 961 | this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed; |
---|
| 962 | else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) |
---|
| 963 | this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed; |
---|
| 964 | |
---|
| 965 | if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) |
---|
| 966 | this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed; |
---|
| 967 | else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) |
---|
| 968 | this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed; |
---|
| 969 | |
---|
| 970 | } else { |
---|
| 971 | |
---|
| 972 | if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) |
---|
| 973 | scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed); |
---|
| 974 | else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) |
---|
| 975 | scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed); |
---|
| 976 | |
---|
| 977 | if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) |
---|
| 978 | scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed); |
---|
| 979 | else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) |
---|
| 980 | scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed); |
---|
| 981 | |
---|
| 982 | } |
---|
| 983 | |
---|
| 984 | if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) |
---|
| 985 | $.ui.ddmanager.prepareOffsets(this, event); |
---|
| 986 | } |
---|
| 987 | |
---|
| 988 | //Regenerate the absolute position used for position checks |
---|
| 989 | this.positionAbs = this._convertPositionTo("absolute"); |
---|
| 990 | |
---|
| 991 | //Set the helper position |
---|
| 992 | if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px'; |
---|
| 993 | if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px'; |
---|
| 994 | |
---|
| 995 | //Rearrange |
---|
| 996 | for (var i = this.items.length - 1; i >= 0; i--) { |
---|
| 997 | |
---|
| 998 | //Cache variables and intersection, continue if no intersection |
---|
| 999 | var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item); |
---|
| 1000 | if (!intersection) continue; |
---|
| 1001 | |
---|
| 1002 | if(itemElement != this.currentItem[0] //cannot intersect with itself |
---|
| 1003 | && this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before |
---|
| 1004 | && !$.ui.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked |
---|
| 1005 | && (this.options.type == 'semi-dynamic' ? !$.ui.contains(this.element[0], itemElement) : true) |
---|
| 1006 | //&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container |
---|
| 1007 | ) { |
---|
| 1008 | |
---|
| 1009 | this.direction = intersection == 1 ? "down" : "up"; |
---|
| 1010 | |
---|
| 1011 | if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) { |
---|
| 1012 | this._rearrange(event, item); |
---|
| 1013 | } else { |
---|
| 1014 | break; |
---|
| 1015 | } |
---|
| 1016 | |
---|
| 1017 | this._trigger("change", event, this._uiHash()); |
---|
| 1018 | break; |
---|
| 1019 | } |
---|
| 1020 | } |
---|
| 1021 | |
---|
| 1022 | //Post events to containers |
---|
| 1023 | this._contactContainers(event); |
---|
| 1024 | |
---|
| 1025 | //Interconnect with droppables |
---|
| 1026 | if($.ui.ddmanager) $.ui.ddmanager.drag(this, event); |
---|
| 1027 | |
---|
| 1028 | //Call callbacks |
---|
| 1029 | this._trigger('sort', event, this._uiHash()); |
---|
| 1030 | |
---|
| 1031 | this.lastPositionAbs = this.positionAbs; |
---|
| 1032 | return false; |
---|
| 1033 | |
---|
| 1034 | }, |
---|
| 1035 | |
---|
| 1036 | _mouseStop: function(event, noPropagation) { |
---|
| 1037 | |
---|
| 1038 | if(!event) return; |
---|
| 1039 | |
---|
| 1040 | //If we are using droppables, inform the manager about the drop |
---|
| 1041 | if ($.ui.ddmanager && !this.options.dropBehaviour) |
---|
| 1042 | $.ui.ddmanager.drop(this, event); |
---|
| 1043 | |
---|
| 1044 | if(this.options.revert) { |
---|
| 1045 | var self = this; |
---|
| 1046 | var cur = self.placeholder.offset(); |
---|
| 1047 | |
---|
| 1048 | self.reverting = true; |
---|
| 1049 | |
---|
| 1050 | $(this.helper).animate({ |
---|
| 1051 | left: cur.left - this.offset.parent.left - self.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft), |
---|
| 1052 | top: cur.top - this.offset.parent.top - self.margins.top + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop) |
---|
| 1053 | }, parseInt(this.options.revert, 10) || 500, function() { |
---|
| 1054 | self._clear(event); |
---|
| 1055 | }); |
---|
| 1056 | } else { |
---|
| 1057 | this._clear(event, noPropagation); |
---|
| 1058 | } |
---|
| 1059 | |
---|
| 1060 | return false; |
---|
| 1061 | |
---|
| 1062 | }, |
---|
| 1063 | |
---|
| 1064 | cancel: function() { |
---|
| 1065 | |
---|
| 1066 | var self = this; |
---|
| 1067 | |
---|
| 1068 | if(this.dragging) { |
---|
| 1069 | |
---|
| 1070 | this._mouseUp(); |
---|
| 1071 | |
---|
| 1072 | if(this.options.helper == "original") |
---|
| 1073 | this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper"); |
---|
| 1074 | else |
---|
| 1075 | this.currentItem.show(); |
---|
| 1076 | |
---|
| 1077 | //Post deactivating events to containers |
---|
| 1078 | for (var i = this.containers.length - 1; i >= 0; i--){ |
---|
| 1079 | this.containers[i]._trigger("deactivate", null, self._uiHash(this)); |
---|
| 1080 | if(this.containers[i].containerCache.over) { |
---|
| 1081 | this.containers[i]._trigger("out", null, self._uiHash(this)); |
---|
| 1082 | this.containers[i].containerCache.over = 0; |
---|
| 1083 | } |
---|
| 1084 | } |
---|
| 1085 | |
---|
| 1086 | } |
---|
| 1087 | |
---|
| 1088 | //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node! |
---|
| 1089 | if(this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]); |
---|
| 1090 | if(this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove(); |
---|
| 1091 | |
---|
| 1092 | $.extend(this, { |
---|
| 1093 | helper: null, |
---|
| 1094 | dragging: false, |
---|
| 1095 | reverting: false, |
---|
| 1096 | _noFinalSort: null |
---|
| 1097 | }); |
---|
| 1098 | |
---|
| 1099 | if(this.domPosition.prev) { |
---|
| 1100 | $(this.domPosition.prev).after(this.currentItem); |
---|
| 1101 | } else { |
---|
| 1102 | $(this.domPosition.parent).prepend(this.currentItem); |
---|
| 1103 | } |
---|
| 1104 | |
---|
| 1105 | return this; |
---|
| 1106 | |
---|
| 1107 | }, |
---|
| 1108 | |
---|
| 1109 | serialize: function(o) { |
---|
| 1110 | |
---|
| 1111 | var items = this._getItemsAsjQuery(o && o.connected); |
---|
| 1112 | var str = []; o = o || {}; |
---|
| 1113 | |
---|
| 1114 | $(items).each(function() { |
---|
| 1115 | var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/)); |
---|
| 1116 | if(res) str.push((o.key || res[1]+'[]')+'='+(o.key && o.expression ? res[1] : res[2])); |
---|
| 1117 | }); |
---|
| 1118 | |
---|
| 1119 | if(!str.length && o.key) { |
---|
| 1120 | str.push(o.key + '='); |
---|
| 1121 | } |
---|
| 1122 | |
---|
| 1123 | return str.join('&'); |
---|
| 1124 | |
---|
| 1125 | }, |
---|
| 1126 | |
---|
| 1127 | toArray: function(o) { |
---|
| 1128 | |
---|
| 1129 | var items = this._getItemsAsjQuery(o && o.connected); |
---|
| 1130 | var ret = []; o = o || {}; |
---|
| 1131 | |
---|
| 1132 | items.each(function() { ret.push($(o.item || this).attr(o.attribute || 'id') || ''); }); |
---|
| 1133 | return ret; |
---|
| 1134 | |
---|
| 1135 | }, |
---|
| 1136 | |
---|
| 1137 | /* Be careful with the following core functions */ |
---|
| 1138 | _intersectsWith: function(item) { |
---|
| 1139 | |
---|
| 1140 | var x1 = this.positionAbs.left, |
---|
| 1141 | x2 = x1 + this.helperProportions.width, |
---|
| 1142 | y1 = this.positionAbs.top, |
---|
| 1143 | y2 = y1 + this.helperProportions.height; |
---|
| 1144 | |
---|
| 1145 | var l = item.left, |
---|
| 1146 | r = l + item.width, |
---|
| 1147 | t = item.top, |
---|
| 1148 | b = t + item.height; |
---|
| 1149 | |
---|
| 1150 | var dyClick = this.offset.click.top, |
---|
| 1151 | dxClick = this.offset.click.left; |
---|
| 1152 | |
---|
| 1153 | var isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r; |
---|
| 1154 | |
---|
| 1155 | if( this.options.tolerance == "pointer" |
---|
| 1156 | || this.options.forcePointerForContainers |
---|
| 1157 | || (this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height']) |
---|
| 1158 | ) { |
---|
| 1159 | return isOverElement; |
---|
| 1160 | } else { |
---|
| 1161 | |
---|
| 1162 | return (l < x1 + (this.helperProportions.width / 2) // Right Half |
---|
| 1163 | && x2 - (this.helperProportions.width / 2) < r // Left Half |
---|
| 1164 | && t < y1 + (this.helperProportions.height / 2) // Bottom Half |
---|
| 1165 | && y2 - (this.helperProportions.height / 2) < b ); // Top Half |
---|
| 1166 | |
---|
| 1167 | } |
---|
| 1168 | }, |
---|
| 1169 | |
---|
| 1170 | _intersectsWithPointer: function(item) { |
---|
| 1171 | |
---|
| 1172 | var isOverElementHeight = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height), |
---|
| 1173 | isOverElementWidth = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width), |
---|
| 1174 | isOverElement = isOverElementHeight && isOverElementWidth, |
---|
| 1175 | verticalDirection = this._getDragVerticalDirection(), |
---|
| 1176 | horizontalDirection = this._getDragHorizontalDirection(); |
---|
| 1177 | |
---|
| 1178 | if (!isOverElement) |
---|
| 1179 | return false; |
---|
| 1180 | |
---|
| 1181 | return this.floating ? |
---|
| 1182 | ( ((horizontalDirection && horizontalDirection == "right") || verticalDirection == "down") ? 2 : 1 ) |
---|
| 1183 | : ( verticalDirection && (verticalDirection == "down" ? 2 : 1) ); |
---|
| 1184 | |
---|
| 1185 | }, |
---|
| 1186 | |
---|
| 1187 | _intersectsWithSides: function(item) { |
---|
| 1188 | |
---|
| 1189 | var isOverBottomHalf = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height), |
---|
| 1190 | isOverRightHalf = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width), |
---|
| 1191 | verticalDirection = this._getDragVerticalDirection(), |
---|
| 1192 | horizontalDirection = this._getDragHorizontalDirection(); |
---|
| 1193 | |
---|
| 1194 | if (this.floating && horizontalDirection) { |
---|
| 1195 | return ((horizontalDirection == "right" && isOverRightHalf) || (horizontalDirection == "left" && !isOverRightHalf)); |
---|
| 1196 | } else { |
---|
| 1197 | return verticalDirection && ((verticalDirection == "down" && isOverBottomHalf) || (verticalDirection == "up" && !isOverBottomHalf)); |
---|
| 1198 | } |
---|
| 1199 | |
---|
| 1200 | }, |
---|
| 1201 | |
---|
| 1202 | _getDragVerticalDirection: function() { |
---|
| 1203 | var delta = this.positionAbs.top - this.lastPositionAbs.top; |
---|
| 1204 | return delta != 0 && (delta > 0 ? "down" : "up"); |
---|
| 1205 | }, |
---|
| 1206 | |
---|
| 1207 | _getDragHorizontalDirection: function() { |
---|
| 1208 | var delta = this.positionAbs.left - this.lastPositionAbs.left; |
---|
| 1209 | return delta != 0 && (delta > 0 ? "right" : "left"); |
---|
| 1210 | }, |
---|
| 1211 | |
---|
| 1212 | refresh: function(event) { |
---|
| 1213 | this._refreshItems(event); |
---|
| 1214 | this.refreshPositions(); |
---|
| 1215 | return this; |
---|
| 1216 | }, |
---|
| 1217 | |
---|
| 1218 | _connectWith: function() { |
---|
| 1219 | var options = this.options; |
---|
| 1220 | return options.connectWith.constructor == String |
---|
| 1221 | ? [options.connectWith] |
---|
| 1222 | : options.connectWith; |
---|
| 1223 | }, |
---|
| 1224 | |
---|
| 1225 | _getItemsAsjQuery: function(connected) { |
---|
| 1226 | |
---|
| 1227 | var self = this; |
---|
| 1228 | var items = []; |
---|
| 1229 | var queries = []; |
---|
| 1230 | var connectWith = this._connectWith(); |
---|
| 1231 | |
---|
| 1232 | if(connectWith && connected) { |
---|
| 1233 | for (var i = connectWith.length - 1; i >= 0; i--){ |
---|
| 1234 | var cur = $(connectWith[i]); |
---|
| 1235 | for (var j = cur.length - 1; j >= 0; j--){ |
---|
| 1236 | var inst = $.data(cur[j], 'sortable'); |
---|
| 1237 | if(inst && inst != this && !inst.options.disabled) { |
---|
| 1238 | 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]); |
---|
| 1239 | } |
---|
| 1240 | }; |
---|
| 1241 | }; |
---|
| 1242 | } |
---|
| 1243 | |
---|
| 1244 | 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]); |
---|
| 1245 | |
---|
| 1246 | for (var i = queries.length - 1; i >= 0; i--){ |
---|
| 1247 | queries[i][0].each(function() { |
---|
| 1248 | items.push(this); |
---|
| 1249 | }); |
---|
| 1250 | }; |
---|
| 1251 | |
---|
| 1252 | return $(items); |
---|
| 1253 | |
---|
| 1254 | }, |
---|
| 1255 | |
---|
| 1256 | _removeCurrentsFromItems: function() { |
---|
| 1257 | |
---|
| 1258 | var list = this.currentItem.find(":data(sortable-item)"); |
---|
| 1259 | |
---|
| 1260 | for (var i=0; i < this.items.length; i++) { |
---|
| 1261 | |
---|
| 1262 | for (var j=0; j < list.length; j++) { |
---|
| 1263 | if(list[j] == this.items[i].item[0]) |
---|
| 1264 | this.items.splice(i,1); |
---|
| 1265 | }; |
---|
| 1266 | |
---|
| 1267 | }; |
---|
| 1268 | |
---|
| 1269 | }, |
---|
| 1270 | |
---|
| 1271 | _refreshItems: function(event) { |
---|
| 1272 | |
---|
| 1273 | this.items = []; |
---|
| 1274 | this.containers = [this]; |
---|
| 1275 | var items = this.items; |
---|
| 1276 | var self = this; |
---|
| 1277 | var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]]; |
---|
| 1278 | var connectWith = this._connectWith(); |
---|
| 1279 | |
---|
| 1280 | if(connectWith) { |
---|
| 1281 | for (var i = connectWith.length - 1; i >= 0; i--){ |
---|
| 1282 | var cur = $(connectWith[i]); |
---|
| 1283 | for (var j = cur.length - 1; j >= 0; j--){ |
---|
| 1284 | var inst = $.data(cur[j], 'sortable'); |
---|
| 1285 | if(inst && inst != this && !inst.options.disabled) { |
---|
| 1286 | queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]); |
---|
| 1287 | this.containers.push(inst); |
---|
| 1288 | } |
---|
| 1289 | }; |
---|
| 1290 | }; |
---|
| 1291 | } |
---|
| 1292 | |
---|
| 1293 | for (var i = queries.length - 1; i >= 0; i--) { |
---|
| 1294 | var targetData = queries[i][1]; |
---|
| 1295 | var _queries = queries[i][0]; |
---|
| 1296 | |
---|
| 1297 | for (var j=0, queriesLength = _queries.length; j < queriesLength; j++) { |
---|
| 1298 | var item = $(_queries[j]); |
---|
| 1299 | |
---|
| 1300 | item.data('sortable-item', targetData); // Data for target checking (mouse manager) |
---|
| 1301 | |
---|
| 1302 | items.push({ |
---|
| 1303 | item: item, |
---|
| 1304 | instance: targetData, |
---|
| 1305 | width: 0, height: 0, |
---|
| 1306 | left: 0, top: 0 |
---|
| 1307 | }); |
---|
| 1308 | }; |
---|
| 1309 | }; |
---|
| 1310 | |
---|
| 1311 | }, |
---|
| 1312 | |
---|
| 1313 | refreshPositions: function(fast) { |
---|
| 1314 | |
---|
| 1315 | //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change |
---|
| 1316 | if(this.offsetParent && this.helper) { |
---|
| 1317 | this.offset.parent = this._getParentOffset(); |
---|
| 1318 | } |
---|
| 1319 | |
---|
| 1320 | for (var i = this.items.length - 1; i >= 0; i--){ |
---|
| 1321 | var item = this.items[i]; |
---|
| 1322 | |
---|
| 1323 | var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item; |
---|
| 1324 | |
---|
| 1325 | if (!fast) { |
---|
| 1326 | item.width = t.outerWidth(); |
---|
| 1327 | item.height = t.outerHeight(); |
---|
| 1328 | } |
---|
| 1329 | |
---|
| 1330 | var p = t.offset(); |
---|
| 1331 | item.left = p.left; |
---|
| 1332 | item.top = p.top; |
---|
| 1333 | }; |
---|
| 1334 | |
---|
| 1335 | if(this.options.custom && this.options.custom.refreshContainers) { |
---|
| 1336 | this.options.custom.refreshContainers.call(this); |
---|
| 1337 | } else { |
---|
| 1338 | for (var i = this.containers.length - 1; i >= 0; i--){ |
---|
| 1339 | var p = this.containers[i].element.offset(); |
---|
| 1340 | this.containers[i].containerCache.left = p.left; |
---|
| 1341 | this.containers[i].containerCache.top = p.top; |
---|
| 1342 | this.containers[i].containerCache.width = this.containers[i].element.outerWidth(); |
---|
| 1343 | this.containers[i].containerCache.height = this.containers[i].element.outerHeight(); |
---|
| 1344 | }; |
---|
| 1345 | } |
---|
| 1346 | |
---|
| 1347 | return this; |
---|
| 1348 | }, |
---|
| 1349 | |
---|
| 1350 | _createPlaceholder: function(that) { |
---|
| 1351 | |
---|
| 1352 | var self = that || this, o = self.options; |
---|
| 1353 | |
---|
| 1354 | if(!o.placeholder || o.placeholder.constructor == String) { |
---|
| 1355 | var className = o.placeholder; |
---|
| 1356 | o.placeholder = { |
---|
| 1357 | element: function() { |
---|
| 1358 | |
---|
| 1359 | var el = $(document.createElement(self.currentItem[0].nodeName)) |
---|
| 1360 | .addClass(className || self.currentItem[0].className+" ui-sortable-placeholder") |
---|
| 1361 | .removeClass("ui-sortable-helper")[0]; |
---|
| 1362 | |
---|
| 1363 | if(!className) |
---|
| 1364 | el.style.visibility = "hidden"; |
---|
| 1365 | |
---|
| 1366 | return el; |
---|
| 1367 | }, |
---|
| 1368 | update: function(container, p) { |
---|
| 1369 | |
---|
| 1370 | // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that |
---|
| 1371 | // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified |
---|
| 1372 | if(className && !o.forcePlaceholderSize) return; |
---|
| 1373 | |
---|
| 1374 | //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 |
---|
| 1375 | if(!p.height()) { p.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css('paddingTop')||0, 10) - parseInt(self.currentItem.css('paddingBottom')||0, 10)); }; |
---|
| 1376 | if(!p.width()) { p.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css('paddingLeft')||0, 10) - parseInt(self.currentItem.css('paddingRight')||0, 10)); }; |
---|
| 1377 | } |
---|
| 1378 | }; |
---|
| 1379 | } |
---|
| 1380 | |
---|
| 1381 | //Create the placeholder |
---|
| 1382 | self.placeholder = $(o.placeholder.element.call(self.element, self.currentItem)); |
---|
| 1383 | |
---|
| 1384 | //Append it after the actual current item |
---|
| 1385 | self.currentItem.after(self.placeholder); |
---|
| 1386 | |
---|
| 1387 | //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317) |
---|
| 1388 | o.placeholder.update(self, self.placeholder); |
---|
| 1389 | |
---|
| 1390 | }, |
---|
| 1391 | |
---|
| 1392 | _contactContainers: function(event) { |
---|
| 1393 | |
---|
| 1394 | // get innermost container that intersects with item |
---|
| 1395 | var innermostContainer = null, innermostIndex = null; |
---|
| 1396 | |
---|
| 1397 | |
---|
| 1398 | for (var i = this.containers.length - 1; i >= 0; i--){ |
---|
| 1399 | |
---|
| 1400 | // never consider a container that's located within the item itself |
---|
| 1401 | if($.ui.contains(this.currentItem[0], this.containers[i].element[0])) |
---|
| 1402 | continue; |
---|
| 1403 | |
---|
| 1404 | if(this._intersectsWith(this.containers[i].containerCache)) { |
---|
| 1405 | |
---|
| 1406 | // if we've already found a container and it's more "inner" than this, then continue |
---|
| 1407 | if(innermostContainer && $.ui.contains(this.containers[i].element[0], innermostContainer.element[0])) |
---|
| 1408 | continue; |
---|
| 1409 | |
---|
| 1410 | innermostContainer = this.containers[i]; |
---|
| 1411 | innermostIndex = i; |
---|
| 1412 | |
---|
| 1413 | } else { |
---|
| 1414 | // container doesn't intersect. trigger "out" event if necessary |
---|
| 1415 | if(this.containers[i].containerCache.over) { |
---|
| 1416 | this.containers[i]._trigger("out", event, this._uiHash(this)); |
---|
| 1417 | this.containers[i].containerCache.over = 0; |
---|
| 1418 | } |
---|
| 1419 | } |
---|
| 1420 | |
---|
| 1421 | } |
---|
| 1422 | |
---|
| 1423 | // if no intersecting containers found, return |
---|
| 1424 | if(!innermostContainer) return; |
---|
| 1425 | |
---|
| 1426 | // move the item into the container if it's not there already |
---|
| 1427 | if(this.containers.length === 1) { |
---|
| 1428 | this.containers[innermostIndex]._trigger("over", event, this._uiHash(this)); |
---|
| 1429 | this.containers[innermostIndex].containerCache.over = 1; |
---|
| 1430 | } else if(this.currentContainer != this.containers[innermostIndex]) { |
---|
| 1431 | |
---|
| 1432 | //When entering a new container, we will find the item with the least distance and append our item near it |
---|
| 1433 | var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[innermostIndex].floating ? 'left' : 'top']; |
---|
| 1434 | for (var j = this.items.length - 1; j >= 0; j--) { |
---|
| 1435 | if(!$.ui.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) continue; |
---|
| 1436 | var cur = this.items[j][this.containers[innermostIndex].floating ? 'left' : 'top']; |
---|
| 1437 | if(Math.abs(cur - base) < dist) { |
---|
| 1438 | dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j]; |
---|
| 1439 | } |
---|
| 1440 | } |
---|
| 1441 | |
---|
| 1442 | if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled |
---|
| 1443 | return; |
---|
| 1444 | |
---|
| 1445 | this.currentContainer = this.containers[innermostIndex]; |
---|
| 1446 | itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true); |
---|
| 1447 | this._trigger("change", event, this._uiHash()); |
---|
| 1448 | this.containers[innermostIndex]._trigger("change", event, this._uiHash(this)); |
---|
| 1449 | |
---|
| 1450 | //Update the placeholder |
---|
| 1451 | this.options.placeholder.update(this.currentContainer, this.placeholder); |
---|
| 1452 | |
---|
| 1453 | this.containers[innermostIndex]._trigger("over", event, this._uiHash(this)); |
---|
| 1454 | this.containers[innermostIndex].containerCache.over = 1; |
---|
| 1455 | } |
---|
| 1456 | |
---|
| 1457 | |
---|
| 1458 | }, |
---|
| 1459 | |
---|
| 1460 | _createHelper: function(event) { |
---|
| 1461 | |
---|
| 1462 | var o = this.options; |
---|
| 1463 | var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper == 'clone' ? this.currentItem.clone() : this.currentItem); |
---|
| 1464 | |
---|
| 1465 | if(!helper.parents('body').length) //Add the helper to the DOM if that didn't happen already |
---|
| 1466 | $(o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]); |
---|
| 1467 | |
---|
| 1468 | if(helper[0] == this.currentItem[0]) |
---|
| 1469 | 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") }; |
---|
| 1470 | |
---|
| 1471 | if(helper[0].style.width == '' || o.forceHelperSize) helper.width(this.currentItem.width()); |
---|
| 1472 | if(helper[0].style.height == '' || o.forceHelperSize) helper.height(this.currentItem.height()); |
---|
| 1473 | |
---|
| 1474 | return helper; |
---|
| 1475 | |
---|
| 1476 | }, |
---|
| 1477 | |
---|
| 1478 | _adjustOffsetFromHelper: function(obj) { |
---|
| 1479 | if (typeof obj == 'string') { |
---|
| 1480 | obj = obj.split(' '); |
---|
| 1481 | } |
---|
| 1482 | if ($.isArray(obj)) { |
---|
| 1483 | obj = {left: +obj[0], top: +obj[1] || 0}; |
---|
| 1484 | } |
---|
| 1485 | if ('left' in obj) { |
---|
| 1486 | this.offset.click.left = obj.left + this.margins.left; |
---|
| 1487 | } |
---|
| 1488 | if ('right' in obj) { |
---|
| 1489 | this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left; |
---|
| 1490 | } |
---|
| 1491 | if ('top' in obj) { |
---|
| 1492 | this.offset.click.top = obj.top + this.margins.top; |
---|
| 1493 | } |
---|
| 1494 | if ('bottom' in obj) { |
---|
| 1495 | this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top; |
---|
| 1496 | } |
---|
| 1497 | }, |
---|
| 1498 | |
---|
| 1499 | _getParentOffset: function() { |
---|
| 1500 | |
---|
| 1501 | |
---|
| 1502 | //Get the offsetParent and cache its position |
---|
| 1503 | this.offsetParent = this.helper.offsetParent(); |
---|
| 1504 | var po = this.offsetParent.offset(); |
---|
| 1505 | |
---|
| 1506 | // This is a special case where we need to modify a offset calculated on start, since the following happened: |
---|
| 1507 | // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent |
---|
| 1508 | // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that |
---|
| 1509 | // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag |
---|
| 1510 | if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) { |
---|
| 1511 | po.left += this.scrollParent.scrollLeft(); |
---|
| 1512 | po.top += this.scrollParent.scrollTop(); |
---|
| 1513 | } |
---|
| 1514 | |
---|
| 1515 | if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information |
---|
| 1516 | || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix |
---|
| 1517 | po = { top: 0, left: 0 }; |
---|
| 1518 | |
---|
| 1519 | return { |
---|
| 1520 | top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0), |
---|
| 1521 | left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0) |
---|
| 1522 | }; |
---|
| 1523 | |
---|
| 1524 | }, |
---|
| 1525 | |
---|
| 1526 | _getRelativeOffset: function() { |
---|
| 1527 | |
---|
| 1528 | if(this.cssPosition == "relative") { |
---|
| 1529 | var p = this.currentItem.position(); |
---|
| 1530 | return { |
---|
| 1531 | top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(), |
---|
| 1532 | left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft() |
---|
| 1533 | }; |
---|
| 1534 | } else { |
---|
| 1535 | return { top: 0, left: 0 }; |
---|
| 1536 | } |
---|
| 1537 | |
---|
| 1538 | }, |
---|
| 1539 | |
---|
| 1540 | _cacheMargins: function() { |
---|
| 1541 | this.margins = { |
---|
| 1542 | left: (parseInt(this.currentItem.css("marginLeft"),10) || 0), |
---|
| 1543 | top: (parseInt(this.currentItem.css("marginTop"),10) || 0) |
---|
| 1544 | }; |
---|
| 1545 | }, |
---|
| 1546 | |
---|
| 1547 | _cacheHelperProportions: function() { |
---|
| 1548 | this.helperProportions = { |
---|
| 1549 | width: this.helper.outerWidth(), |
---|
| 1550 | height: this.helper.outerHeight() |
---|
| 1551 | }; |
---|
| 1552 | }, |
---|
| 1553 | |
---|
| 1554 | _setContainment: function() { |
---|
| 1555 | |
---|
| 1556 | var o = this.options; |
---|
| 1557 | if(o.containment == 'parent') o.containment = this.helper[0].parentNode; |
---|
| 1558 | if(o.containment == 'document' || o.containment == 'window') this.containment = [ |
---|
| 1559 | 0 - this.offset.relative.left - this.offset.parent.left, |
---|
| 1560 | 0 - this.offset.relative.top - this.offset.parent.top, |
---|
| 1561 | $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left, |
---|
| 1562 | ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top |
---|
| 1563 | ]; |
---|
| 1564 | |
---|
| 1565 | if(!(/^(document|window|parent)$/).test(o.containment)) { |
---|
| 1566 | var ce = $(o.containment)[0]; |
---|
| 1567 | var co = $(o.containment).offset(); |
---|
| 1568 | var over = ($(ce).css("overflow") != 'hidden'); |
---|
| 1569 | |
---|
| 1570 | this.containment = [ |
---|
| 1571 | co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left, |
---|
| 1572 | co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top, |
---|
| 1573 | 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, |
---|
| 1574 | 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 |
---|
| 1575 | ]; |
---|
| 1576 | } |
---|
| 1577 | |
---|
| 1578 | }, |
---|
| 1579 | |
---|
| 1580 | _convertPositionTo: function(d, pos) { |
---|
| 1581 | |
---|
| 1582 | if(!pos) pos = this.position; |
---|
| 1583 | var mod = d == "absolute" ? 1 : -1; |
---|
| 1584 | var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName); |
---|
| 1585 | |
---|
| 1586 | return { |
---|
| 1587 | top: ( |
---|
| 1588 | pos.top // The absolute mouse position |
---|
| 1589 | + this.offset.relative.top * mod // Only for relative positioned nodes: Relative offset from element to offset parent |
---|
| 1590 | + this.offset.parent.top * mod // The offsetParent's offset without borders (offset + border) |
---|
| 1591 | - ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod) |
---|
| 1592 | ), |
---|
| 1593 | left: ( |
---|
| 1594 | pos.left // The absolute mouse position |
---|
| 1595 | + this.offset.relative.left * mod // Only for relative positioned nodes: Relative offset from element to offset parent |
---|
| 1596 | + this.offset.parent.left * mod // The offsetParent's offset without borders (offset + border) |
---|
| 1597 | - ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod) |
---|
| 1598 | ) |
---|
| 1599 | }; |
---|
| 1600 | |
---|
| 1601 | }, |
---|
| 1602 | |
---|
| 1603 | _generatePosition: function(event) { |
---|
| 1604 | |
---|
| 1605 | var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName); |
---|
| 1606 | |
---|
| 1607 | // This is another very weird special case that only happens for relative elements: |
---|
| 1608 | // 1. If the css position is relative |
---|
| 1609 | // 2. and the scroll parent is the document or similar to the offset parent |
---|
| 1610 | // we have to refresh the relative offset during the scroll so there are no jumps |
---|
| 1611 | if(this.cssPosition == 'relative' && !(this.scrollParent[0] != document && this.scrollParent[0] != this.offsetParent[0])) { |
---|
| 1612 | this.offset.relative = this._getRelativeOffset(); |
---|
| 1613 | } |
---|
| 1614 | |
---|
| 1615 | var pageX = event.pageX; |
---|
| 1616 | var pageY = event.pageY; |
---|
| 1617 | |
---|
| 1618 | /* |
---|
| 1619 | * - Position constraining - |
---|
| 1620 | * Constrain the position to a mix of grid, containment. |
---|
| 1621 | */ |
---|
| 1622 | |
---|
| 1623 | if(this.originalPosition) { //If we are not dragging yet, we won't check for options |
---|
| 1624 | |
---|
| 1625 | if(this.containment) { |
---|
| 1626 | if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left; |
---|
| 1627 | if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top; |
---|
| 1628 | if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left; |
---|
| 1629 | if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top; |
---|
| 1630 | } |
---|
| 1631 | |
---|
| 1632 | if(o.grid) { |
---|
| 1633 | var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1]; |
---|
| 1634 | 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; |
---|
| 1635 | |
---|
| 1636 | var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0]; |
---|
| 1637 | 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; |
---|
| 1638 | } |
---|
| 1639 | |
---|
| 1640 | } |
---|
| 1641 | |
---|
| 1642 | return { |
---|
| 1643 | top: ( |
---|
| 1644 | pageY // The absolute mouse position |
---|
| 1645 | - this.offset.click.top // Click offset (relative to the element) |
---|
| 1646 | - this.offset.relative.top // Only for relative positioned nodes: Relative offset from element to offset parent |
---|
| 1647 | - this.offset.parent.top // The offsetParent's offset without borders (offset + border) |
---|
| 1648 | + ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) )) |
---|
| 1649 | ), |
---|
| 1650 | left: ( |
---|
| 1651 | pageX // The absolute mouse position |
---|
| 1652 | - this.offset.click.left // Click offset (relative to the element) |
---|
| 1653 | - this.offset.relative.left // Only for relative positioned nodes: Relative offset from element to offset parent |
---|
| 1654 | - this.offset.parent.left // The offsetParent's offset without borders (offset + border) |
---|
| 1655 | + ($.browser.safari && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() )) |
---|
| 1656 | ) |
---|
| 1657 | }; |
---|
| 1658 | |
---|
| 1659 | }, |
---|
| 1660 | |
---|
| 1661 | _rearrange: function(event, i, a, hardRefresh) { |
---|
| 1662 | |
---|
| 1663 | 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)); |
---|
| 1664 | |
---|
| 1665 | //Various things done here to improve the performance: |
---|
| 1666 | // 1. we create a setTimeout, that calls refreshPositions |
---|
| 1667 | // 2. on the instance, we have a counter variable, that get's higher after every append |
---|
| 1668 | // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same |
---|
| 1669 | // 4. this lets only the last addition to the timeout stack through |
---|
| 1670 | this.counter = this.counter ? ++this.counter : 1; |
---|
| 1671 | var self = this, counter = this.counter; |
---|
| 1672 | |
---|
| 1673 | window.setTimeout(function() { |
---|
| 1674 | if(counter == self.counter) self.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove |
---|
| 1675 | },0); |
---|
| 1676 | |
---|
| 1677 | }, |
---|
| 1678 | |
---|
| 1679 | _clear: function(event, noPropagation) { |
---|
| 1680 | |
---|
| 1681 | this.reverting = false; |
---|
| 1682 | // We delay all events that have to be triggered to after the point where the placeholder has been removed and |
---|
| 1683 | // everything else normalized again |
---|
| 1684 | var delayedTriggers = [], self = this; |
---|
| 1685 | |
---|
| 1686 | // We first have to update the dom position of the actual currentItem |
---|
| 1687 | // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088) |
---|
| 1688 | if(!this._noFinalSort && this.currentItem[0].parentNode) this.placeholder.before(this.currentItem); |
---|
| 1689 | this._noFinalSort = null; |
---|
| 1690 | |
---|
| 1691 | if(this.helper[0] == this.currentItem[0]) { |
---|
| 1692 | for(var i in this._storedCSS) { |
---|
| 1693 | if(this._storedCSS[i] == 'auto' || this._storedCSS[i] == 'static') this._storedCSS[i] = ''; |
---|
| 1694 | } |
---|
| 1695 | this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper"); |
---|
| 1696 | } else { |
---|
| 1697 | this.currentItem.show(); |
---|
| 1698 | } |
---|
| 1699 | |
---|
| 1700 | if(this.fromOutside && !noPropagation) delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); }); |
---|
| 1701 | if((this.fromOutside || this.domPosition.prev != this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent != this.currentItem.parent()[0]) && !noPropagation) delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed |
---|
| 1702 | if(!$.ui.contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element |
---|
| 1703 | if(!noPropagation) delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); }); |
---|
| 1704 | for (var i = this.containers.length - 1; i >= 0; i--){ |
---|
| 1705 | if($.ui.contains(this.containers[i].element[0], this.currentItem[0]) && !noPropagation) { |
---|
| 1706 | delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.containers[i])); |
---|
| 1707 | delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.containers[i])); |
---|
| 1708 | } |
---|
| 1709 | }; |
---|
| 1710 | }; |
---|
| 1711 | |
---|
| 1712 | //Post events to containers |
---|
| 1713 | for (var i = this.containers.length - 1; i >= 0; i--){ |
---|
| 1714 | if(!noPropagation) delayedTriggers.push((function(c) { return function(event) { c._trigger("deactivate", event, this._uiHash(this)); }; }).call(this, this.containers[i])); |
---|
| 1715 | if(this.containers[i].containerCache.over) { |
---|
| 1716 | delayedTriggers.push((function(c) { return function(event) { c._trigger("out", event, this._uiHash(this)); }; }).call(this, this.containers[i])); |
---|
| 1717 | this.containers[i].containerCache.over = 0; |
---|
| 1718 | } |
---|
| 1719 | } |
---|
| 1720 | |
---|
| 1721 | //Do what was originally in plugins |
---|
| 1722 | if(this._storedCursor) $('body').css("cursor", this._storedCursor); //Reset cursor |
---|
| 1723 | if(this._storedOpacity) this.helper.css("opacity", this._storedOpacity); //Reset opacity |
---|
| 1724 | if(this._storedZIndex) this.helper.css("zIndex", this._storedZIndex == 'auto' ? '' : this._storedZIndex); //Reset z-index |
---|
| 1725 | |
---|
| 1726 | this.dragging = false; |
---|
| 1727 | if(this.cancelHelperRemoval) { |
---|
| 1728 | if(!noPropagation) { |
---|
| 1729 | this._trigger("beforeStop", event, this._uiHash()); |
---|
| 1730 | for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events |
---|
| 1731 | this._trigger("stop", event, this._uiHash()); |
---|
| 1732 | } |
---|
| 1733 | return false; |
---|
| 1734 | } |
---|
| 1735 | |
---|
| 1736 | if(!noPropagation) this._trigger("beforeStop", event, this._uiHash()); |
---|
| 1737 | |
---|
| 1738 | //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node! |
---|
| 1739 | this.placeholder[0].parentNode.removeChild(this.placeholder[0]); |
---|
| 1740 | |
---|
| 1741 | if(this.helper[0] != this.currentItem[0]) this.helper.remove(); this.helper = null; |
---|
| 1742 | |
---|
| 1743 | if(!noPropagation) { |
---|
| 1744 | for (var i=0; i < delayedTriggers.length; i++) { delayedTriggers[i].call(this, event); }; //Trigger all delayed events |
---|
| 1745 | this._trigger("stop", event, this._uiHash()); |
---|
| 1746 | } |
---|
| 1747 | |
---|
| 1748 | this.fromOutside = false; |
---|
| 1749 | return true; |
---|
| 1750 | |
---|
| 1751 | }, |
---|
| 1752 | |
---|
| 1753 | _trigger: function() { |
---|
| 1754 | if ($.Widget.prototype._trigger.apply(this, arguments) === false) { |
---|
| 1755 | this.cancel(); |
---|
| 1756 | } |
---|
| 1757 | }, |
---|
| 1758 | |
---|
| 1759 | _uiHash: function(inst) { |
---|
| 1760 | var self = inst || this; |
---|
| 1761 | return { |
---|
| 1762 | helper: self.helper, |
---|
| 1763 | placeholder: self.placeholder || $([]), |
---|
| 1764 | position: self.position, |
---|
| 1765 | originalPosition: self.originalPosition, |
---|
| 1766 | offset: self.positionAbs, |
---|
| 1767 | item: self.currentItem, |
---|
| 1768 | sender: inst ? inst.element : null |
---|
| 1769 | }; |
---|
| 1770 | } |
---|
| 1771 | |
---|
| 1772 | }); |
---|
| 1773 | |
---|
| 1774 | $.extend($.ui.sortable, { |
---|
| 1775 | version: "1.8.5" |
---|
| 1776 | }); |
---|
| 1777 | |
---|
| 1778 | })(jQuery); |
---|
| 1779 | /* |
---|
| 1780 | * jQuery UI Slider 1.8.5 |
---|
| 1781 | * |
---|
| 1782 | * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about) |
---|
| 1783 | * Dual licensed under the MIT or GPL Version 2 licenses. |
---|
| 1784 | * http://jquery.org/license |
---|
| 1785 | * |
---|
| 1786 | * http://docs.jquery.com/UI/Slider |
---|
| 1787 | * |
---|
| 1788 | * Depends: |
---|
| 1789 | * jquery.ui.core.js |
---|
| 1790 | * jquery.ui.mouse.js |
---|
| 1791 | * jquery.ui.widget.js |
---|
| 1792 | */ |
---|
| 1793 | (function( $, undefined ) { |
---|
| 1794 | |
---|
| 1795 | // number of pages in a slider |
---|
| 1796 | // (how many times can you page up/down to go through the whole range) |
---|
| 1797 | var numPages = 5; |
---|
| 1798 | |
---|
| 1799 | $.widget( "ui.slider", $.ui.mouse, { |
---|
| 1800 | |
---|
| 1801 | widgetEventPrefix: "slide", |
---|
| 1802 | |
---|
| 1803 | options: { |
---|
| 1804 | animate: false, |
---|
| 1805 | distance: 0, |
---|
| 1806 | max: 100, |
---|
| 1807 | min: 0, |
---|
| 1808 | orientation: "horizontal", |
---|
| 1809 | range: false, |
---|
| 1810 | step: 1, |
---|
| 1811 | value: 0, |
---|
| 1812 | values: null |
---|
| 1813 | }, |
---|
| 1814 | |
---|
| 1815 | _create: function() { |
---|
| 1816 | var self = this, |
---|
| 1817 | o = this.options; |
---|
| 1818 | |
---|
| 1819 | this._keySliding = false; |
---|
| 1820 | this._mouseSliding = false; |
---|
| 1821 | this._animateOff = true; |
---|
| 1822 | this._handleIndex = null; |
---|
| 1823 | this._detectOrientation(); |
---|
| 1824 | this._mouseInit(); |
---|
| 1825 | |
---|
| 1826 | this.element |
---|
| 1827 | .addClass( "ui-slider" + |
---|
| 1828 | " ui-slider-" + this.orientation + |
---|
| 1829 | " ui-widget" + |
---|
| 1830 | " ui-widget-content" + |
---|
| 1831 | " ui-corner-all" ); |
---|
| 1832 | |
---|
| 1833 | if ( o.disabled ) { |
---|
| 1834 | this.element.addClass( "ui-slider-disabled ui-disabled" ); |
---|
| 1835 | } |
---|
| 1836 | |
---|
| 1837 | this.range = $([]); |
---|
| 1838 | |
---|
| 1839 | if ( o.range ) { |
---|
| 1840 | if ( o.range === true ) { |
---|
| 1841 | this.range = $( "<div></div>" ); |
---|
| 1842 | if ( !o.values ) { |
---|
| 1843 | o.values = [ this._valueMin(), this._valueMin() ]; |
---|
| 1844 | } |
---|
| 1845 | if ( o.values.length && o.values.length !== 2 ) { |
---|
| 1846 | o.values = [ o.values[0], o.values[0] ]; |
---|
| 1847 | } |
---|
| 1848 | } else { |
---|
| 1849 | this.range = $( "<div></div>" ); |
---|
| 1850 | } |
---|
| 1851 | |
---|
| 1852 | this.range |
---|
| 1853 | .appendTo( this.element ) |
---|
| 1854 | .addClass( "ui-slider-range" ); |
---|
| 1855 | |
---|
| 1856 | if ( o.range === "min" || o.range === "max" ) { |
---|
| 1857 | this.range.addClass( "ui-slider-range-" + o.range ); |
---|
| 1858 | } |
---|
| 1859 | |
---|
| 1860 | // note: this isn't the most fittingly semantic framework class for this element, |
---|
| 1861 | // but worked best visually with a variety of themes |
---|
| 1862 | this.range.addClass( "ui-widget-header" ); |
---|
| 1863 | } |
---|
| 1864 | |
---|
| 1865 | if ( $( ".ui-slider-handle", this.element ).length === 0 ) { |
---|
| 1866 | $( "<a href='#'></a>" ) |
---|
| 1867 | .appendTo( this.element ) |
---|
| 1868 | .addClass( "ui-slider-handle" ); |
---|
| 1869 | } |
---|
| 1870 | |
---|
| 1871 | if ( o.values && o.values.length ) { |
---|
| 1872 | while ( $(".ui-slider-handle", this.element).length < o.values.length ) { |
---|
| 1873 | $( "<a href='#'></a>" ) |
---|
| 1874 | .appendTo( this.element ) |
---|
| 1875 | .addClass( "ui-slider-handle" ); |
---|
| 1876 | } |
---|
| 1877 | } |
---|
| 1878 | |
---|
| 1879 | this.handles = $( ".ui-slider-handle", this.element ) |
---|
| 1880 | .addClass( "ui-state-default" + |
---|
| 1881 | " ui-corner-all" ); |
---|
| 1882 | |
---|
| 1883 | this.handle = this.handles.eq( 0 ); |
---|
| 1884 | |
---|
| 1885 | this.handles.add( this.range ).filter( "a" ) |
---|
| 1886 | .click(function( event ) { |
---|
| 1887 | event.preventDefault(); |
---|
| 1888 | }) |
---|
| 1889 | .hover(function() { |
---|
| 1890 | if ( !o.disabled ) { |
---|
| 1891 | $( this ).addClass( "ui-state-hover" ); |
---|
| 1892 | } |
---|
| 1893 | }, function() { |
---|
| 1894 | $( this ).removeClass( "ui-state-hover" ); |
---|
| 1895 | }) |
---|
| 1896 | .focus(function() { |
---|
| 1897 | if ( !o.disabled ) { |
---|
| 1898 | $( ".ui-slider .ui-state-focus" ).removeClass( "ui-state-focus" ); |
---|
| 1899 | $( this ).addClass( "ui-state-focus" ); |
---|
| 1900 | } else { |
---|
| 1901 | $( this ).blur(); |
---|
| 1902 | } |
---|
| 1903 | }) |
---|
| 1904 | .blur(function() { |
---|
| 1905 | $( this ).removeClass( "ui-state-focus" ); |
---|
| 1906 | }); |
---|
| 1907 | |
---|
| 1908 | this.handles.each(function( i ) { |
---|
| 1909 | $( this ).data( "index.ui-slider-handle", i ); |
---|
| 1910 | }); |
---|
| 1911 | |
---|
| 1912 | this.handles |
---|
| 1913 | .keydown(function( event ) { |
---|
| 1914 | var ret = true, |
---|
| 1915 | index = $( this ).data( "index.ui-slider-handle" ), |
---|
| 1916 | allowed, |
---|
| 1917 | curVal, |
---|
| 1918 | newVal, |
---|
| 1919 | step; |
---|
| 1920 | |
---|
| 1921 | if ( self.options.disabled ) { |
---|
| 1922 | return; |
---|
| 1923 | } |
---|
| 1924 | |
---|
| 1925 | switch ( event.keyCode ) { |
---|
| 1926 | case $.ui.keyCode.HOME: |
---|
| 1927 | case $.ui.keyCode.END: |
---|
| 1928 | case $.ui.keyCode.PAGE_UP: |
---|
| 1929 | case $.ui.keyCode.PAGE_DOWN: |
---|
| 1930 | case $.ui.keyCode.UP: |
---|
| 1931 | case $.ui.keyCode.RIGHT: |
---|
| 1932 | case $.ui.keyCode.DOWN: |
---|
| 1933 | case $.ui.keyCode.LEFT: |
---|
| 1934 | ret = false; |
---|
| 1935 | if ( !self._keySliding ) { |
---|
| 1936 | self._keySliding = true; |
---|
| 1937 | $( this ).addClass( "ui-state-active" ); |
---|
| 1938 | allowed = self._start( event, index ); |
---|
| 1939 | if ( allowed === false ) { |
---|
| 1940 | return; |
---|
| 1941 | } |
---|
| 1942 | } |
---|
| 1943 | break; |
---|
| 1944 | } |
---|
| 1945 | |
---|
| 1946 | step = self.options.step; |
---|
| 1947 | if ( self.options.values && self.options.values.length ) { |
---|
| 1948 | curVal = newVal = self.values( index ); |
---|
| 1949 | } else { |
---|
| 1950 | curVal = newVal = self.value(); |
---|
| 1951 | } |
---|
| 1952 | |
---|
| 1953 | switch ( event.keyCode ) { |
---|
| 1954 | case $.ui.keyCode.HOME: |
---|
| 1955 | newVal = self._valueMin(); |
---|
| 1956 | break; |
---|
| 1957 | case $.ui.keyCode.END: |
---|
| 1958 | newVal = self._valueMax(); |
---|
| 1959 | break; |
---|
| 1960 | case $.ui.keyCode.PAGE_UP: |
---|
| 1961 | newVal = self._trimAlignValue( curVal + ( (self._valueMax() - self._valueMin()) / numPages ) ); |
---|
| 1962 | break; |
---|
| 1963 | case $.ui.keyCode.PAGE_DOWN: |
---|
| 1964 | newVal = self._trimAlignValue( curVal - ( (self._valueMax() - self._valueMin()) / numPages ) ); |
---|
| 1965 | break; |
---|
| 1966 | case $.ui.keyCode.UP: |
---|
| 1967 | case $.ui.keyCode.RIGHT: |
---|
| 1968 | if ( curVal === self._valueMax() ) { |
---|
| 1969 | return; |
---|
| 1970 | } |
---|
| 1971 | newVal = self._trimAlignValue( curVal + step ); |
---|
| 1972 | break; |
---|
| 1973 | case $.ui.keyCode.DOWN: |
---|
| 1974 | case $.ui.keyCode.LEFT: |
---|
| 1975 | if ( curVal === self._valueMin() ) { |
---|
| 1976 | return; |
---|
| 1977 | } |
---|
| 1978 | newVal = self._trimAlignValue( curVal - step ); |
---|
| 1979 | break; |
---|
| 1980 | } |
---|
| 1981 | |
---|
| 1982 | self._slide( event, index, newVal ); |
---|
| 1983 | |
---|
| 1984 | return ret; |
---|
| 1985 | |
---|
| 1986 | }) |
---|
| 1987 | .keyup(function( event ) { |
---|
| 1988 | var index = $( this ).data( "index.ui-slider-handle" ); |
---|
| 1989 | |
---|
| 1990 | if ( self._keySliding ) { |
---|
| 1991 | self._keySliding = false; |
---|
| 1992 | self._stop( event, index ); |
---|
| 1993 | self._change( event, index ); |
---|
| 1994 | $( this ).removeClass( "ui-state-active" ); |
---|
| 1995 | } |
---|
| 1996 | |
---|
| 1997 | }); |
---|
| 1998 | |
---|
| 1999 | this._refreshValue(); |
---|
| 2000 | |
---|
| 2001 | this._animateOff = false; |
---|
| 2002 | }, |
---|
| 2003 | |
---|
| 2004 | destroy: function() { |
---|
| 2005 | this.handles.remove(); |
---|
| 2006 | this.range.remove(); |
---|
| 2007 | |
---|
| 2008 | this.element |
---|
| 2009 | .removeClass( "ui-slider" + |
---|
| 2010 | " ui-slider-horizontal" + |
---|
| 2011 | " ui-slider-vertical" + |
---|
| 2012 | " ui-slider-disabled" + |
---|
| 2013 | " ui-widget" + |
---|
| 2014 | " ui-widget-content" + |
---|
| 2015 | " ui-corner-all" ) |
---|
| 2016 | .removeData( "slider" ) |
---|
| 2017 | .unbind( ".slider" ); |
---|
| 2018 | |
---|
| 2019 | this._mouseDestroy(); |
---|
| 2020 | |
---|
| 2021 | return this; |
---|
| 2022 | }, |
---|
| 2023 | |
---|
| 2024 | _mouseCapture: function( event ) { |
---|
| 2025 | var o = this.options, |
---|
| 2026 | position, |
---|
| 2027 | normValue, |
---|
| 2028 | distance, |
---|
| 2029 | closestHandle, |
---|
| 2030 | self, |
---|
| 2031 | index, |
---|
| 2032 | allowed, |
---|
| 2033 | offset, |
---|
| 2034 | mouseOverHandle; |
---|
| 2035 | |
---|
| 2036 | if ( o.disabled ) { |
---|
| 2037 | return false; |
---|
| 2038 | } |
---|
| 2039 | |
---|
| 2040 | this.elementSize = { |
---|
| 2041 | width: this.element.outerWidth(), |
---|
| 2042 | height: this.element.outerHeight() |
---|
| 2043 | }; |
---|
| 2044 | this.elementOffset = this.element.offset(); |
---|
| 2045 | |
---|
| 2046 | position = { x: event.pageX, y: event.pageY }; |
---|
| 2047 | normValue = this._normValueFromMouse( position ); |
---|
| 2048 | distance = this._valueMax() - this._valueMin() + 1; |
---|
| 2049 | self = this; |
---|
| 2050 | this.handles.each(function( i ) { |
---|
| 2051 | var thisDistance = Math.abs( normValue - self.values(i) ); |
---|
| 2052 | if ( distance > thisDistance ) { |
---|
| 2053 | distance = thisDistance; |
---|
| 2054 | closestHandle = $( this ); |
---|
| 2055 | index = i; |
---|
| 2056 | } |
---|
| 2057 | }); |
---|
| 2058 | |
---|
| 2059 | // workaround for bug #3736 (if both handles of a range are at 0, |
---|
| 2060 | // the first is always used as the one with least distance, |
---|
| 2061 | // and moving it is obviously prevented by preventing negative ranges) |
---|
| 2062 | if( o.range === true && this.values(1) === o.min ) { |
---|
| 2063 | index += 1; |
---|
| 2064 | closestHandle = $( this.handles[index] ); |
---|
| 2065 | } |
---|
| 2066 | |
---|
| 2067 | allowed = this._start( event, index ); |
---|
| 2068 | if ( allowed === false ) { |
---|
| 2069 | return false; |
---|
| 2070 | } |
---|
| 2071 | this._mouseSliding = true; |
---|
| 2072 | |
---|
| 2073 | self._handleIndex = index; |
---|
| 2074 | |
---|
| 2075 | closestHandle |
---|
| 2076 | .addClass( "ui-state-active" ) |
---|
| 2077 | .focus(); |
---|
| 2078 | |
---|
| 2079 | offset = closestHandle.offset(); |
---|
| 2080 | mouseOverHandle = !$( event.target ).parents().andSelf().is( ".ui-slider-handle" ); |
---|
| 2081 | this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : { |
---|
| 2082 | left: event.pageX - offset.left - ( closestHandle.width() / 2 ), |
---|
| 2083 | top: event.pageY - offset.top - |
---|
| 2084 | ( closestHandle.height() / 2 ) - |
---|
| 2085 | ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) - |
---|
| 2086 | ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) + |
---|
| 2087 | ( parseInt( closestHandle.css("marginTop"), 10 ) || 0) |
---|
| 2088 | }; |
---|
| 2089 | |
---|
| 2090 | this._slide( event, index, normValue ); |
---|
| 2091 | this._animateOff = true; |
---|
| 2092 | return true; |
---|
| 2093 | }, |
---|
| 2094 | |
---|
| 2095 | _mouseStart: function( event ) { |
---|
| 2096 | return true; |
---|
| 2097 | }, |
---|
| 2098 | |
---|
| 2099 | _mouseDrag: function( event ) { |
---|
| 2100 | var position = { x: event.pageX, y: event.pageY }, |
---|
| 2101 | normValue = this._normValueFromMouse( position ); |
---|
| 2102 | |
---|
| 2103 | this._slide( event, this._handleIndex, normValue ); |
---|
| 2104 | |
---|
| 2105 | return false; |
---|
| 2106 | }, |
---|
| 2107 | |
---|
| 2108 | _mouseStop: function( event ) { |
---|
| 2109 | this.handles.removeClass( "ui-state-active" ); |
---|
| 2110 | this._mouseSliding = false; |
---|
| 2111 | |
---|
| 2112 | this._stop( event, this._handleIndex ); |
---|
| 2113 | this._change( event, this._handleIndex ); |
---|
| 2114 | |
---|
| 2115 | this._handleIndex = null; |
---|
| 2116 | this._clickOffset = null; |
---|
| 2117 | this._animateOff = false; |
---|
| 2118 | |
---|
| 2119 | return false; |
---|
| 2120 | }, |
---|
| 2121 | |
---|
| 2122 | _detectOrientation: function() { |
---|
| 2123 | this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal"; |
---|
| 2124 | }, |
---|
| 2125 | |
---|
| 2126 | _normValueFromMouse: function( position ) { |
---|
| 2127 | var pixelTotal, |
---|
| 2128 | pixelMouse, |
---|
| 2129 | percentMouse, |
---|
| 2130 | valueTotal, |
---|
| 2131 | valueMouse; |
---|
| 2132 | |
---|
| 2133 | if ( this.orientation === "horizontal" ) { |
---|
| 2134 | pixelTotal = this.elementSize.width; |
---|
| 2135 | pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 ); |
---|
| 2136 | } else { |
---|
| 2137 | pixelTotal = this.elementSize.height; |
---|
| 2138 | pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 ); |
---|
| 2139 | } |
---|
| 2140 | |
---|
| 2141 | percentMouse = ( pixelMouse / pixelTotal ); |
---|
| 2142 | if ( percentMouse > 1 ) { |
---|
| 2143 | percentMouse = 1; |
---|
| 2144 | } |
---|
| 2145 | if ( percentMouse < 0 ) { |
---|
| 2146 | percentMouse = 0; |
---|
| 2147 | } |
---|
| 2148 | if ( this.orientation === "vertical" ) { |
---|
| 2149 | percentMouse = 1 - percentMouse; |
---|
| 2150 | } |
---|
| 2151 | |
---|
| 2152 | valueTotal = this._valueMax() - this._valueMin(); |
---|
| 2153 | valueMouse = this._valueMin() + percentMouse * valueTotal; |
---|
| 2154 | |
---|
| 2155 | return this._trimAlignValue( valueMouse ); |
---|
| 2156 | }, |
---|
| 2157 | |
---|
| 2158 | _start: function( event, index ) { |
---|
| 2159 | var uiHash = { |
---|
| 2160 | handle: this.handles[ index ], |
---|
| 2161 | value: this.value() |
---|
| 2162 | }; |
---|
| 2163 | if ( this.options.values && this.options.values.length ) { |
---|
| 2164 | uiHash.value = this.values( index ); |
---|
| 2165 | uiHash.values = this.values(); |
---|
| 2166 | } |
---|
| 2167 | return this._trigger( "start", event, uiHash ); |
---|
| 2168 | }, |
---|
| 2169 | |
---|
| 2170 | _slide: function( event, index, newVal ) { |
---|
| 2171 | var otherVal, |
---|
| 2172 | newValues, |
---|
| 2173 | allowed; |
---|
| 2174 | |
---|
| 2175 | if ( this.options.values && this.options.values.length ) { |
---|
| 2176 | otherVal = this.values( index ? 0 : 1 ); |
---|
| 2177 | |
---|
| 2178 | if ( ( this.options.values.length === 2 && this.options.range === true ) && |
---|
| 2179 | ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) ) |
---|
| 2180 | ) { |
---|
| 2181 | newVal = otherVal; |
---|
| 2182 | } |
---|
| 2183 | |
---|
| 2184 | if ( newVal !== this.values( index ) ) { |
---|
| 2185 | newValues = this.values(); |
---|
| 2186 | newValues[ index ] = newVal; |
---|
| 2187 | // A slide can be canceled by returning false from the slide callback |
---|
| 2188 | allowed = this._trigger( "slide", event, { |
---|
| 2189 | handle: this.handles[ index ], |
---|
| 2190 | value: newVal, |
---|
| 2191 | values: newValues |
---|
| 2192 | } ); |
---|
| 2193 | otherVal = this.values( index ? 0 : 1 ); |
---|
| 2194 | if ( allowed !== false ) { |
---|
| 2195 | this.values( index, newVal, true ); |
---|
| 2196 | } |
---|
| 2197 | } |
---|
| 2198 | } else { |
---|
| 2199 | if ( newVal !== this.value() ) { |
---|
| 2200 | // A slide can be canceled by returning false from the slide callback |
---|
| 2201 | allowed = this._trigger( "slide", event, { |
---|
| 2202 | handle: this.handles[ index ], |
---|
| 2203 | value: newVal |
---|
| 2204 | } ); |
---|
| 2205 | if ( allowed !== false ) { |
---|
| 2206 | this.value( newVal ); |
---|
| 2207 | } |
---|
| 2208 | } |
---|
| 2209 | } |
---|
| 2210 | }, |
---|
| 2211 | |
---|
| 2212 | _stop: function( event, index ) { |
---|
| 2213 | var uiHash = { |
---|
| 2214 | handle: this.handles[ index ], |
---|
| 2215 | value: this.value() |
---|
| 2216 | }; |
---|
| 2217 | if ( this.options.values && this.options.values.length ) { |
---|
| 2218 | uiHash.value = this.values( index ); |
---|
| 2219 | uiHash.values = this.values(); |
---|
| 2220 | } |
---|
| 2221 | |
---|
| 2222 | this._trigger( "stop", event, uiHash ); |
---|
| 2223 | }, |
---|
| 2224 | |
---|
| 2225 | _change: function( event, index ) { |
---|
| 2226 | if ( !this._keySliding && !this._mouseSliding ) { |
---|
| 2227 | var uiHash = { |
---|
| 2228 | handle: this.handles[ index ], |
---|
| 2229 | value: this.value() |
---|
| 2230 | }; |
---|
| 2231 | if ( this.options.values && this.options.values.length ) { |
---|
| 2232 | uiHash.value = this.values( index ); |
---|
| 2233 | uiHash.values = this.values(); |
---|
| 2234 | } |
---|
| 2235 | |
---|
| 2236 | this._trigger( "change", event, uiHash ); |
---|
| 2237 | } |
---|
| 2238 | }, |
---|
| 2239 | |
---|
| 2240 | value: function( newValue ) { |
---|
| 2241 | if ( arguments.length ) { |
---|
| 2242 | this.options.value = this._trimAlignValue( newValue ); |
---|
| 2243 | this._refreshValue(); |
---|
| 2244 | this._change( null, 0 ); |
---|
| 2245 | } |
---|
| 2246 | |
---|
| 2247 | return this._value(); |
---|
| 2248 | }, |
---|
| 2249 | |
---|
| 2250 | values: function( index, newValue ) { |
---|
| 2251 | var vals, |
---|
| 2252 | newValues, |
---|
| 2253 | i; |
---|
| 2254 | |
---|
| 2255 | if ( arguments.length > 1 ) { |
---|
| 2256 | this.options.values[ index ] = this._trimAlignValue( newValue ); |
---|
| 2257 | this._refreshValue(); |
---|
| 2258 | this._change( null, index ); |
---|
| 2259 | } |
---|
| 2260 | |
---|
| 2261 | if ( arguments.length ) { |
---|
| 2262 | if ( $.isArray( arguments[ 0 ] ) ) { |
---|
| 2263 | vals = this.options.values; |
---|
| 2264 | newValues = arguments[ 0 ]; |
---|
| 2265 | for ( i = 0; i < vals.length; i += 1 ) { |
---|
| 2266 | vals[ i ] = this._trimAlignValue( newValues[ i ] ); |
---|
| 2267 | this._change( null, i ); |
---|
| 2268 | } |
---|
| 2269 | this._refreshValue(); |
---|
| 2270 | } else { |
---|
| 2271 | if ( this.options.values && this.options.values.length ) { |
---|
| 2272 | return this._values( index ); |
---|
| 2273 | } else { |
---|
| 2274 | return this.value(); |
---|
| 2275 | } |
---|
| 2276 | } |
---|
| 2277 | } else { |
---|
| 2278 | return this._values(); |
---|
| 2279 | } |
---|
| 2280 | }, |
---|
| 2281 | |
---|
| 2282 | _setOption: function( key, value ) { |
---|
| 2283 | var i, |
---|
| 2284 | valsLength = 0; |
---|
| 2285 | |
---|
| 2286 | if ( $.isArray( this.options.values ) ) { |
---|
| 2287 | valsLength = this.options.values.length; |
---|
| 2288 | } |
---|
| 2289 | |
---|
| 2290 | $.Widget.prototype._setOption.apply( this, arguments ); |
---|
| 2291 | |
---|
| 2292 | switch ( key ) { |
---|
| 2293 | case "disabled": |
---|
| 2294 | if ( value ) { |
---|
| 2295 | this.handles.filter( ".ui-state-focus" ).blur(); |
---|
| 2296 | this.handles.removeClass( "ui-state-hover" ); |
---|
| 2297 | this.handles.attr( "disabled", "disabled" ); |
---|
| 2298 | this.element.addClass( "ui-disabled" ); |
---|
| 2299 | } else { |
---|
| 2300 | this.handles.removeAttr( "disabled" ); |
---|
| 2301 | this.element.removeClass( "ui-disabled" ); |
---|
| 2302 | } |
---|
| 2303 | break; |
---|
| 2304 | case "orientation": |
---|
| 2305 | this._detectOrientation(); |
---|
| 2306 | this.element |
---|
| 2307 | .removeClass( "ui-slider-horizontal ui-slider-vertical" ) |
---|
| 2308 | .addClass( "ui-slider-" + this.orientation ); |
---|
| 2309 | this._refreshValue(); |
---|
| 2310 | break; |
---|
| 2311 | case "value": |
---|
| 2312 | this._animateOff = true; |
---|
| 2313 | this._refreshValue(); |
---|
| 2314 | this._change( null, 0 ); |
---|
| 2315 | this._animateOff = false; |
---|
| 2316 | break; |
---|
| 2317 | case "values": |
---|
| 2318 | this._animateOff = true; |
---|
| 2319 | this._refreshValue(); |
---|
| 2320 | for ( i = 0; i < valsLength; i += 1 ) { |
---|
| 2321 | this._change( null, i ); |
---|
| 2322 | } |
---|
| 2323 | this._animateOff = false; |
---|
| 2324 | break; |
---|
| 2325 | } |
---|
| 2326 | }, |
---|
| 2327 | |
---|
| 2328 | //internal value getter |
---|
| 2329 | // _value() returns value trimmed by min and max, aligned by step |
---|
| 2330 | _value: function() { |
---|
| 2331 | var val = this.options.value; |
---|
| 2332 | val = this._trimAlignValue( val ); |
---|
| 2333 | |
---|
| 2334 | return val; |
---|
| 2335 | }, |
---|
| 2336 | |
---|
| 2337 | //internal values getter |
---|
| 2338 | // _values() returns array of values trimmed by min and max, aligned by step |
---|
| 2339 | // _values( index ) returns single value trimmed by min and max, aligned by step |
---|
| 2340 | _values: function( index ) { |
---|
| 2341 | var val, |
---|
| 2342 | vals, |
---|
| 2343 | i; |
---|
| 2344 | |
---|
| 2345 | if ( arguments.length ) { |
---|
| 2346 | val = this.options.values[ index ]; |
---|
| 2347 | val = this._trimAlignValue( val ); |
---|
| 2348 | |
---|
| 2349 | return val; |
---|
| 2350 | } else { |
---|
| 2351 | // .slice() creates a copy of the array |
---|
| 2352 | // this copy gets trimmed by min and max and then returned |
---|
| 2353 | vals = this.options.values.slice(); |
---|
| 2354 | for ( i = 0; i < vals.length; i+= 1) { |
---|
| 2355 | vals[ i ] = this._trimAlignValue( vals[ i ] ); |
---|
| 2356 | } |
---|
| 2357 | |
---|
| 2358 | return vals; |
---|
| 2359 | } |
---|
| 2360 | }, |
---|
| 2361 | |
---|
| 2362 | // returns the step-aligned value that val is closest to, between (inclusive) min and max |
---|
| 2363 | _trimAlignValue: function( val ) { |
---|
| 2364 | if ( val < this._valueMin() ) { |
---|
| 2365 | return this._valueMin(); |
---|
| 2366 | } |
---|
| 2367 | if ( val > this._valueMax() ) { |
---|
| 2368 | return this._valueMax(); |
---|
| 2369 | } |
---|
| 2370 | var step = ( this.options.step > 0 ) ? this.options.step : 1, |
---|
| 2371 | valModStep = val % step, |
---|
| 2372 | alignValue = val - valModStep; |
---|
| 2373 | |
---|
| 2374 | if ( Math.abs(valModStep) * 2 >= step ) { |
---|
| 2375 | alignValue += ( valModStep > 0 ) ? step : ( -step ); |
---|
| 2376 | } |
---|
| 2377 | |
---|
| 2378 | // Since JavaScript has problems with large floats, round |
---|
| 2379 | // the final value to 5 digits after the decimal point (see #4124) |
---|
| 2380 | return parseFloat( alignValue.toFixed(5) ); |
---|
| 2381 | }, |
---|
| 2382 | |
---|
| 2383 | _valueMin: function() { |
---|
| 2384 | return this.options.min; |
---|
| 2385 | }, |
---|
| 2386 | |
---|
| 2387 | _valueMax: function() { |
---|
| 2388 | return this.options.max; |
---|
| 2389 | }, |
---|
| 2390 | |
---|
| 2391 | _refreshValue: function() { |
---|
| 2392 | var oRange = this.options.range, |
---|
| 2393 | o = this.options, |
---|
| 2394 | self = this, |
---|
| 2395 | animate = ( !this._animateOff ) ? o.animate : false, |
---|
| 2396 | valPercent, |
---|
| 2397 | _set = {}, |
---|
| 2398 | lastValPercent, |
---|
| 2399 | value, |
---|
| 2400 | valueMin, |
---|
| 2401 | valueMax; |
---|
| 2402 | |
---|
| 2403 | if ( this.options.values && this.options.values.length ) { |
---|
| 2404 | this.handles.each(function( i, j ) { |
---|
| 2405 | valPercent = ( self.values(i) - self._valueMin() ) / ( self._valueMax() - self._valueMin() ) * 100; |
---|
| 2406 | _set[ self.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%"; |
---|
| 2407 | $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate ); |
---|
| 2408 | if ( self.options.range === true ) { |
---|
| 2409 | if ( self.orientation === "horizontal" ) { |
---|
| 2410 | if ( i === 0 ) { |
---|
| 2411 | self.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate ); |
---|
| 2412 | } |
---|
| 2413 | if ( i === 1 ) { |
---|
| 2414 | self.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } ); |
---|
| 2415 | } |
---|
| 2416 | } else { |
---|
| 2417 | if ( i === 0 ) { |
---|
| 2418 | self.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate ); |
---|
| 2419 | } |
---|
| 2420 | if ( i === 1 ) { |
---|
| 2421 | self.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } ); |
---|
| 2422 | } |
---|
| 2423 | } |
---|
| 2424 | } |
---|
| 2425 | lastValPercent = valPercent; |
---|
| 2426 | }); |
---|
| 2427 | } else { |
---|
| 2428 | value = this.value(); |
---|
| 2429 | valueMin = this._valueMin(); |
---|
| 2430 | valueMax = this._valueMax(); |
---|
| 2431 | valPercent = ( valueMax !== valueMin ) ? |
---|
| 2432 | ( value - valueMin ) / ( valueMax - valueMin ) * 100 : |
---|
| 2433 | 0; |
---|
| 2434 | _set[ self.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%"; |
---|
| 2435 | this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate ); |
---|
| 2436 | |
---|
| 2437 | if ( oRange === "min" && this.orientation === "horizontal" ) { |
---|
| 2438 | this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate ); |
---|
| 2439 | } |
---|
| 2440 | if ( oRange === "max" && this.orientation === "horizontal" ) { |
---|
| 2441 | this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } ); |
---|
| 2442 | } |
---|
| 2443 | if ( oRange === "min" && this.orientation === "vertical" ) { |
---|
| 2444 | this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate ); |
---|
| 2445 | } |
---|
| 2446 | if ( oRange === "max" && this.orientation === "vertical" ) { |
---|
| 2447 | this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } ); |
---|
| 2448 | } |
---|
| 2449 | } |
---|
| 2450 | } |
---|
| 2451 | |
---|
| 2452 | }); |
---|
| 2453 | |
---|
| 2454 | $.extend( $.ui.slider, { |
---|
| 2455 | version: "1.8.5" |
---|
| 2456 | }); |
---|
| 2457 | |
---|
| 2458 | }(jQuery)); |
---|