/*
* jQuery Watch 1.2.0 -- http://plugins.jquery.com/project/watch
*
* Copyright (c) 2009 SolutionStream.com & Michael J. Ryan (http://tracker1.info/)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
* 
* ===============================================================================================
*
*	Provides an interface to objects matching the Mozilla JS (1.2) Object.prototype.watch 
*	method.  This uses a timer to determin changes, so rapidly changing items may miss 
*	some property changes.  This is a rough timer for some general use, not precision observer
*	patterns.
*
*	EXAMPLE:
*			function watchCallbackExample(propertyName, oldValue, newValue) {
*				alert("o." + propertyName + " changed from " + oldValue + " to " + newValue);
*			}
*			
*			//bind a watch event to a callback
*			jQuery(o).watch("someProperty", watchCallbackExample)
*				
*			//unbind a watch event from a callback
*			jQuery(o).unwatch("someProperty", watchCallbackExample);
*
*			//unbind all callbacks from a watched property
*			jQuery(o).unwatch("someProperty");
*
*			//unbind all callbacks for all watched properties
*			jQuery(o).unwatch();
*
* ===============================================================================================
*
*	1.0.0	Initial Release (watch only)
*	
*	1.2.0	Add unwatch methods
*			Remove internal use of Object.prototype.watch support unreliable in the latest FF3.5
*/
(function($) {
	//how often to rerun the genericWatchTimer below, increase this when debugging.
	var timerCycle = 100; //milliseconds (100 = 1/10 second)
	var watchedObjects = [];	//objects to be watched
	var watchedCallbacks = [];	//properties, prior values & callback methods
	var watchTimer = null;

	//jQuery extension method
	$.fn.watch = function(propertyName, callbackMethod) {
		for (var i = 0; i < this.length; i++) {
			var o = this[i];
			watchIt(o, propertyName, callbackMethod); //use timer based watch/check
		}
	}
	
	$.fn.unwatch = function(propertyName, callbackMethod) {
		for (var i = 0; i < this.length; i++) {
			var o = this[i];
			unwatchIt(o, propertyName, callbackMethod); //use timer based watch/check
		}
	}
	
	//add an object/property/callback item to the list.
	function watchIt(obj, propertyName, callbackMethod) {
	
		propertyName = String(propertyName); //force to string
		
		//object must exist, have a propertyName property and the callback must be a function
		if (!(obj && propertyName in obj && typeof callbackMethod == "function"))
			return; //nothing to do/add

		var item, props, prop, oldval, newval;
		for (var i=0; i<watchedObjects.length; i++) {
			if (obj != watchedCallbacks[i]) continue;
			
			item = watchedObjects[i];
			props = watchedCallbacks[i];
			
			for (var j=0; j<props.length; i++) {
				prop = props[j];
				if (prop.name != propertyName) continue;
				prop.callbacks.push(callbackMethod);
				return; //found prop match
			}
			
			//no prop match, insert one
			props.push({ "name":propertyName, oldValue:obj[propertyName], callbacks:[callbackMethod] })
			return;
		}

		//no object match found
		watchedObjects.push(obj);
		watchedCallbacks.push([{ "name":propertyName, oldValue:obj[propertyName], callbacks:[callbackMethod] }]);
	}
	
	//remove an object/property/callback item (nestable) from the list.
	//	null for propertyName and/or callbackMethod will be a wildcard match.
	function unwatchIt(obj, propertyName, callbackMethod) {
		var props, remprops, prop, pname;
		for (var i=0; i<watchedObjects.length; i++) {
			if (obj == watchedObjects[i]) {
				props = watchedCallbacks[i];
				remprops = [];
				for (var j=0; j<props.length; j++) {
					if (!propertyName || propertyName == props[j].name) {
						prop = props[j];
						for (var k=0; k < prop.callbacks.length; k++) {
							var cb = prop.callbacks[k];
							if (!callbackMethod || cb == callbackMethod) {
								prop.callbacks.splice(k,1);
								k--;
							}
						}
						if (!prop.callbacks.length)
							remprops.push(prop.name);
					}
				}
				
				//remove unneeded properties from the watch list
				remitems: 
				while (remprops.length) {
					pname = remprops.pop();
					for (var j=0; j<props.length; j++) {
						if (props[j].name == pname) {
							props.splice(j, 1);
							continue remitems;
						}
					}
				}
				
				//remove unneeded objects from the watch list
				if (props.length == 0) {
					watchedObjects.splice(i, 1);
					watchedCallbacks.splice(i, 1);
				}
				
				return; //done with match
			}
		}
	}
	
	
	//watch handler for browsers without a watch
	function wind() { //wind the watch
		watchTimer = window.setTimeout(genericWatchTimer, timerCycle);
	}
	function genericWatchTimer() {
		/**************************************************
			NOTE: IF YOU ARE DEBUGGING, YOU MAY WANT TO 
			INCREASE THE timerCycle VARIABLE ABOVE
		**************************************************/
		var item, props, prop, oldval, newval;
		for (var i=0; i<watchedObjects.length; i++) {
			item = watchedObjects[i];
			props = watchedCallbacks[i];
			for (var j=0; j<props.length; j++) {
				prop = props[j];
				newval = item[prop.name];
				if (prop.oldValue != newval || typeof(prop.oldValue) != typeof(newval)) {
					for (var k=0; k<prop.callbacks.length; k++) {
						prop.callbacks[k].call(item, prop.name, prop.oldValue, newval);
						prop.oldValue = newval;
					}
				}
			}
		}
		wind();
	}
	wind();
	
	
})(jQuery);