You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
693 lines
28 KiB
693 lines
28 KiB
/* =================================================== |
|
* jquery-sortable.js v0.9.13 |
|
* http://johnny.github.com/jquery-sortable/ |
|
* =================================================== |
|
* Copyright (c) 2012 Jonas von Andrian |
|
* All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions are met: |
|
* * Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* * Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in the |
|
* documentation and/or other materials provided with the distribution. |
|
* * The name of the author may not be used to endorse or promote products |
|
* derived from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY |
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* ========================================================== */ |
|
|
|
|
|
!function ( $, window, pluginName, undefined){ |
|
var containerDefaults = { |
|
// If true, items can be dragged from this container |
|
drag: true, |
|
// If true, items can be droped onto this container |
|
drop: true, |
|
// Exclude items from being draggable, if the |
|
// selector matches the item |
|
exclude: "", |
|
// If true, search for nested containers within an item.If you nest containers, |
|
// either the original selector with which you call the plugin must only match the top containers, |
|
// or you need to specify a group (see the bootstrap nav example) |
|
nested: true, |
|
// If true, the items are assumed to be arranged vertically |
|
vertical: true |
|
}, // end container defaults |
|
groupDefaults = { |
|
// This is executed after the placeholder has been moved. |
|
// $closestItemOrContainer contains the closest item, the placeholder |
|
// has been put at or the closest empty Container, the placeholder has |
|
// been appended to. |
|
afterMove: function ($placeholder, container, $closestItemOrContainer) { |
|
}, |
|
// The exact css path between the container and its items, e.g. "> tbody" |
|
containerPath: "", |
|
// The css selector of the containers |
|
containerSelector: "ol, ul", |
|
// Distance the mouse has to travel to start dragging |
|
distance: 0, |
|
// Time in milliseconds after mousedown until dragging should start. |
|
// This option can be used to prevent unwanted drags when clicking on an element. |
|
delay: 0, |
|
// The css selector of the drag handle |
|
handle: "", |
|
// The exact css path between the item and its subcontainers. |
|
// It should only match the immediate items of a container. |
|
// No item of a subcontainer should be matched. E.g. for ol>div>li the itemPath is "> div" |
|
itemPath: "", |
|
// The css selector of the items |
|
itemSelector: "li", |
|
// The class given to "body" while an item is being dragged |
|
bodyClass: "dragging", |
|
// The class giving to an item while being dragged |
|
draggedClass: "dragged", |
|
// Check if the dragged item may be inside the container. |
|
// Use with care, since the search for a valid container entails a depth first search |
|
// and may be quite expensive. |
|
isValidTarget: function ($item, container) { |
|
return true |
|
}, |
|
// Executed before onDrop if placeholder is detached. |
|
// This happens if pullPlaceholder is set to false and the drop occurs outside a container. |
|
onCancel: function ($item, container, _super, event) { |
|
}, |
|
// Executed at the beginning of a mouse move event. |
|
// The Placeholder has not been moved yet. |
|
onDrag: function ($item, position, _super, event) { |
|
$item.css(position) |
|
}, |
|
// Called after the drag has been started, |
|
// that is the mouse button is being held down and |
|
// the mouse is moving. |
|
// The container is the closest initialized container. |
|
// Therefore it might not be the container, that actually contains the item. |
|
onDragStart: function ($item, container, _super, event) { |
|
$item.css({ |
|
height: $item.outerHeight(), |
|
width: $item.outerWidth() |
|
}) |
|
$item.addClass(container.group.options.draggedClass) |
|
$("body").addClass(container.group.options.bodyClass) |
|
}, |
|
// Called when the mouse button is being released |
|
onDrop: function ($item, container, _super, event) { |
|
$item.removeClass(container.group.options.draggedClass).removeAttr("style") |
|
$("body").removeClass(container.group.options.bodyClass) |
|
}, |
|
// Called on mousedown. If falsy value is returned, the dragging will not start. |
|
// Ignore if element clicked is input, select or textarea |
|
onMousedown: function ($item, _super, event) { |
|
if (!event.target.nodeName.match(/^(input|select|textarea)$/i)) { |
|
event.preventDefault() |
|
return true |
|
} |
|
}, |
|
// The class of the placeholder (must match placeholder option markup) |
|
placeholderClass: "placeholder", |
|
// Template for the placeholder. Can be any valid jQuery input |
|
// e.g. a string, a DOM element. |
|
// The placeholder must have the class "placeholder" |
|
placeholder: '<li class="placeholder"></li>', |
|
// If true, the position of the placeholder is calculated on every mousemove. |
|
// If false, it is only calculated when the mouse is above a container. |
|
pullPlaceholder: true, |
|
// Specifies serialization of the container group. |
|
// The pair $parent/$children is either container/items or item/subcontainers. |
|
serialize: function ($parent, $children, parentIsContainer) { |
|
var result = $.extend({}, $parent.data()) |
|
|
|
if(parentIsContainer) |
|
return [$children] |
|
else if ($children[0]){ |
|
result.children = $children |
|
} |
|
|
|
delete result.subContainers |
|
delete result.sortable |
|
|
|
return result |
|
}, |
|
// Set tolerance while dragging. Positive values decrease sensitivity, |
|
// negative values increase it. |
|
tolerance: 0 |
|
}, // end group defaults |
|
containerGroups = {}, |
|
groupCounter = 0, |
|
emptyBox = { |
|
left: 0, |
|
top: 0, |
|
bottom: 0, |
|
right:0 |
|
}, |
|
eventNames = { |
|
start: "touchstart.sortable mousedown.sortable", |
|
drop: "touchend.sortable touchcancel.sortable mouseup.sortable", |
|
drag: "touchmove.sortable mousemove.sortable", |
|
scroll: "scroll.sortable" |
|
}, |
|
subContainerKey = "subContainers" |
|
|
|
/* |
|
* a is Array [left, right, top, bottom] |
|
* b is array [left, top] |
|
*/ |
|
function d(a,b) { |
|
var x = Math.max(0, a[0] - b[0], b[0] - a[1]), |
|
y = Math.max(0, a[2] - b[1], b[1] - a[3]) |
|
return x+y; |
|
} |
|
|
|
function setDimensions(array, dimensions, tolerance, useOffset) { |
|
var i = array.length, |
|
offsetMethod = useOffset ? "offset" : "position" |
|
tolerance = tolerance || 0 |
|
|
|
while(i--){ |
|
var el = array[i].el ? array[i].el : $(array[i]), |
|
// use fitting method |
|
pos = el[offsetMethod]() |
|
pos.left += parseInt(el.css('margin-left'), 10) |
|
pos.top += parseInt(el.css('margin-top'),10) |
|
dimensions[i] = [ |
|
pos.left - tolerance, |
|
pos.left + el.outerWidth() + tolerance, |
|
pos.top - tolerance, |
|
pos.top + el.outerHeight() + tolerance |
|
] |
|
} |
|
} |
|
|
|
function getRelativePosition(pointer, element) { |
|
var offset = element.offset() |
|
return { |
|
left: pointer.left - offset.left, |
|
top: pointer.top - offset.top |
|
} |
|
} |
|
|
|
function sortByDistanceDesc(dimensions, pointer, lastPointer) { |
|
pointer = [pointer.left, pointer.top] |
|
lastPointer = lastPointer && [lastPointer.left, lastPointer.top] |
|
|
|
var dim, |
|
i = dimensions.length, |
|
distances = [] |
|
|
|
while(i--){ |
|
dim = dimensions[i] |
|
distances[i] = [i,d(dim,pointer), lastPointer && d(dim, lastPointer)] |
|
} |
|
distances = distances.sort(function (a,b) { |
|
return b[1] - a[1] || b[2] - a[2] || b[0] - a[0] |
|
}) |
|
|
|
// last entry is the closest |
|
return distances |
|
} |
|
|
|
function ContainerGroup(options) { |
|
this.options = $.extend({}, groupDefaults, options) |
|
this.containers = [] |
|
|
|
if(!this.options.rootGroup){ |
|
this.scrollProxy = $.proxy(this.scroll, this) |
|
this.dragProxy = $.proxy(this.drag, this) |
|
this.dropProxy = $.proxy(this.drop, this) |
|
this.placeholder = $(this.options.placeholder) |
|
|
|
if(!options.isValidTarget) |
|
this.options.isValidTarget = undefined |
|
} |
|
} |
|
|
|
ContainerGroup.get = function (options) { |
|
if(!containerGroups[options.group]) { |
|
if(options.group === undefined) |
|
options.group = groupCounter ++ |
|
|
|
containerGroups[options.group] = new ContainerGroup(options) |
|
} |
|
|
|
return containerGroups[options.group] |
|
} |
|
|
|
ContainerGroup.prototype = { |
|
dragInit: function (e, itemContainer) { |
|
this.$document = $(itemContainer.el[0].ownerDocument) |
|
|
|
// get item to drag |
|
var closestItem = $(e.target).closest(this.options.itemSelector); |
|
// using the length of this item, prevents the plugin from being started if there is no handle being clicked on. |
|
// this may also be helpful in instantiating multidrag. |
|
if (closestItem.length) { |
|
this.item = closestItem; |
|
this.itemContainer = itemContainer; |
|
if (this.item.is(this.options.exclude) || !this.options.onMousedown(this.item, groupDefaults.onMousedown, e)) { |
|
return; |
|
} |
|
this.setPointer(e); |
|
this.toggleListeners('on'); |
|
this.setupDelayTimer(); |
|
this.dragInitDone = true; |
|
} |
|
}, |
|
drag: function (e) { |
|
if(!this.dragging){ |
|
if(!this.distanceMet(e) || !this.delayMet) |
|
return |
|
|
|
this.options.onDragStart(this.item, this.itemContainer, groupDefaults.onDragStart, e) |
|
this.item.before(this.placeholder) |
|
this.dragging = true |
|
} |
|
|
|
this.setPointer(e) |
|
// place item under the cursor |
|
this.options.onDrag(this.item, |
|
getRelativePosition(this.pointer, this.item.offsetParent()), |
|
groupDefaults.onDrag, |
|
e) |
|
|
|
var p = this.getPointer(e), |
|
box = this.sameResultBox, |
|
t = this.options.tolerance |
|
|
|
if(!box || box.top - t > p.top || box.bottom + t < p.top || box.left - t > p.left || box.right + t < p.left) |
|
if(!this.searchValidTarget()){ |
|
this.placeholder.detach() |
|
this.lastAppendedItem = undefined |
|
} |
|
}, |
|
drop: function (e) { |
|
this.toggleListeners('off') |
|
|
|
this.dragInitDone = false |
|
|
|
if(this.dragging){ |
|
// processing Drop, check if placeholder is detached |
|
if(this.placeholder.closest("html")[0]){ |
|
this.placeholder.before(this.item).detach() |
|
} else { |
|
this.options.onCancel(this.item, this.itemContainer, groupDefaults.onCancel, e) |
|
} |
|
this.options.onDrop(this.item, this.getContainer(this.item), groupDefaults.onDrop, e) |
|
|
|
// cleanup |
|
this.clearDimensions() |
|
this.clearOffsetParent() |
|
this.lastAppendedItem = this.sameResultBox = undefined |
|
this.dragging = false |
|
} |
|
}, |
|
searchValidTarget: function (pointer, lastPointer) { |
|
if(!pointer){ |
|
pointer = this.relativePointer || this.pointer |
|
lastPointer = this.lastRelativePointer || this.lastPointer |
|
} |
|
|
|
var distances = sortByDistanceDesc(this.getContainerDimensions(), |
|
pointer, |
|
lastPointer), |
|
i = distances.length |
|
|
|
while(i--){ |
|
var index = distances[i][0], |
|
distance = distances[i][1] |
|
|
|
if(!distance || this.options.pullPlaceholder){ |
|
var container = this.containers[index] |
|
if(!container.disabled){ |
|
if(!this.$getOffsetParent()){ |
|
var offsetParent = container.getItemOffsetParent() |
|
pointer = getRelativePosition(pointer, offsetParent) |
|
lastPointer = getRelativePosition(lastPointer, offsetParent) |
|
} |
|
if(container.searchValidTarget(pointer, lastPointer)) |
|
return true |
|
} |
|
} |
|
} |
|
if(this.sameResultBox) |
|
this.sameResultBox = undefined |
|
}, |
|
movePlaceholder: function (container, item, method, sameResultBox) { |
|
var lastAppendedItem = this.lastAppendedItem |
|
if(!sameResultBox && lastAppendedItem && lastAppendedItem[0] === item[0]) |
|
return; |
|
|
|
item[method](this.placeholder) |
|
this.lastAppendedItem = item |
|
this.sameResultBox = sameResultBox |
|
this.options.afterMove(this.placeholder, container, item) |
|
}, |
|
getContainerDimensions: function () { |
|
if(!this.containerDimensions) |
|
setDimensions(this.containers, this.containerDimensions = [], this.options.tolerance, !this.$getOffsetParent()) |
|
return this.containerDimensions |
|
}, |
|
getContainer: function (element) { |
|
return element.closest(this.options.containerSelector).data(pluginName) |
|
}, |
|
$getOffsetParent: function () { |
|
if(this.offsetParent === undefined){ |
|
var i = this.containers.length - 1, |
|
offsetParent = this.containers[i].getItemOffsetParent() |
|
|
|
if(!this.options.rootGroup){ |
|
while(i--){ |
|
if(offsetParent[0] != this.containers[i].getItemOffsetParent()[0]){ |
|
// If every container has the same offset parent, |
|
// use position() which is relative to this parent, |
|
// otherwise use offset() |
|
// compare #setDimensions |
|
offsetParent = false |
|
break; |
|
} |
|
} |
|
} |
|
|
|
this.offsetParent = offsetParent |
|
} |
|
return this.offsetParent |
|
}, |
|
setPointer: function (e) { |
|
var pointer = this.getPointer(e) |
|
|
|
if(this.$getOffsetParent()){ |
|
var relativePointer = getRelativePosition(pointer, this.$getOffsetParent()) |
|
this.lastRelativePointer = this.relativePointer |
|
this.relativePointer = relativePointer |
|
} |
|
|
|
this.lastPointer = this.pointer |
|
this.pointer = pointer |
|
}, |
|
distanceMet: function (e) { |
|
var currentPointer = this.getPointer(e) |
|
return (Math.max( |
|
Math.abs(this.pointer.left - currentPointer.left), |
|
Math.abs(this.pointer.top - currentPointer.top) |
|
) >= this.options.distance) |
|
}, |
|
getPointer: function(e) { |
|
var o = e.originalEvent || e.originalEvent.touches && e.originalEvent.touches[0] |
|
return { |
|
left: e.pageX || o.pageX, |
|
top: e.pageY || o.pageY |
|
} |
|
}, |
|
setupDelayTimer: function () { |
|
var that = this |
|
this.delayMet = !this.options.delay |
|
|
|
// init delay timer if needed |
|
if (!this.delayMet) { |
|
clearTimeout(this._mouseDelayTimer); |
|
this._mouseDelayTimer = setTimeout(function() { |
|
that.delayMet = true |
|
}, this.options.delay) |
|
} |
|
}, |
|
scroll: function (e) { |
|
this.clearDimensions() |
|
this.clearOffsetParent() // TODO is this needed? |
|
}, |
|
toggleListeners: function (method) { |
|
var that = this, |
|
events = ['drag','drop','scroll'] |
|
|
|
$.each(events,function (i,event) { |
|
that.$document[method](eventNames[event], that[event + 'Proxy']) |
|
}) |
|
}, |
|
clearOffsetParent: function () { |
|
this.offsetParent = undefined |
|
}, |
|
// Recursively clear container and item dimensions |
|
clearDimensions: function () { |
|
this.traverse(function(object){ |
|
object._clearDimensions() |
|
}) |
|
}, |
|
traverse: function(callback) { |
|
callback(this) |
|
var i = this.containers.length |
|
while(i--){ |
|
this.containers[i].traverse(callback) |
|
} |
|
}, |
|
_clearDimensions: function(){ |
|
this.containerDimensions = undefined |
|
}, |
|
_destroy: function () { |
|
containerGroups[this.options.group] = undefined |
|
} |
|
} |
|
|
|
function Container(element, options) { |
|
this.el = element |
|
this.options = $.extend( {}, containerDefaults, options) |
|
|
|
this.group = ContainerGroup.get(this.options) |
|
this.rootGroup = this.options.rootGroup || this.group |
|
this.handle = this.rootGroup.options.handle || this.rootGroup.options.itemSelector |
|
|
|
var itemPath = this.rootGroup.options.itemPath |
|
this.target = itemPath ? this.el.find(itemPath) : this.el |
|
|
|
this.target.on(eventNames.start, this.handle, $.proxy(this.dragInit, this)) |
|
|
|
if(this.options.drop) |
|
this.group.containers.push(this) |
|
} |
|
|
|
Container.prototype = { |
|
dragInit: function (e) { |
|
var rootGroup = this.rootGroup |
|
|
|
if( !this.disabled && |
|
!rootGroup.dragInitDone && |
|
this.options.drag && |
|
this.isValidDrag(e)) { |
|
rootGroup.dragInit(e, this) |
|
} |
|
}, |
|
isValidDrag: function(e) { |
|
return e.which == 1 || |
|
e.type == "touchstart" && e.originalEvent.touches.length == 1 |
|
}, |
|
searchValidTarget: function (pointer, lastPointer) { |
|
var distances = sortByDistanceDesc(this.getItemDimensions(), |
|
pointer, |
|
lastPointer), |
|
i = distances.length, |
|
rootGroup = this.rootGroup, |
|
validTarget = !rootGroup.options.isValidTarget || |
|
rootGroup.options.isValidTarget(rootGroup.item, this) |
|
|
|
if(!i && validTarget){ |
|
rootGroup.movePlaceholder(this, this.target, "append") |
|
return true |
|
} else |
|
while(i--){ |
|
var index = distances[i][0], |
|
distance = distances[i][1] |
|
if(!distance && this.hasChildGroup(index)){ |
|
var found = this.getContainerGroup(index).searchValidTarget(pointer, lastPointer) |
|
if(found) |
|
return true |
|
} |
|
else if(validTarget){ |
|
this.movePlaceholder(index, pointer) |
|
return true |
|
} |
|
} |
|
}, |
|
movePlaceholder: function (index, pointer) { |
|
var item = $(this.items[index]), |
|
dim = this.itemDimensions[index], |
|
method = "after", |
|
width = item.outerWidth(), |
|
height = item.outerHeight(), |
|
offset = item.offset(), |
|
sameResultBox = { |
|
left: offset.left, |
|
right: offset.left + width, |
|
top: offset.top, |
|
bottom: offset.top + height |
|
} |
|
if(this.options.vertical){ |
|
var yCenter = (dim[2] + dim[3]) / 2, |
|
inUpperHalf = pointer.top <= yCenter |
|
if(inUpperHalf){ |
|
method = "before" |
|
sameResultBox.bottom -= height / 2 |
|
} else |
|
sameResultBox.top += height / 2 |
|
} else { |
|
var xCenter = (dim[0] + dim[1]) / 2, |
|
inLeftHalf = pointer.left <= xCenter |
|
if(inLeftHalf){ |
|
method = "before" |
|
sameResultBox.right -= width / 2 |
|
} else |
|
sameResultBox.left += width / 2 |
|
} |
|
if(this.hasChildGroup(index)) |
|
sameResultBox = emptyBox |
|
this.rootGroup.movePlaceholder(this, item, method, sameResultBox) |
|
}, |
|
getItemDimensions: function () { |
|
if(!this.itemDimensions){ |
|
this.items = this.$getChildren(this.el, "item").filter( |
|
":not(." + this.group.options.placeholderClass + ", ." + this.group.options.draggedClass + ")" |
|
).get() |
|
setDimensions(this.items, this.itemDimensions = [], this.options.tolerance) |
|
} |
|
return this.itemDimensions |
|
}, |
|
getItemOffsetParent: function () { |
|
var offsetParent, |
|
el = this.el |
|
// Since el might be empty we have to check el itself and |
|
// can not do something like el.children().first().offsetParent() |
|
if(el.css("position") === "relative" || el.css("position") === "absolute" || el.css("position") === "fixed") |
|
offsetParent = el |
|
else |
|
offsetParent = el.offsetParent() |
|
return offsetParent |
|
}, |
|
hasChildGroup: function (index) { |
|
return this.options.nested && this.getContainerGroup(index) |
|
}, |
|
getContainerGroup: function (index) { |
|
var childGroup = $.data(this.items[index], subContainerKey) |
|
if( childGroup === undefined){ |
|
var childContainers = this.$getChildren(this.items[index], "container") |
|
childGroup = false |
|
|
|
if(childContainers[0]){ |
|
var options = $.extend({}, this.options, { |
|
rootGroup: this.rootGroup, |
|
group: groupCounter ++ |
|
}) |
|
childGroup = childContainers[pluginName](options).data(pluginName).group |
|
} |
|
$.data(this.items[index], subContainerKey, childGroup) |
|
} |
|
return childGroup |
|
}, |
|
$getChildren: function (parent, type) { |
|
var options = this.rootGroup.options, |
|
path = options[type + "Path"], |
|
selector = options[type + "Selector"] |
|
|
|
parent = $(parent) |
|
if(path) |
|
parent = parent.find(path) |
|
|
|
return parent.children(selector) |
|
}, |
|
_serialize: function (parent, isContainer) { |
|
var that = this, |
|
childType = isContainer ? "item" : "container", |
|
|
|
children = this.$getChildren(parent, childType).not(this.options.exclude).map(function () { |
|
return that._serialize($(this), !isContainer) |
|
}).get() |
|
|
|
return this.rootGroup.options.serialize(parent, children, isContainer) |
|
}, |
|
traverse: function(callback) { |
|
$.each(this.items || [], function(item){ |
|
var group = $.data(this, subContainerKey) |
|
if(group) |
|
group.traverse(callback) |
|
}); |
|
|
|
callback(this) |
|
}, |
|
_clearDimensions: function () { |
|
this.itemDimensions = undefined |
|
}, |
|
_destroy: function() { |
|
var that = this; |
|
|
|
this.target.off(eventNames.start, this.handle); |
|
this.el.removeData(pluginName) |
|
|
|
if(this.options.drop) |
|
this.group.containers = $.grep(this.group.containers, function(val){ |
|
return val != that |
|
}) |
|
|
|
$.each(this.items || [], function(){ |
|
$.removeData(this, subContainerKey) |
|
}) |
|
} |
|
} |
|
|
|
var API = { |
|
enable: function() { |
|
this.traverse(function(object){ |
|
object.disabled = false |
|
}) |
|
}, |
|
disable: function (){ |
|
this.traverse(function(object){ |
|
object.disabled = true |
|
}) |
|
}, |
|
serialize: function () { |
|
return this._serialize(this.el, true) |
|
}, |
|
refresh: function() { |
|
this.traverse(function(object){ |
|
object._clearDimensions() |
|
}) |
|
}, |
|
destroy: function () { |
|
this.traverse(function(object){ |
|
object._destroy(); |
|
}) |
|
} |
|
} |
|
|
|
$.extend(Container.prototype, API) |
|
|
|
/** |
|
* jQuery API |
|
* |
|
* Parameters are |
|
* either options on init |
|
* or a method name followed by arguments to pass to the method |
|
*/ |
|
$.fn[pluginName] = function(methodOrOptions) { |
|
var args = Array.prototype.slice.call(arguments, 1) |
|
|
|
return this.map(function(){ |
|
var $t = $(this), |
|
object = $t.data(pluginName) |
|
|
|
if(object && API[methodOrOptions]) |
|
return API[methodOrOptions].apply(object, args) || this |
|
else if(!object && (methodOrOptions === undefined || |
|
typeof methodOrOptions === "object")) |
|
$t.data(pluginName, new Container($t, methodOrOptions)) |
|
|
|
return this |
|
}); |
|
}; |
|
|
|
}(jQuery, window, 'sortable'); |