///////////////////////////////////////////////////////////////////////////////// 
// Javascript Library - pikkupuu.com 
// 
// created on nov and dec in 2005 by Jarkko Tuomala 
// 
// 
///////////////////////////////////////////////////////////////////////////////// 


function setCookie(name, value, expire) { 
        deleteCookie(name); 
        document.cookie = name + "=" + escape(value) + ((expire == null) ? "" : ("; expires=" + expire.toGMTString())) 
} 

function deleteCookie(name) {
   if (getCookie(name)) {
       document.cookie = name + "=" + ";expires=Thu, 01-Jan-70 00:00:01 GMT";
   }
} 

function getCookie(Name) { 
        var search = Name + "="; 
        if (document.cookie.length > 0) { // if there are any cookies 
                offset = document.cookie.indexOf(search); 
                if (offset != -1) { // if cookie exists 
                        offset += search.length;   // set index of beginning of value 
                        end = document.cookie.indexOf(";", offset);   // set index of end of cookie value 
                        if (end == -1) { 
                                end = document.cookie.length; 
                        } 
                        return unescape(document.cookie.substring(offset, end)) 
                } 
        } 
}

function addAttributeNode(oElement, sAttr, sValue) { 
        // create new attribute 
        var newattr = document.createAttribute(sAttr);
       newattr.value = sValue;
       // add attribute to element 
        oElement.setAttributeNode(newattr); 
} 

/////////////////////////////////////////////////////////////////////////////////////////////// 
// FUNCTION - created on 3.3.2004 by Jarkko Tuomala 
// Trim whitespace from left and right sides of string 
/////////////////////////////////////////////////////////////////////////////////////////////// 
function trim() { 
        var sTrim = (arguments.length > 0) ? arguments[0] : this; 
        return (sTrim) ? sTrim.replace( /^\s*/, "" ).replace( /\s*$/, "" ) : ""; 
} 

String.prototype.trim = trim; 

///////////////////////////////////////////////////////////////////////////////// 
// getElement() function created by Jarkko Tuomala on 31.3.2003 
// gets document element by id given as parameter 
// returns element object 
///////////////////////////////////////////////////////////////////////////////// 
function getElement(id) { 
        if (document.getElementById) { 
                return document.getElementById(id); 
        } else if (document.all) { 
                return document.all(id); 
        } else { 
                return eval("document."+id); 
        } 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 14.10.2003 by Jarkko Tuomala 
// returns element array of tagName given as parameter 
//////////////////////////////////////////////////////////////// 
function getElementArrayByTagName(tagName) { 
        if (document.getElementsByTagName) { 
                return document.getElementsByTagName(tagName); 
        } else if (document.all) { // IE4 
                return document.all.tags(tagName); 
        } else if (document.tags) { // NN4 
                return eval("document.tags."+tagName); 
        } else { 
                return null; 
        } 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 6.5.2004 by Jarkko Tuomala 
// returns attribute value of object given as parameter 
//////////////////////////////////////////////////////////////// 
function getAttribute(object, attribute) { 
        var attr = (object.getAttributeNode(attribute)) ? object.getAttributeNode(attribute).value : object.getAttribute(attribute); 
        return (attr) ? attr : null; 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 7.11.2003 by Jarkko Tuomala 
// returns parent element of element given as parameter 
//////////////////////////////////////////////////////////////// 
function getElementParent(elem) { 
        var parent = (elem.parentNode) ? elem.parentNode : elem.parentElement; 
        return (parent) ? parent : null; 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 7.11.2003 by Jarkko Tuomala 
// returns the tag name of element given as parameter 
//////////////////////////////////////////////////////////////// 
function getElementName(elem) { 
        var name = (elem.nodeName) ? elem.nodeName : elem.tagName; 
        return (name) ? name : null; 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 14.10.2003 by Jarkko Tuomala 
// returns target element of current event 
//////////////////////////////////////////////////////////////// 
function getTargetElement(evt) { 
  if (evt.target) { 
          return (evt.target.nodeType == 3) ? evt.target.parentNode : evt.target; 
  } else { 
        return evt.srcElement; 
  } 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 13.6.2005 by Jarkko Tuomala 
// returns parent element with certain node name 
// and optionally with certain attribute and value 
// function call examples: 
//        getParent(element,'div') 
//        getParent(element,'div',[{attribute:'class',value:'row'}]) 
//////////////////////////////////////////////////////////////// 
var getParent = function recFunction(elem,name,attr) { 
        if (arguments.length != 3) { attr = null; } 
        var oParent = null; 
        var parent = getElementParent(elem); 
        var parentName = getElementName(parent).toLowerCase(); 
        if (parentName == name) { 
                if (attr) { 
                        // return only element with certain attribute and value 
                        var  oAttr= getAttribute(parent,attr[0].attribute); 
                        if (oAttr && oAttr.indexOf(attr[0].value) != -1) { 
                                return parent; 
                        } 
                } else { 
                        return parent; 
                } 
        } 
        if (parentName != "html") { 
                oParent = recFunction(parent,name,attr); 
        } 
        return (oParent) ? oParent : null; 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 9.6.2005 by Jarkko Tuomala 
// updated on 13.9.2005 with attribute search 
// returns first child element with certain node name 
// and optionally with certain attribute and value 
// function call examples: 
//        getChildren(parentElement,'span') 
//        getChildren(parentElement,'span',[{attribute:'class',value:'end'}]) 
//////////////////////////////////////////////////////////////// 
var getChildren = function recursiveFunction(elem,name,attr) { 
        var child; 
        var elemChild; 
        var oChild = null; 
        if (arguments.length != 3) { attr = null; } 
        for (child=0;child<elem.childNodes.length;child++) { 
                elemChild = elem.childNodes[child]; 
                if (getElementName(elemChild).toLowerCase() == name) { 
                        if (attr) { 
                                // return only element with certain attribute and value 
                                var  oAttr= getAttribute(elemChild,attr[0].attribute); 
                                if (oAttr && oAttr.indexOf(attr[0].value) != -1) { 
                                        return elemChild; 
                                } 
                        } else { 
                                return elemChild; 
                        } 
                } 
                // call this recursive function if some node has child nodes 
                if (elemChild.hasChildNodes()) { 
                        oChild = recursiveFunction(elemChild,name,attr); 
                } 
                // return child if it have been found 
                if (oChild) { 
                        return oChild; 
                } 
        } 
        return null; 
} 

//////////////////////////////////////////////////////////////// 
// FUNCTION - created on 10.6.2005 by Jarkko Tuomala 
// returns all child elements with certain node name 
// function call examples: 
//        getChildNodes(element,'div',new Array()) - returns all found elements in array 
//        getChildNodes(element,'div',null) - returns the first found element 
//        getChildNodes(element,'div') - returns the first found element 
//////////////////////////////////////////////////////////////// 
var getChildNodes = function recFunc(elem,name,a) { 
        var child; 
        var elemChild; 
        var oChild = null; 
        if (arguments.length != 3) { a = null; } 
        for (child=0;child<elem.childNodes.length;child++) { 
                elemChild = elem.childNodes[child]; 
                if (getElementName(elemChild).toLowerCase() == name) { 
                        if (a) { 
                                a.push(elemChild); 
                        } else { 
                                 return elemChild; 
                        } 
                } 
                // call this recursive function if some node has child nodes 
                if (elemChild.hasChildNodes()) { 
                        oChild = recFunc(elemChild,name,a); 
                } 
        } 
        return (a) ? (a.length>0) ? a : null : null; 
} 

///////////////////////////////////////////////////////////////////////////////// 
// FUNCTION - created on 11.5.2004 by Jarkko Tuomala 
// sets event handler to object 
///////////////////////////////////////////////////////////////////////////////// 
function setEventHandler(o,evnt,fton) { 
        /* prevent memory leaks in IE - remove event handler */ 
        removeEventHandler(o,evnt,fton); 
        // add event handler 
        if (o.addEventListener) {        // netscape 6 or higher 
                o.addEventListener(evnt.substring(2,evnt.length),fton,false); 
        } else if (o.attachEvent) { // ie5 or higher 
                o.attachEvent(evnt,fton); 
        } else {         // netscape 4 and others 
                eval(o+"."+evnt+"="+fton); 
        } 
} 

///////////////////////////////////////////////////////////////////////////////// 
// FUNCTION - created on 18.10.2005 by Jarkko Tuomala 
// removes event handler from object 
// prevents memory leaks in IE 
///////////////////////////////////////////////////////////////////////////////// 
function removeEventHandler(o,evnt,fton) { 
        if  (o.removeEventListener) {        // netscape 6 or higher
               o.removeEventListener(evnt.substring(2,evnt.length),fton, false);
       } else if (o.detachEvent) { // ie5 or higher
               o.detachEvent(evnt, fton);
       } else {         // netscape 4 and others 
                eval(o+"."+evnt+"=null"); 
        } 
}

function initEventHandlers() {
	var aInput = getElementArrayByTagName("input");
	var i;
	for (i=0;i<aInput.length;i++) { 
		var attr = getAttribute(aInput[i],"type");
		if (attr == "button") {
			if (getAttribute(aInput[i],"value") == "osta") {
				setEventHandler(aInput[i],"onclick",osta);
			} else if (getAttribute(aInput[i],"value") == "tiedot") {
				setEventHandler(aInput[i],"onclick",tiedot);
			}
		}				
	}
}

function tiedot(evt) {
	var elem = getTargetElement(evt);
	if (elem) {
		var screen = getElement("itemscreen");
		if (screen) {
			// remove products
	   	var product = getChildren(screen,'div',[{attribute:'class',value:'product'}]);
   	   while (product) { 
      		screen.removeChild(product);
				product = getChildren(screen,'div',[{attribute:'class',value:'product'}]);
	      } 

	   	var close = getChildren(screen,'div',[{attribute:'id',value:'close'}]);
			if (!close) {
				var closediv = document.createElement("div");
				var closetext = document.createTextNode("X");
				addAttributeNode(closediv, "id", "close");
				setEventHandler(closediv,"onclick",closeScreen);
				closediv.appendChild(closetext);
				screen.appendChild(closediv);
			}
			// add product
			var item = ItemManager.getItemById(elem.name);
			screen.appendChild(drawItem(item,true));
			
			screen.style.display = "block";
			if (screen.focus) {
				screen.focus();
			}
		}
	}
}

function closeScreen() {
		var screen = getElement("itemscreen");
		if (screen) {
			screen.style.display = "none";
		}
}

function osta(evt) {
	var elem = getTargetElement(evt);
	if (elem) {
		var item = ItemManager.getItemById(elem.name);
		ItemManager.AddToBundle(item);
		if (window.location.href.indexOf("tuotteet.html") == -1) {	// if ordered item of day
			setOrderCookie();
			window.location.href = "tuotteet.html";
		} else {
			drawBundle();
		}
	}
}

function setMandatoryFields() {
	var aMandatoryFields = new Array(0); 
	aMandatoryFields.push(new MandatoryField("nimi","nimi")); 
	aMandatoryFields.push(new MandatoryField("toimitusosoite","toimitusosoite"));    
	aMandatoryFields.push(new MandatoryField("postinumero","postinumero"));    
	aMandatoryFields.push(new MandatoryField("toimipaikka","postitoimipaikka"));    
	aMandatoryFields.push(new MandatoryField("email","sähköpostiosoite"));    
	return aMandatoryFields;
}

function getBuyedItems() {
	var items = getCookie("pikkupuu_basket");
	if (items) {
		var itemofday = ItemManager.getItemOfDay();	// set discount for item of day
		ItemManager.readBundleString(items);
		drawBundle(getElement("buyeditems"));
		radioHandler(radioCheckedValue("maksutapa"));
	}
}

function ConfirmOrder() {
	if (radioHandler(radioCheckedValue("maksutapa"))) {
		if (ItemManager.getItemsInBundle()) {
			if (MandatoryFields()) {
				if (checkToimitusehdot()) {
					deleteCookie("pikkupuu_basket"); 
					var orderbutton = getElement("orderbutton");
					if (orderbutton) {
						orderbutton.value = "Tilausta lähetetään, odota hetki...";
						orderbutton.disabled = true;
						orderbutton.style.background = "#fff";
						orderbutton.style.color = "#000";
					}
					document.forms[0].submit();
				}
			}
		} else {
			alert("Ostoskorisi on tyhjä.");
		}	
	}
}

function checkToimitusehdot() {
	if (getElement("checkbox_toimitusehdot").checked) {
		return true;
	} else {
		showAlert("Lue toimitusehdot huolellisesti ennen tilausta ja hyväksy ne merkitsemällä rasti kohtaan Hyväksyn toimitusehdot.");
		return false;
	}
}

function radioCheckedValue(radio) {
	var i;
	var radiofield = document.forms[0][radio];
	for (i=0;radiofield.length;i++) {
		if (radiofield[i] && radiofield[i].checked) {
			return radiofield[i].value;
		}
	}
	return "";
}

function showAlert(alertmsg) {
	var errortext = document.createTextNode(alertmsg);
	var errordiv = getElement("error_toimitusehdot");
	if (errordiv) {
		if (errordiv.hasChildNodes()) {
			errordiv.removeChild(errordiv.firstChild);
		}
		errordiv.appendChild(errortext);
		errordiv.style.display = "block";
	}
}

function clearErrorMessage() {
	var errordiv = getElement("error_toimitusehdot");
	if (errordiv) {
		if (errordiv.hasChildNodes()) {
			errordiv.removeChild(errordiv.firstChild);
		}
		errordiv.style.display = "none";
	}
}

/* delivery handler */ 
function radioHandler(delivery) { 
    if (delivery) { 
		clearErrorMessage();
        var basket = getElement("buyeditems");
		var tuotefield = getElement("tilatuttuotteet");
		var bundleinfo = ItemManager.fetchBundleInformation();
		var totalsum = parseFloat(ItemManager.getTotalInBundle());
		switch (delivery) { 
            case "ennakkolasku":
			drawTableRow(basket,"Postituskulut","10 €",true);
			if (bundleinfo) {
				if (tuotefield) {
					tuotefield.value = bundleinfo;
					tuotefield.value += String.fromCharCode(10)+"Postituskulut       10 €";
				}
				updateTotal("10");
				if (totalsum < 50) {
					showAlert("Emme toimita postitse alle 50 euron tilauksia. Ole hyvä ja lisää tuotteita ostoskoriin. Jos et itse halua tilata niin paljon, niin suosittelemme kimppatilausta tuttaviesi kanssa. Samalla voitte jakaa postituskulut keskenänne.");
					return false;
				}
			}
			break;
			case "postiennakko": 
			drawTableRow(basket,"Postituskulut","10 €",true);
			drawTableRow(basket,"Postiennakko","5 €",false);
			if (bundleinfo) {
				if (tuotefield) {
					tuotefield.value = bundleinfo;
					tuotefield.value += String.fromCharCode(10)+"Postituskulut       10 €";
					tuotefield.value += String.fromCharCode(10)+"Postiennakko       5 €";
				}
					updateTotal("15");
				if (totalsum < 200) {
					showAlert("Emme toimita postiennakolla alle 200 euron tilauksia. Ole hyvä ja muuta maksutapaa tai lisää tuotteita ostoskoriin.");
					return false;
				}
			}
			break; 
			case "nouto": 
			var succeed = removeTableRow(basket,true);
			if (bundleinfo) {
				if (tuotefield) {
					tuotefield.value = bundleinfo;
				}
				updateTotal("0");
			}
			break;
			case "lasku": 
			drawTableRow(basket,"Laskutuspalkkio","5 €",true);
			if (bundleinfo) {
				if (tuotefield) {
					tuotefield.value = bundleinfo;
					tuotefield.value += String.fromCharCode(10)+"Laskutuspalkkio       5 €";
				}
				updateTotal("5");
				if (totalsum < 100) {
					showAlert("Emme toimita laskulla alle 100 euron tilauksia. Ole hyvä ja muuta maksutapaa tai lisää tuotteita ostoskoriin.");
					return false;
				}
			}
			break;			
		}
		return true;
    } else {
		alert("Maksutapaa ei ole valittuna!");
		return false;
	}
} 

function releaseYtunnus(value) {
	var note = getElement("note_ytunnus");
	if (note) {
		note.className = (value == "") ? "hideerror" : "notice";
	}
	var ytunnus = getElement("ytunnus");
	if (ytunnus) {
		ytunnus.disabled = (value == "") ? true : false;
		ytunnus.className = (value == "") ? "disabled_input" : "";
		if (value == "") {
			ytunnus.value = "";
		} else {
			ytunnus.focus();
		}
		var row = getParent(ytunnus,"div",[{attribute:'class',value:'row'}]);
		if (row) {
			var label = getChildren(row,"label");
			if (label) {
				label.className = (value == "") ? "disabled" : "";
			}
		}
	}
}

function releaseLasku(value) {
	var note = getElement("note_ytunnus");
	if (note) {
		note.className = (value != "") ? "hideerror" : "notice";
	}
	var radio = getElement("radio_lasku");
	if (radio) {
		radio.disabled = (value == "") ? true : false;
		radio.checked = (value != "") ? true : false;
		if (value == "") {
			document.forms[0]["maksutapa"][0].checked = true;
		}
		var label = getParent(radio,"label");
		if (label) {
			label.className = (value == "") ? "disabled" : "";
		}
	}
}

function updateTotal(delivery) {
	var totalprice = parseFloat(ItemManager.getTotalInBundle())+parseFloat(delivery);
	var total = getElement("total");
	if (total) {
		if (total.firstChild) {
			total.removeChild(total.firstChild);
		}
		var newprice = document.createTextNode(totalprice+" €");
		total.appendChild(newprice);
	}
	var summafield = getElement("summa");
	if (summafield) {
		summafield.value = totalprice+" €";
	}	
}

function setOrderCookie() {
	var items = ItemManager.getBundleString();
	if (items) {
	        // set cookie 
        	var today = new Date() 
	        var expires = new Date();
			var nDays = 1;
        	expires.setTime(today.getTime() + 3600000*24*nDays); 
	        // set chosen_cookie 
	        setCookie("pikkupuu_basket", items, expires);
        	// end of set cookie
	}
}

function sendOrder() {
	var items = ItemManager.getBundleString();
	if (items) {
	    setOrderCookie();
		window.location.href = "basket.html";
	} else {
		alert("Et ole valinnut vielä yhtään tuotetta.");
	}
}

function removeTableRow(basket,remove) {
	var succeed = null;
	if (basket) {
		var tbody = getChildren(basket,"tbody");
		if (tbody) {
			var trow = getChildren(tbody,"tr",[{attribute:'class',value:'delivery'}]);
			while (trow) {
				succeed = true;
				if (remove) {
					tbody.removeChild(trow);
					trow = getChildren(tbody,"tr",[{attribute:'class',value:'delivery'}]);
				} else {
					trow = null;
				}
			}
			if (succeed == null) {
				succeed = (remove) ? (ItemManager.getItemsInBundle()) ? true : false : false;
			}
		}
	}
	return succeed;
}

function drawTableRow(basket,name,price,override) {
	if (basket) {
		succeed = removeTableRow(basket,override);
		if (succeed) {
			var tbody = getChildren(basket,"tbody");
			if (tbody) {
				var trow = document.createElement("tr");
				addAttributeNode(trow, "class", "delivery");
				var th = document.createElement("th");
				var td2 = document.createElement("td");		
				var td3 = document.createElement("td");
				var td4 = document.createElement("td");	
				var nametext = document.createTextNode(name);
				th.appendChild(nametext);
				var pricetext = document.createTextNode(price);
				td3.appendChild(pricetext);
				trow.appendChild(th);
				trow.appendChild(td2);
				trow.appendChild(td3);
				trow.appendChild(td4);
				tbody.appendChild(trow);
			}
		}
	}
}

function drawBundle(basket) {
	clearErrorMessage();
	if (!basket) {
		basket = getElement("ostoskori");
	}
	var tbody = null;
	var items = ItemManager.getItemsInBundle();
	if (basket) {
		tbody = getChildren(basket,"tbody");
		var trow = getChildren(tbody,"tr");
		while (trow) {
			tbody.removeChild(trow);
			trow = getChildren(tbody,"tr");
		}
		var thead = getChildren(basket,"thead");
		var tfoot = getChildren(basket,"tfoot");
		thead.style.visibility = (items.length > 0) ? "visible" : "hidden";
		tfoot.style.visibility = (items.length > 0) ? "visible" : "hidden";
		if (items.length == 0) {
			var emptytext = document.createTextNode("Ostoslistasi on tyhjä.");
			var emptytr = document.createElement("tr");
			var emptytd = document.createElement("td");
			addAttributeNode(emptytd, "colspan", "4");
			if (tbody) {
				emptytd.appendChild(emptytext);
				emptytr.appendChild(emptytd);
				tbody.appendChild(emptytr);
			}
			return;
		}
	}
	var i;
	for (i=0;i<items.length;i++) {
		// create table rows
		var tr = document.createElement("tr");
		var td1 = document.createElement("th");
		var td2 = document.createElement("td");		
		var td3 = document.createElement("td");
		var td4 = document.createElement("td");		
		var nametext = document.createTextNode(items[i].getShortname());
		var pricetext = document.createTextNode(String(Math.round(items[i].getItemPrice()*items[i].getBasket()*100)/100)+" €");
		
		td1.appendChild(nametext);
		td3.appendChild(pricetext);
		
		// add input for amount of item		
		var eInput = document.createElement("input");
		addAttributeNode(eInput, "type", "text");
		addAttributeNode(eInput, "size", "3");
		addAttributeNode(eInput, "name", items[i].getId());
		addAttributeNode(eInput, "value", items[i].getBasket());
		setEventHandler(eInput,"onchange",updateTotalItemPrice);
		td2.appendChild(eInput);
			
		// add remove image
		var removeimg = document.createElement("img");
		var path = "images/";
		addAttributeNode(removeimg, "src", path+"remove.gif");
		addAttributeNode(removeimg, "class", "remove");
		addAttributeNode(removeimg, "name", items[i].getId());
		setEventHandler(removeimg,"onclick",removeItem);
		td4.appendChild(removeimg);

		tr.appendChild(td1);
		tr.appendChild(td2);
		tr.appendChild(td3);
		tr.appendChild(td4);
		if (tbody) {
			tbody.appendChild(tr);
		}
	}
	var total = getElement("total");
	if (total) {
		if (total.firstChild) {
			total.removeChild(total.firstChild);
		}
		var newprice = document.createTextNode(ItemManager.getTotalInBundle()+" €");
		total.appendChild(newprice);
	}
	if (basket.focus) {
		basket.focus();
	}
}

function removeItem(evt) {
	var elem = getTargetElement(evt);
	if (elem) {
		ItemManager.RemoveFromBundle(ItemManager.getItemById(elem.name));
		var ostoskori = getElement("buyeditems");
		drawBundle(getElement("buyeditems"));
		if (ostoskori) {
			radioHandler(radioCheckedValue("maksutapa"));
			setOrderCookie();
		}
	}
}

function updateTotalItemPrice(e) {
	var elem = getTargetElement(e);
	if (elem) {
		var item = ItemManager.getItemById(elem.name);
		if (!isNaN(elem.value)) {
			item.setBasket(elem.value);
			setOrderCookie();
		}
	}
	drawBundle(getElement("buyeditems"));
}

function initItems() {
	var itemofday = ItemManager.getItemOfDay();	// set discount for item of day
	var items = getCookie("pikkupuu_basket");
	if (items) {
		ItemManager.readBundleString(items);
		drawBundle();
	}
	drawItems(null);
	initEventHandlers();
}

function drawItemOfDay() {
   var item = ItemManager.getItemOfDay();
   var i; 
   var content = getElement("contentforitem");
   if (item == null) {
	if (content && content.firstChild) {
		var removeitem = getChildren(content,"h3");
		content.removeChild(removeitem);
	}
	return;
   }
	// remove products
	if (content) { 
   	var product = getChildren(content,'div',[{attribute:'class',value:'product'}]);
      if (product) { 
      	content.removeChild(product); 
      } 
   }
   var itemHTML; 
   	itemHTML = drawItem(item,false);
    content.appendChild(itemHTML); 

	initEventHandlers();
}

function drawItems(category) {
	var items = (category == null) ? ItemManager.getAllItems() : (category == 'discounted') ? ItemManager.getDiscountedItems() : ItemManager.getItemsByCategory(category);
   var i; 
   var content = getElement("content");
	// remove products
	if (content) { 
   	var product = getChildren(content,'div',[{attribute:'class',value:'product'}]);
      while (product) { 
      	content.removeChild(product); 
			product = getChildren(content,'div',[{attribute:'class',value:'product'}]);
      } 
   }
   var itemHTML; 
   for (i=0;i<items.length;i++) { 
   	itemHTML = drawItem(items[i],false);
      content.appendChild(itemHTML); 
   } 
	initEventHandlers();
	setSelectedCategory(category);
} 

function drawItem(item,screen) { 
/*<div class="product">
	<h1>Otsikko</h1>
	<img src="C:\Documents and Settings\Sani\My Documents\HexinToy\HexinProductKuvat\158_1108YT7021B.jpg" />
	<ul>
		<li><label>nimi</label><span>lehmä</span></li>
		<li>20€</li>
	</ul>
	<div class="buttons">
		<input type="button" value="tiedot" />
		<input type="button" value="osta" name="item_xxx_2003" />
	</div>
</div>*/
   var newdiv = document.createElement("div");
	addAttributeNode(newdiv, "class", "product");
   var newheader = document.createElement("h1");
	if (!screen) {
		var textname = document.createTextNode(item.getShortname());
	} else {
		var textname = document.createTextNode(item.getLongname());
	}
	newheader.appendChild(textname);
   var newimg = document.createElement("img");
	var path = "items/";
	addAttributeNode(newimg, "src", path+item.getImage());
   var newul = document.createElement("ul");
   if (!screen) {
   addAttributeNode(newul, "class", "narrow");
   } else {
   addAttributeNode(newul, "class", "wide");
   }
	var price = parseFloat(item.getPrice());
	var discount = parseFloat(item.getDiscount());
	if (discount > 0) {
		if (!screen) {
			var disprice = item.getItemPrice()+" €";
		} else {
			var disprice = item.getItemPrice()+" € (säästä "+String(item.getDiscount()*100)+"%)";
		}
		newul.appendChild(createListElement("hinta", String(price)+" €", "discounted", disprice, "discount"));
	} else {
		newul.appendChild(createListElement("hinta", String(price)+" €", null, null, null));
	}
	newul.appendChild(createListElement("ikäsuositus", item.getAge(), null, null, null));
	newul.appendChild(createListElement("saatavuus", item.getStock(), null, null, null));
	if (screen) {
		newul.appendChild(createListElement("koko", item.getDimension()+" cm", null, null, null));
		newul.appendChild(createListElement("kuvaus", item.getDescription(), null, null, null));
	}
	var innerdiv = document.createElement("div");
	addAttributeNode(innerdiv, "class", "buttons");
	var newinput = document.createElement("input");
	addAttributeNode(newinput, "type", "button");
	addAttributeNode(newinput, "class", "button");
	if (!screen) {
		addAttributeNode(newinput, "value", "tiedot");
		addAttributeNode(newinput, "name", item.getId());
	} else {
		addAttributeNode(newinput, "value", "sulje");
		setEventHandler(newinput,"onclick",closeScreen);
	}
	var newinput2 = document.createElement("input");	
	addAttributeNode(newinput2, "type", "button");
	addAttributeNode(newinput2, "class", "button");
	addAttributeNode(newinput2, "value", "osta");
	if (screen) {
		setEventHandler(newinput2,"onclick",osta);
	}
	addAttributeNode(newinput2, "name", item.getId());
	innerdiv.appendChild(newinput);
	innerdiv.appendChild(newinput2);	
	newdiv.appendChild(newheader);
	newdiv.appendChild(newimg);
	newdiv.appendChild(newul);
	newdiv.appendChild(innerdiv);
	return newdiv;
}

function createListElement(label, text, attr, text2, attr2) {
   var newli = document.createElement("li");	
   var newlabel = document.createElement("label");
	var textlabel = document.createTextNode(label);
	newlabel.appendChild(textlabel);
	newli.appendChild(newlabel);

   var newspan = document.createElement("span");
	var textspan = document.createTextNode(text);
	if (attr) {
		addAttributeNode(newspan, "class", attr);
	}
	newspan.appendChild(textspan);
	newli.appendChild(newspan);

	if (text2) {
	   var newspan2 = document.createElement("span");
		var textspan2 = document.createTextNode(text2);
		if (attr2) {
			addAttributeNode(newspan2, "class", attr2);
		}
		newspan2.appendChild(textspan2);
		newli.appendChild(newspan2);
	}

	return newli;
}

function setSelectedCategory(category) {
	var menu = getElement("menu");
	if (menu) {
		var j;
		var lis = getChildNodes(menu,'li',new Array(0));
      if (lis) { 
	      for (j=0;j<lis.length;j++) { 
	      	lis[j].className = "";
         }
      }
	}
	if (!category) { return; }
	var cat = getElement(category);	
	if (cat) {
		cat.className = "n1on";
	}
}