function bezierPoint(origin:Point, control:Point, end:Point, loc:Number):Point
{
	var p1:Point = Point.interpolate(origin, control, loc);
	var p2:Point = Point.interpolate(control, end, loc);
	var p:Point = Point.interpolate(p1, p2, loc);
	return p;
}
 
function endPoint(angle:Number, hypontinuse:Number, origin:Point):Point
{
	var ret:Point = new Point((Math.cos(angle)*hypontinuse)+ origin.x, (Math.sin(angle)*hypontinuse)+origin.y);
	return ret;
}
 
function controlPoint(origin:Point, hyp:Number, angle:Number):Point
{
	var a:Number = 3.14159265 + (angle + 1.57079633);
	var end:Point = endPoint(a , hyp, origin);
	return end
}
 
function drawBranch(origin:Point, angle:Number, size:Number, color:Number, childNo:Number):Array
{
	var returnData = new Array();
	var branch:Shape = new Shape();
	var end:Point = endPoint(angle, size, origin);
	var control:Point = controlPoint(Point.interpolate(origin,end,0.5), Point.distance(origin, end)/6, angle);
	branch.graphics.lineStyle(0, color);
	branch.graphics.beginFill(color,1)
	branch.graphics.moveTo(origin.x, origin.y);
	branch.graphics.curveTo(control.x, control.y, end.x, end.y);
	var thickEnd:Point = controlPoint(origin, ((size/100)*3)/childNo, angle);
	branch.graphics.curveTo(control.x, control.y, thickEnd.x, thickEnd.y);
	branch.graphics.lineTo(origin.x, origin.y);
	returnData.push(branch);
	returnData.push(control);
	returnData.push(end);
	return returnData;
 
}
 
function drawTree(origin, angle, size, depth, factor, fixedAngle, frequency, childNo):void
{
	if(depth <= 0)
		return;
	//draw branch
	var branch:Array = drawBranch(new Point(origin.x, origin.y), angle, size, 0x514837, childNo);
	holder.addChild(branch[0]);
	//find start, end, control
	for(var i:Number = 1; i <= frequency; i++)
	{
		var randSeed:Number = (Math.random()/2)+0.75;
		var frequencySeed:Number = Math.round(Math.random()*2)-1
		var newAngle:Number;
		if(i % 2 == 0)
			newAngle = (angle+fixedAngle)*randSeed;
		else
			newAngle = (angle-fixedAngle)*randSeed;
		var offset:Number = ((1/frequency)*i)-((1/frequency)/2);
		var newOrigin:Point = bezierPoint(origin, branch[1], branch[2], offset);
		drawTree(newOrigin, newAngle, size/factor, depth-1, factor, fixedAngle, frequency+frequencySeed, (frequency-i)+1);
	}
}
 
var p:Point = new Point(400,550);
drawTree(p, -1.5, 200, 8, 1.5, 0.7, 3, 1);
 
drawTreeBtn.addEventListener(MouseEvent.CLICK, createManager);
function createManager(event:MouseEvent):void
{
	var len = len.getLineText(0);
	var depth = dep.getLineText(0);
	var frequency = freq.getLineText(0);
	var factor = fac.getLineText(0);
	var angle = angle.getLineText(0);
        //fix for typing issues caused by input
	var length1:Number = new Number(len);
	var depth1:Number = new Number(depth);
	var frequency1:Number = new Number(frequency);
	var factor1:Number = new Number(factor);
	var angle1:Number = new Number(angle);
 
	for(var i:int = holder.numChildren-1; i >= 0; i--)
		holder.removeChildAt(i);
	drawTree(p, -1.5, length1, depth1, factor1, angle1, frequency1, 1);
}

/*
XmlSearch v.1.1
Author:Max Garfinkel
Last Revision: 05/07/2007
new methods added
 
Finds and returns attributes and node values from an xml object
 
public function are:
 
matchAttribute(xml:XML, attributeName:String, attributeValue:String):Boolean
returns true if there exists an attribute of attribute name with the value of attribute value in the xml.
 
getAttributes(xml:XML, searchterm:String, attributeName:String, recursive:Boolean):Array
returns array of 0-* elements containing the attributes attributeName, of node searchterm.
If recursive flag is set to false array will be of 0-1 length.
 
getNodeContent(xml:XML, searchterm:String, recursive:Boolean):Array
returns an array of 0-* elements containing the contents of node searchterm.
If recursive flag is set to false the array will be of 0-1 length.
 
getNodeContentXML(xml:XML, searchterm:String, recursive:Boolean):Array
returns an array of 0-* elements containing the contents of node searchterm.
If recursive flag is set to false the array will be of 0-1 length.
The data is returned as xml blocks within the array.
 
*/
 
class com.maxgarfinkel.data.XmlSearch
{
	private var returnData:Array;
 
		public XmlSearch(){}
 
		//checks if nodes attribute matches filter value
		public function matchAttribute(xml:XML, attributeName:String, attributeValue:String):Boolean
		{
			if(xml.attributes[attributeName].toString() == attributeValue)
				return true;
			else
				return false;
		}
 
        public function getAttributes(xml:XML, searchterm:String, attributeName:String, recursive:Boolean):Array
        {
                this.returnData = [];
                this.searchId(xml, searchterm, attributeName, recursive);
                return(returnData);
        }
 
        private function searchId(xml:XML, searchterm:String, attributeName:String, recursive:Boolean):Void
        {
                for(var i:Number = 0; i < xml.childNodes.length; i++)
                {
                        if(xml.childNodes[i].nodeName.toString() == searchterm)
                                this.returnData.push(xml.childNodes[i].attributes[attributeName]);
                        if(recursive == true)
                                this.searchId(xml.childNodes[i], searchterm, attributeName, recursive);
                }
        }
 
        //Returns xml node data as elements in a single array
        public function getNodeContent(xml:XML, searchterm:String, recursive:Boolean):Array
        {
		this.returnData = [];
                this.searchContent(xml, searchterm, recursive);
                return(returnData);
        }
	//Returns xml node data as xml elements in a single array
	public function getNodeContentXML(xml:XML, searchterm:String, recursive:Boolean):Array
        {
		this.returnData = [];
                this.searchContentReturnXml(xml, searchterm, recursive);
                return(returnData);
        }
 
        private function searchContent(xml:XML, searchterm:String, recursive:Boolean):Void
        {
                for(var i:Number = 0; i < xml.childNodes.length; i++)
                {
                        if(xml.childNodes[i].nodeName.toString() == searchterm)
				this.returnData.push(xml.childNodes[i].firstChild.nodeValue);
                        if(recursive == true)
                                this.searchContent(xml.childNodes[i], searchterm, recursive);
                }
        }
 
	private function searchContentReturnXml(xml:XML, searchterm:String, recursive:Boolean):Void
        {
                 for(var i:Number = 0; i < xml.childNodes.length; i++)
                {
                        if(xml.childNodes[i].nodeName.toString() == searchterm)
				this.returnData.push(xml.childNodes[i]);
                        if(recursive == true)
				this.searchContentReturnXml(xml.childNodes[i], searchterm, recursive);
                }
        }
}