ActionScript 3
Conception d'applications réactive

Application sensible de base

package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;

    public class Main extends Sprite 
    {        
        //Document Class Main Constructor
        public function Main() 
        {
            //Sometimes stage isn't available yet, so if not, wait for it before proceeding
            if (!stage) {
                addEventListener(Event.ADDED_TO_STAGE, stageReady);
            }else {
                stageReady();
            }
        }
        
        protected function stageReady(e:Event = null):void {
            //align the stage to the top left corner of the window/container
            stage.align = StageAlign.TOP_LEFT;
            //don't scale the content when the window resizes
            stage.scaleMode = StageScaleMode.NO_SCALE;
            
            //listen for when the window is resized
            stage.addEventListener(Event.RESIZE, stageResized);
        }
        
        protected function stageResized(e:Event):void {
            //use stage.stageWdith & stage.stageHeight to repostion and resize items
        }   
    }
}

Effectuer de longs processus et ne pas obtenir une application sans réponse

Il existe des situations où vous devez calculer quelque chose de vraiment important dans votre application Flash, sans interrompre l'expérience de l'utilisateur. Pour cela, vous devez concevoir votre processus long comme un processus en plusieurs étapes avec un état enregistré entre les itérations. Par exemple, vous devez effectuer une mise à jour en arrière-plan de nombreux objets internes, mais si vous souhaitez les mettre à jour tous en même temps avec un simple for each (var o in objects) { o.update(); } , Flash brièvement (ou pas aussi brièvement) ne répond plus à l'utilisateur. Vous devez donc effectuer une ou plusieurs mises à jour par image.

private var processing:Boolean;      // are we in the middle of processing
private var lastIndex:int;           // where did we finish last time
var objects:Vector.<UpdatingObject>; // the total list of objects to update
function startProcess():Boolean {
    if (processing) return false; // already processing - please wait
    startProcessing=true;
    lastIndex=0;
    if (!hasEventListener(Event.ENTER_FRAME,iterate)) 
        addEventListener(Event.ENTER_FRAME,iterate); // enable iterating via listener
}
private function iterate(e:Event):void {
    if (!processing) return; // not processing - skip listener
    objects[lastIndex].update(); // perform a quantum of the big process
    lastIndex++; // advance in the big process
    if (lastIndex==objects.length) {
        processing=false; // finished, clear flag
    }
}

Le traitement avancé peut inclure l'utilisation de getTimer() pour vérifier le temps écoulé et autoriser une autre itération si le temps ne s'épuise pas, divisant update() en plusieurs fonctions si la mise à jour est trop longue liste d'objets à traiter, et beaucoup plus.