import com.dstrict.UB.events.Dispatcher;
import com.dstrict.UB.events.Event;
 
class com.dstrict.UB.util.system.BandwidthCheck extends Dispatcher {
 
private var _bandwidthSet:Array;
private var _bandwidth:Number;
 
private var _startTime:Number;
private var _checkCount:Number;
 
private var _loader:MovieClipLoader;
private var _container:MovieClip;
 
public function get bandwidth():Number{
return _bandwidth;
}
 
public function BandwidthCheck() {
_checkCount=0;
_bandwidth=0;
_bandwidthSet=new Array();
}
 
public function check():Void{
_container= _root.createEmptyMovieClip("container", _root.getNextHighestDepth());
var nocache:Number=Math.random()*1000000;
_loader=new MovieClipLoader();
_loader.addListener(this);
_loader.loadClip("bandwidthDummy.png?nocache="+nocache,_container);
}
 
private function calculateBandwidth():Void{
for(var i in _bandwidthSet){
_bandwidth+=_bandwidthSet[i];
}
_bandwidth=_bandwidth/_checkCount;
 
//dispatch a complete event
startEvent(new Event(Event.COMPLETE,this));
}
 
private function onLoadStart(targetMc:MovieClip):Void{
_startTime=getTimer();
}
 
private function onLoadComplete(targetMc:MovieClip):Void{
_loader.unloadClip(_container);
var elapsedTime:Number=(getTimer()-_startTime)/1000;
_checkCount++;
 
var progress:Object = _loader.getProgress(targetMc);
var kilobytes:Number=progress.bytesTotal/1024;
var kBps:Number=kilobytes/elapsedTime;
_bandwidthSet.push(kBps);
 
if(_checkCount==1){
check();
}else{
calculateBandwidth();
}
}
}

var bandwidthCheck:BandwidthCheck=new BandwidthCheck();
bandwidthCheck.addEventListener(Event.COMPLETE,onBandwidthCheck);
bandwidthCheck.check();
 
function onBandwidthCheck(evt:Event){
trace("bandwidth----------------->"+evt.target.bandwidth);
}

import com.dstrict.UB.events.Dispatcher;
import com.dstrict.UB.events.Delegate;
 
class com.dstrict.UB.ui.button.AbstractSimpleButton extends Dispatcher {
 
private var _mc:MovieClip;
 
public function setController(inMc : MovieClip) : Void {
_mc=inMc;
}
public function getController() : MovieClip {
return _mc;
}
/**---------------------------------------------------------------------------
* Constructor function
* @param inMc controller movieClip
*---------------------------------------------------------------------------*/
public function AbstractSimpleButton(inMc:MovieClip) {
setController(inMc);
setButton();
}
public function setButton():Void{
getController().onRollOver=Delegate.create(this,onRollOver);
getController().onRollOut=Delegate.create(this,onRollOut);
getController().onPress=Delegate.create(this,onPress);
getController().onRelease=Delegate.create(this,onRelease);
getController().onReleaseOutside=Delegate.create(this,onReleaseOutside);
}
public function onRollOver() : Void {
// override in sub-class
}
public function onRollOut() : Void {
// override in sub-class
}
public function onPress() : Void {
// override in sub-class
}
public function onRelease() : Void {
// override in sub-class
}
public function onReleaseOutside() : Void {
// override in sub-class
}
public function enabled(mode:Boolean):Void {
// override in sub-class
}
}

import com.dstrict.UB.ui.button.AbstractSimpleButton;
import com.dstrict.UB.events.ButtonEvent;
import com.dstrict.UB.events.Dispatcher;
class com.dstrict.UB.ui.button.ButtonManager extends Dispatcher{
 
private var _buttonSet:Array;
private var _selectButton:AbstractSimpleButton;
 
/**---------------------------------------------------------------------------
* Constructor function
*----------------------------------------------------------------------------*/
public function ButtonManager() {
initialize();
}
 
//==================================================================
///////////public method //////////////////////////////////////////////
//==================================================================
public function addItem(item:AbstractSimpleButton):Void {
_buttonSet.push(item);
registerListener(item);
killListener(item);
}
public function getItemAt(index:Number):AbstractSimpleButton{
return AbstractSimpleButton(_buttonSet[index]);
}
public function kill():Void {
for(var i in _buttonSet){
AbstractSimpleButton(_buttonSet[i]).enabled(false);
}
}
public function live():Void {
for(var i in _buttonSet){
AbstractSimpleButton(_buttonSet[i]).enabled(true);
}
}
 
//==================================================================
///////////event handler //////////////////////////////////////////////
//==================================================================
 
public function onPress(evt:ButtonEvent):Void {
startEvent(new ButtonEvent(ButtonEvent.ON_PRESS,evt.target,evt.currentMovieClip));
}
public function onRelease(evt:ButtonEvent):Void {
enabled(getSelectButton(),true);
enabled(AbstractSimpleButton(evt.target),false);
setSelectButton(AbstractSimpleButton(evt.target));
startEvent(new ButtonEvent(ButtonEvent.ON_RELEASE,evt.target,evt.currentMovieClip));
}
public function onRollOver(evt:ButtonEvent):Void {
startEvent(new ButtonEvent(ButtonEvent.ON_ROLL_OVER,evt.target,evt.currentMovieClip));
}
public function onRollOut(evt:ButtonEvent):Void {
startEvent(new ButtonEvent(ButtonEvent.ON_ROLL_OVER,evt.target,evt.currentMovieClip));
}
 
//==================================================================
///////////private method //////////////////////////////////////////////
//==================================================================
private function initialize():Void {
_buttonSet=new Array();
}
private function setSelectButton(button:AbstractSimpleButton):Void {
_selectButton=button;
}
private function getSelectButton():AbstractSimpleButton{
return _selectButton;
}
private function registerListener(item:AbstractSimpleButton):Void {
item.addEventListener(ButtonEvent.ON_ROLL_OVER,this);
item.addEventListener(ButtonEvent.ON_ROLL_OUT,this);
item.addEventListener(ButtonEvent.ON_PRESS,this);
item.addEventListener(ButtonEvent.ON_RELEASE,this);
}
private function killListener(item:AbstractSimpleButton):Void {
var owner:ButtonManager=this;
item.getController().onUnload=function(){
item.removeEventListener(ButtonEvent.ON_ROLL_OVER,this);
item.removeEventListener(ButtonEvent.ON_ROLL_OUT,this);
item.removeEventListener(ButtonEvent.ON_PRESS,this);
item.removeEventListener(ButtonEvent.ON_RELEASE,this);
};
}
private function enabled(button:AbstractSimpleButton,mode:Boolean):Void {
button.enabled(mode);
}
 
}

class com.dstrict.UB.events.ButtonEvent extends com.dstrict.UB.events.Event {
 
public static var ON_ROLL_OVER:String = "onRollOver";
public static var ON_ROLL_OUT:String = "onRollOut";
public static var ON_PRESS:String = "onPress";
public static var ON_RELEASE:String = "onRelease";
public static var ON_RELEASE_OUTSIDE:String = "onReleaseOutside";
 
public var currentMovieClip:MovieClip;
 
/**--------------------------------------------------------------------------
*constructor function
*@param Type : String, 이벤트 핸들러 메서드
*---------------------------------------------------------------------------*/
public function ButtonEvent(Type : String,Source : Object,curMovieClip:MovieClip) {
super(Type,Source);
currentMovieClip=curMovieClip;
}
}

import com.dstrict.UB.ui.button.AbstractSimpleButton;
import com.dstrict.UB.events.ButtonEvent;
class com.dstrict.UB.ui.button.SampleConcreteButton extends AbstractSimpleButton {
 
public var buttonIndex:Number;
 
public function SampleConcreteButton(inMc : MovieClip,inButtonIndex) {
super(inMc);
buttonIndex=inButtonIndex;
}
 
public function onRollOver() : Void {
getController().gotoAndStop(2);
startEvent(new ButtonEvent(ButtonEvent.ON_ROLL_OVER,this,getController()));
}
 
public function onRollOut() : Void {
getController().gotoAndStop(1);
startEvent(new ButtonEvent(ButtonEvent.ON_ROLL_OUT,this,getController()));
}
 
public function onRelease() : Void {
startEvent(new ButtonEvent(ButtonEvent.ON_RELEASE,this,getController()));
}
 
public function onReleaseOutside() : Void {
startEvent(new ButtonEvent(ButtonEvent.ON_RELEASE,this,getController()));
}
 
public function enabled(mode:Boolean):Void {
getController().enabled=mode;
if(mode){
getController().gotoAndStop(1);
}else{
getController().gotoAndStop(2);
}
}
 
}

import com.dstrict.UB.ui.button.ButtonManager;
import com.dstrict.UB.ui.button.AbstractSimpleButton;
import com.dstrict.UB.ui.button.SampleConcreteButton;
import com.dstrict.UB.events.ButtonEvent;
 
var buttonMgr:ButtonManager=new ButtonManager();
buttonMgr.addEventListener(ButtonEvent.ON_RELEASE,this);
 
buttonMgr.addItem(new SampleConcreteButton(number1_mc,1));
buttonMgr.addItem(new SampleConcreteButton(number2_mc,2));
buttonMgr.addItem(new SampleConcreteButton(number3_mc,3));
buttonMgr.addItem(new SampleConcreteButton(number4_mc,4));
 
//event handler
function onRelease(evt:ButtonEvent):Void{
result_txt.text="onRelease event : "+evt.currentMovieClip+"----->"+evt.target.buttonIndex;
}
 
//Release event
var numberButton:AbstractSimpleButton=buttonMgr.getItemAt(0);
numberButton.onRelease(new ButtonEvent(ButtonEvent.ON_RELEASE,numberButton));

//==================================================================
//@class name  :  ColorMatrixTween.as
//@author          : vkimone. KimKiJeung  (http://kimkijeung.com)
//@last update   : 2007. 03. 19
//@version         : V1.0
//==================================================================
/**
 @description
* 무비클립의  ColorMatrixFilter 트윈 클래스 : 이징함수 설정으로 조절 
 
* @example
*     <code>
*     ColorMatrixTween.tween(targetMc,0,ColorMatrixTween.SATURATION,Regular.easeOut,30,
             {{func: callBackFunction,obj: functionScope, param: [파라미터 배열로 들어감]}}
*     </code>
*/
 
import flash.filters.ColorMatrixFilter;
import com.dstrict.UB.util.filters.ColorMatrix;
class com.dstrict.UB.util.transitions.tween.ColorMatrixTween{
  public static var SATURATION:String="saturation";
  public static var CONTRAST:String="contrast";
  public static var BRIGHTNESS:String="brightness";
 
 /**---------------------------------------------------------------------
  *@description  saturation, contrast, brightness 트랜지션
    @param mc : MovieClip, 적용무비클립
    @param value : Number , 적용 percentage
    @param mode :String , saturation or contrast or brightness mode
    @param func : Function, easing function
   @param durationFrame : Number, 지속프레임
*----------------------------------------------------------------------*/
public static function tween(mc:MovieClip,value:Number,mode:String,func:Function,durationFrame:Number):Void{
var time:Number=1;
var beginning:Array=new Array();
var change:Array=new Array();
 var mat:ColorMatrix = new ColorMatrix();
 switch(mode){
   case SATURATION :
     mat.adjustSaturation(value/100);
     break;
 
   case CONTRAST :
     mat.adjustContrast(value/100);
     break;
 
   case BRIGHTNESS :
     mat.adjustBrightness(255*value/100);
     break;
  }
  var cm:ColorMatrixFilter = new ColorMatrixFilter(mat.matrix);
  var startMatrix:Array=
                       (mc.filters[0].matrix==undefined) ? ColorMatrix.IDENTITY : mc.filters[0].matrix;
  var targetMatrix:Array=mat.matrix;
 
for(var i in targetMatrix){
  beginning.push(startMatrix[i]);
  change.push(targetMatrix[i]-startMatrix[i]);
}
       var type=(typeof(arguments[5])=="object")? true : false;
       if(type){
        var referObj=arguments[5];
       }else{
        var p:Number=arguments[5];
        var referObj=arguments[6];
       }
  mc.onEnterFrame=function(){
  var objIdx:Number=0;
  for(var i in targetMatrix){
   targetMatrix[i]=func(time,beginning[objIdx],change[objIdx],durationFrame,p);
   objIdx++;
   }
   targetColMatrixFilter.matrix=targetMatrix;
   mc.filters=[targetColMatrixFilter];
   time++;
  if(time&gt;durationFrame){
   delete this.onEnterFrame;
   if(referObj!=undefined){
    referObj.func.apply(referObj.obj,referObj.param);
   }
 
  }
};
}
}
 
import  com.dstrict.UB.util.transitions.tween.FilterTween;
import  mx.transitions.easing.*;
import com.dstrict.UB.util.filters.ColorMatrix;
//SATURATION (from 0  to 100)
image.onRollOver=function(){
 ColorMatrixTween.tween(image,0,ColorMatrixTween.SATURATION,Regular.easeOut,10);
}
image.onRollOut=function(){
 ColorMatrixTween.tween(image,100,ColorMatrixTween.SATURATION,Regular.easeOut,10);
}
//CONTRAST (from 0  to 100)
image2.onRollOver=function(){
 ColorMatrixTween.tween(image2,100,ColorMatrixTween.CONTRAST,Regular.easeOut,10);
}
image2.onRollOut=function(){
 ColorMatrixTween.tween(image2,0,ColorMatrixTween.CONTRAST,Regular.easeOut,10);
}
//BRIGHTNESS (from -100  to 100)
image3.onRollOver=function(){
ColorMatrixTween.tween(image3,100,ColorMatrixTween.BRIGHTNESS,Regular.easeOut,10);
}
image3.onRollOut=function(){
ColorMatrixTween.tween(image3,0,ColorMatrixTween.BRIGHTNESS,Regular.easeOut,10);
}

//==================================================================
//@class name  :  FilterTween.as
//@author          : vkimone. KimKiJeung  (http://kimkijeung.com)
//@last update   : 2007. 03. 07
//@version         : V1.0
//==================================================================
/**
 @description
* 무비클립의 필터 속성  트윈 클래스 : 이징함수 설정으로 조절
* 트원할 필터속성의 갯수에 관계없이 오브젝트로 적용 가능
*
* @caution
*  -반드시 트원할 필터 속성의 데이타 타입이 Number 일경우에만 적용할수 있다.
    String,Boolean,Array 는 적용할 수 없다.
   -다중필터 적용은 지원하지 않는다.
*
* @example
*     <code>
*        Filtertween.tween(targetMc,{blurX:36,blurY:36},Regular.easeOut,30,
       {{func: callBackFunction,obj: functionScope, param: [파라미터 배열로 들어감]}}
*     </code>
*/
import flash.filters.BitmapFilter;
class com.dstrict.UB.util.transitions.tween.FilterTween{
/**------------------------------------------------------------------------
 * @param mc : MovieClip, 적용무비클립
 * @param filter : BitmapFilter , 적용할 필터 객체
 * @param obj : Object, 단일 필터속성 (필터 속성 data type 이 Number 일 경우)
                                                     ex. {blurX:32,blurY:32}
 * @param func : Function, easing function
 * @param durationFrame : Number, 지속프레임
 * @param referObj :[option] reference object(caution--&gt; 파라미터값 반드시 배열요소로 입력)
*----------------------------------------------------------------------*/
public static function tween(mc:MovieClip,filter:BitmapFilter,obj:Object,func:Function,durationFrame:Number):Void{
var time:Number=1;
var beginning:Array=new Array();
var change:Array=new Array();
 
for(var i in obj){
  beginning.push(filter[i]);
  change.push(obj[i]-filter[i]);
}
       var type=(typeof(arguments[5])=="object")? true : false;
       if(type){
        var referObj=arguments[5];
       }else{
        var p:Number=arguments[5];
        var referObj=arguments[6];
       }
  mc.onEnterFrame=function(){
  var objIdx:Number=0;
  for(var i in obj){
   filter[i]=func(time,beginning[objIdx],change[objIdx],durationFrame,p);
   mc.filters=[filter]; //필터 적용부분
   objIdx++;
   }
   time++;
  if(time&gt;durationFrame){
   delete this.onEnterFrame;
   if(referObj!=undefined){
    referObj.func.apply(referObj.obj,referObj.param);
   }
 
  }
};
}
}
 
import  com.dstrict.UB.util.transitions.tween.FilterTween;
import  mx.transitions.easing.*;
import flash.filters.*;
var blurFilter:BlurFilter=new BlurFilter(0,0,1);
var dropShadowFilter:DropShadowFilter=new DropShadowFilter(0,120,0x000000,1);
var glowFilter:GlowFilter=new GlowFilter(0x6E7D74,1,16,16,2,2);
//BlurFilter
image.onRollOver=function(){
 FilterTween.tween(image,blurFilter,{blurX:8,blurY:8},Regular.easeOut,15,
        {func:onFilterTweenFinished,obj:_root,param:["blur"]});
}
image.onRollOut=function(){
 FilterTween.tween(image,blurFilter,{blurX:0,blurY:0},Regular.easeOut,15);
}
//DropShadowFilter
image2.onRollOver=function(){
 FilterTween.tween(image2,dropShadowFilter,{distance:4,blurX:4,blurY:4},Regular.easeOut,15,
        {func:onFilterTweenFinished,obj:_root,param:["dropShadow"]});
}
image2.onRollOut=function(){
 FilterTween.tween(image2,dropShadowFilter,{distance:0,blurX:4,blurY:0},Regular.easeOut,15);
}
//GlowFilter
image3.onRollOver=function(){
 FilterTween.tween(image3,glowFilter,{alpha:1,blurX:36,blurY:36},Regular.easeOut,15,
        {func:onFilterTweenFinished,obj:_root,param:["glow"]});
}
image3.onRollOut=function(){
 FilterTween.tween(image3,glowFilter,{alpha:0,blurX:0,blurY:0},Regular.easeOut,15);
}
function onFilterTweenFinished(evt):Void{
 trace("filterTween finished....."+evt);
}

import flash.geom.Point;
var len:Number = 125;
var angleInRadians:Number ;
var cartesianPoint:Point
var unitAngle:Number=15;
for(var i=1 ; i<=24 ; i++){
var mc:MovieClip=this.attachMovie("M_thumb"+i,"M_thumb"+i,i);
angleInRadians = Math.PI*unitAngle/180*(i-1);
cartesianPoint = Point.polar(len, angleInRadians); // 극 좌표를 직교좌표로 전환
 
var offsetX:Number=Math.round(cartesianPoint.x);
var offsetY:Number=Math.round(cartesianPoint.y);
mc._x=Stage.width/2+offsetX;
mc._y=Stage.height/2+offsetY;
}

class com.dstrict.UB.util.system.IME {
  /**-------------------------------------------------------------------
    * @description IME Mode 설정
  *-------------------------------------------------------------------*/
  public static function setIMEMode(mode:String):Void{
  
   if(System.capabilities.hasIME) {
   
   if(mode=="KOREAN"){
      mode=System.IME.KOREAN;
   }
   if(mode=="ALPHANUMERIC"){
       mode=System.IME.ALPHANUMERIC_HALF;
   }
  }
  System.IME.setConversionMode(mode);
  
 }
}
<example code>
 import com.dstrict.UB.util.system.IME;
 IME.setIMEMode("KOREAN"); // 한글전환시
 IME.setIMEMode("ALPHANUMERIC"); // 영문전환시

import com.dstrict.UB.events.Dispatcher;
import com.dstrict.UB.management.IntervalEvent;
/**--------------------------------------------------------------------------------
* @description 인터벌 생성및 실행 클래스
*    원하는 함수를 사용자가 원하는 횟수만큼 호출한후 onIntervalEnd 를 발행시킴...
*
* @implement
*   Interval#onIntervalEnd
*
* @example
* <code>
*  _interval=new Interval();
 _interval.addEventListener(IntervalEvent.ON_INTERVAL_END,this);
 _interval.makeInterval(functionScope,functionReference,duration,loop,[parameter array]);
 
 public function onIntervalEnd(evt:IntervalEvent):Void{
    // 인터벌 이후에 이벤트를 사용하려면 구현...
     parameter array 인자가 그대로 넘어온다...
 
  }
* </code>
*
*--------------------------------------------------------------------------------*/
class com.dstrict.UB.management.Interval extends Dispatcher{
 private var _IntervalID : Number;
 private var _count : Number;
 
  /**------------------------------------------------------------------------------
     * Constructor function
   *------------------------------------------------------------------------------*/
 public function Interval() {
  //생성자 함수 필요없음....
 }
 
 /**------------------------------------------------------------------------------
 * @description 전역속성인 setInterval 함수의 id 값 전부 제거
 *-------------------------------------------------------------------------------*/
 public static function clearAllInterval():Void{
  var topId=setInterval(function(){
  },100);
  for(var i=0 ; i&lt;=topId; i++){    clearInterval(i);   }  }       
/**------------------------------------------------------------------------------    
 * @description interval 에의한 실행함수     
* @param loop : Number, 함수 실행할 횟수     
*@param referObj : Object, 인터벌에 등록한 함수 오브젝트    
 *-------------------------------------------------------------------------------*/   
public function execute(loop:Number,referObj:Object):Void{      if(_count&gt;loop){
        clearInterval(_IntervalID);
       _count=1;
     startEvent(new IntervalEvent(IntervalEvent.ON_INTERVAL_END,referObj.param)); //Dispatch  event
     }else{
        if(referObj!=undefined){
           referObj.func.apply(referObj.obj,referObj.param);
         }
         _count++;
      }
    }
 
 /**-----------------------------------------------------------------------------
 * @description  인터벌 생성
 * @param scope : Object, 실행할 함수의 스코프
 * @param func : Function, 실행할 함수
 * @param duration : Number, 인터벌 간격(밀리세컨드)
 * @param loop : Number, 함수 실행할 횟수
 *-------------------------------------------------------------------------------*/
 public function makeInterval(scope:Object,func:Function,duration:Number,
                                            loop:Number,parameter:Array):Void{
 
   clearInterval(_IntervalID);
   _count=1;
  _IntervalID=setInterval(this,"execute",duration,loop,{func:func,obj:scope,param:parameter});
 
 }
}

import mx.events.EventDispatcher;
/**
* @description     이벤트 디스패처 확장 클래스
*                        이벤트 발생할 클래스에 상속후 startEvent 함수 실행.....
*/
class com.dstrict.UB.events.Dispatcher {
public var dispatchEvent:Function;
public var addEventListener:Function;
public var removeEventListener:Function;
public function Dispatcher() {
EventDispatcher.initialize(this);
}
public function startEvent(obj : Object) : Void {
dispatchEvent(obj);
}
}

_interval=new Interval();
_interval.addEventListener(IntervalEvent.ON_INTERVAL_END,this); --> 인터벌이후에 발생하는이 벤트를 받기위해서 리스너를 붙인다. 받을 이벤트가 없다면 필요없다.
_interval.makeInterval(this,test,200,5,["test string1......","test string2......"]);
 
function test(str:String,str2:String):Void{
trace(str);
trace(str2);
}
function onIntervalEnd(evt:IntervalEvent):Void{
// 인터벌 이후에 이벤트를 사용하려면 구현...
// evt 값은 makeInterval 에서 test 함수를 호출할때 같이 쓰인 문자열 인자값이 배열로 그대로 들어온다.
// evt.target[0] -----> test string1...... evt.target[1] -----> test string2......
}

import mx.core.ext.UIObjectExtensions;
class mx.skins.myTheme.RectBorder extends mx.skins.RectBorder {
static var symbolName:String = "RectBorder";
static var symbolOwner:Object = RectBorder;
var className:String = "RectBorder";
#include "../../core/ComponentVersion.as"
// All of these borders have the same size edges, 1 pixel.
var offset:Number = 4;
function init(Void):Void {
super.init();
}
function drawBorder(Void):Void {
// The graphics are on the symbol's timeline,
// so all you need to do here is size the border.
_width = __width;
_height = __height;
}
// Register the class as the RectBorder for all components to use.
static function classConstruct():Boolean {
UIObjectExtensions.Extensions();
_global.styles.rectBorderClass = RectBorder;
_global.skinRegistry["RectBorder"] = true;
return true;
}
static var classConstructed:Boolean = classConstruct();
static var UIObjectExtensionsDependency = UIObjectExtensions;
}

/**
* @description
* 무비클립 속성  트윈 클래스 : 이징함수 설정으로 조절 
* 트원할 속성의 갯수에 관계없이 오브젝트로 적용 가능
* 
* 트윈이 끝났을 때 실행할 함수 및 파라미터 설정 방법
* 다른 클래스에서 직접 참조해서 호출 가능....
* @param referObj : reference object(caution--> 파라미터값 반드시 배열요소로 입력)
* @example
*     <code>
*        PropertyTweenEase.tween(targetMc,{_x:200,_y:100},Elastic.easeOut,30,{{func: 실행할 함수
이름 , obj: 참조오브젝트, param: [파라미터 배열로 들어감]}}
*     </code>
*/
class com.dstrict.UB.util.transitions.tween.PropertyTweenEase {
/**----------------------------------------------------------------------------------
* @param mc : MovieClip, 적용무비클립
* @param property : Object, 무비클립속성 오브젝트 ex. {_x:100,_y:200}
* @param func : Function, easing function
* @param durationFrame : Number, 지속프레임
*------------------------------------------------------------------------------------*/
public static function tween(mc:MovieClip,obj:Object,func:Function,durationFrame:Number):Void{
var time:Number=1;
var beginning:Array=new Array();
var change:Array=new Array();
  
for(var i in obj){
  beginning.push(mc[i]);
     change.push(obj[i]-mc[i]);
     
}
       var type=(typeof(arguments[4])=="object")? true : false;
       if(type){
        var referObj=arguments[4];
       }else{
        var p:Number=arguments[4]; 
        var referObj=arguments[5];
       }
  mc.onEnterFrame=function(){
  var objIdx:Number=0;
  for(var i in obj){
   mc[i]=func(time,beginning[objIdx],change[objIdx],durationFrame,p);
   objIdx++;
  }
     time++;
  if(time>durationFrame){
   delete this.onEnterFrame;
   if(referObj!=undefined){
    referObj.func.apply(referObj.obj,referObj.param);
   }
   
  }
};
}
}

PropertyTweenEase.tween(mc,{_x:100,_y:200,_alpha:100},Regular.easeOut,20,
{func:this.onMotionFinished,obj:this});
 
function onMotionFinished():Void{
trace("motion finished.......");
}