Mr-Hide's Wiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
===== Events =====


Dans cet article nous vous expliquerons les events, et comment fonctionnent les events avec Allegro.

==== Que sont les Events? ====

Les events vus préviennent que quelque chose s'est passé dans votre programme comme l'appui sur une touche, le mouvement de la souris, un tick du timer, et la synchronisation du display. Allegro les utilises pour vous transmettre tout les types d'évènements, et vous pouvez créer votre propres events.

==== Pourquoi en ai-je besoin? ====

Le système de queue d'évènements d'Allegro est la manière la plus efficace de gérer les events; Il vous suffit simplement d'attendre les nouveaux events et de les traiter quand ils arrivent. Une méthode alternative utilise les requêtes, regardant constamment si un event survient. Le système d'évènement demande bien moins de ressources processeur que la technique avec les requêtes.

==== Sources d'events ====
Une source d'events est une entité qui prévient le programme que quelque chose s'est produit. Il y a plusieurs sources standards d'events, par exemple les Timers, Displays, et Inputs.

==== La queue d'events ====

Une queue d'events, c'est là que sont placés les events en attente de traitement, il s'agit d'une file FIFO (first-in-first-out). Vous pouvez créer différents queues et diriger la source d'events vers la (ou les) bonne(s) queue(s). Cependant, utiliser une seule queue est la méthode la plus simple.

==== Exemple basique ====

Il étend l'exemple de la page précédente, le programme permettra de quitter en cliquant sur la croix X (close) en haut de la fenêtre.

<file c main.c>
#include <stdio.h>
#include <allegro5/allegro.h>
 
int main(int argc, char **argv)
{
   ALLEGRO_DISPLAY *display = NULL;
   ALLEGRO_EVENT_QUEUE *event_queue = NULL;
   ALLEGRO_EVENT ev;
   ALLEGRO_TIMEOUT timeout;
   bool get_event;

   if(!al_init()) {
      fprintf(stderr, "failed to initialize allegro!\n");
      return -1;
   }

   display = al_create_display(640, 480);
   if(!display) {
      fprintf(stderr, "failed to create display!\n");
      return -1;
   }

   event_queue = al_create_event_queue();
   if(!event_queue) {
      fprintf(stderr, "failed to create event_queue!\n");
      al_destroy_display(display);
      return -1;
   }
 
   al_register_event_source(event_queue, al_get_display_event_source(display));

   al_clear_to_color(al_map_rgb(0,0,0));
 
   al_flip_display();
 
   while(1)
   {
      al_init_timeout(&timeout, 0.06);
      
      get_event = al_wait_for_event_until(event_queue, &ev, &timeout);

      if(get_event && ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
         break;
      }

      al_clear_to_color(al_map_rgb(0,0,0));
      al_flip_display();
   }
 
   al_destroy_display(display);
   al_destroy_event_queue(event_queue);

   return 0;
}
</file>

==== Détails ====

<code c>   event_queue = al_create_event_queue();</code>

**al_create_event_queue** retourne un objet de type **ALLEGRO_EVENT_QUEUE**. En cas d'échec elle renvoi **NULL**. Cette fonction a peu de chances d'échouer dans ce programme, nous recommandons tout de même de tester la valeur renvoyée, en effet, vous pourrez avoir des soucis lorsque le programme devient plus compliqué.

<code c>   al_register_event_source(event_queue, al_get_display_event_source(display));</code>

Ici nous dirigeons le Display vers notre queue de manière à être informé des event comme le //close event//. Sans l'appel à cette fonction, les events liés au display ne seront pas placés dans cette queue et ne seront pas traités.

<code c>   ALLEGRO_TIMEOUT timeout;
   al_init_timeout(&timeout, 0.06);
</code>
**al_init_timeout** initialise un objet **ALLEGRO_TIMEOUT**, ici à 0.06 secondes, soit 60 millisecondes.

<code c>      bool got_event = al_wait_for_event_until(event_queue, &ev, &timeout);</code>

Nous demandons à Allegro d'attendre un events, ou que le temps défini soit écoulé. **al_wait_for_event_until** renverra **false** si aucun event est déclenché avant que le temps soit écoulé.

<code c>      if(get_event && ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
         break;
      }
</code>

Ici on vérifié si nous avons un event dans la queu. Si c'est un Display //close event//, on break la boucle du programme.

Ici s'achève notre article sur les events d'Allegro 5. 

[[allegro:display|Précédent]] << [[allegro:start|Sommaire]] >> [[allegro:timers|Suivant]]
Mr-Hide's Wiki

Outils pour utilisateurs

Outils du site

Outils de la page
