// Jauge curseur
// Eric Quillévéré 2008

/*import 3-objetsStandards.js */
/*jsl:import ../../charte/js/js_rewrite.js */

// [bool]  estMaxiInfini : si vrai, indique que le maxi comprend les valeurs au delà
// [string]  OPT_idObjValMini : permet d'indiquer le champ de réception de la valeur mini
// [function] OPT_appelFonctionApresDeplct : Appelle une fonction après le déplacement du curseur
// [int] largeurComplete : largeur de la jauge complète
// [int] OPT_espaceValeurEtJauge_Gauche : espace entre la valeur et la barre de jauge
// [int] OPT_decalCurseurHaut : décalage haut du curseur

function jaugeCurseur(nomObjParent, estHorizontal, estDouble,
	estMaxiInfini, estMiniInfini, selectionPrecise,
	mini, maxi, largeurComplete, hauteurPx,
	classeConteneur, classeValeur, classeConteneurJauge, 
	classeBarre, classeBarreSelection,
	classeCurseur1, classeCurseur2,
	OPT_idObjValMini, OPT_idObjValMaxi,
	OPT_appelFonctionApresDeplct,
	OPT_espaceValeurEtJauge_Gauche, OPT_espaceValeurEtJauge_Droite,
	OPT_decalCurseurHaut)
	{
	
	if (nonDef(OPT_appelFonctionApresDeplct)) OPT_appelFonctionApresDeplct=null;
	if (nonDef(OPT_espaceValeurEtJauge_Gauche)) OPT_espaceValeurEtJauge_Gauche=0;
	if (nonDef(OPT_espaceValeurEtJauge_Droite)) OPT_espaceValeurEtJauge_Droite=0;
	if (nonDef(OPT_decalCurseurHaut)) OPT_decalCurseurHaut=0;
	
	var objParent=obj(nomObjParent);
	var objBlocJauge=null;
	if (objParent)
		{
		// Conteneur général
		objBlocJauge=obj_CreeDiv(objParent,  null, classeConteneur);

		objBlocJauge.style.position='absolute';
		objBlocJauge.style.width=largeurComplete+'px';
		objBlocJauge.style.height=hauteurPx+'px';
		
		// Valeur mini à gauche
		var objMin=obj_CreeDiv(objBlocJauge, null, classeValeur);
		objMin.style.position='absolute';
		objMin.style.height=(hauteurPx-2)+'px';

		var largeurInfo=objMin.offsetWidth;
		var longueurBarre;
		
		// Valeur maxi à gauche
		if (estDouble)
			{
			longueurBarre=largeurComplete-2*largeurInfo- OPT_espaceValeurEtJauge_Gauche-OPT_espaceValeurEtJauge_Droite;
			var objMax=obj_CreeDiv(objBlocJauge, null, classeValeur);
			objMax.style.position='absolute';
			objMax.style.right='0px';
			objMax.style.height=(hauteurPx-2)+'px';
			}
		else
			longueurBarre=largeurComplete-largeurInfo-OPT_espaceValeurEtJauge_Gauche;
		
		// Barre de valeurs du curseur
		objBlocJauge.espacement=0;
		var objBarre=obj_CreeDiv(objBlocJauge, null, classeBarre);		
		objBarre.style.position='absolute';
		
		objBarre.style.width=(longueurBarre-objBlocJauge.espacement-4)+'px';
		objBarre.style.left=(largeurInfo+(objBlocJauge.espacement/2)+OPT_espaceValeurEtJauge_Gauche)+'px';
		objBarre.style.top= (hauteurPx/2-4)+'px';

		// Conteneur des curseurs
		var objDivCurseur=obj_CreeDiv(objBlocJauge, null, classeConteneurJauge);
		objDivCurseur.style.position='absolute';
		objDivCurseur.style.left=(largeurInfo+OPT_espaceValeurEtJauge_Gauche)+'px';
		objDivCurseur.style.width=longueurBarre+'px';
		objDivCurseur.style.height=hauteurPx+'px';

		// Barre de sélection entre curseurs
		var objBarreSel=null;
		objBarreSel=obj_CreeDiv(objDivCurseur, null, classeBarreSelection);	
		objBarreSel.style.position='absolute';
		objBarreSel.style.width=(longueurBarre-objBlocJauge.espacement)+'px';
		objBarreSel.style.top= (hauteurPx/2-4)+'px';		
			
		var posBarreJauge=(objBlocJauge.offsetHeight-objBarre.offsetHeight)/2;
		
		// Curseur
		var objCurseur1, objCurseur2;
		
		objCurseur1=jaugeCurseur_CurseurCree(objDivCurseur, estDouble, classeCurseur1, objMin, 
			estHorizontal, 0, estMaxiInfini, estMiniInfini, mini, maxi, longueurBarre, 
			OPT_appelFonctionApresDeplct, OPT_decalCurseurHaut);
		
		if (estDouble)
			objCurseur2=jaugeCurseur_CurseurCree(objDivCurseur, estDouble, classeCurseur2, objMax, 
			estHorizontal,0, estMaxiInfini, estMiniInfini, mini, maxi, longueurBarre, 
			OPT_appelFonctionApresDeplct, OPT_decalCurseurHaut);
		
			
		jaugeCurseur_CurseurParams(objCurseur1, mini, null, objCurseur2, objBarreSel, OPT_idObjValMini);
		objBlocJauge.jaugeMini=objCurseur1;
		if (estDouble)
			{
			jaugeCurseur_CurseurParams(objCurseur2, maxi, objCurseur1, null, objBarreSel, OPT_idObjValMaxi);

			// Vérifie qu'on peut sélectionner deux valeurs identiques
			if (longueurBarre/(maxi-mini+1)<objCurseur1.offsetWidth && selectionPrecise)
				alert('La taille de la barre est trop petite par rapport à celle des curseurs et à l\'échelle demandée.');

			objBlocJauge.jaugeMaxi=objCurseur2;
				
			}
			
		/*
		// Click sur la barre
		objBarre.onclick=function()
			{
			
			
			}*/
			
		}
		
	// Pour connaître la valeur : propriété "valeur"
	return objBlocJauge;
	}


// Crée une jauge
function jaugeCurseur_CurseurCree(objParent, estDouble,  classeCurseur, objAffiche, 
	estHorizontal, nbDecimales, estMaxiInfini, estMiniInfini,
	miniVal, maxiVal,
	longueurBarre,
	OPT_appelFonctionApresDeplct, OPT_decalCurseurHaut)
	{
	var objCurseur=obj_CreeDiv(objParent, null, classeCurseur);
	objCurseur.style.position='absolute';
	
	objCurseur.sourisDessus=false;
	objCurseur.pxLeft=0;objCurseur.pxTop=0;
	objCurseur.posMaxi=0;
	objCurseur.estDouble=estDouble;
	objCurseur.xCoord=0;objCurseur.yCoord=0;
	objCurseur.estHorizontal=estHorizontal;
	objCurseur.valAffiche=objAffiche;	
	objCurseur.nbDecimales=nbDecimales;	
	objCurseur.estMaxiInfini=estMaxiInfini;	objCurseur.estMiniInfini=estMiniInfini;	
	objCurseur.appelFonctionApresDeplct=OPT_appelFonctionApresDeplct;	
	objCurseur.style.cursor='pointer';
	
	objCurseur.onmousedown=function(event)
		{
		jaugeCurseur_Clic(this, event, miniVal, maxiVal);
		};

	objCurseur.posMaxi = longueurBarre-objCurseur.offsetWidth;
	objCurseur.miniVal=miniVal;
	objCurseur.maxiVal=maxiVal;
	objCurseur.valCount = maxiVal-miniVal+1; // Nb de valeurs dans l'intervalle
	objCurseur.scale = (maxiVal - miniVal) / objCurseur.posMaxi ;
	objCurseur.diffCurseur = longueurBarre/(maxiVal - miniVal+1)-objCurseur.offsetWidth ;// Différence entre la taille du curseur et une unité
	objCurseur.pxLen = longueurBarre; 
	
	if (objCurseur.estHorizontal) 
		objCurseur.fromVal = miniVal;
	else
		{ 
		objCurseur.fromVal = maxiVal;
		objCurseur.scale = -objCurseur.scale; 
		}		
		
	objCurseur.style.top=OPT_decalCurseurHaut + 'px';
	return objCurseur;
	}

	
// Paramètre une jauge	
function jaugeCurseur_CurseurParams(objCurseur,  actuVal,
	miniValObjCurseur, maxiValObjCurseur,
	objBarreSel,
	OPT_idObjValeur)
	{
		
	if (typeof OPT_idObjValeur!='undefined')
		objCurseur.idObjValeur=OPT_idObjValeur;

	objCurseur.objBarreSel = objBarreSel;
	if (objCurseur.diffCurseur<4) objCurseur.diffCurseur=4; // Ecart mini
	
	objCurseur.miniValObjCurseur=miniValObjCurseur;
	objCurseur.maxiValObjCurseur=maxiValObjCurseur;
	
	
	jaugeCurseur_Affiche(objCurseur, ((actuVal-1)/ (objCurseur.maxiVal-objCurseur.miniVal))*objCurseur.posMaxi, true);
	}
	
	
// Fixe ou retourne la position gauche
function jaugeCurseur_posGauche(elmnt, pos)
	{
	if (elmnt.style && (typeof(elmnt.style.left) == 'string')) 
		{
		if (typeof(pos) == 'number') 
			elmnt.style.left = pos + 'px';
		else 
			{
			pos = parseInt(elmnt.style.left);
			if (isNaN(pos)) pos = 0;
			}
		}
	else if (elmnt.style && elmnt.style.pixelLeft) 
		{
		if (typeof(pos) == 'number') 
			elmnt.style.pixelLeft = pos;
		else 
			pos = elmnt.style.pixelLeft;
		}
	return pos;
	}

// Fixe ou retourne la position haut
function jaugeCurseur_posHaut(elmnt, pos)
	{
	if (elmnt.style && (typeof(elmnt.style.top) == 'string')) 
		{
		if (typeof(pos) == 'number') 
			elmnt.style.top = pos + 'px';
		else 
			{
			pos = parseInt(elmnt.style.top);
			if (isNaN(pos)) pos = 0;
			}
		}
	else if (elmnt.style && elmnt.style.pixelTop) 
		{
		if (typeof(pos) == 'number') 
			elmnt.style.pixelTop = pos;
		else 
			pos = elmnt.style.pixelTop;
		}
	return pos;
	}


// jaugeCurseur_Deplace: Handles slider and display while dragging
function jaugeCurseur_Deplace(objCurseur, evnt)
	{
	evnt = (!evnt) ? window.event : evnt; 
	if (objCurseur.sourisDessus) 
		{
		var pos;
		if (objCurseur.estHorizontal)
			pos = objCurseur.pxLeft + evnt.screenX - objCurseur.xCoord ;
		else
			pos = objCurseur.pxTop + evnt.screenY - objCurseur.yCoord ;
		jaugeCurseur_Affiche(objCurseur, pos, false);
		}
	}

// Calcule la position finale ou pas	
function jaugeCurseur_CalculePosition(objCurseur, pos, estInitialisation, estFinale)
	{
	if (estFinale)
		{
		pos=(objCurseur.pxLen / objCurseur.valCount) * Math.round(objCurseur.valCount * pos / objCurseur.pxLen);	
		
		}
	
	// vérifie si pos objet > autre objet
	var posMini=0;
	var posMaxi=objCurseur.posMaxi;
	
	if (!estInitialisation)
		{
		if (objCurseur.miniValObjCurseur)
			{
			if (pos-objCurseur.miniValObjCurseur.offsetWidth<=objCurseur.miniValObjCurseur.offsetLeft) 
				posMini=objCurseur.miniValObjCurseur.offsetLeft+(objCurseur.diffCurseur);
			}

		if (objCurseur.maxiValObjCurseur)
			{
			if (pos+objCurseur.maxiValObjCurseur.offsetWidth>=objCurseur.maxiValObjCurseur.offsetLeft) 
				posMaxi=objCurseur.maxiValObjCurseur.offsetLeft-(objCurseur.diffCurseur);
			}
		}

	if (pos > posMaxi) 
		pos = posMaxi;
	else if (pos < posMini) 
		pos = posMini;
	return pos;
	}
	
// jaugeCurseur_Deplace: Handles slider and display while dragging
function jaugeCurseur_Affiche(objCurseur, pos, estInitialisation)
	{
	pos=jaugeCurseur_CalculePosition(objCurseur, pos, estInitialisation, false);

	// Position avec intervalle
	var sliderPos = (objCurseur.pxLen / objCurseur.valCount) * Math.round(objCurseur.valCount * pos / objCurseur.pxLen);
		
	// Affichage
	if (objCurseur.estHorizontal)
		jaugeCurseur_posGauche(objCurseur, pos);  
	else
		jaugeCurseur_posHaut(objCurseur, pos) ;			
	
	// Valeur réelle
	var valReelle = Math.round((sliderPos * objCurseur.scale + objCurseur.fromVal) * Math.pow(10, objCurseur.nbDecimales)) / Math.pow(10, objCurseur.nbDecimales);
	var valAffichee=valReelle;
	
	//alert(valReelle + '/'+valAffichee);
	if (objCurseur.idObjValeur)
		{
		var objet=obj(objCurseur.idObjValeur);
		if (objet) objet.value=valReelle;
		}
	objCurseur.valeur=valReelle;	
		
	// Valeur affichée
	if (valReelle>=objCurseur.maxiVal && objCurseur.estMaxiInfini && !objCurseur.maxiValObjCurseur)
		valAffichee='>' + objCurseur.maxiVal ;
	else if (valReelle<=objCurseur.miniVal && objCurseur.estMiniInfini && !objCurseur.miniValObjCurseur)
		valAffichee='<' + objCurseur.miniVal;		
	objCurseur.valAffiche.innerHTML = valAffichee; 
	
	// Barre de sélection
	if (objCurseur.objBarreSel)
		{
		var barreSel_debut, barreSel_fin; // barre de sélection
		barreSel_debut=pos;
		barreSel_fin=pos;
		//alert(objCurseur.estDouble);
		if (objCurseur.estDouble)
			{
			if (objCurseur.miniValObjCurseur)
				{
				barreSel_debut=objCurseur.miniValObjCurseur.offsetLeft;
				
				if (barreSel_debut!==0)
					barreSel_debut+=objCurseur.miniValObjCurseur.offsetWidth/2;
				else
					barreSel_debut=1;
				
				}
			else if (objCurseur.maxiValObjCurseur)
				{
				barreSel_fin=objCurseur.maxiValObjCurseur.offsetLeft;
				if (barreSel_debut!==0) 
					barreSel_debut+=(objCurseur.offsetWidth)/2;
				else
					barreSel_debut=1;
				}
			}
		else
			{
			barreSel_debut=1;//(objCurseur.offsetParent.offsetParent).espacement/2;
			if (!estInitialisation) barreSel_fin=pos; else barreSel_fin=barreSel_debut;
			}

		//alert(pos + ' : ' + barreSel_debut + ' /' + barreSel_fin);
		objCurseur.objBarreSel.style.left=barreSel_debut + 'px';
		var taille=barreSel_fin-barreSel_debut;
		if (taille<0) taille=0; // IE
		objCurseur.objBarreSel.style.width=(taille) + 'px';
		}
	}
	


function jaugeCurseur_Clic(objCurseur, evnt)
	{
	
	if (!evnt) evnt = window.event;
	objCurseur.pxLeft = jaugeCurseur_posGauche(objCurseur); 
	objCurseur.pxTop  = jaugeCurseur_posHaut(objCurseur); 
	objCurseur.xCoord = evnt.screenX ;
	objCurseur.yCoord = evnt.screenY; 
	objCurseur.sourisDessus = true;
	
	// Stocke l'événement pour pouvoir le supprimer
	objCurseur.SourisBouge= function(event) {jaugeCurseur_Deplace(objCurseur, event);};
	objCurseur.SourisHaut= function(event) {jaugeCurseur_Relache(objCurseur);};
	even_Cree(document,Array('mousemove'), objCurseur.SourisBouge);
	even_Cree(document,Array('mouseup'), objCurseur.SourisHaut);
	
	}

//  Relache la souris
function jaugeCurseur_Relache(objCurseur)
	{
	objCurseur.sourisDessus = false ;
	//var pos = (objCurseur.valAffiche.innerHTML - objCurseur.fromVal)/(objCurseur.scale); 
	var pos = (objCurseur.valeur - objCurseur.fromVal)/(objCurseur.scale); 
	pos=jaugeCurseur_CalculePosition(objCurseur, pos, false, true);
	jaugeCurseur_Affiche(objCurseur, pos, false);
	
	even_Suppr(document, Array('mousemove'), objCurseur.SourisBouge);
	even_Suppr(document, Array('mouseup'), objCurseur.SourisHaut);
	
	// Appel de fonction après relachement
	if (objCurseur.appelFonctionApresDeplct)
		objCurseur.appelFonctionApresDeplct();
	}