Comment trouver l'instance lorsque le redimensionnement du composant est terminé

Question

Dans mon application, j'obtiens des données si le composant est redimensionné. Je veux retarder la récupération jusqu'à ce que l'utilisateur termine l'opération de redimensionnement. ComponentListener événement componentResized se déclenche chaque fois que la fenêtre est redimensionnée.

Answer 1

Je dirais que vous écrivez propably une application de cartographie quelconque? :-)

Vous pouvez utiliser la classe Timer swing pour attendre la fin d'une durée spécifiée sans événement. Voici le code:

/** Time to wait */ 
private final int DELAY = 1000; 
/** Waiting timer */ 
private javax.swing.Timer waitingTimer; 

/** 
* Handle resize event. 
*/ 
public void componentResized(ComponentEvent e) 
{ 
    if (this.waitingTimer==null) 
    { 
    /* Start waiting for DELAY to elapse. */ 
    this.waitingTimer = new Timer(DELAY,this); 
    this.waitingTimer.start(); 
    } 
    else 
    { 
    /* Event came too soon, swallow it by resetting the timer.. */ 
    this.waitingTimer.restart(); 
    } 
} 

/** 
* Actual resize method 
*/ 
public void applyResize() 
{ 
    //... 
} 

/** 
* Handle waitingTimer event 
*/ 
public void actionPerformed(ActionEvent ae) 
{ 
    /* Timer finished? */ 
    if (ae.getSource()==this.waitingTimer) 
    { 
    /* Stop timer */ 
    this.waitingTimer.stop(); 
    this.waitingTimer = null; 
    /* Resize */ 
    this.applyResize(); 
    } 
} 

Answer 2

Ceci n'est pas possible. Mais vous pouvez utiliser SingleWorkerThread pour minimiser le nombre d'événements traités.

Answer 3

Ce n'est pas possible par des moyens conventionnels, j'en ai peur. componentResized() sera appelée pour chaque changement de taille intermédiaire, et il n'y a aucun moyen de déterminer si l'appel en cours sera le dernier.

Strictement parlant, ce que vous essayez n'est pas une chose conventionnelle à faire. Les charges de données peuvent être des opérations d'E/S coûteuses et sont généralement mieux exécutées lorsque l'utilisateur les attend après une opération d'interface utilisateur plus directe, telle qu'un appui sur un bouton, lorsqu'une rétroaction appropriée peut être affichée suite à leur action. La taille d'un composant peut changer pour des raisons innocentes telles que le cadre étant agrandi ou arrangé suite à une opération ailleurs, comme les nouvelles opérations Aero dans Windows 7.

Certaines applications font de dimensionnement. Google Reader, par exemple, peut charger des messages plus anciens à partir de flux RSS à la suite du déplacement de la barre de défilement dans la fenêtre du navigateur. Ceci est une fonctionnalité intéressante, et supprime le besoin d'un bouton de chargement explicite, mais il est directement piloté par l'utilisateur qui cherche les messages plus anciens; une action consciente, pas inconsciente.

Je suppose que mon point est que vous devez être très prudent sur la façon dont vous faites ce travail. Punir un utilisateur avec une opération d'E/S lente qui le fait attendre simplement parce qu'il a osé redimensionner la fenêtre n'est pas une approche conviviale! Vous donnez peu d'informations précieuses dans votre question sur l'apparence de votre interface utilisateur, sur le composant ou son redimensionnement, même lorsque vous chargez des données. Il est donc difficile de répondre. Voici quelques suggestions: j'espère qu'ils vous aideront.

1. Chargez les données en mémoire au préalable, et afficher juste
Si le modèle de données ne sont pas trop grand, vous pouvez le charger en mémoire, et redessiner rapidement chaque événement redimensionner. Event-Dispatch-Thread combinera les événements de redimensionnement ensemble afin que votre écouteur ne soit pas submergé par les demandes. Cela pourrait être un non-démarreur pour vous, mais il vaut la peine de mentionner.

2. désireux de charger
charge plus de données que vous avez besoin sur le premier événement resize, puis rejeter ou mettre en cache les données que vous n'utilisez pas. Si vous remplissez les lignes d'une table ou d'une liste, cela pourrait être la meilleure approche. Les données tabulaires sont généralement simples à charger et à analyser.

3. Laissez un délai raisonnable pour passer pour le redimensionnement pour arrêter
Le premier événement resize démarre une minuterie avec 1 seconde compte à rebours. Tous les événements de redimensionnement suivants réinitialisent le compte à rebours de 1 seconde. À un moment donné, il y aura un événement de redimensionnement final après lequel aucun événement de redimensionnement ultérieur ne réinitialisera le compte à rebours pour qu'il expire. À ce stade, la minuterie fait votre charge pour vous.

Trois est l'approche la plus sûre et la plus précise, à mon avis. Vous pouvez faire en sorte que votre application soit sensible en indiquant visiblement que les données sont en cours de chargement lors du premier événement de redimensionnement, et ajuster le compte à rebours de la minuterie pour que la sensation de votre application soit correcte.