/* ———————————————————————————————————————————————————————————————————— */
/*																		*/
/*						  EVE		Version 1.1.1						*/
/*					  Dernière Mise à Jour : 09-10-12					*/
/*																		*/
/*						 Mise en Forme & Dynamique						*/
/*	Ce script contient les méthodes de créations d'objet et autre		*/
/*	simulant un codage sous ActionScript et permettant de manipuler		*/
/*	dynamiquement des éléments.											*/
/*																		*/
/* ———————————————————————————————————————————————————————————————————— */



/* ———————————————————————————————————————————— */
/*												*/
/*					CREATION CLIP				*/
/*	Créé et positionne une balise Div prévue  	*/
/*	pour être conçue comme un clip.				*/
/*												*/
/* ———————————————————————————————————————————— */

function creationClip( XX , 		// ————> Positionnement X Initial
					   YY , 		// ————> Positionnement Y Initial
					   Width ,		// ————> Largeur Initial
					   Height , 	// ————> Hauteur Initial
					   GizmoX ,		// ————> Point Gizmo X
					   GizmoY , 	// ————> Point Gizmo Y
					   ID ,			// ————> ID du clip
					   cible ,  	// ————> Cible où placer l'élément
					   Parametres	// ————> Parametres Additionnels
					  ){
	
	// Argument par défaut
	XX = XX || 0;
	YY = YY || 0;
	//
	Parametres = Parametres || {};
	ZZ = Parametres.z || 0;
	Style = Parametres.Style || [];
	Fonctions = Parametres.Fonctions || [];
	
	GizmoX = GizmoX || Width / 2;
	GizmoY = GizmoY || Height / 2;
	
	cible = cible || document.body;
	
	// Créé et affiche la DIV
	var clip = creationDiv( ( XX + ( GizmoX * -1 ) ) , 
							( YY + ( GizmoY * -1 ) ) , 
							"",
							Style ,
							Fonctions ,
							ID ,
							ZZ ,
							cible 
						   );
	
	
	// Calibre la taille du Clip
	clip.style.height = Height + "px";
	clip.style.width = Width + "px";
	
	// Donne au clip ses valeurs
	clip.name = ID;
	//
	clip.X = XX;
	clip.Y = YY;
	clip.Width = Width;
	clip.Heigth = Height;
	clip.GizmoX = GizmoX;
	clip.GizmoY = GizmoY;
	
	// Donne au clip son ID
	if( ID ){ clip.id = ID; }
	
	// Calibre un contenu vide du clip
	clip.innerHTML = "";
	
	// Retourne le lien du clip
	return clip;
}



/* ———————————————————————————————————————————— */
/*												*/
/*				CREATION INFO BULLE				*/
/*	Créé une info-bulle restant en permanance  	*/
/*	positionnée par rapport à la souris et 		*/
/*	qui apparaît/disparaît et a son contenu		*/
/*	se modifiant suivant ses appels 			*/
/*	d'apparition.								*/
/*												*/
/*				Optimisée pour IE7.				*/
/*			  Optimisée pour Safari.			*/
/*												*/
/* ———————————————————————————————————————————— */

function CreationInfoBulle(	Nom ,			// ————> Nom de l'Info-Bulle
						    Parametres ,	// ————> Parametres de l'Info-Bulle
							Style ,			// ————> Style de l'Info-Bulle
							Cible			// ————> Cible de l'Info-Bulle
						   ){
	
	// Arguments par défaut
	Cible = Cible || document.body;
	//
	var Largeur = Parametres.Largeur || 300;
	var Hauteur = Parametres.Hauteur || 150;
	var DecalageX = Parametres.DecalageX || -10;
	var DecalageY = Parametres.DecalageY || -10;
	//
	Style = Style || [];
	//
	var Fluidite = Parametres.Fluidite || 50;
	
	
	// Création du clip servant pour l'Info-Bulle
	Cible[ Nom ] = creationClip( 0 , 
							     0 , 
							     Largeur ,
							     Hauteur ,
							     DecalageX ,
							     DecalageY , 
							     Nom ,
								 null ,
								 { Style:Style }
							    )  
	
	// Place en Z
	Cible[ Nom ].style.zIndex = '1000000';
	
	
	// Paramètres par défaut de l'Info-Bulle
	Cible[ Nom ].Vitesse = Parametres.Vitesse || 10;
	Cible[ Nom ].AlphaMax = Parametres.AlphaMax || 100;
	//
	Cible[ Nom ].ContenuDebut = Parametres.ContenuDebut || "";
	Cible[ Nom ].ContenuFin = Parametres.ContenuFin || "";
	//
	Cible[ Nom ].Largeur = Largeur;
	Cible[ Nom ].Hauteur = Hauteur;
	//
	Cible[ Nom ].Alpha = 0;			// ——> Alpha à atteindre
	Cible[ Nom ].AlphaActuel = 0;	// ——> Alpha en cour
	//
	Cible[ Nom ].actif = true;
	
	
	/***************** Fonction de Positionnement Souris et Modification Alpha *****************/
	//
	Cible[ Nom ].StayMousePosition = function(){
		
		if( this.actif ){
			
			// Si son Alpha est inférieur ou égal à 0 et qu'il est encore visible en display, mes en display invisible (Opacity bug à 0)
			if( this.AlphaActuel <= 0 && getStyle( this.name , "display" ) == "block" ){ this.style.display = "none"; }
			
			// Si son Alpha est supérieur ou égal à 1 et qu'il est encore invisible en display, mes en display visible
			else if( this.AlphaActuel >= 1 && getStyle( this.name , "display" ) == "none" ){ this.style.display = "block"; } 
			
			// Sinon ————>
			else {
			
				// Si son Alpha actuel est inférieur à son Alpha à atteindre ————>
				if( this.AlphaActuel < this.Alpha ){ 
					
					// Son Alpha actuel augmente par rapport à la vitesse
					this.AlphaActuel += this.Vitesse;
					
					// S'il a dépassé l'alpha à atteindre, il se bloque sur la valeur de l'Alpha à atteindre
					if( this.AlphaActuel > this.Alpha ){ this.AlphaActuel = this.Alpha; }; 
					
					// Applique l'Alpha du Clip
					AlphaClip( this , this.AlphaActuel );
					
					
				// Si son Alpha actuel est supérieur à son Alpha à atteindre ————>
				} else if( this.AlphaActuel > this.Alpha ){ 
					
					// Son Alpha actuel réduit par rapport à la vitesse
					this.AlphaActuel -= this.Vitesse;
					
					// S'il a dépassé l'alpha à atteindre, il se bloque sur la valeur de l'Alpha à atteindre
					if( this.AlphaActuel < this.Alpha ){ this.AlphaActuel = this.Alpha; }
					
					// S'il est toujours supérieur à 0, il applique l'Alpha du clip (Je le redis, opacity bug a 0!!!)
					if( this.AlphaActuel > 0 ){ AlphaClip( this , this.AlphaActuel ); }
				}
			}
			
			
			////// PLACEMENT DE LA BULLE
			//
			// Pour un BON navigateur ————>
			if( window.innerWidth ){
				
				
				//******\\ FIREFOX //******\\
				if( navigator.appName != "Netscape" ){
					
					// Si on est proche du bord droit de la scène ————>
					if( MouseX + this.GizmoX + this.Largeur > window.innerWidth - 50 + document.documentElement.scrollLeft ){ 
						
						// Effet miroir horizontal sur la bulle
						this.style.left = ( ( MouseX - this.GizmoX ) - ( this.Largeur - this.GizmoX * 2 ) ) + "px"; 
						
					// Sinon ————>
					} else {
						
						// Place en X par rapport à son Gizmo et à la souris
						this.style.left = ( MouseX - this.GizmoX ) + "px";
					}
						
						
					// Si on est proche du bord bas de la scène ————>
					if( MouseY + this.GizmoY + this.Hauteur > window.innerHeight - 50 + document.documentElement.scrollTop ){ 
						
						// Effet miroir vertical sur la bulle
						this.style.top = ( ( MouseY - this.GizmoY ) - ( this.Hauteur - this.GizmoY * 2 ) ) + "px"; 
					
					// Sinon ————>
					} else {
						
						// Place en Y par rapport à son Gizmo et à la souris
						this.style.top = ( MouseY - this.GizmoY ) + "px";
					}
				
				
				//******\\ SAFARI //******\\
				} else {
						
					// Si on est proche du bord droit de la scène ————>
					if( MouseX + this.GizmoX + this.Largeur > window.innerWidth - 50 + document.body.scrollLeft ){ 
						
						// Effet miroir horizontal sur la bulle
						this.style.left = ( ( MouseX - this.GizmoX ) - ( this.Largeur - this.GizmoX * 2 ) ) + "px"; 
						
					// Sinon ————>
					} else {
						
						// Place en X par rapport à son Gizmo et à la souris
						this.style.left = ( MouseX - this.GizmoX ) + "px";
					}
						
						
					// Si on est proche du bord bas de la scène ————>
					if( MouseY + this.GizmoY + this.Hauteur > window.innerHeight - 50 + document.body.scrollTop ){ 
						
						// Effet miroir vertical sur la bulle
						this.style.top = ( ( MouseY - this.GizmoY ) - ( this.Hauteur - this.GizmoY * 2 ) ) + "px"; 
					
					// Sinon ————>
					} else {
						
						// Place en Y par rapport à son Gizmo et à la souris
						this.style.top = ( MouseY - this.GizmoY ) + "px";
					}
				}
				
				
				
			// Pour IE...  ————>
			} else if( document.documentElement.clientWidth ) {
				
				
				// Si on est proche du bord droit de la scène ————>
				if( MouseX + this.GizmoX + this.Largeur > document.documentElement.clientWidth - 50 + document.documentElement.scrollLeft ){
					
					// Effet miroir horizontal sur la bulle
					this.style.left = ( ( MouseX - this.GizmoX ) - ( this.Largeur - this.GizmoX * 2 ) ) + "px"; 
					
				// Sinon ————>
				} else {
					
					// Place en X par rapport à son Gizmo et à la souris
					this.style.left = ( MouseX + document.documentElement.scrollLeft - this.GizmoX ) + "px";
				}
				
				
				// Si on est proche du bord bas de la scène ————>
				if( MouseY + this.GizmoY + this.Hauteur > document.documentElement.clientHeight - 50 + document.documentElement.scrollTop ){
					
					// Effet miroir vertical sur la bulle
					this.style.top = ( ( MouseY - this.GizmoY ) - ( this.Hauteur - this.GizmoY * 2 ) ) + "px"; 
					
				// Sinon ————>
				} else {
					
					// Place en Y par rapport à son Gizmo et à la souris
					this.style.top = ( MouseY - this.GizmoY + document.documentElement.scrollTop ) + "px";
				}
			}
			
		} else {
			
			this.style.display = "none";
		}
	}
	
	
	/***************** Donne la Fonction affichant l'Info-Bulle *****************/
	//
	Cible[ Nom ].bulle = function( etat ){ 
											// Affiche du contenu à mettre encapsulé entre le Contenu de Début et le Contenu de Fin
											this.innerHTML = this.ContenuDebut + etat + this.ContenuFin; 
											
											// Donne son Alpha à atteindre à son Alpha Max
											this.Alpha = this.AlphaMax; 
										 }
	
	
	/***************** Donne la Fonction voilant l'Info-Bulle *****************/
	//
	Cible[ Nom ].debulle = function( etat ){
												// Donne son Alpha à atteindre à 0
												this.Alpha = 0; 
											}
	
	
	
	/***************** Donne sa boucle pour le déplacement sur la souris et l'Alpha *****************/
	//
	addEnterFrame( Cible[ Nom ] , 
				   "Boucle" , 
				   "StayMousePosition" , 
				   ( Fluidite / 100 ) 
				 );
}





/* ———————————————————————————————————————————— */
/*												*/
/*					ATTACHE IMAGE				*/
/*	Attache une image à une balise ou un "clip".*/
/*												*/
/* ———————————————————————————————————————————— */

function attacheImage( lien , 	// ————> Lien de l'image
					   cible	// ————> Cible où placer l'image
					 ){
	
	// Argument par défaut
	cible = cible || document.body;
	
	// Créé et affiche l'image
	var image = document.createElement( 'img' );
	image.setAttribute( "src" , lien );
	cible.appendChild( image );
	
	// Retourne l'image
	return image;
}



/* ———————————————————————————————————————————— */
/*												*/
/*					DEPLACE CLIP				*/
/*	Déplace un Clip sur un point X / Y selon 	*/
/*	son Gizmo.									*/
/*												*/
/* ———————————————————————————————————————————— */

function deplaceClip( Clip , 	// ————> Clip à déplacer
					  X , 		// ————> Position à atteindre en X
					  Y 		// ————> Position à atteindre en Y
					 ){
	
	// Transforme en Clip si c'est un ID
	if( typeof( Clip ) == "string" ){ Clip = $( Clip ); }
	
	// Positionnement X
	Clip.style.left = ( X - ( Clip.GizmoX || 0 ) ) + "px";
	
	// Positionnement Y
	Clip.style.top = ( Y - ( Clip.GizmoY || 0 ) ) + "px";
}



/* ———————————————————————————————————————————— */
/*												*/
/*					ALPHA CLIP					*/
/*	Modifie l'Alpha d'un Clip.				 	*/
/*												*/
/*	Cette Méthode est optimisé pour IE.			*/
/*												*/
/* ———————————————————————————————————————————— */

function AlphaClip( Clip , 	// ————> Clip à modifier
					Alpha 	// ————> Alpha à avoir
					 ){
	
	// Argument par défaut
	Alpha = Alpha || 100;
	
	// Place son argument rapellant la valeur de son alpha
	Clip._alpha = String( ( Alpha / 100 ) );
	
	// Si on est sur un bon Navigateur ————>
	if( navigator.appName != "Microsoft Internet Explorer" ){
		
		// Modification de l'opacité par l'opacité des styles et renvoie Vrai
		Clip.style.opacity = String( ( Alpha / 100 ) );
		return true;
		
	
	// Si on est... sur IE
	} else {
		
		// Modification de l'opacité par les filtres et renvoie Vrai
		Clip.style.filter = ( 'alpha(opacity=' + Alpha + ')' );
		return true;
	
	}
}



/* ———————————————————————————————————————————— */
/*												*/
/*				  ADD ENTER FRAME				*/
/*	Donne une boucle à un élément pour lancer 	*/
/*	une de ses fonctions constemment.			*/
/*												*/
/* ———————————————————————————————————————————— */

function addEnterFrame( Cible , 	// ————> Cible ayant la boucle
					    Nom , 		// ————> Nom de la boucle
						Fonction , 	// ————> Nom de la fonction à lancer sur la cible
						Cadence 	// ————> Cadence de la boucle (En nombre de dixième de seconde)
					   ){
	
	// Arguments par défaut
	Cadence = Cadence || 1;
	
	// Ajoute à la cible la fonction du nom de cette boucle
	//
	// Dans cette boucle :
	if( Cible != null ){
		
		Cible[ Nom ] = function(){
			
			// Lance la fonction rattaché à cette boucle au sein de la cible
			Cible[ Fonction ]();
		
			// Si la boucle éxiste toujours...
			if( Cible[ Nom ] != null ){
				
				// La Relance au bout d'un certain temps suivant la cadence prévue
				window.setTimeout( Cible[ Nom ] , ( Cadence * 100 ) );
			}
		}
	}
	
	// Lance la boucle une première fois
	Cible[ Nom ]();
}



/* ———————————————————————————————————————————— */
/*												*/
/*				 REMOVE ENTER FRAME				*/
/*	Détruit la boucle d'un élément.				*/
/*												*/
/* ———————————————————————————————————————————— */

function removeEnterFrame( Cible , 	// ————> Cible à retirer une boucle
						   Nom 		// ————> Nom de la boucle à retirer
						 ){
	
	// Mes cette boucle à null
	Cible[ Nom ] = null;
}




/* ———————————————————————————————————————————— */
/*												*/
/*				 	DESTROY						*/
/*	Détruit un élément. 						*/
/*												*/
/* ———————————————————————————————————————————— */

function DestroyChamp( Racine , // ————> Racine de l'élément
					  Nom ,		// ————> Nom de l'élément
					  Cible		// ————> Cible de l'élément
					 ){
	
	// S'il existe ————>
	try{
		// L'écrase
		( Cible || document.body ).removeChild( Racine[ "Div" + Nom ] );
		
	} catch( err ){
		
		// Passe directement par son parent direct pour le détruire
		try{ $( "Div" + Nom ).parentNode.removeChild( $( "Div" + Nom ) );
		} catch( err ){}
	}
}

function DestroyDiv(  ID ,		// ————> ID de l'élément
					  Cible		// ————> Cible de l'élément
					 ){
	
	// S'il existe ————>
	try{
		
		// L'écrase
		( Cible || document.body ).removeChild( $( ID ) );
	
	// Si le lien par son parent échoue ————>
	} catch( err ){
		
		// Passe directement par son parent direct pour le détruire
		try{ $( ID ).parentNode.removeChild( $( ID ) );
		} catch( err ){}
	}
}




/* ———————————————————————————————————————————— */
/*												*/
/*				 CHAMP AUTO SIZE				*/
/*	Créé et place un champ de saisie qui 		*/
/*	s'agrandie automatiquement suivant ce que	*/
/*	l'on met dedans.							*/
/*												*/
/*				Optimisé pour IE7				*/
/*												*/
/* ———————————————————————————————————————————— */

function ChampAutoSize( Racine , 		// ————> Racine où placer les variables et le Champ de saisie
					    Nom , 			// ————> Nom du Champ de Saisie
						Parametres , 	// ————> Parametres du Champ de Saisie ( x , y , Cible , Largeur , Bump )
						Style ,			// ————> Style du Champ de Saisie
						Ajout ,			// ————> Parametres additionnels au Champ de Saisie
						Contenu			// ————> Contenu du formulaire
					   ){
	
	// Définie la Taille du Formulaire en largeur en convertissant les pixels en valeurs de caractère exploitable pour
	// la conception du Champ de saisie
	var tailleFormulaire = ( ( ( Parametres.Largeur || 100 ) / 50 ) - 1 ) * 10 + 1;
	
	// Argument par défaut
	var bumpCaractere = Parametres.Bump || 0;
	var Contenu = Contenu || "";
	
	// Variable additionnel initiée
	var additionnel = "";
	
	
	// S'il y a des Parametres additionnels ————>
	if( Ajout != null ){
		
		// Ajoute chacun de ces paramètres à la variables additionnels séparés d'espaces
		for( var i = 0 ; i < Ajout.length ; i++ ){	additionnel += " " + Ajout[ i ];  }
	}
	
	
	// Détruit tout formulaire portant le même nom
	if( $( "Nom" ) != null ){
		DestroyChamp( Racine , 
				  Nom , 
				  Parametres.Cible  
				);
	}
	
	
	// Créait la Balise Div qui contiendra le Champ de Saisie
	Racine[ "Div" + Nom ] = creationDiv( Parametres.x , 
										 Parametres.y , 
										 null ,
										 null ,
										 null ,
										 ( "Div" + Nom ) ,
										 Parametres.z ,
										 Parametres.Cible 
									   );
	
	
	// Donne à la balise Div le champ de saisie avec son ID, son Contenu et ses Valeurs additionnels
	Racine[ "Div" + Nom ].innerHTML = '<textarea id="' + Nom + '"' + additionnel + '>' + Contenu + '</textarea>';
	
	// Définie la largeur du Champ
	$( Nom ).style.width = Parametres.Largeur + "px";
	
	// Mes le fond transparent
	$( Nom ).style.backgroundColor = 'transparent';
	
	// Mes la Scroll Barre en automatique pour qu'elle soit généralement invisible (Surtout pour IE où elle est visible par essence)
	$( Nom ).style.overflow = "auto";
	
	
	// Si on a définie des styles ————>
	if( Style != null ){
		
		// Définie le style du Champ de Saisie (En prenant soin d'enlever les « ' » pour éviter que ça plante)
		for( var i = 0 ; i < Style.length ; i++ ){
			$( Nom ).style[ Style[ i ].split( " = " )[ 0 ] ] = ConversionCaractere( Style[ i ].split( " = " )[ 1 ] , [ "'" ] , [ "" ] ); 
		}
	}


	// Donne au Champ de Saisie sa Fonction Bouclant
	$( Nom ).AutoSize = function(){
		
		// Définie le Nombre de Ligne à 1
		var nbrLigne = 1;
		
		// Pour chaque Retour Charriot auquel on a procédé ————>
		for( var i = 0 ; i < ( escape( this.value ).split( "%0A" ) ).length ; i++ ){
			
			// Compte le nombre de caractère de cette ligne (Après avoir retiré les caractère de conversion évidemment)
			var caracteresLigne = ( unescape( escape( this.value ).split( "%0A" )[ i ] ).split( "" ) ).length;
			
			// Ajoute au Nombre de ligne le rapport entre la Largeur du champ en caractère, le nobmre de caractère dans cette ligne et le bump
			nbrLigne += Math.floor( caracteresLigne / ( tailleFormulaire + bumpCaractere ) );
			
			// Ajoute une ligne par rapport au Retour Charriot même
			nbrLigne++;
		}
		
		// Modifie la largeur du Champt suivant le Nombre de Ligne obtenu
		this.rows = nbrLigne;
	}
	
	
	// Fait boucler la fonction d'AutoSize du Champ de Saisie
	addEnterFrame( $( Nom ) , 
				   "Boucle" , 
				   "AutoSize" , 
				   1 
				 );
}




/* ———————————————————————————————————————————— */
/*												*/
/*				 CREATION FENETRE				*/
/*	Créé une fenêtre déplaçable dans la page.	*/
/*												*/
/*				Optimisé pour IE7				*/
/*			   Optimisé pour Safari				*/
/*												*/
/* ———————————————————————————————————————————— */

function CreationFenetre( Groupe ,			// ————> Nom du groupe de fenêtre auquel il appartient
						  Nom , 			// ————> Nom d'instance de la fenêtre
						  NomApparant ,		// ————> Titre de la fenêtre
						  Contenue ,		// ————> Contenue de la fenêtre
						  X , 				// ————> Position initial en X de la fenêtre
						  Y , 				// ————> Position initial en Y de la fenêtre
						  Z ,				// ————> Position initial en Z de la fenêtre
						  W , 				// ————> Largeur initial de la fenêtre
						  H ,				// ————> Hauteur initial de la fenêtre
						  Cible ,			// ————> Cible de la fenêtre
						  Parametres		// ————> Parametres additifs
						  ){
	
	// Arguments par défaut
	Cible = Cible || document.body;
	//
	Parametres = Parametres || Object();
	//
	Parametres.HauteurBarre = ( Parametres.HauteurBarre != null ) ? Parametres.HauteurBarre : 20;
	Parametres.LargeurBarre = ( Parametres.LargeurBarre != null ) ? Parametres.LargeurBarre : W;
	Parametres.DecalageBarreX = ( Parametres.DecalageBarreX != null ) ? Parametres.DecalageBarreX : 0;
	Parametres.DecalageBarreY = ( Parametres.DecalageBarreY != null ) ? Parametres.DecalageBarreY : -20;
	Parametres.LargeurBouton = ( Parametres.LargeurBouton != null ) ? Parametres.LargeurBouton : 20;
	Parametres.HauteurBouton = ( Parametres.HauteurBouton != null ) ? Parametres.HauteurBouton : 20;
	Parametres.DecalageBoutonX = ( Parametres.DecalageBoutonX != null ) ? Parametres.DecalageBoutonX : 0;
	Parametres.DecalageBoutonY = ( Parametres.DecalageBoutonY != null ) ? Parametres.DecalageBoutonY : 0;
	Parametres.DecalageContenuX = ( Parametres.DecalageContenuX != null ) ? Parametres.DecalageContenuX : 0;
	Parametres.DecalageContenuY = ( Parametres.DecalageContenuY != null ) ? Parametres.DecalageContenuY : Parametres.DecalageBarre;
	//
	if( Parametres.BoutonX == null ){ Parametres.BoutonX = true; }
	if( Parametres.Bouton_ == null ){ Parametres.Bouton_ = true; }
	//
	Parametres.StyleFenetre = Parametres.StyleFenetre || [ "backgroundColor='#00FFCC'" ];
	Parametres.StyleBarre = Parametres.StyleBarre || [ "backgroundColor='#FFFFCC'" ];
	Parametres.StyleContenu = Parametres.StyleContenu || [ "width='" + W + "px'" ];
	Parametres.StyleX = Parametres.StyleX || [ "backgroundColor='#FF0000'" , "textAlign='center'" ];
	Parametres.StyleXRoll = Parametres.StyleXRoll || [ "backgroundColor='#FFAAAA'" ];
	Parametres.Style_ = Parametres.Style_ || [ "backgroundColor='#00FF00'" , "textAlign='center'" ];
	Parametres.Style_Roll = Parametres.Style_Roll || [ "backgroundColor='#AAFFAA'" ];
	//
	Parametres.StyleX = Fusion( Parametres.StyleX , [ "width='" + Parametres.LargeurBouton + "px'" , "height='" + Parametres.HauteurBouton + "px'" ]  );
	Parametres.Style_ = Fusion( Parametres.Style_ , [ "width='" + Parametres.LargeurBouton + "px'" , "height='" + Parametres.HauteurBouton + "px'" ] );
	//
	if( Parametres.Deplacable == null ){ Parametres.Deplacable = true; }
	if( Parametres.Fluide == null ){ Parametres.Fluide = true; }

	
	
	// Connection au Mouse Port (Si jamais cela n'a pas déjà été fait)
	connectionMousePort( "Mouse" );
	
	// Si le groupe des fenêtres n'éxiste pas, le créé
	if( Cible[ Groupe ] == null ){ Cible[ Groupe ] = Object(); }
	//
	// Si le tableau des Fenêtre et les Objets associés à ce tableau n'éxistent pas, les créé
	if( Cible[ Groupe ].Fenetres == null ){ Cible[ Groupe ].Fenetres = []; }
	if( Cible[ Groupe ].FenetresZ == null ){ Cible[ Groupe ].FenetresZ = Object(); }
	
	
	// Si la fenêtre n'est pas déjà ouverte ————>
	if( $( Nom + "Fenetre" ) == null ){
		
		// Si le Z est null ————>
		if( Z == null ){
			
			// Donne 0 par défaut
			Z = 0;
			
			// Pour chaque autre profondeur de fenêtres ouvertes ————>
			for( var i = 0 ; i < Cible[ Groupe ].Fenetres.length ; i++ ){
				
				// Si elle est supérieur ou égale à celle en cour ——>
				if( Z <= Cible[ Groupe ].FenetresZ[ Cible[ Groupe ].Fenetres[ i ] ] ){
				
					// Donne cette même fenêtre plus un à cette fenêtre pour qu'elle soit, automatiquement, par dessus elle (Et donc par dessus toutes)
					Z = Cible[ Groupe ].FenetresZ[ Cible[ Groupe ].Fenetres[ i ] ] + 1;
				}
			}
		}
		
		
		// Si elle est unique
		if( Parametres.Unique ){
			
			// Pour chaque fenètre, la détruit
			for( var i = 0 ; i < Cible[ Groupe ].Fenetres.length ; i++ ){
				
				$( Cible[ Groupe ].Fenetres[ i ] ).AutoDestruction();
			}
		}
		//
		// Ajoute au tableau des fenêtres de ce groupe l'éxistance de cette fenêtre et sa profondeur
		Cible[ Groupe ].Fenetres.push( Nom + "Fenetre" )
		Cible[ Groupe ].FenetresZ[ Nom ] = Z;
		
		
		// Définit le style des parties de la fenêtre
		var divStyleGlobale = Fusion( Parametres.StyleFenetre ,
									 [ "width='" + W + "px'" , "height='" + H + "px'" ] );
		var divStyleBarre = Fusion( Parametres.StyleBarre ,
								   [ "width='" + Parametres.LargeurBarre + "px'" , "height='" + Parametres.HauteurBarre + "px'" , 
									"cursor='" + Curseur( ( Parametres.Deplacable ) ? 6 : 1 ) + "'"
									] );
		
		////// CRÉATION de la fenêtre ——>
		creationDiv( Number( X ) , Number( Y ) , // ————> Positions
					 "" ,						 // ————> Contenue
					 [],						 // ————> Style
					 [] ,						 // ————> Fonctions
					 ( Nom + "Fenetre" ) ,		 // ————> ID
					 Z ,						 // ————> Z
					 Cible
					);				// ——> Fenêtre globale
		
		creationDiv( 0 , 0 , 					 // ————> Positions
					 "" ,						 // ————> Contenue
					 divStyleGlobale,			 // ————> Style
					 [] ,						 // ————> Fonctions
					 Nom ,		 				 // ————> ID
					 0 , 						 // ————> Z
					 $( Nom + "Fenetre" )		 // ————> Parent
					);				// ——> Partie basse de la fenêtre
		
		creationDiv( Parametres.DecalageContenuX , 											// ————> Positions
					 Parametres.DecalageContenuY , 		
					 OptimiseConversionCaractere( Contenue , [ "[*ACCENT*]" ] , [ "'" ] ) ,	// ————> Contenue (Self-Optimisé pour remmettre les accents)
					 Parametres.StyleContenu ,	 											// ————> Style
					 [] ,						 											// ————> Fonctions
					 ( Nom + "Contenu" ) ,		 											// ————> ID
					 0 , 						 											// ————> Z
					 $( Nom + "Fenetre" )		 											// ————> Parent
					);				// ——> Contenue de la partie basse de la fenêtre
		
		creationDiv( Parametres.DecalageBarreX , 		 // ————> Positions
					 Parametres.DecalageBarreY ,
					 OptimiseConversionCaractere( NomApparant , [ "[*ACCENT*]" ] , [ "'" ] ) ,	// ————> Contenue (Self-Optimisé pour remmettre les accents)
					 divStyleBarre,	 	 		 		 // ————> Style
					 [] ,				 		 		 // ————> Fonctions
					 ( Nom + "Barre" ) , 		 		 // ————> ID
					 0 , 				 		 		 // ————> Z
					 $( Nom + "Fenetre" )			 	 // ————> Parent
					);				// ——> Barre haute de la fenêtre
		
		if( Parametres.BoutonX ){
			
			IncrustationBouton( ( Nom + "BarreX" ) ,
							"simple" ,
							( W - Parametres.LargeurBouton - Parametres.DecalageBoutonX ) , Parametres.DecalageBoutonY , 0 ,
							3 ,
							"" ,
							{ 
								General:Parametres.StyleX ,
								Roll:Parametres.StyleXRoll
							} ,
							{
								onclick:"this.parentNode.parentNode.AutoDestruction();"
							} ,
							$( ( Nom + "Barre" ) )
						);	// ——> Bouton de Suppression
		}
		
		if( Parametres.Bouton_ ){
			IncrustationBouton( ( Nom + "Barre_" ) ,
							"simple" ,
							( W - ( Parametres.LargeurBouton * 2 ) - Parametres.DecalageBoutonX ) , Parametres.DecalageBoutonY , 0 ,
							3 ,
							"" ,
							{ 
								General:Parametres.Style_ ,
								Roll:Parametres.Style_Roll
							} ,
							{
								onclick:"this.onPress();"
							} ,
							$( ( Nom + "Barre" ) )
						);	// ——> Bouton de Réduction
		}

		
		// Paramètres de la fenêtre
		$( Nom + "Fenetre" ).move = false;
		$( Nom + "Fenetre" ).reduit = false;
		//
		$( Nom + "Fenetre" ).X = X;
		$( Nom + "Fenetre" ).Y = Y;
		$( Nom + "Fenetre" ).Z = Z;
		//
		$( Nom + "Fenetre" ).Largeur = Math.max( W , Parametres.LargeurBarre );
		$( Nom + "Fenetre" ).Hauteur = H - Parametres.DecalageBarre;
		//
		$( Nom + "Fenetre" ).bumpX = Parametres.DecalageContenuX;
		$( Nom + "Fenetre" ).bumpY = Parametres.DecalageContenuY;
		//
		$( Nom + "Fenetre" ).Fluide = Parametres.Fluide;
		//
		$( Nom + "Fenetre" ).DecX = 0;
		$( Nom + "Fenetre" ).DecY = 0;
		//
		$( Nom + "Fenetre" ).VitesseX = 0;
		$( Nom + "Fenetre" ).VitesseY = 0;
		//
		$( Nom + "Barre" ).Deplacable = Parametres.Deplacable;
		$( Nom + "Barre" ).Fluide = Parametres.Fluide;
	
		
		////// ACTIONS de la fenêtres
		
		// A l'appuie sur la barre de la fenêtre ——>
		$( ( Nom + "Barre" ) ).onmousedown = function(){
			
			// Si la fenêtre est déplaçable ——>
			if( this.Deplacable ){
					
				// On peut déplacer la fenêtre
				this.parentNode.Moving( true );
				
				// Mes la fenêtre devant les autres
				this.parentNode.Up();
			}
		}
		
		// Au survol de la fenêtre ——>
		$( ( Nom + "Barre" ) ).onmouseover = function(){
			
			// Bloque le surlignage
			MouseAction_StopSurligne( true );
		}
		
		// Au désurvol de la fenêtre ——>
		$( ( Nom + "Barre" ) ).onmouseout = function(){
			
			// Débloque le surlignage
			MouseAction_StopSurligne( false );
		}
		
		
		
		// Au click sur le bouton de Réduction ——>
		if( Parametres.Bouton_ ){
				$( ( Nom + "Barre_" ) ).onPress = function(){
				
				// Toggle la réduction
				this.parentNode.parentNode.reduit = !this.parentNode.parentNode.reduit;
				
				// Réduit ou agrandie selon le choix
				if( !this.parentNode.parentNode.reduit ){ 
					$( Nom ).style.display = "block"; 
					$( ( Nom + "Contenu" ) ).style.display = "block";
				}
				else { 
					$( Nom ).style.display = "none"; 
					$( ( Nom + "Contenu" ) ).style.display = "none";
				}
			}
		}
		
		
		// Au lancement du déplacement (ou arrêt de déplacement) de la fenêtre ——>
		$( Nom + "Fenetre" ).Moving = function( Etat ){
			
			// Change l'état de déplacement de la fenêtre
			this.move = Etat;
			
			// Calcule le décalage entre le curseur et le point 0,0 de la fenêtre
			this.DecX = this.X - MouseX;
			this.DecY = this.Y - MouseY;
		}
		
		
		// A la mise au premier plan de la fenêtre ——>
		$( Nom + "Fenetre" ).Up = function(){
			
			// Pour chaque fenêtres du même groupe ———>
			for( var i = 0 ; i < Cible[ Groupe ].Fenetres.length ; i++ ){
				
				// Si la profondeur de cette fenêtre est supérieur ou égale à celle de cette fenêtre ————>
				if( this.Z <= Cible[ Groupe ].FenetresZ[ Cible[ Groupe ].Fenetres[ i ] ] ){
					
					// La profondeur de cette fenêtre devient égale à celle de l'autre fenêtre plus un
					this.Z = Cible[ Groupe ].FenetresZ[ Cible[ Groupe ].Fenetres[ i ] ] + 1;
				}
			}
			
			// Si ce n'était pas le Z qu'il possédait ——>
			if( Cible[ Groupe ].FenetresZ[ this.id ] != ( this.Z - 1 ) ){
				
				// S'il y a une fonction de mise premier plan ——>
				if( Parametres.FonctionGet != null ){
					
					// Lance la fonction
					Parametres.CibleGet[ Parametres.FonctionGet ]();
				}
			}
			
			// Enregistre la nouvelle profondeur de cette fenêtre
			Cible[ Groupe ].FenetresZ[ this.id ] = this.Z;
			
			// Applique la nouvelle profondeur à cette fenêtre
			this.style.zIndex = String( this.Z );
		}
		
		
		// A l'autodestruction de la fenêtre
		$( Nom + "Fenetre" ).AutoDestruction = function(){
			
			// Détruit la boucle de la fenêtre
			removeEnterFrame( this , "ENTER_FRAME" );

			// Retire du tableau le nom de cette fenêtre
			Cible[ Groupe ].Fenetres.splice( TabPositionElement( Cible[ Groupe ].Fenetres , Nom ) , 1 );
			
			// Mes à null l'occurence de profondeur de cette fenêtre sur l'objet l'ayant retenu
			Cible[ Groupe ].FenetresZ[ Nom ] = null;
			
			// Détruit la fenêtre
			DestroyDiv( this.id );
		}
		
		
		// Durant la boucle de déplacement de la fenêtre ——>
		$( Nom + "Fenetre" ).Boucle = function(){
			
			// Si elle est en train d'être déplacée ————>
			if( this.move ){
				
				
				// Si on est plus appuyé sur la souris ————>
				if( nbrClick > 0 ){ 
					
					// Cesse le suivis de la souris
					this.move = false; 
					
					
					// Si elle est Fluide ————>
					if( this.Fluide ){
						
						// Transmes la vitesse de la souris à la fenêtre
						this.VitesseX = ( MouseSpeedX * 0.5 );
						this.VitesseY = ( MouseSpeedY * 0.5 );
						
					// Si elle n'est pas Fluide ————>
					} else {
						
						// S'arrête dessuite
						this.VitesseX = this.VitesseY = 0;
					}
				}
			
			
				// Récupére la position X,Y du curseur par rapport au décalage qu'il avait lorsqu'on a lancé la demande de déplacement
				this.X = MouseX + this.DecX;
				this.Y = MouseY + this.DecY;
				
				
				////// BORDURE
				
				// Si la fenêtre dépasse par le côté gauche ————>
				if( this.X < 0 ){ 
					
					// Positionne sur le bord gauche
					this.X = 0
					
					
				// Si la fenêtre dépasse par le côté droit à condition que la largeur de la fenêtre soit inférieur à celle de l'écran ————>
				} else if( this.X > ( getLargeurEcran() - W ) && getLargeurEcran() > this.Largeur ){
					
					// Positionne sur le bord droit
					this.X = ( getLargeurEcran() - W )
				}
				
				// Si la fenêtre dépasse par le côté haut ————>
				if( this.Y < Parametres.DecalageBarre * -1 ){ 
				
					// Positionne sur le bord haut
					this.Y = Parametres.DecalageBarre * -1;
					
				
				// Si la fenêtre dépasse par le bord bas à condition que la largeur de la fenêtre soit inférieur à celle de l'écran ————>
				// Quand elle est ouverte ————>
				} else if( this.Y > ( getHauteurEcran() - H ) && !this.reduit && getHauteurEcran() > this.Hauteur ){
					
					// Positionne sur le bord bas
					this.Y = ( getHauteurEcran() - H )
					
				// Quand elle est fermée ————>
				} else if( this.Y > ( getHauteurEcran() - ( Parametres.HauteurBarre + Parametres.DecalageBarre ) ) && this.reduit ){
					
					// Positionne sur le bord bas
					this.Y = ( getHauteurEcran() - ( Parametres.HauteurBarre + Parametres.DecalageBarre ) )
				}
				
				// Applique les nouvelles positions X,Y
				deplaceClip( this , this.X , this.Y );	
			
			
			
			// S'il est en train de subir une vitesse ————>
			} else if( Math.abs( this.VitesseX ) > 0 ||  Math.abs( this.VitesseY ) > 0 ) {
				
				// Applique la vitesse en X,Y
				this.X += this.VitesseX;
				this.Y += this.VitesseY;
				
				// Frein de Vitesse
				this.VitesseX *= 0.95;
				this.VitesseY *= 0.95;
				
				
				////// BORDURE
				
				// Si la fenêtre dépasse par le côté gauche ————>
				if( this.X < 0 ){ 
					
					// Positionne sur le bord gauche
					this.X = 0
					
					// Inverse la vitesse
					this.VitesseX *= -1;
					
					
				// Si la fenêtre dépasse par le côté droit à condition que l'écran soit plus grand que la fenêtre ————>
				} else if( this.X > ( getLargeurEcran() - W ) && getLargeurEcran() > this.Largeur ){
					
					// Positionne sur le bord droit
					this.X = ( getLargeurEcran() - W );
					
					// Inverse la vitesse
					this.VitesseX *= -1;
				}
				
				// Si la fenêtre dépasse par le côté haut ————>
				if( this.Y < Parametres.DecalageBarre * -1 ){ 
				
					// Positionne sur le bord haut
					this.Y = Parametres.DecalageBarre * -1;
					
					// Inverse la vitesse
					this.VitesseY *= -1;
					
				
				// Si la fenêtre dépasse par le bord bas à condition que l'écran soit plus grand que la fenêtre ————>
				// Quand elle est ouverte ————>
				} else if( this.Y > ( getHauteurEcran() - H ) && !this.reduit && getHauteurEcran() > this.Hauteur  ){
					
					// Positionne sur le bord bas
					this.Y = ( getHauteurEcran() - H )
					
					// Inverse la vitesse
					this.VitesseY *= -1;
					
				// Quand elle est fermée ————>
				} else if( this.Y > ( getHauteurEcran() - ( Parametres.HauteurBarre + Parametres.DecalageBarre ) ) && this.reduit ){
					
					// Positionne sur le bord bas
					this.Y = ( getHauteurEcran() - ( Parametres.HauteurBarre + Parametres.DecalageBarre ) );
					
					// Inverse la vitesse
					this.VitesseY *= -1;
				}
				
				// Si la vitesse est tombé trop bas, elle tombe à 0
				if( Math.abs( this.VitesseX ) < 0.2 ){ this.VitesseX = 0; }
				if( Math.abs( this.VitesseY ) < 0.2 ){ this.VitesseY = 0; }
				
				// Applique les nouvelles positions X,Y
				deplaceClip( this , this.X , this.Y );
			}
		}
		
		
		// Donne à la fenêtre sa boucle de déplacement
		addEnterFrame( $( Nom + "Fenetre" ) , "ENTER_FRAME" , "Boucle" , 0.1 );
		
		
		// Renvoie que la fenêtre a été créée
		return true;
	}
	
	// Si aucune fenêtre n'a été créé (Principalement parce qu'il y en a déjà une) renvoie faux
	return false;
}




/* ———————————————————————————————————————————— */
/*												*/
/*				GIVE AUTO PLACEMENT				*/
/*	Donne à une Div une boucle lui permettant	*/
/*	de se déplacer fluidement vers un point		*/
/*	définie via une fonction de cette Div.		*/
/*												*/
/*				Optimisé pour IE7				*/
/*			   Optimisé pour Safari				*/
/*												*/
/* ———————————————————————————————————————————— */

function GiveAutoPlacement( Div ,			// ————> La Div concernée
						    ContreVitesse ,	// ————> La Contre Vitesse appliquée
						    X , Y			// ————> La position X , Y initial de la Div ( Ne rien mettre pour qu'elle soit dans son X , Y actuelle )
						  ){
	
	// Arguments par défaut
	ContreVitesse = ContreVitesse || 30;
	//
	Div.X = X || Number( getStyle( Div , "left" ).split( "px" )[ 0 ] );
	Div.Y = Y || Number( getStyle( Div , "top" ).split( "px" )[ 0 ] );
	
	// Donne les Paramètres à la Div
	Div.CibleX = Div.X;
	Div.CibleY = Div.Y;
	//
	Div.ContreVitesse = ContreVitesse;
	
	// Positionne la Div
	Div.style.left = Div.X + "px";
	Div.style.top = Div.Y + "px";
	
	
	// Boucle de Mouvement de la Div //
	Div.MouvementAutoPlacement = function(){
		
		// Si sa position X et sa position X à avoir sont différentes ————>
		if( this.CibleX != this.X ){
			
			// Il se déplace vers sa position X à avoir
			this.X += Math.round( ( this.CibleX - this.X ) / this.ContreVitesse );
			
			// S'il n'est plus très loin de sa position X à avoir, il se place directement dessus
			if( Math.abs( this.CibleX - this.X ) <= 0.5 ){ this.X = this.CibleX; }
			
			// Applique la position X
			this.style.left = this.X + "px";
		}
		
		// Si sa position Y et sa position Y à avoir sont différentes ————>
		if( this.CibleY != this.Y ){
			
			// Il se déplace vers sa position Y à avoir
			this.Y += Math.round( ( this.CibleY - this.Y ) / this.ContreVitesse );
			
			// S'il n'est plus très loin de sa position Y à avoir, il se place directement dessus
			if( Math.abs( this.CibleY - this.Y ) <= 0.5 ){ this.Y = this.CibleY; }
			
			// Applique la position Y
			this.style.top = this.Y + "px";
		}
	}
	
	
	// Méthode à lancer pour donner la prochaine position à atteindre
	Div.AutoPlacement = function( X , Y ){
		
		// Si une position à atteindre n'est pas null ————>
		if( X != null && X != "" ){
			
			// S'il s'agit d'un String, on établie un calcul par rapport a la position en cour ————>
			if( String( X ).split( "ope" ).length > 1 ){ 
				try{ this.CibleX = eval( ( this.X + String( X ).split( "ope" )[ 1 ] ) ); }
				catch( err ){}
			}
			
			// Sinon, la Cible est directement la position
			else { this.CibleX = X; }
		}
		
		
		// Si une position à atteindre n'est pas null ————>
		if( Y != null && Y != "" ){
			
			// S'il s'agit d'un String, on établie un calcul par rapport a la position en cour ————>
			if( String( Y ).split( "ope" ).length > 1 ){ 
				try{ this.CibleY = eval( ( this.Y + String( Y ).split( "ope" )[ 1 ] ) ); }
				catch( err ){}
			}
			
			// Sinon, la Cible est directement la position
			else { this.CibleY = Y; }
		}
	}
	
	
	// Donne la boucle de déplacement
	addEnterFrame( Div , "BoucleAutoPlacement" , "MouvementAutoPlacement" , 0.1 );
}