3 Conception détaillée

ANALYSE et CONCEPTION
Laboratoire CLIPS - IMAG
840900634
version 1.0
WICALE
(Web Interface for Communication
with All Linguare Environnement)
Interface cliente générique
pour le pilotage
de serveurs linguistiques
Etat : En Travail
Version 1.0
REF :SPC-APP-1.0
Page 1 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
Destinataire(s) :
NOM
ACTION
Christian Boitet
Damien Genthial
Pour validation
Pour validation
VISA
Historiques du document de conception :
Version
Date
1.0
03/11/2003
Origine de la mise à Rédigé par
jour
CARPENA Virginie
Historiques de «WICALE»
Version
Date de livraison
Fonctionnalités
implémentées
1.0
Suivi des modifications de la version courante
Version
Page
Paragraphe
Description des Auteur
modifications
Page 2 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Tables des matières
1
2
Analyse conceptuelle ......................................................................................................... 4
1.1
Les règles............................................................................................................................... 5
1.2
Définition des objets ............................................................................................................. 7
Les solutions envisagés ................................................................................................... 10
2.1
La solution 1 : Interface abstraite .................................................................................... 10
2.2
La solution 2 : Langagier................................................................................................... 11
2.3
Synthèse de la solution retenue aux niveau fonctionnel et organisationnel / conclusion
et perpectives ................................................................................................................................... 11
3
Conception détaillée ........................................................................................................ 11
3.1
Architecture technique du nouveau système ................................................................... 11
3.2
Les écrans (enchainement des menus et des écrans) ....................................................... 12
3.3
Les classes ........................................................................................................................... 25
3.4
Description des données..................................................................................................... 61
3.5
Les fichiers XML................................................................................................................ 61
3.6
Les méthodes ........................................................................... Error! Bookmark not defined.
Page 3 sur 65
Laboratoire CLIPS - IMAG
1
1.1
840900634
version 1.0
Analyse conceptuelle
Résumé
L’application WICALE permet de (voir figure 1) :
- communiquer avec le serveur afin de récupérer le résultat de l‘exécution d’une
commande sur le serveur,
- synchroniser les données linguistiques (réception et émission des linguiciels :
grammaires, dictionnaires, corpus…),
- gérer sur le client une image des linguiciels développés et mis en œuvre sur le serveur.
Préparer et exécuter
une ou des commandes
Serveur :ARIANE-G5,
PILAF, ou autre
Synchroniser les données
(émission et réception)
linguistes
Consulter et mettre à jour
les linguiciels (en local)
Modification des paramètres de
WICALE (langue, répertoires,…)
Fig.1 : Cas d’utilisation d’un linguiste
Page 4 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
Un utilisateur habilité (administrateur, informaticien) peut paramétrer l’application
WICALE. C’est à dire, définir les serveurs disponibles, et pour chaque serveur définir les
commandes (définition des paramètres, de la syntaxe et du résultat de la commande),
l’architecture des données.
Paramétrer les commandes disponibles
(paramètres, syntaxe et résultat)
Administrateur
, informaticien
Paramétrer l’architecture des linguiciels
(architecture, émission et réception)
Programmer le module pour un nouveau
serveur
Fig.2 : Cas d’utilisation de l’administrateur, informaticien
1.2
Les règles
Les fonctionnalités et les contraintes décrites dans le document de spécification, nous
permettent de décrire les règles de gestion de l’application WICALE.
WICALE peut implémenter un ou plusieurs EDLs.
Pour chaque EDL, on dispose d’une liste de commandes. L’exécution d’une commande sur le
serveur nécessite de définir la saisie des paramètres, la syntaxe de la commande
(l’enchaînement des paramètres) et le traitement du résultat.
Les types de paramètres disponibles sont des listes, cases à cocher, zones de texte, zones de
texte multi-lignes et zone de saisie d’un nom de fichier (FILE DIALOG).
L’application doit contrôler la saisie des données obligatoires.
La syntaxe d’une commande est une suite de mots clés, de valeurs, et de séparateurs.
Le résultat d’une commande retourné par le serveur est sous forme d’un texte, l’utilisateur
peut traiter ce résultat. Il peut remplacer une chaîne par une autre (replace), découper le texte
(split), et rechercher un texte particulier (find).
Page 5 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
Les données des EDL sont disponibles sur le poste du client, elle sont rangés suivant
l’architecture des données de l’EDL. Par exemple pour ARIANE pour un couple de langue et
une phase on dispose de composants linguistiques (des grammaires, dictionnaires et des
chaînes d’exécution…).
1
EDL
1..n
COMMANDE
1
1
COMPOSANT
1
1..n
0..n
0..n
1
PARAMETRE
1..n
SYNTAXE
hérite
1
0..n
0..n
ETAPE
TEXTE
Case à
cocher
CHOIX
FICHIER
RESULTAT
1
ETAPE
LISTE
E
Fig 3 : diagramme de classe
Page 6 sur 65
Laboratoire CLIPS - IMAG
1.3
version 1.0
840900634
Définition des objets
EDL
serveur
port
accès
url
L’objet EDL permet de définir les propriétés de l’EDL :
le nom de EDL (identifiant), le type d’accès au serveur
- accès par socket (accès, port)
- accès http(url).
COMMANDE
num_cde
nom_cde
intitule_cde
L’objet COMMANDE permet de définir les commandes
disponibles sur le serveur: le numéro de commande
(identifiant), le nom de commande correspond au nom du
fichier Analyse.py (PILAF), ou LIENLANG (pour
Ariane-G5), l’intitulé de la commande (texte connu des
utilisateurs Analyse morphologique ou Affichage du
couple de langues).
PARAMETRE
nom
libelle
posLibX
posLibY
dimLibX
dimLibY
type
valeur_def
obligatoire
PosX
Pos Y
Dim X
Dim Y
L’objet PARAMETRE permet de définir les propriétés
d’un paramètre : le nom du paramètre (identifiant), le
libellé, le type de paramètre (List, Texte, case à cocher,
fichier), les contrôles à effectuer sur les paramètres saisies
par l’utilisateur (saisie obligatoire), le positionnement des
paramètres dans l’écran de saisie (libellé + champ) et la
valeur par défaut.
TEXTE
Pas de nouveau attribut
Case à cocher
nom_valeur
liste_valeur
Chaine_recup
L’objet CASE A COCHER permet de définir les
propriétés d’un paramètre checkbox : liste de valeurs
Page 7 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
LISTE
nom_valeur
liste_valeur
Chaine_recup
Multiligne
Separateur
L’objet LISTE permet de définir les propriétés d’un
paramètre liste : le nom de la liste à afficher (par exemple
LISTE_MACHINE), la liste des valeurs ou le nom de la
commande : chaque valeur est séparé par un point-virgule
Par exemple (ED - Edition ; REC - Réception).
La chaîne à récupérer lors de la saisie pour compléter la
commande (Par exemple, l’expression régulière [A-Z]* -).
La commande a besoin du code ED et non du libellé.
CHOIX
L’objet CHOIX permet de définir les propriétés d’un
paramètre Choice : le libellé du choix, la position du choix
et la valeur.
nom_choix
posX posY
dimX dimY
valeur_choix
DIALOGFILE
Chaine_recup
SYNTAXE°
mot cle,
param
expression
séparateur
L’objet DIALOGFILE permet de définir les propriétés
d’un paramètre de type fichier : la chaîne récupérée est
soit le nom du fichier, soit le contenu du fichier Texte.
L’objet SYNTAXE permet de définir les propriétés de la
syntaxe d’une commande : le mot clé, le valeur du
paramètre à partir de l’expression, le séparateur.
Page 8 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
RESULTAT
Resultat_ok
L’objet RESULTAT permet de définir les propriétés d’un
résultat : le texte pour vérifier si le résultat est correcte.
ETAPE
methode
expression
expr_concat
expr_remplace
ment
L’objet ETAPE permet de définir les étapes de traitement
d’un résultat : la méthode à appliquer (split, find, replace)
et l’expression régulière (expression, expression de
concaténation, expression de remplacement).
COMPOSANT
nom
type
contenu
Le composant linguistique est identifié par son nom, type
(dictionnaires, formats…), contenu
Page 9 sur 65
Laboratoire CLIPS - IMAG
2
2.1
version 1.0
840900634
Les solutions envisagés
La solution 1 : Interface abstraite
Pour respecter les contraintes définies dans le cahier des charges, une des solutions est de
programmer les fonctionnalités communes aux serveurs (fonctionnalités décrites
précédemment : Exécution commande, synchronisation des résultats et navigation en locale).
Et de définir les spécificités des EDLs (liste de commandes, syntaxe…) dans des fichiers de
paramétrage XML.
Un utilisateur avertit peut compléter les spécificités sans modifier le programme.
Les écrans sont générés dynamiquement lors de l’exécution du programme.
Pour communiquer avec le serveur, le programme utilise une API (classe abstraite). Les
attributs et les méthodes sont définis pour chaque EDL.
XML
Application.jar
Modif
Paramètre
Ecran principal
Exécution
commande
Création script
Et exécution cde
Synchronisation
données
Modification
linguiciels
implémente
Interface Serveur
+getResultat
ServerAriane
Serveur
ServerPilaf
ServerUnl
Serveur
Figure 5 : Application dynamique
Serveur
Page 10 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
2.2
La solution 2 : Langagier
2.3
Synthèse de la solution retenue aux niveau fonctionnel et organisationnel /
conclusion et perpectives
La solution 1 a été retenue, elle répond aux spécifications techniques, elle permet de :
- ne pas recompiler l’application lors de l’ajout d’une commande ou paramètre,
- ne pas recompiler l’application lors de l’ajout d’un EDL
3
Conception détaillée
3.1 Architecture technique du nouveau système
L’application WICALE est structurée en package :
- ihm:définit les écrans de l’application,
- serveur : définit l’interface « ServeurLinguistique», les classes de chaque serveur
« ServerAriane », « ServerPilaf », « Serveur UNL ».
- objet : définit les classes des objets « Serveur », « Commande », « Parametre »,
« Syntaxe »…
- util : définit les fonctions communes : classe « Erreur », « XML », « ExprReguliere »,
« Fichier », « Constante », « Impression », « Jframe ».
IHM
SERVEUR
OBJET
UTIL
globale
Figure 6 : diagramme des composants
Page 11 sur 65
Laboratoire CLIPS - IMAG
3.2
version 1.0
840900634
Les écrans (enchaînement des menus et des écrans)
Les écrans sont définis dans le package IHM, ils sont structurés de la manière suivantes :
FrmMain
FrmSaisieParam
FrmAPropos
FrmScript
FrmResultat
FrmParametre
FrmSynchro
FrmNavigation
FrmComposant
Fig 7 : Enchaînement des écrans de WICALE
L’écran principal (FrmMain) s’affiche lorsque l’utilisateur lance l’application
linguiste
WICALE
Serveur
Lance l’application(main)
Charge les paramètres (chargeParametre – general.xml),
Crée les menus, (creeMenus),
Crée les composants (CreeComposants),
Affiche les libellés suivant la langue (afficheLibelle),
Affiche les serveurs et commandes (actionAfficheTree)
Demande l’écran A propos (actionPerformed)
Affiche l’écran A propos
Demande l’écran Resultat (actionPerformed)
Affiche l’écran FrmResultat
Page 12 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Exécute commande(actionAfficheParametreCde)
Affiche l’écran FrmSaisieParam
Exécute script commande (actionPerformed)
Affiche l’écran FrmScript
Synchronise données (actionPerformed)
Affiche l’écran FrmSynchro
Consultation données(actionPerformed)
Affiche l’écran FrmNavigation
Demande l’écran Parametre(actionPerformed)
Affiche l’écran FrmParametre, au
retour
à
l’écran
principal
chargeParametre, afficheLibelle)
Interface prévue
L’écran principal présente les fonctionnalités de l’application WICALE, les commandes de
chaque serveur disponibles. Les fonctionnalités sont accessibles soit à partir des boutons de la
barre d’outils (OuvrirResultat, Quitter, Exécute la commande, Commande en attente,
Navigation, Synchronisation, Paramètres, A propos), soit à partir du menu Commande.
L’exécution de la commande est disponible en double cliquant sur la commande dans l’arbre.
Page 13 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
Les contrôles prévus
Lors de l’exécution d’une commande, vérifie qu’une commande a été sélectionné dans
l’arbre.
L’application implémente les fonctionnalités suggérées par le menu principal.
3.2.1 Ecran exécution Commande (FrmSaisieParam)
L’écran (FrmSaisieParam) est généré dynamiquement par rapport à la commande sélectionnée
(lecture des paramètres dans le fichier XML <PARAMETRE_SAISIE>.
A FAIRE : A partir de l’API Jframe
linguiste
WICALE
Serveur
Page 14 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Demande affichage des paramètres de cde (main)
Crée les composants (commun + Commande.xml)
(CreeComposants),
Initialise l’écran (setup),
Initialise listes et valeurs par défaut (initialiseParametre)
Saisie des paramètres
Click sur Exécution Commande (option afficher
résultat dans le fichier coché(actionLancer)
Enregistre le fichier dans le répertoire saisie
Exécute
commande(getR
esultat)
Retourne
commande(traite
Resultat)
Click sur effacer paramètre
Vide tous les champs saisie
Saisie des paramètres
Click sur Exécution Commande (option afficher
résultat dans le fichier non coché (actionLancer)
Ouvre FrmResultat avec le résultat texte
Exécute
commande(getR
esultat)
Retourne
commande(traite
Resultat)
Demande de fermer l’ecran FrmResultat
Retour à l’écran frmSaisieParam
Click sur effacer paramètre
Vide tous les champs saisie
Saisie des paramètres
Click sur Script Commande (actionScript)
Enregistre les paramètres de la commande dans
Script.xml
Demande de fermer l’ecran FrmSaisieParam
Retour à l’écran principal (FrmMain)
Page 15 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Interface prévue
L’écran principal présente les fonctionnalités de l’application WICALE, les commandes de
chaque serveur disponibles. Les fonctionnalités sont accessibles soit à partir des boutons de la
barre d’outils (OuvrirResultat, Quitter, Exécute la commande, Commande en attente,
Navigation, Synchronisation, Paramètres, A propos), soit à partir du menu Commande.
L’exécution de la commande est disponible en double cliquant sur la commande dans l’arbre.
Les contrôles prévus
Vérification lors de l’exécution de la commande ou de la création du script que les paramètres
obligatoires sont saisis.
3.2.2 Ecran Commandes en attente (FrmScript)
Page 16 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
L’écran (FrmScript) affiche les commandes préparées par l’utilisateur (elles sont stockées
dans le répertoire DATA/SERVEUR/Script.xml.
linguiste
WICALE
Serveur
Demande affichage du script (FrmScript)
Crée les composants (commun + Commande.xml)
(CreeComposants),
Initialise l’écran (setup),
Initialise listes suivant l’architecture (initialiseListe)
Modification possible des paramètres
Click sur OK(option afficher résultat dans le fichier
coché(actionLancer)
Enregistre le fichier dans le répertoire saisie
Exécute
les
commandes(getR
esultatScript)
Retourne
commande(traite
Resultat)
Demande à l’utilisateur s’il souhaite supprimer le script
L’utilisateur répond Oui
Script supprimé du fichier Script.xml
Sélection d’un script et click sur OK (option afficher
résultat dans le fichier non coché (actionLancer)
Demande à l’utilisateur s’il souhaite supprimer le script
Exécute
commande(getR
esultat)
Retourne
commande(traite
Resultat)
L’utilisateur répond Non
Ouvre FrmResultat avec le résultat texte
Demande de fermer l’ecran FrmResultat
Retour à l’écran frmScript
Page 17 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Demande de fermer l’ecran FrmScript
Retour à l’écran principal (FrmMain)
Interface prévue
L’écran Envoi des commandes préparées Affiche la liste des scripts. L’utilisateur peut
modifier le script mais attention le script de commande ne sera pas contrôlé (pas de contrôle
de la saisie des paramètres ni de la syntaxe de la commande).
Les contrôles prévus
Aucun
3.2.3 Ecran de Navigation (FrmNavigation)
Page 18 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
L’écran (FrmNavigation) permet de sélectionner un composant afin de le visualiser à l’écran.
linguiste
WICALE
Serveur
Demande affichage de l’écran Navigation(FrmNavigation)
Crée les composants (commun + Commande.xml)
(CreeComposants),
Initialise l’écran (setup),
Initialise
listes
suivant
l’architecture
(initialiseListeComposant)
Sélection d’un composant et demande de l’ouvrir
Recherche du composant dans le répertoire DATA et
affichage du contenu dans l’écran FrmComposant
Modification du contenu et enregistrement
Mise à jour des fichiers XML contenant les données
Demande de fermer l’écran FrmComposant
Ferme FrmComposant et retour FrmNavigation
Demande de fermer FrmNAvigation
Ferme l’écran et retour à l’écran principal
Interface prévue
L’écran Consultation des composants permet de sélectionner le type de composant (dans
l’exemple ci –dessous un texte) et le composant. Pour visualiser le composant, il suffit de
double cliquer sur le composant ou de cliquer sur le bouton Ouvrir dans la barre d’outils
Page 19 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
puis Affichage du contenu dans l’écran FrmComposant (Dans une prochaine version de
WICALE il faudra que l’utilisateur puise ouvrir le composant dans un éditeur de texte).
Les contrôles prévus
Page 20 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
Aucun
3.2.4 Ecran Commandes en attente (FrmScript)
L’écran (FrmScript) affiche les commandes préparées par l’utilisateur (elles sont stockées
dans le répertoire DATA/SERVEUR/Script.xml.
linguiste
Demande
affichage
synchronisation(FrmSynchro)
WICALE
de
l’écran
Serveur
de
Crée les composants (commun + Commande.xml)
(CreeComposants),
Initialise l’écran (setup),
Initialise listes suivant l’architecture (initialiseListe)
Demande de visualisation d’un composant
Click sur OK(option afficher résultat dans le fichier
coché(actionLancer)
Exécute
les
commandes(getS
ynchronisation)
Affiche le résultat dans l’onglet composant
Retourne
contenu
composant (traiteResultat)
Demande d’emmettre un composant
La barre d’état affiche un message lorsque le
traitement est terminé
Demande de réceptionner un résultat
Mise à jour du fichier DATA/ …/ …xml.
La barre d’état affiche un message lorsque le
traitement est terminé
Exécute
la
commande(getSy
nchronisation)
Exécute
la
commande(getSy
nchronisation)
Demande de fermer l’ecran FrmSynchronisation
Retour à l’écran principal (FrmMain)
Page 21 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Interface prévue
L’écran Synchronisation des composants permet de synchroniser ou de visualiser les
composants du serveur.
L’utilisateur peut visualiser le composant du serveur en sélectionnant le composant puis en
cliquant sur le bouton Visualiser. Le contenu du composant s’affiche dans l’onglet
Composant.
L’utilisateur peut récupérer un composant en local, il sélectionne le composant, puis clique
sur le bouton Réception.
L’utilisateur peut mettre à jour un composant sur le serveur, il sélectionne le composant, puis
clique sur le bouton Emission
Les contrôles prévus
Aucun
3.2.5 Ecran de paramétrage (FrmParametre)
Page 22 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
L’écran (FrmParametre) permet de mettre à jour les paramètres de l’application WICALE.
linguiste
WICALE
Serveur
Demande l’écran de paramétrage(FrmParametre)
Crée les composants (commun + Commande.xml)
(CreeComposants),
Initialise l’écran (setup),
Initialise listes suivant l’architecture (initialiseListe)
Mise à jour des paramètres et demande d’enregistrer
Mise à jour du fichier general.xml
Demande de fermer l’écran FrmParametre
Ferme FrmParametre et retour FrmMain principal
Interface prévue
L’écran Paramètres de WICALE permet de saisir les paramètres généraux de l’application
c’est à dire le serveur par défaut (sélectionné lors du lancement de la commande dans l’écran
principal), la langue utilisé (affichage des libellés dans les écrans),
Les répertoires des paramètres (fichier XML) et des données (fichier des composants XML).
Cet écran permet de mettre à jour le fichier général.xml directement dans le répertoire des
sources.
Page 23 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
Les contrôles prévus
Aucun
3.2.6 Ecran de paramétrage (FrmParametre)
L’écran (FrmParametre) permet de mettre à jour les paramètres de l’application WICALE.
linguiste
WICALE
Serveur
Demande l’écran d’a propos (FrmAPropos)
Crée les composants (commun + Commande.xml)
(CreeComposants),
Initialise l’écran (setup),
Page 24 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Demande de fermer l’écran FrmAPropos
Ferme FrmAPropos et retour FrmMain principal
Interface prévue
L’écran A propos permet d’afficher le nom des personnes ayant crée l’application, de
l’administrateur, le numéro de version.
Les contrôles prévus
Aucun
3.3 La description des classes
Ce paragraphe décrit les classes avec leurs attributs et méthodes que nous avons développées
et la hiérarchie qui les rassemble.
Nous avons essayé de respecter un certain style quant à l’écriture des classes, variables et des
constantes qui sont décrites dans la charte de développement WICALE.
3.3.1 Répertoire IHM
Ce répertoire contient les classes qui permettent d’instancier les écrans.








FrmMain .java
FrmResultat.java
FrmSynchro
FrmAPropos
FrmNavigation
FrmSaisieParam
FrmComposant
FrmParametre
//écran principal
// écran de résultat
// écran de synchronisation
// écran A Propos
// écran de Navigation
// écran de Saisie de paramètres
// écran de visualisation d’un composant
//écran de saisie des paramètres généraux
Page 25 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
 FrmScript
attente
//écran de lancement des commandes en
3.3.1.1 Hiérarchie des classes
Javax.swing.*
FrmMain
FrmSaisieParam
FrmAPropos
FrmScript
FrmParametre
FrmResultat
FrmSynchro
FrmNavigation
FrmComposant
LÉGENDE
Instancie un objet de la
classe
Dérive de
Classe développée
Classe de la bibliothèque de Sun
Page 26 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
3.3.1.1.1 Classe FrmMain
C’est une classe principale qui est une JFRame appelant l’instanciation de la fenêtre
principale.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import java.awt.*;
import java.awt.event.*;
import java.awt.Component;
import java.io.*;
import org.w3c.dom.*;
import java.util.*;
import java.lang.*;
import javax.swing.JtoolBar
;
et des packages spécifiques du laboratoire fr .Imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.objet.Parametre;
import fr.imag.clips.wicale.objet.Commande;
import fr.imag.clips.wicale.objet.ParametreCde;
import fr.imag.clips.wicale.objet.Serveur;
3.3.1.1.2 Attributs
private JPanel pnl = new JPanel();
private JToolBar toolbar = new JToolBar();
//private JPanel pnlParametre = new JPanel();
private JTree treeCommande = new JTree();
private
DefaultMutableTreeNode
nodRoot
=
DefaultMutableTreeNode("*");
private DefaultTreeModel treeModel ;
private JScrollPane scrollTree ;
private JLabel lblBarreEtat = new JLabel ("");
//JMenu
// JMenu fichier, 1 seule commande "Quitter"
private JMenu mnuFichier = new JMenu("", false);
private JMenuItem mnuFichierOuvrir = new JMenuItem("");
private JMenuItem mnuFichierQuitter = new JMenuItem("");
private JButton btnOuvrir = new JButton();
private JButton btnQuitter = new JButton();
// JMenu Commande
private JMenu mnuCommande = new JMenu("", false);
private JMenuItem mnuCommandeExecution = new JMenuItem("");
private JMenuItem mnuCommandeEnvoiScript = new JMenuItem("");
new
Page 27 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
private JMenuItem mnuCommandeNavigation = new JMenuItem("");
private JMenuItem mnuCommandeSynchronisation = new JMenuItem("");
private JMenuItem mnuCommandeParametre = new JMenuItem("");
//TOOLBAR
private JButton btnCommandeExecution = new JButton ("");
private JButton btnCommandeEnvoiScript = new JButton ("");
private JButton btnCommandeNavigation = new JButton ("");
private JButton btnCommandeSynchronisation = new JButton ("");
private JButton btnCommandeParametre = new JButton ("");
private JMenu mnuAide = new JMenu("", false);
private JMenuItem mnuAideApropos = new JMenuItem("");
private JButton btnAPropos = new JButton();
private JMenuBar mb = new JMenuBar();
3.3.1.1.3 Constructeur
public FrmMain()
3.3.1.1.4 Méthodes
 public void chargeParametre () :
 récupérer les paramètres généraux de l’application dans le fichier
general.xml:
- Parametre : répertoire Paramètre, répertoire DATA, langue par défaut,
serveur par défault
 public void actionPerformed (ActionEvent evt) :
 gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton A Propos qui provoquera l’instanciation
d’une fenêtre A propos. Le bouton Ouvrir Résultat qui provoquera
l’instanciation d’une fenêtre FrmResultat. Le bouton Commande exécution
qui provoquera l’instanciation d’une fenêtre FrmSaisieParam. Le bouton
Navigation qui provoquera l’instanciation d’une fenêtre FrmNavigation. Le
bouton Synchronisation qui provoquera l’instanciation d’une fenêtre
FrmSynchro. Le bouton Envoi script qui provoquera l’instanciation d’une
fenêtre FrmScript. Le bouton Parametre qui provoquera l’instanciation
d’une fenêtre FrmParametre, à la fermeture de la fenêtre charge les
nouveaux paramètres. Le bouton Quitter qui provoquera la fermeture de
l’application.
Si doubleclique sur une commande dans l’arbre provoque l’instanciation de
la fenêtre FrmSaisieParam.
 public void creeMenus () :
crée les menus de l’écran principale
 public void creeComposant() :
crée les composants de l’écran principale
 public void setup() :
Page 28 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
initialise la taille et la position de l’écran
 public void actionAfficheTree() :
initialise l’arbre des serveurs.
 public void actionAfficheCommande () :
initialise l’arbre des groupes et des commandes.
 public void actionAfficheParametreCde () :
Vérifie si l’utilisateur a sélectionné une commande et ouvre l’écran
FrmSaisieParam.
 public void afficheLibelle () :
affiche le libellé (labels, menu) dans la langue choisi par l’utilisateur.
 Private int getIndexCde () :
Retourne l’identifiant de la commande sélectionné.
3.3.1.1.5 Classe FrmSaisieParam
C’est une classe qui instancie l’écran FrmSaisieParam crée dynamiquement.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.lang.*;
import java.util.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.JToolBar;
import java.awt.Button;
import java.awt.List;
import java.awt.CheckboxGroup;*/
import javax.swing.JToolBar;
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
et des packages spécifiques du laboratoire fr .Imag.clips
import fr.imag.clips.wicale.objet.Parametre;
import fr.imag.clips.wicale.objet.Commande;
import fr.imag.clips.wicale.objet.SyntaxeCde;
import fr.imag.clips.wicale.objet.ParametreCde;
import fr.imag.clips.wicale.serveur.ServerLinguistique;
import fr.imag.clips.wicale.serveur.InterfaceServerLinguistique;
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.util.TraiteExprReg;
Page 29 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
3.3.1.1.6 Attributs
private JPanel pane = new JPanel();
private JPanel pnlParametre = new JPanel();
private JToolBar toolbar = new JToolBar();
private JButton btnLancer = new JButton("");
private JButton btnScript = new JButton("");
private JButton btnEffacer = new JButton("");
private JButton btnFermer = new JButton("");
private JLabel lblFichierOut = new JLabel("");
private JTextField txtFichierOut = new JTextField("",2);
private JButton btnParcourirOut = new JButton("");
private JLabel tabLabel[] = new JLabel [0];
private JButton tabBtn[] = new JButton [0];
private JTextField tabTxt [] = new JTextField [0];
private ButtonGroup tabBtnGroup [] = new ButtonGroup [0];
private JRadioButton tabRdoBtn[] = new JRadioButton [100];
private JTextArea tabTextArea [] = new JTextArea [0];
private JList tabList [] = new JList [0];
private JScrollPane tabScroll[] = new JScrollPane [0];
private DefaultListModel defLst;
private JComboBox tabComboBox [] = new JComboBox [0];
private int i=0, j=0;
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//Variables globales
private Thread thRun;
private JFrame fPrincipale;
private Locale currentLocale = new Locale("fr", "FR");
private ResourceBundle messages ;
private Parametre paramAppli;
private Commande cde = new Commande("");
private ParametreCde[] tabParam ;
private SyntaxeCde[] tabSyntaxeCde = new SyntaxeCde[0];
private ParametreCde[] tabGeneral = new ParametreCde[0];
private ParametreCde[] tabCde = new ParametreCde[0];
private SyntaxeCde[] tabConstGeneral = new SyntaxeCde[0];
private SyntaxeCde[] tabConstCde = new SyntaxeCde[0];
private Document docListe;
3.3.1.1.7 Constructeur
Page 30 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
FrmSaisieParam(JFrame fParent, Parametre param, String sTitre, Commande
cdeSelect, boolean bModal)
3.3.1.1.8 Méthodes
 public void actionPerformed (ActionEvent evt) :
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton Parcourir In qui ouvre un écran
permettant de saisir le nom d’un fichier. Le bouton Parcourir Out qui ouvre
un écran permettant de saisir le répertoire le nom d’un fichier résultat. Le
bouton Effacer qui supprime les valeurs des champs. Le bouton Lancer qui
lance l’exécution de la commande. Le bouton Script qui permet de mettre à
jour le fichier Script.xml en ajoutant la nouvelle commande.
 public void valueChanged (ItemEvent iEvt):
Remplit les listes dépendantes de l’élément sélectionné
 public void remplitListe() :
Charge les éléments dans une combo ou une liste déroulante
 public void creeComposant() :
Charge les composants de l’écran dynamiquement à partir du fichier
Commande.XML rubrique <PARAMETRE>
 public void setup() :
initialise la taille et la position de l’écran
 public void actionQuitter () :
Quitte l’écran FrmSaisieParam et vérifie qu’aucun traitement n’est en cours sinon
affiche un message.
 public void actionLancer() :
Lance l’exécution de la commande et ouvre l’écran FrmResultat si l’utilisateur n’a
pas l’option résultat dans un fichier.
 public void actionScript() :
Enregistre les données de la commande dans le fichier Script.xml pour un envoi
ultérieure. Si le fichier n’existe pas il faut le créer
 public void actionEffacer () :
Vide les champs et déselectionne les valeurs des listes.
 Private void actionParcourir () :
Ouvre l’écran qui permet de
showOpenDialog()
sélectionner
un
fichier
JFileChooser.
 Private String [] getParam () :
Retourne un tableau avec la liste des paramètres.
Page 31 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
 Private boolean SaisieObligatoire() :
Retourne true si les données obligatoires ont été saisis sinon retourne un message.
 Private void initialiseParametre () :
Affiche les valeurs par défaut et charge les listes (appel initialiseListeId).
 Private void initialiseListeId () :
Initialise les listes et combos.
 Private void lireFichier() : ASUPPRIMER !!!!!!!!!!!!!!!!!!!!!!!!!! Package util
 Private void actionLancerThread () :
Lance la commande en arrière plan, le résultat est enregistré dans un fichier
(option résultat dans un fichier).
3.3.1.1.9 Classe FrmNavigation
C’est une classe qui charge l’écran de navigation.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
// Pour que javadoc puisse générer les liens sur la doc de ces classes
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JList;
import javax.swing.JToolBar;
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.util.TraiteExprReg;
3.3.1.1.10 Attributs
private JPanel pnl = new JPanel();
private JPanel pnlParametre = new JPanel();
private JPanel pnlComposant = new JPanel();
Page 32 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
private JToolBar toolbar = new JToolBar();
private JButton btnOuvrir = new JButton("");
private JButton btnAnnuler = new JButton("");
private JLabel lblBarreEtat = new JLabel ("");
private JLabel lblComposant = new JLabel();
private JComboBox cboComposant = new JComboBox ();
private JLabel tabLabel[] = new JLabel[0];
private JList tabList[] = new JList[0];
private JScrollPane tabScroll[] = new JScrollPane[0];
private MouseListener mouseListener;
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//Variables globales
private JFrame fPrincipale;
private Locale currentLocale ;
private ResourceBundle messages ;
private Parametre paramAppli;
private TraiteExprReg t = new TraiteExprReg();
private TraiteXml xml = new TraiteXml();
private
String[]
tabMotCle
=
{"id","data",
"libelle_data","niveau","mise_a_jour","param_id","suiv", "nom_fichier", "expression"};
private int iID=0, iDATA = 1, iLIBELLE_DATA = 2, iNIVEAU = 3, iMAJ = 4,
iPARAM_ID = 5, iSUIV=6, iNOM_FICHIER=7, iEXPRESSION=8;
private String[] [] tabStructure = new String[0] [0];
private int iIdComposant = 0;//Sélectionner un composant
private String[] tabParametre = new String [0];
3.3.1.1.11 Constructeur
public FrmNavigation(JFrame fParent, Parametre param, boolean bModal)
3.3.1.1.12 Méthodes
 public void actionPerformed(ActionEvent evt):
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton Edition qui ouvre un écran permettant de
visualiser le composant sélectionné. La sélection d’un composant dans une
liste permet d’initialiser les paramètres à saisir pour sélectionner un
composant. Par exemple lorsque l’on saisit composant Texte Les paramètres
à saisir par l’utilisateur sont Machine ; disque.
 public void valueChanged(ActionEvent evt):
Page 33 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
La sélection d’un élément dans une liste permet d’initialiser les listes
dépendantes. Par exemple lorsque l’on saisit un Corpus et on met à jour la
liste des textes.
 private void selectionElement(ActionEvent evt):
La sélection d’un composant dans la liste permet d’initialiser les listes des
paramètres à saisir.
 private void remplitListe(Object iEvt):
La sélection d’une valeur permet de mettre à jour d’autres liste. Par exemple
lorsque l’on sélectionne un corpus la liste des textes est mise à jour.
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
 private void initialiseListe():
Initialise les listes à partir du fichier XML Liste.xml.
 private void initialiseComposant(int iPosParametre, int iIdStructure):
Initialise les listes à partir du fichier XML Liste.xml.
 private void initialiseListeComposant ():
Initialise la liste des composants à partir du fichier XML Liste.xml.
 private int getIdComposant ():
Retourne l’identifiant du composant sélectionné.
 private void actionEdition():
Recherche le contenu du composant suivant l’architecture des données et ouvre
l’écran FrmComposant.
3.3.1.1.13 Classe FrmScript
C’est une classe qui charge l’écran de navigation.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.awt.*;
import java.io.*;
import java.net.*;
import java.lang.*;
import java.util.*;
import org.w3c.dom.*;
import org.w3c.dom.traversal.*;
import org.xml.sax.SAXException;
import org.xml.sax.InputSource;
import javax.swing.*;
Page 34 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
import javax.swing.event.*;
// Pour que javadoc puisse générer les liens sur la doc de ces classes
import javax.swing.JButton;
import javax.swing.JComboBox;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.serveur.ServerLinguistique;
import fr.imag.clips.wicale.objet.Parametre;
3.3.1.1.14 Attributs
private JPanel pnl = new JPanel();
private JPanel pnlParametre = new JPanel();
private JToolBar toolbar = new JToolBar();
private JButton btnOK = new JButton("");
private JButton btnAnnuler = new JButton("");
private JLabel lblEntete = new JLabel ("");
private JComboBox cboEntete = new JComboBox ();
private JLabel lblScript = new JLabel ("");
private JTextArea txtScript = new JTextArea ("");
private JLabel lblFichierOut = new JLabel("");
private JTextField txtFichierOut = new JTextField("",2);
private JButton btnParcourirOut = new JButton("");
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//Variables globales
private JFrame fPrincipale;
private Locale currentLocale ;
private ResourceBundle messages ;
private Parametre paramAppli;
private TraiteExprReg t = new TraiteExprReg ();
private TraiteXml xml = new TraiteXml ();
private Document docScript;
private JOptionPane optSupprimeScript;
3.3.1.1.15 Constructeur
FrmScript(JFrame fParent, Parametre param, boolean bModal)
3.3.1.1.16 Méthodes
 public void actionPerformed(ActionEvent evt):
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton actionOk permtet de lancer les
commandes du script sélectionné par l’utilisateur (actionOK).
Page 35 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
 public void itemStateChanged(ActionEvent evt):
La sélection d’un script (identifiant suivant l’architecture) affiche le script
contenu dans le fichier Script.Xml.
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
 private void actionOK():
Lance l’exécution du script suivant l’option résultat dans un fichier affiche le
résultat dans l’écran FrmResultat ou pas. Un message demande à l’utilisateur s’il
souhaite supprimer le script après exécution.
 private void actionSupprime (int iPosParametre, int iIdStructure):
Supprime le script dans le fichier script.xml.
 private void initialiseListe ():
Initialise la liste des structures à partir du fichier XML Script.xml.
 private int getEntete ():
Récupère l’entête des commandes par rapport à l’architecture des données.
3.3.1.1.17 Classe FrmSynchro
C’est une classe qui charge l’écran de navigation.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
// Pour que javadoc puisse générer les liens sur la doc de ces classes
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JToolBar;
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
et classe développé pour WICALE package fr.imag.clips
Page 36 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.util.TraiteExprReg;
import fr.imag.clips.wicale.serveur.ServeurLinguistique;
3.3.1.1.18 Attributs
private JPanel pnl = new JPanel();
private JTabbedPane tabPnl = new JTabbedPane(JTabbedPane.LEFT);
private JPanel pnlOnglet1 = new JPanel();
private JPanel pnlOnglet2 = new JPanel();
private JPanel pnlParametre = new JPanel();
private JToolBar toolbar = new JToolBar();
private JButton btnReception = new JButton("");
private JButton btnEmission = new JButton("");
private JButton btnEdition = new JButton("");
private JButton btnAnnuler = new JButton("");
private JLabel lblBarreEtat = new JLabel ("");
private JTextArea txtTexte = new JTextArea("");
private JScrollPane scrollTextArea ;
private JLabel lblComposant = new JLabel();
private JComboBox cboComposant = new JComboBox ();
private JLabel tabLabel[] = new JLabel [0];
private JComboBox tabComboBox [] = new JComboBox [0];
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//Variables globales
private JFrame fPrincipale;
private Locale currentLocale ;
private ResourceBundle messages ;
private Parametre paramAppli;
private TraiteExprReg t = new TraiteExprReg();
private TraiteXml xml = new TraiteXml();
private
String[]
tabMotCle
=
{"id","data",
"libelle_data","niveau","mise_a_jour","param_id","suiv", "nom_fichier"};
private int iID=0, iDATA = 1, iLIBELLE_DATA = 2, iNIVEAU = 3, iMAJ = 4,
iPARAM_ID = 5, iSUIV=6, iNOM_FICHIER=7;
private String[] [] tabStructure = new String[0] [0];
private
String[]
tabMotCleCdeSynchro
=
{"mot_cle","num_param","expression","separateur"};
private int iMOTCLE=0, iNUMPARAM = 1, iEXPRESSION = 2,
iSEPARATEUR = 3;
private String[] [] tabCdeSynchro = new String[0] [0];
private String[] tabMotCleNomModule= {"num_param","expression"};
Page 37 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
private String sIdSelectionne= "";
private int iIdComposant = 0;//Sélectionner un composant
private String[] tabParametre = new String [0];
3.3.1.1.19 Constructeur
FrmSynchro(JFrame fParent, Parametre param, boolean bModal)
3.3.1.1.20 Méthodes
 public void actionPerformed(ActionEvent evt):
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton Edition permte de lancer la commande de
visualisation du contenu du composant. Le contenu est affiché dans l’onglet
Composannt. Le bouton Réception permet de récupérer le composant en
locale et de l’enregistrer dans le répertoire DATA puis l’arborescence
suivant l’architecture des données. Le bouton Emission récupère le contenu
du composant (fichier dans le répertoire DATA puis l’arborescence suivant
l’architecture des données) et met à jour le composant sur le serveur.
 public void selectionComboBox (ActionEvent evt):
Sélectionne d’un composant dans la liste des composants et met à jour les
paramètres à mettre à jour
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
 private void actionReception ():
Lance la commande pour réceptionner un composant et l’enregistre dans un
fichier xml en local \DATA.
 private void actionEmission():
Lance la commande pour mettre à jour un composant sur le serveur.
 private void actionEdition ():
Lance la commande qui permet de visualiser le composant dans l’onglet
Composant.
 private void initialiseListe(int iPosParametre, int iIdStructure):
Initialise les listes suivant l’arborecence des données.
 private void initialiseListeComposant ():
Initialise les listes des compsants.
Page 38 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
 private int getIdComposant():
Retourne l’identifiant du composant sélectionné.
 private String getContenuModule(Document docSynchro):
Retourne le contenu d’un composant (recherche dans un fichier .XML répertoire
\DATA.
 private String [] getParam(Document docSynchro):
Retourne les paramètres de la commande.
3.3.1.1.21 Classe FrmParametre
C’est une classe qui charge l’écran de paramètres généraux de l’application WICALE.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.util.*;
import java.io.*;
import org.w3c.dom.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
// Pour que javadoc puisse générer les liens sur la doc de ces classes
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JButton;
import javax.swing.JToolBar;
import javax.swing.JComboBox;
import javax.swing.JTextField;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.objet.Parametre;
import fr.imag.clips.wicale.objet.serveur;
import fr.imag.clips.wicale.util.TraiteExprReg;
3.3.1.1.22 Attributs
private JPanel pnlParametre = new JPanel();
private JPanel pnl = new JPanel();
private JToolBar toolbar = new JToolBar();
private JButton btnOK = new JButton("");
private JButton btnAnnuler = new JButton("");
Page 39 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
private JLabel lblLangue = new JLabel ("");
private JComboBox cboLangue = new JComboBox ();
private JLabel lblServeur = new JLabel ("");
private JComboBox cboServeur = new JComboBox ();
private JLabel lblRepParametre = new JLabel ("");
private JTextField txtRepParametre = new JTextField ("");
private JLabel lblRepData = new JLabel ("");
private JTextField txtRepData = new JTextField ("");
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//Variables globales
private Frame fPrincipale;
private Locale currentLocale ;
private ResourceBundle messages ;
private Parametre paramAppli;
3.3.1.1.23 Constructeur
FrmParametre(JFrame fParent, Parametre param, boolean bModal)
3.3.1.1.24 Méthodes
 public void actionPerformed(ActionEvent evt):
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton ok permet d’enregistrer les paramètres
dans le fichier General.xml.
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
 private void actionOk():
Permet de mettre à jour le fichier general.xml.
 private void initialiseListe ():
Initialise la liste des langues (recherche des fichiers MessageBundles dans le
Répertoire PARAMETRE) et des serveurs.
 private void getListeLangue ():
Recherche
les
langues
disponibles
MessageBundles*.properties.
c’est
à
dire
les
fichiers
Page 40 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
3.3.1.1.25 Classe FrmResultat
C’est une classe qui charge le résultat dans JEditorPane.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.awt.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
// Pour que javadoc puisse générer les liens sur la doc de ces classes
import javax.swing.JFrame;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.Impression;
3.3.1.1.26 Attributs
private JTextArea txtResultat = new JTextArea("");
private JToolBar toolbar = new JToolBar("");
private JButton btnOuvrir = new JButton("");
private JButton btnEnregistrer = new JButton("");
private JButton btnImprimer= new JButton("");
private JButton btnFermer = new JButton("");
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//CONSTANTE
public static final String CRLF = "\r\n";
//VARIABLES GLOBALES
private Locale currentLocale;
private ResourceBundle messages;
private JFrame fPrincipale;
3.3.1.1.27 Constructeur
FrmResultat(JFrame fParent, String sTitre, String sResultat, Locale currentParent)
3.3.1.1.28 Méthodes
 public void actionPerformed(ActionEvent evt):
Page 41 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton Ouvrir permet de choisir un fichier et
d’afficher le conteu du fichier texte dans un JTextArea. Le bouton
Enregistrer enregistrer dans le fichier saisie par l’utilisateur le contenu
visible à l’écran. Le bouton Imprimer permet d’imprimer le contenu du
fichier visible à l’écran. Le bouton Fermer permet de fermer l’écran
FrmResultat.
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
 private void afficheResultat ():
Affiche le résultat dans un JTextArea.
 private void actionOuvrir():
Ouvre un fichier.
 private void actionEnregistrer ():
Enregistre le résultat dans un fichier texte.
 private void actionImprimer():
Imprime le résultat.
3.3.1.1.29 Classe FrmComposant
C’est une classe qui charge l’écran de navigation.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.awt.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
// Pour que javadoc puisse générer les liens sur la doc de ces classes
import javax.swing.JDialog;
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import java.awt.print.*;
import java.awt.print.Printable;
import java.awt.Graphics;
import org.w3c.dom.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
Page 42 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.Impression;
3.3.1.1.30 Attributs
// Composants de la fenêtre principale
private JTextArea txtResultat = new JTextArea("");
private JToolBar toolbar = new JToolBar("");
private JButton btnEnregistrer = new JButton("");
private JButton btnImprimer= new JButton("");
private JTextField txtRechercher = new JTextField("");
private JButton btnRechercher = new JButton("");
private JButton btnFermer = new JButton("");
//CURSOR
private Cursor curWait = new Cursor(Cursor.WAIT_CURSOR);
private Cursor curDefault = new Cursor(Cursor.DEFAULT_CURSOR);
//VARIABLES GLOBALES
private Locale currentLocale;
private ResourceBundle messages;
private JDialog fPrincipale;
private String sNomFichier ="";
private String sNomComposant="";
private Document docComposant;
private TraiteXml xml = new TraiteXml();
3.3.1.1.31 Constructeur
FrmComposant(JDialog fParent, String sTitre, String sFichier, Document
doc, String sNom, String sContenu, Locale currentParent)
3.3.1.1.32 Méthodes
 public void actionPerformed(ActionEvent evt):
gestion des événements sur click des boutons (action sur les boutons
précités, notamment sur le bouton Enregistrer permet d’enregistrer le
contenu du composant dans le fichier XML du répertoire DATA et
arborescence. Le bouton Imprimer permet d’imprimer le contenu du
composant. Le bouton Rechercher affiche en surbrillance le texte recherché.
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
Page 43 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
 private void afficheResultat ():
affiche le texte (contenu du compsant) dans un JTExtArea.
 private void actionRecherche():
Recherche le texte dans le JtextArea et l’affiche en surbrillance.
 private void actionEnregistre():
Enregistre le composant en locale.
 private void actionImprime():
Imprime le contenu d JtextArea.
3.3.1.1.33 Classe FrmAPropos
C’est une classe qui charge l’écran d’A propos.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.awt.*;
import java.util.*;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.Erreur;
3.3.1.1.34 Attributs
3.3.1.1.35 Constructeur
FrmAPropos(Frame frmParent, String sTitre)
3.3.1.1.36 Méthodes
 private void creeComposant():
Crée les composants.
 private void setup():
Initialise la taille et la position de l’écran.
3.3.1.1.37 Classe ThreadFichier
C’est une classe qui permet de lancer le traitement en arrière plan.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
Page 44 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
import java.util.*;
import java.net.*;
import java.awt.*;
import javax.swing.*;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.util.TraiteExprReg;
import fr.imag.clips.wicale.serveur.ServeurLinguistique;
3.3.1.1.38 Attributs
3.3.1.1.39 Constructeur
ThreadFichier (JFrame EcranMsg, Locale currentParent, String [] tabParam,
String sNomFichierIn, String sNomFichierOut)
3.3.1.1.40 Méthodes
 public void run():
3.3.2 Répertoire objet
Ce répertoire contient les classes qui permettent d’instancier les objets.






Parametre .java
Commande.java
ParametreCde.java
SyntaxeCde.java
Serveur.java
ValeurListe.java
de type Combo ou liste
//Crée les paramètres généraux
//Crée un objet Commande
// Crée un objet Paramètre de Commande
// Crée l’objet Syntaxe de commande
// Crée l’objet Serveur
// Crée l’objet Valeur des listes pour paramètre
3.3.2.1 Hiérarchie des classes
Page 45 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
3.3.2.1.1 Classe Commande
C’est une classe qui permet de créer les objets Commande.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import org.w3c.dom.*
et des packages spécifiques du laboratoire fr .Imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
3.3.2.1.2 Attributs
public int iNumeroCde;
public String sNomCde;
public String sIntituleCde;
//Constantes
public static final String[] tabSingleNode
= {"num_cde", "nom_cde",
"intitule_cde"};
public static final int iNUM_CDE=0, iNOM_CDE=1 , iINTITULE_CDE=2;
3.3.2.1.3 Constructeur
public Commande(String sLigne)
ligne = numero_commande|nom_commande|intituleCde|
3.3.2.1.4 Méthodes
 public String toString() :
Retourne la chaîne de carcatères de l’objet Commande
 public int getNumeroCde() :
Retourne l’identifiant de l’objet Commande
 public Commande[] getCommande(Document doc, String sXPath) :
Retourne la liste des commandes du document passé en paramètre
3.3.2.1.5 Classe Parametre
C’est une classe qui crée l’objet Parametre.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.lang.String;
import org.w3c.dom.*;
et des packages spécifiques du laboratoire fr .Imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
Page 46 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
3.3.2.1.6 Attributs
public String sLangue = "fr-FR";
public String sCodeLangue = "fr";
public String sCodePays = "FR";
public String sServeur = "Ariane";
public String sRepParametre = "PARAMETRE/";
public String sRepData = "DATA/";
//Constantes
public static final String sNOMFICHIER="General.xml";
public static final String[] tabSingleNode = {"LANGUE_PAR_DEFAUT",
"SERVEUR_PAR_DEFAUT", "REP_PARAMETRE", "REP_DATA"};
public static final int iLANGUE=0, iSERVEUR=1 , iREP_PARAMETRE=2,
iREP_DATA=3;
3.3.2.1.7 Constructeur
public Parametre() crée l’objet paramètre avec le contenu du fichier General.xml
3.3.2.1.8 Méthodes
 public void toString() :
Retourne une chaîne de cractère avec les informations de l’objet
3.3.2.1.9 Classe ParametreCde
Crée l’objet Paramètre de Commande.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.lang.String;
import org.w3c.dom.*;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
3.3.2.1.10 Attributs
public String sNomParametre;
public String sLibelleParametre;
public int iPositionLibelleX, iPositionLibelleY;
public int iDimensionLibelleX, iDimensionLibelleY;
public String sTypeParametre;
public String sValeurParDefault;
public int iPositionX, iPositionY;
public int iDimensionX, iDimensionY;
public ValeurListe[] tabValeurListe;
Page 47 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
3.3.2.1.11 Constructeur
public ParametreCde(String ligne, ValeurListe[] tab)
3.3.2.1.12 Méthodes
 public String toString ():
Retourne la chaîne de caractères représentant le ParametreCde
sNomParametre|sLibelleParametre
|iPositionLibelleX
|iPositionLibelleY
|iDimensionLibelleX | iDimensionLibelleY | sTypeParametre |sValeurParDefault
iPositionX | iPositionY | iDimensionX |iDimensionY |
 public String NomParametre():
Retourne l’identifiant de l’objet le nom de paramètre.
 public Parametre[] getParametre (String sFichierParam, String sXPath):
Lit dans le fichier XML, la liste des paramètres de commande
3.3.2.1.13 Classe Serveur
C’est une classe qui crée l’objet Serveur.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.*
3.3.2.1.14 Attributs
3.3.2.1.15 Constructeur
Pas de constructeur
3.3.2.1.16 Méthodes
 private String[] getListeServeur(String sRepParametre) :
Recupère la liste des serveurs disponibles. Dans le répertoire PARAMETRE
recherche tous les répertoires. Chaque répertoire correspond à un serveur
3.3.2.1.17 Classe SyntaxeCde
Crée l’objet SYNTAXE CDE.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.lang.String;
import org.w3c.dom.*;
Page 48 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
3.3.2.1.18 Attributs
public String sMotCle;
public String sNumParam;
public String sExpression;
public String sSeparateur;
public boolean bSaisieObligatoire ;
3.3.2.1.19 Constructeur
public SyntaxeCde(String ligne)
ligne :
mot_cle|num_param|expression|separateur|SaisieObligatoire|
3.3.2.1.20 Méthodes
 public String toString():
Retourne la chaîne de caractères de la syntaxe de Commande
 public String MotCle():
Retourne le mot clé du composant
 public SyntaxeCde[] getSyntaxeCde(String sFichierParam, String sXPath):
Recherche les syntaxes pour la commande (sXPAth)
3.3.2.1.21 Classe ValeurListe
Crée l’objet ValeurListe.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.lang.String;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.*
3.3.2.1.22 Attributs
public String sLibValeurListe,sValeurListe,
sInitialiseListe;
public boolean bSelectionMultiple;
public int iPosX, iPosY;
public int iDimX, iDimY;
sSeparateurSelectionMultiple,
Page 49 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
3.3.2.1.23 Constructeur
public ValeurListe(String ligne)
ligne :
LibelleValeurListe|MultipleLigne|SeparateurLigneMutilple|ValeurListe|iPosX|iPosY|i
DimX|iDimY|initialise_liste|
3.3.2.1.24 Méthodes
 public String toString():
Retourne la chaine de caractères de l’objet séparé par |.
LibelleValeurListe|MultipleLigne|SeparateurLigneMutilple|ValeurListe|iPosX|i
PosY|iDimX|iDimY|initialise_liste|
 public String NomValeurListe():
Retourne le libellé.
3.3.3 Répertoire SERVEUR
Ce répertoire contient les classes qui permettent d’instancier les écrans.




ServerLinguistique .java
ServerAriane.java
ServerPilaf.java
ServerUnl.java
//classe interface décrit les méthodes
// méthode spécifique Ariane
// méthode spécifique Pilaf
// méthode spécifique Unl
3.3.3.1 Hiérarchie des classes
Page 50 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
3.3.3.1.1 Classe ServerLinguistique
Spécifie les méthodes pour communiquer avec le serveur.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.lang.*
et des packages spécifiques du laboratoire fr .Imag.clips
import fr.imag.clips.wicale.objet.Commande;
3.3.3.1.2 Attributs
3.3.3.1.3 Constructeur
interface InterfaceServerLinguistique
{
public String getResultat(Commande cde, String [] tabParam, String
sFichierOut)
public String getResultatScript(String sEntete, String sListeCde, String
sFichierOut)
public String [] synchronisation(int iNumStructure, String [] tabParam)
3.3.3.1.4 Méthodes
3.3.3.1.5 Classe ServerAriane
C’est une classe qui décrit les méthodes de communication pour le serveur Ariane
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.net.*;
import java.util.regex.*;
//Parsing dans fichier XML
import org.w3c.dom.*;
import org.w3c.dom.traversal.*;
import org.xml.sax.SAXException;
import org.xml.sax.InputSource;
et des packages spécifiques du laboratoire fr .Imag.clips
import fr.imag.clips.wicale.util.TraiteExprReg;
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.objet.Commande;
3.3.3.1.6 Attributs
public static final String sRepXml="PARAMETRE/";
public static final String CRLF = "\r\n";
Page 51 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
public static final String sNomServeur = "Ariane";
3.3.3.1.7 Constructeur
3.3.3.1.8 Méthodes
 public String getResultat(Commande cde, String [] tabParam, String
sFichierOut):
Lance la commande par socket TCP/IP et retourne de résultat du serveur. Le
résultat est traité (fichier Commande.xml RESULTAT)
 public String String getResultatScript(String sEntete, String sListeCde, String
sFichierOut):
Lance les commandes par socket TCP/IP et retourne de résultat du serveur.
Le résultat est traité (fichier Commande.xml RESULTAT)
 public String [] synchronisation(int iNumStructure, String [] tabParam):
Lance une des commandes de synchronisation(édition, réception et émission)
3.3.3.1.9 Classe ServerPilaf
C’est une classe qui décrit les méthodes de communication avec le serveur.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.util.*;
import java.io.*;
import java.net.*;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.TraiteExprReg;
import fr.imag.clips.wicale.objet.Command;
3.3.3.1.10 Attributs
protected URL url;
protected HttpURLConnection server;
public
String
[]
"GENERER","TABLEX","TABVAR"};
public String [] tabCategorie;
public String [] tabVariable;
tabCde
=
{"ANALYSER",
//Constante
public final String CRLF = "\r\n";
public final String sNomServeur = "Pilaf";
Page 52 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
public final String sRepXml="PARAMETRE/";
3.3.3.1.11 Constructeur
Pas de constructeur
3.3.3.1.12 Méthodes
 public String getResultat(Commande cde, String [] tabParam, String
sFichierOut):
Lance la commande par socket TCP/IP et retourne de résultat du serveur. Le
résultat est traité (fichier Commande.xml RESULTAT)
 public String String getResultatScript(String sEntete, String sListeCde, String
sFichierOut):
Lance les commandes par socket TCP/IP et retourne de résultat du serveur.
Le résultat est traité (fichier Commande.xml RESULTAT)
 public String [] synchronisation(int iNumStructure, String [] tabParam):
Lance une des commandes de synchronisation(édition, réception et émission)
3.3.3.1.13 Classe ServerUnl
C’est une classe qui charge l’écran de navigation.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
et classe développé pour WICALE package fr.imag.clips
3.3.3.1.14 Attributs
3.3.3.1.15 Constructeur
3.3.3.1.16 Méthodes
 public String getResultat(Commande cde, String [] tabParam, String
sFichierOut):
Lance la commande par socket TCP/IP et retourne de résultat du serveur. Le
résultat est traité (fichier Commande.xml RESULTAT)
 public String String getResultatScript(String sEntete, String sListeCde, String
sFichierOut):
Lance les commandes par socket TCP/IP et retourne de résultat du serveur.
Le résultat est traité (fichier Commande.xml RESULTAT)
Page 53 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
 public String [] synchronisation(int iNumStructure, String [] tabParam):
Lance une des commandes de synchronisation(édition, réception et émission)
3.3.4 Répertoire Util
Ce répertoire contient les classes qui permettent d’instancier les écrans.





Constante.java
Impression.java
ExprReg.java
Xml.java
Erreur.java
//définie toutes les constantes de l’application
// permet d’imprimer un texte
// traite les expressions régulières
// traitement des fichiers XML
// traite les erreurs
3.3.4.1 Hiérarchie des classes
Page 54 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
3.3.4.1.1 Classe Constante
Définit les constantes pour l’application WICALE.
Héritage :
Aucun héritage
3.3.4.1.2 Attributs
public final String CRLF ="\r\n";
public final String sFICHIER_LANGUE = "MessagesBundle_";
public final String sEXT_LANGUE = ".properties";
3.3.4.1.3 Constructeur
Pas de constructeur
3.3.4.1.4 Méthodes
Pas de méthode
3.3.4.1.5 Classe Impression
C’est une classe qui contient les méthodes pour imprimer un texte.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.*;
import javax.swing.*;
import java.awt.print.*;
et des packages spécifiques du laboratoire fr .Imag.clips
3.3.4.1.6 Attributs
private Component componentToBePrinted;
3.3.4.1.7 Constructeur
Impression(Component componentToBePrinted)
3.3.4.1.8 Méthodes
 public void print () :
Imprime le composant.
3.3.4.1.9 Classe ExprReg
Page 55 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
C’est une classe qui contient les méthodes pour traiter les expressions régulières d’un texte.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.net.*;
import java.util.regex.*;
import org.xml.sax.*;
//save
import java.util.Properties;
import org.w3c.dom.*;
import org.w3c.dom.traversal.*;
import org.xml.sax.SAXException;
import org.xml.sax.InputSource;
// Imported JAVA API for XML Parsing 1.0 classes,
// Xerces implementation and XPath API
//simport org.apache.xerces.parsers.DOMParser;
import org.apache.xpath.XPathAPI;
import org.apache.xml.utils.TreeWalker;
import org.apache.xml.utils.DOMBuilder;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.stream.*;
import javax.xml.transform.dom.*;
import java.util.Enumeration;
et classe développé pour WICALE package fr.imag.clips
import fr.imag.clips.wicale.util.TraiteXml;
import fr.imag.clips.wicale.util.TraiteExprReg;
3.3.4.1.10 Attributs
3.3.4.1.11 Constructeur
3.3.4.1.12 Méthodes
 public boolean verifie(String sTraitementOK, String sChaine):
Vérifie si la chaîne de caractères sTraitementOK est contenu dans sChaine.
 public boolean find(String sExprDeb, String sExprCorps, String sExprFin,

String sChaine, String sSeparateur)):
Recherche la chaîne de caractères par rapport à l’expression régulières
passés en paramètres.
.
 public String [] split(String sExpr, String sChaine):
retourne un tableau avec les chaines de caractères.
Page 56 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
 private void String replace(String sExpr, String sChaineReplace, String
sChaine):
Remplace la chaine.
 public String traiteResultat(String sFichierParam, int iCde, String sChaine) ():
Traite le fichier Résultat Recherche toutes les étapes de traitement du résultat.
Chaque étape appelle l’une des méthodes replace, split, ou find et itère avec l’étape
suivante. Le résultat de l’étape n est l’entrée de l’étape n+1
 private void lireFichier(): ASUPPRIMER package Util.fichier
 public String[] traiteModule ():
Traite le fichier Résultat Recherche toutes les étapes de traitement du résultat.
Chaque étape appelle l’une des méthodes replace, split, ou find et itère avec l’étape
suivante. Le résultat de l’étape n est l’entrée de l’étape n+1
3.3.4.1.13 Classe Xml
C’est une classe qui contient les méthodes de traitements des fichiers XML.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.io.*;
import java.util.Properties;
import org.w3c.dom.*;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import org.w3c.dom.traversal.*;
import org.xml.sax.SAXException;
import org.xml.sax.InputSource;
// Imported JAVA API for XML Parsing 1.0 classes,
import org.apache.xpath.XPathAPI;
import org.apache.xml.utils.TreeWalker;
import org.apache.xml.utils.DOMBuilder;
import javax.xml.parsers.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
// Imported Serializer classes
import javax.xml.transform.stream.*;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.dom.DOMSource;
Page 57 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
import javax.xml.transform.stream.StreamResult;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;;
3.3.4.1.14 Attributs
3.3.4.1.15 Constructeur
Pas de constructeur
3.3.4.1.16 Méthodes
 public Document initialiseDoc(String sNomFichier):
initialise le fichier XML dans un Document
 public String [] [] findDoc(Document doc, String xpath, String[]
tabSingleNode) :
Retourne un tableau avec le contenu des attributs.
 public Document updateDocModule(Element racine, Document doc, String
xpath, String [] tabNewValue) :
Met à jour le module.
 public Document updateDocListe(Element racine, Document doc, String xpath,
String [] tabNewValue):
 public Document supprimeAllChild(Document doc, String xpath) :
Supprime les nœuds dans le document
 public Document updateDocScript(Element racine, Document doc, String
xpath, String [] tabNewValue) :
 public String findValeur(Document doc, String xpath) :
Retrouve la valeur pour le premier attribut
 public String findAttribut(Document doc, String xpath) :
Retrouve la valeur pour le premier attribut
 public String sauveFichier(Document doc, String sCodeFichier, String
sFichierOut) :
Enregistre ou crée le fichier XML
 public String[] chargeListe(Document doc, String sServeur, String sXPath) :
Lit le fichier des listes Liste.XML
3.3.4.1.17 Classe Fichier
Page 58 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
C’est une classe qui contient les méthodes de traitement des fichiers.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.awt.event.*;
import java.io.*;
import java.util.*;
et classe développé pour WICALE package fr.imag.clips
3.3.4.1.18 Attributs
3.3.4.1.19 Constructeur
Pas de constructeur
3.3.4.1.20 Méthodes
 public boolean existeFichier(String sNomFichier):
Retourne tru si le fichier existe sinon false.
 public String sFichier(String sNomFichier):
Retourne le contenu du fichier texte
3.3.4.1.21 Classe Erreur
C’est une classe qui contient les méthodes de traitement des erreurs.
Héritage : Cette classe hérite des classes de la bibliothèque de Sun.
import java.util.*
et classe développé pour WICALE package fr.imag.clips
3.3.4.1.22 Attributs
3.3.4.1.23 Constructeur
Pas de constructeur
3.3.4.1.24 Méthodes
 public EnregistreErreur (String sNomFichier, int iErreur, String sMessage,
String sClass, String sMethode):
Page 59 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
Enregistre le message d’erreur dans le fichier .LOG dans le répertoire définit
par l’utlisateur dans l’écran de paramétrage.
Si le fichier ne peut pas être crée System.out.println
Page 60 sur 65
Laboratoire CLIPS - IMAG
3.4
Description des données
3.5
Les fichiers XML
840900634
version 1.0
Les DTD de chaque fichier XML au format UTF-8.
3.5.1 Fichier Paramètre General.xml
LeFichier General.xml contient les paramètres par défaut de l’application. Il se trouve dans le
répertoire IHM
<PARAMETRES>
<LANGUE_PAR_DEFAUT>fr_FR</LANGUE_PAR_DEFAUT>
<SERVEUR_PAR_DEFAUT>Ariane</SERVEUR_PAR_DEFAUT>
<REP_PARAMETRE>c:\Appli\Wicale\PARAMETRE\</REP_PARAMETRE>
<REP_DATA>c:\Appli\Wicale\DATA\</REP_DATA>
<FICHIER_LOG>c:\Appli\Wicale\DATA\</FICHIER_LOG>
</PARAMETRES>
3.5.2 Fichier Paramètre Commande.xml
LeFichier Commande.xml contient les informations de toutes les commandes du serveur. Le
fichier
se
trouve
dans
le
répertoire
des
paramètres
\PARAMETRE\NomServeur\Commande.xml
La commande 0 permet de définir les paramètres et la syntaxe de toutes les commandes. Par
exemple pour le serveur Ariane, l’utilisateur doit saisie le nom de la machine et du disque
pour lancer une commande.
Les numéros de commande commence par 1 et doivent se suivre.
<LST_COMMANDE>
<GPE_COMMANDE nom_groupe="Les actions et interrogations globales">
<nom_groupe>Les actions et interrogations globales</nom_groupe>
<type_groupe>GENERAL</type_groupe>
<COMMANDE num_cde="0">
<num_cde>0</num_cde>
<nom_cde>GENERAL</nom_cde>
<intitule_cde></intitule_cde>
<PARAMETRE_SAISIE>
<PARAMETRE>
<nom_param>Machine</nom_param>
<libelle_param>LBL_MACHINE</libelle_param>
<pos_lib_X>10</pos_lib_X><pos_lib_Y>40</pos_lib_Y>
<dim_lib_X>100</dim_lib_X><dim_lib_Y>20</dim_lib_Y>
<type_param>ComboBox</type_param>
<valeur_def_param>CARPENA</valeur_def_param>
<pos_X>20</pos_X><pos_Y>60</pos_Y>
<dim_X>160</dim_X><dim_Y>20</dim_Y>
<VALEUR_LISTE>
<libelle_liste>LISTE_MACHINE</libelle_liste>
<multiligne>false</multiligne>
<sep_multiligne></sep_multiligne>
<valeur_liste>MACHINE</valeur_liste>
<pos_X>20</pos_X><pos_Y>60</pos_Y>
<dim_X>160</dim_X><dim_Y>20</dim_Y>
<initialise_liste></initialise_liste>
</VALEUR_LISTE>
</PARAMETRE>
…
</PARAMETRE_SAISIE>
Page 61 sur 65
Laboratoire CLIPS - IMAG
840900634
version 1.0
<SYNTAXE>
<ETAPE>
<mot_cle>MACHINE = </mot_cle>
<num_param>0</num_param>
<expression>.*</expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
</ETAPE>
<ETAPE>
<mot_cle>DISQUE = </mot_cle>
<num_param>1</num_param>
<expression>.*</expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
</ETAPE>
…
</SYNTAXE>
</COMMANDE>
<COMMANDE num_cde="1">
<num_cde>1</num_cde>
<nom_cde>LISNOMCORP</nom_cde>
<intitule_cde>Liste des noms de corpus</intitule_cde>
<PARAMETRE_SAISIE>
</PARAMETRE_SAISIE>
<SYNTAXE>
<ETAPE>
<mot_cle>TRAIT = LISNOMCORP (*) </mot_cle>
<num_param></num_param>
<expression></expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>false</saisie_obligatoire>
</ETAPE>
</SYNTAXE>
<RESULTAT>
<resultat_OK>-> Tout est O.K.</resultat_OK>
<resultat_type>-> Tout est O.K.</resultat_type>
<ETAPE>
<nom_methode>find</nom_methode>
<expr_deb>Liste des noms de corpus</expr_deb>
<expr_corps>[A-Za-z0-9.,?!\()\*\/\s\r\n&caract_sub;&caract_accent;:=_$:+]*</expr_corps>
<expr_fin>-LISTE TERMINEE-</expr_fin>
<expr_concat>&retour_chariot;</expr_concat>
<expr_remplacement></expr_remplacement>
</ETAPE>
…
3.5.3 Fichier Paramètre Architecture.xml
Liste de tous les composants
<ARCHITECTURE>
<STRUCTURE id="0">
<id>0</id>
<niveau>1</niveau>
<data>MACHINE</data>
<libelle_data>LBL_MACHINE</libelle_data>
<mise_a_jour>M</mise_a_jour><!--manuelle-->
<param_id></param_id>
<suiv>1</suiv>
<nom_fichier>Liste.xml</nom_fichier>
<valeur_tous></valeur_tous>
<valeur_def>CARPENA</valeur_def>
<expression>.*</expression>
</STRUCTURE>
<STRUCTURE id="1">
<id>1</id>
<niveau>2</niveau>
<data>DISQUE</data>
<libelle_data>LBL_DISQUE</libelle_data>
<mise_a_jour>M</mise_a_jour><!--manuelle-->
<param_id>0</param_id>
<suiv>2;3;6</suiv>
<nom_fichier>Liste.xml</nom_fichier>
<valeur_tous></valeur_tous>
Page 62 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
<valeur_def>191</valeur_def>
<expression>.*</expression>
</STRUCTURE>
3.5.4 Fichier Paramètre Emission.xml
Pour chaque composant, si le serveur permet emmettre le composant alors il faut définir la
syntaxe de la commande d’émission et de récupération du résultat
<LST_STRUCTURE>
<STRUCTURE id="4"><!--toutes les Chaine-->
<SYNTAXE>
<ETAPE>
<mot_cle>MACHINE=</mot_cle>
<num_param>0</num_param>
<expression>.*</expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
</ETAPE>
<ETAPE>
<mot_cle>DISQUE = </mot_cle>
<num_param>1</num_param>
<expression>.*</expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
</ETAPE>
…
</SYNTAXE>
<RESULTAT>
<NOM>
<num_param>4</num_param>
<expression>.*-</expression>
</NOM>
<CONTENU>
<resultat_OK>-> Tout est O.K.</resultat_OK>
<expr_split></expr_split>
<ETAPE>
<nom_methode>find</nom_methode>
<expr_deb>[\*]
CHAINE
LGS
LGC
[\!][\s]*NUMERO[(]S[)]
DATE[\s]*[\*]</expr_deb>
<expr_corps>[A-Za-z0-9()&caract_sub;\*\/\s\w\r\n\!]*</expr_corps>
<expr_fin>[\*]*</expr_fin>
<expr_concat>\r\n</expr_concat>
<expr_remplacement></expr_remplacement>
</ETAPE>
<ETAPE>
<nom_methode>find</nom_methode>
<expr_deb></expr_deb>
<expr_corps>[\s][0-9]{2}[\s]*[(][0-9]{2}\/[0-9]{2}\/[0-9]{2}[)]</expr_corps>
<expr_fin></expr_fin>
<expr_concat>\r\n</expr_concat>
<expr_remplacement></expr_remplacement>
</ETAPE>
…
</CONTENU>
</RESULTAT>
</STRUCTURE>
3.5.5 Fichier Paramètre Reception.xml
Pour chaque composant, si le serveur permet de réceptionner le composant alors il faut définir
la syntaxe de la commande de réception.
<LST_STRUCTURE>
<STRUCTURE id="2"><!--toutes les langues disponibles-->
<SYNTAXE>
<ETAPE>
<mot_cle>MACHINE=</mot_cle>
<num_param>0</num_param>
<expression>.*</expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
Page 63 sur 65
Laboratoire CLIPS - IMAG
version 1.0
840900634
</ETAPE>
<ETAPE>
<mot_cle>DISQUE = </mot_cle>
<num_param>1</num_param>
<expression>.*</expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
</ETAPE>
<ETAPE>
<mot_cle>LGS = *</mot_cle>
<num_param></num_param>
<expression></expression>
<separateur>&retour_chariot;</separateur>
<saisie_obligatoire>true</saisie_obligatoire>
</ETAPE>
…
</SYNTAXE>
</STRUCTURE>
3.6 L’internationalisation
Dans le répertoire des paramètres, on définit un fichier par langue. Le fichier se nomme
« MessagesBundle », le code langue, « _ » le code pays et l’extension .properties.
Ce fichier contient un mot clé et la valeur dans le langue.
LBL_TITRE=Pilote de serveurs linguistiques
LBL_TITRE_SYNCHRO=Synchronisation des composants
LBL_TITRE_NAVIGATION=Consultation des composants en local
LBL_SERVEUR=Serveur
LBL_LANGUE_APPLI=Langue
LBL_REPERTOIRE_PARAMETRE=Répertoire des paramètres
LBL_REPERTOIRE_DATA=Répertoire des données
LBL_PARAMETRE_GENERAL=Paramètres de WICALE
LBL_TABLE= Table…
Java permet de définir une variable Locale avec le paramètre code pays et code langue
Locale currentLocale = new Locale(CODE_FR, PAYS_FR) et une variable ResourceBundle
messages qui permet de rechercher le libellé dans le bon fichier.
//Initialisation des variables
Locale currentLocale = new Locale(sCodeLangue,sCodePays);
messages = ResourceBundle.getBundle(sRepParametre +
currentLocale);
//Lecture du libellés
messages.getString("LBL_PARAMETRE_GENERAL")
"/"+
"MessagesBundle"),
Dans ce chapitre, nous allons apprendre à écrire un programme Java qui puisse – être
indépendant d'une quelconque langue et d'un quelconque pays – intégrer une nouvelle
langue sans nécessiter de re-compilation – présenter certains éléments (monnaies,
dates, …) dans un format quelconque. Pour ce faire, nous allons utiliser des classes
disséminées dans différents packages (java.util, java.text, ...).
Pour mieux comprendre les choses, regardons ce petit programme de plus près.
Analysez-le et dites en quoi on pourrait améliorer ce programme.
Page 64 sur 65
Laboratoire CLIPS - IMAG
3.7
840900634
version 1.0
Séparation Code/Textes
Une des phases essentielles de l'internationalisation d'une application est de séparer le
code des textes affichés dans le programme. Si les textes sont noyés dans le
programme, il faudra modifier le code pour fournir l'application dans un nouveau
langage. Si, au contraire, les deux choses sont séparées, on pourra toucher le code
indépendamment des textes et réciproquement.
Au niveau de Java, les choses sont relativement simples. En effet, le package java.util
propose un certain nombre de classes prévues à cet effet, et notamment les classes
Locale et ResourceBundle.

Locale : cette classe permet de définir un objet de définition de la langue
et du pays pris en compte. On peut obtenir un objet Locale par défaut en
saisissant Locale.getDefault();

ResourceBundle : cette classe permet de gérer un paquet (bundle) de
messages pour une localisation (un objet Locale) donnée.
Pour mieux comprendre tout cela, regardons de plus près le programme suivant.
Notez que dans la fonction main, on choisit (pour le moment) une localisation bien
déterminée. Mais on ne voit quasiment plus aucune chaîne de caractères (en tant que
telle) dans le reste du programme.
La question que vous vous posez certainement est de savoir où le programme va
chercher les chaînes de caractères en question ? En fait, tout est dit dans ce programme,
il va les chercher dans des fichiers commençant par "RTVACalculator" (ATTENTION : ce
préfixe ne doit pas correspondre à un nom de vos fichiers de code, sans quoi cela génère
une erreur). Selon la localisation, la langue et le pays sont concaténés au préfixe ce qui
donne le nom du fichier à localiser. Si ce fichier n'existe pas, un fichier par défaut est
utilisé.
Page 65 sur 65