Action Script Developer Guide To PureMVC

// NoteVOTest
package com.futurescale.sa.model.vo.test
{
    import com.futurescale.sa.model.vo.NoteVO;
    import flexunit.framework.Assert;
    public class NoteVOTest
    {
        [Test] public function testNoteVOWithXML():void
        {
            var url:String = "http://google.com";
            var text:String = "Some stuff I'm keeping in the cloud.";
            var xml:XML = <Note url={url}>{text}</Note>;
            var vo:NoteVO = new NoteVO( xml );
            if (! vo is NoteVO ) Assert.fail("Construction with xml failed");
            if ( vo.text != text ) Assert.fail("text match failed");
            if ( vo.url != url ) Assert.fail("url match failed");
        }
        [Test] public function testNoteVOWithoutXML():void
        {
            var vo:NoteVO = new NoteVO();
            if (! vo is NoteVO ) Assert.fail("Construction without xml failed");
            if ( vo.xml.localName() != NoteVO.ELEMENT )
            Assert.fail("default xml not provided");
        }
        [Test] public function testSet_text():void
        {
            var text:String = "Bunnies are nice!";
            var vo:NoteVO = new NoteVO();
            vo.text = text;
            if ( vo.text != text ) Assert.fail("text match failed");
        }
        [Test] public function testSet_url():void
        {
            var url:String = "http://puremvc.org";
            var vo:NoteVO = new NoteVO();
            vo.url = url;
            if ( vo.url != url ) Assert.fail("url match failed");
        }
        [Test] public function testSet_xml():void
        {
            var url:String = "http://puremvc.org";
            var text:String = "Code at the Speed of Thought!";
            var xml:XML = <Note url={url}>{text}</Note>;
            var vo:NoteVO = new NoteVO();
            vo.xml = xml;
            if ( vo.text != text ) Assert.fail("text match failed");
            if ( vo.url != url ) Assert.fail("url match failed");
        }
    }
}

/**
 * Register the Commands.
 */
 override protected function initializeController():void
 {
    super.initializeController();

    // Initiated by the App
    registerCommand( AppConstants.STARTUP, StartupCommand );
    // Initiated by the Chooser
    registerCommand( AppConstants.MANAGE_STORY, ManageStoryCommand );
    registerCommand( AppConstants.MANAGE_SERIES, ManageSeriesCommand );
    registerCommand( AppConstants.EDIT_STORY, EditStoryCommand );
    registerCommand( StoryProxy.STORY_ADDED, EditStoryCommand );
    // Initiated by the Editor
    registerCommand( AppConstants.ADD_ITEM, AddItemCommand );
    registerCommand( AppConstants.DELETE_ITEM, DeleteItemCommand );
    registerCommand( AppConstants.APPLY_SELECTION, ApplySelectionCommand );
    registerCommand( AppConstants.REMOVE_SELECTION, RemoveSelectionCommand);
    registerCommand( AppConstants.DISCARD_CHANGES, DiscardChangesCommand );
    registerCommand( AppConstants.APPLY_CHANGES, ApplyChangesCommand);
 }

// PopupRequest.as
package com.futurescale.sa.view.popup.request
{
    import flash.display.DisplayObject;
    //省略。。。。。。

    /**
    * PopupRequest carries all the information necessary
    * to request a popup be created by its mediator.
    */
    public class PopupRequest extends Observer
    {
        // Prefix for all request notification names
        private static const NAME:String = "PopupRequest/";
        // Add new request notification names here...
        public static const ALERT_POPUP:String = NAME + "AlertPopup";
        public static const CONFIRMATION_POPUP:String = NAME + "ConfirmationPopup";
        public static const SERIES_POPUP:String = NAME + "SeriesPopup";
        public static const STORY_POPUP:String = NAME + "StoryPopup";
        public static const CHARACTER_POPUP:String = NAME + "CharacterPopup";
        public static const SETTING_POPUP:String = NAME + "SettingPopup";

        /**
        * Constructor.
        * Example: new PopupRequest( handlePopupNotification, this );
        */
        public function PopupRequest( callback:Function=null,
        caller:Object=null )
        {
            super( callback, caller );
            hasCallback = ( callback != null && caller != null );
        }
        // Request has a callback. (Set by constructor)
        public var hasCallback:Boolean = false;

        // Parent in the display list to open the popup over.
        public var parent:DisplayObject =
        FlexGlobals.topLevelApplication as DisplayObject;

        // Child list to place the popup in
        public var childList:String = PopUpManagerChildList.PARENT;

        // Should the popup be centered?
        public var center:Boolean = true;

        // Should the popup be modal?
        public var modal:Boolean = true;

        // Optional data for the popup to use,
        //such as a title or width and height
        public var data:Object = {};

        // Convenience method for creating a new Alert Request
        public static function getAlertRequest( message:String,
        windowTitle:String="Alert",
        callback:Function=null,
        caller:Object = null):PopupRequest {
            var request:PopupRequest = new PopupRequest( callback, caller );
            request.childList = PopUpManagerChildList.POPUP;
            request.data.windowTitle = windowTitle;
            request.data.message = message;
            return request;
        }
    }
}
// PopupActionEvent.as
package com.futurescale.sa.view.popup.event
{
    import flash.events.Event;
    public class PopupActionEvent extends Event
    {
        // Prefix for all popup action event types
        private static const NAME:String = "PopupEvent/";
        // Add new event names here...
        public static const CANCEL:String = NAME + "cancel";
        public static const OK:String = NAME + "ok";
        public static const ADD:String = NAME + "add";
        public static const SAVE:String = NAME + "save";
        public static const DELETE:String = NAME + "delete";

        /**
        * Constructor.
        *
        * Dispatched from a popup, captured by PopupMediatorBase and sent
        * back to the original caller for interpretation.
        */
        public function PopupActionEvent( type:String,
        data:Object = null,
        closePopup:Boolean=true ) {
            super( type );
            this.data = data;
            this.closePopup = closePopup;
        }

        public var data:Object; // optional data
        public var closePopup:Boolean; // close the popup?

    }
}
// IPopup.as
package com.futurescale.sa.view.popup.component
{
    import mx.core.IFlexDisplayObject;
    /**
    * Interface for popups
    */
    public interface IPopup extends IFlexDisplayObject
    {
        function setData( data:Object ):void;
        function getEvents():Array;
    }
}
// ConfirmationPopup.mxml
<?xml version="1.0" encoding="utf-8"?>
<!-- CONFIRMATION POPUP -->
<s:TitleWindow xmlns:fx="http://ns.adobe.com/mxml/2009"
                xmlns:s="library://ns.adobe.com/flex/spark"
                title="{windowTitle}" width="200" height="150" close="onCancel()"
                implements="com.futurescale.sa.view.popup.component.IPopup">
    <fx:Script>
        <![CDATA[
        import com.futurescale.sa.view.popup.event.PopupActionEvent;

        // Required by IPopup interface
        public function setData( data:Object ):void
        {
            if ( data.windowTitle ) windowTitle = data.windowTitle;
            if ( data.promptText ) promptText = data.promptText;
            if ( data.width ) width = data.width;
            if ( data.height ) height = data.height;
        }

        // Required by IPopup interface
        public function getEvents( ):Array
        {
            return [ PopupActionEvent.OK, PopupActionEvent.CANCEL ]
        }

        private function onOk():void
        {
            dispatchEvent( new PopupActionEvent( PopupActionEvent.OK ) )
        }

        private function onCancel():void
        {
            dispatchEvent( new PopupActionEvent( PopupActionEvent.CANCEL ) )
        }

        [Bindable] private var windowTitle:String = "Confirmation";
        [Bindable] private var promptText:String = "Are you sure?";


    </fx:Script>

    <!-- LAYOUT -->
    <s:VGroup width="100%" height="100%" gap="20" horizontalAlign="center" verticalAlign="middle">

        <!-- MESSAGE -->
        <s:Label text="{promptText}"/>

        <!-- BUTTONS -->
        <s:HGroup gap="20">
            <s:Button label="Cancel" click="onCancel()"/>
            <s:Button label="OK" click="onOk()"/>
        </s:HGroup>
    </s:VGroup>

</s:TitleWindow>

// AbstractPopupMediator.as
package com.futurescale.sa.view.popup.mediator
{
    import com.futurescale.sa.view.popup.component.IPopup;
    // 省略......

    public class AbstractPopupMediator extends Mediator
    {
        public function AbstractPopupMediator( name:String )
        {
            super( name );
        }
        /**
        * Override in subclass.
        * Just create and the concrete popup.
        */
        protected function popupFactory():IPopup
        {
            return null;
        }
        /**
        * Called from the handleNotification method when a request notification
        * is received. Creates the popup with popupFactory(), gives it the data
        * from the request, calls setEventInterests to add the listeners, then
        * pops up the popup and optionally centers it.
        */
        protected function openPopup( ) : void
        {
            var popup:IPopup = popupFactory();
            if (popup) {
                popup.setData( request.data );
                setEventInterests( popup );
                PopUpManager.addPopUp( popup,
                request.parent,
                request.modal,
                request.childList );
                if ( request.center ) PopUpManager.centerPopUp( popup );
            }
        }

        /**
        * Called from openPopup when the request is set, before
        * popping up the popup. Interrogates the popup for the
        * events it will dispatch and sets listeners for each.
        */
        protected function setEventInterests( popup:IPopup ):void
        {
            for each ( var interest:String in popup.getEvents() )
            {
                popup.addEventListener( interest,
                handlePopupAction,
                false, 0, true );
            }
        }

        /**
        * Subclasses will register a single notification interest,
        * which will be handled here in the same way for all subclasses.
        */
        override public function handleNotification( note:INotification ):void
        {
            request = note.getBody() as PopupRequest;
            openPopup( );
        }

        /**
        * Subclasses will set a single notification interest,
        * which will be handled here in the same way for all subclasses.
        * The popup will be closed if specified by the event, and then the
        * caller will be notified with the PopupEvent and the
        */
        protected function handlePopupAction( event:PopupActionEvent ):void
        {
            var popup:IPopup = event.target as IPopup;
            if ( event.closePopup ) removePopup( popup );
            var note:Notification = new Notification( event.type, event );
            if (request.hasCallback) request.notifyObserver( note );
            request = null;
        }

        /**
        * Called if the PopupActionEvent's closePopup property is true
        */
        protected function removePopup( popup:IPopup ):void
        {
            PopUpManager.removePopUp( popup );
        }
        // The request is stored temporarily while the popup is alive
        // so that the mediator can notify the caller.
        protected var request:PopupRequest;
    }
}
//  ConfirmationPopupMediator.as
package com.futurescale.sa.view.popup.mediator
{
    import com.futurescale.sa.view.popup.component.ConfirmationPopup;
    import com.futurescale.sa.view.popup.component.IPopup;
    import com.futurescale.sa.view.popup.request.PopupRequest;

    public class ConfirmationPopupMediator extends AbstractPopupMediator
    {
        public static const NAME:String = "ConfirmationPopupMediator";

        public function ConfirmationPopupMediator()
        {
            super( NAME );
        }

        override public function listNotificationInterests():Array
        {
            return [ PopupRequest.CONFIRMATION_POPUP ];
        }
        override protected function popupFactory():IPopup
        {
            return new ConfirmationPopup();
        }
    }
}
// ManageStoryCommand.as
package com.futurescale.sa.controller.command.story
{
    import com.futurescale.sa.model.proxy.StoryProxy;
    // 省略......

    /**
    * Add, change or delete a Story.
    *
    * Popup the StoryPopup, and if the Story is
    * added or saved, persist it. If deleted, confirm,
    * then delete it.
    */
    public class ManageStoryCommand extends SimpleCommand
    {
        private var story:StoryVO;
        private var storyProxy:StoryProxy;

        override public function execute( note:INotification ):void
        {
            var storyStub:StoryVO = StoryVO( note.getBody() ); // Null if adding
            storyProxy = StoryProxy( facade.retrieveProxy( StoryProxy.NAME ) );
            if ( storyStub ) story = storyProxy.loadStory( storyStub );

            // Request the popup
            var request:PopupRequest =
            new PopupRequest( handleEditPopupNote, this );
            request.data.story = story;
            sendNotification( PopupRequest.STORY_POPUP, request );
        }

        /**
        * Handle the popup actions.
        */
        private function handleEditPopupNote( actionNote:INotification ):void
        {
            var event:PopupActionEvent = PopupActionEvent( actionNote.getBody() );
            story = StoryVO( event.data );
            switch ( actionNote.getName() )
            {
                case PopupActionEvent.ADD:
                    storyProxy.addStory( story );
                    break;

                case PopupActionEvent.SAVE:
                    storyProxy.saveStory( story );
                    break;

                case PopupActionEvent.DELETE:
                    var confirm:PopupRequest =
                    new PopupRequest( handleConfirmPopupNote, this );
                    confirm.data.promptText = "Delete Story?";
                    sendNotification( PopupRequest.CONFIRMATION_POPUP, confirm );
                    break;

                case PopupActionEvent.CANCEL:
                    break;
            }
        }

        /**
        * Handle the ConfirmationPopup actions.
        */
        private function handleConfirmPopupNote( actionNote:INotification ):void
        {
            var event:PopupActionEvent = PopupActionEvent( actionNote.getBody() );
            switch ( actionNote.getName() )
            {
                case PopupActionEvent.OK:
                    storyProxy.deleteStory(story);
                    break;

                case PopupActionEvent.CANCEL:
                    break;
            }
        }
    }
}

// GameBoard.mxml
<?xml version="1.0" encoding="utf-8"?>
    <s:Group xmlns:fx="http://ns.adobe.com/mxml/2009"
            xmlns:s="library://ns.adobe.com/flex/spark"
            xmlns:mx="library://ns.adobe.com/flex/mx">
        <fx:Script>
            <![CDATA[
            // Add a Player component to the center of the gameboard
            public function addPlayerToBoard( player:Player ):void
            {
                player.x = this.width/2;
                player.y = this.height/2;
                addElement( player );
            }

            // Add a Fixture component to a random location on the gameboard
            public function addFixtureToBoard( fixture:Fixture ):void
            {
                fixture.x = Math.random() * this.width;
                fixture.y = Math.random() * this.height;
                addElement( fixture );
            }
        </fx:Script>
    </s:Group>

// GameBoardMediator.as
package com.me.myapp.view.mediator
{
    import com.mycompany.myapp.view.component.GameBoard;
    // 省略......

    public class GameBoardMediator extends Mediator
    {
        public static const NAME:String = 'GameBoardMediator';

        public function GameBoardMediator( viewComponent:GameBoard )
        {
            super( NAME, viewComponent );
        }

        protected function get gameBoard():GameBoard
        {
            return viewComponent as GameBoard;
        }

        override public function listNotificationInterests():Array
        {
            return [ AppConstants.ADD_PLAYER,
            AppConstants.ADD_FIXTURE ];
        }

        override public function handleNotification( note:INotification ):void
        {
            // handle inbound requests to add different components
            switch (note.getName())
            {
                case AppConstants.ADD_PLAYER:
                    var pConfig:PlayerConfigVO = PlayerConfigVO( note.getBody() );
                    addPlayer( pConfig );
                    break;

                case AppConstants.ADD_FIXTURE:
                    var fConfig:FixtureConfigVO = FixtureConfigVO( note.getBody() );
                    addFixture( fConfig );
                    break;
            }
        }

        // Add a mediated Player component to the Gameboard
        protected function addPlayer( playerConfig:PlayerConfigVO ):void
        {
            // Only add Player if it does not already exist
            if ( ! facade.hasMediator( PlayerMediator.NAME ) ) {
                var player:Player = new Player( playerConfig );
                var pm:PlayerMediator = new PlayerMediator( player );
                facade.registerMediator( pm );
                gameBoard.addPlayerToBoard( player );
            }
        }

        // Add an unmediated Fixture component to the Gameboard
        protected function addFixture( fixtureConfig:FixtureConfigVO ):void
        {
            var fixture:Fixture = new Fixture( fixtureConfig );
            gameBoard.addFixtureToBoard( fixture );
        }
    }
}

// IMyMobileApp.as
package com.mycompany.myapp.view
{
    import com.mycompany.myapp.model.vo.InfoVO;
    import flash.events.IEventDispatcher;
    import spark.components.View;
    public interface IMyMobileApp extends IEventDispatcher
    {
        function getActiveView():View;
        function showLoginView():void;
        function showListView():void;
        function showInfoView( infoVO:InfoVO ):void;
        function showFormView():void;
    }
}
// MyMobileApp.xml
<?xml version="1.0" encoding="utf-8"?>
<!-- FLEX MOBILE APPLICATION-->
<s:ViewNavigatorApplication
      firstView="com.mycompany.myapp.view.component.LoginView"
      implements="com.mycompany.myapp.view.IMyMobileApp"
      applicationComplete="facade.startup(this)"
      xmlns:s="library://ns.adobe.com/flex/spark"
      xmlns:fx="http://ns.adobe.com/mxml/2009">
    <fx:Script>
        <![CDATA[
        import com.mycompany.myapp.ApplicationFacade;
        import com.mycompany.myapp.model.vo.InfoVO;
        import com.mycompany.myapp.view.component.InfoView;
        import com.mycompany.myapp.view.component.ListView;
        import com.mycompany.myapp.view.component.LoginView;
        import com.mycompany.myapp.view.component.FormView;

        import spark.components.View;
        // RETRIEVE FACADE
        private var facade:ApplicationFacade = ApplicationFacade.getInstance();
        // READ ONLY CONTEXT
        private function get context():String
        {
            // if there is no context, then we are on the LoginView,
            // set by firstView (we can't set a context for firstView)
            return ( navigator.context ) ? String( navigator.context ) : LOGIN;
        }

        // CONTEXT VALUES
        private static const LOGIN:String = "LoginView";
        private static const LIST:String = "ListView";
        private static const FORM:String = "FormView";
        private static const INFO:String = "InfoView";
        //-----------------------------------------------------------
        // Below methods satisfy IMyMobileApp interface
        //-----------------------------------------------------------

        // GET THE ACTIVE VIEW
        public function getActiveView():View
        {
            // Since the LoginView is specified as the 'firstView'
            // we need to mediate it in the traditional way, which means
            // we need to expose the active view
            return navigator.activeView;
        }

        // SHOW THE LOGIN VIEW
        public function showLoginView( ):void
        {
            // Only return to LoginView if we're not already on it
            if ( context != LOGIN ) navigator.popToFirstView();
        }

        // SHOW THE LIST VIEW
        public function showListView( ):void
        {
            // Only act if we're not already on the ListView
            if ( context != LIST )
            {
                // If returning (from Info or Form views), just pop
                // otherwise push a new ListView
                var returning:Boolean = ( context == INFO || context == FORM );
                if ( returning ) {
                    navigator.popView();
                } else {
                    navigator.pushView( ListView, null, LIST );
                }
            }
        }

        // SHOW THE FORM VIEW
        public function showFormView( ):void
        {
            // Only push a FormView if we're not already on it
            if ( context != FORM )
            navigator.pushView( FormView, null, FORM );
        }

        // SHOW THE INFO VIEW (PASSING IN INFO VO)
        public function showInfoView( infoVO:InfoVO ):void
        {
            // Only push an InfoView if we're not already on it
            if ( context != INFO )
            navigator.pushView( InfoView, infoVO, INFO );
        }
    </fx:Script>

</s:ViewNavigatorApplication>

// ApplicationFacade.as
package com.mycompany.myapp
{
    import com.mycompany.myapp.controller.command.StartupCommand;
    import com.mycompany.myapp.controller.constants.AppConstants;
    import com.mycompany.myapp.view.IMyMobileApp;

    public class ApplicationFacade
    {
        public static function getInstance() : ApplicationFacade
        {
            if ( instance == null ) {
                instance = new ApplicationFacade();
            }
            return ApplicationFacade( instance );
        }

        public function startup( app:IMyMobileApp ):void
        {
            registerCommand( AppConstants.STARTUP, StartupCommand );
            sendNotification( ViewerConstants.STARTUP, app );
        }
    }
}

// StartupCommand.as
package com.mycompany.myapp.controller.command
{
    import com.mycompany.myapp.model.proxy.InfoProxy;
    import com.mycompany.myapp.model.proxy.ThingProxy;
    import com.mycompany.myapp.view.IMyMobileApp;
    import com.mycompany.myapp.view.mediator.ApplicationMediator;

    import org.puremvc.as3.interfaces.INotification;
    import org.puremvc.as3.patterns.command.SimpleCommand;

    public class StartupCommand extends SimpleCommand
    {
        override public function execute( note : INotification ) : void
        {
            // Prepare the Controller
            facade.registerCommand( AppConstants.MEDIATE_VIEW, MediateViewCommand );

            // Prepare the Model
            facade.registerProxy( new ThingProxy( ) );
            facade.registerProxy( new InfoProxy( ) );
            // Prepare the View
            var app:IMyMobileApp = IMobileApp( note.getBody() );
            facade.registerMediator( new ApplicationMediator( app ) );
        }
    }
}

//ApplicationMediator.as
package com.mycompany.myapp.view.mediator
{
    import com.mycompany.myapp.controller.constants.AppConstants;
    import com.mycompany.myapp.view.IMyMobileApp;
    import com.mycompany.myapp.model.vo.InfoVO;

    import flash.events.Event;

    import org.puremvc.as3.interfaces.INotification;
    import org.puremvc.as3.patterns.mediator.Mediator;

    import spark.components.View;

    public class ApplicationMediator extends Mediator
    {
        public static const NAME:String = "ApplicationMediator";
        // CONSTRUCTOR - HANDLE COMPONENT BY ITS INTERFACE
        public function ApplicationMediator( app:IMyMobileApp )
        {
            super( NAME, app );
        }

        // CALLED AT REGISTRATION - LIST NOTIFICATION INTERESTS
        override public function listNotificationInterests():Array
        {
            return [ AppConstants.SHOW_LOGIN,
            AppConstants.SHOW_LIST,
            AppConstants.SHOW_FORM,
            AppConstants.SHOW_INFO,
            ];
        }

        // CALLED AT REGISTRATION - LISTEN FOR EVENTS, MEDIATE FIRST VIEW
        override public function onRegister():void
        {
            // Listen for Views to be created
            app.addEventListener( Event.ADDED, handleAdded );

            // Mediate the firstView
            sendNotification( AppConstants.MEDIATE_VIEW, app.getActiveView() );
        }
        // HANDLE NOTIFICATIONS TO CHANGE VIEWS
        override public function handleNotification( note:INotification ):void
        {
            switch ( note.getName() )
            {
                case AppConstants.SHOW_LOGIN:
                    app.showLoginView();
                    break;
                case AppConstants.SHOW_LIST:
                    app.showListView();
                    break;
                case AppConstants.SHOW_FORM:
                    app.showFormView();
                    break;
                case AppConstants.SHOW_INFO:
                    app.showInfoView( InfoVO( note.getBody() ) );
                    break;
            }
        }

        // HANDLE ADDED EVENTS
        private function handleAdded( event:Event ):void
        {
            // Only act on Views
            if ( event.target is View ) {
                sendNotification( AppConstants.MEDIATE_VIEW, event.target );
            }
        }

        // CAST THE VIEW COMPONENT TO THE PROPER TYPE
        private function get app():IMyMobileApp
        {
            return viewComponent as IMyMobileApp;
        }
    }
}

// MediateViewCommand.as
package com.mycompany.myapp.controller.command
{
    import com.mycompany.myapp.view.component.InfoView;
    import com.mycompany.myapp.view.component.ListView;
    import com.mycompany.myapp.view.component.LoginView;
    import com.mycompany.myapp.view.component.FormView;
    import com.mycompany.myapp.view.mediator.InfoViewMediator;
    import com.mycompany.myapp.view.mediator.ListViewMediator;
    import com.mycompany.myapp.view.mediator.LoginViewMediator;
    import com.mycompany.myapp.view.mediator.FormViewMediator;

    import org.puremvc.as3.interfaces.INotification;
    import org.puremvc.as3.interfaces.IMediator;
    import org.puremvc.as3.patterns.command.SimpleCommand;

    import spark.components.View;

    public class MediateViewCommand extends SimpleCommand
    {
        /**
        * Each View is destroyed once it is moved away from,
        * thus Mediators must also be transient. Any existing
        * Mediator is removed, and a new one registered
        * along with the new View. Any additional Mediators
        * associated with the children of these Views should be
        * registered and removed in the onRegister() and onRemove()
        * methods of the View's Mediator.
        */
        override public function execute( note:INotification ):void
        {
            var view:View = View( note.getBody() );
            var mediator:IMediator;
            switch ( view.className )
            {
                case "LoginView":
                    facade.removeMediator( LoginViewMediator.NAME );
                    mediator = new LoginViewMediator( view as LoginView );
                    break;
                case "ListView":
                    facade.removeMediator( ListViewMediator.NAME );
                    mediator = new ListViewMediator( view as ListView );
                    break;
                case "InfoView":
                    facade.removeMediator( InfoViewMediator.NAME );
                    mediator = new InfoViewMediator( view as InfoView );
                    break;
                case "FormView":
                    facade.removeMediator( FormViewMediator.NAME );
                    mediator = new FormViewMediator( view as FormView );
                    break;
            }
            if (mediator) facade.registerMediator( mediator );
        }
    }
}

//ListView.xml
<?xml version="1.0" encoding="utf-8"?>
    <!-- LIST VIEW -->
    <s:View xmlns:s="library://ns.adobe.com/flex/spark"
            xmlns:fx="http://ns.adobe.com/mxml/2009"
            destructionPolicy="never">

    <!-- LIST STUFF HAPPENS HERE -->

    </s:View>