function changeClassNameOnMouseOver(obj) {
	obj.previousClassName = obj.className;
	obj.className = "over";

	return true;
}


function restoreClassNameOnMouseOut(obj) {
	try {
		obj.className = obj.previousClassName;
	}
	catch(e) {
	}

	return true;
}








/* --------------------------------------------------
	Affiche un message de confirmation de suppression et retourne
	true ou false en conséquence.
*/
function confirmDelete(name) {
	var msg;

	if (typeof(name)=="undefined" || name==null || name=="")
		msg = "Confirmez-vous la suppression de cet élément ?";
	else
		msg = "Confirmez-vous la suppression de l'élément \""+name+"\" ?";

	return confirm(msg);
}




/* --------------------------------------------------
	Recherche un objet DHTML d'ID donné et le renvoit (ou null si inexistant)
*/
function getObj(id) {
	// on cherche dans document.all

	try {
		if (eval("typeof(document.getElementById(id))")!="undefined") {
			return document.getElementById(id);
		}
	}
	catch(e) {
	}

	// sinon on cherche dans les formulaires
	for(var i=0; i<document.forms.length; i++) {
		try {
			if (eval("typeof(document.forms[i]."+id+")")!="undefined")
				return eval("document.forms[i]."+id);
		}
		catch(e) {
		}
	}

	// sinon on cherche dans les images
	for(var i=0; i<document.images.length; i++) {
		try {
			if (eval("typeof(document.images[i]."+id+")")!="undefined")
				return eval("document.images[i]."+id);
		}
		catch(e) {
		}
	}

	// pas trouvé !!
	return null;
}



/* --------------------------------------------------
	Renvoie la valeur de la propriété .value d'un champ de nom ou id donné
	(typiquement : champ text, textarea ou hidden)
*/
function getFieldValue(id) {
	var field = getObj(id);
	if (field==null)
		return null;

	return field.value;
}

/* --------------------------------------------------
	Change la valeur de la propriété .value d'un champ de nom ou id donné
	(typiquement : champ text, textarea ou hidden)
*/
function setFieldValue(id, value) {
	var field = getObj(id);
	if (field==null)
		return;

	field.value = value;
}



/* --------------------------------------------------
	Fonction qui renvoie la taille d'un element si elle est inférieure
	à une taille donnée, ou la taille maximum sinon
*/
function normalizeElementHeight(obj, max) {
	var h = obj.scrollHeight;
	if (h > max)
	 h = max;

	return h+"px";
}


/* --------------------------------------------------
	Fonction qui renvoie un objet contenant la position (x, y) d'un objet
*/
function getDim(el){
	for (var lx=0,ly=0;el!=null;
		lx+=el.offsetLeft,ly+=el.offsetTop,el=el.offsetParent);
	return {x:lx,y:ly}
}



/* --------------------------------------------------
	Scrolle la fenêtre jusqu'à la position d'un objet
*/
function scrollWindowTo(obj) {
	try {
		window.scrollTo(0, getDim(obj).y);
	}
	catch(e) {}
}



/* --------------------------------------------------
	Scrolle la fenêtre jusqu'à la position d'un objet
*/
function scrollWindowToCenter(obj) {
	try {
		var deltaH = Math.max((document.body.clientHeight - obj.clientHeight) / 2, 0);
		window.scrollTo(0, getDim(obj).y - deltaH);
	}
	catch(e) {}
}


/* --------------------------------------------------
	Gestion des actions sur le onload du document
*/
var onLoadActions = new Array();

function addOnLoadAction(action)
{
	if (action!=null && action!="")
		onLoadActions[onLoadActions.length] = action;
}

function executeOnLoadActions()
{
	var i;
	for(i=0; i<onLoadActions.length; i++)
		eval(onLoadActions[i]);
}



/* --------------------------------------------------
	Simule un clic sur un lien
*/
function goToURL(u, targetName)
{
	if (typeof(u)=="undefined" || u==null || u=="")
		return true;

	if (u.indexOf("javascript:")==0)
	{
		var jscode = u.substring(11);
		if (eval(jscode))
			return true;
		else
			return false;
	}

	if (typeof(targetName)!="undefined" && targetName!=null){
		var w = window.open(u, targetName);
		w.focus();
  }else{
    	window.location.href=u;
   }
}



/* --------------------------------------------------
	Soumission d'un formulaire en javascript
	(avec appel du callback onsubmit)
*/
function submitForm(f) {
	var result = true;

	try {
		result = f.onsubmit();
	}
	catch(e) {
	}

	if (result)
		f.submit();

	return result;
}


/* --------------------------------------------------
	Callback appelé sur onKeyPress pour soumettre le formulaire si ENTER est tapé
*/
var isSubmitingOnEnter = false;	// pour le contournement de la soumission automatique des formulaires avec un seul champ texte
function submitOwnerFormOnEnter(obj) {
    var key = event.keyCode;

	if (key == 13) {
		isSubmitingOnEnter = true;
		var result = submitForm(obj.form);
		setTimeout("isSubmitingOnEnter=false", 200);
	}

	return true;
}

/* --------------------------------------------------
	Callback appelé sur onKeyPressed pour exécuter une action JSsi ENTER est tapé
*/
function executeOnEnter(action) {
	var key = event.keyCode;

	if (key == 13) {
		eval(action);
		return false;
	}

	return true;
}

// ne fait rien
function nop() {
}


/* --------------------------------------------------
	Va au champ du formulaire suivant (simule TAB) sur un appui sur ENTER
*/
function tabOnEnter (field, evt) {
	var keyCode = document.layers ? evt.which : document.all ?
	evt.keyCode : evt.keyCode;
	if (keyCode != 13)
		return true;
	else {
		try {
			var nextField = getNextElement(field);
			nextField.focus();
			nextField.select();
		}
		catch(e) {
		}

		return false;
	}
}

function getNextElement(field) {
	var fieldFound = false;
	var form = field.form;

	for (var e = 0; e < form.elements.length; e++) {
		if (fieldFound && form.elements[e].type != 'hidden')
			break;
		if (field == form.elements[e])
			fieldFound = true;
	}

	return form.elements[e % form.elements.length];
}



/* --------------------------------------------------
	Affiche ou cache un objet DHTML
*/
function show(obj) {
	try {
		obj.style.display="block";
	}
	catch(e) {
	}
}

function showinline(obj) {
	try {
		obj.style.display="inline";
	}
	catch(e) {
	}
}

function hide(obj) {
	try {
		obj.style.display="none";
	}
	catch(e) {
	}
}


/* --------------------------------------------------
	Met le focus et sélectionne le contenu d'un champ (si possible)
*/
function focusAndSelect(obj) {
	try {
		obj.focus();
	}
	catch(e) {}

	try {
		obj.select();
	}
	catch(e) {}
}


/* --------------------------------------------------
	Simule un clic sur un lien d'ID donné
	=> exécution du "onclick" sur ce lien
	=> exécution de l'URL du lien
*/
function clickLink(linkId) {
	var linkObj = getObj(linkId);
	if (linkObj==null) {
		alert("Le lien d'ID '"+linkId+"' n'existe pas !");
		return;
	}

	var res = true;
	try {
		res = linkObj.onclick();
	}
	catch(e) {
	}

	try {
		if (res)
			goToURL(linkObj.href);
	}
	catch(e) {
	}
}


/* --------------------------------------------------
	Soumet un formulaire en utilisant l'href d'un lien comme action.
*/
function useLinkForSubmit(f, linkObj) {
	f.action = linkObj.href;
	return submitForm(f);
}

////////////////////////////////////////////////////////////////////////////////////
function openCenteredWindow(url, name, w, h, notResizable)
{
	var features = ",directories=no,location=no,status=no,toolbar=no,scrollbars=yes";
	if (notResizable)
		features += ",resizable=no";
	else
		features += ",resizable=yes";
	var w = window.open(url, name, getCenteringWinPos(w,h)+features, true);
	w.focus();
	return w;
}

function getCenteringWinPos(w,h){
    var sW = parseInt(screen.availWidth, 10);
    var sH = parseInt(screen.availHeight, 10);
    if (sW / sH > 2)    // si double ecran
        sW = Math.round(sW/2);

    var x = Math.round((sW - w)/2);
    var y = Math.round((sH - h)/2);

    return "width="+w+",height="+h+",top="+y+",left="+x;
}


/* --------------------------------------------------
	Simule le comportement d'une fenêtre modale à partir d'une fenêtre
	"fille".

	childWindow : objet fenêtre fille
	onCloseExpression : expression javascript facultative à évaluer lorsque la fenêtre pseudo-modale sera fermée.
*/
var forceFocusWindow = null;
var simulateModalOnCloseExpression = null;

function simulateModalBehavior(childWindow, onCloseExpression) {
	try {
		forceFocusWindow = childWindow;
		simulateModalOnCloseExpression = onCloseExpression;

		window.onfocus=focusChildModal;
		forceFocusUntilClosed();
	}
	catch(e)  {
	}
}

function forceFocusUntilClosed() {
	try {
		if (typeof(forceFocusWindow)=="undefined" || forceFocusWindow==null)
			return;

		if (forceFocusWindow.closed) {
			forceFocusWindow=null;
			window.onfocus=null;
			window.focus();

			// éxécution du callback éventuel sur fermeture
			if (typeof(simulateModalOnCloseExpression)!="undefined" && simulateModalOnCloseExpression!=null && simulateModalOnCloseExpression!="") {
				eval(simulateModalOnCloseExpression);
				simulateModalOnCloseExpression = null;
			}
			return;
		}

		setTimeout("forceFocusUntilClosed();", 300);
	}
	catch(e) {
		forceFocusWindow=null;
	}
}

function focusChildModal() {
	try {
		if (typeof(forceFocusWindow)=="undefined" || forceFocusWindow==null || forceFocusWindow.closed)
			return;

		forceFocusWindow.focus();
		setTimeout("forceFocusWindow.focus();",50);
	}
	catch(e) {}

	return false;
}



/* --------------------------------------------------
	Fonction qui renvoie vrai si une checkbox existe ET qu'elle est cochée, sinon retourne la valeur par défaut
*/
function isCheckBoxChecked(cbID, defaultValue) {
	try {
		return getObj(cbID).checked;
	}
	catch(e) {
		return defaultValue;
	}
}

/* --------------------------------------------------
	Renvoie la liste des valeurs des checkboxes sélectionnés
*/
function getCheckedBoxesValues(cbObj) {
	if (typeof(cbObj.length)=="undefined") {
		// checkbox seule
		if (cbObj.checked)
			return [ cbObj.value ];
		else
			return [];
	}
	else {
		// groupe de checkbox
		var res = new Array();
		for(var i=0; i<cbObj.length; i++) {
			if (cbObj[i].checked)
				res[res.length] = cbObj[i].value;
		}
		return res;
	}
}

/* --------------------------------------------------
	Renvoie la valeur d'un radio, ou null si aucun bouton radio n'est sélectionné
*/
function getRadioValue(radioButtonOrGroup) {
  var value = null;
  if (radioButtonOrGroup.length) { // group
    for (var b = 0; b < radioButtonOrGroup.length; b++)
      if (radioButtonOrGroup[b].checked)
        value = radioButtonOrGroup[b].value;
  }
  else if (radioButtonOrGroup.checked)
    value = radioButtonOrGroup.value;
  return value;
}


/* --------------------------------------------------
	Renvoie la valeur de l'option sélectionnée d'un select simple
*/
function getSelectValue(id) {
	var field = getObj(id);
	if (field==null)
		return null;

	return field.options[field.selectedIndex].value;
}

/* --------------------------------------------------
	Renvoie l'option sélectionnée d'un select simple
*/
function getSelectSelectedOption(id) {
	var field = getObj(id);
	if (field==null)
		return null;

	return field.options[field.selectedIndex];
}




/* --------------------------------------------------
	Active le bouton radio de valeur donnée
*/
function setRadioValue(radioButtonOrGroup, value) {
  if (radioButtonOrGroup.length) { // group
    for (var b = 0; b < radioButtonOrGroup.length; b++)
      radioButtonOrGroup[b].checked = (radioButtonOrGroup[b].value == value)
  }
  else
    radioButtonOrGroup.checked = (radioButtonOrGroup.value == value);
}


/* --------------------------------------------------
	Population automatique des propriétés d'un objet
*/
function addProps(obj, data, names, addNull) {
	for (var i = 0; i < names.length; i++) if(i < data.length || addNull) obj[names[i]] = data[i];
}


// --- fonction utilisée par IncrDecrButtons pour incrémenter un champ
function incrField(id, step, min, max, round) {
	var field = getObj(id);
	var v = 0;

	try {
		v = parseFloat(field.value);
		v += step;
	}
	catch(e) {}

	if (isNaN(v))
		v = 0;

	if (typeof(min)!="undefined" && min!="NONE")
		v = Math.max(min, v);

	if (typeof(max)!="undefined" && max!="NONE")
		v = Math.min(max, v);

	var vs = v+"";

	if (typeof(round)!="undefined" && round!="NONE") {
		var k = Math.pow(10, round);
		v = Math.round(v * k) / k;

		if (round > 0) {
			var pos = vs.indexOf(".");
			if (pos<0) {
				pos = vs.length;
				vs+=".";
			}
			if (pos==0) {
				vs="0"+v;
				pos++;
			}
			var nbAfterDot = vs.length - pos - 1;
			for(var i=0; i<round-nbAfterDot; i++)
				vs+="0";
		}
	}

	field.value = vs;
}

// --- fonction utilisée par IncrDecrButtons pour décrémenter un champ
function decrField(id, step, min, max, round) {
	incrField(id, -step, min, max, round);
}





/* --------------------------------------------------
	Fonction qui renvoie vrai si une checkbox existe ET qu'elle est cochée, sinon retourne la valeur par défaut
*/
function isCheckBoxValueChecked(cbObj, value) {
	try {
		if (typeof(cbObj.length)=="undefined") {
			// checkbox seule
			return (cbObj.value==value && cbObj.checked);
		}
		else {
			// on parcourt le groupe de checkboxes
			for(var i=0; i<cbObj.length; i++) {
				if (cbObj.value==value && cbObj.checked)
					return true;
			}
			return false;
		}

	}
	catch(e) {
		return false;
	}
}

/* --------------------------------------------------
	Renvoie la liste des valeurs des checkboxes sélectionnés
*/
function getCheckedBoxesValues(cbObj) {
	if (typeof(cbObj.length)=="undefined") {
		// checkbox seule
		if (cbObj.checked)
			return [ cbObj.value ];
		else
			return [];
	}
	else {
		// groupe de checkbox
		var res = new Array();
		for(var i=0; i<cbObj.length; i++) {
			if (cbObj[i].checked)
				res[res.length] = cbObj[i].value;
		}
		return res;
	}
}

/* --------------------------------------------------
	Renvoie la valeur d'un radio, ou null si aucun bouton radio n'est sélectionné
*/
function getRadioValue(radioButtonOrGroup) {
  var value = null;
  if (radioButtonOrGroup.length) { // group
    for (var b = 0; b < radioButtonOrGroup.length; b++)
      if (radioButtonOrGroup[b].checked)
        value = radioButtonOrGroup[b].value;
  }
  else if (radioButtonOrGroup.checked)
    value = radioButtonOrGroup.value;
  return value;
}




/* --------------------------------------------------
	Active le bouton radio de valeur donnée
*/
function setRadioValue(radioButtonOrGroup, value) {
  if (radioButtonOrGroup.length) { // group
    for (var b = 0; b < radioButtonOrGroup.length; b++)
      radioButtonOrGroup[b].checked = (radioButtonOrGroup[b].value == value)
  }
  else
    radioButtonOrGroup.checked = (radioButtonOrGroup.value == value);
}



/* --------------------------------------------------
	Ajoute un champ à un formulaire
*/
function addField (form, fieldType, fieldName, fieldValue) {
  if (document.getElementById) {
    var input = document.createElement('INPUT');
      if (document.all) { // what follows should work
                          // with NN6 but doesn't in M14
        input.type = fieldType;
        input.name = fieldName;
        input.value = fieldValue;
      }
      else if (document.getElementById) { // so here is the
                                          // NN6 workaround
        input.setAttribute('type', fieldType);
        input.setAttribute('name', fieldName);
        input.setAttribute('value', fieldValue);
      }
    form.appendChild(input);
  }
}

/* --------------------------------------------------
	Récupère un champ d'un formulaire
*/
function getField (form, fieldName) {
  if (!document.all)
    return form[fieldName];
  else  // IE has a bug not adding dynamically created field
        // as named properties so we loop through the elements array
    for (var e = 0; e < form.elements.length; e++)
      if (form.elements[e].name == fieldName)
        return form.elements[e];
  return null;
}

/* --------------------------------------------------
	Supprime un champ d'un formulaire
*/
function removeField (form, fieldName) {
  var field = getField (form, fieldName);
  if (field && !field.length)
    field.parentNode.removeChild(field);
}


/* ----------------------------------------------------------------------
 * Affiche une popup de choix de date
 * Paramètres :
 * 		- field : objet de formulaire (champ texte ou hidden) à renseigner
 * 		- anchorname : nom de l'ancre <a> associé au bouton d'ouverture de la popup (utilisé pour positionner la popup)
 * 		- format : (facultatif) format de la date (par défaut : dd/MM/yyyy)
 * 		- disabledWeekDays : (facultatif) jours de la semaine désactivés (tableau d'entier entre 0 et 6)
 * 		- disabledDates : (facultatif) périodes désactivées (tableau d'agrégats { start=Date(), end=Date() }
 */

function showCalendar(field, anchorname, format, disabledWeekDays, disabledDates, selectedDate) {
	var calendar = new CalendarPopup();
	calendar.setMonthNames('Janvier','F\xe9vrier','Mars','Avril','Mai','Juin','Juillet','Ao\xfbt','Septembre','Octobre','Novembre','D\xe9cembre');
	calendar.setDayHeaders('D','L','M','M','J','V','S');
	calendar.setWeekStartDay(1);
	calendar.setTodayText("Aujourd'hui");
	calendar.showYearNavigation();

	if (typeof(anchorname)=="undefined")
		anchorname=null;

	if (typeof(format)=="undefined" || format==null || format=="")
		format="dd/MM/yyyy";

	if (typeof(disabledWeekDays)!="undefined" && disabledWeekDays!=null && disabledWeekDays.length>0) {
		// jours de la semaine désactivés (tableau d'entier entre 0 et 6)
		var instr="calendar.setDisabledWeekDays(";
		for(var i=0; i<disabledWeekDays.length; i++) {
			if (i>0)
				instr+=",";
			instr += disabledWeekDays[i];
		}
		instr+=")";
		eval(instr);
	}

	if (typeof(disabledDates)!="undefined" && disabledDates!=null) {
		// périodes désactivées (tableau d'agrégats { start=Date(), end=Date() }
		for(var i=0; i<disabledDates.length; i++)
			calendar.addDisabledDates(disabledDates[i].start, disabledDates[i].end);
	}

	calendar.select(field, anchorname, format, selectedDate);
}

/*
 * Soumet un formulaire d'id donné avec pour action l'url (href) d'un lien d'id donné
 */
function submitFormWithLinkURLByIds(formId, linkId) {
	var f = getObj(formId);
	var lnk = getObj(linkId);
	return submitFormWithLinkURL(f, lnk);
}

/*
 * Soumet un formulaire d'id donné avec pour action l'url (href) d'un lien d'id donné
 */
function submitFormWithLinkURL(f, lnk) {
	f.action=lnk.href;
	submitForm(f);
	return false;
}




///////////////////////////////////////////////////

function displayWaitMessage(htmlContent, imgURL)
{
	var html = '<table border="0" cellspacing="10" cellpadding="0"><tr><td align="center" class="waitMessageText">';
	if (imgURL)
		html += '<img src="'+imgURL+'" alt=""></td><td align="center" class="waitMessageText">';
	html += htmlContent;
	html += '</td></tr></div>';

	var obj = document.all["DynamicWaitMsg"];
	if (obj) {
		obj.innerHTML = html;
	}
	else
		document.body.insertAdjacentHTML('beforeEnd', '<div id="DynamicWaitMsg" class="waitMessageZone" style="position:absolute;z-index:30000; visibility:hidden;">'+html+'</div>');

	var obj = document.all["DynamicWaitMsg"];
	centerLayer(obj);
	obj.style.visibility = "visible";
}


var URLSABLIER = 'images/deco/sablier.gif';
var isCurrentlySubmitting = false;

function hideWaitMessage()
{
	isCurrentlySubmitting = false;
	var obj = document.all["DynamicWaitMsg"];
	if (obj) {
		obj.style.visibility = "hidden";
	}
}

function displayWaitOnSubmit() {
	if (isCurrentlySubmitting) {
		// si déjà en train de soumettre => on ne fait rien
		if (!isSubmitingOnEnter)
			alert("Traitement en cours ! Veuillez patienter...");
		// sinon pas de message d'erreur

		return false;
	}
	isCurrentlySubmitting = true;
	displayWaitMessage("Traitement en cours...<br>Veuillez patienter...", URLSABLIER);
	return true;
}


///////////////////////////////////////////////////
function centerLayer(obj)
{
	if (typeof(obj)=="undefined" || obj==null)
		return;

	var x = Math.round((document.body.clientWidth - obj.offsetWidth) / 2 + document.body.scrollLeft);
	var y = Math.round((document.body.clientHeight - obj.offsetHeight) / 2 + document.body.scrollTop);

	obj.style.left = x;
	obj.style.top = y;
}

///////////////////////////////////////////////////
function toDo() {
	alert("Fonctionnalité pas encore mise en place !");
}

/* ----------------------------- */
function selectOptionByValue(field, value) {
	for(var i=0; i<field.options.length; i++) {
		if (field.options[i].value==value) {
			field.selectedIndex = i;
			break;
		}
	}
}



///////////////////////////////////////////////////

var ONEDAY = 1000 * 60 * 60 * 24;

function popupChoixDateDebut(fieldDebut, fieldFin, anchorName) {
	verifieFormatDate(fieldDebut);
	verifieFormatDate(fieldFin);

	var disabledDates;

	var dateFin = fieldFin.value;
	if (dateFin=="")
		dateFin=null;
	else {
		var dFin = parseDate(dateFin);
		if (dFin!=null) {
			// calcul du lendemain de la date de fin actuelle (pour l'exclusion)
			var t = dFin.getTime() + ONEDAY;
			dateFin = formatDate(new Date(t), "dd/MM/yyyy");

			disabledDates = new Array();
			disabledDates[0] = { start:dateFin, end:null };
		}
	}

	// on propose la date de fin si pas encore de date de début
	var selectedDate = null;
	if (fieldDebut.value==null || fieldDebut.value=="")
		selectedDate = fieldFin.value;

	showCalendar(fieldDebut, anchorName, null, null, disabledDates, selectedDate);
}


function popupChoixDateFin(fieldDebut, fieldFin, anchorName) {
	verifieFormatDate(fieldDebut);
	verifieFormatDate(fieldFin);

	var disabledDates;

	var dateDebut = fieldDebut.value;
	if (dateDebut=="")
		dateDebut=null;
	else {
		var dDebut = parseDate(dateDebut);
		if (dDebut!=null) {
			// calcul de la veille de la date début actuelle (pour l'exclusion)
			var t = dDebut.getTime() - ONEDAY;
			dateDebut = formatDate(new Date(t), "dd/MM/yyyy");

			disabledDates = new Array();
			disabledDates[0] = { start:null, end:dateDebut };
		}
	}

	// on propose la date de fin si pas encore de date de début
	var selectedDate = null;
	if (fieldFin.value==null || fieldFin.value=="")
		selectedDate = fieldDebut.value;

	showCalendar(fieldFin, anchorName, null, null, disabledDates, selectedDate);
}


function verifieOrdreDates(fieldDebut, fieldFin) {
//	try {
		verifieFormatDate(fieldDebut);
		verifieFormatDate(fieldFin);

		var dDebut = parseDate(fieldDebut.value);
		var dFin = parseDate(fieldFin.value);

		if (dDebut!=null && dFin!=null && dDebut.getTime()>dFin.getTime() ) {
			if (!confirm("La date de début est postérieure à la date de fin !\nLes dates vont être permutées.\nSouhaitez-vous les permuter ?"))
				return true;

			var temp = fieldDebut.value;
			fieldDebut.value = fieldFin.value;
			fieldFin.value = temp;
			return false;
		}
/*	}
	catch(e) {
	}
*/
	return true;
}

/*
 * Vérifie que la date d'un champ est au format jj/mm/aaaa, la met dans ce format si possible
 * sinon met la chaine à vide.
 */
function verifieFormatDate(field) {
	var d = parseDate(field.value);
	field.value = (d==null) ? field.value : formatDate(d, "dd/MM/yyyy");
	return true;
}



/* ----------------------------------------------------
	Retaille un image à une taille maximum
*/
var imgAutoId = 0;
function autoResizeIfBigger(img, maxW, maxH) {
	var w = img.width;
	var h = img.height;

	if (w==0 && h==0) {
		if (typeof(img.id)=="undefined" || img.id==null || img.id=="") {
			imgAutoId++;
			img.id = "RSIMG"+imgAutoId;
		}
		
		setTimeout("autoResizeIfBigger(getObj('"+img.id+"'),"+maxW+","+maxH+")", 1250);
		return true;
	}
	
	if (w > maxW) {
		h = h*(maxW/w);
		w = maxW;	
	}

	if (h > maxH) {
		w = w*(maxH/h);
		h = maxH;	
	}

	img.width = Math.round(w);
	img.height = Math.round(h);
	
	if (typeof(img.style.visibility)!="undefined")
		img.style.visibility="visible";
	
	return true;
}