reactos/win32ss/user/ntuser/timer.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * PURPOSE:          Window timers messages
   5  * FILE:             subsystems/win32/win32k/ntuser/timer.c
   6  * PROGRAMER:        Gunnar
   7  *                   Thomas Weidenmueller (w3seek@users.sourceforge.net)
   8  *                   Michael Martin (michael.martin@reactos.org)
   9  */
  10
  11 #include <win32k.h>
  12 DBG_DEFAULT_CHANNEL(UserTimer);
  13
  14 /* GLOBALS *******************************************************************/
  15
  16 static LIST_ENTRY TimersListHead;
  17 static LONG TimeLast = 0;
  18
  19 /* Windows 2000 has room for 32768 window-less timers */
  20 #define NUM_WINDOW_LESS_TIMERS   32768
  21
  22 static PFAST_MUTEX    Mutex;
  23 static RTL_BITMAP     WindowLessTimersBitMap;
  24 static PVOID          WindowLessTimersBitMapBuffer;
  25 static ULONG          HintIndex = 1;
  26
  27 ERESOURCE TimerLock;
  28
  29 #define IntLockWindowlessTimerBitmap() \
  30   ExEnterCriticalRegionAndAcquireFastMutexUnsafe(Mutex)
  31
  32 #define IntUnlockWindowlessTimerBitmap() \
  33   ExReleaseFastMutexUnsafeAndLeaveCriticalRegion(Mutex)
  34
  35 #define TimerEnterExclusive() \
  36 { \
  37   KeEnterCriticalRegion(); \
  38   ExAcquireResourceExclusiveLite(&TimerLock, TRUE); \
  39 }
  40
  41 #define TimerLeave() \
  42 { \
  43   ExReleaseResourceLite(&TimerLock); \
  44   KeLeaveCriticalRegion(); \
  45 }
  46
  47
  48 /* FUNCTIONS *****************************************************************/
  49 static
  50 PTIMER
  51 FASTCALL
  52 CreateTimer(VOID)
  53 {
  54   HANDLE Handle;
  55   PTIMER Ret = NULL;
  56
  57   Ret = UserCreateObject(gHandleTable, NULL, NULL, &Handle, TYPE_TIMER, sizeof(TIMER));
  58   if (Ret)
  59   {
  60      Ret->head.h = Handle;
  61      InsertTailList(&TimersListHead, &Ret->ptmrList);
  62   }
  63
  64   return Ret;
  65 }
  66
  67 static
  68 BOOL
  69 FASTCALL
  70 RemoveTimer(PTIMER pTmr)
  71 {
  72   BOOL Ret = FALSE;
  73   if (pTmr)
  74   {
  75      /* Set the flag, it will be removed when ready */
  76      RemoveEntryList(&pTmr->ptmrList);
  77      if ((pTmr->pWnd == NULL) && (!(pTmr->flags & TMRF_SYSTEM))) // System timers are reusable.
  78      {
  79         UINT_PTR IDEvent;
  80
  81         IDEvent = NUM_WINDOW_LESS_TIMERS - pTmr->nID;
  82         IntLockWindowlessTimerBitmap();
  83         RtlClearBit(&WindowLessTimersBitMap, IDEvent);
  84         IntUnlockWindowlessTimerBitmap();
  85      }
  86      UserDereferenceObject(pTmr);
  87      Ret = UserDeleteObject( UserHMGetHandle(pTmr), TYPE_TIMER);
  88   }
  89   if (!Ret) ERR("Warning: Unable to delete timer\n");
  90
  91   return Ret;
  92 }
  93
  94 PTIMER
  95 FASTCALL
  96 FindTimer(PWND Window,
  97           UINT_PTR nID,
  98           UINT flags)
  99 {
 100   PLIST_ENTRY pLE;
 101   PTIMER pTmr, RetTmr = NULL;
 102
 103   TimerEnterExclusive();
 104   pLE = TimersListHead.Flink;
 105   while (pLE != &TimersListHead)
 106   {
 107     pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 108
 109     if ( pTmr->nID == nID &&
 110          pTmr->pWnd == Window &&
 111         (pTmr->flags & (TMRF_SYSTEM|TMRF_RIT)) == (flags & (TMRF_SYSTEM|TMRF_RIT)))
 112     {
 113        RetTmr = pTmr;
 114        break;
 115     }
 116
 117     pLE = pLE->Flink;
 118   }
 119   TimerLeave();
 120
 121   return RetTmr;
 122 }
 123
 124 PTIMER
 125 FASTCALL
 126 FindSystemTimer(PMSG pMsg)
 127 {
 128   PLIST_ENTRY pLE;
 129   PTIMER pTmr = NULL;
 130
 131   TimerEnterExclusive();
 132   pLE = TimersListHead.Flink;
 133   while (pLE != &TimersListHead)
 134   {
 135     pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 136
 137     if ( pMsg->lParam == (LPARAM)pTmr->pfn &&
 138          (pTmr->flags & TMRF_SYSTEM) )
 139        break;
 140
 141     pLE = pLE->Flink;
 142   }
 143   TimerLeave();
 144
 145   return pTmr;
 146 }
 147
 148 BOOL
 149 FASTCALL
 150 ValidateTimerCallback(PTHREADINFO pti,
 151                       LPARAM lParam)
 152 {
 153   PLIST_ENTRY pLE;
 154   BOOL Ret = FALSE;
 155   PTIMER pTmr;
 156
 157   TimerEnterExclusive();
 158   pLE = TimersListHead.Flink;
 159   while (pLE != &TimersListHead)
 160   {
 161     pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 162     if ( (lParam == (LPARAM)pTmr->pfn) &&
 163         !(pTmr->flags & (TMRF_SYSTEM|TMRF_RIT)) &&
 164          (pTmr->pti->ppi == pti->ppi) )
 165     {
 166        Ret = TRUE;
 167        break;
 168     }
 169     pLE = pLE->Flink;
 170   }
 171   TimerLeave();
 172
 173   return Ret;
 174 }
 175
 176 UINT_PTR FASTCALL
 177 IntSetTimer( PWND Window,
 178                   UINT_PTR IDEvent,
 179                   UINT Elapse,
 180                   TIMERPROC TimerFunc,
 181                   INT Type)
 182 {
 183   PTIMER pTmr;
 184   UINT Ret = IDEvent;
 185   LARGE_INTEGER DueTime;
 186   DueTime.QuadPart = (LONGLONG)(-97656); // 1024hz .9765625 ms set to 10.0 ms
 187
 188 #if 0
 189   /* Windows NT/2k/XP behaviour */
 190   if (Elapse > USER_TIMER_MAXIMUM)
 191   {
 192      TRACE("Adjusting uElapse\n");
 193      Elapse = 1;
 194   }
 195 #else
 196   /* Windows XP SP2 and Windows Server 2003 behaviour */
 197   if (Elapse > USER_TIMER_MAXIMUM)
 198   {
 199      TRACE("Adjusting uElapse\n");
 200      Elapse = USER_TIMER_MAXIMUM;
 201   }
 202 #endif
 203
 204   /* Windows 2k/XP and Windows Server 2003 SP1 behaviour */
 205   if (Elapse < USER_TIMER_MINIMUM)
 206   {
 207      TRACE("Adjusting uElapse\n");
 208      Elapse = USER_TIMER_MINIMUM; // 1024hz .9765625 ms, set to 10.0 ms (+/-)1 ms
 209   }
 210
 211   /* Passing an IDEvent of 0 and the SetTimer returns 1.
 212      It will create the timer with an ID of 0 */
 213   if ((Window) && (IDEvent == 0))
 214      Ret = 1;
 215
 216   pTmr = FindTimer(Window, IDEvent, Type);
 217
 218   if ((!pTmr) && (Window == NULL) && (!(Type & TMRF_SYSTEM)))
 219   {
 220       IntLockWindowlessTimerBitmap();
 221
 222       IDEvent = RtlFindClearBitsAndSet(&WindowLessTimersBitMap, 1, HintIndex);
 223
 224       if (IDEvent == (UINT_PTR) -1)
 225       {
 226          IntUnlockWindowlessTimerBitmap();
 227          ERR("Unable to find a free window-less timer id\n");
 228          EngSetLastError(ERROR_NO_SYSTEM_RESOURCES);
 229          ASSERT(FALSE);
 230          return 0;
 231       }
 232
 233       IDEvent = NUM_WINDOW_LESS_TIMERS - IDEvent;
 234       Ret = IDEvent;
 235
 236       IntUnlockWindowlessTimerBitmap();
 237   }
 238
 239   if (!pTmr)
 240   {
 241      pTmr = CreateTimer();
 242      if (!pTmr) return 0;
 243
 244      if (Window && (Type & TMRF_TIFROMWND))
 245         pTmr->pti = Window->head.pti->pEThread->Tcb.Win32Thread;
 246      else
 247      {
 248         if (Type & TMRF_RIT)
 249            pTmr->pti = ptiRawInput;
 250         else
 251            pTmr->pti = PsGetCurrentThreadWin32Thread();
 252      }
 253
 254      pTmr->pWnd    = Window;
 255      pTmr->cmsCountdown = Elapse;
 256      pTmr->cmsRate = Elapse;
 257      pTmr->pfn     = TimerFunc;
 258      pTmr->nID     = IDEvent;
 259      pTmr->flags   = Type|TMRF_INIT;
 260   }
 261   else
 262   {
 263      pTmr->cmsCountdown = Elapse;
 264      pTmr->cmsRate = Elapse;
 265   }
 266
 267   ASSERT(MasterTimer != NULL);
 268   // Start the timer thread!
 269   if (TimersListHead.Flink == TimersListHead.Blink) // There is only one timer
 270      KeSetTimer(MasterTimer, DueTime, NULL);
 271
 272   return Ret;
 273 }
 274
 275 //
 276 // Process win32k system timers.
 277 //
 278 VOID
 279 CALLBACK
 280 SystemTimerProc(HWND hwnd,
 281                 UINT uMsg,
 282                 UINT_PTR idEvent,
 283                 DWORD dwTime)
 284 {
 285   PDESKTOP pDesk;
 286   PWND pWnd = NULL;
 287
 288   if (hwnd)
 289   {
 290      pWnd = UserGetWindowObject(hwnd);
 291      if (!pWnd)
 292      {
 293         ERR("System Timer Proc has invalid window handle! %p Id: %u\n", hwnd, idEvent);
 294         return;
 295      }
 296   }
 297   else
 298   {
 299      TRACE( "Windowless Timer Running!\n" );
 300      return;
 301   }
 302
 303   switch (idEvent)
 304   {
 305 /*
 306    Used in NtUserTrackMouseEvent.
 307  */
 308      case ID_EVENT_SYSTIMER_MOUSEHOVER:
 309        {
 310           POINT Point;
 311           UINT Msg;
 312           WPARAM wParam;
 313
 314           pDesk = pWnd->head.rpdesk;
 315           if ( pDesk->dwDTFlags & DF_TME_HOVER &&
 316                pWnd == pDesk->spwndTrack )
 317           {
 318              Point = pWnd->head.pti->MessageQueue->MouseMoveMsg.pt;
 319              if ( RECTL_bPointInRect(&pDesk->rcMouseHover, Point.x, Point.y) )
 320              {
 321                 if (pDesk->htEx == HTCLIENT) // In a client area.
 322                 {
 323                    wParam = UserGetMouseButtonsState();
 324                    Msg = WM_MOUSEHOVER;
 325
 326                    if (pWnd->ExStyle & WS_EX_LAYOUTRTL)
 327                    {
 328                       Point.x = pWnd->rcClient.right - Point.x - 1;
 329                    }
 330                    else
 331                       Point.x -= pWnd->rcClient.left;
 332                    Point.y -= pWnd->rcClient.top;
 333                 }
 334                 else
 335                 {
 336                    wParam = pDesk->htEx; // Need to support all HTXYZ hits.
 337                    Msg = WM_NCMOUSEHOVER;
 338                 }
 339                 TRACE("Generating WM_NCMOUSEHOVER\n");
 340                 UserPostMessage(hwnd, Msg, wParam, MAKELPARAM(Point.x, Point.y));
 341                 pDesk->dwDTFlags &= ~DF_TME_HOVER;
 342                 break; // Kill this timer.
 343              }
 344           }
 345        }
 346        return; // Not this window so just return.
 347
 348      default:
 349        ERR("System Timer Proc invalid id %u!\n", idEvent);
 350        break;
 351   }
 352   IntKillTimer(pWnd, idEvent, TRUE);
 353 }
 354
 355 VOID
 356 FASTCALL
 357 StartTheTimers(VOID)
 358 {
 359   // Need to start gdi syncro timers then start timer with Hang App proc
 360   // that calles Idle process so the screen savers will know to run......
 361   IntSetTimer(NULL, 0, 1000, HungAppSysTimerProc, TMRF_RIT);
 362 // Test Timers
 363 //  IntSetTimer(NULL, 0, 1000, SystemTimerProc, TMRF_RIT);
 364 }
 365
 366 UINT_PTR
 367 FASTCALL
 368 SystemTimerSet( PWND Window,
 369                 UINT_PTR nIDEvent,
 370                 UINT uElapse,
 371                 TIMERPROC lpTimerFunc)
 372 {
 373   if (Window && Window->head.pti->pEThread->ThreadsProcess != PsGetCurrentProcess())
 374   {
 375      EngSetLastError(ERROR_ACCESS_DENIED);
 376      TRACE("SysemTimerSet: Access Denied!\n");
 377      return 0;
 378   }
 379   return IntSetTimer( Window, nIDEvent, uElapse, lpTimerFunc, TMRF_SYSTEM);
 380 }
 381
 382 BOOL
 383 FASTCALL
 384 PostTimerMessages(PWND Window)
 385 {
 386   PLIST_ENTRY pLE;
 387   MSG Msg;
 388   PTHREADINFO pti;
 389   BOOL Hit = FALSE;
 390   PTIMER pTmr;
 391
 392   pti = PsGetCurrentThreadWin32Thread();
 393
 394   TimerEnterExclusive();
 395   pLE = TimersListHead.Flink;
 396   while(pLE != &TimersListHead)
 397   {
 398      pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 399      if ( (pTmr->flags & TMRF_READY) &&
 400           (pTmr->pti == pti) &&
 401           ((pTmr->pWnd == Window) || (Window == NULL)) )
 402         {
 403            Msg.hwnd    = (pTmr->pWnd) ? pTmr->pWnd->head.h : 0;
 404            Msg.message = (pTmr->flags & TMRF_SYSTEM) ? WM_SYSTIMER : WM_TIMER;
 405            Msg.wParam  = (WPARAM) pTmr->nID;
 406            Msg.lParam  = (LPARAM) pTmr->pfn;
 407
 408            MsqPostMessage(pti, &Msg, FALSE, (QS_POSTMESSAGE|QS_ALLPOSTMESSAGE), 0);
 409            pTmr->flags &= ~TMRF_READY;
 410            ClearMsgBitsMask(pti, QS_TIMER);
 411            Hit = TRUE;
 412            // Now move this entry to the end of the list so it will not be
 413            // called again in the next msg loop.
 414            if (pLE != &TimersListHead)
 415            {
 416               RemoveEntryList(&pTmr->ptmrList);
 417               InsertTailList(&TimersListHead, &pTmr->ptmrList);
 418            }
 419            break;
 420         }
 421
 422      pLE = pLE->Flink;
 423   }
 424
 425   TimerLeave();
 426
 427   return Hit;
 428 }
 429
 430 VOID
 431 FASTCALL
 432 ProcessTimers(VOID)
 433 {
 434   LARGE_INTEGER TickCount, DueTime;
 435   LONG Time;
 436   PLIST_ENTRY pLE;
 437   PTIMER pTmr;
 438   LONG TimerCount = 0;
 439
 440   TimerEnterExclusive();
 441   pLE = TimersListHead.Flink;
 442   KeQueryTickCount(&TickCount);
 443   Time = MsqCalculateMessageTime(&TickCount);
 444
 445   DueTime.QuadPart = (LONGLONG)(-97656); // 1024hz .9765625 ms set to 10.0 ms
 446
 447   while(pLE != &TimersListHead)
 448   {
 449     pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 450     TimerCount++;
 451     if (pTmr->flags & TMRF_WAITING)
 452     {
 453        pLE = pTmr->ptmrList.Flink;
 454        pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 455        continue;
 456     }
 457
 458     if (pTmr->flags & TMRF_INIT)
 459     {
 460        pTmr->flags &= ~TMRF_INIT; // Skip this run.
 461     }
 462     else
 463     {
 464        if (pTmr->cmsCountdown < 0)
 465        {
 466           ASSERT(pTmr->pti);
 467           if ((!(pTmr->flags & TMRF_READY)) && (!(pTmr->pti->TIF_flags & TIF_INCLEANUP)))
 468           {
 469              if (pTmr->flags & TMRF_ONESHOT)
 470                 pTmr->flags |= TMRF_WAITING;
 471
 472              if (pTmr->flags & TMRF_RIT)
 473              {
 474                 // Hard coded call here, inside raw input thread.
 475                 pTmr->pfn(NULL, WM_SYSTIMER, pTmr->nID, (LPARAM)pTmr);
 476              }
 477              else
 478              {
 479                 pTmr->flags |= TMRF_READY; // Set timer ready to be ran.
 480                 // Set thread message queue for this timer.
 481                 if (pTmr->pti)
 482                 {  // Wakeup thread
 483                    pTmr->pti->cTimersReady++;
 484                    ASSERT(pTmr->pti->pEventQueueServer != NULL);
 485                    MsqWakeQueue(pTmr->pti, QS_TIMER, TRUE);
 486                 }
 487              }
 488           }
 489           pTmr->cmsCountdown = pTmr->cmsRate;
 490        }
 491        else
 492           pTmr->cmsCountdown -= Time - TimeLast;
 493     }
 494
 495     pLE = pLE->Flink;
 496   }
 497
 498   // Restart the timer thread!
 499   ASSERT(MasterTimer != NULL);
 500   KeSetTimer(MasterTimer, DueTime, NULL);
 501
 502   TimeLast = Time;
 503
 504   TimerLeave();
 505   TRACE("TimerCount = %d\n", TimerCount);
 506 }
 507
 508 BOOL FASTCALL
 509 DestroyTimersForWindow(PTHREADINFO pti, PWND Window)
 510 {
 511    PLIST_ENTRY pLE;
 512    PTIMER pTmr;
 513    BOOL TimersRemoved = FALSE;
 514
 515    if ((Window == NULL))
 516       return FALSE;
 517
 518    TimerEnterExclusive();
 519    pLE = TimersListHead.Flink;
 520    while(pLE != &TimersListHead)
 521    {
 522       pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 523       pLE = pLE->Flink; /* get next timer list entry before current timer is removed */
 524       if ((pTmr) && (pTmr->pti == pti) && (pTmr->pWnd == Window))
 525       {
 526          TimersRemoved = RemoveTimer(pTmr);
 527       }
 528    }
 529
 530    TimerLeave();
 531
 532    return TimersRemoved;
 533 }
 534
 535 BOOL FASTCALL
 536 DestroyTimersForThread(PTHREADINFO pti)
 537 {
 538    PLIST_ENTRY pLE = TimersListHead.Flink;
 539    PTIMER pTmr;
 540    BOOL TimersRemoved = FALSE;
 541
 542    TimerEnterExclusive();
 543
 544    while(pLE != &TimersListHead)
 545    {
 546       pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 547       pLE = pLE->Flink; /* get next timer list entry before current timer is removed */
 548       if ((pTmr) && (pTmr->pti == pti))
 549       {
 550          TimersRemoved = RemoveTimer(pTmr);
 551       }
 552    }
 553
 554    TimerLeave();
 555
 556    return TimersRemoved;
 557 }
 558
 559 BOOL FASTCALL
 560 IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
 561 {
 562    PTIMER pTmr = NULL;
 563    TRACE("IntKillTimer Window %p id %p systemtimer %s\n",
 564          Window, IDEvent, SystemTimer ? "TRUE" : "FALSE");
 565
 566    TimerEnterExclusive();
 567    pTmr = FindTimer(Window, IDEvent, SystemTimer ? TMRF_SYSTEM : 0);
 568
 569    if (pTmr)
 570    {
 571       RemoveTimer(pTmr);
 572    }
 573    TimerLeave();
 574
 575    return pTmr ? TRUE :  FALSE;
 576 }
 577
 578 INIT_FUNCTION
 579 NTSTATUS
 580 NTAPI
 581 InitTimerImpl(VOID)
 582 {
 583    ULONG BitmapBytes;
 584
 585    /* Allocate FAST_MUTEX from non paged pool */
 586    Mutex = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), TAG_INTERNAL_SYNC);
 587    if (!Mutex)
 588    {
 589        return STATUS_INSUFFICIENT_RESOURCES;
 590    }
 591
 592    ExInitializeFastMutex(Mutex);
 593
 594    BitmapBytes = ROUND_UP(NUM_WINDOW_LESS_TIMERS, sizeof(ULONG) * 8) / 8;
 595    WindowLessTimersBitMapBuffer = ExAllocatePoolWithTag(NonPagedPool, BitmapBytes, TAG_TIMERBMP);
 596    if (WindowLessTimersBitMapBuffer == NULL)
 597    {
 598       return STATUS_UNSUCCESSFUL;
 599    }
 600
 601    RtlInitializeBitMap(&WindowLessTimersBitMap,
 602                        WindowLessTimersBitMapBuffer,
 603                        BitmapBytes * 8);
 604
 605    /* Yes we need this, since ExAllocatePoolWithTag isn't supposed to zero out allocated memory */
 606    RtlClearAllBits(&WindowLessTimersBitMap);
 607
 608    ExInitializeResourceLite(&TimerLock);
 609    InitializeListHead(&TimersListHead);
 610
 611    return STATUS_SUCCESS;
 612 }
 613
 614 UINT_PTR
 615 APIENTRY
 616 NtUserSetTimer
 617 (
 618    HWND hWnd,
 619    UINT_PTR nIDEvent,
 620    UINT uElapse,
 621    TIMERPROC lpTimerFunc
 622 )
 623 {
 624    PWND Window = NULL;
 625    DECLARE_RETURN(UINT_PTR);
 626
 627    TRACE("Enter NtUserSetTimer\n");
 628    UserEnterExclusive();
 629    if (hWnd) Window = UserGetWindowObject(hWnd);
 630    UserLeave();
 631
 632    RETURN(IntSetTimer(Window, nIDEvent, uElapse, lpTimerFunc, TMRF_TIFROMWND));
 633
 634 CLEANUP:
 635    TRACE("Leave NtUserSetTimer, ret=%u\n", _ret_);
 636
 637    END_CLEANUP;
 638 }
 639
 640
 641 BOOL
 642 APIENTRY
 643 NtUserKillTimer
 644 (
 645    HWND hWnd,
 646    UINT_PTR uIDEvent
 647 )
 648 {
 649    PWND Window = NULL;
 650    DECLARE_RETURN(BOOL);
 651
 652    TRACE("Enter NtUserKillTimer\n");
 653    UserEnterExclusive();
 654    if (hWnd) Window = UserGetWindowObject(hWnd);
 655    UserLeave();
 656
 657    RETURN(IntKillTimer(Window, uIDEvent, FALSE));
 658
 659 CLEANUP:
 660    TRACE("Leave NtUserKillTimer, ret=%i\n", _ret_);
 661    END_CLEANUP;
 662 }
 663
 664
 665 UINT_PTR
 666 APIENTRY
 667 NtUserSetSystemTimer(
 668    HWND hWnd,
 669    UINT_PTR nIDEvent,
 670    UINT uElapse,
 671    TIMERPROC lpTimerFunc
 672 )
 673 {
 674    DECLARE_RETURN(UINT_PTR);
 675
 676    TRACE("Enter NtUserSetSystemTimer\n");
 677
 678    RETURN(IntSetTimer(UserGetWindowObject(hWnd), nIDEvent, uElapse, NULL, TMRF_SYSTEM));
 679
 680 CLEANUP:
 681    TRACE("Leave NtUserSetSystemTimer, ret=%u\n", _ret_);
 682    END_CLEANUP;
 683 }
 684
 685 BOOL
 686 APIENTRY
 687 NtUserValidateTimerCallback(
 688     HWND hWnd,
 689     WPARAM wParam,
 690     LPARAM lParam)
 691 {
 692   BOOL Ret = FALSE;
 693
 694   UserEnterShared();
 695
 696   Ret = ValidateTimerCallback(PsGetCurrentThreadWin32Thread(), lParam);
 697
 698   UserLeave();
 699   return Ret;
 700 }
 701
 702 /* EOF */