/*
To compress this file you can use Dojo ShrinkSafe compressor at
http://alex.dojotoolkit.org/shrinksafe/
*/

/*
   Behaviour v1.1 by Ben Nolan, June 2005. Based largely on the work
   of Simon Willison (see comments by Simon below).

   Description:
   	
   	Uses css selectors to apply javascript behaviours to enable
   	unobtrusive javascript in html documents.
   	
   Usage:   
   
	var myrules = {
		'b.someclass' : function(element){
			element.onclick = function(){
				alert(this.innerHTML);
			}
		},
		'#someid u' : function(element){
			element.onmouseover = function(){
				this.innerHTML = "BLAH!";
			}
		}
	};
	
	Behaviour.register(myrules);
	
	// Call Behaviour.apply() to re-apply the rules (if you
	// update the dom, etc).

   License:
   
   	This file is entirely BSD licensed.
   	
   More information:
   	
   	http://ripcord.co.nz/behaviour/
   
*/   

if (!Behaviour) {
	var Behaviour = {
		list : new Array,
		
		register : function(sheet){
			Behaviour.list.push(sheet);
		},
		
		start : function(){
			Behaviour.addLoadEvent(function(){
				Behaviour.apply();
			});
		},
		
		apply : function(){
			for (h=0;sheet=Behaviour.list[h];h++){
				for (selector in sheet){
					list = $$(selector);
					
					if (!list){
						continue;
					}
	
					for (i=0;element=list[i];i++){
						sheet[selector](element);
					}
				}
			}
		},
		
		addLoadEvent : function(func){
			var oldonload = window.onload;
			
			if (typeof window.onload != 'function') {
				window.onload = func;
			} else {
				window.onload = function() {
					oldonload();
					func();
				}
			}
		}
	}
	
	Behaviour.start();
}

/*
   The following code is Copyright (C) Simon Willison 2004.

   document.getElementsBySelector(selector)
   - returns an array of element objects from the current document
     matching the CSS selector. Selectors can contain element names, 
     class names and ids and can be nested. For example:
     
       elements = document.getElementsBySelect('div#main p a.external')
     
     Will return an array of all 'a' elements with 'external' in their 
     class attribute that are contained inside 'p' elements that are 
     contained inside the 'div' element which has id="main"

   New in version 0.4: Support for CSS2 and CSS3 attribute selectors:
   See http://www.w3.org/TR/css3-selectors/#attribute-selectors

   Version 0.4 - Simon Willison, March 25th 2003
   -- Works in Phoenix 0.5, Mozilla 1.3, Opera 7, Internet Explorer 6, Internet Explorer 5 on Windows
   -- Opera 7 fails 
*/

function getAllChildren(e) {
  // Returns all children of element. Workaround required for IE5/Windows. Ugh.
  return e.all ? e.all : e.getElementsByTagName('*');
}

// Speed up written by Dean Edwards, 2006
// http://dean.edwards.name/weblog/2006/03/faster
// Made code cross-platform by Arthur Clemens, 2007

// this object will manage CSS expressions used to query the DOM
var Selectors;
if (!Selectors) {
	if (document.createStyleSheet) Selectors = {
		styleSheet: document.createStyleSheet(),
		cache: {},
		length: 0,
		
		register: function(sheet) {
			// create the CSS expression and add it to the style sheet
			var cssText = [], index;
			for (var selector in sheet) {
				index = this.length++;
				// have to store by index too as the expression hack does not like
				//  spaces in strings for some strange reason
				this.cache[index] = this.cache[selector] = [];
				cssText.push(selector + "{behavior:expression(Selectors.store(" + index + ",this))}");
			}
			this.styleSheet.cssText = cssText.join("\n");
		},
		
		store: function(index, element) {
			// called from the CSS expression
			// store the matched DOM node
			this.cache[index].push(element);
			element.runtimeStyle.behavior = "none";
		},
		
		tidy: function() {
			// clean up after behaviors have been applied
			delete this.cache;
			this.styleSheet.cssText = "";
		}
	}
	if (Selectors) {
		// override getElementsBySelector
		document._getElementsBySelector = document.getElementsBySelector;
		document.getElementsBySelector = function(selector) {
			if (!Selectors.cache || /\[/.test(selector)) { // attribute selectors not supported by IE5/6
				return document._getElementsBySelector(selector);
			} else { // use the cache
				return Selectors.cache[selector];
			}
		};
		// override Behaviour's register function
		Behaviour._register = Behaviour.register;
		Behaviour.register = function(sheet) {
			Selectors.register(sheet);
			// call the old register function
			this._register(sheet);
		}
	}
}
// Do not wait for onload call
// by Dean Edwards/Matthias Miller/John Resig, 2006

var _behaviourOnloadTimer;
if (!Behaviour._apply) {
	Behaviour._apply = Behaviour.apply;
	Behaviour.apply = function() {
		this._apply();
	};
}
if (!Behaviour.init) {
	Behaviour.init = function() {
		// quit if this function has already been called
		if (arguments.callee.done) return;
		
		// flag this function so we don't do the same thing twice
		arguments.callee.done = true;
		
		// kill the timer
		if (_behaviourOnloadTimer) {
			clearInterval(_behaviourOnloadTimer);
			_behaviourOnloadTimer = null;
		}
		
		Behaviour.apply();
	};
}

/* for Mozilla */
if (document.addEventListener) {
	document.addEventListener("DOMContentLoaded", Behaviour.init, false);
}

/* for Internet Explorer */
/*@cc_on @*/
/*@if (@_win32)
	document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>");
	var script = document.getElementById("__ie_onload");
	script.onreadystatechange = function() {
		if (this.readyState == "complete") {
			Behaviour.init(); // call the onload handler
		}
	};
/*@end @*/

/* for Safari */

if (navigator.vendor && navigator.vendor.match(/Apple/)) { // sniff
	if (!_behaviourOnloadTimer) {
		_behaviourOnloadTimer = setInterval(function() {
			if (/loaded|complete/.test(document.readyState)) {
				Behaviour.init(); // call the onload handler
			}
		}, 10);
	}
}