Discussion :

[galien]

Voila je propose cette nouvelle discussion comme pot pourri des différents bugs que tout le monde a rencontré dans la 1.2, de plus si vous avez trouvé le moyen de le contourner n'hésitez pas! (je sens que Bouye vas se lâcher sur les layouts )

[PhiLho]

Voyons, il reste à ce jour 336 bugs encore ouverts pour SoMa, contre, uh... 68 bugs résolus (plus 7 pour la 1.2.1) ?
La 1.3 n'est pas encore sortie !
Bon, si on se limite aux bugs bloquants, critiques ou majeurs, il n'y en a plus "que" 268...
Et ce n'est que le runtime, le compilateur est pas mal aussi... :-)

Bah, gros projet = beaucoup de bugs, c'est normal. Espérons qu'il reste assez de programmeurs sur le projet pour le faire avancer rapidement...

Côté bugs rencontrés, il y en a pas mal, particulièrement sur les composants, sortis un peu précipitamment (mais on est content de les avoir quand même...) pour JavaONE.

Comme le slider qui n'a pas de ticks, qui se comporte bizarrement si on met min à autre chose que zéro... Les graphes qui ne sont pas dynamiques. Les composants qui ne sont que partiellement modifiables par CSS. Le CSS qui ne fonctionne que sur les composants déclarés, pas ceux ajoutés après coup.
J'ai ouvert un bug sur les mixins qui ne sont pas cohérents.
Il y en a un autre sur le parsing de Json, qui ne gère pas les Long (style timestamp).
J'ai aussi un bug sur ShapeSubstract qui ne suit pas le binding.
Ah, oui, et le boundsInParent qui devient énorme sur une forme ayant subi une rotation et un effet (DropShadow).
Bon, j'en oublie sans doute, mais cela va devenir fastidieux... ;-P

[bouye]

je sens que Bouye vas se lâcher sur les layouts ;

Ca serait mal, oh vi ca serait mal

Personnellement j'ai surtout des layoutBounds ou boundsInParent incoherent des que j'utilise de composants texte (Text et Label) avec HBox, VBox et Flow et mais moins souvent avec Stack ce qui fait que j'ai souvent des noeud ou des controles qui se retrouvent avec des origines negatives ou qui se chevauchent ou qui ont au contraire beaucoup trop d'espacement entre eux (donc une des boites englobantes deraille mais pourtant je n'applique pas de rotation dessus).

La bordure de focus de TextBox modifie la boite englobante du composant ce qui fait bien sur que cela modifie la mise en page des boites de dialogues quand le composant recoit ou perd le focus.

Le knob du Slider modifie aussi la boite englobante du composant dans certaines layouts. Le composant n'est pas capable d'indiquer qu'il a le focus.

Certaines noeud n'ont pas la bonne boite englobante quand je les colle dans des layout qui contiennent aussi des ScrollBar.

Certains problemes de layout n'apparaissent uniquement que quand on a des layouts dans d'autres layouts (il y a donc un probleme ou une incoherence au niveau des caculs des origines ou des transformations d'un espace a un autre).

Les gradients deraillent dans un ClipView ou parfois quand on fait un translate sur un ensemble de noeud qui en contient. Il faut donc les cacher.

Ps : tiens le bug abscence de TexturePaint n'est toujours pas resolu ? Etrange j'ai recupere et modifie une implementation sur les forums de Sun qui fonctionne plutot bien.

[galien]

@bouye, pour les textbox, dans une box je detecte pas les problème de layout... que j'avais remarqué au début, strange dites vous?

[Fr3nchK1ss]

Pour ma part, je peux rajouter ça:

- l'ajout d'éffets InnerShadow sur plusieurs grands rectangles comportant un gradient divise les performances par 10, au moins! (ça le faisait pas en 1.1)

- requestFocus() sur une TextBox reset le contenu sous Linux, mais pas sous Windows qui là est surligné en bleu

- la simple mis à jour de la chaîne de caractère affichée par un composant Text bloque l'EDT. J'ai de grandes fenêtres avec de nombreuses données à modifier en temps réel, et ça freeze tout le reste à chaque mise à jour pendant quelques ms du coup ça rame.

- sur la même application, les performances linux sont de l'ordre de 10 fois inférieures au rendu sous Windows (le SDK linux est considéré comme beta, je sais ^^)

- les propriétés nodeHPos et nodeVPos de la Stack ne marchent plus dès que l'on utilise un autre layout comme content. Exemple, Stack avec une VBox dedans, la VBox est incentrable. On remplace la VBox par une TextBox, elle est centrée.

[galien]

L'histoire du gradient et du drop shadow, en effet je crois l'avoir vu sur JIRA, par contre as-tu essayé de mettre cache=true sur tes composants pour voir si il y avait une difference?

[Fr3nchK1ss]

L'histoire du gradient et du drop shadow, en effet je crois l'avoir vu sur JIRA, par contre as-tu essayé de mettre cache=true sur tes composants pour voir si il y avait une difference?

[edit] Petite boulette de ma part, ce sont des InnerShadow et pas des DropShadow

Oui, c'est comme ça que j'avais résolu le problème avec le 1.1. Mais depuis la 1.2, cache=true empèche la fenêtre de ramer que si le gradient est seul. Une fois l'ombre appliquée en plus du gradient, les performances rechuttent au même niveau qu'un cache=false. Actuellement, je suis obligé d'enlever la plupart de mes InnerShadow :/

[galien]

Alors là je pose la question qui tue, Label or not Text?
Je prendrais plutôt la colonne de gauche sur cet exemple

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
 
def SIZE: Integer = 50;
def TIME: Integer = 5;
def font: Font = Font.font("Arial bold", 13);
def labels: Label [] = for(n in [0..SIZE]) Label { font: font text: "{System.nanoTime()}" };
def texts: Text [] = for(n in [0..SIZE]) Text { font: font content: "{System.nanoTime()}"};
def tmLabel = Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames : [
        KeyFrame {
            time : TIME * 1ms
            canSkip : true
            action: function(): Void {
                for (label in labels) label.text = "{System.nanoTime()}"
            }
        }
    ]
}
def tmText = Timeline {
    repeatCount: Timeline.INDEFINITE
    keyFrames : [
        KeyFrame {
            time : TIME * 1ms
            canSkip : true
            action: function(): Void {
                for (text in texts) text.content = "{System.nanoTime()}"
            }
        }
    ]
}
Stage {
    title : "Text & Label test"
    scene: Scene {
        width: 300
        height: 900
        content: [
            HBox {
                spacing: 10
                content: [
                    VBox {
                        content: [
                            Button {
                                text: "Labels"
                                action: function() {
                                    if(tmLabel.running) tmLabel.stop() else           tmLabel.playFromStart();
                                }
                            }
                            labels
                        ]
                    }
                    Line {
                        endY: 500
                    }
                    VBox {
                        content: [
                            Button {
                                text: "Texts"
                                action: function() {
                                    if(tmText.running) tmText.stop() else tmText.playFromStart();
                                }
                            }
                            texts
                        ]
                    }
                ]
            }
 
        ]
    }
 }

Au profilage on remarque que la version Text stress plus GC, au vue des problèmes de calcul des bounds ca doit être due à la Box...
Je vous fait pas le coup SwingList or not List

[bouye]

@bouye, pour les textbox, dans une box je detecte pas les problème de layout... que j'avais remarqué au début, strange dites vous?

Encore une fois cela depend de l'agencement des layouts dans lesquels ces controles sont mis. Par exemple ici qui simule une UI faite de controle separes, le fait de mettre chaque VBox dans son propre Group (apres tout on pourrait avoir envie de mettre des glasspane et autre decoration sur ces VBox) fait que les espacements entre chaque composant varie lorsqu'on fait circuler le focus (sous Windows) :

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
/*
 * Main.fx
 *
 * Created on Aug 28, 2009, 11:35:38 AM
 */
 
package test;
 
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.control.Label;
import javafx.scene.layout.LayoutInfo;
import javafx.scene.control.TextBox;
import javafx.geometry.VPos;
import javafx.scene.Group;
import javafx.scene.shape.Rectangle;
import javafx.scene.paint.Color;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.shape.Line;
 
/**
 * @author Fabrice Bouyé (fabriceb@spc.int)
 */
 
def ui:VBox = VBox {
    spacing: 5;
    content: for (i in [0..3]) {
        def panel:VBox = VBox {
            spacing: 5;
            content: [
                Group {
                    def label:Label = Label {
                        layoutInfo: LayoutInfo { width: 75 }
                        text:##"Options {i+1}"
                    }
                    content: [
                        label,
                        Line {
                            startX: 0; startY: bind label.layoutBounds.maxY;
                            endX: bind label.layoutBounds.width; endY: bind label.layoutBounds.maxY;
                        }
                    ]
                }
                HBox {
                    spacing: 5;
                    nodeVPos: VPos.CENTER;
                    content: [
                        Label {
                            layoutInfo: LayoutInfo { width: 75 }
                            text:##"Name"
                        }
                        TextBox {
 
                        }
                    ]
                }
                HBox {
                    spacing: 5;
                    nodeVPos: VPos.CENTER;
                    content: [
                        Label {
                            layoutInfo: LayoutInfo { width: 75 }
                            text: ##"Password"
                        }
                        TextBox {
 
                        }
                    ]
                }
            ]
        }
        def layoutRect:Rectangle = Rectangle {
            fill: null;
            stroke: Color.RED;
            x: bind panel.layoutX;
            y: bind panel.layoutY;
            width: bind panel.layoutBounds.width;
            height: bind panel.layoutBounds.height;
        }
        def parentRect:Rectangle = Rectangle {
            fill: null;
            stroke: Color.BLUEVIOLET;
            strokeDashArray: [ 10 , 10]
            x: bind panel.boundsInParent.minX;
            y: bind panel.boundsInParent.minY;
            width: bind panel.boundsInParent.width;
            height: bind panel.boundsInParent.height;
        }
        def group = Group {
            content: [
                panel,
                //layoutRect,
                //parentRect
            ]
        }
    }
}
Stage {
    title: "Application title"
    scene: Scene {
        content: [
            Group {
                content: [
                    ui
                ]
            }
        ]
    }
}

[galien]

Salut Bouye,
J'ai été un peu vite dans mes affirmations plus haut, j'ai été aussi victime du même problème . Alors je te donne ma version du crime . Il semblerait que dans les layouts resizable à base de group, du moins H/VBox, j'ai pas testé le reste, le dernier élément de la séquence de nodes ne soit pas correctement recalculé en tout cas si son boundsInParent change. On peut voir ca avec les premiers TextBox qui ne font pas varié le positionnement du VBox interne.
Donc en résumé dès que l'on a des V/HBox imbriqués ça joue des castagnettes.
Le vaccin un peu bricolo du dimanche mais qui fonctionne d'est de rajouter un node bidon à la fin du groupe qui lui ne bouge pas, un Rectangle vide fait l'affaire par exemple.
Il reste quand même une inconnue, c'est que le bug n'apparait pas quand le panel n'est pas dans un Group (en commentaire), ça doit être un effet de bord du bug qui ne se montre pas dans ce cas.
N'étant pas trop sûr que mes explication soient trop claires ton code avec la modif:

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
88
89
90
91
92
 
def ui:VBox = VBox {
    spacing: 5;
    content: for (i in [0..3]) {
        def panel:VBox = VBox {
            spacing: 5;
            content: [
                Group {
                    def label:Label = Label {
                        layoutInfo: LayoutInfo { width: 75 }
                        text:##"Options {i+1}"
                    }
                    content: [
                        label,
                        Line {
                            startX: 0; startY: bind label.layoutBounds.maxY;
                            endX: bind label.layoutBounds.width; endY: bind label.layoutBounds.maxY;
                        }
                    ]
                }
                HBox {
                    spacing: 5;
                    nodeVPos: VPos.CENTER;
                    content: [
                        Label {
                            layoutInfo: LayoutInfo { width: 75 }
                            text:##"Name"
                        }
                        TextBox {
                            columns: 30
                            text: bind "je suis pas un problème"
                        }
                    ]
                }
                HBox {
                    spacing: 5;
                    nodeVPos: VPos.CENTER;
                    content: [
                        Label {
                            layoutInfo: LayoutInfo { width: 75 }
                            text:##"Name2"
                        }
                        TextBox {
                            columns: 30
                            text: "je suis pas un problème"
                        }
                    ]
                }
                HBox {
                    spacing: 5;
                    nodeVPos: VPos.CENTER;
                    content: [
                        Label {
                            layoutInfo: LayoutInfo { width: 75 }
                            text: ##"Password"
                        }
                        TextBox {
                            columns: 30
                            text: "je suis un problème si je suis le dernier"
                        }
                    ]
                }
                Rectangle {}//le petit dernier de la bande
            ]
        }
        def layoutRect:Rectangle = Rectangle {
            fill: null;
            stroke: Color.RED;
            x: bind panel.layoutX;
            y: bind panel.layoutY;
            width: bind panel.layoutBounds.width;
            height: bind panel.layoutBounds.height;
        }
        def parentRect:Rectangle = Rectangle {
            fill: null;
            stroke: Color.BLUEVIOLET;
            strokeDashArray: [ 10 , 10]
            x: bind panel.boundsInParent.minX;
            y: bind panel.boundsInParent.minY;
            width: bind panel.boundsInParent.width;
            height: bind panel.boundsInParent.height;
        }
//        panel//pas de bug
        Group {//bug si c'est dans un group
            content:  [
                panel,
//                layoutRect,
//                parentRect
            ]
        }
    }
}

[galien]

Comment change-t-on le titre du topic svp? Je voudrais remplacer 1.3 par 1.2.1, en effet dans la 1.3 on va voir arriver Prism qui est la nouvelle implémentation de SceneGraph, ça va encore être du sport et en 3D svp
Donc c'est plutôt la 1.2.1 qui risque de nous faire baisser la tension artérielle, si en plus on avait la change que les specs des layouts ne changent pas après

[galien]

@Fr3nchK1ss
Est ce que tu as des précisions ou un exemple du ramage en rafraichissement d'un Label ou Text par exemple, j'ai un peu le même genre de contraintes d'affichage, et plus que le temps de rafraîchissement c'est la conso mémoire qui me tourmente. En tout cas une chose sûre c'est qu'il faut binder avec parcimonie les textes.

[bouye]

Changement fait.

[Fr3nchK1ss]

@Fr3nchK1ss
Est ce que tu as des précisions ou un exemple du ramage en rafraichissement d'un Label ou Text par exemple, j'ai un peu le même genre de contraintes d'affichage, et plus que le temps de rafraîchissement c'est la conso mémoire qui me tourmente. En tout cas une chose sûre c'est qu'il faut binder avec parcimonie les textes.

Le contexte est le suivant, j'affiche quelques noeuds à l'écran, représentés par des petites formes géométriques en mouvement perpétuel. Lorsque l'on clique dessus, une fenêtre apparaît et affiche des données (sous forme de TextBox non-éditables) rafraichies toutes les secondes. C'est ce rafraichissement qui freeze le déplacement des noeuds et le reste de l'IHM par la même occasion. Voici un bout de code de cette fenêtre d'affichage, je passe par un trigger pour éviter le binding mais ça change rien du tout :

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
var posxField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
var posyField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
var capField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
var altField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
var pfField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
var identityField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
var vitField = TextBox { cache: true columns: FIELDS_WIDTH editable: false }
 
var m_trackID: Integer = -1 on replace {
	if (m_trackID != -1) {
		m_EVTempModel.m_title = "Données de la piste ID = {m_trackID}";
		updateFields(getTrackDataFromServer());
	}
}
 
function updateFields(data: String[]) : Void {
 
	pfField.text = TrackModel.plateform(Integer.intValue(data[0]));
	identityField.text = TrackModel.identity(Integer.intValue(data[1]));
 
	posxField.text = data[2];
	posyField.text = data[3];
	altField.text  = data[4];
	vitField.text  = data[5];
	capField.text  = data[6];
}

J'ai déjà bien tout vérifé, la récupération des données ne provoque pas le freeze, seules les lignes telles que "posxField.text = data[2];" provoquent un freeze. Le problème intervient tout le temps, quelque soit le nombre de noeuds. C'est encore plus visible avec très peu de noeuds, car on voit bien le freeze en plein milieu du déplacement super fuilde.

[galien]

@Bouye, merci
@Fr3nchK1ss, pourquoi le cache à true? A priori ca n'optimize seulement si le composant ne change pas, la si tu met à jour le texte il faut recalculer la bitmap en backend, c'est peut être cela. Si c'est pas ca un mécanisme de cache avec deux TextBoxs pourrait amélioré les choses, et la la valeur cache peut être utile.

[galien]

Re, FrenchKiss
Comment le rafraichissement est-il appelé, par un TimeLine? il faut prendre garde à la valeur canSkip, de plus TimeLine execute les taches dans L'EDT, ton code de récecption des datas tourne dedans à moins d'utiliser une tache asynchrone. Il y a celles de l'API, mais perso je trouve celle de JFXtras très pratique. As tu un bout de code pour faire tourner un test?

[Fr3nchK1ss]

@galien
D'abord, merci pour tes suggestions. Ensuite, non les valeurs cache à true je les ai rajoutées aujourd'hui pour tester, avec ou sans il n'y a pas de différence.
Pour le rafraîchissement, j'utilise bien des Timeline pour l'ensemble des tâches cycliques de mon application. Sûrement que les Timeline s'entrecroisent et se bloquent les unes les autres... mais comme dit précédemment, la récupération des données n'engendre pas de freeze, seule la mise à jour des composants graphiques le fait.
Pour ce qui est d'un bout de code, mon appli est assez grosse (j'avoisine les 12 000 lignes de code JavaFx là), j'utilise énormément de classes développées moi-même (je me suis codé un framework perso pour créer facilement une appli suivant des specs bien précises, avec CSS et tout). J'vais reprendre mes tests unitaires et voir si j'arrive à isoler un bon exemple, mais c'est pas garanti ^^.

[galien]

@FrenchKiss,
Bon pour me frotter au path j'ai essayé quelque chose avec les textbox animés et rafraichis, c'est dans ce gout la?

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
/**
 * @author Alex
 */
 
public class TextBoxDansant extends CustomNode {
 
    public-init var width: Number = 120;
    public-init var height: Number = 30;
    public-init var name: String = "Schumi";
    var tb: TextBox;
    override public function create(): Node {
        Stack {
            content: [
                Rectangle {
//                    cache: true
                    width: width height: height
                    arcWidth: 10 arcHeight: 10
//                    fill: Color.BLACK
                    fill: LinearGradient {
                        startX : 0.0
                        startY : 0.0 endX : .0
                        endY : 1.0
                        stops: [
                            Stop {
                                color : Color.GRAY
                                offset: 0.0
                            },
                            Stop {
                                color : Color.BLACK
                                offset: .49
                            },
                            Stop {
                                color : Color.BLACK
                                offset: .51
                            },
                            Stop {
                                color : Color.GRAY
                                offset: 1.
                            }
                        ]
                    }
                }
                VBox {
                    spacing: 2
                    hpos: HPos.CENTER
                    vpos: VPos.CENTER
                    nodeHPos: HPos.CENTER
                    content: [
                        Label {
                            textFill: Color.ORANGE
                            text: name
                            font: Font.font("Arial bold", 11)
                        }
 
                        tb = TextBox {
                            font: Font.font("Arial", 10)
                            layoutInfo: LayoutInfo {
                                width: width -10
                                height: 18
                            }
 
                        }
                    ]
                }
 
            ]
        }
 
    }
    function update() {
        def cal = Calendar.getInstance();
        tb.text = "{%tT cal}.{cal.get(Calendar.MILLISECOND)}"
    }
 
}
function runChrono(tbd: TextBoxDansant) {
    Timeline {
        repeatCount: Timeline.INDEFINITE
        keyFrames: KeyFrame {
            canSkip: true
            time: .1s;
            action: function(): Void {
                tbd.update()
            }
        }
    }.playFromStart();
}
function run() {
    def drivers = [
        "Hamilton",
        "Button",
        "Vettel",
        "Alonso",
        "Badoer",
        "Weber",
        "Kubica",
        "Rosberg",
        "Bourdais"
    ];
    def S=2; def W = 90; def H = 40;
    def path = [
        MoveTo       {         x:  50*S         y: 212*S },
        LineTo       {         x:  80*S         y: 128*S },
        QuadCurveTo  {  controlX:  82*S  controlY: 123*S
                               x:  98*S         y: 124*S },
        LineTo       {         x: 107*S         y: 127*S },
        CubicCurveTo { controlX1: 148*S controlY1: 147*S
                       controlX2:  56*S controlY2: 225*S
                               x: 120*S         y: 254*S },
        LineTo       {         x: 141*S         y: 267*S },
        CubicCurveTo { controlX1: 154*S controlY1: 277*S
                       controlX2: 143*S controlY2: 300*S
                               x: 131*S         y: 295*S },
        LineTo       {         x:  84*S         y: 278*S },
        QuadCurveTo  {  controlX:  34*S  controlY: 255*S
                               x:  43*S         y: 231*S },
        LineTo       {         x:  50*S         y: 212*S },
        ClosePath {},
    ];
    def tbds: TextBoxDansant[] = for (driver in drivers) TextBoxDansant{
        width: W height: H name: driver
        translateX: -50 translateY: 300 + indexof driver *( H + 10)
    };
 
    def track = Path {
        stroke: Color.DARKGRAY
        strokeWidth: 20*S
        elements: path
    };
 
    def line = Path {
        stroke: Color.WHITE
        strokeWidth: 2
        strokeDashArray: [ 20, 15 ]
        elements: path
    };
    def startLines = for (tbd in tbds) ShapeIntersect {
        def _tmp_init = tbd.update();
        a: Rectangle {
            x: 0 y: tbd.translateY + H/2-1
            width: tbd.translateX height: 2
        }
        b: track
        fill: Color.TRANSPARENT
    }
    def pathAnims: PathTransition[] = for(tbd in tbds) PathTransition {
        node: tbd
        path: AnimationPath.createFromPath(track)
        orientation: OrientationType.NONE
        interpolator: Interpolator.LINEAR
        duration: 10s
        repeatCount: Timeline.INDEFINITE
    }
    def finishLine  = Timeline {
        keyFrames: for (tbd in tbds) KeyFrame {
            def _n = indexof tbd;
            time: _n*.5s;
            action: function(): Void {
                pathAnims[_n].stop();
            }
            values: [
            ]
        }
    }     
    Stage {
        title : "TB Chanpionship"
        scene: Scene {
            width: 550
            height: 600
            content: [
                Rectangle {
                    width: 600
                    height: 600
                    fill: Color.GREEN
                }
                HBox {
                    spacing: 50
                    hpos: HPos.CENTER
                    content: [
                        Button {
                            text: "Start"
                            action: function() {
                                Timeline {
 
                                    keyFrames: for (tbd in tbds) KeyFrame {
                                        def n = indexof tbd;
//                                        def _tbd = tbd;
//                                        def bounds = startLines[n].boundsInLocal;
                                        time: n*1s;
                                        action: function(): Void {
                                            pathAnims[n].playFromStart();
                                            runChrono(tbd);
                                        }
//                                        values: [
//                                            _tbd.translateX => bounds.maxX - W/2
//                                        ]
                                    }
 
                                }.playFromStart();
 
                            }
                        }
                        Button {
                            text: "Stop"
                            action: function() {
                                finishLine.playFromStart();
                            }
                        }
                    ]
                }
 
                Group {
                    translateX: 80
                    translateY: -200
                    content: [
                        startLines,
                        track,
                        line,
                        tbds                        
                    ]
                }
 
            ]
        }
    }
}

[Fr3nchK1ss]

@galien
Ca ressemble à ça sauf que je n'utilise pas de Path. Chaque seconde je reçois une liste de nouvelles coordonnées via un web service et j'effectue un Timeline de mouvement sur chacun de mes objets. Voici ma fonction de rafraichissement:

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 function refreshTracks(): Void {
 
	var tracks = m_tracksControl.getTrackListFromServer();
 
	var newTrackModel:TrackModel;
	var trackNode:TrackNode;
	var id;
	var stringTrack: String;
 
	for (track in tracks) {
 
		stringTrack = track as String;
		id = m_tracksControl.getIDFromTrack(stringTrack);
		trackNode = getTrackNode(id);
		var tmpPos = m_tracksControl.getPosFromTrack(stringTrack);
 
		// On teste si la piste est nouvelle. Si oui, on l'ajoute à la liste.
		if (trackNode == null) {
 
			newTrackModel = TrackModel {
				m_ID: id,
				m_pf: m_tracksControl.getPfFromTrack(stringTrack),
				m_iden: m_tracksControl.getIdenFromTrack(stringTrack),
				m_posX: tmpPos[0],
				m_posY: tmpPos[1],
				m_alt: tmpPos[2]};
			trackNode = TrackNode { m_theTrackModel: newTrackModel };
			insert trackNode into m_trackNodeList;
		} // Sinon on met à jour les données de la piste associée à l'ID.
		else {
			// On anime la piste.
			var anim = Timeline {
				repeatCount: 1
				keyFrames : [
					at(1s) {
						trackNode.track.translateX => tmpPos[0] tween Interpolator.LINEAR;
						trackNode.descri.x => tmpPos[0] tween Interpolator.LINEAR;
						trackNode.track.translateY => tmpPos[1] tween Interpolator.LINEAR;
						trackNode.descri.y => tmpPos[1] tween Interpolator.LINEAR;
					}
				]
			}
			anim.play();
		}
	}
}

Un de mes objectifs initiaux est d'en mettre plein la tronche au langage pour voir ce qu'il a dans le ventre. Mais je me demande pourquoi une pauvre mise à jour d'une textbox vient freeze ce bout de code là (et toute l'IHM par la même occasion), qui lui tient les perf à l'aise (j'peux en envoyer 400 facile en parallèle).

[Fr3nchK1ss]

Sinon, quelqu'un a-t-il eu vent d'une date de sortie pour la version 1.2.1 du SDK?