:: Enseignements :: Master :: M1 :: 2014-2015 :: Design Pattern ::

TP noté de POO - Design Patterns

Ce TP noté dure 4h.

Exercice 1 - Visualisation

On souhaite reprendre un programme permettant de visualiser une serie de valeurs sous forme graphique pour l'améliorer et ajouter différentes visualisations.
Le code déjà existant est disponible sous forme de 4 classes. La classe ControlPanel.java correspond à la partie graphique qui affiche une zone de dessin et une zone de saisie des valeurs en dessous. La classe CanvasArea.java et sa petite soeur la classe Brush.java permet de dessiner dans la zone graphique. La classe Main.java qui lors d'une modification d'une valeur redessine la visualisation correspondante.
Vous pouvez tester le code en l'exécutant et vérifier que si l'on change une valeur du tableau, le changement est bien répercuté sur la partie graphique.

On peut noter dans un premier temps que le code n'est pas très propre en terme de dépendance car la classe ControlPanel possède une dépendance directe sur la classe Main ce qui empêche la classe ControlPanel d'être ré-utilisable pour un autre projet.
On souhaite fermer la classe ControlPanel en la rendant non dépendante de la classe Main.
Comment doit on faire ?
Faite les changements qui s'imposent et vérifiez que vous avez bien répondu au problème en déplacant la classe Main dans le paquetage par défaut (directement dans src) tout en laissant les autres classes dans le paquetage control.
Note 1: le code de ControlPanel peut faire peur surtout que vous n'avez pas encore fait d'interface graphique, le but n'est pas de perdre du temps à essayer de le comprendre mais juste de corriger le problème.
Note 2: vous ne devriez plus avoir de champs static dans le Main non plus !
On souhaite maintenant avoir deux visualisations possibles, la visualisation avec les carrés rouges qui est celle qui existe déjà et une visualisation qui dessine en bleu des lignes brisées reliant les différents points.
Le choix de la visualisation doit se faire en fonction de l'argument passé sur la ligne de commande. Si l'argument est square, alors la visualisation doit être sous forme de carrés rouges, si l'argument est line, alors la visualisation doit être sous forme d'une ligne bleue.
En terme de design, on vous demande de prévoir qu'il n'y ait pas seulement deux visualisation possibles mais un nombre indéterminé de visualisation et que le code de chaque visualisation soit séparé.
Dessinez sur une feuille vierge (qui sera ramassée à la fin du TP noté) le diagramme de classes UML du design que vous proposez pour permettre de choisir la visualisation.
Modifiez votre code en conséquence en introduisant un nouveau paquetage visualize en plus du paquetage control.
Note: la classe Main reste dans le paquetage par défaut.
On souhaite ajouter une visualisation nommée mix qui affiche les carrés rouges et par dessus la ligne bleue.
En terme de design, on veut être capable de composer n'importe quel type de visualisation en les dessinant les unes sur les autres.
Dessiner sur le verso de la feuille que vous avez utilisée précédemment le diagramme de classes UML du design que vous proposez.
Modifiez votre code en conséquence.
On souhaite modifier le code pour que lorsque l'on spécifie la visualisation mix, on puisse indiquer derrière le nombre de visualisations que l'on souhaite mixer ainsi que leur nom.
Par exemple, pour afficher les carrés rouges et par dessus la ligne bleue, on exécutera
```
          java Main mix 2 square line
        
```
tandis que si on veut mettre la ligne bleue et par dessus les carrés rouges, on exécutera
```
          java Main mix 2 line square
        
```
Notez que si votre design était correct à la question précédente, vous devez uniquement changer le code de votre main.
Faire les changements qui s'imposent.
Piste: vous pouvez utiliser un Iterator comme dans le TD5-B.
Vérifier que la commande suivante fonctionne
```
          java Main mix 2 square mix 1 line
        
```
Note: Si vous n'y arrivez pas, passez à la suite !
On souhaite pouvoir ajouter la gestion des couleurs c'est à dire que pour les visualisations square et line (mais pas mix) on puisse indiquer sur la ligne de commande à la suite du nom de la visualisation une couleur.
Par exemple, la commande ci-dessous affichera une visualisation avec des carrés verts
```
          java Main square green
        
```
tandis que la commmande suivante
```
          java Main mix 2 square red line blue
        
```
affichera une ligne bleue sur des carrés rouges.
Pour simplifier le problème, on supposera que pour la ligne de commande la couleur qui suit le nom de la visualisation est obligatoire. Les couleurs possibles sont celles définie dans la classe Brush.
Utiliser une seconde feuille pour dessiner le diagramme de classe UML correspondant qui prend en compte ces changements.
Puis implanter votre solution.
On souhaite maintenant mettre en place un système de plugin pour permettre à un utilisateur externe de specifier une nouvelle visualisation sans changer le code existant. Pour cela, nous allons créer un fichier de configuration config.txt qui associe à un nom donné (par exemple, square), la classe correspondante (par exemple, visualize.SquareVisialization).
Voici un exemple du fichier de configuration, config.txt par défaut
```
          square visualize.SquareVisualization simple
          line visualize.LineVisualization simple
          mix visualize.MixedVisualization container
        
```
Le mot clé simple indique que la visualisation est une visualisation simple qui possède une couleur et container indique que la visualisation est elle même spécifiée par plusieurs visualisations.
Utilisez le recto de la seconde feuille pour dessiner le nouveau diagramme de classes UML
Faites les changements qui s'imposent dans votre code.
Rappel: en Java, Class.forName permet de charger une classe à partir de son nom et class.newInstance permet de créer une instance d'une classe arbitraire.