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.

==== Basic Example ====

Extending on the previous example, we will create a program that lets you exit by pressing the X (close) button on the example's window.

<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;

   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)
   {
      ALLEGRO_EVENT ev;
      ALLEGRO_TIMEOUT timeout;
      al_init_timeout(&timeout, 0.06);
      
      bool 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>

==== Walk through ====

This walk through includes code from the previous Display example. Refer to the previous tutorial's walk through for information on code that is not explained here.

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

**al_create_event_queue** will return a new **ALLEGRO_EVENT_QUEUE** object. Should this function fail, it will return **NULL**. While failure is unlikely in this simple example, you are better off checking every single function that could fail for any errors. You may have fewer hidden problems when the program becomes more complicated.

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

Here we actually tie the Display to the event queue so we can be informed of events from the display such as the //close event//. Without this function call, the display events will not be placed in this queue and thus will not be handled.

<code c>   ALLEGRO_TIMEOUT timeout;
   al_init_timeout(&timeout, 0.06);
</code>
**al_init_timeout** initializes a previously defined **ALLEGRO_TIMEOUT** object. In this case we are initializing it to 0.06 seconds from now, or 60 milliseconds in the future.

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

We tell Allegro to wait till an event arrives, or until the time out defined previously has elapsed, which ever occurs first. **al_wait_for_event_until** will return false if it didn't return an event before the timeout.

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

Here we check if we received an event in the event queue. If it is a Display //close event//, we break out of the program loop.

That concludes our basic introduction to Events in Allegro.

[[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
