jasu's blog

WiiFlashServer 0.4.exe

wiiBasicDocument.exe

사진출처 : 문군

사진출처 : 문군

사진출처 : 문군

사진출처 : 문군

ActionScript발표자료.alz

ActionScript발표자료.a01

ActionScript발표자료.a00

엑셀에서의 XML 스프레드시트를 저장하여 일련의 숫자 데이터를 LineGraph로 표현해주는 기능을 한다. 사내 회의 때 사용할 목적으로 만들게 되었다. 사용하는 XML 스프레드시트 데이터는 기본적으로 규칙을 가지고 있는데 아래와 같다.

하나의 셀에는 1뎁스, 2뎁스, 3뎁스까지 표현을 하고 그 이후 데이터들은 날자 별로 각각의 데이터가 들어가게 된다. 반듯이 지켜야 할 규칙은 1뎁스, 2뎁스, 3뎁스를 표현해야 하며 3뎁스의 첫번째 group의 [방문수, 절대 고유 방문자수, 페이지뷰, 평균 페이지뷰, 사이트 방문 시간] 5개의 데이터 타입을 아래에 group에서도 똑같이 적용을 하여야 한다.

위 최소한의 규칙을 적용한다면 cell의 가로 길이나 1뎁스, 2뎁스의 개수는 몇 개라도 상관이 없다.

이렇게 한 이유는 사용하고자 하는 데이터의 형태를 따르게 되었기 때문이다. 초기 작업 진행에 있어서 xml 스프레드시트 데이터의 형태가 트리구조의 형태를 갖지 못하기 때문에 데이터 표현에 있어서 어떠한 방법을 사용해야 하는지가 고민이었다. 1뎁스 데이터 안에 2뎁스와 3뎁스를 group화 할 경우에 각각의 데이터 비교에 있어서 하나의 그래프에 여러 개의 라인그래프를 넣어야 할 경우 불필요한 참조 형태이기 때문에 복잡한 데이터 구조를 조합하여 하나의 group데이터로 표현해야 하는 문제가 있었다. 이로 인해 CPU낭비와 구조화 작업에 있어서 어려움이 예상되었다.

그래서 뎁스에 따른 데이터를 group화 하지 않고 xml 스프레드시트의 각 라인별(cell단위)를 기준으로 하나의 데이터로 표현하고 AssetData 클래스를 통해서 각각의 cell 데이터를 검사하여 원하는 서비스별 데이터를 array로 받아올 수 있도록 하였다.

이렇게 데이터를 구분하였을 때 1뎁스, 2뎁스에서 원하는 데이터들을 멀티 선택하여 화면에 표현할 수 있게 되었다.

한 화면에서 보여질 수 있는 그래프는 위에서 언급한 것과 같이  [방문수, 절대 고유 방문자수, 페이지뷰, 평균 페이지뷰, 사이트 방문 시간] 5개의 그래프 컨테이너를 보여줄 수 있으며 각각의 그래프컨테이너에는 여러 개의 cell 데이터에 해당하는 라인그래프를 표현할 수 있다.

상단에 풀스크린을 지원하는 아이콘을 클릭할 경우 풀스크린으로 보여질 수 있으나 flashPlayer에서의 풀스크린을 할 경우 키보드 이벤트가 작동하지 않기 때문에 멀티선택을 할 수 없는 문제점이 있다. exe파일은 풀스크린이더라도 키보드 입력을 받을 수 있다.

exe파일 버전으로 올려 놓는다. xml데이터는 가상의 데이터 값을 넣어두었으니 필요하신 분은 비교 대상의 데이터를 직접 넣어서 사용해보면 좋을 것 같다. 플래시 안에서 data.xml 파일을 로드하게 해놓았으니 Logger.exe파일과 같은 폴더에 data.xml 데이터를 넣어서 사용하면 된다.

Logger.zip

http://dicaland.cafe24.com/blog/logger/Logger.swf

OBJECTIVES

• Minimize file size
• Maximize flexibility and efficiency by extending the TweenLite class. That way, if you don't need to tween filters, you can just use TweenLite (about 2k); otherwise, this class will only add another 3k (5k total)
• Minimize the amount of code required to initiate a tween
• Maximize performance
• Allow for very flexible callbacks (onComplete, onUpdate, onStart, all with the ability to pass any number of parameters)

FITLERS & PROPERTIES:

• type:"Blur" -
  blurX, blurY, quality
• type:"Glow" -
  alpha, blurX, blurY, color, strength, quality
• type:"Color" -
  colorize, amount, contrast, brightness, saturation, hue, threshold, relative
• type:"DropShadow" -
  alpha, angle, blurX, blurY, color, distance, strength, quality
• type:"Bevel" -
  angle, blurX, blurY, distance, highlightAlpha, highlightColor, shadowAlpha, shadowColor, strength, quality

USAGE

EXAMPLES

FAQ

1. Can I set up a sequence of tweens so that they occur one after the other?
   Of course! Just use the delay property and make sure you set the overwrite property to false (otherwise tweens of the same object will always overwrite each other to avoid conflicts). Here's an example where we colorize a MovieClip red over the course of 2 seconds, and then blur it over the course of 1 second:
   1. import gs.TweenFilterLite;
   2. TweenFilterLite.to(clip_mc, 2, {type:"color", colorize:0xFF0000, amount:1});
   3. TweenFilterLite.to(clip_mc, 1, {type:"blur", blurX:20, blurY:20, delay:2, overwrite:false});

2. Do the properties have to be in a specific order?
   Nope. The only thing that matters is that the first parameter is the object you're tweening, the second parameter is the time (in seconds), and the third parameter contains all the properties you want to tween (in any order). So TweenFilterLite.to(clip_mc, 1, {type:"color", colorize:0xFF0000, amount:1}) is the same as TweenFilterLite.to(clip_mc, 1, {amount:1, colorize:0xFF0000, type:"color"});

3. Can I use TweenFilterLite to tween things other than filters?
   Sure. It extends TweenLite, so you can tween any property you want. TweenFilterLite.to(my_mc, 1, {x:200}) gives you the same result as TweenLite.to(my_mc, 1, {x:200}). However, I'd recommend using TweenLite to tween properties other than filters for two reasons:
   1. In order to accommodate the specialized nature of filters, TweenFilterLite's code is a bit lengthier which translates into more work for the processor. It's doubtful that anyone would notice a performance hit unless you're tweening hundreds or thousands of instances simultaneously, but I'm a bit of an efficiency freak.
   2. TweenLite can tween any property of ANY object whereas TweenFilterLite tweens properties of DisplayObjects (like MovieClips, Sprites, etc.)

4. Why are TweenLite and TweenFilterLite split into 2 classes instead of building all the functionality into one class?
   1. File size. Only a portion of projects out there require tweening of filters. Almost every project I work on uses TweenLite, but only a few require tweening filters (TweenFilterLite). TweenLite is 2k whereas TweenFilterLite is 5k. Again, one of the stated purposes of TweenLite is to minimize file size & code bloat. If someone only wants to use TweenFilterLite, fine. But I think many people appreciate being able to use the most lightweight option for their needs and shave off the 3k when possible.
   2. Speed. Tweening filters is a more complex task. There are additional if/else statements and calculations in the rendering loop inside TweenFilterLite which could potentially slow things down a bit, even for non-filter tweens (I doubt anyone would notice a difference unless they’re running hundreds or thousands of simultaneous tweens, but I’m a big fan of keeping things as efficient & fast as possible)

5. Do I have to pay for a license to use this code? Can I use it for commercial purposes?
   Feel free to take the code and use it as you wish, even for commercial purposes. Some people have requested the ability to donate money to reward the work I put into the class(es), so i put a PayPal "donate now" button at the top and bottom of the page, but you certainly don't need to donate anything. I'm just glad to help the Flash community.

6. Are TweenLite and TweenFilterLite better than Tweener, Fuse, MC Tween, and all the other tweening engines out there?
   Maybe, maybe not. It all depends on your objectives, coding style, etc. I certainly don't claim that TweenLite & TweenFilterLite are superior to all other tweening engines, but in terms of the power-to-file-size ratio, I certainly haven't seen anything that comes close. Feedback has been overwhelmingly positive. I've used TweenLite for many years and it has never let me down. I've never found myself needing features that are available in another tweening engine. But hey, to each his own.

package {
        import flash.display.DisplayObject;
        import flash.display.Sprite;
        import flash.utils.getDefinitionByName;

        public class GetDefinitionByNameExample extends Sprite {
                private var bgColor:uint = 0xFFCC00;
                private var size:uint = 80;

                public function GetDefinitionByNameExample() {
                        var ClassReference:Class = getDefinitionByName("
                                                   flash.display.Sprite") as Class;
                        var instance:Object = new ClassReference();
                        instance.graphics.beginFill(bgColor);
                        instance.graphics.drawRect(0, 0, size, size);
                        instance.graphics.endFill();
                        addChild(DisplayObject(instance));
                }
        }
}

Project Page: http://code.google.com/p/as3flickrlib/
Project Group: http://groups.google.com/group/as3flickrlib

위 구글 코드에서 오픈되어 있는 flickr API adobe 소스를 UML로 변환해 보았다. 필요하신 분들은 참고하시면 좋을 듯 싶다. 기본적인 상속과 합성관계만 형성해 놓은 상태, 대부분 합성으로 페키지가 구성되어 있다.

참고. 새벽에 작성한 관계로 틀린 부분이 있을 수 있음.

package A_package {
        public class A_class {

                private     	var p1:uint;
                protected     	var p2:uint;
                internal    	var p3:uint;
                public        	var p4:uint;

                public function A_class() {

                        p1 = 1; // OK
                        p2 = 2; // OK
                        p3 = 3; // OK
                        p4 = 4; // OK

                }
        }
}

package A_package {
        public class B_class extends A_class {

                public function B_class() {

                        v1 = 1; // error
                        v2 = 2; // OK
                        v3 = 3; // OK
                        v4 = 4; // OK

                }
        }
}

package A_package {
        public class C_class {

                public function C_class() {

                        var a:A_class = new A_class();

                        a.v1 = 1; // error
                        a.v2 = 2; // error
                        a.v3 = 3; // OK
                        a.v4 = 4; // OK

                }
        }
}

package B_package {

        import A_package.A_class;

        public class D_class extends A_class {

                public function D_class() {

                        v1 = 1; // error
                        v2 = 2; // OK
                        v3 = 3; // error
                        v4 = 4; // OK

                }
        }
}

package B_package {

        import A_package.A_class;

        public class E_class {

                public function E_class() {

                        var a:A_class = new A_class();

                        a.v1 = 1; // error
                        a.v2 = 2; // error
                        a.v3 = 3; // error
                        a.v4 = 4; // OK

                }
        }
}

private function setScrollBarStyle(s:UIScrollBar):void{
        s.setStyle("downArrowDisabledSkin", DScrollArrowDown_disabledSkin);
        s.setStyle("downArrowDownSkin", DScrollArrowDown_downSkin);
        s.setStyle("downArrowOverSkin", DScrollArrowDown_overSkin);
        s.setStyle("downArrowUpSkin", DScrollArrowDown_upSkin);

        s.setStyle("upArrowDisabledSkin", DScrollArrowUp_disabledSkin);
        s.setStyle("upArrowDownSkin", DScrollArrowUp_downSkin);
        s.setStyle("upArrowOverSkin", DScrollArrowUp_overSkin);
        s.setStyle("upArrowUpSkin", DScrollArrowUp_upSkin);

        s.setStyle("thumbDownSkin", DScrollThumb_downSkin);
        s.setStyle("thumbIcon", DScrollBar_thumbIcon);
        s.setStyle("thumbOverSkin", DScrollThumb_overSkin);
        s.setStyle("thumbUpSkin", DScrollThumb_upSkin);
        s.setStyle("trackSkin", DScrollTrack_Skin);
}

package viewer.skins{
        import flash.display.DisplayObject;
        import flash.geom.Transform;
        import flash.geom.ColorTransform;

        public class TintColor{
                public function TintColor():void{}
                public static function setTintColor(d:DisplayObject, c:uint, a:Number):void{
                        var resultColorTransform:ColorTransform = new ColorTransform();
                        resultColorTransform.alphaMultiplier = a;
                        resultColorTransform.color = c;

                        var transformation:Transform = d.transform;
                        transformation.colorTransform = resultColorTransform;
                }
        }
}

trace(getResult());
function getResult(a:int=1, b:int=2, c:int=3):Number {
        return (a + b) * c;
}

trace(getResult());
function getResult(a:int=1, b:int=2, c:int=3):Number {
        return a + b * c;
}

lockTest(700, 700);

function lockTest(w:uint, h:uint) {
        var bm:BitmapData = new BitmapData(w,h);
        addChild(new Bitmap(bm));

        trace("lock/Unlock 사용 안함 : "+drawBitmap(bm) + "ms");

        bm.lock();
        trace("lock/Unlock 사용 : "+drawBitmap(bm) + "ms");
        bm.unlock();
}
function drawBitmap(bm:BitmapData):uint {
        var start:uint = getTimer();
        var w:uint=bm.width;
        var h:uint=bm.height;

        for (var x:uint=0; x < w; x++) {
                for (var y:uint=0; y < h; y++) {
                        bm.setPixel(x,y,Math.random()*0xFFFFFF);
                }
        }
        return getTimer() - start;
}

// output
lock/Unlock 사용 안함 : 214ms
lock/Unlock 사용 : 157ms

package{
        import flash.display.Sprite;
        public class FindGuitarTester extends Sprite{
                private var inventory:Inventory;
                private var whatErinLikes:GuitarSpec;
                private var matchingGuitars:Array;
                public function FindGuitarTester():void{
                        inventory = new Inventory();
                        initialize();
                }
                private function initialize():void{
                        initializeInventory(inventory);
                        whatErinLikes = new GuitarSpec(Builder.FENDER, "Stratocastor", Type.ELECTRIC, 6, Wood.ALDER, Wood.ALDER);
                        matchingGuitars = inventory.search(whatErinLikes);
                        if (matchingGuitars != null) {
                                trace("Erin, you might like these guitars:");
                                var len:int = matchingGuitars.length;
                                for (var i:int=0;i<len;i++) {
                                        var guitar:Guitar = matchingGuitars[i];
                                        var spec:GuitarSpec = guitar.getSpec();
                                        trace("  We have a " +
                                        spec.getBuilder() + " " + spec.getModel() + " " +
                                        spec.getType() + " guitar:\n     " +
                                        spec.getBackWood() + " back and sides,\n     " +
                                        spec.getTopWood() + " top.\n  You can have it for only $" +
                                        guitar.getPrice() + "!\n  ----");
                                }
                        } else {
                                trace("Sorry, Erin, we have nothing for you.");
                        }
                }
                private function initializeInventory(inventory:Inventory):void {
                        inventory.addGuitar("11277", 3999.95, new GuitarSpec(Builder.COLLINGS, "CJ", Type.ACOUSTIC, 6, Wood.INDIAN_ROSEWOOD, Wood.SITKA));
                        inventory.addGuitar("V95693", 1499.95, new GuitarSpec(Builder.FENDER, "Stratocastor", Type.ELECTRIC, 6, Wood.ALDER, Wood.ALDER));
                        inventory.addGuitar("V9512", 1549.95, new GuitarSpec(Builder.FENDER, "Stratocastor", Type.ELECTRIC, 6, Wood.ALDER, Wood.ALDER));
                        inventory.addGuitar("122784", 5495.95, new GuitarSpec(Builder.MARTIN, "D-18", Type.ACOUSTIC, 6, Wood.MAHOGANY, Wood.ADIRONDACK));
                        inventory.addGuitar("76531", 6295.95, new GuitarSpec(Builder.MARTIN, "OM-28", Type.ACOUSTIC, 6, Wood.BRAZILIAN_ROSEWOOD, Wood.ADIRONDACK));
                        inventory.addGuitar("70108276", 2295.95, new GuitarSpec(Builder.GIBSON, "Les Paul", Type.ELECTRIC, 6, Wood.MAHOGANY, Wood.MAHOGANY));
                        inventory.addGuitar("82765501", 1890.95, new GuitarSpec(Builder.GIBSON, "SG '61 Reissue", Type.ELECTRIC, 6, Wood.MAHOGANY, Wood.MAHOGANY));
                        inventory.addGuitar("77023", 6275.95, new GuitarSpec(Builder.MARTIN, "D-28", Type.ACOUSTIC, 6, Wood.BRAZILIAN_ROSEWOOD, Wood.ADIRONDACK));
                        inventory.addGuitar("1092", 12995.95, new GuitarSpec(Builder.OLSON, "SJ", Type.ACOUSTIC, 12, Wood.INDIAN_ROSEWOOD, Wood.CEDAR));
                        inventory.addGuitar("566-62", 8999.95, new GuitarSpec(Builder.RYAN, "Cathedral", Type.ACOUSTIC, 12, Wood.COCOBOLO, Wood.CEDAR));
                        inventory.addGuitar("6 29584", 2100.95, new GuitarSpec(Builder.PRS, "Dave Navarro Signature", Type.ELECTRIC, 6, Wood.MAHOGANY, Wood.MAPLE));
                }
        }
}

// Inventory.as

package{
        public class Inventory{
                private var guitars:Array;
                public function Inventory():void{
                        guitars = new Array();
                }
                public function addGuitar(serialNumber:String, price:Number, spec:GuitarSpec):void{
                        var guitar:Guitar = new Guitar(serialNumber, price, spec);
                        guitars.push(guitar);
                }
                public function getGuitar(serialNumber:String):Guitar{
                        var len:int = guitars.length;
                        for(var i:int=0;i<len;i++){
                                if(guitars[i].getSerialNumber() == serialNumber){
                                        return guitars[i];
                                }
                        }
                        return null;
                }
                public function search(searchSpec:GuitarSpec):Array{
                        var matchingGuitars = new Array();
                        var len:int = guitars.length;
                        for(var i:int=0;i<len;i++){
                                if(guitars[i].getSpec().matches(searchSpec)){
                                        matchingGuitars.push(guitars[i]);
                                }
                        }
                        return matchingGuitars;
                }
        }

}

// GuitarSpec.as

package {
        public class GuitarSpec {
                private var builder:String;
                private var model:String;
                private var type:String;
                private var numStrings:int;
                private var backWood:String;
                private var topWood:String;

                public function GuitarSpec(builder:String, model:String, type:String, numStrings:int, backWood:String, topWood:String) {
                        this.builder = builder;
                        this.model = model;
                        this.type = type;
                        this.numStrings = numStrings;
                        this.backWood = backWood;
                        this.topWood = topWood;
                }

                public function getBuilder():String {
                        return builder;
                }

                public function getModel():String {
                        return model;
                }

                public function getType():String {
                        return type;
                }

                public function getNumStrings():int {
                        return numStrings;
                }

                public function getBackWood():String {
                        return backWood;
                }

                public function getTopWood():String {
                        return topWood;
                }

                public function matches(otherSpec:GuitarSpec):Boolean {
                        if (builder != otherSpec.getBuilder()) {
                                return false;
                        }
                        if ((model != null) && (model !="") && (model.toLowerCase() != (otherSpec.getModel().toLowerCase()))) {
                                return false;
                        }
                        if (type != otherSpec.getType()) {
                                return false;
                        }
                        if (numStrings != otherSpec.getNumStrings()) {
                                return false;
                        }
                        if (backWood != otherSpec.getBackWood()) {
                                return false;
                        }
                        if (topWood != otherSpec.getTopWood()) {
                                return false;
                        }
                        return true;
                }
        }
}

package{
        public class Guitar{
                private var serialNumber:String;
                private var price:Number;
                private var spec:GuitarSpec;
                public function Guitar(serialNumber:String, price:Number, spec:GuitarSpec):void{
                        this.serialNumber = serialNumber;
                        this.price = price;
                        this.spec = spec;
                }
                public function getSerialNumber():String{
                        return serialNumber;
                }
                public function getPrice():Number{
                        return price;
                }
                public function setPrice(newPrice:Number):void{
                        price = newPrice;
                }
                public function getSpec():GuitarSpec{
                        return spec;
                }
        }
}

package{
        public class Builder{
                public static const FENDER = "Fender";
                public static const MARTIN = "Martin";
                public static const GIBSON = "Gibson";
                public static const COLLINGS = "Collings";
                public static const OLSON = "Olson";
                public static const RYAN = "Ryan";
                public static const PRS = "PRS";
        }
}

package{
        public class Wood{
                public static const INDIAN_ROSEWOOD = "Indian Rosewood";
                public static const BRAZILIAN_ROSEWOOD = "Brazilian Rosewood";
                public static const MAHOGANY = "Mahogany";
                public static const MAPLE = "Maple";
                public static const COCOBOLO = "Cocobolo";
                public static const CEDAR = "Cedar";
                public static const ADIRONDACK = "Adirondack";
                public static const ALDER = "Alder";
                public static const SITKA = "Sitka";
        }
}

package{
        public class Type{
                public static const ACOUSTIC = "acoustic";
                public static const ELECTRIC = "Belectric";
        }
}

Collide 이벤트를 가지고 형광등을 표현해 봤다. 형광등의 진공 유리관에도 collide 이벤트를 적용하려고 했었는데 SpringConstraint에서 이벤트 반응을 하지 않는다. 구조상으로는 SpringConstraint -> AbstractConstraint -> AbstractItem -> EventDispatcher 와 같은 상속관계를 갖고 있음에도 이벤트에 반응하지 않는 것이 좀 이상하다.

일단은 진공관에 대한 이벤트 반응과 collidable을 false로 해 놓았다.