AppController

// ASAP classes
import org.asapframework.management.movie.*;

// project classes
import controllers.MenuController;
import events.MyLocalControllerEvent;
import data.AppData;
import events.NavigationEvent;
import data.State;


class controllers.AppController extends LocalController {
    
    /** Container for external movies */
    private var swfholder:MovieClip;
    /** Container for the menu */
    private var menuholder:MovieClip;
    
    /** The current controller */
    private var mController:LocalController = null;
    private var mMenuController:MenuController = null;
    
    /**
    
    */
    public static function main (inTimeline:MovieClip) : Void {
        // create new controller
        var controller:AppController = new AppController(inTimeline);
        // store controller on timeline
        inTimeline.localController = controller;
    }
    
    // PRIVATE METHODS
    
    /**
    Creates a new controllers.AppController. Private constructor, so the controllers.AppController instance will only be created from {@link #main}. Initializes variables; loads the menu SWF and sends a message to show the home movie. Calls {@link #onNavigation} directly.
    */
    private function AppController (inTimeLine:MovieClip) {
        super(inTimeLine);
        setName(AppData.MAIN_NAME); // so other controllers can find the reference of this controller by its name
                
        swfholder = inTimeLine.swfholder;
        menuholder = inTimeLine.menuholder;
        
        // Listen for event when movies are loaded and ready to play
        MovieManager.getInstance().addEventListener(MovieManagerEvent.ON_MOVIE_READY, this);
        
        // load the menu
        var loadResult:Boolean = MovieManager.getInstance().loadMovie(AppData.MENU_NAME, AppData.MENU_URL, menuholder, true );
        
        // Don't load home directly, but send a navigation event
        // this way all state changes will be handles the same way
        onNavigation(new NavigationEvent(NavigationEvent.EVENT_NAVIGATION, AppData.HOME_NAME, this));
    }
        
    /**
    Stores the current LocalController.
    */
    private function storeController (inNewController:LocalController) : Void {
    
        mController = inNewController;
    }
    
    /**
    Loads a new SWF with name <code>inMovieName</code>.
    */
    private function loadNewMovie (inMovieName:String) : Void {
    
        switch (inMovieName) {
            case AppData.HOME_NAME:
                var loadResult:Boolean = MovieManager.getInstance().loadMovie(AppData.HOME_NAME, AppData.HOME_URL, swfholder, true );
                break;
            case AppData.GALLERY_NAME:
                var loadResult:Boolean = MovieManager.getInstance().loadMovie(AppData.GALLERY_NAME, AppData.GALLERY_URL, swfholder, true );
                break;
        }
    }
    
    // EVENT HANDLERS
    
    /**
    Handles NavigationEvent events - sent by various parts in the movie. Returns immediately if the new movie name is equal to the current state. Calls the menu to update. Calls {@link #loadNewMovie}.
    */
    private function onNavigation (e:NavigationEvent) : Void {        
        
        if (e.movieName == State.movieName) {
            return;
        }
        // else
        
        // update the state so the menu can be updated at once
        State.movieName = e.movieName;
        mMenuController.update();
        
        if (mController == null) {
            // first movie
            loadNewMovie(State.movieName);
            return;
        }
        // else
        mController.hide();
    }
    
    /**
    Handles MovieManagerEvent events - sent by MovieManager after a movie has been loaded and initialized.
    */
    public function onMovieReady (e:MovieManagerEvent) {
    
        switch (e.name) {
            case AppData.MENU_NAME:
                mMenuController = MenuController(e.controller);
                mMenuController.addEventListener("onNavigation", this);
                mMenuController.show();
                break;
            default:
                storeController(e.controller);

                // subscribe to NavigationEvents from this controller
                mController.addEventListener("onNavigation", this);

                // subscribe to NavigationEvents from this controller
                mController.addEventListener("onOutAnimationDone", this);

                mController.show();
        }
    }
    
    /**
    Event handler called when controller movie is finished with 'hide'.
    Removes the old movie (after cleaning up its listeners).
    Loads new movie.
    */
    public function onOutAnimationDone (e:MyLocalControllerEvent) : Void {
        
        // remove subscription
        var controller:LocalController = e.controller;
        controller.removeEventListener("onNavigation", this);
        controller.removeEventListener("onOutAnimationDone", this);
        // remove movie
        MovieManager.getInstance().removeMovie(controller.getName());
        
        // Now the old movie has unloaded, we load the new movie
        loadNewMovie(State.movieName);
    }
        
}