mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/materia/questionStorage/QuestionGroup.as

@@ -0,0 +1,313 @@
+package materia.questionStorage
+{
+import materia.CreatorConfig;
+import materia.utils.CommonUtils;
+import mx.collections.ArrayCollection;
+import mx.controls.Alert;
+import mx.utils.ObjectUtil;
+public class QuestionGroup
+{
+	public static const TYPE_QGROUP:int = 1;
+	public static const TYPE_QSET:int = 0;
+	public static const TYPE_QUESTION:int = 2;
+	public var id:Number;
+	public var assets:Array = []; // an array of assets used by this group
+	[Bindable]
+	public var items:Array; // each kid can be a questionGroup, or a Question
+	public var name:String;
+	public var options:Object;
+	public var rand:Boolean;
+	public function QuestionGroup(name:String = "", opts:Object = null, random:Boolean = false,
+								  id:Number = 0):void
+	{
+		this.name = name
+		items = new Array();
+		this.options = opts == null? new Object() : opts;
+		this.rand = false;
+		this.id = id;
+	}
+	public static function convertToQGroup(obj:Object):QuestionGroup
+	{
+		return QuestionGroup(convertObject(obj, TYPE_QGROUP));
+	}
+	public static function convertToQSet(obj:Object):QuestionSet
+	{
+		return QuestionSet(convertObject(obj, TYPE_QSET));
+	}
+	public static function convertToQuestion(obj:Object):Question
+	{
+		return Question(convertObject(obj, TYPE_QUESTION));
+	}
+	public static function copyQuestionArray(questionsArray:Array):Array
+	{
+		var copy:Array = [];
+		for (var i:int = 0; i < questionsArray.length; i++)
+		{
+			var q:Question = questionsArray[i];
+			copy.push(q.clone());
+		}
+		return copy;
+	}
+	// can return a question or a question group (or a question set?)
+	private static function convertObject(obj:Object, type:int = -1):*
+	{
+		if (obj == null)
+		{
+			return null;
+		}
+		if (obj is Boolean)
+		{
+			return null;
+		}
+		// *HACK CODE END*
+		// check if obj is a question
+		if (obj.hasOwnProperty("questions"))
+		{
+			return Question.convertObject(obj); // early return
+		}
+		var qset:*;
+		switch (type)
+		{
+			case TYPE_QSET:
+				qset = new QuestionSet();
+				break;
+			case TYPE_QGROUP:
+			default:
+				qset = new QuestionGroup(); // defaulting to question group
+				break;
+		}
+		qset.name = obj.name;
+		var k:Array = new Array();
+		for each(var s:Object in obj.items)
+		{
+			k.push(convertObject(s));
+		}
+		qset.items = k;
+		qset.id = obj.id;
+		qset.options = CommonUtils.convertArrayToObject(obj.options); // make sure options is an object
+		qset.rand = obj.rand;
+		qset.assets = obj.assets;
+		return qset;
+	}
+	private static function isSameOptions(obj1:Object, obj2:Object):Boolean
+	{
+		var s:String;
+		for (s in obj1)
+		{
+			if (obj2[s] == undefined)
+			{
+				return false;
+			}
+			if (String(obj1[s]) != String(obj2[s]))
+			{
+				return false;
+			}
+		}
+		for (s in obj2)
+		{
+			if (obj1[s] == undefined)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+	private static function sameQuestionGroupElement(obj1:*, obj2:*):Boolean
+	{
+		if ((obj1 is QuestionGroup && obj2 is QuestionGroup) ||
+			(obj1 is QuestionSet && obj2 is QuestionSet))
+		{
+			var qg1:QuestionGroup = obj1;
+			var qg2:QuestionGroup = obj2;
+			return qg1.isSameQuestionGroup(qg2);
+		}
+		else if (obj1 is Question && obj2 is Question)
+		{
+			var q1:Question = obj1;
+			var q2:Question = obj2;
+			return q1.isSameQuestion(q2);
+		}
+		return false;
+	}
+	public function addChild(child:Object):void
+	{
+		items.push(child);
+	}
+	public function addGroup(group:QuestionGroup):void
+	{
+		addChild(group);
+	}
+	public function addOption(name:String, value:*):void
+	{
+		options[name] = value;
+	}
+	public function addQAArrayCollection(arr:ArrayCollection, questionFieldName:String,
+										 answerFieldName:String):void
+	{
+		var j:int;
+		for (var i:int = 0; i < arr.length; i++)
+		{
+			var q:Question = new Question("Question Answer");
+			if (arr[i][questionFieldName] is Array)
+			{
+				for (j = 0; j < arr[i][questionFieldName].length; j++)
+				{
+					q.addText(arr[i][questionFieldName][j]);
+				}
+			}
+			else
+			{
+				q.addText(arr[i][questionFieldName]);
+			}
+			if (arr[i][answerFieldName] is Array)
+			{
+				for (j = 0; j < arr[i][answerFieldName].length; j++)
+				{
+					q.addAnswer(arr[i][answerFieldName][j]);
+				}
+			}
+			else
+			{
+				q.addText(arr[i][answerFieldName])
+			}
+			addQuestion(q);
+		}
+	}
+	public function addQuestion(question:Question):Question
+	{
+		addChild(question)
+		return question;
+	}
+	public function clone():QuestionGroup
+	{
+		var clone:QuestionGroup = new QuestionGroup(name, options, rand, id);
+		for (var i:String in options)
+		{
+			clone.options[i] = options[i];
+		}
+		for (var j:String in items)
+		{
+			clone.items[j] = items[j].clone();
+		}
+		return clone;
+	}
+	public function convertToObject():Object
+	{
+		var o:Object = new Object();
+		o["items"] = new Array();
+		for (var i:int = 0; i < items.length; i++)
+		{
+			o["items"].push(items[i].convertToObject());
+		}
+		o["name"] = name;
+		o["options"] = CommonUtils.convertArrayToObject(options);
+		o["rand"] = rand;
+		o["assets"] = assets;
+		return ObjectUtil.copy(o); // enigma was editing the arrays inside of question sets
+		// which were references instead of copies
+	}
+	public function getChild(index:int):Object
+	{
+		return items[index];
+	}
+	public function getQuestions():Array
+	{
+		var q:Array = new Array();
+		for (var i:int = 0; i < items.length; i++)
+		{
+			if (items[i] is Question)
+			{
+				q.push(items[i]);
+			}
+			else
+			{
+				if (!(items[i] is QuestionGroup))
+				{
+					if(items[i] != null)
+					{
+						append(QuestionGroup.convertToQGroup(items[i]).getQuestions(), q);
+					}
+				}
+				else
+				{
+					append(items[i].getQuestions(), q);
+				}
+			}
+		}
+		return q;
+	}
+	/**
+	 * Retruns true if this question group represents the same game ( same questions and groupings )
+	 * 	as the other give group.
+	 *
+	 * This is used by creator manager to check if the user has made changes to a qGroup with a creator.
+	 */
+	public function isSameQuestionGroup(otherQuestionGroup:QuestionGroup):Boolean
+	{
+		if (otherQuestionGroup == null)
+		{
+			return false;
+		}
+		// they should have the same name
+		if (this.name != otherQuestionGroup.name)
+		{
+			return false;
+		}
+		// NOTE: was using object compare like this:
+		//   ObjectUtil.compare(this.options, otherQuestionGroup.options) != 0
+		// but it was having 0 != "0" ( the string)
+		// so doing it the different way
+		if (isSameOptions(this.options, otherQuestionGroup.options) == false)
+		{
+			return false;
+		}
+		if (this.rand != otherQuestionGroup.rand)
+		{
+			return false;
+		}
+		// now recursively check the items
+		if (items.length != otherQuestionGroup.items.length)
+		{
+			return false;
+		}
+		for (var i:int = 0; i < items.length; i++)
+		{
+			if (!sameQuestionGroupElement(this.items[i], otherQuestionGroup.items[i]))
+			{
+				return false;
+			}
+		}
+		return true; // it passed all of the tests, same qGroup
+	}
+	public function get length():int
+	{
+		return items.length;
+	}
+	public function removeItemAt(item:int):void
+	{
+		items.splice(item, 1);
+	}
+	private function append(items:Array, arr:Array):void
+	{
+		for (var i:int = 0; i < items.length; i++)
+		{
+			arr.push(items[i]);
+		}
+	}
+	public function toString():String
+	{
+		var str:String = "[QGroup]:'"+name+ "' " + items.length + ' items'
+		for(var i:String in options)
+		{
+			str += "\n   QG Option: '" + i + "' = '"+ options[i] + "'"
+		}
+		str+= "\n{\n"
+		for each(i in items)
+		{
+			str += " " + i.toString() + '\n'
+		}
+		str+= "\n}"
+		return str
+	}
+}
+}

data/lib/mako/data/flash_widget_dev_core/src/materia/questionStorage/QuestionSet.as

@@ -0,0 +1,21 @@
+package materia.questionStorage
+{
+	public class QuestionSet extends QuestionGroup
+	{
+		public function QuestionSet(name:String="", random:Boolean=false, id:Number=0)
+		{
+			super(name, null, random, id);
+		}
+		public override function clone():QuestionGroup{
+			var clone:QuestionSet = new QuestionSet(name, rand, id);
+			var i:String;
+			for(i in items){
+				clone.items[i] = items[i].clone();
+			}
+			for(i in options){
+				clone.options[i] = options[i];
+			}
+			return clone;
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/materia/toolTips/KogneatoToolTip.as

@@ -0,0 +1,196 @@
+package materia.toolTips
+{
+	import flash.display.Sprite;
+	import flash.filters.DropShadowFilter;
+	import flash.text.TextField;
+	import flash.text.TextFieldAutoSize;
+	import flash.text.TextFormat;
+	import mx.core.UIComponent;
+	public class KogneatoToolTip extends UIComponent
+	{
+		//Components:
+		protected var bg:Sprite;
+		protected var tf:TextField;
+		//Properties:
+		protected var _text:String;
+		//Flags:
+		protected var _bTextChanged:Boolean;
+		//Statics:
+		protected var DEFAULT_POINTER_ORIENTATION:String = "down"; //@TODO: How do I do this?
+		protected var DEFAULT_MIN_TF_WIDTH:int = 50;
+		protected var DEFAULT_MAX_TF_WIDTH:int = 300;
+		protected var DEFAULT_PTR_SIZE:int = 10;
+		protected var DEFAULT_PADDING:int = 7;
+		public function KogneatoToolTip()
+		{
+			super();
+			mouseEnabled = mouseChildren = false;
+		}
+		public function set text(val:String):void
+		{
+			_text = val;
+			_bTextChanged = true;
+			invalidateProperties();
+		}
+		public function get text():String
+		{
+			return _text;
+		}
+		protected override function createChildren():void
+		{
+			super.createChildren();
+			if(!bg)
+			{
+				bg = new Sprite();
+				addChild(bg);
+			}
+			if(!tf)
+			{
+				tf = new TextField();
+				//tf.text = 'XXXXXXXXXXXXXXXXX';
+				//tf.width = 300;
+				//tf.height = 1;
+				//tf.width = 1;
+				tf.autoSize = TextFieldAutoSize.LEFT;
+				//tf.multiline = tf.wordWrap = true;
+				//tf.setStyle('textAlign', 'center');
+				//tf.maxWidth = DEFAULT_MAX_TF_WIDTH;
+				addChild(tf);
+			}
+		}
+		protected override function commitProperties():void
+		{
+			super.commitProperties();
+			if(_bTextChanged)
+			{
+				_bTextChanged = false;
+				tf.text = _text;
+				tf.setTextFormat(new TextFormat('Verdana', 12, 0xFFFFFF, false, false, false, null, null, 'center'));
+				if(tf.width > DEFAULT_MAX_TF_WIDTH)
+				{
+					tf.width = DEFAULT_MAX_TF_WIDTH;
+					tf.multiline = tf.wordWrap = true;
+				}
+				else if(tf.width < DEFAULT_MIN_TF_WIDTH)
+				{
+					tf.autoSize = TextFieldAutoSize.NONE;
+					tf.width = DEFAULT_MIN_TF_WIDTH;
+				}
+				invalidateDisplayList();
+			}
+		}
+		/*
+		public override function get height():Number
+		{
+			return bg.height;
+		}*/
+		protected override function measure():void
+		{
+			super.measure();
+			measuredWidth = bg.width;
+			measuredHeight = bg.height;
+			measuredMinWidth = 50;
+			measuredMinHeight = 30;
+		}
+		protected override function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void
+		{
+			super.updateDisplayList(unscaledWidth, unscaledHeight);
+			var pointerOrientation:String = getStyle("pointerOrientation");
+			var padding:int = DEFAULT_PADDING;
+			var strokeWidth:int = 4;
+			var ptrOffset:int = getStyle("pointerOffset");
+			//trace('DRAWING');
+			var tw:int = padding * 2 + tf.width; //tip width
+			var th:int = padding * 2 + tf.height; //tip height
+			var twh:int = tw / 2;
+			var thh:int = th / 2;
+			var ps:int = DEFAULT_PTR_SIZE;
+			var psh:int = ps / 2;
+			var cr:int = 4; //radius
+			bg.graphics.clear();
+			bg.graphics.lineStyle(strokeWidth, 0xFFFFFF, 0.3, true);
+			//Draw bubble with pointer oriented down
+			bg.graphics.beginFill(0x232323, .95);//0xe6e2d1
+			bg.graphics.moveTo(cr, 0);
+			bg.graphics.curveTo(0, 0, 0, cr);
+			bg.graphics.lineTo(0, th - cr);
+			bg.graphics.curveTo(0, th, cr, th);
+			bg.graphics.lineTo(twh - ps + ptrOffset, th);
+			bg.graphics.lineTo(twh + ptrOffset, th + ps);
+			bg.graphics.lineTo(twh + ps + ptrOffset, th);
+			bg.graphics.lineTo(tw - cr, th);
+			bg.graphics.curveTo(tw, th, tw, th - cr);
+			bg.graphics.lineTo(tw, cr);
+			bg.graphics.curveTo(tw, 0, tw - cr, 0);
+			bg.graphics.lineTo(cr, 0);
+			if(pointerOrientation == 'up')
+			{
+				bg.scaleY = -1;
+				//@TODO @HACK SUPER SUPER HACK ATTACK
+				if(ptrOffset == 0)
+				{
+					bg.y += bg.height - strokeWidth;
+				}
+				tf.x = padding;
+				tf.y = ps + padding;
+			}
+			else //down
+			{
+				tf.x = padding;
+				tf.y = padding;
+			}
+			/*
+			switch(pointerOrientation)
+			{
+				case 'up':
+					tf.x = -twh + padding;
+					tf.y = ps + padding;
+					bg.graphics.beginFill(0xe6e2d1, .95);
+					bg.graphics.moveTo(-ps + ptrOffset, ps);
+					bg.graphics.lineTo(ptrOffset, 0);
+					bg.graphics.lineTo(ps + ptrOffset, ps);
+					bg.graphics.lineTo(twh - cr, ps);
+					bg.graphics.curveTo(twh, ps, twh, ps + cr);
+					var topY:int = ps + th;
+					bg.graphics.lineTo(twh, topY - cr);
+					bg.graphics.curveTo(twh, topY, twh - cr, topY);
+					bg.graphics.lineTo(-twh + cr, topY);
+					bg.graphics.curveTo(-twh, topY, -twh, topY - cr);
+					bg.graphics.lineTo(-twh, ps + cr);
+					bg.graphics.curveTo(-twh, ps, -twh + cr, ps);
+					bg.graphics.lineTo(-ps + ptrOffset, ps);
+					bg.graphics.endFill();
+					break;
+				case 'down':
+				default:
+					tf.x = -twh + padding;
+					tf.y = -ps - padding - tf.height;
+					bg.graphics.beginFill(0xe6e2d1, .95);
+					bg.graphics.moveTo(-ps + ptrOffset, -ps);
+					bg.graphics.lineTo(ptrOffset, 0);
+					bg.graphics.lineTo(ps + ptrOffset, -ps);
+					bg.graphics.lineTo(twh - cr, -ps);
+					bg.graphics.curveTo(twh, -ps, twh, -ps - cr);
+					var topY:int = -ps - th;
+					bg.graphics.lineTo(twh, topY + cr);
+					bg.graphics.curveTo(twh, topY, twh - cr, topY);
+					bg.graphics.lineTo(-twh + cr, topY);
+					bg.graphics.curveTo(-twh, topY, -twh, topY + cr);
+					bg.graphics.lineTo(-twh, -ps - cr);
+					bg.graphics.curveTo(-twh, -ps, -twh + cr, -ps);
+					bg.graphics.lineTo(-ps + ptrOffset, -ps);
+					bg.graphics.endFill();
+					break;
+			}*/
+			//graphics.beginFill(0xFF0000, 0.2);
+			//graphics.drawRect(0, 0, bg.width, bg.height);
+			//graphics.endFill();
+			bg.filters = [new DropShadowFilter(3, 90, 0x0, 0.6, 2, 2, 1, 3)];
+			//bg.x = twh;
+			//bg.y = padding * 2 + th + ps;
+			//trace('ok so height is ' + bg.height);
+			setActualSize(bg.width, bg.height);
+			//measure();
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/materia/toolTips/TipManager.as

@@ -0,0 +1,150 @@
+package materia.toolTips
+{
+	import flash.display.DisplayObject;
+	import flash.events.Event;
+	import flash.events.MouseEvent;
+	import flash.events.TimerEvent;
+	import flash.geom.Point;
+	import flash.utils.Timer;
+	import mx.core.Application;
+	import mx.core.UIComponent;
+	import mx.effects.Fade;
+	import mx.events.FlexEvent;
+	import mx.managers.PopUpManager;
+	import mx.managers.PopUpManagerChildList;
+	public class TipManager
+	{
+		protected static var curToolTip:KogneatoToolTip;
+		protected static var curTipTarget:UIComponent;
+		protected static var _enabled:Boolean = true;
+		protected static var _removeTimer:Timer;
+		protected static const REMOVE_DELAY:int = 10;
+		public function TipManager()
+		{
+		}
+		public static function set enabled(val:Boolean):void
+		{
+			_enabled = val;
+		}
+		public static function get enabled():Boolean
+		{
+			return _enabled;
+		}
+		public static function removeTip():void
+		{
+			_removeTimer = new Timer(REMOVE_DELAY, 1);
+			_removeTimer.addEventListener(TimerEvent.TIMER_COMPLETE, handleRemoveTimerComplete);
+			_removeTimer.start();
+			if(curTipTarget)
+			{
+				curTipTarget.removeEventListener(MouseEvent.MOUSE_OUT, handleTargetMouseOut);
+			}
+		}
+		protected static function handleRemoveTimerComplete(event:TimerEvent = null):void
+		{
+			if(_removeTimer)
+			{
+				_removeTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, handleRemoveTimerComplete);
+				_removeTimer = null;
+			}
+			PopUpManager.removePopUp(curToolTip);
+			curToolTip = null;
+			curTipTarget = null;
+		}
+		public static function showTip(targetUIComponent:Object, tipText:String = '', orientation:String = '', addRemoveListener:Boolean = true):void
+		{
+			if(curToolTip)
+			{
+				if(curToolTip.text == tipText)
+				{
+					//Cancel the remove timer
+					if(_removeTimer)
+					{
+						_removeTimer.stop();
+						_removeTimer.removeEventListener(TimerEvent.TIMER_COMPLETE, handleRemoveTimerComplete);
+						_removeTimer = null;
+					}
+					if(addRemoveListener)
+					{
+						curTipTarget.addEventListener(MouseEvent.MOUSE_OUT, handleTargetMouseOut);
+					}
+					return;
+				}
+				else
+				{
+					handleRemoveTimerComplete();
+				}
+			}
+			if(_enabled && tipText && tipText.length > 0)
+			{
+				curTipTarget = UIComponent(targetUIComponent);
+				if(addRemoveListener)
+				{
+					curTipTarget.addEventListener(MouseEvent.MOUSE_OUT, handleTargetMouseOut);
+				}
+				curToolTip = new KogneatoToolTip();
+				curToolTip.addEventListener(FlexEvent.UPDATE_COMPLETE, handleToolTipUpdateComplete);
+				if(orientation.length > 0)
+				{
+					switch(orientation)
+					{
+						case 'above':
+							curToolTip.setStyle("pointerOrientation", 'down');
+							break;
+						case 'below':
+							curToolTip.setStyle("pointerOrientation", 'up');
+					}
+				}
+				curToolTip.alpha = 0;
+				curToolTip.text = tipText;
+				PopUpManager.addPopUp(curToolTip, DisplayObject(Application.application), false, PopUpManagerChildList.POPUP);
+			}
+		}
+		protected static function handleToolTipUpdateComplete(event:Event):void
+		{
+			if(curToolTip)
+			{
+				if(curToolTip.width > 0 && curToolTip.height > 0)
+				{
+					curToolTip.removeEventListener(FlexEvent.UPDATE_COMPLETE, handleToolTipUpdateComplete);
+					var p:Point = UIComponent(curTipTarget).localToGlobal(new Point());
+					var pointerOrientation:String = curToolTip.getStyle('pointerOrientation');
+					//trace('pointer orientation is ' + pointerOrientation);
+					if(pointerOrientation == 'down' || (pointerOrientation == null && p.y - curToolTip.height > 0))
+					{
+						curToolTip.move(p.x - (curToolTip.width / 2) + (curTipTarget.width / 2), p.y - curToolTip.height);
+					}
+					else
+					{
+						curToolTip.setStyle('pointerOrientation', 'up');
+						curToolTip.move(p.x - (curToolTip.width / 2) + (curTipTarget.width / 2), p.y + curTipTarget.height);
+					}
+					var unfixedXPos:Number = curToolTip.x;
+					if(curToolTip.x + curToolTip.width + 10 > Application.application.stage.stageWidth)
+					{
+						curToolTip.x = Application.application.stage.stageWidth - 10 - curToolTip.width;
+						curToolTip.setStyle("pointerOffset", unfixedXPos - curToolTip.x + 2);
+					}
+					else if(curToolTip.x < 0)
+					{
+						curToolTip.x = 10;
+						curToolTip.setStyle("pointerOffset", unfixedXPos - curToolTip.x + 2);
+					}
+					var f:Fade = new Fade(curToolTip);
+					f.alphaFrom = 0.0;
+					f.alphaTo = 1.0;
+					f.duration = 100;
+					f.play();
+				}
+			}
+		}
+		protected static function handleTargetMouseOut(event:MouseEvent):void
+		{
+			if(curTipTarget)
+			{
+				curTipTarget.removeEventListener(MouseEvent.MOUSE_OUT, handleTargetMouseOut);
+			}
+			removeTip();
+		}
+	}
+}