Compare text

Find the difference between two text files

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Tools

drag diff

Created 3 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

Saved 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

Changed 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