////////////////////////////////////////////////////////////////////////////////////
// FONCTIONS DE GESTION DES LAYERS
////////////////////////////////////////////////////////////////////////////////////


// Détection du type de navigateur
var ns4 = (document.layers)? true:false;
var ns6 = (document.getElementById)? true:false;
var ie_all = (document.all)? true:false;
var ie4 = (document.all)? true:false;
var ie5 = (document.all)? true:false;
var ie6 = (document.all)? true:false;

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque
// DESCRIPTION COURTE :	
//		crée un calque dans un document en cours de création
// DESCRIPTION :	
//		crée un calque dans un document en cours de création dans la frame courante
// ENTREES :
//		@mon_calque (string) nom du calque
//		@mon_texte (string) texte initial du calque
//		@x (int) position x
//		@y (int) position y
//		@l (int) largeur
//		@h (int) hauteur
//		@est_visible (boolean) : indique si le calque doit être affiché
//			VALEURS :
//			* true : le calque est visible,
//			* false : le calque est invisible
//		@est_relatif (boolean) : indique si le calque doit être incrusté dans la page
//			VALEURS :
//			* true : le calque occupe une place dans la page et sa position
//				dépend des éléments qui l'entoure
//			* false : le calque est placé par dessus le reste de la page
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque( mon_calque, mon_texte, x, y, l, h, est_visible, est_relatif )
{
	return calque_frame( mon_calque, mon_texte, x, y, l, h, est_visible, est_relatif, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_frame
// DESCRIPTION COURTE :	
//		crée un calque dans un document en cours de création
// DESCRIPTION :	
//		crée un calque dans un document en cours de création avec spécification de frame
// ENTREES :
//		@mon_calque (string) nom du calque
//		@mon_texte (string) texte initial du calque
//		@x (int) position x
//		@y (int) position y
//		@l (int) largeur
//		@h (int) hauteur
//		@est_visible (boolean) : indique si le calque doit être affiché
//			VALEURS :
//			* true : le calque est visible,
//			* false : le calque est invisible
//		@est_relatif (boolean) : indique si le calque doit être incrusté dans la page
//			VALEURS :
//			* true : le calque occupe une place dans la page et sa position
//				dépend des éléments qui l'entoure
//			* false : le calque est placé par dessus le reste de la page
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_frame( mon_calque, mon_texte, x, y, l, h, est_visible, est_relatif, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 1;
	if( typeof( mon_texte ) == "undefined" )
		mon_texte = "";
	taille = '';
	if( ( typeof( l ) != "undefined" ) && ( typeof( h ) != "undefined" ) )
		taille = 'width:' + l + 'px; height:' + h + 'px; ';
	if( est_relatif != true )
		{
		ma_frame.document.write( '<DIV ID="' + mon_calque + '" STYLE="position:absolute; ' + taille + 'visibility:hidden; z-index:1;">' + mon_texte + '</DIV>' );
		if( ( typeof( x ) != "undefined" ) && ( typeof( y ) != "undefined" ) )
			calque_modifier_coordonnees_frame( mon_calque, x, y, ma_frame );
		}
	else
		ma_frame.document.write( '<DIV ID="' + mon_calque + '" STYLE="' + taille + 'visibility:hidden; z-index:1;">' + mon_texte + '</DIV>' );
	if( est_visible == true )
		calque_afficher_frame( mon_calque, ma_frame );
	else
		calque_cacher_frame( mon_calque, ma_frame );
	return 0;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_texte
// DESCRIPTION COURTE :	
//		modifier le contenu d'un calque
// DESCRIPTION :	
//		modifier le contenu d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@mon_texte (string) : texte initial du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_texte( mon_calque, mon_texte )
{
	return calque_modifier_texte_frame( mon_calque, mon_texte, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_texte_frame
// DESCRIPTION COURTE :	
//		modifier le contenu d'un calque
// DESCRIPTION :	
//		modifier le contenu d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@mon_texte (string) : texte initial du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_texte_frame( mon_calque, mon_texte, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 1;
	if( ns4 )
		{
		var mon_calque_tempo = ma_frame.document[mon_calque].document;
		mon_calque_tempo.write( mon_texte );
		mon_calque_tempo.close();
		}
	else if( ie_all )
		{
		ma_frame.document.all[mon_calque].innerHTML = mon_texte;
		}
	else if( ns6 )
		{
		ma_frame.document.getElementById( mon_calque ).innerHTML = mon_texte;
		}
	return 0;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_texte_frame
// DESCRIPTION COURTE :	
//		lire le contenu d'un calque
// DESCRIPTION :	
//		lire le contenu d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (string) : texte courant du calque
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_texte( mon_calque )
{
	return calque_lire_texte_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_texte_frame
// DESCRIPTION COURTE :	
//		lire le contenu d'un calque
// DESCRIPTION :	
//		lire le contenu d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (string) : texte courant du calque
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_texte_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return "";
	if( ns4 )
		{
		var mon_calque_tempo = ma_frame.document[mon_calque].document;
		mon_texte = "";
		}
	else if( ie_all )
		{
		mon_texte = ma_frame.document.all[mon_calque].innerHTML;
		}
	else if( ns6 )
		{
		mon_texte = ma_frame.document.getElementById( mon_calque ).innerHTML;
		}
	return mon_texte;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_afficher_frame
// DESCRIPTION COURTE :	
//		afficher un calque
// DESCRIPTION :	
//		afficher un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_afficher( mon_calque )
{
	return calque_afficher_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_afficher_frame
// DESCRIPTION COURTE :	
//		afficher un calque
// DESCRIPTION :	
//		afficher un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_afficher_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 1;
	if( ns4 )
		ma_frame.document[mon_calque].visibility = "show";
	else if( ie_all )
		ma_frame.document.all[mon_calque].style.visibility = "visible";
	else if( ns6 )
		ma_frame.document.getElementById( mon_calque ).style.visibility = "visible";
	return 0;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_cacher
// DESCRIPTION COURTE :	
//		cacher un calque
// DESCRIPTION :	
//		cacher un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_cacher( mon_calque )
{
	return calque_cacher_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_cacher_frame
// DESCRIPTION COURTE :	
//		cacher un calque
// DESCRIPTION :	
//		cacher un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_cacher_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 1;
	if( ns4 )
		ma_frame.document[mon_calque].visibility = "hide";
	else if( ie_all )
		ma_frame.document.all[mon_calque].style.visibility = "hidden";
	else if( ns6 )
		ma_frame.document.getElementById( mon_calque ).style.visibility = "hidden";
	return 0;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_est_visible
// DESCRIPTION COURTE :	
//		lire l'état du calque
// DESCRIPTION :	
//		lire l'état du calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* true : le calque est visible
//		* false : le calque est invisible
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_est_visible( mon_calque )
{
	return calque_est_visible_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_est_visible_frame
// DESCRIPTION COURTE :	
//		lire l'état du calque
// DESCRIPTION :	
//		lire l'état du calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* true : le calque est visible
//		* false : le calque est invisible
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_est_visible_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 1;
	if( ns4 )
		etat = ma_frame.document[mon_calque].visibility;
	else if( ie_all )
		etat = ma_frame.document.all[mon_calque].style.visibility;
	else if( ns6 )
		etat = ma_frame.document.getElementById( mon_calque ).style.visibility;
	if( etat.charAt(0) == "v" )
		return true;
	return false;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_coordonnees_frame
// DESCRIPTION COURTE :	
//		modifier les coordonnées d'un calque
// DESCRIPTION :	
//		modifier les coordonnées d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@x (int) : position x
//		@y (int) : position y
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_coordonnees( mon_calque, x, y )
{
	return calque_modifier_coordonnees_frame( mon_calque, x, y, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_coordonnees_frame
// DESCRIPTION COURTE :	
//		modifier les coordonnées d'un calque
// DESCRIPTION :	
//		modifier les coordonnées d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@x (int) : position x
//		@y (int) : position y
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_coordonnees_frame( mon_calque, x, y, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) ||
			( typeof( x ) == "undefined" ) ||
			( typeof( y ) == "undefined" ) )
		return 1;
	x = Math.round( x );
	y = Math.round( y );
	if( ns4 )
		{
		ma_frame.document.mon_calque.left = x;
		ma_frame.document.mon_calque.top = y;
		}
	else if( ie_all )
		{
		ma_frame.document.all[mon_calque].style.left = x;
		ma_frame.document.all[mon_calque].style.top = y;
		}
	else if( ns6 )
		{
		ma_frame.document.getElementById( mon_calque ).style.left = x + "px";
		ma_frame.document.getElementById( mon_calque ).style.top = y + "px";
		}
	return 0;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_x_frame
// DESCRIPTION COURTE :	
//		lire la position x d'un calque
// DESCRIPTION :	
//		lire la position x d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : position x du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_x( mon_calque )
{
	return calque_lire_x_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_x_frame
// DESCRIPTION COURTE :	
//		lire la position x d'un calque
// DESCRIPTION :	
//		lire la position x d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : position x du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_x_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		x = ma_frame.document.mon_calque.left;
	else if( ie_all )
		x = ma_frame.document.all[mon_calque].style.left;
	else if( ns6 )
		x = ma_frame.document.getElementById( mon_calque ).style.left;
	if( x == "" )
		return 0;
	return parseInt( x );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_y_frame
// DESCRIPTION COURTE :	
//		lire la position y d'un calque
// DESCRIPTION :	
//		lire la position y d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : position y du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_y( mon_calque )
{
	return calque_lire_y_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_y_frame
// DESCRIPTION COURTE :	
//		lire la position y d'un calque
// DESCRIPTION :	
//		lire la position y d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : position y du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_y_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		y = ma_frame.document.mon_calque.top;
	else if( ie_all )
		y = ma_frame.document.all[mon_calque].style.top;
	else if( ns6 )
		y = ma_frame.document.getElementById( mon_calque ).style.top;
	if( y == "" )
		return 0;
	return parseInt( y );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_taille_frame
// DESCRIPTION COURTE :	
//		modifier les coordonnées d'un calque
// DESCRIPTION :	
//		modifier les coordonnées d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@l (int) : largeur
//		@h (int) : hauteur
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_taille( mon_calque, l, h )
{
	return calque_modifier_taille_frame( mon_calque, l, h, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_taille_frame
// DESCRIPTION COURTE :	
//		modifier les coordonnées d'un calque
// DESCRIPTION :	
//		modifier les coordonnées d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@l (int) : largeur
//		@h (int) : hauteur
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_taille_frame( mon_calque, l, h, ma_frame )
{
	if( ( mon_calque == "" ) || ( typeof( mon_calque ) == "undefined" ) ||
			( typeof( l ) == "undefined" ) ||
			( typeof( h ) == "undefined" ) )
		return 1;
	l = Math.round( l );
	h = Math.round( h );
	if( ns4 )
		{
		ma_frame.document.mon_calque.width = l;
		ma_frame.document.mon_calque.height = h;
		}
	else if( ie_all )
		{
		ma_frame.document.all[mon_calque].style.width = l;
		ma_frame.document.all[mon_calque].style.height = h;
		}
	else if( ns6 )
		{
		ma_frame.document.getElementById( mon_calque ).style.width = l + "px";
		ma_frame.document.getElementById( mon_calque ).style.height = h + "px";
		}
	return 0;
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_largeur_frame
// DESCRIPTION COURTE :	
//		lire la largeur d'un calque
// DESCRIPTION :	
//		lire la largeur d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : largeur du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_largeur( mon_calque )
{
	return calque_lire_largeur_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_largeur_frame
// DESCRIPTION COURTE :	
//		lire la largeur d'un calque
// DESCRIPTION :	
//		lire la largeur d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : largeur du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_largeur_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		l = ma_frame.document.mon_calque.width;
	else if( ie_all )
		l = ma_frame.document.all[mon_calque].style.width;
	else if( ns6 )
		l = ma_frame.document.getElementById( mon_calque ).style.width;
	if( l == "" )
		return 0;
	return parseInt( l );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_hauteur_frame
// DESCRIPTION COURTE :	
//		lire la hauteur d'un calque
// DESCRIPTION :	
//		lire la hauteur d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : hauteur du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_hauteur( mon_calque )
{
	return calque_lire_hauteur_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_hauteur_frame
// DESCRIPTION COURTE :	
//		lire la hauteur d'un calque
// DESCRIPTION :	
//		lire la hauteur d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : hauteur du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_hauteur_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		h = ma_frame.document.mon_calque.height;
	else if( ie_all )
		h = ma_frame.document.all[mon_calque].style.height;
	else if( ns6 )
		h = ma_frame.document.getElementById( mon_calque ).style.height;
	if( h == "" )
		return 0;
	return parseInt( h );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_largeur_client_frame
// DESCRIPTION COURTE :	
//		lire la largeur du "client" d'un calque
// DESCRIPTION :	
//		lire la largeur du "client" d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : largeur du "client" du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_largeur_client( mon_calque )
{
	return calque_lire_largeur_client_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_largeur_client_frame
// DESCRIPTION COURTE :	
//		lire la largeur du "client" d'un calque
// DESCRIPTION :	
//		lire la largeur du "client" d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : largeur du "client" du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_largeur_client_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		l = ma_frame.document.mon_calque.width;
	else if( ie_all )
		l = ma_frame.document.all[mon_calque].clientWidth;
	else if( ns6 )
		l = ma_frame.document.getElementById( mon_calque ).style.width;
	if( l == "" )
		return 0;
	return parseInt( l );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_hauteur_client_frame
// DESCRIPTION COURTE :	
//		lire la hauteur du "client" d'un calque
// DESCRIPTION :	
//		lire la hauteur du "client" d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : hauteur du "client" du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_hauteur_client( mon_calque )
{
	return calque_lire_hauteur_client_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_hauteur_client_frame
// DESCRIPTION COURTE :	
//		lire la hauteur du "client" d'un calque
// DESCRIPTION :	
//		lire la hauteur du "client" d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : hauteur du "client" du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_hauteur_client_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		h = ma_frame.document.mon_calque.height;
	else if( ie_all )
		h = ma_frame.document.all[mon_calque].scrollHeight;
	else if( ns6 )
//		h = ma_frame.document.getElementById( mon_calque ).style.height;
		h = ma_frame.document.getElementById( mon_calque ).scrollHeight
	if( h == "" )
		return 0;
	return parseInt( h );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_zindex_frame
// DESCRIPTION COURTE :	
//		lire la profondeur d'un calque
// DESCRIPTION :	
//		lire la profondeur d'un calque dans la frame courante
// ENTREES :
//		@ mon_calque (string) : nom du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : hauteur du "client" du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_zindex( mon_calque )
{
	return calque_lire_zindex_frame( mon_calque, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_lire_zindex_frame
// DESCRIPTION COURTE :	
//		lire la profondeur d'un calque
// DESCRIPTION :	
//		lire la profondeur d'un calque avec spécification de frame
// ENTREES :
//		@ mon_calque (string) : nom du calque
//		@ ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* (int) : hauteur du "client" du calque
//		* 0 : erreur dans le paramètre "mon_calque"
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_lire_zindex_frame( mon_calque, ma_frame )
{
	if( ( mon_calque == "" ) ||	( typeof( mon_calque ) == "undefined" ) )
		return 0;
	if( ns4 )
		z = ma_frame.document.mon_calque.zIndex;
	else if( ie_all )
		z = ma_frame.document.all[mon_calque].style.zIndex;
	else if( ns6 )
		z = ma_frame.document.getElementById( mon_calque ).style.zIndex;
	if( z == "" )
		return 0;
	return parseInt( z );
}



//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_zindex_frame
// DESCRIPTION COURTE :	
//		modifier la profondeur d'un calque
// DESCRIPTION :	
//		modifier la profondeur d'un calque dans la frame courante
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@z (int) : nouvelle profondeur du calque
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque" 
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_zindex( mon_calque, z )
{
	return calque_modifier_zindex_frame( mon_calque, z, self );
}

//---------------------------------------------------------------------------------------
// NOM FONCTION : calque_modifier_zindex_frame
// DESCRIPTION COURTE :	
//		modifier la profondeur d'un calque
// DESCRIPTION :	
//		modifier la profondeur d'un calque avec spécification de frame
// ENTREES :
//		@mon_calque (string) : nom du calque
//		@z (int) : nouvelle profondeur du calque
//		@ma_frame (object) : pointeur vers la frame concernée
// NECESSITES :
//		néant
// SORTIES :
//		néant
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* 1 : erreur dans le paramètre "mon_calque" 
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 14/02/2005
// ETAT : ok
// RESTE A FAIRE :
// REMARQUES :
// VOIR AUSSI :
//		
//---------------------------------------------------------------------------------------
function calque_modifier_zindex_frame( mon_calque, z, ma_frame )
{
	if( ( mon_calque == "" ) || ( typeof( mon_calque ) == "undefined" ) ||
			( typeof( z ) == "undefined" ) )
		return 1;
	z = Math.round( z );
	if( ns4 )
		ma_frame.document.mon_calque.zIndex = z;
	else if( ie_all )
		ma_frame.document.all[mon_calque].style.zIndex = z;
	else if( ns6 )
		ma_frame.document.getElementById( mon_calque ).style.zIndex = z;
	return 0;
}




// -------------------
// programme principal
// -------------------
if( typeof( top.info_chargement ) != "undefined" )
	if( top.info_chargement["lib_calques"] != true )
		{
		top.info_chargement["nombre_js"]++;
		top.info_chargement["lib_calques"] = true;
		}


function placer_layer()
{
}

var drag_and_drop__donnees = null;
function drag_and_drop( objet, x_min, y_min, x_max, y_max, fonction )
{
	if( drag_and_drop__donnees == null )
		{
		drag_and_drop__donnees = new Array();
		drag_and_drop__donnees["objet"] = objet;
		drag_and_drop__donnees["x_min"] = x_min;
		drag_and_drop__donnees["y_min"] = y_min;
		drag_and_drop__donnees["x_max"] = x_max;
		drag_and_drop__donnees["y_max"] = y_max;
		drag_and_drop__donnees["x_diff"] = calque_lire_x( objet.id ) - souris_x;
		drag_and_drop__donnees["y_diff"] = calque_lire_y( objet.id ) - souris_y;
		drag_and_drop__donnees["fonction"] = fonction;
		setTimeout( "drag_and_drop__gestion();", 10 );
		}
}

function drag_and_drop__gestion()
{
	var pos_x = souris_x + drag_and_drop__donnees["x_diff"]
	var pos_y = souris_y + drag_and_drop__donnees["y_diff"]

window.status = souris_b;

	if( souris_b == 0 )
		{
		drag_and_drop__donnees = null;
		return;
		}

	if( pos_x < drag_and_drop__donnees["x_min"] )
		pos_x = drag_and_drop__donnees["x_min"];
	if( pos_x > drag_and_drop__donnees["x_max"] )
		pos_x = drag_and_drop__donnees["x_max"];

	if( pos_y < drag_and_drop__donnees["y_min"] )
		pos_y = drag_and_drop__donnees["y_min"];
	if( pos_y > drag_and_drop__donnees["y_max"] )
		pos_y = drag_and_drop__donnees["y_max"];

	calque_modifier_coordonnees( drag_and_drop__donnees["objet"].id, pos_x, pos_y );

	eval( drag_and_drop__donnees["fonction"] + "();" );

	setTimeout( "drag_and_drop__gestion();", 10 );
}