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.

[bouye]

Ensuite il faut voir quelle partie tu veux justement creer en tant que controle. Dans le code initialement poste PlanComponent étend JComponent, c'est une vue sur un plan (ou plutôt un ensemble de murs dans le code initial). On a donc bien la vue et le modèle qui sont découplés : PlanComponent est un contrôle destine a afficher le plan (qui lui n'est pas graphique).

En FX tu vas donc partir sur quelque chose de similaire, par exemple, PlanView, PlanPane ou encore PlanNode qui étend une des classes de base nœud nécessaires pour integrer une telle vue dans le SceneGraph :

• Node - probablement trop générique, il faudra implémenter trop de choses ; on évitera.
• Parent - défini abstraitement un nœud qui contient d'autre nœud. Bon debut mais on va se pencher sur un de ses sous-classes :
  
  • Group - un groupe c'est un parent tout simple qui se met automatiquement a la taille de ce qu'il contient (les nœuds enfants). Idéal pour pour des choses qui ne se transforment pas trop mais donc le contenu n'a pas besoin d’être trop complexe non-plus. Par contre l'utilisation des CSS reste très limite sur cette entité.
  • Region - une région c'est la base de tout les contrôles JavaFX, c'est un peu l’équivalent d'un <div> en HTML ou meme d'un JComponent en Swing, une forme (rectangulaire de base mais ca peut se changer) que sur laquelle tu peux appliquer des CSS et ensuite modifier le contenu avec d'autres nœuds enfants. Par rapport a Group, Region a l'avantage (qui est aussi un défaut) d’être redimensionnable ; donc sans doute dans ton cas faudra-t-il bloquer ses tailles min, pref et max pour éviter des soucis lors de l'affichage dans des gestionnaires de mise en page.
    
    • Pane - c'est le gestionnaire de mise en page de base, l’équivalent d'un JPanel tout simple en Swing. Il dispose d'un peu plus de méthodes publiques que Region pour accéder aux enfants qu'il contient tout en restant plus simple et versatile que la plupart des autres gestionnaires de mise en page qui sont plus spécialisés. En général si tu sais te débrouiller avec Region, ça ne sert a rien d'utiliser un Pane.

Un vrai contrôle en JavaFX c'est un peu plus complexe qu'un simple nœud Parent , ca a par exemple un Skin pour changer son apparence et un Behavior pour changer son comportement, mais on va commencer en restant ultra-simple et donc on va éviter d'aller voir de ce coté la pour le moment.

Un bon début pourrait être :

Code :

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

1
2
public final class PlanView extends Region {
}

Bon qu'est ce qu'on va afficher dans cette vue ? Un plan par exemple, ça serait pas mal... allez paf on met une propriété plan dedans !

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
public final class PlanView extends Region {
 
    private final ObjectProperty<Plan> plan = new SimpleObjectProperty<>(this, "plan");
 
    public final Plan getPlan() {
        return plan.get();
    }
 
    public final void setPlan(final Plan value) {
        plan.set(value);
    }
 
    public final void ObjectProperty<Plan> planProperty() {
        return plan;
    }
}

[bouye]

Avoir un plan c'est cool mais encore faut-il être au courant qu'on en a un, donc autant ajouter ce qu'il faut pour être averti que l'utilisateur nous en a refourgué un :

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
public final class PlanView extends Region {
 
    public PlanView() {
        planProperty().addListener(planChangeListener);
    }
 
    // Invoqué quand le plan change.
    private final ChangeListener<Plan> planChangeListener = (observable, oldValue, newValue) -> {
        Optional.ofNullable(oldValue)
            .ifPresent(this::uninstallPlan);
        Optional.ofNullable(newValue)
            .ifPresent(this::installPlan);
    };
 
    // Nettoyer quand on retire le plan qui était affiché.
    private void uninstallPlan(final Plan plan) {
    }
 
    // Préparer en vue d'afficher un nouveau plan.
    private void installPlan(final Plan plan) {
    }
 
[...]

Pour la suite, la par contre il va falloir choisir quelle méthode d'affichage utiliser...

[sportman1969]

Bonjour,

Dans ma démarche pour passer de Swing à Javafx, ma progression est lente …
Je bloque, notamment, sur ce code au niveau du model.getSize() & model.getElementAt(i) (où catalogFurnitureList est une JList) :

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
 
List<CatalogPieceOfFurniture> selectedFurniture = controller.getSelectedFurniture();
ListModel model = catalogFurnitureList.getModel();
List<Integer> selectedIndices = new ArrayList<Integer>();
for (CatalogPieceOfFurniture piece : selectedFurniture) {
     for (int i = 0, n = model.getSize(); i < n; i++) {
	 if (piece == model.getElementAt(i)) {
	      selectedIndices.add(i);
	      break;          
	 }
      }
}
if (selectedIndices.size() > 0) {
   int [] indices = new int [selectedIndices.size()];
   for (int i = 0; i < indices.length; i++) {
         indices [i] = selectedIndices.get(i);
  }
  catalogFurnitureList.setSelectedIndices(indices);
  catalogFurnitureList.ensureIndexIsVisible(indices [0]);
}

J'ai codé ceci (où catalogList est une ListView) mais pour model.getSize() & model.getElementAt(i) --> ? :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
ObservableList<CatalogSecurityApparatus> selectedApparatus = catalog.getSelectedApparatus();
MultipleSelectionModel  model = catalogList.getSelectionModel();
ObservableList<Integer> selectedIndices = FXCollections.observableArrayList();
for (CatalogSecurityApparatus piece : selectedApparatus) {
     for (int i = 0, n = model.?; i < n; i++) {
          if (piece == model.?) {
             selectedIndices.add(i);
             break;          
          }
     }
}

Y a t'il une alternative pour JavaFX ?

Merci.

[bouye]

Le but étant de ?

Paske sinon ObservableList<Integer> selectedIndices = model.getSelectedIndices(); fait aussi très bien le boulot en une seule ligne.
Meme en Swing un int[] selectedIndices = catalogFurnitureList.getSelectedIndices(); aurait suffit, non?

[sportman1969]

Quand un meuble est sélectionné dans un ‘catalogue’ (List<CatalogPieceOfFurniture> selectedFurniture …), il effectue une synchronisation de sélection du meuble dans la ListView (cette ListView est totalement customisée)

[bouye]

Le fait d'avoir été sélectionné (ailleurs) est donc une propriété observable des éléments du catalogue ?

[bouye]

Bon, on va faire plus simple ; quelque chose dans ce style ?

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
public final class Main extends Application {
 
    @Override
    public void start(final Stage primaryStage) {
        final List<Toto> catalog = IntStream.range(1, 10)
                .mapToObj(index -> new Toto())
                .collect(Collectors.toList());
        final ListView<Toto> list = new ListView<>();
        list.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
        list.getItems().setAll(catalog);
        final Button changeSelectionButton = new Button("Change Selection");
        changeSelectionButton.setOnAction(event -> {
            list.getSelectionModel().clearSelection();
            catalog.stream()
                    .forEach(toto -> {
                        final boolean selected = Math.random() > 0.5;
                        toto.selected = selected;
                    });
            final int[] selectedIndices = catalog.stream()
                    .filter(toto -> toto.selected)
                    .mapToInt(catalog::indexOf)
                    .toArray();
            if (selectedIndices.length > 0) {
                list.getSelectionModel().selectIndices(selectedIndices[0], selectedIndices);
            }
        });
        final ToolBar toolBar = new ToolBar();
        toolBar.getItems().add(changeSelectionButton);
        final BorderPane root = new BorderPane();
        root.setTop(toolBar);
        root.setCenter(list);
        final Scene scene = new Scene(root);
        primaryStage.setScene(scene);
        primaryStage.show();
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);
    }
 
    private static final class Toto {
 
        public boolean selected = false;
    }
}