/* ———————————————————————————————————————————————————————————————————— */
/* */
/* CROSS Version 1.2.6 */
/* Dernière Mise à Jour : 09-10-12 */
/* */
/* Général */
/* Ce script contient les méthodes d'exploitation général pour */
/* la conception et manipulation du site. */
/* */
/* ———————————————————————————————————————————————————————————————————— */
/* ———————————————————————————————————————————— */
/* */
/* $ DOLLAR */
/* Racourcie de getElementById pour récupérer */
/* le lien vers une balise Div. */
/* */
/* ———————————————————————————————————————————— */
function $( element ){
return document.getElementById( element );
}
/* ———————————————————————————————————————————— */
/* */
/* PRECHARGEMENT IMAGE */
/* Précharge un ensemble d'image dont les URL */
/* sont contenues dans un tableau. */
/* */
/* ———————————————————————————————————————————— */
function PrechargementImage( Images ){
// Si le Navigateur est opérationnel pour ce genre de procédés ————>
if ( navigator.appVersion.substring( 0 , 1 ) >= 3 ) {
// Pour chaque URL ————>
for( var i = 0 ; i < Images.length ; i++ ){
// Créé la variable d'image de pour cette image
document[ "imagePre" + i ] = new Image;
// Upload cette image par son URL
document[ "imagePre" + i ].src = Images[ i ];
}
}
}
/* ———————————————————————————————————————————— */
/* */
/* CONVERSION CARACTERE */
/* Convertie une chaine de caratère en */
/* remplaçant des éléments par d'autres. */
/* */
/* ———————————————————————————————————————————— */
function ConversionCaractere( Chaine , // ————> La Chaine de caractère
elementsDepart , // ————> Tableau des éléments à remplacer
elementsFin // ————> Tableau des éléments à mettre à la place des éléments à remplacer
){
if( Chaine == null || Chaine == undefined ){ return ""; }
// Tableau des caractère à convertire
var tabConvers = elementsDepart;
var tabRempla = elementsFin;
// Sépare chaque caractère de la chaine à convertire
var tabChaine = Chaine.split( "" );
// Pour chaque caractère de la chaine à convertir...
for( var i = 0 ; i < tabChaine.length ; i++ ){
// Si elle est égale à un nombre du tableau des caractère à convertir...
if( TabPositionElement( tabConvers , tabChaine[ i ] ) != -1 ){
// Place le caractère de remplacement
tabChaine[ i ] = tabRempla[ TabPositionElement( tabConvers , tabChaine[ i ] ) ];
}
}
// Renvoie la chaine convertie
return tabChaine.join( "" );
}
/* ———————————————————————————————————————————— */
/* */
/* CONVERSION CARACTERE OTHER */
/* 2 : Convertie une chaine de caratère en */
/* remplaçant des éléments encapsulés de */
/* crochets par d'autres. */
/* */
/* 3 : Procéde à la même conversion que la */
/* méthode ConversionCaractere mais en */
/* séparant également les retours charriots. */
/* */
/* ———————————————————————————————————————————— */
function ConversionCaractere2( Chaine , // ————> La Chaine de caractère
elementsDepart , // ————> Tableau des éléments à remplacer
elementsFin // ————> Tableau des éléments à mettre à la place des éléments à remplacer
){
if( Chaine == null || Chaine == undefined ){ return ""; }
// Tableau des caractère à convertire
var tabConvers = elementsDepart;
var tabRempla = elementsFin;
// Sépare chaque caractère de la chaine à convertire
var tabChaine = Chaine.split( "[" );
// Pour chaque caractère de la chaine à convertir...
for( var i = 0 ; i < tabChaine.length ; i++ ){
// Si elle est égale à un nombre du tableau des caractère à convertir...
if( TabPositionElement( tabConvers , ( tabChaine[ i ] ).split( "]" )[ 0 ] ) != -1 ){
// Place le caractère de remplacement
tabChaine[ i ] = tabRempla[ TabPositionElement( tabConvers , ( tabChaine[ i ] ).split( "]" )[ 0 ] ) ] + ( tabChaine[ i ] ).split( "]" )[ 1 ];
}
}
// Renvoie la chaine convertie
return tabChaine.join( "" );
}
function ConversionCaractere3( Chaine , // ————> La Chaine de caractère
elementsDepart , // ————> Tableau des éléments à remplacer
elementsFin // ————> Tableau des éléments à mettre à la place des éléments à remplacer
){
if( Chaine == null || Chaine == undefined ){ return ""; }
// Tableau des caractère à convertire
var tabConvers = elementsDepart;
var tabRempla = elementsFin;
//
// Tableau de la Chaine séparée par ses retours charriot
var ChaineTotal = escape( Chaine ).split( "%0A" );
//
// Chaine de Sortie
var Sortie = "";
// Pour chaque ligne avant son retour charriot ————>
for( var j = 0 ; j < ChaineTotal.length ; j++ ){
// Sépare chaque caractère de la chaine à convertir
var tabChaine = unescape( ChaineTotal[ j ] ).split( "" );
// Pour chaque caractère de la chaine à convertir...
for( var i = 0 ; i < tabChaine.length ; i++ ){
// Si elle est égale à un nombre du tableau des caractère à convertir...
if( TabPositionElement( tabConvers , tabChaine[ i ] ) != -1 ){
// Place le caractère de remplacement
tabChaine[ i ] = tabRempla[ TabPositionElement( tabConvers , tabChaine[ i ] ) ];
}
}
// Ajoute à la sortie
Sortie += escape( tabChaine.join( "" ) );
// Si ce n'est pas la dernière partie, ajoute un retour charriot
if( j < ChaineTotal.length - 1 ){ Sortie += "%0A"; }
}
// Renvoie la chaine convertie
return unescape( Sortie );
}
/* ———————————————————————————————————————————— */
/* */
/* OPTIMISE ECONVERSION CARACTERE */
/* Version simplifié et optimisé de la */
/* conversion de caractère. */
/* */
/* ———————————————————————————————————————————— */
function OptimiseConversionCaractere( Chaine , // ————> La Chaine de caractère
elementsDepart , // ————> Tableau des éléments à remplacer
elementsFin // ————> Tableau des éléments à mettre à la place des éléments à remplacer
){
// Pour chaques éléments à remplacer ————>
for( var i = 0 ; i < elementsDepart.length ; i++ ){
// Remplace ces éléments dans la phrase par ceux prévues
Chaine = Chaine.split( elementsDepart[ i ] ).join( elementsFin[ i ] );
}
// Renvoie le tout
return Chaine;
}
/* ———————————————————————————————————————————— */
/* */
/* TRIM */
/* Convertie une chaine de caratère pour */
/* retirer les espaces. */
/* */
/* ———————————————————————————————————————————— */
function Trim( Chaine ){
// Renvoie la chaine convertie sans espace
return( Chaine.replace(/\s+/g,"") );
}
/* ———————————————————————————————————————————— */
/* */
/* CONVERSION BALISAGE */
/* Convertie une chaine de caractère possédant */
/* des retours chariot manuel en les remplaçant*/
/* par des
. */
/* */
/* ———————————————————————————————————————————— */
function ConversionBalisage( Chaine ){
// Variable de sortie
var sortie = "";
// Conversion de la chaine de caractère en language URL puis dispersion suivant le code de retour charriot
var Chaines = escape( Chaine ).split( "%0A" );
// Pour chaque partie de la chaine ————>
for( var i = 0 ; i < Chaines.length ; i++ ){
// Ajoute cette partie reconvertie normalement à la sortie
sortie += unescape( Chaines[ i ] );
// Si ce n'est pas le dernier, ajoute également un "
"
if( i < Chaines.length - 1 ){ sortie += "
"; }
}
// Renvoie la sortie
return sortie;
}
/* ———————————————————————————————————————————— */
/* */
/* CONVERSION OPTIMAL */
/* Convertie de façon optimal une chaîne de */
/* caractère en vue de son envoie dans une */
/* base de donnée sans problème. */
/* */
/* Cette fonction est surtout utile pour IE */
/* qui envoie les données à la BDD en */
/* p0wnant les accents. */
/* */
/* ———————————————————————————————————————————— */
function ConversionOptimal( Chaine , // ————> Chaine à convertire
Aller // ————> Transmission ou Réception
){
// Tableaux de conversions Initiaux
TabAvant = [ "'" , '"' , "é" , "è" , "ù" , "à" , "À" , "É" ];
TabApres = [ "||1" , "||2" , "e|1" , "e|2" , "u|1" , "a|1" , "A|1" , "E|1" ];
//
// Tableaux de conversion pour la Transmission (Rajoute les parenthèses)
TabBalise = [];
for( var i = 0 ; i < TabApres.length ; i++ ){
TabBalise.push( "[" + TabApres[ i ] + "]" );
}
// Convertie pour la transmission ——>
if( Aller ){
return( escape( ConversionCaractere3( Chaine , TabAvant , TabBalise ) ) )
// Ou Convertie pour la réception ——>
} else {
return( unescape( ConversionCaractere2( Chaine , TabApres , TabAvant ) ) )
}
}
/* ———————————————————————————————————————————— */
/* */
/* DECONVERSION BALISAGE */
/* Convertie les
d'une chaine en retour */
/* charriot classique ou inversement. */
/* */
/* ———————————————————————————————————————————— */
function DeconversionBalisage( Chaine ){
// Variable de sortie
var sortie = "";
// Séparation de la Chaine suivant ses "
"
var Chaines = Chaine.split( "
" );
// Pour chaque partie de la chaine ————>
for( var i = 0 ; i < Chaines.length ; i++ ){
// Ajoute cette partie à la sortie
sortie += Chaines[ i ];
// Si ce n'est pas la dernière, ajoute le code URL du retour charriot
if( i < Chaines.length - 1 ){ sortie += "%0A"; }
}
// Renvoie la sortie reconvertie en normal
return unescape( sortie );
}
function conversionBalisage( Chaine ){
// Variable de sortie
var sortie = "";
// Séparation de la Chaine suivant ses retours charriots
var Chaines = escape( Chaine ).split( "%0A" );
// Pour chaque partie de la chaine ————>
for( var i = 0 ; i < Chaines.length ; i++ ){
// Ajoute cette partie à la sortie
sortie += Chaines[ i ];
// Si ce n'est pas la dernière, ajoute le "
"
if( i < Chaines.length - 1 ){ sortie += "
"; }
}
// Renvoie la sortie reconvertie en normal
return unescape( sortie );
}
/* ———————————————————————————————————————————— */
/* */
/* CRYPTAGE ALEATOIRE */
/* Génére une clée de cryptage aléatoire selon */
/* un nombre de clé et une échelle de valeur */
/* des clées choisit. */
/* */
/* ———————————————————————————————————————————— */
function cryptageAleatoire( nombreCle , // ————> Nombre de Clé au Cryptage
valeur // ————> Valeur maximal d'une clé
){
// Variable de cryptage initial
var cryptage = "";
// Pour chaque clé à créer...
for( var i = 0 ; i < nombreCle ; i++ ){
// Ajoute une valeur aléatoire de clée
cryptage += Math.round( Math.random() * valeur );
// Ajoute le tiret si ce n'est pas la dernière clée
if( i != ( nombreCle - 1 ) ){ cryptage += "-"; }
}
// Renvoie le cryptage ainsi fait
return cryptage;
}
/* ———————————————————————————————————————————— */
/* */
/* FUSION */
/* Fusionne plusieurs variables pour en obtenir*/
/* une nouvelle, mélange des autres. */
/* Si les variables sont des Nombres, elle les */
/* fait s'additionner. */
/* Si les variables sont des string, elle les */
/* fait se concaténer. */
/* Si les variables sont des tableaux, elle */
/* créait un nouveau tableau contenant chaque */
/* élément de chaque tableau dans l'ordre. */
/* */
/* ———————————————————————————————————————————— */
function Fusion(){
// Variable de résultat
var resultat;
// Mise du i (Oui... arguments n'est pas un tableau!...)
var i = 0;
// Tans qu'on trouve des arguments ———>
while( arguments[ i ] != null ){
// Si le premier des arguments est un Object (Array est un Objet) ————>
if( typeof arguments[ 0 ] == "object" ){
// Si on est sur le premier le résultat devient égal au premier tableau mis en chaine de caractère séparé par l'élément de séparation
if( i == 0 ){
resultat = arguments[ i ].join( "!!!getPowerOfFusion!!!" );
// Si on est sur un autre suivant le premier, le résultat rajoute a sa valeur ce tableau mis en chaine de caractère séparé par l'élément de séparation
} else {
resultat += arguments[ i ].join( "!!!getPowerOfFusion!!!" );
}
// Si le suivant éxiste, on ajoute un élément de séparation
if( arguments[ i + 1 ] != null ){
resultat += "!!!getPowerOfFusion!!!";
// Si le suivant n'éxiste pas, on transforme le résultat en tableau suivant ses éléments de séparation
} else { resultat = resultat.split( "!!!getPowerOfFusion!!!" ); }
// Si le premier des arguments est un String ou un Nombre ————>
} else {
// Si c'est le premier, le résultat est égal à cet argument
if( i == 0 ){ resultat = arguments[ i ]
// Si ce n'est pas le premier, le résultat s'additionne ou se concaténe avec cet élément
} else { resultat += arguments[ i ] }
}
// Augmentation i
i++;
}
// Renvoie le résultat obtenu
return resultat;
}
/* ———————————————————————————————————————————— */
/* */
/* GET STYLE */
/* Retourne la valeur d'un style d'une balise */
/* ayant un ID. */
/* /!\ ATENTION /!\ */
/* Le retournement de valeur de style ne */
/* fonctionne que pour des style placés */
/* dynamiquement, autrement dit, il ne */
/* retournera pas les styles donné via CSS. */
/* */
/* Cette Méthode a étée optimisée pour IE. */
/* */
/* ———————————————————————————————————————————— */
function getStyle( Element , // ————> ID de l'élément
Style // ————> Nom du style à retourner
){
// Récupération de l'instance de l'élément
if( typeof( Element ) == "string" ){
var element = $( Element );
} else {
var element = Element;
}
// Si on est sous un bon Navigateur ————>
if ( window.getComputedStyle )
// On récupére la valeur du style par le procédé normal
var sortie = window.getComputedStyle( element , null ).getPropertyValue( Style );
// Si on est ( Malheureusement ) sous IE ————>
else if ( element.currentStyle )
// On récupére la valeur du style par le procédé d'IE
var sortie = eval( 'element.currentStyle.' + Style );
// Renvoie de la valeur
return sortie;
}
/* ———————————————————————————————————————————— */
/* */
/* ARRAY MAX */
/* Sonde les éléments d'un tableau et en */
/* retourne la valeur numérique la plus élevée.*/
/* */
/* ———————————————————————————————————————————— */
function ArrayMax( Tableau ){
// Initialisation du lancement
var lancement = "Math.max( ";
// Pour chaque élément du tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il est bel et bien un nombre ————>
if( !isNaN( Number( Tableau[ i ] ) ) ){
// On ajoute l'élément à la chaine de lancement
lancement += Tableau[ i ];
// Levier bloqué
var test = false;
// Pour chaque élément du tableau après celui-ci ————>
for( var j = i + 1 ; j < Tableau.length ; j++ ){
// Si cet élément est un nombre, on débloque le levier
if( !isNaN( Number( Tableau[ j ] ) ) ){ test = true; }
}
// Si le levier a été débloqué, on ajoute une virgule de séparation dans la fonction de lancement
if( test ){ lancement += " , "; }
// Si le levier est resté bloqué, on mes fin à la chaine de la fonction de lancement
else { lancement += " );"; }
}
}
// Si la taille de la chaine de la fonction démontre qu'on a ajouté aucun élément du tableau, on renvoie directement Faux
if( lancement.length < 14 ){ lancement = "false"; }
// Sinon, on renvoie la fonction lancée à savoir l'élément le plus élevé parmis les éléments numérique du tableau
return eval( lancement );
}
/* ———————————————————————————————————————————— */
/* */
/* GET TAILLE ECRAN */
/* Fonctions doubles permettant de récupérer */
/* les dimentions de la fenêtre. */
/* */
/* ( Optimisé pour IE ) */
/* */
/* ———————————————————————————————————————————— */
////// LARGEUR
function getLargeurEcran(){
// Pour un BON navigateur ————>
if( window.innerWidth ){
// Retourne la largeur de l'écran
return window.innerWidth;
// Pour IE... ————>
} else if( document.documentElement.clientWidth ) {
// Retourne la largeur de l'écran
return document.documentElement.clientWidth;
}
}
////// HAUTEUR
function getHauteurEcran(){
// Pour un BON navigateur ————>
if( window.innerHeight ){
// Retourne la largeur de l'écran
return window.innerHeight;
// Pour IE... ————>
} else if( document.documentElement.clientHeight ) {
// Retourne la largeur de l'écran
return document.documentElement.clientHeight;
}
}
/* ———————————————————————————————————————————— */
/* */
/* STRING REMOVE */
/* Retire directement un caractère d'une chaine*/
/* */
/* ———————————————————————————————————————————— */
function StringRemove( Chaine , // ————> Chaine
Retire // ————> Élément à retirer
){
// Séparation de la chaine par le biais de l'élément à retirer
var TabChaine = Chaine.split( Retire );
// Renvoie la chaine rejointe (Et donc sans l'élément)
return TabChaine.join( "" );
}
/* ———————————————————————————————————————————— */
/* */
/* TAB POSITION ELEMENT */
/* Vérifie la position d'un élément dans un */
/* tableau. */
/* Cette fonction est utilisé dans le cas où */
/* indexOf ne fonctionne pas. */
/* */
/* ———————————————————————————————————————————— */
function TabPositionElement( Tableau , // ————> Tableau
Element // ————> Élément à trouver
){
for( var i = 0 ; i < Tableau.length ; i++ ){
if( Tableau[ i ] == Element ){ return i; }
}
return( -1 );
}
/* ———————————————————————————————————————————— */
/* */
/* TEXTE INTERROMPUE */
/* Interrompt une chaine de caractère au bout */
/* d'un certains nombre de caractère et y */
/* laisse une chaine indiquant l'interruption. */
/* */
/* ———————————————————————————————————————————— */
function TexteInterrompue( Chaine , // ————> Chaine
Nombre , // ————> Nombre de caractère avant interruption
Fin , // ————> Chaine indiquant l'interruption
Type // ————> Type d'arrêt ( "Tout", "Mot" ou "Phrase" )
){
// Arguments par défaut
Type = Type || "Tout"
// Définition du séparateur selon le Type
if( Type == "Tout" ){ Type = ""; }
else if( Type == "Mot" ){ Type = " "; }
else if( Type == "Phrase" ){ Type = "."; }
// Séparation de la chaine
var TabChaine = Chaine.split( Type );
// Chaine reconstituée
Chaine = "";
// Pour chaque Caractère/Mot/Phrase ————>
for( var i = 0 ; i < Nombre ; i++ ){
// Concaténe les caractères tans qu'il y en a suivis du Séparateur.
if( TabChaine[ i ] != null && TabChaine[ i ] != undefined ){
Chaine += TabChaine[ i ] + Type;
}
}
// Place l'indice de Fin s'il restait encore des éléments
if( TabChaine[ i + 1 ] != null && TabChaine[ i + 1 ] != undefined ){
Chaine += Fin;
}
// Renvoie la Chaine
return Chaine;
}
/* ———————————————————————————————————————————— */
/* */
/* TIRAGE ALEATOIRE */
/* Tire aléatoirement un chiffre entre deux */
/* numéros définit. */
/* Permet de créer un racourcie pour la */
/* formule cumulant random et round, etc. */
/* */
/* ———————————————————————————————————————————— */
function TirageAleatoire( Debut , // ————> Numero Minimal
Fin , // ————> Numero Maximal
Arrondie // ————> S'il est arrondie ou non
){
// Arguments par défaut
Arrondie = Arrondie || false;
// Numéro recevant le tirage
var Numero = 0;
// Tirage aléatoire du numéro
Numero = Math.random() * ( Fin - Debut ) + Debut;
// Arrondie le numéro s'il le faut
if( Arrondie ){ Numero = Math.round( Numero ); }
// Retourne le Numéro
return Numero;
}
/* ———————————————————————————————————————————— */
/* */
/* EXTRACTION ALEATOIRE */
/* Retourne un élément aléatoire d'un tableau. */
/* */
/* ———————————————————————————————————————————— */
function ExtractionAleatoire( Tableau ){
// Numéro de tirage aléatoire entre 0 et le nombre d'élément dans le tableau
var NumeroTirage = TirageAleatoire( 0 , ( Tableau.length - 1 ) , true );
// Retourne l'élément de ce Numéro
return Tableau[ NumeroTirage ];
}
/* ———————————————————————————————————————————— */
/* */
/* UNICITE ARRAY */
/* Retourne un tableau dénué de doublon. */
/* */
/* ———————————————————————————————————————————— */
function UniciteArray( Tableau ){
// Variable de Sortie
var Sortie = [];
// Pour chaque élément du Tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// Levier activé
var levier = true;
// Pour chaque élément déjà récupéré ——>
for( var j = 0 ; j < Sortie.length ; j++ ){
// S'il s'y trouve déjà, désactive le levier
if( Sortie[ j ] == Tableau[ i ] ){ levier = false; }
}
// Si le levier est resté activé, ajoute l'élément au tableau de Sortie
if( levier ){ Sortie.push( Tableau[ i ] ); }
}
// Retourne le tableau de sortie
return Sortie;
}
/* ———————————————————————————————————————————— */
/* */
/* GET GET */
/* Récupére un GET de l'addresse URL. */
/* */
/* ———————————————————————————————————————————— */
function getGet(){
// Variables initiales
var Sortie = Object();
// Extraction du lien
var param = window.location.search.slice( 1 , window.location.search.length );
// Sépration des paramètres
var first = param.split( "&" );
// Pour chaque paramètre ————>
for( var i = 0 ; i < first.length ; i++ ){
// Donne la séparation de la chaine du paramètre
second = first[ i ].split( "=" );
// Récupère les valeurs
Sortie[ second[ 0 ] ] = second[ 1 ];
}
// Sortie
return Sortie;
}
/* ———————————————————————————————————————————— */
/* */
/* PUSH UNICITE */
/* Ajoute un élément à un tableau à condition */
/* qu'il ne s'y trouve pas déjà. */
/* */
/* ———————————————————————————————————————————— */
function pushUnicite( Tableau , // ————> Tableau concerné
Element // ————> Élément à ajouter
){
// Pour chaque élément du tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il est strictement égal à l'élément à y mettre, renvoie le tableau tel quel
if( Tableau[ i ] === Element ){ return Tableau; }
}
// Sinon, ajoute l'élément au Tableau
Tableau.push( Element )
// Puis Renvoie le Tableau
return Tableau;
}
/* ———————————————————————————————————————————— */
/* */
/* ALL EMPTY DOWN */
/* Retire toutes les parties d'un tableau */
/* étant null ou étant un String vide. */
/* */
/* ———————————————————————————————————————————— */
function AllEmptyDown( Tableau ){
// Pour chaque élément du tableau ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il est null ou un string vide, il le vire
if( Tableau[ i ] == null || Tableau[ i ] == "" ){ Tableau.splice( i , 1 ); }
}
// Le renvoie
return Tableau;
}
/* ———————————————————————————————————————————— */
/* */
/* KEY WORD */
/* À partir d'un tableau de mots-clés, donne */
/* une notification au choix aux mots dans */
/* cette phrase. */
/* */
/* ———————————————————————————————————————————— */
function KeyWord( Phrase , // ————> La Phrase
Mots , // ————> Les mots concernés
Notification // ————> Les Notifications à mettre
){
// Pour chaque Mots concernés ————>
for( var i = 0 ; i < Mots.length ; i++ ){
// Récupére ces mots dans la phrase, les retire puis les replace entourée des notifications voulues
Phrase = Phrase.split( Mots[ i ] ).join( Notification[ 0 ] + Mots[ i ] + ( Notification[ 1 ] || "" ) );
}
// Renvoie la Phrase
return Phrase;
}
/* ———————————————————————————————————————————— */
/* */
/* STRING EQUAL */
/* Teste une correspondance potentielle entre */
/* deux mots ou entre un mot et un tableau de */
/* mots. */
/* */
/* ———————————————————————————————————————————— */
function StringEqual( Tableau , // ————> Tableau des Mots concernés
Mot // ————> Mot recherché
){
// Si Tableau est un mot unique, il est placé au sein d'un tableau
Tableau = ( typeof Tableau == "object" ) ? Tableau : [ Tableau ];
// Si le Mot n'est pas vide ————>
if( Mot != "" ){
// Pour chaque Mot ————>
for( var i = 0 ; i < Tableau.length ; i++ ){
// S'il se retrouve un minimum dans ce Mot ————> Renvoie Vrai
if( Mot.toLowerCase().split( Tableau[ i ].toLowerCase() ).length > 1 ){ return true; }
}
}
// Sinon, renvoie faux
return false ;
}
/* ———————————————————————————————————————————— */
/* */
/* REMOVE BALISE */
/* Retire toutes les balises d'un string. */
/* */
/* ———————————————————————————————————————————— */
function RemoveBalise( Chaine ){
// Conversion de la Chaine
// ( RAPPEL de Version Navigateur : Untel[x] ne fonctionne pas sur les String sous IE )
var Chaine = Chaine.split( "" );
// Création de la Sortie
var Sortie = "";
//
// Levier
var Levier = true;
// Pour chaque élément de la Chaine ————>
for( var i = 0 ; i < Chaine.length ; i++ ){
// S'il s'agit d'une ouverture de balise, désactive le levier
if( Chaine[ i ] == "<" ){ Levier = false; }
// Si le levier est activé, rajoute la chaine à la sortie
if( Levier ){ Sortie += Chaine[ i ]; }
// S'il s'agit d'une fermeture de balise, active le levier
if( Chaine[ i ] == ">" ){ Levier = true; }
}
// Renvoie la Sortie
return Sortie;
}
/* ———————————————————————————————————————————— */
/* */
/* GIMME NAVIGATOR */
/* Donne avec certitude le navigateur. */
/* */
/* ———————————————————————————————————————————— */
function GimmeNavigator(){
// Les bons navigateurs ————>
//
if( window.innerWidth ){
// Décalage de test du Scroll
document.body.scrollTop += 10
//******\\ FIREFOX //******\\
//
if( document.body.scrollTop ){
// Recalibrage du Scroll
document.body.scrollTop -= 10;
//
//
return( "Safari" );
//******\\ SAFARI //******\\
//
} else { return( "Firefox" ); }
// Les... autres navigateurs ————>
//
} else {
return( "IE" );
}
}
/* ———————————————————————————————————————————— */
/* */
/* TRACE */
/* Autre façon de lancer une alert. */
/* Pour les programmeurs qui jonglent. */
/* */
/* ———————————————————————————————————————————— */
function trace( Texte ){ alert( Texte ); }
/* ———————————————————————————————————————————— */
/* */
/* MAJ LIGNE */
/* Convertie un mot pour que sa première */
/* lettre soit une majuscule. */
/* */
/* ———————————————————————————————————————————— */
function MajLigne( Mot ){
var MotMinus = Mot.toLowerCase().split( "" );
var MotMajus = Mot.toUpperCase().split( "" );
MotMinus.shift();
var Sortie = MotMajus[ 0 ] + MotMinus.join( "" );
return Sortie;
}
/* ———————————————————————————————————————————— */
/* */
/* RECUPERATION SELECTION */
/* Récupére le contenu d'un texte surligné */
/* à la souris par l'utilisateur. */
/* */
/* ———————————————————————————————————————————— */
function RecuperationSelection(){
// Pour FireFox
if( document.selection ){ return( document.selection.createRange().text ); }
// Pour IE...
else{ return( document.getSelection() ); };
}
/* ———————————————————————————————————————————— */
/* */
/* FIND IN */
/* Renvoie le nombre de fois où l'on retrouve */
/* une chaine dans un string. */
/* */
/* ———————————————————————————————————————————— */
function FindIn( Texte ,
Chaine
){
// Sépare le texte
return( Texte.split( Chaine ).length - 1 );
}
/* ———————————————————————————————————————————— */
/* */
/* POP BETWEEN */
/* Retire une chaine de caractère entre deux */
/* séparateur différent dans une chaine. */
/* */
/* ———————————————————————————————————————————— */
function PopBetween( Texte ,
ChaineDebut ,
ChaineFin
){
// Sépare le texte
var leTexte = Texte.split( ChaineDebut );
// Levier
var Levier = true;
// Pour chaque partie du texte
for( var i = 1 ; i < leTexte.length ; i++ ){
// S'il contient la seconde chaine
if( FindIn( leTexte[ i ] , ChaineFin ) && Levier ){
// Convertie cette partie
var laPartie = leTexte[ i ].split( ChaineFin );
laPartie[ 0 ] = null;
AllEmptyDown( laPartie );
leTexte[ i ] = "[*REMOVE*]" + laPartie.join( ChaineFin );
// Bloque le levier
Levier = false;
}
// Si le levier est débloqué et que c'est la fin
if( i == leTexte.length - 1 && Levier ){
// Retire cette partie
leTexte[ i ] = "[*REMOVE*]";
}
}
// Renvoie le tout
return leTexte.join( ChaineDebut ).split( ChaineDebut + "[*REMOVE*]" ).join( "" );
}
/* ———————————————————————————————————————————— */
/* */
/* GET LESS */
/* Retire des gets d'une chaine issue d'un URL */
/* */
/* ———————————————————————————————————————————— */
function GetLess( URL , // ———> L'Url conscerné
ARetirer // ———> tableau des éléments à retirer
){
// Convertie l'URL en string
URL = String( URL );
// Convertie l'élément à retirer s'il est un string
if( typeof ARetirer == "string" ){ ARetirer = [ ARetirer ]; }
// Pour chaque éléments à retirer
for( var i = 0 ; i < ARetirer.length ; i++ ){
// Le retire de l'Url
URL = PopBetween( URL , ARetirer[ i ] , "&" );
}
// S'il reste un "&" à la fin, le retire
if( URL[ URL.length - 1 ] == "&" ){ URL = URL.substr( 0 , URL.length - 1 ); }
// Renvoie l'URL
return URL;
}
/* ———————————————————————————————————————————— */
/* */
/* GET ADD */
/* Ajoute un Get à une chaine URL */
/* */
/* ———————————————————————————————————————————— */
function GetAdd( URL , // ———> L'Url conscerné
AAjouter ,// ———> Tableau des éléments à ajouter
Valeurs // ———> Tableau des valeurs des éléments à ajouter
){
// Convertie l'URL en string
URL = String( URL );
// Convertie l'élément à ajouter s'il est un string
if( typeof AAjouter == "string" ){ AAjouter = [ AAjouter ]; }
if( typeof Valeurs == "string" ){ Valeurs = [ Valeurs ]; }
// S'il n'y a pas de point d'interrogation dans l'URL, en ajoute un
var InterrogationInitial = false;
//
if( !FindIn( URL , "?" ) ){
//
URL += "?";
InterrogationInitial = true;
}
// Pour chaque éléments à ajouter
for( var i = 0 ; i < AAjouter.length ; i++ ){
// Si ce n'est pas le tout premier
if( !InterrogationInitial || i != 0 ){ URL += "&"; }
// L'ajoute à l'Url
URL += AAjouter[ i ] + "=" + Valeurs[ i ];
}
// Renvoie l'URL
return URL;
}
/* ———————————————————————————————————————————— */
/* */
/* HTML 2 STRING */
/* Convertie une chaine Html contenant les */
/* caractère spéciaux html en une chaine */
/* standard. */
/* */
/* ———————————————————————————————————————————— */
function Html2String( Chaine ){
// Renvoie la chaine convertie
return( OptimiseConversionCaractere( Chaine ,
[ "‚" , "ƒ" , "„" , "…" , "†" , "‡" , "ˆ" , "‰" , "Š" , "‹" , "Œ" , "‘" , "’" ,
"“" , "”" , "•" , "–" , "—" , "˜" , "™" , "š" , "›" , "œ" , "Ÿ" , " " , "¡" ,
"¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" , "" , "®" ,
"¯" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" , "º" , "»" ,
"¼" , "½" , "¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" , "Å" , "Æ" , "Ç" , "È" ,
"É" , "Ê" , "Ë" , "Ì" , "Í" , "Î" , "Ï" , "Ð" , "Ñ" , "Ò" , "Ó" , "Ô" , "Õ" ,
"Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" , "Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" ,
"ã" , "ä" , "å" , "æ" , "ç" , "è" , "é" , "ê" , "ë" , "ì" , "í" , "î" , "ï" ,
"ð" , "ñ" , "ò" , "ó" , "ô" , "õ" , "ö" , "÷" , "ø" , "ù" , "ú" , "û" , "ü" ,
"ý" , "þ" , "ÿ" ,
" " , "¡" , "¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" ,
"" , "®" , "&masr;" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" ,
"º" , "»" , "¼" , "½" , "¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" ,
"Å" , "&Aelig" , "Ç" , "È" , "É" , "&Ecric;" , "Ë" , "Ì" , "Í" , "Î" , "Ï" , "Ð" ,
"Ñ" , "Ò" , "Ó" , "Ô" , "Õ" , "Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" ,
"Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" , "ã" , "ä" , "å" , "æ" , "ç" ,
"è" , "é" , "ê" , "ë" , "ì" , "í" , "î" , "ï" , "ð" , "ñ" , "ò" , "ó" ,
"ô" , "õ" , "ö" , "÷" , "ø" , "ù" , "ú" , "û" , "ü" , "ý" , "þ" , "ÿ"
] ,
[ "‚" , "ƒ" , "„" , "…" , "†" , "‡" , "ˆ" , "‰" , "Š" , "‹" , "Œ" , "‘" , "’" ,
"“" , "”" , "•" , "–" , "—" , "˜" , "™" , "š" , "›" , "œ" , "Ÿ" , " " , "¡" ,
"¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" , " " , "®" ,
"¯" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" , "º" , "»" ,
"¼" , "½" , "¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" , "Å" , "Å" , "Ç" , "È" ,
"É" , "Ê" , "Ë" , "Ì" , "Í" , "Î" , "Ï" , "Ð" , "Ñ" , "Ò" , "Ó" , "Ô" , "Õ" ,
"Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" , "Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" ,
"ã" , "ä" , "å" , "æ" , "ç" , "è" , "é" , "ê" , "ë" , "ì" , "í" , "î" , "ï" ,
"ð" , "ñ" , "ò" , "ó" , "ô" , "õ" , "ö" , "÷" , "ø" , "ù" , "ú" , "û" , "ü" ,
"ý" , "þ" , "ÿ" ,
" " , "¡" , "¢" , "£" , "¤" , "¥" , "¦" , "§" , "¨" , "©" , "ª" , "«" , "¬" , " " , "®" ,
"¯" , "°" , "±" , "²" , "³" , "´" , "µ" , "¶" , "·" , "¸" , "¹" , "º" , "»" , "¼" , "½" ,
"¾" , "¿" , "À" , "Á" , "Â" , "Ã" , "Ä" , "Å" , "Å" , "Ç" , "È" , "É" , "Ê" , "Ë" , "Ì" ,
"Í" , "Î" , "Ï" , "Ð" , "Ñ" , "Ò" , "Ó" , "Ô" , "Õ" , "Ö" , "×" , "Ø" , "Ù" , "Ú" , "Û" ,
"Ü" , "Ý" , "Þ" , "ß" , "à" , "á" , "â" , "ã" , "ä" , "å" , "æ" , "ç" , "è" , "é" , "ê" ,
"ë" , "ì" , "í" , "î" , "ï" , "ð" , "ñ" , "ò" , "ó" , "ô" , "õ" , "ö" , "÷" , "ø" , "ù" ,
"ú" , "û" , "ü" , "ý" , "þ" , "ÿ"
]
) );
}
/* ———————————————————————————————————————————— */
/* */
/* ENCRYPTE */
/* Crypte ou décrypte une chaine en y plaçant */
/* caractère entre chaque autre caratère. */
/* */
/* ———————————————————————————————————————————— */
function Encrypte( Chaine , // ———> La chaine concernée
Cryptage , // ———> Cryptage ou Décryptage
Caractere // ———> Caractère de cryptage
){
// S'il y a une chaine ————>
if( Chaine ){
// Arguments par défaut
Caractere = Caractere || "#";
Cryptage = ( Cryptage == null || Cryptage == true ) ? true : false;
// Cryptage ————>
if( Cryptage ){
// Retourne la chaine cryptée
return Chaine.split( "" ).join( Caractere );
// Décryptage ————>
} else {
// Retourne la chaine décryptée
var Sortie = "";
Chaine = Chaine.split( "" );
//
for( var i = 0 ; i < Chaine.length ; i++ ){
//
// Un caractère sur deux ————>
if( EstPair( i ) ){
// Ajoute à la sortie
Sortie += Chaine[ i ];
}
}
// Retourne la sortie
return Sortie;
}
}
}
/* ———————————————————————————————————————————— */
/* */
/* EST PAIR */
/* Vérifie si une valeur est pair ou impair. */
/* */
/* ———————————————————————————————————————————— */
function EstPair( Valeur ){
// Récupère la valeur divisé par deux arrondie et non arrondie
var Valeur1 = Valeur / 2;
var Valeur2 = Math.round( Valeur / 2 );
// Si elles sont les même ————> Sort pair
if( Valeur1 == Valeur2 ){ return true; }
//
// Sinon ————> Sort impair
return false;
}