[débutant] Redimensionner avec SWT standalone

Bonjour, :oops:

J'ai créé une application avec des composites imbriqués.
Le tout est contrôlé par des GridLayout.

Lorsque je lance l'appli tout fonctionne bien jusqu'au moment où j'agrandis la fenêtre. A ce moment là tout disparaît.
Pas de code, ca le fait systématiquement.
De la lecture du forum et de l'aide sur les classes SWT, Je déduis que j'ai zappé un truc simple et j'espère que quelqu'un pourra me dire quoi.

D'avance merci :)

re :)

Une précision, car ca a une importance. En fait, c'est même crucial :
Mon appli est faite d'une successions de composites, que j'enchaine.
Mon composite principal (celui qui est créé au démarrage) fonctionne bien .
Sur cette forme, un bouton permet de créer le composite suivant, qui prend alors la place du premier sur la fenêtre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class Principale extends composite {
	...
	/**
         * Démarrer la gestion règlementaire.
         */
	void gestionReglementaire() {
		setVisible(false);
		new GestionReglementaire(this, getParent(),SWT.NONE);
	}
 
	...
}

GestionReglementaire est une classe dérivée plus ou moins directement de la classe Suivante, qui définit le comportement à la fermeture du composite. Lorsque l'utilisateur clique sur le bouton "Précédent", le composite "Precedent" est réaffiché (setVisible), puis celui-ci détruit. Ce comportement me permet de réutiliser cette fonction (je vais avoir une cinquantaine de vues devant s'enchainer comme cela).

Code:

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
 
public abstract class Suivante extends Composite {
	private Suivante precedent = null;
	protected Button bnPrecedent = null;
 
	/**
         * Constructeur à utiliser pour les fenêtres qui n'ont pas de précédente.
         * Dans ce cas, le bouton est simplement désactivé et la fonctionnalité inutilisée.
         * @param parent Composite dans lequel la fenêtre sera construite (peut être un shell).
         * @param style Style de la fenêtre. La plupart du temps SWT.NONE.
         */
	public Suivante(Composite parent, int style) {
		super(parent, style);
		initialize();
	}
 
	/**
         * Constructeur pour les fenêtres qui doivent avoir un précédent.
         * @param precedent Fenêtre qui sera activée automatiquement à la fermeture de celle-ci. Si ce paramètre est null, alors la fonctionnalité est désactivée.
         * @param parent Composite dans lequel la fenêtre est dessinée.
         * @param style Style de la fenêtre. La plupart du temps SWT.NONE.
         */
	public Suivante(Suivante precedent, Composite parent, int style) {
		super(parent, style);
		this.precedent = precedent;
		initialize();
	}
 
	/**
         * This method initializes this
         */
	private void initialize() {
		setBounds(getShell().getClientArea());
		bnPrecedent = new Button(this, SWT.LEFT);
		bnPrecedent.setBounds(new Rectangle(10, 83, 133, 23));
		bnPrecedent.setText("Précédent");
		bnPrecedent.setVisible(precedent != null);
		bnPrecedent.setEnabled(precedent != null);
		bnPrecedent.addSelectionListener(new org.eclipse.swt.events.SelectionAdapter() {
			public void widgetSelected(org.eclipse.swt.events.SelectionEvent e) {
				doPrecedent();
			}
		});
	}
 
	/**
         * Cette fonction effectue le retour vers la fenêtre précédente.
         * Evidemment elle demande dabord l'autorisation. Si celle-ci lui est refusée, alors l'action n'est pas réalisée.
         */
	private void doPrecedent() {
		if (peutRetourner()) {
			doAvantRetour();
			setVisible(false);
			precedent.setVisible(true);
			getShell().setText(precedent.getTitre());
			doAprèsRetour();
			dispose();
		}
	}
 
	/**
         * Cette fonction réserve la possibilité d'effectuer des actions encore avant le retour.
         */
	protected void doAvantRetour() {}
 
	/**
         * Cette fonction réserve la possibilité d'effectuer des actions encore après le retour (libération de certaines ressources en particulier).
         */
	protected void doAprèsRetour() {}
 
	/**
         * 
         * @return vrai si aucun obstacle ne se présente pour le retour.
         */
	protected boolean peutRetourner() {return true;}
 
}

Tout fonctionne parfaitement tant qu'on n'essaye pas de redimensionner la fenêtre. Ca se comporte alors comme si on dessinait tous les composites successifs l'un après l'autre (comme dans un RowGrid). Comme les précédents sont invisibles, on obtient une zone cliente de l'appli vide.

Quelqu'un pourrait-il me dire comment faire pour que lorsqu'on redimensionne la fenêtre, la position actuelle du composite dans l'aire cliente du shell soit respectée?

D'avance merci.

re :oops: encore!!

Mais bon, j'ai trouvé la solution :

Il suffisait de piéger l'évènement de redimensionnement et d'y repositionner correctement le composite :p

Comme je le pensais, la solution est triviale.
Peu-être une meilleure possible (en effet, mes composites sont affichés deux fois, ce qui provoque un léger flash) ?

A bientôt :D