pageflow 17.0.1 → 17.0.2

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