mirror of
https://github.com/jquery/jquery-ui.git
synced 2024-11-21 11:04:24 +00:00
1008 lines
23 KiB
JavaScript
1008 lines
23 KiB
JavaScript
/*!
|
|
* jQuery UI Draggable @VERSION
|
|
* http://jqueryui.com
|
|
*
|
|
* Copyright 2012 jQuery Foundation and other contributors
|
|
* Dual licensed under the MIT or GPL Version 2 licenses.
|
|
* http://jquery.org/license
|
|
*
|
|
* http://docs.jquery.com/UI/Draggable
|
|
*
|
|
* Depends:
|
|
* jquery.ui.core.js
|
|
* jquery.ui.interaction.js
|
|
* jquery.ui.widget.js
|
|
*/
|
|
(function( $, undefined ) {
|
|
|
|
// create a shallow copy of an object
|
|
function copy( obj ) {
|
|
var prop,
|
|
ret = {};
|
|
for ( prop in obj ) {
|
|
ret[ prop ] = obj[ prop ];
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
$.widget( "ui.draggable", $.ui.interaction, {
|
|
version: "@VERSION",
|
|
widgetEventPrefix: "drag",
|
|
|
|
options: {
|
|
appendTo: null,
|
|
exclude: "input,textarea,button,select,option",
|
|
handle: null,
|
|
helper: false
|
|
},
|
|
|
|
// dragEl: element being dragged (original or helper)
|
|
// position: final CSS position of dragEl
|
|
// offset: offset of dragEl
|
|
// originalPosition: CSS position before drag start
|
|
// originalOffset: offset before drag start
|
|
// originalPointer: pageX/Y at drag start (offset of pointer)
|
|
// startPosition: CSS position at drag start (after beforeStart)
|
|
// startOffset: offset at drag start (after beforeStart)
|
|
// tempPosition: overridable CSS position of dragEl
|
|
// overflowOffset: offset of scroll parent
|
|
// overflow: object containing width and height keys of scroll parent
|
|
// domPosition: object containing original parent and index when using
|
|
// appendTo option without a helper
|
|
|
|
_create: function() {
|
|
this._super();
|
|
|
|
this.scrollSensitivity = 20;
|
|
this.scrollSpeed = 5;
|
|
|
|
// Static position elements can't be moved with top/left
|
|
if ( this.element.css( "position" ) === "static" ) {
|
|
this.element.css( "position", "relative" );
|
|
}
|
|
|
|
this.element.addClass( "ui-draggable" );
|
|
},
|
|
|
|
/** interaction interface **/
|
|
|
|
_isValidTarget: function( element ) {
|
|
var handle = this.options.handle ? element.is( this.options.handle ) : true,
|
|
exclude = this.options.exclude ? element.is( this.options.exclude ) : false;
|
|
|
|
return ( handle && !exclude );
|
|
},
|
|
|
|
_start: function( event, pointerPosition ) {
|
|
var offset, startCssLeft, startCssTop, startPosition, startOffset;
|
|
|
|
// The actual dragging element, should always be a jQuery object
|
|
this.dragEl = ( this.options.helper === true || typeof this.options.helper === 'function' ) ?
|
|
this._createHelper( pointerPosition ) :
|
|
this.element;
|
|
|
|
// _createHelper() ensures that helpers are in the correct position
|
|
// in the DOM, but we need to handle appendTo when there is no helper
|
|
if ( this.options.appendTo && this.dragEl === this.element ) {
|
|
this.domPosition = {
|
|
parent: this.element.parent(),
|
|
index: this.element.index()
|
|
};
|
|
offset = this.dragEl.offset();
|
|
this.dragEl
|
|
.appendTo( this._appendToEl() )
|
|
.offset( offset );
|
|
}
|
|
|
|
this.cssPosition = this.dragEl.css( "position" );
|
|
this.scrollParent = this.element.scrollParent();
|
|
|
|
// Cache starting positions
|
|
this.originalPosition = this.startPosition = this._getPosition();
|
|
this.originalOffset = this.startOffset = this.dragEl.offset();
|
|
this.originalPointer = pointerPosition;
|
|
|
|
// Cache current position and offset
|
|
this.position = copy( this.startPosition );
|
|
this.offset = copy( this.startOffset );
|
|
|
|
// Cache the offset of scrollParent, if required for _handleScrolling
|
|
if ( this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML" ) {
|
|
this.overflowOffset = this.scrollParent.offset();
|
|
}
|
|
|
|
this.overflow = {
|
|
height: this.scrollParent[0] === this.document[0] ?
|
|
this.window.height() : this.scrollParent.height(),
|
|
width: this.scrollParent[0] === this.document[0] ?
|
|
this.window.width() : this.scrollParent.width()
|
|
};
|
|
|
|
this._preparePosition( pointerPosition );
|
|
|
|
// If user cancels beforeStart, don't allow dragging
|
|
if ( this._trigger( "beforeStart", event,
|
|
this._originalHash( pointerPosition ) ) === false ) {
|
|
|
|
// domPosition needs to be undone even if beforeStart is stopped
|
|
// Otherwise this.dragEl will remain in the element appendTo is set to
|
|
this._resetDomPosition();
|
|
return false;
|
|
|
|
}
|
|
|
|
// Save off the usual properties locally, so they can be reverted from start
|
|
startCssLeft = this.dragEl.css("left");
|
|
startCssTop = this.dragEl.css("top");
|
|
startPosition = copy( this._getPosition() );
|
|
startOffset = copy( this.offset );
|
|
|
|
this._setCss();
|
|
this.startPosition = this._getPosition();
|
|
this.startOffset = this.dragEl.offset();
|
|
|
|
// If user cancels on start, don't allow dragging
|
|
if ( this._trigger( "start", event,
|
|
this._fullHash( pointerPosition ) ) === false ) {
|
|
// domPosition needs to be undone even if start is stopped
|
|
// Otherwise this.dragEl will remain in the element appendTo is set to
|
|
|
|
this.startPosition = startPosition;
|
|
this.startOffset = startOffset;
|
|
this.dragEl.css({
|
|
left: startCssLeft,
|
|
top: startCssTop
|
|
});
|
|
|
|
this._resetDomPosition();
|
|
return false;
|
|
}
|
|
this._blockFrames();
|
|
},
|
|
|
|
_resetDomPosition: function() {
|
|
|
|
// Nothing to do in this case
|
|
if ( !this.domPosition ) {
|
|
return;
|
|
}
|
|
|
|
var parent = this.domPosition.parent,
|
|
next = parent.children().eq( this.domPosition.index );
|
|
if ( next.length ) {
|
|
next.before( this.element );
|
|
} else {
|
|
parent.append( this.element );
|
|
}
|
|
this.element.offset( this.offset );
|
|
this.domPosition = null;
|
|
|
|
},
|
|
|
|
_move: function( event, pointerPosition ) {
|
|
this._preparePosition( pointerPosition );
|
|
|
|
// If user cancels drag, don't move the element
|
|
if ( this._trigger( "drag", event, this._fullHash( pointerPosition ) ) === false ) {
|
|
return false;
|
|
}
|
|
|
|
this._setCss();
|
|
|
|
// Scroll the scrollParent, if needed
|
|
this._handleScrolling( pointerPosition );
|
|
},
|
|
|
|
_stop: function( event, pointerPosition ) {
|
|
this._preparePosition( pointerPosition );
|
|
|
|
// If user cancels stop, leave helper there
|
|
if ( this._trigger( "stop", event, this._fullHash( pointerPosition ) ) !== false ) {
|
|
if ( this.options.helper ) {
|
|
delete this.element.data( 'draggable' ).helper;
|
|
this.dragEl.remove();
|
|
}
|
|
this._resetDomPosition();
|
|
}
|
|
|
|
this._unblockFrames();
|
|
},
|
|
|
|
/** internal **/
|
|
|
|
_createHelper: function( pointerPosition ) {
|
|
var helper,
|
|
offset = this.element.offset(),
|
|
xPos = (pointerPosition.x - offset.left) / this.element.outerWidth(),
|
|
yPos = (pointerPosition.y - offset.top) / this.element.outerHeight();
|
|
|
|
// clone
|
|
if ( this.options.helper === true ) {
|
|
helper = this.element.clone()
|
|
.removeAttr( "id" )
|
|
.find( "[id]" )
|
|
.removeAttr( "id" )
|
|
.end();
|
|
} else {
|
|
// TODO: figure out the signature for this; see #4957
|
|
helper = $( this.options.helper() );
|
|
}
|
|
|
|
// Ensure the helper is in the DOM; obey the appendTo option if it exists
|
|
if ( this.options.appendTo || !helper.closest( "body" ).length ) {
|
|
helper.appendTo( this._appendToEl() || this.document[0].body );
|
|
}
|
|
|
|
this.element.data( 'draggable' ).helper = helper;
|
|
|
|
return helper
|
|
// Helper must be absolute to function properly
|
|
.css( "position", "absolute" )
|
|
.offset({
|
|
left: pointerPosition.x - helper.outerWidth() * xPos,
|
|
top: pointerPosition.y - helper.outerHeight() * yPos
|
|
});
|
|
},
|
|
|
|
// TODO: Remove after 2.0, only used for backCompat
|
|
_appendToEl: function() {
|
|
return this.options.appendTo;
|
|
},
|
|
|
|
_getPosition: function() {
|
|
var left, top, position,
|
|
scrollTop = this.scrollParent.scrollTop(),
|
|
scrollLeft = this.scrollParent.scrollLeft();
|
|
|
|
// If fixed or absolute
|
|
if ( this.cssPosition !== "relative" ) {
|
|
position = this.dragEl.position();
|
|
|
|
// Take into account scrollbar
|
|
position.top -= scrollTop;
|
|
position.left -= scrollLeft;
|
|
|
|
return position;
|
|
}
|
|
|
|
// When using relative, css values are checked
|
|
// Otherwise the position wouldn't account for padding on ancestors
|
|
left = this.dragEl.css( "left" );
|
|
top = this.dragEl.css( "top" );
|
|
|
|
// Webkit will give back auto if there is no explicit value
|
|
left = ( left === "auto" ) ? 0: parseInt( left, 10 );
|
|
top = ( top === "auto" ) ? 0: parseInt( top, 10 );
|
|
|
|
return {
|
|
left: left - scrollLeft,
|
|
top: top - scrollTop
|
|
};
|
|
},
|
|
|
|
_handleScrolling: function( pointerPosition ) {
|
|
var scrollTop = this.scrollParent.scrollTop(),
|
|
scrollLeft = this.scrollParent.scrollLeft(),
|
|
scrollSensitivity = this.scrollSensitivity,
|
|
// overflowOffset is only set when scrollParent is not doc/html
|
|
overflowLeft = this.overflowOffset ?
|
|
this.overflowOffset.left :
|
|
scrollLeft,
|
|
overflowTop = this.overflowOffset ?
|
|
this.overflowOffset.top :
|
|
scrollTop,
|
|
xRight = this.overflow.width + overflowLeft - pointerPosition.x,
|
|
xLeft = pointerPosition.x- overflowLeft,
|
|
yBottom = this.overflow.height + overflowTop - pointerPosition.y,
|
|
yTop = pointerPosition.y - overflowTop;
|
|
|
|
// Handle vertical scrolling
|
|
if ( yBottom < scrollSensitivity ) {
|
|
this.scrollParent.scrollTop( scrollTop +
|
|
this._speed( scrollSensitivity - yBottom ) );
|
|
} else if ( yTop < scrollSensitivity ) {
|
|
this.scrollParent.scrollTop( scrollTop -
|
|
this._speed( scrollSensitivity - yTop ) );
|
|
}
|
|
|
|
// Handle horizontal scrolling
|
|
if ( xRight < scrollSensitivity ) {
|
|
this.scrollParent.scrollLeft( scrollLeft +
|
|
this._speed( scrollSensitivity - xRight ) );
|
|
} else if ( xLeft < scrollSensitivity ) {
|
|
this.scrollParent.scrollLeft( scrollLeft -
|
|
this._speed( scrollSensitivity - xLeft ) );
|
|
}
|
|
},
|
|
|
|
_speed: function( distance ) {
|
|
return this.scrollSpeed + Math.round( distance / 2 );
|
|
},
|
|
|
|
// Uses event to determine new position of draggable, before any override from callbacks
|
|
// TODO: handle absolute element inside relative parent like a relative element
|
|
_preparePosition: function( pointerPosition ) {
|
|
var leftDiff = pointerPosition.x - this.originalPointer.x,
|
|
topDiff = pointerPosition.y - this.originalPointer.y,
|
|
newLeft = leftDiff + this.startPosition.left,
|
|
newTop = topDiff + this.startPosition.top;
|
|
|
|
// Save off new values for .css() in various callbacks using this function
|
|
this.position = {
|
|
left: newLeft,
|
|
top: newTop
|
|
};
|
|
|
|
// Save off values to compare user override against automatic coordinates
|
|
this.tempPosition = {
|
|
left: newLeft,
|
|
top: newTop
|
|
};
|
|
|
|
// Refresh offset cache with new positions
|
|
this.offset.left = this.startOffset.left + leftDiff;
|
|
this.offset.top = this.startOffset.top + topDiff;
|
|
},
|
|
|
|
// Places draggable where event, or user via event/callback, indicates
|
|
_setCss: function() {
|
|
var newLeft = this.position.left,
|
|
newTop = this.position.top;
|
|
|
|
// User overriding left/top so shortcut math is no longer valid
|
|
if ( this.tempPosition.left !== this.position.left ||
|
|
this.tempPosition.top !== this.position.top ) {
|
|
// Reset offset based on difference of expected and overridden values
|
|
this.offset.left += newLeft - this.tempPosition.left;
|
|
this.offset.top += newTop - this.tempPosition.top;
|
|
}
|
|
|
|
// TODO: does this work with nested scrollable parents?
|
|
if ( this.cssPosition !== "fixed" ) {
|
|
newLeft += this.scrollParent.scrollLeft();
|
|
newTop += this.scrollParent.scrollTop();
|
|
}
|
|
|
|
this.dragEl.css({
|
|
left: newLeft,
|
|
top: newTop
|
|
});
|
|
},
|
|
|
|
_originalHash: function( pointerPosition ) {
|
|
var ret = {
|
|
position: this.position,
|
|
offset: copy( this.offset ),
|
|
pointer: copy( pointerPosition )
|
|
};
|
|
|
|
if ( this.options.helper ) {
|
|
ret.helper = this.dragEl;
|
|
}
|
|
|
|
return ret;
|
|
},
|
|
|
|
_fullHash: function( pointerPosition ) {
|
|
return $.extend( this._originalHash( pointerPosition ), {
|
|
originalPosition: copy( this.originalPosition ),
|
|
originalOffset: copy( this.originalOffset ),
|
|
originalPointer: copy( this.originalPointer )
|
|
});
|
|
},
|
|
|
|
_blockFrames: function() {
|
|
|
|
this.iframeBlocks = this.document.find( "iframe" ).map(function() {
|
|
var iframe = $( this ),
|
|
iframeOffset = iframe.offset();
|
|
|
|
return $( "<div>" )
|
|
.css({
|
|
position: "absolute",
|
|
width: iframe.outerWidth(),
|
|
height: iframe.outerHeight(),
|
|
top: iframeOffset.top,
|
|
left: iframeOffset.left
|
|
})
|
|
.appendTo( iframe.parent() )[0];
|
|
});
|
|
},
|
|
|
|
_unblockFrames: function() {
|
|
if ( this.iframeBlocks ) {
|
|
this.iframeBlocks.remove();
|
|
delete this.iframeBlocks;
|
|
}
|
|
},
|
|
|
|
_destroy: function() {
|
|
this.element.removeClass( "ui-draggable" );
|
|
this._super();
|
|
}
|
|
});
|
|
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
// $.widget doesn't know how to handle redefinitions with a custom prefix
|
|
// custom prefixes are going away anyway, so it's not worth fixing right now
|
|
widgetEventPrefix: "drag",
|
|
|
|
options: {
|
|
containment: null
|
|
},
|
|
|
|
_create: function() {
|
|
this._super();
|
|
this._on({
|
|
dragstart: "_setContainment",
|
|
drag: "_contain"
|
|
});
|
|
},
|
|
|
|
_setContainment: function( event, ui ) {
|
|
var offset, left, top,
|
|
container = this._getContainer();
|
|
|
|
if ( !container ) {
|
|
this.containment = null;
|
|
return;
|
|
}
|
|
|
|
offset = container.offset();
|
|
left = offset.left +
|
|
(parseFloat( $.css( container[0], "borderLeftWidth", true ) ) || 0) +
|
|
(parseFloat( $.css( container[0], "paddingLeft", true ) ) || 0);
|
|
top = offset.top +
|
|
(parseFloat( $.css( container[0], "borderTopWidth", true ) ) || 0) +
|
|
(parseFloat( $.css( container[0], "paddingTop", true ) ) || 0);
|
|
|
|
this.containment = {
|
|
left: left,
|
|
top: top,
|
|
right: left + container.width(),
|
|
bottom: top + container.height(),
|
|
leftDiff: ui.originalOffset.left - ui.originalPosition.left,
|
|
topDiff: ui.originalOffset.top - ui.originalPosition.top,
|
|
width: this.dragEl.outerWidth(),
|
|
height: this.dragEl.outerHeight()
|
|
};
|
|
},
|
|
|
|
_contain: function( event, ui ) {
|
|
var containment = this.containment;
|
|
|
|
if ( !containment ) {
|
|
return;
|
|
}
|
|
|
|
ui.position.left = Math.max( ui.position.left,
|
|
containment.left - containment.leftDiff );
|
|
ui.position.left = Math.min( ui.position.left,
|
|
containment.right - containment.width - containment.leftDiff );
|
|
|
|
ui.position.top = Math.max( ui.position.top,
|
|
containment.top - containment.topDiff );
|
|
ui.position.top = Math.min( ui.position.top,
|
|
containment.bottom - containment.height - containment.topDiff );
|
|
},
|
|
|
|
_getContainer: function() {
|
|
var container,
|
|
containment = this.options.containment;
|
|
|
|
if ( !containment ) {
|
|
container = null;
|
|
} else if ( containment === "parent" ) {
|
|
container = this.element.parent();
|
|
} else {
|
|
container = $( containment );
|
|
if ( !container.length ) {
|
|
container = null;
|
|
}
|
|
}
|
|
|
|
return container;
|
|
}
|
|
});
|
|
|
|
})( jQuery );
|
|
|
|
// DEPRECATED
|
|
if ( $.uiBackCompat !== false ) {
|
|
|
|
// appendTo 'parent' value
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
|
|
_appendToEl: function() {
|
|
|
|
var el = this.options.appendTo;
|
|
|
|
if ( el === 'parent' ) {
|
|
el = this.dragEl.parent();
|
|
}
|
|
|
|
return el;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// helper 'original' or 'clone' value
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
|
|
_create: function() {
|
|
|
|
this._super();
|
|
|
|
if ( this.options.helper === 'original' ) {
|
|
this.options.helper = false;
|
|
}
|
|
|
|
if ( this.options.helper === 'clone' ) {
|
|
this.options.helper = true;
|
|
}
|
|
|
|
},
|
|
|
|
_setOption: function( key, value ) {
|
|
|
|
if ( key !== 'helper' ) {
|
|
return this._super( key, value );
|
|
}
|
|
|
|
if ( value === 'clone' ) {
|
|
value = true;
|
|
}
|
|
|
|
if ( value === 'original' ) {
|
|
value = false;
|
|
}
|
|
|
|
this._super( key, value );
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// axis option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
axis: false
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this;
|
|
|
|
this._super();
|
|
|
|
// On drag, make sure top does not change so axis is locked
|
|
this.element.on( "drag", function( event, ui ) {
|
|
|
|
if ( self.options.axis === "x" ) {
|
|
ui.position.top = ui.originalPosition.top;
|
|
}
|
|
|
|
if ( self.options.axis === "y" ) {
|
|
ui.position.left = ui.originalPosition.left;
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// cancel option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
cancel: null
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
this._super();
|
|
|
|
if ( this.options.cancel !== null ) {
|
|
this.options.exclude = this.options.cancel;
|
|
}
|
|
|
|
},
|
|
|
|
_setOption: function( key, value ) {
|
|
|
|
if ( key !== 'cancel' ) {
|
|
return this._super( key, value );
|
|
}
|
|
|
|
this._super( key, value );
|
|
this.options.exclude = this.options.cancel;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// cursor option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
cursor: "auto"
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var startCursor, self, body;
|
|
|
|
this._super();
|
|
|
|
self = this;
|
|
body = $( this.document[0].body );
|
|
|
|
// Cache original cursor to set back
|
|
this.element.on( "dragbeforestart", function() {
|
|
|
|
if ( self.options.cursor ) {
|
|
startCursor = body[0].style.cursor;
|
|
body.css( "cursor", self.options.cursor );
|
|
}
|
|
|
|
});
|
|
|
|
// Set back cursor to whatever default was
|
|
this.element.on( "dragstop", function() {
|
|
|
|
if ( self.options.cursor ) {
|
|
body.css( "cursor", startCursor );
|
|
}
|
|
|
|
});
|
|
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// cursorAt option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
cursorAt: false
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this;
|
|
|
|
this._super();
|
|
|
|
this.element.on( "dragbeforestart", function( event, ui ) {
|
|
|
|
var elem = self.dragEl,
|
|
cursorAt = self.options.cursorAt;
|
|
|
|
// No need to continue
|
|
if ( !cursorAt ) {
|
|
return;
|
|
}
|
|
|
|
if ( "top" in cursorAt ) {
|
|
ui.position.top += ui.pointer.y - ui.offset.top - cursorAt.top;
|
|
}
|
|
if ( "left" in cursorAt ) {
|
|
ui.position.left += ui.pointer.x - ui.offset.left - cursorAt.left;
|
|
}
|
|
if ( "bottom" in cursorAt ) {
|
|
ui.position.top += ui.pointer.y - ui.offset.top - elem.outerHeight() + cursorAt.bottom;
|
|
}
|
|
if ( "right" in cursorAt ) {
|
|
ui.position.left += ui.pointer.x - ui.offset.left - elem.outerWidth() + cursorAt.right;
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// grid option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
grid: false
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this,
|
|
currentX, currentY;
|
|
|
|
this._super();
|
|
|
|
this.element.on( "dragbeforestart", function( event, ui ) {
|
|
|
|
if ( !self.options.grid ) {
|
|
return;
|
|
}
|
|
|
|
// Save off the start position, which may be overwritten during drag
|
|
currentX = ui.position.left;
|
|
currentY = ui.position.top;
|
|
|
|
});
|
|
|
|
this.element.on( "drag", function( event, ui ) {
|
|
|
|
if ( !self.options.grid ) {
|
|
return;
|
|
}
|
|
|
|
// Save off the intended intervals
|
|
var x = self.options.grid[0],
|
|
y = self.options.grid[1];
|
|
|
|
// If x is actually something, check that user is at least half way to next point
|
|
if ( x ) {
|
|
if ( ui.position.left - currentX > x/2 ) {
|
|
currentX = currentX + x;
|
|
} else if ( currentX - ui.position.left > x/2 ) {
|
|
currentX = currentX - x;
|
|
}
|
|
}
|
|
|
|
// If y is actually something, check that user is at least half way to next point
|
|
if ( y ) {
|
|
if ( ui.position.top - currentY > y/2 ) {
|
|
currentY = currentY + y;
|
|
} else if ( currentY - ui.position.top > y/2 ) {
|
|
currentY = currentY - y;
|
|
}
|
|
}
|
|
|
|
// If there threshold wasn't crossed these variables wouldn't be changed
|
|
// Otherwise this will now bump the draggable to the next spot on grid
|
|
ui.position.left = currentX;
|
|
ui.position.top = currentY;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// opacity option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
opacity: false
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this,
|
|
originalOpacity;
|
|
|
|
this._super();
|
|
|
|
this.element.on( "dragstart", function() {
|
|
|
|
// No need to continue
|
|
if ( !self.options.opacity ) {
|
|
return;
|
|
}
|
|
|
|
// Cache the original opacity of draggable element to reset later
|
|
originalOpacity = self.dragEl.css( 'opacity' );
|
|
|
|
// Set draggable element to new opacity
|
|
self.dragEl.css( 'opacity', self.options.opacity );
|
|
|
|
});
|
|
|
|
this.element.on( "dragstop", function() {
|
|
|
|
// No need to continue
|
|
if ( !self.options.opacity ) {
|
|
return;
|
|
}
|
|
|
|
// Reset opacity
|
|
self.dragEl.css( 'opacity', originalOpacity );
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// TODO: handle droppables
|
|
// revert + revertDuration options
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
revert: false,
|
|
revertDuration: 500
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this,
|
|
originalLeft, originalTop, originalPosition;
|
|
|
|
this._super();
|
|
|
|
this.element.on( "dragbeforestart", function() {
|
|
|
|
// No need to continue
|
|
if ( !self.options.revert ) {
|
|
return;
|
|
}
|
|
|
|
// Cache the original css of draggable element to reset later
|
|
originalLeft = self.dragEl.css( 'left' );
|
|
originalTop = self.dragEl.css( 'top' );
|
|
originalPosition = self.dragEl.css( 'position' );
|
|
|
|
});
|
|
|
|
this.element.on( "dragstop", function() {
|
|
|
|
// No need to continue
|
|
if ( !self.options.revert ) {
|
|
return;
|
|
}
|
|
|
|
// Reset to before drag
|
|
self.dragEl.animate({
|
|
left: originalLeft,
|
|
top: originalTop,
|
|
position: originalPosition
|
|
}, self.options.revertDuration );
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// zIndex option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
zIndex: false
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this,
|
|
originalZIndex;
|
|
|
|
this._super();
|
|
|
|
this.element.on( "dragstart", function() {
|
|
|
|
// No need to continue
|
|
if ( !self.options.zIndex ) {
|
|
return;
|
|
}
|
|
|
|
// Cache the original zIndex of draggable element to reset later
|
|
originalZIndex = self.dragEl.css( 'z-index' );
|
|
|
|
// Set draggable element to new zIndex
|
|
self.dragEl.css( 'z-index', self.options.zIndex );
|
|
|
|
});
|
|
|
|
this.element.on( "dragstop", function() {
|
|
|
|
// No need to continue
|
|
if ( !self.options.zIndex ) {
|
|
return;
|
|
}
|
|
|
|
// Reset zIndex
|
|
self.dragEl.css( 'z-index', originalZIndex );
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// TODO: need droppable working
|
|
// scope option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
scope: "default"
|
|
}
|
|
});
|
|
|
|
// scroll + scrollSensitivity + scrollSpeedType option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
scroll: true,
|
|
scrollSpeed: null,
|
|
scrollSensitivity: null
|
|
},
|
|
_create : function() {
|
|
|
|
var self = this,
|
|
handleScroll = this._handleScrolling,
|
|
speed = this._speed;
|
|
|
|
this._super();
|
|
|
|
this._speed = function( distance ) {
|
|
|
|
if ( self.options.scrollSpeed !== null ) {
|
|
|
|
self.scrollSpeed = self.options.scrollSpeed;
|
|
|
|
// Undo calculation that makes things go faster as distance increases
|
|
distance = 0;
|
|
}
|
|
|
|
return speed.call( self, distance );
|
|
|
|
};
|
|
|
|
// Wrap member function to check for ability to scroll
|
|
this._handleScrolling = function( pointerPosition ) {
|
|
|
|
if ( !self.options.scroll ) {
|
|
return;
|
|
}
|
|
|
|
if ( self.options.scrollSensitivity !== null ) {
|
|
self.scrollSensitivity = self.options.scrollSensitivity;
|
|
}
|
|
|
|
handleScroll.call( self, pointerPosition );
|
|
|
|
};
|
|
|
|
}
|
|
|
|
});
|
|
|
|
// stack option
|
|
$.widget( "ui.draggable", $.ui.draggable, {
|
|
options: {
|
|
stack: false
|
|
},
|
|
|
|
_create: function() {
|
|
|
|
var self = this;
|
|
|
|
this._super();
|
|
|
|
this.element.on( "dragbeforestart", function() {
|
|
|
|
var stack = self.options.stack,
|
|
group, min;
|
|
|
|
if ( !self.options.stack ) {
|
|
return;
|
|
}
|
|
|
|
group = $.makeArray( $(stack) ).sort(function(a,b) {
|
|
|
|
var aZIndex = parseInt( $(a).css("zIndex"), 10 ),
|
|
bZIndex = parseInt( $(b).css("zIndex"), 10 );
|
|
|
|
return ( aZIndex || 0) - ( bZIndex|| 0);
|
|
});
|
|
|
|
if (!group.length) {
|
|
return;
|
|
}
|
|
|
|
min = parseInt(group[0].style.zIndex, 10) || 0;
|
|
|
|
$(group).each(function(i) {
|
|
this.style.zIndex = min + i;
|
|
});
|
|
|
|
self.element[0].style.zIndex = min + group.length;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
|
|
} |