Forked from:: aote's forked from: ノスタルジック？な感じ？

forked from: forked from: ノスタルジック？な感じ？

ノスタルジックな雰囲気になった。かな？
* またも ActionScript3 Thread Library 使って作りました :-)
*
* コメントが壊れたカタコトの英語でごめんなさい :-(

forked:4
favorite:7
lines:573
license : All rights reserved
modified : 2010-01-07 13:32:39

Embed: Tweet

// forked from hacker_jqf2oner's forked from: ノスタルジック？な感じ？
// forked from soundkitchen's ノスタルジック？な感じ？
/**
 *  ノスタルジックな雰囲気になった。かな？
 *  またも ActionScript3 Thread Library 使って作りました :-)
 *
 *  コメントが壊れたカタコトの英語でごめんなさい :-(
 */
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageQuality;
    import flash.display.StageScaleMode;
    import flash.events.Event;

import com.flashdynamix.utils.SWFProfiler;
    import org.libspark.thread.EnterFrameThreadExecutor;
    import org.libspark.thread.Thread;

[SWF(width=465, height=465, frameRate=30, backgroundColor=0xffffff)]

/**
     *  document class.
     */
    public class Deploy extends Sprite
    {
        /**
         *  constructor.
         */
        public function Deploy()
        {
            addEventListener(Event.ADDED_TO_STAGE, initialize);
        }

/**
         *  initialize the object.
         */
        private function initialize(evt:Event):void
        {
            //  check is thread system already initialized?
            if (!Thread.isReady)
            {
                //  fixed stage settings.
                stage.align = StageAlign.TOP_LEFT;
                stage.quality = StageQuality.MEDIUM;
                stage.scaleMode = StageScaleMode.NO_SCALE;

SWFProfiler.init(this);

//  initialize the thread system.
                Thread.initialize(new EnterFrameThreadExecutor());
            }

//  wake up main task thread.
            new MainThread(this).start();
        }
    }
}

import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Sprite;
import flash.display.Stage;
import flash.errors.IOError;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.filters.BitmapFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BlurFilter;
import flash.net.URLRequest;
import flash.net.URLVariables;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.system.LoaderContext;

import com.adobe.serialization.json.JSON;
import org.libspark.thread.Monitor;
import org.libspark.thread.Thread;
import org.libspark.thread.threads.display.LoaderThread;
import org.libspark.thread.threads.net.URLLoaderThread;
import org.libspark.thread.utils.ParallelExecutor;

/**
 *  main task thread.
 */
internal class MainThread extends Thread
{
    private var layer:DisplayObjectContainer;
    private var loader:LoadDataThread;

/**
     *  constructor.
     */
    public function MainThread(layer:DisplayObjectContainer)
    {
        this.layer = layer;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        var waitor:Thread;

//  wake up handle background task.
        new HandleBackgroundThread(layer).start();
        //  wake up wait animation task.
        waitor = new WaitAnimationThread(layer);
        waitor.start();
        waitor.join();
        //  stack next task(s).
        next(loadData);
    }

/**
     *  load data from flickr.
     */
    private function loadData():void
    {
        loader = new LoadDataThread();
        loader.start();
        loader.join();
        //  stack next task(s).
        next(loadComplete);
    }

/**
     *  laod and display images.
     */
    private function loadComplete():void
    {
        var data:Array,
            queue:FlickrImageQueue,
            container:Sprite;

data = loader.data;
        //  create photo image queue.
        queue = new FlickrImageQueue();
        //  create images container.
        container = new Sprite();
        container.scaleX = 2;
        container.scaleY = 2;

layer.addChild(container);
        //  wake up fix position task thread.
        new FollowMousePositionThread(container).start();
        //  wake up display image task thread.
        new DisplayImageThread(container, queue).start();
        //  wake up load image task thread(s).
        new LoadImageThread(data, queue).start();
        new LoadImageThread(data, queue).start();
        new LoadImageThread(data, queue).start();
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        layer = null;
    }
}

/**
 *  handle background noise task.
 */
internal class HandleBackgroundThread extends Thread
{
    public static const TICK_THRESHOLD:uint = 3;

private var layer:DisplayObjectContainer;
    private var background:Bitmap;
    private var tick:uint;

/**
     *  constructor.
     */
    public function HandleBackgroundThread(layer:DisplayObjectContainer)
    {
        this.layer = layer;
        this.tick = 0;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        var s:Stage;

s = layer.stage;

//  create background noise canvas.
        var bmd:BitmapData = new BitmapData(s.stageWidth / 2, s.stageHeight / 2, true, 0);
        //  create bitmap for background.
        background = new Bitmap(bmd);
        background.scaleX = 2;
        background.scaleY = 2;
        background.alpha = .15;
        //  add background to layer.
        layer.addChild(background);
        //  update background immediately.
        update();
    }

/**
     *  update background.
     */
    private function update():void
    {
        var s:Stage;

s = background.stage;

//  if removed background from stage or interrupted, halt process.
        if (!s || checkInterrupted()) return;
        //  check triggerable?
        if (tick % TICK_THRESHOLD == 0)
        {
            //  regenerate noise.
            background.bitmapData.noise(Math.random() * 100);
        }
        //  increment tick in range.
        tick = ++tick % TICK_THRESHOLD;

//  stack next task(s).
        next(update);
        event(s, Event.RESIZE, resized);
    }

private function resized(evt:Event):void
    {
        var s:Stage,
            pb:BitmapData,
            nb:BitmapData;

//  cast target as stage object.
        s = evt.target as Stage;
        //  if missing target or interrupted, halt process.
        if (!s || checkInterrupted()) return;

//  recreate noise bitmap data.
        pb = background.bitmapData;
        nb = new BitmapData(s.stageWidth / 2, s.stageHeight / 2, true, 0);
        background.bitmapData = nb;
        //  release old data resource.
        pb.dispose();
        //  reset tick counter.
        tick = 0;
        //  update background noise immediately.
        update();
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        if (layer.contains(background))
        {
            layer.removeChild(background);
        }
        layer = null;
        background.bitmapData.dispose();
        background = null;
    }
}

/**
 *  wait animation to til user's first action.
 */
internal class WaitAnimationThread extends Thread
{
    private var layer:DisplayObjectContainer;
    private var message:DisplayObject;
    private var handlers:ParallelExecutor;

/**
     *  constructor.
     */
    public function WaitAnimationThread(layer:DisplayObjectContainer)
    {
        this.layer = layer;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        var txt:TextField,
            fmt:TextFormat,
            bmd:BitmapData;

//  create format for message text.
        fmt = new TextFormat();
        fmt.color = 0x000000;
        fmt.size = 48;
        fmt.font = 'sans-serif';

//  create message text.
        txt = new TextField();
        txt.autoSize = TextFieldAutoSize.LEFT;
        txt.defaultTextFormat = fmt;
        txt.text = 'click to start.';

//  create message data.
        bmd = new BitmapData(txt.textWidth, txt.textHeight, true, 0);
        //  draw text to bitmap data.
        bmd.draw(txt);
        //  create message.
        message = new Sprite();
        //  add bitmap to message layer.
        Sprite(message).addChild(new Bitmap(bmd));
        //  hide message. will disappear later.
        message.visible = false;
        //  add message to layer.
        layer.addChild(message);

//  create sub processes handler.
        handlers = new ParallelExecutor();
        //  stack fixed position task.
        handlers.addThread(new FixCenterPositionThread(message));
        //  wake up handling focus/blur task.
        handlers.addThread(new HandleFocusThread(message));
        //  start each sub processes.
        handlers.start();

//  stack next task(s).
        event(message, MouseEvent.CLICK, hideMessage);
    }

/**
     *  hide message.
     *  will execute when message is clicked.
     */
    private function hideMessage(evt:MouseEvent):void
    {
        //  interrupt sub processes.
        handlers.interrupt();
        handlers = null;

//  wake up hide message task.
        new HideMessageThread(message).start();
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        layer = null;
        message = null;
    }
}

/**
 *  hide message task.
 */
internal class HideMessageThread extends Thread
{
    private var message:DisplayObject;

/**
     *  constructor.
     */
    public function HideMessageThread(message:DisplayObject)
    {
        this.message = message;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        message.alpha *= .95;

if (message.alpha < .02)
        {
            message.alpha = 0;
        }
        else
        {
            next(run);
        }
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        var p:DisplayObjectContainer;

p = message.parent;

if (p)
        {
            p.removeChild(message);
        }
        message = null;
    }
}

/**
 *  fix center position task thread.
 */
internal class FixCenterPositionThread extends Thread
{
    private var target:DisplayObject;

/**
     *  constructor.
     */
    public function FixCenterPositionThread(target:DisplayObject)
    {
        this.target = target;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        var s:Stage;

s = target.stage;
        //  if missing stage, halt process.
        if (!s) return;
        //  fix target position.
        target.x = (s.stageWidth - target.width) / 2;
        target.y = (s.stageHeight - target.height) / 2;
        //  if hide object yet, disappear.
        if (!target.visible)
        {
            target.visible = true;
        }
        //  stack next task(s).
        event(s, Event.RESIZE, resized);
        interrupted(shutdown);
    }

/**
     *  will execute when stage is resized.
     */
    private function resized(evt:Event):void
    {
        var s:Stage;

s = target.stage;
        //  if missing stage, halt process.
        if (!s) return;
        //  fix target position.
        target.x = (s.stageWidth - target.width) / 2;
        target.y = (s.stageHeight - target.height) / 2;
        //  stack next task(s).
        event(s, Event.RESIZE, resized);
        interrupted(shutdown);
    }

/**
     *  default interrupted handler.
     */
    private function shutdown(...args):void
    {
        //  do nothing.
    }

override protected function finalize():void
    {
        target = null;
    }
}

/**
 *  handling focus/blur task thread.
 */
internal class HandleFocusThread extends Thread
{
    private var target:DisplayObject;

/**
     *  constructor.
     */
    public function HandleFocusThread(target:DisplayObject)
    {
        this.target = target;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        //  reset filters.
        target.filters = [
            new BlurFilter(8, 8, BitmapFilterQuality.LOW),
        ];
        //  bind each events.
        events();
    }

/**
     *  bind each events.
     */
    private function events():void
    {
        //  stack next task(s).
        event(target, MouseEvent.ROLL_OVER, focus);
        event(target, MouseEvent.ROLL_OUT, blur);
        interrupted(shutdown);
    }

/**
     *  will execute when target is focused.
     */
    private function focus(evt:MouseEvent):void
    {
        //  reset filters.
        target.filters = [
            new BlurFilter(2, 2, BitmapFilterQuality.LOW),
        ];
        //  bind each events.
        events();
    }

/**
     *  will execute when target is unfocused.
     */
    private function blur(evt:MouseEvent):void
    {
        //  reset filters.
        target.filters = [
            new BlurFilter(8, 8, BitmapFilterQuality.LOW),
        ];
        //  bind each events.
        events();
    }

/**
     *  default shutdown handler.
     */
    private function shutdown(...args):void
    {
        //  do nothing.
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        target = null;
    }
}

/**
 *  load data from flickr task thread.
 */
internal class LoadDataThread extends Thread
{
    public static const YQL_URL:String = 'http://query.yahooapis.com/v1/public/yql';

private var loader:URLLoaderThread;
    private var _data:Array;
    public function get data():Array
    {
        return _data.concat();
    }

/**
     *  constructor.
     */
    public function LoadDataThread()
    {
        _data = [];
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        var req:URLRequest,
            data:URLVariables;

data = new URLVariables();
        data['q'] = 'select * from flickr.photos.recent(64)';
        data['format'] = 'json';

req = new URLRequest();
        req.url = YQL_URL;
        req.data = data;

loader = new URLLoaderThread(req);
        loader.start();
        loader.join();

next(loadComplete);
        error(IOError, loadFailure);
        error(SecurityError, loadFailure);
    }

/**
     *  will execute when load data complete.
     */
    private function loadComplete():void
    {
        var json:Object,
            row:Object;

json = JSON.decode(loader.loader.data);

if (!json.query || !json.query.results) return;

for each (row in json.query.results.photo)
        {
            _data.push(new FlickrPhoto(row));
        }
    }

/**
     *  will execute when load data failure.
     */
    private function loadFailure(e:Error, t:Thread):void
    {
        trace("CAUGHT EXCEPTION: ", e);
        //trace(e.getStackTrace());
    }
}

/**
 *
 */
internal class DisplayImageThread extends Thread
{
    private var layer:DisplayObjectContainer;
    private var queue:FlickrImageQueue;

/**
     *  constructor.
     */
    public function DisplayImageThread(layer:DisplayObjectContainer, queue:FlickrImageQueue)
    {
        this.layer = layer;
        this.queue = queue;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        if (queue.checkPoll())
        {
            var i:uint,
                wrapper:Sprite;

i = layer.numChildren;

wrapper = new Sprite();
            wrapper.addChild(queue.poll());
            wrapper.x = Math.floor(i % 8) * 80;
            wrapper.y = Math.floor(i / 8) * 80;
            wrapper.blendMode = BlendMode.HARDLIGHT;

new HandleFocusThread(wrapper).start();

layer.addChild(wrapper);
        }
        //  stack next task(s).
        next(run);
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        layer = null;
        queue = null;
    }
}

/**
 *  load each image task thread.
 */
internal class LoadImageThread extends Thread
{
    private var data:Array;
    private var queue:FlickrImageQueue;
    private var loader:LoaderThread;

/**
     *  constructor.
     */
    public function LoadImageThread(data:Array, queue:FlickrImageQueue)
    {
        this.data = data;
        this.queue = queue;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        if (!data.length || checkInterrupted()) return;

var row:FlickrPhoto,
            req:URLRequest,
            ctx:LoaderContext;

row = data.shift() as FlickrPhoto;
        req = new URLRequest(row.thumbnailURL);
        ctx = new LoaderContext(true);

loader = new LoaderThread(req, ctx);
        loader.start();
        loader.join();

next(loadComplete);
        error(IOError, loadFailure);
        error(SecurityError, loadFailure);
        interrupted(shutdown);
    }

/**
     *  will execute when load data complete.
     */
    private function loadComplete():void
    {
        //  push new task into queue.
        queue.offer(Bitmap(loader.loader.content));
        //  stack next task(s).
        next(run);
    }

/**
     *  will execute when load data failure.
     */
    private function loadFailure(e:Error, t:Thread):void
    {
        loader = null;
        //  stack next task(s).
        next(run);
    }

/**
     *  default interrupted handler.
     */
    private function shutdown(...args):void
    {
        //  do nothing.
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        loader = null;
        data = null;
        queue = null;
    }
}

/**
 *  follow the mouse point
 */
internal class FollowMousePositionThread extends Thread
{
    public static const MARGIN:Number = 150;

private var target:DisplayObject;

/**
     *  constructor.
     */
    public function FollowMousePositionThread(target:DisplayObject)
    {
        this.target = target;
    }

/**
     *  first executable.
     */
    override protected function run():void
    {
        var s:Stage;

s = target.stage;

if (!s) return;

target.x = MARGIN;
        target.y = MARGIN;

event(s, MouseEvent.MOUSE_MOVE, moved);
        interrupted(shutdown);
    }

/**
     *  will execute when mouse moved.
     */
    private function moved(evt:MouseEvent):void
    {
        update();
    }

/**
     *  update target position.
     */
    private function update():void
    {
        var s:Stage,
            ax:Number, ay:Number,
            dx:Number, dy:Number;

s = target.stage;
        //  if missing stage, halt process.
        if (!s) return;

ax = s.mouseX / s.stageWidth;
        ay = s.mouseY / s.stageHeight;

dx = MARGIN - (target.width - s.stageWidth + MARGIN * 2) * ax;
        dy = MARGIN - (target.height - s.stageHeight + MARGIN * 2) * ay;

target.x += (dx - target.x) / 20;
        target.y += (dy - target.y) / 20;

if (Math.abs(dx - target.x) < 1 && Math.abs(dy - target.y) < 1)
        {
            target.x = dx;
            target.y = dy;

event(s, MouseEvent.MOUSE_MOVE, moved);
            interrupted(shutdown);
        }
        else
        {
            next(update);
        }
    }

/**
     *  default interrupted handler.
     */
    private function shutdown(...args):void
    {
        // do nothing.
    }

/**
     *  finalize the object.
     */
    override protected function finalize():void
    {
        target = null;
    }
}

/**
 *  stack flickr image queue.
 */
internal class FlickrImageQueue
{
    private var queue:Array;
    private var monitor:Monitor;

/**
     *  checking is task empty in queue.
     */
    public function get isEmpty():Boolean
    {
        return queue.length <= 0;
    }

/**
     *  constructor.
     */
    public function FlickrImageQueue()
    {
        queue = [];
        monitor = new Monitor();
    }

/**
     *  checking already stack new task into queue.
     */
    public function checkPoll():Boolean
    {
        var f:Boolean = true;

if (isEmpty)
        {
            f = false;
            monitor.wait();
        }
        return f;
    }

/**
     *  shift stack task.
     */
    public function poll():Bitmap
    {
        return queue.shift();
    }

/**
     *
     */
    public function offer(v:Bitmap):void
    {
        //  push new data into queue.
        queue.push(v);
        //  notify all wait task.
        monitor.notifyAll();
    }
}

internal class FlickrPhoto
{
    private var _id:String;
    public function get id():String
    {
        return _id;
    }

private var _secret:String;
    public function get secret():String
    {
        return _secret;
    }

private var _server:String;
    public function get server():String
    {
        return _server;
    }

private var _farm:String;
    public function get farm():String
    {
        return _farm;
    }

public function get thumbnailURL():String
    {
    	var str:String = 'http://farm'+ farm+'.static.flickr.com/'+ server+ '/'+ id+ '_'	+ secret +  '_s.jpg';
       trace(str);
        return ['http://farm', farm, '.static.flickr.com/', server, '/', id, '_', secret, '_s.jpg'].join('');
    }

public function FlickrPhoto(data:Object)
    {
        this._id = data['id'] || '';
        this._secret = data['secret'] || '';
        this._server = data['server'] || '';
        this._farm = data['farm'] || '';
    }

public function toString():String
    {
        return thumbnailURL;
    }
}

Code Fullscreen

Preview Fullscreen