//Testé par Paul M. Baillot.  Guarantie 'Pas-D'-BUG'
package pbxlogique;
//packet #1 : import pbxlogique.Pbx.*;
//Desc: Méthode misc. qui à pour but de simplifier certaine tâches qui sont
//très plate à faire d'habitude :)
/* -=-=-=- LISTE DE FONCTIONS =-=-=-=-=-
  *public static long unNum(String checkLe)
  public static double retourneNum_R(String valeurCode, long valeurDuToken, long decimaux)
  *public static long retourneNum_I(String valeurCode, long valeurDuToken)
  public static double antiDecimal(double aArrondir, long nDecimal)
  public static long trunc(double aArrondir)
  public static boolean pair(long nverifie)
  public static String encInverse ( String motEncode )
  public static String encAlterne ( String motEncode )
  public static String encodeSimple ( String motEncode, int n)
  public static String encrypt ( String motEncode, int ascii, boolean inverseC, boolean alterneC )
  public static String uCase ( String inputStr )
  public static String lCase ( String inputStr )
  public static String tabSimulate ( String inputstr, long stargetSize )
  *public static int fichierOuvre ( String nomDuFichier )
  public static boolean fichierEfface ( String nomDuFicher )
  *public static boolean fichierNouveau ( String nomDuFicher )
  public static String fichierLireDat()
  *public static int fichierLire ( int fichierData, int lireCombien )
  *public static String fichierTexteLire(int fichierData)
  *public static boolean fichierEcrit ( int fichierData, char[] bufferLire, int ecrireCombien )
  *public static boolean fichierGrandeur ( int fichierData, long commentGrand )
  public static boolean fichierSeek ( int fichierData, long positionF )
  public static boolean fichierFerme ( int fichierData )

  public static String probPBX()

  Voir les méthode elle-meme pour des descriptions.
  Les fonctions avec un astérix peuvent générer des erreurs sauvé dans probPBX()
*/

import java.util.*;
import java.io.File;
import java.io.RandomAccessFile;
import javax.swing.JFileChooser;
/**
 * Titre: La Logique PBX
 * Description:  Une bunch de méthodes pour simplifier la construction de
 * programmes et de les rendres plus robustes et rendre minime les
 * possibilitées d'erreurs.
 * copie droite:    copie droite (c) 2001
 * Company: Showbâhm Ind.
 * @Auteur: Paul M. Baillot
 * @version 0.0.0.0.0.0
 */

public class Pbx {
  //CONSTANTES:
  static protected int maxFichierOuvert = 8; //Maximum de fichier ouvert par PBXLogique
  //------------------------------------------------------------------
  //COMMENCEMENT
  //------------------------------------------------------------------
  static String erreurPBX = new String ("");
  //
  protected static File[] nomFichier = new File[maxFichierOuvert]; //Listes des noms des fichiers.
  protected static boolean[] fichierActive = new boolean[maxFichierOuvert]; //Indique si les fichiers sont déjà ouvert où non.
  protected static long[] fichierSeek = new long[maxFichierOuvert]; //Indique ou commencer à lire/écrire.
  protected static boolean initFichier = false; //Est TRUE après un appel à OuvreFichier
  protected static int aEteLue=-1; //Utilisé par blockRead et blockWrite et aLue
  public static char[] bufferData=new char[32768];
  public static final String CARRIAGE_RETURN=new String(String.valueOf ((byte) 13+(byte) 10));
  //Utiliser pour la fonction FichierLireLigne, peut être utilisé par
  //fichierÉcrit s'y l'on veut rendre le texte éditable dans notepad..
  public static final String CARRIAGE=new String(String.valueOf ((byte) 13));
  //Utiliser pour la fonction FichierLireLigne, peut être utilisé par
  //fichierÉcrit s'y l'on veut rendre le texte éditable dans notepad..

  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static long unNum(String checkLe)
  /*Vérifie si "checkLe" contient un ou des nombres qui peuvent être
   ++checkLe: Contient un ou plusieurs nombres séparé par des tokens (i.e. espace)
      Vous pouvez metre des espace avant et après le chiffre aussi
   ++unNum: Retourne 0 si aucun nombres n'est trouvé ou si un charactère quelquonque
      est trouvé dedans les tokens.
      Retourne 1 pour démontrer que checkLe est un nombre ou >1 représantant le nombre
      de valeurs que la chaine contient qui sont séparé par des tokens.
  */
  {
  long nombreDeToken=0, //Compte le nombre de tokens en générale
       compteurM=0, //Compteur misc.
       nombreTotValide=0; //Nombre totale de nombres valide dans la chaine!
  int compteurO=0;
  StringTokenizer verifieNombre= new StringTokenizer(checkLe);
  String verifieValide=""; //Contient un token à la fois.
  char chiffreValide=' ';  //Fais sure que les tokens sont composé de chiffres.
  boolean identValide=false; //Utiliser pour vérifier chaque charactère de la chaine
  //
  nombreDeToken=verifieNombre.countTokens();
  for (compteurM=1; compteurM<=nombreDeToken; compteurM++)
  {
    if (!verifieNombre.hasMoreTokens()) //*****DEBUG
    {
      erreurPBX="DEBUG_PBX: Erreur à unNum, 'FOR' a surpassé le nombre de tokens.";
      return 0;
    }
    verifieValide=verifieNombre.nextToken();
    for (compteurO=0; compteurO<=verifieValide.length()-1; compteurO++)
    {
      identValide=false;
      switch (verifieValide.charAt(compteurO))
      {
        case '0': {identValide=true;}
        case '1': {identValide=true;}
        case '2': {identValide=true;}
        case '3': {identValide=true;}
        case '4': {identValide=true;}
        case '5': {identValide=true;}
        case '6': {identValide=true;}
        case '7': {identValide=true;}
        case '8': {identValide=true;}
        case '9': {identValide=true;}
        case '.': {if (verifieValide.length()>compteurO+1) identValide=true;}
        //Bug arrangé, qui causait un problème quand juste ces caractère était
        //entrée tout seul.
        case 'E': {if (verifieValide.length()>compteurO+1) identValide=true;}
        case '-': {if (verifieValide.length()>compteurO+1) identValide=true;}
      }
      if (!identValide)
      {
        return 0;
      }
    } //END FOR compteurO
    nombreTotValide++;
    }//END FOR compteurM
  return nombreTotValide;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static double retourneNum_R(String valeurCode, long valeurDuToken, long decimaux)
  /*
  ++valeurCode: La chaine contenant un ou plusieurs chiffres satisfaisant "Pbx.unNum()"
  ++valeurDuToken: Retourner le n'ième token...
  ++decimaux: combiens de décimaux ? (si 0<, ne filtre rien)
  ++retourneNum_R: Retourne le nombre spécifié s'il existe.  Retourne 0 automatiquement si
    Pbx.unNum n'est pas satisfait ou si valeurDuToken<0;

  Desc générale: Retourne le "valeurDuToken"'ième valeur contenu dans "valeurCode", et fais sure qu'il n'y
  à que "decimaux" décimaux. :)
  */
  {
  StringTokenizer prendNombre = new StringTokenizer(valeurCode);
  int compteurM; //Compteurs généraux;
  String strBonNombre; //Prend la chaine du bon token
  double bonNombre; //Prend la valeur du nombre avec tout les décimales.
  char verifieDec; //Analyse les décimales...
  char verifieDetail; //analyse le nombre de décimaux possibles..
  String nombreFabriquer="";
  long decAjouter=-1; //le point compte comme un décimal.. (compte les décimaux.
  boolean commenceDec=false, exposantOK=false;
  if (valeurDuToken<=0) return 0; //Fais sure qu'aucun mal arrive.
  if (unNum(valeurCode)>=valeurDuToken)
  {
    for (compteurM=1; compteurM<valeurDuToken; compteurM++)
    {
      prendNombre.nextToken();
    }//END FOR
    strBonNombre=prendNombre.nextToken();
    bonNombre=Double.parseDouble(strBonNombre);
    if (decimaux<0)
    {
      return bonNombre;
    } else
    {
      for (compteurM=0; compteurM<=strBonNombre.length()-1; compteurM++)
      {
      verifieDec=strBonNombre.charAt(compteurM);
      if (verifieDec=='.')
      {
        commenceDec=true;
      } //END IF
      if (decAjouter<decimaux) nombreFabriquer=nombreFabriquer+verifieDec;
      if (commenceDec) decAjouter++;
        if (verifieDec=='E')
        {
          exposantOK=true;
          nombreFabriquer=nombreFabriquer+"E";
        } else
        {
          if (exposantOK)
          {
            nombreFabriquer=nombreFabriquer+verifieDec;
          } //END IF
        } //END IF
      } //END FOR
      }
      bonNombre=Double.parseDouble(nombreFabriquer);
      return bonNombre;
    }//END IF
  return 0; //Devrait jamais arriver !
  }//END Method
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static long retourneNum_I(String valeurCode, long valeurDuToken)
  /* ++valeurCode: chaines contenants un ou des nombres séparés avec des espaces.
     ++valeurDuToken: Pointe au n'ième nombre dans la chaine de charactère.
     ++retourneNum_I: Retourne la valeur integer "LONG" du nombre en question meme si
      le nombre comporte des décimals.  Retourne 0 si le maximum montant de token est excédé
      ou si un numéros n'ets pas détecté ou si valeurDuToken<0;
  */
  {
  StringTokenizer prendNombre=new StringTokenizer(valeurCode);
  String converti,  //Prend la valeur de chaine de "recoitReel" pour le filtrage de décimal.
         nouvelle="";  //Nouvelle chaine de charactère batit sans décimaux.
  char verifieDec;  //Cherche pour le signe de charactère.
  int compteurM; ///Compteur multi-misc.
  long finale=0; //Nombre finale.
  if (valeurDuToken<=0)
  {
    return 0; //Fais sure qu'aucun mal arrive.
  } else
  {
    if (unNum(valeurCode)<valeurDuToken)
    {
      erreurPBX="DEBUG_PBX: Exception dans retourneNum_I, valeurCode est trop haute.";
      return 0;
    }
    //Donne la valeur "converti"
    for (compteurM=1; compteurM<valeurDuToken; compteurM++)
    {
      prendNombre.nextToken();
    }//END FOR
    converti=prendNombre.nextToken(); //Faite!
    //Commencer le filtrage :)
    for (compteurM=0; compteurM<=converti.length()-1; compteurM++)
    {
      verifieDec=converti.charAt(compteurM);
      if (verifieDec!='.' & verifieDec!='E')
      {
        nouvelle=nouvelle+verifieDec;
      } else
      {
        break; //BREAK FOR
      }//END IF
    }//END FOR
  finale=Long.parseLong(nouvelle);
  return finale;
  }//END IF
  }//END MÉTHODE
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static double antiDecimal(double aArrondir, long nDecimal)
  /*
  ++ aArrondir : Le "double" à arrondir à "aArrondir" décimals près!
  ++ nDecimal : Arrondir à combien de décimals?
  ++ antiDecimal : Retourne le "double" arrondi!
  */
  {
    String converti; //string qui prend la valeur de aArondir.
    converti=Double.toString(aArrondir);
    return retourneNum_R(converti, 1, nDecimal);
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static long trunc(double aArrondir)
  /*
  ++ aArrondir : Le "double" à arrondir à "aArrondir" à l'unité près!
  ++ trunc : Retourne le "long" truncater!
  */
  {
    String converti; //string qui prend la valeur de aArondir.
    converti=Double.toString(aArrondir);
    return retourneNum_I(converti, 1);
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String encInverse ( String motEncode )
  /*
  ++ motEncode : Le mot à inverser (ex: <"123"> --> "321")
  ++ inverse : Retourne le mot inverser. (ex: "123" --> <"321">)
  */
  {
  int i; //Compteur misc.
  String estEnc= new String(""); //Mot encodé
  for (i=motEncode.length()-1; i>=0; i--)
    {
    estEnc=estEnc+motEncode.charAt(i);
    }
  return estEnc;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean pair(long nverifie)
  /*
  ++ nverifie : Un nombre entiers
  ++ pair : Retourne TRUE si le nombre est pair, ou FALSE si le nombre est impair.
  */
  {
  if (nverifie%2==0) {return true;} else {return false;}
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String encAlterne ( String motEncode )
  /*
  ++ motEncode : Chaîne de caractère à encoder
  ++ enAlterne : Alterne de place chaque deux caractères.  Si il y a un nombre
                 impair de caractère, une espace est ajoutée au mot avant
                 l'encodage.
  */
  {
  int i; //Compteur misc.
  String motEnc = new String("");
  if (motEncode.length()==0) return "";
  if (motEncode.length()%2 == 1)
    {
    motEncode = motEncode + " ";
    }
  for (i=0; i<=motEncode.length()/2-1; i++)
    {
    motEnc = motEnc + motEncode.charAt(i*2+1);
    motEnc = motEnc + motEncode.charAt(i*2);
    }
  return motEnc;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String encodeSimple ( String motEncode, int n)
  /*
  ++ motEncode : Mot à encodé
  ++ n : Incrémenter les caractères ascii de "motEncode" par "n" positions
         (ex: si n=1 alors "A" --> "B")
  ++ encodeSimple : Retourne le mot encodé.
  */
  {
  int i;
  int tmpChar;
  String motEnc = new String("");
  if (motEncode.length()==0) return "";
  for (i=0; i<motEncode.length(); i++)
    {
    tmpChar = (((int) motEncode.charAt(i))+n)%256;
    motEnc = motEnc + (char) tmpChar;
    }
  return motEnc;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String encrypt ( String motEncode, int ascii, boolean inverseC, boolean alterneC )
  /*
  ++ motEncode : Le mot à encoder.
  ++ ascii : Incrémenter les caractères ascii de "motEncode" par "n" positions
             (ex: si n=1 alors "A" --> "B")
  ++ inverseC : Si TRUE, le mot prend sont sens oposé (voir fonction encInverse)
  ++ alterneC : Si TRUE, Alterne de place chaque deux caractères.  Si il y a un
                nombre impair de caractère, une espace est ajoutée au mot avant
                l'encodage.
  ++ encrypt : Retourne le mot crypté. NOTE: Cette fonction peut aussi être
               utiliser pour décrypter puisque l'ordre contraire des
               appelles des fonctions ne sont pas nécéssaires (ex: f(1) ; f(2)
               f(3) encrypte.. Mais f(2) ; f(3) ; f(1) peut le décrypter...
  */
  {
  String motEnc=new String(motEncode);
  if (alterneC) motEnc = encAlterne (motEnc);
  if (inverseC) motEnc = encInverse (motEnc);
  motEnc = encodeSimple (motEnc, ascii);
  return motEnc;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  protected static int trouveLibre() //Utilisé par fichierOuvre
  //Retourne -1 pour dire qu'il n'y a plus aucune place.
  //Utilisé pour trouver une position [posF] pour storer l'information
  //d'un fichier.  0..[maxFichierOuvert-1]
  {
  int i;
  for (i=0; i<maxFichierOuvert; i++)
    {
    if (!fichierActive[i]) {return i;}
    }//END FOR
  return -1;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String tabSim ( String inputStr, long targetSize )
  /*
  ++ inputStr   : Le string en question
  ++ targetSize : Le montant d'espace que l'on voudrait que ça prend
  ++ tabSim     : Retourne inputStr + le montant d'espace (si besoin) comme
                  remplissage.
  */
  {
    String temp;
    if (inputStr!=null)
    {
      temp=new String(inputStr);
      for (int i=1; i<=targetSize-inputStr.length(); i++)
      temp=temp+" ";
    }else
    {
      temp="";
      for (int i=1; i<=targetSize; i++)
      temp=temp+" ";
    }
    return new String(temp);
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static int fichierOuvre ( String nomDuFichier )
  /*
  NOTE: Les fichier sont toujours ouvert dans le mode BINAIRE et NON TEXTE*****
  ++ nomDuFichier : Le fichier spécifié sera ouvert.
  ++ fichierOuvre : Retourne >=0 si c'étais un succès.  Si faux, pbxProb peut
                    être utilisé pour savoir c'étais quoi le problème.
  */
  {
  int compteur; //Compteur misc.
  int posF; //Position du fichier (dans la chaine interne de fichiers)
  RandomAccessFile fichier; //Liste interne des propriétés des fichiers
  if (nomDuFichier=="") return -1;
  //Initialise les variables internes.
  //----------------------------------
  if (!initFichier)
    {
    for (compteur=1; compteur<maxFichierOuvert; compteur++)
      {
      fichierSeek[compteur]=0;
      fichierActive[compteur]=false;
      }//END FOR
    initFichier=true;
    }//END IF
  //Trouve de l'espace pour ouvrir le fichier
  //-----------------------------------------
  if ((posF=trouveLibre())==-1)
    {
    erreurPBX="PBX: Trop de fichiers sont ouverts.";
    return -1;
    }//END IF
  //Essaye d'ouvrir le fichier
  //----------------------------
  nomFichier[posF] = new File(nomDuFichier);
  if (!nomFichier[posF].exists())
    {
    erreurPBX="PBX: Fichier "+nomDuFichier+" n'existe pas.";
    //Mais pourrais etre un directoire.
    return -1;
    }//END IF
  try
    {
      fichier = new RandomAccessFile( nomDuFichier, "r" );
    }
  catch (Exception O)
    {
    erreurPBX="PBX: Fichier "+nomDuFichier+" n'est pas un fichier.";
    //Alors étais un directoire..
    return -1;
    }//END TRY
  try
   {
   fichier.close();
   }catch(Exception X)
   {
   erreurPBX="PBX: "+X.toString();
   return -1;
   }
  fichierActive[posF]=true;
  fichierSeek[posF]=0;
  return posF;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean fichierEfface ( String nomDuFicher )
  /*
  ++ nomDuFichier : Nom complet du fichier à effacer
  ++ fichierEfface : Retourne TRUE si le fichier existant a été effacer, ou
                     FALSE sinon
  */
  {
  File creer=new File(nomDuFicher);
  boolean check;
  check=creer.delete();
  return check;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean fichierNouveau ( String nomDuFicher )
  /*
  ++nomDuFichier : Nom du fichier à créer.  Si le fichier existe déjà, rien se produira.
                 Pour sur-écrire un fichier, il faut d'abord essayer d'ouvrir le
                 fichier et de voir s'il existe, et ensuite l'effacer avant
                 d'utiliser cette commande.
  ++ fichierNouveau : Retourne TRUE si le fichier n'existait pas et à été crée
                      sinon retourne FALSE.  (Ex: Si le fichier existe déjà,
                      FALSE sera retourné)
  */
  {
  File creer=new File(nomDuFicher);
  boolean check=false;
  try
    {
    check=creer.createNewFile();
    }
  catch (Exception A)
    {
    erreurPBX="PBX: "+A.toString();
    }
  return check;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String fichierLireDat()
  /*
  ++ fichierLireData : Retounre l'information lue durant la dernière appelle
                       à "fichierLire" sous forme de String.  La variable
                       publique "bufferData" peut être utiliser pour un char[]
  */
  {
  return String.valueOf(bufferData, 0, aEteLue);
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static int fichierLire ( int fichierData, int lireCombien )
  /*
  ++ fichierData : Numéro du fichier ouvert
  ++ lireCOmbien : Lire combien d'octets
  ++ fichierLire : Retourne -1 pour dire de l'opération n'était pas un succès, ou
                   >=0 pour dire combien d'octet on été lue (0..lireCombien)
  */
  {
  //Vérification critique
  if (lireCombien<0 || lireCombien>32768) return -1;
  //
  byte[] buffer = new byte[lireCombien];
  int combienLue; //Combien de bytes ont été lue comparé au "lireCombien"
  int compteur;
  RandomAccessFile fichier;
  //Vérifications supplémentaire..
  //------------------------------
  if (!initFichier)
    {
    erreurPBX="PBX: Aucuns fichiers ne sont ouverts.";
    return -1;
    }//END IF
  if (fichierData<0 || fichierData>=maxFichierOuvert)
    {
    erreurPBX="PBX: Le numéros du fichier est mauvais.";
    return -1;
    }//END IF
  if (!fichierActive[fichierData])
    {
    erreurPBX="PBX: Le fichier n'est pas ouvert";
    return -1;
    }//END IF
  //Ré-OUVRE le fichier
  //-------------------
  try
    {
      fichier = new RandomAccessFile( nomFichier[fichierData].toString(), "r" );
    }
  catch (Exception O)
    {
    erreurPBX="PBX: Fichier "+nomFichier[fichierData].toString()+" n'est pas un fichier.";
    //Alors étais un directoire..
    return -1;
    }
  //Lire le fichier
  //----------------
  try
    {
    fichier.seek(fichierSeek[fichierData]);
    combienLue = fichier.read(buffer);
    for (compteur = 0; compteur < combienLue; compteur++)
    bufferData[compteur] = (char) buffer[compteur];//END FOR
    }
  catch (Exception X)
    {
    erreurPBX="PBX: "+X.toString();
    //Le fichier est ouvert pour "écriture-seulement", etc...
    return -1;
    }//END TRY
  aEteLue=combienLue;
  return combienLue;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean fichierEcrit ( int fichierData, char[] bufferLire, int ecrireCombien )
  /*
  ++ fichierData : Numéro du fichier ouvert
  ++ bufferLire  : Information à écrire dans le fichier
  ++ écrireCombien : Écrire combien des octets de bufferLire (0..<>)
  ++ fichierEcrit : Retourne TRUE pour dire que l'opération était un succès, ou FALSE
                    pour tout autre raison.
  */
  {
  //Vérification critique
  if (ecrireCombien<0 || ecrireCombien>32768) return false;
  int compteur;
  RandomAccessFile fichier;
  byte[] buffer = new byte[ecrireCombien];
  //Vérifications supplémentaire..
  //------------------------------
  if (!initFichier)
    {
    erreurPBX="PBX: Aucuns fichiers ne sont ouverts.";
    return false;
    }//END IF
  if (fichierData<0 || fichierData>=maxFichierOuvert)
    {
    erreurPBX="PBX: Le numéros du fichier est mauvais.";
    return false;
    }//END IF
  if (!fichierActive[fichierData])
    {
    erreurPBX="PBX: Le fichier n'est pas ouvert";
    return false;
    }//END IF
  //Ré-OUVRE le fichier
  //-------------------
  try
    {
      fichier = new RandomAccessFile( nomFichier[fichierData].toString(), "rw" );
    }
  catch (Exception O)
    {
    System.out.println(O.toString());
    erreurPBX="PBX: Fichier "+nomFichier[fichierData].toString()+" n'est pas un fichier.";
    //Alors étais un directoire..
    return false;
    }
  //Écrire dans le fichier
  //----------------------
  for (compteur=0; compteur<ecrireCombien; compteur++)
    {
    buffer[compteur]=(byte) bufferLire[compteur];
    }//END IF
  try
    {
    fichier.seek(fichierSeek[fichierData]);
    fichier.write(buffer);
    }catch (Exception X)
    {
    erreurPBX="PBX: "+X.toString();
    return false;
    }
    fichierSeek[fichierData]=fichierSeek[fichierData]+ecrireCombien;
  try
    {
    fichier.close();
    }catch (Exception X)
    {
    erreurPBX="PBX: "+X.toString();
    return false;
    }
  return true;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean fichierGrandeur ( int fichierData, long commentGrand )
  /*
  ++ fichierData : Numéro du fichier ouvert
  ++ commentGrand : La nouvelle grandeur du fichier
  ++ fichierGrandeur : Retourne TRUE pour dire que c'était un succès ou FALSE
                       pour tout autres raisons.
  */
  {
  //Vérifications supplémentaire..
  //------------------------------
  RandomAccessFile fichier;
  if (commentGrand<0) return false; //Vérification critique.
  if (!initFichier)
    {
    erreurPBX="PBX: Aucuns fichiers ne sont ouverts.";
    return false;
    }//END IF
  if (fichierData<0 || fichierData>=maxFichierOuvert)
    {
    erreurPBX="PBX: Le numéros du fichier est mauvais.";
    return false;
    }//END IF
  if (!fichierActive[fichierData])
    {
    erreurPBX="PBX: Le fichier n'est pas ouvert";
    return false;
    }//END IF
  //Ré-OUVRE le fichier
  //-------------------
  try
    {
      fichier = new RandomAccessFile( nomFichier[fichierData].toString(), "rw" );
    }
  catch (Exception O)
    {
    erreurPBX="PBX: Fichier "+nomFichier[fichierData].toString()+" n'est pas un fichier.";
    //Alors étais un directoire..
    return false;
    }
  //Change la grandeur;
  try
    {
    fichier.setLength(commentGrand);
    }catch (Exception X)
    {
    erreurPBX="PBX: "+X.toString();
    return false;
    }
  return true;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean fichierSeek ( int fichierData, long positionF )
  /*
  ++ fichierData : Numéro du fichier ouvert.
  ++ positionF : Position à laquelle sauter en partant de 0.
  ++ fichierSeek : Retourne TRUE juste si l'opération était un succès.
  */
  {
  if (fichierData>=0 && fichierData<maxFichierOuvert && fichierActive[fichierData])
    {
    fichierSeek[fichierData]=positionF;
    return true;
    }else
    {
    return false;
    }//END IF
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static boolean fichierFerme ( int fichierData )
  /*
  ++ fichierData : Numéro du fichier ouvert
  ++ fichierFerme : Retounre TRUE juste si l'opération était un succès.
  */
  {
  if (fichierData>=0 && fichierData<maxFichierOuvert && fichierActive[fichierData])
    {
    fichierActive[fichierData]=false;
    return true;
    }else
    {
    return false;
    }//END IF
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String uCase ( String inputStr )
  /*
  inputStr : La chaine de caractère à rendre majiscule.
  uCase : Retourne une chaîne de caractères majiscule.
  */
  {
  int compteur;
  String tempStr=new String("");
  for (compteur=0; compteur<inputStr.length(); compteur++)
   tempStr = tempStr+Character.toUpperCase(inputStr.charAt(compteur));
  return tempStr;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String lCase ( String inputStr )
  /*
  inputStr : La chaine de caractère à rendre miniscule.
  lCase : Retourne une chaîne de caractères miniscule.
  */
  {
  int compteur;
  String tempStr=new String("");
  for (compteur=0; compteur<inputStr.length(); compteur++)
   tempStr = tempStr+Character.toLowerCase(inputStr.charAt(compteur));
  return tempStr;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String dialogueOuvre()
  {
  JFileChooser boiteDialogue = new JFileChooser();
  int optionPige = boiteDialogue.showOpenDialog(null);
  if (optionPige == boiteDialogue.APPROVE_OPTION)
    {
    return boiteDialogue.getSelectedFile().toString();
    }//END IF
  return "";
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String dialogueSauve()
  {
  JFileChooser boiteDialogue = new JFileChooser();
  int optionPige = boiteDialogue.showSaveDialog(null);
  if (optionPige == boiteDialogue.APPROVE_OPTION)
    {
    return boiteDialogue.getSelectedFile().toString();
    }//END IF
  return "";
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String fichierTexteLire(int fichierData)
  {
  String combienLue=new String(""); //Combien de bytes ont été lue comparé au "lireCombien"
  int compteur;
  long fichierGrand;

  RandomAccessFile fichier;
  //Vérifications supplémentaire..
  //------------------------------
  if (!initFichier)
    {
    erreurPBX="PBX: Aucuns fichiers ne sont ouverts.";
    return "";
    }//END IF
  if (fichierData<0 || fichierData>=maxFichierOuvert)
    {
    erreurPBX="PBX: Le numéros du fichier est mauvais.";
    return "";
    }//END IF
  if (!fichierActive[fichierData])
    {
    erreurPBX="PBX: Le fichier n'est pas ouvert";
    return "";
    }//END IF
  //Ré-OUVRE le fichier
  //-------------------
  try
    {
      fichier = new RandomAccessFile( nomFichier[fichierData].toString(), "r" );
    }
  catch (Exception O)
    {
    erreurPBX="PBX: Fichier "+nomFichier[fichierData].toString()+" n'est pas un fichier.";
    //Alors étais un directoire..
    return "";
    }
  //Lire le fichier
  //----------------
  try
    {
    fichier.seek(fichierSeek[fichierData]);
    combienLue = fichier.readLine();
    fichierGrand=fichier.length();
    }
  catch (Exception X)
    {
    erreurPBX="PBX: "+X.toString();
    //Le fichier est ouvert pour "écriture-seulement", etc...
    return "";
    }//END TRY

    if (combienLue!=null)
    {
    for (compteur=2; compteur<=3;compteur++)
      {
      if (fichierGrand-1<fichierSeek[fichierData]+combienLue.length()+compteur)
        {
        break;
        }
      try {
      fichier.seek(fichierSeek[fichierData]+combienLue.length()-1+compteur);
      } catch (Exception noNeedToCheck)
      {
      }
      String verF=new String("");
      try
        {
        verF=fichier.readLine();
        }catch (Exception noNeedToCheck)
        {
        }
      if (verF!=null)
        {
        if (verF.length()!=0)
          {
          break;
          }//END IF
        }else
        {
        break;
        }//END IF
      }//END FOR
    fichierSeek[fichierData]=fichierSeek[fichierData]+combienLue.length()-1+compteur;
    }//END IF !null
    else
    {
      erreurPBX="Fin de fichier\n";
    }
    try
    {
      fichier.close();
    }catch(Exception O)
    {
      System.out.println(O);
    }
  return combienLue;
  }
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  //%%%%%%%%%%%%%%%%%%%%%%%%%
  public static String probPBX()
  {
  // ++probPBX : Retourne l'état d'erreur de la classe PBX.
  //Certaines fonctions peuvent générer des erreurs et juste retourner une valeur comme défaut.
  //Si il y en `s une, cette fonction retournera <>"" avec l'erreur entre guimets.
  String tempPrendVar;
  tempPrendVar=erreurPBX;
  erreurPBX="";
  return tempPrendVar;
  }
  public Pbx() {
  //
  }
}