package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.text.TextField;
        import flash.net.*;
        import flash.events.*;
        import flash.display.MovieClip;
	import flash.utils.ByteArray;
 
	// We'll be sending a ByteArray encoded as Base64, and then decoding it on the .NET side.
	// http://dynamicflash.com/goodies/base64/
	import com.dynamicflash.util.Base64;
 
	// be.wellconsidered classes give us an easy means to communicate with webservices.
	// The extension needs to be installed and the component then dropped into your .FLA.
	// You'll see a component called "Service" in the library of the example .FLA.
	// http://www.wellconsidered.be/blog/as3-webservice-component/
	import be.wellconsidered.services.WebService;
	import be.wellconsidered.services.Operation;
	import be.wellconsidered.services.events.OperationEvent;
	import be.wellconsidered.services.events.WebServiceEvent;
 
	// com.pfp includes classes for the Asynchronous JPEG encoder.  There is also a JPEG encoder
	// in Adobe's CoreLib (http://code.google.com/p/as3corelib/), but because this one is asynchronous it allows to 
	// monitor the rendering of the jpeg and therefore create a progress bar.  It is also essential when rendering larger
	// bitmaps, otherwise Flash could time out during the processing.
	import com.pfp.events.*;
	import com.pfp.utils.*;
 
    public class FlashBitmapSave extends MovieClip
    {
	// we create our WebService object.  Remember to include "?wsdl" in the URL.
	private var wsMainService:WebService = new WebService("/Service.asmx?wsdl");
 
                public function FlashBitmapSave()
                {
                        mcDrawingBoard.addEventListener(MouseEvent.MOUSE_DOWN, mcDrawingBoard_MouseDown);
			btnSaveToServer.addEventListener(MouseEvent.CLICK, btnSaveToServer_Click);
 
			// the listener on our webservice will let us know if there's a problem with the webservice,
			// if the url is wrong, if the service is down, etc.
			wsMainService.addEventListener(WebServiceEvent.INITFAILED, wsMainService_InitFailed);
                }
 
		// **** functions for the drawing pad **** //
 
		private function mcDrawingBoard_MouseDown(e:MouseEvent):void
		{
			mcDrawingBoard.addEventListener(MouseEvent.MOUSE_MOVE, mcDrawingBoard_MouseMove);
			stage.addEventListener(MouseEvent.MOUSE_UP, stage_MouseUp);
			mcDrawingBoard.graphics.moveTo(mcDrawingBoard.mouseX, mcDrawingBoard.mouseY);
		}
 
		private function mcDrawingBoard_MouseMove(e:MouseEvent):void
		{
			mcDrawingBoard.graphics.lineStyle(1, 0x000000);
			mcDrawingBoard.graphics.lineTo(mcDrawingBoard.mouseX, mcDrawingBoard.mouseY);
		}
 
		private function stage_MouseUp(e:MouseEvent):void
		{
			mcDrawingBoard.removeEventListener(MouseEvent.MOUSE_MOVE, mcDrawingBoard_MouseMove);
		}
 
		// ************************************** //
 
		private function btnSaveToServer_Click(e:MouseEvent):void
		{
			var bmdSnapshot:BitmapData = new BitmapData(mcDrawingBoard.width, mcDrawingBoard.height);
			// take a snapshot of what was drawn in "mcDrawingBoard"
			bmdSnapshot.draw(mcDrawingBoard);
 
			saveImage(bmdSnapshot);
		}
 
		private function wsMainService_InitFailed(e:WebServiceEvent):void
		{
			log("Webservice failed to initialize.");
		}
 
		private function saveImage(bmdSend:BitmapData):void
		{
			// create a new JPEGAsyncEncoder.  80 is the JPEG quality.
			var jpgEncoder:JPEGAsyncEncoder = new JPEGAsyncEncoder(80);
 
			// encodes 400 pixels before sending out a ProgressEvent.  That means every 400 pixels the CPU has a chance to "breath"
			// and process some other code.  
			jpgEncoder.PixelsPerIteration = 400;
 
			jpgEncoder.addEventListener(JPEGAsyncCompleteEvent.JPEGASYNC_COMPLETE, jpgEncoder_Complete);
			jpgEncoder.addEventListener(ProgressEvent.PROGRESS, jpgEncoder_Progress);
 
			jpgEncoder.encode(bmdSend);			
		}
 
		private function jpgEncoder_Complete(e:JPEGAsyncCompleteEvent):void
		{
			var jpgByteArray:ByteArray = new ByteArray();
			// put the raw image data we got back from the encoder into our ByteArray
			jpgByteArray = e.ImageData;
 
			sendToServer(jpgByteArray);
		}
 
		private function jpgEncoder_Progress(e:ProgressEvent):void
		{
			log("encoding... " + Math.round(e.bytesLoaded / e.bytesTotal * 100).toString());
		}
 
		private function sendToServer(byteArray:ByteArray):void
		{
			var opJPEGSaver:Operation = new Operation(wsMainService);
 
			// unfortunately, I don't think the WebService class we're using has a working ProgressEvent.
			// if I'm wrong, please let me know!
			opJPEGSaver.addEventListener(OperationEvent.COMPLETE, opJPEGSaver_Complete);
			opJPEGSaver.addEventListener(OperationEvent.FAILED, opJPEGSaver_Failed);	
 
			var strEncodedString:String = new String();
			// the Base64 class is static, so we can just call it using Base64.<whatever>
			strEncodedString = Base64.encodeByteArray(byteArray);
 
			// send the encoded bytes to our webservice function we called "SaveJPEG".
			opJPEGSaver.SaveJPEG(strEncodedString);
		}
 
		private function opJPEGSaver_Complete(e:OperationEvent):void
		{
			log("ByteArray successfully sent to server.");
		}
 
		private function opJPEGSaver_Failed(e:OperationEvent):void
		{
			log("Error sending ByteArray to server.");
		}
 
		private function log(strLog:String):void
		{
			// my own way of tracing to the textfield txtTrace -- as you can see.
			// not an important part of anything going on here.
			txtTrace.appendText(strLog + "\n");
			traceScrollBar.scrollTarget = txtTrace;
			txtTrace.scrollV = txtTrace.numLines;
		}
    }
}

Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.IO
 
' To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
' <System.Web.Script.Services.ScriptService()> _
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
     Inherits System.Web.Services.WebService
 
 
    <WebMethod()> _
    Public Function SaveJPEG(ByVal strJPEG As String) As String
 
        'saves an uploaded photo and returns a unique name reference
 
        Dim BinaryContent As Byte() = Convert.FromBase64String(strJPEG)
 
        Try
            'generate a unique name (GUID) for the filename
            Dim strFileName As String = System.Guid.NewGuid.ToString("n")
            'MAKE SURE to change the save path!
            Dim fStream As New FileStream("C:\" + strFileName + ".jpg", FileMode.CreateNew)
            Dim bw As New BinaryWriter(fStream)
 
            bw.Write(BinaryContent)
            bw.Close()
            fStream.Close()
 
            'return the filename for use in Flash
            Return strFileName
 
        Catch ex As Exception
 
            Return ex.Message
 
        End Try
 
    End Function
 
End Class