mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/materia/help/HelpObject.as

@@ -0,0 +1,33 @@
+package materia.help
+{
+	import flash.display.DisplayObject;
+	public class HelpObject
+	{
+		public static const H_ALIGN_AUTO:int = -1;
+		public static const H_ALIGN_LEFT:int = 0;
+		public static const H_ALIGN_RIGHT:int = 1;
+		public static const V_ALIGN_AUTO:int = -1;
+		public static const V_ALIGN_TOP:int = 0;
+		public static const V_ALIGN_BOTTOM:int = 1;
+		public static const V_ALIGN_CENTER:int = 2;
+		private const DEFAULT_WIDTH:int = 300;
+		public var title:String;
+		public var message:String;
+		public var targetComponent:DisplayObject;
+		public var horizontalAlign:int;
+		public var verticalAlign:int;
+		public var width:Number;
+		public var showArrow:Boolean;
+		public function HelpObject(targetComponent:DisplayObject, title:String, message:String,
+								   horizontalAlign:int = -1, verticalAlign:int = -1, width:Number = -1, showArrow:Boolean = true)
+		{
+			this.targetComponent = targetComponent;
+			this.title = title;
+			this.message = message;
+			this.horizontalAlign = horizontalAlign;
+			this.verticalAlign = verticalAlign;
+			this.width = width == -1? DEFAULT_WIDTH:width;
+			this.showArrow = showArrow;
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/materia/help/IHelpGuided.as

@@ -0,0 +1,7 @@
+package materia.help
+{
+public interface IHelpGuided
+{
+	function beginTour():void
+}
+}

data/lib/mako/data/flash_widget_dev_core/src/materia/media/ImageCacherImage.mxml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<mx:Image xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="{creationComplete()}">
+	<mx:Script>
+		<![CDATA[
+			import materia.utils.ImageCacher;
+			/**
+			 * This is an image component that uses ImageCacher to load images.
+			 * Use it like a normal image component, but use imageSource instead of source.
+			 * 
+			 */
+			 
+			 protected var _imageSource:String = "";
+			 
+			 protected var _isCreationComplete:Boolean = false;
+			 
+			 [Bindable]
+			 public function set imageSource(s:String):void
+			 {
+			 	setImageSource(s);
+			 }
+			 
+			 // NOTE: strage bug, there are times when the setter for image source doesnt work right
+			 // this function is used in the flashcards creator
+			 public function setImageSource(s:String):void
+			 {
+			 	_imageSource = s;
+			 	
+			 	if(_isCreationComplete)
+			 	{
+			 		loadTheImage();
+			 	}
+			 }
+			 
+			 protected function loadTheImage():void
+			 {
+			 	ImageCacher.loadImage(this, _imageSource);	
+			 }
+			 
+			 public function get imageSource():String
+			 {
+			 	return _imageSource;
+			 }
+			 
+			 protected function creationComplete():void
+			 {
+			 	_isCreationComplete = true;
+			 	
+			 	if(_imageSource != "")
+			 	{
+			 		loadTheImage();
+			 	}
+			 }
+			 
+		]]>
+	</mx:Script>
+</mx:Image>

data/lib/mako/data/flash_widget_dev_core/src/materia/media/MateriaUploader.as

@@ -0,0 +1,61 @@
+package materia.media
+{
+	import flash.events.Event;
+	import flash.net.FileReference;
+	import flash.net.FileReferenceList;
+	
+	import materia.CreatorConfig;
+	import materia.PopUpAlert;
+	
+	import mx.events.CloseEvent;
+	import mx.managers.PopUpManager;
+	import mx.rpc.events.ResultEvent;
+	
+	/**
+	 * This is a static class to handle uploading files!
+	 * 
+	 * It is currently going to be used by the MediaScreen, and the MediaScreenGameCreatorPopup
+	 * 
+	 * Note: this will depend on the screens to not ask to upload more in the middle of an upload.
+	 * */
+	public class MateriaUploader
+	{
+		 
+		protected static var _files:Array; // an array of FileRefences
+		protected static var _parentStage:*; // a place to put popups
+		protected static var _callbackFunction:Function // callback function
+			// funciton will look like this:
+			//     fileUploadComplete(sucess:Boolean, assetidsList:Array, sourcesList:Array):void
+			
+		protected static var _currentUploadIndex:int;
+		protected static var _currentFileReference:FileReference;
+			
+ 		protected static const SNAP_SHOT_MAX_SIZE:Number = 250;
+		
+		protected static var _sourcesList:Array; // array of urls to open the uploaded images at
+		protected static var _assetIdsList:Array; // array of assetids -> parallel to _sourcesList
+		
+		protected static var _replacedFileData:Object; // file data for a replaced file, if we are replacing
+		
+		protected static var _isReplacingAFile:Boolean = false; // true if we are replacing a file
+
+
+		
+
+	    
+	    protected static function cleanUp():void
+	    {
+	    	//trace(TRACE_STRING + "::cleanUp");
+	    	
+	    	_files = null;
+			_parentStage = null;
+			_callbackFunction = null;
+			_currentFileReference = null;
+			_sourcesList = null;
+			_assetIdsList = null;
+	    }
+	    
+    
+		
+	}
+}

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

@@ -0,0 +1,386 @@
+package materia.questionStorage
+{
+import materia.utils.CommonUtils;
+import mx.utils.ObjectUtil;
+public class Question
+{
+    public static const MC_QUESTION:String = "MC";
+    public static const QA_QUESTION:String = "QA";
+    public static const SO_QUESTION:String = "SO"; // Short answer type. Are we using this?
+    public var answers:Array;
+    public var id:Number;
+    public var questions:Array;
+    public var name:String;
+    public var options:Object;
+    public var type:String;
+    public var value:String;
+    public var assets:Array;
+    public function Question(type:String = "MC", options:Object = null, id:Number = 0, question:String = null, answer:String = null)
+    {
+        this.type = type;
+        this.id = id;
+        questions = new Array();
+        answers = new Array();
+		this.options = options == null? new Object : options;
+        if(question != null)
+       	{
+       		addQuestion(question);
+       	}
+       	if(answer != null)
+       	{
+       		addAnswer(answer);
+       	}
+    }
+    // convert objects to arrays
+    public static function toArray(obj:Object): Array
+    {
+        if (obj == null)
+        {
+            return null;
+        }
+        else
+        {
+            var ret:Array = [];
+            for each (var prop:Object in obj)
+            {
+                ret.push(prop);
+            }
+            return ret;
+        }
+    }
+    public static function convertObject(obj:Object):Question
+    {
+        var q:Question = new Question();
+        q.questions = obj["questions"] is Array ? obj['questions'] : Question.toArray(obj['questions']) ;
+        q.answers = obj["answers"] is Array ? obj['answers'] : Question.toArray(obj['answers']) ;
+        //trace(q.answers.length)
+        if(obj.hasOwnProperty("name")) q.name = obj["name"];
+        q.id = obj["id"];
+        // There was some issues with the options coming in as Arrays vs Objects.
+        // This will make sure we have objects.
+        q.options = CommonUtils.convertArrayToObject(obj["options"]);
+        // questions and answers can also have answers with options -> make em objects
+        var i:int;
+		if(q.questions != null)
+		{
+	        for (i = 0; i < q.questions.length; i++)
+	        {
+	            q.questions[i]["options"] = CommonUtils.convertArrayToObject(q.questions[i]["options"]);
+	        }
+	 	}
+		if(q.answers != null)
+		{
+	        for (i = 0; i < q.answers.length; i++)
+	        {
+	            q.answers[i]["options"] = CommonUtils.convertArrayToObject(q.answers[i]["options"]);
+	        }
+	 }
+        q.type = obj["type"];
+        q.id = obj["id"];
+        q.assets = [];
+        if( obj["assets"] )
+        {
+	        for( i = 0; i< obj["assets"].length; i++)
+	        {
+	        	q.assets.push(obj["assets"][i]);
+	        }
+	    }
+        return q;
+    }
+    public function addAItem(text:String, value:String, options:Object = null):void
+    {
+        if (options == null)
+            options = new Object();
+        answers.push(constructNewItem(text, options, value));
+    }
+    public function addAnswer(text:String, value:String = "100", options:Object = null):void
+    {
+        if (answers == null)
+			answers = new Array();
+        answers.push(constructNewItem(text, options, value));
+    }
+    public function addOption(name:String, value:*):void
+    {
+        if (options == null)
+            options = new Object;
+        options[name] = value;
+    }
+    public function addQItem(text:String, options:Object = null):void
+    {
+        if (options == null)
+            options = new Object();
+        questions.push(constructNewItem(text, options));
+    }
+    public function addQuestion(text:String):void
+    {
+        addQItem(text);
+    }
+    public function addText(text:String):void
+    {
+        addQItem(text);
+    }
+    public function clone():Question
+    {
+        var clone:Question = new Question(type, null, id);
+		//Copy options
+        for (var i:String in options) { clone.options[i] = ObjectUtil.copy(options[i]); }
+		//Copy Answers
+        if(answers && answers.length)
+		{
+			for (i in answers)
+			{
+				clone.answers[i] = ObjectUtil.copy(answers[i]);
+				if(clone.answers[i].value == null) clone.answers[i].value = 0;
+			}
+		}
+		else { clone.answers = new Array(); }
+		//Copy Questions
+        if(questions.length) { for (i in questions) { clone.questions[i] = ObjectUtil.copy(questions[i]); } }
+		else { clone.questions = new Array(); }
+        return clone;
+    }
+    public function convertToObject():Object
+    {
+        var o:Object = new Object();
+        o["questions"] = questions;
+        o["answers"] = answers;
+        o["name"] = name;
+        o["options"] = options;
+        o["type"] = type;
+        o["id"] = id;
+		o["assets"] = assets;
+        return o;
+    }
+    public function get correctAnswer():String
+    {
+	    if(answers == null || answers.length == 0)
+	    {
+		    return "";
+	    }
+        var j:int = 0;
+        for (var i:int = 1; i < answers.length; i++)
+        {
+            if (answers[i].value != "")
+            {
+                if (Number(answers[i].value) > Number(answers[j].value))
+                    j = i;
+            }
+        }
+        return answers[j].text;
+    }
+    // this should only be used for qa type questions
+    public function getAnswer():String
+    {
+        if(this.hasOwnProperty("answers") && answers != null && answers.length) { return answers[0].text; }
+		return null;
+    }
+    public function getOption(name:String):String
+    {
+        if (options == null)
+            return "";
+        else if (options.hasOwnProperty(name))
+            return options[name];
+        else
+            return "";
+    }
+    public function getQuestion():String
+    {
+        if (questions.length)
+        {
+            return questions[0].text;
+        }
+        else
+        {
+            return "";
+        }
+        return this.question;
+    }
+    public function get hint():String
+    {
+        return getOption("hint");
+    }
+    /**
+     * Compare 2 questions, but don't worry about comparing the options.
+     * This is to see if question has changed to the point where it needs a new QID.
+     * The options are added with not just the QID, so don't compare options in this function.
+     * */
+    public function isSameQIDQuestion(otherQuestion:Question):Boolean
+    {
+        this.makeStandardQuestionFormat();
+        otherQuestion.makeStandardQuestionFormat();
+        var q1:Object = this.convertToObject();
+        var q2:Object = otherQuestion.convertToObject();
+        q1.options = new Object();
+        q2.options = new Object();
+        return (ObjectUtil.compare(q1, q2) == 0) // when the compare returns 0, they are the same
+    }
+    /**
+     * Returns true if the 2 questions are the same. The same content/organization/ options.
+     * Set compareQIDs to true if we want to compare QIDs.
+     * TODO: not sure if we would ever really not want to also compare qids
+     */
+    public function isSameQuestion(otherQuestion:Question, compareQIDs:Boolean = false):Boolean
+    {
+        // make them objects so we can compare them with ObjectUtil
+        // Note: is this hacky / bad to do?
+        this.makeStandardQuestionFormat();
+        otherQuestion.makeStandardQuestionFormat();
+        var q1:Object = this.convertToObject();
+        var q2:Object = otherQuestion.convertToObject();
+        var tmpQ1QID:int = q1["id"];
+        var tmpQ2QID:int = q2["id"];
+        if (compareQIDs == false) // we wont worry about QIDs in the comparison
+        {
+            q1["id"] = 0;
+            q2["id"] = 0;
+        }
+        var same:Boolean = (ObjectUtil.compare(q1, q2) == 0); // when the compare returns 0, they are the same
+        q1["id"] = tmpQ1QID;
+        q2["id"] = tmpQ2QID;
+        return same;
+    }
+    public function get question():String
+    {
+        return getQuestion();
+    }
+    public function set question(val:String):void
+    {
+        setQuestion(val);
+    }
+    public function get answer():String
+    {
+        return getAnswer();
+    }
+    public function set answer(val:String):void
+    {
+        setAnswer(val);
+    }
+    public function setAnswer(s:String):void
+    {
+	    if(answers == null) addAnswer(s, '100', null);
+        answers[0].text = s;
+    }
+    public function setQuestion(s:String):void
+    {
+		if(questions[0] == null) questions.push(constructNewItem(s, null));
+		else questions[0].text = s;
+    }
+    protected function convertToStringOptions(obj:Object):void
+    {
+        for (var s:String in obj)
+        {
+            obj[s] = String(obj[s]);
+        }
+    }
+    /**
+     * Make it a standard format so we can easily compare questions.
+     * I was comparing questions with identical content, but they were object comparing as different.
+     *
+     * */
+    protected function makeStandardQuestionFormat():void
+    {
+        if (options == null)
+        {
+            options = new Object();
+        }
+        else
+        {
+            // HACKE CODE?
+            convertToStringOptions(options);
+                // END HACK CODE
+        }
+        if (name == null)
+            name = "";
+        var i:int;
+		if(questions != null)
+		{
+	        for (i = 0; i < questions.length; i++)
+	        {
+	            if (questions[i].value == null) // some questions have values?
+	            {
+	                questions[i].value = "";
+	            }
+	            questions[i].value = String(questions[i].value); // values could be numbers, make them strings
+	            if (questions[i].options == null)
+	            {
+	                questions[i].options = new Object();
+	            }
+	        }
+	 	}
+		if(this.hasOwnProperty("answers") && answers != null)
+		{
+	        for (i = 0; i < answers.length; i++)
+	        {
+	            answers[i].id = 0; // we are not concerned with ids, haha
+	            if (answers[i].options == null) // some questions have values?
+	            {
+	                answers[i].options = new Object();
+	            }
+	            answers[i].value = String(answers[i].value); // values could be numbers, make them strings
+	        }
+		}
+    }
+    private function constructNewItem(text:String, options:Object, value:String = ""):Object
+    {
+        var newItem:Object = new Object();
+        newItem.options = new Object();
+        for (var i:String in options)
+            newItem.options[i] = options[i];
+        newItem.text = text;
+        newItem.value = value;
+        return newItem;
+    }
+	public function toString():String
+	{
+		var str:String =  '['+type + ' Question]: ' + (questions?questions.length+"":'') + "q, " + (answers?answers.length+"":'') + "a  Question: '" + (questions[0]?questions[0].text:'') + "'";
+		for(var i:* in options)
+		{
+			str += "\n   Q Option: '" + i + "' = '"+ options[i] + "'"
+		}
+		return str
+	}
+	/**
+	 * Given TextInput's ItemRenderer errorType, determine if field is valid
+	 * Override method in extended widget class to error check additional column types
+	 **/
+	public function valid(type:String=""):Boolean
+	{
+		switch(type)
+		{
+			case 'question': return validQuestion();
+			case 'answer'  : return validAnswer();
+			default        : return validQuestion() && validAnswer();
+		}
+	}
+	/**
+	 * Override in extended widget class for more comprehensive error checking
+	 * Default: valid answer cannot be empty
+	 **/
+	public function validAnswer():Boolean
+	{
+		return !empty(answer);
+	}
+	/**
+	 * Override in extended widget class for more comprehensive error checking
+	 * Default: valid question cannot be empty
+	 **/
+	public function validQuestion():Boolean
+	{
+		return !empty(question);
+	}
+	/**
+	 * Check if string is empty
+	 * Side effect: Add emtpy error message to question's option parameter
+	 **/
+	public function empty(str:String):Boolean
+	{
+		if(str.length == 0)
+		{
+			options.errorMessage = "Please look over the highlighted fields and enter information where necessary.";
+			options.errorTitle = "Missing Information";
+			return true;
+		}
+		return false;
+	}
+}
+}