2010年4月2日 星期五

BitmapData與ByteArray的操作


在Flash內,我們如果需要對外部載入圖檔,或是stage上的Sprite
做一些點陣圖形的操作(變形旋轉或其他)
要將處理過後的點陣資料,做頁面上顯示或是另做檔案儲存
在這過程中,都是在於DisplayObject,BitmapData與ByteArray這三者的轉換處理
以下是常用處理範例
BitmapData操作
1.如何取得DisplayObject的bitmapData


var bitmapData:BitmapData=new BitmapData(w,h);
bitmapData.draw(DisplayObject) 

2.如何取得外部圖檔或swf的bitmapData
(也就是將外部檔案寫到bitmapData內)
1.利用Loader載入外部檔案


var loader:Loade=new Loader()
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onLoadComplete);
loader.load('xxx.jpg');

2.載入完成後,將載入資料寫到bitmapData內


var bitmapData:BitmapData=new BitmapData(w,h);
bitmapData.draw(loader)


3.如何將bitmapData變成一個DisplayObject


var bitmapData:BitmapData=new BitmapData(w,h);
var bitmap:Bitmap=new Bitmap(bitmapData);
DisplayObjectContainer.addChild(bitmap); 

4.如何將bitmapData變成byteArray
如果要將圖檔以資料方式傳到Server上,要轉成byteArray形式才能上傳


var byteArray:ByteArray=JPEGEncoder.ecncode(bitmapdata)


ByteArray操作
1.如何將byteArray變成一個實體檔案


var targetFile:File =File.createTempFile();
var stream:FileStream = new FileStream();
stream.open(targetFile, FileMode.WRITE)
stream.writeBytes(byteArray, 0, 0);
stream.close(); 

2.如何將byteArray變成bitmapData


var bitmapData:BitmapData=new BitmapData(w,h);
bitmapData.setPixels(new Rectangle(),byteArray);

2010年3月26日 星期五

Design Pattern : 12 Decorator


把裝飾物件與主要內容物件當成相同的物件,也就是給予相同的API
可以在程式內用相同的方式操作,就可以用來組合出有彈性並複雜的結果
這就是Decorator

把裝飾與實際內容物當作相同的方式處裡
範例,要讓輸出字串可以彈性的增加外觀修飾的裝飾
把輸出物拆解成主要內容與裝飾內容,裝飾內容可能也多種的變化


參與者
1.Display (abstract)
提供一個主要內容與裝飾物都要依循的標準操作方法(API)


public abstract class Display {
    public abstract int getColumns();
    public abstract int getRows();
    public abstract String getRowText(int row);
    public final void show(){
        for(...){
            System.out.println(getRowText(i));
        }
    }
}


2.StringDisplay 主內容顯示類別
真正的主要內容顯示class,在實作抽象method時,具體的執行工作內容


public class StringDisplay extends Display {
    private String string;
    public StringDisplay(String string){
        this.string=string;
    }
    public int getColumns() { 
        return string.getBytes().length;
    }
    public int getRows() { 
        return 1;
    }
    public String getRowText(int row) { 
        if(row==0){
            return string;
        }else{
            return null;
        } 
    }
}


3.Border(abstract)
修飾抽象類別,還是繼承了主要Display類別,但是導入了一個display物件
來作為內部method委讓操作使用


public abstract class Border extends Display {
    protected Display display;  
    public Border(Display display){
        this.display=display;
    }
}


4.SlideBorder
在實作抽象method內,利用委讓操作display物件取得主要內容
再添加上裝飾的內容後,將最後結果輸出


public class SlideBorder extends Border {
    private char borderChar;
    public SlideBorder(Display display,char borderChar){
        super(display);
        this.borderChar=borderChar;
    }
    public int getColumns() {
        return 1+display.getColumns()+1;
    }
    public int getRows() {
        return display.getRows();
    }
    public String getRowText(int row) {
        return borderChar+display.getRowText(row)+borderChar;
    }
}


5.Main外部程式
可任意包裝產生所要的結果


Display b1=new StringDisplay("hello ozzy");
b1.show();
Display b2=new SlideBorder(new StringDisplay("hello sun"),'*');
b2.show();



2010年3月25日 星期四

Design Pattern : 11 Composit





當我們遇到有容器(container)與內容(content)需要作遞迴處理
例如要對一個目錄下所有的檔案與目錄都作處理
因為目錄(container)與檔案(content)都可以被裝到目錄下
這時候,可以把兩者都當作是"目錄進入點"(entry)來看
這時候容器與內容就都是屬於同一類的東西

這時候針對entry上定義一個"進入點"所需要的功能
而容器與內容都只是entry的子類別,在遞迴程序的操作上
只要使用屬於entry的method即可,而不用管是容器或是內容

參與者
1.Entry(abstract)
實際執行顯示的是printList(String prefix)
這部份在子類別內實作
而留給外部呼叫的只有printList()



public abstract class Entry {
    public abstract String getName();
    public abstract int getSize();
    public void printList(){
        priinList("");
    }
    protected abstract void printList(String prefix);
}

2.File
把Entry內設定的3個abstract method 實作出來


public class File extends Entry {
    private String name;
    private int size;
    public File(String name,int size){
        this.name=name;
        this.size=size;
    } 
    public String getName() { 
        return this.name;
    }
    public int getSize() { 
        return this.size;
    }
    protected void printList(String prefix) { 
        System.out.println(prefix+"/"+this);
    }
}

3.Directory
在屬於container的class內使用iterator來迴圈執行entry所提供的method


public class Directory extends Entry {
    private String name;
    private Vector directory=new Vector();
    public Directory(String name){
        this.name=name;
    }
    public String getName() {  
        return this.name;
    }
    public int getSize() { 
        int size=0;
        Iterator it=directory.iterator();
        while(it.hasNext()){
            Entry entry=(Entry)it.next();
            size+=entry.getSize();
        }
        return size;
    }
    protected void printList(String prefix) {
        //把自己列印出來,並叫其子node執行entry的列印指令
        System.out.println(prefix+"/"+this);
        Iterator it=directory.iterator();
        while(it.hasNext()){
            Entry entry=(Entry)it.next();
            entry.printList(prefix+"/"+name);
        }
    }
    public Entry add(Entry entry){
        directory.add(entry);
        return this;
    }
}

4.Main 外部程式


Directory root=new Directory("root");
Directory folder1=new Directory("folder1");
File file1=new File("file01",100);
File file2=new File("file02",200);
root.add(folder1);
folder1.add(file1);
folder1.add(file2);
root.printList(); 



2010年3月15日 星期一

Design Pattern : 09 Bridge

通常產生子類別,會有兩種型態
1.extends繼承:
以繼承方式來產生子類別的目的,是在子類別新增功能
屬於功能性的擴增
2.implement實作:
父類別只是一個抽象類別(abstract)或介面(interface)
實作後的子類別,與父類別的功能是相同的,但每個功能可以有不同的展現
屬於實作部分的擴增

如果在做程式設計,希望可以把實作與功能部分完全分離,
如範例中,Display屬於功能性父類別,DisplayImp屬於實作父類別
如果想要新增功能,就擴充在Display的子類別內
如果想要改變輸出型態,如輸出文字變輸出html,
則新增DisplayImp的子類別

Bridge Pattern就是在功能類別(Display)內放一個變數(impl)存放實作類別(DisplayImp)的實體
讓功能類別(Display)內的method都是在操作實作類別(DisplayImp)的功能
把分離的實作擴充與功能擴充部分串起來,就是Bridge Pattern
參與者
1.Display(功能父類別)
在Display功能父類別內,利用一個變數impl儲存實作類別的instance
所有在功能類別內的操作,內部真正都執行的都是impl在執行

public class Display {
    private DisplayImp impl;
    public Display(DisplayImp impl){
        this.impl=impl;
    }
    public void open(){
        impl.rawOpen();
    }
} 

2.abstract DisplayImp(實作的父類別)
實作父類別,定義了所要實作類別所需要的method名稱,再交由子類別去實作出來

public abstract class DisplayImp {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
}

3.CountDisplay(擴充了功能父類別Display)
要新增加功能,就加在這功能擴充的子類別上

public class CountDisplay extends Display {
    public CountDisplay(DisplayImp impl){
        super(impl);
    }
    public void multiOutPut(int num){
    this.open();
    this.print();
    this.print();
    this.close();
    }
}

4.StringDisplayImp(真正實作可以執行的實作類別)

public class StringDisplayImp extends DisplayImp {
    private String string;
    public StringDisplayImp(String string){
        this.string=string;
    }
    public void rawOpen(){
        System.out.println("---Is Open-------");
    };
    .....
}

5.Main外部程式

Display d1=new Display(new StringDisplayImp("OZ D1"));
CountDisplay d2=new CountDisplay(new StringDisplayImp("OZ D2"));
d1.output();
d2.output();
d2.multiOutPut(3);//執行功能擴充後,新增的method



ps:
當以繼承方式產生子類別,子類別並不會繼承父類別的建構子
如果父類別建構子有接受參數執行項目
那在繼承後,子類別在建構子內,並須執行super(xx)

2010年3月12日 星期五

Design Pattern : 07 Builder


當我們想要建構出一個比較複雜的結果
或是想對相同內容提供不同的輸出樣式,就可以使用Builder Pattern

其流程是
1.先產生一個Builder類別,在Builder內
提供各種基本method
2.再產生一個組合程式用的Director類別
在Director內組合各式的builder 功能,來產生一個比較複雜的結果
外部程式只要操作Director就可以得到想要的結果
3.如果要讓同樣的內容可以產生不同格式的輸出
可以繼承Builder產生各式的Builder類別,來產生不同形式的輸出樣式

參與者
1.Builder
抽象類別,規範了要提供給Director操作的的各項method


class abstract Builder{
    public abstract makeTitle(String _title);
    public abstract makeBody(String _body);
    public abstract makeLine();
    public abstract Object getResult();
}

2.TextBuilder
繼承自Builder,並把相關method都實作出來


class abstract TextBuilder extends Builder{
    private StringBuffer buffer=new StringBuffer()
    public makeTitle(String _title){
        buffer.append(_title)
    };
    public makeBody(String _body){..};
    public makeLine(){..};
    public Object getResult(){
        return buffer.toString();
    };
}

3.Director
實體類別,在內部操作並組合各種Builder的method產生所要的結果
在Director只操作Builder類別的method,不可操作builder的子類別專屬method


class Director{
    private Builder builder;
    public Director(Builder builder){
        this.builder=builder;
    }
    public void setData(String _title,String _body){
        builder.makeLine();
        builder.makeTitle(_title);
        builder.makeBody(_body);
        builder.makeLine();
    }
    public void show(){
        System.out.println(builder.getResult().toString());
    }
}

4.Main外部程式


Director director=new Director(new TextBuilder());
director.setData("title","body");
director.show();