windows/timer.c

   1 /*
   2  * Timer functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 #include "winuser.h"
   8 #include "queue.h"
   9 #include "task.h"
  10 #include "winproc.h"
  11 #include "debug.h"
  12
  13
  14 typedef struct tagTIMER
  15 {
  16     HWND           hwnd;
  17     HQUEUE16         hq;
  18     UINT16           msg;  /* WM_TIMER or WM_SYSTIMER */
  19     UINT           id;
  20     UINT           timeout;
  21     struct tagTIMER *next;
  22     DWORD            expires;  /* Next expiration, or 0 if already expired */
  23     HWINDOWPROC      proc;
  24 } TIMER;
  25
  26 #define NB_TIMERS            34
  27 #define NB_RESERVED_TIMERS    2  /* for SetSystemTimer */
  28
  29 static TIMER TimersArray[NB_TIMERS];
  30
  31 static TIMER * pNextTimer = NULL;  /* Next timer to expire */
  32
  33 static CRITICAL_SECTION csTimer;
  34
  35   /* Duration from 'time' until expiration of the timer */
  36 #define EXPIRE_TIME(pTimer,time) \
  37           (((pTimer)->expires <= (time)) ? 0 : (pTimer)->expires - (time))
  38
  39
  40 /***********************************************************************
  41  *           TIMER_Init
  42  *
  43  * Initialize critical section for the timer.
  44  */
  45 BOOL TIMER_Init( void )
  46 {
  47     InitializeCriticalSection( &csTimer );
  48     MakeCriticalSectionGlobal( &csTimer );
  49
  50     return TRUE;
  51 }
  52
  53
  54 /***********************************************************************
  55  *           TIMER_InsertTimer
  56  *
  57  * Insert the timer at its place in the chain.
  58  */
  59 static void TIMER_InsertTimer( TIMER * pTimer )
  60 {
  61     EnterCriticalSection( &csTimer );
  62
  63     if (!pNextTimer || (pTimer->expires < pNextTimer->expires))
  64     {
  65         pTimer->next = pNextTimer;
  66         pNextTimer = pTimer;
  67     }
  68     else
  69     {
  70         TIMER * ptr = pNextTimer;
  71         while (ptr->next && (pTimer->expires >= ptr->next->expires))
  72             ptr = ptr->next;
  73         pTimer->next = ptr->next;
  74         ptr->next = pTimer;
  75     }
  76
  77     LeaveCriticalSection( &csTimer );
  78 }
  79
  80
  81 /***********************************************************************
  82  *           TIMER_RemoveTimer
  83  *
  84  * Remove the timer from the chain.
  85  */
  86 static void TIMER_RemoveTimer( TIMER * pTimer )
  87 {
  88     TIMER **ppTimer = &pNextTimer;
  89
  90     EnterCriticalSection( &csTimer );
  91
  92     while (*ppTimer && (*ppTimer != pTimer)) ppTimer = &(*ppTimer)->next;
  93     if (*ppTimer) *ppTimer = pTimer->next;
  94     pTimer->next = NULL;
  95
  96     LeaveCriticalSection( &csTimer );
  97
  98     if (!pTimer->expires) QUEUE_DecTimerCount( pTimer->hq );
  99 }
 100
 101
 102 /***********************************************************************
 103  *           TIMER_ClearTimer
 104  *
 105  * Clear and remove a timer.
 106  */
 107 static void TIMER_ClearTimer( TIMER * pTimer )
 108 {
 109     TIMER_RemoveTimer( pTimer );
 110     pTimer->hwnd    = 0;
 111     pTimer->msg     = 0;
 112     pTimer->id      = 0;
 113     pTimer->timeout = 0;
 114     WINPROC_FreeProc( pTimer->proc, WIN_PROC_TIMER );
 115 }
 116
 117
 118 /***********************************************************************
 119  *           TIMER_SwitchQueue
 120  */
 121 void TIMER_SwitchQueue( HQUEUE16 old, HQUEUE16 new )
 122 {
 123     TIMER * pT;
 124
 125     EnterCriticalSection( &csTimer );
 126
 127     pT = pNextTimer;
 128     while (pT)
 129     {
 130         if (pT->hq == old) pT->hq = new;
 131         pT = pT->next;
 132     }
 133
 134     LeaveCriticalSection( &csTimer );
 135 }
 136
 137
 138 /***********************************************************************
 139  *           TIMER_RemoveWindowTimers
 140  *
 141  * Remove all timers for a given window.
 142  */
 143 void TIMER_RemoveWindowTimers( HWND hwnd )
 144 {
 145     int i;
 146     TIMER *pTimer;
 147
 148     EnterCriticalSection( &csTimer );
 149
 150     for (i = NB_TIMERS, pTimer = TimersArray; i > 0; i--, pTimer++)
 151         if ((pTimer->hwnd == hwnd) && pTimer->timeout)
 152             TIMER_ClearTimer( pTimer );
 153
 154     LeaveCriticalSection( &csTimer );
 155 }
 156
 157
 158 /***********************************************************************
 159  *           TIMER_RemoveQueueTimers
 160  *
 161  * Remove all timers for a given queue.
 162  */
 163 void TIMER_RemoveQueueTimers( HQUEUE16 hqueue )
 164 {
 165     int i;
 166     TIMER *pTimer;
 167
 168     EnterCriticalSection( &csTimer );
 169
 170     for (i = NB_TIMERS, pTimer = TimersArray; i > 0; i--, pTimer++)
 171         if ((pTimer->hq == hqueue) && pTimer->timeout)
 172             TIMER_ClearTimer( pTimer );
 173
 174     LeaveCriticalSection( &csTimer );
 175 }
 176
 177
 178 /***********************************************************************
 179  *           TIMER_RestartTimers
 180  *
 181  * Restart an expired timer.
 182  */
 183 static void TIMER_RestartTimer( TIMER * pTimer, DWORD curTime )
 184 {
 185     TIMER_RemoveTimer( pTimer );
 186     pTimer->expires = curTime + pTimer->timeout;
 187     TIMER_InsertTimer( pTimer );
 188 }
 189
 190
 191 /***********************************************************************
 192  *           TIMER_GetNextExpiration
 193  *
 194  * Return next timer expiration time, or -1 if none.
 195  */
 196 LONG TIMER_GetNextExpiration(void)
 197 {
 198     TIMER *pTimer;
 199     LONG retValue;
 200
 201     EnterCriticalSection( &csTimer );
 202
 203     pTimer = pNextTimer;
 204
 205     while (pTimer && !pTimer->expires)  /* Skip already expired timers */
 206         pTimer = pTimer->next;
 207
 208     retValue = pTimer ? EXPIRE_TIME( pTimer, GetTickCount() ) : -1;
 209     LeaveCriticalSection( &csTimer );
 210
 211     return retValue;
 212 }
 213
 214
 215 /***********************************************************************
 216  *           TIMER_ExpireTimers
 217  *
 218  * Mark expired timers and wake the appropriate queues.
 219  */
 220 void TIMER_ExpireTimers(void)
 221 {
 222     TIMER *pTimer;
 223     DWORD curTime = GetTickCount();
 224
 225     EnterCriticalSection( &csTimer );
 226
 227     pTimer = pNextTimer;
 228
 229     while (pTimer && !pTimer->expires)  /* Skip already expired timers */
 230         pTimer = pTimer->next;
 231     while (pTimer && (pTimer->expires <= curTime))
 232     {
 233         pTimer->expires = 0;
 234         QUEUE_IncTimerCount( pTimer->hq );
 235         pTimer = pTimer->next;
 236     }
 237
 238     LeaveCriticalSection( &csTimer );
 239 }
 240
 241
 242 /***********************************************************************
 243  *           TIMER_GetTimerMsg
 244  *
 245  * Build a message for an expired timer.
 246  */
 247 BOOL TIMER_GetTimerMsg( MSG *msg, HWND hwnd,
 248                           HQUEUE16 hQueue, BOOL remove )
 249 {
 250     TIMER *pTimer;
 251     DWORD curTime = GetTickCount();
 252
 253     EnterCriticalSection( &csTimer );
 254
 255     pTimer = pNextTimer;
 256
 257     if (hwnd)  /* Find first timer for this window */
 258         while (pTimer && (pTimer->hwnd != hwnd)) pTimer = pTimer->next;
 259     else   /* Find first timer for this queue */
 260         while (pTimer && (pTimer->hq != hQueue)) pTimer = pTimer->next;
 261
 262     if (!pTimer || (pTimer->expires > curTime))
 263     {
 264         LeaveCriticalSection( &csTimer );
 265         return FALSE; /* No timer */
 266     }
 267
 268     if (remove) TIMER_RestartTimer( pTimer, curTime );  /* Restart it */
 269
 270     TRACE(timer, "Timer expired: %04x, %04x, %04x, %08lx\n",
 271                    pTimer->hwnd, pTimer->msg, pTimer->id, (DWORD)pTimer->proc);
 272
 273       /* Build the message */
 274     msg->hwnd    = pTimer->hwnd;
 275     msg->message = pTimer->msg;
 276     msg->wParam  = pTimer->id;
 277     msg->lParam  = (LONG)pTimer->proc;
 278     msg->time    = curTime;
 279
 280     LeaveCriticalSection( &csTimer );
 281
 282     return TRUE;
 283 }
 284
 285
 286 /***********************************************************************
 287  *           TIMER_SetTimer
 288  */
 289 static UINT TIMER_SetTimer( HWND hwnd, UINT id, UINT timeout,
 290                               WNDPROC16 proc, WINDOWPROCTYPE type, BOOL sys )
 291 {
 292     int i;
 293     TIMER * pTimer;
 294
 295     if (!timeout) return 0;
 296
 297     EnterCriticalSection( &csTimer );
 298
 299       /* Check if there's already a timer with the same hwnd and id */
 300
 301     for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 302         if ((pTimer->hwnd == hwnd) && (pTimer->id == id) &&
 303             (pTimer->timeout != 0))
 304         {
 305               /* Got one: set new values and return */
 306             TIMER_RemoveTimer( pTimer );
 307             pTimer->timeout = timeout;
 308             WINPROC_FreeProc( pTimer->proc, WIN_PROC_TIMER );
 309             pTimer->proc = (HWINDOWPROC)0;
 310             if (proc) WINPROC_SetProc( &pTimer->proc, proc,
 311                                        type, WIN_PROC_TIMER );
 312             pTimer->expires = GetTickCount() + timeout;
 313             TIMER_InsertTimer( pTimer );
 314             LeaveCriticalSection( &csTimer );
 315             return id;
 316         }
 317
 318       /* Find a free timer */
 319
 320     for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 321         if (!pTimer->timeout) break;
 322
 323     if ( (i >= NB_TIMERS) ||
 324          (!sys && (i >= NB_TIMERS-NB_RESERVED_TIMERS)) )
 325     {
 326         LeaveCriticalSection( &csTimer );
 327         return 0;
 328     }
 329
 330     if (!hwnd) id = i + 1;
 331
 332       /* Add the timer */
 333
 334     pTimer->hwnd    = hwnd;
 335     pTimer->hq      = (hwnd) ? GetThreadQueue16( GetWindowThreadProcessId( hwnd, NULL ) )
 336                              : GetFastQueue16( );
 337     pTimer->msg     = sys ? WM_SYSTIMER : WM_TIMER;
 338     pTimer->id      = id;
 339     pTimer->timeout = timeout;
 340     pTimer->expires = GetTickCount() + timeout;
 341     pTimer->proc    = (HWINDOWPROC)0;
 342     if (proc) WINPROC_SetProc( &pTimer->proc, proc, type, WIN_PROC_TIMER );
 343     TRACE(timer, "Timer added: %p, %04x, %04x, %04x, %08lx\n",
 344                    pTimer, pTimer->hwnd, pTimer->msg, pTimer->id,
 345                    (DWORD)pTimer->proc );
 346     TIMER_InsertTimer( pTimer );
 347
 348     LeaveCriticalSection( &csTimer );
 349
 350     if (!id) return TRUE;
 351     else return id;
 352 }
 353
 354
 355 /***********************************************************************
 356  *           TIMER_KillTimer
 357  */
 358 static BOOL TIMER_KillTimer( HWND hwnd, UINT id, BOOL sys )
 359 {
 360     int i;
 361     TIMER * pTimer;
 362
 363     EnterCriticalSection( &csTimer );
 364
 365     /* Find the timer */
 366
 367     for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 368         if ((pTimer->hwnd == hwnd) && (pTimer->id == id) &&
 369             (pTimer->timeout != 0)) break;
 370
 371     if ( (i >= NB_TIMERS) ||
 372          (!sys && (i >= NB_TIMERS-NB_RESERVED_TIMERS)) ||
 373          (!sys && (pTimer->msg != WM_TIMER)) ||
 374          (sys && (pTimer->msg != WM_SYSTIMER)) )
 375     {
 376         LeaveCriticalSection( &csTimer );
 377         return FALSE;
 378     }
 379
 380     /* Delete the timer */
 381
 382     TIMER_ClearTimer( pTimer );
 383
 384     LeaveCriticalSection( &csTimer );
 385
 386     return TRUE;
 387 }
 388
 389
 390 /***********************************************************************
 391  *           SetTimer16   (USER.10)
 392  */
 393 UINT16 WINAPI SetTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout,
 394                           TIMERPROC16 proc )
 395 {
 396     TRACE(timer, "%04x %d %d %08lx\n",
 397                    hwnd, id, timeout, (LONG)proc );
 398     return TIMER_SetTimer( hwnd, id, timeout, (WNDPROC16)proc,
 399                            WIN_PROC_16, FALSE );
 400 }
 401
 402
 403 /***********************************************************************
 404  *           SetTimer32   (USER32.511)
 405  */
 406 UINT WINAPI SetTimer( HWND hwnd, UINT id, UINT timeout,
 407                           TIMERPROC proc )
 408 {
 409     TRACE(timer, "%04x %d %d %08lx\n",
 410                    hwnd, id, timeout, (LONG)proc );
 411     return TIMER_SetTimer( hwnd, id, timeout, (WNDPROC16)proc,
 412                            WIN_PROC_32A, FALSE );
 413 }
 414
 415
 416 /***********************************************************************
 417  *           SetSystemTimer16   (USER.11)
 418  */
 419 UINT16 WINAPI SetSystemTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout,
 420                                 TIMERPROC16 proc )
 421 {
 422     TRACE(timer, "%04x %d %d %08lx\n",
 423                    hwnd, id, timeout, (LONG)proc );
 424     return TIMER_SetTimer( hwnd, id, timeout, (WNDPROC16)proc,
 425                            WIN_PROC_16, TRUE );
 426 }
 427
 428
 429 /***********************************************************************
 430  *           SetSystemTimer32   (USER32.509)
 431  */
 432 UINT WINAPI SetSystemTimer( HWND hwnd, UINT id, UINT timeout,
 433                                 TIMERPROC proc )
 434 {
 435     TRACE(timer, "%04x %d %d %08lx\n",
 436                    hwnd, id, timeout, (LONG)proc );
 437     return TIMER_SetTimer( hwnd, id, timeout, (WNDPROC16)proc,
 438                            WIN_PROC_32A, TRUE );
 439 }
 440
 441
 442 /***********************************************************************
 443  *           KillTimer16   (USER.12)
 444  */
 445 BOOL16 WINAPI KillTimer16( HWND16 hwnd, UINT16 id )
 446 {
 447     TRACE(timer, "%04x %d\n", hwnd, id );
 448     return TIMER_KillTimer( hwnd, id, FALSE );
 449 }
 450
 451
 452 /***********************************************************************
 453  *           KillTimer32   (USER32.354)
 454  */
 455 BOOL WINAPI KillTimer( HWND hwnd, UINT id )
 456 {
 457     TRACE(timer, "%04x %d\n", hwnd, id );
 458     return TIMER_KillTimer( hwnd, id, FALSE );
 459 }
 460
 461
 462 /***********************************************************************
 463  *           KillSystemTimer16   (USER.182)
 464  */
 465 BOOL16 WINAPI KillSystemTimer16( HWND16 hwnd, UINT16 id )
 466 {
 467     TRACE(timer, "%04x %d\n", hwnd, id );
 468     return TIMER_KillTimer( hwnd, id, TRUE );
 469 }
 470
 471
 472 /***********************************************************************
 473  *           KillSystemTimer32   (USER32.353)
 474  */
 475 BOOL WINAPI KillSystemTimer( HWND hwnd, UINT id )
 476 {
 477     TRACE(timer, "%04x %d\n", hwnd, id );
 478     return TIMER_KillTimer( hwnd, id, TRUE );
 479 }