emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/SiteManager.as

@@ -0,0 +1,25 @@
+package <%= base_package %>.controllers.manager {
+
+	import <%= base_package %>.models.domain.Content;
+	
+	import org.restfulx.Rx;
+	import org.restfulx.collections.ModelsCollection;
+	
+	public class SiteManager extends ContentManager {
+		
+		override public function set contentTree(value:ModelsCollection):void {
+			super.contentTree = Rx.models.index(Content);
+		}
+		
+		public function SiteManager() {
+		}
+		
+		override public function route(action:String, resource:Object, contentNode:String=null):void {
+			if (!contentNode) {
+				dispatchContentToManager(resource, action, contentNode);
+			} else {
+				super.route(action, resource, contentNode);
+			}
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/manager/UndoManager.as

@@ -0,0 +1,143 @@
+/* Copyright 2008 Theo Hultberg/Iconara */
+
+package <%= base_package %>.controllers.manager {
+	
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	
+	import <%= base_package %>.controllers.command.Undoable;
+	
+
+	/**
+	 * The UndoManager keeps a stack of all the (undoable) commands that have
+	 * been executed, and provides an interface for interacting with this
+	 * command history.
+	 * 
+	 * Once a command is undone it is placed on the redo stack, and vice-versa. If
+	 * a command is undone and another command is added to the undo stack before
+	 * redo is called the redo stack is cleared. 
+	 * 
+	 * The current implementation keeps an infinite history, which probably isn't
+	 * a very good idea in the long run.
+	 * 
+	 * The current implementation also ignores the timestamp property of Undoable,
+	 * which is unfortunate. The timestamp makes it possible to group undoables so
+	 * that those that were performed at almost the same time, just milliseconds
+	 * apart, could be undone at the same time. Take typing a text as an example:
+	 * each keystroke is an undoable action, but the user may not expect or want
+	 * to have to undo each keystroke separately. Instead of implementing an
+	 * algorithm that only creates an undoable command at certain intervals, this
+	 * could be done automatically here in the undo manager by undoing all commands
+	 * that were executed within the x milliseconds of the command that is being
+	 * undone.
+	 */
+	public class UndoManager extends EventDispatcher {
+		
+		private var undoStack : Array;
+		private var redoStack : Array;
+
+
+		/** Undo is possible if there are undoable commands in the stack. */
+		[Bindable(event="undoChanged")]
+		public function get undoPossible( ) : Boolean {
+			return undoStack.length > 0;
+		}
+		
+		/**
+		 * Redo is possible if there are undoable commands in the redo stack, 
+		 * i.e. if any command have been undone.
+		 */
+		[Bindable(event="undoChanged")]
+		public function get redoPossible( ) : Boolean {
+			return redoStack.length > 0;
+		}
+		
+		/**
+		 * Returns a copy of the undo stack. This can be used to display the undo
+		 * history and provide a way to jump multiple steps back in the undo history at once.
+		 * 
+		 * The commands in the history are sorted from the oldest to the newest.
+		 */
+		[Bindable(event="undoChanged")]
+		public function get history( ) : Array {
+			return undoStack.slice();
+		}
+		
+		
+		public function UndoManager( ) {
+			undoStack = [ ];
+			redoStack = [ ];
+		}
+		
+		private function dispatchUndoChanged( ) : void {
+			dispatchEvent(new Event("undoChanged"));
+		}
+		
+		/**
+		 * Once an undoable command is executed it should be added to the undo manager using
+		 * this method.
+		 * 
+		 * This method clears the redo stack, because adding a new undoable after and undo forks
+		 * the undo history, and the state of the application is no longer the same as it was when
+		 * the commands on the redo stack were executed originally.
+		 */
+		public function addUndoable( undoable : Undoable ) : void {
+			undoStack.push(undoable);
+			redoStack = [ ];
+			
+			dispatchUndoChanged();
+		}
+		
+		/**
+		 * This method provides a way to jump an arbitrary number of steps back in the undo history.
+		 */
+		public function restore( undoable : Undoable ) : void {
+			if ( undoStack.indexOf(undoable) > -1 ) {
+				while ( redoStack[redoStack.length - 1] != undoable ) {
+					// undo until the newest command on the redo stack is the target command
+					
+					undo();
+					
+					// this could most certainly be implemented more efficiently, for example
+					// placing all commands on the undo stack on the redo stack until the 
+					// target undoable was found, call undo on that command and place it on
+					// the redo stack, but we'll save that for when we see the need
+				}
+			} else {
+				throw new ArgumentError("Cannot restore because the undoable object specified is not part of the undo history");
+			}
+		}
+		
+		/**
+		 * Undo the most recently added command. The command is placed on the redo stack.
+		 */
+		public function undo( ) : void {
+			if ( undoPossible ) {				
+				var command : Undoable = undoStack.pop();
+			
+				command.undo();
+			
+				redoStack.push(command);
+			
+				dispatchUndoChanged();
+			}
+		}
+		
+		/**
+		 * Redo the most recently undone command. The command is placed on the undo stack.
+		 */
+		public function redo( ) : void {
+			if ( redoPossible ) {
+				var command : Undoable = redoStack.pop();
+
+				command.redo();
+			
+				undoStack.push(command);
+			
+				dispatchUndoChanged();
+			}
+		}
+
+	}
+
+}

data/rails_generators/emergent_config/templates/app/flex/application/controllers/map/DocumentMap.mxml

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Copyright 2008 Theo Hultberg/Iconara -->
+
+<LocalEventMap xmlns="http://mate.asfusion.com/" xmlns:mx="http://www.adobe.com/2006/mxml">
+	
+	<mx:Script>
+	<![CDATA[
+
+	import mx.events.FlexEvent;
+	
+	import com.asfusion.mate.actionLists.IScope;
+
+	
+	import <%= base_package %>.models.domain.Document;
+	import <%= base_package %>.models.presentation.DocumentModel;
+
+	import <%= base_package %>.views.document.PlainDocumentView;
+	import <%= base_package %>.views.document.RichDocumentView;
+	import <%= base_package %>.views.document.DocumentView;
+	
+	import <%= base_package %>.controllers.event.DocumentEvent;
+	import <%= base_package %>.controllers.event.UndoEvent;
+	import <%= base_package %>.controllers.manager.DocumentManager;
+	import <%= base_package %>.controllers.manager.UndoManager;
+	
+	[Bindable] public var doc:Document;
+
+	]]>
+	</mx:Script>
+	
+	<Debugger level="{Debugger.ALL}"/>
+	
+	<!--
+	This is a local event map, which is different from regular event maps in some small, but crucial aspects:
+	
+	- A local event map only hears events comming from the part of the application where it is defined, i.e.
+	  from the view that declares it and all children of that view.
+	- By default all objects created by ObjectBuilder, MethodInvoker and other tags are local to this event map.
+	
+	The reason I use a local event map here is that it makes each DocumentView into a mini-application within 
+	the application. This is the controller for this mini-application, and the only thing it knows about is how
+	to manage a Document instance. The application controller has to worry about all documents, which of them are
+	open, which is the current, etc. but this sub-controller only needs to know about its specific document. This
+	makes the code here much simpler.
+	
+	The events that this event map handles are also heard by the top-level event map, unless you stop their
+	propagation explicitly. For example the DocumentEvent.SAVE event is handled both here and in the top-level 
+	event map. Most other events are only handled here.
+	-->
+
+	<EventHandlers type="{FlexEvent.PREINITIALIZE}">		
+		<!--
+		A MethodInvoker is a kind of ObjectBuilder, so this creates a DocumentManager,
+		sets its "dispatcher" property and calls the setDocument method.
+		-->
+		<MethodInvoker generator="{DocumentManager}" method="setDocument" arguments="{[doc]}">
+			<Properties dispatcher="{scope.dispatcher}"/>
+		</MethodInvoker>
+		
+		<ObjectBuilder generator="{UndoManager}"/>
+	</EventHandlers>
+		
+	<EventHandlers type="{DocumentEvent.UPDATE}">
+		<MethodInvoker generator="{DocumentManager}" method="update" arguments="{[event.reference]}"/>
+	</EventHandlers>
+	
+	<EventHandlers type="{DocumentEvent.SAVED}" dispatcherType="global">
+		<!--
+		This just tells the DocumentManager instance to remove the dirty flag for the document.
+		
+		The event is dispatched by the top-level event map when the document has been successfully saved. 
+		Notice the  dispatcherType property that is set to "global", it makes it possible to listen to
+		events in the same way as top-level event maps can, and it makes it possible to communicate from
+		a top-level event map to local event maps.
+		
+		To avoid reacting to events dispatched because other documents were saved there is a StopHandlers
+		that checks the document reference in the event and compares it to the local document, unless
+		they are the same the event handling will stop.
+		-->
+
+		<StopHandlers eventPropagation="noStop">
+			<stopFunction>{function( scope : IScope ) : Boolean {
+				return DocumentEvent(scope.event).reference != DocumentMap(scope.eventMap).doc;
+			}}</stopFunction>
+		</StopHandlers>
+		
+		<MethodInvoker generator="{DocumentManager}" method="documentSaved"/>
+	</EventHandlers>
+	
+	<EventHandlers type="{UndoEvent.UNDO}">
+		<MethodInvoker generator="{UndoManager}" method="undo"/>
+	</EventHandlers>
+	
+	<EventHandlers type="{UndoEvent.REDO}">
+		<MethodInvoker generator="{UndoManager}" method="redo"/>
+	</EventHandlers>
+	
+	<EventHandlers type="{UndoEvent.RESTORE}">
+		<MethodInvoker generator="{UndoManager}" method="restore" arguments="{event.undoable}"/>
+	</EventHandlers>
+	
+	<EventHandlers type="{UndoEvent.ADD_UNDOABLE}">
+		<MethodInvoker generator="{UndoManager}" method="addUndoable" arguments="{event.undoable}"/>
+	</EventHandlers>
+	
+	
+	<Injectors targets="{[PlainDocumentView, RichDocumentView, DocumentView]}">
+		<ObjectBuilder generator="{DocumentModel}" registerTarget="true"/>
+
+	    <PropertyInjector targetKey="model" source="{lastReturn}" />
+	</Injectors>
+	
+	<Injectors target="{DocumentModel}">
+		<PropertyInjector targetKey="dispatcher"    source="{scope.dispatcher}"/>
+		<PropertyInjector targetKey="document"      source="{DocumentManager}" sourceKey="document"/>
+		<PropertyInjector targetKey="documentDirty" source="{DocumentManager}" sourceKey="documentDirty"/>
+		<PropertyInjector targetKey="undoPossible"  source="{UndoManager}"     sourceKey="undoPossible"/>
+		<PropertyInjector targetKey="redoPossible"  source="{UndoManager}"     sourceKey="redoPossible"/>
+		<PropertyInjector targetKey="undoHistory"   source="{UndoManager}"     sourceKey="history"/>
+	</Injectors>
+		
+</LocalEventMap>

data/rails_generators/emergent_config/templates/app/flex/application/controllers/map/DocumentsMap.mxml

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Copyright 2008 Theo Hultberg/Iconara -->
+
+<EventMap xmlns="http://mate.asfusion.com/" xmlns:mx="http://www.adobe.com/2006/mxml">
+	
+	<mx:Script>
+	<![CDATA[
+			
+	import mx.events.FlexEvent;
+	
+	import <%= base_package %>.controllers.event.DocumentEvent;
+	
+	import <%= base_package %>.controllers.manager.DocumentsManager;
+	
+	import <%= base_package %>.views.document.DocumentsView;
+	import <%= base_package %>.models.factory.DocumentViewFactory;
+	
+	import <%= base_package %>.models.presentation.DocumentsModel;
+	
+	import <%= base_package %>.models.factory.DocumentFactory;
+			
+	]]>
+	</mx:Script>
+	
+	<Debugger level="{Debugger.ALL}"/>
+	
+	<!--
+	This is the main event map for the application, think of it as the application controller.
+	-->
+
+	<EventHandlers type="{FlexEvent.PREINITIALIZE}">
+		<!--
+		The FlexEvent.PREINITIALIZE event is a good place for creating and initializing managers.
+		-->
+		
+		<ObjectBuilder generator="{DocumentFactory}"/>
+		
+		<ObjectBuilder generator="{DocumentsManager}">
+			<!--
+			"lastReturn" refers to the return value of the last action, in this case the object
+			created by the ObjectBuilder tag above
+			-->
+			<Properties documentFactory="{lastReturn}"/>
+		</ObjectBuilder>
+	</EventHandlers>
+	
+	<EventHandlers type="{FlexEvent.APPLICATION_COMPLETE}">
+		<!--
+		The FlexEvent.APPLICATION_COMPLETE is a good place to do things that need to be done just
+		when the application setup is finished. Think of it as the FlexEvent.CREATION_COMPLETE of
+		the whole application. It's a good place to load data that needs to be loaded early and
+		set the default navigation state.
+		
+		This application doesn't load anything and has only one view, so it doesn't need to do
+		anything here. I have declared this EventHandlers just to add these tips.
+		-->
+	</EventHandlers>
+	
+	<EventHandlers type="{DocumentEvent.CREATE_NEW}">
+		<MethodInvoker generator="{DocumentsManager}" method="newDocument" arguments="{event.documentType}"/>		
+	</EventHandlers>
+	
+	<EventHandlers type="{DocumentEvent.OPEN}">
+		<MethodInvoker generator="{DocumentsManager}" method="openDocument" arguments="{[event.reference]}"/>		
+	</EventHandlers>
+	
+	<EventHandlers type="{DocumentEvent.CLOSE}">
+		<MethodInvoker generator="{DocumentsManager}" method="closeDocument" arguments="{[event.reference]}"/>		
+	</EventHandlers>
+	
+	<EventHandlers type="{DocumentEvent.DELETE}">
+		<MethodInvoker generator="{DocumentsManager}" method="deleteDocument" arguments="{[event.reference]}"/>		
+	</EventHandlers>
+	
+	<EventHandlers type="{DocumentEvent.SAVE}">
+		<MethodInvoker generator="{DocumentsManager}" method="save" arguments="{[event.reference]}"/>		
+		<!--
+		This application doesn't actually save documents, but if it had this would be the place to do it.
+
+		When the save is successfully completed (or just not done at all, in this case), I dispatch an
+		event telling anyone who listens that a document has been saved.
+		-->
+		<EventAnnouncer generator="{DocumentEvent}" type="{DocumentEvent.SAVED}">
+			<Properties reference="{event.reference}"/>
+		</EventAnnouncer>
+	</EventHandlers>
+	
+	
+	<Injectors target="{DocumentsView}">
+		<!--
+		This creates the Presentation Model object for the MainView, notice the registerTarget
+		property, which makes it possible to use Injectors that target this object, something that
+		otherwise is only possible with view objects.
+		-->
+	    <ObjectBuilder generator="{DocumentsModel}" registerTarget="true" />
+
+		<!-- This injects the DocumentsModel instance created by the last tag into the MainView instance -->
+		<PropertyInjector targetKey="model" source="{lastReturn}" />
+		
+		<!--
+		This creates a DocumentViewFactory and injects it into MainView. If more than one MainView
+		were to be created the same DocumentViewFactory instance would be reused, because Mate caches
+		all objects that are created by the EventMap, unless you tell it not to.
+		-->
+		<PropertyInjector targetKey="documentViewFactory" source="{DocumentViewFactory}"/>
+	</Injectors>
+	
+	<Injectors target="{DocumentsModel}">
+		<!--
+		DocumentModel is not a view class, but can be used as a target for injection because an instance
+		of the class was created with an ObjectBuilder that had the registerTarget property set to true,
+		see the Injectors for DocumentView.
+		-->
+
+		<!--
+		"scope.dispatcher" refers to the event dispatcher used by the event map. Events dispatched using this
+		dispatcher will be heard by this event map. The reason why I inject this dispatcher into the DocumentsModel
+		object is that since it's not a view class events that it dispatches don't bubble up, and so it needs
+		a way to dispatch events that can be heard by this event map.
+		-->
+		<PropertyInjector targetKey="dispatcher"      source="{scope.dispatcher}"/>
+		
+		<!--
+		This injects some objects into the DocumentsModel instance, but also sets up bindings so that when the
+		"documents", "openDocuments" or "currentDocument" properties on the DocumentsManager instance change
+		they will automatically be updated in the DocumentsModel instance too.
+		-->
+		<PropertyInjector targetKey="documents"       source="{DocumentsManager}" sourceKey="documents"/>
+		<PropertyInjector targetKey="openDocuments"   source="{DocumentsManager}" sourceKey="openDocuments"/>
+		<PropertyInjector targetKey="currentDocument" source="{DocumentsManager}" sourceKey="currentDocument"/>
+	</Injectors>
+		
+</EventMap>

data/rails_generators/emergent_config/templates/app/flex/application/controllers/map/ManagerPresentationModelMap.mxml

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<EventMap xmlns="http://mate.asfusion.com/" xmlns:mx="http://www.adobe.com/2006/mxml">
+
+	<!--
+	This is the main event map for the application, think of it as the application controller.
+	-->
+
+	<mx:Script>
+	<![CDATA[
+			
+	import mx.events.FlexEvent;
+	
+	import <%= base_package %>.models.presentation.*;
+	import <%= base_package %>.controllers.manager.*;
+	
+	import <%= base_package %>.views.navigation.NavigationBarLeftView;
+			
+	]]>
+	</mx:Script>
+	
+	<!--	<Debugger level="{Debugger.ALL}"/>	-->
+
+	<EventHandlers type="{FlexEvent.PREINITIALIZE}">
+	</EventHandlers>
+	
+	<EventHandlers type="{FlexEvent.APPLICATION_COMPLETE}">
+	
+	</EventHandlers>
+		
+	<Injectors targets="{[AuthenticationManager, HomeManager, AboutUsManager, SiteManager]}">
+		<PropertyInjector targetKey="dispatcher" source="{scope.dispatcher}"/>
+	</Injectors>
+	
+	<Injectors target="{MainManager}">
+		<PropertyInjector targetKey="cmsMode" source="{NavigationBarTopModel}" sourceKey="cmsMode"/>
+	</Injectors>
+	
+	<Injectors target="{ProfileModel}">
+		<PropertyInjector targetKey="currentUser" source="{AuthenticationManager}" sourceKey="currentUser"/>
+	</Injectors>
+
+	<Injectors target="{MainModel}">
+		<PropertyInjector targetKey="currentUser" source="{AuthenticationManager}" sourceKey="currentUser"/>
+		<PropertyInjector targetKey="login" source="{AuthenticationManager}" sourceKey="login"/>
+		<PropertyInjector targetKey="logout" source="{AuthenticationManager}" sourceKey="logout"/>
+		<PropertyInjector targetKey="cmsMode" source="{MainManager}" sourceKey="cmsMode"/>	
+	</Injectors>
+	
+	<Injectors target="{AboutUsModel}">
+		<PropertyInjector targetKey="target" source="{AboutUsManager}" sourceKey="target"/>
+		<PropertyInjector targetKey="parent" source="{AboutUsManager}" sourceKey="parent"/>
+		<PropertyInjector targetKey="children" source="{AboutUsManager}" sourceKey="children"/>
+	</Injectors>
+	
+	<Injectors target="{NavigationBarLeftView}">
+		<PropertyInjector targetKey="contentTree" source="{SiteManager}" sourceKey="contentTree"/>
+	</Injectors>
+		
+</EventMap>

data/rails_generators/emergent_config/templates/app/flex/application/controllers/map/ObjectMap.mxml

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<EventMap xmlns="http://mate.asfusion.com/" xmlns:mx="http://www.adobe.com/2006/mxml">
+
+	<mx:Script>
+	<![CDATA[
+			
+	import mx.events.FlexEvent;
+	
+	import <%= base_package %>.models.presentation.*;
+
+	import <%= base_package %>.controllers.manager.*;
+
+	import <%= base_package %>.views.aboutUs.*;
+	import <%= base_package %>.views.account.*;
+	import <%= base_package %>.views.login.*;
+	import <%= base_package %>.views.profile.*;
+	import <%= base_package %>.views.contactUs.*;
+	import <%= base_package %>.views.main.*;
+	import <%= base_package %>.views.pages.*;
+	import <%= base_package %>.views.navigation.*;
+
+	import <%= base_package %>.models.factory.ResourceFactory;
+
+	]]>
+	</mx:Script>
+	
+	<!--	<Debugger level="{Debugger.ALL}"/>	-->
+
+	<EventHandlers type="{FlexEvent.PREINITIALIZE}">
+		<!-- Views -->
+    	<ObjectBuilder generator="{AccountView}"/>
+    	<ObjectBuilder generator="{LoginView}"/>
+    	<ObjectBuilder generator="{ProfileView}"/>
+    	<ObjectBuilder generator="{ContactUsView}"/>
+    	<ObjectBuilder generator="{PagesView}"/>
+		<ObjectBuilder generator="{NavigationBarLeftView}"/>
+		<ObjectBuilder generator="{NavigationBarRightView}"/>
+		<ObjectBuilder generator="{NavigationBarTopView}"/>
+		<ObjectBuilder generator="{NavigationBarBottomView}"/>
+		<ObjectBuilder generator="{NavigationBarsView}"/>
+
+		<!-- Presenters -->
+    	<ObjectBuilder generator="{PagesPresenter}"/>
+		<ObjectBuilder generator="{NavigationBarLeftPresenter}"/>
+		<ObjectBuilder generator="{NavigationBarRightPresenter}"/>
+		<ObjectBuilder generator="{NavigationBarTopPresenter}"/>
+		<ObjectBuilder generator="{NavigationBarBottomPresenter}"/>
+		<ObjectBuilder generator="{NavigationBarsPresenter}"/>
+
+		<!-- Managers -->
+    	<ObjectBuilder generator="{AccountManager}"/>
+    	<ObjectBuilder generator="{ResourceManager}"/>
+    	<ObjectBuilder generator="{PagesManager}"/>
+    	<ObjectBuilder generator="{AuthenticationManager}"/>
+    	<ObjectBuilder generator="{SiteManager}"/>
+
+		<!-- Presentation Models -->
+    	<ObjectBuilder generator="{AccountModel}"/>
+    	<ObjectBuilder generator="{ResourceModel}"/>
+    	<ObjectBuilder generator="{PagesModel}"/>
+    	<ObjectBuilder generator="{MainModel}"/>
+    	<ObjectBuilder generator="{ContactUsModel}"/>
+    	<ObjectBuilder generator="{ProfileModel}"/>
+    	<ObjectBuilder generator="{AuthenticationModel}"/>
+		<ObjectBuilder generator="{NavigationBarLeftModel}"/>
+		<ObjectBuilder generator="{NavigationBarRightModel}"/>
+		<ObjectBuilder generator="{NavigationBarTopModel}"/>
+		<ObjectBuilder generator="{NavigationBarBottomModel}"/>
+		<ObjectBuilder generator="{NavigationBarsModel}"/>
+
+		<!-- Factories -->
+    	<ObjectBuilder generator="{ResourceFactory}"/>
+	</EventHandlers>
+	
+</EventMap>

data/rails_generators/emergent_config/templates/app/flex/application/controllers/map/PresentationModelViewMap.mxml

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="utf-8"?>
+<EventMap xmlns="http://mate.asfusion.com/" xmlns:mx="http://www.adobe.com/2006/mxml">
+
+	<mx:Script>
+	<![CDATA[
+			
+	import mx.events.FlexEvent;
+	
+	import <%= base_package %>.models.presentation.AccountModel;
+	import <%= base_package %>.models.presentation.ProfileModel;
+	import <%= base_package %>.models.presentation.ContactUsModel;
+	import <%= base_package %>.models.presentation.AuthenticationModel;
+	import <%= base_package %>.models.presentation.HomeModel;
+	import <%= base_package %>.models.presentation.AboutUsModel;
+	import <%= base_package %>.models.presentation.MainModel;
+
+	import <%= base_package %>.views.account.AccountView;
+	import <%= base_package %>.views.login.LoginView;
+	import <%= base_package %>.views.profile.ProfileView;
+	import <%= base_package %>.views.contactUs.ContactUsView;
+	import <%= base_package %>.views.home.HomeView;
+	import <%= base_package %>.views.aboutUs.AboutUsView;
+	import <%= base_package %>.views.main.MainView;
+
+	]]>
+	</mx:Script>
+	
+	<!--	<Debugger level="{Debugger.ALL}"/>	-->
+
+	<EventHandlers type="{FlexEvent.PREINITIALIZE}">
+	</EventHandlers>
+	
+	<EventHandlers type="{FlexEvent.APPLICATION_COMPLETE}">
+	</EventHandlers>
+	
+	<Injectors target="{MainView}">
+		<PropertyInjector targetKey="model" source="{MainModel}" />
+	</Injectors>
+	
+	<!-- Pages -->
+	<Injectors target="{HomeView}">
+		<PropertyInjector targetKey="model" source="{HomeModel}" />
+	</Injectors>
+	
+	<Injectors target="{LoginView}">
+		<PropertyInjector targetKey="model" source="{AuthenticationModel}" />
+	</Injectors>
+	
+	<Injectors target="{AccountView}">
+		<PropertyInjector targetKey="model" source="{AccountModel}" />
+	</Injectors>
+	
+	<Injectors target="{ProfileView}">
+		<PropertyInjector targetKey="model" source="{ProfileModel}" />
+	</Injectors>
+	
+	<Injectors target="{ContactUsView}">
+		<PropertyInjector targetKey="model" source="{ContactUsModel}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarLeftView}">
+		<PropertyInjector targetKey="model" source="{NavigationBarLeftModel}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarRightView}">
+		<PropertyInjector targetKey="model" source="{NavigationBarRightModel}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarTopView}">
+		<PropertyInjector targetKey="model" source="{NavigationBarTopModel}" />
+	</Injectors>
+	
+	<Injectors target="{NavigationBarBottomView}">
+		<PropertyInjector targetKey="model" source="{NavigationBarBottomModel}" />
+	</Injectors>
+	
+	<Injectors targets="{[AccountModel, AuthenticationModel, ContactUsModel, ProfileModel]}">
+	    <PropertyInjector targetKey="dispatcher" source="{scope.dispatcher}"/>
+	</Injectors>
+	
+</EventMap>