How come allegro automatically handles minimize button, but not close button?

Here is a sample from Allegro5 tutorial: (to see the original sample, follow the link, I've simplified it a bit for illustratory purposes.

#include <allegro5/allegro.h>

int main(int argc, char **argv)
{
   ALLEGRO_DISPLAY *display = NULL;
   ALLEGRO_EVENT_QUEUE *event_queue = NULL;
   al_init()
   display = al_create_display(640, 480);
   event_queue = al_create_event_queue();
   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;
}

If I don't manually check for the ALLEGRO_EVENT_DISPLAY_CLOSE, then I can't close the window开发者_高级运维 or terminate the program (without killing the process through task manager). I understand this. But in this case I don't understand how the minimize button works without me manually handling it. Can someone please explain?

Disclaimer: I don't know Allegro.

Minimizing a window at the most basic level only involves work from the process that deals with the windows (the Window Manager), not the process itself. Terminating a program, usually requires files to be closed or memory to be freed or something else that only the process itself can do.

The biggest reason that you must handle it yourself via an event is that closing (destroying) a window invalidates the ALLEGRO_DISPLAY * pointer. The request to terminate the window comes from a different thread, so it would be unsafe to destroy it immediately. Allowing you to process it yourself on your own time is safe and easy, and fits in with the event model that Allegro 5 uses for all other things.

There are other ways to solve the problem, but they are no more simple than this method and don't really have any major advantages.

I don't know anything about allegro, but minimizing windows is generally handled by the window manager without the need of further intervention by your program. The main window is set to a "minimized"-state and your program continues running in the background without a visible window.

You can check if your app is being minized by intercepting specific window-messages (those being WM_ACTIVATEAPP, WM_ACTIVATE or WM_SIZE). Maybe allegro provides something like that, too.

In contrast closing the window does need to be done by your program. Clicking on the X simply sends a message to the window (WM_CLOSE), that the user has clicked it, and you have to respond accordingly (save states, quit the program, or you could prevent it).

At least that's how the normal winapi works, and allegro seems to work the same way.