JBUILDER 7: Introduction à l'utilisation de JTree

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.

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…

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.

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.

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.

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