function initSite()
	{
	if (window.init_site_already_called) { return; }
	window.init_site_already_called = true;
	adjustLayout();
	//insertLogo();
	adjustSectionHead();
	initSearch();
	//adjustSearch();
	insertFirstAndLastChildren();
	adjustContentTables();
	//adjustMainStory();
	adjustLinks();
    //createSectionDropdown()
	//adjustContentFeatured();
	adjustBrowseSections();
	collapsibleNavigation();
	initForms();
	ieImageOversizeFix();
	}
	
function doClearfield (field, defaultvalue){
        if (field.value == defaultvalue) {
            field.value = "";
        }
}


function doPopulatefield (field, defaultvalue){
        if (field.value == "") {
            field.value = defaultvalue;
        }
}
	
function ieImageOversizeFix()
	{
	if (isIEWin())
		{
		window.removeHeightFromMainStoryImg = function ()
			{
			var msimg = getElement('#main_story .featured_image img');
			if (!msimg) { return; }
			msimg.height = '';
			}
		setTimeout('removeHeightFromMainStoryImg()', 200);
		}
	}
function adjustLayout()
	{
	var body = document.getElementsByTagName('body')[0];
	var page = document.getElementById('page');
	if (!page)
		{
		if (body.bgColor) { body.bgColor = ''; }
		body.innerHTML = '<div id="page_outer"><div id="page">'+ body.innerHTML +'<'+'/div><'+'/div>';
		}
	if (document.addEventListener && (!document.addEventListener.toString))
		{
		// window.onload = addJavascriptClassToBody;
		addJavascriptClassToBody();
		}
	else { addJavascriptClassToBody(); }
	}
function addJavascriptClassToBody()
	{
	var body = document.getElementsByTagName('body')[0];
	body.className = 'js_enabled';
	}
function insertLogo()
	{
	var ident = document.getElementById('site_ident');
	ident.className = 'adjusted';
	var inner = ident.innerHTML.replace(/<h3>/i, "");
	inner = inner.replace(/<\/h3>/i, "");
	ident.innerHTML = '<a href="http://www.croydon.gov.uk"><img src="/images/webapp/logo.gif" alt="' + inner + '" /></a>';
	}
function adjustSectionHead()
	{
	var section_head = document.getElementById('section');
	if (!section_head)
		{
		var path = document.getElementById('path');
		var lis = path.getElementsByTagName('li');
		if (lis.length > 1)
			{
			var section_name = '';
			var section_li = lis[1].childNodes[0];
			try
				{
				section_name = section_li.childNodes[0].nodeValue;
				}
			catch(e)
				{
				try
					{
					section_name = section_li.nodeValue;
					}
				catch(e){}
				}
			if (section_name)
				{
				section_head = document.createElement('h2');
				section_head.innerHTML = section_name;
				section_head.id = 'section';
				path.appendChild(section_head);
				}
			}
		if (!section_name) { return; }
		}
	section_head.innerHTML = '<span id="sectionheadinner">' + section_head.innerHTML + '</span>';
	section_head.parentNode.removeChild(section_head);
	document.getElementById('page').appendChild(section_head);
	}
function initSearch()
	{
	var keyword = document.getElementById('search_keyword');
	var search_phrase = 'Search site...';
	if (!keyword.value) { keyword.value = search_phrase; }
	keyword.onfocus = function()
		{
		if (this.value == search_phrase) { this.value = ''; }
		}
	keyword.onblur = function()
		{
		if (this.value == '') { this.value = search_phrase; }
		}
	}
function adjustSearch()
	{
	var search_button = document.getElementById('search_button');
	if (!search_button) { return; }
	search_button.onmouseover = function() { edt.css.addClass(this, 'hover'); };
	search_button.onmouseout = function() { edt.css.removeClass(this, 'hover'); };
	}
function insertFirstAndLastChildren()
	{
	addFirstChild('site_links');
	addFirstChild('legal');
	addLastChild('pages');
	}
function adjustContentTables()
	{
	var content = document.getElementById('content');
	if (!content) { return; }
	var tables = content.getElementsByTagName('table');
	var content_width = null;
	var em = null;
	if (document.body.currentStyle && (navigator.platform.indexOf('Mac') == -1))
		{
		content.innerHTML += '<div id="emsizer" style="width: 10em">emsizer</div>';
		var emsizer = document.getElementById('emsizer');
		em = emsizer.offsetWidth/10;
		// NB. content_width is hard-coded
		// could possibly be recovered programatically
		content_width = 23 * em;
		emsizer.parentNode.removeChild(emsizer);
		}
	for (var i = 0; i < tables.length; i++)
		{
		if (em)
			{
			var spacer_element = null
			if (tables[i].offsetWidth > content_width)
				{
				tables[i].className = 'JS_RemoveFromFlow';
				/*if (!spacer_element)
					{
					spacer_element = document.createElement('div');
					spacer_element.className = 'JS_FlowSpace-table';
					}
				var insert_spacer = spacer_element.cloneNode(true);
				var after_table = null;
				var current_node = tables[i];
				while (current_node.nextSibling && !(after_table))
					{
					current_node = current_node.nextSibling;
					if (current_node.nodeType == 1)
						{
						after_table = current_node;
						}
					}
				if (after_table)
					{
					after_table.parentNode.insertBefore(insert_spacer, after_table);
					}
				else
					{
					content.appendChild(insert_spacer);
					}
				var flexi_height = tables[i].offsetHeight/em;
				insert_spacer.innerHTML = '<div style="width: 100px; height: ' + flexi_height + 'em;"></div>';*/
				}
			}
		var trs = tables[i].getElementsByTagName('tr');
		for (var j = 0; j < trs.length; j++)
			{
			var ths = trs[j].getElementsByTagName('th');
			if (ths.length && (ths.length<2))
				{
				if (j == 0) { return; }
				ths[0].className = 'first_child';
				}
			}
		}
	}
function adjustMainStory()
	{
	var main_story = document.getElementById('main_story');
	if (!main_story) { return; }
	var main_story_h2 = main_story.getElementsByTagName('h2')[0];
	insertLinedCorners(main_story_h2);
	}
function adjustLinks()
	{
	var links = document.getElementsByTagName('p');
	for (var i = 0; i < links.length; i++)
		{
		if (links[i].className != 'link') { continue; }
		var link = links[i].getElementsByTagName('a')[0];
		var linktext = link.innerHTML;
		if (linktext.match(/<img/i)) { continue; }
		var linksrc = linktext.toLowerCase();
		linksrc = linksrc.replace(/ <span>.*/i, '');
		linksrc = linksrc.replace(/ /g, "_");
		var parentClass = links[i].parentNode.className;
		var linkcolor = parentClass;
		var extension = parentClass.match(/^mainblock_/) ? 'png' : 'gif';
		if (isIEWin('<6')) { extension = 'gif'; }
		if (linkcolor.match('^block_') == null) { linkcolor = ''; }
		linkcolor = linkcolor.replace(/^block_/, "");
		if (linkcolor) { linkcolor = '-'+linkcolor; }
		
		linksrc = '/images/link/' + linksrc + linkcolor + '.' + extension;
		var filter = '';
		if (extension == 'png' && isIEWin(6))
			{
			filter = ' style="width: 100px; height:19px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'' + linksrc + '\', sizingMethod=\'scale\')"';
			linksrc = Config.image.spacer.src;
			}
		linktext = linktext.replace(/<[^>]+>/g, '');
		var alt_attr = link.title ? link.title : linktext;
		link.innerHTML = '<img src="' + linksrc + '"' + filter + ' onmouseover="imgHover(this, 1)" onmouseout="imgHover(this)" alt="' + alt_attr + '" />';
		}
	}
function createSectionDropdown()
	{
	
	var sections = document.getElementById('sections');
	if (!sections) { return; }
	sections.parentNode.removeChild(sections);
	
		var assoc = document.getElementById('associated');
	if (!assoc) { return; }
	
	
        var actions = document.getElementById('actions');
        var hompageactions = document.getElementById('homepage_actions');
        var homeatoz = document.getElementById('homeatoz');
        var associated_links = document.getElementById('associated_links');
        
        if(hompageactions != null){
		
            assoc.insertBefore(sections,homeatoz);
            assoc.insertBefore(hompageactions, sections);
		
        }else {
            if (associated_links != null){
                assoc.appendChild(associated_links);
                assoc.insertBefore(sections, associated_links);
            }else{
                assoc.appendChild(sections);
            }
            if(actions != null){
                assoc.insertBefore(actions, sections);
            }    
            		
        }
		
	
	}
function adjustContentFeatured()
	{
	var feats = document.getElementById('content_featured');
	if (!feats) { return; }
	var lis = feats.getElementsByTagName('li');
	for (var i = 0; i < lis.length; i++)
		{
		insertCorners(lis[i]);
		var links = lis[i].getElementsByTagName('a');
		}
	}
var browse_columns = 3;
function adjustBrowseSections()
	{
	var section_browse = getElement('#browse_sections');
	if (!section_browse) { return; }
	var section_lis = getElements('#browse_sections > ul > li');
	var total_lis = section_lis.length;
	var lis_per_col = Math.floor(total_lis / browse_columns + 0.5);
	var parent_ul = section_lis[0].parentNode;
	var new_uls = [];
	for (var i = lis_per_col; i < total_lis; i++)
		{
		if (i%lis_per_col == 0) { new_uls[new_uls.length] = document.createElement('ul'); }
		var removeli = section_lis[i].parentNode.removeChild(section_lis[i]);
		new_uls[new_uls.length-1].appendChild(removeli);
		}
	for (var i = 0; i < new_uls.length; i++)
		{
		section_browse.appendChild(new_uls[i]);
		}
	}
function initForms()
	{
	//adjustYourLondonLogo();
	//adjustEbaseLogo();
	//adjustEbaseCalendar();
	}
function adjustYourLondonLogo()
	{

	if (!document.location.href.match(/yourlondon.gov.uk\//)) { return; }
	var logo = getElement('#site_ident img');
	
	if (!logo) { return; }
	logo.src = logo.src.replace(/.*\/images/, "http://croydon.edt.ltd.uk/images");
	}
function adjustEbaseLogo()
	{
	if (!document.location.href.match(/\/ufs\//)) { return; }
	var logo = getElement('#site_ident img');
	if (!logo) { return; }
	logo.src = logo.src.replace(/.*\/images/, "/ufs/shared/croydonres/images");
	}
function adjustEbaseCalendar()
	{
	try
		{
		var old_popUpCalendar = this.popUpCalendar;
		popUpCalendar = function (ctl,	ctl2, ivin)
			{
			crossobj = getElement('#calendar').style;
			old_popUpCalendar(ctl, ctl2, ivin);
			}
		var old_position = this.position;
		position = function (obj, left, top)
			{
			if (obj == crossobj)
				{
				var displace = getElement('#page').offsetLeft + getElement('#page_outer').offsetLeft;
				left = left - displace;
				}
			old_position(obj, left, top);
			}
		var old_popUpMonth = this.popUpMonth;
		popUpMonth = function ()
			{
			old_popUpMonth();
			}
		}
	catch(e) {}
	}
function imgHover(img, state)
	{
	if (state)
		{
		if (img.src.indexOf(Config.image.spacer.src) != -1)
			{
			img.style.filter = img.style.filter.replace(/\.png/, "-hover.png");
			}
		else
			{
			img.src = img.src.replace(/.([^.]+)$/, "-hover.$1");
			}
		}
	else
		{
		if (img.src.indexOf(Config.image.spacer.src) != -1)
			{
			img.style.filter = img.style.filter.replace(/-hover\.png/, ".png");
			}
		else
			{
			img.src = img.src.replace(/-hover.([^.]+)$/, ".$1");
			}
		}
	}
function addFirstChild(element, tag)
	{
	
	if (typeof(element) == 'string') { element = document.getElementById(element); }
	if (!element) { return; }
	if (!tag) { tag = 'li'; }
	var tags = element.getElementsByTagName(tag);
	if (tags[0])
		{	
		if (tags[0].className) { tags[0].className += ' '; }
		tags[0].className += 'first_child';
		}
	}
function addLastChild(element, tag)
	{

	if (typeof(element) == 'string') { element = document.getElementById(element); }
	if (!element) { return; }
	if (!tag) { tag = 'li'; }
	var tags = element.getElementsByTagName(tag);
	if (tags[0])
		{
		var i = tags.length - 1;
		if (tags[i].className) { tags[i].className += ' '; }
		tags[i].className = 'last_child';
		}
	}
function insertLinedCorners(element)
	{
	insertPositionedElements(element, ['lined_tl', 'lined_tr', 'lined_bl', 'lined_br']);
	}
function insertCorners(element)
	{
	insertPositionedElements(element, ['rounded_tl', 'rounded_tr', 'rounded_bl', 'rounded_br']);
	}
function insertRightCorners(element)
	{
	insertPositionedElements(element, ['rounded_tr', 'rounded_br']);
	}
function insertBottomRightCorner(element)
	{
	insertPositionedElements(element, ['rounded_br']);
	}
function insertPositionedElements(element, list)
	{
	element = (typeof element == 'string') ? document.getElementById(element) : element;
	if (!element) { return; }
	var insertion = '';
	for (var i in list)
		{
		insertion += '<div class="' + list[i] + '"></div>';
		
		}
		
	element.innerHTML = insertion + element.innerHTML;
	
	}
var Config = new Object();
/*---------------------------------------------------
   IMAGES
----------------------------------------------------*/
Config.image = new Object();
Config.image_src = '/images/webapp/';
Config.image.disclosure = {};
Config.image.disclosure.open = new Image();
Config.image.disclosure.open.src = Config.image_src + 'disclosure.open.gif';
Config.image.disclosure.closed = new Image();
Config.image.disclosure.closed.src = Config.image_src + 'disclosure.closed.gif';
Config.image.disclosure.spacer = new Image();
Config.image.disclosure.spacer.src = Config.image_src + 'disclosure.spacer.gif';
Config.image.spacer = new Image();
Config.image.spacer.src = Config.image_src + 'blank.gif';
/*---------------------------------------------------
   TEXT
----------------------------------------------------*/
Config.text = new Object;
Config.text.subcategories = 'sub-categories';
Config.text.disclosure = {};
Config.text.disclosure.title = {};
Config.text.disclosure.title.closed = 'Show ' + Config.text.subcategories;
Config.text.disclosure.title.open = 'Hide ' + Config.text.subcategories;
/*---------------------------------------------------
   COLLAPSIBLE
----------------------------------------------------*/
Config.collapsible = new Object();
Config.collapsible.elements = ['#browse_sections'];
Config.collapsible.store = true;
/*
	cssQuery, version 2.0.2 (2005-08-19)
	Copyright: 2004-2005, Dean Edwards (http://dean.edwards.name/)
	License: http://creativecommons.org/licenses/LGPL/2.1/
*/
// the following functions allow querying of the DOM using CSS selectors
var cssQuery = function() {
var version = "2.0.2";
// -----------------------------------------------------------------------
// main query function
// -----------------------------------------------------------------------
var $COMMA = /\s*,\s*/;
var cssQuery = function($selector, $$from) {
try {
	var $match = [];
	var $useCache = arguments.callee.caching && !$$from;
	var $base = ($$from) ? ($$from.constructor == Array) ? $$from : [$$from] : [document];
	// process comma separated selectors
	var $$selectors = parseSelector($selector).split($COMMA), i;
	for (i = 0; i < $$selectors.length; i++) {
		// convert the selector to a stream
		$selector = _toStream($$selectors[i]);
		// faster chop if it starts with id (MSIE only)
		if (isMSIE && $selector.slice(0, 3).join("") == " *#") {
			$selector = $selector.slice(2);
			$$from = _msie_selectById([], $base, $selector[1]);
		} else $$from = $base;
		// process the stream
		var j = 0, $token, $filter, $arguments, $cacheSelector = "";
		while (j < $selector.length) {
			$token = $selector[j++];
			$filter = $selector[j++];
			$cacheSelector += $token + $filter;
			// some pseudo-classes allow arguments to be passed
			//  e.g. nth-child(even)
			$arguments = "";
			if ($selector[j] == "(") {
				while ($selector[j++] != ")" && j < $selector.length) {
					$arguments += $selector[j];
				}
				$arguments = $arguments.slice(0, -1);
				$cacheSelector += "(" + $arguments + ")";
			}
			// process a token/filter pair use cached results if possible
			$$from = ($useCache && cache[$cacheSelector]) ?
				cache[$cacheSelector] : select($$from, $token, $filter, $arguments);
			if ($useCache) cache[$cacheSelector] = $$from;
		}
		$match = $match.concat($$from);
	}
	delete cssQuery.error;
	return $match;
} catch ($error) {
	cssQuery.error = $error;
	return [];
}};
// -----------------------------------------------------------------------
// public interface
// -----------------------------------------------------------------------
cssQuery.toString = function() {
	return "function cssQuery() {\n  [version " + version + "]\n}";
};
// caching
var cache = {};
cssQuery.caching = false;
cssQuery.clearCache = function($selector) {
	if ($selector) {
		$selector = _toStream($selector).join("");
		delete cache[$selector];
	} else cache = {};
};
// allow extensions
var modules = {};
var loaded = false;
cssQuery.addModule = function($name, $script) {
//edt.log('loading '+$name, $script);
	if (loaded) eval("$script=" + String($script));
	modules[$name] = new $script();;
};
// hackery
cssQuery.valueOf = function($code) {
	return $code ? eval($code) : this;
};
// -----------------------------------------------------------------------
// declarations
// -----------------------------------------------------------------------
var selectors = {};
var pseudoClasses = {};
// a safari bug means that these have to be declared here
var AttributeSelector = {match: /\[([\w-]+(\|[\w-]+)?)\s*(\W?=)?\s*([^\]]*)\]/};
var attributeSelectors = [];
// -----------------------------------------------------------------------
// selectors
// -----------------------------------------------------------------------
// descendant selector
selectors[" "] = function($results, $from, $tagName, $namespace) {
	// loop through current selection
	var $element, i, j;
	for (i = 0; i < $from.length; i++) {
		// get descendants
		var $subset = getElementsByTagName($from[i], $tagName, $namespace);
		// loop through descendants and add to results selection
		for (j = 0; ($element = $subset[j]); j++) {
			if (thisElement($element) && compareNamespace($element, $namespace))
				$results.push($element);
		}
	}
};
// ID selector
selectors["#"] = function($results, $from, $id) {
	// loop through current selection and check ID
	var $element, j;
	for (j = 0; ($element = $from[j]); j++) if ($element.id == $id) $results.push($element);
};
// class selector
selectors["."] = function($results, $from, $className) {
	// create a RegExp version of the class
	$className = new RegExp("(^|\\s)" + $className + "(\\s|$)");
	// loop through current selection and check class
	var $element, i;
	for (i = 0; ($element = $from[i]); i++)
		if ($className.test($element.className)) $results.push($element);
};
// pseudo-class selector
selectors[":"] = function($results, $from, $pseudoClass, $arguments) {
	// retrieve the cssQuery pseudo-class function
	var $test = pseudoClasses[$pseudoClass], $element, i;
	// loop through current selection and apply pseudo-class filter
	if ($test) for (i = 0; ($element = $from[i]); i++)
		// if the cssQuery pseudo-class function returns "true" add the element
		if ($test($element, $arguments)) $results.push($element);
};
// -----------------------------------------------------------------------
// pseudo-classes
// -----------------------------------------------------------------------
pseudoClasses["link"] = function($element) {
	var $document = getDocument($element);
	if ($document.links) for (var i = 0; i < $document.links.length; i++) {
		if ($document.links[i] == $element) return true;
	}
};
pseudoClasses["visited"] = function($element) {
	// can't do this without jiggery-pokery
};
// -----------------------------------------------------------------------
// DOM traversal
// -----------------------------------------------------------------------
// IE5/6 includes comments (LOL) in it's elements collections.
// so we have to check for this. the test is tagName != "!". LOL (again).
var thisElement = function($element) {
	return ($element && $element.nodeType == 1 && $element.tagName != "!") ? $element : null;
};
// return the previous element to the supplied element
//  previousSibling is not good enough as it might return a text or comment node
var previousElementSibling = function($element) {
	while ($element && ($element = $element.previousSibling) && !thisElement($element)) continue;
	return $element;
};
// return the next element to the supplied element
var nextElementSibling = function($element) {
	while ($element && ($element = $element.nextSibling) && !thisElement($element)) continue;
	return $element;
};
// return the first child ELEMENT of an element
//  NOT the first child node (though they may be the same thing)
var firstElementChild = function($element) {
	return thisElement($element.firstChild) || nextElementSibling($element.firstChild);
};
var lastElementChild = function($element) {
	return thisElement($element.lastChild) || previousElementSibling($element.lastChild);
};
// return child elements of an element (not child nodes)
var childElements = function($element) {
	var $childElements = [];
	$element = firstElementChild($element);
	while ($element) {
		$childElements.push($element);
		$element = nextElementSibling($element);
	}
	return $childElements;
};
// -----------------------------------------------------------------------
// browser compatibility
// -----------------------------------------------------------------------
// all of the functions in this section can be overwritten. the default
//  configuration is for IE. The functions below reflect this. standard
//  methods are included in a separate module. It would probably be better
//  the other way round of course but this makes it easier to keep IE7 trim.
var isMSIE = true;
var isXML = function($element) {
	var $document = getDocument($element);
	return (typeof $document.mimeType == "unknown") ?
		/\.xml$/i.test($document.URL) :
		Boolean($document.mimeType == "XML Document");
};
// return the element's containing document
var getDocument = function($element) {
	return $element.ownerDocument || $element.document;
};
var getElementsByTagName = function($element, $tagName) {
	return ($tagName == "*" && $element.all) ? $element.all : $element.getElementsByTagName($tagName);
};
var compareTagName = function($element, $tagName, $namespace) {
	if ($tagName == "*") return thisElement($element);
	if (!compareNamespace($element, $namespace)) return false;
	if (!isXML($element)) $tagName = $tagName.toUpperCase();
	return $element.tagName == $tagName;
};
var compareNamespace = function($element, $namespace) {
	return !$namespace || ($namespace == "*") || ($element.scopeName == $namespace);
};
var getTextContent = function($element) {
	return $element.innerText;
};
function _msie_selectById($results, $from, id) {
	var $match, i, j;
	for (i = 0; i < $from.length; i++) {
		if ($match = $from[i].all.item(id)) {
			if ($match.id == id) $results.push($match);
			else if ($match.length != null) {
				for (j = 0; j < $match.length; j++) {
					if ($match[j].id == id) $results.push($match[j]);
				}
			}
		}
	}
	return $results;
};
// for IE5.0
if (![].push) Array.prototype.push = function() {
	for (var i = 0; i < arguments.length; i++) {
		this[this.length] = arguments[i];
	}
	return this.length;
};
// -----------------------------------------------------------------------
// query support
// -----------------------------------------------------------------------
// select a set of matching elements.
// "from" is an array of elements.
// "token" is a character representing the type of filter
//  e.g. ">" means child selector
// "filter" represents the tag name, id or class name that is being selected
// the function returns an array of matching elements
var $NAMESPACE = /\|/;
function select($$from, $token, $filter, $arguments) {
	if ($NAMESPACE.test($filter)) {
		$filter = $filter.split($NAMESPACE);
		$arguments = $filter[0];
		$filter = $filter[1];
	}
	var $results = [];
	if (selectors[$token]) {
		selectors[$token]($results, $$from, $filter, $arguments);
	}
	return $results;
};
// -----------------------------------------------------------------------
// parsing
// -----------------------------------------------------------------------
// convert css selectors to a stream of tokens and filters
//  it's not a real stream. it's just an array of strings.
var $STANDARD_SELECT = /^[^\s>+~]/;
var $$STREAM = /[\s#.:>+~()@]|[^\s#.:>+~()@]+/g;
function _toStream($selector) {
	if ($STANDARD_SELECT.test($selector)) $selector = " " + $selector;
	return $selector.match($$STREAM) || [];
};
var $WHITESPACE = /\s*([\s>+~(),]|^|$)\s*/g;
var $IMPLIED_ALL = /([\s>+~,]|[^(]\+|^)([#.:@])/g;
var parseSelector = function($selector) {
	return $selector
	// trim whitespace
	.replace($WHITESPACE, "$1")
	// e.g. ".class1" --> "*.class1"
	.replace($IMPLIED_ALL, "$1*$2");
};
var Quote = {
	toString: function() {return "'"},
	match: /^('[^']*')|("[^"]*")$/,
	test: function($string) {
		return this.match.test($string);
	},
	add: function($string) {
		return this.test($string) ? $string : this + $string + this;
	},
	remove: function($string) {
		return this.test($string) ? $string.slice(1, -1) : $string;
	}
};
var getText = function($text) {
	return Quote.remove($text);
};
var $ESCAPE = /([\/()[\]?{}|*+-])/g;
function regEscape($string) {
	return $string.replace($ESCAPE, "\\$1");
};
// -----------------------------------------------------------------------
// modules
// -----------------------------------------------------------------------
cssQuery.addModule("css-standard", function() { // override IE optimisation
// cssQuery was originally written as the CSS engine for IE7. It is
//  optimised (in terms of size not speed) for IE so this module is
//  provided separately to provide cross-browser support.
// -----------------------------------------------------------------------
// browser compatibility
// -----------------------------------------------------------------------
// sniff for Win32 Explorer
isMSIE = eval("false;/*@cc_on@if(@\x5fwin32)isMSIE=true@end@*/");
if (!isMSIE) {
	getElementsByTagName = function($element, $tagName, $namespace) {
		return $namespace ? $element.getElementsByTagNameNS("*", $tagName) :
			$element.getElementsByTagName($tagName);
	};
	compareNamespace = function($element, $namespace) {
		return !$namespace || ($namespace == "*") || ($element.prefix == $namespace);
	};
	isXML = document.contentType ? function($element) {
		return /xml/i.test(getDocument($element).contentType);
	} : function($element) {
		return getDocument($element).documentElement.tagName != "HTML";
	};
	getTextContent = function($element) {
		// mozilla || opera || other
		return $element.textContent || $element.innerText || _getTextContent($element);
	};
	function _getTextContent($element) {
		var $textContent = "", $node, i;
		for (i = 0; ($node = $element.childNodes[i]); i++) {
			switch ($node.nodeType) {
				case 11: // document fragment
				case 1: $textContent += _getTextContent($node); break;
				case 3: $textContent += $node.nodeValue; break;
			}
		}
		return $textContent;
	};
}
}); // addModule
cssQuery.addModule("css-level2", function() {
// -----------------------------------------------------------------------
// selectors
// -----------------------------------------------------------------------
// child selector
selectors[">"] = function($results, $from, $tagName, $namespace) {
	var $element, i, j;
	for (i = 0; i < $from.length; i++) {
		var $subset = childElements($from[i]);
		for (j = 0; ($element = $subset[j]); j++)
			if (compareTagName($element, $tagName, $namespace))
				$results.push($element);
	}
};
// sibling selector
selectors["+"] = function($results, $from, $tagName, $namespace) {
	for (var i = 0; i < $from.length; i++) {
		var $element = nextElementSibling($from[i]);
		if ($element && compareTagName($element, $tagName, $namespace))
			$results.push($element);
	}
};
// attribute selector
selectors["@"] = function($results, $from, $attributeSelectorID) {
	var $test = attributeSelectors[$attributeSelectorID].test;
	var $element, i;
	for (i = 0; ($element = $from[i]); i++)
		if ($test($element)) $results.push($element);
};
// -----------------------------------------------------------------------
// pseudo-classes
// -----------------------------------------------------------------------
pseudoClasses["first-child"] = function($element) {
	return !previousElementSibling($element);
};
pseudoClasses["lang"] = function($element, $code) {
	$code = new RegExp("^" + $code, "i");
	while ($element && !$element.getAttribute("lang")) $element = $element.parentNode;
	return $element && $code.test($element.getAttribute("lang"));
};
// -----------------------------------------------------------------------
//  attribute selectors
// -----------------------------------------------------------------------
// constants
AttributeSelector.NS_IE = /\\:/g;
AttributeSelector.PREFIX = "@";
// properties
AttributeSelector.tests = {};
// methods
AttributeSelector.replace = function($match, $attribute, $namespace, $compare, $value) {
	var $key = this.PREFIX + $match;
	if (!attributeSelectors[$key]) {
		$attribute = this.create($attribute, $compare || "", $value || "");
		// store the selector
		attributeSelectors[$key] = $attribute;
		attributeSelectors.push($attribute);
	}
	return attributeSelectors[$key].id;
};
AttributeSelector.parse = function($selector) {
	$selector = $selector.replace(this.NS_IE, "|");
	var $match;
	while ($match = $selector.match(this.match)) {
		var $replace = this.replace($match[0], $match[1], $match[2], $match[3], $match[4]);
		$selector = $selector.replace(this.match, $replace);
	}
	return $selector;
};
AttributeSelector.create = function($propertyName, $test, $value) {
	var $attributeSelector = {};
	$attributeSelector.id = this.PREFIX + attributeSelectors.length;
	$attributeSelector.name = $propertyName;
	$test = this.tests[$test];
	$test = $test ? $test(this.getAttribute($propertyName), getText($value)) : false;
	$attributeSelector.test = new Function("e", "return " + $test);
	return $attributeSelector;
};
AttributeSelector.getAttribute = function($name) {
	switch ($name.toLowerCase()) {
		case "id":
			return "e.id";
		case "class":
			return "e.className";
		case "for":
			return "e.htmlFor";
		case "href":
			if (isMSIE) {
				// IE always returns the full path not the fragment in the href attribute
				//  so we RegExp it out of outerHTML. Opera does the same thing but there
				//  is no way to get the original attribute.
				return "String((e.outerHTML.match(/href=\\x22?([^\\s\\x22]*)\\x22?/)||[])[1]||'')";
			}
	}
	return "e.getAttribute('" + $name.replace($NAMESPACE, ":") + "')";
};
// -----------------------------------------------------------------------
//  attribute selector tests
// -----------------------------------------------------------------------
AttributeSelector.tests[""] = function($attribute) {
	return $attribute;
};
AttributeSelector.tests["="] = function($attribute, $value) {
	return $attribute + "==" + Quote.add($value);
};
AttributeSelector.tests["~="] = function($attribute, $value) {
	return "/(^| )" + regEscape($value) + "( |$)/.test(" + $attribute + ")";
};
AttributeSelector.tests["|="] = function($attribute, $value) {
	return "/^" + regEscape($value) + "(-|$)/.test(" + $attribute + ")";
};
// -----------------------------------------------------------------------
//  parsing
// -----------------------------------------------------------------------
// override parseSelector to parse out attribute selectors
var _parseSelector = parseSelector;
parseSelector = function($selector) {
	return _parseSelector(AttributeSelector.parse($selector));
};
}); // addModule
/* Thanks to Bill Edney */
cssQuery.addModule("css-level3", function() {
// -----------------------------------------------------------------------
// selectors
// -----------------------------------------------------------------------
// indirect sibling selector
selectors["~"] = function($results, $from, $tagName, $namespace) {
	var $element, i;
	for (i = 0; ($element = $from[i]); i++) {
		while ($element = nextElementSibling($element)) {
			if (compareTagName($element, $tagName, $namespace))
				$results.push($element);
		}
	}
};
// -----------------------------------------------------------------------
// pseudo-classes
// -----------------------------------------------------------------------
// I'm hoping these pseudo-classes are pretty readable. Let me know if
//  any need explanation.
pseudoClasses["contains"] = function($element, $text) {
	$text = new RegExp(regEscape(getText($text)));
	return $text.test(getTextContent($element));
};
pseudoClasses["root"] = function($element) {
	return $element == getDocument($element).documentElement;
};
pseudoClasses["empty"] = function($element) {
	var $node, i;
	for (i = 0; ($node = $element.childNodes[i]); i++) {
		if (thisElement($node) || $node.nodeType == 3) return false;
	}
	return true;
};
pseudoClasses["last-child"] = function($element) {
	return !nextElementSibling($element);
};
pseudoClasses["only-child"] = function($element) {
	$element = $element.parentNode;
	return firstElementChild($element) == lastElementChild($element);
};
pseudoClasses["not"] = function($element, $selector) {
	var $negated = cssQuery($selector, getDocument($element));
	for (var i = 0; i < $negated.length; i++) {
		if ($negated[i] == $element) return false;
	}
	return true;
};
pseudoClasses["nth-child"] = function($element, $arguments) {
	return nthChild($element, $arguments, previousElementSibling);
};
pseudoClasses["nth-last-child"] = function($element, $arguments) {
	return nthChild($element, $arguments, nextElementSibling);
};
pseudoClasses["target"] = function($element) {
	return $element.id == location.hash.slice(1);
};
// UI element states
pseudoClasses["checked"] = function($element) {
	return $element.checked;
};
pseudoClasses["enabled"] = function($element) {
	return $element.disabled === false;
};
pseudoClasses["disabled"] = function($element) {
	return $element.disabled;
};
pseudoClasses["indeterminate"] = function($element) {
	return $element.indeterminate;
};
// -----------------------------------------------------------------------
//  attribute selector tests
// -----------------------------------------------------------------------
AttributeSelector.tests["^="] = function($attribute, $value) {
	return "/^" + regEscape($value) + "/.test(" + $attribute + ")";
};
AttributeSelector.tests["$="] = function($attribute, $value) {
	return "/" + regEscape($value) + "$/.test(" + $attribute + ")";
};
AttributeSelector.tests["*="] = function($attribute, $value) {
	return "/" + regEscape($value) + "/.test(" + $attribute + ")";
};
// -----------------------------------------------------------------------
//  nth child support (Bill Edney)
// -----------------------------------------------------------------------
function nthChild($element, $arguments, $traverse) {
	switch ($arguments) {
		case "n": return true;
		case "even": $arguments = "2n"; break;
		case "odd": $arguments = "2n+1";
	}
	var $$children = childElements($element.parentNode);
	function _checkIndex($index) {
		var $index = ($traverse == nextElementSibling) ? $$children.length - $index : $index - 1;
		return $$children[$index] == $element;
	};
	//	it was just a number (no "n")
	if (!isNaN($arguments)) return _checkIndex($arguments);
	$arguments = $arguments.split("n");
	var $multiplier = parseInt($arguments[0]);
	var $step = parseInt($arguments[1]);
	if ((isNaN($multiplier) || $multiplier == 1) && $step == 0) return true;
	if ($multiplier == 0 && !isNaN($step)) return _checkIndex($step);
	if (isNaN($step)) $step = 0;
	var $count = 1;
	while ($element = $traverse($element)) $count++;
	if (isNaN($multiplier) || $multiplier == 1)
		return ($traverse == nextElementSibling) ? ($count <= $step) : ($step >= $count);
	return ($count % $multiplier) == $step;
};
}); // addModule
// -------- >>      insert modules here for packaging       << -------- \
loaded = true;
// -----------------------------------------------------------------------
// return the query function
// -----------------------------------------------------------------------
return cssQuery;
}(); // cssQuery
/*---------------------------------------------------
   CSSQUERY ENDS
----------------------------------------------------*/
// -----------------------------------------------------------------------
// EDTify the interface
// -----------------------------------------------------------------------
if (!this.edt) { this.edt = {}; }
if (!edt.dom) { edt.dom = {}; }
edt.dom.getElementsBySelector = function(selector, args)
	{
	if (!args) { args = {}; }
	var context = args.context;
	var contents = args.contents;
	var filter = args.filter;
	var els = [];
	if (!selector.constructor || selector.constructor != Array)
		{
		selector = [selector];
		}
	for (var i = 0; i < selector.length; i++)
		{
		var new_els = selector[i].appendChild ? [selector[i]] : cssQuery(selector[i],context);
		if (new_els[0]) { els = els.concat(new_els); }
		if (!selector[i].appendChild && typeof(selector[i] == 'string'))
			{
			var processed = _processSelectorForContents(selector[i]);
			selector[i] = processed[0];
			contents = processed[1] || contents;
			}
		if (contents)
			{
			els = _filterContentsElements(els, contents);
			}
		}
	els = _filterElements(els, filter);
	return els;
	};
edt.dom.getElementBySelector = function(selector, args, last)
	{
	if (!args) { args = {}; }
	var context = args.context;
	var contents = args.contents;
	var filter = args.filter;
	var els = [];
	if (!selector.appendChild && typeof(selector == 'string'))
		{
		var processed = _processSelectorForContents(selector);
		selector = processed[0];
		contents = processed[1] || contents;
		els = edt.dom.getElementsBySelector(selector, {context:context});
		}
	else
		{
		els = [selector];
		} 
	var elem = els[(last ? els.length-1 : 0)];
	if (contents)
		{
		elem = _filterContentsElements([elem], contents);
		}
	return elem ? _filterElements(elem, filter) : null;
	};
edt.dom.getLastElementBySelector = function(selector, args, contents)
	{
	return edt.dom.getElementBySelector(selector, args, 'last')
	};
function _processSelectorForContents(selector)
	{
	var processed = [selector, ''];
	if (selector.match(/\*(.)$/))
		{
		processed[1] = selector.charAt(selector.length-1);
		processed[0] = selector.replace(/\s*\*.$/, '');
		}
	return processed;
	}
function _filterElements(els, filter)
	{
	//if (!filter) { return els; }
	var return_type = els.constructor == Array ? 'array' : '';
	if (!return_type) { els = [els]; }
	var filter_els = [];
	for (var i = 0; i < els.length; i++)
		{
		if (!filter || filter(els[i], i, els))
			{
			filter_els.push(els[i]);
			if (edt.config && edt.config['export'].dom_methods && this._dom_functions)
				{
				for (var func in _dom_functions)
					{
					var func_name = _dom_functions[func];
					if (filter_els[filter_els.length-1][func_name]) { continue; }
					if (!this._dom_function_store) { this._dom_function_store = {}; }
					if (!_dom_function_store[func_name])
						{
						_dom_function_store[func_name] = new Function('insertion', 'args', 'last', 'return edt.dom.'+func_name+'(this, insertion, args, last);');
						}
					filter_els[filter_els.length-1][func_name] = _dom_function_store[func_name];
					edt.log('added method', func_name);
					}
				}
			}
		}
	els = filter_els;
	return return_type == 'array' ? els : els[0];
	}
function _filterContentsElements(els, contents)
	{
	var contents_els = [];
	if (contents.match(/^all/i)) { contents = '*'; }
	else if (contents.match(/^text/i)) { contents = 't'; }
	else if (contents.match(/^element/i)) { contents = 'e'; }
	for (var j = 0; j < els.length; j++)
		{
		for (var k = 0; k < els[j].childNodes.length; k++)
			{
			var current_node = els[j].childNodes[k];
			if (contents == '*' || (contents == 't' && current_node.nodeType == 3) || (contents == 'e' && current_node.nodeType == 1))
				{
				contents_els.push(current_node);
				}
			}
		}
	return contents_els;
	}
if (edt.exportFunctions)
	{
	edt.exportFunctions(['getElementsBySelector', 'getElementBySelector', 'getLastElementBySelector'], 'dom_accessor_functions', edt.dom);
	}
if (!this.edt) { this.edt = {}; }
if (!edt.css) { edt.css = {}; }
edt.css.addClass = function(node, klass)
	{
	var classregex = new RegExp('\\b'+klass+'\\b');
	var nodes = getElements(node);
	for (var i = 0; i < nodes.length; i++)
		{
		var classnode = nodes[i];
		if (edt.css.hasClass(classnode, klass)) { return; }
		if (classnode.className)
			{
			klass = ' ' + klass;
			}
		classnode.className += klass;
		
		}
	}
edt.css.hasClass = function(node, klass)
	{
	var classregex = new RegExp('\\b'+klass+'\\b');
	if (classregex.test(node.className)) { return true; }
	return false;
	}
edt.css.removeClass = function(node, klass)
	{
	var classregex = new RegExp(klass);
	var nodes = getElements(node);
	for (var i = 0; i < nodes.length; i++)
		{
		var classvalue = nodes[i].className;
		if (classvalue)
			{
			classvalue = classvalue.replace(classregex, "")
			classvalue = classvalue.replace(/^\s*(.*)\s*$/, "$1")
			classvalue = classvalue.replace(/ /, " ");
			nodes[i].className = classvalue;
			}
		}
	}
edt.css.replaceClass = function(node, klass, oldklass)
	{
	var nodes = getElements(node);
	edt.css.addClass(newklass);
	edt.css.removeClass(oldklass);
	}
function isIEMac()
	{
	if ([document.frames].toString() != '[object Frames]') { return false; }
	return true;
	}
function isIEWin(version)
	{
	var ie_v = 0;
	if ([document.frames].toString() != '[object]') { return false; }
	if (!version) { return true; }
	if (document.body.contentEditable) { ie_v = 5.5; }
	if (document.documentElement.clientHeight) { ie_v = 6; }
	// NB. the next line will fail in quirks mode
	// possibly better to check for standards mode and if not parse agent string
	if (this.XMLHttpRequest) { ie_v = 7; }
	if (typeof version == 'number') { return (version == ie_v); }
	return eval (ie_v + version + ';');
	}
function isIE(args)
	{
	if (isIEWin(args)) { return true; }
	return isIEMac(args);
	}
function createCookie(name, value, days)
	{
	if (days)
		{
		var date = new Date();
		date.setTime(date.getTime()+(days*24*60*60*1000));
		var expires = "; expires="+date.toGMTString();
		}
	else
		{
		var expires = "";
		}
	document.cookie = name+"="+value+expires+"; path=/";
	}
function readCookie(name)
	{
	var ca = document.cookie.split(';');
	var nameEQ = name + "=";
	for(var i=0; i < ca.length; i++)
		{
		var c = ca[i];
		while (c.charAt(0)==' ') c = c.substring(1, c.length); //delete spaces
		if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
		}
	return null;
	}
function collapsibleNavigation()
	{
	if (Config.collapsible.store)
		{
		loadDisclosure();
		window.onunload = function() { storeDisclosure(); }
		}
	var collapsible_hierachies = Config.collapsible.elements;
	for (var j = 0; j < collapsible_hierachies.length; j++)
		{
		var hierarchy = collapsible_hierachies[j];
		var toggle_controls_required = false;
		var lis = getElements(hierarchy + ' li');
		for (var i = 0; i < lis.length; i++)
			{
			var sublis = getElements('li', lis[i]);
			if (sublis[0])
				{
				toggle_controls_required = true;
				edt.css.addClass(lis[i], 'parent');
				var closed = disclosure_states[lis[i].id] ? false : true;
				if (closed)
					{
					edt.css.addClass(lis[i], 'closed');
					}
				var disc_img_state = closed ? 'closed' : 'open';
				var disc_title = Config.text.disclosure.title[disc_img_state];
				insertAtTop(lis[i], '<img src="' + Config.image.disclosure[disc_img_state].src +'" class="disclosure" onclick="toggleDisclosure(this);" alt="control to show or hide sub-categories" title="' + disc_title + '" />');
				}
			else
				{
				edt.css.addClass(lis[i], 'child');
				insertAtTop(lis[i], '<img src="' + Config.image.disclosure.spacer.src + '" class="no_disclosure" alt="" />');
				}
			}
		if (toggle_controls_required == true)
			{
			collapser = getElement(hierarchy);
			insertAtTop(collapser, '<div class="toggle_controls"><span onclick="expandAll(\'' + hierarchy + '\');"><img src="' + Config.image.disclosure.closed.src +'" class="disclosure" title="Expand all ' + Config.text.subcategories + '" />Expand all</span> <span onclick="collapseAll(\'' + hierarchy + '\');"><img src="' + Config.image.disclosure.open.src +'" class="disclosure" title="Close all ' + Config.text.subcategories + '" />Collapse all</span></div>');
			}
		}
	}
var disclosure_states = {};
function toggleDisclosure(el, value)
	{
	var closed = edt.css.hasClass(el.parentNode, 'closed');
	
	var new_state = closed ? 'open' : 'closed';
	el.src = Config.image.disclosure[new_state].src;
	el.title = Config.text.disclosure.title[new_state];
	
	el = el.parentNode;
	var node_id = el.id;
	if (!closed && disclosure_states[node_id]) { delete disclosure_states[node_id]; }
	else if (closed) { disclosure_states[node_id] = 1; }
	storeDisclosure();
	
	if (value != null)
		{
		
		}
	if (closed)
		{
		edt.css.removeClass(el, 'closed');
		}
	else
		{
		edt.css.addClass(el, 'closed');
		}
	}
function storeDisclosure()
	{
	if (!Config.collapsible.store) { return; }
	var disc_string = '';
	for (var prop in disclosure_states)
		{
		if (disc_string) { disc_string += ','; }
		disc_string += prop;
		}
	createCookie('disclosure', disc_string, 28);
	}
function loadDisclosure()
	{
	var disc_string = readCookie('disclosure');
	if (!disc_string) { return; }
	var open_nodes = disc_string.split(',')
	for (var i = 0; i < open_nodes.length; i++)
		{
		disclosure_states[open_nodes[i]] = 1;
		}
	}
function expandAll(selector)
	{
	selector = selector ? selector += ' ' : '';
	var parents = getElements(selector + '.parent');
	for (var i = 0; i < parents.length; i++)
		{
		edt.css.removeClass(parents[i], 'closed');
		disclosure_states[parents[i].id] = 1;
		var disc_img = getElement('img.disclosure', {context: parents[i]});
		disc_img.src = Config.image.disclosure.open.src;
		}
	storeDisclosure();
	}
function collapseAll(selector)
	{
	selector = selector ? selector += ' ' : '';
	var parents = getElements(selector + '.parent');
	for (var i = 0; i < parents.length; i++)
		{
		edt.css.addClass(parents[i], 'closed');
		delete disclosure_states[parents[i].id];
		var disc_img = getElement('img.disclosure', {context: parents[i]});
		disc_img.src = Config.image.disclosure.closed.src;
		}
	storeDisclosure();
	}
function insertAtTop(node, add)
	{
	node.innerHTML = add + node.innerHTML;
	}
var getElements = edt.dom.getElementsBySelector;
var getElement = edt.dom.getElementBySelector;
window.addDOMReady = function(theFunc)
	{
	window.onloadCallback = function(caller)
		{
		if (window.onload_callback_already_called) { return; }
		window.onload_callback_already_called = true;
		theFunc();
		}
	if (document.addEventListener)
		{
		document.addEventListener("DOMContentLoaded", function() { window.onloadCallback(); }, false);
		if (document.addEventListener.toString) { return; }
		}
	var store_win_onload = window.onload;
	window.onload = function()
		{
		if (store_win_onload) { store_win_onload(); }
		window.onloadCallback();
		}
	}
window.addDOMReady(initSite);

function jumpSection(){
	document.jumpForm.action=document.jumpForm.dropdown.value;
	if(document.jumpForm.dropdown.value == 'please select...');
	else{
		document.jumpForm.submit();
	}
	
}