Texte vergleichen

Finde den Unterschied zwischen zwei Textdateien

Verarbeitung

Diffchecker Desktop Der sicherste Weg, Diffchecker zu nutzen. Hol dir die Desktop-App: Deine Diffs verlassen nie deinen Computer!Desktop holen

distill_difference

Erstellt vor 7 MonatenDiff läuft nie ab

163 Entfernungen

Zeilen
Gesamt
Entfernt

Zeichen
Gesamt
Entfernt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

714 Zeilen

196 Hinzufügungen

Zeilen
Gesamt
Hinzugefügt

Zeichen
Gesamt
Hinzugefügt

Um diese Funktion weiterhin zu nutzen, aktualisiere auf Diffchecker Pro Preise anzeigen

701 Zeilen

// ZIM - https://zimjs.com - DISTILLED NON-MINIFIED

WW.zapp_scaling = WW.zapp_width = WW.zapp_height = WW.zapp_color = WW.zapp_outerColor = WW.zapp_assets = WW.zapp_path = WW.zapp_progress = WW.zapp_gpu = WW.zapp_gpuObj = WW.zapp_maxNum = WW.zapp_singleTouch = null;

function zid(s) {

return document.getElementById(s);

}

function zil() {

var a = function(e) {if (!e) e = event; if (e.keyCode && (e.keyCode >= 32 && e.keyCode <= 40)) e.preventDefault();};

if (WW.zilK) { // do not double apply

var b = function(e) {if (!e) e = event; e.preventDefault();};

WW.removeEventListener("keydown", WW.zilK);

var c = b;

WW.removeEventListener("wheel", WW.zilW);

window.addEventListener("keydown", a, {passive:false});

WW.removeEventListener("DOMMouseScroll", WW.zilS);

window.addEventListener("wheel", b, {passive:false});

}

window.addEventListener("DOMMouseScroll", c, {passive:false});

WW.zilK = function(e) {if (!e) e = event; if (e.keyCode && (e.keyCode >= 32 && e.keyCode <= 40)) e.preventDefault();};

return [a, b, c];

WW.zilW = function(e) {if (!e) e = event; e.preventDefault();};

WW.zilS = WW.zilW;

WW.addEventListener("keydown", WW.zilK, {passive:false});

WW.addEventListener("wheel", WW.zilW, {passive:false});

WW.addEventListener("DOMMouseScroll", WW.zilS, {passive:false});

return [WW.zilK, WW.zilW, WW.zilS];

}

function zet(selector) {

function zet(selector, first) {

function Zet() {

var that = this;

this.on = function(type, call) {

if (zot(selector) || zot(type) || zot(call)) return;

var tags = that.tags;

for (var i=0; i<tags.length; i++) {

tags[i].addEventListener(type, call);

}

};

this.off = function(type, call) {

if (zot(selector) || zot(type) || zot(call)) return;

var tags = that.tags;

for (var i=0; i<tags.length; i++) {

tags[i].removeEventListener(type, call);

}

};

Object.defineProperty(that, 'tags', {

get: function() {

if (zot(selector)) return [];

if (typeof selector == 'string' || selector instanceof String) {

return document.querySelectorAll(selector);

if (first) zogo(selector, document.querySelector(selector))

if (first) return [document.querySelector(selector)];

else return document.querySelectorAll(selector);

} else { // selector is already an object - assume a tag

if (typeof (selector).innerHTML == "string") return [selector];

return [];

}

set: function() {

}

});

this.css = function(property, value) {

// if property is object then assign all props in object

var tags = that.tags;

for (var i=0; i<tags.length; i++) {

if (arguments.length == 1 && arguments[0].constructor === {}.constructor) {

for (var p in property) {

tags[i].style[p] = property[p];

}

} else if (arguments.length == 1) {

return that.tags[0].style[property];

} else {

tags[i].style[property] = value;

}

};

this.prop = function(property, value) {

if (zot(property)) return;

var tags = that.tags;

var a = [];

for (var i=0; i<tags.length; i++) {

if (zot(value)) {

if (property.constructor === {}.constructor) {

for (var p in property) {

tags[i][p] = property[p];

}

} else {

a.push(tags[i][property]);

}

} else {

tags[i][property] = value;

}

if (zot(value)) return a;

};

}

return new Zet();

}

function zik(v) {

if (zot(v)) return;

return zim.Pick.choose(v);

}

var zogr=zogb=zogp=zogy=zogo=zogl=zogd=zog;

function isDUO(a) {return a.length == 1 && a[0] != undefined && a[0].constructor === {}.constructor;}

function zob(func, args, sig, scope) {

var zimon = (zim && (zim.ZIMONON || window.ZIMONON));

if (isDUO(args)) {

var zp = args[0];

var za = (zot(sig))?func.toString().split(/\n/,1)[0].match(/$(.*)$/)[1].replace(/\s+/g,"").split(","):sig.replace(/\s+/g,"").split(",");

var zv = []; var zi; var zt;

for (zi=0; zi<za.length; zi++) {zt=za[zi].split("=")[0]; za[zi]=zt; zv.push(zp[zt]);}

for (zi in zp) {if (za.indexOf(zi)<0) {if (zon) zog(func,"bad argument "+zi);}};

var zr; if (zr=(func.prototype.isPrototypeOf(scope))?new (func.bind.apply(func,[null].concat(zv)))():func.apply(null,zv)) {if (zimon && !zr.arguments) {zr.arguments = [zp]}; return zr;} else {return true;}

} else {

if (zimon && scope && args && zot(scope.arguments)) {

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

}

Gespeicherte Diffs

Originaltext

Datei öffnen

// ZIM - https://zimjs.com - DISTILLED NON-MINIFIED

zim.extend = function(subclass, superclass, override, prefix, prototype) {
		var sig = "subclass, superclass, override, prefix, prototype";
		var duo; if (duo = zob(zim.extend, arguments, sig)) return duo;
		if (zot(subclass) || zot(superclass)) {
			if (zon && subclass!=zim.StageGL) zog("zim.extend() - please supply a class and its superclass");
			return;
		}
		// zogr("start")		
		if (zot(prefix)) prefix = "super";
		if (zot(override)) override = [];
		if (!Array.isArray(override)) override = [override];
		if (zot(prototype)) prototype = true;
		// modified CreateJS extend() to include any prototype members already added
		// see http://www.createjs.com/docs/easeljs/classes/Utility%20Methods.html
		var existingP = {};
		for (var f in subclass.prototype) Object.defineProperty(existingP,f,Object.getOwnPropertyDescriptor(subclass.prototype, f));
		function o() {this.constructor = subclass;}
		o.prototype = superclass.prototype;
		subclass.prototype = new o();
		for (f in existingP) {
			Object.defineProperty(subclass.prototype,f,Object.getOwnPropertyDescriptor(existingP,f));
		}

// modified CreateJS promote() to promote methods other than constructor only if methods is true
		// zim does not override with prototypes so it is uneccessary to loop through the super class methods
		// added checking an array of string values of methods defined in class (not prototype) that are being overridden
		var subP = subclass.prototype;
		var supP = (Object.getPrototypeOf&&Object.getPrototypeOf(subP))||subP.__proto__;
		if (supP) {
			subP[(prefix+="_") + "constructor"] = supP.constructor; // constructor is not always innumerable
			var n;
			for (var i=0; i<override.length; i++) {				
				n = override[i];
				if (typeof supP[n] == "function") {
					subP[prefix + n] = supP[n];
				}
			}
			if (prototype) {
				for (n in supP) {
					if (subP.hasOwnProperty(n) && (typeof supP[n] == "function")) {subP[prefix + n] = supP[n];}
				}
			}
		}
		return subclass;
	};
	
zim.orange="#f58e25"; zim.green="#acd241"; zim.pink="#e472c4"; zim.blue="#50c4b7"; zim.brown="#d1a170"; zim.yellow="#ebcb35"; zim.purple="#993399"; zim.red="#fb4758"; zim.silver="#999999"; zim.pewter="#888888"; zim.tin="#777777"; zim.granite="#666666"; zim.grey="#555555"; zim.gray="#555555"; zim.charcoal="#444444"; zim.licorice="#222222"; zim.lighter="#eeeeee"; zim.moon="#dddddd"; zim.light="#cccccc"; zim.mist="#bbbbbb"; zim.fog="#aaaaaa"; zim.dark="#333333"; zim.darker="#111111"; zim.black="#000000"; zim.white="#ffffff"; zim.clear="rgba(0,0,0,0)"; zim.faint="rgba(0,0,0,.01)";
String.prototype.darken = function(a) {return zim.darken(this, a);}; String.prototype.lighten = function(a) {return zim.lighten(this, a);};
zim.TIME="seconds"; zim.TIMECHECK=true; zim.ANIMATE = true; zim.OPTIMIZE = false; zim.ACTIONEVENT = "mousedown"; zim.DEFAULTWIRE = "currentValue"; zim.POSREG = false; zim.DRAGALL = false;
zim.TOP="top"; zim.BOTTOM="bottom"; zim.LEFT="left"; zim.RIGHT="right"; zim.CENTER="center"; zim.MIDDLE="middle"; zim.HORIZONTAL="horizontal"; zim.VERTICAL="vertical"; zim.BOTH="both"; zim.UP="up"; zim.DOWN="down"; zim.AUTO="auto"; zim.DEFAULT="default"; zim.AVE="ave"; zim.DIR="dir"; zim.START="start"; zim.END="end"; zim.NEXT="next"; zim.PREV="prev"; zim.GET="get"; zim.POST="post"; zim.LOCALSTORAGE="localstorage"; zim.SOCKET="socket"; zim.TO="to"; zim.FROM="from";  zim.SINE="sine"; zim.SQUARE="square"; zim.TRIANGLE="triangle"; zim.SAW="saw"; zim.ZAP="zap"
zim.TAU=Math.PI*2; zim.DEG=180/Math.PI; zim.RAD=Math.PI/180; zim.VERSION="cat/04/zim";
zim.distill = function(){zog("zim.Distill() - done - you can remove command")};
function zenable(t,v) {if (v) {t.mouseChildren = true;t.mouseEnabled = true;t._enabled = true;} else {t.mouseChildren = false;t.mouseEnabled = false;t._enabled = false;}}

zim.chop = function(obj, cols, rows, tile, margin) {
		if (zot(obj)) return;
		if (zot(cols)) cols = 3;
		if (zot(rows)) rows = 3;
		if (zot(tile)) tile = true;
		if (zot(margin)) margin = 0;
		var w = obj.width/cols;
		var h = obj.height/rows;
		var m = margin;
		var pieces = [];
		zim.loop(rows, function (r) {
			zim.loop(cols, function (c) {
				var p = new zim.Bitmap(obj, w+m*2, h+m*2, c*w-m, r*h-m);
				if (margin != 0) {
					p.setBounds(m,m,w,h);
					p.regX = m;
					p.regY = m;
				}
				pieces.push(p);
			});
		});
		if (tile) return new zim.Tile(pieces,cols,rows,0,0,true);
		else return pieces;
	};

zim.shuffle = function(array) {
		if (zot(array)) return;
		var i = array.length, j, temp;
		if (i == 0) return array;
		while(--i) {
			j = Math.floor(Math.random()*(i+1));
			temp=array[i];
			array[i]=array[j];
			array[j]=temp;
		}
		return array;
	};

zim.rand = function(a, b, integer, negative) {
		if (zot(a) && zot(b)) return Math.random();
		if (zot(a) || isNaN(a)) a = 0;
		if (zot(b) || isNaN(b)) b = 0;
		if (a%1!=0 || b%1!=0) integer = false;
		if (zot(integer)) integer = true;
		if (negative) if (Math.random()>.5) {a*=-1; b*=-1;}
		if (integer) if (a>b) {a++;} else if (b>a) {b++;}
		var r;
		if (a == 0 && b == 0) return 0;
		else if (b == 0) r = Math.random()*a;
		else r = Math.min(a,b) + Math.random()*(Math.max(a,b)-Math.min(a,b));
		if (integer) return Math.floor(r);
		else return r;
	};

var timeType = getTIME(time, timeUnit);
		if (zot(time)) time = timeType=="s"?1:1000;

time = zim.Pick.choose(time);
		var obj = {startTime:Date.now(), time:0, paused:false, done:false, timeUnit:timeUnit};

if (pauseOnBlur) {
			if (zot(zim.blurCheck)) zim.setBlurDetect();
			zim.pauseOnBlur.push(obj);
		}

var lastTime = obj.startTime;
		function next() {
			var now = Date.now();
			obj.time += (now - lastTime)/(timeType=="s"?1000:1);
			lastTime = now;
			if (obj.time >= time) {
				obj.done = true;
				(call)(obj);
				obj.clear();
				return;
			}
			obj.rid = requestAnimationFrame(next);
		}

obj.pause = function(state, immediate, reset) {
			if (zot(state)) state = true;
			if (state) { // pausing
				cancelAnimationFrame(obj.rid);
			} else { // unpausing
				if (immediate) lastTime = 0; // a long time ago ;-)
				else if (reset) {lastTime = Date.now(); obj.time=0;}
				else lastTime = Date.now();
				next();
			}
			obj.paused = state;
		};

obj.clear = function() {
			if (obj) cancelAnimationFrame(obj.rid);
			for (var i in obj) {
				delete obj[i];
			}
			obj.pause = function() {};
			obj.clear = function() {};
		};
		next(); // thanks StevenWarren for the glitch fix!
		return obj;
	};

zim.interval = function(time, call, total, immediate, pauseOnBlur, timeUnit) {
		var sig = "time, call, total, immediate, pauseOnBlur, timeUnit";
		var duo; if (duo = zob(zim.interval, arguments, sig, this)) return duo;
		if (zot(call)) return;
		if (typeof call != 'function') return;

var timeType = getTIME(time, timeUnit);
		if (zot(time)) time = timeType=="s"?1:1000;

if (zot(immediate)) immediate = false;
		if (!zot(total) && (isNaN(total) || total<=0)) return;
		if (zot(total)) total = -1;
		var obj = {count:0, total:total, paused:false, time:time, active:true, timeUnit:timeUnit};

if (pauseOnBlur) {
			if (zot(zim.blurCheck)) zim.setBlurDetect();
			zim.pauseOnBlur.push(obj);
		}

function interval() {
			obj.startTime = Date.now();
			obj.interval = zim.Pick.choose(obj.time);
			obj.id = setTimeout(function() {
				if (obj.paused) return;
				if (!obj.active) return;
				// obj.rid = requestAnimationFrame(interval);
				obj.count++;
				(call)(obj);
				interval();
				checkTotal();
			}, obj.interval*(timeType=="s"?1000:1));

}
		if (immediate) {
			setTimeout(function() {
				(call)(obj);
				checkTotal();
			}, 10);
		}
		function checkTotal() {
			if (total == -1) return;
			if (obj.count >= (immediate?obj.total-1:obj.total)) obj.clear();
		}
		var pausedTimeout;
		obj.pause = function(state, immediate, reset) {
			if (zot(state)) state = true;
			if (state) { // pausing
				clearTimeout(pausedTimeout);
				clearTimeout(obj.id);
				cancelAnimationFrame(obj.rid);
				obj.pauseTimeLeft = obj.interval-(Date.now()-obj.startTime)/(timeType=="s"?1000:1);
			} else { // unpausing
				if (!obj.paused) obj.pause(true);
				pausedTimeout = setTimeout(function() {
					obj.count++;
					(call)(obj);
					interval();
					checkTotal();
				}, immediate?0:(reset?obj.interval:obj.pauseTimeLeft)*(timeType=="s"?1000:1));
				obj.pauseTimeLeft = null;
			}
			obj.paused = state;
		};
		obj.clear = function() {
			obj.active = false;
			clearTimeout(pausedTimeout);
			cancelAnimationFrame(obj.rid);
			clearTimeout(obj.id);
			var count = obj.count;
			for (var i in obj) {
				delete obj[i];
			}
			obj.active = false;
			obj.count = count;
			obj.pause = function() {};
			obj.clear = function() {};
		};
		interval();
		return obj;
	};

zim.copy = function(obj, clone, cloneContainer) {
		if (zot(clone)) clone = false;
		if (zot(cloneContainer)) cloneContainer = true;
		if (obj==null || !(obj instanceof Array || obj.constructor == {}.constructor)) return clone&&obj!=null?(obj.clone?(obj.type&&((obj.type!="Container"&&obj.type!="Stage"&&obj.type!="StageGL")||cloneContainer)?obj.clone():obj):obj):obj;
		if (obj instanceof Array) {
			var array = [];
			for (var i=0; i<obj.length; i++) {
				array[i] = zim.copy(obj[i], clone, cloneContainer);
			}
			return array;
		}
		if (obj.constructor == {}.constructor) {
			var copy = {};
			for (var attr in obj) {
				var answer = zim.copy(obj[attr], clone, cloneContainer);
				if (obj.hasOwnProperty(attr)) copy[attr] = answer;
			}
			return copy;
		}
	};

zim.isEmpty = function(obj) {
		if (zot(obj)) return;
		var count = 0;
		for (var o in obj) {
			count++; break;
		}
		return (count == 0);
	};

zim.isPick = function(obj) {
		if(zot(obj)) return;
		return (Array.isArray(obj)||(obj.constructor=={}.constructor && obj.min!=null && obj.max!=null)||(obj.constructor === Function && (obj.array!=null || obj()!=null))); // obj.array is a series
	};

zim.merge = function() {
		var obj = {}; var i; var j;
		for (i=0; i<arguments.length; i++) {
			for (j in arguments[i]) {
				if (arguments[i].hasOwnProperty(j)) {
					obj[j] = arguments[i][j];
				}
			}
		}
		return obj;
	};

// if (addZeros && places > 0 && answer != 0) {
		// 	var place = String(answer).indexOf(".");
		// 	var length = String(answer).length;
		// 	if (place < 0) {place = length++; answer+=".";}
		// 	for (var i=0; i<places-(length-place-1); i++) {answer += "0";}
		// }
		var sign = zim.sign(answer);
		if (addZeros > 0) {
			var place = String(answer).indexOf(".");
			var length = String(answer).length;
			if (place < 0) {place = length++; answer+=".";}
			for (var i=0; i<addZeros-(length-place-1); i++) {answer += "0";}
		}
		if (addZerosBefore > 1) {
			// fix this - Dan Zen - negative decimal number problem
			if (sign == -1) answer = answer.substr(1,answer.length-1);
			var place = String(answer).indexOf(".");
			var length = String(answer).length;
			var left = (place < 0) ? length : place;
			for (var i=0; i<addZerosBefore-left; i++) {answer = "0" + answer;}
			if (sign == -1) answer = "-" + answer;
		}
		if (addZerosBefore == 0) answer = answer.toString().replace(/^0\./,".");
		if ((addZeros + addZerosBefore > 0) && !includeZero && Number(answer) == 0) answer = 0;
		if (time) answer = String(answer).replace(".", ":");
		return zim.zut(evt) ? answer : null;
	};

zim.sign = function(num) {
		return num?num<0?-1:1:0;
	};

zim.constrain = function(num, min, max, negative) {
		if (zot(num)) return;
		if (zot(min)) min = 0;
		if (zot(max)) max = Number.MAX_VALUE;
		if (max < min) {var max2 = min; max = min; min = max2;} // ES6 Fix to come
		if (zot(negative)) negative = false;
		if (negative && num < 0) {
			return Math.max(-max, Math.min(num, -min));
		} else {
			return Math.max(min, Math.min(num, max));
		}
	};

zim.dist = function(a, b, c, d) {
		if (zot(a) || zot(b)) return;
		if (!zot(a.x) && !zot(b.x)) {
			d = b.y;
			c = b.x;
			b = a.y;
			a = a.x;
		} else {
			if (zot(c)) c = 0;
			if (zot(d)) d = 0;
		}
		return Math.sqrt((Math.pow(c-a, 2) + Math.pow(d-b, 2)));
	};

zim.rectIntersect = function(a, b, margin) {
		if (zot(margin)) margin = 0;
		if (a.x >= b.x + b.width + margin || a.x + a.width + margin <= b.x ||
			a.y >= b.y + b.height + margin || a.y + a.height + margin <= b.y ) {
			return false;
		} else {
			return true;
		}
	};

zim.boundsAroundPoints = function(points) {
		var tX = 10000;
		var tY = 10000;
		var bX = -10000;
		var bY = -10000;
		for (var i=0; i<points.length; i++) {
			var p = points[i];
			if (p.x < tX) tX = p.x;
			if (p.x > bX) bX = p.x;
			if (p.y < tY) tY = p.y;
			if (p.y > bY) bY = p.y;
		}
		return {x:tX, y:tY, width:bX-tX, height:bY-tY};
	};

zim.angle = function(x1, y1, x2, y2) {
		if (zot(x1) || zot(y1)) return;
		if (zot(x2)) {x2 = x1; x1 = 0;}
		if (zot(y2)) {y2 = y1; y1 = 0;}
		return (Math.atan2(y2-y1, x2-x1)*180/Math.PI+360)%360;
	};

zim.Point = function(x, y, z, q, r, s, t, u, v, w) {
		if (zot(x)) x = 0;
		if (zot(y)) y = 0;
		if (zot(z)) z = 0;
		if (zot(q)) q = 0;
		if (zot(r)) r = 0;
		if (zot(s)) s = 0;
		if (zot(t)) t = 0;
		if (zot(u)) u = 0;
		if (zot(v)) v = 0;
		if (zot(w)) w = 0;
		this.x = x;
		this.y = y;
		this.z = z;
		this.q = q;
		this.r = r;
		this.s = s;
		this.t = t;
		this.u = u;
		this.v = v;
		this.w = w;
	};

zim.Boundary = function(x, y, width, height) {
		if (zot(x) || zot(y) || zot(width) || zot(height)) return;
		this.x = x;
		this.y = y;
		this.width = width;
		this.height = height;
		this.contract = function(a,b,c,d) {
			if (zot(a)) return this;
			if (zot(b)) b = a;
			if (zot(c)) {
				c = a*2;
			} else {
				c = c+a;
			}
			if (zot(d)) {
				d = b*2;
			} else {
				d = d+b;
			}
			this.x += a;
			this.y += b;
			this.width -= c;
			this.height -= d;
			return this;
		};
	};

zim.RadialColor = function(colors,ratios, x0,y0,r0, x1,y1,r1) {
		this.type = "RadialColor";
		this.colors = zot(colors)?["black","white"]:colors;
		this.ratios = zot(ratios)?[0,1]:ratios;
		this.x0 = zot(x0)?0:x0;
		this.y0 = zot(y0)?0:y0;
		this.r0 = zot(r0)?0:r0;
		this.x1 = zot(x1)?0:x1;
		this.y1 = zot(y1)?100:y1;
		this.r1 = zot(r1)?100:r1;
	};

zim.Bezier = function Bezier(a, b, c, d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;

this.len = 100;
        this.arcLengths = new Array(this.len + 1);
        this.arcLengths[0] = 0;

var ox = this.x(0), oy = this.y(0), clen = 0;
        for(var i = 1; i <= this.len; i += 1) {
            var x = this.x(i * 0.01), y = this.y(i * 0.01);
            var dx = ox - x, dy = oy - y;
            clen += Math.sqrt(dx * dx + dy * dy);
            this.arcLengths[i] = clen;
            ox = x, oy = y;
        }
        this.length = clen;
    };

zim.Bezier.prototype = {
        map: function(u) {
            var targetLength = u * this.arcLengths[this.len];
            var low = 0, high = this.len, index = 0;
            while (low < high) {
                index = low + (((high - low) / 2) | 0);
                if (this.arcLengths[index] < targetLength) {
                    low = index + 1;

} else {
                    high = index;
                }
            }
            if (this.arcLengths[index] > targetLength) {
                index--;
            }

var lengthBefore = this.arcLengths[index];
            if (lengthBefore === targetLength) {
                return index / this.len;

} else {
                return (index + (targetLength - lengthBefore) / (this.arcLengths[index + 1] - lengthBefore)) / this.len;
            }
        },

mx: function (u) {
            return this.x(this.map(u));
        },

my: function (u) {
            return this.y(this.map(u));
        },

x: function (t) {
            return ((1 - t) * (1 - t) * (1 - t)) * this.a.x
                   + 3 * ((1 - t) * (1 - t)) * t * this.b.x
                   + 3 * (1 - t) * (t * t) * this.c.x
                   + (t * t * t) * this.d.x;
        },

y: function (t) {
            return ((1 - t) * (1 - t) * (1 - t)) * this.a.y
                   + 3 * ((1 - t) * (1 - t)) * t * this.b.y
                   + 3 * (1 - t) * (t * t) * this.c.y
                   + (t * t * t) * this.d.y;
        }
    };

zim.makeID = function(type, length, letterCase) {
		if (zot(type)) type = "mixed";
		if (zot(length)) length = 5;
		if (zot(letterCase)) letterCase = "uppercase";
		var choices;
		var nums = [2,3,4,5,6,7,8,9];
		var lets = "abcdefghjkmnpqrstuvwxyz".split("");
		if (type.constructor === Array) {
			choices = type;
		} else if (type == "numbers") {
			choices = nums;
		} else if (type == "letters") {
			choices = lets;
		} else {
			choices = nums.concat(lets);
		}
		var id = "";
		var c; // character - note, char is a reserved word for compressor!
		var rand;
		for (var i=0; i<length; i++) {
			c = choices[Math.floor(Math.random()*choices.length)];
			rand = Math.random();
			if (letterCase == "uppercase" || (letterCase == "mixed" && rand > .5)) {
				if (c.toUpperCase) c = c.toUpperCase();
			} else {
				if (c.toLowerCase) c = c.toLowerCase();
			}
			id += String(c);
		}
		return id;
	};

zim.series = function() {
		var array;
		var range;
		if (arguments.length == 0) return function(){};
		if (arguments.length == 1 && Array.isArray(arguments[0])) {
			array = arguments[0];
		} else if (arguments.length == 1 && arguments[0].constructor == {}.constructor) {
			range = arguments[0];
			if (zot(range.min)) range.min = 0;
			if (zot(range.max)) range.max = 1;
			if (zot(range.step)) range.step = 1;
			array = [];
			zim.loop(Math.floor(Math.abs(range.max-range.min)+range.step), function (i) {
				array.push(i+range.min);
			}, null, range.step);
			range = null;
		} else {
			array = Array.prototype.slice.call(arguments);
		}
        var count = 0;
		var dir = 1;
		var step = 1;
		var every = 0;
		var everyCount = 0;
		var bounce = false;
		var constrain = false;
		var lastVal;

var f = function() {
			if (every && everyCount%(every) != 0) {
				everyCount++;
				return lastVal;
			}
			everyCount++;
			var length = array.length;
			var val;
			val = array[(length*10+count)%length];

if (bounce) {
				if (dir > 0 && count+dir*step >= length) {
					dir = -1;
					count = (length-1)-(count+step-(length-1));
				} else if (dir < 0 && count+dir*step < 0) {
					dir = 1;
					count = step - count;
				} else {
					count += dir*step;
				}
			} else if (constrain) {
				if (dir > 0 && count+dir*step >= length) count = length-1;
				else if (dir < 0 && count+dir*step < 0) count = 0;
				else count += dir*step;
			} else {
				count += dir*step;
			}
			lastVal = val;
			return val;
        };
        f.array = array;
		f.type = "series";
		Object.defineProperty(f, 'index', {
			get: function() {
				var length = array.length;
				return (length*10+count)%length;
			},
			set: function(value) {
				count = value;
			}
		});
		f.jump = function(value) {
			count = value;
			return f;
		};
		f.reverse = function(value) {
			if (zot(value)) value = true;
			if (value) dir = -1;
			else dir = 1;
			count = array.length-1;
			return f;
		};
		f.bounce = function(value) {
			// normalize count
			if (zot(value)) value = true;
			var length = array.length;
			count = (length*10+count)%length;
			bounce = value;
			return f;
		};
		f.step = function(value) {
			if (zot(value)) value = 1;
			step = Math.floor(value);
			return f;
		};
		f.every = function(value) {
			if (zot(value)) value = 1;
			every = Math.abs(value);
			everyCount = 0;
			return f;
		};
		f.constrain = function(value) {
			if (zot(value)) value = true;
			constrain = value;
			return f;
		};
        return f;
	};

zim.Damp = function(startValue, damp) {
		var sig = "startValue, damp";
		var duo; if (duo = zob(zim.Damp, arguments, sig, this)) return duo;
		this.lastValue = (zot(startValue)) ? 0 : startValue;
		this.damp = (zot(damp)) ? .1 : damp;
	};
	zim.Damp.prototype.convert = function(desiredValue) {
		return this.lastValue = this.lastValue + (desiredValue - this.lastValue) * this.damp;
	};
	zim.Damp.prototype.immediate = function(desiredValue) {
		this.lastValue = desiredValue;
		return this;
	};

zim.Dictionary = function(unique) {
		this.length = 0;
		this.unique = unique;
		var objects = this.objects = []; // store objects and values in synched arrays
		var values = this.values = [];

this.add = function(o,v) {
			if (zot(o)) return;
			if (zot(v)) v = true;
			if (this.unique) this.remove(o);
			objects.push(o);
			values.push(v);
			this.length++;
		};

this.at = function(o) {
			if (zot(o)) return;
			var i = objects.indexOf(o);
			if (i > -1) return values[i];
			return null;
		};

this.remove = function(o) {
			if (zot(o)) return false;
			var i = objects.indexOf(o);
			if (i > -1) {
				objects.splice(i,1);
				values.splice(i,1);
				this.length--;
				return true;
			} else {
				return false;
			}
		};

this.clear = function() {
			objects = this.objects = []; // store objects and values in synched arrays
			values = this.values = [];
			this.length = null;
			return this;
		};

this.dispose = function(a,b,disposing) {
			objects = null;
			values = null;
			this.length = null;
			return true;
		};
	};

zim.Pick = function(choices) {
        this.choices = choices;
        this.num = function(num) {
            var s = [];
            for (var i=0; i<num; i++) {s.push(zim.Pick.choose(this));}
            this.choices = zim.Pick.series(s);
            return this;
        };
        var that = this;
        this.loop = function(num, call) {
            var r;
            for (var i=0; i<num; i++) {
                r = call(zim.Pick.choose(that), i, num);
                if (typeof r != 'undefined') return r;
            }
         };
    };
    zim.Pick.prototype.type = "Pick";
    zim.Pick.series = function() {
		// see https://github.com/danzen/Pick for all inclusive class to use in other libraries / languages, etc.
		return zim.series.apply(null, arguments);
    };
    zim.Pick.rand = function(a, b, integer, negative) {
		// see https://github.com/danzen/Pick for all inclusive class to use in other libraries / languages, etc.
		return zim.rand(a, b, integer, negative);
    };
    zim.Pick.choose = function(obj, literal, target) {
        if (literal == null) literal = true;
		if (obj==null) return obj;
        if (obj.type=="Pick" || literal) {
            var c = obj.choices || obj;
            if (Array.isArray(c)) {
                var val = c[Math.floor(Math.random()*(c.length))];
                return zim.Pick.choose(val); // recursive
            } else if (c.constructor === {}.constructor) {
                if (!zot(c.noPick)) return c.noPick; // a passthrough for arrays and functions
                if (zot(c.max)) return c;
                if (zot(c.integer)) c.integer = false;
                var val = zim.Pick.rand(c.min, c.max, c.integer, c.negative);
                return val; // this is just a number in a range - no need for recursive
            } else if (c instanceof Function) {
				if (c.count==null) c.count=0;
				else c.count++;
                return zim.Pick.choose((c)(target)); // recursive
            }
            return obj;
        } else {
            return obj;
        }
	};

zim.scrollX = function(num, time) {
		return zim.abstractScroll("X", "Left", num, time);
	};

zim.scrollY = function(num, time) {
		return zim.abstractScroll("Y", "Top", num, time);
	};

zim.abstractScroll = function(dir, side, num, time) {
		var timeType = getTIME(time);
		var perpend = (dir == "X") ? "Y" : "X"; // perpendicular direction
		if (zot(num)) {
			var safari = 0;
			var browser=navigator.applicationName;
			var navindex=navigator.userAgent.indexOf('Safari');
			if (navindex != -1 || browser=='Safari') {
				var safari = 1;
			}
			return (document.documentElement && document.documentElement["scroll"+side]) || document.body["scroll"+side];
		} else if (zot(time)) {
			window.scrollTo(zim["scroll"+perpend](), num);
		} else {
			var interval = 50;
			var t = time*(timeType=="s"?1000:1);
			if (t < interval) t = interval;
			var steps = t/interval;
			var current = zim["scroll"+dir]();
			var amount = num - current;
			var diff = amount/steps;
			var count = 0;
			var scrollInterval = setInterval(function() {
				count++;
				current+=diff;
				window.scrollTo(zim["scroll"+perpend](), current);
				if (count >= steps) {
					window.scrollTo(zim["scroll"+perpend](), num);
					clearInterval(scrollInterval);
				}
			}, interval);
		}
		return num;
	};

zim.windowWidth = function() {
		var w = isNaN(window.innerWidth) ? window.clientWidth : window.innerWidth;
		var h = isNaN(window.innerHeight) ? window.clientHeight : window.innerHeight;
		if (zim.mobile() && !zot(window.orientation) && !window.parent) {
			if ((w > h && Math.abs(window.orientation) != 90) || h > w && Math.abs(window.orientation) == 90) {
				var oldW = w;
				w = h;
				h = oldW;
			}
		}
		// 6. part of TEN PATCH
		// pay attention to swapRotation from Frame
		return (typeof zdf != "undefined" && zdf.swapRotation)?h:w;
	};

zim.windowHeight = function() {
		var w = isNaN(window.innerWidth) ? window.clientWidth : window.innerWidth;
		var h = isNaN(window.innerHeight) ? window.clientHeight : window.innerHeight;
		if (zim.mobile() && !zot(window.orientation) && !window.parent) {
			if ((w > h && Math.abs(window.orientation) != 90) || h > w && Math.abs(window.orientation) == 90) {
				var oldW = w;
				w = h;
				h = oldW;
			}
		}
		// 7. part of TEN PATCH
		// pay attention to swapRotation from Frame
		return (typeof zdf != "undefined" && zdf.swapRotation)?w:h;
	};

zim.convertColor = function(color, toColorType, alpha) {
		if (zot(toColorType)) toColorType = "hex";
		if (zot(color)) return;
		color = zik(color);
		var colors = ['black','aliceblue','antiquewhite','aqua','aquamarine','azure','beige','bisque','blanchedalmond','blue','blueviolet','brown','burlywood','cadetblue','chartreuse','chocolate','coral','cornflowerblue','cornsilk','crimson','cyan','darkblue','darkcyan','darkgoldenrod','darkgray','darkgrey','darkgreen','darkkhaki','darkmagenta','darkolivegreen','darkorange','darkorchid','darkred','darksalmon','darkseagreen','darkslateblue','darkslategray','darkslategrey','darkturquoise','darkviolet','deeppink','deepskyblue','dimgray','dimgrey','dodgerblue','firebrick','floralwhite','forestgreen','fuchsia','gainsboro','ghostwhite','gold','goldenrod','gray','grey','green','greenyellow','honeydew','hotpink','indianred','indigo','ivory','khaki','lavender','lavenderblush','lawngreen','lemonchiffon','lightblue','lightcoral','lightcyan','lightgoldenrodyellow','lightgray','lightgrey','lightgreen','lightpink','lightsalmon','lightseagreen','lightskyblue','lightslategray','lightslategrey','lightsteelblue','lightyellow','lime','limegreen','linen','magenta','maroon','mediumaquamarine','mediumblue','mediumorchid','mediumpurple','mediumseagreen','mediumslateblue','mediumspringgreen','mediumturquoise','mediumvioletred','midnightblue','mintcream','mistyrose','moccasin','navajowhite','navy','oldlace','olive','olivedrab','orange','orangered','orchid','palegoldenrod','palegreen','paleturquoise','palevioletred','papayawhip','peachpuff','peru','pink','plum','powderblue','purple','rebeccapurple','red','rosybrown','royalblue','saddlebrown','salmon','sandybrown','seagreen','seashell','sienna','silver','skyblue','slateblue','slategray','slategrey','snow','springgreen','steelblue','tan','teal','thistle','tomato','turquoise','violet','wheat','white','whitesmoke','yellow','yellowgreen'];
		var hex = ['000000','f0f8ff','faebd7','00ffff','7fffd4','f0ffff','f5f5dc','ffe4c4','ffebcd','0000ff','8a2be2','a52a2a','deb887','5f9ea0','7fff00','d2691e','ff7f50','6495ed','fff8dc','dc143c','00ffff','00008b','008b8b','b8860b','a9a9a9','a9a9a9','006400','bdb76b','8b008b','556b2f','ff8c00','9932cc','8b0000','e9967a','8fbc8f','483d8b','2f4f4f','2f4f4f','00ced1','9400d3','ff1493','00bfff','696969','696969','1e90ff','b22222','fffaf0','228b22','ff00ff','dcdcdc','f8f8ff','ffd700','daa520','808080','808080','008000','adff2f','f0fff0','ff69b4','cd5c5c','4b0082','fffff0','f0e68c','e6e6fa','fff0f5','7cfc00','fffacd','add8e6','f08080','e0ffff','fafad2','d3d3d3','d3d3d3','90ee90','ffb6c1','ffa07a','20b2aa','87cefa','778899','778899','b0c4de','ffffe0','00ff00','32cd32','faf0e6','ff00ff','800000','66cdaa','0000cd','ba55d3','9370db','3cb371','7b68ee','00fa9a','48d1cc','c71585','191970','f5fffa','ffe4e1','ffe4b5','ffdead','000080','fdf5e6','808000','6b8e23','ffa500','ff4500','da70d6','eee8aa','98fb98','afeeee','db7093','ffefd5','ffdab9','cd853f','ffc0cb','dda0dd','b0e0e6','800080','663399','ff0000','bc8f8f','4169e1','8b4513','fa8072','f4a460','2e8b57','fff5ee','a0522d','c0c0c0','87ceeb','6a5acd','708090','708090','fffafa','00ff7f','4682b4','d2b48c','008080','d8bfd8','ff6347','40e0d0','ee82ee','f5deb3','ffffff','f5f5f5','ffff00','9acd32'];

if (toColorType.toLowerCase() == "zim") {
			var i = zim.colorsHex.indexOf(color);
			if (i<0) return color;
			return zim.colors[zim.colorsHex.indexOf(color)];
		}

var answer;
		if (answer = color.match(/rgba$(.*)$/)) {
			if (zot(alpha)) {
				color = "rgb("+answer[1]+")"; // includes alpha but does not matter
			} else {
				var c = color.split(",");
				c[3] = alpha+")";
				return c.join(",");
			}
		}

function rgbToHex(rgb) {
			var hex = Number(rgb).toString(16);
			if (hex.length < 2) {
				hex = "0" + hex;
			}
			return hex;
		}

function getRGB(string) {
			var c = string.split(",");
			var red = rgbToHex(c[0]);
			var green = rgbToHex(c[1]);
			var blue = rgbToHex(c[2]);
			return [red, green, blue];
		}

if (zot(alpha)) alpha == 1;
		if (answer = color.match(/rgb$(.*)$/)) {
			if (toColorType == "rgba") {
				var c = color.split(")");
				return c[0]+","+alpha+c[1];
			} else if (toColorType == "hex") {
				var colors = getRGB(answer[1]);
				return "#" + colors[0] + colors[1] + colors[2];
			} else if (toColorType == "hexNumber") {
				var colors = getRGB(answer[1]);
				return parseInt(colors[0]+colors[1]+colors[2], 16);
			} else if (toColorType == "string") {
				var color = getRGB(answer[1]).join("").toLowerCase();
				var index = hex.indexOf(color);
				if (index == -1) return "#" + color;
				else return colors[index];
			} else return color;
		}

if (toColorType == "rgb" || toColorType == "rgba") {
			function hexToRgbA(hex){ // kennebec on StackOverflow
				var c;
				if(/^#([A-Fa-f0-9]{3}){1,2}$/.test(hex)){
					c= hex.substring(1).split('');
					if(c.length== 3){
						c= [c[0], c[0], c[1], c[1], c[2], c[2]];
					}
					c= '0x'+c.join('');
					if (toColorType == "rgb") {
						return 'rgb('+[(c>>16)&255, (c>>8)&255, c&255]+')';
					} else {
						return 'rgba('+[(c>>16)&255, (c>>8)&255, c&255].join(',')+','+alpha+')';
					}

} else {
					if (toColorType == "rgb") {
						return "rgb(0,0,0)";
					} else {
						return "rgba(0,0,0,1)";
					}
				}
			}
			if (color.charAt(0)=="#") {
				return hexToRgbA(color);
			} else {
				return hexToRgbA(zim.convertColor(color));
			}
		} else if (toColorType == "hex") {
			if (color.charAt(0)=="#") return color; // already hex
		} else if (toColorType == "hexNumber") {
			if (color.charAt(0)=="#") {
				return parseInt(color.replace(/^#/, ''), 16);
			}	
		} else {
			if (color.charAt(0)=="#") {
				color = color.replace("#","");
				if (color.length == 3) {
					color = color.charAt(0)+color.charAt(0)+color.charAt(1)+color.charAt(1)+color.charAt(2)+color.charAt(2);
				}
			}
		}
		if (toColorType == "string") {
			var index = hex.indexOf(color);
			if (index == -1) return "#" + color;
			else return colors[index];
		} else if (toColorType == "hexNumber") {
			return parseInt(hex[colors.indexOf(color.toLowerCase())!=-1?colors.indexOf(color):0], 16);
	    } else {			
			return "#"+hex[colors.indexOf(color.toLowerCase())!=-1?colors.indexOf(color):0];
		}
	};

zim.colorRange = function(color1, color2, ratio) {
		// thanks Chris Dolphin - StackOverflow
		// modified by Dan Zen to use hex input and output
		// possibly converting and converting back - but not quite...
		if (zot(ratio)) ratio = .5;
		ratio = Math.max(0, Math.min(1, ratio));
		if (zot(color1)) color1 = "white";
		if (zot(color2)) color2 = "black";
		var c1 = zim.convertColor(color1, "rgb");
		var c2 = zim.convertColor(color2, "rgb");
		var color1 = c1.substring(4, c1.length - 1).split(',');
		var color2 = c2.substring(4, c2.length - 1).split(',');
		var difference;
		var newColor = "#";
		var c;
		for (var i=0; i<color1.length; i++) {
			difference = color2[i] - color1[i];
			c = Math.floor(parseInt(color1[i], 10) + difference * ratio).toString(16);
			if (c.length < 2) c = "0"+c;
			newColor += c;
		}
		return newColor;
	};

zim.lighten = function(color, ratio) {
		if (zot(ratio)) ratio = .5;
		if (ratio >= 0) return zim.colorRange(String(color), "#FFFFFF", ratio);
		else return zim.colorRange(String(color), "#000000", -ratio);
	};

zim.darken = function(color, ratio) {
		if (zot(ratio)) ratio = .5;
		if (ratio >= 0) return zim.colorRange(String(color), "#000000", ratio);
		else return zim.colorRange(String(color), "#ffffff", -ratio);
	};

zim.toAlpha = function(color, ratio) {
		if (zot(ratio)) ratio = .5;
		return zim.convertColor(String(color), "rgba", ratio);
	};

zim.pointAlongCurve = function(points, ratio, getAngle, even) {
	if (!points || !points[0] || !points[1] || !points[2] || !points[3]) return;

if (zot(even)) even = false;
	var cubic = new zim.Bezier(points[0],points[1],points[2],points[3]);
	if (even) {
		var x=cubic.mx(ratio);
		var y=cubic.my(ratio);
	} else {
		var x=cubic.x(ratio);
		var y=cubic.y(ratio);
	}
	if (getAngle) {
		var lastRatio = ratio-.05;
		var nextRatio = ratio+.05;
		if (lastRatio < 0) lastRatio = 0;
		if (nextRatio > 1) nextRatio = 1;
		if (even) {
			var x0=cubic.mx(lastRatio);
			var y0=cubic.my(lastRatio);
			var x2=cubic.mx(nextRatio);
			var y2=cubic.my(nextRatio);
		} else {
			var x0=cubic.x(lastRatio);
			var y0=cubic.y(lastRatio);
			var x2=cubic.x(nextRatio);
			var y2=cubic.y(nextRatio);
		}
		var angle = zim.angle(x0, y0, x2, y2);
		return({x:x,y:y,angle:angle});
	}
	return({x:x,y:y});
};

zim.distanceAlongCurve = function(points) {
		// Thanks David F. Knight in OpenGl.org forumn
		// points are [startPt, controlPt1, controlPt2, endPt]
		var chord = zim.dist(points[0], points[3]);
		var controlDist = zim.dist(points[0], points[1]) + zim.dist(points[1], points[2]) + zim.dist(points[2], points[3]);
		return (chord + controlDist)/2;
	};

zim.closestPointAlongCurve = function(point, segmentPoints, num, interpolate, percentage) {
		var closest = 10000000;
		var closestTestPoint;
		var index = 0;
		var secondaryIndex = 0;
		if (zot(num)) num = 10;
		zim.loop(segmentPoints, function(points, i, t) {
			// add num more points to estimate closest
			var cubic = new zim.Bezier(points[0],points[1],points[2],points[3]);
			zim.loop(num, function (j, total) {
				// var d = zim.dist(point, zim.pointAlongCurve(segmentPoints(that.points[i], that.points[i<t-1?i+1:0]), j/10));
				// var testPoint = zim.pointAlongCurve(points, j/total);
				// var d = zim.dist(point, testPoint);
				var testPoint = {x:cubic.x(j/total), y:cubic.y(j/total)};
				var d = zim.dist(point, testPoint);
				if (d < closest) {
					closest = d;
					closestTestPoint = testPoint;
					index = i;
					secondaryIndex = j;
				}
			});
		});
		if (percentage) {
			return (index*num+secondaryIndex)/(segmentPoints.length*num)*100;
		} else if (interpolate) {
			return closestTestPoint;
		}
		return index;

};

zim.mobile = function(orientation) {
		if (typeof MOBILE != "undefined" && MOBILE!="default") return MOBILE;
		if (!zot(zim.MOBILE) && zim.MOBILE!="default") return zim.MOBILE;
		if (zot(orientation)) orientation = true;
		if (/ip(hone|od|ad)/i.test(navigator.userAgent)) return "ios";
		if (/android|nexus/i.test(navigator.userAgent)) return "android";
		if (/blackberry/i.test(navigator.userAgent)) return "blackberry";
		if (/nokia|phone|mobile/i.test(navigator.userAgent)) return "windows";
		if (/opera mini|webos/i.test(navigator.userAgent)) return "other";
		if (orientation && window.orientation !== undefined) {
			if (/safari/i.test(navigator.userAgent)) return "ios";
			return true;
		}
		return false;
	};

zim.Ticker = {
		stages:null,
		myUpdate: null,
		alwaysList:new zim.Dictionary(),
		list:new zim.Dictionary(),
		wire:new zim.Dictionary(),
		setFPS: function(m, d) {
			if (zot(m) && zot(d)) {
				m = 60; d = 60;
			} else if (zot(m)) {
				m = 60;
			} else if (zot(d)) {
				d = m;
			}
			zim.Ticker.framerate = createjs.Ticker.framerate = (zim.mobile()) ? m : d;
		},
		setTimingMode: function(mode) {
			createjs.Ticker.timingMode = createjs.Ticker.RAF;
			if (mode == "synched") createjs.Ticker.timingMode = createjs.Ticker.RAF_SYNCHED;
			if (mode == "timeout") createjs.Ticker.timingMode = createjs.Ticker.TIMEOUT;
		},
		add: function(f, s, w) { // function, stage, wire
			var t = zim.Ticker;
			if (t.has(f, s)) return f; // don't let the same function be added twice
			if (zot(s) || !s.update) s = zdf.stage;
			if (zot(f) || typeof f !== 'function') {zog("zim.Ticker.add() - only add functions"); return;}
			if (t.list.at(s)) {t.list.at(s).push(f);} else {t.list.add(s, [f]);}
			if (!t.ticker) t.ticker = createjs.Ticker.on("tick", t.call);
			if (!t.framerate) t.setFPS();
			return f;
		},
		addWire: function (obj, data) {
			if (zot(data[0])) return obj;
			var t = zim.Ticker;
			t.wire.add(obj, data);
			// data = [target-0, prop-1, twoWay-2, setSource-3, filter-4, call-5, input-6, lastValue-7]
			// if wanting to set the source equal to the target value to start...
			var current = data[0][data[1]];
			if (data[4]) current = data[4](current, "from");
			if (data[3]) obj[data[6]] = data[7] = current;

if (!t.ticker) t.ticker = createjs.Ticker.on("tick", t.call);
			if (!t.framerate) t.setFPS();
			return obj;
		},
		rawID:{},
		raw: function(f) {
			var id = zim.makeID(7, "letters");
			-function raw(t) {f(t); zim.Ticker.rawID[id] = requestAnimationFrame(raw);}();
			return id;
		},
		removeRaw: function(id) {
			cancelAnimationFrame(zim.Ticker.rawID[id]);
			delete zim.Ticker.rawID[id];
		},
		call: function(e) {
			var t = zim.Ticker;
			var s, functions;
			var stages = []; // list of stages to update
			for (var i=0; i<t.list.length; i++) {
				s = t.list.objects[i]; // stage
				functions = t.list.values[i]; // list of functions for the stage
				for (var j=0; j<functions.length; j++) {
					functions[j](e);
				}
				var u = false;
				if (t.alwaysList.at(s)) {
					u=true;
				} else if (functions.length > 0) {
					if (zot(t.update) && (!zim.OPTIMIZE&&(zns||!OPTIMIZE))) {
						u=true;
					} else if (t.update) {
						u=true;
					}
				}
				if (u && stages.indexOf(s) < 0) stages.push(s);
			}

// check for wire
			// data = [target-0, prop-1, twoWay-2, setSource-3, filter-4, call-5, input-6, lastValue-7]
			for (var i=t.wire.length-1; i>=0; i--) {
				var obj = t.wire.objects[i]; // object
				var data = t.wire.values[i]; // data
				if (data) {
					var current = obj[data[6]];
					if (current != data[7]) {
						if (data[4]) current = data[4](current, "to", data[7]);
						data[0][data[1]] = data[7] = current;
						if (data[5]) data[5](current);
						s = data[0].stage;
						if (s && stages.indexOf(s) < 0) stages.push(s);
					}
					if (data[2] && data[0]) { // twoWay
						current = data[0][data[1]];
						// zog(data[7], current)
						if (data[7] != current) {
							if (data[4]) current = data[4](current, "from", data[7]);
							obj[data[6]] = data[7] = current;
							if (data[5]) data[5](current);
							s = obj.stage;
							if (s && stages.indexOf(s) < 0) stages.push(s);
						}
					}
				}
			}

// may have no functions to run but always is turned on
			if (t.list.length == 0) {
				for (i=0; i<t.alwaysList.length; i++) {
					s = t.alwaysList.objects[i]; // stage
					if (stages.indexOf(s) < 0) stages.push(s);
				}
			}
			var l = stages.length;
			for (var i=0; i<l; i++) {
				stages[i].update();
				// zog("updating")
			}
		},
		always: function(s) {
			var t = zim.Ticker;
			if (!t.framerate) t.setFPS();
			if (zot(s) || !s.update) s = zdf.stage;
			t.alwaysList.add(s, true);

if (!t.ticker) t.ticker = createjs.Ticker.on("tick", t.call);
		},
		alwaysOff: function(s) {
			var t = zim.Ticker;
			if (zot(s) || !s.update) s = zdf.stage;
			t.alwaysList.remove(s);
		},
		remove: function(f) {
			var t = zim.Ticker;
			if (zot(f) || typeof f !== 'function') {zog("zim.Ticker - only remove functions"); return;}
			var count = 0;
			var s;
			for (var i=0; i<t.list.length; i++) {
				s = t.list.objects[i]; // stage
				var index = t.list.values[i].indexOf(f);
				if (index > -1) {
					t.list.values[i].splice(index,1);
				}
				count+=t.list.values[i].length;
			}
			if (t.alwaysList.length > 0 || t.list.length > 0 || t.wire.length > 0) return;
			createjs.Ticker.off("tick", t.ticker);
			t.ticker = null;
		},
		removeAll: function(s) { // functions only - not wire
			var t = zim.Ticker;
			var count = 0;
			var st;
			for (var i=0; i<t.list.length; i++) {
				st = t.list.objects[i]; // stage
				if (zot(s) || s === st) {
					t.list.values[i] = [];
				}
				count+=t.list.values[i].length;
			}
			if (t.alwaysList.length > 0 || t.list.length > 0 || t.wire.length > 0) return;
			createjs.Ticker.off("tick", t.ticker);
			t.ticker = null;
		},
		removeWire: function(obj, target, prop, input) {
			var t = zim.Ticker;
			if (zot(obj) && zot(target) && zot(prop) && zot(input)) {
				t.wire.clear(); // remove all wires
			} else {
				for (var i=t.wire.length-1; i>=0; i--) {
					var o = t.wire.objects[i];
					var data = t.wire.values[i];
					if (!data) continue;
					if (obj && o!=obj) continue;
					if (target && data[0] != target) continue;
					if (prop && data[1] != prop) continue;
					if (input && data[6] != input) continue;
					t.wire.objects.splice(i,1);
					t.wire.values.splice(i,1);
				}
			}
			if (t.alwaysList.length > 0 || t.list.length > 0 || t.wire.length > 0) return;
			createjs.Ticker.off("tick", t.ticker);
			t.ticker = null;
		},
		has: function(f,s) { // swapped params in zim 5.3.1
			if (zot(s) || !s.update) s = zdf.stage;
			return zim.Ticker.list && zim.Ticker.list.at(s) && zim.Ticker.list.at(s).indexOf(f) >= 0;
		},
		dispose: function(s) {
			var t = zim.Ticker;
			var count = 0;
			var st;
			for (var i=t.list.length-1; i>=0; i--) { // countdown when removing
				st = t.list.objects[i]; // stage
				if (zot(s) || s === st) {
					t.list.remove(s);
					t.alwaysList.remove(s);
				} else {
					count+=t.list.values[i].length;
				}
			}
			if (t.alwaysList.length > 0) return;
			if (count == 0) {createjs.Ticker.off("tick", t.ticker); t.ticker = null;}
			return true;
		}
	};
	zim.Ticker.setFPS();

Object.defineProperty(zim.Ticker, 'update', {
		get: function() {
			return zim.Ticker.myUpdate;
		},
		set: function(value) {
			var t =  zim.Ticker;
			if (typeof value != "boolean") value = null;
			t.myUpdate = value;
			if (t.myUpdate === false) {
				 cancelAnimationFrame(t.ticker);
				 // note, this overrides always()
				 // but running always() will override update = false
				 t.alwaysList = new zim.Dictionary();
			}
		}
	});

zim.drag = function(obj, boundary, overCursor, dragCursor, all, swipe, localBounds, onTop, surround, slide, slideDamp, slideSnap, reg, removeTweens, startBounds, rect, currentTarget, offStage) {
		var sig = "obj, boundary, overCursor, dragCursor, all, swipe, localBounds, onTop, surround, slide, slideDamp, slideSnap, reg, removeTweens, startBounds, rect, currentTarget, offStage";
		var duo; if (duo = zob(zim.drag, arguments, sig)) return duo;

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

var DA = zim.DRAGALL;
		if (window.DRAGALL != null) DA = window.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.numChildren && obj.numChildren>1 && obj.mouseChildren==true && !all) {
			// recall drags individually on objects
			var args = Array.prototype.slice.call(arguments);
			args[4] = true; // all
			obj.loop(function (o) {
				args[0] = o; // replace container with each child
				zim.drag.apply(null, args);
			});
			return obj;
		}

if (obj.zimDown) obj.noDrag(); // clear any previous drags
		obj.cursor = (zot(overCursor)) ? "pointer" : overCursor;
		if (zot(swipe)) swipe = false;
		if (zot(localBounds)) localBounds = false;
		if (zot(onTop)) onTop = true;
		if (zot(surround)) surround = false;
		if (zot(slide)) slide = false;
		if (zot(slideDamp)) slideDamp = .3;
		if (zot(slideSnap)) slideSnap = true;
		var snapOptions = ["horizontal", "vertical", "auto"];
		if (slideSnap !== true && snapOptions.indexOf(slideSnap) < 0) slideSnap = false;
		if (zot(reg)) reg = false;
		if (zot(removeTweens)) removeTweens = true;
		if (zot(startBounds)) startBounds = true;
		if (zot(boundary) && !zot(rect)) boundary = rect;
		
		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 upX; // mouse up translated to local
			var upY;
			var objUpX; // drag object x when mouse up
			var objUpY;
			var lastBackX; // used to calculate trajectory
			var lastBackY;
			var lastX; // used to see if sliding object is still moving
			var lastY;
			var hasMoved;
		} else {
			obj.zimDragTicker = function(){};
		}

obj._draggable = true;
		zim.setSwipe(obj, swipe);
		obj.zimBoundary = boundary;
		obj.zimLocalBounds = localBounds;
		obj.downCheck = false;		
		var moveCheck = false;

var diffX; var diffY; var point; var r;	var rLocal;

// 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 = {};
		obj.zimDown = obj.on("mousedown", function(e) {
			if (!obj.stage || obj.dragPaused) return;
			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()) {zog("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) createjs.Tween.removeTweens(dragObject);
			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) var point = new zim.Point(e.stageX/zim.scaX, e.stageY/zim.scaY);
			else var 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;

if (obj.zimBoundary) {
				if (localBounds) {
					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
			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];
				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 (!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);

function positionObject(o, x, y) {

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;

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 (localBounds) {
						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...
			if (stage && stage.type) var point = o.parent.globalToLocal(x, y);
			// case where createjs stage - does not have adjusted globalToLocal
			else var point = o.parent.globalToLocal(x*zim.scaX, y*zim.scaY);

var checkedPoint;
			if (slide && slideSnap) {
				if (slideSnap == "vertical") {
					checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);
					o.x = checkedPoint.x;
					o.y = point.y-diffY;
				} else if (slideSnap == "horizontal") {
					checkedPoint = checkBounds(o,point.x-diffX, point.y-diffY);
					o.x = point.x-diffX;
					o.y = checkedPoint.y;
				} else {					
					o.x = point.x-diffX;
					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
				o.x = checkedPoint.x;
				o.y = checkedPoint.y;
			}
			if (slide && !hasMoved && (o.slideStartX != o.x || o.slideStartY != o.y)) hasMoved = true;
		}

obj.zimPosition = positionObject;

obj.zimUp = obj.on("pressup", function(e){doUp(e);}, true);
				
		function doUp(e, outsideUp) {
			var id = "id"+Math.abs(e.pointerID+1);
			delete obj.pointers[id];
			if (!obj.downCheck || obj.dragPaused) return;
			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;
					var point = dragObject.parent.globalToLocal(x/zim.scaX, y/zim.scaY);
				} else {
					var point = new zim.Point(0,0);
				}				
				obj.downCheck = false;
				upX = point.x;
				upY = point.y;
				objUpX = dragObject.x;
				objUpY = dragObject.y;
				if (outsideUp) {
					lastBackX = upX = 0;
					lastBackY = upY = 0;
				}
				dampX.immediate(dragObject.x);
				dampY.immediate(dragObject.y);
			} else {
				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();
		}

// 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() {
			var stage = obj.stage;
			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) {
					if (dragObject.parent) {
						var point = dragObject.parent.globalToLocal(obj.dragMouseX, obj.dragMouseY);
					} else {
						var point = new zim.Point(0,0);
					}
					lastCount++;
					backX.push(point.x);
					backY.push(point.y);
					if (lastCount >= back) {
						lastBackX = backX.shift();
						lastBackY = backY.shift();
					} else {
						lastBackX = backX[0];
						lastBackY = backY[0];
					}
				} else {
					if (!obj.zimDragMoving) return;
					var desiredX = objUpX + upX-lastBackX;
					var desiredY = objUpY + upY-lastBackY;
					if (r) {
						var checkedPoint = checkBounds(dragObject, desiredX, desiredY);
						desiredX = checkedPoint.x;
						desiredY = checkedPoint.y;
					}
					if (!slideSnap) {
						var checkedPoint = checkBounds(dragObject, dampX.convert(desiredX), dampY.convert(desiredY));
						dragObject.x = checkedPoint.x;
						dragObject.y = checkedPoint.y;
						testMove(dragObject,dragObject.x,dragObject.y,dragObject.x,dragObject.y);
					} else {
						dragObject.x = dampX.convert(desiredX);
						dragObject.y = dampY.convert(desiredY);
						testMove(dragObject,dragObject.x,dragObject.y,desiredX,desiredY);
					}
				}
			};
			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;
				}
			}
		}
		return obj;
	};

zim.noDrag = function(obj, recursive) {
		if (zot(obj) || !obj.on) return;
		if (zot(recursive)) recursive = true;
		if (recursive && obj.numChildren && obj.numChildren > 1) {
			for (var i=0; i<obj.numChildren; i++) {
				var o = obj.getChildAt(i);
				undrag(o);
			}
		}
		undrag(obj); // also undrag the parent to be sure
		function undrag(obj) {
			obj.cursor = null; //"default";
			obj._draggable = false;
			zim.setSwipe(obj, true);
			obj.off("added", obj.zimAdded);
			obj.off("removed", obj.zimRemoved);
			obj.off("mousedown", obj.zimDown);
			obj.off("pressmove", obj.zimMove);
			obj.off("pressup", obj.zimUp);
			if (obj.zmu) {
				if (obj.stage) obj.stage.frame.off("mouseupplus", obj.zmu);
				else zdf.off("mouseupplus", obj.zmu);
			}		
			if (zim.Ticker) {
				if (obj.zimDragSlide) zim.Ticker.remove(obj.zimDragSlide);
				if (obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker);
			}
			obj.zimDragMoving=obj.zimAdded=obj.zimRemoved=obj.zimDown=obj.zimMove=obj.zimUp=obj.zimBoundary=obj.zimDragSlide=null;
			obj.slideStartX = obj.slideStartY = obj.zimDragImmediate = null;
			obj.dragMouseX = obj.zimPosition = obj.dragMouseY = obj.zimDown = obj.zimUp = null;
			obj.zimDragTicker = obj.zimDragSlide = null;
		}
		return obj;
	};

zim.noMouse = function(obj) {
		obj.zimLastMouse = obj.mouseChildren;
		obj.mouseChildren = false;
		obj.mouseEnabled = false;
		return obj;
	};

zim.effect = function(obj, effect, x, y, width, height) {
		if (zot(effect)) return obj;		
		
		if (zot(obj.effects)) obj.effects = {};
        if (!Array.isArray(effect)) effect = [effect];   
        var customCount = 0;     
        for (var j=0; j<effect.length; j++) {
            var eff = effect[j];
			if (!eff.type) {
				if (eff instanceof createjs.BlurFilter) eff.type = "BlurEffect";
				else if (eff instanceof createjs.ColorFilter) eff.type = "ColorEffect";
				else if (eff instanceof createjs.AlphaMaskFilter) eff.type = "AlphaEffect";
				else if (eff instanceof createjs.ColorMatrixFilter) eff.type = "MultiEffect";		
	            else if (zot(eff.type)) eff.type = "custom"+customCount++;
			}
			var e = eff.type.replace(/effect/i, "");
            obj.effects[e.toLowerCase()] = eff;
        }
        obj.filters = [];
        for (var i in obj.effects) {
            obj.filters.push(obj.effects[i]);
        } 
        obj.cache(x,y,width,height); 
		return obj;
	};

zim.noEffect = function(obj, effects, cache) {
		if (zot(cache)) cache = false;
		if (zot(effects)) {
			var storeMulti;
			if (obj.effects.multi) storeMulti = obj.effects.multi;
			obj.effects = {};		
			if (storeMulti) obj.effects.multi = storeMulti;	
		} else {
			if (!obj.effects) obj.effects = {};
			if (!Array.isArray(effects)) effects = [effects];   
	        for (var j=0; j<effects.length; j++) {
				var e = effects[j].replace(/effect/i, "");
				delete obj.effects[e.toLowerCase()];
			}			
		}
		obj.filters = [];
		for (var i in obj.effects) {
			obj.filters.push(obj.effects[i]);
		} 
		if (cache || obj.filters.length > 0) {
			if (obj.updateCache) obj.updateCache();
		} else {
			if (obj.uncache) obj.uncache();
		}
		return obj;
	};

zim.setSwipe = function(obj, swipe) {
		if (zot(obj) || !obj.on) return;
		obj.zimNoSwipe = (swipe) ? null : true;
		if (obj instanceof createjs.Container) dig(obj);
		function dig(container) {
			var num = container.numChildren;
			var temp;
			for (var i=0; i<num; i++) {
				temp = container.getChildAt(i);
				temp.zimNoSwipe = obj.zimNoSwipe;
				if (temp instanceof createjs.Container) {
					dig(temp);
				}
			}
		}
		return obj;
	};

zim.removePhysics = function(obj) {
		if (zot(obj.physics)) return obj;
		if (obj == obj.physics.followObj) obj.physics.follow(null);
		obj.follow = obj.noFollow = obj.control = obj.noControl = obj.sleep = obj.wake = null;
		obj.impulse = obj.force = obj.spin = obj.torque = null;
		obj.physics.remove(obj.body);
		obj.physics = null;
		return obj;
	};

zim.hitTestPoint = function(obj, x, y, boundsCheck) {
		if (!obj.stage || zot(x) || zot(y)) return false;
		var stage = obj.stage;
		if (zot(obj) || !obj.globalToLocal) return;
		if (zot(boundsCheck)) boundsCheck = true;
		if (boundsCheck) {
			var bounds = obj.getBounds();
			if (bounds) { // faster to check if point is in bounds first
				var boundPoint = obj.globalToLocal(x,y);
				if (boundPoint.x > bounds.x + bounds.width || boundPoint.x < bounds.x) return false;
				if (boundPoint.y > bounds.y + bounds.height || boundPoint.y < bounds.y) return false;
			}
		}
		var point = {x:x, y:y};
		if (obj.image || obj.spriteSheet || obj.type == "Shape") point = obj.globalToLocal(point.x, point.y);
		else point = obj.globalToLocal(point.x*zim.scaX,point.y*zim.scaY);
		return obj.hitTest(point.x, point.y);
	};

zim.hitTestReg = function(a, b, boundsCheck) {
		if (!a.stage || !b.stage) return false;
		var stage = a.stage;
		if (zot(a) || zot(b) || !a.localToLocal || !b.localToLocal) return;
		if (zot(boundsCheck)) boundsCheck = true;

var point = b.localToGlobal(b.regX,b.regY);
		var bounds = a.getBounds();
		if (boundsCheck && bounds) { // faster to check if point is in bounds first
			// note, bounds get pre-scaled x and y - only hitTest() needs scaled
			var boundPoint = a.globalToLocal(point.x,point.y);
			if (boundPoint.x > bounds.x + bounds.width || boundPoint.x < bounds.x) return false;
			if (boundPoint.y > bounds.y + bounds.height || boundPoint.y < bounds.y) return false;
		}
		if (a.image || a.spriteSheet || a.type == "Shape") point = a.globalToLocal(point.x, point.y);
		else point = a.globalToLocal(point.x*zim.scaX,point.y*zim.scaY);
		return a.hitTest(point.x, point.y);
	};

zim.hitTestBounds = function(a, b, margin, boundsShape) {
		if (!a.stage || !b.stage) return;
		if (zot(a) || zot(b) || !a.getBounds || !b.getBounds) return;
		var boundsCheck = false;
		if (boundsShape && boundsShape.graphics) boundsCheck=true;

var aB = a.getBounds();
		var bB = b.getBounds();
		if (!aB || !bB) {
			if (zon) zogy("hitTestBounds():\n please setBounds() on both objects");
			return;
		}
		if (zot(margin)) margin = 0;
		var adjustedA = zim.boundsToGlobal(a);
		var adjustedB = zim.boundsToGlobal(b);

if (boundsCheck) {
			var g = boundsShape.graphics;
			g.c();
			g.ss(1).s("blue");
			g.r(adjustedA.x, adjustedA.y, adjustedA.width, adjustedA.height);
			g.s("green");
			g.r(adjustedB.x, adjustedB.y, adjustedB.width, adjustedB.height);
			boundsShape.stage.update();
		}
		return zim.rectIntersect(adjustedA, adjustedB, margin);

};

if (globalObj && globalObj.type && (globalObj.type=="Stage" ||  globalObj.type=="StageGL")) {
			var pTL = obj.localToLocal(oB.x, oB.y, globalObj);
			var pTR = obj.localToLocal(oB.x+oB.width, oB.y, globalObj);
			var pBR = obj.localToLocal(oB.x+oB.width, oB.y+oB.height, globalObj);
			var pBL = obj.localToLocal(oB.x, oB.y+oB.height, globalObj);			
		} else {
			if (flip) {
				var pTL = obj.globalToLocal(oB.x, oB.y);
				var pTR = obj.globalToLocal(oB.x+oB.width, oB.y);
				var pBR = obj.globalToLocal(oB.x+oB.width, oB.y+oB.height);
				var pBL = obj.globalToLocal(oB.x, oB.y+oB.height);
			} else {
				var pTL = obj.localToGlobal(oB.x, oB.y);
				var pTR = obj.localToGlobal(oB.x+oB.width, oB.y);
				var pBR = obj.localToGlobal(oB.x+oB.width, oB.y+oB.height);
				var pBL = obj.localToGlobal(oB.x, oB.y+oB.height);
			}
		}

// handle rotation
		// if (inside) { // NOT WORKING 
		// 	var newTLX = Math.max(pTL.x,pTR.x,pBR.x,pBL.x);
		// 	var newTLY = Math.max(pTL.y,pTR.y,pBR.y,pBL.y);
		// 	var newBRX = Math.min(pTL.x,pTR.x,pBR.x,pBL.x);
		// 	var newBRY = Math.min(pTL.y,pTR.y,pBR.y,pBL.y);
		// } else {
			var newTLX = Math.min(pTL.x,pTR.x,pBR.x,pBL.x);
			var newTLY = Math.min(pTL.y,pTR.y,pBR.y,pBL.y);
			var newBRX = Math.max(pTL.x,pTR.x,pBR.x,pBL.x);
			var newBRY = Math.max(pTL.y,pTR.y,pBR.y,pBL.y);
		// }

return new createjs.Rectangle(
			newTLX,
			newTLY,
			newBRX-newTLX,
			newBRY-newTLY
		);
	};

zim.cur = function(obj, type) {
		if (zot(obj)) {zog("zim methods - cur(): please provide object"); return obj;}
		if (zot(type)) type = "pointer";
		obj.cursor = type;
		return obj;
	};

zim.sha = function(obj, color, offsetX, offsetY, blur) {
		if (zot(obj)) {zog("zim methods - sha(): please provide object"); return obj;}
		if (zot(color)) color = "rgba(0,0,0,.3)";
		if (color.blur) {obj.shadow = color; return obj;} // a Shadow is passed as first parameter
		if (zot(offsetX)) offsetX = obj.width ? obj.width *.08 : 5;
		if (zot(offsetY)) offsetY = obj.height ? obj.height *.08 : 5;
		if (zot(blur)) blur = obj.width ? obj.width *.16 : 10;
		obj.shadow = new createjs.Shadow(color, offsetX, offsetY, blur);
		return obj;
	};

// converting to version 2 format with right and bottom boolean parameters
		// still will need to deal with new version 3 center values
		var right = false;
		if (horizontal == "right") right = true;
		var bottom = false;
		if (vertical == "bottom") bottom = true;

var PR = zim.POSREG;
		if (window.POSREG != null) PR = window.POSREG;
		if (zot(reg)) reg = PR;

if (zot(obj)) return;
		if (zot(reg) && zot(regX)) regX = false; // regX and regY override reg
		if (zot(reg) && zot(regY)) regY = false;
		if (!zot(reg) && zot(regX)) regX = reg;
		if (!zot(reg) && zot(regY)) regY = reg;

if (zot(add)) add = true;
		if (!zot(container) && !container.addChild) container = null;
		if (!obj.getBounds && !obj.getBounds()) {regX = regY = false;}

if (zot(container)) {
			if (obj.parent) container = obj.parent;
			else if (zdf) container = zdf.stage;
		}

if (!obj.parent && zot(x)) x = 0;
		if (!obj.parent && zot(y)) y = 0;

var resetObjCheck = false;
		if (!obj.getBounds()) {
			obj.setBounds(0,0);
			resetObjCheck = true;
		}

var resetContainerCheck = false;
		if (container && !container.getBounds()) {
			container.setBounds(0,0);
			resetContainerCheck = true;
		}

if (!zot(container) && container.addChild && add) {
			var lastBounds = container.getBounds().clone();
			function addMe() {
				if (zot(index) || (typeof index === 'number' && isNaN(index))) {
					if (!container.contains(obj)) container.addChild(obj);
				} else {
					container.addChildAt(obj, index);
				}
			}
			addMe();
			var currentBounds = container.getBounds();
			if (
				lastBounds.width!=currentBounds.width ||
				lastBounds.height!=currentBounds.height ||
				lastBounds.x!=currentBounds.x ||
				lastBounds.y!=currentBounds.y
			) {
				obj.removeFrom();
				container.setBounds(lastBounds.x, lastBounds.y, lastBounds.width, lastBounds.height); // lock bounds
				resetContainerCheck = true; // to set bounds to flex later
				addMe();
			}
		}

// deal with version 3 center values
		if (!regX && !regY) {
			if ((horizontal == "center" || horizontal == "middle") && (vertical == "center" || vertical == "middle")) {
				obj.center(container);
				obj.mov(x, y);
				if (resetObjCheck) obj.setBounds(null);
				if (resetContainerCheck) container.setBounds(null);
				return obj;
			}
		}
		if (horizontal == "center" || horizontal == "middle") {
			if (regX) obj.x = container.width / 2;
			else {
				var yy = obj.y;
				obj.center();
				obj.y = yy;
			}
			obj.mov(x);
			x = null;
			horizontal = null;
		} else {
			if (horizontal === true) right = true;
		}
		if (vertical == "center" || vertical == "middle") {
			if (regY) obj.y = container.height / 2;
			else {
				var xx = obj.x;
				obj.center();
				obj.x = xx;
			}
			obj.mov(0,y);
			y = null;
			vertical = null;
		} else {
			if (vertical === true) bottom = true;
		}
		// end version 3 adjust

if (obj.parent && obj.parent.getBounds) {
			container = obj.parent;

if (zot(x) && right==true) x = 0;
			if (zot(y) && bottom==true) y = 0;

if (!zot(x)) obj.x = x;
			if (!zot(y)) obj.y = y;
			if (zot(x) && zot(y) && !right && !bottom) {
				if (resetObjCheck) obj.setBounds(null);
				if (resetContainerCheck) container.setBounds(null);
				return obj;
			}

zim.loc = function(obj, target, y, container, index, add, localToLocal, x) {
		var sig = "obj, target, y, container, index, add, localToLocal, x";
		var duo; if (duo = zob(zim.loc, arguments, sig)) return duo;
		if (obj.type=="AC"&&zdf) {zdf.ac("loc", arguments); return obj.addTo(container, index);}
		if (zot(obj)) return;
		if (typeof target == "number") {
			x = target;
			target = null;
		}
		if (!zot(target)) {
			if (!zot(target.x)) x = target.x;
			if (!zot(target.y)) y = target.y;
		}
		if (zot(x) && zot(target)) x = obj.x;
		if (zot(y) && zot(target)) y = obj.y;

if (zot(add)) add = true;
		if (zot(container)) {
			if (obj.parent) container = obj.parent;
			else if (zdf) container = zdf.stage;
		}
		if (add && container) {
			if (!obj.parent || container != obj.parent) {
				if (zot(index) || isNaN(index)) {container.addChild(obj);}
				else {
					container.addChildAt(obj, index);
				}
			} else if (!zot(index)) {
				container.addChildAt(obj, index);
			}
		}
		if (zot(localToLocal)) localToLocal = true;
		if (target && target.parent && obj.parent && localToLocal) {
			var point = target.parent.localToLocal(x, y, obj.parent);
			x = point.x;
			y = point.y;
		}
		obj.x = x;
		obj.y = y;
		return obj;
	};

zim.mov = function(obj, x, y) {
		var sig = "obj, x, y";
		var duo; if (duo = zob(zim.mov, arguments, sig)) return duo;
		if (obj.type=="AC"&&zdf) {zdf.ac("mov", arguments); return obj;}
		if (zot(obj)) return;
		if (!zot(x)) obj.x += x;
		if (!zot(y)) obj.y += y;
		return obj;
	};

zim.bot = function(obj) {
		if (zot(obj) || !obj.parent) return obj;
		obj.parent.setChildIndex(obj, 0);
		return obj;
	};

zim.ord = function(obj, num) {
		if (zot(obj) || !obj.parent) return;
		if (zot(num)) num = 0;
		obj.parent.setChildIndex(obj, obj.parent.getChildIndex(obj)+num);
		return obj;
	};

zim.alp = function(obj, alpha) {
		if (zot(obj)) return;
		if (!zot(alpha)) {
			obj.alpha = obj.hovOriginal = alpha;			
			if (obj.tag && obj.tag.style) {
				if (obj.type!="Loader") obj.tag.style.opacity = alpha;
				if (alpha == 0) obj.tag.style.display = obj.tag.zimDisplay = "none";
				else obj.tag.style.display = obj.tag.zimDisplay = "inline-block";			
			}
		}
		return obj;
	};

zim.vis = function(obj, visible) {
		if (zot(obj)) return;
		obj.visible = visible;
		if (obj.tag && obj.tag.style) {
			if (!visible) obj.tag.style.display = obj.tag.zimDisplay = "none";
			else obj.tag.style.display = obj.tag.zimDisplay = "inline-block";			
		}
		return obj;
	};

zim.rot = function(obj, rotation, x, y) {
		if (zot(obj)) return;
		if (obj.type=="AC"&&zdf) {zdf.ac("rot", arguments); return obj;}
		if (!zot(rotation)) {
			if (obj.parent && (!zot(x) || !zot(y))) {
				if (zot(x)) x = obj.x;
				if (zot(y)) y = obj.y;
				var diffX = x-obj.x;
				var diffY = y-obj.y;
				var inside = obj.parent.localToLocal(x, y, obj);
				var outside = new zim.Point(obj.x, obj.y);
				obj.reg(inside.x, inside.y);
				obj.rotation=rotation;
				obj.x = x;
				obj.y = y;
				var backPoint = obj.parent.localToLocal(outside.x, outside.y, obj);
				obj.reg(backPoint.x, backPoint.y);
				obj.x = outside.x;
				obj.y = outside.y;
			} else {
				obj.rotation=rotation;
			}
		}
		return obj;
	};

zim.reg = function(obj, regX, regY, still) {
		if (zot(obj)) return;
		if (obj.type=="AC"&&zdf) {zdf.ac("reg", arguments); return obj;}
		var lastRegX = obj.regX;
		var lastRegY = obj.regY;
		if (!zot(regX)) obj.regX = regX;
		if (!zot(regY)) obj.regY = regY;
		if (still && obj.parent) {
			var p = obj.localToLocal(lastRegX, lastRegY, obj.parent);
			obj.x -= p.x-obj.x;
			obj.y -= p.y-obj.y;
		}
		return obj;
	};

zim.sca = function(obj, scale, scaleY) {
		if (obj.type=="AC"&&zdf) {zdf.ac("sca", arguments); return obj;}
		if (zot(obj) || zot(obj.scaleX)) return obj;
		if (zot(scale)) scale = obj.scaleX;
		if (zot(scaleY)) scaleY = scale;
		obj.scaleX = scale; obj.scaleY = scaleY;
		return obj;
	};

zim.animate = function(target, props, time, ease, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, sequence, sequenceCall, sequenceParams, sequenceReverse, ticker, cjsProps, css, protect, override, from, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, sequenceWait, rate, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck) {
		var sig = "target, props, time, ease, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, sequence, sequenceCall, sequenceParams, sequenceReverse, ticker, cjsProps, css, protect, override, from, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, sequenceWait, rate, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck";

if (target && (target.props || target.obj)) {
			var duo; if (duo = zob(zim.animate, arguments, sig)) return duo;
		}
		if (target.type=="AC"&&zdf) {zdf.ac("animate", arguments); return target;}

if (!target) return; // 10.9.0 ?
		var AN = zim.ANIMATE;
		if (window.ANIMATE != null) AN = window.ANIMATE;
		if (!AN) return target;

if (zot(timeCheck)) timeCheck = true;
		// last param is noWarning - sent internall as false by wiggle for instance
		var timeType = getTIME(null, timeUnit, null, null, zot(timeCheck)?false:!timeCheck);

if (loopCount > 0) loop = true;

var startArguments = arguments;
		var startParams = Array.prototype.slice.call(arguments);

if (zot(props) && !zot(obj)) props = obj; // conversion of 7.1 props parameter to pre 7.1 obj parameter
		obj = props;
		if (zot(obj)) {if (zon) {zog("animate() - need props");} return target;}

// added ZIM 10.7.0
		if (target.type == "BeadsContainer") {
			if (zot(sequence)) sequence = 0;
		}

// added ZIM 10.8.0Added a rate parameter near the end of animate() to change the rate of speed of the animation
		if (zot(pauseOnBlur)) pauseOnBlur = true;
		if (target.type == "Tone") pauseOnBlur = false;
		if (pauseOnBlur) {
			if (zot(zim.blurCheck)) zim.setBlurDetect();
			zim.pauseAnimateOnBlur = true;
		}

// zik supports passing array of options or an object with min, max, integer, negative properties and zik will pick or calculate a random value
		if (!zot(sequence) && target.addChild) {
			// do not process ZIM VEE until individual animates are called
		} else {
			time = zim.Pick.choose(time);
			ease = zim.Pick.choose(ease);
			wait = zim.Pick.choose(wait);
			loopCount = zim.Pick.choose(loopCount);
			loopWait = zim.Pick.choose(loopWait);
			rewind = zim.Pick.choose(rewind);
			rewindWait = zim.Pick.choose(rewindWait);
			if (zot(rewindTime)) rewindTime = time;
			else rewindTime = zim.Pick.choose(rewindTime);
			sequenceReverse = zim.Pick.choose(sequenceReverse);
			from = zim.Pick.choose(from);
			set = zim.Pick.choose(set);
			// when sequence recalls animate() some of have been put in cjsProps and not in main params like above
			var zikTypes = ["loopCount","loopWait","rewind","rewindWait"];
			for (var prop in cjsProps) {
				if (zikTypes.indexOf(prop) >= 0) cjsProps[prop] = zim.Pick.choose(cjsProps[prop]);
			}
		}

// CJSPROPS
		// convert loop and rewind properties into the legacy cjs props object
		var newProps = {override: ((!zot(target) && !zot(target.zimX) && !zot(obj.x)) || (!zot(target) && !zot(target.zimY) && !zot(obj.y)))};
		if (!zot(loop)) newProps.loop = loop;
		if (!zot(loopCount)) newProps.count = loopCount; // note prop is count
		if (!zot(loopWait)) newProps.loopWait = loopWait;
		if (!zot(loopCall)) newProps.loopCall = loopCall;
		if (!zot(loopWaitParams)) newProps.loopWaitParams = loopWaitParams;
		if (!zot(loopWaitCall)) newProps.loopWaitCall = loopWaitCall;
		if (!zot(loopParams)) newProps.loopParams = loopParams;
		if (!zot(loopPick)) newProps.loopPick = loopPick;
		if (!zot(rewind)) newProps.rewind = rewind;
		if (!zot(rewindWait)) newProps.rewindWait = rewindWait;
		if (!zot(rewindCall)) newProps.rewindCall = rewindCall;
		if (!zot(rewindParams)) newProps.rewindParams = rewindParams;
		if (!zot(rewindWaitCall)) newProps.rewindWaitCall = rewindWaitCall;
		if (!zot(rewindWaitParams)) newProps.rewindWaitParams = rewindWaitParams;
		if (!zot(props)) newProps = zim.merge(newProps, cjsProps); // cjsProps to overwrite
		cjsProps = newProps;
		
		// convert dot property format
		zim.loop(obj, function (o, v) {
			if (typeof o == "string") {
				var sp = o.split("."); // add a dot at start for CreateJS dot plugin
				if (sp.length > 1 && o.substr(0,1)!=".") {
					obj["."+o] = v;
					delete obj[o];
					o = "."+o;
				}
				// handle createjs needing + sign (sigh) for dot plugin
				if (sp.length > 1 && typeof v == "string") {
					var sub = v.substr(0,1);
					if (sub != "+" && sub != "-") obj[o] = "+" + v;
				}
			}
		});

// handle getting value with dot property format
		// (target, "rotation.x") for instance
		function getValue(what, prop) {
			if (prop.substr(0,1) == ".") {
				var dots = prop.split(".");
				var lastdot = what;
				for (var i=1; i<dots.length; i++) {
					lastdot = lastdot[dots[i]];
				}
				return lastdot;
			} else {
				return what[prop];
			}
		}

// handle setting value with dot property format
		// (target, "rotation.x", 200) for instance
		function setValue(what, prop, val) {
			if (prop.substr(0,1) == ".") {
				var dots = prop.split(".");
				var lastdot = what;
				for (var i=1; i<dots.length-1; i++) {
					lastdot = lastdot[dots[i]];
				}
				lastdot[dots[dots.length-1]] = val;
			} else {
				what[prop] = val;
			}
		}

// this was down below but meant series was always starting from last tween's zimTweenOriginals
		target.zimTweenOriginals = {};

// SEQUENCE HANDLING
		// handle multiple targets first if there is an array
		// this just recalls the animate function for each element delayed by the sequence parameter
		// if (zot(sequence)) sequence = 0;
		var sequenceTarget;
		if (!zot(sequence) && target.addChild) { // container with sequence so convert target to array
			var newTarget = [];
			for (var i=0; i<target.numChildren; i++) {
				newTarget.push(target.getChildAt(i));
			}
			sequenceTarget = target;
			target = newTarget;
		}

if (target instanceof Array) {
			if (sequenceReverse) target.reverse();
			var currentTarget = 0;
			for (var i=0; i<target.length; i++) {

var tar = target[i];
				if (from) {
					var val;
					tar.zimObj = {};
					for (var prop in obj) {
						if (extraTypes.indexOf(prop) >= 0) val = obj[prop];
						else val = zim.Pick.choose(obj[prop]);
						tar.zimObj[prop] = tar[prop];

// calculate relative -- ZIM 10.7.1 patch
						if (typeof val == "string") {
							var newStart;
							if (tar.zimLastObj && !zot(tar.zimLastObj[prop])) newStart = tar.zimLastObj[prop];
							else newStart = tar[prop];
							val = newStart + Number(val.replace(/\s/g,""));
						}
						if (tar.zimLastObj) tar.zimLastObj[prop] = rewind?tar.zimTweenOriginals[prop]:obj[prop];
						tar[prop] = val;
					}
				} else {
					tar.zimObj = {};
					for (var prop in obj) {
						if (extraTypes.indexOf(prop) >= 0) tar.zimObj[prop] = obj[prop];
						// else tar.zimObj[prop] = zim.Pick.choose(obj[prop]);
						else tar.zimObj[prop] = obj[prop]; // let pick go through... 10.8.0
					}
				}
				var seqTime = i*sequence;
				if (i==0 && sequence!=0) seqTime = timeType=="s"?.02:20; // patched in 10.7.0 and 10.7.1

zim.animate(tar, tar.zimObj, time, ease, (i==target.length-1?call:null), (i==target.length-1?params:null), wait, waitedCall, waitedParams, null, null, null, null, null, null, null, loopPick, null, null, null, null, null, null, rewindTime, rewindEase, null, sequenceCall, sequenceParams, null, ticker, zim.copy(cjsProps), css, protect, override, null, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, seqTime, rate, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck); // do not send from!

}
			return sequenceTarget;
		}

// DEFAULTS
		var t = time;
		var t2 = rewindTime;
		if (zot(t)) t = timeType=="s"?1:1000;
		if (zot(rewindTime)) rewindTime = t2 = t;
		if (zot(ease)) ease = "quadInOut";
		if (zot(wait)) wait = 0;
		if (zot(rewindWait)) rewindWait = 0;
		if (zot(cjsProps)) cjsProps = {override: (!zot(target.zimX) && !zot(obj.x) || !zot(target.zimY) && !zot(obj.y))};
		if (zot(params)) params = target;
		if (zot(ticker)) ticker = true;
		if (zot(css)) css = false;
		if (zot(protect)) protect = false;
		if (zot(from)) from = false;
		if (zot(set)) set = {};
		if (set.scale) {set.scaleX = set.scaleY = set.scale; delete set.scale;}
		if (!zot(override)) cjsProps.override = override;
		if (zot(drag)) drag = false;
		if (zot(startPaused)) startPaused = drag?true:false;
		if (zot(dynamic)) dynamic = false;
		if (zot(clamp)) clamp = true;
		if (zot(clean)) clean = true;
		
		if (zot(rate)) rate = 1;	
		// tweens are separated - this is used to set the CreateJS timeScale	
		// the rate parameter is not used after this 
		// the rate property sets the target.futureRate 
		// but also applies the timeScale to all tweens on the object
		// individual timeScale can be set by using target.zimTweens[id].timeScale = 2; 
		// after the rate has been called
		target.futureRate = rate; 
		
		var tween;
		var idSet;
		var providedID;
		
		
		// ANIMATION SERIES HANDLING
		// if an array is passed in to animate() as the obj
		// then animate treats this as an animation series
		// [{target:circle, obj:{alpha:0}, time:1000}, {target:rect, obj:{alpha:0}, time:1000},]

if (obj instanceof Array) {
			var currentCount = 1;
			if (obj.length == 0) return this;
			var starts;
			var lastParamTarget;

prepareSeries();
			prepareIds();
			runMaster();

// store all props in seriesTweens for target
				// and all the calls in seriesCalls (including last call)
				// used in endTween() method
				if (target && !target.seriesTweens) {
					target.seriesTweens = [];
					target.seriesCalls = [];
					target.seriesParams = [];
				}
				var o;
				for (var i=0; i<obj.length; i++) {
					o = obj[i];
					if (o.target) {
						if (!o.target.seriesTweens) o.target.seriesTweens = [];
						if (!o.target.seriesCalls) o.target.seriesCalls = [];
						if (!o.target.seriesParams) o.target.seriesParams = [];
						o.target.seriesTweens.push(o.props);
						o.target.seriesCalls.push(o.call);
						o.target.seriesParams.push(o.params);
					} else {
						target.seriesTweens.push(o.props);
						target.seriesCalls.push(o.call);
						target.seriesParams.push(o.params);
					}
				}
				target.seriesCalls.push(call);
				target.seriesParams.push(params);

// loop backwards and get original properties
				// only works if series of same object (most common)
				o = obj[0];
				var ttar;
				if (!target) ttar = o.target;
				else ttar = target;
				ttar.zimSeriesOriginals = {};
				for (i=obj.length-1; i>=0; i--) {
					o = obj[i];
					if (zot(o.props) && !zot(o.obj)) o.props = o.obj;
					o.obj = o.props;
					zim.loop(o.obj, function (oo, v) {
						// using string property name on zimTweenOriginals (just storing)
						if (oo == "path") ttar.zimSeriesOriginals[oo] = obj[oo];
						else ttar.zimSeriesOriginals[oo] = getValue(ttar, oo); // dot property
					});
				}

var froms = new zim.Dictionary();
				starts = new zim.Dictionary();
				for (var i=0; i<obj.length; i++) {
					o = obj[i];
					if (!target) target = o.target;
					if (zot(o.target)) o.target = target;
					if (zot(o.ease)) o.ease = ease;
					if (zot(o.target)) continue;

if (i==0) o.target.zimSeriesArgs = startArguments;

if (zot(o.props) && !zot(o.obj)) o.props = o.obj;
					o.obj = o.props;
					if (o.loop && (zot(o.loopCount) || o.loopCount <= 0)) {
						o.loopCount = 0;
						// this object is looping forever so no point in keeping any next objects
						obj.splice(i+1, obj.length); // obj.length may be too much but it works
					}
					if (!zot(o.obj.scale)) {
						o.obj.scaleX = o.obj.scaleY = o.obj.scale;
						delete o.obj.scale;
					}

if (o.from) {
						var firstFrom = froms.at(o.target);
						if (firstFrom) {
							if (o.set) {
								// all properties from obj go to set
								// matching firstFrom properties to to obj
								// matching set properties override firstFrom on obj
								var temp = zim.copy(o.obj);
								var merged = zim.merge(firstFrom, o.set);
								o.obj = getFroms(o.target, o.obj, merged);
								o.set = zim.merge(o.set, temp);
							} else {
								o.set = zim.copy(o.obj);
								o.obj = getFroms(o.target, o.obj, firstFrom);
							}
							o.from = false;
						} else {
							// any set properties override target properties
							froms.add(o.target, getFroms(o.target, o.obj, o.set));
						}
					}
					var startProps = {};
					for (var iii in o.obj) {
						startProps[iii] = o.set?(o.set[iii]?o.set[iii]:o.target[iii]):o.target[iii];
					}
					if (zot(starts.at(o.target))) starts.add(o.target, {});
					var newEntry = zim.merge(starts.at(o.target), startProps);
					starts.remove(o.target);
					starts.add(o.target, newEntry);
					o.masterSet = zim.copy(o.set);
				}
				if (zot(target.zimTweens)) target.zimTweens = {};
			} // end prepareSeries
			return target;
		} // end series

if (obj) {
			if (obj.x) target.zimX = true;
			if (obj.y) target.zimY = true;
		}

// SHAPE TWEEN
		if (!zot(obj.shape) && obj.shape.type == target.type && (target.type=="Blob" || target.type == "Squiggle")) {
			var targetPoints = target.pointObjects;
			var shapePoints = obj.shape.pointObjects;
			if (targetPoints.length != shapePoints.length) {
				if (zon) zogy("animate() - shapes must be of same number of points");
				delete obj.shape;
			} else {
				var shape = obj.shape;
				delete obj.shape;
				var blobShift = zot(obj.blobShift)?0:obj.blobShift;
				delete obj.blobShift;
				var first = true;
				for (var i=0; i<targetPoints.length; i++) {
					var targetPoint = targetPoints[i];
					var shapePoint = shapePoints[(targetPoints.length*20000+i+blobShift)%targetPoints.length];
					// loop through the first four elements of the points array
					// the first element is the point container
					// the second is the circle inside (we leave this alone)
					// the third and forth are the two control rectangles
					for (j=0; j<4; j++) {
						if (j==1) continue;
						var controls = targetPoint[j];
						var shapeControls = shapePoint[j];
						// animate the control to the location of shapePoint
						// this will animate the whole control container when j=0
						// and the two rectangle control handles when j=2 and j=3
						var animateParams = zim.copy(startParams);
						animateParams[0] = controls;
						animateParams[1] = {x:shapePoint[j].x, y:shapePoint[j].y, rotation:shapePoint[j].rotation};
						// ~~~~~~~~~~~~~~
						// this needs to be changed if parameter order changes!
						// ~~~~~~~~~~~~~~
						if (first) {
							animateParams[37] = true; // events
							if (controls.animateEvent) controls.off("animation", controls.animateEvent);
							controls.animateEvent = controls.on("animation", function () {
								target.update();
							});
						}
						first = false;
						zim.animate.apply(zim.animate, animateParams);
					}
				}
				if (zim.isEmpty(obj)) return target;
			}
		}

// -----------------------------
		// NORMALIZED TWEEN COMING THROUGH
				
		if (zot(target)) return;		
		if (!target.tweenStates) target.tweenStates = {all:true};	
		
		var fromCheck = false;
		
		
								
		// Handle notes
		if (obj.note) {
			if (Array.isArray(obj.note)) { // random
				zim.loop(obj.note, function (n, i) {
					if (typeof n == "string") obj.note[i] = zim.Synth.note(n);
				});
			} else if (obj.note.min) { // range
				obj.note.min = zim.Synth.note(obj.note.min);
				obj.note.max = zim.Synth.note(obj.note.max);
			} else if (obj.note.array) { // series
				zim.loop(obj.note.array, function (n, i) {
					if (typeof n == "string") obj.note.array[i] = zim.Synth.note(n);
				});
			} else if (typeof obj.note == "function") {
				if (zon) {zog("animate() - use frequency in ZIM VEE functions not note"); return target;}
			} else {
				obj.note = zim.Synth.note(obj.note);
			}
			obj.frequency = obj.note;
			delete obj.note;
		}

if (callType != "all" && callType != "main" && callType != "none") callType = "all";

if (!target.seriesTweens) {
				zim.loop(target.zimLastObj, function (o) {
					if (typeof target.zimLastObj[o] == "string") {
						target.zimLastObj[o] = target[o] + Number(target.zimLastObj[o].replace(/\s/g,""));
					}
					setValue(target, o, target.zimLastObj[o]);
				});
				// zim.loop(obj, function (o) {
				// 	if (typeof obj[o] == "string") {
				// 		obj[o] = target[o] + Number(obj[o].replace(/\s/g,""));
				// 	}
				// 	setValue(target, o, obj[o]);
				// });
				if (callType != "none" && call) call(params);
			} else {

zim.loop(target.seriesTweens, function(objSeries, i, t) {
					zim.loop(objSeries, function (o) {
						if (typeof objSeries[o] == "string") {
							objSeries[o] = target[o] + Number(objSeries[o].replace(/\s/g,""));
						}
						setValue(target, o, objSeries[o]);
					});
					if (callType == "all") {
						if (target.seriesCalls[i]) target.seriesCalls[i](target.seriesParams[i]);
					}
				});
				if (callType != "none") {
					var lastCall = target.seriesCalls[target.seriesCalls.length-1];
					if (lastCall) lastCall(target.seriesParams[target.seriesParams.length-1]);
				}
				target.seriesTweens = null;
				target.seriesCalls = null;
				target.seriesParams = null;
			}

if (target.stage) target.stage.update();
			return target;
		};
		effectCheck = false;
		zim.loop(obj, function (o, v) {
			// using string property name on zimTweenOriginals (just storing)
			if (o == "path") target.zimTweenOriginals[o] = obj[o];
			else target.zimTweenOriginals[o] = getValue(target, o); // dot property
			// if (target.effects) {	// commented because might be animating property before ever setting it		
				// replacing property that auto updates with property (Batch) that does not auto update - so we later batch the update
				if (o.match("hue")) {obj["hueBatch"] = v; delete obj.hue; effectCheck = true;}
				else if (o.match("saturation")) {obj["saturationBatch"] = v; delete obj.saturation; effectCheck = true;}
				else if (o.match("brightness")) {obj["brightnessBatch"] = v; delete obj.brightness; effectCheck = true;}
				else if (o.match("contrast")) {obj["contrastBatch"] = v; delete obj.contrast; effectCheck = true;}
				else if (o.match(/^.effects/)) {effectCheck = true;}
			// } 
		});
		
			
		target.resetTween = function(paused) {
			if (zot(paused)) paused = true;
			target.pauseAnimate();
			target.percent = null; // added ZIM Cat 04 patch
			target.startPercent = null;
			var origins = target.zimSeriesOriginals?target.zimSeriesOriginals:target.zimTweenOriginals;
			zim.loop(origins, function (o) {
				// actually needing to set real property on target
				if (o == "path") {
					target.percentComplete = 0;
					target.zimPath = origins[o];
					var startPoint;
					// if using traverse, a zimStartPercent is available
					if (target.zimStartPercent) startPoint = target.zimPath.getCurvePoint(target.zimStartPercent/100);
					else startPoint = target.zimPath.getCurvePoint(target.zimStartPercent/100);
					// target.zimPath.pointCircles[0]; // first point
					if (startPoint) target.loc(startPoint.x, startPoint.y);
				}
				else setValue(target, o, origins[o]);
			});
			target.zimLastObj = null; // otherwise relative is wrong
			// need to actually put target at start point in case animation is done
			if (target.stage) target.stage.update();

target.stopAnimate();
			// path is removed from original object so add it back
			if (target.zimPath) startParams[1].path = target.zimPath;
			if (!zot(target.zimStartRotation)) target.rotation = target.zimStartRotation;
			target.zimStartRotation = null;
			if (!zot(target.zimStartScaleX)) target.scaleX = target.zimStartScaleX;
			target.zimStartScaleX = null;
			if (!zot(target.zimStartScaleY)) target.scaleY = target.zimStartScaleY;
			target.zimStartScaleY = null;
			zim.animate.apply(null, target.zimSeriesArgs?target.zimSeriesArgs:startParams);
			target.pauseAnimate(paused);
			return target;
		};

target.replayTween = function() {
			target.resetTween(false);
			return target;
		};

if (obj.path || dynamic) {
			// can't risk turning percentComplete off when animation ends as only one per all animations
			// instead, evaluate how percentComplete is set when starting an animation
			// if there is a value and no getter setter or a value has been changed when not tweening
			// (this last is because the getter setter may have previously been set - once set, it is not removed)
			// then assumes percentComplete is desired else sets to 0 when starting an animation
			// the startPercentComplete is then examined once the animation starts
			var startPercentComplete;
			if (target.requestedPercentComplete) startPercentComplete = target.requestedPercentComplete;
			else if (target.percentComplete && !isGetter(target, "percentComplete")) startPercentComplete = target.percentComplete;
			// the below did not work as expected with the first value being assigned if true - weird - so made above
			// var startPercentComplete = target.requestedPercentComplete //|| (target.percentComplete && !isGetter(target, "percentComplete"))?target.percentComplete:null;
			target.requestedPercentComplete = null;
			if (zot(startPercentComplete)) startPercentComplete = 0;
			target.pathRatio = 0; // could be wrong setting this to 0
			target.zimStartRotation = target.rotation;
			target.percent = null; // added ZIM Cat 04 patch
			target.startPercent = null;
		}
	
		if (css) ticker = false;
		if (zot(target.zimTweens)) target.zimTweens = {};

var stage;
		if (!css) {
			if (!target.stage) {
				if (zdf) stage = zdf.stage;
				else css = true;
			} else {
				stage = target.stage;
			}
		}

// convert color tween
		if (target.setColorRange && !zot(obj.color)) {
			var color = obj.color;
			delete obj.color;
			obj.colorRange = 1;
			target.setColorRange(target.color, color);
			target.colorRange = 0;
		}

// moved these to before protect (to catch scale convert) - ZIM Cat
		// PREPARE ZIK RANDOM VALUES PASSED IN AS ARRAY OR RAND OBJECT {min, max, integer, negative}
		var savedPicks = {};
		for (var i in obj) {
			if (extraTypes.indexOf(i) >= 0) continue; // skip for extras
			savedPicks[i] = zim.copy(obj[i]); // store pre picked to use if loopPick is true
			obj[i] = zim.Pick.choose(obj[i]);
		}
		if (!zot(obj.scale)) {
			obj.scaleX = obj.scaleY = zim.Pick.choose(obj.scale);
			delete obj.scale;
		}

if (zim.isEmpty(obj)) return; // nothing left to animate
		if (target.type != "Sprite") {
			target.paused = false;
			target.animating = true;
		}
		function addZimBusy() {
			if (!target.zimMouseEnabledCheck) {
				target.zimMouseEnabledCheck = true;
				target.zimLastMouseEnabled = target.mouseEnabled;
			}
			target.mouseEnabled = false;
			setTimeout(function() {
				if (!target.zimBusy) target.zimBusy = {};
				for(var o in obj) {
					target.zimBusy[o] = true;
				}
				target.zimMouseEnabledCheck = null;
				target.mouseEnabled = target.zimLastMouseEnabled;
			}, 70);
		}
		if (protect || cjsProps.loop || cjsProps.rewind) addZimBusy();

// IDS and IDSETS
		// this is for ids and idSets on this target
		// a single tween for an id does not get an idSet
		// a second tween for the same id gets an idSet
		// the original id is the id for the idSet
		prepareIds();
		function prepareIds() {
			if (zot(id)) {
				id = zim.makeID(10);
			} else {
				id = String(id);
				providedID = id;
			}
			if (zot(target.zimIdSets)) target.zimIdSets = {};
			if (!zot(target.zimIdSets[id])) { // already an idSet
				idSet = id;
				id = zim.makeID(10);
				target.zimIdSets[idSet].push(id);
			} else if (!zot(target.zimTweens[id])) { // not an idSet but already a tween so make an idSet
				idSet = id;
				id = zim.makeID(10);
				// var idSet = target.zimTweens[id].zimIdSet;
				target.zimIdSets[idSet] = [idSet]; // add original into set
				target.zimTweens[idSet].zimIdSet = idSet; // reference back to idSet
				target.zimIdSets[idSet].push(id); // push the second one in
			} // else nothing - id is not currently part of idSet
		}

extraTypes.shift(); // take off extra for later
		for (i in set) set[i] = zim.Pick.choose(set[i]);
		for (i in cjsProps) {
			if (i=="waitedCall" || i=="waitedParams" || i=="loopCall" || i=="rewindCall" || i=="loopWaitCall" || i=="rewindWaitCall") continue;
			cjsProps[i] = zim.Pick.choose(cjsProps[i]);
		}

// In ZIM Cat 00 we moved prepareRelative to tween section to handle loopPick 
		// In ZIM Cat 02 patch we moved getFrom() to at end of preparing relative to fix froms based on relative
		// In ZIM Cat 03 we repatched Cat 02 and 03 because if a series is set then we need to getFrom() before the wait in tweens
		// so we call prepareRelative2() later in the tweens to both set relatives and froms after loopPick
		prepareRelative();
		function prepareRelative() {
			// PREPARE RELATIVE VALUES PASSED IN AS STRINGS
			relativeAdjust();
			relativeSetAdjust();
			if (target.seriesTweens) target.seriesTweens[0] = obj;			
			if (from && !fromCheck) obj = getFroms(target, obj, set, true);
		}
		function prepareRelative2() {
			relativeAdjust();			
			if (from && !fromCheck) obj = getFroms(target, obj, set, true);
		}
		
		function relativeAdjust() {
			var newStart;
			if (!target.zimLastObj) target.zimLastObj = {};
			for (i in obj) {
				if (typeof obj[i] == "string") {
					if (obj[i].substr(0,1)=="+") continue; // let createjs relative through
					if (target.zimLastObj && !zot(target.zimLastObj[i])) newStart = target.zimLastObj[i];
					else newStart = target[i];
					obj[i] = newStart + Number(obj[i].replace(/\s/g,""));
				}
				target.zimLastObj[i] = rewind?target.zimTweenOriginals[i]:obj[i];
			}
		}
		function relativeSetAdjust() {
			var newStart;
			for (i in set) {
				if (typeof set[i] == "string") {
					if (set[i].substr(0,1)=="+") continue;
					if (target.zimLastObj && !zot(target.zimLastObj[i])) newStart = target.zimLastObj[i];
					else newStart = target[i];
					set[i] = newStart + Number(set[i].replace(/\s/g,""));
				}
				target.zimLastObj[i] = rewind?target.zimTweenOriginals[i]:obj[i];
			}
		}

// start NIO updates 1
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// PERCENT COMPLETE SETUP
		if (target.getBounds && zot(target.percentCompleteCheck)) {
			target.percentCompleteCheck = true;
			Object.defineProperty(target, 'percentComplete', {
				get: function() {
					if (this.zimTween) {
						return this.zimTween.duration ? this.zimTween.position / this.zimTween.duration * 100 : 0;
					} else {
						return 0;
					}
				},
				set: function(value) {
					if (this.zimTween) {

// STICK ON PATH BEFORE DRAG FIX
						immediateCheck = true;
						
						setPercent(value, true);
					} else {
						// to handle being set prior to a subsequent animation
						this.requestedPercentComplete = value;
					}
				}
			});
			Object.defineProperty(target, 'percentCompleteNoAngle', {
				get: function() {
					if (this.zimTween) {
						return this.zimTween.duration ? this.zimTween.position / this.zimTween.duration * 100 : 0;
					} else {
						return 0;
					}
				},
				set: function(value) {
					if (this.zimTween) {
						setPercent(value, false);
					} else {
						// to handle being set prior to a subsequent animation
						this.requestedPercentComplete = value;
					}
				}
			});
		}

Object.defineProperty(target, 'rate', {
			get: function() {
				return target.futureRate;
			},
			set: function(value) {
				target.futureRate = value;
				zim.loop(target.zimTweens, function(id,tw) {
					tw.timeScale = value;
				});				
			},
			configurable: true // not sure why we need to?
		});

// STICK ON PATH BEFORE DRAG FIX
			if (immediateCheck && typeof pathPercent != "undefined") pathPercent = value;
			if (target.handlePath) target.handlePath();
		}

// PATH ANIMATION SETUP
		var pathObject;
		if (!zot(obj.path) && obj.path.segmentPoints) {
			if (zot(obj.orient)) obj.orient = true;
			if (obj.orient && zot(obj.flip)) obj.flip = true;
			if (target.type == "Pen") target.infinite = true;
			target.zimOnPath = true;
			if (zot(target.pathRatio)) target.pathRatio = 0;
			if (obj.orient) {
				obj.orient = obj.path;
				obj.startOrient = obj.rotation; // ?
			}
			pathObject = obj.path;
			// ZIM 10.7.0 ---
			if (drag) {
				delete obj.path;
				delete obj.percent;
				if (zon && (target.startPercent && target.startPercent>0) || (target.percent && target.percent!=100)) zog("ZIM.animate() - startPercent and percent currently not supported with drag on path");
				// old code from 10.6.1 -
				var newPoint = pathObject.getCurvePoint(target.pathRatio, percents, segments);
				if (newPoint) {
					latestSegmentIndex = newPoint.z; // point on path before the calculated point - used with drag
					var locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
					target.x = locPoint.x;
					target.y = locPoint.y;
				}
			} else {
				if (zot(target.startPercent)) {
					target.startPercent = zim.Pick.choose(!zot(obj.startPercent)?obj.startPercent:0);
				}
				if (zot(target.percent)) {
					target.percent = zim.Pick.choose(!zot(obj.percent)?obj.percent:100);
				}
				delete obj.path;
				delete obj.percent;
			}
			// ---
			var dynamicPath = !pathObject.lockControls;
			delete obj.path;
			obj.pathRatio = 1; // this is what we are animating to
		}

// !!!!! fix for dot values

// PREPARE START VALUES - now that pathRatio is set
		// moved to prepareRelative
		// if (from) obj = getFroms(target, obj, set, true);
		function getFroms(target, obj, set, update) {
			fromCheck = true;
			// animating based on pathRatio - but API is percentComplete
			// with from set, this causes problems - so add pathRatio equal to percentComplete to set
			if (pathObject && (!zot(target.percentComplete) || (set && !zot(set.percentComplete)))) {
				if (!set) set = {};
				if (zot(set.pathRatio)) set.pathRatio = !zot(set.percentComplete) ? set.percentComplete/100 : target.percentComplete/100;
			}
			var newObj = {};
			for (i in obj) {
				if (set && !zot(set[i])) {
					newObj[i] = set[i];
				} else {
					newObj[i] = target[i];
				}
				if (update) target[i] = obj[i];
			}
			return newObj;
		}

var lastPercentComplete = target.percentComplete;
		var flipCheck = true; // if we can flip - not same as pathFlip
		var mouseCheck = false;
		var activeCheck = true;
		var latestSegmentIndex = 0;
				
		var redirect=true;
		if (!zot(obj.redirect)) {
			redirect=obj.redirect;
			delete obj.redirect;
		}

// CONTINUE PATH ANIMATION SETUP
		if (pathObject) {			
			var segments;
			var percents;
			if (!dynamicPath) {
				segments = zim.copy(pathObject.segmentPoints);
				percents = zim.copy(pathObject.segmentRatios);
			}
			// drag does not pay attention to this...
			target.currentPercent = target.startPercent + target.percent*target.pathRatio;		
			var newPointRatio = ((1000000+target.currentPercent)%100)/100;
			var newPoint = pathObject.getCurvePoint(newPointRatio, percents, segments);

if (target.parent && newPoint) {
				var locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
				target.x = locPoint.x;
				target.y = locPoint.y;
			}

// DRAG SETUP
			// Fairly complex system - to implement damping on drag
			// dragging can be done when animation is on or off
			// dragging with rewind turned on lets you drag and release to redirect animation
			// dragging with animation off lets you throw the animation
			if (drag) {
				ease = "linear";
				target.cursor = "pointer";
				var pathPercent = target.percentComplete;
				var pathDownCheck = false;
				var lastPause = startPaused?startPaused:target.paused;
				var lastForward = true;
				var currentForward = true;
				var lastPathPercent = pathPercent;
				var stage;

var pixels = 10;
				var segments = zim.copy(pathObject.segmentPoints);
				var length = 0;
				zim.loop(segments, function (point) {
					length+=zim.distanceAlongCurve(point);
				});
				var numPoints = Math.round(length/segments.length/pixels);
				var testPoints = pathObject.interpolate(numPoints, null, true, null, true);
				var currentDist = (pathPercent?pathPercent:0)/100*length;
				var targetDist = currentDist;
				var dirTest = 0;
				pathObject.zimAnimateChanged = false;
				var segmentRatios = zim.copy(pathObject.segmentRatios);
				target.zimAnimatePathChange = pathObject.on("change", function() {pathObject.zimAnimateChanged = true;});

// 10.6.0 patch to turn move target along path if not animating
				target.zimAnimatePathDown = pathObject.on("mousedown", function() {pathDownCheck=true; if (target.paused==true) mouseCheck = true;});
				target.zimAnimatePathUp = pathObject.on("pressup", function() {mouseCheck = false;});
				
				target.zimAnimateDragDown = target.on("mousedown", function (e) {					
					stage = e.target.stage;
					if (!target.amu) target.amu = stage.frame.on("mouseupplus", function() {					
						mouseCheck = false;				
					});		
					stage.mouseMoveOutside = true;
					flipCheck = false; // sometimes picking up target changes its direction - not good
					activeCheck = true;
					setTimeout(function() {
						flipCheck = true;
					}, 50);
					mouseCheck = true;

if (pathObject.zimAnimateChanged) {
						segments = zim.copy(pathObject.segmentPoints);
						length = 0;
						zim.loop(segments, function (point) {
							length+=zim.distanceAlongCurve(point);
						});
						numPoints = Math.round(length/segments.length/pixels);
						testPoints = pathObject.interpolate(numPoints, null, true, null, true);
						segmentRatios = zim.copy(pathObject.segmentRatios);
					}

pathObject.zimAnimateChanged = false;
					pathPercent = target.percentComplete;
					dampPercent.immediate(pathPercent);
					var calcPercent = dirTest = pathPercent;
					if (rewind) { // handle rewind
						if (tween.position > tween.duration/2) calcPercent = (100-pathPercent)*2;
						else calcPercent = pathPercent*2;
					}
					currentDist = (calcPercent?calcPercent:0)/100*length;
					targetDist = currentDist;
				});

target.animateReturn = function() {
					if (!rewind) {
						if (zon) zogy("animate() - animateReturn() needs rewind set to true");
						return;
					}
					lastForward = false;
					currentForward = false;
					if (target.percentComplete < 50) target.percentComplete = 100-target.percentComplete;
					target.pauseAnimate(false);
				};

target.zimAnimateDragUp = target.on("pressup", function () {
					if (target.paused==false) mouseCheck = false;
					flipCheck = false;
					setTimeout(function() {
						flipCheck = true;
					}, 50);
					// do not change currentForward if no change in dirSamples
					if (dirSamples[0] < dirSamples[4]) currentForward = true;
					else if (dirSamples[0] > dirSamples[4]) currentForward = false;
					if (!target.paused && rewind && redirect && currentForward != lastForward) {
						target.percentComplete = 100-target.percentComplete;
						lastForward = currentForward;
						// can't seem to get this to change direction when
						// dragging when paused and then unpausing direction
					}
				});

var dampPercent = new zim.Damp(pathPercent, .15);
				var lastPercent = 0;
				var dirCount = 0;
				var dirSamples = [0,0,0,0,0];

// STICK ON PATH BEFORE DRAG FIX
				var immediateCheck = false;

target.zimDragAnimateTicker = zim.Ticker.add(function () {
					if (!drag) return; // might be paused
					if (++dirCount%20) {
						dirSamples.push(targetDist);
						dirSamples.shift();
					}
					currentDist = targetDist;
					// this was still running (due to easing) when unpaused so set mouseCheck to false in pause() script to solve

// 10.6.0 patch to make pauseAnimate work again after breaking in 10.4.0 (there is another part to this patch too)
					// mouseCheck = true;

if (pathDownCheck) pathPercent = target.percentComplete; // ZIM Cat fix

if (mouseCheck || (activeCheck && target.paused==true)) {
						// STICK ON PATH BEFORE DRAG FIX (immediateCheck added)
						if (pathDownCheck || immediateCheck || (pathObject.type == "Blob" && Math.abs(lastPercent-pathPercent)>(rewind?45:90))) {
							pathDownCheck = false;
							var newPercent = pathPercent;
							dampPercent.immediate(newPercent);
							immediateCheck = false;
						} else {
							var newPercent = dampPercent.convert(pathPercent);
						}
						// target.percentComplete = newPercent;
						if (Math.abs(lastPercent-newPercent)>.1) {
							target.percentCompleteNoAngle = newPercent;
							lastPercent = newPercent;
						} else {
							target.percentCompleteNoAngle = newPercent; // changed lastPercent to newPercent
							//if (!mouseCheck) {
								activeCheck = false;
							//}
							movingCheck = false;
						}
					} else {
						activeCheck = false; // otherwise goes to last drag after animation turned off
					}

}, stage);
			}
		}
	
		// ORIENTATION SETUP
		var pathOrient;
		if (obj.orient) {
			if (obj.orient === true) {
				var oPoint = target.parent.localToGlobal(!zot(obj.x)?obj.x:target.x, !zot(obj.y)?obj.y:target.y);
				obj.orient = {x:oPoint.x, y:oPoint.y};
			}
			pathOrient = obj.orient;
			delete obj.orient;

var startAngle = target.rotation;
			target.rotation = pathObject.getPointAngle(0) + startAngle;

if (pathOrient != pathObject) {
				var orientPoint;
				if (pathOrient.parent) {
					orientPoint = pathOrient.parent.localToLocal(pathOrient.x, pathOrient.y, target.parent);
				} else {
					orientPoint = target.parent.globalToLocal(pathOrient.x, pathOrient.y);
				}
				target.rotation = zim.angle(target.x, target.y, orientPoint.x, orientPoint.y)+startAngle;
			}
		}

// FLIP SETUP
		var pathFlip;
		var startFlip;
		if (obj.flip) {
			pathFlip = obj.flip;
			delete obj.flip;
			startFlip = target.scaleX;
		}
		var pathFlipVertical;
		var startFlipVertical;
		if (obj.flipVertical) {
			pathFlipVertical = obj.flipVertical;
			delete obj.flipVertical;
			startFlipVertical = target.scaleY;
		}

var lastX=target.x;
		var lastY=target.y;

// end NIO updates
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// LOOP AND REWIND SETUP
		var count = 0;
		if (cjsProps.loop) {
			if (!zot(cjsProps.count)) {
				count = cjsProps.count;
				delete cjsProps.count;
				var currentCount = 1;
			}
		}
		var wait3 = 0;
		if (cjsProps.loopWait) {
			wait3 = cjsProps.loopWait;
			loopWait = cjsProps.loopWait; // for dynamic
			delete cjsProps.loopWait;
		}
		var call3;
		if (cjsProps.loopCall) {
			call3 = cjsProps.loopCall;
			delete cjsProps.loopCall;
		}
		var params3 = target;
		if (cjsProps.loopParams) {
			params3 = cjsProps.loopParams;
			delete cjsProps.loopParams;
		}
		
		// checkTIME will test to make sure they are in the right units probably
		if (TIMECHECK && timeCheck) {
			if (t) checkTIME(t, timeType);
			if (t2) checkTIME(t2, timeType);
			if (wait) checkTIME(wait, timeType);
			if (wait2) checkTIME(wait2, timeType);
			if (wait3) checkTIME(wait3, timeType);
			if (loopWait) checkTIME(loopWait, timeType);
			if (cjsProps.rewindWait) checkTIME(cjsProps.rewindWait, timeType);
			if (seriesWait) checkTIME(seriesWait, timeType);
			if (sequenceWait) checkTIME(sequenceWait, timeType);
		}

// convert times if needed
		if (timeType == "s") {
			if (t) t *= 1000;
			if (t2) t2 *= 1000;
			if (wait) wait *= 1000;
			if (wait2) wait2 *= 1000;
			if (wait3) wait3 *= 1000;
			if (loopWait) loopWait *= 1000;
			if (cjsProps.rewindWait) cjsProps.rewindWait *= 1000;
			if (seriesWait) seriesWait *= 1000;
			if (sequenceWait) sequenceWait *= 1000;
		}

function doLoopCall() {
			if (wait3>0) target.waiting = false;
			if (!cjsProps.loop) return; // added Cat 03 - was being called even if not looping
			if (sequenceCall && typeof sequenceCall == 'function') {				
				var sp = zot(sequenceParams) ? target : sequenceParams;
				(sequenceCall)(sp);
			}
			if (call3 && typeof call3 == 'function') {(call3)(params3);}			
			// added 10.8.0 for loopPick
			if (loopPick) {

// can't seem to get time to adjust - so using timeScale
				// tween.step.prev.t = 0
				// tween.step.prev.d = 2000
				// tween.step.t = 2000
				// tween.step.d = 2000
				// tween.step.prev.next.t = 0
				// tween.step.prev.next.d = 2000

var r = zim.Pick.choose(target.futureRate);
				if (!zot(target.futureRate)) tween.timeScale = r;

var adjustedScale;
				if (!zot(savedPicks.scale)) {
					adjustedScale = zim.Pick.choose(savedPicks.scale);
				}

if (!from) {
					if (tween.step && tween.step.prev && tween.step.prev.props) {
						for (var i in tween.step.prev.props) {
							if (extraTypes.indexOf(i) >= 0) continue; // skip for extras
							var p = zim.Pick.choose(savedPicks[i]);

// also handle relative
							if (typeof p == "string") {
								if (p.substr(0,1) != "+") {
									var newStart;
									if (target.zimLastObj && !zot(target.zimLastObj[i])) newStart = target.zimLastObj[i];
									else newStart = target[i];
									p = newStart + Number(p.replace(/\s/g,""));
								}
							}
							target.zimLastObj[i] = rewind?target.zimTweenOriginals[i]:p;
							// end handle relative
							
							if (!zot(savedPicks[i])) tween.step.prev.props[i] = p;
							if (i=="scaleX" && !zot(adjustedScale)) tween.step.prev.props.scaleX = adjustedScale;
							if (i=="scaleY" && !zot(adjustedScale)) tween.step.prev.props.scaleY = adjustedScale;
						}
					}
				} else {
					// can't seem to get from to work
					// at the moment sequence is not passing in from as it switches ahead of time
					// but just a plain from should work - just can't override the CreateJS tween
					// maybe it is a rewind issue...
					// if (tween.step && tween.step.props) {
					// 	for (var i in tween.step.props) {
					// 		if (extraTypes.indexOf(i) >= 0) continue; // skip for extras
					// 		if (!zot(savedPicks[i])) tween.step.props[i] = target[i] = zim.Pick.choose(savedPicks[i]);
					// 		if (i=="scaleX" && !zot(adjustedScale)) tween.step.props.scaleX = target.scaleX = adjustedScale;
					// 		if (i=="scaleY" && !zot(adjustedScale)) tween.step.props.scaleY = target.scaleY = adjustedScale;
					//
					// 	}
					// }
				}
			}			
		}
		var call4;
		if (cjsProps.loopWaitCall) {
			call4 = cjsProps.loopWaitCall;
			delete cjsProps.loopWaitCall;
		}
		var params4 = target;
		if (cjsProps.loopWaitParams) {
			params4 = cjsProps.loopWaitParams;
			delete cjsProps.loopWaitParams;
		}
		function doLoopWaitCall() {
			if (call4 && typeof call4 == 'function') {(call4)(params4);}
		}

// ADJUST EASE
		
		var customEases = [
			"ballisticIn", "ballisticOut", "ballisticInOut", 
			"snapIn", "snapOut", "snapInOut", 
			"slowmoIn", "slowmoOut", "slowmoInOut", 
		];
		if (customEases.indexOf(ease) != -1) {
			var ba = [0.4,0.75,0.9,.95];
			var sn = [0.99,-0.69,0.53,0.014];	
			var sm = [1.18,0.69,1,0.96];		
			
			if (ease == "ballisticIn") ease = zik(zim.zimEase(ba));
			else if (ease == "ballisticOut") ease = zik(zim.zimEase(ba).reverse());
			else if (ease == "ballisticInOut") ease = zik(zim.zimEase(ba, null, true)); // mirror
			else if (ease == "snapIn") ease = zik(zim.zimEase(sn));
			else if (ease == "snapOut") ease = zik(zim.zimEase(sn).reverse());
			else if (ease == "snapInOut") ease = zik(zim.zimEase(sn, null, true)); // mirror
			else if (ease == "slowmoIn") ease = zik(zim.zimEase(sm));
			else if (ease == "slowmoOut") ease = zik(zim.zimEase(sm).reverse());
			else if (ease == "slowmoInOut") ease = zik(zim.zimEase(sm, null, true)); // mirror
		}
		
		if (cjsProps.rewind) {
			// flip second ease			
			if (ease) {
				if (ease instanceof Function) { // zimEase
					var ease2 = zik(ease.reverse());
				} else {
					// backIn backOut backInOut
					var ease2 = ease;
					if (ease2.indexOf("InOut") == -1) {
						if (ease2.indexOf("Out") != -1) {
							ease2 = ease2.replace("Out", "In");
						} else if (ease2.indexOf("In") != -1) {
							ease2 = ease2.replace("In", "Out");
						}
					}
				}
			}
			if (rewindEase) {
				var ease2 = rewindEase;
			}
		}

if (ease instanceof Function) {			
			var finalEase = ease;
		} else {
			var equation = "get" + ease.charAt(0).toUpperCase()+ease.slice(1);
			var ea = zik(easeAmount);
			var ef = zik(easeFrequency);
			if ((!zot(ea) || !zot(ef)) && createjs.Ease[equation]) {
				if (!zot(ef) && zot(ea)) ea = 1;
				if (!zot(ea) && zot(ef)) ef = .3*1.5;
				var finalEase = createjs.Ease[equation](ea, ef);
			} else {
				var finalEase = createjs.Ease[ease];
			}
			
		}
		if (ease2) {
			if (ease2 instanceof Function) {
				var finalEase2 = ease2;
			} else {
				equation = "get" + ease2.charAt(0).toUpperCase()+ease2.slice(1);
				ea = zik(easeAmount);
				ef = zik(easeFrequency);
				if ((!zot(ea) || !zot(ef)) && createjs.Ease[equation]) {
					if (!zot(ef) && zot(ea)) ea = 1;
					if (!zot(ea) && zot(ef)) ef = .3*1.5;
					var finalEase2 = createjs.Ease[equation](ea, ef);
				} else {
					var finalEase2 = createjs.Ease[ease2];
				}
			}
		}

// REWIND TWEENS
		if (cjsProps.rewind) {

var wait2 = 0;
			delete cjsProps.rewind;

// if need to access it later in dynamic
			rewind = true;
			rewindWait = cjsProps.rewindWait;

if (cjsProps.rewindWait) {
				wait2 = cjsProps.rewindWait;
				delete cjsProps.rewindWait; // not a createjs prop so delete
			}

var call2;
			if (cjsProps.rewindCall) {
				call2 = cjsProps.rewindCall;
				var params2 = cjsProps.rewindParams;
				if (zot(params2)) params2 = target;
				delete cjsProps.rewindCall;
				delete cjsProps.rewindParams;
			}
			function doRewindCall() {
				if (wait2>0) target.waiting = false;
				if (call2 && typeof call2 == 'function') {(call2)(params2);}
			}
			var call5;
			if (cjsProps.rewindWaitCall) {
				call5 = cjsProps.rewindWaitCall;
				var params5 = cjsProps.rewindWaitParams;
				if (zot(params5)) params5 = target;
				delete cjsProps.rewindWaitCall;
				delete cjsProps.rewindWaitParams;
			}
			function doRewindWaitCall() {
				if (wait2>0) target.waiting = true;
				if (call5 && typeof call5 == 'function') {(call5)(params5);}
			}
			if (seriesWait > 0 || sequenceWait > 0 || wait > 0) { // do not want wait as part of future loops (use loopWait)
				if (seriesWait > 0 || sequenceWait > 0) {
					target.waiting = true;
					tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override})
						.wait(seriesWait>0?seriesWait:0, true)
						.wait(sequenceWait>0?sequenceWait:0, true)
						// .call(function(){
						// 	if (sequenceCall && typeof sequenceCall == 'function') {(sequenceCall)(zot(sequenceParams)?target:sequenceParams);}
						// })
						.call(function(target){
							target.waiting = false;
							sequenceWait = seriesWait = 0;
							preTween1(tween);
						});
					tween.timeScale = target.futureRate;
				} else {
					preTween1();
				}
			} else {
				prepareRelative2();
				tween1();
			}
			function preTween1(lastTween) {
				prepareRelative2();		
				if (wait>0) target.waiting = true;		
				tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override}).wait(wait, true).call(function(){
					target.waiting = false;
					if (waitedCall && typeof waitedCall == 'function') {(waitedCall)(zot(waitedParams)?target:waitedParams);}
					wait = 0;
					tween1(tween);
				});
				tween.timeScale = target.futureRate;
				if (lastTween) transferIds(lastTween, tween);
			}
			function tween1(lastTween) {
				var obj2 = getStart();
				if (target.set && !from) target.set(set);				
				tween = target.zimTweens[id] =  target.zimTween = createjs.Tween.get(target, cjsProps)
					.to(obj, t, finalEase)
					.call(doRewindWaitCall)
					.wait(wait2, true)
					.call(doRewindCall)
					.to(obj2, t2, finalEase2)
					.call(doneAnimating)
					.wait(wait3, true)
					.call(doLoopCall);
				tween.timeScale = target.futureRate;
				if (lastTween) transferIds(lastTween, tween);
				setZimTweenProps();
			}

} else {  // NOT REWIND TWEENS
			
			
			if (seriesWait > 0 || sequenceWait > 0 || wait > 0) { // do not want wait as part of future loops (use loopWait)
				
				if (seriesWait > 0 || sequenceWait > 0) {
					target.waiting = true;					
					tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override})
						.wait(seriesWait>0?seriesWait:0, true)
						.wait(sequenceWait>0?sequenceWait:0, true)
						// .call(function(){
						// 	if (sequenceCall && typeof sequenceCall == 'function') {(sequenceCall)(zot(sequenceParams)?target:sequenceParams);}
						// })
						.call(function(){
							sequenceWait = seriesWait = 0;
							target.waiting = false;
							preTween2(tween);
						});
						tween.timeScale = target.futureRate;
				} else {
					preTween2();
				}
			} else {
				prepareRelative2();				
				tween2();
			}
			function preTween2(lastTween) {
				prepareRelative2();		
				if (wait > 0) target.waiting = true;		
				tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override}).wait(wait, true).call(function(){
					wait = 0;
					target.waiting = false;
					if (waitedCall && typeof waitedCall == 'function') {(waitedCall)(zot(waitedParams)?target:waitedParams);}
					tween2(tween);
				});
				tween.timeScale = target.futureRate;
				if (lastTween) transferIds(lastTween, tween);
			}
			function tween2(lastTween) {
				if (target.set && !from) {target.set(set);}
				tween = target.zimTweens[id] =  target.zimTween = createjs.Tween.get(target, cjsProps)
					.to(obj, t, finalEase)
					.call(doneAnimating)
					.wait(wait3, true)
					.call(doLoopCall);
				tween.timeScale = target.futureRate;
				if (lastTween) transferIds(lastTween, tween);
				setZimTweenProps();
			}
		}

function transferIds(lastTween, tween) {
			tween.zimIdSet = lastTween.zimIdSet; // know we need this one - not sure about the rest 10.4.0
			tween.zimObj = lastTween.zimObj;
			tween.zimTicker = lastTween.zimTicker;
			tween.zimExtraTickers = lastTween.zimExtraTickers;
			tween.requestID = lastTween.requestID;
		}

tween.startPaused = startPaused; // turned off by pause(false) or pauseAnimate(false) or setting percentComplete
		tween.rewinding = false;

if (!zot(rate)) tween.timeScale = zim.Pick.choose(rate);

// SET TICKER
		var zimTicker;
		if (!css && ticker) {
			// moved this to after Tween has started so rewind is taken into account, etc.
			// do not want to reset percentComplete at the end incase dragging
			// so just reset it to 0 if at 100
			// means to purposely start at end, must set rewind true and start at 50% and animate to 100% for instance
			if (startPercentComplete) {
				target.pathRatio = (target.percentComplete && Math.round(target.percentComplete) != 100)?target.percentComplete/100:0;
				target.percentCompleteNoAngle = Math.round(startPercentComplete) != 100?startPercentComplete:0;
			}
			if (events && !zot(sequenceTarget) && sequenceTarget.dispatchEvent) {
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
					sequenceTarget.dispatchEvent("animation");
				}, stage);
			} else if (events && target.dispatchEvent) {
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
					target.dispatchEvent("animation");
				}, stage);
			} else {
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();					
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
				}, stage);
			}
		}
		
		function totalArr(arr) {
		  if(!Array.isArray(arr)) return;
		  var totalNumber = 0;
		  for (var i=0,l=arr.length; i<l; i++) {
			 totalNumber+=arr[i];
		  }
		  return totalNumber;
		}

var forwardStack = [1,1,1];

var handlePath = function () {
			if (!target.parent || tween.passive || tween.startPaused) return;
			if (drag && rewind && ((lastPathPercent < 50 && target.percentComplete > 50) || (lastPathPercent > 50 && target.percentComplete < 50))) {
				lastForward = target.percentComplete<50;
			}
			lastPathPercent = target.percentComplete;

if (pathObject) {
				if (dynamicPath) {
					segments = pathObject.segmentPoints;
					percents = pathObject.segmentRatios;
				}

if (drag) {
					var newPoint = pathObject.getCurvePoint(target.pathRatio, percents, segments);
				} else {
					target.currentPercent = target.startPercent + target.percent*target.pathRatio;
					var newPointRatio = ((1000000+target.currentPercent)%100)/100;
					if (target.pathRatio==1) newPointRatio+=target.percent>0?1:0;
					var newPoint = pathObject.getCurvePoint(newPointRatio, percents, segments);
				}

if (newPoint) {
					latestSegmentIndex = newPoint.z; // point on path before the calculated point - used with drag
					var locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
					target.x = locPoint.x;
					target.y = locPoint.y;
				}
			}
			var opposite = (startAngle==90||startAngle==270||startAngle==-90);
			if (pathFlip && flipCheck) {
				if (lastX > target.x && zim.sign(opposite?target.scaleY:target.scaleX) == zim.sign(startFlip)) opposite?target.scaleY*=-1:target.scaleX*=-1;
				if (lastX < target.x && zim.sign(opposite?target.scaleY:target.scaleX) != zim.sign(startFlip)) opposite?target.scaleY*=-1:target.scaleX*=-1;
			}
			if (pathFlipVertical && flipCheck) {
				if (lastY > target.y && zim.sign(opposite?target.scaleX:target.scaleY) == zim.sign(startFlipVertical)) opposite?target.scaleX*=-1:target.scaleY*=-1;
				if (lastY < target.y && zim.sign(opposite?target.scaleX:target.scaleY) != zim.sign(startFlipVertical)) opposite?target.scaleX*=-1:target.scaleY*=-1;
			}
			var aa;
			if (pathOrient) {
				if (pathObject==pathOrient) {
					aa = zim.angle(lastX, lastY, target.x, target.y)+startAngle;
				} else {
					var orientPoint;
					if (pathOrient.parent) {
						orientPoint = pathOrient.parent.localToLocal(pathOrient.x, pathOrient.y, target.parent);
					} else {
						orientPoint = target.parent.globalToLocal(pathOrient.x, pathOrient.y);
					}
					aa = zim.angle(target.x, target.y, orientPoint.x, orientPoint.y)+startAngle;
				}
				if (aa != 0) {
					if (!target.paused || movingCheck) {
						if (pathFlip && lastX-target.x > 0) aa += 180;
						var aaa = aa;
						if (!pathFlip && lastX-target.x > 0 ) aaa = aa-180;
						target.rotation = aaa==startAngle?target.rotation:aaa;
					}
				}
			}
			// picking up target can sway results so take average of last three
			// could possibly use this with flip to make it less jittery when dropping

if (drag) {
				var diff = target.x-lastX + target.y-lastY;
				if (Math.abs(diff) > 2) {
					forwardStack.push(zim.sign(diff));
					forwardStack.shift();
					// tween.forward = forwardStack.reduce((a,b) => a+b, 0) > 0;
					 tween.forward = totalArr(forwardStack);
				}
			}

lastX = target.x;
			lastY = target.y;
		};
		// there is only one percentComplete on a target
		// this will overwrite the handlePath function used by that percentComplete
		// so that the proper drag scope is used - complex - fixed in 10.6.1
		// will not be able to animate properly after a drag - use containers
		if (pathObject) target.handlePath = handlePath;

// SET MASK TO DYNAMIC
		if (!zot(target.zimMaskDynamic)) target.zimMaskApply(); // set mask set by zimMask to dynamic

// calling sequenceCall in loop as well so don't call here if looping - ZIM Cat 03
			if (!cjsProps.loop && sequenceCall && typeof sequenceCall == 'function') {
				var sp = zot(sequenceParams) ? target : sequenceParams;
				(sequenceCall)(sp);
			}
			if (call && typeof call == 'function') {(call)(params);}
		}
		function getStart() {
			// for rewind, we need to know the start value
			// which could be modified by the set parameter
			var startObj = {};
			for (var i in obj) {
				if (css && target.style) {
					if (!zot(set[i]) && !from) {
						startObj[i] = set[i];
					} else {
						startObj[i] = target.style[i];
					}
				} else {
					if (!zot(set[i]) && !from) {
						// !!!!!! maybe fix for dot plugin
						startObj[i] = set[i];
					} else {
						if (i.substr(0,1) == ".") {
							var dots = i.split(".");
							var lastdot = target;
							for (var j=1; j<dots.length; j++) {
								lastdot = lastdot[dots[j]];
							}
							startObj[i] = lastdot;
						} else {
							startObj[i] = target[i];
						}
					}
				}
			}
			return startObj;
		}
		function removeBusy(obj) {
			if (!target.zimBusy) return;
			for (var o in obj) {
				delete target.zimBusy[o];
			}
			if (zim.isEmpty(target.zimBusy)) target.zimBusy = null;
		}

// PAUSE AND STOP MANAGEMENT
		var zimPaused = false;
		setZimTweenProps();
		function setZimTweenProps() {
			// used to keep track of tweens for various ids
			// for pauseAnimate() and stopAnimate() down below
			tween.zimObj = obj;
			tween.zimTicker = zimTicker;
			tween.zimPaused = zimPaused;
			if (idSet) tween.zimIdSet = idSet;
			if (providedID) {
				// add to zim.idSets for global animation pause and stop by id
				// zim.idSets = {id:[target, target], id:[target, target, target]}
				// watchout - global idSet works on provided IDS
				// local idSets work on multiple ids that are the same
				// so an object with one tween under a provided id is not locally an idSet
				if (zot(zim.idSets)) zim.idSets = {};
				if (zot(zim.idSets[providedID])) {
					zim.idSets[providedID] = [target];
				} else {
					if (zim.idSets[providedID].indexOf(target) < 0) zim.idSets[providedID].push(target); // ES6 needed
				}
			}
			if (!zim.animatedObjects) zim.animatedObjects = new zim.Dictionary(true);
			zim.animatedObjects.add(target, true);
		}
		function endTween(id) {
			if (target.tweenStates && target.tweenStates[id]) delete target.tweenStates[id];
			if (zot(target.zimTweens) || zot(target.zimTweens[id])) return;
			target.zimX = null;
			target.zimY = null;
			removeBusy(target.zimTweens[id].zimObj);
			target.zimTweens[id].paused = true;
			endTicker(id);
			var idSet = target.zimTweens[id].zimIdSet;
			if (!zot(idSet) && target.zimIdSets) {
				var sets = target.zimIdSets[idSet];
				if (sets) sets.splice(sets.indexOf(id), 1);
				if (sets && sets.length == 0) {
					delete target.zimIdSets[idSet];
					if (zim.isEmpty(target.zimIdSets)) delete target.zimIdSets;
				}
			}
			//target.pathRatio = null;
			if (target.type == "Pen" && target.zimOnPath) {target.stop(); target.zimOnPath = false;}
			delete target.zimTweens[id];

// BUG
			// fast consecutive overlapping animates are not clearing zimTweens
			// so the pause is not being set - need to fix somehow - still broken
			// For instance animating something on a click and then tripple clicking really fast
			// Where this is an issue in app, prevent fast multiple activations of animate
			// For instance set object to mouseEnabled = false until animate is complete
			// then set object to mouseEnabled = true in call function
			if (zim.isEmpty(target.zimTweens)) {
				target.stopAnimate(null,null,null,false,true); // last true is internal
			}

// handle zim.idSets
			// very tricky - the originating id for an idSet does not get an idSet
			// but rather its id is used by subsequent tweens for the tween.idSets
			// the originating id may create a zim.idSets if it was provided as a parameter
			if ((target.zimTweens && target.zimTweens[id]) ||
				(target.zimIdSets && target.zimIdSets[idSet?idSet:id])) {
					// leave zim.idSets alone
			} else {
				if (zim.idSets && zim.idSets[idSet?idSet:id]) {
					zim.idSets[idSet?idSet:id];
					var targetIndex = zim.idSets[idSet?idSet:id].indexOf(target);
					if (targetIndex >= 0)  zim.idSets[idSet?idSet:id].splice(targetIndex, 1);
					if (zim.idSets[idSet?idSet:id].length <= 0) {
						delete zim.idSets[idSet?idSet:id];
						if (zim.isEmpty(zim.idSets)) delete zim.idSets;
					}
				}
			}
		}
		function endTicker(id) {
			// need a little delay to make sure updates the last animation
			// and to help call function have a stage update
			// store reference to ticker function in a closure
			// as we may delete the zimTweens reference before the 200 ms is up
			-function() {
				var ticker = target.zimTweens[id].zimTicker;
				if (target.zimTweens[id].extraTickers) {
					for (var k=0; k<target.zimTweens[id].extraTickers.length; k++) {
						zim.Ticker.remove(target.zimTweens[id].extraTickers[k]);
					}
				}
				// if (ticker) zim.Ticker.remove(ticker); ticker = null;
				if (target.zimTweens[id].requestID) cancelAnimationFrame(target.zimTweens[id].requestID);				
				if (ticker) {
					setTimeout(function(){
						if (ticker) zim.Ticker.remove(ticker); ticker = null;
					},200);
				}
			}();
		}
		function pauseTicker(id, paused) {
			var tween = target.zimTweens[id];
			tween.paused = paused;
			if (paused == tween.zimPaused) return;
			tween.zimPaused = paused;
			if (paused) {
				if (tween.zimTicker) tween.zimAnimateTimeout = setTimeout(function(){zim.Ticker.remove(tween.zimTicker);},200);
				// if (target.zimZoomTicker) zim.Ticker.remove(target.zimZoomTicker);
			} else {
				tween.startPaused = false;
				clearTimeout(tween.zimAnimateTimeout);
				if (tween.zimTicker) tween.zimTicker = zim.Ticker.add(tween.zimTicker, stage);
				// if (target.zimZoomTicker) target.zimZoomTicker = zim.Ticker.add(target.zimZoomTicker, stage);
			}
		}
		function expandIds(ids) {
			// turn any idSets into ids
			var actualIds = [];
			for (var i=0; i<ids.length; i++) {
				if (target.zimIdSets && !zot(target.zimIdSets[ids[i]])) {
					actualIds = actualIds.concat(target.zimIdSets[ids[i]]);
				} else {
					actualIds.push(ids[i]);
				}
			}
			return actualIds;
		}

// METHODS ADDED TO TARGET
		if (!target.stopAnimate || !target.stopAnimate.real) { // empty method gets added by default
			target.stopAnimate = function(ids, toEnd, include, command, internal) {
								
				if (internal && drag) { // zim 10.7.1 fix to still drag if done animating
					target.pauseAnimate();
					return;
				}
				
				if (zot(ids)) {
					target.tweenStates = {}; // all are off
				}
				
				if (toEnd) {
					target.endTween(null, ids);
					return target;
				}
				// can't risk turning percentComplete off as only one per all animations
				// instead, evaluate how percentComplete is set when starting an animation
				// if there is no getter setter or a value has been changed when not tweening
				// then assumes percentComplete is desired else sets to 0 when starting an animation
				// if (internal) target.percentComplete = target.pathRatio = 0;

if (zot(command)) command = true;
				if (target.pan == undefined) {
					target.paused = true;
					target.animating = false;
				}
				if (target.type == "Pen" && target.zimOnPath) {target.stop(); target.zimOnPath = false;}
				if (zot(include)) include = true;
				if (command && drag) {
					if (pathObject) pathObject.off("change", target.zimAnimatePathChange);
					target.off("mousedown", target.zimAnimateDragDown);
					target.off("pressmove", target.zimAnimateDragPress);
					target.off("pressup", target.zimAnimateDragUp);
					if (target.amu) stage.frame.off("mouseupplus", target.amu);	
					zim.Ticker.remove(target.zimDragAnimateTicker);
				}
				if (zot(ids)) {
					if (!include) return target; // would be exclude all ids
					target.zimBusy = null; // clear any busy properties
					createjs.Tween.removeTweens(target);
					for (var id in target.zimTweens) {
						endTicker(id);						
					}
					target.zimTweens = null;
					target.zimIdSets = null;
					target.zimTween = null;
					if (zim.idSets && zim.idSets[idSet?idSet:id]) {
						delete zim.idSets[idSet?idSet:id];
						if (zim.isEmpty(zim.idSets)) delete zim.idSets;
					}
					zim.animatedObjects.remove(target);	
					
				} else {
					if (!Array.isArray(ids)) ids = [ids];
					// expand any idSets into ids
					var actualIds = expandIds(ids);
					for (var id in target.zimTweens) {
						if (target.zimTweens[id].requestID) {
							cancelAnimationFrame(target.zimTweens[id].requestID);
						}
						if (include && actualIds.indexOf(id) >= 0) {
							endTween(id, command);							
						}
						if (!include && actualIds.indexOf(id) < 0) {
							endTween(id, command);
						}
					}
				}
				
				// if (zimTicker) zim.Ticker.remove(zimTicker);
				// zog(target)
				return target;
			};
			target.stopAnimate.real = true; // record this as real method instead of empty method
			target.pauseAnimate = function(paused, ids, include, ignoreDynamic) {				
				if (ids=="pauseOnBlur") {	
					ids = null;
				} else if (zot(ids)) {
					target.tweenStates = {all:paused===false?true:false}; // either all on or all off 
				}
				
				if (target.type == "Pen") {
					if (paused === false) {
						if (target.zimOnPath) target.infinite = true;
					} else {
						target.stop();
					}
				}
				if (usingDynamic && !ignoreDynamic) {
					target.pause(paused, ids);
					return target;
				}

if (zot(paused)) paused = true;
				mouseCheck = false;
				target.paused = paused; 
				target.animating = !paused;
				if (zot(include)) include = true;
				if (zot(ids) && !include) return target; // would exclude all ids
				if (zot(ids)) { // want all ids
					for (var id in target.zimTweens) {pauseTicker(id, paused);}
				} else {
					if (!Array.isArray(ids)) ids = [ids];
					// expand any idSets into ids
					var actualIds = expandIds(ids);
					for (var id in target.zimTweens) {
						if (include && actualIds.indexOf(id) >= 0) {
							pauseTicker(id, paused);
							target.tweenStates[id] = !paused;
						}
						if (!include && actualIds.indexOf(id) < 0) {
							pauseTicker(id, paused);
							target.tweenStates[id] = !paused;
						}
					}
				}		
				if (target.type=="Sprite") {
					if (!target.running) target.stop();
				}			
				return target;
			};
		}

// start NIO updates 2
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (startPaused) target.pauseAnimate(true, id, null, true); // last true overrides dynamic check

// EXTRA SETUP
		var extra;
		if (obj.extra) {
			extra = obj.extra;
			delete obj.extra;
			if (!Array.isArray(extra)) extra = [extra];
		}
		// handle incoming convenience properties:
		for (var i=0; i<extraTypes.length; i++) {
			var type = extraTypes[i];
			if (obj[type]) {
				if (zot(extra)) extra = [];
				makeExtra(type, obj[type]);
				delete obj[type];
			}
		}
		function makeExtra(prop, arr) {
			if (arr === true) extra.push({outputProp:extraLookup[prop]});
			else if (Array.isArray(arr)) extra.push({outputProp:extraLookup[prop], outputMin:arr[0], outputMax:arr[1], inputMin:arr[2], inputMax:arr[3]});
			else extra.push({outputProp:extraLookup[prop], outputMax:arr});
		}

if (extra) {
			target.zimStartScaleX = target.scaleX;
			target.zimStartScaleY = target.scaleY;
			tween.extraTickers = [];
			var extraObj;
			var extraProportion;
			for (var i=0; i<extra.length; i++) {
				var eObj = extra[i];
				if (zot(eObj.inputObj)) eObj.inputObj = target;
				if (zot(eObj.inputProp)) eObj.inputProp = "y";
				if (zot(eObj.inputMin)) eObj.inputMin = 0;
				if (zot(eObj.inputMax)) eObj.inputMax = eObj.inputProp=="x"?stage.width:stage.height;
				if (zot(eObj.outputObj)) eObj.outputObj = target;
				if (zot(eObj.outputProp)) eObj.outputProp = "scale";
				if (zot(eObj.outputMin)) eObj.outputMin = 0;
				if (zot(eObj.outputMax)) eObj.outputMax = eObj.outputMin + 1;
				if (zot(eObj.constrain)) eObj.constrain = true;

// ZIK all property values!
				for (var j in eObj) {
					obj[j] = zim.Pick.choose(obj[j]);
				}
				if (eObj.outputProp == "percentSpeed") dynamic = true;

extraProportion = new zim.Proportion(
					eObj.inputMin, eObj.inputMax,
					eObj.outputMin, eObj.outputMax,
					eObj.factor, eObj.outputRound
				);
				var func = function() { // closure
					var eO = eObj;
					var eP = extraProportion;
					var lastNewValue=0;
					return function () {
						var newValue;
						var eTarget = eO.outputObj;
						// adjusted for local to global ZIM 10.7.0
						var iV = eO.inputObj[eO.inputProp];
						if (eO.inputProp == "x" || eO.inputProp == "y") {
							if (eO.inputObj.parent) {
								var ppp = eO.inputObj.parent.localToGlobal(iV,iV);
								iV = ppp[eO.inputProp];
							}
						}
						if (eO.constrain) newValue = zim.constrain(eP.convert(iV), eO.outputMin, eO.outputMax);
						else newValue = eP.convert(iV);
						if (Number.isNaN(newValue)) newValue = eO.outputMin!=null?eO.outputMin:0;

// if (eO.constrain) newValue = zim.constrain(eP.convert(eO.inputObj[eO.inputProp]), eO.outputMin, eO.outputMax);
						// else newValue = eP.convert(eO.inputObj[eO.inputProp]);
						// various convenience properties and exceptions
						if (eO.outputProp == "scale") {
							eTarget.scaleX = zim.sign(eTarget.scaleX)*newValue;
							eTarget.scaleY = zim.sign(eTarget.scaleY)*newValue;
						} else if (eO.outputProp == "scaleX") {
							eTarget.scaleX = zim.sign(eTarget.scaleX)*newValue;
						} else if (eO.outputProp == "scaleY") {
							eTarget.scaleY = zim.sign(eTarget.scaleY)*newValue;
						} else if (eO.outputProp == "layer") {
							if (!eTarget.parent) return;
							var newLayer = zim.constrain(Math.round(newValue),0,eTarget.parent.numChildren-1);
							if (newLayer != eTarget.parent.getChildIndex(eTarget)) eTarget.parent.setChildIndex(eTarget, newLayer);
						} else if (eO.outputProp == "percentSpeed") {
							eTarget[eO.outputProp] = newValue*100;
						} else {
							eTarget[eO.outputProp] = newValue;
						}
					};
				}();
				func();
				tween.extraTickers.push(zim.Ticker.add(func, stage));
			}
		}
		// DYNAMIC ANIMATION
		var usingDynamic;
		var requestID;
		if (dynamic || target.zimAnimateDragDown) {
			var dynamicObj = {};
			if (dynamic) {
		
				usingDynamic = true;
				target.pauseAnimate(true, id, null, true); // last true overrides dynamic check
				target.paused = false;
				target.animating = true;
				tween.currentTime = 0;
				var myTween = tween;
				if (zot(target.percentSpeed)) target.percentSpeed = tween.startPaused?0:100;
				var baseSpeed = 1000/60;
				tween.currentTime = 0;
				var setToMiddle = (!sequenceWait && !seriesWait && !wait && !count && cjsProps.loop);
				if (clamp && cjsProps.loop && !count) clamp = false;
				var calculatedDuration = time + (rewind?(rewindTime?rewindTime:time):0) + (rewindWait?rewindWait:0) + (loopWait?loopWait:0);
				calculatedDuration *= timeType=="s"?1000:1;
				var clampMultiplier = 1;
				if (cjsProps.loop && count) clampMultiplier = count;
				var clampEnd;
				if (clamp) clampEnd = calculatedDuration*clampMultiplier;
				function advanceTween() {
					tween.requestID = requestID = requestAnimationFrame(advanceTween);
					if (!dynamic || (tween.startPaused && target.percentSpeed==0)) return;					
					tween.startPaused = false;
					if (tween != myTween) {
						myTween = tween;
						tween.currentTime = 0;
						target.pauseAnimate(true, id, null, true);
						target.paused = false;
						target.animating = true;
						setToMiddle = (!sequenceWait && !seriesWait && !wait && !count && cjsProps.loop);
					}
					if (setToMiddle) {
						tween.currentTime += 10000 * calculatedDuration;
						tween.setPosition(tween.currentTime, true);
						setToMiddle = false;
					}
		
					var newTime = tween.currentTime+baseSpeed*target.percentSpeed/100;
					if (clampEnd && wait==0) newTime = zim.constrain(newTime, 0, clampEnd);
					tween.currentTime = newTime;
		
					tween.setPosition(tween.currentTime);
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
					stage.update();
				}
				advanceTween();
			}
		
		
			var lastSpeed;
			var pausing = false;
			target.pause = function(state, time) {
				if (zot(state)) state = true;
				if (zot(time)) time = 0;
				if (state) {
					if (target.zimAnimateDragDown) {
						drag = false;
						target.cursor = "default";
						if (pathObject) pathObject.off("change", target.zimAnimatePathChange);
						target.off("mousedown", target.zimAnimateDragDown);
						target.off("pressmove", target.zimAnimateDragPress);
						target.off("pressup", target.zimAnimateDragUp);
						if (!dynamic) return;
					}					
					lastSpeed = target.percentSpeed;
					if (time > 0) {
						pausing = true;
						zim.animate({target:target, props:{percentSpeed:0}, override:false, ticker:false, time:time, call:function() {
							pausing = false;
							target.percentSpeed = 0;
		
							target.paused = true;
							target.animating = false;
							dynamic = false;
							target.dispatchEvent("pause");
						}});
					} else {
						tween.startPaused = false;
						pausing = false;
						target.percentSpeed = 0;
		
						target.paused = true;
						target.animating = false;
						dynamic = false;
						setTimeout(function() {target.dispatchEvent("pause");}, 10);
					}
				} else {
					if (target.zimAnimateDragDown) {
						drag = true;
						target.cursor = "pointer";
						if (pathObject) target.zimAnimatePathChange = pathObject.on("change", target.zimAnimatePathChange);
						target.zimAnimateDragDown = target.on("mousedown", target.zimAnimateDragDown);
						target.zimAnimateDragPress = target.on("pressmove", target.zimAnimateDragPress);
						target.zimAnimateDragUp = target.on("pressup", target.zimAnimateDragUp);
						if (!dynamic && startPaused != false) return;
					}
					mouseCheck = false;
					tween.currentTime = tween.position;
					if (time > 0) {
						pausing = true;
						zim.animate({
							target:target,
							props:{percentSpeed:lastSpeed},
							override:false,
							ticker:false,
							time:time,
							call:function() {
								pausing = false;
								target.percentSpeed = lastSpeed;
								target.paused = false;
								target.animating = true;
								dynamic = true;
							}
						});
					} else {
						pausing = false;
						target.percentSpeed = lastSpeed;
						target.paused = false;
						target.animating = true;
						dynamic = true;
					}
				}
				return target;
			};
		}

// end NIO updates
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

return target;
	};

zim.stopAnimate = function(ids, toEnd) {
		if (zot(ids)) {
			if (zim.animatedObjects) {
				for (var i=zim.animatedObjects.length-1; i>=0; i--) {
					zim.animatedObjects.objects[i].stopAnimate(null, toEnd);
				}
			}
			return;
		}
		if (!Array.isArray(ids)) ids = [ids];
		if (!zim.idSets) return;
		for (var j=0; j<ids.length; j++) {
			var idSet = ids[j];
			if (zim.idSets[idSet]) {
				var idLength = zim.idSets[idSet].length-1;
				for (var i=idLength; i>=0; i--) {
					zim.idSets[idSet][i].stopAnimate(idSet, toEnd);
				}
			}
		}
	};

zim.pauseAnimate = function(state, ids) {
		if (zot(state)) state = true;
		if (zot(ids) || ids=="pauseOnBlur") {
			if (zim.animatedObjects) {
				for (var i=zim.animatedObjects.length-1; i>=0; i--) {
					zim.animatedObjects.objects[i].pauseAnimate(state, ids);
				}
			}
			return;
		}
		if (!Array.isArray(ids)) ids = [ids];
		if (!zim.idSets) return;
		for (var j=0; j<ids.length; j++) {
			var idSet = ids[j];
			 if (zim.idSets[idSet]) {
				for (var i=zim.idSets[idSet].length-1; i>=0; i--) {
					zim.idSets[idSet][i].pauseAnimate(state, idSet);
				}
			}
		}
	};

zim.loop = function(obj, call, reverse, step, start, end) {
		var sig = "obj, call, reverse, step, start, end";
		var duo; if (duo = zob(zim.loop, arguments, sig)) return duo;
		zim.zimLoopCheck = true;
		if (zot(obj) || zot(call)) return undefined;
		if (zot(reverse)) reverse = false;
		if (zot(step) || step <= 0) step = 1;

var type = typeof obj=="number"?"number":(obj.constructor === Array?"array":(obj.constructor === {}.constructor?"object":(obj instanceof NodeList?"nodelist":(typeof obj == "string"?"string":(obj instanceof HTMLCollection?"htmlcollection":"invalid")))));

if (type == "container" && !obj.addChild) {
			return undefined;
		}
		if (type == "number" || type == "string" || type == "array" || type == "nodelist" || type == "htmlcollection") {

zim.copyMatrix = function(obj, source) {
		obj.x = source.x;
		obj.y = source.y;
		obj.scaleX = source.scaleX;
		obj.scaleY = source.scaleY;
		obj.regX = source.regX;
		obj.regY = source.regY;
		obj.rotation = source.rotation;
		obj.skewX = source.skewX;
		obj.skewY = source.skewY;
		return obj;
	};

zim.addTo = function(obj, container, index, localToLocal) {
		var sig = "obj, container, index, localToLocal";
		var duo; if (duo = zob(zim.addTo, arguments, sig)) return duo;
		// if (obj.type=="AC"&&zdf) {zdf.ac("addTo", arguments); return obj;}
		if (zot(obj)) {zog("zim methods - addTo(): please provide object"); return;}
		if (zot(container)) {
			if (zdf) {container = zdf.stage;}
			else {zog("zim methods - addTo(): please provide container"); return;}
		}
		if (zot(localToLocal)) localToLocal = true;
		if (!obj.parent) localToLocal = false;
		if (localToLocal) var point = obj.parent.localToLocal(obj.x, obj.y, container);
		if (zot(index) || isNaN(index)) {container.addChild(obj);}
		else {container.addChildAt(obj, index);}
		if (localToLocal) {obj.x = point.x; obj.y = point.y;}
		return obj;
	};

zim.removeFrom = function(obj, container) {
		if (zot(obj)) {zog("zim methods - removeFrom(): please provide object"); return;}
		if (zot(container)) {
			if (obj.parent) obj.parent.removeChild(obj);
		}
		else container.removeChild(obj);
		return obj;
	};

zim.added = function(obj, call, interval, maxTime) {
		if (zot(obj) || zot(call) || typeof call != "function") return;
		
		// // Can't do it this way as object's container may be added after object is added to container
		// if (obj.stage) (call)(obj.stage, obj);
		// else {
		// 	obj.on("added", function(e) {
		// 		if (obj.stage) {
		// 			(call)(obj.stage, obj);
		// 			e.remove();
		// 		}
		// 	}); 
		// }	
		
		var timeType = getTIME(interval);
		if (zot(interval)) interval = timeType=="s"?.1:100;
		if (obj.stage) {(call)(obj.stage, obj); return;}
		var t = interval*(timeType=="s"?1000:1);
		var mt;
		if (maxTime) {
			checkTIME(maxTime);
			mt = maxTime*(timeType=="s"?1000:1);
		}
		var startTime = Date.now();
		var startCount = 0;
		var startID = setInterval(function() {
			if (startCount > 5) {
				clearInterval(startID);
				return;
			}
			startCount++;
			if (obj.stage) {
				(call)(obj.stage, obj);
				clearInterval(startID);
				clearInterval(id);
			}
		}, 10);
		var id = setInterval(function() {
			if (mt > 0 && startTime-Date.now()>mt) clearInterval(id);
			if (obj.stage) {
				(call)(obj.stage, obj);
				clearInterval(id);
			}
		}, t);
		return id;
		
	};

zim.tap = function(obj, call, distance, time, once, dbl, dblTime, call2, call3, call4) {
		var sig = "obj, call, distance, time, once, dbl, dblTime, call2, call3, call4";
		var duo; if (duo = zob(zim.tap, arguments, sig)) return duo;
		if (zot(obj) || zot(call) || typeof call != "function") return;
		if (zot(distance)) distance = dbl?10:5;
		var timeType = getTIME(time);
		if (zot(time)) time = timeType=="s"?8:8000;
		if (zot(once)) once = false;
		if (zot(dbl)) dbl = false;
		if (zot(dblTime)) {
			if (call4) {
				dblTime = timeType=="s"?.5:500;
			} else {
				dblTime = timeType=="s"?1:1000;
			}
		}
		obj.cursor = "pointer";
		var stage;
		var firstTap = false;
		var doubleCheck = false;
		var firstUp;
		
		if (dbl) {
			obj.zimDblClickDownEvent = obj.on("mousedown", function (e) {
				firstUp = false;
				if (firstTap) { firstTap = false; return; }
				firstTap = true;
				stage = e.target.stage;
				if (e.currentTarget.type == "List") {
					if (e.target.type == "WindowBacking") return;
					var local = e.currentTarget.globalToLocal(e.stageX / zim.scaX, e.stageY / zim.scaY);
					if (local.y <= 0) return; // avoid titleBar and organizer
				}
				var lastX = e.stageX / zim.scaX;
				var lastY = e.stageY / zim.scaY;
				var startTime = Date.now();
				var upStageX;
				var upStageY;
				doubleCheck = true;
				if (obj.zimDoubleTimeout) clearTimeout(obj.zimDoubleTimeout);
				obj.zimDoubleTimeout = setTimeout(function () {
					doubleCheck = false;
					firstTap = false;
					if (obj.zimDblClickUpEvent) obj.off("pressup", obj.zimDblClickUpEvent);
					if (firstUp && call4) {
						if (Math.abs(lastX + lastY - upStageX / zim.scaX - upStageY / zim.scaY) < distance) {
							if (obj.excludeTap) return;
							call4(e);
						} else if (call2) call2(e);
					}
				}, timeType == "s" ? dblTime * 1000 : dblTime);
				obj.zimDblClickUpEvent = obj.on("pressup", function (e) {
					upStageX = e.stageX; // upstage added by Xuntar
					upStageY = e.stageY;
					firstUp = true;
					if (firstTap) {
						if (call3) call3(e);
						return;
					} else if (!doubleCheck) return;
					if (Math.abs(lastX + lastY - e.stageX / zim.scaX - e.stageY / zim.scaY) < distance && Date.now() - startTime < (timeType == "s" ? time * 1000 : time)) {
						if (obj.excludeTap) return;
						clearTimeout(obj.zimDoubleTimeout);
						call(e);
					} else if (call2) call2(e);
					e.remove();
				});
			}, null, once);
		} else {
			obj.zimClickDownEvent = obj.on("mousedown", function (e) {				
				stage = e.target.stage;
				if (e.currentTarget.type == "List") {
					if (e.target.type == "WindowBacking") return;
					var local = e.currentTarget.globalToLocal(e.stageX / zim.scaX, e.stageY / zim.scaY);
					if (local.y <= 0) return; // avoid titleBar and organizer
				}
				var lastX = e.stageX / zim.scaX;
				var lastY = e.stageY / zim.scaY;
				var startTime = Date.now();
				obj.zimClickUpEvent = obj.on("pressup", function (e) {					
					if (Math.abs(lastX + lastY - e.stageX / zim.scaX - e.stageY / zim.scaY) < distance && Date.now() - startTime < (timeType=="s"?time*1000:time)) {
						if (obj.excludeTap) return;
						call(e);
					} else if (call2) call2(e);
					e.remove();
				}); 
			}, null, once);
		}
		
		return obj;
	};

zim.hold = function(obj, call, distance, time, once) {
		if (zot(obj) || zot(call) || typeof call != "function") return;
		if (zot(distance)) distance = 5;
		var timeType = getTIME(time);
		if (zot(time)) time = timeType=="s"?1.5:1500;
		if (zot(once)) once = false;
		obj.cursor = "pointer";
		var stage;
		obj.zimClickHoldDownEvent = obj.on("mousedown", function (e) {
			stage = e.target.stage;
			if (zot(stage.frame)) stage.frame = zdf;
			if (zot(stage.frame) || !stage.frame.mousemoveEvent) { // not recording frame mouseX and mouseY
				if (zot(stage.frame)) stage.frame = {};
				stage.frame.mouseX = e.stageX/zim.scaX;
				stage.frame.mouseY = e.stageY/zim.scaY;
				if (stage.frame.mouseholdEvent) stage.off("stagemousemove", stage.frame.mouseholdEvent);
				stage.frame.mouseholdEvent = stage.on("stagemousemove", function (e) {
					stage.frame.mouseX = e.stageX/zim.scaX;
					stage.frame.mouseY = e.stageY/zim.scaY;
				});
			}
			if (e.currentTarget.type == "List") {
				if (e.target.type == "WindowBacking") return;
				var local = e.currentTarget.globalToLocal(e.stageX / zim.scaX, e.stageY / zim.scaY);
				if (local.y <= 0) return; // avoid titleBar and organizer
			}
			var lastX = e.stageX / zim.scaX;
			var lastY = e.stageY / zim.scaY;
			var startTime = Date.now();
			clearInterval(obj.zimHoldInterval);
			var count = 0;
			obj.zimHoldInterval = setInterval(function () {
				if (count < 10) { // if location has gone outside distance then not a hold
					if (Math.abs(lastX + lastY - stage.frame.mouseX - stage.frame.mouseY) > distance) {
						clearInterval(obj.zimHoldInterval);
					}
				} else {
					if (Math.abs(lastX + lastY - stage.frame.mouseX - stage.frame.mouseY) < distance) {
						if (obj.excludeHold) return;
						call(e);
					}
					clearInterval(obj.zimHoldInterval);
				}
				count++;
			}, time / 10 * (timeType == "s" ? 1000 : 1));
			obj.zimClickHoldUpEvent = obj.on("pressup", function (e) {
				clearInterval(obj.zimHoldInterval);
				if (stage && stage.frame.mouseholdEvent) {
					stage.off("stagemousemove", stage.frame.mouseholdEvent);
				}
			}, null, true); // just once
		}, null, once);
		return obj;
	};

zim.noHold = function(obj) {
		if (zot(obj)) return;
		if (obj.cursor) obj.cursor = "default";
		obj.off("mousedown", obj.zimClickHoldDownEvent);
		obj.off("pressup", obj.zimClickHoldUpEvent);
		if (obj.stage && obj.stage.frame.mouseEvent) {
			obj.stage.off("stagemousemove", obj.stage.frame.mouseEvent);
		}
		clearInterval(obj.zimHoldTimeout);
		return obj;
	};

zim.centerReg = function(obj, container, index, add) {
		var sig = "obj, container, index, add";
		var duo; if (duo = zob(zim.centerReg, arguments, sig)) return duo;
		if (obj.type=="AC"&&zdf) {zdf.ac("centerReg", arguments); return obj.addTo(container, index);}
		if (zot(obj) || !obj.getBounds || !obj.getBounds()) {zog("zim methods - centerReg(): please provide object with bounds set"); return obj;}
		if (zot(add)) add = true;
		if (zot(container) && obj.parent && add) {
			container = obj.parent;
			if (zot(index)) index = obj.parent.getChildIndex(obj);
			obj.parent.removeChild(obj);
		}
		if (!zot(container) && container == obj.parent) {
			if (zot(index)) index = obj.parent.getChildIndex(obj);
			obj.parent.removeChild(obj);
		}
		var oB = obj.getBounds();
		obj.regX = oB.x + oB.width/2;
		obj.regY = oB.y + oB.height/2;
		return add ? zim.center(obj, container, index) : obj;
	};

zim.center = function(obj, container, index, add) {
		var sig = "obj, container, index, add";
		var duo; if (duo = zob(zim.center, arguments, sig)) return duo;
		if (obj.type=="AC"&&zdf) {zdf.ac("center", arguments); return obj.addTo(container, index);}
		if (zot(obj) || !obj.getBounds) {zog("zim.center(): please provide object with bounds"); return obj;}
		if (zot(container)) {
			if (obj.parent) container = obj.parent;
			else if (zdf) container = zdf.stage;
		}
		if (zot(container) || !container.getBounds)  {zog("zim.center(): please provide container with bounds"); return obj;}

var oB = obj.getBounds();
		var cB = container.getBounds();

if (zot(add)) add = true;

var resetCheck = false;
		if (zot(cB)) {
			container.setBounds(0,0);
			cB = container.getBounds();
			resetCheck = true;
		}

if (add && container.addChild) {
            if (zot(index) || (typeof index === 'number' && isNaN(index))) {
				if (!container.contains(obj)) container.addChild(obj);
            } else {
                container.addChildAt(obj, index);
            }
        }
		if (zot(oB)) {
			obj.x = cB.x+cB.width/2;
			obj.y = cB.y+cB.height/2;
			return obj;
		}

var zeroX = false;
		var zeroY = false;
		if (container.scaleX == 0) {
			zeroX = true;
			container.scaleX=.00001;
		}
		if (container.scaleY == 0) {
			zeroY = true;
			container.scaleY=.00001;
		}

// get registration point of object in coordinates of the container
		var reg = obj.localToLocal(obj.regX, obj.regY, container);

// get bounds of the object in global space even if object is rotated and scaled
		// this makes a rectangle surrounding a rotated object - so bigger but parallel edges to the x and y
		var glob = zim.boundsToGlobal(obj);

// now project this rectangle into the container coordinates
		// passing in a rectangle (glob) will make this act on the rectangle rather than the bounds
		// flip (true) means we go from global to local in the container
		var loc = zim.boundsToGlobal(container, glob, true);

if (zeroX) container.scaleX=0;
		if (zeroY) container.scaleY=0;

// the positions are all in the container coordinate so do the calculation
		obj.x = cB.x + cB.width/2 - loc.width/2  + (reg.x-loc.x);
		obj.y = cB.y + cB.height/2 - loc.height/2  + (reg.y-loc.y);

if (!add && container.getStage && container.stage && obj.parent) {
			var p = container.localToLocal(obj.x, obj.y, obj.parent);
			obj.x = p.x;
			obj.y = p.y;
		}
		if (resetCheck) container.setBounds(null);

return obj;
	};

zim.expand = function(obj, padding, paddingVertical, paddingRight, paddingBottom) {
		var sig = "padding, paddingVertical, paddingRight, paddingBottom";
		var duo; if (duo = zob(zim.expand, arguments, sig)) return duo;
		if (zot(obj) || !obj.getBounds || !obj.getBounds()) {zog("zim methods - expand(): please provide object with bounds set"); return obj;}
		if (zot(padding)) padding = 20;
		if (zot(paddingVertical)) paddingVertical = padding;
		if (!zot(paddingRight) || !zot(paddingBottom)) {
			if (zot(paddingRight)) paddingRight = padding;
			if (zot(paddingBottom)) paddingBottom = paddingVertical;
			var paddingLeft = padding;
			var paddingTop = paddingVertical;
		} else {
			var paddingLeft = paddingRight = padding;
			var paddingTop = paddingBottom = paddingVertical;
		}
		var oB = obj.getBounds();
		var rect = new createjs.Shape();
		rect.graphics.f("0").r(oB.x-paddingLeft,oB.y-paddingTop,oB.width+paddingLeft+paddingRight,oB.height+paddingTop+paddingBottom);
		obj.hitArea = rect;
		return obj;
	};

zim.setMask = function(obj, mask, dynamic) {
		if (zot(obj)) {zog("zim methods - setMask(): please provide obj");}
		if (zot(mask)) {setMaskNull(); return obj;}
		var stage = obj.stage||(zdf?zdf.stage:null);
		function setMaskNull() {
			if (obj.zimMask && obj.zimMask.parent) obj.zimMask.parent.removeChild(obj.zimMask);
			obj.zimMask = null;
			if (obj.zimMaskTicker) zim.Ticker.remove(obj.zimMaskTicker);
			obj.mask = null;
		}
		if (obj.zimMaskOriginal && obj.zimMaskOriginal != mask) setMaskNull();
		if (zot(dynamic)) {
			// blob, drag, transform, gesture, animate
			dynamic = (mask.type=="Blob" || !zot(mask.zimDown) || !zot(mask.transformControls) || !zot(mask.zimTouch) || !zot(mask.zimTweens));
			mask.zimMaskDynamic = dynamic;
		}
		obj.zimMaskOriginal = mask;
		var m;
		function apply() {
			if (dynamic && (!stage || !mask.stage)) return obj;
			if (m && m.dispose) m.dispose();
			m = null;			
			obj.zimMask = mask.zimMask = m = mask.shape.clone();
			zim.copyMatrix(m, mask);
			mask.addChildAt(m,0);
			m.alpha = 0;

if (!obj.parent) {obj.mask = m; return;}

var mm = mask.getConcatenatedMatrix().decompose();
			var om = obj.parent.getConcatenatedMatrix().decompose();
			m.scaleX = mm.scaleX/om.scaleX;
			m.scaleY = mm.scaleY/om.scaleY;
			m.rotation = (mm.rotation?mm.rotation:0)-(om.rotation?om.rotation:0);			
			var p = mask.localToLocal(mask.shape.x+mask.regX,mask.shape.y+mask.regY,obj.parent);
			m.x = p.x;
			m.y = p.y;

obj.mask = m;
		}
		// called from Blob and zim functions that move zim shapes
		mask.zimMaskApply = function() {
			if (obj.zimMaskTicker) zim.Ticker.remove(obj.zimMaskTicker);
			obj.zimMaskTicker = zim.Ticker.add(apply);
		};
		if (mask && mask.shape) { // zim.Rectangle, Circle or Triangle, blob
			apply();
			if (dynamic) mask.zimMaskApply();
		} else {
			m = mask;
			obj.mask = m; // set the createjs mask
		}
		return obj;
	};

zim.KEYFOCUS = null;

zim.STYLE = null;
zim.ignore = "ignore";
zim.getStyle = function(type, group, inherit) {

var functionList = ["pos","addTo","center","centerReg","mov","drag","transform","gesture","outline","bounds","animate","wiggle","cache"];

// called by DisplayObjects
	var DS = zim.STYLE;
	
	if (typeof STYLE !== typeof undefined) DS = STYLE;
	
	// convert Lazy Object styles - ZIM Cat 03
	for (var prop in STYLE) {
		var val = STYLE[prop]; 
		if (prop.match(/^[(A-Z)]/)) {
			if (!STYLE.type) STYLE.type = {};            
			if (STYLE.type[prop]) STYLE.type[prop] = zim.merge(STYLE.type[prop], val);
			else STYLE.type[prop] = val;   
			delete STYLE[prop];         
		}
	};
	
	if (!zot(DS)) DS = zim.copy(DS); // can't copy with clone due to recursion
	else DS = {};

// an object of styles from creator class that have already been ziked
	// for instance, List calls Window and Tabs and these can inherit styles applied to the List
	// Tabs call Buttons and Labels and these can inherit styles from the List and Tabs
	// List will overwrite Button styles - so originator overwrites subsequent styles

if (zot(inherit)) {
		inherit = {};
	} else {
		// remove any functions from inheritance
		for (var i=0; i<functionList.length; i++) {
			delete inherit[functionList[i]];
		}
	}
	var IS = inherit;

if (!zot(type) && !zot(TS) && !zot(TS[type])) DS = zim.merge(DS, TS[type]);
	if (!zot(group) && !zot(GS)) DS = zim.merge(DS, GS);
	var val;

for (var s in DS) {
		if (IS[s]) { // inherited value overrides
			delete DS[s];
			continue;
		}
		val = functionList.indexOf(s)==-1&&!DS.delayPick?zim.Pick.choose(DS[s]):DS[s]; // do not zik configuration objects of methods
		if (val=="ignore") {delete DS[s]; continue;}
		// not sure what the line below was for - maybe auto cloning a bitmap? but had to remove it ZIM 9.5.0 when debugging addTo STYLE issues
	 	// else if (val && val.clone && val.type != type && val.type != "Stage" && val.type != "StageGL") val = val.clone();
		// copy config objects with clone except for type container - do not center or centerReg on shape
		else if (val && val.constructor === {}.constructor) val = zim.copy(val, true, false);
		DS[s] = val;
	}
	DS = zim.merge(DS, IS);

if (DS.style===false) return {};

return DS;
};

// sets x, y, alpha, rotation, scale, scaleX, scaleY, regX, regY, skewX, skewY, bounds, visible
// also sets addTo, center, centerReg, transform, drag, gesture, animate, wiggle, expand, cache, and outline (used internally)
zim.styleTransforms = function(obj, styles) {

// if (styles.pos == "left" || styles.pos == "top") obj.pos();
				// if (styles.pos == "right") obj.pos({right:true});
				// if (styles.pos == "bottom") obj.pos({bottom:true});
				// if (styles.pos == "rightbottom" || styles.pos == "bottomright" || styles.pos == "rightBottom" || styles.pos == "bottomRight") obj.pos({right:true, bottom:true});
				// if (styles.pos == "center") obj.center();
				// if (styles.pos == "centerReg" || styles.pos == "centerreg") obj.centerReg();
			}
		}
		if (styles.mov || styles.move) {
			if (styles.move) styles.mov = styles.move;
			if (styles.mov.constructor==={}.constructor) {
				obj.mov(zim.Pick.choose(styles.mov.x), zim.Pick.choose(styles.mov.y));
			} else {
				obj.mov(zim.Pick.choose(styles.mov));
			}
		}		
		if (styles.outline) {
			setTimeout(function(){
				obj.outline(styles.outline.constructor==={}.constructor?styles.outline:null);
				if (obj.stage) obj.stage.update();
			},20);
		}
		if (styles.drag) {
			obj.drag(styles.drag.constructor==={}.constructor?styles.drag:{currentTarget:true});
		}
		if (styles.gesture) {
			obj.gesture(styles.gesture.constructor==={}.constructor?styles.gesture:null);
		}
		if (styles.transform) {
			setTimeout(function(){obj.transform(styles.transform.constructor==={}.constructor?styles.transform:null);},20);
		}
		if (styles.animate) {
			if (!Array.isArray(styles.animate)) styles.animate = [styles.animate];
			for (var i=0; i<styles.animate.length; i++) {
				-function(){
					var sty = styles.animate[i];
					if (sty.constructor==={}.constructor) setTimeout(function(){obj.animate(sty);},20);
				}();
			}
		}
		if (styles.wiggle) {
			if (!Array.isArray(styles.wiggle)) styles.wiggle = [styles.wiggle];
			for (var i=0; i<styles.wiggle.length; i++) {
				-function(){
					var sty = styles.wiggle[i];
					if (sty.constructor==={}.constructor) setTimeout(function(){obj.wiggle(sty);},20);
				}();
			}
		}
		if (styles.expand) {
			obj.expand(styles.expand===true?null:styles.expand);
		}
		if (styles.cache) {
			if (styles.cache.constructor==={}.constructor) {
				if (styles.cache.x) obj.cache(zim.Pick.choose(styles.cache.x), zim.Pick.choose(styles.cache.y), zim.Pick.choose(styles.cache.x), zim.Pick.choose(styles.cache.y));
				else obj.cache(zim.Pick.choose(styles.cache.width), zim.Pick.choose(styles.cache.height));
			} else {
				obj.cache();
			}
		}
	}
};

zim.Style = {
	remembered:{},
	clear:function() {STYLE={}; return zim.Style;},
	clearTypes:function() {STYLE={}; delete STYLE.types; return zim.Style;},
	clearGroups:function() {STYLE={}; delete STYLE.groups; return zim.Style;},
	remember:function(id) {
		if (!STYLE) STYLE = {};
		if (zot(id)) id = "default";
		zim.Style.remembered[id]=zim.copy(STYLE, true);
		return zim.Style;
	},
	clearRemembered:function(id) {
		if (zot(id)) zim.Style.remembered = {};
		else delete zim.Style.remembered[id];
		return zim.Style;
	},
	recall:function(id) {
		if (zot(id)) id = "default";
		STYLE = zim.Style.remembered[id];
		return zim.Style;
 	},
	add:function(obj) {
		if (!STYLE) STYLE = {};
		STYLE = zim.merge(STYLE, obj);
		return zim.Style;
 	},
	addType:function(typeName, obj) {
		if (!STYLE) STYLE = {};
		if (!STYLE.type) STYLE.type = {};
		STYLE.type[typeName] = obj;
		return zim.Style;
 	},
	addGroup:function(groupName, obj) {
		if (!STYLE) STYLE = {};
		if (!STYLE.group) STYLE.group = {};
		STYLE.group[groupName] = obj;
		return zim.Style;
 	},
	remove:function(styleName) {
		if (!STYLE) STYLE = {};
		delete STYLE[styleName];
		return zim.Style;
 	},
	removeType:function(typeName) {
		if (!STYLE) STYLE = {};
		if (!STYLE.type) return zim.Style;
		delete STYLE.type[typeName];
		return zim.Style;
 	},
	removeGroup:function(groupName) {
		if (!STYLE) STYLE = {};
		if (!STYLE.group) return zim.Style;
		delete STYLE.group[groupName];
		return zim.Style;
 	}
};

zim.localToGlobal = function localToGlobal(x,y,scope,func) {
	if (x==null || y==null) return;
	var point = func.call(scope,x,y);
	var stage = scope.stage;
	if (typeof zdf == "undefined") {
		if (!stage) return point;
		zdf = {stage:stage, canvas:stage.canvas};
	}
	point.x /= zim.scaX;
	point.y /= zim.scaY;
	return point;
};
zim.globalToLocal = function globalToLocal(x,y,scope,func) {
	if (x==null || y==null) return;
	var stage = scope.stage;
	if (typeof zdf == "undefined") {
		if (!stage) return func.call(scope,x,y);
		zdf = {stage:stage, canvas:stage.canvas};
	}
	x *= zim.scaX;
	y *= zim.scaY;
	var point = func.call(scope,x,y);
	return point;
};
zim.localToLocal = function localToLocal(x,y,target,scope) {
	if (x==null || y==null || target==null) return;
	var point = scope.localToGlobal(x,y);
	var stage = scope.stage;
	if (typeof zdf == "undefined") {
		if (!stage) return target.globalToLocal(point.x, point.y);
		zdf = {stage:stage, canvas:stage.canvas};
	}
	if (!stage) stage = zdf.stage;
	if (target == stage) return point;
	if (point) return target.globalToLocal(point.x, point.y);
};

zim.displayBase = function(obj) {
		var that = obj;				
		Object.defineProperty(obj, 'width', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.width*this.scaleX);
			},
			set: function(value) {
				var b = this.getBounds();
				if (zot(b) || b.width==0) {
					if (zon) zogy("DisplayObject() - width needs bounds set with setBounds()");
					return;
				}
				var s = value/b.width;
				this.scaleX = this.scaleY = s;
			}
		});
		Object.defineProperty(obj, 'height', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.height*this.scaleY);
			},
			set: function(value) {
				var b = this.getBounds();
				if (zot(b) || b.height==0) {
					if (zon) zogy("DisplayObject() - height needs bounds set with setBounds()");
					return;
				}
				var s = value/b.height;
				this.scaleX = this.scaleY = s;
			}
		});
		Object.defineProperty(obj, 'widthOnly', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.width*this.scaleX);
			},
			set: function(value) {
				var b = this.getBounds();
				if ((zot(b) || b.width==0) && zon) {zogy("DisplayObject() - widthOnly needs bounds set with setBounds()"); return;}
				var s = value/b.width;
				this.scaleX = s;
			}
		});
		Object.defineProperty(obj, 'heightOnly', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.height*this.scaleY);
			},
			set: function(value) {
				var b = this.getBounds();
				if ((zot(b) || b.height==0) && zon) {zogy("DisplayObject() - heightOnly needs bounds set with setBounds()"); return;}
				var s = value/b.height;
				this.scaleY = s;
			}
		});
		Object.defineProperty(obj, 'level', {
			enumerable: true,
			get: function() {
				if (this.parent) return this.parent.getChildIndex(this); return null;
			},
			set: function(value) {
				if (this.parent) this.parent.setChildIndex(this, Math.max(0, Math.min(value, this.parent.numChildren-1)));
			}
		});
		Object.defineProperty(obj, 'depth', {
			enumerable: true,
			get: function() {
				return this._depth;
			},
			set: function(depth) {
				this._depth = depth;
				if (!zot(this.vrChannel)) {
					var parallaxShift = this.vrParallaxDistance ? depth*this.vrParallax*this.vrParallaxDistance : 0;
					if (this.vrChannel == "left") {
						this.x = this.vrStartX + depth + parallaxShift;
					} else if (this.vrChannel == "right") {
						this.x = this.vrStartX - depth + parallaxShift;
					}
				}
			}
		});
		Object.defineProperty(obj, 'blendMode', {
			enumerable: true,
			get: function() {
				return this.compositeOperation;
			},
			set: function(value) {
				this.compositeOperation = value;
			}
		});
			
		if (!that.name) {
			var _name;
			Object.defineProperty(that, 'name', {
				get: function() {
					return _name;
				},
				set: function(value) {
					_name = value;
					zim.zimObjectIDs[value] = that;
				}
			});
		}
		that._draggable;
		Object.defineProperty(that, 'draggable', {
			get: function() {
				return this._draggable;
			},
			set: function(value) {
				if (value == this._draggable) return;
				this._draggable = value;
				if (this._draggable) this.drag();
				else this.noDrag();
			}
		});
		
		var frame;
		var adCheck;
		that.on("mousedown", function (e) {
			if (e.target.stage) {
				frame = e.target.stage.frame;
				if (frame.allowDefault) {
					adCheck = true;
					frame.allowDefault = false;
				}
			}
		});
		that.on("pressup", function (e) {
			if (frame && adCheck) frame.allowDefault = true;
		});
		
		// EFFECTS
		// making 8 properties, 4 that update effect and 4 that do not 
		// so that regular properties can update effect - obj.hue=20 // updates
		// but animate and wiggle can bulk update effect - obj.hueBatch=20 // does not update
		var effects = ["hue", "saturation", "brightness", "contrast"];
		for (var i=0; i<effects.length; i++) {
			-function() { // closure to remember eff
				var eff = effects[i];
				for (var j=0; j<2; j++) {
					-function() { // closure to remember add
						var add = j==0?"":"Batch";
						Object.defineProperty(that, eff+add, {
							get: function() {											
								if (that.effects && that.effects.multi) return that.effects.multi[eff];	
								else return 0;		
							},
							set: function(value) {
								if (!that.effects || !that.effects.multi) that.effect(new MultiEffect(eff=="hue"?value:0,eff=="saturation"?value:0,eff=="brightness"?value:0,eff=="contrast"?value:0));
								else that.effects.multi[eff] = value;
								if (add=="") that.updateEffects(); 
							}
						});
					}();				
				}			
			}();
		}	
	
	}

zim.gD = function(obj) {
		if (!obj) return;
		if (zim.KEYFOCUS == obj) zim.KEYFOCUS = null;
		if (obj.draggable) obj.noDrag();
		if (obj.zimTweens) obj.stopAnimate();
		if (obj.zimWire) obj.noWire();
		if (obj.zimWired) obj.noWired();
		if (obj.zimClickHoldDownEvent) obj.noHold();
		if (obj.transformControls) obj.transformControls.dispose();
		if (obj.zimClickDownEvent) obj.zimClickDownEvent = null;
		if (obj.zimClickUpEvent) obj.zimClickUpEvent = null;
		if (obj.physics) obj.removePhysics();
		if (obj.name && zim.zimObjectIDs[obj.name] == obj) delete zim.zimObjectIDs[obj.name];
	}

zim.Stage = function(canvasID) {
	if (zot(canvasID)) return;
	var tag = canvasID.tagName=="CANVAS"?canvasID:zid(canvasID);
	if (zot(tag)) return;
	this.cjsStage_constructor(canvasID);
	this.setBounds(0,0,tag.width,tag.height);
	this.type = "Stage";
	if (typeof zdf == 'undefined') zimDefaultFrame = zdf = {stage:this};
	this.cache = function(a,b,c,d,scale,options) {
		if (zot(c)) {
			if (zot(a)) {
				var bounds = this.getBounds();
				if (!zot(bounds)) {
					var added = this.borderWidth > 0 ? this.borderWidth/2 : 0;
					a = bounds.x-added;
					b = bounds.y-added;
					c = bounds.width+added*2;
					d = bounds.height+added*2;
				}
			} else {
				c = a;
				d = b;
				a = 0;
				b = 0;
			}
		}
		this.cjsStage_cache(a,b,c,d,scale,options);
		return this;
	};
	this.on("mousedown", function(e) {
		var e2 = e.clone();
		e2.type = "pressdown";
		e.target.dispatchEvent(e2);
	}, undefined, false, undefined, true);	
	this.loop = function(call, reverse, step, start, end) {
		return zim.loop(this, call, reverse, step, start, end);
	};
	this.hitTestGrid = function(width, height, cols, rows, x, y, offsetX, offsetY, spacingX, spacingY, local, type) {
		return zim.hitTestGrid(this, width, height, cols, rows, x, y, offsetX, offsetY, spacingX, spacingY, local, type);
	};
	this.disposeAllChildren = function() {
		for (var i=this.numChildren-1; i>=0; i--) {
			var child = this.getChildAt(i)
			if (child.dispose) child.dispose();
		}
		return this;
	};

Object.defineProperty(this, 'scaleX', {
			get: function () {
				return this.cjsStage_scaleX;
			},
			set: function (value) {
				this.cjsStage_scaleX = value;
				zim.scaX = createjs.stageTransformable ? 1 : value;
			}
		});

Object.defineProperty(this, 'scaleY', {
			get: function () {
				return this.cjsStage_scaleY;
			},
			set: function (value) {
				this.cjsStage_scaleY = value;
				zim.scaY = createjs.stageTransformable ? 1 : value;
			}
		});
	
		this.localToGlobal = function (x, y) {
			return zim.localToGlobal(x, y, this, this.cjsStage_localToGlobal);
		};
		this.globalToLocal = function (x, y) {
			return zim.globalToLocal(x, y, this, this.cjsStage_globalToLocal);
		};
		this.localToLocal = function (x, y, target) {
			return zim.localToLocal(x, y, target, this);
		};
	}	
};
zim.extend(zim.Stage, createjs.Stage, ["cache","localToLocal","localToGlobal","globalToLocal"], "cjsStage", false);

zim.Container = function(a, b, c, d, style, group, inherit) {
		var sig = "a, b, c, d, style, group, inherit";
		var duo; if (duo = zob(zim.Container, arguments, sig, this)) return duo;
		if (!zim.containerCheck) {
			zim.containerCheck=true;
		}
		this.cjsContainer_constructor();
		this.type = "Container";
		this.group = group;
		var that = this;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

if (zot(a)) a = DS.a!=null?DS.a:null;
		if (zot(b)) b = DS.b!=null?DS.b:null;
		if (zot(c)) c = DS.c!=null?DS.c:null;
		if (zot(d)) d = DS.d!=null?DS.d:null;

this.cache = function(a,b,c,d,scale,options,margin) {
			if (this.type=="AC"&&zdf) {zdf.ac("cache", arguments, this); return this;}
			var sig = "a,b,c,d,scale,options,margin";
			var duo; if (duo = zob(that.cache, arguments, sig)) return duo;
			var bounds = that.getBounds();
			if (zot(c)) {
				if (zot(a)) {
					if (!zot(bounds)) {
						var added = that.borderWidth > 0 ? that.borderWidth/2 : 0;
						a = bounds.x-added;
						b = bounds.y-added;
						c = bounds.width+added*2;
						d = bounds.height+added*2;
					}
				} else {
					c = a;
					d = b;
					a = 0;
					b = 0;
				}
			}
			if (that.type == "Triangle") {
				a-=that.borderWidth?that.borderWidth:0;
				c+=that.borderWidth?that.borderWidth*2:0;
				b-=that.borderWidth?that.borderWidth:0;
				d+=that.borderWidth?that.borderWidth*2:0;
			}
			if (zot(margin)) margin = 0;
			that.cjsContainer_cache(a-margin,b-margin,c+margin*2,d+margin*2,scale,options);
			if (bounds) that.setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
			return that;
		};
		this.uncache = function() {
			that.cjsContainer_uncache();
			return that;
		};
		this.childrenToBitmap = function () {
			var cached = this.cacheCanvas;
			var pic = new zim.Bitmap(this.cache().cacheCanvas);
			if (!cached) this.uncache();
			this.removeAllChildren();
			pic.addTo(this);
			return this;
		};
		var frame = zdf || 1;
		if (createjs && !createjs.stageTransformable && frame.retina) {
			this.localToGlobal = function(x,y) {
				return zim.localToGlobal(x,y,this,this.cjsContainer_localToGlobal);
			};
			this.globalToLocal = function(x,y) {
				return zim.globalToLocal(x,y,this,this.cjsContainer_globalToLocal);
			};
			this.localToLocal = function(x,y,target) {
				return zim.localToLocal(x,y,target,this);
			};
		}
		this.setBounds = function(a,b,c,d) {
			var n = normalizeBounds(a, b, c, d);
			this.cjsContainer_setBounds(n[0],n[1],n[2],n[3]);
			return this;
		};
		
		this.disposeAllChildren = function() {
			for (var i=this.numChildren-1; i>=0; i--) {
				var child = this.getChildAt(i)
				if (child.dispose) child.dispose();
			}
			return this;
		};
			
		zim.displayBase(that);
		
		if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
		this.clone = function(exact) {
			if (this.type=="AC"&&zdf) {
				if (zon) {zogy("ZIM asset() - cannot clone lazy loaded asset - use Frame() assets parameter or loadAssets() method")};
				zdf.ac("clone", arguments, this); 
				return this;
			}
			var currentBounds = this.getBounds();
			if (zot(currentBounds)) currentBounds = {x:null, y:null, width:null, height:null};
			return this.cloneChildren(this.cloneProps(new zim.Container(currentBounds.x,currentBounds.y,currentBounds.width,currentBounds.height, style, this.group, inherit)), exact);
		};
		this.hasProp = function(prop) {
			return (!zot(this[prop]) || this.hasOwnProperty(prop));
		};
	};
	zim.Container.prototype.dispose = function(disposing) {			
		recursiveDispose(this, disposing);
		return true;
	};
	zim.Container.prototype.specialColor = function(command, co) {
		if (co.type=="GradientColor") command.linearGradient(co.colors, co.ratios, co.x0, co.y0, co.x1, co.y1);
		else if (co.type=="RadialColor") command.radialGradient(co.colors, co.ratios, co.x0, co.y0, co.r0, co.x1, co.y1, co.r1);
		else if (co.type == "BitmapColor") command.bitmap(co.image, co.repetition, co.matrix);
	};

zim.Shape = function(a, b, c, d, graphics, optimize, style, group, inherit) {
		var sig = "a, b, c, d, graphics, optimize, style, group, inherit";
		var duo; if (duo = zob(zim.Shape, arguments, sig, this)) return duo;
		this.cjsShape_constructor(graphics);
		this.type = "Shape";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);
		var that = this;

if (zot(a)) a = DS.a!=null?DS.a:null;
		if (zot(b)) b = DS.b!=null?DS.b:null;
		if (zot(c)) c = DS.c!=null?DS.c:null;
		if (zot(d)) d = DS.d!=null?DS.d:null;
		if (zot(graphics)) graphics = DS.graphics!=null?DS.graphics:null;
		if (zot(optimize)) optimize = DS.optimize!=null?DS.optimize:false;

if (!optimize) {
			var shorts = ["mt","lt","a","at","bt","ct","qt","cp","c",
			"f","lf","rf","bf","ef","ss","sd","s",
			"ls","rs","bs","es","dr","rr","rc","dc","de","dp","pg","p"];
			for (var i=0; i<shorts.length; i++) {
				~function() { // store each in closure to maintain name
					var n = i;
					that[shorts[n]] = function(){
						if (shorts[n]=="ct") that.graphics.curveTo.apply(that.graphics, arguments);
						else that.graphics[shorts[n]].apply(that.graphics, arguments);
						return that;
					};
				}();
			}
		}
		Object.defineProperty(that, 'command', {
			get: function() {
				return that.graphics.command;
			},
			set: function(value) {
			}
		});

this.cache = function(a,b,c,d,scale,options,margin) {
			var sig = "a,b,c,d,scale,options,margin";
			var duo; if (duo = zob(that.cache, arguments, sig)) return duo;
			var bounds = that.getBounds();
			if (zot(c)) {
				if (zot(a)) {
					if (!zot(bounds)) {
						var added = that.borderWidth > 0 ? that.borderWidth/2 : 0;
						a = bounds.x-added;
						b = bounds.y-added;
						c = bounds.width+added*2;
						d = bounds.height+added*2;
					}
				} else {
					c = a;
					d = b;
					a = 0;
					b = 0;
				}
			}
			if (zot(margin)) margin = 0;
			that.cjsShape_cache(a-margin,b-margin,c+margin*2,d+margin*2,scale,options);
			return that;
		};
		this.setBounds = function(a,b,c,d) {
			var n = normalizeBounds(a, b, c, d);
			this.cjsShape_setBounds(n[0],n[1],n[2],n[3]);
			return this;
		};
		if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
		this.clone = function(recursive) {
			if (zot(recursive)) recursive = true;
			var currentBounds = this.getBounds();
			if (zot(currentBounds)) currentBounds = {x:null, y:null, width:null, height:null};
			var c = that.cloneProps(new zim.Shape(currentBounds.x,currentBounds.y,currentBounds.width,currentBounds.height, graphics, style, group, inherit));
			if (recursive) c.graphics = that.graphics.clone();
			else c.graphics = that.graphics;
			return c;
		};
		var frame = zdf || 1;
		if (createjs && !createjs.stageTransformable && frame.retina) {
			this.localToGlobal = function(x,y) {
				return zim.localToGlobal(x,y,this,this.cjsShape_localToGlobal);
			};
			this.globalToLocal = function(x,y) {
				return zim.globalToLocal(x,y,this,this.cjsShape_globalToLocal);
			};
			this.localToLocal = function(x,y,target) {
				return zim.localToLocal(x,y,target,this);
			};
		}
		this.hasProp = function(prop) {
			return (!zot(this[prop]) || this.hasOwnProperty(prop));
		};
		// this.pg = function(points, close) {
		// 	if (!Array.isArray(points)) points = Array.from(arguments);
		// 	var type = 	points[0].x != null?"obj":points[0][0] != null?"arr":"par";	
		// 
		// 	var p, fp, sp;
		// 	if (type=="obj") p = points[0];
		// 	else if (type=="arr") p = {x:points[0][0], y:points[0][1]||0};
		// 	else p = {x:points[0], y:points[1]||0};
		// 	fp = {x:p.x, y:p.y};
		// 	this.mt(fp.x, fp.y);			
		// 	for (var i=1; i<points.length; i++) {
		// 		if (type=="obj") p = points[i];
		// 		else if (type=="arr") p = {x:points[i][0], y:points[i][1]||0};
		// 		else p = {x:points[i*2], y:points[i*2+1]||0};
		// 		if (i==1) sp = {x:p.x, y:p.y};
		// 		this.lt(p.x, p.y);								
		// 	}	
		// 	this.lt(fp.x, fp.y).lt(sp.x, sp.y); // go around to second point to get correct end bevel/miter
		// 	return this;
		// }
		
		zim.displayBase(that);	
		
		this.dispose = function(a,b,disposing) {
			zim.gD(this); // globalDispose function for common elements
			this.graphics.c();
			this.dispatchEvent("removed");
			this.removeAllEventListeners();
			if (this.parent) this.parent.removeChild(this);
		};
	};
	zim.extend(zim.Shape, createjs.Shape, ["cache","clone","setBounds","localToLocal","localToGlobal","globalToLocal"], "cjsShape", false);
	zimify(zim.Shape.prototype);

zim.Bitmap = function(image, width, height, left, top, id, style, group, inherit) {
	var sig = "image, width, height, left, top, id, style, group, inherit";
	var duo; if (duo = zob(zim.Bitmap, arguments, sig, this)) return duo;
	if (!zot(image)) {
		if (image.uncache) { // testing if it has a CreateJS uncache method
			var cached = image.cacheCanvas;
			var original = image;
			image = image.cache().cacheCanvas; // what we will pass to bitmap
		}
	}
	this.cjsBitmap_constructor(image);
	if (original && !cached) original.uncache();

var that = this;
	this.type = "Bitmap";
	this.group = group;
	var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

this.id = that.fileID = DS.id!=null?DS.id:id;
	if (zot(width)) width = DS.width!=null?DS.width:image?image.width:100;
	if (zot(height)) height = DS.height!=null?DS.height:image?image.height:100;	
	if (!zot(width) && !zot(height)) that.setBounds(0,0,width,height);
	if (zot(left)) left = DS.left!=null?DS.left:0;
	if (zot(top)) top = DS.top!=null?DS.top:0;

if (zdf) {
		// not supported by IE - thanks Chris Spolton for the find and suggested fix
		if (zdf.canvas.getContext("2d")) {
			this.imageData = zdf.canvas.getContext("2d").createImageData(width, height);
		} else {
			this.imageData = document.createElement('canvas').getContext("2d").createImageData(width, height);
			// if (ImageData) this.imageData = new ImageData(width, height);
		}
		this.drawImageData = function(x, y, sourceX, sourceY, sourceWidth, sourceHeight) {
			if (zot(x)) x = 0;
			if (zot(y)) y = 0;
			if (zot(sourceX)) sourceX = 0;
			if (zot(sourceY)) sourceY = 0;
			if (zot(sourceWidth)) sourceWidth = width;
			if (zot(sourceHeight)) sourceHeight = height;
			if (!that.proxyCanvas) {
				var c = that.proxyCanvas = document.createElement("canvas");
				c.setAttribute("width", width);
				c.setAttribute("height", height);
				that.proxyContext = c.getContext('2d');
				image = that.image = c;
			}
			if (that.proxyContext) {
				that.proxyContext.putImageData(that.imageData, x, y, sourceX, sourceY, sourceWidth, sourceHeight);
			}
		};
		if (zot(image)) that.drawImageData();

// handle delay when creating Bitmap from data
		if (image.match && image.match(/data:image/i)) setTimeout(function() {
			if (that.stage) that.stage.update();
			setTimeout(function() {
				if (that.stage) that.stage.update();
			}, 50);
		}, 50);
	}

if (image && image.nodeName && image.nodeName.toLowerCase() != "video") that.sourceRect = {x:left, y:top, width:width, height:height};

this.cache = function(a,b,c,d,scale,options) {
		if (zot(c)) {
			if (zot(a)) {
				var bounds = this.getBounds();
				if (!zot(bounds)) {
					var added = this.borderWidth > 0 ? this.borderWidth/2 : 0;
					a = bounds.x-added;
					b = bounds.y-added;
					c = bounds.width+added*2;
					d = bounds.height+added*2;
				}
			} else {
				c = a;
				d = b;
				a = 0;
				b = 0;
			}
		}
		var bounds = this.getBounds();
		this.cjsBitmap_cache(a,b,c,d,scale,options);
		this.setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
		return this;
	};
		
	this.clone = function() {
		var c = this.cloneProps(new zim.Bitmap(image, width, height, left, top, that.fileID, style, this.group, inherit));
		c.cloned = true;
		return c;
	};
	var frame = zdf || 1;
	if (createjs && !createjs.stageTransformable && frame.retina) {
		this.localToGlobal = function(x,y) {
			return zim.localToGlobal(x,y,this,this.cjsBitmap_localToGlobal);
		};
		this.globalToLocal = function(x,y) {
			return zim.globalToLocal(x,y,this,this.cjsBitmap_globalToLocal);
		};
		this.localToLocal = function(x,y,target) {
			return zim.localToLocal(x,y,target,this);
		};
	}
	this.hasProp = function(prop) {
		return (!zot(this[prop]) || this.hasOwnProperty(prop));
	};
	var myContext;
	this.getColorAt = function(x,y) {
		if (!myContext) {
			that.cache();
			myContext = that.cacheCanvas.getContext('2d');
			that.uncache();
		}
		var d = myContext.getImageData(x, y, 1, 1).data;
		return "rgba("+d[0]+","+d[1]+","+d[2]+","+d[3]+")";
	};

zim.displayBase(that);
	
	if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
	
	this.dispose = function(a,b,disposing) {
		zim.gD(this); // globalDispose function for common elements
		this.dispatchEvent("removed");
		this.removeAllEventListeners();
		if (!this.cloned) {
			if (this.id) {
				if (this.stage && this.stage.frame) frame = this.stage.frame;
				else frame = zdf;
				if (frame && frame.assets) {
					if (frame.assets[this.id]) delete frame.assets[this.id];
				}
				if (zim.assets[this.id]) delete zim.assets[this.id];
			}		
		}	
		if (this.parent) this.parent.removeChild(this);
	};
};
zim.Bitmap.fromData = function(data, callback) {
	var width = 100;
	var height = 100;	
	var img = new Image();
	img.onload = function() {
		width = img.naturalWidth;
		height = img.naturalHeight;
		if (zot(width)) width = img.width;
		if (zot(height)) height = img.height;
		var bitmap = new zim.Bitmap(data, width, height);
		setTimeout(function() {
			callback(bitmap);
		}, 50);
	}
	img.src = data;	
};
zim.extend(zim.Bitmap, createjs.Bitmap, ["cache","clone","dispose","localToLocal","localToGlobal","globalToLocal"], "cjsBitmap", false);
zimify(zim.Bitmap.prototype);

zim.Sprite = function(image, cols, rows, count, offsetX, offsetY, spacingX, spacingY, width, height, animations, json, id, globalControl, spriteSheet, label, frame, style, group, inherit) {
		var sig = "image, cols, rows, count, offsetX, offsetY, spacingX, spacingY, width, height, animations, json, id, globalControl, spriteSheet, label, frame, style, group, inherit";
		var duo; if (duo = zob(zim.Sprite, arguments, sig, this)) return duo;
		this.type = "Sprite";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

var that = this;
		var sheet;
		if (zot(frame)) frame = DS.frame!=null?DS.frame:zdf;
		if (zot(json) && !zot(image)) {
			if (zot(cols)) cols = DS.cols!=null?DS.cols:1;
			if (zot(rows)) rows = DS.rows!=null?DS.rows:1;
			if (zot(count)) count = DS.count!=null?DS.count:(cols*rows);
			if (zot(offsetX)) offsetX = DS.offsetX!=null?DS.offsetX:0;
			if (zot(offsetY)) offsetY = DS.offsetY!=null?DS.offsetY:0;
			if (zot(spacingX)) spacingX = DS.spacingX!=null?DS.spacingX:0;
			if (zot(spacingY)) spacingY = DS.spacingY!=null?DS.spacingY:0;
			if (zot(width)) width = DS.width!=null?DS.width:image.width;
			if (zot(height)) height = DS.height!=null?DS.height:image.height;

this.animations = animations;
		this.cjsSprite_constructor(sheet, label);
		if (!zot(label)) this.stop();

if (zot(id)) id = zim.makeID();
		this.id = id;

if (zot(globalControl)) globalControl = true;
		that.globalControl = globalControl;

// normalize up to 1/10 - as in if put at .1 then have to multiply all others speeds by 10
			minSpeed = zim.constrain(zim.decimals(minSpeed), .1);
			maxSpeed = zim.constrain(zim.decimals(maxSpeed), .1);

// normalize speed:
			var framesNormalized = [];
			var normalize = (minSpeed != maxSpeed);
			var fr;
			for (var i=0; i<frames.length; i++) {
				fr = frames[i];
				if (normalize) {
					// if minSpeed less than 1 then divide all others by minSpeed otherwise use speed - and need to round to a number that is at least .1
					for (var j=0; j<zim.constrain(Math.round(minSpeed<1?fr.s/minSpeed:fr.s), .1); j++) {
						framesNormalized.push(fr.f);
					}
				} else {
					framesNormalized.push(fr.f);
				}
			}
			return framesNormalized;
		};

this.run = function(time, label, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startFrame, endFrame, tweek, id, globalControl, pauseOnBlur) {
			var sig = "time, label, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startFrame, endFrame, tweek, id, globalControl, pauseOnBlur";
			var duo; if (duo = zob(this.run, arguments, sig)) return duo;

var timeType = getTIME();

var obj;
			var set;
			var lookup;
			if (zot(tweek)) tweek = 1;
			if (!zot(id)) that.id = id;
			if (!zot(globalControl)) that.globalControl = globalControl;

if (Array.isArray(label)) {
				// check labels
				var innerLabel;
				var lastLabel;
				obj = [];
				var extraTime = 0;
				var firstStartFrame;
				for (var i=0; i<label.length; i++) {
					innerLabel = label[i]; // {label:"first", time:1, etc}

innerLabel.lookup = that.parseFrames(innerLabel.label, innerLabel.startFrame, innerLabel.endFrame);
					if (i==0) firstStartFrame = innerLabel.lookup[0];
					delete innerLabel.startFrame;
					delete innerLabel.endFrame;

innerLabel.obj = zim.merge(innerLabel.obj, {normalizedFrame:innerLabel.lookup.length-1});
					innerLabel.set = zim.merge(innerLabel.set, {normalizedFrames:{noPick:innerLabel.lookup}, normalizedFrame:0});

// based on previous frames
					if (zot(innerLabel.wait)) innerLabel.wait = extraTime*tweek;

lastLabel = innerLabel.label;
					delete innerLabel.label;

obj.push(innerLabel);

// will get applied next set of frames
					extraTime = 0;
					var tt = zot(innerLabel.time)?time:innerLabel.time;
					if (endFrame-startFrame > 0) extraTime = tt / (endFrame-startFrame) / 2; // slight cludge - seems to look better?

// if (i==0) firstStartFrame = startFrame;
				}
				//startFrame = firstStartFrame;
				if (obj.length == 0) return this;
				if (obj.length == 1) { // just one label in list ;-)
					time = obj[0].time;
					label = lastLabel;
					setSingle();
				} else {
					that.gotoAndStop(firstStartFrame);
				}
			} else { // single label
				setSingle();
			}

function setSingle() {
				_normalizedFrames = that.parseFrames(label, startFrame, endFrame);
				_normalizedFrame = 0;
				that.gotoAndStop(_normalizedFrames[_normalizedFrame]);
				startFrame = endFrame = null;
				obj = {normalizedFrame:_normalizedFrames.length-1};
			}

if (zot(time)) time = timeType=="s"?1:1000;
			// if already running the sprite then stop the last run
			if (that.running) that.stopAnimate(that.id);
			that.running = true;
			
			if (!Array.isArray(obj)) {
				var extraTime = 0;
				if (endFrame-startFrame > 0) extraTime = time / Math.abs(endFrame-startFrame) / 2; // slight cludge - seems to look better?
				if (_normalizedFrames && _normalizedFrames.length>0) extraTime = time / _normalizedFrames.length / 2; // slight cludge - seems to look better?
				if (zot(loopWait)) {loopWait = extraTime*tweek;}
				if (zot(rewindWait)) {rewindWait = extraTime*tweek;}
			}

// locally override call to add running status after animation done
			var localCall = function() {
				that.running = false;
				that.stop();
				if (call && typeof call == 'function') call(params||that);				
			};
			zim.animate({
				target:that,
				obj:obj,
				time:time,
				ease:"linear",
				call:localCall,
				params:params,
				wait:wait, waitedCall:waitedCall, waitedParams:waitedParams,
				loop:loop,
				loopCount:loopCount,
				loopWait:loopWait,
				loopCall:loopCall, loopParams:loopParams,
				loopWaitCall:loopWaitCall, loopWaitParams:loopWaitParams,
				rewind:rewind, rewindWait:rewindWait, // rewind is ignored by animation series
				rewindCall:rewindCall, rewindParams:rewindParams,
				rewindWaitCall:rewindWaitCall, rewindWaitParams:rewindWaitParams,
				rewindTime:rewindTime, rewindEase:rewindEase,
				override:false,
				pauseOnBlur:pauseOnBlur,
				id:that.id
			});
			that.runPaused = false;
			return that;
		};

this.runPaused = true;
		this.pauseRun = function(paused) {
			if (zot(paused)) paused = true;
			that.runPaused = paused;
			if (that.globalControl) {
				zim.pauseAnimate(paused, that.id);
			} else {
				that.pauseAnimate(paused, that.id);
			}
			return that;
		};
		this.stopRun = function() {
			that.runPaused = true;
			that.running = false;
			if (that.globalControl) {
				zim.stopAnimate(that.id);
			} else {
				that.stopAnimate(that.id);
			}
			return that;
		};

Object.defineProperty(this, 'frame', {
			get: function() {
				return this.currentFrame;
			},
			set: function(value) {
				value = Math.round(value);
				if (this.paused) {
					this.gotoAndStop(value);
				} else {
					this.gotoAndPlay(value);
				}
			}
		});

Object.defineProperty(this, 'normalizedFrame', {
			get: function() {
				return _normalizedFrame;
			},
			set: function(value) {
				_normalizedFrame = Math.round(value);
				this.gotoAndStop(_normalizedFrames[_normalizedFrame]);
			}
		});

Object.defineProperty(this, 'normalizedFrames', {
			get: function() {
				return _normalizedFrames;
			},
			set: function(value) {
				_normalizedFrames = value;
			}
		});

Object.defineProperty(this, 'totalFrames', {
			get: function() {
				return sheet.getNumFrames();
			},
			set: function(value) {
				zog("zim.Sprite - totalFrames is read only");
			}
		});

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
		this.clone = function() {
			return this.cloneProps(new zim.Sprite(image, cols, rows, count, offsetX, offsetY, spacingX, spacingY, width, height, animations, json, null, globalControl, spriteSheet, label, frame, style, this.group, inherit));
		};
		var frame = zdf || 1;
		if (createjs && !createjs.stageTransformable && frame.retina) {
			this.localToGlobal = function(x,y) {
				return zim.localToGlobal(x,y,this,this.cjsSprite_localToGlobal);
			};
			this.globalToLocal = function(x,y) {
				return zim.globalToLocal(x,y,this,this.cjsSprite_globalToLocal);
			};
			this.localToLocal = function(x,y,target) {
				return zim.localToLocal(x,y,target,this);
			};
		}
		
		this.hasProp = function(prop) {
			return (!zot(this[prop]) || this.hasOwnProperty(prop));
		};
		
		zim.displayBase(that);
		
		this.dispose = function(a,b,disposing) {
			zim.gD(this); // globalDispose function for common elements
			this.dispatchEvent("removed");
			this.removeAllEventListeners();
			if (this.parent) this.parent.removeChild(this);
		};
	};
	zim.extend(zim.Sprite, createjs.Sprite, ["clone","localToLocal","localToGlobal","globalToLocal"], "cjsSprite", false);
	zimify(zim.Sprite.prototype);

zim.CustomShape = function(x, y, w, h) {

this.zimContainer_constructor(x, y, w, h, false);

var that = this;
	this.mouseChildren = false;
	that._dashedOffset = 5;

Object.defineProperty(that, 'color', {
		get: function() {
			return that._color;
		},
		set: function(value) {
			if (zot(value)) value = "black";
			that._color = value;
			if (value && value.type) that.specialColor(that.colorCommand, value);
			else that.colorCommand.style = value;
		}
	});
	this.setColorRange = function(color1, color2) {
		if (zot(color2)) {
			that.startColor = that.color;
			that.endColor = color1;
		} else if (zot(color1)) {
			that.startColor = that.color;
			that.endColor = color2;
		} else {
			that.startColor = color1;
			that.endColor = color2;
		}
		return that;
	};
	that._colorRange = 0;
	Object.defineProperty(that, 'colorRange', {
		get: function() {
			return that._colorRange;
		},
		set: function(value) {
			that._colorRange = value;
			if (!zot(that.startColor) && !zot(that.endColor)) {
				that.color = zim.colorRange(that.startColor, that.endColor, value);
			}
		}
	});
	Object.defineProperty(that, 'borderColor', {
		get: function() {
			return that._borderColor;
		},
		set: function(value) {
			that._borderColor = value;
			if (value && !that.borderWidth) {
				that.borderWidth = 1;
			}
			if (!that.borderColorCommand) {
				that.drawShape();
			}
			else if (value && value.type) that.specialColor(that.borderColorCommand, value);
			else that.borderColorCommand.style = value;
		}
	});
	Object.defineProperty(that, 'borderWidth', {
		get: function() {
			return that._borderWidth;
		},
		set: function(value) {
			if (!(value>0)) value = 0;
			that._borderWidth = value;			
			if (!that.borderWidthCommand || that._borderWidth == 0) {
				that.borderWidthCommand = null;
				that.drawShape();				
			}
			else {
				that.borderWidthCommand.width = that._borderWidth;
				if (that._dashed) {
					that.borderDashedCommand.segments = that._dashed;
					that.borderDashedCommand.offset = that._dashedOffset;
				}
			}
		}
	});
	Object.defineProperty(that, 'thickness', {
		get: function() {
			return that._thickness;
		},
		set: function(value) {
			if (!(value>0)) value = 0;
			that._thickness = value;
			if (!that.thicknessCommand || that._thickness == 0) that.drawShape();
			else {
				that.thicknessCommand.width = that._thickness;
				if (that._dashed) {
					that.dashedCommand.segments = that._dashed;
					that.dashedCommand.offset = that._dashedOffset;
				}
			}
		}
	});
	Object.defineProperty(that, 'dashed', {
		get: function() {
			return that._dashed;
		},
		set: function(value) {
			that._dashed = value;
			if (value && !Array.isArray(that._dashed)) that.dashed = [10, 10];
			if (that.type == "Squiggle" || that.type == "Line") {
				if (!that.thicknessCommand || that._thickness == 0) return;
				var dashedCommand = that.dashedCommand;
			} else {
				if (!that.borderWidthCommand || that._borderWidth == 0) return;
				var dashedCommand = that.borderDashedCommand;
			}
			if (!dashedCommand) {
				that.drawShape();
			} else {
				if (that._dashed) {
					dashedCommand.segments = that._dashed;
					dashedCommand.offset = that._dashedOffset;
				} else {
					dashedCommand.segments = null;
					dashedCommand.offset = null;
				}
			}
		}
	});
	Object.defineProperty(that, 'dashedOffset', {
		get: function() {
			return that._dashedOffset;
		},
		set: function(value) {
			if (isNaN(value)) value = 5;
			that._dashedOffset = value;
			if (that.type == "Squiggle" || that.type == "Line") {
				if (!that.thicknessCommand || that._thickness == 0) return;
				var dashedCommand = that.dashedCommand;
			} else {
				if (!that.borderWidthCommand || that._borderWidth == 0) return;
				var dashedCommand = that.borderDashedCommand;
			}

if (!dashedCommand) {
				that.drawShape();
			} else {
				if (that._dashed) {
					dashedCommand.segments = that._dashed;
					dashedCommand.offset = that._dashedOffset;
				} else {
					dashedCommand.segments = null;
					dashedCommand.offset = null;
				}
			}
		}
	});
	Object.defineProperty(that, 'corner', {
		get: function() {
			return that._corner;
		},
		set: function(value) {
			that._corner = value;
			that.drawShape();
		}
	});

// special clone that clones contents of shape
	this.cloneAll = function(exact, style, group, inherit) {
		var currentBounds = this.getBounds();
		if (zot(currentBounds)) currentBounds = {x:null, y:null, width:null, height:null};
		var body = this.cloneChildren(this.cloneProps(new zim.Container(currentBounds.x,currentBounds.y,currentBounds.width,currentBounds.height, style, group, inherit)), exact);
		body.mouseChildren = false;
		body.type = this.type;
		return body;
	};

};
zim.extend(zim.CustomShape, zim.Container, null, "zimContainer", false);

zim.Circle = function(radius, color, borderColor, borderWidth, dashed, percent, percentClose, strokeObj, style, group, inherit) {
		var sig = "radius, color, borderColor, borderWidth, dashed, percent, percentClose, strokeObj, style, group, inherit";
		var duo; if (duo = zob(zim.Circle, arguments, sig, this)) return duo;
		this.zimCustomShape_constructor(null,null,null,null,false);
		this.type = "Circle";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);
		if (zot(radius)) radius = DS.radius!=null?DS.radius:50;
		if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
		if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
		if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
		else if (borderColor!=null && borderWidth==null) borderWidth = 1;
		if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":"black");
		if (zot(percent)) percent = DS.percent!=null?DS.percent:100;
		if (zot(percentClose)) percentClose = DS.percentClose!=null?DS.percentClose:true;
		if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

// PICK
		var oa = remember(radius, color, borderColor, borderWidth, percent);
		function remember() {return arguments;} // for cloning PICK
		radius = zim.Pick.choose(radius);
		color = zim.Pick.choose(color);
		borderColor = zim.Pick.choose(borderColor);
		borderWidth = zim.Pick.choose(borderWidth);
		percent = zim.Pick.choose(percent);

var that = this;
		that._radius = radius;
		that._color = color;
		that._borderColor = borderColor;
		that._borderWidth = borderWidth;
		that._dashed = dashed;
		if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];

var circle = this.shape = new createjs.Shape();
		this.addChild(circle);

Object.defineProperty(that, 'radius', {
			get: function() {
				return that._radius;
			},
			set: function(value) {
				that._radius = value;
				that.drawShape();
			}
		});
		
		Object.defineProperty(that, 'percent', {
			get: function() {
				return percent;
			},
			set: function(value) {
				percent = value;
				that.drawShape();
			}
		});
		
		Object.defineProperty(that, 'percentClose', {
			get: function() {
				return percentClose;
			},
			set: function(value) {
				percentClose = value;
				that.drawShape();
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// NOTE: extends ZIM CustomShape for more properties and a few functions.
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it

this.clone = function(exact, container) {
			var newShape = that.cloneProps(new zim.Circle((exact||!zim.isPick(oa[0]))?that.radius:oa[0], (exact||!zim.isPick(oa[1]))?that.color:oa[1], (exact||!zim.isPick(oa[2]))?that.borderColor:oa[2], (exact||!zim.isPick(oa[3]))?that.borderWidth:oa[3], that.dashed, (exact||!zim.isPick(oa[4]))?percent:oa[4], percentClose, strokeObj, style, this.group, inherit));
			if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
			if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
			return newShape;
		};
	};
	zim.extend(zim.Circle, zim.CustomShape, "clone", "zimCustomShape", false);

zim.Rectangle = function(width, height, color, borderColor, borderWidth, corner, dashed, strokeObj, style, group, inherit) {
    var sig = "width, height, color, borderColor, borderWidth, corner, dashed, strokeObj, style, group, inherit";
    var duo; if (duo = zob(zim.Rectangle, arguments, sig, this)) return duo;
    this.zimCustomShape_constructor(null,null,null,null,false);
    this.type = "Rectangle";
    this.group = group;

var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

if (zot(width)) width = DS.width!=null?DS.width:null;
    if (zot(height)) height = DS.height!=null?DS.height:!zot(width)?width:100;
    if (zot(width)) width = height;
    if (zot(corner)) corner = DS.corner!=null?DS.corner:0;
    if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
    if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
    if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
    if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
    else if (borderColor!=null && borderWidth==null) borderWidth = 1;
    if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":"black");
    if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

// PICK
    var oa = remember(width, height, color, borderColor, borderWidth);
    function remember() {return arguments;} // for cloning PICK
    width = zim.Pick.choose(width);
    height = zim.Pick.choose(height);
    color = zim.Pick.choose(color);
    borderColor = zim.Pick.choose(borderColor);
    borderWidth = zim.Pick.choose(borderWidth);

var that = this;
    that._color = color;
    that._borderColor = borderColor;
    that._borderWidth = borderWidth;
	that._dashed = dashed;    
    if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];
	that._corner = corner;

var rectangle = this.shape = new createjs.Shape();
    this.addChild(rectangle);

that.setBounds(0,0,width,height);
    };
	that.drawShape();
	
	// Object.defineProperty(that, 'corner', {
	// 	get: function() {
	// 		return corner;
	// 	},
	// 	set: function(value) {
	// 		corner = value;
	// 		that.drawShape();
	// 	}
	// });

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // NOTE: extends ZIM CustomShape for more properties and a few functions.
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS);
    this.clone = function(exact) {
        var newShape =  that.cloneProps(new zim.Rectangle((exact||!zim.isPick(oa[0]))?width:oa[0], (exact||!zim.isPick(oa[1]))?height:oa[1], (exact||!zim.isPick(oa[2]))?that.color:oa[2], (exact||!zim.isPick(oa[3]))?that.borderColor:oa[3], (exact||!zim.isPick(oa[4]))?that.borderWidth:oa[4], corner, that._dashed, strokeObj, style, this.group, inherit));
        return newShape;
    };
};
zim.extend(zim.Rectangle, zim.CustomShape, "clone", "zimCustomShape", false);

zim.Triangle = function(a, b, c, color, borderColor, borderWidth, corner, center, adjust, dashed, strokeObj, style, group, inherit) {
    var sig = "a, b, c, color, borderColor, borderWidth, corner, center, adjust, dashed, strokeObj, style, group, inherit";
    var duo; if (duo = zob(zim.Triangle, arguments, sig, this)) return duo;
    this.zimCustomShape_constructor(null,null,null,null,false);
    this.type = "Triangle";
    this.group = group;
    var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

if (zot(a)) a = DS.a!=null?DS.a:100;
    if (zot(b)) b = DS.b!=null?DS.b:a;
    if (zot(c)) c = DS.c!=null?DS.c:b;
    if (c==-1) c = Math.sqrt(Math.pow(a,2)+Math.pow(b,2));
	if (zot(corner)) corner = DS.corner!=null?DS.corner:0;
    if (zot(center)) center = DS.center!=null?DS.center:true;
    if (zot(adjust)) adjust = DS.adjust!=null?DS.adjust:0;
    if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
    if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
    if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
    else if (borderColor!=null && borderWidth==null) borderWidth = 1;
    if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":"black");
    if (zot(adjust)) adjust = DS.adjust!=null?DS.adjust:0;
    if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

// PICK
    var oa = remember(a, b, c, color, borderColor, borderWidth);
    function remember() {return arguments;} // for cloning PICK
    a = zim.Pick.choose(a);
    b = zim.Pick.choose(b);
    c = zim.Pick.choose(c);
    this.a = a;
    this.b = b;
    this.c = c;
    color = zim.Pick.choose(color);
    borderColor = zim.Pick.choose(borderColor);
    borderWidth = zim.Pick.choose(borderWidth);

var that = this;
    that._color = color;
    that._borderColor = borderColor;
    that._borderWidth = borderWidth;
    that._dashed = dashed;
    if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];
	that._corner = corner;

var lines = [a,b,c];
    lines.sort(function(a, b){return b-a;});
    var aa = lines[0];
    var bb = lines[1];
    var cc = lines[2];
    var order = [lines.indexOf(a), lines.indexOf(b), lines.indexOf(c)];

if (aa > bb+cc) {
        zog("zim display - Triangle(): invalid triangle lengths");
        return;
    }

var tri = this.shape = new createjs.Shape();
    this.adjusted = adjust;
    this.addChild(tri);

// find biggest angle with cosine rule
        var angle1 = Math.acos( (Math.pow(bb,2) + Math.pow(cc,2) - Math.pow(aa,2)) / (2 * bb * cc) ) * 180 / Math.PI;

// use the sine rule for next biggest angle
        var angle2 = Math.asin( bb * Math.sin(angle1 * Math.PI / 180) / aa ) * 180 / Math.PI;

// find last angle
        var angle3 = 180 - angle1 - angle2;

// get position of angles by mapping to opposite side sizes
        // as in smallest angle is across from smallest side
        // largest angle is across from largest size, etc.
        var temp = [angle1, angle2, angle3]; // largets to smallest
        that.angles = [temp[order[1]], temp[order[2]], temp[order[0]]];

var nextAngle = that.angles[1];
        var backX = Math.cos(nextAngle * Math.PI / 180) * b;
        var upY = Math.sin(nextAngle * Math.PI / 180) * b;

var width = Math.max(a, a-backX);
        var height = upY;
        that.setBounds(0,adjust,width,height);
        tri.y = height;
			
        that.three={x:a-backX,y:0-upY};
				
		var sX = a*corners[0]/((corners[0]+corners[1])||1);
		g
			.mt(sX,0)
			.at(a,0, a-backX,0-upY, corners[1])
			.at(a-backX,0-upY, 0,0, corners[2])
			.at(0,0, a,0, corners[0])
			.lt(sX,0);
			
		g.cp();

if (center) {
            that.regX = width/2;
            that.regY = height/2;
        }
        if (adjust) {
            that.shape.y+=adjust;
        }
    };
	that.drawShape();

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // NOTE: extends ZIM CustomShape for more properties and a few functions.
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS);
    this.clone = function(exact) {
        var newShape = that.cloneProps(new zim.Triangle((exact||!zim.isPick(oa[0]))?a:oa[0], (exact||!zim.isPick(oa[1]))?b:oa[1], (exact||!zim.isPick(oa[2]))?c:oa[2], (exact||!zim.isPick(oa[3]))?that.color:oa[3], (exact||!zim.isPick(oa[4]))?that.borderColor:oa[4], (exact||!zim.isPick(oa[5]))?that.borderWidth:oa[5], corner, center, adjust, dashed, strokeObj, style, this.group, inherit));
        if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
        if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
        return newShape;
    };
};
zim.extend(zim.Triangle, zim.CustomShape, "clone", "zimCustomShape");

zim.Line = function(length, thickness, color, startHead, endHead, dashed, strokeObj, lineType, lineOrientation, curveH, curveV, points, style, group, inherit) {
		var sig = "length, thickness, color, startHead, endHead, dashed, strokeObj, lineType, lineOrientation, curveH, curveV, points, style, group, inherit";
		var duo; if (duo = zob(zim.Line, arguments, sig, this)) return duo;
		this.zimCustomShape_constructor(null,null,null,null,false);
		this.type = "Line";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);
		if (zot(length)) length = DS.length!=null?DS.length:100;
		if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(thickness)) thickness = DS.thickness!=null?DS.thickness:3;
		if (zot(color)) color = DS.color!=null?DS.color:"black";
		if (zot(startHead)) startHead = DS.startHead!=null?DS.startHead:null;
		if (zot(endHead)) endHead = DS.endHead!=null?DS.endHead:null;
		if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

if (zot(lineType)) lineType = DS.lineType!=null?DS.lineType:"straight";
		if (lineType !== "corner" && lineType != "curve") lineType = "straight";
		if (zot(lineOrientation)) lineOrientation = DS.lineOrientation!=null?DS.lineOrientation:"auto";
		if (lineOrientation !== "vertical" && lineOrientation != "horizontal") lineOrientation = "auto";

if (zot(curveH)) curveH = DS.curveH!=null?DS.curveH:20;
		if (zot(curveV)) curveV = DS.curveV!=null?DS.curveV:20;
		if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

// PICK
		var oa = remember(length, color, thickness, startHead, endHead);
		function remember() {return arguments;} // for cloning PICK
		length = zim.Pick.choose(length);
		color = zim.Pick.choose(color);
		thickness = zim.Pick.choose(thickness);
		startHead = zim.Pick.choose(startHead);
		endHead = zim.Pick.choose(endHead);
		// do below otherwise will be the same head and get moved if cloned
		if (startHead && startHead.clone) startHead = startHead.clone();
		if (endHead && endHead.clone) endHead = endHead.clone();

var that = this;
		that._length = length;
		that._color = color;
		that._thickness = thickness;
		that._dashed = dashed;
		if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];

that._startX = 0;
		that._startY = 0;
		that._endX = length;
		that._endY = 0;
		that._startHead = startHead;
		that._endHead = endHead;
		that._points = points;
		that._lineOrientation = lineOrientation;
		that.angle = 0;
		that.lineType = lineType;

var startRegY;
		if (that._startHead) prepareHead("start", that._startHead);
		if (that._endHead) prepareHead("end", that._endHead);
		function prepareHead(type, head) {
			if (head == "triangle" || head == "arrow") {
				var h = that["_"+type+"Head"] = new zim.Triangle(thickness*4, thickness*4, thickness*4, color);
				h.rotation = 90;
			} else if (head == "circle") {
				that["_"+type+"Head"] = new zim.Circle(thickness*2.2, color);
			}
			if (zot(that["_"+type+"Head"].startAngle)) that["_"+type+"Head"].startAngle = that["_"+type+"Head"].rotation;
		}

startHead = that._startHead;
		endHead = that._endHead;

if (startHead && startHead.type == "Triangle") startHead.startRegY = startHead.regY;
		if (endHead && endHead.type == "Triangle") endHead.startRegY = endHead.regY;

var shape = this.shape = new createjs.Shape();
		this.addChild(shape);

var sX = that._startX;
				var sY = that._startY;
				var eX = that._endX;
				var eY = that._endY;

if (that.lineType == "straight") {
					if (startHead && startHead.type == "Triangle") {
						startHead.regY = 0;
						var d = zim.dist(sX,sY,eX,eY);
						if (d != 0) sX = sX + that._startHead.height/2*(eX-sX)/d;
						if (d != 0) sY = sY + that._startHead.height/2*(eY-sY)/d;
					}
					if (endHead && endHead.type == "Triangle") {
						endHead.regY = 0;
						var d = zim.dist(sX,sY,eX,eY);
						if (d != 0) eX = eX - that._endHead.height/2*(eX-sX)/d;
						if (d != 0) eY = eY - that._endHead.height/2*(eY-sY)/d;
					}
				} else {
					if (arrowAdjustStart) {
						if (that._lineOrientation == "horizontal" || that.autoOrientation == "horizontal") {
							if (startHead && startHead.type == "Triangle") {
								startHead.regY = 0;
								// if (eX > sX) sX += that._startHead.height/2;
								// else sX -= that._startHead.height/2;
								if (eX > sX) {
									sX = Math.min(eX, sX+that._startHead.height/2);
								} else {
									sX = Math.max(eX, sX-that._startHead.height/2);
								}
							}
						} else {
							if (startHead && startHead.type == "Triangle") {
								startHead.regY = 0;
								// if (eY > sY) sY += that._startHead.height/2;
								// else sY -= that._startHead.height/2;
								if (eY > sY) {
									sY = Math.min(eY, sY+that._startHead.height/2);
								} else {
									sY = Math.max(eY, sY-that._startHead.height/2);
								}
							}
						}
					} else {
						if (startHead && startHead.type == "Triangle") startHead.regY = startHead.startRegY;
					}
					if (arrowAdjustEnd) {
						if (that._lineOrientation == "horizontal" || that.autoOrientation == "horizontal") {
							if (endHead && endHead.type == "Triangle") {
								endHead.regY = 0;
								if (eX > sX) eX -= that._endHead.height/2;
								else eX += that._endHead.height/2;
							}
						} else {
							if (endHead && endHead.type == "Triangle") {
								endHead.regY = 0;
								if (eY > sY) eY -= that._endHead.height/2;
								else eY += that._endHead.height/2;
							}
						}
					} else {
						if (endHead && endHead.type == "Triangle") endHead.regY = endHead.startRegY;
					}
				}

if (that.lineType == "straight") {
					g.mt(sX, sY).lt(eX, eY);
					startArrowGuide = endArrowGuide = [sX, sY, eX, eY];
				} else if (that.lineType == "corner") {
					var midX = sX + (eX-sX)*.4;
					var midY = sY + (eY-sY)*.4;
					if (that._lineOrientation == "auto") {
						that.autoOrientation = (Math.abs(sX-eX) > Math.abs(sY-eY))?"horizontal":"vertical";
					}
					if (that._lineOrientation == "horizontal" || that.autoOrientation == "horizontal") {
						startArrowGuide = endArrowGuide = [sX, sY, midX, sY];
						// startArrowGuide = endArrowGuide = [that._startX, that._startY, midX, that._startY];
						g.mt(sX, sY).lt(midX, sY).lt(midX, eY).lt(eX, eY);
					} else {
						startArrowGuide = endArrowGuide = [sX, sY, sX, midY];
						// startArrowGuide = endArrowGuide = [that._startX, that._startY, that._startX, midY];
						g.mt(sX, sY).lt(sX, midY).lt(eX, midY).lt(eX, eY);
					}
				} else { // "curve"
					var hSign = (sX > eX)?-1:1;
					var vSign = (sY > eY)?-1:1;

var nextX = sX; // relative drawing would be handy but not implemente in version yet
					var nextY = sY;
					var distX = Math.abs(sX - eX);
					var distY = Math.abs(sY - eY);
					var curveX = Math.min(curveH, distX*.5); // need proportion curve until hits curveH
					var curveY = Math.min(curveV, distY*.5);

if (that._lineOrientation == "auto") {
						that.autoOrientation = (Math.abs(sX-eX) > Math.abs(sY-eY))?"horizontal":"vertical";
					}

if (that._lineOrientation == "horizontal" || that.autoOrientation == "horizontal") {

var insideDistance = (distY-curveY*2);
						var outsideDistance = (distX-curveX*2)/2;

g.mt(nextX, nextY);
						if (outsideDistance > 0) {
							nextX = nextX+outsideDistance*hSign;
							g.lt(nextX, nextY);
						}

var lastY = nextY;
						nextY = nextY+curveY*vSign;
						nextX = nextX+curveX*hSign;
						g.qt(nextX, lastY, nextX, nextY);

startArrowGuide = endArrowGuide = [sX, sY, nextX, sY];

if (insideDistance > 0) {
							nextY = nextY+insideDistance*vSign;
							g.lt(nextX, nextY);
						}
						nextY = nextY+curveY*vSign;
						var lastX = nextX;
						nextX = nextX+curveX*hSign;
						g.qt(lastX, nextY, nextX, nextY);
						if (outsideDistance > 0) {
							nextX = nextX+outsideDistance*hSign;
							g.lt(nextX, nextY);
						}

} else {

var insideDistance = (distX-curveX*2);
						var outsideDistance = (distY-curveY*2)/2;

g.mt(nextX, nextY);
						if (outsideDistance > 0) {
							nextY = nextY+outsideDistance*vSign;
							g.lt(nextX, nextY);
						}

var lastX = nextX;
						nextX = nextX+curveX*hSign;
						nextY = nextY+curveY*vSign;
						g.qt(lastX, nextY, nextX, nextY);

startArrowGuide = endArrowGuide = [sX, sY, sX, nextY];

if (insideDistance > 0) {
							nextX = nextX+insideDistance*hSign;
							g.lt(nextX, nextY);
						}
						nextX = nextX+curveX*hSign;
						var lastY = nextY;
						nextY = nextY+curveY*vSign;
						g.qt(nextX, lastY, nextX, nextY);
						if (outsideDistance > 0) {
							nextY = nextY+outsideDistance*vSign;
							g.lt(nextX, nextY);
						}
					}
				}
			}

that.setBounds(Math.min(that._startX, that._endX),Math.min(that._startY, that._endY),Math.abs(that._startX-that._endX),Math.abs(that._startY-that._endY));
			that._length = Math.sqrt(Math.pow(that._startX-that._endX,2) + Math.pow(that._startY-that._endY,2));
			that.angle = Math.atan2(that._endY-that._startY, that._endX-that._startX) * 180 / Math.PI;
			if (that._startHead && that._startHead.loc) {
				that._startHead.loc(that._startX, that._startY, that);
				var startAngle = Math.atan2(startArrowGuide[3]-startArrowGuide[1], startArrowGuide[2]-startArrowGuide[0]) * 180 / Math.PI;
				that._startHead.rotation = startAngle-180+that._startHead.startAngle;
			}
			if (that._endHead && that._endHead.loc) {
				that._endHead.loc(that._endX, that._endY, that);
				var endAngle = Math.atan2(endArrowGuide[3]-endArrowGuide[1], endArrowGuide[2]-endArrowGuide[0]) * 180 / Math.PI;
				that._endHead.rotation = endAngle+that._endHead.startAngle;
			}

};
		that.drawShape();

this.setPoints = function(a, b, c, d, arrowAdjustStart, arrowAdjustEnd) {
			if (Array.isArray(a) && zot(b)) {
				that.points = a;
				return that;
			} else if (a && !zot(a.x)) {
				that._startX = zot(a.x)?that._startX:a.x;
				that._startY = zot(a.y)?that._startY:a.y;
				if (b) {
					that._endX = zot(b.x)?that._endX:b.x;
					that._endY = zot(b.y)?that._endY:b.y;
				}
			} else {
				that._startX = zot(a)?that._startX:a;
				that._startY = zot(b)?that._startY:b;
				that._endX = zot(c)?that._endX:c;
				that._endY = zot(d)?that._endY:d;
			}
			that.drawShape(arrowAdjustStart, arrowAdjustEnd);
			return that;
		};

this.from = function(a, b) {
			if (a && !zot(a.x)) {
				that._startX = zot(a.x)?that._startX:a.x;
				that._startY = zot(a.y)?that._startY:a.y;
			} else {
				that._startX = zot(a)?that._startX:a;
				that._startY = zot(b)?that._startY:b;
			}
			that.drawShape();
			return that;
		};

this.to = function(a, b) {
			if (a && !zot(a.x)) {
				that._endX = zot(a.x)?that._endX:a.x;
				that._endY = zot(a.y)?that._endY:a.y;
			} else {
				that._endX = zot(a)?that._endX:a;
				that._endY = zot(b)?that._endY:b;
			}
			that.drawShape();
			return that;
		};

Object.defineProperty(that, 'length', {
			get: function() {
				return that._length;
			},
			set: function(value) {
				var s = that.length!=0 ? value/that.length : 0;
				if (isNaN(s)) return;
				var startScaleX = that.scaleX;
				var startScaleY = that.scaleY;
				that.scaleX *= s;
				that.scaleY *= s;
				var gStart = that.localToGlobal(that._startX, that._startY);
				var gEnd = that.localToGlobal(that._endX, that._endY);
				that.scaleX = startScaleX;
				that.scaleY = startScaleY;
				var lStart = that.globalToLocal(gStart.x, gStart.y);
				var lEnd = that.globalToLocal(gEnd.x, gEnd.y);
				that.setPoints(lStart, lEnd);
			}
		});
		Object.defineProperty(that, 'startPoint', {
			get: function() {
				return new zim.Point(that._startX, that._startY);
			},
			set: function(value) {
				that._startX = zot(value.x)?that._startX:value.x;
				that._startY = zot(value.y)?that._startY:value.y;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endPoint', {
			get: function() {
				return new zim.Point(that._endX, that._endY);
			},
			set: function(value) {
				that._endX = zot(value.x)?that._endX:value.x;
				that._endY = zot(value.y)?that._endY:value.y;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startHead', {
			get: function() {
				return that._startHead;
			},
			set: function(value) {
				that._startHead = value;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endHead', {
			get: function() {
				return that._endHead;
			},
			set: function(value) {
				that._endHead = value;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startX', {
			get: function() {
				return that._startX;
			},
			set: function(value) {
				that._startX = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startY', {
			get: function() {
				return that._startY;
			},
			set: function(value) {
				that._startY = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endX', {
			get: function() {
				return that._endX;
			},
			set: function(value) {
				that._endX = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endY', {
			get: function() {
				return that._endY;
			},
			set: function(value) {
				that._endY = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'points', {
			get: function() {
				return that._points;
			},
			set: function(value) {
				if (!value) return;
				that._points = value;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'lineOrientation', {
			get: function() {
				return that._lineOrientation;
			},
			set: function(value) {
				if (!value) return;
				that._lineOrientation = value;
				that.drawShape();
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// NOTE: extends ZIM CustomShape for more properties and a few functions.
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it

this.clone = function(exact, container) {
			var startH = (exact||!zim.isPick(oa[3]))?that._startHead:oa[3];
			if (startH) {
				if (startH.clone) {
					startH = startH.clone();
					startH.rotation = that._startHead.startAngle;
				}
			}
			var endH = (exact||!zim.isPick(oa[4]))?that._endHead:oa[4];
			if (endH) {
				if (endH.clone) {
					endH = endH.clone();
					endH.rotation = that._endHead.startAngle;
				}
			}
			var newShape = that.cloneProps(new zim.Line((exact||!zim.isPick(oa[0]))?that.length:oa[0], (exact||!zim.isPick(oa[2]))?that.thickness:oa[2], (exact||!zim.isPick(oa[1]))?that.color:oa[1], startH, endH, that.dashed, strokeObj, lineType, that._lineOrientation, curveH, curveV, zim.copy(points), style, this.group, inherit));
			if (that.points) newShape.setPoints(that.points);
			else newShape.setPoints(that._startX, that._startY, that._endX, that._endY);

if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
			if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
			return newShape;
		};
	};
	zim.extend(zim.Line, zim.CustomShape, "clone", "zimCustomShape", false);

zim.Squiggle = function(color, thickness, points, length, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, stickColor, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit) {
		var sig = "color, thickness, points, length, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, stickColor, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit";
		var duo; if (duo = zob(zim.Squiggle, arguments, sig, this)) return duo;

this.group = group;
		var DS = style===false?{}:zim.getStyle("Squiggle", this.group, inherit);

if (zot(thickness)) thickness = DS.thickness!=null?DS.thickness:6;
		if (zot(length)) length = DS.length!=null?DS.length:300;
		if (zot(points)) points = DS.points!=null?DS.points:5;
		if (typeof points == "string") {
			var svgProcessor = new zim.SVGContainer();
			points = svgProcessor.processPath(points);
		}
		var num = typeof points == "number" ? points : points.length;
		if (num == 0) return;
		if (zot(controlLength)) controlLength = DS.controlLength!=null?DS.controlLength:(length / num);
		this.zimCustomShape_constructor(length, controlLength, null, null, false);
		this.type = "Squiggle";

this.mouseChildren = true; // set to false in CustomShape

if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(color)) color = DS.color!=null?DS.color:zim.blue;
		if (color.style) {this.colorCommand = color; color = "black";}

if (zot(controlType)) controlType = DS.controlType!=null?DS.controlType:null;
		var originalControlType = controlType;
		if (zot(controlType)) controlType = "mirror";
		if (zot(lockControlType)) lockControlType = DS.lockControlType!=null?DS.lockControlType:false;
		if (zot(interactive)) interactive = DS.interactive!=null?DS.interactive:true;
		if (zot(showControls)) showControls = DS.showControls!=null?DS.showControls:interactive;
		var _controls = showControls;
		if (zot(lockControls)) lockControls = DS.lockControls!=null?DS.lockControls:!interactive;
		if (zot(handleSize)) handleSize = DS.handleSize!=null?DS.handleSize:zim.mobile()?20:10;
		if (zot(allowToggle)) allowToggle = DS.allowToggle!=null?DS.allowToggle:interactive;
		if (zot(move)) move = DS.move!=null?DS.move:interactive;
		if (zot(stickColor)) stickColor = DS.stickColor!=null?DS.stickColor:"#111";
		if (zot(selectColor)) selectColor = DS.selectColor!=null?DS.selectColor:"#fff";
		if (zot(selectPoints)) selectPoints = DS.selectPoints!=null?DS.selectPoints:interactive;
		this.stickColor = stickColor;

if (zot(onTop)) onTop = DS.onTop!=null?DS.onTop:true;
		if (zot(editPoints)) editPoints = DS.editPoints!=null?DS.editPoints:interactive;
		if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

var oa = remember(color);
		function remember() {return arguments;} // for cloning PICK
		color = zim.Pick.choose(color);

var that = this;
		var stage;
		var types = this.types = ["mirror", "straight", "free", "none"];
		this.interactive = interactive;
		this.num = num;
		this.onTop = onTop;
		this.move = move;
		this.editPoints = editPoints;
		this.allowToggle = allowToggle;
		this.lockControlType = lockControlType;
		this.selectPoints = selectPoints;
		this.lockControls = lockControls;

var _points;
		var _pointCircles;
		var _pointControls;
		that._color = color;
		that._thickness = thickness;
		that._dashed = dashed;
		if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];

var shape;
		var moveDownEvent;
		var movePressEvent;
		var moveUpEvent;

var draggingCheck = that.move;
		var min = 2; // min distance within which a click will add a point

var mapMove;
		var sets;

if (originalControlType && typeof points != "number") {
			// override controlType
			zim.loop(points, function(point) {
				point[8]=originalControlType;
				if (originalControlType == "none") {
					point[4]=point[5]=point[6]=point[7]=0;
				}
			});
		}

init();
		function init() {
			if (sets) sets.removeAllEventListeners();

that.num = num = typeof points == "number" ? points : points.length;
			num = Math.max(2,num);
			controlLength = length / num;

shape = that.shape = new zim.Shape({style:false}).addTo(that);
			var sticks = that.sticks = new zim.Shape({style:false}).addTo(that);
			if (handleSize <= 0) sticks.removeFrom();
			var g = shape.graphics;
			g.c();
			var s = sticks.graphics;
			s.c();

var ballS = handleSize/10*8;
			var rectS = handleSize;

if (that.selectPoints) {
				that.selectedBalls = new zim.SelectionSet();
				that.selectedRect1s = new zim.SelectionSet();
				that.selectedRect2s = new zim.SelectionSet();

that.selectionManager = new zim.SelectionManager([
					that.selectedBalls,
					that.selectedRect1s,
					that.selectedRect2s
				], "ctrl", false);
			} else {
				that.selectionManager = new zim.SelectionManager(null, "ctrl");
			}

var mobile = zim.mobile();

sets = that.controls = new zim.Container({style:false}).addTo(that); // sets - a set contains a ball and two rects
			if (that.interactive) sets.drag({onTop:!mobile});
			_points = [];
			_pointControls = [];
			_pointCircles = [];

var angle, point, temp, set, rect1, rect2, ball, type, setInfo;

for (var i=0; i<num; i++) {
				set = new zim.Container({style:false}).addTo(sets);
				set.num = i;
				if (typeof points == "number") { // no sets yet
					var stickLength = zim.Pick.choose(controlLength);
					temp = new zim.Container(stickLength, thickness, null, null, false).addTo(that).loc({x:i*length/(num-1)-stickLength/2, y:i%2*stickLength});
					ball = new zim.Circle(ballS, that.selectPoints&&that.selectedBalls.isSelected(i)?selectColor:zim.light, zim.dark, 2, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:stickLength/2, y:0});
					rect1 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(controlType),  handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, false)
						.centerReg(temp)
						.loc({x:0,y:0});
					rect2 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(controlType),  handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, false)
						.centerReg(temp)
						.loc({x:stickLength,y:0});

var ballPoint = temp.localToLocal(ball.x, ball.y, sets);
					ball.x = ballPoint.x;
					ball.y = ballPoint.y;
					ball.addTo(set, null, false);
					var rect1Point = temp.localToLocal(rect1.x, rect1.y, sets);
					rect1.x = controlType=="none"?0:rect1Point.x-ball.x;
					rect1.y = controlType=="none"?0:rect1Point.y-ball.y;
					rect1.addTo(set, null, false);
					var rect2Point = temp.localToLocal(rect2.x, rect2.y, sets);
					rect2.x = controlType=="none"?0:rect2Point.x-ball.x;
					rect2.y = controlType=="none"?0:rect2Point.y-ball.y;
					rect2.addTo(set, null, false);
					set.x = ball.x;
					set.y = ball.y;
					ball.x = 0;
					ball.y = 0;
					if (controlType=="none") ball.addTo(set, null, false); // on top

} else { // passing in set data

// _pointCircles are relative to squiggle but handles are relative to ball
					// points is an array of [[setX, setY, ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]

setInfo = points[i];
					type = setInfo[8] ? setInfo[8] : controlType;
					set.loc({x:setInfo[0], y:setInfo[1]});
					ball = new zim.Circle(ballS, zim.light, zim.dark, 2, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set)
						.loc({x:setInfo[2],y:setInfo[3]});
					rect1 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type),  handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[4],y:setInfo[5]});
					rect2 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type), handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[6],y:setInfo[7]});
				}

ball.mySet = set;
				ball.rect1 = rect1;
				ball.rect2 = rect2;
				ball.index = i;

if (mobile) {
					ball.on("mousedown", mobileDouble);
				} else {
					ball.on("dblclick", doubleIt);
				}

rect1.ball = ball;
				rect1.other = rect2;
				rect2.ball = ball;
				rect2.other = rect1;

if (handleSize==0) {
					ball.expand(10);
					rect1.expand(10);
					rect2.expand(10);
				}

if (mobile) {
					ball.expand();
					rect1.expand();
					rect2.expand();
				}

point = [set, ball, rect1, rect2, setInfo?setInfo[8]:controlType];
				_points.push(point);
				_pointCircles.push(ball);
				_pointControls.push(set);
			}

ball.rect1.color = getBackgroundColor(type);
				ball.rect2.color = getBackgroundColor(type);
				that.drawShape();
				var ev = new createjs.Event("change");
				ev.controlType = "bezierSwitch";
				that.dispatchEvent(ev);
				ball.stage.update();
			}

function getBackgroundColor(type) {
				var colors = {straight:zim.pink, free:zim.yellow, none:zim.blue};
				return colors[type] ? colors[type] : zim.purple;
			}

that.drawShape = function () {
				g.c();
				var minThickness = zim.mobile() ? 10 : 6;
				if (thickness < minThickness) {
					// 1. draw backing grab line
					g.s("rgba(0,0,0,.01)").ss(minThickness);
					var set = _points[0][0];
					var ballPoint = set.localToLocal(_points[0][1].x, _points[0][1].y, shape);
					g.mt(ballPoint.x, ballPoint.y);

var currentIndex; var nextIndex;
					for (var i=0; i<_points.length; i++) {
						var currentIndex = i;
						var nextIndex = (i+1)%_points.length;

var set = _points[currentIndex][0];
						var ball = _points[currentIndex][1];
						var control1 = _points[currentIndex][2];
						var control2 = _points[currentIndex][3];

var nextSet = _points[nextIndex][0];
						var nextBall = _points[nextIndex][1];
						var nextControl1 = _points[nextIndex][2];
						var nextControl2 = _points[nextIndex][3];
						// var ctype = _points[currentIndex][4]; // STEFAN

var control2Point = set.localToLocal(control2.x, control2.y, shape);
						var nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
						var nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);

if (i != _points.length-1) {
							// if (ctype == 'none') { // STEFAN
							// 	g.lt(nextBallPoint.x, nextBallPoint.y);
							// } else {
								g.bt(
									control2Point.x, control2Point.y,
									nextControl1Point.x, nextControl1Point.y,
									nextBallPoint.x, nextBallPoint.y
								);
							// }						
						}
					}
				}

// 2. draw real line

if (!that.colorCommand) {
					that.colorCommand = g.s(that._color).command;
					if (color && color.type) that.specialColor(that.colorCommand, color);
				}
				if (!that.thicknessCommand) that.thicknessCommand = g.ss(that._thickness, strokeObj.caps, strokeObj.joints, strokeObj.miterLimit, strokeObj.ignoreScale).command;
				if (that._dashed) {
					if (!that.dashedCommand) that.dashedCommand = g.sd(Array.isArray(that._dashed)?that._dashed:[10, 10], that._dashedOffset).command;
				}

set = _points[0][0];
				ballPoint = set.localToLocal(_points[0][1].x, _points[0][1].y, shape);
				g.mt(ballPoint.x, ballPoint.y);

s.c().s(that.stickColor).ss(1);
				
				var currentIndex; var nextIndex;
				for (var i=0; i<_points.length; i++) {
					var currentIndex = i;
					var nextIndex = (i+1)%_points.length;
				
					var set = _points[currentIndex][0];
					var ball = _points[currentIndex][1];
					var control1 = _points[currentIndex][2];
					var control2 = _points[currentIndex][3];
					// var ctype = _points[currentIndex][4]; // STEFAN
				
					var nextSet = _points[nextIndex][0];
					var nextBall = _points[nextIndex][1];
					var nextControl1 = _points[nextIndex][2];
					var nextControl2 = _points[nextIndex][3];
				
					var control2Point = set.localToLocal(control2.x, control2.y, shape);
					var nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
					var nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);
				
					if (i != _points.length-1) {
						g.bt(
							control2Point.x, control2Point.y,
							nextControl1Point.x, nextControl1Point.y,
							nextBallPoint.x, nextBallPoint.y
						);
					}
				
					// create the sticks
					var ballPoint = set.localToLocal(ball.x, ball.y, shape);
					var control1Point = set.localToLocal(control1.x, control1.y, shape);
				
					if (i == 0) control1.visible = 0;
					if (i != 0) s.mt(ballPoint.x, ballPoint.y).lt(control1Point.x, control1Point.y);
					if (i != _points.length-1) s.mt(ballPoint.x, ballPoint.y).lt(control2Point.x, control2Point.y);
					if (i == _points.length-1) control2.visible = 0;
				}

// var currentIndex; var nextIndex;
				// for (var i=0; i<_points.length; i++) {
				// 	var currentIndex = i;
				// 	var nextIndex = (i+1)%_points.length;
				// 
				// 	var set = _points[currentIndex][0];
				// 	var ball = _points[currentIndex][1];
				// 	var control1 = _points[currentIndex][2];
				// 	var control2 = _points[currentIndex][3];
				// 	var ctype = _points[currentIndex][4]; // STEFAN
				// 
				// 	var nextSet = _points[nextIndex][0];
				// 	var nextBall = _points[nextIndex][1];
				// 	var nextControl1 = _points[nextIndex][2];
				// 	var nextControl2 = _points[nextIndex][3];
				// 
				// 	var control2Point = set.localToLocal(control2.x, control2.y, shape);
				// 	var nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
				// 	var nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);
				// 
				// 	if (i != _points.length - 1) {
				// 		// STEFAN
				// 		if (ctype == 'none') {
				// 			g.lt(nextBallPoint.x, nextBallPoint.y);
				// 			control2.visible = 0;
				// 			control1.visible = 0;
				// 		} else {
				// 			g.bt(control2Point.x, control2Point.y,
				// 			nextControl1Point.x, nextControl1Point.y,
				// 			nextBallPoint.x, nextBallPoint.y);
				// 
				// 			// create the sticks
				// 			var ballPoint = set.localToLocal(ball.x, ball.y, shape);
				// 			var control1Point = set.localToLocal(control1.x, control1.y, shape);
				// 			control2.visible = true;
				// 			control1.visible = true;
				// 			if (i == 0) control1.visible = false;
				// 			if (i != 0) s.mt(ballPoint.x, ballPoint.y).lt(control1Point.x, control1Point.y);
				// 			if (i != _points.length - 1) s.mt(ballPoint.x, ballPoint.y).lt(control2Point.x, control2Point.y);
				// 			if (i == _points.length - 1) control2.visible = false;
				// 		}
				// 	}
				// }

if (that._dashed) g.append(that.dashedCommand);
				g.append(that.thicknessCommand);
				g.append(that.colorCommand);
			};
			that.drawShape();

var startPosition;
			sets.on("mousedown", function(e) {
				stage = e.target.stage;
				if (that.lockControls) return;
				if (that.selectPoints) that.keyFocus = true;
				startPosition = {x:e.target.x, y:e.target.y};
				if (e.target.rect1) { // then mousedown on ball - which has a rect1
					var ball = e.target;
					ball.startX = ball.x;
					ball.startY = ball.y;
					ball.rect1.startX = ball.rect1.x;
					ball.rect1.startY = ball.rect1.y;
					ball.rect2.startX = ball.rect2.x;
					ball.rect2.startY = ball.rect2.y;
				} else { // mousedown on control
					var rect = e.target;
					rect.startX = rect.x;
					rect.startY = rect.y;
					var ball = rect.ball;
					var index = ball.index;
					var type = controlType;
					if (!zot(_points[index][4])) type = _points[index][4];
					if (type == "straight") {
						var other = rect.other;
						var dX = other.x - ball.x;
						var dY = other.y - ball.y;
						other.stickLength = Math.sqrt(Math.pow(dX,2) + Math.pow(dY,2));
					}
				}
				if (that.selectPoints) {
					// need to reset all start points for each control circle and rectangle moved
					var currentSet = that.selectionManager.currentSet;
					if (currentSet && currentSet.selections && currentSet.selections.length > 0) {
						for(var i=0; i<currentSet.selections.length; i++) {
							var point = that.pointObjects[currentSet.selections[i]];
							point[1].startX = point[1].x;
							point[1].startY = point[1].y;
							point[2].startX = point[2].x;
							point[2].startY = point[2].y;
							point[3].startX = point[3].x;
							point[3].startY = point[3].y;
						}
					}
				}
			});

if (that.selectPoints) {
				sets.tap(function (e) {
					if (e.target.rect1) { // then mousedown on ball - which has a rect1
						var ball = e.target;
						that.selectedBalls.toggle(ball.parent.num);
					} else { // mousedown on control
						var rect = e.target;
						rect.color = "white";
						var ball = rect.ball;
						if (ball.rect1 == rect) that.selectedRect1s.toggle(ball.parent.num);
						else that.selectedRect2s.toggle(ball.parent.num);
					}
					// loop through all controls and set to right color based on selection
					for (var i=0; i<that.pointObjects.length; i++) {
						var po = that.pointObjects[i];
						po[1].color = that.selectedBalls.isSelected(i)?zim.white:zim.light;
						po[2].color = that.selectedRect1s.isSelected(i)?zim.white:getBackgroundColor(po[4]);
						po[3].color = that.selectedRect2s.isSelected(i)?zim.white:getBackgroundColor(po[4]);
					}
					stage.update();
				});
			}

sets.on("pressmove", function(e) {
				if (that.lockControls) return;
				if (that.selectPoints) {
					var currentSelected = getCurrentSelected();
					if (currentSelected.indexOf(e.target) == -1) {
						mapMove(e.target);
						that.drawShape();
					} else {
						if (currentSelected.length > 0) {
							var diffX = e.target.x-e.target.startX;
							var diffY = e.target.y-e.target.startY;
							for(var i=0; i<currentSelected.length; i++) {
								var pointObj = currentSelected[i];
								pointObj.x = pointObj.startX + diffX;
								pointObj.y = pointObj.startY + diffY;
								mapMove(pointObj);
							}
							that.drawShape();
						}
					}
				} else {
					mapMove(e.target);
					that.drawShape();
				}
			});

sets.on("pressup", function(e) {
				if (that.lockControls) return;
				var moveControlCheck = (e.target.x != startPosition.x || e.target.y != startPosition.y);
				var ev = new createjs.Event("change");
				if (e.target.rect1) { // pressup on ball
					ev.controlType = "bezierPoint";
					endMove(e.target);
				} else {
					ev.controlType = "bezierHandle";
				}
				if (moveControlCheck) that.dispatchEvent(ev);
			});

that.changeControl = function(index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update) {
				var sig = "index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update";
				var duo; if (duo = zob(that.changeControl, arguments, sig)) return duo;
				if (zot(index)) {
					for (var i=0; i<_points.length; i++) {
						that.changeControl(i, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY);
					}
					return;
				}
				var point = _points[index];
				point[4] = type;
				if (type == "none") {
					if (!zot(circleX)) point[2].x = circleX;
					if (!zot(circleY)) point[2].y = circleY;
					point[2].x = point[1].x;
					point[2].y = point[1].y;
					point[3].x = point[1].x;
					point[3].y = point[1].y;
					point[1].parent.addChild(point[1]);
				} else {
					if (!zot(rect1X)) point[2].x = rect1X;
					if (!zot(rect1Y)) point[2].y = rect1Y;
					if (!zot(rect2X)) point[3].x = rect2X;
					if (!zot(rect2Y)) point[3].y = rect2Y;
					if (!zot(circleX)) point[1].x = circleX;
					if (!zot(circleY)) point[1].y = circleY;
					point[1].parent.addChildAt(point[1], 0);
				}
				if (update) {
					that.update();
					if (stage) stage.update();
				}
			};

that.transformPoints = function(transformType, amount, x, y) {
				that.points = zim.transformPoints(that.points, transformType, amount, x, y);
				return that;
			};

that.traverse = function(obj, start, end, time) {
				var ratios = zim.copy(that.segmentRatios);
				ratios.unshift(0);
				if (zot(end)) end = start+1;
				var forward = start < end;
				if (forward) {
					var startPercent = ratios[start]*100;
					var endPercent = ratios[end]*100;
				} else {
					var startPercent = 50 + (100 - ratios[start]*100)/2;
					var endPercent = 50 + (100 - ratios[end]*100)/2;
				}
				obj.percentComplete = obj.zimStartPercent = startPercent;
				obj.animate({
					ease:"linear",
					props:{path:that},
					rewind:!forward,
					time:time,
					events:true
				});
				obj.on("animation", function (e) {
					// when it hits the end it may start over
					if (obj.percentComplete > endPercent || obj.percentComplete == 0) {
						obj.stopAnimate();
						e.remove();
						var eventObj = new createjs.Event("traversed");
						eventObj.obj = obj;
						that.dispatchEvent(eventObj);
					}
				});
				return that;
			};

that.update = function(normalize) {
				if (normalize) {
					// located any rotated or scaled points
					// and set them back to non-rotated and non-scaled
					// but keep control handles at the earlier positions
					// need to normalize before doing more manual updates with Beziers
					// do not need to normalize if animating blob points
					that.points = that.pointsAdjusted;
				} else {
					that.drawShape();
				}
				that.zimAnimateChanged = true;
				return that;
			};

// squiggle
			if (that.interactive) {
				if (move) shape.drag({onTop:false});
				moveDownEvent = shape.on("mousedown", function(e) {
					stage = e.target.stage;
					startPosition = {x:shape.x, y:shape.y};
					if (that.selectPoints) that.keyFocus = true;
					upTop();
				});
				movePressEvent = shape.on("pressmove", function() {
					sets.x = shape.x;
					sets.y = shape.y;
					sticks.x = shape.x;
					sticks.y = shape.y;
				});
				moveUpEvent = shape.on("pressup", function() {
					var moveControlCheck = (shape.x != startPosition.x || shape.y != startPosition.y);
					var movePoint = shape.localToLocal(that.regX,that.regY,that.parent);
					that.x = movePoint.x;
					that.y = movePoint.y;
					sets.x = sets.y = sticks.x = sticks.y = shape.x = shape.y = 0;
					if (moveControlCheck) {
						var ev = new createjs.Event("change");
						ev.controlType = "move";
						that.dispatchEvent(ev);
					}
					if (stage) stage.update();
				});

if (!that.move) stopDragging(true); // true is first time
			}

function upTop() {
				if (that.onTop) {
					var nc = that.parent.numChildren-1;
					if (that.parent.getChildAt(nc).type == "Keyboard") nc--;
					that.parent.setChildIndex(that, nc);
				}
			}

that.toggleEvent = that.on("mousedown", function() {
				if (!that.allowToggle) return;
				if (!_controls) {
					that.showControls();
					that.dispatchEvent("controlsshow");
				}
			});
						
			that.added(function() {
				stage = that.stage;
				if (that.toggleStageEvent) stage.off("stagemousedown", that.toggleStageEvent);
				that.toggleStageEvent = stage.on("stagemousedown", function(e) {
					if (!that.allowToggle || !that.stage) return;
					if (_controls && !that.hitTestPoint(e.stageX/zim.scaX, e.stageY/zim.scaY, false)) {
						that.hideControls();
						that.dispatchEvent("controlshide");
					}
				});			
			});

that.clickEvent = that.on("click", function() {
				if (that.ctrlKey) {
					setTimeout(function() { // give time for record to work if drag with ctrl down
						that.clone(true).addTo(that.stage).mov(0, 100);
						if (that.allowToggle) {
							that.hideControls();
							that.dispatchEvent("controlshide");
						}
						var ev = new createjs.Event("change");
						ev.controlType = "move";
						that.dispatchEvent(ev);
						that.stage.update();
					}, 50);
				}
			});

that.hideControls = function() {
				that.toggled = false;
				sets.visible = false;
				sticks.visible = false;
				_controls = false;
				if (that.stage) that.stage.update();
				if (!that.allowToggle && that.move) stopDragging();
				return that;
			};
			if (!showControls) that.hideControls();
			that.showControls = function() {
				that.toggled = true;
				// if call this with code then will not trigger a change event - not good for TransformManager.persist()
				sets.visible = true;
				sticks.visible = true;
				_controls = true;
				sets.x = shape.x;
				sets.y = shape.y;
				sticks.x = shape.x;
				sticks.y = shape.y;
				that.addChildAt(shape,0); // put to bottom incase dragged
				if (that.move && !that.allowToggle) startDragging();
				if (that.stage) that.stage.update();
				return that;
			};

that.toggle = function(state) {
				if (state===true) that.showControls();
				else if (state===false) that.hideControls();
				else if (_controls) that.hideControls();
				else that.showControls();
				return that;
			};

that.recordData = function(toJSON) {
				if (zot(toJSON)) toJSON = false;
				var obj = {
					type:"Blob",
					index:that.parent?that.parent.getChildIndex(that):-1,
					x:that.x, y:that.y,
					points:that.recordPoints(),
					color:that.color,
					thickness:that.thickness,
					move:that.move,
					toggle:that.allowToggle,
					controlsVisible:_controls
				};
				if (toJSON) return JSON.stringify(obj);
				return obj;
			};

that.setData = function(data, fromJSON) {
				if (zot(data)) return;
				if (fromJSON) {
					try {
						data = JSON.parse(data);
					} catch (e) {
						return;
					}
				}
				var index = data.index;
				if (zot(index)) index = -1;
				delete data.index;

var pointData = data.points;
				if (!zot(pointData)) that.setPoints(pointData);
				delete data.points;
				that.num = pointData.length;

for (var d in data) {
					that[d] = data[d];
				}
				if (that.parent) {
					that.parent.setChildIndex(that, index);
				}
				that.update();
				return that;
			};

that.recordPoints = function(popup) {
				// balls are relative to blob but handles are relative to ball
				// points is an array of [[ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]
				if (zot(popup)) popup = false;
				var points = that.points;
				if (popup) {
					if (!that.pane) {
						var pane = that.pane = new zim.Pane({
							container:that.stage,
							width:Math.min(500, that.stage.width-20),
							height:Math.min(500, that.stage.height-20),
							draggable:true,
						});
						var textArea = that.textArea = new zim.TextArea(Math.min(400, that.stage.width-70), Math.min(400, that.stage.height-70));
						textArea.centerReg(pane);
					}
					that.textArea.text = JSON.stringify(points);					
					that.pane.show();
				}
				return points;
			};

that.setPoints = function(points) {
				// adjust blob to match points passed in from recordPoints
				var p;
				var p2;
				for (var i=0; i<points.length; i++) {
					p = _points[i];
					p2 = points[i];
					if (zot(p)) continue;
					p[0].x = p2[0];
					p[0].y = p2[1];
					p[1].x = p2[2];
					p[1].y = p2[3];
					p[2].x = p2[4];
					p[2].y = p2[5];
					p[3].x = p2[6];
					p[3].y = p2[7];
					p[4] = p2[8];
				}
				that.update();
				return that;
			};
			if (style!==false) zim.styleTransforms(that, DS);
			that.clone = function(exact, commands) {
				var newShape =  that.cloneProps(new zim.Squiggle(commands?that.colorCommand:((exact||!zim.isPick(oa[0]))?that.color:oa[0]), that.thickness, that.recordPoints(), length, controlLength, controlType, lockControlType, sets.visible, lockControls, handleSize, that.allowToggle, that.move, dashed, onTop, stickColor, selectColor, selectPoints, that.editPoints, interactive, strokeObj, style, that.group, inherit));
				if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
				if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
				return newShape;
			};

// to add a control - make sure click in one spot - not drag
			that.shape.on("mousedown", function (e) {
				stage = e.target.stage;
				if (!that.editPoints) return;
				if (that.controlsVisible) {
					that.pressX = e.stageX/zim.scaX;
					that.pressY = e.stageY/zim.scaX;
				} else {
					that.pressX = null;
					that.pressY = null;
				}
			});
			that.addPointFactor = 10;
			that.addMinDistance = 15;

that.shape.on("pressup", function (e) {
				if (!that.editPoints) return;
				if (that.pressX && Math.abs(that.pressX-e.stageX/zim.scaX) < min && Math.abs(that.pressY-e.stageY/zim.scaY) < min) {
					if (that.selectPoints) that.lastPoints = zim.copy(that.points);
					var points = that.points;
					var point = that.globalToLocal(e.stageX/zim.scaX, e.stageY/zim.scaY);
					var pointBefore = zim.closestPointAlongCurve(point, that.segmentPoints);
					if (that.editPoints == "anywhere") {
						points.splice(pointBefore+1, 0, [point.x, point.y, 0,0, 0,0, 0,0]);
						that.points = points;
						that.changeControl({index:pointBefore+1, type:"mirror", update:true});
					} else { // only on edge
						// test close enough to edge otherwise return
						var p = that.pointsAdjusted;
						var cubic = that.getSegmentPoint(p[pointBefore], p[(pointBefore+1)%p.length]);
						var length = zim.distanceAlongCurve(cubic);
						var testNum = Math.round(length/that.addPointFactor);
						var testPoints = that.interpolate(testNum, pointBefore, false, points);
						// interpolate is setting 2 more points than asked
						var closest=10000;
						var closestPoint;
						var closestIndex;
						zim.loop(testPoints, function (p, k) {
							var d = zim.dist(p, point);
							if (d < closest) {
								closest = d;
								closestIndex = k;
								closestPoint = p;
							}
						});
						if (closest < that.addMinDistance) {
							var ratios = that.segmentRatios;
							var currentRatio = ratios[pointBefore];
							var lastRatio = pointBefore>0?ratios[pointBefore-1]:0;
							that.addPoint(100*(lastRatio+(currentRatio-lastRatio)*((closestIndex)/(testNum+1))));
						}
					}
					
					that.lastSelectedIndex = pointBefore+1;
					that.lastSelected = that.controls.getChildAt(that.lastSelectedIndex);
					that.stage.update();
				}
			});

// remove point
			that.controls.on("click", function (e) {
				that.lastSelected = e.target.parent;
				var index = that.lastSelectedIndex = that.controls.getChildIndex(e.target.parent);
				if (!that.editPoints) return;
				if (that.selectionManager.shiftKey) { // remove
					// if (that.selectionManager.currentSet == that.selectedBalls && that.selectedBalls.selections.length > 0) return;
					removeControl(e);
				}
			});

function removeControl(e) {
				if (e.target.type == "Circle") {
					var index = that.lastSelectedIndex = that.controls.getChildIndex(e.target.parent);
					if (that.controls.numChildren <= 2) return;
					var points = that.points;
					if (that.selectPoints) that.lastPoints = zim.copy(points);
					points.splice(index, 1); // remove the point at the index
					that.points = points;
					that.stage.update();
					that.lastSelected = that.lastSelectedIndex = null;
				}
			}
			that.controls.hold(removeControl);

if (!_controls) that.hideControls();
			that.dispatchEvent("update");
		} // end of init()

// if (that.selectPoints) {
		function getCurrentSelected() {
			var answer = [];
			var currentSet = that.selectionManager.currentSet;
			if (currentSet && currentSet.selections && currentSet.selections.length > 0) {
				for(var i=0; i<currentSet.selections.length; i++) {
					var point = that.pointObjects[currentSet.selections[i]];
					if (currentSet == that.selectedBalls) {
						answer.push(point[1]);
					} else if (currentSet == that.selectedRect1s) {
						answer.push(point[2]);
					}	else if (currentSet == that.selectedRect2s) {
						answer.push(point[3]);
					} else {
						continue;
					}
				}
			}
			return answer;
		}

function replaceControls(target) {
			// move ball back to origin and move set accordingly
			// so if we animate the set it will behave as expected
			if (target.type != "Circle") return;
			var ball = target;
			var set = ball.mySet;
			var rect1 = ball.rect1;
			var rect2 = ball.rect2;
			rect1.x -= ball.x;
			rect1.y -= ball.y;
			rect2.x -= ball.x;
			rect2.y -= ball.y;
			set.x += ball.x;
			set.y += ball.y;
			ball.x = 0;
			ball.y = 0;
		}

that.selectionManager.on("keydown", function (e) {
			if (!that.selectPoints) return;
			if (!that.keyFocus) return;
			if (e.keyCode >= 37 && e.keyCode <= 40) {
				var currentSelected = getCurrentSelected();
				if (currentSelected.length > 0) {
					for(var i=0; i<currentSelected.length; i++) {
						var pointObj = currentSelected[i];
						if (e.keyCode == 37) pointObj.x -= that.selectionManager.shiftKey?10:1;
						else if (e.keyCode == 39) pointObj.x += that.selectionManager.shiftKey?10:1;
						else if (e.keyCode == 38) pointObj.y -= that.selectionManager.shiftKey?10:1;
						else if (e.keyCode == 40) pointObj.y += that.selectionManager.shiftKey?10:1;
						mapMove(pointObj);
					}
					that.drawShape();
					that.dispatchEvent("update");
					if (that.stage) that.stage.update();
				}
			}
		});

that.selectionManager.on("keyup", function (e) {
			if (!that.selectPoints) return;
			if (!that.keyFocus) return;
			if (e.keyCode >= 37 && e.keyCode <= 40) {
				var currentSelected = getCurrentSelected();
				if (currentSelected.length > 0) {
					for(var i=0; i<currentSelected.length; i++) {
						replaceControls(currentSelected[i]);
					}
				}
			}
		});

that.selectionManager.on("undo", function () {
			if (!that.selectPoints) return;
			if (!that.keyFocus) return;
			if (that.lastPoints) {
				var tempPoints = zim.copy(that.lastPoints);
				that.lastPoints = zim.copy(that.points);
				that.points = tempPoints;
				if (that.stage) that.stage.update();
			}
		});
		// }

mapMove = function (target) {
			if (that.lockControls) return;
			if (target.rect1) { // pressmove on ball
				var ball = target;
				var diffX = ball.x - ball.startX;
				var diffY = ball.y - ball.startY;
				ball.rect1.x = ball.rect1.startX + diffX;
				ball.rect1.y = ball.rect1.startY + diffY;
				ball.rect2.x = ball.rect2.startX + diffX;
				ball.rect2.y = ball.rect2.startY + diffY;
			} else { // pressmove on control
				var rect = target;
				var other = rect.other; // the other handle
				var ball = rect.ball;
				var index = ball.index;
				var type = controlType;
				if (!zot(_points[index][4])) type = _points[index][4];
				if (type == "straight" || type == "mirror") {
					var dX = rect.x - ball.x;
					var dY = rect.y - ball.y;
					if (type == "mirror") {
						other.x = ball.x - dX;
						other.y = ball.y - dY;
					} else {
						var a = Math.atan2(dY, dX);
						var dNewX = -other.stickLength * Math.cos(a+Math.PI);
						var dNewY = -other.stickLength * Math.sin(a+Math.PI);
						other.x = ball.x - dNewX;
						other.y = ball.y - dNewY;
					}
				}
			}

// that.setBounds();
			// decided not to dynamically set bounds
			// they really just go around the control points and not the shape
			// and if dynamically set they go to null if the control points are not showing
		};

Object.defineProperty(that, 'move', {
			get: function() {
				return move;
			},
			set: function(value) {
				if (move != value) {
					move = value;
					if (value) {
						startDragging();
					} else {
						stopDragging();
					}
				}
			}
		});

Object.defineProperty(that, 'interactive', {
			get: function() {
				return interactive;
			},
			set: function(value) {
				interactive = value;
				_controls = interactive;
				that.allowToggle = interactive;
				that.editPoints = interactive;
				that.lockControls = !interactive; // note negative!
				that.selectPoints = interactive;
				that.move = interactive;
				that.points = that.points; // force remake
			}
		});

Object.defineProperty(that, 'allowToggle', {
			get: function() {
				return allowToggle;
			},
			set: function(value) {
				if (allowToggle != value) {
					allowToggle = value;
					if (allowToggle) {
						if (that.move) startDragging();
					} else {
						if (!_controls && that.move) stopDragging();
					}
				}
			}
		});

Object.defineProperty(that, 'controlsVisible', {
			get: function() {
				return _controls;
			},
			set: function(value) {
				_controls = value;
				if (value) {
					that.showControls();
				} else {
					that.hideControls();
				}
			}
		});

if (typeof KEYFOCUS !== typeof undefined) zim.KEYFOCUS = KEYFOCUS;
		Object.defineProperty(this, 'keyFocus', {
			get: function() {
				return zim.KEYFOCUS == that;
			},
			set: function(value) {
				zim.KEYFOCUS = that;
			}
		});
		if (!zim.KEYFOCUS) setFocus();
		function setFocus() {if (!that.selectPoints) return; that.keyFocus = true; var d=document.activeElement; if (d) d.blur();}

Object.defineProperty(that, 'pointsAdjusted', { // points with rotation
			get: function() {
				var points = [];
				var point; var p; var po;
				var pObjects = that.pointObjects;
				zim.loop(pObjects.length, function(i, t) {
					po = pObjects[i];
					p = _points[i];
					if (po[0].rotation==0 && po[0].scaleX==0 && po[0].scaleY==0) { // get points
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(p[2].x),
							zim.decimals(p[2].y),
							zim.decimals(p[3].x),
							zim.decimals(p[3].y)
						];
					} else {
						var lo1 = po[0].localToLocal(po[2].x, po[2].y, po[0].parent);
						var lo2 = po[0].localToLocal(po[3].x, po[3].y, po[0].parent);
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(lo1.x-p[0].x),
							zim.decimals(lo1.y-p[0].y),
							zim.decimals(lo2.x-p[0].x),
							zim.decimals(lo2.y-p[0].y)
						];
					}
					if (p[4] && p[4]!=="mirror") point.push(p[4]);
					points.push(point);
				});
				return points;
			},
			set: function (value) {
				if (zon) zogy("Squiggle() - pointsAdjusted is read only");
			}
		});

Object.defineProperty(that, 'pointObjects', {
			get: function() {
				return _points;
			},
			set: function (value) {
				if (zon) { zog("Squiggle() - pointObjects is read only - but its contents can be manipulated - use squiggle.update() after changes"); }
			}
		});

Object.defineProperty(that, 'pointControls', {
			get: function() {
				return _pointControls;
			},
			set: function(value) {
				if (zon) {zog("Squiggle() - pointControls is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

Object.defineProperty(that, 'pointCircles', {
			get: function() {
				return _pointCircles;
			},
			set: function(value) {
				if (zon) {zog("Squiggle() - pointCircles is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// path manipulation and animating to path methods

Object.defineProperty(that, 'segmentPoints', {
			get: function() {
				var array = []; // array of prepared segment points
				var p = that.pointsAdjusted;
				zim.loop(p.length-1, function(i, t) {
					var s = that.getSegmentPoint(p[i], p[i+1]);
					array.push(s);
				});
				return array;
			},
			set: function(value) {
				if (zon) {zog("Squiggle() - segmentPoints is read only");}
			}
		});

Object.defineProperty(that, 'segmentRatios', {
			get: function() {
				var distances = [];
				var total = 0;
				zim.loop(that.segmentPoints, function(points) {
					var d = zim.distanceAlongCurve(points);
					distances.push(d);
					total += d;
				});
				var percents = [];
				var totalPercents = 0;
				zim.loop(distances, function (d) {
					var p = d/total;
					totalPercents += p;
					percents.push(totalPercents);
				});
				return percents;
			},
			set: function(value) {
				if (zon) {zog("Squiggle() - segmentRatios is read only");}
			}
		});

that.approximateBounds = function(num, showPoints, margin) {
			if (zot(num)) num = 80;
			if (zot(margin)) margin = 0;
			num /= that.num;
			var points = that.interpolate(num, null, true, null, true);
			var bounds = zim.boundsAroundPoints(points);
			that.setBounds(bounds.x-margin, bounds.y-margin, bounds.width+margin*2, bounds.height+margin*2);
			if (showPoints) {
				if (!that.parent) {
					if (zon) zogy("approximateBounds() - add to stage to first to see points");
					return that;
				}
				if (!that.hitPathPoints) that.hitPathPoints = new zim.Container().addTo();
				else that.hitPathPoints.removeAllChildren();
				that.hitPathPoints.top();
				for (var i=0; i<points.length; i++) {
					var point = points[i];
					point = that.localToGlobal(point.x, point.y);
					new zim.Circle(3).loc(point.x, point.y, that.hitPathPoints);
				}
			}
			return that;
		};

that.getPointAngle = function(index) {
			var p = that.pointObjects[index][0]; // parent
			var r1 = that.pointObjects[index][2];
			var r2 = that.pointObjects[index][3];
			if (p==that.stage) {
				var globalR1 = new zim.Point(r1.x, r1.y);
				var globalR2 = new zim.Point(r2.x, r2.y);
			} else {
				var globalR1 = p.localToGlobal(r1.x, r1.y);
				var globalR2 = p.localToGlobal(r2.x, r2.y);
			}
			return zim.angle(globalR1.x, globalR1.y,globalR2.x, globalR2.y);
		};

that.getSegmentPoint = function(point1, point2) {
			if (zot(point1) || zot(point2)) return;
			// dragging points temporarily puts data out of order
			if (point1[2] != 0 || point1[3] != 0) {
				point1[4] -= point1[2];
				point1[5] -= point1[3];
				point1[6] -= point1[2];
				point1[7] -= point1[3];
				point1[0] += point1[2];
				point1[1] += point1[3];
				point1[2] = 0;
				point1[3] = 0;
			}
			if (point2[2] != 0 || point2[3] != 0) {
				point2[4] -= point2[2];
				point2[5] -= point2[3];
				point2[6] -= point2[2];
				point2[7] -= point2[3];
				point2[0] += point2[2];
				point2[1] += point2[3];
				point2[2] = 0;
				point2[3] = 0;
			}
			var p1 = {x:point1[0], y:point1[1]};
			var p2 = {x:point1[0]+point1[6], y:point1[1]+point1[7]};
			var p3 = {x:point2[0]+point2[4], y:point2[1]+point2[5]};
			var p4 = {x:point2[0], y:point2[1]};
			if (sets.x != 0 || sets.y !=0) {
				p1.x+=sets.x;
				p2.x+=sets.x;
				p3.x+=sets.x;
				p4.x+=sets.x;
				p1.y+=sets.y;
				p2.y+=sets.y;
				p3.y+=sets.y;
				p4.y+=sets.y;
			}
			return [p1,p2,p3,p4];
		};

that.getAdjacentSegmentData = function(index) {
			if (zot(index)) index = 0;
			var p = that.pointsAdjusted;
			if (that.num == 2) {
				return [
					[that.getSegmentPoint(p[0], p[1])],
					[0]
				];
			}
			if (index == 0) {
				return [
					[that.getSegmentPoint(p[0], p[1]),
					that.getSegmentPoint(p[1], p[2])],
					[0,1]
				];
			} else if (index >= that.num-2) {
				return [
					[that.getSegmentPoint(p[that.num-3], p[that.num-2]),
					that.getSegmentPoint(p[that.num-2], p[that.num-1])],
					[that.num-3, that.num-2]
				];
			} else {
				return [
					[that.getSegmentPoint(p[index-1], p[index]),
					that.getSegmentPoint(p[index], p[index+1]),
					that.getSegmentPoint(p[index+1], p[index+2])],
					[index-1,index,index+1]
				];
			}
		};

that.getCurvePoint = function(ratio, segmentRatios, segmentPoints, getAngle, even) {

if (zot(ratio) || isNaN(ratio)) ratio = 0;
			if (zot(segmentRatios)) segmentRatios = that.segmentRatios;
			if (zot(segmentPoints)) segmentPoints = that.segmentPoints;
			if (zot(getAngle)) getAngle = false;
			if (zot(even)) even = false;
			var percents = segmentRatios;
			var segments = segmentPoints;
			var afterIndex = zim.loop(percents, function (p, i) {
				if (p >= ratio) return i;
			});
			var earlierPercent = afterIndex > 0 ? percents[afterIndex-1] : 0;
			var localTotal = afterIndex > 0 ? (percents[afterIndex]-percents[afterIndex-1]):percents[afterIndex];
			if (!localTotal) return undefined;
			var localPercent = (ratio-earlierPercent)/localTotal;
			var finalPoint = zim.pointAlongCurve(segments[afterIndex], localPercent, getAngle, true);
			var finalFinalPoint = that.localToGlobal(finalPoint.x, finalPoint.y);
			finalFinalPoint.angle = finalPoint.angle;
			finalFinalPoint.z = afterIndex;
			return !zot(finalFinalPoint) ? finalFinalPoint : undefined;
		};

this.addPoint = function(percent, controlType) {
			if (zot(percent)) percent = 100;
			var points = that.points;
			var ratios = that.segmentRatios;
			var controls = that.pointControls;
			controlType = controlType ? controlType : originalControlType;
			insertPointData(points, controls, ratios, percent, controlType);
			that.points = points;
			that.num = points.length;
			return that;
		};

this.addPoints = function(num, controlType, startPoint, spread, dataOnly, points, even) {
			if (zot(points)) points = zim.copy(that.points);
			var ratios = zim.copy(that.segmentRatios);
			var lastRatio = 0;

if (dataOnly) that.interpolatedPoints = [];

// dataOnly should add points to current point too
			// but can't just use current point because sometimes that is static
			// like when dragging the shape or a point - it does not register until mouseup
			// and things like hitTestPath need that to be dynamic
			// So the below does not work:
			// if (dataOnly) {
			// 	that.interpolatedPoints = [];
			// 	zim.loop(points, function (point, i) {
			// 		if (!zot(startPoint) && i!=startPoint) return;
			// 		that.interpolatedPoints.push({x:point[0], y:point[1]})
			// 	});
			// }
			if (spread) var totalPoints = ratios.length*num;
			zim.loop(ratios, function (ratio, j) {
				if (dataOnly) insertPointData(points, that.pointControls, that.segmentRatios, lastRatio*100, controlType, !zot(startPoint) && j!=startPoint, dataOnly, even);
				var numCount = spread?Math.round(totalPoints*(ratio-lastRatio)):num;
				var div = 1/(numCount+1);
				zim.loop(numCount, function(i) {
					var r = lastRatio + (ratio-lastRatio)*div*(i+1);
					insertPointData(points, that.pointControls, that.segmentRatios, r*100, controlType, !zot(startPoint) && j!=startPoint, dataOnly, even);
					if (!dataOnly && num > 0) that.points = points;
				});
				lastRatio = ratio;
			});
			if (dataOnly && that.type == "Squiggle") {
				// changed to skipPoint false in zim 10.7.0 - not sure why it was true...
				insertPointData(points, that.pointControls, that.segmentRatios, 100, controlType, false, dataOnly, even);
			}
			if (that.stage) that.stage.update();
			that.num = points.length;
			return that;
		};
		this.interpolate = function(num, startPoint, spread, points, even) {
			if (zot(num)) num = 1;
			// dataOnly will add Point to start point too
			that.addPoints(num, "none", startPoint, spread, true, points, even);
			return that.interpolatedPoints;
		};

this.dispose = function(temp, b, disposing) {
			if (!that.shape) return;
			zim.gD(that); // globalDispose function for common elements			
			if (stage && that.toggleStageEvent) stage.off("stagemousedown", that.toggleStageEvent);
			that.controls.noDrag();	// sets	
			that.controls.removeAllEventListeners();
			if (that.selectPoints && that.selectionManager) that.selectionManager.dispose();
			that.selectedBalls = null;
			that.selectedRect1s = null;
			that.selectedRect2s = null;
			that.selectionManager = null;		
			that.off("mousedown", that.toggleEvent);
			that.off("click", that.clickEvent);
				
			if (temp) {
				that.shape.dispose();				
				that.shape = null;				
				for (var i=0; i<that.points.length; i++) {
					that.pointObjects[i][0].removeAllEventListeners();
					that.pointObjects[i][1].removeAllEventListeners();
					that.pointObjects[i][2].removeAllEventListeners();
					that.pointObjects[i][3].removeAllEventListeners();
				}
				that.controls.removeFrom(that);
				that.sticks.dispose();
				_points = null;
				_pointCircles = null;
			} else {
				that.removeAllEventListeners();	
				_points = null;
				_pointCircles = null;		
				if (!disposing) this.zimCustomShape_dispose(true);				
			}
			return true;
		};
	};
	zim.extend(zim.Squiggle, zim.CustomShape, ["clone", "dispose"], "zimCustomShape", false);

zim.Blob = function(color, borderColor, borderWidth, points, radius, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, stickColor, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit) {
		var sig = "color, borderColor, borderWidth, points, radius, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, stickColor, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit";
		var duo; if (duo = zob(zim.Blob, arguments, sig, this)) return duo;
		this.group = group;
		var DS = style===false?{}:zim.getStyle("Blob", this.group, inherit);

if (zot(radius)) radius = DS.radius!=null?DS.radius:100;
		this.zimCustomShape_constructor(-radius,-radius,radius*2,radius*2,false);
		this.type = "Blob";

this.mouseChildren = true; // set to false in CustomShape

if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
		if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
		if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
		else if (borderColor!=null && borderWidth==null) borderWidth = 1;
		if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":zim.green);
		if (color.style) {this.colorCommand = color; color = "black";}
		if (borderColor && borderColor.style) {this.borderColorCommand = borderColor; borderColor = "black";}
		if (zot(points)) points = DS.points!=null?DS.points:4;
		var num = typeof points == "number" ? points : points.length;
		var controlLengthOriginal = controlLength;
		if (zot(controlLength)) controlLength = DS.controlLength!=null?DS.controlLength:(radius * 4 / num);
		if (zot(controlType)) controlType = DS.controlType!=null?DS.controlType:null;
		var originalControlType = controlType;
		if (zot(controlType)) controlType = "straight";
		if (zot(lockControlType)) lockControlType = DS.lockControlType!=null?DS.lockControlType:false;
		if (zot(interactive)) interactive = DS.interactive!=null?DS.interactive:true;
		if (zot(showControls)) showControls = DS.showControls!=null?DS.showControls:interactive;
		var _controls = showControls;
		if (zot(lockControls)) lockControls = DS.lockControls!=null?DS.lockControls:!interactive;
		if (zot(handleSize)) handleSize = DS.handleSize!=null?DS.handleSize:(zim.mobile()?20:10);
		if (zot(allowToggle)) allowToggle = DS.allowToggle!=null?DS.allowToggle:interactive;
		if (zot(move)) move = DS.move!=null?DS.move:interactive;
		if (zot(stickColor)) stickColor = DS.stickColor!=null?DS.stickColor:"#111";
		if (zot(selectColor)) selectColor = DS.selectColor!=null?DS.selectColor:"#fff";
		if (zot(selectPoints)) selectPoints = DS.selectPoints!=null?DS.selectPoints:interactive;
		this.stickColor = stickColor;

var oa = remember(color, borderColor);
		function remember() {return arguments;} // for cloning PICK
		color = zim.Pick.choose(color);
		borderColor = zim.Pick.choose(borderColor);

var that = this;
		this.interactive = interactive;
		this.num = num;
		this.editPoints = editPoints;
		this.selectPoints = selectPoints;
		this.lockControls = lockControls;
		this.onTop = onTop;
		this.move = move;
		this.allowToggle = allowToggle;
		this.lockControlType = lockControlType;

var types = this.types = ["mirror", "straight", "free", "none"];

var _points;
		var _pointCircles;
		var _pointControls;
		that._color = color;
		that._borderColor = borderColor;
		that._borderWidth = borderWidth;
		that._dashed = dashed;
		if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];

var shape;
		var moveDownEvent;
		var movePressEvent;
		var moveUpEvent;
		var stage;

var draggingCheck = that.move;
		var min = 2; // distance within which to count as click to add point

var mapMove;
		var sets;

init();
		function init() {
			if (sets) sets.removeAllEventListeners();

if (that.selectPoints) {
				that.selectedBalls = new zim.SelectionSet();
				that.selectedRect1s = new zim.SelectionSet();
				that.selectedRect2s = new zim.SelectionSet();

num = typeof points == "number" ? points : points.length;
			if (num <= 0) return;
			if (zot(controlLengthOriginal)) controlLength = radius * 4 / num;

var ballS = handleSize/10*8;
			var rectS = handleSize;

var mobile = zim.mobile();

sets = that.controls = new zim.Container({style:false}).addTo(that); // sets - a set contains a ball and two rects
			if (that.interactive) sets.drag({onTop:!mobile});

_points = [];
			_pointControls = [];
			_pointCircles = [];

var angle, point, temp, set, rect1, rect2, ball, type, setInfo;

for (var i=0; i<num; i++) {
				set = new zim.Container({style:false}).addTo(sets);
				set.num = i;
				if (typeof points == "number") { // no sets yet

// easier to create controls in a temp vertical Container
					// set the registration point at the circle center
					// then rotate the temp container
					// then get the resulting rotated coordinates and use localToLocal
					// to find coordinates of controls in set Container
					// afterwards, adjust controls in set Container so origin and registration is at ball
					// then move the set Container so it matches that adjustment
					// (or could have calculated all positions to start with aTan2, sin, cos etc.)
					var length = zim.Pick.choose(controlLength);
					temp = new zim.Container(length, radius, null, null, false).reg(length/2, radius).addTo(that);
					temp.rotation = i/num * 360;
					ball = new zim.Circle(ballS, that.selectPoints&&that.selectedBalls.isSelected(i)?selectColor:zim.light, zim.dark, 2, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:length/2,y:0});
					rect1 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(controlType), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, false)
						.centerReg(temp)
						.loc({x:0,y:0});
					rect2 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(controlType), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, false)
						.centerReg(temp)
						.loc({x:length,y:0});

} else { // passing in set data

// balls are relative to blob but handles are relative to ball
					// points is an array of [[setX, setY, ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]

setInfo = points[i];
					type = setInfo[8] ? setInfo[8] : controlType;
					set.loc({x:setInfo[0], y:setInfo[1]});
					ball = new zim.Circle(ballS, zim.light, zim.dark, 2, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set)
						.loc({x:setInfo[2],y:setInfo[3]});
					rect1 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[4],y:setInfo[5]});
					rect2 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[6],y:setInfo[7]});
				}

ball.mySet = set;
				ball.rect1 = rect1;
				ball.rect2 = rect2;
				ball.index = i;

if (handleSize==0) {
					ball.expand(10);
					rect1.expand(10);
					rect2.expand(10);
				}

if (mobile) {
					ball.on("mousedown", mobileDouble);
				} else {
					ball.on("dblclick", doubleIt);
				}

rect1.ball = ball;
				rect1.other = rect2;
				rect2.ball = ball;
				rect2.other = rect1;

if (mobile) {
					ball.expand();
					rect1.expand();
					rect2.expand();
				}

point = [set, ball, rect1, rect2, setInfo?setInfo[8]:controlType];
				_points.push(point);
				_pointCircles.push(ball);
				_pointControls.push(set);
			}

function getBackgroundColor(type) {
				var colors = {mirror:zim.purple, free:zim.yellow, none:zim.blue};
				return colors[type] ? colors[type] : zim.pink;
			}

that.drawShape = function() {
				g.c();
				if (!that.colorCommand) {
					that.colorCommand = g.f(that._color).command;
					if (color && color.type) that.specialColor(that.colorCommand, color);
				}
				// border of 0 or a string value still draws a border in CreateJS
				if (zot(that._borderWidth) || that._borderWidth > 0) { // no border specified or a border > 0
					if (!zot(that._borderColor) || !zot(that._borderWidth)) { // either a border color or thickness
						if (zot(that._borderColor)) that._borderColor = "black";
						if (!that.borderColorCommand) {
							that.borderColorCommand = g.s(that._borderColor).command;
							if (that._borderColor && that._borderColor.type) that.specialColor(that.borderColorCommand, that._borderColor);
						}
						if (!that.borderWidthCommand) that.borderWidthCommand = g.ss(that._borderWidth, strokeObj.caps, strokeObj.joints, strokeObj.miterLimit, strokeObj.ignoreScale).command;
						if (that._dashed) {
							if (!that.borderDashedCommand) that.borderDashedCommand = g.sd(Array.isArray(that._dashed)?that._dashed:[10, 10], that._dashedOffset).command;
						}
					}
				}
				var set = _points[0][0];
				var ballPoint = set.localToLocal(_points[0][1].x, _points[0][1].y, shape);
				g.mt(ballPoint.x, ballPoint.y);

s.c().s(that.stickColor).ss(1);

var currentIndex; var nextIndex;
				for (var i=0; i<_points.length; i++) {
					var currentIndex = i;
					var nextIndex = (i+1)%_points.length;

var set = _points[currentIndex][0];
					var ball = _points[currentIndex][1];
					var control1 = _points[currentIndex][2];
					var control2 = _points[currentIndex][3];

var nextSet = _points[nextIndex][0];
					var nextBall = _points[nextIndex][1];
					var nextControl1 = _points[nextIndex][2];
					var nextControl2 = _points[nextIndex][3];

var control2Point = set.localToLocal(control2.x, control2.y, shape);
					var nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
					var nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);

g.bt(
						control2Point.x, control2Point.y,
						nextControl1Point.x, nextControl1Point.y,
						nextBallPoint.x, nextBallPoint.y
					);

// create the sticks
					var ballPoint = set.localToLocal(ball.x, ball.y, shape);
					var control1Point = set.localToLocal(control1.x, control1.y, shape);

s.mt(ballPoint.x, ballPoint.y).lt(control1Point.x, control1Point.y);
					s.mt(ballPoint.x, ballPoint.y).lt(control2Point.x, control2Point.y);
				}
				g.cp();

g.append(that.colorCommand);
				if (that._dashed) g.append(that.borderDashedCommand);
				if (that.borderWidthCommand) g.append(that.borderWidthCommand);
				if (that.borderColorCommand) g.append(that.borderColorCommand);
			};
			that.drawShape();

var startPosition;
			sets.on("mousedown", function(e) {
				if (that.lockControls) return;
				if (that.selectPoints) that.keyFocus = true;
				startPosition = {x:e.target.x, y:e.target.y};
				if (e.target.rect1) { // then mousedown on ball
					var ball = e.target;
					ball.startX = ball.x;
					ball.startY = ball.y;
					ball.rect1.startX = ball.rect1.x;
					ball.rect1.startY = ball.rect1.y;
					ball.rect2.startX = ball.rect2.x;
					ball.rect2.startY = ball.rect2.y;
				} else { // mousedown on control
					var rect = e.target;
					rect.startX = rect.x;
					rect.startY = rect.y;
					var ball = rect.ball;
					var index = ball.index;
					var type = controlType;
					if (!zot(_points[index][4])) type = _points[index][4];
					if (type == "straight") {
						var other = rect.other;
						var dX = other.x - ball.x;
						var dY = other.y - ball.y;
						other.stickLength = Math.sqrt(Math.pow(dX,2) + Math.pow(dY,2));
					}
				}
				if (that.selectPoints) {
					// need to reset all start points for each control circle and rectangle moved
					var currentSet = that.selectionManager.currentSet;
					if (currentSet && currentSet.selections && currentSet.selections.length > 0) {
						for(var i=0; i<currentSet.selections.length; i++) {
							var point = that.pointObjects[currentSet.selections[i]];
							point[1].startX = point[1].x;
							point[1].startY = point[1].y;
							point[2].startX = point[2].x;
							point[2].startY = point[2].y;
							point[3].startX = point[3].x;
							point[3].startY = point[3].y;
						}
					}
				}
			});

that.changeControl = function(index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update) {
				var sig = "index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update";
				var duo; if (duo = zob(that.changeControl, arguments, sig)) return duo;
				if (zot(index)) {
					for (var i=0; i<_points.length; i++) {
						that.changeControl(i, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY);
					}
					return that;
				}
				var point = _points[index];
				point[4] = type;
				if (type == "none") {
					if (!zot(circleX)) point[1].x = circleX;
					if (!zot(circleY)) point[1].y = circleY;
					point[2].x = point[1].x,
					point[2].y = point[1].y;
					point[3].x = point[1].x,
					point[3].y = point[1].y;
					point[1].parent.addChild(point[1]);
				} else {
					if (!zot(circleX)) point[1].x = circleX;
					if (!zot(circleY)) point[1].y = circleY;
					if (!zot(rect1X)) point[2].x = rect1X;
					if (!zot(rect1Y)) point[2].y = rect1Y;
					if (!zot(rect2X)) point[3].x = rect2X;
					if (!zot(rect2Y)) point[3].y = rect2Y;
					point[1].parent.addChildAt(point[1], 0);
				}
				point[2].color = getBackgroundColor(type);
				point[3].color = getBackgroundColor(type);
				if (update) {
					that.update();
					if (that.stage) that.stage.update();
				}
				return that;
			};

that.transformPoints = function(transformType, amount, x, y) {
				that.points = zim.transformPoints(that.points, transformType, amount, x, y);
				return that;
			};

that.traverse = function(obj, start, end, time) {
				var ratios = zim.copy(that.segmentRatios);
				ratios.unshift(0);
				if (zot(end)) end = start+1;
				var forward = start < end;
				if (forward) {
					var startPercent = ratios[start]*100;
					var endPercent = ratios[end]*100;
				} else {
					var startPercent = 50 + (100 - ratios[start]*100)/2;
					var endPercent = 50 + (100 - ratios[end]*100)/2;
				}
				obj.percentComplete = startPercent;
				obj.animate({
					ease:"linear",
					props:{path:that},
					rewind:!forward,
					time:time,
					events:true
				});
				obj.on("animation", function (e) {
					// when it hits the end it may start over
					if (obj.percentComplete > endPercent || obj.percentComplete == 0) {
						obj.stopAnimate();
						e.remove();
						var eventObj = new createjs.Event("traversed");
						eventObj.obj = obj;
						that.dispatchEvent(eventObj);
					}
				});
				return that;
			};

// blob
			if (that.move && that.interactive) shape.drag({onTop:false});
			moveDownEvent = shape.on("mousedown", function(e) {
				stage = e.target.stage;
				startPosition = {x:shape.x, y:shape.y};
				if (that.selectPoints) that.keyFocus = true;
				upTop();
			});
			movePressEvent = shape.on("pressmove", function() {
				sets.x = shape.x;
				sets.y = shape.y;
				sticks.x = shape.x;
				sticks.y = shape.y;
			});
			moveUpEvent = shape.on("pressup", function() {
				var moveControlCheck = (shape.x != startPosition.x || shape.y != startPosition.y);
				var movePoint = shape.localToLocal(that.regX,that.regY,that.parent);
				that.x = movePoint.x;
				that.y = movePoint.y;
				sets.x = sets.y = sticks.x = sticks.y = shape.x = shape.y = 0;
				if (moveControlCheck) {
					var ev = new createjs.Event("change");
					ev.controlType = "move";
					that.dispatchEvent(ev);
				}
				stage.update();
			});

if (!move) stopDragging(true);

that.added(function() {
				stage = that.stage;
				if (that.toggleStageEvent) that.stage.off("stagemousedown", that.toggleStageEvent);
				that.toggleStageEvent = that.stage.on("stagemousedown", function(e) {
					if (!that.allowToggle || !that.stage) return;
					if (_controls && !that.hitTestPoint(e.stageX/zim.scaX, e.stageY/zim.scaY, false)) {
						that.hideControls();
						that.dispatchEvent("controlshide");
					}
				});
			});

that.clickEvent = that.on("click", function() {
				if (that.ctrlKey) {
					setTimeout(function() { // give time for record to work if drag with ctrl down
						that.clone(true).addTo(that.stage).mov(100);
						if (that.allowToggle) {
							that.hideControls();
							that.dispatchEvent("controlshide");
						}
						var ev = new createjs.Event("change");
						ev.controlType = "move";
						that.dispatchEvent(ev);
						that.stage.update();
					}, 50);
				}
			});

that.hideControls = function() {
				that.toggled = false;
				sets.visible = false;
				sticks.visible = false;
				_controls = false;
				if (that.stage) that.stage.update();
				if (!that.allowToggle && that.move) stopDragging();
				return that;
			};
			if (!_controls) that.hideControls();
			that.showControls = function() {
				// if call this with code then will not trigger a change event - not good for TransformManager.persist()
				that.toggled = true;
				sets.visible = true;
				sticks.visible = true;
				_controls = true;
				sets.x = shape.x;
				sets.y = shape.y;
				sticks.x = shape.x;
				sticks.y = shape.y;
				that.addChildAt(shape,0); // put to bottom in case dragged
				if (that.move && !that.allowToggle) startDragging();
				if (that.stage) that.stage.update();
				return that;
			};

that.recordData = function(toJSON) {
				if (zot(toJSON)) toJSON = false;
				var obj = {
					type:"Blob",
					index:that.parent?that.parent.getChildIndex(that):-1,
					x:that.x, y:that.y,
					points:that.recordPoints(),
					color:that.color,
					borderColor:that.borderColor,
					borderWidth:that.borderWidth,
					move:that.move,
					toggle:that.allowToggle,
					controlsVisible:_controls
				};
				if (toJSON) return JSON.stringify(obj);
				return obj;
			};

that.setData = function(data, fromJSON) {
				if (zot(data)) return;
				if (fromJSON) {
					try{
						data = JSON.parse(data);
					} catch (e) {
						return;
					}
				}
				var index = data.index;
				if (zot(index)) index = -1;
				delete data.index;

var pointData = data.points;
				if (!zot(pointData)) that.setPoints(pointData);
				delete data.points;
				this.num = pointData.length;

for (var d in data) {
					that[d] = data[d];
				}
				if (that.parent) {
					that.parent.setChildIndex(that, index);
				}
				return that;
			};

that.recordPoints = function(popup) {
				// _pointCircles are relative to blob but handles are relative to ball
				// points is an array of [[ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]
				if (zot(popup)) popup = false;
				var points = that.points;
				if (popup) {
					if (!pane) {
						var pane = that.pane = new zim.Pane({
							displayClose:false,
							container:that.stage,
							width:Math.min(500, that.stage.width-20),
							height:Math.min(500, that.stage.height-20),
							draggable:true,
						});
						var textArea = that.textArea = new zim.TextArea(Math.min(400, that.stage.width-70), Math.min(400, that.stage.height-70));
						textArea.centerReg(pane);
					} 
					pane.show();		
					textArea.text = JSON.stringify(points);
				}
				return points;
			};

that.setPoints = function(points) {
				// adjust blob to match points passed in from recordPoints
				var p;
				var p2;
				for (var i=0; i<points.length; i++) {
					p = _points[i];
					p2 = points[i];
					if (zot(p)) continue;
					p[0].x = p2[0];
					p[0].y = p2[1];
					p[1].x = p2[2];
					p[1].y = p2[3];
					p[2].x = p2[4];
					p[2].y = p2[5];
					p[3].x = p2[6];
					p[3].y = p2[7];
					p[4] = p2[8];
					p[2].color = getBackgroundColor(p[4]);
					p[3].color = getBackgroundColor(p[4]);
				}
				that.update();
				return that;
			};
			if (style!==false) zim.styleTransforms(that, DS);
			that.clone = function(exact, commands) {
				var newShape =  that.cloneProps(new zim.Blob(commands?that.colorCommand:((exact||!zim.isPick(oa[0]))?that.color:oa[0]), commands?that.borderColorCommand:((exact||!zim.isPick(oa[1]))?that.borderColor:oa[1]), that.borderWidth, that.recordPoints(), radius, controlLength, controlType, lockControlType, sets.visible, lockControls, handleSize, that.allowToggle, that.move, dashed, onTop, stickColor, selectColor, selectPoints, that.editPoints, interactive, strokeObj, style, that.group, inherit));
				if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
				if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
				return newShape;
			};

// to add a control - make sure click in one spot - not drag
			that.shapeMousedownEvent = that.shape.on("mousedown", function (e) {
				stage = e.target.stage;
				if (!that.editPoints) return;
				if (that.controlsVisible) {
					that.pressX = e.stageX/zim.scaX;
					that.pressY = e.stageY/zim.scaY;
				} else {
					that.pressX = null;
					that.pressY = null;
				}
			});
			that.addPointFactor = 10;
			that.addMinDistance = 15;
			that.shapePressupEvent = that.shape.on("pressup", function (e) {

if (!that.editPoints) return;
				if (that.pressX && Math.abs(that.pressX-e.stageX/zim.scaX) < min && Math.abs(that.pressY-e.stageY/zim.scaY) < min) {
					if (that.selectPoints) that.lastPoints = zim.copy(that.points);
					var points = that.points;
					var point = that.globalToLocal(e.stageX/zim.scaX, e.stageY/zim.scaY);
					var pointBefore = zim.closestPointAlongCurve(point, that.segmentPoints);

if (that.editPoints == "anywhere") {
						points.splice(pointBefore+1, 0, [point.x, point.y, 0,0, 0,0, 0,0]);
						that.points = points;
						that.changeControl({index:pointBefore+1, type:"mirror", update:true});
					} else { // only on edge
						// test close enough to edge otherwise return
						var p = that.pointsAdjusted;
						var cubic = that.getSegmentPoint(p[pointBefore], p[(pointBefore+1)%p.length]);
						var length = zim.distanceAlongCurve(cubic);
						var testNum = Math.round(length/that.addPointFactor);
						var testPoints = that.interpolate(testNum, pointBefore, false, points);
						var closest=10000;
						var closestPoint;
						var closestIndex;

zim.loop(testPoints, function (p, k) {
							if (k==0) return; // don't put on existing point
							var d = zim.dist(p, point);
							if (d < closest) {
								closest = d;
								closestIndex = k;
								closestPoint = p;
							}
						});
						if (closest < that.addMinDistance) {
							var ratios = that.segmentRatios;
							var currentRatio = ratios[pointBefore];
							var lastRatio = pointBefore>0?ratios[pointBefore-1]:0;
							that.addPoint(100*(lastRatio+(currentRatio-lastRatio)*(closestIndex/(testNum+1))));
						}
					}

that.lastSelectedIndex = pointBefore+1;
					that.lastSelected = that.controls.getChildAt(that.lastSelectedIndex);
					that.stage.update();
				}
			});

// remove point
			that.controlsClickEvent = that.controls.on("click", function (e) {
				that.lastSelected = e.target.parent;
				var index = that.lastSelectedIndex = that.controls.getChildIndex(e.target.parent);
				if (!that.editPoints) return;
				if (that.selectionManager.shiftKey) { // remove
					removeControl(e);
				}
			});

if (!_controls) that.hideControls();
			that.dispatchEvent("update");
		} // end of init()

function replaceControls(target) {
			if (!that.selectPoints) return;
			// move ball back to origin and move set accordingly
			// so if we animate the set it will behave as expected
			if (target.type != "Circle") return;
			var ball = target;
			var set = ball.mySet;
			var rect1 = ball.rect1;
			var rect2 = ball.rect2;
			rect1.x -= ball.x;
			rect1.y -= ball.y;
			rect2.x -= ball.x;
			rect2.y -= ball.y;
			set.x += ball.x;
			set.y += ball.y;
			ball.x = 0;
			ball.y = 0;
		}

Object.defineProperty(that, 'interactive', {
			get: function() {
				return interactive;
			},
			set: function(value) {
				interactive = value;
				_controls = interactive;
				that.allowToggle = interactive;
				that.editPoints = interactive;
				that.lockControls = !interactive; // note negative
				that.selectPoints = interactive;
				that.move = interactive;
				that.points = that.points; // force remake
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        // NOTE: extends ZIM CustomShape for more properties and a few functions.
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (typeof KEYFOCUS !== typeof undefined) zim.KEYFOCUS = KEYFOCUS;
		Object.defineProperty(this, 'keyFocus', {
			get: function() {
				return zim.KEYFOCUS == that;
			},
			set: function(value) {
				zim.KEYFOCUS = that;
			}
		});
		if (that.selectPoints && !zim.KEYFOCUS) setFocus();
		function setFocus() {that.keyFocus = true; var d=document.activeElement; if (d) d.blur();}

Object.defineProperty(that, 'pointsAdjusted', { // points with rotation
			get: function() {
				var points = [];
				var point; var p; var po;
				var pObjects = that.pointObjects;
				zim.loop(pObjects.length, function(i, t) {
					po = pObjects[i];
					p = _points[i];
					if (po[0].rotation==0 && po[0].scaleX==0 && po[0].scaleY==0) { // get points
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(p[2].x),
							zim.decimals(p[2].y),
							zim.decimals(p[3].x),
							zim.decimals(p[3].y)
						];
					} else {
						var lo1 = po[0].localToLocal(po[2].x, po[2].y, po[0].parent);
						var lo2 = po[0].localToLocal(po[3].x, po[3].y, po[0].parent);
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(lo1.x-p[0].x),
							zim.decimals(lo1.y-p[0].y),
							zim.decimals(lo2.x-p[0].x),
							zim.decimals(lo2.y-p[0].y)
						];
					}
					if (p[4] && p[4]!=="mirror") point.push(p[4]);
					points.push(point);
				});
				return points;
			},
			set: function(value) {
				if (zon) zogy("Blob() - pointsAdjusted is read only");
			}
		});

Object.defineProperty(that, 'pointObjects', {
			get: function() {
				return _points;
			},
			set: function(value) {
				if (zon) {zog("Blob() - pointObjects is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

Object.defineProperty(that, 'pointControls', {
			get: function() {
				return _pointControls;
			},
			set: function(value) {
				if (zon) {zog("Blob() - pointControls is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

Object.defineProperty(that, 'pointCircles', {
			get: function() {
				return _pointCircles;
			},
			set: function(value) {
				if (zon) {zog("Blob() - pointCircles is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// path manipulation and animating to path methods

Object.defineProperty(that, 'segmentPoints', {
			get: function() {
				var p = that.pointsAdjusted;
				var array = []; // array of prepared segment points
				zim.loop(p.length, function(i, t) {
					var s = that.getSegmentPoint(p[i], p[i<t-1?i+1:0]);
					array.push(s);
				});
				return array;
			},
			set: function(value) {
				if (zon) {zog("Blob() - segmentPoints is read only");}
			}
		});

that.approximateBounds = function(num, showPoints) {
			if (zot(num)) num = 80;
			num /= that.num;
			var points = that.interpolate(num, null, true, null, true);
			var bounds = zim.boundsAroundPoints(points);
			that.setBounds(bounds.x, bounds.y, bounds.width, bounds.height);
			if (showPoints) {
				if (!that.parent) {
					if (zon) zogy("approximateBounds() - add to stage to first to see points");
					return that;
				}
				if (!that.hitPathPoints) that.hitPathPoints = new zim.Container().addTo();
				else that.hitPathPoints.removeAllChildren();
				that.hitPathPoints.top();
				for (var i=0; i<points.length; i++) {
					var point = points[i];
					point = that.localToGlobal(point.x, point.y);
					new zim.Circle(3).loc(point.x, point.y, that.hitPathPoints);
				}
			}
			return that;
		};

that.getAdjacentSegmentData = function(index) {
			if (zot(index)) index = 0;
			var p = that.pointsAdjusted;
			if (that.num == 2) {
				return [
					[that.getSegmentPoint(p[0], p[1]),
					that.getSegmentPoint(p[1], p[0])],
					[0,1]
				];
			}
			if (index == 0) {
				return [
					[that.getSegmentPoint(p[that.num-1], p[0]),
					that.getSegmentPoint(p[0], p[1]),
					that.getSegmentPoint(p[1], p[2])],
					[that.num-1,0,1]
				];
			} else if (index >= that.num-1) {
				return [
					[that.getSegmentPoint(p[that.num-2], p[that.num-1]),
					that.getSegmentPoint(p[that.num-1], p[0]),
					that.getSegmentPoint(p[0], p[1])],
					[that.num-2,that.num-1,0]
				];
			} else {
				var lastIndex = (index+2>=that.num)?0:index+2;
				return [
					[that.getSegmentPoint(p[index-1], p[index]),
					that.getSegmentPoint(p[index], p[index+1]),
					that.getSegmentPoint(p[index+1], p[lastIndex])],
					[index-1,index,index+1]
				];
			}
		};

that.getCurvePoint = function(ratio, segmentRatios, segmentPoints, getAngle) {
			if (zot(segmentRatios)) segmentRatios = that.segmentRatios;
			if (zot(segmentPoints)) segmentPoints = that.segmentPoints;
			if (zot(getAngle)) getAngle = false;
			var percents = segmentRatios;
			var segments = segmentPoints;
			var afterIndex = zim.loop(percents, function (p, i) {
				if (p >= ratio) return i;
			});
			var earlierPercent = afterIndex > 0 ? percents[afterIndex-1] : 0;
			var localTotal = afterIndex > 0 ? (percents[afterIndex]-percents[afterIndex-1]):percents[afterIndex];
			var localPercent = (ratio-earlierPercent)/localTotal;
			var finalPoint = zim.pointAlongCurve(segments[afterIndex], localPercent, getAngle, true);
			if (zot(finalPoint)) return undefined;
			var finalFinalPoint = that.localToGlobal(finalPoint.x, finalPoint.y);
			finalFinalPoint.angle = finalPoint.angle;
			finalFinalPoint.z = afterIndex;
			return !zot(finalFinalPoint) ? finalFinalPoint : undefined;
		};

zim.loop(ratios, function (ratio, i) {
				if (percent/100 < ratio) {
					index = i;
					currentRatio = ratio;
					return true;
				}
				lastRatio = ratio;
			});
			var segment = that.segmentPoints[index];
			var r = currentRatio > 0?(percent/100-lastRatio)/(currentRatio-lastRatio):0;
			// zog(percent)
			// zog(percent/100-currentRatio/ratios.length)
			// var r = currentRatio > 0?(percent/100-1/ratios.length*currentRatio)/(currentRatio-lastRatio):0

if (dataOnly) that.interpolatedPoints = [];

// dataOnly should add points to current point too
			// but can't just use current point because sometimes that is static
			// like when dragging the shape or a point - it does not register until mouseup
			// and things like hitTestPath need that to be dynamic
			// So the below does not work:
			// if (dataOnly) {
			// 	that.interpolatedPoints = [];
			// 	zim.loop(points, function (point, i) {
			// 		if (!zot(startPoint) && i!=startPoint) return;
			// 		that.interpolatedPoints.push({x:point[0], y:point[1]})
			// 	});
			// }
			if (spread) var totalPoints = ratios.length*num;
			zim.loop(ratios, function (ratio, j) {
				if (dataOnly) insertPointData(points, that.pointControls, that.segmentRatios, lastRatio*100, controlType, !zot(startPoint) && j!=startPoint, dataOnly, even);
				var numCount = spread?Math.round(totalPoints*(ratio-lastRatio)):num;
				var div = 1/(numCount+1);
				zim.loop(numCount, function(i) {
					var r = lastRatio + (ratio-lastRatio)*div*(i+1);
					insertPointData(points, that.pointControls, that.segmentRatios, r*100, controlType, !zot(startPoint) && j!=startPoint, dataOnly, even);
					if (!dataOnly && num > 0) that.points = points;
				});
				lastRatio = ratio;
			});
			if (dataOnly && that.type == "Squiggle") insertPointData(points, that.pointControls, that.segmentRatios, 100, controlType, null, dataOnly, even);
			if (that.stage) that.stage.update();
			that.num = points.length;
			return that;
		};
		this.interpolate = function(num, startPoint, spread, points, even) {
			if (zot(num)) num = 1;
			// dataOnly will add Point to start point too
			that.addPoints(num, "none", startPoint, spread, true, points, even);
			return that.interpolatedPoints;
		};

this.dispose = function(temp, d, disposing) {
			if (!that.shape) return;
			zim.gD(that); // globalDispose function for common elements			
			if (stage && that.toggleStageEvent) stage.off("stagemousedown", that.toggleStageEvent);
			that.controls.noDrag();	// sets	
			that.controls.removeAllEventListeners();			
			if (that.selectPoints && that.selectionManager) that.selectionManager.dispose();
			that.selectedBalls = null;
			that.selectedRect1s = null;
			that.selectedRect2s = null;
			that.selectionManager = null;
			
			that.off("mousedown", that.toggleEvent);
			that.off("click", that.clickEvent);		
					
			if (temp) {
				that.shape.dispose();				
				that.shape = null;				
				for (var i=0; i<that.points.length; i++) {
					that.pointObjects[i][0].removeAllEventListeners();
					that.pointObjects[i][1].removeAllEventListeners();
					that.pointObjects[i][2].removeAllEventListeners();
					that.pointObjects[i][3].removeAllEventListeners();
				}
				that.controls.removeFrom(that);
				that.sticks.dispose();
				_points = null;
				_pointCircles = null;
			} else {
				that.removeAllEventListeners();	
				_points = null;
				_pointCircles = null;				
				if (!disposing) this.zimCustomShape_dispose(true);				
			}
			return true;
			
			
			// // if (that.toggleStageEvent) that.stage.off("stagemousedown", that.toggleStageEvent);
			// // this.zimContainer_dispose();
			// // return true
			// if (!that.shape) return;
			// zim.gD(that); // globalDispose function for common elements
			// that.shape.cursor = "default";
			// for (var i=0; i<that.pointObjects.length; i++) {
			// 	that.pointObjects[i][1].removeAllEventListeners();
			// }
			// for (i=0; i<_pointCircles.length; i++) {
			// 	_pointCircles[i].removeAllEventListeners();
			// }
			// that.sticks.removeFrom(that);
			// that.controls.removeFrom(that);
			// that.shape.removeAllEventListeners();
			// that.controls.removeAllEventListeners();
			// that.off("mousedown", that.toggleEvent);
			// that.off("click", that.clickEvent);
			// if (stage && that.toggleStageEvent) stage.off("stagemousedown", that.toggleStageEvent);
			// if (!temp && that.selectPoints) that.selectionManager.removeAllEventListeners();
			// // if (!disposing) that.zimCustomShape_dispose(true);
			// return true;
		};
	};
	zim.extend(zim.Blob, zim.CustomShape, ["clone", "dispose"], "zimCustomShape", false);

zim.Label = function(text, size, font, color, rollColor, shadowColor, shadowBlur, align, valign, bold, italic, variant, lineWidth, lineHeight, backing, outlineColor, outlineWidth, backgroundColor, backgroundBorderColor, backgroundBorderWidth, corner, backgroundDashed, padding, paddingHorizontal, paddingVertical, shiftHorizontal, shiftVertical, rollPersist, labelWidth, labelHeight, maxSize, splitWords, style, group, inherit) {
		var sig = "text, size, font, color, rollColor, shadowColor, shadowBlur, align, valign, bold, italic, variant, lineWidth, lineHeight, backing, outlineColor, outlineWidth, backgroundColor, backgroundBorderColor, backgroundBorderWidth, corner, backgroundDashed, padding, paddingHorizontal, paddingVertical, shiftHorizontal, shiftVertical, rollPersist, labelWidth, labelHeight, maxSize, splitWords, style, group, inherit";
		var duo; if (duo = zob(zim.Label, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "Label";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

if (zot(text)) text=DS.text!=null?DS.text:"LABEL";
		if (zot(size)) size=DS.size!=null?DS.size:36;
		if (zot(font)) font=DS.font!=null?DS.font:"arial"; // arial unless manually set
		if (zot(color)) color=DS.color!=null?DS.color:"black";
		if (zot(bold)) bold=DS.bold!=null?DS.bold:false;
		if (zot(italic)) italic=DS.italic!=null?DS.italic:false;

var oa = remember(text, size, font, color, bold, italic);
		function remember() {return arguments;}

text = zim.Pick.choose(text);
		var emptyText = false;
		if (text === "") {
			text = " ";
			emptyText = true;
		}
		size = zim.Pick.choose(size);
		font = zim.Pick.choose(font);
		color = zim.Pick.choose(color);
		bold = zim.Pick.choose(bold);
		italic = zim.Pick.choose(italic);

if (zot(rollColor)) rollColor=DS.rollColor!=null?DS.rollColor:null;
		if (zot(shadowColor) || shadowColor=="ignore") shadowColor=(DS.shadowColor!=null&&shadowColor!="ignore")?DS.shadowColor:-1;
		if (zot(shadowBlur) || shadowBlur=="ignore") shadowBlur=(DS.shadowBlur!=null&&shadowBlur!="ignore")?DS.shadowBlur:14;
		if (zot(align)) align=DS.align!=null?DS.align:"left";
		if (zot(valign)) valign=DS.valign!=null?DS.valign:"top";
		if ((!zot(outlineColor) || !zot(DS.outlineColor)) && zot(outlineWidth)) outlineWidth = DS.outlineWidth!=null?DS.outlineWidth:Math.round(size*.2);
		if ((!zot(outlineWidth) || !zot(DS.outlineWidth)) && zot(outlineColor)) outlineColor = DS.outlineColor!=null?DS.outlineColor:"#000000";
		if (zot(outlineWidth)) outlineWidth = DS.outlineWidth!=null?DS.outlineWidth:0;
		if (zot(backgroundColor) || backgroundColor=="ignore") backgroundColor = (DS.backgroundColor!=null&&backgroundColor!="ignore")?DS.backgroundColor:null;
		if (zot(padding) || padding=="ignore") padding = (DS.padding!=null&&padding!="ignore")?DS.padding:10;
		if (zot(paddingHorizontal)) paddingHorizontal = DS.paddingHorizontal!=null?DS.paddingHorizontal:padding;
		if (zot(paddingVertical)) paddingVertical = DS.paddingVertical!=null?DS.paddingVertical:padding;
		if (zot(shiftHorizontal)) shiftHorizontal = DS.shiftHorizontal!=null?DS.shiftHorizontal:0;
		if (zot(shiftVertical)) shiftVertical = DS.shiftVertical!=null?DS.shiftVertical:0;
		if (zot(variant)) variant=DS.variant!=null?DS.variant:false;
		if (zot(lineWidth)) lineWidth = DS.lineWidth!=null?DS.lineWidth:null;
		if (zot(lineHeight)) lineHeight = DS.lineHeight!=null?DS.lineHeight:null;
		if (zot(backing) || backing=="ignore") backing = (DS.backing!=null&&backing!="ignore")?DS.backing.clone():null;
		if (zot(rollPersist)) rollPersist = DS.rollPersist!=null?DS.rollPersist:false;
		if (DS.labelWidth!=null) lineWidth = DS.labelWidth;
		if (!zot(labelWidth)) lineWidth = labelWidth;
		if (align == "middle") align = "center";
		if (zot(labelHeight)) labelHeight = DS.labelHeight!=null?DS.labelHeight:null;
		if (zot(maxSize)) maxSize = DS.maxSize!=null?DS.maxSize:null;
		size = maxSize?Math.min(size, maxSize):size;
		if (zot(splitWords)) splitWords=DS.splitWords!=null?DS.splitWords:false;

var yAdjust;
			if (valign == "baseline") {
				yAdjust = b.y;
			} else if (valign == "top") {
				obj.y = size-size/6;
				// if (!retina && obj2) obj2.y = size-size/6;
				yAdjust = 0;
			} else if (valign == "center" || valign == "middle") {
				yAdjust = - b.height / 2;
				obj.y = size*.3;
				// if (!retina && obj2) obj2.y = size*.3;
			} else { // bottom align
				yAdjust = -b.height;
			}
			// if (valign!="baseline" && obj2) obj2.y -= size*.06/(valign=="center"?2:1);
			that.setBounds(b.x, yAdjust, DS.width?DS.width-padding*2:b.width, DS.height?DS.height-padding*2:b.height);
			if (that.hitArea) that.hitArea.graphics.c().f("black").r(that.getBounds().x, that.getBounds().y, that.getBounds().width, that.getBounds().height);
			if (valign == "center" || valign == "middle") {
				zim.pos(obj, null, 0);
				zim.mov(obj, 0, 1);
			}
			if (!labelHeight) {
				if (backing) {
					if (backingPlaced) setBackBounds();
				} else if (!zot(backgroundColor)) {
					setBackground();
				}
			}

if (valign != "baseline" && !retina) obj.y += size/32; //32; // backing often on capital letters without descenders - was /16

finalShift();
		}
		setSize();

if (!zot(backing)) {
			if (backing.type == "Pattern") {
				that.backing = new zim.Container(that.width+paddingHorizontal*2, that.height+paddingVertical*2, null, null, false).centerReg(null, null, false);
				if (shadowColor != -1 && shadowBlur > 0) {
					var shadowRect = new zim.Rectangle(that.width+paddingHorizontal*2-2, that.height+paddingVertical-2, "#666", null, null, corner, null, null, false).center(that.backing);
					shadowRect.shadow = new createjs.Shadow(shadowColor, 3, 3, shadowBlur);
				}
				var mask = new zim.Rectangle(that.width+paddingHorizontal*2, that.height+paddingVertical*2, backgroundColor, null, null, corner, null, null, false).addTo(that.backing);
				backing.centerReg(mask);
				backing.setMask(mask);
				that.backing.pattern = backing;
			} else {
				that.backing = backing;
			}
			that.backing.center(that, 0);
			backing = that.backing;
			setBackBounds();
			backingPlaced = true;
		}

function setBackBounds() {
			var bb = backing.boundsToGlobal();
			var bbb = that.boundsToGlobal(bb, true);
			that.setBounds(bbb.x, bbb.y, bbb.width, bbb.height);
		}

function finalShift() {
			zim.pos(obj, (align=="left"||align=="right")?(backing||that.background?paddingHorizontal:0):null, (valign=="top"||valign=="baseline"||valign=="bottom")?(backing||that.background?paddingVertical:0):null, align=="right", valign=="bottom");
			// zim.pos(obj, (align=="left"||align=="right")?0:null, (valign=="top"||valign=="baseline"||valign=="bottom")?0:null, align=="right", valign=="bottom");
			obj.x += shiftHorizontal;
			obj.y += shiftVertical;
		}
		finalShift();

function setOutline() {
			if (obj2) {
				obj2.x = obj.x;
				obj2.y = obj.y;
				that.addChildAt(obj2,(that.background||that.backing)?1:0);
			}
		}
		setOutline();

Object.defineProperty(that, 'text', {
			get: function() {
				var t = (obj.text == " " && emptyText) ? "" : obj.text;
				return t;
			},
			set: function(value) {
				emptyText = false;
				if (value === "") {
					value = " ";
					emptyText = true;
				}
				obj.text = String(value);
				obj.setBounds(null);
				that.setBounds(null);
				setSize();
				if (obj2) obj2.text = String(value);
				if (!zot(lineWidth) && !zot(labelHeight)) {
					fitText();
					if (obj2) setOutline();
				}				
			}
		});

Object.defineProperty(that, 'size', {
			get: function() {
				return size;
			},
			set: function(value) {
				size = maxSize?Math.min(value, maxSize):value;
				options[3] = size + "px";
				this.label.font = options.join(" ");
				if (obj2) obj2.font = options.join(" ");
				obj.setBounds(null);
				that.setBounds(null);
				setSize();
			}
		});

Object.defineProperty(that, 'bold', {
			get: function() {
				return Boolean(this.label.font.match("bold"));
			},
			set: function(value) {
				bold = value;
				options[2] = value?"bold":"normal";
				this.label.font = options.join(" ");
				if (obj2) obj2.font = options.join(" ");
			}
		});

Object.defineProperty(that, 'italic', {
			get: function() {
				return Boolean(this.label.font.match("italic"));
			},
			set: function(value) {
				italic = value;
				options[0] = value?"italic":"normal";
				this.label.font = options.join(" ");
				if (obj2) obj2.font = options.join(" ");
			}
		});

Object.defineProperty(that, 'variant', {
			get: function() {
				return Boolean(this.label.font.match("small-caps"));
			},
			set: function(value) {
				variant = value;
				options[1] = value?"small-caps":"normal";
				this.label.font = options.join(" ");
				if (obj2) obj2.font = options.join(" ");
			}
		});

Object.defineProperty(that, 'font', {
			get: function() {
				return options[4];
			},
			set: function(value) {
				if (zot(value)) return;
				font = value;
				options[4] = value;
				this.label.font = options.join(" ");
				if (obj2) obj2.font = options.join(" ");
			}
		});

Object.defineProperty(that, 'align', {
			get: function() {
				return align;
			},
			set: function(value) {
				if (zot(value)) return;
				align = value;
				this.label.textAlign = align;
				if (obj2) obj2.textAlign = align;
				setSize();
			}
		});

Object.defineProperty(that, 'valign', {
			get: function() {
				return valign;
			},
			set: function(value) {
				if (zot(value)) return;
				valign = value;
				setSize();
			}
		});

Object.defineProperty(that, 'color', {
			get: function() {
				return color;
			},
			set: function(value) {
				if (rollColor == color) rollColor = value;
				color = value;
				obj.color = color;
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});
		var startColor;
		var endColor;
		this.setColorRange = function(color1, color2) {
			if (zot(color2)) {
				startColor = that.color;
				endColor = color1;
			} else if (zot(color1)) {
				startColor = that.color;
				endColor = color2;
			} else {
				startColor = color1;
				endColor = color2;
			}
			return that;
		};
		var _colorRange = 0;
		Object.defineProperty(that, 'colorRange', {
			get: function() {
				return _colorRange;
			},
			set: function(value) {
				_colorRange = value;
				if (!zot(startColor) && !zot(endColor)) {
					that.color = zim.colorRange(startColor, endColor, value);
				}
			}
		});

Object.defineProperty(that, 'backgroundColor', {
			get: function() {
				return backgroundColor;
			},
			set: function(value) {
				backgroundColor = value;
				if (that.background) {
					that.background.color = value;
				} else if (that.backing) {
					that.backing.color = value;
				} else {
					setBackground();
				}
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'outlineColor', {
			get: function() {
				return outlineColor;
			},
			set: function(value) {
				outlineColor = value;
				if (obj2) obj2.color = outlineColor;
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'rollColor', {
			get: function() {
				return rollColor;
			},
			set: function(value) {
				if (!that.mouseoverEvent && value) setRollColors();
				if (value==null && that.mouseoverEvent) removeRollColors();
				rollColor = value;
			}
		});

this._enabled = true;
		Object.defineProperty(that, 'enabled', {
			get: function() {
				return that._enabled;
			},
			set: function(value) {
				zenable(that, value);
				obj.color = color;
				that.mouseChildren = false;
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

this.showRollColor = function(yes) {
			if (zot(yes)) yes = true;
			if (yes) {
				obj.color = rollColor;
			} else {
				obj.color = color;
			}
			if (that.stage) that.stage.update();
			return that;
		};

Object.defineProperty(that, 'labelWidth', {
			get: function() {
				return lineWidth;
			},
			set: function(value) {
				if (value > 0) {
					lineWidth = value;
					
					lW = lineWidth;				
					if (!zot(backing) || !zot(backgroundColor)) {					
						if (lW) lW = lW-paddingHorizontal*2;
					}
					
					that.label.lineWidth = lW;
					if (obj2) obj2.lineWidth = lW;
				
					obj.setBounds(null);
					that.setBounds(null);
					setSize();					
					if (labelHeight) fitText();	
					
					if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
				}
			}
		});

zim.styleTransforms(this, DS);
		this.clone = function(exact) {
			return that.cloneProps(new zim.Label((exact||!zim.isPick(oa[0]))?that.text:oa[0], (exact||!zim.isPick(oa[1]))?size:oa[1], (exact||!zim.isPick(oa[2]))?font:oa[2], (exact||!zim.isPick(oa[3]))?color:oa[3], rollColor, shadowColor, shadowBlur, align, valign, (exact||!zim.isPick(oa[4]))?bold:oa[4], (exact||!zim.isPick(oa[5]))?italic:oa[5], variant, lineWidth, lineHeight,
				!zot(backing)?backing.clone(exact):null, outlineColor, outlineWidth, backgroundColor, backgroundBorderColor, backgroundBorderWidth, corner, backgroundDashed, padding, paddingHorizontal, paddingVertical, shiftHorizontal, shiftVertical, rollPersist, labelWidth, labelHeight, maxSize, splitWords, style, this.group, inherit));
		};
	};
	zim.extend(zim.Label, zim.Container, "clone", "zimContainer");

zim.Button = function(width, height, label, backgroundColor, rollBackgroundColor, color, rollColor, borderColor, borderRollColor, borderWidth, corner, shadowColor, shadowBlur, hitPadding, gradient, gloss, dashed, backing, rollBacking, rollPersist, icon, rollIcon, toggle, toggleBackgroundColor, rollToggleBackgroundColor, toggleColor, rollToggleColor, toggleBacking, rollToggleBacking, toggleIcon, rollToggleIcon, toggleEvent, wait, waitTime, waitBackgroundColor, rollWaitBackgroundColor, waitColor, rollWaitColor, waitModal, waitEnabled, waitBacking, rollWaitBacking, waitIcon, rollWaitIcon, align, valign, indent, indentHorizontal, indentVertical, style, group, inherit) {
		var sig = "width, height, label, backgroundColor, rollBackgroundColor, color, rollColor, borderColor, borderRollColor, borderWidth, corner, shadowColor, shadowBlur, hitPadding, gradient, gloss, dashed, backing, rollBacking, rollPersist, icon, rollIcon, toggle, toggleBackgroundColor, rollToggleBackgroundColor, toggleColor, rollToggleColor, toggleBacking, rollToggleBacking, toggleIcon, rollToggleIcon, toggleEvent, wait, waitTime, waitBackgroundColor, rollWaitBackgroundColor, waitColor, rollWaitColor, waitModal, waitEnabled, waitBacking, rollWaitBacking, waitIcon, rollWaitIcon, align, valign, indent, indentHorizontal, indentVertical, style, group, inherit";
		var duo; if (duo = zob(zim.Button, arguments, sig, this)) return duo;
		this.group = group;
		var DS = style===false?{}:zim.getStyle("Button", group, inherit);

if (zot(width)) width=DS.width!=null?DS.width:200;
		if (zot(height)) height=DS.height!=null?DS.height:60;
		this.zimContainer_constructor(width, height, null, null, false);
		this.type = "Button";

if (zot(backgroundColor)) backgroundColor=DS.backgroundColor!=null?DS.backgroundColor:"#C60";
		if (zot(rollBackgroundColor)) rollBackgroundColor=DS.rollBackgroundColor!=null?DS.rollBackgroundColor:"#F93";
		var oColor = color;
		var oRollColor = rollColor;
		if (zot(color)) color=DS.color!=null?DS.color:"white";
		if (zot(rollColor)) rollColor=DS.rollColor!=null?DS.rollColor:"white";

var oa = remember(backgroundColor, rollBackgroundColor, color, rollColor);
		function remember() {return arguments;} // for cloning PICK
		backgroundColor = zik(backgroundColor);
		rollBackgroundColor = zik(rollBackgroundColor);
		color = zik(color);
		rollColor = zik(rollColor);

if (zot(waitBackgroundColor)) waitBackgroundColor=DS.waitBackgroundColor!=null?DS.waitBackgroundColor:backgroundColor;
		if (zot(rollWaitBackgroundColor)) rollWaitBackgroundColor=DS.rollWaitBackgroundColor!=null?DS.rollWaitBackgroundColor:rollBackgroundColor;
		if (zot(waitColor)) waitColor=DS.waitColor!=null?DS.waitColor:label.color;
		if (zot(rollWaitColor)) rollWaitColor=DS.rollWaitColor!=null?DS.rollWaitColor:label.rollColor;

var that = this;
		this.mouseChildren = false;
		this.cursor = "pointer";
		that.focus = false;
		that.rolled = false;
		var stage;

var timeType = getTIME(waitTime);

that.rollBacking = zot(rollBacking)?(DS.rollBacking!=null?DS.rollBacking.clone():null):rollBacking;
		that.waitBacking = zot(waitBacking)?(DS.waitBacking!=null?DS.waitBacking.clone():null):waitBacking;
		that.rollWaitBacking = zot(rollWaitBacking)?(DS.rollWaitBacking!=null?DS.rollWaitBacking.clone():null):rollWaitBacking;
		that.toggleBacking = zot(toggleBacking)?(DS.toggleBacking!=null?DS.toggleBacking.clone():null):toggleBacking;
		that.rollToggleBacking = zot(rollToggleBacking)?(DS.rollToggleBacking!=null?DS.rollToggleBacking.clone():null):rollToggleBacking;

//~~~~~~~~~~~~~  ICONS
		that.icon = zot(icon)?(DS.icon!=null?DS.icon.clone():null):icon;
		that.rollIcon = zot(rollIcon)?(DS.rollIcon!=null?DS.rollIcon.clone():null):rollIcon;
		that.waitIcon = zot(waitIcon)?(DS.waitIcon!=null?DS.waitIcon.clone():null):waitIcon;
		that.rollWaitIcon = zot(rollWaitIcon)?(DS.rollWaitIcon!=null?DS.rollWaitIcon.clone():null):rollWaitIcon;
		that.toggleIcon = zot(toggleIcon)?(DS.toggleIcon!=null?DS.toggleIcon.clone():null):toggleIcon;
		that.rollToggleIcon = zot(rollToggleIcon)?(DS.rollToggleIcon!=null?DS.rollToggleIcon.clone():null):rollToggleIcon;
		var iconTypes = ["icon", "rollIcon", "toggleIcon", "rollToggleIcon", "waitIcon", "rollWaitIcon"];
		for (var i=0; i<iconTypes.length; i++) {
			var ty = iconTypes[i];
			var ic = that[ty]; // access to object passed to parameter or null
			if (ic) {
				// assumes center reg
				ic.x = width / 2;
				ic.y = height / 2;
			}
		}
		if (that.icon) that.addChild(that.icon);

//~~~~~~~~~~~~~  GRADIENT AND GLOSS

if (!Array.isArray(corner)) corner = [corner, corner, corner, corner];
		if (gradient > 0) { // add an overlay
			var gr = new createjs.Shape();
			gr.graphics.lf(["rgba(255,255,255,"+gradient+")","rgba(0,0,0,"+gradient+")"], [0, 1], 0, 0, 0, height-borderWidth);
			gr.graphics.rc(borderWidth/2, borderWidth/2, width-borderWidth, height-borderWidth, corner[0], corner[1], corner[2], corner[3]);
			this.addChild(gr);
		}
		if (gloss > 0) { // add an overlay
			var gl = new createjs.Shape();
			gl.graphics.f("rgba(255,255,255,"+gloss+")");
			gl.graphics.rc(borderWidth/2, borderWidth/2, width-borderWidth, (height-borderWidth)/2, corner[0], corner[1], 0, 0);
			gl.graphics.f("rgba(0,0,0,"+gloss+")");
			gl.graphics.rc(borderWidth/2, height/2, width-borderWidth, (height-borderWidth)/2, 0, 0, corner[2], corner[3]);
			this.addChild(gl);
		}

//~~~~~~~~~~~~~  HITAREA AND LABEL

var hitArea;
		var rect;
		if (hitPadding > 0) makeHitArea();
		function makeHitArea() {
			rect = new createjs.Shape();
			rect.graphics.f("#000").r(-hitPadding,-hitPadding,width+hitPadding*2,height+hitPadding*2);
			that.hitArea = hitArea = rect;
		}

this.addChild(label);
		label.center(this);
		// label.y+=(typeof zdf!="undefined" && zdf.retina!=true)?1:0;
		label.y+=1;
		this.label = label;

zim.pos(label, (align=="left"||align=="right")?indentHorizontal:null, (valign=="top"||valign=="bottom")?indentVertical:null, align=="right", valign=="bottom");

//~~~~~~~~~~~~~  TOGGLE STATE
		this.toggled = false;
		if (toggleOkay) {			
			var originalText = label.text;
			var originalColor = label.color;
			var originalRollColor = label.rollColor;
			this.on(toggleEvent, function() {
				that.toggled = !that.toggled;
				setToggled();
			});
		}

this.toggle = function(state) {
			if (!toggleOkay) {
				if (zon) zogy("Button() - can't toggle with wait parameters provided");
				return that;
			}
			if (zot(state)) {
				that.toggled = !that.toggled;
			} else {
				that.toggled = state;
			}
			setToggled();
			return that;
		};

//~~~~~~~~~~~~~  WAIT STATE
		var pressCheck = false;
		that.waiting = false;
		var willBeWaiting = false;
		var waitTimeout;
		var waitStartText;
		// var waitStartBackgroundColor;
		var waitStartTextBackgroundColor = that.label.color;
		var waitStartRollTextBackgroundColor = that.label.rollColor;
		var waitStartEnabled;
		var waitModalEvent;
		var waitEvent = this.on("mousedown", function() {
			pressCheck=true;
			doWait();
		});

function doWait() {
			if ((!zot(wait) || !zot(waitBacking) || !zot(rollWaitBacking)) && !that.waiting) {
				willBeWaiting = true;
				if (zot(waitEnabled)) waitEnabled = true;
				if (waitModal) waitModalEvent = that.stage.on("stagemousedown", function(e) {
					if (!that.hitTestPoint(e.stageX/zim.scaX, e.stageY/zim.scaY)) that.clearWait();
				}, null, true); // run only once
				// wait before setting the waiting property so first click is not a waiting
				setTimeout(function(){that.waiting = true;}, 50);
				// set button to waiting state
				waitStartText = label.text;
				if (!zot(waitColor)) that.label.color = waitColor;
				if (!zot(rollWaitColor)) that.label.rollColor = rollWaitColor;
				waitStartEnabled = that.enabled;
				if (!waitEnabled && that.enabled) that.enabled = false;
				if (!zot(wait)) that.label.text = wait;

if (that.rolled) {
					if (zot(backing) && !that.rollWaitBacking) that.backing.color = rollWaitBackgroundColor;
					if (that.rollWaitBacking) changeObject("rollWaitBacking", that.rollWaitBacking);
					else if (that.waitBacking) changeObject("waitBacking", that.waitBacking);
					if (that.rollWaitIcon) changeObject("rollWaitIcon", that.rollWaitIcon);
					else if (that.waitIcon) changeObject("waitIcon", that.waitIcon);
				} else {
					if (zot(backing) && !that.waitBacking) that.backing.color = waitBackgroundColor;
					if (that.waitBacking) changeObject("waitBacking", that.waitBacking);
					if (that.waitIcon) changeObject("waitIcon", that.waitIcon);
				}

if (zot(waitTime)) waitTime = timeType=="s"?5:5000; // 5 seconds
				if (waitTimeout) waitTimeout.clear();
				waitTimeout = zim.timeout(waitTime, function() {
					// set button to proper text, icon, backing, colors, etc.
					if (!that.enabled) that.enabled = waitStartEnabled;
					that.clearWait();
					that.dispatchEvent("waited");
				});
				if (that.stage) that.stage.update();
			}
		}
		this.wait = function() {
			doWait();
		};
		this.clearWait = function() {
			if (!waitTimeout) return that;
			if (waitModalEvent) that.stage.off("stagemousedown", waitModalEvent);
			waitTimeout.clear();
			that.label.text = waitStartText;
			setOriginalObjects();
			that.label.color = waitStartTextBackgroundColor;
			that.label.rollColor = waitStartRollTextBackgroundColor;
			setTimeout(function(){that.waiting = false;}, 55); // give time for first click to see not waiting yet
			willBeWaiting = false;
			if (that.stage) that.stage.update();
			return that;
		};
		this.removeWait = function() {
			that.clearWait();
			wait = null;
			that.waitBacking = null;
			that.rollWaitBacking = null;
			that.off("mousedown", waitEvent);
			return that;
		};

//~~~~~~~~~~~~~  INTERACTION

this.on("pressup", function(){
			pressCheck=false;
			if (that.rollPersist && !reallyOn) removeRoll();
		});

// visually swap button backing or icon
		// on clicks if wait or toggle and on mouseover and mouseout
		// note - icon will be removed if newObject is null
		// BUT - backing will be ignored if newObject is null
		// so these act slightly differently!
		function changeObject(type, newObject) {
			if (type.indexOf("con")>=0) { // icon
				for (var i=0; i<iconTypes.length; i++) {
					var ty = iconTypes[i];
					var ic = that[ty];
					that.removeChild(ic);
				}
				if (that[type]) that.addChildAt(that[type], 1);
			} else {
				if (!that[type]) return;
				for (var i=0; i<backingTypes.length; i++) {
					var t = backingTypes[i];
					var b = that[t];
					that.removeChild(b);
				}
				if (that[type]) that.addChildAt(that[type], 0);
			}
		}

var reallyOn = false;		
		this.on("mouseover", function (e) {
			if (that.stage && that.stage.frame.leftMouseDown && !onCheck) return;
			buttonOn(e);
		});
		function buttonOn(e) {
			that.rolled = true;
			reallyOn = true;

// specific to each setting
			// so can have a rollover backing even without a backing
			// also... if no rollWaitBacking or rollToggleBacking
			// then if there is the backing for these, still set the backing
			// all backings get removed and current backing object is placed
			// normal buttons (with no backings) get borders on rectangle
			// backings get overlayed border with borderColor and borderRollColor
			// will have to track each state normal, toggle and wait
			// do not set colors on any custom backings (aside from border colors)

if (willBeWaiting) {
				if (zot(backing) && zot(that.rollWaitBacking)) that.backing.color = zot(rollWaitBackgroundColor)?rollBackgroundColor:rollWaitBackgroundColor;
				changeObject("rollWaitBacking", that.rollWaitBacking);
				if (that.rollWaitIcon) changeObject("rollWaitIcon", that.rollWaitIcon);
			} else if (toggleOkay && that.toggled) {
				if (zot(backing) && zot(that.rollToggleBacking)) that.backing.color = rollToggleBackgroundColor;
				changeObject("rollToggleBacking", that.rollToggleBacking);
				if (that.rollToggleIcon) changeObject("rollToggleIcon", that.rollToggleIcon);
			} else {
				if (zot(backing)) that.backing.color = rollBackgroundColor;
				else if (!zot(backing.mask)) that.backing.mask.color = rollBackgroundColor;
				changeObject("rollBacking", that.rollBacking);
				if (that.rollIcon) changeObject("rollIcon", that.rollIcon);
			}
			if (that.border) that.border.borderColor = borderRollColor;

if (that.label.showRollColor) that.label.showRollColor();
			if (that.stage) that.stage.update();
		}
		
		// for mobile with no mouseover 
		// and to stop rollover if pressed off button and rollover ZIM Cat 04
		var onCheck = false;
		var touchCheck = false;
		this.on("mousedown", function (e) {
			onCheck = true;
			if (that.rolled) return;
			touchCheck = true;
			buttonOn(e);			
		});
		this.on("pressup", function (e) {			
			onCheck = false;
			if (touchCheck) { // touch screen
				touchCheck = false;
				buttonOff(e);
			}
		});
		this.on("pressmove", function (e) {
			var frame = that.stage ? that.stage.frame : zdf;
			var hitting = that.hitTestPoint(frame.mouseX, frame.mouseY);
			if (onCheck && !hitting) {
				buttonOff(e);
				onCheck = false;
			} else if (!onCheck && hitting) {
				buttonOn(e);
				onCheck = true;
			}
		});

this.on("mouseout", buttonOff); // thanks Maxime Riehl
		function buttonOff(e) {
			reallyOn = false;
			that.off("mouseout", buttonOff); // not working and not needed? 2018
			if (that.rollPersist) {
				if (!pressCheck) removeRoll();
			} else {
				removeRoll();
			}
		}
		function removeRoll() {
			that.rolled = false;
			if (willBeWaiting || that.waiting) {
				if (zot(backing) && zot(that.waitBacking)) that.backing.color = zot(waitBackgroundColor)?backgroundColor:waitBackgroundColor;
				if (that.waitBacking) changeObject("waitBacking", that.waitBacking);
				else changeObject("backing", that.backing);
				if (that.waitIcon) changeObject("waitIcon", that.waitIcon);
				else if (that.icon) changeObject("icon", that.icon);
				else changeObject("icon", null);
			} else if (that.toggled && toggleOkay) {
				if (zot(backing) && zot(that.toggleBacking)) that.backing.color = toggleBackgroundColor;
				if (that.toggleBacking) changeObject("toggleBacking", that.toggleBacking);
				else changeObject("backing", that.backing);
				if (that.toggleIcon) changeObject("toggleIcon", that.toggleIcon);
				else if (that.icon) changeObject("icon", that.icon);
				else changeObject("icon", null);
			} else {
				if (zot(backing))  that.backing.color = backgroundColor;
				else if (!zot(backing.mask)) that.backing.mask.color = backgroundColor;
				changeObject("backing", that.backing);
				if (that.icon) changeObject("icon", that.icon);
				else changeObject("icon", null);
			}

if (that.border) that.border.borderColor = borderColor;

if (that.label.showRollColor) that.label.showRollColor(false);
			if (that.stage) that.stage.update();
		}

Object.defineProperty(that, 'text', {
			get: function() {
				var t = (label.text == " ") ? "" : label.text;
				return t;
			},
			set: function(value) {
				label.text = value;
				if (originalText) originalText = value;
				label.center(this);
				label.y+=1;
				zim.pos(label, (align=="left"||align=="right")?indentHorizontal:null, (valign=="top"||valign=="bottom")?indentVertical:null, align=="right", valign=="bottom");
			}
		});

Object.defineProperty(that, 'color', {
			get: function() {
				return color;
			},
			set: function(value) {
				color = value;
				if (originalColor) originalColor = color;
				if (that.label && !zot(that.label.color)) {
					that.label.color = color;
				}
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'backgroundColor', {
			get: function() {
				return backgroundColor;
			},
			set: function(value) {
				backgroundColor = value;
				if (that.backing.color) {
					that.backing.color = backgroundColor;
				} else if (that.backing.mask) {
					that.backing.mask.color = backgroundColor;
				}
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'rollBackgroundColor', {
			get: function() {
				return rollBackgroundColor;
			},
			set: function(value) {
				rollBackgroundColor = value;
				if (that.rollBacking && that.rollBacking.color) {
					that.rollBacking.color = rollBackgroundColor;
				} else if (that.rollBacking && that.rollBacking.mask) {
					that.rollBacking.mask.color = rollBackgroundColor;
				}
			}
		});

Object.defineProperty(that, 'borderColor', {
			get: function() {
				return borderColor;
			},
			set: function(value) {
				borderColor = value;
				if (!that.rolled) {
					if (that.backing && that.backing.borderColor) that.backing.borderColor = value;
					if (that.border) that.border.borderColor = value;
				}
			}
		});

Object.defineProperty(that, 'borderRollColor', {
			get: function() {
				return borderRollColor;
			},
			set: function(value) {
				borderRollColor = value;
				if (that.rolled) {
					if (that.backing && that.backing.borderColor) that.backing.borderColor = value;
					if (that.border) that.border.borderColor = value;
				}
			}
		});

Object.defineProperty(that, 'hitPadding', {
			get: function() {
				return hitPadding;
			},
			set: function(value) {
				hitPadding = value;
				if (hitPadding == 0) {
					if (hitArea) {
						this.hitArea = null;
					}
				} else {
					makeHitArea();
				}
			}
		});

this._enabled = true;
		this.startMouseChildren = this.mouseChildren;
		Object.defineProperty(that, 'enabled', {
			get: function() {
				return that._enabled;
			},
			set: function(value) {
				if (that._enabled) that.startMouseChildren = that.mouseChildren;
				if (value) {
					zenable(that, value);
					that.mouseChildren = that.startMouseChildren;
				} else {
					removeRoll();
					zenable(that, value);
				}
				label.color = label.color;
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

// setBacking or leave backing parameter blank to remove this type of backing
		this.setBacking = function(type, newBacking) {
			setObject(type, newBacking);
		};
		// setIcon or leave icon parameter blank to remove this type of icon
		this.setIcon = function(type, newIcon) {
			setObject(type, newIcon);
		};
		function setObject(type, newObject) {
			if (zot(type)) return that;
			if (that.contains(that[type])) {
				that.removeChild(that[type]);
				if (newObject) that.addChildAt(newObject, type.indexOf("con")>=0?that.numChildren-1:0);
				if (that.stage) that.stage.update();
			}
			if (newObject) {
				if (zot(backing) && type == "backing") backing = newObject;
				if (newObject.type == "Pattern") newObject = setPattern(type, newObject);
				that[type] = newObject;
				that[type].x = width/2;
				that[type].y = height/2;
			} else {
				that[type] = null;
			}
			return that;
		}
		if (style!==false) zim.styleTransforms(this, DS);

this.clone = function(exact) {
			var but = new zim.Button(
				width, height, label.clone(),

(exact||!zim.isPick(oa[0]))?backgroundColor :oa[0],
				(exact||!zim.isPick(oa[1]))?rollBackgroundColor :oa[1],
				(exact||!zim.isPick(oa[2]))?color :oa[2],
				(exact||!zim.isPick(oa[3]))?rollColor :oa[3],

originalBorderColor, borderRollColor, originalBorderWidth, corner, shadowColor, shadowBlur, hitPadding, gradient, gloss, dashed,
				!zot(backing)?that.backing.clone():null,
				!zot(rollBacking)?that.rollBacking.clone():null,
				rollPersist,
				!zot(icon)?icon.clone():null, !zot(rollIcon)?rollIcon.clone():null,
				toggle, toggleBackgroundColor, rollToggleBackgroundColor, toggleColor, rollToggleColor,
				!zot(toggleBacking)?toggleBacking.clone():null,
				!zot(rollToggleBacking)?rollToggleBacking.clone():null,
				!zot(toggleIcon)?toggleIcon.clone():null,
				!zot(rollToggleIcon)?rollToggleIcon.clone():null,
				toggleEvent,
				wait, waitTime, waitBackgroundColor, rollWaitBackgroundColor, waitColor, rollWaitColor, waitModal, waitEnabled,
				!zot(waitBacking)?waitBacking.clone():null,
				!zot(rollWaitBacking)?rollWaitBacking.clone():null,
				!zot(waitIcon)?waitIcon.clone():null,
				!zot(rollWaitIcon)?rollWaitIcon.clone():null,
				align, valign, indent, indentHorizontal, indentVertical,
				style,
				this.group,
				inherit // added in ZIM Cat 03 - not sure if it was missing on purpose
			);
			return that.cloneProps(but);
		};
		
		this.doDispose = function(a,b,disposing) {
			if (that.icon) that.icon.dispose();			
			if (that.rollIcon) that.rollIcon.dispose();
			if (that.waitIcon) that.waitIcon.dispose();
			if (that.rollWaitIcon) that.rollWaitIcon.dispose();
			if (that.toggleIcon) that.toggleIcon.dispose();
			if (that.rollToggleIcon) that.rollToggleIcon.dispose();
			that.icon = that.rollIcon = that.waitIcon = that.rollWaitIcon = that.toggleIcon = that.rollToggleIcon = null;
			if (!disposing) this.zimContainer_dispose(true);
			return true;
		}
	};
	zim.extend(zim.Button, zim.Container, ["clone", "dispose"], "zimContainer", false);
	zim.Button.prototype.dispose = function(disposing) {return this.doDispose(null,null,disposing);};

zim.CheckBox = function(size, label, startChecked, color, backgroundColor, borderColor, borderWidth, corner, margin, indicatorType, indicatorColor, tap, style, group, inherit) {
		var sig = "size, label, startChecked, color, backgroundColor, borderColor, borderWidth, corner, margin, indicatorType, indicatorColor, tap, style, group, inherit";
		var duo; if (duo = zob(zim.CheckBox, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "CheckBox";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

if (zot(size)) size = DS.size!=null?DS.size:60;
		if (zot(label)) label = DS.label!=null?DS.label:null;
		if (zot(startChecked)) startChecked = DS.startChecked!=null?DS.startChecked:false;
		var myChecked = startChecked;
		if (zot(color)) color = DS.color!=null?DS.color:"#111";
		if (zot(backgroundColor)) backgroundColor = DS.backgroundColor!=null?DS.backgroundColor:"rgba(255,255,255,.8)";
		if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:"#111";
		if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:size/10;
		if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
		else if (borderColor!=null && borderWidth==null) borderWidth = size/10;
		if (zot(corner)) corner=DS.corner!=null?DS.corner:0;
		if (typeof label === "string" || typeof label === "number") label = new zim.Label({
			text:label, size:size*5/6, color:color, valign:"center",
			backing:"ignore", shadowColor:"ignore", shadowBlur:"ignore", padding:"ignore", backgroundColor:"ignore",
			style:style, group:this.group
		});
		if (zot(margin)) margin = DS.margin!=null?DS.margin:size/5;
		if (indicatorType != "box" && indicatorType != "square" && indicatorType != "x") indicatorType = DS.indicatorType!=null?DS.indicatorType:"check";
		if (zot(indicatorColor)) indicatorColor = DS.indicatorColor!=null?DS.indicatorColor:borderWidth>0?borderColor:"black";
		this.setBounds(-margin, -margin, size+margin*2, size+margin*2);
		if (zot(tap)) tap = DS.tap!=null?DS.tap:false;

var that = this;
		this.cursor = "pointer";

var box = this.box = new zim.Rectangle(size, size, backgroundColor, null, null, corner);
		var box2 = this.box2 = new zim.Rectangle(size*5/7, size*5/7, "rgba(0,0,0,0)", borderColor, borderWidth, corner);
		box2.x = size/7; box2.y = size/7;
		this.addChild(box, box2);

var fullWidth = size;

if (label) {
			label.center(that);
			label.x = that.getBounds().width;
			this.label = label;
			this.setBounds(-margin, -margin, size+margin*3+label.getBounds().width, Math.max(size+margin*2, label.getBounds().height));
			fullWidth = label.x + label.width;
		}

var backing = new zim.Shape({style:false});
		var g = backing.graphics;
		g.f("rgba(0,0,0,.01)").r(
			this.getBounds().x,
			this.getBounds().y,
			fullWidth+(margin*2),
			this.getBounds().height
		);
		this.hitArea = backing;
		// hitArea will stop rollovers on labels but oh well

var cW = 95;
		check.setBounds(-cW/2, -cW/2, cW, cW);
		var scale = size/(cW+66);

check.scaleX = check.scaleY = scale;
		check.alpha = .9;
		check.x = size/2;
		check.y = size/2;

if (myChecked) this.addChild(check);

if (tap) {
			this.tap(toggleCheck);
		} else {
			this.on((!zns?ACTIONEVENT=="mousedown":zim.ACTIONEVENT=="mousedown")?"mousedown":"click", toggleCheck);
		}

Object.defineProperty(that, 'checked', {
			get: function() {
				return myChecked;
			},
			set: function(value) {
				that.setChecked(value);
			}
		});

this.toggle = function(type) {
			if (zot(type)) type = !myChecked;
			that.setChecked(type);
		};

Object.defineProperty(that, 'toggled', {
			get: function() {
				return myChecked;
			},
			set: function(value) {
				that.setChecked(value);
			}
		});

Object.defineProperty(that, 'text', {
			get: function() {
				if (label) return label.text;
				return null;
			},
			set: function(value) {
				if (label) {
					label.text = value;
					if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
				}
			}
		});

Object.defineProperty(check, 'indicatorColor', {
			get: function() {
				return indicatorColor;
			},
			set: function(value) {
				if (myChecked) {that.removeChild(check);}
				check = new createjs.Shape();
				g2 = check.graphics;
				indicatorColor = value;
				g2.f(indicatorColor).p("AnQAdICBiaIEEDZIF8nfICfB4In/KPg");
				check.scaleX = check.scaleY = scale;
				check.alpha = .9;
				check.x = size/2;
				check.y = size/2;
				if (myChecked) that.addChild(check);
				if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'indicator', {
			get: function() {
				return check;
			},
			set: function(value) {
				zog("ZIM CheckBox - check is read only");
			}
		});

this._enabled = true;
		Object.defineProperty(that, 'enabled', {
			get: function() {
				return that._enabled;
			},
			set: function(value) {
				zenable(that, value);
			}
		});

function toggleCheck(e) {
			myChecked = !myChecked;
			that.setChecked(myChecked);
			that.dispatchEvent("change");
		}

this.setChecked = function(value) {
			if (zot(value)) value = true;
			myChecked = value;
			if (myChecked) {
				that.addChild(check);
			} else {
				that.removeChild(check);
			}
			if ((!zim.OPTIMIZE&&(zns||!OPTIMIZE)) && that.stage) that.stage.update();
			return that;
		};

if (style!==false) zim.styleTransforms(this, DS);
		this.clone = function() {
			return that.cloneProps(new zim.CheckBox(size, label?label.clone():"", startChecked, color, backgroundColor, borderColor, borderWidth, corner, margin, indicatorType, indicatorColor, tap, style, this.group, inherit));
		};
	};
	zim.extend(zim.CheckBox, zim.Container, "clone", "zimContainer", false);

zim.Waiter = function(container, speed, foregroundColor, backgroundColor, corner, shadowColor, shadowBlur, fadeTime, style, group, inherit) {
		var sig = "container, speed, foregroundColor, backgroundColor, corner, shadowColor, shadowBlur, fadeTime, style, group, inherit";
		var duo; if (duo = zob(zim.Waiter, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "Waiter";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

var timeType = getTIME(speed);

if (zot(speed)) speed=DS.speed!=null?DS.speed:timeType=="s"?.6:600; // ms cycle time
		if (zot(foregroundColor)) foregroundColor=DS.foregroundColor!=null?DS.foregroundColor:"white";
		if (zot(backgroundColor)) backgroundColor=DS.backgroundColor!=null?DS.backgroundColor:"orange";
		if (zot(corner)) corner=DS.corner!=null?DS.corner:16;
		if (zot(shadowColor)) shadowColor=DS.shadowColor!=null?DS.shadowColor:"rgba(0,0,0,.3)";
		if (zot(shadowBlur)) shadowBlur=DS.shadowBlur!=null?DS.shadowBlur:14;
		if (zot(fadeTime)) fadeTime=DS.fadeTime!=null?DS.fadeTime:0;

var height = 40;
		var numDots = 3;
		var r = height*.6/2;
		var s = (height-r*2)/2;
		var width = numDots*(r*2+s)+s;

this.setBounds(-width/2,-height/2, width, height);

var that = this;
		var stage;

var display = this.display = new zim.Shape({style:false});
		this.addChild(display);
		display.setBounds(0, 0, width, height);
		display.regX = width/2;
		display.regY = height/2;
		var g = display.graphics;
		g.f(backgroundColor);
		var cc = corner;
		if (!Array.isArray(cc)) cc = [corner, corner, corner, corner];
		g.rc(0, 0, width, height, cc[0], cc[1], cc[2], cc[3]);
		if (shadowColor != -1 && shadowBlur > 0) display.shadow = new createjs.Shadow(shadowColor, 3, 3, shadowBlur);
		display.on("click", function(e) {
			// stops the click from going through the display to the background
			e.stopImmediatePropagation();
		});

var circles = new zim.Container({style:false});
		this.addChild(circles);

var dot;
		for (var i=0; i<numDots; i++) {
			dot = new createjs.Shape();
			dot.graphics.f(foregroundColor).dc(0,0,r);
			dot.x = (i-(numDots-1)/2) * (r*2+s);
			circles.addChild(dot);
			dot.cache(-r,-r,r*2,r*2);
			dot.alpha = 0;
		}

this.hide = function() {
			if (fadeTime > 0) {
				that.animate({obj:{alpha:0}, time:fadeTime, call:end});
			} else {
				end();
			}
			function end() {
				if (that.parent) that.parent.removeChild(that);
				stage = that.stage;
				if (stage) stage.update();
				if (that.zimAccessibility) {
					var a = that.zimAccessibility;
					a.resize(that);
					if (accessibilityClicker) accessibilityClicker.focus();
					else that.zimTabTag.nextSibling.focus();
					setTimeout(function() {a.talk("Waiter has finished.");}, 50);
				}
			}
			that.toggled = false;
			return that;
		};
		var accessibilityClicker;
		var timeouts = [];
		this.show = function() {
			var mess = "zim display - Waiter(): Please pass in a reference to a container with bounds set as first parameter to Waiter";
			if (zot(container)) {
				if (zdf) {
					container = zdf.stage;
				} else {
					zog(mess);
					return;
				}
			} else if (!container.getBounds) {
				zog(mess);
				return;
			} else if (zot(container.stage)) {
				zog("zim display - Waiter(): The container must have a stage property");
				return;
			}
			var dot; var counter=0;
			var s = speed*(timeType=="s"?1000:1);
			for (var i=0; i<circles.numChildren; i++) {
				if (circles) {
					timeouts.push(setTimeout(function() {
						dot = circles.getChildAt(counter);
						createjs.Tween.get(dot,{loop:true})
							.to({alpha:1}, s/numDots/2)
							.wait(s/numDots)
							.to({alpha:0}, s/numDots)
							.wait(s-s/numDots-s/numDots/2);
						counter++;
					}, i*s/numDots));
				}
			}
			that.ticker = createjs.Ticker.on("tick", function() {container.stage.update();});

that.x = (container.getBounds().width) /2;
			that.y = (container.getBounds().height) /2;
			container.addChild(that);
			if (fadeTime > 0) {
				that.alpha = 0;
				that.animate({alpha:1}, fadeTime);
			}
			if (that.zimAccessibility) {
				var a = that.zimAccessibility;
				setTimeout(function(){if (a.activatedObject) accessibilityClicker = a.activatedObject.zimTabTag;}, 50);
				a.resize(that);
				a.talk(that.zimTabTag.getAttribute("aria-label"));
			}
			that.toggled = true;
			return that;
		};
		that.toggle = function(state) {
			if (state===true) that.show();
			else if (state===false) that.hide();
			else if (that.parent) that.hide();
			else that.show();
			return that;
		};

if (style!==false) zim.styleTransforms(this, DS);
		this.clone = function() {
			return that.cloneProps(new zim.Waiter(container, speed, foregroundColor, backgroundColor, corner, shadowColor, shadowBlur, fadeTime, style, this.group, inherit));
		};

this.dispose = function(a,b,disposing) {
			if (that.ticker) createjs.Ticker.off("tick", that.ticker);
			createjs.Tween.removeTweens(that);
			that.removeFrom();
			for (var i=0; i<circles.numChildren; i++) {
				var circle = circles.getChildAt(i);
				clearInterval(timeouts[i]);
				createjs.Tween.removeTweens(circle);
			}
			if (!disposing) this.zimContainer_dispose(true);
			return true;
		};
	};
	zim.extend(zim.Waiter, zim.Container, ["clone", "dispose"], "zimContainer", false);

zim.Tile = function(obj, cols, rows, spacingH, spacingV, unique, width, height, squeezeH, squeezeV, colSize, rowSize, align, valign, count, mirrorH, mirrorV, snapToPixel, clone, events, group, style, inherit) {
		var sig = "obj, cols, rows, spacingH, spacingV, unique, width, height, squeezeH, squeezeV, colSize, rowSize, align, valign, count, mirrorH, mirrorV, snapToPixel, clone, events, group, style, inherit";
		var duo; if (duo = zob(zim.Tile, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "Tile";

this.group = group;
	    var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);
		if (zot(obj)) obj = DS.obj!=null?DS.obj:new zim.Circle();

if (zot(cols)) cols = DS.cols!=null?DS.cols:1121;
		if (zot(rows)) rows = DS.rows!=null?DS.rows:1121;
		var defaultFlag;
		if (cols==1121 && rows==1121) cols = rows = defaultFlag = 3;
		else if (cols==1121) cols = 1;
		else if (rows==1121) rows = 1;
		if (zot(unique)) unique = DS.unique!=null?DS.unique:false;
		if (zot(width)) width = DS.width!=null?DS.width:null;
		if (zot(height)) height = DS.height!=null?DS.height:null;
		if (zot(colSize)) colSize = DS.colSize!=null?DS.colSize:null;
		if (zot(rowSize)) rowSize = DS.rowSize!=null?DS.rowSize:null;
		if (!zot(width)) colSize = null; // width and height override sizes
		if (!zot(height)) rowSize = null;

if (zot(spacingH)) spacingH = DS.spacingH!=null?DS.spacingH:defaultFlag?3:null;
		if (zot(spacingV)) spacingV = DS.spacingV!=null?DS.spacingV:defaultFlag?3:null;
		if (zot(spacingH) || !zot(colSize)) spacingH = 0; // sizes override spacing
		if (zot(spacingV) || !zot(rowSize)) spacingV = 0;
		if (zot(squeezeH)) squeezeH = DS.squeezeH!=null?DS.squeezeH:false;
		if (zot(squeezeV)) squeezeV = DS.squeezeV!=null?DS.squeezeV:false;
		if (zot(align)) align = DS.align!=null?DS.align:"left";
		if (zot(valign)) valign = DS.valign!=null?DS.valign:"top";
		if (zot(count)) count = DS.count!=null?DS.count:(unique&&Array.isArray(obj))?obj.length:null;
		if (count === 0) {count = null; if (zon) {zog("ZIM Tile() - count parameter of 0 is ignored - see docs");}}
		if (zot(mirrorH)) mirrorH = DS.mirrorH!=null?DS.mirrorH:false;
		if (zot(mirrorV)) mirrorV = DS.mirrorV!=null?DS.mirrorV:false;
		if (zot(snapToPixel)) snapToPixel = DS.snapToPixel!=null?DS.snapToPixel:true;
		if (snapToPixel) {
			if (obj && obj.stage) obj.stage.snapToPixelEnabled = true;
			else if (typeof(elem) !== 'undefined' && zdf) zdf.stage.snapToPixelEnabled = true;
		}
		if (zot(clone)) clone = DS.clone!=null?DS.clone:unique?false:true;
		if (zot(events)) events = DS.events!=null?DS.events:true;

var that = this;
		that.cols = cols = Math.round(cols);
		that.rows = rows = Math.round(rows);
		that.spacingH = spacingH;
		that.spacingV = spacingV;
		that.squeezeH = squeezeH;
		that.squeezeV = squeezeV;
		var VEEAlign = (typeof align=="function");
		var VEEVAlign = (typeof valign=="function");
		// these two are used only for not ZIM VEE - as there are VEE with Squeeze is not supported
		that.align = VEEAlign?"left":align;
		that.valign = VEEVAlign?"top":valign;
		that.mirrorH = mirrorH;
		that.mirrorV = mirrorV;

// ~~~~~~~~~~~~~~~~~~~  GET ARRAY OF ITEMS  ~~~~~~~~~~~~~~~
		// this list could be edited later and passed back into remake()
		// so need to separate this part from the rest
		// also, need to record what was made with zik so resize does not change items
		that.items = [];
		var tile;
		var currentCount = 0;
		outer:
		for (var j=0; j<rows; j++) {
			for (var i=0; i<cols; i++) {
				currentCount++;
				if (!zot(count) && currentCount > count) break outer;
				tile = unique?obj[currentCount-1]:zim.Pick.choose(obj);
				if (typeof tile == "string") tile = window.asset(tile).centerReg({add:false}).clone();
				if (zot(tile)) {
					tile = new zim.Container(0,0,0,0);
				}
				// if (clone && !(j==0 && i==0)) tile = tile.clone();
				if (clone) {
					if ((j!=0 || i!=0)) tile = tile.clone();
				}
				if (events) {
					tile.on("change", function (e) {
						var evt = new createjs.Event("change");
						evt.item = e.currentTarget;
						that.dispatchEvent(evt);
					});
				}
				that.items.push(tile);
				tile.tileNum = currentCount-1;
				tile.tileCol = i;
				tile.tileRow = j;
			}
		}

// ~~~~~~~~~~~~~~~~~~~  ORIGINAL CALCULATIONS ~~~~~~~~~~~~~~~
		// collect col and row tile total sizes
		// with resize, we need to do this separately so zik is only run once

var objects; // nested array of objects - recreated from linear items array
		var widthTotals; // for each row
		var heightTotals; // for each column
		var widthMax; // for each column
		var heightMax; // for each row
		var widthTotalMax; // for all columns
		var heightTotalMax; // for all rows
		var widthUncompressedMax; // for all columns uncompressed
		var heightUncompressedMax; // for all rows uncompressed
		var scalesX; // used for resizing mirror
		var scalesY;
		var rowCounts; // number of rows across columns
		var finalAlign; // so any zik col align is rememebered

// remember any set widths and heights in case
		// zik is used for colSize and rowSize
		var widthHeights;

function makeTile() {

that.removeAllChildren();

objects = []; // row arrays of picked objects in column
			widthTotals = []; // for each row
			heightTotals = []; // for each column
			widthMax = []; // for each column
			heightMax = []; // for each row
			widthTotalMax = 0; // for all columns
			heightTotalMax = 0; // for all rows
			widthUncompressedMax = 0; // for all columns uncompressed
			heightUncompressedMax = 0; // for all rows uncompressed
			scalesX = []; // used for resizing mirror
			scalesY = [];
			rowCounts = []; // number of rows across columns
			widthHeights = []; // width and heights per row per col [w,h]
			finalAlign = []; // remember horizontal aligns - vertical aligns are made in final loop

if (!that.items || !that.items.length) that.items = [];
			count = that.items.length;
			var currentCount = 0;
			var tile;
			var j=0; var k=0;
			var h; var w;
			for (var i=0; i<count; i++) {
				j=Math.floor(i/that.cols);
				k=i%that.cols;
				if (zot(objects[j])) objects[j] = [];
				if (zot(that.items[i])) that.items[i] = new zim.Container(0,0,0,0);
				objects[j][k] = that.items[i];
			}
			that.rows = Math.max(1, objects.length);
			that.cols = Math.max(1, !zot(objects[0])?objects[0].length:0);

outer2:
			for (var j=0; j<that.rows; j++) {
				scalesX.push([]);
				scalesY.push([]);
				widthHeights.push([]);
				if (rowSize&&zot(height)) h = zim.Pick.choose(rowSize);
				for (var i=0; i<that.cols; i++) {
					currentCount++;
					if (!zot(count) && currentCount > count) break outer2;
					tile = objects[j][i];
					tile.snapToPixel = snapToPixel;
					that.addChild(tile);

scalesX[j].push(tile.scaleX);
					scalesY[j].push(tile.scaleY);
					if (j==0 && (colSize&&zot(width))) w = zim.Pick.choose(colSize);
					if (j==0) finalAlign.push(zim.Pick.choose(align));
					if (!colSize||!zot(width)) w = Math.abs(tile.width);
					if (!rowSize||!zot(height)) h = Math.abs(tile.height);
					widthHeights[j][i] = [w,h];
					if (zot(widthMax[i])) widthMax[i] = 0;
					if (zot(heightMax[j])) heightMax[j] = 0;
					if (w > widthMax[i]) widthMax[i] = w;
					if (h > heightMax[j]) heightMax[j] = h;
					if (zot(widthTotals[j])) widthTotals[j] = 0;
					if (zot(heightTotals[i])) heightTotals[i] = 0;
					widthTotals[j] += w;
					heightTotals[i] += h;
					if (widthTotals[j] > widthTotalMax) widthTotalMax = widthTotals[j];
					if (heightTotals[i] > heightTotalMax) heightTotalMax = heightTotals[i];
					if (zot(rowCounts[i])) rowCounts[i] = 0;
					rowCounts[i]++;
				}
			}
			if (that.squeezeH === false) {
				for (var i=0; i<widthMax.length; i++) {
					var val = widthMax[i];
					widthUncompressedMax+=val;
				}
			}
			if (that.squeezeV === false) {
				for (var i=0; i<heightMax.length; i++) {
					var val = heightMax[i];
					heightUncompressedMax+=val;
				}
			}

}
		makeTile();

var overallWidth;
		var overallHeight;
		var rowTotals;
		var rowSpacings;
		function resize(width, height) {

// ~~~~~~~~~~~~~~~~~~~  GET WIDTHS ~~~~~~~~~~~~~~~

if (width <= 0) width = null;
			if (height <= 0) height = null;

if (!zot(width)&&that.squeezeH=="full") {
				overallWidth = width;
			} else if (!zot(width)) {
				overallWidth = Math.max(widthTotalMax+(that.cols-1)*that.spacingH, width);
			} else {
				if (widthUncompressedMax > 0) overallWidth = widthUncompressedMax+(that.cols-1)*that.spacingH;
				else overallWidth = widthTotalMax+(that.cols-1)*that.spacingH;
			}

if (!zot(height)&&that.squeezeV=="full") {
				overallHeight = height;
			} else if (!zot(height)) {
				overallHeight = Math.max(heightTotalMax+(that.rows-1)*that.spacingV, height);
			} else {
				if (heightUncompressedMax > 0) overallHeight = heightUncompressedMax+(that.rows-1)*that.spacingV;
				else overallHeight = heightTotalMax+(that.rows-1)*that.spacingV;
			}

that.setBounds(0,0,overallWidth,overallHeight);

// ~~~~~~~~~~~~~~~~~~~  PLACEMENTS ~~~~~~~~~~~~~~~

var rowObjects;
			var colTotal; // keep track of current x positions
			// loop order means we need to keep array data for y
			rowTotals = []; // keep track of current y positions
			rowSpacings = [];
			var rowTops = [];
			var rowTilesTotalWidth;
			for (j=0; j<objects.length; j++) {
				rowObjects = objects[j];
				colTotal = 0;
				if (!zot(width)) {rowTilesTotalWidth = 0;}
				for (i=0; i<rowObjects.length; i++) {
					tile = rowObjects[i];
					var b;
					var left;
					var top;
					var spreadXspacing;
					var spreadYspacing;
					if (j==0) {
						rowTotals[i] = 0;

// ~~~~~~~~~~~~~~~~~~~  VERTICAL ALIGN ~~~~~~~~~~~~~~~

if (!zot(height)) {
							if (that.squeezeV=="full") {
								rowSpacings[i] = rowCounts[i]>1?((height - heightTotals[i]) / (rowCounts[i]-1)):0;
							} else if (that.squeezeV) {
								rowSpacings[i] = rowCounts[i]>1?Math.max(that.spacingV, (height - heightTotals[i]) / (rowCounts[i]-1)):0;
							} else {
								rowSpacings[i] = rowCounts[i]>1?Math.max(that.spacingV, (overallHeight - heightTotals[i]) / (rowCounts[i]-1)):0;
							}
						}
						if (that.squeezeV) {
							// check for center or bottom valign of whole row
							if (that.valign=="center" || that.valign=="middle") {
								rowTops[i] = (overallHeight-(heightTotals[i]+(rowCounts[i]-1)*(!zot(height)?rowSpacings[i]:that.spacingV)))/2;
							} else if (that.valign=="bottom") {
								rowTops[i] = overallHeight-(heightTotals[i]+(rowCounts[i]-1)*(!zot(height)?rowSpacings[i]:that.spacingV));
							} else {
								rowTops[i] = 0;
							}
						} else {
							rowTops[i] = 0;
						}
					}

b = tile.getBounds();
					if (i==0) {

// ~~~~~~~~~~~~~~~~~~~  HORIZONTAL ALIGN ~~~~~~~~~~~~~~~

if (!zot(width)) {
							if (that.squeezeH=="full") {
								spreadXspacing = rowObjects.length>1?((width - widthTotals[j]) / (rowObjects.length-1)):0;
							} else if (that.squeezeH) {
								spreadXspacing = rowObjects.length>1?Math.max(that.spacingH, (width - widthTotals[j]) / (rowObjects.length-1)):0;
							} else {
								spreadXspacing = rowObjects.length>1?Math.max(that.spacingH, (overallWidth - widthTotals[j]) / (rowObjects.length-1)):0;
							}
						}
						if (that.squeezeH) {
							// check for center or right align of whole row
							if (that.align=="center" || that.align=="middle") {
								left = (overallWidth-(widthTotals[j]+(rowObjects.length-1)*(!zot(width)?spreadXspacing:that.spacingH)))/2;
							} else if (that.align=="right") {
								left = overallWidth-(widthTotals[j]+(rowObjects.length-1)*(!zot(width)?spreadXspacing:that.spacingH));
							} else {
								left = 0;
							}
						} else {
							left = 0;
						}

// squeeze does not work with ZIK - so this is for non-squeezed
						var finalVAlign = zim.Pick.choose(valign); // start of each row pick a valign
					}
					// squeeze does not work with ZIK - here is the recorded align for the current column
					align = finalAlign[i];

var w = widthHeights[j][i][0];
					var h = widthHeights[j][i][1];

if (!that.squeezeH && VEEAlign) {
						if (zot(width) && (align=="center" || align=="middle")) {
							tile.x += (widthMax[i]-tile.width)/2;
						} else if (zot(width) && align=="right") {
							tile.x += widthMax[i]-tile.width;
						}
					} else if (!that.squeezeH) { // this allows for dynamic setting of align (for non-VEE, non squeezeH)
						if (zot(width) && (that.align=="center" || that.align=="middle")) {
							tile.x += (widthMax[i]-tile.width)/2;
						} else if (zot(width) && that.align=="right") {
							tile.x += widthMax[i]-tile.width;
						}
					} else {
						if (zot(width) && (that.align=="center" || that.align=="middle")) {
							tile.x += (w-tile.width)/2;
						} else if (zot(width) && that.align=="right") {
							tile.x += w-tile.width;
						}
					}
					if (that.mirrorV && j%2==1) {
						tile.scaleY = -scalesY[j][i];
						// tile.y = rowTotals[i]+h-b.y*2;
					} else {
						// tile.y = rowTotals[i] + tile.regY-b.y;
					}
					tile.pos(null,rowTotals[i]);
					if (!that.squeezeV && VEEVAlign) {
						if (zot(height) && (finalVAlign=="center" || finalVAlign=="middle")) {
							tile.y += (heightMax[j]-tile.height)/2;
						} else if (zot(height) && finalVAlign=="bottom") {
							tile.y += heightMax[j]-tile.height;
						}
					} else if (!that.squeezeV) { // this allows for dynamic setting of valign (for non-VEE, non squeezeV)
						if (zot(height) && (that.valign=="center" || that.valign=="middle")) {
							tile.y += (heightMax[j]-tile.height)/2;
						} else if (zot(height) && that.valign=="bottom") {
							tile.y += heightMax[j]-tile.height;
						}
					} else {
						if (zot(height) && (that.valign=="center" || that.valign=="middle")) {
							tile.y += (h-tile.height)/2;
						} else if (zot(height) && that.valign=="bottom") {
							tile.y += h-tile.height;
						}
					}

if (that.squeezeH === true || !zot(width)) {
						colTotal += w+(!zot(width)?spreadXspacing:that.spacingH);
					} else {
						colTotal += widthMax[i]+(!zot(width)?spreadXspacing:that.spacingH);
					}

tile.x += left;
					tile.y += rowTops[i];

if (that.squeezeV === true || !zot(height)) {
						rowTotals[i] += h+(!zot(height)?rowSpacings[i]:that.spacingV);
					} else {
						rowTotals[i] += heightMax[j]+(!zot(height)?rowSpacings[i]:that.spacingV);
					}
				}
			}
		} // end resize

resize(width, height);

this.itemUnderPoint = function(x, y, ignoreSpacing) {
			if (zot(ignoreSpacing)) ignoreSpacing = true;
			if (zot(x) || zot(y)) return;
			var point = that.globalToLocal(x, y);
			x = point.x;
			y = point.y;

var wT = 0;
			var co = zim.loop(widthMax, function (w, i) {
				wT+=w+that.spacingH;
				if (!ignoreSpacing || ignoreSpacing == "vertical") {
					// test for in cracks
					if (x > wT-that.spacingH  && x < wT) return false;
				}
				if (x < wT-that.spacingH/2) return i;
			});
			if (co === false) return; // in crack
			if (co === true) co = cols-1;

if (x < 0 || x > overallWidth || y < 0 || y > overallHeight) return;
			var hT = 0;
			var ro = zim.loop(heightMax, function (h, j) {
				var ss = !zot(height)?rowSpacings[i]:that.spacingV;
				if (!ignoreSpacing || ignoreSpacing == "horizontal") {
					// test for in cracks
					if (y > hT-ss  && y < hT) return false;
				}
				hT+=h+ss;
				if (y < hT-ss/2) return j;
			});
			if (ro === false) return; // in crack
			if (ro === true) ro = rows-1;

return that.items2D[ro][co];
		};

this.remake = function(items) {
			if (!zot(items)) that.items = items;
			makeTile();
			resize(width, height);
			return that;
		};

this.resize = function(w, h) {
			if (zot(w)) w = width;
			if (zot(h)) h = height;
			width = w;
			height = h;
			resize(w, h);
			return that;
		};

Object.defineProperty(this, "items2D", {
			get:function(){
				return get2D(that.items);
			},
			set:function(val) {
				if (zon) zogy("Tile() - items2D is read only");
			}
		});

Object.defineProperty(this, "items2DCols", {
			get:function(){
				return get2DCols(that.items);
			},
			set:function(val) {
				if (zon) zogy("Tile() - items2DCols is read only");
			}
		});

Object.defineProperty(this, "current", {
			get:function(){
				var items = [];
				var tileWidth = (that.width - (that.cols-1)*that.spacingH) / that.cols;
				var tileHeight = (that.height - (that.rows-1)*that.spacingV) / that.rows;

// loop through tile locations and compile array of objects under point
				zim.loop(that.items, function (t) {
					// get index of middle of bounding box of item
					var b = t.getBounds();
					var x = t.x - t.regX + b.x + b.width / 2;
					var y = t.y - t.regY + b.y + b.height / 2;
					var index = that.hitTestGrid(that.width, that.height, that.cols, that.rows, x, y, null, null, that.spacingH, that.spacingV, true, "open");
					if (index != null) items[index[0]] = t;
				});
				// // slow with hundreds
				// for (var j=0; j<that.rows; j++) {
				// 	for (var i=0; i<that.cols; i++) {
				// 		var x = i*(that.spacingH + tileWidth)+tileWidth/2;
				// 		var y = j*(that.spacingV + tileHeight)+tileHeight/2;
				// 		var item = that.getObjectUnderPoint(x, y, 1);
				// 		items.push(item);
				// 	}
				// }
				return items;
			},
			set:function(val) {
				if (zon) zogy("Tile() - current is read only");
			}
		});

Object.defineProperty(this, "current2D", {
			get:function(){
				return get2D(that.current);
			},
			set:function(val) {
				if (zon) zogy("Tile() - current2D is read only");
			}
		});

Object.defineProperty(this, "current2DCols", {
			get:function(){
				return get2DCols(that.current);
			},
			set:function(val) {
				if (zon) zogy("Tile() - current2DCols is read only");
			}
		});

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it

this.clone = function(exact) {
			if (exact) {
				var exactItems = [];
				for (var i=0; i<that.items.length; i++) {
					exactItems.push(that.items[i].clone(true));
				}
			}
			return that.cloneProps(new zim.Tile(exact?zim.series(exactItems):(obj.clone?obj.clone():obj), that.cols, that.rows, that.spacingH, that.spacingV, unique, width, height, that.squeezeH, that.squeezeV, colSize, rowSize, align, valign, that.items.length, that.mirrorH, that.mirrorV, snapToPixel, exact?false:clone, events, this.style, this.group));
		};
	};
	zim.extend(zim.Tile, zim.Container, "clone", "zimContainer", false);

zim.Emitter = function(obj, width, height, interval, num, life, fade, shrink, decayTime, decayStart, trace, traceFadeTime, traceShiftX, traceShiftY, angle, force, gravity, wind, layers, animation, random, horizontal, vertical, sink, sinkForce, cache, events, startPaused, pool, poolMin, particles, style, group, inherit) {
	    var sig = "obj, width, height, interval, num, life, fade, shrink, decayTime, decayStart, trace, traceFadeTime, traceShiftX, traceShiftY, angle, force, gravity, wind, layers, animation, random, horizontal, vertical, sink, sinkForce, cache, events, startPaused, pool, poolMin, particles, style, group, inherit";
	    var duo; if (duo = zob(zim.Emitter, arguments, sig, this)) return duo;

this.type = "Emitter";
		this.group = group;
		var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);

if (zot(obj)) obj = DS.obj!=null?DS.obj:[new zim.Circle(20,"#e472c4"),new zim.Circle(20,"#acd241"),new zim.Circle(20,"#50c4b7")];
		if (zot(width)) width = DS.width!=null?DS.width:300;
		if (zot(height)) height = DS.height!=null?DS.height:300;
		var timeType = getTIME(interval);
		if (zot(interval)) interval = DS.interval!=null?DS.interval:timeType=="s"?.02:20;
		if (typeof interval == "number") interval = Math.max(timeType=="s"?.01:10, interval);
		if (zot(num)) num = DS.num!=null?DS.num:1;
		if (zot(trace)) trace = DS.trace!=null?trace.size:false;
		if (zot(traceFadeTime)) traceFadeTime = DS.traceFadeTime!=null?DS.traceFadeTime:decayTime;
		if (zot(traceShiftX)) traceShiftX = DS.traceShiftX!=null?DS.traceShiftX:0;
		if (zot(traceShiftY)) traceShiftY = DS.traceShiftY!=null?DS.traceShiftY:0;
		checkTIME(life, timeType);
		if (zot(life)) life = DS.life!=null?DS.life:timeType=="s"?1:1000;
		if (zot(fade)) fade = DS.fade!=null?DS.fade:true;
		if (zot(shrink)) shrink = DS.shrink!=null?DS.shrink:trace?false:true;
		checkTIME(decayTime, timeType);
		if (zot(decayTime)) decayTime = DS.decayTime!=null?DS.decayTime:timeType=="s"?1:1000;
		if (zot(angle)) angle = DS.angle!=null?DS.angle:{min:0, max:360};
		if (zot(force)) force = DS.force!=null?DS.force:5;
		if (zot(gravity)) gravity = DS.gravity!=null?DS.gravity:9.8;
		if (zot(wind)) wind = DS.wind!=null?DS.wind:0;
		if (zot(layers)) layers = DS.layers!=null?DS.layers:"top"; // bottom, random
		if (zot(width)) width = DS.width!=null?DS.width:100;
		if (zot(height)) height = DS.height!=null?DS.height:100;
		if (zot(horizontal)) horizontal = DS.horizontal!=null?DS.horizontal:false;
		if (zot(vertical)) vertical = DS.vertical!=null?DS.vertical:false;
		if (zot(sink)) sink = DS.sink!=null?DS.sink:null;
		if (!zot(sink) && zot(sinkForce)) sinkForce = DS.sinkForce!=null?DS.sinkForce:10;
		if (zot(events)) events = DS.events!=null?DS.events:false;
		if (zot(startPaused)) startPaused = DS.startPaused!=null?DS.startPaused:false;
		if (zot(pool)) pool = DS.pool!=null?DS.pool:true;
		if (zot(poolMin)) poolMin = DS.poolMin!=null?DS.poolMin:0;
		if (zot(particles)) particles = DS.particles!=null?DS.particles:new zim.Container();
		if (zot(animation)) animation = DS.animation!=null?DS.animation:null;
		
		particles.type = "Particles";

this.zimContainer_constructor(width, height, null, null, false);
		this.type = "Emitter";
		var that = this;

this.regX = width/2; // new auto center reg
		this.regY = height/2;

// might want many of these as dynamic properties - sigh.
		that.obj = obj; that.particles = particles;
		that.interval = interval; that.num = num;
		that.life = life; that.fade = fade; that.shrink = shrink;
		that.decayTime = decayTime;  that.decayStart = decayStart;
		that.trace = trace; that.traceFadeTime = traceFadeTime,
		that.traceShiftX = traceShiftX; that.traceShiftY = traceShiftY;
		that.angle = angle, that.emitterForce = force;
		that.gravity = gravity; that.wind = wind;
		that.layers = layers; that.animation = animation; that.random = random;
		that.horizontal = horizontal; that.vertical = vertical;
		that.sink = sink; that.sinkForce = sinkForce;
		that.events = events; that.startEmitterPaused = that.emitterPaused = startPaused;
		that.pool = pool; that.poolMin = poolMin;

that.particlesEmitted = 0;
		var poolList = [];
		var poolIndex = 0;
		var poolCount = 0;

var emitterTicker;
		var stage;
		zim.added(that, addedToStage);
	    function addedToStage(s) {

that.emitterPaused = null; // will set back using that.startEmitterPaused

that.on("added", function () {
				that.particles.addTo(that.parent);
			});
			stage = s;
			if (zot(cache)) {
				if (stage.isWebGL) {
					cache = false;
				} else {
					cache = zim.mobile();
				}
			}
			if (cache) stage.snapToPixelEnabled = true;
			if (stage) {
				var myIndex = that.parent.getChildIndex(that);
				that.parent.addChildAt(particles, myIndex); // add particles beneath emitter in emitter's container
				// particles.x = that.x;
				// particles.y = that.y;
				if (!horizontal && !vertical) that.centerReg(null, null, false);

//-------------   INTERVAL
				// var counter = 0;
				// var time = Date.now();
				// that.interval = 1000 / 60;

that.zimInterval = zim.interval(that.interval, function() {
	            // that.zimInterval = setInterval(function() {

// counter++;
				    // zog(decimals(counter/(Date.now() - time)*1000,5));

if (that.startEmitterPaused) {that.pauseEmitter(); return;}
					// want to leave that.obj as it was provided
					// but for creation we will normalize it as an Array
					obj = Array.isArray(that.obj)?that.obj:[that.obj];
	                if (obj.length <= 0) return;

zim.loop(zim.Pick.choose(that.num), function() {
		                if (that.decayTime > 0) {
		                    var decay = {};
		                    if (that.shrink) decay.scale=0;
		                    if (that.fade) decay.alpha=0;
		                }
						if (that.pool && poolList.length > 0 && poolCount >= Math.max(that.poolMin, (that.life/minInterval+5)*maxNum)) { // USE POOL... throw in an extra 5 for good measure
							var container = poolList[(poolIndex++)%poolList.length];
							container.visible = true;
							var particle = container.trace?container.getChildAt(0):container;
							if (particle.emitShape) {
								var t = particle.template;
								particle.graphics.c().s(t.s?zim.Pick.choose(t.s):null).ss(t.ss?zim.Pick.choose(t.ss):null).sd(t.sd?zim.Pick.choose(t.sd):null, t.offset?zim.Pick.choose(t.offset):null);
							}
							if (container.trace) container.updateCache();
							if (that.layers == "top") {
								if (particle.emitShape) container.addTo(particles, null, false);
								else container.centerReg(particles);
							} else {
								if (particle.emitShape) container.addTo(particles, that.layers=="bottom"?0:zim.rand(particles.numChildren), false);
								else container.centerReg(particles, that.layers=="bottom"?0:zim.rand(particles.numChildren));
							}
							container.alpha = 1;
							container.scaleX = 1;
							container.scaleY = 1;
							particle.alpha = particle.originalAlpha;
							particle.scaleX = particle.originalScaleX;
							particle.scaleY = particle.originalScaleY;
							particle.endSpurt = false;

} else { // END POOL, START NOT POOL
							poolCount++;
							var container;
							if (that.trace) {
								container = new zim.Container(width,height, null, null, false);
								container.trace = true;
							}

if (that.trace) { // still need to add the container if there is one
								if (that.layers == "top") {
									container.addTo(particles, null, false);
								} else {
									container.addTo(particles, that.layers=="bottom"?0:zim.rand(particles.numChildren), false);
								}
								container.cache(traceShiftX,traceShiftY,width,height);
							}

if (!that.trace) container = particle;
							container.particle = particle;
							particle.originalAlpha = particle.alpha;
							particle.originalScaleX = particle.scaleX;
							particle.originalScaleY = particle.scaleY;

} // END NOT POOL

that.currentParticle = particle;
						that.particlesEmitted++;

container.particleNormal = true;
						container.particleDecaying = false;
						container.particleFizzing = false;

if (that.random) {
		                    // {color:[blue, pink, yellow, orange]}
		                    zim.loop(that.random, function(property, options) {
		                        var val = zim.Pick.choose(options);
		                        if (property == "scale") {
		                            particle.sca(val);
		                        } else {
									if (property == "x") {
										particle.info.position.x = (that.horizontal || that.vertical)?val:val+width/2;
									} else if (property == "y") {
										particle.info.position.y = (that.horizontal || that.vertical)?val:val+height/2;
									}
									if ((property == "x" || property == "y") && particle.emitShape) {
										particle.graphics.mt(particle.info.position.x, particle.info.position.y);
									}
		                            particle[property] = val;
									if (particle.emitShape) {particle.x=0; particle.y = 0;} // just adjust info for x and y of shape
		                        }
		                    });
		                }

if (cache && !particle.emitShape) particle.cache(particle.getBounds().x-10,particle.getBounds().y-10,particle.getBounds().width+20,particle.getBounds().height+20);

//-------------    DECAY, FADE, SHRINK, FIZZ

// do not shrink shapes as registration is at 0,0 not at the particle
						var shrinkMe = particle.emitShape?false:that.shrink;

if (that.decayTime > 0 && (that.fade || shrinkMe || (that.trace && that.traceFadeTime > 0))) {

if (that.trace && that.traceFadeTime > 0) {
								container.animate({
									obj:{alpha:0},
									time:that.traceFadeTime,
									wait:that.life-that.traceFadeTime,
									waitedCall:function(t) {
										t.particleNormal = false;
										t.particleFizzing = true;
									},
									call:fizz,
									override:false,
									id:"decay"
								});
							}
							if (that.fade || shrinkMe) {
								var o = {};
								if (that.fade) o.alpha = 0;
								if (shrinkMe) {
									o.scaleX = 0;
									o.scaleY = 0;
								}

// animate seems messed up - recording as if seconds when ms is set
			                    particle.animate({
									obj:o,
									time:that.decayTime,
									wait:zot(that.decayStart)?that.life-that.decayTime:that.decayStart,
									waitedCall:function(t) {
										if (t.parent != that) t = t.parent; // access container if there is one
										t.particleNormal = false;
										t.particleDecaying = true;
									},
									call:function(t) {
										if (that.events) sendEvent("decayed", t);
										if (t.endSpurt) sendEvent("spurtdecayed", t);
										if (!(that.trace && that.traceFadeTime > 0)) {
											if (zot(that.decayStart) || that.decayStart+that.decayTime>that.life) {
												if (t.parent) fizz(t.parent.trace?t.parent:t); // only want to call fizz once
											} else {
												-function() {
						                            var c = container;
						                            zim.timeout(that.life-(that.decayStart+that.decayTime), function(){fizz(c);});
						                        }();
											}
										}
									},
									override:false,
									id:"decay"
								});
							}
		                } else {
		                    if (that.life > 0) {
		                        -function() {
		                            var c = container;
		                            c.timeOut = zim.timeout(that.life, function(){fizz(c);});
		                        }();
		                    }
		               	}
						if (that.events) sendEvent("emitted", container);
						spurtCheck(particle);
		                if (that.animation) {
							var a = zim.Pick.choose(that.animation);
		                    if (zot(a.override)) a.override = false;
		                    particle.animate(zim.copy(a));
		                }
					});
				// }, that.interval);
			}, null, true, true); // true for immediate, true for pause on blur

//-------------  TICKER

});
	            }, stage);
	            frameRate = 1 / zim.Ticker.framerate;
	        }
	    }

that.particles.noMouse();

//-------------    FUNCTIONS

function fizz(p) {

if (that.events) sendEvent("fizzed", p);
			if (p.trace?p.getChildAt(0).endSpurt:p.endSpurt) {
				sendEvent("spurtfizzed", p);
				that.spurting = false;
			}
			if (that.pool) {
				if (p.pooled == "end") {
					// already removed from poolList by clearPool
					// go through and removeChild
				} else if (p.pooled) { // already in the pool
					p.visible = false;
					return;
				} else { // add to pool and return so does not get removed
					p.pooled = true;
					if (poolList) poolList.push(p);
					p.visible = false;
					return;
				}
			}
			that.removeChild(p);
			if (that.trace) p.uncache();
			p = null;
		}

function sendEvent(type, object) {
			if (zot(object)) return;
			var e = new createjs.Event(type);
			e.particle = object.trace?object.getChildAt(0):object;
			that.dispatchEvent(e);
		}

function spurtCheck(p) {
			if (zot(that.spurtCount) && zot(that.spurtNum)) return;
			that.spurtCount++;
			if (that.spurtCount >= that.spurtNum) {
				lastSpurt(p);
			}
		}

function lastSpurt(p) {
			that.pauseEmitter();
			that.spurtCount = that.spurtNum = null;
			if (zot(p)) return;
			sendEvent("spurted", p);
			p.endSpurt = true;
		}

//-------------    PROPERTIES

Object.defineProperty(that, 'interval', {
			get: function() {
				return interval;
			},
			set: function(theInterval) {
				interval = theInterval;
				if (that.zimInterval) that.zimInterval.time = interval;
			}
		});

//-------------    METHODS

this.removeFrom = function(container) {
			// that.removeFrom();
			if (that.parent) that.parent.removeChild(that);
			that.particles.removeFrom();
		};

this.spurting = false;
		this.spurt = function(num, time, restart) {
			var sig = "num, time, restart";
	   	 	var duo; if (duo = zob(that.spurt, arguments, sig)) return duo;

if (!zot(time)) {
				zim.timeout(zim.Pick.choose(time), function() {
					lastSpurt(that.currentParticle);
					// zogr(that.emitterPaused)
				}, true);
				that.spurting = true;
			}
			if (!zot(num)) {
				// handled by checkSpurt() function
				that.spurtNum = zim.Pick.choose(num);
				that.spurtCount = 0;
				that.spurting = true;
			}
			that.pauseEmitter(false, restart, null, true); // unpause and immediately call call interval function
			return that;
		};

this.clearPool = function() {
			zim.loop(that, function(p) {
				p.pooled="end";
				if (!p.visible) that.removeChild(p);
			},true);
			poolCount = 0;
			poolIndex = 0;
			poolList = [];
		};

if (!that.startEmitterPaused) this.emitterPaused = false; // do not set to false - as it will be done below if needed
		this.pauseEmitter = function(state, restart, freeze, immediate) {
			that.startEmitterPaused = null;
			if (zot(state)) state = true;
			if (zot(restart)) restart = false;
			if (zot(freeze)) freeze = false;
			if (state) { // pausing
				if (that.emitterPaused) return that;
				if (freeze) {
					if (emitterTicker) zim.Ticker.remove(emitterTicker);
			        zim.loop(that, function(particle) {
			            particle.pauseAnimate();
						if (particle.trace) particle.getChildAt(0).pauseAnimate();
						if (particle.timeOut) {
							particle.timeOut.pause();
						}
			        });
				}
		        that.zimInterval.pause();
				that.emitterPaused = true;
			} else { // unpausing
				if (!that.emitterPaused) return that;
				if (restart) {
					zim.loop(that, function(particle) {
			            particle.stopAnimate();
						if (particle.timeOut) particle.timeOut.clear();
						if (particle.trace) particle.getChildAt(0).pauseAnimate();
			        });
					that.removeAllChildren();
				}
				if (stage && emitterTicker && !zim.Ticker.has(stage, emitterTicker)) {
					zim.Ticker.add(emitterTicker, stage);
			        zim.loop(that, function(particle) {
			            particle.pauseAnimate(false);
						if (particle.timeOut) particle.timeOut.pause(false);
						if (particle.trace) particle.getChildAt(0).pauseAnimate(false);
			        });
				}
		        if (that.zimInterval) that.zimInterval.pause(false, immediate);
				that.emitterPaused = false;
			}
			return that;
		};

this.resize = function(w, h) {
			if (!zot(w)) width = w;
			if (!zot(h)) height = h;
			that.setBounds(0,0,width,height);
			if (!horizontal && !vertical) that.centerReg();
			that.clearPool();
		};

if (style!==false) zim.styleTransforms(this, DS);

this.clone = function(exact) {
			var objClone;
			if (Array.isArray(that.obj) || that.obj.constructor == {}.constructor) {
				objClone = zim.copy(that.obj);
			} else if (that.obj.clone) {
				objClone = that.obj.clone(exact);
			} else {
				objClone = that.obj;
			}
			// note that all will clone the current property except for startEmitterPaused which clones the initial parameter value
			return that.cloneProps(new zim.Emitter(objClone, width, height, that.interval, that.num, that.life, that.fade, that.shrink, that.decayTime, that.decayStart, that.trace, that.traceFadeTime, that.traceShiftX, that.traceShiftY, that.angle, that.emitterForce, that.gravity, that.wind, that.layers, that.animation, zim.copy(that.random), that.horizontal, that.vertical, that.sink, that.sinkForce, cache, that.events, startPaused, that.pool, that.poolMin, style, that.group, inherit));
	    };

this.dispose = function(a,b,disposing) {
			if (that.zimInterval) that.zimInterval.clear();
	        if (emitterTicker) {
				zim.Ticker.remove(emitterTicker);
			}
			zim.loop(poolList, function(particle) {
				if (particle) particle.dispose();
	        });			
			if (particles && particles.dispose) particles.dispose();
			if (that.currentParticle && that.currentParticle.dispose) that.currentParticle.dispose();
			if (obj && Array.isArray(obj)) {
				zim.loop(obj, function (el) {
					if (el.dispose) el.dispose();
				})
			} else {
				if (obj && obj.dispose) obj.dispose();
			}
			particles = that.currentParticle = that.particles = obj = that.obj = poolList = that.poolList = null;
	        return true;
	    };
	};
	zim.extend(zim.Emitter, zim.Container, "clone", "zimContainer", false);

zim.BlurEffect = function(blurX, blurY, quality, style, group, inherit) {
		var sig = "blurX, blurY, quality, style, group, inherit";
		var duo; if (duo = zob(zim.BlurEffect, arguments, sig, this)) return duo;
		this.group = group;
		var DS = style===false?{}:zim.getStyle("BlurEffect", group, inherit);

// OCT
		if (zot(blurX)) blurX=DS.blurX!=null?DS.blurX:10;
		if (zot(blurY)) blurY=DS.blurY!=null?DS.blurY:10;
		if (zot(quality)) quality=DS.quality!=null?DS.quality:1;
		
		// VEE
		var oa = remember(blurX, blurY, quality);	
		function remember() {return arguments;} 
		blurX = zik(blurX);
		blurY = zik(blurY);
		quality = zik(quality);
			
		this.createjsBlurFilter_constructor(blurX, blurY, quality);
		this.type = "BlurEffect";		
		
		this.clone = function(exact) {
			return new zim.BlurEffect(
				(exact||!zim.isPick(oa[0]))?blurX :oa[0],
				(exact||!zim.isPick(oa[1]))?blurY :oa[1],
				(exact||!zim.isPick(oa[2]))?quality :oa[2],
				style,this.group,inherit
			);
		};
	}	
	zim.extend(zim.BlurEffect, createjs.BlurFilter, "clone", "createjsBlurFilter", false);

zim.SelectionSet = function(selections) {
		this.type = "SelectionSet";
		if (zot(selections)) selections = [];
		this.selections = selections;
		this.clear = function() {
			this.selections = [];
		};
		this.isSelected = function(item) {
			return this.selections.indexOf(item) >= 0;
		};
		// add will append if multiple or SelectionManager multiple is true
		// otherwise turns all other selections off and adds parameter selection
		this.add = function(item, multiple, match, unmatch) {
			if (zot(item)) return;
			if (zot(multiple)) {
				if (!zot(this.selectionManager)) multiple = this.selectionManager.multiple;
			}
			if (!zot(this.selectionManager)) {
				this.selectionManager.setCurrent(this);
				if (!multiple && this.selectionManager.multipleSets) this.selectionManager.clear();
			}
			if (!multiple ) this.clear();
			var ind = this.selections.indexOf(item);
			if (ind >= 0) return;
			this.selections.push(item);
			if (!zot(match)) {
				if (!Array.isArray(match)) match = [match];
				for (var i=0; i<=match.length; i++) {
					match[i].add(item, multiple);
				}
			}
			if (!zot(unmatch)) {
				if (!Array.isArray(unmatch)) unmatch = [unmatch];
				for (i=0; i<=unmatch.length; i++) {
					unmatch[i].remove(item, multiple);
				}
			}
		};
		this.remove = function(item, multiple, match, unmatch) {
			if (zot(item)) return;
			if (zot(multiple)) {
				if (!zot(this.selectionManager)) multiple = this.selectionManager.multiple;
			}
			if (!zot(this.selectionManager)) this.selectionManager.setCurrent(this);
			if (!multiple) this.clear();
			var ind = this.selections.indexOf(item);
			if (!zot(this.selectionManager)) {
				this.selectionManager.setCurrent(this);
				if (!multiple && this.selectionManager.multipleSets) this.selectionManager.clear();
			}
			if (!multiple ) this.clear();
			if (!multiple) this.clear();
			else if (ind >= 0) this.selections.splice(ind, 1);
			if (!zot(match)) {
				if (!Array.isArray(match)) match = [match];
				for (var i=0; i<=match.length; i++) {
					match[i].remove(item, multiple);
				}
			}
			if (!zot(unmatch)) {
				if (!Array.isArray(unmatch)) unmatch = [unmatch];
				for (i=0; i<=unmatch.length; i++) {
					unmatch[i].add(item, multiple);
				}
			}
		};
		this.toggle = function(item, multiple, match, unmatch) {
			if (this.isSelected(item)) this.remove(item, multiple, match, unmatch);
			else this.add(item, multiple, match, unmatch);
		};
		this.dispose = function(a,b,disposing) {
			this.clear();
			this.selections = null;
			return true;
		};
	};

zim.SelectionManager = function(sets, multipleKey, multipleSets) {
		this.cjsEventDispatcher_constructor();
		this.type = "SelectionManager";
		if (zot(sets)) sets = [];
		if (zot(multipleSets)) multipleSets = true;
		if (!Array.isArray(sets)) sets = [sets];
		this.sets = sets;
		this.multipleKey = multipleKey;
		this.multipleSets = multipleSets;
		this.multiple = false;
		var that = this;
		for (var i=0; i<sets.length; i++) {
			sets[i].selectionManager = this;
		}
		this.clear = function() {
			this.currentSet = null;
			for (var i=0; i<sets.length; i++) {
				sets[i].clear();
			}
		};
		this.setCurrent = function(set) {
			this.currentSet = set;
			for (var i=0; i<sets.length; i++) {
				if (sets[i] == set) continue;
				if (!this.multipleSets) sets[i].clear();
			}
		};
		var eDown = new createjs.Event("keydown");
		this.eventRemove = eDown.remove;
		this.keydownEvent = function(e) {
			e.remove = that.eventRemove;
			if (that.multipleKey) that.multiple = e[that.multipleKey+"Key"];
			that.ctrlKey = e.ctrlKey;
			that.shiftKey = e.shiftKey;
			that.metaKey = e.metaKey;
			that.dispatchEvent(e);
			if (e.keyCode==90 && (that.ctrlKey || that.metaKey)) {
				that.dispatchEvent("undo");
			}
		};
		window.addEventListener("keydown", this.keydownEvent);
		
		this.keyupEvent = function(e) {
			if (that.multipleKey) that.multiple = e[that.multipleKey+"Key"];
			that.ctrlKey = e.ctrlKey;
			that.shiftKey = e.shiftKey;
			that.metaKey = e.metaKey;
			e.remove = that.eventRemove;
			that.dispatchEvent(e);
		}
		window.addEventListener("keyup", this.keyupEvent);
		
		this.dispose = function () {
			this.clear();
			window.removeEventListener("keydown", this.keydownEvent);
			window.removeEventListener("keyup", this.keyupEvent);
		};
	};
	zim.extend(zim.SelectionManager, createjs.EventDispatcher, null, "cjsEventDispatcher", false);

zim.Frame = function(scaling, width, height, color, outerColor, assets, path, progress, rollover, touch, scrollTop, align, valign, canvasID, rollPerSecond, delay, canvasCheck, gpu, gpuObj, nextFrame, nextStage, allowDefault, loadFailObj, sensors, retina, mouseMoveOutside, captureMouse, shim, maxConnections) {
		var sig = "scaling, width, height, color, outerColor, assets, path, progress, rollover, touch, scrollTop, align, valign, canvasID, rollPerSecond, delay, canvasCheck, gpu, gpuObj, nextFrame, nextStage, allowDefault, loadFailObj, sensors, retina, mouseMoveOutside, captureMouse, shim, maxConnections";
		var duo; if (duo = zob(zim.Frame, arguments, sig, this)) return duo;
		if (zon) zogg("ZIM FRAME");
		this.cjsEventDispatcher_constructor();
		this.type = "Frame";
		this.startTime = new Date().getTime();
		var that = this;

// global variables to help reference the frame in some cases
		// not currently used for stage critical functions
		// just used to get key events or colors internally
		// also, as of zim 5.1.0 used for new Ticker.add(function(){});
		// will use the zdf.stage if stage is not supplied as second parameter
		// this may lead to problems if a second frame is used
		// and the second frame stage is not used for the new Ticker.add()
		// but two frames are rarely used and this simplifies 99% of the tickers
		if (typeof zdf == 'undefined' || zdf == null || !zdf.type) zimDefaultFrame = zdf = this;

if (zot(canvasCheck)) canvasCheck = true;
		var canvasSupported = !!window.HTMLCanvasElement;
		if (!canvasSupported && canvasCheck) { // no canvas support
			setTimeout(function() {
				that.dispatchEvent("failed");
			}, 100);
			return;
		}
		var mobile = zim.mobile();
		if (zot(scaling)) scaling = "full";
		if (scaling=="outside") scaling = "fill"; // handle legacy outside value
		// if (zot(width)) width = "1024";
		// if (zot(height)) height = "768";
		if (zot(rollover)) rollover = !mobile;
		if (zot(touch)) touch = true;
		if (zot(scrollTop)) scrollTop = false;
		if (zot(align)) align = "center";
		if (zot(valign)) valign = "center";
		var randomCanvas = "";
		if (zot(canvasID)) {
			if (zdf != this) { // more than one canvas with generic name
				randomCanvas = zim.makeID(5);
				canvasID = "myCanvas" + randomCanvas;
			} else {
				canvasID = "myCanvas";
			}
		}
		var timeType = getTIME(delay);
		if (zot(rollPerSecond)) rollPerSecond = 20;
		if (zot(delay)) delay = mobile?(timeType=="s"?1:1000):(timeType=="s"?.03:30);
		if (zot(gpu)) gpu = false;
		if (zot(allowDefault)) allowDefault = false;
		if (zot(loadFailObj)) loadFailObj = "circles";
		this.loadFailObj = loadFailObj;
		if (zot(sensors)) sensors = false;
		if (zot(retina)) retina = true;
		this.retina = retina;
		if (zot(mouseMoveOutside)) mouseMoveOutside = false;
		if (zot(captureMouse)) captureMouse = true;
		if (zot(shim)) shim = false;
		if (zot(maxConnections)) maxConnections = 10;
		var defaultMaxConnections = maxConnections;

if (gpu) retina = false;
		this.retina = retina;

// with the addition of the assets parameter there are two asynchronous events
		// the canvas making with various timeouts and the asset loading
		// When a process is done, it checks to see if readyToDispatch is true
		// if so it dispatches "ready" otherwise it sets the readyToDispatch to true
		// when other process is done, it does the same
		var readyToDispatch = false;
		
		var oldLeft = false;
		this.leftMouseDown = false;
		function leftEvent(e) {
			// e = e.nativeEvent;
		  	that.leftMouseDown = e.buttons === undefined 
			    ? e.which === 1 
			    : e.buttons === 1;
			if (oldLeft && !that.leftMouseDown) that.dispatchEvent("mouseupplus");
			oldLeft = that.leftMouseDown;
		}

// setting a scaling of something other than this list will set the scaling to tag mode
		// where the scaling parameter value is assumed to be the ID of an HTML tag to contain the Frame
		var types = ["fit","fill","full"];

if (shim) {
			this.shim = true;
			shim.stage.frame = this;
			var canvas = this.canvas = shim.canvas;
			this.scale = shim.stage.scaleX;
			var shimTime;
			var shimResizeEvent;
			setTimeout(function() {
				setFrameShim();
				shimResizeEvent = function(){
					setFrameShim();
					if (shimTime) clearTimeout(shimTime);
					// delay a last setting to wait for createjs to update
					shimTime = setTimeout(setFrameShim, 50);
				}
				window.addEventListener('resize', shimResizeEvent);
			}, 20);
			var stage = shim.stage;
			var stageW = stage.getBounds() ? stage.getBounds().width : canvas.width/stage.scaleX;
			var stageH = stage.getBounds() ? stage.getBounds().height: canvas.height/stage.scaleY;
			if (!stage.getBounds()) stage.setBounds(0,0,stageW,stageH);

color = canvas.style.backgroundColor;
			setMousemove();
			function setFrameShim() {
				that.scale = shim.stage.scaleX;
				var bRect = canvas.getBoundingClientRect();
				that.x = bRect.x + zim.scrollX();
				that.y = bRect.y + zim.scrollY();
				zim.scaX = createjs.stageTransformable ? 1 : shim.stage.scaleX;
				zim.scaY = createjs.stageTransformable ? 1 : shim.stage.scaleY;
			}
			setFrameShim();
		} else {
			this.scale = 1;
			this.x = 0;
			this.y = 0;
			var stage;
			var stageW;
			var stageH;
		}

var largest; // automatically set
		var appOrientation; // watch out - orientation keyword is used by apple - sigh
		var lastOrientation; // used to detect orientation change
		var appReady = false; // check variable (watch - "ready" is reserved)
		var tagID;
		var tag;

// 0. part of TEN PATCH
		// need to keep check for resize and assets for dispatching ready
		var resizeReady = false;
		var assetsReady = false;

// Firefox has a glitch when setting the canvas to a new dimension
		// this only happens in full mode if a new Ticker is updating the stage
		// so set the new Ticker update to false - unfortunately for 500ms
		// which means animations will pause a little during resize
		// the resize event triggers pretty quickly and that will update the stage
		var lastTicker;
		var pauseTicker = false;
		var checkResize = (scaling == "full" && typeof InstallTrigger !== 'undefined'); // firefox check

// 1. part of TEN PATCH
		// various tablets have orientation marked wrong - or they start horizontal at 0 rather than vertical at 0
		// like Some Galaxy Tabs - yet Chrome does not report a width and height change with orientation change
		// so it is almost a no win situation - but this tests the start and if incorrect swaps rotation
		// Also see windowWidth() and windowHeight() functions for their usage of swapRotation
		this.swapRotation = false;
		if (mobile && !window.parent) { // can't tell if in iFrame
			var mw = isNaN(window.innerWidth) ? window.clientWidth : window.innerWidth;
			var mh = isNaN(window.innerHeight) ? window.clientHeight : window.innerHeight;
			this.swapRotation = ((window.orientation==0||window.orientation==180)&&mw>mh)||(Math.abs(window.orientation)==90&&mh>mw);
		}

// 2. part of TEN PATCH
		// resize now checks twice for window dimensions - with second time being set by delay parameter
		window.addEventListener('resize', windowResizeEvent);
		var checkTime;
		function windowResizeEvent() {
			if (shim) {
				var bbb = stage.getBounds();
				stageW = bbb.width;
				stageH = bbb.height;
				that.dispatchEvent("resize");
				return;
			}
			checkTime = Date.now() + delay*(timeType=="s"?1000:1);
			if (checkResize) {
				if (!pauseTicker) {
					pauseTicker = true;
					lastTicker = zim.Ticker.update;
					if (!zim.tickerFrame) {
						zim.Ticker.update = false;
						zim.tickerFrame = that;
					}
					sizeCanvas();
					dispatchResize();
					clearInterval(that.frameTime);
					that.frameTime = setInterval(function() {
						if (Date.now() > checkTime) {
							clearInterval(that.frameTime);
							pauseTicker = false;
							if (that==zim.tickerFrame) zim.Ticker.update = lastTicker;
							return;
						}
						sizeCanvas();
						dispatchResize();
					}, 50);
				}
			} else {
				sizeCanvas();
				dispatchResize();
				clearInterval(that.frameTime);
				that.frameTime = setInterval(function() {
					if (Date.now() > checkTime) {
						clearInterval(that.frameTime);
						return;
					}
					sizeCanvas();
					dispatchResize();
				}, delay*(timeType=="s"?1000:1)<50?delay*(timeType=="s"?1000:1)+5:50);
			}
		}

// asset parameter
		that.loadAssetsCount = 0;
		if (zot(zim.assets)) {
			zim.assets = {}; // store asset Bitmap or play function for sound
			zim.assetIDs = {}; // store ids for assets
		}		
		
		var preExistingCanvas = false;
		function init() {
			if (initCheck) return;
			initCheck = true;
			if (types.indexOf(scaling) == -1) {
				tagID = scaling;
				if (zot(zid(tagID))) {zogy("Frame - scaling: HTML tag with id="+scaling+" must exist"); return;}
				tag = that.tag = zid(tagID);
				that.scaling = scaling = (zot(width) || zot(height)) ? "tag" : "inline"; // tag with no dimensions or dimensions
				if (canvasID.indexOf("myCanvas") == 0) canvasID = tagID + "Canvas"; // removed in 6.9.0 + randomCanvas;
				if (tag.tagName.toLowerCase() == "canvas") {
					preExistingCanvas = true;
					canvasID = tagID; // the tag is a canvas (added in Cat 01)
				}
			} else {
				that.scaling = scaling;
			}
			that.canvasID = canvasID;

// now assign default width and height (ignored by full and tag)
			if (zot(width)) width = 500;
			if (zot(height)) height = 500;
			stageW = width;
			stageH = height;

if (!zot(outerColor)) that.outerColor = outerColor;

makeCanvas();
			makeStage();

// 3. part of TEN PATCH
			// two delays to check initial size
			// combined getResize into function
			if (mobile) {
				function getResize() {
					sizeCanvas();
					resizeReady = true;
					// check to make sure any asset loading is done
					checkDispatch();
					dispatchResize();
					if (stage) stage.update();
				}
				// for older mobile - pan hides the location bar
				if (scrollTop) {setTimeout(function() {window.scrollTo(0, 0);}, 50);}
				setTimeout(getResize, 100);
				// for extra delay
				if (delay*(timeType=="s"?1000:1) != 100) setTimeout(getResize, delay*(timeType=="s"?1000:1)); // to catch delayed screen sizes
			} else {
				// check to make sure any asset loading is done
				resizeReady = true;
				checkDispatch();
			}

if (!zot(assets)) { // there are assets
				var q;
				if (assets.constructor == {}.constructor && !(assets.audioSprite || assets.id || assets.data || assets.src)) {
					q = that.loadAssets(zim.merge(assets, {progress:progress, queueOnly:true}));
				} else {
					q = that.loadAssets({assets:assets, path:path, progress:progress, queueOnly:true});
				}
				if (zot(q) || !q.on) {
					if (zon) zogy("Frame() - load failed");

// 4. part of TEN PATCH
					// now keep specific track of assetsReady
					// in three places below
					assetsReady = true;
					checkDispatch();
				} else {
					q.on("complete", function() {
						assetsReady = true;
						checkDispatch();
					});
				}
			} else {
				assetsReady = true;
				checkDispatch();
			}
		}

function makeCanvas() {
			// the width and height of a canvas are separate from from the width and height styles
			// so beware of unintentionally stretching the canvas with styles

if (preExistingCanvas) {
				var canvas = that.canvas = that.tag;
			} else {
				var canvas = that.canvas = document.createElement("canvas");
				canvas.setAttribute("id", canvasID);
			}
			canvas.setAttribute("tabindex", 0);				
			var w = zim.windowWidth();
			var h = zim.windowHeight();
			var pRatio = window.devicePixelRatio || 1;
			// canvas.setAttribute("title", "application");
			if (scaling == "full" || scaling == "tag") {
				if (retina) {
					that.scale = pRatio;
					canvas.setAttribute("width", w*that.scale);
					canvas.setAttribute("height", h*that.scale);
					if (scaling == "full") {
						canvas.style.width = w+'px';
						canvas.style.height = h+'px';
					}
				} else {
					canvas.setAttribute("width", w);
					canvas.setAttribute("height", h);
				}
			} else {
				canvas.setAttribute("width", stageW);
				canvas.setAttribute("height", stageH);
			}
			var alternative = zid(canvasID + "Alternative");
			if (alternative) canvas.appendChild(alternative);
			if (!preExistingCanvas) {
				if (scaling == "tag" || scaling  == "inline") {
					tag.appendChild(canvas);
					// canvas.style.position = "relative"; // to enable zIndex if needed
				} else {
					document.body.appendChild(canvas);
				}
			}
			if (!zot(color)) canvas.style.backgroundColor = color;
			if (scaling == "full" || scaling == "fit" || scaling == "fill") {
				canvas.style.position = "absolute";
				if (!allowDefault) document.body.style.overflow = "hidden";
			} else {
				// helps position Tag, TextArea, etc. when parent is scaled with CSS
				if (getComputedStyle(canvas.parentElement).position=="static") canvas.parentElement.style.position = "relative";
			}
		}

function makeStage() {
			sizeCanvas();
			if (types.indexOf(scaling) != -1 && !allowDefault) {that.zil = zil();} // keep canvas still (from arrows, scrollwheel, etc.) (fit, fill and full only)
			if (that.mousedownEvent && stage) stage.off("stagemousedown", that.mousedownEvent);
			if (that.mousemoveEvent && stage) stage.off("stagemousemove", that.mousemoveEvent);
			stage = gpu?new zim.StageGL(canvasID, gpuObj):new zim.Stage(canvasID);
			stage.frame = that;
			stage.mouseMoveOutside = mouseMoveOutside;
			if (!zot(color) && gpu) stage.setClearColor(zim.convertColor(color));
			stage.setBounds(0, 0, stageW, stageH);
			stage.width = stageW;
			stage.height = stageH;
			if (retina) sizeCanvas();
			if (rollover) stage.enableMouseOver(rollPerSecond); // if you need mouse rollover
			if (touch) createjs.Touch.enable(stage, false, allowDefault); // added for mobile
			if (allowDefault) stage.preventSelection = false; // thanks Jonghyun for the tip // causes double mouse events
			if (nextFrame) stage.nextStage = nextFrame.stage;
			if (nextStage) stage.nextStage = nextStage;
			setMousemove();
		}

if (scaling == "fit") {
				// scales canvas to fit dimensions inside screen
				that.scale = (w/h >= stageW/stageH) ? h/stageH : w/stageW;
			} else if (scaling == "fill") {
				// scales canvas so screen inside dimensions
				that.scale = (w/h >= stageW/stageH) ? w/stageW : h/stageH;
			} else if (scaling == "full") {
				can.style.left = can.style.top = "0px";
				can.width = stageW = w;
				can.height = stageH = h;
				if (stage) {
					stage.setBounds(0,0,stageW,stageH); // need this
					if (retina) {
						var pRatio = window.devicePixelRatio || 1;
						can.width = w*pRatio;
						can.height = h*pRatio;
						can.style.width = w+'px';
						can.style.height = h+'px';
						that.scale = pRatio;
						stage.scaleX = stage.scaleY = that.scale;					
					} else {
						stage.scaleX = stage.scaleY = 1;
					}
					stage.tickOnUpdate = false;
					stage.update();
					stage.tickOnUpdate = true;								
					stage.width = stageW;
					stage.height = stageH;
					if (gpu) stage.updateViewport(stageW/stage.scaleX, stageH/stage.scaleY);
					zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
					zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
				}
				if (!allowDefault) {
					zim.scrollX(0);
					zim.scrollY(0);
				}
				setVisible();
				return;
			} else if (scaling == "tag") {
				// does not scale canvas but sets width and height to tag
				stageW = tag.style.width == "" ? (tag.getAttribute("width") || tag.offsetWidth) : tag.style.width;
				stageH = tag.style.height == "" ? (tag.getAttribute("height") || tag.offsetHeight) : tag.style.height;
				if (retina) {
					can.width = stageW*that.scale;
					can.height = stageH*that.scale;
					can.style.width = stageW+"px";
					can.style.height = stageH+"px";
					if (stage) {
						stage.scaleX = stage.scaleY = that.scale;						
					}
				} else {
					if (stage) stage.scaleX = stage.scaleY = 1;
					can.width = stageW;
					can.height = stageH;
				}
				if (stage) {
					stage.tickOnUpdate = false;
					stage.update();
					stage.tickOnUpdate = true;
					
					stage.setBounds(0,0,stageW,stageH); // need this
					stage.width = stageW;
					stage.height = stageH;
					if (gpu) stage.updateViewport(stageW/stage.scaleX, stageH/stage.scaleY);
					zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
					zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
				}
				tag.style.overflow = "hidden";
				can.style.left = can.style.top = "0px";

var bRect = can.getBoundingClientRect();
				that.x = bRect.x + zim.scrollX();
				that.y = bRect.y + zim.scrollY();
				setVisible();
				return;
			} else if (scaling == "inline") {
				// does not scale canvas but sets width and height
				if (retina) {

// may put percentage style on canvas tag
					// this only handles width and only on first styleSheet
					if (document.styleSheets[0]) {
						try {
							var rules = document.styleSheets[0].rules || document.styleSheets[0].cssRules;
							for (var i=0; i < rules.length; i++) {
						        var rule = rules[i];
						        if (rule.selectorText == "#"+canvasID) {
									var ww = rule.style.getPropertyValue("width");
									if (ww) {
										var www = zum(can.style.width);
										var hhh = zum(can.style.height);
										can.style.width = ww;
									}
						        }
						    }
						} catch (e) {
						}
					}
					var comp = window.getComputedStyle(can);
					var wid = zum(comp.getPropertyValue('width'));
					if (www) {
						can.style.height = (hhh*wid/www) + "px";
						comp = window.getComputedStyle(can);
					}
					var hei = zum(comp.getPropertyValue('height'));

if (retina) {
				var pRatio = window.devicePixelRatio || 1;
				that.scale *= pRatio;
				can.width = stageW*that.scale;
				can.height = stageH*that.scale;
				can.style.width = (stageW*that.scale/pRatio)+'px';
				can.style.height = (stageH*that.scale/pRatio)+'px';
				if (stage) {
					stage.scaleX = stage.scaleY = that.scale;					
				}
			} else {
				if (stage) stage.scaleX = stage.scaleY = 1;
				can.style.width = newW + "px";
				can.style.height = newH + "px";
			}
			if (stage) {
				stage.tickOnUpdate = false;
				stage.update();
				stage.tickOnUpdate = true;
			}
			if (align=="left") that.x = 0;
			else if (align=="right") that.x = (w-newW);
			else that.x = ((w-newW)/2);
			if (valign=="top") that.y = 0;
			else if (valign=="bottom") that.y = (h-newH);
			else that.y = ((h-newH)/2);
			can.style.left = that.x + "px";
			can.style.top = that.y + "px";
			if (!allowDefault) {
				zim.scrollX(0);
				zim.scrollY(0);
			}
			setVisible();

if (stage) {
				zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
				zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
			}
		}

this.update = function() {
			sizeCanvas();
			that.dispatchEvent("update");
		};

// ASSETS
		this.loadAssets = function(assets, path, progress, xhr, time, loadTimeout, outputAudioSprite, crossOrigin, fileType, queueOnly, maxConnections) {
			if (zot(assets)) return endEarly();
			if (zot(assets.src)) { // might be sending single parameter of asset object or audiosprite
				var sig = "assets, path, progress, xhr, time, loadTimeout, outputAudioSprite, crossOrigin, fileType, queueOnly, maxConnections";
				var duo; if (duo = zob(that.loadAssets, arguments, sig)) return duo;
			}
			var timeType = getTIME(time?time:null);
			if (!zot(progress) && progress.type == "ProgressBar" && zot(xhr)) xhr = true;
			if (!Array.isArray(assets)) assets = [assets];
			if (assets.length == 0) return endEarly();
			function endEarly() {
				var queue = new zim.Queue();
				queue.isLoading = false;
				queue.loadAssetsCount = 0;
				setTimeout(function () {
					queue.dispatchEvent("complete");
					that.dispatchEvent("complete");
				}, 10);
				return queue;
			}
			if (zot(time)) time = 0;
			if (zot(loadTimeout)) loadTimeout = timeType=="s"?8:8000;
			if (zot(outputAudioSprite)) outputAudioSprite = false;
			if (zot(crossOrigin)) crossOrigin = "anonymous";
			if (zot(queueOnly)) queueOnly = false;
			if (zot(maxConnections)) maxConnections = defaultMaxConnections;

if (a.noCORSonImage) {
							var img = new Image();
							imagesNoCORS.push(img);
						    img.src = a.src;
							img.id = a.id;
						    img.onload = function(e) {
								var img = e.currentTarget; // bug fixed in Cat 02 patch
								var asset = zim.assets[img.id] = new zim.Bitmap(img).expand(0);
								var ev = new createjs.Event("assetload");
								ev.asset = asset;
								queue.dispatchEvent(ev);
								if (!queueOnly) {
									var ev = new createjs.Event("assetload");
									ev.asset = asset;
									that.dispatchEvent(ev);
								 }
								queue.loadAssetsCount--;
								if (queue.loadAssetsCount == 0) endAssetLoad();
						    };
						} else {							
							zim.assetIDs[a.id] = a.src;
							var maxNum = a.maxNum;
							var aType = a.type;
							var aLoadTimeout = zot(a.loadTimeout)?loadTimeout:a.loadTimeout;
							a = a.src;
							prepareLoad(a);
							var manObj = {src:a, loadTimeout:aLoadTimeout*(timeType=="s"?1000:1), data:maxNum, type:aType};
							if (!zot(fileType)) manObj.type = fileType;
							manifest.push(manObj);
						}
					} else { // ZIM font object
						if (a.src.match(/fonts\.googleapis\.com/)) googleFonts.push(a);
						else fonts.push(a);
					}
				} else {
					prepareLoad(a);
					var manObj = {src:a, loadTimeout:loadTimeout*(timeType=="s"?1000:1)};
					if (!zot(fileType)) manObj.type = fileType;
					manifest.push(manObj);
				}
				if (soundCheck && firstSoundCheck) {
					// dynamically make audio tag with sound to overcome some Apple devices not playing sounds
					var audioTag = document.createElement("audio");
					audioTag.setAttribute("src", ((!zot(path) && !a.match(/^http:\/\/|https:\/\//i))?path:"")+a);
					document.body.appendChild(audioTag);
					firstSoundCheck = false;
				}
			} // end loop

function prepareLoad(a) {
				mainCount++;
				if (a.split) {
					var temp = a.split("?");
					ext = temp[0].match(re);
					if (ext && createjs.Sound.SUPPORTED_EXTENSIONS.indexOf(ext[1]) >= 0) soundCheck = true;
				}
			}
			that.loadAssetsCount++;
			that.isLoading = true;
			var queue = new zim.Queue();
			queue.isLoading = true;
			queue.loadAssetsCount = 0;

if (!zot(progress) && progress.show) {
				progress.zimActiveLoader = queue;
                progress.show();
            }

if (fonts.length > 0) { // there are fonts to load
				// create manual list - which seems to always work
				var fontObjects = [];
				var fontObject;
				var fontData;
				for (var i=0; i<fonts.length; i++) {
					fontData = fonts[i];
					fontObject = {
						src: "url("+(fontData.src.match(/^http/i)?"":(path?path:""))+fontData.src+")" + (fontData.type?" format('"+fontData.type+"')":""),
						family: fontData.font
					};
					if (fontData.weight) fontObject.weight = fontData.weight;
					if (fontData.style) fontObject.style = fontData.style;
					fontObjects.push(fontObject);
				}
				var fontLoader = new createjs.FontLoader({src:fontObjects}, true);
				fontLoader.on("complete", fontDone);
				fontLoader.on("error", fontDone);
			    fontLoader.load();
				queue.loadAssetsCount++;
			}
			if (googleFonts.length > 0) { // there are google fonts to load
				var fontLoader;
				for (var i=0; i<googleFonts.length; i++) {
					fontData = googleFonts[i];
					fontObject = {
						src: fontData.src,
						type: "fontcss"
					};
					queue.loadAssetsCount++; // each google font gets its own loader
					fontLoader = new createjs.FontLoader(fontObject, true);
					fontLoader.on("complete", fontDone);
					fontLoader.on("error", fontDone);
				    fontLoader.load();
				}
			}
			function fontDone() {
				queue.loadAssetsCount--;
				if (queue.loadAssetsCount == 0) endAssetLoad();
			}

if (imagesNoCORS.length > 0) { // there are image tags loading to defeat CORS
				// loaded events are up above in loop
				for (var i=0; i<imagesNoCORS.length; i++) {
					queue.loadAssetsCount++;
				}
			}
			
			function svgDone(bitmap, params) {
				queue.loadAssetsCount--;
				var item = params.item;				
				var asset = zim.assets[item.id] = bitmap;	
				asset.svg = params.svg; // add SVG to Bitmap as property
				var ev = new createjs.Event("assetload");
				ev.item = item; // createjs preload item
				ev.asset = asset;
				queue.dispatchEvent(ev);
				if (!queueOnly) {
					var ev = new createjs.Event("assetload");
					ev.item = item;
					ev.asset = asset;
					that.dispatchEvent(ev);
				 }				 
				if (queue.loadAssetsCount == 0) endAssetLoad();				 
			}

try {preload.loadManifest(manifest);}catch(err){}
				// // strange - the try just stops an error but still loads
				// catch {
				// 	// setTimeout(function() {
				// 	// 	preload.loadManifest(manifest);
				// 	// }, 50);
				// }

} // end non font/noCORSonImage

function endAssetLoad() {
				// setting a time will force the preload to wait at least this amount of time
				// this can be used for testing or if you always want time to show a loading message
				var endLoad = Date.now();
				time = Math.max(0, time-(endLoad-startLoad));
				setTimeout(function() {
					that.loadAssetsCount--;
					if (that.loadAssetsCount <= 0) that.isLoading = false;
					queue.isLoading = false;
					queue.dispatchEvent(completeEventObject);
					if (!queueOnly) that.dispatchEvent(completeEventObject);
				}, time*(timeType=="s"?1000:1));
			}
			return queue;
		};

// called by asset if auto loading (ac is Asset Container)
		this.ac = function(method, args, obj) {
			if (obj) {
				if (!obj.commands) obj.commands = [];
	   			obj.commands.push([method,args,obj]);
			} else {
				if (!args[0].commands) args[0].commands = [];
				args[0].commands.push([method,args]);
			}
		};

// create a global asset function
		// and a Frame asset method
		// change to not window.asset for Cat 02
		window.asset = zim.asset = this.asset = function(n, w, h, second) {
			if (zot(n)) return;
			n = zik(n);			
			var fromID = zim.assetIDs[n];
			if (fromID) n = fromID;

// getting {type:"sound", path:"assets/", id:732}
			// want    {type:"sound", path:"assets/", id:"bird.mp3"}
			if (zim.assets[n]) return zim.assets[n];

// regular asset has been returned above
			// now check auto load assets or broken if second

if (second) {
				if (that.loadFailObj == "circles") var empty = that.makeCircles(14);
				else var empty = that.loadFailObj;
				if (empty) {
					empty.type = "EmptyAsset";
					empty.id = n;
					empty.play = function(){if (zon) {zogy("Frame - asset("+n+") not found"); return {};}};
				}
				return empty;
			} else {
				var assetHolder = new zim.Container(w, h);
				if (w && h) assetHolder.type = "ACWD"; // AssetContainer with Dimensions - does not recall methods
				else assetHolder.type = "AC"; // AssetContainer
				var assetLoader = that.loadAssets(n);
				var parts = n.split(".");
				if (createjs.Sound.SUPPORTED_EXTENSIONS.indexOf(parts[parts.length-1]) >= 0) {
					assetHolder.type = "Sound";
					assetHolder.play = function() {
						assetHolder.playParams = arguments;
						assetHolder.proxy = new createjs.EventDispatcher();
						Object.defineProperty(assetHolder.proxy, 'volume', {
							get: function() {
								if (assetHolder.sound) return assetHolder.sound.volume;
							},
							set: function(value) {
								assetHolder.volume = value;
								if (assetHolder.sound) assetHolder.sound.volume = value;
							}
						});
						Object.defineProperty(assetHolder.proxy, 'pan', {
							get: function() {
								if (assetHolder.sound) return assetHolder.sound.pan;
							},
							set: function(value) {
								assetHolder.pan = value;
								if (assetHolder.sound) assetHolder.sound.pan = value;
							}
						});
						return assetHolder.proxy;
					}
				}
				assetLoader.on("complete", function () {
														
					// thanks Xuntar for the adjustment Cat 03
					// to handle lazy load with asset({id:"etc", src:"https:domain/etc.png"});
					if (n.id) n = n.id; 
					else if (n.src) n = n.src;
										
					var loaded = that.asset(n, null, null, true);
					zim.assets[n] = assetHolder; // assign assetHolder back to asset in case used again
					if (loaded.play) {
						assetHolder.play = loaded.play;
						if (assetHolder.playParams) {							
							assetHolder.sound = assetHolder.play.apply(null, assetHolder.playParams);
							if (assetHolder.volume != null) assetHolder.sound.volume = assetHolder.volume;
							if (assetHolder.pan != null) assetHolder.sound.pan = assetHolder.pan;
							assetHolder.sound.on("complete", function () {
								assetHolder.proxy.dispatchEvent("complete")
							});
						} 						
					} else if (loaded.type == "Bitmap") {
						loaded.addTo(assetHolder);
						assetHolder.mouseChildren = false;
						assetHolder.type = "Image";
						assetHolder.bitmap = loaded;
						assetHolder.image = loaded.image;
						assetHolder.id = loaded.id;
						if (assetHolder.commands) {
							for (var i=0; i<assetHolder.commands.length; i++) {
								if (assetHolder.commands[i][2]) assetHolder[assetHolder.commands[i][0]].apply(assetHolder, assetHolder.commands[i][1]);
								else zim[assetHolder.commands[i][0]].apply(assetHolder, assetHolder.commands[i][1]);
							}
						}
						assetHolder.commands = null;
						if (assetHolder.stage) assetHolder.stage.update();
					} else if (loaded.type == "EmptyAsset") {
						loaded.addTo(assetHolder);
						assetHolder.mouseChildren = false;
						assetHolder.type = "EmptyAsset";
						if (assetHolder.stage) assetHolder.stage.update();
					}
					assetHolder.dispatchEvent("assetLoad");
					assetHolder.dispatchEvent("complete");
				});
				return assetHolder;
			}
		};
		zim.asset.getIDs = function() {
			var ids = [];
			for (name in zim.assetIDs) {
				ids.push(name);
			}
			return ids;
		};

// create an image function
		// that uses CORS busting and then calls asset()
		zim.image = function(n, w, h, second) {
			if (n.match(/^htt/i)) n = "https://cors.zimjs.com/" + n;
			return zim.asset(n, w, h, second);
		};

zim.zimObjectIDs = {};
		zim.object = this.object = function(name) {
			return zim.zimObjectIDs[name];
		};
		zim.object.getNames = function() {
			var names = [];
			for (name in zim.zimObjectIDs) {
				names.push(name);
			}
			return names;
		};

if (!window.zns) {
			window.asset = this.asset;
			window.image = zim.image;
			window.object = this.object;
		}

this.setDefault = function() {
			zimDefaultFrame = zdf = that;
			return that;
		};

Object.defineProperty(that, 'isDefault', {
			get: function() {
				return zdf == that;
			},
			set: function(s) {
				zogy("Frame(): isDefault is read only - see setDefault()");
			}
		});

Object.defineProperty(that, 'stage', {
			get: function() {
				return stage;
			},
			set: function(s) {
				zogy("Frame(): stage is read only - see remakeCanvas(), perhaps");
			}
		});

Object.defineProperty(that, 'width', {
			get: function() {
				return stageW;
			},
			set: function(w) {
				zogy("Frame(): width is read only - see remakeCanvas(), perhaps");
			}
		});

Object.defineProperty(that, 'height', {
			get: function() {
				return stageH;
			},
			set: function(h) {
				zogy("Frame(): height is read only - see remakeCanvas(), perhaps");
			}
		});

Object.defineProperty(this, 'color', {
			get: function() {
				return color;
			},
			set: function(value) {
				color = value;
				if (!zot(value)) {
					zid(canvasID).style.backgroundColor = color;
					if (!zot(color) && gpu) stage.setClearColor(zim.convertColor(color));
				} else {
					zid(canvasID).style.backgroundColor = "default";
				}
			}
		});

var _outerColor;
		Object.defineProperty(this, 'outerColor', {
			get: function() {
				return _outerColor;
			},
			set: function(value) {
				_outerColor = value;
				zet("body").css({backgroundColor:_outerColor});
			}
		});

Object.defineProperty(that, 'allowDefault', {
			get: function() {
				return allowDefault;
			},
			set: function(t) {
				if (t) {
					stage.preventSelection = false;
					document.body.style.overflow = "visible";
					if (that.zil) {
						window.removeEventListener("keydown", that.zil[0]);
						window.removeEventListener("wheel", that.zil[1]);
						window.removeEventListener("DOMMouseScroll", that.zil[2]);
						that.zil = null;
					}
				} else {
					stage.preventSelection = true;
					stage.enableDOMEvents(true);
					if (scaling == "full" || scaling == "fit" || scaling == "fill") document.body.style.overflow = "hidden";
					if (zot(that.zil)) that.zil = zil();
				}
				allowDefault = t;
				if (stage.__touch) stage.__touch.preventDefault = !allowDefault;
			}
		});

this.remakeCanvas = function(width, height) {
			if (scaling == "full") return;
			if (zot(width)) width = stageW;
			if (zot(height)) height = stageH;
			if (zid(canvasID)) zid(canvasID).parentNode.removeChild(zid(canvasID));
			stageW = width;
			stageH = height;
			var onStage = [];
			for (var i=0; i<that.stage.numChildren; i++) {
				onStage.push(that.stage.getChildAt(i));
			}
			makeCanvas();
			makeStage();
			for (var i=0; i<onStage.length; i++) {
				that.stage.addChild(onStage[i]);
			}
		};

this.follow = function(obj, boundary, damp, dampY, leftOffset, rightOffset, upOffset, downOffset, offsetDamp, offsetDampY, horizontal, vertical, borderLock, lag) {
			var sig = "obj, boundary, damp, dampY, leftOffset, rightOffset, upOffset, downOffset, offsetDamp, offsetDampY, horizontal, vertical, borderLock, lag";
			var duo; if (duo = zob(that.follow, arguments, sig)) return duo;
			that.followObj = null;
			if (that.followTicker) zim.Ticker.remove(that.followTicker);
			if (zot(obj)) return;
			obj.dirX = obj.dirY = 0;
			that.followObj = obj;
			obj.followDampX = null;
			obj.followDampY = null;
			if (zot(boundary)) boundary = new zim.Boundary(0,0,that.stage.width,that.stage.height);
			that.followBoundary = boundary;
			if (zot(damp)) damp = .05;
			if (zot(dampY)) dampY = damp;
			if (zot(leftOffset)) leftOffset = 0;
			if (zot(rightOffset)) rightOffset = 0;
			if (zot(upOffset)) upOffset = 0;
			if (zot(downOffset)) downOffset = 0;
			if (zot(offsetDamp)) offsetDamp = .02;
			if (zot(offsetDampY)) offsetDampY = offsetDamp;
			if (zot(horizontal)) horizontal = true;
			if (zot(vertical)) vertical = true;
			if (zot(borderLock)) borderLock = false;
			if (zot(lag)) lag = false;

if (!obj.parent) obj.on("added", good);
			else good();
			function good() {
				var container = obj.parent;
				that.frameBorderLock = borderLock;
				if (horizontal) {
					that.followDampX = new zim.Damp(container.x,damp);
					that.offsetDampX = new zim.Damp(boundary.x+leftOffset+(boundary.width-leftOffset-rightOffset)/2, offsetDamp);
				}
				if (vertical) {
					that.followDampY = new zim.Damp(container.y,dampY);
					that.offsetDampY = new zim.Damp(boundary.y+upOffset+(boundary.height-upOffset-downOffset)/2,offsetDampY);
				}
				that.followTicker = zim.Ticker.add(function () {
					var boundary = that.followBoundary;
					if (horizontal) {
						var midH = boundary.x+leftOffset+(boundary.width-leftOffset-rightOffset)/2;
						that.followOffsetX = [lag?boundary.x+boundary.width-leftOffset:midH, midH, lag?boundary.x+leftOffset:midH];
						if (that.followObj) container.x = that.followDampX.convert(that.offsetDampX.convert(that.followOffsetX[obj.motionController?obj.motionController.dirX+1:1])-obj.x);
					}
					if (vertical) {
						var midV = boundary.y+upOffset+(boundary.height-upOffset-downOffset)/2;
						that.followOffsetY = [lag?boundary.y+boundary.height-downOffset:midV, midV, lag?boundary.y+upOffset:midV];
						if (that.followObj) container.y = that.followDampY.convert(that.offsetDampY.convert(that.followOffsetY[obj.motionController?obj.motionController.dirY+1:1])-obj.y);
					}

if (that.frameBorderLock) {
					    if (container.x > that.followBoundary.x) container.x = that.followBoundary.x;
					    if (container.y > that.followBoundary.y) container.y = that.followBoundary.y;
					    if (container.x < (that.followBoundary.x + that.followBoundary.width - container.width)) container.x = (that.followBoundary.x + that.followBoundary.width - container.width);
					    if (container.y < (that.followBoundary.y + that.followBoundary.height - container.height)) container.y = (that.followBoundary.y + that.followBoundary.height - container.height);
					}
				});
			}
			return obj;
		};

this.dispose = function(a,b,disposing) {

// remove zil events
			if (that.zil && that.zil.length) {
				window.removeEventListener("keydown", that.zil[0]);
				window.removeEventListener("wheel", that.zil[1]);
				window.removeEventListener("DOMMouseScroll", that.zil[2]);
			}
			
			// remove frame events
			// var realWindow = window.parent || window;
			if (shimResizeEvent) window.removeEventListener('resize', shimResizeEvent);
			window.removeEventListener('resize', windowResizeEvent);
			window.removeEventListener("keydown", keydownEvent); // thanks Reinout Mechant for the fix!
			window.removeEventListener("keyup", keyupEvent);
			window.removeEventListener("wheel", wheelEvent);
			window.removeEventListener("devicemotion", devicemotionEvent);
			window.removeEventListener("deviceorientation", deviceorientationEvent);
			
			window.removeEventListener("mousedown", leftEvent, true);
			window.removeEventListener("mousemove", leftEvent, true); 
			window.removeEventListener("mouseup", leftEvent);
						
			if (!allowDefault) document.body.style.overflow = "auto";
			recursiveDispose(stage);
			function recursiveDispose(obj) {
				if (obj.dispose) obj.dispose();
				else {
					obj.removeAllEventListeners();
					if (obj.numChildren) {
						for (var i=obj.numChildren-1; i>=0; i--) {
							recursiveDispose(obj.getChildAt(i));
						}
					}
					if (obj.parent) obj.parent.removeChild(obj);
				}
			}
			if (zid(canvasID)) zid(canvasID).parentNode.removeChild(zid(canvasID));
			if (that == zim.tickerFrame) zim.tickerFrame = null;
			if (that === zdf) zdf = null;

stage = null;
			that = null;
			return true;
		};

// zim colors - legacy
		this.orange		= "#f58e25";
		this.green  	= "#acd241";
		this.pink  		= "#e472c4";
		this.blue   	= "#50c4b7";
		this.brown  	= "#d1a170";
		this.yellow   	= "#ebcb35";
		this.purple		= "#993399";
		this.red 		= "#fb4758"; // dedicated to Alexa
		this.black 		= "#000000";
		this.darker 	= "#111111";
		this.dark 		= "#333333";
		this.grey   	= "#555555";
		this.gray 		= "#555555";
		this.tin		= "#777777";
		this.silver		= "#999999";
		this.fog		= "#aaaaaa";
		this.mist		= "#bbbbbb";
		this.light 		= "#cccccc";
		this.moon 		= "#dddddd";
		this.lighter 	= "#eeeeee";
		this.white		= "#ffffff";
		this.clear 		= "rgba(0,0,0,0)";
		this.faint 		= "rgba(0,0,0,.01)";

this.makeCircles = function(radius, multiple) {
			if (zot(radius)) radius = 100;
			var colors = [that.orange, that.green, that.pink, that.blue, that.brown, that.dark];
			if (multiple) {
				var c = new zim.Container({style:false});
				c.radius = radius;
				for (var i=0; i<colors.length; i++) {
					c.addChild(new zim.Circle((c.radius/colors.length)*(colors.length-i), colors[i], null, null, null, null, null, null, false));
				}
			} else {
				var c = new zim.Shape({style:false});
				var g = c.graphics;
				c.radius = radius;
				for (var i=0; i<colors.length; i++) {
					g.f(colors[i]).dc(0,0,(c.radius/colors.length)*(colors.length-i));
				}
				c.setBounds(-c.radius,-c.radius,c.radius*2,c.radius*2);
			}
			return c;
		};

this.madeWith = function(color, text, edges, box, slats, borderColor, borderWidth) {

if (zot(color)) color = zim.dark;
			if (zot(text)) text = "Made with ZIM";

var madeWith = new zim.Container();
			var icon = madeWith.icon = that.makeIcon(edges, box, slats, borderColor, borderWidth)
				.sca(.5).alp(.92).hov(1).addTo(madeWith)
				.tap(function () {
					icon.alp(.92);
					icon.stage.update();
					zgo("https://zimjs.com", "_blank");
				});
			var label = madeWith.label = new zim.Label(text, 16, null, color).sca(.7).pos(0, -19, zim.CENTER, zim.BOTTOM, madeWith);
			return madeWith;
		};

this.makeIcon = function(edges, box, slats, borderColor, borderWidth) {
	        var icon = new zim.Container(-20, -13, 102, 120).reg(-20,-13);
			if (zot(edges)) edges = that.light;
			if (zot(box)) box = that.dark;
			if (slats === true) slats = [that.silver, that.silver, that.silver, that.silver, that.silver];
	        new zim.Rectangle(icon.width, icon.height, box, borderColor, borderWidth).loc(-20,-13,icon);

var data = [
	            [slats?slats[0]:"#E474C3", "AieA0IAAgCIAmhlIEXAAIg5Bng", 41.7, 19.5],
	            [slats?slats[1]:"#50C5B7", "AiSAzIAnhlID+AAIg5Blg", 35.3, 33.2],
				[slats?slats[2]:"#F48E25", "AiFA0IAmhnIDlAAIg5Bng", 28.9, 46.7],
			    [slats?slats[3]:"#EBCD36", "Ah4AzIAmhlIDLAAIg5Blg", 22.4, 60.5],
			  	[slats?slats[4]:"#ABD140", "AhrA0IAAgFIAlhiICxAAIg5Bng", 16.1, 74.3],
	            [edges, "AlGHRIAnhnIH+AAIgbBngAlGlpIAnhnIJmAAIg5Bng", 32.7, 46.5],
	        ];
	        zim.loop(data, function (d) {
	            var shape = new zim.Shape().addTo(icon);
	            shape.graphics.f(d[0]).p(d[1]);
	            shape.setTransform(d[2],d[3]);
	        });
	        icon.mouseChildren = false;
	        return icon;
	    };

this.makeCat = function(height) {
			if (zot(height)) height = 246;
			var data = [
		        [16.95,241.15, 0,"black",[1.5,2,1],"AgKAhIAVhB"],
		        [58.65,244.378,0,"#A7A7A7",[3,2,1],"AmYAAIMxAB"],
		        [105.64,107.14,"#EF7988",0,0,"AAEArQgNAAgjghQgiggAFgIQAFgJBEgCQBEgDAGAGQAHAIgfAkQgfAlgPAAIAAAAg"],
		        [104.84,111.34,0,"black",[1,1,1],"AABA2IAPAYQAJAPAJAGQAKAHAMAAQAbAAAXgWQAQgPAVghQAVghAAgcQAAgnglgYQgbgSgxgCIgrACAAJADIgIAzAhphVQgXAVgMAWQgKAQgIAiQgIAkAFAMQALAfAqAOQAmANAcgIQANgEANgQQALgNAGgT"],
		        [105.05,111.4,"#757B74",0,0,"AheBrQgvgRgQgeQgPgdAQgkQAZg8AEgFQAXgfA8gGQBVgKA+ATQBRAZgYBEQgVA/gnAZQgUAOgZAKQgJAJgVgbQgUgegCAAQgDAAgWAgQgWAUgZAAQgMAAgNgEg"],
		        [86.18,93,"black",0,0,"Aj7g0QiYg0i9AyQA0g3BcgRQBagQBfAaQBkAbBEBBQBNBHASBpQhgiYibg0gAFxiDQAzgdA6AMQA9AMA2A4QgHgBAAACQAAAAgBABQAAAAAAAAQgBAAgBAAQAAAAgBgBQh8gshOAzQhIAvhBCYQALjABzhCg"],
		        [78.5,63.23,"#705F6C","black",[1,1,1],"AHAg5IgNmIIBfGpQgOgQgSgMQgjgXgPASgAKeDZQg2g4g9gMQg6gMgzAdQhzBCgLDBQBBiZBIgvQBNgzB9AsQAEACAAgCQAAgCAHABgAqdBuIAAnsIDmHEQgegMgsgBQhXgChFA3gAoEDzQA0g3BdgRQBagQBeAaQBkAbBFBBQBMBIASBpQhfiYibg1QiYg0i+Ayg"],
		        [86.28,98.01,"black","black",[1,1,1],"AJSh/QgEADgHgDQgFgBgBAFQgNBXhNA9QhTBEhagZQgGgCgPAFQgUAHgEAAQCNAeBchOQBGg7AWhigApRhnQAFABAIAAQAGABAAAAQBFBsCVA7QCpBDCrgzQACAAAHAJQAEAFAFAJQjAAzitg/Qing9g/iHg"],
		        [96.95,97.3,"#0C0436",0,0,"AlZBJQgVgVAAgeQAAgcAVgVQAVgVAeAAQAdAAAVAVQAVAVAAAcQAAAegVAVQgVAVgdAAQgeAAgVgVgAD1AcQgVgVAAgdQAAgdAVgVQAVgVAeAAQAdAAAVAVQAVAVAAAdQAAAdgVAVQgVAVgdAAQgeAAgVgVg"],
		        [96.88,97.2,"#EA9424",0,0,"AlpBYQgbgbAAgnQAAglAbgbQAbgbAnAAQAmAAAbAbQAbAbAAAlQAAAngbAbQgbAbgmAAQgnAAgbgbgADnArQgbgbAAgmQAAgmAbgbQAbgbAmAAQAnAAAbAbQAbAbAAAmQAAAmgbAbQgbAbgnAAQgmAAgbgbg"],
		        [96.88,97.2,"#AFCE3A",0,0,"AlzBiQgggfAAgtQAAgrAggfQAfggAtAAQAsAAAgAgQAfAfAAArQAAAtgfAfQggAggsAAQgtAAgfgggADcA1QgfgfAAgsQAAgsAfgfQAgggAsAAQAtAAAfAgQAgAfAAAsQAAAsggAfQgfAggtAAQgsAAggggg"],
		        [78.5,64.1,0,"black",[1,1,1],"AHAhCIgNmIIBfGpQgOgQgSgMQgjgXgPASgAKeDQQg2g4g9gMQg6gMgzAdQhzBCgLDBQCqAvBlhgQBJhFAGhagAoADiQAlgiBTgOQBYgOBaARQDrAsA0DTQjAAziog/Qihg+hAiIgAqdBlIAAnsIDmHEQgegMgsgBQhXgChFA3g"],
		        [86.375,93.9,"#EACE35",0,0,"AltB+Qiig9g/iIQAkghBTgOQBZgPBaARQDrAtA0DRQhWAXhSAAQhkAAhcgjgADxB2QALjABzhBQAzgeA6AMQA9ANA2A4QgGBYhJBGQhEBAhiAAQgxAAg4gQg"],
		        [73.45,154.83,"black","black",[2,1,1],"AkjjDIByAMQB/ANBEAFQB/AICXgSIgKFzQj4hflLiNQgDgBAFiag"],
		        [79.42,123.62,"#A7A7A7","black",[2,1,1],"AEBpxIgBgBQAYiNAeiQQA8kgAfgMQAggNBLEqQAlCVAfCXIAXARQAbAXAZAcQBQBZAZBnQAZBngUB+QgKA/gPArQgeASgrAWQhYAuhFAXQg8AUh0AWIhoASIAAQzItygCQAvhKA1hoQBqjRAjiXQAri/AOjLIAFimQgegHhTgeQhEgZhgg/IhTg7QgekPgQkUQggonBEgWQBFgWCbEtQAkBGA3B9QAbA9AYA3QASAqAQAmIgjhQIABAAIJmgYIBUACIBQAK"]
		    ];
			var catIcon = new zim.Container(157.5,246);
			zim.loop(data, function (d) {
			   var s = new zim.Shape().f(d[2]).s(d[3]).ss(d[4]?d[4][0]:null, d[4]?d[4][1]:null, d[4]?d[4][2]:null).p(d[5]);
			   s.setTransform(d[0],d[1]);
			   s.addTo(catIcon);
			}, true);
			var container = new zim.Container();
			catIcon.sca(height/246).addTo(container).mov(0,-.4);
			if (mobile) container.cache();
			container.mouseChildren = false;
			return container;
	    };
	};
	zim.extend(zim.Frame, createjs.EventDispatcher, null, "cjsEventDispatcher", false);

zim.Queue = function() {
		// internal usage only by Frame
		this.cjsEventDispatcher_constructor();
		this.isLoading = true; // thanks Frank Los for the suggestion.
	};
	zim.extend(zim.Queue, createjs.EventDispatcher, null, "cjsEventDispatcher");
	
return zim;
} (zim || {});

function zimify(obj, list) {

if (obj && obj.noDrag) return obj;

}

var ignore;
function zimplify(exclude) {

zim.setBlurDetect = function() {

zim.blurCheck = true;
	zim.pauseAnimateOnBlur = true;
	zim.pauseOnBlur = [];
	zim.blurDetect = (function(){
		var stateKey,
			eventKey,
			keys = {
					hidden: "visibilitychange",
					webkitHidden: "webkitvisibilitychange",
					mozHidden: "mozvisibilitychange",
					msHidden: "msvisibilitychange"
		};
		for (stateKey in keys) {
			if (stateKey in document) {
				eventKey = keys[stateKey];
				break;
			}
		}
		return function(c) {
			if (c) document.addEventListener(eventKey, c);
			return !document[stateKey];
		};
	})();

zim.blurDetect(function(){
		if(zim.blurDetect()){
			setTimeout(function(){		
				
				// coming back from blur into focus so set back animations 	
													
				if (zim.pauseOnBlur) {					
					for (var i=0; i<zim.pauseOnBlur.length; i++) {
						var obj = zim.pauseOnBlur[i];
						if (!obj.pauseOnBlurPaused) obj.pause(false);
					}
				}
				if (zim.pauseAnimateOnBlur && zim.animatedObjects) {	
					for (var i=0; i<zim.animatedObjects.objects.length; i++) {
						var obj = zim.animatedObjects.objects[i];	
						var currentStates = zim.copy(obj.tweenStates);							
						if (!obj.tweenStates) {
							obj.pauseAnimate(false);
						} else if (zot(currentStates.all) || currentStates.all) {	
							obj.pauseAnimate(false);
							for (id in currentStates) {
								if (id=="all") continue;
								if (!currentStates[id]) {
									obj.pauseAnimate(true, id);
								}
							}
						} else {	
							obj.pauseAnimate(true);
							for (id in currentStates) {
								if (id=="all") continue;
								if (currentStates[id]) obj.pauseAnimate(false, id);
							}
						}	
						if (obj.type == "Sprite") obj.paused = true;										
					}
				}
			},300);
		} else {
			
			// going out of focus so set pauses 
			
			if (zim.pauseOnBlur) {
				for (var i=0; i<zim.pauseOnBlur.length; i++) {
					var obj = zim.pauseOnBlur[i];
					obj.pauseOnBlurPaused = obj.paused;
					obj.pause(true);
				}
			}
			if (zim.pauseAnimateOnBlur && zim.animatedObjects) {
				// zim.loop(zim.animatedObjects.objects, function(obj) {
				// 	obj.pauseOnBlurPaused = obj.type=="Sprite"?obj.runPaused:obj.paused; 
				// });
				zim.pauseAnimate(true, "pauseOnBlur");
			}
		}
	});

};
return zim;} (zim || {});
if (!window.zns && window.zimplify) zimplify();

Bearbeitung

Datei öffnen

// ZIM - https://zimjs.com - DISTILLED NON-MINIFIED

zim.extend = function(subclass, superclass, override, prefix, prototype) {
		var sig = "subclass, superclass, override, prefix, prototype";
		var duo; if (duo = zob(zim.extend, arguments, sig)) return duo;
		if (zot(subclass) || zot(superclass)) {
			if (zon && subclass!=zim.StageGL) zogy("zim.extend() - please supply a class and its superclass");
			return;
		}
		// zogr("start")		
		if (zot(prefix)) prefix = "super";
		if (zot(override)) override = [];
		if (!Array.isArray(override)) override = [override];
		if (zot(prototype)) prototype = true;
		// modified CreateJS extend() to include any prototype members already added
		// see https://www.createjs.com/docs/easeljs/classes/Utility%20Methods.html
		var existingP = {};
		for (var f in subclass.prototype) Object.defineProperty(existingP,f,Object.getOwnPropertyDescriptor(subclass.prototype, f));
		function o() {this.constructor = subclass;}
		o.prototype = superclass.prototype;
		subclass.prototype = new o();
		for (f in existingP) {
			Object.defineProperty(subclass.prototype,f,Object.getOwnPropertyDescriptor(existingP,f));
		}

// modified CreateJS promote() to promote methods other than constructor only if methods is true
		// zim does not override with prototypes so it is uneccessary to loop through the super class methods
		// added checking an array of string values of methods defined in class (not prototype) that are being overridden
		var subP = subclass.prototype;
		var supP = (Object.getPrototypeOf&&Object.getPrototypeOf(subP))||subP.__proto__;
		if (supP) {
			subP[(prefix+="_") + "constructor"] = supP.constructor; // constructor is not always innumerable
			var n;
			for (var i=0; i<override.length; i++) {				
				n = override[i];
				if (typeof supP[n] == "function") {
					subP[prefix + n] = supP[n];
				}
			}
			if (prototype) {
				for (n in supP) {
					if (Object.prototype.hasOwnProperty.call(subP, n) && (typeof supP[n] == "function")) {subP[prefix + n] = supP[n];}
				}
			}
		}
		return subclass;
	};
	
zim.orange="#f58e25"; zim.green="#acd241"; zim.pink="#e472c4"; zim.blue="#50c4b7"; zim.brown="#d1a170"; zim.yellow="#ebcb35"; zim.purple="#993399"; zim.red="#fb4758"; zim.silver="#999999"; zim.pewter="#888888"; zim.tin="#777777"; zim.granite="#666666"; zim.grey="#555555"; zim.gray="#555555"; zim.charcoal="#444444"; zim.licorice="#222222"; zim.lighter="#eeeeee"; zim.moon="#dddddd"; zim.light="#cccccc"; zim.mist="#bbbbbb"; zim.fog="#aaaaaa"; zim.dark="#333333"; zim.darker="#111111"; zim.black="#000000"; zim.white="#ffffff"; zim.clear="rgba(0,0,0,0)"; zim.faint="rgba(0,0,0,.01)";
String.prototype.darken = function(a) {return zim.darken(this, a);}; String.prototype.lighten = function(a) {return zim.lighten(this, a);};
zim.TIME="seconds"; zim.TIMECHECK=true; zim.ANIMATE = true; zim.OPTIMIZE = false; zim.ACTIONEVENT = "mousedown"; zim.DEFAULTWIRE = "currentValue"; zim.POSREG = false; zim.DRAGALL = false;
zim.TOP="top"; zim.BOTTOM="bottom"; zim.LEFT="left"; zim.RIGHT="right"; zim.CENTER="center"; zim.MIDDLE="middle"; zim.HORIZONTAL="horizontal"; zim.VERTICAL="vertical"; zim.BOTH="both"; zim.UP="up"; zim.DOWN="down"; zim.AUTO="auto"; zim.DEFAULT="default"; zim.AVE="ave"; zim.DIR="dir"; zim.START="start"; zim.END="end"; zim.NEXT="next"; zim.PREV="prev"; zim.GET="get"; zim.POST="post"; zim.LOCALSTORAGE="localstorage"; zim.SOCKET="socket"; zim.TO="to"; zim.FROM="from";  zim.SINE="sine"; zim.SQUARE="square"; zim.TRIANGLE="triangle"; zim.SAW="saw"; zim.ZAP="zap"
zim.TAU=Math.PI*2; zim.DEG=180/Math.PI; zim.RAD=Math.PI/180; zim.VERSION="019/zim";
zim.distill = function(){zog("zim.Distill() - done - you can remove command")};
function zenable(t,v) {if (v) {t.mouseChildren = true;t.mouseEnabled = true;t._enabled = true;} else {t.mouseChildren = false;t.mouseEnabled = false;t._enabled = false;}}

zim.chop = function(obj, cols, rows, tile, margin, scale) {
		if (zot(obj)) return;
		if (zot(cols)) cols = 3;
		if (zot(rows)) rows = 3;
		if (zot(tile)) tile = true;
		if (zot(margin)) margin = 0;
		if (zot(scale)) scale = 1;	
		// removed in ZIM ZIM 01 patch - causing parts to be same size canvas as original	
		// if (obj.uncache) { // testing if it has a CreateJS uncache method
		// 	obj = obj.cache(null,null,null,null,scale).cacheCanvas;
		// }
		// var w = obj.width/cols;
		// var h = obj.height/rows;
		if (!obj.getBounds) obj = new zim.Bitmap(obj); // added ZIM ZIM 02
		var b = obj.getBounds();
		if (zot(b)) zogy("ZIM chop() - obj must have bounds");
		var w = b.width/cols;
		var h = b.height/rows;
		var m = margin;
		var pieces = [];
		zim.loop(rows, function (r) {
			zim.loop(cols, function (c) {		
				var p = new zim.Bitmap(obj, w+m*2, h+m*2, c*w-m, r*h-m, scale);
				if (margin != 0) {
					p.setBounds(m,m,w,h);
					p.regX = m;
					p.regY = m;
				} else {
					p.setBounds(m,m,w,h);
				}
				pieces.push(p);
			});
		});
		if (tile) return new zim.Tile(pieces,cols,rows,0,0,true).sca(obj.scaleX,obj.scaleY);
		else return pieces;
	};

zim.shuffle = function(array, different) {
		if (zot(array)) return;
		if (!Array.isArray(array)) array = Object.values(arguments);
		var i = array.length, j, temp;
		if (i <= 1) return array;
		if (different) {
			var sur = {};
			var arr = [];
			for (var i=0; i<array.length; i++) {
				sur[i] = array[i];
				arr.push(i);
			}
			var original = zim.copy(arr);
			zim.shuffle(arr);
			while (zim.arraysEqual(original, arr)) {
				zim.shuffle(arr);
			} 
			for (i=0; i<arr.length; i++) {
				array[i] = sur[arr[i]];
			}
			return array;
		} else {
			while(--i) {
				j = Math.floor(Math.random()*(i+1));
				temp=array[i];
				array[i]=array[j];
				array[j]=temp;
			}
			return array;
		}
	};

zim.rand = function(a, b, integer, negative) {
		
		if (zot(a) && zot(b)) return Math.random();
		if (zot(a) || isNaN(a)) a = 0;
		if (zot(b) || isNaN(b)) b = 0;
		if (a%1!=0 || b%1!=0) integer = false;
		if (zot(integer)) integer = true;
		if (negative) if (Math.random()>.5) {a*=-1; b*=-1;}
		if (integer) if (a>b) {a++;} else if (b>a) {b++;}
		var r;
		if (a == 0 && b == 0) return 0;
		else if (b == 0) r = Math.random()*a;
		else r = Math.min(a,b) + Math.random()*(Math.max(a,b)-Math.min(a,b));
		if (integer) return Math.floor(r);
		else return r;
	};

zim.timeout = function(time, call, pauseOnBlur, timeUnit) {
		var sig = "time, call, pauseOnBlur, timeUnit";
		var duo; if (duo = zob(zim.timeout, arguments, sig, this)) return duo;
		if (zot(call)) return;
		if (typeof call != 'function') return;
		var o = zim.interval(time, call, 1, false, pauseOnBlur, timeUnit, null, null, true);
		o.type = "timeoutObj";
		return o;
	};

zim.interval = function(time, call, total, immediate, pauseOnBlur, timeUnit, complete, completeParams, timeout, mID, tether) {
		var sig = "time, call, total, immediate, pauseOnBlur, timeUnit, complete, completeParams, timeout, mID, tether";
		var duo; if (duo = zob(zim.interval, arguments, sig, this)) return duo;
		if (zot(call)) return;
		if (typeof call != 'function') return;
		
		var timeType = getTIME(time, timeUnit);
		if (zot(time)) time = timeType=="s"?1:1000;

if (!timeout) {
			var initialT = total;
			var tag = zim.makeID();

}

if (zot(immediate)) immediate = false;
		if (!zot(total) && (isNaN(total) || total<=0)) return;
		if (zot(total)) total = -1;
		var obj = {count:(immediate && (!isPick(time) && time <= (timeType=="s"?5/1000:5))) ? -1:0, total:total, paused:false, time:time, active:true, timeUnit:timeUnit};

if (pauseOnBlur) {
			if (zot(zim.blurCheck)) zim.setBlurDetect();
			zim.pauseOnBlur.push(obj);
		}
		function interval() {
			obj.startTime = Date.now();
			obj.interval = zim.Pick.choose(obj.time);
			obj.id = setTimeout(function() {
				if (obj.paused) return;
				if (!obj.active) return;
				// obj.rid = requestAnimationFrame(interval);
				obj.count++;
				(call)(obj);
				interval();
				checkTotal();
			}, obj.interval*(timeType=="s"?1000:1));
		}
		if (immediate && (isPick(time) || time > (timeType=="s"?5/1000:5))) {
			setTimeout(function() {
				(call)(obj);
				checkTotal();
			}, 5);
		}
		function checkTotal() {
			if (total == -1) return;
			if (obj.count >= (immediate?obj.total-1:obj.total)) {
				if (complete && typeof complete=="function") complete(completeParams);
				obj.clear();
			}
		}
		var pausedTimeout;
		obj.type = "intervalObject";
		obj.pause = function(state, immediate, reset) {
			if (zot(state)) state = true;
			if (state) { // pausing
				clearTimeout(pausedTimeout);
				clearTimeout(obj.id);
				cancelAnimationFrame(obj.rid);
				obj.pauseTimeLeft = obj.interval-(Date.now()-obj.startTime)/(timeType=="s"?1000:1);

} else { // unpausing
				if (!obj.paused) obj.pause(true);
				pausedTimeout = setTimeout(function() {
					obj.count++;
					(call)(obj);
					interval();
					checkTotal();					
				}, immediate?0:(reset?obj.interval:obj.pauseTimeLeft)*(timeType=="s"?1000:1));
				obj.pauseTimeLeft = null;

}
			obj.paused = state;
		};
		obj.next = function() {
			obj.count++;				
			(call)(obj);	
			checkTotal();
		};
		obj.clear = function() {
			obj.active = false;
			clearTimeout(pausedTimeout);
			cancelAnimationFrame(obj.rid);
			clearTimeout(obj.id);
			var count = obj.count;
			for (var i in obj) {
				delete obj[i];
			}
			obj.active = false;
			obj.count = count;
			obj.pause = function() {};
			obj.clear = function() {};

};
		interval();
		return obj;
	};

zim.copy = function(obj, clone, cloneContainer) {
		if (zot(clone)) clone = false;
		if (zot(cloneContainer)) cloneContainer = true;
		if (obj==null || !(obj instanceof Array || obj.constructor == {}.constructor)) return clone&&obj!=null?(obj.clone?(obj.type&&((obj.type!="Container"&&obj.type!="Stage"&&obj.type!="StageGL")||cloneContainer)?obj.clone():obj):obj):obj;
		if (obj instanceof Array) {
			var array = [];
			for (var i=0; i<obj.length; i++) {
				array[i] = zim.copy(obj[i], clone, cloneContainer);
			}
			return array;
		}
		if (obj.constructor == {}.constructor) {
			var copy = {};
			for (var attr in obj) {
				var answer = zim.copy(obj[attr], clone, cloneContainer);
				if (Object.prototype.hasOwnProperty.call(obj, attr)) copy[attr] = answer;
			}
			return copy;
		}
	};

zim.isEmpty = function(obj) {
		if (zot(obj)) return;
		var count = 0;
		for (var o in obj) {
			count++; break;
		}
		return (count == 0);
	};

zim.isPick = function(obj) {
		if(zot(obj)) return;
		return (Array.isArray(obj)||(obj.constructor=={}.constructor && ((obj.min!=null && obj.max!=null) || obj.noPick))||(obj.constructor === Function && (obj.array!=null || obj()!=null))); // obj.array is a series
	};

zim.merge = function() {
		var obj = {}; var i; var j;
		for (i=0; i<arguments.length; i++) {
			for (j in arguments[i]) {
				if (Object.prototype.hasOwnProperty.call(arguments[i], j)) {
					obj[j] = arguments[i][j];
				}
			}
		}
		return obj;
	};

zim.zut = function(e) {
		if (zot(e) || typeof e == "object") return true;
	};
	zim.decimals = function(num, places, addZeros, addZerosBefore, includeZero, time, evt) {
		if (zot(num)) return 0;
		if (zot(places)) places = 1;
		if (zot(addZeros)) addZeros = 0;
		if (zot(addZerosBefore)) addZerosBefore = 1;
		if (zot(includeZero)) includeZero = true;
		if (zot(time)) time = false;
		// if (addZeros && places < 0) {
		// 	var place = String(num).indexOf(".");
		// 	var length = String(num).length;
		// 	var left = (place < 0) ? length : place;
		// 	for (var i=0; i<-places-left; i++) {num = "0" + num;}
		// 	return num;
		// }
		var answer = Math.round(num*Math.pow(10, places))/Math.pow(10, places);		
		if (time) {
			var secs = answer - Math.floor(answer);
			answer = zim.decimals(Math.floor(answer) + secs*60/100, 2);
		}
	
		// if (addZeros && places > 0 && answer != 0) {
		// 	var place = String(answer).indexOf(".");
		// 	var length = String(answer).length;
		// 	if (place < 0) {place = length++; answer+=".";}
		// 	for (var i=0; i<places-(length-place-1); i++) {answer += "0";}
		// }
		var sign = zim.sign(answer);
		var place,length,i;
		if (addZeros > 0) {
			place = String(answer).indexOf(".");
			length = String(answer).length;
			if (place < 0) {place = length++; answer+=".";}
			for (i=0; i<addZeros-(length-place-1); i++) {answer += "0";}
		}
		if (addZerosBefore > 1) {
			// fix this - Dan Zen - negative decimal number problem
			if (sign == -1) answer = answer.substr(1,answer.length-1);
			place = String(answer).indexOf(".");
			length = String(answer).length;
			var left = (place < 0) ? length : place;
			for (i=0; i<addZerosBefore-left; i++) {answer = "0" + answer;}
			if (sign == -1) answer = "-" + answer;
		}
		if (addZerosBefore == 0) answer = answer.toString().replace(/^0\./,".");
		if ((addZeros + addZerosBefore > 0) && !includeZero && Number(answer) == 0) answer = 0;
		if (time) answer = String(answer).replace(".", ":");
		
		return zim.zut(evt) ? answer : null;
	};

zim.sign = function(num) {
		return num?num<0?-1:1:0;
	};

zim.angle = function(a, b, c, d) {
		if (zot(a) || zot(b)) return;
		if (!zot(a.x)) {
			if (zot(b)) {
				a = 0;
				b = 0;
				c = a.x;
				d = a.y;
			} else {
				d = b.y;
				c = b.x;
				b = a.y;
				a = a.x;
			}
		} else {
			if (zot(c)) {c = a; a = 0;}
			if (zot(d)) {d = b; b = 0;}
		}		
		return (Math.atan2(d-b, c-a)*180/Math.PI+360)%360;
	};

if (typeof createjs != "undefined") {
		zim.Point = function(x, y, z, q, r, s, t, u, v, w) {
			if (zot(x)) x = 0;
			if (zot(y)) y = 0;
			if (zot(z)) z = 0;
			if (zot(q)) q = 0;
			if (zot(r)) r = 0;
			if (zot(s)) s = 0;
			if (zot(t)) t = 0;
			if (zot(u)) u = 0;
			if (zot(v)) v = 0;
			if (zot(w)) w = 0;
			this.createjsPoint_constructor(x,y);
			this.type = "Point";
			this.x = x;
			this.y = y;
			this.z = z;
			this.q = q;
			this.r = r;
			this.s = s;
			this.t = t;
			this.u = u;
			this.v = v;
			this.w = w;
			this.angle = function(point) {
				return this.createjsPoint_angle(point)*180/Math.PI;
			}
			this.project = function(angle, length) {
				return this.createjsPoint_project(angle*Math.PI/180, length);
			}
		};
		zim.extend(zim.Point, createjs.Point, ["angle","project"], "createjsPoint");
	}

zim.Boundary = function(x, y, width, height) {
		if (!zot(x.x)) { // a rectangle or getBounds() is provided
			height = x.height;
			width = x.width;
			y = x.y;
			x = x.x;
		}
		if (zot(x) || zot(y) || zot(width) || zot(height)) return;
		this.x = x;
		this.y = y;
		this.width = width;
		this.height = height;

this.contract = function(a,b,c,d) {
			if (zot(a)) return this;
			if (zot(b)) b = a;
			if (zot(c)) {
				c = a*2;
			} else {
				c = c+a;
			}
			if (zot(d)) {
				d = b*2;
			} else {
				d = d+b;
			}
			this.x += a;
			this.y += b;
			this.width -= c;
			this.height -= d;
			return this;
		};
	};

zim.RadialColor = function(colors,ratios, x0,y0,r0, x1,y1,r1) {
		this.type = "RadialColor";
		this.colors = zot(colors)?["black","white"]:colors;
		if (!Array.isArray(this.colors)) this.colors = [this.colors, this.colors];
		if (this.colors.length==1) this.colors.push(this.colors[0]); // at least two colors
		this.ratios = ratios;
		if (!Array.isArray(this.ratios)) {
			this.ratios = [];
			for (var i=0; i<this.colors.length; i++) {
				this.ratios.push(i/(this.colors.length-1))
			}
		}
		this.x0 = x0;
		this.y0 = y0;
		this.r0 = r0;
		this.x1 = x1;
		this.y1 = y1;
		this.r1 = r1;
	};

zim.Bezier = function Bezier(a, b, c, d) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;

this.len = 100;
        this.arcLengths = new Array(this.len + 1);
        this.arcLengths[0] = 0;

} else {
                    high = index;
                }
            }
            if (this.arcLengths[index] > targetLength) {
                index--;
            }

var lengthBefore = this.arcLengths[index];
            if (lengthBefore === targetLength) {
                return index / this.len;

} else {
                return (index + (targetLength - lengthBefore) / (this.arcLengths[index + 1] - lengthBefore)) / this.len;
            }
        },

mx: function (u) {
            return this.x(this.map(u));
        },

my: function (u) {
            return this.y(this.map(u));
        },

zim.series = function() {
		var array;
		var range;

if (arguments[0] == null) return null;
		if (arguments.length == 0) return function(){};
		if (arguments.length == 1 && Array.isArray(arguments[0])) {
			array = arguments[0];
		} else if (arguments.length == 1 && arguments[0].constructor == {}.constructor) {			
			range = arguments[0];
			if (zot(range.min)) range.min = 0;
			if (zot(range.max)) range.max = 1;
			if (zot(range.step)) range.step = 1;
			array = [];
			zim.loop(Math.floor(Math.abs(range.max-range.min)+range.step), function (i) {
				array.push(i+range.min);
			}, null, null, range.step);
			range = null;
		} else {
			array = Array.prototype.slice.call(arguments);
		}
        var count = 0;
		var dir = 1;
		var step = 1;
		var every = 0;
		var everyCount = 0;
		var bounce = false;
		var flip = false;
		var constrain = false;
		var randomize = false;
		var mix = false;
		var firstVal;
		var lastVal;

zim.Dictionary = function(unique) {
		this.length = 0;
		this.unique = unique;
		var objects = this.objects = []; // store objects and values in synched arrays
		var values = this.values = [];
		this.type = "Dictionary";

// MONITOR		
		this.mID = "z~"+this.type;

this.add = function(o,v) {
			if (zot(o)) return;
			if (zot(v)) v = true;
			if (this.unique) this.remove(o);
			objects.push(o);
			values.push(v);
			this.length++;
		};

this.at = function(o) {
			if (zot(o)) return;
			var i = objects.indexOf(o);
			if (i > -1) return values[i];
			return null;
		};

this.clear = function() {
			objects = this.objects = []; // store objects and values in synched arrays
			values = this.values = [];
			this.length = null;
			return this;
		};

this.dispose = function() {
			objects = null;
			values = null;
			this.length = null;
			return true;
		};
	};

zim.Pick = function(choices) {
        this.choices = choices;
        this.num = function(num) {
            var s = [];
            for (var i=0; i<num; i++) {s.push(zim.Pick.choose(this));}
            this.choices = zim.Pick.series(s);
            return this;
        };
        var that = this;
        this.loop = function(num, call) {
            var r;
            for (var i=0; i<num; i++) {
                r = call(zim.Pick.choose(that), i, num);
                if (typeof r != 'undefined') return r;
            }
         };
    };
    zim.Pick.prototype.type = "Pick";
    zim.Pick.series = function() {
		// see https://github.com/danzen/Pick for all inclusive class to use in other libraries / languages, etc.
		return zim.series.apply(null, arguments);
    };
    zim.Pick.rand = function(a, b, integer, negative) {
		// see https://github.com/danzen/Pick for all inclusive class to use in other libraries / languages, etc.
		return zim.rand(a, b, integer, negative);
    };
    zim.Pick.choose = function(obj, literal, target) {
        if (literal == null) literal = true;
		if (obj==null) return obj;
        if (obj.type=="Pick" || literal) {
            var c = obj.choices || obj;
			var val;
            if (Array.isArray(c)) {
                val = c[Math.floor(Math.random()*(c.length))];
                return zim.Pick.choose(val); // recursive
            } else if (c.constructor === {}.constructor) {
                if (!zot(c.noPick)) return c.noPick; // a passthrough for arrays and functions
                if (zot(c.max)) return c;
                if (zot(c.integer)) c.integer = false;
                val = zim.Pick.rand(c.min, c.max, c.integer, c.negative);
                return val; // this is just a number in a range - no need for recursive
            } else if (c instanceof Function) {
				if (c.count==null) c.count=0;
				else c.count++;
                return zim.Pick.choose((c)(target, true)); // recursive
            }	
            return obj;
        } else {	
            return obj;
        }		
	};
	zim.Pick.getMinMax = function(vee) {
		if (!zot(vee.min) && !zot(vee.max)) return vee;				
		if (Array.isArray(vee)) {
			return zim.arrayMinMax(vee);
		}
		if (vee.type == "series") {
			return zim.arrayMinMax(vee.array);
		}
		else return {min:null, max:null}
	};

zim.abstractScroll = function(dir, side, num, time) {
		var timeType = getTIME(time);
		var perpend = (dir == "X") ? "Y" : "X"; // perpendicular direction
		if (zot(num)) {			
			return (document.documentElement && document.documentElement["scroll"+side]) || document.body["scroll"+side];
		} else if (zot(time)) {
			WW.scrollTo(zim["browserScroll"+perpend](), num);
		} else {
			var interval = 50;
			var t = time*(timeType=="s"?1000:1);
			if (t < interval) t = interval;
			var steps = t/interval;
			var current = zim["browserScroll"+dir]();
			var amount = num - current;
			var diff = amount/steps;
			var count = 0;
			var scrollInterval = setInterval(function() {
				count++;
				current+=diff;
				WW.scrollTo(zim["browserScroll"+perpend](), current);
				if (count >= steps) {
					WW.scrollTo(zim["browserScroll"+perpend](), num);
					clearInterval(scrollInterval);
				}
			}, interval);
		}
		return num;
	};

zim.windowWidth = function() {
		var w = isNaN(WW.innerWidth) ? WW.clientWidth : WW.innerWidth;
		var h = isNaN(WW.innerHeight) ? WW.clientHeight : WW.innerHeight;
		if (zim.mobile() && !zot(WW.orientation) && !WW.parent) {
			if ((w > h && Math.abs(WW.orientation) != 90) || h > w && Math.abs(WW.orientation) == 90) {
				var oldW = w;
				w = h;
				h = oldW;
			}
		}
		// 6. part of TEN PATCH
		// pay attention to swapRotation from Frame
		return (WW.zdf && WW.zdf.swapRotation)?h:w;
	};

zim.windowHeight = function() {
		var w = isNaN(WW.innerWidth) ? WW.clientWidth : WW.innerWidth;
		var h = isNaN(WW.innerHeight) ? WW.clientHeight : WW.innerHeight;
		if (zim.mobile() && !zot(WW.orientation) && !WW.parent) {
			if ((w > h && Math.abs(WW.orientation) != 90) || h > w && Math.abs(WW.orientation) == 90) {
				var oldW = w;
				w = h;
				h = oldW;
			}
		}
		// 7. part of TEN PATCH
		// pay attention to swapRotation from Frame
		return (WW.zdf && WW.zdf.swapRotation)?w:h;
	};

zim.convertColor = function(color, toColorType, alpha) {
		if (zot(toColorType)) toColorType = "hex";
		color = zik(color);
        if (typeof color == "number") color = "#" + color.toString(16);
		if (zot(color) || !color.toLowerCase) return;        
		color = color.toLowerCase();
		toColorType = toColorType.toLowerCase();
		var colors = ['black','aliceblue','antiquewhite','aqua','aquamarine','azure','beige','bisque','blanchedalmond','blue','blueviolet','brown','burlywood','cadetblue','chartreuse','chocolate','coral','cornflowerblue','cornsilk','crimson','cyan','darkblue','darkcyan','darkgoldenrod','darkgray','darkgrey','darkgreen','darkkhaki','darkmagenta','darkolivegreen','darkorange','darkorchid','darkred','darksalmon','darkseagreen','darkslateblue','darkslategray','darkslategrey','darkturquoise','darkviolet','deeppink','deepskyblue','dimgray','dimgrey','dodgerblue','firebrick','floralwhite','forestgreen','fuchsia','gainsboro','ghostwhite','gold','goldenrod','gray','grey','green','greenyellow','honeydew','hotpink','indianred','indigo','ivory','khaki','lavender','lavenderblush','lawngreen','lemonchiffon','lightblue','lightcoral','lightcyan','lightgoldenrodyellow','lightgray','lightgrey','lightgreen','lightpink','lightsalmon','lightseagreen','lightskyblue','lightslategray','lightslategrey','lightsteelblue','lightyellow','lime','limegreen','linen','magenta','maroon','mediumaquamarine','mediumblue','mediumorchid','mediumpurple','mediumseagreen','mediumslateblue','mediumspringgreen','mediumturquoise','mediumvioletred','midnightblue','mintcream','mistyrose','moccasin','navajowhite','navy','oldlace','olive','olivedrab','orange','orangered','orchid','palegoldenrod','palegreen','paleturquoise','palevioletred','papayawhip','peachpuff','peru','pink','plum','powderblue','purple','rebeccapurple','red','rosybrown','royalblue','saddlebrown','salmon','sandybrown','seagreen','seashell','sienna','silver','skyblue','slateblue','slategray','slategrey','snow','springgreen','steelblue','tan','teal','thistle','tomato','turquoise','violet','wheat','white','whitesmoke','yellow','yellowgreen'];
		var hex = ['000000','f0f8ff','faebd7','00ffff','7fffd4','f0ffff','f5f5dc','ffe4c4','ffebcd','0000ff','8a2be2','a52a2a','deb887','5f9ea0','7fff00','d2691e','ff7f50','6495ed','fff8dc','dc143c','00ffff','00008b','008b8b','b8860b','a9a9a9','a9a9a9','006400','bdb76b','8b008b','556b2f','ff8c00','9932cc','8b0000','e9967a','8fbc8f','483d8b','2f4f4f','2f4f4f','00ced1','9400d3','ff1493','00bfff','696969','696969','1e90ff','b22222','fffaf0','228b22','ff00ff','dcdcdc','f8f8ff','ffd700','daa520','808080','808080','008000','adff2f','f0fff0','ff69b4','cd5c5c','4b0082','fffff0','f0e68c','e6e6fa','fff0f5','7cfc00','fffacd','add8e6','f08080','e0ffff','fafad2','d3d3d3','d3d3d3','90ee90','ffb6c1','ffa07a','20b2aa','87cefa','778899','778899','b0c4de','ffffe0','00ff00','32cd32','faf0e6','ff00ff','800000','66cdaa','0000cd','ba55d3','9370db','3cb371','7b68ee','00fa9a','48d1cc','c71585','191970','f5fffa','ffe4e1','ffe4b5','ffdead','000080','fdf5e6','808000','6b8e23','ffa500','ff4500','da70d6','eee8aa','98fb98','afeeee','db7093','ffefd5','ffdab9','cd853f','ffc0cb','dda0dd','b0e0e6','800080','663399','ff0000','bc8f8f','4169e1','8b4513','fa8072','f4a460','2e8b57','fff5ee','a0522d','c0c0c0','87ceeb','6a5acd','708090','708090','fffafa','00ff7f','4682b4','d2b48c','008080','d8bfd8','ff6347','40e0d0','ee82ee','f5deb3','ffffff','f5f5f5','ffff00','9acd32'];

if (toColorType == "zim") {
			var i = zim.colorsHex.indexOf(color);
			if (i<0) return color;
			return zim.colors[zim.colorsHex.indexOf(color)];
		}		
		if (toColorType == "hsv") toColorType == "hsl";
				
		var answer;
		var c;
		if (answer = color.match(/rgba$(.*)$/)) {	
			c = answer[1].split(",");
			var a = c.pop(); // take off alpha
			if (zot(alpha)) alpha = a; // use alpha otherwise parameter overrides
			if (toColorType=="array") {
				c.push(a);
				return c;
			}				
			color = "rgb("+c.join(",")+")";			
			if (toColorType=="rgb") return color;	
			if (toColorType == "hsl") {
				return rgbToHsl(c[0], c[1], c[2]);
			}	
		}
		
			
		function rgbToHex(rgb) {
			var hex = Number(rgb).toString(16);
			if (hex.length < 2) {
				hex = "0" + hex;
			}
			return hex;
		}
		
		// https://gist.github.com/mjackson/5311256 comment by gntlechaos
		function mapMinMax(value,oldMin,oldMax,newMin, newMax) {
			return  (newMax-newMin)*(value-oldMin)/(oldMax-oldMin)+newMin;
		}		
		function rgbToHsl(r, g, b) {
			r /= 255;
			g /= 255;
			b /= 255;
			const l = Math.max(r, g, b);
			const s = l - Math.min(r, g, b);
			const h = s
				? l === r
				? (g - b) / s
				: l === g
				? 2 + (b - r) / s
				: 4 + (r - g) / s
				: 0;
			return [
				60 * h < 0 ? 60 * h + 360 : 60 * h,
				100 * (s ? (l <= 0.5 ? s / (2 * l - s) : s / (2 - (2 * l - s))) : 0),
				(100 * (2 * l - s)) / 2
			];
		}

function getRGB(string) {
			var c = string.split(",");
			var red = rgbToHex(c[0]);
			var green = rgbToHex(c[1]);
			var blue = rgbToHex(c[2]);
			var alpha = zot(alpha)?"":rgbToHex(Math.round(Number(c[3])*255));
			return [red, green, blue, alpha];
		}

if (zot(alpha)) alpha = 1;
		var added;
		var co;
		var index;
		if (answer = color.match(/rgb$(.*)$/)) {
			if (toColorType == "rgba") {
				return "rgba("+answer[1]+","+alpha+")";
			} else if (toColorType == "hex") {	
				added = alpha != 1?","+alpha:"";
				co = getRGB(answer[1]+added);
				return "#" + co[0] + co[1] + co[2] + co[3];
			} else if (toColorType == "hexnumber") {
				added = alpha != 1?","+alpha:0;
				co = getRGB(answer[1]+added);
				return parseInt(co[0]+""+co[1]+""+co[2], 16);
			} else if (toColorType == "hexstring") {
				added = alpha != 1?","+alpha:0;
				co = getRGB(answer[1]+added);
				return "0xff"+co[0]+""+co[1]+""+co[2];
			} else if (toColorType == "string") {
				color = getRGB(answer[1]).join("").toLowerCase();
				index = hex.indexOf(color);
				if (index == -1) return "#" + color;
				else return colors[index];
			} else if (toColorType == "array") {
				added = alpha != 1?","+alpha:0;
				return getRGB(answer[1]+added);
			} else if (toColorType == "hsl") {
				c = answer[1].split(",");
				return rgbToHsl(c[0], c[1], c[2]);
			} else return color;
		}

zim.colorRange = function(color1, color2, ratio) {
		// thanks Chris Dolphin - StackOverflow
		// modified by Dan Zen to use hex input and output
		// possibly converting and converting back - but not quite...
		if (zot(ratio)) ratio = .5;
		ratio = Math.max(0, Math.min(1, ratio));
		if (zot(color1)) color1 = "white";
		if (zot(color2)) color2 = "black";
		color1 = zik(color1);
		color2 = zik(color2);
		var color1O = color1;
		var color2O = color2;
		var c1 = zim.convertColor(color1, "rgb");
		var c2 = zim.convertColor(color2, "rgb");		
		color1 = c1.substring(4, c1.length - 1).split(',');
		color2 = c2.substring(4, c2.length - 1).split(',');
		var difference;
		var newColor = "#";
		var c;
		if (ratio==0) {
			newColor = color1O;
		} else if (ratio==1) {
			newColor = color2O;
		} else {
			for (var i=0; i<color1.length; i++) {
				difference = color2[i] - color1[i];
				c = Math.floor(parseInt(color1[i], 10) + difference * ratio).toString(16);
				if (c.length < 2) c = "0"+c;
				newColor += c;
			}
		}
		return newColor;
	};

zim.toAlpha = function(color, ratio) {
		if (zot(ratio)) ratio = .5;
		return zim.convertColor(String(color), "rgba", ratio);
	};

zim.pointAlongCurve = function(points, ratio, getAngle, even) {
	if (!points || !points[0] || !points[1] || !points[2] || !points[3]) return;

if (zot(even)) even = false;
	var cubic = new zim.Bezier(points[0],points[1],points[2],points[3]);
	var x,y,x0,y0,x2,y2;
	if (even) {
		x=cubic.mx(ratio);
		y=cubic.my(ratio);
	} else {
		x=cubic.x(ratio);
		y=cubic.y(ratio);
	}
	if (getAngle) {
		var lastRatio = ratio-.05;
		var nextRatio = ratio+.05;
		if (lastRatio < 0) lastRatio = 0;
		if (nextRatio > 1) nextRatio = 1;
		if (even) {
			x0=cubic.mx(lastRatio);
			y0=cubic.my(lastRatio);
			x2=cubic.mx(nextRatio);
			y2=cubic.my(nextRatio);
		} else {
			x0=cubic.x(lastRatio);
			y0=cubic.y(lastRatio);
			x2=cubic.x(nextRatio);
			y2=cubic.y(nextRatio);
		}
		var angle = zim.angle(x0, y0, x2, y2);
		return({x:x,y:y,angle:angle});
	}
	return({x:x,y:y});
};

zim.closestPointAlongCurve = function(point, segmentPoints, num, interpolate, percentage) {
		var closest = 10000000;
		var closestTestPoint;
		var index = 0;
		var secondaryIndex = 0;
		if (zot(num)) num = 10;
		var totalD = 0;
		var totals = [];
		var lastDist=0;
		zim.loop(segmentPoints, function(points, i) {
			// add num more points to estimate closest
			var dist = zim.distanceAlongCurve(points);
			totalD += dist;	
			var cubic = new zim.Bezier(points[0],points[1],points[2],points[3]);
			zim.loop(num, function (j, total) {
				// var d = zim.dist(point, zim.pointAlongCurve(segmentPoints(that.points[i], that.points[i<t-1?i+1:0]), j/10));
				// var testPoint = zim.pointAlongCurve(points, j/total);
				// var d = zim.dist(point, testPoint);
				totals.push(lastDist+dist*j/total);
				// if (even) var testPoint = {x:cubic.mx(j/total), y:cubic.my(j/total)};
				var testPoint = {x:cubic.x(j/total), y:cubic.y(j/total)};				
				var d = zim.dist(point, testPoint);
				if (d < closest) {
					closest = d;
					closestTestPoint = testPoint;
					index = i;
					secondaryIndex = j;
				}
			});
			lastDist = totalD;
		});
		if (percentage) {
			return (totals[index*num+secondaryIndex]||0)/totalD*100;
			// return (index*num+secondaryIndex)/(segmentPoints.length*num)*100;
		} else if (interpolate) {
			return closestTestPoint;
		}
		return index;

};

zim.mobile = function(orientation) {
		if (!zot(WW.MOBILE) && WW.MOBILE!="default") return WW.MOBILE;
		if (!zot(zim.MOBILE) && zim.MOBILE!="default") return zim.MOBILE;
		if (zot(orientation)) orientation = true;
		if (/ip(hone|od|ad)/i.test(navigator.userAgent)) return "ios";
		if (/android|nexus/i.test(navigator.userAgent)) return "android";
		if (/blackberry/i.test(navigator.userAgent)) return "blackberry";
		if (/nokia|phone|mobile/i.test(navigator.userAgent)) return "windows";
		if (/opera mini|webos/i.test(navigator.userAgent)) return "other";
		if (orientation && WW.orientation !== undefined) {
			if (/safari/i.test(navigator.userAgent)) return "ios";
			return true;
		}
		return false;
	};

zim.Ticker = {
		stages:null,
		myUpdate: null,
		alwaysList:new zim.Dictionary(),
		list:new zim.Dictionary(),
		wire:new zim.Dictionary(),
		setFPS: function(m, d) {
			if (zot(m) && zot(d)) {
				m = 60; d = 60;
			} else if (zot(m)) {
				m = 60;
			} else if (zot(d)) {
				d = m;
			}
			zim.Ticker.framerate = createjs.Ticker.framerate = (zim.mobile()) ? m : d;
		},
		setTimingMode: function(mode) {
			createjs.Ticker.timingMode = createjs.Ticker.RAF;
			if (mode == "synched") createjs.Ticker.timingMode = createjs.Ticker.RAF_SYNCHED;
			if (mode == "timeout") createjs.Ticker.timingMode = createjs.Ticker.TIMEOUT;
		},
		add: function(f, s, mID, tether) { // function, stage
			var t = zim.Ticker;
			if (t.has(f, s)) return f; // don't let the same function be added twice
			if (zot(s) || !s.update) s = WW.zdf.stage;
			if (zot(f) || typeof f !== 'function') {zogy("zim.Ticker.add() - only add functions"); return;}
			f.zT = zim.makeID();
			if (t.list.at(s)) {t.list.at(s).push(f);} else {t.list.add(s, [f]);}
			if (!t.ticker) t.ticker = createjs.Ticker.on("tick", t.call, null, null, null, null, mID?mID:"z~Ticker");
			if (!t.framerate) t.setFPS();

return f;
		},
		addWire: function (obj, data, mID) {
			if (zot(data[0])) return obj;
			var t = zim.Ticker;
			obj.zT = zim.makeID();
			t.wire.add(obj, data);
			// data = [target-0, prop-1, twoWay-2, setSource-3, filter-4, call-5, input-6, lastValue-7]
			// if wanting to set the source equal to the target value to start...
			var current = data[0][data[1]];
			if (data[4]) current = data[4](current, "from");
			if (data[3]) obj[data[6]] = data[7] = current;
			if (!t.ticker) t.ticker = createjs.Ticker.on("tick", t.call, null, null, null, null, mID?mID:"z~wire");
			if (!t.framerate) t.setFPS();

return obj;
		},
		rawID:{},
		raw: function(f, mID, tether) {
			var id = zim.makeID("letters", 7);
			-function raw(t) {f(t); zim.Ticker.rawID[id] = requestAnimationFrame(raw);}();

return id;
		},
		removeRaw: function(id, mID, tether) {
			cancelAnimationFrame(zim.Ticker.rawID[id]);

delete zim.Ticker.rawID[id];
		},
		call: function(e) {
			var t = zim.Ticker;
			var s, functions, i;
			var stages = []; // list of stages to update
			for (i=0; i<t.list.length; i++) {
				s = t.list.objects[i]; // stage
				functions = t.list.values[i]; // list of functions for the stage
				for (var j=0; j<functions.length; j++) {
					functions[j](e);
				}
				var u = false;
				if (t.alwaysList.at(s)) {
					u=true;
				} else if (functions.length > 0) {
					if (zot(t.update) && (!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE))) {
						u=true;
					} else if (t.update) {
						u=true;
					}
				}
				if (u && stages.indexOf(s) < 0) {
					stages.push(s);
				}
			}

// check for wire
			// data = [target-0, prop-1, twoWay-2, setSource-3, filter-4, call-5, input-6, lastValue-7]
			for (i=t.wire.length-1; i>=0; i--) {
				var obj = t.wire.objects[i]; // object
				var data = t.wire.values[i]; // data
				if (data) {
					var current = obj[data[6]];
					if (current != data[7]) {
						if (data[4]) current = data[4](current, "to", data[7]);
						data[0][data[1]] = data[7] = current;
						if (data[5]) data[5](current);
						s = data[0].stage;
						if (s && stages.indexOf(s) < 0) stages.push(s);
					}
					if (data[2] && data[0]) { // twoWay
						current = data[0][data[1]];
						// zog(data[7], current)
						if (data[7] != current) {
							if (data[4]) current = data[4](current, "from", data[7]);
							obj[data[6]] = data[7] = current;
							if (data[5]) data[5](current);
							s = obj.stage;
							if (s && stages.indexOf(s) < 0) stages.push(s);
						}
					}
				}
			}

// may have no functions to run but always is turned on
			if (t.list.length == 0) {
				for (i=0; i<t.alwaysList.length; i++) {
					s = t.alwaysList.objects[i]; // stage
					if (stages.indexOf(s) < 0) stages.push(s);
				}
			}
			var l = stages.length;
			for (i=0; i<l; i++) {
				stages[i].update();
			}
		},
		always: function(s, mID, tether) {
			var t = zim.Ticker;
			if (!t.framerate) t.setFPS();
			if (zot(s) || !s.update) s = WW.zdf.stage;
			t.alwaysList.add(s, true);
			if (!t.ticker) t.ticker = createjs.Ticker.on("tick", t.call, null, null, null, null, mID?mID:"z~Ticker");

},
		alwaysOff: function(s, mID, tether) {
			var t = zim.Ticker;
			if (zot(s) || !s.update) s = WW.zdf.stage;
			t.alwaysList.remove(s);

},
		remove: function(f, mID, tether) {
			var t = zim.Ticker;
			if (zot(f) || typeof f !== 'function') {zogy("zim.Ticker - only remove functions"); return;}
			for (var i=0; i<t.list.length; i++) {
				var index = t.list.values[i].indexOf(f);
				if (index > -1) {
					t.list.values[i].splice(index,1);
				}
			}

if (t.alwaysList.length > 0 || t.list.length > 0 || t.wire.length > 0) return;
			createjs.Ticker.off("tick", t.ticker, null, mID?mID:"z~Ticker");			
			t.ticker = null;
		},
		removeAll: function(s, mID, tether) { // functions only - not wire
			var t = zim.Ticker;
			var st;
			for (var i=0; i<t.list.length; i++) {
				st = t.list.objects[i]; // stage
				if (zot(s) || s === st) {
					t.list.values[i] = [];
				}
			}
			if (t.alwaysList.length > 0 || t.list.length > 0 || t.wire.length > 0) return;
			createjs.Ticker.off("tick", t.ticker, null, mID?mID:"z~Ticker");

t.ticker = null;
		},
		removeWire: function(obj, target, prop, input, mID) {
			var t = zim.Ticker;
			if (zot(obj) && zot(target) && zot(prop) && zot(input)) {
				t.wire.clear(); // remove all wires
			} else {
				for (var i=t.wire.length-1; i>=0; i--) {
					var o = t.wire.objects[i];
					var data = t.wire.values[i];
					if (!data) continue;
					if (obj && o!=obj) continue;
					if (target && data[0] != target) continue;
					if (prop && data[1] != prop) continue;
					if (input && data[6] != input) continue;
					t.wire.objects.splice(i,1);
					t.wire.values.splice(i,1);
				}
			}

if (t.alwaysList.length > 0 || t.list.length > 0 || t.wire.length > 0) return;
			createjs.Ticker.off("tick", t.ticker, null, mID?mID:"z~wire", obj);
			t.ticker = null;
		},
		isUpdating: function(s) {
			if (zot(s)) s = WW.zdf.stage;
			var u = false;
			var t = zim.Ticker;
			if (t.alwaysList.at(s)) {
				u=true;
			} else if (t.list && t.list.values.at(s) && t.list.values.at(s).length > 0) {
				if (zot(t.update) && (!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE))) {
					u=true;
				} else if (t.update) {
					u=true;
				}
			}
			return u;
		},
		has: function(f,s) { // swapped params in zim 5.3.1
			if (zot(s) || !s.update) s = WW.zdf.stage;
			return zim.Ticker.list && zim.Ticker.list.at(s) && zim.Ticker.list.at(s).indexOf(f) >= 0;
		},
		getFPS: function() {
			return createjs.Ticker.getMeasuredFPS();
		},
		dispose: function(s, mID, tether) {
			var t = zim.Ticker;
			var count = 0;
			var st;
			for (var i=t.list.length-1; i>=0; i--) { // countdown when removing
				st = t.list.objects[i]; // stage
				if (zot(s) || s === st) {
					t.list.remove(s);
					t.alwaysList.remove(s);
				} else {
					count+=t.list.values[i].length;
				}
			}

if (t.alwaysList.length > 0) return;
			if (count == 0) {createjs.Ticker.off("tick", t.ticker, null, mID?mID:"z~Ticker"); t.ticker = null;}
			return true;
		}
	};
	zim.Ticker.setFPS();

Object.defineProperty(zim.Ticker, 'update', {
		get: function() {
			return zim.Ticker.myUpdate;
		},
		set: function(value) {
			var t =  zim.Ticker;
			if (typeof value != "boolean") value = null;
			t.myUpdate = value;
			if (t.myUpdate === false) {
				cancelAnimationFrame(t.ticker);
				// note, this overrides always()
				// but running always() will override update = false
				t.alwaysList = new zim.Dictionary();
			}
		}
	});

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, dropTargets, dropCopy, dropSnap, dropBack, dropEnd, dropFull, dropHitTest, dropScale, dropWidth, dropHeight, dropOriginal, style, group) {
		var sig = "obj, boundary, axis, overCursor, dragCursor, all, swipe, localBoundary, onTop, surround, slide, slideFactor, slideSnap, slideSnapDamp, reg, removeTweens, startBounds, rect, currentTarget, offStage, immediateBoundary, singleTouch, dropTargets, dropCopy, dropSnap, dropBack, dropEnd, dropFull, dropHitTest, dropScale, dropWidth, dropHeight, dropOriginal, style, group";
		var duo; if (duo = zob(zim.drag, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("drag", arguments); return obj;}

var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle("Drag", group);

// MONITOR
		var mID = "z~"+(DS.monitor===false?"-":"drag");
		if (obj && obj.mID && obj.mID[2]=="-") mID = "z~-";

if (zot(obj)) obj = DS.obj!=null?DS.obj:null;
		if (zot(obj) || !obj.on) return;
		if (zot(currentTarget)) currentTarget = DS.currentTarget!=null?DS.currentTarget:null;
		if (zot(all)) all = DS.all!=null?DS.all:null;
		if (zot(boundary)) boundary = DS.boundary!=null?DS.boundary:null;
		if (zot(axis)) axis = DS.axis!=null?DS.axis:null;
		if (zot(overCursor)) overCursor = DS.overCursor!=null?DS.overCursor:null;
		if (zot(dragCursor)) dragCursor = DS.dragCursor!=null?DS.dragCursor:null;
		if (zot(axis)) axis = DS.axis!=null?DS.axis:null;
		
		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 = DS.swipe!=null?DS.swipe:false;		
		if (zot(localBoundary)) localBoundary = DS.localBoundary!=null?DS.localBoundary:false;
		if (zot(onTop)) onTop = DS.onTop!=null?DS.onTop:true;
		if (zot(surround)) surround = DS.surround!=null?DS.surround:false;
		if (zot(slide)) slide = DS.slide!=null?DS.slide:false;
		if (zot(slideFactor)) slideFactor = DS.slideFactor!=null?DS.slideFactor:.9;
		if (zot(slideSnap)) slideSnap = DS.slideSnap!=null?DS.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 = DS.slideSnapDamp!=null?DS.slideSnapDamp:.1;
		if (zot(reg)) reg = DS.reg!=null?DS.reg:false;
		if (zot(removeTweens)) removeTweens = DS.removeTweens!=null?DS.removeTweens:true;
		if (zot(startBounds)) startBounds = DS.startBounds!=null?DS.startBounds:true;
		if (zot(rect)) rect = DS.rect!=null?DS.rect:null;
		if (zot(boundary) && !zot(rect)) boundary = rect;
		if (zot(singleTouch)) singleTouch = DS.singleTouch!=null?DS.singleTouch:false;

if (zot(offStage)) offStage = DS.offStage!=null?DS.offStage:null;
		if (zot(immediateBoundary)) immediateBoundary = DS.immediateBoundary!=null?DS.immediateBoundary:null;
		if (zot(singleTouch)) singleTouch = DS.singleTouch!=null?DS.singleTouch:null;
		if (zot(dropTargets)) dropTargets = DS.dropTargets!=null?DS.dropTargets:null;
		if (zot(dropCopy)) dropCopy = DS.dropCopy!=null?DS.dropCopy:null;
		if (zot(dropHitTest)) dropHitTest = DS.dropHitTest!=null?DS.dropHitTest:null;
		if (zot(dropScale)) dropScale = DS.dropScale!=null?DS.dropScale:null;
		if (zot(dropWidth)) dropWidth = DS.dropWidth!=null?DS.dropWidth:null;
		if (zot(dropHeight)) dropHeight = DS.dropHeight!=null?DS.dropHeight:null;
		if (zot(dropOriginal)) dropOriginal = DS.dropOriginal!=null?DS.dropOriginal:null; // ZIM 019 patch

if (dropTargets) {
			slide = false;
			obj.dropTargets = dropTargets;
		}
		if (zot(dropSnap)) dropSnap = DS.dropSnap!=null?DS.dropSnap:true;
		if (zot(dropBack)) dropBack = DS.dropBack!=null?DS.dropBack:true;
		if (zot(dropEnd)) dropEnd = DS.dropEnd!=null?DS.dropEnd:true;
		if (zot(dropFull)) dropFull = DS.dropFull!=null?DS.startBounds:true;
		var hitTypes = ["reg", "circles", "rect", "circle"];
		if (dropHitTest) dropHitTest.toLowerCase();
		if (!hitTypes.includes(dropHitTest)) dropHitTest = null;
		if (zot(dropHitTest)) dropHitTest = DS.dropHitTest!=null?DS.dropHitTest:"bounds";
				
		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, null, null, mID); // if not added to display list
		obj.zimRemoved = obj.on("removed", unInitializeObject, null, true, null, null, mID);
		if (obj.parent) initializeObject();

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

var dragObject;

var stage;
		obj.pointers = {};
		var stCheck = false;
		var dropListCheck;
		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

// obj.zimMove = obj.on("pressmove", obj.zimMove);	// for some reason causing squiggle drag problems
			
			stCheck = true;
			dropListCheck = false;
			stage = obj.stage;
			if (!obj.zmu) obj.zmu = stage.frame.on("mouseupplus", function(e) {				
				if (obj.downCheck) {				
					// Note - adjusted the mouseupplus event to delay 30ms if triggered on a mousemove 	
					if (!slide) obj.downCheck = false;					
					doUp(e, true); // true for cancel slide		
				}				
			}, null, null, null, null, mID);		
						
			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;
			dragObject.dragStartX = dragObject.x;
			dragObject.dragStartY = dragObject.y;

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, mID, obj);

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;

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;
			}

// DROP - added ZIM 017 Patch
			if (zot(dragObject.dropStartS)) {	
				if (!dragObject.dropOriginalList) {
					dragObject.dropOriginalX = dragObject.x;
					dragObject.dropOriginalY = dragObject.y;				
					dragObject.dropOriginalS = dragObject.scale;
				}
				dragObject.dropStartX = dragObject.x;
				dragObject.dropStartY = dragObject.y;
				dragObject.dropStartS = dragObject.scale;
			}			
			if (obj.dropTargets && dropCopy && !dragObject.dropClone) {
				if (dragObject.clone) {
					dragObject.dropCopy = dragObject.clone(true).addTo(dragObject.parent, dragObject.parent.getChildIndex(dragObject));
					dragObject.dropCopy.dropClone = true;
					if (!dragObject.dropOriginalList) {
						dragObject.dropCopy.dropOriginalX = dragObject.dropOriginalX;
						dragObject.dropCopy.dropOriginalY = dragObject.dropOriginalY;
						dragObject.dropCopy.dropOriginalS = dragObject.dropOriginalS;
					}					
					dragObject.dropCopy.dropStartX = dragObject.dropStartX;
					dragObject.dropCopy.dropStartY = dragObject.dropStartY;
					dragObject.dropCopy.dropStartS = dragObject.dropStartS;				
					dragObject.dropCopy.noMouse();
				}
			} 
			// HANDLE DROP ON LIST 
			if (obj.dropTargets) {
				var notList = true;
				zim.loop(obj.dropTargets, function(target){
					if (target.type == "List") {
						if (!obj.dropListProps) obj.dropListProps = {
							color:white,
							thickness:1,
							alpha:1,
							speed:5
						};		
						if (!target.dropReticle) {								
							target.dropReticle = new zim.Rectangle(20,20,clear,obj.dropListProps.color,obj.dropListProps.thickness).reg(CENTER).rot(45).alp(obj.dropListProps.alpha);
							target.dropReticleIndex = null;
							target.zgb = target.boundsToGlobal();
							target.zgs = target.getConcatenatedDisplayProps().matrix.decompose().scaleX/stage.scaleX;	
						}					
						notList = false;	
					}
				});
				dropListCheck = !notList;
			}
		}, true, null, null, null, mID);

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();
			
			// DROP ON LIST - added ZIM 017
			if (dropListCheck) {
				// scroll if ghost is at edges of scrollable list				
				var ghost = dragObject;
				var checkItem;
				var dropScrollSpeed = obj.dropListProps.speed;
				zim.List.doDropOver(dropTargets, ghost, checkItem, dropScrollSpeed);				
			}
		}, true, null, null, null, mID);

// 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);
				}
			}

// 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;
			}
		}

obj.zimPosition = positionObject;

obj.zimUp = obj.on("pressup", function(e){doUp(e);}, true, null, null, null, mID);
				
		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 (Math.abs(dX) < 1 && Math.abs(dY) < 1) {
				if (Math.abs(dragObject.x-dragObject.dragStartX) < 1 && Math.abs(dragObject.y-dragObject.dragStartY) < 1) {
					hasMoved = false;
					dragObject.dispatchEvent("slidestop");
					if (obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker, mID, obj);
				}

// 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 && obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker, mID, obj);
				// 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(); 
				}
			}

// DROP - added ZIM 017 patch

if (obj.dropTargets) {
				if (!Array.isArray(obj.dropTargets)) obj.dropTargets = [obj.dropTargets];
				// // ZIM 019 patch - removed this and moved dropFull = false 
				// // to if moved to different place		
				// // the droppedTarget will be overwritten if succesful
				// // but if not then we want it to be the same as it was		
				// if (dragObject.droppedTarget) {
				// 	dragObject.droppedTarget.dropFull = false;
				// 	dragObject.droppedTarget = null;
				// }
								
				var wasFull = false; // ZIM 019 patch

var miss = zim.loop(obj.dropTargets, function(target) {

if (target.type == "List") {
						if (target.scrollInt) target.scrollInt.clear();
						if (!zot(target.dropReticleIndex)) {
							target.dropReticle.removeFrom();												
							var placeObject = dragObject;
							if (dropCopy) {
								// need to do the swap on one of these		
								if (dropCopy && dragObject.dropCopy) {
									placeObject = dragObject.dropCopy;
									swapProperties("x", dragObject, placeObject);
									swapProperties("y", dragObject, placeObject);
								}
							}								
							if (dropScale) placeObject.sca(dropScale);
							if (dropWidth || dropHeight) placeObject.siz(dropWidth, dropHeight);
							if (dropEnd) placeObject.noMouse();
							else placeObject.mouse();	
							
							// added in ZIM 019 patch
							// set last dropTarget dropFull to false
							if (placeObject.droppedTarget) placeObject.droppedTarget.dropFull = false;

placeObject.droppedTarget = target;		
							target.addAt(placeObject, target.dropReticleIndex);			
							target.dropItem = dragObject;

dragObject.droppedTarget = target;
							dragObject.dropTarget = target;
							target.dropList = target;
							target.dropNewIndex = target.dropReticleIndex;
							target.dropReticleIndex = null;		
							return false					 
						}
						return;
					}

if (dragObject["hitTest"+String(dropHitTest).charAt(0).toUpperCase() + String(dropHitTest).slice(1)](target)) {
						
						wasFull = target.dropFull; // ZIM 019 patch 
						
						if (!dropFull || !target.dropFull) {
							var placeObject = dragObject;
							if (dropCopy && dragObject.dropCopy) {
								placeObject = dragObject.dropCopy;
								swapProperties("x", dragObject, placeObject);
								swapProperties("y", dragObject, placeObject);
							}
							// clone gets all these things
							if (dropSnap) placeObject.loc(target);
							if (dropScale) placeObject.sca(dropScale);
							if (dropWidth || dropHeight) placeObject.siz(dropWidth, dropHeight);
							if (dropEnd) placeObject.noMouse();
							else placeObject.mouse();

// added these in ZIM 019 patch	
							placeObject.dropStartX = placeObject.x;
							placeObject.dropStartY = placeObject.y;
							placeObject.dropStartS = placeObject.scale;	
							// set last dropTarget dropFull to false
							if (placeObject.droppedTarget) dragObject.droppedTarget.dropFull = false;	
							// end ZIM 019 patch

if (dropFull) target.dropFull = true;	
							
							placeObject.droppedTarget = target;													
							placeObject.dropTarget = target;	
																
							return false;
						}
					} 
				});

// dropOriginal 
				// if set to false then once in a system always snaps back to within system 
				// if set to true if dropped not on target then goes back to original x,y,scale 
				// otherwise if full then still snaps back inside system
				if (miss) {		
					// dragObject.dropTarget = dragObject.droppedTarget = null;	// going back to last spot - removed this in ZIM 019 patch
					if (dropBack) {

// ZIM 019 Patch to handle dropOrigin		
						// dropOriginalList means it came originally from a List and will not have a dropOriginalX, etc.
						if ((!dropFull || !wasFull) && dropOriginal && !dragObject.dropOriginalList) {
							dragObject.dropStartX = dragObject.dropOriginalX;
							dragObject.dropStartY = dragObject.dropOriginalY;
							dragObject.dropStartS = dragObject.dropOriginalS;
							if (dragObject.droppedTarget) dragObject.droppedTarget.dropFull = false;
							dragObject.dropTarget = dragObject.droppedTarget = null;
						} 
						dragObject.animate({
							props:{x:dragObject.dropStartX, y:dragObject.dropStartY, scale:dragObject.dropStartS}, 
							time:.2, 
							timeUnit:"s",
							call:function(target) {
								if (dropCopy) {
									if (target.dropCopy) target.dropCopy.dispose();
									else target.dispose();
								}
							}
						});
					} else {
						
						// added these in ZIM 019 patch	
						if (dragObject.droppedTarget) dragObject.droppedTarget.dropFull = false;	
						dragObject.droppedTarget = null;						
						// end ZIM 019 patch

dragObject.sca(dragObject.dropOriginalS);	
						if (dropCopy && dragObject.dropCopy) {
							swapProperties("x", dragObject, dragObject.dropCopy);
							swapProperties("y", dragObject, dragObject.dropCopy);
							dragObject.dropCopy.mouse();
						}
					}
					
				}
			}
			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)*zim.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};
		}
		obj.zimCheckBounds = checkBounds;
		
		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");
					if (obj.zimDragTicker) zim.Ticker.remove(obj.zimDragTicker, mID, obj);
				}
				// 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;
			}
		}

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;
	};

zim.noDrag = function(obj, recursive, snapBack) {
		if (zot(obj) || !obj.on) return;

// MONITOR
		var mID = "z~noDrag";
		if (obj && obj.mID && ((obj.mID[2] && obj.mID[2]=="-") || obj.mID[0]=="-")) mID = "z~-";

if (zot(recursive)) recursive = true;
		if (zot(snapBack)) snapBack = true;
		if (recursive && obj.numChildren && obj.numChildren > 1) {
			for (var i=0; i<obj.numChildren; i++) {
				var o = obj.getChildAt(i);
				undrag(o);
			}
		}
		undrag(obj); // also undrag the parent to be sure
		function undrag(obj) {
			if (obj.cur) obj.cur("default");
			obj._draggable = false;
			zim.setSwipe(obj, true);
			obj.off("added", obj.zimAdded, null, mID);
			obj.off("removed", obj.zimRemoved, null, mID);
			obj.off("mousedown", obj.zimDown, null, mID);
			obj.off("pressmove", obj.zimMove, null, mID);
			obj.off("pressup", obj.zimUp, null, mID);
			if (obj.zmu) {
				if (obj.stage) obj.stage.frame.off("mouseupplus", obj.zmu, null, mID);
				else WW.zdf.off("mouseupplus", obj.zmu, null, mID);
			}		
			if (zim.Ticker) {				
				if (obj.zimDragSlide) zim.Ticker.remove(obj.zimDragSlide, mID, obj);	
				if (obj.zimDragTicker) {								
					zim.Ticker.remove(obj.zimDragTicker, mID, obj);
					if (snapBack) {
						var f = obj.zimCheckBounds(obj, obj.x, obj.y);	
						obj.animate({x:f.x, y:f.y}, .3);
					}
				}
			}
			obj.zimDragMoving=obj.zimAdded=obj.zimRemoved=obj.zimDown=obj.zimMove=obj.zimUp=obj.zimBoundary=obj.zimDragSlide=null;
			obj.slideStartX = obj.slideStartY = obj.zimDragImmediate = null;
			obj.dragMouseX = obj.zimPosition = obj.dragMouseY = obj.zimDown = obj.zimUp = null;
			obj.zimDragTicker = obj.zimDragSlide = null;
		}
		return obj;
	};

zim.noMouse = function(obj) {
		obj.zimLastMouse = obj.mouseChildren;
		obj.mouseChildren = false;
		obj.mouseEnabled = false;
		obj.zimLastMouseEnabled = false;
		return obj;
	};

zim.effect = function(obj, effect, x, y, width, height) {
		if (zot(effect)) return obj;		
		
		if (zot(obj.effects)) obj.effects = {};
        if (!Array.isArray(effect)) effect = [effect];   
        var customCount = 0;     
        for (var j=0; j<effect.length; j++) {
            var eff = effect[j];
			if (!eff.type) {
				if (eff instanceof createjs.BlurFilter) eff.type = "BlurEffect";
				else if (eff instanceof createjs.ColorFilter) eff.type = "ColorEffect";
				else if (eff instanceof createjs.AlphaMaskFilter) eff.type = "AlphaEffect";
				else if (eff instanceof createjs.ColorMatrixFilter) eff.type = "MultiEffect";		
				else if (zot(eff.type)) eff.type = "custom"+customCount++;
			}
			var e = eff.type.replace(/effect/i, "");
            obj.effects[e.toLowerCase()] = eff;
        }
        obj.filters = [];
        for (var i in obj.effects) {
            obj.filters.push(obj.effects[i]);
        } 
		
        obj.cache(x,y,width,height,null,{adjustBounds:true},null,(WW.DIR && WW.DIR=="rtl")); 
		return obj;
	};

zim.noEffect = function(obj, effects, cache) {
		if (zot(cache)) cache = false;
		if (zot(effects)) {
			var storeMulti;
			if (obj.effects.multi) storeMulti = obj.effects.multi;
			obj.effects = {};		
			if (storeMulti) obj.effects.multi = storeMulti;	
		} else {
			if (!obj.effects) obj.effects = {};
			if (!Array.isArray(effects)) effects = [effects];   
				for (var j=0; j<effects.length; j++) {
				var e = effects[j].replace(/effect/i, "");
				delete obj.effects[e.toLowerCase()];
			}			
		}
		obj.filters = [];
		for (var i in obj.effects) {
			obj.filters.push(obj.effects[i]);
		} 
		if (cache || obj.filters.length > 0) {
			if (obj.updateCache) obj.updateCache();
		} else {
			if (obj.uncache) obj.uncache();
		}
		return obj;
	};

zim.hitTestPoint = function(obj, x, y, boundsCheck) {
		if (!obj.stage || zot(x) || zot(y)) return false;
		if (zot(obj) || !obj.globalToLocal) return;
		if (zot(boundsCheck)) boundsCheck = true;
		if (boundsCheck) {
			var bounds = obj.getBounds();
			if (bounds) { // faster to check if point is in bounds first
				var boundPoint = obj.globalToLocal(x,y);
				if (boundPoint.x > bounds.x + bounds.width || boundPoint.x < bounds.x) return false;
				if (boundPoint.y > bounds.y + bounds.height || boundPoint.y < bounds.y) return false;
			}
		}
		var point = {x:x, y:y};
		if (obj.image || obj.spriteSheet || obj.type == "Shape") point = obj.globalToLocal(point.x, point.y);
		else point = obj.globalToLocal(point.x*zim.scaX,point.y*zim.scaY);
		return obj.hitTest(point.x, point.y);
	};

zim.hitTestReg = function(a, b, boundsCheck) {
		if (!a.stage || !b.stage) return false;
		if (zot(a) || zot(b) || !a.localToLocal || !b.localToLocal) return;
		if (zot(boundsCheck)) boundsCheck = true;

};

zim.boundsCheck = false;
	zim.boundsToGlobal = function(obj, rect, flip, inside, globalObj) {
		if (zot(obj) || !obj.getBounds) return;
		if (zot(flip)) flip = false;
		if (globalObj && !obj.getBounds && !obj.getBounds()) return obj;
		var oB = obj.getBounds();
		if (!oB && zot(rect)) {
			zogy("zim methods - boundsToGlobal():\n please setBounds() on object (or a rectangle)");
			return;
		}
		if (rect) oB = rect;
		
		var pTL,pTR,pBR,pBL;
		if (globalObj && globalObj.type && !(globalObj.type=="Stage" ||  globalObj.type=="StageGL")) {
			pTL = obj.localToLocal(oB.x, oB.y, globalObj);
			pTR = obj.localToLocal(oB.x+oB.width, oB.y, globalObj);
			pBR = obj.localToLocal(oB.x+oB.width, oB.y+oB.height, globalObj);
			pBL = obj.localToLocal(oB.x, oB.y+oB.height, globalObj);			
		} else {
			if (flip) {
				pTL = obj.globalToLocal(oB.x, oB.y);
				pTR = obj.globalToLocal(oB.x+oB.width, oB.y);
				pBR = obj.globalToLocal(oB.x+oB.width, oB.y+oB.height);
				pBL = obj.globalToLocal(oB.x, oB.y+oB.height);
			} else {
				pTL = obj.localToGlobal(oB.x, oB.y);
				pTR = obj.localToGlobal(oB.x+oB.width, oB.y);
				pBR = obj.localToGlobal(oB.x+oB.width, oB.y+oB.height);
				pBL = obj.localToGlobal(oB.x, oB.y+oB.height);
			}
		}

return new createjs.Rectangle(
			newTLX,
			newTLY,
			newBRX-newTLX,
			newBRY-newTLY
		);
	};

zim.cur = function(obj, type) {
		if (zot(obj)) {zogy("zim methods - cur(): please provide object"); return obj;}
		if (zot(type)) type = "pointer";

var f = WW.zdf;
		if (obj.stage) f = obj.stage.frame;
		
		if (f.cursors) {
			// set cursor to none and record desired in cursorList
			if (f.cursors[type]) {
				obj.cursor = "none";
				obj._cursor = type;
				f.cursorList.add(obj, type);
				return obj;
			}
		}

// set that cursor is to be adjusted but keep as true
		if (f.cursorList) f.cursorList.add(obj, true);

obj.cursor = type;
		return obj;
	};

zim.sha = function(obj, color, offsetX, offsetY, blur) {
		if (zot(obj)) {zogy("zim methods - sha(): please provide object"); return obj;}
		if (zot(color)) color = "rgba(0,0,0,.3)";
		if (color.blur) {obj.shadow = color; return obj;} // a Shadow is passed as first parameter
		if (zot(offsetX)) offsetX = obj.width ? obj.width *.08 : 5;
		if (zot(offsetY)) offsetY = obj.height ? obj.height *.08 : 5;
		if (zot(blur)) blur = obj.width ? obj.width *.16 : 10;
		if (color == -1) obj.shadow = null;
		else obj.shadow = new createjs.Shadow(color, offsetX, offsetY, blur);
		return obj;
	};

zim.pos = function(obj, x, y, horizontal, vertical, container, index, add, reg, regX, regY) {
		var sig = "obj, x, y, horizontal, vertical, container, index, add, reg, regX, regY";
		var duo; if (duo = zob(zim.pos, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("pos", arguments); return obj.addTo(container, index);}
		
		// handle DIR effect 
		if ((WW.DIR && WW.DIR=="rtl") || (!WW.DIR && zim.DIR=="rtl")) {
			if (horizontal=="start") horizontal="right";
			else if (horizontal=="end") horizontal="left";
		} else {
			if (horizontal=="start") horizontal="left";
			else if (horizontal=="end") horizontal="right";
		}

var PR = zim.POSREG;
		if (WW.POSREG != null) PR = WW.POSREG;
		if (zot(reg)) reg = PR;

if (zot(add)) add = true;
		if (!zot(container) && !container.addChild) container = null;
		if (!obj.getBounds && !obj.getBounds()) {regX = regY = false;}

obj.zimPos = {x:x,y:y,h:horizontal,v:vertical,i:index};

if (zot(container)) {
			if (obj.parent) container = obj.parent;
			else if (WW.zdf) container = WW.zdf.stage;
		}

if (!obj.parent && zot(x)) x = 0;
		if (!obj.parent && zot(y)) y = 0;

var resetObjCheck = false;
		if (!obj.getBounds()) {
			obj.setBounds(0,0);
			resetObjCheck = true;
		}

var resetContainerCheck = false;
		if (container && !container.getBounds()) {
			container.setBounds(0,0);
			resetContainerCheck = true;
		}

if (obj.parent && obj.parent.getBounds) {
			container = obj.parent;

if (zot(x) && right==true) x = 0;
			if (zot(y) && bottom==true) y = 0;

zim.loc = function(obj, target, y, container, index, add, localToLocal, x) {
		var sig = "obj, target, y, container, index, add, localToLocal, x";
		var duo; if (duo = zob(zim.loc, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("loc", arguments); return obj.addTo(container, index);}
		if (zot(obj)) return;
		if (typeof target == "number") {
			x = target;
			target = null;
		}
		if (!zot(target)) {
			if (Array.isArray(target)) {
				x = target[0];
				y = target[1];
			} else {
				if (!zot(target.x)) x = target.x;
				if (!zot(target.y)) y = target.y;
			}
		}
		if (zot(x) && zot(target)) x = obj.x;
		if (zot(y) && zot(target)) y = obj.y;

if (zot(add)) add = true;
		if (zot(container)) {
			if (obj.parent) container = obj.parent;
			else if (WW.zdf) container = WW.zdf.stage;
		}
		if (add && container) {
			if (!obj.parent || container != obj.parent) {
				if (zot(index) || isNaN(index)) {container.addChild(obj);}
				else {
					container.addChildAt(obj, index);
				}
			} else if (!zot(index)) {
				container.addChildAt(obj, index);
			}
		}
		if (zot(localToLocal)) localToLocal = true;
		if (target && target.parent && obj.parent && localToLocal) {
			var point = target.parent.localToLocal(x, y, obj.parent);
			x = point.x;
			y = point.y;
		}
		obj.x = x;
		obj.y = y;
		return obj;
	};

zim.mov = function(obj, x, y) {
		var sig = "obj, x, y";
		var duo; if (duo = zob(zim.mov, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("mov", arguments); return obj;}
		if (zot(obj)) return;
		if (!zot(x)) obj.x += x;
		if (!zot(y)) obj.y += y;
		return obj;
	};

zim.bot = function(obj) {
		if (zot(obj) || !obj.parent) return obj;
		obj.parent.setChildIndex(obj, 0);
		return obj;
	};

zim.ord = function(obj, num) {
		if (zot(obj) || !obj.parent) return;
		if (zot(num)) num = 0;
		obj.parent.setChildIndex(obj, zim.constrain(obj.parent.getChildIndex(obj)+num, 0, obj.parent.numChildren-1));
		return obj;
	};

zim.rot = function(obj, rotation, x, y) {
		if (zot(obj)) return;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("rot", arguments); return obj;}
		if (!zot(rotation)) {
			if (obj.parent && (!zot(x) || !zot(y))) {
				if (zot(x)) x = obj.x;
				if (zot(y)) y = obj.y;
				var inside = obj.parent.localToLocal(x, y, obj);
				var outside = new zim.Point(obj.x, obj.y);
				obj.reg(inside.x, inside.y);
				obj.rotation=rotation;
				obj.x = x;
				obj.y = y;
				var backPoint = obj.parent.localToLocal(outside.x, outside.y, obj);
				obj.reg(backPoint.x, backPoint.y);
				obj.x = outside.x;
				obj.y = outside.y;
			} else {
				obj.rotation=rotation;
			}
		}
		return obj;
	};

zim.reg = function(obj, regX, regY, still) {
		if (zot(obj)) return;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("reg", arguments); return obj;}
		var lastRegX = obj.regX;
		var lastRegY = obj.regY;
		var originalX = regX;
		var DIR = WW.DIR || zim.DIR || "ltr";
		var bounds;
		if (regX=="default") regX = null;
		
		// handle constants
		if (typeof regX == "string") {
			bounds = obj.getBounds();
			if (!bounds) regX = null; 
			else {				
				if (regX=="start") regX=DIR=="ltr"?"left":"right";
				if (regX=="end") regX=DIR=="ltr"?"right":"left";
				if (regX=="left") regX = bounds.x;
				else if (regX=="right") regX = bounds.x+bounds.width;				
				else if (regX=="center"||regX=="middle") regX = bounds.x+bounds.width/2;
			}			
		} 
		if (typeof regY == "string") {
			if (!bounds) bounds = obj.getBounds();
			if (!bounds) regY = null;
			else if (regY=="top") regY = bounds.y;
			else if (regY=="bottom") regY = bounds.y+bounds.height;
			else if (regY=="center"||regY=="middle") regY = bounds.y+bounds.height/2;
		} else if (zot(regY) && (originalX=="center"||originalX=="middle")) {
			if (!bounds) bounds = obj.getBounds();
			if (!bounds) regY = null;
			else regY = bounds.y+bounds.height/2;			
		}		
		if (regY == "default") regY = null;
		
		if (!zot(regX)) obj.regX = regX;
		if (!zot(regY)) obj.regY = regY;
		if (still && obj.parent) {
			var p = obj.localToLocal(lastRegX, lastRegY, obj.parent);
			obj.x -= p.x-obj.x;
			obj.y -= p.y-obj.y;
		}
		return obj;
	};

zim.sca = function(obj, scale, scaleY) {
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("sca", arguments); return obj;}
		if (zot(obj) || zot(obj.scaleX)) return obj;
		if (zot(scale)) scale = obj.scaleX;
		if (zot(scaleY)) scaleY = scale;
		obj.scaleX = scale; obj.scaleY = scaleY;
		return obj;
	};

zim.animate = function(target, props, time, ease, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startCall, startParams, animateCall, animateParams, sequence, sequenceCall, sequenceParams, sequenceReverse, sequenceRatio, ticker, cjsProps, css, protect, override, from, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, sequenceWait, rate, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck, noAnimateCall, pathDamp, rewindPick, style, group) {
		var sig = "target, props, time, ease, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startCall, startParams, animateCall, animateParams, sequence, sequenceCall, sequenceParams, sequenceReverse, sequenceRatio, ticker, cjsProps, css, protect, override, from, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, sequenceWait, rate, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck, noAnimateCall, pathDamp, rewindPick, style, group";

if (target && (target.props || target.obj)) {
			var duo; if (duo = zob(zim.animate, arguments, sig)) return duo;
		}	
		
				
		if (target && target.type && target.type=="AC" && WW.zdf) {WW.zdf.ac("animate", arguments); return target;}

// STYLE added in ZIM 019 - just preset all except target
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle("Animate", group);

// MONITOR
		var mID = "z~"+(DS.monitor===false?"-":"animate");
		if (target && target.mID && target.mID[2]=="-") mID = "z~-"; // if object is set to redact then redact method
		
		if (zot(props)) props = DS.props!=null?DS.props:null;
		if (zot(time)) time = DS.time!=null?DS.time:null;
		if (zot(ease)) ease = DS.ease!=null?DS.ease:null;
		if (zot(call)) call = DS.call!=null?DS.call:null;
		if (zot(params)) params = DS.params!=null?DS.params:null;
		if (zot(wait)) wait = DS.wait!=null?DS.wait:null;
		if (zot(waitedCall)) waitedCall = DS.waitedCall!=null?DS.waitedCall:null;
		if (zot(waitedParams)) waitedParams = DS.waitedParams!=null?DS.waitedParams:null;
		if (zot(loop)) loop = DS.loop!=null?DS.loop:null;
		if (zot(loopCount)) loopCount = DS.loopCount!=null?DS.loopCount:null;
		if (zot(loopWait)) loopWait = DS.loopWait!=null?DS.loopWait:null;
		if (zot(loopCall)) loopCall = DS.loopCall!=null?DS.loopCall:null;
		if (zot(loopParams)) loopParams = DS.loopParams!=null?DS.loopParams:null;
		if (zot(loopWaitCall)) loopWaitCall = DS.loopWaitCall!=null?DS.loopWaitCall:null;	
		if (zot(loopWaitParams)) loopWaitParams = DS.loopWaitParams!=null?DS.loopWaitParams:null;
		if (zot(loopPick)) loopPick = DS.loopPick!=null?DS.loopPick:null;
		if (zot(rewind)) rewind = DS.rewind!=null?DS.rewind:null;
		if (zot(rewindWait)) rewindWait = DS.rewindWait!=null?DS.rewindWait:null;
		if (zot(rewindCall)) rewindCall = DS.rewindCall!=null?DS.rewindCall:null;
		if (zot(rewindParams)) rewindParams = DS.rewindParams!=null?DS.rewindParams:null;
		if (zot(rewindWaitCall)) rewindWaitCall = DS.rewindWaitCall!=null?DS.rewindWaitCall:null;
		if (zot(rewindWaitParams)) rewindWaitParams = DS.rewindWaitParams!=null?DS.rewindWaitParams:null;
		if (zot(rewindTime)) rewindTime = DS.rewindTime!=null?DS.rewindTime:null;
		if (zot(rewindEase)) rewindEase = DS.rewindEase!=null?DS.rewindEase:null;
		if (zot(startCall)) startCall = DS.startCall!=null?DS.startCall:null;
		if (zot(startParams)) startParams = DS.startParams!=null?DS.startParams:null;
		if (zot(animateCall)) animateCall = DS.animateCall!=null?DS.animateCall:null;
		if (zot(animateParams)) animateParams = DS.animateParams!=null?DS.animateParams:null;
		if (zot(sequence)) sequence = DS.sequence!=null?DS.sequence:null;
		if (zot(sequenceCall)) sequenceCall = DS.sequenceCall!=null?DS.sequenceCall:null;
		if (zot(sequenceParams)) sequenceParams = DS.sequenceParams!=null?DS.sequenceParams:null;
		if (zot(sequenceReverse)) sequenceReverse = DS.sequenceReverse!=null?DS.sequenceReverse:null;
		if (zot(sequenceRatio)) sequenceRatio = DS.sequenceRatio!=null?DS.sequenceRatio:null;
		if (zot(ticker)) ticker = DS.ticker!=null?DS.ticker:null;
		if (zot(cjsProps)) cjsProps = DS.cjsProps!=null?DS.cjsProps:null;
		if (zot(css)) css = DS.css!=null?DS.css:null;		
		if (zot(protect)) protect = DS.protect!=null?DS.protect:null;
		if (zot(override)) override = DS.override!=null?DS.override:null;
		if (zot(from)) from = DS.from!=null?DS.from:null;
		if (zot(set)) set = DS.set!=null?DS.set:null;
		if (zot(id)) id = DS.id!=null?DS.id:null;
		if (zot(events)) events = DS.events!=null?DS.events:null;
		if (zot(sequenceTarget)) sequenceTarget = DS.sequenceTarget!=null?DS.sequenceTarget:null;
		if (zot(dynamic)) dynamic = DS.dynamic!=null?DS.dynamic:null;
		if (zot(drag)) drag = DS.drag!=null?DS.drag:null;
		if (zot(clamp)) clamp = DS.clamp!=null?DS.clamp:null;
		if (zot(startPaused)) startPaused = DS.startPaused!=null?DS.startPaused:null;
		if (zot(clean)) clean = DS.clean!=null?DS.clean:null;
		if (zot(obj)) obj = DS.obj!=null?DS.obj:null;
		if (zot(seriesWait)) seriesWait = DS.seriesWait!=null?DS.seriesWait:null;
		if (zot(sequenceWait)) sequenceWait = DS.sequenceWait!=null?DS.sequenceWait:null;
		if (zot(rate)) rate = DS.rate!=null?DS.rate:null;
		if (zot(pauseOnBlur)) pauseOnBlur = DS.pauseOnBlur!=null?DS.pauseOnBlur:null;
		if (zot(easeAmount)) easeAmount = DS.easeAmount!=null?DS.easeAmount:null;
		if (zot(easeFrequency)) easeFrequency = DS.easeFrequency!=null?DS.easeFrequency:null;
		if (zot(timeUnit)) timeUnit = DS.timeUnit!=null?DS.timeUnit:null;
		if (zot(timeCheck)) timeCheck = DS.timeCheck!=null?DS.timeCheck:null;
		if (zot(noAnimateCall)) noAnimateCall = DS.noAnimateCall!=null?DS.noAnimateCall:null;
		if (zot(pathDamp)) pathDamp = DS.pathDamp!=null?DS.pathDamp:null;
		if (zot(rewindPick)) rewindPick = DS.rewindPick!=null?DS.rewindPick:null;

if (!target) target = {}; // ZIM 018 replacing: return; from 10.9.0 
		var AN = zim.ANIMATE;
		if (WW.ANIMATE != null) AN = WW.ANIMATE;
		if (!AN) {
			if (zot(noAnimateCall)) noAnimateCall = true;
			if (call && noAnimateCall && typeof call == "function") call(zot(params)?target:params);
			return target;
		}

if (zot(timeCheck)) timeCheck = true;
		// last param is noWarning - sent internal as false by wiggle for instance
		var timeType = getTIME(null, timeUnit, null, null, zot(timeCheck)?false:!timeCheck);

if (loopCall || loopWait || loopPick || loopCount) loop = true;
		if (rewindCall || rewindWait || rewindPick || rewindTime || rewindEase) rewind = true;

var i, prop, currentCount;
		var startArguments = arguments;
		var startParameters = Array.prototype.slice.call(arguments);

if (zot(props) && !zot(obj)) props = obj; // conversion of 7.1 props parameter to pre 7.1 obj parameter
		obj = props;
		if (zot(obj)) {if (zon) {zogy("animate() - need props");} return target;}

if (!zot(sequenceRatio)) sequence = 0;

// added ZIM 10.7.0
		if (target.type == "BeadsContainer") {
			if (zot(sequence)) sequence = 0;
		}

// added ZIM 10.8.0 Added a rate parameter near the end of animate() to change the rate of speed of the animation
		if (target.type == "Tone") pauseOnBlur = false;
		if (pauseOnBlur === false) zim.pauseAnimateOnBlur = false; // adjusted for ZIM ZIM 01 - it would be good to do individual perhaps
		else if (pauseOnBlur || (zot(pauseOnBlur) && zim.pauseAnimateOnBlur !== false)) {
			if (zot(zim.blurCheck)) zim.setBlurDetect();
			zim.pauseAnimateOnBlur = true;
		}

// zik supports passing array of options or an object with min, max, integer, negative properties and zik will pick or calculate a random value
		if (!zot(sequence) && target.addChild) {
			// do not process ZIM VEE until individual animates are called
		} else {
			time = zim.Pick.choose(time);
			ease = zim.Pick.choose(ease);
			wait = zim.Pick.choose(wait);
			loopCount = zim.Pick.choose(loopCount);
			loopWait = zim.Pick.choose(loopWait);
			rewind = zim.Pick.choose(rewind);
			rewindWait = zim.Pick.choose(rewindWait);
			if (rewind && zot(rewindTime)) rewindTime = time;
			else rewindTime = zim.Pick.choose(rewindTime);
			sequenceReverse = zim.Pick.choose(sequenceReverse);
			from = zim.Pick.choose(from);
			set = zim.Pick.choose(set);
			// when sequence recalls animate() some of have been put in cjsProps and not in main params like above
			var zikTypes = ["loopCount","loopWait","rewind","rewindWait"];
			for (prop in cjsProps) {
				if (zikTypes.indexOf(prop) >= 0) cjsProps[prop] = zim.Pick.choose(cjsProps[prop]);
			}
		}
		if (ease == "none") ease = "linear";

// CJSPROPS
		// convert loop and rewind properties into the legacy cjs props object 
 
		var newProps = {override: zot(override) ? ((!zot(target) && !zot(target.zimX) && !zot(obj.x)) || (!zot(target) && !zot(target.zimY) && !zot(obj.y))) : override};
   
		if (!zot(loop)) newProps.loop = loop;
		if (!zot(loopCount)) newProps.count = loopCount; // note prop is count
		if (!zot(loopWait)) newProps.loopWait = loopWait;
		if (!zot(loopCall)) newProps.loopCall = loopCall;
		if (!zot(loopWaitParams)) newProps.loopWaitParams = loopWaitParams;
		if (!zot(loopWaitCall)) newProps.loopWaitCall = loopWaitCall;
		if (!zot(loopParams)) newProps.loopParams = loopParams;
		if (!zot(loopPick)) newProps.loopPick = loopPick;
		if (!zot(rewind)) newProps.rewind = rewind;
		if (!zot(rewindWait)) newProps.rewindWait = rewindWait;
		if (!zot(rewindCall)) newProps.rewindCall = rewindCall;
		if (!zot(rewindParams)) newProps.rewindParams = rewindParams;
		if (!zot(rewindWaitCall)) newProps.rewindWaitCall = rewindWaitCall;
		if (!zot(rewindWaitParams)) newProps.rewindWaitParams = rewindWaitParams;

if (!zot(startCall)) newProps.startCall = startCall;
		if (!zot(startParams)) newProps.startParams = startParams;
		if (!zot(animateCall)) newProps.animateCall = animateCall;
		if (!zot(animateParams)) newProps.animateParams = animateParams;

if (zot(rate)) rate = 1;

if (!zot(props)) newProps = zim.merge(newProps, cjsProps); // cjsProps to overwrite
		cjsProps = newProps;
		
		// convert dot property format
		zim.loop(obj, function (o, v) {
			if (typeof o == "string") {
				var sp = o.split("."); // add a dot at start for CreateJS dot plugin
				if (sp.length > 1 && o.substr(0,1)!=".") {
					obj["."+o] = v;
					delete obj[o];
					o = "."+o;
				}
				// handle createjs needing + sign (sigh) for dot plugin
				if (sp.length > 1 && typeof v == "string") {
					var sub = v.substr(0,1);
					if (sub != "+" && sub != "-") obj[o] = "+" + v;
				}
			}
		});

// handle setting value with dot property format
		// (target, "rotation.x", 200) for instance
		function setValue(what, prop, val) {	
			if (prop.substr(0,1) == ".") {
				var dots = prop.split(".");
				var lastdot = what;
				for (var i=1; i<dots.length-1; i++) {
					lastdot = lastdot[dots[i]];
				}
				lastdot[dots[dots.length-1]] = val;
			} else {
				what[prop] = val;
			}
		}

// this was down below but meant series was always starting from last tween's zimTweenOriginals
		target.zimTweenOriginals = {};
		
		// SEQUENCE HANDLING
		// handle multiple targets first if there is an array
		// this just recalls the animate function for each element delayed by the sequence parameter
		// if (zot(sequence)) sequence = 0;

if (!zot(sequence) && target.addChild) { // container with sequence so convert target to array
			var newTarget = [];
			for (i=0; i<target.numChildren; i++) {
				newTarget.push(target.getChildAt(i));
			}
			sequenceTarget = target;
			target = newTarget;
			sequenceTarget.animating = true;
		}
		function sequenceDone() {
			if (call) call(params||sequenceTarget);
		}

// PREPARE ZIK RANDOM VALUES PASSED IN AS ARRAY OR RAND OBJECT {min, max, integer, negative}
		var extraTypes = ["extra", "zoom", "speed", "layer", "fade"];
		var extraLookup = {zoom:target.type=="Pen"?"size":"scale", speed:"percentSpeed", layer:"layer", fade:"alpha"};
	
		if (target instanceof Array) {
			if (sequenceReverse) target.reverse();
			
			for (i=0; i<target.length; i++) {

var tar = target[i];
				if (from) {
					var val;
					tar.zimObj = {};
					for (prop in obj) {
						if (extraTypes.indexOf(prop) >= 0) val = obj[prop];						
						else val = zim.Pick.choose(obj[prop]);
						tar.zimObj[prop] = tar[prop];

// calculate relative -- ZIM 10.7.1 patch
						if (typeof val == "string" && prop != "transform") {
							var newStart;
							if (tar.zimLastObj && !zot(tar.zimLastObj[prop])) newStart = tar.zimLastObj[prop];
							else newStart = tar[prop];
							val = newStart + Number(val.replace(/\s/g,""));
						}
						if (tar.zimLastObj) tar.zimLastObj[prop] = rewind?tar.zimTweenOriginals[prop]:obj[prop];
						tar[prop] = val;
					}
				} else {
					tar.zimObj = {};
					for (prop in obj) {
						if (extraTypes.indexOf(prop) >= 0) tar.zimObj[prop] = obj[prop];
						// else tar.zimObj[prop] = zim.Pick.choose(obj[prop]);
						else tar.zimObj[prop] = obj[prop]; // let pick go through... 10.8.0
					}
				}
				var rrr = rate;
				if (!zot(sequenceRatio)) {
					rrr = rate + (tar.ratio?tar.ratio:0);
				}
				var seqTime = i*sequence;
				if (i==0 && sequence!=0) seqTime = timeType=="s"?.02:20; // patched in 10.7.0 and 10.7.1
								
				// zim.animate(tar, tar.zimObj, time, ease, (i==target.length-1?call:null), (i==target.length-1?params:null)			
				zim.animate(tar, tar.zimObj, time, ease, (i==target.length-1?sequenceDone:null), null, wait, waitedCall, waitedParams, null, null, null, null, null, null, null, loopPick, null, null, null, null, null, null, rewindTime, rewindEase, startCall, startParams, animateCall, animateParams, null, sequenceCall, sequenceParams, null, null, ticker, zim.copy(cjsProps), css, protect, override, null, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, seqTime, rrr, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck, noAnimateCall, pathDamp, rewindPick, style, group); // do not send from!
	
			}
			return sequenceTarget;
		}

// DEFAULTS
		var t = time;
		var t2 = rewindTime;
		if (zot(t)) t = timeType=="s"?1:1000;
		if (zot(rewindTime)) rewindTime = t2 = t;
		if (zot(ease)) ease = "quadInOut";
		if (zot(wait)) wait = 0;
		if (zot(rewindWait)) rewindWait = 0;
		if (zot(cjsProps)) cjsProps = {override: (!zot(target.zimX) && !zot(obj.x) || !zot(target.zimY) && !zot(obj.y))};
		if (zot(params)) params = target;
		if (zot(ticker)) ticker = true;
		if (zot(css)) css = false;
		var originalProtect = protect;
		if (zot(protect)) protect = false;
		if (zot(from)) from = false;
		if (zot(set)) set = {};
		if (set.scale) {set.scaleX = set.scaleY = set.scale; delete set.scale;}
		if (!zot(override)) cjsProps.override = override;
		if (zot(drag)) drag = false;
		if (zot(startPaused)) startPaused = drag&&cjsProps.path?true:false;
		if (zot(dynamic)) dynamic = false;
		if (zot(clamp)) clamp = true;
		if (zot(clean)) clean = true;
		if (zot(pathDamp)) pathDamp = .15;
		
		
		// tweens are separated - this is used to set the CreateJS timeScale	
		// the rate parameter is not used after this 
		// the rate property sets the target.futureRate 
		// but also applies the timeScale to all tweens on the object
		// individual timeScale can be set by using target.zimTweens[id].timeScale = 2; 
		// after the rate has been called
		target.futureRate = rate; 
		
		var tween;
		var idSet;
		var providedID;

// ANIMATION SERIES HANDLING
		// if an array is passed in to animate() as the obj
		// then animate treats this as an animation series
		// [{target:circle, obj:{alpha:0}, time:1}, {target:rect, obj:{alpha:0}, time:1}]

if (obj instanceof Array) {
			currentCount = 1;
			if (obj.length == 0) return this;
			var starts;
			var lastParamTarget;

prepareSeries();
			prepareIds();
			runMaster();
		
			return target;
		} // end series
		
		function runMaster() { // one day might consider reverse... or do this by animating percentComplete backwards
			if (target.zimLastObj) {
				zim.loop(target.zimLastObj, function (i) {
					if (zot(target.zimTweenOriginals[i])) return; // next in loop
					target[i] = target.zimTweenOriginals[i];
					target.zimLastObj[i] = target.zimTweenOriginals[i];
				});
			}
			var o; // inner obj
			var w = wait; // time for wait before starting animation
			var lastEnd = 0; // time of last label end
			var duration; // time of each label animation not including initial wait
			var durationRewind;
			for (var i=0; i<obj.length; i++) {
				o = obj[i];
				if (zot(o.target)) continue;
				if (zot(o.time)) o.time = t;
				w += (o.wait?o.wait:0);
				duration = o.time;

if (animateCall) {
					if (o.animateCall) {
						-function() {
							var originalCall = o.animateCall;
							var originalParams = o.animateParams;
							var generalCall = animateCall;
							var generalParams = animateParams;
							o.animateCall = function(target) {
								originalCall(originalParams||target);
								generalCall(generalParams||target);
							}
						}();						
					} else {
						o.animateCall = animateCall;
						o.animateParams = animateParams;
					}
				}
				
				durationRewind = (zot(o.rewindTime)?duration:o.rewindTime);
				if (o.rewind) duration = duration + durationRewind + (o.rewindWait?o.rewindWait:0);
				if (o.loop) {
					// if loopCount is 0 (forever) then prepare series makes this the last animation
					duration *= o.loopCount;
					duration += (o.loopCount-1) * (o.loopWait?o.loopWait:0);
				}
				if (zot(o.params)) o.params = o.target;
				lastParamTarget = o.target;
				if (w < 0) {
					lastEnd += w;
					w = 0;
				}
				var currentObj = {
					target:o.target,
					obj:zim.copy(o.obj),
					seriesWait:lastEnd,
					wait:w,
					waitedCall:o.waitedCall,
					waitedParams:o.waitedParams,
					time:o.time,
					ease:o.ease,
					from:o.from,
					rewind:o.rewind,
					call:o.call,
					params:o.params,
					loop:o.loop, loopCount:o.loopCount, loopWait:o.loopWait,
					loopCall:o.loopCall, loopParams:o.loopParams,
					loopWaitCall:o.loopWaitCall, loopWaitParams:o.loopWaitParams,
					loopPick:o.loopPick,
					rewindWait:o.rewindWait,
					rewindCall:o.rewindCall, rewindParams:o.rewindParams,
					rewindWaitCall:o.rewindWaitCall, rewindWaitParams:o.rewindWaitParams,
					rewindTime:o.rewindTime, rewindEase:o.rewindEase,
					startCall:o.startCall,
					startParams:o.startParams,
					animateCall:o.animateCall,
					animateParams:o.animateParams,
					set:zim.copy(o.masterSet),
					events:events,
					rate:target.futureRate,
					pauseOnBlur:o.pauseOnBlur,
					easeAmount:o.easeAmount, easeFrequency:o.easeFrequency,
					override:false,
					id:id,
					clean:(loop||o.loop)?true:clean // need to clean if looping
				};
				if (i == obj.length-1) {
					endSeries(currentObj);
				}					
				zim.animate(currentObj);
				lastEnd += w + duration;
				w = 0;
			}
		}
		function endSeries(currentObj) {
			var savedCall = currentObj.call;
			var savedParams = currentObj.params;
			if (cjsProps.loop && (!cjsProps.count || currentCount < cjsProps.count)) {
				currentObj.call = function() {					
					if (savedCall && typeof savedCall == 'function') {(savedCall)(savedParams||target);}
					if (cjsProps.loopCall && typeof cjsProps.loopCall == 'function') {(cjsProps.loopCall)(cjsProps.loopParams||target);}
					if (cjsProps.loopWait) {
						if (zot(target.zimTweens)) target.zimTweens = {};
						tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override}).wait(cjsProps.loopWait, true).call(goNext);
						tween.timeScale = target.futureRate;	
					} else {						
						goNext();
					}
					function goNext() {
						for (var k=0; k<starts.objects.length; k++) {
							if (starts.objects[k].set) starts.objects[k].set(starts.values[k]);
						}
						if (cjsProps.loopWaitCall && typeof cjsProps.loopWaitCall == 'function') {(cjsProps.loopWaitCall)(cjsProps.loopWaitParams||target);}
						runMaster();
					}
				};
			} else {	
				currentObj.call = function() {
					if (savedCall && typeof savedCall == 'function') {(savedCall)(savedParams);}
					if (zot(params)) params = lastParamTarget;
					if (call && typeof call == 'function') {(call)(params);}
					// endTween(id); // removed ZIM 015 to support Timeline - do not think this is needed...
					target.zimLastObj = null; // ami fix 10.7.1
				};
			}
			currentCount++;
		}
		function prepareSeries() {

// store all props in seriesTweens for target
			// and all the calls in seriesCalls (including last call)
			// used in endTween() method
			if (target && !target.seriesTweens) {
				target.seriesTweens = [];
				target.seriesCalls = [];
				target.seriesParams = [];
			}
			var o;
			for (var i=0; i<obj.length; i++) {
				o = obj[i];
				if (o.target) {
					if (!o.target.seriesTweens) o.target.seriesTweens = [];
					if (!o.target.seriesCalls) o.target.seriesCalls = [];
					if (!o.target.seriesParams) o.target.seriesParams = [];
					o.target.seriesTweens.push(o.props);
					o.target.seriesCalls.push(o.call);
					o.target.seriesParams.push(o.params);
				} else {
					target.seriesTweens.push(o.props);
					target.seriesCalls.push(o.call);
					target.seriesParams.push(o.params);
				}
			}
			target.seriesCalls.push(call);
			target.seriesParams.push(params);

// loop backwards and get original properties
			// only works if series of same object (most common)
			o = obj[0];
			var ttar;
			if (!target) ttar = o.target;
			else ttar = target;
			ttar.zimSeriesOriginals = {};
			for (i=obj.length-1; i>=0; i--) {
				o = obj[i];
				if (zot(o.props) && !zot(o.obj)) o.props = o.obj;
				o.obj = o.props;
				zim.loop(o.obj, function (oo) {
					// using string property name on zimTweenOriginals (just storing)
					if (oo == "path") ttar.zimSeriesOriginals[oo] = obj[oo];
					else ttar.zimSeriesOriginals[oo] = getValue(ttar, oo); // dot property
				});
			}

var froms = new zim.Dictionary();
			starts = new zim.Dictionary();
			for (i=0; i<obj.length; i++) {
				o = obj[i];
				if (!target) target = o.target;
				if (zot(o.target)) o.target = target;
				if (zot(o.ease)) o.ease = ease;
				if (zot(o.target)) continue;

if (i==0) o.target.zimSeriesArgs = startArguments;

if (zot(o.props) && !zot(o.obj)) o.props = o.obj;
				o.obj = o.props;
				if (o.loopCall || o.loopWait || o.loopPick || o.loopCount) o.loop = true;
				if (o.rewindCall || o.rewindWait || o.rewindPick || o.rewindTime || o.rewindEase) o.rewind = true;
				if (o.loop && (zot(o.loopCount) || o.loopCount <= 0)) {
					o.loopCount = 0;
					// this object is looping forever so no point in keeping any next objects
					obj.splice(i+1, obj.length); // obj.length may be too much but it works
				}
				if (!zot(o.obj.scale)) {
					o.obj.scaleX = o.obj.scaleY = o.obj.scale;
					delete o.obj.scale;
				}

if (o.from) {
					var firstFrom = froms.at(o.target);					
					if (firstFrom) {
						if (o.set) {
							// all properties from obj go to set
							// matching firstFrom properties to to obj
							// matching set properties override firstFrom on obj
							var temp = zim.copy(o.obj);
							var merged = zim.merge(firstFrom, o.set);
							o.obj = getFroms(o.target, o.obj, merged);
							o.set = zim.merge(o.set, temp);
						} else {
							o.set = zim.copy(o.obj);
							o.obj = getFroms(o.target, o.obj, firstFrom);
						}
						o.from = false;
					} else {
						// any set properties override target properties
						froms.add(o.target, getFroms(o.target, o.obj, o.set));
					}
				}
				var startProps = {};
				for (var iii in o.obj) {
					startProps[iii] = o.set?(o.set[iii]?o.set[iii]:o.target[iii]):o.target[iii];
				}
				if (zot(starts.at(o.target))) starts.add(o.target, {});
				var newEntry = zim.merge(starts.at(o.target), startProps);
				starts.remove(o.target);
				starts.add(o.target, newEntry);
				o.masterSet = zim.copy(o.set);
			}
			if (zot(target.zimTweens)) target.zimTweens = {};
		} // end prepareSeries

if (obj) {
			if (obj.x) target.zimX = true;
			if (obj.y) target.zimY = true;
		}

// SHAPE TWEEN
		if (!zot(obj.shape) && obj.shape.type == target.type && (target.type=="Blob" || target.type == "Squiggle")) {
			
			var targetPoints = target.pointObjects;
			var shapePoints = obj.shape.pointObjects;
			if (targetPoints.length != shapePoints.length) {
				if (zon) zogy("animate() - shapes must be of same number of points");
				delete obj.shape;
			} else {
				// var shape = obj.shape;
				delete obj.shape;
				var blobShift = zot(obj.blobShift)?0:obj.blobShift;
				delete obj.blobShift;
				var first = true;
				for (i=0; i<targetPoints.length; i++) {
					var targetPoint = targetPoints[i];
					var shapePoint = shapePoints[(targetPoints.length*20000+i+blobShift)%targetPoints.length];
					// loop through the first four elements of the points array
					// the first element is the point container
					// the second is the circle inside (we leave this alone)
					// the third and forth are the two control rectangles
					for (j=0; j<4; j++) {
						if (j==1) continue;
						var controls = targetPoint[j];
						// var shapeControls = shapePoint[j];
						// animate the control to the location of shapePoint
						// this will animate the whole control container when j=0
						// and the two rectangle control handles when j=2 and j=3
						var animateParameters = zim.copy(startParameters);
						animateParameters[0] = controls;
						animateParameters[1] = {x:shapePoint[j].x, y:shapePoint[j].y, rotation:shapePoint[j].rotation};
						// ~~~~~~~~~~~~~~
						// PARAMETER WARNING - this needs to be changed if parameter order changes!
						// ~~~~~~~~~~~~~~
						if (first) {
							animateParameters[42] = true; // events
							if (controls.animateEvent) controls.off("animation", controls.animateEvent, null, mID);
							controls.animateEvent = controls.on("animation", function () {
								target.update();
							}, null, null, null, null, mID);
						}
						first = false;						
						zim.animate.apply(zim.animate, animateParameters);
					}
				}
				if (zim.isEmpty(obj)) return target;
			}
		}

// props, time, ease, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startCall, startParams, animateCall, animateParams, sequence, sequenceCall, sequenceParams, sequenceReverse, sequenceRatio, ticker, cjsProps, css, protect, override, from, set, id, events, sequenceTarget, dynamic, drag, clamp, startPaused, clean, obj, seriesWait, sequenceWait, rate, pauseOnBlur, easeAmount, easeFrequency, timeUnit, timeCheck, noAnimateCall, pathDamp, rewindPick

// -----------------------------
		// NORMALIZED TWEEN COMING THROUGH
				
		if (zot(target)) return;		
		if (!target.tweenStates) target.tweenStates = {all:true};

function isGetter (obj, prop) {
			return !!Object.getOwnPropertyDescriptor(obj, prop)['get'];
		}

if (target.type == "Sprite" || !Object.prototype.hasOwnProperty.call(target,"paused")) {
			Object.defineProperty(target, 'paused', {
				get: function() {
					return target.animatePaused;
				},
				set: function(value) {
					target.animatePaused = value;
				}
			});
			if (target.type != undefined) target.paused = true;
			target.animating = false;
		}	
		
		// FOR END, RESET AND START of TWEEN
		target.endTween = function(callType, ids) {
			target.stopAnimate(ids);

if (callType != "all" && callType != "main" && callType != "none") callType = "all";

if (!target.seriesTweens) {
				zim.loop(target.zimLastObj, function (o) {
					if (typeof target.zimLastObj[o] == "string" && o != "transform") {
						target.zimLastObj[o] = target[o] + Number(target.zimLastObj[o].replace(/\s/g,""));
					}
					setValue(target, o, target.zimLastObj[o]);					
				});
				// zim.loop(obj, function (o) {
				// 	if (typeof obj[o] == "string") {
				// 		obj[o] = target[o] + Number(obj[o].replace(/\s/g,""));
				// 	}
				// 	setValue(target, o, obj[o]);
				// });
				if (callType != "none" && call) call(params);
			} else {

zim.loop(target.seriesTweens, function(objSeries, i) {
					zim.loop(objSeries, function (o) {
						if (typeof objSeries[o] == "string" && o != "transform") {
							objSeries[o] = target[o] + Number(objSeries[o].replace(/\s/g,""));
						}
						setValue(target, o, objSeries[o]);
					});
					if (callType == "all") {
						if (target.seriesCalls[i]) target.seriesCalls[i](target.seriesParams[i]);
					}
				});
				if (callType != "none") {
					var lastCall = target.seriesCalls[target.seriesCalls.length-1];
					if (lastCall) lastCall(target.seriesParams[target.seriesParams.length-1]);
				}
				target.seriesTweens = null;
				target.seriesCalls = null;
				target.seriesParams = null;
			}

if (target.stage) target.stage.update();
			return target;
		};
		var effectCheck = false;
		zim.loop(obj, function (o, v) {
			// using string property name on zimTweenOriginals (just storing)
			if (o == "path") target.zimTweenOriginals[o] = obj[o];
			else target.zimTweenOriginals[o] = getValue(target, o); // dot property
			// if (target.effects) {	// commented because might be animating property before ever setting it		
				// replacing property that auto updates with property (Batch) that does not auto update - so we later batch the update
				if (o.match("hue")) {obj["hueBatch"] = v; delete obj.hue; effectCheck = true;}
				else if (o.match("saturation")) {obj["saturationBatch"] = v; delete obj.saturation; effectCheck = true;}
				else if (o.match("brightness")) {obj["brightnessBatch"] = v; delete obj.brightness; effectCheck = true;}
				else if (o.match("contrast")) {obj["contrastBatch"] = v; delete obj.contrast; effectCheck = true;}
				else if (o.match(/^.effects/)) {effectCheck = true;}
			// } 
		});
		
			
		target.resetTween = function(paused) {
			if (zot(paused)) paused = true;
			target.pauseAnimate();
			target.percent = null; // added ZIM Cat 04 patch
			target.startPercent = null;
			var origins = target.zimSeriesOriginals?target.zimSeriesOriginals:target.zimTweenOriginals;
			zim.loop(origins, function (o) {
				// actually needing to set real property on target
				if (o == "path") {
					target.percentComplete = 0;
					target.zimPath = origins[o];
					var startPoint;
					// if using traverse, a zimStartPercent is available
					if (target.zimStartPercent) startPoint = target.zimPath.getCurvePoint(target.zimStartPercent/100);
					else startPoint = target.zimPath.getCurvePoint(target.zimStartPercent/100);
					// target.zimPath.pointCircles[0]; // first point
					target.loc(startPoint.x, startPoint.y);
				}
				else setValue(target, o, origins[o]);
			});
			target.zimLastObj = null; // otherwise relative is wrong
			// need to actually put target at start point in case animation is done
			if (target.stage) target.stage.update();

target.stopAnimate();
			// path is removed from original object so add it back
			if (target.zimPath) startParameters[1].path = target.zimPath;
			if (!zot(target.zimStartRotation)) target.rotation = target.zimStartRotation;
			target.zimStartRotation = null;
			if (!zot(target.zimStartScaleX)) target.scaleX = target.zimStartScaleX;
			target.zimStartScaleX = null;
			if (!zot(target.zimStartScaleY)) target.scaleY = target.zimStartScaleY;
			target.zimStartScaleY = null;
			zim.animate.apply(null, target.zimSeriesArgs?target.zimSeriesArgs:startParameters);
			target.pauseAnimate(paused);
			return target;
		};

target.replayTween = function() {
			target.resetTween(false);
			return target;
		};
		if (obj.path || dynamic) {
			// can't risk turning percentComplete off when animation ends as only one per all animations
			// instead, evaluate how percentComplete is set when starting an animation
			// if there is a value and no getter setter or a value has been changed when not tweening
			// (this last is because the getter setter may have previously been set - once set, it is not removed)
			// then assumes percentComplete is desired else sets to 0 when starting an animation
			// the startPercentComplete is then examined once the animation starts
			var startPercentComplete;
			if (target.requestedPercentComplete) startPercentComplete = target.requestedPercentComplete;
			else if (target.percentComplete && !isGetter(target, "percentComplete")) startPercentComplete = target.percentComplete;
			// the below did not work as expected with the first value being assigned if true - weird - so made above
			// var startPercentComplete = target.requestedPercentComplete //|| (target.percentComplete && !isGetter(target, "percentComplete"))?target.percentComplete:null;
			target.requestedPercentComplete = null;
			if (zot(startPercentComplete)) startPercentComplete = 0;
			target.pathRatio = 0; // could be wrong setting this to 0
			target.zimStartRotation = target.rotation;
			target.percent = null; // added ZIM Cat 04 patch			
			if (!(target.parent && target.parent.type=="BeadsContainer")) target.startPercent = null; // NFT patch of Cat 04 patch
		}

if (css) ticker = false;
		if (zot(target.zimTweens)) target.zimTweens = {};

var stage;
		if (!css) {
			if (!target.stage) {
				if (WW.zdf) stage = WW.zdf.stage;
				else css = true;
			} else {
				stage = target.stage;
			}
		}

// moved these to before protect (to catch scale convert) - ZIM Cat
		// PREPARE ZIK RANDOM VALUES PASSED IN AS ARRAY OR RAND OBJECT {min, max, integer, negative}
		// moved to before color code - ZIM 017
		var savedPicks = {};
		for (i in obj) {
			// zogb(i)
			if (extraTypes.indexOf(i) >= 0) continue; // skip for extras
			savedPicks[i] = zim.copy(obj[i]); // store pre picked to use if loopPick is true
			obj[i] = zim.Pick.choose(obj[i], null, target);
		}
		if (!zot(obj.scale)) {
			obj.scaleX = obj.scaleY = zim.Pick.choose(obj.scale, null, target);
			delete obj.scale;
		}

// convert color tween - added protect for colorRange in ZIM 016
		var colorBusy = target.zimBusy && target.zimBusy.colorRange; 
		if (!colorBusy) {
			if (target.setColorRange && !zot(obj.color)) {
				var color = obj.color;
				delete obj.color;
				obj.colorRange = 1;
				target.setColorRange(target.color, color);
				target.colorRange = 0;
			} else if (obj.color && (target.material || target.isMaterial)) {	
				if (target.isMaterial) {
					zogy("ZIM animate - please animate the color on the mesh not the material");
					return target;
				}
				var coTarget = target;
				if (coTarget.cT) zim.Ticker.remove(coTarget.cT, mID, target);
				target = {val:0, zimTweens:{}, ticker:coTarget.cT};
				var startColor = coTarget.material.color.getHexString();
				var endColor = obj.color;
				obj = {val:1};			
				coTarget.cT = zim.Ticker.add(function() {
					var cc = zim.colorRange("#"+startColor, endColor, target.val);
					coTarget.material.color.set(cc);
				}, null, mID, target);
				if (call) {
					var oldCall = call;
					call = function() {
						if (coTarget.cT == target.ticker) { 
							oldCall(callParams||coTarget);
							zim.Ticker.remove(coTarget.cT, mID, target);
							coTarget.cT = null;
							target = null;
						}
					}
				} else {
					call = function() {
						if (coTarget.cT == target.ticker) {
							zim.Ticker.remove(coTarget.cT, mID, target);
							coTarget.cT = null;
							target = null;
						}
					}
				}
			}
		} else {
			if (obj.color) { // just to handle protect
				delete obj.color;
				obj.colorRange = 1;
			}
		}

// PROTECT LOOPS AND REWINDS WITH BUSY
		// if protected or a loop or rewind is currently running for any of these properties
		// then remove the property from obj as it is currently busy
		for(var o in obj) {
			if (!target.zimBusy) break;
			if (target.zimBusy[o]) delete obj[o];
		}
		if (zim.isEmpty(obj)) return; // nothing left to animate
		if (target.type != "Sprite") {
			if (target.type != undefined) target.paused = false;
			target.animating = true;
		} else { // sprite - adjusted in ZIM 015 patch... do not animate sprite if told to go to a specific frame... but not sure...
			for (var pro in obj) {
				if (pro != "normalizedFrame") {
					target.animating = true;
					break;
				}
			}
		}
		function addZimBusy() {
			if (originalProtect === false) return; 
			if (!target.zimMouseEnabledCheck) {
				target.zimMouseEnabledCheck = true;
				target.zimLastMouseEnabled = target.mouseEnabled;
			}
			target.mouseEnabled = false;
			setTimeout(function() {
				if (!target.zimBusy) target.zimBusy = {};
				for(var o in obj) {
					target.zimBusy[o] = true;
				}
				target.zimMouseEnabledCheck = null;
				target.mouseEnabled = target.zimLastMouseEnabled;
			}, 70);
		}
		if (protect || cjsProps.loop || cjsProps.rewind) addZimBusy();

// IDS and IDSETS
		// this is for ids and idSets on this target
		// a single tween for an id does not get an idSet
		// a second tween for the same id gets an idSet
		// the original id is the id for the idSet
		prepareIds();
		function prepareIds() {
			if (zot(id)) {
				id = zim.makeID(null,10);
			} else {
				id = String(id);
				providedID = id;
			}
			if (zot(target.zimIdSets)) target.zimIdSets = {};
			if (!zot(target.zimIdSets[id])) { // already an idSet
				idSet = id;
				id = zim.makeID(null,10);
				target.zimIdSets[idSet].push(id);
			} else if (target.zimTweens && !zot(target.zimTweens[id])) { // not an idSet but already a tween so make an idSet
				idSet = id;
				id = zim.makeID(null,10);
				// var idSet = target.zimTweens[id].zimIdSet;
				target.zimIdSets[idSet] = [idSet]; // add original into set
				target.zimTweens[idSet].zimIdSet = idSet; // reference back to idSet
				target.zimIdSets[idSet].push(id); // push the second one in
			} // else nothing - id is not currently part of idSet
		}

extraTypes.shift(); // take off extra for later
		for (i in set) set[i] = zim.Pick.choose(set[i], null, target);
		for (i in cjsProps) {
			if (i=="waitedCall" || i=="waitedParams" || i=="loopCall" || i=="rewindCall" || i=="loopWaitCall" || i=="rewindWaitCall" || i=="startCall" || i=="animateCall") continue;
			cjsProps[i] = zim.Pick.choose(cjsProps[i], null, target);
		}

// start NIO updates 1
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// PERCENT COMPLETE SETUP
		// if (target.getBounds && zot(target.percentCompleteCheck)) {
		if (zot(target.percentCompleteCheck)) {
			target.percentCompleteCheck = true;		
			target._percentComplete = 0;
			Object.defineProperty(target, 'percentComplete', {
				get: function() { 		
					if (target.paused) return target._percentComplete;
					if (target.tweenStartTime && target.tweenEndTime) {	
						// return if paused and however long is paused gets added to target.tweenStartTime and target.tweenEndTime
						// but then how does this affect the timeline?
						// maybe target.percentComplete is always based on time and it ignores pause 
						// whereas tween.percentComplete is based on the animation
						// maybe target.percentComplete should be percentTime 
						var dn = Date.now();	
						var nt;
						// loop is based on latest tween set
						if (cjsProps.loop && dn > target.tweenEndTime) {
							nt = (dn - target.tweenStartTime) % (target.tweenEndTime - target.tweenStartTime);
						} else {
							nt = dn - target.tweenStartTime;
						}		
						var v = Math.max(0, Math.min(100, nt / (target.tweenEndTime - target.tweenStartTime) * 100));
						target._percentComplete	= v;							
						return  v;
					} else {
						return 0;
					}
				},
				set: function(value) {	
					if (this.zimTween) {
						// STICK ON PATH BEFORE DRAG FIX
						immediateCheck = true;
						setPercent(value, true);
					} else {
						// to handle being set prior to a subsequent animation
						this.requestedPercentComplete = value;
					}					
					target._percentComplete = value;
					if (effectCheck) target.updateEffects();	
					if (animateCall && typeof animateCall == "function") animateCall(animateParams||target);
				}
			});

Object.defineProperty(target, 'percentCompleteNoAngle', {
				get: function() {					
					if (target.paused) return target._percentComplete; // needed to match percentComplete?  015
					if (target.tweenStartTime && target.tweenEndTime) {	
						var dn = Date.now();	
						var nt;
						// loop is based on latest tween set
						if (cjsProps.loop && dn > target.tweenEndTime) {
							nt = (dn - target.tweenStartTime) % (target.tweenEndTime - target.tweenStartTime);
						} else {
							nt = dn - target.tweenStartTime;
						}	
						var v = Math.max(0, Math.min(100, nt / (target.tweenEndTime - target.tweenStartTime) * 100));
						target._percentComplete	= v;						
						return  v;	
					} else {
						return 0;
					}
				},
				set: function(value) {
					if (this.zimTween) {
						setPercent(value, false);
					} else {
						// to handle being set prior to a subsequent animation
						this.requestedPercentComplete = value;
					}
					target._percentComplete = value;					
				}
			});
		}

} else {						
					target.zimTween.setPosition(Math.round(value*target.zimTween.duration/100));
				}
			} else {
				if (!zot(target.zimTween.currentTime)) {
					target.zimTween.currentTime = target.zimTween.currentTime - target.zimTween.position + value*target.zimTween.duration/100;
				}
			}
			if (setAngle && pathObject && obj.orient !== false && pathObject.getCurvePoint) {		
				target.rotation = pathObject.getCurvePoint(target.pathRatio, null, null, true).angle + (startAngle?startAngle:0);
			}

// STICK ON PATH BEFORE DRAG FIX
			if (immediateCheck && typeof pathPercent != "undefined") pathPercent = value;
			if (target.handlePath) target.handlePath();
		}

// PATH ANIMATION SETUP
		var pathObject,newPoint,locPoint,segments;
		if (!zot(obj.path) && obj.path.segmentPoints) {
			if (zot(obj.orient)) obj.orient = true;
			if (obj.orient && zot(obj.flip)) obj.flip = true;
			if (target.type == "Pen") target.infinite = true;
			target.zimOnPath = true;
			if (zot(target.pathRatio)) target.pathRatio = 0;
			if (obj.orient===true) {
				obj.orient = obj.path;
			}
			if (obj.orient) {
				obj.startOrient = obj.rotation; // ?
			}
			pathObject = obj.path;
			// ZIM 10.7.0 ---			
			if (drag) {
				delete obj.path;
				delete obj.percent;
				if (zon && (target.startPercent && target.startPercent>0) || (target.percent && target.percent!=100)) zogy("ZIM.animate() - startPercent and percent currently not supported with drag on path");
				// old code from 10.6.1 -
				newPoint = pathObject.getCurvePoint(target.pathRatio, percents, segments);
				if (newPoint) {
					// latestSegmentIndex = newPoint.z; // point on path before the calculated point - used with drag
					locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
					target.x = locPoint.x;
					target.y = locPoint.y;
				}
			} else {
				if (zot(target.startPercent)) {
					target.startPercent = zim.Pick.choose(!zot(obj.startPercent)?obj.startPercent:0, null, target);
				}
				if (zot(target.percent)) {
					target.percent = zim.Pick.choose(!zot(obj.percent)?obj.percent:100, null, target);
				}
				delete obj.path;
				delete obj.percent;
			}
			// ---
			var dynamicPath = !pathObject.lockControls;
			delete obj.path;
			obj.pathRatio = 1; // this is what we are animating to
		}
		
		// PREPARE START VALUES - now that pathRatio is set
		// moved to prepareRelative
		// if (from) obj = getFroms(target, obj, set, true);
		var startObj = {} // for later getStart()
		function getFroms(target, obj, set, update) {
			
			fromCheck = true;
			// animating based on pathRatio - but API is percentComplete
			// with from set, this causes problems - so add pathRatio equal to percentComplete to set
			if (pathObject && (!zot(target.percentComplete) || (set && !zot(set.percentComplete)))) {
				if (!set) set = {};
				if (zot(set.pathRatio)) set.pathRatio = !zot(set.percentComplete) ? set.percentComplete/100 : target.percentComplete/100;
			}
			var newObj = {};
			for (i in obj) {
				if (set && !zot(set[i])) {
					newObj[i] = set[i];
				} else {
					if (i.match(/\./)) { // handle dot props like threejs - patched ZIM 018						
						var bunch = i.split(/\./g);						
						if (bunch[0]=="") bunch.shift(); // sometimes has dot on front and sometimes not
						newObj[i] = target[bunch[0]][bunch[1]];
					} else {
						newObj[i] = target[i];
					}
				}
				if (update) {
					if (i.match(/\./)) target[bunch[0]][bunch[1]] = obj[i];
					else target[i] = obj[i];
				}				
			}
			return newObj;
		}

// var lastPercentComplete = target.percentComplete;
		var flipCheck = true; // if we can flip - not same as pathFlip
		var mouseCheck = false;
		var activeCheck = true;
		// var latestSegmentIndex = 0;

var redirect=true;
		if (!zot(obj.redirect)) {
			redirect=obj.redirect;
			delete obj.redirect;
		}

// CONTINUE PATH ANIMATION SETUP
		
		function getPathPercent(e) {
			var point = pathObject.globalToLocal(e.rawX/zim.scaX, e.rawY/zim.scaY);
			var mousePlace = currentDist;
			// do not change currentForward if no change in dirSamples
			if (pathObject.type == "Blob") {
				if (dirSamples[0] < dirSamples[4]) currentForward = true;
				else if (dirSamples[0] > dirSamples[4]) currentForward = false;
				if (mousePlace < 10 && !currentForward) {
					targetDist = currentDist = mousePlace = length-5;
					dampPercent.immediate(targetDist/length*100);
					dirSamples=[length-1,length-2,length,length-3,length-4];
				} else if (mousePlace > length-10 && currentForward) {
					targetDist = currentDist = mousePlace = 5;
					dampPercent.immediate(targetDist/length*100);
					dirSamples=[0,0,0,0,0];
				}
			}
			// thanks https://codepen.io/eliCrow/pen/MLdddR
			var dPoint = {x:point.x, y:point.y, r:mousePlace};
			testPoints.sort(function (a, b) {
				var aPoint = {x:a.x, y:a.y, r:a.r*length};
				var bPoint = {x:b.x, y:b.y, r:b.r*length};
				var aDiff = Math.sqrt(Math.pow(dPoint.x-aPoint.x, 2)+Math.pow(dPoint.y-aPoint.y, 2)+Math.pow(dPoint.r-aPoint.r, 2));
				var bDiff = Math.sqrt(Math.pow(dPoint.x-bPoint.x, 2)+Math.pow(dPoint.y-bPoint.y, 2)+Math.pow(dPoint.r-bPoint.r, 2));
				return aDiff-bDiff;
			});
			targetDist = testPoints[0].r*length;
			pathPercent = targetDist/length*100;
			pathPercent = zim.constrain(pathPercent,0,99.95); // get rid of end glitch
			if (rewind) { // handle rewind
				pathPercent/=2;
				if (tween.position > tween.duration/2) pathPercent = 100-pathPercent;
			}
            target._percentComplete = pathPercent
		}	
		
		if (pathObject) {
			var percents;
			if (!dynamicPath) {
				segments = zim.copy(pathObject.segmentPoints);
				percents = zim.copy(pathObject.segmentRatios);
			}
			// drag does not pay attention to this...
			target.currentPercent = target.startPercent + target.percent*target.pathRatio;
			var newPointRatio = ((1000000+target.currentPercent)%100)/100;
			newPoint = pathObject.getCurvePoint(newPointRatio, percents, segments);

if (target.parent && newPoint) {
				locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
				target.x = locPoint.x;
				target.y = locPoint.y;
			}

target.zimAnimateDragDown = target.on("mousedown", function (e) {					
					stage = e.target.stage;
					if (!target.amu) target.amu = stage.frame.on("mouseupplus", function() {					
						mouseCheck = false;				
					}, null, null, null, null, mID);		
					stage.mouseMoveOutside = true;
					flipCheck = false; // sometimes picking up target changes its direction - not good
					activeCheck = true;
					setTimeout(function() {
						flipCheck = true;
					}, 50);
					mouseCheck = true;

if (pathObject.zimAnimateChanged) {
						segments = zim.copy(pathObject.segmentPoints);
						length = 0;
						zim.loop(segments, function (point) {
							length+=zim.distanceAlongCurve(point);
						});
						numPoints = Math.round(length/segments.length/pixels);
						testPoints = pathObject.interpolate(numPoints, null, true, null, true);
						// segmentRatios = zim.copy(pathObject.segmentRatios);
					}

pathObject.zimAnimateChanged = false;
					pathPercent = getP(target);
					dampPercent.immediate(pathPercent);
					// var calcPercent = dirTest = pathPercent;
					var calcPercent = pathPercent;
					if (rewind) { // handle rewind
						if (tween.position > tween.duration/2) calcPercent = (100-pathPercent)*2;
						else calcPercent = pathPercent*2;
					}
					currentDist = (calcPercent?calcPercent:0)/100*length;
					targetDist = currentDist;
				}, null, null, null, null, mID);

var movingCheck = false;
				target.zimAnimateDragPress = target.on("pressmove", function(e) {movingCheck=true; getPathPercent(e);}, null, null, null, null, mID);

target.animateReturn = function() {
					if (!rewind) {
						if (zon) zogy("animate() - animateReturn() needs rewind set to true");
						return;
					}
					lastForward = false;
					currentForward = false;
					if (getP(target) < 50) setP(target, 100-getP(target));
					target.pauseAnimate(false);
				};

target.zimAnimateDragUp = target.on("pressup", function () {
					if (target.paused==false) mouseCheck = false;
					flipCheck = false;
					setTimeout(function() {
						flipCheck = true;
					}, 50);
					// do not change currentForward if no change in dirSamples
					if (dirSamples[0] < dirSamples[4]) currentForward = true;
					else if (dirSamples[0] > dirSamples[4]) currentForward = false;
					if (!target.paused && rewind && redirect && currentForward != lastForward) {						
						setP(target, 100-getP(target));
						lastForward = currentForward;
						// can't seem to get this to change direction when
						// dragging when paused and then unpausing direction
					}
				}, null, null, null, null, mID);

var dampPercent = new zim.Damp(pathPercent, pathDamp);
				var lastPercent = 0;
				var dirCount = 0;
				var dirSamples = [0,0,0,0,0];

// STICK ON PATH BEFORE DRAG FIX
				var immediateCheck = false;

target.zimDragAnimateTicker = zim.Ticker.add(function () {
					var newPercent;
					if (!drag) return; // might be paused
					if (++dirCount%20) {
						dirSamples.push(targetDist);
						dirSamples.shift();
					}
					currentDist = targetDist;
					// this was still running (due to easing) when unpaused so set mouseCheck to false in pause() script to solve

// 10.6.0 patch to make pauseAnimate work again after breaking in 10.4.0 (there is another part to this patch too)
					// mouseCheck = true;

if (pathDownCheck) pathPercent = getP(target); // ZIM Cat fix

if (mouseCheck || (activeCheck && target.paused==true)) {
						// STICK ON PATH BEFORE DRAG FIX (immediateCheck added)
						if (pathDownCheck || immediateCheck || (pathObject.type == "Blob" && Math.abs(lastPercent-pathPercent)>(rewind?45:90))) {
							pathDownCheck = false;
							newPercent = pathPercent;
							dampPercent.immediate(newPercent);
							immediateCheck = false;
						} else {
							newPercent = dampPercent.convert(pathPercent);
						}
						// target.percentComplete = newPercent;
						if (Math.abs(lastPercent-newPercent)>.1) {
							setP(target, newPercent);
							lastPercent = newPercent;
						} else {
							setP(target, newPercent);
							//if (!mouseCheck) {
								activeCheck = false;
							//}
							movingCheck = false;
						}
					} else {
						activeCheck = false; // otherwise goes to last drag after animation turned off
					}

}, stage, mID, target);
			}
		}

// ORIENTATION SETUP
		var pathOrient;
		if (obj.orient) {
			if (obj.orient === true) {
				var oPoint = target.parent.localToGlobal(!zot(obj.x)?obj.x:target.x, !zot(obj.y)?obj.y:target.y);
				obj.orient = {x:oPoint.x, y:oPoint.y};
			}
			pathOrient = obj.orient;
			delete obj.orient;

var startAngle = target.rotation;
			target.rotation = pathObject.getPointAngle(0) + startAngle;

// // FLIP SETUP
		// var pathFlip;
		// var startFlip;
		// if (obj.flip) {
		// 	pathFlip = obj.flip;
		// 	delete obj.flip;
		// 	startFlip = target.scaleX;
		// }
		// var pathFlipVertical;
		// var startFlipVertical;
		// if (obj.flipVertical) {
		// 	pathFlipVertical = obj.flipVertical;
		// 	delete obj.flipVertical;
		// 	startFlipVertical = target.scaleY;
		// }
		// 
		// var lastX=target.x;
		// var lastY=target.y;
		
		
		
		// FLIP SETUP
		var startFlip = target.scaleX,
			startFlipVertical = target.scaleY,
			pathFlip = obj.flip != undefined ? obj.flip : false,
			pathFlipVertical = obj.flipVertical != undefined ? obj.flipVertical : false;

var lastX=target.x;
		var lastY=target.y;
		
		
		// end NIO updates
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// LOOP AND REWIND SETUP
		var count = 0;
		if (cjsProps.loop) {
			if (!zot(cjsProps.count)) {
				count = cjsProps.count;
				delete cjsProps.count;
				currentCount = 1;
			}
		}
		var wait3 = 0;
		if (cjsProps.loopWait) {
			wait3 = cjsProps.loopWait;
			loopWait = cjsProps.loopWait; // for dynamic
			delete cjsProps.loopWait;
		}
		var call3;
		if (cjsProps.loopCall) {
			call3 = cjsProps.loopCall;
			delete cjsProps.loopCall;
		}
		var params3 = target;
		if (cjsProps.loopParams) {
			params3 = cjsProps.loopParams;
			delete cjsProps.loopParams;
		}
		
		// checkTIME will test to make sure they are in the right units probably
		if (WW.TIMECHECK && timeCheck) {
			if (t) checkTIME(t, timeType);
			if (t2) checkTIME(t2, timeType);
			if (wait) checkTIME(wait, timeType);
			if (wait2) checkTIME(wait2, timeType);
			if (wait3) checkTIME(wait3, timeType);
			if (loopWait) checkTIME(loopWait, timeType);
			if (cjsProps.rewindWait) checkTIME(cjsProps.rewindWait, timeType);
			if (seriesWait) checkTIME(seriesWait, timeType);
			if (sequenceWait) checkTIME(sequenceWait, timeType);
		}

var ttt = t;
		if (cjsProps.rewind) ttt += t2;
		// else ttt += t; // error?  removed in ZIM 015

target.zimTweenArgs = {
			time:ttt,
			wait:wait,
			wait2:wait2,
			wait3:wait3,
			loopWait:loopWait,
			rewindWait:cjsProps.rewindWait,
			seriesWait:seriesWait,
			sequenceWait:sequenceWait
		}

function doLoopCall() {			
			if (wait3>0) target.waiting = false;
			if (!cjsProps.loop) return; // added Cat 03 - was being called even if not looping
			if (sequenceCall && typeof sequenceCall == 'function') {				
				var sp = zot(sequenceParams) ? target : sequenceParams;
				(sequenceCall)(sp);
			}
			if (call3 && typeof call3 == 'function') {(call3)(params3||target);}			
			// added 10.8.0 for loopPick
			if (loopPick) {

// can't seem to get time to adjust - so use rate which sets createjs timeScale
				// tween.step.prev.t = 0
				// tween.step.prev.d = 2000
				// tween.step.t = 2000
				// tween.step.d = 2000
				// tween.step.prev.next.t = 0
				// tween.step.prev.next.d = 2000

var r = zim.Pick.choose(target.futureRate, null, target);
				if (!zot(target.futureRate)) tween.timeScale = r;

var adjustedScale;
				if (!zot(savedPicks.scale)) {
					adjustedScale = zim.Pick.choose(savedPicks.scale, null, target);
				}

if (!from) {

if (tween.step && tween.step.prev && tween.step.prev.props) {
						for (var i in tween.step.prev.props) {
							if (extraTypes.indexOf(i) >= 0) continue; // skip for extras
							var p = zim.Pick.choose(savedPicks[i], null, target);

// handle color at loop - ZIM 018
							if (i=="colorRange") i = "color"
							var p = zim.Pick.choose(savedPicks[i], null, target);
							if (i=="color") i = "colorRange";
							if (target.setColorRange && i=="colorRange") {
								target.setColorRange(target.color, p);
								continue;
							}

// ZIM ZIM 02 patch to make non-rewind work with loopPick
							// the difference seems to be using tween.step.prev for rewind and tween.step for non-rewind
							// we had tween.step.prev for both since the begining - we must not have tested on a non-rewind
							if (rewind) {
								if (!zot(savedPicks[i])) tween.step.prev.props[i] = p;
								if (i=="scaleX" && !zot(adjustedScale)) tween.step.prev.props.scaleX = adjustedScale;
								if (i=="scaleY" && !zot(adjustedScale)) tween.step.prev.props.scaleY = adjustedScale;
							} else {
								if (!zot(savedPicks[i])) tween.step.props[i] = p;
								if (i=="scaleX" && !zot(adjustedScale)) tween.step.props.scaleX = adjustedScale;
								if (i=="scaleY" && !zot(adjustedScale)) tween.step.props.scaleY = adjustedScale;
							}	
						}
					}
				} else {
					// can't seem to get from to work
					// at the moment sequence is not passing in from as it switches ahead of time
					// but just a plain from should work - just can't override the CreateJS tween
					// maybe it is a rewind issue...
					// if (tween.step && tween.step.props) {
					// 	for (var i in tween.step.props) {
					// 		if (extraTypes.indexOf(i) >= 0) continue; // skip for extras
					// 		if (!zot(savedPicks[i])) tween.step.props[i] = target[i] = zim.Pick.choose(savedPicks[i]);
					// 		if (i=="scaleX" && !zot(adjustedScale)) tween.step.props.scaleX = target.scaleX = adjustedScale;
					// 		if (i=="scaleY" && !zot(adjustedScale)) tween.step.props.scaleY = target.scaleY = adjustedScale;
					//
					// 	}
					// }
				}
			}			
		}
		var call4;
		if (cjsProps.loopWaitCall) {
			call4 = cjsProps.loopWaitCall;
			delete cjsProps.loopWaitCall;
		}
		var params4 = target;
		if (cjsProps.loopWaitParams) {
			params4 = cjsProps.loopWaitParams;
			delete cjsProps.loopWaitParams;
		}
		function doLoopWaitCall() {
			if (call4 && typeof call4 == 'function') {(call4)(params4||target);}
		}

// START

var call6;
		if (cjsProps.startCall) {
			call6 = cjsProps.startCall;
			delete cjsProps.startCall;
		}
		var params6;
		if (cjsProps.startParams) {
			params6 = cjsProps.startParams;
			delete cjsProps.startParams;
		}
		function doStartCall(tween) {				
			if (tween.startCalled) return;
			tween.startCalled = true;
			if (call6 && typeof call6 == 'function') {(call6)(params6||target);}
		}

// PERCENT TIME ADJUSTMENTS ZIM 015
		
		function setLatestTween(tween) {
			target.latestTween = tween;
			if (target.waiting) tween.startTime = Date.now();
			else tween.startTime = setStartTime;
			tween.zimLoop = loop;
			if (!target.animating) {
				target.pauseAnimate(true);
			}
			// if (zot(tween.percentComplete)) {
				Object.defineProperty(tween, 'percentComplete', {
					get: function() {
						return this.position / this.duration*100;
					},
					set: function(value) {
						this.setPosition(value*this.duration/100);
					}
				});
			// }
		}

// set the startTime of the actual tween based on a potential wait and series wait
		// also get a new target.tweenEndTime if there is a later end
		var dn = Date.now();
		if (!target.tweenStartTime) target.tweenStartTime = dn;
		if (!target.tweenEndTime) target.tweenEndTime = dn;
		var setStartTime = dn + (wait?wait:0) + (seriesWait?seriesWait:0);
		var newEnd = setStartTime + (ttt?ttt:0);
		if (newEnd > target.tweenEndTime) target.tweenEndTime = newEnd;
		
		
		// ADJUST EASE
		
		var customEases = [
			"ballisticIn", "ballisticOut", "ballisticInOut", 
			"snapIn", "snapOut", "snapInOut", 
			"slowmoIn", "slowmoOut", "slowmoInOut", 
		];
		if (customEases.indexOf(ease) != -1) {
			ease = assignEase(ease);
		}
		function assignEase(ease) {
			var ba = [0.4,0.75,0.9,.95];
			var sn = [0.99,-0.69,0.53,0.014];	
			var sm = [1.18,0.69,1,0.96];		
			
			if (ease == "ballisticIn") ease = zik(zim.zimEase(ba));
			else if (ease == "ballisticOut") ease = zik(zim.zimEase(ba).reverse());
			else if (ease == "ballisticInOut") ease = zik(zim.zimEase(ba, null, true)); // mirror
			else if (ease == "snapIn") ease = zik(zim.zimEase(sn));
			else if (ease == "snapOut") ease = zik(zim.zimEase(sn).reverse());
			else if (ease == "snapInOut") ease = zik(zim.zimEase(sn, null, true)); // mirror
			else if (ease == "slowmoIn") ease = zik(zim.zimEase(sm));
			else if (ease == "slowmoOut") ease = zik(zim.zimEase(sm).reverse());
			else if (ease == "slowmoInOut") ease = zik(zim.zimEase(sm, null, true)); // mirror
			return ease;
		}
		var ease2, finalEase, finalEase2
		if (cjsProps.rewind) {
			
			// flip second ease			
			if (ease) {				
				if (ease instanceof Function) { // zimEase
					ease2 = zik(ease.reverse());
				} else {
					// backIn backOut backInOut
					ease2 = ease;
					if (ease2.indexOf("InOut") == -1) {
						if (ease2.indexOf("Out") != -1) {
							ease2 = ease2.replace("Out", "In");
						} else if (ease2.indexOf("In") != -1) {
							ease2 = ease2.replace("In", "Out");
						}
					}
				}
			}
			if (rewindEase) {
				ease2 = rewindEase;
				if (customEases.indexOf(ease2) != -1) {
					ease2 = assignEase(ease2);
				}
			}
		}

if (ease instanceof Function) {			
			finalEase = ease;
		} else {
			var equation = "get" + ease.charAt(0).toUpperCase()+ease.slice(1);
			var ea = zik(easeAmount);
			var ef = zik(easeFrequency);
			if ((!zot(ea) || !zot(ef)) && createjs.Ease[equation]) {
				if (!zot(ef) && zot(ea)) ea = 1;
				if (!zot(ea) && zot(ef)) ef = .3*1.5;
				finalEase = createjs.Ease[equation](ea, ef);
			} else {
				finalEase = createjs.Ease[ease];
			}
			
		}
		if (ease2) {
			if (ease2 instanceof Function) {
				finalEase2 = ease2;
			} else {
				equation = "get" + ease2.charAt(0).toUpperCase()+ease2.slice(1);
				ea = zik(easeAmount);
				ef = zik(easeFrequency);
				if ((!zot(ea) || !zot(ef)) && createjs.Ease[equation]) {
					if (!zot(ef) && zot(ea)) ea = 1;
					if (!zot(ea) && zot(ef)) ef = .3*1.5;
					finalEase2 = createjs.Ease[equation](ea, ef);
				} else {
					finalEase2 = createjs.Ease[ease2];
				}
			}
		}

// ZIM 016 - HANDLE RE-ANIMATE - animating the same as already animating 
		// might override the tween so the previous does not finish 
		// and would not endTween() which removes tweens at id and turns off Ticker.
		// endTween(id);

// REWIND TWEENS
		
		function doRewindCall() {	
			// ADDED in ZIM 018

if (!from && rewindPick) {

var adjustedScale;
				if (!zot(savedPicks.scale)) {
					adjustedScale = zim.Pick.choose(savedPicks.scale, null, target);
				}

if (tween.step && tween.step.props) {
					for (var i in tween.step.props) {
						if (extraTypes.indexOf(i) >= 0) continue; // skip for extras

// handle color at rewind - ZIM 018
						if (i=="colorRange") i = "color"
						var p = zim.Pick.choose(savedPicks[i], null, target);
						if (i=="color") i = "colorRange";
						if (target.setColorRange && i=="colorRange") {
							target.setColorRange(p, target.color);
							continue;
						}

// also handle relative
						if (typeof p == "string" && i != "transform") {
							if (p.substr(0,1) != "+" && p.substr(0,1) != "-") {
								var newStart;
								if (target.zimLastObj && !zot(target.zimLastObj[i])) newStart = target.zimLastObj[i];
								else newStart = target[i];
								p = newStart + Number(p.replace(/\s/g,""));
							}
						}
						// end handle relative
						
						// target.zimLastObj[i] = rewind?target.zimTweenOriginals[i]:p;
						target.zimLastObj[i] = p;
								
						if (!zot(savedPicks[i])) {
							tween.step.props[i] = p; // sets the rewind property
							tween._stepHead.props[i] = p; // sets the start of a loop to end of rewind
						}
						if (i=="scaleX" && !zot(adjustedScale)) {
							tween.step.props.scaleX = adjustedScale;
							tween._stepHead.props.scaleX = adjustedScale;
						}
						if (i=="scaleY" && !zot(adjustedScale)) {
							tween.step.props.scaleY = adjustedScale;
							tween._stepHead.props.scaleY = adjustedScale;
						}
						
					}
				}
			}		
			// END ADDED in ZIM 018				
			
			if (wait2>0) target.waiting = false;
			if (call2 && typeof call2 == 'function') {(call2)(params2);}
		}
		function doRewindWaitCall() {				
			if (wait2>0) target.waiting = true;
			if (call5 && typeof call5 == 'function') {(call5)(params5);}
		}

function tween1(lastTween) {	
			if (!startTest)	{
				obj2 = getStart();				
				startTest = true;				
			} 			
			checkSets();
			// if (target.set && !from) target.set(set);	
			tween = target.zimTweens[id] =  target.zimTween = createjs.Tween.get(target, cjsProps)
				.call(doStartCall)				
				.to(obj, t, finalEase)				
				.call(doRewindWaitCall)
				.wait(wait2, true)
				.call(doRewindCall)
				// this is hard coded... need to inject a different obj2 into createjs tween
				// and activate the code in doStartCall that makes loop start at end of new rewind
				.to(obj2, t2, finalEase2) 
				.call(doneAnimating)
				.wait(wait3, true)
				.call(doLoopCall);
				
			tween.timeScale = target.futureRate;
			if (lastTween) transferIds(lastTween, tween);
			setZimTweenProps();
			setLatestTween(tween);
			
		}

// // This was calling wait tween even if wait is 0 - not sure if we need it... maybe
		// // switched as part of ZIM 015 changes - same with preTween1

// function preTween2(lastTween) {
		// 	prepareRelative2();		
		// 	if (wait > 0) target.waiting = true;
		// 	tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override}).wait(wait, true).call(function(){
		// 		wait = 0;
		// 		target.waiting = false;
		// 		tween2(tween);
		// 		if (waitedCall && typeof waitedCall == 'function') {(waitedCall)(zot(waitedParams)?target:waitedParams);}
		// 	});
		// 	tween.timeScale = target.futureRate;			
		// 	if (lastTween) transferIds(lastTween, tween);
		// 	setLatestTween(tween);
		// }
		function preTween2(lastTween) {			
			prepareRelative2();		
			if (wait > 0) {
				target.waiting = true;
				tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override}).wait(wait, true).call(function(){
					wait = 0;
					target.waiting = false;
					tween2(tween);
					if (waitedCall && typeof waitedCall == 'function') {(waitedCall)(zot(waitedParams)?target:waitedParams);}
				});
				tween.timeScale = target.futureRate;			
				if (lastTween) transferIds(lastTween, tween);
				setLatestTween(tween);
			} else {
				tween2(lastTween);
			}
		}
		function tween2(lastTween) {
			
			checkSets();
			// if (target.set && !from) {target.set(set);}
			tween = target.zimTweens[id] =  target.zimTween = createjs.Tween.get(target, cjsProps)
				.call(doStartCall)
				.to(obj, t, finalEase)				
				.call(doneAnimating)
				.wait(wait3, true)
				.call(doLoopCall);						
			tween.timeScale = target.futureRate;			
			if (lastTween) transferIds(lastTween, tween);
			setZimTweenProps();
			setLatestTween(tween);
		}
		
		if (cjsProps.rewind) {

var wait2 = 0;
			delete cjsProps.rewind;

// if need to access it later in dynamic
			rewind = true;
			rewindWait = cjsProps.rewindWait;

if (cjsProps.rewindWait) {
				wait2 = cjsProps.rewindWait;
				delete cjsProps.rewindWait; // not a createjs prop so delete
			}

var call2;
			if (cjsProps.rewindCall) {
				call2 = cjsProps.rewindCall;
				var params2 = cjsProps.rewindParams;
				if (zot(params2)) params2 = target;
				delete cjsProps.rewindCall;
				delete cjsProps.rewindParams;
			}			
			var call5;
			if (cjsProps.rewindWaitCall) {
				call5 = cjsProps.rewindWaitCall;
				var params5 = cjsProps.rewindWaitParams;
				if (zot(params5)) params5 = target;
				delete cjsProps.rewindWaitCall;
				delete cjsProps.rewindWaitParams;
			}			
			if (seriesWait > 0 || sequenceWait > 0 || wait > 0) { // do not want wait as part of future loops (use loopWait)
				if (seriesWait > 0 || sequenceWait > 0) {
					target.waiting = true;
					tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override})
						.wait(seriesWait>0?seriesWait:0, true)
						.wait(sequenceWait>0?sequenceWait:0, true)
						// .call(function(){
						// 	if (sequenceCall && typeof sequenceCall == 'function') {(sequenceCall)(zot(sequenceParams)?target:sequenceParams);}
						// })
						.call(function(target){
							target.waiting = false;
							sequenceWait = seriesWait = 0;
							preTween1(tween);
						});
					tween.timeScale = target.futureRate;
					setLatestTween(tween);
				} else {
					preTween1();
				}
			} else {
				prepareRelative2();
				tween1();
			}

} else {  // NOT REWIND TWEENS

if (seriesWait > 0 || sequenceWait > 0 || wait > 0) { // do not want wait as part of future loops (use loopWait)
				
				if (seriesWait > 0 || sequenceWait > 0) {		
					target.waiting = true;					
					tween = target.zimTweens[id] = target.zimTween = createjs.Tween.get(target, {override:cjsProps.override})
						.wait(seriesWait>0?seriesWait:0, true)
						.wait(sequenceWait>0?sequenceWait:0, true)
						// .call(function(){
						// 	if (sequenceCall && typeof sequenceCall == 'function') {(sequenceCall)(zot(sequenceParams)?target:sequenceParams);}
						// })
						.call(function(){
							sequenceWait = seriesWait = 0;
							target.waiting = false;
							preTween2(tween);
						});
						tween.timeScale = target.futureRate;
						setLatestTween(tween);
				} else {
					preTween2();
				}
			} else {
				prepareRelative2();	
				tween2();
			}			
		}

tween.startPaused = startPaused; // turned off by pause(false) or pauseAnimate(false) or setting percentComplete
		tween.rewinding = false;

if (!zot(rate)) tween.timeScale = zim.Pick.choose(rate, null, target);

// ANIMATE CALL
		if (cjsProps.animateCall) {
			animateCall = cjsProps.animateCall;
			delete cjsProps.animateCall;
		}
		if (cjsProps.animateParams) {
			animateParams = cjsProps.animateParams;
			delete cjsProps.animateParams;
		}

// SET TICKER
		var zimTicker;
		if (!css && ticker) {
			// moved this to after Tween has started so rewind is taken into account, etc.
			// do not want to reset percentComplete at the end incase dragging
			// so just reset it to 0 if at 100
			// means to purposely start at end, must set rewind true and start at 50% and animate to 100% for instance
			if (startPercentComplete) {
				target.pathRatio = (target.percentComplete && Math.round(target.percentComplete) != 100)?target.percentComplete/100:0;
				target.percentCompleteNoAngle = Math.round(startPercentComplete) != 100?startPercentComplete:0;
			}
            
			if (events && !zot(sequenceTarget) && sequenceTarget.dispatchEvent) {
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
					sequenceTarget.dispatchEvent("animation");
				}, stage, mID, target);
			} else if (events && target.dispatchEvent) {
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
					target.dispatchEvent("animation");
				}, stage, mID, target);
			} else if (animateCall && typeof animateCall == "function") {
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();					
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
					animateCall(animateParams||target);
				}, stage, mID, target);
			} else {		                	
				zimTicker = zim.Ticker.add(function(){
					if (effectCheck) target.updateEffects();					
					if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
				}, stage, mID, target);
			}
		}
		
		function totalArr(arr) {
			if(!Array.isArray(arr)) return;
			var totalNumber = 0;
			for (var i=0,l=arr.length; i<l; i++) {
				totalNumber+=arr[i];
			}
			return totalNumber;
		}

var forwardStack = [1,1,1];
		// var lastAA = 0; // commented out in path animation
		// var adjustA = 1;
		
				
		var handlePath = function () {
			if (!target.parent || tween.passive || tween.startPaused) return;
			if (drag && rewind && ((lastPathPercent < 50 && target.percentComplete > 50) || (lastPathPercent > 50 && target.percentComplete < 50))) {
				lastForward = target.percentComplete<50;
			}
			lastPathPercent = target.percentComplete;

if (pathObject) {
				if (dynamicPath) {
					segments = pathObject.segmentPoints;
					percents = pathObject.segmentRatios;
				}

if (drag) {
					var newPoint = pathObject.getCurvePoint(target.pathRatio, percents, segments);
				} else {
					target.currentPercent = target.startPercent + target.percent*target.pathRatio;
					var newPointRatio = ((1000000+target.currentPercent)%100)/100;
					if (target.pathRatio==1) newPointRatio+=target.percent>0?1:0;
					newPoint = pathObject.getCurvePoint(newPointRatio, percents, segments);
				}

if (newPoint) {
					// latestSegmentIndex = newPoint.z; // point on path before the calculated point - used with drag
					var locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
					target.x = locPoint.x;
					target.y = locPoint.y;
				}
			}
			var diffX = Math.abs(lastX - target.x),
			diffY = Math.abs(lastY - target.y);	
			var opposite = (startAngle==90||startAngle==270||startAngle==-90);
			// if (pathFlip && flipCheck) {
			// 	if (diffX < .01 && zim.sign(opposite?target.scaleY:target.scaleX) != zim.sign(startFlip)) {opposite?target.scaleY*=-1:target.scaleX*=-1;}
			// 	else if (Math.round(lastX) > Math.round(target.x) && diffX > .01 && zim.sign(opposite?target.scaleY:target.scaleX) == zim.sign(startFlip)) {opposite?target.scaleY*=-1:target.scaleX*=-1;}
			// 	else if (Math.round(lastX) < Math.round(target.x) && diffX > .01 && zim.sign(opposite?target.scaleY:target.scaleX) != zim.sign(startFlip)) {opposite?target.scaleY*=-1:target.scaleX*=-1;}
			// }
			// if (pathFlipVertical && flipCheck) {
			// 	if (Math.round(lastY) > Math.round(target.y) && diffY > .01 && zim.sign(opposite?target.scaleX:target.scaleY) == zim.sign(startFlipVertical)) opposite?target.scaleX*=-1:target.scaleY*=-1;
			// 	if (Math.round(lastY) < Math.round(target.y) && diffY > .01 && zim.sign(opposite?target.scaleX:target.scaleY) != zim.sign(startFlipVertical)) opposite?target.scaleX*=-1:target.scaleY*=-1;
			// }

if (pathFlip && flipCheck) {
				if (lastX > target.x && diffX > .01 && zim.sign(opposite?target.scaleY:target.scaleX) == zim.sign(startFlip)) {opposite?target.scaleY*=-1:target.scaleX*=-1;}
				else if (lastX < target.x && diffX > .01 && zim.sign(opposite?target.scaleY:target.scaleX) != zim.sign(startFlip)) {opposite?target.scaleY*=-1:target.scaleX*=-1;}
				else if ((target.percentComplete < 99 && target.percentComplete > 1) && diffX < .01 && diffY > .01 && zim.sign(opposite?target.scaleY:target.scaleX) != zim.sign(startFlip)) {opposite?target.scaleY*=-1:target.scaleX*=-1;}
			}
			if (pathFlipVertical && flipCheck) {
				if (lastY > target.y && diffY > .01 && zim.sign(opposite?target.scaleX:target.scaleY) == zim.sign(startFlipVertical)) {opposite?target.scaleX*=-1:target.scaleY*=-1;}
				else if (lastY < target.y && diffY > .01 && zim.sign(opposite?target.scaleX:target.scaleY) != zim.sign(startFlipVertical)) {opposite?target.scaleX*=-1:target.scaleY*=-1;}
				else if ((target.percentComplete < 99 && target.percentComplete > 1) && diffY < .01 && diffX > .01 && zim.sign(opposite?target.scaleX:target.scaleY) != zim.sign(startFlipVertical)) {opposite?target.scaleX*=-1:target.scaleY*=-1;}
			}

var aa;
			if (pathOrient && diffX > .05 || pathOrient && diffY > .05) {
				if (pathObject==pathOrient) {
					aa = zim.angle(lastX, lastY, target.x, target.y)+startAngle;
				} else {
					var orientPoint;
					if (pathOrient.parent) {
						orientPoint = pathOrient.parent.localToLocal(pathOrient.x, pathOrient.y, target.parent);
					} else {
						orientPoint = target.parent.globalToLocal(pathOrient.x, pathOrient.y);
					}
					aa = zim.angle(target.x, target.y, orientPoint.x, orientPoint.y)+startAngle;
				}

if (aa != 0) {
					if (!target.paused || movingCheck) {
						if (pathFlip && lastX-target.x > .01) aa += 180;
						var aaa = aa;
						// if (!pathFlip && lastX-target.x > 0 && pathFlipVertical) aaa = aa-180;
						target.rotation = Math.round(aaa==startAngle?target.rotation:aaa);			
						if (rewind && target.percentComplete > 50 && !pathFlip) target.rotation += 180
					}
				}
			}

// var handlePath = function () {	
		// 	if (!target.parent || tween.passive || tween.startPaused) return;
		// 	if (drag && rewind && ((lastPathPercent < 50 && target.percentComplete > 50) || (lastPathPercent > 50 && target.percentComplete < 50))) {
		// 		lastForward = target.percentComplete<50;
		// 	}
		// 	lastPathPercent = target.percentComplete;
		// 
		// 	if (pathObject) {
		// 		if (dynamicPath) {
		// 			segments = pathObject.segmentPoints;
		// 			percents = pathObject.segmentRatios;
		// 		}
		// 
		// 		if (drag) {
		// 			var newPoint = pathObject.getCurvePoint(target.pathRatio, percents, segments);
		// 		} else {
		// 			target.currentPercent = target.startPercent + target.percent*target.pathRatio;
		// 			var newPointRatio = ((1000000+target.currentPercent)%100)/100;
		// 			if (target.pathRatio==1) newPointRatio+=target.percent>0?1:0;
		// 			newPoint = pathObject.getCurvePoint(newPointRatio, percents, segments);
		// 		}
		// 
		// 		if (newPoint) {
		// 			// latestSegmentIndex = newPoint.z; // point on path before the calculated point - used with drag
		// 			var locPoint = target.parent.globalToLocal(newPoint.x, newPoint.y);
		// 			target.x = locPoint.x;
		// 			target.y = locPoint.y;
		// 		}
		// 	}
		// 	var opposite = (startAngle==90||startAngle==270||startAngle==-90);
		// 
		// 	var adjust = .05;
		// 
		// 	// if (pathFlip && flipCheck) {
		// 	// 	if (lastX > target.x+adjust && zim.sign(opposite?target.scaleY:target.scaleX) == zim.sign(startFlip)) opposite?target.scaleY*=-1:target.scaleX*=-1;
		// 	// 	if (lastX < target.x-adjust && zim.sign(opposite?target.scaleY:target.scaleX) != zim.sign(startFlip)) opposite?target.scaleY*=-1:target.scaleX*=-1;
		// 	// }
		// 	// if (pathFlipVertical && flipCheck) {
		// 	// 	if (lastY > target.y+adjust && zim.sign(opposite?target.scaleX:target.scaleY) == zim.sign(startFlipVertical)) opposite?target.scaleX*=-1:target.scaleY*=-1;
		// 	// 	if (lastY < target.y-adjust && zim.sign(opposite?target.scaleX:target.scaleY) != zim.sign(startFlipVertical)) opposite?target.scaleX*=-1:target.scaleY*=-1;
		// 	// }
		// 
		// 	if (pathFlip && flipCheck) {
		// 	    if (lastX == target.x) {target.scaleX = startFlip}
		// 	    else if (Math.round(lastX) < Math.round(target.x) && target.scaleX != startFlip) {target.scaleX*=-1;}
		// 	    else if (Math.round(lastX) > Math.round(target.x) && target.scaleX == startFlip) {target.scaleX*=-1;}
		// 	}
		// 
		// 	var aa;
		// 	if (pathOrient) {
		// 		if (pathObject==pathOrient) {
		// 			aa = zim.angle(lastX, lastY, target.x, target.y)+startAngle;
		// 		} else {
		// 			var orientPoint;
		// 			if (pathOrient.parent) {
		// 				orientPoint = pathOrient.parent.localToLocal(pathOrient.x, pathOrient.y, target.parent);
		// 			} else {
		// 				orientPoint = target.parent.globalToLocal(pathOrient.x, pathOrient.y);
		// 			}
		// 			aa = zim.angle(target.x, target.y, orientPoint.x, orientPoint.y)+startAngle;
		// 		}
		// 
		// 		if (aa != 0) {
		// 			if (!target.paused || movingCheck) {
		// 				if (pathFlip && lastX-target.x > .05) aa += 180;
		// 				var aaa = aa;
		// 				// if (!pathFlip && lastX-target.x > 0 && pathFlipVertical) aaa = aa-180;
		// 				target.rotation = aaa==startAngle?target.rotation:aaa;			
		// 				if (rewind && target.percentComplete > 50 && !pathFlip) target.rotation += 180
		// 			}
		// 		}
		// 	}
				
			// if (pathOrient) {
			// 
			// 	var aa;
			// 	if (pathObject==pathOrient) {
			// 		aa = zim.angle(lastX, lastY, target.x, target.y)+startAngle;
			// 	} else {
			// 		var orientPoint;
			// 		if (pathOrient.parent) {
			// 			orientPoint = pathOrient.parent.localToLocal(pathOrient.x, pathOrient.y, target.parent);
			// 		} else {
			// 			orientPoint = target.parent.globalToLocal(pathOrient.x, pathOrient.y);
			// 		}
			// 		aa = zim.angle(target.x, target.y, orientPoint.x, orientPoint.y)+startAngle;
			// 	}
			// 
			// 	aa = (aa+360*100000)%360;								
			// 	if (aa != 0) { //  || !target.zimAnimateDragDown) {					
			// 		if (!target.paused || movingCheck) {						
			// 			var sid = (aa>0&&aa<180)?1:-1;	
			// 			var rever = (rewind && target.percentComplete > 50)?-1:1;											
			// 			var aaa = lastAA+360*100000-(aa+360*100000);
			// 			if (aaa != -180 && aaa != 180) {
			// 				if (aaa > 1) adjustA = -1;
			// 				if (aaa < -1) adjustA = 1;
			// 			}	
			// 			lastAA = aa;
			// 			if (pathFlip && lastX-target.x > .05*sid*rever*adjustA) aa += 180;						
			// 			target.rotation = aa;
			// 			if (rever && !pathFlip) target.rotation += 180
			// 		}
			// 	}
			// }
			// picking up target can sway results so take average of last three
			// could possibly use this with flip to make it less jittery when dropping

lastX = target.x;
			lastY = target.y;
		};
		
		
		// there is only one percentComplete on a target
		// this will overwrite the handlePath function used by that percentComplete
		// so that the proper drag scope is used - complex - fixed in 10.6.1
		// will not be able to animate properly after a drag - use containers
		if (pathObject || pathOrient || pathFlip || pathFlipVertical) target.handlePath = handlePath;

// SET MASK TO DYNAMIC
		if (!zot(target.zimMaskDynamic)) target.zimMaskApply(); // set mask set by zimMask to dynamic

// ANIMATION DONE AND HELPER FUNCTIONS
		function doneAnimating() {
			if (target.seriesTweens) target.seriesTweens.shift();
			if (target.seriesCalls) target.seriesCalls.shift();
			if (target.seriesParams) target.seriesParams.shift();
			if (target.paused && target.type != "Sprite") {
				// ZIM 015 - not sure why we want to call this when paused 
				// as it activates the animation if in series
				// if (call && typeof call == 'function') {(call)(params);}
				return;
			}
			if (cjsProps.loop) {
				if (count > 0) {					
					if (currentCount < count) {
						if (wait3>0) target.waiting = true;
						doLoopWaitCall();
						currentCount++;
						return;
					} else {
						if (rewind) {							
							if (target.set) target.set(startObj);							
						} else {							
							if (target.set) target.set(obj);
						}
					}
				} else {							
					if (wait3>0) target.waiting = true;
					doLoopWaitCall();
					return;
				}
			} else {
				if (rewind) {
					if (target.set) target.set(startObj);							
				} else {							
					if (target.set) target.set(obj);
				}
			}	
			
			// ZIM 015 - this was the first thing we tried to scrub a series with percentComplete 
			// there were lots of other things too to make it work.
			// Leaving the seriesTween test in here... but probably not doing much			
			if (clean) endTween(id);
			else {
				if (target.seriesTweens) {
					if (target.seriesTweens.length == 0) target.pauseAnimate(true, id);
				} else {
					// ZIM 019 added !dynamic check to keep dynamic alive - so now set clean to false will keep dynamic live
					if (!dynamic) target.pauseAnimate(true, id);
				}
			}

// calling sequenceCall in loop as well so don't call here if looping - ZIM Cat 03
			if (!cjsProps.loop && sequenceCall && typeof sequenceCall == 'function') {
				var sp = zot(sequenceParams) ? target : sequenceParams;
				(sequenceCall)(sp);
			}
			if (call && typeof call == 'function') {(call)(params);}
		}
		
		function getStart() {
			// for rewind, we need to know the start value
			// which could be modified by the set parameter			
			for (var i in obj) {
				if (css && target.style) {
					if (!zot(set[i]) && !from) {
						startObj[i] = set[i];
					} else {
						if (i=="transform") startObj[i] = target.style[i];
						else startObj[i] = zum(target.style[i]);
					}
				} else {
					if (!zot(set[i]) && !from) {
						startObj[i] = set[i];
					} else {
						if (i.substr(0,1) == ".") {
							var dots = i.split(".");
							var lastdot = target;
							for (var j=1; j<dots.length; j++) {
								lastdot = lastdot[dots[j]];
							}
							startObj[i] = lastdot;
						} else {
							startObj[i] = target[i];
						}
					}
				}
			}
			return startObj;
		}
		function removeBusy(obj) {
			if (!target.zimBusy) return;
			for (var o in obj) {
				delete target.zimBusy[o];
			}
			if (zim.isEmpty(target.zimBusy)) target.zimBusy = null;
		}

// PAUSE AND STOP MANAGEMENT
		var zimPaused = false;
		setZimTweenProps();
		function setZimTweenProps() {
			// used to keep track of tweens for various ids
			// for pauseAnimate() and stopAnimate() down below
			tween.zimObj = obj;
			tween.zimTicker = zimTicker;
			tween.zimPaused = zimPaused;
			if (idSet) tween.zimIdSet = idSet;
			if (providedID) {
				// add to zim.idSets for global animation pause and stop by id
				// zim.idSets = {id:[target, target], id:[target, target, target]}
				// watchout - global idSet works on provided IDS
				// local idSets work on multiple ids that are the same
				// so an object with one tween under a provided id is not locally an idSet
				if (zot(zim.idSets)) zim.idSets = {};
				if (zot(zim.idSets[providedID])) {
					zim.idSets[providedID] = [target];
				} else {
					if (zim.idSets[providedID].indexOf(target) < 0) zim.idSets[providedID].push(target); // ES6 needed
				}
			}
			if (!zim.animatedObjects) zim.animatedObjects = new zim.Dictionary(true);
			zim.animatedObjects.add(target, true);
		}
		function endTween(id, overrideEnd) { 
			if (dynamic) return;
			if (target.tweenStates && target.tweenStates[id]) delete target.tweenStates[id];
			if (zot(target.zimTweens) || zot(target.zimTweens[id])) return;
			target.zimX = null;
			target.zimY = null;
			removeBusy(target.zimTweens[id].zimObj);
			target.zimTweens[id].paused = true;
			endTicker(id);
			var idSet = target.zimTweens[id].zimIdSet;
			if (!zot(idSet) && target.zimIdSets) {
				var sets = target.zimIdSets[idSet];
				if (sets) sets.splice(sets.indexOf(id), 1);
				if (sets && sets.length == 0) {
					delete target.zimIdSets[idSet];
					if (zim.isEmpty(target.zimIdSets)) delete target.zimIdSets;
				}
			}
            
			//target.pathRatio = null;
			if (target.type == "Pen" && target.zimOnPath) {target.stop(); target.zimOnPath = false;}
			delete target.zimTweens[id];
			
			target.zimLastObj = null; // added ZIM NFT 01 patch

// BUG
			// fast consecutive overlapping animates are not clearing zimTweens
			// so the pause is not being set - need to fix somehow - still broken
			// For instance animating something on a click and then tripple clicking really fast
			// Where this is an issue in app, prevent fast multiple activations of animate
			// For instance set object to mouseEnabled = false until animate is complete
			// then set object to mouseEnabled = true in call function
			if (!overrideEnd && zim.isEmpty(target.zimTweens)) {
				target.stopAnimate(null,null,null,false,true); // last true is internal
			}

// handle zim.idSets
			// very tricky - the originating id for an idSet does not get an idSet
			// but rather its id is used by subsequent tweens for the tween.idSets
			// the originating id may create a zim.idSets if it was provided as a parameter
			if ((target.zimTweens && target.zimTweens[id]) ||
				(target.zimIdSets && target.zimIdSets[idSet?idSet:id])) {
					// leave zim.idSets alone
			} else {
				if (zim.idSets && zim.idSets[idSet?idSet:id]) {
					zim.idSets[idSet?idSet:id];
					var targetIndex = zim.idSets[idSet?idSet:id].indexOf(target);
					if (targetIndex >= 0)  zim.idSets[idSet?idSet:id].splice(targetIndex, 1);
					if (zim.idSets[idSet?idSet:id].length <= 0) {
						delete zim.idSets[idSet?idSet:id];
						if (zim.isEmpty(zim.idSets)) delete zim.idSets;
					}
				}
			}
		}
		function endTicker(id) {
			// need a little delay to make sure updates the last animation
			// and to help call function have a stage update
			// store reference to ticker function in a closure
			// as we may delete the zimTweens reference before the 200 ms is up
			-function() {
				var ticker = target.zimTweens[id].zimTicker;
				if (target.zimTweens[id].extraTickers) {
					for (var k=0; k<target.zimTweens[id].extraTickers.length; k++) {
						if (target.zimTweens[id].extraTickers[k]) zim.Ticker.remove(target.zimTweens[id].extraTickers[k]);
					}
				}
				// if (ticker) zim.Ticker.remove(ticker); ticker = null;
				if (target.zimTweens[id].requestID) cancelAnimationFrame(target.zimTweens[id].requestID);				
				if (ticker) {
					setTimeout(function(){
						if (ticker) zim.Ticker.remove(ticker, mID, target); ticker = null;
					},200);
				}
			}();
		}
		function pauseTicker(id, paused) {
			
			var tween = target.zimTweens[id];
			tween.paused = paused;
			if (paused == tween.zimPaused) return;			
			tween.zimPaused = paused;

if (paused) {					
				if (tween.zimTicker) tween.zimAnimateTimeout = setTimeout(function(){
					if (tween.zimTicker) zim.Ticker.remove(tween.zimTicker, mID, target);
				},200);
				// if (target.zimZoomTicker) zim.Ticker.remove(target.zimZoomTicker);
			} else {		
				tween.startPaused = false;
				clearTimeout(tween.zimAnimateTimeout);				
				if (tween.zimTicker) tween.zimTicker = zim.Ticker.add(tween.zimTicker, stage, mID, target);
				// if (target.zimZoomTicker) target.zimZoomTicker = zim.Ticker.add(target.zimZoomTicker, stage);
			}
		}
		function expandIds(ids) {
			// turn any idSets into ids
			var actualIds = [];
			for (var i=0; i<ids.length; i++) {
				if (target.zimIdSets && !zot(target.zimIdSets[ids[i]])) {
					actualIds = actualIds.concat(target.zimIdSets[ids[i]]);
				} else {
					actualIds.push(ids[i]);
				}
			}
			return actualIds;
		}

// METHODS ADDED TO TARGET
		
		if (!target.stopAnimate || !target.stopAnimate.real) { // empty method gets added by default
			target.stopAnimate = function(ids, toEnd, include, command, internal) {
				var id;
				target.dynamicAnimation = null;	
				if (internal && drag) { // zim 10.7.1 fix to still drag if done animating
					target.pauseAnimate();
					return;
				}
				
				if (zot(ids)) {
					target.tweenStates = {}; // all are off
				}
				
				if (toEnd) {
					target.endTween(null, ids);
					return target;
				}
				// can't risk turning percentComplete off as only one per all animations
				// instead, evaluate how percentComplete is set when starting an animation
				// if there is no getter setter or a value has been changed when not tweening
				// then assumes percentComplete is desired else sets to 0 when starting an animation
				// if (internal) target.percentComplete = target.pathRatio = 0;

if (zot(command)) command = true;
				if (target.pan == undefined && target.type != "Timer") { // hmmm what about other objects with paused properties...
					if (target.type != undefined) target.paused = true;
					target.animating = false;
				}
				if (target.type == "Pen" && target.zimOnPath) {target.stop(); target.zimOnPath = false;}
				if (zot(include)) include = true;
				if (command && drag) {
					if (pathObject) pathObject.off("change", target.zimAnimatePathChange, null, mID);
					target.off("mousedown", target.zimAnimateDragDown, null, mID);
					target.off("pressmove", target.zimAnimateDragPress, null, mID);
					target.off("pressup", target.zimAnimateDragUp, null, mID);
					if (target.amu) stage.frame.off("mouseupplus", target.amu, null, mID);	
					if (target.zimDragAnimateTicker) zim.Ticker.remove(target.zimDragAnimateTicker, mID, target);
				}
				if (zot(ids)) {
					if (!include) return target; // would be exclude all ids
					target.zimBusy = null; // clear any busy properties
					createjs.Tween.removeTweens(target);
					for (id in target.zimTweens) {
						endTicker(id);						
					}
					target.zimTweens = null;
					target.zimIdSets = null;
					target.zimTween = null;
					// NOT SURE WHAT ID SHOULD BE REFERENCED BELOW - ZIM ZIM 00
					if (zim.idSets && zim.idSets[idSet?idSet:id]) {
						delete zim.idSets[idSet?idSet:id];
						if (zim.isEmpty(zim.idSets)) delete zim.idSets;
					}
					zim.animatedObjects.remove(target);	
					
				} else {
					if (!Array.isArray(ids)) ids = [ids];
					// expand any idSets into ids
					var actualIds = expandIds(ids);
					for (id in target.zimTweens) {
						if (target.zimTweens[id].requestID) {
							cancelAnimationFrame(target.zimTweens[id].requestID);
						}
						if (include && actualIds.indexOf(id) >= 0) {
							endTween(id, command);							
						}
						if (!include && actualIds.indexOf(id) < 0) {
							endTween(id, command);
						}
					}
				}
				
				// if (zimTicker) zim.Ticker.remove(zimTicker);
				// zog(target)
				return target;
			};
			target.stopAnimate.real = true; // record this as real method instead of empty method
			target.pauseAnimate = function(paused, ids, include, ignoreDynamic) {				
				if (paused!==false) target.percentComplete; // run the percentComplete before setting pause
				var id;			
				if (ids=="pauseOnBlur") {	
					ids = null;
				} else if (zot(ids)) {
					target.tweenStates = {all:paused===false?true:false}; // either all on or all off 
				}
				
				if (target.type == "Pen") {
					if (paused === false) {
						if (target.zimOnPath) target.infinite = true;
					} else {
						target.stop();
					}
				}
				if (usingDynamic && !ignoreDynamic) {
					if (zot(ids)) { // want all ids	
						// added in ZIM NFT 00 patch - not sure about it...
						// it matches what we do when not dynamic
						// works but jumps to new value too quickly in speed? 
						// due to extra tickers?
						for (id in target.zimTweens) {pauseTicker(id, paused);}
					} else {
						target.pause(paused, ids);
					}					
					return target;
				}

if (zot(paused)) paused = true;
				mouseCheck = false;
				if (target.type != undefined) target.paused = paused; 
				target.animating = !paused;
				if (zot(include)) include = true;
				if (zot(ids) && !include) return target; // would exclude all ids
				if (zot(ids)) { // want all ids
					for (id in target.zimTweens) {pauseTicker(id, paused);}
				} else {
					if (!Array.isArray(ids)) ids = [ids];
					// expand any idSets into ids
					var actualIds = expandIds(ids);
					for (id in target.zimTweens) {
						if (include && actualIds.indexOf(id) >= 0) {
							pauseTicker(id, paused);
							target.tweenStates[id] = !paused;
						}
						if (!include && actualIds.indexOf(id) < 0) {
							pauseTicker(id, paused);
							target.tweenStates[id] = !paused;
						}
					}
				}		
				if (target.type=="Sprite") {
					if (!target.running) target.stop();
				}			
				return target;
			};
		}

// start NIO updates 2
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (startPaused) target.pauseAnimate(true, id, null, true); // last true overrides dynamic check

// EXTRA SETUP
		var extra;
		if (obj.extra) {
			extra = obj.extra;
			delete obj.extra;
			if (!Array.isArray(extra)) extra = [extra];
		}
		// handle incoming convenience properties:
		for (i=0; i<extraTypes.length; i++) {
			var type = extraTypes[i];
			if (obj[type]) {
				if (zot(extra)) extra = [];
				makeExtra(type, obj[type]);
				delete obj[type];
			}
		}
		function makeExtra(prop, arr) {
			if (arr === true) extra.push({outputProp:extraLookup[prop]});
			else if (Array.isArray(arr)) extra.push({outputProp:extraLookup[prop], outputMin:arr[0], outputMax:arr[1], inputMin:arr[2], inputMax:arr[3]});
			else extra.push({outputProp:extraLookup[prop], outputMax:arr});
		}

if (extra) {
			target.zimStartScaleX = target.scaleX;
			target.zimStartScaleY = target.scaleY;
			tween.extraTickers = [];
			var extraProportion;
			for (i=0; i<extra.length; i++) {
				var eObj = extra[i];
				if (zot(eObj.inputObj)) eObj.inputObj = target;
				if (zot(eObj.inputProp)) eObj.inputProp = "y";
				if (zot(eObj.inputMin)) eObj.inputMin = 0;
				if (zot(eObj.inputMax)) eObj.inputMax = eObj.inputProp=="x"?stage.width:stage.height;
				if (zot(eObj.outputObj)) eObj.outputObj = target;
				if (zot(eObj.outputProp)) eObj.outputProp = "scale";
				if (zot(eObj.outputMin)) eObj.outputMin = 0;
				if (zot(eObj.outputMax)) eObj.outputMax = eObj.outputMin + 1;
				if (zot(eObj.constrain)) eObj.constrain = true;

// ZIK all property values!
				for (var j in eObj) {
					obj[j] = zim.Pick.choose(obj[j], null, target);
				}
				if (eObj.outputProp == "percentSpeed") dynamic = true;

extraProportion = new zim.Proportion(
					eObj.inputMin, eObj.inputMax,
					eObj.outputMin, eObj.outputMax,
					eObj.factor, eObj.outputRound
				);
				var func = function() { // closure
					var eO = eObj;
					var eP = extraProportion;
					return function () {
						var newValue;
						var eTarget = eO.outputObj;
						// adjusted for local to global ZIM 10.7.0
						var iV = eO.inputObj[eO.inputProp];
						if (eO.inputProp == "x" || eO.inputProp == "y") {
							if (eO.inputObj.parent) {
								var ppp = eO.inputObj.parent.localToGlobal(iV,iV);
								iV = ppp[eO.inputProp];
							}
						}
						if (eO.constrain) newValue = zim.constrain(eP.convert(iV), eO.outputMin, eO.outputMax);
						else newValue = eP.convert(iV);
						if (Number.isNaN(newValue)) newValue = eO.outputMin!=null?eO.outputMin:0;

var newTime = tween.currentTime+baseSpeed*target.percentSpeed/100;
			if (clampEnd && wait==0) newTime = zim.constrain(newTime, 0, clampEnd);
			tween.currentTime = newTime;

tween.setPosition(tween.currentTime);
			if (pathObject || pathOrient || pathFlip || pathFlipVertical) {handlePath();}
			stage.update();
		}
		if (dynamic) target.dynamicAnimation = true;
		if (dynamic || target.zimAnimateDragDown) {
			if (dynamic) {		
				usingDynamic = true;
				target.pauseAnimate(true, id, null, true); // last true overrides dynamic check
				if (target.type != undefined) target.paused = false;
				target.animating = true;
				tween.currentTime = 0;
				var myTween = tween;
				if (zot(target.percentSpeed)) target.percentSpeed = tween.startPaused?0:100;
				var baseSpeed = 1000/60;
				tween.currentTime = 0;
				var setToMiddle = (!sequenceWait && !seriesWait && !wait && !count && cjsProps.loop);
				if (clamp && cjsProps.loop && !count) clamp = false;
				var calculatedDuration = time + (rewind?(rewindTime?rewindTime:time):0) + (rewindWait?rewindWait:0) + (loopWait?loopWait:0);
				calculatedDuration *= timeType=="s"?1000:1;
				var clampMultiplier = 1;
				if (cjsProps.loop && count) clampMultiplier = count;
				var clampEnd;
				if (clamp) clampEnd = calculatedDuration*clampMultiplier;				
				advanceTween();
			}
		
		
			var lastSpeed;
			// var pausing = false;
			target.pause = function(state, time) {
				if (zot(state)) state = true;
				if (zot(time)) time = 0;
				if (state) {
					if (target.zimAnimateDragDown) {
						drag = false;
						target.cur("default");
						if (pathObject) pathObject.off("change", target.zimAnimatePathChange, null, mID);
						target.off("mousedown", target.zimAnimateDragDown, null, mID);
						target.off("pressmove", target.zimAnimateDragPress, null, mID);
						target.off("pressup", target.zimAnimateDragUp, null, mID);
						if (!dynamic) return;
					}					
					lastSpeed = target.percentSpeed;
					if (time > 0) {
						// pausing = true;
						zim.animate({target:target, props:{percentSpeed:0}, override:false, ticker:false, time:time, call:function() {
							// pausing = false;
							target.percentSpeed = 0;		
							if (target.type != undefined) target.paused = true;
							target.animating = false;
							dynamic = false;
							target.dispatchEvent("pause");
						}});
					} else {
						tween.startPaused = false;
						// pausing = false;
						target.percentSpeed = 0;		
						if (target.type != undefined) target.paused = true;
						target.animating = false;
						dynamic = false;
						setTimeout(function() {target.dispatchEvent("pause");}, 10);
					}
				} else {
					if (target.zimAnimateDragDown) {
						drag = true;
						target.cur("pointer");
						if (pathObject) target.zimAnimatePathChange = pathObject.on("change", target.zimAnimatePathChange, null, null, null, null, mID);
						target.zimAnimateDragDown = target.on("mousedown", target.zimAnimateDragDown, null, null, null, null, mID);
						target.zimAnimateDragPress = target.on("pressmove", target.zimAnimateDragPress, null, null, null, null, mID);
						target.zimAnimateDragUp = target.on("pressup", target.zimAnimateDragUp, null, null, null, null, mID);
						if (!dynamic && startPaused != false) return;
					}
					mouseCheck = false;
					tween.currentTime = tween.position;
					if (time > 0) {
						// pausing = true;
						zim.animate({
							target:target,
							props:{percentSpeed:lastSpeed},
							override:false,
							ticker:false,
							time:time,
							call:function() {
								// pausing = false;
								target.percentSpeed = lastSpeed;
								target.paused = false;
								target.animating = true;
								dynamic = true;
							}
						});
					} else {
						// pausing = false;
						target.percentSpeed = lastSpeed;
						if (target.type != undefined) target.paused = false;
						target.animating = true;
						dynamic = true;
					}
				}
				return target;
			};
		}

// end NIO updates
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

return target;
	};

zim.stopAnimate = function(ids, toEnd) {
		var i;
		if (zot(ids)) {
			if (zim.animatedObjects) {
				for (i=zim.animatedObjects.length-1; i>=0; i--) {
					zim.animatedObjects.objects[i].stopAnimate(null, toEnd);
				}
			}
			return;
		}
		if (!Array.isArray(ids)) ids = [ids];
		if (!zim.idSets) return;
		for (var j=0; j<ids.length; j++) {
			var idSet = ids[j];
			if (zim.idSets[idSet]) {
				var idLength = zim.idSets[idSet].length-1;
				for (i=idLength; i>=0; i--) {
					zim.idSets[idSet][i].stopAnimate(idSet, toEnd);
				}
			}
		}
	};

zim.pauseAnimate = function(state, ids) {
		if (zot(state)) state = true;
		var i;
		if (zot(ids) || ids=="pauseOnBlur") {
			if (zim.animatedObjects) {
				for (i=zim.animatedObjects.length-1; i>=0; i--) {
					zim.animatedObjects.objects[i].pauseAnimate(state, ids);
				}
			}
			return;
		}
		if (!Array.isArray(ids)) ids = [ids];
		if (!zim.idSets) return;
		for (var j=0; j<ids.length; j++) {
			var idSet = ids[j];
			if (zim.idSets[idSet]) {
				for (i=zim.idSets[idSet].length-1; i>=0; i--) {
					zim.idSets[idSet][i].pauseAnimate(state, idSet);
				}
			}
		}
	};

zim.loop = function(obj, call, reverse, interval, step, start, end, immediate, complete, completeParams) {
		var sig = "obj, call, reverse, interval, step, start, end, immediate, complete, completeParams";
		var duo; if (duo = zob(zim.loop, arguments, sig)) return duo;

zim.zimLoopCheck = true;
		if (zot(obj) || zot(call)) return undefined;
		if (zot(reverse)) reverse = false;		
		if (zot(interval)) interval = 0;
		if (zot(step) || step <= 0) step = 1;
		if (zot(immediate)) immediate = true;

// MONITOR
		var mID = "z~loop";
		if (obj && obj.mID && ((obj.mID[2] && obj.mID[2]=="-") || obj.mID[0]=="-")) mID = "z~-";

if (obj.constructor === Number) obj = Number(obj);
		if (obj.constructor === String) obj = String(obj);

var comp = interval===0 && complete && typeof complete=="function";

var length,i,total,r;
		if (type == "number" || type == "string" || type == "array" || type == "nodelist" || type == "htmlcollection" || type == "Dictionary") {
			if (type == "Dictionary") {
				var vals = zim.copy(obj.values);
				obj = zim.copy(obj.objects);
			}
			length = type=="number"?obj:obj.length;
			total = getTotal(length-1);
			if (total == 0) return true;
			if (reverse) {
				if (interval === 0) {
					for(i=start; i>=end; i-=step) {
						if (type=="number") {
							r = call(i, total, start, end, obj);
						} else if (type=="array" || type=="string") {
							r = call(obj[i], i, total, start, end, obj);
						} else if (type=="Dictionary") {
							r = call(obj[i], vals[i], i, total, start, end, obj);
						} else { // nodelist
							r = call(obj.item(i), i, total, start, end, obj);
						}
						if (typeof r != 'undefined' && r != "next") return r;
					}
				} else {
					zim.interval(interval, function(io) {
						i = io.count;
						if (!immediate) i--;
						if (step) i *= step;
						i = start-i;
						if (type=="number") {
							r = call(i, total, start, end, obj, io);
						} else if (type=="array" || type=="string") {
							r = call(obj[i], i, total, start, end, obj, io);
						} else if (type=="Dictionary") {
							r = call(obj[i], vals[i], i, total, start, end, obj, io);
						} else { // nodelist
							r = call(obj.item(i), i, total, start, end, obj, io);
						}					
						
						if (r == 'next' && i < total-1) io.next();
						else if (typeof r != 'undefined') {
							io.clear();
							return r;
						}
					}, total, immediate, null, null, complete, completeParams, null, mID);					
				}
			} else {
				if (interval === 0) {
					for(i=start; i<=end; i+=step) {
						if (type=="number") {
							r = call(i, total, start, end, obj);
						} else if (type=="array" || type=="string") {
							r = call(obj[i], i, total, start, end, obj);
						} else if (type=="Dictionary") {
							r = call(obj[i], vals[i], i, total, start, end, obj);
						} else { // nodelist // htmlcollection
							r = call(obj.item(i), i, total, start, end, obj);
						}
						if (typeof r != 'undefined' && r != "next") return r;
					}
				} else {
					zim.interval(interval, function(io) {
						i = io.count + start;
						if (!immediate) i--;
						if (step != 1) i = -start + i*step;
						
						if (type=="number") {
							r = call(i, total, start, end, obj, io);
						} else if (type=="array" || type=="string") {
							r = call(obj[i], i, total, start, end, obj, io);
						} else if (type=="Dictionary") {
							r = call(obj[i], vals[i], i, total, start, end, obj, io);
						} else { // nodelist or htmlcollection
							r = call(obj.item(i), i, total, start, end, obj, io);
						}
						
						if (r == 'next' && i < total-1) io.next();
						else if (typeof r != 'undefined') {
							io.clear();
							return r;
						}
					}, total, immediate, null, null, complete, completeParams, null, mID);					
				}
			}
			if (comp) complete(completeParams);
			return true;
		} else if (type == "object") {
			length = 0;
			var props = [];
			for (i in obj) {
				length++;
				props.push(i);
			}
			total = getTotal(length-1);
			if (total == 0) return true;
			if (reverse) {
				if (interval === 0) {
					for(i=start; i>=end; i-=step) {
						r = call(props[i], obj[props[i]], i, total, start, end, obj);
						if (typeof r != 'undefined' && r != "next") return r;
					}					
				} else {
					zim.interval(interval, function(io) {
						i = io.count;
						if (!immediate) i--;
						if (step) i *= step;
						i = start-i;
						
						r = call(props[i], obj[props[i]], i, total, start, end, obj, io);
						
						if (r == 'next' && i < total-1) io.next();
						else if (typeof r != 'undefined') {
							io.clear();
							return r;
						}
					}, total, immediate, null, null, complete, completeParams, null, mID, obj);					
				}
			} else {
				if (interval === 0) {
					for(i=start; i<=end; i+=step) {
						r = call(props[i], obj[props[i]], i, total, start, end, obj);
						if (typeof r != 'undefined' && r != "next") return r;
					}
				} else {
					zim.interval(interval, function(io) {
						i = io.count + start;
						if (!immediate) i--;
						if (step != 1) i = -start + i*step;
						
						r = call(props[i], obj[props[i]], i, total, start, end, obj, io);
						
						if (r == 'next' && i < total-1) io.next();
						else if (typeof r != 'undefined') {
							io.clear();
							return r;
						}
					}, total, immediate, null, null, complete, completeParams, null, mID, obj);					
				}
			}
			if (comp) complete(completeParams);
			return true;
		} else {
			total = getTotal(obj.numChildren-1);
			if (total == 0) return;
			if (reverse) {
				if (interval === 0) {
					for(i=start; i>=end; i-=step) {
						r = call(obj.getChildAt(i), i, total, start, end, obj);
						if (typeof r != 'undefined' && r != "next") return r;
					}
				} else {
					zim.interval(interval, function(io) {						
						i = io.count;
						if (!immediate) i--;
						if (step) i *= step;
						i = start-i;
						
						r = call(obj.getChildAt(i), i, total, start, end, obj, io);
						
						if (r == 'next' && i < total-1) io.next();
						else if (typeof r != 'undefined') {
							io.clear();
							return r;
						}
					}, total, immediate, null, null, complete, completeParams, null, mID);					
				}
			} else {
				if (interval === 0) {
					for(i=start; i<=end; i+=step) {
						r = call(obj.getChildAt(i), i, total, start, end, obj);
						if (typeof r != 'undefined' && r != "next") return r;
					}
				} else {
					zim.interval(interval, function(io) {
						i = io.count + start;
						if (!immediate) i--;
						if (step != 1) i = -start + i*step;
						
						r = call(obj.getChildAt(i), i, total, start, end, obj, io);					
						if (r == 'next' && i < total-1) io.next();	
						else if (typeof r != 'undefined') {
							io.clear();
							return r;
						}
					}, total, immediate, null, null, complete, completeParams, null, mID);					
				}
			}
			if (comp) complete(completeParams);
			return true;
		}
		function getTotal(max) {
			if (zot(start)) start = reverse?max:0;
			if (zot(end)) end = reverse?0:max;
			if ((reverse && end > start) || (!reverse && start > end)) return 0;
			if ((start < 0 && end) <0 || (start > max && end > max)) return 0;
			start = Math.max(0, Math.min(start, max));
			end = Math.max(0, Math.min(end, max));
			return Math.floor((reverse?(start-end):(end-start)) / step) + 1;
		}
		
	};

zim.addTo = function(obj, container, index, still) {
		var sig = "obj, container, index, still";
		var duo; if (duo = zob(zim.addTo, arguments, sig)) return duo;
		// if (obj.type=="AC"&&zdf) {zdf.ac("addTo", arguments); return obj;}
		if (zot(obj)) {zogy("zim methods - addTo(): please provide object"); return;}
		if (zot(container)) {
			if (WW.zdf) {container = WW.zdf.stage;}
			else {zogy("zim methods - addTo(): please provide container"); return;}
		}
		if (zot(still)) still = true;
		if (!obj.parent) still = false;

if (still) var point = obj.parent.localToLocal(obj.x, obj.y, container);
		if (zot(index) || isNaN(index)) {container.addChild(obj);}
		else {container.addChildAt(obj, index);}
		if (still) {obj.x = point.x; obj.y = point.y;}
		return obj;
	};

zim.removeFrom = function(obj, container) {
		if (zot(obj)) {zogy("zim methods - removeFrom(): please provide object"); return;}
		if (obj.removePhysics) obj.removePhysics();
		if (zot(container)) {
			if (obj.parent) obj.parent.removeChild(obj);
		}
		else container.removeChild(obj);
		return obj;
	};

zim.tap = function(obj, call, distance, time, once, dbl, dblTime, call2, call3, call4, cursor, mobileUp) {
		var sig = "obj, call, distance, time, once, dbl, dblTime, call2, call3, call4, cursor, mobileUp";
		var duo; if (duo = zob(zim.tap, arguments, sig)) return duo;
		if (zot(obj) || zot(call) || typeof call != "function") return;
		if (zot(distance)) distance = zim.handCursor?(dbl?100:50):(dbl?10:5);
		var timeType = getTIME(time);
		if (zot(time)) time = timeType=="s"?8:8000;
		if (zot(once)) once = false;
		if (zot(dbl)) dbl = false;
		if (zot(dblTime)) {
			if (call4) {
				dblTime = timeType=="s"?.5:500;
			} else {
				dblTime = timeType=="s"?1:1000;
			}
		}
		if (zot(cursor)) cursor = "pointer";
		if (cursor !== false) obj.cur(cursor);
		var firstTap = false;
		var doubleCheck = false;
		var firstUp;

// MONITOR
		var mID = "z~tap";
		if (obj && obj.mID && ((obj.mID[2] && obj.mID[2]=="-") || obj.mID[0]=="-")) mID = "z~-";

if (dbl) {
			obj.zimDblClickDownEvent = obj.on("mousedown", function (e) {
				firstUp = false;
				if (firstTap) { firstTap = false; return; }
				firstTap = true;
				if (e.currentTarget.type == "List") {
					if (e.target.type == "WindowBacking") return;
					var local = e.currentTarget.globalToLocal(e.stageX / zim.scaX, e.stageY / zim.scaY);
					if (local.y <= 0) return; // avoid titleBar and organizer
				}
				var lastX = e.stageX / zim.scaX;
				var lastY = e.stageY / zim.scaY;
				var startTime = Date.now();
				var upStageX;
				var upStageY;
				doubleCheck = true;
				if (obj.zimDoubleTimeout) clearTimeout(obj.zimDoubleTimeout);
				obj.zimDoubleTimeout = setTimeout(function () {
					doubleCheck = false;
					firstTap = false;
					if (obj.zimDblClickUpEvent) obj.off("pressup", obj.zimDblClickUpEvent, false, mID);
					if (firstUp && call4) {
						if (Math.abs(lastX + lastY - upStageX / zim.scaX - upStageY / zim.scaY) < distance) {
							if (obj.excludeTap) return;
							call4(e);
						} else if (call2) call2(e);
					}
				}, timeType == "s" ? dblTime * 1000 : dblTime);
				obj.zimDblClickUpEvent = obj.on("pressup", function (e) {
					upStageX = e.stageX; // upstage added by Xuntar
					upStageY = e.stageY;
					firstUp = true;
					if (firstTap) {
						if (call3) call3(e);
						return;
					} else if (!doubleCheck) return;
					if (Math.abs(lastX + lastY - e.stageX / zim.scaX - e.stageY / zim.scaY) < distance && Date.now() - startTime < (timeType == "s" ? time * 1000 : time)) {
						if (obj.excludeTap) return;
						clearTimeout(obj.zimDoubleTimeout);
						call(e);
						if (once) {
							obj.off("mousedown", obj.zimDblClickDownEvent, false, mID);
							obj.zimDblClickDownEvent = null;
							if (obj.cursor) obj.cur("default");
						}
					} else if (call2) call2(e);
					e.remove();
				}, null, null, null, null, mID);
			}, null, null, null, null, mID);
		} else {
			obj.zimClickDownEvent = obj.on("mousedown", function (e) {
				if (e.currentTarget.type == "List") {
					if (e.target.type == "WindowBacking") return;
					var local = e.currentTarget.globalToLocal(e.stageX / zim.scaX, e.stageY / zim.scaY);
					if (local.y <= 0) return; // avoid titleBar and organizer
				}
				var windowParent = false;
				var pp = e.target.parent.parent;
				if (pp && pp.type == "Window") windowParent = true;
				else if (pp && pp.parent && pp.parent.type == "Window") windowParent = true;
				if (M && !mobileUp && e.currentTarget.type != "List" && !windowParent) {
					if (obj.excludeTap) return;
					call(e);
					if (once) {
						obj.off("mousedown", obj.zimClickDownEvent, false, mID);
						obj.zimClickDownEvent = null;
						if (obj.cursor) obj.cur("default");
					}
				} else {
					var lastX = e.stageX / zim.scaX;
					var lastY = e.stageY / zim.scaY;
					var startTime = Date.now();
					obj.zimClickUpEvent = obj.on("pressup", function (e) {	
						// commented does not work on 45 degree - hahaha - was still activating tap on 45 degree sliding list	
						// if (Math.abs(lastX + lastY - e.stageX / zim.scaX - e.stageY / zim.scaY) < distance && Date.now() - startTime < (timeType=="s"?time*1000:time)) {
						if (Math.abs(lastX - e.stageX / zim.scaX) < distance && Math.abs(lastY - e.stageY / zim.scaY) < distance && Date.now() - startTime < (timeType=="s"?time*1000:time)) {
							if (obj.excludeTap) return;
							call(e);
							if (once) {
								obj.off("mousedown", obj.zimClickDownEvent, false, mID);
								obj.zimClickDownEvent = null;
								if (obj.cursor) obj.cur("default");
							}
						} else if (call2) call2(e);
						e.remove();					
					}, null, null, null, null, mID);
				}
			}, null, null, null, null, mID);
		}
		
		return obj;
	};

var stage;
		obj.zimClickHoldDownEvent = obj.on("mousedown", function (e) {
			if (!stage) stage = e.target.stage;
			if (!stage) return;
			if (zot(stage.frame)) stage.frame = WW.zdf;
			if (zot(stage.frame) || !stage.frame.mousemoveEvent) { // not recording frame mouseX and mouseY
				if (zot(stage.frame)) stage.frame = {};
				stage.frame.mouseX = e.stageX/zim.scaX;
				stage.frame.mouseY = e.stageY/zim.scaY;
				if (stage.frame.mouseholdEvent) stage.off("stagemousemove", stage.frame.mouseholdEvent, null, mID);
				stage.frame.mouseholdEvent = stage.on("stagemousemove", function (e) {
					stage.frame.mouseX = e.stageX/zim.scaX;
					stage.frame.mouseY = e.stageY/zim.scaY;
				}, null, null, null, null, mID);
			}
			if (e.currentTarget.type == "List") {
				if (e.target.type == "WindowBacking") return;
				var local = e.currentTarget.globalToLocal(e.stageX / zim.scaX, e.stageY / zim.scaY);
				if (local.y <= 0) return; // avoid titleBar and organizer
			}
			var lastX = e.stageX / zim.scaX;
			var lastY = e.stageY / zim.scaY;
			clearInterval(obj.zimHoldInterval);
			var count = 0;
			obj.zimHoldInterval = setInterval(function () {
				if (count < 10) { // if location has gone outside distance then not a hold
					if (Math.abs(lastX + lastY - stage.frame.mouseX - stage.frame.mouseY) > distance) {
						clearInterval(obj.zimHoldInterval);
					}
				} else {
					if (Math.abs(lastX + lastY - stage.frame.mouseX - stage.frame.mouseY) < distance) {
						if (obj.excludeHold) return;
						call(e);
					}
					clearInterval(obj.zimHoldInterval);
				}
				count++;
			}, time / 10 * (timeType == "s" ? 1000 : 1));
			obj.zimClickHoldUpEvent = obj.on("pressup", function () {
				clearInterval(obj.zimHoldInterval);
				if (stage && stage.frame.mouseholdEvent) {
					stage.off("stagemousemove", stage.frame.mouseholdEvent, null, mID);
				}
			}, null, true, null, null, mID); // just once
		}, null, once, null, null, mID);
		return obj;
	};

zim.noHold = function(obj) {
		if (zot(obj)) return;

// MONITOR
		var mID = "z~noHold";
		if (obj && obj.mID && ((obj.mID[2] && obj.mID[2]=="-") || obj.mID[0]=="-")) mID = "z~-";

if (obj.cursor) obj.cur("default");
		obj.off("mousedown", obj.zimClickHoldDownEvent, null, mID);
		obj.off("pressup", obj.zimClickHoldUpEven, null, mID);
		if (obj.stage && obj.stage.frame.mouseEvent) {
			obj.stage.off("stagemousemove", obj.stage.frame.mouseEvent, null, mID);
		}
		clearInterval(obj.zimHoldTimeout);
		return obj;
	};

zim.centerReg = function(obj, container, index, add) {
		var sig = "obj, container, index, add";
		var duo; if (duo = zob(zim.centerReg, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("centerReg", arguments); return obj.addTo(container, index);}
		if (zot(obj) || !obj.getBounds || !obj.getBounds()) {zogy("zim methods - centerReg(): please provide object with bounds set"); return obj;}
		if (zot(add)) add = true;
		if (zot(container) && obj.parent && add) {
			container = obj.parent;
			if (zot(index)) index = obj.parent.getChildIndex(obj);
			obj.parent.removeChild(obj);
		}
		if (!zot(container) && container == obj.parent) {
			if (zot(index)) index = obj.parent.getChildIndex(obj);
			obj.parent.removeChild(obj);
		}
		var oB = obj.getBounds();
		obj.regX = oB.x + oB.width/2;
		obj.regY = oB.y + oB.height/2;
		return add ? zim.center(obj, container, index) : obj;
	};

zim.center = function(obj, container, index, add) {
		var sig = "obj, container, index, add";
		var duo; if (duo = zob(zim.center, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("center", arguments); return obj.addTo(container, index);}
		if (zot(obj) || !obj.getBounds) {zogy("zim.center(): please provide object with bounds"); return obj;}
		if (zot(container)) {
			if (obj.parent) container = obj.parent;
			else if (WW.zdf) container = WW.zdf.stage;
		}
		if (zot(container) || !container.getBounds)  {zogy("zim.center(): please provide container with bounds"); return obj;}

var oB = obj.getBounds();
		var cB = container.getBounds();

if (zot(add)) add = true;

var resetCheck = false;
		if (zot(cB)) {
			container.setBounds(0,0);
			cB = container.getBounds();
			resetCheck = true;
		}

if (add && container.addChild) {
            if (zot(index) || (typeof index === 'number' && isNaN(index))) {
				if (!obj.parent || obj.parent!=container) container.addChild(obj);
				// if (!container.contains(obj)) container.addChild(obj);
            } else {
                container.addChildAt(obj, index);
            }
        }
		if (zot(oB)) {
			obj.x = cB.x+cB.width/2;
			obj.y = cB.y+cB.height/2;
			return obj;
		}

var zeroX = false;
		var zeroY = false;
		if (container.scaleX == 0) {
			zeroX = true;
			container.scaleX=.00001;
		}
		if (container.scaleY == 0) {
			zeroY = true;
			container.scaleY=.00001;
		}

// get registration point of object in coordinates of the container
		var reg = obj.localToLocal(obj.regX, obj.regY, container);

if (zeroX) container.scaleX=0;
		if (zeroY) container.scaleY=0;

// the positions are all in the container coordinate so do the calculation
		obj.x = cB.x + cB.width/2 - loc.width/2  + (reg.x-loc.x);
		obj.y = cB.y + cB.height/2 - loc.height/2  + (reg.y-loc.y);

return obj;
	};

zim.expand = function(obj, padding, paddingV, paddingRight, paddingBottom) {
		var sig = "obj, padding, paddingV, paddingRight, paddingBottom";
		var duo; if (duo = zob(zim.expand, arguments, sig)) return duo;
		if (obj.type=="AC"&&WW.zdf) {WW.zdf.ac("expand", arguments); return obj;}
		if (zot(obj) || !obj.getBounds || !obj.getBounds()) {zogy("zim methods - expand(): please provide object with bounds set"); return obj;}
		if (zot(padding)) padding = 20;
		if (zot(paddingV)) paddingV = padding;
		var paddingLeft,paddingTop;
		if (!zot(paddingRight) || !zot(paddingBottom)) {
			if (zot(paddingRight)) paddingRight = padding;
			if (zot(paddingBottom)) paddingBottom = paddingV;
			paddingLeft = padding;
			paddingTop = paddingV;
		} else {
			paddingLeft = paddingRight = padding;
			paddingTop = paddingBottom = paddingV;
		}
		var oB = obj.getBounds();
		var rect = new zim.Shape({style:false});
		rect.graphics.f("rgba(0,0,0,.01)").r(oB.x-paddingLeft,oB.y-paddingTop,oB.width+paddingLeft+paddingRight,oB.height+paddingTop+paddingBottom);
		obj.hitArea = rect;

return obj;
	};

zim.setMask = function(obj, mask, dynamic) {
		if (zot(obj)) {zogy("zim methods - setMask(): please provide obj");}
		if (zot(mask)) {setMaskNull(); return obj;}

// MONITOR
		var mID = "z~setMask";
		if (obj && obj.mID && ((obj.mID[2] && obj.mID[2]=="-") || obj.mID[0]=="-")) mID = "z~-";

if (!obj.parent) {obj.mask = m; return;}

obj.mask = m;
		}
		// called from Blob and zim functions that move zim shapes
		mask.zimMaskApply = function() {
			if (obj.zimMaskTicker) zim.Ticker.remove(obj.zimMaskTicker, mID, obj);
			obj.zimMaskTicker = zim.Ticker.add(apply, null, mID, obj);
		};
		if (mask && mask.shape) { // zim.Rectangle, Circle or Triangle, blob
			apply();
			if (dynamic) mask.zimMaskApply();
		} else {
			m = mask;
			obj.mask = m; // set the createjs mask
		}
		return obj;
	};

zim.KEYFOCUS = null;

zim.STYLE = null;
	zim.GLOBALSTYLE = null;
	zim.getStyle = function(type, group, inherit, groupOnly) {

var functionList = ["tap", "change", "hold", "noTap", "noChange", "noHold", "pos", "addTo", "center", "centerReg", "reg", "mov", "move", "siz", "drag", "transform", "gesture", "mouse", "expand", "outline", "bounds", "animate", "wiggle", "cache", "cursor","uppercase", "shadow", "mouse"];

// called by DisplayObjects
		// ZIM NFT MODULE ADJUST
		var STYLE = WW.STYLE || zim.STYLE;
		var GLOBALSTYLE = WW.GLOBALSTYLE || zim.GLOBALSTYLE;
		if (GLOBALSTYLE) STYLE = zim.merge(GLOBALSTYLE, STYLE);
		if (!STYLE) STYLE = {};
		if (!STYLE.group) STYLE.group = {};
		var DS = STYLE;		
		var val;

// groupOnly - ZIM 015 
		var onlyCheck = false;
		if (!zot(groupOnly)) {
			type = null;
			group = groupOnly;
			onlyCheck = true;
		}

// convert Lazy Object styles - ZIM Cat 03
		if (STYLE && STYLE.type && typeof STYLE.type == "string") {		
			STYLE.ttype = STYLE.type;			
			delete STYLE.type;
		}
		for (var prop in STYLE) {
			val = STYLE[prop]; 		
			if (prop.match(/^[(A-Z)]/)) {				
				if (!STYLE.type) STYLE.type = {};            
				if (STYLE.type[prop]) STYLE.type[prop] = zim.merge(STYLE.type[prop], val);
				else STYLE.type[prop] = val;   
				delete STYLE[prop];         
			} else if (val.constructor === {}.constructor && prop!="group" && prop!="type" && !zim.isPick(val) && functionList.indexOf(prop)==-1) {
				// Added Lazy Group in ZIM ZIM 01 post stable patch				            
				if (STYLE.group[prop]) STYLE.group[prop] = zim.merge(STYLE.group[prop], val);
				else STYLE.group[prop] = val;   
				delete STYLE[prop];
			}
		}
		// end Lazy

// MONITOR 
		STYLE.group["noMonitor"] = Style.m;
		
		// 016 - added !onlyCheck here for when a group is set and style is false but the group does not exist 
		// this was letting styles in as the next check gave empty group styles
		if (!zot(DS)) DS = zim.copy(DS); // can't copy with clone due to recursion
		else DS = {};

// an object of styles from creator class that have already been ziked
		// for instance, List calls Window and Tabs and these can inherit styles applied to the List
		// Tabs call Buttons and Labels and these can inherit styles from the List and Tabs
		// List will overwrite Button styles - so originator overwrites subsequent styles

var i;
		if (zot(inherit)) {
			inherit = {};
		} else {
			// remove any functions from inheritance
			for (i=0; i<functionList.length; i++) {
				delete inherit[functionList[i]];
			}
		}
		var IS = inherit;

if (onlyCheck) {
			DS = {}; // watch if GS is null this would let styles leak through on onlyCheck unless reset DS
			if (!zot(group) && !zot(GS)) DS = GS;
		} else {
			if (!zot(type) && !zot(TS) && !zot(TS[type])) DS = zim.merge(DS, TS[type]);
			if (!zot(group) && !zot(GS)) DS = zim.merge(DS, GS);
		}

for (var s in DS) {
			if (IS[s]) { // inherited value overrides
				delete DS[s];
				continue;
			}
			val = functionList.indexOf(s)==-1&&!DS.delayPick?zim.Pick.choose(DS[s]):DS[s]; // do not zik configuration objects of methods
			if (val=="ignore") {delete DS[s]; continue;}
			// not sure what the line below was for - maybe auto cloning a bitmap? but had to remove it ZIM 9.5.0 when debugging addTo STYLE issues
			// else if (val && val.clone && val.type != type && val.type != "Stage" && val.type != "StageGL") val = val.clone();
			// copy config objects with clone except for type container - do not center or centerReg on shape
			else if (val && val.constructor === {}.constructor) val = zim.copy(val, true, false);
			var zm; for (var z in DS) {
				if (zm=z.match(/^(.+)gColor$/)) {
					DS[zm[1]+"ackgroundColor"] = DS[z];
					delete DS[z];
				}
			}
			DS[s] = val;
		}
		DS = zim.merge(DS, IS);
		if (DS.ttype && !DS.type) {DS.type = DS.ttype; delete DS.ttype;}
		if (DS.style===false) return {};

return DS;
	};

// sets x, y, alpha, rotation, scale, scaleX, scaleY, regX, regY, skewX, skewY, bounds, visible
// also sets tap, change, addTo, center, centerReg, transform, drag, gesture, animate, wiggle, expand, cache, and outline (used internally)
zim.styleTransforms = function(obj, styles) {
		
	var zimTransformList = ["visible","x","y","scale","scaleX","scaleY","rotation","alpha","skewX","skewY","blendMode"];
	
	var i;
	if (styles) {	
		if (styles.add) {
			obj.addTo();
		}		
		if (styles.cursor) {
			if (obj.cur) obj.cur(styles.cursor===true?"pointer":styles.cursor);
		}
		if (styles.shadow) {
			if (obj.sha) obj.sha(styles.shadow.color, styles.shadow.offsetX, styles.shadow.offsetY, styles.shadow.blur);
		}
		if (styles.addTo) {
			obj.addTo(styles.addTo===true?null:styles.addTo);
			// not sure what these were doing below but replaced them with above... ZIM 9.5.0
			//obj.addTo(styles.addTo.constructor==={}.constructor?styles.addTo:null);
		}		
		for (i=0; i<zimTransformList.length; i++) {
			if (styles[zimTransformList[i]]!=null) obj[zimTransformList[i]] = zim.Pick.choose(styles[zimTransformList[i]]);
		}
		if (styles.regX!=null || styles.regY!=null) { // ZIM ZIM 02 - moved regX and regY here
			obj.reg(zot(styles.regX)?DEFAULT:styles.regX, zot(styles.regY)?DEFAULT:styles.regY);
		}
		if (styles.bounds) {
			if (styles.bounds.constructor==={}.constructor) {
				obj.setBounds(styles.bounds.x?styles.bounds.x:0, styles.bounds.y?styles.bounds.y:0, styles.bounds.width?styles.bounds.width:100, styles.bounds.height?styles.bounds.height:100);
			}
		}
		if (styles.center) {
			obj.center(styles.center===true?null:styles.center);
			// obj.center(styles.center.constructor==={}.constructor?styles.center:null);
		}
		if (styles.centerReg) {
			obj.centerReg(styles.centerReg===true?null:styles.centerReg);
			//obj.centerReg(styles.centerReg.constructor==={}.constructor?styles.centerReg:null);
		}
		if (styles.reg!=null) {
			if (styles.reg.constructor==={}.constructor) {
				obj.reg(zim.Pick.choose(styles.reg.x), zim.Pick.choose(styles.reg.y), styles.reg.still);
			} else {
				obj.reg(styles.reg);
			}
		}
		if (styles.x!=null) {
			if (styles.loc) {
				if (styles.loc.x==null) styles.loc.x = styles.x;
			} else {
				styles.loc = {x:styles.x};
			}
		}
		if (styles.y!=null) {
			if (styles.loc) {
				if (styles.loc.y==null) styles.loc.y = styles.y;
			} else {
				styles.loc = {y:styles.y};
			}
		}
		if (styles.loc) {
			if (styles.loc.constructor==={}.constructor) {
				obj.loc(zim.Pick.choose(styles.loc.x), zim.Pick.choose(styles.loc.y));
			} else {
				obj.loc(zim.Pick.choose(styles.loc));
			}
		}
		if (styles.pos) {
			if (styles.pos.constructor==={}.constructor) {
				obj.pos(zim.Pick.choose(styles.pos.x), zim.Pick.choose(styles.pos.y), zim.Pick.choose(styles.pos.horizontal), zim.Pick.choose(styles.pos.vertical), zim.Pick.choose(styles.pos.container), zim.Pick.choose(styles.pos.index), styles.pos.add, zim.Pick.choose(styles.pos.reg), zim.Pick.choose(styles.pos.regX), zim.Pick.choose(styles.pos.regY));				
			} else {
				var sp = zim.Pick.choose(styles.pos);
				if (sp == "left" || sp == "top") obj.pos();
				if (sp == "right") obj.pos({horizontal:"right"});
				if (sp == "bottom") obj.pos({vertical:"bottom"});
				if (sp == "rightbottom" || sp == "bottomright") obj.pos({horizontal:"right", vertical:"bottom"});
				if (sp == "center") obj.center();
			}
		}
		if (styles.mov || styles.move) {
			if (styles.move) styles.mov = styles.move;
			if (styles.mov.constructor==={}.constructor) {
				obj.mov(zim.Pick.choose(styles.mov.x), zim.Pick.choose(styles.mov.y));
			} else {
				obj.mov(zim.Pick.choose(styles.mov));
			}
		}		
		if (styles.siz) { // do not do size as that exists for font size for instance			
			if (styles.siz.constructor==={}.constructor) {
				obj.siz(zim.Pick.choose(styles.siz.width), zim.Pick.choose(styles.siz.height), zim.Pick.choose(styles.siz.only));
			} else {
				obj.siz(zim.Pick.choose(styles.siz));
			}
		}	
		if (styles.outline) {
			setTimeout(function(){
				obj.outline(styles.outline.constructor==={}.constructor?styles.outline:null);
				if (obj.stage) obj.stage.update();
			},20);
		}
		if (styles.drag) {
			obj.drag(styles.drag.constructor==={}.constructor?styles.drag:{currentTarget:true});
		}
		if (styles.gesture) {
			obj.gesture(styles.gesture.constructor==={}.constructor?styles.gesture:null);
		}
		if (styles.mouse===false) {
			obj.noMouse();
		}
		if (styles.transform) {
			setTimeout(function(){obj.transform(styles.transform.constructor==={}.constructor?styles.transform:null);},20);
		}
		if (styles.animate) {
			if (!Array.isArray(styles.animate)) styles.animate = [styles.animate];
			for (i=0; i<styles.animate.length; i++) {
				-function(){
					var sty = styles.animate[i];
					if (sty.constructor==={}.constructor) setTimeout(function(){obj.animate(sty);},20);
				}();
			}
		}
		if (styles.wiggle) {
			if (!Array.isArray(styles.wiggle)) styles.wiggle = [styles.wiggle];
			for (i=0; i<styles.wiggle.length; i++) {
				-function(){
					var sty = styles.wiggle[i];
					if (sty.constructor==={}.constructor) setTimeout(function(){obj.wiggle(sty);},20);
				}();
			}
		}
		if (styles.expand) {
			obj.expand(styles.expand===true?null:styles.expand);
		}
		if (styles.cache) {
			if (styles.cache.constructor==={}.constructor) {
				if (styles.cache.x) obj.cache(zim.Pick.choose(styles.cache.x), zim.Pick.choose(styles.cache.y), zim.Pick.choose(styles.cache.x), zim.Pick.choose(styles.cache.y));
				else obj.cache(zim.Pick.choose(styles.cache.width), zim.Pick.choose(styles.cache.height));
			} else {
				obj.cache();
			}
		}	
		if (styles.uppercase && (obj.text || obj.label)) {
			if (obj.text) obj.text = obj.text.toUpperCase();
			else obj.label.text = obj.label.text.toUpperCase();
		}

if (styles.tap && obj.tap) obj.tap(styles.tap);
		if (styles.change && obj.change) obj.change(styles.change);
		if (styles.hold && obj.hold) obj.hold(styles.hold);
		if (styles.noChange && obj.noChange) obj.noChange();
		if (styles.noTap && obj.noTap) obj.noTap();
		if (styles.noHold && obj.noHold) obj.noHold();
		if (!zot(styles.mouse) && obj.mouse) {
			if (styles.mouse) obj.mouse();
			else obj.noMouse();
		}
		if (styles.noMouse && obj.noMouse) obj.noMouse();

var STYLE = WW.STYLE || zim.STYLE;
		if (STYLE && (STYLE.once===true || STYLE.once==obj.type)) {			
			if (WW.STYLE) WW.STYLE = {}; else zim.STYLE = {};
		}		
	}
};

zim.Style = {
	m:{monitor:false},
	remembered:{},
	clear:function() {if (WW.STYLE) WW.STYLE = {}; if (zim.STYLE) zim.STYLE = {}; return zim.Style;},
	clearTypes:function() {var STYLE = WW.STYLE || zim.STYLE; delete STYLE.types; return zim.Style;},
	clearGroups:function() {var STYLE = WW.STYLE || zim.STYLE; delete STYLE.groups; return zim.Style;},
	remember:function(id) {
		if (zot(id)) id = "default";
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		zim.Style.remembered[id]=zim.copy(STYLE, true);
		return zim.Style;
	},
	clearRemembered:function(id) {
		if (zot(id)) zim.Style.remembered = {};
		else delete zim.Style.remembered[id];
		return zim.Style;
	},
	recall:function(id) {
		if (zot(id)) id = "default";
		if (WW.STYLE) WW.STYLE = zim.Style.remembered[id]; 
		else zim.STYLE = zim.Style.remembered[id];
		return zim.Style;
	},
	add:function(obj) {
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		if (WW.STYLE) WW.STYLE = zim.merge(STYLE, obj);
		else zim.STYLE = zim.merge(STYLE, obj);
		return zim.Style;
	},
	addType:function(typeName, obj) {
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		if (!STYLE.type) STYLE.type = {};
		STYLE.type[typeName] = obj;
		return zim.Style;
	},
	addGroup:function(groupName, obj) {
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		if (!STYLE.group) STYLE.group = {};
		STYLE.group[groupName] = obj;
		return zim.Style;
	},
	remove:function(styleName) {
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		delete STYLE[styleName];
		return zim.Style;
	},
	removeType:function(typeName) {
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		if (!STYLE.type) return zim.Style;
		delete STYLE.type[typeName];
		return zim.Style;
	},
	removeGroup:function(groupName) {
		var STYLE = WW.STYLE || zim.STYLE; 
		if (!STYLE) {
			if (zns) STYLE = zim.STYLE = {};
			else STYLE = WW.STYLE = {};
		} 
		if (!STYLE.group) return zim.Style;
		delete STYLE.group[groupName];
		return zim.Style;
	}
};

zim.localToGlobal = function localToGlobal(x,y,scope,func) {
	if (x==null || y==null) return;
	var point = func.call(scope,x,y);
	var stage = scope.stage;
	if (!WW.zdf) {
		if (!stage) return point;
		WW.zdf = {stage:stage, canvas:stage.canvas};
	}
	point.x /= zim.scaX;
	point.y /= zim.scaY;
	return point;
};
zim.globalToLocal = function globalToLocal(x,y,scope,func) {
	if (x==null || y==null) return;
	var stage = scope.stage;
	if (!WW.zdf) {
		if (!stage) return func.call(scope,x,y);
		WW.zdf = {stage:stage, canvas:stage.canvas};
	}
	x *= zim.scaX;
	y *= zim.scaY;
	var point = func.call(scope,x,y);
	return point;
};
zim.localToLocal = function localToLocal(x,y,target,scope) {
	if (x==null || y==null || target==null) return;
	var point = scope.localToGlobal(x,y);
	var stage = scope.stage;
	if (!WW.zdf) {
		if (!stage) return target.globalToLocal(point.x, point.y);
		WW.zdf = {stage:stage, canvas:stage.canvas};
	}
	if (!stage) stage = WW.zdf.stage;
	if (target == stage) return point;
	if (point) return target.globalToLocal(point.x, point.y);
};

zim.displayBase = function(obj) {
		var that = obj;				
		var mID = "z~-";

Object.defineProperty(obj, 'width', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.width*this.scaleX);
			},
			set: function(value) {
				if (obj.scaleDimensions!==false) {
					var b = this.getBounds();
					if (zot(b) || b.width==0) {
						if (zon) zogy("DisplayObject() - width needs bounds set with setBounds()");
						return;
					}
					var s = value/b.width;
					this.scaleX = this.scaleY = s;
				} else {
					var p = obj.width!=0?obj.height/obj.width:0;
					obj.setWidth(value);
					obj.setHeight(value*p);
					obj.drawShape();
				}		
			}
		});
		Object.defineProperty(obj, 'height', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.height*this.scaleY);
			},
			set: function(value) {				
				if (obj.scaleDimensions!==false) {
					var b = this.getBounds();
					if (zot(b) || b.height==0) {
						if (zon) zogy("DisplayObject() - height needs bounds set with setBounds()");
						return;
					}
					var s = value/b.height;
					this.scaleX = this.scaleY = s;
				} else {
					var p = obj.height!=0?obj.width/obj.height:0;
					obj.setHeight(value);
					obj.setWidth(value*p);
					obj.drawShape();
				}	
				
			}
		});
		Object.defineProperty(obj, 'widthOnly', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.width*this.scaleX);
			},
			set: function(value) {
				if (obj.scaleDimensions!==false) {
					var b = this.getBounds();
					if ((zot(b) || b.width==0) && zon) {zogy("DisplayObject() - widthOnly needs bounds set with setBounds()"); return;}
					var s = value/b.width;
					this.scaleX = s;					
				} else {
					obj.setWidth(value);
					obj.drawShape();
				}				
			}
		});
		Object.defineProperty(obj, 'heightOnly', {
			enumerable: true,
			get: function() {
				// that.setBounds(null);
				var b = this.getBounds();
				return (zot(b))?null:Math.abs(b.height*this.scaleY);
			},
			set: function(value) {
				if (obj.scaleDimensions!==false) {
					var b = this.getBounds();
					if ((zot(b) || b.height==0) && zon) {zogy("DisplayObject() - heightOnly needs bounds set with setBounds()"); return;}
					var s = value/b.height;
					this.scaleY = s;
				} else {
					obj.setHeight(value);
					obj.drawShape();
				}	
			}
		});
		Object.defineProperty(obj, 'level', {
			enumerable: true,
			get: function() {
				if (this.parent) return this.parent.getChildIndex(this); return null;
			},
			set: function(value) {
				if (this.parent) this.parent.setChildIndex(this, Math.max(0, Math.min(value, this.parent.numChildren-1)));
			}
		});
		Object.defineProperty(obj, 'depth', {
			enumerable: true,
			get: function() {
				return this._depth;
			},
			set: function(depth) {
				this._depth = depth;
				if (!zot(this.vrChannel)) {
					var parallaxShift = this.vrParallaxDistance ? depth*this.vrParallax*this.vrParallaxDistance : 0;
					if (this.vrChannel == "left") {
						this.x = this.vrStartX + depth + parallaxShift;
					} else if (this.vrChannel == "right") {
						this.x = this.vrStartX - depth + parallaxShift;
					}
				}
			}
		});
		Object.defineProperty(obj, 'blendMode', {
			enumerable: true,
			get: function() {
				return this.compositeOperation;
			},
			set: function(value) {
				this.compositeOperation = value;
			}
		});
			
		if (!that.name) {
			var _name;
			Object.defineProperty(that, 'name', {
				get: function() {
					return _name;
				},
				set: function(value) {
					_name = value;
					zim.zimObjectIDs[value] = that;
				}
			});
		}
		that._draggable;
		Object.defineProperty(that, 'draggable', {
			get: function() {
				return this._draggable;
			},
			set: function(value) {
				if (value == this._draggable) return;
				this._draggable = value;
				if (this._draggable) this.drag();
				else this.noDrag();
			}
		});
		
		// allow dragging the page if the stage is dragged and allowDefault is on
		// TODO - perhaps add only if Frame is in tag mode
		var frame;
		var addCheck;
		that.on("mousedown", function (e) {
			if (e && e.nativeEvent && e.nativeEvent.touches) {
				if (e.target.stage) {
					frame = e.target.stage.frame;
					if (frame.allowDefault) {
						addCheck = true;
						frame.allowDefault = false;					
					}
				}
			}			
		}, null, null, null, null, mID);
		that.on("pressup", function () {
			if (frame && addCheck) frame.allowDefault = true;
		}, null, null, null, null, mID);
		
		// EFFECTS
		// making 8 properties, 4 that update effect and 4 that do not 
		// so that regular properties can update effect - obj.hue=20 // updates
		// but animate and wiggle can bulk update effect - obj.hueBatch=20 // does not update
		var effects = ["hue", "saturation", "brightness", "contrast"];
		for (var i=0; i<effects.length; i++) {
			-function() { // closure to remember eff
				var eff = effects[i];
				for (var j=0; j<2; j++) {
					-function() { // closure to remember add
						var add = j==0?"":"Batch";
						Object.defineProperty(that, eff+add, {
							get: function() {											
								if (that.effects && that.effects.multi) return that.effects.multi[eff];	
								else return 0;		
							},
							set: function(value) {
								if (!that.effects || !that.effects.multi) that.effect(new zim.MultiEffect(eff=="hue"?value:0,eff=="saturation"?value:0,eff=="brightness"?value:0,eff=="contrast"?value:0));
								else that.effects.multi[eff] = value;
								if (add=="") that.updateEffects(); 
							}
						});
					}();				
				}			
			}();
		}	
	
	}

zim.gD = function(obj) {
		if (!obj) return;
		if (obj.z_bc) { // ZIM ZIM 01 patch to help out Safari - thanks Chris Spolton
			var c = obj.z_bc;
	        c.width = c.height = 1;
	        if (c.getContext) c.getContext("2d").clearRect(0,0,1,1);
			delete obj.z_bc;
		}
		if (zim.KEYFOCUS == obj) zim.KEYFOCUS = null;
		if (WW.KEYFOCUS == obj) WW.KEYFOCUS = null;	
		if (obj.stage && obj.stage.frame) obj.stage.frame.cursorList.remove(obj);
		else if (zdf) zdf.cursorList.remove(obj);	
		if (obj.cacheCanvas) obj.uncache();
		if (obj.zimMask) obj.setMask(null);
		if (obj.veeObj) obj.veeObj = null;
		if (obj.draggable) obj.noDrag();
		if (obj.zimTouch) obj.noGesture();
		if (obj.zimTweens) obj.stopAnimate();
		if (obj.zimWire) obj.noWire();
		if (obj.zimWired) obj.noWired();
		if (obj.zimClickHoldDownEvent) obj.noHold();
		if (obj.motionController) obj.motionController.dispose();
		if (obj.transformControls) obj.transformControls.dispose();
		if (obj.zimClickDownEvent) obj.zimClickDownEvent = null;
		if (obj.zimClickUpEvent) obj.zimClickUpEvent = null;
		if (obj.physics) obj.removePhysics();
		if (obj.name && zim.zimObjectIDs[obj.name] == obj) delete zim.zimObjectIDs[obj.name];
	}

zim.Stage = function(canvasID, touch, singleTouch) {
	if (zot(canvasID)) return;
	var tag = canvasID.tagName=="CANVAS"?canvasID:zid(canvasID);
	if (zot(tag)) return;
	this.cjsStage_constructor(canvasID);
	this.setBounds(0,0,tag.width,tag.height);
	this.type = "Stage";

// MONITOR	
	var mID = this.mID = "z~"+this.type;

if (!WW.zdf) WW.zimDefaultFrame = WW.zdf = {stage:this};
	
	if (singleTouch) createjs.Touch.enable(this, true);
	else if (touch) createjs.Touch.enable(this, false);
				
	this.cache = function(a,b,c,d,scale,options) {
		if (zot(c)) {
			if (zot(a)) {
				var bounds = this.getBounds();
				if (!zot(bounds)) {
					var added = this.borderWidth > 0 ? this.borderWidth/2 : 0;
					a = bounds.x-added;
					b = bounds.y-added;
					c = bounds.width+added*2;
					d = bounds.height+added*2;
				}
			} else {
				c = a;
				d = b;
				a = 0;
				b = 0;
			}
		}
		this.cjsStage_cache(a,b,c,d,scale,options);
		this.z_bc = this.cacheCanvas;
		return this;
	};
	this.on("mousedown", function(e) {
		var e2 = e.clone();
		e2.type = "pressdown";
		e.target.dispatchEvent(e2);
	}, undefined, false, undefined, true, mID);	
	this.loop = function(call, reverse, interval, step, start, end) {
		return zim.loop(this, call, reverse, interval, step, start, end);
	};
	this.hitTestGrid = function(width, height, cols, rows, x, y, offsetX, offsetY, spacingX, spacingY, local, type) {
		return zim.hitTestGrid(this, width, height, cols, rows, x, y, offsetX, offsetY, spacingX, spacingY, local, type);
	};
	this.disposeAllChildren = function() {
		for (var i=this.numChildren-1; i>=0; i--) {
			var child = this.getChildAt(i)
			if (child.dispose) child.dispose();
		}
		return this;
	};

this.frame = WW.zdf;
	if (createjs && !createjs.stageTransformable && (WW.zdf.retina || typeof exportRoot != "undefined")) {
		Object.defineProperty(this, 'scale', {
			get: function () {
				return this.cjsStage_scale;
			},
			set: function (value) {
				this.cjsStage_scaleX = value;
				this.cjsStage_scaleY = value;
				zim.scaX = createjs.stageTransformable ? 1 : value;
				zim.scaY = createjs.stageTransformable ? 1 : value;
			}
		});

if (zot(a)) a = DS.a!=null?DS.a:null;
		if (zot(b)) b = DS.b!=null?DS.b:null;
		if (zot(c)) c = DS.c!=null?DS.c:null;
		if (zot(d)) d = DS.d!=null?DS.d:null;

this.cache = function(a,b,c,d,scale,options,margin,rtl,willReadFrequently) {			
			if (that.type=="AC"&&WW.zdf) {WW.zdf.ac("cache", arguments, that); return that;}
			var sig = "a,b,c,d,scale,options,margin,rtl,willReadFrequently";
			var duo; if (duo = zob(that.cache, arguments, sig)) return duo;
			var bounds = that.getBounds();
			if (zot(c)) {
				if (zot(a)) {
					if (!zot(bounds)) {
						var added = that.borderWidth > 0 ? that.borderWidth/2 : 0;
						a = bounds.x-added;
						b = bounds.y-added;
						c = bounds.width+added*2;
						d = bounds.height+added*2;
					}
				} else {
					c = a;
					d = b;
					a = 0;
					b = 0;
				}
			}			
			if (that.type == "Triangle") {
				a-=that.borderWidth?that.borderWidth:0;
				c+=that.borderWidth?that.borderWidth*2:0;
				b-=that.borderWidth?that.borderWidth:0;
				d+=that.borderWidth?that.borderWidth*2:0;
			}
			if (zot(margin)) margin = 0;
			that.cjsContainer_cache(a-margin,b-margin,c+margin*2,d+margin*2,scale,options,rtl,willReadFrequently);		
			
			// if (bounds && ((that.width == 0 && c > 0) || (options && options.adjustBounds))) {   
            //     that.setBounds(a, b, c, d);				
			// 	if (a!=bounds.x || b!=bounds.y || c!=bounds.width || d!=bounds.height) that.reg(a,b);
            //     that.hitArea = new zim.Shape().f(black).dr(a-margin,b-margin,c+margin*2,d+margin*2);                
            // }		
			
			if (bounds && ((that.width == 0 && c > 0) || (options && options.adjustBounds))) {   
				var oW = that.width;
                that.setBounds(a, b, c, d);	
				if (oW != 0) {
					if (a!=bounds.x || b!=bounds.y || c!=bounds.width || d!=bounds.height) that.reg(a,b);
					that.hitArea = new zim.Shape().f(black).dr(a-margin,b-margin,c+margin*2,d+margin*2);        
				}        
            }

that.z_bc = that.canvas = that.cacheCanvas;
			return that;
		};
		this.uncache = function() {
			that.cjsContainer_uncache();
			return that;
		};
		this.childrenToBitmap = function () {
			var cached = this.cacheCanvas;
			var pic = new zim.Bitmap(this.cache().cacheCanvas);
			if (!cached) this.uncache();
			this.removeAllChildren();
			pic.addTo(this);
			return this;
		};

this.sortBy = function(prop, inverse) {
			if (zot(prop)) return this;
			var sortFunction = function(obj1, obj2, options) {
				if (obj1[prop] > obj2[prop]) { return inverse?-1:1; }
				if (obj1[prop] < obj2[prop]) { return inverse?1:-1; }
				return 0;
			}
			this.sortChildren(sortFunction);
			return this;
		}
        
		this.normalize = function(prop, from, from2, min, max, factor, clamp) {

// TODO - special hue, saturation, etc.

var sig = "prop, from, from2, min, max, overflow, flip";
			var duo; if (duo = zob(that.normalize, arguments, sig)) return duo;

if (this.z_norm) {
                if (zot(prop)) prop = this.z_norm.prop;
                if (zot(from)) from = this.z_norm.from;
                if (zot(from2)) from2 = this.z_norm.from2;
                if (zot(from2)) min = this.z_norm.min;
                if (zot(max)) max = this.z_norm.max;
                if (zot(factor)) factor = this.z_norm.factor;
                if (zot(clamp)) clamp = this.z_norm.clamp;
            }

if (zot(from)) from = "start";
			else if (from == "left") from = "start";
			else if (from == "right") from = "end";
			else if (from == "middle") from = "center";
			else if (from != "start" && from != "center" && from != "end") from = "start";
			if (from=="center" && zot(from2)) from2 = "center";
			if (from2 == "top") from2 = "start";
			else if (from2 == "bottom") from2 = "end";
			else if (from2 == "middle") from2 = "center";
			else if (from2 != "start" && from2 != "center" && from2 != "end") from2 = "start";

this.z_norm = {prop:prop, from:from, from2:from2, min:min, max:max, factor:factor, clamp:clamp};

this.normalized = true;
            that.saveOriginalReg = function() {
                that.loop(function(c) {
                    c._orX = c.regX;
                    c._orY = c.regY;
                });
            }    
            that.resetOriginalReg = function() {
                that.loop(function(c) {
                    c.reg(c._orX, c._orY, true);	
                });
            }

if (prop == "reg") {
				that.resetOriginalReg();
				that.saveOriginalReg(); 
			
				// loop items and shift reg with third param true 
				var maxX = -10000000;
				var maxY = -10000000;

that.loop(function(c) {		
					c._dx = c._dy = null;			
					if (from == "center") c._dx = that.width/2-c.x;
					else if (from == "end") c._dx = that.width-c.x;
					else if (from == "start") c._dx = 0-c.x;
					if (from2 == "center") c._dy = that.height/2-c.y;
					else if (from2 == "start") c._dy = 0-c.y;
					else if (from2 == "end") c._dy = that.height-c.y;
					c.reg(c._dx,c._dy,true);
					maxX = Math.max(maxX, Math.abs(c._orX-c._dx));
					maxY = Math.max(maxY, Math.abs(c._orY-c._dy));
				});
				that.loop(function(c) {
					c.ratio = 1 - (Math.sqrt(Math.pow((c._orX-c._dx),2) + Math.pow((c._orY-c._dy),2)) / Math.sqrt(Math.pow(maxX,2) + Math.pow(maxY,2)));
					if (factor==-1) c.ratio = 1-c.ratio;
					if (clamp) c.ratio = zim.constrain(c.ratio, 0, 1);				
				});
				
			} else { // not reg
				if (zot(min) || zot(max)) setMM();
				var d;
				if (from == "start") d = [0,1,-1];
				else if (from == "end") d = [0,1,1];
				if (from == "center") d = [-1,1,-1];
				that.proportion = new zim.Proportion(min, max, d[0], d[1], d[2], false, clamp);				
				that.loop(function(c) {					
					c.ratio = Math.abs(that.proportion.convert(c[prop]));
					if (from == "center") c.ratio = 1-c.ratio;
				});
			}

function setMM() {
				var minC = 1000000000;
				var maxC = -1000000000;
				that.loop(function(c) {	
					if (zot(min) && c[prop] < minC) minC = c[prop];
					if (zot(max) && c[prop] > maxC) maxC = c[prop];
				});
				if (zot(min)) min = minC;
				if (zot(max)) max = maxC;
			}			
            return this;
		}

function recursiveDispose(obj, disposing) {

// MONITOR
		var mID = "z~Container";
		
		// zogr(obj.type)
		if (obj) zim.gD(obj); // globalDispose function for common elements
		// dispose was fixed in ZIM 10.7.0 in TWO ways:
		// ONE
		// Some classes have custom dispose - so may want to call these.
		// If disposing is true then we are coming from a custom dispose already
		// otherwise, call the custom dispose and pass true to say we are already disposing containers
		// otherwise the custom dispose will try and call the container dispose and we have an endless loop
		if (!disposing && obj && obj.dispose && obj.dispose !== zim.Container.prototype.dispose) {
			obj.dispose(null,null,true);
		}
		// TWO
		// dispose was only disposing type=="CONTAINER"
		// so should have been type=="Container" - but even that is too narrow
		// as would not include components parts or Tile parts, etc.
		// so fixed it to include all decendents of Container by testing for addChild
		// zog(obj.type)
		// if (obj.type == "Container") {
		if (obj && obj.addChild) {
			obj.dispatchEvent("removed");
			obj.removeAllEventListeners(null, mID);
			if (obj.numChildren) {
				for (var i=obj.numChildren-1; i>=0; i--) {
					recursiveDispose(obj.getChildAt(i));
				}
			}
		}
		if (obj && obj.parent) obj.parent.removeChild(obj);
	}
	zim.extend(zim.Container, createjs.Container, ["cache","uncache","setBounds","getBounds","clone","localToLocal","localToGlobal","globalToLocal"], "cjsContainer", false);
	zimify(zim.Container.prototype);

this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);
		
		// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);
		
		var that = this;

this.cache = function(a,b,c,d,scale,options,margin,rtl,willReadFrequently) {
			var sig = "a,b,c,d,scale,options,margin,rtl,willReadFrequently";
			var duo; if (duo = zob(that.cache, arguments, sig)) return duo;
			var bounds = that.getBounds();
			if (zot(c)) {
				if (zot(a)) {
					if (!zot(bounds)) {
						var added = that.borderWidth > 0 ? that.borderWidth/2 : 0;
						a = bounds.x-added;
						b = bounds.y-added;
						c = bounds.width+added*2;
						d = bounds.height+added*2;
					}
				} else {
					c = a;
					d = b;
					a = 0;
					b = 0;
				}
			}
			if (zot(margin)) margin = 0;
			that.cjsShape_cache(a-margin,b-margin,c+margin*2,d+margin*2,scale,options,rtl,willReadFrequently);
			if (bounds && options && options.adjustBounds && (a!=bounds.x || b!=bounds.y || c!=bounds.width || d!=bounds.height)) {                    
                that.setBounds(a, b, c, d);
                that.reg(a,b);
                that.hitArea = new zim.Shape().f(black).dr(a-margin,b-margin,c+margin*2,d+margin*2);                
            }	
			that.z_bc = that.canvas = that.cacheCanvas;
			return that;
		};
		this.setBounds = function(a,b,c,d) {
			var n = normalizeBounds(a, b, c, d);
			this.cjsShape_setBounds(n[0],n[1],n[2],n[3]);
			this.width;
			return this;
		};
		this.getBounds = function(targetSpace) {
			if (targetSpace) {
				return that.boundsToGlobal(null,null,null,targetSpace);
			}
			return that.cjsShape_getBounds();
		};
		if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
		this.clone = function(recursive) {
			if (zot(recursive)) recursive = true;
			var currentBounds = this.getBounds();
			if (zot(currentBounds)) currentBounds = {x:null, y:null, width:null, height:null};
			var c = that.cloneProps(new zim.Shape(currentBounds.x,currentBounds.y,currentBounds.width,currentBounds.height, graphics, style, group, inherit));
			if (recursive) c.graphics = that.graphics.clone();
			else c.graphics = that.graphics;
			return c;
		};
		var frame = WW.zdf || 1;
		if (createjs && !createjs.stageTransformable && frame.retina) {
			this.localToGlobal = function(x,y) {
				return zim.localToGlobal(x,y,this,this.cjsShape_localToGlobal);
			};
			this.globalToLocal = function(x,y) {
				return zim.globalToLocal(x,y,this,this.cjsShape_globalToLocal);
			};
			this.localToLocal = function(x,y,target) {
				return zim.localToLocal(x,y,target,this);
			};
		}
		this.hasProp = function(prop) {
			return (!zot(this[prop]) || Object.prototype.hasOwnProperty.call(this,prop));
		};
		// this.pg = function(points, close) {
		// 	if (!Array.isArray(points)) points = Array.from(arguments);
		// 	var type = 	points[0].x != null?"obj":points[0][0] != null?"arr":"par";	
		// 
		// 	var p, fp, sp;
		// 	if (type=="obj") p = points[0];
		// 	else if (type=="arr") p = {x:points[0][0], y:points[0][1]||0};
		// 	else p = {x:points[0], y:points[1]||0};
		// 	fp = {x:p.x, y:p.y};
		// 	this.mt(fp.x, fp.y);			
		// 	for (var i=1; i<points.length; i++) {
		// 		if (type=="obj") p = points[i];
		// 		else if (type=="arr") p = {x:points[i][0], y:points[i][1]||0};
		// 		else p = {x:points[i*2], y:points[i*2+1]||0};
		// 		if (i==1) sp = {x:p.x, y:p.y};
		// 		this.lt(p.x, p.y);								
		// 	}	
		// 	this.lt(fp.x, fp.y).lt(sp.x, sp.y); // go around to second point to get correct end bevel/miter
		// 	return this;
		// }
		
		zim.displayBase(that);	
		
		this.dispose = function() {
			zim.gD(this); // globalDispose function for common elements
			this.graphics.c();
			this.dispatchEvent("removed");
			this.removeAllEventListeners(null, mID);
			if (this.parent) this.parent.removeChild(this);
		};
	};
	zim.extend(zim.Shape, createjs.Shape, ["cache","clone","setBounds","getBounds","localToLocal","localToGlobal","globalToLocal"], "cjsShape", false);
	zimify(zim.Shape.prototype);

zim.Bitmap = function(image, width, height, left, top, scale, style, group, inherit) {	
	var sig = "image, width, height, left, top, scale, style, group, inherit";
	var duo; if (duo = zob(zim.Bitmap, arguments, sig, this)) return duo;

this.group = group;
	var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle("Bitmap", this.group, inherit);
	if (zot(scale)) scale = DS.scale!=null?DS.scale:1;
	if (zot(width)) width = DS.width!=null?DS.width:image?image.width:100;
	if (zot(height)) height = DS.height!=null?DS.height:image?image.height:100;
	if (zot(left)) left = DS.left!=null?DS.left:0;
	if (zot(top)) top = DS.top!=null?DS.top:0;
		
	var displayCheck = false;
	var imageOriginal = image;
	if (!zot(image)) {
		if (image.uncache) { // testing if it has a CreateJS uncache method
			displayCheck = true;
			var cached = image.cacheCanvas;
			var original = image;
			var bOriginal = original.getBounds();
			image.cache(left,top,width,height,scale); // do not chain on end as might be createjs image
			this.z_bc = image = image.cacheCanvas; // what we will pass to bitmap
		}		
	}	
	this.cjsBitmap_constructor(image);
	if (original && !cached) original.uncache();
	if (bOriginal) original.setBounds(bOriginal.x, bOriginal.y, bOriginal.width, bOriginal.height);
	
	var that = this;
	this.type = "Bitmap";	
	
	// MONITOR		
	var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (!zot(width) && !zot(height)) this.setBounds(0,0,width*scale,height*scale);

this.cacheScale = scale;
	
	this.drawImageData = function(x, y, sourceX, sourceY, sourceWidth, sourceHeight) {
		if (zot(x)) x = 0;
		if (zot(y)) y = 0;
		if (zot(sourceX)) sourceX = 0;
		if (zot(sourceY)) sourceY = 0;
		if (zot(sourceWidth)) sourceWidth = width;
		if (zot(sourceHeight)) sourceHeight = height;
		if (!that.proxyCanvas) {
			var c = that.proxyCanvas = document.createElement("canvas");
			c.setAttribute("width", width);
			c.setAttribute("height", height);
			that.proxyContext = c.getContext('2d');
			image = imageOriginal = that.image = c;
		}
		if (that.proxyContext) {
			that.proxyContext.putImageData(that.imageData, x, y, sourceX, sourceY, sourceWidth, sourceHeight);
		}
	}

if (WW.zdf) {
		// not supported by IE - thanks Chris Spolton for the find and suggested fix
		if (WW.zdf.canvas.getContext("2d")) {
			this.imageData = WW.zdf.canvas.getContext("2d").createImageData(width, height);
		} else {
			this.imageData = document.createElement('canvas').getContext("2d").createImageData(width, height);
			// if (ImageData) this.imageData = new ImageData(width, height);
		}
		if (zot(image)) that.drawImageData();

// handle delay when creating Bitmap from data
		if (image && image.match && image.match(/data:image/i)) setTimeout(function() {
			if (that.stage) that.stage.update();
			setTimeout(function() {
				if (that.stage) that.stage.update();
			}, 50);
		}, 50);
	}
	
	if (image && image.nodeName && image.nodeName.toLowerCase() != "video") {
		if (displayCheck) that.sourceRect = {x:0, y:0, width:width*scale, height:height*scale};
		else that.sourceRect = {x:left, y:top, width:width, height:height};
	}
	function normalizeBounds(a, b, c, d) {
		var bounds = [];
		if (zot(a)) {
			bounds = [a,b,c,d];
		} else if (zot(b)) {
			if (a.x) bounds = [a.x, a.y, a.width, a.height]; 	
			else {
				bounds[0] = 0;
				bounds[1] = 0;
				bounds[2] = a;
				bounds[3] = a;
			}		
		} else if (!zot(c)) {
			bounds[0] = a;
			bounds[1] = b;
			bounds[2] = c;
			bounds[3] = d;
		} else {
			bounds[0] = 0;
			bounds[1] = 0;
			bounds[2] = a;
			bounds[3] = b;
		}
		if (zot(bounds[3])) bounds[3] = bounds[2];
		return bounds;
	}
	this.setBounds = function(a,b,c,d) {
		var n = normalizeBounds(a, b, c, d);
		that.cjsBitmap_setBounds(n[0],n[1],n[2],n[3]);
		that.width;
		return that;
	};
	this.getBounds = function(targetSpace) {
		if (targetSpace) {
			return that.boundsToGlobal(null,null,null,targetSpace);
		}
		return that.cjsBitmap_getBounds();
	};

this.cache = function(a,b,c,d,scale,options,rtl,willReadFrequently) {
		var sig = "a,b,c,d,scale,options,rtl,willReadFrequently";
		var duo; if (duo = zob(that.cache, arguments, sig)) return duo;
		var bounds;
		that.cacheScale = scale;
		if (zot(c)) {
			if (zot(a)) {
				bounds = this.getBounds();
				if (!zot(bounds)) {
					var added = this.borderWidth > 0 ? this.borderWidth/2 : 0;
					a = bounds.x-added;
					b = bounds.y-added;
					c = bounds.width+added*2;
					d = bounds.height+added*2;
				}
			} else {
				c = a;
				d = b;
				a = 0;
				b = 0;
			}
		}
		bounds = that.getBounds();
		that.cjsBitmap_cache(a,b,c,d,scale,options,rtl,willReadFrequently);		
		if (bounds && options && options.adjustBounds && (a!=bounds.x || b!=bounds.y || c!=bounds.width || d!=bounds.height)) {                    
			that.setBounds(a, b, c, d);
			that.reg(a,b);
			that.hitArea = new zim.Shape().f(black).dr(a-margin,b-margin,c+margin*2,d+margin*2);                
		}	
		that.z_bc = that.canvas = that.cacheCanvas;
		return that;
	};
		
	this.clone = function() {		
		var c = this.cloneProps(new zim.Bitmap(imageOriginal, width, height, left, top, scale, style, this.group, inherit));
		c.cloned = true;
		c.src = that.src;
		c.file = that.file;
		c.image = that.image;
		c.svg = that.svg;
		c.item = that.item;
		return c;
	};
	var frame = WW.zdf || 1;
	if (createjs && !createjs.stageTransformable && frame.retina) {
		this.localToGlobal = function(x,y) {
			return zim.localToGlobal(x,y,this,this.cjsBitmap_localToGlobal);
		};
		this.globalToLocal = function(x,y) {
			return zim.globalToLocal(x,y,this,this.cjsBitmap_globalToLocal);
		};
		this.localToLocal = function(x,y,target) {
			return zim.localToLocal(x,y,target,this);
		};
	}
	this.hasProp = function(prop) {
		return (!zot(this[prop]) || Object.prototype.hasOwnProperty.call(this,prop));
	};
	var myContext;
	this.getColorAt = function(x,y,array) {
		if (!myContext) {
			that.cache(null,null,null,null,null,null,null,true);
			myContext = that.cacheCanvas.getContext('2d');			
			that.uncache();
		}	
		var d = myContext.getImageData(x, y, 1, 1).data;
		d[3] /= 255;
		if (array) return d;
		return "rgba("+d[0]+","+d[1]+","+d[2]+","+d[3]+")";
	};

this.keyOut = function(color, tolerance, replacement) {
		if (zot(color)) color = "#389b26";
		if (zot(tolerance)) tolerance = .1;
		if (!Array.isArray(color)) color = [color];
		if (!Array.isArray(tolerance)) tolerance = [tolerance];
		if (!zot(replacement) && !Array.isArray(replacement)) replacement = [replacement];
		var i, j;
		var c = [];
		var t = []; 
		var rep = []; 
		for (i=0; i<color.length; i++) {
			c[i] = zim.convertColor(color[i], "array");
			if (tolerance[i]!=null) t[i] = tolerance[i] * 255;
			else t[i] = tolerance[0] * 255;
			if (replacement) {
				if (replacement[i]!=null) {
					rep[i] = zim.convertColor(replacement[i], "array");
					rep[i][3] *= 255;
				} else {
					rep[i] = zim.convertColor(replacement[0], "array");
					rep[i][3] *= 255;
				}
			}
		}	
		
		if (that.cacheCanvas) that.updateCache();
		if (!myContext) {
			that.cache(null,null,null,null,null,null,null,true);
			myContext = that.cacheCanvas.getContext('2d');
			// that.uncache();
		}
		var info = myContext.getImageData(left, top, width, height)
		var d = info.data;
		var l = d.length/4;
		if (replacement) {
			for (i=0; i<l; i++) {
				var r = d[i*4+0];
				var g = d[i*4+1];
				var b = d[i*4+2];
				for (j=0; j<color.length; j++) {
					if (r>c[j][0]-t[j]&&r<c[j][0]+t[j]&&g>c[j][1]-t[j]&&g<c[j][1]+t[j]&&b>c[j][2]-t[j]&&b<c[j][2]+t[j]) {												
						d[i*4+0]=rep[j][0]; 
						d[i*4+1]=rep[j][1]; 
						d[i*4+2]=rep[j][2]; 
						d[i*4+3]=rep[j][3]; 						
					}
				}
			}
		} else {
			for (i=0; i<l; i++) {
				var r = d[i*4+0];
				var g = d[i*4+1];
				var b = d[i*4+2];
				for (j=0; j<color.length; j++) {
					if (r>c[j][0]-t[j]&&r<c[j][0]+t[j]&&g>c[j][1]-t[j]&&g<c[j][1]+t[j]&&b>c[j][2]-t[j]&&b<c[j][2]+t[j]) {
						d[i*4+3]=0; // no alpha for color						
					}
				}
			}
		}		
		myContext.putImageData(info,top,left);
		return this;
	}

this.removeGreenScreen = function(smoothing, hueMin, hueMax, satMin, lightMin) {

if (zot(smoothing)) smoothing = 0;  // Edge smoothing factor (0-10) - higher values create smoother edges around subjects
        if (zot(hueMin)) hueMin = 80;    // Minimum hue value (0-360) for green detection - sets the lower bound of green hues
        if (zot(hueMax)) hueMax = 160;   // Maximum hue value (0-360) for green detection - sets the upper bound of green hues 
        if (zot(satMin)) satMin = 30;    // Minimum saturation value (0-100) - avoids detecting desaturated/grayish pixels as green
        if (zot(lightMin)) lightMin = 15;  // Minimum lightness value (0-100) - avoids detecting very dark pixels as green
        
		if (!myContext) {
			that.cache(null,null,null,null,null,null,null,true);
			myContext = that.cacheCanvas.getContext('2d');
			// that.uncache();
		}
		        
        // Get pixel data
        var imageData = myContext.getImageData(0, 0, width, height);
        var data = imageData.data;
        
        // Function to convert RGB to HSL
        function rgbToHsl(r, g, b) {
            r /= 255;
            g /= 255;
            b /= 255;
            
            var max = Math.max(r, g, b);
            var min = Math.min(r, g, b);
            var h, s, l = (max + min) / 2;
            
            if (max === min) {
                h = s = 0; // gray
            } else {
                var d = max - min;
                s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
                
                switch (max) {
                    case r: h = (g - b) / d + (g < b ? 6 : 0); break;
                    case g: h = (b - r) / d + 2; break;
                    case b: h = (r - g) / d + 4; break;
                }
                
                h /= 6;
            }
            
            return { 
                h: h * 360, // convert to degrees
                s: s * 100, // percentage
                l: l * 100  // percentage
            };
        }
        
        // Process each pixel
        for (var i = 0; i < data.length; i += 4) {
            var r = data[i];
            var g = data[i + 1];
            var b = data[i + 2];
            
            // Convert to HSL for easier green detection
            var hsl = rgbToHsl(r, g, b);
            
            // Check if pixel is in the defined green range
            var isGreen = (hsl.h >= hueMin && hsl.h <= hueMax && 
                        hsl.s >= satMin && 
                        hsl.l >= lightMin);
                        
            // Set transparency with edge smoothing
            var alpha = 255; // opaque by default
            
            if (isGreen) {
                // Completely transparent pixel
                alpha = 0;
            } else if (smoothing > 0) {
                // Check if pixel is close to green range - for edge smoothing
                var hueDiff = Math.min(
                    Math.abs(hsl.h - hueMin),
                    Math.abs(hsl.h - hueMax)
                );
                
                if (hueDiff < smoothing * 5) {
                    // Reduce opacity gradually based on proximity to green
                    var factor = hueDiff / (smoothing * 5);
                    alpha = Math.min(255, Math.max(0, Math.round(factor * 255)));
                }
            }
            
            // Save pixel with updated transparency
            data[i + 3] = alpha;
        }
        
        // Update image data
        myContext.putImageData(imageData, 0, 0);
        
        return that;
    }

this.addBitmapData = function() {
		if (!createjs.BitmapData) {
			zogy("zim.Bitmap addBitmapData() needs CreatejS 1.5.0 or greater"); return that;
		}			
		var cc = that.cacheCanvas?that.cacheCanvas:that.cache().cacheCanvas;
		var bitmapData = new createjs.BitmapData(cc);
		var bbd = new zim.Bitmap(bitmapData.canvas);
		bbd.bitmapData = bitmapData;
		return bbd;
	}

this.color = function(color, thresholdColor, x, y) {
		if (!that.stage) return;
		if (!that.bitmapData) {
			zogy("zim.Bitmap must be made with addBitmapData() to use color()"); return that;
		}
		if (zot(color)) color = red;
		color = zik(color);
		if (zot(thresholdColor)) thresholdColor = dark;
		var F = that.stage.frame?that.stage.frame:zdf;			
		// convert our mouse point to a point on the bitmap
		var point;
		if (x!=null && y!=null) {
			point = {x:x, y:y};
		} else {
			point = that.globalToLocal(F.mouseX, F.mouseY);	
		}
		// avoid pressing on the same color or the border color
		var currentColor = this.bitmapData.getPixel(point.x, point.y);
		if (
			currentColor == zim.convertColor(color, 'hexnumber') || 
			currentColor <  zim.convertColor(thresholdColor, "hexnumber") // towards black
		) return;    
		// get the colorPicker color as hexstring - needed for floodFill
		var newColor = zim.convertColor(color, 'hexstring');    
		// do a floodFill from the point with the new color
		that.bitmapData.floodFill(point.x, point.y, newColor);
		return that;
	}

zim.displayBase(that);
	
	if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
	
	// this.dispose = function() {
	this.doDispose = function() {
		zim.gD(this); // globalDispose function for common elements
		this.dispatchEvent("removed");
		this.removeAllEventListeners(null, mID);
		if (!this.cloned) {
			if (this.id) {
				if (this.stage && this.stage.frame) frame = this.stage.frame;
				else frame = WW.zdf;
				if (frame && frame.assets) {
					if (frame.assets[this.id]) delete frame.assets[this.id];
				}
				if (zim.assets[this.id]) delete zim.assets[this.id];
			}		
		}	
		if (this.parent) this.parent.removeChild(this);
	};
};
zim.Bitmap.fromData = function(data, callback) {
	var width = 100;
	var height = 100;	
	var img = new Image();
	img.onload = function() {
		width = img.naturalWidth;
		height = img.naturalHeight;
		if (zot(width)) width = img.width;
		if (zot(height)) height = img.height;
		var bitmap = new zim.Bitmap(data, width, height);
		setTimeout(function() {
			callback(bitmap);
		}, 50);
	}
	img.src = data;	
};
zim.extend(zim.Bitmap, createjs.Bitmap, ["cache","clone","dispose","setBounds","getBounds","localToLocal","localToGlobal","globalToLocal"], "cjsBitmap", false);
zim.Bitmap.prototype.dispose = function() {return this.doDispose();};
zimify(zim.Bitmap.prototype);

this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

var that = this;
		var sheet;
		if (zot(frame)) frame = DS.frame!=null?DS.frame:WW.zdf;
		if (image && typeof image == "string") image = frame.asset(image);
		if (zot(json) && !zot(image)) {
			if (zot(cols)) cols = DS.cols!=null?DS.cols:1;
			if (zot(rows)) rows = DS.rows!=null?DS.rows:1;
			if (zot(count)) count = DS.count!=null?DS.count:(cols*rows);
			if (zot(offsetX)) offsetX = DS.offsetX!=null?DS.offsetX:0;
			if (zot(offsetY)) offsetY = DS.offsetY!=null?DS.offsetY:0;
			if (zot(spacingX)) spacingX = DS.spacingX!=null?DS.spacingX:0;
			if (zot(spacingY)) spacingY = DS.spacingY!=null?DS.spacingY:0;
			if (zot(width)) width = DS.width!=null?DS.width:image.width;
			if (zot(height)) height = DS.height!=null?DS.height:image.height;
			if (image.bitmap) image = image.bitmap;

// {
				// 	"frames": {
				// 		"bl_01.png": {
				// 				"frame": {
				// 					"x": 1,
				// 					"y": 1,
				// 					"w": 73,
				// 					"h": 143
				// 				},
								
				// json is in JSON hash format
				// {id:{},id:{}}
				fr = [];
				an = {};
				var i = 0;
				for (f in json.frames) {
					ff = json.frames[f].frame;
					fr.push([ff.x, ff.y, ff.w, ff.h]);
					an[f.split(".")[0]] = i++;
				}				
				json.frames = fr;		
				if (!animations) animations = json.animations = an;

} else if (json.frames && !Array.isArray(json.frames[0])) {

// {
				// 	"frames": [
				// 		{
				// 			"filename": "bl_01.png",
				// 			"frame": {
				// 				"x": 1,
				// 				"y": 1,
				// 				"w": 73,
				// 				"h": 143
				// 			},

// json is in JSON array format
				// [{},{}]
				fr = [];
				var an = {};
				for (f=0; f<json.frames.length; f++) {
					var ff = json.frames[f].frame;
					fr.push([ff.x, ff.y, ff.w, ff.h]);
					an[json.frames[f].filename.split(".")[0]] = f;
				}		
				if (!animations) animations = json.animations = an;			
				json.frames = fr;
				
			} else if (!json.frames) {
				// handle XML format for Kenny files, etc.
				var dt = new zim.Dat(json_o);
				fr = [];				
				an = {};
				zim.loop(dt.data, function(child, i) {
					fr.push([child.getAttribute("x"), child.getAttribute("y"), child.getAttribute("width"), child.getAttribute("height")]);
					an[child.getAttribute("name").split(".")[0]] = i;
				})
				json = {};
				if (!animations) animations = json.animations = an;				
				json.frames = fr;
			}

if (!json.images && json.meta && json.meta.image) {
				json.images = [json.meta.image];
			}	
			
			// even though data is in JSON, may want to create SpriteSheet from image
			// so that cors will work - so see if provided an image
			// or that the images in the JSON are available in frame.assets
			frames = json.frames;
			animations = json.animations;
			if (!zot(image)) {				
				makeSheet(image, frames, animations);
			} else {
				var im = json.images?json.images[0]:null;
				if (!im || !im.split) {
					sheet = new createjs.SpriteSheet(json);
				} else {
					var assets = [];
					zim.loop(json.images, function(im) {
						var imEnd = im.split("/").pop();
						if (frame.asset(imEnd) && frame.asset(imEnd).type != "EmptyAsset") {
							assets.push(frame.asset(imEnd));
						} else if (frame.asset(im) && frame.asset(im).type != "EmptyAsset") {
							assets.push(frame.asset(im));
						} else if (frame.asset(im).type != "EmptyAsset") {
							assets.push(frame.asset(im));
						} else {
							if (zon) zogy("Sprite() - please preload Sprite in Frame or with loadAssets");
						}
					});
					makeSheet(assets, frames, animations);					
				}
			}
		} else {
			return;
		}

this.animations = animations;
		this.cjsSprite_constructor(sheet, label);
		if (!zot(label)) this.stop();

if (zot(id)) id = zim.makeID();
		this.id = id;

if (zot(globalControl)) globalControl = true;
		that.globalControl = globalControl;

this.run = function(time, label, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startFrame, endFrame, frame, tweek, id, globalControl, pauseOnBlur) {
			var sig = "time, label, call, params, wait, waitedCall, waitedParams, loop, loopCount, loopWait, loopCall, loopParams, loopWaitCall, loopWaitParams, loopPick, rewind, rewindWait, rewindCall, rewindParams, rewindWaitCall, rewindWaitParams, rewindTime, rewindEase, startFrame, endFrame, frame, tweek, id, globalControl, pauseOnBlur";
			var duo; if (duo = zob(that.run, arguments, sig)) return duo;

if (that.running) that.stopAnimate(that.id); // ZIM 017 - moved this up so single frame stops previous animation

var timeType = getTIME();

var obj;
			if (zot(tweek)) tweek = 1;
			if (!zot(id)) that.id = id;
			if (!zot(globalControl)) that.globalControl = globalControl;
			if (!zot(frame)) {
				startFrame = endFrame = frame;
				that.frame = frame;
				that.randFrame = false;
				return that; // just go to the frame ZIM 017
			}

that.running = true; // not calling a single frame a run - as it does not animate - ZIM 017

var extraTime;
			if (Array.isArray(label)) {				
				// check labels
				var innerLabel;
				var lastLabel;
				obj = [];
				extraTime = 0;
				var firstStartFrame;
				for (var i=0; i<label.length; i++) {
					innerLabel = label[i]; // {label:"first", time:1, etc}

// based on previous frames
					if (zot(innerLabel.wait)) innerLabel.wait = extraTime*tweek;

lastLabel = innerLabel.label;
					delete innerLabel.label;

obj.push(innerLabel);

// if (i==0) firstStartFrame = startFrame;
				}				
				//startFrame = firstStartFrame;
				if (obj.length == 0) return this;
				if (obj.length == 1) { // just one label in list ;-)
					time = obj[0].time;
					label = lastLabel;
					setSingle();
				} else {
					that.gotoAndStop(firstStartFrame);
				}
			} else { // single label
				setSingle();
			}

if (zot(time)) time = timeType=="s"?1:1000;
			
			
			if (!Array.isArray(obj)) {
				extraTime = 0;
				if (endFrame-startFrame > 0) extraTime = time / Math.abs(endFrame-startFrame) / 2; // slight cludge - seems to look better?
				if (_normalizedFrames && _normalizedFrames.length>0) extraTime = time / _normalizedFrames.length / 2; // slight cludge - seems to look better?
				if (loop && zot(loopWait)) {loopWait = extraTime*tweek;}
				if (rewind && zot(rewindWait)) {rewindWait = extraTime*tweek;}
			}

// locally override call to add running status after animation done
			var localCall = function() {
				that.running = false;
				that.stop();
				if (call && typeof call == 'function') call(params||that);				
			};
			zim.animate({
				target:that,
				obj:obj,
				time:time,
				ease:"linear",
				call:localCall,
				params:params,
				wait:wait, waitedCall:waitedCall, waitedParams:waitedParams,
				loop:loop,
				loopCount:loopCount,
				loopWait:loopWait,
				loopPick:loopPick,
				// animateCall:function() {zog(that.latestTween.percentComplete);},
				loopCall:loopCall, loopParams:loopParams,
				loopWaitCall:loopWaitCall, loopWaitParams:loopWaitParams,
				rewind:rewind, rewindWait:rewindWait, // rewind is ignored by animation series
				rewindCall:rewindCall, rewindParams:rewindParams,
				rewindWaitCall:rewindWaitCall, rewindWaitParams:rewindWaitParams,
				rewindTime:rewindTime, rewindEase:rewindEase,
				override:false,
				pauseOnBlur:pauseOnBlur,
				id:that.id
			});
			that.runPaused = false;
			that.pauseAnimate(false); // needed after 015 latestTween adjustments because Sprite starts with animating=false
			return that;
		};

Object.defineProperty(this, 'frame', {
			get: function() {
				return this.currentFrame;
			},
			set: function(value) {
				value = Math.round(value);
				that.randFrame = false;
				if (this.paused) {
					this.gotoAndStop(value);
				} else {
					this.gotoAndPlay(value);
				}
			}
		});

Object.defineProperty(this, 'normalizedFrames', {
			get: function() {
				return _normalizedFrames;
			},
			set: function(value) {
				_normalizedFrames = value;
			}
		});

Object.defineProperty(this, 'totalFrames', {
			get: function() {
				return sheet.getNumFrames();
			},
			set: function() {
				zogy("zim.Sprite - totalFrames is read only");
			}
		});

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it
		this.clone = function(exact) {
			var s = this.cloneProps(new zim.Sprite(image, cols, rows, count, offsetX, offsetY, spacingX, spacingY, width, height, animations, json, null, globalControl, spriteSheet, label, frame, style, this.group, inherit));
			
			// modified ZIM 017 late patch - for random frame sprite default with Tile, etc.
			if (exact || !that.randFrame) s.frame = that.frame;
			
			return s;			
		};
		if (createjs && !createjs.stageTransformable && frame.retina) {
			this.localToGlobal = function(x,y) {
				return zim.localToGlobal(x,y,this,this.cjsSprite_localToGlobal);
			};
			this.globalToLocal = function(x,y) {
				return zim.globalToLocal(x,y,this,this.cjsSprite_globalToLocal);
			};
			this.localToLocal = function(x,y,target) {
				return zim.localToLocal(x,y,target,this);
			};
		}
		
		this.hasProp = function(prop) {
			return (!zot(this[prop]) || Object.prototype.hasOwnProperty.call(this,prop));
		};
		
		zim.displayBase(that);
		function normalizeBounds(a, b, c, d) {
			var bounds = [];
			if (zot(a)) {
				bounds = [a,b,c,d];
			} else if (zot(b)) {
				if (a.x) bounds = [a.x, a.y, a.width, a.height]; 	
				else {
					bounds[0] = 0;
					bounds[1] = 0;
					bounds[2] = a;
					bounds[3] = a;
				}		
			} else if (!zot(c)) {
				bounds[0] = a;
				bounds[1] = b;
				bounds[2] = c;
				bounds[3] = d;
			} else {
				bounds[0] = 0;
				bounds[1] = 0;
				bounds[2] = a;
				bounds[3] = b;
			}
			if (zot(bounds[3])) bounds[3] = bounds[2];
			return bounds;
		}
		this.setBounds = function(a,b,c,d) {
			var n = normalizeBounds(a, b, c, d);
			that.cjsSprite_setBounds(n[0],n[1],n[2],n[3]);
			that.width;
			return that;
		};
		this.getBounds = function(targetSpace) {
			if (targetSpace) {
				return that.boundsToGlobal(null,null,null,targetSpace);
			}
			return that.cjsSprite_getBounds();
		};

if (!label) {
			that.gotoAndStop(zim.rand(that.totalFrames-1));
			that.randFrame = true;
		}

this.dispose = function() {
			zim.gD(this); // globalDispose function for common elements
			this.dispatchEvent("removed");
			this.removeAllEventListeners(null, mID);
			if (this.parent) this.parent.removeChild(this);
		};
	};
	zim.extend(zim.Sprite, createjs.Sprite, ["clone","setBounds","getBounds","localToLocal","localToGlobal","globalToLocal"], "cjsSprite", false);
	zimify(zim.Sprite.prototype);

zim.CustomShape = function(x, y, w, h) {

this.zimContainer_constructor(x, y, w, h, false);

// depreciated
	this.linearGradient = function(colors,ratios,x0,y0,x1,y1) {
		this.linearGradientParams = Array.prototype.slice.call(arguments);
		this.colorCommand.linearGradient(colors,ratios,x0,y0,x1,y1);
		return this;
	};
	this.radialGradient = function(colors,ratios,x0,y0,radius0,x1,y1,radius1) {
		this.radialGradientParams = Array.prototype.slice.call(arguments);
		this.colorCommand.radialGradient(colors,ratios,x0,y0,radius0,x1,y1,radius1);
		return this;
	};
	
	// special clone that clones contents of shape
	this.cloneAll = function(exact, style, group, inherit) {
		var currentBounds = this.getBounds();
		if (zot(currentBounds)) currentBounds = {x:null, y:null, width:null, height:null};
		var body = this.cloneChildren(this.cloneProps(new zim.Container(currentBounds.x,currentBounds.y,currentBounds.width,currentBounds.height, style, group, inherit)), exact);
		body.mouseChildren = false;
		body.type = this.type;
		return body;
	};

};
zim.extend(zim.CustomShape, zim.Container, null, "zimContainer", false);

zim.Circle = function(radius, color, borderColor, borderWidth, dashed, percent, percentClose, percentArc, strokeObj, style, group, inherit) {
	var sig = "radius, color, borderColor, borderWidth, dashed, percent, percentClose, percentArc, strokeObj, style, group, inherit";
	var duo; if (duo = zob(zim.Circle, arguments, sig, this)) return duo;
	this.zimCustomShape_constructor(null,null,null,null,false);
	this.type = "Circle";	
	this.group = group;
	// var DS = style===false?{}:zim.getStyle(this.type, this.group, inherit);
	// adjustments for groupOnly - to set style:false and still use group
	var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);
	
	// MONITOR		
	this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(radius)) radius = DS.radius!=null?DS.radius:50;
	if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
	if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
	if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
	if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
	else if (borderColor!=null && borderWidth==null) borderWidth = 1;
	if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":zim.black);
	if (zot(percent)) percent = DS.percent!=null?DS.percent:100;
	if (zot(percentClose)) percentClose = DS.percentClose!=null?DS.percentClose:true;
	if (zot(percentArc)) percentArc = DS.percentArc!=null?DS.percentArc:null;
	if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

// PICK
	var oa = remember(radius, color, borderColor, borderWidth, percent);
	this.veeObj = {radius:oa[0], color:oa[1], borderColor:oa[2], borderWidth:oa[3], percent:oa[4]};
	function remember() {return arguments;} // for cloning PICK
	radius = zim.Pick.choose(radius);
	color = zim.Pick.choose(color);
	borderColor = zim.Pick.choose(borderColor);
	borderWidth = zim.Pick.choose(borderWidth);
	percent = zim.Pick.choose(percent);

var that = this;
	that._radius = radius;
	that._color = color;
	that._borderColor = borderColor;
	that._borderWidth = borderWidth;
	that._dashed = dashed;
	if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];

var circle = this.shape = new createjs.Shape();
	this.addChild(circle);

Object.defineProperty(that, 'radius', {
		get: function() {
			return that._radius;
		},
		set: function(value) {
			that._radius = value;
			that.drawShape();
		}
	});
	
	Object.defineProperty(that, 'percentage', {
		get: function() {
			return percent;
		},
		set: function(value) {
			percent = value;
			that.drawShape();
		}
	});
	
	Object.defineProperty(that, 'percentClose', {
		get: function() {
			return percentClose;
		},
		set: function(value) {
			percentClose = value;
			that.drawShape();
		}
	});

Object.defineProperty(that, 'percentArc', {
		get: function() {
			return percentArc;
		},
		set: function(value) {
			percentArc = value;
			that.drawShape();
		}
	});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	// NOTE: extends ZIM CustomShape for more properties and a few functions.
	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it

this.clone = function(exact, useStyle) {
		var cloneStyle = zot(useStyle)?style:useStyle;
		if (exact) cloneStyle = false; 
		var newShape = that.cloneProps(new zim.Circle((exact||!zim.isPick(oa[0]))?that.radius:oa[0], (exact||!zim.isPick(oa[1]))?that.color:oa[1], (exact||!zim.isPick(oa[2]))?that.borderColor:oa[2], (exact||!zim.isPick(oa[3]))?that.borderWidth:oa[3], that.dashed, (exact||!zim.isPick(oa[4]))?percent:oa[4], percentClose, percentArc, strokeObj, cloneStyle, this.group, inherit));
		if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
		if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
		return newShape;
	};
};
// zim.Circle.prototype.toString = function() {return ["Circle"];};
zim.extend(zim.Circle, zim.CustomShape, "clone", "zimCustomShape", false);

zim.Rectangle = function(width, height, color, borderColor, borderWidth, corner, dashed, strokeObj, scaleDimensions, style, group, inherit) {
    var sig = "width, height, color, borderColor, borderWidth, corner, dashed, strokeObj, scaleDimensions, style, group, inherit";
    var duo; if (duo = zob(zim.Rectangle, arguments, sig, this)) return duo;
    this.zimCustomShape_constructor(null,null,null,null,false);
    this.type = "Rectangle";
    this.group = group;

var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type, this.group, inherit);

// MONITOR		
	this.mID = "z~"+(DS.monitor===false?"-":this.type);
	
    if (zot(width)) width = DS.width!=null?DS.width:null;
    if (zot(height)) height = DS.height!=null?DS.height:!zot(width)?width:100;
    if (zot(width)) width = height;
    if (zot(corner)) corner = DS.corner!=null?DS.corner:0;
    if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
    if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
    if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
    if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
    else if (borderColor!=null && borderWidth==null) borderWidth = 1;
    if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":zim.black);
	if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};
    if (zot(scaleDimensions)) scaleDimensions = DS.scaleDimensions!=null?DS.scaleDimensions:true;

// PICK
    var oa = remember(width, height, color, borderColor, borderWidth);
	this.veeObj = {width:oa[0], height:oa[1], color:oa[2], borderColor:oa[3], borderWidth:oa[4]};
    function remember() {return arguments;} // for cloning PICK
    width = zim.Pick.choose(width);
    height = zim.Pick.choose(height);
    color = zim.Pick.choose(color);
    borderColor = zim.Pick.choose(borderColor);
    borderWidth = zim.Pick.choose(borderWidth);

that.setWidth = function(w) {width = w;}
	that.setHeight = function(h) {height = h;}

var rectangle = this.shape = new createjs.Shape();
    this.addChild(rectangle);

that.setBounds(0,0,width,height);
		if (that._color.type) that.color = that._color;
		
    };
	that.drawShape();
	
	// Object.defineProperty(that, 'corner', {
	// 	get: function() {
	// 		return corner;
	// 	},
	// 	set: function(value) {
	// 		corner = value;
	// 		that.drawShape();
	// 	}
	// });

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // NOTE: extends ZIM CustomShape for more properties and a few functions.
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false||group!=null) zim.styleTransforms(this, DS);
    this.clone = function(exact, useStyle) {
		var cloneStyle = zot(useStyle)?style:useStyle;
		if (exact) cloneStyle = false; 
        var newShape =  that.cloneProps(new zim.Rectangle((exact||!zim.isPick(oa[0]))?width:oa[0], (exact||!zim.isPick(oa[1]))?height:oa[1], (exact||!zim.isPick(oa[2]))?that.color:oa[2], (exact||!zim.isPick(oa[3]))?that.borderColor:oa[3], (exact||!zim.isPick(oa[4]))?that.borderWidth:oa[4], corner, that._dashed, strokeObj, that.scaleDimensions, cloneStyle, this.group, inherit));
        return newShape;
    };
};
zim.extend(zim.Rectangle, zim.CustomShape, "clone", "zimCustomShape", false);

// MONITOR		
	this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(a)) a = DS.a!=null?DS.a:100;
    if (zot(b)) b = DS.b!=null?DS.b:a;
    if (zot(c)) c = DS.c!=null?DS.c:b;
    if (b==-1) b = Math.sqrt(Math.pow(a,2)+Math.pow(c,2));
    if (c==-1) c = Math.sqrt(Math.pow(a,2)+Math.pow(b,2));
    if (zot(corner)) corner = DS.corner!=null?DS.corner:0;
    if (zot(center)) center = DS.center!=null?DS.center:true;
    if (zot(adjust)) adjust = DS.adjust!=null?DS.adjust:0;
    if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
    if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
    if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
    else if (borderColor!=null && borderWidth==null) borderWidth = 1;
    if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":zim.black);
    if (zot(adjust)) adjust = DS.adjust!=null?DS.adjust:0;
    if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

// PICK
    var oa = remember(a, b, c, color, borderColor, borderWidth);
    this.veeObj = {a:oa[0], b:oa[1], c:oa[2], color:oa[3], borderColor:oa[4], borderWidth:oa[5]};
    function remember() {return arguments;} // for cloning PICK
    a = zim.Pick.choose(a);
    b = zim.Pick.choose(b);
    c = zim.Pick.choose(c);
    this.a = a;
    this.b = b;
    this.c = c;
    color = zim.Pick.choose(color);
    borderColor = zim.Pick.choose(borderColor);
    borderWidth = zim.Pick.choose(borderWidth);

var that = this;
    that._color = color;
    that._borderColor = borderColor;
    that._borderWidth = borderWidth;
    that._dashed = dashed;
    if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];
    that._corner = corner;

if (aa > bb+cc) {
        zogy("zim display - Triangle(): invalid triangle lengths");
        return;
    }

var tri = this.shape = new createjs.Shape();
    this.adjusted = adjust;
    this.addChild(tri);

// find biggest angle with cosine rule
        var angle1 = Math.acos( (Math.pow(bb,2) + Math.pow(cc,2) - Math.pow(aa,2)) / (2 * bb * cc) ) * 180 / Math.PI;

// use the sine rule for next biggest angle
        var angle2 = Math.asin( bb * Math.sin(angle1 * Math.PI / 180) / aa ) * 180 / Math.PI;

// find last angle
        var angle3 = 180 - angle1 - angle2;

var nextAngle = that.angles[1];
        var backX = Math.cos(nextAngle * Math.PI / 180) * b;
        var upY = Math.sin(nextAngle * Math.PI / 180) * b;

var width = Math.max(a, a-backX);
        var height = upY;
        that.setBounds(0,adjust,width,height);
        tri.y = height;
			
        that.three={x:a-backX,y:0-upY};
				
        var sX = a*corners[0]/((corners[0]+corners[1])||1);
        g
            .mt(sX,0)
            .at(a,0, a-backX,0-upY, corners[1])
            .at(a-backX,0-upY, 0,0, corners[2])
            .at(0,0, a,0, corners[0])
            .lt(sX,0);
			
		g.cp();

if (center) {
            that.regX = width/2;
            that.regY = height/2;
        }
        if (adjust) {
            that.shape.y+=adjust;
        }
		if (that._color.type) that.color = that._color;
    };
	that.drawShape();

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    // NOTE: extends ZIM CustomShape for more properties and a few functions.
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS);
    this.clone = function(exact, useStyle) {
		var cloneStyle = zot(useStyle)?style:useStyle;
		if (exact) cloneStyle = false; 
        var newShape = that.cloneProps(new zim.Triangle((exact||!zim.isPick(oa[0]))?a:oa[0], (exact||!zim.isPick(oa[1]))?b:oa[1], (exact||!zim.isPick(oa[2]))?c:oa[2], (exact||!zim.isPick(oa[3]))?that.color:oa[3], (exact||!zim.isPick(oa[4]))?that.borderColor:oa[4], (exact||!zim.isPick(oa[5]))?that.borderWidth:oa[5], corner, center, adjust, dashed, strokeObj, cloneStyle, this.group, inherit));
        if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
        if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
        return newShape;
    };
};
zim.extend(zim.Triangle, zim.CustomShape, "clone", "zimCustomShape");

zim.Line = function(length, thickness, color, startHead, endHead, dashed, strokeObj, lineType, lineOrientation, curveH, curveV, points, startLength, endLength, style, group, inherit) {
		var sig = "length, thickness, color, startHead, endHead, dashed, strokeObj, lineType, lineOrientation, curveH, curveV, points, startLength, endLength, style, group, inherit";
		var duo; if (duo = zob(zim.Line, arguments, sig, this)) return duo;
		this.zimCustomShape_constructor(null,null,null,null,false);
		this.type = "Line";
		this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
		this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(length)) length = DS.length!=null?DS.length:100;
		if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(thickness)) thickness = DS.thickness!=null?DS.thickness:3;
		if (zot(color)) color = DS.color!=null?DS.color:zim.black;
		if (zot(startHead)) startHead = DS.startHead!=null?DS.startHead:null;
		if (zot(endHead)) endHead = DS.endHead!=null?DS.endHead:null;
		if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

if (zot(curveH)) curveH = DS.curveH!=null?DS.curveH:20;
		if (zot(curveV)) curveV = DS.curveV!=null?DS.curveV:20;
		if (zot(strokeObj)) strokeObj = DS.strokeObj!=null?DS.strokeObj:{};

if (zot(startLength)) startLength = DS.startLength!=null?DS.startLength:null;
		if (zot(endLength)) endLength = DS.endLength!=null?DS.endLength:null;
	
		// PICK
		var oa = remember(length, color, thickness, startHead, endHead, startLength, endLength);
		this.veeObj = {length:oa[0], color:oa[1], thickness:oa[2], startHead:oa[3], endHead:oa[4], startLength:oa[5], endLength:oa[6]};
		function remember() {return arguments;} // for cloning PICK
		length = zim.Pick.choose(length);
		color = zim.Pick.choose(color);
		thickness = zim.Pick.choose(thickness);
		startHead = zim.Pick.choose(startHead);
		endHead = zim.Pick.choose(endHead);
		// do below otherwise will be the same head and get moved if cloned
		if (startHead && startHead.clone) startHead = startHead.clone();
		if (endHead && endHead.clone) endHead = endHead.clone();
		startLength = zim.Pick.choose(startLength);
		endLength = zim.Pick.choose(endLength);

var that = this;
		that._length = length;
		that._color = color;
		that._thickness = thickness;
		that._dashed = dashed;
		if (that._dashed && !Array.isArray(that._dashed)) that._dashed = [10, 10];

if (that._startHead) prepareHead("start", that._startHead);
		if (that._endHead) prepareHead("end", that._endHead);
		function prepareHead(type, head) {
			if (head == "triangle" || head == "arrow") {
				var h = that["_"+type+"Head"] = new zim.Triangle(thickness*4, thickness*4, thickness*4, color);
				h.rotation = 90;
			} else if (head == "circle") {
				that["_"+type+"Head"] = new zim.Circle(thickness*2.2, color);
			}
			if (zot(that["_"+type+"Head"].startAngle)) that["_"+type+"Head"].startAngle = that["_"+type+"Head"].rotation;
		}

startHead = that._startHead;
		endHead = that._endHead;

if (startHead && startHead.type == "Triangle") startHead.startRegY = startHead.regY;
		if (endHead && endHead.type == "Triangle") endHead.startRegY = endHead.regY;

var shape = this.shape = new createjs.Shape();
		this.addChild(shape);

var g = shape.graphics;
		that.drawShape = function(arrowAdjustStart, arrowAdjustEnd) {
			g.c();
			that.colorCommand = g.s(that._color).command;
			// if (color && color.type) that.specialColor(that.colorCommand, color, that);
			that.thicknessCommand = g.ss(that._thickness, strokeObj.caps, strokeObj.joints, strokeObj.miterLimit, strokeObj.ignoreScale).command;
			if (that._dashed) {
				that.dashedCommand = g.sd(Array.isArray(that._dashed)?that._dashed:[10, 10], that._dashedOffset).command;
			}
			var startArrowGuide;
			var endArrowGuide;

if (that._points) {
				var start = that._points[0];
				that._startX = start[0];
				that._startY = start[1];
				var endPoint = that._points[that._points.length-1];
				var end = [endPoint[endPoint.length-2], endPoint[endPoint.length-1]];
				that._endX = end[0];
				that._endY = end[1];
				g.mt(start[0], start[1]);
				for (var i=1; i<that._points.length; i++) {
					var point = that._points[i];
					if (i==1) startArrowGuide = [that._startX, that._startY, point[0], point[1]];
					if (point.length==2) g.lt(point[0], point[1]);
					else if (point.length==4) g.qt(point[0], point[1], point[2], point[3]);
					else if (point.length==6) g.bt(point[0], point[1], point[2], point[3], point[4], point[5]);
				}
				// end arrow will go along last control line or from last point to penultimate point if no control line
				if (point.length >= 4) { // last point in loop
					endArrowGuide = [point[point.length-4], point[point.length-3], that._endX, that._endY];
				} else {
					var penPoint = that._points[that._points.length-2];
					endArrowGuide = [penPoint[penPoint.length-2], penPoint[penPoint.length-1], that._endX, that._endY];
				}
			} else {

if (that.lineType == "straight") {
					g.mt(sX, sY).lt(eX, eY);
					startArrowGuide = endArrowGuide = [sX, sY, eX, eY];

} else if (that.lineType == "corner") {
					var midX = sX + (eX-sX)*.4;
					var midY = sY + (eY-sY)*.4;
					if (that._lineOrientation == "auto") {
						that.autoOrientation = (Math.abs(sX-eX) > Math.abs(sY-eY))?"horizontal":"vertical";
					}
					if (that._lineOrientation == "horizontal" || that.autoOrientation == "horizontal") {
						startArrowGuide = endArrowGuide = [sX, sY, midX, sY];
						// startArrowGuide = endArrowGuide = [that._startX, that._startY, midX, that._startY];					
						var mX1 = midX;
						var mX2;
						if (startLength!=null) {							
							if (midX > sX) {
								if (midX-sX > startLength) mX1 = sX + startLength;
							} else {
								if (sX-midX > startLength) mX1 = sX - startLength;
							}
						} 
						if (endLength!=null) {
							if (eX > midX) {
								if (eX-midX > endLength) mX2 = eX - endLength;
								else mX2 = midX;
							} else {
								if (midX-eX > endLength) mX2 = eX + endLength;
								else mX2 = midX;
							}
							if (startLength==null) mX1 = mX2;
						} else {							
							mX2 = mX1;
						}
						g.mt(sX, sY).lt(mX1, sY).lt(mX2, eY).lt(eX, eY);
					} else {
						startArrowGuide = endArrowGuide = [sX, sY, sX, midY];
						// startArrowGuide = endArrowGuide = [that._startX, that._startY, that._startX, midY];
						var mY1 = midY;
						var mY2;
						if (startLength!=null) {							
							if (midY > sY) {
								if (midY-sY > startLength) mY1 = sY + startLength;
							} else {
								if (sY-midY > startLength) mY1 = sY - startLength;
							}
						} 
						if (endLength!=null) {
							if (eY > midY) {
								if (eY-midY > endLength) mY2 = eY - endLength;
								else mY2 = midY;
							} else {
								if (midY-eY > endLength) mY2 = eY + endLength;
								else mY2 = midY;
							}
							if (startLength==null) mY1 = mY2;
						} else {							
							mY2 = mY1;
						}
						g.mt(sX, sY).lt(sX, mY1).lt(eX, mY2).lt(eX, eY);
					}
				} else { // "curve"

var hSign = (sX > eX)?-1:1;
					var vSign = (sY > eY)?-1:1;

var nextX = sX; // relative drawing would be handy but not implemented in version yet
					var nextY = sY;
					var distX = Math.abs(sX - eX);
					var distY = Math.abs(sY - eY);
					var curveX = Math.min(curveH, distX*.5); // need proportion curve until hits curveH
					var curveY = Math.min(curveV, distY*.5);

if (that._lineOrientation == "auto") {
						that.autoOrientation = (Math.abs(sX-eX) > Math.abs(sY-eY))?"horizontal":"vertical";
					}

if (startLength!=null && endLength!=null) {
						startLength=null;
						if (zon) zogy("ZIM Line() - startLength ignored");
					}

var insideDistance,outsideDistance,lastX,lastY;
					if (that._lineOrientation == "horizontal" || that.autoOrientation == "horizontal") {

insideDistance = (distY-curveY*2);
						outsideDistance = (distX-curveX*2)/2;

var diff = 0;
						if (startLength != null) diff = Math.max(0, distX/2-startLength);
						if (endLength != null) diff = Math.min(0, -(distX/2-endLength));
						
						g.mt(nextX, nextY);
						if (outsideDistance > 0) {
							nextX = nextX+(outsideDistance-diff)*hSign;
							g.lt(nextX, nextY);
						}

lastY = nextY;
						nextY = nextY+curveY*vSign;
						nextX = nextX+curveX*hSign;
						g.qt(nextX, lastY, nextX, nextY);

startArrowGuide = endArrowGuide = [sX, sY, nextX, sY];

if (insideDistance > 0) {
							nextY = nextY+insideDistance*vSign;
							g.lt(nextX, nextY);
						}
						nextY = nextY+curveY*vSign;
						lastX = nextX;
						nextX = nextX+curveX*hSign;
						g.qt(lastX, nextY, nextX, nextY);
						if (outsideDistance > 0) {
							nextX = nextX+(outsideDistance+diff)*hSign;
							g.lt(nextX, nextY);
						}

} else {

insideDistance = (distX-curveX*2);
						outsideDistance = (distY-curveY*2)/2;

var diff = 0;
						if (startLength != null) diff = Math.max(0, distY/2-startLength);
						if (endLength != null) diff = Math.min(0, -(distY/2-endLength));

g.mt(nextX, nextY);
						if (outsideDistance > 0) {
							nextY = nextY+(outsideDistance-diff)*vSign;
							g.lt(nextX, nextY);
						}

lastX = nextX;
						nextX = nextX+curveX*hSign;
						nextY = nextY+curveY*vSign;
						g.qt(lastX, nextY, nextX, nextY);

startArrowGuide = endArrowGuide = [sX, sY, sX, nextY];

if (insideDistance > 0) {
							nextX = nextX+insideDistance*hSign;
							g.lt(nextX, nextY);
						}
						nextX = nextX+curveX*hSign;
						lastY = nextY;
						nextY = nextY+curveY*vSign;
						g.qt(nextX, lastY, nextX, nextY);
						if (outsideDistance > 0) {
							nextY = nextY+(outsideDistance+diff)*vSign;
							g.lt(nextX, nextY);
						}
					}
				}
			}

// ALSO ADJUST ZIM ZIM 02 - to localToLocal
		this.setPoints = function(a, b, c, d, arrowAdjustStart, arrowAdjustEnd) {
			if (Array.isArray(a) && zot(b)) {
				that.points = a;
				return that;
			} else if (a && !zot(a.x)) {
				that._startX = zot(a.x)?that._startX:a.x;
				that._startY = zot(a.y)?that._startY:a.y;
				if (b) {
					that._endX = zot(b.x)?that._endX:b.x;
					that._endY = zot(b.y)?that._endY:b.y;
				}
			} else {
				that._startX = zot(a)?that._startX:a;
				that._startY = zot(b)?that._startY:b;
				that._endX = zot(c)?that._endX:c;
				that._endY = zot(d)?that._endY:d;
			}
			that.drawShape(arrowAdjustStart, arrowAdjustEnd);
			return that;
		};

this.from = function(a, b, localToLocal) {			
			if (zot(localToLocal)) localToLocal = true;
			var x, y;
			if (a && a.parent && that.parent && localToLocal) {
				var point = a.parent.localToLocal(a.x, a.y, that.parent);
				x = point.x;
				y = point.y;
			} 
			if (a && !zot(a.x)) {
				that._startX = !zot(x)?x:zot(a.x)?that._startX:a.x;
				that._startY = !zot(y)?y:zot(a.y)?that._startY:a.y;
			} else {
				that._startX = zot(a)?that._startX:a;
				that._startY = zot(b)?that._startY:b;
			}
			that.drawShape();
			return that;
		};

this.to = function(a, b, localToLocal) {
			if (zot(localToLocal)) localToLocal = true;
			var x, y;
			if (a && a.parent && that.parent && localToLocal) {
				var point = a.parent.localToLocal(a.x, a.y, that.parent);
				x = point.x;
				y = point.y;
			} 
			if (a && !zot(a.x)) {
				that._endX = !zot(x)?x:zot(a.x)?that._endX:a.x;
				that._endY = !zot(y)?y:zot(a.y)?that._endY:a.y;
			} else {
				that._endX = zot(a)?that._endX:a;
				that._endY = zot(b)?that._endY:b;
			}
			that.drawShape();
			return that;
		};

Object.defineProperty(that, 'length', {
			get: function() {
				return that._length;
			},
			set: function(value) {
				var s = that.length!=0 ? value/that.length : 0;
				if (isNaN(s)) return;
				var startScaleX = that.scaleX;
				var startScaleY = that.scaleY;
				that.scaleX *= s;
				that.scaleY *= s;
				var gStart = that.localToGlobal(that._startX, that._startY);
				var gEnd = that.localToGlobal(that._endX, that._endY);
				that.scaleX = startScaleX;
				that.scaleY = startScaleY;
				var lStart = that.globalToLocal(gStart.x, gStart.y);
				var lEnd = that.globalToLocal(gEnd.x, gEnd.y);
				that.setPoints(lStart, lEnd);
			}
		});
		Object.defineProperty(that, 'startPoint', {
			get: function() {
				return new zim.Point(that._startX, that._startY);
			},
			set: function(value) {
				that._startX = zot(value.x)?that._startX:value.x;
				that._startY = zot(value.y)?that._startY:value.y;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endPoint', {
			get: function() {
				return new zim.Point(that._endX, that._endY);
			},
			set: function(value) {
				that._endX = zot(value.x)?that._endX:value.x;
				that._endY = zot(value.y)?that._endY:value.y;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startHead', {
			get: function() {
				return that._startHead;
			},
			set: function(value) {
				that._startHead = value;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endHead', {
			get: function() {
				return that._endHead;
			},
			set: function(value) {
				that._endHead = value;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startX', {
			get: function() {
				return that._startX;
			},
			set: function(value) {
				that._startX = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startY', {
			get: function() {
				return that._startY;
			},
			set: function(value) {
				that._startY = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endX', {
			get: function() {
				return that._endX;
			},
			set: function(value) {
				that._endX = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endY', {
			get: function() {
				return that._endY;
			},
			set: function(value) {
				that._endY = value||0;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'startLength', {
			get: function() {
				return startLength;
			},
			set: function(value) {
				oa[5] = value;
				startLength = zik(value);
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'endLength', {
			get: function() {
				return endLength;
			},
			set: function(value) {
				oa[6] = value;
				endLength = zik(value);
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'points', {
			get: function() {
				return that._points;
			},
			set: function(value) {
				if (!value) return;
				that._points = value;
				that.drawShape();
			}
		});
		Object.defineProperty(that, 'lineOrientation', {
			get: function() {
				return that._lineOrientation;
			},
			set: function(value) {
				if (!value) return;
				that._lineOrientation = value;
				that.drawShape();
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// NOTE: extends ZIM CustomShape for more properties and a few functions.
		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it

this.clone = function(exact, useStyle) {
			var cloneStyle = zot(useStyle)?style:useStyle;
			if (exact) cloneStyle = false; 
			var startH = (exact||!zim.isPick(oa[3]))?that._startHead:oa[3];
			if (startH) {
				if (startH.clone) {
					startH = startH.clone();
					startH.rotation = that._startHead.startAngle;
				}
			}
			var endH = (exact||!zim.isPick(oa[4]))?that._endHead:oa[4];
			if (endH) {
				if (endH.clone) {
					endH = endH.clone();
					endH.rotation = that._endHead.startAngle;
				}
			}
			var newShape = that.cloneProps(new zim.Line((exact||!zim.isPick(oa[0]))?that.length:oa[0], (exact||!zim.isPick(oa[2]))?that.thickness:oa[2], (exact||!zim.isPick(oa[1]))?that.color:oa[1], startH, endH, that.dashed, strokeObj, lineType, that._lineOrientation, curveH, curveV, zim.copy(points), (exact||!zim.isPick(oa[5]))?startLength:oa[5], (exact||!zim.isPick(oa[6]))?endLength:oa[6], cloneStyle, this.group, inherit));
			if (that.points) newShape.setPoints(that.points);
			else newShape.setPoints(that._startX, that._startY, that._endX, that._endY);

zim.Squiggle = function(color, thickness, points, length, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, circleColor, circleBorderColor, stickColor, stickThickness, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit) {
		var sig = "color, thickness, points, length, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, circleColor, circleBorderColor, stickColor, stickThickness, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit";
		var duo; if (duo = zob(zim.Squiggle, arguments, sig, this)) return duo;

this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle("Squiggle", this.group, inherit);

if (zot(thickness)) thickness = DS.thickness!=null?DS.thickness:6;
		if (zot(length)) length = DS.length!=null?DS.length:300;
		if (zot(points)) points = DS.points!=null?DS.points:5;		
		if (typeof points == "string") {
			var svgProcessor = new zim.SVGContainer();
			points = svgProcessor.processPath(points);
		}
		var approxCheck = typeof points != "number";
		var num = typeof points == "number" ? points : points.length;
		if (num == 0) return;
		if (zot(controlLength)) controlLength = DS.controlLength!=null?DS.controlLength:(length / num);
		this.zimCustomShape_constructor(length, controlLength, null, null, false);
		this.type = "Squiggle";
		
		// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

this.mouseChildren = true; // set to false in CustomShape

if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(color)) color = DS.color!=null?DS.color:zim.blue;
		if (color.style) {this.colorCommand = color; color = zim.black;}

if (zot(controlType)) controlType = DS.controlType!=null?DS.controlType:null;
		var originalControlType = controlType;
		if (zot(controlType)) controlType = "mirror";
		if (zot(lockControlType)) lockControlType = DS.lockControlType!=null?DS.lockControlType:false;
		if (zot(interactive)) interactive = DS.interactive!=null?DS.interactive:true;
		if (zot(showControls)) showControls = DS.showControls!=null?DS.showControls:interactive;
		var _controls = showControls;
		if (zot(lockControls)) lockControls = DS.lockControls!=null?DS.lockControls:!interactive;
		if (zot(handleSize)) handleSize = DS.handleSize!=null?DS.handleSize:zim.mobile()?20:10;
		if (zot(allowToggle)) allowToggle = DS.allowToggle!=null?DS.allowToggle:interactive;
		if (zot(move)) move = DS.move!=null?DS.move:interactive;
		if (zot(circleColor)) circleColor = DS.circleColor!=null?DS.circleColor:zim.light;
		if (zot(circleBorderColor)) circleBorderColor = DS.circleBorderColor!=null?DS.circleBorderColor:zim.dark;
		if (zot(stickColor)) stickColor = DS.stickColor!=null?DS.stickColor:zim.darker;
		if (zot(stickThickness)) stickThickness = DS.stickThickness!=null?DS.stickThickness:1;
		if (zot(selectColor)) selectColor = DS.selectColor!=null?DS.selectColor:zim.white;
		if (zot(selectPoints)) selectPoints = DS.selectPoints!=null?DS.selectPoints:interactive;
		this.circleColor = circleColor;
		this.circleBorderColor = circleBorderColor;
		this.stickColor = stickColor;
		this.stickThickness = stickThickness;

var oa = remember(color);
		this.veeObj = {color:oa[0]};
		function remember() {return arguments;} // for cloning PICK
		color = zim.Pick.choose(color);

var that = this;
		var stage;
		this.types = ["mirror", "straight", "free", "none"];
		this.interactive = interactive;
		this.num = num;
		this.onTop = onTop;
		this.move = move;
		this.editPoints = editPoints;
		this.allowToggle = allowToggle;
		this.lockControlType = lockControlType;
		this.selectPoints = selectPoints;
		this.lockControls = lockControls;

var shape;
		var moveDownEvent;
		var movePressEvent;
		var moveUpEvent;

var draggingCheck = that.move;
		var min = 2; // min distance within which a click will add a point

var mapMove;
		var sets;

init();
		function init() {
			if (sets) sets.removeAllEventListeners(null, mID);

that.num = num = typeof points == "number" ? points : points.length;
			num = Math.max(2,num);
			controlLength = length / num;

var ballS = handleSize/10*8;
			var rectS = handleSize;

if (that.selectPoints) {
				that.selectedBalls = new zim.SelectionSet();
				that.selectedRect1s = new zim.SelectionSet();
				that.selectedRect2s = new zim.SelectionSet();

var mobile = zim.mobile();

var i, point, temp, set, rect1, rect2, ball, type, setInfo;

for (i=0; i<num; i++) {
				set = new zim.Container({style:false}).addTo(sets);
				set.num = i;
				if (typeof points == "number") { // no sets yet
					var stickLength = zim.Pick.choose(controlLength);
					temp = new zim.Container(stickLength, thickness, null, null, false).addTo(that).loc({x:i*length/(num-1)-stickLength/2, y:i%2*stickLength});
					ball = new zim.Circle(ballS, that.selectPoints&&that.selectedBalls.isSelected(i)?selectColor:that.circleColor, that.circleBorderColor, 2, null, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:stickLength/2, y:0});
					rect1 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(controlType),  handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:0,y:0});
					rect2 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(controlType),  handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:stickLength,y:0});

} else { // passing in set data

// _pointCircles are relative to squiggle but handles are relative to ball
					// points is an array of [[setX, setY, ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]

setInfo = points[i];
					type = setInfo[8] ? setInfo[8] : controlType;
					set.loc({x:setInfo[0], y:setInfo[1]});
					ball = new zim.Circle(ballS, that.circleColor, that.circleBorderColor, 2, null, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set)
						.loc({x:setInfo[2],y:setInfo[3]});
					rect1 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type),  handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[4],y:setInfo[5]});
					rect2 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type), handleSize==0?null:zim.dark,  handleSize==0?null:2, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[6],y:setInfo[7]});
				}

ball.mySet = set;
				ball.rect1 = rect1;
				ball.rect2 = rect2;
				ball.index = i;

if (mobile) {
					ball.on("mousedown", mobileDouble, null, null, null, null, mID);
				} else {
					ball.on("dblclick", doubleIt, null, null, null, null, mID);
				}

rect1.ball = ball;
				rect1.other = rect2;
				rect2.ball = ball;
				rect2.other = rect1;

if (handleSize==0) {
					ball.expand(10);
					rect1.expand(10);
					rect2.expand(10);
				}

if (mobile) {
					ball.expand();
					rect1.expand();
					rect2.expand();
				}

point = [set, ball, rect1, rect2, setInfo?setInfo[8]:controlType];
				_points.push(point);
				_pointCircles.push(ball);
				_pointControls.push(set);
			}

ball.rect1.color = getBackgroundColor(type);
				ball.rect2.color = getBackgroundColor(type);
				that.drawShape();
				if (color.type) that.color = color;
				var ev = new createjs.Event("change");
				ev.controlType = "bezierSwitch";
				that.dispatchEvent(ev);
				ball.stage.update();
			}

function getBackgroundColor(type) {
				var colors = {straight:"#e472c4", free:"#ebcb35", none:"#50c4b7"};
				return colors[type] ? colors[type] : "#993399";
			}
			var mob = zim.mobile();
			that.drawShape = function () {
				g.c();
				var minThickness = mob ? 10 : 6;
				var i,currentIndex,nextIndex,set,ball;
				var control1,control2,nextSet,ballPoint,nextBall,nextControl1,control1Point,control2Point,nextControl1Point,nextBallPoint;
								
				if (thickness < minThickness) {
					// 1. draw backing grab line
					g.s("rgba(0,0,0,.01)").ss(minThickness);
					set = _points[0][0];
					ballPoint = set.localToLocal(_points[0][1].x, _points[0][1].y, shape);
					g.mt(ballPoint.x, ballPoint.y);

for (i=0; i<_points.length; i++) {
						currentIndex = i;
						nextIndex = (i+1)%_points.length;

set = _points[currentIndex][0];
						ball = _points[currentIndex][1];
						control1 = _points[currentIndex][2];
						control2 = _points[currentIndex][3];

nextSet = _points[nextIndex][0];
						nextBall = _points[nextIndex][1];
						nextControl1 = _points[nextIndex][2];
						// nextControl2 = _points[nextIndex][3];
						// var ctype = _points[currentIndex][4]; // STEFAN
						
						control2Point = set.localToLocal(control2.x, control2.y, shape);
						nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
						nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);

// 2. draw real line

if (!that.colorCommand) {
					that.colorCommand = g.s(that._color).command;
					// if (color && color.type) that.specialColor(that.colorCommand, color, that);
				}
				if (!that.thicknessCommand) that.thicknessCommand = g.ss(that._thickness, strokeObj.caps, strokeObj.joints, strokeObj.miterLimit, strokeObj.ignoreScale).command;
				if (that._dashed) {
					if (!that.dashedCommand) that.dashedCommand = g.sd(Array.isArray(that._dashed)?that._dashed:[10, 10], that._dashedOffset).command;
				}

set = _points[0][0];
				ballPoint = set.localToLocal(_points[0][1].x, _points[0][1].y, shape);
				g.mt(ballPoint.x, ballPoint.y);

s.c().s(that.stickColor).ss(that.stickThickness);
				
				
				for (i=0; i<_points.length; i++) {
					currentIndex = i;
					nextIndex = (i+1)%_points.length;
				
					set = _points[currentIndex][0];
					ball = _points[currentIndex][1];
					control1 = _points[currentIndex][2];
					control2 = _points[currentIndex][3];
					// var ctype = _points[currentIndex][4]; // STEFAN
				
					nextSet = _points[nextIndex][0];
					nextBall = _points[nextIndex][1];
					nextControl1 = _points[nextIndex][2];
					// nextControl2 = _points[nextIndex][3];
				
					control2Point = set.localToLocal(control2.x, control2.y, shape);
					nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
					nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);
				
					if (i != _points.length-1) {
						g.bt(
							control2Point.x, control2Point.y,
							nextControl1Point.x, nextControl1Point.y,
							nextBallPoint.x, nextBallPoint.y
						);
					}
				
					// create the sticks
					ballPoint = set.localToLocal(ball.x, ball.y, shape);
					control1Point = set.localToLocal(control1.x, control1.y, shape);
				
					if (i == 0) control1.visible = 0;
					if (i != 0) s.mt(ballPoint.x, ballPoint.y).lt(control1Point.x, control1Point.y);
					if (i != _points.length-1) s.mt(ballPoint.x, ballPoint.y).lt(control2Point.x, control2Point.y);
					if (i == _points.length-1) control2.visible = 0;
				}
				
				if (that._dashed) g.append(that.dashedCommand);
				g.append(that.thicknessCommand);
				g.append(that.colorCommand);
				if (that._color.type) that.color = that._color;
			};
			that.drawShape();

var startPosition;
			var mDown = false;
			sets.on("mousedown", function(e) {
				stage = e.target.stage;
				if (that.lockControls) return;
				mDown = true;
				sets.loop(function(set) {
					if (set == e.target.parent) return;					
					if (set.lastChildren==null) set.lastChildren = set.mouseChildren;
					if (set.lastMouse==null) set.lastMouse = set.mouseEnabled;
					set.noMouse();
				});
				if (shape.lastMouse==null) shape.lastMouse = shape.mouseEnabled;
				shape.mouseEnabled = false;
				if (that.selectPoints) that.keyFocus = true;
				startPosition = {x:e.target.x, y:e.target.y};
				if (e.target.rect1) { // then mousedown on ball - which has a rect1
					ball = e.target;
					ball.startX = ball.x;
					ball.startY = ball.y;
					ball.rect1.startX = ball.rect1.x;
					ball.rect1.startY = ball.rect1.y;
					ball.rect2.startX = ball.rect2.x;
					ball.rect2.startY = ball.rect2.y;
				} else { // mousedown on control
					var rect = e.target;
					rect.startX = rect.x;
					rect.startY = rect.y;
					ball = rect.ball;
					var index = ball.index;
					var type = controlType;
					if (!zot(_points[index][4])) type = _points[index][4];
					if (type == "straight") {
						var other = rect.other;
						var dX = other.x - ball.x;
						var dY = other.y - ball.y;
						other.stickLength = Math.sqrt(Math.pow(dX,2) + Math.pow(dY,2));
					}
				}
				if (that.selectPoints) {
					// need to reset all start points for each control circle and rectangle moved
					var currentSet = that.selectionManager.currentSet;
					if (currentSet && currentSet.selections && currentSet.selections.length > 0) {
						for(i=0; i<currentSet.selections.length; i++) {
							var point = that.pointObjects[currentSet.selections[i]];
							point[1].startX = point[1].x;
							point[1].startY = point[1].y;
							point[2].startX = point[2].x;
							point[2].startY = point[2].y;
							point[3].startX = point[3].x;
							point[3].startY = point[3].y;
						}
					}
				}
			}, null, null, null, null, mID);

if (that.selectPoints) {
				sets.tap({call:function (e) {
					if (e.target.rect1) { // then mousedown on ball - which has a rect1
						var ball = e.target;
						that.selectedBalls.toggle(ball.parent.num);
					} else { // mousedown on control
						var rect = e.target;
						rect.color = "white";
						ball = rect.ball;
						if (ball.rect1 == rect) that.selectedRect1s.toggle(ball.parent.num);
						else that.selectedRect2s.toggle(ball.parent.num);
					}
					// loop through all controls and set to right color based on selection
					for (i=0; i<that.pointObjects.length; i++) {
						var po = that.pointObjects[i];
						po[1].color = that.selectedBalls.isSelected(i)?selectColor:that.circleColor;
						po[2].color = that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(po[4]);
						po[3].color = that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(po[4]);
					}
					stage.update();
				}, mobileUp:true});
			}

sets.on("pressup", function(e) {
				if (that.lockControls) return;
				mDown = false;
				sets.loop(function(set) {
					if (set == e.target.parent) return;					
					if (set.lastChildren!=null) set.mouseChildren = set.lastChildren;
					if (set.lastMouse!=null) set.mouseEnabled = set.lastMouse;
					set.lastChildren = null;
					set.lastMouse = null;
				});
				if (shape.lastMouse!=null) shape.mouseEnabled = shape.lastMouse;
				shape.lastMouse = null;
				var moveControlCheck = (e.target.x != startPosition.x || e.target.y != startPosition.y);
				var ev = new createjs.Event("change");
				if (e.target.rect1) { // pressup on ball
					ev.controlType = "bezierPoint";
					endMove(e.target);
				} else {
					ev.controlType = "bezierHandle";
				}
				if (moveControlCheck) that.dispatchEvent(ev);
			}, null, null, null, null, mID);

that.selectPoint = function(index, state, multiple) {
				if (zot(state)) state = true;
				if (state) {
					that.selectedBalls.add(index, multiple);
					var ball = that.pointCircles[index];
					ball.startX = ball.x;
					ball.startY = ball.y;
					ball.rect1.startX = ball.rect1.x;
					ball.rect1.startY = ball.rect1.y;
					ball.rect2.startX = ball.rect2.x;
					ball.rect2.startY = ball.rect2.y;
				} else {
					that.selectedBalls.remove(index, multiple);
				}
				// loop through all controls and set to right color based on selection
				for (var i=0; i<that.pointObjects.length; i++) {
					var po = that.pointObjects[i];
					po[1].color = that.selectedBalls.isSelected(i)?selectColor:that.circleColor;
					po[2].color = that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(po[4]);
					po[3].color = that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(po[4]);
				}
				if (that.stage) that.stage.update();
				return that;
			}

that.changeControl = function(index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update) {
				var sig = "index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update";
				var duo; if (duo = zob(that.changeControl, arguments, sig)) return duo;
				if (zot(index)) {
					for (i=0; i<_points.length; i++) {
						that.changeControl(i, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY);
					}
					return;
				}
				var point = _points[index];
				point[4] = type;
				if (type == "none") {
					if (!zot(circleX)) point[2].x = circleX;
					if (!zot(circleY)) point[2].y = circleY;
					point[2].x = point[1].x;
					point[2].y = point[1].y;
					point[3].x = point[1].x;
					point[3].y = point[1].y;
					point[1].parent.addChild(point[1]);
				} else {
					if (!zot(rect1X)) point[2].x = rect1X;
					if (!zot(rect1Y)) point[2].y = rect1Y;
					if (!zot(rect2X)) point[3].x = rect2X;
					if (!zot(rect2Y)) point[3].y = rect2Y;
					if (!zot(circleX)) point[1].x = circleX;
					if (!zot(circleY)) point[1].y = circleY;
					point[1].parent.addChildAt(point[1], 0);
				}
				if (update) {
					that.update();
					if (stage) stage.update();
				}
			};

that.transformPoints = function(transformType, amount, x, y, approximateBounds) {
				if (zot(approximateBounds)) approximateBounds = true;
				that.points = zim.transformPoints(that.points, transformType, amount, x, y);
				if (approximateBounds) that.approximateBounds();
				return that;
			};

that.traverse = function(obj, start, end, time, reverse) {		
				
				var ratios = zim.copy(that.segmentRatios);
				ratios.unshift(0);
				if (zot(end)) end = start+1;
				var startPercent = ratios[start]*100;
				var endPercent = ratios[end]*100;
				
				var amount;
				if (!reverse && startPercent > endPercent) amount = 100 - startPercent + endPercent;
				else if (!reverse && startPercent < endPercent) amount = endPercent - startPercent;				
				else if (reverse && startPercent > endPercent) amount = - (startPercent - endPercent);
				else if (reverse && startPercent < endPercent) amount =  - (100 - endPercent + startPercent);

return that;

// old

// var ratios = zim.copy(that.segmentRatios);
				// ratios.unshift(0);
				// if (zot(end)) end = start+1;
				// var forward = start < end;
				// var startPercent, endPercent;
				// if (forward) {
				// 	startPercent = ratios[start]*100;
				// 	endPercent = ratios[end]*100;
				// } else {
				// 	startPercent = 50 + (100 - ratios[start]*100)/2;
				// 	endPercent = 50 + (100 - ratios[end]*100)/2;
				// }

// obj.percentComplete = obj.zimStartPercent = startPercent+.1;
				// obj.animate({
				// 	ease:"linear",
				// 	props:{path:that},
				// 	rewind:!forward,
				// 	time:time,
				// 	events:true
				// });
				// obj.on("animation", function (e) {
				// 	// when it hits the end it may start over
				// 	if (obj.percentComplete > endPercent || obj.percentComplete == 0) {
				// 		obj.stopAnimate();
				// 		e.remove();
				// 		var eventObj = new createjs.Event("traversed");
				// 		eventObj.obj = obj;
				// 		that.dispatchEvent(eventObj);
				// 	}
				// });
				// return that;
			};
			
			that.reversePoints = function() {			
				points = zim.copy(that.points);
				that.points = zim.reversePoints(zim.copy(that.points));
				that.update();
				return that;
			};
						
			that.appendPoints = function(points, controlType) {
				var current = zim.copy(that.points);
				that.points = zim.appendPoints(current, points, controlType);				
				that.update();
				return that;
			};
			
			that.prependPoints = function(point, controlType) {
				var current = zim.copy(that.points);
				that.points = zim.rependPoints(current, points, controlType);				
				that.update();
				return that;
			};
			
			that.splitPoints = function(index) {
				var current = zim.copy(that.points);
				if (index < 1 || index > current.length-1) return;
				var split = zim.splitPoints(current, index);				
				var first = split[0];
				var second = split[1];
				var s = that.clone();
				that.points = first;
				that.update();
				s.points = second;
				if (that.parent) s.addTo(that.parent);
				return s;
			};
			
			that.makeBlob = function(controlType, mergeDist) {	
				if (zot(controlType)) controlType = "mirror";			
				if (zot(mergeDist)) mergeDist = 5;			
				var points = zim.copy(that.points);				
				zim.loop(points, function (p, i, t) {					
					if (!p[8]) p[8] = "mirror";
					if (i==0) {
						if (controlType == "free") p[4] = p[5] = 0;
						p[8] = controlType;
					}
					if (i==t-1) {
						if (controlType == "free") p[6] = p[7] = 0;
						p[8] = controlType;
					}					
				});
				// check if squiggle is already joined
				if (Math.abs(points[0][0]-points[points.length-1][0]) < mergeDist && Math.abs(points[0][1]-points[points.length-1][1]) < mergeDist) {
					points[0][4] = points[points.length-1][4];
					points[0][5] = points[points.length-1][5];
					points.pop(); // remove last point
				}
				var b = new zim.Blob({
					points:points,
					borderColor:that.color, 
					borderWidth:that.thickness, 
					showControls:that.controlsVisible,
					interactive:that.interactive,
					onTop:that.onTop,
					dashed:that.dashed,
					stickColor:that.stickColor,
					stickThickness:that.stickThickness
				});
				return b;
			};

// squiggle
			if (that.interactive && move) shape.drag({onTop:false});
			moveDownEvent = shape.on("mousedown", function(e) {
				stage = e.target.stage;
				startPosition = {x:shape.x, y:shape.y};
				if (that.selectPoints) that.keyFocus = true;
				upTop();
			}, null, null, null, null, mID);
			movePressEvent = shape.on("pressmove", function() {
				sets.x = shape.x;
				sets.y = shape.y;
				sticks.x = shape.x;
				sticks.y = shape.y;
			}, null, null, null, null, mID);
			moveUpEvent = shape.on("pressup", function() {
				var moveControlCheck = (shape.x != startPosition.x || shape.y != startPosition.y);
				var movePoint = shape.localToLocal(that.regX,that.regY,that.parent);
				that.x = movePoint.x;
				that.y = movePoint.y;
				sets.x = sets.y = sticks.x = sticks.y = shape.x = shape.y = 0;
				if (moveControlCheck) {
					var ev = new createjs.Event("change");
					ev.controlType = "move";
					that.dispatchEvent(ev);
				}
				if (stage) stage.update();
			}, null, null, null, null, mID);

if (!that.move) stopDragging(true); // true is first time

function upTop() {
				if (that.onTop) {
					var nc = that.parent.numChildren-1;
					if (that.parent.getChildAt(nc).type == "Keyboard") nc--;
					that.parent.setChildIndex(that, nc);
				}
			}

that.toggleEvent = that.on("mousedown", function() {
				if (!that.allowToggle) return;
				if (!_controls) {
					that.showControls();
					that.dispatchEvent("controlsshow");
				}
			}, null, null, null, null, mID);
						
			that.added(function() {
				stage = that.stage;
				if (that.toggleStageEvent) stage.off("stagemousedown", that.toggleStageEvent, null, mID);
				that.toggleStageEvent = stage.on("stagemousedown", function(e) {
					if (mDown || !that.allowToggle || !that.stage) return;
					if (_controls && !that.hitTestPoint(e.stageX/zim.scaX, e.stageY/zim.scaY, false)) {
						that.hideControls();
						that.dispatchEvent("controlshide");
					}
				});			
			}, null, null, null, null, mID);

that.recordData = function(toJSON) {
				if (zot(toJSON)) toJSON = false;
				var obj = {
					type:"Squiggle",
					index:that.parent?that.parent.getChildIndex(that):-1,
					x:that.x, y:that.y,
					points:that.getPoints(),
					color:that.color,
					thickness:that.thickness,
					move:that.move,
					allowToggle:that.allowToggle,
					controlsVisible:_controls
				};
				if (toJSON) return JSON.stringify(obj);
				return obj;
			};

var pointData = data.points;
				if (!zot(pointData)) that.setPoints(pointData);
				delete data.points;
				that.num = pointData.length;

for (var d in data) {
					that[d] = data[d];
				}
				if (that.parent) {
					that.parent.setChildIndex(that, index);
				}
				that.update();
				return that;
			};

that.getPoints = function(popup) {
				// balls are relative to blob but handles are relative to ball
				// points is an array of [[ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]
				if (zot(popup)) popup = false;
				var points = that.points;
				if (popup) {
					if (!that.pane) {
						var pane = that.pane = new zim.Pane({
							container:that.stage,
							width:Math.min(500, that.stage.width-20),
							height:Math.min(500, that.stage.height-20),
							draggable:true,
						});
						var textArea = that.textArea = new zim.TextArea(Math.min(400, that.stage.width-70), Math.min(400, that.stage.height-70));
						pane.add(textArea);
					}
					that.textArea.text = JSON.stringify(points);					
					that.pane.show();
				}
				return points;
			};
			that.recordPoints = that.getPoints

that.setPoints = function(points) {
				// adjust blob to match points passed in from getPoints
				var p;
				var p2;
				for (var i=0; i<points.length; i++) {
					p = _points[i];
					p2 = points[i];
					if (zot(p)) continue;
					p[0].x = p2[0];
					p[0].y = p2[1];
					p[1].x = p2[2];
					p[1].y = p2[3];
					p[2].x = p2[4];
					p[2].y = p2[5];
					p[3].x = p2[6];
					p[3].y = p2[7];
					p[4] = p2[8];
				}
				that.update();
				return that;
			};
			if (style!==false) zim.styleTransforms(that, DS);
			that.clone = function(exact, commands) {
				var tList = [];
				var tCheck = false;
				zim.loop(that.pointControls,function(p){
					if (p.scaleX+p.scaleY+p.regX+p.regY+p.rotation!=2) tCheck = true;
					tList.push([p.scaleX,p.scaleY,p.regX,p.regY,p.rotation]);
				});
				var newShape =  that.cloneProps(new zim.Squiggle(commands?that.colorCommand:((exact||!zim.isPick(oa[0]))?that.color:oa[0]), that.thickness, that.getPoints(), length, controlLength, controlType, lockControlType, sets.visible, lockControls, handleSize, that.allowToggle, that.move, dashed, onTop, that.circleColor, that.circleBorderColor, that.stickColor, that.stickThickness, selectColor, selectPoints, that.editPoints, interactive, strokeObj, style, that.group, inherit));
				if (tCheck) {
					zim.loop(newShape.pointControls,function(p,i){					
						p.scaleX = tList[i][0];
						p.scaleY = tList[i][1];
						p.regX = tList[i][2];
						p.regY = tList[i][3];
						p.rotation = tList[i][4];					
					});
					newShape.update();
				}
				if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
				if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
				return newShape;				
			};

// to add a control - make sure click in one spot - not drag
			that.shape.on("mousedown", function (e) {
				stage = e.target.stage;
				if (!that.editPoints) return;
				if (that.controlsVisible) {
					that.pressX = e.stageX/zim.scaX;
					that.pressY = e.stageY/zim.scaX;
				} else {
					that.pressX = null;
					that.pressY = null;
				}
			}, null, null, null, null, mID);
			that.addPointFactor = 10;
			that.addMinDistance = 15;

that.shape.on("pressup", function (e) {
				if (!that.editPoints) return;
				if (that.pressX && Math.abs(that.pressX-e.stageX/zim.scaX) < min && Math.abs(that.pressY-e.stageY/zim.scaY) < min) {
					if (that.selectPoints) that.lastPoints = zim.copy(that.points);
					var points = that.points;
					var point = that.globalToLocal(e.stageX/zim.scaX, e.stageY/zim.scaY);
					var pointBefore = zim.closestPointAlongCurve(point, that.segmentPoints);
					if (that.editPoints == "anywhere") {
						points.splice(pointBefore+1, 0, [point.x, point.y, 0,0, 0,0, 0,0]);
						that.points = points;
						that.changeControl({index:pointBefore+1, type:"mirror", update:true});
					} else { // only on edge
						// test close enough to edge otherwise return
						var p = that.pointsAdjusted;
						var cubic = that.getSegmentPoint(p[pointBefore], p[(pointBefore+1)%p.length]);
						var length = zim.distanceAlongCurve(cubic);
						var testNum = Math.round(length/that.addPointFactor);
						var testPoints = that.interpolate(testNum, pointBefore, false, points);
						// interpolate is setting 2 more points than asked
						var closest=10000;
						var closestIndex;
						zim.loop(testPoints, function (p, k) {
							var d = zim.dist(p, point);
							if (d < closest) {
								closest = d;
								closestIndex = k;
							}
						});
						if (closest < that.addMinDistance) {
							var ratios = that.segmentRatios;
							var currentRatio = ratios[pointBefore];
							var lastRatio = pointBefore>0?ratios[pointBefore-1]:0;
							that.addPoint(100*(lastRatio+(currentRatio-lastRatio)*((closestIndex)/(testNum+1))));
						}
					}
					
					that.lastindex = pointBefore+1;
					that.lastSelected = that.controls.getChildAt(that.lastindex);
					that.stage.update();
				}
			}, null, null, null, null, mID);

// remove point
			that.controls.on("click", function (e) {
				that.lastSelected = e.target.parent;
				that.lastindex = that.controls.getChildIndex(e.target.parent);
				if (!that.editPoints) return;
				if (that.selectionManager.shiftKey) { // remove
					// if (that.selectionManager.currentSet == that.selectedBalls && that.selectedBalls.selections.length > 0) return;
					removeControl(e);
				}
			}, null, null, null, null, mID);

function removeControl(e) {
				if (e.target.type == "Circle") {
					var index = that.lastindex = that.controls.getChildIndex(e.target.parent);
					if (that.controls.numChildren <= 2) return;
					var points = that.points;
					if (that.selectPoints) that.lastPoints = zim.copy(points);
					points.splice(index, 1); // remove the point at the index
					that.points = points;
					that.stage.update();
					that.lastSelected = that.lastindex = null;
				}
			}
			if (that.editPoints) that.controls.hold(removeControl);

if (!_controls) that.hideControls();
			that.dispatchEvent("update");
		} // end of init()

mapMove = function (target) {
			if (that.lockControls) return;
			var ball;
			if (target.rect1) { // pressmove on ball
				ball = target;
				var diffX = ball.x - ball.startX;
				var diffY = ball.y - ball.startY;
				ball.rect1.x = ball.rect1.startX + diffX;
				ball.rect1.y = ball.rect1.startY + diffY;
				ball.rect2.x = ball.rect2.startX + diffX;
				ball.rect2.y = ball.rect2.startY + diffY;
			} else { // pressmove on control
				var rect = target;
				var other = rect.other; // the other handle
				ball = rect.ball;
				var index = ball.index;
				var type = controlType;
				if (!zot(_points[index][4])) type = _points[index][4];
				if (type == "straight" || type == "mirror") {
					var dX = rect.x - ball.x;
					var dY = rect.y - ball.y;
					if (type == "mirror") {
						other.x = ball.x - dX;
						other.y = ball.y - dY;
					} else {
						var a = Math.atan2(dY, dX);
						var dNewX = -other.stickLength * Math.cos(a+Math.PI);
						var dNewY = -other.stickLength * Math.sin(a+Math.PI);
						other.x = ball.x - dNewX;
						other.y = ball.y - dNewY;
					}
				}
			}

Object.defineProperty(that, 'interactive', {
			get: function() {
				return interactive;
			},
			set: function(value) {
				interactive = value;
				_controls = interactive;
				that.allowToggle = interactive;
				that.editPoints = interactive;
				that.lockControls = !interactive; // note negative!
				that.selectPoints = interactive;
				that.move = interactive;
				var p = that.points; // force remake
				that.points = p;
			}
		});

if (WW.KEYFOCUS!=null) zim.KEYFOCUS = WW.KEYFOCUS;
		Object.defineProperty(this, 'keyFocus', {
			get: function() {
				return zim.KEYFOCUS == that;
			},
			set: function() {
				zim.KEYFOCUS = that;
			}
		});
		if (!zim.KEYFOCUS) setFocus();
		function setFocus() {if (!that.selectPoints) return; that.keyFocus = true; var d=document.activeElement; if (d) d.blur();}

Object.defineProperty(that, 'points', {
			get: function() {
				var points = [];
				var point; var p;				
				for (var i=0; i<_points.length; i++) {
					p = _points[i];
					point = [
						zim.decimals(p[0].x),
						zim.decimals(p[0].y),
						zim.decimals(p[1].x),
						zim.decimals(p[1].y),
						zim.decimals(p[2].x),
						zim.decimals(p[2].y),
						zim.decimals(p[3].x),
						zim.decimals(p[3].y)
					];
					if (p[4] && p[4]!=="mirror") point.push(p[4]);
					points.push(point);
				}
				return points;
			},
			set: function(value) {			
				var x = that.x;
				var y = that.y;
				var v = that.visible;
				
				var tList = [];
				var tCheck = false;
				zim.loop(that.pointControls,function(p){
					if (p.scaleX+p.scaleY+p.regX+p.regY+p.rotation!=2) tCheck = true;
					tList.push([p.scaleX,p.scaleY,p.regX,p.regY,p.rotation]);
				});				
				that.dispose(true);
				points = value;
				// if (that.shape) {
				// 	that.shape.graphics.clear();
				// 	that.sticks.graphics.clear();
				// 	that.controls.noDrag();
				// 	that.removeAllChildren();
				// 	delete that.shape;
				// 	delete that.sticks;
				// 	delete that.controls;
				// }
				init(); // remake Squiggle
				that.lockControls = _lockControls;
				that.x = x;
				that.y = y;
				that.visible = v;
				if (tCheck) {
					zim.loop(that.pointControls,function(p,i){					
						p.scaleX = tList[i][0];
						p.scaleY = tList[i][1];
						p.regX = tList[i][2];
						p.regY = tList[i][3];
						p.rotation = tList[i][4];
					
					});
					that.update();
				}
			}
		});

Object.defineProperty(that, 'pointsAdjusted', { // points with rotation
			get: function() {
				var points = [];
				var point; var p; var po;
				var pObjects = that.pointObjects;
				zim.loop(pObjects.length, function(i) {
					po = pObjects[i];
					p = _points[i];
					if (po[0].rotation==0 && po[0].scaleX==0 && po[0].scaleY==0) { // get points
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(p[2].x),
							zim.decimals(p[2].y),
							zim.decimals(p[3].x),
							zim.decimals(p[3].y)
						];
					} else {
						var lo1 = po[0].localToLocal(po[2].x, po[2].y, po[0].parent);
						var lo2 = po[0].localToLocal(po[3].x, po[3].y, po[0].parent);
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(lo1.x-p[0].x),
							zim.decimals(lo1.y-p[0].y),
							zim.decimals(lo2.x-p[0].x),
							zim.decimals(lo2.y-p[0].y)
						];
					}
					if (p[4] && p[4]!=="mirror") point.push(p[4]);
					points.push(point);
				});
				return points;
			},
			set: function () {
				if (zon) zogy("Squiggle() - pointsAdjusted is read only");
			}
		});

Object.defineProperty(that, 'pointObjects', {
			get: function() {
				return _points;
			},
			set: function () {
				if (zon) { zogy("Squiggle() - pointObjects is read only - but its contents can be manipulated - use squiggle.update() after changes"); }
			}
		});

Object.defineProperty(that, 'pointControls', {
			get: function() {
				return _pointControls;
			},
			set: function() {
				if (zon) {zogy("Squiggle() - pointControls is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

Object.defineProperty(that, 'pointCircles', {
			get: function() {
				return _pointCircles;
			},
			set: function() {
				if (zon) {zogy("Squiggle() - pointCircles is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// path manipulation and animating to path methods

Object.defineProperty(that, 'segmentPoints', {
			get: function() {
				var array = []; // array of prepared segment points
				var p = that.pointsAdjusted;
				zim.loop(p.length-1, function(i) {
					var s = that.getSegmentPoint(p[i], p[i+1]);
					array.push(s);
				});
				return array;
			},
			set: function() {
				if (zon) {zogy("Squiggle() - segmentPoints is read only");}
			}
		});

Object.defineProperty(that, 'segmentRatios', {
			get: function() {
				var distances = [];
				var total = 0;
				zim.loop(that.segmentPoints, function(points) {
					var d = zim.distanceAlongCurve(points);
					distances.push(d);
					total += d;
				});
				var percents = [];
				var totalPercents = 0;
				zim.loop(distances, function (d) {
					var p = d/total;
					totalPercents += p;
					percents.push(totalPercents);
				});
				return percents;
			},
			set: function() {
				if (zon) {zogy("Squiggle() - segmentRatios is read only");}
			}
		});

that.getPointAngle = function(index) {
			var p = that.pointObjects[index][0]; // parent
			var r1 = that.pointObjects[index][2];
			var r2 = that.pointObjects[index][3];
			var globalR1, globalR2;
			if (p==that.stage) {
				globalR1 = new zim.Point(r1.x, r1.y);
				globalR2 = new zim.Point(r2.x, r2.y);
			} else {
				globalR1 = p.localToGlobal(r1.x, r1.y);
				globalR2 = p.localToGlobal(r2.x, r2.y);
			}
			return zim.angle(globalR1.x, globalR1.y,globalR2.x, globalR2.y);
		};

that.getCurvePoint = function(ratio, segmentRatios, segmentPoints, getAngle, even) {

this.addPoint = function(percent, controlType) {
			if (zot(percent)) percent = 100;
			var points = that.points;
			var ratios = that.segmentRatios;
			var controls = that.pointControls;
			controlType = controlType ? controlType : originalControlType;
			var index = insertPointData(points, controls, ratios, percent, controlType);
			that.points = points;
			that.num = points.length;
			return index;
		};

this.removePoint = function(index) {	
			if (zot(index) || index < 0) return;		
			var currentPoints = zim.copy(that.points);
			currentPoints.splice(index, 1);
			that.points = currentPoints;
			if (that.stage) that.stage.update();
			return that;
		}

if (dataOnly) that.interpolatedPoints = [];

this.dispose = function(temp, b, disposing) {
			if (!that.shape) return;
			zim.gD(that); // globalDispose function for common elements			
			if (stage && that.toggleStageEvent) stage.off("stagemousedown", that.toggleStageEvent);
			that.controls.noDrag();	// sets	
			that.controls.removeAllEventListeners(null, mID);
			if (that.selectPoints && that.selectionManager) that.selectionManager.dispose();
			that.selectedBalls = null;
			that.selectedRect1s = null;
			that.selectedRect2s = null;
			that.selectionManager = null;		
			that.off("mousedown", that.toggleEvent, null, mID);
			that.off("click", that.clickEvent, null, mID);
				
			if (temp) {
				that.shape.dispose();				
				that.shape = null;				
				for (var i=0; i<that.points.length; i++) {
					that.pointObjects[i][0].removeAllEventListeners(null, mID);
					that.pointObjects[i][1].removeAllEventListeners(null, mID);
					that.pointObjects[i][2].removeAllEventListeners(null, mID);
					that.pointObjects[i][3].removeAllEventListeners(null, mID);
				}
				that.controls.removeFrom(that);
				that.sticks.dispose();
				_points = null;
				_pointCircles = null;
			} else {
				that.removeAllEventListeners(null, mID);	
				_points = null;
				_pointCircles = null;		
				if (!disposing) this.zimCustomShape_dispose(true);				
			}
			return true;
		};
	};
	zim.extend(zim.Squiggle, zim.CustomShape, ["clone", "dispose"], "zimCustomShape", false);

zim.Blob = function(color, borderColor, borderWidth, points, radius, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, circleColor, circleBorderColor, stickColor, stickThickness, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit) {
		var sig = "color, borderColor, borderWidth, points, radius, controlLength, controlType, lockControlType, showControls, lockControls, handleSize, allowToggle, move, dashed, onTop, circleColor, circleBorderColor, stickColor, stickThickness, selectColor, selectPoints, editPoints, interactive, strokeObj, style, group, inherit";
		var duo; if (duo = zob(zim.Blob, arguments, sig, this)) return duo;
		this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle("Blob", this.group, inherit);

if (zot(radius)) radius = DS.radius!=null?DS.radius:100;
		this.zimCustomShape_constructor(-radius,-radius,radius*2,radius*2,false);
		this.type = "Blob";

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

this.mouseChildren = true; // set to false in CustomShape

if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
		if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
		if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
		else if (borderColor!=null && borderWidth==null) borderWidth = 1;
		if (zot(color)) color = DS.color!=null?DS.color:(borderWidth>0?"rgba(0,0,0,0)":zim.green);
		if (color.style) {this.colorCommand = color; color = zim.black;}
		if (borderColor && borderColor.style) {this.borderColorCommand = borderColor; borderColor = zim.black;}
		if (zot(points)) points = DS.points!=null?DS.points:4;
		var approxCheck = typeof points != "number";
		var num = typeof points == "number" ? points : points.length;
		var controlLengthOriginal = controlLength;
		if (zot(controlLength)) controlLength = DS.controlLength!=null?DS.controlLength:(radius * 4 / num);
		if (zot(controlType)) controlType = DS.controlType!=null?DS.controlType:null;
		var originalControlType = controlType;
		if (zot(controlType)) controlType = "straight";
		if (zot(lockControlType)) lockControlType = DS.lockControlType!=null?DS.lockControlType:false;
		if (zot(interactive)) interactive = DS.interactive!=null?DS.interactive:true;
		if (zot(showControls)) showControls = DS.showControls!=null?DS.showControls:interactive;
		var _controls = showControls;
		if (zot(lockControls)) lockControls = DS.lockControls!=null?DS.lockControls:!interactive;
		if (zot(handleSize)) handleSize = DS.handleSize!=null?DS.handleSize:(zim.mobile()?20:10);
		if (zot(allowToggle)) allowToggle = DS.allowToggle!=null?DS.allowToggle:interactive;
		if (zot(move)) move = DS.move!=null?DS.move:interactive;
		if (zot(circleColor)) circleColor = DS.circleColor!=null?DS.circleColor:zim.light;
		if (zot(circleBorderColor)) circleBorderColor = DS.circleBorderColor!=null?DS.circleBorderColor:zim.dark;
		if (zot(stickColor)) stickColor = DS.stickColor!=null?DS.stickColor:zim.darker;
		if (zot(stickThickness)) stickThickness = DS.stickThickness!=null?DS.stickThickness:1;
		if (zot(selectColor)) selectColor = DS.selectColor!=null?DS.selectColor:zim.white;
		if (zot(selectPoints)) selectPoints = DS.selectPoints!=null?DS.selectPoints:interactive;
		this.circleColor = circleColor;
		this.circleBorderColor = circleBorderColor;
		this.stickColor = stickColor;
		this.stickThickness = stickThickness;

var oa = remember(color, borderColor);
		this.veeObj = {color:oa[0], borderColor:oa[1]};
		function remember() {return arguments;} // for cloning PICK
		color = zim.Pick.choose(color);
		borderColor = zim.Pick.choose(borderColor);

this.types = ["mirror", "straight", "free", "none"];

var shape;
		var moveDownEvent;
		var movePressEvent;
		var moveUpEvent;
		var stage;

var draggingCheck = that.move;
		var min = 2; // distance within which to count as click to add point

var mapMove;
		var sets;

points = checkForShape(points);
		function checkForShape(shape) {
			if (shape=="circle" || shape == "rectangle" || shape =="triangle") {
				if (shape == "circle") shape = new zim.Circle(radius);
				if (shape == "rectangle") shape = new zim.Rectangle(radius*2,radius*2).centerReg({add:false});
				if (shape == "triangle") shape = new zim.Triangle(radius*2,radius*2,radius*2);
			}
			var points;
			if (shape.type == "Circle" || shape.type == "Rectangle" || shape.type == "Triangle" || shape.type == "Flare") {
				var b = shape.getBounds();
				if (shape.type == "Circle") {
					points = 4;
					controlLengthOriginal = controlLength = radius*2*.5523;
				} else if (shape.type == "Rectangle") {
					shape.centerReg({add:false});
                    if (shape.corner) { // normalize to array of four arrays with pair arrays
                        var c = zim.copy(shape.corner);
                        if (typeof c == "number") c = [[c,c],[c,c],[c,c],[c,c]]; 
                        else if (Array.isArray(c)) {
                            if (c.length==2) c = [c,c,c,c]; // distributing a single pair input
                            zim.loop(4, function(i){
                                if (zot(c[i])) c[i]=[0,0];
                                if (!Array.isArray(c[i])) c[i] = [c[i],c[i]];
                            });
                        }
                        var adj = .55; // when uneven, .7 works better...
                        points = [
                            [
                                -b.width/2, -(b.height/2 - c[0][1]), 
                                0, 0, 
                                0, 0, 
                                0, -c[0][1] * adj, 
                                "straight"
                            ],
                            [
                                -(b.width/2 - c[0][0]), -b.height/2, 
                                0, 0, 
                                -c[0][0] * adj, 0, 
                                0, 0, 
                                "straight"
                            ],
                            
                            [
                                (b.width/2 - c[1][0]), -b.height/2, 
                                0, 0, 
                                0, 0, 
                                c[1][0] * adj, 0, 
                                "straight"
                            ],
                            [   
                                b.width/2, -(b.height/2 - c[1][1]), 
                                0, 0, 
                                0, -c[1][1] * adj, 
                                0, 0, 
                                "straight"
                            ],
                            
                            [
                                b.width/2, (b.height/2 - c[2][1]), 
                                0, 0, 
                                0, 0, 
                                0, c[2][1] * adj, 
                                "straight"
                            ],
                            [
                                (b.width/2 - c[2][0]), b.height/2, 
                                0, 0, 
                                c[2][0] * adj, 0, 
                                0, 0, 
                                "straight"
                            ],
                            
                            [
                                -(b.width/2 - c[3][0]), b.height/2, 
                                0, 0, 
                                0, 0, 
                                -c[3][0] * adj, 0, 
                                "straight"
                            ],
                            [
                                -b.width/2, (b.height/2 - c[3][1]), 
                                0, 0, 
                                0, c[3][1] * adj, 
                                0, 0, 
                                "straight"
                            ]
                    
                        ]
                    } else {
                        points = [[b.x-b.width/2, b.y-b.height/2],[b.x+b.width/2, b.y-b.height/2],[b.x+b.width/2, b.y+b.height/2],[b.x-b.width/2, b.y+b.height/2]];
                    }                    
					that.setBounds(b.x-b.width/2, b.y-b.height/2, b.width, b.height);
					that.regX = shape.regX-b.width/2;
					that.regY = shape.regY-b.height/2;
					// this.rotation = shape.rotation;
					// this.scaleX = shape.scaleX;
					// this.scaleY = shape.scaleY;
				} else if (shape.type == "Triangle") {
					points = [[shape.three.x-shape.width/2, shape.three.y+shape.height/2+shape.adjusted],[shape.two.x-shape.width/2, shape.two.y+shape.height/2+shape.adjusted],[shape.one.x-shape.width/2, shape.one.y+shape.height/2+shape.adjusted]];
					that.setBounds(b.x-b.width/2, b.y-b.height/2, b.width, b.height);
				} else if (shape.type == "Flare") {
					var diffX = b.width/2+b.x;
					var diffY = b.height/2+b.y;
					points = [];
					var fp = zim.copy(shape.points);
					var lastP = {x:null,y:null};					
					zim.loop(fp, function(p, i) {
						var px = Math.round(p.x);
						var py = Math.round(p.y);
						if (px==lastP.x && py==lastP.y) return;
						lastP = {x:px, y:py};
						points.push([px-diffX, p.y-diffY]);
					});				
					that.setBounds(-shape.width/2, -shape.height/2, shape.width, shape.height);
				}
				return points;
			} else {
				return shape;
			}
		}
		if (typeof points == "string") {
			var svgProcessor = new zim.SVGContainer();
			points = svgProcessor.processPath(points);
			// added ZIM NFT 01 - keep watch...
			// if first and last point are at same place merge points
			if (points[0][0]==points[points.length-1][0] && points[0][1]==points[points.length-1][1]) {
				points[0][4] = points[points.length-1][4];
				points[0][5] = points[points.length-1][5];
				points.pop();
			}
		}

init();
		function init() {
			if (sets) sets.removeAllEventListeners(null, mID);

if (that.selectPoints) {
				that.selectedBalls = new zim.SelectionSet();
				that.selectedRect1s = new zim.SelectionSet();
				that.selectedRect2s = new zim.SelectionSet();

num = typeof points == "number" ? points : points.length;
			if (num <= 0) return;
			if (zot(controlLengthOriginal)) controlLength = radius * 4 / num;

var ballS = handleSize/10*8;
			var rectS = handleSize;

var mobile = zim.mobile();

sets = that.controls = new zim.Container({style:false}).addTo(that); // sets - a set contains a ball and two rects
			if (that.interactive) sets.drag({onTop:!mobile});

_points = [];
			_pointControls = [];
			_pointCircles = [];

var i, point, temp, set, rect1, rect2, ball, type, setInfo;
			
			for (i=0; i<num; i++) {
				set = new zim.Container({style:false}).addTo(sets);
				set.num = i;
				if (typeof points == "number") { // no sets yet

// easier to create controls in a temp vertical Container
					// set the registration point at the circle center
					// then rotate the temp container
					// then get the resulting rotated coordinates and use localToLocal
					// to find coordinates of controls in set Container
					// afterwards, adjust controls in set Container so origin and registration is at ball
					// then move the set Container so it matches that adjustment
					// (or could have calculated all positions to start with aTan2, sin, cos etc.)
					var length = zim.Pick.choose(controlLength);
					temp = new zim.Container(length, radius, null, null, false).reg(length/2, radius).addTo(that);
					temp.rotation = i/num * 360;
					ball = new zim.Circle(ballS, that.selectPoints&&that.selectedBalls.isSelected(i)?selectColor:that.circleColor, that.circleBorderColor, 2, null, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:length/2,y:0});
					rect1 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(controlType), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:0,y:0});
					rect2 = new zim.Rectangle(rectS, rectS, that.selectPoints&&that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(controlType), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, null, false)
						.centerReg(temp)
						.loc({x:length,y:0});

} else { // passing in set data

// balls are relative to blob but handles are relative to ball
					// points is an array of [[setX, setY, ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]

setInfo = points[i];
					type = setInfo[8] ? setInfo[8] : controlType;
					set.loc({x:setInfo[0], y:setInfo[1]});
					ball = new zim.Circle(ballS, that.circleColor, that.circleBorderColor, 2, null, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set)
						.loc({x:setInfo[2],y:setInfo[3]});
					rect1 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[4],y:setInfo[5]});
					rect2 = new zim.Rectangle(rectS, rectS, getBackgroundColor(type), handleSize==0?null:zim.dark, handleSize==0?null:2, null, null, null, null, false)
						.centerReg({add:false})
						.addTo(set, 0)
						.loc({x:setInfo[6],y:setInfo[7]});
				}

ball.mySet = set;
				ball.rect1 = rect1;
				ball.rect2 = rect2;
				ball.index = i;

if (handleSize==0) {
					ball.expand(10);
					rect1.expand(10);
					rect2.expand(10);
				}

if (mobile) {
					ball.on("mousedown", mobileDouble, null, null, null, null, mID);
				} else {
					ball.on("dblclick", doubleIt, null, null, null, null, mID);
				}

rect1.ball = ball;
				rect1.other = rect2;
				rect2.ball = ball;
				rect2.other = rect1;

if (mobile) {
					ball.expand();
					rect1.expand();
					rect2.expand();
				}

point = [set, ball, rect1, rect2, setInfo?setInfo[8]:controlType];
				_points.push(point);
				_pointCircles.push(ball);
				_pointControls.push(set);
			}

function getBackgroundColor(type) {
				var colors = {mirror:"#993399", free:"#ebcb35", none:"#50c4b7"};
				return colors[type] ? colors[type] : "#e472c4";
			}

that.drawShape = function() {
				
				var currentIndex,nextIndex;
				var set,control1,control2,nextSet,ballPoint,nextBall,nextControl1,control1Point,control2Point,nextControl1Point,nextBallPoint;
						
				g.c();
				if (!that.colorCommand) {
					that.colorCommand = g.f(that._color).command;
					// if (color && color.type) that.specialColor(that.colorCommand, color, that);
				}
				// border of 0 or a string value still draws a border in CreateJS
				if (zot(that._borderWidth) || that._borderWidth > 0) { // no border specified or a border > 0
					if (!zot(that._borderColor) || !zot(that._borderWidth)) { // either a border color or thickness
						if (zot(that._borderColor)) that._borderColor = zim.black;
						if (!that.borderColorCommand) {
							that.borderColorCommand = g.s(that._borderColor).command;
							if (that._borderColor && that._borderColor.type) that.specialColor(that.borderColorCommand, that._borderColor, that);
						}
						if (!that.borderWidthCommand) that.borderWidthCommand = g.ss(that._borderWidth, strokeObj.caps, strokeObj.joints, strokeObj.miterLimit, strokeObj.ignoreScale).command;
						if (that._dashed) {
							if (!that.borderDashedCommand) that.borderDashedCommand = g.sd(Array.isArray(that._dashed)?that._dashed:[10, 10], that._dashedOffset).command;
						}
					}
				}
				set = _points[0][0];
				ballPoint = set.localToLocal(_points[0][1].x, _points[0][1].y, shape);
				g.mt(ballPoint.x, ballPoint.y);

s.c().s(that.stickColor).ss(that.stickThickness);

for (var i=0; i<_points.length; i++) {
					currentIndex = i;
					nextIndex = (i+1)%_points.length;

set = _points[currentIndex][0];
					ball = _points[currentIndex][1];
					control1 = _points[currentIndex][2];
					control2 = _points[currentIndex][3];

nextSet = _points[nextIndex][0];
					nextBall = _points[nextIndex][1];
					nextControl1 = _points[nextIndex][2];
					// nextControl2 = _points[nextIndex][3];

control2Point = set.localToLocal(control2.x, control2.y, shape);
					nextControl1Point = nextSet.localToLocal(nextControl1.x, nextControl1.y, shape);
					nextBallPoint = nextSet.localToLocal(nextBall.x, nextBall.y, shape);

g.bt(
						control2Point.x, control2Point.y,
						nextControl1Point.x, nextControl1Point.y,
						nextBallPoint.x, nextBallPoint.y
					);

// create the sticks
					ballPoint = set.localToLocal(ball.x, ball.y, shape);
					control1Point = set.localToLocal(control1.x, control1.y, shape);

s.mt(ballPoint.x, ballPoint.y).lt(control1Point.x, control1Point.y);
					s.mt(ballPoint.x, ballPoint.y).lt(control2Point.x, control2Point.y);
				}
				g.cp();

var startPosition;
			var mDown;
			sets.on("mousedown", function(e) {
				if (that.lockControls) return;
				sets.loop(function(set) {
					if (set == e.target.parent) return;					
					if (set.lastChildren==null) set.lastChildren = set.mouseChildren;
					if (set.lastMouse==null) set.lastMouse = set.mouseEnabled;
					set.noMouse();
				});
				if (shape.lastMouse==null) shape.lastMouse = shape.mouseEnabled;
				shape.mouseEnabled = false;
				mDown = true;
				if (that.selectPoints) that.keyFocus = true;
				startPosition = {x:e.target.x, y:e.target.y};
				var ball;
				if (e.target.rect1) { // then mousedown on ball
					ball = e.target;
					ball.startX = ball.x;
					ball.startY = ball.y;
					ball.rect1.startX = ball.rect1.x;
					ball.rect1.startY = ball.rect1.y;
					ball.rect2.startX = ball.rect2.x;
					ball.rect2.startY = ball.rect2.y;
				} else { // mousedown on control
					var rect = e.target;
					rect.startX = rect.x;
					rect.startY = rect.y;
					ball = rect.ball;
					var index = ball.index;
					var type = controlType;
					if (!zot(_points[index][4])) type = _points[index][4];
					if (type == "straight") {
						var other = rect.other;
						var dX = other.x - ball.x;
						var dY = other.y - ball.y;
						other.stickLength = Math.sqrt(Math.pow(dX,2) + Math.pow(dY,2));
					}
				}
				if (that.selectPoints) {
					// need to reset all start points for each control circle and rectangle moved
					var currentSet = that.selectionManager.currentSet;
					if (currentSet && currentSet.selections && currentSet.selections.length > 0) {
						for(var i=0; i<currentSet.selections.length; i++) {
							var point = that.pointObjects[currentSet.selections[i]];
							point[1].startX = point[1].x;
							point[1].startY = point[1].y;
							point[2].startX = point[2].x;
							point[2].startY = point[2].y;
							point[3].startX = point[3].x;
							point[3].startY = point[3].y;
						}
					}
				}
			}, null, null, null, null, mID);

if (that.selectPoints) {
				sets.tap({call:function (e) {
					var ball;
					if (e.target.rect1) { // then mousedown on ball - which has a rect1
						ball = e.target;
						that.selectedBalls.toggle(ball.parent.num);
					} else { // mousedown on control
						var rect = e.target;
						rect.color = "white";
						ball = rect.ball;
						if (ball.rect1 == rect) that.selectedRect1s.toggle(ball.parent.num);
						else that.selectedRect2s.toggle(ball.parent.num);
					}
					// loop through all controls and set to right color based on selection
					for (var i=0; i<that.pointObjects.length; i++) {
						var po = that.pointObjects[i];
						po[1].color = that.selectedBalls.isSelected(i)?selectColor:that.circleColor;
						po[2].color = that.selectedRect1s.isSelected(i)?selectColor:getBackgroundColor(po[4]);
						po[3].color = that.selectedRect2s.isSelected(i)?selectColor:getBackgroundColor(po[4]);
					}
					e.target.stage.update();
				}, mobileUp:true});
			}

sets.on("pressup", function(e) {
				if (that.lockControls) return;
				sets.loop(function(set) {
					if (set == e.target.parent) return;					
					if (set.lastChildren!=null) set.mouseChildren = set.lastChildren;
					if (set.lastMouse!=null) set.mouseEnabled = set.lastMouse;
					set.lastChildren = null;
					set.lastMouse = null;
				});
				if (shape.lastMouse!=null) shape.mouseEnabled = shape.lastMouse;
				shape.lastMouse = null;
				mDown = false;
				var moveControlCheck = (e.target.x != startPosition.x || e.target.y != startPosition.y);
				var ev = new createjs.Event("change");
				if (e.target.rect1) { // pressup on ball
					ev.controlType = "bezierPoint";
					endMove(e.target);
				} else {
					ev.controlType = "bezierHandle";
				}
				if (moveControlCheck) that.dispatchEvent(ev);
			}, null, null, null, null, mID);

that.changeControl = function(index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update) {
				var sig = "index, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY, update";
				var duo; if (duo = zob(that.changeControl, arguments, sig)) return duo;
				if (zot(index)) {
					for (var i=0; i<_points.length; i++) {
						that.changeControl(i, type, rect1X, rect1Y, rect2X, rect2Y, circleX, circleY);
					}
					return that;
				}
				var point = _points[index];
				point[4] = type;
				if (type == "none") {
					if (!zot(circleX)) point[1].x = circleX;
					if (!zot(circleY)) point[1].y = circleY;
					point[2].x = point[1].x,
					point[2].y = point[1].y;
					point[3].x = point[1].x,
					point[3].y = point[1].y;
					point[1].parent.addChild(point[1]);
				} else {
					if (!zot(circleX)) point[1].x = circleX;
					if (!zot(circleY)) point[1].y = circleY;
					if (!zot(rect1X)) point[2].x = rect1X;
					if (!zot(rect1Y)) point[2].y = rect1Y;
					if (!zot(rect2X)) point[3].x = rect2X;
					if (!zot(rect2Y)) point[3].y = rect2Y;
					point[1].parent.addChildAt(point[1], 0);
				}
				point[2].color = getBackgroundColor(type);
				point[3].color = getBackgroundColor(type);
				if (update) {
					that.update();
					if (that.stage) that.stage.update();
				}
				return that;
			};
			
			that.transformPoints = function(transformType, amount, x, y, approximateBounds) {
				if (zot(approximateBounds)) approximateBounds = true;
				that.points = zim.transformPoints(that.points, transformType, amount, x, y);
				if (approximateBounds) that.approximateBounds();
				return that;
			};

// **** the values we are getting for the points are correct - I have double checked them 
				// I think below is right but maybe going forward with startPercent and amount in animate() is off 
				// why it would be off going forward and not backwards, I don't know.
				
				var amount;
				if (!reverse && startPercent > endPercent) amount = 100 - startPercent + endPercent;
				else if (!reverse && startPercent < endPercent) amount = endPercent - startPercent;
				else if (reverse && startPercent > endPercent) amount = - (startPercent - endPercent);
				else if (reverse && startPercent < endPercent) amount =  - (100 - endPercent + startPercent);

var eventObj = new createjs.Event("traversed");
				eventObj.obj = obj;

obj.animate({
					ease:"linear",
					// **************** problem in animate?
					props:{path:that, startPercent:startPercent, percent:amount},
					time:time,
					call:function() {
						that.dispatchEvent(eventObj);
					}
				});

return that;
			};
			
			that.reversePoints = function(sameStart) {	
				if (zot(sameStart)) sameStart = true;		
				points = zim.copy(that.points);				
				points.reverse();
				if (sameStart) points.unshift(points.pop()); // keep the start point the same
				zim.loop(points, function(p) {
					var p6 = p[6];					
					p[6] = p[4];
					p[4] = p6;
					var p7 = p[7];
					p[7] = p[5];
					p[5] = p7;
					// [point[6], point[7], point[4], point[5]] = [point[4], point[5], point[6], point[7]];                        
				});
				
				that.points = points;
				that.update();
				return that;
			};			
			
						
			that.splitPoints = function(index) {
				var current = zim.copy(that.points);
				if (index < 1 || index > current.length-1) return;
				var first = zim.copy(current.slice(0,index+1));
				var second = zim.copy(current.slice(index));
				zim.trimPointEnds(first);
				zim.trimPointEnds(second);
				var s = that.clone();
				that.points = first;
				that.update();
				s.points = second;
				if (that.parent) s.addTo(that.parent);
				return s;
			};
			
			that.makeSquiggle = function(index) {	
				var current = zim.copy(that.points);
				if (zot(index)) index = 0;
				index = (index+current.length*1000)%current.length;
				var first = zim.copy(current.slice(index));
				var second = zim.copy(current.slice(0,index+1));
				current = first.concat(second);
				zim.trimPointEnds(current);
				var s = new zim.Squiggle({
					points:current,
					color:that.borderColor, 
					thickness:that.borderWidth, 
					showControls:that.controlsVisible,
					interactive:that.interactive,
					onTop:that.onTop,
					dashed:that.dashed,
					stickColor:that.stickColor,
					stickThickness:that.stickThickness					
				});
				return s;
			};

that.splitBlob = function(a, b, num, clean) {
				if (zot(a)) a = 0;
				if (zot(b)) b = Math.ceil(that.points.length/2);				
				if (zot(num)) num = 50;
				if (zot(clean)) clean = true;
				if (typeof a == "number" && typeof b == "number") {
					var c = a;
					if (a > b) {
						a = b;
						b = c;
					} 
				}
			
				if (!zot(a.x) || !zot(b.x)) {
					// this gets array of cubic beziers that closestPointAlongCurve needs
					var blobSegments = that.segmentPoints;
				}

var p1, p2, i1, i2;
				if (!zot(a.x)) { // a global x,y point provided
					var bb = b;		
					if (zot(b.x)) bb = that.pointCircles[b].localToGlobal(0,0);	
					var point1 = zim.loop(num, function(i,t) {
						var p = zim.getPointAtPercent(a.x,a.y,bb.x,bb.y,i/t*100);
						if (that.hitTestPoint(p.x, p.y)) return p;
					});
					if (point1 === true) return; // not intersecting
					p1 = that.globalToLocal(point1.x, point1.y);
					// point, segmentPoints, num, interpolate, percentage
					var percent1 = zim.closestPointAlongCurve(p1, blobSegments, 20, false, true);					
				} else {
					i1 = a;
					p1 = that.pointCircles[a];
				}

if (!zot(b.x)) { // a global x,y point provided			
					var aa = a;		
					if (zot(a.x)) aa = that.pointCircles[a].localToGlobal(0,0);			
					var point2 = zim.loop(num, function(i,t) {
						var p = zim.getPointAtPercent(aa.x,aa.y,b.x,b.y,i/t*100);
						if (that.hitTestPoint(p.x, p.y)) return p;
					}, true); // reverse
					if (point2 === true) return; // not intersecting
					p2 = that.globalToLocal(point2.x, point2.y);
					var percent2 = zim.closestPointAlongCurve(p2, blobSegments, 20, false, true);
				} else {
					i2 = b;
					p2 = that.pointCircles[b];
				}					
				
				if (!zot(a.x)) i1 = that.addPoint(percent1); // returns index of point
				if (!zot(b.x)) i2 = that.addPoint(percent2);

if (!zot(a.x) && zot(b.x) && i1 <= i2) i2++;
				if (!zot(b.x) && zot(a.x) && i2 <= i1) i1++;
				if (!zot(a.x) && !zot(b.x) && i2 <= i1) i1++;
					
				// turn the blob into a squiggle at the first point
				var s1 = that.makeSquiggle(i1).loc(that); // returns Squiggle
				
				// once the blob is cut into a squiggle 
				// we need to find the new index of the second point
				// we will store this as i3
				var num = that.points.length;
				var i3 = (i1 > i2) ? num-i1+i2 : i2-i1;
				
				// split the squiggle into two at the adjusted second point
				var s2 = s1.splitPoints(i3).loc(that); // returns second Squiggle
					
				// turn the squiggles into blobs
				var b1 = s1.makeBlob("free").loc(s1);
				var b2 = s2.makeBlob("free").loc(s2);

b1.color = that.color;
				b2.color = that.color;
				b1.borderColor = that.borderColor;
				b2.borderColor = that.borderColor;
								
				// remove the old parts				
				s1.dispose();
				s2.dispose();
				if (clean) that.dispose();
				
				return [b1, b2];

}

// blob
			if (that.move && that.interactive) shape.drag({onTop:false});
			moveDownEvent = shape.on("mousedown", function(e) {
				stage = e.target.stage;
				startPosition = {x:shape.x, y:shape.y};
				if (that.selectPoints) that.keyFocus = true;
				upTop();
			}, null, null, null, null, mID);
			movePressEvent = shape.on("pressmove", function() {
				sets.x = shape.x;
				sets.y = shape.y;
				sticks.x = shape.x;
				sticks.y = shape.y;
			}, null, null, null, null, mID);
			moveUpEvent = shape.on("pressup", function() {
				var moveControlCheck = (shape.x != startPosition.x || shape.y != startPosition.y);
				var movePoint = shape.localToLocal(that.regX,that.regY,that.parent);
				that.x = movePoint.x;
				that.y = movePoint.y;
				sets.x = sets.y = sticks.x = sticks.y = shape.x = shape.y = 0;
				if (moveControlCheck) {
					var ev = new createjs.Event("change");
					ev.controlType = "move";
					that.dispatchEvent(ev);
				}
				stage.update();
			}, null, null, null, null, mID);

if (!move) stopDragging(true);

that.added(function() {
				stage = that.stage;
				if (that.toggleStageEvent) that.stage.off("stagemousedown", that.toggleStageEvent, null, mID);
				that.toggleStageEvent = that.stage.on("stagemousedown", function(e) {
					if (mDown || !that.allowToggle || !that.stage) return;
					if (_controls && !that.hitTestPoint(e.stageX/zim.scaX, e.stageY/zim.scaY, false)) {
						that.hideControls();
						that.dispatchEvent("controlshide");
					}
				});
			}, null, null, null, null, mID);

that.clickEvent = that.on("click", function() {
				if (that.ctrlKey) {
					setTimeout(function() { // give time for record to work if drag with ctrl down
						that.clone(true).addTo(that.stage).mov(100);
						if (that.allowToggle) {
							that.hideControls();
							that.dispatchEvent("controlshide");
						}
						var ev = new createjs.Event("change");
						ev.controlType = "move";
						that.dispatchEvent(ev);
						that.stage.update();
					}, 50);
				}
			}, null, null, null, null, mID);

that.hideControls = function() {
				that.toggled = false;
				sets.visible = false;
				sticks.visible = false;
				_controls = false;
				if (that.stage) that.stage.update();
				if (!that.allowToggle && that.move) stopDragging();
				return that;
			};
			if (!_controls) that.hideControls();
			that.showControls = function() {
				// if call this with code then will not trigger a change event - not good for TransformManager.persist()
				that.toggled = true;
				sets.visible = true;
				sticks.visible = true;
				_controls = true;
				sets.x = shape.x;
				sets.y = shape.y;
				sticks.x = shape.x;
				sticks.y = shape.y;
				that.addChildAt(shape,0); // put to bottom in case dragged
				if (that.move && !that.allowToggle) startDragging();
				if (that.stage) that.stage.update();
				return that;
			};

that.recordData = function(toJSON) {
				if (zot(toJSON)) toJSON = false;
				var obj = {
					type:"Blob",
					index:that.parent?that.parent.getChildIndex(that):-1,
					x:that.x, y:that.y,
					points:that.getPoints(),
					color:that.color,
					borderColor:that.borderColor,
					borderWidth:that.borderWidth,
					move:that.move,
					allowToggle:that.allowToggle,
					controlsVisible:_controls
				};
				if (toJSON) return JSON.stringify(obj);
				return obj;
			};

that.setData = function(data, fromJSON) {
				if (zot(data)) return;
				if (fromJSON) {
					try{
						data = JSON.parse(data);
					} catch (e) {
						return;
					}
				}
				var index = data.index;
				if (zot(index)) index = -1;
				delete data.index;

var pointData = data.points;
				if (!zot(pointData)) that.setPoints(pointData);
				delete data.points;
				this.num = pointData.length;

for (var d in data) {
					that[d] = data[d];
				}
				if (that.parent) {
					that.parent.setChildIndex(that, index);
				}
				return that;
			};

that.getPoints = function(popup) {
				// _pointCircles are relative to blob but handles are relative to ball
				// points is an array of [[ballX, ballY, handleX, handleY, handle2X, handle2Y, type], etc.]
				if (zot(popup)) popup = false;
				var points = that.points;
				if (popup) {
					if (!pane) {
						var pane = that.pane = new zim.Pane({
							displayClose:false,
							container:that.stage,
							width:Math.min(500, that.stage.width-20),
							height:Math.min(500, that.stage.height-20),
							draggable:true,
						});
						var textArea = that.textArea = new zim.TextArea(Math.min(400, that.stage.width-70), Math.min(400, that.stage.height-70));
						pane.add(textArea);
					} 
					pane.show();		
					textArea.text = JSON.stringify(points);
				}
				return points;
			};
			that.recordPoints = that.getPoints;

that.setPoints = function(points) {
				// adjust blob to match points passed in from getPoints
				var p;
				var p2;
				for (var i=0; i<points.length; i++) {
					p = _points[i];
					p2 = points[i];
					if (zot(p)) continue;
					p[0].x = p2[0];
					p[0].y = p2[1];
					p[1].x = p2[2];
					p[1].y = p2[3];
					p[2].x = p2[4];
					p[2].y = p2[5];
					p[3].x = p2[6];
					p[3].y = p2[7];
					p[4] = p2[8];
					p[2].color = getBackgroundColor(p[4]);
					p[3].color = getBackgroundColor(p[4]);
				}
				that.update();
				return that;
			};
			if (style!==false) zim.styleTransforms(that, DS);
			that.clone = function(exact, commands) {
				var tList = [];
				var tCheck = false;
				zim.loop(that.pointControls,function(p){
					if (p.scaleX+p.scaleY+p.regX+p.regY+p.rotation!=2) tCheck = true;
					tList.push([p.scaleX,p.scaleY,p.regX,p.regY,p.rotation]);
				});
				var newShape =  that.cloneProps(new zim.Blob(commands?that.colorCommand:((exact||!zim.isPick(oa[0]))?that.color:oa[0]), commands?that.borderColorCommand:((exact||!zim.isPick(oa[1]))?that.borderColor:oa[1]), that.borderWidth, that.getPoints(), radius, controlLength, controlType, lockControlType, sets.visible, lockControls, handleSize, that.allowToggle, that.move, dashed, onTop, that.circleColor, that.circleBorderColor, that.stickColor, that.stickThickness, selectColor, selectPoints, that.editPoints, interactive, strokeObj, style, that.group, inherit));
				if (tCheck) {
					zim.loop(newShape.pointControls,function(p,i){					
						p.scaleX = tList[i][0];
						p.scaleY = tList[i][1];
						p.regX = tList[i][2];
						p.regY = tList[i][3];
						p.rotation = tList[i][4];					
					});
					newShape.update();
				}
				
				if (that.linearGradientParams) newShape.linearGradient.apply(newShape, that.linearGradientParams);
				if (that.radialGradientParams) newShape.radialGradient.apply(newShape, that.radialGradientParams);
				return newShape;
			};

// to add a control - make sure click in one spot - not drag
			that.shapeMousedownEvent = that.shape.on("mousedown", function (e) {
				stage = e.target.stage;
				if (!that.editPoints) return;
				if (that.controlsVisible) {
					that.pressX = e.stageX/zim.scaX;
					that.pressY = e.stageY/zim.scaY;
				} else {
					that.pressX = null;
					that.pressY = null;
				}
			}, null, null, null, null, mID);
			that.addPointFactor = 10;
			that.addMinDistance = 15;
			that.shapePressupEvent = that.shape.on("pressup", function (e) {

zim.loop(testPoints, function (p, k) {
							if (k==0) return; // don't put on existing point
							var d = zim.dist(p, point);
							if (d < closest) {
								closest = d;
								closestIndex = k;
							}
						});
						if (closest < that.addMinDistance) {
							var ratios = that.segmentRatios;
							var currentRatio = ratios[pointBefore];
							var lastRatio = pointBefore>0?ratios[pointBefore-1]:0;
							that.addPoint(100*(lastRatio+(currentRatio-lastRatio)*(closestIndex/(testNum+1))));
						}
					}

that.lastindex = pointBefore+1;
					that.lastSelected = that.controls.getChildAt(that.lastindex);
					that.stage.update();
				}
			}, null, null, null, null, mID);

// remove point
			that.controlsClickEvent = that.controls.on("click", function (e) {
				that.lastSelected = e.target.parent;
				that.lastindex = that.controls.getChildIndex(e.target.parent);
				if (!that.editPoints) return;
				if (that.selectionManager.shiftKey) { // remove
					removeControl(e);
				}
			}, null, null, null, null, mID);

if (!_controls) that.hideControls();
			that.dispatchEvent("update");
		} // end of init()

Object.defineProperty(that, 'interactive', {
			get: function() {
				return interactive;
			},
			set: function(value) {
				interactive = value;
				_controls = interactive;
				that.allowToggle = interactive;
				that.editPoints = interactive;
				that.lockControls = !interactive; // note negative
				that.selectPoints = interactive;
				that.move = interactive;
				var p = that.points; // force remake
				that.points = p;
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        // NOTE: extends ZIM CustomShape for more properties and a few functions.
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if (WW.KEYFOCUS!=null) zim.KEYFOCUS = WW.KEYFOCUS;
		Object.defineProperty(this, 'keyFocus', {
			get: function() {
				return zim.KEYFOCUS == that;
			},
			set: function() {
				zim.KEYFOCUS = that;
			}
		});
		if (that.selectPoints && !zim.KEYFOCUS) setFocus();
		function setFocus() {that.keyFocus = true; var d=document.activeElement; if (d) d.blur();}

Object.defineProperty(that, 'points', {
			get: function() {
				var points = [];
				var point; var p;
				for (var i=0; i<_points.length; i++) {
					p = _points[i];
					point = [
						zim.decimals(p[0].x),
						zim.decimals(p[0].y),
						zim.decimals(p[1].x),
						zim.decimals(p[1].y),
						zim.decimals(p[2].x),
						zim.decimals(p[2].y),
						zim.decimals(p[3].x),
						zim.decimals(p[3].y)
					];
					if (p[4] && p[4]!=="straight") point.push(p[4]);
					points.push(point);
				}
				return points;
			},
			set: function(value) {
				var x = that.x;
				var y = that.y;
				var v = that.visible;
				var tList = [];
				var tCheck = false;
				zim.loop(that.pointControls,function(p){
					if (p.scaleX+p.scaleY+p.regX+p.regY+p.rotation!=2) tCheck = true;
					tList.push([p.scaleX,p.scaleY,p.regX,p.regY,p.rotation]);
				});
				that.dispose(true);
				points = checkForShape(value);
				if (that.shape) {
					that.shape.graphics.clear();
					that.sticks.graphics.clear();
					that.controls.noDrag();
					that.removeAllChildren();
					delete that.shape;
					delete that.sticks;
					delete that.controls;
				}
				that.visible = false;
				init(); // remake Blob				
				that.lockControls = _lockControls;
				that.x = x;
				that.y = y;
				that.visible = v;
				if (tCheck) {
					zim.loop(that.pointControls,function(p,i){					
						p.scaleX = tList[i][0];
						p.scaleY = tList[i][1];
						p.regX = tList[i][2];
						p.regY = tList[i][3];
						p.rotation = tList[i][4];
					
					});
					that.update();
				}
			}
		});

Object.defineProperty(that, 'pointsAdjusted', { // points with rotation
			get: function() {
				var points = [];
				var point; var p; var po;
				var pObjects = that.pointObjects;
				zim.loop(pObjects.length, function(i) {
					po = pObjects[i];
					p = _points[i];
					if (po[0].rotation==0 && po[0].scaleX==0 && po[0].scaleY==0) { // get points
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(p[2].x),
							zim.decimals(p[2].y),
							zim.decimals(p[3].x),
							zim.decimals(p[3].y)
						];
					} else {
						var lo1 = po[0].localToLocal(po[2].x, po[2].y, po[0].parent);
						var lo2 = po[0].localToLocal(po[3].x, po[3].y, po[0].parent);
						point = [
							zim.decimals(p[0].x),
							zim.decimals(p[0].y),
							zim.decimals(p[1].x),
							zim.decimals(p[1].y),
							zim.decimals(lo1.x-p[0].x),
							zim.decimals(lo1.y-p[0].y),
							zim.decimals(lo2.x-p[0].x),
							zim.decimals(lo2.y-p[0].y)
						];
					}
					if (p[4] && p[4]!=="mirror") point.push(p[4]);
					points.push(point);
				});
				return points;
			},
			set: function() {
				if (zon) zogy("Blob() - pointsAdjusted is read only");
			}
		});

Object.defineProperty(that, 'pointObjects', {
			get: function() {
				return _points;
			},
			set: function() {
				if (zon) {zogy("Blob() - pointObjects is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

Object.defineProperty(that, 'pointControls', {
			get: function() {
				return _pointControls;
			},
			set: function() {
				if (zon) {zogy("Blob() - pointControls is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

Object.defineProperty(that, 'pointCircles', {
			get: function() {
				return _pointCircles;
			},
			set: function() {
				if (zon) {zogy("Blob() - pointCircles is read only - but its contents can be manipulated - use blob.update() after changes");}
			}
		});

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// path manipulation and animating to path methods

Object.defineProperty(that, 'segmentPoints', {
			get: function() {
				var p = that.pointsAdjusted;
				var array = []; // array of prepared segment points
				zim.loop(p.length, function(i, t) {
					var s = that.getSegmentPoint(p[i], p[i<t-1?i+1:0]);
					array.push(s);
				});
				return array;
			},
			set: function() {
				if (zon) {zogy("Blob() - segmentPoints is read only");}
			}
		});

Object.defineProperty(that, 'segmentRatios', {
			get: function() {
				var distances = [];
				var total = 0;
				zim.loop(that.segmentPoints, function(points) {
					var d = zim.distanceAlongCurve(points);
					distances.push(d);
					total += d;
				});
				var percents = [];
				var totalPercents = 0;
				zim.loop(distances, function (d) {
					var p = d/total;
					totalPercents += p;
					percents.push(totalPercents);
				});
				return percents;
			},
			set: function() {
				if (zon) {zogy("Blob() - segmentRatios is read only");}
			}
		});

this.addPoint = function(percent, controlType) {
			if (zot(percent)) percent = 100;
			var points = that.points;
			var ratios = that.segmentRatios;
			var controls = that.pointControls;
			controlType = controlType ? controlType : originalControlType;
			var index = insertPointData(points, controls, ratios, percent, controlType);
			that.points = points;
			that.num = points.length;
			return index;
		};

if (dataOnly) that.interpolatedPoints = [];

// dataOnly should add points to current point too
			// but can't just use current point because sometimes that is static
			// like when dragging the shape or a point - it does not register until mouseup
			// and things like hitTestPath need that to be dynamic
			// So the below does not work:
			// if (dataOnly) {
			// 	that.interpolatedPoints = [];
			// 	zim.loop(points, function (point, i) {
			// 		if (!zot(startPoint) && i!=startPoint) return;
			// 		that.interpolatedPoints.push({x:point[0], y:point[1]})
			// 	});
			// }
			if (spread) var totalPoints = ratios.length*num;
			zim.loop(ratios, function (ratio, j) {
				if (dataOnly) insertPointData(points, that.pointControls, that.segmentRatios, lastRatio*100, controlType, !zot(startPoint) && j!=startPoint, dataOnly, even);
				var numCount = spread?Math.round(totalPoints*(ratio-lastRatio)):num;
				var div = 1/(numCount+1);
				zim.loop(numCount, function(i) {
					var r = lastRatio + (ratio-lastRatio)*div*(i+1);
					insertPointData(points, that.pointControls, that.segmentRatios, r*100, controlType, !zot(startPoint) && j!=startPoint, dataOnly, even);
					if (!dataOnly && num > 0) that.points = points;
				});
				lastRatio = ratio;
			});
			if (dataOnly && that.type == "Squiggle") insertPointData(points, that.pointControls, that.segmentRatios, 100, controlType, null, dataOnly, even);
			if (that.stage) that.stage.update();
			that.num = points.length;
			return that;
		};
		this.interpolate = function(num, startPoint, spread, points, even) {
			if (zot(num)) num = 1;
			// dataOnly will add Point to start point too
			that.addPoints(num, "none", startPoint, spread, true, points, even);
			return that.interpolatedPoints;
		};		
		if (approxCheck) that.approximateBounds();

zim.Label = function(text, size, font, color, rollColor, shadowColor, shadowBlur, align, valign, bold, italic, variant, lineWidth, lineHeight, backing, outlineColor, outlineWidth, backgroundColor, backgroundBorderColor, backgroundBorderWidth, corner, backgroundDashed, padding, paddingH, paddingV, shiftH, shiftV, rollPersist, labelWidth, labelHeight, maxSize, splitWords, style, group, inherit) {
		var sig = "text, size, font, color, rollColor, shadowColor, shadowBlur, align, valign, bold, italic, variant, lineWidth, lineHeight, backing, outlineColor, outlineWidth, backgroundColor, backgroundBorderColor, backgroundBorderWidth, corner, backgroundDashed, padding, paddingH, paddingV, shiftH, shiftV, rollPersist, labelWidth, labelHeight, maxSize, splitWords, style, group, inherit";
		var duo; if (duo = zob(zim.Label, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "Label";

this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(text)) text=DS.text!=null?DS.text:"LABEL";
		if (zot(size)) size=DS.size!=null?DS.size:36;
		if (zot(font)) font=DS.font!=null?DS.font:"arial"; // arial unless manually set
		if (zot(color)) color=DS.color!=null?DS.color:zim.black;
		if (zot(bold)) bold=DS.bold!=null?DS.bold:false;
		if (zot(italic)) italic=DS.italic!=null?DS.italic:false;

var oa = remember(text, size, font, color, bold, italic);
		this.veeObj = {text:oa[0], size:oa[1], font:oa[2], color:oa[3], bold:oa[4], italic:oa[5]};
		function remember() {return arguments;}

text = zik(text);
		shiftH = zik(shiftH);
		shiftV = zik(shiftV);

var emptyText = false;
		if (text === "") {
			text = " ";
			emptyText = true;
		}
		size = zim.Pick.choose(size);
		font = zim.Pick.choose(font);
		font = font.replace("+", " ");
		var fontTypes = ["ttf","otf","woff2","woff","fnt"];
		var ncheck = font.split(".");
		if (ncheck.length>0 && fontTypes.indexOf(ncheck[1])!=-1) font = ncheck[0];
		color = zim.Pick.choose(color);
		bold = zim.Pick.choose(bold);
		italic = zim.Pick.choose(italic);

if (zot(rollColor)) rollColor=DS.rollColor!=null?DS.rollColor:null;
		if (zot(shadowColor) || shadowColor=="ignore") shadowColor=(DS.shadowColor!=null&&shadowColor!="ignore")?DS.shadowColor:-1;
		if (zot(shadowBlur) || shadowBlur=="ignore") shadowBlur=(DS.shadowBlur!=null&&shadowBlur!="ignore")?DS.shadowBlur:14;
		if (zot(align)) align=DS.align!=null?DS.align:"left";
		if (zot(valign)) valign=DS.valign!=null?DS.valign:"top";
		if ((!zot(outlineColor) || !zot(DS.outlineColor)) && zot(outlineWidth)) outlineWidth = DS.outlineWidth!=null?DS.outlineWidth:Math.round(size*.2);
		if ((!zot(outlineWidth) || !zot(DS.outlineWidth)) && zot(outlineColor)) outlineColor = DS.outlineColor!=null?DS.outlineColor:zim.black;
		if (zot(outlineWidth)) outlineWidth = DS.outlineWidth!=null?DS.outlineWidth:0;
		if (zot(backgroundColor) || backgroundColor=="ignore") backgroundColor = (DS.backgroundColor!=null&&backgroundColor!="ignore")?DS.backgroundColor:null;
		if (zot(backgroundBorderColor)) backgroundBorderColor = (DS.backgroundBorderColor!=null&&backgroundBorderColor!="ignore")?DS.backgroundBorderColor:null;
		if (zot(backgroundBorderWidth)) backgroundBorderWidth = (DS.backgroundBorderWidth!=null&&backgroundBorderWidth!="ignore")?DS.backgroundBorderWidth:null;
		if (zot(corner)) corner = (DS.corner!=null&&corner!="ignore")?DS.corner:null;
		if (zot(backgroundDashed)) backgroundDashed = (DS.backgroundDashed!=null&&backgroundDashed!="ignore")?DS.backgroundDashed:null;
		if (zot(padding) || padding=="ignore") padding = (DS.padding!=null&&padding!="ignore")?DS.padding:10;
		if (zot(paddingH)) paddingH = DS.paddingH!=null?DS.paddingH:padding;
		if (zot(paddingV)) paddingV = DS.paddingV!=null?DS.paddingV:padding;
		if (zot(shiftH)) shiftH = DS.shiftH!=null?DS.shiftH:0;
		if (zot(shiftV)) shiftV = DS.shiftV!=null?DS.shiftV:0;
		if (zot(variant)) variant=DS.variant!=null?DS.variant:false;
		if (zot(lineWidth)) lineWidth = DS.lineWidth!=null?DS.lineWidth:null;
		if (zot(lineHeight)) lineHeight = DS.lineHeight!=null?DS.lineHeight:null;
		if (zot(backing) || backing=="ignore") backing = (DS.backing!=null&&backing!="ignore")?DS.backing.clone():null;
		if (zot(rollPersist)) rollPersist = DS.rollPersist!=null?DS.rollPersist:false;
		if (DS.labelWidth!=null) lineWidth = DS.labelWidth;
		if (!zot(labelWidth)) lineWidth = labelWidth;
		if (align == "middle") align = "center";
		if (zot(labelHeight)) labelHeight = DS.labelHeight!=null?DS.labelHeight:null;
		if (zot(maxSize)) maxSize = DS.maxSize!=null?DS.maxSize:null;
		size = maxSize?Math.min(size, maxSize):size;
		if (zot(splitWords)) splitWords=DS.splitWords!=null?DS.splitWords:false;

obj = makeLabel(text);

// measure lines to make sure not going past lineWidth		
		function testLine(l, w, line) {
			var endIndex = Math.ceil(lW/w*line.length);
			var start = line.substr(0,endIndex);
			var l2 = makeLabel(start);
			var w2 = l2.getMeasuredWidth();
			if (w2 > lW) {
				while (w2 > lW) {
					endIndex--;
					start = line.substr(0,endIndex)
					l2 = makeLabel(start);
					w2 = l2.getMeasuredWidth();					
				}
			} else if (w2 <= lW) {
				while (w2 <= lW) {					
					endIndex++;
					start = line.substr(0,endIndex)
					l2 = makeLabel(start);
					w2 = l2.getMeasuredWidth();
				}							
				endIndex--;
				start = line.substr(0,endIndex)
			} 			
			var end = line.substr(endIndex, line.length);
			return {endIndex:endIndex, start:start, end:end};
		}		
		
		if (splitWords && lW > size * 1.2) { // approximate						
			var metrics = obj.getMetrics();
			var wCount = 0;			
			while (metrics.width > lW && wCount < 1000) {
				wCount++;
				zim.loop(metrics.lines, function(line, i) {
					line = line.replace(/^[\s\t]+/, "");					
					var l = makeLabel(line);
					var w = l.getMeasuredWidth();					
					if (w > lW) {						
						var dat = testLine(l, w, line);	
						metrics.lines[i] = dat.start;
						// move extra letters into the next line if there is one
						if (metrics.lines.length > i+1) {  							
							dat.end.trim();
							metrics.lines[i+1] = dat.end + " " + metrics.lines[i+1];
						} else {
							metrics.lines.push(dat.end);
						}
						obj = makeLabel(metrics.lines.join(" "));
						metrics = obj.getMetrics();
						return false;
					}					
				}); // end line loop					
			} // end while	
		} // end split test		
		
		this.label = obj;
		obj.textAlign = align;
		obj.textBaseline = "alphabetic";
		
		if (outlineWidth > 0) {
			var obj2 = this.outlineLabel = obj.clone();
			obj2.color = outlineColor;
			obj2.outline = outlineWidth;
		}
		if (shadowColor != -1 && shadowBlur > 0) obj.shadow = new createjs.Shadow(shadowColor, 3, 3, shadowBlur);
		this.addChild(obj);

if (valign != "baseline" && !retina) obj.y += size/32; //32; // backing often on capital letters without descenders - was /16

finalShift();
		}
		setSize();

if (!zot(backing)) {
			if (backing.type == "Pattern") {
				that.backing = new zim.Container(that.width+paddingH*2, that.height+paddingV*2, null, null, false).centerReg(null, null, false);
				if (shadowColor != -1 && shadowBlur > 0) {
					var shadowRect = new zim.Rectangle(that.width+paddingH*2-2, that.height+paddingV-2, "#666", null, null, corner, null, null, null, false).center(that.backing);
					shadowRect.shadow = new createjs.Shadow(shadowColor, 3, 3, shadowBlur);
				}
				var mask = new zim.Rectangle(that.width+paddingH*2, that.height+paddingV*2, backgroundColor, null, null, corner, null, null, null, false).addTo(that.backing);
				backing.centerReg(mask);
				backing.setMask(mask);
				that.backing.pattern = backing;
			} else {
				that.backing = backing;
			}
			that.backing.center(that, 0);
			backing = that.backing;
			setBackBounds();
			backingPlaced = true;
		}

function setBackBounds() {
			var bb = backing.boundsToGlobal();
			var bbb = that.boundsToGlobal(bb, true);			
			that.setBounds(bbb.x, bbb.y, bbb.width, bbb.height);
		}

function finalShift() {
			zim.pos(obj, (align=="left"||align=="right")?(backing||that.background?paddingH:0):null, (valign=="top"||valign=="baseline"||valign=="bottom")?(backing||that.background?paddingV:0):null, align=="right", valign=="bottom");
			// zim.pos(obj, (align=="left"||align=="right")?0:null, (valign=="top"||valign=="baseline"||valign=="bottom")?0:null, align=="right", valign=="bottom");
			obj.x += shiftH;
			obj.y += shiftV;			
		}
		finalShift();

function setOutline() {
			if (obj2) {
				obj2.x = obj.x;
				obj2.y = obj.y;
				that.addChildAt(obj2,(that.background||that.backing)?1:0);
			}
		}
		setOutline();

Object.defineProperty(that, 'size', {
			get: function() {
				return size;
			},
			set: function(value) {
				size = maxSize?Math.min(value, maxSize):value;
				options[3] = size + "px";
				this.label.font = options.join(" ");
				if (obj2) obj2.font = options.join(" ");	
				
				obj.setBounds(null);
				that.setBounds(null);

setSize();
				setOutline();
				
			}
		});

Object.defineProperty(that, 'lineHeight', {
			get: function() {
				return that.label.lineHeight;
			},
			set: function(value) {
				this.label.lineHeight = value;
				if (obj2) obj2.label.lineHeight = value;
					
				obj.setBounds(null);
				that.setBounds(null);

setSize();
				setOutline();

if (!zot(lineWidth) && !zot(labelHeight)) fitText();

}
		});

Object.defineProperty(that, 'valign', {
			get: function() {
				return valign;
			},
			set: function(value) {
				if (zot(value)) return;
				valign = value;
				setSize();
				setOutline();
			}
		});

Object.defineProperty(that, 'color', {
			get: function() {
				return color;
			},
			set: function(value) {
				if (rollColor == color) rollColor = value;
				color = value;
				obj.color = color;
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});
		Object.defineProperty(that, 'colorOnly', {
			get: function() {
				return color;
			},
			set: function(value) {
				color = value;
				obj.color = color;
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});
		var startColor;
		var endColor;
		this.setColorRange = function(color1, color2) {
			if (zot(color2)) {
				startColor = that.color;
				endColor = color1;
			} else if (zot(color1)) {
				startColor = that.color;
				endColor = color2;
			} else {
				startColor = color1;
				endColor = color2;
			}
			return that;
		};
		var _colorRange = 0;
		Object.defineProperty(that, 'colorRange', {
			get: function() {
				return _colorRange;
			},
			set: function(value) {
				_colorRange = value;
				if (!zot(startColor) && !zot(endColor)) {
					that.color = zim.colorRange(startColor, endColor, value);
				}
			}
		});

Object.defineProperty(that, 'backgroundColor', {
			get: function() {
				return backgroundColor;
			},
			set: function(value) {
				backgroundColor = value;
				if (that.background) {
					that.background.color = value;
				} else if (that.backing) {
					that.backing.color = value;
				} else {
					setBackground();
				}
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'outlineColor', {
			get: function() {
				return outlineColor;
			},
			set: function(value) {
				outlineColor = value;
				if (obj2) obj2.color = outlineColor;
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

this._enabled = true;
		Object.defineProperty(that, 'enabled', {
			get: function() {
				return that._enabled;
			},
			set: function(value) {
				zenable(that, value);
				obj.color = color;
				that.mouseChildren = false;
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

this.showRollColor = function(yes) {			
			if (zot(yes)) yes = true;
			if (yes) {
				obj.color = rollColor;
			} else {
				obj.color = color;
			}
			if (that.stage) that.stage.update();
			return that;
		};

Object.defineProperty(that, 'labelWidth', {
			get: function() {
				return lineWidth;
			},
			set: function(value) {
				if (value > 0) {
					lineWidth = value;
					
					lW = lineWidth;				
					if (!zot(backing) || !zot(backgroundColor)) {					
						if (lW) lW = lW-paddingH*2;
					}
					
					that.label.lineWidth = lW;
					if (obj2) obj2.lineWidth = lW;
				
					obj.setBounds(null);
					that.setBounds(null);					
					setSize();			
					if (labelHeight) fitText();	
					
					if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
				}
			}
		});

Object.defineProperty(that, 'labelHeight', {
			get: function() {
				return labelHeight;
			},
			set: function(value) {
				if (value > 0) {
					labelHeight = value;
					
					lH = labelHeight;				
					if (!zot(backing) || !zot(backgroundColor)) {					
						if (lH) lH = lH-paddingV*2;
					}
										
					if (lineWidth) fitText();
					that.setBounds(null);
					if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
				}
			}
		});
		if (!zot(lineWidth) && !zot(labelHeight)) {
			fitText();
		}
		
		function fitText() {
			that.size = maxSize?maxSize:200;
			var count = 0;
			while(lineHeight < lH / 2 && (that.height > lH || that.width > lW)) {
			// while(that.height > labelHeight || that.width > lineWidth) { // ami Aug 2019
				count++;
				that.size = that.size/2;
				if (count>50) break;
			}
			count = 0;
			while(that.height <= lH && that.width <= lW) {
				count++;
				that.size = Math.ceil(that.size + 1);
				if (count>50) break;
			}
			that.size = that.size - 1;
			setOutline();
						
			obj.setBounds(null);
			var b = obj.getBounds();
			var by = b.y;
			var bh = b.height;			
			if (lH) {
				if (valign=="bottom") {
					by = by-lH+bh;
				} else if (valign=="center" || valign=="middle") {
					by = (by+by-lH+bh)/2; // ?
				}	
				bh = lH;				
			}
			obj.setBounds(b.x, by, b.width, bh);
			
			that.setBounds(null);
			b = that.getBounds();
			that.setBounds(b.x, b.y, b.width, b.height);
									
			if (backing) {
				if (backingPlaced) setBackBounds();
			} else if (!zot(backgroundColor)) {
				setBackground();
			}
		}
		if (style!==false) zim.styleTransforms(this, DS);
		this.clone = function(exact) {
			return that.cloneProps(new zim.Label((exact||!zim.isPick(oa[0]))?that.text:oa[0], (exact||!zim.isPick(oa[1]))?size:oa[1], (exact||!zim.isPick(oa[2]))?font:oa[2], (exact||!zim.isPick(oa[3]))?color:oa[3], rollColor, shadowColor, shadowBlur, align, valign, (exact||!zim.isPick(oa[4]))?bold:oa[4], (exact||!zim.isPick(oa[5]))?italic:oa[5], variant, lineWidth, lineHeight,
				!zot(backing)?backing.clone(exact):null, outlineColor, outlineWidth, backgroundColor, backgroundBorderColor, backgroundBorderWidth, corner, backgroundDashed, padding, paddingH, paddingV, shiftH, shiftV, rollPersist, labelWidth, labelHeight, maxSize, splitWords, style, this.group, inherit));
		};
	};
	zim.extend(zim.Label, zim.Container, "clone", "zimContainer");

zim.Button = function(width, height, label, backgroundColor, rollBackgroundColor, downBackgroundColor, color, rollColor, downColor, borderColor, borderWidth, rollBorderColor, downBorderColor, backing, rollBacking, downBacking, icon, rollIcon, downIcon, corner, dashed, shadowColor, shadowBlur, gradient, gloss, align, valign, indent, indentH, indentV, hitPadding, autoPadding, autoPaddingH, autoPaddingV, rollPersist, toggle, toggleBackgroundColor, rollToggleBackgroundColor, downToggleBackgroundColor, toggleColor, rollToggleColor, downToggleColor, toggleBacking, rollToggleBacking, downToggleBacking, toggleIcon, rollToggleIcon, downToggleIcon, toggleEvent, wait, waitTime, waitBackgroundColor, rollWaitBackgroundColor, downWaitBackgroundColor, waitColor, rollWaitColor, downWaitColor, waitBacking, rollWaitBacking, downWaitBacking, waitIcon, rollWaitIcon, downWaitIcon, waitModal, waitEnabled, style, group, inherit) {
		var sig = "width, height, label, backgroundColor, rollBackgroundColor, downBackgroundColor, color, rollColor, downColor, borderColor, borderWidth, rollBorderColor, downBorderColor, backing, rollBacking, downBacking, icon, rollIcon, downIcon, corner, dashed, shadowColor, shadowBlur, gradient, gloss, align, valign, indent, indentH, indentV, hitPadding, autoPadding, autoPaddingH, autoPaddingV, rollPersist, toggle, toggleBackgroundColor, rollToggleBackgroundColor, downToggleBackgroundColor, toggleColor, rollToggleColor, downToggleColor, toggleBacking, rollToggleBacking, downToggleBacking, toggleIcon, rollToggleIcon, downToggleIcon, toggleEvent, wait, waitTime, waitBackgroundColor, rollWaitBackgroundColor, downWaitBackgroundColor, waitColor, rollWaitColor, downWaitColor, waitBacking, rollWaitBacking, downWaitBacking, waitIcon, rollWaitIcon, downWaitIcon, waitModal, waitEnabled, style, group, inherit";
		var duo; if (duo = zob(zim.Button, arguments, sig, this)) return duo;
		this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle("Button", group, inherit);

if (zot(width)) width=DS.width!=null?DS.width:200;
		if (zot(height)) height=DS.height!=null?DS.height:60;
		
		if (zot(WW.M)) WW.M = zim.mobile();		
		
		// used if custom label to determine which color to use
		var colorStart = color!=null?color:color=DS.color!=null?DS.color:null
		var rollColorStart = rollColor!=null?rollColor:rollColor=DS.rollColor!=null?DS.rollColor:null
		
		if (zot(colorStart)) color=zim.white;
		else color = colorStart;
		if (zot(rollColorStart)) rollColor=zim.white;	
		else rollColor = rollColorStart;	
		
		// used to return the label to start colors after roll colors
		var oColor = color;
		var oRollColor = rollColor;

if (zot(autoPadding)) autoPadding=DS.autoPadding!=null?DS.autoPadding:20;
		if (zot(autoPaddingH)) autoPaddingH=DS.autoPaddingH!=null?DS.autoPaddingH:autoPadding;
		if (zot(autoPaddingV)) autoPaddingV=DS.autoPaddingV!=null?DS.autoPaddingV:autoPadding;
		if (zot(align)) align=DS.align!=null?DS.align:"center";
		if (zot(valign)) valign=DS.valign!=null?DS.valign:"center";
		var oLabel = label;
		if (zot(label)) {if (zot(icon) && zot(backing)) {label = DS.label!=null?DS.label:"PRESS";} else {label = "";}}
		// text, size, font, color, rollColor, shadowColor, shadowBlur, align, valign
		if (typeof label === "string" || typeof label === "number") {
			label = new zim.Label({
				text:label, size:DS.size!=null?DS.size:36, font:DS.font!=null?DS.font:"arial", color:DS.color!=null&&oColor==null?DS.color:color, rollColor:DS.rollColor&&oRollColor==null!=null?DS.rollColor:rollColor, align:align, valign:valign, rollPersist:DS.rollPersist!=null?DS.rollPersist:false,
				backing:"ignore", shadowColor:"ignore", shadowBlur:"ignore", padding:"ignore", backgroundColor:"ignore", shiftV:DS.shiftV!=null?DS.shiftV:0, shiftH:DS.shiftH!=null?DS.shiftH:0,
				style:false, group:this.group
			});		
		} else {
			if (zot(colorStart)) {
				color = label.color;
				oColor = color;
			} else {
				label.color = color;				
			}
			
			if (zot(rollColorStart)) {				
				if (zot(label.rollColor)) {
					rollColor = color;
					oRollColor = color;
					label.rollColor = rollColor;
				} else {
					rollColor = label.rollColor;
					oRollColor = rollColor;
				}	
			} else {
				label.rollColor = rollColor;				
			}
		}
		if (zot(downColor)) downColor=DS.downColor!=null?DS.downColor:rollColor;
		
		if (width=="auto") width = label.width+autoPaddingH*2;
		if (height=="auto") height = label.height+autoPaddingV*2;
		
		this.zimContainer_constructor(width, height, null, null, false);
		this.type = "Button";

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

// TODO - can't set backgroundColor to color etc as it is calling a ZIM VEE activation on it
		// so somehow zik the color then set the backgroundColor... but will that mess up the oa?
		// get styles but leave final value null - then do oa - then apply matching defaults 
		// but maybe same with rollColor and downColor

if (zot(backgroundColor)) backgroundColor=DS.backgroundColor!=null?DS.backgroundColor:zim.purple;
		if (zot(rollBackgroundColor)) rollBackgroundColor=DS.rollBackgroundColor!=null?DS.rollBackgroundColor:backgroundColor.lighten?backgroundColor.lighten(.2):backgroundColor;
		if (zot(downBackgroundColor)) downBackgroundColor=DS.downBackgroundColor!=null?DS.downBackgroundColor:rollBackgroundColor;
		
		var oa = remember(backgroundColor, rollBackgroundColor, downBackgroundColor, color, rollColor, downColor);
		this.veeObj = {backgroundColor:oa[0], rollBackgroundColor:oa[1], downBackgroundColor:oa[2], color:oa[3], rollColor:oa[4], downColor:oa[5]};
		function remember() {return arguments;} // for cloning PICK
		backgroundColor = zik(backgroundColor);
		rollBackgroundColor = zik(rollBackgroundColor);
		downBackgroundColor = zik(downBackgroundColor);
		color = zik(color);
		rollColor = zik(rollColor);
		downColor = zik(downColor);

var timeType = zot(WW.TIME) ? zot(zim.TIME) ? "seconds" : zim.TIME : WW.TIME;
		
		var originalBorderColor = borderColor;
		var originalBorderWidth = borderWidth;
		if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:null;
		if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:null;
		if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
		else if (borderColor!=null && borderWidth==null) borderWidth = 1;
		if (zot(rollBorderColor)) rollBorderColor=DS.rollBorderColor!=null?DS.rollBorderColor:borderColor;
		if (zot(downBorderColor)) downBorderColor=DS.downBorderColor!=null?DS.downBorderColor:rollBorderColor;
		
		if (zot(corner)) corner=DS.corner!=null?DS.corner:10;
		if (zot(shadowColor)) shadowColor=DS.shadowColor!=null?DS.shadowColor:"rgba(0,0,0,.3)";
		if (zot(shadowBlur)) shadowBlur=DS.shadowBlur!=null?DS.shadowBlur:14;
		if (zot(hitPadding)) hitPadding=DS.hitPadding!=null?DS.hitPadding:0;
		if (zot(indent)) indent=DS.indent!=null?DS.indent:10;
		if (zot(indentH)) indentH=DS.indentH!=null?DS.indentH:indent;
		if (zot(indentV)) indentV=DS.indentV!=null?DS.indentV:indent;
		if (zot(gradient)) gradient = DS.gradient!=null?DS.gradient:0;
		if (zot(gloss)) gloss = DS.gloss!=null?DS.gloss:0;		
		var toggleOkay = (!zot(toggle) || !zot(toggleBacking) || !zot(rollToggleBacking) || !zot(downToggleBacking) || !zot(toggleIcon) || !zot(rollToggleIcon) || !zot(downToggleIcon)) && zot(wait) && zot(waitBacking) && zot(rollWaitBacking);
		if (toggleOkay && zot(toggleEvent)) toggleEvent = WW.M?"mousedown":"click";
		if (zot(rollPersist)) rollPersist = DS.rollPersist!=null?DS.rollPersist:false;
		this.rollPersist = rollPersist;
		if (zot(dashed)) dashed = DS.dashed!=null?DS.dashed:false;
		
        if (zot(toggle)) toggle=DS.toggle!=null?DS.toggle:null;
		if (!zot(toggle) && toggle.type=="Label") {if (zon) zogy("Button() - do not pass Label to toggle parameter - just pass a String");}

if (zot(toggleBackgroundColor)) toggleBackgroundColor=DS.toggleBackgroundColor!=null?DS.toggleBackgroundColor:backgroundColor;
		if (zot(rollToggleBackgroundColor)) rollToggleBackgroundColor=DS.rollToggleBackgroundColor!=null?DS.rollToggleBackgroundColor:rollBackgroundColor;
		if (zot(downToggleBackgroundColor)) downToggleBackgroundColor=DS.downToggleBackgroundColor!=null?DS.downToggleBackgroundColor:rollToggleBackgroundColor;
		if (zot(toggleColor)) toggleColor=DS.toggleColor!=null?DS.toggleColor:label.color;
		if (zot(rollToggleColor)) rollToggleColor=DS.rollToggleColor!=null?DS.rollToggleColor:label.rollColor;
		if (zot(downToggleColor)) downToggleColor=DS.downToggleColor!=null?DS.downToggleColor:label.rollToggleColor;

if (zot(wait)) wait=DS.wait!=null?DS.wait:null;
		if (zot(waitTime)) waitTime=DS.waitTime!=null?DS.waitTime:timeType=="seconds"||timeType=="s"?5:5000;
		if (zot(waitBackgroundColor)) waitBackgroundColor=DS.waitBackgroundColor!=null?DS.waitBackgroundColor:backgroundColor;
		if (zot(rollWaitBackgroundColor)) rollWaitBackgroundColor=DS.rollWaitBackgroundColor!=null?DS.rollWaitBackgroundColor:rollBackgroundColor;
		if (zot(downWaitBackgroundColor)) downWaitBackgroundColor=DS.downWaitBackgroundColor!=null?DS.downWaitBackgroundColor:rollBackgroundColor;
		if (zot(waitColor)) waitColor=DS.waitColor!=null?DS.waitColor:label.color;
		if (zot(rollWaitColor)) rollWaitColor=DS.rollWaitColor!=null?DS.rollWaitColor:label.rollColor;
		if (zot(downWaitColor)) downWaitColor=DS.downWaitColor!=null?DS.downWaitColor:rollWaitColor;

var that = this;
		this.mouseChildren = false;
		this.cur("pointer");
		that.focus = false;
		that.rolled = false;		
		that.corner = corner;

timeType = getTIME(waitTime);

//~~~~~~~~~~~~~  BACKINGS
		// also see manual setting of backings beneath getter setter methods
		if (zot(backing)) backing = DS.backing!=null?DS.backing.clone():null;
		if (zot(backing)) that.backing = new zim.Rectangle(width,height,backgroundColor,null,null,corner,dashed,null, null,false).centerReg(null, null, false);
		else that.backing = backing; // if backing is null - we have no custom backing - this test is used later
				
		that.rollBacking = zot(rollBacking)?(DS.rollBacking!=null?DS.rollBacking.clone():null):rollBacking;
		that.downBacking = zot(downBacking)?(DS.downBacking!=null?DS.downBacking.clone():null):downBacking;
		that.waitBacking = zot(waitBacking)?(DS.waitBacking!=null?DS.waitBacking.clone():null):waitBacking;
		that.rollWaitBacking = zot(rollWaitBacking)?(DS.rollWaitBacking!=null?DS.rollWaitBacking.clone():null):rollWaitBacking;
		that.downWaitBacking = zot(downWaitBacking)?(DS.downWaitBacking!=null?DS.downWaitBacking.clone():null):downWaitBacking;
		that.toggleBacking = zot(toggleBacking)?(DS.toggleBacking!=null?DS.toggleBacking.clone():null):toggleBacking;
		that.rollToggleBacking = zot(rollToggleBacking)?(DS.rollToggleBacking!=null?DS.rollToggleBacking.clone():null):rollToggleBacking;
		that.downToggleBacking = zot(downToggleBacking)?(DS.downToggleBacking!=null?DS.downToggleBacking.clone():null):downToggleBacking;

//~~~~~~~~~~~~~  GRADIENT AND GLOSS

//~~~~~~~~~~~~~  HITAREA AND LABEL

this.addChild(label);
		label.center(this);
		// label.y+=(WW.zdf && zdf.retina!=true)?1:0;
		label.y+=1;
		this.label = label;

zim.pos(label, (align=="left"||align=="right")?indentH:null, (valign=="top"||valign=="bottom")?indentV:null, align=="right", valign=="bottom");

var latestColor = label.color; // used to help down color change back to whatever mode color is set (normal, toggle, wait)

//~~~~~~~~~~~~~  TOGGLE STATE
		this.toggled = false;
		if (toggleOkay) {			
			var originalText = label.text;
			var originalColor = label.color;
			var originalRollColor = label.rollColor;
			var originalDownColor = label.rollColor;
			this.on(toggleEvent, function() {
				that.toggled = !that.toggled;
				setToggled();
			}, null, null, null, null, mID);
		}

this.toggle = function(state) {			
			if (!toggleOkay) {
				if (zon) zogy("Button() - can't toggle with wait parameters provided");
				return that;
			}
			if (zot(state)) {
				that.toggled = !that.toggled;
			} else {
				that.toggled = state;
			}
			setToggled();
			return that;
		};

function doWait() {
			if ((!zot(wait) || !zot(waitBacking) || !zot(rollWaitBacking)) && !that.waiting) {
				willBeWaiting = true;
				if (zot(waitEnabled)) waitEnabled = true;
				if (waitModal) waitModalEvent = that.stage.on("stagemousedown", function(e) {
					if (!that.hitTestPoint(e.stageX/zim.scaX, e.stageY/zim.scaY)) that.clearWait();
				}, null, true, null, null, mID); // run only once
				// wait before setting the waiting property so first click is not a waiting
				setTimeout(function(){that.waiting = true;}, 50);
				// set button to waiting state
				waitStartText = label.text;
				if (!zot(waitColor)) that.label.colorOnly = latestColor = waitColor;
				if (!zot(rollWaitColor)) that.label.rollColor = rollWaitColor;
				waitStartEnabled = that.enabled;
				if (!waitEnabled && that.enabled) that.enabled = false;
				if (!zot(wait)) that.label.text = wait;

if (that.rolled) {
					if (zot(backing) && !that.rollWaitBacking) {
                        that.backing.color = rollWaitBackgroundColor;
                    }
					if (that.rollWaitBacking) changeObject("rollWaitBacking");
					else if (that.waitBacking) changeObject("waitBacking");
					if (that.rollWaitIcon) changeObject("rollWaitIcon");
					else if (that.waitIcon) changeObject("waitIcon");
				} else {
					if (zot(backing) && !that.waitBacking) that.backing.color = waitBackgroundColor;
					if (that.waitBacking) changeObject("waitBacking");
					if (that.waitIcon) changeObject("waitIcon");
				}

if (waitTimeout) waitTimeout.clear();
				waitTimeout = zim.timeout(waitTime, function() {
					// set button to proper text, icon, backing, colors, etc.
					if (!that.enabled) that.enabled = waitStartEnabled;
					that.clearWait();
					that.dispatchEvent("waited");
				});
				if (that.stage) that.stage.update();
			}
		}
		this.wait = doWait;
		this.clearWait = function() {
			if (!waitTimeout) return that;
			if (waitModalEvent) that.stage.off("stagemousedown", waitModalEvent, null, mID);
			waitTimeout.clear();
			that.label.text = waitStartText;
			setOriginalObjects();
			that.label.colorOnly = latestColor = waitStartTextBackgroundColor;
			that.label.rollColor = waitStartRollTextBackgroundColor;
			setTimeout(function(){that.waiting = false;}, 55); // give time for first click to see not waiting yet
			willBeWaiting = false;
			if (that.stage) that.stage.update();
			return that;
		};
		this.removeWait = function() {
			that.clearWait();
			wait = null;
			that.waitBacking = null;
			that.rollWaitBacking = null;
			that.off("mousedown", waitEvent, null, mID);
			return that;
		};

//~~~~~~~~~~~~~  INTERACTION

// visually swap button backing or icon
		// on clicks if wait or toggle and on mouseover and mouseout
		function changeObject(type, remove) {
			var i;
			if (type.indexOf("con")>=0) { // icon
				for (i=0; i<iconTypes.length; i++) {
					var ty = iconTypes[i];
					var ic = that[ty];
					that.removeChild(ic);
				}
				if (that[type]) that.addChildAt(that[type], 1);
			} else {
				if (!that[type] && !remove) return;
				for (i=0; i<backingTypes.length; i++) {
					var t = backingTypes[i];
					var b = that[t];
					that.removeChild(b);
				}
				
				if (that[type]) that.addChildAt(that[type], 0);
			}
		}

if (that.pressed) that.label.colorOnly = downColor;
			else if (that.label.showRollColor) that.label.showRollColor();
			else that.label.colorOnly = latestColor;
			if (that.stage) that.stage.update();
		}
		
		// for mobile with no mouseover 
		// and to stop rollover if pressed off button and rollover ZIM Cat 04
		// adjusted ZIM 01 with M - as down stage messed things up
		var onCheck = false;
		this.on("mousedown", function () {
			that.pressed = onCheck = true;			
			buttonOn();			
			if (that.rolled) return;
		}, null, null, null, null, mID);
		
		this.on("pressup", function (e) {			
			that.pressed = onCheck = pressCheck = false;

if (reallyOn) buttonOn(); // will recall the roll ZIM01
			else if (that.rollPersist) removeRoll();
			
			if (e.nativeEvent && (e.nativeEvent.type == "touchend" || e.nativeEvent == "touchcancel")) { // touch screen
				buttonOff();
			}
		}, null, null, null, null, mID);
		
		this.on("pressmove", function () {
			var frame = that.stage ? that.stage.frame : WW.zdf;
			var hitting = that.hitTestPoint(frame.mouseX, frame.mouseY);
			if (onCheck && !hitting) {
				buttonOff();
				onCheck = false;
			} else if (!onCheck && hitting) {
				buttonOn();
				onCheck = true;
			}
		}, null, null, null, null, mID);

this.on("mouseout", buttonOff, null, null, null, null, mID); // thanks Maxime Riehl
		function buttonOff() {
			reallyOn = false;
			if (that.rollPersist) {
				if (!pressCheck) removeRoll();
			} else {
				removeRoll();
			}
		}
		
		function removeRoll() {			
			that.rolled = false;
			if (willBeWaiting || that.waiting) {
				if (zot(backing) && that.backing && zot(that.waitBacking)) that.backing.color = zot(waitBackgroundColor)?backgroundColor:waitBackgroundColor;
				if (that.waitBacking) changeObject("waitBacking");
				else if (that.backing) changeObject("backing");
				if (that.waitIcon) changeObject("waitIcon");
				else if (that.icon) changeObject("icon");
				else changeObject("icon", null);
			} else if (that.toggled && toggleOkay) {
				if (zot(backing) && that.backing && zot(that.toggleBacking)) that.backing.color = toggleBackgroundColor;
				if (that.toggleBacking) changeObject("toggleBacking");
				else if (that.backing) changeObject("backing");
				if (that.toggleIcon) changeObject("toggleIcon");
				else if (that.icon) changeObject("icon");
				else changeObject("icon", null);
			} else {
				if (zot(backing) && that.backing)  that.backing.color = backgroundColor;
				else if (backing && !zot(backing.mask) && that.backing) that.backing.mask.color = backgroundColor;
				if (that.backing) changeObject("backing");
				if (that.icon) changeObject("icon");
				else changeObject("icon", null);
			}

if (that.border) that.border.borderColor = borderColor;

that.label.colorOnly = latestColor;
			if (that.label.showRollColor) that.label.showRollColor(false);
			if (that.stage) that.stage.update();
		}
		that.removeRoll = removeRoll;
		if (that.rollBacking) that.rollBacking.removeFrom(); // just in case

Object.defineProperty(that, 'text', {
			get: function() {
				var t = (label.text == " ") ? "" : label.text;
				return t;
			},
			set: function(value) {
				label.text = value;
				if (originalText) originalText = value;
				label.center(this);
				label.y+=1;
				zim.pos(label, (align=="left"||align=="right")?indentH:null, (valign=="top"||valign=="bottom")?indentV:null, align=="right", valign=="bottom");
			}
		});

Object.defineProperty(that, 'color', {
			get: function() {
				return color;
			},
			set: function(value) {
				color = value;
				if (originalColor) originalColor = color;
				if (that.label && !zot(that.label.color)) {
					that.label.color = latestColor = color;
				}
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'rollColor', {
			get: function() {
				return rollColor;
			},
			set: function(value) {
				rollColor = value;
				if (originalRollColor) originalRollColor = rollColor;
				if (that.label) {
					that.label.rollColor = rollColor;
				}
			}
		});
		
		Object.defineProperty(that, 'downColor', {
			get: function() {
				return downColor;
			},
			set: function(value) {
				downColor = value;
				if (originalDownColor) originalDownColor = downColor;
				if (that.label) {
					that.label.colorOnly = downColor;
				}
			}
		});

Object.defineProperty(that, 'backgroundColor', {
			get: function() {
				return backgroundColor;
			},
			set: function(value) {
				backgroundColor = value;
				if (that.backing.color) {
					that.backing.color = backgroundColor;
				} else if (that.backing.mask) {
					that.backing.mask.color = backgroundColor;
				}
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'toggleBackgroundColor', {
			get: function() {
				return toggleBackgroundColor;
			},
			set: function(value) {
				toggleBackgroundColor = value;
				if (that.toggleBacking && that.toggleBacking.color) {
					that.toggleBacking.color = toggleBackgroundColor;
				} else if (that.toggleBacking && that.toggleBacking.mask) {
					that.toggleBacking.mask.color = toggleBackgroundColor;
				}
			}
		});

Object.defineProperty(that, 'rollToggleBackgroundColor', {
			get: function() {
				return rollToggleBackgroundColor;
			},
			set: function(value) {
				rollToggleBackgroundColor = value;
				if (that.rollToggleBacking && that.rollToggleBacking.color) {
					that.rollToggleBacking.color = rollToggleBackgroundColor;
				} else if (that.rollToggleBacking && that.rollToggleBacking.mask) {
					that.rollToggleBacking.mask.color = rollToggleBackgroundColor;
				}
			}
		});
		
		Object.defineProperty(that, 'downBackgroundColor', {
			get: function() {
				return downBackgroundColor;
			},
			set: function(value) {
				downBackgroundColor = value;
				if (that.downBacking && that.downBacking.color) {
					that.downBacking.color = downBackgroundColor;
				} else if (that.downBacking && that.downBacking.mask) {
					that.downBacking.mask.color = downBackgroundColor;
				}
			}
		});

Object.defineProperty(that, 'borderWidth', {
			get: function() {
				return borderWidth;
			},
			set: function(value) {
				borderWidth = value;
				that.backing.borderWidth = value;				
			}
		});

Object.defineProperty(that, 'rollBorderColor', {
			get: function() {
				return rollBorderColor;
			},
			set: function(value) {
				rollBorderColor = value;
				if (that.rolled) {
					if (that.backing && that.backing.borderColor) that.backing.borderColor = value;
					if (that.border) that.border.borderColor = value;
				}
			}
		});

this._enabled = true;
		this.startMouseChildren = this.mouseChildren;
		Object.defineProperty(that, 'enabled', {
			get: function() {
				return that._enabled;
			},
			set: function(value) {
				if (that._enabled) that.startMouseChildren = that.mouseChildren;
				if (value) {
					zenable(that, value);
					that.mouseChildren = that.startMouseChildren;
				} else {
					removeRoll();
					zenable(that, value);
				}
				var c = label.color;
				label.color = latestColor = c;
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

// setBacking or leave backing parameter blank to remove this type of backing
		this.setBacking = function(type, newBacking) {
			setObject(type, newBacking);
			return that;
		};
		// setIcon or leave icon parameter blank to remove this type of icon
		this.setIcon = function(type, newIcon) {
			setObject(type, newIcon);
			return that;
		};
		function setObject(type, newObject) {
			if (zot(type)) return that;
			if (that.contains(that[type])) {
				that.removeChild(that[type]);
				if (newObject) that.addChildAt(newObject, type.indexOf("con")>=0?that.numChildren-1:0);
				if (that.stage) that.stage.update();
			}
			if (newObject) {
				if (zot(backing) && type == "backing") backing = newObject;
				if (newObject.type == "Pattern") newObject = setPattern(type, newObject);
				that[type] = newObject;
				that[type].x = width/2;
				that[type].y = height/2;
			} else {
				that[type] = null;
			}
			setOriginalObjects();		
			return that;
		}
		if (style!==false) zim.styleTransforms(this, DS);

this.clone = function(exact) {
			var but = new zim.Button(
				width, height, (oLabel&&oLabel.type=="Label")?label.clone():oLabel,
				(exact||!zim.isPick(oa[0]))?backgroundColor :oa[0],
				(exact||!zim.isPick(oa[1]))?rollBackgroundColor :oa[1],
				(exact||!zim.isPick(oa[2]))?downBackgroundColor :oa[2],
				(exact||!zim.isPick(oa[3]))?color :oa[3],
				(exact||!zim.isPick(oa[4]))?rollColor :oa[4],
				(exact||!zim.isPick(oa[5]))?downColor :oa[5],
				originalBorderColor, originalBorderWidth, rollBorderColor, downBorderColor, 
				!zot(backing)?that.backing.clone():null,
				!zot(rollBacking)?that.rollBacking.clone():null,
				!zot(downBacking)?that.downBacking.clone():null,
				!zot(icon)?icon.clone():null, 
				!zot(rollIcon)?rollIcon.clone():null, 
				!zot(downIcon)?downIcon.clone():null,
				corner, dashed, shadowColor, shadowBlur, gradient, gloss, align, valign, indent, indentH, indentV, hitPadding, autoPadding, autoPaddingH, autoPaddingV, rollPersist, 			
				toggle, 
				toggleBackgroundColor, rollToggleBackgroundColor, downToggleBackgroundColor, 
				toggleColor, rollToggleColor, downToggleColor,
				!zot(toggleBacking)?toggleBacking.clone():null,
				!zot(rollToggleBacking)?rollToggleBacking.clone():null,
				!zot(downToggleBacking)?downToggleBacking.clone():null,
				!zot(toggleIcon)?toggleIcon.clone():null,
				!zot(rollToggleIcon)?rollToggleIcon.clone():null,
				!zot(downToggleIcon)?downToggleIcon.clone():null,
				toggleEvent,
				wait, waitTime, 
				waitBackgroundColor, rollWaitBackgroundColor, downWaitBackgroundColor,
				waitColor, rollWaitColor, downWaitColor,
				!zot(waitBacking)?waitBacking.clone():null,
				!zot(rollWaitBacking)?rollWaitBacking.clone():null,
				!zot(downWaitBacking)?downWaitBacking.clone():null,
				!zot(waitIcon)?waitIcon.clone():null,
				!zot(rollWaitIcon)?rollWaitIcon.clone():null,
				!zot(downWaitIcon)?downWaitIcon.clone():null,
				waitModal, waitEnabled,
				style,
				this.group,
				inherit // added in ZIM Cat 03 - not sure if it was missing on purpose
			);
			return that.cloneProps(but);
		};
		
		this.doDispose = function(a,b,disposing) {
			if (that.icon) that.icon.dispose();			
			if (that.rollIcon) that.rollIcon.dispose();
			if (that.downIcon) that.downIcon.dispose();
			if (that.waitIcon) that.waitIcon.dispose();
			if (that.rollWaitIcon) that.rollWaitIcon.dispose();
			if (that.downWaitIcon) that.downWaitIcon.dispose();
			if (that.toggleIcon) that.toggleIcon.dispose();
			if (that.rollToggleIcon) that.rollToggleIcon.dispose();
			if (that.downToggleIcon) that.downToggleIcon.dispose();
			that.icon = that.rollIcon = that.downIcon = that.waitIcon = that.rollWaitIcon = that.downWaitIcon = that.toggleIcon = that.rollToggleIcon = that.downToggleIcon = null;
			if (!disposing) this.zimContainer_dispose(true);
			return true;
		}
	};
	zim.extend(zim.Button, zim.Container, ["clone", "dispose"], "zimContainer", false);
	zim.Button.prototype.dispose = function(disposing) {return this.doDispose(null,null,disposing);};

zim.CheckBox = function(size, label, startChecked, color, backgroundColor, borderColor, borderWidth, corner, margin, indicatorType, indicatorColor, tap, rtl, style, group, inherit) {
		var sig = "size, label, startChecked, color, backgroundColor, borderColor, borderWidth, corner, margin, indicatorType, indicatorColor, tap, rtl, style, group, inherit";
		var duo; if (duo = zob(zim.CheckBox, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "CheckBox";

this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(size)) size = DS.size!=null?DS.size:60;		
		if (zot(label)) label = DS.label!=null?DS.label:null;		
		if (zot(startChecked)) startChecked = DS.startChecked!=null?DS.startChecked:false;		
		if (zot(color)) color = DS.color!=null?DS.color:zim.darker;
		if (zot(backgroundColor)) backgroundColor = DS.backgroundColor!=null?DS.backgroundColor:zim.white.toAlpha(.8);
		if (zot(borderColor)) borderColor = DS.borderColor!=null?DS.borderColor:zim.darker;
		if (zot(borderWidth)) borderWidth = DS.borderWidth!=null?DS.borderWidth:size/10;
		if (borderColor < 0 || borderWidth < 0) borderColor = borderWidth = null;
		else if (borderColor!=null && borderWidth==null) borderWidth = size/10;
		if (zot(corner)) corner=DS.corner!=null?DS.corner:0;	
		if (zot(margin)) margin = DS.margin!=null?DS.margin:size/5;
		if (indicatorType != "box" && indicatorType != "square" && indicatorType != "x") indicatorType = DS.indicatorType!=null?DS.indicatorType:"check";
		if (zot(indicatorColor)) indicatorColor = DS.indicatorColor!=null?DS.indicatorColor:borderWidth>0?borderColor:zim.black;
		this.setBounds(-margin, -margin, size+margin*2, size+margin*2);
		if (zot(tap)) tap = DS.tap!=null?DS.tap:false;
		if (zot(rtl)) rtl = DS.rtl!=null?DS.rtl:WW.DIR=="rtl";

var fullWidth = size;

if (label) {
			label.center(that);
			this.label = label;
			if (rtl) {
				label.x = -margin;
				this.setBounds(-label.width-margin*2, -margin, size+margin*3+label.getBounds().width, Math.max(size+margin*2, label.getBounds().height));
				fullWidth = size + label.width + margin;
				this.regX = size;				
			} else {
				label.x = that.getBounds().width;
				this.setBounds(-margin, -margin, size+margin*4+label.getBounds().width, Math.max(size+margin*2, label.getBounds().height));
				fullWidth = label.x + label.width;
			}			
		}
		
		var backing = new zim.Shape({style:false});
		var g = backing.graphics;
		g.f("rgba(0,0,0,.01)").r(
			this.getBounds().x,
			this.getBounds().y,
			fullWidth+(margin*2),
			this.getBounds().height
		);
		this.hitArea = backing;
		// hitArea will stop rollovers on labels but oh well

var cW = 95;
		check.setBounds(-cW/2, -cW/2, cW, cW);
		var scale = size/(cW+66);

check.scaleX = check.scaleY = scale;
		check.alpha = .9;
		check.x = size/2;
		check.y = size/2;

if (myChecked) this.addChild(check);

if (tap) {
			this.tap(toggleCheck);
		} else {
			this.on((!zns?WW.ACTIONEVENT=="mousedown":zim.ACTIONEVENT=="mousedown")?"mousedown":"click", toggleCheck, null, null, null, null, mID);
		}

Object.defineProperty(that, 'checked', {
			get: function() {
				return myChecked;
			},
			set: function(value) {
				that.setChecked(value);
			}
		});

this.toggle = function(type) {
			if (zot(type)) type = !myChecked;
			that.setChecked(type);
		};

Object.defineProperty(that, 'toggled', {
			get: function() {
				return myChecked;
			},
			set: function(value) {
				that.setChecked(value);
			}
		});

Object.defineProperty(that, 'text', {
			get: function() {
				if (label) return label.text;
				return null;
			},
			set: function(value) {
				if (label) {
					label.text = value;
					if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
				}
			}
		});

Object.defineProperty(check, 'indicatorColor', {
			get: function() {
				return indicatorColor;
			},
			set: function(value) {
				if (myChecked) {that.removeChild(check);}
				check = new createjs.Shape();
				g2 = check.graphics;
				indicatorColor = value;
				g2.f(indicatorColor).p("AnQAdICBiaIEEDZIF8nfICfB4In/KPg");
				check.scaleX = check.scaleY = scale;
				check.alpha = .9;
				check.x = size/2;
				check.y = size/2;
				if (myChecked) that.addChild(check);
				if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			}
		});

Object.defineProperty(that, 'indicator', {
			get: function() {
				return check;
			},
			set: function() {
				zogy("ZIM CheckBox - check is read only");
			}
		});

this._enabled = true;
		Object.defineProperty(that, 'enabled', {
			get: function() {
				return that._enabled;
			},
			set: function(value) {
				zenable(that, value);
			}
		});

function toggleCheck() {
			myChecked = !myChecked;
			that.setChecked(myChecked);
			that.dispatchEvent("change");
		}

this.setChecked = function(value) {
			if (zot(value)) value = true;
			myChecked = value;
			if (myChecked) {
				that.addChild(check);
			} else {
				that.removeChild(check);
			}
			if ((!zim.OPTIMIZE&&(zns||!WW.OPTIMIZE)) && that.stage) that.stage.update();
			return that;
		};

if (style!==false) zim.styleTransforms(this, DS);
		this.clone = function(exact) {
			return that.cloneProps(new zim.CheckBox(size, (exact||!zim.isPick(oa[0]))?label?label.clone():null:oa[0], (exact||!zim.isPick(oa[1]))?startChecked:oa[1], color, backgroundColor, borderColor, borderWidth, corner, margin, indicatorType, indicatorColor, tap, rtl, style, this.group, inherit));
		};
	};
	zim.extend(zim.CheckBox, zim.Container, "clone", "zimContainer", false);

this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

var timeType = getTIME(speed);

if (zot(speed)) speed=DS.speed!=null?DS.speed:timeType=="s"?.6:600; // ms cycle time
		if (zot(foregroundColor)) foregroundColor=DS.foregroundColor!=null?DS.foregroundColor:zim.white;
		if (zot(backgroundColor)) backgroundColor=DS.backgroundColor!=null?DS.backgroundColor:"orange";
		if (zot(corner)) corner=DS.corner!=null?DS.corner:16;
		if (zot(shadowColor)) shadowColor=DS.shadowColor!=null?DS.shadowColor:"rgba(0,0,0,.3)";
		if (zot(shadowBlur)) shadowBlur=DS.shadowBlur!=null?DS.shadowBlur:14;
		if (zot(fadeTime)) fadeTime=DS.fadeTime!=null?DS.fadeTime:0;

var height = 40;
		var numDots = 3;
		var r = height*.6/2;
		var s = (height-r*2)/2;
		var width = numDots*(r*2+s)+s;

this.setBounds(-width/2,-height/2, width, height);

var that = this;
		var stage;

var circles = new zim.Container({style:false});
		this.addChild(circles);

this.hide = function() {
			if (fadeTime > 0) {
				that.animate({obj:{alpha:0}, time:fadeTime, call:end});
			} else {
				end();
			}
			function end() {
				if (that.parent) that.parent.removeChild(that);
				stage = that.stage;
				if (stage) stage.update();
				if (that.zimAccessibility) {
					var a = that.zimAccessibility;
					a.resize(that);
					if (accessibilityClicker) accessibilityClicker.focus();
					else that.zimTabTag.nextSibling.focus();
					setTimeout(function() {a.talk("Waiter has finished.");}, 50);
				}
			}
			that.toggled = false;
			return that;
		};
		var accessibilityClicker;
		var timeouts = [];
		this.show = function() {
			var mess = "zim display - Waiter(): Please pass in a reference to a container with bounds set as first parameter to Waiter";
			if (zot(container)) {
				if (WW.zdf) {
					container = WW.zdf.stage;
				} else {
					zogy(mess);
					return;
				}
			} else if (!container.getBounds) {
				zogy(mess);
				return;
			} else if (zot(container.stage)) {
				zogy("zim display - Waiter(): The container must have a stage property");
				return;
			}
			var dot; var counter=0;
			var s = speed*(timeType=="s"?1000:1);
			for (var i=0; i<circles.numChildren; i++) {
				if (circles) {
					timeouts.push(setTimeout(function() {
						dot = circles.getChildAt(counter);
						createjs.Tween.get(dot,{loop:true})
							.to({alpha:1}, s/numDots/2)
							.wait(s/numDots)
							.to({alpha:0}, s/numDots)
							.wait(s-s/numDots-s/numDots/2);
						counter++;
					}, i*s/numDots));
				}
			}
			that.ticker = createjs.Ticker.on("tick", function() {container.stage.update();}, null, null, null, null, mID);

this.dispose = function(a,b,disposing) {
			if (that.ticker) createjs.Ticker.off("tick", that.ticker, null, mID);
			createjs.Tween.removeTweens(that);
			that.removeFrom();
			for (var i=0; i<circles.numChildren; i++) {
				var circle = circles.getChildAt(i);
				clearInterval(timeouts[i]);
				createjs.Tween.removeTweens(circle);
			}
			if (!disposing) this.zimContainer_dispose(true);
			return true;
		};
	};
	zim.extend(zim.Waiter, zim.Container, ["clone", "dispose"], "zimContainer", false);

zim.Tile = function(obj, cols, rows, spacingH, spacingV, unique, width, height, squeezeH, squeezeV, colSize, rowSize, align, valign, count, mirrorH, mirrorV, snapToPixel, clone, events, exact, scaleToH, scaleToV, scaleToType, backgroundColor, backgroundPadding, backgroundPaddingH, backgroundPaddingV, backing, backdropColor, backdropPadding, backdropPaddingH, backdropPaddingV, mat, style, group, inherit) {
		var sig = "obj, cols, rows, spacingH, spacingV, unique, width, height, squeezeH, squeezeV, colSize, rowSize, align, valign, count, mirrorH, mirrorV, snapToPixel, clone, events, exact, scaleToH, scaleToV, scaleToType, backgroundColor, backgroundPadding, backgroundPaddingH, backgroundPaddingV, backing, backdropColor, backdropPadding, backdropPaddingH, backdropPaddingV, mat, style, group, inherit";
		var duo; if (duo = zob(zim.Tile, arguments, sig, this)) return duo;
		this.zimContainer_constructor(null,null,null,null,false);
		this.type = "Tile";
	
		this.group = group;
		var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
		var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(obj)) obj = DS.obj!=null?DS.obj:new zim.Circle();
		if (zot(cols)) cols = DS.cols!=null?DS.cols:1121;
		if (zot(rows)) rows = DS.rows!=null?DS.rows:1121;
		var defaultFlag;
		if (cols==1121 && rows==1121) cols = rows = defaultFlag = 3;
		else if (cols==1121) cols = 1;
		else if (rows==1121) rows = 1;
		if (zot(unique)) unique = DS.unique!=null?DS.unique:false;
		if (zot(width)) width = DS.width!=null?DS.width:null;
		if (zot(height)) height = DS.height!=null?DS.height:null;
		if (zot(colSize)) colSize = DS.colSize!=null?DS.colSize:null;
		if (zot(rowSize)) rowSize = DS.rowSize!=null?DS.rowSize:null;
		if (!zot(width)) colSize = null; // width and height override sizes
		if (!zot(height)) rowSize = null;

if (zot(spacingH)) spacingH = DS.spacingH!=null?DS.spacingH:null;
		if (zot(spacingV)) spacingV = DS.spacingV!=null?DS.spacingV:null;

if (zot(spacingH) || !zot(colSize) || !zot(width)) spacingH = 0; // sizes override spacing
		if (zot(spacingV) || !zot(rowSize) || !zot(height)) spacingV = 0;	
		if (zot(squeezeH)) squeezeH = DS.squeezeH!=null?DS.squeezeH:false;
		if (zot(squeezeV)) squeezeV = DS.squeezeV!=null?DS.squeezeV:false;
		if (zot(align)) align = DS.align!=null?DS.align:"left";
		if (zot(valign)) valign = DS.valign!=null?DS.valign:"top";
		if (zot(count)) count = DS.count!=null?DS.count:(unique&&Array.isArray(obj))?obj.length:null;
		if (count === 0) {count = null; if (zon) {zogy("ZIM Tile() - count parameter of 0 is ignored - see docs");}}

// Added ZIM 019 Patch

var colsO = cols;
		var rowsO = rows;

// Added ZIM 018

var spacingHList = [];
		var spacingVList = [];
		var spacingHTotal = 0;
		var spacingVTotal = 0;
		var mCols = (count && count<cols)?count-1:cols-1;
		for (i=0; i<mCols; i++) {
			var s = zik(spacingH);
			spacingHList.push(s);
			spacingHTotal += s;
		}
		var mRows = (count && Math.ceil(count/cols)<rows)?Math.ceil(count/cols)-1:rows-1;
		for (i=0; i<mRows; i++) {
			var s = zik(spacingV);
			spacingVList.push(s);
			spacingVTotal += s;
		}

var spacingHOList = zim.copy(spacingHList);
		var spacingVOList = zim.copy(spacingVList);;
		var spacingHOTotal = spacingHTotal;
		var spacingVOTotal = spacingVTotal;
		var spacingHAve = cols-1>0?spacingHTotal/(cols-1):0
		var spacingVAve = rows-1>0?spacingVTotal/(rows-1):0

// end add 018

if (zot(mirrorH)) mirrorH = DS.mirrorH!=null?DS.mirrorH:false;
		if (zot(mirrorV)) mirrorV = DS.mirrorV!=null?DS.mirrorV:false;
		if (zot(snapToPixel)) snapToPixel = DS.snapToPixel!=null?DS.snapToPixel:true;
		if (snapToPixel) {
			if (obj && obj.stage) obj.stage.snapToPixelEnabled = true;
			else if (typeof(elem) !== 'undefined' && WW.zdf) WW.zdf.stage.snapToPixelEnabled = true;
		}
		if (zot(clone)) clone = DS.clone!=null?DS.clone:unique?false:null;
		if (clone==null) clone = typeof(obj) === 'function' && obj.type != "series"?false:true; 
		if (zot(events)) events = DS.events!=null?DS.events:true;

if (zot(scaleToH)) scaleToH = DS.scaleToH!=null?DS.scaleToH:null;
		if (zot(scaleToV)) scaleToV = DS.scaleToV!=null?DS.scaleToV:null;
		if (zot(scaleToType)) scaleToType = DS.scaleToType!=null?DS.scaleToType:null;
		if (zot(backgroundColor)) backgroundColor = DS.backgroundColor!=null?DS.backgroundColor:null;
        if (zot(backgroundPadding)) backgroundPadding = DS.backgroundPadding!=null?DS.backgroundPadding:0;
		if (zot(backgroundPaddingH)) backgroundPaddingH = DS.backgroundPaddingH!=null?DS.backgroundPaddingH:!zot(backgroundColor)?backgroundPadding:0;
		if (zot(backgroundPaddingV)) backgroundPaddingV = DS.backgroundPaddingV!=null?DS.backgroundPaddingV:!zot(backgroundColor)?backgroundPadding:0;
		if (zot(backing)) backing = DS.backing!=null?DS.backing:null;
		if (zot(backdropColor)) backdropColor = DS.backdropColor!=null?DS.backdropColor:null;		
		if (zot(backdropPadding)) backdropPadding = DS.backdropPadding!=null?DS.backdropPadding:0;
		if (zot(backdropPaddingH)) backdropPaddingH = DS.backdropPaddingH!=null?DS.backdropPaddingH:!zot(backdropColor)?backdropPadding:0;
		if (zot(backdropPaddingV)) backdropPaddingV = DS.backdropPaddingV!=null?DS.backdropPaddingV:!zot(backdropColor)?backdropPadding:0;
		if (backdropPaddingV || backdropPaddingH) backdropPadding = true; // numbers only used from H and V values
		if (zot(exact)) exact = DS.exact!=null?DS.exact:null;
		if (zot(mat)) mat = DS.mat!=null?DS.mat:false;

var that = this;
		that.cols = cols = Math.round(cols);
		that.rows = rows = Math.round(rows);
		that.squeezeH = squeezeH;
		that.squeezeV = squeezeV;
		var VEEAlign = zim.isPick(align)
		var VEEVAlign = zim.isPick(valign);
	
		// these two are used only for not ZIM VEE - as VEE with Squeeze is not supported
		that.align = VEEAlign?"left":align;
		that.valign = VEEVAlign?"top":valign;
		that.mirrorH = mirrorH;
		that.mirrorV = mirrorV;

that.spacingH = spacingHList[0];
		that.spacingV = spacingVList[0];
		if (zot(that.spacingH)) that.spacingH = spacingH;
		if (zot(that.spacingV)) that.spacingV = spacingV;

// ~~~~~~~~~~~~~~~~~~~  GET ARRAY OF ITEMS  ~~~~~~~~~~~~~~~
		// this list could be edited later and passed back into remake()
		// so need to separate this part from the rest
		// also, need to record what was made with zik so resize does not change items
		that.items = [];
		var tile;
		var currentCount = 0;
		var ACCheck = false;
		outer:
		for (var j=0; j<rows; j++) {
			for (var i=0; i<cols; i++) {
				currentCount++;
				if (!zot(count) && currentCount > count) break outer;
				tile = unique?obj[currentCount-1]:zim.Pick.choose(obj);
				if (typeof tile == "string") tile = WW.asset(tile).reg(CENTER).clone();
				if (zot(tile)) {
					tile = new zim.Container(0,0,0,0);
				}
				// if (clone && !(j==0 && i==0)) tile = tile.clone();
				if (clone) {
					if ((j!=0 || i!=0)) tile = tile.clone(exact);
				}
				if (events) {
					tile.on("change", function (e) {
						var evt = new createjs.Event("change");
						evt.item = e.currentTarget;
						that.dispatchEvent(evt);
					}, null, null, null, null, mID);
				}
				that.items.push(tile);
				if (tile.type == "AC") ACCheck = true;
				tile.tileNum = currentCount-1;
				tile.tileCol = i;
				tile.tileRow = j;
			}			
		}
		if (ACCheck && zon) zogy("ZIM Tile - assets must have dimensions for Tile");

// ~~~~~~~~~~~~~~~~~~~  ORIGINAL CALCULATIONS ~~~~~~~~~~~~~~~
		// collect col and row tile total sizes
		// with resize, we need to do this separately so zik is only run once

// remember any set widths and heights in case
		// zik is used for colSize and rowSize
		var widthHeights;
		var widthO;
		var heightO;

function makeTile() {

that.removeAllChildren();

if (!that.items || !that.items.length) that.items = [];
			count = that.items.length;
			var currentCount = 0;
			var tile;
			var i; var j=0; var k=0;
			var h; var w;
			for (i=0; i<count; i++) {
				j=Math.floor(i/that.cols);
				k=i%that.cols;
				if (zot(objects[j])) objects[j] = [];
				if (zot(that.items[i])) that.items[i] = new zim.Container(0,0,0,0);
				objects[j][k] = that.items[i];
			}
			that.rows = Math.max(1, objects.length);
			that.cols = Math.max(1, !zot(objects[0])?objects[0].length:0);

outer2:
			for (j=0; j<that.rows; j++) {
				scalesX.push([]);
				scalesY.push([]);
				widthHeights.push([]);
				if (rowSize&&zot(height)) h = zim.Pick.choose(rowSize);
				for (i=0; i<that.cols; i++) {
					currentCount++;
					if (!zot(count) && currentCount > count) break outer2;
					tile = objects[j][i];
					
					tile.snapToPixel = snapToPixel;
					that.addChild(tile);

scalesX[j].push(tile.scaleX);
					scalesY[j].push(tile.scaleY);
					if (colSize&&zot(width)) w = zim.Pick.choose(colSize);
					
					if (j==0) finalAlign.push(zim.Pick.choose(align));

// needs projected width and height on the tile 
					var tB = tile.boundsToGlobal(null, null, null, that);		
					if (!colSize||!zot(width)) w = Math.abs(tB.width);
					if (!rowSize||!zot(height)) h = Math.abs(tB.height);
					// if (!colSize||!zot(width)) w = Math.abs(tile.width);
					// if (!rowSize||!zot(height)) h = Math.abs(tile.height);
					tile.fW = w;
					tile.fH = h;

// 019 fix for aligning later
					tile.fW2 = Math.abs(tB.width);
					tile.fH2 = Math.abs(tB.height);

widthHeights[j][i] = [w,h];
					if (zot(widthMax[i])) widthMax[i] = 0;
					if (zot(heightMax[j])) heightMax[j] = 0;
					if (w > widthMax[i]) widthMax[i] = w;
					if (h > heightMax[j]) heightMax[j] = h;
					if (zot(widthTotals[j])) widthTotals[j] = 0;
					if (zot(heightTotals[i])) heightTotals[i] = 0;
					widthTotals[j] += w;
					heightTotals[i] += h;
					if (widthTotals[j] > widthTotalMax) widthTotalMax = widthTotals[j];
					if (heightTotals[i] > heightTotalMax) heightTotalMax = heightTotals[i];
					if (zot(rowCounts[i])) rowCounts[i] = 0;
					rowCounts[i]++;
				}
			}
			var val;
			if (that.squeezeH === false) {
				for (i=0; i<widthMax.length; i++) {
					val = widthMax[i];
					widthUncompressedMax+=val;
				}
			}
			if (that.squeezeV === false) {
				for (i=0; i<heightMax.length; i++) {
					val = heightMax[i];
					heightUncompressedMax+=val;
				}
			}
			widthO = widthUncompressedMax;
			heightO = heightUncompressedMax;
		}
		makeTile();

var overallWidth;
		var overallHeight;
		var rowTotals;
		var rowSpacings;
		var widthScaling = 1;
		var heightScaling = 1;	
						
		function resize(width, height) {
			
			if (that.normalized) that.resetOriginalReg();

if (!zot(backdropColor) && backdropPadding) {
				width -= Math.max(backdropPaddingH*2, 0);
				height -= Math.max(backdropPaddingV*2, 0);
			}
			
			// ~~~~~~~~~~~~~~~~~~~  GET WIDTHS ~~~~~~~~~~~~~~~

if (width <= 0) width = null;
			if (height <= 0) height = null;

if (!zot(width)&&that.squeezeH=="full") {
				overallWidth = width;
			} else if (!zot(width)) {
				if (scaleToH) overallWidth = width;
				else overallWidth = Math.max(widthTotalMax+spacingHTotal, width);
			} else {
				if (widthUncompressedMax > 0) overallWidth = widthUncompressedMax+spacingHTotal;
				else overallWidth = widthTotalMax+spacingHTotal;
			}

if (!zot(height)&&that.squeezeV=="full") {
				overallHeight = height;				
			} else if (!zot(height)) {						
				if (scaleToV) overallHeight = height;
				else overallHeight = Math.max(heightTotalMax+spacingVTotal, height);
			} else {
				if (heightUncompressedMax > 0) overallHeight = heightUncompressedMax+spacingVTotal;
				else overallHeight = heightTotalMax+spacingVTotal;
			}
			
			that.setBounds(0,0,overallWidth,overallHeight);
			widthScaling = (overallWidth-spacingHOTotal)/(widthO);
			heightScaling = (overallHeight-spacingVOTotal)/(heightO);

// ~~~~~~~~~~~~~~~~~~~  PLACEMENTS ~~~~~~~~~~~~~~~

var rowObjects;
			var colTotal; // keep track of current x positions
			// loop order means we need to keep array data for y
			rowTotals = []; // keep track of current y positions
			rowSpacings = [];
			var rowTops = [];
			
			for (j=0; j<objects.length; j++) {
				rowObjects = objects[j];
				colTotal = 0;
				for (i=0; i<rowObjects.length; i++) {
					tile = rowObjects[i];
					var left;
					var spreadXspacing;
					if (j==0) {
						rowTotals[i] = 0;

// ~~~~~~~~~~~~~~~~~~~  VERTICAL ALIGN ~~~~~~~~~~~~~~~

if (!zot(height)) {
							if (that.squeezeV=="full") {
								rowSpacings[i] = rowCounts[i]>1?((height - heightTotals[i]) / (rowCounts[i]-1)):0;
							} else if (that.squeezeV) {
								rowSpacings[i] = rowCounts[i]>1?Math.max(spacingVAve, (height - heightTotals[i]) / (rowCounts[i]-1)):0;
							} else {
								rowSpacings[i] = rowCounts[i]>1?Math.max(spacingVAve, (overallHeight - heightTotals[i]) / (rowCounts[i]-1)):0;
							}
						}
						if (that.squeezeV) {
							// check for center or bottom valign of whole row
							if (that.valign=="center" || that.valign=="middle") {
								rowTops[i] = (overallHeight-(heightTotals[i]+(rowCounts[i]-1)*(!zot(height)?rowSpacings[i]:spacingVAve)))/2;
							} else if (that.valign=="bottom") {
								rowTops[i] = overallHeight-(heightTotals[i]+(rowCounts[i]-1)*(!zot(height)?rowSpacings[i]:spacingVAve));
							} else {
								rowTops[i] = 0;
							}
						} else {
							rowTops[i] = 0;
						}
					}

if (i==0) {

// ~~~~~~~~~~~~~~~~~~~  HORIZONTAL ALIGN ~~~~~~~~~~~~~~~

if (!zot(width)) {							
							if (that.squeezeH=="full") {
								spreadXspacing = rowObjects.length>1?((width - widthTotals[j]) / (rowObjects.length-1)):0;
							} else if (that.squeezeH) {
								spreadXspacing = rowObjects.length>1?Math.max(spacingHAve, (width - widthTotals[j]) / (rowObjects.length-1)):0;
							} else {
								spreadXspacing = rowObjects.length>1?Math.max(spacingHAve, (overallWidth - widthTotals[j]) / (rowObjects.length-1)):0;
							}
						}
						if (that.squeezeH) {							
							// check for center or right align of whole row
							if (that.align=="center" || that.align=="middle") {
								left = (overallWidth-(widthTotals[j]+(rowObjects.length-1)*(!zot(width)?spreadXspacing:spacingHAve)))/2;
							} else if (that.align=="right") {
								left = overallWidth-(widthTotals[j]+(rowObjects.length-1)*(!zot(width)?spreadXspacing:spacingHAve));
							} else {
								left = 0;
							}
						} else {
							left = 0;
						}

var w = widthHeights[j][i][0];
					var h = widthHeights[j][i][1];

if (that.mirrorH && i%2==1) {
						tile.scaleX = -scalesX[j][i];
						// tile.x = colTotal+w-b.x*2*tile.scaleX;
					} else {
						// tile.x = colTotal + (tile.regX-b.x);
					}
					tile.pos(colTotal, null);	
					
					if (!that.squeezeH && VEEAlign) {						
						if (zot(width) && (align=="center" || align=="middle")) {
							tile.x += (widthMax[i]-tile.fW2)/2;
						} else if (zot(width) && align=="right") {
							tile.x += widthMax[i]-tile.fW2;
						}
					} else if (!that.squeezeH) { // this allows for dynamic setting of align (for non-VEE, non squeezeH)				
						if (zot(width) && (that.align=="center" || that.align=="middle")) {							
							tile.x += (widthMax[i]-tile.fW2)/2;							
						} else if (zot(width) && that.align=="right") {
							tile.x += widthMax[i]-tile.fW2;
						}
					} else {
						if (zot(width) && (that.align=="center" || that.align=="middle")) {
							tile.x += (w-tile.fW2)/2;
						} else if (zot(width) && that.align=="right") {
							tile.x += w-tile.fW2;
						}
					}
					if (that.mirrorV && j%2==1) {
						tile.scaleY = -scalesY[j][i];
						// tile.y = rowTotals[i]+h-b.y*2;
					} else {
						// tile.y = rowTotals[i] + tile.regY-b.y;
					}
					tile.pos(null,rowTotals[i]);
					if (!that.squeezeV && VEEVAlign) {
						if (zot(height) && (finalVAlign=="center" || finalVAlign=="middle")) {
							tile.y += (heightMax[j]-tile.fH2)/2;
						} else if (zot(height) && finalVAlign=="bottom") {
							tile.y += heightMax[j]-tile.fH2;
						}
					} else if (!that.squeezeV) { // this allows for dynamic setting of valign (for non-VEE, non squeezeV)
						if (zot(height) && (that.valign=="center" || that.valign=="middle")) {
							tile.y += (heightMax[j]-tile.fH2)/2;
						} else if (zot(height) && that.valign=="bottom") {
							tile.y += heightMax[j]-tile.fH2;
						}
					} else {
						if (zot(height) && (that.valign=="center" || that.valign=="middle")) {
							tile.y += (h-tile.fH2)/2;
						} else if (zot(height) && that.valign=="bottom") {
							tile.y += h-tile.fH2;
						}
					}

if (that.squeezeH === true || !zot(width)) {
						colTotal += w+(!zot(width)?spreadXspacing:spacingHList[i]);
					} else {
						colTotal += widthMax[i]+(!zot(width)?spreadXspacing:spacingHList[i]);
					}
					
					tile.x += left;
					tile.y += rowTops[i];

if (that.squeezeV === true || !zot(height)) {
						rowTotals[i] += h+(!zot(height)?rowSpacings[i]:spacingVList[j]);
					} else {
						rowTotals[i] += heightMax[j]+(!zot(height)?rowSpacings[i]:spacingVList[j]);
					}
				}
			}
			
			if (that.normalized) that.normalize();

} // end resize

resize(width, height);

this.setProps = function(props) {
			zim.setProps(this.items, props);
			return this;
		}		
		
		this.itemUnderPoint = function(x, y, ignoreSpacing) {
			if (zot(ignoreSpacing)) ignoreSpacing = true;
			if (zot(x) || zot(y)) return;
			var point = that.globalToLocal(x, y);
			x = point.x;
			y = point.y;

var wT = 0;
			var co = zim.loop(widthMax, function (w, i) {
				wT+=w+spacingHList[i];
				if (!ignoreSpacing || ignoreSpacing == "vertical") {
					// test for in cracks
					if (x > wT-spacingHList[i]  && x < wT) return false;
				}
				if (x < wT-spacingHList[i]/2) return i;
			});
			if (co === false) return; // in crack
			if (co === true) co = cols-1;

return that.items2D[ro][co];
		};

this.remake = function(items, newSpacingH, newSpacingV, newCount, newCols, newRows) {

// a little complicated so we just remake the spacings if provided or items length has gotten bigger
			// if items length is different we create a new count - can override with newCount
			if (zot(items)) items = that.items
			if (zot(newCount) && items.length != that.items.length) count = that.cols*that.rows;
			if (
				!zot(newSpacingH) || 
				!zot(newSpacingV) || 
				items.length > that.items.length || 
				(!zot(newCols) && newCols != that.cols) || 
				(!zot(newRows) && newRows != that.rows)
			) {

if (!zot(newCols)) colsO = newCols;
				if (!zot(newRows)) rowsO = newRows;
				if (colsO <= 0) colsO = 1;
				if (rowsO <= 0) rowsO = 1;		
				
				if (!zot(newCount)) count = newCount
				else count = items.length;

if (count > colsO) that.cols = colsO;
				else that.cols = count;				
				that.rows = Math.ceil(count/that.cols);
				
				if (!zot(newSpacingH)) spacingH = newSpacingH;
				if (!zot(newSpacingV)) spacingV = newSpacingV;

spacingHList = [];
				spacingVList = [];
				spacingHTotal = 0;
				spacingVTotal = 0;
				mCols = (count && count<that.cols)?count-1:that.cols-1;
				for (i=0; i<mCols; i++) {
					var s = zik(spacingH);
					spacingHList.push(s);
					spacingHTotal += s;
				}
				mRows = (count && Math.ceil(count/that.cols)<that.rows)?Math.ceil(count/that.cols)-1:that.rows-1;
				for (i=0; i<mRows; i++) {
					var s = zik(spacingV);
					spacingVList.push(s);
					spacingVTotal += s;
				}
				spacingHOList = zim.copy(spacingHList);
				spacingVOList = zim.copy(spacingVList);;
				spacingHOTotal = spacingHTotal;
				spacingVOTotal = spacingVTotal;
				spacingHAve = that.cols-1>0?spacingHTotal/(that.cols-1):0
				spacingVAve = that.rows-1>0?spacingVTotal/(that.rows-1):0
			}

if (!zot(items)) that.items = items;
			makeTile();
			
			resize(width, height);
			makeAdditions(true);
			return that;
		};

that.setSpacing = function(h,v) {
			if (!zot(h)) {
				if (Array.isArray(h)) spacingHList = h;
				else {
					spacingHList = [];
					zim.loop(that.items2DCols.length, function() {
						spacingHList.push(h);
					});
				}
			} 
			if (!zot(v)) {
				if (Array.isArray(v)) spacingVList = v;
				else {
					spacingVList = [];
					zim.loop(that.items2D.length, function() {
						spacingVList.push(v);
					});
				}
			} 			
			that.remake();
			return that;
		}

this.resize = function(w, h) {
			if (zot(w)) w = width;
			if (zot(h)) h = height;
			width = w;
			height = h;
			resize(w, h);
			makeAdditions(true);
			return that;
		};

Object.defineProperty(this, "items2D", {
			get:function(){
				return get2D(that.items);
			},
			set:function() {
				if (zon) zogy("Tile() - items2D is read only");
			}
		});

Object.defineProperty(this, "items2DCols", {
			get:function(){
				return get2DCols(that.items);
			},
			set:function() {
				if (zon) zogy("Tile() - items2DCols is read only");
			}
		});

Object.defineProperty(this, "current", {
			get:function(){
				var items = [];
				// var tileWidth = (that.width - (that.cols-1)*that.spacingH) / that.cols;
				// var tileHeight = (that.height - (that.rows-1)*that.spacingV) / that.rows;

// loop through tile locations and compile array of objects under point
				zim.loop(that.items, function (t) {
					// get index of middle of bounding box of item
					var b = t.getBounds();
					if (b) {
						var x = t.x - t.regX + b.x + b.width / 2;
						var y = t.y - t.regY + b.y + b.height / 2;
						var index = that.hitTestGrid(that.width, that.height, that.cols, that.rows, x, y, null, null, spacingHList[0], spacingVList[0], true, "open");
						if (index != null) items[index[0]] = t;
					}
				});
				// // slow with hundreds
				// for (var j=0; j<that.rows; j++) {
				// 	for (var i=0; i<that.cols; i++) {
				// 		var x = i*(that.spacingH + tileWidth)+tileWidth/2;
				// 		var y = j*(that.spacingV + tileHeight)+tileHeight/2;
				// 		var item = that.getObjectUnderPoint(x, y, 1);
				// 		items.push(item);
				// 	}
				// }
				return items;
			},
			set:function() {
				if (zon) zogy("Tile() - current is read only");
			}
		});

Object.defineProperty(this, "current2D", {
			get:function(){
				return get2D(that.current);
			},
			set:function() {
				if (zon) zogy("Tile() - current2D is read only");
			}
		});

Object.defineProperty(this, "current2DCols", {
			get:function(){
				return get2DCols(that.current);
			},
			set:function() {
				if (zon) zogy("Tile() - current2DCols is read only");
			}
		});

// ZIM 015 CHANGES 
		// scaleToH, scaleToV, scaleToType, 
		// backgroundColor, backing, 
		// backdropColor, backdropPadding, backdropPaddingH, backdropPaddingV, 
		// mat	
		
		var backgrounds;
		var backings;
		var backgroundColors;
		var backdrop;
		var backgroundScaleX;
		var backgroundScaleY;

function makeAdditions(resize) {

// if resize is true it keeps the existing backgrounds, backings, backdrop and mat 
			// it uses the values from the first zik so they do not change as being resized

if (resize) {
				// probably okay if leaving these but just in case...
				if (backdrop) backdrop.removeFrom();
				if (mat) mat.removeFrom();
				// should be okay with keeping backings and backgrounds 
				// they will have levels recycled
			}

if (!zot(backgroundColor) || backing || scaleToH || scaleToV) {
				if (!resize && (scaleToH || scaleToV)) {
					backgroundScaleX = [];
					backgroundScaleY = [];
				}
				if (!resize || zot(backgroundColor)) backgrounds = []; // used regardless
				if (!resize && !zot(backgroundColor)) backgroundColors = [];
				if (!resize && backing) backings = [];

// this batch of code was commented out in 019 draft and not sure why
				if (backing && !zot(backgroundColor)) {
					zim.loop(backings, function(bbb) {
						bbb.addTo(that, backgrounds.length) // add after backgrounds
					}, true); // backwards
				}
				if (zot(backgroundColor)) {
					zim.loop(backgrounds, function(background) {
						background.dispose();
					}, true); // backwards
					backgrounds = null;
					backgroundColors = null;
				} else {
					that.backgrounds = backgrounds;
					that.backgroundColors = backgroundColors;
				}

if (!zot(backgroundColor) && (colSize || rowSize)) {
					that.loop(function(item, i) {
						item.mov(colSize?-spacingHOList[i]/2:0, rowSize?-spacingVOList[Math.floor(i/that.cols)]/2:0);					
					});
					var bb = that.getBounds();
					if (bb) that.setBounds(bb.x, bb.y, bb.width-(colSize?spacingHOTotal:0), bb.height-(rowSize?spacingVOTotal:0))
					bb = that.getBounds();
				}
				if (backing) that.backings = backings;

// end of strangely commented code in 019 draft - now commented back in
				
			}

that.setBounds(null)
			var bounds = that.getBounds();
			if (bounds) that.setBounds(bounds.x, bounds.y, bounds.width, bounds.height);

// add backdrop

if (mat) {
				that.mat = mat;
				mat.center(that,0);
			}

// add backdropColor 
			if (backdropColor) {
				var bb = that.getBounds();
				if (bb) {
					backdrop = that.backdrop = new zim.Rectangle({
						width:bb.width+backdropPaddingH*2, 
						height:bb.height+backdropPaddingV*2, 
						color:backdropColor,
						style:false,
						group:"backdrop"
					});
					backdrop.center(that,0);
					that.loop(function(item) {
						item.mov(Math.max(0,backdropPaddingH), Math.max(backdropPaddingV,0));					
					});	
					that.setBounds(0,0,bb.width+Math.max(0,backdropPaddingH)*2,bb.height+Math.max(backdropPaddingV,0)*2);
				}
			}

}
		makeAdditions();

if (style!==false) zim.styleTransforms(this, DS); // global function - would have put on DisplayObject if had access to it

this.clone = function(exact) {
			if (zot(exact) && unique) exact = true; // added ZIM 016
			if (exact) {
				var exactItems = [];
				if (backgroundColor) var exactBackgroundColors = [];
				if (backing) var exactBackings = [];
				for (var i=0; i<that.items.length; i++) {
					exactItems.push(that.items[i].clone(true));
					if (backgroundColor) exactBackgroundColors.push(backgroundColors[i]);
					if (backing) exactBackings.push(backings[i].clone(true));
				}
			}			
			return that.cloneProps(new zim.Tile(exact&&exactItems?zim.series(exactItems):(obj.clone?obj.clone():obj), that.cols, that.rows, exact?series(spacingHList):that.spacingH, exact?series(spacingVList):that.spacingV, exact?false:unique, width, height, that.squeezeH, that.squeezeV, colSize, rowSize, align, valign, that.items.length, that.mirrorH, that.mirrorV, snapToPixel, exact?false:clone, events, exact, scaleToH, scaleToV, scaleToType, exact&&exactBackgroundColors?zim.series(exactBackgroundColors):backgroundColor, backgroundPadding, backgroundPaddingH, backgroundPaddingV, exact&&exactBackings?zim.series(exactBackings):(backing&&backing.clone)?backing.clone():backing, backdropColor, backdropPadding, backdropPaddingH, backdropPaddingV, (mat&&mat.clone)?mat.clone():mat, this.style, this.group));
		};
	};
	zim.extend(zim.Tile, zim.Container, "clone", "zimContainer", false);

zim.Emitter = function(obj, width, height, interval, num, life, fade, shrink, warm, decayTime, decayStart, trace, traceFadeTime, traceShiftX, traceShiftY, angle, force, gravity, wind, layers, animation, random, horizontal, vertical, sink, sinkForce, cache, events, startPaused, pool, poolMin, particles, focusWarm, style, group, inherit) {
	var sig = "obj, width, height, interval, num, life, fade, shrink, warm, decayTime, decayStart, trace, traceFadeTime, traceShiftX, traceShiftY, angle, force, gravity, wind, layers, animation, random, horizontal, vertical, sink, sinkForce, cache, events, startPaused, pool, poolMin, particles, focusWarm, style, group, inherit";
	var duo; if (duo = zob(zim.Emitter, arguments, sig, this)) return duo;

this.type = "Emitter";

this.group = group;
	var DS = style===false?group!=null?zim.getStyle(null,null,inherit,this.group):{}:zim.getStyle(this.type,this.group,inherit);

// MONITOR		
	var mID = this.mID = "z~"+(DS.monitor===false?"-":this.type);

if (zot(obj)) obj = DS.obj!=null?DS.obj:[new zim.Circle(20,zim.pink),new zim.Circle(20,zim.green),new zim.Circle(20,zim.blue)];
	if (zot(width)) width = DS.width!=null?DS.width:300;
	if (zot(height)) height = DS.height!=null?DS.height:300;
	var timeType = getTIME(interval);
	if (zot(interval)) interval = DS.interval!=null?DS.interval:timeType=="s"?.02:20;
	if (typeof interval == "number") interval = Math.max(timeType=="s"?.01:10, interval);
	if (zot(num)) num = DS.num!=null?DS.num:1;
	if (zot(trace)) trace = DS.trace!=null?trace.size:false;	
	if (zot(traceShiftX)) traceShiftX = DS.traceShiftX!=null?DS.traceShiftX:0;
	if (zot(traceShiftY)) traceShiftY = DS.traceShiftY!=null?DS.traceShiftY:0;
	checkTIME(life, timeType);		
	if (zot(life)) life = DS.life!=null?DS.life:timeType=="s"?1:1000;
	if (zot(fade)) fade = DS.fade!=null?DS.fade:true;
	if (zot(shrink)) shrink = DS.shrink!=null?DS.shrink:trace?false:true;
	if (zot(warm)) warm = DS.warm!=null?DS.warm:null;	
	checkTIME(decayTime, timeType);
	if (zot(decayTime)) decayTime = DS.decayTime!=null?DS.decayTime:timeType=="s"?1:1000;
    if (zot(traceFadeTime)) traceFadeTime = DS.traceFadeTime!=null?DS.traceFadeTime:decayTime;
	if (zot(angle)) angle = DS.angle!=null?DS.angle:{min:0, max:360};
	if (zot(force)) force = DS.force!=null?DS.force:5;
	if (zot(gravity)) gravity = DS.gravity!=null?DS.gravity:9.8;
	if (zot(wind)) wind = DS.wind!=null?DS.wind:0;
	if (zot(layers)) layers = DS.layers!=null?DS.layers:"top"; // bottom, random
	if (zot(width)) width = DS.width!=null?DS.width:100;
	if (zot(height)) height = DS.height!=null?DS.height:100;
	if (zot(horizontal)) horizontal = DS.horizontal!=null?DS.horizontal:false;
	if (zot(vertical)) vertical = DS.vertical!=null?DS.vertical:false;
	if (zot(sink)) sink = DS.sink!=null?DS.sink:null;
	if (!zot(sink) && zot(sinkForce)) sinkForce = DS.sinkForce!=null?DS.sinkForce:10;
	if (zot(events)) events = DS.events!=null?DS.events:false;
	if (zot(startPaused)) startPaused = DS.startPaused!=null?DS.startPaused:false;
	if (zot(pool)) pool = DS.pool!=null?DS.pool:true;
	if (zot(poolMin)) poolMin = DS.poolMin!=null?DS.poolMin:0;
	if (zot(particles)) particles = DS.particles!=null?DS.particles:new zim.Container();
	if (zot(focusWarm)) focusWarm = DS.focusWarm!=null?DS.focusWarm:true;
	if (obj.type == "shape") focusWarm = false;
 	
	particles.type = "Particles";
	particles.emitter = this;

this.zimContainer_constructor(width, height, null, null, false);
	this.type = "Emitter";
	var that = this;

this.regX = width/2; // new auto center reg
	this.regY = height/2;

// might want many of these as dynamic properties - sigh.
	that.obj = obj; that.particles = particles;
	that.interval = interval; that.num = num;
	that.life = life; that.fade = fade; that.shrink = shrink;
	that.decayTime = decayTime;  that.decayStart = decayStart;
	that.trace = trace; that.traceFadeTime = traceFadeTime,
	that.traceShiftX = traceShiftX; that.traceShiftY = traceShiftY;
	that.angle = angle, that.emitterForce = force;
	that.gravity = gravity; that.wind = wind;
	that.layers = layers; that.animation = animation; that.random = random;
	that.horizontal = horizontal; that.vertical = vertical;
	that.sink = sink; that.sinkForce = sinkForce;
	that.events = events; that.startEmitterPaused = that.emitterPaused = startPaused;
	that.pool = pool; that.poolMin = poolMin;

that.particlesEmitted = 0;
	var poolList = [];
	var poolIndex = 0;
	var poolCount = 0;

var emitterTicker;
	var stage;
	zim.added(that, addedToStage);
	function addedToStage(s) {
		that.emitterPaused = null; // will set back using that.startEmitterPaused

that.on("added", function () {			
			// added in ZIM 014
			zim.loop(that.particles, function(particle) {
				particle.visible = false;
			});
			that.particles.addTo(that.parent);
		}, null, null, null, null, mID);
		stage = s;
		if (zot(cache)) {
			if (stage.isWebGL) {
				cache = false;
			} else {
				cache = zim.mobile();
			}
		}
		if (cache) stage.snapToPixelEnabled = true;
		if (stage) {
			var myIndex = that.parent.getChildIndex(that);
			that.parent.addChildAt(particles, myIndex); // add particles beneath emitter in emitter's container
			// particles.x = that.x;
			// particles.y = that.y;
			if (!horizontal && !vertical) that.centerReg(null, null, false);

//-------------   INTERVAL
			// var counter = 0;
			// var time = Date.now();
			// that.interval = 1000 / 60;

// time, call, total, immediate, pauseOnBlur, timeUnit, complete, completeParams, timeout, mID			
			that.zimInterval = zim.interval(that.interval, runEmitter, null, true, true, null, null, null, null, mID, that); // true for immediate, true for pause on blur
			
			function runEmitter() {

// counter++;
				// zog(decimals(counter/(Date.now() - time)*1000,5));

var maxLifeNum = zim.isPick(that.life)?zim.Pick.getMinMax(that.life).max:that.life;
				if (zot(maxLifeNum)) maxLifeNum = timeType=="s"?1:1000;
	
				if (that.startEmitterPaused) {that.pauseEmitter(); return;}
				// want to leave that.obj as it was provided
				// but for creation we will normalize it as an Array
				obj = Array.isArray(that.obj)?that.obj:[that.obj];
				if (obj.length <= 0) return;

var minInterval; // used to calculate max pool
				var maxNum;
				function sortNumber(a,b) {return a - b;}
				if (Array.isArray(that.interval)) {
					that.interval.sort(sortNumber);
					minInterval = that.interval[0];
				} else if (that.interval.constructor == {}.constructor){
					minInterval = that.interval.min;
				} else {
					minInterval = that.interval;
				}
				if (Array.isArray(that.num)) {
					that.num.sort(sortNumber);
					maxNum = that.num[that.num.length-1];
				} else if (that.num.constructor == {}.constructor){
					maxNum = that.num.max;
				} else {
					maxNum = that.num;
				}				
                
				zim.loop(zim.Pick.choose(that.num), function() {
					
					if (that.decayTime > 0) {
						var decay = {};
						if (that.shrink) decay.scale=0;
						if (that.fade) decay.alpha=0;
					}
					var container, t, particle;
                    
                    // zog(that.pool, poolList.length > 0, poolCount >= Math.max(that.poolMin, (maxLifeNum/minInterval)*maxNum+15))
					
                    if (that.pool && poolList.length > 0 && poolCount >= Math.max(that.poolMin, (maxLifeNum/minInterval)*maxNum+15)) { // USE POOL... throw in an extra 5 for good measure
						
						container = poolList[(poolIndex++)%poolList.length];
						container.visible = true;
						particle = container.trace?container.getChildAt(0):container;
													
						if (particle.emitShape) {
							t = particle.template;
							particle.graphics.c().s(t.s?zim.Pick.choose(t.s):null).ss(t.ss?zim.Pick.choose(t.ss):null).sd(t.sd?zim.Pick.choose(t.sd):null, t.offset?zim.Pick.choose(t.offset):null);
						}
						if (container.trace && container.cacheCanvas) {
							container.updateCache();
						}
						if (that.layers == "top") {
							if (particle.emitShape) container.addTo(particles, null, false);
							else container.addTo(particles, particles.numChildren-1, false);
						} else {
							if (particle.emitShape) container.addTo(particles, that.layers=="bottom"?0:zim.rand(particles.numChildren), false);
							else container.addTo(particles, that.layers=="bottom"?0:zim.rand(particles.numChildren), false);
						}                        
						if (!that.trace) container.reg("center");
						
						container.scaleX = 1;
						container.scaleY = 1;
						container.alpha = container.originalAlpha;
						// particle.alpha = particle.originalAlpha;
						particle.scaleX = particle.originalScaleX;
						particle.scaleY = particle.originalScaleY;
						particle.rotation = particle.originalRotation;
						particle.color = particle.originalColor;
						particle.endSpurt = false;

} else { // END POOL, START NOT POOL
                        
						poolCount++;
						container;
						if (that.trace) {
							container = new zim.Container(width,height, null, null, false);
							container.trace = true;
						}

if (that.trace) { // still need to add the container if there is one
							if (that.layers == "top") {
								container.addTo(particles, null, false);
							} else {
								container.addTo(particles, that.layers=="bottom"?0:zim.rand(particles.numChildren), false);
							}  
							container.cache(that.traceShiftX, that.traceShiftY, (stage?stage.width:1200)+2*that.traceShiftX, (stage?stage.height:1000)+2*that.traceShiftY);
						}

if (!that.trace) container = particle;
						container.particle = particle;
						container.originalAlpha = container.alpha;
						particle.originalAlpha = particle.alpha;
						particle.originalScaleX = particle.scaleX;
						particle.originalScaleY = particle.scaleY;
						particle.originalRotation = particle.rotation;
						particle.originalColor = particle.color;

} // END NOT POOL

that.currentParticle = particle;
					that.particlesEmitted++;

container.particleNormal = true;
					container.particleDecaying = false;
					container.particleFizzing = false;

if (particle.type=="Sprite") {
                        var fNum = Math.floor(Math.random()*particle.totalFrames);
                        particle.run({startFrame:fNum, endFrame:fNum});
                    }
					if (that.random) {
						// {color:[blue, pink, yellow, orange]}
						zim.loop(that.random, function(property, options) {
							var val = zim.Pick.choose(options);
							if (property == "scale") {
								particle.sca(val);
							} else if (property == "frame" && particle.run) {
								particle.run({startFrame:val, endFrame:val});
							} else {
								if (property == "x") {
									particle.info.position.x = (that.horizontal || that.vertical)?val:val+width/2;
								} else if (property == "y") {
									particle.info.position.y = (that.horizontal || that.vertical)?val:val+height/2;
								}
								if ((property == "x" || property == "y") && particle.emitShape) {
									particle.graphics.mt(particle.info.position.x, particle.info.position.y);
								}
								particle[property] = val;
								if (particle.emitShape) {particle.x=0; particle.y = 0;} // just adjust info for x and y of shape
							}
						});
					}
					if (
						cache && 
						!particle.emitShape && 
						particle.type!="Pic" && 
						particle.type!="Bitmap" && 
						particle.type!="Sprite"
					) particle.cache(particle.getBounds().x-10,particle.getBounds().y-10,particle.getBounds().width+20,particle.getBounds().height+20);

//-------------    DECAY, FADE, SHRINK, FIZZ

// do not shrink shapes as registration is at 0,0 not at the particle
					var shrinkMe = particle.emitShape?false:that.shrink;

var myLife = (container?container:particle).life = zik(that.life);
					that.traceFadeTime = Math.min(myLife, that.traceFadeTime);
					that.decayTime = Math.min(myLife, that.decayTime);

if (that.decayTime > 0 && (that.fade || shrinkMe || (that.trace && that.traceFadeTime > 0))) {
						if (that.trace && that.traceFadeTime > 0) {
							container.animate({
								obj:{alpha:0},
								time:that.traceFadeTime,
								wait:myLife-that.traceFadeTime,
								waitedCall:function(t) {
									t.particleNormal = false;
									t.particleFizzing = true;
								},
								call:fizz,
								override:true,
								id:"decay",
								group:"noMonitor"
							});
						}
						if (that.fade || shrinkMe) {
							var o = {};
							if (that.fade) o.alpha = 0;
							if (shrinkMe) {
								o.scaleX = 0;
								o.scaleY = 0;
							}
					
							// animate seems messed up - recording as if seconds when ms is set
							particle.animate({
								obj:o,
								time:that.decayTime,
								wait:zot(that.decayStart)?myLife-that.decayTime:that.decayStart,
								waitedCall:function(t) {
									if (t.parent != that) t = t.parent; // access container if there is one
									t.particleNormal = false;
									t.particleDecaying = true;
								},
								call:function(t) {
									if (that.events) sendEvent("decayed", t);
									if (t.endSpurt) sendEvent("spurtdecayed", t);
									if (!(that.trace && that.traceFadeTime > 0)) {
										if (zot(that.decayStart) || that.decayStart+that.decayTime>that.life) {
											if (t.parent) fizz(t.parent.trace?t.parent:t); // only want to call fizz once
										} else {
											-function() {
												var c = container;
												zim.timeout(myLife-(that.decayStart+that.decayTime), function(){fizz(c);});
											}();
										}
									}
								},
								override:false,
								id:"decay",
								group:"noMonitor"
							});
						}
					} else {
						container.life = that.life;
						if (that.life > 0) {
							-function() {
								var c = container;
								c.timeOut = zim.timeout(that.life, function(){fizz(c);});
							}();
						}
					}
					if (that.events) sendEvent("emitted", container);
					spurtCheck(particle);
					if (that.animation) {
						var a = zim.Pick.choose(that.animation);
						if (Array.isArray(a)) {
							zim.loop(a, function(aa) {
								if (zot(aa.override)) aa.override = false;
								var anim = zim.copy(aa);
								if (anim.group) anim.group+=",noMonitor";
								else anim.group = "noMonitor";							
								particle.animate(anim);
							});
						} else {
							if (zot(a.override)) a.override = false;	
							var anim = zim.copy(a);		
							if (anim.group) anim.group+=",noMonitor";
							else anim.group = "noMonitor";				
							particle.animate(anim);
						}							
					}
				});
			}

//-------------  TICKER AND WARM

var frameRate = 0; // need a new Ticker before can get the framerate so set this after new Ticker
			emitterTicker = that.emitterTicker = zim.Ticker.add(calcEmitter, stage, "z~testing", that);
			frameRate = 1 / zim.Ticker.framerate;
			
			
			that.focusWarm = focusWarm;
			that.doWarm = function(warm) {

if (zot(warm) || warm === true) {
					var max;
					if (life.max) max = life.max;
					else if (Array.isArray(life)) max = zim.arrayMinMax(life).max;
					else max = zik(life);
					var min;
					if (interval.min) min = interval.min;
					else if (Array.isArray(interval)) min = zim.arrayMinMax(interval).min;
					else min = zik(interval);
					warm = Math.min(200, Math.round(max/min));
				}		
				var pool_o = that.pool;
				that.pool = false;
				var ticksPerParticle = Math.round(interval*zim.Ticker.framerate);				
				zim.loop(Math.round(warm*interval*zim.Ticker.framerate), function(i) {
					if (i%ticksPerParticle==0) {
						runEmitter();
					}
					zim.loop(particles, function(particle) {
						if (!particle.warmTick) particle.warmTick = 1;
						else particle.warmTick++;
						if (particle.warmTick/zim.Ticker.framerate > particle.life) fizz(particle)
					});
					calcEmitter();
				});		
				// set animations to percentComplete
				zim.loop(particles, function(particle) {
					if (particle.zimTweens) {
						var spc = particle.warmTick/zim.Ticker.framerate/particle.life*100;
						if (spc >= 100) particle.alpha = 0;	
						particle.percentComplete = spc;	
					}
				});		
				that.pool = pool_o;

}
			if (warm) that.doWarm(warm);

that.particles.noMouse();

//-------------    FUNCTIONS

function fizz(p) {

if (that.events) sendEvent("fizzed", p);
		if (p.trace?p.getChildAt(0).endSpurt:p.endSpurt) {
			sendEvent("spurtfizzed", p);
			that.spurting = false;
			if (cache) stage.snapToPixelEnabled = false;
		}
		if (that.pool) {
			if (p.pooled == "end") {
				// already removed from poolList by clearPool
				// go through and removeChild
			} else if (p.pooled) { // already in the pool
				p.visible = false;					
				return;
			} else { // add to pool and return so does not get removed
				p.pooled = true;
				if (poolList) poolList.push(p);
				p.visible = false;
				return;
			}
		}
		that.removeChild(p);
		if (that.trace) p.uncache();
		p = null;
	}

function sendEvent(type, object) {
		if (zot(object)) return;
		var e = new createjs.Event(type);
		e.particle = object.trace?object.getChildAt(0):object;
		that.dispatchEvent(e);
	}

function spurtCheck(p) {
		if (zot(that.spurtCount) && zot(that.spurtNum)) return;
		that.spurtCount++;
		if (that.spurtCount >= that.spurtNum) {
			lastSpurt(p);
		}
	}

function lastSpurt(p) {
		that.pauseEmitter();
		that.spurtCount = that.spurtNum = null;
		if (zot(p)) return;
		sendEvent("spurted", p);
		p.endSpurt = true;
	}

//-------------    PROPERTIES

Object.defineProperty(that, 'interval', {
		get: function() {
			return interval;
		},
		set: function(theInterval) {
			interval = theInterval;
			if (that.zimInterval) that.zimInterval.time = interval;
		}
	});

//-------------    METHODS

this.removeFrom = function() {
		// that.removeFrom();
		if (that.parent) that.parent.removeChild(that);
		that.particles.removeFrom();
		if (cache) stage.snapToPixelEnabled = false;
	};

this.spurting = false;
	this.spurt = function(num, time, restart) {
		var sig = "num, time, restart";
		var duo; if (duo = zob(that.spurt, arguments, sig)) return duo;
		if (cache) stage.snapToPixelEnabled = true;
		if (!zot(time)) {
			zim.timeout(zim.Pick.choose(time), function() {
				lastSpurt(that.currentParticle);
			}, true);
			that.spurting = true;
		}
		if (!zot(num)) {
			// handled by checkSpurt() function
			that.spurtNum = zim.Pick.choose(num);
			that.spurtCount = 0;
			that.spurting = true;
		}
		that.pauseEmitter(false, restart, null, true); // unpause and immediately call call interval function
		return that;
	};

this.clearPool = function() {
		zim.loop(that.particles, function(p) {
			p.pooled="end";
			if (!p.visible) that.removeChild(p);
		},true);
		poolCount = 0;
		poolIndex = 0;
		poolList = [];
	};
	
	if (!that.startEmitterPaused) this.emitterPaused = false; // do not set to false - as it will be done below if needed
	this.pauseEmitter = function(state, restart, freeze, immediate) {
		
		that.startEmitterPaused = null;
		if (zot(state)) state = true;
		if (zot(restart)) restart = false;
		if (zot(freeze)) freeze = false;
		if (state) { // pausing
		if (that.emitterPaused) return that;
		if (freeze) {
			if (emitterTicker) zim.Ticker.remove(emitterTicker, mID, that);
			zim.loop(that.particles, function(particle) {
				particle.pauseAnimate();
				if (particle.trace) particle.getChildAt(0).pauseAnimate();
					if (particle.timeOut) {
						particle.timeOut.pause();
					}
				});
			}
			that.zimInterval.pause();
			that.emitterPaused = true;
			if (cache) stage.snapToPixelEnabled = false;
		} else { // unpausing
			if (!that.emitterPaused) return that;
			if (restart) {
				zim.loop(that.particles, function(particle) {
					particle.stopAnimate();
					if (particle.timeOut) particle.timeOut.clear();
					if (particle.trace) particle.getChildAt(0).pauseAnimate();
				});
				that.removeAllChildren();
			}
			if (stage && emitterTicker && !zim.Ticker.has(stage, emitterTicker)) {
				zim.Ticker.add(emitterTicker, stage, mID, that);
				zim.loop(that.particles, function(particle) {
					particle.pauseAnimate(false);
					if (particle.timeOut) particle.timeOut.pause(false);
					if (particle.trace) particle.getChildAt(0).pauseAnimate(false);
				});
			}
			if (that.zimInterval) that.zimInterval.pause(false, immediate);
			that.emitterPaused = false;
			if (cache) stage.snapToPixelEnabled = true;
		}
		return that;
	};

this.resize = function(w, h) {
		if (!zot(w)) width = w;
		if (!zot(h)) height = h;
		that.setBounds(0,0,width,height);
		if (!horizontal && !vertical) that.centerReg();
		that.clearPool();
	};

if (style!==false) zim.styleTransforms(this, DS);

this.clone = function(exact) {
		var objClone;
		if (Array.isArray(that.obj) || that.obj.constructor == {}.constructor) {
			objClone = zim.copy(that.obj);
		} else if (that.obj.clone) {
			objClone = that.obj.clone(exact);
		} else {
			objClone = that.obj;
		}
		// note that all will clone the current property except for startEmitterPaused which clones the initial parameter value
		return that.cloneProps(new zim.Emitter(objClone, width, height, that.interval, that.num, that.life, that.fade, that.shrink, warm, that.decayTime, that.decayStart, that.trace, that.traceFadeTime, that.traceShiftX, that.traceShiftY, that.angle, that.emitterForce, that.gravity, that.wind, that.layers, that.animation, zim.copy(that.random), that.horizontal, that.vertical, that.sink, that.sinkForce, cache, that.events, startPaused, that.pool, that.poolMin, particles, focusWarm, style, that.group, inherit));
	};

this.dispose = function() {
		if (cache) stage.snapToPixelEnabled = true;
		if (that.zimInterval) that.zimInterval.clear();
		if (emitterTicker) zim.Ticker.remove(emitterTicker, mID, that);
		zim.loop(poolList, function(particle) {
			if (particle) particle.dispose();
		});			
		if (particles && particles.dispose) particles.dispose();
		if (that.currentParticle && that.currentParticle.dispose) that.currentParticle.dispose();
		if (obj && Array.isArray(obj)) {
			zim.loop(obj, function (el) {
				if (el.dispose) el.dispose();
			});
		} else {
			if (obj && obj.dispose) obj.dispose();
		}
		particles = that.currentParticle = that.particles = obj = that.obj = poolList = that.poolList = null;
		return true;
	};
};
zim.extend(zim.Emitter, zim.Container, "clone", "zimContainer", false);

// OCT
		if (zot(blurX)) blurX=DS.blurX!=null?DS.blurX:10;
		if (zot(blurY)) blurY=DS.blurY!=null?DS.blurY:10;
		if (zot(quality)) quality=DS.quality!=null?DS.quality:1;
		
		// VEE
		var oa = remember(blurX, blurY, quality);	
		this.veeObj = {blurX:oa[0], blurY:oa[1], quality:oa[2]};
		function remember() {return arguments;} 
		blurX = zik(blurX);
		blurY = zik(blurY);
		quality = zik(quality);
			
		this.createjsBlurFilter_constructor(blurX, blurY, quality);
		this.type = "BlurEffect";	
		
		// MONITOR		
		this.mID = "z~"+(DS.monitor===false?"-":this.type);
		
		this.clone = function(exact) {
			return new zim.BlurEffect(
				(exact||!zim.isPick(oa[0]))?blurX :oa[0],
				(exact||!zim.isPick(oa[1]))?blurY :oa[1],
				(exact||!zim.isPick(oa[2]))?quality :oa[2],
				style,this.group,inherit
			);
		};
	}	
	zim.extend(zim.BlurEffect, createjs.BlurFilter, "clone", "createjsBlurFilter", false);

zim.SelectionSet = function(selections) {
		this.type = "SelectionSet";

// MONITOR		
		this.mID = "z~"+this.type;

if (zot(selections)) selections = [];
		this.selections = selections;
		this.clear = function() {
			this.selections = [];
		};
		this.isSelected = function(item) {
			return this.selections.indexOf(item) >= 0;
		};
		// add will append if multiple or SelectionManager multiple is true
		// otherwise turns all other selections off and adds parameter selection
		this.add = function(item, multiple, match, unmatch) {
			if (zot(item)) return;
			if (zot(multiple)) {
				if (!zot(this.selectionManager)) multiple = this.selectionManager.multiple;
			}
			if (!zot(this.selectionManager)) {
				this.selectionManager.setCurrent(this);
				if (!multiple && this.selectionManager.multipleSets) this.selectionManager.clear();
			}
			if (!multiple ) this.clear();
			var ind = this.selections.indexOf(item);
			if (ind >= 0) return;
			this.selections.push(item);
			if (!zot(match)) {
				if (!Array.isArray(match)) match = [match];
				for (var i=0; i<=match.length; i++) {
					match[i].add(item, multiple);
				}
			}
			if (!zot(unmatch)) {
				if (!Array.isArray(unmatch)) unmatch = [unmatch];
				for (i=0; i<=unmatch.length; i++) {
					unmatch[i].remove(item, multiple);
				}
			}
		};
		this.remove = function(item, multiple, match, unmatch) {
			if (zot(item)) return;
			if (zot(multiple)) {
				if (!zot(this.selectionManager)) multiple = this.selectionManager.multiple;
			}
			if (!zot(this.selectionManager)) this.selectionManager.setCurrent(this);
			if (!multiple) this.clear();
			var ind = this.selections.indexOf(item);
			if (!zot(this.selectionManager)) {
				this.selectionManager.setCurrent(this);
				if (!multiple && this.selectionManager.multipleSets) this.selectionManager.clear();
			}
			if (!multiple ) this.clear();
			if (!multiple) this.clear();
			else if (ind >= 0) this.selections.splice(ind, 1);
			if (!zot(match)) {
				if (!Array.isArray(match)) match = [match];
				for (var i=0; i<=match.length; i++) {
					match[i].remove(item, multiple);
				}
			}
			if (!zot(unmatch)) {
				if (!Array.isArray(unmatch)) unmatch = [unmatch];
				for (i=0; i<=unmatch.length; i++) {
					unmatch[i].add(item, multiple);
				}
			}
		};
		this.toggle = function(item, multiple, match, unmatch) {
			if (this.isSelected(item)) this.remove(item, multiple, match, unmatch);
			else this.add(item, multiple, match, unmatch);
		};
		this.dispose = function() {
			this.clear();
			this.selections = null;
			return true;
		};
	};

zim.SelectionManager = function(sets, multipleKey, multipleSets) {
		this.cjsEventDispatcher_constructor();
		this.type = "SelectionManager";

// MONITOR	
		this.mID = "z~"+this.type;

if (zot(sets)) sets = [];
		if (zot(multipleSets)) multipleSets = true;
		if (!Array.isArray(sets)) sets = [sets];
		this.sets = sets;
		this.multipleKey = multipleKey;
		this.multipleSets = multipleSets;
		this.multiple = false;
		var that = this;
		var _enabled = true;
		for (var i=0; i<sets.length; i++) {
			sets[i].selectionManager = this;
		}
		this.clear = function() {
			this.currentSet = null;
			for (var i=0; i<sets.length; i++) {
				sets[i].clear();
			}
		};
		this.setCurrent = function(set) {
			this.currentSet = set;
			for (var i=0; i<sets.length; i++) {
				if (sets[i] == set) continue;
				if (!this.multipleSets) sets[i].clear();
			}
		};
		var eDown = new createjs.Event("keydown");
		this.downEventRemove = eDown.remove;
		this.keydownEvent = function(e) {			
			e.remove = that.downEventRemove;
			if (that.multipleKey) that.multiple = e[that.multipleKey+"Key"];
			that.ctrlKey = e.ctrlKey;
			that.shiftKey = e.shiftKey;
			that.metaKey = e.metaKey;
			if (!_enabled) return;
			that.dispatchEvent(e);
			if (e.keyCode==90 && (that.ctrlKey || that.metaKey)) {
				that.dispatchEvent("undo");
			}
		};
		WW.addEventListener("keydown", this.keydownEvent);
		
		var eUp = new createjs.Event("keyup");
		this.upEventRemove = eUp.remove;
		this.keyupEvent = function(e) {			
			e.remove = that.upEventRemove;
			if (that.multipleKey) that.multiple = e[that.multipleKey+"Key"];
			that.ctrlKey = e.ctrlKey;
			that.shiftKey = e.shiftKey;
			that.metaKey = e.metaKey;
			if (!_enabled) return;
			that.dispatchEvent(e);
		}
		WW.addEventListener("keyup", this.keyupEvent);

Object.defineProperty(that, 'enabled', {
			get: function() {
				return _enabled;
			},
			set: function(value) {
				_enabled = value;
			}
		});
		
		this.dispose = function () {
			this.clear();
			WW.removeEventListener("keydown", this.keydownEvent);
			WW.removeEventListener("keyup", this.keyupEvent);
		};
	};
	zim.extend(zim.SelectionManager, createjs.EventDispatcher, null, "cjsEventDispatcher", false);

zim.Frame = function(scaling, width, height, color, outerColor, ready, assets, path, progress, ticker, rollover, touch, scrollTop, align, valign, canvasID, rollPerSecond, delay, canvasCheck, gpu, gpuObj, nextFrame, nextStage, allowDefault, loadFailObj, retina, mouseMoveOutside, captureMouse, shim, maxConnections, maxNum, singleTouch) {
	var sig = "scaling, width, height, color, outerColor, ready, assets, path, progress, ticker, rollover, touch, scrollTop, align, valign, canvasID, rollPerSecond, delay, canvasCheck, gpu, gpuObj, nextFrame, nextStage, allowDefault, loadFailObj, retina, mouseMoveOutside, captureMouse, shim, maxConnections, maxNum, singleTouch";
	var duo; if (duo = zob(zim.Frame, arguments, sig, this)) return duo;
	if (zon) zogg("ZIM FRAME");
	this.cjsEventDispatcher_constructor();
	this.type = "Frame";

// MONITOR		
	var mID = this.mID = "z~"+this.type;

// handle zapp directives 
	if (!zot(zapp_scaling)) scaling = zapp_scaling;
	if (!zot(zapp_width)) width = zapp_width;
	if (!zot(zapp_height)) height = zapp_height;
	if (!zot(zapp_color)) color = zapp_color;
	if (!zot(zapp_outerColor)) outerColor = zapp_outerColor;
	if (!zot(zapp_assets)) assets = zapp_assets;
	if (!zot(zapp_path)) path = zapp_path;
	if (!zot(zapp_progress)) progress = zapp_progress;
	if (!zot(zapp_gpu)) gpu = zapp_gpu;
	if (!zot(zapp_gpuObj)) gpuObj = zapp_gpuObj;
	if (!zot(zapp_maxNum)) maxNum = zapp_maxNum;
	if (!zot(zapp_singleTouch)) singleTouch = zapp_singleTouch;

var that = this;	
		
	// global variables to help reference the frame in some cases
	// not currently used for stage critical functions
	// just used to get key events or colors internally
	// also, as of zim 5.1.0 used for new Ticker.add(function(){});
	// will use the zdf.stage if stage is not supplied as second parameter
	// this may lead to problems if a second frame is used
	// and the second frame stage is not used for the new Ticker.add()
	// but two frames are rarely used and this simplifies 99% of the tickers
	if (!WW.zdf || !WW.zdf.type) WW.zimDefaultFrame = WW.zdf = WW.F = this;
	WW.M = zim.mobile();
	var D=Date;
	this.startTime = new D().getTime();

F.reloaded = (WW.performance && WW.performance.getEntriesByType && WW.performance.getEntriesByType("navigation")[0].type === "reload") 
	
	if (zot(canvasCheck)) canvasCheck = true;
	var canvasSupported = !!WW.HTMLCanvasElement;
	if (!canvasSupported && canvasCheck) { // no canvas support
		setTimeout(function() {
			that.dispatchEvent("failed");
		}, 100);
		return;
	}
	var mobile = zim.mobile();
	if (zot(scaling)) scaling = "full";
	if (scaling=="outside") scaling = "fill"; // handle legacy outside value
	// if (zot(width)) width = "1024";
	// if (zot(height)) height = "768";
	if (!zot(path)) WW.PATH = path;
	if (zot(rollover)) rollover = !mobile;
	if (zot(touch)) touch = true;
	if (zot(scrollTop)) scrollTop = false;
	if (zot(align)) align = "center";
	if (zot(valign)) valign = "center";
	var randomCanvas = "";
	if (zot(canvasID)) {
		if (WW.zdf != this) { // more than one canvas with generic name
			randomCanvas = zim.makeID(null,5);
			canvasID = "myCanvas" + randomCanvas;
		} else {
			canvasID = "myCanvas";				
		}
	}
	var timeType = getTIME(delay);
	if (zot(rollPerSecond)) rollPerSecond = 20;
	if (zot(delay)) delay = mobile?(timeType=="s"?1:1000):(timeType=="s"?.03:30);
	if (zot(gpu)) gpu = false;
	if (zot(allowDefault)) allowDefault = false;
	if (zot(loadFailObj)) loadFailObj = "circles";
	this.loadFailObj = loadFailObj;
	if (zot(retina)) retina = true;
	this.retina = retina;
	if (zot(mouseMoveOutside)) mouseMoveOutside = false;
	if (zot(captureMouse)) captureMouse = true;
	if (zot(shim)) shim = false;
	if (zot(maxConnections)) maxConnections = 10;
	if (zot(singleTouch)) singleTouch = false;
	if (singleTouch) touch = true;
	var defaultMaxConnections = maxConnections;
	that.maxNum = maxNum;

if (gpu) retina = false;
	this.retina = retina;
	
	var oldLeft = false;
	var old2Left = false;
	this.leftMouseDown = false;
	function leftEvent(e) {		
		// e = e.nativeEvent;	
		that.leftMouseDown = e.buttons === undefined?e.which === 1:e.buttons === 1;
		if (oldLeft && !that.leftMouseDown) {
			// adjusted ZIM 017 patch to accomodate mousemove trigger on fast apple drags
			if (e && e.type == "mouseup") {
				that.dispatchEvent("mouseupplus");						
			} else {
				setTimeout(function() {
					that.dispatchEvent("mouseupplus");
				}, 30);	
			}
		}
		if (old2Left && !that.leftMouseDown) that.dispatchEvent("mouseupplusonly");
		oldLeft = old2Left = that.leftMouseDown;
	}
	
	// setting a scaling of something other than this list will set the scaling to tag mode
	// where the scaling parameter value is assumed to be the ID of an HTML tag to contain the Frame
	var types = ["fit","fill","full"];

var stage,sW,sH;
	if (shim) {
		this.shim = true;
		shim.stage.frame = this;
		var canvas = this.canvas = shim.canvas;
		this.scale = shim.stage.scaleX;
		var shimTime;
		var shimResizeEvent;			
		setTimeout(function() {
			setFrameShim();
			shimResizeEvent = function(){
				setFrameShim();
				if (shimTime) clearTimeout(shimTime);
				// delay a last setting to wait for createjs to update
				shimTime = setTimeout(setFrameShim, 50);
			}
			WW.addEventListener('resize', shimResizeEvent);
		}, 20);
		stage = shim.stage;
		sW = stage.getBounds() ? stage.getBounds().width : canvas.width/stage.scaleX;
		sH = stage.getBounds() ? stage.getBounds().height: canvas.height/stage.scaleY;
		if (!stage.getBounds()) stage.setBounds(0,0,sW,sH);
		color = canvas.style.backgroundColor;
		setMousemove();			
		setFrameShim();
	} else {
		this.scale = 1;
		this.x = 0;
		this.y = 0;
	}
	function setFrameShim() {
		that.scale = shim.stage.scaleX;
		var bRect = canvas.getBoundingClientRect();
		that.x = bRect.x + zim.browserScrollX();
		that.y = bRect.y + zim.browserScrollY();
		zim.scaX = createjs.stageTransformable ? 1 : shim.stage.scaleX;
		zim.scaY = createjs.stageTransformable ? 1 : shim.stage.scaleY;
	}

var appOrientation; // watch out - orientation keyword is used by apple - sigh
	var lastOrientation; // used to detect orientation change
	var appReady = false; // check variable (watch - "ready" is reserved)
	var tagID;
	var tag;

// 0. part of TEN PATCH
	// need to keep check for resize and assets for dispatching ready
	var resizeReady = false;
	var assetsReady = false;

// Firefox has a glitch when setting the canvas to a new dimension
	// this only happens in full mode if a new Ticker is updating the stage
	// so set the new Ticker update to false - unfortunately for 500ms
	// which means animations will pause a little during resize
	// the resize event triggers pretty quickly and that will update the stage
	var lastTicker;
	var pauseTicker = false;
	var checkResize = (scaling == "full" && typeof InstallTrigger !== 'undefined'); // firefox check

// 1. part of TEN PATCH
	// various tablets have orientation marked wrong - or they start horizontal at 0 rather than vertical at 0
	// like Some Galaxy Tabs - yet Chrome does not report a width and height change with orientation change
	// so it is almost a no win situation - but this tests the start and if incorrect swaps rotation
	// Also see windowWidth() and windowHeight() functions for their usage of swapRotation
	this.swapRotation = false;
	if (mobile && !WW.parent) { // can't tell if in iFrame
		var mw = isNaN(WW.innerWidth) ? WW.clientWidth : WW.innerWidth;
		var mh = isNaN(WW.innerHeight) ? WW.clientHeight : WW.innerHeight;
		this.swapRotation = ((WW.orientation==0||WW.orientation==180)&&mw>mh)||(Math.abs(WW.orientation)==90&&mh>mw);
	}

// 2. part of TEN PATCH
	// resize now checks twice for window dimensions - with second time being set by delay parameter
	WW.addEventListener('resize', windowResizeEvent);
	var checkTime;
	function windowResizeEvent() {
		if (shim) {
			if (stage.canvas) {
				var w = sW = stage.canvas.width;
				var h = sH = stage.canvas.height;
				stage.setBounds(0,0,w,h); 
			}			
			that.dispatchEvent("resize");
			return;
		}
		checkTime = Date.now() + delay*(timeType=="s"?1000:1);
		if (checkResize) {
			if (!pauseTicker) {
				pauseTicker = true;
				lastTicker = zim.Ticker.update;
				if (!zim.tickerFrame) {
					zim.Ticker.update = false;
					zim.tickerFrame = that;
				}
				sizeCanvas();
				dispatchResize();
				clearInterval(that.frameTime);
				that.frameTime = setInterval(function() {
					if (Date.now() > checkTime) {
						clearInterval(that.frameTime);
						pauseTicker = false;
						if (that==zim.tickerFrame) zim.Ticker.update = lastTicker;
						return;
					}
					sizeCanvas();
					dispatchResize();
				}, 50);
			}
		} else {
			sizeCanvas();
			dispatchResize();
			clearInterval(that.frameTime);
			that.frameTime = setInterval(function() {
				if (Date.now() > checkTime) {
					clearInterval(that.frameTime);
					return;
				}
				sizeCanvas();
				dispatchResize();
			}, delay*(timeType=="s"?1000:1)<50?delay*(timeType=="s"?1000:1)+5:50);
		}
	}

// asset parameter
	that.loadAssetsCount = 0;
	if (zot(zim.assets)) {
		zim.assets = {}; // store asset Bitmap or play function for sound
		zim.assetIDs = {}; // store ids for assets
	}		
	// prepare prefix check
	var m=[]; m[0]="h"; m[1]="c"; m[2]="o"; m[3]="p"; m[4]="e";
	
	var preExistingCanvas = false;
	function init() {
		if (initCheck) return;
		initCheck = true;
		if (types.indexOf(scaling) == -1) {
			tagID = scaling;
			if (zot(zid(tagID))) {zogy("Frame - scaling: HTML tag with id="+scaling+" must exist"); return;}
			tag = that.tag = zid(tagID);
			that.scaling = scaling = (zot(width) || zot(height)) ? "tag" : "inline"; // tag with no dimensions or dimensions
			if (canvasID.indexOf("myCanvas") == 0) canvasID = tagID + "Canvas"; // removed in 6.9.0 + randomCanvas;
			if (tag.tagName.toLowerCase() == "canvas") {
				preExistingCanvas = true;
				canvasID = tagID; // the tag is a canvas (added in Cat 01)
			}
		} else {
			that.scaling = scaling;
		}
		that.canvasID = canvasID;

// now assign default width and height (ignored by full and tag)
		if (zot(width)) width = 500;
		if (zot(height)) height = 500;
		sW = width;
		sH = height;
		
		if (!zot(outerColor)) that.outerColor = outerColor;

makeCanvas();
		makeStage();

// 3. part of TEN PATCH
		// two delays to check initial size
		// combined getResize into function
		if (mobile) {				
			// for older mobile - pan hides the location bar
			if (scrollTop) {setTimeout(function() {WW.scrollTo(0, 0);}, 50);}
			setTimeout(getResize, 100);
			// for extra delay
			if (delay*(timeType=="s"?1000:1) != 100) setTimeout(getResize, delay*(timeType=="s"?1000:1)); // to catch delayed screen sizes
		} else {
			// check to make sure any asset loading is done
			resizeReady = true;
			checkDispatch();
		}
		function getResize() {
			sizeCanvas();
			resizeReady = true;
			// check to make sure any asset loading is done
			checkDispatch();
			dispatchResize();
			if (stage) stage.update();
		}

if (!zot(assets)) { // there are assets
			var q;
			if (assets.constructor == {}.constructor && !(assets.audioSprite || assets.id || assets.data || assets.src)) {
				q = that.loadAssets(zim.merge(assets, {progress:progress, queueOnly:true}));
			} else {
				q = that.loadAssets({assets:assets, path:path, progress:progress, queueOnly:true});
			}
			if (zot(q) || !q.on) {
				if (zon) zogy("Frame() - load failed");

// 4. part of TEN PATCH
				// now keep specific track of assetsReady
				// in three places below
				assetsReady = true;
				checkDispatch();
			} else {
				q.on("complete", function() {
					assetsReady = true;
					checkDispatch();
				}, null, null, null, null, mID);
			}
		} else {
			assetsReady = true;
			checkDispatch();
		}
	}

// 5. part of TEN PATCH
	// adjusted checkDispatch to check for resize and assets separately
	// previously, it was as long as there were two checks dispatch!
	// but now resize checks twice so needed to adjust
	function checkDispatch() {
		if (resizeReady && assetsReady && !appReady) {
			if (stage.width >= 1 && stage.height >= 1) {				
				if (!zot(progress) && progress.show) progress.hide();	
				if (that == WW.zdf)	{
					WW.S = stage;				
					WW.W = stage.width;
					WW.H = stage.height;	
				}								
				if (ready && typeof ready == "function") ready(that, stage, stage.width, stage.height);
				if (!that) return;
				if (ticker && typeof ticker == "function") {
					var count = 0;
					if (!that) return;
					that.updateID = zim.Ticker.add(function(){ticker(++count, that, stage, stage.width, stage.height);}, null, mID, that);
					that.pauseTicker = function(state) {
						if (zot(state)) state = true;
						if (state) {
							if (that.updateID) zim.Ticker.remove(that.updateID, mID, that);
						} else {
							zim.Ticker.add(that.updateID, null, mID, that);
						}
					}
				}				
				that.dispatchEvent("ready");
				appReady = true;
				dispatchResize();
				stage.update();
			} else {					
				setTimeout(function() {
					sizeCanvas();
					checkDispatch();
				}, 50);
			}				
		}
	}	
	function makeCanvas() {
		// the width and height of a canvas are separate from from the width and height styles
		// so beware of unintentionally stretching the canvas with styles
		
		var canvas;
		if (preExistingCanvas) {
			canvas = that.canvas = that.tag;
		} else {
			canvas = that.canvas = document.createElement("canvas");
			canvas.setAttribute("id", canvasID);
		}
		canvas.setAttribute("tabindex", 0);				
		var w = zim.windowWidth();
		var h = zim.windowHeight();
		var pRatio = WW.devicePixelRatio || 1;
		// canvas.setAttribute("title", "application");
		if (scaling == "full" || scaling == "tag") {
			if (retina) {
				that.scale = pRatio;
				canvas.setAttribute("width", w*that.scale);
				canvas.setAttribute("height", h*that.scale);
				if (scaling == "full") {
					canvas.style.width = w+'px';
					canvas.style.height = h+'px';
				}
			} else {
				canvas.setAttribute("width", w);
				canvas.setAttribute("height", h);
			}
		} else {
			canvas.setAttribute("width", sW);
			canvas.setAttribute("height", sH);
		}
		var alternative = zid(canvasID + "Alternative");
		if (alternative) canvas.appendChild(alternative);
		if (!preExistingCanvas) {
			if (scaling == "tag" || scaling  == "inline") {
				tag.appendChild(canvas);
				// canvas.style.position = "relative"; // to enable zIndex if needed
			} else {
				document.body.appendChild(canvas);
			}
		}
		if (!zot(color)) canvas.style.backgroundColor = color;
		if (scaling == "full" || scaling == "fit" || scaling == "fill") {
			canvas.style.position = "absolute";
			if (!allowDefault) document.body.style.overflow = "hidden";
		} else {
			// helps position Tag, TextArea, etc. when parent is scaled with CSS
			if (getComputedStyle(canvas.parentElement).position=="static") canvas.parentElement.style.position = "relative";
		}

// Added ZIM 014
		canvas.addEventListener("pointerdown", function(e) {
			canvas.setPointerCapture(e.pointerId);
			that.dispatchEvent(e);
		});	
		canvas.addEventListener("pointerup", function(e) {
			canvas.releasePointerCapture(e.pointerId);
			that.dispatchEvent(e);
		});
		canvas.addEventListener("pointermove", function(e) {
			that.dispatchEvent(e);
		});
		canvas.addEventListener("pointerenter", function(e) {
			that.dispatchEvent(e);
		});
		canvas.addEventListener("pointerleave", function(e) {
			that.dispatchEvent(e);
		});	
		
	}
	
	function setMousemove() {				
		if (captureMouse) { // patched in 10.7.1
			that.mouseX = 0;
			that.mouseY = 0;
			that.mousedownEvent = stage.on("stagemousedown", function (e) {
				that.mouseX = e.stageX/zim.scaX;
				that.mouseY = e.stageY/zim.scaY;
			}, null, null, null, null, mID);
			that.mousemoveEvent = stage.on("stagemousemove", function (e) {
				that.mouseX = e.stageX/zim.scaX;
				that.mouseY = e.stageY/zim.scaY;
			}, null, null, null, null, mID);
		}
		// changed to pointer in ZIM 019 patch mousedown, etc. was not activating after CreateJS 1.5 switch
		WW.removeEventListener("pointerdown", leftEvent, true);
		WW.removeEventListener("pointermove", leftEvent, true);
		WW.removeEventListener("pointerup", leftEvent);			
		WW.addEventListener("pointerdown", leftEvent, true);
		WW.addEventListener("pointermove", leftEvent, true); // tell actual mousemove there was a mouseup
		WW.addEventListener("pointerup", leftEvent); // give actual mouseup a chance to act
	}

if (scaling == "fit") {
			// scales canvas to fit dimensions inside screen
			that.scale = (w/h >= sW/sH) ? h/sH : w/sW;
		} else if (scaling == "fill") {
			// scales canvas so screen inside dimensions
			that.scale = (w/h >= sW/sH) ? w/sW : h/sH;
		} else if (scaling == "full") {
			can.style.left = can.style.top = "0px";
			can.width = sW = w;
			can.height = sH = h;
			if (stage) {
				stage.setBounds(0,0,sW,sH); // need this
				if (retina) {
					pRatio = WW.devicePixelRatio || 1;
					can.width = w*pRatio;
					can.height = h*pRatio;
					can.style.width = w+'px';
					can.style.height = h+'px';
					that.scale = pRatio;
					stage.scaleX = stage.scaleY = that.scale;					
				} else {
					stage.scaleX = stage.scaleY = 1;
				}
				stage.tickOnUpdate = false;
				stage.update();
				stage.tickOnUpdate = true;								
				stage.width = sW;
				stage.height = sH;
				if (gpu) stage.updateViewport(sW/stage.scaleX, sH/stage.scaleY);
				zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
				zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
			}
			if (!allowDefault) {
				zim.browserScrollX(0);
				zim.browserScrollY(0);
			}
			setVisible();
			return;
		} else if (scaling == "tag") {
			// does not scale canvas but sets width and height to tag
			sW = tag.style.width == "" ? (tag.getAttribute("width") || tag.offsetWidth) : tag.style.width;
			sH = tag.style.height == "" ? (tag.getAttribute("height") || tag.offsetHeight) : tag.style.height;
			if (retina) {
				can.width = sW*that.scale;
				can.height = sH*that.scale;
				can.style.width = sW+"px";
				can.style.height = sH+"px";
				if (stage) {
					stage.scaleX = stage.scaleY = that.scale;						
				}
			} else {
				if (stage) stage.scaleX = stage.scaleY = 1;
				can.width = sW;
				can.height = sH;
			}
			if (stage) {
				stage.tickOnUpdate = false;
				stage.update();
				stage.tickOnUpdate = true;
				
				stage.setBounds(0,0,sW,sH); // need this
				stage.width = sW;
				stage.height = sH;
				if (gpu) stage.updateViewport(sW/stage.scaleX, sH/stage.scaleY);
				zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
				zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
			}
			tag.style.overflow = "hidden";
			can.style.left = can.style.top = "0px";

bRect = can.getBoundingClientRect();
			that.x = bRect.x + zim.browserScrollX();
			that.y = bRect.y + zim.browserScrollY();
			setVisible();
			return;
		} else if (scaling == "inline") {
			// does not scale canvas but sets width and height
			if (retina) {

// may put percentage style on canvas tag
				// this only handles width and only on first styleSheet
				if (document.styleSheets[0]) {
					try {
						var rules = document.styleSheets[0].rules || document.styleSheets[0].cssRules;
						for (var i=0; i < rules.length; i++) {
							var rule = rules[i];
							if (rule.selectorText == "#"+canvasID) {
								var ww = rule.style.getPropertyValue("width");
								if (ww) {
									var www = zum(can.style.width);
									var hhh = zum(can.style.height);
									can.style.width = ww;
								}
							}
						}
					} catch (e) {
						+function(){}();
					}
				}
				var comp = WW.getComputedStyle(can);
				var wid = zum(comp.getPropertyValue('width'));
				if (www) {
					can.style.height = (hhh*wid/www) + "px";
					comp = WW.getComputedStyle(can);
				}
				var hei = zum(comp.getPropertyValue('height'));

pRatio = WW.devicePixelRatio || 1;
				that.scale = wid/width*pRatio;
				can.width = sW*that.scale;
				can.height = sH*that.scale;
				can.style.width = wid+'px';
				can.style.height = hei+'px';
				if (stage) {
					stage.scaleX = stage.scaleY = that.scale;						
				}
			} else {
				if (stage) stage.scaleX = stage.scaleY = 1;
			}
			if (stage) {
				stage.tickOnUpdate = false;
				stage.update();
				stage.tickOnUpdate = true;
				stage.setBounds(0,0,sW,sH); // need this
				stage.width = sW;
				stage.height = sH;
				if (gpu) stage.updateViewport(sW/stage.scaleX, sH/stage.scaleY);
				zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
				zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
			}
			can.style.left = can.style.top = "0px";
			bRect = can.getBoundingClientRect();
			that.x = bRect.x + zim.browserScrollX();
			that.y = bRect.y + zim.browserScrollY();
			setVisible();
			return;
		}
		// scaling and positioning for fit and outside
		newH = sH * that.scale;
		newW = sW * that.scale;

if (retina) {
			pRatio = WW.devicePixelRatio || 1;
			that.scale *= pRatio;
			can.width = sW*that.scale;
			can.height = sH*that.scale;
			can.style.width = (sW*that.scale/pRatio)+'px';
			can.style.height = (sH*that.scale/pRatio)+'px';
			if (stage) {
				stage.scaleX = stage.scaleY = that.scale;					
			}
		} else {
			if (stage) stage.scaleX = stage.scaleY = 1;
			can.style.width = newW + "px";
			can.style.height = newH + "px";
		}
		if (stage) {
			stage.tickOnUpdate = false;
			stage.update();
			stage.tickOnUpdate = true;
		}
		if (align=="left") that.x = 0;
		else if (align=="right") that.x = (w-newW);
		else that.x = ((w-newW)/2);
		if (valign=="top") that.y = 0;
		else if (valign=="bottom") that.y = (h-newH);
		else that.y = ((h-newH)/2);
		can.style.left = that.x + "px";
		can.style.top = that.y + "px";
		if (!allowDefault) {
			zim.browserScrollX(0);
			zim.browserScrollY(0);
		}
		setVisible();

if (stage) {
			zim.scaX = createjs.stageTransformable ? 1 : stage.scaleX;
			zim.scaY = createjs.stageTransformable ? 1 : stage.scaleY;
		}
	}
	var s = m.reverse().join("");
		
	this.update = function() {
		sizeCanvas();
		that.dispatchEvent("update");
	};

// ASSETS
	this.loadAssets = function(assets, path, progress, xhr, time, loadTimeout, outputAudioSprite, crossOrigin, fileType, queueOnly, maxConnections, maxNum) {
		if (zot(assets)) return endEarly();
		if (zot(assets.src)) { // might be sending single parameter of asset object or audiosprite
			var sig = "assets, path, progress, xhr, time, loadTimeout, outputAudioSprite, crossOrigin, fileType, queueOnly, maxConnections, maxNum";
			var duo; if (duo = zob(that.loadAssets, arguments, sig)) return duo;
		}

if (!zot(path) && path.replace) {
			path = path.replace(/\/$/,"");
			path = path + "/";
			WW.PATH = path;
		} 
		// else if (!zot(WW.PATH)) path = WW.PATH;		
		var timeType = getTIME(time?time:null);
		if (!zot(progress) && progress.type == "ProgressBar" && zot(xhr)) xhr = true;
		if (zot(xhr)) xhr = true;
		if (!Array.isArray(assets)) assets = [assets];
		if (assets.length == 0) return endEarly();
		function endEarly() {
			var queue = new zim.Queue();
			queue.isLoading = false;
			queue.loadAssetsCount = 0;
			setTimeout(function () {
				queue.dispatchEvent("complete");
				that.dispatchEvent("complete");
			}, 10);
			return queue;
		}
		if (zot(time)) time = 0;
		if (zot(loadTimeout)) loadTimeout = timeType=="s"?8:8000;
		if (zot(outputAudioSprite)) outputAudioSprite = false;
		if (zot(crossOrigin)) crossOrigin = "anonymous";
		if (zot(queueOnly)) queueOnly = false;
		if (zot(maxConnections)) maxConnections = defaultMaxConnections;
		if (zot(maxNum)) maxNum = that.maxNum;

var soundCheck = false;
		var manifest = [];
		var a, ext, i, j, obj;
		var re = /\.([^.]+)$/i; // get extension		
		var fonts = [];
		var googleFonts = [];
		var imagesNoCORS = [];
		var mainCount = 0;
		var firstSoundCheck = true;
		
		// 018 TRYING TO FIX CREATEJS ERROR IF SOUND LOADED AGAIN - BUT BREAKS LAZY LOAD
		// var emptyAssets = false;

for (i=0; i<assets.length; i++) {			
			a = assets[i];	
			// if (zim.assets[a]) {
			// 	// 018 TRYING TO FIX CREATEJS ERROR IF SOUND LOADED AGAIN - BUT BREAKS LAZY LOAD
			// 	// if (assets.length==1) {
			// 	// 		emptyAssets = true;
			// 			// continue;
			// 	// }
			// }
            if (a.replace) a = a.replace(/gf_/i, "https://fonts.googleapis.com/css?family=");			
			// split multi into individual ZIM asset objects and make the first of these
			if (a.assets) {				
				var assetMulti = [];
				assets.splice(i, 1); 
				if (!Array.isArray(a.assets)) a.assets = [a.assets];
				for (j=0; j<a.assets.length; j++) {
					var aj = a.assets[j];
					if (aj.split) {
						var temp = aj.split("?");
						ext = temp[0].match(re);
					}							
					if (ext && fontTypes.indexOf(ext[1]) >= 0) {
						fonts.push((a.path?a.path:"")+aj);
					} else if (aj.match && aj.match(/fonts\.googleapis\.com/i)) {
						googleFonts.push(aj);
					} else if (aj.font) {
						if (aj.src) aj.src = (a.path?a.path:"")+aj.src;
						else aj.font = (a.path?a.path:"")+aj.font;
						fonts.push(aj);
					} else if (zim.assetIDs[aj]) {
						assetMulti.push({id:a.path+aj, src:a.path+aj, path:null, loadTimeout:a.loadTimeout, maxNum:a.maxNum, noCORSonImage:a.noCORSonImage});
					} else if (aj.audioSprite) {	
						// ZIM 018 attempted patch for audioSprite not working in multi-assets object
						// tried passing path but it substitutes it somewhere with the default path - boo
						// so tried what was used with assetIDs above and it still does it.
						// assetMulti.push({id:a.path+aj.src, src:a.path+aj.src, path:null, audioSprite:aj.audioSprite, data:aj.data, loadTimeout:a.loadTimeout, maxNum:a.maxNum, noCORSonImage:a.noCORSonImage});
						assetMulti.push({id:aj.src, src:aj.src, path:aj.path, audioSprite:aj.audioSprite, data:aj.data, loadTimeout:a.loadTimeout, maxNum:a.maxNum, noCORSonImage:a.noCORSonImage});
					} else {
						assetMulti.push({id:aj, src:aj, path:a.path, loadTimeout:a.loadTimeout, maxNum:a.maxNum, noCORSonImage:a.noCORSonImage});
					}
				}
				for (var k=assetMulti.length-1; k>=0; k--) {
					assets.splice(i, 0, assetMulti[k]);
				}
				a = assetMulti[0];
				if (a==undefined) continue;
			}

// catch {src} without id and just replace it with src unless google font
			if (a.constructor == {}.constructor) {
				var propCount = 0;
				for (var prop in a) {
					propCount++;
				}
				if (propCount==1 && a.src && !a.src.match(/fonts\.googleapis\.com/i)) a = a.src;
			}
							
			// normal processing
			var manObj;
			if (a.constructor == {}.constructor) {	
				if (a.audioSprite) {
					obj = zim.copy(a);
					a = obj.src;
					prepareLoad(a);
					var replacement = [];
					var r;
					for (j=0; j<obj.audioSprite.length; j++) {
						r = obj.audioSprite[j];
						replacement.push({id:r[0], startTime:Math.round(r[1]*1000), duration:Math.round((r[2]-r[1])*1000)});
					}
					delete(obj.audioSprite); // the ZIM data
					obj.data = {audioSprite:replacement}; // the CreateJS data					
					manifest.push(obj);
				} else if (a.data && a.data.audioSprite) { // CreateJS AudioSprite
					obj = zim.copy(a);
					a = obj.src;
					prepareLoad(a);
					manifest.push(obj);
				} else if (a.id || a.path) { // ZIM asset object	
					if (!a.id) a.id = a.src;									
					if (a.path) {
						a.path = a.path.replace(/\/$/,"");
						a.path = a.path + "/";
						var url, found;						
						if (a.path.match(/http/i)) {
							a.src = a.path+a.src;
						} else if (a.path.match(/^\//)) {
							// file:///E:/danzen/code/test/sound.html
							// https://zimjs.com/parallax.html
							url = WW.location.href;
							// putting ? after .* makes it not hungry
							// so find first non repeating / and that is root
							found = url.match(/(.*?)([^/])\/[^/]/);								
							url = found[1]+found[2];
							a.src = url+a.path+a.src;
						} else {							
							var pname = WW.location.pathname;							
							url = WW.location.href;
							var fileOnly = url.split(pname)[0] + pname;
							found = fileOnly.match(/(.*)\//);
							a.path = a.path.replace(/^\.\//,"");
							var goBack = a.path.match(/\.\.\//g);s
							var pref = found[1];
							if (goBack) {
								for (z_i=0; z_i<goBack.length; z_i++) {
									var spl = pref.split("/");
									spl.pop();
									pref = spl.join("/");
								}
								a.path = a.path.replace(/\.\.\//g, "");
							}							
							a.src = pref+"/"+a.path + a.src;
						}
						delete a.path;
					}

if (a.noCORSonImage) {
						var img = new Image();
						imagesNoCORS.push(img);
						img.src = a.src;
						img.id = a.id;
						var ev;
						img.onload = function(e) {
							var img = e.currentTarget; // bug fixed in Cat 02 patch
							var asset = zim.assets[img.id] = new zim.Bitmap({image:img, style:false}).expand(0);
							ev = new createjs.Event("assetload");
							if (asset && typeof asset != "string" && typeof asset != "number") {
								asset.file = img.id;		
								asset.src = img.src;		
							}
							ev.asset = asset;
							queue.dispatchEvent(ev);
							if (!queueOnly) {
								ev = new createjs.Event("assetload");
								ev.asset = asset;
								that.dispatchEvent(ev);
							}
							queue.loadAssetsCount--;
							if (queue.loadAssetsCount == 0) endAssetLoad();
						}
					} else {	
						zim.assetIDs[a.id] = a.src;
						var mn = a.maxNum;
						if (zot(mn)) mn = maxNum;
						var aType = a.type;
						var aLoadTimeout = zot(a.loadTimeout)?loadTimeout:a.loadTimeout;
						
						a = a.src;
						prepareLoad(a);
						manObj = {src:a, loadTimeout:aLoadTimeout*(timeType=="s"?1000:1), data:mn, type:aType};
						if (!zot(fileType)) manObj.type = fileType;
						manifest.push(manObj);						
					}
				} else { // ZIM font object
					if (a.src && a.src.match(/fonts\.googleapis\.com/i)) googleFonts.push(a);
					else fonts.push(a);
				}
			} else {	
				// check for font - ZIM ZIM 02 		
				var exten = prepareLoad(a);
				if (exten && fontTypes.indexOf(exten[1]) >= 0) {
					fonts.push(a);
					mainCount--;
				} else if (a.match(/fonts\.googleapis\.com/i)) {
					googleFonts.push(a);
					mainCount--;
				} else {					
					manObj = {src:a, loadTimeout:loadTimeout*(timeType=="s"?1000:1), data:maxNum};
					if (!zot(fileType)) manObj.type = fileType;
					manifest.push(manObj);
				}
			}
			if (soundCheck && firstSoundCheck) {
				// dynamically make audio tag with sound to overcome some Apple devices not playing sounds
				var audioTag = document.createElement("audio");
				audioTag.setAttribute("src", ((!zot(path) && !a.match(/^http:\/\/|https:\/\/|file:\/\//i))?path:"")+a);
				document.body.appendChild(audioTag);
				firstSoundCheck = false;
			}
		} // end loop

function prepareLoad(a) {
			ext = null;			
			if (a.split) {
				var temp = a.split("?");
				ext = temp[0].match(re);
				if (ext && createjs.Sound.SUPPORTED_EXTENSIONS.indexOf(ext[1]) >= 0) soundCheck = true;
			}
			mainCount++;
			return ext;
		}
		
		that.loadAssetsCount++;
		that.isLoading = true;
		var queue = new zim.Queue();
		queue.isLoading = true;
		queue.loadAssetsCount = 0;

if (!zot(progress) && progress.show) {
			progress.zimActiveLoader = queue;
            progress.show();
        }
		var fontLoader;
		if (fonts.length > 0) { // there are fonts to load
			// create manual list - which seems to always work
			var fontObjects = [];
			var fontObject;
			var fontData;
			for (i=0; i<fonts.length; i++) {
				fontData = fonts[i];
				if (fontData.font && !fontData.src) {
					fontData.src = fontData.font;
					fontData.font = fontData.font.split(".")[0];
					var ff = fontData.font.split("/");
					fontData.font = ff[ff.length-1];
				}
				if (typeof fontData == "string") {
					fontData = {font:fontData.split(".")[0], src:fontData};
				}
				fontObject = {
					src: "url("+(fontData.src.match(/\//i)?"":(path?path:""))+fontData.src+")" + (fontData.type?" format('"+fontData.type+"')":""),
					family: fontData.font
				};
				if (fontData.weight) fontObject.weight = fontData.weight;
				if (fontData.style) fontObject.style = fontData.style;
				fontObjects.push(fontObject);
			}
			fontLoader = new createjs.FontLoader({src:fontObjects}, true);
			fontLoader.on("complete", fontDone, null, null, null, null, mID);
			fontLoader.on("error", fontDone, null, null, null, null, mID);
			fontLoader.load();
			queue.loadAssetsCount++;
		}
		if (googleFonts.length > 0) { // there are google fonts to load
			for (i=0; i<googleFonts.length; i++) {
				fontData = googleFonts[i];
				if (typeof fontData == "string") {
					fontData = {src:fontData};
				}
				fontObject = {
					src: fontData.src,
					type: "fontcss"
				};
				queue.loadAssetsCount++; // each google font gets its own loader
				fontLoader = new createjs.FontLoader(fontObject, true);
				fontLoader.on("complete", fontDone, null, null, null, null, mID);
				fontLoader.on("error", fontDone, null, null, null, null, mID);
				fontLoader.load();
			}
		}
		function fontDone() {
			queue.loadAssetsCount--;
			if (queue.loadAssetsCount == 0) endAssetLoad();
		}

if (imagesNoCORS.length > 0) { // there are image tags loading to defeat CORS
			// loaded events are up above in loop
			for (i=0; i<imagesNoCORS.length; i++) {
				queue.loadAssetsCount++;
			}
		}
		
		function svgDone(bitmap, params) {	
			queue.loadAssetsCount--;
			var item = params.item;	
			var asset = zim.assets[item.id] = bitmap;	
			asset.src = item.src;
			asset.file = item.id;
			asset.item = item;
			asset.svg = params.svg; // add SVG to Bitmap as property
			var ev = new createjs.Event("assetload");
			ev.item = item; // createjs preload item
			ev.asset = asset;
			asset.type = "SVG";
			queue.dispatchEvent(ev);
			if (!queueOnly) {
				ev = new createjs.Event("assetload");
				ev.item = item;
				ev.asset = asset;
				that.dispatchEvent(ev);
			}				 
			if (queue.loadAssetsCount == 0) endAssetLoad();				 
		}

that.preloadEvent = preload.on("complete", function(e) {
				completeEventObject = e;
				queue.loadAssetsCount--;
				if (queue.loadAssetsCount == 0) endAssetLoad();
			}, null, null, null, null, mID);			
			try {preload.loadManifest(manifest);}catch(err){
				+function(){}()
			}
			// // strange - the try just stops an error but still loads
			// catch {
			// 	// setTimeout(function() {
			// 	// 	preload.loadManifest(manifest);
			// 	// }, 50);
			// }

} // end non font/noCORSonImage

// 018 TRYING TO FIX CREATEJS ERROR IF SOUND LOADED AGAIN - BUT BREAKS LAZY LOAD
		// // if calling an already preloaded asset
		// if (emptyAssets && queue.loadAssetsCount == 0) {			
		// 	endAssetLoad();
		// }

function endAssetLoad() {
			// setting a time will force the preload to wait at least this amount of time
			// this can be used for testing or if you always want time to show a loading message
			var endLoad = Date.now();
			time = Math.max(0, time-(endLoad-startLoad));
			setTimeout(function() {
				that.loadAssetsCount--;
				if (that.loadAssetsCount <= 0) that.isLoading = false;
				queue.isLoading = false;
				queue.dispatchEvent(completeEventObject);
				if (!zot(progress) && progress.show) progress.hide();
				if (!queueOnly) that.dispatchEvent(completeEventObject);
			}, time*(timeType=="s"?1000:1));
		}
		return queue;
	};

// called by asset if auto loading (ac is Asset Container)
	this.ac = function(method, args, obj) {			
		if (obj) {
			if (!obj.commands) obj.commands = [];
			obj.commands.push([method,args,obj]);
		} else {
			if (!args[0].commands) args[0].commands = [];
			args[0].commands.push([method,args]);
		}
	};

// create a global asset function
	// and a Frame asset method
	zim.asset = this.asset = function(n, w, h, maxNum, second) {
		if (zot(n)) return;
		n = zik(n);		
		var fromID = zim.assetIDs[n];
		if (fromID) n = fromID;
		
		// getting {type:"sound", path:"assets/", id:732}
		// want    {type:"sound", path:"assets/", id:"bird.mp3"}
		
		// items like json coming through without a type
		if (zim.assets[n] && (!zim.assets[n].type || (zim.assets[n].type && zim.assets[n].type.substr(0,2) != "AC"))) return zim.assets[n];
		// regular asset has been returned above
		// now check auto load assets or broken if second
		
		if (WW.PATH!=null) zim.PATH = WW.PATH;
		if (zim.PATH!=null && zim.PATH.replace) {
			zim.PATH = zim.PATH.replace(/\/$/,"");
			zim.PATH = zim.PATH + "/";
		}				
		if (second) {
			var empty;
			if (that.loadFailObj == "circles") empty = that.makeCircles(14);
			else empty = that.loadFailObj;
			if (empty) {
				empty.type = "EmptyAsset";
				empty.id = n;
				empty.play = function(){if (zon) {zogy("Frame - asset("+n+") not found"); return {};}};
			}
			return empty;
		} else {
			var assetHolder = new zim.Container(w, h);
			
			// added this to here as well as to complete event so that does not keep trying to load same asset ZIM NFT 01
			zim.assets[n] = assetHolder; 
			
			if (w && h) assetHolder.type = "ACWD"; // AssetContainer with Dimensions - does not recall methods
			else assetHolder.type = "AC"; // AssetContainer		
			
			var assetLoader = that.loadAssets({assets:n, path:n.split("/").length==1?zim.PATH:null, queueOnly:true, maxNum:maxNum});
			var parts = n.split(".");				
			if (createjs.Sound.SUPPORTED_EXTENSIONS.indexOf(parts[parts.length-1]) >= 0) {				
				assetHolder.play = function() {
					assetHolder.playParams = arguments;
					assetHolder.proxy = new createjs.EventDispatcher();
					Object.defineProperty(assetHolder.proxy, 'volume', {
						get: function() {
							if (assetHolder.sound) return assetHolder.sound.volume;
							else return null;
						},
						set: function(value) {
							assetHolder.volume = value;
							if (assetHolder.sound) assetHolder.sound.volume = value;
						}
					});
					Object.defineProperty(assetHolder.proxy, 'pan', {
						get: function() {
							if (assetHolder.sound) return assetHolder.sound.pan;
							else return null;
						},
						set: function(value) {
							assetHolder.pan = value;
							if (assetHolder.sound) assetHolder.sound.pan = value;
						}
					});
					Object.defineProperty(assetHolder.proxy, 'paused', {
						get: function() {
							if (assetHolder.sound) return assetHolder.sound.paused;
							else return null;
						},
						set: function(value) {
							assetHolder.paused = value;
							if (assetHolder.sound) assetHolder.sound.paused = value;
						}
					});
					Object.defineProperty(assetHolder.proxy, 'position', {
						get: function() {
							if (assetHolder.sound) return assetHolder.sound.position;
							else return null;
						},
						set: function(value) {
							assetHolder.position = value;
							if (assetHolder.sound) assetHolder.sound.position = value;
						}
					});
					Object.defineProperty(assetHolder.proxy, 'duration', {
						get: function() {
							if (assetHolder.sound) return assetHolder.sound.duration;
							else return null;
						},
						set: function(value) {
							zogy("ZIM Aud - duration is read only");
						}
					});
					return assetHolder.proxy;
				}
			}				
			assetLoader.on("complete", function () {
													
				// thanks Xuntar for the adjustment Cat 03
				// to handle lazy-load with asset({id:"etc", src:"https:domain/etc.png"});
				if (n.id) n = n.id; 
				else if (n.src) n = n.src;							
				var loaded = that.asset(n, null, null, null, true);

// create an image function
	// that uses CORS busting and then calls asset()
	zim.image = function(n, w, h, maxNum, second) {
		if (n.match(/^htt/i)) n = "https://cors.zimjs.com/" + n;
		return zim.asset(n, w, h, maxNum, second);
	};

zim.zimObjectIDs = {};
	zim.object = this.object = function(name) {
		return zim.zimObjectIDs[name];
	};
	zim.object.getNames = function() {
		var names = [];
		for (var name in zim.zimObjectIDs) {
			names.push(name);
		}
		return names;
	};

if (!WW.zns) {
		WW.asset = this.asset;
		WW.image = zim.image;
		WW.object = this.object;
	}

this.setDefault = function() {
		WW.zimDefaultFrame = WW.zdf = WW.F = that;
		WW.S = stage;
		WW.W = stage.width;
		WW.H = stage.height;
		return that;
	};

Object.defineProperty(that, 'isDefault', {
		get: function() {
			return WW.zdf == that;
		},
		set: function() {
			zogy("Frame(): isDefault is read only - see setDefault()");
		}
	});

Object.defineProperty(that, 'stage', {
		get: function() {
			return stage;
		},
		set: function() {
			zogy("Frame(): stage is read only - see remakeCanvas(), perhaps");
		}
	});

Object.defineProperty(that, 'width', {
		get: function() {
			return sW;
		},
		set: function() {
			zogy("Frame(): width is read only - see remakeCanvas(), perhaps");
		}
	});

Object.defineProperty(that, 'height', {
		get: function() {
			return sH;
		},
		set: function() {
			zogy("Frame(): height is read only - see remakeCanvas(), perhaps");
		}
	});

Object.defineProperty(this, 'color', {
		get: function() {
			return color;
		},
		set: function(value) {
			color = value;
			if (!zot(value)) {
				that.canvas.style.backgroundColor = color;
				// zid(canvasID).style.backgroundColor = color;
				if (!zot(color) && gpu) stage.setClearColor(zim.convertColor(color));
			} else {
				// zid(canvasID).style.backgroundColor = "default";
				that.canvas.style.backgroundColor = "default";
			}
		}
	});

var _outerColor;
	Object.defineProperty(this, 'outerColor', {
		get: function() {
			return _outerColor;
		},
		set: function(value) {
			_outerColor = value;
			zet("body").css({backgroundColor:_outerColor});
		}
	});

Object.defineProperty(that, 'allowDefault', {
		get: function() {
			return allowDefault;
		},
		set: function(t) {
			if (t) {
				stage.preventSelection = false;
				document.body.style.overflow = "visible";
				if (that.zil) {
					WW.removeEventListener("keydown", that.zil[0]);
					WW.removeEventListener("wheel", that.zil[1]);
					WW.removeEventListener("DOMMouseScroll", that.zil[2]);
					that.zil = null;
				}
			} else {
				stage.preventSelection = true;
				stage.enableDOMEvents(true);
				if (scaling == "full" || scaling == "fit" || scaling == "fill") document.body.style.overflow = "hidden";
				if (zot(that.zil)) that.zil = zil();
			}
			allowDefault = t;
			if (stage.__touch) stage.__touch.preventDefault = !allowDefault;
		}
	});

Object.defineProperty(that, 'touch', {
		get: function() {
			return touch;
		},
		set: function(value) {
			touch = value;
			createjs.Touch.disable(that.stage);			
			if (touch) {				
				createjs.Touch.enable(that.stage, singleTouch); // true for single touch, false for multitouch
			}			
		}
	});

Object.defineProperty(that, 'singleTouch', {
		get: function() {
			return singleTouch;
		},
		set: function(value) {
			singleTouch = value;
			touch = true;
			createjs.Touch.disable(that.stage);		
			createjs.Touch.enable(that.stage, singleTouch); // true for single touch, false for multitouch						
		}
	});

// CURSOR SYSTEM WITH CUR()
	// added ZIM 014

var cursors;	
	Object.defineProperty(that, 'cursors', {
		get: function() {
			return cursors;
		},
		set: function(obj) {
			cursors = obj && obj.constructor=={}.constructor ? obj : null;
			if (cursors) addCursors(cursors); 
			else removeCursors();
		}
	});

that.cursorTypes = [
		"none", "auto", "pointer", "text", "wait", "crosshair", "default", "help", "move", "progress", "e-resize", "ne-resize", "nw-resize", "n-resize", "se-resize", "sw-resize", "s-resize", "w-resize",
		"context-menu", "cell", "vertical-text", "alias", "copy", "no-drop", "not-allowed", "ew-resize", "ns-resize", "nesw-resize", "nwse-resize", "col-resize", "row-resize", "all-scroll", "grab", "grabbing", "zoom-in", "zoom-out"
	];

that.cursorList = new zim.Dictionary(true); // keep track of items with cur() added	- true for unique

function addCursors(obj) {
		zim.loop(obj, function (name, val) {
			if (val.noMouse) val.noMouse(); // turn mouse off on custom cursor
		});

if (that.pme) removeCursors();
		
		zim.loop(that.cursorList, function(key) {
			// only update if not already adjusted otherwise could overwrite none as desired cursor value
			if (!key._cursor && key.cursor && obj[key.cursor]) {
				key._cursor = key.cursor;
				that.cursorList.add(key, key._cursor); // will overwrite default true value with cursor type as string
				key.cursor = "none";
			}
		});
		
	 	if (obj["default"]) document.body.style.cursor = "none";

that.pme = that.on("pointermove", function(e) {			
			// move the cursor object and update stage if not already a Ticker
			// zog("here", that.cursorObj)
			if (!that.cursorObj) return;

// handle touchscreen not getting mouseover - sigh
			var oldCursor = that.cursorObj;
			var co = that.stage.getObjectUnderPoint(that.mouseX, that.mouseY, 1);
			while (co && !(co._cursor || co.cursor)) {
				co = co.parent;
			}
			if (co && (co._cursor || co.cursor)) {
				setCustom(co);
			} else if (obj["default"]) {
				setCursor("none");
				that.cursorObj = obj["default"];
				obj["default"].addTo(that.stage);
			} else {
				setCursor();
			}
			if (that.cursorObj != oldCursor && oldCursor.removeFrom) oldCursor.removeFrom();			
			if (!that.cursorObj) return;
			that.cursorObj.x = that.mouseX;
			that.cursorObj.y = that.mouseY;
			that.cursorObj.top();
			if (!zim.Ticker.isUpdating(that.stage)) that.stage.update();
		}, null, null, null, null, mID);

function doCursor(newCursor) {
			setCursor("none");
			that.cursorObj = newCursor;
			that.cursorObj.x = that.mouseX;
			that.cursorObj.y = that.mouseY;
			that.cursorObj.mouseChildren = false;
			that.cursorObj.mouseEnabled = false;
			that.cursorObj.addTo(that.stage);
		}

that.pee = that.on("pointerenter", function(e) {
			if (firstSet) {
				firstSet = false;
				return;
			}
			setTimeout(function() {
				// may be starting on an object with a cursor
				var co = that.stage.getObjectUnderPoint(that.mouseX, that.mouseY, 1);
				while (co && !(co._cursor || co.cursor)) {
					co = co.parent;
				}
				if (co && (co._cursor || co.cursor)) return;
				if (obj["default"]) {
					doCursor(obj["default"]);
				} else {
					setCursor();
				}
				that.stage.update();
			}, 50);        
		}, null, null, null, null, mID);	
		that.smo = that.stage.on("mouseover", function(e) {
			setCustom(e.target);				
		}, null, null, null, null, mID);

that.ple = that.on("pointerdown", function(e) {
			if (that.cursorObj) {
				zim.interval(.001, function(){ // to over top drag
					if (that.cursorObj) that.cursorObj.top();
					that.stage.update();
				}, 2, true, null, null, null, null, null, mID, that);
			}
		}, null, null, null, null, mID);
		that.pde = that.on("pointerleave", function(e) {
			firstSet = false;
			if (that.cursorObj) that.cursorObj.removeFrom();
			that.stage.update();
		}, null, null, null, null, mID);
		
		that.smu = that.stage.on("mouseout", function(e) {
			if (that.cursorObj) that.cursorObj.removeFrom();
			if (obj["default"]) {
				doCursor(obj["default"]);
			} else {
				setCursor();
			}
		}, null, null, null, null, mID);		
	}

function removeCursors() {

if (that.pme) that.off("pointermove", that.pme, null, mID);
		if (that.pee) that.off("pointerenter", that.pee, null, mID);	
		if (that.ple) that.off("pointerdown", that.ple, null, mID);
		if (that.pde) that.off("pointerleave", that.pde, null, mID);
		if (that.smo) that.stage.off("mouseover", that.smo, null, mID);
		if (that.smu) that.stage.off("mouseout", that.smu, null, mID);
		that.pme = that.pee = that.ple = that.pde = that.smo = that.smu = null;

zim.loop(that.cursorList, function(key, val) {	
			if (val !== true) key.cursor = val;
			key._cursor = null;
		});
		zim.loop(that.cursorList, function(key) {		
			that.cursorList.add(key, true); 
		});
		
		if (that.cursorObj) {
			that.cursorObj.dispose();
			that.cursorObj = null;
			that.stage.update();
		}
		setCursor();
	}
	function setCursor(type) {
		if (type != "none") that.cursorObj = null;
		if (that.canvas.parentElement) that.canvas.parentElement.style.cursor = type||"default";
	}

// END CURSOR SYSTEM

function contextEvent(e) {
		that.dispatchEvent(e);
	}
	WW.addEventListener("contextmenu", contextEvent, false);

var eDown = new createjs.Event("keydown");
	this.downEventRemove = eDown.remove;
	function keydownEvent(e) {
		e.remove = that.downEventRemove;
		that.altKey = e.altKey;
		that.ctrlKey = e.ctrlKey;
		that.metaKey = e.metaKey;
		that.shiftKey = e.shiftKey;
		if (e.altKey && e.key=="ArrowLeft") WW.history.back();
		if (e.altKey && e.key=="ArrowRight") WW.history.forward();
		that.dispatchEvent(e);
	}
	// var realWindow = window.parent || window;
	WW.addEventListener("keydown", keydownEvent);

this.remakeCanvas = function(width, height) {
		if (scaling == "full") return;
		if (zot(width)) width = sW;
		if (zot(height)) height = sH;
		if (zid(canvasID)) zid(canvasID).parentNode.removeChild(zid(canvasID));
		sW = width;
		sH = height;
		var onStage = [];
		for (var i=0; i<that.stage.numChildren; i++) {
			onStage.push(that.stage.getChildAt(i));
		}
		makeCanvas();
		makeStage();
		for (i=0; i<onStage.length; i++) {
			that.stage.addChild(onStage[i]);
		}
	};

this.follow = function(obj, boundary, damp, dampY, leftOffset, rightOffset, upOffset, downOffset, offsetDamp, offsetDampY, horizontal, vertical, borderLock, lag) {
		var sig = "obj, boundary, damp, dampY, leftOffset, rightOffset, upOffset, downOffset, offsetDamp, offsetDampY, horizontal, vertical, borderLock, lag";
		var duo; if (duo = zob(that.follow, arguments, sig)) return duo;
		that.followObj = null;
		if (that.followTicker) zim.Ticker.remove(that.followTicker, mID, that);
		if (zot(obj)) return;
		obj.dirX = obj.dirY = 0;
		that.followObj = obj;
		obj.followDampX = null;
		obj.followDampY = null;
		if (zot(boundary)) boundary = new zim.Boundary(0,0,that.stage.width,that.stage.height);
		that.followBoundary = boundary;
		if (zot(damp)) damp = .05;
		if (zot(dampY)) dampY = damp;
		if (zot(leftOffset)) leftOffset = 0;
		if (zot(rightOffset)) rightOffset = 0;
		if (zot(upOffset)) upOffset = 0;
		if (zot(downOffset)) downOffset = 0;
		if (zot(offsetDamp)) offsetDamp = .02;
		if (zot(offsetDampY)) offsetDampY = offsetDamp;
		if (zot(horizontal)) horizontal = true;
		if (zot(vertical)) vertical = true;
		if (zot(borderLock)) borderLock = false;
		if (zot(lag)) lag = false;

if (!obj.parent) obj.on("added", good, null, null, null, null, mID);
		else good();
		function good() {
			var container = obj.parent;
			that.frameBorderLock = borderLock;
			if (horizontal) {
				that.followDampX = new zim.Damp(container.x,damp);
				that.offsetDampX = new zim.Damp(boundary.x+leftOffset+(boundary.width-leftOffset-rightOffset)/2, offsetDamp);
			}
			if (vertical) {
				that.followDampY = new zim.Damp(container.y,dampY);
				that.offsetDampY = new zim.Damp(boundary.y+upOffset+(boundary.height-upOffset-downOffset)/2,offsetDampY);
			}
			that.followTicker = zim.Ticker.add(function () {
				var boundary = that.followBoundary;
				if (horizontal) {
					var midH = boundary.x+leftOffset+(boundary.width-leftOffset-rightOffset)/2;
					that.followOffsetX = [lag?boundary.x+boundary.width-leftOffset:midH, midH, lag?boundary.x+leftOffset:midH];
					if (that.followObj) container.x = that.followDampX.convert(that.offsetDampX.convert(that.followOffsetX[obj.motionController?obj.motionController.dirX+1:1])-obj.x);
				}
				if (vertical) {
					var midV = boundary.y+upOffset+(boundary.height-upOffset-downOffset)/2;
					that.followOffsetY = [lag?boundary.y+boundary.height-downOffset:midV, midV, lag?boundary.y+upOffset:midV];
					if (that.followObj) container.y = that.followDampY.convert(that.offsetDampY.convert(that.followOffsetY[obj.motionController?obj.motionController.dirY+1:1])-obj.y);
				}

if (that.frameBorderLock) {
					if (container.x > that.followBoundary.x) container.x = that.followBoundary.x;
					if (container.y > that.followBoundary.y) container.y = that.followBoundary.y;
					if (container.x < (that.followBoundary.x + that.followBoundary.width - container.width)) container.x = (that.followBoundary.x + that.followBoundary.width - container.width);
					if (container.y < (that.followBoundary.y + that.followBoundary.height - container.height)) container.y = (that.followBoundary.y + that.followBoundary.height - container.height);
				}
			}, null, mID, that);
		}
		return obj;
	};
	
	// Fixed in ZIM 014 to 
	if (zot(zim.blurCheck)) zim.setBlurDetect(); // added in ZIM NFT 01 for tabfocus and tabblur events

this.keyboardMessage = function(color, backgroundColor, message, response, percent, call) {
		var sig = "color, backgroundColor, message, response, percent, call";
		var duo; if (duo = zob(that.keyboardMessage, arguments, sig)) return duo;
		if (zot(color)) color = zim.yellow;
		if (zot(backgroundColor)) backgroundColor = "black";
		if (zot(message)) message = "PRESS SCREEN FOR KEYBOARD CONTROL";
		if (zot(response)) response = "YOU HAVE KEYBOARD CONTROL";
		if (zot(percent)) percent = 80;
		function inIframe () {
			try {
				return window.self !== window.top;
			} catch (e) {
				return true;
			}
		}
		var inFrame = inIframe();
		if (inFrame) that.canvas.style.pointerEvents = "none";

if (message != "") {
			var message = new zim.Label({
				text:message, 
				size:40, 
				color:color, 
				backgroundColor:backgroundColor,
				paddingV:15,
				paddingH:30,
				shiftV:1,
				align:CENTER
			})
				.scaleTo(that.stage,percent)
				.ske(10)
				.reg(CENTER)
				.pos(0,50,CENTER,BOTTOM)
		}
		document.addEventListener("mousedown", kmd);
		document.addEventListener("pointerdown", kmd);
		function kmd () {
			if (inFrame) that.canvas.style.pointerEvents = "auto"; 
			document.removeEventListener("mousedown", kmd);
			document.removeEventListener("pointerdown", kmd);			
			if (message != "") {
				message.text = response;
				message.animate({
					props:{alpha:0}, 
					wait:1,
					call:function() {message.dispose(); message=null;}
				});
				that.stage.update();
			}
			if (call && typeof call == "function") call();
			that.dispatchEvent("keyboardactive");
		}
		return message==""?null:message;
	}

this.dispose = function() {

// Handle three and physics
		createjs.removeRemotePointers(that.stage);
		if (zim.TAM) zim.TAM.dispose();
		zim.TAM = null;	
        if (WW.zimDefaultThree && WW.zimDefaultThree.dispose && WW.zimDefaultThree.frame==that) {
			WW.zimDefaultThree.dispose(); 		
			WW.zimDefaultThree = null;
		}
		if (WW.zimDefaultPhysics && WW.zimDefaultPhysics.dispose && WW.zimDefaultPhysics.frame==that) {
			WW.zimDefaultPhysics.dispose(); 
			WW.zimDefaultPhysics = null;
		}

// remove zil events
		if (that.zil && that.zil.length) {
			WW.removeEventListener("keydown", that.zil[0]);
			WW.removeEventListener("wheel", that.zil[1]);
			WW.removeEventListener("DOMMouseScroll", that.zil[2]);
		}
		if (canvas) canvas.removeAllEventListeners(null, mID);
		if (that.frameTime) clearInterval(that.frameTime);
		
		// remove frame events
		// var realWindow = window.parent || window;
		if (shimResizeEvent) WW.removeEventListener('resize', shimResizeEvent);
		WW.removeEventListener('resize', windowResizeEvent);
		WW.removeEventListener("contextmenu", contextEvent); 
		WW.removeEventListener("keydown", keydownEvent); // thanks Reinout Mechant for the fix!
		WW.removeEventListener("keyup", keyupEvent);
		WW.removeEventListener("wheel", wheelEvent);
		if (that.zimDevicemotionEvent) WW.removeEventListener("devicemotion", that.zimDevicemotionEvent);
		if (that.zimDeviceorientationEvent) WW.removeEventListener("deviceorientation", that.zimDeviceorientationEvent);
		
		WW.removeEventListener("pointerdown", leftEvent, true);
		WW.removeEventListener("pointermove", leftEvent, true); 
		WW.removeEventListener("pointerup", leftEvent);	
						
		if (!allowDefault) document.body.style.overflow = "athatuto";
		recursiveDispose(stage);
		function recursiveDispose(obj) {
			if (!obj) return;
			if (obj.dispose) obj.dispose();
			else {
				obj.removeAllEventListeners(null, mID);
				if (obj.numChildren) {
					for (var i=obj.numChildren-1; i>=0; i--) {
						recursiveDispose(obj.getChildAt(i));
					}
				}
				if (obj.parent) obj.parent.removeChild(obj);
			}
			obj = null;
		}
		if (zid(canvasID)) zid(canvasID).parentNode.removeChild(zid(canvasID));
		zim.Ticker.dispose(stage);
		if (that == zim.tickerFrame) zim.tickerFrame = null;
		if (that === WW.zdf) WW.zdf = WW.S = WW.W = WW.H = null;

stage = null;
		that = null;
		return true;
	};

// zim colors - legacy
	// have been removed as they are stored on zim or global

this.makeCircles = function(radius, multiple) {
		if (zot(radius)) radius = 100;
		var colors = [zim.orange, zim.green, zim.pink, zim.blue, zim.brown, zim.dark];
		var c, i;
		if (multiple) {
			c = new zim.Container({style:false});
			c.radius = radius;
			for (i=0; i<colors.length; i++) {
				c.addChild(new zim.Circle((c.radius/colors.length)*(colors.length-i), colors[i], null, null, null, null, null, null, null, false));
			}
		} else {
			c = new zim.Shape({style:false});
			var g = c.graphics;
			c.radius = radius;
			for (i=0; i<colors.length; i++) {
				g.f(colors[i]).dc(0,0,(c.radius/colors.length)*(colors.length-i));
			}
			c.setBounds(-c.radius,-c.radius,c.radius*2,c.radius*2);
		}
		return c;
	};

this.madeWith = function(color, text, edges, box, slats, borderColor, borderWidth) {
		var sig = "color, text, edges, box, slats, borderColor, borderWidth";
		var duo; if (duo = zob(that.madeWith, arguments, sig)) return duo;
		
		if (zot(color)) color = zim.dark;
		if (zot(text)) text = "Made with ZIM";

var madeWith = new zim.Container();
		var icon = madeWith.icon = that.makeIcon(edges, box, slats, borderColor, borderWidth)
			.sca(.5).alp(.92).hov(1).addTo(madeWith)
			.tap(function () {
				icon.alp(.92);
				icon.stage.update();
				zgo("https://zimjs.com", "_blank");
			});
		madeWith.label = new zim.Label(text, 16, null, color).sca(.7).pos(0, -19, zim.CENTER, zim.BOTTOM, madeWith);
		return madeWith;
	};

this.makeIcon = function(edges, box, slats, borderColor, borderWidth) {
		var sig = "edges, box, slats, borderColor, borderWidth";
		var duo; if (duo = zob(that.makeIcon, arguments, sig)) return duo;
		var icon = new zim.Container(-20, -13, 102, 120).reg(-20,-13);
		if (zot(edges)) edges = zim.light;			
		if (zot(box)) box = zim.dark;
		if (slats === true) slats = [zim.silver, zim.silver, zim.silver, zim.silver, zim.silver];
		else if (!zot(slats) && !Array.isArray(slats)) slats = [slats, slats, slats, slats, slats, slats];
		new zim.Rectangle(icon.width, icon.height, box, borderColor, borderWidth).loc(-20,-13,icon);

var data = [
			[slats?slats[0]:"#E474C3", "AieA0IAAgCIAmhlIEXAAIg5Bng", 41.7, 19.5],
			[slats?slats[1]:"#50C5B7", "AiSAzIAnhlID+AAIg5Blg", 35.3, 33.2],
			[slats?slats[2]:"#F48E25", "AiFA0IAmhnIDlAAIg5Bng", 28.9, 46.7],
			[slats?slats[3]:"#EBCD36", "Ah4AzIAmhlIDLAAIg5Blg", 22.4, 60.5],
			[slats?slats[4]:"#ABD140", "AhrA0IAAgFIAlhiICxAAIg5Bng", 16.1, 74.3],
			[edges, "AlGHRIAnhnIH+AAIgbBngAlGlpIAnhnIJmAAIg5Bng", 32.7, 46.5],
		];
		zim.loop(data, function (d) {
			var shape = new zim.Shape().addTo(icon);
			shape.graphics.f(d[0]).p(d[1]);
			shape.setTransform(d[2],d[3]);
		});
		icon.mouseChildren = false;
		return icon;
	};

this.makeAbstract = function(color) { // undocumented		
		if (zot(color)) color = "black";	
		var data = [
			[115.8,103.55, "#4ACBEB","Am6GkIAAtHIN0AAIAAClIrZAAIAAKig"],
			[127.55,73.3, "#A1E543","AAjLSIAAp6IEiAAIAAJ6gAlELOIAAp2IEiAAIAAJ2gAlEihIAAowIKEAAIAAIwg"],
			[32.55,73.05, "#B545E4","Ak6LQIAA2fIJ1AAIAAWfg"]
		];
		var icon = new zim.Rectangle(200,200,color);
		zim.loop(data, function (d) {
			var s = new zim.Shape().f(d[2]).p(d[3]);
			s.setTransform(d[0]+20,d[1]+27);
			s.addTo(icon);
		}, true);
		var container = new zim.Container();
		icon.sca(.4).addTo(container)
		container.mouseChildren = false;
		return container;
	}

this.makeCat = function(height) {
	if (zot(height)) height = 246;
	var data = [
	[16.95,241.15, 0,"black",[1.5,2,1],"AgKAhIAVhB"],
	[58.65,244.378,0,"#A7A7A7",[3,2,1],"AmYAAIMxAB"],
	[105.64,107.14,"#EF7988",0,0,"AAEArQgNAAgjghQgiggAFgIQAFgJBEgCQBEgDAGAGQAHAIgfAkQgfAlgPAAIAAAAg"],
	[104.84,111.34,0,"black",[1,1,1],"AABA2IAPAYQAJAPAJAGQAKAHAMAAQAbAAAXgWQAQgPAVghQAVghAAgcQAAgnglgYQgbgSgxgCIgrACAAJADIgIAzAhphVQgXAVgMAWQgKAQgIAiQgIAkAFAMQALAfAqAOQAmANAcgIQANgEANgQQALgNAGgT"],
	[105.05,111.4,"#757B74",0,0,"AheBrQgvgRgQgeQgPgdAQgkQAZg8AEgFQAXgfA8gGQBVgKA+ATQBRAZgYBEQgVA/gnAZQgUAOgZAKQgJAJgVgbQgUgegCAAQgDAAgWAgQgWAUgZAAQgMAAgNgEg"],
	[86.18,93,"black",0,0,"Aj7g0QiYg0i9AyQA0g3BcgRQBagQBfAaQBkAbBEBBQBNBHASBpQhgiYibg0gAFxiDQAzgdA6AMQA9AMA2A4QgHgBAAACQAAAAgBABQAAAAAAAAQgBAAgBAAQAAAAgBgBQh8gshOAzQhIAvhBCYQALjABzhCg"],
	[78.5,63.23,"#705F6C","black",[1,1,1],"AHAg5IgNmIIBfGpQgOgQgSgMQgjgXgPASgAKeDZQg2g4g9gMQg6gMgzAdQhzBCgLDBQBBiZBIgvQBNgzB9AsQAEACAAgCQAAgCAHABgAqdBuIAAnsIDmHEQgegMgsgBQhXgChFA3gAoEDzQA0g3BdgRQBagQBeAaQBkAbBFBBQBMBIASBpQhfiYibg1QiYg0i+Ayg"],
	[86.28,98.01,"black","black",[1,1,1],"AJSh/QgEADgHgDQgFgBgBAFQgNBXhNA9QhTBEhagZQgGgCgPAFQgUAHgEAAQCNAeBchOQBGg7AWhigApRhnQAFABAIAAQAGABAAAAQBFBsCVA7QCpBDCrgzQACAAAHAJQAEAFAFAJQjAAzitg/Qing9g/iHg"],
	[96.95,97.3,"#0C0436",0,0,"AlZBJQgVgVAAgeQAAgcAVgVQAVgVAeAAQAdAAAVAVQAVAVAAAcQAAAegVAVQgVAVgdAAQgeAAgVgVgAD1AcQgVgVAAgdQAAgdAVgVQAVgVAeAAQAdAAAVAVQAVAVAAAdQAAAdgVAVQgVAVgdAAQgeAAgVgVg"],
	[96.88,97.2,"#EA9424",0,0,"AlpBYQgbgbAAgnQAAglAbgbQAbgbAnAAQAmAAAbAbQAbAbAAAlQAAAngbAbQgbAbgmAAQgnAAgbgbgADnArQgbgbAAgmQAAgmAbgbQAbgbAmAAQAnAAAbAbQAbAbAAAmQAAAmgbAbQgbAbgnAAQgmAAgbgbg"],
	[96.88,97.2,"#AFCE3A",0,0,"AlzBiQgggfAAgtQAAgrAggfQAfggAtAAQAsAAAgAgQAfAfAAArQAAAtgfAfQggAggsAAQgtAAgfgggADcA1QgfgfAAgsQAAgsAfgfQAgggAsAAQAtAAAfAgQAgAfAAAsQAAAsggAfQgfAggtAAQgsAAggggg"],
	[78.5,64.1,0,"black",[1,1,1],"AHAhCIgNmIIBfGpQgOgQgSgMQgjgXgPASgAKeDQQg2g4g9gMQg6gMgzAdQhzBCgLDBQCqAvBlhgQBJhFAGhagAoADiQAlgiBTgOQBYgOBaARQDrAsA0DTQjAAziog/Qihg+hAiIgAqdBlIAAnsIDmHEQgegMgsgBQhXgChFA3g"],
	[86.375,93.9,"#EACE35",0,0,"AltB+Qiig9g/iIQAkghBTgOQBZgPBaARQDrAtA0DRQhWAXhSAAQhkAAhcgjgADxB2QALjABzhBQAzgeA6AMQA9ANA2A4QgGBYhJBGQhEBAhiAAQgxAAg4gQg"],
	[73.45,154.83,"black","black",[2,1,1],"AkjjDIByAMQB/ANBEAFQB/AICXgSIgKFzQj4hflLiNQgDgBAFiag"],
	[79.42,123.62,"#A7A7A7","black",[2,1,1],"AEBpxIgBgBQAYiNAeiQQA8kgAfgMQAggNBLEqQAlCVAfCXIAXARQAbAXAZAcQBQBZAZBnQAZBngUB+QgKA/gPArQgeASgrAWQhYAuhFAXQg8AUh0AWIhoASIAAQzItygCQAvhKA1hoQBqjRAjiXQAri/AOjLIAFimQgegHhTgeQhEgZhgg/IhTg7QgekPgQkUQggonBEgWQBFgWCbEtQAkBGA3B9QAbA9AYA3QASAqAQAmIgjhQIABAAIJmgYIBUACIBQAK"]
	];
	var catIcon = new zim.Container(157.5,246);
	zim.loop(data, function (d) {
	var s = new zim.Shape().f(d[2]).s(d[3]).ss(d[4]?d[4][0]:null, d[4]?d[4][1]:null, d[4]?d[4][2]:null).p(d[5]);
	s.setTransform(d[0],d[1]);
	s.addTo(catIcon);
	}, true);
	var container = new zim.Container();
	catIcon.sca(height/246).addTo(container).mov(0,-.4);
	if (mobile) {
		container.cache();
		container.setBounds(0,0,157.5*catIcon.scale,246*catIcon.scale);
	}
	container.mouseChildren = false;
	return container;
	};
};
zim.extend(zim.Frame, createjs.EventDispatcher, null, "cjsEventDispatcher", false);

zim.Queue = function() {
	// internal usage only by Frame
	this.cjsEventDispatcher_constructor();
	this.type = "Queue";

// MONITOR	
	this.mID = "z~"+this.type;
	
	this.isLoading = true; // thanks Frank Los for the suggestion.
};
zim.extend(zim.Queue, createjs.EventDispatcher, null, "cjsEventDispatcher");

return zim;
} (zim || {});

function zimify(obj, a, b, c, d, list) {
		
	if (obj && obj.noDrag) return obj;
	if (list !== true) list = null;

if (zim) {
		// adjust localToGlobal, etc.
		obj.cjsLocalToGlobal = obj.localToGlobal; // store the original methods
		obj.cjsGlobalToLocal = obj.globalToLocal;
		obj.cjsLocalToLocal = obj.localToLocal;
		obj.localToGlobal = function(x,y) {
			return zim.localToGlobal(x,y,obj,obj.cjsLocalToGlobal); // call the ZIM methods
		};
		obj.globalToLocal = function(x,y) {
			return zim.globalToLocal(x,y,obj,obj.cjsGlobalToLocal);
		};
		obj.localToLocal = function(x,y,target) {
			return zim.localToLocal(x,y,target,obj);
		};
		
		// ZIM DisplayObjects already have these
		// includes width, height, etc.
		if (!obj.hueBatch) zim.displayBase(obj);
	}
		
	if (!zot(a) && !zot(b) && !zot(c) && !zot(d)) {
		a = a;
	} else if (!zot(a) && !zot(b)) {
		c=a; 
		d=b;
		a=0;
		b=0;
	} 
	if (!zot(a) && !zot(b) && !zot(c) && !zot(d)) {
		obj.setBounds(a,b,c,d);
	} else if (obj.nominalBounds != null && obj.getBounds && obj.getBounds()==null) {
		var n = obj.nominalBounds;	
		obj.setBounds(n.x,n.y,n.width,n.height);
	}
	if (obj.parent && obj.parent.actionFrames && !obj.parent.addPhysics) {
		zimify(obj.parent, zdf?zdf.width:null, zdf?zdf.height:null);		
	}
	
	return obj;

}

function zimplify(exclude) {

document.Window = Window;
	document.Blob = Blob;

if (zot(exclude)) exclude = [];
	if (!Array.isArray(exclude)) exclude = [exclude];
	var methods = zimify(null, null, null, null, null, true); // get list of zim methods
	var exceptions = ["loop", "stopAnimate", "pauseAnimate", "animate", "wiggle", "wire", "wired"];
	for (var command in zim) {
		if ((methods.indexOf(command) == -1 || exceptions.indexOf(command) >= 0) && exclude.indexOf(command) == -1) {			
			window[command] = zim[command];
		}
	}	
}
var zim = function(zim) {

zim.setBlurDetect = function() {
	
	zim.blurCheck = true;
	zim.pauseAnimateOnBlur = true;
	zim.pauseOnBlur = [];
	zim.blurDetect = (function(){
		var stateKey,
			eventKey,
			keys = {
					hidden: "visibilitychange",
					webkitHidden: "webkitvisibilitychange",
					mozHidden: "mozvisibilitychange",
					msHidden: "msvisibilitychange"
		};
		for (stateKey in keys) {
			if (stateKey in document) {
				eventKey = keys[stateKey];
				break;
			}
		}
		return function(c) {
			if (c) document.addEventListener(eventKey, c);
			return !document[stateKey];
		};
	})();

zim.blurDetect(function(){
		
		var i,obj,id;
		if(zim.blurDetect()){
			setTimeout(function(){		
				
				// coming back from blur into focus so set back animations									
				if (zim.pauseOnBlur) {					
					for (i=0; i<zim.pauseOnBlur.length; i++) {
						obj = zim.pauseOnBlur[i];
						if (!obj.pauseOnBlurPaused) obj.pause(false);
					}
				}
				if (zim.pauseAnimateOnBlur && zim.animatedObjects) {	
					var emitterCheck = [];
					var lastParent;
					for (i=0; i<zim.animatedObjects.objects.length; i++) {
						obj = zim.animatedObjects.objects[i];	
						var currentStates = zim.copy(obj.tweenStates);							
						if (!obj.tweenStates) {
							obj.pauseAnimate(false);
						} else if (zot(currentStates.all) || currentStates.all) {	
							obj.pauseAnimate(false);
							if (!obj.dynamicAnimation) {
								for (id in currentStates) {
									if (id=="all") continue;
									if (currentStates[id]===false) {
										obj.pauseAnimate(true, id);
									}
								}
							}
						} else {	
							obj.pauseAnimate(true);
							for (id in currentStates) {
								if (id=="all") continue;
								if (currentStates[id]) obj.pauseAnimate(false, id);
							}
						}	
						if (obj.type == "Sprite") obj.paused = true;
						if (
							obj.parent && 
							obj.parent.type == "Particles" 
							&& obj.parent.emitter 
							&& obj.parent.emitter.focusWarm
						) {
							lastParent = obj.parent.emitter;
							if (emitterCheck.indexOf(obj.parent.emitter) < 0) emitterCheck.push(obj.parent.emitter);
						}
					}
					if (emitterCheck.length>0) {
						for (i=0; i<emitterCheck.length; i++) {
							emitterCheck[i].doWarm(emitterCheck[i].focusWarm);
                            emitterCheck[i].clearPool();
						}
					}
				}
			},300);
			if (WW.zdf) WW.zdf.dispatchEvent("tabfocus");
		} else {
			
			// going out of focus so set pauses 
				
			if (zim.pauseOnBlur) {
				for (i=0; i<zim.pauseOnBlur.length; i++) {
					obj = zim.pauseOnBlur[i];
					obj.pauseOnBlurPaused = obj.paused;
					obj.pause(true);
				}
			}
			if (zim.pauseAnimateOnBlur && zim.animatedObjects) {
				// zim.loop(zim.animatedObjects.objects, function(obj) {
				// 	obj.pauseOnBlurPaused = obj.type=="Sprite"?obj.runPaused:obj.paused; 
				// });
				zim.pauseAnimate(true, "pauseOnBlur");
			}
			if (WW.zdf) WW.zdf.dispatchEvent("tabblur");
		}
	});

};
return zim;} (zim || {});
if (!window.zns && window.zimplify) zimplify();

Texte vergleichen

Anzeige

Verarbeitung

distill_difference