CLICK HERE TO BUY IT TODAY! OR GET IT FREE VIA TRIALPAY  

PHP Demo Application - Source Code

/Framework/Model/Vendor/jquery-ui/development-bundle/ui/jquery.ui.draggable.js



/*
 * jQuery UI Draggable 1.8.4
 *
 * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 *
 * http://docs.jquery.com/UI/Draggables
 *
 * Depends:
 *    jquery.ui.core.js
 *    jquery.ui.mouse.js
 *    jquery.ui.widget.js
 */
(function( $, undefined ) {
	$.widget("ui.draggable", $.ui.mouse, {
		    widgetEventPrefix"drag",
		    options: {
			        addClassestrue,
			        appendTo"parent",
			        axisfalse,
			        connectToSortablefalse,
			        containmentfalse,
			        cursor"auto",
			        cursorAtfalse,
			        gridfalse,
			        handlefalse,
			        helper"original",
			        iframeFixfalse,
			        opacityfalse,
			        refreshPositionsfalse,
			        revertfalse,
			        revertDuration500,
			        scope"default",
			        scrolltrue,
			        scrollSensitivity20,
			        scrollSpeed20,
			        snapfalse,
			        snapMode"both",
			        snapTolerance20,
			        stackfalse,
			        zIndexfalse
			    },
		    _create: function() {
			        if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
			            this.element[0].style.position 'relative';
			        (this.options.addClasses && this.element.addClass("ui-draggable"));
			        (this.options.disabled && this.element.addClass("ui-draggable-disabled"));
			        this._mouseInit();
			    },
		    destroy: function() {
			        if(!this.element.data('draggable')) return;
			        this.element
			            .removeData("draggable")
			            .unbind(".draggable")
			            .removeClass("ui-draggable"
			                " ui-draggable-dragging"
			                " ui-draggable-disabled");
			        this._mouseDestroy();
			        return this;
			    },
		    _mouseCapture: function(event) {
			        var this.options;
			        // among others, prevent a drag on a resizable-handle
			        if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
			            return false;
			        //Quit if we're not on a valid handle
			        this.handle this._getHandle(event);
			        if (!this.handle)
			            return false;
			        return true;
			    },
		    _mouseStart: function(event) {
			        var this.options;
			        //Create and append the visible helper
			        this.helper this._createHelper(event);
			        //Cache the helper size
			        this._cacheHelperProportions();
			        //If ddmanager is used for droppables, set the global draggable
			        if($.ui.ddmanager)
			            $.ui.ddmanager.current this;
			        /*
			         * - Position generation -
			         * This block generates everything position related - it's the core of draggables.
			         */
			        //Cache the margins of the original element
			        this._cacheMargins();
			        //Store the helper's css position
			        this.cssPosition this.helper.css("position");
			        this.scrollParent this.helper.scrollParent();
			        //The element's absolute position on the page minus margins
			        this.offset this.positionAbs this.element.offset();
			        this.offset = {
				            topthis.offset.top this.margins.top,
				            leftthis.offset.left this.margins.left
				        };
			        $.extend(this.offset, {
				            click: { //Where the click happened, relative to the element
					                leftevent.pageX this.offset.left,
					                topevent.pageY this.offset.top
					            },
				            parentthis._getParentOffset(),
				            relativethis._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
				        });
			        //Generate the original position
			        this.originalPosition this.position this._generatePosition(event);
			        this.originalPageX event.pageX;
			        this.originalPageY event.pageY;
			        //Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
			        (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
			        //Set a containment if given in the options
			        if(o.containment)
			            this._setContainment();
			        //Trigger event + callbacks
			        if(this._trigger("start"event) === false) {
				            this._clear();
				            return false;
				        }
			        //Recache the helper size
			        this._cacheHelperProportions();
			        //Prepare the droppable offsets
			        if ($.ui.ddmanager && !o.dropBehaviour)
			            $.ui.ddmanager.prepareOffsets(thisevent);
			        this.helper.addClass("ui-draggable-dragging");
			        this._mouseDrag(eventtrue);
			 //Execute the drag once - this causes the helper not to be visible before getting its correct position
			        return true;
			    },
		    _mouseDrag: function(eventnoPropagation) {
			        //Compute the helpers position
			        this.position this._generatePosition(event);
			        this.positionAbs this._convertPositionTo("absolute");
			        //Call plugins and callbacks and use the resulting position if something is returned
			        if (!noPropagation) {
				            var ui this._uiHash();
				            if(this._trigger('drag'eventui) === false) {
					                this._mouseUp({});
					                return false;
					            }
				            this.position ui.position;
				        }
			        if(!this.options.axis || this.options.axis != "y"this.helper[0].style.left this.position.left+'px';
			        if(!this.options.axis || this.options.axis != "x"this.helper[0].style.top this.position.top+'px';
			        if($.ui.ddmanager) $.ui.ddmanager.drag(thisevent);
			        return false;
			    },
		    _mouseStop: function(event) {
			        //If we are using droppables, inform the manager about the drop
			        var dropped false;
			        if ($.ui.ddmanager && !this.options.dropBehaviour)
			            dropped = $.ui.ddmanager.drop(thisevent);
			        //if a drop comes from outside (a sortable)
			        if(this.dropped) {
				            dropped this.dropped;
				            this.dropped false;
				        }
			        //if the original element is removed, don't bother to continue
			        if(!this.element[0] || !this.element[0].parentNode)
			            return false;
			        if((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.elementdropped))) {
				            var self this;
				            $(this.helper).animate(this.originalPositionparseInt(this.options.revertDuration10), function() {
					                if(self._trigger("stop"event) !== false) {
						                    self._clear();
						                }
					            });
				        } else {
				            if(this._trigger("stop"event) !== false) {
					                this._clear();
					            }
				        }
			        return false;
			    },
		    cancel: function() {
			        if(this.helper.is(".ui-draggable-dragging")) {
				            this._mouseUp({});
				        } else {
				            this._clear();
				        }
			        return this;
			    },
		    _getHandle: function(event) {
			        var handle = !this.options.handle || !$(this.options.handlethis.element).length true false;
			        $(this.options.handlethis.element)
			            .find("*")
			            .andSelf()
			            .each(function() {
				                if(this == event.targethandle true;
				            });
			        return handle;
			    },
		    _createHelper: function(event) {
			        var this.options;
			        var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' this.element.clone() : this.element);
			        if(!helper.parents('body').length)
			            helper.appendTo((o.appendTo == 'parent' this.element[0].parentNode o.appendTo));
			        if(helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
			            helper.css("position""absolute");
			        return helper;
			    },
		    _adjustOffsetFromHelper: function(obj) {
			        if (typeof obj == 'string') {
				            obj obj.split(' ');
				        }
			        if ($.isArray(obj)) {
				            obj = {left: +obj[0], top: +obj[1] || 0};
				        }
			        if ('left' in obj) {
				            this.offset.click.left obj.left this.margins.left;
				        }
			        if ('right' in obj) {
				            this.offset.click.left this.helperProportions.width obj.right this.margins.left;
				        }
			        if ('top' in obj) {
				            this.offset.click.top obj.top this.margins.top;
				        }
			        if ('bottom' in obj) {
				            this.offset.click.top this.helperProportions.height obj.bottom this.margins.top;
				        }
			    },
		    _getParentOffset: function() {
			        //Get the offsetParent and cache its position
			        this.offsetParent this.helper.offsetParent();
			        var po this.offsetParent.offset();
			        // This is a special case where we need to modify a offset calculated on start, since the following happened:
			        // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
			        // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
			        //    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
			        if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
				            po.left += this.scrollParent.scrollLeft();
				            po.top += this.scrollParent.scrollTop();
				        }
			        if((this.offsetParent[0] == document.body//This needs to be actually done for all browsers, since pageX/pageY includes this information
			        || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
			            po = { top0left0
				};
			        return {
				            toppo.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
				            leftpo.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
				        };
			    },
		    _getRelativeOffset: function() {
			        if(this.cssPosition == "relative") {
				            var this.element.position();
				            return {
					                topp.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
					                leftp.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
					            };
				        } else {
				            return { top0left0
					};
				        }
			    },
		    _cacheMargins: function() {
			        this.margins = {
				            left: (parseInt(this.element.css("marginLeft"),10) || 0),
				            top: (parseInt(this.element.css("marginTop"),10) || 0)
				        };
			    },
		    _cacheHelperProportions: function() {
			        this.helperProportions = {
				            widththis.helper.outerWidth(),
				            heightthis.helper.outerHeight()
				        };
			    },
		    _setContainment: function() {
			        var this.options;
			        if(o.containment == 'parent'o.containment this.helper[0].parentNode;
			        if(o.containment == 'document' || o.containment == 'window'this.containment = [
			            this.offset.relative.left this.offset.parent.left,
			            this.offset.relative.top this.offset.parent.top,
			            $(o.containment == 'document' document window).width() - this.helperProportions.width this.margins.left,
			            ($(o.containment == 'document' document window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height this.margins.top
			        ];
			        if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {
				            var ce = $(o.containment)[0];
				 if(!ce) return;
				            var co = $(o.containment).offset();
				            var over = ($(ce).css("overflow") != 'hidden');
				            this.containment = [
				                co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
				                co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
				                co.left+(over Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width this.margins.left,
				                co.top+(over Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height this.margins.top
				            ];
				        } else if(o.containment.constructor == Array) {
				            this.containment o.containment;
				        }
			    },
		    _convertPositionTo: function(dpos) {
			        if(!pospos this.position;
			        var mod == "absolute" : -1;
			        var this.optionsscroll this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent this.scrollParentscrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
			        return {
				            top: (
				                pos.top                                                                    // The absolute mouse position
				                this.offset.relative.top mod                                        // Only for relative positioned nodes: Relative offset from element to offset parent
				                this.offset.parent.top mod                                            // The offsetParent's offset without borders (offset + border)
				                - ($.browser.safari && $.browser.version 526 && this.cssPosition == 'fixed' : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode scroll.scrollTop() ) ) * mod)
				            ),
				            left: (
				                pos.left                                                                // The absolute mouse position
				                this.offset.relative.left mod                                        // Only for relative positioned nodes: Relative offset from element to offset parent
				                this.offset.parent.left mod                                            // The offsetParent's offset without borders (offset + border)
				                - ($.browser.safari && $.browser.version 526 && this.cssPosition == 'fixed' : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode scroll.scrollLeft() ) * mod)
				            )
				        };
			    },
		    _generatePosition: function(event) {
			        var this.optionsscroll this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent this.scrollParentscrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
			        var pageX event.pageX;
			        var pageY event.pageY;
			        /*
			         * - Position constraining -
			         * Constrain the position to a mix of grid, containment.
			         */
			        if(this.originalPosition) {
				//If we are not dragging yet, we won't check for options
				            if(this.containment) {
					                if(event.pageX this.offset.click.left this.containment[0]) pageX this.containment[0] + this.offset.click.left;
					                if(event.pageY this.offset.click.top this.containment[1]) pageY this.containment[1] + this.offset.click.top;
					                if(event.pageX this.offset.click.left this.containment[2]) pageX this.containment[2] + this.offset.click.left;
					                if(event.pageY this.offset.click.top this.containment[3]) pageY this.containment[3] + this.offset.click.top;
					            }
				            if(o.grid) {
					                var top this.originalPageY Math.round((pageY this.originalPageY) / o.grid[1]) * o.grid[1];
					                pageY this.containment ? (!(top this.offset.click.top this.containment[1] || top this.offset.click.top this.containment[3]) ? top : (!(top this.offset.click.top this.containment[1]) ? top o.grid[1] : top o.grid[1])) : top;
					                var left this.originalPageX Math.round((pageX this.originalPageX) / o.grid[0]) * o.grid[0];
					                pageX this.containment ? (!(left this.offset.click.left this.containment[0] || left this.offset.click.left this.containment[2]) ? left : (!(left this.offset.click.left this.containment[0]) ? left o.grid[0] : left o.grid[0])) : left;
					            }
				        }
			        return {
				            top: (
				                pageY                                                                // The absolute mouse position
				                this.offset.click.top                                                    // Click offset (relative to the element)
				                this.offset.relative.top                                                // Only for relative positioned nodes: Relative offset from element to offset parent
				                this.offset.parent.top                                                // The offsetParent's offset without borders (offset + border)
				                + ($.browser.safari && $.browser.version 526 && this.cssPosition == 'fixed' : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode scroll.scrollTop() ) ))
				            ),
				            left: (
				                pageX                                                                // The absolute mouse position
				                this.offset.click.left                                                // Click offset (relative to the element)
				                this.offset.relative.left                                                // Only for relative positioned nodes: Relative offset from element to offset parent
				                this.offset.parent.left                                                // The offsetParent's offset without borders (offset + border)
				                + ($.browser.safari && $.browser.version 526 && this.cssPosition == 'fixed' : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode scroll.scrollLeft() ))
				            )
				        };
			    },
		    _clear: function() {
			        this.helper.removeClass("ui-draggable-dragging");
			        if(this.helper[0] != this.element[0] && !this.cancelHelperRemovalthis.helper.remove();
			        //if($.ui.ddmanager) $.ui.ddmanager.current = null;
			        this.helper null;
			        this.cancelHelperRemoval false;
			    },
		    // From now on bulk stuff - mainly helpers
		    _trigger: function(typeeventui) {
			        ui ui || this._uiHash();
			        $.ui.plugin.call(thistype, [eventui]);
			        if(type == "drag"this.positionAbs this._convertPositionTo("absolute");
			 //The absolute position has to be recalculated after plugins
			        return $.Widget.prototype._trigger.call(thistypeeventui);
			    },
		    plugins{},
		    _uiHash: function(event) {
			        return {
				            helperthis.helper,
				            positionthis.position,
				            originalPositionthis.originalPosition,
				            offsetthis.positionAbs
				        };
			    }
		});
	$.extend($.ui.draggable, {
		    version"1.8.4"
		});
	$.ui.plugin.add("draggable""connectToSortable", {
		    start: function(eventui) {
			        var inst = $(this).data("draggable"), inst.options,
			            uiSortable = $.extend({}ui, { iteminst.element
				});
			        inst.sortables [];
			        $(o.connectToSortable).each(function() {
				            var sortable = $.data(this'sortable');
				            if (sortable && !sortable.options.disabled) {
					                inst.sortables.push({
						                    instancesortable,
						                    shouldRevertsortable.options.revert
						                });
					                sortable._refreshItems();
					    //Do a one-time refresh at start to refresh the containerCache
					                sortable._trigger("activate"eventuiSortable);
					            }
				        });
			    },
		    stop: function(eventui) {
			        //If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
			        var inst = $(this).data("draggable"),
			            uiSortable = $.extend({}ui, { iteminst.element
				});
			        $.each(inst.sortables, function() {
				            if(this.instance.isOver) {
					                this.instance.isOver 0;
					                inst.cancelHelperRemoval true;
					 //Don't remove the helper in the draggable instance
					                this.instance.cancelHelperRemoval false;
					 //Remove it in the sortable instance (so sortable plugins like revert still work)
					                //The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'
					                if(this.shouldRevertthis.instance.options.revert true;
					                //Trigger the stop of the sortable
					                this.instance._mouseStop(event);
					                this.instance.options.helper this.instance.options._helper;
					                //If the helper has been the original item, restore properties in the sortable
					                if(inst.options.helper == 'original')
					                    this.instance.currentItem.css({ top'auto'left'auto'
						});
					            } else {
					                this.instance.cancelHelperRemoval false;
					 //Remove the helper in the sortable instance
					                this.instance._trigger("deactivate"eventuiSortable);
					            }
				        });
			    },
		    drag: function(eventui) {
			        var inst = $(this).data("draggable"), self this;
			        var checkPos = function(o) {
				            var dyClick this.offset.click.topdxClick this.offset.click.left;
				            var helperTop this.positionAbs.tophelperLeft this.positionAbs.left;
				            var itemHeight o.heightitemWidth o.width;
				            var itemTop o.topitemLeft o.left;
				            return $.ui.isOver(helperTop dyClickhelperLeft dxClickitemTopitemLeftitemHeightitemWidth);
				        };
			        $.each(inst.sortables, function(i) {
				            //Copy over some variables to allow calling the sortable's native _intersectsWith
				            this.instance.positionAbs inst.positionAbs;
				            this.instance.helperProportions inst.helperProportions;
				            this.instance.offset.click inst.offset.click;
				            if(this.instance._intersectsWith(this.instance.containerCache)) {
					                //If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
					                if(!this.instance.isOver) {
						                    this.instance.isOver 1;
						                    //Now we fake the start of dragging for the sortable instance,
						                    //by cloning the list group item, appending it to the sortable and using it as inst.currentItem
						                    //We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
						                    this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item"true);
						                    this.instance.options._helper this.instance.options.helper;
						 //Store helper option to later restore it
						                    this.instance.options.helper = function() {
							return ui.helper[0];
							};
						                    event.target this.instance.currentItem[0];
						                    this.instance._mouseCapture(eventtrue);
						                    this.instance._mouseStart(eventtruetrue);
						                    //Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
						                    this.instance.offset.click.top inst.offset.click.top;
						                    this.instance.offset.click.left inst.offset.click.left;
						                    this.instance.offset.parent.left -= inst.offset.parent.left this.instance.offset.parent.left;
						                    this.instance.offset.parent.top -= inst.offset.parent.top this.instance.offset.parent.top;
						                    inst._trigger("toSortable"event);
						                    inst.dropped this.instance.element;
						 //draggable revert needs that
						                    //hack so receive/update callbacks work (mostly)
						                    inst.currentItem inst.element;
						                    this.instance.fromOutside inst;
						                }
					                //Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
					                if(this.instance.currentItemthis.instance._mouseDrag(event);
					            } else {
					                //If it doesn't intersect with the sortable, and it intersected before,
					                //we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
					                if(this.instance.isOver) {
						                    this.instance.isOver 0;
						                    this.instance.cancelHelperRemoval true;
						                    //Prevent reverting on this forced stop
						                    this.instance.options.revert false;
						                    // The out event needs to be triggered independently
						                    this.instance._trigger('out'eventthis.instance._uiHash(this.instance));
						                    this.instance._mouseStop(eventtrue);
						                    this.instance.options.helper this.instance.options._helper;
						                    //Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
						                    this.instance.currentItem.remove();
						                    if(this.instance.placeholderthis.instance.placeholder.remove();
						                    inst._trigger("fromSortable"event);
						                    inst.dropped false;
						 //draggable revert needs that
						                }
					            };
				        });
			    }
		});
	$.ui.plugin.add("draggable""cursor", {
		    start: function(eventui) {
			        var = $('body'), = $(this).data('draggable').options;
			        if (t.css("cursor")) o._cursor t.css("cursor");
			        t.css("cursor"o.cursor);
			    },
		    stop: function(eventui) {
			        var = $(this).data('draggable').options;
			        if (o._cursor) $('body').css("cursor"o._cursor);
			    }
		});
	$.ui.plugin.add("draggable""iframeFix", {
		    start: function(eventui) {
			        var = $(this).data('draggable').options;
			        $(o.iframeFix === true "iframe" o.iframeFix).each(function() {
				            $('<div class="ui-draggable-iframeFix" style="background: #fff;
				"></div>')
				            .css({
					                widththis.offsetWidth+"px"heightthis.offsetHeight+"px",
					                position"absolute"opacity"0.001"zIndex1000
					            })
				            .css($(this).offset())
				            .appendTo("body");
				        });
			    },
		    stop: function(eventui) {
			        $("div.ui-draggable-iframeFix").each(function() {
				this.parentNode.removeChild(this);
				});
			 //Remove frame helpers
			    }
		});
	$.ui.plugin.add("draggable""opacity", {
		    start: function(eventui) {
			        var = $(ui.helper), = $(this).data('draggable').options;
			        if(t.css("opacity")) o._opacity t.css("opacity");
			        t.css('opacity'o.opacity);
			    },
		    stop: function(eventui) {
			        var = $(this).data('draggable').options;
			        if(o._opacity) $(ui.helper).css('opacity'o._opacity);
			    }
		});
	$.ui.plugin.add("draggable""scroll", {
		    start: function(eventui) {
			        var = $(this).data("draggable");
			        if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML'i.overflowOffset i.scrollParent.offset();
			    },
		    drag: function(eventui) {
			        var = $(this).data("draggable"), i.optionsscrolled false;
			        if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {
				            if(!o.axis || o.axis != 'x') {
					                if((i.overflowOffset.top i.scrollParent[0].offsetHeight) - event.pageY o.scrollSensitivity)
					                    i.scrollParent[0].scrollTop scrolled i.scrollParent[0].scrollTop o.scrollSpeed;
					                else if(event.pageY i.overflowOffset.top o.scrollSensitivity)
					                    i.scrollParent[0].scrollTop scrolled i.scrollParent[0].scrollTop o.scrollSpeed;
					            }
				            if(!o.axis || o.axis != 'y') {
					                if((i.overflowOffset.left i.scrollParent[0].offsetWidth) - event.pageX o.scrollSensitivity)
					                    i.scrollParent[0].scrollLeft scrolled i.scrollParent[0].scrollLeft o.scrollSpeed;
					                else if(event.pageX i.overflowOffset.left o.scrollSensitivity)
					                    i.scrollParent[0].scrollLeft scrolled i.scrollParent[0].scrollLeft o.scrollSpeed;
					            }
				        } else {
				            if(!o.axis || o.axis != 'x') {
					                if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
					                    scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
					                else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
					                    scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
					            }
				            if(!o.axis || o.axis != 'y') {
					                if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
					                    scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
					                else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
					                    scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
					            }
				        }
			        if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
			            $.ui.ddmanager.prepareOffsets(ievent);
			    }
		});
	$.ui.plugin.add("draggable""snap", {
		    start: function(eventui) {
			        var = $(this).data("draggable"), i.options;
			        i.snapElements [];
			        $(o.snap.constructor != String ? ( o.snap.items || ':data(draggable)' ) : o.snap).each(function() {
				            var $t = $(this);
				 var $o $t.offset();
				            if(this != i.element[0]) i.snapElements.push({
					                itemthis,
					                width$t.outerWidth(), height$t.outerHeight(),
					                top$o.topleft$o.left
					            });
				        });
			    },
		    drag: function(eventui) {
			        var inst = $(this).data("draggable"), inst.options;
			        var o.snapTolerance;
			        var x1 ui.offset.leftx2 x1 inst.helperProportions.width,
			            y1 ui.offset.topy2 y1 inst.helperProportions.height;
			        for (var inst.snapElements.length 1;
			 >= 0;
			 i--){
				            var inst.snapElements[i].leftinst.snapElements[i].width,
				                inst.snapElements[i].topinst.snapElements[i].height;
				            //Yes, I know, this is insane ;
				)
				            if(!((l-x1 && x1 r+&& t-y1 && y1 b+d) || (l-x1 && x1 r+&& t-y2 && y2 b+d) || (l-x2 && x2 r+&& t-y1 && y1 b+d) || (l-x2 && x2 r+&& t-y2 && y2 b+d))) {
					                if(inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.elementevent, $.extend(inst._uiHash(), { snapIteminst.snapElements[i].item
						})));
					                inst.snapElements[i].snapping false;
					                continue;
					            }
				            if(o.snapMode != 'inner') {
					                var ts Math.abs(y2) <= d;
					                var bs Math.abs(y1) <= d;
					                var ls Math.abs(x2) <= d;
					                var rs Math.abs(x1) <= d;
					                if(tsui.position.top inst._convertPositionTo("relative", { topinst.helperProportions.heightleft0
						}).top inst.margins.top;
					                if(bsui.position.top inst._convertPositionTo("relative", { topbleft0
						}).top inst.margins.top;
					                if(lsui.position.left inst._convertPositionTo("relative", { top0leftinst.helperProportions.width
						}).left inst.margins.left;
					                if(rsui.position.left inst._convertPositionTo("relative", { top0leftr
						}).left inst.margins.left;
					            }
				            var first = (ts || bs || ls || rs);
				            if(o.snapMode != 'outer') {
					                var ts Math.abs(y1) <= d;
					                var bs Math.abs(y2) <= d;
					                var ls Math.abs(x1) <= d;
					                var rs Math.abs(x2) <= d;
					                if(tsui.position.top inst._convertPositionTo("relative", { toptleft0
						}).top inst.margins.top;
					                if(bsui.position.top inst._convertPositionTo("relative", { topinst.helperProportions.heightleft0
						}).top inst.margins.top;
					                if(lsui.position.left inst._convertPositionTo("relative", { top0leftl
						}).left inst.margins.left;
					                if(rsui.position.left inst._convertPositionTo("relative", { top0leftinst.helperProportions.width
						}).left inst.margins.left;
					            }
				            if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
				                (inst.options.snap.snap && inst.options.snap.snap.call(inst.elementevent, $.extend(inst._uiHash(), { snapIteminst.snapElements[i].item
					})));
				            inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
				        };
			    }
		});
	$.ui.plugin.add("draggable""stack", {
		    start: function(eventui) {
			        var = $(this).data("draggable").options;
			        var group = $.makeArray($(o.stack)).sort(function(a,b) {
				            return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
				        });
			        if (!group.length) {
				return;
				}
			        var min parseInt(group[0].style.zIndex) || 0;
			        $(group).each(function(i) {
				            this.style.zIndex min i;
				        });
			        this[0].style.zIndex min group.length;
			    }
		});
	$.ui.plugin.add("draggable""zIndex", {
		    start: function(eventui) {
			        var = $(ui.helper), = $(this).data("draggable").options;
			        if(t.css("zIndex")) o._zIndex t.css("zIndex");
			        t.css('zIndex'o.zIndex);
			    },
		    stop: function(eventui) {
			        var = $(this).data("draggable").options;
			        if(o._zIndex) $(ui.helper).css('zIndex'o._zIndex);
			    }
		});
	})(jQuery);





PHP Demo Source Code Index