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 = gpsi->ptCursor;
 319              if ( RECTL_bPointInRect(&pDesk->rcMouseHover, Point.x, Point.y) )
 320              {
 321                 if (pDesk->htEx == HTCLIENT) // In a client area.
 322                 {
 323                    wParam = MsqGetDownKeyState(pWnd->head.pti->MessageQueue);
 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      case ID_EVENT_SYSTIMER_FLASHWIN:
 349        {
 350           FLASHWINFO fwi =
 351             {sizeof(FLASHWINFO),
 352              UserHMGetHandle(pWnd),
 353              FLASHW_SYSTIMER,0,0};
 354
 355           IntFlashWindowEx(pWnd, &fwi);
 356        }
 357        return;
 358
 359      default:
 360        ERR("System Timer Proc invalid id %u!\n", idEvent);
 361        break;
 362   }
 363   IntKillTimer(pWnd, idEvent, TRUE);
 364 }
 365
 366 VOID
 367 FASTCALL
 368 StartTheTimers(VOID)
 369 {
 370   // Need to start gdi syncro timers then start timer with Hang App proc
 371   // that calles Idle process so the screen savers will know to run......
 372   IntSetTimer(NULL, 0, 1000, HungAppSysTimerProc, TMRF_RIT);
 373 // Test Timers
 374 //  IntSetTimer(NULL, 0, 1000, SystemTimerProc, TMRF_RIT);
 375 }
 376
 377 UINT_PTR
 378 FASTCALL
 379 SystemTimerSet( PWND Window,
 380                 UINT_PTR nIDEvent,
 381                 UINT uElapse,
 382                 TIMERPROC lpTimerFunc)
 383 {
 384   if (Window && Window->head.pti->pEThread->ThreadsProcess != PsGetCurrentProcess())
 385   {
 386      EngSetLastError(ERROR_ACCESS_DENIED);
 387      TRACE("SysemTimerSet: Access Denied!\n");
 388      return 0;
 389   }
 390   return IntSetTimer( Window, nIDEvent, uElapse, lpTimerFunc, TMRF_SYSTEM);
 391 }
 392
 393 BOOL
 394 FASTCALL
 395 PostTimerMessages(PWND Window)
 396 {
 397   PLIST_ENTRY pLE;
 398   MSG Msg;
 399   PTHREADINFO pti;
 400   BOOL Hit = FALSE;
 401   PTIMER pTmr;
 402
 403   pti = PsGetCurrentThreadWin32Thread();
 404
 405   TimerEnterExclusive();
 406   pLE = TimersListHead.Flink;
 407   while(pLE != &TimersListHead)
 408   {
 409      pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 410      if ( (pTmr->flags & TMRF_READY) &&
 411           (pTmr->pti == pti) &&
 412           ((pTmr->pWnd == Window) || (Window == NULL)) )
 413         {
 414            Msg.hwnd    = (pTmr->pWnd) ? pTmr->pWnd->head.h : 0;
 415            Msg.message = (pTmr->flags & TMRF_SYSTEM) ? WM_SYSTIMER : WM_TIMER;
 416            Msg.wParam  = (WPARAM) pTmr->nID;
 417            Msg.lParam  = (LPARAM) pTmr->pfn;
 418
 419            MsqPostMessage(pti, &Msg, FALSE, (QS_POSTMESSAGE|QS_ALLPOSTMESSAGE), 0, 0);
 420            pTmr->flags &= ~TMRF_READY;
 421            ClearMsgBitsMask(pti, QS_TIMER);
 422            Hit = TRUE;
 423            // Now move this entry to the end of the list so it will not be
 424            // called again in the next msg loop.
 425            if (pLE != &TimersListHead)
 426            {
 427               RemoveEntryList(&pTmr->ptmrList);
 428               InsertTailList(&TimersListHead, &pTmr->ptmrList);
 429            }
 430            break;
 431         }
 432
 433      pLE = pLE->Flink;
 434   }
 435
 436   TimerLeave();
 437
 438   return Hit;
 439 }
 440
 441 VOID
 442 FASTCALL
 443 ProcessTimers(VOID)
 444 {
 445   LARGE_INTEGER TickCount, DueTime;
 446   LONG Time;
 447   PLIST_ENTRY pLE;
 448   PTIMER pTmr;
 449   LONG TimerCount = 0;
 450
 451   TimerEnterExclusive();
 452   pLE = TimersListHead.Flink;
 453   KeQueryTickCount(&TickCount);
 454   Time = MsqCalculateMessageTime(&TickCount);
 455
 456   DueTime.QuadPart = (LONGLONG)(-97656); // 1024hz .9765625 ms set to 10.0 ms
 457
 458   while(pLE != &TimersListHead)
 459   {
 460     pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 461     TimerCount++;
 462     if (pTmr->flags & TMRF_WAITING)
 463     {
 464        pLE = pTmr->ptmrList.Flink;
 465        pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 466        continue;
 467     }
 468
 469     if (pTmr->flags & TMRF_INIT)
 470     {
 471        pTmr->flags &= ~TMRF_INIT; // Skip this run.
 472     }
 473     else
 474     {
 475        if (pTmr->cmsCountdown < 0)
 476        {
 477           ASSERT(pTmr->pti);
 478           if ((!(pTmr->flags & TMRF_READY)) && (!(pTmr->pti->TIF_flags & TIF_INCLEANUP)))
 479           {
 480              if (pTmr->flags & TMRF_ONESHOT)
 481                 pTmr->flags |= TMRF_WAITING;
 482
 483              if (pTmr->flags & TMRF_RIT)
 484              {
 485                 // Hard coded call here, inside raw input thread.
 486                 pTmr->pfn(NULL, WM_SYSTIMER, pTmr->nID, (LPARAM)pTmr);
 487              }
 488              else
 489              {
 490                 pTmr->flags |= TMRF_READY; // Set timer ready to be ran.
 491                 // Set thread message queue for this timer.
 492                 if (pTmr->pti)
 493                 {  // Wakeup thread
 494                    pTmr->pti->cTimersReady++;
 495                    ASSERT(pTmr->pti->pEventQueueServer != NULL);
 496                    MsqWakeQueue(pTmr->pti, QS_TIMER, TRUE);
 497                 }
 498              }
 499           }
 500           pTmr->cmsCountdown = pTmr->cmsRate;
 501        }
 502        else
 503           pTmr->cmsCountdown -= Time - TimeLast;
 504     }
 505
 506     pLE = pLE->Flink;
 507   }
 508
 509   // Restart the timer thread!
 510   ASSERT(MasterTimer != NULL);
 511   KeSetTimer(MasterTimer, DueTime, NULL);
 512
 513   TimeLast = Time;
 514
 515   TimerLeave();
 516   TRACE("TimerCount = %d\n", TimerCount);
 517 }
 518
 519 BOOL FASTCALL
 520 DestroyTimersForWindow(PTHREADINFO pti, PWND Window)
 521 {
 522    PLIST_ENTRY pLE;
 523    PTIMER pTmr;
 524    BOOL TimersRemoved = FALSE;
 525
 526    if (Window == NULL)
 527       return FALSE;
 528
 529    TimerEnterExclusive();
 530    pLE = TimersListHead.Flink;
 531    while(pLE != &TimersListHead)
 532    {
 533       pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 534       pLE = pLE->Flink; /* get next timer list entry before current timer is removed */
 535       if ((pTmr) && (pTmr->pti == pti) && (pTmr->pWnd == Window))
 536       {
 537          TimersRemoved = RemoveTimer(pTmr);
 538       }
 539    }
 540
 541    TimerLeave();
 542
 543    return TimersRemoved;
 544 }
 545
 546 BOOL FASTCALL
 547 DestroyTimersForThread(PTHREADINFO pti)
 548 {
 549    PLIST_ENTRY pLE = TimersListHead.Flink;
 550    PTIMER pTmr;
 551    BOOL TimersRemoved = FALSE;
 552
 553    TimerEnterExclusive();
 554
 555    while(pLE != &TimersListHead)
 556    {
 557       pTmr = CONTAINING_RECORD(pLE, TIMER, ptmrList);
 558       pLE = pLE->Flink; /* get next timer list entry before current timer is removed */
 559       if ((pTmr) && (pTmr->pti == pti))
 560       {
 561          TimersRemoved = RemoveTimer(pTmr);
 562       }
 563    }
 564
 565    TimerLeave();
 566
 567    return TimersRemoved;
 568 }
 569
 570 BOOL FASTCALL
 571 IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
 572 {
 573    PTIMER pTmr = NULL;
 574    TRACE("IntKillTimer Window %p id %uI systemtimer %s\n",
 575          Window, IDEvent, SystemTimer ? "TRUE" : "FALSE");
 576
 577    TimerEnterExclusive();
 578    pTmr = FindTimer(Window, IDEvent, SystemTimer ? TMRF_SYSTEM : 0);
 579
 580    if (pTmr)
 581    {
 582       RemoveTimer(pTmr);
 583    }
 584    TimerLeave();
 585
 586    return pTmr ? TRUE :  FALSE;
 587 }
 588
 589 INIT_FUNCTION
 590 NTSTATUS
 591 NTAPI
 592 InitTimerImpl(VOID)
 593 {
 594    ULONG BitmapBytes;
 595
 596    /* Allocate FAST_MUTEX from non paged pool */
 597    Mutex = ExAllocatePoolWithTag(NonPagedPool, sizeof(FAST_MUTEX), TAG_INTERNAL_SYNC);
 598    if (!Mutex)
 599    {
 600        return STATUS_INSUFFICIENT_RESOURCES;
 601    }
 602
 603    ExInitializeFastMutex(Mutex);
 604
 605    BitmapBytes = ALIGN_UP_BY(NUM_WINDOW_LESS_TIMERS, sizeof(ULONG) * 8) / 8;
 606    WindowLessTimersBitMapBuffer = ExAllocatePoolWithTag(NonPagedPool, BitmapBytes, TAG_TIMERBMP);
 607    if (WindowLessTimersBitMapBuffer == NULL)
 608    {
 609       return STATUS_UNSUCCESSFUL;
 610    }
 611
 612    RtlInitializeBitMap(&WindowLessTimersBitMap,
 613                        WindowLessTimersBitMapBuffer,
 614                        BitmapBytes * 8);
 615
 616    /* Yes we need this, since ExAllocatePoolWithTag isn't supposed to zero out allocated memory */
 617    RtlClearAllBits(&WindowLessTimersBitMap);
 618
 619    ExInitializeResourceLite(&TimerLock);
 620    InitializeListHead(&TimersListHead);
 621
 622    return STATUS_SUCCESS;
 623 }
 624
 625 UINT_PTR
 626 APIENTRY
 627 NtUserSetTimer
 628 (
 629    HWND hWnd,
 630    UINT_PTR nIDEvent,
 631    UINT uElapse,
 632    TIMERPROC lpTimerFunc
 633 )
 634 {
 635    PWND Window = NULL;
 636    DECLARE_RETURN(UINT_PTR);
 637
 638    TRACE("Enter NtUserSetTimer\n");
 639    UserEnterExclusive();
 640    if (hWnd) Window = UserGetWindowObject(hWnd);
 641    UserLeave();
 642
 643    RETURN(IntSetTimer(Window, nIDEvent, uElapse, lpTimerFunc, TMRF_TIFROMWND));
 644
 645 CLEANUP:
 646    TRACE("Leave NtUserSetTimer, ret=%u\n", _ret_);
 647
 648    END_CLEANUP;
 649 }
 650
 651
 652 BOOL
 653 APIENTRY
 654 NtUserKillTimer
 655 (
 656    HWND hWnd,
 657    UINT_PTR uIDEvent
 658 )
 659 {
 660    PWND Window = NULL;
 661    DECLARE_RETURN(BOOL);
 662
 663    TRACE("Enter NtUserKillTimer\n");
 664    UserEnterExclusive();
 665    if (hWnd) Window = UserGetWindowObject(hWnd);
 666    UserLeave();
 667
 668    RETURN(IntKillTimer(Window, uIDEvent, FALSE));
 669
 670 CLEANUP:
 671    TRACE("Leave NtUserKillTimer, ret=%i\n", _ret_);
 672    END_CLEANUP;
 673 }
 674
 675
 676 UINT_PTR
 677 APIENTRY
 678 NtUserSetSystemTimer(
 679    HWND hWnd,
 680    UINT_PTR nIDEvent,
 681    UINT uElapse,
 682    TIMERPROC lpTimerFunc
 683 )
 684 {
 685    DECLARE_RETURN(UINT_PTR);
 686
 687    TRACE("Enter NtUserSetSystemTimer\n");
 688
 689    RETURN(IntSetTimer(UserGetWindowObject(hWnd), nIDEvent, uElapse, NULL, TMRF_SYSTEM));
 690
 691 CLEANUP:
 692    TRACE("Leave NtUserSetSystemTimer, ret=%u\n", _ret_);
 693    END_CLEANUP;
 694 }
 695
 696 BOOL
 697 APIENTRY
 698 NtUserValidateTimerCallback(
 699     LPARAM lParam)
 700 {
 701   BOOL Ret = FALSE;
 702
 703   UserEnterShared();
 704
 705   Ret = ValidateTimerCallback(PsGetCurrentThreadWin32Thread(), lParam);
 706
 707   UserLeave();
 708   return Ret;
 709 }
 710
 711 /* EOF */