RubyGems - dojo-pkg - Versions diffs - 1.111.0 - Mend

dojo-pkg 1.111.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2409) hide show

data/data/dojo-release-1.1.1-src/dojox/flash/tests/TestFlash.as ADDED Viewed

@@ -0,0 +1,36 @@
+import DojoExternalInterface;
+import ExpressInstall;
+class TestFlash{
+	private var message:String;
+	public function TestFlash(){
+	}
+	public static function main(){
+		//getURL("javascript:alert('main')");
+		trace("main");
+		DojoExternalInterface.initialize();
+		var test = new TestFlash();
+		DojoExternalInterface.addCallback("setMessage", test, test.setMessage);
+		DojoExternalInterface.addCallback("getMessage", test, test.getMessage);
+		DojoExternalInterface.addCallback("multipleValues",
+											test, test.multipleValues);
+		DojoExternalInterface.done();
+	}
+	public function setMessage(message:String):Void{
+		this.message = message;
+	}
+	public function getMessage():String{
+		return this.message;
+	}
+	public function multipleValues(key:String, value:String,
+									namespace:String):String{
+		return namespace + key + value;
+	}
+}

data/data/dojo-release-1.1.1-src/dojox/flash/tests/TestFlash.swf ADDED Viewed

Binary file

data/data/dojo-release-1.1.1-src/dojox/flash/tests/buildFlashTest.sh ADDED Viewed

@@ -0,0 +1,4 @@
+#!/bin/sh
+# TODO: FIXME: Get rid of this and hook it into Dojo's general build script
+# You must have mtasc to run this
+mtasc -trace DojoExternalInterface.trace -main -cp .. -swf TestFlash.swf -version 8 -header 215:138:10 TestFlash.as

data/data/dojo-release-1.1.1-src/dojox/flash/tests/test_flash.html ADDED Viewed

@@ -0,0 +1,15 @@
+<html>
+	<head>
+		<script src="../../../dojo/dojo.js" djConfig="isDebug: true"></script>
+		<script src="test_flash.js"></script>
+	</head>
+	<body>
+		<h1>Test Dojox Flash</h1>
+		<p>For detailed test output see Firebug console (if Firefox).
+		  This test should be run on Firefox, Internet Explorer, and Safari
+		  to confirm that Dojox Flash is working correctly.</p>
+	</body>
+</html>

data/data/dojo-release-1.1.1-src/dojox/flash/tests/test_flash.js ADDED Viewed

@@ -0,0 +1,155 @@
+// TODO: FIXME: Refactor this to use D.O.H. instead of its own assertions
+dojo.require("dojox.flash");
+var flashLoaded = false;
+var pageLoaded = false;
+var testXML = testBook = null;
+function flashReady(){
+	console.debug("flashReady");
+	flashLoaded = true;
+	if(isReady()){
+		run();
+	}
+}
+function pageReady(){
+	console.debug("pageReady");
+	pageLoaded = true;
+	loadResources();
+	if(isReady()){
+		run();
+	}
+}
+function isReady(){
+	return testXML && testBook && pageLoaded && flashLoaded;
+}
+function loadResources(){
+	console.debug("Trying to load resources");
+	var d = dojo.xhrGet({
+		url: "../../storage/tests/resources/testXML.xml",
+		handleAs: "text"
+	});
+	d.addCallback(function(results){
+		console.debug("testXML loaded");
+		testXML = results;
+		if(isReady()){
+			run();
+		}
+	});
+	d.addErrback(function(error){
+		console.debug("Unable to load testXML.xml: " + error);
+	});
+	d = dojo.xhrGet({
+		url: "../../storage/tests/resources/testBook.txt",
+		handleAs: "text"
+	});
+	d.addCallback(function(results){
+		console.debug("testBook loaded");
+		testBook = results;
+		if(isReady()){
+			run();
+		}
+	});
+	d.addErrback(function(error){
+		console.debug("Unable to load testXML.xml: " + error);
+	});
+}
+function run(){
+	console.debug("run");
+	try{
+		var correct, actual;
+		console.debug("Setting simple message...");
+		correct = "hello world";
+		dojox.flash.comm.setMessage(correct);
+		actual = dojox.flash.comm.getMessage();
+		assert(correct, actual, "Setting/getting simple message did not work");
+		console.debug("Setting message with evil characters...");
+		// our correct and actual values get tricky when we have double back
+		// slashes; do a trick so that they can be compared easier
+		var doubleSlash = "\\";
+		doubleSlash = doubleSlash.charAt(0);
+		correct = "hello world\n\n\nasdfasdf!@#$@#%^[]{}&amp;<xml>" + doubleSlash
+					+ "<div>$%^&%^&*^&()<><><>,./;\0\r\f\'][`~=\"+-]MORE!\n\rLESS";
+		dojox.flash.comm.setMessage(correct);
+		actual = dojox.flash.comm.getMessage();
+		assert(correct, actual, "Setting/getting message with evil characters did not work");
+		console.debug("Setting testXML...");
+		correct = testXML;
+		dojox.flash.comm.setMessage(correct);
+		actual = dojox.flash.comm.getMessage();
+		assert(correct, actual, "Setting/getting testXML did not work");
+		console.debug("Setting testBook(~300K)...");
+		correct = testBook;
+		dojox.flash.comm.setMessage(correct);
+		actual = dojox.flash.comm.getMessage();
+		assert(correct, actual, "Setting/getting testBook did not work");
+		console.debug("Setting testBook 3 times (~900K)...");
+		correct = testBook + testBook + testBook;
+		dojox.flash.comm.setMessage(correct);
+		actual = dojox.flash.comm.getMessage();
+		assert(correct, actual, "Setting/getting testBook X 3 did not work");
+		console.debug("Setting JSON...");
+		var obj = {type: "car", color: "red", model: "Ford", year: "2008",
+					features: ["A/C", "automatic", "4-wheel drive"]};
+		correct = dojo.toJson(obj, true);
+		dojox.flash.comm.setMessage(correct);
+		actual = dojox.flash.comm.getMessage();
+		assert(correct, actual, "Setting/getting JSON did not work");
+		console.debug("Calling method that takes multiple values...");
+		actual = dojox.flash.comm.multipleValues("key", "value", "namespace");
+		assert("namespacekeyvalue", actual, "Setting/getting multiple values did not work");
+		var allPassed = document.createElement("p");
+		allPassed.style.backgroundColor = "green";
+		allPassed.style.color = "white";
+		allPassed.style.fontSize = "24pt";
+		allPassed.appendChild(document.createTextNode("All tests passed"));
+		var body = document.getElementsByTagName("body")[0];
+		body.appendChild(allPassed);
+	}catch(e){
+		console.debug(e.message || e);
+	}
+}
+function assert(correct, actual, msg){
+	//alert("correct="+correct+",\n\nactual="+actual);
+	if(correct != actual){
+	  var failed = document.createElement("p");
+		failed.style.backgroundColor = "red";
+		failed.style.color = "white";
+		failed.style.fontSize = "24pt";
+		failed.appendChild(document.createTextNode("Test failed: " + msg));
+		var body = document.getElementsByTagName("body")[0];
+		body.appendChild(failed);
+		throw new Error("ASSERTION FAILED: " + msg);
+	}else{
+		console.debug("Assertion passed");
+	}
+}
+console.debug("adding listeners...");
+dojox.flash.addLoadedListener(flashReady);
+dojox.flash.setSwf("TestFlash.swf", true);
+dojo.connect(dojo, "loaded", pageReady);

data/data/dojo-release-1.1.1-src/dojox/flash.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ dojo.provide("dojox.flash");
2	+ dojo.require("dojox.flash._base");

data/data/dojo-release-1.1.1-src/dojox/form/CheckedMultiSelect.js ADDED Viewed

@@ -0,0 +1,219 @@
+dojo.provide("dojox.form.CheckedMultiSelect");
+dojo.require("dijit.form.MultiSelect");
+dojo.require("dijit.form.CheckBox");
+dojo.declare("dojox.form._CheckedMultiSelectItem",
+	[dijit._Widget, dijit._Templated],
+	{
+	// summary:
+	//		The individual items for a CheckedMultiSelect
+	widgetsInTemplate: true,
+	templatePath: dojo.moduleUrl("dojox.form", "resources/_CheckedMultiSelectItem.html"),
+	baseClass: "dojoxMultiSelectItem",
+	// option: Element
+	//		The option that is associated with this item
+	option: null,
+	parent: null,
+	// disabled: boolean
+	//		Whether or not this widget is disabled
+	disabled: false,
+	_changeBox: function(){
+		// summary:
+		//		Called to force the select to match the state of the check box
+		//		(only on click of the checkbox)
+		this.option.selected = this.checkBox.getValue() && true;
+		// fire the parent's change
+		this.parent._onChange();
+		// refocus the parent
+		this.parent.focus();
+	},
+	_labelClick: function(){
+		// summary:
+		//		Called when the label portion is clicked
+		dojo.stopEvent(e);
+		if(this.disabled){
+			return;
+		}
+		var cb = this.checkBox;
+		cb.setValue(!cb.getValue());
+		this._changeBox();
+	},
+	_onMouse: function(e){
+		// summary:
+		//		Sets the hover state depending on mouse state (passes through
+		//		to the check box)
+		this.checkBox._onMouse(e);
+	},
+	_onClick: function(e){
+		// summary:
+		//		Sets the click state (passes through to the check box)
+		this.checkBox._onClick(e);
+	},
+	_updateBox: function(){
+		// summary:
+		//		Called to force the box to match the state of the select
+		this.checkBox.setValue(this.option.selected);
+	},
+	setAttribute: function(attr, value){
+		// summary:
+		//		Disables (or enables) all the children as well
+		this.inherited(arguments);
+		switch(attr){
+			case "disabled":
+				this.checkBox.setAttribute(attr, value);
+				break;
+			default:
+				break;
+		}
+	}
+});
+dojo.declare("dojox.form.CheckedMultiSelect", dijit.form.MultiSelect, {
+	// summary:
+	//		Extends the core dijit MultiSelect to provide a "checkbox" selector
+	templateString: "",
+	templatePath: dojo.moduleUrl("dojox.form", "resources/CheckedMultiSelect.html"),
+	baseClass: "dojoxMultiSelect",
+	// children: dojox.form._CheckedMultiSelectItem[]
+	//		Array of all our children (for updating them)
+	children: [],
+	/*=====
+	dojox.form.__SelectOption = function(){
+		//	value: String
+		//		The value of the option.  Setting to empty (or missing) will
+		//		place a separator at that location
+		//	label: String
+		//		The label for our option.  It can contain html tags.
+		this.value = value;
+		this.label = label;
+	}
+	=====*/
+	// options: dojox.form.__SelectOption[]
+	//		our set of options
+	options: null,
+	_mouseDown: function(e){
+		// summary:
+		//		Cancels the mousedown event to prevent others from stealing
+		//		focus
+		dojo.stopEvent(e);
+	},
+	_updateChildren: function(){
+		// summary:
+		//		Called to update the checked states of my children to match me
+		dojo.forEach(this.children,function(child){
+			child._updateBox();
+		});
+	},
+	_addChild: function(/*Element*/ option){
+		// summary:
+		//		Adds and returns a child for the given option.
+		var item = new dojox.form._CheckedMultiSelectItem({
+			option: option,
+			parent: this
+		});
+		this.wrapperDiv.appendChild(item.domNode);
+		return item;
+	},
+	_loadChildren: function(){
+		// summary:
+		//		Reloads the children to match our box.
+		// Destroy any existing children before loading them again
+		dojo.forEach(this.children, function(child){
+			child.destroyRecursive();
+		});
+		this.children = dojo.query("option", this.domNode).map(function(child){
+			return this._addChild(child);
+		}, this);
+		this.options = dojo.map(this.children, function(child){
+			var opt = child.option;
+			return { value:opt.value, label: opt.text };
+		});
+		// Update the statuses of the children
+		this._updateChildren();
+	},
+	addOption: function(/* dojox.form.__SelectOption or string, optional */ value, /* string? */ label){
+		// summary: Adds the given option to the select
+		var o = new Option("","");
+		o.value = value.value || value;
+		o.innerHTML = value.label || label;
+		this.containerNode.appendChild(o);
+	},
+	removeOption: function(/*String*/ optionId){
+		dojo.query("option[value=" + optionId + "]", this.domNode).forEach(function(node){
+			node.parentNode.removeChild(node);
+		}, this);
+	},
+	setOptionLabel: function(/*string*/ optionId, /*string*/ label){
+		dojo.query("option[value=" + optionId + "]", this.domNode).forEach(function(node){
+			node.innerHTML = label;
+		});
+	},
+	addSelected: function(select){
+		this.inherited(arguments);
+		// Reload my children and the children of the guy pointing to me
+		if(select._loadChildren){
+			select._loadChildren();
+		}
+		this._loadChildren();
+	},
+	setAttribute: function(attr, value){
+		// summary:
+		//		Disable (or enable) all the children as well
+		this.inherited(arguments);
+		switch(attr){
+			case "disabled":
+				dojo.forEach(this.children, function(node){
+					if(node && node.setAttribute){
+						node.setAttribute(attr, value);
+					}
+				});
+				break;
+			default:
+				break;
+		}
+	},
+	startup: function(){
+		if(this._started){ return; }
+		this.inherited(arguments);
+		// Load children and make connections
+		this._loadChildren();
+		this.connect(this, "setValue", "_updateChildren");
+		this.connect(this, "invertSelection", "_updateChildren");
+		this.connect(this, "addOption", "_loadChildren");
+		this.connect(this, "removeOption", "_loadChildren");
+		this.connect(this, "setOptionLabel", "_loadChildren");
+		this._started = true;
+	}
+});

data/data/dojo-release-1.1.1-src/dojox/form/DropDownSelect.js ADDED Viewed

@@ -0,0 +1,263 @@
+dojo.provide("dojox.form.DropDownSelect");
+dojo.require("dijit.form.Button");
+dojo.require("dijit.Menu");
+dojo.require("dojo.data.ItemFileWriteStore");
+dojo.declare("dojox.form.DropDownSelect", dijit.form.DropDownButton, {
+	// summary:
+	//		This is a "Styleable" select box - it is basically a DropDownButton which
+	//		can take as its input a <select>.
+	baseClass: "dojoxDropDownSelect",
+	/*=====
+	dojox.form.__SelectOption = function(){
+		//	value: String
+		//		The value of the option.  Setting to empty (or missing) will
+		//		place a separator at that location
+		//	label: String
+		//		The label for our option.  It can contain html tags.
+		this.value = value;
+		this.label = label;
+	}
+	=====*/
+	// options: dojox.form.__SelectOption[]
+	//		our set of options
+	options: null,
+	// emptyLabel: string
+	//		What to display in an "empty" dropdown
+	emptyLabel: "",
+	// _isPopulated: boolean
+	//		Whether or not we have been populated
+	_isPopulated: false,
+	_addMenuItem: function(/* dojox.form.__SelectOption */ option){
+		// summary:
+		//		For the given option, add a menu item to our dropdown
+		//		If the option doesn't have a value, then a separator is added
+		//		in that place.
+		var menu = this.dropDown;
+		if(!option.value){
+			// We are a separator (no label set for it)
+			menu.addChild(new dijit.MenuSeparator());
+		}else{
+			// Just a regular menu option
+			var click = dojo.hitch(this, "setAttribute","value",option);
+			var mi = new dijit.MenuItem({
+				id: this.id + "_item_" + option.value,
+				label: option.label,
+				onClick: click
+			});
+			menu.addChild(mi);
+		}
+	},
+	_resetButtonState: function(){
+		// summary:
+		//		Resets the menu and the length attribute of the button - and
+		//		ensures that the label is appropriately set.
+		var len = this.options.length;
+		// reset the menu to make it "populatable on the next click
+		var dropDown = this.dropDown;
+		dojo.forEach(dropDown.getChildren(), function(child){
+			child.destroyRecursive();
+		});
+		this._isPopulated = false;
+		// Set our length attribute and our value
+		this.setAttribute("readOnly", (len === 1));
+		this.setAttribute("disabled", (len === 0));
+		this.setAttribute("value", this.value);
+	},
+	_updateSelectedState: function(){
+		// summary:
+		//		Sets the "selected" class on the item for styling purposes
+		var val = this.value;
+		if(val){
+			var testId = this.id + "_item_" + val;
+			dojo.forEach(this.dropDown.getChildren(), function(child){
+				dojo[child.id === testId ? "addClass" : "removeClass"](child.domNode,
+														this.baseClass + "SelectedOption");
+			}, this);
+		}
+	},
+	addOption: function(/* dojox.form.__SelectOption or string, optional */ value, /* string? */ label){
+		// summary:
+		//		Adds an option to the end of the select.  If value is empty or
+		//		missing, a separator is created instead.
+		this.options.push(value.value ? value : { value:value, label:label });
+	},
+	removeOption: function(/* string, dojox.form.__SelectOption or number */ valueOrIdx){
+		// summary:
+		//		Removes the given option
+		this.options = dojo.filter(this.options, function(node, idx){
+			return !((typeof valueOrIdx === "number" && idx === valueOrIdx) ||
+					(typeof valueOrIdx === "string" && node.value === valueOrIdx) ||
+					(valueOrIdx.value && node.value === valueOrIdx.value));
+		});
+	},
+	setOptionLabel: function(/*string*/ value, /*string*/ label){
+		dojo.forEach(this.options, function(node){
+			if(node.value === value){
+				node.label = label;
+			}
+		});
+	},
+	destroy: function(){
+		// summary:
+		//		Clear out an outstanding hack handle
+		if(this._labelHackHandle){
+			clearTimeout(this._labelHackHandle);
+		}
+		this.inherited(arguments);
+	},
+	setLabel: function(/* string */ content){
+		// summary:
+		//		Wraps our label in a div - that way, our rich text can work
+		//		correctly.
+		content = '<div class=" ' + this.baseClass + 'Label">' +
+					content +
+					'</div>';
+		//		Because FF2 has a problem with layout, we need to delay this
+		//		call for it.
+		if(this._labelHackHandle){
+			clearTimeout(this._labelHackHandle);
+		}
+		if(dojo.isFF === 2){
+			this._labelHackHandle = setTimeout(dojo.hitch(this, function(){
+				this._labelHackHandle = null;
+				dijit.form.DropDownButton.prototype.setLabel.call(this, content);
+			}), 0);
+		}else{
+			this.inherited(arguments);
+		}
+	},
+	setAttribute: function(/*string*/ attr, /* anything */ value){
+		// summary: sometime we get called to set our value - we need to
+		//			make sure and route those requests through _setValue()
+		//			instead.
+		if(attr === "value"){
+			// If a string is passed, then we set our value from looking it up.
+			if(typeof value === "string"){
+				value = dojo.filter(this.options, function(node){
+					return node.value === value;
+				})[0];
+			}
+			// If we don't have a value, try to show the first item
+			if(!value){
+				value = this.options[0] || { value: "", label: "" };
+			}
+			this.value = value.value;
+			if(this._started){
+				this.setLabel(value.label || this.emptyLabel || "&nbsp;");
+			}
+			this._handleOnChange(value.value);
+			value = this.value;
+		}else{
+			this.inherited(arguments);
+		}
+	},
+	_fillContent: function(){
+		// summary:
+		//		Loads our options and sets up our dropdown correctly.  We
+		//		don't want any content, so we don't call any inherit chain
+		//		function.
+		var opts = this.options;
+		if(!opts){
+			opts = this.options = this.srcNodeRef ? dojo.query(">",
+						this.srcNodeRef).map(function(node){
+							if(node.getAttribute("type") === "separator"){
+								return { value: "", label: "" };
+							}
+							return { value: node.getAttribute("value"),
+										label: String(node.innerHTML) };
+						}, this) : [];
+		}
+		// Set the value to be the first, or the selected index
+		if(opts.length && !this.value){
+			var si = this.srcNodeRef.selectedIndex;
+			this.value = opts[si != -1 ? si : 0].value;
+		}
+		// Create the dropDown widget
+		this.dropDown = new dijit.Menu();
+	},
+	postCreate: function(){
+		// summary: sets up our event handling that we need for functioning
+		//			as a select
+		this.inherited(arguments);
+		// Make our event connections for updating state
+		var fx = function(){
+			dojo[this._opened ? "addClass" : "removeClass"](this.focusNode,
+														this.baseClass + "ButtonOpened");
+		};
+		this.connect(this, "_openDropDown", fx);
+		this.connect(this, "_closeDropDown", fx);
+		this.connect(this, "onChange", "_updateSelectedState");
+		this.connect(this, "addOption", "_resetButtonState");
+		this.connect(this, "removeOption", "_resetButtonState");
+		this.connect(this, "setOptionLabel", "_resetButtonState");
+	},
+	startup: function(){
+		// summary:
+		//		FF2 has layout problems if the reset call isn't done on a
+		//		slight delay
+		this.inherited(arguments);
+		if(dojo.isFF === 2){
+			setTimeout(dojo.hitch(this, this._resetButtonState), 0);
+		}else{
+			this._resetButtonState();
+		}
+	},
+	_populate: function(/* function */ callback){
+		// summary:
+		//			populates the menu (and does the callback, if passed)
+		var dropDown = this.dropDown;
+		// Add each menu item
+		dojo.forEach(this.options, this._addMenuItem, this);
+		// Update states
+		this._updateSelectedState();
+		dojo.addClass(this.dropDown.domNode, this.baseClass + "Menu");
+		this._isPopulated = true;
+		if(callback){ callback.call(this); }
+	},
+	_toggleDropDown: function(){
+		// summary: Overrides DropDownButton's toggle function to make sure
+		//			that the values are correctly populated.
+		var dropDown = this.dropDown;
+		if(dropDown && !dropDown.isShowingNow && !this._isPopulated){
+			this._populate(dojox.form.DropDownSelect.superclass._toggleDropDown);
+		}else{
+			this.inherited(arguments);
+		}
+	}
+});