// browser detect object
var is = {
	opera: !!window.opera,
	ie: /*@cc_on!@*/false,
	khtml: navigator.userAgent.indexOf('KHTML') > -1,
	gecko: navigator.userAgent.indexOf('KHTML') == -1 && navigator.userAgent.indexOf('Gecko') > -1,
	mac: navigator.userAgent.indexOf('Macintosh') > -1
}

// debug - cancelable alert
if (window.debug)
{
	window.alert = function(alert)
	{
		if (!confirm(alert))
			throw 'stopped';
	}
}

// Preload stuff
var preloadImages = {};
function preload(label, url)
{
	if (!(label in preloadImages))
	{
		preloadImages[label] = new Image();
		preloadImages[label].src = ImgURL + url;
	}
}

function getPreloadImage(label)
{
	if (label in preloadImages)
	{
		return preloadImages[label].src;
	}
	else if (label != 'empty')
	{
		preload('empty', 'g/px.gif');
		return getPreloadImage('empty');
	}
	else
	{
		return ImgURL + 'g/px/gif';
	}
}

function imgHoverOn()
{
	if (this.__hoverStateImg)
		this.src = getPreloadImage(this.__hoverStateImg);
}

function imgHoverOff()
{
	if (this.__normalStateImg)
		this.src = getPreloadImage(this.__normalStateImg);
}

function imageHoverSwap(img, normalStateImg, hoverStateImg)
{
	img.src = getPreloadImage(normalStateImg);

	if (!img.__hoverStateImg)
	{
		addEvent(img, 'mouseover', imgHoverOn);
		addEvent(img, 'mouseout', imgHoverOff);
	}

	img.__hoverStateImg = hoverStateImg;
	img.__normalStateImg = normalStateImg;
}

Object.extend = function(dest, source, allowOverwrite)
{
	for (var prop in source)
	{
		if (source.hasOwnProperty(prop) && (allowOverwrite || !dest.hasOwnProperty(prop)))
			dest[prop] = source[prop];
	}

	return dest;
}

Object.extend(Array.prototype,
{
	indexOf: function(searchElement, fromIndex)
	{
		var l = this.length, i = 0;
		if (fromIndex)
		{
			i = fromIndex;
			if (i < 0)
			{
				i += l;
				if (i < 0) i = 0;
			}
		}

		while (i < l)
		{
			if (this[i] === searchElement) return i;
			i++;
		}

		return -1;
	},
	forEach: function(func, obj)
	{
		if (typeof func != 'function')
			throw new TypeError();

		for (var i = 0, len = this.length; i < len; i++)
		{
			if (i in this)
				func.call(obj, this[i], i, this);
		}
	}
});

Object.extend(String.prototype,
{
	trim: function()
	{
		return this.replace(/^\s+|\s+$/, '');
	},
	ucFirst: function()
	{
		return this.charAt(0).toUpperCase() + this.substr(1);
	},
	escapeHtml: function()
	{
		var escapeChars = {
			'&': '&amp;',
			'<': '&lt;',
			'>': '&gt;',
			'"': '&quot;'
		};

		return this.replace(/[&<>"]/g, function(c) { return escapeChars[c]; });
	},
	unescapeHtml: function()
	{
		var unescapeChars = {
			'&amp;': '&',
			'&lt;': '<',
			'&gt;': '>',
			'&quot;': '"',
			'&#039;': '\'',
			'&euro;': String.fromCharCode(8364)
		};

		return this.replace(/&(amp|lt|gt|quot|#039|euro);/g, function(c) { return unescapeChars[c]; });
	}
});

Object.extend(Function.prototype,
{
	bind: function()
	{
		var handler = this, args = [].slice.call(arguments, 0), object = args.shift();

		return function()
		{
			return handler.apply(object, args.concat([].slice.call(arguments, 0)));
		}
	}
});

RegExp.escape = function(string)
{
	return string.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
}

// Generics
if (!('forEach' in Array))
{
	Array.forEach = function(array)
	{
		[].forEach.apply(array, [].slice.call(arguments, 1));
	}
}

// handy
function Set()
{
	var set = {}, i = arguments.length;
	while (i--)
		set[arguments[i]] = 1;

	return set;
}

// execute methods on DOMload
var DomLoaded =
{
	onload: [],
	loaded: function()
	{
		if (DomLoaded.done) return;
		DomLoaded.done = true;

		if (DomLoaded.timer)
			clearInterval(DomLoaded.timer);

		if (DomLoaded.onload.length)
			DomLoaded.execute();
	},
	load: function(fireThis)
	{
		DomLoaded.onload.push(fireThis);

		if (DomLoaded.onload.length == 1)
		{
			if (document.addEventListener)
				document.addEventListener('DOMContentLoaded', DomLoaded.loaded, false);
			else
			{
				DomLoaded.timer = setInterval(function()
				{
					if (document.getElementById('domLoaded'))
						DomLoaded.loaded();
				}, 10);
			}

			// generic fallback
			addEvent(window, 'load', DomLoaded.loaded);
		}
	},
	execute: function()
	{
		var func = DomLoaded.onload.shift();

		if (typeof func == 'function')
			func();

		if (DomLoaded.onload.length)
			setTimeout(DomLoaded.execute, 10);
	}
}

// generic eventhandling
var addEvent = function()
{
	if (document.addEventListener)
	{
		return function(element, type, handler)
		{
			element.addEventListener(type, handler, false);
		}
	}
	else
	{
		function handleEvent(event)
		{
			event = event || fixEvent(window.event);

			var handlers = this.events[event.type], returnValue;
			for (var i in handlers)
			{
				if (handlers.hasOwnProperty(i) && handlers[i].call(this, event) === false)
					returnValue = false;
			}

			return returnValue;
		}
		function fixEvent(event)
		{
			event.preventDefault = preventDefault;
			event.stopPropagation = stopPropagation;

			return event;
		}
		function preventDefault() { this.returnValue = false; }
		function stopPropagation() { this.cancelBubble = true; }
		function removeAllEvents()
		{
			while ((cachedEvent = eventCache.pop()))
				removeEvent(cachedEvent.element, cachedEvent.type, cachedEvent.handler);
		}

		var guid = 1;
		var eventCache = [];

		return function(element, type, handler)
		{
			if (!handler.$$guid) handler.$$guid = guid++;
			if (!element.events) element.events = {};
			if (!element.events[type])
			{
				element.events[type] = {};
				if (element['on' + type]) element.events[type][0] = element['on' + type];
				element['on' + type] = handleEvent;
			}

			element.events[type][handler.$$guid] = handler;

			if (type != 'unload')
			{
				if (!eventCache.length)
					addEvent(window, 'unload', removeAllEvents);

				eventCache.push(
					{
						element: element,
						type: type,
						handler: handler
					}
				);
			}
		}
	}
}();

var removeEvent = function()
{
	if (document.removeEventListener)
	{
		return function(element, type, handler)
		{
			element.removeEventListener(type, handler, false);
		}
	}
	else
	{
		return function(element, type, handler)
		{
			if (element.events && element.events[type] && handler.$$guid)
				delete element.events[type][handler.$$guid];
		}
	}
}();

function getHead()
{
	/*@cc_on
		var bases = document.getElementsByTagName('base');
		if (bases.length && bases[0].childNodes.length)
			return bases[0];
	@*/

	return document.getElementsByTagName('head')[0];
}

function getQueryString(form)
{
	var elements = form.elements, element;
	var qName, qValues, qParts = [];
	var i, j, k, o;
	for (i = 0; i < elements.length; i++)
	{
		element = elements[i];

		if (element.name && !element.disabled)
		{
			qValues = [];

			switch (element.tagName.toLowerCase())
			{
				case 'input':
					k = element.type.toLowerCase();
					if ((k == 'checkbox' || k == 'radio') && !element.checked)
						break;
				case 'textarea':
					qValues.push(element.value);
					break;
				case 'select':
					k = element.options, o = [];
					if (element.multiple)
					{
						for (j = 0; j < k.length; j++)
							if (k[j].selected) o.push(k[j]);
					}
					else
						o.push(k[element.selectedIndex]);

					for (j = 0; j < o.length; j++)
					{
						k = o[j].value;
						if (!k && !('value' in k))
							k = o.text;
						qValues.push(k);
					}

					break;
			}

			if ((k = qValues.length))
			{
				qName = encodeURIComponent(element.name);
				for (j = 0; j < k; j++)
					qParts.push(qName + '=' + encodeURIComponent(qValues[j]));
			}
		}
	}

	return qParts.join('&');
}

function HTMLBuilder(newInstance)
{
	if (this == window)
		return new HTMLBuilder();

	if (HTMLBuilder.instance && !newInstance)
		return HTMLBuilder.instance;

	this.idList = {};
	this.eventHandlers = Set(
		'onblur', 'onchange', 'onclick', 'ondblclick', 'onfocus', 'onkeydown',
		'onkeypress', 'onkeyup', 'onload', 'onmousedown', 'onmousemove', 'onmouseout',
		'onkouseover', 'onmouseup', 'onreset', 'onselect', 'onsubmit', 'onunload'
	);

	if (!newInstance)
		HTMLBuilder.instance = this;

	return this;
}
Object.extend(HTMLBuilder.prototype,
{
	built: function(object)
	{
		this.idList = {};

		return this.builtRecursive(object);
	},
	builtRecursive: function(object)
	{
		var element = null, attribute, i;

		if (object.o)
		{
			element = object.o;
		}
		else if (object.n)
		{
			if (object.n == '#text')
			{
				element = document.createTextNode(object.v || '');
			}
			else
			{
				if (object.a && 'name' in object.a)
				{
					try
					{
						element = document.createElement('<' + object.n + ' name=' + object.a['name'] + '>');
						delete object.a['name'];
					}
					catch(e) {}
				}

				if (element || (element = document.createElement(object.n)))
				{
					if (object.a)
					{
						for (attribute in object.a)
						{
							if (object.a[attribute] !== null && object.a.hasOwnProperty(attribute))
							{
								if (	attribute in this.eventHandlers &&
									typeof object.a[attribute] != 'function'
								)
								{
									element[attribute] = new Function(object.a[attribute]);
								}
								else
								{
									if (attribute == 'id')
										this.idList[object.a[attribute]] = element;

									if (attribute == 'style')
										element.style.cssText = object.a['style'];
									else
										element[attribute] = object.a[attribute];
								}
							}
						}
					}

					if (object.c && object.c.length)
					{
						if (	object.n == 'table' &&
							!(object.c[0].n in Set('tbody', 'theader', 'tfooter'))
						)
						{
							element.appendChild(
								this.built(
									{
										n: 'tbody',
										c: object.c
									}
								)
							);
						}
						else
						{
							var childNode;
							for (i = 0; i < object.c.length; i++)
							{
								if (object.c[i] && (childNode = this.builtRecursive(object.c[i])))
									element.appendChild(childNode)
							}
						}
					}
				}
			}
		}

		return element;
	},
	getIdList: function()
	{
		return Object.extend({}, this.idList);
	},
	getElementById: function(id)
	{
		return this.idList[id] || null;
	}
});

function getURLParms(href)
{
	var parms = {};
	var i = href.indexOf('?');
	if (i > -1)
	{
		var get = href.substr(i+1);
		var p1 = get.split('&'), p2;
		i = p1.length;
		while (i--)
		{
			p2 = p1[i].split('=');
			parms[p2[0]] = p2[1];
		}
	}

	return parms;
}

function appendURLParms(url, parms)
{
	var queryString = createQueryString(parms);

	if (queryString)
		queryString = (url.indexOf('?') == -1 ? '?' : '&') + queryString;

	return queryString;
}

function appendDataParms(data, parms)
{
	var queryString = createQueryString(parms);

	if (queryString)
		queryString = (data == '' ? '' : '&') + queryString;

	return queryString;
}

function createQueryString(parms)
{
	var query = [];

	for (var parm in parms)
	{
		if (parms.hasOwnProperty(parm))
			query.push(encodeURIComponent(parm) + '=' + encodeURIComponent(parms[parm]));
	}

	return query.join('&');
}

function unserialize(data)
{
	var re = /(\w):([\d.]+)[:;]/g;
	re.lastIndex = 0;
	return unserialize_do(re, data);
}

function unserialize_do(re, data)
{
	var cur, ret = '', i, key;
	if ((cur = re.exec(data)) !== null)
	{
		switch (cur[1])
		{
			case 'a':
			case 'o':
				ret = cur[1] == 'a' ? [] : {};
				i = cur[2];
				while (i--)
				{
					key = unserialize_do(re, data);
					ret[key] = unserialize_do(re, data);
				}
				break;
			case 's':
				ret = data.substr(re.lastIndex+1, cur[2]);
				re.lastIndex += cur[2] - 1;
				break;
			case 'i':
			case 'd':
				ret = cur[2] / 1;
				break;
			case 'b':
				ret = cur[2] ? true : false;
				break;
		}
	}

	return ret;
}

function getElementsByClassName(className, nodeName, parentElement, callback)
{
	if (!nodeName)
		nodeName = '*';

	if (!parentElement)
		parentElement = document;

	var results = [], multiple = className.indexOf('|') > -1, s, i = 0, element;

	if (parentElement.getElementsByClassName && nodeName == '*' && !multiple)
	{
		results = parentElement.getElementsByClassName(className);

		if (callback)
			Array.forEach(results, callback);
	}
	else if (document.evaluate && !multiple)
	{
		s = document.evaluate(
			".//" + nodeName + "[contains(concat(' ', @class, ' '), ' " + className + " ')]",
			parentElement,
			null,
			XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
			null
		);

		while ((element = s.snapshotItem(i++)))
		{
			results.push(element);
			if (callback)
				callback(element);
		}
	}
	else
	{
		s = parentElement.getElementsByTagName(nodeName);
		var re = getClassRegExp(className), elementClassName;

		while ((element = s[i++]))
		{
			elementClassName = element.className;
			if (	elementClassName.length &&
				(	elementClassName == className ||
					re.test(elementClassName)
				)
			)
			{
				results.push(element);
				if (callback)
					callback(element);
			}
		}
	}

	return results;
}

function is_ignorable(nod)
{
	return (nod.nodeType == 8 || (nod.nodeType == 3 && !/[^\t\n\r ]/.test(nod.data)));
}

function first_child(par, nodeName)
{
	if (par && par.nodeType == 1)
	{
		var res = par.firstChild;
		if (nodeName)
		{
			nodeName = nodeName.toLowerCase();
			do
			{
				if (res.nodeName.toLowerCase() == nodeName)
					return res;
			}
			while ((res = res.nextSibling));
		}
		else
		{
			do
			{
				if (!is_ignorable(res))
					return res;
			}
			while ((res = res.nextSibling));
		}
	}

	return null;
}

function last_child(par, nodeName)
{
	if (par && par.nodeType == 1)
	{
		var res = par.lastChild;
		if (nodeName)
		{
			nodeName = nodeName.toLowerCase();
			do
			{
				if (res.nodeName.toLowerCase() == nodeName)
					return res;
			}
			while ((res = res.previousSibling));
		}
		else
		{
			do
			{
				if (!is_ignorable(res))
					return res;
			}
			while ((res = res.previousSibling));
		}
	}

	return null;
}

function node_after(sib, nodeName)
{
	if (sib)
	{
		if (nodeName)
		{
			nodeName = nodeName.toLowerCase();
			while ((sib = sib.nextSibling))
			{
				if (sib.nodeName.toLowerCase() == nodeName)
					return sib;
			}
		}
		else
		{
			while ((sib = sib.nextSibling))
			{
				if (!is_ignorable(sib))
					return sib;
			}
		}
	}

	return null;
}

function ellipsis(root)
{
	if (ellipsis.__native == undefined)
	{
		ellipsis.__native = true;
		if (document.defaultView && document.defaultView.getComputedStyle)
		{
			var foo = document.createElement('div');
			foo.style.cssText = 'text-overflow:ellipsis;-o-text-overflow:ellipsis';
			if (!foo.style.cssText)
				ellipsis.__native = false;
		}
	}

	if (!ellipsis.__native)
	{
		if (!root)
			getElementsByClassName('ellipsis', null, null, ellipsis_do);
		else
			ellipsis_do(root);
	}
}

function ellipsis_table(tableId)
{
	if (is.ie || is.khtml)
	{
		var productTable = document.getElementById(tableId);
		if (productTable)
		{
			var tableBody = productTable.getElementsByTagName('tbody')[0];
			var row = tableBody && tableBody.rows[0];
			if (row)
			{
				var cell, i = 0, j = 0;
				while (row && (cell = row.cells[i]))
				{
					if (cell.colSpan && cell.colSpan > 1)
					{
						row = tableBody.rows[++j];
						continue;
					}

					if (!hasClass(cell, 'ellipsis'))
						productTable.rows[0].cells[i].width = cell.clientWidth - (is.ie ? 8 : 0);

					i++;
				}

				productTable.style.tableLayout = 'fixed';
			}
		}
	}
}

function ellipsis_do(root)
{
	var ellipsis_word = false;

	// speed things up
	if (root.clientWidth)
	{
		if (root.nodeName != 'TD')
		{
			root.style.width = root.clientWidth + 'px';
			root.style.position = 'fixed';
		}

		var s = [root], e, o, w;

		while ((e = s.pop()))
		{
			do
			{
				switch (e.nodeType)
				{
					case 1:
						if (e.style.display != 'none')
						{
							if (document.defaultView.getComputedStyle(e, null).getPropertyValue('overflow') == 'hidden')
							{
								ellipsis_overflow(e, ellipsis_word);
							}
							else
							{
								if ((o = e.nextSibling)) s.push(o);
								e = e.firstChild;
								break;
							}
						}

					default:
						e = e.nextSibling;
				}
			}
			while (e);
		}

		root.style.position = '';
	}
}

function ellipsis_overflow(p, ellipsis_word)
{
	var w = p.clientWidth;
	if (w && p.scrollWidth > w)
	{
		var s = [p], e, o, q, l;

		while ((e = s.pop()))
		{
			do
			{
				switch (e.nodeType)
				{
					case 1:
						if ((o = e.previousSibling)) s.push(o);
						e = e.lastChild;
						break;

					case 3:
						if (/[^\t\n\r ]/.test(e.data))
						{
							// Take an educated guess on what the length of the text should be
							q = e.nodeValue;
							l = Math.floor((q.length * w) / p.scrollWidth) - 1;
							if (l > 0)
							{
								do
								{
									e.nodeValue = q.substr(0, --l) + '...';
								}
								while (l && (p.scrollWidth > w || (ellipsis_word && e.nodeValue.charAt(l-1) != ' ')));

								if (l > 0) return;
							}

							e.nodeValue = '';
						}

					default:
						e = e.previousSibling;
				}
			}
			while(e);
		}
	}
}

function addClass(element, className)
{
	if (element.className.length)
	{
		var classes = getClassList(element);
		if (classes.indexOf(className) == -1)
		{
			classes.push(className);
			setClassList(element, classes);
		}
	}
	else
		element.className = className;
}

function removeClass(element, className)
{
	var classes = getClassList(element), index;
	if ((index = classes.indexOf(className)) > -1)
	{
		delete classes[index];
		setClassList(element, classes);
	}
}

function replaceClass(element, oldclass, newclass)
{
	var classes = getClassList(element), index;
	if ((index = classes.indexOf(oldclass)) > -1 && classes.indexOf(newclass) == -1)
	{
		classes[index] = newclass;
		setClassList(element, classes);
	}
}

function hasClass(element, className)
{
	var elementClassName = element.className;
	return	elementClassName.length &&
		(	elementClassName == className ||
			getClassRegExp(className).test(elementClassName)
		);
}

function getClassList(element)
{
	return element.className.length ? element.className.split(/\s+/) : [];
}

function setClassList(element, classes)
{
	element.className = classes.join(' ');
}

var regExpCache = {};
function getClassRegExp(className)
{
	if (!(className in regExpCache))
		regExpCache[className] = new RegExp('(^|\\s)' + className + '(\\s|$)');

	return regExpCache[className];
}

function getOffsetTop(el, offsetParent)
{
	var offsetTop = 0;
	if (!offsetParent) offsetParent = null;
	do
	{
		offsetTop += el.offsetTop
	}
	while ((el = el.offsetParent) != offsetParent);

	return offsetTop;
}

function getOffsetLeft(el, offsetParent)
{
	var offsetLeft = 0;
	if (!offsetParent) offsetParent = null;
	do
	{
		offsetLeft += el.offsetLeft
	}
	while ((el = el.offsetParent) != offsetParent);

	return offsetLeft;
}

function setRelativePosition(element, offsetElement, offsetTop, offsetLeft, minTop, minLeft)
{
	var offsetParent = null;
	try { offsetParent = element.offsetParent; } catch(e) {}

	var top = getOffsetTop(offsetElement, offsetParent) + offsetTop;
	if (minTop !== undefined && top + (offsetParent && getOffsetTop(offsetParent)) < minTop) top = minTop;

	var left = getOffsetLeft(offsetElement, offsetParent) + offsetLeft;
	if (minLeft !== undefined && left + (offsetParent && getOffsetLeft(offsetParent)) < minLeft) left = minLeft;

	element.style.top = top + 'px';
	element.style.left = left + 'px';
}

function external_links(rootid)
{
	var root = document;
	if (rootid && !(root = document.getElementById(rootid))) return false;

	var c = root.getElementsByTagName('a'), a, i = 0, attr;
	var re = /(^|\s)external(\s|$)/;
	while ((a = c[i++]))
	{
		attr = a.getAttribute('rel');
		if (attr && (attr == 'external' || re.test(attr)))
			a.target = '_blank';
	}

	return true;
}

function FolderTree(id)
{
	var list = document.getElementById(id);
	if (list)
	{
		preload('foldertree_open', 'g/if/icons/folder_tree_min.gif');
		preload('foldertree_closed', 'g/if/icons/folder_tree_plus.gif');

		var subLists = list.getElementsByTagName('ul'), i = 0, ul, img, li;
		while ((ul = subLists[i++]))
		{
			if ((img = first_child(ul.parentNode, 'img')))
			{
				img.src = getPreloadImage('foldertree_closed');
				img.style.cursor = 'pointer';
				addEvent(img, 'click', FolderTreeToggle);
			}

			ul.style.display = 'none';
		}

		subLists = getElementsByClassName('highlight', 'li', list), i = 0;
		while ((li = subLists[i++]))
		{
			do
			{
				if ((img = first_child(li, 'img')))
					FolderTreeToggle.call(img);

				li = li.parentNode.parentNode;
			}
			while (li && li.nodeName.toLowerCase() == 'li');
		}
	}
}

function FolderTreeToggle()
{
	var subList = first_child(this.parentNode, 'ul');
	if (subList)
	{
		if (subList.style.display == 'none')
		{
			subList.style.display = 'block';
			this.src = getPreloadImage('foldertree_open');
			if (!this.ellipsed)
			{
				ellipsis(subList);
				this.ellipsed = true;
			}
		}
		else
		{
			subList.style.display = 'none';
			this.src = getPreloadImage('foldertree_closed');
		}
	}
}

// Generic Cookie functies
function getCookie(name)
{
	var cookie = document.cookie.split('; '), i = cookie.length, crumb;
	while (i--)
	{
 		crumb = cookie[i].split('=');
		if (crumb[0] == name)
			return crumb[1] != undefined ? unescape(crumb[1]) : null;
	}

	return null;
}

function setCookie(sName, sValue)
{
	document.cookie = sName + '=' + escape(sValue) + '; expires=Fri, 31 Dec 2099 23:59:59 GMT; path=/; domain=.' + document.domain;
}

function getSessionId()
{
	var sidName = window.sidName || 'TnetId';
	return getCookie(sidName);
}

function timeDiff(starttime)
{
	return ((new Date().getTime()-starttime)/1000).toString().replace('.',',');
}

function hideMed(img, time)
{
	setCookie('lastmed', time);
	img.parentNode.style.display = 'none';
}

var categories = [];
var hideSections = {}, skipcookie = true;
function initSectionDisplay()
{
	if (skipcookie)
	{
		preload('sectionHideIcon', 'g/bullets/min.gif');
		preload('sectionShowIcon', 'g/bullets/plus.gif');

		var c = getCookie('klipklapcookie');
		if (c !== null)
		{
			var temp = c.split(','), i = temp.length;
			while (i--)
				hideSections[temp[i]] = 1;
		}
	}

	var l = categories.length;
	while (l--)
	{
		if (hideSections[categories[l]])
		{
			temp = document.getElementById(categories[l]);
			if (temp && typeof temp.onclick == 'function')
			{
				addClass(temp, 'pointer');
				temp.title = 'in/uitklappen';
				temp.onclick();
			}
		}
	}

	skipcookie = false;
	categories = [];
}

function toggleSectionDisplay(img)
{
	var display, cat = document.getElementById(img.id + 'List');
	if (cat)
	{
		if (img.src == getPreloadImage('sectionShowIcon'))
		{
			img.src = getPreloadImage('sectionHideIcon');
			cat.style.display = '';
			ellipsis(cat);
			delete hideSections[img.id];
		}
		else
		{
			img.src = getPreloadImage('sectionShowIcon');
			cat.style.display = 'none';
			hideSections[img.id] = 1;
		}

		if (!skipcookie)
		{
			var temp = [];
			for (var category in hideSections)
				if (hideSections.hasOwnProperty(category))
					temp.push(category);

			setCookie('klipklapcookie', temp.join(','));
		}
	}
}

// Deprecated function
function winopen(url, width, height)
{
	if (!width) width=460;
	if (!height) height=550;
	if (url.charAt(0) == '/') url = url.substr(1);
	if (url.indexOf('http://') != 0) url = BaseURL + url;
	window.open(url, '_blank', 'toolbar=no,location=no,menubar=no,scrollbars=yes,width='+width+',height='+height+',resizable=yes,status=no');
}

function cancelEvent(e)
{
	if (e.preventDefault)
	{
		e.preventDefault();
	}
	else if (e.cancelBubble != undefined)
	{
		if (e.keyCode) e.keyCode = 0;
		e.returnValue = 0;
		e.cancelBubble = true;
	}

	return false;
}

// sitestat
function sitestat(ns_l)
{
	ns_l+='&amp;ns__t='+(new Date()).getTime();
	var ns_pixelUrl=ns_l;
	var ns_0=document.referrer;
	ns_0=(ns_0.lastIndexOf('/')==ns_0.length-1)?ns_0.substring(ns_0.lastIndexOf('/'),0):ns_0;
	if(ns_0.length>0)ns_l+='&amp;ns_referrer='+escape(ns_0);
	if(document.images)
	{
		var ns_1=new Image();
		ns_1.src=ns_l;
	}
	else
		document.write('<img src="'+ns_l+'" width="1" height="1" alt="">');
}