jasu's blog

어제 CS3발표회를 다녀왔다. 전날 새벽에 잠을 못 잔 관계로 오후로 접어들면서 급격한 뇌 산소부족으로 인해 하품이 나고 눈이 슬슬 감겼다… 하루 일정에 13개나 되는 제품에 대한 설명을 하다 보니 다소 아쉬움이 있었다. 이제는 플래시만을 위한 conference가 아니라는 것이 가장 큰 아쉬움이긴 하지만…

한국 adobe 사장의 인사말로 시작을 했는데 예전의 macromedia 대표이사였던 이원진 사장의 카리스마가 옛 추억처럼 떠올랐다. 이원진 전 adobe사장은 현재 구글코리아의 사업 및 운영총괄 사장으로 있다. Vip참석자는 동시통역기를 나중에 준다고 하여 넋을 놓고 앉아 있다가 오전 한 섹션은 제대로 이해를 하지 못하고 지나갔다. Adobe 제품의 전반적인 통합 workflow에 관한 이야기였던 것 같다.

Adobe의 신제품 발표회였던 만큼 가장 비중을 둔 것은 포토샵CS3였다. 그만큼 좋은 기능들이 많이 포함되어 있었다. 사진을 취미로 하고 있는 나에게는 더없이 좋은 기능들이다. 예를 들면 피사체를 부분별로 찍은 복수의 사진들을 하나의 이미지 형태로 자동 배치하고 블랜드효과를 적용하여 하나의 이미지처럼 매끄럽게 처리하는 스크립트 기능은 놀랄만한 것이었다. 그리고 3D오브젝트를 포토샵에서 불러와서 맵핑을 하고 x,y,z 위치를 변경하여 화면에 배치할 수 있는 기능은 앞으로 웹디자이너들이 웹에서 3D를 활용할 수 있는 방법을 제시해줬다.

그리고 이미지의 특정한 부분의 실제 길이를 알려주고 면적을 구하는 것과 z값의 각도를 틀어서 맵핑을 할 수 있는 기능등과 같이 많은 기능들이 추가되었다. 그리고 포토샵에서 동영상을 편집 가능하게 된 것은 어도비에서 포토샵에 대한 욕심이 얼마나 많은 것인가를 단적으로 보여준다.

inDesign이라는 툴을 새롭게 소개하기도 했는데 개인적으로는 국내 웹디자인에서 큰 효력을 발휘할지는 의문이다. 어떻게 보면 포토샵과 드림위버의 필요한 기능들만을 가볍게 혼합해 놓은 것 같기도 하다. 몇가지 편리한 기능들을 볼 수는 있었지만 그 기능들을 사용하기 위해 또 다른 툴을 알아가기에는 국내 웹디자이너들에게는 무리가 있을 듯 싶다.

플래시의 경우, 통합 workflow의 이점이라고 한다면 psd파일이나 ai파일의 레이어 구조까지 그대로 플래시에서 불러와서 사용가능 하다는 것이다. ai파일의 경우 ai에서 심볼에 인스턴스 네임을 적용 하면 플래시에서 일러스트를 불러왔을 때 심볼의 인스턴스네임까지 가지고 올 수 있다. 하지만 플래시와 디자인을 구분하고 있는 지금의 시점에서 본다면 서로간에 업무협조가 제대로 이루어 질 수 있을지 의문이다. 일러스트의 백터 시스템 구조를 플래시CS3에서 그대로 사용하게 된 점은 Macromedia가 어도비라는 배를 탄 것이 잘한 것이라고 이야기하고 있는 듯 하다.

psd파일도 앞의 ai파일과 같이 레이어구조 그대로 가져와서 필요한 부분만을 체크하여 불러올 수 있고 텍스트의 경우도 비트맵 또는 수정 가능한 텍스트 형태로 불러올 수도 있다. 기존에는 png형태의 외부 파일로 저장을 하여 다시 import하던 방식에서 획기적으로 작업 효율성을 높인 부분이다.

그러나 포토샵 cs2 버전으로 제작된 psd이기 때문에 그러한지는 모르겠지만 이렇게 PSD파일을 플래시에서 직접 불어올 경우 비트맵 이미지의 경계선이 매끄럽지 못한 부분이 있어서 다시 외부 png파일로 저장을 하여 불러오는 경우가 있다. 그리고 포토샵에서 레이어이펙트를 적용했을 경우에도 투명png형태로 가지고 오는 것이 아니라 배경까지 포함하기 때문에 그림자에 멀티레이어이펙트를 적용했을 경우에도 다시 png파일로 저장해야 하는 문제가 있다.(여담이지만 제발 디자이너들은 그림자에 레이어이펙트를 적용하지 않았으면 좋겠다) 포토샵 cs3에서 제작된 파일의 경우도 이러한 문제가 있다면 다음 버전을 출시하기 전에 패치해야 할 부분이다.

이 밖에도 프리미어, 에프터이펙트등에 관한 설명을 들을 수 있었는데 짧은 시간 동안 설명이 이루어진 관계로 자세한 내용을 접할 수는 없었다. CS3의 제품에서 가장 중점은 둔 부분을 말한다면 “통합workflow”라는 말로 대신할 수 있을 듯싶다.

플래시 모임에서 만난 진우와 같이 앉아서 경청을 했는데 진우의 재미있는 입담 덕분에 즐겁게 들을 수 있었다. 피곤한 하루였지만 맛있는 호텔 점심식사도 하고 나름대로 즐거운 하루였다.

쉬는 기간이 10일 정도 지나니 점점 시차적응이 되지 않고 있다. 새벽에 잠깐 눈을 붙였다가 깼더니 잠이 안 와서 결국 날 샜다… 출출해서 냉장고에 넣어놓은 샌드위치를 꺼내보니 너무 안쪽에 넣어두었는지 한쪽이 얼어있네.. 이런….
더 이상 잠도 오지 않고... 에공 조금 있다가 CS3 신제품 발표회에 가야겠다… 이건 자는 것도 아니고 깨어 있는 것도 아녀….

기본적으로 ActionScript의 컴파일러는 현재 스코프 내에 사용하고자 하는 변수를 찾을 수 없을 때에는 상위 스코프에서 찾게 된다. 아래와 같은 코드를 AS2에서 실행해보면 다음과 같이 출력되는 것을 알 수 있다.

// AS2 코드 결과
var _this:String = "global";
trace(_this);  // 출력 :  global

function subScopeFunction() {
        trace(_this);  // 출력 : global
        var _this:String = "local";
        trace(_this); // 출력 : local
}
subScopeFunction();
trace(_this);  // 출력 : global

하지만 AS3에서는 사정이 좀 다르다.

// AS3 코드 결과
var _this:String = "global";
trace(_this);  // 출력 :  global

function subScopeFunction() {
        trace(_this);  // 출력 : null
        var _this:String = "local";
        trace(_this); // 출력 : local
}
subScopeFunction();
trace(_this);  // 출력 : global

위 코드에서 보이는 것과 같이 AS3에서는 전역 변수와 지역 변수명이 같을 경우에는 지역변수는 지역 스코프 내에서만 유효한 값을 갖게 된다. 이는 ActionScript 3.0의 컴파일러가 컴파일을 시도할 때 스코프 내의 변수들을 먼저 불러오기 때문이다.

subScopeFunction() 스코프 내의 첫 번째 행에서 global영역에서 지정한 변수명과 동일한 변수명을 사용하여 출력을 하였으나 subScopeFunction() 스코프 내에 global 변수명과 동일한 지역변수를 var를 통해서 선언하였기 때문에 최초 subScopeFunction() 함수를 컴파일 할 때 라인 위치와는 상관없이 지역변수 _this의 메모리 영역을 먼저 잡아 놓게 된다. 이 때문에 subScopeFunction() 첫 행의 결과는 null을 출력한다.

AS3에서는 형태 지정이 없는 변수만 디폴트 값이 undefined이고 String이나 Object의 디폴트 값은 null, Boolean 는 false, uint는 0, Number는 NaN 값이 디폴트 값이다.

 

AS3의 형태 시스템의 특징은 다음과 같다. 아래의 코드에 대해서 생각해 보면 오브젝트형의 변수 str에 수치 0을 대입하여 공문자열과 비교하고 있다.

var str:* = 0;
if ("" == str) {
        trace("str은 공문자열");
}

위의 If 문은 공문자를 검출하기 위한 것이지만 실제로 이 코드를 실행하면 ”str은 공문자열”이라고 출력된다.

이 결과는 AS3가 약한 형태 성질을 가지고 있기 때문에 일어난다. ActionScript에서는 ＇+＇ 등의 오퍼레이터에 의해서 복수의 데이터형이 혼합되면 처리 전에 암묵적으로 형태 변환을 한다. 예를 들면 trace("count:" + 0)와 같이 문자열과 수치를 더하면 0의 값이 문자열로 변환되어 count:0이라는 결과를 얻게 된다. trace 예와 같은 암묵적 형태 변환은 ActionScript 3.0 이전 버전에서도 있었던 것이지만 위에서 처음 예로 든 코드의 경우는 ActionScript 2.0에서는 공문자열과 str은 같지 않은 것으로 나온다.

암묵적 형태 변환은 위의 trace() 예와 같이 비교적 편리한 기능으로서 사용되지만 한편으로는 예기치 못한 결과가 나올 수 있다. 예를 들면 위에 언급한 코드의 경우 실제로 컴파일러가 어떠한 변환을 통해 true 라는 결과가 나오는지 개발자가 직감적으로는 이해 하기가 어려운 점이 있다.

파이어폭스에서 임시로 인터넷 파일을 저장하는 경로를 임의로 변경하는 방법은 아래와 같다.

1. 파이어폭스 주소입력창에서 about:config를 입력한다.
2. 설정 이름중에서 "browser.cache.disk.parent_directory" 항목을 찾는다.
3. 항목에서 오른쪽 마우스 클릭이나 더블 클릭을 하여 설정값을 원하는 폴더로 변경한다.
예) c:\\windows\temp
4. 위 "browser.cache.disk.parent_directory" 항목이 없을 경우에는 설정값들이 보이는 리스트의 빈 영역에서 마우스 오른쪽 클릭을 하여 새로 만들기 -> 문자열 을 클릭하여 새 문자열 작성 창을 연다
5. 새 문자열 값 => "browser.cache.disk.parent_directory" 로 입력하고 확인을 누른다.
6. 문자열 값 입력 => c:\\windows\temp를 입력하고 확인을 누른다.
7. 파이어폭스 브라우저를 닫고 다시 실행하여 사용하게 되면 앞에서 사용자가 설정한 폴더에 임시파일이 저장된다.

Event 클래스를 확장하면 자신의 커스텀 이벤트 클래스를 정의할 수 있다. 예를 들면 아래와 같은 경우다.

package{
        import flash.events.Event;
        public class CustomEvent extends Event{
                public function CustomEvent(){
                        super("customEvent");
                }
                public override function clone():Event{
                        return new CustomEvent();
                }
        }
}

(Event의 서브 클래스로 상속할 때는 clone() 메소드를 오버라이드할 필요가 있다.)

EventDispatcher 클래스의 dispatchEvent() 메소드를 사용하면 자동으로 이벤트의 dispatch가 생긴다. 예를 들면 Sprite는 EventDispatcher의 서브 클래스이기 때문에 다음과 같이 CustomEvent을 dispatch 할 수 있다.

package{
        import flash.display.Sprite;
        public class CustomEventSprite extends Sprite{
                public function dispatchCustomEvent():void{
                        dispatchEvent(new CustomEvent());
                }
        }
}

그리고는 이벤트 처리를 호출하기 위해 이벤트 리스너를 등록하면 된다.

package{
import flash.display.Sprite;
public class EventTest extends Sprite{
         public function EventTest(){
             var ceSprite:CustomEventSprite = new CustomEventSprite();
             ceSprite.addEventListener("customEvent", onCustomEvent);
             ceSprite.dispatchCustomEvent();
         }
         private function onCustomEvent(evt:CustomEvent):void{
             trace("dispatch CustomEvent");
         }
}
}

하지만 AS3에서는 다중 상속이 허용되지 않기 때문에 모든 클래스를 EventDispatcher의 서브 클래스로 만들 수 있는 것이 아니다. 상속하고 있는 클래스의 경우에는 IEventDispatcher 인터페이스를 사용한다. 클래스 내부에서 EventDispatcher의 인스턴스를 가져와서 처리를 Delegate하는 방법이다.

Sprite의 마우스 이벤트

AS3에서 버튼을 작성하는 경우 우선은 SimpleButton의 사용을 생각할 수 있지만 간단하지 않은버튼 형태의 경우는 SimpleButton을 대신하여 Sprite를 사용할 수 있다. 그 경우 버튼으로서 사용하는 Sprite의 안에 다른 Sprite 오브젝트로서 배치하고 버튼 형태의 모션을 만드는 것도 있을 수 있다.
그렇지만 이 때 다음과 같은 문제가 발생할 수 있다. 버튼으로서 사용한 Sprite의 안에 있는  Sprite도 마우스 이벤트의 대상이 되는 것이다. 이로 인해서 버튼용의 Sprite가 아니라 그 안에 있는 Sprite가 이벤트의 타겟이 되어 버릴 수 있다.(AS3는 DisplayObject의 서브 클래스를 추가하면 의도하지 않아도 이벤트 플로우가 바뀌어 버린다.)

이러한 문제를 방지하려면 mouseEnabled 프롭퍼티를 false로 설정하면 가능하다. Sprite 하나하나에 임의로 설정하여 관리하는 것이 귀찮으면 버튼용 Sprite의 mouseChildren 프롭퍼티를 false로 하는 방법도 있다. 이렇게 하면 버튼용 Sprite의 안에 있는 오브젝트는 모두 이벤트 대상에서 제외된다.

public mouseEnabled : Boolean  // 마우스 이벤트를 받을까
public mouseChildren : Boolean // 아이 오브젝트가 마우스 이벤트를 받을까
public buttonMode : Boolean    // 버튼으로서 행동할까
public hitArea : Sprite        // 마우스 이벤트의 대상이 되는 화면상의 영역
public useHandCursor : Boolean // 커서의 형상을 손의 형태로 할까

buttonMode 프롭퍼티를 true로 설정하면 마우스가 Sprite의 위에 왔을 때 마우스의 모양을 자동적으로 손 모양으로 바꾸어 준다.(useHandCursor 프롭퍼티 쪽이 우선)

SimpleButton는 InteractiveObject의 서브 클래스로서 마우스의 조작에 따라 버튼처럼 행동할 수 있다. Flash authoring tool로 버튼 심볼을 작성하면 4개의 프레임이 생기는데 SimpleButton 에도 각각의 프레임에 대응하는 프롭퍼티가 존재한다.

 
public upState : DisplayObject        // 업 상태의 표시 오브젝트
public overState : DisplayObject      // 오버 상태의 표시 오브젝트
public downState : DisplayObject     // 다운 상태의 표시 오브젝트
public hitTestState : DisplayObject    // 히트 테스트용 오브젝트

 
이상의 4개의 프롭퍼티에 대응하는 마우스 조작 상태로 의도된 표시를 표현한다. DisplayObject 를 설정하는 것이 SimpleButton의 기본적인 사용 방법이다.

var myButton:SimpleButton = new SimpleButton();
addChild(myButton);

// 각 스테이트용의 오브젝트를 작성(하나의 Shape를 공유)
var stateShape:Shape = new Shape();
stateShape.graphics.lineStyle(2, 0x202020);
stateShape.graphics.beginFill(0xFF0000);
stateShape.graphics.drawRect(10, 10, 50, 50);

// 버튼 오브젝트의 프롭퍼티를 설정
myButton.upState = stateShape;
myButton.downState = stateShape;
myButton.overState = stateShape;
myButton.hitTestState = stateShape;

SimpleButton에는 위 4개의 상태 오브젝트 외에 아래와 같은 프롭퍼티가 있다.

 
public trackAsMenu : Boolean       // 메뉴와 같은 사용법을 할 것인가
public enabled : Boolean            // 버튼을 유효하게 할 것인가
public useHandCursor : Boolean     // 커서의 모양을 핸드커서 형태로 것인가

 
trackAsMenu는 마우스를 눌렀다가 다른 장소에서 마우스를 놓았을 경우에서도 click 이벤트를 받고 싶은 경우에 사용한다. 보통 click 이벤트는 동일 오브젝트상에서 마우스를 클릭하는 행위를 하지 않으면 dispatch 되지 않지만 trackAsMenu를 true로 해 두면 다른 오브젝트상에서 마우스를 놓아도 적용된다. SimpleButton 오브젝트상에서 마우스를 놓았을 경우에도 그 SimpleButton 오브젝트에 click 이벤트가  dispatch된다. 메뉴를 만들 때 유용하다.

enabled 프롭퍼티는 버튼의 유효/ 무효를 선택할 수 있다. enabled를 false로 설정하면 실제 마우스를 조작해도 외형상은 반응하지 않는 것 처럼 보이지만 이벤트는 dispatch된다.

useHandCursor 프롭퍼티는 디폴트가 true다. 보통은 특별히 신경 쓸 필요는 없을 것 같다.

argument 오브젝트

디폴트 값으로 지정되어 있지 않은 인수를 생략 하고 함수를 호출하려고 하면 컴파일러가 에러를 돌려준다. 또 선언되고 있는 것보다 많은 인수를 지정하여 호출하는 경우도 compile error가 되지만  둘 모두 실행은 된다.

인수에 액세스 하기 위해서는 arguments라고 하는 오브젝트를 사용할 수 있다. 이것은 선언 없음으로 함수 내에서 참조할 수 있는 오브젝트로 건네 받은 인수의 배열이라고 부르며 오브젝트 (arguments.callee)를 프롭퍼티로서 가지고 있다. 인수명에 arguments이 사용되고 있는 함수 내에서는 arguments는 그 인수를 가리키게 되어 arguments 오브젝트를 사용할 수 없게 된다.

arguments 오브젝트는 아래와 같은 재귀 함수에서 처럼 편리하게 이용할 수 있다.

var factirial:Function = function(x:int):int {
        if (x == 0) {
                return 1;
        } else {
                return (x * arguments.callee(x - 1));
        }
}

인수의 수가 결정되지 않은 경우는 compile error를 무시하고 함수를 호출하지 않으면 안 된다는 것은 좋지 않다. 그래서 AS3 에는 arguments를 대신하는 다음과 같은 기능이 준비되어 있다.

「... 」 인수

AS3의 마지막 인수로서 「... + 임의의 이름」을 지정하면 정의된 수 이상의 인수를 건네줄 수 있게 된다. 명시적으로 이름이 지정되어 있지 않은 인수는 「임의의 이름」으로 지정된 이름을 가지는 배열로서 사용할 수 있다. 아래의 예에서는 rest라고 하는 배열에 2 와 3을 전달한다.

function sampFunc(x:int, ... rest) {
        if (rest.length > 0) {
                trace(rest[0];
        }
}
// 2가 출력된다.
sampFunc(1, 2, 3);

arguments 오브젝트와 달리 이 방법으로 하면 컴파일러도 불만이 없다. 함수 정의로부터 인수의 수를 정하지 않았다는 것을 컴파일러는 인지할 수 있게 된다. 사전에 인수의 수를 특정할 수 없는 경우는 「... 」 의 사용을 추천한다. 단,「... 」이 지정되어 있으면 arguments 오브젝트는 사용할 수 없다.

URLVariables 클래스
public 함수 URLVariables(source:String = null)

새로 URLVariables 오브젝트를 작성한다. URLVariables 오브젝트를 URLRequest 오브젝트의 data 프롭퍼티에 건네준다.

스트링과 함께 URLVariables constructor을 호출하면 decode() 메소드가 자동적으로 실행되고 그 스트링이 URLVariables 오브젝트의 프롭퍼티로 변환된다.

파라미터
    source:String (default = null) —URL encode 된 스트링.


decode() 메소드
public function decode(source:String):void

변수 스트링을 지정하면 URLVariables 오브젝트의 프롭퍼티로 변환된다.

이 메소드는 URLVariables 이벤트에 의해서 내부적으로 사용된다. 대부분의 경우 유저가 직접 이 메소드를 호출할 필요는 없다.

다음의 예에서는 http://www.[yourDomain].com/application.jsp로 호스트 되는 리모트 어플리케이션을 열어서 URLVariables 오브젝트로 받는 유저 세션에 관한 데이터를 어플리케이션에 건네준다.

이 예의 내용은 다음과 같다.

   1. constructor함수는 request라는 이름의 리모트 어플리케이션의 URL을 파라미터로 취득하는  URLRequest 인스턴스를 작성한다.
   2. URLVariables 오브젝트를 작성하고 2개의 프롭퍼티에 값을 할당한다.
   3. URLVariables 오브젝트가 URLRequest 오브젝트의 data 프롭퍼티에 할당한다.
   4. navigateToURL를 호출하고 새로운 브라우저 윈도우를 열어서 리모트 어플리케이션의 URL에 접속한다.

메모 : 이 예를 실행하려면 리모트 어플리케이션의 URL을 실제의 URL로 바꿀 필요가 있다. 또한 URLVariables 오브젝트의 Flash Player가 보낸 정보를 처리하기 위한 서버 코드가 필요하다.

package {
import flash.display.Sprite;
import flash.net.navigateToURL;
import flash.net.URLRequest;
import flash.net.URLVariables;

public class URLVariablesExample extends Sprite {

    public function URLVariablesExample() {
        var url:String = "http://www.[yourDomain].com/application.jsp";
        var request:URLRequest = new URLRequest(url);
        var variables:URLVariables = new URLVariables();
        variables.exampleSessionId = new Date().getTime();
        variables.exampleUserLabel = "guest";
        request.data = variables;
        navigateToURL(request);
    }
}}

URLLoader 클래스
외부로부터의 XML 데이터등을 읽어들일 때는 URLLoader 클래스를 사용할 수 있다.


URLRequest 클래스를 통한 데이터 송신
URLLoader를 사용해서 서버에 리퀘스트를 보내려면 우선 URLRequest 클래스의 인스턴스를 만든다. URLRequest의 오브젝트에는 리퀘스트 URL이나 헤더 정보 등을 지정할 수 있다.

아래 작성한 코드는 URLRequest 오브젝트를 인수로서 URLLoader의 load() 메소드를 호출한다.

var myReq:URLRequest = new URLRequest();
myReq.url = "foo.xml";  // constructor의 인수로도 지정 가능
var myLoader:URLLoader = new URLLoader();
myLoader.load(myReq);

HTTP 헤더에 정보를 추가하는 경우는 항목 마다 URLRequestHeader 클래스의 인스턴스를 작성하여 URLRequestHeader 오브젝트의 requestHeaders 속성(Array 형태)에 추가한다.

var myReq:URLRequest = new URLRequest("foo.xml");
var myRH:URLRequestHeader = new URLRequestHeader("pragma", "no-cache");
myReq.requestHeaders.push(myRH);
var myLoader:URLLoader = new URLLoader();
myLoader.load(myReq);

수신한 데이터의 처리
load()를 실행하고 나서 데이터의 읽기 처리가 끝날 때까지는 ActionScript로부터 읽어 들인 데이터에 액세스 할 수 없다. URLLoader는 수신 처리를 완료하면 complete 이벤트를 발생시키므로 complete 이벤트에 대한 이벤트 핸들러 내에서 데이터 조작을 실시해야 한다. 읽어들인 데이터는 URLLoader의 data 속성으로부터 액세스 할 수 있다.

myLoader.addEventListener(Event.COMPLETE, completeHandler);
myLoader.load(new URLRequest("foo.xml"));

private function completeHandler(event:Event):void {
        trace(myLoader.data);
}

읽혀진 데이터는 DataFormat 클래스에 정의하고 있는 3종류의 포맷 형태를 갖는다. URLLoader 오브젝트의 dataFormat 속성을 보면 다음과 같다.

    * DataFormat.TEXT : String 형의 문자열
    * DataFormat.BINARY : ByteArray 형의 바이너리 데이터
    * DataFormat.VARIABLES : URL encode 된 폼 변수를 가진다 URLVariables 오브젝트

데이터의 송신
서버에 데이터를 송신할 때도 위와 같이 3종류의 포맷을 사용할 수 있다. 송신하는 데이터를 URLRequest 오브젝트의 data 속성에 세트 하면 리퀘스트시에 세트한 데이터가 보내진다.

아래의 예에서는 URLVariables 오브젝트를 POST 형태로 송신하고 있다. 이 경우 데이터는 x-www-form-urlencoded 포맷에 encode 되어 보내진다.

var myVars:URLVariables = new URLVariables();
myVars.userID = "guest";
myVars.password = "foo";
myReq.data = myVars;
myReq.url = "ww.sample.com/foo.jsp";
myReq.method = URLRequestMethod.POST;
myLoader.load(myReq);

송신 방법 (GET/POST)은 URLRequest 오브젝트의 method 속성에 URLRequestMethod 클래스에 정의된 값을 사용하여 지정한다. 디폴트는 GET다. POST하는 경우는 데이터의 MIME 타입을 URLRequest 오브젝트의 contentType 속성으로 설정할 수 있다. ByteArray 오브젝트를 송신하는 경우는 GET은 사용할 수 없다.

navigateToURL 함수

AS3 어플리케이션으로부터 또 하나의 브라우저 윈도우를 열고 싶을 때, 또는 현재 AS3 어플리케이션을 실행중의 윈도우를 다른 HTML 컨텐츠로 바꾸고 싶을 때, navigateToURL() 함수를 사용한다. AS3이전 버전에서는 getURL()을 사용하였다. 아래는 navigateToURL() 함수의 정의.

public function navigateToURL(request:URLRequest, window:String = null):void

1 첫 번째 인수에는 URLRequest 오브젝트를 지정한다. 이 오브젝트에는 URLLoader 클래스에서는  리퀘스트 하는 URL이나 헤더 정보, 그리고 송신하는 데이터와 송신 방법 등을 지정한다.

2 번째의 인수에는 리퀘스트의 결과를 수신하는 윈도우 target을 지정한다. 이것은 디폴트값이 정의되고 있기 때문에 생략이 가능하다. 생략 했을 경우에는 새로운 윈도우가 열린다. 즉 "_blank" 를 지정한 것과 동등의 결과가 된다.

아래의 샘플에서는 navigateToURL()의 두번째 인수를 "_self"로 하고 있기 때문에 AS3 어플리케이션을 실행하고 있는 윈도우에서 컨텐츠를 열게 된다.

import flash.net.navigateToURL;

var myVars:URLVariables = new URLVariables();
myVars.currentTime = new Date().getTime();
myVars.city = "Tokyo";

var myReq:URLRequest = new URLRequest();
myReq.url = "http://www.sample.com/weather";
myReq.data = myVars;

// 현재의 윈도우에 컨텐츠를 연다.
navigateToURL(myReq, "_self");

navigateToURL() 함수를 사용하려면 import해서 사용한다.


sendToURL() 함수
AS3 어플리케이션으로부터 서버에 데이터를 보내고 싶지만 결과는 무시하고 싶을 때는 sendToURL() 함수를 사용한다. 사용법은 위에서 소개한 것처럼 navigateToURL() 함수와 거의 비슷하다. 차이는 2번째의 인수가 없다는 것이다.

public function sendToURL(request:URLRequest):void

import flash.net.sendToURL;

var myVars:URLVariables = new URLVariables();
myVars.user = "foo";
myVars.data = "hello";

var myReq:URLRequest = new URLRequest();
myReq.url = "http://www.sample.com/post";
myReq.data = myVars;
myReq.method = URLRequestMethod.POST;
// 서버에 데이터를 송신
sendToURL(myReq);

프롭퍼티의 선언에 private로 지정하면 다른 클래스에서는 참조할 수 없게 된다. 또 public으로 지정했을 경우는 어떤 클래스에서도 참조할 수 있다.

Protected로 지정한 프롭퍼티는 계승한 클래스에서는 참조를 할 수 있다. Default인 internal 의 경우는 같은 패키지내의 클래스이면 참조가 가능하다.

주의할 것은 protected의 경우 다른 패키지의 클래스에서 참조를 시도해도 서브 클래스이면 참조가 가능하다는 것이다. 반대로 protected의 프롭퍼티는 같은 패키지내의 클래스에서도 서브 클래스가 아니면 참조할 수 없다는 것이다.

또 internal의 프롭퍼티는 같은 패키지내의 서브 클래스에서만 참조가 가능하다.

예를 들어보면 우선 foo라는 패키지에 FooBase 클래스를 정의한다. 클래스 내에는 protected와 internal 의 2종류의 함수를 정의한다.

package foo
{
        public class FooBase
        {
                protected function protectedFunc():void {
                }
                internal function internalFunc():void {
                }
        }
}

다음은 bar라고 하는 패키지에 상기 FooBase의 서브 클래스를 정의한다. 함수를 오버라이드(override) 하기 위해 override 키워드를 사용하고 있다.

package bar
{
        import foo.FooBase;

        public class BarSub extends FooBase
        {
                // 부모클래스의 정의를 오버라이드(override)
                override protected function protectedFunc():void {
                }
                // 여기는 internal이기 때문에 오버라이드(override) 할 수 없다.
                override internal function internalFunc():void {
                }
        }
}

위 코드를 컴파일 해 보면 protectedFunc() 메소드는 가능하지만 internalFunc() 메소드는 그런 함수는 발견되지 못하여 에러를 출력한다.

또 서브 클래스내의 코드에서 직접 부모클래스의 protected 프롭퍼티를 참조할 수 없다.

public class BarSub extends FooBase
{
        public function callProtected():void {
                var foo:FooBase = new FooBase();
                // protected 의 메소드를 호출해 본다
                foo.protectedFunc();
        }
}

위의 예의 경우 callProtected()에서 에러가 발생한다.

서브 클래스를 정의하려면 extends 키워드를 사용한다.

// 부모클래스 정의
public class MyBase
{
        public function hello():String {
                return "hello";
        }
}

// 서브 클래스의 정의
public class MySub extends MyBase
{
}

서브 클래스의 오브젝트는 부모클래스의 오브젝트와 같게 사용할 수 있다.

// MyBase 형의 변수에 대입
var base:MyBase = new MyBase();
var sub:MyBase = new MySub();

// MyBase 형의 인수를 받는 함수에 건넨다
needBase(sub);
needBase(base);

public function needBase(obj:MyBase):void {
        trace(obj.hello());
}

반대로 부모클래스를 서브 클래스로 대신하여 인수로 전달 할 수 없다, 아래의 코드는 ActionScript 3.0 환경 설정에서 -strict 옵션을 붙이지 않으면 실행할 수 있지만 ActionScript 2.0에서는 에러를 출력한다.

var sub:MyBase = new MySub();
needSub(sub);

public function needSub(obj:MySub):void {
        trace(obj.hello());
}

Adobe에서 아직 Flash CS3용 AIR 기능확장을 제공하고 있지는 않지만  grant skinner가 Flash CS3용 AIR extension을 자작해 공개해 놓았다.

 
Step 1 :
Adobe Labs에서 Flex 3 SDK를 다운 받아서 특정 폴더를 만들어 압축을 풀어 놓는다.


Step 2 :
Extension Manager v1.8 를 다운 받아서 설치

Step 3 :
AIRPanel zip 파일을 다운 받아서 압축을 풀고 stop2에서 설치한 Extension 프로그램으로 AIRRanel extension을 등록한다. (플래시 툴이 열려 있을 경우는 닫고 다시 실행해야 other panel에서 확인이 가능하다)

Step 4 :
처음 AIRPanel extension을 설치하고 fla를 air파일로 만들기 전에 AIRPanel의 test버튼을 클릭했을 때 adl.exe 파일을 등록하기 위한 open창이 뜨면 step1에서 받아놓은 sdk 폴더에 보면 /bin 폴더에서 확인할 수 있다. 그것을 등록한다.

그리고 test버튼을 클릭하면 air파일을 만들기 전에 테스트로 화면에서 확인 할 수 있고 Package 버튼을 클릭하면 실제로 air파일을 생성하게 된다. Settings 버튼은 어플리케이션의 기본적인 정보와 SystemChrome에서는 standard와 none를 제공하고 있는데 none를 선택하고 Transparent를 체크하면 transparent로 뚫린 플래시 어플리케이션을 만들 수 있다

주의할 점은 fla파일이 한글을 포함한 폴더 경로에 있을 경우에는 air를 생성하지 못한다. 영문 폴더를 생활화...

필요 없는 오브젝트의 참조가 남아있으면 그 오브젝트가 사용하고 있는 메모리 영역을 사용할 수 없게 된다. 특히 복수가 참조하는 오브젝트에 대해서는 참조를 해제하는 것을 잊어버리게 되면 메모리의 낭비가 발생하므로 주의해야 한다.

이벤트 리스너를 등록하려면 이벤트의 타겟으로 되는 오브젝트와 이벤트 리스너를 가지는 오브젝트 사이에 참조를 할 수 있다. AS3에서는 아래와 같이 기술한다.

eventTarget.addEventLisener("eventType", eventHandler);

이 코드를 실행하면 eventTarget과 현재 스크립트가 포함된 this 사이에 참조가 만들어진다. 하지만 이것은 명시적인 참조의 추가가 아니기 때문에 참조의 삭제가 필요한 경우 간과할 수 있다.

아래는 이벤트 리스너 추가시에 참조의 취급 방법에 대한 내용이다.


참조의 방향
참조에는 방향성이 있다. 즉, 오브젝트간의 참조는 한 방향으로만 가능하다. 예를 들면 아래와 같은 코드가 있을 때,

var foo = new Foo();
foo.bar = this;
foo = null;

1행에서 만들어진 참조는 this -> new Foo() 방향으로 만들어진 참조이다. 2행에서 만들어진 참조는 1행과 반대로 new Foo() -> this 방향으로 만들어 진 참조다. 3행에서 1행의 참조를 삭제하게 되면 this -> new Foo()으로의 참조를 할 수 없다.

가비지컬렉터는 오브젝트 트리의 루트로부터 참조를 찾아 들어 간다. 우선 루트의 오브젝트를 찾아내고 다음에 그 오브젝트의 오브젝트를 찾아내는 동작을 반복하게 된다. 위 샘플을 실행했을 경우 this에 new Foo()로 만들어진 오브젝트를 찾아 낼 수 없다. 즉 2행째에 작성한 참조가 남아있다고 해도 3행을 실행하게 되면 메모리 문제는 해결될 수 있다.


오브젝트에 이벤트 리스너 추가
오브젝트에 이벤트 리스너를 추가할 경우에 참조 방향으로는 아래와 같다.

import flash.events.Event;
import flash.events.MouseEvent;
var foo = New Foo();
addChild(foo);
foo.addEventListener(MouseEvent.CLICK, clickHandler);

function clickHandler(evt:Event):void{
        trace(this);
}

위 코드에서 foo 오브젝트를 작성하고 그 오브젝트에 clickHandler라는 이벤트 리스너를 등록하였다. clickHandler 메소드는 스크립트가 작성된 this 오브젝트의 메소드가 된다.

이러한 경우 foo 오브젝트의 참조를 삭제할 때 이벤트 리스너도 삭제하지 않으면 메모리에 잔존하는 문제의 원인이 될 수 있다. 아래와 같이 오브젝트로부터 this에 이벤트 리스너를 설정할 경우도 같다.

parent.addEventListener("click", clickHandler);

약한 참조의 이용
약한 참조는 참조가 존재하고 있어도 가비지콜렉터에 의해서 참조로서 보이지 않는 참조이다. 이는 매우 편리하게 사용할 수 있는데 이벤트 리스너에 의해 생성되는 참조가 모두 약한 참조라면 참조의 방향을 신경 쓰지 않고 등록한 리스너를 방치해 두어도 문제가 되지 않기 때문이다. 이벤트 리스너를 등록할 때 약한 참조를 사용할지를 지정할 수 있다. addEventListener()의 5번째 인수를 true로 적용하면 약한 참조를 사용할 수 있다.

addEventListener("eventType", listenerHandler, false, 0, true);

3번째와 4번째 인수는 false와 0 값을 지정해 두면 대체적으로 문제가 없기 때문에 위와 같은 형태로 5번째 인수를 false와 true로 적용하여 강한 참조와 약한 참조를 사용할 수 있다.

Flash Player9 업데이트 3에서는 공개되는 하드웨어 기능을 이용한 풀 스크린 모드가 추가되었다.

하드웨어 스켈링의 사용법
Flash Player9 업데이트 3의 Stage 오브젝트에는 fullScreenSourceRect라고 하는 속성이 추가된다. 이 속성은 AS2와 AS3에서 모두 사용 가능하다. fullScreenSourceRect에 의해 지정된 영역은 하드웨어의 스켈링 기능에 의해 표현 되기 때문에 기존의 풀 스크린 모드보다 퍼포먼스와 화질 면에서 현격히 개선되고 있다.

아래 샘플은 Stage를 화면 전체에 넓히는 기능이다.

import flash.geom.*;
function goFullScreen()
{
        Stage["fullScreenSourceRect"] = new Rectangle(0, 0, Stage.width, Stage.height);
        Stage["displayState"] = "fullScreen";
}

비디오를 풀 스크린으로 표시하는 경우는 Rectangle 크기를 비디오의 오리지날의 크기로 한다.

AS3에서 Stage의 fullScreenSourceRect속성을 적용하려면 playerglobal.swc를 클래스패스영역에 포함 시켜야 한다. CS3 의 ActionScript 3.0/classes 폴더에 기존에 파일을 아래 파일로 바꿔주어야 한다. (playerglobal.swc파일을 첨부한다.)



비디오의 퀄리티와 용량에 따라 다르겠지만 대체적으로 fullScreenSourceRect속성을 사용하면 비디오를 풀스크린으로 표현했을 때의 CPU 점유율은 사용하지 않은 것 보다 대략 절반 정도로 떨어지고 화질 면에서도 개선된 점을 발견할 수 있다.

AS3로 만든 플래시에서 AS2로 만든 swf를 로드 할 수는 있지만 그 안에 있는 메소드나 변수에 접근 할 수는 없다. 블로그의 메뉴와 배경에 나타나는 나비는 as2로 만들었고,  infinite메뉴는 따로 AS3로 만들었기 때문에 서로 다른 swf 파일로 되어 있다.

고민이 되었던 부분은 infinite 메뉴를 클릭했을 때 fullscreen 형태로 컨텐츠를 보여주게 되면서 아래에 있는 블로그의 기존에 생성하던 나비와 플레이 되고 있던 음악은 종료해야 한다는 것이었다. 나비의 경우는 화면에 보이지 않으면서 불필요하게 CPU를 낭비하게 되고 음악 또한 불필요하다.

그래서 직접 AS3 코드에서 AS2코드를 참조할 수 없으니 간접적으로 참조할 수 있는 방법으로 LocalConnection 클래스를 사용하게 되었다. LocalConnection의 경우는 as2,와 as3에서 서로 호환적으로 사용이 가능하다.

root에 있는 변수나 메소드에 접근할 때 actionscript 2.0에서는 _root를 절대적 참조 영역으로 사용하였으나 as3부터는 _root를 통해 직접적으로 변수나 함수를 참조할 수가 없다.

as3에서 root영역에 있는 변수나 함수를 참조하기 위해서는 아래와 같은 형태로 가능하다. (코드의 일부 개념적인 부분은 한상훈님의 설명을 참조하였다.)  'ADDED_TO_STAGE'라는 이벤트는 constructor를 통해서 인스턴스를 생성할 때 메모리 영역을 할당 받기 전의 참조로 인한 문제를 방지하기 위해 사용한 듯한데 아직까지 as3의 개념이 확실히 잡히지 않았다.

import flash.events.MouseEvent;
import flash.events.Event;

var menu_num:Number = 100;

mc.buttonMode = true;
mc.addEventListener(MouseEvent.CLICK, clickHandler);

function clickHandler(evt:Event):void{
        var rootTest:RootTest = new RootTest();
        addChild(rootTest);
        rootTest.getTrace();
}

package{
import flash.display.MovieClip;
import flash.events.Event;

public class RootTest extends MovieClip{

        private var _root:MovieClip;

        public function RootTest(){
                addEventListener(Event.ADDED_TO_STAGE, initialize);
        }
        private function initialize(evt:Event):void{
                removeEventListener(Event.ADDED_TO_STAGE, initialize);
                _root = root as MovieClip;//or MovieClip(root);        
	}
        public function getTrace():void{
                trace(stage);
                trace(_root.menu_num);
        }
}}

출력 :
[object Stage]
100

오늘 AS3로 무비클립의 특정 프레임으로 이동하는 모션 클래스를 제작하다가 Timer 클래스의 버그인줄 알고 Timer 관련 레퍼런스를 찾아보니 버그가 아니라 설정된 기능이었다.

보통 Timer 클래스를 정의하여 사용할 때 두 개의 파라미터를 전달하게 되는데 그 첫 번째는 handler 메소드의 실행 간격을 정의하는 Delay고 두 번째 파라미터는 몇 번을 실행할 것인가를 나타내는 repeatCount:int 다. 아래의 코드는 1초 간격으로 5번 handler 메소드를 실행하게 된다.

var timer:Timer = new Timer(1000, 5);

위 코드에서 두 번째 파라미터 값이 –값을 갖게 되면 한번 실행되고 종료하지만 0 값을 갖게 되면 무한히 handler 메소드를 실행하며 currentCount값도 무한하게 증가한다. repeatCount의 default값이 0이기 때문에 두번째 파라미터를 설정하지 않을 경우도 stop() 메소드로 Timer이벤트를 종료할 때가지 실행하게 된다.  

import flash.utils.Timer;
import flash.events.TimerEvent;

var timer:Timer = new Timer(30, 0); // or new Timer(30);
timer.addEventListener(TimerEvent.TIMER, timerHandler);
timer.start();

function timerHandler(evt:Event):void{
        trace(evt.currentTarget.currentCount);
}

런타임시 스크립트상에서 repeatCount로 전달되는 파라미터 값이 0의 값을 갖게 될 때는 주의해서 Timer 이벤트를 종료해 줄 필요가 있다.

every() 메소드    
AS3 function every(callback:Function, thisObject:* = null):Boolean

지정된 함수에서 false를 돌려주는 아이템에 이를 때까지 배열내의 각 아이템에 테스트 함수를 실행한다. 이 메소드를 사용하면 배열내의 모든 아이템이 있는 기준(값이 특정의 수치보다 작은 등)이 만족하는지 어떤지를 판별할 수 있다.

파라미터
    callback:Function — 배열내의 각 아이템에 대해 실행하는 함수. 이 함수에는 단순한 비교 (item < 20 등)나 보다 복잡한 연산을 포함할 수 있다 .또 이 함수를 호출하려면 다음과 같이 아이템의 값, 아이템의 인덱스, 및 Array 오브젝트의 3개 인수를 사용한다.

function callback(item:*, index:int, array:Array):Boolean;

    thisObject:* (default = null) — 함수의 this로서 사용하는 오브젝트.

반환값
    Boolean — 불리언 값. true를 돌려준다 (지정된 함수에 대해 배열 내의 모든 아이템이 true 를 돌려주는 경우)  그 이외의 경우는 false를 돌려준다.

다음의 예에서는 2개의 배열을 테스트하고 각 배열내의 모든 아이템이 수치인지를 판별하고 테스트 결과를 출력한다. 첫번째 배열의 결과는 true, 2번째의 배열은 false를 나타내고 있으며 false를 받는 즉시 테스트 함수의 순회는 종료된다.

package {
        import flash.display.Sprite;
        public class Array_every extends Sprite {
                public function Array_every() {
                        var arr1:Array = new Array(1, 2, 4);
                        var res1:Boolean = arr1.every(isNumeric);
                        trace("isNumeric:", res1);// true

                        var arr2:Array = new Array(1, "ham", 2);
                        var res2:Boolean = arr2.every(isNumeric);
                        trace("isNumeric:", res2);// false
                }
                private function isNumeric(element:*, index:int, arr:Array):Boolean {
                        trace(element);
                        return (element is Number);
                }
        }
}

출력 :
1
2
4
isNumeric: true
1
ham
isNumeric: false


forEach( ) 메소드    
AS3 function forEach(callback:Function, thisObject:* = null):void

배열내의 각 아이템에 대해 함수를 실행한다.

파라미터
    callback:Function — 배열내의 각 아이템에 대해 실행하는 함수. 이 함수에는 단순한 커멘드 (trace() 스테이트먼트 등)나 보다 복잡한 연산을 포함할 수 있다. 또 이 함수를 호출하려면  다음과 같이 아이템의 값, 아이템의 인덱스, 및 Array 오브젝트와 같이 3개의 인수를 사용한다.

    function callback(item:*, index:int, array:Array):void;

    thisObject:* (default = null) — 함수의 this로서 사용하는 오브젝트.

다음의 예에서는 배열내의 각 아이템에 대해서 trace() 스테이트먼트를 traceEmployee() 함수로 대체하고 있다.

package {
        import flash.display.Sprite;
        public class Array_forEach extends Sprite {
                public function Array_forEach() {
                        var employees:Array = new Array();
                        employees.push({name:"Employee 1", manager:false});
                        employees.push({name:"Employee 2", manager:true});
                        employees.push({name:"Employee 3", manager:false});
                        trace(employees);
                        employees.forEach(traceEmployee);
                }
                private function traceEmployee(element:*, index:int, arr:Array):void {
                        trace(element.name + " (" + element.manager + ")");
                }
        }
}

다음의 예도 배열내의 각 아이템에 대해 trace() 스테이트먼트를 실행하고 있지만 여기서 사용한 traceEmployee() 함수에는 약간의 변경이 있다.

package {
        import flash.display.Sprite;
        public class Array_forEach_2 extends Sprite {
                public function Array_forEach_2() {
                        var employeeXML:XML = <employees>
                        <employee name="Steven" manager="false" />
                        <employee name="Bruce" manager="true" />
                        <employee name="Rob" manager="false" />
                        </employees>;
                        var employeesList:XMLList = employeeXML.employee;
                        var employeesArray:Array = new Array();
                        for each (var tempXML:XML in employeesList) {
                                employeesArray.push(tempXML);
                        }
                        employeesArray.sortOn("@name");
                        employeesArray.forEach(traceEmployee);
                }
                private function traceEmployee(element:*, index:Number, arr:Array):void {
                        trace(element.@name + ((element.@manager == "true") ? " (manager)" : ""));
                }
        }
}

filter() 메소드    
AS3 function filter(callback:Function, thisObject:* = null):Array

배열내의 각 아이템에 대해 테스트 함수를 실행하여 지정된 함수에 대해서 true를 돌려주는 모든 아이템을 포함하는 새로운 배열을 작성한다. false를 돌려주는 아이템은 새로운 배열에 포함하지 않는다.

파라미터
    callback:Function — 배열내의 각 아이템에 대해 실행하는 함수. 이 함수에는 단순한 비교 (item < 20 등)나 보다 복잡한 연산을 포함할 수 있다. 또 이 함수를 호출하려면 다음과 같이 아이템의 값, 아이템의 인덱스, 및 Array 오브젝트와 같이 3개의 인수를 사용한다.

    function callback(item:*, index:int, array:Array):Boolean;

    thisObject:* (default = null) — 함수의 this로서 사용하는 오브젝트.

반환값
    Array — 원본 배열내의 아이템으로 true를 돌려준 것을 모두 포함한 새로운 배열이다.

다음의 예에서는 관리자인 모든 종업원의 배열을 작성한다.

package {
        import flash.display.Sprite;
        public class Array_filter extends Sprite {
                public function Array_filter() {

                        var employees:Array = new Array();
                        employees.push({name:"Employee 1", manager:false});
                        employees.push({name:"Employee 2", manager:true});
                        employees.push({name:"Employee 3", manager:false});
                        trace("Employees:");
                        employees.forEach(traceEmployee);

                        var managers:Array = employees.filter(isManager);
                        trace("Managers:");
                        managers.forEach(traceEmployee);
                }
                private function isManager(element:*, index:int, arr:Array):Boolean {
                        return (element.manager == true);
                }
                private function traceEmployee(element:*, index:int, arr:Array):void {
                        trace("t" + element.name + ((element.manager) ? " (manager)" : ""));
                }
        }
}

map() 메소드    
AS3 function map(callback:Function, thisObject:* = null):Array

배열내의 각 아이템에 대해 함수를 실행하여 원본 배열의 각 아이템에 대한 함수의 결과에 대응하는 아이템으로부터 완성되는 새로운 배열을 작성한다.

파라미터
    callback:Function — 배열내의 각 아이템에 대해 실행하는 함수. 이 함수에는 단순한 커멘드 (스트링의 배열의 대문자 소문자의 변경 등)나 보다 복잡한 연산을 포함할 수 있다. 또 이 함수를 호출하려면 다음과 같이 아이템의 값, 아이템의 인덱스, 및 Array 오브젝트와 같이 3개의 인수를 사용한다.

    function callback(item:*, index:int, array:Array):void;
 
    thisObject:* (default = null) — 함수의 this로서 사용하는 오브젝트.

반환값
    Array — 원본배열내의 각 아이템의 함수의 결과가 포함되는 새로운 배열이다.

다음의 예에서는 배열내의 모든 아이템을 대문자로 변경하고 있다.

package {
        import flash.display.Sprite;
        public class Array_map extends Sprite {
                public function Array_map() {
                        var arr:Array = new Array("one", "two", "Three");
                        trace(arr); // one,two,Three

                        var upperArr:Array = arr.map(toUpper);
                        trace(upperArr); // ONE,TWO,THREE
                }
                private function toUpper(element:*, index:int, arr:Array):String {
                        return String(element).toUpperCase();
                }
        }
}

some() 메소드    
AS3 function some(callback:Function, thisObject:* = null):Boolean

true를 돌려주는 아이템에 이를 때까지 배열내의 각 아이템에 테스트 함수를 실행한다. 이 메소드를 사용하면 배열내의 어느 아이템의 기준(값이 특정의 수치보다 작은지 등)을 만족하는지 어떤지를 판별할 수 있다.

파라미터
    callback:Function — 배열내의 각 아이템에 대해 실행하는 함수. 이 함수에는 단순한 비교 (item < 20 등)나 보다 복잡한 연산을 포함할 수 있다. 또 이 함수를 호출하려면 다음과 같이 아이템의 값, 아이템의 인덱스, 및 Array 오브젝트와 같이 3개의 인수를 사용한다.

    function callback(item:*, index:int, array:Array):Boolean;

    thisObject:* (default = null) — 함수의 this로서 사용하는 오브젝트.

반환값
    Boolean — 불리언 값. true를 돌려준다. (지정된 함수에 대해 배열내의 몇개의 아이템이 true를 돌려주는 경우). 그 이외의 경우는 false를 돌려준다.

다음의 예에서는 배열 내 요소 중 undefined 값이 포함된 것을 표시한다.

package {
        import flash.display.Sprite;
        public class Array_some extends Sprite {
                public function Array_some() {
                        var arr:Array = new Array();
                        arr[0] = "one";
                        arr[1] = "two";
                        arr[3] = "four";
                        var isUndef:Boolean = arr.some(isUndefined);
                        trace(isUndef);
                        if (isUndef) {
                                trace("array contains undefined values: " + arr);
                        } else {
                                trace("array contains no undefined values.");
                        }
                }
                private function isUndefined(element:*, index:int, arr:Array):Boolean {
                        return (element == undefined);
                }
        }
}

출력 :
true
array contains undefined values: one,two,,four

오늘 부로 2년 3개월 가량 다니던 회사를 그만두게 되었다. 쉽게 생각하고 편하게 받아들이면 한없이 편하고 좋은 사람들이 많은 회사였는데 내가 왜 나왔을까를 생각해 보면 내가 앞으로 어떻게 살아야 하는지를 대변해 준다.

그 동안 나는 주어진 작업에서 최선 보다는 우선을 생각했고, 그것은 이 바닥의 어쩔 수 없는 프로세스에 의해서 생겨난 전투적인 생활이라는 것을 알게 되었다. 그 속에는 내가 버려야 하는 것들의 아쉬움이 나에게는 너무나도 컸던 것 같다.

하지만 배운 점도 많다. 식당 개 삼년이면 라면을 끓인다고 했던가… 인문계열 고등학교를 나와 컴퓨터과학을 전공한 내가 직접 만들기는 어렵더라도 디자인의 바람직함에 대해 어렴풋하게 느낄 수 있었다. 그리고 취미로만 느꼈던 이 재미난 놀이가 먹고 자는데 도움을 줄 수 있다는 것도 알게 되었다. 그러한 과정에서 내가 하고 싶은 것이 무엇인가를 생각할 수 있는 시간을 나에게 주었던 기간이었다.

현재는 결정된 것이 아무것도 없지만 지금의 나의 느낌은 행복이다. 이 행복은 회사를 그만 두었기 때문에 느끼는 행복이 아니라 새로운 앞날에 대한 내 기대치에서 나오는 행복일거라 나는 믿는다. 획일적인 일상 속에서 쌓였던 번뇌를 씻기 위해 나는 당분간은 폐인모드로 생활해 볼까 한다. 밥 먹고 자고 일어나, 공부하고, 자전거 타고, 여행도 가고, 바다도 보고… 이 시대의 회사원들이 평일에 하지 못하는 것들을 골라서 해볼 참이다…쿠쿠 생각만 해도 당신은 부러워 할꺼다… 메롱~

어쩌면 난 다음주 월요일 아침에 늦잠을 자다 시계를 보고 발작을 일으키며 헐레벌떡 일어나 욕실로 달려갈지도 모른다. 언제나 그랬듯이 이런 나를 한심하게 쳐다보는 밍밍이는 하품을 할게다. 정신을 차리고 나는 이미 평일 아침에 정해진 약속 시간까지 어디로 향해야 하는 규칙을 더이상 지키지 않아도 된다는 것을 알게 될거고, 나는 그 행복을 이불 삼아 덮고 행복한 꿈을 꾸겠지…
.
.
.
.
꿈1
꿈2
꾸움3
.
.
.
아무튼 나는 백수다. ㅠ.ㅠ

일본 가나자와에 있는 시계분수...아이디어가 재미있다....

Flash, Flex Builder, Dreamweaver또는 임의의 텍스트 문자 편집기를 사용하여 as 확장자(extension)를 가지는 외부 ActionScript 원시 파일을 작성할 수 있다.

ActionScript 3.0은 Flash authoring tool나 Flex Builder 등 다양한 어플리케이션 개발 환경에서 사용할 수 있다.

아래에서는 Flash authoring tool 또는 Flex Builder 2 툴을 사용한 간단한 ActionScript 3.0 어플리케이션의 작성과 확장을 스텝 방식으로 학습해본다. 작성하는 어플리케이션은 ActionScript 3.0의 외부 클래스 파일을 Flash 및 Flex 어플리케이션으로 사용하기 위한 단순한 견본을 제시한다. 그 패턴은 다른 모든 어플리케이션에 적용할 수 있는 기본적인 것이다.


ActionScript 어플리케이션의 설계

어플리케이션의 작성을 시작하기 전에 어떠한 어플리케이션을 만들 것인가를 생각할 필요가 있다.

설계는 어플리케이션의 이름과 목적을 나타내는 짧은 설명 등과 같이 간단한 것에서부터 다수의 UML (Unified Modeling Language) 그림을 포함한 것과 같이 복잡한 것으로 나타낼 수 있는데 어느 것을 사용하여도 상관없다. 아래에서 나올 내용은 ActionScript 어플리케이션의 개발과 설계에서 빠뜨릴 수 없는 순서라고 할 수 있다.

다음에서 설명할 어플리케이션은 ActionScript 어플리케이션을 공부할 때 처음으로 사용되는 예로서 단순한 설계를 사용한 표준적인 "Hello World" 어플리케이션이다.

    * 어플리케이션의 이름은 HelloWorld 다.

    * "Hello, World!" 라고하는 문자열이 포함된 텍스트 필드가 1개 표시된다.

    * 이 필드를 간단하게 재이용할 수 있도록 Greeter라는 이름의 객체 지향 클래스가 1개 사용된다. 이 클래스는 Flash 문서 또는 Flex 어플리케이션 내에서 사용할 수 있다.

    * 기본이 되는 어플리케이션을 작성한 후에 유저에게 유저명을 입력시켜서 어플리케이션에 그 이름을 유저 리스트와 조합시키는 새로운 기능을 추가하다.

위와 같이 간결하게 정의하고 어플리케이션의 작성을 시작한다.


HelloWorld 프로젝트와 Greeter 클래스의 작성

Hello World 어플리케이션의 설계 설명에서는 재이용하기 쉬운 코드를 사용한다는 것이 명시되어 있다. 이 목표를 고려하여 어플리케이션은 Greeter라는 이름의 객체 지향 클래스를 1개 사용한다.이 클래스는 Flex Builder 또는 Flash authoring tool로 작성한 어플리케이션 내에서 사용된다.

Flash authoring tool로 Greeter 클래스를 작성하려면:

   1. Flash authoring tool로 [파일]-[신규]를 선택한다.

   2. [신규 문서] 다이알로그 박스로 ActionScript 파일을 선택하여 [OK]를 클릭한다.

ActionScript 편집 윈도우가 표시된다.

   3. [파일]-[저장]을 선택한다. 어플리케이션을 보존하는 폴더를 선택하여 ActionScript 파일에 Greeter.as라는 이름을 붙여 [OK]를 클릭한다.

 
Greeter 클래스에의 코드의 추가

Greeter 클래스는 오브젝트 Greeter를 정의하고 이것을 통해 HelloWorld 어플리케이션을 사용할 수 있다.

Greeter 클래스에 코드를 추가하려면 :

   1. 새로운 파일에 다음 코드를 입력한다.

package
{
        public class Greeter
        {
                public function sayHello():String

                {
                        var greeting:String;
                        greeting = "Hello World!";
                        return greeting;
                }
        }
}

Greeter 클래스에서는 " Hello World!";"라는 문자열을 돌려주는 1개의 sayHello() 메소드가 포함되어 있다.

   2. [파일]-[저장]을 선택하고 이 ActionScript 파일을 저장한다..

이로써 Flash 또는 Flex 어플리케이션으로 Greeter 클래스를 사용할 수 있게 되었다.


ActionScript 코드를 사용하는 어플리케이션의 작성

작성된 Greeter 클래스는 필요한 것을 모두 갖춘 어플리케이션이지만 어플리케이션 전부를 나타내는 것은 아니다. Greeter 클래스를 사용하려면 Flash 문서 또는 Flex 어플리케이션을 작성할 필요가 있다.

HelloWorld 어플리케이션에서는 Greeter 클래스의 새로운 인스턴스가 작성된다. 다음에 나타내는 것은 어플리케이션에 Greeter 클래스를 합성하는 방법이다..

Flash authoring tool를 사용해 ActionScript 어플리케이션을 작성하려면:

   1. [파일]-[신규]를 선택한다.

   2. [신규 문서] 다이알로그 박스로 [Flash 문서]를 선택하고 [OK]를 클릭한다.

새로운 Flash 윈도우가 표시된다.

   3. [파일]-[저장]을 선택한다. Greeter.as 클래스 파일과 같은 폴더를 선택하여 Flash 문서에 HelloWorld.fla라는 이름을 붙이고 [OK]를 클릭한다.

   4. [Flash 툴] 팔레트로 [텍스트 툴]을 선택한 후, 스테이지상에서 드레그 하여 폭 300 픽셀, 높이 약 100 픽셀의 새로운 텍스트 필드를 정의한다.

   5. 스테이지상의 텍스트 필드가 선택된 상태에서 [프롭퍼티] 윈도우에 텍스트 필드의 인스턴스명을 mainText라고 입력한다.

   6. 메인 타임 라인의 최초의 프레임을 클릭한다.

   7. [액션] 패널에 다음의 스크립트를 입력한다.

	var myGreeter:Greeter = new Greeter();
	mainText.text = myGreeter.sayHello();

   8. 파일을 저장한다.

ActionScript 어플리케이션의 퍼블리시를 통한 테스트

어플리케이션 개발은 반복 프로세스다. 코드를 기술하여 컴파일 하고 올바르게 컴파일 될 때까지 코드를 편집한다. 컴파일 된 어플리케이션을 실행해 테스트하고 의도한 설계가 실현되고 있는지 어떤지를 확인한다. 의도한 설계대로 실현되지 않을 경우에는 실현될 때까지 코드를 편집한다. Flash 및 Flex Builder의 개발 환경에는 어플리케이션을 퍼블리시, 테스트, 및 디버그 하는 다수의 방법이 준비되어 있다.

다음에 각 환경에서 HelloWorld 어플리케이션을 테스트하는 기본적인 순서를 나타낸다.

Flash authoring tool를 사용해 ActionScript 어플리케이션을 퍼블리시 및 테스트하려면:

   1. 어플리케이션을 퍼블리시하고, compile error가 없는가 확인한다. Flash authoring tool로 [컨트롤]-[무비 프리뷰]를 선택하고 ActionScript 코드를 컴파일 하여 HelloWorld 어플리케이션을 실행한다.

   2. 어플리케이션을 테스트했을 때, [출력] 윈도우에 에러나 경고가 표시되었을 경우에는HelloWorld.fla 또는 HelloWorld.as 파일에서 에러의 원인을 수정하고 나서 어플리케이션의 테스트를 다시 시도한다.

   3. compile error가 없으면 Flash Player 윈도우에 Hello World 어플리케이션이 표시된다. 윈도우에는 "Hello World!"라는 텍스트가 표시된다.

 
이로써 간단하지만 ActionScript 3.0을 사용하여 완전한 객체 지향 어플리케이션을 작성할 수 있었다. 다음으로는 HelloWorld 어플리케이션을 확장해본다.


HelloWorld 어플리케이션의 확장

여기에서는 어플리케이션을 좀 더 흥미롭게 작성 해본다. 어플리케이션에 유저명을 요구시켜서 그것을 이름 리스트와 검증시켜본다.

우선 Greeter 클래스를 갱신해 새로운 기능을 추가한다. 다음에 Flex 또는 Flash 어플리케이션을 갱신해 새로운 기능을 추가한다.

Greeter.as 파일을 갱신하려면 :

   1. "Greeter.as" 파일을 연다.

   2. 파일의 내용을 다음과 같이 변경한다.

package{
        public class Greeter{
                // Defines the names that should receive a proper greeting.

                public static var validNames:Array = ["Sammy", "Frank", "Dean"];

                // Builds a greeting string using the given name.

                public function sayHello(userName:String = ""):String{

                        var greeting:String;

                        if (userName == ""){
                                greeting = "Hello. Please type your user name, and then press the Enter key.";
                        }else if (validName(userName)){
                                greeting = "Hello, " + userName + ".";
                        }else{
                                greeting = "Sorry, " + userName + ",you are not on the list.";
                        }
                        return greeting;
                }

                // Checks whether a name is in the validNames list.

                public static function validName(inputName:String = ""):Boolean{
                        if (validNames.indexOf(inputName) > -1){
                                return true;
                        }else{
                                return false;
                        }
                }
        }
}

Greeter 클래스는 몇개의 새로운 기능이 추가되었다.

   3. validNames 배열은 유효한 유저명을 리스트로 나타낸다. 이 배열은 Greeter 클래스의 로드시에 3개의 이름의 리스트에 초기화된다.

   4. sayHello() 메소드는 유저명을 받아들여 어떠한 조건에 근거하여 인사를 변경할 수 있게 된다. userName이 문자열 ("") 인 경우 greeting 프롭퍼티는 유저에게 이름의 입력을 요구하는 것으로 설정한다. 유저명이 유효하면 인사는 "Hello, userName"이 된다. 마지막으로 2개의 조건 어느 쪽에도 적합하지 않는 경우에는 greeting 변수는 "Sorry, userName, you are not on the list." 로 설정된다.

   5. validName() 메소드는 inputName변수 값을 validNames 배열내에서 발견했을 경우에는 true 를, 발견되지 않았을 경우에는 false를 반환한다. 스테이트먼트 validNames.indexOf(inputName) 는 validNames 배열 내에서 inputName 문자열과 같은 문자열이 있는지를 검사한다. Array.indexOf() 메소드는 배열내의 오브젝트 초기의 인스턴스의 인덱스 위치, 또는 오브젝트가 배열에 발견되지 않았을 경우에는 값 -1을 반환한다.

 
아래와 같이 Flash 파일 또는 Flex 파일을 편집한다.

 
Flash authoring tool를 사용해 어플리케이션을 변경하려면:

   1. HelloWorld.fla 파일을 연다.

   2. 프레임 1의 스크립트를 아래와 같이 변경하고 문자열 ("")를 Greeter 클래스의 sayHello() 메소드에게 건네도록 한다.
 

	var myGreeter:Greeter = new Greeter();
	mainText.text = myGreeter.sayHello("");

   3. [툴] 팔레트의 [텍스트] 툴을 선택하고 스테이지상에서 기존의 mainText 텍스트 필드의 바로 아래에 2개의 새로운 텍스트 필드를 작성한다.

   4. 최초의 텍스트 필드의 라벨이 되는 텍스트로서 User Name: 이라고 입력한다.

   5. 1개의 새로운 텍스트 필드를 선택하고 텍스트 필드의 타입으로서 InputText를 선택한다. 인스턴스명으로서 textIn이라고 입력한다.

   6. 메인 타임 라인의 최초의 프레임을 클릭한다.

   7. [액션] 패널에서 기존의 스크립트의 아래에 아래와 같은 스크립트를 추가한다.

mainText.border = true;
textIn.border = true;

textIn.addEventListener(KeyboardEvent.KEY_UP, keyPressed);

function keyPressed(event:Event):void
{
        if (event.keyCode == Keyboard.ENTER)
        {
                mainText.text = myGreeter.sayHello(textIn.text);
        }
}
이 스크립트는 아래와 같은 기능을 한다

   8. 최초의 2행은 단순하게 2개의 텍스트 필드의 경계선을 정의한다.

   9. textIn 필드 등의 입력 텍스트 필드에는 dispatch 할 수 있는 이벤트 세트가 있다. addEventListener() 메소드에 의해서 특정의 타입의 이벤트가 발생했을 때에 실행되는 함수를 정의할 수 있다. 이 예에서는 키보드의 Enter 키를 떼었을 때 이벤트를 처리하게 된다.

  10. keyPressed() 커스텀 함수는 myGreeter 오브젝트의 sayHello() 메소드를 호출하여 textIn 텍스트 필드의 텍스트를 파라미터로서 건네준다. 이 메소드는 건네 받은 값에 근거하여 인사의 문자열을 돌려준다. 반환된 문자열은 mainText 텍스트 필드의 text 프롭퍼티에 할당할 수 있다.

프레임 1의 완전한 스크립트는 다음과 같다.

mainText.border = true;
textIn.border = true;

var myGreeter:Greeter = new Greeter();
mainText.text = myGreeter.sayHello("");

textIn.addEventListener(KeyboardEvent.KEY_UP, keyPressed);

function keyPressed(event:Event):void
{
        if (event.keyCode == Keyboard.ENTER)
        {
                mainText.text = myGreeter.sayHello(textIn.text);
        }
}

  11. 파일을 저장한다.

  12. [컨트롤]-[무비 프리뷰]를 선택하고 어플리케이션을 실행한다.

어플리케이션을 실행하면 유저명 입력을 통해서 메시지를 구할 수 있다. 유효한 유저명 (Sammy ,Frank , 또는 Dean)를 입력하면 "hello"라는 확인 메세지가 표시된다.

ActionScript 3.0에서는 사용할 수 있는 많은 데이터형이 있다. 이러한 데이터형에는 "단순한" 또는 "기본적인" 데이터형이라고 볼 수 있는 것이 있다.

    * String : 이름 또는 텍스트 형태의 문자
    * Numeric : ActionScript 3.0에는 수치 데이터형으로 3종류의 데이터형을 사용한다.
          o Number : 소수점이 있거나 없는 값을 포함한 모든 수치
          o int : 정수 (소수점이 없는 자연수)
          o uint : 부호 없는 정수. 즉 부의 수가 되지 않는 자연수
    * Boolean : 스위치의 on이나 off, 2개의 값이 동일한가 아닌가 등의 true 나 false의 값

단순한 데이터형은 1개의 정보를 나타낸다. 예를 들어 단일의 숫자 또는 텍스트의 1문장 등이지만 ActionScript에서 정의되는 데이터형의 대부분은 정리되고 그룹화된 세트값을 나타내기 위해 복잡한 데이터형으로서 기술할 수 있다. 예를 들어 데이터형 Date의 변수는 1개의 값, 즉 특정의 시점을 나타내지만 그 일자의 값은 실제로는 일, 월, 년, 시간, 분 , 초 등 복수의 값으로 나타내며 모두 개별의 수치를 갖는다. 이 때문에 일자는 단일의 값으로 해서 생각하지만 (Date 변수를 작성해 단일의 값으로 해서 처리할 수 있지만) 컴퓨터의 내부에서는 1개의 일자를 정의하는 복수 값으로부터 완성되는 그룹이라고 볼 수 있다.

프로그래머가 정의하는 데이터형 이외의 데이터형 대부분은 복잡한 데이터형이다. 복잡한 데이터형이라고 할 수 있는 것은 다음과 같다.

    * MovieClip : 무비 클립 심볼
    * TextField : 다이나믹 텍스트 필드 또는 텍스트 입력 필드
    * SimpleButton : 버튼 심볼
    * Date : 특정의 시점에 관한 정보 (일자와 시간)

데이터형과 같은 의미로 많이 사용되는 용어에 클래스와 오브젝트가 있다. 클래스는 단지 데이터형을 정의한 것이고 오브젝트는 클래스의 실제의 인스턴스다. MovieClip의 변수는 MovieClip 오브젝트로 기술할 수 있다.

아래 예에서는 MouseEventExample 및 ChildSprite 클래스를 사용하여 단순한 이미지를 사용, 마우스 이벤트가 송출되는 방법을 나타낸다.

package {
        import flash.display.Sprite;

        public class MouseEventExample extends Sprite {
                private var size:uint = 100;
                private var bgColor:uint = 0xFFCC00;

                public function MouseEventExample() {
                        var child:ChildSprite = new ChildSprite();
                        addChild(child);
                }
        }
}

import flash.display.Sprite;
import flash.events.MouseEvent;

class ChildSprite extends Sprite {
        private var size:uint = 50;
        private var overSize:uint = 60;
        private var backgroundColor:uint = 0xFFCC00;
        private var overColor:uint = 0xCCFF00;
        private var downColor:uint = 0x00CCFF;

        public function ChildSprite() {
                draw(size, size, backgroundColor);
                addEventListener(MouseEvent.CLICK, clickHandler);
                addEventListener(MouseEvent.DOUBLE_CLICK, doubleClickHandler);
                addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
                addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
                addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
                addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
                addEventListener(MouseEvent.MOUSE_WHEEL, mouseWheelHandler);
        }

        private function draw(w:uint, h:uint, bgColor:uint):void {
                graphics.clear();
                graphics.beginFill(bgColor);
                graphics.drawRect(0, 0, w, h);
                graphics.endFill();
        }

        private function clickHandler(event:MouseEvent):void {
                trace("clickHandler");
        }

        private function doubleClickHandler(event:MouseEvent):void {
                trace("doubleClickHandler");
        }

        private function mouseDownHandler(event:MouseEvent):void {
                trace("mouseDownHandler");
                draw(overSize, overSize, downColor);

                var sprite:Sprite = Sprite(event.target);
                sprite.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
                sprite.startDrag();
        }

        private function mouseMoveHandler(event:MouseEvent):void {
                trace("mouseMoveHandler");
                event.updateAfterEvent();
        }

        private function mouseOutHandler(event:MouseEvent):void {
                trace("mouseOutHandler");
                draw(size, size, backgroundColor);
        }

        private function mouseOverHandler(event:MouseEvent):void {
                trace("mouseOverHandler");
                draw(overSize, overSize, overColor);
        }

        private function mouseWheelHandler(event:MouseEvent):void {
                trace("mouseWheelHandler delta: " + event.delta);
        }

        private function mouseUpHandler(event:MouseEvent):void {
                trace("mouseUpHandler");
                var sprite:Sprite = Sprite(event.target);
                sprite.removeEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
                sprite.stopDrag();
                draw(overSize, overSize, overColor);
        }
}

이 예제 소스는 다음과 같이 처리 한다.

1.    사각을 만드는데 사용하는 사이즈 (100 × 100 픽셀)와 배경색 (오렌지색)의 프롭퍼티를 선언한다.
2.    Constructor의 ChildSprite 오브젝트 child를 작성한다. 처음에 child의 constructor에서 draw() 메소드를 호출하여 오렌지색의 100 × 100 픽셀의 사각형을 (0,0) 의 좌표에 표시한다. 그 다음 코드는 7 개의 이벤트 청취자와 각 핸들러 메소드를 추가로 작성한다.

*    click/clickHandler() : 마우스 커서를 사각형 위에 놓고 왼쪽 mouse button을 싱글 클릭 했을 때 송출된다.
*    doubleClick/doubleClickHandler( ): 사각형 위에서 왼쪽 mouse button이 더블 클릭 되었을 때 송출된다.
*    mouseDown/mouseDownHandler() : ChildSprite 오브젝트 (오렌지색의 사각형)를 클릭하면 trace() 메세지가 화면에 표시되고 ChildSprite.draw()를 호출하여 mouseOverHandler()에서 나타난 밝은 청색의 사각형 위치에 어두운 황색 사각형이 표시된다. 또 mouseDownHandler() 메소드에 의해서 mouseMove 이벤트 청취자를 등록한다. 이것에 의해서 마우스의 이동이 처리되고 startDrag() 메소드를 호출하게 되어 Sprite 오브젝트의 드러그가 가능하게 된다.
*    mouseOut/mouseOutHandler() : 포인터가 사각형의 영역을 out하면 송출된다. draw() 메소드를 호출하여 사각형을 기존의 디폴트 색으로 변환한다.
*    mouseOver/mouseOverHandler( ): 마우스 포인터가 사각형과 겹쳐지면 송출된다. 이 메소드를 통해서 사각형은 어두운 황색 배경색으로 바뀌고 크기도 커진다.
*    mouseUp/mouseUpHandler(): 유저가 mouse button을 떼어 놓으면 mouseMove 이벤트 청취자가 삭제되어 stopDrag된다.
*    mouseMove/mouseMoveHandler(): 왼쪽 mouse button을 클릭하고 있는 동안 이 메소드는 Flash Player에 대해서 계속 오렌지색의 사각형을 다시 그리기를 요청하게 된다.
*    mouseWheel/mouseWheelHandler(): 사각형 위에서 마우스 휠을 회전시켰을 때에 송출된다.

package {

   import flash.display.Sprite;
   import flash.display.StageAlign;
   import flash.display.StageScaleMode;
   import flash.events.Event;

   public class StageExample extends Sprite {

      public function StageExample() {
         stage.scaleMode = StageScaleMode.NO_SCALE;
         stage.align = StageAlign.TOP_LEFT;
         stage.addEventListener(Event.ACTIVATE, activateHandler);
         stage.addEventListener(Event.RESIZE, resizeHandler);
      }

      private function activateHandler(event:Event):void {
         trace("activateHandler: " + event);
      }

      private function resizeHandler(event:Event):void {
         trace("resizeHandler: " + event);
         trace("stageWidth: " + stage.stageWidth + " stageHeight: " + stage.stageHeight);
      }
   }
}