/* Functii utile la prelucrari diverse in cadrul script-urilor de Java Script
 * Author: 	Gimi
 * Date: 	2006.02.07
 * Version:	1.1
 */

// functii utile in diverse operatii asupra aplicatiei web
// ------------------------------------------------------------------------------------------------------

var is_ns6 = document.getElementById ? 1 : 0;			// 1 for NS6,7, Mozilla, Firefox, IE, Opera
var is_ie4 = document.all ? 1 : 0;						// 1 for IE, Opera

var agt = navigator.userAgent.toLowerCase();
var is_opera = (agt.indexOf("opera") != -1);			// just Opera


// ACTION: 			functie de trimitere a datelor dintr-un form la confirmarea unei actiuni
// Parametrii: 		form - numele formularului
// 					id - valoare (id-ul) care se trimite ca variabila
// 					text - textul care va fi afisat in caseta de confirmare generata
// Returneaza:		testeza confirmarea si lanseaza trimitera datelor in caz afirmativ
// Uz: 				la operatiile care necesita confirmarea actiunii
// ------------------------------------------------------------------------------------------------------
function action(form, id, text) {
	if(confirm(text)) {
		eval("document."+form+".id.value="+id);
		eval("document."+form+".submit()");
	}
}
// ------------------------------------------------------------------------------------------------------


// CONFIRM_ACTION:	functie de trimitere a datelor dintr-un form la confirmarea unei actiuni
// Parametrii: 		form - numele formularului
// 					id - valoare (id-ul) care se trimite ca variabila
// 					text - textul care va fi afisat in caseta de confirmare generata
// Returneaza:		testeza confirmarea si lanseaza trimitera datelor in caz afirmativ
// Uz: 				la operatiile care necesita confirmarea actiunii
// ------------------------------------------------------------------------------------------------------
function confirm_action(url, text) {
	if(confirm(text)) {
		window.location = url;
	}
}
// ------------------------------------------------------------------------------------------------------


// OPENWIND:	functie de deschidere a unei fereastre popup
// Parametrii: 	file_link - fisierul care se deschide in fereastra popup
// 				width - latimea ferestrei popup
// 				height - inaltimea ferestrei popup
// 				scrollbar - este yes sau no, functie de preferinte
// Returneaza:	deschiderea unei ferestre popup
// Uz: 			uneori
// ------------------------------------------------------------------------------------------------------
function openwind(file_link, window_name, width, height, scrollbar) {
	var parameters;
	var winx = (screen.width - width) / 2;
    var winy = (screen.height - height) / 2;
	
	parameters = "width="+width+", height="+height+", top="+winy+", left="+winx+", status=no, scrollbars="+scrollbar;
	
	win = window.open(file_link,window_name,parameters);
	win.window.focus();
}
// ------------------------------------------------------------------------------------------------------


// CHECK_PASS:	functie de verificare a egalitatii parolelor dintr-un formular
// Parametrii: 	form - numele formularului ptr care se verifica egalitatea celor 2 parole
// 				field_pass - numele campului de introducere al parolei
// 				field_pass_re - numele campului de reintroducere al parolei
// 				field_pass_re - 
// Returneaza:	TRUE - in caz de succes, FLASE	
// Uz:			uneori
// ------------------------------------------------------------------------------------------------------
function check_pass(form, field_pass, field_pass_re) {
	var valid = true;
	
	// verificare egalitate parole :
	if(eval("form."+field_pass+".value!=form."+field_pass_re+".value")) {
		valid = false;
		alert("Both passwords must have the same value!");
		return valid;
	}
	
	return valid;
}
// ------------------------------------------------------------------------------------------------------


// GO_TO_LOCATION:	functie de redirectare
// Parametrii: 		form_name - numele formularului in care este inclus select-ul de redirectare
// 					select_name - numele campului select
// 					var_name - numele variabilei GET care se trimite
// 					var_value - valoarea variabilei GET care se trimite
// 					uri - pagina care se va accesa
// 					operation - este "" daca variabila GET este unica
// Returneaza:		
// Uz:				ptr redirectarea catre o pagina printr-un formular
// ------------------------------------------------------------------------------------------------------
function go_to_location(form_name, select_name, var_name, var_value, uri, operation) {
	var url = "";
	
	if(operation!="") {
		url = uri+"&";
	} else {
		url = uri+"?";
	}
	
	if (document.getElementById(select_name)) {
		window.location = url+var_name+"="+var_value;
	}
/*	if(eval(document.form_name+"."+select_name+".value!=0")) {
		window.location = url+var_name+"="+var_value;
	}*/
}
// ------------------------------------------------------------------------------------------------------


// GO_TO_PAGE:	functie de trimitere la o noua pagina
// Parametrii:	form_name - url-ul paginii catre care se va face trimiterea
// Returneaza:	
// Uz:			ptr trimiterea care o pagina
// ------------------------------------------------------------------------------------------------------
function go_to_page(url) {
	window.location = url;
}
// ------------------------------------------------------------------------------------------------------


// ISNUMERIC: 	functie ce verifica ca un camp de text sa contina doar cifre
// Parametrii: 	text - textul introdus care se verifica
// 				text_alert - mesajul care se afiseaza in caz de eroare
// Returneaza:	TRUE, in cazul in care textul contine numai cifre si FALSE in caz contrar
// Uz:			ptr verificarea cifrelor intr-un text
// ------------------------------------------------------------------------------------------------------
function isnumeric(text, text_alert) {
	valid = true;
	
	var sw_text;

	for(var j=0; j<text.length; j++) {
		if(isNaN(text.charAt(j))) {
			sw_text = 1;
			break;
		}
	}
	
	if((sw_text==1)) {
		valid = false;
		alert(text_alert);
		return valid;
	}
	
	return valid;
}
// ------------------------------------------------------------------------------------------------------


// VERIFY_PRICE_FIELD: 	functie utila pentru introducerea corecta a preturilor
// Parametrii: 			price - pretul introdus care se verifica
// 						price_alert - mesajul care se afiseaza in caz de eroare
// 						points_error - mesajul de eroare in cazul in care pretul contine mail multe semne "."
// Returneaza:			TRUE, in cazul in care textul contine numai cifre si FALSE in caz contrar
// Uz:					ptr verificarea cifrelor intr-un text
// ------------------------------------------------------------------------------------------------------
function verify_price_field(price, price_alert, points_error) {
	valid = true;
	
	var sw_price, puncte;
	sw_price = 0;
	puncte = 0;
	
	for(var j=0; j < price.length; j++) {
		if(isNaN(price.charAt(j))) {
			sw_price++;
		}
		
		if(price.charAt(j)==".")
			puncte++;
	}
	
	if((sw_price - puncte) > 0) {
		valid = false;
		alert(price_alert);
		return valid;
	} else {
		// se verifica ca pretul sa nu aiba mai multe puncte asociate :
		if(puncte > 1) {
			valid = false;
			alert(points_error);
			return valid;
		}
	}
	
	return valid;
}
// ------------------------------------------------------------------------------------------------------


// CHECK_EXT: 	functie de verificare a extensiei unui fisier
// Parametrii: 	path - calea catre fisierul de pe disc care se verifica
// 				array_ext - vectorul de tip JS ce contine extensiile permise
// Returneaza:	TRUE, in cazul in care fisierul contine si FALSE in caz contrar
// Uz:			ptr verificarea extensiei unui fisier
// ------------------------------------------------------------------------------------------------------
function check_ext(path, array_ext) {
	var file_array = path.split(".");
	var ext, sw_ext=0;
	
	for(i=0;i<file_array.length;i++) {
		if(i==(file_array.length-1)) {
			ext = file_array[i];
		}
	}
	
	for(i=0;i<array_ext.length;i++) {
		if(ext.toUpperCase()==array_ext[i] || ext.toLowerCase()==array_ext[i]) {
			sw_ext = 1;
			break;
		}
	}
	
	return sw_ext;
}
// ------------------------------------------------------------------------------------------------------


// JS_IN_STRING_ARRAY:	functie de verificare daca exista un anumit caracter intr-un string
// Parametrii: 			search_val - string-ul in care se cauta caracterele
// 						array_val - vectorul ce contine caracterele nedorite
// Returneaza:			returneaza un vector ce contine:
//						pe prima pozitie: TRUE sau FALSE, functie de rezultat (gasit/negasit)
//						pe a doua pozitie: caracterul nedorit
// Uz:					in cazul in care exista caractere nepermise intr-un string
// ------------------------------------------------------------------------------------------------------
function js_in_string_array(search_val, array_val) {
	var sw = Array();
	sw[0] = "0";
	sw[1] = "";
	
	for(i=0; i<array_val.length; i++) {
		if(search_val.indexOf(array_val[i])!=-1) {
			sw[0] = "1";
			sw[1] = array_val[i];
			break;
		}
	}
	
	return sw;
}
// ------------------------------------------------------------------------------------------------------


// JS_IN_ARRAY:		functie de verificare a existentei unei valori intr-un vector
// Parametrii: 		search_val - valoare cautata
// 					array_val - vectorul in care se cauta
// Returneaza:		returneaza TRUE, daca valoarea a fost gasita in vector
// Uz:				in cazul vectorilor JS
// ------------------------------------------------------------------------------------------------------
function js_in_array(search_val, array_val) {
	var sw = 0;
	
	for(i=0; i<array_val.length; i++) {
		if(search_val==array_val[i]) {
			sw = 1;
			break;
		}
	}
	
	return sw;
}
// ------------------------------------------------------------------------------------------------------


// JS_TRIM:		functie de eliminare a spatiilor din stanga si dreapta unui string
// Parametrii: 	s - string-ul de modificat
// Returneaza:	string-ul modificat
// Uz:			in cazul string-urilor
// ------------------------------------------------------------------------------------------------------
function js_trim(s) {
	while (s.substring(0,1)==' ') {
		s = s.substring(1,s.length);
	}
	
	while (s.substring(s.length-1,s.length)==' ') {
		s = s.substring(0,s.length-1);
	}
	return s;
}
// ------------------------------------------------------------------------------------------------------


// FORMATNUM: 	functie da formatare a numerelor intregi
// Parametrii: 	expr - numarul care urmeaza a fi formatat
// 				decplaces - numarul de zerouri care vor fi adaugate numarului intreg
// Returneaza:	noul numar formatat
// Uz:			ptr formatarea unui numar
// ------------------------------------------------------------------------------------------------------
function formatnum(expr, decplaces) {
	var str = (Math.round(parseFloat(expr) * Math.pow(10,decplaces))).toString()
	while (str.length <= decplaces) {
		str = "0" + str
	} 
	var decpoint = str.length - decplaces
	return str.substring(0,decpoint) + "." + str.substring(decpoint,str.length)
}
// ------------------------------------------------------------------------------------------------------


// CHECK_MAIL:	functie de verificare a adresei de e-mail
// Parametrii: 	str - string-ul care este verificat
// 				text - mesajul care se afiseaza in caz de eroare
// Returneaza:	TRUE, in cazul in care fisierul contine si FALSE in caz contrar
// Uz:			ptr verificarea mail-ului
// ------------------------------------------------------------------------------------------------------
function check_mail(str, text) {
	valid = true;
	if(str=="") {
		alert(text);
		valid = false;
	} else {
		tmp = str;
		if(tmp.indexOf("@")==-1 || tmp.indexOf("@")==0) {
			alert(text);
			valid = false;
		} else {
			arr1 = new Array();
			arr1 = tmp.split("@");
			if(arr1[1].indexOf(".")==-1 || arr1[1].indexOf(".")==0) {
				alert(text);
				valid = false;
			} else {
				arr2 = new Array();
				arr2 = arr1[1].split(".");
				if(arr2[1].length<2 || arr2[1].length>20) {
					alert(text);
					valid = false;
				}
			}
		}
	}
	return valid;
}
// ------------------------------------------------------------------------------------------------------


// SHOW_HIDE_ELEMENT:	permite ascunderea/afisarea unui element HTML identificat prin intermediul unui ID
// Parametrii: 			element_name - numele id-ului elementului ptr care se aplica operatia
// 						operation - show sau hide
// Returneaza:			-
// Uz:					ptr ascunderea/afisarea elementelor HTML
// ------------------------------------------------------------------------------------------------------
function show_hide_element(element_name, operation) {
	if(operation == "show") {
		document.getElementById(element_name).style.display = '';
	} else if(operation == "hide") {
		document.getElementById(element_name).style.display = 'none';
	}
}
// ------------------------------------------------------------------------------------------------------


// CHECK_UNCHECK_ALL:	permite selctii multiple in cazul checkbox-urilor
// Parametrii: 			operation - check/uncheck functie de operatia care se efectueaza
// 						form_name - numele formularului in care se gasesc checkbox-urile
// Returneaza:			-
// Uz:					ptr check/uncheck de checkbox-uri
// ------------------------------------------------------------------------------------------------------
function check_uncheck_all(operation, form_name, field_checks) {
	var form = eval("document."+form_name);
	var valid = true;
	
	if(operation=="uncheck")
		valid = false;
	
	check_id = "";
	for (var i = 0; i<form.elements.length; i++) {
		if(form.elements[i].type.indexOf("checkbox")!=-1) {
			form.elements[i].checked = valid;
			
			if(operation=="check")
				check_id = check_id + form.elements[i].value + "|";
			else
				check_id = "";
		}
	}
	if(operation=="check")
		eval("form."+field_checks+".value = \"|\" + check_id");
	else
		eval("form."+field_checks+".value = check_id");
}
// ------------------------------------------------------------------------------------------------------


// UCFIRST:			permite setalrea primei litere mari in cazul unui text
// Parametrii: 		word - cuvantul care se modifica
// Returneaza:		textul modificat
// Uz:				modificari de text
// ------------------------------------------------------------------------------------------------------
function ucfirst(word) {
	var new_word = "";
	
	for(j=0; j < word.length; j++) {
		if(j==0) {
			new_word += word.charAt(j).toUpperCase();
		} else {
			new_word += word.charAt(j);
		}
	}
	
	return new_word;
}
// ------------------------------------------------------------------------------------------------------


// COUNT_CHARS:		numara caracterele dintr-un camp al unui formular
// Parametrii: 		form_name - numele formularului ce contine campul din care se numara caracterele
// 					field_name - numele campului din care se numara caracterele
//					max_chars - numarul maxi d caractre permise
//					div_id - id-ul divului care contine counter-ul
// Returneaza:		un alert cau modifica un div 
// Uz:				-
// ------------------------------------------------------------------------------------------------------
function count_chars(form_name, field_name, max_chars, div_id, text_alert) {
	eval("var form = document."+form_name);
	
	if(form.add_info.value.length > max_chars) {
		eval("document.getElementById('"+div_id+"').innerHTML = form."+field_name+".value.length");
		
		if(text_alert!="") {
			alert(text_alert);
		}
	} else {
		eval("document.getElementById('"+div_id+"').innerHTML = form."+field_name+".value.length");
	}
}
// ------------------------------------------------------------------------------------------------------


// ENABLE_DISABLE_FIELD:	pune un field pe disable sau enable
// Parametrii: 				form_name - numele formularului ce contine campul
// 							field_name - numele campului ptr care se face operatis
//							operation - este enable sau disable
// Returneaza:				-
// Uz:						-
// ------------------------------------------------------------------------------------------------------
function enable_disable_field(form_name, field_name, operation) {
	eval("var form = document."+form_name);
	
	if(operation=="enable") {
		eval("form."+field_name+".disabled = false");
	} else if(operation=="disable") {
		eval("form."+field_name+".disabled = true");
	}
}
// ------------------------------------------------------------------------------------------------------


// NAVIGATION:		permite navigarea back/forward intre paginile din browser
// Parametrii: 		where - in ce sens se va face navigarea: back/forward
// 					nr_pages - numarul de pagini in care se navigheaza
// Returneaza:		-
// Uz:				-
// ------------------------------------------------------------------------------------------------------
function navigation(where, nr_pages) {
	var ie, ns;
	
	if(where=="back") {
		ie = "history."+where;
		ns = "history.go";
	}
	
	if(eval(ie)) { // For IE
		eval(ie+"()");
		
	} else if(eval(ns)) { // For NS
		eval(ns+"("+nr_pages+")")
	}
}
// ------------------------------------------------------------------------------------------------------


// DETECT_BROWSER:	permite detectarea browser-ului utilizat
// Parametrii: 		-
// Returneaza:		NS - ptr Netscape/Mozilla, IE - Internet Explorer, NA - ptr browser necunoscut
// Uz:				-
// ------------------------------------------------------------------------------------------------------
function detect_browser() {
	var browsername = navigator.appName;
	
	if (browsername.indexOf("Netscape")!=-1) {
		browsername = "NS"
	} else {
		if (browsername.indexOf("Microsoft")!=-1) {
			browsername = "IE"
		} else {
			browsername = "NA"
		}
	}
	
	return browsername;
}
// ------------------------------------------------------------------------------------------------------


// grupul de functii ce implementeaza roll-over-ul unor imagini :
// ------------------------------------------------------------------------------------------------------
function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
	var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
	if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_findObj(n, d) { //v4.01
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
	d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && d.getElementById) x=d.getElementById(n); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}
// ------------------------------------------------------------------------------------------------------


// STR_REPLACE:	functie gen str_replace dion PHP - inlocuieste un substring cu un altul dintr-un text
// Parametrii: 	
// Returneaza:	TRUE - in caz de succes, FLASE
// Uz:			uneori
// ------------------------------------------------------------------------------------------------------
function str_replace(search, replace, subject) {
	var split_string = subject.split(search);
	var new_string = '';
	
	for(var i = 0; i < split_string.length; i++) {
		new_string += split_string[i] + replace;
	}
	
	return new_string.substr(0, (new_string.length - replace.length));
}
// ------------------------------------------------------------------------------------------------------


// findPosX:		gaseste pozitia div-ului in pagina
// Parametrii: 		obj - obiectul div
// Returneaza:		pozitia pe x
// ------------------------------------------------------------------------------------------------------
function findPosX(obj) {
	var curleft = 0;
	if (obj.offsetParent) {
		while (obj.offsetParent) {
			curleft += obj.offsetLeft
			obj = obj.offsetParent;
		}
	} else if(obj.x) {
		curleft += obj.x;
	}
	
	return curleft;
}
// ------------------------------------------------------------------------------------------------------


// FINDPOSY:		gaseste pozitia div-ului in pagina
// Parametrii: 		obj - obiectul div
// Returneaza:		pozitia pe y
// ------------------------------------------------------------------------------------------------------
function findPosY(obj) {
	var curtop = 0;
	if (obj.offsetParent) {
		while (obj.offsetParent) {
			curtop += obj.offsetTop
			obj = obj.offsetParent;
		}
	} else if(obj.y) {
		curtop += obj.y;
	}
	
	return curtop;
}
// ------------------------------------------------------------------------------------------------------


// GET_MOUSE:		coordonatele mouse-ului in pagina
// Parametrii: 		e - evenimentul mouse
//					pos - este x sau y
// Returneaza:		pozitia pe x sau pe y, functie de valoarea 'pos'
// ------------------------------------------------------------------------------------------------------
function get_mouse(e, pos) {
	var tempX = 0;
	var tempY = 0;
	
	if (document.all) {
		tempX = event.clientX + document.body.scrollLeft;
		tempY = event.clientY + document.body.scrollTop;
	} else {
		tempX = e.pageX;
		tempY = e.pageY;
	}

	if (tempX < 0) {
		tempX = 0;
	}
	if (tempY < 0) {
		tempY = 0;
	}
	
	return (pos == 'x') ? tempX : tempY;
}
// ------------------------------------------------------------------------------------------------------


// SHOW_TO_MOUSEPOS:	arata un div la pozitia pouse-ului
// Parametrii: 			e - evenimentul mouse
//						div_id - numele div-ului
// Returneaza:			-
// ------------------------------------------------------------------------------------------------------
function show_to_mousepos(e, div_id, offset, align) {
	var X = get_mouse(e, 'x');
	var Y = get_mouse(e, 'y');
	var div_element = document.getElementById(div_id);
	
	show_hide_element(div_id, 'show');
	
	var winSize = new WindowSize();
	
	// daca inaltimea div-ului nu se incadreaza in pagina (in cazul in care este afisat la bottom)
	// div-ul va fi afisat deasupra link-ului astfel incat sa fie in pagina :
	if(Y + offset + div_element.offsetHeight <= winSize.height) {
		div_element.style.top = (Y + offset)+"px";
	} else {
		if(Y - offset - div_element.offsetHeight < 0) {
			div_element.style.top = (Y + offset)+"px";
		} else {
			div_element.style.top = (Y - offset - div_element.offsetHeight)+"px";
		}
	}
	
	// pozitionarea la stanga / dreapta mouse-ului :
	var posX = (align == 'left') ? -div_element.offsetWidth : 0;
	
	// daca latimea div-ului nu se incadreaza in pagina (in cazul in care este afisat la draepta ecranului)
	// div-ul va fi afisat astfel incat sa fie vizibil in pagina:
	if(X + div_element.offsetWidth <= winSize.width) {
		div_element.style.left = (posX + X)+"px";
	} else {
		if(typeof(X) == 'undefined') {
			div_element.style.left = (posX + X)+"px";
		} else {
			div_element.style.left = (winSize.width - div_element.offsetWidth - offset)+"px";
		}
	}
}

function show_to_pos(e, div_id) {
	var div_element = document.getElementById(div_id);
	obj = document.getElementById('newsletterTAB');
	
	show_hide_element(div_id, 'show');
	
	var winSize = new WindowSize();
	
	posX = findPosX(obj);
	posY = findPosY(obj);
	
	div_element.style.top = (posY+30)+"px";
	div_element.style.left = (posX-120)+"px";
}
// ------------------------------------------------------------------------------------------------------


// CLASA WindowSize: extrage dimensiunile ferestrei
// ----------------------------------------------------------------------------------------------
// extrage dimensiunea de interior a ferestrei browser-ului :
function WindowSize() {
	var width, height;
	
	if(self.innerHeight) { // toate, fara Explorer
		this.width = self.innerWidth;
		this.height = self.innerHeight;
	}
	else if(document.documentElement && document.documentElement.clientHeight) { // Explorer 6
		this.width = document.documentElement.clientWidth;
		this.height = document.documentElement.clientHeight;
	}
	else if(document.body) { // alte tipuri de explorere
		this.width = document.body.clientWidth;
		this.height = document.body.clientHeight;
	}
}
// ----------------------------------------------------------------------------------------------


// LINK_REPLACE:	functie ce modifica textul unui link la apasarea acestuia
// Parametrii: 		link_id - id-ul link-ului care se modifica
//					new_text - noul text care va inlocui vechiul la actiune
//					old_text - vechiul text de la care s-a plecat
//					func_replace - numele functiei apelanta la actiune
//					div_id - id-ul div-ului asupra caruia se face actiunea
//					operation - operatia de show/hide asupra div-ului 
// Returneaza:		-
// Uz:				destul de des
// ------------------------------------------------------------------------------------------------------
function link_replace(link_id, new_text, old_text, func_replace, div_id, operation) {
	var link = document.getElementById(link_id);
	
	if(operation == 'show') {
		operation_negate = 'hide';
	} else {
		operation_negate = 'show';
	}
	
	link.innerHTML = new_text;
	link.setAttribute('href', 'javascript: '+func_replace+'(\''+link_id+'\', \''+old_text+'\', \''+new_text+'\', \''+func_replace+'\', \''+div_id+'\', \''+operation_negate+'\');');
	
	show_hide_element(div_id, operation);
}
// ------------------------------------------------------------------------------------------------------


// SET_COOKIE:	seteaza un cookie
// Parametrii: 	cookie_name - numele cookie-ului
//				cookie_value - valoare cookie-ului
//				cookie_expiredays - numarul de zile dupa care va expira
// Returneaza:	-
// Uz:			-
// ------------------------------------------------------------------------------------------------------
function set_cookie(cookie_name, cookie_value, cookie_expiredays) {
	var expdate = new Date()
	
	expdate.setDate(expdate.getDate() + cookie_expiredays);
	
	document.cookie = cookie_name+ "=" + escape(cookie_value) + 
					  ((cookie_expiredays == null) ? "" : ";expires=" + expdate);
}
// ------------------------------------------------------------------------------------------------------


// SET_COOKIE:	seteaza un cookie
// Parametrii: 	cookie_name - numele cookie-ului
//				cookie_value - valoare cookie-ului
//				cookie_expiredays - numarul de zile dupa care va expira
// Returneaza:	-
// Uz:			-
// ------------------------------------------------------------------------------------------------------
function get_cookie(cookie_name) {
	if(document.cookie.length > 0) {
		cookie_start = document.cookie.indexOf(cookie_name + "=");
		
		if(cookie_start != -1) {
			cookie_start = cookie_start + cookie_name.length + 1;
			cookie_end = document.cookie.indexOf(";", cookie_start);
			
			if(cookie_end == -1) {
				cookie_end = document.cookie.length;
			}
			
			return unescape(document.cookie.substring(cookie_start, cookie_end));
		}
	}
	return null;
}
// ------------------------------------------------------------------------------------------------------