JBUILDER 7: Introduction à l'utilisation de JTree

Olivier Constans

L'objet de ce nouveau tutoriel est multiple. En effet, le sujet principal est l'utilisation d'un arbre grâce à  la classe JTree, mais comme nous allons étudier son utilisation associée à une mini base de données, nous en profiterons donc aussi pour faire connaissance avec interbase.

Attention, pour profiter pleinement de ce tutoriel et du fait de l'utilisation de composants base de donnée , il faut disposer d'une version Jbuilder professionnelle ou entreprise ainsi que d'interbase et de son driver Jdbc.

- Titre : JBUILDER 7: Introduction à l'utilisation de JTree

- Auteur : Olivier Constans

- Parution : 1 octobre 2002

- Mise à jour : 4 janvier 2013

- Licence : Copyright ® 2002 Olivier Constans. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. La base de données :

- I-A. Construction de la base de données :

- I-B. Construction des tables

- II. Le programme en JAVA

- II-A. Les classes :

- II-B. Construction du projet :

- III. JTREE

- III-A. Qu'est ce qu'un arbre ?

- III-B. Comment construit on un arbre ?

I - La base de données :

Cette base est relativement simple. Elle a pour objet de fournir le support nécessaire à l'illustration d'une arborescence. La meilleure façon pour cela est de modéliser un livre constitué de parties , chapitres et de lignes de textes . Notre arbre en sera en quelque sorte la table des matières.

I-A - Construction de la base de données :

Pour cela nous allons utiliser Interbase 6.5.

Nous commençons par créer un répertoire , dans cet exemple il s'appellera DataBase . Puis nous ouvrons IBConsole , nous nous connectons au serveur local,  puis dans le menu Database nous choisissons Create Database . La fenêtre suivante apparaît et nous allons y préciser l'emplacement et le fichier .gdb à créer ainsi que la taille de la base de donnée et son alias:

Après avoir validé par OK, notre base est créée, il ne reste plus qu'à y inscrire des utilisateurs et à y créer nos tables, et bien sûr à les remplir de données.

I-B - Construction des tables

Pour cela, nous allons maintenant ouvrir le programme pilote de base de donnée à partir du menu outil de JBUILDER7.

Tout d'abord, nous allons ajouter créer un URL vers notre toute nouvelle base de donnée en sélectionnant URL base de donnée et l'option Nouveau du menu fichier. Dans la fenêtre suivante, nous allons associer le pilote interbase au chemin d'accès de notre base de donnée :

Après validation, notre base de donnée est ajoutée à la liste des URL .

Nous allons maintenant pouvoir créer les tables de notre base de donnée avec l'option Créer une table du menu fichier.

Puis nous y mettrons quelques données grâce l'outil interactive SQL auquel nous accédons par IBConsole…

II - Le programme en JAVA

Ce dernier sera très simple. En effet, si nous voulons apprendre un point particulier, ici manipuler un JTREE, il faut savoir se consacrer à l'essentiel.

Donc, nous afficherons , après l'avoir initialisé notre arbre dans une fenêtre et  un bouton nous permettra de quitter l'application.

II-A - Les classes :

Ce programme utilisera 3 classes :

- AppTreeTuto, la classe principale de l'application

- CadreTreeTuto, le cadre qui contient notre jtree

- Dm, Un module de donnée qui regroupe nos accès à la base de donnée.

II-B - Construction du projet :

Dans Jbuilder, nous créerons un nouveau projet grâce à l'expert .

Une fois ce dernier créé, nous ajoutons une nouvelle classe de type module de donnée :

Nous ouvrons maintenant notre classe Dm et nous sélectionnons le concepteur.

A quoi sert cette classe module de données, et bien simplement à regrouper en un seul endroit les composants base de donnée utilisés par notre application.

Grâce au concepteur, nous allons choisir le composant Jdatabase dans l'onglet DataExpress de la barre de composant.

Une fois ce dernier ajouté à notre classe, nous allons lui donner les propriétés pour le lier à notre petite base de donnée d'exemple.

et tout particulièrement voici la configuration de la propriété connexion qui se configure d'une façon très simple grâce à  la puissance de JBuilder :

L'URL doit indiquer notre base de donnée Interbase JTUTO.GDB .

Le mot de passe est ici ‘eleve' . Si nous souhaitons qu'il soit demandé à chaque fois que le programme sera exécuté , il faudra cocher la case ‘Demander le mot de passe'.

Un petit test de la connexion nous permet de voir que tout est ok.

Simultanément , Jbuilder génère le code java correspondant .

Maintenant, nous allons ajouter le ou les accès aux tables de notre application.

Nous réaliserons cela en ajoutant à Dm des composants QueryDataSet qui nous permettons d'accéder à nos tables grâce à SQL

Là encore, Jbuilder nous apporte l'aide de ses puissants experts pour configurer notre composant et dans notre cas notamment la requête SQL de la propriété query :

Nous ajouterons donc dans la classe Dm tous les accès aux tables de notre base de données.

Passons maintenant à l'application.

Nous ajoutons au projet 2 nouvelles classes en choisissant l'expert Application. Je passerai sur les détails car je suppose que créer une application avec jbuilder vous est déjà connu.

Dans la classe du cadre, nous ouvrirons le concepteur et nous ajouterons un JscrollPane et  Jtree à notre panel et le bouton pour quitter le programme.

III - JTREE

Bien passons maintenant au vif du sujet, l'arbre et son utilisation .

III-A - Qu'est ce qu'un arbre ?

C'est une structure de donnée particulière qui possède un point de départ, la racine , des branches et des feuilles.

Ce qui tient lieu de racine, de branches ou de feuilles sont des instances de l'objet DefaultMutableTreeNode.

Rattacher ces objets entre eux constitue l'arbre. Le nœud de départ qui n'a pas de parent est la racine, une nœud peut être rattaché à un ou plusieurs autres nœud, les branches et enfin, un nœud sans enfant est une feuille.

III-B - Comment construit on un arbre ?

Supposons que nous souhaitions représenter l'arborescence suivante :

Départ
|
-Branche1
|           |
|           -F1
|           -F2
|
-Branche2
|
-F3

Tout d'abord, on crée  une instance de Jtree

JTree jTree1 = new JTree();

Puis , il nous faut la racine

DefaultMutableTreeNode root = new DefaultMutableTreeNode("Départ");

On construit les branches que l'on prévoie

DefaultMutableTreeNode Branche1 = new DefaultMutableTreeNode("B1");

On ajoute nos feuille à la branche,

Branche1.Add(new DefaultMutableTreeNode("F1"))
Branche1.Add(new DefaultMutableTreeNode("F2"))

Puis notre branche à la racine

root.Add(Branche1)

Passons à la branche numéro 2

DefaultMutableTreeNode Branche2 = new DefaultMutableTreeNode("B2");
Branche2.Add(new DefaultMutableTreeNode("F1"))
root.Add(Branche2)

A ce moment précis, nous avons liés entre eux une serie de noeuds d'arbre constituée d'un point de départ, de branches et de feuilles.

Il nous faut maintenant l'associer à notre objet Jtree qui lui se chargera de mettre en œuvre les méthodes nécessaires  à l'affichage , la navigation et autre aspect graphique et intéractif.

Pour cela, il nous faut une instance d'un objet modèle d'arbre auquel nous passerons en paramètre du constructeur notre liste de nœud liés entre eux qui constitue notre arborescence.

model = new DefaultTreeModel(root);

sur lequel notre Jtree s'appuira ensuite.

jTree1.setModel(model);

Entre parenthèses, vous remarquerez ici que notre objet Jtree s'appuie sur un modèle d'arbre et que nous avons ici utilisé une instance de l'objet DefaultTreeModel . Il va sans dire que si vous avez besoin d'un arbre qui possède un comportement particulier, vous pouvez tout à fait vous créer votre propre modèle d'arbre et y programmer le comportement souhaité (tout comme pour les tables et leur modèles de table cf tutoriel modèle de table).

Maintenant que vous avez un peu compris le principe de la construction d'un arbre, étudions celui qui fait l'objet de ce tutoriel…

Tout à lieu dans la méthode treeLoad().

Détaillons la un peu :

- Notre arbre ici doit représenter un livre composé de parties, chacune étant elle même une suite de chapitres dans lesquels on trouve du texte.

- Chacune de ces parties constituera une branche dans notre arborescence et ces branches seront classées hiérarchiquement dans l'ordre

Livre contient Partie
qui contient Chapitre
qui contient Texte.

- Le livre est stocké dans une table et pour pouvoir charger notre arbre, il faut lire cette table dans le bon ordre.

C'est le rôle du QueryDataSet et de la requête SQL que nous avons vu plus haut.

Cela correspond au code suivant :

void treeLoad()
{
DefaultMutableTreeNode root = new DefaultMutableTreeNode("livre");
DefaultMutableTreeNode chap = null;
DefaultMutableTreeNode part = null;
DefaultMutableTreeNode text =null;

DmTuto.getQdsLivre().open();

Pour remplir notre arbre, nous allons lire notre table et surveiller les changements de chapitres et de parties  (ce que l'on appelle les ruptures de contrôle) .

Quand il n'y a pas de rupture , on remplie la branche en cours avec le texte, quand il y a rupture , on remplie la branche du niveau supérieur  avec la branche actuelle terminée et on commence la nouvelle branche…

Cela est réalisé dans la boucle suivante. Les variables p et c contiennent la partie et  chapitre que l'on lit dans la table et sp et sc contiennent les sauvegardes des valeurs précédentes des parties et chapitres. Ces 4 variables servent à déterminer quant il y a rupture (dès que c <> sc ou p <> sp)

int c =0;
int p =0;
int sc =0 ;
int sp = 0 ;
while ( DmTuto.getQdsLivre().next()) // Tant que la derniere ligne du querydataset n'est pas atteinte, lire la ligne suivante
{
c= DmTuto.getQdsLivre().getInt("CHAPITRE");// lecture du numéro de chapitre
p= DmTuto.getQdsLivre().getInt("PARTIE");// lecture du numéro de partie
text = new DefaultMutableTreeNode(DmTuto.getQdsLivre().getString("TEXTE"));// lecture du texte

if (p==sp)
{
if (c==sc)
{// Cas normal, pas de rupture
chap.add(text);// ajouter le texte au chapitre en cours
}else// ruture sur le chapitre
{
chap = new DefaultMutableTreeNode(new Integer(c));// Créer u nouveau chapitre
chap.add(text);// y stocker le texte lu
part.add(chap);// Ajouter ce chapitre à la partie
sc=c; // mémoriser le nouveau chapitre
}
}else// ruture sur la partie
{
chap = new DefaultMutableTreeNode(new Integer(c));// créer un nouveau chapitre
part = new DefaultMutableTreeNode(new Integer(p));// créer une nouvelle partie
chap.add(text);// ajouter le texte à notre nouveau chapitre
part.add(chap);//ajouter notre nouveau chapitre à notre nouvelle partie
root.add(part);// et ajouter cette nouvelle partie à notre arbre (à sa racine)
sc=c;// mémoriser le nouveau chapitre
sp=p;// mémoriser la nouvelle partie
}

}

Enfin, une fois notre arborescence chargée, il ne reste plus qu'à fermer la table et construire notre arbre

DmTuto.getQdsLivre().close();// fermer la table
// finaliser notre arbre maintenant qu'il à un contenu....
model = new DefaultTreeModel(root);

jTree1.setModel(model);

}

Pour ce qui est du reste, je vous laisse jeter un œil dans le programme qui reste du Jbuilder classique et aussi le soin d'ajouter le code pour aller chercher dans les tables Partie et Chapitre les intitulés de ces derniers afin de les afficher au bons endroits dans l'arbre….

Pour télécharger les sources et la base de donnée de ce tutoriel : ICI