| Server IP : 104.21.112.1 / Your IP : 216.73.216.145 Web Server : LiteSpeed System : Linux premium151.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64 User : tempvsty ( 647) PHP Version : 8.0.30 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /home/tempvsty/peekmysite.com/wp-content/plugins/motopress-content-editor/jquery/event/drag/ |
Upload File : |
steal('jquery/event', 'jquery/lang/vector', 'jquery/event/livehack',function( $ ) {
//modify live
//steal the live handler ....
var bind = function( object, method ) {
var args = Array.prototype.slice.call(arguments, 2);
return function() {
var args2 = [this].concat(args, $.makeArray(arguments));
return method.apply(object, args2);
};
},
event = $.event,
clearSelection = window.getSelection ? function(){
window.getSelection().removeAllRanges()
} : function(){};
// var handle = event.handle; //unused
/**
* @class jQuery.Drag
* @parent specialevents
* @plugin jquery/event/drag
* @download http://jmvcsite.heroku.com/pluginify?plugins[]=jquery/event/drag/drag.js
* @test jquery/event/drag/qunit.html
* Provides drag events as a special events to jQuery.
* A jQuery.Drag instance is created on a drag and passed
* as a parameter to the drag event callbacks. By calling
* methods on the drag event, you can alter the drag's
* behavior.
* ## Drag Events
*
* The drag plugin allows you to listen to the following events:
*
* <ul>
* <li><code>dragdown</code> - the mouse cursor is pressed down</li>
* <li><code>draginit</code> - the drag motion is started</li>
* <li><code>dragmove</code> - the drag is moved</li>
* <li><code>dragend</code> - the drag has ended</li>
* <li><code>dragover</code> - the drag is over a drop point</li>
* <li><code>dragout</code> - the drag moved out of a drop point</li>
* </ul>
*
* Just by binding or delegating on one of these events, you make
* the element dragable. You can change the behavior of the drag
* by calling methods on the drag object passed to the callback.
*
* ### Example
*
* Here's a quick example:
*
* //makes the drag vertical
* $(".drags").delegate("draginit", function(event, drag){
* drag.vertical();
* })
* //gets the position of the drag and uses that to set the width
* //of an element
* $(".resize").delegate("dragmove",function(event, drag){
* $(this).width(drag.position.left() - $(this).offset().left )
* })
*
* ## Drag Object
*
* <p>The drag object is passed after the event to drag
* event callback functions. By calling methods
* and changing the properties of the drag object,
* you can alter how the drag behaves.
* </p>
* <p>The drag properties and methods:</p>
* <ul>
* <li><code>[jQuery.Drag.prototype.cancel cancel]</code> - stops the drag motion from happening</li>
* <li><code>[jQuery.Drag.prototype.ghost ghost]</code> - copys the draggable and drags the cloned element</li>
* <li><code>[jQuery.Drag.prototype.horizontal horizontal]</code> - limits the scroll to horizontal movement</li>
* <li><code>[jQuery.Drag.prototype.location location]</code> - where the drag should be on the screen</li>
* <li><code>[jQuery.Drag.prototype.mouseElementPosition mouseElementPosition]</code> - where the mouse should be on the drag</li>
* <li><code>[jQuery.Drag.prototype.only only]</code> - only have drags, no drops</li>
* <li><code>[jQuery.Drag.prototype.representative representative]</code> - move another element in place of this element</li>
* <li><code>[jQuery.Drag.prototype.revert revert]</code> - animate the drag back to its position</li>
* <li><code>[jQuery.Drag.prototype.vertical vertical]</code> - limit the drag to vertical movement</li>
* <li><code>[jQuery.Drag.prototype.limit limit]</code> - limit the drag within an element (*limit plugin)</li>
* <li><code>[jQuery.Drag.prototype.scrolls scrolls]</code> - scroll scrollable areas when dragging near their boundries (*scroll plugin)</li>
* </ul>
* <h2>Demo</h2>
* Now lets see some examples:
* @demo jquery/event/drag/drag.html 1000
* @constructor
* The constructor is never called directly.
*/
$.Drag = function() {};
/**
* @Static
*/
$.extend($.Drag, {
lowerName: "drag",
current: null,
distance: 0,
/**
* Called when someone mouses down on a draggable object.
* Gathers all callback functions and creates a new Draggable.
* @hide
*/
mousedown: function( ev, element ) {
var isLeftButton = ev.button === 0 || ev.button == 1;
if (!isLeftButton || this.current ) {
return;
} //only allows 1 drag at a time, but in future could allow more
//ev.preventDefault();
//create Drag
var drag = new $.Drag(),
delegate = ev.delegateTarget || element,
selector = ev.handleObj.selector,
self = this;
this.current = drag;
drag.setup({
element: element,
delegate: ev.delegateTarget || element,
selector: ev.handleObj.selector,
moved: false,
_distance: this.distance,
callbacks: {
dragdown: event.find(delegate, ["dragdown"], selector),
draginit: event.find(delegate, ["draginit"], selector),
dragover: event.find(delegate, ["dragover"], selector),
dragmove: event.find(delegate, ["dragmove"], selector),
dragout: event.find(delegate, ["dragout"], selector),
dragend: event.find(delegate, ["dragend"], selector)
},
destroyed: function() {
self.current = null;
}
}, ev);
}
});
/**
* @Prototype
*/
$.extend($.Drag.prototype, {
setup: function( options, ev ) {
$.extend(this, options);
this.element = $(this.element);
this.event = ev;
this.moved = false;
this.allowOtherDrags = false;
var mousemove = bind(this, this.mousemove),
mouseup = bind(this, this.mouseup);
this._mousemove = mousemove;
this._mouseup = mouseup;
this._distance = options.distance ? options.distance : 0;
this.mouseStartPosition = ev.vector(); //where the mouse is located
$(document).bind('mousemove', mousemove);
$(document).bind('mouseup', mouseup);
if (!this.callEvents('down', this.element, ev) ) {
this.noSelection(this.delegate);
//this is for firefox
clearSelection();
}
},
/**
* Unbinds listeners and allows other drags ...
* @hide
*/
destroy: function() {
$(document).unbind('mousemove', this._mousemove);
$(document).unbind('mouseup', this._mouseup);
if (!this.moved ) {
this.event = this.element = null;
}
this.selection(this.delegate);
this.destroyed();
},
mousemove: function( docEl, ev ) {
if (!this.moved ) {
var dist = Math.sqrt( Math.pow( ev.pageX - this.event.pageX, 2 ) + Math.pow( ev.pageY - this.event.pageY, 2 ));
if(dist < this._distance){
return false;
}
this.init(this.element, ev);
this.moved = true;
}
var pointer = ev.vector();
if ( this._start_position && this._start_position.equals(pointer) ) {
return;
}
//e.preventDefault();
this.draw(pointer, ev);
},
mouseup: function( docEl, event ) {
//if there is a current, we should call its dragstop
if ( this.moved ) {
this.end(event);
}
this.destroy();
},
/**
* noSelection method turns off text selection during a drag event.
* This method is called by default unless a event is listening to the 'dragdown' event.
*
* ## Example
*
* $('div.drag').bind('dragdown', function(elm,event,drag){
* drag.noSelection();
* });
*
* @param [elm] an element to prevent selection on. Defaults to the dragable element.
*/
noSelection: function(elm) {
elm = elm || this.delegate
document.documentElement.onselectstart = function() {
return false;
};
document.documentElement.unselectable = "on";
this.selectionDisabled = (this.selectionDisabled ? this.selectionDisabled.add(elm) : $(elm));
this.selectionDisabled.css('-moz-user-select', '-moz-none');
},
/**
* selection method turns on text selection that was previously turned off during the drag event.
* This method is called by default in 'destroy' unless a event is listening to the 'dragdown' event.
*
* ## Example
*
* $('div.drag').bind('dragdown', function(elm,event,drag){
* drag.noSelection();
* });
*/
selection: function(elm) {
if(this.selectionDisabled){
document.documentElement.onselectstart = function() {};
document.documentElement.unselectable = "off";
this.selectionDisabled.css('-moz-user-select', '');
}
},
init: function( element, event ) {
element = $(element);
var startElement = (this.movingElement = (this.element = $(element))); //the element that has been clicked on
//if a mousemove has come after the click
this._cancelled = false; //if the drag has been cancelled
this.event = event;
/**
* @attribute mouseElementPosition
* The position of start of the cursor on the element
*/
this.mouseElementPosition = this.mouseStartPosition.minus(this.element.offsetv()); //where the mouse is on the Element
//this.callStart(element, event);
this.callEvents('init', element, event);
//Check what they have set and respond accordingly
// if they canceled
if ( this._cancelled === true ) {
return;
}
//if they set something else as the element
this.startPosition = startElement != this.movingElement ? this.movingElement.offsetv() : this.currentDelta();
this.makePositioned(this.movingElement);
this.oldZIndex = this.movingElement.css('zIndex');
this.movingElement.css('zIndex', 1000);
if (!this._only && this.constructor.responder ) {
this.constructor.responder.compile(event, this);
}
},
makePositioned: function( that ) {
var style, pos = that.css('position');
if (!pos || pos == 'static' ) {
style = {
position: 'relative'
};
if ( window.opera ) {
style.top = '0px';
style.left = '0px';
}
that.css(style);
}
},
callEvents: function( type, element, event, drop ) {
var i, cbs = this.callbacks[this.constructor.lowerName + type];
for ( i = 0; i < cbs.length; i++ ) {
cbs[i].call(element, event, this, drop);
}
return cbs.length;
},
/**
* Returns the position of the movingElement by taking its top and left.
* @hide
* @return {Vector}
*/
currentDelta: function() {
return new $.Vector(parseInt(this.movingElement.css('left'), 10) || 0, parseInt(this.movingElement.css('top'), 10) || 0);
},
//draws the position of the dragmove object
draw: function( pointer, event ) {
// only drag if we haven't been cancelled;
if ( this._cancelled ) {
return;
}
clearSelection();
/**
* @attribute location
* The location of where the element should be in the page. This
* takes into account the start position of the cursor on the element.
*
* If the drag is going to be moved to an unacceptable location, you can call preventDefault in
* dragmove to prevent it from being moved there.
*
* $('.mover').bind("dragmove", function(ev, drag){
* if(drag.location.top() < 100){
* ev.preventDefault()
* }
* });
*
* You can also set the location to where it should be on the page.
*/
this.location = pointer.minus(this.mouseElementPosition); // the offset between the mouse pointer and the representative that the user asked for
// position = mouse - (dragOffset - dragTopLeft) - mousePosition
// call move events
this.move(event);
if ( this._cancelled ) {
return;
}
if (!event.isDefaultPrevented() ) {
this.position(this.location);
}
//fill in
if (!this._only && this.constructor.responder ) {
this.constructor.responder.show(pointer, this, event);
}
},
/**
* Sets the position of this drag.
*
* The limit and scroll plugins
* overwrite this to make sure the drag follows a particular path.
*
* @param {jQuery.Vector} newOffsetv the position of the element (not the mouse)
*/
position: function( newOffsetv ) { //should draw it on the page
var style, dragged_element_css_offset = this.currentDelta(),
// the drag element's current left + top css attributes
dragged_element_position_vector = // the vector between the movingElement's page and css positions
this.movingElement.offsetv().minus(dragged_element_css_offset); // this can be thought of as the original offset
this.required_css_position = newOffsetv.minus(dragged_element_position_vector);
this.offsetv = newOffsetv;
//dragged_element vector can probably be cached.
style = this.movingElement[0].style;
if (!this._cancelled && !this._horizontal ) {
style.top = this.required_css_position.top() + "px";
}
if (!this._cancelled && !this._vertical ) {
style.left = this.required_css_position.left() + "px";
}
},
move: function( event ) {
this.callEvents('move', this.element, event);
},
over: function( event, drop ) {
this.callEvents('over', this.element, event, drop);
},
out: function( event, drop ) {
this.callEvents('out', this.element, event, drop);
},
/**
* Called on drag up
* @hide
* @param {Event} event a mouseup event signalling drag/drop has completed
*/
end: function( event ) {
if ( this._cancelled ) {
return;
}
if (!this._only && this.constructor.responder ) {
this.constructor.responder.end(event, this);
}
this.callEvents('end', this.element, event);
if ( this._revert ) {
var self = this;
this.movingElement.animate({
top: this.startPosition.top() + "px",
left: this.startPosition.left() + "px"
}, function() {
self.cleanup.apply(self, arguments);
});
}
else {
this.cleanup();
}
this.event = null;
},
/**
* Cleans up drag element after drag drop.
* @hide
*/
cleanup: function() {
this.movingElement.css({
zIndex: this.oldZIndex
});
if ( this.movingElement[0] !== this.element[0] &&
!this.movingElement.has(this.element[0]).length &&
!this.element.has(this.movingElement[0]).length ) {
this.movingElement.css({
display: 'none'
});
}
if ( this._removeMovingElement ) {
this.movingElement.remove();
}
this.movingElement = this.element = this.event = null;
},
/**
* Stops drag drop from running.
*/
cancel: function() {
this._cancelled = true;
//this.end(this.event);
if (!this._only && this.constructor.responder ) {
this.constructor.responder.clear(this.event.vector(), this, this.event);
}
this.destroy();
},
/**
* Clones the element and uses it as the moving element.
* @return {jQuery.fn} the ghost
*/
ghost: function( loc ) {
// create a ghost by cloning the source element and attach the clone to the dom after the source element
var ghost = this.movingElement.clone().css('position', 'absolute');
(loc ? $(loc) : this.movingElement).after(ghost);
ghost.width(this.movingElement.width()).height(this.movingElement.height());
// put the ghost in the right location ...
ghost.offset(this.movingElement.offset())
// store the original element and make the ghost the dragged element
this.movingElement = ghost;
this.noSelection(ghost)
this._removeMovingElement = true;
return ghost;
},
/**
* Use a representative element, instead of the movingElement.
* @param {HTMLElement} element the element you want to actually drag
* @param {Number} offsetX the x position where you want your mouse on the object
* @param {Number} offsetY the y position where you want your mouse on the object
*/
representative: function( element, offsetX, offsetY ) {
this._offsetX = offsetX || 0;
this._offsetY = offsetY || 0;
var p = this.mouseStartPosition;
this.movingElement = $(element);
this.movingElement.css({
top: (p.y() - this._offsetY) + "px",
left: (p.x() - this._offsetX) + "px",
display: 'block',
position: 'absolute'
}).show();
this.noSelection(this.movingElement)
this.mouseElementPosition = new $.Vector(this._offsetX, this._offsetY);
},
/**
* Makes the movingElement go back to its original position after drop.
* @codestart
* ".handle dragend" : function( el, ev, drag ) {
* drag.revert()
* }
* @codeend
* @param {Boolean} [val] optional, set to false if you don't want to revert.
*/
revert: function( val ) {
this._revert = val === undefined ? true : val;
return this;
},
/**
* Isolates the drag to vertical movement.
*/
vertical: function() {
this._vertical = true;
return this;
},
/**
* Isolates the drag to horizontal movement.
*/
horizontal: function() {
this._horizontal = true;
return true;
},
/**
* Respondables will not be alerted to this drag.
*/
only: function( only ) {
return (this._only = (only === undefined ? true : only));
},
/**
* Sets the distance from the mouse before the item begins dragging.
* @param {Number} val
*/
distance:function(val){
if(val !== undefined){
this._distance = val;
return this;
}else{
return this._distance
}
}
});
/**
* @add jQuery.event.special
*/
event.setupHelper([
/**
* @attribute dragdown
* <p>Listens for when a drag movement has started on a mousedown.
* If you listen to this, the mousedown's default event (preventing
* text selection) is not prevented. You are responsible for calling it
* if you want it (you probably do). </p>
* <p><b>Why might you not want it?</b></p>
* <p>You might want it if you want to allow text selection on element
* within the drag element. Typically these are input elements.</p>
* <p>Drag events are covered in more detail in [jQuery.Drag].</p>
* @codestart
* $(".handles").delegate("dragdown", function(ev, drag){})
* @codeend
*/
'dragdown',
/**
* @attribute draginit
* Called when the drag starts.
* <p>Drag events are covered in more detail in [jQuery.Drag].</p>
*/
'draginit',
/**
* @attribute dragover
* Called when the drag is over a drop.
* <p>Drag events are covered in more detail in [jQuery.Drag].</p>
*/
'dragover',
/**
* @attribute dragmove
* Called when the drag is moved.
* <p>Drag events are covered in more detail in [jQuery.Drag].</p>
*/
'dragmove',
/**
* @attribute dragout
* When the drag leaves a drop point.
* <p>Drag events are covered in more detail in [jQuery.Drag].</p>
*/
'dragout',
/**
* @attribute dragend
* Called when the drag is done.
* <p>Drag events are covered in more detail in [jQuery.Drag].</p>
*/
'dragend'], "mousedown", function( e ) {
$.Drag.mousedown.call($.Drag, e, this);
});
});