emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/TectonMap2.as

@@ -0,0 +1,289 @@
+
+package com.fourD.core
+{
+	import flash.events.IEventDispatcher;
+	import flash.utils.Dictionary;
+	
+	import mx.core.Application;
+	
+	public class TectonMap2 extends EventMap {
+		
+		/** map of tectons to kanon (parent), tropon (child), and action (string) */
+		public var genericTectonMap:Dictionary;
+		
+		public var tectonMap:Dictionary;
+		
+		/** the tectons that are listening for tectons to start and whatnot */
+		public var tectonReceptors:Dictionary;
+		
+		public var activeReceptors:Dictionary;
+		
+		/** pathway of tectons to be run */
+		public var tectonPathway:Dictionary;
+		
+		private var _dispatcher:IEventDispatcher;
+		
+		private var firstTectonsInTree:Array;
+		private var numLevelsUp:int; // how many levels we've climbed in the tree
+		private var maxLevels:int; // max number of levels in the tree
+		
+		private var pathwayActive:Boolean;
+		
+		private var _presenter:SmartObject = new SmartObject(TectonScopeProperties.PRESENTER);
+		[Bindable(event="propertyChange")]
+		public function get presenter():* { return _presenter; }
+		
+		private var _tropon:SmartObject = new SmartObject(TectonScopeProperties.TROPON);
+		[Bindable(event="propertyChange")]
+		public function get tropon():* { return _tropon; }
+		
+		private var _kanon:SmartObject = new SmartObject(TectonScopeProperties.KANON);
+		[Bindable(event="propertyChange")]
+		public function get kanon():* { return _kanon; }
+		
+		/** holds our tecton objects from XML (easily done in RestfulX) */
+		private var _tectons:Array; [Bindable]
+		public function get tectons():Array { return _tectons; }
+		public function set tectons(value:Array):void {
+			_tectons = value;
+			trace("TECTONS SET");
+			if (_tectons) { initializeMaps(); }
+		}
+		
+		public function TectonMap2() {
+			tectonClassMap = new Dictionary(true);
+			tectonMap = new Dictionary(true);
+			tectonReceptors = new Dictionary(true);
+			tectonPathway = new Dictionary(true);
+			activeReceptors = new Dictionary(true);
+			
+			_dispatcher = this.getDispatcher();
+			_dispatcher.addEventListener(PathwayEvent.TRAVERSE, buildPathway);
+		}
+		
+		// constructs the tectons required into a pathway object and then runs them in order...
+		/**
+		 *	1) Find all Tectons that are assigned to the initialize of another Tecton
+		 *	2) Eliminate those Tectons that are already active or initialized
+		 *	3) Add event listener to the the current Tecton for each of the ones listening for it's initialize...
+		 * 	That is, addEventListener for super Tecton.COMPLETE
+		 * 	4) Create a PathwayDictionary that has in there all the COMPLETE events the currentTecton is listening for
+		 * 	5) Repeat
+		 * 	6) For every COMPLETE the currentTecton hears, remove that one from the Dictionary
+		 * 	7) Once all of them are removed from the Dictionary (by checking after every removal),
+		 * 	8) Run the current Tecton.
+		 */
+		private function buildPathway(event:PathwayEvent):void {
+			if (pathwayActive) { return; }
+			trace("pathwayEvent");
+			var type:String = event.type;
+			var url:Array = event.url;
+			var tropon:*, action:String, tecton:Tecton, kanon:*;
+			var fqnTropon:String, fqnKanon:String;
+			var tectonName:String;
+			var lastTecton:Tecton;
+			// [{view:target, action:"show"}, {view:anotherTarget, action:"flip"}]
+			// for loop is going from end to beginning!  Provides space for initialization...
+			if (url.tropon) { tropon = url.tropon; }
+			if (url.action) { action = url.action; }
+			if (url.kanon) { kanon = url.kanon; }
+			// figure out what the tropon and action are:
+			// 1) if it's multiple tropons, then must be part of the same kanon
+			// 	to figure this out, chop the tropon off so we have the Sos.mainView,
+			//	then find a className based on that
+			//	that's where the tecton is sent.  Tectons must know the parent "Kanon"
+			//var className:String = getQualifiedClassName( event.target ).replace( "::", "." );
+			var path:String = tropon.toString();
+			kanonClass = RouterUtil.getClassKanonName((path);
+			troponClass = RouterUtil.getClassTroponName(path);
+			tectonName = RouterUtil.getTectonName(path, action);
+				if (tropon.parent) { kanon = tropon.parent; }
+				else if (url[i - 1].view) { kanon = url[i - 1].view; }
+				else { kanon = "somethingElse"; }
+				
+				tectonName = tropon.toString() + "." + action;
+				
+				if (tectonMap[tectonName]) {
+					tecton = tectonMap[tectonName];
+				} else {
+					// create a new tecton for that tropon instance...
+					fqnTropon = getQualifiedClassName(tropon);
+					fqnKanon = (kanon is String) ? kanon : getQualifiedClassName(kanon);
+					var appName:String = getQualifiedClassName(Application.application);
+					
+					var genericName:String = appName + "." + fqnKanon + "." + fqnTropon + "." + action;
+					
+					tecton = tectonClassMap[genericName];
+					// create a new one and then store it in the dictionary...
+					tecton = TectonUtils.clone(tecton) as Tecton;
+					tecton.tropon = tropon;
+					
+					tectonMap[tectonName] = tecton;
+					// probably should add to the initialize and complete of other Tectons this
+					// newly generated one...
+					var baseName:String = "tecton" // split off the numbers from the instances in the class path
+					var initializePheronType:String = baseName + Pheron2.INITIALIZE;
+					var intializeTectons:Array = tectonPheronMap[initializePheronType];
+					var startPheronType:String = baseName + Pheron2.START;
+					var startTectons:Array = tectonPheronMap[startPheronType];
+					var completePheronType:String = baseName + Pheron2.COMPLETE;
+					var completeTectons:Array = tectonPheronMap[completePheronType];
+					// add the new tecton to all of the tecton listener handlers in the application
+					// might be expensive?
+					addTectonToHandlers(initializeTectons, Pheron2.INITIALIZE);
+					addTectonToHandlers(startTectons, Pheron2.START);
+					addTectonToHandlers(completeTectons, Pheron2.COMPLETE);					
+				}
+				firstInTree = null;
+				numLevelsUp = 0;
+				maxLevels = 0;
+				initialize(tecton);
+				// this initialize function will create basically a preordered tree
+				// and after tons of recursion, it will get here,
+				// and we know the tree has been built.
+			}
+			pathwayActive = true;
+			// finally, initialize the sequence and the rest will be handled by events!
+			i=0, len = firstTectonsInTree.length;
+			for (i; i < len; i++) {
+				tecton = firstTectonsInTree[i];
+				tecton.runSequence(scope);
+			}
+		}
+		
+		private function addTectonToHandlers(handlerTectons:Array, phase:String):void {
+			if (handlerTectons == null) { return; }
+			var i:int=0, len:int = handlerTectons.length;
+			for (i; i < len; i++) {
+				var tect:Tecton = handlerTectons[i];
+				if (phase == Pheron2.INITIALIZE) { tect.initializeHandlers.push(tecton); }
+				else if (phase == Pheron2.START) { tect.startHandlers.push(tecton); }
+				else if (phase == Pheron2.COMPLETE) { tect.completeHandlers.push(tecton); }
+			}
+		}
+		
+		public function getTecton(fqnKanon:String, fqnTropon:String, action:String):Tecton {
+			return TectonUtils.clone(tectonClassMap[fqnKanon][fqnTropon][action]) as Tecton
+		}
+		
+		public function initialize(tecton:Tecton):void {
+			if (!tecton) { return; } // throw error
+			
+			// 2) validate tecton conditions to see if it's viable
+			var conditions:Array = tecton.conditions;
+			if (conditions != null) {
+				var value:Boolean = ConditionsUtil.validateConditions(conditions)
+				if (!value) { return; }
+			}
+			
+			tecton.isInitialized = true;
+			var initializePheronType:String = tecton.toString() + Pheron2.INITIALIZE;			
+			
+			// 4) Find tectons that are listening for this tecton to initialize
+			initializeReceptorTectons(tecton, initializePheronType);			
+		}
+		
+		private function initializeReceptorTectons(tecton:Tecton, pheronType:String):Array {
+			var receptorTectons:Array;
+			if (pathwayMap[numLevelsUp] == undefined) {
+				// then it's a new level!
+				pathwayMap[numLevelsUp] = new Array();
+				numLevelsUp ++;
+				pathwayMap[numLevelsUp].push(tecton);
+			}
+			if (tectonReceptors[pheronType] != undefined) {
+				receptorTectons = tectonReceptors[pheronType];
+			}
+			if (receptorTectons != null) {
+				var i:int=0, len:int = receptorTectons.length;
+				for (i; i < len; i++) {
+					var receptorTecton:Tecton = receptorTectons[i];
+					// if it's already active, forget about it
+					if (receptorTecton.isActive || receptorTecton.isInitialized) { continue; }
+					var completePheronType:String = receptorTecton.toString() + Pheron2.COMPLETE;
+					tecton.addEventListener(completePheronType, tecton.tectonate);
+					initialize(receptorTecton);
+				}
+			}
+			
+			if (numLevelsUp > maxLevels) {
+				// since the initialize() method will create another loop,
+				// this value will only be calculated when it reaches the leaf of the tree.
+				maxLevels = numLevelsUp;
+				firstTectonsInTree = pathwayMap[maxLevels];
+			}
+		}
+		
+		private function initializeMaps():void {
+			var fqnTecton:String = getQualifiedClassName(tecton);
+			registerClassAlias(fqnTecton.replace("::","."), Tecton);
+			var i:int=0, len:int = tectons.length;
+			trace("INITIALIZE MAPS!");
+			// 1) create map of tectonReceptors to tectons
+			// 2) create map of tropons (from the troponTree) to tectons
+			var tecton:Tecton, tropon:*, tropons:Array, action:String, kanon:*;
+			for (i; i < len; i++) {
+				tecton = tectons[i];
+				action = tecton.actionName;
+				if (tecton.tropon) {
+					trace("tecton exists");
+					tropon = tecton.tropon;
+					if (!tropon is Class) {
+						trace("tropon is displayObject");
+						trace(tropon);
+						if (!tecton.kanon) {
+							trace("kanon wasn't explicitly defined");
+							kanon = (tropon.parent) || null;
+						}
+					} else if (tropon is Class) {
+						trace("tropon is class = " + tropon);
+						if (!tecton.kanon) {
+							trace("kanon doesn't exist for class");
+							//THROW ERROR, try to find it some other way, via the content map?
+						} else {
+							kanon = tecton.kanon;
+						}
+					}
+				}
+				else if (tecton.tropons) {
+					tropons = tecton.tropons;
+				}
+				// doesn't matter if it's a Class or DisplayObject :)
+				var fqnKanon:String = getQualifiedClassName(kanon);
+				var fqnTropon:String = getQualifiedClassName(tropon);
+				var fqnApp:String = getQualifiedClassName(Application.application);
+				var genericName:String = fqnApp + "." + fqnKanon + "." + fqnTropon + "." + action;
+				var baseName:String = "something" // figure out something like Sos.mainView.button.panel
+				genericTectonMap[genericName] = tecton;
+				genericTectonMap[baseName] = tecton;
+				
+				var j:int=0, lenj:int;
+				trace(tropon);
+				if (tropon != null) {
+					trace("Tropon is not equal to null");
+					fqnTropon = getQualifiedClassName(tropon);
+					if (tectonClassMap[fqnKanon] == undefined) {
+						tectonClassMap[fqnKanon] = new Dictionary(true); trace("first dictionary");
+					}
+					if (tectonClassMap[fqnKanon][fqnTropon] == undefined) {
+						tectonClassMap[fqnKanon][fqnTropon] = new Dictionary(true); trace("second dictionary");
+					}
+					if (action) {
+						tectonClassMap[fqnKanon][fqnTropon][action] = tecton;
+						trace("ALL OF IT: " + "\nKanon = " + fqnKanon + "\nTropon = " + fqnTropon + "\nAction = " + action);
+					}
+				} else if (tropons != null && tropon == null) {
+					lenj = tropons.length;
+					for (j; j < lenj; j++) {
+						tropon = tropons[j];
+						fqnTropon = getQualifiedClassName(tropon);
+						if (tectonClassMap[fqnKanon] == undefined) { tectonClassMap[fqnKanon] = new Dictionary(true); }
+						if (tectonClassMap[fqnKanon][fqnTropon] == undefined) { tectonClassMap[fqnKanon][fqnTropon] = new Dictionary(true); }
+						if (action) { tectonClassMap[fqnKanon][fqnTropon][action] = tecton; }
+					}
+				}
+			}
+		}
+
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/TectonMapSample.mxml

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="utf-8"?>
+<TectonMap xmlns="com.fourD.core.*" xmlns:mx="http://www.adobe.com/2006/mxml">
+
+	<mx:Script>
+	<![CDATA[
+			
+	import mx.events.FlexEvent;
+	
+	import sos.views.main.MainView;
+	import sos.views.main.MainPresenter;
+	import mx.controls.Button;
+			
+	]]>
+	</mx:Script>
+	
+	<!--	<Debugger level="{Debugger.ALL}"/>	-->
+	<tectons>
+		
+	
+	<Tecton id="showLogin" tropon="{Button}" kanon="{MainView}" actionName="show">
+	<!--<conditions>
+			<SimpleCondition property="spinLogin.isActive" value="false"/>
+			<ComplexCondition firstItem="{event.tropon}" secondItem="" operator=""/>
+		</conditions>	-->
+		<actions>
+			<InstanceMethodInvoker method="instant" instance="{event.tropon.parent.presenter}"
+				arguments="{[event.tropon]}"/>
+		</actions>
+	</Tecton>
+	
+	<Tecton id="showPage">
+		<conditions>
+			<ComplexCondition firstItem="{event.tropon}" secondItem="" operator=""/>
+		</conditions>
+		<actions>
+			<InstanceMethodInvoker method="index" instance="{event.target.parent.presenter}"
+				arguments="{[event.tropon]}"/>
+		</actions>
+	</Tecton>
+	
+<!--<Tecton id="showAllPages">
+		<receptors>
+			<TectonReceptor tecton="{hideLogin}" eventType="{TectonEvent.RUN_COMPLETE}"/>
+		</receptors>
+		<conditions>
+			<ComplexCondition firstItem="{event.tropon}" secondItem="" operator=""/>
+			<SimpleCondition property="{showLogin.isActive}" value="false"/>
+		</conditions>
+		<actions>
+			<InstanceMethodInvoker method="index" instance="{event.tropons[0].parent.presenter}"
+				arguments="{[event.tropons]}"/>
+		</actions>
+		<complete>
+			<InstancePropertyInjector instance="{event.tropons[0].parent}">
+				<Properties currentState="index"/>
+			</InstancePropertyInjector>
+		</complete>
+	</Tecton>
+	
+	<Tecton id="introCarousel">
+		<conditions>
+			<SimpleCondition property="introCarousel.isActive" value="false"/>
+		</conditions>
+		<actions>
+			<InstanceMethodInvoker method="intro" instance="{event.target}"
+				arguments="{[event.tropons]}"/>
+		</actions>
+		<receptors>
+			<TectonReceptor tecton="{hideLogin}" eventType="{TectonEvent.RUN_COMPLETE}"/>
+		</receptors>
+	</Tecton>	-->
+	</tectons>	
+</TectonMap>

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/TectonReceptor.as

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2008-2009 (c) Lance Pollard
+ * www.systemsofseven.com/blog
+ * www.4ddesignlab.com
+ * LanceJPollard@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.fourD.core {
+	
+	import flash.display.DisplayObject;
+	
+	[Bindable]
+	public class TectonReceptor {
+		
+		public var tectons:Array;
+		
+		public var tecton:Tecton;
+		
+		public var eventType:String;
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/TectonScope.as

@@ -0,0 +1,38 @@
+
+package com.fourD.core {
+	import com.asfusion.mate.core.IEventMap;
+	
+	import flash.display.DisplayObjectContainer;
+	import flash.events.Event;
+	
+	/**
+	 * <code>MessageScope</code> is an object created by the <code>MessageHandlers</code>.
+	 * <p>It represents the running scope of a <code>IActionList</code>. 
+	 * The <code>IActionList</code> and its actions share this object to transfer data
+	 * between them.</p>
+	 */
+	public class TectonScope extends Scope
+	{
+		public var tecton:Tecton;
+		
+		public var tropon:DisplayObjectContainer;
+		
+		public var kanon:DisplayObjectContainer;
+		
+		public var action:String;
+		
+		public var presenter:*;
+		
+		/*-----------------------------------------------------------------------------------------------------------
+		*                                          Constructor
+		-------------------------------------------------------------------------------------------------------------*/	
+		/**
+		 * Constructor
+		 */
+		public function TectonScope(event:Event, active:Boolean, map:IEventMap, inheritScope:IScope = null)
+		{
+			super(event, active, map, inheritScope);
+		}
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/TectonScopeProperties.as

@@ -0,0 +1,18 @@
+package com.fourD.core
+{
+	public final class TectonScopeProperties
+	{
+		
+		public static const PRESENTER:String = "presenter";
+		
+		public static const TROPON:String = "tropon";
+		
+		public static const KANON:String = "kanon";
+		
+		
+		public function TectonScopeProperties()
+		{
+		}
+
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/core/TectonUtils.as

@@ -0,0 +1,51 @@
+package com.fourD.core
+{
+	import mx.utils.ObjectUtil;
+	import flash.utils.getDefinitionByName;
+	import flash.utils.getQualifiedClassName;
+	
+	public class TectonUtils
+	{
+		public function TectonUtils()
+		{
+		}
+		
+		public static function clone(object:Object):Object {
+			if (object is Tecton) {
+				var fqn:String = getQualifiedClassName(object);
+				var clazz:Class = getDefinitionByName(fqn) as Class;
+				var cloned:Object = new clazz;
+				cloned["tropon"] = object["tropon"];
+				cloned["actions"] = object["actions"];
+				cloned["actionParams"] = object["actionParams"];
+				cloned["kanon"] = object["kanon"];
+				cloned["tropons"] = object["tropons"];
+				cloned["name"] = object["name"];
+				cloned["actionName"] = object["actionName"];
+				cloned["conditions"] = object["conditions"];
+				cloned["receptors"] = object["receptors"];
+				cloned["initialize"] = object["initialize"];
+				cloned["start"] = object["start"];
+				cloned["complete"] = object["complete"];
+				cloned["isInitialized"] = object["isInitialized"];
+				cloned["isRunning"] = object["isRunning"];
+				cloned["isComplete"] = object["isComplete"];
+				cloned["isActive"] = object["isActive"];
+			/*	for each (var node:XML in describeType(object)..accessor) {
+					if (!isInvalidPropertyName(node.@name) && !RxUtils.isIgnored(node)) {
+						try {
+							var name:String = node.@name;
+							cloned[name] = object[name];
+						} catch (e:Error) {
+							// we can fail cloning if the property is read-only, etc.
+						}
+					}
+				}	*/
+				return cloned;
+			} else {
+				return ObjectUtil.copy(object);
+			}
+		}
+
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/events/LayoutActionEvent.as

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2008 (c) Lance Pollard
+ * www.systemsofseven.com/blog
+ * www.4ddesignlab.com
+ * LanceJPollard@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.fourD.events {
+
+	import flash.events.*;
+		
+	public class LayoutActionEvent extends Event {
+		
+		/** Lifecycle for a LayoutActionEvent
+		 * First layoutStart is dispatched, causing the items to be layed out first, called by
+		 * updateDisplayList.  Then layoutEnd invokes introStart (so you can do custom flows in and such).
+		 * Once the introCompletes, ambientStart is dispatched, invoking enterframe handlers
+		 * or whatever you have configured to run during the application life.  When you click an item,
+		 * you endAmbiend, and the ambientEnd dispatches itemSelectedStart.  And on and on.
+		 */
+		public static const LAYOUT_START:String = "layoutStartTweenActionEvent";
+		public static const LAYOUT_COMPLETE:String = "layoutCompleteTweenActionEvent";
+		
+		public static const INTRO_START:String = "introStartTweenActionEvent";
+		public static const INTRO_END:String = "introEndTweenActionEvent";
+		public static const INTRO_COMPLETE:String = "introCompleteTweenActionEvent";
+		
+		public static const AMBIENT_START:String = "ambientStartTweenActionEvent";
+		public static const AMBIENT_END:String = "ambiendEndTweenActionEvent";
+		public static const AMBIENT_COMPLETE:String = "ambientCompleteTweenActionEvent";
+		
+		public static const ITEM_SELECTED_START:String = "itemSelectedStartTweenActionEvent";
+		public static const ITEM_SELECTED_END:String = "itemSelectedEndTweenActionEvent";
+		public static const ITEM_SELECTED_COMPLETE:String = "itemSelectedCompleteTweenActionEvent";
+		
+		public static const ITEM_DESELECTED_START:String = "itemDeselectedStartTweenActionEvent";
+		public static const ITEM_DESELECTED_END:String = "itemDeselectedEndTweenActionEvent";
+		public static const ITEM_DESELECTED_COMPLETE:String = "itemDeselectedCompleteTweenActionEvent";
+		
+		public static const OUTRO_START:String = "outroStartTweenActionEvent";
+		public static const OUTRO_END:String = "outroEndTweenActionEvent";
+		public static const OUTRO_COMPLETE:String = "outroCompleteTweenActionEvent";
+		
+		public function LayoutActionEvent(type:String, bubbles:Boolean = false)
+	    {
+	        super(type, bubbles);
+	    }
+	
+		override public function clone():Event
+	    {
+	        return new LayoutActionEvent(type, bubbles);
+	    }
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/layouts/CarouselLayout.as

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2008 (c) Lance Pollard
+ * www.systemsofseven.com/blog
+ * www.4ddesignlab.com
+ * LanceJPollard@gmail.com
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package com.fourD.layouts
+{
+	import com.fourD.animators.TweenMaxAnimator;
+	
+	import flash.display.DisplayObject;
+	
+	import mx.core.ILayoutElement;
+	import mx.core.UIComponent;
+	
+	public class CarouselLayout extends FourDLayout {
+		
+		[Bindable] public var spiralAmount:Number = 0;
+		[Bindable] public var speed:Number = 1/300;
+		[Bindable] public var radius:Number;
+		[Bindable] public var anglePer:Number;
+		
+		public function CarouselLayout() {
+			super();
+		}
+		
+		override public function initializeLayoutEquation():void {
+			if (animator) {
+				(animator as TweenMaxAnimator).layoutAlign = "alignStart";
+			}
+			numOfItems = target.numLayoutElements;
+			preferredLayoutElementWidth = 120;
+			preferredLayoutElementHeight = 120;			
+			selectedChild = target.getLayoutElementAt(selectedIndex) as DisplayObject;
+			if (!radius) {
+				radius = target.width/2 + 100;
+			}
+			if (!anglePer) {
+				anglePer = (Math.PI * 2) / numOfItems;
+			}
+		}
+		
+		override public function getLayoutElementToken(layoutElement:ILayoutElement, index:int):Object {
+			var token:Object = new Object();
+			
+			// must do this to set the element width and height before anything else
+			setLayoutElementWidth(layoutElement, preferredLayoutElementWidth, token, target.width);			
+			setLayoutElementHeight(layoutElement, preferredLayoutElementHeight, token, target.height);
+			
+			(layoutElement as UIComponent).includeInLayout = false;
+               	
+            // then this is the equation for each item
+			token.x = Math.sin((index-selectedIndex) * anglePer) * radius;
+			token.z = -(Math.cos((index-selectedIndex) * anglePer) * radius);
+			var rot:Number = (-(index-selectedIndex) * anglePer) * (180 / Math.PI);
+			token.rotationY = rot;
+			token.x = token.x + target.width/2;
+			token.y = target.height/2 - token.height/2 + (index * spiralAmount);
+			
+			return token;
+		}
+	}
+}