windows/timer.c

   1 /*
   2  * Timer functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "windef.h"
  22 #include "wingdi.h"
  23 #include "wine/winuser16.h"
  24 #include "winuser.h"
  25 #include "winerror.h"
  26
  27 #include "winproc.h"
  28 #include "message.h"
  29 #include "win.h"
  30 #include "wine/server.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(timer);
  34
  35
  36 typedef struct tagTIMER
  37 {
  38     HWND           hwnd;
  39     DWORD          thread;
  40     UINT           msg;  /* WM_TIMER or WM_SYSTIMER */
  41     UINT           id;
  42     UINT           timeout;
  43     HWINDOWPROC    proc;
  44 } TIMER;
  45
  46 #define NB_TIMERS            34
  47 #define NB_RESERVED_TIMERS    2  /* for SetSystemTimer */
  48
  49 #define SYS_TIMER_RATE  55   /* min. timer rate in ms (actually 54.925)*/
  50
  51 static TIMER TimersArray[NB_TIMERS];
  52
  53 static CRITICAL_SECTION csTimer = CRITICAL_SECTION_INIT("csTimer");
  54
  55
  56 /***********************************************************************
  57  *           TIMER_ClearTimer
  58  *
  59  * Clear and remove a timer.
  60  */
  61 static void TIMER_ClearTimer( TIMER * pTimer )
  62 {
  63     pTimer->hwnd    = 0;
  64     pTimer->msg     = 0;
  65     pTimer->id      = 0;
  66     pTimer->timeout = 0;
  67     WINPROC_FreeProc( pTimer->proc, WIN_PROC_TIMER );
  68 }
  69
  70
  71 /***********************************************************************
  72  *           TIMER_RemoveWindowTimers
  73  *
  74  * Remove all timers for a given window.
  75  */
  76 void TIMER_RemoveWindowTimers( HWND hwnd )
  77 {
  78     int i;
  79     TIMER *pTimer;
  80
  81     EnterCriticalSection( &csTimer );
  82
  83     for (i = NB_TIMERS, pTimer = TimersArray; i > 0; i--, pTimer++)
  84         if ((pTimer->hwnd == hwnd) && pTimer->timeout)
  85             TIMER_ClearTimer( pTimer );
  86
  87     LeaveCriticalSection( &csTimer );
  88 }
  89
  90
  91 /***********************************************************************
  92  *           TIMER_RemoveThreadTimers
  93  *
  94  * Remove all timers for the current thread.
  95  */
  96 void TIMER_RemoveThreadTimers(void)
  97 {
  98     int i;
  99     TIMER *pTimer;
 100
 101     EnterCriticalSection( &csTimer );
 102
 103     for (i = NB_TIMERS, pTimer = TimersArray; i > 0; i--, pTimer++)
 104         if ((pTimer->thread == GetCurrentThreadId()) && pTimer->timeout)
 105             TIMER_ClearTimer( pTimer );
 106
 107     LeaveCriticalSection( &csTimer );
 108 }
 109
 110
 111 /***********************************************************************
 112  *           TIMER_SetTimer
 113  */
 114 static UINT_PTR TIMER_SetTimer( HWND hwnd, UINT_PTR id, UINT timeout,
 115                               WNDPROC16 proc, WINDOWPROCTYPE type, BOOL sys )
 116 {
 117     int i;
 118     TIMER * pTimer;
 119     HWINDOWPROC winproc = 0;
 120
 121     if (hwnd && !(hwnd = WIN_IsCurrentThread( hwnd )))
 122     {
 123         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 124         return 0;
 125     }
 126
 127     if (!timeout)
 128       {       /* timeout==0 is a legal argument  UB 990821*/
 129        WARN("Timeout== 0 not implemented, using timeout=1\n");
 130         timeout=1;
 131       }
 132
 133     EnterCriticalSection( &csTimer );
 134
 135       /* Check if there's already a timer with the same hwnd and id */
 136
 137     for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 138         if ((pTimer->hwnd == hwnd) && (pTimer->id == id) &&
 139             (pTimer->timeout != 0))
 140         {
 141             TIMER_ClearTimer( pTimer );
 142             break;
 143         }
 144
 145     if ( i == NB_TIMERS )
 146     {
 147           /* Find a free timer */
 148
 149         for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 150             if (!pTimer->timeout) break;
 151
 152         if ( (i >= NB_TIMERS) ||
 153              (!sys && (i >= NB_TIMERS-NB_RESERVED_TIMERS)) )
 154         {
 155             LeaveCriticalSection( &csTimer );
 156             return 0;
 157         }
 158     }
 159
 160     if (!hwnd) id = i + 1;
 161
 162     if (proc) WINPROC_SetProc( &winproc, proc, type, WIN_PROC_TIMER );
 163
 164     SERVER_START_REQ( set_win_timer )
 165     {
 166         req->win    = hwnd;
 167         req->msg    = sys ? WM_SYSTIMER : WM_TIMER;
 168         req->id     = id;
 169         req->rate   = max( timeout, SYS_TIMER_RATE );
 170         req->lparam = (unsigned int)winproc;
 171         wine_server_call( req );
 172     }
 173     SERVER_END_REQ;
 174
 175       /* Add the timer */
 176
 177     pTimer->hwnd    = hwnd;
 178     pTimer->thread  = GetCurrentThreadId();
 179     pTimer->msg     = sys ? WM_SYSTIMER : WM_TIMER;
 180     pTimer->id      = id;
 181     pTimer->timeout = timeout;
 182     pTimer->proc    = winproc;
 183
 184     TRACE("Timer added: %p, %p, %04x, %04x, %p\n",
 185           pTimer, pTimer->hwnd, pTimer->msg, pTimer->id, pTimer->proc );
 186
 187     LeaveCriticalSection( &csTimer );
 188
 189     if (!id) return TRUE;
 190     else return id;
 191 }
 192
 193
 194 /***********************************************************************
 195  *           TIMER_KillTimer
 196  */
 197 static BOOL TIMER_KillTimer( HWND hwnd, UINT_PTR id, BOOL sys )
 198 {
 199     int i;
 200     TIMER * pTimer;
 201
 202     SERVER_START_REQ( kill_win_timer )
 203     {
 204         req->win = hwnd;
 205         req->msg = sys ? WM_SYSTIMER : WM_TIMER;
 206         req->id  = id;
 207         wine_server_call( req );
 208     }
 209     SERVER_END_REQ;
 210
 211     EnterCriticalSection( &csTimer );
 212
 213     /* Find the timer */
 214
 215     for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 216         if ((pTimer->hwnd == hwnd) && (pTimer->id == id) &&
 217             (pTimer->timeout != 0)) break;
 218
 219     if ( (i >= NB_TIMERS) ||
 220          (!sys && (i >= NB_TIMERS-NB_RESERVED_TIMERS)) ||
 221          (!sys && (pTimer->msg != WM_TIMER)) ||
 222          (sys && (pTimer->msg != WM_SYSTIMER)) )
 223     {
 224         LeaveCriticalSection( &csTimer );
 225         return FALSE;
 226     }
 227
 228     /* Delete the timer */
 229
 230     TIMER_ClearTimer( pTimer );
 231
 232     LeaveCriticalSection( &csTimer );
 233
 234     return TRUE;
 235 }
 236
 237
 238 /***********************************************************************
 239  *              SetTimer (USER.10)
 240  */
 241 UINT16 WINAPI SetTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout,
 242                           TIMERPROC16 proc )
 243 {
 244     TRACE("%04x %d %d %08lx\n",
 245                    hwnd, id, timeout, (LONG)proc );
 246     return TIMER_SetTimer( WIN_Handle32(hwnd), id, timeout, (WNDPROC16)proc,
 247                            WIN_PROC_16, FALSE );
 248 }
 249
 250
 251 /***********************************************************************
 252  *              SetTimer (USER32.@)
 253  */
 254 UINT_PTR WINAPI SetTimer( HWND hwnd, UINT_PTR id, UINT timeout,
 255                           TIMERPROC proc )
 256 {
 257     TRACE("%p %d %d %p\n", hwnd, id, timeout, proc );
 258     return TIMER_SetTimer( hwnd, id, timeout, (WNDPROC16)proc, WIN_PROC_32A, FALSE );
 259 }
 260
 261
 262 /***********************************************************************
 263  *           TIMER_IsTimerValid
 264  */
 265 BOOL TIMER_IsTimerValid( HWND hwnd, UINT_PTR id, HWINDOWPROC hProc )
 266 {
 267     int i;
 268     TIMER *pTimer;
 269     BOOL ret = FALSE;
 270
 271     hwnd = WIN_GetFullHandle( hwnd );
 272     EnterCriticalSection( &csTimer );
 273
 274     for (i = 0, pTimer = TimersArray; i < NB_TIMERS; i++, pTimer++)
 275         if ((pTimer->hwnd == hwnd) && (pTimer->id == id) &&
 276             (pTimer->proc == hProc))
 277         {
 278             ret = TRUE;
 279             break;
 280         }
 281
 282    LeaveCriticalSection( &csTimer );
 283    return ret;
 284 }
 285
 286
 287 /***********************************************************************
 288  *              SetSystemTimer (USER.11)
 289  */
 290 UINT16 WINAPI SetSystemTimer16( HWND16 hwnd, UINT16 id, UINT16 timeout,
 291                                 TIMERPROC16 proc )
 292 {
 293     TRACE("%04x %d %d %08lx\n",
 294                    hwnd, id, timeout, (LONG)proc );
 295     return TIMER_SetTimer( WIN_Handle32(hwnd), id, timeout, (WNDPROC16)proc,
 296                            WIN_PROC_16, TRUE );
 297 }
 298
 299
 300 /***********************************************************************
 301  *              SetSystemTimer (USER32.@)
 302  */
 303 UINT_PTR WINAPI SetSystemTimer( HWND hwnd, UINT_PTR id, UINT timeout,
 304                                 TIMERPROC proc )
 305 {
 306     TRACE("%p %d %d %p\n", hwnd, id, timeout, proc );
 307     return TIMER_SetTimer( hwnd, id, timeout, (WNDPROC16)proc, WIN_PROC_32A, TRUE );
 308 }
 309
 310
 311 /***********************************************************************
 312  *              KillTimer (USER32.@)
 313  */
 314 BOOL WINAPI KillTimer( HWND hwnd, UINT_PTR id )
 315 {
 316     TRACE("%p %d\n", hwnd, id );
 317     return TIMER_KillTimer( hwnd, id, FALSE );
 318 }
 319
 320
 321 /***********************************************************************
 322  *              KillSystemTimer (USER32.@)
 323  */
 324 BOOL WINAPI KillSystemTimer( HWND hwnd, UINT_PTR id )
 325 {
 326     TRACE("%p %d\n", hwnd, id );
 327     return TIMER_KillTimer( hwnd, id, TRUE );
 328 }