Discussion :

[robert_trudel]

salut

j'ai fait un mini programme pour dessiner des formes, il fonctionne bien, mais je chercher à ajouter quelques fonctionnalités

mes formes dessiné ont tous une méthode

draw(Graphics g)

je cherche à ce que les formes dessiné ai des petits carré autour afin de savoir si elle est sélectionné au non

je sais pas comment m'y prendre pour faire cette tâche, je pensais envoyé un paramètre pour lui s'il est sélectionné ou non

je serais obligé de forcé un redessinage de la pièce

quel serait une bonne pratique pour ce cas là?

merci

[bouye]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
List<Shape> shapes = ...
Shape selectedShape = null;
Rectangle2D.Float currentBounds = new Rectangle2D.Float();
int margin = 20;
 
/**
* {@inheritDoc}
*/
@Override
protected void paintComponent(Graphics g) {
  Dimension size = getSize();
  Insets insets = getInsets();
  int width = size.width - (insets.left + insets.right);
  int height = size.height - (insets.top + insets.bottom);
  Graphics2D g2d = g.create(insets.left, insets.top, width, height);
  try {
    Shape clip = g2d.getClip();
    for (Shape s : shapes) { 
       Rectange2D sb = s.getBounds2D();
       currentBounds.x = (float) (sb.getX() - margin);
       currentBounds.y = (float) (sb.getY() - margin);
       currentBounds.width = (float) (sb.getWidth() + 2 * margin);
       currentBounds.height= (float) (sb.getHeight() + 2 * margin);
       // Pas la peine de dessiner si ce n'est pas dans la zone a afficher.
       if (clip.intersects(currentBounds ) || clip.contains(currentBounds ) || bounds.contains(clip)) {
         g2d.setPaint(...);
         g2d.fill(s);
         g2d.setStroke(...);
         g2d.setPaint(...);
         g2d.draw(s);
       }
    } 
    // On dessine les ancres par dessus.
    if (selectedShape != null) {
      Rectange2D sb = selectedShape .getBounds2D();
      currentBounds .x = (float) (sb.getX() - margin);
      currentBounds .y = (float) (sb.getY() - margin);
      currentBounds .width = (float) (sb.getWidth() + 2 * margin);
      currentBounds .height= (float) (sb.getHeight() + 2 * margin);
       // Pas la peine de dessiner si ce n'est pas dans la zone a afficher.
      if (clip.intersects(currentBounds ) || clip.contains(currentBounds ) || bounds.contains(clip)) {
        // Dessiner les ancres en utilisant sb pour les positionner.
        [...]           
      }
    }
  }
  finally {
    g2d.dispose();
  }
}
 
/**
* {@inheritDoc}
*/
@Override
public void mouseClicked(MouveEvent e) {
  Insets insets = getInsets();
  float x = e.getX() - insets.left;
  float y = e.getY() - insets.top;
  // Reafficher a la position de l'ancienne selection.
  if (selectedShape != null) {
     Rectange2D sb = selectedShape.getBounds2D();
     currentBounds.x = (float) (sb.getX() - margin);
     currentBounds.y = (float) (sb.getY() - margin);
     currentBounds.width = (float) (sb.getWidth() + 2 * margin);
     currentBounds.height= (float) (sb.getHeight() + 2 * margin);
     repaint((int) (currentBounds.x + insets.left),  (int) (currentBounds.y + insets.top), (int)currentBounds.width, (int) currentBounds.height);
  }
  selectedShape = null;
  // Partir de la fin de la liste vers le debut pour recuperer les formes situees au dessus en premier.
  for (ListIterator<Shape> it = shapes.listIterator(list.size()-1) ; it.hasPrevious() ; ) {
    Shape s = it.previous();
    if (s.contains(x, y)) {
      selectedShape = s;
      break;
    }
  }
  // Reafficher a la position de la nouvelle selection.
  if (selectedShape != null) {
     Rectange2D sb = selectedShape.getBounds2D();
     currentBounds.x = (float) (sb.getX() - margin);
     currentBounds.y = (float) (sb.getY() - margin);
     currentBounds.width = (float) (sb.getWidth() + 2 * margin);
     currentBounds.height= (float) (sb.getHeight() + 2 * margin);
     repaint((int) (currentBounds.x + insets.left),  (int) (currentBounds.y + insets.top), (int)currentBounds.width, (int) currentBounds.height);
  }
}

[robert_trudel]

ça semble pas vraiment applicable pour mon cas...

j'ai une classe qui extends mouseAdapter
dans cette classe, j'ai un jpanel (nommé canvas) sur lequel je dessine des formes

dans mon mouseDragged, je fais un repaint à partir du canvas

dans mon mouseClick je fais rien encore... j'arrive à savoir aisément si le composant a le focus ou non

c'est sur la façon d'appeler le draw que je me questionne faudrait que je modifie le draw... ou bien créer une nouvelle méthode que j'appèlerais dans mon mouseclick....

ça fait plus crade... il me semble

est-ce que si mes formes hériterais de component ça faciliterais les choses?

des commentaires?

[bouye]

Je ne vois pas trop en quoi ca ne sera pas adaptable a ton code.

C'est possible de faire un JComponent par forme c'est juste inutilement lourd. Mais ca reste faisable.

[robert_trudel]

si je comprend bien ton code, tu as par exemple un jpanel qui dedans a la méthode paintComponent et mouseClicked, les formes sont directement dessiné et tu peux savoir directement si c'est la forme est sélectionné ou non et dessiné en conséquence

étant donné que mes formes ont leur propre méthode draw, je suis supposé faire comment pour lui dire qu'elle a le focus?

[bouye]

En leur mettant un membre booleen focus et en t'arrangeant pour qu'on ne puisse avoir qu'une seule et unique forme ayant le focus à la fois. Il faut ensuite rajouter le rendu du focus dans le code dessin de la forme ou déléger à une autre classe (par exemple si le rendu est tout le temps de type boite rectangulaire avec 6 carrés de sélection ça ne sert à rien de le dupliquer un peu partout, il vaudra mieux déléger à une autre classe).

Mais que sont tes formes ? Des listes de points ? Des objes étendant Shape ? Des objets étendant JComponent ?

Dans les deux premiers cas tu n'échapperas pas à une gestion de la forme active similaire à ce que j'ai fait.
Dans le second tu devras te créer un gestionnaire de focus dans lequel tu devras enregister toutes les formes (penser à désenregistrer lorsqu'on en supprime une) et qui écoutera les évenement de gain/perte de focus pour s'arranger pour qu'il n'y ai jamais qu'au plus une forme ayant le focus.

Et il y a bien un composant racine qui se charge de les afficher ?

[robert_trudel]

mes formes sont d'une classe qui extends une autre classe qui possède une méthode draw, getPosition, setPosition

dans le draw de chacune des formes, j'effectue le traitement pour les dessiner

dans une jpanel, j'ai la liste des formes dessiné

donc quand j'ajoute une forme sur le panel, j'appèle directement repaint idem quand j'efface une forme

j'ai de plus dans cette classe une méthode paint, qui parcourt la liste des formes et qui appèle la méthode draw pour les dessiner

[bouye]

Donc il n'y a aucune raison que tu ne puisses pas adapter mon code a ce que tu fais (sauf que dans ton code tu appeleras la methode de dessin de chaque forme plutot que la dessiner directement).

Ne pas se reposer sur Shape est un peu dommage car tu perds toutes les facilites liees aux methodes de test d'appartenance, d'intersection, de boite englobantes, etc. liees a cette interface et ses sous-classes.
Et pour etre precis, les divers calculs concernant les boites englobantes et la zone de clip sont les optimisations de base necessaires pour un rendu rapide (qui se base sur un rendu partiel) car tu risques de trouver rapidement que c'est lent a se dessiner si tu repeins tout a chaque fois quand tu as beaucoup de formes a l'ecran.

[robert_trudel]

j'avais regardé ce tutoriel pour démarrer mon projet:

http://duj.developpez.com/tutoriels/java/dessin/intro/

j'ai j'adopte ta façon de faire

je dois avoir un panel où dessiner mes formes avec ses listener et cie

pour mes formes ils doivent implémenter Shape?

[bouye]

Pas forcement nottament si tes propres objets geometriques sont des objets complexes qui contiennent des trucs comme le stroke, la peinture de fond, la peinture de bordure etc...

Mais disont que Shape est la, deja toute prete et le package java.awt.geom dispose de classes associees qui permettent de faire des operations comment le supportent les editeurs de dessin vectoriel: par exemple avec Area on peut ajouter ou soustraire deux formes entre elles ; avec Path2D on peut faire des courbes, etc... Sinon tu peux toujours essayer de tout reimplementer tout par toi meme mais ca risque de prendre un temps certain.

Par exemple tu peux tres bien avoir un objet de ce type. A toi de voir si tu veux ou non implementer l'interface Shape mais disons que ca peut aider d'avoir acces a une partie sinon a toutes ses methodes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class FormeAbstraite extends Shape {
  protected Shape delegated;
  protected Paint foreground;
  protected Paint background;
  protected Stroke stroke;
 
  FormeAbstraite(Shape delegated) throws IllegalArgumentException {
    if (delegated == null) {
      throw new IllegalArgumentException("Delegated shape cannot be null.");
    }
    this.delegated = delegated;
}
 
  public void draw(Graphics2D g) {
      if (background != null) {
        g.setPaint(background);
        g.fill(delegated);
      }
      if (foreground!= null && stroke != null) {
        g.setPaint(background);
        g.setStroke(stroke);
        g.draw(delegated);
      }
  }
 
  // Implementation de l'interface Shape.
 
  /** 
  * {@inheritDoc}
  */
  @Override
  public boolean contains(int x, int y) {
    return delegated.contains(x, y);
  }
 
  /** 
  * {@inheritDoc}
  */
  @Override
  public Rectangle getBounds() {
    return delegated.getBounds();
  }
 
  [...]
 
}

Ce qui n'empeche pas non-plus de conserver une List<Point> lorsque tu veux creer des polygones editables, etc..

Par exemple si tu veux implementer un rectangle dans ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
public class MonRectangle extends FormeAbstraite {
   public MonRectangle() {
     super(new Rectangle2D.Float());
   }
 
  public void setRect(float x, float y, float w, float h) {
    ((Rectangle2D.Float)delegated).setRect(x, y, w, h);
  }
 
  [...]
}

[robert_trudel]

ok est dans le panel sur lequel tu dessines les formes, c'est là que tu ferais ton traitement si l'item est sélectionné ou non... comme dans le premier code que tu as posté?

[bouye]

Generalement oui

[robert_trudel]

je crois que c'est pas extends mais implement... Shape est une interface si je m'abuse....

[bouye]

En effet (code tape a la va-vite + trop de JavaFX ces derniers temps)

[robert_trudel]

je voudrais quelques précision afin de mieux comprendre et de pouvoir avancer

dans forme abstraite, pourquoi la méthode

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public void draw(Graphics2D g)

pourquoi pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract void paint(Graphics g, Shape a) ;

ou une autre méthode du genre?

d'ailleur je me demande pourquoi paint plutôt que draw ou paintComponent...et vice versa

ça devrait pas être au pièce qui hérite de FormeAbstraite de savoir comment elles doivent être dessiné?

pas compris l'intéret des de background et foreground qui sont de type Paint... d'ailleurs elle doivent être initialisé via le constructeur...

[bouye]

Je n'ai rien compris (et il faut dire que tu n'as guere donne les details de ton implementation jusqu'a present).

Par le passe tu as ecris :

mes formes sont d'une classe qui extends une autre classe qui possède une méthode draw, getPosition, setPosition

dans le draw de chacune des formes, j'effectue le traitement pour les dessiner

Pourquoi devrais-tu passer en parametre la forme a dessiner si la forme c'est toi ?

Quand au fait que la methode s'apelle draw(), paint(), print(), render(), dessine(), ... on s'en fiche : c'est la methode de rendu.

[robert_trudel]

j'ai déjà dit: "j'ai j'adopte ta façon de faire"

donc j'ai fait une classe FormeAbstraite qui implement Shape

j'ai mis la classe abstract car j'ai comme idée que je vais avoir plus forme qui ne seront pas nécessairement pareil et qui devront se dessiner différement

il me semble que paint, draw, paintComponent ne sont pas utiliser pour les même raison


dans ta FormeAbstraite, pour les paint c'est quoi l'utilité?

[bouye]

Faire que la forme soit elle-même capable de se dessiner, y compris l'affichage du fait qu'elle ait le focus/sélection, sur n'importe quelle surface graphique sans lier trop fortement le code de rendu à un JPanel, ce que tu voulais faire plut tôt dans ta citation non ?

A moins que ta forme ne soit une forme composée (ou encore groupe) de plusieurs sous-formes ayant chacune des peinture et des stroke différents, ce code de rendu est suffisament généraliste pour fonctionner avec n'importe quelle forme géométrique simple.

J'avais donné le code pour un rectangle mais pour un cercle c'est pas plus compliqué :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
public class MonCercle extends FormeAbstraite {
   public MonRectangle() {
     super(new Ellipse2D.Float());
   }
 
  public void setCircle(float cx, float cy, float r) {
    ((Ellipse2D.Float)delegated).setFrameFromCenter(cx, cy, r, r);
  }
 
  [...]
}

le code de rendu est toujours hérité de la classe mère et n'a pas besoin d'être modifié.

Le code pour un groupe sera plus complexe :

• les méthodes héritant de Shape ne forwardent pas directement à la forme déléguée mais parcourent l'arborescence des sous-groupes/formes enfants et font, par exemple, l'union des boites englobantes ou s'arrêtent sur la première sous-forme qui contient le point testé.
• certaines méthodes qui renvoient un PathIterator ne peuvent pas être implémentées *facilement* et donc peuvent renvoyer une exception genre UnsupportedOperationException OU alors il faut procéder à la fusion/concaténation des PathIterator des sous-groupes/formes enfants (au choix).
• le code de rendu doit être modifié pour appeler la méthode de rendu des sous-groupes/formes enfants. On peut utiliser le clip du Graphics pour avoir une optimisation ce qui donnerait un code similaire à mon code rendu initial dans le JPanel.

[robert_trudel]

Faire que la forme soit elle-même capable de se dessiner, y compris l'affichage du fait qu'elle ait le focus/sélection, sur n'importe quelle surface graphique sans lier trop fortement le code de rendu à un JPanel, ce que tu voulais faire plut tôt dans ta citation non ?

oui en plein ça

A moins que ta forme ne soit une forme composée (ou encore groupe) de plusieurs sous-formes ayant chacune des peinture et des stroke différents, ce code de rendu est suffisament généraliste pour fonctionner avec n'importe quelle forme géométrique simple.

j'ai une forme rectgulaire, dessus j'ajoute quelques en plus d'écrire du texte
ensuite j'ai quelques segment de ligne avec dedans des cercles et des lignes diagonales