/**
* Fichier contenant des fonctions utiles
* auteur : T. Vibes
* copyright Onyme 2008
***/

/**
* Enlève les espaces à gauche de la chaine
* @param str
* 		Chaîne à traiter
* @return
*	La chaîne traitée
**/
function LTrim(str){
  if (str==null){
    return null;
  }
  for(var i=0;str.charAt(i)==" ";i++);
  return str.substring(i,str.length);
}

/**
* Enlève les espaces à droite de la chaine
* @param str
* 		Chaîne à traiter
* @return
*	La chaîne traitée	
**/
function RTrim(str){
  if (str==null){
    return null;
  }
  for(var i=str.length-1;str.charAt(i)==" ";i--);
  return str.substring(0,i+1);
}


/**
* Enlève les espaces à gauche et à droite de la chaîne
* @param str
* 		Chaîne à traiter
* @return
*	La chaîne traitée	
**/
function Trim(str){  return LTrim(RTrim(str));}


//renvoie la position gauche absolue de l'objet
function getAbsoluteLeft(objectId) {
	// Get an object left position from the upper left viewport corner
	// Tested with relative and nested objects
	o = document.getElementById(objectId)
	return getObjectAbsoluteLeft(o);
}

//renvoie la position gauche absolue de l'objet
function getObjectAbsoluteLeft(o) {
	var tmp = o;
	// Get an object left position from the upper left viewport corner
	// Tested with relative and nested objects
	oLeft = o.offsetLeft            // Get left position from the parent object
	while(o.offsetParent!=null) {   // Parse the parent hierarchy up to the document element
		oParent = o.offsetParent    // Get parent object reference
		oLeft += oParent.offsetLeft // Add parent left position
		o = oParent
	}
	o = tmp;
	var scrollL = 0;
	while(o.parentNode!=null){
		if(o.parentNode.scrollLeft!=null && o.parentNode.scrollLeft >0)
			scrollL += o.parentNode.scrollLeft;
		o = o.parentNode;
	}

	// Return left postion
	return (oLeft - scrollL)
}

//renvoie la position haute absolue
function getAbsoluteTop(objectId) {
	// Get an object top position from the upper top viewport corner
	// Tested with relative and nested objects
	o = document.getElementById(objectId)
	return getObjectAbsoluteTop(o);
}

/*
* renvoie la position haute absolue
* Modifiée : T.Vibes
*	Le script original ne prévoyait pas qu'un objet pouvait se trouver dans un conteneur "scrollable"
*	ce qui fausse la valeur offsetTop (qui ne tient pas compte de la partie "cachée" du conteneur par scroll)
*/
function getObjectAbsoluteTop(o) {
	var tmp = o;
	if(o!=null){		
	
		oTop = o.offsetTop	
		// Get Top position from the parent object       			
		while(o.offsetParent!=null) {   // Parse the parent hierarchy up to the document element
			oParent = o.offsetParent;    // Get parent object reference						
		    oTop += oParent.offsetTop;
			o = oParent
		}
		o = tmp;
		var scrollT = 0;
		while(o.parentNode!=null){
			if(o.parentNode.scrollTop!=null && o.parentNode.scrollTop >0)
				scrollT += o.parentNode.scrollTop;
			o = o.parentNode;
		}
	}
		
	// Return top postion	
	return (oTop - scrollT)
}  

/**
 * Renvoie la position X de la souris pour l'évènement passé en param
 * @param e
 * 		Evenement javascript
 * @return
 * 		La position X de la souris
 */
function getMouseX(e) {
	var posx = 0;	
	if (!e) var e = window.event;
	if (e.pageX || e.pageY) 	{
		posx = e.pageX;
	}
	else if (e.clientX) 	{
		posx = e.clientX + document.body.scrollLeft
			+ document.documentElement.scrollLeft;
	}
	return posx;
}

/**
* Renvoie la position Y de la souris pour l'évènement passé en param
* @param e
* 		Evenement javascript
* @return
* 		La position Y de la souris
*/
function getMouseY(e) {	
	var posy = 0;
	if (!e) var e = window.event;
	
	if (e.pageY) 	{		
		posy = e.pageY;
	}
	else if (e.clientY) 	{
		posy = e.clientY + document.body.scrollTop
			+ document.documentElement.scrollTop;
	}
	return posy;
}


function IsEmpty(aTextField) {
   if (aTextField.value==null) return true;
   else if (Trim(aTextField.value)=="")  return true;
   else return false;
}

/**
* Teste si la chaîne est un nombre
* @param chaine
* 		chaine de caractère
* @return
*	VRAI si la chaîne est un nombre (peut être parsée), FAUX sinon
**/
function isNumerique(chaine) {
    var exp= new RegExp("^[0-9]{1,}\.?[0-9]{0,2}$","g");
    if (chaine!=null && chaine!="") return exp.test(chaine);
    else return false;
}

/**
* Fonction qui remplace le 'motif' par la chaîne 'replacement' dans 'str'. Attention
* la fonction ne fonctionne pas comme en java et on ne peut pas (encore) passer d'expression
* régulière pour le paramètre motif.
*
* @param str
* 	chaîne dans laquelle on va faire les remplacement
* @param motif
*	motif à remplacer
* @param replacement
*	chaîne de remplacement
* @return
*	La chaîne modifiée
**/
function replaceAll(str, motif, replacement){
	var motif_length=motif.length;
	var left_hand=null;
	var right_hand = null;
	if(str.indexOf(motif)!=-1){
		left_hand = str.substring(0,str.indexOf(motif));
		right_hand = replaceAll(str.substring(str.indexOf(motif) + motif_length),motif,replacement);
		return left_hand + replacement + right_hand;
	}else
		return str;
	
}

/**
* Renvoie l'élément source sur lequel l'évènement s'est produit. Comme la syntaxe est différente selon les navigateurs
* on a créée cette méthode pour simplifier le code
* @param event
* 	Objet Event
* @return
*	Un élément DOM
*/
function getSource(e){
	if (window.event) {
      return window.event.srcElement;
    } else if (e) {
      return e.target;
    } else return;
}


/**
 * ajoute un événement à un élément
 * 
 * @param
 * 		obj l'elément qu'on veut lui ajouter un événement. par exemple <code>div</code>
 * @param
 * 		type type de l'événement. par exemple <code>click</code>, <code>mouseover</code>, <code>submit</code>
 * @param	
 * 		fn la fonction qui gérér l'evenement
 * 
 * exemple :
 * 		addEvent( document.getElementById('foo'), 'click', doSomething );
 *	    addEvent( obj, 'mouseover', function(){ alert('hello!'); } );  
 */
function addEvent( obj, type, fn ) {
	 if(fn!=null){
		  if ( obj.attachEvent ) {
		    obj['e'+type+fn] = fn;
		    obj[type+fn] = function(){obj['e'+type+fn]( window.event );}
		    obj.attachEvent( 'on'+type, obj[type+fn] );
		  } else
		    obj.addEventListener( type, fn, false );
	 }
}

/**
 * supprime un événement d'un élément
 * 
 * @see	addEvent() 		 
 */
function removeEvent( obj, type, fn ) {	
  if ( obj.detachEvent ) {
    obj.detachEvent( 'on'+type, obj[type+fn] );
    obj[type+fn] = null;
  } else  	
    obj.removeEventListener( type, fn, false );
}
 
/**
 * Cette fonction stop le bubbling des evenements
 * @param e l'evenement fournit
 */
function stopBubble(e) {
     // If an event object is provided, then this is a non-IE browser
     if ( e && e.stopPropagation )
          // and therefore it supports the W3C stopPropagation() method
          e.stopPropagation();
     else
          // Otherwise, we need to use the Internet Explorer
          // way of cancelling event bubbling
          window.event.cancelBubble = true;
}

/**
 * Renvoie le père ou l'ancetre d'un élément.
 * par exemple si l'élément à un parent div
 * 
 * @param element l'element qu'on veut lui trouvé son parent. Obligatoire
 * @param nomParent le père ou l'ancêtre(nom de balise) de l'élément à trouvé.
 * 		  Si l'élément n'a pas de parent ou ancêtre qui correspond à nomParent alors
 * 		  on renvoie html. Optionnel
 * @return le père ou l'ancêtre de element
 * 				 	
 */
function getParentNode(element, nomParent){
	
	var parent = element.parentNode;		
	
	if(arguments.length != 2)
		return parent;		
				
	if (parent == null)	
		return null;
	else if(parent.nodeName.toLowerCase() == nomParent.toLowerCase())	
		return parent;
	else if(parent.nodeName.toLowerCase() == "html")
		return parent;	
	else		
		return	getParentNode(parent,nomParent);	
		
}

/**
 * Renvoie un élément qui a un attribut id. 
 * (raccourci de document.getElementById) 
 * @param name l'id
 * @return l'element qui à cet id
 */
function id(name) {	
    return document.getElementById(name);
}

/**
 * 
 */
function next( elem ) {
    do {
         elem = elem.nextSibling;
    } while ( elem && elem.nodeType != 1 );
    return elem;
}


/**
 * 
 */
function prev( elem ) {
    do {
         elem = elem.previousSibling;
    } while ( elem && elem.nodeType != 1 );
    return elem;
}

/**
 * 
 * Renvoie un tableau d'éléments qui contient l'attribute classe spécifié
 * @param 
 * 		name le nom de la classe. paramètre obligatoire
 * @param
 * 		type le type de l'élément. paramètre optionnel	
 * @param
 * 		ele si ce paramètre est spécifié alors on revoie ses éléments fils qui ont pour className=name, 
 * 			sinon on renvoie les éléments de tout le document. paramètre optionnel
 */
function hasClass(name,type,ele) {	
  var r = [];
  // Locate the class name (allows for multiple class names)
  var re = new RegExp("(^|\\s)" + name + "(\\s|$)");    
  // Limit search by type, or look through all elements
  if(ele)  
  	var e = ele.getElementsByTagName(type || "*");
  else   	
  	var e = document.getElementsByTagName(type || "*");      	
  for ( var j = 0; j < e.length; j++ )
   // If the element has the class, add it for return
      if ( re.test(e[j].className) ) r.push( e[j] );  
  // Return the list of matched elements  
  return r;
  
}

/**
 *  Get a style property (name) of a specific element (elem)
 */
function getStyle( elem, name ) {
    // If the property exists in style[], then it's been set
    // recently (and is current)
    if (elem.style[name])
        return elem.style[name];
    // Otherwise, try to use IE's method
    else if (elem.currentStyle)
        return elem.currentStyle[name];
    // Or the W3C's method, if it exists
    else if (document.defaultView && document.defaultView.getComputedStyle) {
        // It uses the traditional 'text-align' style of rule writing,
        // instead of textAlign
        name = name.replace(/([A-Z])/g,"-$1");
        name = name.toLowerCase();
        // Get the style object and get the value of the property (if it exists)
        var s = document.defaultView.getComputedStyle(elem,"");
        return s && s.getPropertyValue(name);
    // Otherwise, we're using some other browser
    } else
        return null;
}

function checkEmail( elem ) {
	return elem.value == '' ||
		/^[a-z0-9_+.-]+\@([a-z0-9-]+\.)+[a-z0-9]{2,4}$/i.test( elem.value );
}