-/* * Message queues related functions
+/*
+ * Message queues related functions
*
* Copyright 1993, 1994 Alexandre Julliard
- */
-
-#include <string.h>
-#include <signal.h>
-#include <assert.h>
-#include "windef.h"
-#include "wingdi.h"
-#include "winerror.h"
-#include "wine/winbase16.h"
-#include "wine/winuser16.h"
-#include "queue.h"
-#include "win.h"
-#include "user.h"
-#include "hook.h"
-#include "thread.h"
-#include "debugtools.h"
-#include "server.h"
-#include "spy.h"
-
-DECLARE_DEBUG_CHANNEL(msg);
-DECLARE_DEBUG_CHANNEL(sendmsg);
-
-#define MAX_QUEUE_SIZE 120 /* Max. size of a message queue */
-
-static HQUEUE16 hFirstQueue = 0;
-static HQUEUE16 hExitingQueue = 0;
-static HQUEUE16 hmemSysMsgQueue = 0;
-static MESSAGEQUEUE *sysMsgQueue = NULL;
-static PERQUEUEDATA *pQDataWin16 = NULL; /* Global perQData for Win16 tasks */
-
-static MESSAGEQUEUE *pMouseQueue = NULL; /* Queue for last mouse message */
-static MESSAGEQUEUE *pKbdQueue = NULL; /* Queue for last kbd message */
-
-HQUEUE16 hCursorQueue = 0;
-HQUEUE16 hActiveQueue = 0;
-
-
-/***********************************************************************
- * PERQDATA_CreateInstance
- *
- * Creates an instance of a reference counted PERQUEUEDATA element
- * for the message queue. perQData is stored globally for 16 bit tasks.
- *
- * Note: We don't implement perQdata exactly the same way Windows does.
- * Each perQData element is reference counted since it may be potentially
- * shared by multiple message Queues (via AttachThreadInput).
- * We only store the current values for Active, Capture and focus windows
- * currently.
- */
-PERQUEUEDATA * PERQDATA_CreateInstance( )
-{
- PERQUEUEDATA *pQData;
-
- BOOL16 bIsWin16 = 0;
-
- TRACE_(msg)("()\n");
-
- /* Share a single instance of perQData for all 16 bit tasks */
- if ( ( bIsWin16 = THREAD_IsWin16( NtCurrentTeb() ) ) )
- {
- /* If previously allocated, just bump up ref count */
- if ( pQDataWin16 )
- {
- PERQDATA_Addref( pQDataWin16 );
- return pQDataWin16;
- }
- }
-
- /* Allocate PERQUEUEDATA from the system heap */
- if (!( pQData = (PERQUEUEDATA *) HeapAlloc( GetProcessHeap(), 0,
- sizeof(PERQUEUEDATA) ) ))
- return 0;
-
- /* Initialize */
- pQData->hWndCapture = pQData->hWndFocus = pQData->hWndActive = 0;
- pQData->ulRefCount = 1;
- pQData->nCaptureHT = HTCLIENT;
-
- /* Note: We have an independent critical section for the per queue data
- * since this may be shared by different threads. see AttachThreadInput()
- */
- InitializeCriticalSection( &pQData->cSection );
- /* FIXME: not all per queue data critical sections should be global */
- MakeCriticalSectionGlobal( &pQData->cSection );
-
- /* Save perQData globally for 16 bit tasks */
- if ( bIsWin16 )
- pQDataWin16 = pQData;
-
- return pQData;
-}
-
-
-/***********************************************************************
- * PERQDATA_Addref
- *
- * Increment reference count for the PERQUEUEDATA instance
- * Returns reference count for debugging purposes
- */
-ULONG PERQDATA_Addref( PERQUEUEDATA *pQData )
-{
- assert(pQData != 0 );
- TRACE_(msg)("(): current refcount %lu ...\n", pQData->ulRefCount);
-
- EnterCriticalSection( &pQData->cSection );
- ++pQData->ulRefCount;
- LeaveCriticalSection( &pQData->cSection );
-
- return pQData->ulRefCount;
-}
-
-
-/***********************************************************************
- * PERQDATA_Release
- *
- * Release a reference to a PERQUEUEDATA instance.
- * Destroy the instance if no more references exist
- * Returns reference count for debugging purposes
- */
-ULONG PERQDATA_Release( PERQUEUEDATA *pQData )
-{
- assert(pQData != 0 );
- TRACE_(msg)("(): current refcount %lu ...\n",
- (LONG)pQData->ulRefCount );
-
- EnterCriticalSection( &pQData->cSection );
- if ( --pQData->ulRefCount == 0 )
- {
- LeaveCriticalSection( &pQData->cSection );
- DeleteCriticalSection( &pQData->cSection );
-
- TRACE_(msg)("(): deleting PERQUEUEDATA instance ...\n" );
-
- /* Deleting our global 16 bit perQData? */
- if ( pQData == pQDataWin16 )
- pQDataWin16 = 0;
-
- /* Free the PERQUEUEDATA instance */
- HeapFree( GetProcessHeap(), 0, pQData );
-
- return 0;
- }
- LeaveCriticalSection( &pQData->cSection );
-
- return pQData->ulRefCount;
-}
-
-
-/***********************************************************************
- * PERQDATA_GetFocusWnd
- *
- * Get the focus hwnd member in a threadsafe manner
- */
-HWND PERQDATA_GetFocusWnd( PERQUEUEDATA *pQData )
-{
- HWND hWndFocus;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- hWndFocus = pQData->hWndFocus;
- LeaveCriticalSection( &pQData->cSection );
-
- return hWndFocus;
-}
-
-
-/***********************************************************************
- * PERQDATA_SetFocusWnd
- *
- * Set the focus hwnd member in a threadsafe manner
- */
-HWND PERQDATA_SetFocusWnd( PERQUEUEDATA *pQData, HWND hWndFocus )
-{
- HWND hWndFocusPrv;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- hWndFocusPrv = pQData->hWndFocus;
- pQData->hWndFocus = hWndFocus;
- LeaveCriticalSection( &pQData->cSection );
-
- return hWndFocusPrv;
-}
-
-
-/***********************************************************************
- * PERQDATA_GetActiveWnd
- *
- * Get the active hwnd member in a threadsafe manner
- */
-HWND PERQDATA_GetActiveWnd( PERQUEUEDATA *pQData )
-{
- HWND hWndActive;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- hWndActive = pQData->hWndActive;
- LeaveCriticalSection( &pQData->cSection );
-
- return hWndActive;
-}
-
-
-/***********************************************************************
- * PERQDATA_SetActiveWnd
- *
- * Set the active focus hwnd member in a threadsafe manner
- */
-HWND PERQDATA_SetActiveWnd( PERQUEUEDATA *pQData, HWND hWndActive )
-{
- HWND hWndActivePrv;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- hWndActivePrv = pQData->hWndActive;
- pQData->hWndActive = hWndActive;
- LeaveCriticalSection( &pQData->cSection );
-
- return hWndActivePrv;
-}
-
-
-/***********************************************************************
- * PERQDATA_GetCaptureWnd
- *
- * Get the capture hwnd member in a threadsafe manner
- */
-HWND PERQDATA_GetCaptureWnd( PERQUEUEDATA *pQData )
-{
- HWND hWndCapture;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- hWndCapture = pQData->hWndCapture;
- LeaveCriticalSection( &pQData->cSection );
-
- return hWndCapture;
-}
-
-
-/***********************************************************************
- * PERQDATA_SetCaptureWnd
- *
- * Set the capture hwnd member in a threadsafe manner
- */
-HWND PERQDATA_SetCaptureWnd( PERQUEUEDATA *pQData, HWND hWndCapture )
-{
- HWND hWndCapturePrv;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- hWndCapturePrv = pQData->hWndCapture;
- pQData->hWndCapture = hWndCapture;
- LeaveCriticalSection( &pQData->cSection );
-
- return hWndCapturePrv;
-}
-
-
-/***********************************************************************
- * PERQDATA_GetCaptureInfo
- *
- * Get the capture info member in a threadsafe manner
- */
-INT16 PERQDATA_GetCaptureInfo( PERQUEUEDATA *pQData )
-{
- INT16 nCaptureHT;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- nCaptureHT = pQData->nCaptureHT;
- LeaveCriticalSection( &pQData->cSection );
-
- return nCaptureHT;
-}
-
-
-/***********************************************************************
- * PERQDATA_SetCaptureInfo
- *
- * Set the capture info member in a threadsafe manner
- */
-INT16 PERQDATA_SetCaptureInfo( PERQUEUEDATA *pQData, INT16 nCaptureHT )
-{
- INT16 nCaptureHTPrv;
- assert(pQData != 0 );
-
- EnterCriticalSection( &pQData->cSection );
- nCaptureHTPrv = pQData->nCaptureHT;
- pQData->nCaptureHT = nCaptureHT;
- LeaveCriticalSection( &pQData->cSection );
-
- return nCaptureHTPrv;
-}
-
-
-/***********************************************************************
- * QUEUE_Lock
- *
- * Function for getting a 32 bit pointer on queue structure. For thread
- * safeness programmers should use this function instead of GlobalLock to
- * retrieve a pointer on the structure. QUEUE_Unlock should also be called
- * when access to the queue structure is not required anymore.
- */
-MESSAGEQUEUE *QUEUE_Lock( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE *queue;
-
- HeapLock( GetProcessHeap() ); /* FIXME: a bit overkill */
- queue = GlobalLock16( hQueue );
- if ( !queue || (queue->magic != QUEUE_MAGIC) )
- {
- HeapUnlock( GetProcessHeap() );
- return NULL;
- }
-
- queue->lockCount++;
- HeapUnlock( GetProcessHeap() );
- return queue;
-}
-
-
-/***********************************************************************
- * QUEUE_Unlock
- *
- * Use with QUEUE_Lock to get a thread safe access to message queue
- * structure
- */
-void QUEUE_Unlock( MESSAGEQUEUE *queue )
-{
- if (queue)
- {
- HeapLock( GetProcessHeap() ); /* FIXME: a bit overkill */
-
- if ( --queue->lockCount == 0 )
- {
- DeleteCriticalSection ( &queue->cSection );
- if (queue->server_queue)
- CloseHandle( queue->server_queue );
- GlobalFree16( queue->self );
- }
-
- HeapUnlock( GetProcessHeap() );
- }
-}
-
-
-/***********************************************************************
- * QUEUE_DumpQueue
- */
-void QUEUE_DumpQueue( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE *pq;
-
- if (!(pq = QUEUE_Lock( hQueue )) )
- {
- WARN_(msg)("%04x is not a queue handle\n", hQueue );
- return;
- }
-
- EnterCriticalSection( &pq->cSection );
-
- DPRINTF( "next: %12.4x Intertask SendMessage:\n"
- "thread: %10p ----------------------\n"
- "firstMsg: %8p smWaiting: %10p\n"
- "lastMsg: %8p smPending: %10p\n"
- "msgCount: %8.4x smProcessing: %10p\n"
- "lockCount: %7.4x\n"
- "paints: %10.4x\n"
- "timers: %10.4x\n"
- "wakeBits: %8.4x\n"
- "wakeMask: %8.4x\n"
- "hCurHook: %8.4x\n",
- pq->next, pq->teb, pq->firstMsg, pq->smWaiting, pq->lastMsg,
- pq->smPending, pq->msgCount, pq->smProcessing,
- (unsigned)pq->lockCount, pq->wPaintCount, pq->wTimerCount,
- pq->wakeBits, pq->wakeMask, pq->hCurHook);
-
- LeaveCriticalSection( &pq->cSection );
-
- QUEUE_Unlock( pq );
-}
-
-
-/***********************************************************************
- * QUEUE_WalkQueues
- */
-void QUEUE_WalkQueues(void)
-{
- char module[10];
- HQUEUE16 hQueue = hFirstQueue;
-
- DPRINTF( "Queue Msgs Thread Task Module\n" );
- while (hQueue)
- {
- MESSAGEQUEUE *queue = QUEUE_Lock( hQueue );
- if (!queue)
- {
- WARN_(msg)("Bad queue handle %04x\n", hQueue );
- return;
- }
- if (!GetModuleName16( queue->teb->htask16, module, sizeof(module )))
- strcpy( module, "???" );
- DPRINTF( "%04x %4d %p %04x %s\n", hQueue,queue->msgCount,
- queue->teb, queue->teb->htask16, module );
- hQueue = queue->next;
- QUEUE_Unlock( queue );
- }
- DPRINTF( "\n" );
-}
-
-
-/***********************************************************************
- * QUEUE_IsExitingQueue
- */
-BOOL QUEUE_IsExitingQueue( HQUEUE16 hQueue )
-{
- return (hExitingQueue && (hQueue == hExitingQueue));
-}
-
-
-/***********************************************************************
- * QUEUE_SetExitingQueue
- */
-void QUEUE_SetExitingQueue( HQUEUE16 hQueue )
-{
- hExitingQueue = hQueue;
-}
-
-
-/***********************************************************************
- * QUEUE_CreateMsgQueue
- *
- * Creates a message queue. Doesn't link it into queue list!
- */
-static HQUEUE16 QUEUE_CreateMsgQueue( BOOL16 bCreatePerQData )
-{
- HQUEUE16 hQueue;
- HANDLE handle;
- MESSAGEQUEUE * msgQueue;
-
- TRACE_(msg)("(): Creating message queue...\n");
-
- if (!(hQueue = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT,
- sizeof(MESSAGEQUEUE) )))
- return 0;
-
- msgQueue = (MESSAGEQUEUE *) GlobalLock16( hQueue );
- if ( !msgQueue )
- return 0;
-
- SERVER_START_REQ( get_msg_queue )
- {
- SERVER_CALL_ERR();
- handle = req->handle;
- }
- SERVER_END_REQ;
- if (!handle)
- {
- ERR_(msg)("Cannot get thread queue");
- GlobalFree16( hQueue );
- return 0;
- }
- msgQueue->server_queue = handle;
- msgQueue->server_queue = ConvertToGlobalHandle( msgQueue->server_queue );
-
- msgQueue->self = hQueue;
- msgQueue->wakeBits = msgQueue->changeBits = 0;
-
- InitializeCriticalSection( &msgQueue->cSection );
- MakeCriticalSectionGlobal( &msgQueue->cSection );
-
- msgQueue->lockCount = 1;
- msgQueue->magic = QUEUE_MAGIC;
-
- /* Create and initialize our per queue data */
- msgQueue->pQData = bCreatePerQData ? PERQDATA_CreateInstance() : NULL;
-
- return hQueue;
-}
-
-
-/***********************************************************************
- * QUEUE_FlushMessage
- *
- * Try to reply to all pending sent messages on exit.
- */
-static void QUEUE_FlushMessages( MESSAGEQUEUE *queue )
-{
- SMSG *smsg;
- MESSAGEQUEUE *senderQ = 0;
-
- if( queue )
- {
- EnterCriticalSection( &queue->cSection );
-
- /* empty the list of pending SendMessage waiting to be received */
- while (queue->smPending)
- {
- smsg = QUEUE_RemoveSMSG( queue, SM_PENDING_LIST, 0);
-
- senderQ = QUEUE_Lock( smsg->hSrcQueue );
- if ( !senderQ )
- continue;
-
- /* return 0, to unblock other thread */
- smsg->lResult = 0;
- smsg->flags |= SMSG_HAVE_RESULT;
- QUEUE_SetWakeBit( senderQ, QS_SMRESULT);
-
- QUEUE_Unlock( senderQ );
- }
-
- QUEUE_ClearWakeBit( queue, QS_SENDMESSAGE );
-
- LeaveCriticalSection( &queue->cSection );
- }
-}
-
-
-/***********************************************************************
- * QUEUE_DeleteMsgQueue
- *
- * Unlinks and deletes a message queue.
- *
- * Note: We need to mask asynchronous events to make sure PostMessage works
- * even in the signal handler.
- */
-BOOL QUEUE_DeleteMsgQueue( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE * msgQueue = QUEUE_Lock(hQueue);
- HQUEUE16 *pPrev;
-
- TRACE_(msg)("(): Deleting message queue %04x\n", hQueue);
-
- if (!hQueue || !msgQueue)
- {
- ERR_(msg)("invalid argument.\n");
- return 0;
- }
-
- msgQueue->magic = 0;
-
- if( hCursorQueue == hQueue ) hCursorQueue = 0;
- if( hActiveQueue == hQueue ) hActiveQueue = 0;
-
- /* flush sent messages */
- QUEUE_FlushMessages( msgQueue );
-
- HeapLock( GetProcessHeap() ); /* FIXME: a bit overkill */
-
- /* Release per queue data if present */
- if ( msgQueue->pQData )
- {
- PERQDATA_Release( msgQueue->pQData );
- msgQueue->pQData = 0;
- }
-
- /* remove the message queue from the global link list */
- pPrev = &hFirstQueue;
- while (*pPrev && (*pPrev != hQueue))
- {
- MESSAGEQUEUE *msgQ = (MESSAGEQUEUE*)GlobalLock16(*pPrev);
-
- /* sanity check */
- if ( !msgQ || (msgQ->magic != QUEUE_MAGIC) )
- {
- /* HQUEUE link list is corrupted, try to exit gracefully */
- ERR_(msg)("HQUEUE link list corrupted!\n");
- pPrev = 0;
- break;
- }
- pPrev = &msgQ->next;
- }
- if (pPrev && *pPrev) *pPrev = msgQueue->next;
- msgQueue->self = 0;
-
- HeapUnlock( GetProcessHeap() );
-
- /* free up resource used by MESSAGEQUEUE structure */
- msgQueue->lockCount--;
- QUEUE_Unlock( msgQueue );
-
- return 1;
-}
-
-
-/***********************************************************************
- * QUEUE_CreateSysMsgQueue
- *
- * Create the system message queue, and set the double-click speed.
- * Must be called only once.
- */
-BOOL QUEUE_CreateSysMsgQueue( int size )
-{
- /* Note: We dont need perQ data for the system message queue */
- if (!(hmemSysMsgQueue = QUEUE_CreateMsgQueue( FALSE )))
- return FALSE;
- FarSetOwner16( hmemSysMsgQueue, 0 );
- sysMsgQueue = (MESSAGEQUEUE *) GlobalLock16( hmemSysMsgQueue );
- return TRUE;
-}
-
-
-/***********************************************************************
- * QUEUE_GetSysQueue
- */
-MESSAGEQUEUE *QUEUE_GetSysQueue(void)
-{
- return sysMsgQueue;
-}
-
-
-/***********************************************************************
- * QUEUE_SetWakeBit
- *
- * See "Windows Internals", p.449
- */
-static BOOL QUEUE_TrySetWakeBit( MESSAGEQUEUE *queue, WORD bit, BOOL always )
-{
- BOOL wake = FALSE;
-
- EnterCriticalSection( &queue->cSection );
-
- TRACE_(msg)("queue = %04x (wm=%04x), bit = %04x, always = %d\n",
- queue->self, queue->wakeMask, bit, always );
-
- if ((queue->wakeMask & bit) || always)
- {
- if (bit & QS_MOUSE) pMouseQueue = queue;
- if (bit & QS_KEY) pKbdQueue = queue;
- queue->changeBits |= bit;
- queue->wakeBits |= bit;
- }
- if (queue->wakeMask & bit)
- {
- queue->wakeMask = 0;
- wake = TRUE;
- }
-
- LeaveCriticalSection( &queue->cSection );
-
- if ( wake )
- {
- /* Wake up thread waiting for message */
- SERVER_START_REQ( wake_queue )
- {
- req->handle = queue->server_queue;
- req->bits = bit;
- SERVER_CALL();
- }
- SERVER_END_REQ;
- }
-
- return wake;
-}
-void QUEUE_SetWakeBit( MESSAGEQUEUE *queue, WORD bit )
-{
- QUEUE_TrySetWakeBit( queue, bit, TRUE );
-}
-
-
-/***********************************************************************
- * QUEUE_ClearWakeBit
- */
-void QUEUE_ClearWakeBit( MESSAGEQUEUE *queue, WORD bit )
-{
- EnterCriticalSection( &queue->cSection );
- queue->changeBits &= ~bit;
- queue->wakeBits &= ~bit;
- LeaveCriticalSection( &queue->cSection );
-}
-
-/***********************************************************************
- * QUEUE_TestWakeBit
- */
-WORD QUEUE_TestWakeBit( MESSAGEQUEUE *queue, WORD bit )
-{
- WORD ret;
- EnterCriticalSection( &queue->cSection );
- ret = queue->wakeBits & bit;
- LeaveCriticalSection( &queue->cSection );
- return ret;
-}
-
-
-/***********************************************************************
- * QUEUE_WaitBits
- *
- * See "Windows Internals", p.447
- *
- * return values:
- * 0 if exit with timeout
- * 1 otherwise
- */
-int QUEUE_WaitBits( WORD bits, DWORD timeout )
-{
- MESSAGEQUEUE *queue;
- HQUEUE16 hQueue;
-
- TRACE_(msg)("q %04x waiting for %04x\n", GetFastQueue16(), bits);
-
- hQueue = GetFastQueue16();
- if (!(queue = QUEUE_Lock( hQueue ))) return 0;
-
- for (;;)
- {
- DWORD dwlc;
-
- EnterCriticalSection( &queue->cSection );
-
- if (queue->changeBits & bits)
- {
- /* One of the bits is set; we can return */
- queue->wakeMask = 0;
-
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
- return 1;
- }
- if (queue->wakeBits & QS_SENDMESSAGE)
- {
- /* Process the sent message immediately */
- queue->wakeMask = 0;
-
- LeaveCriticalSection( &queue->cSection );
- QUEUE_ReceiveMessage( queue );
- continue; /* nested sm crux */
- }
-
- queue->wakeMask = bits | QS_SENDMESSAGE;
- TRACE_(msg)("%04x: wakeMask is %04x, waiting\n", queue->self, queue->wakeMask);
- LeaveCriticalSection( &queue->cSection );
-
- ReleaseThunkLock( &dwlc );
- if (dwlc) TRACE_(msg)("had win16 lock\n");
-
- if (USER_Driver.pMsgWaitForMultipleObjects)
- USER_Driver.pMsgWaitForMultipleObjects( 1, &queue->server_queue, FALSE, timeout );
- else
- WaitForSingleObject( queue->server_queue, timeout );
- if (dwlc) RestoreThunkLock( dwlc );
- }
-}
-
-
-/***********************************************************************
- * QUEUE_AddSMSG
- *
- * This routine is called when a SMSG need to be added to one of the three
- * SM list. (SM_PROCESSING_LIST, SM_PENDING_LIST, SM_WAITING_LIST)
- */
-BOOL QUEUE_AddSMSG( MESSAGEQUEUE *queue, int list, SMSG *smsg )
-{
- TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
- smsg, SPY_GetMsgName(smsg->msg));
-
- switch (list)
- {
- case SM_PROCESSING_LIST:
- /* don't need to be thread safe, only accessed by the
- thread associated with the sender queue */
- smsg->nextProcessing = queue->smProcessing;
- queue->smProcessing = smsg;
- break;
-
- case SM_WAITING_LIST:
- /* don't need to be thread safe, only accessed by the
- thread associated with the receiver queue */
- smsg->nextWaiting = queue->smWaiting;
- queue->smWaiting = smsg;
- break;
-
- case SM_PENDING_LIST:
- {
- /* make it thread safe, could be accessed by the sender and
- receiver thread */
- SMSG **prev;
-
- EnterCriticalSection( &queue->cSection );
- smsg->nextPending = NULL;
- prev = &queue->smPending;
- while ( *prev )
- prev = &(*prev)->nextPending;
- *prev = smsg;
- LeaveCriticalSection( &queue->cSection );
-
- QUEUE_SetWakeBit( queue, QS_SENDMESSAGE );
- break;
- }
-
- default:
- ERR_(sendmsg)("Invalid list: %d", list);
- break;
- }
-
- return TRUE;
-}
-
-
-/***********************************************************************
- * QUEUE_RemoveSMSG
- *
- * This routine is called when a SMSG needs to be removed from one of the three
- * SM lists (SM_PROCESSING_LIST, SM_PENDING_LIST, SM_WAITING_LIST).
- * If smsg == 0, remove the first smsg from the specified list
- */
-SMSG *QUEUE_RemoveSMSG( MESSAGEQUEUE *queue, int list, SMSG *smsg )
-{
-
- switch (list)
- {
- case SM_PROCESSING_LIST:
- /* don't need to be thread safe, only accessed by the
- thread associated with the sender queue */
-
- /* if smsg is equal to null, it means the first in the list */
- if (!smsg)
- smsg = queue->smProcessing;
-
- TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
- smsg, SPY_GetMsgName(smsg->msg));
- /* In fact SM_PROCESSING_LIST is a stack, and smsg
- should be always at the top of the list */
- if ( (smsg != queue->smProcessing) || !queue->smProcessing )
- {
- ERR_(sendmsg)("smsg not at the top of Processing list, smsg=0x%p queue=0x%p\n", smsg, queue);
- return 0;
- }
- else
- {
- queue->smProcessing = smsg->nextProcessing;
- smsg->nextProcessing = 0;
- }
- return smsg;
-
- case SM_WAITING_LIST:
- /* don't need to be thread safe, only accessed by the
- thread associated with the receiver queue */
-
- /* if smsg is equal to null, it means the first in the list */
- if (!smsg)
- smsg = queue->smWaiting;
-
- TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
- smsg, SPY_GetMsgName(smsg->msg));
- /* In fact SM_WAITING_LIST is a stack, and smsg
- should be always at the top of the list */
- if ( (smsg != queue->smWaiting) || !queue->smWaiting )
- {
- ERR_(sendmsg)("smsg not at the top of Waiting list, smsg=0x%p queue=0x%p\n", smsg, queue);
- return 0;
- }
- else
- {
- queue->smWaiting = smsg->nextWaiting;
- smsg->nextWaiting = 0;
- }
- return smsg;
-
- case SM_PENDING_LIST:
- /* make it thread safe, could be accessed by the sender and
- receiver thread */
- EnterCriticalSection( &queue->cSection );
-
- if (!smsg)
- smsg = queue->smPending;
- if ( (smsg != queue->smPending) || !queue->smPending )
- {
- ERR_(sendmsg)("should always remove the top one in Pending list, smsg=0x%p queue=0x%p\n", smsg, queue);
- LeaveCriticalSection( &queue->cSection );
- return 0;
- }
-
- TRACE_(sendmsg)("queue=%x, list=%d, smsg=%p msg=%s\n", queue->self, list,
- smsg, SPY_GetMsgName(smsg->msg));
-
- queue->smPending = smsg->nextPending;
- smsg->nextPending = 0;
-
- /* if no more SMSG in Pending list, clear QS_SENDMESSAGE flag */
- if (!queue->smPending)
- QUEUE_ClearWakeBit( queue, QS_SENDMESSAGE );
-
- LeaveCriticalSection( &queue->cSection );
- return smsg;
-
- default:
- ERR_(sendmsg)("Invalid list: %d\n", list);
- break;
- }
-
- return 0;
-}
-
-
-/***********************************************************************
- * QUEUE_ReceiveMessage
- *
- * This routine is called to check whether a sent message is waiting
- * for the queue. If so, it is received and processed.
- */
-BOOL QUEUE_ReceiveMessage( MESSAGEQUEUE *queue )
-{
- LRESULT result = 0;
- SMSG *smsg;
- MESSAGEQUEUE *senderQ;
-
- EnterCriticalSection( &queue->cSection );
- if ( !((queue->wakeBits & QS_SENDMESSAGE) && queue->smPending) )
- {
- LeaveCriticalSection( &queue->cSection );
- return FALSE;
- }
- LeaveCriticalSection( &queue->cSection );
-
- TRACE_(sendmsg)("queue %04x\n", queue->self );
-
- /* remove smsg on the top of the pending list and put it in the processing list */
- smsg = QUEUE_RemoveSMSG(queue, SM_PENDING_LIST, 0);
- QUEUE_AddSMSG(queue, SM_WAITING_LIST, smsg);
-
- TRACE_(sendmsg)("RM: %s [%04x] (%04x -> %04x)\n",
- SPY_GetMsgName(smsg->msg), smsg->msg, smsg->hSrcQueue, smsg->hDstQueue );
-
- if (IsWindow( smsg->hWnd ))
- {
- WND *wndPtr = WIN_FindWndPtr( smsg->hWnd );
- DWORD extraInfo = queue->GetMessageExtraInfoVal; /* save ExtraInfo */
-
- /* use sender queue extra info value while calling the window proc */
- senderQ = QUEUE_Lock( smsg->hSrcQueue );
- if (senderQ)
- {
- queue->GetMessageExtraInfoVal = senderQ->GetMessageExtraInfoVal;
- QUEUE_Unlock( senderQ );
- }
-
- /* call the right version of CallWindowProcXX */
- if (smsg->flags & SMSG_WIN32)
- {
- TRACE_(sendmsg)("\trcm: msg is Win32\n" );
- if (smsg->flags & SMSG_UNICODE)
- result = CallWindowProcW( wndPtr->winproc,
- smsg->hWnd, smsg->msg,
- smsg->wParam, smsg->lParam );
- else
- result = CallWindowProcA( wndPtr->winproc,
- smsg->hWnd, smsg->msg,
- smsg->wParam, smsg->lParam );
- }
- else /* Win16 message */
- result = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
- (HWND16) smsg->hWnd,
- (UINT16) smsg->msg,
- LOWORD (smsg->wParam),
- smsg->lParam );
-
- queue->GetMessageExtraInfoVal = extraInfo; /* Restore extra info */
- WIN_ReleaseWndPtr(wndPtr);
- TRACE_(sendmsg)("result = %08x\n", (unsigned)result );
- }
- else WARN_(sendmsg)("\trcm: bad hWnd\n");
-
-
- /* set SMSG_SENDING_REPLY flag to tell ReplyMessage16, it's not
- an early reply */
- smsg->flags |= SMSG_SENDING_REPLY;
- ReplyMessage( result );
-
- TRACE_(sendmsg)("done!\n" );
- return TRUE;
-}
-
-
-
-/***********************************************************************
- * QUEUE_AddMsg
- *
- * Add a message to the queue. Return FALSE if queue is full.
- */
-BOOL QUEUE_AddMsg( HQUEUE16 hQueue, int type, MSG *msg, DWORD extraInfo )
-{
- MESSAGEQUEUE *msgQueue;
- QMSG *qmsg;
-
-
- if (!(msgQueue = QUEUE_Lock( hQueue ))) return FALSE;
-
- /* allocate new message in global heap for now */
- if (!(qmsg = (QMSG *) HeapAlloc( GetProcessHeap(), 0, sizeof(QMSG) ) ))
- {
- QUEUE_Unlock( msgQueue );
- return 0;
- }
-
- EnterCriticalSection( &msgQueue->cSection );
-
- /* Store message */
- qmsg->type = type;
- qmsg->msg = *msg;
- qmsg->extraInfo = extraInfo;
-
- /* insert the message in the link list */
- qmsg->nextMsg = 0;
- qmsg->prevMsg = msgQueue->lastMsg;
-
- if (msgQueue->lastMsg)
- msgQueue->lastMsg->nextMsg = qmsg;
-
- /* update first and last anchor in message queue */
- msgQueue->lastMsg = qmsg;
- if (!msgQueue->firstMsg)
- msgQueue->firstMsg = qmsg;
-
- msgQueue->msgCount++;
-
- LeaveCriticalSection( &msgQueue->cSection );
-
- QUEUE_SetWakeBit( msgQueue, QS_POSTMESSAGE );
- QUEUE_Unlock( msgQueue );
-
- return TRUE;
-}
-
-
-
-/***********************************************************************
- * QUEUE_FindMsg
*
- * Find a message matching the given parameters. Return -1 if none available.
- */
-QMSG* QUEUE_FindMsg( MESSAGEQUEUE * msgQueue, HWND hwnd, int first, int last )
-{
- QMSG* qmsg;
-
- EnterCriticalSection( &msgQueue->cSection );
-
- if (!msgQueue->msgCount)
- qmsg = 0;
- else if (!hwnd && !first && !last)
- qmsg = msgQueue->firstMsg;
- else
- {
- /* look in linked list for message matching first and last criteria */
- for (qmsg = msgQueue->firstMsg; qmsg; qmsg = qmsg->nextMsg)
- {
- MSG *msg = &(qmsg->msg);
-
- if (!hwnd || (msg->hwnd == hwnd))
- {
- if (!first && !last)
- break; /* found it */
-
- if ((msg->message >= first) && (!last || (msg->message <= last)))
- break; /* found it */
- }
- }
- }
-
- LeaveCriticalSection( &msgQueue->cSection );
-
- return qmsg;
-}
-
-
-
-/***********************************************************************
- * QUEUE_RemoveMsg
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
*
- * Remove a message from the queue (pos must be a valid position).
- */
-void QUEUE_RemoveMsg( MESSAGEQUEUE * msgQueue, QMSG *qmsg )
-{
- EnterCriticalSection( &msgQueue->cSection );
-
- /* set the linked list */
- if (qmsg->prevMsg)
- qmsg->prevMsg->nextMsg = qmsg->nextMsg;
-
- if (qmsg->nextMsg)
- qmsg->nextMsg->prevMsg = qmsg->prevMsg;
-
- if (msgQueue->firstMsg == qmsg)
- msgQueue->firstMsg = qmsg->nextMsg;
-
- if (msgQueue->lastMsg == qmsg)
- msgQueue->lastMsg = qmsg->prevMsg;
-
- /* deallocate the memory for the message */
- HeapFree( GetProcessHeap(), 0, qmsg );
-
- msgQueue->msgCount--;
- if (!msgQueue->msgCount) msgQueue->wakeBits &= ~QS_POSTMESSAGE;
-
- LeaveCriticalSection( &msgQueue->cSection );
-}
-
-
-#if 0
-/***********************************************************************
- * QUEUE_WakeSomeone
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
*
- * Wake a queue upon reception of a hardware event.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-static void QUEUE_WakeSomeone( UINT message )
-{
- WND* wndPtr = NULL;
- WORD wakeBit;
- HWND hwnd;
- HQUEUE16 hQueue = 0;
- MESSAGEQUEUE *queue = NULL;
-
- if (hCursorQueue)
- hQueue = hCursorQueue;
-
- if( (message >= WM_KEYFIRST) && (message <= WM_KEYLAST) )
- {
- wakeBit = QS_KEY;
- if( hActiveQueue )
- hQueue = hActiveQueue;
- }
- else
- {
- wakeBit = (message == WM_MOUSEMOVE) ? QS_MOUSEMOVE : QS_MOUSEBUTTON;
- if( (hwnd = GetCapture()) )
- if( (wndPtr = WIN_FindWndPtr( hwnd )) )
- {
- hQueue = wndPtr->hmemTaskQ;
- WIN_ReleaseWndPtr(wndPtr);
- }
- }
-
- if( (hwnd = GetSysModalWindow16()) )
- {
- if( (wndPtr = WIN_FindWndPtr( hwnd )) )
- {
- hQueue = wndPtr->hmemTaskQ;
- WIN_ReleaseWndPtr(wndPtr);
- }
- }
- if (hQueue)
- {
- queue = QUEUE_Lock( hQueue );
- QUEUE_SetWakeBit( queue, wakeBit );
- QUEUE_Unlock( queue );
- return;
- }
+#include "config.h"
+#include "wine/port.h"
- /* Search for someone to wake */
- hQueue = hFirstQueue;
- while ( (queue = QUEUE_Lock( hQueue )) )
- {
- if (QUEUE_TrySetWakeBit( queue, wakeBit, FALSE ))
- {
- QUEUE_Unlock( queue );
- return;
- }
-
- hQueue = queue->next;
- QUEUE_Unlock( queue );
- }
+#include <stdarg.h>
+#include <string.h>
+#include <signal.h>
+#include <assert.h>
+#include "windef.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "winerror.h"
+#include "wine/winbase16.h"
+#include "wine/winuser16.h"
+#include "message.h"
+#include "win.h"
+#include "user.h"
+#include "thread.h"
+#include "wine/debug.h"
+#include "wine/server.h"
- WARN_(msg)("couldn't find queue\n");
-}
-#endif
+WINE_DEFAULT_DEBUG_CHANNEL(msg);
/***********************************************************************
- * hardware_event
+ * QUEUE_CreateMsgQueue
*
- * Add an event to the system message queue.
- * Note: the position is relative to the desktop window.
+ * Creates a message queue. Doesn't link it into queue list!
*/
-void hardware_event( UINT message, WPARAM wParam, LPARAM lParam,
- int xPos, int yPos, DWORD time, DWORD extraInfo )
+static HQUEUE16 QUEUE_CreateMsgQueue(void)
{
- MSG *msg;
- QMSG *qmsg;
- MESSAGEQUEUE *queue;
- int mergeMsg = 0;
-
- if (!sysMsgQueue) return;
+ HQUEUE16 hQueue;
+ HANDLE handle;
+ MESSAGEQUEUE * msgQueue;
- EnterCriticalSection( &sysMsgQueue->cSection );
+ TRACE_(msg)("(): Creating message queue...\n");
- /* Merge with previous event if possible */
- qmsg = sysMsgQueue->lastMsg;
+ if (!(hQueue = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT,
+ sizeof(MESSAGEQUEUE) )))
+ return 0;
- if ((message == WM_MOUSEMOVE) && sysMsgQueue->lastMsg)
- {
- msg = &(sysMsgQueue->lastMsg->msg);
-
- if ((msg->message == message) && (msg->wParam == wParam))
- {
- /* Merge events */
- qmsg = sysMsgQueue->lastMsg;
- mergeMsg = 1;
- }
- }
+ msgQueue = (MESSAGEQUEUE *) GlobalLock16( hQueue );
+ if ( !msgQueue )
+ return 0;
- if (!mergeMsg)
+ SERVER_START_REQ( get_msg_queue )
{
- /* Should I limit the number of messages in
- the system message queue??? */
-
- /* Don't merge allocate a new msg in the global heap */
-
- if (!(qmsg = (QMSG *) HeapAlloc( GetProcessHeap(), 0, sizeof(QMSG) ) ))
- {
- LeaveCriticalSection( &sysMsgQueue->cSection );
- return;
- }
-
- /* put message at the end of the linked list */
- qmsg->nextMsg = 0;
- qmsg->prevMsg = sysMsgQueue->lastMsg;
-
- if (sysMsgQueue->lastMsg)
- sysMsgQueue->lastMsg->nextMsg = qmsg;
-
- /* set last and first anchor index in system message queue */
- sysMsgQueue->lastMsg = qmsg;
- if (!sysMsgQueue->firstMsg)
- sysMsgQueue->firstMsg = qmsg;
-
- sysMsgQueue->msgCount++;
+ wine_server_call_err( req );
+ handle = reply->handle;
}
-
- /* Store message */
- msg = &(qmsg->msg);
- msg->hwnd = 0;
- msg->message = message;
- msg->wParam = wParam;
- msg->lParam = lParam;
- msg->time = time;
- msg->pt.x = xPos;
- msg->pt.y = yPos;
- qmsg->extraInfo = extraInfo;
- qmsg->type = QMSG_HARDWARE;
-
- LeaveCriticalSection( &sysMsgQueue->cSection );
-
- if ((queue = QUEUE_Lock( GetFastQueue16() )))
+ SERVER_END_REQ;
+ if (!handle)
{
- WORD wakeBit;
-
- if ((message >= WM_KEYFIRST) && (message <= WM_KEYLAST)) wakeBit = QS_KEY;
- else wakeBit = (message == WM_MOUSEMOVE) ? QS_MOUSEMOVE : QS_MOUSEBUTTON;
-
- QUEUE_SetWakeBit( queue, wakeBit );
- QUEUE_Unlock( queue );
+ ERR_(msg)("Cannot get thread queue\n");
+ GlobalFree16( hQueue );
+ return 0;
}
+ msgQueue->server_queue = handle;
+ msgQueue->self = hQueue;
+ return hQueue;
}
/***********************************************************************
- * QUEUE_GetQueueTask
+ * QUEUE_Current
+ *
+ * Get the current thread queue, creating it if required.
+ * QUEUE_Unlock is not needed since the queue can only be deleted by
+ * the current thread anyway.
*/
-HTASK16 QUEUE_GetQueueTask( HQUEUE16 hQueue )
+MESSAGEQUEUE *QUEUE_Current(void)
{
- HTASK16 hTask = 0;
-
- MESSAGEQUEUE *queue = QUEUE_Lock( hQueue );
+ HQUEUE16 hQueue = NtCurrentTeb()->queue;
- if (queue)
+ if (!hQueue)
{
- hTask = queue->teb->htask16;
- QUEUE_Unlock( queue );
+ if (!(hQueue = QUEUE_CreateMsgQueue())) return NULL;
+ SetThreadQueue16( 0, hQueue );
}
- return hTask;
-}
-
-
-
-/***********************************************************************
- * QUEUE_IncPaintCount
- */
-void QUEUE_IncPaintCount( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE *queue;
-
- if (!(queue = QUEUE_Lock( hQueue ))) return;
- EnterCriticalSection( &queue->cSection );
- queue->wPaintCount++;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_SetWakeBit( queue, QS_PAINT );
- QUEUE_Unlock( queue );
-}
-
-
-/***********************************************************************
- * QUEUE_DecPaintCount
- */
-void QUEUE_DecPaintCount( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE *queue;
-
- if (!(queue = QUEUE_Lock( hQueue ))) return;
- EnterCriticalSection( &queue->cSection );
- queue->wPaintCount--;
- if (!queue->wPaintCount) queue->wakeBits &= ~QS_PAINT;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
-}
-
-
-/***********************************************************************
- * QUEUE_IncTimerCount
- */
-void QUEUE_IncTimerCount( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE *queue;
-
- if (!(queue = QUEUE_Lock( hQueue ))) return;
- EnterCriticalSection( &queue->cSection );
- queue->wTimerCount++;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_SetWakeBit( queue, QS_TIMER );
- QUEUE_Unlock( queue );
+ return GlobalLock16( hQueue );
}
-/***********************************************************************
- * QUEUE_DecTimerCount
- */
-void QUEUE_DecTimerCount( HQUEUE16 hQueue )
-{
- MESSAGEQUEUE *queue;
-
- if (!(queue = QUEUE_Lock( hQueue ))) return;
- EnterCriticalSection( &queue->cSection );
- queue->wTimerCount--;
- if (!queue->wTimerCount) queue->wakeBits &= ~QS_TIMER;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
-}
-
-
-/***********************************************************************
- * PostQuitMessage (USER.6)
- */
-void WINAPI PostQuitMessage16( INT16 exitCode )
-{
- PostQuitMessage( exitCode );
-}
-
/***********************************************************************
- * PostQuitMessage (USER32.@)
- *
- * PostQuitMessage() posts a message to the system requesting an
- * application to terminate execution. As a result of this function,
- * the WM_QUIT message is posted to the application, and
- * PostQuitMessage() returns immediately. The exitCode parameter
- * specifies an application-defined exit code, which appears in the
- * _wParam_ parameter of the WM_QUIT message posted to the application.
- *
- * CONFORMANCE
+ * QUEUE_DeleteMsgQueue
*
- * ECMA-234, Win32
- */
-void WINAPI PostQuitMessage( INT exitCode )
-{
- MESSAGEQUEUE *queue;
-
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return;
- EnterCriticalSection( &queue->cSection );
- queue->wPostQMsg = TRUE;
- queue->wExitCode = (WORD)exitCode;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
-}
-
-
-/***********************************************************************
- * GetWindowTask (USER.224)
- */
-HTASK16 WINAPI GetWindowTask16( HWND16 hwnd )
-{
- HTASK16 retvalue;
- WND *wndPtr = WIN_FindWndPtr( hwnd );
-
- if (!wndPtr) return 0;
- retvalue = QUEUE_GetQueueTask( wndPtr->hmemTaskQ );
- WIN_ReleaseWndPtr(wndPtr);
- return retvalue;
-}
-
-/***********************************************************************
- * GetWindowThreadProcessId (USER32.@)
- */
-DWORD WINAPI GetWindowThreadProcessId( HWND hwnd, LPDWORD process )
-{
- DWORD retvalue;
- MESSAGEQUEUE *queue;
-
- WND *wndPtr = WIN_FindWndPtr( hwnd );
- if (!wndPtr) return 0;
-
- queue = QUEUE_Lock( wndPtr->hmemTaskQ );
- WIN_ReleaseWndPtr(wndPtr);
-
- if (!queue) return 0;
-
- if ( process ) *process = (DWORD)queue->teb->pid;
- retvalue = (DWORD)queue->teb->tid;
-
- QUEUE_Unlock( queue );
- return retvalue;
-}
-
-
-/***********************************************************************
- * SetMessageQueue (USER.266)
- */
-BOOL16 WINAPI SetMessageQueue16( INT16 size )
-{
- return SetMessageQueue( size );
-}
-
-
-/***********************************************************************
- * SetMessageQueue (USER32.@)
- */
-BOOL WINAPI SetMessageQueue( INT size )
-{
- /* now obsolete the message queue will be expanded dynamically
- as necessary */
-
- /* access the queue to create it if it's not existing */
- GetFastQueue16();
-
- return TRUE;
-}
-
-/***********************************************************************
- * InitThreadInput (USER.409)
+ * Delete a message queue.
*/
-HQUEUE16 WINAPI InitThreadInput16( WORD unknown, WORD flags )
+void QUEUE_DeleteMsgQueue(void)
{
- HQUEUE16 hQueue;
- MESSAGEQUEUE *queuePtr;
+ HQUEUE16 hQueue = NtCurrentTeb()->queue;
+ MESSAGEQUEUE * msgQueue;
- TEB *teb = NtCurrentTeb();
+ if (!hQueue) return; /* thread doesn't have a queue */
- if (!teb)
- return 0;
+ TRACE("(): Deleting message queue %04x\n", hQueue);
- hQueue = teb->queue;
-
- if ( !hQueue )
+ if (!(msgQueue = GlobalLock16( hQueue )))
{
- /* Create thread message queue */
- if( !(hQueue = QUEUE_CreateMsgQueue( TRUE )))
- {
- ERR_(msg)("failed!\n");
- return FALSE;
- }
-
- /* Link new queue into list */
- queuePtr = QUEUE_Lock( hQueue );
- queuePtr->teb = NtCurrentTeb();
-
- HeapLock( GetProcessHeap() ); /* FIXME: a bit overkill */
- SetThreadQueue16( 0, hQueue );
- teb->queue = hQueue;
-
- queuePtr->next = hFirstQueue;
- hFirstQueue = hQueue;
- HeapUnlock( GetProcessHeap() );
-
- QUEUE_Unlock( queuePtr );
+ ERR("invalid thread queue\n");
+ return;
}
- return hQueue;
+ SetThreadQueue16( 0, 0 );
+ CloseHandle( msgQueue->server_queue );
+ GlobalFree16( hQueue );
}
+
/***********************************************************************
- * GetQueueStatus (USER.334)
+ * InitThreadInput (USER.409)
*/
-DWORD WINAPI GetQueueStatus16( UINT16 flags )
+HQUEUE16 WINAPI InitThreadInput16( WORD unknown, WORD flags )
{
- MESSAGEQUEUE *queue;
- DWORD ret;
-
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
- EnterCriticalSection( &queue->cSection );
- ret = MAKELONG( queue->changeBits, queue->wakeBits );
- queue->changeBits = 0;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
-
- return ret & MAKELONG( flags, flags );
+ MESSAGEQUEUE *queue = QUEUE_Current();
+ return queue ? queue->self : 0;
}
/***********************************************************************
*/
DWORD WINAPI GetQueueStatus( UINT flags )
{
- MESSAGEQUEUE *queue;
- DWORD ret;
-
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
- EnterCriticalSection( &queue->cSection );
- ret = MAKELONG( queue->changeBits, queue->wakeBits );
- queue->changeBits = 0;
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
-
- return ret & MAKELONG( flags, flags );
-}
-
-
-/***********************************************************************
- * GetInputState (USER.335)
- */
-BOOL16 WINAPI GetInputState16(void)
-{
- return GetInputState();
-}
+ DWORD ret = 0;
-/***********************************************************************
- * WaitForInputIdle (USER32.@)
- */
-DWORD WINAPI WaitForInputIdle (HANDLE hProcess, DWORD dwTimeOut)
-{
- DWORD cur_time, ret;
- HANDLE idle_event = -1;
+ /* check for pending X events */
+ if (USER_Driver.pMsgWaitForMultipleObjectsEx)
+ USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
- SERVER_START_REQ( wait_input_idle )
+ SERVER_START_REQ( get_queue_status )
{
- req->handle = hProcess;
- req->timeout = dwTimeOut;
- if (!(ret = SERVER_CALL_ERR())) idle_event = req->event;
+ req->clear = 1;
+ wine_server_call( req );
+ ret = MAKELONG( reply->changed_bits & flags, reply->wake_bits & flags );
}
SERVER_END_REQ;
- if (ret) return 0xffffffff; /* error */
- if (!idle_event) return 0; /* no event to wait on */
-
- cur_time = GetTickCount();
-
- TRACE_(msg)("waiting for %x\n", idle_event );
- while ( dwTimeOut > GetTickCount() - cur_time || dwTimeOut == INFINITE )
- {
- ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut, QS_SENDMESSAGE );
- if ( ret == ( WAIT_OBJECT_0 + 1 ))
- {
- MESSAGEQUEUE * queue;
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0xFFFFFFFF;
- QUEUE_ReceiveMessage ( queue );
- QUEUE_Unlock ( queue );
- continue;
- }
- if ( ret == WAIT_TIMEOUT || ret == 0xFFFFFFFF )
- {
- TRACE_(msg)("timeout or error\n");
- return ret;
- }
- else
- {
- TRACE_(msg)("finished\n");
- return 0;
- }
- }
-
- return WAIT_TIMEOUT;
+ return ret;
}
+
/***********************************************************************
- * GetInputState (USER32.@)
+ * GetInputState (USER32.@)
*/
BOOL WINAPI GetInputState(void)
{
- MESSAGEQUEUE *queue;
- BOOL ret;
+ DWORD ret = 0;
- if (!(queue = QUEUE_Lock( GetFastQueue16() )))
- return FALSE;
- EnterCriticalSection( &queue->cSection );
- ret = queue->wakeBits & (QS_KEY | QS_MOUSEBUTTON);
- LeaveCriticalSection( &queue->cSection );
- QUEUE_Unlock( queue );
+ /* check for pending X events */
+ if (USER_Driver.pMsgWaitForMultipleObjectsEx)
+ USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
+ SERVER_START_REQ( get_queue_status )
+ {
+ req->clear = 0;
+ wine_server_call( req );
+ ret = reply->wake_bits & (QS_KEY | QS_MOUSEBUTTON);
+ }
+ SERVER_END_REQ;
return ret;
}
/***********************************************************************
- * UserYield (USER.332)
- * UserYield16 (USER32.@)
- */
-void WINAPI UserYield16(void)
-{
- MESSAGEQUEUE *queue;
-
- /* Handle sent messages */
- queue = QUEUE_Lock( GetFastQueue16() );
-
- while ( queue && QUEUE_ReceiveMessage( queue ) )
- ;
-
- QUEUE_Unlock( queue );
-
- /* Yield */
- OldYield16();
-
- /* Handle sent messages again */
- queue = QUEUE_Lock( GetFastQueue16() );
-
- while ( queue && QUEUE_ReceiveMessage( queue ) )
- ;
-
- QUEUE_Unlock( queue );
-}
-
-/***********************************************************************
- * GetMessagePos (USER.119) (USER32.@)
- *
+ * GetMessagePos (USER.119)
+ * GetMessagePos (USER32.@)
+ *
* The GetMessagePos() function returns a long value representing a
* cursor position, in screen coordinates, when the last message
* retrieved by the GetMessage() function occurs. The x-coordinate is
* in the low-order word of the return value, the y-coordinate is in
* the high-order word. The application can use the MAKEPOINT()
- * macro to obtain a POINT structure from the return value.
+ * macro to obtain a POINT structure from the return value.
*
* For the current cursor position, use GetCursorPos().
*
DWORD WINAPI GetMessagePos(void)
{
MESSAGEQUEUE *queue;
- DWORD ret;
-
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
- ret = queue->GetMessagePosVal;
- QUEUE_Unlock( queue );
- return ret;
+ if (!(queue = QUEUE_Current())) return 0;
+ return queue->GetMessagePosVal;
}
/***********************************************************************
- * GetMessageTime (USER.120) (USER32.@)
+ * GetMessageTime (USER.120)
+ * GetMessageTime (USER32.@)
*
* GetMessageTime() returns the message time for the last message
* retrieved by the function. The time is measured in milliseconds with
* CONFORMANCE
*
* ECMA-234, Win32
- *
+ *
*/
LONG WINAPI GetMessageTime(void)
{
MESSAGEQUEUE *queue;
- LONG ret;
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
- ret = queue->GetMessageTimeVal;
- QUEUE_Unlock( queue );
-
- return ret;
+ if (!(queue = QUEUE_Current())) return 0;
+ return queue->GetMessageTimeVal;
}
/***********************************************************************
- * GetMessageExtraInfo (USER.288) (USER32.@)
+ * GetMessageExtraInfo (USER.288)
+ * GetMessageExtraInfo (USER32.@)
*/
-LONG WINAPI GetMessageExtraInfo(void)
+LPARAM WINAPI GetMessageExtraInfo(void)
{
MESSAGEQUEUE *queue;
- LONG ret;
-
- if (!(queue = QUEUE_Lock( GetFastQueue16() ))) return 0;
- ret = queue->GetMessageExtraInfoVal;
- QUEUE_Unlock( queue );
- return ret;
+ if (!(queue = QUEUE_Current())) return 0;
+ return queue->GetMessageExtraInfoVal;
}
-/**********************************************************************
- * AttachThreadInput (USER32.@) Attaches input of 1 thread to other
- *
- * Attaches the input processing mechanism of one thread to that of
- * another thread.
- *
- * RETURNS
- * Success: TRUE
- * Failure: FALSE
- *
- * TODO:
- * 1. Reset the Key State (currenly per thread key state is not maintained)
+/***********************************************************************
+ * SetMessageExtraInfo (USER32.@)
*/
-BOOL WINAPI AttachThreadInput(
- DWORD idAttach, /* [in] Thread to attach */
- DWORD idAttachTo, /* [in] Thread to attach to */
- BOOL fAttach) /* [in] Attach or detach */
+LPARAM WINAPI SetMessageExtraInfo(LPARAM lParam)
{
- MESSAGEQUEUE *pSrcMsgQ = 0, *pTgtMsgQ = 0;
- BOOL16 bRet = 0;
-
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
-
- /* A thread cannot attach to itself */
- if ( idAttach == idAttachTo )
- goto CLEANUP;
-
- /* According to the docs this method should fail if a
- * "Journal record" hook is installed. (attaches all input queues together)
- */
- if ( HOOK_IsHooked( WH_JOURNALRECORD ) )
- goto CLEANUP;
-
- /* Retrieve message queues corresponding to the thread id's */
- pTgtMsgQ = QUEUE_Lock( GetThreadQueue16( idAttach ) );
- pSrcMsgQ = QUEUE_Lock( GetThreadQueue16( idAttachTo ) );
-
- /* Ensure we have message queues and that Src and Tgt threads
- * are not system threads.
- */
- if ( !pSrcMsgQ || !pTgtMsgQ || !pSrcMsgQ->pQData || !pTgtMsgQ->pQData )
- goto CLEANUP;
-
- if (fAttach) /* Attach threads */
- {
- /* Only attach if currently detached */
- if ( pTgtMsgQ->pQData != pSrcMsgQ->pQData )
- {
- /* First release the target threads perQData */
- PERQDATA_Release( pTgtMsgQ->pQData );
-
- /* Share a reference to the source threads perQDATA */
- PERQDATA_Addref( pSrcMsgQ->pQData );
- pTgtMsgQ->pQData = pSrcMsgQ->pQData;
- }
- }
- else /* Detach threads */
- {
- /* Only detach if currently attached */
- if ( pTgtMsgQ->pQData == pSrcMsgQ->pQData )
- {
- /* First release the target threads perQData */
- PERQDATA_Release( pTgtMsgQ->pQData );
-
- /* Give the target thread its own private perQDATA once more */
- pTgtMsgQ->pQData = PERQDATA_CreateInstance();
- }
- }
-
- /* TODO: Reset the Key State */
-
- bRet = 1; /* Success */
-
-CLEANUP:
+ MESSAGEQUEUE *queue;
+ LONG old_value;
- /* Unlock the queues before returning */
- if ( pSrcMsgQ )
- QUEUE_Unlock( pSrcMsgQ );
- if ( pTgtMsgQ )
- QUEUE_Unlock( pTgtMsgQ );
-
- return bRet;
+ if (!(queue = QUEUE_Current())) return 0;
+ old_value = queue->GetMessageExtraInfoVal;
+ queue->GetMessageExtraInfoVal = lParam;
+ return old_value;
}
projects / wine / blobdiff