New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit

git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f

1 files changed, 5910 insertions, 0 deletions

diff --git a/includes/js/dojox/off/offline.js.uncompressed.js b/includes/js/dojox/off/offline.js.uncompressed.js
new file mode 100644
index 0000000..aa2866d
--- /dev/null
+++ b/includes/js/dojox/off/offline.js.uncompressed.js
@@ -0,0 +1,5910 @@
+/*
+	Copyright (c) 2004-2008, The Dojo Foundation
+	All Rights Reserved.
+
+	Licensed under the Academic Free License version 2.1 or above OR the
+	modified BSD license. For more information on Dojo licensing, see:
+
+		http://dojotoolkit.org/book/dojo-book-0-9/introduction/licensing
+*/
+
+/*
+	This is a compiled version of Dojo, built for deployment and not for
+	development. To get an editable version, please visit:
+
+		http://dojotoolkit.org
+
+	for documentation and information on getting the source.
+*/
+
+if(!dojo._hasResource["dojox.storage.Provider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage.Provider"] = true;
+dojo.provide("dojox.storage.Provider");
+
+dojo.declare("dojox.storage.Provider", null, {
+	// summary: A singleton for working with dojox.storage.
+	// description:
+	//		dojox.storage exposes the current available storage provider on this
+	//		platform. It gives you methods such as dojox.storage.put(),
+	//		dojox.storage.get(), etc.
+	//		
+	//		For more details on dojox.storage, see the primary documentation
+	//		page at
+	//			http://manual.dojotoolkit.org/storage.html
+	//		
+	//		Note for storage provider developers who are creating subclasses-
+	//		This is the base class for all storage providers Specific kinds of
+	//		Storage Providers should subclass this and implement these methods.
+	//		You should avoid initialization in storage provider subclass's
+	//		constructor; instead, perform initialization in your initialize()
+	//		method. 
+	constructor: function(){
+	},
+	
+	// SUCCESS: String
+	//	Flag that indicates a put() call to a 
+	//	storage provider was succesful.
+	SUCCESS: "success",
+	
+	// FAILED: String
+	//	Flag that indicates a put() call to 
+	//	a storage provider failed.
+	FAILED: "failed",
+	
+	// PENDING: String
+	//	Flag that indicates a put() call to a 
+	//	storage provider is pending user approval.
+	PENDING: "pending",
+	
+	// SIZE_NOT_AVAILABLE: String
+	//	Returned by getMaximumSize() if this storage provider can not determine
+	//	the maximum amount of data it can support. 
+	SIZE_NOT_AVAILABLE: "Size not available",
+	
+	// SIZE_NO_LIMIT: String
+	//	Returned by getMaximumSize() if this storage provider has no theoretical
+	//	limit on the amount of data it can store. 
+	SIZE_NO_LIMIT: "No size limit",
+
+	// DEFAULT_NAMESPACE: String
+	//	The namespace for all storage operations. This is useful if several
+	//	applications want access to the storage system from the same domain but
+	//	want different storage silos. 
+	DEFAULT_NAMESPACE: "default",
+	
+	// onHideSettingsUI: Function
+	//	If a function is assigned to this property, then when the settings
+	//	provider's UI is closed this function is called. Useful, for example,
+	//	if the user has just cleared out all storage for this provider using
+	//	the settings UI, and you want to update your UI.
+	onHideSettingsUI: null,
+
+	initialize: function(){
+		// summary: 
+		//		Allows this storage provider to initialize itself. This is
+		//		called after the page has finished loading, so you can not do
+		//		document.writes(). Storage Provider subclasses should initialize
+		//		themselves inside of here rather than in their function
+		//		constructor.
+		console.warn("dojox.storage.initialize not implemented");
+	},
+	
+	isAvailable: function(){ /*Boolean*/
+		// summary: 
+		//		Returns whether this storage provider is available on this
+		//		platform. 
+		console.warn("dojox.storage.isAvailable not implemented");
+	},
+
+	put: function(	/*string*/ key,
+					/*object*/ value, 
+					/*function*/ resultsHandler,
+					/*string?*/ namespace){
+		// summary:
+		//		Puts a key and value into this storage system.
+		// description:
+		//		Example-
+		//			var resultsHandler = function(status, key, message){
+		//			  alert("status="+status+", key="+key+", message="+message);
+		//			};
+		//			dojox.storage.put("test", "hello world", resultsHandler);
+		//	
+		//		Important note: if you are using Dojo Storage in conjunction with
+		//		Dojo Offline, then you don't need to provide
+		//		a resultsHandler; this is because for Dojo Offline we 
+		//		use Google Gears to persist data, which has unlimited data
+		//		once the user has given permission. If you are using Dojo
+		//		Storage apart from Dojo Offline, then under the covers hidden
+		//		Flash might be used, which is both asychronous and which might
+		//		get denied; in this case you must provide a resultsHandler.
+		// key:
+		//		A string key to use when retrieving this value in the future.
+		// value:
+		//		A value to store; this can be any JavaScript type.
+		// resultsHandler:
+		//		A callback function that will receive three arguments. The
+		//		first argument is one of three values: dojox.storage.SUCCESS,
+		//		dojox.storage.FAILED, or dojox.storage.PENDING; these values
+		//		determine how the put request went. In some storage systems
+		//		users can deny a storage request, resulting in a
+		//		dojox.storage.FAILED, while in other storage systems a storage
+		//		request must wait for user approval, resulting in a
+		//		dojox.storage.PENDING status until the request is either
+		//		approved or denied, resulting in another call back with
+		//		dojox.storage.SUCCESS. 
+		//		The second argument in the call back is the key name that was being stored.
+		//		The third argument in the call back is an optional message that
+		//		details possible error messages that might have occurred during
+		//		the storage process.
+		//	namespace:
+		//		Optional string namespace that this value will be placed into;
+		//		if left off, the value will be placed into dojox.storage.DEFAULT_NAMESPACE
+		
+		console.warn("dojox.storage.put not implemented");
+	},
+
+	get: function(/*string*/ key, /*string?*/ namespace){ /*Object*/
+		// summary:
+		//		Gets the value with the given key. Returns null if this key is
+		//		not in the storage system.
+		// key:
+		//		A string key to get the value of.
+		//	namespace:
+		//		Optional string namespace that this value will be retrieved from;
+		//		if left off, the value will be retrieved from dojox.storage.DEFAULT_NAMESPACE
+		// return: Returns any JavaScript object type; null if the key is not present
+		console.warn("dojox.storage.get not implemented");
+	},
+
+	hasKey: function(/*string*/ key, /*string?*/ namespace){
+		// summary: Determines whether the storage has the given key. 
+		return !!this.get(key, namespace); // Boolean
+	},
+
+	getKeys: function(/*string?*/ namespace){ /*Array*/
+		// summary: Enumerates all of the available keys in this storage system.
+		// return: Array of available keys
+		console.warn("dojox.storage.getKeys not implemented");
+	},
+	
+	clear: function(/*string?*/ namespace){
+		// summary: 
+		//		Completely clears this storage system of all of it's values and
+		//		keys. If 'namespace' is provided just clears the keys in that
+		//		namespace.
+		console.warn("dojox.storage.clear not implemented");
+	},
+  
+	remove: function(/*string*/ key, /*string?*/ namespace){
+		// summary: Removes the given key from this storage system.
+		console.warn("dojox.storage.remove not implemented");
+	},
+	
+	getNamespaces: function(){ /*string[]*/
+		console.warn("dojox.storage.getNamespaces not implemented");
+	},
+
+	isPermanent: function(){ /*Boolean*/
+		// summary:
+		//		Returns whether this storage provider's values are persisted
+		//		when this platform is shutdown. 
+		console.warn("dojox.storage.isPermanent not implemented");
+	},
+
+	getMaximumSize: function(){ /* mixed */
+		// summary: The maximum storage allowed by this provider
+		// returns: 
+		//	Returns the maximum storage size 
+		//	supported by this provider, in 
+		//	thousands of bytes (i.e., if it 
+		//	returns 60 then this means that 60K 
+		//	of storage is supported).
+		//
+		//	If this provider can not determine 
+		//	it's maximum size, then 
+		//	dojox.storage.SIZE_NOT_AVAILABLE is 
+		//	returned; if there is no theoretical
+		//	limit on the amount of storage 
+		//	this provider can return, then
+		//	dojox.storage.SIZE_NO_LIMIT is 
+		//	returned
+		console.warn("dojox.storage.getMaximumSize not implemented");
+	},
+		
+	putMultiple: function(	/*array*/ keys,
+							/*array*/ values, 
+							/*function*/ resultsHandler,
+							/*string?*/ namespace){
+		// summary:
+		//		Puts multiple keys and values into this storage system.
+		// description:
+		//		Example-
+		//			var resultsHandler = function(status, key, message){
+		//			  alert("status="+status+", key="+key+", message="+message);
+		//			};
+		//			dojox.storage.put(["test"], ["hello world"], resultsHandler);
+		//	
+		//		Important note: if you are using Dojo Storage in conjunction with
+		//		Dojo Offline, then you don't need to provide
+		//		a resultsHandler; this is because for Dojo Offline we 
+		//		use Google Gears to persist data, which has unlimited data
+		//		once the user has given permission. If you are using Dojo
+		//		Storage apart from Dojo Offline, then under the covers hidden
+		//		Flash might be used, which is both asychronous and which might
+		//		get denied; in this case you must provide a resultsHandler.
+		// keys:
+		//		An array of string keys to use when retrieving this value in the future,
+		//		one per value to be stored
+		// values:
+		//		An array of values to store; this can be any JavaScript type, though the
+		//		performance of plain strings is considerably better
+		// resultsHandler:
+		//		A callback function that will receive three arguments. The
+		//		first argument is one of three values: dojox.storage.SUCCESS,
+		//		dojox.storage.FAILED, or dojox.storage.PENDING; these values
+		//		determine how the put request went. In some storage systems
+		//		users can deny a storage request, resulting in a
+		//		dojox.storage.FAILED, while in other storage systems a storage
+		//		request must wait for user approval, resulting in a
+		//		dojox.storage.PENDING status until the request is either
+		//		approved or denied, resulting in another call back with
+		//		dojox.storage.SUCCESS. 
+		//		The second argument in the call back is the key name that was being stored.
+		//		The third argument in the call back is an optional message that
+		//		details possible error messages that might have occurred during
+		//		the storage process.
+		//	namespace:
+		//		Optional string namespace that this value will be placed into;
+		//		if left off, the value will be placed into dojox.storage.DEFAULT_NAMESPACE
+		
+		console.warn("dojox.storage.putMultiple not implemented");
+		//	JAC: We could implement a 'default' puMultiple here by just doing 
+		//  each put individually
+	},
+
+	getMultiple: function(/*array*/ keys, /*string?*/ namespace){ /*Object*/
+		// summary:
+		//		Gets the valuse corresponding to each of the given keys. 
+		//		Returns a null array element for each given key that is
+		//		not in the storage system.
+		// keys:
+		//		An array of string keys to get the value of.
+		//	namespace:
+		//		Optional string namespace that this value will be retrieved from;
+		//		if left off, the value will be retrieved from dojox.storage.DEFAULT_NAMESPACE
+		// return: Returns any JavaScript object type; null if the key is not present
+
+		console.warn("dojox.storage.getMultiple not implemented");
+		//	JAC: We could implement a 'default' getMultiple here by just 
+		//  doing each get individually
+	},
+
+	removeMultiple: function(/*array*/ keys, /*string?*/ namespace) {
+		// summary: Removes the given keys from this storage system.
+
+		//	JAC: We could implement a 'default' removeMultiple here by just 
+		//  doing each remove individually
+		console.warn("dojox.storage.remove not implemented");
+	},
+	
+	isValidKeyArray: function( keys) {
+		if(keys === null || keys === undefined || !dojo.isArray(keys)){
+			return false;
+		}
+
+		//	JAC: This could be optimized by running the key validity test 
+		//  directly over a joined string
+		return !dojo.some(keys, function(key){
+			return !this.isValidKey(key);
+		}); // Boolean
+	},
+
+	hasSettingsUI: function(){ /*Boolean*/
+		// summary: Determines whether this provider has a settings UI.
+		return false;
+	},
+
+	showSettingsUI: function(){
+		// summary: If this provider has a settings UI, determined
+		// by calling hasSettingsUI(), it is shown. 
+		console.warn("dojox.storage.showSettingsUI not implemented");
+	},
+
+	hideSettingsUI: function(){
+		// summary: If this provider has a settings UI, hides it.
+		console.warn("dojox.storage.hideSettingsUI not implemented");
+	},
+	
+	isValidKey: function(/*string*/ keyName){ /*Boolean*/
+		// summary:
+		//		Subclasses can call this to ensure that the key given is valid
+		//		in a consistent way across different storage providers. We use
+		//		the lowest common denominator for key values allowed: only
+		//		letters, numbers, and underscores are allowed. No spaces. 
+		if(keyName === null || keyName === undefined){
+			return false;
+		}
+			
+		return /^[0-9A-Za-z_]*$/.test(keyName);
+	},
+	
+	getResourceList: function(){ /* Array[] */
+		// summary:
+		//	Returns a list of URLs that this
+		//	storage provider might depend on.
+		// description:
+		//	This method returns a list of URLs that this
+		//	storage provider depends on to do its work.
+		//	This list is used by the Dojo Offline Toolkit
+		//	to cache these resources to ensure the machinery
+		//	used by this storage provider is available offline.
+		//	What is returned is an array of URLs.
+		//  Note that Dojo Offline uses Gears as its native 
+		//  storage provider, and does not support using other
+		//  kinds of storage providers while offline anymore.
+		
+		return [];
+	}
+});
+
+}
+
+if(!dojo._hasResource["dojox.storage.manager"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage.manager"] = true;
+dojo.provide("dojox.storage.manager");
+//dojo.require("dojo.AdapterRegistry");
+// FIXME: refactor this to use an AdapterRegistry
+
+dojox.storage.manager = new function(){
+	// summary: A singleton class in charge of the dojox.storage system
+	// description:
+	//		Initializes the storage systems and figures out the best available 
+	//		storage options on this platform.	
+	
+	// currentProvider: Object
+	//	The storage provider that was automagically chosen to do storage
+	//	on this platform, such as dojox.storage.FlashStorageProvider.
+	this.currentProvider = null;
+	
+	// available: Boolean
+	//	Whether storage of some kind is available.
+	this.available = false;
+
+  // providers: Array
+  //  Array of all the static provider instances, useful if you want to
+  //  loop through and see what providers have been registered.
+  this.providers = [];
+	
+	this._initialized = false;
+
+	this._onLoadListeners = [];
+	
+	this.initialize = function(){
+		// summary: 
+		//		Initializes the storage system and autodetects the best storage
+		//		provider we can provide on this platform
+		this.autodetect();
+	};
+	
+	this.register = function(/*string*/ name, /*Object*/ instance){
+		// summary:
+		//		Registers the existence of a new storage provider; used by
+		//		subclasses to inform the manager of their existence. The
+		//		storage manager will select storage providers based on 
+		//		their ordering, so the order in which you call this method
+		//		matters. 
+		// name:
+		//		The full class name of this provider, such as
+		//		"dojox.storage.FlashStorageProvider".
+		// instance:
+		//		An instance of this provider, which we will use to call
+		//		isAvailable() on. 
+		
+		// keep list of providers as a list so that we can know what order
+		// storage providers are preferred; also, store the providers hashed
+		// by name in case someone wants to get a provider that uses
+		// a particular storage backend
+		this.providers.push(instance);
+		this.providers[name] = instance;
+	};
+	
+	this.setProvider = function(storageClass){
+		// summary:
+		//		Instructs the storageManager to use the given storage class for
+		//		all storage requests.
+		// description:
+		//		Example-
+		//			dojox.storage.setProvider(
+		//				dojox.storage.IEStorageProvider)
+	
+	};
+	
+	this.autodetect = function(){
+		// summary:
+		//		Autodetects the best possible persistent storage provider
+		//		available on this platform. 
+		
+		//console.debug("dojox.storage.manager.autodetect");
+		
+		if(this._initialized){ // already finished
+			return;
+		}
+
+		// a flag to force the storage manager to use a particular 
+		// storage provider type, such as 
+		// djConfig = {forceStorageProvider: "dojox.storage.WhatWGStorageProvider"};
+		var forceProvider = dojo.config["forceStorageProvider"] || false;
+
+		// go through each provider, seeing if it can be used
+		var providerToUse;
+		//FIXME: use dojo.some
+		for(var i = 0; i < this.providers.length; i++){
+			providerToUse = this.providers[i];
+			if(forceProvider && forceProvider == providerToUse.declaredClass){
+				// still call isAvailable for this provider, since this helps some
+				// providers internally figure out if they are available
+				// FIXME: This should be refactored since it is non-intuitive
+				// that isAvailable() would initialize some state
+				providerToUse.isAvailable();
+				break;
+			}else if(!forceProvider && providerToUse.isAvailable()){
+				break;
+			}
+		}
+		
+		if(!providerToUse){ // no provider available
+			this._initialized = true;
+			this.available = false;
+			this.currentProvider = null;
+			console.warn("No storage provider found for this platform");
+			this.loaded();
+			return;
+		}
+			
+		// create this provider and mix in it's properties
+		// so that developers can do dojox.storage.put rather
+		// than dojox.storage.currentProvider.put, for example
+		this.currentProvider = providerToUse;
+		dojo.mixin(dojox.storage, this.currentProvider);
+		
+		// have the provider initialize itself
+		dojox.storage.initialize();
+		
+		this._initialized = true;
+		this.available = true;
+	};
+	
+	this.isAvailable = function(){ /*Boolean*/
+		// summary: Returns whether any storage options are available.
+		return this.available;
+	};
+	
+	this.addOnLoad = function(func){ /* void */
+		// summary:
+		//		Adds an onload listener to know when Dojo Offline can be used.
+		// description:
+		//		Adds a listener to know when Dojo Offline can be used. This
+		//		ensures that the Dojo Offline framework is loaded and that the
+		//		local dojox.storage system is ready to be used. This method is
+		//		useful if you don't want to have a dependency on Dojo Events
+		//		when using dojox.storage.
+		// func: Function
+		//		A function to call when Dojo Offline is ready to go
+		this._onLoadListeners.push(func);
+		
+		if(this.isInitialized()){
+			this._fireLoaded();
+		}
+	};
+	
+	this.removeOnLoad = function(func){ /* void */
+		// summary: Removes the given onLoad listener
+		for(var i = 0; i < this._onLoadListeners.length; i++){
+			if(func == this._onLoadListeners[i]){
+				this._onLoadListeners = this._onLoadListeners.splice(i, 1);
+				break;
+			}
+		}
+	};
+	
+	this.isInitialized = function(){ /*Boolean*/
+	 	// summary:
+		//		Returns whether the storage system is initialized and ready to
+		//		be used. 
+
+		// FIXME: This should REALLY not be in here, but it fixes a tricky
+		// Flash timing bug.
+		// Confirm that this is still needed with the newly refactored Dojo
+		// Flash. Used to be for Internet Explorer. -- Brad Neuberg
+		if(this.currentProvider != null
+			&& this.currentProvider.declaredClass == "dojox.storage.FlashStorageProvider" 
+			&& dojox.flash.ready == false){
+			return false;
+		}else{
+			return this._initialized;
+		}
+	};
+
+	this.supportsProvider = function(/*string*/ storageClass){ /* Boolean */
+		// summary: Determines if this platform supports the given storage provider.
+		// description:
+		//		Example-
+		//			dojox.storage.manager.supportsProvider(
+		//				"dojox.storage.InternetExplorerStorageProvider");
+
+		// construct this class dynamically
+		try{
+			// dynamically call the given providers class level isAvailable()
+			// method
+			var provider = eval("new " + storageClass + "()");
+			var results = provider.isAvailable();
+			if(!results){ return false; }
+			return results;
+		}catch(e){
+			return false;
+		}
+	};
+
+	this.getProvider = function(){ /* Object */
+		// summary: Gets the current provider
+		return this.currentProvider;
+	};
+	
+	this.loaded = function(){
+		// summary:
+		//		The storage provider should call this method when it is loaded
+		//		and ready to be used. Clients who will use the provider will
+		//		connect to this method to know when they can use the storage
+		//		system. You can either use dojo.connect to connect to this
+		//		function, or can use dojox.storage.manager.addOnLoad() to add
+		//		a listener that does not depend on the dojo.event package.
+		// description:
+		//		Example 1-
+		//			if(dojox.storage.manager.isInitialized() == false){ 
+		//				dojo.connect(dojox.storage.manager, "loaded", TestStorage, "initialize");
+		//			}else{
+		//				dojo.connect(dojo, "loaded", TestStorage, "initialize");
+		//			}
+		//		Example 2-
+		//			dojox.storage.manager.addOnLoad(someFunction);
+
+
+		// FIXME: we should just provide a Deferred for this. That way you
+		// don't care when this happens or has happened. Deferreds are in Base
+		this._fireLoaded();
+	};
+	
+	this._fireLoaded = function(){
+		//console.debug("dojox.storage.manager._fireLoaded");
+		
+		dojo.forEach(this._onLoadListeners, function(i){ 
+			try{ 
+				i(); 
+			}catch(e){ console.debug(e); } 
+		});
+	};
+	
+	this.getResourceList = function(){
+		// summary:
+		//		Returns a list of whatever resources are necessary for storage
+		//		providers to work. 
+		// description:
+		//		This will return all files needed by all storage providers for
+		//		this particular environment type. For example, if we are in the
+		//		browser environment, then this will return the hidden SWF files
+		//		needed by the FlashStorageProvider, even if we don't need them
+		//		for the particular browser we are working within. This is meant
+		//		to faciliate Dojo Offline, which must retrieve all resources we
+		//		need offline into the offline cache -- we retrieve everything
+		//		needed, in case another browser that requires different storage
+		//		mechanisms hits the local offline cache. For example, if we
+		//		were to sync against Dojo Offline on Firefox 2, then we would
+		//		not grab the FlashStorageProvider resources needed for Safari.
+		var results = [];
+		dojo.forEach(dojox.storage.manager.providers, function(currentProvider){
+			results = results.concat(currentProvider.getResourceList());
+		});
+		
+		return results;
+	}
+};
+
+}
+
+if(!dojo._hasResource["dojox._sql._crypto"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox._sql._crypto"] = true;
+// Taken from http://www.movable-type.co.uk/scripts/aes.html by
+// Chris Veness (CLA signed); adapted for Dojo and Google Gears Worker Pool
+// by Brad Neuberg, bkn3@columbia.edu
+
+dojo.provide("dojox._sql._crypto");
+
+dojo.mixin(dojox._sql._crypto,{
+	// _POOL_SIZE:
+	//	Size of worker pool to create to help with crypto
+	_POOL_SIZE: 100,
+	
+	encrypt: function(plaintext, password, callback){
+		// summary:
+		//	Use Corrected Block TEA to encrypt plaintext using password
+		//	(note plaintext & password must be strings not string objects).
+		//	Results will be returned to the 'callback' asychronously.	
+		this._initWorkerPool();
+	
+		var msg ={plaintext: plaintext, password: password};
+		msg = dojo.toJson(msg);
+		msg = "encr:" + String(msg);
+	
+		this._assignWork(msg, callback);
+	},
+
+	decrypt: function(ciphertext, password, callback){
+		// summary:
+		//	Use Corrected Block TEA to decrypt ciphertext using password
+		//	(note ciphertext & password must be strings not string objects).
+		//	Results will be returned to the 'callback' asychronously.
+		this._initWorkerPool();
+	
+		var msg ={ciphertext: ciphertext, password: password};
+		msg = dojo.toJson(msg);
+		msg = "decr:" + String(msg);
+	
+		this._assignWork(msg, callback);
+	},
+	
+	_initWorkerPool: function(){
+		// bugs in Google Gears prevents us from dynamically creating
+		// and destroying workers as we need them -- the worker
+		// pool functionality stops working after a number of crypto
+		// cycles (probably related to a memory leak in Google Gears).
+		// this is too bad, since it results in much simpler code.
+	
+		// instead, we have to create a pool of workers and reuse them. we
+		// keep a stack of 'unemployed' Worker IDs that are currently not working.
+		// if a work request comes in, we pop off the 'unemployed' stack
+		// and put them to work, storing them in an 'employed' hashtable,
+		// keyed by their Worker ID with the value being the callback function
+		// that wants the result. when an employed worker is done, we get
+		// a message in our 'manager' which adds this worker back to the 
+		// unemployed stack and routes the result to the callback that
+		// wanted it. if all the workers were employed in the past but
+		// more work needed to be done (i.e. it's a tight labor pool ;) 
+		// then the work messages are pushed onto
+		// a 'handleMessage' queue as an object tuple{msg: msg, callback: callback}
+	
+		if(!this._manager){
+			try{
+				this._manager = google.gears.factory.create("beta.workerpool", "1.0");
+				this._unemployed = [];
+				this._employed ={};
+				this._handleMessage = [];
+			
+				var self = this;
+				this._manager.onmessage = function(msg, sender){
+					// get the callback necessary to serve this result
+					var callback = self._employed["_" + sender];
+				
+					// make this worker unemployed
+					self._employed["_" + sender] = undefined;
+					self._unemployed.push("_" + sender);
+				
+					// see if we need to assign new work
+					// that was queued up needing to be done
+					if(self._handleMessage.length){
+						var handleMe = self._handleMessage.shift();
+						self._assignWork(handleMe.msg, handleMe.callback);
+					}
+				
+					// return results
+					callback(msg);
+				}
+				
+				var workerInit = "function _workerInit(){"
+									+ "gearsWorkerPool.onmessage = "
+										+ String(this._workerHandler)
+									+ ";"
+								+ "}";
+			
+				var code = workerInit + " _workerInit();";
+	
+				// create our worker pool
+				for(var i = 0; i < this._POOL_SIZE; i++){
+					this._unemployed.push("_" + this._manager.createWorker(code));
+				}
+			}catch(exp){
+				throw exp.message||exp;
+			}
+		}
+	},
+
+	_assignWork: function(msg, callback){
+		// can we immediately assign this work?
+		if(!this._handleMessage.length && this._unemployed.length){
+			// get an unemployed worker
+			var workerID = this._unemployed.shift().substring(1); // remove _
+		
+			// list this worker as employed
+			this._employed["_" + workerID] = callback;
+		
+			// do the worke
+			this._manager.sendMessage(msg, workerID);
+		}else{
+			// we have to queue it up
+			this._handleMessage ={msg: msg, callback: callback};
+		}
+	},
+
+	_workerHandler: function(msg, sender){
+		
+		/* Begin AES Implementation */
+		
+		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+		
+		// Sbox is pre-computed multiplicative inverse in GF(2^8) used in SubBytes and KeyExpansion [§5.1.1]
+		var Sbox =	[0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
+					 0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
+					 0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
+					 0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
+					 0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
+					 0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
+					 0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
+					 0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
+					 0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
+					 0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
+					 0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
+					 0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
+					 0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
+					 0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
+					 0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
+					 0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16];
+
+		// Rcon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
+		var Rcon = [ [0x00, 0x00, 0x00, 0x00],
+					 [0x01, 0x00, 0x00, 0x00],
+					 [0x02, 0x00, 0x00, 0x00],
+					 [0x04, 0x00, 0x00, 0x00],
+					 [0x08, 0x00, 0x00, 0x00],
+					 [0x10, 0x00, 0x00, 0x00],
+					 [0x20, 0x00, 0x00, 0x00],
+					 [0x40, 0x00, 0x00, 0x00],
+					 [0x80, 0x00, 0x00, 0x00],
+					 [0x1b, 0x00, 0x00, 0x00],
+					 [0x36, 0x00, 0x00, 0x00] ]; 
+
+		/*
+		 * AES Cipher function: encrypt 'input' with Rijndael algorithm
+		 *
+		 *	 takes	 byte-array 'input' (16 bytes)
+		 *			 2D byte-array key schedule 'w' (Nr+1 x Nb bytes)
+		 *
+		 *	 applies Nr rounds (10/12/14) using key schedule w for 'add round key' stage
+		 *
+		 *	 returns byte-array encrypted value (16 bytes)
+		 */
+		function Cipher(input, w) {	   // main Cipher function [§5.1]
+		  var Nb = 4;				// block size (in words): no of columns in state (fixed at 4 for AES)
+		  var Nr = w.length/Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys
+
+		  var state = [[],[],[],[]];  // initialise 4xNb byte-array 'state' with input [§3.4]
+		  for (var i=0; i<4*Nb; i++) state[i%4][Math.floor(i/4)] = input[i];
+
+		  state = AddRoundKey(state, w, 0, Nb);
+
+		  for (var round=1; round<Nr; round++) {
+			state = SubBytes(state, Nb);
+			state = ShiftRows(state, Nb);
+			state = MixColumns(state, Nb);
+			state = AddRoundKey(state, w, round, Nb);
+		  }
+
+		  state = SubBytes(state, Nb);
+		  state = ShiftRows(state, Nb);
+		  state = AddRoundKey(state, w, Nr, Nb);
+
+		  var output = new Array(4*Nb);	 // convert state to 1-d array before returning [§3.4]
+		  for (var i=0; i<4*Nb; i++) output[i] = state[i%4][Math.floor(i/4)];
+		  return output;
+		}
+
+
+		function SubBytes(s, Nb) {	  // apply SBox to state S [§5.1.1]
+		  for (var r=0; r<4; r++) {
+			for (var c=0; c<Nb; c++) s[r][c] = Sbox[s[r][c]];
+		  }
+		  return s;
+		}
+
+
+		function ShiftRows(s, Nb) {	   // shift row r of state S left by r bytes [§5.1.2]
+		  var t = new Array(4);
+		  for (var r=1; r<4; r++) {
+			for (var c=0; c<4; c++) t[c] = s[r][(c+r)%Nb];	// shift into temp copy
+			for (var c=0; c<4; c++) s[r][c] = t[c];			// and copy back
+		  }			 // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
+		  return s;	 // see fp.gladman.plus.com/cryptography_technology/rijndael/aes.spec.311.pdf 
+		}
+
+
+		function MixColumns(s, Nb) {   // combine bytes of each col of state S [§5.1.3]
+		  for (var c=0; c<4; c++) {
+			var a = new Array(4);  // 'a' is a copy of the current column from 's'
+			var b = new Array(4);  // 'b' is a•{02} in GF(2^8)
+			for (var i=0; i<4; i++) {
+			  a[i] = s[i][c];
+			  b[i] = s[i][c]&0x80 ? s[i][c]<<1 ^ 0x011b : s[i][c]<<1;
+			}
+			// a[n] ^ b[n] is a•{03} in GF(2^8)
+			s[0][c] = b[0] ^ a[1] ^ b[1] ^ a[2] ^ a[3]; // 2*a0 + 3*a1 + a2 + a3
+			s[1][c] = a[0] ^ b[1] ^ a[2] ^ b[2] ^ a[3]; // a0 * 2*a1 + 3*a2 + a3
+			s[2][c] = a[0] ^ a[1] ^ b[2] ^ a[3] ^ b[3]; // a0 + a1 + 2*a2 + 3*a3
+			s[3][c] = a[0] ^ b[0] ^ a[1] ^ a[2] ^ b[3]; // 3*a0 + a1 + a2 + 2*a3
+		  }
+		  return s;
+		}
+
+
+		function AddRoundKey(state, w, rnd, Nb) {  // xor Round Key into state S [§5.1.4]
+		  for (var r=0; r<4; r++) {
+			for (var c=0; c<Nb; c++) state[r][c] ^= w[rnd*4+c][r];
+		  }
+		  return state;
+		}
+
+
+		function KeyExpansion(key) {  // generate Key Schedule (byte-array Nr+1 x Nb) from Key [§5.2]
+		  var Nb = 4;			 // block size (in words): no of columns in state (fixed at 4 for AES)
+		  var Nk = key.length/4	 // key length (in words): 4/6/8 for 128/192/256-bit keys
+		  var Nr = Nk + 6;		 // no of rounds: 10/12/14 for 128/192/256-bit keys
+
+		  var w = new Array(Nb*(Nr+1));
+		  var temp = new Array(4);
+
+		  for (var i=0; i<Nk; i++) {
+			var r = [key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]];
+			w[i] = r;
+		  }
+
+		  for (var i=Nk; i<(Nb*(Nr+1)); i++) {
+			w[i] = new Array(4);
+			for (var t=0; t<4; t++) temp[t] = w[i-1][t];
+			if (i % Nk == 0) {
+			  temp = SubWord(RotWord(temp));
+			  for (var t=0; t<4; t++) temp[t] ^= Rcon[i/Nk][t];
+			} else if (Nk > 6 && i%Nk == 4) {
+			  temp = SubWord(temp);
+			}
+			for (var t=0; t<4; t++) w[i][t] = w[i-Nk][t] ^ temp[t];
+		  }
+
+		  return w;
+		}
+
+		function SubWord(w) {	 // apply SBox to 4-byte word w
+		  for (var i=0; i<4; i++) w[i] = Sbox[w[i]];
+		  return w;
+		}
+
+		function RotWord(w) {	 // rotate 4-byte word w left by one byte
+		  w[4] = w[0];
+		  for (var i=0; i<4; i++) w[i] = w[i+1];
+		  return w;
+		}
+
+		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+
+		/* 
+		 * Use AES to encrypt 'plaintext' with 'password' using 'nBits' key, in 'Counter' mode of operation
+		 *							 - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf
+		 *	 for each block
+		 *	 - outputblock = cipher(counter, key)
+		 *	 - cipherblock = plaintext xor outputblock
+		 */
+		function AESEncryptCtr(plaintext, password, nBits) {
+		  if (!(nBits==128 || nBits==192 || nBits==256)) return '';	 // standard allows 128/192/256 bit keys
+	
+		  // for this example script, generate the key by applying Cipher to 1st 16/24/32 chars of password; 
+		  // for real-world applications, a more secure approach would be to hash the password e.g. with SHA-1
+		  var nBytes = nBits/8;	 // no bytes in key
+		  var pwBytes = new Array(nBytes);
+		  for (var i=0; i<nBytes; i++) pwBytes[i] = password.charCodeAt(i) & 0xff;
+
+		  var key = Cipher(pwBytes, KeyExpansion(pwBytes));
+
+		  key = key.concat(key.slice(0, nBytes-16));  // key is now 16/24/32 bytes long
+
+		  // initialise counter block (NIST SP800-38A §B.2): millisecond time-stamp for nonce in 1st 8 bytes,
+		  // block counter in 2nd 8 bytes
+		  var blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
+		  var counterBlock = new Array(blockSize);	// block size fixed at 16 bytes / 128 bits (Nb=4) for AES
+		  var nonce = (new Date()).getTime();  // milliseconds since 1-Jan-1970
+
+		  // encode nonce in two stages to cater for JavaScript 32-bit limit on bitwise ops
+		  for (var i=0; i<4; i++) counterBlock[i] = (nonce >>> i*8) & 0xff;
+		  for (var i=0; i<4; i++) counterBlock[i+4] = (nonce/0x100000000 >>> i*8) & 0xff; 
+
+		  // generate key schedule - an expansion of the key into distinct Key Rounds for each round
+		  var keySchedule = KeyExpansion(key);
+
+		  var blockCount = Math.ceil(plaintext.length/blockSize);
+		  var ciphertext = new Array(blockCount);  // ciphertext as array of strings
+  
+		  for (var b=0; b<blockCount; b++) {
+			// set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
+			// again done in two stages for 32-bit ops
+			for (var c=0; c<4; c++) counterBlock[15-c] = (b >>> c*8) & 0xff;
+			for (var c=0; c<4; c++) counterBlock[15-c-4] = (b/0x100000000 >>> c*8)
+
+			var cipherCntr = Cipher(counterBlock, keySchedule);	 // -- encrypt counter block --
+	
+			// calculate length of final block:
+			var blockLength = b<blockCount-1 ? blockSize : (plaintext.length-1)%blockSize+1;
+
+			var ct = '';
+			for (var i=0; i<blockLength; i++) {	 // -- xor plaintext with ciphered counter byte-by-byte --
+			  var plaintextByte = plaintext.charCodeAt(b*blockSize+i);
+			  var cipherByte = plaintextByte ^ cipherCntr[i];
+			  ct += String.fromCharCode(cipherByte);
+			}
+			// ct is now ciphertext for this block
+
+			ciphertext[b] = escCtrlChars(ct);  // escape troublesome characters in ciphertext
+		  }
+
+		  // convert the nonce to a string to go on the front of the ciphertext
+		  var ctrTxt = '';
+		  for (var i=0; i<8; i++) ctrTxt += String.fromCharCode(counterBlock[i]);
+		  ctrTxt = escCtrlChars(ctrTxt);
+
+		  // use '-' to separate blocks, use Array.join to concatenate arrays of strings for efficiency
+		  return ctrTxt + '-' + ciphertext.join('-');
+		}
+
+
+		/* 
+		 * Use AES to decrypt 'ciphertext' with 'password' using 'nBits' key, in Counter mode of operation
+		 *
+		 *	 for each block
+		 *	 - outputblock = cipher(counter, key)
+		 *	 - cipherblock = plaintext xor outputblock
+		 */
+		function AESDecryptCtr(ciphertext, password, nBits) {
+		  if (!(nBits==128 || nBits==192 || nBits==256)) return '';	 // standard allows 128/192/256 bit keys
+
+		  var nBytes = nBits/8;	 // no bytes in key
+		  var pwBytes = new Array(nBytes);
+		  for (var i=0; i<nBytes; i++) pwBytes[i] = password.charCodeAt(i) & 0xff;
+		  var pwKeySchedule = KeyExpansion(pwBytes);
+		  var key = Cipher(pwBytes, pwKeySchedule);
+		  key = key.concat(key.slice(0, nBytes-16));  // key is now 16/24/32 bytes long
+
+		  var keySchedule = KeyExpansion(key);
+
+		  ciphertext = ciphertext.split('-');  // split ciphertext into array of block-length strings 
+
+		  // recover nonce from 1st element of ciphertext
+		  var blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
+		  var counterBlock = new Array(blockSize);
+		  var ctrTxt = unescCtrlChars(ciphertext[0]);
+		  for (var i=0; i<8; i++) counterBlock[i] = ctrTxt.charCodeAt(i);
+
+		  var plaintext = new Array(ciphertext.length-1);
+
+		  for (var b=1; b<ciphertext.length; b++) {
+			// set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
+			for (var c=0; c<4; c++) counterBlock[15-c] = ((b-1) >>> c*8) & 0xff;
+			for (var c=0; c<4; c++) counterBlock[15-c-4] = ((b/0x100000000-1) >>> c*8) & 0xff;
+
+			var cipherCntr = Cipher(counterBlock, keySchedule);	 // encrypt counter block
+
+			ciphertext[b] = unescCtrlChars(ciphertext[b]);
+
+			var pt = '';
+			for (var i=0; i<ciphertext[b].length; i++) {
+			  // -- xor plaintext with ciphered counter byte-by-byte --
+			  var ciphertextByte = ciphertext[b].charCodeAt(i);
+			  var plaintextByte = ciphertextByte ^ cipherCntr[i];
+			  pt += String.fromCharCode(plaintextByte);
+			}
+			// pt is now plaintext for this block
+
+			plaintext[b-1] = pt;  // b-1 'cos no initial nonce block in plaintext
+		  }
+
+		  return plaintext.join('');
+		}
+
+		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+
+		function escCtrlChars(str) {  // escape control chars which might cause problems handling ciphertext
+		  return str.replace(/[\0\t\n\v\f\r\xa0!-]/g, function(c) { return '!' + c.charCodeAt(0) + '!'; });
+		}  // \xa0 to cater for bug in Firefox; include '-' to leave it free for use as a block marker
+
+		function unescCtrlChars(str) {	// unescape potentially problematic control characters
+		  return str.replace(/!\d\d?\d?!/g, function(c) { return String.fromCharCode(c.slice(1,-1)); });
+		}
+
+		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
+		
+		function encrypt(plaintext, password){
+			return AESEncryptCtr(plaintext, password, 256);
+		}
+
+		function decrypt(ciphertext, password){	
+			return AESDecryptCtr(ciphertext, password, 256);
+		}
+		
+		/* End AES Implementation */
+		
+		var cmd = msg.substr(0,4);
+		var arg = msg.substr(5);
+		if(cmd == "encr"){
+			arg = eval("(" + arg + ")");
+			var plaintext = arg.plaintext;
+			var password = arg.password;
+			var results = encrypt(plaintext, password);
+			gearsWorkerPool.sendMessage(String(results), sender);
+		}else if(cmd == "decr"){
+			arg = eval("(" + arg + ")");
+			var ciphertext = arg.ciphertext;
+			var password = arg.password;
+			var results = decrypt(ciphertext, password);
+			gearsWorkerPool.sendMessage(String(results), sender);
+		}
+	}
+});
+
+}
+
+if(!dojo._hasResource["dojox._sql.common"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox._sql.common"] = true;
+dojo.provide("dojox._sql.common");
+
+
+
+// summary:
+//	Executes a SQL expression.
+// description:
+// 	There are four ways to call this:
+// 	1) Straight SQL: dojox.sql("SELECT * FROM FOOBAR");
+// 	2) SQL with parameters: dojox.sql("INSERT INTO FOOBAR VALUES (?)", someParam)
+// 	3) Encrypting particular values: 
+//			dojox.sql("INSERT INTO FOOBAR VALUES (ENCRYPT(?))", someParam, "somePassword", callback)
+// 	4) Decrypting particular values:
+//			dojox.sql("SELECT DECRYPT(SOMECOL1), DECRYPT(SOMECOL2) FROM
+//					FOOBAR WHERE SOMECOL3 = ?", someParam,
+//					"somePassword", callback)
+//
+// 	For encryption and decryption the last two values should be the the password for
+// 	encryption/decryption, and the callback function that gets the result set.
+//
+// 	Note: We only support ENCRYPT(?) statements, and
+// 	and DECRYPT(*) statements for now -- you can not have a literal string
+// 	inside of these, such as ENCRYPT('foobar')
+//
+// 	Note: If you have multiple columns to encrypt and decrypt, you can use the following
+// 	convenience form to not have to type ENCRYPT(?)/DECRYPT(*) many times:
+//
+// 	dojox.sql("INSERT INTO FOOBAR VALUES (ENCRYPT(?, ?, ?))", 
+//					someParam1, someParam2, someParam3, 
+//					"somePassword", callback)
+//
+// 	dojox.sql("SELECT DECRYPT(SOMECOL1, SOMECOL2) FROM
+//					FOOBAR WHERE SOMECOL3 = ?", someParam,
+//					"somePassword", callback)
+dojox.sql = new Function("return dojox.sql._exec(arguments);");
+
+dojo.mixin(dojox.sql, {
+	dbName: null,
+	
+	// summary:
+	//	If true, then we print out any SQL that is executed
+	//	to the debug window
+	debug: (dojo.exists("dojox.sql.debug")?dojox.sql.debug:false),
+
+	open: function(dbName){
+		if(this._dbOpen && (!dbName || dbName == this.dbName)){
+			return;
+		}
+		
+		if(!this.dbName){
+			this.dbName = "dot_store_" 
+				+ window.location.href.replace(/[^0-9A-Za-z_]/g, "_");
+			// database names in Gears are limited to 64 characters long
+			if(this.dbName.length > 63){
+			  this.dbName = this.dbName.substring(0, 63);
+			}
+		}
+		
+		if(!dbName){
+			dbName = this.dbName;
+		}
+		
+		try{
+			this._initDb();
+			this.db.open(dbName);
+			this._dbOpen = true;
+		}catch(exp){
+			throw exp.message||exp;
+		}
+	},
+
+	close: function(dbName){
+		// on Internet Explorer, Google Gears throws an exception
+		// "Object not a collection", when we try to close the
+		// database -- just don't close it on this platform
+		// since we are running into a Gears bug; the Gears team
+		// said it's ok to not close a database connection
+		if(dojo.isIE){ return; }
+		
+		if(!this._dbOpen && (!dbName || dbName == this.dbName)){
+			return;
+		}
+		
+		if(!dbName){
+			dbName = this.dbName;
+		}
+		
+		try{
+			this.db.close(dbName);
+			this._dbOpen = false;
+		}catch(exp){
+			throw exp.message||exp;
+		}
+	},
+	
+	_exec: function(params){
+		try{	
+			// get the Gears Database object
+			this._initDb();
+		
+			// see if we need to open the db; if programmer
+			// manually called dojox.sql.open() let them handle
+			// it; otherwise we open and close automatically on
+			// each SQL execution
+			if(!this._dbOpen){
+				this.open();
+				this._autoClose = true;
+			}
+		
+			// determine our parameters
+			var sql = null;
+			var callback = null;
+			var password = null;
+
+			var args = dojo._toArray(params);
+
+			sql = args.splice(0, 1)[0];
+
+			// does this SQL statement use the ENCRYPT or DECRYPT
+			// keywords? if so, extract our callback and crypto
+			// password
+			if(this._needsEncrypt(sql) || this._needsDecrypt(sql)){
+				callback = args.splice(args.length - 1, 1)[0];
+				password = args.splice(args.length - 1, 1)[0];
+			}
+
+			// 'args' now just has the SQL parameters
+
+			// print out debug SQL output if the developer wants that
+			if(this.debug){
+				this._printDebugSQL(sql, args);
+			}
+
+			// handle SQL that needs encryption/decryption differently
+			// do we have an ENCRYPT SQL statement? if so, handle that first
+			if(this._needsEncrypt(sql)){
+				var crypto = new dojox.sql._SQLCrypto("encrypt", sql, 
+													password, args, 
+													callback);
+				return; // encrypted results will arrive asynchronously
+			}else if(this._needsDecrypt(sql)){ // otherwise we have a DECRYPT statement
+				var crypto = new dojox.sql._SQLCrypto("decrypt", sql, 
+													password, args, 
+													callback);
+				return; // decrypted results will arrive asynchronously
+			}
+
+			// execute the SQL and get the results
+			var rs = this.db.execute(sql, args);
+			
+			// Gears ResultSet object's are ugly -- normalize
+			// these into something JavaScript programmers know
+			// how to work with, basically an array of 
+			// JavaScript objects where each property name is
+			// simply the field name for a column of data
+			rs = this._normalizeResults(rs);
+		
+			if(this._autoClose){
+				this.close();
+			}
+		
+			return rs;
+		}catch(exp){
+			exp = exp.message||exp;
+			
+			console.debug("SQL Exception: " + exp);
+			
+			if(this._autoClose){
+				try{ 
+					this.close(); 
+				}catch(e){
+					console.debug("Error closing database: " 
+									+ e.message||e);
+				}
+			}
+		
+			throw exp;
+		}
+	},
+
+	_initDb: function(){
+		if(!this.db){
+			try{
+				this.db = google.gears.factory.create('beta.database', '1.0');
+			}catch(exp){
+				dojo.setObject("google.gears.denied", true);
+				dojox.off.onFrameworkEvent("coreOperationFailed");
+				throw "Google Gears must be allowed to run";
+			}
+		}
+	},
+
+	_printDebugSQL: function(sql, args){
+		var msg = "dojox.sql(\"" + sql + "\"";
+		for(var i = 0; i < args.length; i++){
+			if(typeof args[i] == "string"){
+				msg += ", \"" + args[i] + "\"";
+			}else{
+				msg += ", " + args[i];
+			}
+		}
+		msg += ")";
+	
+		console.debug(msg);
+	},
+
+	_normalizeResults: function(rs){
+		var results = [];
+		if(!rs){ return []; }
+	
+		while(rs.isValidRow()){
+			var row = {};
+		
+			for(var i = 0; i < rs.fieldCount(); i++){
+				var fieldName = rs.fieldName(i);
+				var fieldValue = rs.field(i);
+				row[fieldName] = fieldValue;
+			}
+		
+			results.push(row);
+		
+			rs.next();
+		}
+	
+		rs.close();
+		
+		return results;
+	},
+
+	_needsEncrypt: function(sql){
+		return /encrypt\([^\)]*\)/i.test(sql);
+	},
+
+	_needsDecrypt: function(sql){
+		return /decrypt\([^\)]*\)/i.test(sql);
+	}
+});
+
+// summary:
+//	A private class encapsulating any cryptography that must be done
+// 	on a SQL statement. We instantiate this class and have it hold
+//	it's state so that we can potentially have several encryption
+//	operations happening at the same time by different SQL statements.
+dojo.declare("dojox.sql._SQLCrypto", null, {
+	constructor: function(action, sql, password, args, callback){
+		if(action == "encrypt"){
+			this._execEncryptSQL(sql, password, args, callback);
+		}else{
+			this._execDecryptSQL(sql, password, args, callback);
+		}		
+	}, 
+	
+	_execEncryptSQL: function(sql, password, args, callback){
+		// strip the ENCRYPT/DECRYPT keywords from the SQL
+		var strippedSQL = this._stripCryptoSQL(sql);
+	
+		// determine what arguments need encryption
+		var encryptColumns = this._flagEncryptedArgs(sql, args);
+	
+		// asynchronously encrypt each argument that needs it
+		var self = this;
+		this._encrypt(strippedSQL, password, args, encryptColumns, function(finalArgs){
+			// execute the SQL
+			var error = false;
+			var resultSet = [];
+			var exp = null;
+			try{
+				resultSet = dojox.sql.db.execute(strippedSQL, finalArgs);
+			}catch(execError){
+				error = true;
+				exp = execError.message||execError;
+			}
+		
+			// was there an error during SQL execution?
+			if(exp != null){
+				if(dojox.sql._autoClose){
+					try{ dojox.sql.close(); }catch(e){}
+				}
+			
+				callback(null, true, exp.toString());
+				return;
+			}
+		
+			// normalize SQL results into a JavaScript object 
+			// we can work with
+			resultSet = dojox.sql._normalizeResults(resultSet);
+		
+			if(dojox.sql._autoClose){
+				dojox.sql.close();
+			}
+				
+			// are any decryptions necessary on the result set?
+			if(dojox.sql._needsDecrypt(sql)){
+				// determine which of the result set columns needs decryption
+	 			var needsDecrypt = self._determineDecryptedColumns(sql);
+
+				// now decrypt columns asynchronously
+				// decrypt columns that need it
+				self._decrypt(resultSet, needsDecrypt, password, function(finalResultSet){
+					callback(finalResultSet, false, null);
+				});
+			}else{
+				callback(resultSet, false, null);
+			}
+		});
+	},
+
+	_execDecryptSQL: function(sql, password, args, callback){
+		// strip the ENCRYPT/DECRYPT keywords from the SQL
+		var strippedSQL = this._stripCryptoSQL(sql);
+	
+		// determine which columns needs decryption; this either
+		// returns the value *, which means all result set columns will
+		// be decrypted, or it will return the column names that need
+		// decryption set on a hashtable so we can quickly test a given
+		// column name; the key is the column name that needs
+		// decryption and the value is 'true' (i.e. needsDecrypt["someColumn"] 
+		// would return 'true' if it needs decryption, and would be 'undefined'
+		// or false otherwise)
+		var needsDecrypt = this._determineDecryptedColumns(sql);
+	
+		// execute the SQL
+		var error = false;
+		var resultSet = [];
+		var exp = null;
+		try{
+			resultSet = dojox.sql.db.execute(strippedSQL, args);
+		}catch(execError){
+			error = true;
+			exp = execError.message||execError;
+		}
+	
+		// was there an error during SQL execution?
+		if(exp != null){
+			if(dojox.sql._autoClose){
+				try{ dojox.sql.close(); }catch(e){}
+			}
+		
+			callback(resultSet, true, exp.toString());
+			return;
+		}
+	
+		// normalize SQL results into a JavaScript object 
+		// we can work with
+		resultSet = dojox.sql._normalizeResults(resultSet);
+	
+		if(dojox.sql._autoClose){
+			dojox.sql.close();
+		}
+	
+		// decrypt columns that need it
+		this._decrypt(resultSet, needsDecrypt, password, function(finalResultSet){
+			callback(finalResultSet, false, null);
+		});
+	},
+
+	_encrypt: function(sql, password, args, encryptColumns, callback){
+		//console.debug("_encrypt, sql="+sql+", password="+password+", encryptColumns="+encryptColumns+", args="+args);
+	
+		this._totalCrypto = 0;
+		this._finishedCrypto = 0;
+		this._finishedSpawningCrypto = false;
+		this._finalArgs = args;
+	
+		for(var i = 0; i < args.length; i++){
+			if(encryptColumns[i]){
+				// we have an encrypt() keyword -- get just the value inside
+				// the encrypt() parantheses -- for now this must be a ?
+				var sqlParam = args[i];
+				var paramIndex = i;
+			
+				// update the total number of encryptions we know must be done asynchronously
+				this._totalCrypto++;
+			
+				// FIXME: This currently uses DES as a proof-of-concept since the
+				// DES code used is quite fast and was easy to work with. Modify dojox.sql
+				// to be able to specify a different encryption provider through a 
+				// a SQL-like syntax, such as dojox.sql("SET ENCRYPTION BLOWFISH"),
+				// and modify the dojox.crypto.Blowfish code to be able to work using
+				// a Google Gears Worker Pool
+			
+				// do the actual encryption now, asychronously on a Gears worker thread
+				dojox._sql._crypto.encrypt(sqlParam, password, dojo.hitch(this, function(results){
+					// set the new encrypted value
+					this._finalArgs[paramIndex] = results;
+					this._finishedCrypto++;
+					// are we done with all encryption?
+					if(this._finishedCrypto >= this._totalCrypto
+						&& this._finishedSpawningCrypto){
+						callback(this._finalArgs);
+					}
+				}));
+			}
+		}
+	
+		this._finishedSpawningCrypto = true;
+	},
+
+	_decrypt: function(resultSet, needsDecrypt, password, callback){
+		//console.debug("decrypt, resultSet="+resultSet+", needsDecrypt="+needsDecrypt+", password="+password);
+		
+		this._totalCrypto = 0;
+		this._finishedCrypto = 0;
+		this._finishedSpawningCrypto = false;
+		this._finalResultSet = resultSet;
+	
+		for(var i = 0; i < resultSet.length; i++){
+			var row = resultSet[i];
+		
+			// go through each of the column names in row,
+			// seeing if they need decryption
+			for(var columnName in row){
+				if(needsDecrypt == "*" || needsDecrypt[columnName]){
+					this._totalCrypto++;
+					var columnValue = row[columnName];
+				
+					// forming a closure here can cause issues, with values not cleanly
+					// saved on Firefox/Mac OS X for some of the values above that
+					// are needed in the callback below; call a subroutine that will form 
+					// a closure inside of itself instead
+					this._decryptSingleColumn(columnName, columnValue, password, i,
+												function(finalResultSet){
+						callback(finalResultSet);
+					});
+				}
+			}
+		}
+	
+		this._finishedSpawningCrypto = true;
+	},
+
+	_stripCryptoSQL: function(sql){
+		// replace all DECRYPT(*) occurrences with a *
+		sql = sql.replace(/DECRYPT\(\*\)/ig, "*");
+	
+		// match any ENCRYPT(?, ?, ?, etc) occurrences,
+		// then replace with just the question marks in the
+		// middle
+		var matches = sql.match(/ENCRYPT\([^\)]*\)/ig);
+		if(matches != null){
+			for(var i = 0; i < matches.length; i++){
+				var encryptStatement = matches[i];
+				var encryptValue = encryptStatement.match(/ENCRYPT\(([^\)]*)\)/i)[1];
+				sql = sql.replace(encryptStatement, encryptValue);
+			}
+		}
+	
+		// match any DECRYPT(COL1, COL2, etc) occurrences,
+		// then replace with just the column names
+		// in the middle
+		matches = sql.match(/DECRYPT\([^\)]*\)/ig);
+		if(matches != null){
+			for(var i = 0; i < matches.length; i++){
+				var decryptStatement = matches[i];
+				var decryptValue = decryptStatement.match(/DECRYPT\(([^\)]*)\)/i)[1];
+				sql = sql.replace(decryptStatement, decryptValue);
+			}
+		}
+	
+		return sql;
+	},
+
+	_flagEncryptedArgs: function(sql, args){
+		// capture literal strings that have question marks in them,
+		// and also capture question marks that stand alone
+		var tester = new RegExp(/([\"][^\"]*\?[^\"]*[\"])|([\'][^\']*\?[^\']*[\'])|(\?)/ig);
+		var matches;
+		var currentParam = 0;
+		var results = [];
+		while((matches = tester.exec(sql)) != null){
+			var currentMatch = RegExp.lastMatch+"";
+
+			// are we a literal string? then ignore it
+			if(/^[\"\']/.test(currentMatch)){
+				continue;
+			}
+
+			// do we have an encrypt keyword to our left?
+			var needsEncrypt = false;
+			if(/ENCRYPT\([^\)]*$/i.test(RegExp.leftContext)){
+				needsEncrypt = true;
+			}
+
+			// set the encrypted flag
+			results[currentParam] = needsEncrypt;
+
+			currentParam++;
+		}
+	
+		return results;
+	},
+
+	_determineDecryptedColumns: function(sql){
+		var results = {};
+
+		if(/DECRYPT\(\*\)/i.test(sql)){
+			results = "*";
+		}else{
+			var tester = /DECRYPT\((?:\s*\w*\s*\,?)*\)/ig;
+			var matches;
+			while(matches = tester.exec(sql)){
+				var lastMatch = new String(RegExp.lastMatch);
+				var columnNames = lastMatch.replace(/DECRYPT\(/i, "");
+				columnNames = columnNames.replace(/\)/, "");
+				columnNames = columnNames.split(/\s*,\s*/);
+				dojo.forEach(columnNames, function(column){
+					if(/\s*\w* AS (\w*)/i.test(column)){
+						column = column.match(/\s*\w* AS (\w*)/i)[1];
+					}
+					results[column] = true;
+				});
+			}
+		}
+
+		return results;
+	},
+
+	_decryptSingleColumn: function(columnName, columnValue, password, currentRowIndex,
+											callback){
+		//console.debug("decryptSingleColumn, columnName="+columnName+", columnValue="+columnValue+", currentRowIndex="+currentRowIndex)
+		dojox._sql._crypto.decrypt(columnValue, password, dojo.hitch(this, function(results){
+			// set the new decrypted value
+			this._finalResultSet[currentRowIndex][columnName] = results;
+			this._finishedCrypto++;
+			
+			// are we done with all encryption?
+			if(this._finishedCrypto >= this._totalCrypto
+				&& this._finishedSpawningCrypto){
+				//console.debug("done with all decrypts");
+				callback(this._finalResultSet);
+			}
+		}));
+	}
+});
+
+}
+
+if(!dojo._hasResource["dojox.sql"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.sql"] = true;
+
+dojo.provide("dojox.sql");
+
+}
+
+if(!dojo._hasResource["dojox.storage.GearsStorageProvider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage.GearsStorageProvider"] = true;
+dojo.provide("dojox.storage.GearsStorageProvider");
+
+
+
+
+if(dojo.isGears){
+	
+	(function(){
+		// make sure we don't define the gears provider if we're not gears
+		// enabled
+		
+		dojo.declare("dojox.storage.GearsStorageProvider", dojox.storage.Provider, {
+			// summary:
+			//		Storage provider that uses the features of Google Gears
+			//		to store data (it is saved into the local SQL database
+			//		provided by Gears, using dojox.sql)
+			// description: 
+			//		You can disable this storage provider with the following djConfig
+			//		variable:
+			//		var djConfig = { disableGearsStorage: true };
+			//		
+			//		Authors of this storage provider-	
+			//			Brad Neuberg, bkn3@columbia.edu 
+			constructor: function(){
+			},
+			// instance methods and properties
+			TABLE_NAME: "__DOJO_STORAGE",
+			initialized: false,
+			
+			_available: null,
+			
+			initialize: function(){
+				//console.debug("dojox.storage.GearsStorageProvider.initialize");
+				if(dojo.config["disableGearsStorage"] == true){
+					return;
+				}
+				
+				// partition our storage data so that multiple apps
+				// on the same host won't collide
+				this.TABLE_NAME = "__DOJO_STORAGE";
+				
+				// create the table that holds our data
+				try{
+					dojox.sql("CREATE TABLE IF NOT EXISTS " + this.TABLE_NAME + "( "
+								+ " namespace TEXT, "
+								+ " key TEXT, "
+								+ " value TEXT "
+								+ ")"
+							);
+					dojox.sql("CREATE UNIQUE INDEX IF NOT EXISTS namespace_key_index" 
+								+ " ON " + this.TABLE_NAME
+								+ " (namespace, key)");
+				}catch(e){
+					console.debug("dojox.storage.GearsStorageProvider.initialize:", e);
+					
+					this.initialized = false; // we were unable to initialize
+					dojox.storage.manager.loaded();
+					return;
+				}
+				
+				// indicate that this storage provider is now loaded
+				this.initialized = true;
+				dojox.storage.manager.loaded();	
+			},
+			
+			isAvailable: function(){
+				// is Google Gears available and defined?
+				return this._available = dojo.isGears;
+			},
+
+			put: function(key, value, resultsHandler, namespace){
+				if(this.isValidKey(key) == false){
+					throw new Error("Invalid key given: " + key);
+				}
+				namespace = namespace||this.DEFAULT_NAMESPACE;
+				
+				// serialize the value;
+				// handle strings differently so they have better performance
+				if(dojo.isString(value)){
+					value = "string:" + value;
+				}else{
+					value = dojo.toJson(value);
+				}
+				
+				// try to store the value	
+				try{
+					dojox.sql("DELETE FROM " + this.TABLE_NAME
+								+ " WHERE namespace = ? AND key = ?",
+								namespace, key);
+					dojox.sql("INSERT INTO " + this.TABLE_NAME
+								+ " VALUES (?, ?, ?)",
+								namespace, key, value);
+				}catch(e){
+					// indicate we failed
+					console.debug("dojox.storage.GearsStorageProvider.put:", e);
+					resultsHandler(this.FAILED, key, e.toString());
+					return;
+				}
+				
+				if(resultsHandler){
+					resultsHandler(dojox.storage.SUCCESS, key, null);
+				}
+			},
+
+			get: function(key, namespace){
+				if(this.isValidKey(key) == false){
+					throw new Error("Invalid key given: " + key);
+				}
+				namespace = namespace||this.DEFAULT_NAMESPACE;
+				
+				// try to find this key in the database
+				var results = dojox.sql("SELECT * FROM " + this.TABLE_NAME
+											+ " WHERE namespace = ? AND "
+											+ " key = ?",
+											namespace, key);
+				if(!results.length){
+					return null;
+				}else{
+					results = results[0].value;
+				}
+				
+				// destringify the content back into a 
+				// real JavaScript object;
+				// handle strings differently so they have better performance
+				if(dojo.isString(results) && (/^string:/.test(results))){
+					results = results.substring("string:".length);
+				}else{
+					results = dojo.fromJson(results);
+				}
+				
+				return results;
+			},
+			
+			getNamespaces: function(){
+				var results = [ dojox.storage.DEFAULT_NAMESPACE ];
+				
+				var rs = dojox.sql("SELECT namespace FROM " + this.TABLE_NAME
+									+ " DESC GROUP BY namespace");
+				for(var i = 0; i < rs.length; i++){
+					if(rs[i].namespace != dojox.storage.DEFAULT_NAMESPACE){
+						results.push(rs[i].namespace);
+					}
+				}
+				
+				return results;
+			},
+
+			getKeys: function(namespace){
+				namespace = namespace||this.DEFAULT_NAMESPACE;
+				if(this.isValidKey(namespace) == false){
+					throw new Error("Invalid namespace given: " + namespace);
+				}
+				
+				var rs = dojox.sql("SELECT key FROM " + this.TABLE_NAME
+									+ " WHERE namespace = ?",
+									namespace);
+				
+				var results = [];
+				for(var i = 0; i < rs.length; i++){
+					results.push(rs[i].key);
+				}
+				
+				return results;
+			},
+
+			clear: function(namespace){
+				if(this.isValidKey(namespace) == false){
+					throw new Error("Invalid namespace given: " + namespace);
+				}
+				namespace = namespace||this.DEFAULT_NAMESPACE;
+				
+				dojox.sql("DELETE FROM " + this.TABLE_NAME 
+							+ " WHERE namespace = ?",
+							namespace);
+			},
+			
+			remove: function(key, namespace){
+				namespace = namespace||this.DEFAULT_NAMESPACE;
+				
+				dojox.sql("DELETE FROM " + this.TABLE_NAME 
+							+ " WHERE namespace = ? AND"
+							+ " key = ?",
+							namespace,
+							key);
+			},
+			
+			putMultiple: function(keys, values, resultsHandler, namespace) {
+ 				if(this.isValidKeyArray(keys) === false 
+						|| ! values instanceof Array 
+						|| keys.length != values.length){
+					throw new Error("Invalid arguments: keys = [" 
+									+ keys + "], values = [" + values + "]");
+				}
+				
+				if(namespace == null || typeof namespace == "undefined"){
+					namespace = dojox.storage.DEFAULT_NAMESPACE;		
+				}
+	
+				if(this.isValidKey(namespace) == false){
+					throw new Error("Invalid namespace given: " + namespace);
+				}
+	
+				this._statusHandler = resultsHandler;
+
+				// try to store the value	
+				try{
+					dojox.sql.open();
+					dojox.sql.db.execute("BEGIN TRANSACTION");
+					var _stmt = "REPLACE INTO " + this.TABLE_NAME + " VALUES (?, ?, ?)";
+					for(var i=0;i<keys.length;i++) {
+						// serialize the value;
+						// handle strings differently so they have better performance
+						var value = values[i];
+						if(dojo.isString(value)){
+							value = "string:" + value;
+						}else{
+							value = dojo.toJson(value);
+						}
+				
+						dojox.sql.db.execute( _stmt,
+							[namespace, keys[i], value]);
+					}
+					dojox.sql.db.execute("COMMIT TRANSACTION");
+					dojox.sql.close();
+				}catch(e){
+					// indicate we failed
+					console.debug("dojox.storage.GearsStorageProvider.putMultiple:", e);
+					if(resultsHandler){
+						resultsHandler(this.FAILED, keys, e.toString());
+					}
+					return;
+				}
+				
+				if(resultsHandler){
+					resultsHandler(dojox.storage.SUCCESS, key, null);
+				}
+			},
+
+			getMultiple: function(keys, namespace){
+				//	TODO: Maybe use SELECT IN instead
+
+				if(this.isValidKeyArray(keys) === false){
+					throw new ("Invalid key array given: " + keys);
+				}
+				
+				if(namespace == null || typeof namespace == "undefined"){
+					namespace = dojox.storage.DEFAULT_NAMESPACE;		
+				}
+				
+				if(this.isValidKey(namespace) == false){
+					throw new Error("Invalid namespace given: " + namespace);
+				}
+		
+				var _stmt = "SELECT * FROM " + this.TABLE_NAME	+ 
+					" WHERE namespace = ? AND "	+ " key = ?";
+				
+				var results = [];
+				for(var i=0;i<keys.length;i++){
+					var result = dojox.sql( _stmt, namespace, keys[i]);
+						
+					if( ! result.length){
+						results[i] = null;
+					}else{
+						result = result[0].value;
+						
+						// destringify the content back into a 
+						// real JavaScript object;
+						// handle strings differently so they have better performance
+						if(dojo.isString(result) && (/^string:/.test(result))){
+							results[i] = result.substring("string:".length);
+						}else{
+							results[i] = dojo.fromJson(result);
+						}
+					}
+				}
+				
+				return results;
+			},
+			
+			removeMultiple: function(keys, namespace){
+				namespace = namespace||this.DEFAULT_NAMESPACE;
+				
+				dojox.sql.open();
+				dojox.sql.db.execute("BEGIN TRANSACTION");
+				var _stmt = "DELETE FROM " + this.TABLE_NAME + " WHERE namespace = ? AND key = ?";
+
+				for(var i=0;i<keys.length;i++){
+					dojox.sql.db.execute( _stmt,
+						[namespace, keys[i]]);
+				}
+				dojox.sql.db.execute("COMMIT TRANSACTION");
+				dojox.sql.close();
+			}, 				
+			
+			isPermanent: function(){ return true; },
+
+			getMaximumSize: function(){ return this.SIZE_NO_LIMIT; },
+
+			hasSettingsUI: function(){ return false; },
+			
+			showSettingsUI: function(){
+				throw new Error(this.declaredClass 
+									+ " does not support a storage settings user-interface");
+			},
+			
+			hideSettingsUI: function(){
+				throw new Error(this.declaredClass 
+									+ " does not support a storage settings user-interface");
+			}
+		});
+
+		// register the existence of our storage providers
+		dojox.storage.manager.register("dojox.storage.GearsStorageProvider",
+										new dojox.storage.GearsStorageProvider());
+	})();
+}
+
+}
+
+if(!dojo._hasResource["dojox.storage.WhatWGStorageProvider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage.WhatWGStorageProvider"] = true;
+dojo.provide("dojox.storage.WhatWGStorageProvider");
+
+
+
+dojo.declare("dojox.storage.WhatWGStorageProvider", [ dojox.storage.Provider ], {
+	// summary:
+	//		Storage provider that uses WHAT Working Group features in Firefox 2 
+	//		to achieve permanent storage.
+	// description: 
+	//		The WHAT WG storage API is documented at 
+	//		http://www.whatwg.org/specs/web-apps/current-work/#scs-client-side
+	//
+	//		You can disable this storage provider with the following djConfig
+	//		variable:
+	//		var djConfig = { disableWhatWGStorage: true };
+	//		
+	//		Authors of this storage provider-	
+	//			JB Boisseau, jb.boisseau@eutech-ssii.com
+	//			Brad Neuberg, bkn3@columbia.edu 
+
+	initialized: false,
+	
+	_domain: null,
+	_available: null,
+	_statusHandler: null,
+	_allNamespaces: null,
+	_storageEventListener: null,
+	
+	initialize: function(){
+		if(dojo.config["disableWhatWGStorage"] == true){
+			return;
+		}
+		
+		// get current domain
+		// see: https://bugzilla.mozilla.org/show_bug.cgi?id=357323
+		this._domain = (location.hostname == "localhost") ? "localhost.localdomain" : location.hostname;
+		// console.debug(this._domain);
+		
+		// indicate that this storage provider is now loaded
+		this.initialized = true;
+		dojox.storage.manager.loaded();	
+	},
+	
+	isAvailable: function(){
+		try{
+			// see: https://bugzilla.mozilla.org/show_bug.cgi?id=357323
+			var myStorage = globalStorage[((location.hostname == "localhost") ? "localhost.localdomain" : location.hostname)];
+		}catch(e){
+			this._available = false;
+			return this._available;
+		}
+		
+		this._available = true;	
+		return this._available;
+	},
+
+	put: function(key, value, resultsHandler, namespace){
+		if(this.isValidKey(key) == false){
+			throw new Error("Invalid key given: " + key);
+		}
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		// get our full key name, which is namespace + key
+		key = this.getFullKey(key, namespace);	
+		
+		this._statusHandler = resultsHandler;
+		
+		// serialize the value;
+		// handle strings differently so they have better performance
+		if(dojo.isString(value)){
+			value = "string:" + value;
+		}else{
+			value = dojo.toJson(value);
+		}
+		
+		// register for successful storage events.
+		var storageListener = dojo.hitch(this, function(evt){
+			// remove any old storage event listener we might have added
+			// to the window on old put() requests; Firefox has a bug
+			// where it can occassionaly go into infinite loops calling
+			// our storage event listener over and over -- this is a 
+			// workaround
+			// FIXME: Simplify this into a test case and submit it
+			// to Firefox
+			window.removeEventListener("storage", storageListener, false);
+			
+			// indicate we succeeded
+			if(resultsHandler){
+				resultsHandler.call(null, this.SUCCESS, key);
+			}
+		});
+		
+		window.addEventListener("storage", storageListener, false);
+		
+		// try to store the value	
+		try{
+			var myStorage = globalStorage[this._domain];
+			myStorage.setItem(key, value);
+		}catch(e){
+			// indicate we failed
+			this._statusHandler.call(null, this.FAILED, key, e.toString());
+		}
+	},
+
+	get: function(key, namespace){
+		if(this.isValidKey(key) == false){
+			throw new Error("Invalid key given: " + key);
+		}
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		// get our full key name, which is namespace + key
+		key = this.getFullKey(key, namespace);
+		
+		// sometimes, even if a key doesn't exist, Firefox
+		// will return a blank string instead of a null --
+		// this _might_ be due to having underscores in the
+		// keyname, but I am not sure.
+		
+		// FIXME: Simplify this bug into a testcase and
+		// submit it to Firefox
+		var myStorage = globalStorage[this._domain];
+		var results = myStorage.getItem(key);
+		
+		if(results == null || results == ""){
+			return null;
+		}
+		
+		results = results.value;
+		
+		// destringify the content back into a 
+		// real JavaScript object;
+		// handle strings differently so they have better performance
+		if(dojo.isString(results) && (/^string:/.test(results))){
+			results = results.substring("string:".length);
+		}else{
+			results = dojo.fromJson(results);
+		}
+		
+		return results;
+	},
+	
+	getNamespaces: function(){
+		var results = [ this.DEFAULT_NAMESPACE ];
+		
+		// simply enumerate through our array and save any string
+		// that starts with __
+		var found = {};
+		var myStorage = globalStorage[this._domain];
+		var tester = /^__([^_]*)_/;
+		for(var i = 0; i < myStorage.length; i++){
+			var currentKey = myStorage.key(i);
+			if(tester.test(currentKey) == true){
+				var currentNS = currentKey.match(tester)[1];
+				// have we seen this namespace before?
+				if(typeof found[currentNS] == "undefined"){
+					found[currentNS] = true;
+					results.push(currentNS);
+				}
+			}
+		}
+		
+		return results;
+	},
+
+	getKeys: function(namespace){
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		if(this.isValidKey(namespace) == false){
+			throw new Error("Invalid namespace given: " + namespace);
+		}
+		
+		// create a regular expression to test the beginning
+		// of our key names to see if they match our namespace;
+		// if it is the default namespace then test for the presence
+		// of no namespace for compatibility with older versions
+		// of dojox.storage
+		var namespaceTester;
+		if(namespace == this.DEFAULT_NAMESPACE){
+			namespaceTester = new RegExp("^([^_]{2}.*)$");	
+		}else{
+			namespaceTester = new RegExp("^__" + namespace + "_(.*)$");
+		}
+		
+		var myStorage = globalStorage[this._domain];
+		var keysArray = [];
+		for(var i = 0; i < myStorage.length; i++){
+			var currentKey = myStorage.key(i);
+			if(namespaceTester.test(currentKey) == true){
+				// strip off the namespace portion
+				currentKey = currentKey.match(namespaceTester)[1];
+				keysArray.push(currentKey);
+			}
+		}
+		
+		return keysArray;
+	},
+
+	clear: function(namespace){
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		if(this.isValidKey(namespace) == false){
+			throw new Error("Invalid namespace given: " + namespace);
+		}
+		
+		// create a regular expression to test the beginning
+		// of our key names to see if they match our namespace;
+		// if it is the default namespace then test for the presence
+		// of no namespace for compatibility with older versions
+		// of dojox.storage
+		var namespaceTester;
+		if(namespace == this.DEFAULT_NAMESPACE){
+			namespaceTester = new RegExp("^[^_]{2}");	
+		}else{
+			namespaceTester = new RegExp("^__" + namespace + "_");
+		}
+		
+		var myStorage = globalStorage[this._domain];
+		var keys = [];
+		for(var i = 0; i < myStorage.length; i++){
+			if(namespaceTester.test(myStorage.key(i)) == true){
+				keys[keys.length] = myStorage.key(i);
+			}
+		}
+		
+		dojo.forEach(keys, dojo.hitch(myStorage, "removeItem"));
+	},
+	
+	remove: function(key, namespace){
+		// get our full key name, which is namespace + key
+		key = this.getFullKey(key, namespace);
+		
+		var myStorage = globalStorage[this._domain];
+		myStorage.removeItem(key);
+	},
+	
+	isPermanent: function(){
+		return true;
+	},
+
+	getMaximumSize: function(){
+		return this.SIZE_NO_LIMIT;
+	},
+
+	hasSettingsUI: function(){
+		return false;
+	},
+	
+	showSettingsUI: function(){
+		throw new Error(this.declaredClass + " does not support a storage settings user-interface");
+	},
+	
+	hideSettingsUI: function(){
+		throw new Error(this.declaredClass + " does not support a storage settings user-interface");
+	},
+	
+	getFullKey: function(key, namespace){
+		namespace = namespace||this.DEFAULT_NAMESPACE;
+		
+		if(this.isValidKey(namespace) == false){
+			throw new Error("Invalid namespace given: " + namespace);
+		}
+		
+		// don't append a namespace string for the default namespace,
+		// for compatibility with older versions of dojox.storage
+		if(namespace == this.DEFAULT_NAMESPACE){
+			return key;
+		}else{
+			return "__" + namespace + "_" + key;
+		}
+	}
+});
+
+dojox.storage.manager.register("dojox.storage.WhatWGStorageProvider", 
+								new dojox.storage.WhatWGStorageProvider());
+
+}
+
+if(!dojo._hasResource["dijit._base.place"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dijit._base.place"] = true;
+dojo.provide("dijit._base.place");
+
+// ported from dojo.html.util
+
+dijit.getViewport = function(){
+	//	summary
+	//	Returns the dimensions and scroll position of the viewable area of a browser window
+
+	var _window = dojo.global;
+	var _document = dojo.doc;
+
+	// get viewport size
+	var w = 0, h = 0;
+	var de = _document.documentElement;
+	var dew = de.clientWidth, deh = de.clientHeight;
+	if(dojo.isMozilla){
+		// mozilla
+		// _window.innerHeight includes the height taken by the scroll bar
+		// clientHeight is ideal but has DTD issues:
+		// #4539: FF reverses the roles of body.clientHeight/Width and documentElement.clientHeight/Width based on the DTD!
+		// check DTD to see whether body or documentElement returns the viewport dimensions using this algorithm:
+		var minw, minh, maxw, maxh;
+		var dbw = _document.body.clientWidth;
+		if(dbw > dew){
+			minw = dew;
+			maxw = dbw;
+		}else{
+			maxw = dew;
+			minw = dbw;
+		}
+		var dbh = _document.body.clientHeight;
+		if(dbh > deh){
+			minh = deh;
+			maxh = dbh;
+		}else{
+			maxh = deh;
+			minh = dbh;
+		}
+		w = (maxw > _window.innerWidth) ? minw : maxw;
+		h = (maxh > _window.innerHeight) ? minh : maxh;
+	}else if(!dojo.isOpera && _window.innerWidth){
+		//in opera9, dojo.body().clientWidth should be used, instead
+		//of window.innerWidth/document.documentElement.clientWidth
+		//so we have to check whether it is opera
+		w = _window.innerWidth;
+		h = _window.innerHeight;
+	}else if(dojo.isIE && de && deh){
+		w = dew;
+		h = deh;
+	}else if(dojo.body().clientWidth){
+		// IE5, Opera
+		w = dojo.body().clientWidth;
+		h = dojo.body().clientHeight;
+	}
+
+	// get scroll position
+	var scroll = dojo._docScroll();
+
+	return { w: w, h: h, l: scroll.x, t: scroll.y };	//	object
+};
+
+dijit.placeOnScreen = function(
+	/* DomNode */	node,
+	/* Object */		pos,
+	/* Object */		corners,
+	/* boolean? */		tryOnly){
+	//	summary:
+	//		Keeps 'node' in the visible area of the screen while trying to
+	//		place closest to pos.x, pos.y. The input coordinates are
+	//		expected to be the desired document position.
+	//
+	//		Set which corner(s) you want to bind to, such as
+	//		
+	//			placeOnScreen(node, {x: 10, y: 20}, ["TR", "BL"])
+	//		
+	//		The desired x/y will be treated as the topleft(TL)/topright(TR) or
+	//		BottomLeft(BL)/BottomRight(BR) corner of the node. Each corner is tested
+	//		and if a perfect match is found, it will be used. Otherwise, it goes through
+	//		all of the specified corners, and choose the most appropriate one.
+	//		
+	//		NOTE: node is assumed to be absolutely or relatively positioned.
+
+	var choices = dojo.map(corners, function(corner){ return { corner: corner, pos: pos }; });
+
+	return dijit._place(node, choices);
+}
+
+dijit._place = function(/*DomNode*/ node, /* Array */ choices, /* Function */ layoutNode){
+	// summary:
+	//		Given a list of spots to put node, put it at the first spot where it fits,
+	//		of if it doesn't fit anywhere then the place with the least overflow
+	// choices: Array
+	//		Array of elements like: {corner: 'TL', pos: {x: 10, y: 20} }
+	//		Above example says to put the top-left corner of the node at (10,20)
+	//	layoutNode: Function(node, aroundNodeCorner, nodeCorner)
+	//		for things like tooltip, they are displayed differently (and have different dimensions)
+	//		based on their orientation relative to the parent.   This adjusts the popup based on orientation.
+
+	// get {x: 10, y: 10, w: 100, h:100} type obj representing position of
+	// viewport over document
+	var view = dijit.getViewport();
+
+	// This won't work if the node is inside a <div style="position: relative">,
+	// so reattach it to dojo.doc.body.   (Otherwise, the positioning will be wrong
+	// and also it might get cutoff)
+	if(!node.parentNode || String(node.parentNode.tagName).toLowerCase() != "body"){
+		dojo.body().appendChild(node);
+	}
+
+	var best = null;
+	dojo.some(choices, function(choice){
+		var corner = choice.corner;
+		var pos = choice.pos;
+
+		// configure node to be displayed in given position relative to button
+		// (need to do this in order to get an accurate size for the node, because
+		// a tooltips size changes based on position, due to triangle)
+		if(layoutNode){
+			layoutNode(node, choice.aroundCorner, corner);
+		}
+
+		// get node's size
+		var style = node.style;
+		var oldDisplay = style.display;
+		var oldVis = style.visibility;
+		style.visibility = "hidden";
+		style.display = "";
+		var mb = dojo.marginBox(node);
+		style.display = oldDisplay;
+		style.visibility = oldVis;
+
+		// coordinates and size of node with specified corner placed at pos,
+		// and clipped by viewport
+		var startX = (corner.charAt(1) == 'L' ? pos.x : Math.max(view.l, pos.x - mb.w)),
+			startY = (corner.charAt(0) == 'T' ? pos.y : Math.max(view.t, pos.y -  mb.h)),
+			endX = (corner.charAt(1) == 'L' ? Math.min(view.l + view.w, startX + mb.w) : pos.x),
+			endY = (corner.charAt(0) == 'T' ? Math.min(view.t + view.h, startY + mb.h) : pos.y),
+			width = endX - startX,
+			height = endY - startY,
+			overflow = (mb.w - width) + (mb.h - height);
+
+		if(best == null || overflow < best.overflow){
+			best = {
+				corner: corner,
+				aroundCorner: choice.aroundCorner,
+				x: startX,
+				y: startY,
+				w: width,
+				h: height,
+				overflow: overflow
+			};
+		}
+		return !overflow;
+	});
+
+	node.style.left = best.x + "px";
+	node.style.top = best.y + "px";
+	if(best.overflow && layoutNode){
+		layoutNode(node, best.aroundCorner, best.corner);
+	}
+	return best;
+}
+
+dijit.placeOnScreenAroundElement = function(
+	/* DomNode */		node,
+	/* DomNode */		aroundNode,
+	/* Object */		aroundCorners,
+	/* Function */		layoutNode){
+
+	//	summary
+	//	Like placeOnScreen, except it accepts aroundNode instead of x,y
+	//	and attempts to place node around it.  Uses margin box dimensions.
+	//
+	//	aroundCorners
+	//		specify Which corner of aroundNode should be
+	//		used to place the node => which corner(s) of node to use (see the
+	//		corners parameter in dijit.placeOnScreen)
+	//		e.g. {'TL': 'BL', 'BL': 'TL'}
+	//
+	//	layoutNode: Function(node, aroundNodeCorner, nodeCorner)
+	//		for things like tooltip, they are displayed differently (and have different dimensions)
+	//		based on their orientation relative to the parent.   This adjusts the popup based on orientation.
+
+
+	// get coordinates of aroundNode
+	aroundNode = dojo.byId(aroundNode);
+	var oldDisplay = aroundNode.style.display;
+	aroundNode.style.display="";
+	// #3172: use the slightly tighter border box instead of marginBox
+	var aroundNodeW = aroundNode.offsetWidth; //mb.w;
+	var aroundNodeH = aroundNode.offsetHeight; //mb.h;
+	var aroundNodePos = dojo.coords(aroundNode, true);
+	aroundNode.style.display=oldDisplay;
+
+	// Generate list of possible positions for node
+	var choices = [];
+	for(var nodeCorner in aroundCorners){
+		choices.push( {
+			aroundCorner: nodeCorner,
+			corner: aroundCorners[nodeCorner],
+			pos: {
+				x: aroundNodePos.x + (nodeCorner.charAt(1) == 'L' ? 0 : aroundNodeW),
+				y: aroundNodePos.y + (nodeCorner.charAt(0) == 'T' ? 0 : aroundNodeH)
+			}
+		});
+	}
+
+	return dijit._place(node, choices, layoutNode);
+}
+
+}
+
+if(!dojo._hasResource["dojox.flash._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.flash._base"] = true;
+dojo.provide("dojox.flash._base");
+
+// for dijit.getViewport(), needed by dojox.flash.Embed.center()
+
+
+dojox.flash = function(){
+	// summary:
+	//	The goal of dojox.flash is to make it easy to extend Flash's capabilities
+	//	into an Ajax/DHTML environment.
+	//  
+	//	dojox.flash provides an easy object for interacting with the Flash plugin. 
+	//	This object provides methods to determine the current version of the Flash
+	//	plugin (dojox.flash.info); write out the necessary markup to 
+	//	dynamically insert a Flash object into the page (dojox.flash.Embed; and 
+	//	do dynamic installation and upgrading of the current Flash plugin in 
+	//	use (dojox.flash.Install). If you want to call methods on the Flash object
+	//	embedded into the page it is your responsibility to use Flash's ExternalInterface
+	//	API and get a reference to the Flash object yourself.
+	//		
+	//	To use dojox.flash, you must first wait until Flash is finished loading 
+	//	and initializing before you attempt communication or interaction. 
+	//	To know when Flash is finished use dojo.connect:
+	//		
+	//	dojo.connect(dojox.flash, "loaded", myInstance, "myCallback");
+	//		
+	//	Then, while the page is still loading provide the file name:
+	//		
+	//	dojox.flash.setSwf(dojo.moduleUrl("dojox", "_storage/storage.swf"));
+	//			
+	//	If no SWF files are specified, then Flash is not initialized.
+	//		
+	//	Your Flash must use Flash's ExternalInterface to expose Flash methods and
+	//	to call JavaScript.
+	//		
+	//	setSwf can take an optional 'visible' attribute to control whether
+	//	the Flash object is visible or not on the page; the default is visible:
+	//		
+	//	dojox.flash.setSwf(dojo.moduleUrl("dojox", "_storage/storage.swf"),
+	//						false);
+	//		
+	//	Once finished, you can query Flash version information:
+	//		
+	//	dojox.flash.info.version
+	//		
+	//	Or can communicate with Flash methods that were exposed:	
+	//
+	//	var f = dojox.flash.get();
+	//	var results = f.sayHello("Some Message");	
+	// 
+	//	Your Flash files should use DojoExternalInterface.as to register methods;
+	//	this file wraps Flash's normal ExternalInterface but correct various
+	//	serialization bugs that ExternalInterface has.
+	//
+	//	Note that dojox.flash is not meant to be a generic Flash embedding
+	//	mechanism; it is as generic as necessary to make Dojo Storage's
+	//	Flash Storage Provider as clean and modular as possible. If you want 
+	//	a generic Flash embed mechanism see SWFObject 
+	//	(http://blog.deconcept.com/swfobject/).
+	//
+	// 	Notes:
+	//	Note that dojox.flash can currently only work with one Flash object
+	//	on the page; it does not yet support multiple Flash objects on
+	//	the same page. 
+	//		
+	//	Your code can detect whether the Flash player is installing or having
+	//	its version revved in two ways. First, if dojox.flash detects that
+	//	Flash installation needs to occur, it sets dojox.flash.info.installing
+	//	to true. Second, you can detect if installation is necessary with the
+	//	following callback:
+	//		
+	//	dojo.connect(dojox.flash, "installing", myInstance, "myCallback");
+	//		
+	//	You can use this callback to delay further actions that might need Flash;
+	//	when installation is finished the full page will be refreshed and the
+	//	user will be placed back on your page with Flash installed.
+	//		
+	//	-------------------
+	//	Todo/Known Issues
+	//	-------------------
+	//	* On Internet Explorer, after doing a basic install, the page is
+	//	not refreshed or does not detect that Flash is now available. The way
+	//	to fix this is to create a custom small Flash file that is pointed to
+	//	during installation; when it is finished loading, it does a callback
+	//	that says that Flash installation is complete on IE, and we can proceed
+	//	to initialize the dojox.flash subsystem.
+	//	* Things aren't super tested for sending complex objects to Flash
+	//	methods, since Dojo Storage only needs strings
+	//		
+	//	Author- Brad Neuberg, http://codinginparadise.org
+}
+
+dojox.flash = {
+	ready: false,
+	url: null,
+	
+	_visible: true,
+	_loadedListeners: new Array(),
+	_installingListeners: new Array(),
+	
+	setSwf: function(/* String */ url, /* boolean? */ visible){
+		// summary: Sets the SWF files and versions we are using.
+		// url: String
+		//	The URL to this Flash file.
+		// visible: boolean?
+		//	Whether the Flash file is visible or not. If it is not visible we hide it off the
+		//	screen. This defaults to true (i.e. the Flash file is visible).
+		this.url = url;
+		
+		if(typeof visible != "undefined"){
+			this._visible = visible;
+		}
+		
+		// initialize ourselves		
+		this._initialize();
+	},
+	
+	addLoadedListener: function(/* Function */ listener){
+		// summary:
+		//	Adds a listener to know when Flash is finished loading. 
+		//	Useful if you don't want a dependency on dojo.event.
+		// listener: Function
+		//	A function that will be called when Flash is done loading.
+		
+		this._loadedListeners.push(listener);
+	},
+
+	addInstallingListener: function(/* Function */ listener){
+		// summary:
+		//	Adds a listener to know if Flash is being installed. 
+		//	Useful if you don't want a dependency on dojo.event.
+		// listener: Function
+		//	A function that will be called if Flash is being
+		//	installed
+		
+		this._installingListeners.push(listener);
+	},	
+	
+	loaded: function(){
+		// summary: Called back when the Flash subsystem is finished loading.
+		// description:
+		//	A callback when the Flash subsystem is finished loading and can be
+		//	worked with. To be notified when Flash is finished loading, add a
+		//  loaded listener: 
+		//
+		//  dojox.flash.addLoadedListener(loadedListener);
+	
+		dojox.flash.ready = true;
+		if(dojox.flash._loadedListeners.length > 0){
+			for(var i = 0;i < dojox.flash._loadedListeners.length; i++){
+				dojox.flash._loadedListeners[i].call(null);
+			}
+		}
+	},
+	
+	installing: function(){
+		// summary: Called if Flash is being installed.
+		// description:
+		//	A callback to know if Flash is currently being installed or
+		//	having its version revved. To be notified if Flash is installing, connect
+		//	your callback to this method using the following:
+		//	
+		//	dojo.event.connect(dojox.flash, "installing", myInstance, "myCallback");
+		
+		if(dojox.flash._installingListeners.length > 0){
+			for(var i = 0; i < dojox.flash._installingListeners.length; i++){
+				dojox.flash._installingListeners[i].call(null);
+			}
+		}
+	},
+	
+	// Initializes dojox.flash.
+	_initialize: function(){
+		//console.debug("dojox.flash._initialize");
+		// see if we need to rev or install Flash on this platform
+		var installer = new dojox.flash.Install();
+		dojox.flash.installer = installer;
+
+		if(installer.needed() == true){		
+			installer.install();
+		}else{
+			// write the flash object into the page
+			dojox.flash.obj = new dojox.flash.Embed(this._visible);
+			dojox.flash.obj.write();
+			
+			// setup the communicator
+			dojox.flash.comm = new dojox.flash.Communicator();
+		}
+	}
+};
+
+
+dojox.flash.Info = function(){
+	// summary: A class that helps us determine whether Flash is available.
+	// description:
+	//	A class that helps us determine whether Flash is available,
+	//	it's major and minor versions, and what Flash version features should
+	//	be used for Flash/JavaScript communication. Parts of this code
+	//	are adapted from the automatic Flash plugin detection code autogenerated 
+	//	by the Macromedia Flash 8 authoring environment. 
+	//	
+	//	An instance of this class can be accessed on dojox.flash.info after
+	//	the page is finished loading.
+	//	
+	//	This constructor must be called before the page is finished loading.	
+	
+	// Visual basic helper required to detect Flash Player ActiveX control 
+	// version information on Internet Explorer
+	if(dojo.isIE){
+		document.write([
+			'<script language="VBScript" type="text/vbscript"\>',
+			'Function VBGetSwfVer(i)',
+			'  on error resume next',
+			'  Dim swControl, swVersion',
+			'  swVersion = 0',
+			'  set swControl = CreateObject("ShockwaveFlash.ShockwaveFlash." + CStr(i))',
+			'  if (IsObject(swControl)) then',
+			'    swVersion = swControl.GetVariable("$version")',
+			'  end if',
+			'  VBGetSwfVer = swVersion',
+			'End Function',
+			'</script\>'].join("\r\n"));
+	}
+	
+	this._detectVersion();
+}
+
+dojox.flash.Info.prototype = {
+	// version: String
+	//		The full version string, such as "8r22".
+	version: -1,
+	
+	// versionMajor, versionMinor, versionRevision: String
+	//		The major, minor, and revisions of the plugin. For example, if the
+	//		plugin is 8r22, then the major version is 8, the minor version is 0,
+	//		and the revision is 22. 
+	versionMajor: -1,
+	versionMinor: -1,
+	versionRevision: -1,
+	
+	// capable: Boolean
+	//		Whether this platform has Flash already installed.
+	capable: false,
+	
+	// installing: Boolean
+	//	Set if we are in the middle of a Flash installation session.
+	installing: false,
+	
+	isVersionOrAbove: function(
+							/* int */ reqMajorVer, 
+							/* int */ reqMinorVer, 
+							/* int */ reqVer){ /* Boolean */
+		// summary: 
+		//	Asserts that this environment has the given major, minor, and revision
+		//	numbers for the Flash player.
+		// description:
+		//	Asserts that this environment has the given major, minor, and revision
+		//	numbers for the Flash player. 
+		//	
+		//	Example- To test for Flash Player 7r14:
+		//	
+		//	dojox.flash.info.isVersionOrAbove(7, 0, 14)
+		// returns:
+		//	Returns true if the player is equal
+		//	or above the given version, false otherwise.
+		
+		// make the revision a decimal (i.e. transform revision 14 into
+		// 0.14
+		reqVer = parseFloat("." + reqVer);
+		
+		if(this.versionMajor >= reqMajorVer && this.versionMinor >= reqMinorVer
+			 && this.versionRevision >= reqVer){
+			return true;
+		}else{
+			return false;
+		}
+	},
+	
+	_detectVersion: function(){
+		var versionStr;
+		
+		// loop backwards through the versions until we find the newest version	
+		for(var testVersion = 25; testVersion > 0; testVersion--){
+			if(dojo.isIE){
+				versionStr = VBGetSwfVer(testVersion);
+			}else{
+				versionStr = this._JSFlashInfo(testVersion);		
+			}
+				
+			if(versionStr == -1 ){
+				this.capable = false; 
+				return;
+			}else if(versionStr != 0){
+				var versionArray;
+				if(dojo.isIE){
+					var tempArray = versionStr.split(" ");
+					var tempString = tempArray[1];
+					versionArray = tempString.split(",");
+				}else{
+					versionArray = versionStr.split(".");
+				}
+					
+				this.versionMajor = versionArray[0];
+				this.versionMinor = versionArray[1];
+				this.versionRevision = versionArray[2];
+				
+				// 7.0r24 == 7.24
+				var versionString = this.versionMajor + "." + this.versionRevision;
+				this.version = parseFloat(versionString);
+				
+				this.capable = true;
+				
+				break;
+			}
+		}
+	},
+	 
+	// JavaScript helper required to detect Flash Player PlugIn version 
+	// information. Internet Explorer uses a corresponding Visual Basic
+	// version to interact with the Flash ActiveX control. 
+	_JSFlashInfo: function(testVersion){
+		// NS/Opera version >= 3 check for Flash plugin in plugin array
+		if(navigator.plugins != null && navigator.plugins.length > 0){
+			if(navigator.plugins["Shockwave Flash 2.0"] || 
+				 navigator.plugins["Shockwave Flash"]){
+				var swVer2 = navigator.plugins["Shockwave Flash 2.0"] ? " 2.0" : "";
+				var flashDescription = navigator.plugins["Shockwave Flash" + swVer2].description;
+				var descArray = flashDescription.split(" ");
+				var tempArrayMajor = descArray[2].split(".");
+				var versionMajor = tempArrayMajor[0];
+				var versionMinor = tempArrayMajor[1];
+				if(descArray[3] != ""){
+					var tempArrayMinor = descArray[3].split("r");
+				}else{
+					var tempArrayMinor = descArray[4].split("r");
+				}
+				var versionRevision = tempArrayMinor[1] > 0 ? tempArrayMinor[1] : 0;
+				var version = versionMajor + "." + versionMinor + "." 
+											+ versionRevision;
+											
+				return version;
+			}
+		}
+		
+		return -1;
+	}
+};
+
+dojox.flash.Embed = function(visible){
+	// summary: A class that is used to write out the Flash object into the page.
+	// description:
+	//	Writes out the necessary tags to embed a Flash file into the page. Note that
+	//	these tags are written out as the page is loaded using document.write, so
+	//	you must call this class before the page has finished loading.
+	
+	this._visible = visible;
+}
+
+dojox.flash.Embed.prototype = {
+	// width: int
+	//	The width of this Flash applet. The default is the minimal width
+	//	necessary to show the Flash settings dialog. Current value is 
+	//  215 pixels.
+	width: 215,
+	
+	// height: int 
+	//	The height of this Flash applet. The default is the minimal height
+	//	necessary to show the Flash settings dialog. Current value is
+	// 138 pixels.
+	height: 138,
+	
+	// id: String
+	// 	The id of the Flash object. Current value is 'flashObject'.
+	id: "flashObject",
+	
+	// Controls whether this is a visible Flash applet or not.
+	_visible: true,
+
+	protocol: function(){
+		switch(window.location.protocol){
+			case "https:":
+				return "https";
+				break;
+			default:
+				return "http";
+				break;
+		}
+	},
+	
+	write: function(/* Boolean? */ doExpressInstall){
+		// summary: Writes the Flash into the page.
+		// description:
+		//	This must be called before the page
+		//	is finished loading. 
+		// doExpressInstall: Boolean
+		//	Whether to write out Express Install
+		//	information. Optional value; defaults to false.
+		
+		// determine our container div's styling
+		var containerStyle = "";
+		containerStyle += ("width: " + this.width + "px; ");
+		containerStyle += ("height: " + this.height + "px; ");
+		if(!this._visible){
+			containerStyle += "position: absolute; z-index: 10000; top: -1000px; left: -1000px; ";
+		}
+		
+		// figure out the SWF file to get and how to write out the correct HTML
+		// for this Flash version
+		var objectHTML;
+		var swfloc = dojox.flash.url;
+		var swflocObject = swfloc;
+		var swflocEmbed = swfloc;
+		var dojoUrl = dojo.baseUrl;
+		if(doExpressInstall){
+			// the location to redirect to after installing
+			var redirectURL = escape(window.location);
+			document.title = document.title.slice(0, 47) + " - Flash Player Installation";
+			var docTitle = escape(document.title);
+			swflocObject += "?MMredirectURL=" + redirectURL
+			                + "&MMplayerType=ActiveX"
+			                + "&MMdoctitle=" + docTitle
+							+ "&baseUrl=" + escape(dojoUrl);
+			swflocEmbed += "?MMredirectURL=" + redirectURL 
+							+ "&MMplayerType=PlugIn"
+							+ "&baseUrl=" + escape(dojoUrl);
+		}else{
+		  // IE/Flash has an evil bug that shows up some time: if we load the
+		  // Flash and it isn't in the cache, ExternalInterface works fine --
+		  // however, the second time when its loaded from the cache a timing
+		  // bug can keep ExternalInterface from working. The trick below 
+		  // simply invalidates the Flash object in the cache all the time to
+		  // keep it loading fresh. -- Brad Neuberg
+		  swflocObject += "?cachebust=" + new Date().getTime();
+		}
+
+		if(swflocEmbed.indexOf("?") == -1){
+			swflocEmbed +=  '?baseUrl='+escape(dojoUrl);
+		}else{
+		  swflocEmbed +=  '&baseUrl='+escape(dojoUrl);
+		}
+
+		objectHTML =
+			'<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" '
+			  + 'codebase="'
+				+ this.protocol()
+				+ '://fpdownload.macromedia.com/pub/shockwave/cabs/flash/'
+				+ 'swflash.cab#version=8,0,0,0"\n '
+			  + 'width="' + this.width + '"\n '
+			  + 'height="' + this.height + '"\n '
+			  + 'id="' + this.id + '"\n '
+			  + 'name="' + this.id + '"\n '
+			  + 'align="middle">\n '
+			  + '<param name="allowScriptAccess" value="sameDomain"></param>\n '
+			  + '<param name="movie" value="' + swflocObject + '"></param>\n '
+			  + '<param name="quality" value="high"></param>\n '
+			  + '<param name="bgcolor" value="#ffffff"></param>\n '
+			  + '<embed src="' + swflocEmbed + '" '
+			  	  + 'quality="high" '
+				  + 'bgcolor="#ffffff" '
+				  + 'width="' + this.width + '" '
+				  + 'height="' + this.height + '" '
+				  + 'id="' + this.id + 'Embed' + '" '
+				  + 'name="' + this.id + '" '
+				  + 'swLiveConnect="true" '
+				  + 'align="middle" '
+				  + 'allowScriptAccess="sameDomain" '
+				  + 'type="application/x-shockwave-flash" '
+				  + 'pluginspage="'
+				  + this.protocol()
+				  +'://www.macromedia.com/go/getflashplayer" '
+				  + '></embed>\n'
+			+ '</object>\n';
+					
+		// using same mechanism on all browsers now to write out
+		// Flash object into page
+
+		// document.write no longer works correctly
+		// due to Eolas patent workaround in IE;
+		// nothing happens (i.e. object doesn't
+		// go into page if we use it)
+		dojo.connect(dojo, "loaded", dojo.hitch(this, function(){
+			var div = document.createElement("div");
+			div.setAttribute("id", this.id + "Container");
+			div.setAttribute("style", containerStyle);
+			div.innerHTML = objectHTML;
+	
+			var body = document.getElementsByTagName("body");
+			if(!body || !body.length){
+				throw new Error("No body tag for this page");
+			}
+			body = body[0];
+			body.appendChild(div);
+		}));
+	},  
+	
+	get: function(){ /* Object */
+		// summary: Gets the Flash object DOM node.
+		if(dojo.isIE || dojo.isSafari){
+			return document.getElementById(this.id);
+		}else{
+			// different IDs on OBJECT and EMBED tags or
+			// else Firefox will return wrong one and
+			// communication won't work; 
+			// also, document.getElementById() returns a
+			// plugin but ExternalInterface calls don't
+			// work on it so we have to use
+			// document[id] instead
+			return document[this.id + "Embed"];
+		}
+	},
+	
+	setVisible: function(/* Boolean */ visible){
+	  //console.debug("setVisible, visible="+visible);
+		
+		// summary: Sets the visibility of this Flash object.		
+		var container = dojo.byId(this.id + "Container");
+		if(visible == true){
+		  container.style.position = "absolute"; // IE -- Brad Neuberg
+			container.style.visibility = "visible";
+		}else{
+			container.style.position = "absolute";
+			container.style.x = "-1000px";
+			container.style.y = "-1000px";
+			container.style.visibility = "hidden";
+		}
+	},
+	
+	center: function(){
+		// summary: Centers the flash applet on the page.
+		
+		var elementWidth = this.width;
+		var elementHeight = this.height;
+
+		var viewport = dijit.getViewport();
+
+		// compute the centered position    
+		var x = viewport.l + (viewport.w - elementWidth) / 2;
+		var y = viewport.t + (viewport.h - elementHeight) / 2; 
+		
+		// set the centered position
+		var container = dojo.byId(this.id + "Container");
+		container.style.top = y + "px";
+		container.style.left = x + "px";
+	}
+};
+
+
+dojox.flash.Communicator = function(){
+	// summary:
+	//	A class that is used to communicate between Flash and JavaScript.
+	// description:
+	//	This class helps mediate Flash and JavaScript communication. Internally
+	//	it uses Flash 8's ExternalInterface API, but adds functionality to fix 
+	//	various encoding bugs that ExternalInterface has.
+}
+
+dojox.flash.Communicator.prototype = {
+	// Registers the existence of a Flash method that we can call with
+	// JavaScript, using Flash 8's ExternalInterface. 
+	_addExternalInterfaceCallback: function(methodName){
+		var wrapperCall = dojo.hitch(this, function(){
+			// some browsers don't like us changing values in the 'arguments' array, so
+			// make a fresh copy of it
+			var methodArgs = new Array(arguments.length);
+			for(var i = 0; i < arguments.length; i++){
+				methodArgs[i] = this._encodeData(arguments[i]);
+			}
+			
+			var results = this._execFlash(methodName, methodArgs);
+			results = this._decodeData(results);
+			
+			return results;
+		});
+		
+		this[methodName] = wrapperCall;
+	},
+	
+	// Encodes our data to get around ExternalInterface bugs that are still
+	// present even in Flash 9.
+	_encodeData: function(data){
+		if(!data || typeof data != "string"){
+			return data;
+		}
+		
+		// double encode all entity values, or they will be mis-decoded
+		// by Flash when returned
+		var entityRE = /\&([^;]*)\;/g;
+		data = data.replace(entityRE, "&amp;$1;");
+
+		// entity encode XML-ish characters, or Flash's broken XML serializer
+		// breaks
+		data = data.replace(/</g, "&lt;");
+		data = data.replace(/>/g, "&gt;");
+
+		// transforming \ into \\ doesn't work; just use a custom encoding
+		data = data.replace("\\", "&custom_backslash;");
+
+		data = data.replace(/\0/g, "\\0"); // null character
+		data = data.replace(/\"/g, "&quot;");
+
+		return data;
+	},
+	
+	// Decodes our data to get around ExternalInterface bugs that are still
+	// present even in Flash 9.
+	_decodeData: function(data){
+		// wierdly enough, Flash sometimes returns the result as an
+		// 'object' that is actually an array, rather than as a String;
+		// detect this by looking for a length property; for IE
+		// we also make sure that we aren't dealing with a typeof string
+		// since string objects have length property there
+		if(data && data.length && typeof data != "string"){
+			data = data[0];
+		}
+		
+		if(!data || typeof data != "string"){
+			return data;
+		}
+	
+		// certain XMLish characters break Flash's wire serialization for
+		// ExternalInterface; these are encoded on the 
+		// DojoExternalInterface side into a custom encoding, rather than
+		// the standard entity encoding, because otherwise we won't be able to
+		// differentiate between our own encoding and any entity characters
+		// that are being used in the string itself
+		data = data.replace(/\&custom_lt\;/g, "<");
+		data = data.replace(/\&custom_gt\;/g, ">");
+		data = data.replace(/\&custom_backslash\;/g, '\\');
+		
+		// needed for IE; \0 is the NULL character
+		data = data.replace(/\\0/g, "\0");
+		
+		return data;
+	},
+	
+	// Executes a Flash method; called from the JavaScript wrapper proxy we
+	// create on dojox.flash.comm.
+	_execFlash: function(methodName, methodArgs){
+		var plugin = dojox.flash.obj.get();
+		methodArgs = (methodArgs) ? methodArgs : [];
+		
+		// encode arguments that are strings
+		for(var i = 0; i < methodArgs; i++){
+			if(typeof methodArgs[i] == "string"){
+				methodArgs[i] = this._encodeData(methodArgs[i]);
+			}
+		}
+
+		// we use this gnarly hack below instead of 
+		// plugin[methodName] for two reasons:
+		// 1) plugin[methodName] has no call() method, which
+		// means we can't pass in multiple arguments dynamically
+		// to a Flash method -- we can only have one
+		// 2) On IE plugin[methodName] returns undefined -- 
+		// plugin[methodName] used to work on IE when we
+		// used document.write but doesn't now that
+		// we use dynamic DOM insertion of the Flash object
+		// -- Brad Neuberg
+		var flashExec = function(){ 
+			return eval(plugin.CallFunction(
+						 "<invoke name=\"" + methodName
+						+ "\" returntype=\"javascript\">" 
+						+ __flash__argumentsToXML(methodArgs, 0) 
+						+ "</invoke>")); 
+		};
+		var results = flashExec.call(methodArgs);
+		
+		if(typeof results == "string"){
+			results = this._decodeData(results);
+		}
+			
+		return results;
+	}
+}
+
+// FIXME: dojo.declare()-ify this
+
+// TODO: I did not test the Install code when I refactored Dojo Flash from 0.4 to 
+// 1.0, so am not sure if it works. If Flash is not present I now prefer 
+// that Gears is installed instead of Flash because GearsStorageProvider is
+// much easier to work with than Flash's hacky ExternalInteface. 
+// -- Brad Neuberg
+dojox.flash.Install = function(){
+	// summary: Helps install Flash plugin if needed.
+	// description:
+	//		Figures out the best way to automatically install the Flash plugin
+	//		for this browser and platform. Also determines if installation or
+	//		revving of the current plugin is needed on this platform.
+}
+
+dojox.flash.Install.prototype = {
+	needed: function(){ /* Boolean */
+		// summary:
+		//		Determines if installation or revving of the current plugin is
+		//		needed. 
+	
+		// do we even have flash?
+		if(dojox.flash.info.capable == false){
+			return true;
+		}
+
+		// Must have ExternalInterface which came in Flash 8
+		if(!dojox.flash.info.isVersionOrAbove(8, 0, 0)){
+			return true;
+		}
+
+		// otherwise we don't need installation
+		return false;
+	},
+
+	install: function(){
+		// summary: Performs installation or revving of the Flash plugin.
+	
+		// indicate that we are installing
+		dojox.flash.info.installing = true;
+		dojox.flash.installing();
+		
+		if(dojox.flash.info.capable == false){ // we have no Flash at all
+			// write out a simple Flash object to force the browser to prompt
+			// the user to install things
+			var installObj = new dojox.flash.Embed(false);
+			installObj.write(); // write out HTML for Flash
+		}else if(dojox.flash.info.isVersionOrAbove(6, 0, 65)){ // Express Install
+			var installObj = new dojox.flash.Embed(false);
+			installObj.write(true); // write out HTML for Flash 8 version+
+			installObj.setVisible(true);
+			installObj.center();
+		}else{ // older Flash install than version 6r65
+			alert("This content requires a more recent version of the Macromedia "
+						+" Flash Player.");
+			window.location.href = + dojox.flash.Embed.protocol() +
+						"://www.macromedia.com/go/getflashplayer";
+		}
+	},
+	
+	// Called when the Express Install is either finished, failed, or was
+	// rejected by the user.
+	_onInstallStatus: function(msg){
+		if (msg == "Download.Complete"){
+			// Installation is complete.
+			dojox.flash._initialize();
+		}else if(msg == "Download.Cancelled"){
+			alert("This content requires a more recent version of the Macromedia "
+						+" Flash Player.");
+			window.location.href = dojox.flash.Embed.protocol() +
+						"://www.macromedia.com/go/getflashplayer";
+		}else if (msg == "Download.Failed"){
+			// The end user failed to download the installer due to a network failure
+			alert("There was an error downloading the Flash Player update. "
+						+ "Please try again later, or visit macromedia.com to download "
+						+ "the latest version of the Flash plugin.");
+		}	
+	}
+}
+
+// find out if Flash is installed
+dojox.flash.info = new dojox.flash.Info();
+
+// vim:ts=4:noet:tw=0:
+
+}
+
+if(!dojo._hasResource["dojox.flash"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.flash"] = true;
+dojo.provide("dojox.flash");
+
+
+}
+
+if(!dojo._hasResource["dojox.storage.FlashStorageProvider"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage.FlashStorageProvider"] = true;
+dojo.provide("dojox.storage.FlashStorageProvider");
+
+
+
+
+
+// summary: 
+//		Storage provider that uses features in Flash to achieve permanent
+//		storage
+// description:
+//		Authors of this storage provider-
+//			Brad Neuberg, bkn3@columbia.edu	
+dojo.declare("dojox.storage.FlashStorageProvider", dojox.storage.Provider, {
+		initialized: false,
+		
+		_available: null,
+		_statusHandler: null,
+		_flashReady: false,
+		_pageReady: false,
+		
+		initialize: function(){
+		  //console.debug("FlashStorageProvider.initialize");
+			if(dojo.config["disableFlashStorage"] == true){
+				return;
+			}
+			
+			// initialize our Flash
+			dojox.flash.addLoadedListener(dojo.hitch(this, function(){
+			  //console.debug("flashReady");
+			  // indicate our Flash subsystem is now loaded
+			  this._flashReady = true;
+			  if(this._flashReady && this._pageReady){
+				  this._loaded();
+				}
+			}));
+			var swfLoc = dojo.moduleUrl("dojox", "storage/Storage.swf").toString();
+			dojox.flash.setSwf(swfLoc, false);
+			
+			// wait till page is finished loading
+			dojo.connect(dojo, "loaded", this, function(){
+			  //console.debug("pageReady");
+			  this._pageReady = true;
+			  if(this._flashReady && this._pageReady){
+			    this._loaded();
+			  }
+			});
+		},
+		
+		//	Set a new value for the flush delay timer.
+		//	Possible values:
+		//	  0 : Perform the flush synchronously after each "put" request
+		//	> 0 : Wait until 'newDelay' ms have passed without any "put" request to flush
+		//	 -1 : Do not  automatically flush
+		setFlushDelay: function(newDelay){
+			if(newDelay === null || typeof newDelay === "undefined" || isNaN(newDelay)){
+				throw new Error("Invalid argunment: " + newDelay);
+			}
+			
+			dojox.flash.comm.setFlushDelay(String(newDelay));
+		},
+		
+		getFlushDelay: function(){
+			return Number(dojox.flash.comm.getFlushDelay());
+		},
+		
+		flush: function(namespace){
+			//FIXME: is this test necessary?  Just use !namespace
+			if(namespace == null || typeof namespace == "undefined"){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			dojox.flash.comm.flush(namespace);
+		},
+
+		isAvailable: function(){
+			return (this._available = !dojo.config["disableFlashStorage"]);
+		},
+
+		put: function(key, value, resultsHandler, namespace){
+			if(!this.isValidKey(key)){
+				throw new Error("Invalid key given: " + key);
+			}
+			
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+				
+			this._statusHandler = resultsHandler;
+			
+			// serialize the value;
+			// handle strings differently so they have better performance
+			if(dojo.isString(value)){
+				value = "string:" + value;
+			}else{
+				value = dojo.toJson(value);
+			}
+			
+			dojox.flash.comm.put(key, value, namespace);
+		},
+
+		putMultiple: function(keys, values, resultsHandler, namespace){
+			if(!this.isValidKeyArray(keys) || ! values instanceof Array 
+			    || keys.length != values.length){
+				throw new Error("Invalid arguments: keys = [" + keys + "], values = [" + values + "]");
+			}
+			
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+
+			this._statusHandler = resultsHandler;
+			
+			//	Convert the arguments on strings we can pass along to Flash
+			var metaKey = keys.join(",");
+			var lengths = [];
+			for(var i=0;i<values.length;i++){
+				if(dojo.isString(values[i])){
+					values[i] = "string:" + values[i];
+				}else{
+					values[i] = dojo.toJson(values[i]);
+				}
+				lengths[i] = values[i].length; 
+			}
+			var metaValue = values.join("");
+			var metaLengths = lengths.join(",");
+			
+			dojox.flash.comm.putMultiple(metaKey, metaValue, metaLengths, this.namespace);
+		},
+
+		get: function(key, namespace){
+			if(!this.isValidKey(key)){
+				throw new Error("Invalid key given: " + key);
+			}
+			
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+			
+			var results = dojox.flash.comm.get(key, namespace);
+
+			if(results == ""){
+				return null;
+			}
+		
+			return this._destringify(results);
+		},
+
+		getMultiple: function(/*array*/ keys, /*string?*/ namespace){ /*Object*/
+			if(!this.isValidKeyArray(keys)){
+				throw new ("Invalid key array given: " + keys);
+			}
+			
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+			
+			var metaKey = keys.join(",");
+			var metaResults = dojox.flash.comm.getMultiple(metaKey, this.namespace);
+			var results = eval("(" + metaResults + ")");
+			
+			//	destringify each entry back into a real JS object
+			//FIXME: use dojo.map
+			for(var i = 0; i < results.length; i++){
+				results[i] = (results[i] == "") ? null : this._destringify(results[i]);
+			}
+			
+			return results;		
+		},
+
+		_destringify: function(results){
+			// destringify the content back into a 
+			// real JavaScript object;
+			// handle strings differently so they have better performance
+			if(dojo.isString(results) && (/^string:/.test(results))){
+				results = results.substring("string:".length);
+			}else{
+				results = dojo.fromJson(results);
+			}
+		
+			return results;
+		},
+		
+		getKeys: function(namespace){
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+			
+			var results = dojox.flash.comm.getKeys(namespace);
+			
+			// Flash incorrectly returns an empty string as "null"
+			if(results == null || results == "null"){
+			  results = "";
+			}
+			
+			results = results.split(",");
+			results.sort();
+			
+			return results;
+		},
+		
+		getNamespaces: function(){
+			var results = dojox.flash.comm.getNamespaces();
+			
+			// Flash incorrectly returns an empty string as "null"
+			if(results == null || results == "null"){
+			  results = dojox.storage.DEFAULT_NAMESPACE;
+			}
+			
+			results = results.split(",");
+			results.sort();
+			
+			return results;
+		},
+
+		clear: function(namespace){
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+			
+			dojox.flash.comm.clear(namespace);
+		},
+		
+		remove: function(key, namespace){
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+			
+			dojox.flash.comm.remove(key, namespace);
+		},
+		
+		removeMultiple: function(/*array*/ keys, /*string?*/ namespace){ /*Object*/
+			if(!this.isValidKeyArray(keys)){
+				dojo.raise("Invalid key array given: " + keys);
+			}
+			if(!namespace){
+				namespace = dojox.storage.DEFAULT_NAMESPACE;		
+			}
+			
+			if(!this.isValidKey(namespace)){
+				throw new Error("Invalid namespace given: " + namespace);
+			}
+			
+			var metaKey = keys.join(",");
+			dojox.flash.comm.removeMultiple(metaKey, this.namespace);
+		},
+
+		isPermanent: function(){
+			return true;
+		},
+
+		getMaximumSize: function(){
+			return dojox.storage.SIZE_NO_LIMIT;
+		},
+
+		hasSettingsUI: function(){
+			return true;
+		},
+
+		showSettingsUI: function(){
+			dojox.flash.comm.showSettings();
+			dojox.flash.obj.setVisible(true);
+			dojox.flash.obj.center();
+		},
+
+		hideSettingsUI: function(){
+			// hide the dialog
+			dojox.flash.obj.setVisible(false);
+			
+			// call anyone who wants to know the dialog is
+			// now hidden
+			if(dojo.isFunction(dojox.storage.onHideSettingsUI)){
+				dojox.storage.onHideSettingsUI.call(null);	
+			}
+		},
+		
+		getResourceList: function(){ /* Array[] */
+			// Dojo Offline no longer uses the FlashStorageProvider for offline
+			// storage; Gears is now required
+			return [];
+		},
+		
+		/** Called when Flash and the page are finished loading. */
+		_loaded: function(){
+			// get available namespaces
+			this._allNamespaces = this.getNamespaces();
+			
+			this.initialized = true;
+
+			// indicate that this storage provider is now loaded
+			dojox.storage.manager.loaded();
+		},
+		
+		//	Called if the storage system needs to tell us about the status
+		//	of a put() request. 
+		_onStatus: function(statusResult, key, namespace){
+		  //console.debug("onStatus, statusResult="+statusResult+", key="+key);
+			var ds = dojox.storage;
+			var dfo = dojox.flash.obj;
+			
+			if(statusResult == ds.PENDING){
+				dfo.center();
+				dfo.setVisible(true);
+			}else{
+				dfo.setVisible(false);
+			}
+			
+			if(ds._statusHandler){
+				ds._statusHandler.call(null, statusResult, key, namespace);		
+			}
+		}
+	}
+);
+
+dojox.storage.manager.register("dojox.storage.FlashStorageProvider",
+								new dojox.storage.FlashStorageProvider());
+
+}
+
+if(!dojo._hasResource["dojox.storage._common"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage._common"] = true;
+dojo.provide("dojox.storage._common");
+
+
+
+/*
+  Note: if you are doing Dojo Offline builds you _must_
+  have offlineProfile=true when you run the build script:
+  ./build.sh action=release profile=offline offlineProfile=true
+*/
+
+
+
+
+// now that we are loaded and registered tell the storage manager to
+// initialize itself
+dojox.storage.manager.initialize();
+
+}
+
+if(!dojo._hasResource["dojox.storage"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.storage"] = true;
+dojo.provide("dojox.storage");
+
+
+}
+
+if(!dojo._hasResource["dojox.off.files"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off.files"] = true;
+dojo.provide("dojox.off.files");
+
+// Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org
+
+// summary:
+//	Helps maintain resources that should be
+//	available offline, such as CSS files.
+// description:
+//	dojox.off.files makes it easy to indicate
+//	what resources should be available offline,
+//	such as CSS files, JavaScript, HTML, etc.
+dojox.off.files = {
+	// versionURL: String
+	//	An optional file, that if present, records the version
+	//	of our bundle of files to make available offline. If this
+	//	file is present, and we are not currently debugging,
+	//	then we only refresh our offline files if the version has
+	//	changed. 
+	versionURL: "version.js",
+	
+	// listOfURLs: Array
+	//	For advanced usage; most developers can ignore this.
+	//	Our list of URLs that will be cached and made available
+	//	offline.
+	listOfURLs: [],
+	
+	// refreshing: boolean
+	//	For advanced usage; most developers can ignore this.
+	//	Whether we are currently in the middle
+	//	of refreshing our list of offline files.
+	refreshing: false,
+
+	_cancelID: null,
+	
+	_error: false,
+	_errorMessages: [],
+	_currentFileIndex: 0,
+	_store: null,
+	_doSlurp: false,
+	
+	slurp: function(){
+		// summary:
+		//	Autoscans the page to find all resources to
+		//	cache. This includes scripts, images, CSS, and hyperlinks
+		//	to pages that are in the same scheme/port/host as this
+		//	page. We also scan the embedded CSS of any stylesheets
+		//	to find @import statements and url()'s.
+		//  You should call this method from the top-level, outside of
+		//	any functions and before the page loads:
+		//
+		//	<script>
+		//		
+		//		
+		//		
+		//		
+		//
+		//		// configure how we should work offline
+		//
+		//		// set our application name
+		//		dojox.off.ui.appName = "Moxie";
+		//
+		//		// automatically "slurp" the page and
+		//		// capture the resources we need offline
+		//		dojox.off.files.slurp();
+		//
+		// 		// tell Dojo Offline we are ready for it to initialize itself now
+		//		// that we have finished configuring it for our application
+		//		dojox.off.initialize();
+		//	</script>
+		//
+		//	Note that inline styles on elements are not handled (i.e.
+		//	if you somehow have an inline style that uses a URL);
+		//	object and embed tags are not scanned since their format
+		//	differs based on type; and elements created by JavaScript
+		//	after page load are not found. For these you must manually
+		//	add them with a dojox.off.files.cache() method call.
+		
+		// just schedule the slurp once the page is loaded and
+		// Dojo Offline is ready to slurp; dojox.off will call
+		// our _slurp() method before indicating it is finished
+		// loading
+		this._doSlurp = true;
+	},
+	
+	cache: function(urlOrList){ /* void */
+		// summary:
+		//		Caches a file or list of files to be available offline. This
+		//		can either be a full URL, such as http://foobar.com/index.html,
+		//		or a relative URL, such as ../index.html. This URL is not
+		//		actually cached until dojox.off.sync.synchronize() is called.
+		// urlOrList: String or Array[]
+		//		A URL of a file to cache or an Array of Strings of files to
+		//		cache
+		
+		//console.debug("dojox.off.files.cache, urlOrList="+urlOrList);
+		
+		if(dojo.isString(urlOrList)){
+			var url = this._trimAnchor(urlOrList+"");
+			if(!this.isAvailable(url)){ 
+				this.listOfURLs.push(url); 
+			}
+		}else if(urlOrList instanceof dojo._Url){
+			var url = this._trimAnchor(urlOrList.uri);
+			if(!this.isAvailable(url)){ 
+				this.listOfURLs.push(url); 
+			}
+		}else{
+			dojo.forEach(urlOrList, function(url){
+				url = this._trimAnchor(url);
+				if(!this.isAvailable(url)){ 
+					this.listOfURLs.push(url); 
+				}
+			}, this);
+		}
+	},
+	
+	printURLs: function(){
+		// summary:
+		//	A helper function that will dump and print out
+		//	all of the URLs that are cached for offline
+		//	availability. This can help with debugging if you
+		//	are trying to make sure that all of your URLs are
+		//	available offline
+		console.debug("The following URLs are cached for offline use:");
+		dojo.forEach(this.listOfURLs, function(i){
+			console.debug(i);
+		});	
+	},
+	
+	remove: function(url){ /* void */
+		// summary:
+		//		Removes a URL from the list of files to cache.
+		// description:
+		//		Removes a URL from the list of URLs to cache. Note that this
+		//		does not actually remove the file from the offline cache;
+		//		instead, it just prevents us from refreshing this file at a
+		//		later time, so that it will naturally time out and be removed
+		//		from the offline cache
+		// url: String
+		//		The URL to remove
+		for(var i = 0; i < this.listOfURLs.length; i++){
+			if(this.listOfURLs[i] == url){
+				this.listOfURLs = this.listOfURLs.splice(i, 1);
+				break;
+			}
+		}
+	},
+	
+	isAvailable: function(url){ /* boolean */
+		// summary:
+		//		Determines whether the given resource is available offline.
+		// url: String
+		//	The URL to check
+		for(var i = 0; i < this.listOfURLs.length; i++){
+			if(this.listOfURLs[i] == url){
+				return true;
+			}
+		}
+		
+		return false;
+	},
+	
+	refresh: function(callback){ /* void */
+		//console.debug("dojox.off.files.refresh");
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Refreshes our list of offline resources,
+		//	making them available offline.
+		// callback: Function
+		//	A callback that receives two arguments: whether an error
+		//	occurred, which is a boolean; and an array of error message strings
+		//	with details on errors encountered. If no error occured then message is
+		//	empty array with length 0.
+		try{
+			if(dojo.config.isDebug){
+				this.printURLs();
+			}
+			
+			this.refreshing = true;
+			
+			if(this.versionURL){
+				this._getVersionInfo(function(oldVersion, newVersion, justDebugged){
+					//console.warn("getVersionInfo, oldVersion="+oldVersion+", newVersion="+newVersion
+					//				+ ", justDebugged="+justDebugged+", isDebug="+dojo.config.isDebug);
+					if(dojo.config.isDebug || !newVersion || justDebugged 
+							|| !oldVersion || oldVersion != newVersion){
+						console.warn("Refreshing offline file list");
+						this._doRefresh(callback, newVersion);
+					}else{
+						console.warn("No need to refresh offline file list");
+						callback(false, []);
+					}
+				});
+			}else{
+				console.warn("Refreshing offline file list");
+				this._doRefresh(callback);
+			}
+		}catch(e){
+			this.refreshing = false;
+                       
+			// can't refresh files -- core operation --
+			// fail fast
+			dojox.off.coreOpFailed = true;
+			dojox.off.enabled = false;
+			dojox.off.onFrameworkEvent("coreOperationFailed");
+		}
+	},
+	
+	abortRefresh: function(){
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Aborts and cancels a refresh.
+		if(!this.refreshing){
+			return;
+		}
+		
+		this._store.abortCapture(this._cancelID);
+		this.refreshing = false;
+	},
+	
+	_slurp: function(){
+		if(!this._doSlurp){
+			return;
+		}
+		
+		var handleUrl = dojo.hitch(this, function(url){
+			if(this._sameLocation(url)){
+				this.cache(url);
+			}
+		});
+		
+		handleUrl(window.location.href);
+		
+		dojo.query("script").forEach(function(i){
+			try{
+				handleUrl(i.getAttribute("src"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'script' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		dojo.query("link").forEach(function(i){
+			try{
+				if(!i.getAttribute("rel")
+					|| i.getAttribute("rel").toLowerCase() != "stylesheet"){
+					return;
+				}
+			
+				handleUrl(i.getAttribute("href"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'link' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		dojo.query("img").forEach(function(i){
+			try{
+				handleUrl(i.getAttribute("src"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'img' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		dojo.query("a").forEach(function(i){
+			try{
+				handleUrl(i.getAttribute("href"));
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp 'a' error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		// FIXME: handle 'object' and 'embed' tag
+		
+		// parse our style sheets for inline URLs and imports
+		dojo.forEach(document.styleSheets, function(sheet){
+			try{
+				if(sheet.cssRules){ // Firefox
+					dojo.forEach(sheet.cssRules, function(rule){
+						var text = rule.cssText;
+						if(text){
+							var matches = text.match(/url\(\s*([^\) ]*)\s*\)/i);
+							if(!matches){
+								return;
+							}
+							
+							for(var i = 1; i < matches.length; i++){
+								handleUrl(matches[i])
+							}
+						}
+					});
+				}else if(sheet.cssText){ // IE
+					var matches;
+					var text = sheet.cssText.toString();
+					// unfortunately, using RegExp.exec seems to be flakey
+					// for looping across multiple lines on IE using the
+					// global flag, so we have to simulate it
+					var lines = text.split(/\f|\r|\n/);
+					for(var i = 0; i < lines.length; i++){
+						matches = lines[i].match(/url\(\s*([^\) ]*)\s*\)/i);
+						if(matches && matches.length){
+							handleUrl(matches[1]);
+						}
+					}
+				}
+			}catch(exp){
+				//console.debug("dojox.off.files.slurp stylesheet parse error: " 
+				//				+ exp.message||exp);
+			}
+		});
+		
+		//this.printURLs();
+	},
+	
+	_sameLocation: function(url){
+		if(!url){ return false; }
+		
+		// filter out anchors
+		if(url.length && url.charAt(0) == "#"){
+			return false;
+		}
+		
+		// FIXME: dojo._Url should be made public;
+		// it's functionality is very useful for
+		// parsing URLs correctly, which is hard to
+		// do right
+		url = new dojo._Url(url);
+		
+		// totally relative -- ../../someFile.html
+		if(!url.scheme && !url.port && !url.host){ 
+			return true;
+		}
+		
+		// scheme relative with port specified -- brad.com:8080
+		if(!url.scheme && url.host && url.port
+				&& window.location.hostname == url.host
+				&& window.location.port == url.port){
+			return true;
+		}
+		
+		// scheme relative with no-port specified -- brad.com
+		if(!url.scheme && url.host && !url.port
+			&& window.location.hostname == url.host
+			&& window.location.port == 80){
+			return true;
+		}
+		
+		// else we have everything
+		return  window.location.protocol == (url.scheme + ":")
+				&& window.location.hostname == url.host
+				&& (window.location.port == url.port || !window.location.port && !url.port);
+	},
+	
+	_trimAnchor: function(url){
+		return url.replace(/\#.*$/, "");
+	},
+	
+	_doRefresh: function(callback, newVersion){
+		// get our local server
+		var localServer;
+		try{
+			localServer = google.gears.factory.create("beta.localserver", "1.0");
+		}catch(exp){
+			dojo.setObject("google.gears.denied", true);
+			dojox.off.onFrameworkEvent("coreOperationFailed");
+			throw "Google Gears must be allowed to run";
+		}
+		
+		var storeName = "dot_store_" 
+							+ window.location.href.replace(/[^0-9A-Za-z_]/g, "_");
+							
+		// clip at 64 characters, the max length of a resource store name
+		if(storeName.length >= 64){
+		  storeName = storeName.substring(0, 63);
+		}
+			
+		// refresh everything by simply removing
+		// any older stores
+		localServer.removeStore(storeName);
+		
+		// open/create the resource store
+		localServer.openStore(storeName);
+		var store = localServer.createStore(storeName);
+		this._store = store;
+
+		// add our list of files to capture
+		var self = this;
+		this._currentFileIndex = 0;
+		this._cancelID = store.capture(this.listOfURLs, function(url, success, captureId){
+			//console.debug("store.capture, url="+url+", success="+success);
+			if(!success && self.refreshing){
+				self._cancelID = null;
+				self.refreshing = false;
+				var errorMsgs = [];
+				errorMsgs.push("Unable to capture: " + url);
+				callback(true, errorMsgs);
+				return;
+			}else if(success){
+				self._currentFileIndex++;
+			}
+			
+			if(success && self._currentFileIndex >= self.listOfURLs.length){
+				self._cancelID = null;
+				self.refreshing = false;
+				if(newVersion){
+					dojox.storage.put("oldVersion", newVersion, null,
+									dojox.off.STORAGE_NAMESPACE);
+				}
+				dojox.storage.put("justDebugged", dojo.config.isDebug, null,
+									dojox.off.STORAGE_NAMESPACE);
+				callback(false, []);
+			}
+		});
+	},
+	
+	_getVersionInfo: function(callback){
+		var justDebugged = dojox.storage.get("justDebugged", 
+									dojox.off.STORAGE_NAMESPACE);
+		var oldVersion = dojox.storage.get("oldVersion",
+									dojox.off.STORAGE_NAMESPACE);
+		var newVersion = null;
+		
+		callback = dojo.hitch(this, callback);
+		
+		dojo.xhrGet({
+				url: this.versionURL + "?browserbust=" + new Date().getTime(),
+				timeout: 5 * 1000,
+				handleAs: "javascript",
+				error: function(err){
+					//console.warn("dojox.off.files._getVersionInfo, err=",err);
+					dojox.storage.remove("oldVersion", dojox.off.STORAGE_NAMESPACE);
+					dojox.storage.remove("justDebugged", dojox.off.STORAGE_NAMESPACE);
+					callback(oldVersion, newVersion, justDebugged);
+				},
+				load: function(data){
+					//console.warn("dojox.off.files._getVersionInfo, load=",data);
+					
+					// some servers incorrectly return 404's
+					// as a real page
+					if(data){
+						newVersion = data;
+					}
+					
+					callback(oldVersion, newVersion, justDebugged);
+				}
+		});
+	}
+}
+
+}
+
+if(!dojo._hasResource["dojox.off.sync"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off.sync"] = true;
+dojo.provide("dojox.off.sync");
+
+
+
+
+
+// Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org
+
+// summary:
+//		Exposes syncing functionality to offline applications
+dojo.mixin(dojox.off.sync, {
+	// isSyncing: boolean
+	//		Whether we are in the middle of a syncing session.
+	isSyncing: false,
+	
+	// cancelled: boolean
+	//		Whether we were cancelled during our last sync request or not. If
+	//		we are cancelled, then successful will be false.
+	cancelled: false,
+	
+	// successful: boolean
+	//		Whether the last sync was successful or not.  If false, an error
+	//		occurred.
+	successful: true,
+	
+	// details: String[]
+	//		Details on the sync. If the sync was successful, this will carry
+	//		any conflict or merging messages that might be available; if the
+	//		sync was unsuccessful, this will have an error message.  For both
+	//		of these, this should be an array of Strings, where each string
+	//		carries details on the sync. 
+	//	Example: 
+	//		dojox.off.sync.details = ["The document 'foobar' had conflicts - yours one",
+	//						"The document 'hello world' was automatically merged"];
+	details: [],
+	
+	// error: boolean
+	//		Whether an error occurred during the syncing process.
+	error: false,
+	
+	// actions: dojox.off.sync.ActionLog
+	//		Our ActionLog that we store offline actions into for later
+	//		replaying when we go online
+	actions: null,
+	
+	// autoSync: boolean
+	//		For advanced usage; most developers can ignore this.
+	//		Whether we do automatically sync on page load or when we go online.
+	//		If true we do, if false syncing must be manually initiated.
+	//		Defaults to true.
+	autoSync: true,
+	
+	// summary:
+	//	An event handler that is called during the syncing process with
+	//	the state of syncing. It is important that you connect to this
+	//	method and respond to certain sync events, especially the 
+	//	"download" event.
+	// description:
+	//	This event handler is called during the syncing process. You can
+	//	do a dojo.connect to receive sync feedback:
+	//
+	//		dojo.connect(dojox.off.sync, "onSync", someFunc);
+	//
+	//	You will receive one argument, which is the type of the event
+	//	and which can have the following values.
+	//
+	//	The most common two types that you need to care about are "download"
+	//	and "finished", especially if you are using the default
+	//	Dojo Offline UI widget that does the hard work of informing
+	//	the user through the UI about what is occuring during syncing.
+	//
+	//	If you receive the "download" event, you should make a network call
+	//	to retrieve and store your data somehow for offline access. The
+	//	"finished" event indicates that syncing is done. An example:
+	//	
+	//		dojo.connect(dojox.off.sync, "onSync", function(type){
+	//			if(type == "download"){
+	//				// make a network call to download some data
+	//				// for use offline
+	//				dojo.xhrGet({
+	//					url: 		"downloadData.php",
+	//					handleAs:	"javascript",
+	//					error:		function(err){
+	//						dojox.off.sync.finishedDownloading(false, "Can't download data");
+	//					},
+	//					load:		function(data){
+	//						// store our data
+	//						dojox.storage.put("myData", data);
+	//
+	//						// indicate we are finished downloading
+	//						dojox.off.sync.finishedDownloading(true);
+	//					}
+	//				});
+	//			}else if(type == "finished"){
+	//				// update UI somehow to indicate we are finished,
+	//				// such as using the download data to change the 
+	//				// available data
+	//			}
+	//		})
+	//
+	//	Here is the full list of event types if you want to do deep
+	//	customization, such as updating your UI to display the progress
+	//	of syncing (note that the default Dojo Offline UI widget does
+	//	this for you if you choose to pull that in). Most of these
+	//	are only appropriate for advanced usage and can be safely
+	//	ignored:
+	//
+	//		* "start"
+	//				syncing has started
+	//		* "refreshFiles"
+	//				syncing will begin refreshing
+	//				our offline file cache
+	//		* "upload"
+	//				syncing will begin uploading
+	//				any local data changes we have on the client.
+	//				This event is fired before we fire
+	//				the dojox.off.sync.actions.onReplay event for
+	//				each action to replay; use it to completely
+	//				over-ride the replaying behavior and prevent
+	//				it entirely, perhaps rolling your own sync
+	//				protocol if needed.
+	//		* "download"
+	//				syncing will begin downloading any new data that is
+	//				needed into persistent storage. Applications are required to
+	//				implement this themselves, storing the required data into
+	//				persistent local storage using Dojo Storage.
+	//		* "finished"
+	//				syncing is finished; this
+	//				will be called whether an error ocurred or not; check
+	//				dojox.off.sync.successful and dojox.off.sync.error for sync details
+	//		* "cancel"
+	//				Fired when canceling has been initiated; canceling will be
+	//				attempted, followed by the sync event "finished".
+	onSync: function(/* String */ type){},
+	
+	synchronize: function(){ /* void */
+		// summary: Starts synchronizing
+
+		//dojo.debug("synchronize");
+		if(this.isSyncing || dojox.off.goingOnline || (!dojox.off.isOnline)){
+			return;
+		}
+	
+		this.isSyncing = true;
+		this.successful = false;
+		this.details = [];
+		this.cancelled = false;
+		
+		this.start();
+	},
+	
+	cancel: function(){ /* void */
+		// summary:
+		//	Attempts to cancel this sync session
+		
+		if(!this.isSyncing){ return; }
+		
+		this.cancelled = true;
+		if(dojox.off.files.refreshing){
+			dojox.off.files.abortRefresh();
+		}
+		
+		this.onSync("cancel");
+	},
+	
+	finishedDownloading: function(successful /* boolean? */, 
+									errorMessage /* String? */){
+		// summary:
+		//		Applications call this method from their
+		//		after getting a "download" event in
+		//		dojox.off.sync.onSync to signal that
+		//		they are finished downloading any data 
+		//		that should be available offline
+		// successful: boolean?
+		//		Whether our downloading was successful or not.
+		//		If not present, defaults to true.
+		// errorMessage: String?
+		//		If unsuccessful, a message explaining why
+		if(typeof successful == "undefined"){
+			successful = true;
+		}
+		
+		if(!successful){
+			this.successful = false;
+			this.details.push(errorMessage);
+			this.error = true;
+		}
+		
+		this.finished();
+	},
+	
+	start: function(){ /* void */
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Called at the start of the syncing process. Advanced
+		//	developers can over-ride this method to use their
+		//	own sync mechanism to start syncing.
+		
+		if(this.cancelled){
+			this.finished();
+			return;
+		}
+		this.onSync("start");
+		this.refreshFiles();
+	},
+	
+	refreshFiles: function(){ /* void */
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Called when we are going to refresh our list
+		//	of offline files during syncing. Advanced developers 
+		//	can over-ride this method to do some advanced magic related to
+		//	refreshing files.
+		
+		//dojo.debug("refreshFiles");
+		if(this.cancelled){
+			this.finished();
+			return;
+		}
+		
+		this.onSync("refreshFiles");
+		
+		dojox.off.files.refresh(dojo.hitch(this, function(error, errorMessages){
+			if(error){
+				this.error = true;
+				this.successful = false;
+				for(var i = 0; i < errorMessages.length; i++){
+					this.details.push(errorMessages[i]);
+				}
+				
+				// even if we get an error while syncing files,
+				// keep syncing so we can upload and download
+				// data
+			}
+			
+			this.upload();
+		}));
+	},
+	
+	upload: function(){ /* void */
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Called when syncing wants to upload data. Advanced
+		//	developers can over-ride this method to completely
+		//	throw away the Action Log and replaying system
+		//	and roll their own advanced sync mechanism if needed.
+		
+		if(this.cancelled){
+			this.finished();
+			return;
+		}
+		
+		this.onSync("upload");
+		
+		// when we are done uploading start downloading
+		dojo.connect(this.actions, "onReplayFinished", this, this.download);
+		
+		// replay the actions log
+		this.actions.replay();
+	},
+	
+	download: function(){ /* void */
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Called when syncing wants to download data. Advanced
+		//	developers can over-ride this method to use their
+		//	own sync mechanism.
+		
+		if(this.cancelled){
+			this.finished();
+			return;
+		}
+		
+		// apps should respond to the "download"
+		// event to download their data; when done
+		// they must call dojox.off.sync.finishedDownloading()
+		this.onSync("download");
+	},
+	
+	finished: function(){ /* void */
+		// summary:
+		//	For advanced usage; most developers can ignore this.
+		//	Called when syncing is finished. Advanced
+		//	developers can over-ride this method to clean
+		//	up after finishing their own sync
+		//	mechanism they might have rolled.
+		this.isSyncing = false;
+		
+		this.successful = (!this.cancelled && !this.error);
+		
+		this.onSync("finished");
+	},
+	
+	_save: function(callback){
+		this.actions._save(function(){
+			callback();
+		});
+	},
+	
+	_load: function(callback){
+		this.actions._load(function(){
+			callback();
+		});
+	}
+});
+
+
+// summary:
+//		A class that records actions taken by a user when they are offline,
+//		suitable for replaying when the network reappears. 
+// description:
+//		The basic idea behind this method is to record user actions that would
+//		normally have to contact a server into an action log when we are
+//		offline, so that later when we are online we can simply replay this log
+//		in the order user actions happened so that they can be executed against
+//		the server, causing synchronization to happen. 
+//		
+//		When we replay, for each of the actions that were added, we call a 
+//		method named onReplay that applications should connect to and 
+//		which will be called over and over for each of our actions -- 
+//		applications should take the offline action
+//		information and use it to talk to a server to have this action
+//		actually happen online, 'syncing' themselves with the server. 
+//
+//		For example, if the action was "update" with the item that was updated, we
+//		might call some RESTian server API that exists for updating an item in
+//		our application.  The server could either then do sophisticated merging
+//		and conflict resolution on the server side, for example, allowing you
+//		to pop up a custom merge UI, or could do automatic merging or nothing
+//		of the sort. When you are finished with this particular action, your
+//		application is then required to call continueReplay() on the actionLog object
+//		passed to onReplay() to continue replaying the action log, or haltReplay()
+//		with the reason for halting to completely stop the syncing/replaying
+//		process.
+//
+//		For example, imagine that we have a web application that allows us to add
+//		contacts. If we are offline, and we update a contact, we would add an action;
+//		imagine that the user has to click an Update button after changing the values
+//		for a given contact:
+//	
+//		dojox.off.whenOffline(dojo.byId("updateButton"), "onclick", function(evt){
+//			// get the updated customer values
+//			var customer = getCustomerValues();
+//			
+//			// we are offline -- just record this action
+//			var action = {name: "update", customer: customer};
+//			dojox.off.sync.actions.add(action)
+//			
+//			// persist this customer data into local storage as well
+//			dojox.storage.put(customer.name, customer);
+//		})
+//
+//		Then, when we go back online, the dojox.off.sync.actions.onReplay event
+//		will fire over and over, once for each action that was recorded while offline:
+//
+//		dojo.connect(dojox.off.sync.actions, "onReplay", function(action, actionLog){
+//			// called once for each action we added while offline, in the order
+//			// they were added
+//			if(action.name == "update"){
+//				var customer = action.customer;
+//				
+//				// call some network service to update this customer
+//				dojo.xhrPost({
+//					url: "updateCustomer.php",
+//					content: {customer: dojo.toJson(customer)},
+//					error: function(err){
+//						actionLog.haltReplay(err);
+//					},
+//					load: function(data){
+//						actionLog.continueReplay();
+//					}
+//				})
+//			}
+//		})
+//
+//		Note that the actions log is always automatically persisted locally while using it, so
+//		that if the user closes the browser or it crashes the actions will safely be stored
+//		for later replaying.
+dojo.declare("dojox.off.sync.ActionLog", null, {
+		// entries: Array
+		//		An array of our action entries, where each one is simply a custom
+		//		object literal that were passed to add() when this action entry
+		//		was added.
+		entries: [],
+		
+		// reasonHalted: String
+		//		If we halted, the reason why
+		reasonHalted: null,
+		
+		// isReplaying: boolean
+		//		If true, we are in the middle of replaying a command log; if false,
+		//		then we are not
+		isReplaying: false,
+		
+		// autoSave: boolean
+		//		Whether we automatically save the action log after each call to
+		//		add(); defaults to true. For applications that are rapidly adding
+		//		many action log entries in a short period of time, it can be
+		//		useful to set this to false and simply call save() yourself when
+		//		you are ready to persist your command log -- otherwise performance
+		//		could be slow as the default action is to attempt to persist the
+		//		actions log constantly with calls to add().
+		autoSave: true,
+		
+		add: function(action /* Object */){ /* void */
+			// summary:
+			//	Adds an action to our action log
+			// description:
+			//	This method will add an action to our
+			//	action log, later to be replayed when we
+			//	go from offline to online. 'action'
+			//	will be available when this action is
+			//	replayed and will be passed to onReplay.
+			//
+			//	Example usage:
+			//	
+			//	dojox.off.sync.log.add({actionName: "create", itemType: "document",
+			//					  {title: "Message", content: "Hello World"}});
+			// 
+			//	The object literal is simply a custom object appropriate
+			//	for our application -- it can be anything that preserves the state
+			//	of a user action that will be executed when we go back online
+			//	and replay this log. In the above example,
+			//	"create" is the name of this action; "documents" is the 
+			//	type of item this command is operating on, such as documents, contacts,
+			//	tasks, etc.; and the final argument is the document that was created. 
+			
+			if(this.isReplaying){
+				throw "Programming error: you can not call "
+						+ "dojox.off.sync.actions.add() while "
+						+ "we are replaying an action log";
+			}
+			
+			this.entries.push(action);
+			
+			// save our updated state into persistent
+			// storage
+			if(this.autoSave){
+				this._save();
+			}
+		},
+		
+		onReplay: function(action /* Object */, 
+							actionLog /* dojox.off.sync.ActionLog */){ /* void */
+			// summary:
+			//	Called when we replay our log, for each of our action
+			//	entries.
+			// action: Object
+			//	A custom object literal representing an action for this
+			//	application, such as 
+			//	{actionName: "create", item: {title: "message", content: "hello world"}}
+			// actionLog: dojox.off.sync.ActionLog
+			//	A reference to the dojox.off.sync.actions log so that developers
+			//	can easily call actionLog.continueReplay() or actionLog.haltReplay().
+			// description:
+			//	This callback should be connected to by applications so that
+			//	they can sync themselves when we go back online:
+			//
+			//		dojo.connect(dojox.off.sync.actions, "onReplay", function(action, actionLog){
+			//				// do something
+			//		})
+			//
+			//	When we replay our action log, this callback is called for each
+			//	of our action entries in the order they were added. The 
+			//	'action' entry that was passed to add() for this action will 
+			//	also be passed in to onReplay, so that applications can use this information
+			//	to do their syncing, such as contacting a server web-service
+			//	to create a new item, for example. 
+			// 
+			//	Inside the method you connected to onReplay, you should either call
+			//	actionLog.haltReplay(reason) if an error occurred and you would like to halt
+			//	action replaying or actionLog.continueReplay() to have the action log
+			//	continue replaying its log and proceed to the next action; 
+			//	the reason you must call these is the action you execute inside of 
+			//	onAction will probably be asynchronous, since it will be talking on 
+			//	the network, and you should call one of these two methods based on 
+			//	the result of your network call.
+		},
+		
+		length: function(){ /* Number */
+			// summary:
+			//	Returns the length of this 
+			//	action log
+			return this.entries.length;
+		},
+		
+		haltReplay: function(reason /* String */){ /* void */
+			// summary: Halts replaying this command log.
+			// reason: String
+			//		The reason we halted.
+			// description:
+			//		This method is called as we are replaying an action log; it
+			//		can be called from dojox.off.sync.actions.onReplay, for
+			//		example, for an application to indicate an error occurred
+			//		while replaying this action, halting further processing of
+			//		the action log. Note that any action log entries that
+			//		were processed before have their effects retained (i.e.
+			//		they are not rolled back), while the action entry that was
+			//		halted stays in our list of actions to later be replayed.	
+			if(!this.isReplaying){
+				return;
+			}
+			
+			if(reason){
+				this.reasonHalted = reason.toString();		
+			}
+			
+			// save the state of our action log, then
+			// tell anyone who is interested that we are
+			// done when we are finished saving
+			if(this.autoSave){
+				var self = this;
+				this._save(function(){
+					self.isReplaying = false;
+					self.onReplayFinished();
+				});
+			}else{
+				this.isReplaying = false;
+				this.onReplayFinished();
+			}
+		},
+		
+		continueReplay: function(){ /* void */
+			// summary:
+			//		Indicates that we should continue processing out list of
+			//		actions.
+			// description:
+			//		This method is called by applications that have overridden
+			//		dojox.off.sync.actions.onReplay() to continue replaying our 
+			//		action log after the application has finished handling the 
+			//		current action.
+			if(!this.isReplaying){
+				return;
+			}
+			
+			// shift off the old action we just ran
+			this.entries.shift();
+			
+			// are we done?
+			if(!this.entries.length){
+				// save the state of our action log, then
+				// tell anyone who is interested that we are
+				// done when we are finished saving
+				if(this.autoSave){
+					var self = this;
+					this._save(function(){
+						self.isReplaying = false;
+						self.onReplayFinished();
+					});
+					return;
+				}else{
+					this.isReplaying = false;
+					this.onReplayFinished();
+					return;
+				}
+			}
+			
+			// get the next action
+			var nextAction = this.entries[0];
+			this.onReplay(nextAction, this);
+		},
+		
+		clear: function(){ /* void */
+			// summary:
+			//	Completely clears this action log of its entries
+			
+			if(this.isReplaying){
+				return;
+			}
+			
+			this.entries = [];
+			
+			// save our updated state into persistent
+			// storage
+			if(this.autoSave){
+				this._save();
+			}
+		},
+		
+		replay: function(){ /* void */
+			// summary:
+			//	For advanced usage; most developers can ignore this.
+			//	Replays all of the commands that have been
+			//	cached in this command log when we go back online;
+			//	onCommand will be called for each command we have
+			
+			if(this.isReplaying){
+				return;
+			}
+			
+			this.reasonHalted = null;
+			
+			if(!this.entries.length){
+				this.onReplayFinished();
+				return;
+			}
+			
+			this.isReplaying = true;
+			
+			var nextAction = this.entries[0];
+			this.onReplay(nextAction, this);
+		},
+		
+		// onReplayFinished: Function
+		//	For advanced usage; most developers can ignore this.
+		//	Called when we are finished replaying our commands;
+		//	called if we have successfully exhausted all of our
+		//	commands, or if an error occurred during replaying.
+		//	The default implementation simply continues the
+		//	synchronization process. Connect to this to register
+		//	for the event:
+		//
+		//		dojo.connect(dojox.off.sync.actions, "onReplayFinished", 
+		//					someFunc)
+		onReplayFinished: function(){
+		},
+
+		toString: function(){
+			var results = "";
+			results += "[";
+			
+			for(var i = 0; i < this.entries.length; i++){
+				results += "{";
+				for(var j in this.entries[i]){
+					results += j + ": \"" + this.entries[i][j] + "\"";
+					results += ", ";
+				}
+				results += "}, ";
+			}
+			
+			results += "]";
+			
+			return results;
+		},
+		
+		_save: function(callback){
+			if(!callback){
+				callback = function(){};
+			}
+			
+			try{
+				var self = this;
+				var resultsHandler = function(status, key, message){
+					//console.debug("resultsHandler, status="+status+", key="+key+", message="+message);
+					if(status == dojox.storage.FAILED){
+						dojox.off.onFrameworkEvent("save", 
+											{status: dojox.storage.FAILED,
+											isCoreSave: true,
+											key: key,
+											value: message,
+											namespace: dojox.off.STORAGE_NAMESPACE});
+						callback();
+					}else if(status == dojox.storage.SUCCESS){
+						callback();
+					}
+				};
+				
+				dojox.storage.put("actionlog", this.entries, resultsHandler,
+									dojox.off.STORAGE_NAMESPACE);
+			}catch(exp){
+				console.debug("dojox.off.sync._save: " + exp.message||exp);
+				dojox.off.onFrameworkEvent("save",
+							{status: dojox.storage.FAILED,
+							isCoreSave: true,
+							key: "actionlog",
+							value: this.entries,
+							namespace: dojox.off.STORAGE_NAMESPACE});
+				callback();
+			}
+		},
+		
+		_load: function(callback){
+			var entries = dojox.storage.get("actionlog", dojox.off.STORAGE_NAMESPACE);
+			
+			if(!entries){
+				entries = [];
+			}
+			
+			this.entries = entries;
+			
+			callback();
+		}
+	}
+);
+
+dojox.off.sync.actions = new dojox.off.sync.ActionLog();
+
+}
+
+if(!dojo._hasResource["dojox.off._common"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off._common"] = true;
+dojo.provide("dojox.off._common");
+
+
+
+
+
+// Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org
+
+// summary:
+//		dojox.off is the main object for offline applications.
+dojo.mixin(dojox.off, {
+	// isOnline: boolean
+	//	true if we are online, false if not
+	isOnline: false,
+	
+	// NET_CHECK: int
+	//		For advanced usage; most developers can ignore this.
+	//		Time in seconds on how often we should check the status of the
+	//		network with an automatic background timer. The current default
+	//		is 5 seconds.
+	NET_CHECK: 5,
+	
+	// STORAGE_NAMESPACE: String
+	//		For advanced usage; most developers can ignore this.
+	//		The namespace we use to save core data into Dojo Storage.
+	STORAGE_NAMESPACE: "_dot",
+	
+	// enabled: boolean
+	//		For advanced usage; most developers can ignore this.
+	//		Whether offline ability is enabled or not. Defaults to true.
+	enabled: true,
+	
+	// availabilityURL: String
+	//		For advanced usage; most developers can ignore this.
+	//		The URL to check for site availability.  We do a GET request on
+	//		this URL to check for site availability.  By default we check for a
+	//		simple text file in src/off/network_check.txt that has one value
+	//		it, the value '1'.
+	availabilityURL: dojo.moduleUrl("dojox", "off/network_check.txt"),
+	
+	// goingOnline: boolean
+	//		For advanced usage; most developers can ignore this.
+	//		True if we are attempting to go online, false otherwise
+	goingOnline: false,
+	
+	// coreOpFailed: boolean
+	//		For advanced usage; most developers can ignore this.
+	//		A flag set by the Dojo Offline framework that indicates that the
+	//		user denied some operation that required the offline cache or an
+	//		operation failed in some critical way that was unrecoverable. For
+	//		example, if the offline cache is Google Gears and we try to get a
+	//		Gears database, a popup window appears asking the user whether they
+	//		will approve or deny this request. If the user denies the request,
+	//		and we are doing some operation that is core to Dojo Offline, then
+	//		we set this flag to 'true'.  This flag causes a 'fail fast'
+	//		condition, turning off offline ability.
+	coreOpFailed: false,
+	
+	// doNetChecking: boolean
+	//		For advanced usage; most developers can ignore this.
+	//		Whether to have a timing interval in the background doing automatic
+	//		network checks at regular intervals; the length of time between
+	//		checks is controlled by dojox.off.NET_CHECK. Defaults to true.
+	doNetChecking: true,
+	
+	// hasOfflineCache: boolean
+	//		For advanced usage; most developers can ignore this.
+	//  	Determines if an offline cache is available or installed; an
+	//  	offline cache is a facility that can truely cache offline
+	//  	resources, such as JavaScript, HTML, etc. in such a way that they
+	//  	won't be removed from the cache inappropriately like a browser
+	//  	cache would. If this is false then an offline cache will be
+	//  	installed. Only Google Gears is currently supported as an offline
+	//  	cache. Future possible offline caches include Firefox 3.
+	hasOfflineCache: null,
+	
+	// browserRestart: boolean
+	//		For advanced usage; most developers can ignore this.
+	//		If true, the browser must be restarted to register the existence of
+	//		a new host added offline (from a call to addHostOffline); if false,
+	//		then nothing is needed.
+	browserRestart: false,
+	
+	_STORAGE_APP_NAME: window.location.href.replace(/[^0-9A-Za-z_]/g, "_"),
+	
+	_initializeCalled: false,
+	_storageLoaded: false,
+	_pageLoaded: false,
+	
+	onLoad: function(){
+		// summary:
+		//	Called when Dojo Offline can be used.
+		// description:
+		//	Do a dojo.connect to this to know when you can
+		//	start using Dojo Offline:
+		//		dojo.connect(dojox.off, "onLoad", myFunc);
+	},
+	
+	onNetwork: function(type){
+		// summary:
+		//	Called when our on- or offline- status changes.
+		// description:
+		//	If we move online, then this method is called with the
+		//	value "online". If we move offline, then this method is
+		//	called with the value "offline". You can connect to this
+		//	method to do add your own behavior:
+		//
+		//		dojo.connect(dojox.off, "onNetwork", someFunc)
+		//
+		//	Note that if you are using the default Dojo Offline UI
+		//	widget that most of the on- and off-line notification
+		//	and syncing is automatically handled and provided to the
+		//	user.
+		// type: String
+		//	Either "online" or "offline".
+	},
+	
+	initialize: function(){ /* void */
+		// summary:
+		//		Called when a Dojo Offline-enabled application is finished
+		//		configuring Dojo Offline, and is ready for Dojo Offline to
+		//		initialize itself.
+		// description:
+		//		When an application has finished filling out the variables Dojo
+		//		Offline needs to work, such as dojox.off.ui.appName, it must
+		//		this method to tell Dojo Offline to initialize itself.
+		
+		//		Note:
+		//		This method is needed for a rare edge case. In some conditions,
+		//		especially if we are dealing with a compressed Dojo build, the
+		//		entire Dojo Offline subsystem might initialize itself and be
+		//		running even before the JavaScript for an application has had a
+		//		chance to run and configure Dojo Offline, causing Dojo Offline
+		//		to have incorrect initialization parameters for a given app,
+		//		such as no value for dojox.off.ui.appName. This method is
+		//		provided to prevent this scenario, to slightly 'slow down' Dojo
+		//		Offline so it can be configured before running off and doing
+		//		its thing.	
+
+		//console.debug("dojox.off.initialize");
+		this._initializeCalled = true;
+		
+		if(this._storageLoaded && this._pageLoaded){
+			this._onLoad();
+		}
+	},
+	
+	goOffline: function(){ /* void */
+		// summary:
+		//		For advanced usage; most developers can ignore this.
+		//		Manually goes offline, away from the network.
+		if((dojox.off.sync.isSyncing)||(this.goingOnline)){ return; }
+		
+		this.goingOnline = false;
+		this.isOnline = false;
+	},
+	
+	goOnline: function(callback){ /* void */
+		// summary: 
+		//		For advanced usage; most developers can ignore this.
+		//		Attempts to go online.
+		// description:
+		//		Attempts to go online, making sure this web application's web
+		//		site is available. 'callback' is called asychronously with the
+		//		result of whether we were able to go online or not.
+		// callback: Function
+		//		An optional callback function that will receive one argument:
+		//		whether the site is available or not and is boolean. If this
+		//		function is not present we call dojo.xoff.onOnline instead if
+		//		we are able to go online.
+		
+		//console.debug("goOnline");
+		
+		if(dojox.off.sync.isSyncing || dojox.off.goingOnline){
+			return;
+		}
+		
+		this.goingOnline = true;
+		this.isOnline = false;
+		
+		// see if can reach our web application's web site
+		this._isSiteAvailable(callback);
+	},
+	
+	onFrameworkEvent: function(type /* String */, saveData /* Object? */){
+		//	summary:
+		//		For advanced usage; most developers can ignore this.
+		//		A standard event handler that can be attached to to find out
+		//		about low-level framework events. Most developers will not need to
+		//		attach to this method; it is meant for low-level information
+		//		that can be useful for updating offline user-interfaces in
+		//		exceptional circumstances. The default Dojo Offline UI
+		//		widget takes care of most of these situations.
+		//	type: String
+		//		The type of the event:
+		//
+		//		* "offlineCacheInstalled"
+		//			An event that is fired when a user
+		//			has installed an offline cache after the page has been loaded.
+		//			If a user didn't have an offline cache when the page loaded, a
+		//			UI of some kind might have prompted them to download one. This
+		//			method is called if they have downloaded and installed an
+		//			offline cache so a UI can reinitialize itself to begin using
+		//			this offline cache.
+		//		* "coreOperationFailed"
+		//			Fired when a core operation during interaction with the
+		//			offline cache is denied by the user. Some offline caches, such
+		//			as Google Gears, prompts the user to approve or deny caching
+		//			files, using the database, and more. If the user denies a
+		//			request that is core to Dojo Offline's operation, we set
+		//			dojox.off.coreOpFailed to true and call this method for
+		//			listeners that would like to respond some how to Dojo Offline
+		//			'failing fast'.
+		//		* "save"
+		//			Called whenever the framework saves data into persistent
+		//			storage. This could be useful for providing save feedback
+		//			or providing appropriate error feedback if saving fails 
+		//			due to a user not allowing the save to occur
+		//	saveData: Object?
+		//		If the type was 'save', then a saveData object is provided with
+		//		further save information. This object has the following properties:	
+		//
+		//		* status - dojox.storage.SUCCESS, dojox.storage.PENDING, dojox.storage.FAILED
+		//		Whether the save succeeded, whether it is pending based on a UI
+		//		dialog asking the user for permission, or whether it failed. 	
+		//
+		//		* isCoreSave - boolean
+		//		If true, then this save was for a core piece of data necessary
+		//		for the functioning of Dojo Offline. If false, then it is a
+		//		piece of normal data being saved for offline access. Dojo
+		//		Offline will 'fail fast' if some core piece of data could not
+		//		be saved, automatically setting dojox.off.coreOpFailed to
+		//		'true' and dojox.off.enabled to 'false'.
+		//
+		// 		* key - String
+		//		The key that we are attempting to persist
+		//
+		// 		* value - Object
+		//		The object we are trying to persist
+		//
+		// 		* namespace - String
+		//		The Dojo Storage namespace we are saving this key/value pair
+		//		into, such as "default", "Documents", "Contacts", etc.
+		//		Optional.
+		if(type == "save"){
+			if(saveData.isCoreSave && (saveData.status == dojox.storage.FAILED)){
+				dojox.off.coreOpFailed = true;
+				dojox.off.enabled = false;
+			
+				// FIXME: Stop the background network thread
+				dojox.off.onFrameworkEvent("coreOperationFailed");
+			}
+		}else if(type == "coreOperationFailed"){
+			dojox.off.coreOpFailed = true;
+			dojox.off.enabled = false;
+			// FIXME: Stop the background network thread
+		}
+	},
+	
+	_checkOfflineCacheAvailable: function(callback){
+		// is a true, offline cache running on this machine?
+		this.hasOfflineCache = dojo.isGears;
+		
+		callback();
+	},
+	
+	_onLoad: function(){
+		//console.debug("dojox.off._onLoad");
+		
+		// both local storage and the page are finished loading
+		
+		// cache the Dojo JavaScript -- just use the default dojo.js
+		// name for the most common scenario
+		// FIXME: TEST: Make sure syncing doesn't break if dojo.js
+		// can't be found, or report an error to developer
+		dojox.off.files.cache(dojo.moduleUrl("dojo", "dojo.js"));
+		
+		// pull in the files needed by Dojo
+		this._cacheDojoResources();
+		
+		// FIXME: need to pull in the firebug lite files here!
+		// workaround or else we will get an error on page load
+		// from Dojo that it can't find 'console.debug' for optimized builds
+		// dojox.off.files.cache(dojo.config.baseRelativePath + "src/debug.js");
+		
+		// make sure that resources needed by all of our underlying
+		// Dojo Storage storage providers will be available
+		// offline
+		dojox.off.files.cache(dojox.storage.manager.getResourceList());
+		
+		// slurp the page if the end-developer wants that
+		dojox.off.files._slurp();
+		
+		// see if we have an offline cache; when done, move
+		// on to the rest of our startup tasks
+		this._checkOfflineCacheAvailable(dojo.hitch(this, "_onOfflineCacheChecked"));
+	},
+	
+	_onOfflineCacheChecked: function(){
+		// this method is part of our _onLoad series of startup tasks
+		
+		// if we have an offline cache, see if we have been added to the 
+		// list of available offline web apps yet
+		if(this.hasOfflineCache && this.enabled){
+			// load framework data; when we are finished, continue
+			// initializing ourselves
+			this._load(dojo.hitch(this, "_finishStartingUp"));
+		}else if(this.hasOfflineCache && !this.enabled){
+			// we have an offline cache, but it is disabled for some reason
+			// perhaps due to the user denying a core operation
+			this._finishStartingUp();
+		}else{
+			this._keepCheckingUntilInstalled();
+		}
+	},
+	
+	_keepCheckingUntilInstalled: function(){
+		// this method is part of our _onLoad series of startup tasks
+		
+		// kick off a background interval that keeps
+		// checking to see if an offline cache has been
+		// installed since this page loaded
+			
+		// FIXME: Gears: See if we are installed somehow after the
+		// page has been loaded
+		
+		// now continue starting up
+		this._finishStartingUp();
+	},
+	
+	_finishStartingUp: function(){
+		//console.debug("dojox.off._finishStartingUp");
+		
+		// this method is part of our _onLoad series of startup tasks
+		
+		if(!this.hasOfflineCache){
+			this.onLoad();
+		}else if(this.enabled){
+			// kick off a thread to check network status on
+			// a regular basis
+			this._startNetworkThread();
+
+			// try to go online
+			this.goOnline(dojo.hitch(this, function(){
+				//console.debug("Finished trying to go online");
+				// indicate we are ready to be used
+				dojox.off.onLoad();
+			}));
+		}else{ // we are disabled or a core operation failed
+			if(this.coreOpFailed){
+				this.onFrameworkEvent("coreOperationFailed");
+			}else{
+				this.onLoad();
+			}
+		}
+	},
+	
+	_onPageLoad: function(){
+		//console.debug("dojox.off._onPageLoad");
+		this._pageLoaded = true;
+		
+		if(this._storageLoaded && this._initializeCalled){
+			this._onLoad();
+		}
+	},
+	
+	_onStorageLoad: function(){
+		//console.debug("dojox.off._onStorageLoad");
+		this._storageLoaded = true;
+		
+		// were we able to initialize storage? if
+		// not, then this is a core operation, and
+		// let's indicate we will need to fail fast
+		if(!dojox.storage.manager.isAvailable()
+			&& dojox.storage.manager.isInitialized()){
+			this.coreOpFailed = true;
+			this.enabled = false;
+		}
+		
+		if(this._pageLoaded && this._initializeCalled){
+			this._onLoad();		
+		}
+	},
+	
+	_isSiteAvailable: function(callback){
+		// summary:
+		//		Determines if our web application's website is available.
+		// description:
+		//		This method will asychronously determine if our web
+		//		application's web site is available, which is a good proxy for
+		//		network availability. The URL dojox.off.availabilityURL is
+		//		used, which defaults to this site's domain name (ex:
+		//		foobar.com). We check for dojox.off.AVAILABILITY_TIMEOUT (in
+		//		seconds) and abort after that
+		// callback: Function
+		//		An optional callback function that will receive one argument:
+		//		whether the site is available or not and is boolean. If this
+		//		function is not present we call dojox.off.onNetwork instead if we
+		//		are able to go online.
+		dojo.xhrGet({
+			url:		this._getAvailabilityURL(),
+			handleAs:	"text",
+			timeout:	this.NET_CHECK * 1000, 
+			error:		dojo.hitch(this, function(err){
+				//console.debug("dojox.off._isSiteAvailable.error: " + err);
+				this.goingOnline = false;
+				this.isOnline = false;
+				if(callback){ callback(false); }
+			}),
+			load:		dojo.hitch(this, function(data){
+				//console.debug("dojox.off._isSiteAvailable.load, data="+data);
+				this.goingOnline = false;
+				this.isOnline = true;
+				
+				if(callback){ callback(true);
+				}else{ this.onNetwork("online"); }
+			})
+		});
+	},
+	
+	_startNetworkThread: function(){
+		//console.debug("startNetworkThread");
+		
+		// kick off a thread that does periodic
+		// checks on the status of the network
+		if(!this.doNetChecking){
+			return;
+		}
+		
+		window.setInterval(dojo.hitch(this, function(){	
+			var d = dojo.xhrGet({
+				url:	 	this._getAvailabilityURL(),
+				handleAs:	"text",
+				timeout: 	this.NET_CHECK * 1000,
+				error:		dojo.hitch(this, 
+								function(err){
+									if(this.isOnline){
+										this.isOnline = false;
+										
+										// FIXME: xhrGet() is not
+										// correctly calling abort
+										// on the XHR object when
+										// it times out; fix inside
+										// there instead of externally
+										// here
+										try{
+											if(typeof d.ioArgs.xhr.abort == "function"){
+												d.ioArgs.xhr.abort();
+											}
+										}catch(e){}
+					
+										// if things fell in the middle of syncing, 
+										// stop syncing
+										dojox.off.sync.isSyncing = false;
+					
+										this.onNetwork("offline");
+									}
+								}
+							),
+				load:		dojo.hitch(this, 
+								function(data){
+									if(!this.isOnline){
+										this.isOnline = true;
+										this.onNetwork("online");
+									}
+								}
+							)
+			});
+
+		}), this.NET_CHECK * 1000);
+	},
+	
+	_getAvailabilityURL: function(){
+		var url = this.availabilityURL.toString();
+		
+		// bust the browser's cache to make sure we are really talking to
+		// the server
+		if(url.indexOf("?") == -1){
+			url += "?";
+		}else{
+			url += "&";
+		}
+		url += "browserbust=" + new Date().getTime();
+		
+		return url;
+	},
+	
+	_onOfflineCacheInstalled: function(){
+		this.onFrameworkEvent("offlineCacheInstalled");
+	},
+	
+	_cacheDojoResources: function(){
+		// if we are a non-optimized build, then the core Dojo bootstrap
+		// system was loaded as separate JavaScript files;
+		// add these to our offline cache list. these are
+		// loaded before the dojo.require() system exists
+		
+		// FIXME: create a better mechanism in the Dojo core to
+		// expose whether you are dealing with an optimized build;
+		// right now we just scan the SCRIPT tags attached to this
+		// page and see if there is one for _base/_loader/bootstrap.js
+		var isOptimizedBuild = true;
+		dojo.forEach(dojo.query("script"), function(i){
+			var src = i.getAttribute("src");
+			if(!src){ return; }
+			
+			if(src.indexOf("_base/_loader/bootstrap.js") != -1){
+				isOptimizedBuild = false;
+			}
+		});
+		
+		if(!isOptimizedBuild){
+			dojox.off.files.cache(dojo.moduleUrl("dojo", "_base.js").uri);
+			dojox.off.files.cache(dojo.moduleUrl("dojo", "_base/_loader/loader.js").uri);
+			dojox.off.files.cache(dojo.moduleUrl("dojo", "_base/_loader/bootstrap.js").uri);
+			
+			// FIXME: pull in the host environment file in a more generic way
+			// for other host environments
+			dojox.off.files.cache(dojo.moduleUrl("dojo", "_base/_loader/hostenv_browser.js").uri);
+		}
+		
+		// add anything that was brought in with a 
+		// dojo.require() that resulted in a JavaScript
+		// URL being fetched
+		
+		// FIXME: modify dojo/_base/_loader/loader.js to
+		// expose a public API to get this information
+	
+		for(var i = 0; i < dojo._loadedUrls.length; i++){
+			dojox.off.files.cache(dojo._loadedUrls[i]);
+		}
+		
+		// FIXME: add the standard Dojo CSS file
+	},
+	
+	_save: function(){
+		// summary:
+		//		Causes the Dojo Offline framework to save its configuration
+		//		data into local storage.	
+	},
+	
+	_load: function(callback){
+		// summary:
+		//		Causes the Dojo Offline framework to load its configuration
+		//		data from local storage
+		dojox.off.sync._load(callback);
+	}
+});
+
+
+// wait until the storage system is finished loading
+dojox.storage.manager.addOnLoad(dojo.hitch(dojox.off, "_onStorageLoad"));
+
+// wait until the page is finished loading
+dojo.addOnLoad(dojox.off, "_onPageLoad");
+
+}
+
+if(!dojo._hasResource["dojox.off"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off"] = true;
+dojo.provide("dojox.off");
+
+
+}
+
+if(!dojo._hasResource["dojox.off.ui"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off.ui"] = true;
+dojo.provide("dojox.off.ui");
+
+
+
+
+
+// Author: Brad Neuberg, bkn3@columbia.edu, http://codinginparadise.org
+
+// summary:
+//	dojox.off.ui provides a standard,
+//	default user-interface for a 
+//	Dojo Offline Widget that can easily
+//	be dropped into applications that would
+//	like to work offline.
+dojo.mixin(dojox.off.ui, {
+	// appName: String
+	//	This application's name, such as "Foobar". Note that
+	//	this is a string, not HTML, so embedded markup will
+	//	not work, including entities. Only the following
+	//	characters are allowed: numbers, letters, and spaces.
+	//	You must set this property.
+	appName: "setme",
+	
+	// autoEmbed: boolean
+	//	For advanced usage; most developers can ignore this.
+	//	Whether to automatically auto-embed the default Dojo Offline
+	//	widget into this page; default is true. 
+	autoEmbed: true,
+	
+	// autoEmbedID: String
+	//	For advanced usage; most developers can ignore this.
+	//	The ID of the DOM element that will contain our
+	//	Dojo Offline widget; defaults to the ID 'dot-widget'.
+	autoEmbedID: "dot-widget",
+	
+	// runLink: String
+	//	For advanced usage; most developers can ignore this.
+	//	The URL that should be navigated to to run this 
+	//	application offline; this will be placed inside of a
+	//	link that the user can drag to their desktop and double
+	//	click. Note that this URL must exactly match the URL
+	//	of the main page of our resource that is offline for
+	//	it to be retrieved from the offline cache correctly.
+	//	For example, if you have cached your main page as
+	//	http://foobar.com/index.html, and you set this to
+	//	http://www.foobar.com/index.html, the run link will
+	//	not work. By default this value is automatically set to 
+	//	the URL of this page, so it does not need to be set
+	//	manually unless you have unusual needs.
+	runLink: window.location.href,
+	
+	// runLinkTitle: String
+	//	For advanced usage; most developers can ignore this.
+	//	The text that will be inside of the link that a user
+	//	can drag to their desktop to run this application offline.
+	//	By default this is automatically set to "Run " plus your
+	//	application's name.
+	runLinkTitle: "Run Application",
+	
+	// learnHowPath: String
+	//	For advanced usage; most developers can ignore this.
+	//	The path to a web page that has information on 
+	//	how to use this web app offline; defaults to
+	//	src/off/ui-template/learnhow.html, relative to
+	//	your Dojo installation. Make sure to set
+	//	dojo.to.ui.customLearnHowPath to true if you want
+	//	a custom Learn How page.
+	learnHowPath: dojo.moduleUrl("dojox", "off/resources/learnhow.html"),
+	
+	// customLearnHowPath: boolean
+	//	For advanced usage; most developers can ignore this.
+	//	Whether the developer is using their own custom page
+	//	for the Learn How instructional page; defaults to false.
+	//	Use in conjunction with dojox.off.ui.learnHowPath.
+	customLearnHowPath: false,
+	
+	htmlTemplatePath: dojo.moduleUrl("dojox", "off/resources/offline-widget.html").uri,
+	cssTemplatePath: dojo.moduleUrl("dojox", "off/resources/offline-widget.css").uri,
+	onlineImagePath: dojo.moduleUrl("dojox", "off/resources/greenball.png").uri,
+	offlineImagePath: dojo.moduleUrl("dojox", "off/resources/redball.png").uri,
+	rollerImagePath: dojo.moduleUrl("dojox", "off/resources/roller.gif").uri,
+	checkmarkImagePath: dojo.moduleUrl("dojox", "off/resources/checkmark.png").uri,
+	learnHowJSPath: dojo.moduleUrl("dojox", "off/resources/learnhow.js").uri,
+	
+	_initialized: false,
+	
+	onLoad: function(){
+		// summary:
+		//	A function that should be connected to allow your
+		//	application to know when Dojo Offline, the page, and
+		//	the Offline Widget are all initialized and ready to be
+		//	used:
+		//
+		//		dojo.connect(dojox.off.ui, "onLoad", someFunc)
+	},
+
+	_initialize: function(){
+		//console.debug("dojox.off.ui._initialize");
+		
+		// make sure our app name is correct
+		if(this._validateAppName(this.appName) == false){
+			alert("You must set dojox.off.ui.appName; it can only contain "
+					+ "letters, numbers, and spaces; right now it "
+					+ "is incorrectly set to '" + dojox.off.ui.appName + "'");
+			dojox.off.enabled = false;
+			return;
+		}
+		
+		// set our run link text to its default
+		this.runLinkText = "Run " + this.appName;
+		
+		// setup our event listeners for Dojo Offline events
+		// to update our UI
+		dojo.connect(dojox.off, "onNetwork", this, "_onNetwork");
+		dojo.connect(dojox.off.sync, "onSync", this, "_onSync");
+		
+		// cache our default UI resources
+		dojox.off.files.cache([
+							this.htmlTemplatePath,
+							this.cssTemplatePath,
+							this.onlineImagePath,
+							this.offlineImagePath,
+							this.rollerImagePath,
+							this.checkmarkImagePath
+							]);
+		
+		// embed the offline widget UI
+		if(this.autoEmbed){
+			this._doAutoEmbed();
+		}
+	},
+	
+	_doAutoEmbed: function(){
+		// fetch our HTML for the offline widget
+
+		// dispatch the request
+		dojo.xhrGet({
+			url:	 this.htmlTemplatePath,
+			handleAs:	"text",
+			error:		function(err){
+				dojox.off.enabled = false;
+				err = err.message||err;
+				alert("Error loading the Dojo Offline Widget from "
+						+ this.htmlTemplatePath + ": " + err);
+			},
+			load:		dojo.hitch(this, this._templateLoaded)	 
+		});
+	},
+	
+	_templateLoaded: function(data){
+		//console.debug("dojox.off.ui._templateLoaded");
+		// inline our HTML
+		var container = dojo.byId(this.autoEmbedID);
+		if(container){ container.innerHTML = data; }
+		
+		// fill out our image paths
+		this._initImages();
+		
+		// update our network indicator status ball
+		this._updateNetIndicator();
+		
+		// update our 'Learn How' text
+		this._initLearnHow();
+		
+		this._initialized = true;
+		
+		// check offline cache settings
+		if(!dojox.off.hasOfflineCache){
+			this._showNeedsOfflineCache();
+			return;
+		}
+		
+		// check to see if we need a browser restart
+		// to be able to use this web app offline
+		if(dojox.off.hasOfflineCache && dojox.off.browserRestart){
+			this._needsBrowserRestart();
+			return;
+		}else{
+			var browserRestart = dojo.byId("dot-widget-browser-restart");
+			if(browserRestart){ browserRestart.style.display = "none"; }
+		}
+		
+		// update our sync UI
+		this._updateSyncUI();
+		
+		// register our event listeners for our main buttons
+		this._initMainEvtHandlers();
+		
+		// if offline functionality is disabled, disable everything
+		this._setOfflineEnabled(dojox.off.enabled);
+		
+		// update our UI based on the state of the network
+		this._onNetwork(dojox.off.isOnline ? "online" : "offline");
+		
+		// try to go online
+		this._testNet();
+	},
+	
+	_testNet: function(){
+		dojox.off.goOnline(dojo.hitch(this, function(isOnline){
+			//console.debug("testNet callback, isOnline="+isOnline);
+			
+			// display our online/offline results
+			this._onNetwork(isOnline ? "online" : "offline");
+			
+			// indicate that our default UI 
+			// and Dojo Offline are now ready to
+			// be used
+			this.onLoad();
+		}));
+	},
+	
+	_updateNetIndicator: function(){
+		var onlineImg = dojo.byId("dot-widget-network-indicator-online");
+		var offlineImg = dojo.byId("dot-widget-network-indicator-offline");
+		var titleText = dojo.byId("dot-widget-title-text");
+		
+		if(onlineImg && offlineImg){
+			if(dojox.off.isOnline == true){
+				onlineImg.style.display = "inline";
+				offlineImg.style.display = "none";
+			}else{
+				onlineImg.style.display = "none";
+				offlineImg.style.display = "inline";
+			}
+		}
+		
+		if(titleText){
+			if(dojox.off.isOnline){
+				titleText.innerHTML = "Online";
+			}else{
+				titleText.innerHTML = "Offline";
+			}
+		}
+	},
+	
+	_initLearnHow: function(){
+		var learnHow = dojo.byId("dot-widget-learn-how-link");
+		
+		if(!learnHow){ return; }
+		
+		if(!this.customLearnHowPath){
+			// add parameters to URL so the Learn How page
+			// can customize itself and display itself
+			// correctly based on framework settings
+			var dojoPath = dojo.config.baseRelativePath;
+			this.learnHowPath += "?appName=" + encodeURIComponent(this.appName)
+									+ "&hasOfflineCache=" + dojox.off.hasOfflineCache
+									+ "&runLink=" + encodeURIComponent(this.runLink)
+									+ "&runLinkText=" + encodeURIComponent(this.runLinkText)
+									+ "&baseRelativePath=" + encodeURIComponent(dojoPath);
+			
+			// cache our Learn How JavaScript page and
+			// the HTML version with full query parameters
+			// so it is available offline without a cache miss					
+			dojox.off.files.cache(this.learnHowJSPath);
+			dojox.off.files.cache(this.learnHowPath);
+		}
+		
+		learnHow.setAttribute("href", this.learnHowPath);
+		
+		var appName = dojo.byId("dot-widget-learn-how-app-name");
+		
+		if(!appName){ return; }
+		
+		appName.innerHTML = "";
+		appName.appendChild(document.createTextNode(this.appName));
+	},
+	
+	_validateAppName: function(appName){
+		if(!appName){ return false; }
+		
+		return (/^[a-z0-9 ]*$/i.test(appName));
+	},
+	
+	_updateSyncUI: function(){
+		var roller = dojo.byId("dot-roller");
+		var checkmark = dojo.byId("dot-success-checkmark");
+		var syncMessages = dojo.byId("dot-sync-messages");
+		var details = dojo.byId("dot-sync-details");
+		var cancel = dojo.byId("dot-sync-cancel");
+		
+		if(dojox.off.sync.isSyncing){
+			this._clearSyncMessage();
+			
+			if(roller){ roller.style.display = "inline"; }
+			
+			if(checkmark){ checkmark.style.display = "none"; }
+			
+			if(syncMessages){
+				dojo.removeClass(syncMessages, "dot-sync-error");
+			}
+			
+			if(details){ details.style.display = "none"; }
+			
+			if(cancel){ cancel.style.display = "inline"; }
+		}else{	
+			if(roller){ roller.style.display = "none"; }
+			
+			if(cancel){ cancel.style.display = "none"; }
+			
+			if(syncMessages){
+				dojo.removeClass(syncMessages, "dot-sync-error");
+			}
+		}
+	},
+	
+	_setSyncMessage: function(message){
+		var syncMessage = dojo.byId("dot-sync-messages");
+		if(syncMessage){
+			// when used with Google Gears pre-release in Firefox/Mac OS X,
+			// the browser would crash when testing in Moxie
+			// if we set the message this way for some reason.
+			// Brad Neuberg, bkn3@columbia.edu
+			//syncMessage.innerHTML = message;
+			
+			while(syncMessage.firstChild){
+				syncMessage.removeChild(syncMessage.firstChild);
+			}
+			syncMessage.appendChild(document.createTextNode(message));
+		}
+	},
+	
+	_clearSyncMessage: function(){
+		this._setSyncMessage("");
+	},
+	
+	_initImages: function(){	
+		var onlineImg = dojo.byId("dot-widget-network-indicator-online");
+		if(onlineImg){
+			onlineImg.setAttribute("src", this.onlineImagePath);
+		}
+		
+		var offlineImg = dojo.byId("dot-widget-network-indicator-offline");
+		if(offlineImg){
+			offlineImg.setAttribute("src", this.offlineImagePath);
+		}
+		
+		var roller = dojo.byId("dot-roller");
+		if(roller){
+			roller.setAttribute("src", this.rollerImagePath);
+		}
+		
+		var checkmark = dojo.byId("dot-success-checkmark");
+		if(checkmark){
+			checkmark.setAttribute("src", this.checkmarkImagePath);
+		}
+	},
+	
+	_showDetails: function(evt){
+		// cancel the button's default behavior
+		evt.preventDefault();
+		evt.stopPropagation();
+		
+		if(!dojox.off.sync.details.length){
+			return;
+		}
+		
+		// determine our HTML message to display
+		var html = "";
+		html += "<html><head><title>Sync Details</title><head><body>";
+		html += "<h1>Sync Details</h1>\n";
+		html += "<ul>\n";
+		for(var i = 0; i < dojox.off.sync.details.length; i++){
+			html += "<li>";
+			html += dojox.off.sync.details[i];
+			html += "</li>";	
+		}
+		html += "</ul>\n";
+		html += "<a href='javascript:window.close()' "
+				 + "style='text-align: right; padding-right: 2em;'>"
+				 + "Close Window"
+				 + "</a>\n";
+		html += "</body></html>";
+		
+		// open a popup window with this message
+		var windowParams = "height=400,width=600,resizable=true,"
+							+ "scrollbars=true,toolbar=no,menubar=no,"
+							+ "location=no,directories=no,dependent=yes";
+
+		var popup = window.open("", "SyncDetails", windowParams);
+		
+		if(!popup){ // aggressive popup blocker
+			alert("Please allow popup windows for this domain; can't display sync details window");
+			return;
+		}
+		
+		popup.document.open();
+		popup.document.write(html);
+		popup.document.close();
+		
+		// put the focus on the popup window
+		if(popup.focus){
+			popup.focus();
+		}
+	},
+	
+	_cancel: function(evt){
+		// cancel the button's default behavior
+		evt.preventDefault();
+		evt.stopPropagation();
+		
+		dojox.off.sync.cancel();
+	},
+	
+	_needsBrowserRestart: function(){
+		var browserRestart = dojo.byId("dot-widget-browser-restart");
+		if(browserRestart){
+			dojo.addClass(browserRestart, "dot-needs-browser-restart");
+		}
+		
+		var appName = dojo.byId("dot-widget-browser-restart-app-name");
+		if(appName){
+			appName.innerHTML = "";
+			appName.appendChild(document.createTextNode(this.appName));
+		}
+		
+		var status = dojo.byId("dot-sync-status");
+		if(status){
+			status.style.display = "none";
+		}
+	},
+	
+	_showNeedsOfflineCache: function(){
+		var widgetContainer = dojo.byId("dot-widget-container");
+		if(widgetContainer){
+			dojo.addClass(widgetContainer, "dot-needs-offline-cache");
+		}
+	},
+	
+	_hideNeedsOfflineCache: function(){
+		var widgetContainer = dojo.byId("dot-widget-container");
+		if(widgetContainer){
+			dojo.removeClass(widgetContainer, "dot-needs-offline-cache");
+		}
+	},
+	
+	_initMainEvtHandlers: function(){
+		var detailsButton = dojo.byId("dot-sync-details-button");
+		if(detailsButton){
+			dojo.connect(detailsButton, "onclick", this, this._showDetails);
+		}
+		var cancelButton = dojo.byId("dot-sync-cancel-button");
+		if(cancelButton){
+			dojo.connect(cancelButton, "onclick", this, this._cancel);
+		}
+	},
+	
+	_setOfflineEnabled: function(enabled){
+		var elems = [];
+		elems.push(dojo.byId("dot-sync-status"));
+		
+		for(var i = 0; i < elems.length; i++){
+			if(elems[i]){
+				elems[i].style.visibility = 
+							(enabled ? "visible" : "hidden");
+			}
+		}
+	},
+	
+	_syncFinished: function(){
+		this._updateSyncUI();
+		
+		var checkmark = dojo.byId("dot-success-checkmark");
+		var details = dojo.byId("dot-sync-details");
+		
+		if(dojox.off.sync.successful == true){
+			this._setSyncMessage("Sync Successful");
+			if(checkmark){ checkmark.style.display = "inline"; }
+		}else if(dojox.off.sync.cancelled == true){
+			this._setSyncMessage("Sync Cancelled");
+			
+			if(checkmark){ checkmark.style.display = "none"; }
+		}else{
+			this._setSyncMessage("Sync Error");
+			
+			var messages = dojo.byId("dot-sync-messages");
+			if(messages){
+				dojo.addClass(messages, "dot-sync-error");
+			}
+			
+			if(checkmark){ checkmark.style.display = "none"; }
+		}
+		
+		if(dojox.off.sync.details.length && details){
+			details.style.display = "inline";
+		}
+	},
+	
+	_onFrameworkEvent: function(type, saveData){
+		if(type == "save"){
+			if(saveData.status == dojox.storage.FAILED && !saveData.isCoreSave){
+				alert("Please increase the amount of local storage available "
+						+ "to this application");
+				if(dojox.storage.hasSettingsUI()){
+					dojox.storage.showSettingsUI();
+				}		
+			
+				// FIXME: Be able to know if storage size has changed
+				// due to user configuration
+			}
+		}else if(type == "coreOperationFailed"){
+			console.log("Application does not have permission to use Dojo Offline");
+		
+			if(!this._userInformed){
+				alert("This application will not work if Google Gears is not allowed to run");
+				this._userInformed = true;
+			}
+		}else if(type == "offlineCacheInstalled"){
+			// clear out the 'needs offline cache' info
+			this._hideNeedsOfflineCache();
+		
+			// check to see if we need a browser restart
+			// to be able to use this web app offline
+			if(dojox.off.hasOfflineCache == true
+				&& dojox.off.browserRestart == true){
+				this._needsBrowserRestart();
+				return;
+			}else{
+				var browserRestart = dojo.byId("dot-widget-browser-restart");
+				if(browserRestart){
+					browserRestart.style.display = "none";
+				}
+			}
+		
+			// update our sync UI
+			this._updateSyncUI();
+		
+			// register our event listeners for our main buttons
+			this._initMainEvtHandlers();
+		
+			// if offline is disabled, disable everything
+			this._setOfflineEnabled(dojox.off.enabled);
+		
+			// try to go online
+			this._testNet();
+		}
+	},
+	
+	_onSync: function(type){
+		//console.debug("ui, onSync="+type);
+		switch(type){
+			case "start": 
+				this._updateSyncUI();
+				break;
+				
+			case "refreshFiles":
+				this._setSyncMessage("Downloading UI...");
+				break;
+				
+			case "upload":
+				this._setSyncMessage("Uploading new data...");
+				break;
+				
+			case "download":
+				this._setSyncMessage("Downloading new data...");
+				break;
+				
+			case "finished":
+				this._syncFinished();
+				break;
+				
+			case "cancel":
+				this._setSyncMessage("Canceling Sync...");
+				break;
+				
+			default:
+				dojo.warn("Programming error: "
+							+ "Unknown sync type in dojox.off.ui: " + type);
+				break;
+		}
+	},
+	
+	_onNetwork: function(type){
+		// summary:
+		//	Called when we go on- or off-line
+		// description:
+		//	When we go online or offline, this method is called to update
+		//	our UI. Default behavior is to update the Offline
+		//	Widget UI and to attempt a synchronization.
+		// type: String
+		//	"online" if we just moved online, and "offline" if we just
+		//	moved offline.
+		
+		if(!this._initialized){ return; }
+		
+		// update UI
+		this._updateNetIndicator();
+		
+		if(type == "offline"){
+			this._setSyncMessage("You are working offline");
+		
+			// clear old details
+			var details = dojo.byId("dot-sync-details");
+			if(details){ details.style.display = "none"; }
+			
+			// if we fell offline during a sync, hide
+			// the sync info
+			this._updateSyncUI();
+		}else{ // online
+			// synchronize, but pause for a few seconds
+			// so that the user can orient themselves
+			if(dojox.off.sync.autoSync){
+				if(dojo.isAIR){
+					window.setTimeout(function(){dojox.off.sync.synchronize();}, 1000);
+				}else{
+					window.setTimeout(dojox._scopeName + ".off.sync.synchronize()", 1000);
+				}
+			}
+		}
+	}
+});
+
+// register ourselves for low-level framework events
+dojo.connect(dojox.off, "onFrameworkEvent", dojox.off.ui, "_onFrameworkEvent");
+
+// start our magic when the Dojo Offline framework is ready to go
+dojo.connect(dojox.off, "onLoad", dojox.off.ui, dojox.off.ui._initialize);
+
+}
+
+if(!dojo._hasResource["dojox.off.offline"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.off.offline"] = true;
+dojo.provide("dojox.off.offline");
+
+
+
+
+
+
+
+}
+