Прогресс создания ByteArray

[AlexCooper]

FB4.7 SectorBuilder.rar

Main.as

package
{
	import flash.display.BitmapData;
	import flash.display.DisplayObject;
	import flash.display.JPEGEncoderOptions;
	import flash.display.Sprite;
 
	import flash.net.FileReference;
	import flash.utils.ByteArray;
 
	import utils.SeparateBuilder;
	import utils.SeparateEvent;
 
	import view.RandomView;
 
	[SWF(width="960",height="640",frameRate="60",backgroundColor="#FFFFFF")]
	public class Main extends Sprite
	{
		private var _viewport:Sprite;
		private var rview:DisplayObject
		private var _separe:SeparateBuilder;
 
 
		public function Main()
		{
			_viewport = new Sprite();
			addChild( _viewport );
 
			createRandomView();
			adaptViewPort();
			createSeparator();
			createScreenshot();
		}
 
		private function adaptViewPort():void
		{
			_viewport.width = stage.stageWidth;
			_viewport.height =  stage.stageHeight;
		}
 
		private function createRandomView():void
		{
			rview = new RandomView(5000,5000);
 
			_viewport.addChild( rview );
		}
 
		private function createSeparator():void {
 
			_separe = new SeparateBuilder(500);
 
			_separe.addEventListener( SeparateEvent.INIT, 	separateHandler );
			_separe.addEventListener( SeparateEvent.COMPLETE, 	separateHandler );
			_separe.addEventListener( SeparateEvent.PROCESSING, separateHandler );
 
		}
 
		private function createScreenshot():void {
			_separe.work( rview ); 			
		}
 
		protected function separateHandler(event:SeparateEvent):void
		{
			switch (event.type) {
 
				case SeparateEvent.INIT:
 
					trace('Start');
					break;
 
				case SeparateEvent.PROCESSING :
					trace('Processing : '+ event.data);
					break;
 
				case SeparateEvent.COMPLETE :
 
					trace('Complete');
 
					encode( _separe.bitmapData );
 
					break;
			}
		}
 
		private function encode(bitmapData:BitmapData):void
		{
			var jpeg:JPEGEncoderOptions = new JPEGEncoderOptions();
				jpeg.quality = 4;
 
			var byteArray:ByteArray = bitmapData.encode( bitmapData.rect, jpeg);
 
			save( byteArray );
		}
 
		private function save(byteArray:ByteArray):void
		{
			var fr:FileReference = new FileReference();
				fr.save(
					byteArray ,
					'screenshot_'+new Date().time+'.jpg'
				);
		}
	}
}

utils.SeparateBuilder.as

package utils
{
	import flash.display.BitmapData;
	import flash.display.DisplayObject;
	import flash.events.EventDispatcher;
	import flash.geom.Point;
	import flash.utils.ByteArray;
	import flash.utils.setTimeout;
 
	import net.alexscript.hack.Extruder;
 
	public class SeparateBuilder extends EventDispatcher
	{
		private var _blockSize:Number;
		private var _height:Number;
 
		private var _target:DisplayObject;
 
		private var _byteArray:ByteArray;
		private var _map:Point;
		private var _iteration:uint;
		private var _cache:BitmapData;
 
		public function SeparateBuilder(blockSize:Number=500)
		{
			super();
 
			_blockSize = blockSize;
		}
 
 
 
		public function work(view:DisplayObject):void
		{
			if (_target) {
				throw new Error('SeparateBuilder is work');
			}
 
			target = view;
		}
 
		public function get bitmapData():BitmapData
		{
			return _cache;
		}
 
		private function set target(value:DisplayObject):void
		{
			_target = value;
 
			_iteration = 0;
 
			_byteArray = new ByteArray();
 
			_cache = new BitmapData(_target.width, _target.height,true);
 
			calculation();
 
			say( SeparateEvent.INIT );
 
			processing();
		}
 
		private function calculation():void
		{
			_map = new Point( 
				Math.floor( target.width / _blockSize ),
				Math.floor( target.height / _blockSize )
			);
 
			if ( target.width > _map.x * _blockSize ) _map.x++;
 
			if ( target.height > _map.y * _blockSize ) _map.y++;
 
			trace( 'Map Sector : ',_map);
		}
 
		private function get target():DisplayObject
		{
			return _target;
		}
 
		private function processing():void
		{
			var sector:Point = new Point(
				_iteration % _map.x,
				Math.floor(_iteration/_map.x) 
			);
 
			snap( sector );
 
			var length:Number = _map.x * _map.y;
			var percent:Number=  100/(length/_iteration);
 
			say( SeparateEvent.PROCESSING , String( Math.floor(percent) )  );
 
			if ( ++_iteration < length ) 
				setTimeout( processing, 1 );
			else 
				complete();
		}
 
		private function snap(sector:Point):void
		{
			var anker:Point = new Point( 
					sector.x*_blockSize,
					sector.y*_blockSize
				);
 
			var zone:Point = new Point(_blockSize,_blockSize);
 
			if ( (anker.x+zone.x) > target.width )  zone.x = target.width - anker.x;
			if ( (anker.y+zone.y) > target.height )  zone.y = target.height - anker.y;
 
			var bd:BitmapData = Extruder.get( target, anker.x, anker.y , zone.x, zone.y );
 
			_cache.copyPixels( bd, bd.rect, anker);
		}
 
		private function complete():void
		{
			_target = null;
 
			say( SeparateEvent.COMPLETE );
		}
 
		private function say(type:String, data:String=''):void {
			this.dispatchEvent( new SeparateEvent( type, data ) );
		}
	}
}

utils.SeparateEvent.as

package utils
{
	import flash.events.DataEvent;
 
	public class SeparateEvent extends DataEvent
	{
		public static var INIT:String = 'init';
		public static var PROCESSING:String = 'processing';
		public static var COMPLETE:String = 'complete';
 
		public function SeparateEvent(type:String, data:String='')
		{
			super(type, true, false, data);
		}
	}
}

view.RandowView.as

package view
{
	import flash.display.Sprite;
	import flash.geom.Point;
 
	public class RandomView extends Sprite
	{
		private var _h:Number;
		private var _w:Number;
		public function RandomView(h:Number=5000,w:Number=5000)
		{
			super();
 
			_h = h;
			_w = w;
 
			graphics.beginFill(0xAAAAAA,1);
			graphics.drawRect(0,0,_w,_h);
			graphics.endFill();
 
			var rnd:Number = Math.floor(Math.random()*10)+10;
 
			while (--rnd) draw();
		}
 
		private function draw():void
		{
			var color:uint = Math.random()*0xFFFFFF;
 
			var size:Number = Math.min(_h,_w)*.1;
 
			var body:Point = new Point( Math.random()*(_w-size*2),Math.random()*(_h-size*2));
 
			body.x += size;
			body.y += size;
 
			with (graphics) {
 
				beginFill(color,1);
 
				switch( Math.floor(Math.random()*2) ) {
					case 0:
						drawRect(body.x,body.y, size, size);
					break;
 
					case 1:
						drawCircle(body.x,body.y,size);
					break;
				}
 
				endFill();
			}
		}
	}
}

net.alexscript.hack.Extruder.as

package net.alexscript.hack {
 
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.DisplayObject;
	import flash.display.PixelSnapping;
	import flash.geom.Matrix;
	import flash.geom.Rectangle;
 
	public class Extruder {
 
		public function Extruder() {
 
		}
 
		public static function get( ARG_object:DisplayObject, ARG_x:Number = 0, ARG_y:Number = 0, ARG_width:Number = 0, ARG_height:Number = 0,transpend:Boolean=true):BitmapData {
 
			if (!ARG_width) ARG_width = (ARG_object.mask) ? ARG_object.mask.width : ARG_object.width;
			if (!ARG_height) ARG_height = (ARG_object.mask) ? ARG_object.mask.height : ARG_object.height;
 
			var cropArea:Rectangle = new Rectangle(0, 0, ARG_width, ARG_height);
			var fillColor:uint = transpend
					? 0x00000000
					: 0x0;
			var bmpd:BitmapData = new BitmapData(ARG_width, ARG_height,true,fillColor);
 
			var croppedBitmap:Bitmap = new Bitmap(bmpd, PixelSnapping.ALWAYS, true);
 
			var cropMatrix:Matrix = new Matrix();
			cropMatrix.translate(-ARG_x, -ARG_y);
 
			bmpd.draw( ARG_object, cropMatrix, null, null, cropArea, true );
 
			return bmpd; 
		}
 
	}
 
}