function findPos(obj) {
var curleft = curtop = 0;
if (obj.offsetParent) {
curleft = obj.offsetLeft
curtop = obj.offsetTop
while (obj = obj.offsetParent) {
curleft += obj.offsetLeft
curtop += obj.offsetTop
}
}
return [curleft,curtop];
}
/* iubito's menu - http://iubito.free.fr/prog/menu.php - configuration du javascript */
/* true = le menu sera vertical, à gauche.
false = le menu sera horizontal, en haut. */
var vertical = false;
/* Centrer le menu ? (true/false).
Centre horizontalement ou verticalement suivant le mode choisi. */
var centrer_menu = false;
/* On est obligé de définir une largeur pour les menus.
Pour mettre des menus de largeurs différentes :
var largeur_menu = new Array(largeur menu1, largeur menu2, largeur menu3...)
Il faut faire attention à mettre autant de valeurs que de nombre de menu !
Attention, si vous êtes en menu vertical, mettez une largeur fixe (pas de Array) !
*/
var largeur_menu = 87;
/* En mode vertical, on a besoin de connaître la hauteur de chaque menu.
Même si les "cases" ne sont pas dimensionnées en hauteur.
Ajustez cette variable si les menus sont trop rapprochés ou espacés en vertical.
Pour mettre des menus de hauteurs différentes :
var hauteur_menu = new Array(hauteur menu1, hauteur menu2, hauteur menu3...)
Il faut faire attention à mettre autant de valeurs que de nombre de menu !
Attention, si vous êtes en menu horizontal, mettez une largeur fixe (pas de Array) !
*/
var hauteur_menu = 25;
/* En mode horizontal.
Largeur des sous-menus, pour IE uniquement, les autres navigateurs respectent la largeur
auto. Mettez "auto" uniquement si vous êtes sûr d'avoir mis des   à la place des
espace dans les items !
Pour mettre des sous-menus de largeurs différentes :
var largeur_sous_menu = new Array(largeur1, largeur2...).
Il faut faire attention à mettre autant de valeurs que de menus.
Si un menu n'a pas de sous-menus, il faut mettre quand même quelque chose !
Il est possible de mettre "auto" dans certaines colonnes, à condition de respecter la
consigne ci-dessus.
*/
var largeur_sous_menu = 150;
/* Pour les navigateurs connaissant la largeur automatique (s'adapte au contenu), cette
option (active par défaut) permet d'avoir une largeur automatique. En cas contraire
(false), les sous menus auront la largeur largeur_sous_menu. */
var largeur_auto_ssmenu = true;
/* ... pour mettre un peu d'espace entre les menus ! */
var espace_entre_menus = 5;
/* position du menu par rapport au haut de l'écran ou de la page.
0 = le menu est tout en haut. en px */
var top_menu = 2;
/* En version horizontale.
position des sous-menus par rapport au haut de l'écran ou de la page. Il faut prévoir
la hauteur des menus, donc ne pas mettre 0 et faire "à tâton". en px */
var top_ssmenu = top_menu + 18;
/* Position gauche du menu, en px. */
var left_menu = 0;
/* En version verticale.
Position des sous-menus par rapport au bord gauche de l'écran. */
var left_ssmenu = largeur_menu+5;
/* Quand la souris quitte un sous-menu, si le sous-menu disparait immédiatement,
cela gêne l'utilisateur. Alors on peut mettre un délai avant disparition du sous-menu.
500 ms c'est bien :-) */
var delai = 650; // en milliseconde
/* En version horizontale.
Comme le menu peut se superposer avec le texte de la page, il est possible de faire
descendre un peu la page (on augmente la marge du haut) pour aérer un peu la page,
une quarantaine de pixel c'est pas mal. en px*/
var marge_en_haut_de_page = top_menu + 0;
/* En version verticale.
On décale le document à droite pour pas que le menu le superpose. */
var marge_a_gauche_de_la_page = largeur_menu + 0;
/* Mettez à true si vous souhaitez que le menu soit toujours visible.
Mettez false si vous ne le souhaitez pas, dans ce cas le menu "disparaîtra" quand vous
descendrez dans la page. */
var suivre_le_scroll=true;
/* Pour IE uniquement, les balises <select> passent toujours au-dessus du menu, donc
par défaut on cache les listes déroulantes quand le menu est ouvert, puis on les fait
réapparaître à la fermeture du menu. Pour empêcher ça, mettre à false. */
var cacher_les_select=true;
var nbmenu = 0; //Auto-calculé
var timeout; //ne pas toucher, c'est pour déclarer la variable
var agt = navigator.userAgent.toLowerCase();
var isMac = (agt.indexOf('mac') != -1);
var isOpera = (agt.indexOf('opera') != -1);
var IEver = parseInt(agt.substring(agt.indexOf('msie ') + 5));
var isIE = ((agt.indexOf('msie')!=-1 && !isOpera && (agt.indexOf('webtv')==-1)) && !isMac);
var isIE5win = (isIE && IEver >= 5);
var isIE5mac = ((agt.indexOf('msie') != -1) && isMac);
var isSafari = (agt.indexOf('safari') != -1);
//pour enlever les "px" pour faire des calculs...
var reg = new RegExp("px", "g");
// onScroll pour Internet Explorer, le position:fixed fait ce boulot pour les autres navigateurs
// qui respectent les normes CSS...
window.onscroll = function()
{
if (suivre_le_scroll && (isIE || isIE5mac))
{
if (isIE5mac) document.getElementById("conteneurmenu").style.visibility="hidden";
var cumul=0;
for(i=1;i<=nbmenu;i++)
{
var scrollTop = (document.documentElement&&document.documentElement.scrollTop
?document.documentElement.scrollTop
:document.body.scrollTop);
if (!vertical) {
document.getElementById("menu"+i).style.top = scrollTop + top_menu + "px";
if (document.getElementById("ssmenu"+i))//undefined
document.getElementById("ssmenu"+i).style.top = scrollTop + top_ssmenu + "px";
} else {
document.getElementById("menu"+i).style.top = scrollTop
+(((i-1)*espace_entre_menus)+cumul+1+top_menu)+"px";
if (document.getElementById("ssmenu"+i))//undefined
document.getElementById("ssmenu"+i).style.top = scrollTop
+(((i-1)*espace_entre_menus)+cumul+1+top_menu)+"px";
cumul += isFinite(hauteur_menu)?hauteur_menu:hauteur_menu[i-1];
}
}
if (isIE5mac) document.getElementById("conteneurmenu").style.visibility="visible";
}
}
function preChargement()
{
if (document.getElementById("conteneurmenu"))
document.getElementById("conteneurmenu").style.visibility="hidden";
}
function Chargement() {
//Compte nbmenu
nbmenu = 0;
while (document.getElementById("menu"+(nbmenu+1)))
nbmenu++;
document.getElementById("conteneurmenu").style.visibility="hidden";
trimespaces();
with(document.body.style) {
//		if (!vertical) marginTop=marge_en_haut_de_page+"px";
//		else		   marginLeft=marge_a_gauche_de_la_page+"px";
}
positionne();
CacherMenus();
//pour Safari, qui a du mal à afficher le menu parfois, le fait de changer la taille
//des caractères corrige le problème. Merci Stol ! http://iubito.free.fr/forum/read.php?id=705&f=2
if(isSafari)
document.getElementById('conteneurmenu').style.fontSize='10px';
// comme on a évité le clignotement, maintenant on fait apparaître le menu ;-)
document.getElementById("conteneurmenu").style.visibility='';
}
window.onresize = Chargement;
/*
* Place les éléments du menu correctement, au chargement, au scroll, au redimensionnement
* de la fenêtre
*/
function positionne() {
//Calcul hauteur et largeur fenêtre compatible avec certains doctypes IE
var largeur_fenetre;
if (document.documentElement && document.documentElement.clientWidth) {
largeur_fenetre = document.documentElement.clientWidth;
} else if (document.body && document.body.clientWidth) {
largeur_fenetre = document.body.clientWidth;
} else if (window.innerWidth) {
largeur_fenetre = window.innerWidth;
}
var hauteur_fenetre;
if (document.documentElement && document.documentElement.clientHeight) {
hauteur_fenetre = document.documentElement.clientHeight;
} else if (document.body && document.body.clientHeight) {
hauteur_fenetre = document.body.clientHeight;
} else if (window.innerHeight) {
hauteur_fenetre = window.innerHeight;
}
if (centrer_menu) {
if (!vertical) {
var largeur_totale = espace_entre_menus * (nbmenu-1);
if (isFinite(largeur_menu))
largeur_totale += largeur_menu * nbmenu;
else {
for (i = 1; i <= nbmenu; i++)
largeur_totale += largeur_menu[i-1];
}
left_menu = (largeur_fenetre - largeur_totale)/2;
} else {
var hauteur_totale = espace_entre_menus * (nbmenu-1);
if (isFinite(hauteur_menu))
hauteur_totale += hauteur_menu * nbmenu;
else {
for (i = 1; i <= nbmenu; i++)
hauteur_totale += hauteur_menu[i-1];
}
top_menu = (hauteur_fenetre - hauteur_totale)/2;
}
}
/*	
//Menus
var cumul = 0;
for(i=1;i<=nbmenu;i++) {
with(document.getElementById("menu"+i).style) {
if (!vertical) {
top=top_menu+"px";
left=(((i-1)*espace_entre_menus)+cumul+1+left_menu)+"px";
} else {
top=(((i-1)*espace_entre_menus)+cumul+1+top_menu)+"px";
left=left_menu+"px";
}
//			if (!suivre_le_scroll || isIE || isIE5mac)
//				position="absolute";
//			else position="fixed";
//if (vertical) height=hauteur_menu+"px";
margin="0";
zIndex="2";
if (vertical || isFinite(largeur_menu))
width=largeur_menu+"px";
else
width=largeur_menu[i-1]+"px";
if ((!vertical && isFinite(largeur_menu)) || (vertical && isFinite(hauteur_menu))) {
cumul += (!vertical?largeur_menu:hauteur_menu);
}
else {
cumul += (!vertical?largeur_menu[i-1]:hauteur_menu[i-1]);
if (vertical) height=hauteur_menu[i-1]+"px";
}
}
}
*/	
var ma_position = findPos( document.getElementById('conteneurmenu').offsetParent );
//Sous-menus
if (!isIE)
cumul = ma_position[0] + 200;
else
{
cumul = 0;
espace_entre_menus=0;
}
for(i=1;i<=nbmenu;i++) {
if (document.getElementById("ssmenu"+i))//undefined
{
with(document.getElementById("ssmenu"+i).style) {
if (!suivre_le_scroll || isIE || isIE5mac)
position="absolute";
else position="fixed";
if (!vertical) {
top=top_ssmenu+"px";
left=(((i-1)*espace_entre_menus)+cumul+1+left_menu)+"px";
} else {
left=left_ssmenu+"px";
top=(((i-1)*espace_entre_menus)+cumul+1+top_menu)+"px";
}
if (isIE || isOpera || isIE5mac || !largeur_auto_ssmenu) {
if (isFinite(largeur_sous_menu))
width = largeur_sous_menu+(largeur_sous_menu!="auto"?"px":"");
else
width = largeur_sous_menu[i-1]+(largeur_sous_menu[i-1]!="auto"?"px":"");
}
else width = "auto";
if (!vertical && !isIE5mac) {
//repositionnement si déborde à droite
if ((width != "auto")
&& ((left.replace(reg,'').valueOf()*1 + width.replace(reg,'').valueOf()*1) > largeur_fenetre))
left = (largeur_fenetre-width.replace(reg,'').valueOf())+"px";
}
margin="0";
zIndex="3";
}
}
if ((!vertical && isFinite(largeur_menu)) || (vertical && isFinite(hauteur_menu))) {
cumul += (!vertical?largeur_menu:hauteur_menu);
}
else {
cumul += (!vertical?largeur_menu[i-1]:hauteur_menu[i-1]);
}
}
}
function MontrerMenu(strMenu) {
AnnulerCacher();
CacherMenus();
if (document.getElementById(strMenu))//undefined
with (document.getElementById(strMenu).style)
visibility="visible";
SelectVisible("hidden",document.getElementsByTagName('select'));
}
function CacherDelai() {
timeout = setTimeout('CacherMenus()',delai);
}
function AnnulerCacher() {
if (timeout) {
clearTimeout(timeout);
}
}
function CacherMenus() {
for(i=1;i<=nbmenu;i++) {
if (document.getElementById("ssmenu"+i))//undefined
with(document.getElementById("ssmenu"+i).style)
visibility="hidden";
}
SelectVisible("visible",document.getElementsByTagName('select'));
}
function trimespaces() {
//Contourne un bug d'IE5/win... il ne capte pas bien les css pour les <li>, donc on les vire !
if(isIE5win) {
for(i=1;i<=nbmenu;i++) {
if (document.getElementById("ssmenu"+i))//undefined
with(document.getElementById("ssmenu"+i))
innerHTML = innerHTML.replace(/<LI>|<\/LI>/g,"");
}
}
}
function SelectVisible(v,elem) {
if (cacher_les_select && (isIE||isIE5win))
for (var i=0;i<elem.length;i++) elem[i].style.visibility=v;
}

// ***************************************************************************************************************
// ***************************************************************************************************************
// Librairie principale
// ***************************************************************************************************************
// ***************************************************************************************************************
// regroupe toutes les fonctions générales ainsi que les fonctions d'accès aux éléments DOM
// ***************************************************************************************************************
// ***************************************************************************************************************
// code pour conserver le codage UTF-8 dans C-génie : éàè
//---------------------------------------------------------------------------------------
// VARIABLES GLOBALES :
//		@profondeur_recursivite_max (int) : indique la profondeur maximale autorisée pour la fonction "convertir_objet_en_texte"
//---------------------------------------------------------------------------------------
var profondeur_recursivite_max=10;
//---------------------------------------------------------------------------------------
// NOM FONCTION : copy_array
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function copy_array( source )
{
// --------------
// initialisation
// --------------
var destination = new Array();
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
for( var indice in source )
if( ( typeof( source[indice] ) == "object" ) || ( typeof( source[indice] ) == "array" ) )
destination[indice] = copy_array( source[indice] );
else
destination[indice] = source[indice];
return destination;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : supprimer_eventbubble
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function supprimer_eventbubble( event )
{
// --------------
// initialisation
// --------------
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
if( typeof( window.event ) != 'undefined' )
window.event.cancelBubble = true;
else
event.cancelBubble = true; 
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
if( typeof( HTMLElement ) != "undefined" )
{
HTMLElement.prototype.__defineSetter__("innerText", function (sText_old) {
var sText = new String( sText_old );
this.innerHTML = sText.replace(/\&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
});
HTMLElement.prototype.__defineGetter__("innerText", function () {
var r = this.ownerDocument.createRange();
r.selectNodeContents(this);
return r.toString();
});
HTMLElement.prototype.__defineGetter__("outerHTML", function () {
var _emptyTags = {
"IMG":   true,
"BR":    true,
"INPUT": true,
"META":  true,
"LINK":  true,
"PARAM": true,
"HR":    true
};
var attrs = this.attributes;
var str = "<" + this.tagName;
for (var i = 0; i < attrs.length; i++)
str += " " + attrs[i].name + "=\"" + attrs[i].value + "\"";
if (_emptyTags[this.tagName])
return str + ">";
return str + ">" + this.innerHTML + "</" + this.tagName + ">";
});
HTMLElement.prototype.__defineSetter__("outerHTML", function (sHTML) {
var r = this.ownerDocument.createRange();
r.setStartBefore(this);
var df = r.createContextualFragment(sHTML);
this.parentNode.replaceChild(df, this);
});
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : xreplace
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function xreplace( chaine_a_traiter, a_remplacer, remplacer_par )
{
// --------------
// initialisation
// --------------
var chaine_finale = "";
var deb_capture = 0;
var fin_capture = 0;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
fin_capture = chaine_a_traiter.indexOf( a_remplacer );
while( fin_capture > -1 )
{
chaine_finale += chaine_a_traiter.substring( deb_capture, fin_capture );
chaine_finale += remplacer_par;
deb_capture = fin_capture + a_remplacer.length
fin_capture = chaine_a_traiter.indexOf( a_remplacer, deb_capture );
}
chaine_finale += chaine_a_traiter.substring( deb_capture );
return chaine_finale + "";
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : hasAttribute
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function hasAttribute( objet, nom_attribut )
{
// --------------
// initialisation
// --------------
var retour = false;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
if( document.all )
{
if( nom_attribut == "class" )
nom_attribut = "className";
}
else if( nom_attribut == "className" )
nom_attribut = "class";
// -----------
// traitements
// -----------
try // code compatible DOM
{
retour = objet.hasAttribute( nom_attribut );
}
catch( ex ) // patch fait pour IE
{
if( typeof( objet[nom_attribut] ) != "undefined" )
retour = true;
else
retour = false;
}
return retour;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : getAttribute
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function getAttribute( objet, nom_attribut )
{
// --------------
// initialisation
// --------------
var retour = null;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
if( document.all )
{
if( nom_attribut == "class" )
nom_attribut = "className";
}
else if( nom_attribut == "className" )
nom_attribut = "class";
// -----------
// traitements
// -----------
try
{
retour = objet.getAttribute( nom_attribut );
}
catch( ex )
{
if( typeof( objet[nom_attribut] ) != "undefined" )
retour = objet[nom_attribut];
else
retour = null;
}
return retour;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : setAttribute
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function setAttribute( objet, nom_attribut, valeur )
{
// --------------
// initialisation
// --------------
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
if( document.all )
{
if( nom_attribut == "class" )
nom_attribut = "className";
}
else if( nom_attribut == "className" )
nom_attribut = "class";
// -----------
// traitements
// -----------
try
{
objet.setAttribute( nom_attribut, valeur );
}
catch( ex )
{
objet[nom_attribut] = valeur;
}
return true;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : removeAttribute
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function removeAttribute( objet, nom_attribut )
{
// --------------
// initialisation
// --------------
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
if( document.all )
{
if( nom_attribut == "class" )
nom_attribut = "className";
}
else if( nom_attribut == "className" )
nom_attribut = "class";
// -----------
// traitements
// -----------
try
{
objet.removeAttribute( nom_attribut );
}
catch( ex )
{
}
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : getElementsByAttribute
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function getElementsByAttribute( nom_attribut, valeur )
{
// --------------
// initialisation
// --------------
var tabRetour = new Array();
var tabTmp = new Array();
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
tabTmp = document.body.getElementsByTagName( "*" );
j=0;
for (i=0; i<tabTmp.length; i++)
if( hasAttribute( tabTmp[i], nom_attribut ) )
if( ( typeof( valeur ) == "undefined" )
|| ( getAttribute( tabTmp[i], nom_attribut ) == valeur ) ) 
{
tabRetour[j] = tabTmp[i];
j++;
}
return tabRetour; 
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : ajouter_evenement
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function ajouter_evenement( objet, evenement, fonction )
{
// --------------
// initialisation
// --------------
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
if( document.all )
objet.attachEvent( 'on' + evenement, fonction );
else
objet.addEventListener( evenement, fonction, false );
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
// Parcourt un objet ou un tableau et le transforme en une chaine de texte présentée (= print_r en PHP)
// Gère 
//		- les tableaux imbriqués
// 		- les types inconnus
// 		- un niveau de profondeur d'exploration maximum réglé en variable globale
// 		- les objets vides
//---------------------------------------------------------------------------------------
// NOM FONCTION : convertir_objet_en_texte
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function convertir_objet_en_texte( objet, profondeur_recursivite )
{
// --------------
// initialisation
// --------------
var texte;
var texte_retour = "";
var objet_vide = true;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
if( typeof( profondeur_recursivite ) != "number" ) // rend le paramètre optionnel
profondeur_recursivite = 0;
if( typeof( objet ) == "object" )
texte = "Objet :";
else
texte = "Tableau :";
for( var indice in objet )
{
objet_vide = false;
if( ( typeof( objet[indice] ) == "object" ) || ( typeof( objet[indice] ) == "array" ) )
{
texte_retour = "";
if( profondeur_recursivite < profondeur_recursivite_max )
{
texte_retour = convertir_objet_en_texte( objet[indice], profondeur_recursivite + 1 );
texte_retour = xreplace( texte_retour, "\r\n", "\r\n\t\t" );
}
else
texte_retour = "Objet : -- PROFONDEUR MAX (" + profondeur_recursivite + ") DEPASSEE -> exploration non effectuée. --";
}
else
{
if( typeof( objet[indice] ) == "unknown" )
texte_retour = "-- TYPE INCONNU -- ";
else
texte_retour = objet[indice];
}
texte = texte + "\r\n\t\t[" + indice + "] => " + texte_retour;
}
if( objet_vide == true )
texte = texte + " -- VIDE -- ";
return texte;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : debug
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 10/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function debug( variable )
{
// --------------
// initialisation
// --------------
var texte = "";
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
var type = typeof( variable );
if( ( type == "object" ) || ( type == "array" ) )
texte = convertir_objet_en_texte( variable );
else
texte = variable;
if( document.getElementById( "debug" ) == null )
{
var mon_div = document.createElement( "DIV" );
mon_div.className = "debug";
mon_div.id = "debug";
document.body.appendChild( mon_div );
document.getElementById( "debug" ).innerText = "Zone de Debug\r\n";
}
document.getElementById( "debug" ).innerText += "\r\n" + texte;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : FormatNumber2
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@num (float) : nombre à formater
//		@decimalNum (int) : nombre de chiffres après la virgule
//		@bolLeadingZero (boolean) : indique s'il faut laisser le zéro pour les nombres entre -1 exclus et 1 exclus
//		@bolParens (boolean) : indique s'il faut mettre des parenthéses autour des nombres négatifs
//		@bolCommas (boolean) : indique s'il faut mettre des "." comme séparateur de milliers
// NECESSITES :
// SORTIES :
// VALEURS DE RETOUR :	
//		* (string) : nombre formaté
// AUTEUR : INCONNU
// DERNIERE MODIF : 10/12/2005
// ETAT : ok
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function FormatNumber2( num, decimalNum, bolLeadingZero, bolParens, bolCommas )
{
// --------------
// initialisation
// --------------
var tmpNum = num;
var iSign = num < 0 ? -1 : 1;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
if( isNaN( parseInt( num ) ) )
return "NaN";
// -----------
// traitements
// -----------
// on tronque le nombre pour avoir strictement le nombre de chiffres après la virgule demandée
tmpNum *= Math.pow(10,decimalNum);
tmpNum = Math.round(Math.abs(tmpNum))
tmpNum /= Math.pow(10,decimalNum);
// on remet le signe
tmpNum *= iSign;
// on crée une chaine de caractères avec le nombre
var tmpNumStr = new String(tmpNum);
// gestion de la présence du zéro pour les nombres entre -1 et 1
if (!bolLeadingZero && num < 1 && num > -1 && num != 0)
if (num > 0)
tmpNumStr = tmpNumStr.substring(1,tmpNumStr.length);
else
tmpNumStr = "-" + tmpNumStr.substring(2,tmpNumStr.length);
// remplacement du séparateur décimal "." par ","
tmpNumStr = xreplace( tmpNumStr, ".", "," );
// remplir après la virgule pour obtenir le nombre de chiffres voulus même avec un nombre comportant moins de précision
var emplacement_du_point = tmpNumStr.indexOf(",");
if( emplacement_du_point < 0 )
{
emplacement_du_point = tmpNumStr.length;
tmpNumStr = tmpNumStr + ",";
}
for( var i=tmpNumStr.length-emplacement_du_point-1 ; i<decimalNum ; i++ )
tmpNumStr = tmpNumStr + "0";
// ajout du séparateur de milliers
if (bolCommas && (num >= 1000 || num <= -1000)) {
var iStart = tmpNumStr.indexOf(",");
if (iStart < 0)
iStart = tmpNumStr.length;
iStart -= 3;
while (iStart >= 1) {
tmpNumStr = tmpNumStr.substring(0,iStart) + "." + tmpNumStr.substring(iStart,tmpNumStr.length)
iStart -= 3;
}		
}
// ajout des parenthéses sur les nombres négatifs
if (bolParens && num < 0)
tmpNumStr = "(" + tmpNumStr.substring(1,tmpNumStr.length) + ")";
return tmpNumStr;
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : fermer_fenetre
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 17/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function fermer_fenetre(  )
{
// --------------
// initialisation
// --------------
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
top.opener=self;
top.close();
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : champ_ecrire_valeur
// DESCRIPTION COURTE :	met à jour la valeur d'un élément de formulaire
// DESCRIPTION :	
//		met à jour la valeur d'un élément de formulaire
// ENTREES :
//		@objet (objet) : pointeur sur l'objet dont il faut mettre à jour le contenu
//		@valeur (mixed) : nouveau contenu de l'élément de formulaire
// NECESSITES :
//		l'objet doit être un élément de formulaire.
// SORTIES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
//		* null : impossible d'écrire la valeur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 09/12/2005
// ETAT : ok
// RESTE A FAIRE :
//		* traiter les listes déroulantes à choix multiples
// REMARQUES :
// VOIR AUSSI : champ_lire_valeur champ_verifier_modification champ_restaurer_ancienne_valeur champ_memoriser_valeur champ_preparer preparer_tous_les_champs
//---------------------------------------------------------------------------------------
function champ_ecrire_valeur( objet, valeur )
{
// --------------
// initialisation
// --------------
var liste_elements = null;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// vérification du paramètre objet
if( objet == null )
// null : impossible de lire la valeur
return null;
// -----------
// traitements
// -----------
valeur = lib_general__convertir_unicode_vers_js( valeur );
if( objet.tagName == "SELECT" )
{
if( objet.options.length == 0 )
{
objet.selectedIndex = -1;
return;
}
for( var i=0 ; i<objet.options.length ; i++ )
if( objet.options[i].value == valeur )
objet.selectedIndex = i;
if( objet.options[objet.selectedIndex].value != valeur )
objet.selectedIndex = 0;
}
if( objet.tagName == "TEXTAREA" )
objet.value = valeur;
if( objet.tagName == "INPUT" )
{
if( ( objet.type == "text" )
|| ( objet.type == "password" )
|| ( objet.type == "hidden" )
|| ( objet.type == "button" ) )
objet.value = valeur;
if( ( objet.type == "radio" ) || ( objet.type == "checkbox" ) )
{
liste_elements = getElementsByAttribute( "name", objet.name );
for( num_element=0 ; num_element<liste_elements.length ; num_element++ )
if( liste_elements[num_element].value == valeur )
liste_elements[num_element].checked = true;
else
liste_elements[num_element].checked = false;
//			champ_verifier_modification( objet );
//			objet.checked = valeur;
}
if( objet.type == "file" )
{
var parent = objet.parentNode;
parent.innerHTML = parent.innerHTML;
objet = parent.firstChild;
}
}
//champ_verifier_modification( objet );		
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
function MM_swapImgRestore() { //v3.0
var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}
function MM_preloadImages() { //v3.0
var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];} }
}
function MM_findObj(n, d) { //v4.01
var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
if(!x && d.getElementById) x=d.getElementById(n); return x;
}
function MM_swapImage() { //v3.0
var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}
function MM_openBrWindow(theURL,winName,features) {
if (winName=='pdfreader')
{
var cheminSansNomFichier = 'http:';
var listeRepertoire = window.location.href.split("/");
for (i=1; i<listeRepertoire.length-1; i++)
{ cheminSansNomFichier = cheminSansNomFichier+'/'+listeRepertoire[i]; }
if (window.location.hostname.lastIndexOf("laetis.loc") == -1)
{
chemin = 'http://'+listeRepertoire[2]+'/';
win=window.open(chemin+'includes/plugins/pdf/framepdf.php?pdfPage='+cheminSansNomFichier+'/'+theURL,winName,'scrollbars=yes,resizable=yes');
}
else
{
chemin = 'http://'+listeRepertoire[2]+'/'+listeRepertoire[3]+'/';
win=window.open(chemin+'includes/plugins/pdf/framepdf.php?pdfPage='+cheminSansNomFichier+'/'+theURL,winName,'scrollbars=yes,resizable=yes');
}
}
else
{
win=window.open(theURL,winName,features);
}
win.opener = self;
win.focus();			
}
function element_select__trier( nom_liste )
{
var liste1 = new Array();
var liste2 = new Array();
for( var i=0 ; i<$( nom_liste ).options.length ; i++ )
liste1[i] = { value: $( nom_liste ).options[i].value, text: $( nom_liste ).options[i].text };
liste2 = $A( liste1 ).sortBy( function( valeur, indice )
{
if( valeur["value"] == "" )
return "";
return valeur["text"];
});
element_select__vider( nom_liste );
for( var i=0 ; i<liste2.length ; i++ )
element_select__ajouter_item( nom_liste, liste2[i]["text"], liste2[i]["value"] );
}
function element_select__vider( nom_liste )
{
for( i=$(nom_liste).options.length-1 ; i>=0 ; i-- )
$(nom_liste).remove( i );
$(nom_liste).selectedIndex = 0;
}
function element_select__ajouter_item( nom_liste, texte, valeur )
{
var mon_option = new Option( "", valeur ); 
try
{
$( nom_liste ).add( mon_option, null ); // ne fonctionne pas sous IE
}
catch(ex)
{
$( nom_liste ).add( mon_option ); // fonctionne sous IE seulement
}
$( nom_liste ).options[$( nom_liste ).options.length-1].innerHTML = texte;
}
function lib_general__convertir_dec_hex( valeur )
{
var reste = 0;
var chaine = "";
var lettres = new Array("0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","G");
while( valeur>15 )
{
reste = valeur - 16*Math.floor( valeur / 16 );
valeur = Math.floor( valeur / 16 );
chaine = lettres[reste] + chaine;
}
chaine = lettres[valeur] + chaine;
return chaine;
}
function lib_general__forcer_a_quatre_caracteres( chaine )
{
for( var i=chaine.length ; i<4 ; i++ )
chaine = "0" + chaine;
return chaine;
}
function lib_general__convertir_unicode_vers_js( mon_texte )
{
var mon_texte_old = "";
while( mon_texte_old != mon_texte )
{
mon_texte_old = mon_texte;
mon_texte = mon_texte.replace( /&#x([0-9a-f][0-9a-f][0-9a-f][0-9a-f]);/, "\\u$1");
mon_texte = mon_texte.replace( /&#x([0-9a-f][0-9a-f][0-9a-f]);/, "\\u0$1");
mon_texte = mon_texte.replace( /&#x([0-9a-f][0-9a-f]);/, "\\u00$1");
mon_texte = mon_texte.replace( /&#x([0-9a-f]);/, "\\u000$1");
var tempo = {"nbsp":160,"iexcl":161,"cent":162,"pound":163,"curren":164,"yen":165,"brvbar":166,"sect":167,"uml":168,"copy":169,"ordf":170,"laquo":171,"not":172,"shy":173,"reg":174,"macr":175,"deg":176,"plusmn":177,"sup2":178,"sup3":179,"acute":180,"micro":181,"para":182,"middot":183,"cedil":184,"sup1":185,"ordm":186,"raquo":187,"frac14":188,"frac12":189,"frac34":190,"iquest":191,"Agrave":192,"Aacute":193,"Acirc":194,"Atilde":195,"Auml":196,"Aring":197,"AElig":198,"Ccedil":199,"Egrave":200,"Eacute":201,"Ecirc":202,"Euml":203,"Igrave":204,"Iacute":205,"Icirc":206,"Iuml":207,"ETH":208,"Ntilde":209,"Ograve":210,"Oacute":211,"Ocirc":212,"Otilde":213,"Ouml":214,"times":215,"Oslash":216,"Ugrave":217,"Uacute":218,"Ucirc":219,"Uuml":220,"Yacute":221,"THORN":222,"szlig":223,"agrave":224,"aacute":225,"acirc":226,"atilde":227,"auml":228,"aring":229,"aelig":230,"ccedil":231,"egrave":232,"eacute":233,"ecirc":234,"euml":235,"igrave":236,"iacute":237,"icirc":238,"iuml":239,"eth":240,"ntilde":241,"ograve":242,"oacute":243,"ocirc":244,"otilde":245,"ouml":246,"divide":247,"oslash":248,"ugrave":249,"uacute":250,"ucirc":251,"uuml":252,"yacute":253,"thorn":254,"yuml":255,"fnof":402,"Alpha":913,"Beta":914,"Gamma":915,"Delta":916,"Epsilon":917,"Zeta":918,"Eta":919,"Theta":920,"Iota":921,"Kappa":922,"Lambda":923,"Mu":924,"Nu":925,"Xi":926,"Omicron":927,"Pi":928,"Rho":929,"Sigma":931,"Tau":932,"Upsilon":933,"Phi":934,"Chi":935,"Psi":936,"Omega":937,"alpha":945,"beta":946,"gamma":947,"delta":948,"epsilon":949,"zeta":950,"eta":951,"theta":952,"iota":953,"kappa":954,"lambda":955,"mu":956,"nu":957,"xi":958,"omicron":959,"pi":960,"rho":961,"sigmaf":962,"sigma":963,"tau":964,"upsilon":965,"phi":966,"chi":967,"psi":968,"omega":969,"thetasym":977,"upsih":978,"piv":982,"bull":8226,"hellip":8230,"prime":8242,"Prime":8243,"oline":8254,"frasl":8260,"weierp":8472,"image":8465,"real":8476,"trade":8482,"alefsym":8501,"larr":8592,"uarr":8593,"rarr":8594,"darr":8595,"harr":8596,"crarr":8629,"lArr":8656,"uArr":8657,"rArr":8658,"dArr":8659,"hArr":8660,"forall":8704,"part":8706,"exist":8707,"empty":8709,"nabla":8711,"isin":8712,"notin":8713,"ni":8715,"prod":8719,"sum":8721,"minus":8722,"lowast":8727,"radic":8730,"prop":8733,"infin":8734,"ang":8736,"and":8743,"or":8744,"cap":8745,"cup":8746,"int":8747,"there4":8756,"sim":8764,"cong":8773,"asymp":8776,"ne":8800,"equiv":8801,"le":8804,"ge":8805,"sub":8834,"sup":8835,"nsub":8836,"sube":8838,"supe":8839,"oplus":8853,"otimes":8855,"perp":8869,"sdot":8901,"lceil":8968,"rceil":8969,"lfloor":8970,"rfloor":8971,"lang":9001,"rang":9002,"loz":9674,"spades":9824,"clubs":9827,"hearts":9829,"diams":9830,"quot":34,"amp":38,"lt":60,"gt":62,"OElig":338,"oelig":339,"Scaron":352,"scaron":353,"Yuml":376,"circ":710,"tilde":732,"ensp":8194,"emsp":8195,"thinsp":8201,"zwnj":8204,"zwj":8205,"lrm":8206,"rlm":8207,"ndash":8211,"mdash":8212,"lsquo":8216,"rsquo":8217,"sbquo":8218,"ldquo":8220,"rdquo":8221,"bdquo":8222,"dagger":8224,"Dagger":8225,"permil":8240,"lsaquo":8249,"rsaquo":8250,"euro":8364};
for( var caractere in tempo )
mon_texte = mon_texte.replace( "&" + caractere + ";", "\\u" + lib_general__forcer_a_quatre_caracteres( lib_general__convertir_dec_hex( tempo[caractere] ) ) );
var chaine = mon_texte.match( /&#([0-9]+);/ );
while( chaine != null )
{
mon_texte = mon_texte.replace( chaine[0], "\\u" + lib_general__forcer_a_quatre_caracteres( lib_general__convertir_dec_hex( chaine[1] ) ) );
chaine = mon_texte.match( /&#([0-9]+);/ );
}
}
mon_texte=xreplace(mon_texte,"\r","\\r");
mon_texte=xreplace(mon_texte,"\n","\\n");
mon_texte=xreplace(mon_texte,"\t","\\t");
mon_texte=xreplace(mon_texte,"\'","\\\'");
mon_texte=xreplace(mon_texte,"\"","\\\"");
eval( "var texte='" + mon_texte + "';" );
return texte;
}
//---------------------------------------------------------------------------------------
// NOM FONCTION : transmettre_log_service_automatise
// DESCRIPTION COURTE :	
// DESCRIPTION :	
//		.
// ENTREES :
//		@[nom_variable] (type) : 
//			STRUCT :
//				[][dflsdflk]
//				  [dqsdqd][]
//			VALEURS :
//				* false : truc
//				* 1 : truc
//				* "toto" : truc
//		VARIABLES GLOBALES :
// NECESSITES :
//		.
// SORTIES :
//		@nom_variable (type) : utilité
//		VARIABLES GLOBALES :
// VALEURS DE RETOUR :	
//		* 0 : aucune erreur
// AUTEUR : DANIEL Eric
// DERNIERE MODIF : 17/12/2005
// ETAT : dev
// RESTE A FAIRE :
//		*
// REMARQUES :
// VOIR AUSSI :
//---------------------------------------------------------------------------------------
function transmettre_log_service_automatise(id_service)
{
// --------------
// initialisation
// --------------
var	url="/commun/logs__services_automatises.php";
var parametres="id_service="+id_service;
// ------------------------------------
// vérification des paramètres d'entrée
// ------------------------------------
// -----------
// traitements
// -----------
var mon_ajax = new Ajax.Request(url, {method: 'get', parameters: parametres} );
// ---------------------
// sortie de la fonction
// ---------------------
// 0 : aucune erreur
return 0;
}
function retrier_une_liste( objet, sens )
{
var tempo = "";
var liste_des_values = new Array();
var liste_des_textes = new Array();
var selection_courante = 0;
var j = 0;
for( var i=0 ; i<objet.options.length ; i++ )
{
liste_des_values[i] = objet.options[i].value;
liste_des_textes[i] = objet.options[i].text;
}
selection_courante = liste_des_values[objet.selectedIndex];
echange_effectue = true;
while( echange_effectue )
{
echange_effectue = false;
for( var i=1 ; i<objet.options.length ; i++ )
if( liste_des_textes[i] < liste_des_textes[i-1] )
{
tempo = liste_des_values[i];
liste_des_values[i] = liste_des_values[i-1];
liste_des_values[i-1] = tempo;
tempo = liste_des_textes[i];
liste_des_textes[i] = liste_des_textes[i-1];
liste_des_textes[i-1] = tempo;
echange_effectue = true;
}
}
for( var i=0 ; i<objet.options.length ; i++ )
{
if( sens == 1 )
j = i;
else
j = objet.options.length-i-1;
objet.options[i].value = liste_des_values[j];
objet.options[i].text = liste_des_textes[j];
if( objet.options[i].value == selection_courante )
objet.selectedIndex = i;
}
}
function Left(str, n)
{
if (n <= 0)
return "";
else if (n > String(str).length)
return str;
else
return String(str).substring(0,n);
}
function Right(str, n)
{
if (n <= 0)
return "";
else if (n > String(str).length)
return str;
else
{
var iLen = String(str).length;
return String(str).substring(iLen, iLen - n);
}
}

/*  Prototype JavaScript framework, version 1.5.1.1
*  (c) 2005-2007 Sam Stephenson
*
*  Prototype is freely distributable under the terms of an MIT-style license.
*  For details, see the Prototype web site: http://www.prototypejs.org/
*
/*--------------------------------------------------------------------------*/
var Prototype = {
Version: '1.5.1.1',
Browser: {
IE:     !!(window.attachEvent && !window.opera),
Opera:  !!window.opera,
WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
Gecko:  navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1
},
BrowserFeatures: {
XPath: !!document.evaluate,
ElementExtensions: !!window.HTMLElement,
SpecificElementExtensions:
(document.createElement('div').__proto__ !==
document.createElement('form').__proto__)
},
ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
emptyFunction: function() { },
K: function(x) { return x }
}
var Class = {
create: function() {
return function() {
this.initialize.apply(this, arguments);
}
}
}
var Abstract = new Object();
Object.extend = function(destination, source) {
for (var property in source) {
destination[property] = source[property];
}
return destination;
}
Object.extend(Object, {
inspect: function(object) {
try {
if (object === undefined) return 'undefined';
if (object === null) return 'null';
return object.inspect ? object.inspect() : object.toString();
} catch (e) {
if (e instanceof RangeError) return '...';
throw e;
}
},
toJSON: function(object) {
var type = typeof object;
switch(type) {
case 'undefined':
case 'function':
case 'unknown': return;
case 'boolean': return object.toString();
}
if (object === null) return 'null';
if (object.toJSON) return object.toJSON();
if (object.ownerDocument === document) return;
var results = [];
for (var property in object) {
var value = Object.toJSON(object[property]);
if (value !== undefined)
results.push(property.toJSON() + ': ' + value);
}
return '{' + results.join(', ') + '}';
},
keys: function(object) {
var keys = [];
for (var property in object)
keys.push(property);
return keys;
},
values: function(object) {
var values = [];
for (var property in object)
values.push(object[property]);
return values;
},
clone: function(object) {
return Object.extend({}, object);
}
});
Function.prototype.bind = function() {
var __method = this, args = $A(arguments), object = args.shift();
return function() {
return __method.apply(object, args.concat($A(arguments)));
}
}
Function.prototype.bindAsEventListener = function(object) {
var __method = this, args = $A(arguments), object = args.shift();
return function(event) {
return __method.apply(object, [event || window.event].concat(args));
}
}
Object.extend(Number.prototype, {
toColorPart: function() {
return this.toPaddedString(2, 16);
},
succ: function() {
return this + 1;
},
times: function(iterator) {
$R(0, this, true).each(iterator);
return this;
},
toPaddedString: function(length, radix) {
var string = this.toString(radix || 10);
return '0'.times(length - string.length) + string;
},
toJSON: function() {
return isFinite(this) ? this.toString() : 'null';
}
});
Date.prototype.toJSON = function() {
return '"' + this.getFullYear() + '-' +
(this.getMonth() + 1).toPaddedString(2) + '-' +
this.getDate().toPaddedString(2) + 'T' +
this.getHours().toPaddedString(2) + ':' +
this.getMinutes().toPaddedString(2) + ':' +
this.getSeconds().toPaddedString(2) + '"';
};
var Try = {
these: function() {
var returnValue;
for (var i = 0, length = arguments.length; i < length; i++) {
var lambda = arguments[i];
try {
returnValue = lambda();
break;
} catch (e) {}
}
return returnValue;
}
}
/*--------------------------------------------------------------------------*/
var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
initialize: function(callback, frequency) {
this.callback = callback;
this.frequency = frequency;
this.currentlyExecuting = false;
this.registerCallback();
},
registerCallback: function() {
this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},
stop: function() {
if (!this.timer) return;
clearInterval(this.timer);
this.timer = null;
},
onTimerEvent: function() {
if (!this.currentlyExecuting) {
try {
this.currentlyExecuting = true;
this.callback(this);
} finally {
this.currentlyExecuting = false;
}
}
}
}
Object.extend(String, {
interpret: function(value) {
return value == null ? '' : String(value);
},
specialChar: {
'\b': '\\b',
'\t': '\\t',
'\n': '\\n',
'\f': '\\f',
'\r': '\\r',
'\\': '\\\\'
}
});
Object.extend(String.prototype, {
gsub: function(pattern, replacement) {
var result = '', source = this, match;
replacement = arguments.callee.prepareReplacement(replacement);
while (source.length > 0) {
if (match = source.match(pattern)) {
result += source.slice(0, match.index);
result += String.interpret(replacement(match));
source  = source.slice(match.index + match[0].length);
} else {
result += source, source = '';
}
}
return result;
},
sub: function(pattern, replacement, count) {
replacement = this.gsub.prepareReplacement(replacement);
count = count === undefined ? 1 : count;
return this.gsub(pattern, function(match) {
if (--count < 0) return match[0];
return replacement(match);
});
},
scan: function(pattern, iterator) {
this.gsub(pattern, iterator);
return this;
},
truncate: function(length, truncation) {
length = length || 30;
truncation = truncation === undefined ? '...' : truncation;
return this.length > length ?
this.slice(0, length - truncation.length) + truncation : this;
},
strip: function() {
return this.replace(/^\s+/, '').replace(/\s+$/, '');
},
stripTags: function() {
return this.replace(/<\/?[^>]+>/gi, '');
},
stripScripts: function() {
return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
},
extractScripts: function() {
var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
return (this.match(matchAll) || []).map(function(scriptTag) {
return (scriptTag.match(matchOne) || ['', ''])[1];
});
},
evalScripts: function() {
return this.extractScripts().map(function(script) { return eval(script) });
},
escapeHTML: function() {
var self = arguments.callee;
self.text.data = this;
return self.div.innerHTML;
},
unescapeHTML: function() {
var div = document.createElement('div');
div.innerHTML = this.stripTags();
return div.childNodes[0] ? (div.childNodes.length > 1 ?
$A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
div.childNodes[0].nodeValue) : '';
},
toQueryParams: function(separator) {
var match = this.strip().match(/([^?#]*)(#.*)?$/);
if (!match) return {};
return match[1].split(separator || '&').inject({}, function(hash, pair) {
if ((pair = pair.split('='))[0]) {
var key = decodeURIComponent(pair.shift());
var value = pair.length > 1 ? pair.join('=') : pair[0];
if (value != undefined) value = decodeURIComponent(value);
if (key in hash) {
if (hash[key].constructor != Array) hash[key] = [hash[key]];
hash[key].push(value);
}
else hash[key] = value;
}
return hash;
});
},
toArray: function() {
return this.split('');
},
succ: function() {
return this.slice(0, this.length - 1) +
String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
},
times: function(count) {
var result = '';
for (var i = 0; i < count; i++) result += this;
return result;
},
camelize: function() {
var parts = this.split('-'), len = parts.length;
if (len == 1) return parts[0];
var camelized = this.charAt(0) == '-'
? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
: parts[0];
for (var i = 1; i < len; i++)
camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
return camelized;
},
capitalize: function() {
return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
},
underscore: function() {
return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
},
dasherize: function() {
return this.gsub(/_/,'-');
},
inspect: function(useDoubleQuotes) {
var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
var character = String.specialChar[match[0]];
return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
});
if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
return "'" + escapedString.replace(/'/g, '\\\'') + "'";
},
toJSON: function() {
return this.inspect(true);
},
unfilterJSON: function(filter) {
return this.sub(filter || Prototype.JSONFilter, '#{1}');
},
isJSON: function() {
var str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
},
evalJSON: function(sanitize) {
var json = this.unfilterJSON();
try {
if (!sanitize || json.isJSON()) return eval('(' + json + ')');
} catch (e) { }
throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
},
include: function(pattern) {
return this.indexOf(pattern) > -1;
},
startsWith: function(pattern) {
return this.indexOf(pattern) === 0;
},
endsWith: function(pattern) {
var d = this.length - pattern.length;
return d >= 0 && this.lastIndexOf(pattern) === d;
},
empty: function() {
return this == '';
},
blank: function() {
return /^\s*$/.test(this);
}
});
if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
escapeHTML: function() {
return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
},
unescapeHTML: function() {
return this.replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
}
});
String.prototype.gsub.prepareReplacement = function(replacement) {
if (typeof replacement == 'function') return replacement;
var template = new Template(replacement);
return function(match) { return template.evaluate(match) };
}
String.prototype.parseQuery = String.prototype.toQueryParams;
Object.extend(String.prototype.escapeHTML, {
div:  document.createElement('div'),
text: document.createTextNode('')
});
with (String.prototype.escapeHTML) div.appendChild(text);
var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype = {
initialize: function(template, pattern) {
this.template = template.toString();
this.pattern  = pattern || Template.Pattern;
},
evaluate: function(object) {
return this.template.gsub(this.pattern, function(match) {
var before = match[1];
if (before == '\\') return match[2];
return before + String.interpret(object[match[3]]);
});
}
}
var $break = {}, $continue = new Error('"throw $continue" is deprecated, use "return" instead');
var Enumerable = {
each: function(iterator) {
var index = 0;
try {
this._each(function(value) {
iterator(value, index++);
});
} catch (e) {
if (e != $break) throw e;
}
return this;
},
eachSlice: function(number, iterator) {
var index = -number, slices = [], array = this.toArray();
while ((index += number) < array.length)
slices.push(array.slice(index, index+number));
return slices.map(iterator);
},
all: function(iterator) {
var result = true;
this.each(function(value, index) {
result = result && !!(iterator || Prototype.K)(value, index);
if (!result) throw $break;
});
return result;
},
any: function(iterator) {
var result = false;
this.each(function(value, index) {
if (result = !!(iterator || Prototype.K)(value, index))
throw $break;
});
return result;
},
collect: function(iterator) {
var results = [];
this.each(function(value, index) {
results.push((iterator || Prototype.K)(value, index));
});
return results;
},
detect: function(iterator) {
var result;
this.each(function(value, index) {
if (iterator(value, index)) {
result = value;
throw $break;
}
});
return result;
},
findAll: function(iterator) {
var results = [];
this.each(function(value, index) {
if (iterator(value, index))
results.push(value);
});
return results;
},
grep: function(pattern, iterator) {
var results = [];
this.each(function(value, index) {
var stringValue = value.toString();
if (stringValue.match(pattern))
results.push((iterator || Prototype.K)(value, index));
})
return results;
},
include: function(object) {
var found = false;
this.each(function(value) {
if (value == object) {
found = true;
throw $break;
}
});
return found;
},
inGroupsOf: function(number, fillWith) {
fillWith = fillWith === undefined ? null : fillWith;
return this.eachSlice(number, function(slice) {
while(slice.length < number) slice.push(fillWith);
return slice;
});
},
inject: function(memo, iterator) {
this.each(function(value, index) {
memo = iterator(memo, value, index);
});
return memo;
},
invoke: function(method) {
var args = $A(arguments).slice(1);
return this.map(function(value) {
return value[method].apply(value, args);
});
},
max: function(iterator) {
var result;
this.each(function(value, index) {
value = (iterator || Prototype.K)(value, index);
if (result == undefined || value >= result)
result = value;
});
return result;
},
min: function(iterator) {
var result;
this.each(function(value, index) {
value = (iterator || Prototype.K)(value, index);
if (result == undefined || value < result)
result = value;
});
return result;
},
partition: function(iterator) {
var trues = [], falses = [];
this.each(function(value, index) {
((iterator || Prototype.K)(value, index) ?
trues : falses).push(value);
});
return [trues, falses];
},
pluck: function(property) {
var results = [];
this.each(function(value, index) {
results.push(value[property]);
});
return results;
},
reject: function(iterator) {
var results = [];
this.each(function(value, index) {
if (!iterator(value, index))
results.push(value);
});
return results;
},
sortBy: function(iterator) {
return this.map(function(value, index) {
return {value: value, criteria: iterator(value, index)};
}).sort(function(left, right) {
var a = left.criteria, b = right.criteria;
return a < b ? -1 : a > b ? 1 : 0;
}).pluck('value');
},
toArray: function() {
return this.map();
},
zip: function() {
var iterator = Prototype.K, args = $A(arguments);
if (typeof args.last() == 'function')
iterator = args.pop();
var collections = [this].concat(args).map($A);
return this.map(function(value, index) {
return iterator(collections.pluck(index));
});
},
size: function() {
return this.toArray().length;
},
inspect: function() {
return '#<Enumerable:' + this.toArray().inspect() + '>';
}
}
Object.extend(Enumerable, {
map:     Enumerable.collect,
find:    Enumerable.detect,
select:  Enumerable.findAll,
member:  Enumerable.include,
entries: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
if (!iterable) return [];
if (iterable.toArray) {
return iterable.toArray();
} else {
var results = [];
for (var i = 0, length = iterable.length; i < length; i++)
results.push(iterable[i]);
return results;
}
}
if (Prototype.Browser.WebKit) {
$A = Array.from = function(iterable) {
if (!iterable) return [];
if (!(typeof iterable == 'function' && iterable == '[object NodeList]') &&
iterable.toArray) {
return iterable.toArray();
} else {
var results = [];
for (var i = 0, length = iterable.length; i < length; i++)
results.push(iterable[i]);
return results;
}
}
}
Object.extend(Array.prototype, Enumerable);
if (!Array.prototype._reverse)
Array.prototype._reverse = Array.prototype.reverse;
Object.extend(Array.prototype, {
_each: function(iterator) {
for (var i = 0, length = this.length; i < length; i++)
iterator(this[i]);
},
clear: function() {
this.length = 0;
return this;
},
first: function() {
return this[0];
},
last: function() {
return this[this.length - 1];
},
compact: function() {
return this.select(function(value) {
return value != null;
});
},
flatten: function() {
return this.inject([], function(array, value) {
return array.concat(value && value.constructor == Array ?
value.flatten() : [value]);
});
},
without: function() {
var values = $A(arguments);
return this.select(function(value) {
return !values.include(value);
});
},
indexOf: function(object) {
for (var i = 0, length = this.length; i < length; i++)
if (this[i] == object) return i;
return -1;
},
reverse: function(inline) {
return (inline !== false ? this : this.toArray())._reverse();
},
reduce: function() {
return this.length > 1 ? this : this[0];
},
uniq: function(sorted) {
return this.inject([], function(array, value, index) {
if (0 == index || (sorted ? array.last() != value : !array.include(value)))
array.push(value);
return array;
});
},
clone: function() {
return [].concat(this);
},
size: function() {
return this.length;
},
inspect: function() {
return '[' + this.map(Object.inspect).join(', ') + ']';
},
toJSON: function() {
var results = [];
this.each(function(object) {
var value = Object.toJSON(object);
if (value !== undefined) results.push(value);
});
return '[' + results.join(', ') + ']';
}
});
Array.prototype.toArray = Array.prototype.clone;
function $w(string) {
string = string.strip();
return string ? string.split(/\s+/) : [];
}
if (Prototype.Browser.Opera){
Array.prototype.concat = function() {
var array = [];
for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
for (var i = 0, length = arguments.length; i < length; i++) {
if (arguments[i].constructor == Array) {
for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
array.push(arguments[i][j]);
} else {
array.push(arguments[i]);
}
}
return array;
}
}
var Hash = function(object) {
if (object instanceof Hash) this.merge(object);
else Object.extend(this, object || {});
};
Object.extend(Hash, {
toQueryString: function(obj) {
var parts = [];
parts.add = arguments.callee.addPair;
this.prototype._each.call(obj, function(pair) {
if (!pair.key) return;
var value = pair.value;
if (value && typeof value == 'object') {
if (value.constructor == Array) value.each(function(value) {
parts.add(pair.key, value);
});
return;
}
parts.add(pair.key, value);
});
return parts.join('&');
},
toJSON: function(object) {
var results = [];
this.prototype._each.call(object, function(pair) {
var value = Object.toJSON(pair.value);
if (value !== undefined) results.push(pair.key.toJSON() + ': ' + value);
});
return '{' + results.join(', ') + '}';
}
});
Hash.toQueryString.addPair = function(key, value, prefix) {
key = encodeURIComponent(key);
if (value === undefined) this.push(key);
else this.push(key + '=' + (value == null ? '' : encodeURIComponent(value)));
}
Object.extend(Hash.prototype, Enumerable);
Object.extend(Hash.prototype, {
_each: function(iterator) {
for (var key in this) {
var value = this[key];
if (value && value == Hash.prototype[key]) continue;
var pair = [key, value];
pair.key = key;
pair.value = value;
iterator(pair);
}
},
keys: function() {
return this.pluck('key');
},
values: function() {
return this.pluck('value');
},
merge: function(hash) {
return $H(hash).inject(this, function(mergedHash, pair) {
mergedHash[pair.key] = pair.value;
return mergedHash;
});
},
remove: function() {
var result;
for(var i = 0, length = arguments.length; i < length; i++) {
var value = this[arguments[i]];
if (value !== undefined){
if (result === undefined) result = value;
else {
if (result.constructor != Array) result = [result];
result.push(value)
}
}
delete this[arguments[i]];
}
return result;
},
toQueryString: function() {
return Hash.toQueryString(this);
},
inspect: function() {
return '#<Hash:{' + this.map(function(pair) {
return pair.map(Object.inspect).join(': ');
}).join(', ') + '}>';
},
toJSON: function() {
return Hash.toJSON(this);
}
});
function $H(object) {
if (object instanceof Hash) return object;
return new Hash(object);
};
// Safari iterates over shadowed properties
if (function() {
var i = 0, Test = function(value) { this.key = value };
Test.prototype.key = 'foo';
for (var property in new Test('bar')) i++;
return i > 1;
}()) Hash.prototype._each = function(iterator) {
var cache = [];
for (var key in this) {
var value = this[key];
if ((value && value == Hash.prototype[key]) || cache.include(key)) continue;
cache.push(key);
var pair = [key, value];
pair.key = key;
pair.value = value;
iterator(pair);
}
};
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
initialize: function(start, end, exclusive) {
this.start = start;
this.end = end;
this.exclusive = exclusive;
},
_each: function(iterator) {
var value = this.start;
while (this.include(value)) {
iterator(value);
value = value.succ();
}
},
include: function(value) {
if (value < this.start)
return false;
if (this.exclusive)
return value < this.end;
return value <= this.end;
}
});
var $R = function(start, end, exclusive) {
return new ObjectRange(start, end, exclusive);
}
var Ajax = {
getTransport: function() {
return Try.these(
function() {return new XMLHttpRequest()},
function() {return new ActiveXObject('Msxml2.XMLHTTP')},
function() {return new ActiveXObject('Microsoft.XMLHTTP')}
) || false;
},
activeRequestCount: 0
}
Ajax.Responders = {
responders: [],
_each: function(iterator) {
this.responders._each(iterator);
},
register: function(responder) {
if (!this.include(responder))
this.responders.push(responder);
},
unregister: function(responder) {
this.responders = this.responders.without(responder);
},
dispatch: function(callback, request, transport, json) {
this.each(function(responder) {
if (typeof responder[callback] == 'function') {
try {
responder[callback].apply(responder, [request, transport, json]);
} catch (e) {}
}
});
}
};
Object.extend(Ajax.Responders, Enumerable);
Ajax.Responders.register({
onCreate: function() {
Ajax.activeRequestCount++;
},
onComplete: function() {
Ajax.activeRequestCount--;
}
});
Ajax.Base = function() {};
Ajax.Base.prototype = {
setOptions: function(options) {
this.options = {
method:       'post',
asynchronous: true,
contentType:  'application/x-www-form-urlencoded',
encoding:     'UTF-8',
parameters:   ''
}
Object.extend(this.options, options || {});
this.options.method = this.options.method.toLowerCase();
if (typeof this.options.parameters == 'string')
this.options.parameters = this.options.parameters.toQueryParams();
}
}
Ajax.Request = Class.create();
Ajax.Request.Events =
['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
_complete: false,
initialize: function(url, options) {
this.transport = Ajax.getTransport();
this.setOptions(options);
this.request(url);
},
request: function(url) {
this.url = url;
this.method = this.options.method;
var params = Object.clone(this.options.parameters);
if (!['get', 'post'].include(this.method)) {
// simulate other verbs over post
params['_method'] = this.method;
this.method = 'post';
}
this.parameters = params;
if (params = Hash.toQueryString(params)) {
// when GET, append parameters to URL
if (this.method == 'get')
this.url += (this.url.include('?') ? '&' : '?') + params;
else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
params += '&_=';
}
try {
if (this.options.onCreate) this.options.onCreate(this.transport);
Ajax.Responders.dispatch('onCreate', this, this.transport);
this.transport.open(this.method.toUpperCase(), this.url,
this.options.asynchronous);
if (this.options.asynchronous)
setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);
this.transport.onreadystatechange = this.onStateChange.bind(this);
this.setRequestHeaders();
this.body = this.method == 'post' ? (this.options.postBody || params) : null;
this.transport.send(this.body);
/* Force Firefox to handle ready state 4 for synchronous requests */
if (!this.options.asynchronous && this.transport.overrideMimeType)
this.onStateChange();
}
catch (e) {
this.dispatchException(e);
}
},
onStateChange: function() {
var readyState = this.transport.readyState;
if (readyState > 1 && !((readyState == 4) && this._complete))
this.respondToReadyState(this.transport.readyState);
},
setRequestHeaders: function() {
var headers = {
'X-Requested-With': 'XMLHttpRequest',
'X-Prototype-Version': Prototype.Version,
'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
};
if (this.method == 'post') {
headers['Content-type'] = this.options.contentType +
(this.options.encoding ? '; charset=' + this.options.encoding : '');
/* Force "Connection: close" for older Mozilla browsers to work
* around a bug where XMLHttpRequest sends an incorrect
* Content-length header. See Mozilla Bugzilla #246651.
*/
if (this.transport.overrideMimeType &&
(navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
headers['Connection'] = 'close';
}
// user-defined headers
if (typeof this.options.requestHeaders == 'object') {
var extras = this.options.requestHeaders;
if (typeof extras.push == 'function')
for (var i = 0, length = extras.length; i < length; i += 2)
headers[extras[i]] = extras[i+1];
else
$H(extras).each(function(pair) { headers[pair.key] = pair.value });
}
for (var name in headers)
this.transport.setRequestHeader(name, headers[name]);
},
success: function() {
return !this.transport.status
|| (this.transport.status >= 200 && this.transport.status < 300);
},
respondToReadyState: function(readyState) {
var state = Ajax.Request.Events[readyState];
var transport = this.transport, json = this.evalJSON();
if (state == 'Complete') {
try {
this._complete = true;
(this.options['on' + this.transport.status]
|| this.options['on' + (this.success() ? 'Success' : 'Failure')]
|| Prototype.emptyFunction)(transport, json);
} catch (e) {
this.dispatchException(e);
}
var contentType = this.getHeader('Content-type');
if (contentType && contentType.strip().
match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
this.evalResponse();
}
try {
(this.options['on' + state] || Prototype.emptyFunction)(transport, json);
Ajax.Responders.dispatch('on' + state, this, transport, json);
} catch (e) {
this.dispatchException(e);
}
if (state == 'Complete') {
// avoid memory leak in MSIE: clean up
this.transport.onreadystatechange = Prototype.emptyFunction;
}
},
getHeader: function(name) {
try {
return this.transport.getResponseHeader(name);
} catch (e) { return null }
},
evalJSON: function() {
try {
var json = this.getHeader('X-JSON');
return json ? json.evalJSON() : null;
} catch (e) { return null }
},
evalResponse: function() {
try {
return eval((this.transport.responseText || '').unfilterJSON());
} catch (e) {
this.dispatchException(e);
}
},
dispatchException: function(exception) {
(this.options.onException || Prototype.emptyFunction)(this, exception);
Ajax.Responders.dispatch('onException', this, exception);
}
});
Ajax.Updater = Class.create();
Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
initialize: function(container, url, options) {
this.container = {
success: (container.success || container),
failure: (container.failure || (container.success ? null : container))
}
this.transport = Ajax.getTransport();
this.setOptions(options);
var onComplete = this.options.onComplete || Prototype.emptyFunction;
this.options.onComplete = (function(transport, param) {
this.updateContent();
onComplete(transport, param);
}).bind(this);
this.request(url);
},
updateContent: function() {
var receiver = this.container[this.success() ? 'success' : 'failure'];
var response = this.transport.responseText;
if (!this.options.evalScripts) response = response.stripScripts();
if (receiver = $(receiver)) {
if (this.options.insertion)
new this.options.insertion(receiver, response);
else
receiver.update(response);
}
if (this.success()) {
if (this.onComplete)
setTimeout(this.onComplete.bind(this), 10);
}
}
});
Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
initialize: function(container, url, options) {
this.setOptions(options);
this.onComplete = this.options.onComplete;
this.frequency = (this.options.frequency || 2);
this.decay = (this.options.decay || 1);
this.updater = {};
this.container = container;
this.url = url;
this.start();
},
start: function() {
this.options.onComplete = this.updateComplete.bind(this);
this.onTimerEvent();
},
stop: function() {
this.updater.options.onComplete = undefined;
clearTimeout(this.timer);
(this.onComplete || Prototype.emptyFunction).apply(this, arguments);
},
updateComplete: function(request) {
if (this.options.decay) {
this.decay = (request.responseText == this.lastText ?
this.decay * this.options.decay : 1);
this.lastText = request.responseText;
}
this.timer = setTimeout(this.onTimerEvent.bind(this),
this.decay * this.frequency * 1000);
},
onTimerEvent: function() {
this.updater = new Ajax.Updater(this.container, this.url, this.options);
}
});
function $(element) {
if (arguments.length > 1) {
for (var i = 0, elements = [], length = arguments.length; i < length; i++)
elements.push($(arguments[i]));
return elements;
}
if (typeof element == 'string')
element = document.getElementById(element);
return Element.extend(element);
}
if (Prototype.BrowserFeatures.XPath) {
document._getElementsByXPath = function(expression, parentElement) {
var results = [];
var query = document.evaluate(expression, $(parentElement) || document,
null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
for (var i = 0, length = query.snapshotLength; i < length; i++)
results.push(query.snapshotItem(i));
return results;
};
document.getElementsByClassName = function(className, parentElement) {
var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
return document._getElementsByXPath(q, parentElement);
}
} else document.getElementsByClassName = function(className, parentElement) {
var children = ($(parentElement) || document.body).getElementsByTagName('*');
var elements = [], child, pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
for (var i = 0, length = children.length; i < length; i++) {
child = children[i];
var elementClassName = child.className;
if (elementClassName.length == 0) continue;
if (elementClassName == className || elementClassName.match(pattern))
elements.push(Element.extend(child));
}
return elements;
};
/*--------------------------------------------------------------------------*/
if (!window.Element) var Element = {};
Element.extend = function(element) {
var F = Prototype.BrowserFeatures;
if (!element || !element.tagName || element.nodeType == 3 ||
element._extended || F.SpecificElementExtensions || element == window)
return element;
var methods = {}, tagName = element.tagName, cache = Element.extend.cache,
T = Element.Methods.ByTag;
// extend methods for all tags (Safari doesn't need this)
if (!F.ElementExtensions) {
Object.extend(methods, Element.Methods),
Object.extend(methods, Element.Methods.Simulated);
}
// extend methods for specific tags
if (T[tagName]) Object.extend(methods, T[tagName]);
for (var property in methods) {
var value = methods[property];
if (typeof value == 'function' && !(property in element))
element[property] = cache.findOrStore(value);
}
element._extended = Prototype.emptyFunction;
return element;
};
Element.extend.cache = {
findOrStore: function(value) {
return this[value] = this[value] || function() {
return value.apply(null, [this].concat($A(arguments)));
}
}
};
Element.Methods = {
visible: function(element) {
return $(element).style.display != 'none';
},
toggle: function(element) {
element = $(element);
Element[Element.visible(element) ? 'hide' : 'show'](element);
return element;
},
hide: function(element) {
$(element).style.display = 'none';
return element;
},
show: function(element) {
$(element).style.display = '';
return element;
},
remove: function(element) {
element = $(element);
element.parentNode.removeChild(element);
return element;
},
update: function(element, html) {
html = typeof html == 'undefined' ? '' : html.toString();
$(element).innerHTML = html.stripScripts();
setTimeout(function() {html.evalScripts()}, 10);
return element;
},
replace: function(element, html) {
element = $(element);
html = typeof html == 'undefined' ? '' : html.toString();
if (element.outerHTML) {
element.outerHTML = html.stripScripts();
} else {
var range = element.ownerDocument.createRange();
range.selectNodeContents(element);
element.parentNode.replaceChild(
range.createContextualFragment(html.stripScripts()), element);
}
setTimeout(function() {html.evalScripts()}, 10);
return element;
},
inspect: function(element) {
element = $(element);
var result = '<' + element.tagName.toLowerCase();
$H({'id': 'id', 'className': 'class'}).each(function(pair) {
var property = pair.first(), attribute = pair.last();
var value = (element[property] || '').toString();
if (value) result += ' ' + attribute + '=' + value.inspect(true);
});
return result + '>';
},
recursivelyCollect: function(element, property) {
element = $(element);
var elements = [];
while (element = element[property])
if (element.nodeType == 1)
elements.push(Element.extend(element));
return elements;
},
ancestors: function(element) {
return $(element).recursivelyCollect('parentNode');
},
descendants: function(element) {
return $A($(element).getElementsByTagName('*')).each(Element.extend);
},
firstDescendant: function(element) {
element = $(element).firstChild;
while (element && element.nodeType != 1) element = element.nextSibling;
return $(element);
},
immediateDescendants: function(element) {
if (!(element = $(element).firstChild)) return [];
while (element && element.nodeType != 1) element = element.nextSibling;
if (element) return [element].concat($(element).nextSiblings());
return [];
},
previousSiblings: function(element) {
return $(element).recursivelyCollect('previousSibling');
},
nextSiblings: function(element) {
return $(element).recursivelyCollect('nextSibling');
},
siblings: function(element) {
element = $(element);
return element.previousSiblings().reverse().concat(element.nextSiblings());
},
match: function(element, selector) {
if (typeof selector == 'string')
selector = new Selector(selector);
return selector.match($(element));
},
up: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(element.parentNode);
var ancestors = element.ancestors();
return expression ? Selector.findElement(ancestors, expression, index) :
ancestors[index || 0];
},
down: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return element.firstDescendant();
var descendants = element.descendants();
return expression ? Selector.findElement(descendants, expression, index) :
descendants[index || 0];
},
previous: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
var previousSiblings = element.previousSiblings();
return expression ? Selector.findElement(previousSiblings, expression, index) :
previousSiblings[index || 0];
},
next: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
var nextSiblings = element.nextSiblings();
return expression ? Selector.findElement(nextSiblings, expression, index) :
nextSiblings[index || 0];
},
getElementsBySelector: function() {
var args = $A(arguments), element = $(args.shift());
return Selector.findChildElements(element, args);
},
getElementsByClassName: function(element, className) {
return document.getElementsByClassName(className, element);
},
readAttribute: function(element, name) {
element = $(element);
if (Prototype.Browser.IE) {
if (!element.attributes) return null;
var t = Element._attributeTranslations;
if (t.values[name]) return t.values[name](element, name);
if (t.names[name])  name = t.names[name];
var attribute = element.attributes[name];
return attribute ? attribute.nodeValue : null;
}
return element.getAttribute(name);
},
getHeight: function(element) {
return $(element).getDimensions().height;
},
getWidth: function(element) {
return $(element).getDimensions().width;
},
classNames: function(element) {
return new Element.ClassNames(element);
},
hasClassName: function(element, className) {
if (!(element = $(element))) return;
var elementClassName = element.className;
if (elementClassName.length == 0) return false;
if (elementClassName == className ||
elementClassName.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
return true;
return false;
},
addClassName: function(element, className) {
if (!(element = $(element))) return;
Element.classNames(element).add(className);
return element;
},
removeClassName: function(element, className) {
if (!(element = $(element))) return;
Element.classNames(element).remove(className);
return element;
},
toggleClassName: function(element, className) {
if (!(element = $(element))) return;
Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
return element;
},
observe: function() {
Event.observe.apply(Event, arguments);
return $A(arguments).first();
},
stopObserving: function() {
Event.stopObserving.apply(Event, arguments);
return $A(arguments).first();
},
// removes whitespace-only text node children
cleanWhitespace: function(element) {
element = $(element);
var node = element.firstChild;
while (node) {
var nextNode = node.nextSibling;
if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
element.removeChild(node);
node = nextNode;
}
return element;
},
empty: function(element) {
return $(element).innerHTML.blank();
},
descendantOf: function(element, ancestor) {
element = $(element), ancestor = $(ancestor);
while (element = element.parentNode)
if (element == ancestor) return true;
return false;
},
scrollTo: function(element) {
element = $(element);
var pos = Position.cumulativeOffset(element);
window.scrollTo(pos[0], pos[1]);
return element;
},
getStyle: function(element, style) {
element = $(element);
style = style == 'float' ? 'cssFloat' : style.camelize();
var value = element.style[style];
if (!value) {
var css = document.defaultView.getComputedStyle(element, null);
value = css ? css[style] : null;
}
if (style == 'opacity') return value ? parseFloat(value) : 1.0;
return value == 'auto' ? null : value;
},
getOpacity: function(element) {
return $(element).getStyle('opacity');
},
setStyle: function(element, styles, camelized) {
element = $(element);
var elementStyle = element.style;
for (var property in styles)
if (property == 'opacity') element.setOpacity(styles[property])
else
elementStyle[(property == 'float' || property == 'cssFloat') ?
(elementStyle.styleFloat === undefined ? 'cssFloat' : 'styleFloat') :
(camelized ? property : property.camelize())] = styles[property];
return element;
},
setOpacity: function(element, value) {
element = $(element);
element.style.opacity = (value == 1 || value === '') ? '' :
(value < 0.00001) ? 0 : value;
return element;
},
getDimensions: function(element) {
element = $(element);
var display = $(element).getStyle('display');
if (display != 'none' && display != null) // Safari bug
return {width: element.offsetWidth, height: element.offsetHeight};
// All *Width and *Height properties give 0 on elements with display none,
// so enable the element temporarily
var els = element.style;
var originalVisibility = els.visibility;
var originalPosition = els.position;
var originalDisplay = els.display;
els.visibility = 'hidden';
els.position = 'absolute';
els.display = 'block';
var originalWidth = element.clientWidth;
var originalHeight = element.clientHeight;
els.display = originalDisplay;
els.position = originalPosition;
els.visibility = originalVisibility;
return {width: originalWidth, height: originalHeight};
},
makePositioned: function(element) {
element = $(element);
var pos = Element.getStyle(element, 'position');
if (pos == 'static' || !pos) {
element._madePositioned = true;
element.style.position = 'relative';
// Opera returns the offset relative to the positioning context, when an
// element is position relative but top and left have not been defined
if (window.opera) {
element.style.top = 0;
element.style.left = 0;
}
}
return element;
},
undoPositioned: function(element) {
element = $(element);
if (element._madePositioned) {
element._madePositioned = undefined;
element.style.position =
element.style.top =
element.style.left =
element.style.bottom =
element.style.right = '';
}
return element;
},
makeClipping: function(element) {
element = $(element);
if (element._overflow) return element;
element._overflow = element.style.overflow || 'auto';
if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
element.style.overflow = 'hidden';
return element;
},
undoClipping: function(element) {
element = $(element);
if (!element._overflow) return element;
element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
element._overflow = null;
return element;
}
};
Object.extend(Element.Methods, {
childOf: Element.Methods.descendantOf,
childElements: Element.Methods.immediateDescendants
});
if (Prototype.Browser.Opera) {
Element.Methods._getStyle = Element.Methods.getStyle;
Element.Methods.getStyle = function(element, style) {
switch(style) {
case 'left':
case 'top':
case 'right':
case 'bottom':
if (Element._getStyle(element, 'position') == 'static') return null;
default: return Element._getStyle(element, style);
}
};
}
else if (Prototype.Browser.IE) {
Element.Methods.getStyle = function(element, style) {
element = $(element);
style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
var value = element.style[style];
if (!value && element.currentStyle) value = element.currentStyle[style];
if (style == 'opacity') {
if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
if (value[1]) return parseFloat(value[1]) / 100;
return 1.0;
}
if (value == 'auto') {
if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
return element['offset'+style.capitalize()] + 'px';
return null;
}
return value;
};
Element.Methods.setOpacity = function(element, value) {
element = $(element);
var filter = element.getStyle('filter'), style = element.style;
if (value == 1 || value === '') {
style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');
return element;
} else if (value < 0.00001) value = 0;
style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +
'alpha(opacity=' + (value * 100) + ')';
return element;
};
// IE is missing .innerHTML support for TABLE-related elements
Element.Methods.update = function(element, html) {
element = $(element);
html = typeof html == 'undefined' ? '' : html.toString();
var tagName = element.tagName.toUpperCase();
if (['THEAD','TBODY','TR','TD'].include(tagName)) {
var div = document.createElement('div');
switch (tagName) {
case 'THEAD':
case 'TBODY':
div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';
depth = 2;
break;
case 'TR':
div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';
depth = 3;
break;
case 'TD':
div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';
depth = 4;
}
$A(element.childNodes).each(function(node) { element.removeChild(node) });
depth.times(function() { div = div.firstChild });
$A(div.childNodes).each(function(node) { element.appendChild(node) });
} else {
element.innerHTML = html.stripScripts();
}
setTimeout(function() { html.evalScripts() }, 10);
return element;
}
}
else if (Prototype.Browser.Gecko) {
Element.Methods.setOpacity = function(element, value) {
element = $(element);
element.style.opacity = (value == 1) ? 0.999999 :
(value === '') ? '' : (value < 0.00001) ? 0 : value;
return element;
};
}
Element._attributeTranslations = {
names: {
colspan:   "colSpan",
rowspan:   "rowSpan",
valign:    "vAlign",
datetime:  "dateTime",
accesskey: "accessKey",
tabindex:  "tabIndex",
enctype:   "encType",
maxlength: "maxLength",
readonly:  "readOnly",
longdesc:  "longDesc"
},
values: {
_getAttr: function(element, attribute) {
return element.getAttribute(attribute, 2);
},
_flag: function(element, attribute) {
return $(element).hasAttribute(attribute) ? attribute : null;
},
style: function(element) {
return element.style.cssText.toLowerCase();
},
title: function(element) {
var node = element.getAttributeNode('title');
return node.specified ? node.nodeValue : null;
}
}
};
(function() {
Object.extend(this, {
href: this._getAttr,
src:  this._getAttr,
type: this._getAttr,
disabled: this._flag,
checked:  this._flag,
readonly: this._flag,
multiple: this._flag
});
}).call(Element._attributeTranslations.values);
Element.Methods.Simulated = {
hasAttribute: function(element, attribute) {
var t = Element._attributeTranslations, node;
attribute = t.names[attribute] || attribute;
node = $(element).getAttributeNode(attribute);
return node && node.specified;
}
};
Element.Methods.ByTag = {};
Object.extend(Element, Element.Methods);
if (!Prototype.BrowserFeatures.ElementExtensions &&
document.createElement('div').__proto__) {
window.HTMLElement = {};
window.HTMLElement.prototype = document.createElement('div').__proto__;
Prototype.BrowserFeatures.ElementExtensions = true;
}
Element.hasAttribute = function(element, attribute) {
if (element.hasAttribute) return element.hasAttribute(attribute);
return Element.Methods.Simulated.hasAttribute(element, attribute);
};
Element.addMethods = function(methods) {
var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
if (!methods) {
Object.extend(Form, Form.Methods);
Object.extend(Form.Element, Form.Element.Methods);
Object.extend(Element.Methods.ByTag, {
"FORM":     Object.clone(Form.Methods),
"INPUT":    Object.clone(Form.Element.Methods),
"SELECT":   Object.clone(Form.Element.Methods),
"TEXTAREA": Object.clone(Form.Element.Methods)
});
}
if (arguments.length == 2) {
var tagName = methods;
methods = arguments[1];
}
if (!tagName) Object.extend(Element.Methods, methods || {});
else {
if (tagName.constructor == Array) tagName.each(extend);
else extend(tagName);
}
function extend(tagName) {
tagName = tagName.toUpperCase();
if (!Element.Methods.ByTag[tagName])
Element.Methods.ByTag[tagName] = {};
Object.extend(Element.Methods.ByTag[tagName], methods);
}
function copy(methods, destination, onlyIfAbsent) {
onlyIfAbsent = onlyIfAbsent || false;
var cache = Element.extend.cache;
for (var property in methods) {
var value = methods[property];
if (!onlyIfAbsent || !(property in destination))
destination[property] = cache.findOrStore(value);
}
}
function findDOMClass(tagName) {
var klass;
var trans = {
"OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
"FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
"DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
"H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
"INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
"TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
"TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
"TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
"FrameSet", "IFRAME": "IFrame"
};
if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
if (window[klass]) return window[klass];
klass = 'HTML' + tagName + 'Element';
if (window[klass]) return window[klass];
klass = 'HTML' + tagName.capitalize() + 'Element';
if (window[klass]) return window[klass];
window[klass] = {};
window[klass].prototype = document.createElement(tagName).__proto__;
return window[klass];
}
if (F.ElementExtensions) {
copy(Element.Methods, HTMLElement.prototype);
copy(Element.Methods.Simulated, HTMLElement.prototype, true);
}
if (F.SpecificElementExtensions) {
for (var tag in Element.Methods.ByTag) {
var klass = findDOMClass(tag);
if (typeof klass == "undefined") continue;
copy(T[tag], klass.prototype);
}
}
Object.extend(Element, Element.Methods);
delete Element.ByTag;
};
var Toggle = { display: Element.toggle };
/*--------------------------------------------------------------------------*/
Abstract.Insertion = function(adjacency) {
this.adjacency = adjacency;
}
Abstract.Insertion.prototype = {
initialize: function(element, content) {
this.element = $(element);
this.content = content.stripScripts();
if (this.adjacency && this.element.insertAdjacentHTML) {
try {
this.element.insertAdjacentHTML(this.adjacency, this.content);
} catch (e) {
var tagName = this.element.tagName.toUpperCase();
if (['TBODY', 'TR'].include(tagName)) {
this.insertContent(this.contentFromAnonymousTable());
} else {
throw e;
}
}
} else {
this.range = this.element.ownerDocument.createRange();
if (this.initializeRange) this.initializeRange();
this.insertContent([this.range.createContextualFragment(this.content)]);
}
setTimeout(function() {content.evalScripts()}, 10);
},
contentFromAnonymousTable: function() {
var div = document.createElement('div');
div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
return $A(div.childNodes[0].childNodes[0].childNodes);
}
}
var Insertion = new Object();
Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
initializeRange: function() {
this.range.setStartBefore(this.element);
},
insertContent: function(fragments) {
fragments.each((function(fragment) {
this.element.parentNode.insertBefore(fragment, this.element);
}).bind(this));
}
});
Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
initializeRange: function() {
this.range.selectNodeContents(this.element);
this.range.collapse(true);
},
insertContent: function(fragments) {
fragments.reverse(false).each((function(fragment) {
this.element.insertBefore(fragment, this.element.firstChild);
}).bind(this));
}
});
Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
initializeRange: function() {
this.range.selectNodeContents(this.element);
this.range.collapse(this.element);
},
insertContent: function(fragments) {
fragments.each((function(fragment) {
this.element.appendChild(fragment);
}).bind(this));
}
});
Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
initializeRange: function() {
this.range.setStartAfter(this.element);
},
insertContent: function(fragments) {
fragments.each((function(fragment) {
this.element.parentNode.insertBefore(fragment,
this.element.nextSibling);
}).bind(this));
}
});
/*--------------------------------------------------------------------------*/
Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
initialize: function(element) {
this.element = $(element);
},
_each: function(iterator) {
this.element.className.split(/\s+/).select(function(name) {
return name.length > 0;
})._each(iterator);
},
set: function(className) {
this.element.className = className;
},
add: function(classNameToAdd) {
if (this.include(classNameToAdd)) return;
this.set($A(this).concat(classNameToAdd).join(' '));
},
remove: function(classNameToRemove) {
if (!this.include(classNameToRemove)) return;
this.set($A(this).without(classNameToRemove).join(' '));
},
toString: function() {
return $A(this).join(' ');
}
};
Object.extend(Element.ClassNames.prototype, Enumerable);
/* Portions of the Selector class are derived from Jack Slocum’s DomQuery,
* part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
* license.  Please see http://www.yui-ext.com/ for more information. */
var Selector = Class.create();
Selector.prototype = {
initialize: function(expression) {
this.expression = expression.strip();
this.compileMatcher();
},
compileMatcher: function() {
// Selectors with namespaced attributes can't use the XPath version
if (Prototype.BrowserFeatures.XPath && !(/\[[\w-]*?:/).test(this.expression))
return this.compileXPathMatcher();
var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
c = Selector.criteria, le, p, m;
if (Selector._cache[e]) {
this.matcher = Selector._cache[e]; return;
}
this.matcher = ["this.matcher = function(root) {",
"var r = root, h = Selector.handlers, c = false, n;"];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i in ps) {
p = ps[i];
if (m = e.match(p)) {
this.matcher.push(typeof c[i] == 'function' ? c[i](m) :
new Template(c[i]).evaluate(m));
e = e.replace(m[0], '');
break;
}
}
}
this.matcher.push("return h.unique(n);\n}");
eval(this.matcher.join('\n'));
Selector._cache[this.expression] = this.matcher;
},
compileXPathMatcher: function() {
var e = this.expression, ps = Selector.patterns,
x = Selector.xpath, le,  m;
if (Selector._cache[e]) {
this.xpath = Selector._cache[e]; return;
}
this.matcher = ['.//*'];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i in ps) {
if (m = e.match(ps[i])) {
this.matcher.push(typeof x[i] == 'function' ? x[i](m) :
new Template(x[i]).evaluate(m));
e = e.replace(m[0], '');
break;
}
}
}
this.xpath = this.matcher.join('');
Selector._cache[this.expression] = this.xpath;
},
findElements: function(root) {
root = root || document;
if (this.xpath) return document._getElementsByXPath(this.xpath, root);
return this.matcher(root);
},
match: function(element) {
return this.findElements(document).include(element);
},
toString: function() {
return this.expression;
},
inspect: function() {
return "#<Selector:" + this.expression.inspect() + ">";
}
};
Object.extend(Selector, {
_cache: {},
xpath: {
descendant:   "//*",
child:        "/*",
adjacent:     "/following-sibling::*[1]",
laterSibling: '/following-sibling::*',
tagName:      function(m) {
if (m[1] == '*') return '';
return "[local-name()='" + m[1].toLowerCase() +
"' or local-name()='" + m[1].toUpperCase() + "']";
},
className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
id:           "[@id='#{1}']",
attrPresence: "[@#{1}]",
attr: function(m) {
m[3] = m[5] || m[6];
return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
},
pseudo: function(m) {
var h = Selector.xpath.pseudos[m[1]];
if (!h) return '';
if (typeof h === 'function') return h(m);
return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
},
operators: {
'=':  "[@#{1}='#{3}']",
'!=': "[@#{1}!='#{3}']",
'^=': "[starts-with(@#{1}, '#{3}')]",
'$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
'*=': "[contains(@#{1}, '#{3}')]",
'~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
'|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
},
pseudos: {
'first-child': '[not(preceding-sibling::*)]',
'last-child':  '[not(following-sibling::*)]',
'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',
'empty':       "[count(*) = 0 and (count(text()) = 0 or translate(text(), ' \t\r\n', '') = '')]",
'checked':     "[@checked]",
'disabled':    "[@disabled]",
'enabled':     "[not(@disabled)]",
'not': function(m) {
var e = m[6], p = Selector.patterns,
x = Selector.xpath, le, m, v;
var exclusion = [];
while (e && le != e && (/\S/).test(e)) {
le = e;
for (var i in p) {
if (m = e.match(p[i])) {
v = typeof x[i] == 'function' ? x[i](m) : new Template(x[i]).evaluate(m);
exclusion.push("(" + v.substring(1, v.length - 1) + ")");
e = e.replace(m[0], '');
break;
}
}
}
return "[not(" + exclusion.join(" and ") + ")]";
},
'nth-child':      function(m) {
return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
},
'nth-last-child': function(m) {
return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
},
'nth-of-type':    function(m) {
return Selector.xpath.pseudos.nth("position() ", m);
},
'nth-last-of-type': function(m) {
return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
},
'first-of-type':  function(m) {
m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
},
'last-of-type':   function(m) {
m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
},
'only-of-type':   function(m) {
var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
},
nth: function(fragment, m) {
var mm, formula = m[6], predicate;
if (formula == 'even') formula = '2n+0';
if (formula == 'odd')  formula = '2n+1';
if (mm = formula.match(/^(\d+)$/)) // digit only
return '[' + fragment + "= " + mm[1] + ']';
if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
if (mm[1] == "-") mm[1] = -1;
var a = mm[1] ? Number(mm[1]) : 1;
var b = mm[2] ? Number(mm[2]) : 0;
predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
"((#{fragment} - #{b}) div #{a} >= 0)]";
return new Template(predicate).evaluate({
fragment: fragment, a: a, b: b });
}
}
}
},
criteria: {
tagName:      'n = h.tagName(n, r, "#{1}", c);   c = false;',
className:    'n = h.className(n, r, "#{1}", c); c = false;',
id:           'n = h.id(n, r, "#{1}", c);        c = false;',
attrPresence: 'n = h.attrPresence(n, r, "#{1}"); c = false;',
attr: function(m) {
m[3] = (m[5] || m[6]);
return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}"); c = false;').evaluate(m);
},
pseudo:       function(m) {
if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
},
descendant:   'c = "descendant";',
child:        'c = "child";',
adjacent:     'c = "adjacent";',
laterSibling: 'c = "laterSibling";'
},
patterns: {
// combinators must be listed first
// (and descendant needs to be last combinator)
laterSibling: /^\s*~\s*/,
child:        /^\s*>\s*/,
adjacent:     /^\s*\+\s*/,
descendant:   /^\s/,
// selectors follow
tagName:      /^\s*(\*|[\w\-]+)(\b|$)?/,
id:           /^#([\w\-\*]+)(\b|$)/,
className:    /^\.([\w\-\*]+)(\b|$)/,
pseudo:       /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|\s|(?=:))/,
attrPresence: /^\[([\w]+)\]/,
attr:         /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\]]*?)\4|([^'"][^\]]*?)))?\]/
},
handlers: {
// UTILITY FUNCTIONS
// joins two collections
concat: function(a, b) {
for (var i = 0, node; node = b[i]; i++)
a.push(node);
return a;
},
// marks an array of nodes for counting
mark: function(nodes) {
for (var i = 0, node; node = nodes[i]; i++)
node._counted = true;
return nodes;
},
unmark: function(nodes) {
for (var i = 0, node; node = nodes[i]; i++)
node._counted = undefined;
return nodes;
},
// mark each child node with its position (for nth calls)
// "ofType" flag indicates whether we're indexing for nth-of-type
// rather than nth-child
index: function(parentNode, reverse, ofType) {
parentNode._counted = true;
if (reverse) {
for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
node = nodes[i];
if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
}
} else {
for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
}
},
// filters out duplicates and extends all nodes
unique: function(nodes) {
if (nodes.length == 0) return nodes;
var results = [], n;
for (var i = 0, l = nodes.length; i < l; i++)
if (!(n = nodes[i])._counted) {
n._counted = true;
results.push(Element.extend(n));
}
return Selector.handlers.unmark(results);
},
// COMBINATOR FUNCTIONS
descendant: function(nodes) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++)
h.concat(results, node.getElementsByTagName('*'));
return results;
},
child: function(nodes) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++) {
for (var j = 0, children = [], child; child = node.childNodes[j]; j++)
if (child.nodeType == 1 && child.tagName != '!') results.push(child);
}
return results;
},
adjacent: function(nodes) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
var next = this.nextElementSibling(node);
if (next) results.push(next);
}
return results;
},
laterSibling: function(nodes) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++)
h.concat(results, Element.nextSiblings(node));
return results;
},
nextElementSibling: function(node) {
while (node = node.nextSibling)
if (node.nodeType == 1) return node;
return null;
},
previousElementSibling: function(node) {
while (node = node.previousSibling)
if (node.nodeType == 1) return node;
return null;
},
// TOKEN FUNCTIONS
tagName: function(nodes, root, tagName, combinator) {
tagName = tagName.toUpperCase();
var results = [], h = Selector.handlers;
if (nodes) {
if (combinator) {
// fastlane for ordinary descendant combinators
if (combinator == "descendant") {
for (var i = 0, node; node = nodes[i]; i++)
h.concat(results, node.getElementsByTagName(tagName));
return results;
} else nodes = this[combinator](nodes);
if (tagName == "*") return nodes;
}
for (var i = 0, node; node = nodes[i]; i++)
if (node.tagName.toUpperCase() == tagName) results.push(node);
return results;
} else return root.getElementsByTagName(tagName);
},
id: function(nodes, root, id, combinator) {
var targetNode = $(id), h = Selector.handlers;
if (!nodes && root == document) return targetNode ? [targetNode] : [];
if (nodes) {
if (combinator) {
if (combinator == 'child') {
for (var i = 0, node; node = nodes[i]; i++)
if (targetNode.parentNode == node) return [targetNode];
} else if (combinator == 'descendant') {
for (var i = 0, node; node = nodes[i]; i++)
if (Element.descendantOf(targetNode, node)) return [targetNode];
} else if (combinator == 'adjacent') {
for (var i = 0, node; node = nodes[i]; i++)
if (Selector.handlers.previousElementSibling(targetNode) == node)
return [targetNode];
} else nodes = h[combinator](nodes);
}
for (var i = 0, node; node = nodes[i]; i++)
if (node == targetNode) return [targetNode];
return [];
}
return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
},
className: function(nodes, root, className, combinator) {
if (nodes && combinator) nodes = this[combinator](nodes);
return Selector.handlers.byClassName(nodes, root, className);
},
byClassName: function(nodes, root, className) {
if (!nodes) nodes = Selector.handlers.descendant([root]);
var needle = ' ' + className + ' ';
for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
nodeClassName = node.className;
if (nodeClassName.length == 0) continue;
if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
results.push(node);
}
return results;
},
attrPresence: function(nodes, root, attr) {
var results = [];
for (var i = 0, node; node = nodes[i]; i++)
if (Element.hasAttribute(node, attr)) results.push(node);
return results;
},
attr: function(nodes, root, attr, value, operator) {
if (!nodes) nodes = root.getElementsByTagName("*");
var handler = Selector.operators[operator], results = [];
for (var i = 0, node; node = nodes[i]; i++) {
var nodeValue = Element.readAttribute(node, attr);
if (nodeValue === null) continue;
if (handler(nodeValue, value)) results.push(node);
}
return results;
},
pseudo: function(nodes, name, value, root, combinator) {
if (nodes && combinator) nodes = this[combinator](nodes);
if (!nodes) nodes = root.getElementsByTagName("*");
return Selector.pseudos[name](nodes, value, root);
}
},
pseudos: {
'first-child': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
if (Selector.handlers.previousElementSibling(node)) continue;
results.push(node);
}
return results;
},
'last-child': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
if (Selector.handlers.nextElementSibling(node)) continue;
results.push(node);
}
return results;
},
'only-child': function(nodes, value, root) {
var h = Selector.handlers;
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
results.push(node);
return results;
},
'nth-child':        function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root);
},
'nth-last-child':   function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root, true);
},
'nth-of-type':      function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root, false, true);
},
'nth-last-of-type': function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, formula, root, true, true);
},
'first-of-type':    function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, "1", root, false, true);
},
'last-of-type':     function(nodes, formula, root) {
return Selector.pseudos.nth(nodes, "1", root, true, true);
},
'only-of-type':     function(nodes, formula, root) {
var p = Selector.pseudos;
return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
},
// handles the an+b logic
getIndices: function(a, b, total) {
if (a == 0) return b > 0 ? [b] : [];
return $R(1, total).inject([], function(memo, i) {
if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
return memo;
});
},
// handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
nth: function(nodes, formula, root, reverse, ofType) {
if (nodes.length == 0) return [];
if (formula == 'even') formula = '2n+0';
if (formula == 'odd')  formula = '2n+1';
var h = Selector.handlers, results = [], indexed = [], m;
h.mark(nodes);
for (var i = 0, node; node = nodes[i]; i++) {
if (!node.parentNode._counted) {
h.index(node.parentNode, reverse, ofType);
indexed.push(node.parentNode);
}
}
if (formula.match(/^\d+$/)) { // just a number
formula = Number(formula);
for (var i = 0, node; node = nodes[i]; i++)
if (node.nodeIndex == formula) results.push(node);
} else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
if (m[1] == "-") m[1] = -1;
var a = m[1] ? Number(m[1]) : 1;
var b = m[2] ? Number(m[2]) : 0;
var indices = Selector.pseudos.getIndices(a, b, nodes.length);
for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
for (var j = 0; j < l; j++)
if (node.nodeIndex == indices[j]) results.push(node);
}
}
h.unmark(nodes);
h.unmark(indexed);
return results;
},
'empty': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++) {
// IE treats comments as element nodes
if (node.tagName == '!' || (node.firstChild && !node.innerHTML.match(/^\s*$/))) continue;
results.push(node);
}
return results;
},
'not': function(nodes, selector, root) {
var h = Selector.handlers, selectorType, m;
var exclusions = new Selector(selector).findElements(root);
h.mark(exclusions);
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (!node._counted) results.push(node);
h.unmark(exclusions);
return results;
},
'enabled': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (!node.disabled) results.push(node);
return results;
},
'disabled': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (node.disabled) results.push(node);
return results;
},
'checked': function(nodes, value, root) {
for (var i = 0, results = [], node; node = nodes[i]; i++)
if (node.checked) results.push(node);
return results;
}
},
operators: {
'=':  function(nv, v) { return nv == v; },
'!=': function(nv, v) { return nv != v; },
'^=': function(nv, v) { return nv.startsWith(v); },
'$=': function(nv, v) { return nv.endsWith(v); },
'*=': function(nv, v) { return nv.include(v); },
'~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
'|=': function(nv, v) { return ('-' + nv.toUpperCase() + '-').include('-' + v.toUpperCase() + '-'); }
},
matchElements: function(elements, expression) {
var matches = new Selector(expression).findElements(), h = Selector.handlers;
h.mark(matches);
for (var i = 0, results = [], element; element = elements[i]; i++)
if (element._counted) results.push(element);
h.unmark(matches);
return results;
},
findElement: function(elements, expression, index) {
if (typeof expression == 'number') {
index = expression; expression = false;
}
return Selector.matchElements(elements, expression || '*')[index || 0];
},
findChildElements: function(element, expressions) {
var exprs = expressions.join(','), expressions = [];
exprs.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
expressions.push(m[1].strip());
});
var results = [], h = Selector.handlers;
for (var i = 0, l = expressions.length, selector; i < l; i++) {
selector = new Selector(expressions[i].strip());
h.concat(results, selector.findElements(element));
}
return (l > 1) ? h.unique(results) : results;
}
});
function $$() {
return Selector.findChildElements(document, $A(arguments));
}
var Form = {
reset: function(form) {
$(form).reset();
return form;
},
serializeElements: function(elements, getHash) {
var data = elements.inject({}, function(result, element) {
if (!element.disabled && element.name) {
var key = element.name, value = $(element).getValue();
if (value != null) {
if (key in result) {
if (result[key].constructor != Array) result[key] = [result[key]];
result[key].push(value);
}
else result[key] = value;
}
}
return result;
});
return getHash ? data : Hash.toQueryString(data);
}
};
Form.Methods = {
serialize: function(form, getHash) {
return Form.serializeElements(Form.getElements(form), getHash);
},
getElements: function(form) {
return $A($(form).getElementsByTagName('*')).inject([],
function(elements, child) {
if (Form.Element.Serializers[child.tagName.toLowerCase()])
elements.push(Element.extend(child));
return elements;
}
);
},
getInputs: function(form, typeName, name) {
form = $(form);
var inputs = form.getElementsByTagName('input');
if (!typeName && !name) return $A(inputs).map(Element.extend);
for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
var input = inputs[i];
if ((typeName && input.type != typeName) || (name && input.name != name))
continue;
matchingInputs.push(Element.extend(input));
}
return matchingInputs;
},
disable: function(form) {
form = $(form);
Form.getElements(form).invoke('disable');
return form;
},
enable: function(form) {
form = $(form);
Form.getElements(form).invoke('enable');
return form;
},
findFirstElement: function(form) {
return $(form).getElements().find(function(element) {
return element.type != 'hidden' && !element.disabled &&
['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
});
},
focusFirstElement: function(form) {
form = $(form);
form.findFirstElement().activate();
return form;
},
request: function(form, options) {
form = $(form), options = Object.clone(options || {});
var params = options.parameters;
options.parameters = form.serialize(true);
if (params) {
if (typeof params == 'string') params = params.toQueryParams();
Object.extend(options.parameters, params);
}
if (form.hasAttribute('method') && !options.method)
options.method = form.method;
return new Ajax.Request(form.readAttribute('action'), options);
}
}
/*--------------------------------------------------------------------------*/
Form.Element = {
focus: function(element) {
$(element).focus();
return element;
},
select: function(element) {
$(element).select();
return element;
}
}
Form.Element.Methods = {
serialize: function(element) {
element = $(element);
if (!element.disabled && element.name) {
var value = element.getValue();
if (value != undefined) {
var pair = {};
pair[element.name] = value;
return Hash.toQueryString(pair);
}
}
return '';
},
getValue: function(element) {
element = $(element);
var method = element.tagName.toLowerCase();
return Form.Element.Serializers[method](element);
},
clear: function(element) {
$(element).value = '';
return element;
},
present: function(element) {
return $(element).value != '';
},
activate: function(element) {
element = $(element);
try {
element.focus();
if (element.select && (element.tagName.toLowerCase() != 'input' ||
!['button', 'reset', 'submit'].include(element.type)))
element.select();
} catch (e) {}
return element;
},
disable: function(element) {
element = $(element);
element.blur();
element.disabled = true;
return element;
},
enable: function(element) {
element = $(element);
element.disabled = false;
return element;
}
}
/*--------------------------------------------------------------------------*/
var Field = Form.Element;
var $F = Form.Element.Methods.getValue;
/*--------------------------------------------------------------------------*/
Form.Element.Serializers = {
input: function(element) {
switch (element.type.toLowerCase()) {
case 'checkbox':
case 'radio':
return Form.Element.Serializers.inputSelector(element);
default:
return Form.Element.Serializers.textarea(element);
}
},
inputSelector: function(element) {
return element.checked ? element.value : null;
},
textarea: function(element) {
return element.value;
},
select: function(element) {
return this[element.type == 'select-one' ?
'selectOne' : 'selectMany'](element);
},
selectOne: function(element) {
var index = element.selectedIndex;
return index >= 0 ? this.optionValue(element.options[index]) : null;
},
selectMany: function(element) {
var values, length = element.length;
if (!length) return null;
for (var i = 0, values = []; i < length; i++) {
var opt = element.options[i];
if (opt.selected) values.push(this.optionValue(opt));
}
return values;
},
optionValue: function(opt) {
// extend element because hasAttribute may not be native
return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
}
}
/*--------------------------------------------------------------------------*/
Abstract.TimedObserver = function() {}
Abstract.TimedObserver.prototype = {
initialize: function(element, frequency, callback) {
this.frequency = frequency;
this.element   = $(element);
this.callback  = callback;
this.lastValue = this.getValue();
this.registerCallback();
},
registerCallback: function() {
setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},
onTimerEvent: function() {
var value = this.getValue();
var changed = ('string' == typeof this.lastValue && 'string' == typeof value
? this.lastValue != value : String(this.lastValue) != String(value));
if (changed) {
this.callback(this.element, value);
this.lastValue = value;
}
}
}
Form.Element.Observer = Class.create();
Form.Element.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
getValue: function() {
return Form.Element.getValue(this.element);
}
});
Form.Observer = Class.create();
Form.Observer.prototype = Object.extend(new Abstract.TimedObserver(), {
getValue: function() {
return Form.serialize(this.element);
}
});
/*--------------------------------------------------------------------------*/
Abstract.EventObserver = function() {}
Abstract.EventObserver.prototype = {
initialize: function(element, callback) {
this.element  = $(element);
this.callback = callback;
this.lastValue = this.getValue();
if (this.element.tagName.toLowerCase() == 'form')
this.registerFormCallbacks();
else
this.registerCallback(this.element);
},
onElementEvent: function() {
var value = this.getValue();
if (this.lastValue != value) {
this.callback(this.element, value);
this.lastValue = value;
}
},
registerFormCallbacks: function() {
Form.getElements(this.element).each(this.registerCallback.bind(this));
},
registerCallback: function(element) {
if (element.type) {
switch (element.type.toLowerCase()) {
case 'checkbox':
case 'radio':
Event.observe(element, 'click', this.onElementEvent.bind(this));
break;
default:
Event.observe(element, 'change', this.onElementEvent.bind(this));
break;
}
}
}
}
Form.Element.EventObserver = Class.create();
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
getValue: function() {
return Form.Element.getValue(this.element);
}
});
Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(), {
getValue: function() {
return Form.serialize(this.element);
}
});
if (!window.Event) {
var Event = new Object();
}
Object.extend(Event, {
KEY_BACKSPACE: 8,
KEY_TAB:       9,
KEY_RETURN:   13,
KEY_ESC:      27,
KEY_LEFT:     37,
KEY_UP:       38,
KEY_RIGHT:    39,
KEY_DOWN:     40,
KEY_DELETE:   46,
KEY_HOME:     36,
KEY_END:      35,
KEY_PAGEUP:   33,
KEY_PAGEDOWN: 34,
element: function(event) {
return $(event.target || event.srcElement);
},
isLeftClick: function(event) {
return (((event.which) && (event.which == 1)) ||
((event.button) && (event.button == 1)));
},
pointerX: function(event) {
return event.pageX || (event.clientX +
(document.documentElement.scrollLeft || document.body.scrollLeft));
},
pointerY: function(event) {
return event.pageY || (event.clientY +
(document.documentElement.scrollTop || document.body.scrollTop));
},
stop: function(event) {
if (event.preventDefault) {
event.preventDefault();
event.stopPropagation();
} else {
event.returnValue = false;
event.cancelBubble = true;
}
},
// find the first node with the given tagName, starting from the
// node the event was triggered on; traverses the DOM upwards
findElement: function(event, tagName) {
var element = Event.element(event);
while (element.parentNode && (!element.tagName ||
(element.tagName.toUpperCase() != tagName.toUpperCase())))
element = element.parentNode;
return element;
},
observers: false,
_observeAndCache: function(element, name, observer, useCapture) {
if (!this.observers) this.observers = [];
if (element.addEventListener) {
this.observers.push([element, name, observer, useCapture]);
element.addEventListener(name, observer, useCapture);
} else if (element.attachEvent) {
this.observers.push([element, name, observer, useCapture]);
element.attachEvent('on' + name, observer);
}
},
unloadCache: function() {
if (!Event.observers) return;
for (var i = 0, length = Event.observers.length; i < length; i++) {
Event.stopObserving.apply(this, Event.observers[i]);
Event.observers[i][0] = null;
}
Event.observers = false;
},
observe: function(element, name, observer, useCapture) {
element = $(element);
useCapture = useCapture || false;
if (name == 'keypress' &&
(Prototype.Browser.WebKit || element.attachEvent))
name = 'keydown';
Event._observeAndCache(element, name, observer, useCapture);
},
stopObserving: function(element, name, observer, useCapture) {
element = $(element);
useCapture = useCapture || false;
if (name == 'keypress' &&
(Prototype.Browser.WebKit || element.attachEvent))
name = 'keydown';
if (element.removeEventListener) {
element.removeEventListener(name, observer, useCapture);
} else if (element.detachEvent) {
try {
element.detachEvent('on' + name, observer);
} catch (e) {}
}
}
});
/* prevent memory leaks in IE */
if (Prototype.Browser.IE)
Event.observe(window, 'unload', Event.unloadCache, false);
var Position = {
// set to true if needed, warning: firefox performance problems
// NOT neeeded for page scrolling, only if draggable contained in
// scrollable elements
includeScrollOffsets: false,
// must be called before calling withinIncludingScrolloffset, every time the
// page is scrolled
prepare: function() {
this.deltaX =  window.pageXOffset
|| document.documentElement.scrollLeft
|| document.body.scrollLeft
|| 0;
this.deltaY =  window.pageYOffset
|| document.documentElement.scrollTop
|| document.body.scrollTop
|| 0;
},
realOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.scrollTop  || 0;
valueL += element.scrollLeft || 0;
element = element.parentNode;
} while (element);
return [valueL, valueT];
},
cumulativeOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.offsetTop  || 0;
valueL += element.offsetLeft || 0;
element = element.offsetParent;
} while (element);
return [valueL, valueT];
},
positionedOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.offsetTop  || 0;
valueL += element.offsetLeft || 0;
element = element.offsetParent;
if (element) {
if(element.tagName=='BODY') break;
var p = Element.getStyle(element, 'position');
if (p == 'relative' || p == 'absolute') break;
}
} while (element);
return [valueL, valueT];
},
offsetParent: function(element) {
if (element.offsetParent) return element.offsetParent;
if (element == document.body) return element;
while ((element = element.parentNode) && element != document.body)
if (Element.getStyle(element, 'position') != 'static')
return element;
return document.body;
},
// caches x/y coordinate pair to use with overlap
within: function(element, x, y) {
if (this.includeScrollOffsets)
return this.withinIncludingScrolloffsets(element, x, y);
this.xcomp = x;
this.ycomp = y;
this.offset = this.cumulativeOffset(element);
return (y >= this.offset[1] &&
y <  this.offset[1] + element.offsetHeight &&
x >= this.offset[0] &&
x <  this.offset[0] + element.offsetWidth);
},
withinIncludingScrolloffsets: function(element, x, y) {
var offsetcache = this.realOffset(element);
this.xcomp = x + offsetcache[0] - this.deltaX;
this.ycomp = y + offsetcache[1] - this.deltaY;
this.offset = this.cumulativeOffset(element);
return (this.ycomp >= this.offset[1] &&
this.ycomp <  this.offset[1] + element.offsetHeight &&
this.xcomp >= this.offset[0] &&
this.xcomp <  this.offset[0] + element.offsetWidth);
},
// within must be called directly before
overlap: function(mode, element) {
if (!mode) return 0;
if (mode == 'vertical')
return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
element.offsetHeight;
if (mode == 'horizontal')
return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
element.offsetWidth;
},
page: function(forElement) {
var valueT = 0, valueL = 0;
var element = forElement;
do {
valueT += element.offsetTop  || 0;
valueL += element.offsetLeft || 0;
// Safari fix
if (element.offsetParent == document.body)
if (Element.getStyle(element,'position')=='absolute') break;
} while (element = element.offsetParent);
element = forElement;
do {
if (!window.opera || element.tagName=='BODY') {
valueT -= element.scrollTop  || 0;
valueL -= element.scrollLeft || 0;
}
} while (element = element.parentNode);
return [valueL, valueT];
},
clone: function(source, target) {
var options = Object.extend({
setLeft:    true,
setTop:     true,
setWidth:   true,
setHeight:  true,
offsetTop:  0,
offsetLeft: 0
}, arguments[2] || {})
// find page position of source
source = $(source);
var p = Position.page(source);
// find coordinate system to use
target = $(target);
var delta = [0, 0];
var parent = null;
// delta [0,0] will do fine with position: fixed elements,
// position:absolute needs offsetParent deltas
if (Element.getStyle(target,'position') == 'absolute') {
parent = Position.offsetParent(target);
delta = Position.page(parent);
}
// correct by body offsets (fixes Safari)
if (parent == document.body) {
delta[0] -= document.body.offsetLeft;
delta[1] -= document.body.offsetTop;
}
// set position
if(options.setLeft)   target.style.left  = (p[0] - delta[0] + options.offsetLeft) + 'px';
if(options.setTop)    target.style.top   = (p[1] - delta[1] + options.offsetTop) + 'px';
if(options.setWidth)  target.style.width = source.offsetWidth + 'px';
if(options.setHeight) target.style.height = source.offsetHeight + 'px';
},
absolutize: function(element) {
element = $(element);
if (element.style.position == 'absolute') return;
Position.prepare();
var offsets = Position.positionedOffset(element);
var top     = offsets[1];
var left    = offsets[0];
var width   = element.clientWidth;
var height  = element.clientHeight;
element._originalLeft   = left - parseFloat(element.style.left  || 0);
element._originalTop    = top  - parseFloat(element.style.top || 0);
element._originalWidth  = element.style.width;
element._originalHeight = element.style.height;
element.style.position = 'absolute';
element.style.top    = top + 'px';
element.style.left   = left + 'px';
element.style.width  = width + 'px';
element.style.height = height + 'px';
},
relativize: function(element) {
element = $(element);
if (element.style.position == 'relative') return;
Position.prepare();
element.style.position = 'relative';
var top  = parseFloat(element.style.top  || 0) - (element._originalTop || 0);
var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);
element.style.top    = top + 'px';
element.style.left   = left + 'px';
element.style.height = element._originalHeight;
element.style.width  = element._originalWidth;
}
}
// Safari returns margins on body which is incorrect if the child is absolutely
// positioned.  For performance reasons, redefine Position.cumulativeOffset for
// KHTML/WebKit only.
if (Prototype.Browser.WebKit) {
Position.cumulativeOffset = function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.offsetTop  || 0;
valueL += element.offsetLeft || 0;
if (element.offsetParent == document.body)
if (Element.getStyle(element, 'position') == 'absolute') break;
element = element.offsetParent;
} while (element);
return [valueL, valueT];
}
}
Element.addMethods();

// ***************************************************************************************************************
// ***************************************************************************************************************
// Librairie getelementbyselector
// ***************************************************************************************************************
// ***************************************************************************************************************
// ATTENTION : cette librairie n'a pas été écrite par AGAMA
// permet de sélectionner une liste d'éléments en précisant un chemin DOM quelconque
// ***************************************************************************************************************
// ***************************************************************************************************************
// code pour conserver le codage UTF-8 dans C-génie : éàè
/* document.getElementsBySelector(selector)
- returns an array of element objects from the current document
matching the CSS selector. Selectors can contain element names, 
class names and ids and can be nested. For example:
elements = document.getElementsBySelect('div#main p a.external')
Will return an array of all 'a' elements with 'external' in their 
class attribute that are contained inside 'p' elements that are 
contained inside the 'div' element which has id="main"
New in version 0.4: Support for CSS2 and CSS3 attribute selectors:
See http://www.w3.org/TR/css3-selectors/#attribute-selectors
Version 0.4 - Simon Willison, March 25th 2003
-- Works in Phoenix 0.5, Mozilla 1.3, Opera 7, Internet Explorer 6, Internet Explorer 5 on Windows
-- Opera 7 fails 
*/
function getAllChildren(e) {
// Returns all children of element. Workaround required for IE5/Windows. Ugh.
return e.all ? e.all : e.getElementsByTagName('*');
}
document.getElementsBySelector = function(selector) {
// Attempt to fail gracefully in lesser browsers
if (!document.getElementsByTagName) {
return new Array();
}
// Split selector in to tokens
var tokens = selector.split(' ');
var currentContext = new Array(document);
for (var i = 0; i < tokens.length; i++) {
token = tokens[i].replace(/^\s+/,'').replace(/\s+$/,'');;
if (token.indexOf('#') > -1) {
// Token is an ID selector
var bits = token.split('#');
var tagName = bits[0];
var id = bits[1];
var element = document.getElementById(id);
if (tagName && element.nodeName.toLowerCase() != tagName) {
// tag with that ID not found, return false
return new Array();
}
// Set currentContext to contain just this element
currentContext = new Array(element);
continue; // Skip to next token
}
if (token.indexOf('.') > -1) {
// Token contains a class selector
var bits = token.split('.');
var tagName = bits[0];
var className = bits[1];
if (!tagName) {
tagName = '*';
}
// Get elements matching tag, filter them for class selector
var found = new Array;
var foundCount = 0;
for (var h = 0; h < currentContext.length; h++) {
var elements;
if (tagName == '*') {
elements = getAllChildren(currentContext[h]);
} else {
elements = currentContext[h].getElementsByTagName(tagName);
}
for (var j = 0; j < elements.length; j++) {
found[foundCount++] = elements[j];
}
}
currentContext = new Array;
var currentContextIndex = 0;
for (var k = 0; k < found.length; k++) {
if (found[k].className && found[k].className.match(new RegExp('\\b'+className+'\\b'))) {
currentContext[currentContextIndex++] = found[k];
}
}
continue; // Skip to next token
}
// Code to deal with attribute selectors
if (token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/)) {
var tagName = RegExp.$1;
var attrName = RegExp.$2;
var attrOperator = RegExp.$3;
var attrValue = RegExp.$4;
if (!tagName) {
tagName = '*';
}
// Grab all of the tagName elements within current context
var found = new Array;
var foundCount = 0;
for (var h = 0; h < currentContext.length; h++) {
var elements;
if (tagName == '*') {
elements = getAllChildren(currentContext[h]);
} else {
elements = currentContext[h].getElementsByTagName(tagName);
}
for (var j = 0; j < elements.length; j++) {
found[foundCount++] = elements[j];
}
}
currentContext = new Array;
var currentContextIndex = 0;
var checkFunction; // This function will be used to filter the elements
switch (attrOperator) {
case '=': // Equality
checkFunction = function(e) { return (e.getAttribute(attrName) == attrValue); };
break;
case '~': // Match one of space seperated words 
checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('\\b'+attrValue+'\\b'))); };
break;
case '|': // Match start with value followed by optional hyphen
checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?'))); };
break;
case '^': // Match starts with value
checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) == 0); };
break;
case '$': // Match ends with value - fails with "Warning" in Opera 7
checkFunction = function(e) { return (e.getAttribute(attrName).lastIndexOf(attrValue) == e.getAttribute(attrName).length - attrValue.length); };
break;
case '*': // Match ends with value
checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) > -1); };
break;
default :
// Just test for existence of attribute
checkFunction = function(e) { return e.getAttribute(attrName); };
}
currentContext = new Array;
var currentContextIndex = 0;
for (var k = 0; k < found.length; k++) {
if (checkFunction(found[k])) {
currentContext[currentContextIndex++] = found[k];
}
}
// alert('Attribute Selector: '+tagName+' '+attrName+' '+attrOperator+' '+attrValue);
continue; // Skip to next token
}
if (!currentContext[0]){
return;
}
// If we get here, token is JUST an element (not a class or ID selector)
tagName = token;
var found = new Array;
var foundCount = 0;
for (var h = 0; h < currentContext.length; h++) {
var elements = currentContext[h].getElementsByTagName(tagName);
for (var j = 0; j < elements.length; j++) {
found[foundCount++] = elements[j];
}
}
currentContext = found;
}
return currentContext;
}
/* That revolting regular expression explained 
/^(\w+)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/
\---/  \---/\-------------/    \-------/
|      |         |               |
|      |         |           The value
|      |    ~,|,^,$,* or =
|   Attribute 
Tag
*/

/*
var mes_demandes = {
0 : {
"selecteur" : "b.uneclass",
"evenement" : "onclick",
"action" : function()
{
alert(this.innerHTML);
}
},
1 : {
"selecteur" : "#un_identifiant u",
"evenement" : "onmouseover",
"action" : function()
{
this.innerHTML = "BLAH!";
}
}
};
amelioration.ajouter_des_ameliorations( mes_demandes );
appeler amelioration.appliquer_les_ameliorations() pour réappliquer les améliorations
*/
var amelioration =
{
"liste_des_ameliorations" : new Array(),
"ajouter_des_ameliorations" : function( demandes )
{
for( var num_demande=0 ; ma_demande=demandes[num_demande] ; num_demande++ )
amelioration.liste_des_ameliorations.push( ma_demande );
},
"appliquer_les_ameliorations" : function()
{
var liste_des_elements = null;
var ma_demande = null;
var mon_element = null;
for( var num_demande=0 ; ma_demande=amelioration.liste_des_ameliorations[num_demande] ; num_demande++ )
{
liste_des_elements = document.getElementsBySelector( ma_demande.selecteur );
if( !liste_des_elements )
continue;
for( var num_element=0 ; mon_element=liste_des_elements[num_element] ; num_element++ )
{
if( document.all )
{
mon_element.detachEvent( ma_demande.evenement, ma_demande.action );
mon_element.attachEvent( ma_demande.evenement, ma_demande.action );
}
else
{
mon_element.removeEventListener( ma_demande.evenement.substr( 2, ma_demande.evenement.length-2 ), ma_demande.action, false );
mon_element.addEventListener( ma_demande.evenement.substr( 2, ma_demande.evenement.length-2 ), ma_demande.action, false );
}
}
}
}
};
// ajout vb1 : propriete trim sur les string
String.prototype.trim = function(str) {
str = this != window? this : str;
// vb1 : modif de la regexp : remplacé  \s par [\s\xA0]
// car replace de \s ( espace ) ne fonctionne pas sous IE quand la chaine comporte des espaces créés
// par conversion de &nbsp; par la méthode unescapeHTML() car le code de ce caractere est 160( A0 ) au lieu de 32
return str.replace(/^[\s\xA0]+/g, '').replace(/[\s\xA0]+$/g, ''); 
};
// ajout vb1 : propriete removeaccent sur les string
String.prototype.removeaccent = function(str) {
str = this != window? this : str;
return str.replace(/[àáâãäå]/g, 'a').replace(/[èéêë]/g, 'e').replace(/[ìíîï]/g, 'i').
replace(/[òóôõö]/g, 'o').replace(/ñ/g, 'n').replace(/[ùúûü]/g, 'u').replace(/[ýÿ]/g, 'y').
replace(/ç/g, 'c').replace(/œ/g, 'oe');
};
// ajout vb1 : propriete removeaccent sur les string
String.prototype.convertir_en_nom_de_variable = function(str) {
str = this != window? this : str;
return str.trim().removeaccent().toLowerCase().replace(/[ ]/g, '_');
};
if( document.all )
window.attachEvent( "onload", amelioration.appliquer_les_ameliorations );
else
window.addEventListener( "load", amelioration.appliquer_les_ameliorations, false );

/*	Unobtrusive Flash Objects (UFO) v3.21 <http://www.bobbyvandersluis.com/ufo/>
Copyright 2005, 2006 Bobby van der Sluis
This software is licensed under the CC-GNU LGPL <http://creativecommons.org/licenses/LGPL/2.1/>
*/
var UFO = {
req: ["movie", "width", "height", "majorversion", "build"],
opt: ["play", "loop", "menu", "quality", "scale", "salign", "wmode", "bgcolor", "base", "flashvars", "devicefont", "allowscriptaccess", "seamlesstabbing", "allowfullscreen"],
optAtt: ["id", "name", "align", "onmouseover", "onmouseout", "onclick", "onmouseup", "onmousedown"],
optExc: ["swliveconnect"],
ximovie: "ufo.swf",
xiwidth: "215",
xiheight: "138",
ua: navigator.userAgent.toLowerCase(),
pluginType: "",
fv: [0,0],
foList: [],
create: function(FO, id) {
if (!UFO.uaHas("w3cdom") || UFO.uaHas("ieMac")) return;
UFO.getFlashVersion();
UFO.foList[id] = UFO.updateFO(FO);
UFO.createCSS("#" + id, "visibility:hidden;");
UFO.domLoad(id);
},
updateFO: function(FO) {
if (typeof FO.xi != "undefined" && FO.xi == "true") {
if (typeof FO.ximovie == "undefined") FO.ximovie = UFO.ximovie;
if (typeof FO.xiwidth == "undefined") FO.xiwidth = UFO.xiwidth;
if (typeof FO.xiheight == "undefined") FO.xiheight = UFO.xiheight;
}
FO.mainCalled = false;
return FO;
},
domLoad: function(id) {
var _t = setInterval(function() {
if ((document.getElementsByTagName("body")[0] != null || document.body != null) && document.getElementById(id) != null) {
UFO.main(id);
clearInterval(_t);
}
}, 250);
if (typeof document.addEventListener != "undefined") {
document.addEventListener("DOMContentLoaded", function() { UFO.main(id); clearInterval(_t); } , null); // Gecko, Opera 9+
}
},
main: function(id) {
var _fo = UFO.foList[id];
if (_fo.mainCalled) return;
UFO.foList[id].mainCalled = true;
document.getElementById(id).style.visibility = "hidden";
if (UFO.hasRequired(id)) {
if (UFO.hasFlashVersion(parseInt(_fo.majorversion, 10), parseInt(_fo.build, 10))) {
if (typeof _fo.setcontainercss != "undefined" && _fo.setcontainercss == "true") UFO.setContainerCSS(id);
UFO.writeSWF(id);
}
else if (_fo.xi == "true" && UFO.hasFlashVersion(6, 65)) {
UFO.createDialog(id);
}
}
document.getElementById(id).style.visibility = "visible";
},
createCSS: function(selector, declaration) {
var _h = document.getElementsByTagName("head")[0]; 
var _s = UFO.createElement("style");
if (!UFO.uaHas("ieWin")) _s.appendChild(document.createTextNode(selector + " {" + declaration + "}")); // bugs in IE/Win
_s.setAttribute("type", "text/css");
_s.setAttribute("media", "screen"); 
_h.appendChild(_s);
if (UFO.uaHas("ieWin") && document.styleSheets && document.styleSheets.length > 0) {
var _ls = document.styleSheets[document.styleSheets.length - 1];
if (typeof _ls.addRule == "object") _ls.addRule(selector, declaration);
}
},
setContainerCSS: function(id) {
var _fo = UFO.foList[id];
var _w = /%/.test(_fo.width) ? "" : "px";
var _h = /%/.test(_fo.height) ? "" : "px";
UFO.createCSS("#" + id, "width:" + _fo.width + _w +"; height:" + _fo.height + _h +";");
if (_fo.width == "100%") {
UFO.createCSS("body", "margin-left:0; margin-right:0; padding-left:0; padding-right:0;");
}
if (_fo.height == "100%") {
UFO.createCSS("html", "height:100%; overflow:hidden;");
UFO.createCSS("body", "margin-top:0; margin-bottom:0; padding-top:0; padding-bottom:0; height:100%;");
}
},
createElement: function(el) {
return (UFO.uaHas("xml") && typeof document.createElementNS != "undefined") ?  document.createElementNS("http://www.w3.org/1999/xhtml", el) : document.createElement(el);
},
createObjParam: function(el, aName, aValue) {
var _p = UFO.createElement("param");
_p.setAttribute("name", aName);	
_p.setAttribute("value", aValue);
el.appendChild(_p);
},
uaHas: function(ft) {
var _u = UFO.ua;
switch(ft) {
case "w3cdom":
return (typeof document.getElementById != "undefined" && typeof document.getElementsByTagName != "undefined" && (typeof document.createElement != "undefined" || typeof document.createElementNS != "undefined"));
case "xml":
var _m = document.getElementsByTagName("meta");
var _l = _m.length;
for (var i = 0; i < _l; i++) {
if (/content-type/i.test(_m[i].getAttribute("http-equiv")) && /xml/i.test(_m[i].getAttribute("content"))) return true;
}
return false;
case "ieMac":
return /msie/.test(_u) && !/opera/.test(_u) && /mac/.test(_u);
case "ieWin":
return /msie/.test(_u) && !/opera/.test(_u) && /win/.test(_u);
case "gecko":
return /gecko/.test(_u) && !/applewebkit/.test(_u);
case "opera":
return /opera/.test(_u);
case "safari":
return /applewebkit/.test(_u);
default:
return false;
}
},
getFlashVersion: function() {
if (UFO.fv[0] != 0) return;  
if (navigator.plugins && typeof navigator.plugins["Shockwave Flash"] == "object") {
UFO.pluginType = "npapi";
var _d = navigator.plugins["Shockwave Flash"].description;
if (typeof _d != "undefined") {
_d = _d.replace(/^.*\s+(\S+\s+\S+$)/, "$1");
var _m = parseInt(_d.replace(/^(.*)\..*$/, "$1"), 10);
var _r = /r/.test(_d) ? parseInt(_d.replace(/^.*r(.*)$/, "$1"), 10) : 0;
UFO.fv = [_m, _r];
}
}
else if (window.ActiveXObject) {
UFO.pluginType = "ax";
try { // avoid fp 6 crashes
var _a = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
}
catch(e) {
try { 
var _a = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
UFO.fv = [6, 0];
_a.AllowScriptAccess = "always"; // throws if fp < 6.47 
}
catch(e) {
if (UFO.fv[0] == 6) return;
}
try {
var _a = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
}
catch(e) {}
}
if (typeof _a == "object") {
var _d = _a.GetVariable("$version"); // bugs in fp 6.21/6.23
if (typeof _d != "undefined") {
_d = _d.replace(/^\S+\s+(.*)$/, "$1").split(",");
UFO.fv = [parseInt(_d[0], 10), parseInt(_d[2], 10)];
}
}
}
},
hasRequired: function(id) {
var _l = UFO.req.length;
for (var i = 0; i < _l; i++) {
if (typeof UFO.foList[id][UFO.req[i]] == "undefined") return false;
}
return true;
},
hasFlashVersion: function(major, release) {
return (UFO.fv[0] > major || (UFO.fv[0] == major && UFO.fv[1] >= release)) ? true : false;
},
writeSWF: function(id) {
var _fo = UFO.foList[id];
var _e = document.getElementById(id);
if (UFO.pluginType == "npapi") {
if (UFO.uaHas("gecko") || UFO.uaHas("xml")) {
while(_e.hasChildNodes()) {
_e.removeChild(_e.firstChild);
}
var _obj = UFO.createElement("object");
_obj.setAttribute("type", "application/x-shockwave-flash");
_obj.setAttribute("data", _fo.movie);
_obj.setAttribute("width", _fo.width);
_obj.setAttribute("height", _fo.height);
_obj.setAttribute("BackToTheHtml", "oui" );
var _l = UFO.optAtt.length;
for (var i = 0; i < _l; i++) {
if (typeof _fo[UFO.optAtt[i]] != "undefined") _obj.setAttribute(UFO.optAtt[i], _fo[UFO.optAtt[i]]);
}
var _o = UFO.opt.concat(UFO.optExc);
var _l = _o.length;
for (var i = 0; i < _l; i++) {
if (typeof _fo[_o[i]] != "undefined") UFO.createObjParam(_obj, _o[i], _fo[_o[i]]);
}
_e.appendChild(_obj);
}
else {
var _emb = "";
var _o = UFO.opt.concat(UFO.optAtt).concat(UFO.optExc);
var _l = _o.length;
for (var i = 0; i < _l; i++) {
if (typeof _fo[_o[i]] != "undefined") _emb += ' ' + _o[i] + '="' + _fo[_o[i]] + '"';
}
_e.innerHTML = '<embed BackToTheHtml="oui" type="application/x-shockwave-flash" src="' + _fo.movie + '" width="' + _fo.width + '" height="' + _fo.height + '" pluginspage="http://www.macromedia.com/go/getflashplayer"' + _emb + '></embed>';
}
}
else if (UFO.pluginType == "ax") {
var _objAtt = "";
var _l = UFO.optAtt.length;
for (var i = 0; i < _l; i++) {
if (typeof _fo[UFO.optAtt[i]] != "undefined") _objAtt += ' ' + UFO.optAtt[i] + '="' + _fo[UFO.optAtt[i]] + '"';
}
var _objPar = "";
var _l = UFO.opt.length;
for (var i = 0; i < _l; i++) {
if (typeof _fo[UFO.opt[i]] != "undefined") _objPar += '<param name="' + UFO.opt[i] + '" value="' + _fo[UFO.opt[i]] + '" />';
}
var _p = window.location.protocol == "https:" ? "https:" : "http:";
_e.innerHTML = '<object BackToTheHtml="oui" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"' + _objAtt + ' width="' + _fo.width + '" height="' + _fo.height + '" codebase="' + _p + '//download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=' + _fo.majorversion + ',0,' + _fo.build + ',0"><param name="movie" value="' + _fo.movie + '" />' + _objPar + '</object>';
}
},
createDialog: function(id) {
var _fo = UFO.foList[id];
UFO.createCSS("html", "height:100%; overflow:hidden;");
UFO.createCSS("body", "height:100%; overflow:hidden;");
UFO.createCSS("#xi-con", "position:absolute; left:0; top:0; z-index:1000; width:100%; height:100%; background-color:#fff; filter:alpha(opacity:75); opacity:0.75;");
UFO.createCSS("#xi-dia", "position:absolute; left:50%; top:50%; margin-left: -" + Math.round(parseInt(_fo.xiwidth, 10) / 2) + "px; margin-top: -" + Math.round(parseInt(_fo.xiheight, 10) / 2) + "px; width:" + _fo.xiwidth + "px; height:" + _fo.xiheight + "px;");
var _b = document.getElementsByTagName("body")[0];
var _c = UFO.createElement("div");
_c.setAttribute("id", "xi-con");
var _d = UFO.createElement("div");
_d.setAttribute("id", "xi-dia");
_c.appendChild(_d);
_b.appendChild(_c);
var _mmu = window.location;
if (UFO.uaHas("xml") && UFO.uaHas("safari")) {
var _mmd = document.getElementsByTagName("title")[0].firstChild.nodeValue = document.getElementsByTagName("title")[0].firstChild.nodeValue.slice(0, 47) + " - Flash Player Installation";
}
else {
var _mmd = document.title = document.title.slice(0, 47) + " - Flash Player Installation";
}
var _mmp = UFO.pluginType == "ax" ? "ActiveX" : "PlugIn";
var _uc = typeof _fo.xiurlcancel != "undefined" ? "&xiUrlCancel=" + _fo.xiurlcancel : "";
var _uf = typeof _fo.xiurlfailed != "undefined" ? "&xiUrlFailed=" + _fo.xiurlfailed : "";
UFO.foList["xi-dia"] = { movie:_fo.ximovie, width:_fo.xiwidth, height:_fo.xiheight, majorversion:"6", build:"65", flashvars:"MMredirectURL=" + _mmu + "&MMplayerType=" + _mmp + "&MMdoctitle=" + _mmd + _uc + _uf };
UFO.writeSWF("xi-dia");
},
expressInstallCallback: function() {
var _b = document.getElementsByTagName("body")[0];
var _c = document.getElementById("xi-con");
_b.removeChild(_c);
UFO.createCSS("body", "height:auto; overflow:auto;");
UFO.createCSS("html", "height:auto; overflow:auto;");
},
cleanupIELeaks: function() {
var _o = document.getElementsByTagName("object");
var _l = _o.length
for (var i = 0; i < _l; i++) {
_o[i].style.display = "none";
for (var x in _o[i]) {
if (typeof _o[i][x] == "function") {
_o[i][x] = null;
}
}
}
}
};
if (typeof window.attachEvent != "undefined" && UFO.uaHas("ieWin")) {
window.attachEvent("onunload", UFO.cleanupIELeaks);
}

// ***********************************************************************************************************
// Fonctions diverses
// ***********************************************************************************************************
function getElementsByClassName( ptr, clsName ) 
{ 
var arr = new Array(); 
var elems = ptr.getElementsByTagName("*");
for ( i = 0; ( elem = elems[i] ); i++ )
{		
if ( elem.className == clsName )
{
if( typeof( elem.innerHTML ) != "undefined" )
{
var id = elem.getAttribute("id");
arr[id] = elem.innerHTML;	
}
}
}
return arr;
}
function changer_langue( langue )
{
var mon_url = document.location + "";
if( window.location.hash != "" )
mon_url = xreplace( mon_url, document.location.hash, "" );
mon_url = xreplace( mon_url, "#", "" );
if( window.location.search == "" )
document.location = mon_url + "?changer_langue=" + langue;
else
document.location = mon_url + "&changer_langue=" + langue;
}
function imprimer_la_page( )
{
var mon_url = document.location + "?imprimer_la_page=oui";	
window.open(mon_url ,null,'width=650,height=600, status=yes, directories=yes, toolbar=yes, location=yes, menubar=yes, scrollbars=yes, resizable=yes');
}
// ***********************************************************************************************************
// Gestion de la barre de recherche
// ***********************************************************************************************************
var recherche_vider_recherche_flag = false;
function recherche_vider_recherche()
{
if( recherche_vider_recherche_flag == false )
{
recherche_vider_recherche_flag = true;
$( "mot_recherche_sur_le_site" ).value = "";	
}
}
// ***********************************************************************************************************
// Gestion de l'identification
// ***********************************************************************************************************
var identification_login_modifie = false;
function identification_verifier_login()
{
if( identification_login_modifie == false )
{
identification_login_modifie = true;
$( "identification_identifiant" ).value = "";
$( "identification_mot_de_passe" ).value = "";
}
}
function identification_identifier()
{
if( ( $( 'identification_identifiant' ).value == "" )
|| ( $( 'identification_mot_de_passe' ).value == "" )
|| ( identification_login_modifie == false )
)
return;
Element.hide( 'identification_message_pb' );
Element.show( 'identification_message_en_cours' );
$( 'identification_identifiant' ).disabled = true;
$( 'identification_mot_de_passe' ).disabled = true;
$( 'identification_go' ).disabled = true;
var mon_ajax = new Ajax.Request(
window.location.protocol + "//" + window.location.host + "/" + langue + "?codage_page=html",
{
method: 'post',
parameters: "identification_identifiant=" + $( 'identification_identifiant' ).value + "&identification_mot_de_passe=" + $( 'identification_mot_de_passe' ).value,
onComplete: identification_identifier_retour
} );	
}
function identification_identifier_retour( reponse )
{	
var tempo = null;
if( $( 'tempo_login' ) == null )
new Insertion.Bottom( document.getElementsByTagName( "body" )[0], '<div id="tempo_login"></div>' );
tempo = $( 'tempo_login' );
$( 'tempo_login' ).innerHTML = reponse.responseText;
if( $( 'login-on' ) == null )
{
tempo.innerHTML = "";
$( 'identification_identifiant' ).disabled = false;
$( 'identification_mot_de_passe' ).disabled = false;
$( 'identification_go' ).disabled = false;
Element.hide( 'identification_message_en_cours' );
Element.show( 'identification_message_pb' );
}
else
{
$( 'bloc_identification' ).innerHTML = $( 'login-on' ).outerHTML;
recharger_ajax( reponse );
}
tempo.innerHTML = "";
}
function identification_deconnecter()
{
Element.hide( 'lien_deconnexion' );
Element.show( 'deconnexion_message_en_cours' );
var mon_ajax = new Ajax.Request(
window.location.protocol + "//" + window.location.host + "/" + langue + "/profil/deconnecter",
{
method: 'post',
parameters: "sans_redirection=oui&codage_page=html",
onComplete: identification_deconnecter_retour
} );
}
function identification_deconnecter_retour( reponse )
{
var tempo = null;
if( $( 'tempo_login' ) == null )
new Insertion.Bottom( document.getElementsByTagName( "body" )[0], '<div id="tempo_login"></div>' );
tempo = $( 'tempo_login' );
identification_login_modifie = false;
$( 'tempo_login' ).innerHTML = reponse.responseText;
$( 'bloc_identification' ).innerHTML = $( 'login-off' ).outerHTML;
recharger_ajax( reponse );
$('identification_mot_de_passe').value="xxxx";
}
function recharger_ajax( reponse )
{	
var ptr = $( 'tempo_login' );
ptr.innerHTML = reponse.responseText;
var block_ajax = getElementsByClassName(ptr, "reload_ajax");	
ptr.innerHTML = "";	
for(var indice in block_ajax)
{  
if(typeof(block_ajax[indice])=="string")
{
$( indice ).innerHTML = block_ajax[indice];
var liste_des_javascripts = $( indice ).getElementsByTagName("SCRIPT");
$A(liste_des_javascripts).each(function(noeud){
if( noeud.text.substring( 1, 5 ) == '<' + '!' + '--' )
eval(noeud.text.substring( 6, noeud.text.length-4 ));
else
eval(noeud.text);
});
}		
}	 
}
// ***********************************************************************************************************
// Gestion du scrolling
// ***********************************************************************************************************
var scroll_position = 0;
var scroll_taille = 0;
var scroll_timer = null;
function scroll_init()
{
if( $( 'mon_scroll' ) == null )
return;
scroll_taille = $( 'mon_scroll' ).offsetHeight;
scroll_position = 0;
$( 'mon_scroll' ).innerHTML = $( 'mon_scroll' ).innerHTML + $( 'mon_scroll' ).innerHTML;
scroll_timer = null;
scroll_start()
}
function scroll_start()
{
if( scroll_timer == null )
scroll_timer = setInterval( 'scroll_scroll()', 300 );
}
function scroll_stop()
{
if( scroll_timer != null )
clearInterval( scroll_timer );
scroll_timer = null;
}
function scroll_scroll()
{
scroll_position = scroll_position-3;
if( scroll_position < -scroll_taille )
scroll_position += scroll_taille;
$( 'mon_scroll' ).style.top = scroll_position + "px";
}
ajouter_evenement( window, 'load', scroll_init );
// ***********************************************************************************************************
// Gestion de l'heure
// ***********************************************************************************************************
/*
function heure__mettre_a_jour()
{
var liste_des_heures = getElementsByAttribute( "className", "heure" );
for( var num_heure = 0 ; num_heure<liste_des_heures.length ; num_heure++ )
{
var ma_date = new Date();
var format_de_l_heure;
if( !hasAttribute( liste_des_heures[num_heure], "heure__format_de_l_heure" ) )
setAttribute( liste_des_heures[num_heure], "heure__format_de_l_heure", liste_des_heures[num_heure].innerText );
format_de_l_heure = getAttribute( liste_des_heures[num_heure], "heure__format_de_l_heure" );
ma_date.setTime( ma_date.getTime() + 60000 * ( 60 * getAttribute( liste_des_heures[num_heure], "heure__decalage" ) + ma_date.getTimezoneOffset() ) );
heure = "";
for( var num=0 ; num<format_de_l_heure.length ; num++ )
{
if( format_de_l_heure.substr( num, 1 ) != "%" )
heure += format_de_l_heure.substr( num, 1 )
else
{
num++;
switch( format_de_l_heure.substr( num, 1 ) )
{
// %h : affiche les heures (mode 24h) avec le moins de chiffre possible (ex : "1" pour 1h, "14" pour 14h)
case "h" :
heure += ma_date.getHours();
break;
// %H : affiche les heures (mode 24h) avec deux chiffres (ex : "01" pour 1h, "14" pour 14h)
case "H" :
heure += remplir_a_2_chiffres( ma_date.getHours() );
break;
// %t : affiche les heures (mode 12h) avec le moins de chiffre possible (ex : "1" pour 1h, "2" pour 14h)
case "t" :
if( ma_date.getHours() < 12 )
	heure += ma_date.getHours();
else
	heure += ma_date.getHours()-12;
break;
// %T : affiche les heures (mode 12h) avec deux chiffres (ex : "01" pour 1h, "02" pour 14h)
case "T" :
if( ma_date.getHours() < 12 )
	heure += remplir_a_2_chiffres( ma_date.getHours() );
else
	heure += remplir_a_2_chiffres( ma_date.getHours()-12 );
break;
// %m : affiche les minutes avec le moins de chiffre possible (ex : "1" pour 1mn, "14" pour 14mn)
case "m" :
heure += ma_date.getMinutes();
break;
// %M : affiche les minutes avec deux chiffres (ex : "01" pour 1mn, "14" pour 14mn)
case "M" :
heure += remplir_a_2_chiffres( ma_date.getMinutes() );
break;
// %s : affiche les secondes avec le moins de chiffre possible (ex : "1" pour 1s, "14" pour 14s)
case "s" :
heure += ma_date.getSeconds();
break;
// %S : affiche les secondes avec deux chiffres (ex : "01" pour 1s, "14" pour 14s)
case "S" :
heure += remplir_a_2_chiffres( ma_date.getSeconds() );
break;
// %a : affiche am ou pm en fonction de l'heure
case "a" :
if( ma_date.getHours() < 12 )
	heure += "am";
else
	heure += "pm";
break;
// %A : affiche AM ou PM en fonction de l'heure
case "A" :
if( ma_date.getHours() < 12 )
	heure += "AM";
else
	heure += "PM";
break;
}
}
}
liste_des_heures[num_heure].innerText = heure;
}
setTimeout( "heure__mettre_a_jour()", 60000 );
}
ajouter_evenement( window, 'load', heure__mettre_a_jour );
*/
// ***********************************************************************************************************
// Moteur de recherche Etudes-mémos
// ***********************************************************************************************************
var page_courante = 0;
function montrer_page( nombre )
{
if( $( 'page_de_resultats__' + nombre ) == null )
return;
if( page_courante > 0 )
{
Element.hide( 'page_de_resultats__' + page_courante );
Element.removeClassName( 'lien_page_haut__' + page_courante, 'pagination-select' );
Element.removeClassName( 'lien_page_bas__' + page_courante, 'pagination-select' );
}
Element.show( 'page_de_resultats__' + nombre );
Element.addClassName( 'lien_page_haut__' + nombre, 'pagination-select' );
Element.addClassName( 'lien_page_bas__' + nombre, 'pagination-select' );
page_courante = nombre
}
function moteur_de_recherche_lingway__lancer()
{
barre_d_attente_afficher( 'Searching' );
Element.show( 'barre_d_attente_layer' );
Element.hide( 'resultats' );
}
// ***********************************************************************************************************
// Veilles
// ***********************************************************************************************************
function verifier_criteres_de_veille()
{
for( var num_veille=1 ; num_veille<6 ; num_veille++ )
{
var produit = $( 'produit_veille_' + num_veille );
var pays = $( 'pays_veille_' + num_veille );
var valeur_produit = "";
var valeur_pays = "";
if( ( produit != null ) && ( pays != null ) )
{
if( produit.tagName == "INPUT" )
valeur_produit = produit.value;
if( produit.tagName == "SELECT" )
valeur_produit = produit.options[produit.selectedIndex].value;
if( pays.tagName == "INPUT" )
valeur_pays = pays.value;
if( pays.tagName == "SELECT" )
valeur_pays = pays.options[pays.selectedIndex].value;
if( ( ( valeur_produit == "" ) && ( valeur_pays != "" ) )
|| ( ( valeur_produit != "" ) && ( valeur_pays == "" ) ) )
{
alert( veille_message );
return false;
}
}
}
}
// ***********************************************************************************************************
// Flux import-export
// ***********************************************************************************************************
var position=-72*3;
function lancer_animation()
{
if( $( 'zform' ).action == "#resultats" )
setInterval( 'moveScroll()', 400 );
Element.show( 'toto' );
}
function moveScroll()
{
position = position+68;
if( position > 544-68-68 )
position=-204;
$( 'toto' ).style.margin = "0px 0px 0px " + position + "px";
}
function popup(url,width,height)
{
window.open( url, "Popup", "width=" + width + ",height=" + height);
}
// Transfert d'un select à un autre
function affecte_select(input,select)
{
pi=document.getElementById(input);
ps=document.getElementById(select);
if( pi.options.selectedIndex != -1 )
{
ind=(ps.options.length);
ps.options[ind]= new Option(pi.options[pi.options.selectedIndex].text,pi.options[pi.options.selectedIndex].value);
pi.options[pi.options.selectedIndex]=null;
}
}
// Retire du select de destination et remet à l'origine par ordre alphabétique
function retire_select(input,select)
{
pi=document.getElementById(input);
ps=document.getElementById(select);
if( ps.options.selectedIndex != -1 )
{
ind=(pi.options.length);
for (var a = 0; a <ind; a ++)
{
if(ps.options[ps.options.selectedIndex].text<pi.options[a].text)
{
for (var b = ind; b >a; b-=1 )
pi.options[b]= new Option(pi.options[b-1].text,pi.options[b-1].value);
pi.options[a]= new Option(ps.options[ps.options.selectedIndex].text,ps.options[ps.options.selectedIndex].value);
a=ind;
}
}
ps.options[ps.options.selectedIndex]=null;
}
}
function clic_select(select)
{
ps=document.getElementById(select);
ind=(ps.options.length);
for (var a = 0; a <ind; a++)
ps.options[a].selected=true;
}
function efface_select(input,select)
{
ps=document.getElementById(select);
while(ps.options.length>0)
{
ps.options[0].selected=true;
retire_select(input,select);
}
}
function cherche_nc()
{
document.getElementById('cnp_lib').innerHTML='';
frech.location.href='/' + langue + '/services/decouvrez-les-flux-d-un-produit-entre-deux-pays_numero-nomenclature?nc='+document.getElementById('nc').value
}
function fixer_type_de_flux()
{
if( document.getElementById('flux_1').checked )
$( "type_de_flux" ).className = "type_de_flux_import";
else
$( "type_de_flux" ).className = "type_de_flux_export";
}
// ***********************************************************************************************************
// calcul de prix export
// ***********************************************************************************************************
function calcul_feuille_haut() {
transmettre_log_service_automatise( 'S_auto_7' );
document.tableau.fbft.value =
Math.round(
(
parseFloat( document.tableau.mpupa.value )
+ parseFloat( document.tableau.mffde.value )
+ parseFloat( document.tableau.vm.value )
+ parseFloat( document.tableau.cmcabcg.value )
)*100 )/100;
document.tableau.caf.value =
Math.round(
(
parseFloat( document.tableau.fbft.value )
+ parseFloat( document.tableau.cttp.value )
+ parseFloat( document.tableau.catp.value )
)*100 )/100;
document.tableau.ddd.value =
Math.round(
(
( parseFloat( document.tableau.dddp.value ) / 100 ) * parseFloat( document.tableau.caf.value )
)*100 )/100;
document.tableau.ti.value =
Math.round(
(
( parseFloat( document.tableau.tip.value ) / 100 ) * parseFloat( document.tableau.caf.value )
)*100 )/100;
document.tableau.rda.value =
Math.round(
(
parseFloat( document.tableau.caf.value )
+ parseFloat( document.tableau.ddd.value )
+ parseFloat( document.tableau.ti.value )
+ parseFloat( document.tableau.cpapadp.value )
+ parseFloat( document.tableau.mmapapd.value )
+ parseFloat( document.tableau.mfdi.value )
)*100 )/100;
}
function calcul_feuille_bas() {
transmettre_log_service_automatise( 'S_auto_7' );
document.tableau.mi.value =
Math.round(
(
parseFloat( document.tableau.rdabis.value ) / ( 1 - ( parseFloat( document.tableau.mip.value ) / 100 ) )
- parseFloat( document.tableau.rdabis.value )
)*100 )/100;
document.tableau.pvg.value =
Math.round(
(
parseFloat( document.tableau.rdabis.value )
+ parseFloat( document.tableau.mi.value )
)*100 )/100;
document.tableau.mgca.value =
Math.round(
(
parseFloat( document.tableau.pvg.value ) / ( 1 - ( parseFloat( document.tableau.mgcap.value ) / 100 ) )
- parseFloat( document.tableau.pvg.value )
)*100 )/100;
document.tableau.pvd.value =
Math.round(
(
parseFloat( document.tableau.pvg.value )
+ parseFloat( document.tableau.mgca.value )
)*100 )/100;
document.tableau.md.value =
Math.round(
(
parseFloat( document.tableau.pvd.value ) / ( 1 - ( parseFloat( document.tableau.mdp.value ) / 100 ) )
- parseFloat( document.tableau.pvd.value )
)*100 )/100;
document.tableau.pvcfht.value =
Math.round(
(
parseFloat( document.tableau.md.value )
+ parseFloat( document.tableau.pvd.value )
)*100 )/100;
document.tableau.ttva.value =
Math.round(
(
parseFloat( document.tableau.pvcfht.value ) * ( parseFloat( document.tableau.ttvap.value ) / 100 )
)*100 )/100;
document.tableau.pvttc.value =
Math.round(
(
parseFloat( document.tableau.pvcfht.value )
+ parseFloat( document.tableau.ttva.value )
)*100 )/100;
}
function calctout(aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak,al,am,an,ao,ap,aq,ar){
aa=parseFloat(aa);ab=parseFloat(ab);ac=parseFloat(ac);ad=parseFloat(ad);ae=parseFloat(ae); af=parseFloat(af);ag=parseFloat(ag);ah=parseFloat(ah);ai=parseFloat(ai);aj=parseFloat(aj); ak=parseFloat(ak);al=parseFloat(al);am=parseFloat(am);an=parseFloat(an);ao=parseFloat(ao);
ap=parseFloat(ap);aq=parseFloat(aq);ar=parseFloat(ar);
ad=aa+ab+ac;         ad= Math.round (ad*100)/100;
document.tableau.fbft.value=ad;
ai=ad+ae+ag+ah;        ai= Math.round (ai*100)/100;
document.tableau.caf.value=ai;
al=(ad+ae+af)*(ak/100);         al= Math.round (al*100)/100;
document.tableau.ddd.value=al;
an=ai*(am/100);         an= Math.round (an*100)/100;
document.tableau.ti.value=an;
ap=ai+aj+al+an+ao;         ap= Math.round (ap*100)/100;
document.tableau.rqpdc.value=ap;
ar=ap+aq;         ar= Math.round (ar*100)/100;
document.tableau.rda.value=ar;
document.tableau.rdabis.value=ar;
return;
}
function calcfin(arbis,as,at,au,av,aw,ax,ay,az,ba,bb,bc,bd){
arbis=parseFloat(arbis);as=parseFloat(as);at=parseFloat(at);au=parseFloat(au);
av=parseFloat(av);aw=parseFloat(aw);ax=parseFloat(ax);ay=parseFloat(ay);
az=parseFloat(az);ba=parseFloat(ba);bb=parseFloat(bb);bc=parseFloat(bc);bd=parseFloat(bd);
at=arbis*(as/100);         at= Math.round (at*100)/100;
document.tableau.mi.value=at;
au=arbis+at;
au=arbis+at;               au= Math.round (au*100)/100;
document.tableau.pvg.value=au;
aw=au*(av/100);         aw= Math.round (aw*100)/100;
document.tableau.mgca.value=aw;
ax=au+aw;         ax= Math.round (ax*100)/100;
document.tableau.pvd.value=ax;
az=(ay/100)*ax;         az= Math.round (az*100)/100;
document.tableau.md.value=az;
ba=az+ax;        ba= Math.round (ba*100)/100;
document.tableau.pvcfht.value=ba;
bc=ba*(1+(bb/100));         bc= Math.round (bc*100)/100;
document.tableau.pvttc.value=bc;
bd=ba*(bb/100);                   bd= Math.round (bd*100)/100;
document.tableau.ttva.value=bd;
return;
}
// ***********************************************************************************************************
// conversion de mesures
// ***********************************************************************************************************
function init(name,valeur){
this.name=name
this.valeur=valeur
}
var long = new Array(8)
var mass = Array(7)
var volu = Array(6)
var surf = Array(8)
if( langue == 'fr' )
{
long[0]= new init("metres",1)
long[1]= new init("centimetres",0.01)
long[2]= new init("millimetres",0.001)
long[3]= new init("kilometres",1000)
long[4]= new init("inches",0.0254)
long[5]= new init("feet",0.3048)
long[6]= new init("yards",0.9144)
long[7]= new init("miles",1609.3)
mass[0]= new init("kilogrammes",1)
mass[1]= new init("milligrammes",0.000001)
mass[2]= new init("grammes",0.001)
mass[3]= new init("tonnes",1000)
mass[4]= new init("pounds",0.4536)
mass[5]= new init("onces",0.002835)
mass[6]= new init("us tons",1016)
volu[0]= new init("metres cube",1)
volu[1]= new init("centimetres cube",0.000001)
volu[2]= new init("decimetres cube ou litres",0.001)
volu[3]= new init("cubic inches (cu.in)",0.0000016387)
volu[4]= new init("cubic feet (cu.ft)",0.02832)
volu[5]= new init("cubic yards (cu.yd)",0.7646)
volu[6]= new init("U.S. gallons (gal)",0.003785)
surf[0]= new init("metres carre",1)
surf[1]= new init("centimetres carre",0.0001)
surf[2]= new init("ares",100)
surf[3]= new init("hectares",10000)
surf[4]= new init("kilometres carre",100000)
surf[5]= new init("square inches (sq.in)",0.00064516)
surf[6]= new init("square feet (sq.ft)",0.0929)
surf[7]= new init("square yards (sq.yd)",0.8361)
}
else if( langue == 'uk' )
{
long[0]= new init("metres",1)
long[1]= new init("centimetres",0.01)
long[2]= new init("millimetres",0.001)
long[3]= new init("kilometres",1000)
long[4]= new init("inches",0.0254)
long[5]= new init("feet",0.3048)
long[6]= new init("yards",0.9144)
long[7]= new init("miles",1609.3)
mass[0]= new init("kilograms",1)
mass[1]= new init("milligrams",0.000001)
mass[2]= new init("grams",0.001)
mass[3]= new init("tons",1000)
mass[4]= new init("pounds",0.4536)
mass[5]= new init("ounces",0.002835)
mass[6]= new init("US tons",1016)
volu[0]= new init("cubic metre",1)
volu[1]= new init("cubic centimetre",0.000001)
volu[2]= new init("cubic decimetre or litre",0.001)
volu[3]= new init("cubic inches (cu.in)",0.0000016387)
volu[4]= new init("cubic feet (cu.ft)",0.02832)
volu[5]= new init("cubic yards (cu.yd)",0.7646)
volu[6]= new init("U.S. gallons (gal)",0.003785)
surf[0]= new init("square metre",1)
surf[1]= new init("square centimetre",0.0001)
surf[2]= new init("are",100)
surf[3]= new init("acres",10000)
surf[4]= new init("square kilometre",100000)
surf[5]= new init("square inches (sq.in)",0.00064516)
surf[6]= new init("square feet (sq.ft)",0.0929)
surf[7]= new init("square yards (sq.yd)",0.8361)
}
else if( langue == 'de' )
{
long[0]= new init("meter",1)
long[1]= new init("zentimeter",0.01)
long[2]= new init("millimeter",0.001)
long[3]= new init("kilometer",1000)
long[4]= new init("zoll",0.0254)
long[5]= new init("fuß",0.3048)
long[6]= new init("yard",0.9144)
long[7]= new init("meilen",1609.3)
mass[0]= new init("kilogramm",1)
mass[1]= new init("milligramm",0.000001)
mass[2]= new init("gramm",0.001)
mass[3]= new init("tonnen",1000)
mass[4]= new init("pfund",0.4536)
mass[5]= new init("unze",0.002835)
mass[6]= new init("Amerikanische tonne",1016)
volu[0]= new init("kubikmeter",1)
volu[1]= new init("kubikzentimeter",0.000001)
volu[2]= new init("kubikdezimeter oder Liter",0.001)
volu[3]= new init("kubikzoll (cu.in)",0.0000016387)
volu[4]= new init("kubikfuß (cu.ft)",0.02832)
volu[5]= new init("kubikyard (cu.yd)",0.7646)
volu[6]= new init("Amerikanische gallonen (gal)",0.003785)
surf[0]= new init("guadratmeter",1)
surf[1]= new init("quadratzentimeter",0.0001)
surf[2]= new init("ar",100)
surf[3]= new init("hektar",10000)
surf[4]= new init("quadratkilometer",100000)
surf[5]= new init("quadratzoll (sq.in)",0.00064516)
surf[6]= new init("quadratfuß (sq.ft)",0.0929)
surf[7]= new init("quadratyard (sq.yd)",0.8361)
}
function calcul(type)
{transmettre_log_service_automatise( 'S_auto_5' );
if(type == "tempe"){
valeur = document.conversion.val_tempe1.value
unite_1 = document.conversion.unit_tempe1[document.conversion.unit_tempe1.selectedIndex].value
unite_2 = document.conversion.unit_tempe2[document.conversion.unit_tempe2.selectedIndex].value
if((unite_1 == "vide") || (unite_2 == "vide")){
return 1;
}
if(unite_1 == 0){
if(unite_2 == 0){
x = valeur
x = x * 1000
x = Math.round(x)
x = x / 1000
document.conversion.val_tempe2.value = x
}
else{
x = (valeur * 1.8) + 32
x = x * 1000
x = Math.round(x)
x = x / 1000
document.conversion.val_tempe2.value = x
}
}
else{
if(unite_2 == 0){
x = (valeur - 32) / 1.8
x = x * 1000
x = Math.round(x)
x = x / 1000
document.conversion.val_tempe2.value = x
}
else{
x = valeur
x = x * 1000
x = Math.round(x)
x = x / 1000
document.conversion.val_tempe2.value = x
}
}
}
else{
valeur = eval("document.conversion.val_"+ type +"1.value")
unite_1 = eval("document.conversion.unit_"+ type +"1[document.conversion.unit_"+ type +"1.selectedIndex].value")
unite_2 = eval("document.conversion.unit_"+ type +"2[document.conversion.unit_"+ type +"2.selectedIndex].value")
if((unite_1 == "vide") || (unite_2 == "vide")){
return 1;
}
x = eval("(valeur * "+ type +"[unite_1].valeur) / "+ type +"[unite_2].valeur")
x = x * 1000
x = Math.round(x)
x = x / 1000
eval("document.conversion.val_"+ type +"2.value = x")
}
}
// ***********************************************************************************************************
// conversion de devises
// ***********************************************************************************************************
var monnaie_pivot = 0;
var ancienne_valeur=0;
function convertion_des_devises()
{
var signe_de_la_monnaie_pivot = monnaie_pivot;
if( monnaie_pivot == "sup1" )
signe_de_la_monnaie_pivot = document.devises.supp1.options[document.devises.supp1.selectedIndex].value;
if( monnaie_pivot == "sup2" )
signe_de_la_monnaie_pivot = document.devises.supp2.options[document.devises.supp2.selectedIndex].value;
ref = eval( "monnaie_" + signe_de_la_monnaie_pivot ) * eval( "document.devises." + monnaie_pivot + ".value" );
if( eval( "document.devises." + monnaie_pivot + ".value" ) != ancienne_valeur ) {
ancienne_valeur = eval( "document.devises." + monnaie_pivot + ".value" );
;transmettre_log_service_automatise( 'S_auto_6' );
}
document.devises.USD.value = Math.round( ref / monnaie_USD * 10000 ) / 10000;
document.devises.AUD.value = Math.round( ref / monnaie_AUD * 10000 ) / 10000;
document.devises.BRL.value = Math.round( ref / monnaie_BRL * 10000 ) / 10000;
document.devises.CAD.value = Math.round( ref / monnaie_CAD * 10000 ) / 10000;
document.devises.CNY.value = Math.round( ref / monnaie_CNY * 10000 ) / 10000;
document.devises.EUR.value = Math.round( ref / monnaie_EUR * 10000 ) / 10000;
document.devises.FRF.value = Math.round( ref / monnaie_FRF * 10000 ) / 10000;
document.devises.HKD.value = Math.round( ref / monnaie_HKD * 10000 ) / 10000;
document.devises.HUF.value = Math.round( ref / monnaie_HUF * 10000 ) / 10000;
document.devises.INR.value = Math.round( ref / monnaie_INR * 10000 ) / 10000;
document.devises.JPY.value = Math.round( ref / monnaie_JPY * 10000 ) / 10000;
document.devises.MXP.value = Math.round( ref / monnaie_MXP * 10000 ) / 10000;
document.devises.PLZ.value = Math.round( ref / monnaie_PLZ * 10000 ) / 10000;
document.devises.GBP.value = Math.round( ref / monnaie_GBP * 10000 ) / 10000;
document.devises.SEK.value = Math.round( ref / monnaie_SEK * 10000 ) / 10000;
document.devises.CHF.value = Math.round( ref / monnaie_CHF * 10000 ) / 10000;
document.devises.CSK.value = Math.round( ref / monnaie_CSK * 10000 ) / 10000;
document.devises.MAD.value = Math.round( ref / monnaie_MAD * 10000 ) / 10000;
document.devises.sup1.value = Math.round( ref / eval( "monnaie_" + document.devises.supp1.options[document.devises.supp1.selectedIndex].value ) * 10000 ) / 10000;
document.devises.sup2.value = Math.round( ref / eval( "monnaie_" + document.devises.supp2.options[document.devises.supp2.selectedIndex].value ) * 10000 ) / 10000;
}
function SelDev( monnaie )
{
monnaie_pivot = monnaie;
ancienne_valeur = eval( "document.devises." + monnaie_pivot + ".value" );
}
// ***********************************************************************************************************
// nomenclature douaniere
// ***********************************************************************************************************
function modifier_numero( texte )
{
$('codesel').innerHTML = texte;
Element.show( 'ma_table' );
}
function affdesc(s)
{
$('description2').innerHTML = s;
}
function ajax_description( code )
{
var drapeaux = "&nbsp;";
//alert('/' + langue + '/services/connaitre-votre-numero-de-nomenclature-douaniere-description?langue_nomenclature=' + langue + '&code='+escape(code));
result_row = ajax_file('/' + langue + '/services/connaitre-votre-numero-de-nomenclature-douaniere-description?langue_nomenclature=' + langue + '&code='+escape(code));
var phrase=result_row.replace(/\r/g,"").split("\n");
for( num_trad=0 ; num_trad<phrase.length-1 ; num_trad++ )
{
var elem=phrase[num_trad].split( "\t" );
var langue_tempo = elem[0];
var desc = elem[1];
if( langue_tempo.toLowerCase() == langue.toLowerCase() )
affdesc( desc );
if( desc != "" )
{
//			deschtml = desc.replace(/''/g,"'");
deschtml = desc.replace(/'/g,"\\'"); //"
deschtml = deschtml.replace(/>/g,'&gt;');
deschtml = deschtml.replace(/</g,'&lt;');
deschtml = deschtml.replace(/""/g,'');
drapeaux = drapeaux + '<a href="#" onclick="affdesc(\'' + deschtml + '\')">' + langue_tempo + '</a>&nbsp;';
}
}
//	document.getElementById('drapeaux').innerHTML=drapeaux;
}
function valide()
{
if( nomenclature__desc != "" )
top.opener.document.getElementById(nomenclature__desc).innerHTML=document.getElementById('description').innerHTML
if( nomenclature__code != "" )
{
s=document.getElementById('codesel').innerHTML;
s=s.replace(/ /g,'')
top.opener.document.getElementById(nomenclature__code).value=s;
}
top.window.close();
}
var img_trdroit = new Image;
img_trdroit.src = "/commun/images/nomenclature/trdroit.gif"
var img_trbas = new Image;
img_trbas.src = "/commun/images/nomenclature/trbas.gif"
function nbsp(n){
var s='',t;
if(n>3){
for(t=0;t<n;t++){
s+='&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
}
}
return s;
}
// Mise à jour via AJAX
function ajax_select(niveau,code){
var retour;
retour='<table>';
if( nomenclature__action == "liste" )
result_row = ajax_file('/' + langue + '/services/connaitre-votre-numero-de-nomenclature-douaniere-flux?langue_nomenclature=' + langue + '&code='+escape(code)+'&niveau='+escape(niveau)+'&ms=' + new Date().getTime());
else
result_row = ajax_file('/' + langue + '/services/connaitre-votre-numero-de-nomenclature-douaniere-flux-rech?langue_nomenclature=' + langue + '&recherche=' + nomenclature__recherche + '&code='+escape(code)+'&niveau='+escape(niveau)+'&ms=' + new Date().getTime());
var phrase=result_row.split("\n");
for(t=0;t<phrase.length-1;t++){
var elem=phrase[t].split("\t");
if(elem[2].length<10 || elem[1].substr(10,2)=='10'){
//		if(elem[0]<4 && (elem[2].length<10 || (elem[1].substr(10,2)=='10'))){
image="/commun/images/nomenclature/trdroit.gif";
code='id=img'+elem[1];
chaine_div='<div id="'+elem[1]+'" style="display:none;width:100%"></div>';
//			if(elem[1].substr(10,2)=='10'){
//				elem[2]='---- -- --';
//			}
}else{
image="/commun/images/nomenclature/vide.gif";
code='';
chaine_div='';
}
if(elem[0]==3 ){ // str(elem[1].substr(10,2)=='80'){
if(elem[2].substr(5,2)=='00'){
elem[2]=elem[2].substr(0,4);
}
}
if(elem[0]==4 ){ // && elem[1].substr(10,2)=='10'
if(elem[2].substr(8,2)=='00'){
elem[2]=elem[2].substr(0,7);
}
}
title=elem[4].replace('"','');
title=title.replace('"','');
title=title.replace('"','');
title=title.replace('"','');
if(title.length>4){
title='title="'+title+'"';
}		
retour+='<TABLE CELLPADDING="3" CELLSPACING="1" class="code'+elem[0]+'"><TR><TD class=code'+elem[0]+'>&nbsp;&nbsp;<A class=code HREF="javascript:ouvreNiveau(\''+elem[1]+'\',\''+elem[2]+'\',\''+elem[0]+'\');" '+title+'><img src="'+image+'" '+code+' border=0>'+elem[2]+'</A></TD>';
retour+='<td class=libelle'+elem[0]+'><table border=0 CELLPADDING="0" CELLSPACING="0"><tr valign="top"><td class=libelle'+elem[0]+'><img src="/commun/images/nomenclature/pixel.gif" height=1 width="'+(elem[0]-3)*50+'"></td><td class=libelle'+elem[0]+' width=100%><A class=code HREF="javascript:ouvreNiveau(\''+elem[1]+'\',\''+elem[2]+'\',\''+elem[0]+'\');" '+title+'>'+elem[3]+'</a></td></tr></table></TD></TR></TABLE>';
retour+=chaine_div;		
}
return retour;
}
function afficheCode(code,niveau){
var img;
//	if(niveau<4){
el=document.getElementById(code);
if(el){
img=document.getElementById('img'+code);
if(	el.style.display!=''){
el.style.display='';
niveau++;
if(img)	img.src=img_trbas.src;
if(el.innerHTML=='' && (img || niveau<4)){
el.innerHTML=ajax_select(niveau,code);
}
for(i = 0; i < document.getElementsByTagName("table").length; i++){
if(document.getElementsByTagName("table")[i].id.substr(2,4)==code.substr(0,4) && document.getElementsByTagName("table")[i].id!="t_"+code){
document.getElementsByTagName("table")[i].style.display='none';
}
}
}else{
for(i = 0; i < document.getElementsByTagName("table").length; i++){
if(document.getElementsByTagName("table")[i].id.substr(2,4)==code.substr(0,4) && document.getElementsByTagName("table")[i].id!="t_"+code){
document.getElementsByTagName("table")[i].style.display='';
}
}
el.style.display='none';
el.innerHTML='';
if(img) img.src=img_trdroit.src;
}
}
//	}
}
function ouvreNiveau(code,nom,niveau){
modifier_numero( ' '+nom );
ajax_description(code);
afficheCode(code,niveau);
}
function ouvreNiveauSup(code,nom,niveau){
modifier_numero( ' '+nom );
ajax_description(code);
afficheCode(code.substr(0,4)+'00000080',3);
}
// ***********************************************************************************************************
// salons
// ***********************************************************************************************************
function mettre_a_jour_code_secteur()
{
// lecture du secteur sélectionné
//	var id_secteur = "" + $('code_secteur_fiche').options[$('code_secteur_fiche').selectedIndex].value;
var id_secteur = "" + $('code_secteur_fiche').value;
var nombre_d_items_ajoutes = 0;
if( id_secteur != "" )
Element.show( "ligne_sous_secteur" );
else
Element.hide( "ligne_sous_secteur" );
// pour chaque item de la liste
var nom_liste = "code_sous_secteur_fiche";
vider_une_liste( nom_liste );
$A(liste_des_sous_secteurs).each( function( valeur, indice )
{
if( valeur["secteur"] == id_secteur )
{
ajouter_item( nom_liste, valeur["nom"], valeur["id"] );
nombre_d_items_ajoutes++;
}
} );
if( nombre_d_items_ajoutes == 0 )
ajouter_item( nom_liste, "                                   ", "" );
}
function vider_une_liste( nom_liste )
{
for( i=$(nom_liste).options.length-1 ; i>=0 ; i-- )
$(nom_liste).remove( i );
}
function ajouter_item( nom_liste, texte, valeur )
{
var mon_option = new Option( texte, valeur ); 
try
{
$( nom_liste ).add( mon_option, null ); // ne fonctionne pas sous IE
}
catch(ex)
{
$( nom_liste ).add( mon_option ); // fonctionne sous IE seulement
}
}
// ***********************************************************************************************************
// Atlas
// ***********************************************************************************************************
function lp_toggle( id ) {
var tabTmp = new Array();
var objet = document.getElementById( id );
if( objet.className == "element_visible" ) {
objet.className = "element_invisible";
document.getElementById( id + "_bloc" ).className = "menu_non_selectionne";
return;
}
tabTmp = document.body.getElementsByTagName( "*" );
for (i=0; i<tabTmp.length; i++)
if( tabTmp[i].id != id.substr( 0, tabTmp[i].id.length ) )
if( tabTmp[i].className == "element_visible" ) {
tabTmp[i].className = "element_invisible";
document.getElementById( tabTmp[i].id + "_bloc" ).className = "menu_non_selectionne";
}
objet.className = "element_visible";
document.getElementById( id + "_bloc" ).className = "menu_selectionne";
}
// ***********************************************************************************************************
// Compteur de clics sur la publicité
// ***********************************************************************************************************
function stats_publicite( langue, nom_pub )
{
var url = 'stats_publicite.php';
var parametres = 'langue='+langue+'&nom_pub='+nom_pub;
var myAjax = new Ajax.Request(
url,
{
method: 'get',
parameters: parametres
}
);
}

// ***********************************************************************************************************
// Compteur de clics sur un lien
// ***********************************************************************************************************
/*function stats_lien( langue, nom_lien, url_du_lien )
{
	var url = 'stats_lien.php';
	var parametres = 'langue='+langue+'&nom_lien='+nom_lien+'&url_du_lien='+url_du_lien;
	alert(url+'?'+parametres);
	var myAjax = new Ajax.Request(
		url,
		{
			method: 'get',
			parameters: parametres
		}
	);
}*/

// ***********************************************************************************************************
// Compteur de clics sur la publicité de parrainage
// ***********************************************************************************************************
function stats_publicite_parrainage( langue )
{
var url = 'stats_publicite_parrainage.php';
var parametres = 'langue='+langue;
var myAjax = new Ajax.Request(
url,
{
method: 'get',
parameters: parametres
}
);
}
// ***********************************************************************************************************
// Menu en Flash
// ***********************************************************************************************************
function detecter_flash()
{
var x = null;
if( navigator.mimeTypes && navigator.mimeTypes.length )
{
x = navigator.mimeTypes['application/x-shockwave-flash'];
if( x && x.enabledPlugin )
return true;
}
if( navigator.plugins && typeof navigator.plugins["Shockwave Flash"] == "object" )
return true;
if( window.ActiveXObject )
{
try { x = new ActiveXObject("ShockwaveFlash.ShockwaveFlash"); }
catch(e) {}
try {  x.GetVariable("$version");}
catch(e) { return false;}
return true;
}
return false;
}
function volume_100()
{
document[ 'mpl' ].sendEvent( 'volume',100 );
}
function volume_0()
{
document[ 'mpl' ].sendEvent( 'volume',0 );
}