// Fonction principale qui crée un nouveau UCBTextBox de type décimal
function UCBTextBox_DeclareDecimal(idTextBox, valeurDefaut, integerPart, decimalPart, autoriseNegatif)
{
	var textBox = $(idTextBox);
	
	if (!textBox) return;
	
	//alert(idTextBox + " = " + textBox.value);
	
	// On greffe les propriétés sur la textbox pour y accèder plus tard
	textBox.valeurDefaut = valeurDefaut;
	//alert(textBox.value);
	textBox.integerPart = integerPart;
	textBox.decimalPart = decimalPart;
	textBox.autoriseNegatif = autoriseNegatif == true; // Tester à true revient à caster en booléen : si nul (non renseigné), on se retrouve avec false
	

	textBox.onKeyPress = function(e){return textBox.verifSaisieDecimal(e);};
	textBox.onKeyDown = function(e){return textBox.verifSaisieSuppression(e);};
	textBox.onBlur = function(){textBox.formatte();};
	textBox.onFocus = function(){textBox.executeSauveCurseur(textBox.prepare);};
	textBox.onKeyUp = function(){if(textBox.actionKeyUp != null){textBox.executeSauveCurseur(textBox.actionKeyUp);textBox.actionKeyUp=null;}};
	
	// Déclaration des évènements
	ucbAjouteEvenement(textBox, "focus", textBox.onFocus);
	ucbAjouteEvenement(textBox, "blur", textBox.onBlur);
	ucbAjouteEvenement(textBox, "keypress", textBox.onKeyPress);
	ucbAjouteEvenement(textBox, "keydown", textBox.onKeyDown);
	ucbAjouteEvenement(textBox, "keyup", textBox.onKeyUp);
	
	// THE fonction qui renvoie la valeur numérique du champ...
	textBox.valeur = function()
	{
		return parseFloat(this.value.replace(',', '.').replace(/ /g, ''));
	}
	
	// Fonctions
	textBox.formatte = function()
	{
		// Remplacer la virgule par un point et supprimer les espaces. Sinon y comprends pas...
		var fResultat = parseFloat(this.value.replace(/,/, '.').replace(/ /g, ""));
		var sResultat = '';
		if(isNaN(fResultat)) // Si invalide (vide, texte, ...), on met la valeur par défaut
  		sResultat = this.valeurDefaut;
		else
			sResultat = fResultat.toFixed(this.decimalPart);
		// Remplacement . par ,
		sResultat = sResultat.replace(/\./, ',');
		// Positionnement des espaces
		var ptr = 0;
		var i = sResultat.indexOf(',') - 1;
		if(i == -2) i = sResultat.length - 1; // Pas de virgule
		for(; i > 0 && sResultat.charAt(i-1) != '-'; --i)
			if(++ptr%3==0)
				sResultat = sResultat.substring(0,i) + ' ' + sResultat.substring(i);
			
		this.value = sResultat;
	}

	textBox.prepare = function()
	{
    // Si la zone contient la valeur par défaut ou que la valeur saisie est égale à 0, 
    if (this.value == this.valeurDefaut)
        // on vide la zone de saisie : 
        this.value = "";
    else
			this.value = this.value.replace(/ /g, "");
	}

	textBox.calculeFuturTexte = function(insertion)
	{
		// Recupere la position du curseur
		// Cette méthode ne fonctionne pas sous Safari...
		// Elle ne fonctionnera pas non plus sous IE si le champ de texte à tester contient plus de 256 caractères.
		
		// Attention : Pour des touches de suppression, il faut mettre insertion à false (pas vide, pas 0, mais false)
		// , et ajouter un paramètre après qui soit 1 pour suppr et -1 pour backspace
		
		var departSelection = 0;
		var finSelection = 0;
		
		// Version IE
		if(document.selection)
		{
			var range = document.selection.createRange();
			var isCollapsed = range.compareEndPoints("StartToEnd", range) == 0;
			if (!isCollapsed)
				range.collapse(true);
			var b = range.getBookmark();
			departSelection = b.charCodeAt(2) - 2;
			
			range = document.selection.createRange();
			if(!isCollapsed)
				range.collapse(false);
			b = range.getBookmark();
			finSelection = b.charCodeAt(2) - 2;
		}
		
		// Version Gecko (mozilla / firefox)
		else if(this.selectionStart)
		{
			departSelection = this.selectionStart;
			finSelection = this.selectionEnd;
		}
		
		// Autres... on esquive
		else
			return this.value + insertion;
			
		// Y a-t-il une suppression ?
		if(insertion === false)
		{
			if(departSelection == finSelection)
			{
				var retour = this.value.slice(0, this.derniereSuppression > 0 || departSelection + this.derniereSuppression < 0 ? departSelection : departSelection + this.derniereSuppression);
				return retour + this.value.slice(this.derniereSuppression > 0 && finSelection + this.derniereSuppression <= this.value.length ? finSelection + this.derniereSuppression : finSelection, this.value.length);
			}
			
			// Si tout un bout de texte est sélectionné, on se contente de le supprimer
			return this.value.slice(0, departSelection) + this.value.slice(finSelection, this.value.length);
		}
		
		// Sinon...	
		var retour = this.value.slice(0, departSelection);
		retour += insertion;
		retour += this.value.slice(finSelection, this.value.length);
		return retour;
	}
	
	textBox.verifSaisieDecimal = function(e)
	{

		e = ucbNormaliseEvenement(e);
		var texteApres = this.value;
		if(this.derniereSuppression != 0) // Une touche de suppression a été utilisée !
			texteApres = this.calculeFuturTexte(false);
		else
		{
			// Si la touche utilisée n'est pas un caractère (genre une fléche), on autorise et stou :
			// Sous IE, event.charCode n'existe pas. Il est donc strictement différent de zéro dans tous les cas, d'où le ===
			// Sous FFX, charcode est égal au code du caractère tapé au clavier, zéro sinon. C'est donc 0 qui nous interesse pour quitter sans broncher.
			if(e.charCode === 0) return true;
			// On remplace le point par une virgule :
			if (e.toucheClavier == 46)
			{
				e.toucheClavier = 44;
				this.ajouteActionKeyUp("this.value = this.value.replace(/\\./g,',');");
			}
			
			texteApres = this.calculeFuturTexte(String.fromCharCode(e.toucheClavier));
		}
		// Über système de contrôle de validité...
		// Il pourrait être amélioré pour ne pas complétement refuser l'entrée, mais couper le texte à
		// partir du caractère qui pose problème... Ca serait plus cohérent surtout pour un copier-coller
		
		// On commence par interdire n'importe quel caractère non numérique (et non virgule)
		// Sauf les moins en début de texte
		if(!texteApres.match(/^-{0,1}[0-9|,]*$/))
			return ucbAnnuleAction(e);
		
		// Interdiction éventuelle du négatif
		if(!this.autoriseNegatif && e.toucheClavier == 45)
			return ucbAnnuleAction(e);
			
		// On regarde la forme de notre nombre
		var negatifPresent = texteApres.indexOf('-') == 0;
		var virgulePresente = texteApres.indexOf(",") != -1;
		var nbCharsPartEntiere = virgulePresente ? texteApres.indexOf(",") : texteApres.length;
		if(negatifPresent && nbCharsPartEntiere >= 0) --nbCharsPartEntiere;
		var nbCharsPartDecimale = virgulePresente ? texteApres.length - nbCharsPartEntiere - 1 : 0;
		if(virgulePresente && negatifPresent) --nbCharsPartDecimale;
		
		// La virgule est interdite s'il n'y a pas de décimales autorisées
		if(this.decimalPart == 0 && virgulePresente && e.toucheClavier == 44)
			return ucbAnnuleAction(e);

		if(texteApres.match(/,+.*,+/) && e.toucheClavier == 44) // S'il y a plusieurs virgules et que la touche demandée est une virgule
			return ucbAnnuleAction(e);
		
		// Est-ce bon ?
		if(nbCharsPartEntiere > this.integerPart)
		{
			// Si la personne veut ajouter un chiffre après la limite entière, on insère une virgule juste avant
			if(!virgulePresente && texteApres == this.value + String.fromCharCode(e.toucheClavier) && this.decimalPart > 0)
				this.ajouteActionKeyUp('this.value="' + this.value.substr(0,texteApres.length-1)+','+String.fromCharCode(e.toucheClavier)+'";', 1);
			else
				return ucbAnnuleAction(e); // Partie entière trop longue
		}
		
		if(nbCharsPartDecimale > this.decimalPart)
			return ucbAnnuleAction(e);	// Partie décimale trop longue
		
		// Autres règles...
		if(texteApres.indexOf(',') == 0)
			this.ajouteActionKeyUp('this.value = "0" + this.value;', 1);
	}

	
	textBox.verifSaisieSuppression = function(e)
	{
		e = ucbNormaliseEvenement(e);
		if(e.toucheClavier == 8)
			this.derniereSuppression = -1;
		else if(e.toucheClavier == 46)
			this.derniereSuppression = 1;
		else
		{
			this.derniereSuppression = 0;
			return true;
		}
		
		// Forçons l'appel à la fonction de vérification
		return this.onKeyPress(e);
	}
	
	// Cette fonction permet d'executer le code javascript passé en paramètre, sans que le curseur ne soit déplacé.
	textBox.executeSauveCurseur = function(code)
	{
		var positionCurseur = -1; // Quele est la position actuelle du curseur ?
		if(document.selection)
		{
			var range = document.selection.createRange();
			if(range.compareEndPoints("StartToEnd", range) != 0)
				range.collapse(true);
			positionCurseur = range.getBookmark().charCodeAt(2)-2;
		} else if(this.selectionStart)
			positionCurseur = this.selectionStart;
		
		if(typeof(code) == 'string')
			eval(code);
		if(typeof(code) == 'function')
			this.decalageCurseurKeyUp += code.apply(this);		
		
		if(positionCurseur > -1)
		{
			positionCurseur += this.decalageCurseurKeyUp;
			// On replace le curseur à sa place d'origine sinon il va à la fin lors des remplacements
			if(this.createTextRange)
			{
				var range = this.createTextRange();
				range.move('character', positionCurseur);
				range.select();
			} else if(this.setSelectionRange)
				this.setSelectionRange(positionCurseur, 0);
		}
		this.decalageCurseurKeyUp = 0;
	}
	
	textBox.ajouteActionKeyUp = function(code, decalageCurseur)
	{
		if(this.actionKeyUp == null)
			this.actionKeyUp = '';
		this.actionKeyUp += code;
		
		if(decalageCurseur)
			this.decalageCurseurKeyUp += decalageCurseur;
	}
	
	
	// On formate le champ dès le démarrage de la page
	textBox.formatte();
}