reactos/subsystems/win32/win32k/ntuser/msgqueue.c

   1 /*
   2  *  ReactOS W32 Subsystem
   3  *  Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19 /*
  20  * COPYRIGHT:        See COPYING in the top level directory
  21  * PROJECT:          ReactOS kernel
  22  * PURPOSE:          Message queues
  23  * FILE:             subsystems/win32/win32k/ntuser/msgqueue.c
  24  * PROGRAMER:        Casper S. Hornstrup (chorns@users.sourceforge.net)
  25  * REVISION HISTORY:
  26  *       06-06-2001  CSH  Created
  27  */
  28
  29 /* INCLUDES ******************************************************************/
  30
  31 #include <w32k.h>
  32
  33 #define NDEBUG
  34 #include <debug.h>
  35
  36 /* GLOBALS *******************************************************************/
  37
  38 #define SYSTEM_MESSAGE_QUEUE_SIZE           (256)
  39
  40 static MSG SystemMessageQueue[SYSTEM_MESSAGE_QUEUE_SIZE];
  41 static ULONG SystemMessageQueueHead = 0;
  42 static ULONG SystemMessageQueueTail = 0;
  43 static ULONG SystemMessageQueueCount = 0;
  44 static KSPIN_LOCK SystemMessageQueueLock;
  45
  46 static ULONG volatile HardwareMessageQueueStamp = 0;
  47 static LIST_ENTRY HardwareMessageQueueHead;
  48 static KMUTANT HardwareMessageQueueLock;
  49
  50 static KEVENT HardwareMessageEvent;
  51
  52 static PAGED_LOOKASIDE_LIST MessageLookasideList;
  53 static PAGED_LOOKASIDE_LIST TimerLookasideList;
  54
  55 #define IntLockSystemMessageQueue(OldIrql) \
  56   KeAcquireSpinLock(&SystemMessageQueueLock, &OldIrql)
  57
  58 #define IntUnLockSystemMessageQueue(OldIrql) \
  59   KeReleaseSpinLock(&SystemMessageQueueLock, OldIrql)
  60
  61 #define IntUnLockSystemHardwareMessageQueueLock(Wait) \
  62   KeReleaseMutant(&HardwareMessageQueueLock, IO_NO_INCREMENT, FALSE, Wait)
  63
  64 /* FUNCTIONS *****************************************************************/
  65
  66 //
  67 // Wakeup any thread/process waiting on idle input.
  68 //
  69 static VOID FASTCALL
  70 IdlePing(VOID)
  71 {
  72   HWND hWnd;
  73   PWINDOW_OBJECT Window;
  74   PPROCESSINFO W32d = PsGetCurrentProcessWin32Process();
  75
  76   hWnd = UserGetForegroundWindow();
  77
  78   Window = UserGetWindowObject(hWnd);
  79
  80   if (Window && Window->pti)
  81   {
  82      if (Window->pti->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE))
  83      {
  84         co_HOOK_CallHooks(WH_FOREGROUNDIDLE,HC_ACTION,0,0);
  85      }
  86   }
  87
  88   if (W32d && W32d->InputIdleEvent)
  89      KePulseEvent( W32d->InputIdleEvent, EVENT_INCREMENT, TRUE);
  90 }
  91
  92 HANDLE FASTCALL
  93 IntMsqSetWakeMask(DWORD WakeMask)
  94 {
  95    PTHREADINFO Win32Thread;
  96    PUSER_MESSAGE_QUEUE MessageQueue;
  97    HANDLE MessageEventHandle;
  98
  99    Win32Thread = PsGetCurrentThreadWin32Thread();
 100    if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
 101       return 0;
 102
 103    MessageQueue = Win32Thread->MessageQueue;
 104    MessageQueue->WakeMask = WakeMask;
 105    MessageEventHandle = MessageQueue->NewMessagesHandle;
 106
 107    return MessageEventHandle;
 108 }
 109
 110 BOOL FASTCALL
 111 IntMsqClearWakeMask(VOID)
 112 {
 113    PTHREADINFO Win32Thread;
 114    PUSER_MESSAGE_QUEUE MessageQueue;
 115
 116    Win32Thread = PsGetCurrentThreadWin32Thread();
 117    if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
 118       return FALSE;
 119
 120    MessageQueue = Win32Thread->MessageQueue;
 121 // HACK!!!!!!! Newbies that wrote this should hold your head down in shame! (jt)
 122    MessageQueue->WakeMask = ~0;
 123
 124    return TRUE;
 125 }
 126
 127 VOID FASTCALL
 128 MsqIncPaintCountQueue(PUSER_MESSAGE_QUEUE Queue)
 129 {
 130    Queue->PaintCount++;
 131    Queue->QueueBits |= QS_PAINT;
 132    Queue->ChangedBits |= QS_PAINT;
 133    if (Queue->WakeMask & QS_PAINT)
 134       KeSetEvent(Queue->NewMessages, IO_NO_INCREMENT, FALSE);
 135 }
 136
 137 VOID FASTCALL
 138 MsqDecPaintCountQueue(PUSER_MESSAGE_QUEUE Queue)
 139 {
 140    Queue->PaintCount--;
 141 }
 142
 143
 144 NTSTATUS FASTCALL
 145 MsqInitializeImpl(VOID)
 146 {
 147    /*CurrentFocusMessageQueue = NULL;*/
 148    InitializeListHead(&HardwareMessageQueueHead);
 149    KeInitializeEvent(&HardwareMessageEvent, NotificationEvent, 0);
 150    KeInitializeSpinLock(&SystemMessageQueueLock);
 151    KeInitializeMutant(&HardwareMessageQueueLock, 0);
 152
 153    ExInitializePagedLookasideList(&MessageLookasideList,
 154                                   NULL,
 155                                   NULL,
 156                                   0,
 157                                   sizeof(USER_MESSAGE),
 158                                   TAG_USRMSG,
 159                                   256);
 160    ExInitializePagedLookasideList(&TimerLookasideList,
 161                                   NULL,
 162                                   NULL,
 163                                   0,
 164                                   sizeof(TIMER_ENTRY),
 165                                   TAG_TIMER,
 166                                   64);
 167
 168    return(STATUS_SUCCESS);
 169 }
 170
 171 VOID FASTCALL
 172 MsqInsertSystemMessage(MSG* Msg)
 173 {
 174    LARGE_INTEGER LargeTickCount;
 175    KIRQL OldIrql;
 176    ULONG Prev;
 177    EVENTMSG Event;
 178
 179    IntLockSystemMessageQueue(OldIrql);
 180
 181    /*
 182     * Bail out if the queue is full. FIXME: We should handle this case
 183     * more gracefully.
 184     */
 185
 186    if (SystemMessageQueueCount == SYSTEM_MESSAGE_QUEUE_SIZE)
 187    {
 188       IntUnLockSystemMessageQueue(OldIrql);
 189       return;
 190    }
 191
 192    KeQueryTickCount(&LargeTickCount);
 193    Msg->time = MsqCalculateMessageTime(&LargeTickCount);
 194
 195    Event.message = Msg->message;
 196    Event.time    = Msg->time;
 197    Event.hwnd    = Msg->hwnd;
 198    Event.paramL  = Msg->pt.x;
 199    Event.paramH  = Msg->pt.y;
 200    co_HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&Event);
 201
 202    /*
 203     * If we got WM_MOUSEMOVE and there are already messages in the
 204     * system message queue, check if the last message is mouse move
 205     * and if it is then just overwrite it.
 206     */
 207
 208    if (Msg->message == WM_MOUSEMOVE && SystemMessageQueueCount)
 209    {
 210       if (SystemMessageQueueTail == 0)
 211          Prev = SYSTEM_MESSAGE_QUEUE_SIZE - 1;
 212       else
 213          Prev = SystemMessageQueueTail - 1;
 214       if (SystemMessageQueue[Prev].message == WM_MOUSEMOVE)
 215       {
 216          SystemMessageQueueTail = Prev;
 217          SystemMessageQueueCount--;
 218       }
 219    }
 220
 221    /*
 222     * Actually insert the message into the system message queue.
 223     */
 224
 225    SystemMessageQueue[SystemMessageQueueTail] = *Msg;
 226    SystemMessageQueueTail =
 227       (SystemMessageQueueTail + 1) % SYSTEM_MESSAGE_QUEUE_SIZE;
 228    SystemMessageQueueCount++;
 229
 230    IntUnLockSystemMessageQueue(OldIrql);
 231
 232    KeSetEvent(&HardwareMessageEvent, IO_NO_INCREMENT, FALSE);
 233 }
 234
 235 BOOL FASTCALL
 236 MsqIsClkLck(LPMSG Msg, BOOL Remove)
 237 {
 238    PTHREADINFO pti;
 239    PSYSTEM_CURSORINFO CurInfo;
 240    BOOL Res = FALSE;
 241
 242    pti = PsGetCurrentThreadWin32Thread();
 243    if (pti->rpdesk == NULL)
 244    {
 245       return FALSE;
 246    }
 247
 248    CurInfo = IntGetSysCursorInfo();
 249
 250    switch (Msg->message)
 251    {
 252      case WM_LBUTTONUP:
 253        Res = ((Msg->time - CurInfo->ClickLockTime) >= gspv.dwMouseClickLockTime);
 254        if (Res && (!CurInfo->ClickLockActive))
 255        {
 256          CurInfo->ClickLockActive = TRUE;
 257        }
 258        break;
 259      case WM_LBUTTONDOWN:
 260        if (CurInfo->ClickLockActive)
 261        {
 262          Res = TRUE;
 263          CurInfo->ClickLockActive = FALSE;
 264          CurInfo->ClickLockTime = 0;
 265        }
 266        else
 267        {
 268          CurInfo->ClickLockTime = Msg->time;
 269        }
 270        break;
 271    }
 272    return Res;
 273 }
 274
 275 BOOL FASTCALL
 276 MsqIsDblClk(LPMSG Msg, BOOL Remove)
 277 {
 278    PTHREADINFO pti;
 279    PSYSTEM_CURSORINFO CurInfo;
 280    LONG dX, dY;
 281    BOOL Res;
 282
 283    pti = PsGetCurrentThreadWin32Thread();
 284    if (pti->rpdesk == NULL)
 285    {
 286       return FALSE;
 287    }
 288
 289    CurInfo = IntGetSysCursorInfo();
 290    Res = (Msg->hwnd == (HWND)CurInfo->LastClkWnd) &&
 291          ((Msg->time - CurInfo->LastBtnDown) < gspv.iDblClickTime);
 292    if(Res)
 293    {
 294
 295       dX = CurInfo->LastBtnDownX - Msg->pt.x;
 296       dY = CurInfo->LastBtnDownY - Msg->pt.y;
 297       if(dX < 0)
 298          dX = -dX;
 299       if(dY < 0)
 300          dY = -dY;
 301
 302       Res = (dX <= gspv.iDblClickWidth) &&
 303             (dY <= gspv.iDblClickHeight);
 304
 305       if(Res)
 306       {
 307          if(CurInfo->ButtonsDown)
 308            Res = (CurInfo->ButtonsDown == Msg->message);
 309       }
 310    }
 311
 312    if(Remove)
 313    {
 314       CurInfo->LastBtnDownX = Msg->pt.x;
 315       CurInfo->LastBtnDownY = Msg->pt.y;
 316       CurInfo->ButtonsDown = Msg->message;
 317       if (Res)
 318       {
 319          CurInfo->LastBtnDown = 0;
 320          CurInfo->LastClkWnd = NULL;
 321       }
 322       else
 323       {
 324          CurInfo->LastClkWnd = (HANDLE)Msg->hwnd;
 325          CurInfo->LastBtnDown = Msg->time;
 326       }
 327    }
 328
 329    return Res;
 330 }
 331
 332 static BOOL APIENTRY
 333 co_MsqTranslateMouseMessage(PUSER_MESSAGE_QUEUE MessageQueue, PWINDOW_OBJECT Window, UINT FilterLow, UINT FilterHigh,
 334                             PUSER_MESSAGE Message, BOOL Remove, PBOOL Freed,
 335                             PWINDOW_OBJECT ScopeWin, PPOINT ScreenPoint, BOOL FromGlobalQueue, PLIST_ENTRY *Next)
 336 {
 337    USHORT Msg = Message->Msg.message;
 338    PWINDOW_OBJECT CaptureWindow = NULL;
 339    HWND hCaptureWin;
 340
 341    ASSERT_REFS_CO(ScopeWin);
 342
 343    /*
 344    co_WinPosWindowFromPoint can return a Window, and in that case
 345    that window has a ref that we need to deref. Thats why we add "dummy"
 346    refs in all other cases.
 347    */
 348
 349    hCaptureWin = IntGetCaptureWindow();
 350    if (hCaptureWin == NULL)
 351    {
 352       if (Msg == WM_MOUSEWHEEL)
 353       {
 354          CaptureWindow = UserGetWindowObject(IntGetFocusWindow());
 355          if (CaptureWindow) UserReferenceObject(CaptureWindow);
 356       }
 357       else
 358       {
 359          co_WinPosWindowFromPoint(ScopeWin, NULL, &Message->Msg.pt, &CaptureWindow);
 360          if(CaptureWindow == NULL)
 361          {
 362             CaptureWindow = ScopeWin;
 363             if (CaptureWindow) UserReferenceObject(CaptureWindow);
 364          }
 365          else
 366          {
 367             /* this is the one case where we dont add a ref, since the returned
 368             window is already referenced */
 369          }
 370       }
 371    }
 372    else
 373    {
 374       /* FIXME - window messages should go to the right window if no buttons are
 375                  pressed */
 376       CaptureWindow = UserGetWindowObject(hCaptureWin);
 377       if (CaptureWindow) UserReferenceObject(CaptureWindow);
 378    }
 379
 380
 381
 382    if (CaptureWindow == NULL)
 383    {
 384       if(!FromGlobalQueue)
 385       {
 386          RemoveEntryList(&Message->ListEntry);
 387          if(MessageQueue->MouseMoveMsg == Message)
 388          {
 389             MessageQueue->MouseMoveMsg = NULL;
 390          }
 391       }
 392       // when FromGlobalQueue is true, the caller has already removed the Message
 393       ExFreePool(Message);
 394       *Freed = TRUE;
 395       return(FALSE);
 396    }
 397
 398    if (CaptureWindow->pti->MessageQueue != MessageQueue)
 399    {
 400       if (! FromGlobalQueue)
 401       {
 402          DPRINT("Moving msg between private queues\n");
 403          /* This message is already queued in a private queue, but we need
 404           * to move it to a different queue, perhaps because a new window
 405           * was created which now covers the screen area previously taken
 406           * by another window. To move it, we need to take it out of the
 407           * old queue. Note that we're already holding the lock mutexes of the
 408           * old queue */
 409          RemoveEntryList(&Message->ListEntry);
 410
 411          /* remove the pointer for the current WM_MOUSEMOVE message in case we
 412             just removed it */
 413          if(MessageQueue->MouseMoveMsg == Message)
 414          {
 415             MessageQueue->MouseMoveMsg = NULL;
 416          }
 417       }
 418
 419       /* lock the destination message queue, so we don't get in trouble with other
 420          threads, messing with it at the same time */
 421       IntLockHardwareMessageQueue(CaptureWindow->pti->MessageQueue);
 422       InsertTailList(&CaptureWindow->pti->MessageQueue->HardwareMessagesListHead,
 423                      &Message->ListEntry);
 424       if(Message->Msg.message == WM_MOUSEMOVE)
 425       {
 426          if(CaptureWindow->pti->MessageQueue->MouseMoveMsg)
 427          {
 428             /* remove the old WM_MOUSEMOVE message, we're processing a more recent
 429                one */
 430             RemoveEntryList(&CaptureWindow->pti->MessageQueue->MouseMoveMsg->ListEntry);
 431             ExFreePool(CaptureWindow->pti->MessageQueue->MouseMoveMsg);
 432          }
 433          /* save the pointer to the WM_MOUSEMOVE message in the new queue */
 434          CaptureWindow->pti->MessageQueue->MouseMoveMsg = Message;
 435
 436          CaptureWindow->pti->MessageQueue->QueueBits |= QS_MOUSEMOVE;
 437          CaptureWindow->pti->MessageQueue->ChangedBits |= QS_MOUSEMOVE;
 438          if (CaptureWindow->pti->MessageQueue->WakeMask & QS_MOUSEMOVE)
 439             KeSetEvent(CaptureWindow->pti->MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
 440       }
 441       else
 442       {
 443          CaptureWindow->pti->MessageQueue->QueueBits |= QS_MOUSEBUTTON;
 444          CaptureWindow->pti->MessageQueue->ChangedBits |= QS_MOUSEBUTTON;
 445          if (CaptureWindow->pti->MessageQueue->WakeMask & QS_MOUSEBUTTON)
 446             KeSetEvent(CaptureWindow->pti->MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
 447       }
 448       IntUnLockHardwareMessageQueue(CaptureWindow->pti->MessageQueue);
 449
 450       *Freed = FALSE;
 451       UserDereferenceObject(CaptureWindow);
 452       return(FALSE);
 453    }
 454
 455    /* From here on, we're in the same message queue as the caller! */
 456
 457    *ScreenPoint = Message->Msg.pt;
 458
 459    if((Window != NULL && PtrToInt(Window) != 1 && CaptureWindow->hSelf != Window->hSelf) ||
 460          ((FilterLow != 0 || FilterHigh != 0) && (Msg < FilterLow || Msg > FilterHigh)))
 461    {
 462       /* Reject the message because it doesn't match the filter */
 463
 464       if(FromGlobalQueue)
 465       {
 466          /* Lock the message queue so no other thread can mess with it.
 467             Our own message queue is not locked while fetching from the global
 468             queue, so we have to make sure nothing interferes! */
 469          IntLockHardwareMessageQueue(CaptureWindow->pti->MessageQueue);
 470          /* if we're from the global queue, we need to add our message to our
 471             private queue so we don't loose it! */
 472          InsertTailList(&CaptureWindow->pti->MessageQueue->HardwareMessagesListHead,
 473                         &Message->ListEntry);
 474       }
 475
 476       if (Message->Msg.message == WM_MOUSEMOVE)
 477       {
 478          if(CaptureWindow->pti->MessageQueue->MouseMoveMsg &&
 479                (CaptureWindow->pti->MessageQueue->MouseMoveMsg != Message))
 480          {
 481             /* delete the old message */
 482             RemoveEntryList(&CaptureWindow->pti->MessageQueue->MouseMoveMsg->ListEntry);
 483             ExFreePool(CaptureWindow->pti->MessageQueue->MouseMoveMsg);
 484             if (!FromGlobalQueue)
 485             {
 486                // We might have deleted the next one in our queue, so fix next
 487                *Next = Message->ListEntry.Flink;
 488             }
 489          }
 490          /* always save a pointer to this WM_MOUSEMOVE message here because we're
 491             sure that the message is in the private queue */
 492          CaptureWindow->pti->MessageQueue->MouseMoveMsg = Message;
 493       }
 494       if(FromGlobalQueue)
 495       {
 496          IntUnLockHardwareMessageQueue(CaptureWindow->pti->MessageQueue);
 497       }
 498
 499       UserDereferenceObject(CaptureWindow);
 500       *Freed = FALSE;
 501       return(FALSE);
 502    }
 503
 504    /* FIXME - only assign if removing? */
 505    Message->Msg.hwnd = CaptureWindow->hSelf;
 506    Message->Msg.message = Msg;
 507    Message->Msg.lParam = MAKELONG(Message->Msg.pt.x, Message->Msg.pt.y);
 508
 509    /* remove the reference to the current WM_(NC)MOUSEMOVE message, if this message
 510       is it */
 511    if (Message->Msg.message == WM_MOUSEMOVE ||
 512          Message->Msg.message == WM_NCMOUSEMOVE)
 513    {
 514       if(FromGlobalQueue)
 515       {
 516          /* Lock the message queue so no other thread can mess with it.
 517             Our own message queue is not locked while fetching from the global
 518             queue, so we have to make sure nothing interferes! */
 519          IntLockHardwareMessageQueue(CaptureWindow->pti->MessageQueue);
 520          if(CaptureWindow->pti->MessageQueue->MouseMoveMsg)
 521          {
 522             /* delete the WM_(NC)MOUSEMOVE message in the private queue, we're dealing
 523                with one that's been sent later */
 524             RemoveEntryList(&CaptureWindow->pti->MessageQueue->MouseMoveMsg->ListEntry);
 525             ExFreePool(CaptureWindow->pti->MessageQueue->MouseMoveMsg);
 526             /* our message is not in the private queue so we can remove the pointer
 527                instead of setting it to the current message we're processing */
 528             CaptureWindow->pti->MessageQueue->MouseMoveMsg = NULL;
 529          }
 530          IntUnLockHardwareMessageQueue(CaptureWindow->pti->MessageQueue);
 531       }
 532       else if (CaptureWindow->pti->MessageQueue->MouseMoveMsg == Message)
 533       {
 534          CaptureWindow->pti->MessageQueue->MouseMoveMsg = NULL;
 535       }
 536    }
 537
 538    UserDereferenceObject(CaptureWindow);
 539    *Freed = FALSE;
 540    return(TRUE);
 541 }
 542
 543 BOOL APIENTRY
 544 co_MsqPeekHardwareMessage(PUSER_MESSAGE_QUEUE MessageQueue, PWINDOW_OBJECT Window,
 545                           UINT FilterLow, UINT FilterHigh, BOOL Remove,
 546                           PUSER_MESSAGE* Message)
 547 {
 548    KIRQL OldIrql;
 549    POINT ScreenPoint;
 550    BOOL Accept, Freed;
 551    PLIST_ENTRY CurrentEntry;
 552    PWINDOW_OBJECT DesktopWindow = NULL;
 553    PVOID WaitObjects[2];
 554    NTSTATUS WaitStatus;
 555    DECLARE_RETURN(BOOL);
 556    USER_REFERENCE_ENTRY Ref;
 557    PDESKTOPINFO Desk = NULL;
 558
 559    WaitObjects[1] = MessageQueue->NewMessages;
 560    WaitObjects[0] = &HardwareMessageQueueLock;
 561    do
 562    {
 563       IdlePing();
 564
 565       UserLeaveCo();
 566
 567       WaitStatus = KeWaitForMultipleObjects(2, WaitObjects, WaitAny, UserRequest,
 568                                             UserMode, FALSE, NULL, NULL);
 569
 570       UserEnterCo();
 571    }
 572    while (NT_SUCCESS(WaitStatus) && STATUS_WAIT_0 != WaitStatus);
 573
 574    DesktopWindow = UserGetWindowObject(IntGetDesktopWindow());
 575
 576    if (DesktopWindow)
 577    {
 578        UserRefObjectCo(DesktopWindow, &Ref);//can DesktopWindow be NULL?
 579        Desk = DesktopWindow->pti->pDeskInfo;
 580    }
 581
 582    /* Process messages in the message queue itself. */
 583    IntLockHardwareMessageQueue(MessageQueue);
 584    CurrentEntry = MessageQueue->HardwareMessagesListHead.Flink;
 585    while (CurrentEntry != &MessageQueue->HardwareMessagesListHead)
 586    {
 587       PUSER_MESSAGE Current =
 588          CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
 589       CurrentEntry = CurrentEntry->Flink;
 590       if (Current->Msg.message >= WM_MOUSEFIRST &&
 591             Current->Msg.message <= WM_MOUSELAST)
 592       {
 593
 594
 595          Accept = co_MsqTranslateMouseMessage(MessageQueue, Window, FilterLow, FilterHigh,
 596                                               Current, Remove, &Freed,
 597                                               DesktopWindow, &ScreenPoint, FALSE, &CurrentEntry);
 598          if (Accept)
 599          {
 600             if (Remove)
 601             {
 602                RemoveEntryList(&Current->ListEntry);
 603             }
 604             IntUnLockHardwareMessageQueue(MessageQueue);
 605             IntUnLockSystemHardwareMessageQueueLock(FALSE);
 606             *Message = Current;
 607
 608             if (Desk)
 609                 Desk->LastInputWasKbd = FALSE;
 610
 611             RETURN(TRUE);
 612          }
 613
 614       }
 615    }
 616    IntUnLockHardwareMessageQueue(MessageQueue);
 617
 618    /* Now try the global queue. */
 619
 620    /* Transfer all messages from the DPC accessible queue to the main queue. */
 621    IntLockSystemMessageQueue(OldIrql);
 622    while (SystemMessageQueueCount > 0)
 623    {
 624       PUSER_MESSAGE UserMsg;
 625       MSG Msg;
 626       BOOL ProcessMessage;
 627
 628       ASSERT(SystemMessageQueueHead < SYSTEM_MESSAGE_QUEUE_SIZE);
 629       Msg = SystemMessageQueue[SystemMessageQueueHead];
 630       SystemMessageQueueHead =
 631          (SystemMessageQueueHead + 1) % SYSTEM_MESSAGE_QUEUE_SIZE;
 632       SystemMessageQueueCount--;
 633       IntUnLockSystemMessageQueue(OldIrql);
 634       if (WM_MOUSEFIRST <= Msg.message && Msg.message <= WM_MOUSELAST)
 635       {
 636          MSLLHOOKSTRUCT MouseHookData;
 637
 638          MouseHookData.pt.x = LOWORD(Msg.lParam);
 639          MouseHookData.pt.y = HIWORD(Msg.lParam);
 640          switch(Msg.message)
 641          {
 642             case WM_MOUSEWHEEL:
 643                MouseHookData.mouseData = MAKELONG(0, GET_WHEEL_DELTA_WPARAM(Msg.wParam));
 644                break;
 645             case WM_XBUTTONDOWN:
 646             case WM_XBUTTONUP:
 647             case WM_XBUTTONDBLCLK:
 648             case WM_NCXBUTTONDOWN:
 649             case WM_NCXBUTTONUP:
 650             case WM_NCXBUTTONDBLCLK:
 651                MouseHookData.mouseData = MAKELONG(0, HIWORD(Msg.wParam));
 652                break;
 653             default:
 654                MouseHookData.mouseData = 0;
 655                break;
 656          }
 657          MouseHookData.flags = 0;
 658          MouseHookData.time = Msg.time;
 659          MouseHookData.dwExtraInfo = 0;
 660          ProcessMessage = (0 == co_HOOK_CallHooks(WH_MOUSE_LL, HC_ACTION,
 661                            Msg.message, (LPARAM) &MouseHookData));
 662       }
 663       else
 664       {
 665          ProcessMessage = TRUE;
 666       }
 667       if (ProcessMessage)
 668       {
 669          UserMsg = ExAllocateFromPagedLookasideList(&MessageLookasideList);
 670          /* What to do if out of memory? For now we just panic a bit in debug */
 671          ASSERT(UserMsg);
 672          UserMsg->FreeLParam = FALSE;
 673          UserMsg->Msg = Msg;
 674          InsertTailList(&HardwareMessageQueueHead, &UserMsg->ListEntry);
 675       }
 676       IntLockSystemMessageQueue(OldIrql);
 677    }
 678    HardwareMessageQueueStamp++;
 679    IntUnLockSystemMessageQueue(OldIrql);
 680
 681    /* Process messages in the queue until we find one to return. */
 682    CurrentEntry = HardwareMessageQueueHead.Flink;
 683    while (CurrentEntry != &HardwareMessageQueueHead)
 684    {
 685       PUSER_MESSAGE Current =
 686          CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
 687       CurrentEntry = CurrentEntry->Flink;
 688       RemoveEntryList(&Current->ListEntry);
 689       HardwareMessageQueueStamp++;
 690       if (Current->Msg.message >= WM_MOUSEFIRST &&
 691             Current->Msg.message <= WM_MOUSELAST)
 692       {
 693          const ULONG ActiveStamp = HardwareMessageQueueStamp;
 694          /* Translate the message. */
 695          Accept = co_MsqTranslateMouseMessage(MessageQueue, Window, FilterLow, FilterHigh,
 696                                               Current, Remove, &Freed,
 697                                               DesktopWindow, &ScreenPoint, TRUE, NULL);
 698          if (Accept)
 699          {
 700             /* Check for no more messages in the system queue. */
 701             IntLockSystemMessageQueue(OldIrql);
 702             if (SystemMessageQueueCount == 0 &&
 703                   IsListEmpty(&HardwareMessageQueueHead))
 704             {
 705                KeClearEvent(&HardwareMessageEvent);
 706             }
 707             IntUnLockSystemMessageQueue(OldIrql);
 708
 709             /*
 710             If we aren't removing the message then add it to the private
 711             queue.
 712             */
 713             if (!Remove)
 714             {
 715                IntLockHardwareMessageQueue(MessageQueue);
 716                if(Current->Msg.message == WM_MOUSEMOVE)
 717                {
 718                   if(MessageQueue->MouseMoveMsg)
 719                   {
 720                      RemoveEntryList(&MessageQueue->MouseMoveMsg->ListEntry);
 721                      ExFreePool(MessageQueue->MouseMoveMsg);
 722                   }
 723                   MessageQueue->MouseMoveMsg = Current;
 724                }
 725                InsertTailList(&MessageQueue->HardwareMessagesListHead,
 726                               &Current->ListEntry);
 727                IntUnLockHardwareMessageQueue(MessageQueue);
 728             }
 729             IntUnLockSystemHardwareMessageQueueLock(FALSE);
 730             *Message = Current;
 731
 732             RETURN(TRUE);
 733          }
 734          /* If the contents of the queue changed then restart processing. */
 735          if (HardwareMessageQueueStamp != ActiveStamp)
 736          {
 737             CurrentEntry = HardwareMessageQueueHead.Flink;
 738             continue;
 739          }
 740       }
 741    }
 742
 743    /* Check if the system message queue is now empty. */
 744    IntLockSystemMessageQueue(OldIrql);
 745    if (SystemMessageQueueCount == 0 && IsListEmpty(&HardwareMessageQueueHead))
 746    {
 747       KeClearEvent(&HardwareMessageEvent);
 748    }
 749    IntUnLockSystemMessageQueue(OldIrql);
 750    IntUnLockSystemHardwareMessageQueueLock(FALSE);
 751
 752    RETURN(FALSE);
 753
 754 CLEANUP:
 755    if (DesktopWindow) UserDerefObjectCo(DesktopWindow);
 756
 757    END_CLEANUP;
 758 }
 759
 760 //
 761 // Note: Only called from input.c.
 762 //
 763 VOID FASTCALL
 764 co_MsqPostKeyboardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
 765 {
 766    PUSER_MESSAGE_QUEUE FocusMessageQueue;
 767    MSG Msg;
 768    LARGE_INTEGER LargeTickCount;
 769    KBDLLHOOKSTRUCT KbdHookData;
 770    EVENTMSG Event;
 771    BOOLEAN Entered = FALSE;
 772
 773    DPRINT("MsqPostKeyboardMessage(uMsg 0x%x, wParam 0x%x, lParam 0x%x)\n",
 774           uMsg, wParam, lParam);
 775
 776    // Condition may arise when calling MsqPostMessage and waiting for an event.
 777    if (!UserIsEntered())
 778    {
 779          // Fixme: Not sure ATM if this thread is locked.
 780          UserEnterExclusive();
 781          Entered = TRUE;
 782    }
 783
 784    FocusMessageQueue = IntGetFocusMessageQueue();
 785
 786    Msg.hwnd = 0;
 787
 788    if (FocusMessageQueue && (FocusMessageQueue->FocusWindow != (HWND)0))
 789        Msg.hwnd = FocusMessageQueue->FocusWindow;
 790
 791    Msg.message = uMsg;
 792    Msg.wParam = wParam;
 793    Msg.lParam = lParam;
 794
 795    KeQueryTickCount(&LargeTickCount);
 796    Msg.time = MsqCalculateMessageTime(&LargeTickCount);
 797
 798    Event.message = Msg.message;
 799    Event.hwnd    = Msg.hwnd;
 800    Event.time    = Msg.time;
 801    Event.paramL  = (Msg.wParam & 0xFF) | (HIWORD(Msg.lParam) << 8);
 802    Event.paramH  = Msg.lParam & 0x7FFF;
 803    if (HIWORD(Msg.lParam) & 0x0100) Event.paramH |= 0x8000;
 804    co_HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&Event);
 805
 806    /* We can't get the Msg.pt point here since we don't know thread
 807       (and thus the window station) the message will end up in yet. */
 808
 809    KbdHookData.vkCode = Msg.wParam;
 810    KbdHookData.scanCode = (Msg.lParam >> 16) & 0xff;
 811    KbdHookData.flags = (0 == (Msg.lParam & 0x01000000) ? 0 : LLKHF_EXTENDED) |
 812                        (0 == (Msg.lParam & 0x20000000) ? 0 : LLKHF_ALTDOWN) |
 813                        (0 == (Msg.lParam & 0x80000000) ? 0 : LLKHF_UP);
 814    KbdHookData.time = Msg.time;
 815    KbdHookData.dwExtraInfo = 0;
 816    if (co_HOOK_CallHooks(WH_KEYBOARD_LL, HC_ACTION, Msg.message, (LPARAM) &KbdHookData))
 817    {
 818       DPRINT("Kbd msg %d wParam %d lParam 0x%08x dropped by WH_KEYBOARD_LL hook\n",
 819              Msg.message, Msg.wParam, Msg.lParam);
 820       if (Entered) UserLeave();
 821       return;
 822    }
 823
 824    if (FocusMessageQueue == NULL)
 825    {
 826          DPRINT("No focus message queue\n");
 827          if (Entered) UserLeave();
 828          return;
 829    }
 830
 831    if (FocusMessageQueue->FocusWindow != (HWND)0)
 832    {
 833          Msg.hwnd = FocusMessageQueue->FocusWindow;
 834          DPRINT("Msg.hwnd = %x\n", Msg.hwnd);
 835
 836          FocusMessageQueue->Desktop->pDeskInfo->LastInputWasKbd = TRUE;
 837
 838          Msg.pt = gpsi->ptCursor;
 839          MsqPostMessage(FocusMessageQueue, &Msg, FALSE, QS_KEY);
 840    }
 841    else
 842    {
 843          DPRINT("Invalid focus window handle\n");
 844    }
 845
 846    if (Entered) UserLeave();
 847    return;
 848 }
 849
 850 VOID FASTCALL
 851 MsqPostHotKeyMessage(PVOID Thread, HWND hWnd, WPARAM wParam, LPARAM lParam)
 852 {
 853    PWINDOW_OBJECT Window;
 854    PTHREADINFO Win32Thread;
 855    MSG Mesg;
 856    LARGE_INTEGER LargeTickCount;
 857    NTSTATUS Status;
 858
 859    Status = ObReferenceObjectByPointer (Thread,
 860                                         THREAD_ALL_ACCESS,
 861                                         PsThreadType,
 862                                         KernelMode);
 863    if (!NT_SUCCESS(Status))
 864       return;
 865
 866    Win32Thread = ((PETHREAD)Thread)->Tcb.Win32Thread;
 867    if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
 868    {
 869       ObDereferenceObject ((PETHREAD)Thread);
 870       return;
 871    }
 872
 873    Window = IntGetWindowObject(hWnd);
 874    if (!Window)
 875    {
 876       ObDereferenceObject ((PETHREAD)Thread);
 877       return;
 878    }
 879
 880    Mesg.hwnd = hWnd;
 881    Mesg.message = WM_HOTKEY;
 882    Mesg.wParam = wParam;
 883    Mesg.lParam = lParam;
 884    KeQueryTickCount(&LargeTickCount);
 885    Mesg.time = MsqCalculateMessageTime(&LargeTickCount);
 886    Mesg.pt = gpsi->ptCursor;
 887    MsqPostMessage(Window->pti->MessageQueue, &Mesg, FALSE, QS_HOTKEY);
 888    UserDereferenceObject(Window);
 889    ObDereferenceObject (Thread);
 890
 891    //  InsertHeadList(&pThread->MessageQueue->PostedMessagesListHead,
 892    //   &Message->ListEntry);
 893    //  KeSetEvent(pThread->MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
 894 }
 895
 896 PUSER_MESSAGE FASTCALL
 897 MsqCreateMessage(LPMSG Msg, BOOLEAN FreeLParam)
 898 {
 899    PUSER_MESSAGE Message;
 900
 901    Message = ExAllocateFromPagedLookasideList(&MessageLookasideList);
 902    if (!Message)
 903    {
 904       return NULL;
 905    }
 906
 907    Message->FreeLParam = FreeLParam;
 908    RtlMoveMemory(&Message->Msg, Msg, sizeof(MSG));
 909
 910    return Message;
 911 }
 912
 913 VOID FASTCALL
 914 MsqDestroyMessage(PUSER_MESSAGE Message)
 915 {
 916    ExFreeToPagedLookasideList(&MessageLookasideList, Message);
 917 }
 918
 919 VOID FASTCALL
 920 co_MsqDispatchSentNotifyMessages(PUSER_MESSAGE_QUEUE MessageQueue)
 921 {
 922    PLIST_ENTRY ListEntry;
 923    PUSER_SENT_MESSAGE_NOTIFY Message;
 924
 925    while (!IsListEmpty(&MessageQueue->SentMessagesListHead))
 926    {
 927       ListEntry = RemoveHeadList(&MessageQueue->SentMessagesListHead);
 928       Message = CONTAINING_RECORD(ListEntry, USER_SENT_MESSAGE_NOTIFY,
 929                                   ListEntry);
 930
 931       co_IntCallSentMessageCallback(Message->CompletionCallback,
 932                                     Message->hWnd,
 933                                     Message->Msg,
 934                                     Message->CompletionCallbackContext,
 935                                     Message->Result);
 936
 937    }
 938
 939 }
 940
 941 BOOLEAN FASTCALL
 942 MsqPeekSentMessages(PUSER_MESSAGE_QUEUE MessageQueue)
 943 {
 944    return(!IsListEmpty(&MessageQueue->SentMessagesListHead));
 945 }
 946
 947 BOOLEAN FASTCALL
 948 co_MsqDispatchOneSentMessage(PUSER_MESSAGE_QUEUE MessageQueue)
 949 {
 950    PUSER_SENT_MESSAGE Message;
 951    PLIST_ENTRY Entry;
 952    LRESULT Result;
 953    BOOL SenderReturned;
 954    PUSER_SENT_MESSAGE_NOTIFY NotifyMessage;
 955
 956    if (IsListEmpty(&MessageQueue->SentMessagesListHead))
 957    {
 958       return(FALSE);
 959    }
 960
 961    /* remove it from the list of pending messages */
 962    Entry = RemoveHeadList(&MessageQueue->SentMessagesListHead);
 963    Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
 964
 965    /* insert it to the list of messages that are currently dispatched by this
 966       message queue */
 967    InsertTailList(&MessageQueue->LocalDispatchingMessagesHead,
 968                   &Message->ListEntry);
 969
 970    if (Message->HookMessage == MSQ_ISHOOK)
 971    {
 972       Result = co_HOOK_CallHooks(Message->Msg.message,
 973                                  (INT)(INT_PTR)Message->Msg.hwnd,
 974                                  Message->Msg.wParam,
 975                                  Message->Msg.lParam);
 976    }
 977    else if (Message->HookMessage == MSQ_ISEVENT)
 978    {
 979       Result = co_EVENT_CallEvents( Message->Msg.message,
 980                                     Message->Msg.hwnd,
 981                                     Message->Msg.wParam,
 982                                     Message->Msg.lParam);
 983    }
 984    else
 985    {
 986       /* Call the window procedure. */
 987       Result = co_IntSendMessage(Message->Msg.hwnd,
 988                                  Message->Msg.message,
 989                                  Message->Msg.wParam,
 990                                  Message->Msg.lParam);
 991    }
 992
 993    /* remove the message from the local dispatching list, because it doesn't need
 994       to be cleaned up on thread termination anymore */
 995    RemoveEntryList(&Message->ListEntry);
 996
 997    /* remove the message from the dispatching list, so lock the sender's message queue */
 998    SenderReturned = (Message->DispatchingListEntry.Flink == NULL);
 999    if(!SenderReturned)
1000    {
1001       /* only remove it from the dispatching list if not already removed by a timeout */
1002       RemoveEntryList(&Message->DispatchingListEntry);
1003    }
1004    /* still keep the sender's message queue locked, so the sender can't exit the
1005       MsqSendMessage() function (if timed out) */
1006
1007    /* Let the sender know the result. */
1008    if (Message->Result != NULL)
1009    {
1010       *Message->Result = Result;
1011    }
1012
1013    /* Notify the sender. */
1014    if (Message->CompletionEvent != NULL)
1015    {
1016       KeSetEvent(Message->CompletionEvent, IO_NO_INCREMENT, FALSE);
1017    }
1018
1019    /* Notify the sender if they specified a callback. */
1020    if (!SenderReturned && Message->CompletionCallback != NULL)
1021    {
1022       if(!(NotifyMessage = ExAllocatePoolWithTag(NonPagedPool,
1023                            sizeof(USER_SENT_MESSAGE_NOTIFY), TAG_USRMSG)))
1024       {
1025          DPRINT1("MsqDispatchOneSentMessage(): Not enough memory to create a callback notify message\n");
1026          goto Notified;
1027       }
1028       NotifyMessage->CompletionCallback =
1029          Message->CompletionCallback;
1030       NotifyMessage->CompletionCallbackContext =
1031          Message->CompletionCallbackContext;
1032       NotifyMessage->Result = Result;
1033       NotifyMessage->hWnd = Message->Msg.hwnd;
1034       NotifyMessage->Msg = Message->Msg.message;
1035       MsqSendNotifyMessage(Message->SenderQueue, NotifyMessage);
1036    }
1037
1038 Notified:
1039
1040    /* dereference both sender and our queue */
1041    IntDereferenceMessageQueue(MessageQueue);
1042    IntDereferenceMessageQueue(Message->SenderQueue);
1043
1044    /* free the message */
1045    ExFreePool(Message);
1046    return(TRUE);
1047 }
1048
1049 VOID APIENTRY
1050 MsqRemoveWindowMessagesFromQueue(PVOID pWindow)
1051 {
1052    PUSER_SENT_MESSAGE SentMessage;
1053    PUSER_MESSAGE PostedMessage;
1054    PUSER_MESSAGE_QUEUE MessageQueue;
1055    PLIST_ENTRY CurrentEntry, ListHead;
1056    PWINDOW_OBJECT Window = pWindow;
1057
1058    ASSERT(Window);
1059
1060    MessageQueue = Window->pti->MessageQueue;
1061    ASSERT(MessageQueue);
1062
1063    /* remove the posted messages for this window */
1064    CurrentEntry = MessageQueue->PostedMessagesListHead.Flink;
1065    ListHead = &MessageQueue->PostedMessagesListHead;
1066    while (CurrentEntry != ListHead)
1067    {
1068       PostedMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1069                                         ListEntry);
1070       if (PostedMessage->Msg.hwnd == Window->hSelf)
1071       {
1072          RemoveEntryList(&PostedMessage->ListEntry);
1073          MsqDestroyMessage(PostedMessage);
1074          CurrentEntry = MessageQueue->PostedMessagesListHead.Flink;
1075       }
1076       else
1077       {
1078          CurrentEntry = CurrentEntry->Flink;
1079       }
1080    }
1081
1082    /* remove the sent messages for this window */
1083    CurrentEntry = MessageQueue->SentMessagesListHead.Flink;
1084    ListHead = &MessageQueue->SentMessagesListHead;
1085    while (CurrentEntry != ListHead)
1086    {
1087       SentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
1088                                       ListEntry);
1089       if(SentMessage->Msg.hwnd == Window->hSelf)
1090       {
1091          DPRINT("Notify the sender and remove a message from the queue that had not been dispatched\n");
1092
1093          RemoveEntryList(&SentMessage->ListEntry);
1094
1095          /* remove the message from the dispatching list */
1096          if(SentMessage->DispatchingListEntry.Flink != NULL)
1097          {
1098             RemoveEntryList(&SentMessage->DispatchingListEntry);
1099          }
1100
1101          /* wake the sender's thread */
1102          if (SentMessage->CompletionEvent != NULL)
1103          {
1104             KeSetEvent(SentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
1105          }
1106
1107          /* dereference our and the sender's message queue */
1108          IntDereferenceMessageQueue(MessageQueue);
1109          IntDereferenceMessageQueue(SentMessage->SenderQueue);
1110
1111          /* free the message */
1112          ExFreePool(SentMessage);
1113
1114          CurrentEntry = MessageQueue->SentMessagesListHead.Flink;
1115       }
1116       else
1117       {
1118          CurrentEntry = CurrentEntry->Flink;
1119       }
1120    }
1121 }
1122
1123 VOID FASTCALL
1124 MsqSendNotifyMessage(PUSER_MESSAGE_QUEUE MessageQueue,
1125                      PUSER_SENT_MESSAGE_NOTIFY NotifyMessage)
1126 {
1127    InsertTailList(&MessageQueue->NotifyMessagesListHead,
1128                   &NotifyMessage->ListEntry);
1129    MessageQueue->QueueBits |= QS_SENDMESSAGE;
1130    MessageQueue->ChangedBits |= QS_SENDMESSAGE;
1131    if (MessageQueue->WakeMask & QS_SENDMESSAGE)
1132       KeSetEvent(MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
1133 }
1134
1135 NTSTATUS FASTCALL
1136 co_MsqSendMessage(PUSER_MESSAGE_QUEUE MessageQueue,
1137                   HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam,
1138                   UINT uTimeout, BOOL Block, INT HookMessage,
1139                   ULONG_PTR *uResult)
1140 {
1141    PTHREADINFO pti;
1142    PUSER_SENT_MESSAGE Message;
1143    KEVENT CompletionEvent;
1144    NTSTATUS WaitStatus;
1145    LRESULT Result;
1146    PUSER_MESSAGE_QUEUE ThreadQueue;
1147    LARGE_INTEGER Timeout;
1148    PLIST_ENTRY Entry;
1149
1150    if(!(Message = ExAllocatePoolWithTag(PagedPool, sizeof(USER_SENT_MESSAGE), TAG_USRMSG)))
1151    {
1152       DPRINT1("MsqSendMessage(): Not enough memory to allocate a message");
1153       return STATUS_INSUFFICIENT_RESOURCES;
1154    }
1155
1156    KeInitializeEvent(&CompletionEvent, NotificationEvent, FALSE);
1157
1158    pti = PsGetCurrentThreadWin32Thread();
1159    ThreadQueue = pti->MessageQueue;
1160    ASSERT(ThreadQueue != MessageQueue);
1161
1162    Timeout.QuadPart = (LONGLONG) uTimeout * (LONGLONG) -10000;
1163
1164    /* FIXME - increase reference counter of sender's message queue here */
1165
1166    Result = 0;
1167    Message->Msg.hwnd = Wnd;
1168    Message->Msg.message = Msg;
1169    Message->Msg.wParam = wParam;
1170    Message->Msg.lParam = lParam;
1171    Message->CompletionEvent = &CompletionEvent;
1172    Message->Result = &Result;
1173    Message->SenderQueue = ThreadQueue;
1174    IntReferenceMessageQueue(ThreadQueue);
1175    Message->CompletionCallback = NULL;
1176    Message->HookMessage = HookMessage;
1177
1178    IntReferenceMessageQueue(MessageQueue);
1179
1180    /* add it to the list of pending messages */
1181    InsertTailList(&ThreadQueue->DispatchingMessagesHead, &Message->DispatchingListEntry);
1182
1183    /* queue it in the destination's message queue */
1184    InsertTailList(&MessageQueue->SentMessagesListHead, &Message->ListEntry);
1185
1186    MessageQueue->QueueBits |= QS_SENDMESSAGE;
1187    MessageQueue->ChangedBits |= QS_SENDMESSAGE;
1188    if (MessageQueue->WakeMask & QS_SENDMESSAGE)
1189       KeSetEvent(MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
1190
1191    /* we can't access the Message anymore since it could have already been deleted! */
1192
1193    if(Block)
1194    {
1195       IdlePing();
1196
1197       UserLeaveCo();
1198
1199       /* don't process messages sent to the thread */
1200       WaitStatus = KeWaitForSingleObject(&CompletionEvent, UserRequest, UserMode,
1201                                          FALSE, (uTimeout ? &Timeout : NULL));
1202
1203       UserEnterCo();
1204
1205       if(WaitStatus == STATUS_TIMEOUT)
1206       {
1207          /* look up if the message has not yet dispatched, if so
1208             make sure it can't pass a result and it must not set the completion event anymore */
1209          Entry = MessageQueue->SentMessagesListHead.Flink;
1210          while (Entry != &MessageQueue->SentMessagesListHead)
1211          {
1212             if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry)
1213                   == Message)
1214             {
1215                /* we can access Message here, it's secure because the message queue is locked
1216                   and the message is still hasn't been dispatched */
1217                Message->CompletionEvent = NULL;
1218                Message->Result = NULL;
1219                break;
1220             }
1221             Entry = Entry->Flink;
1222          }
1223
1224          /* remove from the local dispatching list so the other thread knows,
1225             it can't pass a result and it must not set the completion event anymore */
1226          Entry = ThreadQueue->DispatchingMessagesHead.Flink;
1227          while (Entry != &ThreadQueue->DispatchingMessagesHead)
1228          {
1229             if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, DispatchingListEntry)
1230                   == Message)
1231             {
1232                /* we can access Message here, it's secure because the sender's message is locked
1233                   and the message has definitely not yet been destroyed, otherwise it would
1234                   have been removed from this list by the dispatching routine right after
1235                dispatching the message */
1236                Message->CompletionEvent = NULL;
1237                Message->Result = NULL;
1238                RemoveEntryList(&Message->DispatchingListEntry);
1239                Message->DispatchingListEntry.Flink = NULL;
1240                break;
1241             }
1242             Entry = Entry->Flink;
1243          }
1244
1245          DPRINT("MsqSendMessage (blocked) timed out\n");
1246       }
1247       while (co_MsqDispatchOneSentMessage(ThreadQueue))
1248          ;
1249    }
1250    else
1251    {
1252       PVOID WaitObjects[2];
1253
1254       WaitObjects[0] = &CompletionEvent;
1255       WaitObjects[1] = ThreadQueue->NewMessages;
1256       do
1257       {
1258          IdlePing();
1259
1260          UserLeaveCo();
1261
1262          WaitStatus = KeWaitForMultipleObjects(2, WaitObjects, WaitAny, UserRequest,
1263                                                UserMode, FALSE, (uTimeout ? &Timeout : NULL), NULL);
1264
1265          UserEnterCo();
1266
1267          if(WaitStatus == STATUS_TIMEOUT)
1268          {
1269             /* look up if the message has not yet been dispatched, if so
1270                make sure it can't pass a result and it must not set the completion event anymore */
1271             Entry = MessageQueue->SentMessagesListHead.Flink;
1272             while (Entry != &MessageQueue->SentMessagesListHead)
1273             {
1274                if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry)
1275                      == Message)
1276                {
1277                   /* we can access Message here, it's secure because the message queue is locked
1278                      and the message is still hasn't been dispatched */
1279                   Message->CompletionEvent = NULL;
1280                   Message->Result = NULL;
1281                   break;
1282                }
1283                Entry = Entry->Flink;
1284             }
1285
1286             /* remove from the local dispatching list so the other thread knows,
1287                it can't pass a result and it must not set the completion event anymore */
1288             Entry = ThreadQueue->DispatchingMessagesHead.Flink;
1289             while (Entry != &ThreadQueue->DispatchingMessagesHead)
1290             {
1291                if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, DispatchingListEntry)
1292                      == Message)
1293                {
1294                   /* we can access Message here, it's secure because the sender's message is locked
1295                      and the message has definitely not yet been destroyed, otherwise it would
1296                      have been removed from this list by the dispatching routine right after
1297                   dispatching the message */
1298                   Message->CompletionEvent = NULL;
1299                   Message->Result = NULL;
1300                   RemoveEntryList(&Message->DispatchingListEntry);
1301                   Message->DispatchingListEntry.Flink = NULL;
1302                   break;
1303                }
1304                Entry = Entry->Flink;
1305             }
1306
1307             DPRINT("MsqSendMessage timed out\n");
1308             break;
1309          }
1310          while (co_MsqDispatchOneSentMessage(ThreadQueue))
1311             ;
1312       }
1313       while (NT_SUCCESS(WaitStatus) && STATUS_WAIT_0 != WaitStatus);
1314    }
1315
1316    if(WaitStatus != STATUS_TIMEOUT)
1317       *uResult = (STATUS_WAIT_0 == WaitStatus ? Result : -1);
1318
1319    return WaitStatus;
1320 }
1321
1322 VOID FASTCALL
1323 MsqPostMessage(PUSER_MESSAGE_QUEUE MessageQueue, MSG* Msg, BOOLEAN FreeLParam,
1324                DWORD MessageBits)
1325 {
1326    PUSER_MESSAGE Message;
1327
1328    if(!(Message = MsqCreateMessage(Msg, FreeLParam)))
1329    {
1330       return;
1331    }
1332    InsertTailList(&MessageQueue->PostedMessagesListHead,
1333                   &Message->ListEntry);
1334    MessageQueue->QueueBits |= MessageBits;
1335    MessageQueue->ChangedBits |= MessageBits;
1336    if (MessageQueue->WakeMask & MessageBits)
1337       KeSetEvent(MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
1338 }
1339
1340 VOID FASTCALL
1341 MsqPostQuitMessage(PUSER_MESSAGE_QUEUE MessageQueue, ULONG ExitCode)
1342 {
1343    MessageQueue->QuitPosted = TRUE;
1344    MessageQueue->QuitExitCode = ExitCode;
1345    MessageQueue->QueueBits |= QS_POSTMESSAGE;
1346    MessageQueue->ChangedBits |= QS_POSTMESSAGE;
1347    if (MessageQueue->WakeMask & QS_POSTMESSAGE)
1348       KeSetEvent(MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE);
1349 }
1350
1351 BOOLEAN APIENTRY
1352 co_MsqFindMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
1353                   IN BOOLEAN Hardware,
1354                   IN BOOLEAN Remove,
1355                   IN PWINDOW_OBJECT Window,
1356                   IN UINT MsgFilterLow,
1357                   IN UINT MsgFilterHigh,
1358                   OUT PUSER_MESSAGE* Message)
1359 {
1360    PLIST_ENTRY CurrentEntry;
1361    PUSER_MESSAGE CurrentMessage;
1362    PLIST_ENTRY ListHead;
1363
1364    if (Hardware)
1365    {
1366       return(co_MsqPeekHardwareMessage( MessageQueue,
1367                                         Window,
1368                                         MsgFilterLow,
1369                                         MsgFilterHigh,
1370                                         Remove,
1371                                         Message));
1372    }
1373
1374    CurrentEntry = MessageQueue->PostedMessagesListHead.Flink;
1375    ListHead = &MessageQueue->PostedMessagesListHead;
1376    while (CurrentEntry != ListHead)
1377    {
1378       CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1379                                          ListEntry);
1380       if ( ( !Window ||
1381             PtrToInt(Window) == 1 ||
1382             Window->hSelf == CurrentMessage->Msg.hwnd ) &&
1383             ( (MsgFilterLow == 0 && MsgFilterHigh == 0) ||
1384               ( MsgFilterLow <= CurrentMessage->Msg.message &&
1385                 MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
1386       {
1387          if (Remove)
1388          {
1389             RemoveEntryList(&CurrentMessage->ListEntry);
1390          }
1391
1392          *Message = CurrentMessage;
1393          return(TRUE);
1394       }
1395       CurrentEntry = CurrentEntry->Flink;
1396    }
1397
1398    return(FALSE);
1399 }
1400
1401 NTSTATUS FASTCALL
1402 co_MsqWaitForNewMessages(PUSER_MESSAGE_QUEUE MessageQueue, PWINDOW_OBJECT WndFilter,
1403                          UINT MsgFilterMin, UINT MsgFilterMax)
1404 {
1405    PVOID WaitObjects[2] = {MessageQueue->NewMessages, &HardwareMessageEvent};
1406    LARGE_INTEGER TimerExpiry;
1407    PLARGE_INTEGER Timeout;
1408    NTSTATUS ret;
1409
1410    if (MsqGetFirstTimerExpiry(MessageQueue, WndFilter, MsgFilterMin, MsgFilterMax, &TimerExpiry))
1411    {
1412       Timeout = &TimerExpiry;
1413    }
1414    else
1415    {
1416       Timeout = NULL;
1417    }
1418
1419    IdlePing(); // Going to wait so send Idle ping.
1420
1421    UserLeaveCo();
1422
1423    ret = KeWaitForMultipleObjects(2,
1424                                   WaitObjects,
1425                                   WaitAny,
1426                                   Executive,
1427                                   UserMode,
1428                                   FALSE,
1429                                   Timeout,
1430                                   NULL);
1431
1432    UserEnterCo();
1433
1434    return ret;
1435 }
1436
1437 BOOL FASTCALL
1438 MsqIsHung(PUSER_MESSAGE_QUEUE MessageQueue)
1439 {
1440    LARGE_INTEGER LargeTickCount;
1441
1442    KeQueryTickCount(&LargeTickCount);
1443    return ((LargeTickCount.u.LowPart - MessageQueue->LastMsgRead) > MSQ_HUNG);
1444 }
1445
1446 BOOLEAN FASTCALL
1447 MsqInitializeMessageQueue(struct _ETHREAD *Thread, PUSER_MESSAGE_QUEUE MessageQueue)
1448 {
1449    LARGE_INTEGER LargeTickCount;
1450    NTSTATUS Status;
1451
1452    MessageQueue->Thread = Thread;
1453    MessageQueue->CaretInfo = (PTHRDCARETINFO)(MessageQueue + 1);
1454    InitializeListHead(&MessageQueue->PostedMessagesListHead);
1455    InitializeListHead(&MessageQueue->SentMessagesListHead);
1456    InitializeListHead(&MessageQueue->HardwareMessagesListHead);
1457    InitializeListHead(&MessageQueue->TimerListHead);
1458    InitializeListHead(&MessageQueue->DispatchingMessagesHead);
1459    InitializeListHead(&MessageQueue->LocalDispatchingMessagesHead);
1460    KeInitializeMutex(&MessageQueue->HardwareLock, 0);
1461    MessageQueue->QuitPosted = FALSE;
1462    MessageQueue->QuitExitCode = 0;
1463    KeQueryTickCount(&LargeTickCount);
1464    MessageQueue->LastMsgRead = LargeTickCount.u.LowPart;
1465    MessageQueue->FocusWindow = NULL;
1466    MessageQueue->PaintCount = 0;
1467 // HACK!!!!!!! Newbies that wrote this should hold your head down in shame! (jt)
1468    MessageQueue->WakeMask = ~0;
1469    MessageQueue->NewMessagesHandle = NULL;
1470
1471    Status = ZwCreateEvent(&MessageQueue->NewMessagesHandle, EVENT_ALL_ACCESS,
1472                           NULL, SynchronizationEvent, FALSE);
1473    if (!NT_SUCCESS(Status))
1474    {
1475       return FALSE;
1476    }
1477
1478    Status = ObReferenceObjectByHandle(MessageQueue->NewMessagesHandle, 0,
1479                                       ExEventObjectType, KernelMode,
1480                                       (PVOID*)&MessageQueue->NewMessages, NULL);
1481    if (!NT_SUCCESS(Status))
1482    {
1483       ZwClose(MessageQueue->NewMessagesHandle);
1484       MessageQueue->NewMessagesHandle = NULL;
1485       return FALSE;
1486    }
1487
1488    return TRUE;
1489 }
1490
1491 VOID FASTCALL
1492 MsqCleanupMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
1493 {
1494    PLIST_ENTRY CurrentEntry;
1495    PUSER_MESSAGE CurrentMessage;
1496    PTIMER_ENTRY CurrentTimer;
1497    PUSER_SENT_MESSAGE CurrentSentMessage;
1498
1499    /* cleanup posted messages */
1500    while (!IsListEmpty(&MessageQueue->PostedMessagesListHead))
1501    {
1502       CurrentEntry = RemoveHeadList(&MessageQueue->PostedMessagesListHead);
1503       CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1504                                          ListEntry);
1505       MsqDestroyMessage(CurrentMessage);
1506    }
1507
1508    /* remove the messages that have not yet been dispatched */
1509    while (!IsListEmpty(&MessageQueue->SentMessagesListHead))
1510    {
1511       CurrentEntry = RemoveHeadList(&MessageQueue->SentMessagesListHead);
1512       CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
1513                                              ListEntry);
1514
1515       DPRINT("Notify the sender and remove a message from the queue that had not been dispatched\n");
1516
1517       /* remove the message from the dispatching list */
1518       if(CurrentSentMessage->DispatchingListEntry.Flink != NULL)
1519       {
1520          RemoveEntryList(&CurrentSentMessage->DispatchingListEntry);
1521       }
1522
1523       /* wake the sender's thread */
1524       if (CurrentSentMessage->CompletionEvent != NULL)
1525       {
1526          KeSetEvent(CurrentSentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
1527       }
1528
1529       /* dereference our and the sender's message queue */
1530       IntDereferenceMessageQueue(MessageQueue);
1531       IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
1532
1533       /* free the message */
1534       ExFreePool(CurrentSentMessage);
1535    }
1536
1537    /* cleanup timers */
1538    while (! IsListEmpty(&MessageQueue->TimerListHead))
1539    {
1540       CurrentEntry = RemoveHeadList(&MessageQueue->TimerListHead);
1541       CurrentTimer = CONTAINING_RECORD(CurrentEntry, TIMER_ENTRY, ListEntry);
1542       ExFreeToPagedLookasideList(&TimerLookasideList, CurrentTimer);
1543    }
1544
1545    /* notify senders of dispatching messages. This needs to be cleaned up if e.g.
1546       ExitThread() was called in a SendMessage() umode callback */
1547    while (!IsListEmpty(&MessageQueue->LocalDispatchingMessagesHead))
1548    {
1549       CurrentEntry = RemoveHeadList(&MessageQueue->LocalDispatchingMessagesHead);
1550       CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
1551                                              ListEntry);
1552
1553       /* remove the message from the dispatching list */
1554       if(CurrentSentMessage->DispatchingListEntry.Flink != NULL)
1555       {
1556          RemoveEntryList(&CurrentSentMessage->DispatchingListEntry);
1557       }
1558
1559       DPRINT("Notify the sender, the thread has been terminated while dispatching a message!\n");
1560
1561       /* wake the sender's thread */
1562       if (CurrentSentMessage->CompletionEvent != NULL)
1563       {
1564          KeSetEvent(CurrentSentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
1565       }
1566
1567       /* dereference our and the sender's message queue */
1568       IntDereferenceMessageQueue(MessageQueue);
1569       IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
1570
1571       /* free the message */
1572       ExFreePool(CurrentSentMessage);
1573    }
1574
1575    /* tell other threads not to bother returning any info to us */
1576    while (! IsListEmpty(&MessageQueue->DispatchingMessagesHead))
1577    {
1578       CurrentEntry = RemoveHeadList(&MessageQueue->DispatchingMessagesHead);
1579       CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
1580                                              DispatchingListEntry);
1581       CurrentSentMessage->CompletionEvent = NULL;
1582       CurrentSentMessage->Result = NULL;
1583
1584       /* do NOT dereference our message queue as it might get attempted to be
1585          locked later */
1586    }
1587
1588 }
1589
1590 PUSER_MESSAGE_QUEUE FASTCALL
1591 MsqCreateMessageQueue(struct _ETHREAD *Thread)
1592 {
1593    PUSER_MESSAGE_QUEUE MessageQueue;
1594
1595    MessageQueue = (PUSER_MESSAGE_QUEUE)ExAllocatePoolWithTag(NonPagedPool,
1596                   sizeof(USER_MESSAGE_QUEUE) + sizeof(THRDCARETINFO),
1597                   TAG_MSGQ);
1598
1599    if (!MessageQueue)
1600    {
1601       return NULL;
1602    }
1603
1604    RtlZeroMemory(MessageQueue, sizeof(USER_MESSAGE_QUEUE) + sizeof(THRDCARETINFO));
1605    /* hold at least one reference until it'll be destroyed */
1606    IntReferenceMessageQueue(MessageQueue);
1607    /* initialize the queue */
1608    if (!MsqInitializeMessageQueue(Thread, MessageQueue))
1609    {
1610       IntDereferenceMessageQueue(MessageQueue);
1611       return NULL;
1612    }
1613
1614    return MessageQueue;
1615 }
1616
1617 VOID FASTCALL
1618 MsqDestroyMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
1619 {
1620    PDESKTOP desk;
1621
1622    /* remove the message queue from any desktops */
1623    if ((desk = InterlockedExchangePointer((PVOID*)&MessageQueue->Desktop, 0)))
1624    {
1625       (void)InterlockedExchangePointer((PVOID*)&desk->ActiveMessageQueue, 0);
1626       IntDereferenceMessageQueue(MessageQueue);
1627    }
1628
1629    /* clean it up */
1630    MsqCleanupMessageQueue(MessageQueue);
1631
1632    /* decrease the reference counter, if it hits zero, the queue will be freed */
1633    IntDereferenceMessageQueue(MessageQueue);
1634 }
1635
1636 PHOOKTABLE FASTCALL
1637 MsqGetHooks(PUSER_MESSAGE_QUEUE Queue)
1638 {
1639    return Queue->Hooks;
1640 }
1641
1642 VOID FASTCALL
1643 MsqSetHooks(PUSER_MESSAGE_QUEUE Queue, PHOOKTABLE Hooks)
1644 {
1645    Queue->Hooks = Hooks;
1646 }
1647
1648 LPARAM FASTCALL
1649 MsqSetMessageExtraInfo(LPARAM lParam)
1650 {
1651    LPARAM Ret;
1652    PTHREADINFO pti;
1653    PUSER_MESSAGE_QUEUE MessageQueue;
1654
1655    pti = PsGetCurrentThreadWin32Thread();
1656    MessageQueue = pti->MessageQueue;
1657    if(!MessageQueue)
1658    {
1659       return 0;
1660    }
1661
1662    Ret = MessageQueue->ExtraInfo;
1663    MessageQueue->ExtraInfo = lParam;
1664
1665    return Ret;
1666 }
1667
1668 LPARAM FASTCALL
1669 MsqGetMessageExtraInfo(VOID)
1670 {
1671    PTHREADINFO pti;
1672    PUSER_MESSAGE_QUEUE MessageQueue;
1673
1674    pti = PsGetCurrentThreadWin32Thread();
1675    MessageQueue = pti->MessageQueue;
1676    if(!MessageQueue)
1677    {
1678       return 0;
1679    }
1680
1681    return MessageQueue->ExtraInfo;
1682 }
1683
1684 HWND FASTCALL
1685 MsqSetStateWindow(PUSER_MESSAGE_QUEUE MessageQueue, ULONG Type, HWND hWnd)
1686 {
1687    HWND Prev;
1688
1689    switch(Type)
1690    {
1691       case MSQ_STATE_CAPTURE:
1692          Prev = MessageQueue->CaptureWindow;
1693          MessageQueue->CaptureWindow = hWnd;
1694          return Prev;
1695       case MSQ_STATE_ACTIVE:
1696          Prev = MessageQueue->ActiveWindow;
1697          MessageQueue->ActiveWindow = hWnd;
1698          return Prev;
1699       case MSQ_STATE_FOCUS:
1700          Prev = MessageQueue->FocusWindow;
1701          MessageQueue->FocusWindow = hWnd;
1702          return Prev;
1703       case MSQ_STATE_MENUOWNER:
1704          Prev = MessageQueue->MenuOwner;
1705          MessageQueue->MenuOwner = hWnd;
1706          return Prev;
1707       case MSQ_STATE_MOVESIZE:
1708          Prev = MessageQueue->MoveSize;
1709          MessageQueue->MoveSize = hWnd;
1710          return Prev;
1711       case MSQ_STATE_CARET:
1712          ASSERT(MessageQueue->CaretInfo);
1713          Prev = MessageQueue->CaretInfo->hWnd;
1714          MessageQueue->CaretInfo->hWnd = hWnd;
1715          return Prev;
1716    }
1717
1718    return NULL;
1719 }
1720
1721 #ifndef NDEBUG
1722 static VOID FASTCALL
1723 DumpTimerList(PUSER_MESSAGE_QUEUE MessageQueue)
1724 {
1725    PLIST_ENTRY Current;
1726    PTIMER_ENTRY Timer;
1727
1728    Current = MessageQueue->TimerListHead.Flink;
1729    if (Current == &MessageQueue->TimerListHead)
1730    {
1731       DPRINT("timer list is empty for queue %p\n", MessageQueue);
1732    }
1733    while (Current != &MessageQueue->TimerListHead)
1734    {
1735       Timer = CONTAINING_RECORD(Current, TIMER_ENTRY, ListEntry);
1736       DPRINT("queue %p timer %p expiry %I64d wnd %x id %p period %u timerproc %p msg %u\n",
1737              MessageQueue, Timer, Timer->ExpiryTime.QuadPart, Timer->Wnd, Timer->IDEvent,
1738              Timer->Period, Timer->TimerFunc, Timer->Msg);
1739       Current = Current->Flink;
1740    }
1741 }
1742 #endif /* ! defined(NDEBUG) */
1743
1744 /* Must have the message queue locked while calling this */
1745 static VOID FASTCALL
1746 InsertTimer(PUSER_MESSAGE_QUEUE MessageQueue, PTIMER_ENTRY NewTimer)
1747 {
1748    PLIST_ENTRY Current;
1749
1750    Current = MessageQueue->TimerListHead.Flink;
1751    while (Current != &MessageQueue->TimerListHead)
1752    {
1753       if (NewTimer->ExpiryTime.QuadPart <
1754             CONTAINING_RECORD(Current, TIMER_ENTRY, ListEntry)->ExpiryTime.QuadPart)
1755       {
1756          break;
1757       }
1758       Current = Current->Flink;
1759    }
1760
1761    InsertTailList(Current, &NewTimer->ListEntry);
1762 }
1763
1764 /* Must have the message queue locked while calling this */
1765 static PTIMER_ENTRY FASTCALL
1766 RemoveTimer(PUSER_MESSAGE_QUEUE MessageQueue, HWND Wnd, UINT_PTR IDEvent, UINT Msg)
1767 {
1768    PTIMER_ENTRY Timer;
1769    PLIST_ENTRY EnumEntry;
1770
1771    /* Remove timer if already in the queue */
1772    EnumEntry = MessageQueue->TimerListHead.Flink;
1773    while (EnumEntry != &MessageQueue->TimerListHead)
1774    {
1775       Timer = CONTAINING_RECORD(EnumEntry, TIMER_ENTRY, ListEntry);
1776       EnumEntry = EnumEntry->Flink;
1777
1778       if (Timer->Wnd == Wnd &&
1779             Timer->IDEvent == IDEvent &&
1780             Timer->Msg == Msg)
1781       {
1782          RemoveEntryList(&Timer->ListEntry);
1783          return Timer;
1784       }
1785    }
1786
1787    return NULL;
1788 }
1789
1790 BOOLEAN FASTCALL
1791 MsqSetTimer(PUSER_MESSAGE_QUEUE MessageQueue, HWND Wnd,
1792             UINT_PTR IDEvent, UINT Period, TIMERPROC TimerFunc,
1793             UINT Msg)
1794 {
1795    PTIMER_ENTRY Timer;
1796    LARGE_INTEGER CurrentTime;
1797
1798    DPRINT("MsqSetTimer queue %p wnd %x id %p period %u timerproc %p msg %d\n",
1799           MessageQueue, Wnd, IDEvent, Period, TimerFunc, Msg);
1800
1801    Timer = RemoveTimer(MessageQueue, Wnd, IDEvent, Msg);
1802    if (NULL == Timer)
1803    {
1804       Timer = ExAllocateFromPagedLookasideList(&TimerLookasideList);
1805       if (NULL == Timer)
1806       {
1807          DPRINT1("Failed to allocate timer entry\n");
1808          return FALSE;
1809       }
1810       DPRINT("Allocated new timer entry %p\n", Timer);
1811       Timer->Wnd = Wnd;
1812       Timer->IDEvent = IDEvent;
1813       Timer->Msg = Msg;
1814    }
1815    else
1816    {
1817       DPRINT("Updating existing timer entry %p\n", Timer);
1818    }
1819
1820    KeQuerySystemTime(&CurrentTime);
1821    Timer->ExpiryTime.QuadPart = CurrentTime.QuadPart +
1822                                 (ULONGLONG) Period * (ULONGLONG) 10000;
1823    Timer->Period = Period;
1824    Timer->TimerFunc = TimerFunc;
1825    DPRINT("Insert timer now %I64d expiry %I64d\n", CurrentTime.QuadPart,
1826           Timer->ExpiryTime.QuadPart);
1827
1828    InsertTimer(MessageQueue, Timer);
1829
1830 #ifndef NDEBUG
1831
1832    DumpTimerList(MessageQueue);
1833 #endif /* ! defined(NDEBUG) */
1834
1835    return TRUE;
1836 }
1837
1838 BOOLEAN FASTCALL
1839 MsqKillTimer(PUSER_MESSAGE_QUEUE MessageQueue, HWND Wnd,
1840              UINT_PTR IDEvent, UINT Msg)
1841 {
1842    PTIMER_ENTRY Timer;
1843
1844    DPRINT("MsqKillTimer queue %p wnd %x id %p msg %d\n",
1845           MessageQueue, Wnd, IDEvent, Msg);
1846
1847    Timer = RemoveTimer(MessageQueue, Wnd, IDEvent, Msg);
1848
1849    if (NULL == Timer)
1850    {
1851       DPRINT("Failed to remove timer from list, not found\n");
1852    }
1853    else
1854    {
1855       ExFreeToPagedLookasideList(&TimerLookasideList, Timer);
1856    }
1857
1858 #ifndef NDEBUG
1859    DumpTimerList(MessageQueue);
1860 #endif /* ! defined(NDEBUG) */
1861
1862    return NULL != Timer;
1863 }
1864
1865 BOOLEAN FASTCALL
1866 MsqGetTimerMessage(PUSER_MESSAGE_QUEUE MessageQueue,
1867                    PWINDOW_OBJECT WindowFilter, UINT MsgFilterMin, UINT MsgFilterMax,
1868                    MSG *Msg, BOOLEAN Restart)
1869 {
1870    PTIMER_ENTRY Timer;
1871    LARGE_INTEGER CurrentTime;
1872    LARGE_INTEGER LargeTickCount;
1873    PLIST_ENTRY EnumEntry;
1874    BOOLEAN GotMessage;
1875
1876    DPRINT("MsqGetTimerMessage queue %p msg %p restart %s\n",
1877           MessageQueue, Msg, Restart ? "TRUE" : "FALSE");
1878
1879    KeQuerySystemTime(&CurrentTime);
1880    DPRINT("Current time %I64d\n", CurrentTime.QuadPart);
1881    EnumEntry = MessageQueue->TimerListHead.Flink;
1882    GotMessage = FALSE;
1883    while (EnumEntry != &MessageQueue->TimerListHead)
1884    {
1885       Timer = CONTAINING_RECORD(MessageQueue->TimerListHead.Flink,
1886                                 TIMER_ENTRY, ListEntry);
1887       DPRINT("Checking timer %p wnd %x expiry %I64d\n", Timer, Timer->Wnd,
1888              Timer->ExpiryTime.QuadPart);
1889       EnumEntry = EnumEntry->Flink;
1890       if ((NULL == WindowFilter || Timer->Wnd == WindowFilter->hSelf) &&
1891             ((MsgFilterMin == 0 && MsgFilterMax == 0) ||
1892              (MsgFilterMin <= Timer->Msg &&
1893               Timer->Msg <= MsgFilterMax)))
1894       {
1895          if (Timer->ExpiryTime.QuadPart <= CurrentTime.QuadPart)
1896          {
1897             DPRINT("Timer is expired\n");
1898             GotMessage = TRUE;
1899             break;
1900          }
1901          else
1902          {
1903             DPRINT("No need to check later timers\n");
1904             break;
1905          }
1906       }
1907       else
1908       {
1909          DPRINT("timer %p (wnd %x msg %d) failed filter wnd %x msgmin %d msgmax %d\n",
1910                 Timer, Timer->Wnd, Timer->Msg, WindowFilter->hSelf, MsgFilterMin, MsgFilterMax);
1911       }
1912    }
1913
1914    if (! GotMessage)
1915    {
1916       DPRINT("No timer pending\n");
1917       return FALSE;
1918    }
1919
1920    Msg->hwnd = Timer->Wnd;
1921    Msg->message = Timer->Msg;
1922    Msg->wParam = (WPARAM) Timer->IDEvent;
1923    Msg->lParam = (LPARAM) Timer->TimerFunc;
1924    KeQueryTickCount(&LargeTickCount);
1925    Msg->time = MsqCalculateMessageTime(&LargeTickCount);
1926    Msg->pt = gpsi->ptCursor;
1927
1928    if (Restart)
1929    {
1930       RemoveEntryList(&Timer->ListEntry);
1931       Timer->ExpiryTime.QuadPart = CurrentTime.QuadPart +
1932                                    (ULONGLONG) Timer->Period * (ULONGLONG) 10000;
1933       DPRINT("Restarting timer %p expires %I64d\n", Timer, Timer->ExpiryTime.QuadPart);
1934       InsertTimer(MessageQueue, Timer);
1935
1936 #ifndef NDEBUG
1937
1938       DumpTimerList(MessageQueue);
1939 #endif /* ! defined(NDEBUG) */
1940
1941    }
1942
1943    DPRINT("Created message wnd %x msg %d wParam %u lParam %u\n", Msg->hwnd, Msg->message,
1944           Msg->wParam, Msg->lParam);
1945
1946    return TRUE;
1947 }
1948
1949 VOID FASTCALL
1950 MsqRemoveTimersWindow(PUSER_MESSAGE_QUEUE MessageQueue, HWND Wnd)
1951 {
1952    PTIMER_ENTRY Timer;
1953    PLIST_ENTRY EnumEntry;
1954
1955    DPRINT("MsqRemoveTimersWindow queue %p wnd %x\n", MessageQueue, Wnd);
1956
1957    EnumEntry = MessageQueue->TimerListHead.Flink;
1958    while (EnumEntry != &MessageQueue->TimerListHead)
1959    {
1960       Timer = CONTAINING_RECORD(EnumEntry, TIMER_ENTRY, ListEntry);
1961       EnumEntry = EnumEntry->Flink;
1962       if (Timer->Wnd == Wnd)
1963       {
1964          DPRINT("Removing timer %p because its window is going away\n", Timer);
1965          RemoveEntryList(&Timer->ListEntry);
1966          ExFreeToPagedLookasideList(&TimerLookasideList, Timer);
1967       }
1968    }
1969
1970 #ifndef NDEBUG
1971    DumpTimerList(MessageQueue);
1972 #endif /* ! defined(NDEBUG) */
1973
1974 }
1975
1976 BOOLEAN FASTCALL
1977 MsqGetFirstTimerExpiry(PUSER_MESSAGE_QUEUE MessageQueue,
1978                        PWINDOW_OBJECT WndFilter, UINT MsgFilterMin, UINT MsgFilterMax,
1979                        PLARGE_INTEGER FirstTimerExpiry)
1980 {
1981    PTIMER_ENTRY Timer;
1982    PLIST_ENTRY EnumEntry;
1983
1984    DPRINT("MsqGetFirstTimerExpiry queue %p wndfilter %x msgfiltermin %d msgfiltermax %d expiry %p\n",
1985           MessageQueue, WndFilter, MsgFilterMin, MsgFilterMax, FirstTimerExpiry);
1986
1987    EnumEntry = MessageQueue->TimerListHead.Flink;
1988    while (EnumEntry != &MessageQueue->TimerListHead)
1989    {
1990       Timer = CONTAINING_RECORD(MessageQueue->TimerListHead.Flink,
1991                                 TIMER_ENTRY, ListEntry);
1992       EnumEntry = EnumEntry->Flink;
1993       if ((NULL == WndFilter || PtrToInt(WndFilter) == 1 || Timer->Wnd == WndFilter->hSelf) &&
1994             ((MsgFilterMin == 0 && MsgFilterMax == 0) ||
1995              (MsgFilterMin <= Timer->Msg &&
1996               Timer->Msg <= MsgFilterMax)))
1997       {
1998          *FirstTimerExpiry = Timer->ExpiryTime;
1999          DPRINT("First timer expires %I64d\n", Timer->ExpiryTime);
2000          return TRUE;
2001       }
2002    }
2003
2004    return FALSE;
2005 }
2006
2007 /* EOF */