WaitPort(Window->UserPort);

Wait(1L << Win->UserPort->mp_SigBit);

/***************************************************
*   fenêtre Intuition et timer.device              *
*        par D. GENOT                              *
*   opt : -L                                       *
***************************************************/

#include <exec/types.h>
#include <exec/memory.h>
#include <intuition/intuition.h>
#include <graphics/text.h>
#include <graphics/gfxbase.h>
#include <graphics/rastport.h>
#include <devices/timer.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

/**********************
*     define          *
**********************/
#define WLARG 640
#define WHAUT 240

#define RP Window->RPort

/*********************
*   structures       *
*********************/
struct IntuitionBase *IntuitionBase=NULL;
struct GfxBase *GfxBase=NULL;
struct Screen *Screen=NULL;
struct Window *Window=NULL;
struct IntuiMessage *msg;

struct timerequest *tr=NULL;  /* timer Request   */
struct timeval *time;   /* délai d'attente */
struct MsgPort *tport;  /* pour signaux    */

LONG T_Dev;             /* device ouvert ? */

extern struct Window *OpenWindow();  
extern struct Screen *OpenScreen();

/********************
*  declarations     *
********************/
void openall();
void cleanexit();
void PrintIT(struct IntuiText *,int,int);

void attente();

/*********************************
* variables : nombres et chaines *
*********************************/

ULONG classe;       /* IDCMP */
USHORT code;        /* keys  */

char s[201];       /* pour 'storage' des messages */

/*********************************
*  structures                    *
*********************************/

struct TextAttr Font=
	{
	"topaz.font",8,	/* nom + hauteur */
	0,0				/* style + flags */
	};

struct NewScreen NewScreen=    /* def. et init. immediate */
  	{
	0,0,           /*  sommet gche , haut */
	640,256,       /* largeur et hauteur */
	3,             /* nbre de plans de bits  */
	0,1,           /*    couleurs        */ 
	HIRES,         /*      mode          */
	CUSTOMSCREEN,  /*      type          */
	&Font,          /*  fontes perso      */
	"   @ D. G. SoftWare 1991 , Programmation d'une ANIM...  ",/* titre */
	NULL,          /*   gadgets          */
	NULL          /*     bitmap         */
	}; 

struct NewWindow NewWindow=
{
0,				/* LeftEdge */
12,				/* TopEdge  */
WLARG,			/* Width    */
WHAUT,			/* Height   */
4,6,				/* DetailPen,BlockPen */
CLOSEWINDOW | VANILLAKEY ,/* IDCMPFflags */
SMART_REFRESH | ACTIVATE |
 NOCAREREFRESH | WINDOWCLOSE | BORDERLESS |
 SIZEBRIGHT |
 RMBTRAP ,		/* flags    */
 
 /******** RMBTRAP est nécessaire pour timer.device qui bloque 
           sinon à l'appui de R Mouse ...       *************/
           
NULL,			/* first gadget       */
NULL,			/* check mark         */
NULL,			 /* titre */
NULL,			  /* pteur ecran perso ouvert */
NULL,			/* bitmap   */
80,25,			/* MinWidth , MinHeight */
640,256,			/* MaxWidth , MaxHeight */
CUSTOMSCREEN		/* type */
};

struct IntuiText bleu=
{6,0,JAM2,0,0,0,&s[0],NULL};		/* en bleu pale */

struct IntuiText rouge=
{3,0,JAM2,0,0,0,&s[0],NULL};		/* en rouge */

USHORT couleurs[8]=
{0x334,0xfff,0x000,0xf80,0x00f,0x0f0,0x0ff,0xf5f};
/* gris,blanc,noir,orange,bleu f,vert,bleu c,rose */
/*  0  ,  1  ,  2  ,  3  ,  4   ,  5 ,  6   ,  7  */

/******* routines ***********************/

void PrintIT(texte,ab,or)
struct IntuiText *texte;
int ab,or;
{
	PrintIText(RP,texte,(SHORT)ab,(SHORT)or);
}

void cleanexit()
{
if( !T_Dev )
   CloseDevice((struct IORequest *)tr);
if( tr )
   DeleteExtIO(tr);
if( tport )
   DeletePort(tport);
if( time )
   FreeMem(time,sizeof(struct timeval));
if(Window)
	CloseWindow(Window);
if(Screen)
	CloseScreen(Screen);
if(IntuitionBase)
	CloseLibrary((struct Library *)IntuitionBase);
if(GfxBase)
	CloseLibrary((struct Library *)GfxBase);
exit(0);
}

void openall()
{
   
 IntuitionBase=(struct IntuitionBase *)
	OpenLibrary("intuition.library",0);
 if (IntuitionBase==NULL)
 	exit(0);

 if((GfxBase=(struct GfxBase *)
	OpenLibrary("graphics.library",0))==NULL)
	cleanexit();

 if ((Screen=OpenScreen(&NewScreen))==NULL)
 	cleanexit();

 NewWindow.Screen=Screen;
 if ((Window=OpenWindow(&NewWindow))==NULL)          
	cleanexit();               /*  si raté !! */

 LoadRGB4(&Screen->ViewPort,couleurs,8);

 time=(struct timeval *)AllocMem(sizeof(struct timeval),MEMF_PUBLIC | MEMF_CLEAR);
 if( !time )
   cleanexit();
 time->tv_secs =0;
 time->tv_micro=500000; /* 0,5 seconde */

 tport=(struct MsgPort *)CreatePort(0,0);
 if( !tport )
 {
   T_Dev=NULL;
   cleanexit();
 }
   
 tr=(struct timerequest *)CreateExtIO(tport,sizeof(struct timerequest));
 if( !tr )
 {
   T_Dev=NULL;
   cleanexit();
 } 
 tr->tr_time=*time;

 T_Dev=OpenDevice(TIMERNAME,UNIT_MICROHZ,(struct IORequest *)tr,0L);
 if( T_Dev )    /*   0   si OK  */
  cleanexit();
   
}

void attente()
{

   BOOL fini=FALSE;
   ULONG Wmask=1L << Window->UserPort->mp_SigBit;
   ULONG Tmask=1L << tport->mp_SigBit;
   ULONG Signal_recu;
   ULONG sec=0;
   ULONG dix=0; /* secondes et dixièmes */

   time->tv_secs =0;
   time->tv_micro=500000; /* 0,5 seconde */
   tr->tr_time=*time;
   tr->tr_node.io_Command=TR_ADDREQUEST;
   SendIO( (struct IORequest *)tr );   /* 1er envoi */
         
   do
	{
	   Signal_recu=Wait( Wmask | Tmask );
      
      if( Signal_recu & Wmask ) /* dans FENETRE */
      {
	     while(msg=(struct IntuiMessage *)GetMsg(Window->UserPort))
        { 
	       classe=msg->Class;                      
          code=msg->Code;
	      
          ReplyMsg((struct Message *)msg);
         
          switch(classe)
          {
            case VANILLAKEY:
               switch(code)
               {
                  case 'Q':
                  case 'q':
                    fini=TRUE;
                    break;
                  default:
                    sprintf(s,"dernière touche : '%c'",code);
                    PrintIT(&bleu,50,150);
                    break;
               }
               break;
            case CLOSEWINDOW:
               fini=TRUE;
               break;
            default:
               break;
          }
        } /* end while( msg ) */
      } /* end if( Wmask ) */

      if( Signal_recu & Tmask ) /* DELAI ecoulé */
      {
         dix+=5;
         if( dix==10 )
         {
            dix=0;
            sec++;
         }
         sprintf(s,"secondes : %3d,%d",sec,dix);
         PrintIT(&rouge,50,50);

         time->tv_secs =0;
         time->tv_micro=500000; /* 0,5 seconde */
         tr->tr_time=*time;
         tr->tr_node.io_Command=TR_ADDREQUEST;
         SendIO( (struct IORequest *)tr );   /* remettez-nous ça ! ! */
      } /* end if( Tmask ) */

	}while( !fini );	   
   
   if( !CheckIO(tr) )
      AbortIO(tr);   /* arrete la demande en cours */
   WaitIO(tr);       /* attend t_request OK     */
}

/***********  MAIN  ********************/

void main()
{
   openall();
   
   attente();
   
   cleanexit();
}