Programmation Objet en JAVA

Cours 10 : Projet de Programmation, retour sur le partiel

Partiel : le sujet

• Un graphe non-orienté :

– les noeuds ou sommets (Vertex, Vertices) : les clients

– les arcs sont pondérés par la distance entre les 2 noeuds

– Le graphe est connexe : il existe un chemin entre tous couples de sommet.

• L’objectif : trouver l’arbre couvrant minimal,

Partiel : le sujet - suite

• Représentation du graphe :

– chaque sommet est repéré par un entier de 0 à n-1

– un arc contient 3 entiers : org, dest, longueur.

– le graphe se représente par un tableau succ[i] qui contient les successeurs du noeud i stocké par une liste chaînée

• Les classes :

– Arc : un arc

– Liste : une liste chaînée contenant la valeur stockée (un arc) et une référence sur l’élément suivant (une Liste)

– Graphe qui contient Liste[] succ• Remarque : le graphe est non-orienté, un arbre est orienté

(implicitement).

La frontière, l’arbre

• La frontière regroupe l’ensemble des arcs dont l’origine est dans l’arbre couvrant : les candidats pour la construction de l’arbre

• Construction du graphe en maintenant la frontière :

– init : ajouter un arc (-1,i,0) -> le noeud i est la racine de l’arbre couvrant.

– Boucle de 1 à n-1:

• extraire l’arc de coût minimale de l’arbre, son origine est x

– ajouter dans la frontière tous les arcs dont l’origine est x (grâce au tableau succ)

• Les fonctions à écrire :

– void ajouter(Arc a)

– Arc extraireMin() qui doit également retirer l’arc de la frontière

– Le main

Projet : passage à l’interface graphique

Le point sur l’avance

• La 4ème semaine du projet :– c’est bientôt fini– Déjà 25+15 = 40 points d’assignés, la moitié

• Où vous devez en être. – Le moteur doit être (presque fini)– Tester les tours de jeu :

• en mode console (long)• faire un main qui simule une partie en 2 tours en faisant des

choix aléatoire ou systématique– Le moteur doit être terminé avant la semaine prochaine

• Semaine 5 : réfléchir à l’interface graphique• Faire le point sur les dépôts avec votre chargé de TP !!!

Interface graphique - feuille de route

• Il y a 2 aspects importants dans le développement de l’IG :

– représenter l’information

– mettre en place les interactions avec l’utilisateur• Avant tout dessiner l’interface pour s’assurer que toute l’information soit

présente.• Par exemple prévoir 3 panneaux :

– représentation du plateau

– panneau d’information (où on en est, à qui de jouer, quelle est la tâche, ... )

– panneau de contrôle (affiche par exemple les cartes du joueur, les pions de transport lors de la préparation des déplacements)

• Pour les panneau de contrôle et d’information, c’est assez simple. • Que faire pour le panneau « plateau » ? Quelles sont les interactions ? et

comment les mettre en oeuvre• Pensez au JScrollPane !

Interface graphique - visualisation

• Les informations à visualiser :

– Les pions visibles pour tous les joueurs

– Le pion caché pour le joueur dont c’est le tour

– Les cartes Voyages du joueur courant

– Quelles sont les villages traversés par chaque joueur

– Le score de chaque joueur ? • Attention :

– si 2 routes ont même départ et arrivée ? penser à en dessiner une différemment.

Interface graphique : les interactions

• Le joueur doit pouvoir sélectionner un de ses pions de transport ou une de ses cartes Voyages :

– pour placer les pions sur le plateau

– payer ses voyages

– se défausser en fin de tour• Il doit aussi pouvoir sélectionner une route lors de ses déplacement.

Panneau « plateau » - solution 1

• Prévoir un simple JPanel, et redéfinir la méthode paint pour dessiner intégralement le contenu du plateau

• PlateauGraphique extends JPanel et contient une référence sur le plateau.

• Simple si on prévoit :

– Pour chaque classe du Plateau, une extension graphique qui prend en charge le dessin de chaque élément :

• Ville -> VilleGraphique -> contient une méthode paint()

– Le dessin du PlateauGraphique fait une boucle sur tous les éléments.

• Comment réaliser les interactions ?

Panneau « plateau » - solution 1 - interaction

• Le problème est la gestion des événements lié au plateau graphique.

– avec un seul panneau et aucun composant graphique comment connaître la route sélectionnée ?

– Une solution difficile : faire un calcul savant à partir des coordonnées du clique.

– Une solution facile mais moins élégante : utiliser des JDialog

• Pour la sélection de la route, faire apparaître un JDialog avec la liste des routes partant du Village position du joueur.

• Pour la sélection du pion à poser, faire pareil ou utiliser le panneau de contrôle -> prévoir des JButton ou autre.

Panneau « plateau » - solution 2

• Prévoir un JPanel où sera placer «  à la main », sans passer par un LayoutManager, un composant graphique par élément du plateau.

• PlateauGraphique extends JPanel et contient une référence sur le plateau.

• Chaque élément est un composant : le plus simple est JComponent.

– Village -> VillageGraphique extends JComponent, avec une référence sur le Village

– de même Route -> RouteGraphique extends JComponent

• Simple si on prévoit :

– Pour chaque classe du Plateau, une extension graphique qui prend en charge le dessin de chaque élément :

• Ville -> VilleGraphique -> contient une méthode paint()

– Le dessin du PlateauGraphique fait une boucle sur tous les éléments.

• Comment réaliser les interactions ?

Interlude : dessin des composants, rappels et précisions

Dessin des composants

• Une fenêtre (ou un panneau) est un canevas sur lequel l’application dessine ou peint :

– Les composants de l’API, c’est déjà fait.

– Le reste, c’est à vous de faire.

JButton

Pixel = picture element

Fenêtre et sous-fenêtre

• Chaque composant possède son espace de dessin : sa sous-fenêtre, subwindow

• Subwindow = Aire rectangulaire dans le composant parent avec son propre système de coordonnées

• Clipping, les règles : un composant ne peut peindre

• hors de sa sous fenêtre

• Sur un de ses composants.

(0,0)

(wp, hp)

(0,0)

(wb, hb)

JPanel

JButton

JButton

Le système de coordonnées

• Presque du cartésien : Ywindow = heigth - Ycartesien• Pour chaque fenêtre et chaque sous-fenêtre, un système de

coordonnées qui lui est propre.

(0,0) (width,0)

(0,height) (width, height)

Mon propre composant graphique

• Hérite de Component, JComponent ou JPanel

• Redéfinir la fonction

void paint (Graphics G_Arg) {

Graphics2D g2 = (Graphics2D) G_Arg;

}

• Hérite de repaint() pour lancer paint(…)

– Asynchrone, gestion automatique du Graphics

• Décide de sa stratégie : setDoubleBuffered(b)

• Hérite de méthodes externes dont il faut tenir compte

– setSize(), setEnable(), setBackground(), setFont(), setForeground(), etc.

Dessin avec Graphics2D

• Fonction public void paint(Graphics g ) appelé par Java– Mais Graphics = Graphics2D depuis ... – Transtypage : Graphics2D g2 = (Graphics) g;

• Etat de dessin plus élaboré (attributs)– Paint : peinture (Color, GradientPaint ou TexturePaint)– Font : police de caractère– Clip : zone de restriction du dessin– Stroke : pinceau = forme, épaisseur (1p), joins aux angles– Transform : Matrice affine de transformation

• Translation, rotation, zoom, penchant– Composite : règle de superposition d’un pixel de couleur

avec un autre– Liste de RenderingHint définissant la qualité de rendu

Peinture, mode d’emploi

import java.awt.Graphics

import java.awt.Graphics2D // Java2

1. récupérer le “graphics context” du composant

Graphics g = myJPanel.getGraphics( );

Graphics2D g2 = (Graphics2D) g;

2. Peindre

g2.drawLine(x1,y1, x2,y2);

Peinture, exemples de « draw » et « fill »

• Point (x,y)

• Line (pt1,pt2)

• PolyLine (pt list)

• Arc

• Oval (pt, w,h)

• Rectangle (pt, w,h)

• RoundRectangle

• Polygon (pt list)

• Image (file, x,y)

• Text (string, x,y) label

Quand repeindre ?

• L’écran est une feuille de dessin unique

– Toutes les fenêtres sont peintes sur la même feuille.

– All windows paint on the same surface!

– Les fenêtres ne se souviennent pas de ce qu’elle cache.

– Besoin de repeindre, dès qu’une nouvelle zone de l’écran apparait.

• repaint eventsReceive Repaint events

• ouverture, changement de dimension, mise au premier (ou arrière) pla.

• quand d’autre fenêtre viennent modifier l’écran

• Mais plus si vous le jugez nécessaire

Peinture en Java : repaint

• Repaint event:

• Les composants Java Swing attrapent les événements repaint

• appel des méthodes paintComponent( )

• héritage d’un composant et redéfinition de paintComponent()

• Appel explicite : repaint( ) --> paintComponent( )

Nouveau composant, un exemple

public class MyPanel extends JPanel {

public void paintComponent(Graphics g){ super.paintComponent(g); // erases background Graphics2D g2 = (Graphics2D)g; //cast for java2

// my graphics: g2.setColor(new Color(255,0,0)); g2.fillRect(10,10,200,50); g2.setColor(new Color(0,0,0)); g2.drawString("Hello World", 10, 10); }}

Hello World

Mise en place d’un composant

• Comment placer « à la main » un composant :

– La méthode setBounds héritée de awt.Component:

Moves and resizes this component. The new location of the top-left corner is specified by x and y, and the new size is specified by

width and height.• Puis il faut dessiner l’espace réservé : paintComponent• Attention, la zone de dessin est un rectangle ! Pour la sélection ?

Zone à problème

Zone de sélection par défaut

Redéfinir contains

public boolean contains(int x, int y)

Gives the UI delegate an opportunity to define the precise shape of this component for the sake of mouse processing.

• En redéfinissant cette méthode, on peut spécifier la «zone» concernée par le composant (zone de clique)

• Attention on peut donc distinguer la zone à dessiner (setBounds) et la zone d’interaction (redéfinition de contains).

DoubleBufferring

• Dessiner tous un composant sur une image hors-écran :

– Paint background color

– Paint shapes• Puis, dessiner l’image résultante dans le JPanel• Swing le fait pour vous !!

Interlude : fin, retour au projet

Solution 2 - suite et fin

• Le PlateauGraphique est un JPanel• à vous d’y placer «  à la main » vos propres composants pour les

villes, routes, rivières, ... .

– Utiliser setBounds pour placer les composants dans l’espace du JPanel

– Redéfinir contains pour indiquer la zone d’interaction du composant

– Utiliser un MouseListener

Solution 3 - à mi chemin

• Le PlateauGraphique est un JPanel

– La méthode paintComponent dessine les villages, routes, ...

– Ajout à la main de composant graphique (JButton ou JLabel, ...) sur les routes afin de les sélectionner