<!--
// JavaScript Document  

/* ************************************************************************
   Nom : 					outil_calc.js
   Description : 	Outil de calcul 
  
   Auteur : 			???
   Date M.A.J. :	???

   Auteur :       Martin Boucher
   Date M.A.J. :  2009-02-17 
       ANOMALIE#56 Difference entre comparaison anglais et francais 

   Auteur :       Martin Boucher
   Date M.A.J. :  2009-04-17 
       Nouveaux taux salaire minimum
   ************************************************************************ */

// -----------------------------------------------------------------------------------------------------
// Déclaration des variables

// les deux varialbes txHorSalMinReg et txHorSalMinPoubr ne sont plus utilisées 
//var txHorSalMinReg = 7.45;		// Taux horaire du salaire minimum régulier
//var txHorSalMinPoubr = 6.70;	// Taux horaire du salaire minimum au pourboire

var txHorSalMinReg = undefined;		// Taux horaire du salaire minimum régulier
var txHorSalMinPourb = undefined;	// Taux horaire du salaire minimum au pourboire
var txHorSalMin = undefined;	// Reçoit le taux horaire minimum selon le type de salarie
var typeSalarie = undefined;	// Recoit le type de salarie

var blnAncre = 0;							// Booleen pour alterner l'ancre du détail du calcul

var msgDateAnterieure 	= "La date saisie ne peut être supérieure à la date du jour.";
var msgDateInferieure 	= "La date de fin de période doit être supérieure à la date de début.";
var msgAnneeErronee 		= "Il y a un problème avec l'année saisie.";
var msgMoisErrone 			= "Le mois doit être compris entre 1 et 12."
var msgJourErrone 			= "Le jour doit être compris entre 1 et 31."
var msgFormatDateErrone = "Format de date incorrect. AAAA-MM-JJ."
var msgFormatHoraire		= "SVP Inscrire le nombre d'heures sous le format 0 h 00. \nEx. : pour 40 heures et 30 minutes, inscrire 40 h 30.";
var msgFormatMonetaire	= "SVP Inscrire le montant sous le format 0,00. \nEx. : pour 10,35 $, inscrire 10,35.";
var msgMinute 					= "Le nombre de minutes ne peut être supérieur à 59.";
var msgNbrHeureMax 			= "Le nombre d'heures ne peut être supérieur à 168 h.";
var msgNbrHeureZero			= "Le nombre d'heures ne peut être égal à zéro.";
var msgTauxHorIllegalReg= "Ce taux horaire n'est pas conforme à la Loi sur les normes du " +
											 		"travail. \nDepuis le 1er mai 2009, le taux en vigueur est de " +
													"9,00 $ l'heure. \nPour les périodes antérieures à cette date, " +
													"consulter l'historique du \nsalaire minimum contenu dans l'aide " +
													"associée au champ « taux horaire ».";
var msgTauxHorIllegalPourb= "Ce taux horaire n'est pas conforme à la Loi sur les normes du " +
													"travail. \nDepuis le 1er mai 2009, le taux en vigueur est de " +
													"8,00 $ l'heure. \nPour les périodes antérieures à cette date, " +
													"consulter l'historique du \nsalaire minimum contenu dans l'aide " +
													"associée au champ « taux horaire ».";

// -----------------------------------------------------------------------------------------------------
// Déclaration des expressions rationnelles (regular expression)

/* En début de chaîne, un ou plusieurs caractères numérique, suivi de zéro ou un caractère 'espace',
	 suivi du caractère 'h' ou 'H' ou ':', suivi de zéro ou un caractère 'espace',  suivi de deux caractères
	 numérique en fin de chaîne. */
var reFormatHoraire = /^\d+\s?(h|H|:)?\s?(\d{2})?$/;

/* En début de chaîne, zéro ou plusieurs caractère numérique, 
	 suivi de zéro ou un caractère ',' ou de zéro ou un caractère '.',
   suivi d'un ou plusieurs caractère numérique en fin de chaîne. */
var reMonetaire = /^\d*(,|\.)?\d+$/;

// En début de chaîne, un ou plusieurs caractères 'espace' puis fin de chaîne.
var reWhitespace = /^\s+$/;

/* 	Tableau contenant les jours de la semaine
		Ce tableau sert, entre autre, à trouver le jour suivant celui qui est sélectionné. 
		fonction ajustePeriode()*/
var strJourSemaine = new Array("Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi");


/* -----------------------------------------------------------------------------------------------------
   Nom : 					isEmpty
   Description : 	Vérifie si une chaîne est vide
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			s - chaîne
   Sortie : 			Retourne true si la chaîne 's' est vide.
   -------------------------------------------------------------------------------------------------- */
function isEmpty(s) {
  return ((s == null) || (s.length == 0));
}


/* -----------------------------------------------------------------------------------------------------
   Nom : 					isWhitespace
   Description : 	Vérifie si une chaîne est visuellement vide. Elle peut
	 								contenir des caractères d'espacement
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			s - chaîne
   Sortie : 			Retourne true si la chaîne 's' est vide ou
	 								si elle contient des caractères espace seulement.
   -------------------------------------------------------------------------------------------------- */
function isWhitespace(s) {
  return (isEmpty(s) || reWhitespace.test(s));
}


/* -----------------------------------------------------------------------------------------------------
   Nom : 					isFormatHoraire
   Description : 	Vérifie si une chaîne est de format horaire heures:minutes
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/25

   Entrée : 			s - chaîne
   Sortie : 			Retourne true si la chaîne 's' est du format 0h00, 0H00, 0:00, 0 h 00, 0 H 00, 0 : 00
   -------------------------------------------------------------------------------------------------- */
function isFormatHoraire(s) {
  return (reFormatHoraire.test(s));
}


/* -----------------------------------------------------------------------------------------------------
   Nom : 					isMonetaire 
   Description : 	Vérifie si une chaîne est de format monétaire,
	 								sans le signe "$"
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			s - chaîne
   Sortie : 			Retourne true si la chaîne 's' est du format 0,0
   -------------------------------------------------------------------------------------------------- */
function isMonetaire(s) {
  return (reMonetaire.test(s));
}


/* -----------------------------------------------------------------------------------------------------
   Nom :					isDateAnterieure
   Description :	Vérifie que la date du champ référencé est antérieure à la date du jour.
   Auteur :				Marc Morin
   Date M.A.J. :	2003/10/10

	 Fonction appelée : 
									dash2slash(string)
 
   Entrée :				référence sur le champ input type="text"
   Sortie :				true si la date est antérieure ou égale à la date du jour, sinon false.
	 Appelé par :		valideDate()
   -------------------------------------------------------------------------------------------------- */
function isDateAnterieure(fld) {
	var test01;
	var aujourdhui = new Date();
	var dateValidee = new Date(dash2slash(fld.value));
//	alert ("aujourdhui : " + aujourdhui);
//	alert ("dateValidee : " + dateValidee);
	if (aujourdhui <= dateValidee) {
		return false;
	}
	else {
		return true;
	}
}

/* -----------------------------------------------------------------------------------------------------
   Nom :					dateInferieure
   Description :	Vérifie que la date du champ identifié par idDate01 est inférieure à la date 
	 								du champ identifié par idDate02.
   Auteur :				Marc Morin
   Date M.A.J. :	2003/10/17
 
	 Fonction appelée : 
									dash2slash(string)
 
   Entrée :				deux id identifiant les deux champs input type="text" des dates à comparer
   Sortie :				true si la date du champ identifié par idDate01 est inférieure à la date 
	 								du champ identifié par idDate02.
   -------------------------------------------------------------------------------------------------- */
function dateInferieure(idDate01, idDate02) {
	var date01 = new Date(dash2slash(document.getElementById(idDate01).value));
	var date02 = new Date(dash2slash(document.getElementById(idDate02).value));
/* debug
alert ("date01 : " + date01 + "\ndate02 : " + date02);
*/
	if (date01 < date02) {
		return true;
	}
	else 	if (date01 >= date02) {
		alert (msgDateInferieure);
		return false;
	}
	else {
		return undefined;
	}
}

// Vecteur des taux horaires minimum régulier
// lors d'un nouveau taux, il faudra ajouter ce dernier au vecteur.
var tauxHorMinReg = new Array();
tauxHorMinReg[tauxHorMinReg.length] = 4.35;
tauxHorMinReg[tauxHorMinReg.length] = 4.55;
tauxHorMinReg[tauxHorMinReg.length] = 4.75;
//tauxHorMinReg[tauxHorMinReg.length] = 5.00;
tauxHorMinReg[tauxHorMinReg.length] = 5.30;
tauxHorMinReg[tauxHorMinReg.length] = 5.55;
tauxHorMinReg[tauxHorMinReg.length] = 5.70;
tauxHorMinReg[tauxHorMinReg.length] = 5.85;
tauxHorMinReg[tauxHorMinReg.length] = 6.00;
tauxHorMinReg[tauxHorMinReg.length] = 6.45;
tauxHorMinReg[tauxHorMinReg.length] = 6.70;
tauxHorMinReg[tauxHorMinReg.length] = 6.80;
tauxHorMinReg[tauxHorMinReg.length] = 6.90;
tauxHorMinReg[tauxHorMinReg.length] = 7.00;
tauxHorMinReg[tauxHorMinReg.length] = 7.20;
tauxHorMinReg[tauxHorMinReg.length] = 7.30;
tauxHorMinReg[tauxHorMinReg.length] = 7.45;
tauxHorMinReg[tauxHorMinReg.length] = 7.60;
tauxHorMinReg[tauxHorMinReg.length] = 7.75;
tauxHorMinReg[tauxHorMinReg.length] = 8.00;
tauxHorMinReg[tauxHorMinReg.length] = 8.50;
tauxHorMinReg[tauxHorMinReg.length] = 9.00;
tauxHorMinReg[tauxHorMinReg.length] = 9.50;
tauxHorMinReg[tauxHorMinReg.length] = 9.65;
// Ajouter le nouveau taux ici, à la suite du dernier taux horaire

// Vecteur des taux horaires minimum à pourboire
// lors d'un nouveau taux, il faudra ajouter ce dernier au vecteur.
var tauxHorMinPourb = new Array();
tauxHorMinPourb[tauxHorMinPourb.length] = 3.63;
tauxHorMinPourb[tauxHorMinPourb.length] = 3.83;
tauxHorMinPourb[tauxHorMinPourb.length] = 4.03;
tauxHorMinPourb[tauxHorMinPourb.length] = 4.28;
tauxHorMinPourb[tauxHorMinPourb.length] = 4.58;
tauxHorMinPourb[tauxHorMinPourb.length] = 4.83;
tauxHorMinPourb[tauxHorMinPourb.length] = 5.00;
tauxHorMinPourb[tauxHorMinPourb.length] = 5.13;
tauxHorMinPourb[tauxHorMinPourb.length] = 5.28;
tauxHorMinPourb[tauxHorMinPourb.length] = 5.73;
tauxHorMinPourb[tauxHorMinPourb.length] = 5.95;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.05;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.15;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.25;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.45;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.55;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.70;
tauxHorMinPourb[tauxHorMinPourb.length] = 6.85;
tauxHorMinPourb[tauxHorMinPourb.length] = 7.00;
tauxHorMinPourb[tauxHorMinPourb.length] = 7.25;
tauxHorMinPourb[tauxHorMinPourb.length] = 7.75;
tauxHorMinPourb[tauxHorMinPourb.length] = 8.00;
tauxHorMinPourb[tauxHorMinPourb.length] = 8.25;
tauxHorMinPourb[tauxHorMinPourb.length] = 8.35;
// Ajouter le nouveau taux ici, à la suite du dernier taux horaire

// Constructeur de l'objet pour le salaire minimum régulier
function salMinRegDate(date, taux) {
	this.date = date;
	this.taux = taux;
}
// Création d'un vecteur d'objet
var salMinRegDateDB = new Array();
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1986/10/01', 4.35);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1987/10/01', 4.55);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1988/10/01', 4.75);
//salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1989/10/01', 5.00);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1990/10/01', 5.30);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1991/10/01', 5.55);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1992/10/01', 5.70);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1993/10/01', 5.85);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1994/10/01', 6.00);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1995/10/01', 6.45);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1996/10/01', 6.70);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1997/10/01', 6.80);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('1998/10/01', 6.90);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2001/02/01', 7.00);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2002/10/01', 7.20);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2003/02/01', 7.30);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2004/05/01', 7.45);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2005/05/01', 7.60);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2006/05/01', 7.75);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2007/05/01', 8.00);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2008/05/01', 8.50);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2009/05/01', 9.00);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2010/05/01', 9.50);
salMinRegDateDB[salMinRegDateDB.length] = new salMinRegDate('2011/05/01', 9.65);
// Ajouter le nouveau taux ici, à la suite de dernier taux horaire

// Création du Hash (tableau associatif)
for (var i = 0; i < salMinRegDateDB.length; i++) {
	salMinRegDateDB[salMinRegDateDB[i].taux] = salMinRegDateDB[i];
}

// Constructeur de l'objet pour le salaire minimum à pourboire
function salMinPourbDate(date, taux) {
	this.date = date;
	this.taux = taux;
}
// Création d'un vecteur d'objet
var salMinPourbDateDB = new Array();
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1986/10/01', 3.63);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1987/10/01', 3.83);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1988/10/01', 4.03);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1989/10/01', 4.28);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1990/10/01', 4.58);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1991/10/01', 4.83);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1992/10/01', 5.00);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1993/10/01', 5.13);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1994/10/01', 5.28);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1995/10/01', 5.73);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1996/10/01', 5.95);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1997/10/01', 6.05);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('1998/10/01', 6.15);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2001/02/01', 6.25);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2002/10/01', 6.45);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2003/02/01', 6.55);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2004/05/01', 6.70);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2005/05/01', 6.85);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2006/05/01', 7.00);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2007/05/01', 7.25);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2008/05/01', 7.75);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2009/05/01', 8.00);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2010/05/01', 8.25);
salMinPourbDateDB[salMinPourbDateDB.length] = new salMinPourbDate('2011/05/01', 8.35);
// Ajouter le nouveau taux ici, à la suite de dernier taux horaire

// Création du Hash (tableau associatif)
for (var i = 0; i < salMinPourbDateDB.length; i++) {
	salMinPourbDateDB[salMinPourbDateDB[i].taux] = salMinPourbDateDB[i];
}

// +++++++++++++++++++++++++++++++++++++++++++++
// Constructeur de l'objet pour le taux horaire du salaire minimum régulier

function salMinRegTaux(taux, strDate) {

	this.taux = taux;
	this.strDate = strDate;
}

// Création d'un vecteur d'objet
var salMinRegTauxDB = new Array();
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(4.35, '1986/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(4.55, '1987/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(4.75, '1988/10/01');
//salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(5.00, '1989/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(5.30, '1990/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(5.55, '1991/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(5.70, '1992/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(5.85, '1993/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(6.00, '1994/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(6.45, '1995/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(6.70, '1996/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(6.80, '1997/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(6.90, '1998/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(7.00, '2001/02/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(7.20, '2002/10/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(7.30, '2003/02/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(7.45, '2004/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(7.60, '2005/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(7.75, '2006/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(8.00, '2007/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(8.50, '2008/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(9.00, '2009/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(9.50, '2010/05/01');
salMinRegTauxDB[salMinRegTauxDB.length] = new salMinRegTaux(9.65, '2011/05/01');
// Ajouter le nouveau taux ici, à la suite du dernier taux horaire

// Création du Hash (tableau associatif)
for (var i = 0; i < salMinRegTauxDB.length; i++) {
	salMinRegTauxDB[salMinRegTauxDB[i].strDate] = salMinRegTauxDB[i];
}

// Constructeur de l'objet pour le taux horaire du salaire minimum à pourboire

function salMinPourbTaux(taux, strDate) {
	this.taux = taux;
	this.strDate = strDate;
}
// Création d'un vecteur d'objet
var salMinPourbTauxDB = new Array();
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(3.63, '1986/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(3.83, '1987/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(4.03, '1988/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(4.28, '1989/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(4.58, '1990/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(4.83, '1991/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(5.00, '1992/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(5.13, '1993/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(5.28, '1994/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(5.73, '1995/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(5.95, '1996/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.05, '1997/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.15, '1998/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.25, '2001/02/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.45, '2002/10/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.55, '2003/02/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.70, '2004/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(6.85, '2005/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(7.00, '2006/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(7.25, '2007/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(7.75, '2008/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(8.00, '2009/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(8.25, '2010/05/01');
salMinPourbTauxDB[salMinPourbTauxDB.length] = new salMinPourbTaux(8.35, '2011/05/01');
// Ajouter le nouveau taux ici, à la suite de dernier taux horaire

// Création du Hash (tableau associatif)
for (var i = 0; i < salMinPourbTauxDB.length; i++) {
	salMinPourbTauxDB[salMinPourbTauxDB[i].taux] = salMinPourbTauxDB[i];
}

// +++++++++++++++++++++++++++++++++++++++++++++

/* -----------------------------------------------
	Nom : tauxAnterieur(taux)

	Description : Reçoit un taux horaire et retourne
								le taux antérieur en vigueur. 
								Retournera 'undefined' s'il n'y a
								pas de taux antérieur.
	------------------------------------------------ */
function tauxAnterieur(taux) {

	if (typeSalarie != 'pourboire')	{
		for (var i = 0; i < tauxHorMinReg.length; i++) {
			if (taux == tauxHorMinReg[i]) {
				taux = tauxHorMinReg[--i];
				break;
			}
		}
	}
	else {
		for (var i = 0; i < tauxHorMinPourb.length; i++) {
			if (taux == tauxHorMinPourb[i]) {
				taux = tauxHorMinPourb[--i];
				break;
			}
		}
	}
//	alert ("fonction : tauxAnterieur\n\nValeur retourné :\ntaux : " + taux);
	return taux;
}


/* -----------------------------------------------
	Nom : tauxPosterieur(taux)

	Description : Reçoit un taux horaire et retourne
								le taux postérieur en vigueur. 
								Retournera 'undefined' s'il n'y a
								pas de taux postérieur.
	------------------------------------------------ */
/*
function tauxPosterieur(taux) {
	
	if (typeSalarie != 'pourboire')	{
		for (var i = 0; i < tauxHorMinReg.length; i++) {
			if (taux == tauxHorMinReg[i]) {
				taux = tauxHorMinReg[++i];
				break;
			}
		}
	}
	else {
		for (var i = 0; i < tauxHorMinPourb.length; i++) {
			if (taux == tauxHorMinPourb[i]) {
				taux = tauxHorMinPourb[++i];
				break;
			}
		}
	}

//	alert ("fonction : tauxPosterieur\n\nValeur retourné :\ntaux : " + taux);
	return taux;
	
}
*/

/* ---------------------------------------------------------------------------
   Nom : 					tauxEnVigueur(taux, dateDebut, dateFin)
   Description : 	

   Auteur : 			Marc Morin
   Date M.A.J. :	2004/07/21

	 Fonction appelée : 
									tauxAnterieur(taux)
									tauxEnVigueur(taux, dateDebut, dateFin)  >> récursivité

	 Utilise les variables globales :
									typeSalarie

   Entrée : 			un taux horaire, une date de début et une date de fin
   Sortie : 			Vecteur contenant le taux horaire en vigueur et un booléen.
   -------------------------------------------------------------------------- */
function tauxEnVigueur(taux, dateDebut, dateFin) {
	
//alert ("fonction : tauxEnVigueur\n\nValeur reçu :\ntaux : " + taux + "\ndateDebut : " + dateDebut + "\ndateFin : " + dateFin);

	if (typeSalarie != 'pourboire') {

//alert(salMinRegDateDB[taux].date);


		var	dateEnVigueur = new Date(salMinRegDateDB[taux].date);
/*		
		var strMois = dateEnVigueur.getMonth();
		strMois ++;
		if (strMois < 10) {
			strMois = "0" + strMois;
		}
		var strJours = dateEnVigueur.getDate();
		if (strJours < 10) {
			strJours = "0" + strJours;
		}
		var strDate = dateEnVigueur.getFullYear() + "/" + strMois + "/" + strJours;
*/
//		alert ("strDate : " + strDate);
//alert(salMinRegTauxDB[strDate].taux);
//alert(salMinRegDateDB[dateEnVigueur].taux);

/*
		var taux_tmp;
		for (var i = 0; i < tauxHorMinReg.length; i++) {
			
//			alert("dateDebut : " + dateDebut);
			if (new Date(dateDebut) >= new Date(salMinRegDateDB[tauxHorMinReg[i]].date)) {
				taux_tmp = tauxHorMinReg[i];
			}
			else {
//				taux_tmp = tauxHorMinReg[i];
				alert("taux_tmp : " + taux_tmp);
			}
		}
*/		

	} else {

		var	dateEnVigueur = new Date(salMinPourbDateDB[taux].date);
	}

// debug	
//alert ("fonction : tauxEnVigueur \n" + 
//			 "\ndateDebut : " + dateDebut +
//			 "\ndateFin : " + dateFin +
//			 "\ndateEnVigueur : " + dateEnVigueur);
	
	if (dateEnVigueur <= dateDebut) {

// debug
//alert ("taux : " + taux);

		var array = new Array(taux, true);
		return array;

	} else if (dateDebut < dateEnVigueur && dateEnVigueur <= dateFin) {

//		alert (msgChangementTaux);
//		return false;

		taux = tauxAnterieur(taux);
		var array = new Array(taux, false);
		return array;
	} else {

		taux = tauxAnterieur(taux);

		if (taux == undefined) {

			alert ("fonction : tauxEnVigueur()\ntaux : " + taux);
			return false;

		} else {

			taux = tauxEnVigueur(taux, dateDebut, dateFin);
			return taux;

//			taux_dateEnVigueur = tauxEnVigueur(taux, dateDebut, dateFin);
//			return (taux_dateEnVigueur);
		}
	}
}
/*	----------------------------------------------------------------
		Nom : fctTauxPeriode(dateDebut)
		
		Description : Retourne le taux horaire en vigeur selon la date
									passé en paramètre.
		
		---------------------------------------------------------------- */
function fctTauxPeriode (dateDebut) {

//alert("dateDebut : " + dateDebut);
	var tauxOk = 0;
//alert("tauxOk : " + tauxOk);
	if (typeSalarie != 'pourboire') {
	
		for (i=0; i < tauxHorMinReg.length; i++) {
//			alert(i);
//			alert("typeSalarie : " + typeSalarie + "\ni : " + i + "\ntauxHorMinReg[i] : " + tauxHorMinReg[i] + "\ndateDebut : " + dateDebut + "\ntauxOk : " + tauxOk);
//			alert("salMinRegDateDB[tauxHorMinReg[i]].date : " + salMinRegDateDB[tauxHorMinReg[i]].date);

			if (new Date(salMinRegDateDB[tauxHorMinReg[i]].date) <= new Date(dateDebut)) {

				if (tauxOk != 0) {

//					alert("tauxHorMinReg[i] : " + tauxHorMinReg[i]);
					return tauxHorMinReg[i];
				}
			}
			else {
				i--;
				i--;
				tauxOk = 1;
//				alert("i = " + i + "\ntauxOk : " + tauxOk);
//				alert("typeSalarie : " + typeSalarie + "\ni : " + i + "\nsalMinRegDateDB[tauxHorMinReg[i]].date : " + salMinRegDateDB[tauxHorMinReg[i]].date + "\ndateDebut : " + dateDebut + "\ntauxOk : " + tauxOk);
			}
		}
		
		i = tauxHorMinReg.length;
		return tauxHorMinReg[--i]

	} else {
		
		for (i=0; i < tauxHorMinPourb.length; i++) {
//			alert(i);
//			alert("typeSalarie : " + typeSalarie + "\ni : " + i + "\ntauxHorMinPourb[i] : " + tauxHorMinPourb[i] + "\ndateDebut : " + dateDebut + "\ntauxOk : " + tauxOk);
//			alert("salMinPourbDateDB[tauxHorMinPourb[i]].date : " + salMinPourbDateDB[tauxHorMinPourb[i]].date);

			if (new Date(salMinPourbDateDB[tauxHorMinPourb[i]].date) <= new Date(dateDebut)) {
				
				if (tauxOk) {
					
					return tauxHorMinPourb[i];
				}
			}
			else {
				
				i--;
				i--;
				tauxOk = 1;
			}
		}
		i = tauxHorMinPourb.length;
		return tauxHorMinPourb[--i]

	}
}

/*	------------------------------------------------------------------------
		Nom :					isBisextile
		Description :	Retourne vrai si la date fait parti d'une année bisextile.
		Auteur : 			Marc Morin
		Date :				2004-06-30
		
		Entrée :			un objet Date()
		Sortie :			true or false

		Appelé par :	
		------------------------------------------------------------------------ */
function isBisextile(mDate) {

	if (mDate.getFullYear()%400==0 || (mDate.getFullYear()%4 == 0 && mDate.getFullYear()%100!=0)) {
		return true
	} else {
		return false
	}
}

/* -----------------------------------------------------------------------------------------------------
   Nom : 					isLastDayOfMonth
   Description : 	Retourne vrai si la date de l'objet est la dernière date du mois.
   Auteur : 			Patrick Matte
   Date M.A.J. :	2003/10/27

   Entrée : 			un objet Date()
   Sortie : 			Si la date est égale à la dernière date du mois, retourne vrai.
   Appelé par :		nbrMoisComplet		
   -------------------------------------------------------------------------------------------------- */
function isLastDayOfMonth(checkDate) {
	var daysInMonth;
	var lastDate;
	var monthDays = new Array(31,28,31,30,31,30,31,31,30,31,30,31);

	if (checkDate.getMonth() == 1) { // Février
		if (checkDate.getFullYear()%400==0 || (checkDate.getFullYear()%4 == 0 && checkDate.getFullYear()%100!=0) ) {
		 	monthDays[1] +=1;
		}
	}

	// Nombre de jours dans 1 mois
	daysInMonth = monthDays[checkDate.getMonth()];

	// Crée la date de la fin du mois
	lastDate = new Date(checkDate.getFullYear(),checkDate.getMonth(),daysInMonth);

	// Si la date est égale à la dernière date du mois, retourne vrai.
	if (checkDate.getFullYear() == lastDate.getFullYear() && checkDate.getMonth() == lastDate.getMonth() && checkDate.getDate() == lastDate.getDate()) {
		return true;
	}
	else {
		return false;
	}
}

/* -----------------------------------------------------------------------------------------------------
   Nom : 					nbrMoisComplet(dateDebut, dateFin)
   Description : 	Détermine le nombre de mois complet entre deux dates.
   Auteur : 			Patrick Matte
   Date M.A.J. :	2003/10/27

   Entrée : 			deux objets Date()
   Sortie : 			Le nombre de mois complet compris entre les deux date.
   -------------------------------------------------------------------------------------------------- */
function nbrMoisComplet(dateDebut, dateFin) {
	var dureeService = dateFin.getFullYear() - dateDebut.getFullYear()
	// donne le nombre d'année entre les 2 dates, excluant les années contenues par les dates
	dureeService--;
	
	// Calcule le nombre de mois pour les années non complètes
	// incluant les mois où le début et la fin se trouvent.
	if (dureeService == -1) { // le début et la fin sont la même année
	dureeService = ((dateFin.getMonth()+1) - (dateDebut.getMonth()+1));	
	}
	else {									// le début et la fin sont dans des années différentes
	dureeService = (dureeService * 12) + (dateFin.getMonth()) + (12 - (dateDebut.getMonth()));
	}	
	// Calcul des jours du mois de début et de fin
	// Modification ANOMALIE#56 MB difference entre anglais et francais 
	if (dateDebut.getDate() > dateFin.getDate()) { // si le jour de début est plus grand que le jour de fin
		if ((!isLastDayOfMonth(dateDebut) || !isLastDayOfMonth(dateFin))) {
			// le mois ne compte pas. Enlever 1 mois.
			dureeService--;
		}
	}
	return dureeService;
}

function nbrMoisCompletAvis(dateDebut, dateFin) {
	var dureeService = dateFin.getFullYear() - dateDebut.getFullYear()
	// donne le nombre d'année entre les 2 dates, excluant les années contenues par les dates
	dureeService--;
	
	// Calcule le nombre de mois pour les années non complètes
	// incluant les mois où le début et la fin se trouvent.
	if (dureeService == -1) { // le début et la fin sont la même année
	dureeService = ((dateFin.getMonth()+1) - (dateDebut.getMonth()+1));	
	}
	else {									// le début et la fin sont dans des années différentes
	dureeService = (dureeService * 12) + (dateFin.getMonth()) + (12 - (dateDebut.getMonth()));
	}
	if(dateDebut.getDate() == 1 && isLastDayOfMonth(dateFin)){
		dureeService = dureeService + 1;
	}	
	// Calcul des jours du mois de début et de fin
	// Modification ANOMALIE#56 MB difference entre anglais et francais 
	if (dateDebut.getDate() > dateFin.getDate()) { // si le jour de début est plus grand que le jour de fin
		if ((!isLastDayOfMonth(dateDebut) || !isLastDayOfMonth(dateFin)) && dateDebut.getDate()-dateFin.getDate()!=1) {
			// le mois ne compte pas. Enlever 1 mois.
			dureeService--;
		}
	}
	return dureeService;
}




/* ------------------------------------------------------------------------
   Nom : 					setBrowser 
   Description : 	Vérifie la version du fureteur utilisée par l'utilisateur
	 								parmis Navigator 4, Navigator 6 ou Internet Explorer 4/5
	 								et initialise 3 variables globales
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			null
   Sortie : 			initialine les variables booléennes isNav4, isNav6 et isIE4
   ------------------------------------------------------------------------ */
var isNav4, isNav6, isIE4;
function setBrowser() {
	if (navigator.appVersion.charAt(0) == "4") 	{
		if (navigator.appName.indexOf("Explorer") >= 0) {	
			isIE4 = true;	
		}
		else {	
			isNav4 = true; 
		}
	}
	else if (navigator.appVersion.charAt(0) > "4") {
		isNav6 = true;
	}
}

/* ------------------------------------------------------------------------
   Nom : 					setIdProperty
   Description : 	Permet de donner une valeur à une propriété donnée
	 								dans une balise donnée.  Définie la propriété
									directement dans la balise et non dans la feuille
									de style.
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			id : identification de la balise à modifier
	 								property : propriété de la balise à modifier
									value : nouvelle valeur de la propriété
	 Sortie : 			null
   ------------------------------------------------------------------------ */
function setIdProperty( id, property, value ) {
	if (isNav6) {
		var styleObject = document.getElementById( id );
		if (styleObject != null) {
			styleObject = styleObject.style;
			styleObject[ property ] = value;
		}
	}
	else if (isNav4) {
		document[id][property] = value;
	}
	else if (isIE4) {
		document.all[id].style[property] = value;
	}
}

/* -----------------------------------------------------------------------------------------------------
   Nom :					valideDate
   Description :	Applique plusieurs validation de date pas le biais de functions sur le champ référencé
   Auteur :				Marc Morin
   Date M.A.J. :	2003/10/14
 
	 Fonction appelée : 
									checkDate(fld)
									isDateAnterieure(fld)
 
   Entrée :				référence sur un champ input type="text"
   Sortie :				null
   -------------------------------------------------------------------------------------------------- */
function valideDate(fld) {
	if (! checkDate(fld)) {
		setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
		return false;
	} else if (! isDateAnterieure(fld)) {
		alert (msgDateAnterieure);
		setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
		return false;
	} else {
		return true;
	}	
}

/* -----------------------------------------------------------------------------------------------------
   Nom :					checkDate
   Description :	Valide le format de la date du champ référencé	
   Auteur :				Marc Morin -	réf. JavaScript & DHTML Cookbook, Danny Goodman p.46
   Date M.A.J. :	2003/11/03

	 Fonction appelée : 
									dash2slash(string)
 
   Entrée :				référence sur le champ input type="text"
   Sortie :				null
   -------------------------------------------------------------------------------------------------- */
function checkDate(fld) {
	var annee, mois, jour;
	var entry = dash2slash(fld.value);
//	var re = /\b\d{4}[\/-]\d{1,2}[\/-]\d{1,2}\b/;
//	var re = /\b\d{4}[-]\d{1,2}[-]\d{1,2}\b/;
	var re = /\b\d{4}[\/]\d{1,2}[\/]\d{1,2}\b/;
	if (re.test(entry)) {
//		var delimChar = (entry.indexOf("/") != -1) ? "/" : "-";
//		var delimChar = "-";
		var delimChar = "/";
		var delim1 = entry.indexOf(delimChar);
		var delim2 = entry.lastIndexOf(delimChar);
		annee = parseInt(entry.substring(0, delim1), 10);
		mois = parseInt(entry.substring(delim1+1, delim2), 10);
		jour = parseInt(entry.substring(delim2+1), 10);
		var testDate = new Date(annee, mois-1, jour);
//		alert (testDate);
		if (testDate.getDate() == jour) {
			if (testDate.getMonth() + 1 == mois) {
				if (testDate.getFullYear() == annee) {
					return true;
				} else {
					alert (msgAnneeErronee);
				}
			} else {
				alert (msgMoisErrone);
			}
		} else {
			alert (msgJourErrone);
		}
	}
	else {
		alert (msgFormatDateErrone);
	}
	return false;
}

/* ------------------------------------------------------------------------
   Nom : 					ajustePeriode
   Description : 	Affiche le jour précédent au jour choisi
  
   Auteur : 			Patrick Matte
   Date M.A.J. :	2003/10/24
   Entrée : 			objJour : objet SELECT contenant un selectedIndex
   Sortie : 			Affichage dans le span "dateFin"
   ------------------------------------------------------------------------ */
function ajustePeriode(objJour)
{
	if (objJour.selectedIndex > 0)
		// Affiche le jour précédent le jour actuel
		{	document.getElementById("dateFin").innerHTML = "&nbsp;au&nbsp;" + strJourSemaine[objJour.selectedIndex-1].toLowerCase();	}
	else
		// Affiche "samedi"
		{	document.getElementById("dateFin").innerHTML = "&nbsp;au&nbsp;" + strJourSemaine[6].toLowerCase();	}
}

/* ------------------------------------------------------------------------
   Nom : 					valideFormat
   Description : 	Permet de valider les données en format horaire et monétaire
	 								en utilisant des sous-fonctions générales.
  
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/11/05
   Entrée : 			fld : objet champ
	 								format : 'horaire' ou 'monétaire'
   Sortie : 			boolean : true si valide, false si invalide
   ------------------------------------------------------------------------ */
function valideFormat(fld, format, blnZero) {
	// Vérification du format horaire
	if (format == 'horaire') {
		if ((isWhitespace (fld.value) || fld.value == "") && blnZero == false) {
			fld.value = "0 h 00";
			return true;
		}
		else if (!isFormatHoraire (fld.value)) {
			alert (msgFormatHoraire);
			setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
			return false;
		}
		else if (!isMinute (fld.value)) {
			alert (msgMinute);
			setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
			return false;
		}
		else if (hreFloat(fld.value) > 168.0) {
			alert(msgNbrHeureMax);
			setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
			return false;
		}
		else if (hreFloat(fld.value) == 0) {
			if (blnZero == true) {
				alert(msgNbrHeureZero);
				setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
				return false;
			}
			return true;
		}
		else {
			return true;
		}
	} 
	// Vérification du format monétaire
	else if (format == 'monetaire') {
		if (isWhitespace (fld.value) || fld.value == "") {
			fld.value = "0,00";
			return false;
		}
		else if (!isMonetaire (fld.value)) {
			alert (msgFormatMonetaire);
			setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
			return false;
		} 
		else {
			return true;
		}
	}
	else {
		alert("Erreur de paramètre");
		return false;
	}
}

/* ----------------------------------------------------------------------------------------------------
   Nom :					validePeriode
   Description :	valide la periode délimitée par deux date selon un nombre de jours maximum	
   Auteur :				Marc Morin
   Date M.A.J. :	2003/10/14
 
	 Fonction appelée : 
									dash2slash(string)
									daysBetween(date01, date02)
 
   Entrée :				fld - référence sur le champ input type="text"
	 								id - attribut id de l'élément contenant la deuxième date
									nbrJrsMax - nombre de jours maximum permi pour la période
   Sortie :				true si la période est valide, sinon false.
   ------------------------------------------------------------------------------------------------- */
function validePeriode(fld, id, nbrJrsMax) {
	var test01;
	var test02;
	var date01 = new Date(dash2slash(fld.value));
	var date02 = new Date(dash2slash(document.getElementById(id).value));	
	test01 = date01.getDate();
	test02 = date02.getDate();

//	alert ("date01 : " + date01);
//	alert ("test01 : " + test01);
//	alert ("date02 : " + date02);
//	alert ("test02 : " + test02);

	if (!isNaN(test01) || !isNaN(test02)) {
		if (daysBetween(date01, date02) > nbrJrsMax) {
			nbrJrsMax ++;
			alert ("La période saisie ne peut être de plus de " + nbrJrsMax + " jours.");
			return false;
		}
		else {
			return true;
		}
	}
	else {
		return true;
	}
}

/* -----------------------------------------------------------------------------------
   Nom :					daysBetween
   Description :	Calcul le nombre de jours entre deux objets Date()	
   Auteur :				Marc Morin -	réf. JavaScript & DHTML Cookbook, Danny Goodman p.44
   Date M.A.J. :	2003/10/14
 
   Entrée :				deux objets Date()
   Sortie :				nombre de jours entre deux dates
   -------------------------------------------------------------------------------- */
function daysBetween (date1, date2) {
	var DSTAdjust = 0;
	// constants used for our calculations below
	oneMinute = 1000 * 60;
	var oneDay = oneMinute * 60 * 24;
	// equalize times in case date objects have them
	date1.setHours(0);
	date1.setMinutes(0);
	date1.setSeconds(0);
	date2.setHours(0);
	date2.setMinutes(0);
	date2.setSeconds(0);
	// take care of spans across Daylight Saving Time changes
	if (date2 > date1) {
		DSTAdjust = (date2.getTimezoneOffset() - date1.getTimezoneOffset()) * oneMinute;
	}
	else {
		DSTAdjust = (date1.getTimezoneOffset() - date2.getTimezoneOffset()) * oneMinute;
	}
	var diff = Math.abs(date2.getTime() - date1.getTime()) - DSTAdjust;
	return Math.ceil(diff/oneDay);
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					getTypeSalarie
   Description : 	Permet de définir le type de salarié en obtennant la valeur
	 								du paramètre 'type_salarie" passé dans le URL. 
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/26

   Entrée : 			aucun paramètre. Lecture du URL
	 Sortie : 			assignation de la variable globale typeSalarie
	 Référence :		http://devedge.netscape.com/library/manuals/2000/javascript/1.5/reference/
	 								regexp.html#1194735
   ------------------------------------------------------------------------------------------------- */
function getTypeSalarie(type) {
//	var re = /type_salarie=(.*)&?/;
//	typeSalarie = window.location.search;
//	var type = re.exec(typeSalarie);
//	typeSalarie = type[1];
	typeSalarie = type;
//	alert(typeSalarie);	
	
	// Redirection vers l'accueil si aucun type n'est spécifié
/*	
	if (typeSalarie == undefined) {
		window.location.href = "index.asp";
	}
*/
}

/* ------------------------------------------------------------------------
   Nom : 					init_txHorSalMin
   Description : 	initialise le taux horaire minimum selon le type de salarié
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			typeSalarie - chaîne contenant le type de salarié
	 Sortie : 			txtHorSalMin - constante globale contenant le salaire minimum
	 								pour le type de salarié actuel
   ------------------------------------------------------------------------ */
function init_txHorSalMin(typeSalarie) {
	
	var dateSysteme = new Date();
	var taux_prec = undefined; // recoit le taux horaire precedant
	
	if (typeSalarie == 'pourboire') {
	
//		txHorSalMin = txHorSalMinPoubr;

		for(i=0; i < tauxHorMinPourb.length; i++) {

			txHorSalMin = tauxHorMinPourb[i];
			var dateEnVigueur = new Date(salMinPourbDateDB[txHorSalMin].date);
			
			if( dateEnVigueur > dateSysteme) {

				txHorSalMin = taux_prec;
				break;
			}
			
			taux_prec = txHorSalMin;
		}
	}
	
	else {
	
//		txHorSalMin = txHorSalMinReg;

		for(i=0; i < tauxHorMinReg.length; i++) {

			txHorSalMin = tauxHorMinReg[i];
//			alert(txHorSalMin);
//			alert(salMinRegDateDB[txHorSalMin].date);
			var dateEnVigueur = new Date(salMinRegDateDB[txHorSalMin].date);

//			alert("i=" + i + "\nfonction : init_txHorSalMin\ntxHorSalMin : " + txHorSalMin + "\ndateEnVigueur : " + dateEnVigueur);

			
			if( dateEnVigueur > dateSysteme) {
//			alert("fonction : init_txHorSalMin\ntxHorSalMin = taux_prec : " + taux_prec + "\ndateEnVigueur : " + dateEnVigueur);
				txHorSalMin = taux_prec;
				break;
			}
			
			taux_prec = txHorSalMin;
//			alert("fonction : init_txHorSalMin\ntaux_prec = txHorSalMin : " + txHorSalMin + "\ndateEnVigueur : " + dateEnVigueur + "\ndateSysteme : " + dateSysteme);
		}
	}
	
/*
alert (txHorSalMin);
	var DateSystem = new Date();	// Date du jour (selon la date du poste client)
	var tauxHoraire = new Array();
alert (DateSystem);
	tauxHoraire = tauxEnVigueur(txHorSalMin, calcDate(DateSystem, 6, 1), DateSystem);
	txHorSalMin = tauxHoraire[0];
alert (txHorSalMin);
*/
}

/* ------------------------------------------------------------------------
   Nom : 					valideSalaireMin
   Description : 	Vérification du salaire minimum
  
   Auteur : 			Patrick Matte
   Date M.A.J. :	2003/10/28
   Entrée : 			type - type de salarié
	 								i - # de la semaine
   Sortie : 			blnMin - false: salaire trop bas - true: salaire valide
   ------------------------------------------------------------------------ */
function valideSalaireMin(type, i) {

	var blnMin = true; // devient false si le salaire de la semaine est plus petit que le salaire minimum.
	var hrsCalcul; // Nombre d'heure réel, calculé à 1.5 pour le temps supplémentaire

	// Vérification du salaire minimum
	if (type != "pourboire") {
		if (blnTempsSup[i]) { 			// S'il y a du temps supplémentaire
			// Calcule le nombre d'heures incluant l'équivalent en heures
			// du 1.50 de temps supplémentaire
			hrsCalcul = hrsTrav[i] + (hrsTempsSup[i] * 1.50);

			// Vérifie si c'est un taux horaire ou un salaire de base (ou à la semaine)
			if (!isWhitespace(mntTauxHoraire[i])) {
				var mntTotalInclSupp;
				if (typeSalarie != "commission") {
					// Ajoute le temps supplémentaire puisqu'il est retranché lors du calcul du total
					mntTotalInclSupp = mntGrandTotalSem[i] + (parseFloat (remplaceVirgulePoint(document.getElementById("txtTauxHoraire" + i).value)) * hrsTempsSup[i] * 1.50)
				}
				else {
					// N'ajoute pas le temps supplémentaire puisqu'il est déjà inclu.
					mntTotalInclSupp = mntGrandTotalSem[i]
				}
				// Si le salaire de la semaine, incluant le temps supplémentaire, est plus petit
				// que le salaire minimum * le temps travaillé (incluant temps supplémentaire)
				if (arrondi2dec(mntTotalInclSupp) < arrondi2dec(txHorSalMin * hrsCalcul)) {
					blnMin = false;
				}
			}
			else {
				// Si le salaire de la semaine, incluant le temps supplémentaire, est plus petit
				// que le salaire minimum * le temps travaillé (incluant temps supplémentaire)
				// (le temps supplémentaire est déjà contenu dans le total)
				if (arrondi2dec(mntGrandTotalSem[i]) < arrondi2dec(txHorSalMin * hrsCalcul)) {
					blnMin = false;
				}
			}
		}
		else {	// S'il n'y a pas de temps supplémentaire
			if (arrondi2dec(mntGrandTotalSem[i]) < arrondi2dec(txHorSalMin * hrsTrav[i])) { // salaire de base plus petit que salaire minimum
				blnMin = false;
			}
		}
	}
	else {
		// Si c'est un salarié à pourboire et que son taux horaire est plus petit que le salaire minimum
		if (arrondi2dec(mntTauxHoraire[i]) < arrondi2dec(txHorSalMin)) {
			blnMin = false;
		}
	}
	return(blnMin);
}

/* ------------------------------------------------------------------------
   Nom : 					writeWarning
   Description : 	Construction de la chaîne indiquant les semaines
	 								où le salaire minimum est trop bas.
  
   Auteur : 			Patrick Matte
   Date M.A.J. :	2003/10/24
   Entrée : 			blnMin - array de booleans pour chacune des semaines			
	 								type - type de salarié
									intPeriode - # de semaine qui tombe dans un changement de periode
   Sortie : 			strMsgMin - chaîne contenant le message d'avertissement
   ------------------------------------------------------------------------ */
function writeWarning(blnMin, type, intPeriode) {

	var intMin = 0;	// compte le nombre de semaine en erreur
	var strMsgMin = "";	// chaîne contenant le message d'erreur à afficher

	for (i = 1; i <= blnMin.length; i++) {
		if (blnMin[i] == false) {
			strMsgMin += (i + ", "); // Ajoute le numéro de semaine dans la chaîne, suivi d'une virgule
			intMin += 1; // Compteur du nombre de semaines en erreur
		}
	}
	// Le salaire minimum de chacune des semaines est adéquat
	if (intMin == 0) {
		strMsgMin = "";
	}
	// Le salaire minimum d'au moins une semaine est en erreur.
	else {
		strMsgMin = strMsgMin.substr(0, strMsgMin.length - 2); // Enleve la dernière virgule après le numéro de semaine
	}
	return(strMsgMin);
}


/* ------------------------------------------------------------------------
   Nom : 					isMinute
   Description : 	Vérifie si le nombre de minutes dans une chaîne est valide.
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/17

   Entrée : 			s - chaine de format '0H00', '0h00' ou '0:00'
	 Sortie : 			Retourne vrai si le nombre de minute < 60 sinon retourne false
									Peut recevoir une chaine de format '0h' ou seulement un numérique '0', 
									dans ce cas le nombre de minute sera 'undefined' et la fonction
									retournera 'true'.
   ------------------------------------------------------------------------ */
function isMinute(s) {
	// regular expression
	// en debut de chaine, un ou plusieurs numerique, suivi de 'h', H' ou ':',
	// suivi de zéro ou deux numériques en fin de chaine.
	var re = /^\d+\s?(h|H|:)?\s?(\d{2})?$/;
	var m = re.exec(s);
	var minute = parseInt (m[2]);
//	alert ("m[0] : " + m[0] + "\nm[1] : " + m[1] + "\nm[2] : " + m[2] + "\nm[3] : " + m[3]);
//	var hre_min_array = s.split(h|H);
//	var minute = parseInt (hre_min_array[1]);
	if (minute == undefined || isNaN(minute)) {
		return true;
	}
	else if (minute < 60) {
		return true;
	}
	else {
		return false;
	}
}


// Reçoit une chaîne de format '0h00' et retourne un nombre 0.00
// où le nombre de minute équivaut à la partie décimale (minute/60)
// i.e. 10:15 retourne 10.25
function hreFloat(s) {
	var delimChar = (s.indexOf(":") != -1) ? ":" : "h";
	var hre_min_array = s.toLowerCase().split(delimChar);
	var heure = parseFloat (hre_min_array[0]) 
	heure += (hre_min_array[1]) ? hre_min_array[1]/60 : 0;
	return heure;
}


// Reçoit une chaîne 's' de format décimal 0.00 et retourne une chaîne de format horaire 0h00
// i.e. s = 10.25 retournera  10h15
function afficheHeure(f) {
	var str = new String (f); // nécessaire pour utiliser la méthode split(), 'f' etant un nombre à virgule flottante...
	var heure;
	var minute;
	// *** vérifier si il faut gérer la virgule dans le cas
	//     où les paramètres régionnaux du poste la gère.
	var hre_min_array = str.split(/\./);
	heure = hre_min_array[0];
	if (! hre_min_array[1]) {
		minute = "00";
	}
	else {
		minute = "." + hre_min_array[1];
		minute *= 60;
		minute = Math.round(minute);
		if (minute < 10) {
			minute = "0" + minute;
		}
	}
	return (heure + "&nbsp;h&nbsp;" + minute);
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					remplaceVirgulePoint(str)
   Description : 	Transforme une chaîne en remplaçant la virgule (,) par un point (.)
	 								Combiné avec un ParseFloat() lorsque l'on veut faire des calcul sur une chaîne 
									représentant un montant monétaire, par exemple 10,34 retourne 10.34
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/31

   Entrée : 			Chaîne
   Sortie : 			Chaîne
   ------------------------------------------------------------------------------------------------- */
function remplaceVirgulePoint(s) {
	var str = new String (s);
	var a;
	a = str.replace(",","\.");
	return (a);
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					remplacePointVirgule(str)
   Description : 	Transforme une chaîne en remplaçant la point (.) par une virgule (,)
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/31

   Entrée : 			Chaîne
   Sortie : 			Chaîne
   ------------------------------------------------------------------------------------------------- */
function remplacePointVirgule(s) {
	var str = new String (s);
	var a;
	a = str.replace("\.",",");
	return (a);
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					dash2slash(str)
   Description : 	Transforme une chaîne en remplaçant les tirets (-) par des barres obliques (/)
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/31

   Entrée : 			Chaîne
   Sortie : 			Chaîne
   ------------------------------------------------------------------------------------------------- */
function dash2slash(str) {
	var ch01 = new String(str);
	var ch02;
	ch02 = ch01.replace(/-/g,"/");
	return ch02;	
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					slash2dash(str)
   Description : 	Transforme une chaîne en remplaçant les barres obliques (/) par des tirets (-)
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/31

   Entrée : 			Chaîne
   Sortie : 			Chaîne
   ------------------------------------------------------------------------------------------------- */
function slash2dash(str) {
	var ch01 = new String(str);
	var ch02;
	ch02 = ch01.replace(/\//g,"-");
	return ch02;	
}

 
/* ----------------------------------------------------------------------------------------------------
   Nom : 					arrondi2dec(f)
   Description : 	Reçoit un Float et arrondis à deux décimal près
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/31

   Entrée : 			Float
   Sortie : 			Float
   ------------------------------------------------------------------------------------------------- */
function arrondi2dec(f) {
/* debug */
//alert("fonction arrondi2dec\nvaleur a arrondire : " + f);
	f *= 100;
	f = Math.round(f);
	f /= 100;
//alert("valeur arrondie : " + f);
	return (f);
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					mntAffiche(s)
   Description : 	Reçoit un nombre à virgule flotante ou une chaîne représentant un montant monétaire et
	 								transforme ce nombre ou cette chaîne en une chaîne dont le format permet l'affichage.
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/31

	 Fonction appelée : 
									remplaceVirgulePoint(s)
									arrondi2dec(montant)
									remplacePointVirgule(s)

   Entrée : 			Float ou chaîne
   Sortie : 			Chaîne servant à l'affichage du montant (nombre à virgule flotante)
	 								i.e. 0 retourne 0,00
									5 retourne 5,00
									10,3 retourne 10,30 etc.
   ------------------------------------------------------------------------------------------------- */
function mntAffiche(s) {
	var montant;
	montant = remplaceVirgulePoint(s);
	montant = parseFloat (montant);
	montant = arrondi2dec(montant);
	if (montant == 0) {
		montant = "0,00";
	}
	// si montant est un entier, ajoute deux décimales zéro
	else if (montant%1 == 0) {
		montant += ",00";
	}
	// si montant n'a qu'une seule décimal, ajoute une décimale zéro
	else if ((montant * 10)%1 == 0) {
		montant += "0";
	}
	// pour afficher un montant avec virgule
	montant = remplacePointVirgule(montant);
	
	// Insère les espaces pour les milliers et les millions.
	if (montant.length > 6) {
		montant = montant.substring(0, montant.length-6) + " " + montant.substring(montant.length-6, montant.length);
	}
	if (montant.length > 10) {
		montant = montant.substring(0, montant.length-10) + " " + montant.substring(montant.length-10, montant.length);
	}
	return (montant);
}

/* ------------------------------------------------------------------------
   Nom : 					showCalcul
   Description : 	Redirige vers l'ancre qui affiche le calcul au complet
	 								La fonction alterne entre 2 noms d'ancres pour toujours
									aller au même endroit.
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/09/26

   Entrée : 			anchor01, anchor02; deux chaînes en alternance désignant
	 								deux ancres à atteindre dans le document. Lors de l'appel
									de la fonction, les chaînes doivent contenir le caractère
									'#' en début de chaîne.									
	 Sortie : 			URL qui pointe vers une ancre
   ------------------------------------------------------------------------ */
//str.replace(/#.*$/,"");


function showCalcul(anchor01, anchor02) {
	var strUrl = window.location.href;
	strUrl = strUrl.replace(/#.*$/,"");
	if (blnAncre == 0) {
		// S'assure qu'une ancre n'est pas présente dans le URL
		blnAncre = 1;
		window.location.href = strUrl + anchor01;
	}
	else if (blnAncre == 1) {
		blnAncre = 2;
		window.location.href = strUrl + anchor02;
	}
	else {
		blnAncre = 1;
		window.location.href = strUrl + anchor01;
	}
}


/* ------------------------------------------------------------------------
   Nom : 					calcDate
   Description : 	Permet d'ajouter ou d'enlever un nombre de jours à une
	 								date donnée pour retourner une nouvelle date.
  
   Auteur : 			Patrick Matte
   Date M.A.J. :	2003/10/02
   Entrée : 			date - la date à modifier
	 								diff - nombre de jours à additionner ou soustraire.
									action - 	0 = addition de la différence
														1 = soustraction de la différence
   Sortie : 			nouvelle date
   ------------------------------------------------------------------------ */
function calcDate(mdate, diff, action) {
	// Les dates sont calculées en millisecondes. C'est pourquoi il faut multiplier
	// par 86400000 millisecondes, ce qui donne une journée.
	
	// mm 2004-05-01 problème rencontré avec le changement d'heure.
	//return (action == 1 ? new Date(date - (diff * 86400000)) : new Date(date + (diff * 86400000)));

	mdate.setHours(0);
	mdate.setMinutes(0);
	mdate.setSeconds(0);

	return (action == 1 ? new Date(mdate - ((diff * 86400000)-3600000)) : new Date(mdate - (-diff * 86400000)));
}


function formatDate(date) {
	var dateJour, dateMois, dateAnnee, dateSem;
	var strJours = new Array("Dimanche","Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi","Samedi");
	var strMois = new Array("Janvier","Février","Mars","Avril","Mai","Juin","Juillet","Août","Septembre","Octobre","Novembre","Décembre");
	
	dateJour = date.getDate();
	dateMois = date.getMonth();
	dateAnnee = date.getFullYear();
	dateSem = date.getDay();
	
	return (strJours[dateSem] + " " + dateJour + " " + strMois[dateMois] + " " + dateAnnee);
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					focusElement (formName, elemName)
   Description : 	Donne le focus à un champ texte « elemName » d'un formulaire « formName »
	 								Appeler la fonction au travers d'un setTimeout, ex.
									setTimeout("focusElement('" + ref.form.name + "', '" + ref.name + "')", 0);
   Auteur : 			Marc Morin
	 Réf. :					JavaScript & DHTML Cookbook, Danny Goodman, 8.4
   Date M.A.J. :	2003/10/21

   Entrée : 			Nom du formulaire et nom de l'élément			
   Sortie : 			null
   ------------------------------------------------------------------------------------------------- */
function focusElement (formName, elemName)
{
	var elem = document.forms[formName].elements[elemName];
	elem.focus();
	elem.select();
}


/* ----------------------------------------------------------------------------------------------------
   Nom : 					valideNbrJrsSem
   Description : 	Vérifie si la valeur est située entre 1 et 7
   Auteur : 			Marc Morin
   Date M.A.J. :	2003/10/09

   Entrée : 			référence sur un champ input type="text"
   Sortie : 			Retourne true si la valeur est situé entre 1 er 7
	 Fonction appelée : focusElement (pour redonner le focus au champ validé)
   ------------------------------------------------------------------------------------------------- */
function valideNbrJrsSem(fld)
{
	if (! ((fld.value > 0) && (fld.value < 8)))
	{
		setTimeout("focusElement('" + fld.form.name + "', '" + fld.id + "')", 0);
		return false;
	}
	else {
		return true;
	}
}

//-->