Texte vergleichen

Finden Sie den Unterschied zwischen zwei Textdateien

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Onlinewerkzeuge

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Comparing sensitive data, confidential files or internal emails?

Most legal and privacy policies prohibit uploading sensitive data online. Diffchecker Desktop ensures your confidential information never leaves your computer. Work offline and compare documents securely.

Download Diffchecker Desktop Learn more

drag diff

Created 7 months agoDiff never expires

15 removals

651 lines

34 additions

670 lines

var sig = "obj, boundary, axis, overCursor, dragCursor, all, swipe, localBoundary, onTop, surround, slide, slideFactor, slideSnap, slideSnapDamp, reg, removeTweens, startBounds, rect, currentTarget, offStage, immediateBoundary, singleTouch";

var duo; if (duo = zob(zim.drag, arguments, sig)) return duo;

z_d("31");

if (zot(obj) || !obj.on) return;

var DA = zim.DRAGALL;

if (WW.DRAGALL != null) DA = WW.DRAGALL;

if (zot(all) && zot(currentTarget)) all = DA;

if (zot(all) && zot(currentTarget)) currentTarget = false;

else if (!zot(all)) currentTarget = all;

else if (zot(currentTarget)) currentTarget = false;

if (obj.type == "Tag" || obj.type == "TextArea" || obj.type == "Loader") currentTarget = true;

if (boundary && boundary.getBounds && (obj.type=="Container" || obj.type=="Tile") && obj.mouseChildren==true && !all) {

// recall drags individually on objects

var args = Array.prototype.slice.call(arguments);

args[4] = true; // all

setTimeout(function () {

obj.loop(function (o) {

args[0] = o; // replace container with each child

zim.drag.apply(null, args);

});

}, immediateBoundary?0:50);

return obj;

}

if (zot(axis) || axis=="all" || (axis!="horizontal" && axis!="vertical")) axis = "both";

if (obj.zimDown) obj.noDrag(); // clear any previous drags

if (obj.cur) obj.cur(zot(overCursor) ? "pointer" : overCursor);

else obj.cursor = zot(overCursor) ? "pointer" : overCursor;

if (zot(swipe)) swipe = false;

if (zot(localBoundary)) localBoundary = false;

if (zot(onTop)) onTop = true;

if (zot(surround)) surround = false;

if (zot(slide)) slide = false;

if (zot(slideFactor)) slideFactor = .9;

if (zot(slideSnap)) slideSnap = true;

var snapOptions = ["horizontal", "vertical", "auto"];

if (slideSnap !== true && snapOptions.indexOf(slideSnap) < 0) slideSnap = false;

if (slideSnap == "auto") slideSnap = true;

if (zot(slideSnapDamp)) slideSnapDamp = .1;

if (zot(reg)) reg = false;

if (zot(removeTweens)) removeTweens = true;

if (zot(startBounds)) startBounds = true;

if (zot(boundary) && !zot(rect)) boundary = rect;

if (zot(singleTouch)) singleTouch = false;

obj.dragPaused = false;

if (slide) {

// set up damping for slide and variables used to predict future locations

// these get populated in a setTimeout in the init function

var dampX;

var dampY;

var back; // how many ticks ago to estimate trajectory

var lastCount;

var backX;

var backY;

var backT;

var upX; // mouse up translated to local

var upY;

var upT;

var objUpX; // drag object x when mouse up

var objUpY;

var lastBackX; // used to calculate trajectory

var lastBackY;

var lastBackT;

var lastX; // used to see if sliding object is still moving

var lastY;

var hasMoved;

var tick = WW.M?20:10;

var vX;

var vY;

var dX;

var dY;

var bX = false;

var bY = false;

var vRange = 50;

} else {

obj.zimDragTicker = function(){};

}

obj._draggable = true;

zim.setSwipe(obj, swipe);

obj.zimBoundary = boundary;

obj.zimlocalBoundary = localBoundary;

obj.circleBounds = boundary&&boundary.type=="Circle"?boundary.radius:false;

obj.downCheck = false;

var moveCheck = false;

var diffX,diffY,r,rLocal,point;

// initialize happens possibly before added to stage - only checking for parent

obj.zimAdded = obj.on("added", initializeObject, null, true); // if not added to display list

obj.zimRemoved = obj.on("removed", unInitializeObject, null, true);

if (obj.parent) initializeObject();

function initializeObject() {

obj.off("added", obj.zimAdded);

boundary = obj.zimBoundary;

if (boundary && boundary.getBounds && boundary.type != "Blob") {

obj.zimlocalBoundary = false;

if (boundary.type != "Stage" && boundary.type != "StageGL") boundary = boundary.boundsToGlobal();

else boundary = new zim.Boundary(0,0,boundary.width,boundary.height);

if (!surround) {

var bounds = obj.boundsToGlobal();

point = obj.localToGlobal(obj.regX,obj.regY);

var tl = new zim.Point(point.x-bounds.x, point.y-bounds.y);

var bw = obj.borderWidth?obj.borderWidth:0;

boundary.x += tl.x+bw/2;

boundary.y += tl.y+bw/2;

boundary.width -= bounds.width+bw;

boundary.height -= bounds.height+bw;

}

obj.zimBoundary = boundary;

}

// check position right away if there is a bounding box

// there is no mousedown so set the diffX and diffY to 0

diffX = 0; diffY = 0;

// positionObject() is used as well in the dragmove function

// where it expects a global x and y

// so convert obj.x and obj.y positions inside its parent to global:

if (obj.zimBoundary && obj.zimBoundary.type != "Blob") {

if (localBoundary) {

r = zim.boundsToGlobal(obj.parent, obj.zimBoundary);

if (surround) rLocal = obj.zimBoundary;

} else {

r = obj.zimBoundary;

if (surround) rLocal = zim.boundsToGlobal(obj.parent, obj.zimBoundary, true); // flips to global to local

}

if (r && startBounds) {

point = obj.parent.localToGlobal(obj.x, obj.y);

positionObject(obj, point.x, point.y);

}

if (slide) {

// little delay to in case position is set directly after drag is called

setTimeout(function() {

// set up damping for slide and variables used to predict future locations

if (slide && slideSnap) {

dampX = new zim.Damp(null, slideSnapDamp);

dampY = new zim.Damp(null, slideSnapDamp);

}

obj.zimDragImmediate = function(x, y) {

objUpX = x;

objUpY = y;

vX = vY = 0;

dX = dY = 0;

upX = lastBackX = upY = lastBackY = upT = lastBackT = 0;

if (slide && slideSnap) {

if (!zot(x)) dampX.immediate(x);

if (!zot(y)) dampY.immediate(y);

}

};

back = 3; // how many ticks ago to estimate trajectory

lastCount = 0;

backX = [];

backY = [];

backT = [];

upX = obj.x; // mouse up translated to local

upY = obj.y;

objUpX = obj.x; // drag object x when mouse up

objUpY = obj.y;

lastBackX = obj.x; // used to calculate trajectory

lastBackY = obj.y;

lastBackT = Date.now();

lastX = -10000; // used to see if sliding object is still moving

lastY = -10000;

obj.zimDragMoving = true;

setUpSlide();

}, 50);

}

if (!zot(obj.zimMaskDynamic)) obj.zimMaskApply(); // set mask set by zimMask to dynamic

}

function unInitializeObject() {

if (obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker);

}

var dragObject;

var stage;

obj.pointers = {};

var stCheck = false;

obj.zimDown = obj.on("mousedown", function(e) {

if (!obj.stage || obj.dragPaused) return;

if (singleTouch && stCheck) return; // breaking if coming back from iframe until next mousedown

if (singleTouch && stCheck) {

e.preventDefault();

e.stopImmediatePropagation();

return;

}; // breaking if coming back from iframe until next mousedown

// obj.zimMove = obj.on("pressmove", obj.zimMove); // for some reason causing squiggle drag problems

stCheck = true;

stage = obj.stage;

if (!obj.zmu) obj.zmu = stage.frame.on("mouseupplus", function(e) {

if (obj.downCheck) {

if (!slide) obj.downCheck = false;

doUp(e, true); // true for cancel slide

}

});

obj.dragMouseX = Math.round(e.stageX/zim.scaX)+stage.x;

obj.dragMouseY = Math.round(e.stageY/zim.scaY)+stage.y;

var id = "id"+Math.abs(e.pointerID+1);

obj.pointers[id] = true; // keep track of multitouch to keep object ticker alive

// e.stageX and e.stageY are global

// e.target.x and e.target.y are relative to e.target's parent

// bring stageX and stageY into the parent's frame of reference

// could use e.localX and e.localY but might be dragging container or contents

dragObject = (currentTarget)?e.currentTarget:e.target;

if (obj.zimBoundary && !dragObject.getBounds()) {zogy("zim.drag() - drag object needs bounds set"); return;}

obj.downCheck = true;

obj.stage.mouseMoveOutside = true;

if (!zim.Ticker.has(obj.zimDragTicker)) zim.Ticker.add(obj.zimDragTicker, obj.stage);

if (removeTweens && obj.zimTweens) {

for (var tw in obj.zimTweens) {

var ao = obj.zimTweens[tw];

if (ao.zimObj && (ao.zimObj.x!=null||ao.zimObj.y!=null)) {

obj.stopAnimate(tw);

}

if (!dragObject.parent) return;

if (onTop) {

var nc = dragObject.parent.numChildren-1;

if (dragObject.parent.getChildAt(nc).type=="Keyboard") nc--;

dragObject.parent.setChildIndex(dragObject,nc);

if (dragObject.ZIMoutlineShape) dragObject.outline();

}

if (dragObject.parent == obj.stage) point = new zim.Point(e.stageX/zim.scaX, e.stageY/zim.scaY);

else point = dragObject.parent.globalToLocal(e.stageX/zim.scaX, e.stageY/zim.scaY);

if (reg) {

dragObject.x = point.x;

dragObject.y = point.y;

}

diffX = point.x - dragObject.x;

diffY = point.y - dragObject.y;

r = null;

if (obj.zimBoundary) {

if (localBoundary) {

r = zim.boundsToGlobal(dragObject.parent, obj.zimBoundary);

if (surround) rLocal = obj.zimBoundary;

} else {

r = obj.zimBoundary;

if (surround) rLocal = zim.boundsToGlobal(dragObject.parent, obj.zimBoundary, true); // true flips to global to local

}

// just a quick way to set a default cursor or use the cursor sent in

if (obj.cur) obj.cur(zot(dragCursor)?"pointer":dragCursor);

else obj.cursor = zot(dragCursor)?"pointer":dragCursor;

// extra slide settings to project where the object will slide to

if (slide) {

obj.slideStartX = obj.x;

obj.slideStartY = obj.y;

hasMoved = obj.zimDragMoving; // just in case clicking while it is animating back to position

lastCount = 0;

backX = [point.x];

backY = [point.y];

backT = [Date.now()];

lastX = -10000; // reset

lastY = -10000;

obj.zimDragMoving = true;

}

// extra pen drag

if (obj.type == "Pen") {

obj.zimDragCheck = true;

moveCheck = false;

}

}, true);

obj.zimMove = obj.on("pressmove", function(e) {

if (singleTouch && !obj.pointers["id"+Math.abs(e.pointerID+1)]) return;

if (singleTouch && !obj.pointers["id"+Math.abs(e.pointerID+1)]) {

if (!obj.downCheck || obj.dragPaused) return;

e.preventDefault();

e.stopImmediatePropagation();

return;

};

if (!obj.downCheck || obj.dragPaused) {

e.preventDefault();

e.stopImmediatePropagation();

return;

};

var x = (offStage?e.rawX:e.stageX)/zim.scaX+stage.x;

var y = (offStage?e.rawY:e.stageY)/zim.scaY+stage.y;

obj.dragMouseX = Math.round(x);

obj.dragMouseY = Math.round(y);

positionObject(dragObject, x, y);

if (dragObject.ZIMoutlineShape) dragObject.outline();

if (obj.type == "Pen" && !moveCheck && obj.drawing) moveCheck = true;

else if (obj.type == "Tag" || obj.type == "TextArea" || obj.type == "Loader") obj.resize();

}, true);

// obj.off("pressmove",obj.zimMove); // for some reason causing squiggle drag problems

function positionObject(o, x, y) {

var diffX_o = diffX;

var diffY_o = diffY;

if (zot(o)) o = (dragObject) ? dragObject : obj; // so zim.dragBoundary can use this

// x and y are the desired global positions for the object o

// checkBounds returns the same values if there are no bounds

// and returns values inside the bounds if there are bounds set

// or returns a position so that object o surrounds the bounds if surround is true

// firstly, convert the global x and y to a point relative to the object's parent

if (!o.parent) return;

// if (!o.stage) return;

// var noXY = false;

if (zot(x) || zot(y)) {

// noXY = true;

// so zim.dragBoundary can use this to position on change

// it may be we are resizing before we even drag at all

// so we need to establish variables that would have been made on drag events

var p = o.parent.localToGlobal(o.x, o.y);

diffX = diffY = 0;

if (obj.zimBoundary) {

if (localBoundary) {

r = zim.boundsToGlobal(o.parent, obj.zimBoundary);

if (surround) rLocal = o.zimBoundary;

} else {

r = obj.zimBoundary;

if (surround) rLocal = zim.boundsToGlobal(o.parent, obj.zimBoundary, true); // flips to global to local

}

x = p.x;

y = p.y;

if (slide) {

objUpX = o.x;

objUpY = o.y;

dragObject = o;

// if (dampX) dampX.immediate(objUpX);

// if (dampY) dampY.immediate(objUpY);

}

// TODO only need this if boundary - so try and test for that first...

var point;

if (stage && stage.type) point = o.parent.globalToLocal(x, y);

// case where createjs stage - does not have adjusted globalToLocal

else point = o.parent.globalToLocal(x*zim.scaX, y*zim.scaY);

var mX = axis=="both" || axis=="horizontal";

var mY = axis=="both" || axis=="vertical";

var checkedPoint;

if (slide && slideSnap) {

if (slideSnap == "vertical") {

checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);

if (mX) o.x = checkedPoint.x;

if (mY) o.y = point.y-diffY;

} else if (slideSnap == "horizontal") {

checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);

if (mX) o.x = point.x-diffX;

if (mY) o.y = checkedPoint.y;

} else {

if (mX) o.x = point.x-diffX;

if (mY) o.y = point.y-diffY;

}

} else {

checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);

// now set the object's x and y to the resulting checked local point

if (mX) o.x = checkedPoint.x;

if (mY) o.y = checkedPoint.y;

}

if (slide && !hasMoved && (o.slideStartX != o.x || o.slideStartY != o.y)) hasMoved = true;

if (o.downCheck) {

diffX = diffX_o;

diffY = diffY_o;

}

// if (noXY) {

// obj.downCheck = true;

// doUp({pointers:[]});

// }

}

obj.zimPosition = positionObject;

obj.zimUp = obj.on("pressup", function(e){doUp(e);}, true);

function doUp(e, outsideUp) {

// if (obj.zimMove) obj.off("pressmove", obj.zimMove); // for some reason causing squiggle drag problems

if (singleTouch && !outsideUp && !obj.pointers["id"+Math.abs(e.pointerID+1)]) {

if (singleTouch && !outsideUp && !obj.pointers["id"+Math.abs(e.pointerID+1)]) return;

e.preventDefault();

e.stopImmediatePropagation();

return;

};

stCheck = false;

var id = "id"+Math.abs((!zot(e.pointerID)?e.pointerID:0)+1); // avoiding NaN but not sure if correct ZIM 015

delete obj.pointers[id];

if (!obj.downCheck || obj.dragPaused) return;

if (!obj.downCheck || obj.dragPaused) {

e.preventDefault();

e.stopImmediatePropagation();

return;

};

if (obj.cur) obj.cur(zot(overCursor)?"pointer":overCursor);

else obj.cursor = zot(overCursor)?"pointer":overCursor;

if (e.stageX == null) return; // added for TextureActive drag in 2D view

if (slide) {

dragObject.dispatchEvent("slidestart");

if (dragObject.parent) {

var x = offStage?e.rawX:e.stageX;

var y = offStage?e.rawY:e.stageY;

point = dragObject.parent.globalToLocal(x/zim.scaX, y/zim.scaY);

} else {

point = new zim.Point(0,0);

}

// Added ZIM 014 to adjust for velocity effect

upX = point.x;

upY = point.y;

upT = Date.now();

// Added ZIM 015 if mouseuplus triggers first (TextureActive) then there is no event object

if (isNaN(upX)) upX = -1000;

if (isNaN(upY)) upY = -1000;

dX = upX-lastBackX;

dY = upY-lastBackY;

var t = upT-lastBackT;

vX = zim.constrain(dX*tick/t, -vRange, vRange);

vY = zim.constrain(dY*tick/t, -vRange, vRange);

bX = false; // for damping on slideSnap

bY = false;

// end add

obj.downCheck = false;

objUpX = dragObject.x;

objUpY = dragObject.y;

if (outsideUp) {

lastBackX = upX = 0;

lastBackY = upY = 0;

lastBackT = upT = 0;

}

// if (dampX) dampX.immediate(50);

// if (dampY) dampY.immediate(0);

} else {

obj.downCheck = false; // added ZIM NFT 01

var pointerCount = 0;

for (var o in obj.pointers) {

pointerCount++;

}

if (pointerCount == 0) zim.Ticker.remove(obj.zimDragTicker);

// extra pen drag

if (obj.type == "Pen") {

obj.zimDragCheck = false;

if (moveCheck && obj.drawing) obj.stopCheck(); // added drawing check Cat 04

// if (moveCheck) obj.stopCheck();

}

if (obj.stage) obj.stage.update();

}

// the bounds check for registration inside the bounds

// or if surround is set for the whole object staying outside the bounds

function checkBounds(o, x, y) {

if (!o.parent) return {x:x,y:y};

if (r) {

if (surround) {

var w = o.getBounds().width;

var h = o.getBounds().height;

var bx = o.getBounds().x;

var by = o.getBounds().y;

if (w < rLocal.width) {

// put half way between

x = rLocal.x + (rLocal.width - w) / 2 + (o.regX-bx);

} else {

if (x - (o.regX-bx) > rLocal.x) {

x = rLocal.x + (o.regX-bx);

}

if (x - (o.regX-bx) + w < rLocal.x + rLocal.width) {

x = rLocal.x + rLocal.width + (o.regX-bx) - w;

}

if (o.height < rLocal.height) {

// put half way between

y = rLocal.y + (rLocal.height - h) / 2 + (o.regY-by);

} else {

if (y - (o.regY-by) > rLocal.y) {

y = rLocal.y + (o.regY-by);

}

if (y - (o.regY-by) + h < rLocal.y + rLocal.height) {

y = rLocal.y + rLocal.height + (o.regY-by) - h;

}

} else {

if (r.type=="Blob") {

if (r.shape.hitTestPoint(x,y)) return {x:x,y:y};

else return {x:obj.x,y:obj.y};

} else {

// convert the desired drag position to a global point

// note that we want the position of the object in its parent

// so we use the parent as the local frame

point = o.parent.localToGlobal(x,y);

// r is the bounds rectangle on the global stage

// r is set during mousedown to allow for global scaling when in localBoundary mode

// if you scale in localBoundary==false mode, you will need to reset bounds with dragBoundary()

if (obj.circleBounds) {

var midX = r.x+r.width/2;

var midY = r.y+r.height/2;

var rad = obj.circleBounds;

if (zim.dist(midX, midY, point.x, point.y) <= rad) {

x = point.x;

y = point.y;

} else {

var ang = zim.angle(midX, midY, point.x, point.y)*RAD;

x = midX + rad*Math.cos(ang);

y = midY + rad*Math.sin(ang);

}

} else {

x = Math.max(r.x, Math.min(r.x+r.width, point.x));

y = Math.max(r.y, Math.min(r.y+r.height, point.y));

}

// now that the point has been checked on the global scale

// convert the point back to the obj parent frame of reference

point = o.parent.globalToLocal(x, y);

x = point.x;

y = point.y;

}

return {x:x,y:y};

}

function testMove(o,x,y,desiredX,desiredY) {

if (Math.abs(o.x-lastX) < .1 && Math.abs(o.y-lastY) < .1) {

obj.zimDragMoving = false;

o.x = desiredX; // snap to final resting place

o.y = desiredY;

o.slideStartX = null;

o.slideStartY = null;

if (hasMoved) {

o.dispatchEvent("slidestop");

zim.Ticker.remove(obj.zimDragTicker);

}

// extra pen drag

if (obj.type == "Pen") {

obj.zimDragCheck = false;

if (moveCheck && obj.drawing) obj.stopCheck(); // added drawing check Cat 04

// if (moveCheck) obj.stopCheck();

}

} else {

lastX = x;

lastY = y;

}

// we store where the object was a few ticks ago and project it forward

// then damp until it stops - although the ticker keeps running and updating

// if it snaps then the object is allowed to go past the bounds and damp back

// if it is not snapping then the object stops at the bounds when it is slid

function setUpSlide() {

obj.zimDragTicker = function() {

if (zot(obj.slideStartX)) return; // don't stop other things like window scrollbar from moving object

if (!dragObject) dragObject = obj; // could be risky if intending to drag children

if (obj.downCheck) {

var point;

if (dragObject.parent) {

point = dragObject.parent.globalToLocal(obj.dragMouseX, obj.dragMouseY);

} else {

point = new zim.Point(0,0);

}

lastCount++;

backX.push(point.x);

backY.push(point.y);

backT.push(Date.now());

if (lastCount >= back) {

lastBackX = backX.shift();

lastBackY = backY.shift();

lastBackT = backT.shift();

} else {

lastBackX = backX[0];

lastBackY = backY[0];

lastBackT = backT[0];

}

} else {

if (!obj.zimDragMoving) return;

dX = vX;

dY = vY;

var desiredX;

var desiredY;

if (axis==BOTH) {

desiredX = dragObject.x + dX;

desiredY = dragObject.y + dY;

} else if (axis==HORIZONTAL) {

desiredX = dragObject.x + dX;

desiredY = dragObject.y;

} else if (axis==VERTICAL) {

desiredX = dragObject.x;

desiredY = dragObject.y + dY;

}

vX = dX*slideFactor;

vY = dY*slideFactor;

var checkedPoint;

if (r) {

checkedPoint = checkBounds(dragObject, desiredX, desiredY);

if (slideSnap===true || slideSnap == "horizontal") {

if (Math.round(desiredX) != Math.round(checkedPoint.x)) {

if (!bX) {

dampX.immediate(desiredX);

bX = true;

}

vX = 0;

desiredX = dampX.convert(checkedPoint.x);

}

if (slideSnap == "horizontal") desiredY = checkedPoint.y;

}

if (slideSnap===true || slideSnap == "vertical") {

if (Math.round(desiredY) != Math.round(checkedPoint.y)) {

if (!bY) {

bY = true;

dampY.immediate(desiredY);

vY = 0;

}

desiredY = dampY.convert(checkedPoint.y);

}

if (slideSnap == "vertical") desiredX = checkedPoint.x;

}

if (!slideSnap) {

desiredX = checkedPoint.x;

desiredY = checkedPoint.y;

}

dragObject.x = desiredX;

dragObject.y = desiredY;

testMove(dragObject,dragObject.x,dragObject.y,desiredX,desiredY);

}

return obj;

};//-31

Gespeicherten Diffs

Original text

Open file

zim.drag = function(obj, boundary, axis, overCursor, dragCursor, all, swipe, localBoundary, onTop, surround, slide, slideFactor, slideSnap, slideSnapDamp, reg, removeTweens, startBounds, rect, currentTarget, offStage, immediateBoundary, singleTouch) {
		var sig = "obj, boundary, axis, overCursor, dragCursor, all, swipe, localBoundary, onTop, surround, slide, slideFactor, slideSnap, slideSnapDamp, reg, removeTweens, startBounds, rect, currentTarget, offStage, immediateBoundary, singleTouch";
		var duo; if (duo = zob(zim.drag, arguments, sig)) return duo;
		z_d("31");

if (zot(obj) || !obj.on) return;

var DA = zim.DRAGALL;
		if (WW.DRAGALL != null) DA = WW.DRAGALL;
		if (zot(all) && zot(currentTarget)) all = DA;
		if (zot(all) && zot(currentTarget)) currentTarget = false;
		else if (!zot(all)) currentTarget = all;
		else if (zot(currentTarget)) currentTarget = false;
		if (obj.type == "Tag" || obj.type == "TextArea" || obj.type == "Loader") currentTarget = true;

if (boundary && boundary.getBounds && (obj.type=="Container" || obj.type=="Tile") && obj.mouseChildren==true && !all) {
			// recall drags individually on objects
			var args = Array.prototype.slice.call(arguments);
			args[4] = true; // all		
			setTimeout(function () {
				obj.loop(function (o) {
					args[0] = o; // replace container with each child
					zim.drag.apply(null, args);
				});
			}, immediateBoundary?0:50);								
			return obj;
		}
		if (zot(axis) || axis=="all" || (axis!="horizontal" && axis!="vertical")) axis = "both";
		if (obj.zimDown) obj.noDrag(); // clear any previous drags
		if (obj.cur) obj.cur(zot(overCursor) ? "pointer" : overCursor);
		else obj.cursor = zot(overCursor) ? "pointer" : overCursor;
		if (zot(swipe)) swipe = false;		
		if (zot(localBoundary)) localBoundary = false;
		if (zot(onTop)) onTop = true;
		if (zot(surround)) surround = false;
		if (zot(slide)) slide = false;
		if (zot(slideFactor)) slideFactor = .9;
		if (zot(slideSnap)) slideSnap = true;
		var snapOptions = ["horizontal", "vertical", "auto"];
		if (slideSnap !== true && snapOptions.indexOf(slideSnap) < 0) slideSnap = false;
		if (slideSnap == "auto") slideSnap = true;
		if (zot(slideSnapDamp)) slideSnapDamp = .1;
		if (zot(reg)) reg = false;
		if (zot(removeTweens)) removeTweens = true;
		if (zot(startBounds)) startBounds = true;
		if (zot(boundary) && !zot(rect)) boundary = rect;
		if (zot(singleTouch)) singleTouch = false;
		
		obj.dragPaused = false;
		
		if (slide) {
			// set up damping for slide and variables used to predict future locations
			// these get populated in a setTimeout in the init function

var dampX;
			var dampY;
			var back; // how many ticks ago to estimate trajectory
			var lastCount;
			var backX;
			var backY;
			var backT;
			var upX; // mouse up translated to local
			var upY;
			var upT;
			var objUpX; // drag object x when mouse up
			var objUpY;
			var lastBackX; // used to calculate trajectory
			var lastBackY;
			var lastBackT;
			var lastX; // used to see if sliding object is still moving
			var lastY;
			var hasMoved;
			var tick = WW.M?20:10; 
			var vX;
			var vY;
			var dX;
			var dY;
			var bX = false;
			var bY = false;
			var vRange = 50;

} else {
			obj.zimDragTicker = function(){};
		}

obj._draggable = true;
		zim.setSwipe(obj, swipe);
		obj.zimBoundary = boundary;
		obj.zimlocalBoundary = localBoundary;
		obj.circleBounds = boundary&&boundary.type=="Circle"?boundary.radius:false;
		obj.downCheck = false;		
		var moveCheck = false;

var diffX,diffY,r,rLocal,point;

// initialize happens possibly before added to stage - only checking for parent
		obj.zimAdded = obj.on("added", initializeObject, null, true); // if not added to display list
		obj.zimRemoved = obj.on("removed", unInitializeObject, null, true);
		if (obj.parent) initializeObject();

function unInitializeObject() {
			if (obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker);
		}

var dragObject;

var stage;
		obj.pointers = {};
		var stCheck = false;
		obj.zimDown = obj.on("mousedown", function(e) {			
			if (!obj.stage || obj.dragPaused) return;
			if (singleTouch && stCheck) return;	 // breaking if coming back from iframe until next mousedown

// obj.zimMove = obj.on("pressmove", obj.zimMove);	// for some reason causing squiggle drag problems
			
			stCheck = true;
			stage = obj.stage;
			if (!obj.zmu) obj.zmu = stage.frame.on("mouseupplus", function(e) {	
				if (obj.downCheck) {
					if (!slide) obj.downCheck = false;						
					doUp(e, true); // true for cancel slide						
				}					
			});		
			obj.dragMouseX = Math.round(e.stageX/zim.scaX)+stage.x;
			obj.dragMouseY = Math.round(e.stageY/zim.scaY)+stage.y;
			var id = "id"+Math.abs(e.pointerID+1);
			obj.pointers[id] = true; // keep track of multitouch to keep object ticker alive
			// e.stageX and e.stageY are global
			// e.target.x and e.target.y are relative to e.target's parent
			// bring stageX and stageY into the parent's frame of reference
			// could use e.localX and e.localY but might be dragging container or contents
			dragObject = (currentTarget)?e.currentTarget:e.target;
			if (obj.zimBoundary && !dragObject.getBounds()) {zogy("zim.drag() - drag object needs bounds set"); return;}
			obj.downCheck = true;
			obj.stage.mouseMoveOutside = true;

if (!zim.Ticker.has(obj.zimDragTicker)) zim.Ticker.add(obj.zimDragTicker, obj.stage);

if (removeTweens && obj.zimTweens) {
				for (var tw in obj.zimTweens) {
					var ao = obj.zimTweens[tw];
					if (ao.zimObj && (ao.zimObj.x!=null||ao.zimObj.y!=null)) {
						obj.stopAnimate(tw);
					}
				}
			}

if (!dragObject.parent) return;
			if (onTop) {
				var nc = dragObject.parent.numChildren-1;
				if (dragObject.parent.getChildAt(nc).type=="Keyboard") nc--;
				dragObject.parent.setChildIndex(dragObject,nc);
				if (dragObject.ZIMoutlineShape) dragObject.outline();
			}
			if (dragObject.parent == obj.stage) point = new zim.Point(e.stageX/zim.scaX, e.stageY/zim.scaY);
			else point = dragObject.parent.globalToLocal(e.stageX/zim.scaX, e.stageY/zim.scaY);
			if (reg) {
				dragObject.x = point.x;
				dragObject.y = point.y;
			}
			diffX = point.x - dragObject.x;
			diffY = point.y - dragObject.y;

r = null;
			if (obj.zimBoundary) {
				if (localBoundary) {
					r = zim.boundsToGlobal(dragObject.parent, obj.zimBoundary);
					if (surround) rLocal = obj.zimBoundary;
				} else {
					r = obj.zimBoundary;
					if (surround) rLocal = zim.boundsToGlobal(dragObject.parent, obj.zimBoundary, true); // true flips to global to local
				}
			}
			
			// just a quick way to set a default cursor or use the cursor sent in
			if (obj.cur) obj.cur(zot(dragCursor)?"pointer":dragCursor);
			else obj.cursor = zot(dragCursor)?"pointer":dragCursor;

// extra slide settings to project where the object will slide to
			if (slide) {
				obj.slideStartX = obj.x;
				obj.slideStartY = obj.y;
				hasMoved = obj.zimDragMoving; // just in case clicking while it is animating back to position

lastCount = 0;
				backX = [point.x];
				backY = [point.y];
				backT = [Date.now()];
				lastX = -10000; // reset
				lastY = -10000;
				obj.zimDragMoving = true;
			}

// extra pen drag
			if (obj.type == "Pen") {
				obj.zimDragCheck = true;
				moveCheck = false;
			}

}, true);

obj.zimMove = obj.on("pressmove", function(e) {
			if (singleTouch && !obj.pointers["id"+Math.abs(e.pointerID+1)]) return;			
			if (!obj.downCheck || obj.dragPaused) return;			
			var x = (offStage?e.rawX:e.stageX)/zim.scaX+stage.x;
			var y = (offStage?e.rawY:e.stageY)/zim.scaY+stage.y;
			obj.dragMouseX = Math.round(x);
			obj.dragMouseY = Math.round(y);
			positionObject(dragObject, x, y);
			if (dragObject.ZIMoutlineShape) dragObject.outline();
			if (obj.type == "Pen" && !moveCheck && obj.drawing) moveCheck = true;
			else if (obj.type == "Tag" || obj.type == "TextArea" || obj.type == "Loader") obj.resize();
		}, true);

// obj.off("pressmove",obj.zimMove);  // for some reason causing squiggle drag problems

function positionObject(o, x, y) {

var diffX_o = diffX;
			var diffY_o = diffY;
			if (zot(o)) o = (dragObject) ? dragObject : obj; // so zim.dragBoundary can use this

// x and y are the desired global positions for the object o
			// checkBounds returns the same values if there are no bounds
			// and returns values inside the bounds if there are bounds set
			// or returns a position so that object o surrounds the bounds if surround is true
			// firstly, convert the global x and y to a point relative to the object's parent
			if (!o.parent) return;
			// if (!o.stage) return;

// var noXY = false;
			if (zot(x) || zot(y)) {
				// noXY = true;
				// so zim.dragBoundary can use this to position on change
				// it may be we are resizing before we even drag at all
				// so we need to establish variables that would have been made on drag events
				var p = o.parent.localToGlobal(o.x, o.y);
				diffX = diffY = 0;
				if (obj.zimBoundary) {
					if (localBoundary) {
						r = zim.boundsToGlobal(o.parent, obj.zimBoundary);
						if (surround) rLocal = o.zimBoundary;
					} else {
						r = obj.zimBoundary;
						if (surround) rLocal = zim.boundsToGlobal(o.parent, obj.zimBoundary, true); // flips to global to local
					}
				}
				x = p.x;
				y = p.y;
				if (slide) {
					objUpX = o.x;
					objUpY = o.y;
					dragObject = o;
					// if (dampX) dampX.immediate(objUpX);
					// if (dampY) dampY.immediate(objUpY);
				}
			}

// TODO only need this if boundary - so try and test for that first...
			var point;
			if (stage && stage.type) point = o.parent.globalToLocal(x, y);
			// case where createjs stage - does not have adjusted globalToLocal
			else point = o.parent.globalToLocal(x*zim.scaX, y*zim.scaY);

var mX = axis=="both" || axis=="horizontal"; 
			var mY = axis=="both" || axis=="vertical";

var checkedPoint;
			if (slide && slideSnap) {
				if (slideSnap == "vertical") {
					checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);
					if (mX) o.x = checkedPoint.x;
					if (mY) o.y = point.y-diffY;
				} else if (slideSnap == "horizontal") {
					checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);
					if (mX) o.x = point.x-diffX;
					if (mY) o.y = checkedPoint.y;
				} else {
					if (mX) o.x = point.x-diffX;
					if (mY) o.y = point.y-diffY;
				}
			} else {
				checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);
				// now set the object's x and y to the resulting checked local point
				if (mX) o.x = checkedPoint.x;
				if (mY) o.y = checkedPoint.y;
			}
			if (slide && !hasMoved && (o.slideStartX != o.x || o.slideStartY != o.y)) hasMoved = true;
			if (o.downCheck) {
				diffX = diffX_o;
				diffY = diffY_o;
			}
			// if (noXY) {
			// 	obj.downCheck = true;
			// 	doUp({pointers:[]});
			// }
		}

obj.zimPosition = positionObject;

obj.zimUp = obj.on("pressup", function(e){doUp(e);}, true);
				
		function doUp(e, outsideUp) {

// if (obj.zimMove) obj.off("pressmove", obj.zimMove);	 // for some reason causing squiggle drag problems
			if (singleTouch && !outsideUp && !obj.pointers["id"+Math.abs(e.pointerID+1)]) return;
			
			stCheck = false;

var id = "id"+Math.abs((!zot(e.pointerID)?e.pointerID:0)+1); // avoiding NaN but not sure if correct ZIM 015
			delete obj.pointers[id];
			if (!obj.downCheck || obj.dragPaused) return;

if (obj.cur) obj.cur(zot(overCursor)?"pointer":overCursor);
			else obj.cursor = zot(overCursor)?"pointer":overCursor;
			
			if (slide) {				
				dragObject.dispatchEvent("slidestart");
				
				if (dragObject.parent) {
					var x = offStage?e.rawX:e.stageX;
					var y = offStage?e.rawY:e.stageY;
					point = dragObject.parent.globalToLocal(x/zim.scaX, y/zim.scaY);
				} else {
					point = new zim.Point(0,0);
				}							
				
				// Added ZIM 014 to adjust for velocity effect
				upX = point.x;
				upY = point.y;
				upT = Date.now();	
				
				// Added ZIM 015 if mouseuplus triggers first (TextureActive) then there is no event object
				if (isNaN(upX)) upX = -1000;
				if (isNaN(upY)) upY = -1000;

dX = upX-lastBackX;
				dY = upY-lastBackY;
				var t = upT-lastBackT;

vX = zim.constrain(dX*tick/t, -vRange, vRange);
				vY = zim.constrain(dY*tick/t, -vRange, vRange);

bX = false; // for damping on slideSnap
				bY = false;		
				// end add

obj.downCheck = false;

objUpX = dragObject.x;
				objUpY = dragObject.y;

if (outsideUp) {
					lastBackX = upX = 0;
					lastBackY = upY = 0;
					lastBackT = upT = 0;
				}

// if (dampX) dampX.immediate(50);
				// if (dampY) dampY.immediate(0);

} else {
                obj.downCheck = false; // added ZIM NFT 01
				var pointerCount = 0;
				for (var o in obj.pointers) {
					pointerCount++;
				}
				if (pointerCount == 0) zim.Ticker.remove(obj.zimDragTicker);
				// extra pen drag
				if (obj.type == "Pen") {
					obj.zimDragCheck = false;
					if (moveCheck && obj.drawing) obj.stopCheck(); // added drawing check Cat 04
					// if (moveCheck) obj.stopCheck(); 
				}
			}
			if (obj.stage) obj.stage.update();
		}

// the bounds check for registration inside the bounds
		// or if surround is set for the whole object staying outside the bounds
		function checkBounds(o, x, y) {
			if (!o.parent) return {x:x,y:y};
			if (r) {
				if (surround) {
					var w = o.getBounds().width;
					var h = o.getBounds().height;
					var bx = o.getBounds().x;
					var by = o.getBounds().y;
					if (w < rLocal.width) {
						// put half way between
						x = rLocal.x + (rLocal.width - w) / 2 + (o.regX-bx);
					} else {
						if (x - (o.regX-bx) > rLocal.x) {
							x = rLocal.x + (o.regX-bx);
						}
						if (x - (o.regX-bx) + w < rLocal.x + rLocal.width) {
							x = rLocal.x + rLocal.width + (o.regX-bx) - w;
						}
					}
					if (o.height < rLocal.height) {
						// put half way between
						y = rLocal.y + (rLocal.height - h) / 2 + (o.regY-by);
					} else {
						if (y - (o.regY-by) > rLocal.y) {
							y = rLocal.y + (o.regY-by);
						}
						if (y - (o.regY-by) + h < rLocal.y + rLocal.height) {
							y = rLocal.y + rLocal.height + (o.regY-by) - h;
						}
					}
				} else {
					if (r.type=="Blob") {
						if (r.shape.hitTestPoint(x,y)) return {x:x,y:y};
						else return {x:obj.x,y:obj.y};
					} else {
						// convert the desired drag position to a global point
						// note that we want the position of the object in its parent
						// so we use the parent as the local frame
						point = o.parent.localToGlobal(x,y);
						// r is the bounds rectangle on the global stage
						// r is set during mousedown to allow for global scaling when in localBoundary mode
						// if you scale in localBoundary==false mode, you will need to reset bounds with dragBoundary()
						
						if (obj.circleBounds) {
							var midX = r.x+r.width/2;
							var midY = r.y+r.height/2;
							var rad = obj.circleBounds;
							if (zim.dist(midX, midY, point.x, point.y) <= rad) {
								x = point.x;
								y = point.y;
							} else {
								var ang = zim.angle(midX, midY, point.x, point.y)*RAD;
								x = midX + rad*Math.cos(ang);
								y = midY + rad*Math.sin(ang);
							}							
						} else {
							x = Math.max(r.x, Math.min(r.x+r.width, point.x));
							y = Math.max(r.y, Math.min(r.y+r.height, point.y));
						}
						// now that the point has been checked on the global scale
						// convert the point back to the obj parent frame of reference
						point = o.parent.globalToLocal(x, y);
						x = point.x;
						y = point.y;
					}
				}
			}
			return {x:x,y:y};
		}
		
		function testMove(o,x,y,desiredX,desiredY) {
			if (Math.abs(o.x-lastX) < .1 && Math.abs(o.y-lastY) < .1) {
				obj.zimDragMoving = false;
				o.x = desiredX; // snap to final resting place
				o.y = desiredY;
				o.slideStartX = null;
				o.slideStartY = null;
				if (hasMoved) {
					o.dispatchEvent("slidestop");
					zim.Ticker.remove(obj.zimDragTicker);
				}
				// extra pen drag
				if (obj.type == "Pen") {
					obj.zimDragCheck = false;
					if (moveCheck && obj.drawing) obj.stopCheck(); // added drawing check Cat 04
					// if (moveCheck) obj.stopCheck(); 
				}
			} else {
				lastX = x;
				lastY = y;
			}
		}

// we store where the object was a few ticks ago and project it forward
		// then damp until it stops - although the ticker keeps running and updating
		// if it snaps then the object is allowed to go past the bounds and damp back
		// if it is not snapping then the object stops at the bounds when it is slid

function setUpSlide() {
			obj.zimDragTicker = function() {
				if (zot(obj.slideStartX)) return; // don't stop other things like window scrollbar from moving object

if (!dragObject) dragObject = obj; // could be risky if intending to drag children
				if (obj.downCheck) {
					var point;
					if (dragObject.parent) {
						point = dragObject.parent.globalToLocal(obj.dragMouseX, obj.dragMouseY);
					} else {
						point = new zim.Point(0,0);
					}
					lastCount++;
					backX.push(point.x);
					backY.push(point.y);
					backT.push(Date.now());
					if (lastCount >= back) {
						lastBackX = backX.shift();
						lastBackY = backY.shift();
						lastBackT = backT.shift();
					} else {
						lastBackX = backX[0];
						lastBackY = backY[0];
						lastBackT = backT[0];
					}
				} else {
					if (!obj.zimDragMoving) return;

dX = vX;
					dY = vY;

var desiredX;
					var desiredY;
		
					if (axis==BOTH) {
						desiredX = dragObject.x + dX;
						desiredY = dragObject.y + dY;
					} else if (axis==HORIZONTAL) {
						desiredX = dragObject.x + dX;
						desiredY = dragObject.y;
					} else if (axis==VERTICAL) {
						desiredX = dragObject.x;
						desiredY = dragObject.y + dY;
					}
					
					vX = dX*slideFactor;
					vY = dY*slideFactor;

var checkedPoint;
					if (r) {
						checkedPoint = checkBounds(dragObject, desiredX, desiredY);						
						
						if (slideSnap===true || slideSnap == "horizontal") {	
							if (Math.round(desiredX) != Math.round(checkedPoint.x)) {
								if (!bX) {
									dampX.immediate(desiredX);
									bX = true;
								}								
								vX = 0;
								desiredX = dampX.convert(checkedPoint.x);								
							}
							if (slideSnap == "horizontal") desiredY = checkedPoint.y;
						}

if (slideSnap===true || slideSnap == "vertical") {
				
							if (Math.round(desiredY) != Math.round(checkedPoint.y)) {												
								if (!bY) {
									bY = true;
									dampY.immediate(desiredY);										
									vY = 0;																							
								}		
								desiredY = dampY.convert(checkedPoint.y);																					
							}
							if (slideSnap == "vertical") desiredX = checkedPoint.x;
						}

if (!slideSnap) {
							desiredX = checkedPoint.x;
							desiredY = checkedPoint.y;
						}
					}

dragObject.x = desiredX;
					dragObject.y = desiredY;

testMove(dragObject,dragObject.x,dragObject.y,desiredX,desiredY);

}
			}	
		}
		return obj;
	};//-31

Geänderter text

Open file

if (zot(obj) || !obj.on) return;

if (obj.cur) obj.cur(zot(overCursor) ? "pointer" : overCursor);
		else obj.cursor = zot(overCursor) ? "pointer" : overCursor;

if (zot(swipe)) swipe = false;		
		if (zot(localBoundary)) localBoundary = false;
		if (zot(onTop)) onTop = true;
		if (zot(surround)) surround = false;
		if (zot(slide)) slide = false;
		if (zot(slideFactor)) slideFactor = .9;
		if (zot(slideSnap)) slideSnap = true;
		var snapOptions = ["horizontal", "vertical", "auto"];
		if (slideSnap !== true && snapOptions.indexOf(slideSnap) < 0) slideSnap = false;
		if (slideSnap == "auto") slideSnap = true;
		if (zot(slideSnapDamp)) slideSnapDamp = .1;
		if (zot(reg)) reg = false;
		if (zot(removeTweens)) removeTweens = true;
		if (zot(startBounds)) startBounds = true;
		if (zot(boundary) && !zot(rect)) boundary = rect;
		if (zot(singleTouch)) singleTouch = false;
		
		obj.dragPaused = false;
		
		if (slide) {
			// set up damping for slide and variables used to predict future locations
			// these get populated in a setTimeout in the init function

} else {
			obj.zimDragTicker = function(){};
		}

var diffX,diffY,r,rLocal,point;

function unInitializeObject() {
			if (obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker);
		}

var dragObject;

var stage;
		obj.pointers = {};
		var stCheck = false;
		obj.zimDown = obj.on("mousedown", function(e) {			
			if (!obj.stage || obj.dragPaused) return;
			if (singleTouch && stCheck) {
				e.preventDefault();
				e.stopImmediatePropagation();
				return;
			};	 // breaking if coming back from iframe until next mousedown

if (!zim.Ticker.has(obj.zimDragTicker)) zim.Ticker.add(obj.zimDragTicker, obj.stage);

lastCount = 0;
				backX = [point.x];
				backY = [point.y];
				backT = [Date.now()];
				lastX = -10000; // reset
				lastY = -10000;
				obj.zimDragMoving = true;
			}

// extra pen drag
			if (obj.type == "Pen") {
				obj.zimDragCheck = true;
				moveCheck = false;
			}

}, true);

obj.zimMove = obj.on("pressmove", function(e) {
			if (singleTouch && !obj.pointers["id"+Math.abs(e.pointerID+1)]) {
				e.preventDefault();
				e.stopImmediatePropagation();
				return;
			};	
			if (!obj.downCheck || obj.dragPaused) {
				e.preventDefault();
				e.stopImmediatePropagation();
				return;
			};			
			var x = (offStage?e.rawX:e.stageX)/zim.scaX+stage.x;
			var y = (offStage?e.rawY:e.stageY)/zim.scaY+stage.y;
			obj.dragMouseX = Math.round(x);
			obj.dragMouseY = Math.round(y);
			positionObject(dragObject, x, y);
			if (dragObject.ZIMoutlineShape) dragObject.outline();
			if (obj.type == "Pen" && !moveCheck && obj.drawing) moveCheck = true;
			else if (obj.type == "Tag" || obj.type == "TextArea" || obj.type == "Loader") obj.resize();
		}, true);

// obj.off("pressmove",obj.zimMove);  // for some reason causing squiggle drag problems

function positionObject(o, x, y) {

var diffX_o = diffX;
			var diffY_o = diffY;
			if (zot(o)) o = (dragObject) ? dragObject : obj; // so zim.dragBoundary can use this

if (zot(x) || zot(y)) {
				// so zim.dragBoundary can use this to position on change
				// it may be we are resizing before we even drag at all
				// so we need to establish variables that would have been made on drag events
				var p = o.parent.localToGlobal(o.x, o.y);
				diffX = diffY = 0;
				if (obj.zimBoundary) {
					if (localBoundary) {
						r = zim.boundsToGlobal(o.parent, obj.zimBoundary);
						if (surround) rLocal = o.zimBoundary;
					} else {
						r = obj.zimBoundary;
						if (surround) rLocal = zim.boundsToGlobal(o.parent, obj.zimBoundary, true); // flips to global to local
					}
				}
				x = p.x;
				y = p.y;
				if (slide) {
					objUpX = o.x;
					objUpY = o.y;
					dragObject = o;
					// if (dampX) dampX.immediate(objUpX);
					// if (dampY) dampY.immediate(objUpY);
				}
			}

var mX = axis=="both" || axis=="horizontal"; 
			var mY = axis=="both" || axis=="vertical";

obj.zimPosition = positionObject;

obj.zimUp = obj.on("pressup", function(e){doUp(e);}, true);
				
		function doUp(e, outsideUp) {

if (singleTouch && !outsideUp && !obj.pointers["id"+Math.abs(e.pointerID+1)]) {
				e.preventDefault();
				e.stopImmediatePropagation();
				return;
			};
			
			stCheck = false;

var id = "id"+Math.abs((!zot(e.pointerID)?e.pointerID:0)+1); // avoiding NaN but not sure if correct ZIM 015
			delete obj.pointers[id];

if (!obj.downCheck || obj.dragPaused) {
				e.preventDefault();
				e.stopImmediatePropagation();
				return;
			};

if (obj.cur) obj.cur(zot(overCursor)?"pointer":overCursor);
			else obj.cursor = zot(overCursor)?"pointer":overCursor;

if (e.stageX == null) return; // added for TextureActive drag in 2D view

if (slide) {				
				dragObject.dispatchEvent("slidestart");
				
				if (dragObject.parent) {
					var x = offStage?e.rawX:e.stageX;
					var y = offStage?e.rawY:e.stageY;
					point = dragObject.parent.globalToLocal(x/zim.scaX, y/zim.scaY);
				} else {
					point = new zim.Point(0,0);
				}							
				
				// Added ZIM 014 to adjust for velocity effect
				upX = point.x;
				upY = point.y;
				upT = Date.now();	
				
				// Added ZIM 015 if mouseuplus triggers first (TextureActive) then there is no event object
				if (isNaN(upX)) upX = -1000;
				if (isNaN(upY)) upY = -1000;

dX = upX-lastBackX;
				dY = upY-lastBackY;
				var t = upT-lastBackT;

vX = zim.constrain(dX*tick/t, -vRange, vRange);
				vY = zim.constrain(dY*tick/t, -vRange, vRange);

bX = false; // for damping on slideSnap
				bY = false;		
				// end add

obj.downCheck = false;

objUpX = dragObject.x;
				objUpY = dragObject.y;

if (outsideUp) {
					lastBackX = upX = 0;
					lastBackY = upY = 0;
					lastBackT = upT = 0;
				}

// if (dampX) dampX.immediate(50);
				// if (dampY) dampY.immediate(0);

function setUpSlide() {
			obj.zimDragTicker = function() {
				if (zot(obj.slideStartX)) return; // don't stop other things like window scrollbar from moving object

dX = vX;
					dY = vY;

if (!slideSnap) {
							desiredX = checkedPoint.x;
							desiredY = checkedPoint.y;
						}
					}

dragObject.x = desiredX;
					dragObject.y = desiredY;

testMove(dragObject,dragObject.x,dragObject.y,desiredX,desiredY);

}
			}	
		}
		return obj;
	};//-31