emergent-core 0.1.0

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

@@ -0,0 +1,102 @@
+/*
+ * 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 flash.geom.Point;
+	
+	import mx.components.baseClasses.GroupBase;
+	import mx.core.ILayoutElement;
+	import mx.core.IUIComponent;
+	import mx.layout.LayoutBase;
+
+	public class CircleLayout extends LayoutBase
+	{
+		public function CircleLayout() {
+			super();
+		}
+		
+		public var rotate:Boolean = true;
+		
+		public function findIndexAt(children:Array, x:Number, y:Number):int {
+			var hCenter:Number = target.width / 2;
+			var vCenter:Number = target.height / 2;
+			var angle:Number = Math.atan2(y-vCenter, x-hCenter) + Math.PI;
+			var index:Number = angle * children.length / (2 * Math.PI) + 1;
+			
+			return index;
+		}
+		
+		override public function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
+   		{
+        	super.updateDisplayList(unscaledWidth, unscaledHeight);
+			var layoutTarget:GroupBase = target;
+    		var layoutElement:ILayoutElement;
+        	var numOfItems:int = layoutTarget.numLayoutElements;
+        	
+			var radius:Number = target.width - 10;
+			var anglePer:Number = (Math.PI * 2) / numOfItems;
+			
+			var width:Number = target.width/2;
+			var height:Number = target.height/2;
+			var offset:Number = 180*(Math.PI/180);
+			var rad:Number;
+			
+			var token:Object;
+
+			for(var i:uint=0; i<numOfItems; i++) {
+				
+            	layoutElement = layoutTarget.getLayoutElementAt(i);
+				token = new Object();
+				token.width = layoutElement.getPreferredBoundsWidth();
+				token.height = layoutElement.getPreferredBoundsHeight();
+					
+				var w:Number = width-layoutElement.getPreferredBoundsWidth();
+				var h:Number = height-layoutElement.getPreferredBoundsHeight();
+				
+
+					rad = ((Math.PI*i)/(numOfItems/2))+offset;
+				token.x = (w*Math.cos(rad))+w;
+				token.y = (h*Math.sin(rad))+h;
+				
+				if(rotate) {
+					token.rotationY = ((360/length)*i);
+					while(token.rotationY > 180) {
+						token.rotationY -= 360;
+					}
+				}
+				animator.moveItem(layoutElement as DisplayObject, token);
+			}
+			//animator.end();
+		}
+		
+	}
+}

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

@@ -0,0 +1,136 @@
+/*
+ * 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 mx.core.ILayoutElement;
+	import mx.core.UIComponent;
+
+	public class CoverFlowLayout extends FourDLayout
+	{	
+		public function CoverFlowLayout()
+		{
+			super();
+		}
+		
+		private var _angle:Number = 70; [Bindable]
+		public function get angle():Number { return _angle; }
+		public function set angle(value:Number):void {
+			_angle = value;
+			if (target) target.invalidateDisplayList();
+		}
+		
+		private var _gap:Number = 0;
+		[Bindable]
+		public function get gap():Number { return _gap; }
+		public function set gap(value:Number):void {
+			_gap = value;
+			if (target) target.invalidateDisplayList();
+		}
+		
+		private var _distance:Number = 10;
+		[Bindable]
+		public function get distance():Number { return _distance; }
+		public function set distance(value:Number):void {
+			_distance = value;
+			if (target) target.invalidateDisplayList();
+		}
+		
+		private var _direction:String = "horizontal"; [Bindable]
+		[Inspectable(defaultValue="horizontal", enumeration="horizontal,vertical,null")]	
+		public function get direction():String { return _direction; }
+		public function set direction(value:String):void {
+			_direction = value;
+			if (target) target.invalidateDisplayList();
+		}
+		
+		private var init:Boolean = false;
+		
+		protected var maxChildHeight:Number;
+		protected var maxChildWidth:Number;
+		protected var abs:Number;
+		protected var offset:Number=0;
+		
+		[Bindable] public var radius:Number;
+		[Bindable] public var anglePer:Number;
+		
+		override public function initializeLayoutEquation():void {
+			selectedChild = target.getLayoutElementAt(selectedIndex) as UIComponent;
+			maxChildHeight = Number((selectedChild as ILayoutElement).getPreferredBoundsWidth());
+			maxChildWidth = Number((selectedChild as ILayoutElement).getPreferredBoundsHeight());
+			if (!gap) {
+				if (direction == "horizontal") {
+					gap = maxChildHeight / 3;
+				}
+			}
+			if (!radius) {
+				radius = target.width/2;
+			}
+			if (!anglePer) {
+				anglePer = (Math.PI * 2) / numOfItems;
+			}
+			preferredLayoutElementWidth = 120;
+			preferredLayoutElementHeight = 120;
+		}
+		
+		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);
+               	
+            // then this is the equation for each item
+			abs = Math.abs(selectedIndex - index);
+			offset += token.width;
+			token.x = (selectedChild as ILayoutElement).getPreferredBoundsWidth() + ((abs - 1) * gap)// + offset;
+			if (_gap > 0) token.x += (abs - 1) * (_gap + token.width);
+			token.y = -(maxChildHeight - layoutElement.getPreferredBoundsHeight()) / 2;
+			token.z = (selectedChild as ILayoutElement).getPreferredBoundsWidth() + abs * 5;
+			
+			(layoutElement as UIComponent).includeInLayout = false;
+			
+			token.rotationY = angle;
+			if(index < selectedIndex) {
+				token.x = -token.x + token.width/2;
+				token.rotationY *= -1;
+			} else if(index == selectedIndex) {
+				token.x = 0;
+				token.z = -200 / 2;
+				token.rotationY = 0;
+				offset = 0;
+			}
+				
+			token.x = token.x + target.width/2 - token.width/2;
+			token.y = (token.y*-1) + target.height/2 - token.height/2;
+			
+			return token;
+		}
+		
+	}
+}

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

@@ -0,0 +1,272 @@
+/*
+ * 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.actions.LayoutAction;
+	import com.fourD.actions.SimpleLayoutAction;
+	import com.fourD.animators.IAnimator;
+	import com.fourD.animators.TweenMaxAnimator;
+	import com.fourD.core.FourDComponent;
+	import com.fourD.core.SimpleZSorter;
+	
+	import flash.display.DisplayObject;
+	import flash.events.MouseEvent;
+	import flash.events.TimerEvent;
+	import flash.geom.Point;
+	import flash.utils.Timer;
+	
+	import mx.components.DataGroup;
+	import mx.components.Group;
+	import mx.components.ResizeMode;
+	import mx.components.baseClasses.GroupBase;
+	import mx.core.ILayoutElement;
+	import mx.core.IVisualElement;
+	import mx.core.UIComponent;
+	import mx.core.mx_internal;
+	import mx.events.FlexEvent;
+	import mx.events.IndexChangedEvent;
+	import mx.events.ItemExistenceChangedEvent;
+	import mx.layout.LayoutBase;
+	import mx.layout.LayoutElementHelper;
+	use namespace mx_internal;
+	
+	public class FourDLayout extends LayoutBase
+	{
+		// Commonly used variables in layout algorithms:
+		public var selectedIndex:int;
+		public var selectedChild:DisplayObject;
+		protected var currentIndex:int; // like a "proposed" index
+		protected var numOfItems:int;
+		
+		[Inspectable(defaultValue="true", enumeration="true,false")]
+		[Bindable] public var zSort:Boolean = true;
+		private var zSortStartTimer:Timer;
+				
+		[Bindable] public var hitAreaX1:Number;
+		[Bindable] public var hitAreaX2:Number;
+		private var elementToGlobalPoint:Point;
+		
+		[Bindable] public var preferredLayoutElementWidth:Number;
+		[Bindable] public var preferredLayoutElementHeight:Number;
+
+		[Inspectable(defaultValue="false", enumeration="true,false")]
+		[Bindable] public var selectedIndexHitTest:Boolean;
+		
+		// hack to establish the actions slightly after onCreationComplete...
+		private var actionInstantiator:Timer;
+				
+		private var _action:LayoutAction; [Bindable]
+		public function get action():LayoutAction { return _action; }
+		public function set action(value:LayoutAction):void {
+			_action = value;
+		}
+		
+		// must do this because you can't easily access the containerBases parent container
+		// in the default case, it is group.parent.parent.parent.parent, but that may change with skinning
+		override public function set target(value:GroupBase):void {
+			super.target = value;
+			target.resizeMode = ResizeMode.SCALE;
+			attachHandlers();
+		}
+		
+		private var _animator:IAnimator; [Bindable]
+		public function get animator():IAnimator { return _animator; }
+		public function set animator(value:IAnimator):void {
+			_animator = value;
+		}
+		
+		// VERY IMPORTANT: Any rotation of the whole layout must be done using
+		// "container", not "target" (group).  This is because the FourDComponent
+		// gives you much more freedom in setting pivot points and tweens
+		private var _container:FourDComponent; [Bindable]
+		public function get container():FourDComponent { return _container; }
+		public function set container(value:FourDComponent):void {
+			_container = value;
+			// increases frame rate because includeInLayout calls invalidateProperties();
+			_container.includeInLayout = false;
+			if (_container.initialized == true)
+            {
+                onCreationComplete(new FlexEvent(""));
+            }
+            else
+            {
+                _container.addEventListener(FlexEvent.CREATION_COMPLETE, onCreationComplete);      
+            }
+		}
+		
+		public function FourDLayout() {
+			if (animator == null) {
+				animator = new TweenMaxAnimator();
+			}
+			if (action == null) {
+				action = new SimpleLayoutAction();
+			}
+		}
+		
+		/** Handler Functions for Group and containerItem (Layout and LayoutItem)
+		 * 	Override these handlers in the subclasses if you would like! */
+		protected function attachHandlers():void {
+			target.addEventListener(IndexChangedEvent.CHILD_INDEX_CHANGE, groupHandler);
+			target.addEventListener(ItemExistenceChangedEvent.ITEM_ADD, groupHandler);
+			target.addEventListener(ItemExistenceChangedEvent.ITEM_REMOVE, groupHandler);
+		}
+		
+		protected function onCreationComplete(event:FlexEvent):void {
+			actionInstantiator = new Timer(1000, 0);
+			actionInstantiator.addEventListener(TimerEvent.TIMER, instantiateAction);
+			actionInstantiator.start();
+		}
+		
+		private function instantiateAction(event:TimerEvent):void {
+			actionInstantiator.stop();
+			actionInstantiator = null;
+			action.layout = this;
+			action.container = container;
+			action.target = target;
+			action.animator = animator;
+			
+			if (action.usedActions == null) {
+				action.usedActions = [action.INTRO,
+										action.AMBIENT,
+										action.ITEM_SELECTED,
+										action.ITEM_DESELECTED];	
+			}
+			
+			action.layoutStart();
+			
+			if (zSort && container.visible) {
+				zSortStartTimer = new Timer(500, 0);
+				zSortStartTimer.start();
+				zSortStartTimer.addEventListener(TimerEvent.TIMER, zSortStart);
+			}
+		}
+		
+		private function zSortStart(event:TimerEvent):void {
+			zSortStartTimer.stop();
+			zSortStartTimer = null;
+			container.addEventListener(Event.ENTER_FRAME, zSortGroup);
+		}
+		
+		private function zSortGroup(event:Event):void {
+			SimpleZSorter.sortClips(target);
+		}
+		
+		protected function groupHandler(event:*):void {
+			var item:DisplayObject;
+			if (event.type == ItemExistenceChangedEvent.ITEM_ADD) {
+				if (target is DataGroup) {
+					item = event.renderer;
+				} else if (target is Group) {
+					item = event.relatedObject;
+				}
+				item.addEventListener(MouseEvent.CLICK, itemClickHandler);
+			}
+		}
+		
+		protected function itemClickHandler(event:MouseEvent):void {
+			var layoutElement:DisplayObject = event.target as DisplayObject;
+			if (target is DataGroup) {
+	        	selectedIndex = (target as DataGroup).mx_internal::getItemIndexForRenderer(event.currentTarget as IVisualElement);
+			} else if (target is Group) {
+				selectedIndex = (target as Group).getElementIndex(event.currentTarget as IVisualElement);
+			}
+			action.itemSelected();
+		}
+		
+		// put this into an Action.update class.  LayoutAction classes!
+		public function handleSelectedIndexHitTest():void {
+			var layoutElement:DisplayObject;
+			numOfItems = target.numLayoutElements;
+			var i:int=0;
+			for (i; i < numOfItems; i++) {
+            	layoutElement = target.getLayoutElementAt(i) as UIComponent;
+				elementToGlobalPoint = layoutElement.localToGlobal(
+					new Point(layoutElement.x, layoutElement.y));
+				if (elementToGlobalPoint.x > hitAreaX1 && elementToGlobalPoint.x < hitAreaX2) {
+					selectedIndex = (target as Group).getElementIndex(layoutElement as IVisualElement);
+				}
+			}
+		}
+		
+		/** initializeLayoutEquation is where you set up your layout */
+		public function initializeLayoutEquation():void {}
+		
+		/** getLayoutElementToken is where you place the logic to place each item in the layout */
+		public function getLayoutElementToken(layoutElement:ILayoutElement, index:int):Object {
+			return new Object();
+		}
+		
+		public function calculatePercentWidth(layoutElement:ILayoutElement, width:Number):Number {
+			var percentWidth:Number = LayoutElementHelper.pinBetween(layoutElement.percentWidth * 0.01 * width,
+layoutElement.getMinBoundsWidth(),
+layoutElement.getMaxBoundsWidth());
+	    	return percentWidth < width ? percentWidth : width;
+	    }
+
+	    public function calculatePercentHeight(layoutElement:ILayoutElement, height:Number):Number {
+	    	var percentHeight:Number = LayoutElementHelper.pinBetween(layoutElement.percentHeight * 0.01 * height,
+layoutElement.getMinBoundsHeight(),
+layoutElement.getMaxBoundsHeight());
+	    	return percentHeight < height ? percentHeight : height;
+	    }
+
+	    public function hasPercentWidth(layoutElement:ILayoutElement):Boolean {
+	        return !isNaN(layoutElement.percentWidth);
+	    }
+
+	    public function hasPercentHeight(layoutElement:ILayoutElement):Boolean {
+	        return !isNaN(layoutElement.percentHeight);
+	    }
+		
+		protected function setLayoutElementWidth(layoutElement:ILayoutElement, preferredWidth:Number, token:*, unscaledWidth:Number):void {
+			if (hasPercentWidth(layoutElement)) {
+				token.width = calculatePercentWidth(layoutElement, unscaledWidth);
+			} else {
+				token.width = layoutElement.getPreferredBoundsWidth();
+			}
+			
+			if (token.width > preferredWidth) {
+				token.width = preferredWidth;
+			}
+		}
+		
+		protected function setLayoutElementHeight(layoutElement:ILayoutElement, preferredHeight:Number, token:*, unscaledHeight:Number):void {
+			if (hasPercentHeight(layoutElement)) {
+				token.height = calculatePercentHeight(layoutElement, unscaledHeight);
+			} else {
+				token.height = layoutElement.getPreferredBoundsHeight();
+			}
+			
+			if (token.height > preferredHeight) {
+				token.height = preferredHeight;
+			}
+		}
+		
+	}
+}

data/rails_generators/emergent_config/templates/app/flex/com/fourD/utils/TweenUtil.as

@@ -0,0 +1,110 @@
+/*
+ * 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.utils
+{
+		
+	import com.fourD.core.FourDComponent;
+	
+	import mx.containers.ApplicationControlBar;
+	import mx.containers.Canvas;
+	import mx.containers.Panel;
+	import mx.core.UIComponent;
+	
+	public class TweenUtil
+	{
+		
+		public static function resolveAnimationType(animationType:String, target:Object):void {
+			
+		}
+		
+		public static function resolveParams(tweens:Array, tweenParams:Array, animator:Object):Array {
+			trace("resolve tween params");
+			var tmpArray:Array = new Array();
+			for (var i:int=0; i < tweenParams.length; i++) {
+				for (var j:int=0; j < tweens.length; j++) {
+					if (tweenParams[i].tween == tweens[j]) {
+						if (tweenParams[i].when == "onComplete") {
+							tweens[j].onComplete = animator.onTweenComplete;
+							tweens[j].onCompleteParams = [tweenParams[i]]; // as Object;
+						}
+						if (tweenParams[i].when == "onStart" || undefined) {	
+							tweens[j].onStart = animator.onTweenStart;
+							//var al:Alert = Alert.show("tween: " + value[i].tween.rotationY);
+							tweens[j].onStartParams = [tweenParams[i]]//[value[i]];
+						}
+						tmpArray.push(tweenParams[i] as Object);
+					}
+				}
+			}
+			tweenParams = tmpArray;
+			return tweenParams;
+		}
+		
+		public static function validateTweenTarget(target:Object, fourDComponent:UIComponent):Boolean {
+			// Hack to get parent if the direct parent is a Skin!
+			var valid:Boolean;
+			if (fourDComponent is FourDComponent) {
+				var plane:FourDComponent = fourDComponent as FourDComponent;
+				if (target.parent != plane.front) {
+					if (target.parent == plane.back || target == plane.front || target == plane.back) {
+						valid = true;
+					}
+				}
+				if (target.parent != plane.back) {
+					if (target.parent == plane.front || target == plane.front || target == plane.back) {
+						valid = true;
+					}
+				}
+				if (target != plane.front) {
+					if (target.parent == plane.back || target.parent == plane.front || target == plane.back) {
+						valid = true;
+					}
+				}
+				if (target != plane.back) {
+					if (target.parent == plane.back || target.parent == plane.front || target == plane.front) {
+						valid = true;
+					}
+				}
+			}
+			
+			if (target is Panel || target.parent is Panel) {
+				valid = true
+			}
+			if (target is ApplicationControlBar || target.parent is ApplicationControlBar) {
+				valid = true
+			}
+			if (target is Canvas || target.parent is Canvas) {
+				valid = true
+			}
+
+			return valid;
+		}
+		
+	}
+}