/* ----------------------------------------------------------------------------------------------------------------------------------------------	*/
/* 				Fonctions du calendriers							*/
/* ----------------------------------------------------------------------------------------------------------------------------------------------*/

var objcalendar;
var colorCalendarCurrent = "#FCAD86";		//Couleur de fond de la cellule de la date active
var colorCalendarOtherMonth = "#C79E75";	//Couleur du texte des jours d'un autre mois
var colorCalendarBorderWeek = "#EE5B00";	//Couleur de la bordure du tableau des semaines
var colorCalendarTextHeader = "#A94100";	//Couleur du texte des en-têtes si mouseover

var Format_Date = "jj/mm/aaaa";
function event_Date (e)  {
	var myEvent = e || window.event;
	obj = myEvent.target || myEvent.srcElement;
	if (myEvent.type == "focus" && obj.value == Format_Date)  obj.value = "";
	else if (myEvent.type == "blur" && obj.value == "")  obj.value =  Format_Date;
}

// Création d'un tableau contenant les jours de la semaine
//var tabjour=new Array("Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi");
// Création d'un tableau contenant les mois
//var tabmois=new Array("Janvier","Février","Mars","Avril","Mai","Juin","Juillet", "Août","Septembre","Octobre","Novembre","Décembre");

// Fonction permettant de créer un calendrier DHTML. Celle fonction gère aussi l'affichage et les comportements du calendrier. 
// Elle est déclenchée lorsque l'utilisateur utilise le clic droit de la souris au-dessus d'une zone de texte configurée comme étant une date
function Show_Calendar (e, objclick) {

	if (typeof(tabjour) == "undefined") 
	{	
		switch(jslanguageIso) {
			case 'en':
				tabjour=new Array("Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday");
				tabmois=new Array("January","February","March","April","May","June","July","August","September","October","November","December");
				break;
			default:
				tabjour=new Array("Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi");
				tabmois=new Array("Janvier","Février","Mars","Avril","Mai","Juin","Juillet", "Août","Septembre","Octobre","Novembre","Décembre");
				break;
		}
	}

	var myEvent = e || window.event;
	if (typeof(objclick) == "undefined") objclick = myEvent.target || myEvent.srcElement;
	else if (typeof(objclick) == "string") objclick = $(objclick);
	// Le le calendrier n'a encore jamais été créé, il doit d'abord être créé
	if ($('CalendarLayer') == null)
	{
		// L'objet de base du calendrier est une couche
		objcalendar = document.createElement("DIV");		
		objcalendar.id = 'CalendarLayer';				// L'identifiant de la couche du calendrier est CalendarLayer
		document.body.appendChild(objcalendar);			// Le calendrier est ajouté dans le corps de la page HTML
				
		// Le calendrier a 3 modes d'affichage : 
		//	- Affichage des jours du mois (par défaut)
		//	- Affichage des mois de l'année
		//	- Affichage des années sur une période de 20 ans.
		// Ces 3 modes d'affichage permetent de saisir rapidement une date même éloignée en moins de 10 clics de souris
		
		// Le tableau principal du calendrier qui affichera des données différentes en fonction du mode d'affichage est crée 
		objcalendar.TabJour = document.createElement("TABLE");
		objcalendar.TabJour.id = 'TabCalendarLayer';
		objcalendar.TabJour.border = 0;			// Ce tableau n'aura pas de bordure tout autour
		objcalendar.TabJour.cellPadding = 0;			// Pas de marge intérieure
		objcalendar.TabJour.cellSpacing = 0;			// Par d'espace entre les cellules
		objcalendar.TabJour.className = "TextCalendar";	// La classe TextCalendar est utilisée pour afficher les données
		//Le tableau est inséré dans la calendrier
		objcalendar.appendChild(objcalendar.TabJour);	
		// Ils est placé à 10 pixels du bord gauche du calendrier, à 20 pixels du haut et fera 130 pixels de large
		
		//addEvent(objcalendar, "click", Event_on_Calendar)
		
		// La hauteur du calendrier devra faire au moins 130 pixels mais s'adaptera à la hauteur du tableau de données en lui laissant un marge de 10 pixels en bas
		objcalendar.adjustHeight = function () {
				this.style.height = Math.max(130,20 + objcalendar.TabJour.offsetHeight + 10) + "px";
		}

		// Ajout d'une fonction Close à l'objet calendrier. L'appel de cette fonction fermera le calendrier
		objcalendar.Close = function(){
			this.style.visibility = "hidden";	// Le calendrier devient invisible
			this.DeleteTable();			// Les données contenues dans le tableau d'affichage sont supprimées afin de réduire la taille du calendrier
			this.style.top = "0px";		// Le calendrier est placé en haut de la page
			this.style.left = "0px";	// Le calendrier est placé à gauche de la page
		}	
				
		// Ajout d'une fonction DeleteTable à l'objet calendrier. L'appel de cette fonction supprime toutes les lignes contenues dans le tableau de données (jours, mois ou années)
		objcalendar.DeleteTable = function(){
			// Boucle tant que le tableau possède encore au moins une ligne
			/*while (objcalendar.TabJour.rows.length > 0)
			{		
				objcalendar.TabJour.deleteRow();	// Suppression d'une ligne du tableau	
			}*/
			var table = document.getElementById('TabCalendarLayer');
			while(table.hasChildNodes())
			{
				table.removeChild(table.firstChild);
			}
		}	
				
		// Ajout d'une fonction GenereJours à l'objet calendrier. L'appel de cette fonction permet d'afficher tous les jours du mois choisi par l'utilisateur.
		// Tous les jours des semaines qui contiennent au moins un jour du mois sont affichés mais les jours qui ne font pas partie du mois choisi auront une couleur différente
		objcalendar.GenereJours = function(){
						
			// La calendrier est passé en mode Days (Jours)
			objcalendar.Mode = "Days";
			
			// Suppression des données existantes dans le tableau
			this.DeleteTable();
	
			// Création d'une variable date initiale au premier jour du mois
			var dDate = new Date(this.currentYear ,this.currentMonth ,1);

			// La cellule indiquant à l'utilisateur quel mois est affiché est mise à jour
			this.CellMonth.innerHTML = tabmois[this.currentMonth]
			// La cellule indiquant à l'utilisateur quelle année est affichée est mise à jour
			this.CellYear.innerHTML = this.currentYear;
			
			// Ajout d'une première ligne dans le tableau pour afficher les jours de la semaine
			var row = this.TabJour.insertRow(-1);
			row.align="center";	// Les jours de la semaine sont centrés
			
			if (objcalendar.lDisplayWeekColumn)
			{
				var cell = row.insertCell(-1);		
				// Le texte de la cellule contient la première lettre du jour de la semaine
				cell.innerHTML = ((jslanguageIso == "en")?"Week":"Sem");
				cell.onclick = this.GenereSemaine;
				// Une bordure bleu clair est affiché en bas de cette cellule. Cela représentera une ligne séparatrice entre les jours de la semaine et les jours du mois
				cell.className = "CalendarTopWeek";
			}			
				
			// Boucle sur le tableau Javascript des jours de la semaine
			for (var i=0; i<this.tabjour.length;i++)
			{
				// Ajout d'une cellule pour chaque jour de la semaine
				var cell = row.insertCell(-1);		
				// Le texte de la cellule contient la première lettre du jour de la semaine
				cell.innerHTML = this.tabjour[i].substring(0,1);
				
				// Une bordure bleu clair est affiché en bas de cette cellule. Cela représentera une ligne séparatrice entre les jours de la semaine et les jours du mois
				cell.className = "CalendarTopWeekDay";
				if (i == 0) addClass (cell, "CalendarFisrtWeekDay");
				cell = null;
			}
			i = null;
			
			// Si le premier jour du mois n'est pas un dimanche, la variable date est repositionnée sur le dimanche précédent.
			if (dDate.getDay() != this.JourDebutSemaine) 
			{
				if (this.JourDebutSemaine == 0) dDate = add_Day_to_Date(dDate, -1 * dDate.getDay())
				else 
				{
					while(dDate.getDay() != this.JourDebutSemaine) 
					{
						dDate = add_Day_to_Date(dDate, -1)
					}
				}
			}
			this.dFirstDay = Date_To_String(dDate);
			// Déclaration d'une variable logique qui servira à intérrompre la boucle sur les jours
			var lContinue = true;
			// Déclartion d'une variable iLigne qui permet de savoir la ligne en cours de création
			var iLigne = 0;
			// Boucle infinie
			while (lContinue)
			{
				// Si la date en cours est un dimanche, cela indique un changement de semaine et donc il faut créer une nouvelle ligne dans le tableau
				if (dDate.getDay() == this.JourDebutSemaine) 
				{		
					// Si la date en cours ne faits pas partie du mois à afficher et que ce n'est pas la première ligne en cours de création, la génération du calendrier est terminé
					if (dDate.getMonth() != this.currentMonth && iLigne != 0) 
					{
						// Variable lContinue pasée à false pour mettre un terme à la boucle infinie.
						lContinue = false;
						// Instrunction break rtourne immédiatement au while et donc termine la boucle
						break;			
					}
					
					// Ajout d'une ligne pour simuler le changement de semaine
					var row = this.TabJour.insertRow(-1);					
					row.align="center";	// Les données sont centrées					
					row.height = "15px";	// Chaque ligne fait 15 pixels de haut
					// Incrémentation du compteur de ligne
					
					if (objcalendar.lDisplayWeekColumn)
					{
						// Ajourt d'une cellule pour simuler le changement de jour
						var cell = row.insertCell(-1);	
						// Le  texte de la cellule est le numéro de jours dans le mois
						cell.className = "CalendarWeek";
						cell.innerHTML = RechSemaine(dDate, this.JourDebutSemaine + 1);
						cell.DateText = Date_To_String(dDate);

						cell.onclick = objcalendar.ClickDate;
					}
					iLigne++;	
				}
				
				// Ajourt d'une cellule pour simuler le changement de jour
				var cell = row.insertCell(-1);	
				// Le  texte de la cellule est le numéro de jours dans le mois
				cell.innerHTML= dDate.getDate();
				if (dDate.getDay() == this.JourDebutSemaine) addClass (cell, "CalendarFisrtWeekDay");
				
				var lDisableDate = false;
				if (typeof(disablebeforetoday) != "undefined")
				{
					lDisableDate = IsDateBefore(dDate); //cell.style.textDecoration = "line-through";
				}
				
				if (!lDisableDate) cell.style.cursor = "pointer";			// Le curseur de la souris sera une main lorsque l'utilisateur passera la main au-dessus de la cellule
				// Ajout d'un attribut DateText sur la cellule avec la date courant au format voulu (dd/mm/yyyy)
				cell.DateText = Date_To_String(dDate);	
				
				// Création d'une fonction liée à l'évènement click sur la cellule
				if (!lDisableDate) cell.onclick = objcalendar.ClickDate;
				
				// Si la date courante fait partie du mois à afficher, les dates seront affichées en gras ou que la date courante était la date initaile de l'objet
				if (((dDate.getMonth() == this.currentMonth && dDate.getFullYear() == this.currentYear) || cell.DateText == objcalendar.initialDateText) && !lDisableDate) 
				{
					cell.style.fontWeight = "bold";
					// Si la date courante est la date initiale de l'objet, la cellule aura une couleur de fond bleu très clair
					if (cell.DateText == objcalendar.initialDateText) cell.style.backgroundColor = colorCalendarCurrent;
				}
				// Sinon , le texte est écrit dans une couleur plus claire que la classe TextCalendar
				else cell.style.color = colorCalendarOtherMonth;
				//if (lDisableDate) cell.style.textDecoration = "line-through";
				if (lDisableDate){ cell.style.fontStyle = "italic";cell.style.color = "#999999";}
				
				// Déplacement de la date d'une jour
				dDate = add_Day_to_Date(dDate, 1)
				cell = null;
			}
			this.dLastDay = Date_To_String(add_Day_to_Date(dDate, -1));
			
			objcalendar.adjustHeight();
			iLigne = null;
			lContinue = null;
			row = null;
			dDate = null;
			
			$("TabCalendarLayer").style.visibility = ((typeof customCalendarMonth != "undefined")?"hidden":"");
			if (typeof customCalendarMonth != "undefined") 
			{
				if (IsFunction(customCalendarMonth)) eval(customCalendarMonth + "()")
			}
			
		}	
		
		objcalendar.ClickDate = function(){
			// La valeur du jour sur lequel l'utilisateur vient de cliquer est affichée dans l'objet qui a déclenché l'affichage du calendrier
			if (typeof(objcalendar.RelatedObject.maxValue) != "undefined" || typeof(objcalendar.RelatedObjectminValue) != "undefined")
			{ 
				var dDate = String_to_Date(this.DateText);
				if (typeof(objcalendar.RelatedObject.maxValue) != "undefined") dDate = ((dDate.getTime() <= objcalendar.RelatedObject.maxValue.getTime())?dDate:objcalendar.RelatedObject.maxValue);
				if (typeof(objcalendar.RelatedObject.minValue) != "undefined") dDate = ((dDate.getTime() >= objcalendar.RelatedObject.minValue.getTime())?dDate:objcalendar.RelatedObject.minValue);
				objcalendar.RelatedObject.value = Date_To_String(dDate);
			}
			else objcalendar.RelatedObject.value = this.DateText;
			fire_Event(objcalendar.RelatedObject, "change");
			// Fermeture du calendrier
			objcalendar.Close();			
		}
		
		// Ajout d'une fonction GenereSemaine à l'objet calendrier. L'appel de cette fonction permet d'afficher toutes les semaines de l'année.
		objcalendar.GenereSemaine = function(){
			
			// La calendrier est passé en mode Months (Mois)
			objcalendar.Mode = "Semaine";
			
			// Suppression des données existantes dans le tableau
			objcalendar.DeleteTable();
			
			// La cellule indiquant à l'utilisateur quel mois est affiché est vidée
			objcalendar.CellMonth.innerHTML = "";
			
			// La cellule indiquant à l'utilisateur quelle année est affichée est mise à jour
			objcalendar.CellYear.innerHTML = objcalendar.currentYear;
			
			// Boucle sur le tableau Javascript des mois
			for (var i=0; i<52;i++)
			{
								
				// Cette formule permet d'afficher 4 lignes de 3 mois
				if (Math.round(i / 10) - (i/10) == 0) 
				{
					// Insertion d'une nouvelle ligne dans le tableau
					var row = objcalendar.TabJour.insertRow(-1);		
					row.align="center";	// Les données sont centrées					
					row.height = "18px";	// Chaque ligne fait 25 pixels de haut
				}
				
				// Insertion d'une cellule pour chaque mois
				var cell = row.insertCell(-1);	
				// Le texte de la cellule contient les 3 premières lettres du mois suivies d'un point si le mois est plus long	
				cell.innerHTML = i + 1;
				cell.style.fontWeight = "bold";
				
				if (i + 1 == parseInt(objcalendar.initialWeekText) && objcalendar.currentYear == objcalendar.initialDate.getFullYear()) cell.style.backgroundColor = colorCalendarCurrent;
				
				if (Math.round((i+1) / 10) - ((i+1)/10) != 0) cell.style.borderRight = "1px solid " + colorCalendarBorderWeek;
				cell.style.cursor = "pointer";			// Le curseur de la souris sera une main lorsque l'utilisateur passera la main au-dessus de la cellule
				cell.DateText = RechDate(i + 1, objcalendar.currentYear, objcalendar.JourDebutSemaine + 1);
				cell.title = cell.DateText.substring(0,5) + "-" + Date_To_String(add_Day_to_Date(String_to_Date(cell.DateText), 7)).substring(0,5)
				// Création d'une fonction liée à l'évènement click sur la cellule
				cell.onclick = objcalendar.ClickDate;
				cell = null;
				
			}
			objcalendar.adjustHeight();
			i = null;
			
		}	
		// Ajout d'une fonction GenereMois à l'objet calendrier. L'appel de cette fonction permet d'afficher tous les mois de l'année.
		objcalendar.GenereMois = function(){
			
			// La calendrier est passé en mode Months (Mois)
			objcalendar.Mode = "Months";
			
			// Suppression des données existantes dans le tableau
			objcalendar.DeleteTable();
			
			// La cellule indiquant à l'utilisateur quel mois est affiché est vidée
			objcalendar.CellMonth.innerHTML = "";
			
			// La cellule indiquant à l'utilisateur quelle année est affichée est mise à jour
			objcalendar.CellYear.innerHTML = objcalendar.currentYear;
			
			// Boucle sur le tableau Javascript des mois
			for (var i=0; i<tabmois.length;i++)
			{
				// Cette formule permet d'afficher 4 lignes de 3 mois
				if (Math.round(i / 3) - (i/3) == 0) 
				{
					// Insertion d'une nouvelle ligne dans le tableau
					var row = objcalendar.TabJour.insertRow(-1);		
					row.align="center";	// Les données sont centrées					
					row.height = "25px";	// Chaque ligne fait 25 pixels de haut
				}
				// Insertion d'une cellule pour chaque mois
				var cell = row.insertCell(-1);	
				// Le texte de la cellule contient les 3 premières lettres du mois suivies d'un point si le mois est plus long	
				cell.innerHTML = ((tabmois[i].length < 4)?tabmois[i]:tabmois[i].substring(0,3) + ".");
				// Ajout d'un attribut MonthIndex qui servira à savoir sur quel mois l'utilisateur a cliqué
				cell.MonthIndex = i;
				cell.className = "CalendarTopWeekDay";
				cell.style.cursor = "pointer";			// Le curseur de la souris sera une main lorsque l'utilisateur passera la main au-dessus de la cellule
				
				// Si le mois en cours est le mois affiché précédemment et que l'année est l'année en cours, la cellule prend  une couleur bleu clair
				if (objcalendar.currentDate.getFullYear() == objcalendar.currentYear && i == objcalendar.currentMonth) cell.style.backgroundColor = colorCalendarCurrent;
								
				// Création d'une fonction liée à l'évènement click sur la cellule
				cell.onclick = function () {
					// Le mois courant est le mois sur lequel l'utilisateur vient de cliquer
					objcalendar.currentMonth = this.MonthIndex;
					//Affichage du calendrier pour le mois sélectionné par l'utilisateur
					objcalendar.GenereJours();
				}
				cell = null;
				
			}
			objcalendar.adjustHeight();
			i = null;
			
		}	
		
		// Ajout d'une fonction GenereYear à l'objet calendrier. L'appel de cette fonction permet d'afficher les 20 ans les plus proches de l'année courante
		objcalendar.GenereYear = function(){
			
			// La calendrier est passé en mode Years (Années)
			objcalendar.Mode = "Years";
			
			// Suppression des données existantes dans le tableau
			objcalendar.DeleteTable();
			
			// La cellule indiquant à l'utilisateur quel mois est affiché est vidée
			objcalendar.CellMonth.innerHTML = "";
			
			// La cellule indiquant à l'utilisateur quelle année est affichéé est vidée
			objcalendar.CellYear.innerHTML = "";
			// Ajout d'un attribut SearchYear au calendrier qui indique la plus proche année divisble par 20
			objcalendar.SearchYear = Math.floor(objcalendar.currentYear / 20) * 20;
			
			// Boucle sur 20 années
			for (var i=0; i<20;i++)
			{
				// Cette formule permet d'afficher 5 lignes de 4 années
				if (Math.round(i / 4) - (i/4) == 0) 
				{
					// Insertion d'une nouvelle ligne dans le tableau
					var row = objcalendar.TabJour.insertRow(-1);
					row.align="center";	// Les données sont centrées					
					row.height = "20px";	// Chaque ligne fait 25 pixels de haut			
				}
				// Insertion d'une cellule pour chaque année
				var cell = row.insertCell(-1);
				// Le texte de la cellule contient l'année courante
				cell.innerHTML = objcalendar.SearchYear + i;
				cell.className = "CalendarTopWeekDay";
				cell.style.cursor = "pointer";				// Le curseur de la souris sera une main lorsque l'utilisateur passera la main au-dessus de la cellule
				
				// Si l'année  en cours est l'année affichée précédemment, la cellule prend  une couleur bleu clair
				if (objcalendar.currentDate.getFullYear() == cell.innerHTML) cell.style.backgroundColor = colorCalendarCurrent;
				
				// Création d'une fonction liée à l'évènement click sur la cellule
				cell.onclick = function () {
					// L'année courante est l'année sur laquelle l'utilisateur vient de cliquer
					objcalendar.currentYear = parseInt(this.innerHTML);
					//Affichage des mois pour l'année sélectionnée par l'utilisateur
					objcalendar.GenereMois();
				}
				cell = null;
				
			}
			objcalendar.adjustHeight();
			i = null;
							
		}	
		
		// Ajout d'une fonction Incr à l'objet calendrier. Cette fonction est exécutée lorsque l'utilisateur clique sur la flèche de gauche ou de droite. Elle permet de changer rapidement le calendrier
		objcalendar.Incr = function(e){
			var myEvent = e || window.event;
			var objclick = myEvent.target || myEvent.srcElement;
			// Le traitement sera différent en fonction du mode du calendrier
			switch (objcalendar.Mode) 
			{
				// Mode affichage des jours du mois. Le mois suivant ou précédent est affiché
				case "Days":
					// Incrémentation du mois
					objcalendar.currentMonth += objclick.Inc;
					// Si l'utilisateur à appuyer sur la flèche précédente en étant su le mois de Janvier, il faut passer au mois de décembre de l'année précédente
					if (objcalendar.currentMonth < 0) 
					{
						// Le mois courant est passé à décembre
						objcalendar.currentMonth = 11;
						// L'année courante est passé à l'année précédente 
						objcalendar.currentYear += -1;
					}
					// Si l'utilisateur à appuyer sur la flèche suivante en étant su le mois de décembre, il faut passer au mois de janvier de l'année suivante
					else if (objcalendar.currentMonth > 11) 
					{
						// Le mois courant est passé à janvier
						objcalendar.currentMonth = 0;
						// L'année courante est passé à l'année suivante 
						objcalendar.currentYear += 1;
					}
					//Affichage du calendrier pour le mois suivant ou précédent
					objcalendar.GenereJours();
					break;
					
				// Mode affichage des mois de l'année. Les mois  de l'année suivante ou précédente sont affichés
				case "Semaine":
					// Incrémentation de l'année
					objcalendar.currentYear += objclick.Inc;
					//objcalendar.CellYear.innerHTML = objcalendar.currentYear;	
					//Affichage des mois pour l'année suivante ou précédente
					objcalendar.GenereSemaine();	
					break;
					
				// Mode affichage des mois de l'année. Les mois  de l'année suivante ou précédente sont affichés
				case "Months":
					// Incrémentation de l'année
					objcalendar.currentYear += objclick.Inc;
					//objcalendar.CellYear.innerHTML = objcalendar.currentYear;	
					//Affichage des mois pour l'année suivante ou précédente
					objcalendar.GenereMois();	
					break;
					
				// Mode affichage 20 années suivantes ou précédentes.
				case "Years":
					// Incrémentation de l'année de plus ou moins 20 ans
					objcalendar.currentYear += objclick.Inc * 20;	
					//Affichage des années voulues
					objcalendar.GenereYear();	
					break;
			}
		}
		
		// Ajout d'une fonction addArrow à l'objet calendrier. Cette fonction permet de créer une flèche qui permettra à l'utilisateur de changer rapidement de mois, d'année, etc...
		// Paramètre 1 : row	- Référence de la ligne dans laquelle la flèche doit être rajoutée
		// Paramètre 2 : position	- 2 valeur sont possible 'left' ou 'right'
		objcalendar.addArrow = function(row, position){
			
			// Ajout d'une cellule de 25 pixels de largeur à la ligne
			var cell = row.insertCell(-1);
			cell.width = "25px";
			
			// Création d'un objet image
			cell.img = document.createElement("IMG");
			// Cette image est liée à la cellule
			cell.appendChild(cell.img);
			// Elle est postionnée relativement à la ligne et non pas à la cellule
			cell.img.className = "calendarArrow";
			cell.img.style.left = ((position == "left")?2:143) + "px";
			cell.img.src = "/images/calendar_" + position + ".gif";	// Affichage de l'image de la flèche dans l'objet image
			// Ajout d'un attribut Inc de la valeur -1 ou +1 qui sera utilisé lorsque l'utilisateur cliquera sur ces flèches
			cell.img.Inc = ((position == "left")?-1:1);	
			//Liaison entre l'évènement click sur la flèche et le lancement de la fonction Incr de l'objet calendrier
			cell.img.onclick=objcalendar.Incr;
			
			cell.ondelete = function () {
				this.img = null;
			}
			
			cell = null;	
			
		}
			
		// Ajout d'une fonction addHeaderCell  à l'objet calendrier. Cette fonction permet de créer des cellules dans l'en-tête 
		// Paramètre 1 : clickfct	- Référence de la fonction qui doit être lancée lorsque l'utilisateur clique sur la cellule
		objcalendar.addHeaderCell = function(clickfct){
			
			// Ajout d'une cellule à la ligne
			var cell = row.insertCell(-1);
			cell.className = "CalendarHeaderText";
			//cell.style.cursor = "pointer";	// Le curseur de la souris sera une main lorsque l'utilisateur passera la main au-dessus de la cellule
			cell.onclick=clickfct;	// Lien entre l'évènement clic et la fonction passée en paramètre
			return cell;
		}
		
		// Ajout d'une fonction sur l'évènement click sur le calendrier afin d'éviter que le calendrier ne se ferme lorsque l'utilisateur clique dessus.
		objcalendar.onclick = function(){return false}		
								
		// Ajout d'un tableau d'en-tête
		var header = document.createElement("TABLE");
		header.id = 'CalendarLayerHeader';
		header.border = 0;		// Pas de bordure
		header.width = "100%";	// Le tableau fait toute la largeur du calendrier
		header.cellPadding = 0;	// Pas ed marge intérieure
		header.cellSpacing = 0;	// Pas d'espace entre les cellules
		header.className = "Text CalendarHeader";
		
		// Le tableau d'en tête est ajouté au calendrier
		objcalendar.appendChild(header);
		
		// Ajout d'une ligne au tableau d'en tête
		var row = header.insertRow(-1);
		row.align = "center";	// Les données seront centrées
		
		// Ajout de la flèche de gauche
		objcalendar.addArrow(row, 'left');
		
		// Ajout de la cellule qui contiendra le mois courant. Un clic sur cette cellule affichera tous les mois
		objcalendar.CellMonth = objcalendar.addHeaderCell(objcalendar.GenereMois);
		
		// Ajout de la cellule qui contiendra l'année courante. Un clic sur cette cellule affichera 20 années proches
		objcalendar.CellYear = objcalendar.addHeaderCell(objcalendar.GenereYear);
		
		// Ajout de la flèche de droite
		objcalendar.addArrow(row, 'right')
		header = null;
		row = null;
		
		objcalendar.ondelete = function () {
			this.TabJour = null;
			this.CellMonth = null;
			this.CellYear = null;
			this.RelatedObject = null;
			this.Close = null;
			this.DeleteTable = null;
			this.GenereJours = null;
			this.GenereMois = null;
			this.GenereYear = null;
			this.ClickDate = null;
			this.Incr = null;
			this.addArrow = null;
			this.addHeaderCell  = null;
		}
	
	}
	
	// Le calendrier doit maintenant exister ainsi que l'objet à l'origine de son affichage
	if (typeof(objcalendar) != "object" || objclick == null) return;
	
	if (getvalueCSS(objcalendar,"visibility") == "visible" && objcalendar.RelatedObject == objclick) 
	{
		objcalendar.Close();
		return;
	}
	
	// Un attribut RelatedObject est rattaché au calendrier. Il contient à référence à l'objet pour lequelle la date doit être modifiée
	objcalendar.RelatedObject = objclick;
		
	// la date du jour sera affichée par défaut
	objcalendar.initialDate = new Date();
	// Si cet objet avait déjà une date, cette date sera affiché par défaut
	if (objcalendar.RelatedObject.value != "" && objcalendar.RelatedObject.value != Format_Date) {
		var cinitialDate = formatDate(objcalendar.RelatedObject.value);
		if (cinitialDate != "") objcalendar.initialDate = String_to_Date(objcalendar.RelatedObject.value);
	}
	else if (typeof(get_DateDefaut) == "function") objcalendar.initialDate = get_DateDefaut();
	
	objcalendar.JourDebutSemaine = ((typeof(hnJourVillage) != "undefined")?hnJourVillage-1:0);
	if (IsFunction('get_JourDebutSemaine')) objcalendar.JourDebutSemaine = get_JourDebutSemaine();
	objcalendar.lDisplayWeekColumn = ((typeof(hnDisplayWeekColumn) != "undefined")?hnDisplayWeekColumn:true);

	if (objcalendar.JourDebutSemaine == 0) objcalendar.tabjour = tabjour;
	else {
		objcalendar.tabjour = new Array(7);
		var i = -1;
		for (var j = objcalendar.JourDebutSemaine;j<tabjour.length;j++)
		{
			i++;
			objcalendar.tabjour[i] = tabjour[j];
		}
		for (var j = 0;j<objcalendar.JourDebutSemaine;j++)
		{
			i++;
			objcalendar.tabjour[i] = tabjour[j];
		}
	}
		
	// Un attribut initialDateText est rattaché au calendrier. Il contient la date initiale de l'objet
	objcalendar.initialDateText = Date_To_String(objcalendar.initialDate);
	objcalendar.initialWeekText = RechSemaine(objcalendar.initialDate, objcalendar.JourDebutSemaine + 1);
		
	// Un attribut currentDate est rattaché au calendrier. Il contient la date courante de l'objet
	objcalendar.currentDate = objcalendar.initialDate;
	// Un attribut currentMonth est rattaché au calendrier. Il contient le mois courant de l'objet
	objcalendar.currentMonth = objcalendar.initialDate.getMonth();
	// Un attribut currentYear est rattaché au calendrier. Il contient l'année courante de l'objet
	objcalendar.currentYear = objcalendar.initialDate.getFullYear();
	
	//Affichage du calendrier pour le mois de la date par défaut
	objcalendar.GenereJours();
	
	// Récupération des positions de l'objet afin de pouvoir positionner le calendrier correctement
	var obj = objcalendar.RelatedObject;
	var CalendarPosition = [obj.offsetLeft, obj.offsetTop + obj.offsetHeight];
	while (obj.parentNode.tagName != "BODY") 
	{
		obj = obj.parentNode;
		CalendarPosition[0] += obj.offsetLeft;
		if (obj.tagName != "TD" && obj.tagName != "TBODY") CalendarPosition[1] += obj.offsetTop - obj.scrollTop;
	}	
	objcalendar.RelatedObjectTop = objcalendar.offsetTop;
	objcalendar.style.left = CalendarPosition[0] + "px";
	objcalendar.style.top = CalendarPosition[1] + "px";
		
	// Si la calendrier n'a pas la place d'être affiché en-dessous de l'objet, il est affiché au-dessus. Dans tout les cas, son bord droit est placé au même niveau que le bord droit de l'objet
	if (objcalendar.offsetTop + objcalendar.offsetHeight > get_body_height()) objcalendar.style.top = Math.max(objcalendar.RelatedObjectTop - objcalendar.offsetHeight, get_body_height() - objcalendar.offsetHeight,0) + "px";
	if (objcalendar.offsetLeft < 0) objcalendar.style.left = "0px";
		
	// Le calendrier est renbdu visible
	objcalendar.style.visibility = "visible";
	
	if (IsFunction('ready_calandar')) ready_calandar();
	
	// Eviter le l'afichage du menu contextuel des tableaux
	if (myEvent.stopPropagation) {
		myEvent.stopPropagation();
	}
	myEvent.cancelBubble = true;
	
	obj = null;
	
	// La fonction renvoie la valeur false pour empêcher l'affichage du menu contextuel lors du clic droit
	return false;

}

function Event_on_Page (e) {
	// Si le calendrier n'a jamais été créé -> fin de la fonction
	if (typeof(objcalendar) != "object") return;
	// Si le calendrier n'est pas visible -> fin de la fonction
	if (objcalendar.style.visibility != "visible") return;
	
	// Récupération de la référence de l'objet sur lequel le clic a eu lieu
	var myEvent = e || window.event;
	var obj = myEvent.target || myEvent.srcElement;
	
	if (obj == objcalendar.RelatedObject) return;
	
	// Recherche de tous les parents de l'objet dans l'arborescence des objets de la page HTML
	while (obj.tagName != "BODY") 
	{
		obj = obj.parentNode;
		// Le l'objet cliqué fait partie du calendrier, il ne doit pas être masqué -> fin de la fonction
		if (obj == objcalendar) return;
	}
	// Le calendrier est masqué
	objcalendar.Close();
	//obj = null;
}
/*
function Event_on_Calendar (e) {
	var myEvent = e || window.event;
	// Eviter le l'afichage du menu contextuel des tableaux
	if (myEvent.stopPropagation) {
		myEvent.stopPropagation();
	}
	myEvent.cancelBubble = true;
}
*/
// Fonction permettant d'ajouter un nombre de jour à une date
// Paramètre 1 : dDate	- Date à laquelle il faut rajouter le nombre de jours
// Paramètre 2 : iNbDay	- Nombre de jours à ajouter (si positif) ou à soustraire (si négatif)
function add_Day_to_Date(dDate, iNbDay) {
	var iNbMs = 0;
	// Nouvelle variable date qui sert à renvoyer le résultat de la somme	
	dNewDate = new Date();
	// La date est repostionnée à minuit, ce qui permet d'viter des erreurs de la fonction si elle est exécutée en boucle.
	dStartDate = new Date(dDate.getFullYear(), dDate.getMonth(),dDate.getDate());
	// Somme en millisecondes
	iNbMs = dStartDate.getTime()  + (iNbDay * 24 + 1) * 3600 * 1000;
	// Transformation du nombre de millisecondes en date;
	dNewDate.setTime(iNbMs);
	dNewDate.setHours(0,0,0,0)
	return dNewDate;
}

function NbDays(dDate1, dDate2) {
	if (typeof(dDate1 == "string")) dDate1 = String_to_Date(dDate1)
	if (typeof(dDate2 == "string")) dDate2 = String_to_Date(dDate2)
	//dDate1.setHours(0,0,0,0)
	//dDate2.setHours(0,0,0,0)
	var iNbDays = (dDate1.getTime() - dDate2.getTime()) /  (24 * 3600 * 1000)
	return Math.round(iNbDays)
}

// Fonction qui transforme une chaine de caratère contenant une date en un objet date
// Paramètre 1 : cDate	- Chaine de caractère à transformer en date
function String_to_Date(cDate) {
	if (typeof(cDate) != "string") cDate = Date_To_String(cDate);
	// Définition d'un tableau Javascript qui contient les différents éléments de la date.
	var DateData = cDate.split('/');
	// Création d'un objet date auquel les informations issues de la chaine de caractère sont passées en paramètres
	dDateConversion = new Date(DateData[2],DateData[1] - 1, DateData[0]);
	// L'objet date créé est retourné
	return dDateConversion;
}

// Fonction qui transforme un objet date en chaine de caractère
// Paramètre 1 : dDateFormat	- date qu'il faut transformer en chaine de caractère (pour afficher à l'utilisateur)
function Date_To_String(dDateFormat) {
	// Création d'un nouvel objet chaine de caratère
	var cDateFormat = new String();
	// Si le jour du mois est inférieur à 10, la chaine de caractères doit commencer par un "0"
	if (dDateFormat.getDate() < 10) cDateFormat = "0";
	// Il faut ensuite ajouter le néméro de jour et le caractère '/' pour séparer les jour du mois
	cDateFormat += dDateFormat.getDate() + '/';
	// Si le mois est inférieur à 10, il faut insérer un "0"
	if (parseInt(dDateFormat.getMonth() + 1) < 10)cDateFormat += "0";
	// Il faut ensuite ajouter le néméro du mois, le caractère '/' pour séparer le mois de l'année et ajouter l'année sur 4 caractères. Cette chaine de caractère est terminnée et est donc renvoyée.
	return cDateFormat += parseInt(dDateFormat.getMonth() + 1)  + '/' + dDateFormat.getFullYear();
}

/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------- 	*/
/*						  								*/
/*						 RechDate								*/
/*						  								*/
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------- 	*/

/* Paramètres : 	- iWeek	: Numéro de la semaine pour laquelle la date doit être calculée						*
  * 		- iYear	: Année											*
  * 		- cVillage	: Village pour lequel le cacul doit se faire.								*/

// Fonction permettant de trouver la date de début de la semaine pour une année civile et un village
function RechDate(iWeek, iYear, iJour) {
	var cDate = new String();
	var dDate = new Date();
	var dDate1Janv = new Date();
	dDate1Janv = new Date(iYear, 0, 1);
		
	dDate = DebutSemaine(dDate1Janv, iJour);
	if (dDate1Janv.getTime() - dDate.getTime() > (4 * 24 * 3600 * 1000)) {dDate = add_Day_to_Date(dDate, 7)}
	//if(iJour == 7) dDate = add_Day_to_Date(dDate, -1)
	return Date_To_String(add_Day_to_Date(dDate, (iWeek - 1) * 7));
}

/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------- 	*/
/*						  								*/
/*						 RechSemaine								*/
/*						  								*/
/*-------------------------------------------------------------------------------------------------------------------------------------------------------------------- 	*/

/* Paramètres : 	- cDate	: Date pour laquelle le numéro de semaine doit être calculé						*
  * 		- cVillage	: Village pour lequel le cacul doit se faire.								*/

// Fonction permettant de trouver la semaine pour une date et un village
function RechSemaine(cDate, iJour) {
	
	if (typeof(cDate) != "string") cDate = Date_To_String(cDate);
	
	var dDate_1Janv = new Date();
	var dDate_Sem = new Date();
	var dDate_Sem1Janv = new Date();
	dDateSemaine = new Date();
	var dDateInf = new Date();
	var dDateSup = new Date();
	
	dDateSemaine = String_to_Date(cDate);
	var iYear = dDateSemaine.getFullYear();	
	
	dDateInf = String_to_Date(RechDate(1, dDateSemaine.getFullYear() + 1, iJour));
	dDateSup = String_to_Date(RechDate(1, dDateSemaine.getFullYear() + 2, iJour));
	if (dDateInf.getTime() - dDateSemaine.getTime() <= 0 && dDateSup.getTime() - dDateSemaine.getTime() > 0){iYear++}
	dDateInf = String_to_Date(RechDate(1, dDateSemaine.getFullYear() - 1, iJour));
	dDateSup = String_to_Date(RechDate(1, dDateSemaine.getFullYear(), iJour));
	if (dDateInf.getTime() - dDateSemaine.getTime() <= 0 && dDateSup.getTime() - dDateSemaine.getTime() > 0){iYear--}
	
	dDate_1Janv = new Date(iYear, 0, 1);
	dDate_Sem1Janv = DebutSemaine(dDate_1Janv, iJour);
	dDate_Sem = DebutSemaine(dDateSemaine, iJour);
	if (dDate_1Janv.getTime() - dDate_Sem1Janv.getTime() > (4 * 24 + 1) * 3600 *1000){dDate_Sem1Janv = add_Day_to_Date(dDate_Sem1Janv, 7)}
	if(iJour == 7) dDate_Sem1Janv = add_Day_to_Date(dDate_Sem1Janv, -1)
	
	return Math.round((dDate_Sem.getTime() - dDate_Sem1Janv.getTime()) / (7 * 24 * 3600 * 1000)) + 1
	
}

function Week_Day(dDate) {
	return dDate.getDay() + 1;
}

function DebutSemaine(dDate, iJour) {
	var iDecale = 0;
	if (Week_Day(dDate) < iJour)
	{
		iDecale = (Week_Day(dDate) - 1) + (8 - iJour)
	}
	else
	{
		iDecale = Week_Day(dDate) - iJour
	}
	return add_Day_to_Date(dDate, -1 * iDecale)
}

// Fonction qui met l'année sur 4 chiffres
function y2k(number) { return (number < 1000) ? number + 1900 : number; }

// Fonction qui teste l'existence d'une date
// Paramètre 1 : day	- Jour du mois
// Paramètre 2 : month	- Mois
// Paramètre 3 : year	- Année
function DateExists (day,month,year) {
	// Création d'un objet date à la date d'aujourd'hui
	var today = new Date();
	// Récupération de l'année
	year = ((!year) ? y2k(today.getFullYear()):year);
	// Récupération du mois
	month = ((!month) ? today.getMonth():month-1);
	if (!day) return false
	// Création d'un objet date à la date demandée
	var dDateTest = new Date(year,month,day);
	// Vérification que la date crée retourne les même informations que la date demandée
	if ( (y2k(dDateTest.getFullYear()) == year) &&(month == dDateTest.getMonth()) &&(day == dDateTest.getDate()) )	return true;
	else return false;
}

function getCurrentTime() {	
	now = new Date();
	return ((now.getHours() < 10)?"0":"") + now.getHours() + ":" + ((now.getMinutes() < 10)?"0":"") + now.getMinutes() + ":" + ((now.getSeconds() < 10)?"0":"") + now.getSeconds();
}
function IsDateBefore(dDate) {	
	if (typeof dDate == "string") dDate = String_to_Date(dDate);
	now = new Date();
	now.setHours(0,0,0,0);
	return dDate.getTime() < now.getTime();
}