resources/lib/jquery.ui/jquery.ui.slider.js

   1 /*!
   2  * jQuery UI Slider 1.9.2
   3  * http://jqueryui.com
   4  *
   5  * Copyright 2012 jQuery Foundation and other contributors
   6  * Released under the MIT license.
   7  * http://jquery.org/license
   8  *
   9  * http://api.jqueryui.com/slider/
  10  *
  11  * Depends:
  12  *      jquery.ui.core.js
  13  *      jquery.ui.mouse.js
  14  *      jquery.ui.widget.js
  15  */
  16 (function( $, undefined ) {
  17
  18 // number of pages in a slider
  19 // (how many times can you page up/down to go through the whole range)
  20 var numPages = 5;
  21
  22 $.widget( "ui.slider", $.ui.mouse, {
  23         version: "1.9.2",
  24         widgetEventPrefix: "slide",
  25
  26         options: {
  27                 animate: false,
  28                 distance: 0,
  29                 max: 100,
  30                 min: 0,
  31                 orientation: "horizontal",
  32                 range: false,
  33                 step: 1,
  34                 value: 0,
  35                 values: null
  36         },
  37
  38         _create: function() {
  39                 var i, handleCount,
  40                         o = this.options,
  41                         existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
  42                         handle = "<a class='ui-slider-handle ui-state-default ui-corner-all' href='#'></a>",
  43                         handles = [];
  44
  45                 this._keySliding = false;
  46                 this._mouseSliding = false;
  47                 this._animateOff = true;
  48                 this._handleIndex = null;
  49                 this._detectOrientation();
  50                 this._mouseInit();
  51
  52                 this.element
  53                         .addClass( "ui-slider" +
  54                                 " ui-slider-" + this.orientation +
  55                                 " ui-widget" +
  56                                 " ui-widget-content" +
  57                                 " ui-corner-all" +
  58                                 ( o.disabled ? " ui-slider-disabled ui-disabled" : "" ) );
  59
  60                 this.range = $([]);
  61
  62                 if ( o.range ) {
  63                         if ( o.range === true ) {
  64                                 if ( !o.values ) {
  65                                         o.values = [ this._valueMin(), this._valueMin() ];
  66                                 }
  67                                 if ( o.values.length && o.values.length !== 2 ) {
  68                                         o.values = [ o.values[0], o.values[0] ];
  69                                 }
  70                         }
  71
  72                         this.range = $( "<div></div>" )
  73                                 .appendTo( this.element )
  74                                 .addClass( "ui-slider-range" +
  75                                 // note: this isn't the most fittingly semantic framework class for this element,
  76                                 // but worked best visually with a variety of themes
  77                                 " ui-widget-header" +
  78                                 ( ( o.range === "min" || o.range === "max" ) ? " ui-slider-range-" + o.range : "" ) );
  79                 }
  80
  81                 handleCount = ( o.values && o.values.length ) || 1;
  82
  83                 for ( i = existingHandles.length; i < handleCount; i++ ) {
  84                         handles.push( handle );
  85                 }
  86
  87                 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
  88
  89                 this.handle = this.handles.eq( 0 );
  90
  91                 this.handles.add( this.range ).filter( "a" )
  92                         .click(function( event ) {
  93                                 event.preventDefault();
  94                         })
  95                         .mouseenter(function() {
  96                                 if ( !o.disabled ) {
  97                                         $( this ).addClass( "ui-state-hover" );
  98                                 }
  99                         })
 100                         .mouseleave(function() {
 101                                 $( this ).removeClass( "ui-state-hover" );
 102                         })
 103                         .focus(function() {
 104                                 if ( !o.disabled ) {
 105                                         $( ".ui-slider .ui-state-focus" ).removeClass( "ui-state-focus" );
 106                                         $( this ).addClass( "ui-state-focus" );
 107                                 } else {
 108                                         $( this ).blur();
 109                                 }
 110                         })
 111                         .blur(function() {
 112                                 $( this ).removeClass( "ui-state-focus" );
 113                         });
 114
 115                 this.handles.each(function( i ) {
 116                         $( this ).data( "ui-slider-handle-index", i );
 117                 });
 118
 119                 this._on( this.handles, {
 120                         keydown: function( event ) {
 121                                 var allowed, curVal, newVal, step,
 122                                         index = $( event.target ).data( "ui-slider-handle-index" );
 123
 124                                 switch ( event.keyCode ) {
 125                                         case $.ui.keyCode.HOME:
 126                                         case $.ui.keyCode.END:
 127                                         case $.ui.keyCode.PAGE_UP:
 128                                         case $.ui.keyCode.PAGE_DOWN:
 129                                         case $.ui.keyCode.UP:
 130                                         case $.ui.keyCode.RIGHT:
 131                                         case $.ui.keyCode.DOWN:
 132                                         case $.ui.keyCode.LEFT:
 133                                                 event.preventDefault();
 134                                                 if ( !this._keySliding ) {
 135                                                         this._keySliding = true;
 136                                                         $( event.target ).addClass( "ui-state-active" );
 137                                                         allowed = this._start( event, index );
 138                                                         if ( allowed === false ) {
 139                                                                 return;
 140                                                         }
 141                                                 }
 142                                                 break;
 143                                 }
 144
 145                                 step = this.options.step;
 146                                 if ( this.options.values && this.options.values.length ) {
 147                                         curVal = newVal = this.values( index );
 148                                 } else {
 149                                         curVal = newVal = this.value();
 150                                 }
 151
 152                                 switch ( event.keyCode ) {
 153                                         case $.ui.keyCode.HOME:
 154                                                 newVal = this._valueMin();
 155                                                 break;
 156                                         case $.ui.keyCode.END:
 157                                                 newVal = this._valueMax();
 158                                                 break;
 159                                         case $.ui.keyCode.PAGE_UP:
 160                                                 newVal = this._trimAlignValue( curVal + ( (this._valueMax() - this._valueMin()) / numPages ) );
 161                                                 break;
 162                                         case $.ui.keyCode.PAGE_DOWN:
 163                                                 newVal = this._trimAlignValue( curVal - ( (this._valueMax() - this._valueMin()) / numPages ) );
 164                                                 break;
 165                                         case $.ui.keyCode.UP:
 166                                         case $.ui.keyCode.RIGHT:
 167                                                 if ( curVal === this._valueMax() ) {
 168                                                         return;
 169                                                 }
 170                                                 newVal = this._trimAlignValue( curVal + step );
 171                                                 break;
 172                                         case $.ui.keyCode.DOWN:
 173                                         case $.ui.keyCode.LEFT:
 174                                                 if ( curVal === this._valueMin() ) {
 175                                                         return;
 176                                                 }
 177                                                 newVal = this._trimAlignValue( curVal - step );
 178                                                 break;
 179                                 }
 180
 181                                 this._slide( event, index, newVal );
 182                         },
 183                         keyup: function( event ) {
 184                                 var index = $( event.target ).data( "ui-slider-handle-index" );
 185
 186                                 if ( this._keySliding ) {
 187                                         this._keySliding = false;
 188                                         this._stop( event, index );
 189                                         this._change( event, index );
 190                                         $( event.target ).removeClass( "ui-state-active" );
 191                                 }
 192                         }
 193                 });
 194
 195                 this._refreshValue();
 196
 197                 this._animateOff = false;
 198         },
 199
 200         _destroy: function() {
 201                 this.handles.remove();
 202                 this.range.remove();
 203
 204                 this.element
 205                         .removeClass( "ui-slider" +
 206                                 " ui-slider-horizontal" +
 207                                 " ui-slider-vertical" +
 208                                 " ui-slider-disabled" +
 209                                 " ui-widget" +
 210                                 " ui-widget-content" +
 211                                 " ui-corner-all" );
 212
 213                 this._mouseDestroy();
 214         },
 215
 216         _mouseCapture: function( event ) {
 217                 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
 218                         that = this,
 219                         o = this.options;
 220
 221                 if ( o.disabled ) {
 222                         return false;
 223                 }
 224
 225                 this.elementSize = {
 226                         width: this.element.outerWidth(),
 227                         height: this.element.outerHeight()
 228                 };
 229                 this.elementOffset = this.element.offset();
 230
 231                 position = { x: event.pageX, y: event.pageY };
 232                 normValue = this._normValueFromMouse( position );
 233                 distance = this._valueMax() - this._valueMin() + 1;
 234                 this.handles.each(function( i ) {
 235                         var thisDistance = Math.abs( normValue - that.values(i) );
 236                         if ( distance > thisDistance ) {
 237                                 distance = thisDistance;
 238                                 closestHandle = $( this );
 239                                 index = i;
 240                         }
 241                 });
 242
 243                 // workaround for bug #3736 (if both handles of a range are at 0,
 244                 // the first is always used as the one with least distance,
 245                 // and moving it is obviously prevented by preventing negative ranges)
 246                 if( o.range === true && this.values(1) === o.min ) {
 247                         index += 1;
 248                         closestHandle = $( this.handles[index] );
 249                 }
 250
 251                 allowed = this._start( event, index );
 252                 if ( allowed === false ) {
 253                         return false;
 254                 }
 255                 this._mouseSliding = true;
 256
 257                 this._handleIndex = index;
 258
 259                 closestHandle
 260                         .addClass( "ui-state-active" )
 261                         .focus();
 262
 263                 offset = closestHandle.offset();
 264                 mouseOverHandle = !$( event.target ).parents().andSelf().is( ".ui-slider-handle" );
 265                 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
 266                         left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
 267                         top: event.pageY - offset.top -
 268                                 ( closestHandle.height() / 2 ) -
 269                                 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
 270                                 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
 271                                 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
 272                 };
 273
 274                 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
 275                         this._slide( event, index, normValue );
 276                 }
 277                 this._animateOff = true;
 278                 return true;
 279         },
 280
 281         _mouseStart: function() {
 282                 return true;
 283         },
 284
 285         _mouseDrag: function( event ) {
 286                 var position = { x: event.pageX, y: event.pageY },
 287                         normValue = this._normValueFromMouse( position );
 288
 289                 this._slide( event, this._handleIndex, normValue );
 290
 291                 return false;
 292         },
 293
 294         _mouseStop: function( event ) {
 295                 this.handles.removeClass( "ui-state-active" );
 296                 this._mouseSliding = false;
 297
 298                 this._stop( event, this._handleIndex );
 299                 this._change( event, this._handleIndex );
 300
 301                 this._handleIndex = null;
 302                 this._clickOffset = null;
 303                 this._animateOff = false;
 304
 305                 return false;
 306         },
 307
 308         _detectOrientation: function() {
 309                 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
 310         },
 311
 312         _normValueFromMouse: function( position ) {
 313                 var pixelTotal,
 314                         pixelMouse,
 315                         percentMouse,
 316                         valueTotal,
 317                         valueMouse;
 318
 319                 if ( this.orientation === "horizontal" ) {
 320                         pixelTotal = this.elementSize.width;
 321                         pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
 322                 } else {
 323                         pixelTotal = this.elementSize.height;
 324                         pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
 325                 }
 326
 327                 percentMouse = ( pixelMouse / pixelTotal );
 328                 if ( percentMouse > 1 ) {
 329                         percentMouse = 1;
 330                 }
 331                 if ( percentMouse < 0 ) {
 332                         percentMouse = 0;
 333                 }
 334                 if ( this.orientation === "vertical" ) {
 335                         percentMouse = 1 - percentMouse;
 336                 }
 337
 338                 valueTotal = this._valueMax() - this._valueMin();
 339                 valueMouse = this._valueMin() + percentMouse * valueTotal;
 340
 341                 return this._trimAlignValue( valueMouse );
 342         },
 343
 344         _start: function( event, index ) {
 345                 var uiHash = {
 346                         handle: this.handles[ index ],
 347                         value: this.value()
 348                 };
 349                 if ( this.options.values && this.options.values.length ) {
 350                         uiHash.value = this.values( index );
 351                         uiHash.values = this.values();
 352                 }
 353                 return this._trigger( "start", event, uiHash );
 354         },
 355
 356         _slide: function( event, index, newVal ) {
 357                 var otherVal,
 358                         newValues,
 359                         allowed;
 360
 361                 if ( this.options.values && this.options.values.length ) {
 362                         otherVal = this.values( index ? 0 : 1 );
 363
 364                         if ( ( this.options.values.length === 2 && this.options.range === true ) &&
 365                                         ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
 366                                 ) {
 367                                 newVal = otherVal;
 368                         }
 369
 370                         if ( newVal !== this.values( index ) ) {
 371                                 newValues = this.values();
 372                                 newValues[ index ] = newVal;
 373                                 // A slide can be canceled by returning false from the slide callback
 374                                 allowed = this._trigger( "slide", event, {
 375                                         handle: this.handles[ index ],
 376                                         value: newVal,
 377                                         values: newValues
 378                                 } );
 379                                 otherVal = this.values( index ? 0 : 1 );
 380                                 if ( allowed !== false ) {
 381                                         this.values( index, newVal, true );
 382                                 }
 383                         }
 384                 } else {
 385                         if ( newVal !== this.value() ) {
 386                                 // A slide can be canceled by returning false from the slide callback
 387                                 allowed = this._trigger( "slide", event, {
 388                                         handle: this.handles[ index ],
 389                                         value: newVal
 390                                 } );
 391                                 if ( allowed !== false ) {
 392                                         this.value( newVal );
 393                                 }
 394                         }
 395                 }
 396         },
 397
 398         _stop: function( event, index ) {
 399                 var uiHash = {
 400                         handle: this.handles[ index ],
 401                         value: this.value()
 402                 };
 403                 if ( this.options.values && this.options.values.length ) {
 404                         uiHash.value = this.values( index );
 405                         uiHash.values = this.values();
 406                 }
 407
 408                 this._trigger( "stop", event, uiHash );
 409         },
 410
 411         _change: function( event, index ) {
 412                 if ( !this._keySliding && !this._mouseSliding ) {
 413                         var uiHash = {
 414                                 handle: this.handles[ index ],
 415                                 value: this.value()
 416                         };
 417                         if ( this.options.values && this.options.values.length ) {
 418                                 uiHash.value = this.values( index );
 419                                 uiHash.values = this.values();
 420                         }
 421
 422                         this._trigger( "change", event, uiHash );
 423                 }
 424         },
 425
 426         value: function( newValue ) {
 427                 if ( arguments.length ) {
 428                         this.options.value = this._trimAlignValue( newValue );
 429                         this._refreshValue();
 430                         this._change( null, 0 );
 431                         return;
 432                 }
 433
 434                 return this._value();
 435         },
 436
 437         values: function( index, newValue ) {
 438                 var vals,
 439                         newValues,
 440                         i;
 441
 442                 if ( arguments.length > 1 ) {
 443                         this.options.values[ index ] = this._trimAlignValue( newValue );
 444                         this._refreshValue();
 445                         this._change( null, index );
 446                         return;
 447                 }
 448
 449                 if ( arguments.length ) {
 450                         if ( $.isArray( arguments[ 0 ] ) ) {
 451                                 vals = this.options.values;
 452                                 newValues = arguments[ 0 ];
 453                                 for ( i = 0; i < vals.length; i += 1 ) {
 454                                         vals[ i ] = this._trimAlignValue( newValues[ i ] );
 455                                         this._change( null, i );
 456                                 }
 457                                 this._refreshValue();
 458                         } else {
 459                                 if ( this.options.values && this.options.values.length ) {
 460                                         return this._values( index );
 461                                 } else {
 462                                         return this.value();
 463                                 }
 464                         }
 465                 } else {
 466                         return this._values();
 467                 }
 468         },
 469
 470         _setOption: function( key, value ) {
 471                 var i,
 472                         valsLength = 0;
 473
 474                 if ( $.isArray( this.options.values ) ) {
 475                         valsLength = this.options.values.length;
 476                 }
 477
 478                 $.Widget.prototype._setOption.apply( this, arguments );
 479
 480                 switch ( key ) {
 481                         case "disabled":
 482                                 if ( value ) {
 483                                         this.handles.filter( ".ui-state-focus" ).blur();
 484                                         this.handles.removeClass( "ui-state-hover" );
 485                                         this.handles.prop( "disabled", true );
 486                                         this.element.addClass( "ui-disabled" );
 487                                 } else {
 488                                         this.handles.prop( "disabled", false );
 489                                         this.element.removeClass( "ui-disabled" );
 490                                 }
 491                                 break;
 492                         case "orientation":
 493                                 this._detectOrientation();
 494                                 this.element
 495                                         .removeClass( "ui-slider-horizontal ui-slider-vertical" )
 496                                         .addClass( "ui-slider-" + this.orientation );
 497                                 this._refreshValue();
 498                                 break;
 499                         case "value":
 500                                 this._animateOff = true;
 501                                 this._refreshValue();
 502                                 this._change( null, 0 );
 503                                 this._animateOff = false;
 504                                 break;
 505                         case "values":
 506                                 this._animateOff = true;
 507                                 this._refreshValue();
 508                                 for ( i = 0; i < valsLength; i += 1 ) {
 509                                         this._change( null, i );
 510                                 }
 511                                 this._animateOff = false;
 512                                 break;
 513                         case "min":
 514                         case "max":
 515                                 this._animateOff = true;
 516                                 this._refreshValue();
 517                                 this._animateOff = false;
 518                                 break;
 519                 }
 520         },
 521
 522         //internal value getter
 523         // _value() returns value trimmed by min and max, aligned by step
 524         _value: function() {
 525                 var val = this.options.value;
 526                 val = this._trimAlignValue( val );
 527
 528                 return val;
 529         },
 530
 531         //internal values getter
 532         // _values() returns array of values trimmed by min and max, aligned by step
 533         // _values( index ) returns single value trimmed by min and max, aligned by step
 534         _values: function( index ) {
 535                 var val,
 536                         vals,
 537                         i;
 538
 539                 if ( arguments.length ) {
 540                         val = this.options.values[ index ];
 541                         val = this._trimAlignValue( val );
 542
 543                         return val;
 544                 } else {
 545                         // .slice() creates a copy of the array
 546                         // this copy gets trimmed by min and max and then returned
 547                         vals = this.options.values.slice();
 548                         for ( i = 0; i < vals.length; i+= 1) {
 549                                 vals[ i ] = this._trimAlignValue( vals[ i ] );
 550                         }
 551
 552                         return vals;
 553                 }
 554         },
 555
 556         // returns the step-aligned value that val is closest to, between (inclusive) min and max
 557         _trimAlignValue: function( val ) {
 558                 if ( val <= this._valueMin() ) {
 559                         return this._valueMin();
 560                 }
 561                 if ( val >= this._valueMax() ) {
 562                         return this._valueMax();
 563                 }
 564                 var step = ( this.options.step > 0 ) ? this.options.step : 1,
 565                         valModStep = (val - this._valueMin()) % step,
 566                         alignValue = val - valModStep;
 567
 568                 if ( Math.abs(valModStep) * 2 >= step ) {
 569                         alignValue += ( valModStep > 0 ) ? step : ( -step );
 570                 }
 571
 572                 // Since JavaScript has problems with large floats, round
 573                 // the final value to 5 digits after the decimal point (see #4124)
 574                 return parseFloat( alignValue.toFixed(5) );
 575         },
 576
 577         _valueMin: function() {
 578                 return this.options.min;
 579         },
 580
 581         _valueMax: function() {
 582                 return this.options.max;
 583         },
 584
 585         _refreshValue: function() {
 586                 var lastValPercent, valPercent, value, valueMin, valueMax,
 587                         oRange = this.options.range,
 588                         o = this.options,
 589                         that = this,
 590                         animate = ( !this._animateOff ) ? o.animate : false,
 591                         _set = {};
 592
 593                 if ( this.options.values && this.options.values.length ) {
 594                         this.handles.each(function( i ) {
 595                                 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
 596                                 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
 597                                 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
 598                                 if ( that.options.range === true ) {
 599                                         if ( that.orientation === "horizontal" ) {
 600                                                 if ( i === 0 ) {
 601                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
 602                                                 }
 603                                                 if ( i === 1 ) {
 604                                                         that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
 605                                                 }
 606                                         } else {
 607                                                 if ( i === 0 ) {
 608                                                         that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
 609                                                 }
 610                                                 if ( i === 1 ) {
 611                                                         that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
 612                                                 }
 613                                         }
 614                                 }
 615                                 lastValPercent = valPercent;
 616                         });
 617                 } else {
 618                         value = this.value();
 619                         valueMin = this._valueMin();
 620                         valueMax = this._valueMax();
 621                         valPercent = ( valueMax !== valueMin ) ?
 622                                         ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
 623                                         0;
 624                         _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
 625                         this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
 626
 627                         if ( oRange === "min" && this.orientation === "horizontal" ) {
 628                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
 629                         }
 630                         if ( oRange === "max" && this.orientation === "horizontal" ) {
 631                                 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
 632                         }
 633                         if ( oRange === "min" && this.orientation === "vertical" ) {
 634                                 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
 635                         }
 636                         if ( oRange === "max" && this.orientation === "vertical" ) {
 637                                 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
 638                         }
 639                 }
 640         }
 641
 642 });
 643
 644 }(jQuery));