git.oblomov.eu Git - wine/blob - windows/queue.c

   1 /* * Message queues related functions
   2  *
   3  * Copyright 1993, 1994 Alexandre Julliard
   4  */
   5
   6 #include <string.h>
   7 #include <signal.h>
   8 #include <assert.h>
   9 #include "windef.h"
  10 #include "wingdi.h"
  11 #include "winerror.h"
  12 #include "wine/winbase16.h"
  13 #include "wine/winuser16.h"
  14 #include "queue.h"
  15 #include "win.h"
  16 #include "hook.h"
  17 #include "heap.h"
  18 #include "thread.h"
  19 #include "debugtools.h"
  20 #include "server.h"
  21 #include "spy.h"
  22
  23 DECLARE_DEBUG_CHANNEL(msg);
  24 DECLARE_DEBUG_CHANNEL(sendmsg);
  25
  26 #define MAX_QUEUE_SIZE   120  /* Max. size of a message queue */
  27
  28 static HQUEUE16 hFirstQueue = 0;
  29 static HQUEUE16 hExitingQueue = 0;
  30 static HQUEUE16 hmemSysMsgQueue = 0;
  31 static MESSAGEQUEUE *sysMsgQueue = NULL;
  32 static PERQUEUEDATA *pQDataWin16 = NULL;  /* Global perQData for Win16 tasks */
  33
  34 static MESSAGEQUEUE *pMouseQueue = NULL;  /* Queue for last mouse message */
  35 static MESSAGEQUEUE *pKbdQueue = NULL;    /* Queue for last kbd message */
  36
  37 HQUEUE16 hCursorQueue = 0;
  38 HQUEUE16 hActiveQueue = 0;
  39
  40
  41 /***********************************************************************
  42  *           PERQDATA_CreateInstance
  43  *
  44  * Creates an instance of a reference counted PERQUEUEDATA element
  45  * for the message queue. perQData is stored globally for 16 bit tasks.
  46  *
  47  * Note: We don't implement perQdata exactly the same way Windows does.
  48  * Each perQData element is reference counted since it may be potentially
  49  * shared by multiple message Queues (via AttachThreadInput).
  50  * We only store the current values for Active, Capture and focus windows
  51  * currently.
  52  */
  53 PERQUEUEDATA * PERQDATA_CreateInstance( )
  54 {
  55     PERQUEUEDATA *pQData;
  56
  57     BOOL16 bIsWin16 = 0;
  58
  59     TRACE_(msg)("()\n");
  60
  61     /* Share a single instance of perQData for all 16 bit tasks */
  62     if ( ( bIsWin16 = THREAD_IsWin16( NtCurrentTeb() ) ) )
  63     {
  64         /* If previously allocated, just bump up ref count */
  65         if ( pQDataWin16 )
  66         {
  67             PERQDATA_Addref( pQDataWin16 );
  68             return pQDataWin16;
  69         }
  70     }
  71
  72     /* Allocate PERQUEUEDATA from the system heap */
  73     if (!( pQData = (PERQUEUEDATA *) HeapAlloc( SystemHeap, 0,
  74                                                     sizeof(PERQUEUEDATA) ) ))
  75         return 0;
  76
  77     /* Initialize */
  78     pQData->hWndCapture = pQData->hWndFocus = pQData->hWndActive = 0;
  79     pQData->ulRefCount = 1;
  80     pQData->nCaptureHT = HTCLIENT;
  81
  82     /* Note: We have an independent critical section for the per queue data
  83      * since this may be shared by different threads. see AttachThreadInput()
  84      */
  85     InitializeCriticalSection( &pQData->cSection );
  86     /* FIXME: not all per queue data critical sections should be global */
  87     MakeCriticalSectionGlobal( &pQData->cSection );
  88
  89     /* Save perQData globally for 16 bit tasks */
  90     if ( bIsWin16 )
  91         pQDataWin16 = pQData;
  92
  93     return pQData;
  94 }
  95
  96
  97 /***********************************************************************
  98  *           PERQDATA_Addref
  99  *
 100  * Increment reference count for the PERQUEUEDATA instance
 101  * Returns reference count for debugging purposes
 102  */
 103 ULONG PERQDATA_Addref( PERQUEUEDATA *pQData )
 104 {
 105     assert(pQData != 0 );
 106     TRACE_(msg)("(): current refcount %lu ...\n", pQData->ulRefCount);
 107
 108     EnterCriticalSection( &pQData->cSection );
 109     ++pQData->ulRefCount;
 110     LeaveCriticalSection( &pQData->cSection );
 111
 112     return pQData->ulRefCount;
 113 }
 114
 115
 116 /***********************************************************************
 117  *           PERQDATA_Release
 118  *
 119  * Release a reference to a PERQUEUEDATA instance.
 120  * Destroy the instance if no more references exist
 121  * Returns reference count for debugging purposes
 122  */
 123 ULONG PERQDATA_Release( PERQUEUEDATA *pQData )
 124 {
 125     assert(pQData != 0 );
 126     TRACE_(msg)("(): current refcount %lu ...\n",
 127           (LONG)pQData->ulRefCount );
 128
 129     EnterCriticalSection( &pQData->cSection );
 130     if ( --pQData->ulRefCount == 0 )
 131     {
 132         LeaveCriticalSection( &pQData->cSection );
 133         DeleteCriticalSection( &pQData->cSection );
 134
 135         TRACE_(msg)("(): deleting PERQUEUEDATA instance ...\n" );
 136
 137         /* Deleting our global 16 bit perQData? */
 138         if ( pQData == pQDataWin16 )
 139             pQDataWin16 = 0;
 140
 141         /* Free the PERQUEUEDATA instance */
 142         HeapFree( SystemHeap, 0, pQData );
 143
 144         return 0;
 145     }
 146     LeaveCriticalSection( &pQData->cSection );
 147
 148     return pQData->ulRefCount;
 149 }
 150
 151
 152 /***********************************************************************
 153  *           PERQDATA_GetFocusWnd
 154  *
 155  * Get the focus hwnd member in a threadsafe manner
 156  */
 157 HWND PERQDATA_GetFocusWnd( PERQUEUEDATA *pQData )
 158 {
 159     HWND hWndFocus;
 160     assert(pQData != 0 );
 161
 162     EnterCriticalSection( &pQData->cSection );
 163     hWndFocus = pQData->hWndFocus;
 164     LeaveCriticalSection( &pQData->cSection );
 165
 166     return hWndFocus;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           PERQDATA_SetFocusWnd
 172  *
 173  * Set the focus hwnd member in a threadsafe manner
 174  */
 175 HWND PERQDATA_SetFocusWnd( PERQUEUEDATA *pQData, HWND hWndFocus )
 176 {
 177     HWND hWndFocusPrv;
 178     assert(pQData != 0 );
 179
 180     EnterCriticalSection( &pQData->cSection );
 181     hWndFocusPrv = pQData->hWndFocus;
 182     pQData->hWndFocus = hWndFocus;
 183     LeaveCriticalSection( &pQData->cSection );
 184
 185     return hWndFocusPrv;
 186 }
 187
 188
 189 /***********************************************************************
 190  *           PERQDATA_GetActiveWnd
 191  *
 192  * Get the active hwnd member in a threadsafe manner
 193  */
 194 HWND PERQDATA_GetActiveWnd( PERQUEUEDATA *pQData )
 195 {
 196     HWND hWndActive;
 197     assert(pQData != 0 );
 198
 199     EnterCriticalSection( &pQData->cSection );
 200     hWndActive = pQData->hWndActive;
 201     LeaveCriticalSection( &pQData->cSection );
 202
 203     return hWndActive;
 204 }
 205
 206
 207 /***********************************************************************
 208  *           PERQDATA_SetActiveWnd
 209  *
 210  * Set the active focus hwnd member in a threadsafe manner
 211  */
 212 HWND PERQDATA_SetActiveWnd( PERQUEUEDATA *pQData, HWND hWndActive )
 213 {
 214     HWND hWndActivePrv;
 215     assert(pQData != 0 );
 216
 217     EnterCriticalSection( &pQData->cSection );
 218     hWndActivePrv = pQData->hWndActive;
 219     pQData->hWndActive = hWndActive;
 220     LeaveCriticalSection( &pQData->cSection );
 221
 222     return hWndActivePrv;
 223 }
 224
 225
 226 /***********************************************************************
 227  *           PERQDATA_GetCaptureWnd
 228  *
 229  * Get the capture hwnd member in a threadsafe manner
 230  */
 231 HWND PERQDATA_GetCaptureWnd( PERQUEUEDATA *pQData )
 232 {
 233     HWND hWndCapture;
 234     assert(pQData != 0 );
 235
 236     EnterCriticalSection( &pQData->cSection );
 237     hWndCapture = pQData->hWndCapture;
 238     LeaveCriticalSection( &pQData->cSection );
 239
 240     return hWndCapture;
 241 }
 242
 243
 244 /***********************************************************************
 245  *           PERQDATA_SetCaptureWnd
 246  *
 247  * Set the capture hwnd member in a threadsafe manner
 248  */
 249 HWND PERQDATA_SetCaptureWnd( PERQUEUEDATA *pQData, HWND hWndCapture )
 250 {
 251     HWND hWndCapturePrv;
 252     assert(pQData != 0 );
 253
 254     EnterCriticalSection( &pQData->cSection );
 255     hWndCapturePrv = pQData->hWndCapture;
 256     pQData->hWndCapture = hWndCapture;
 257     LeaveCriticalSection( &pQData->cSection );
 258
 259     return hWndCapturePrv;
 260 }
 261
 262
 263 /***********************************************************************
 264  *           PERQDATA_GetCaptureInfo
 265  *
 266  * Get the capture info member in a threadsafe manner
 267  */
 268 INT16 PERQDATA_GetCaptureInfo( PERQUEUEDATA *pQData )
 269 {
 270     INT16 nCaptureHT;
 271     assert(pQData != 0 );
 272
 273     EnterCriticalSection( &pQData->cSection );
 274     nCaptureHT = pQData->nCaptureHT;
 275     LeaveCriticalSection( &pQData->cSection );
 276
 277     return nCaptureHT;
 278 }
 279
 280
 281 /***********************************************************************
 282  *           PERQDATA_SetCaptureInfo
 283  *
 284  * Set the capture info member in a threadsafe manner
 285  */
 286 INT16 PERQDATA_SetCaptureInfo( PERQUEUEDATA *pQData, INT16 nCaptureHT )
 287 {
 288     INT16 nCaptureHTPrv;
 289     assert(pQData != 0 );
 290
 291     EnterCriticalSection( &pQData->cSection );
 292     nCaptureHTPrv = pQData->nCaptureHT;
 293     pQData->nCaptureHT = nCaptureHT;
 294     LeaveCriticalSection( &pQData->cSection );
 295
 296     return nCaptureHTPrv;
 297 }
 298
 299
 300 /***********************************************************************
 301  *           QUEUE_Lock
 302  *
 303  * Function for getting a 32 bit pointer on queue structure. For thread
 304  * safeness programmers should use this function instead of GlobalLock to
 305  * retrieve a pointer on the structure. QUEUE_Unlock should also be called
 306  * when access to the queue structure is not required anymore.
 307  */
 308 MESSAGEQUEUE *QUEUE_Lock( HQUEUE16 hQueue )
 309 {
 310     MESSAGEQUEUE *queue;
 311
 312     HeapLock( SystemHeap );  /* FIXME: a bit overkill */
 313     queue = GlobalLock16( hQueue );
 314     if ( !queue || (queue->magic != QUEUE_MAGIC) )
 315     {
 316         HeapUnlock( SystemHeap );
 317         return NULL;
 318     }
 319
 320     queue->lockCount++;
 321     HeapUnlock( SystemHeap );
 322     return queue;
 323 }
 324
 325
 326 /***********************************************************************
 327  *           QUEUE_Unlock
 328  *
 329  * Use with QUEUE_Lock to get a thread safe access to message queue
 330  * structure
 331  */
 332 void QUEUE_Unlock( MESSAGEQUEUE *queue )
 333 {
 334     if (queue)
 335     {
 336         HeapLock( SystemHeap );  /* FIXME: a bit overkill */
 337
 338         if ( --queue->lockCount == 0 )
 339         {
 340             DeleteCriticalSection ( &queue->cSection );
 341             if (queue->server_queue)
 342                 CloseHandle( queue->server_queue );
 343             GlobalFree16( queue->self );
 344         }
 345
 346         HeapUnlock( SystemHeap );
 347     }
 348 }
 349
 350
 351 /***********************************************************************
 352  *           QUEUE_DumpQueue
 353  */
 354 void QUEUE_DumpQueue( HQUEUE16 hQueue )
 355 {
 356     MESSAGEQUEUE *pq;
 357
 358     if (!(pq = QUEUE_Lock( hQueue )) )
 359     {
 360         WARN_(msg)("%04x is not a queue handle\n", hQueue );
 361         return;
 362     }
 363
 364     EnterCriticalSection( &pq->cSection );
 365
 366     DPRINTF( "next: %12.4x  Intertask SendMessage:\n"
 367              "thread: %10p  ----------------------\n"
 368              "firstMsg: %8p   smWaiting:     %10p\n"
 369              "lastMsg:  %8p   smPending:     %10p\n"
 370              "msgCount: %8.4x   smProcessing:  %10p\n"
 371              "lockCount: %7.4x\n"
 372              "paints: %10.4x\n"
 373              "timers: %10.4x\n"
 374              "wakeBits: %8.4x\n"
 375              "wakeMask: %8.4x\n"
 376              "hCurHook: %8.4x\n",
 377              pq->next, pq->teb, pq->firstMsg, pq->smWaiting, pq->lastMsg,
 378              pq->smPending, pq->msgCount, pq->smProcessing,
 379              (unsigned)pq->lockCount, pq->wPaintCount, pq->wTimerCount,
 380              pq->wakeBits, pq->wakeMask, pq->hCurHook);
 381
 382     LeaveCriticalSection( &pq->cSection );
 383
 384     QUEUE_Unlock( pq );
 385 }
 386
 387
 388 /***********************************************************************
 389  *           QUEUE_WalkQueues
 390  */
 391 void QUEUE_WalkQueues(void)
 392 {
 393     char module[10];
 394     HQUEUE16 hQueue = hFirstQueue;
 395
 396     DPRINTF( "Queue Msgs Thread   Task Module\n" );
 397     while (hQueue)
 398     {
 399         MESSAGEQUEUE *queue = QUEUE_Lock( hQueue );
 400         if (!queue)
 401         {
 402             WARN_(msg)("Bad queue handle %04x\n", hQueue );
 403             return;
 404         }
 405         if (!GetModuleName16( queue->teb->htask16, module, sizeof(module )))
 406             strcpy( module, "???" );
 407         DPRINTF( "%04x %4d %p %04x %s\n", hQueue,queue->msgCount,
 408                  queue->teb, queue->teb->htask16, module );
 409         hQueue = queue->next;
 410         QUEUE_Unlock( queue );
 411     }
 412     DPRINTF( "\n" );
 413 }
 414
 415
 416 /***********************************************************************
 417  *           QUEUE_IsExitingQueue
 418  */
 419 BOOL QUEUE_IsExitingQueue( HQUEUE16 hQueue )
 420 {
 421     return (hExitingQueue && (hQueue == hExitingQueue));
 422 }
 423
 424
 425 /***********************************************************************
 426  *           QUEUE_SetExitingQueue
 427  */
 428 void QUEUE_SetExitingQueue( HQUEUE16 hQueue )
 429 {
 430     hExitingQueue = hQueue;
 431 }
 432
 433
 434 /***********************************************************************
 435  *           QUEUE_CreateMsgQueue
 436  *
 437  * Creates a message queue. Doesn't link it into queue list!
 438  */
 439 static HQUEUE16 QUEUE_CreateMsgQueue( BOOL16 bCreatePerQData )
 440 {
 441     HQUEUE16 hQueue;
 442     HANDLE handle;
 443     MESSAGEQUEUE * msgQueue;
 444
 445     TRACE_(msg)("(): Creating message queue...\n");
 446
 447     if (!(hQueue = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT,
 448                                   sizeof(MESSAGEQUEUE) )))
 449         return 0;
 450
 451     msgQueue = (MESSAGEQUEUE *) GlobalLock16( hQueue );
 452     if ( !msgQueue )
 453         return 0;
 454
 455     SERVER_START_REQ
 456     {
 457         struct get_msg_queue_request *req = server_alloc_req( sizeof(*req), 0 );
 458         server_call( REQ_GET_MSG_QUEUE );
 459         handle = req->handle;
 460     }
 461     SERVER_END_REQ;
 462     if (!handle)
 463     {
 464         ERR_(msg)("Cannot get thread queue");
 465         GlobalFree16( hQueue );
 466         return 0;
 467     }
 468     msgQueue->server_queue = handle;
 469     msgQueue->server_queue = ConvertToGlobalHandle( msgQueue->server_queue );
 470
 471     msgQueue->self        = hQueue;
 472     msgQueue->wakeBits    = msgQueue->changeBits = 0;
 473
 474     InitializeCriticalSection( &msgQueue->cSection );
 475     MakeCriticalSectionGlobal( &msgQueue->cSection );
 476
 477     msgQueue->lockCount = 1;
 478     msgQueue->magic = QUEUE_MAGIC;
 479
 480     /* Create and initialize our per queue data */
 481     msgQueue->pQData = bCreatePerQData ? PERQDATA_CreateInstance() : NULL;
 482
 483     return hQueue;
 484 }
 485
 486
 487 /***********************************************************************
 488  *           QUEUE_FlushMessage
 489  *
 490  * Try to reply to all pending sent messages on exit.
 491  */
 492 static void QUEUE_FlushMessages( MESSAGEQUEUE *queue )
 493 {
 494     SMSG *smsg;
 495     MESSAGEQUEUE *senderQ = 0;
 496
 497     if( queue )
 498     {
 499         EnterCriticalSection( &queue->cSection );
 500
 501         /* empty the list of pending SendMessage waiting to be received */
 502         while (queue->smPending)
 503         {
 504             smsg = QUEUE_RemoveSMSG( queue, SM_PENDING_LIST, 0);
 505
 506             senderQ = QUEUE_Lock( smsg->hSrcQueue );
 507             if ( !senderQ )
 508                 continue;
 509
 510             /* return 0, to unblock other thread */
 511             smsg->lResult = 0;
 512             smsg->flags |= SMSG_HAVE_RESULT;
 513             QUEUE_SetWakeBit( senderQ, QS_SMRESULT);
 514
 515             QUEUE_Unlock( senderQ );
 516         }
 517
 518         QUEUE_ClearWakeBit( queue, QS_SENDMESSAGE );
 519
 520         LeaveCriticalSection( &queue->cSection );
 521     }
 522 }
 523
 524
 525 /***********************************************************************
 526  *           QUEUE_DeleteMsgQueue
 527  *
 528  * Unlinks and deletes a message queue.
 529  *
 530  * Note: We need to mask asynchronous events to make sure PostMessage works
 531  * even in the signal handler.
 532  */
 533 BOOL QUEUE_DeleteMsgQueue( HQUEUE16 hQueue )
 534 {
 535     MESSAGEQUEUE * msgQueue = QUEUE_Lock(hQueue);
 536     HQUEUE16 *pPrev;
 537
 538     TRACE_(msg)("(): Deleting message queue %04x\n", hQueue);
 539
 540     if (!hQueue || !msgQueue)
 541     {
 542         ERR_(msg)("invalid argument.\n");
 543         return 0;
 544     }
 545
 546     msgQueue->magic = 0;
 547
 548     if( hCursorQueue == hQueue ) hCursorQueue = 0;
 549     if( hActiveQueue == hQueue ) hActiveQueue = 0;
 550
 551     /* flush sent messages */
 552     QUEUE_FlushMessages( msgQueue );
 553
 554     HeapLock( SystemHeap );  /* FIXME: a bit overkill */
 555
 556     /* Release per queue data if present */
 557     if ( msgQueue->pQData )
 558     {
 559         PERQDATA_Release( msgQueue->pQData );
 560         msgQueue->pQData = 0;
 561     }
 562
 563     /* remove the message queue from the global link list */
 564     pPrev = &hFirstQueue;
 565     while (*pPrev && (*pPrev != hQueue))
 566     {
 567         MESSAGEQUEUE *msgQ = (MESSAGEQUEUE*)GlobalLock16(*pPrev);
 568
 569         /* sanity check */
 570         if ( !msgQ || (msgQ->magic != QUEUE_MAGIC) )
 571         {
 572             /* HQUEUE link list is corrupted, try to exit gracefully */
 573             ERR_(msg)("HQUEUE link list corrupted!\n");
 574             pPrev = 0;
 575             break;
 576         }
 577         pPrev = &msgQ->next;
 578     }
 579     if (pPrev && *pPrev) *pPrev = msgQueue->next;
 580     msgQueue->self = 0;
 581
 582     HeapUnlock( SystemHeap );
 583
 584     /* free up resource used by MESSAGEQUEUE structure */
 585     msgQueue->lockCount--;
 586     QUEUE_Unlock( msgQueue );
 587
 588     return 1;
 589 }
 590
 591
 592 /***********************************************************************
 593  *           QUEUE_CreateSysMsgQueue
 594  *
 595  * Create the system message queue, and set the double-click speed.
 596  * Must be called only once.
 597  */
 598 BOOL QUEUE_CreateSysMsgQueue( int size )
 599 {
 600     /* Note: We dont need perQ data for the system message queue */
 601     if (!(hmemSysMsgQueue = QUEUE_CreateMsgQueue( FALSE )))
 602         return FALSE;
 603
 604     sysMsgQueue = (MESSAGEQUEUE *) GlobalLock16( hmemSysMsgQueue );
 605     return TRUE;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           QUEUE_GetSysQueue
 611  */
 612 MESSAGEQUEUE *QUEUE_GetSysQueue(void)
 613 {
 614     return sysMsgQueue;
 615 }
 616
 617
 618 /***********************************************************************
 619  *           QUEUE_SetWakeBit
 620  *
 621  * See "Windows Internals", p.449
 622  */
 623 static BOOL QUEUE_TrySetWakeBit( MESSAGEQUEUE *queue, WORD bit, BOOL always )
 624 {
 625     BOOL wake = FALSE;
 626
 627     EnterCriticalSection( &queue->cSection );
 628
 629     TRACE_(msg)("queue = %04x (wm=%04x), bit = %04x, always = %d\n",
 630                         queue->self, queue->wakeMask, bit, always );
 631
 632     if ((queue->wakeMask & bit) || always)
 633     {
 634         if (bit & QS_MOUSE) pMouseQueue = queue;
 635         if (bit & QS_KEY) pKbdQueue = queue;
 636         queue->changeBits |= bit;
 637         queue->wakeBits   |= bit;
 638     }
 639     if (queue->wakeMask & bit)
 640     {
 641         queue->wakeMask = 0;
 642         wake = TRUE;
 643     }
 644
 645     LeaveCriticalSection( &queue->cSection );
 646
 647     if ( wake )
 648     {
 649         /* Wake up thread waiting for message */
 650         if ( THREAD_IsWin16( queue->teb ) )
 651         {
 652             int iWndsLock = WIN_SuspendWndsLock();
 653             PostEvent16( queue->teb->htask16 );
 654             WIN_RestoreWndsLock( iWndsLock );
 655         }
 656         else
 657         {
 658             SERVER_START_REQ
 659             {
 660                 struct wake_queue_request *req = server_alloc_req( sizeof(*req), 0 );
 661                 req->handle = queue->server_queue;
 662                 req->bits   = bit;
 663                 server_call( REQ_WAKE_QUEUE );
 664             }
 665             SERVER_END_REQ;
 666         }
 667     }
 668
 669     return wake;
 670 }
 671 void QUEUE_SetWakeBit( MESSAGEQUEUE *queue, WORD bit )
 672 {
 673     QUEUE_TrySetWakeBit( queue, bit, TRUE );
 674 }
 675
 676
 677 /***********************************************************************
 678  *           QUEUE_ClearWakeBit
 679  */
 680 void QUEUE_ClearWakeBit( MESSAGEQUEUE *queue, WORD bit )
 681 {
 682     EnterCriticalSection( &queue->cSection );
 683     queue->changeBits &= ~bit;
 684     queue->wakeBits   &= ~bit;
 685     LeaveCriticalSection( &queue->cSection );
 686 }
 687
 688 /***********************************************************************
 689  *           QUEUE_TestWakeBit
 690  */
 691 WORD QUEUE_TestWakeBit( MESSAGEQUEUE *queue, WORD bit )
 692 {
 693     WORD ret;
 694     EnterCriticalSection( &queue->cSection );
 695     ret = queue->wakeBits & bit;
 696     LeaveCriticalSection( &queue->cSection );
 697     return ret;
 698 }
 699
 700
 701 /***********************************************************************
 702  *           QUEUE_WaitBits
 703  *
 704  * See "Windows Internals", p.447
 705  *
 706  * return values:
 707  *    0 if exit with timeout
 708  *    1 otherwise
 709  */
 710 int QUEUE_WaitBits( WORD bits, DWORD timeout )
 711 {
 712     MESSAGEQUEUE *queue;
 713     DWORD curTime = 0;
 714     HQUEUE16 hQueue;
 715
 716     TRACE_(msg)("q %04x waiting for %04x\n", GetFastQueue16(), bits);
 717
 718     if ( THREAD_IsWin16( NtCurrentTeb() ) && (timeout != INFINITE) )
 719         curTime = GetTickCount();
 720
 721     hQueue = GetFastQueue16();
 722     if (!(queue = QUEUE_Lock( hQueue ))) return 0;
 723
 724     for (;;)
 725     {
 726         EnterCriticalSection( &queue->cSection );
 727
 728         if (queue->changeBits & bits)
 729         {
 730             /* One of the bits is set; we can return */
 731             queue->wakeMask = 0;
 732
 733             LeaveCriticalSection( &queue->cSection );
 734             QUEUE_Unlock( queue );
 735             return 1;
 736         }
 737         if (queue->wakeBits & QS_SENDMESSAGE)
 738         {
 739             /* Process the sent message immediately */
 740             queue->wakeMask = 0;
 741
 742             LeaveCriticalSection( &queue->cSection );
 743             QUEUE_ReceiveMessage( queue );
 744             continue;                           /* nested sm crux */
 745         }
 746
 747         queue->wakeMask = bits | QS_SENDMESSAGE;
 748         TRACE_(msg)("%04x) wakeMask is %04x, waiting\n", queue->self, queue->wakeMask);
 749         LeaveCriticalSection( &queue->cSection );
 750
 751         if ( !THREAD_IsWin16( NtCurrentTeb() ) )
 752         {
 753             BOOL                bHasWin16Lock;
 754             DWORD               dwlc;
 755
 756             if ( (bHasWin16Lock = _ConfirmWin16Lock()) )
 757             {
 758                 TRACE_(msg)("bHasWin16Lock=TRUE\n");
 759                 ReleaseThunkLock( &dwlc );
 760             }
 761
 762             WaitForSingleObject( queue->server_queue, timeout );
 763
 764             if ( bHasWin16Lock )
 765             {
 766                 RestoreThunkLock( dwlc );
 767             }
 768         }
 769         else
 770         {
 771             if ( timeout == INFINITE )
 772                 WaitEvent16( 0 );  /* win 16 thread, use WaitEvent */
 773             else
 774             {
 775                 /* check for timeout, then give control to other tasks */
 776                 if (GetTickCount() - curTime > timeout)
 777                 {
 778
 779                     QUEUE_Unlock( queue );
 780                     return 0;   /* exit with timeout */
 781                 }
 782                 K32WOWYield16();
 783             }
 784         }
 785     }
 786 }
 787
 788
 789 /***********************************************************************
 790  *           QUEUE_AddSMSG
 791  *
 792  * This routine is called when a SMSG need to be added to one of the three
 793  * SM list.  (SM_PROCESSING_LIST, SM_PENDING_LIST, SM_WAITING_LIST)
 794  */
 795 BOOL QUEUE_AddSMSG( MESSAGEQUEUE *queue, int list, SMSG *smsg )
 796 {
 797     TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
 798           smsg, SPY_GetMsgName(smsg->msg));
 799
 800     switch (list)
 801     {
 802         case SM_PROCESSING_LIST:
 803             /* don't need to be thread safe, only accessed by the
 804              thread associated with the sender queue */
 805             smsg->nextProcessing = queue->smProcessing;
 806             queue->smProcessing = smsg;
 807             break;
 808
 809         case SM_WAITING_LIST:
 810             /* don't need to be thread safe, only accessed by the
 811              thread associated with the receiver queue */
 812             smsg->nextWaiting = queue->smWaiting;
 813             queue->smWaiting = smsg;
 814             break;
 815
 816         case SM_PENDING_LIST:
 817         {
 818             /* make it thread safe, could be accessed by the sender and
 819              receiver thread */
 820             SMSG **prev;
 821
 822             EnterCriticalSection( &queue->cSection );
 823             smsg->nextPending = NULL;
 824             prev = &queue->smPending;
 825             while ( *prev )
 826                 prev = &(*prev)->nextPending;
 827             *prev = smsg;
 828             LeaveCriticalSection( &queue->cSection );
 829
 830             QUEUE_SetWakeBit( queue, QS_SENDMESSAGE );
 831             break;
 832         }
 833
 834         default:
 835             ERR_(sendmsg)("Invalid list: %d", list);
 836             break;
 837     }
 838
 839     return TRUE;
 840 }
 841
 842
 843 /***********************************************************************
 844  *           QUEUE_RemoveSMSG
 845  *
 846  * This routine is called when a SMSG needs to be removed from one of the three
 847  * SM lists (SM_PROCESSING_LIST, SM_PENDING_LIST, SM_WAITING_LIST).
 848  * If smsg == 0, remove the first smsg from the specified list
 849  */
 850 SMSG *QUEUE_RemoveSMSG( MESSAGEQUEUE *queue, int list, SMSG *smsg )
 851 {
 852
 853     switch (list)
 854     {
 855         case SM_PROCESSING_LIST:
 856             /* don't need to be thread safe, only accessed by the
 857              thread associated with the sender queue */
 858
 859             /* if smsg is equal to null, it means the first in the list */
 860             if (!smsg)
 861                 smsg = queue->smProcessing;
 862
 863             TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
 864                   smsg, SPY_GetMsgName(smsg->msg));
 865             /* In fact SM_PROCESSING_LIST is a stack, and smsg
 866              should be always at the top of the list */
 867             if ( (smsg != queue->smProcessing) || !queue->smProcessing )
 868             {
 869                 ERR_(sendmsg)("smsg not at the top of Processing list, smsg=0x%p queue=0x%p\n", smsg, queue);
 870                 return 0;
 871             }
 872             else
 873             {
 874                 queue->smProcessing = smsg->nextProcessing;
 875                 smsg->nextProcessing = 0;
 876             }
 877             return smsg;
 878
 879         case SM_WAITING_LIST:
 880             /* don't need to be thread safe, only accessed by the
 881              thread associated with the receiver queue */
 882
 883             /* if smsg is equal to null, it means the first in the list */
 884             if (!smsg)
 885                 smsg = queue->smWaiting;
 886
 887             TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
 888                   smsg, SPY_GetMsgName(smsg->msg));
 889             /* In fact SM_WAITING_LIST is a stack, and smsg
 890              should be always at the top of the list */
 891             if ( (smsg != queue->smWaiting) || !queue->smWaiting )
 892             {
 893                 ERR_(sendmsg)("smsg not at the top of Waiting list, smsg=0x%p queue=0x%p\n", smsg, queue);
 894                 return 0;
 895             }
 896             else
 897             {
 898                 queue->smWaiting = smsg->nextWaiting;
 899                 smsg->nextWaiting = 0;
 900             }
 901             return smsg;
 902
 903         case SM_PENDING_LIST:
 904             /* make it thread safe, could be accessed by the sender and
 905              receiver thread */
 906             EnterCriticalSection( &queue->cSection );
 907
 908             if (!smsg)
 909                 smsg = queue->smPending;
 910             if ( (smsg != queue->smPending) || !queue->smPending )
 911             {
 912                 ERR_(sendmsg)("should always remove the top one in Pending list, smsg=0x%p queue=0x%p\n", smsg, queue);
 913                 LeaveCriticalSection( &queue->cSection );
 914                 return 0;
 915             }
 916
 917             TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
 918                   smsg, SPY_GetMsgName(smsg->msg));
 919
 920             queue->smPending = smsg->nextPending;
 921             smsg->nextPending = 0;
 922
 923             /* if no more SMSG in Pending list, clear QS_SENDMESSAGE flag */
 924             if (!queue->smPending)
 925                 QUEUE_ClearWakeBit( queue, QS_SENDMESSAGE );
 926
 927             LeaveCriticalSection( &queue->cSection );
 928             return smsg;
 929
 930         default:
 931             ERR_(sendmsg)("Invalid list: %d\n", list);
 932             break;
 933     }
 934
 935     return 0;
 936 }
 937
 938
 939 /***********************************************************************
 940  *           QUEUE_ReceiveMessage
 941  *
 942  * This routine is called to check whether a sent message is waiting
 943  * for the queue.  If so, it is received and processed.
 944  */
 945 BOOL QUEUE_ReceiveMessage( MESSAGEQUEUE *queue )
 946 {
 947     LRESULT       result = 0;
 948     SMSG          *smsg;
 949     MESSAGEQUEUE  *senderQ;
 950
 951     EnterCriticalSection( &queue->cSection );
 952     if ( !((queue->wakeBits & QS_SENDMESSAGE) && queue->smPending) )
 953     {
 954         LeaveCriticalSection( &queue->cSection );
 955         return FALSE;
 956     }
 957     LeaveCriticalSection( &queue->cSection );
 958
 959     TRACE_(sendmsg)("queue %04x\n", queue->self );
 960
 961     /* remove smsg on the top of the pending list and put it in the processing list */
 962     smsg = QUEUE_RemoveSMSG(queue, SM_PENDING_LIST, 0);
 963     QUEUE_AddSMSG(queue, SM_WAITING_LIST, smsg);
 964
 965     TRACE_(sendmsg)("RM: %s [%04x] (%04x -> %04x)\n",
 966             SPY_GetMsgName(smsg->msg), smsg->msg, smsg->hSrcQueue, smsg->hDstQueue );
 967
 968     if (IsWindow( smsg->hWnd ))
 969     {
 970         WND *wndPtr = WIN_FindWndPtr( smsg->hWnd );
 971         DWORD extraInfo = queue->GetMessageExtraInfoVal; /* save ExtraInfo */
 972
 973         /* use sender queue extra info value while calling the window proc */
 974         senderQ = QUEUE_Lock( smsg->hSrcQueue );
 975         if (senderQ)
 976         {
 977             queue->GetMessageExtraInfoVal = senderQ->GetMessageExtraInfoVal;
 978             QUEUE_Unlock( senderQ );
 979         }
 980
 981         /* call the right version of CallWindowProcXX */
 982         if (smsg->flags & SMSG_WIN32)
 983         {
 984             TRACE_(sendmsg)("\trcm: msg is Win32\n" );
 985             if (smsg->flags & SMSG_UNICODE)
 986                 result = CallWindowProcW( wndPtr->winproc,
 987                                             smsg->hWnd, smsg->msg,
 988                                             smsg->wParam, smsg->lParam );
 989             else
 990                 result = CallWindowProcA( wndPtr->winproc,
 991                                             smsg->hWnd, smsg->msg,
 992                                             smsg->wParam, smsg->lParam );
 993         }
 994         else  /* Win16 message */
 995             result = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
 996                                        (HWND16) smsg->hWnd,
 997                                        (UINT16) smsg->msg,
 998                                        LOWORD (smsg->wParam),
 999                                        smsg->lParam );
1000
1001         queue->GetMessageExtraInfoVal = extraInfo;  /* Restore extra info */
1002         WIN_ReleaseWndPtr(wndPtr);
1003         TRACE_(sendmsg)("result =  %08x\n", (unsigned)result );
1004     }
1005     else WARN_(sendmsg)("\trcm: bad hWnd\n");
1006
1007
1008     /* set SMSG_SENDING_REPLY flag to tell ReplyMessage16, it's not
1009        an early reply */
1010     smsg->flags |= SMSG_SENDING_REPLY;
1011     ReplyMessage( result );
1012
1013     TRACE_(sendmsg)("done!\n" );
1014     return TRUE;
1015 }
1016
1017
1018
1019 /***********************************************************************
1020  *           QUEUE_AddMsg
1021  *
1022  * Add a message to the queue. Return FALSE if queue is full.
1023  */
1024 BOOL QUEUE_AddMsg( HQUEUE16 hQueue, int type, MSG *msg, DWORD extraInfo )
1025 {
1026     MESSAGEQUEUE *msgQueue;
1027     QMSG         *qmsg;
1028
1029
1030     if (!(msgQueue = QUEUE_Lock( hQueue ))) return FALSE;
1031
1032     /* allocate new message in global heap for now */
1033     if (!(qmsg = (QMSG *) HeapAlloc( SystemHeap, 0, sizeof(QMSG) ) ))
1034     {
1035         QUEUE_Unlock( msgQueue );
1036         return 0;
1037     }
1038
1039     EnterCriticalSection( &msgQueue->cSection );
1040
1041       /* Store message */
1042     qmsg->type = type;
1043     qmsg->msg = *msg;
1044     qmsg->extraInfo = extraInfo;
1045
1046     /* insert the message in the link list */
1047     qmsg->nextMsg = 0;
1048     qmsg->prevMsg = msgQueue->lastMsg;
1049
1050     if (msgQueue->lastMsg)
1051         msgQueue->lastMsg->nextMsg = qmsg;
1052
1053     /* update first and last anchor in message queue */
1054     msgQueue->lastMsg = qmsg;
1055     if (!msgQueue->firstMsg)
1056         msgQueue->firstMsg = qmsg;
1057
1058     msgQueue->msgCount++;
1059
1060     LeaveCriticalSection( &msgQueue->cSection );
1061
1062     QUEUE_SetWakeBit( msgQueue, QS_POSTMESSAGE );
1063     QUEUE_Unlock( msgQueue );
1064
1065     return TRUE;
1066 }
1067
1068
1069
1070 /***********************************************************************
1071  *           QUEUE_FindMsg
1072  *
1073  * Find a message matching the given parameters. Return -1 if none available.
1074  */
1075 QMSG* QUEUE_FindMsg( MESSAGEQUEUE * msgQueue, HWND hwnd, int first, int last )
1076 {
1077     QMSG* qmsg;
1078
1079     EnterCriticalSection( &msgQueue->cSection );
1080
1081     if (!msgQueue->msgCount)
1082         qmsg = 0;
1083     else if (!hwnd && !first && !last)
1084         qmsg = msgQueue->firstMsg;
1085     else
1086     {
1087         /* look in linked list for message matching first and last criteria */
1088         for (qmsg = msgQueue->firstMsg; qmsg; qmsg = qmsg->nextMsg)
1089         {
1090             MSG *msg = &(qmsg->msg);
1091
1092             if (!hwnd || (msg->hwnd == hwnd))
1093             {
1094                 if (!first && !last)
1095                     break;   /* found it */
1096
1097                 if ((msg->message >= first) && (!last || (msg->message <= last)))
1098                     break;   /* found it */
1099             }
1100         }
1101     }
1102
1103     LeaveCriticalSection( &msgQueue->cSection );
1104
1105     return qmsg;
1106 }
1107
1108
1109
1110 /***********************************************************************
1111  *           QUEUE_RemoveMsg
1112  *
1113  * Remove a message from the queue (pos must be a valid position).
1114  */
1115 void QUEUE_RemoveMsg( MESSAGEQUEUE * msgQueue, QMSG *qmsg )
1116 {
1117     EnterCriticalSection( &msgQueue->cSection );
1118
1119     /* set the linked list */
1120     if (qmsg->prevMsg)
1121         qmsg->prevMsg->nextMsg = qmsg->nextMsg;
1122
1123     if (qmsg->nextMsg)
1124         qmsg->nextMsg->prevMsg = qmsg->prevMsg;
1125
1126     if (msgQueue->firstMsg == qmsg)
1127         msgQueue->firstMsg = qmsg->nextMsg;
1128
1129     if (msgQueue->lastMsg == qmsg)
1130         msgQueue->lastMsg = qmsg->prevMsg;
1131
1132     /* deallocate the memory for the message */
1133     HeapFree( SystemHeap, 0, qmsg );
1134
1135     msgQueue->msgCount--;
1136     if (!msgQueue->msgCount) msgQueue->wakeBits &= ~QS_POSTMESSAGE;
1137
1138     LeaveCriticalSection( &msgQueue->cSection );
1139 }
1140
1141
1142 /***********************************************************************
1143  *           QUEUE_WakeSomeone
1144  *
1145  * Wake a queue upon reception of a hardware event.
1146  */
1147 static void QUEUE_WakeSomeone( UINT message )
1148 {
1149     WND*          wndPtr = NULL;
1150     WORD          wakeBit;
1151     HWND hwnd;
1152     HQUEUE16     hQueue = 0;
1153     MESSAGEQUEUE *queue = NULL;
1154
1155     if (hCursorQueue)
1156         hQueue = hCursorQueue;
1157
1158     if( (message >= WM_KEYFIRST) && (message <= WM_KEYLAST) )
1159     {
1160        wakeBit = QS_KEY;
1161        if( hActiveQueue )
1162            hQueue = hActiveQueue;
1163     }
1164     else
1165     {
1166        wakeBit = (message == WM_MOUSEMOVE) ? QS_MOUSEMOVE : QS_MOUSEBUTTON;
1167        if( (hwnd = GetCapture()) )
1168          if( (wndPtr = WIN_FindWndPtr( hwnd )) )
1169            {
1170                hQueue = wndPtr->hmemTaskQ;
1171                WIN_ReleaseWndPtr(wndPtr);
1172            }
1173     }
1174
1175     if( (hwnd = GetSysModalWindow16()) )
1176     {
1177       if( (wndPtr = WIN_FindWndPtr( hwnd )) )
1178         {
1179             hQueue = wndPtr->hmemTaskQ;
1180             WIN_ReleaseWndPtr(wndPtr);
1181         }
1182     }
1183
1184     if (hQueue)
1185     {
1186         queue = QUEUE_Lock( hQueue );
1187         QUEUE_SetWakeBit( queue, wakeBit );
1188         QUEUE_Unlock( queue );
1189         return;
1190     }
1191
1192     /* Search for someone to wake */
1193     hQueue = hFirstQueue;
1194     while ( (queue = QUEUE_Lock( hQueue )) )
1195     {
1196         if (QUEUE_TrySetWakeBit( queue, wakeBit, FALSE ))
1197         {
1198             QUEUE_Unlock( queue );
1199             return;
1200         }
1201
1202         hQueue = queue->next;
1203         QUEUE_Unlock( queue );
1204     }
1205
1206     WARN_(msg)("couldn't find queue\n");
1207 }
1208
1209
1210 /***********************************************************************
1211  *           hardware_event
1212  *
1213  * Add an event to the system message queue.
1214  * Note: the position is relative to the desktop window.
1215  */
1216 void hardware_event( UINT message, WPARAM wParam, LPARAM lParam,
1217                      int xPos, int yPos, DWORD time, DWORD extraInfo )
1218 {
1219     MSG *msg;
1220     QMSG  *qmsg;
1221     int  mergeMsg = 0;
1222
1223     if (!sysMsgQueue) return;
1224
1225     EnterCriticalSection( &sysMsgQueue->cSection );
1226
1227     /* Merge with previous event if possible */
1228     qmsg = sysMsgQueue->lastMsg;
1229
1230     if ((message == WM_MOUSEMOVE) && sysMsgQueue->lastMsg)
1231     {
1232         msg = &(sysMsgQueue->lastMsg->msg);
1233
1234         if ((msg->message == message) && (msg->wParam == wParam))
1235         {
1236             /* Merge events */
1237             qmsg = sysMsgQueue->lastMsg;
1238             mergeMsg = 1;
1239         }
1240     }
1241
1242     if (!mergeMsg)
1243     {
1244         /* Should I limit the number of messages in
1245           the system message queue??? */
1246
1247         /* Don't merge allocate a new msg in the global heap */
1248
1249         if (!(qmsg = (QMSG *) HeapAlloc( SystemHeap, 0, sizeof(QMSG) ) ))
1250         {
1251             LeaveCriticalSection( &sysMsgQueue->cSection );
1252             return;
1253         }
1254
1255         /* put message at the end of the linked list */
1256         qmsg->nextMsg = 0;
1257         qmsg->prevMsg = sysMsgQueue->lastMsg;
1258
1259         if (sysMsgQueue->lastMsg)
1260             sysMsgQueue->lastMsg->nextMsg = qmsg;
1261
1262         /* set last and first anchor index in system message queue */
1263         sysMsgQueue->lastMsg = qmsg;
1264         if (!sysMsgQueue->firstMsg)
1265             sysMsgQueue->firstMsg = qmsg;
1266
1267         sysMsgQueue->msgCount++;
1268     }
1269
1270       /* Store message */
1271     msg = &(qmsg->msg);
1272     msg->hwnd    = 0;
1273     msg->message = message;
1274     msg->wParam  = wParam;
1275     msg->lParam  = lParam;
1276     msg->time    = time;
1277     msg->pt.x    = xPos;
1278     msg->pt.y    = yPos;
1279     qmsg->extraInfo = extraInfo;
1280     qmsg->type      = QMSG_HARDWARE;
1281
1282     LeaveCriticalSection( &sysMsgQueue->cSection );
1283
1284     QUEUE_WakeSomeone( message );
1285 }
1286
1287
1288 /***********************************************************************
1289  *           QUEUE_GetQueueTask
1290  */
1291 HTASK16 QUEUE_GetQueueTask( HQUEUE16 hQueue )
1292 {
1293     HTASK16 hTask = 0;
1294
1295     MESSAGEQUEUE *queue = QUEUE_Lock( hQueue );
1296
1297     if (queue)
1298     {
1299         hTask = queue->teb->htask16;
1300         QUEUE_Unlock( queue );
1301     }
1302
1303     return hTask;
1304 }
1305
1306
1307
1308 /***********************************************************************
1309  *           QUEUE_IncPaintCount
1310  */
1311 void QUEUE_IncPaintCount( HQUEUE16 hQueue )
1312 {
1313     MESSAGEQUEUE *queue;
1314
1315     if (!(queue = QUEUE_Lock( hQueue ))) return;
1316     EnterCriticalSection( &queue->cSection );
1317     queue->wPaintCount++;
1318     LeaveCriticalSection( &queue->cSection );
1319     QUEUE_SetWakeBit( queue, QS_PAINT );
1320     QUEUE_Unlock( queue );
1321 }
1322
1323
1324 /***********************************************************************
1325  *           QUEUE_DecPaintCount
1326  */
1327 void QUEUE_DecPaintCount( HQUEUE16 hQueue )
1328 {
1329     MESSAGEQUEUE *queue;
1330
1331     if (!(queue = QUEUE_Lock( hQueue ))) return;
1332     EnterCriticalSection( &queue->cSection );
1333     queue->wPaintCount--;
1334     if (!queue->wPaintCount) queue->wakeBits &= ~QS_PAINT;
1335     LeaveCriticalSection( &queue->cSection );
1336     QUEUE_Unlock( queue );
1337 }
1338
1339
1340 /***********************************************************************
1341  *           QUEUE_IncTimerCount
1342  */
1343 void QUEUE_IncTimerCount( HQUEUE16 hQueue )
1344 {
1345     MESSAGEQUEUE *queue;
1346
1347     if (!(queue = QUEUE_Lock( hQueue ))) return;
1348     EnterCriticalSection( &queue->cSection );
1349     queue->wTimerCount++;
1350     LeaveCriticalSection( &queue->cSection );
1351     QUEUE_SetWakeBit( queue, QS_TIMER );
1352     QUEUE_Unlock( queue );
1353 }
1354
1355
1356 /***********************************************************************
1357  *           QUEUE_DecTimerCount
1358  */
1359 void QUEUE_DecTimerCount( HQUEUE16 hQueue )
1360 {
1361     MESSAGEQUEUE *queue;
1362
1363     if (!(queue = QUEUE_Lock( hQueue ))) return;
1364     EnterCriticalSection( &queue->cSection );
1365     queue->wTimerCount--;
1366     if (!queue->wTimerCount) queue->wakeBits &= ~QS_TIMER;
1367     LeaveCriticalSection( &queue->cSection );
1368     QUEUE_Unlock( queue );
1369 }
1370
1371
1372 /***********************************************************************
1373  *              PostQuitMessage (USER.6)
1374  */
1375 void WINAPI PostQuitMessage16( INT16 exitCode )
1376 {
1377     PostQuitMessage( exitCode );
1378 }
1379
1380
1381 /***********************************************************************
1382  *              PostQuitMessage (USER32.@)
1383  *
1384  * PostQuitMessage() posts a message to the system requesting an
1385  * application to terminate execution. As a result of this function,
1386  * the WM_QUIT message is posted to the application, and
1387  * PostQuitMessage() returns immediately.  The exitCode parameter
1388  * specifies an application-defined exit code, which appears in the
1389  * _wParam_ parameter of the WM_QUIT message posted to the application.
1390  *
1391  * CONFORMANCE
1392  *
1393  *  ECMA-234, Win32
1394  */
1395 void WINAPI PostQuitMessage( INT exitCode )
1396 {
1397     MESSAGEQUEUE *queue;
1398
1399     if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return;
1400     EnterCriticalSection( &queue->cSection );
1401     queue->wPostQMsg = TRUE;
1402     queue->wExitCode = (WORD)exitCode;
1403     LeaveCriticalSection( &queue->cSection );
1404     QUEUE_Unlock( queue );
1405 }
1406
1407
1408 /***********************************************************************
1409  *              GetWindowTask (USER.224)
1410  */
1411 HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
1412 {
1413     HTASK16 retvalue;
1414     WND *wndPtr = WIN_FindWndPtr( hwnd );
1415
1416     if (!wndPtr) return 0;
1417     retvalue = QUEUE_GetQueueTask( wndPtr->hmemTaskQ );
1418     WIN_ReleaseWndPtr(wndPtr);
1419     return retvalue;
1420 }
1421
1422 /***********************************************************************
1423  *              GetWindowThreadProcessId (USER32.@)
1424  */
1425 DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
1426 {
1427     DWORD retvalue;
1428     MESSAGEQUEUE *queue;
1429
1430     WND *wndPtr = WIN_FindWndPtr( hwnd );
1431     if (!wndPtr) return 0;
1432
1433     queue = QUEUE_Lock( wndPtr->hmemTaskQ );
1434     WIN_ReleaseWndPtr(wndPtr);
1435
1436     if (!queue) return 0;
1437
1438     if ( process ) *process = (DWORD)queue->teb->pid;
1439     retvalue = (DWORD)queue->teb->tid;
1440
1441     QUEUE_Unlock( queue );
1442     return retvalue;
1443 }
1444
1445
1446 /***********************************************************************
1447  *              SetMessageQueue (USER.266)
1448  */
1449 BOOL16 WINAPI SetMessageQueue16( INT16 size )
1450 {
1451     return SetMessageQueue( size );
1452 }
1453
1454
1455 /***********************************************************************
1456  *              SetMessageQueue (USER32.@)
1457  */
1458 BOOL WINAPI SetMessageQueue( INT size )
1459 {
1460     /* now obsolete the message queue will be expanded dynamically
1461      as necessary */
1462
1463     /* access the queue to create it if it's not existing */
1464     GetFastQueue16();
1465
1466     return TRUE;
1467 }
1468
1469 /***********************************************************************
1470  *              InitThreadInput (USER.409)
1471  */
1472 HQUEUE16 WINAPI InitThreadInput16( WORD unknown, WORD flags )
1473 {
1474     HQUEUE16 hQueue;
1475     MESSAGEQUEUE *queuePtr;
1476
1477     TEB *teb = NtCurrentTeb();
1478
1479     if (!teb)
1480         return 0;
1481
1482     hQueue = teb->queue;
1483
1484     if ( !hQueue )
1485     {
1486         /* Create thread message queue */
1487         if( !(hQueue = QUEUE_CreateMsgQueue( TRUE )))
1488         {
1489             ERR_(msg)("failed!\n");
1490             return FALSE;
1491         }
1492
1493         /* Link new queue into list */
1494         queuePtr = QUEUE_Lock( hQueue );
1495         queuePtr->teb = NtCurrentTeb();
1496
1497         HeapLock( SystemHeap );  /* FIXME: a bit overkill */
1498         SetThreadQueue16( 0, hQueue );
1499         teb->queue = hQueue;
1500
1501         queuePtr->next  = hFirstQueue;
1502         hFirstQueue = hQueue;
1503         HeapUnlock( SystemHeap );
1504
1505         QUEUE_Unlock( queuePtr );
1506     }
1507
1508     return hQueue;
1509 }
1510
1511 /***********************************************************************
1512  *              GetQueueStatus (USER.334)
1513  */
1514 DWORD WINAPI GetQueueStatus16( UINT16 flags )
1515 {
1516     MESSAGEQUEUE *queue;
1517     DWORD ret;
1518
1519     if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
1520     EnterCriticalSection( &queue->cSection );
1521     ret = MAKELONG( queue->changeBits, queue->wakeBits );
1522     queue->changeBits = 0;
1523     LeaveCriticalSection( &queue->cSection );
1524     QUEUE_Unlock( queue );
1525
1526     return ret & MAKELONG( flags, flags );
1527 }
1528
1529 /***********************************************************************
1530  *              GetQueueStatus (USER32.@)
1531  */
1532 DWORD WINAPI GetQueueStatus( UINT flags )
1533 {
1534     MESSAGEQUEUE *queue;
1535     DWORD ret;
1536
1537     if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
1538     EnterCriticalSection( &queue->cSection );
1539     ret = MAKELONG( queue->changeBits, queue->wakeBits );
1540     queue->changeBits = 0;
1541     LeaveCriticalSection( &queue->cSection );
1542     QUEUE_Unlock( queue );
1543
1544     return ret & MAKELONG( flags, flags );
1545 }
1546
1547
1548 /***********************************************************************
1549  *              GetInputState (USER.335)
1550  */
1551 BOOL16 WINAPI GetInputState16(void)
1552 {
1553     return GetInputState();
1554 }
1555
1556 /***********************************************************************
1557  *              WaitForInputIdle (USER32.@)
1558  */
1559 DWORD WINAPI WaitForInputIdle (HANDLE hProcess, DWORD dwTimeOut)
1560 {
1561     DWORD cur_time, ret;
1562     HANDLE idle_event = -1;
1563
1564     SERVER_START_REQ
1565     {
1566         struct wait_input_idle_request *req = server_alloc_req( sizeof(*req), 0 );
1567         req->handle = hProcess;
1568         req->timeout = dwTimeOut;
1569         if (!(ret = server_call( REQ_WAIT_INPUT_IDLE ))) idle_event = req->event;
1570     }
1571     SERVER_END_REQ;
1572     if (ret) return 0xffffffff;  /* error */
1573     if (!idle_event) return 0;  /* no event to wait on */
1574
1575     cur_time = GetTickCount();
1576
1577     TRACE_(msg)("waiting for %x\n", idle_event );
1578     while ( dwTimeOut > GetTickCount() - cur_time || dwTimeOut == INFINITE )
1579     {
1580         ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut, QS_SENDMESSAGE );
1581         if ( ret == ( WAIT_OBJECT_0 + 1 ))
1582         {
1583             MESSAGEQUEUE * queue;
1584             if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0xFFFFFFFF;
1585             QUEUE_ReceiveMessage ( queue );
1586             QUEUE_Unlock ( queue );
1587             continue;
1588         }
1589         if ( ret == WAIT_TIMEOUT || ret == 0xFFFFFFFF )
1590         {
1591             TRACE_(msg)("timeout or error\n");
1592             return ret;
1593         }
1594         else
1595         {
1596             TRACE_(msg)("finished\n");
1597             return 0;
1598         }
1599     }
1600
1601     return WAIT_TIMEOUT;
1602 }
1603
1604 /***********************************************************************
1605  *              GetInputState (USER32.@)
1606  */
1607 BOOL WINAPI GetInputState(void)
1608 {
1609     MESSAGEQUEUE *queue;
1610     BOOL ret;
1611
1612     if (!(queue = QUEUE_Lock( GetFastQueue16() )))
1613         return FALSE;
1614     EnterCriticalSection( &queue->cSection );
1615     ret = queue->wakeBits & (QS_KEY | QS_MOUSEBUTTON);
1616     LeaveCriticalSection( &queue->cSection );
1617     QUEUE_Unlock( queue );
1618
1619     return ret;
1620 }
1621
1622 /***********************************************************************
1623  *              UserYield (USER.332)
1624  *              UserYield16 (USER32.@)
1625  */
1626 void WINAPI UserYield16(void)
1627 {
1628     MESSAGEQUEUE *queue;
1629
1630     /* Handle sent messages */
1631     queue = QUEUE_Lock( GetFastQueue16() );
1632
1633     while ( queue && QUEUE_ReceiveMessage( queue ) )
1634         ;
1635
1636     QUEUE_Unlock( queue );
1637
1638     /* Yield */
1639     if ( THREAD_IsWin16( NtCurrentTeb() ) )
1640         OldYield16();
1641     else
1642         WIN32_OldYield16();
1643
1644     /* Handle sent messages again */
1645     queue = QUEUE_Lock( GetFastQueue16() );
1646
1647     while ( queue && QUEUE_ReceiveMessage( queue ) )
1648         ;
1649
1650     QUEUE_Unlock( queue );
1651 }
1652
1653 /***********************************************************************
1654  *              GetMessagePos (USER.119) (USER32.@)
1655  *
1656  * The GetMessagePos() function returns a long value representing a
1657  * cursor position, in screen coordinates, when the last message
1658  * retrieved by the GetMessage() function occurs. The x-coordinate is
1659  * in the low-order word of the return value, the y-coordinate is in
1660  * the high-order word. The application can use the MAKEPOINT()
1661  * macro to obtain a POINT structure from the return value.
1662  *
1663  * For the current cursor position, use GetCursorPos().
1664  *
1665  * RETURNS
1666  *
1667  * Cursor position of last message on success, zero on failure.
1668  *
1669  * CONFORMANCE
1670  *
1671  * ECMA-234, Win32
1672  *
1673  */
1674 DWORD WINAPI GetMessagePos(void)
1675 {
1676     MESSAGEQUEUE *queue;
1677     DWORD ret;
1678
1679     if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
1680     ret = queue->GetMessagePosVal;
1681     QUEUE_Unlock( queue );
1682
1683     return ret;
1684 }
1685
1686
1687 /***********************************************************************
1688  *              GetMessageTime (USER.120) (USER32.@)
1689  *
1690  * GetMessageTime() returns the message time for the last message
1691  * retrieved by the function. The time is measured in milliseconds with
1692  * the same offset as GetTickCount().
1693  *
1694  * Since the tick count wraps, this is only useful for moderately short
1695  * relative time comparisons.
1696  *
1697  * RETURNS
1698  *
1699  * Time of last message on success, zero on failure.
1700  *
1701  * CONFORMANCE
1702  *
1703  * ECMA-234, Win32
1704  *
1705  */
1706 LONG WINAPI GetMessageTime(void)
1707 {
1708     MESSAGEQUEUE *queue;
1709     LONG ret;
1710
1711     if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
1712     ret = queue->GetMessageTimeVal;
1713     QUEUE_Unlock( queue );
1714
1715     return ret;
1716 }
1717
1718
1719 /***********************************************************************
1720  *              GetMessageExtraInfo (USER.288) (USER32.@)
1721  */
1722 LONG WINAPI GetMessageExtraInfo(void)
1723 {
1724     MESSAGEQUEUE *queue;
1725     LONG ret;
1726
1727     if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
1728     ret = queue->GetMessageExtraInfoVal;
1729     QUEUE_Unlock( queue );
1730
1731     return ret;
1732 }
1733
1734
1735 /**********************************************************************
1736  *              AttachThreadInput (USER32.@) Attaches input of 1 thread to other
1737  *
1738  * Attaches the input processing mechanism of one thread to that of
1739  * another thread.
1740  *
1741  * RETURNS
1742  *    Success: TRUE
1743  *    Failure: FALSE
1744  *
1745  * TODO:
1746  *    1. Reset the Key State (currenly per thread key state is not maintained)
1747  */
1748 BOOL WINAPI AttachThreadInput(
1749     DWORD idAttach,   /* [in] Thread to attach */
1750     DWORD idAttachTo, /* [in] Thread to attach to */
1751     BOOL fAttach)   /* [in] Attach or detach */
1752 {
1753     MESSAGEQUEUE *pSrcMsgQ = 0, *pTgtMsgQ = 0;
1754     BOOL16 bRet = 0;
1755
1756     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1757
1758     /* A thread cannot attach to itself */
1759     if ( idAttach == idAttachTo )
1760         goto CLEANUP;
1761
1762     /* According to the docs this method should fail if a
1763      * "Journal record" hook is installed. (attaches all input queues together)
1764      */
1765     if ( HOOK_IsHooked( WH_JOURNALRECORD ) )
1766         goto CLEANUP;
1767
1768     /* Retrieve message queues corresponding to the thread id's */
1769     pTgtMsgQ = QUEUE_Lock( GetThreadQueue16( idAttach ) );
1770     pSrcMsgQ = QUEUE_Lock( GetThreadQueue16( idAttachTo ) );
1771
1772     /* Ensure we have message queues and that Src and Tgt threads
1773      * are not system threads.
1774      */
1775     if ( !pSrcMsgQ || !pTgtMsgQ || !pSrcMsgQ->pQData || !pTgtMsgQ->pQData )
1776         goto CLEANUP;
1777
1778     if (fAttach)   /* Attach threads */
1779     {
1780         /* Only attach if currently detached  */
1781         if ( pTgtMsgQ->pQData != pSrcMsgQ->pQData )
1782         {
1783             /* First release the target threads perQData */
1784             PERQDATA_Release( pTgtMsgQ->pQData );
1785
1786             /* Share a reference to the source threads perQDATA */
1787             PERQDATA_Addref( pSrcMsgQ->pQData );
1788             pTgtMsgQ->pQData = pSrcMsgQ->pQData;
1789         }
1790     }
1791     else    /* Detach threads */
1792     {
1793         /* Only detach if currently attached */
1794         if ( pTgtMsgQ->pQData == pSrcMsgQ->pQData )
1795         {
1796             /* First release the target threads perQData */
1797             PERQDATA_Release( pTgtMsgQ->pQData );
1798
1799             /* Give the target thread its own private perQDATA once more */
1800             pTgtMsgQ->pQData = PERQDATA_CreateInstance();
1801         }
1802     }
1803
1804     /* TODO: Reset the Key State */
1805
1806     bRet = 1;      /* Success */
1807
1808 CLEANUP:
1809
1810     /* Unlock the queues before returning */
1811     if ( pSrcMsgQ )
1812         QUEUE_Unlock( pSrcMsgQ );
1813     if ( pTgtMsgQ )
1814         QUEUE_Unlock( pTgtMsgQ );
1815
1816     return bRet;
1817 }