[Dynapi-CVS] CVS: dynapi2x/src/fx bezier.js,NONE,1.1 circleanim.js,NONE,1.1 hoveranim.js,NONE,1.1 imganim.js,NONE,1.1 motionx.js,NONE,1.1 pathanim.js,NONE,1.1 pathanim_glide.js,NONE,1.1 pathanim_slide.js,NONE,1.1 thread.js,NONE,1.1 timerx.js,NONE,1.1

[Robert R. <rai...@us...>]

Update of /cvsroot/dynapi/dynapi2x/src/fx
In directory usw-pr-cvs1:/tmp/cvs-serv19326/src/fx

Added Files:
	bezier.js circleanim.js hoveranim.js imganim.js motionx.js 
	pathanim.js pathanim_glide.js pathanim_slide.js thread.js 
	timerx.js 
Log Message:
initial import


--- NEW FILE ---
// Bezier Algorithm Reference: http://astronomy.swin.edu.au/~pbourke/curves/bezier/

function Bezier(cp, n) {
	var l = cp.length;
	var p = [];
	for (var i=0; i<n; i++) p = p.concat(Bezier._plot(cp,i/n));
	return p.concat([cp[l-2],cp[l-1]]);
}

Bezier._plot = function (cp, mu) {
	var n = (cp.length/2)-1;
	var k,kn,nn,nkn;
	var blend;
	var b = [0,0];

	var muk = 1;
	var munk = Math.pow(1-mu, n);

	for (k=0;k<=n;k++) {
		nn = n;
		kn = k;
		nkn = n - k;
		blend = muk * munk;
		muk *= mu;
		munk /= (1-mu);
		while (nn >= 1) {
			blend *= nn;
			nn--;
			if (kn > 1) {
				blend /= kn;
				kn--;
			}
			if (nkn > 1) {
				blend /= nkn;
				nkn--;
			}
		}
		
		b[0] += cp[k*2] * blend;
		b[1] += cp[k*2+1] * blend;
	}
	b[0] = Math.round(b[0]);
	b[1] = Math.round(b[1]);
	return b;
}

/*function Bezier3(cp,mu) {
	var x1=cp[0],y1=cp[1],x2=cp[2],y2=cp[3],x3=cp[4],y3=cp[5];
	var mu2 = mu * mu;
	var mum1 = 1 - mu;
	var mum12 = mum1 * mum1;
	var x = Math.round(x1 * mum12 + 2 * x2 * mum1 * mu + x3 * mu2);
	var y = Math.round(y1 * mum12 + 2 * y2 * mum1 * mu + y3 * mu2);
	return [x,y];
}

function Bezier4(cp,mu) {
	var x1=cp[0],y1=cp[1],x2=cp[2],y2=cp[3],x3=cp[4],y3=cp[5],x4=cp[6],y4=cp[7];
 	var mum1 = 1 - mu;
	var mum13 = mum1 * mum1 * mum1;
	var mu3 = mu * mu * mu;
	var x = Math.round(mum13*x1 + 3*mu*mum1*mum1*x2 + 3*mu*mu*mum1*x3 + mu3*x4);
	var y = Math.round(mum13*y1 + 3*mu*mum1*mum1*y2 + 3*mu*mu*mum1*y3 + mu3*y4);
	return [x,y];
}*/

--- NEW FILE ---
/*
	DynAPI Distribution
	CircleAnimation Class

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: PathAnimation
*/

// You must add this to the DynAPI library if you want to include it via dynapi.library.include('CircleAnimation');
// dynapi.library.add('dynapi.fx.CircleAnimation','circleanim.js',['Thread','dynapi.functions']);

function CircleAnimation(dlyr) {
	this.inherit('Thread',dlyr);

	this.offsetX = 0;
	this.offsetY = 0;
	this.playing = false;
	this.radius = 100;
	this.angle = 0;
	this.setAngleIncrement(10);
}
dynapi.setPrototype('CircleAnimation','Thread');
CircleAnimation.prototype.setRadius = function (r) {
	this.hradius = this.vradius = r;
};
CircleAnimation.prototype.setHRadius = function (r) {
	this.hradius = r;
};
CircleAnimation.prototype.setVRadius = function (r) {
	this.vradius = r;
};
CircleAnimation.prototype.setAngle = function (a) {
	this.angle = dynapi.functions.degreeToRadian(a);
};
CircleAnimation.prototype.setAngleIncrement = function (inc) {
	this.angleinc = dynapi.functions.degreeToRadian(inc);
};
CircleAnimation.prototype.playAnimation = function () {
	this.playing = true;
	if (this.dlyr!=null) {
		this.offsetX = this.hradius*Math.cos(this.angle);
		this.offsetY = -this.vradius*Math.sin(this.angle);
		this.baseX = this.dlyr.x-this.offsetX;
		this.baseY = this.dlyr.y+this.offsetY;
		this.dlyr.invokeEvent("circlestart");
	}
	this.start();
};
CircleAnimation.prototype.stopAnimation = function () {
	this.playing = false;
	this.stop();
	if (this.dlyr!=null) this.dlyr.invokeEvent("circlestop");
};
CircleAnimation.prototype.run = function () {
	if (!this.playing || this.dlyr==null) return;	
	this.angle += this.angleinc;
	this.offsetX = this.hradius*Math.cos(this.angle);
	this.offsetY = -this.vradius*Math.sin(this.angle);

	if (this.dlyr!=null) {
		this.dlyr.invokeEvent("circlerun");
		this.dlyr.moveTo(this.baseX+this.offsetX,this.baseY+this.offsetY);
	}
};
CircleAnimation.prototype.reset = function () {
	this.angle = this.offsetX = this.offsetY = 0;
};
CircleAnimation.prototype.generatePath = function(centerX,centerY) {
	if (centerX==null) centerX = this.dlyr!=null? this.dlyr.x : 0;
	if (centerY==null) centerY = this.dlyr!=null? this.dlyr.y : 0;
	var path = [];
	var i = 0;
/*	for (var a=this.angle;a<=this.angle+Math.PI*2;a+=this.angleinc) {
		path[i] = Math.round(centerX + this.hradius*Math.cos(a));
		path[i+1] = Math.round(centerY - this.vradius*Math.sin(a));
		i+=2;
	}*/

	if (this.angleinc>0)
		for (var a=this.angle;a<=this.angle+Math.PI*2;a+=this.angleinc) {
			path[i] = Math.round(centerX + this.hradius*Math.cos(a));
			path[i+1] = Math.round(centerY - this.vradius*Math.sin(a));
			i+=2;
		}
	else
		for (var a=this.angle;a>=this.angle-Math.PI*2;a+=this.angleinc) {
			path[i] = Math.round(centerX + this.hradius*Math.cos(a));
			path[i+1] = Math.round(centerY - this.vradius*Math.sin(a));
			i+=2;
		}
	return path;
};

--- NEW FILE ---
/*
	DynAPI Distribution
	HoverAnimation Class

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: PathAnimation
*/

// You must add this to the DynAPI library if you want to include it via dynapi.library.include('HoverAnimation');
// dynapi.library.add('HoverAnimation','hoveranim.js','Thread','dynapi.fx');

function HoverAnimation(dlyr) {
	this.Thread = Thread;
	this.Thread(dlyr);

	this.offsetX = 0;
	this.offsetY = 0;
	this.playing = false;
	this.amplitude = 100;
	this.angle = 0;
	this.setAngleIncrement(10);
}
HoverAnimation.prototype = new Thread;
HoverAnimation.prototype.setAmplitude = function (amp) {
	this.amplitude = amp;
};
HoverAnimation.prototype.setAngle = function (a) {
	this.angle = PathAnimation.degreeToRadian(a);
};
HoverAnimation.prototype.setAngleIncrement = function (inc) {
	this.angleinc = PathAnimation.degreeToRadian(inc);
};
HoverAnimation.prototype.playAnimation = function () {
	this.playing = true;
	if (this.dlyr!=null) {
		this.offsetX = 0;
		this.offsetY = this.amplitude*Math.sin(this.angle);
		this.baseX = this.dlyr.x;
		this.baseY = this.dlyr.y+this.offsetY;
		this.dlyr.invokeEvent("hoverstart");
	}
	this.start();
};
HoverAnimation.prototype.stopAnimation = function () {
	this.playing = false;
	this.stop();
	if (this.dlyr!=null) this.dlyr.invokeEvent("hoverstop");
};
HoverAnimation.prototype.run = function () {
	if (!this.playing || this.dlyr==null) return;
	this.angle += this.angleinc;
	this.offsetX = 0;
	this.offsetY = this.amplitude*Math.sin(this.angle);
	if (this.dlyr!=null) {
		this.dlyr.invokeEvent("hoverrun");
		this.dlyr.moveTo(this.baseX+this.offsetX,this.baseY+this.offsetY);
	}
};
HoverAnimation.prototype.reset = function () {
	this.angle = this.offsetX = this.offsetY = 0;
};

HoverAnimation.prototype.generatePath = function(centerX,centerY) {
	// to do
};

--- NEW FILE ---
/*
	DynAPI Distribution
	ImageAnimation Class

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: Thread
*/

function ImageAnimation(dynimage) {
	this.Thread = Thread;
	this.Thread(dynimage);

	this.imgAnim = new Array();
	this.imgAnim.playing = null;
}
ImageAnimation.prototype = new Thread;
ImageAnimation.prototype.addAnimation = function (imgArray) {
	var animNum = this.imgAnim.length;
	this.imgAnim[animNum] = imgArray;
	this.imgAnim[animNum].loops = false;
	this.imgAnim[animNum].resets = false;
	this.imgAnim[animNum].frame = 0;
	this.imgAnim[animNum].playing = true;
	this.imgAnim[animNum].direction = 0;
	this.imgAnim[animNum].alternates = false;
	return animNum;
};
ImageAnimation.prototype.getFrame = function (animNum,frameNum) {
	return this.imgAnim[animNum][frameNum];
};

ImageAnimation.prototype.setLoops = function (animNum,loop) {
	this.imgAnim[animNum].loops = loop;
};
ImageAnimation.prototype.setResets = function (animNum) {
	this.imgAnim[animNum].resets = true;
};
ImageAnimation.prototype.setAlternates = function (animNum,alt) {
	this.imgAnim[animNum].loops = true;
	this.imgAnim[animNum].alternates = alt;
};

ImageAnimation.prototype.playAnimation = function (animNum) {
	if (animNum!=null && this.imgAnim.playing!=animNum) {
		this.playing = true;
		this.imgAnim.playing = animNum;
		if (this.dlyr!=null) this.dlyr.invokeEvent("imgstart");
		this.start();
	}
};
ImageAnimation.prototype.stopAnimation = function () {
	this.imgAnim.playing = null;
	this.playing = false;
	this.stop();
	if (this.dlyr!=null) this.dlyr.invokeEvent("imgrun");
};
ImageAnimation.prototype.run = function () {
	if (!this.playing || this.imgAnim.playing==null || this.dlyr==null) return;
	
	var anim = this.imgAnim[this.imgAnim.playing];
	
	if (anim.frame==0 && this.img==anim[anim.frame]) {
		anim.frame++;	// skip 1st frame if same
	}
	if (this.dlyr!=null) this.dlyr.invokeEvent("imgrun");
	this.dlyr.setImage(anim[anim.frame]);
	
	if (anim.frame>=anim.length-1) {
		if (anim.loops) {
			if (anim.alternates && anim.direction==0 && anim.frame==anim.length-1) {
				anim.direction = 1; 
				anim.frame = anim.length-2;
			}
			else anim.frame = 0;
		}
		else if (anim.resets) {
			anim.frame = 0;
			this.stop()
		}
		else {
			this.stop()
		}
	}
	else {
		if (anim.alternates) {
			if (anim.frame==0 && anim.direction==1) {
				anim.direction = 0;
				anim.frame = 1;
			}
			else if (anim.direction==0) {
				anim.frame++;
			}
			else if (anim.direction==1) {
				anim.frame--;
			}
		}
		else {
			anim.frame++;
		}
	}
};

--- NEW FILE ---
/*
	DynAPI Distribution
	MotionX Class by Raymond Irving (xw...@ya...)

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: Dynlayer
*/

DynLayer.prototype.makeSolid=function(){
	this.isHard=true
	this._collideX=this.x
	this._collideY=this.x
	this.collideEvent ={
		onmove:function(e) {
			var me=e.getSource()
			var dirX='',dirY=''
			// get direction
			if (me._collideX!=me.x) {
				if (me._collideX<me.x){dirX="E"}else{dirX="W"}
			}
			if (me._collideY!=me.y){
				if (me._collideY<me.y){dirY="S"}else{dirY="N"}
			}
			// get angle direction
			me._setCollideAngleDirection(me._collideX,me._collideY,me.x,me.y)
			me._collideX=me.x;
			me._collideY=me.y;
			me._collideDirection=dirY+dirX;
			me._checkForCollision();
		}
	}
	this.addEventListener(this.collideEvent)
}
DynLayer.prototype._setLocation=DynLayer.prototype.setLocation;
DynLayer.prototype.setLocation=function(x,y) {
	this._setLocation(x,y);
	this.invokeEvent('move');
}
DynLayer.prototype._setCollideAngleDirection = function(x1,y1,x2,y2) {
	var distx = (x2-x1),disty = (y1-y2),angle;
	//if (distx==0 && disty==0) return 0;
	var rad=Math.abs(Math.atan2(disty,distx))
	if (disty>=0) {
		if (distx>=0) angle = 90-(rad*180/Math.PI)
		else angle = 270+(180-(rad*180/Math.PI));
	}else{
		angle = 90+(rad*180/Math.PI)
	}
	this._collideAngle=Math.ceil(angle);
};
DynLayer.prototype._checkForCollision=function(){
	if (!this.parent.children.length>0) return false;
	var ch,chX,sX,sY,colX1,colX2,colY1,colY2,n1,n2;
	this.collideObject==null
	for (var i in this.parent.children) {
		ch=this.parent.children[i];
		if (ch!=this && ch.isHard==true) {
			chX=ch.x;
			chY=ch.y;
			sX=this.x;
			sY=this.y;
			colX1=(sX>=chX && sX<=chX+ch.w)
			colX2=(chX>=sX && chX<=sX+this.w)
			colY1=(sY>=chY && sY<=chY+ch.h)
			colY2=(chY>=sY && chY<=sY+this.h)
			if ((colX1 || colX2) && (colY1 || colY2)) {
				if (this._collideDirection=='NE') {
					n1=((chY+ch.h)-this.y);n2=((sX+this.w)-chX)
					if (n1<n2) {face="S"}else{face="W"}
				}else if (this._collideDirection=='NW') {
					n1=((chY+ch.h)-this.y);n2=((chX+ch.w)-sX)
					if (n1<n2) {face="S"}else{face="E"}
				}else if (this._collideDirection=='SE') {
					n1=((sY+this.h)-ch.y);n2=((sX+this.w)-chX)
					if (n1<n2) {face="N"}else{face="W"}
				}else if (this._collideDirection=='SW') {
					n1=((sY+this.h)-ch.y);n2=((chX+ch.w)-sX)
					if (n1<n2) {face="N"}else{face="E"}
				}else if (this._collideDirection=='E') {
					face="W"
				}else if (this._collideDirection=='W') {
					face="E"
				}else if (this._collideDirection=='N') {
					face="S"
				}else if (this._collideDirection=='S') {
					face="N"
				}

				ch._impactSide=face
				if (face=="W"){this._impactSide="E"}
				if (face=="E"){this._impactSide="W"}
				if (face=="N"){this._impactSide="S"}
				if (face=="S"){this._impactSide="N"}

				this._collideObject=ch
				this.invokeEvent("collide");
				ch._collideObject=this
				ch.invokeEvent("collide");
			}
		}
	}
	return false;
};
DynLayer.prototype.getImpactSide=function(){
	return this._impactSide;
}
DynLayer.prototype.getObstacle=function(){
	return this._collideObject;
}
DynLayer.prototype.getDirection=function(){
	return this._collideDirection;
}
DynLayer.prototype.getDirectionAngle=function(){
	return this._collideAngle;
}

--- NEW FILE ---
/*
	DynAPI Distribution
	PathAnimation Class

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: dynapi.fx.Thread
*/

function PathAnimation(dlyr) {
	this.inherit('Thread',dlyr);
	this.paths = new Array();
	this.pathPlaying = null;
}
var p = dynapi.setPrototype('PathAnimation','Thread');

p.add = function (path, loops, resets) {
	var n = this.paths.length;
	this.paths[n] = path;
	this.setLoops(n,loops);
	this.setResets(n,resets);
	this.setFrame(n,0);
	return n;
};
p.setLoops = function (n, loops) {
	this.paths[n].loops = (loops);
};
p.setResets = function (n, resets) {
	this.paths[n].resets = (resets);
};
p.setFrame = function (n, frame) {
	this.paths[n].frame = frame;
};
p.play = function (noevt) {
	if (!this.playing) {
		this.pathPlaying = null;
		if (arguments[0]==null) arguments[0] = 0;
		if (typeof(arguments[0]) == "number") {
			this.pathPlaying = this.paths[arguments[0]];
		}
		else if (typeof(arguments[0]) == "object") {  
			this.pathPlaying = arguments[0];
			this.pathPlaying.loops = arguments[1]||false;
			this.pathPlaying.resets = arguments[2]||false;
			this.pathPlaying.frame = 0;
		}
		this.playing = true;
		if (this.dlyr!=null && noevt!=false) this.dlyr.invokeEvent("pathstart");
		this.start();
	}
};
p._Thread_stop = Thread.prototype.stop;
p.stop = function (noevt) {
	if (this.pathPlaying && this.pathPlaying.resets && !this.cancelThread && this.dlyr!=null) this.dlyr.setLocation(this.pathPlaying[0],this.pathPlaying[1]);
	this._Thread_stop();
	this.pathPlaying = null;
	this.playing = false;
	if (this.dlyr!=null && noevt!=false) this.dlyr.invokeEvent("pathcancel");
};
p.run = function () {
	if (!this.playing || this.pathPlaying==null) return;
	var anim = this.pathPlaying;
	if (anim.frame>=anim.length/2) {
		if (anim.loops) {
			anim.frame = 0;
		}
		else if (anim.resets) {
			anim.frame = 0;
			if (this.dlyr!=null) this.dlyr.setLocation(anim[0],anim[1]);
			this.stop();
			this.dlyr.invokeEvent("pathfinish");
			return;
		}
		else {
			anim.frame = 0;
			this.stop();
			this.dlyr.invokeEvent("pathfinish");
			return;
		}
	}
	if (anim.frame==0 && (this.dlyr!=null && this.dlyr.x==anim[0] && this.dlyr.y==anim[1])) {
		anim.frame += 1;
	}
	this.newX = anim[anim.frame*2];
	this.newY = anim[anim.frame*2+1];
	
	if (this.dlyr!=null) {
		this.dlyr.invokeEvent("pathrun");
		this.dlyr.setLocation(this.newX,this.newY);
	}
	anim.frame++;
};

// Path Functions

// Combines separate [x1,x2],[y1,y2] arrays into a path array [x1,y1,x2,y2]
/*PathAnimation.interlace = function(x,y) {
	var l = Math.max(x.length,y.length);
	var a = new Array(l*2);
	for (var i=0; i<l; i++) {
		a[i*2] = x[i];
		a[i*2+1] = y[i];
	}
	return a;
};

// Returns correct angle in radians between 2 points
PathAnimation.getNormalizedAngle = function(x1,y1,x2,y2) {
	var distx = Math.abs(x1-x2);
	var disty = Math.abs(y1-y2);
	if (distx==0 && disty==0) angle = 0;
	else if (distx==0) angle = Math.PI/2;
	else angle = Math.atan(disty/distx);
	if (x1<x2) {
		if (y1<y2) angle = Math.PI*2-angle;
	}
	else {
		if (y1<y2) angle = Math.PI+angle;
		else angle = Math.PI-angle;
	}
	return angle;
};
*/

--- NEW FILE ---
/*
	DynAPI Distribution
	Glide Animation Extension

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: PathAnimation
*/

// To use on a DynLayer:
// dlyr.addMethod("glideTo",PathAnimation.glideTo);
// dlyr.addMethod("glideStop",PathAnimation.glideStop);
// dlyr.glideTo(x,y,"slow","slow",5,10);
// dlyr.glideStop();

// Or attach to all DynLayers or another class like this:
// DynLayer.prototype.glideTo = PathAnimation.glideTo;
// DynLayer.prototype.glideStop = PathAnimation.glideStop;

// These will invoke "pathstart", "pathrun", "pathfinish" and "pathcancel" events on the dynlayer

PathAnimation.glideTo = function(x2,y2,angleinc,ms,startSpeed,endSpeed) {
	if (!this._pathanim) this._pathanim = new PathAnimation(this);
	if (!ms) ms = 20;
	if (x2==null) x2 = this.x;
	if (y2==null) y2 = this.y;
	if (this.x==x2 && this.y==y2) return;
	this._pathanim.sleep(ms);
	this._pathanim.play( GlideAnimation(this.x,this.y,x2,y2,angleinc,startSpeed,endSpeed) );
};
PathAnimation.glideStop = function () {
	if (this._pathanim) this._pathanim.stop();
};

function GlideAnimation(x1,y1,x2,y2,angleinc,startSpeed,endSpeed) {
	var normAngle = PathAnimation.getNormalizedAngle(x1,y1,x2,y2);
	var distx = x2-x1;
	var disty = y2-y1;
	var distance = Math.sqrt(Math.pow(distx,2) + Math.pow(disty,2));
	angleinc = (angleinc==null)? 7 : Math.abs(angleinc);
	
	// a terrible mess but it works
	var r = 1;
	if (startSpeed == "fast") {
		var centerX = x1;
		var centerY = y1;
		var centerX2 = x2;
		var centerY2 = y2;
		startAngle = 0;
		endAngle = 90;
		if (endSpeed=="fast") distance = distance/2;
	}
	else {
		startAngle = -90;
		endAngle = 0;
		if (endSpeed == "fast") {
			var centerX = x1+distx;
			var centerY = y1+disty;
		}
		else {  // default slow,slow
			var centerX2 = x2-distx/2;
			var centerY2 = y2-disty/2;
			distance = distance/2;
			var centerX = x1+distx/2;
			var centerY = y1+disty/2;
			r = -1;
		}
	}

	var i,d,x,y,dx,dy,path=[];
	for (var a=startAngle; a<endAngle; a+=angleinc) {
		i = path.length;
		d = distance*Math.sin(a*Math.PI/180);
		path[i] = Math.round(centerX + d*Math.cos(normAngle));
		path[i+1] = Math.round(centerY - d*Math.sin(normAngle));
	}
	if (startSpeed==endSpeed) {
		for (var a=endAngle; a<endAngle+90; a+=angleinc) {
			i = path.length;
			d = distance*Math.sin(a*Math.PI/180);
			path[i] = Math.round(centerX2 - r*d*Math.cos(normAngle));
			path[i+1] = Math.round(centerY2 + r*d*Math.sin(normAngle));
		}
	}
	
	var l = path.length;
	if (path[l-2] != x2 && path[l-1]!=y2) {
		path[l] = x2;
		path[l+1] = y2;
	}
	return path;
};

PathAnimation.glide = GlideAnimation;

--- NEW FILE ---
/*
	DynAPI Distribution
	Slide Animation Extension

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: PathAnimation
*/

// To use on a DynLayer:
// dlyr.setMethod("slideTo",PathAnimation.slideTo);  // will overwrite the built in DynLayer.slideTo()
// dlyr.setMethod("slideStop",PathAnimation.slideStop);
// dlyr.slideTo(x,y,5,10);
// dlyr.slideStop();

// Or attach to all DynLayers or another class like this:
// DynLayer.prototype.glideTo = PathAnimation.glideTo;
// DynLayer.prototype.glideStop = PathAnimation.glideStop;

// These will invoke "pathstart", "pathrun", "pathfinish" and "pathcancel" events on the dynlayer

PathAnimation.slideTo = function(x,y,inc,ms) {
	if (!this._pathanim) this._pathanim = new PathAnimation(this);
	if (!ms) ms = 20;
	if (!inc) inc = 10;
	if (x==null) x = this.x;
	if (y==null) y = this.y;
	this._pathanim.sleep(ms);
	this._pathanim.play( SlideAnimation(this.x,this.y, x,y, inc) );
};
PathAnimation.slideStop = function () {
	if (this._pathanim) this._pathanim.stop();
};

// Generates a path between 2 points, stepping inc pixels at a time
function SlideAnimation(x1,y1,x2,y2,inc) {
	if (x2==null) x2 = x1;
	if (y2==null) y2 = y1;
	var distx = x2-x1;
	var disty = y2-y1;
	if (x1==x2 && y1==y2) return;
	var num = Math.sqrt(Math.pow(distx,2) + Math.pow(disty,2))/(inc||10)-1;
	var dx = distx/num;
	var dy = disty/num;
	var path = [];
	var x = x1;
	var y = y1;
	for (var i=0;i<=num;i++) {
		x += dx;
		y += dy;
		path[i*2] = Math.round(x);
		path[i*2+1] = Math.round(y);
	}
	if (path[i*2-2] != x2 || path[i*2-1] != y2) {
		path[i*2] = x2;
		path[i*2+1] = y2;
	}
	return path;
};
PathAnimation.line = SlideAnimation;

// a useful functions in some cases but not needed for slide

// Generates a path between 2 points in N steps
/*PathAnimation.lineN = function(x1,y1,x2,y2,N) {
	if (N==0) return [];
	var dx = (x2 == x1)? 0 : (x2 - x1)/N;
	var dy = (y2 == y1)? 0 : (y2 - y1)/N;
	var path = new Array();
	for (var i=0;i<=N;i++) {
		path[i*2] = Math.round(x1 + i*dx);
		path[i*2+1] = Math.round(y1 + i*dy);
	}
	return path;
};*/


--- NEW FILE ---
/*
	DynAPI Distribution
	Thread class

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: dynapi.api.DynLayer
*/

function Thread(dlyr) {
	// Inherit from object. Provides unique ID
	this.inherit('DynObject');
	this.setDynLayer(dlyr);
}
var p = dynapi.setPrototype('Thread','DynObject');
p.active = false;
p.interval = 50;
p.cancelThread = false;
p.sleep = function (ms) {
	this.interval = Math.abs(parseInt(ms));
	if (this.active) {
		this.stop();
		setTimeout(this+'.start()',this.interval+1);
	}
};
p.setFPS = function (fps) {
	this.sleep(Math.floor(1000/fps));
};
p.cancel = function () {
	this.cancelThread = true;
	this.stop();
};
p.start = function () {
	if (!this.active) {
		this.active = true;
		if (!this.cancelThread) this.timer = setInterval(this+'.run()',this.interval);
	}
};
p.run = dynapi.functions.Null; // overwrite run
p.stop = function () {
	this.active = false;
	if (!this.cancelThread && this.timer) {
		clearInterval(this.timer);
		delete this.timer;
	}
};
p.setDynLayer = function (dlyr) {
	this.dlyr = dlyr;
};
p.getDynLayer = function () {
	return this.dlyr;
};

--- NEW FILE ---
/*
	DynAPI Distribution
	TimerX Class by Raymond Irving (xw...@ya...)

	The DynAPI Distribution is distributed under the terms of the GNU LGPL license.

	requires: Dynlayer
*/

DynLayer.prototype.startTimer=function(interval) {
	if (this.tickTimer>0) this.stopTimer()
	this._timerInterval=interval||5
	this._timerTickCount=0
	this._timerStoped=false
	this._tickTimer=setTimeout(this+'.tickLoop()',this._timerInterval)
}
DynLayer.prototype.tickLoop=function() {
	if (this._timerStoped==true||this._timerStoped==null) return
	this._timerTickCount++;
	this.invokeEvent("timer")
	this._tickTimer=setTimeout(this+'.tickLoop()',this._timerInterval)
}
DynLayer.prototype.stopTimer=function() {
	this._timerStoped=true
	clearTimeout(this._tickTimer)
	status="stop"
}
DynLayer.prototype.setTimerInterval=function(interval) {
	this._timerInterval=interval||this._timerInterval
}
DynLayer.prototype.getTimerInterval=function() {
	return this._timerInterval
}
DynLayer.prototype.getTickCount=function() {
	return this._timerTickCount
}
DynLayer.prototype.resetTickCount=function() {
	this._timerTickCount=0
}