/**
*	com.jR.Drawing.Base
*	March 14th, 2006
*	Copyright (c) Jānis Radiņš ( janis@mediaverk.lv )
* 
*	This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
*	License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
* 
*	This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
*	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
* 
*	You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software
*	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/
import AsBroadcaster;
import mx.events.EventDispatcher;
import com.jR.Utils;
import com.jR.Drawing.TransformMatrix;
class com.jR.Drawing.Base {
	private var _mc:MovieClip;
	private var _x:Number = null;
	private var _y:Number = null;
	private var _visible:Boolean = null;
	//
	private var _autoClear:Boolean = true;
	private var _rotation:Number = 0;
	private var _skewX:Number = 0;
	private var _skewY:Number = 0;
	// line style settings
	private var _lineSize:Number = null;
	private var _lineRgb:Number = null;
	private var _lineAlpha:Number = null;
	// solid fill settings
	private var _fillRgb:Number = null;
	private var _fillAlpha:Number = null;
	// gradient fill settings
	private var _gradientType:String = null;
	private var _gradientColors:Array = null;
	private var _gradientAlphas:Array = null;
	private var _gradientRatios:Array = null;
	// gradient fill matrix settings
	private var _gradientMatrix_x:Number = null;
	private var _gradientMatrix_y:Number = null;
	private var _gradientMatrix_w:Number = null;
	private var _gradientMatrix_h:Number = null;
	private var _gradientMatrix_r:Number = null;
	// gradient fill matix auto generation settings
	private var _gradientX:Number = null;
	private var _gradientY:Number = null;
	private var _gradientWidth:Number = null;
	private var _gradientHeight:Number = null;
	private var _gradientRotation:Number = null;
	// minimal sector size for drawing circle
	private var minSectorSize:Number = 45;
	// functions required by AsBroadcaster
	public var addListener:Function;
	public var removeListener:Function;
	private var broadcastMessage:Function;
	// functions required by EventDispatcher
	public var addEventListener:Function;
	public var removeEventListener:Function;
	private var dispatchEvent:Function;
	// trace errors handler
	private var _traceErrors:Boolean = false;
	public function Base(Void) {
		AsBroadcaster.initialize(this);
		EventDispatcher.initialize(this);
	}
	public function get mc():MovieClip {
		return _mc;
	}
	public function get x():Number {
		return _mc._x;
	}
	public function get y():Number {
		return _mc._y;
	}
	public function get visible():Boolean {
		return _mc._visible;
	}
	public function get autoClear():Boolean {
		return _autoClear;
	}
	public function get rotation():Number {
		return _rotation;
	}
	public function get skewX():Number {
		return rad2deg(_skewX);
	}
	public function get skewY():Number {
		return rad2deg(_skewY);
	}
	public function get lineSize():Number {
		return _lineSize;
	}
	public function get lineRgb():Number {
		return _lineRgb === null ? 0x0 : _lineRgb;
	}
	public function get lineAlpha():Number {
		return _lineAlpha === null ? 100 : _lineAlpha;
	}
	public function get fillRgb():Number {
		return _fillRgb === null ? 0x0 : _fillRgb;
	}
	public function get fillAlpha():Number {
		return _fillAlpha === null ? 100 : _fillAlpha;
	}
	public function get gradientX():Number {
		return _gradientX;
	}
	public function get gradientY():Number {
		return _gradientY;
	}
	public function get gradientWidth():Number {
		return _gradientWidth;
	}
	public function get gradientHeight():Number {
		return _gradientHeight;
	}
	public function get gradientRotation():Number {
		return _gradientRotation;
	}
	public function get gradientType():String {
		return _gradientType === null ? "linear" : _gradientType;
	}
	public function get gradientColors():Array {
		return _gradientColors;
	}
	public function get gradientAlphas():Array {
		if (_gradientAlphas === null || _gradientAlphas.length<_gradientColors.length) {
			throwError("Fill Alphas array length is different that Fill Colors array length.\nModifying values to match!");
			var __return:Array = _gradientAlphas === null ? new Array() : _gradientAlphas.concat();
			while (__return.length<_gradientColors.length) {
				__return.push(100);
			}
			return __return;
		}
		return _gradientAlphas;
	}
	public function get gradientRatios():Array {
		if (_gradientRatios === null || _gradientRatios.length<_gradientColors.length) {
			throwError("Fill Ratios array length is different that Fill Colors array length.\nModifying values to match!");
			var __return:Array;
			var __increment, __incrementStep:Number;
			if (_gradientRatios === null) {
				__return = new Array();
				__increment = 0;
				__incrementStep = 255/(_gradientColors.length-1);
			} else {
				__return = _gradientRatios.concat();
				__incrementStep = (255-_gradientRatios[_gradientRatios.length-1])/(_gradientColors.length-_gradientRatios.length);
				__increment = _gradientRatios[_gradientRatios.length-1]+__incrementStep;
			}
			for (var i:Number = __return.length; i<_gradientColors.length; i++) {
				__return.push(Utils.roundTo(__increment, 2));
				__increment += __incrementStep;
			}
			return __return;
		}
		return _gradientRatios;
	}
	public function get gradientMatrix_x():Number {
		return _gradientMatrix_x;
	}
	public function get gradientMatrix_y():Number {
		return _gradientMatrix_y;
	}
	public function get gradientMatrix_w():Number {
		return _gradientMatrix_w;
	}
	public function get gradientMatrix_h():Number {
		return _gradientMatrix_h;
	}
	public function get gradientMatrix_r():Number {
		return _gradientMatrix_r;
	}
	public function get gradientMatrix():Object {
		var __x = gradientMatrix_x === null ? gradientX : gradientMatrix_x;
		var __y = gradientMatrix_y === null ? gradientY : gradientMatrix_y;
		var __w = gradientMatrix_w === null ? gradientWidth : gradientMatrix_w;
		var __h = gradientMatrix_h === null ? gradientHeight : gradientMatrix_h;
		var __r = gradientMatrix_r === null ? _gradientRotation : _gradientMatrix_r;
		if(__r != 0 && _gradientType == "radial"){
			var __mat:TransformMatrix = new TransformMatrix();
			__mat.scale(__w, __h);
			__mat.rotate(__r);
			__mat.translate(__x, __y);
			return __mat;
		}
		return {matrixType:"box", x:__x, y:__y, w:__w, h:__h, r:deg2rad(__r)};
	}
	public function get traceErrors():Boolean {
		return _traceErrors;
	}
	public function set x(value:Number):Void {
		_mc._x = value;
	}
	public function set y(value:Number):Void {
		_mc._y = value;
	}
	public function set visible(value:Boolean):Void {
		_mc._visible = value;
	}
	public function set autoClear(value:Boolean):Void {
		_autoClear = value;
	}
	public function set rotation(value:Number):Void {
		_rotation = value;
	}
	public function set skewX(value:Number):Void {
		_skewX = value > -90 && value < 90 ? deg2rad(value) : 0;
	}
	public function set skewY(value:Number):Void {
		_skewY = value > -90 && value < 90 ? deg2rad(value) : 0;
	}
	public function set lineSize(value:Number):Void {
		_lineSize = value !== null ? value : null;
	}
	public function set lineRgb(value:Number):Void {
		_lineRgb = value;
	}
	public function set lineAlpha(value:Number):Void {
		_lineAlpha = value;
	}
	public function set fillRgb(value:Number):Void {
		_fillRgb = value;
	}
	public function set fillAlpha(value:Number):Void {
		_fillAlpha = value;
	}
	public function set gradientType(value:String):Void {
		_gradientType = value == "radial" || value == "linear" ? value : null;
	}
	public function set gradientColors(value:Array):Void {
		_gradientColors = value instanceof Array == false ? null : value;
	}
	public function set gradientAlphas(value:Array):Void {
		_gradientAlphas = value instanceof Array == false ? null : value;
	}
	public function set gradientRatios(value:Array):Void {
		_gradientRatios = value instanceof Array == false ? null : value;
	}
	public function set gradientMatrix(value:Object):Void {
		for (var i in value) {
			if (this["_gradientMatrix_"+i] !== undefined) {
				this["gradientMatrix_"+i] = value[i];
			}
		}
	}
	public function set gradientMatrix_x(value:Number):Void {
		_gradientMatrix_x = value;
	}
	public function set gradientMatrix_y(value:Number):Void {
		_gradientMatrix_y = value;
	}
	public function set gradientMatrix_w(value:Number):Void {
		_gradientMatrix_w = value;
	}
	public function set gradientMatrix_h(value:Number):Void {
		_gradientMatrix_h = value;
	}
	public function set gradientMatrix_r(value:Number):Void {
		_gradientMatrix_r = value;
	}
	public function set traceErrors(value:Boolean):Void {
		_traceErrors = value;
	}
	public function lineStyle(__lineSize:Number, __lineRgb:Number, __lineAlpha:Number):Void {
		lineSize = isNaN(__lineSize) == true ? null : __lineSize;
		lineRgb = isNaN(__lineRgb) == true ? null : __lineRgb;
		lineAlpha = isNaN(__lineAlpha) == true ? null : __lineAlpha;
	}
	private function applyLineStyle(forceOutline:Boolean):Void {
		if (_lineSize !== null) {
			_mc.lineStyle(lineSize, lineRgb, lineAlpha);
		} else if (forceOutline == true) {
			_mc.lineStyle(1, 0x0, 100);
		} else {
			resetLineStyle();
		}
	}
	private function resetLineStyle(Void):Void {
		_mc.lineStyle(undefined, undefined, undefined);
	}
	private function beginFill(Void):Void {
		_mc.beginFill(fillRgb, fillAlpha);
	}
	private function endFill(Void):Void {
		_mc.endFill();
	}
	private function beginGradientFill(Void):Void {
		if (gradientColors === null || gradientColors.length == 0) {
			throwError("No colors for gradient fill!");
			return;
		}
		_mc.beginGradientFill(gradientType, gradientColors, gradientAlphas, gradientRatios, gradientMatrix);
	}
	public function clear(Void):Void {
		_mc.clear();
	}
	public function reset(Void):Void {
		_autoClear = true;
		_rotation = 0;
		_skewX = 0;
		_skewY = 0;
		_lineSize = null;
		_lineRgb = null;
		_lineAlpha = null;
		_fillRgb = null;
		_fillAlpha = null;
		_gradientType = null;
		_gradientColors = null;
		_gradientAlphas = null;
		_gradientRatios = null;
		_gradientMatrix_x = null;
		_gradientMatrix_y = null;
		_gradientMatrix_w = null;
		_gradientMatrix_h = null;
		_gradientMatrix_r = null;
		_gradientX = null;
		_gradientY = null;
		_gradientWidth = null;
		_gradientHeight = null;
		_gradientRotation = null;
	}
	private function deg2rad(angle:Number):Number {
		return angle*(Math.PI/180);
	}
	private function rad2deg(angle:Number):Number {
		return angle*(180/Math.PI);
	}
	private function getAnchorHeight(angle:Number, radius:Number):Number {
		var cathetus:Number = radius*(Math.sin(deg2rad(90-angle/2))/Math.sin(Math.PI/2));
		return Utils.roundTo(radius*2-cathetus, 3);
	}
	private function getSectorPoints(startAngle:Number, endAngle:Number, radius:Number):Array {
		startAngle = (startAngle+360)%360;
		endAngle = (endAngle+360)%360;
		var __angles:Array = new Array();
		__angles.push(startAngle);
		var distance:Number = angleDelta(startAngle, endAngle);
		for (var i:Number = 1; i<Math.floor(distance/minSectorSize); i++) {
			__angles.push((startAngle+minSectorSize*i+360)%360);
		}
		__angles.push(endAngle);
		var __return:Array = new Array();
		__return.push(rotatePoint(radius, 0, startAngle));
		var __anchor:Number;
		var __delta:Number;
		for (var i:Number = 1; i<__angles.length; i++) {
			__delta = angleDelta(__angles[i-1], __angles[i]);
			__return.push(rotatePoint(getAnchorHeight(__delta, radius), 0, __angles[i-1]+__delta/2));
			__return.push(rotatePoint(radius, 0, __angles[i]));
		}
		return __return;
	}
	private function rotatePoint(__x:Number, __y:Number, __angle:Number):Object {
		var radius:Number = Math.sqrt(Math.pow(__x, 2)+Math.pow(__y, 2));
		var angle:Number = Math.atan2(__y, __x)+deg2rad(__angle);
		return {x:Utils.roundTo(radius*Math.cos(angle), 3), y:Utils.roundTo(radius*Math.sin(angle), 3)};
	}
	private function angleDelta(angle1:Number, angle2:Number):Number {
		angle1 %= 360;
		angle2 %= 360;
		if (angle1 == angle2) {
			return 360;
		}
		if (angle1>angle2) {
			return 360-angle1+angle2;
		}
		return angle2-angle1;
	}
	public function initMouseEvents(pointer:Boolean):Void {
		_mc.useHandCursor = Boolean(pointer);
		_mc.onDragOut = Utils.delegate(this, onMouseEvent, "onDragOutDraw");
		_mc.onDragOver = Utils.delegate(this, onMouseEvent, "onDragOverDraw");
		_mc.onPress = Utils.delegate(this, onMouseEvent, "onPressDraw");
		_mc.onRelease = Utils.delegate(this, onMouseEvent, "onReleaseDraw");
		_mc.onReleaseOutside = Utils.delegate(this, onMouseEvent, "onReleaseOutsideDraw");
		_mc.onRollOut = Utils.delegate(this, onMouseEvent, "onRollOutDraw");
		_mc.onRollOver = Utils.delegate(this, onMouseEvent, "onRollOverDraw");
	}
	private function onMouseEvent(event:String):Void {
		broadcastMessage(event, this);
		dispatchEvent({type:event, target:this});
	}
	private function throwError(error:String, isNotice:Boolean):Void {
		error = (isNotice == true ? "Notice" : "Error")+": "+error;
		if(_traceErrors == true){
			trace(error);
		}
		broadcastMessage("onDrawingError", error, this);
		dispatchEvent({type:"onDrawingError", target:this});
	}
}