Discussion :

[sportman1969]

Bonjour,
Je cherche à faire passer un projet qui est en Swing en JavaFX.
Je demande simplement si quelqu'un peut me renseigner en me disant si c'est possible. Je prends l'exemple avec une classe où j'ai bcp de difficulté à trouver ce qui correspond en JavaFX.
Si vous pensez que c'est 'presque' pas possible, me le signaler

Voici la classe :

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
 
public class PlanComponent extends JComponent {
private static final float MARGIN = 40;
private float scale = 0.5f;
 
   public PlanComponent() { 
      setOpaque(true);
  } 
 
   @Override
   public Dimension getPreferredSize() {
       if (isPreferredSizeSet()) {
           return super.getPreferredSize();
       } else {
           Insets insets = getInsets();
           Rectangle2D planBounds = getPlanBounds();
           return new Dimension(Math.round(((float)planBounds.getWidth() + MARGIN * 2)* this.scale) + insets.left + insets.right, Math.round(((float)planBounds.getHeight() + MARGIN * 2)* this.scale) + insets.top + insets.bottom);
       } 
    } 
 
    private Rectangle2D getPlanBounds() {
        Rectangle2D planBounds =  new Rectangle2D.Float(0, 0, 1000, 1000);
        for (Wall wall : home.getWalls()) { 
             planBounds.add(wall.getXStart(), wall.getYStart());
             planBounds.add(wall.getXEnd(), wall.getYEnd());
        }  
        return planBounds; 
    }
 
    @Override
    protected void paintComponent(Graphics g) {
         Graphics2D g2D = (Graphics2D)g.create();
         paintBackground(g2D);
         Insets insets = getInsets();
         g2D.clipRect(insets.left, insets.top, getWidth() - insets.left - insets.right, getHeight() - insets.top - insets.bottom); 
         Rectangle2D planBounds = getPlanBounds();
         g2D.translate(insets.left + (MARGIN - planBounds.getMinX()) * this.scale, insets.top + (MARGIN - planBounds.getMinY()) * this.scale);
         g2D.scale(scale, scale);
         paintContent(g2D);
         g2D.dispose(); 
     } 
 
      private void paintBackground(Graphics2D g2D) {
	  if (isOpaque()) {
               Color backgroundColor = UIManager.getColor("window");
               g2D.setColor(backgroundColor);  
               g2D.fillRect(0, 0, getWidth(), getHeight());
          }
      }  
 
       private void paintContent(Graphics2D g2D) {
          g2D.setColor(getForeground());
          for (Wall wall : this.home.getWalls()) {
               Line2D line = new Line2D.Float(wall.getXStart(),wall.getYStart(), wall.getXEnd(), wall.getYEnd());
               g2D.setStroke(new BasicStroke(wall.getThickness(), BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER));
               g2D.draw(line);
          } 
       } 
}

Merci pour tout renseignement.

Bien à vous.

[ddoumeche]

Bonsoir,

cela ressemble à un Layout, me tromperais-je ?

Saches que tu peux intégrer des composants Swing dans une application JavaFx et vice-versa: https://docs.oracle.com/javafx/8/emb...mbed_swing.htm

[sportman1969]

Bonjour,

Merci pour ta réaction.
Il s'agit d'une classe venant d'un programme qui permet de créer des plans.
Oui, je sais qu'il est possible d'intégrer des composants Swing dans une appli JavaFX mais j'aimerais éviter cette solution si c'est possible.

[bouye]

Reprenons en détails ce que fait ta classe : elle dessine des lignes qui correspondent a des murs. Un plan architectural ? Un dessin de maison ou de donjon ou de labyrinthe dans un jeu ?

La partie qui gère la collection de murs ou encore la gestion du calcul de la taille du plan peut rester identique ou similaire. Peut-être tout au plus faudra-t-il mettre une liste observable de murs dans la maison et bien sur utiliser les classes appropriées pour les bornes. Certains nœuds existants FX peuvent cependant aider ou simplifier le calcul : Group par exemple si les murs sont eux-mêmes des nœuds. Mais on peut tout aussi bien conserver la séparation entre la définition des murs (dans la classe Wall) et leur représentation (ici sous forme de Line2D) ; il faudra alors faire des calculs soit même, rien d'impossible et ça ressemblera a ce qui est fait ici.

A noter ici que le code de rendu Java2D démontre ici une perte de performance puisqu'il crée une nouvelle Line2D pour chacun des murs et ce a chaque réaffichage au lieu de réutiliser une seule et unique ligne, mais passons.

Le dessin FX maintenant. Deux choix s'offrent a toi :

• Conserver un dessin bitmap ; il faudra donc utiliser un Canvas ou une WriteableImage et dessiner dans son GraphicContext. Ça ressemble tout a fait a ce qui se fait en Swing/Java2D. La seule grosse différence c'est que quand le contenu ne change pas, il n'y a pas besoin de redessiner : dans Swing/Java2D paintComponent() est régulièrement invoqué par le repaint manager des qu'il y a besoin de rafraîchir l’écran (c'est a dire pratiquement tout le temps quand le contenu de la fenêtre change ou est couvert par quelque chose) tandis qu'en FX, le GraphicContext conserve toutes les commandes invoquées et se redessine lui-même.
• Faire du vectoriel ; comme dans le code de paintComponent() il va falloir créer des objets vectoriels (ici nœuds JavaFX) pour faire des Line, Rectangle ou Region (un pour chaque mur) destinés a représenter les murs et les positionner dans un Group, Region ou Pane parent. Ce parent sera alors placé dans la scène.

L’intérêt d'un affichage vectoriel c'est qu'il sera possible d'effectuer des transformations (zoom etc) dessus sans perte de qualité et que ça sera facile a styler via CSS ; mais s'il y a vraiment beaucoup de mur ça peut bouffer pas mal de mémoire ou de performance. Par contre, un jeu c'est souvent plus performant avec des affichages bitmap ; il faudra par contre gérer les redimensionnements de la zone bitmap affichable lors que la fenêtre change de taille.

Essaie de voir d'abord quelle solution t'interpelle avant qu'on réfléchisse a aller plus loin.

[sportman1969]

Tout d’abord, merci pour ton aide.

Il ne s’agit pas d’un jeu mais d’une application qui permettra de réaliser des plans.

Pour plus d’info :

• En annexe, le document word ‘PlanComponent_info’ dans lequel il y a les infos sur les méthodes de la classe ‘PlanComponent’ (j’aurais peut-être dû commencer par ça ). Repris de la page 270 du document ‘LescahiersduprogrammeurSwing’;

• En annexe également ‘LescahiersduprogrammeurSwing’ --> le .pdf est trop 'lourd', je ne parviens pas à l'annexer;

• Au cas où tu jetterais un œil sur le document ‘LescahiersduprogrammeurSwing’ :
  - Moi, je ne souhaite pas implémenter la partie 3D;
  - Les images des meubles du projet ‘LescahiersduprogrammeurSwing’ seront remplacés chez moi par des symboles (électriques ou autres);
  - En page 247 de ce document, il est précisé ‘Comme un logement ne peut contenir qu’un seul plan, on décide de ne pas créer de classe séparée pour le plan et d’associer directement à la classe Home l’ensemble des murs du plan’. Moi, je souhaite avoir la possibilité de réaliser plusieurs plans (sous-sol, rez, étages). Donc, je prévois d’implémenter les méthodes reprisent dans ‘Home’ qui gèrent les murs dans une autre classe appelée ‘Plan’. Ma classe ‘Home’ contiendra une collection de ‘Plan’.

Ensuite pour la partie ‘Le dessin FX’ : Vu que je ne connais aucun élément des 2 propositions que tu proposes, j’ai dur de choisir. Mon but est de me calquer au plus près du projet existant car il n’y a pas que la classe ‘PlanComponent’ à adapter en JavaFX. Et donc, je souhaite utiliser la méthode qui me permettra de passer le code en JavaFX le plus facilement possible --> Je ne t’aide pas bcp !!!

Maintenant, je me pose une question : si je souhaite bien éviter la solution d'intégrer des composants Swing dans l'application JavaFx comme proposé ci-dessus. Ne serait-il pas plus facile de modifier tout ce qui concerne Swing (exemple : classe qui extends JComponent --> mais dans ce cas, comment implémenter le code repris dans les 2 méthodes overridées 'getPreferredSize' et 'paintComponent' !) mais de conserver par exemple tout l'implémentation avec Java2D puisque ça ne provient pas de Swing ?

[bouye]

Tu peux très bien héberger des document trop lourds sur un emplacement cloud publique et adjoindre le lien ici ; bien que je doute que que ce soit l'endroit approprie pour lier tout un bouquin ici, d'autant plus s'il s'agit d'un livre payant comme cela semble être le cas ici

Dans tous les cas notre but ici va être de te conseiller ou de t'orienter, voir de corriger les bugs donc c'est quand même toi qui va devoir prendre les décisions a un moment ou a un autre. Pour le reste c'est comme toujours : bien reflechir a la conception, penser son problème en amont, le découper en sous-parties indépendantes facilement isolables les unes des autres, penser aux tests, etc. Et pour le reste, poster chaque soucis dans des topics appropries, savoir bien expliquer clairement son problème, l'accompagner des exemples et tests suffisamment concis et atomiques pour permettre aux gens qui viennent aider de prendre le problème en route et pour eux de ne pas se prendre la tête avec des choses hyper-complexes qui viendraient parasiter le soucis principal, etc.

Le problème de conception générale est globalement indépendant de la lib graphique a utiliser. Bien que certaines classes et méthodes de JavaFX peuvent influer sur l’implémentation (je pense entre aux collections observables). De manière générale les grandes lignes de la conception, les patterns/motifs a utiliser n'ont pas vraiment besoin de connaître, dans un premier temps, les détails de l’implémentation. Donc si tu veux avoir plusieurs plans par maison ben tu prends ton crayon et une feuille ou un éditeur de diagramme genre UML et tu réfléchis sur la manière dont tu peux gérer ça. Ex : comme tu le dis, au lieu de ce qui est explique dans le livre, ici ta maison contiendra une collection de plans ; c'est un bon debut pour gérer les plans des divers étages de ta maison.

Coté implémentation, ça peut se faire via les collections observables JavaFX qui te permettent de faire de la propagation d’événement automatique, alors que dans du Java Bean il aurait fallu gérer ça a mano (et du POGO y aurait eut 0 événement). Mais ce n'est pas une obligation non-plus de faire cela en FX.

Code rendu maintenant, si tu veux changer le moins de chose possible il suffit d'aller voir du coté de FXGraphic2D, une lib de JFree (les concepteurs de la lib JFreeChart) qui permet d'utiliser du Java2D en JavaFX. Donc pour le coup ça serait vraiment un port a minima puisque pas grand chose ne changerait.