dojo._xdResourceLoaded({
depends: [["provide", "dojox.off.files"]],
defineResource: function(dojo){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>

		//		dojo.require("dojox.sql");

		//		dojo.require("dojox.off");

		//		dojo.require("dojox.off.ui");

		//		dojo.require("dojox.off.sync");

		//

		//		// 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(djConfig.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="+djConfig.isDebug);

					if(djConfig.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, "_");

			

		// 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", djConfig.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);

				}

		});

	}

}



}


}});