var fwDebug = false;

function myAlert(s) {
	if(fwDebug) {
		alert(s);
	}
};

var FunctionLibrary = function() {
};

//neco jako dedeni pro 2 objekty
FunctionLibrary.prototype.mix = function(parent, obj) {
	for(i in parent.prototype) {
		if(i in obj.prototype) continue;
		obj.prototype[i] = parent.prototype[i];
	}
};

//vyhledavani elementu podle ruznych kriterii
FunctionLibrary.prototype.getElementById = function(aID) {
	var elem = document.getElementById(aID);
	if(elem !== null) {
		return elem;
	} else {
		myAlert("Element of id: " + aID + " not found");
		return null;
	}
};
	
FunctionLibrary.prototype.deleteElementById = function(aID) {
	var remElem = this.getElementById(aID);
	this.deleteElement(remElem);
};

FunctionLibrary.prototype.deleteElement = function(remElem) {
	var parElem = remElem.parentNode;
	if(remElem !== null && parElem !== null) {
		parElem.removeChild(remElem);
	}
};
	
FunctionLibrary.prototype.removeElementById = function(aID) {
	this.deleteElementById(aID);
};

FunctionLibrary.prototype.removeElement = function(remElem) {
	this.deleteElement(remElem);
};

/**
 * vrati vsechny podprvky, ktere maji danou tridu (i do hloubky)
 * 
 * @param findClass
 * @param parentNode - nepovinny
 * @returns {Array}
 */
FunctionLibrary.prototype.getElementsByClassName = function(findClass, parentNode) {
	var elems = document.body.getElementsByTagName("*");
	var ret = new Array();
	var i, j, classes;
	for(i = 0; i < elems.length; i++) {
		classes = elems[i].className.split(" ");
		for(j = 0; j < classes.length; j++) {
			if(classes[j] == findClass) {
				if(parentNode) {
					//vlozit jen kdyz ma daneho rodice
					if(this.hasParent(elems[i], parentNode)) {
						ret.push(elems[i]);
					}
				} else {
					ret.push(elems[i]);
					break;
				}
			}
		}
	}
	return ret;
};

FunctionLibrary.prototype.getElementsByClassNamePreg = function(findClass, all) {
	if(all !== false) {
		all = true;
	}
	var elems = document.body.getElementsByTagName("*");
	var ret = new Array();
	var i, j, matches, classes;
	for(i = 0; i < elems.length; i++) {
		classes = elems[i].className.split(" ");
		for(j = 0; j < classes.length; j++) {
			matches = classes[j].match(findClass);
			if(matches != null) {
				if(matches[0] == classes[j]) {
					ret.push(elems[i]);
					if(!all) {
						return ret;
					}
					break;
				}
			}
		}
	}
	return ret;
};

FunctionLibrary.prototype.getElementsByTagName = function(elem, tagName) {
	return elem.getElementsByTagName(tagName);
};

FunctionLibrary.prototype.getChildrenByTagName = function(elem, tagName) {
	var i;
	var ret = [];
	for(i = 0; i < elem.childNodes.length; i++) {
		if(elem.childNodes[i].tagName && (elem.childNodes[i].tagName.toLowerCase() == tagName.toLowerCase())) {
			ret.push(elem.childNodes[i]);
		}
	}
	return ret;
};

/**
 * vrati prime potomky s danou tridou
 * 
 * @param elem
 * @param findClass
 * @returns {Array}
 */
FunctionLibrary.prototype.getChildrenByClassName = function(elem, findClass) {
	var i;
	var ret = [];
	for(i = 0; i < elem.childNodes.length; i++) {
		if(elem.childNodes[i].className && fLib.hasClassName(elem.childNodes[i], findClass)) {
			ret.push(elem.childNodes[i]);
		}
	}
	return ret;
};

/**
 * najit prvniho rodice elem s danym nazvem tagu
 * 
 * @param elem
 * @param findTag
 * @returns
 */
FunctionLibrary.prototype.getParentByTagName = function(elem, findTag) {
	var par = null;
	while(par = elem.parentNode) {
		if(par.tagName.toLowerCase() == findTag.toLowerCase()) {
			return par;
		}
		elem = par;
	}
	return false;
};

FunctionLibrary.prototype.hasParent = function(elem, parent) {
	var par = null;
	while(par = elem.parentNode) {
		if(par == parent) {
			return true;
		}
		elem = par;
	}
	return false;
};

//--------------------------------------------------------------------------
	
FunctionLibrary.prototype.appendElem = function(aElem, aElemName) {
	var child = document.createElement(aElemName);
	aElem.appendChild(child);
	return child;
};
	
FunctionLibrary.prototype.swapElemetnts = function(aNew, aOld) {
	var parElem = aOld.parentNode;
	if(parElem !== null) {
		parElem.replaceChild(aNew, aOld);
		return aNew;
	} else {
		myAlert("Element requested to be replaced has no parent!");
	}
};
	
FunctionLibrary.prototype.clone = function(cloneID, insertID) {
	var cloneNode = this.getElementById(cloneID);
	var insertNode = this.getElementById(insertID);
	
	var elems = cloneNode.cloneNode(true);
	var inputs = elems.getElementsByTagName("input");
	for(var i in inputs) {
		inputs[i].value = "";
	}
	
	if(cloneNode !== null && insertNode !== null) {
		insertNode.appendChild(elems);
	}
};
	
FunctionLibrary.prototype.removeChildren = function(elem) {
	while(elem.childNodes.length >= 1) {
		elem.removeChild(elem.firstChild);       
	}
};
	
FunctionLibrary.prototype.moveChildren = function(elemOld, elemNew) {
	while(elemOld.firstChild != null) {
		elemNew.appendChild(elemOld.firstChild);
	}
};

//--------------------------------------------------------------------------
	
//round to certain number of decimal numbers
FunctionLibrary.prototype.roundNumber = function(num, dec) {
	var result = Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec);
	return result;
};
	
//insert spaces afrer 3 nums
FunctionLibrary.prototype.formatNumber = function(nStr) {
	nStr += "";
	var rgx = /(\d+)(\d{3})/;
	while(rgx.test(nStr)) {
		nStr = nStr.replace(rgx, "$1" + " " + "$2");
	}
	return nStr;
};
	
FunctionLibrary.prototype.getNumValById = function(aID, aMin, aMax) {
	var elem;
	if((elem = this.getElementById(aID)) !== null) {
		return this.getNumVal(elem, aMin, aMax);
	}	
};
	
FunctionLibrary.prototype.getNumVal = function(elem, aMin, aMax) {
	var val = obj.value;
		
	if(this.isNumeric(val)) {
		if((elem.value >= aMin) && (elem.value <= aMax)) {
			return elem.value;
		} else {
			elem.value = aMin;
			return aMin;
		}
	} else {
		elem.value = aMin;
		return aMin;
	}	
};
	
FunctionLibrary.prototype.isNumeric = function(v) {
	return typeof v != "boolean" && v !== null && !isNaN(+ v);
};
	
FunctionLibrary.prototype.setValueById = function(aID, aVal) {
	var elem;
	if((elem = this.getElementById(aID)) !== null) {
		this.setValue(elem, aVal);
	}
};
	
FunctionLibrary.prototype.setValue = function(elem, aVal) {
	elem.value = aVal;
};
	
FunctionLibrary.prototype.setDisabledById = function(aID, aDisabled) {
	var elem;
	if((elem = this.getElementById(aID)) !== null) {
		this.setDisabled(elem, aDisabled);
	}
};
	
FunctionLibrary.prototype.setDisabled = function (elem, aDisabled) {
	if(aDisabled) {
		elem.disabled = "disabled";
	} else {
		elem.disabled = "";
	}
};

//prida do prvku select prvek option s value a title
FunctionLibrary.prototype.addOption = function(select, value, title) {
	var opt = document.createElement("option");
	opt.value = value;
	opt.innerHTML = title;
	select.appendChild(opt);
	return opt;
};
	
//prida do prvku select prvek option s value a title
FunctionLibrary.prototype.removeOptions = function(select, value, title) {
	var opt = document.createElement("option");
	opt.value = value;
	opt.innerHTML = title;
	select.appendChild(opt);
	return opt;
};
	
FunctionLibrary.prototype.removeOptions = function(select) {
	removeChildren(select);
};

FunctionLibrary.prototype.getRadioValue = function(radio) {
	var i;
	for(i = 0; i < radio.length; i++) {
		if(radio[i].checked) {
			return radio[i].value;
		}
	}
	return null;
};

FunctionLibrary.prototype.clearSelection = function() {
	if(document.selection && document.selection.empty) {
		document.selection.empty() ;
	} else if(window.getSelection) {
		var sel = window.getSelection();
		if(sel && sel.removeAllRanges) {
			sel.removeAllRanges() ;
		}
	}
};

//--------------------------------------------------------------------------
	
FunctionLibrary.prototype.getClient = function() {
	return window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");
};

FunctionLibrary.prototype.postData = function(client, url, data, callback) {
	client.open('POST', url, true);
	client.onreadystatechange = callback;

	client.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
	client.setRequestHeader("Content-length", data.length);
	client.send(data);
};

FunctionLibrary.prototype.getData = function(client, url, callback) {
	client.open('GET', url, true);
	client.onreadystatechange = callback;

	client.send(null);
};
	
FunctionLibrary.prototype.parseJSON = function(data) {
	try {
		return eval('(' + data + ')');
	} catch(err) {
		throw "Error parsing JSON data: " + data;
	}
};

//--------------------------------------------------------------------------
	
FunctionLibrary.prototype.setOpacity = function(elem, opac) {
	elem.style.opacity = opac / 100;
	elem.style.filter = "alpha(opacity=" + opac + ")";
};
	
FunctionLibrary.prototype.fadeElement = function(aElem, aOpacityStart, aOpacityEnd, aStep, aTimeStep, aCallback) {
	var current = aOpacityStart;
	
	var doStep = function(aStart, aEnd, aStep) {
		if(aStart == aEnd) {
			return false;
		}
		return (aStart > aEnd) ? aStart - aStep : aStart + aStep;
	};
	
	var opacityStep = function() {
		if((newOpacity = doStep(current, aOpacityEnd, aStep)) !== false) {
			fLib.setOpacity(aElem, newOpacity);
			//myAlert(newOpacity)
			current = newOpacity;
			setTimeout(opacityStep, aTimeStep);
		} else {
			//uz je konec prechodu
			if(aCallback !== undefined) {
				aCallback();
			}
		}
	};
	
	setTimeout(opacityStep, aTimeStep);
};
	
/**
 * nastavi vlastnost display a prepina ji mezi 2ma hodnotami
 * 
 * @param aID
 * @param aDefault
 * @param aNew
 * @returns
 */
FunctionLibrary.prototype.toggleDisplayById = function(aID, aDefault, aNew) {
	var elem;
	if((elem = this.getElementById(aID)) !== null) {
		return this.toggleDisplay(elem, aDefault, aNew);
	} else {
		return false;
	}
};
	
/**
 * prepne CSS vlastnost display
 * 
 * @param elem
 * @param aDefault
 * @param aNew
 * @returns
 */
FunctionLibrary.prototype.toggleDisplay = function(elem, aDefault, aNew) {
	if(elem.style.display == "") {
		elem.style.display = aDefault;
	}
	if(elem.style.display == aDefault) {
		elem.style.display = aNew;
		return aNew;
	} else {
		elem.style.display = aDefault;
		return aDefault;
	}
};
	
/**
 * nastavi CSS vlastnost display
 */
FunctionLibrary.prototype.setDisplayById = function(aID, aDisplay) {
	var elem;
	if((elem = this.getElementById(aID)) !== null) {
		this.setDisplay(elem, aDisplay);
	}
};
	
FunctionLibrary.prototype.setDisplay = function(elem, aDisplay) {
	elem.style.display = aDisplay;
};
	
FunctionLibrary.prototype.getStyle = function(elem, strCssRule) {
	var ret = "";
	if(document.defaultView && document.defaultView.getComputedStyle) {
		ret = document.defaultView.getComputedStyle(elem, null).getPropertyValue(strCssRule);
	} else if(elem.currentStyle) {
		strCssRule = strCssRule.replace(/\-(\w)/g, function (strMatch, p1) {
			return p1.toUpperCase();
		});
		ret = elem.currentStyle[strCssRule];
	}
	return ret;
};
	
FunctionLibrary.prototype.getStyleById = function(aID, strCssRule) {
	var elem;
	if((elem = this.getElementById(aID)) !== null) {
		this.getStyle(elem, strCssRule);
	}
};

/**
 * vrati z CSS zapisu NNNpx ciselnou cast
 * 
 */
FunctionLibrary.prototype.getSizeInPx = function(s) {
	var matches = s.match(/([0-9\.]+)px/i);
	if(matches != null) {
		return Math.round(matches[1]);
	} else {
		return 0;
	}
};

FunctionLibrary.prototype.getElemWidth = function(elem) {
	var val = this.getSizeInPx(this.getStyle(elem, "width"));
	if(val == 0) {
		var bwidthL = parseInt(this.getSizeInPx(this.getStyle(elem, "border-left-width")));
		var bwidthR = parseInt(this.getSizeInPx(this.getStyle(elem, "border-right-width")));
		var paddingL = parseInt(this.getSizeInPx(this.getStyle(elem, "padding-left")));
		var paddingR = parseInt(this.getSizeInPx(this.getStyle(elem, "padding-right")));
		val = elem.offsetWidth - bwidthL - bwidthR - paddingL - paddingR;
		if(val < 0) {
			val = 0;
		}
	}
	return parseInt(val);
};
	
FunctionLibrary.prototype.getElemHeight = function(elem) {
	var val = this.getSizeInPx(this.getStyle(elem, "height"));
	//alert("CSS: " + this.getStyle(elem, "height") + " CSS H: " + val + " Offset: " + elem.offsetHeight);
	if(val == 0) {
		var bwidthT = parseInt(this.getSizeInPx(this.getStyle(elem, "border-top-width")));
		var bwidthB = parseInt(this.getSizeInPx(this.getStyle(elem, "border-bottom-width")));
		var paddingT = parseInt(this.getSizeInPx(this.getStyle(elem, "padding-top")));
		var paddingB = parseInt(this.getSizeInPx(this.getStyle(elem, "padding-bottom")));
		val = elem.offsetHeight - bwidthT - bwidthB - paddingT - paddingB;
		if(val < 0) {
			val = 0;
		}
	}
	return parseInt(val);
};

FunctionLibrary.prototype.getElemPadding = function(elem, dir) {
	return parseInt(this.getSizeInPx(this.getStyle(elem, "padding-" + dir)));
};
	
FunctionLibrary.prototype.getMaxZIndex = function() {
	var all = document.getElementsByTagName('*'); 
	var maxZ = 0;
	for(var i = 0; i < all.length; i++) {
		var currZ = 0;
		var elem = all[i];
		currZ = parseInt(this.getStyle(elem, "z-index"));
		if(currZ > maxZ){
			maxZ = currZ;
		}
	}
	return maxZ;
};

//--------------------------------------------------------------------------
	
//height of document
FunctionLibrary.prototype.getDocumentHeight = function() {
	return document.documentElement.scrollHeight;
};

//width of document
FunctionLibrary.prototype.getDocumentWidth = function() {
	return document.documentElement.scrollWidth;
};
	
//return scroll position
FunctionLibrary.prototype.getTopScroll = function() {
	if(window.pageYOffset) {
		return window.pageYOffset;
	} else {
		return document.documentElement.scrollTop;
	}
};
	
//height of viewport
FunctionLibrary.prototype.getWindowHeight = function() {
	if(window.innerHeight) {
		return window.innerHeight;
	} else {
		return document.documentElement.clientHeight;
	}
};
	
FunctionLibrary.prototype.getWindowWidth = function() {
	if(window.innerWidth) {
		return window.innerWidth;
	} else {
		return document.documentElement.clientWidth;
	}
};
	
FunctionLibrary.prototype.findPos = function(obj) {
	var curleft = 0;
	var curtop = 0;
	if (obj.offsetParent) {
		do {
			curleft += obj.offsetLeft;
			curtop += obj.offsetTop;
		} while (obj = obj.offsetParent);
	}
	return [curleft,curtop];
};

FunctionLibrary.prototype.afterLoad = function(handler) {
	if(document.readyState == "complete") {
		handler();
	} else {
		this.addEvent("load", handler, window);
	}
};

//adds event to element
FunctionLibrary.prototype.addEvent = function(eventName, handler, object) {
	if(object) {
		if(object.addEventListener) {
			object.addEventListener(eventName, handler, false);
		} else {
			object.attachEvent("on" + eventName, handler);
		}
	} else {
		throw("Error adding event: [on" + eventName + "] = " + handler);
	}
};

FunctionLibrary.prototype.addElemEvent = function(eventName, handler, object) {
	this.addEvent(eventName, function(e) {
		var elem = fLib.getEventTarget(e);
		if(elem) {
			handler(elem);
		}
	}, object);
};
	
//removes event from element
FunctionLibrary.prototype.removeEvent = function(eventName, handler, object) {
	if(object.removeEventListener) {
		object.removeEventListener(eventName, handler, false);
	} else {
		object.detachEvent("on" + eventName, handler);
	}
};
	
//mouse position
FunctionLibrary.prototype.getMousePositionX = function(e) {
	return e.clientX + document.documentElement.scrollLeft + document.body.scrollLeft;
};
	
FunctionLibrary.prototype.getMousePositionY = function(e) {
	return e.clientY + document.documentElement.scrollTop + document.body.scrollTop;
};
	
FunctionLibrary.prototype.getEventTarget = function(e) {
	var event = e || window.event;

	if(event.target) {
		return event.target;
	} else if(event.srcElement) {
		return event.srcElement;
	}
};
	
FunctionLibrary.prototype.getEventCurrentTarget = function(e) {
	var event = e || window.event;

	if(event.currentTarget) {
		return event.currentTarget;
	} else if(event.srcElement) {
		return null;
	}
};

FunctionLibrary.prototype.stopPropagation = function(e) {
	var event = e || window.event;
	event.stopPropagation ? event.stopPropagation() : event.cancelBubble = true; 
};

/**
 * najde prvek pole
 * 
 * @param aArr
 * @param aElem
 * @returns {Number}
 */
FunctionLibrary.prototype.arIndexOf = function(aArr, aElem) {
	var i = 0;
	for(i = 0; i < aArr.length; i++) {
		if(aArr[i] == aElem) {
			return i;
		}
	}
	return -1;
};

FunctionLibrary.prototype.arSwap = function(arr, i1, i2) {
	var tmp = arr[i1];
	arr[i1] = arr[i2];
	arr[i2] = tmp;
	return arr;
};


/**
 * pro kazdy prvek pole pouzije callback compare a preda mu aktualni element a 
 * hodnotu search
 * 
 * @param arr
 * @param compare
 * @param search
 * @returns
 */
FunctionLibrary.prototype.getArrayValue = function(arr, compare, search) {
	var i;
	for(i = 0; i < arr.length; i++) {
		if(compare(arr[i], search)) {
			return arr[i]; 
		}
	}
	return false;
};
	
FunctionLibrary.prototype.strReplace = function(aSrc, aTar, s) {
	while(s.indexOf(aSrc) >= 0) {
		s = s.replace(aSrc, aTar);
	}
	return s;
};

FunctionLibrary.prototype.addClassName = function(elem, cl) {
	if(elem) {
		elem.className += " " + cl;
	} else {
		throw "Element is undefined.";
	}
};

FunctionLibrary.prototype.addClassNameById = function(aID, cl) {
	this.findElemAndApply(aID, this.addClassName, [cl]);
};

FunctionLibrary.prototype.removeClassName = function(elem, cl) {
	if(elem.className) {
		var classes = elem.className.split(" ");
		elem.className = "";
		for(var i in classes) {
			if(classes[i] != cl) {
				elem.className += " " + classes[i];
			}
		}
	}
};

FunctionLibrary.prototype.removeClassNameById = function(aID, cl) {
	return this.findElemAndApply(aID, this.removeClassName, [cl]);
};

FunctionLibrary.prototype.hasClassName = function(elem, cl) {
	var classes = elem.className.split(" ");
	return this.arIndexOf(classes, cl) != -1;
};

FunctionLibrary.prototype.hasClassNameById = function(aID, cl) {
	return this.findElemAndApply(aID, this.hasClassName, [cl]);
};

//------------------------------------------------------------------------------

/**
 * aplikuje funkci na dany element, podle ID
 * 
 */
FunctionLibrary.prototype.findElemAndApply = function(aID, fun) {
	var elem;
	var args = new Array();
	var i;
	if((elem = this.getElementById(arguments[0])) !== null) {
		args.push(elem);
		for(i = 2; i < arguments.length; i++) {
			args.push(arguments[i]);
		}
		return arguments[1].apply(this, args);
	}
};

/**
 * zavola funkci nad kazdym prvkem pole
 * 
 * @param arr
 * @param fun
 */
FunctionLibrary.prototype.each = function(arr, fun) {
	for(var i = 0; i < arr.length; i++) {
		fun(arr[i]);
	}
};

/**
 * preda funkci kazdy prvek pole a vysledky uklada do jineho pole
 * 
 * @param arr
 * @param fun
 * @returns
 */
FunctionLibrary.prototype.map = function(arr, fun) {
	ret = [];
	for(var i = 0; i < arr.length; i++) {
		ret.push(fun(arr[i]));
	}
	return ret;
};

//------------------------------------------------------------------------------

/**
 * vytvori objekt DOM
 * 
 * @param tagName
 * @returns
 */
FunctionLibrary.prototype.createElem = function(tagName) {
	return document.createElement(tagName);
};

/**
 * nastavi prvku novy obsah
 * 
 * @param elem
 * @param newChild
 */
FunctionLibrary.prototype.setElemContent = function(elem) {
	fLib.removeChildren(elem);
	for(var i = 1; i < arguments.length; i++) {
		elem.appendChild(arguments[i]);
	}
};

FunctionLibrary.prototype.appendChildren = function(elem) {
	for(var i = 1; i < arguments.length; i++) {
		elem.appendChild(arguments[i]);
	}
};

//------------------------------------------------------------------------------

FunctionLibrary.prototype.splitVarString = function(string, stringSep, varSep, valueSep) {
	if(!stringSep) {	stringSep = "?";	}
	if(!varSep) {		varSep = "&";		}
	if(!valueSep) {		valueSep = "=";		}
	var ret = new Array();
	var all = string.split(stringSep);
	if(all.length == 2) {
		var separed = all[1].split(varSep);
		for(var i in separed) {
			var tmp = separed[i].split(valueSep);
			if(tmp.length == 2) {
				ret.push({"varName": tmp[0], "varValue": tmp[1]});
			}
		}
	}
	return ret;
};

FunctionLibrary.prototype.findVarByName = function(vars, name) {
	for(i in vars) {
		if(vars[i].varName == name) {
			return vars[i].varValue;
		}
	}
	return null;
};

FunctionLibrary.prototype.setVar = function(vars, name, value, append) {
	if(!this.findVarByName(vars, name) || append) {
		vars.push({"varName": name, "varValue": value});
	} else {
		for(var i in vars) {
			if(vars[i].varName == name) {
				vars[i].varValue = value;
			}
		}
	}
	return vars;
};

FunctionLibrary.prototype.removeVar = function(vars, name, value) {
	var tmp = [];
	for(var i in vars) {
		if(vars[i].varName != name) {
			tmp.push(vars[i]);
		} else if(value) {
			//je specifikovana hodnota
			if(vars[i].varValue != value) {
				tmp.push(vars[i]);
			}
		}
	}
	return tmp;
};

FunctionLibrary.prototype.buildVarString = function(vars, stringSep, varSep, valueSep) {
	if(!stringSep) {	stringSep = "?";	}
	if(!varSep) {		varSep = "&";		}
	if(!valueSep) {		valueSep = "=";		}
	var s = "";
	var sep = stringSep;
	for(var i in vars) {
		s += sep + vars[i].varName + valueSep + vars[i].varValue;
		sep = varSep;
	}
	return s;
};

//------------------------------------------------------------------------------

FunctionLibrary.prototype.addHashVar = function(name, value, append) {
	var vars = this.getHashVars();
	this.setVar(vars, name, value, append);
	this.setHashVars(vars);
};

/**
 * projde hahs a rozdeli ho podle & a nasledne vrati dvojce k=v v poli
 */
FunctionLibrary.prototype.getHashVars = function() {
	return this.splitVarString(location.hash, "#", "&", "=");
};

FunctionLibrary.prototype.removeHashVar = function(name, value) {
	var vars = this.splitVarString(location.hash, "#", "&", "=");
	this.removeVar(vars, name, value);
	this.setHashVars(vars);
};

/**
 * vrati hodnotu promenne podle nazvu
 * 
 * @param name
 * @returns
 */
FunctionLibrary.prototype.getHashVar = function(name) {
	var vars = this.getHashVars();
	return this.findVarByName(vars, name);
};

/**
 * zkontroluje pritomnost promenne
 * 
 * @param name
 * @returns {Boolean}
 */
FunctionLibrary.prototype.hasHashVar = function(name) {
	var vars = this.getHashVars();
	var value = this.findVarByName(vars, name);
	return value != null;
};

FunctionLibrary.prototype.setHashVars = function(vars) {
	location.hash = this.buildVarString(vars, "#", "&", "=");
};

//------------------------------------------------------------------------------

/**
 * vytvori funkci, ktera ma nastavenou hodnotu this na context
 */
FunctionLibrary.prototype.closure = function() {
	var context = arguments[0];
	var fun = arguments[arguments.length - 1];
	var args = [];
	for(var i = 1; i < arguments.length - 1; i++) {
		args.push(arguments[i]);
	}
	
	return function() {
		var tmpArgs = new Array();
		for(var i in args) {
			tmpArgs.push(args[i]);
		}
		//zde muzou byt pri volani predany dalsi argumenty
		for(var i = 0; i < arguments.length; i++) {
			tmpArgs.push(arguments[i]);
		}
		fun.apply(context, tmpArgs);
	};
};

//------------------------------------------------------------------------------

var Sizzler = function(selector, context) {
	this.items = Sizzle(selector, context);
};

Sizzler.prototype.each = function(fun) {
	fLib.each(this.items, fun);
};

Sizzler.prototype.getAll = function() {
	return this.items;
};

/**
 * na prvni element zavola funkci
 */
Sizzler.prototype.first = function(fun) {
	if(this.items.length > 0) {
		fun(this.items[0]);
	}
};

Sizzler.prototype.getFirst = function() {
	if(this.items.length > 0) {
		return this.items[0];
	}
	return null;
};

Sizzler.prototype.last = function(fun) {
	if(this.items.length > 0) {
		fun(this.items[this.items.length - 1]);
	}
	return null;
};

Sizzler.prototype.getLast = function() {
	if(this.items.length > 0) {
		return this.items[this.items.length - 1];
	}
};

Sizzler.prototype.event = function(event, handler) {
	this.each(function(elem) {
		fLib.addEvent(event, function(elem) {
			return handler(elem);
		}, elem);
	});
};

Sizzler.prototype.style = function(property, value) {
	this.each(function(elem) {
		elem.style[property] = value;
	});
};

Sizzler.prototype.remove = function() {
	this.each(function(elem) {
		if(elem.parentNode) {
			elem.parentNode.removeChild(elem);
		}
	});
};

//------------------------------------------------------------------------------

var SZ = function(selector, context) {
	if(Sizzle != undefined) {
		return new Sizzler(selector, context);
	} else {
		throw "Sizzle not found.";
	}
};

var fLib = new FunctionLibrary();

var CL = fLib.closure;