emergent-core 0.1.0

data/rails_generators/emergent_config/templates/app/flex/com/fourD/animators/TweenMaxAnimator.as

@@ -0,0 +1,269 @@
+/*
+ * 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.animators
+{
+	
+	import flash.display.DisplayObject;
+	import flash.events.TimerEvent;
+	import flash.utils.Timer;
+	
+	import gs.*;
+	import gs.events.TweenEvent;
+	
+	import mx.core.IUIComponent;
+	import mx.core.UIComponent;
+	
+	/**
+	 * An animator class which uses the Tweener library. This is the default animator provided by OpenFlux. 
+	 */
+	public class TweenMaxAnimator implements IAnimator
+	{
+		
+		protected var component:DisplayObject;
+		
+		private var tweens:Array;
+		private var tweenParams:Array;
+		private var item:DisplayObject;
+		
+		public var side:String = "front";
+
+		private var _groupTween:TweenGroup;
+		private var _singleTween:TweenMax;
+		private var _isTweening:Boolean;
+		
+		public var itemAlign:String;
+		public var layoutAlign:String;
+		
+		/**
+		 * The duration of time used to animate a component.
+		 */
+		public var time:Number = 1;
+		
+		public function TweenMaxAnimator() {
+			_groupTween = new TweenGroup();
+		//	Tweener.registerSpecialProperty("actualWidth", getActualWidth, setActualWidth);
+		//	Tweener.registerSpecialProperty("actualHeight", getActualHeight, setActualHeight);
+		}
+		
+		public function tween(tweens:Array, tweenParams:Array=null, target:Object=null):void {
+			this.tweens = tweens;
+			this.tweenParams = tweenParams;
+			if (target) {
+				item = target as DisplayObject;
+			}
+			
+//			if (item.alpha == 0) {
+//				var ui:IUIComponent = item as IUIComponent;
+//				ui.setActualSize(item.width, item.height);
+//				ui.move(token.x, token.y);
+//				tweenParams.alpha = 1;
+//			}
+			
+			prepareTweenGarbageCollector();
+			trace("tween");
+			if (tweenParams) {
+				trace("tweenParams exist");
+				if (!setOppositeTween) {
+					trace("about to set oppositeTween var");
+					for (var i:int=0; i < tweenParams.length; i++) {
+						if (tweenParams[i].flipTo) {
+							trace('tweenparam flipTo');
+							tweenFlip();
+						} else {
+							createTween(tweens);
+						}
+					}
+				} else {
+					if (toTween && fromTween) {
+						trace("tweento and tweenFrom SEEEEEEEEEEEET");
+						tweenFlip();
+					} else {
+						createTween(tweens);
+					}
+				}
+			} else {
+				createTween(tweens);
+			}
+			
+			
+			// you must put them in backward!!! it took me forever to figure this out!
+			// createTween(_tweenFrom);
+			// createTween(_tweenTo);
+			
+			loadingTweens = true;
+		}
+
+		private var loadingTweens:Boolean = false;
+		private var isTweening:Boolean = false;
+
+		public function createTween(tweenArray:Array):void {
+			trace("create tween");
+			var tg:TweenGroup;
+			if (layoutAlign) {
+			if (layoutAlign == TweenGroup.ALIGN_START) {
+				trace("layoutAligne = start");
+				tg = new TweenGroup();
+				tg.align = TweenGroup.ALIGN_SEQUENCE;
+			} else {
+				_groupTween.align = layoutAlign;
+			}
+			} else {
+				_groupTween.align = TweenGroup.ALIGN_SEQUENCE;
+			}
+			for (var i:int=0; i < tweenArray.length; i++) {
+				var tween:TweenMax;
+				if (tweenArray[i].duration == null) {
+					tween = TweenMax.to(item, 1, tweenArray[i]);
+				} else {
+					tween = TweenMax.to(item, tweenArray[i].duration, tweenArray[i]);
+				}
+				if (layoutAlign == TweenGroup.ALIGN_START) {
+					tg.push(tween);
+				} else {
+					trace("last last group");
+					_groupTween.push(tween);
+				}
+			}
+		}
+
+		private var tweenDirection:String = "to";
+
+		public function tweenFlip():void{
+			trace("TWEEN FLIP, direction = " + tweenDirection);
+			switch(tweenDirection){
+				case "to":
+				tweenDirection = "from";
+				
+				if (setOppositeTween) {
+					tweens = [toTween];
+				}
+					createTween(tweens);
+				break;
+
+				case "from":
+				tweenDirection = "to";
+				tweens = [fromTween]
+				createTween(tweens);
+				break;
+			}	
+		}
+
+		public function prepareTweenGarbageCollector():void {
+			if (isTweening) {
+				_groupTween.clear();
+				isTweening = false;
+			}
+			if (!loadingTweens) {
+				trace("loading tweens");
+				var tweenLoadingTimer:Timer = new Timer(100, 1);  
+            	tweenLoadingTimer.addEventListener(TimerEvent.TIMER, prepareToKillTweens);  
+           		tweenLoadingTimer.start(); 
+			} else {
+				return;
+			}
+		}
+
+		private function prepareToKillTweens(event:TimerEvent):void {
+			//_groupTween[_groupTween.length - 1].addEventListener(TweenEvent.COMPLETE, onTweenGroupComplete);
+			isTweening = true;
+			_groupTween.onComplete = onTweenGroupComplete;
+			loadingTweens = false;
+		}
+
+		private function onTweenGroupComplete(event:TweenEvent=null):void {
+			_groupTween.clear();
+			isTweening = false;
+		}
+		
+		private var toTween:Object;
+		private var fromTween:Object;
+		private var setOppositeTween:Boolean = false;
+		
+		public function onTweenStart(params:Object):void {
+			executeParams(params);
+		}
+		
+		public function onTweenComplete(params:Object=null):void {
+			executeParams(params);
+		}
+		
+		/** This is where you define what can be found in that params object */
+		public function executeParams(params:Object=null):void {
+			
+			if (params.flipTo) {
+				if (!setOppositeTween) {
+					toTween = params.tween;
+					fromTween = params.flipTo;
+					setOppositeTween = true;
+				}
+			}
+			if (params.state && params.view) {
+				params.view.currentState = params.state;
+			}
+			
+			// But now how do you break the cycle, and get back to it?
+			// Say, for example, clicking a plane flips it to back, clicking again to the front
+			// Then you run an animation.  This destroys the flipping and creates another
+			// But then you want to flip the plane by just clicking...
+			// To do this, just have an onClick method setting up the params!
+			
+			// add other things here as you see fit.
+		}
+		
+		public function addItem(item:DisplayObject):void {
+			item.alpha = 0;
+		}
+		
+/*		public function removeItem(item:DisplayObject, callback:Function):void
+		{
+			var token:Object = new Object();
+			token.time = 1/4; */
+			/*
+			token.x = item.x + item.width/2;
+			token.y = item.y + item.height/2;
+			token.width = 100;
+			token.height = 100;
+			*/
+/*			token.alpha = 0;
+			token.onComplete = callback;
+			token.onCompleteParams = [item];
+			Tweener.addTween(item, token);
+		} */
+		
+		private function getActualWidth(item:IUIComponent, parameters:Array, ...args):Number { return item.width; }
+		private function setActualWidth(item:UIComponent, value:Number, parameters:Array, ...args):void {
+			item.setActualSize(value, item.height);
+		}
+		
+		private function getActualHeight(item:IUIComponent, parameters:Array, ...args):Number { return item.height; }
+		private function setActualHeight(item:IUIComponent, value:Number, parameters:Array, ...args):void {
+			item.setActualSize(item.width, value);
+		}
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/cameras/AstroCamera.as

@@ -0,0 +1,177 @@
+/*
+ * 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.cameras
+{
+	
+	import com.fourD.animators.IAnimator;
+	
+	import flash.geom.Matrix3D;
+	
+	import gs.events.TweenEvent;
+	
+	import mx.core.UIComponent;
+
+	/**
+	 * 
+	 * @author Lance Pollard - lancejpollard@gmail.com
+	 */
+	public class AstroCamera extends UIComponent {
+		
+		public var isTween:Boolean=false;
+		public var isZSortingWhenTween:Boolean=false;
+		
+		/**
+		 *	Now you can tween the entire MainView as a UIComponent!
+		 *	This UIComponent is the "sceneContainer"
+		 */
+		public function AstroCamera() {
+			// <Camera scene="mainView.canvas" children="{[every, child, you, need]}"
+			// for numChildren of scene, these are all the children (to make sure)
+		}
+		
+		/** 
+		 *	This should be the MainView...
+		 *	Application.mainView.scene
+		 *	Or in other words: Canvas(container(scene))
+		 *	Then any object in your mainView can be acted on by the Camera3D
+		 */
+		private var _scene:UIComponent
+		
+		[Bindable]
+		public function set scene(value:UIComponent):void {
+			_scene = value;
+			if(!_scene.transform.matrix3D){
+				_scene.z = -1;
+				_scene.z = 0;
+			}
+			
+			zSort();
+		}
+		
+		public function get scene():UIComponent {
+			return _scene;
+		}
+		
+		private var _animator:IAnimator; [Bindable]
+		public function get animator():IAnimator { return _animator; }
+		public function set animator(value:IAnimator):void {
+			_animator = value;
+		}
+		
+		private var _zSortDuringTween:Boolean;
+			
+		public function set zSortDuringTween(value:Boolean):void {
+			_zSortDuringTween = value;
+		}
+		
+		public function get zSortDuringTween():Boolean {
+			return _zSortDuringTween;
+		}
+				
+		public function zSort():void {
+			var childs:Array = new Array();
+			var i:uint;
+			
+			for(i=0; i < _scene.numChildren; i++) {
+				childs.push(_scene.getChildAt(i));
+			}
+			
+			var child:UIComponent;
+			var matrix:Matrix3D;
+			var childsAndZ:Array = new Array();
+			
+			for(i=0; i < childs.length; i++) {
+				child = childs[i];
+				if(!child.transform.matrix3D) { continue; }
+				
+				matrix = child.transform.matrix3D.clone();
+				matrix.append(_scene.transform.matrix3D);
+				
+				childsAndZ.push({z:matrix.position.z, child:child});
+				_scene.removeChild(child);
+				
+			}
+			childsAndZ.sortOn('z', Array.NUMERIC);
+			childsAndZ.reverse();
+			
+			for(i=0; i < childsAndZ.length; i++) {
+				child = childsAndZ[i].child;
+				(scene as UIComponent).addChild(child);
+			}
+		}
+		
+		private var _lookAtTweens:Array;
+		
+		public function set lookAtTweens(value:Array):void {
+			_lookAtTweens = null;
+			_lookAtTweens = new Array();
+		}
+		
+		public function get lookAtTweens():Array {
+			return _lookAtTweens;
+		}
+		
+		public function set lookAtTweenParams(value:Array):void {
+			
+		}
+		
+		public function lookAt(targetDisplay:UIComponent):void {
+//			if(targetDisplay.parent! = _scene) {
+//				throw new Error('Passed "targetDisplay" UIComponent must be child of camera scene');
+//			}
+
+			_scene.transform.matrix3D.interpolateTo(targetDisplay.transform.matrix3D, 1);
+			_scene.transform.matrix3D.invert();
+			
+			zSort();
+			
+			if(!lookAtTweens) {
+				
+				animator.tween([{x:_scene.x,
+											y:_scene.y,
+											z:_scene.z,
+											rotationX:_scene.rotationX,
+											rotationY:_scene.rotationY,
+											rotationZ:_scene.rotationZ,
+											onUpdate:setZSorting}], null, _scene);
+				
+			} else {
+				lookAtTweens.onUpdate = setZSorting;
+				//anim.createTween(_scene, lookAtTweens);
+			}
+		}
+		
+		protected function setZSorting(event:TweenEvent):void {
+			if(zSortDuringTween) {
+				zSort();
+			}
+		}
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/components/FourDDataGrid.mxml

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<view:FourDItem xmlns:view="com.themorphicgroup.view.*" xmlns:local="*"
+	width="200" height="300" xmlns:ns="http://ns.adobe.com/mxml/2009">
+	<ns:Script>
+		<![CDATA[
+//			import com.themorphicgroup.vo.PhotoVO;
+			public var clickFunction:Function;
+			import gs.TweenMax;
+			
+//			[Bindable]private var photo:PhotoVO;
+			[Bindable]
+			private var photo:Object = new Object();
+			photo.photoTitle = "LANCE";
+			
+			override public function set data(value:Object):void {
+				super.data = value;
+//				if (value is PhotoVO) {
+//					photo = PhotoVO(value);
+//				}
+			}
+			
+			private function rollOver(event:MouseEvent):void {
+				TweenMax.to(event.target, 1, {rotationX:-50});
+				TweenMax.to(event.target, 2, {delay:1, rotationX:0});
+			}
+
+		]]>
+	</ns:Script>
+	<view:front>
+	<ns:Group id="group" width="200" height="300">
+		<view:FourDItem id="column" width="{group.width/2}" pivotX="center" pivotY="center">
+			<view:front>
+				<ns:Group>
+					<ns:layout>
+						<ns:VerticalLayout/>
+					</ns:layout>
+					<view:FourDItem id="row" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row2" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row3" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row4" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row5" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+				</ns:Group>
+			</view:front>
+		</view:FourDItem>
+		<view:FourDItem x="{group.width/2}" width="{group.width/2}" id="column2" pivotX="center" pivotY="center">
+			<view:front>
+				<ns:Group>
+					<ns:layout>
+						<ns:VerticalLayout/>
+					</ns:layout>
+					<view:FourDItem id="row6" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row7" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row8" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row9" pivotX="center" pivotY="bottom">
+						<view:front>
+							<ns:Button rollOver="rollOver(event)" label="{photo.photoTitle}" width="100" height="{group.height/5}"/>
+						</view:front>
+					</view:FourDItem>
+					<view:FourDItem id="row10" pivotX="center" pivotY="bottom">
+						<view:front>
+								<ns:Image source="Photo 5.jpg" width="200" height="{group.width/5}"/>
+						</view:front>
+					</view:FourDItem>
+				</ns:Group>
+			</view:front>
+		</view:FourDItem>
+	</ns:Group>
+	</view:front>
+	<view:pivotX>center</view:pivotX>
+	<view:pivotY>center</view:pivotY>
+	
+	
+</view:FourDItem>

data/rails_generators/emergent_config/templates/app/flex/com/fourD/components/FourDItemRenderer.mxml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="utf-8"?>
+<view:FourDItem xmlns:view="com.themorphicgroup.view.*" xmlns:local="*"
+	width="100" height="100" xmlns:ns="http://ns.adobe.com/mxml/2009"
+	tweens="{[{rotationY:720, rotationZ:100}]}">
+	<ns:Script>
+		<![CDATA[
+//			import com.themorphicgroup.vo.PhotoVO;
+			public var clickFunction:Function;
+			import gs.TweenMax;
+			
+//			[Bindable]private var photo:PhotoVO;
+			[Bindable]
+			private var photo:Object = new Object();
+			photo.photoTitle = "LANCE POLLARD";
+			
+			override public function set data(value:Object):void {
+				super.data = value;
+//				if (value is PhotoVO) {
+//					photo = PhotoVO(value);
+//				}
+			}
+			
+
+			protected function canvas1_mouseOverHandler(event:MouseEvent):void
+			{
+				this.setStyle("backgroundColor",0xfff55d);
+//				TweenMax.to(this, 1, {rotationX:180});
+			}
+			
+			private function click():void {
+				//TweenMax.to(this.parent, 4, {rotationY:360});
+				this.tween();
+			}
+
+
+			protected function canvas1_mouseOutHandler(event:MouseEvent):void
+			{
+				this.setStyle("backgroundColor",0xf8f8f8);
+			}
+
+		]]>
+	</ns:Script>
+	<view:front>
+	<ns:Canvas width="200" height="300">
+		<ns:Button rollOver="canvas1_mouseOverHandler(event)" click="click()" id="but" width="200" height="300"/>
+		<ns:Label text="{photo.photoTitle}" horizontalCenter="0" verticalCenter="0"/>
+		<local:RevealBox width="{but.width}" height="{but.height}"/>
+	</ns:Canvas>
+	</view:front>
+	<view:pivotX>center</view:pivotX>
+	<view:pivotY>center</view:pivotY>
+	
+	
+</view:FourDItem>

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

@@ -0,0 +1,72 @@
+/*
+ * 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.core
+{
+	
+	import flash.display.DisplayObject;
+	import flash.events.Event;
+	import flash.geom.PerspectiveProjection;
+	import flash.geom.Point;	
+
+	public class CenterPerspectiveProjection extends EventDispatcher {
+		
+		private var root:DisplayObject;
+
+		public function CenterPerspectiveProjection(root:DisplayObject) {
+			this.root = root;
+		}
+		
+		protected function updateStageAlign():void {
+			var pp:PerspectiveProjection = root.transform.perspectiveProjection;
+			pp.projectionCenter = new Point(root.stage.stageWidth/2, root.stage.stageHeight/2);
+			root.transform.perspectiveProjection = pp;
+		}
+		
+		static public function setCenterOn(root:DisplayObject):void {
+			if(!root.transform.perspectiveProjection){
+				throw new Error('Passed root object must have perspectiveProjection (root.transform.perspectiveProjection)');
+			}
+			
+			updateStageAlign();
+		}
+		
+		static public function updateOnResize():void {
+			updateStageAlign();
+			root.stage.addEventListener(Event.RESIZE, onStageResize);
+		}
+		
+		static public function disableUpdateOnResize():void {
+			root.stage.removeEventListener(Event.RESIZE, onStageResize);
+		}
+		
+		protected function onStageResize(event:Event):void {
+			updateStageAlign();
+		}
+	}
+}