Remarques relatives au traitement multiple

Lors de l'utilisation d'un toolkit de widget, il est important de comprendre le modèle de traitement sous-jacent utilisé pour la lecture et la distribution des événements de l'interface utilisateur de la plate-forme. L'implémentation de l'unité d'exécution de l'interface utilisateur affecte les règles que les applications doivent suivre lors de l'utilisation d'unités d'exécution Java dans leur code.

Distribution des événements natifs

Sous toute application de l'interface graphique, quel que soit le langage ou le toolkit utilisé, la plate-forme du système d'exploitation détecte les événements de l'interface graphique et les place dans les files d'événements de l'application. Bien que les mécanismes soient légèrement différents sur les plates-formes d'un système d'exploitation à l'autre, les bases sont similaires. Lorsque l'utilisateur clique à l'aide d'un bouton de la souris, saisit des caractères ou trace des fenêtres, le système d'exploitation génère des événements de l'interface graphique d'application, tels que des clics de souris, des séquences de touches ou des événements de traçage de fenêtre. Cela détermine quelle fenêtre et application doivent recevoir chaque événement et le place dans la file d'événements de l'application.

La structure sous-jacente de toute application de l'interface graphique fenêtrée est une boucle d'événements. Les applications initialisent, puis démarrent une boucle qui lit tout simplement les événements de l'interface graphique dans la file et réagit en fonction. Tout travail effectué pendant le traitement de l'un de ces événements doit avoir lieu rapidement afin que le système de l'interface graphique puisse répondre à l'utilisateur.

Les opérations longues déclenchées par les événements de l'interface graphique doivent être effectuées dans une unité d'exécution distincte afin de permettre à l'unité d'exécution de la boucle d'événements de renvoyer rapidement les données et d'extraire l'événement suivant de la file de l'application. Cependant, l'accès à l'API de la plate-forme et des widgets à partir d'autres unités d'exécution doit être contrôlé par un verrouillage et une sérialisation explicites. Une application qui ne parvient pas à suivre les règles peut entraîner l'échec d'un appel du système d'exploitation, ou pire encore, le verrouillage de tout le système de l'interface graphique.

Unité d'exécution de l'interface utilisateur SWT

SWT suit le modèle d'utilisation d'unité d'exécution supporté directement par les plates-formes. Le programme d'application exécute la boucle d'événements dans son unité d'exécution principale et distribue les événements directement à partir de cette unité d'exécution. L'unité d'exécution de l'interface utilisateur est l'unité d'exécution dans laquelle l'affichage a été créé. Tous les autres widgets doivent être créés dans l'unité d'exécution de l'interface utilisateur.

La totalité du code d'événement étant déclenchée à partir de l'unité d'exécution de l'interface utilisateur de l'application, le code d'application traitant les événements peut librement accéder aux widgets et effectuer des appels graphiques sans aucune technique spéciale. Cependant, l'application est responsable du processus parallèle des unités d'exécution de calcul lors d'opérations longues répondant à un événement.

Remarque : SWT déclenche une exception SWTException pour tous les appels effectués à partir d'une unité d'exécution de l'interface utilisateur.

L'unité d'exécution principale, dont la boucle d'événements, d'une application SWT ressemble à ce qui suit :

   public static void main(String[] args) {
      Display display = new Display ();
      Shell shell = new Shell (display);
      shell.open ();
      // lance la boucle d'événements. Arrêt lorsque l'utilisateur
      // a agi pour quitter la fenêtre.
      while (!shell.isDisposed ()) {
         if (!display.readAndDispatch())
            display.sleep();
      }
      display.dispose ();
   }

Une fois les widgets créés et le shell ouvert, l'application lit et distribue les événements de la file du système d'exploitation jusqu'à ce que la fenêtre shell soit disposée. Si aucun événement n'est disponible pour nous dans la file, nous ordonnons à l'affichage de passer en attente afin que d'autres applications puissent s'exécuter.

SWT fournit des méthodes d'accès spéciales pour appeler le code des graphiques et des widgets à partir d'une unité d'exécution en arrière-plan.

Exécution du code à partir d'une unité d'exécution sans interface utilisateur

Les applications souhaitant appeler un code de l'interface utilisateur à partir d'une unité d'exécution sans interface utilisateur doivent fournit un exécutable qui appelle le code de l'interface utilisateur. Les méthodes syncExec(Runnable) et asyncExec(Runnable) de la classe Affichage sont utilisées pour exécuter ces exécutables dans l'unité d'exécution de l'interface utilisateur pendant la boucle d'événements.

Le fragment de code ci-après illustre le schéma d'utilisation de ces méthodes :

   // effectue des calculs intensifs
   ...
   // met à jour l'interface graphique. ne dépend pas du résultat,
   // d'où l'utilisation d'async.
   display.asyncExec (new Runnable () {
      public void run() {
         if (!myWindow.isDisposed())
            myWindow.redraw();
      }
   });
   // calculs terminés
   ...

Il est recommandé de contrôler si votre widget est supprimé de l'exécutable lors de l'utilisation de asyncExec. Etant donné que d'autres événements peuvent se produire dans l'unité d'exécution de l'interface utilisateur entre l'appel vers asyncExec et l'exécution de votre exécutable, vous ne pouvez jamais être certain de l'état de vos widgets au moment où votre exécutable s'exécute.

Le plan de travail et les unités d'exécution

Les règles d'utilisation d'unités d'exécution sont très claires lorsque vous implémentez une application SWT dès son fondement, car vous contrôlez la création de la boucle d'événements et la décision de séparer les unités d'exécution de calculs en processus parallèles dans votre application.

Les choses se compliquent lorsque vous attribuez un code de plug-in au plan de travail. Les règles suivantes sont considérées comme des "règles d'engagement" lors de l'utilisation des classes d'interface utilisateur de la plate-forme, bien que d'une version à une autre, des exceptions à ces règles peuvent exister :