media/as3/ZeroClipboard.as

/* Compile using: mxmlc --target-player=10.0.0 ZeroClipboard.as */
package {
        import flash.display.Stage;
        import flash.display.Sprite;
        import flash.display.LoaderInfo;
        import flash.display.StageScaleMode;
        import flash.events.*;
        import flash.display.StageAlign;
        import flash.display.StageScaleMode;
        import flash.external.ExternalInterface;
        import flash.system.Security;
        import flash.utils.*;
        import flash.system.System;
        import flash.net.FileReference;
        import flash.net.FileFilter;
 
        public class ZeroClipboard extends Sprite {
                
                private var domId:String = '';
                private var button:Sprite;
                private var clipText:String = 'blank';
                private var fileName:String = '';
                private var action:String = 'copy';
                private var incBom:Boolean = true;
                private var charSet:String = 'utf8';
                
                
                public function ZeroClipboard() {
                        // constructor, setup event listeners and external interfaces
                        stage.scaleMode = StageScaleMode.EXACT_FIT;
                        flash.system.Security.allowDomain("*");
                        
                        // import flashvars
                        var flashvars:Object = LoaderInfo( this.root.loaderInfo ).parameters;
                        domId = flashvars.id;
                        
                        // invisible button covers entire stage
                        button = new Sprite();
                        button.buttonMode = true;
                        button.useHandCursor = true;
                        button.graphics.beginFill(0x00FF00);
                        button.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
                        button.alpha = 0.0;
                        addChild(button);
                        
                        button.addEventListener(MouseEvent.CLICK, clickHandler);
                        button.addEventListener(MouseEvent.MOUSE_OVER, function(event:Event):void {
                                ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseOver', null );
                        } );
                        button.addEventListener(MouseEvent.MOUSE_OUT, function(event:Event):void {
                                ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseOut', null );
                        } );
                        button.addEventListener(MouseEvent.MOUSE_DOWN, function(event:Event):void {
                                ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseDown', null );
                        } );
                        button.addEventListener(MouseEvent.MOUSE_UP, function(event:Event):void {
                                ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseUp', null );
                        } );
                        
                        // External functions - readd whenever the stage is made active for IE
                        addCallbacks();
                        stage.addEventListener(Event.ACTIVATE, addCallbacks);
                        
                        // signal to the browser that we are ready
                        ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'load', null );
                }
                
                public function addCallbacks (evt:Event = null):void {
                        ExternalInterface.addCallback("setHandCursor", setHandCursor);
                        ExternalInterface.addCallback("clearText", clearText);
                        ExternalInterface.addCallback("setText", setText);
                        ExternalInterface.addCallback("appendText", appendText);
                        ExternalInterface.addCallback("setFileName", setFileName);
                        ExternalInterface.addCallback("setAction", setAction);
                        ExternalInterface.addCallback("setCharSet", setCharSet);
                        ExternalInterface.addCallback("setBomInc", setBomInc);
                }
                
                
                public function setCharSet(newCharSet:String):void {
                        if ( newCharSet == 'UTF16LE' ) {
                                charSet = newCharSet;
                        } else {
                                charSet = 'UTF8';
                        }
                }
                
                public function setBomInc(newBomInc:Boolean):void {
                        incBom = newBomInc;
                }
                
                public function clearText():void {
                        clipText = '';
                }
                
                public function appendText(newText:String):void {
                        clipText += newText;
                }
                
                public function setText(newText:String):void {
                        clipText = newText;
                }
                
                public function setFileName(newFileName:String):void {
                        fileName = newFileName;
                }
                
                public function setAction(newAction:String):void {
                        action = newAction;
                }
                
                public function setHandCursor(enabled:Boolean):void {
                        // control whether the hand cursor is shown on rollover (true)
                        // or the default arrow cursor (false)
                        button.useHandCursor = enabled;
                }
                
                
                private function clickHandler(event:Event):void {
                        var fileRef:FileReference = new FileReference();
                        fileRef.addEventListener(Event.COMPLETE, saveComplete);
                        
                        if ( action == "save" ) {
                                /* Save as a file */
                                if ( charSet == 'UTF16LE' ) {
                                        fileRef.save( strToUTF16LE(clipText), fileName );
                                } else {
                                        fileRef.save( strToUTF8(clipText), fileName );
                                }
                        } else if ( action == "pdf" ) {
                                        fileRef.save( "This instance of ZeroClipboard is not configured for PDF export. "+
                                                "Please use the PDF export version.", fileName+".txt" );
                        } else {
                                /* Copy the text to the clipboard. Note charset and BOM have no effect here */
                                System.setClipboard( clipText );
                                ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'complete', clipText );
                        }
                }
                
                
                private function saveComplete(event:Event):void {
                        ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'complete', clipText );
                }
                
                
                private function getProp( prop:String, opts:Array ):String
                {
                        var i:int, iLen:int;
                        for ( i=0, iLen=opts.length ; i<iLen ; i++ )
                        {
                                if ( opts[i].indexOf( prop+":" ) != -1 )
                                {
                                        return opts[i].replace( prop+":", "" );
                                }
                        }
                        return "";
                }
                
                
                /*
                 * Function: strToUTF8
                 * Purpose:  Convert a string to the output utf-8
                 * Returns:  ByteArray
                 * Inputs:   String
                 */
                private function strToUTF8( str:String ):ByteArray {
                        var utf8:ByteArray = new ByteArray();
                        
                        /* BOM first */
                        if ( incBom ) {
                                utf8.writeByte( 0xEF );
                                utf8.writeByte( 0xBB );
                                utf8.writeByte( 0xBF );
                        }
                        utf8.writeUTFBytes( str );
                        
                        return utf8;
                }
                
                
                /*
                 * Function: strToUTF16LE
                 * Purpose:  Convert a string to the output utf-16
                 * Returns:  ByteArray
                 * Inputs:   String
                 * Notes:    The fact that this function is needed is a little annoying. Basically, strings in
                 *   AS3 are UTF-16 (with surrogate pairs and everything), but characters which take up less
                 *   than 8 bytes appear to be stored as only 8 bytes. This function effective adds the 
                 *   padding required, and the BOM
                 */
                private function strToUTF16LE( str:String ):ByteArray {
                        var utf16:ByteArray = new ByteArray();
                        var iChar:uint;
                        var i:uint=0, iLen:uint = str.length;
                        
                        /* BOM first */
                        if ( incBom ) {
                                utf16.writeByte( 0xFF );
                                utf16.writeByte( 0xFE );
                        }
                        
                        while ( i < iLen ) {
                                iChar = str.charCodeAt(i);
                                
                                if ( iChar < 0xFF ) {
                                        /* one byte char */
                                        utf16.writeByte( iChar );
                                        utf16.writeByte( 0 );
                                } else {
                                        /* two byte char */
                                        utf16.writeByte( iChar & 0x00FF );
                                        utf16.writeByte( iChar >> 8 );
                                }
                                
                                i++;
                        }
                        
                        return utf16;
                }
        }
}
1	/* Compile using: mxmlc --target-player=10.0.0 ZeroClipboard.as */
2	package {
3	import flash.display.Stage;
4	import flash.display.Sprite;
5	import flash.display.LoaderInfo;
6	import flash.display.StageScaleMode;
7	import flash.events.*;
8	import flash.display.StageAlign;
9	import flash.display.StageScaleMode;
10	import flash.external.ExternalInterface;
11	import flash.system.Security;
12	import flash.utils.*;
13	import flash.system.System;
14	import flash.net.FileReference;
15	import flash.net.FileFilter;
16
17	public class ZeroClipboard extends Sprite {
18
19	private var domId:String = '';
20	private var button:Sprite;
21	private var clipText:String = 'blank';
22	private var fileName:String = '';
23	private var action:String = 'copy';
24	private var incBom:Boolean = true;
25	private var charSet:String = 'utf8';
26
27
28	public function ZeroClipboard() {
29	// constructor, setup event listeners and external interfaces
30	stage.scaleMode = StageScaleMode.EXACT_FIT;
31	flash.system.Security.allowDomain("*");
32
33	// import flashvars
34	var flashvars:Object = LoaderInfo( this.root.loaderInfo ).parameters;
35	domId = flashvars.id;
36
37	// invisible button covers entire stage
38	button = new Sprite();
39	button.buttonMode = true;
40	button.useHandCursor = true;
41	button.graphics.beginFill(0x00FF00);
42	button.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);
43	button.alpha = 0.0;
44	addChild(button);
45
46	button.addEventListener(MouseEvent.CLICK, clickHandler);
47	button.addEventListener(MouseEvent.MOUSE_OVER, function(event:Event):void {
48	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseOver', null );
49	} );
50	button.addEventListener(MouseEvent.MOUSE_OUT, function(event:Event):void {
51	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseOut', null );
52	} );
53	button.addEventListener(MouseEvent.MOUSE_DOWN, function(event:Event):void {
54	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseDown', null );
55	} );
56	button.addEventListener(MouseEvent.MOUSE_UP, function(event:Event):void {
57	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'mouseUp', null );
58	} );
59
60	// External functions - readd whenever the stage is made active for IE
61	addCallbacks();
62	stage.addEventListener(Event.ACTIVATE, addCallbacks);
63
64	// signal to the browser that we are ready
65	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'load', null );
66	}
67
68	public function addCallbacks (evt:Event = null):void {
69	ExternalInterface.addCallback("setHandCursor", setHandCursor);
70	ExternalInterface.addCallback("clearText", clearText);
71	ExternalInterface.addCallback("setText", setText);
72	ExternalInterface.addCallback("appendText", appendText);
73	ExternalInterface.addCallback("setFileName", setFileName);
74	ExternalInterface.addCallback("setAction", setAction);
75	ExternalInterface.addCallback("setCharSet", setCharSet);
76	ExternalInterface.addCallback("setBomInc", setBomInc);
77	}
78
79
80	public function setCharSet(newCharSet:String):void {
81	if ( newCharSet == 'UTF16LE' ) {
82	charSet = newCharSet;
83	} else {
84	charSet = 'UTF8';
85	}
86	}
87
88	public function setBomInc(newBomInc:Boolean):void {
89	incBom = newBomInc;
90	}
91
92	public function clearText():void {
93	clipText = '';
94	}
95
96	public function appendText(newText:String):void {
97	clipText += newText;
98	}
99
100	public function setText(newText:String):void {
101	clipText = newText;
102	}
103
104	public function setFileName(newFileName:String):void {
105	fileName = newFileName;
106	}
107
108	public function setAction(newAction:String):void {
109	action = newAction;
110	}
111
112	public function setHandCursor(enabled:Boolean):void {
113	// control whether the hand cursor is shown on rollover (true)
114	// or the default arrow cursor (false)
115	button.useHandCursor = enabled;
116	}
117
118
119	private function clickHandler(event:Event):void {
120	var fileRef:FileReference = new FileReference();
121	fileRef.addEventListener(Event.COMPLETE, saveComplete);
122
123	if ( action == "save" ) {
124	/* Save as a file */
125	if ( charSet == 'UTF16LE' ) {
126	fileRef.save( strToUTF16LE(clipText), fileName );
127	} else {
128	fileRef.save( strToUTF8(clipText), fileName );
129	}
130	} else if ( action == "pdf" ) {
131	fileRef.save( "This instance of ZeroClipboard is not configured for PDF export. "+
132	"Please use the PDF export version.", fileName+".txt" );
133	} else {
134	/* Copy the text to the clipboard. Note charset and BOM have no effect here */
135	System.setClipboard( clipText );
136	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'complete', clipText );
137	}
138	}
139
140
141	private function saveComplete(event:Event):void {
142	ExternalInterface.call( 'ZeroClipboard_TableTools.dispatch', domId, 'complete', clipText );
143	}
144
145
146	private function getProp( prop:String, opts:Array ):String
147	{
148	var i:int, iLen:int;
149	for ( i=0, iLen=opts.length ; i<iLen ; i++ )
150	{
151	if ( opts[i].indexOf( prop+":" ) != -1 )
152	{
153	return opts[i].replace( prop+":", "" );
154	}
155	}
156	return "";
157	}
158
159
160	/*
161	* Function: strToUTF8
162	* Purpose: Convert a string to the output utf-8
163	* Returns: ByteArray
164	* Inputs: String
165	*/
166	private function strToUTF8( str:String ):ByteArray {
167	var utf8:ByteArray = new ByteArray();
168
169	/* BOM first */
170	if ( incBom ) {
171	utf8.writeByte( 0xEF );
172	utf8.writeByte( 0xBB );
173	utf8.writeByte( 0xBF );
174	}
175	utf8.writeUTFBytes( str );
176
177	return utf8;
178	}
179
180
181	/*
182	* Function: strToUTF16LE
183	* Purpose: Convert a string to the output utf-16
184	* Returns: ByteArray
185	* Inputs: String
186	* Notes: The fact that this function is needed is a little annoying. Basically, strings in
187	* AS3 are UTF-16 (with surrogate pairs and everything), but characters which take up less
188	* than 8 bytes appear to be stored as only 8 bytes. This function effective adds the
189	* padding required, and the BOM
190	*/
191	private function strToUTF16LE( str:String ):ByteArray {
192	var utf16:ByteArray = new ByteArray();
193	var iChar:uint;
194	var i:uint=0, iLen:uint = str.length;
195
196	/* BOM first */
197	if ( incBom ) {
198	utf16.writeByte( 0xFF );
199	utf16.writeByte( 0xFE );
200	}
201
202	while ( i < iLen ) {
203	iChar = str.charCodeAt(i);
204
205	if ( iChar < 0xFF ) {
206	/* one byte char */
207	utf16.writeByte( iChar );
208	utf16.writeByte( 0 );
209	} else {
210	/* two byte char */
211	utf16.writeByte( iChar & 0x00FF );
212	utf16.writeByte( iChar >> 8 );
213	}
214
215	i++;
216	}
217
218	return utf16;
219	}
220	}
221	}