2 * Message queues related functions
4 * Copyright 1993, 1994 Alexandre Julliard
19 #define MAX_QUEUE_SIZE 120 /* Max. size of a message queue */
21 static HQUEUE16 hFirstQueue
= 0;
22 static HQUEUE16 hDoomedQueue
= 0;
23 static HQUEUE16 hmemSysMsgQueue
= 0;
24 static MESSAGEQUEUE
*sysMsgQueue
= NULL
;
26 static MESSAGEQUEUE
*pMouseQueue
= NULL
; /* Queue for last mouse message */
27 static MESSAGEQUEUE
*pKbdQueue
= NULL
; /* Queue for last kbd message */
29 extern void SIGNAL_MaskAsyncEvents(BOOL32
);
31 MESSAGEQUEUE
*pCursorQueue
= NULL
;
32 MESSAGEQUEUE
*pActiveQueue
= NULL
;
34 /***********************************************************************
37 void QUEUE_DumpQueue( HQUEUE16 hQueue
)
41 if (!(pq
= (MESSAGEQUEUE
*) GlobalLock16( hQueue
)) ||
42 GlobalSize16(hQueue
) < sizeof(MESSAGEQUEUE
)+pq
->queueSize
*sizeof(QMSG
))
44 fprintf( stderr
, "%04x is not a queue handle\n", hQueue
);
49 "next: %12.4x Intertask SendMessage:\n"
50 "hTask: %11.4x ----------------------\n"
51 "msgSize: %9.4x hWnd: %10.4x\n"
52 "msgCount: %8.4x msg: %11.4x\n"
53 "msgNext: %9.4x wParam: %8.4x\n"
54 "msgFree: %9.4x lParam: %8.8x\n"
55 "qSize: %11.4x lRet: %10.8x\n"
56 "wWinVer: %9.4x ISMH: %10.4x\n"
57 "paints: %10.4x hSendTask: %5.4x\n"
58 "timers: %10.4x hPrevSend: %5.4x\n"
62 pq
->next
, pq
->hTask
, pq
->msgSize
, pq
->hWnd
,
63 pq
->msgCount
, pq
->msg
, pq
->nextMessage
, pq
->wParam
,
64 pq
->nextFreeMessage
, (unsigned)pq
->lParam
, pq
->queueSize
,
65 (unsigned)pq
->SendMessageReturn
, pq
->wWinVersion
, pq
->InSendMessageHandle
,
66 pq
->wPaintCount
, pq
->hSendingTask
, pq
->wTimerCount
,
67 pq
->hPrevSendingTask
, pq
->wakeBits
, pq
->wakeMask
, pq
->hCurHook
);
71 /***********************************************************************
74 void QUEUE_WalkQueues(void)
76 HQUEUE16 hQueue
= hFirstQueue
;
78 fprintf( stderr
, "Queue Size Msgs Task\n" );
81 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
);
84 fprintf( stderr
, "*** Bad queue handle %04x\n", hQueue
);
87 fprintf( stderr
, "%04x %5d %4d %04x %s\n",
88 hQueue
, queue
->msgSize
, queue
->msgCount
, queue
->hTask
,
89 MODULE_GetModuleName( GetExePtr(queue
->hTask
) ) );
92 fprintf( stderr
, "\n" );
96 /***********************************************************************
99 BOOL32
QUEUE_IsDoomedQueue( HQUEUE16 hQueue
)
101 return (hDoomedQueue
&& (hQueue
== hDoomedQueue
));
105 /***********************************************************************
106 * QUEUE_SetDoomedQueue
108 void QUEUE_SetDoomedQueue( HQUEUE16 hQueue
)
110 hDoomedQueue
= hQueue
;
114 /***********************************************************************
115 * QUEUE_CreateMsgQueue
117 * Creates a message queue. Doesn't link it into queue list!
119 static HQUEUE16
QUEUE_CreateMsgQueue( int size
)
122 MESSAGEQUEUE
* msgQueue
;
124 TDB
*pTask
= (TDB
*)GlobalLock16( GetCurrentTask() );
126 dprintf_msg(stddeb
,"Creating message queue...\n");
128 queueSize
= sizeof(MESSAGEQUEUE
) + size
* sizeof(QMSG
);
129 if (!(hQueue
= GlobalAlloc16( GMEM_FIXED
| GMEM_ZEROINIT
, queueSize
)))
131 msgQueue
= (MESSAGEQUEUE
*) GlobalLock16( hQueue
);
132 msgQueue
->self
= hQueue
;
133 msgQueue
->msgSize
= sizeof(QMSG
);
134 msgQueue
->queueSize
= size
;
135 msgQueue
->wakeBits
= msgQueue
->changeBits
= QS_SMPARAMSFREE
;
136 msgQueue
->wWinVersion
= pTask
? pTask
->version
: 0;
137 GlobalUnlock16( hQueue
);
142 /***********************************************************************
143 * QUEUE_DeleteMsgQueue
145 * Unlinks and deletes a message queue.
147 * Note: We need to mask asynchronous events to make sure PostMessage works
148 * even in the signal handler.
150 BOOL32
QUEUE_DeleteMsgQueue( HQUEUE16 hQueue
)
152 MESSAGEQUEUE
* msgQueue
= (MESSAGEQUEUE
*)GlobalLock16(hQueue
);
156 dprintf_msg(stddeb
,"Deleting message queue %04x\n", hQueue
);
158 if (!hQueue
|| !msgQueue
)
160 dprintf_msg(stddeb
,"DeleteMsgQueue: invalid argument.\n");
163 if( pCursorQueue
== msgQueue
) pCursorQueue
= NULL
;
164 if( pActiveQueue
== msgQueue
) pActiveQueue
= NULL
;
166 /* flush sent messages */
167 senderQ
= msgQueue
->hSendingTask
;
170 MESSAGEQUEUE
* sq
= (MESSAGEQUEUE
*)GlobalLock16(senderQ
);
172 sq
->SendMessageReturn
= 0L;
173 QUEUE_SetWakeBit( sq
, QS_SMRESULT
);
174 senderQ
= sq
->hPrevSendingTask
;
177 SIGNAL_MaskAsyncEvents( TRUE
);
179 pPrev
= &hFirstQueue
;
180 while (*pPrev
&& (*pPrev
!= hQueue
))
182 MESSAGEQUEUE
*msgQ
= (MESSAGEQUEUE
*)GlobalLock16(*pPrev
);
185 if (*pPrev
) *pPrev
= msgQueue
->next
;
188 SIGNAL_MaskAsyncEvents( FALSE
);
190 GlobalFree16( hQueue
);
195 /***********************************************************************
196 * QUEUE_CreateSysMsgQueue
198 * Create the system message queue, and set the double-click speed.
199 * Must be called only once.
201 BOOL32
QUEUE_CreateSysMsgQueue( int size
)
203 if (size
> MAX_QUEUE_SIZE
) size
= MAX_QUEUE_SIZE
;
204 else if (size
<= 0) size
= 1;
205 if (!(hmemSysMsgQueue
= QUEUE_CreateMsgQueue( size
))) return FALSE
;
206 sysMsgQueue
= (MESSAGEQUEUE
*) GlobalLock16( hmemSysMsgQueue
);
211 /***********************************************************************
214 MESSAGEQUEUE
*QUEUE_GetSysQueue(void)
220 /***********************************************************************
223 * See "Windows Internals", p.449
225 void QUEUE_SetWakeBit( MESSAGEQUEUE
*queue
, WORD bit
)
227 dprintf_msg(stddeb
,"SetWakeBit: queue = %04x (wm=%04x), bit = %04x\n",
228 queue
->self
, queue
->wakeMask
, bit
);
230 if (bit
& QS_MOUSE
) pMouseQueue
= queue
;
231 if (bit
& QS_KEY
) pKbdQueue
= queue
;
232 queue
->changeBits
|= bit
;
233 queue
->wakeBits
|= bit
;
234 if (queue
->wakeMask
& bit
)
237 PostEvent( queue
->hTask
);
242 /***********************************************************************
245 void QUEUE_ClearWakeBit( MESSAGEQUEUE
*queue
, WORD bit
)
247 queue
->changeBits
&= ~bit
;
248 queue
->wakeBits
&= ~bit
;
252 /***********************************************************************
255 * See "Windows Internals", p.447
257 void QUEUE_WaitBits( WORD bits
)
261 dprintf_msg(stddeb
,"WaitBits: q %04x waiting for %04x\n", GetTaskQueue(0), bits
);
265 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) ))) return;
267 if (queue
->changeBits
& bits
)
269 /* One of the bits is set; we can return */
273 if (queue
->wakeBits
& QS_SENDMESSAGE
)
275 /* Process the sent message immediately */
278 QUEUE_ReceiveMessage( queue
);
279 continue; /* nested sm crux */
282 queue
->wakeMask
= bits
| QS_SENDMESSAGE
;
283 if(queue
->changeBits
& bits
) continue;
285 dprintf_msg(stddeb
,"wb: (%04x) wakeMask is %04x, waiting\n", queue
->self
, queue
->wakeMask
);
292 /***********************************************************************
293 * QUEUE_ReceiveMessage
295 * This routine is called when a sent message is waiting for the queue.
297 void QUEUE_ReceiveMessage( MESSAGEQUEUE
*queue
)
299 MESSAGEQUEUE
*senderQ
= NULL
;
300 HQUEUE16 prevSender
= 0;
301 QSMCTRL
* prevCtrlPtr
= NULL
;
304 dprintf_msg(stddeb
, "ReceiveMessage, queue %04x\n", queue
->self
);
305 if (!(queue
->wakeBits
& QS_SENDMESSAGE
) ||
306 !(senderQ
= (MESSAGEQUEUE
*)GlobalLock16( queue
->hSendingTask
)))
307 { dprintf_msg(stddeb
,"\trcm: nothing to do\n"); return; }
309 if( !senderQ
->hPrevSendingTask
)
311 queue
->wakeBits
&= ~QS_SENDMESSAGE
; /* no more sent messages */
312 queue
->changeBits
&= ~QS_SENDMESSAGE
;
315 /* Save current state on stack */
316 prevSender
= queue
->InSendMessageHandle
;
317 prevCtrlPtr
= queue
->smResultCurrent
;
319 /* Remove sending queue from the list */
320 queue
->InSendMessageHandle
= queue
->hSendingTask
;
321 queue
->smResultCurrent
= senderQ
->smResultInit
;
322 queue
->hSendingTask
= senderQ
->hPrevSendingTask
;
324 dprintf_msg(stddeb
, "\trcm: smResultCurrent = %08x, prevCtrl = %08x\n",
325 (unsigned)queue
->smResultCurrent
, (unsigned)prevCtrlPtr
);
326 QUEUE_SetWakeBit( senderQ
, QS_SMPARAMSFREE
);
328 dprintf_msg(stddeb
, "\trcm: calling wndproc - %04x %04x %04x %08x\n",
329 senderQ
->hWnd
, senderQ
->msg
, senderQ
->wParam
, (unsigned)senderQ
->lParam
);
331 if (IsWindow( senderQ
->hWnd
))
333 DWORD extraInfo
= queue
->GetMessageExtraInfoVal
;
334 queue
->GetMessageExtraInfoVal
= senderQ
->GetMessageExtraInfoVal
;
336 result
= CallWindowProc16( (WNDPROC16
)GetWindowLong16(senderQ
->hWnd
, GWL_WNDPROC
),
337 senderQ
->hWnd
, senderQ
->msg
, senderQ
->wParam
, senderQ
->lParam
);
339 queue
->GetMessageExtraInfoVal
= extraInfo
; /* Restore extra info */
340 dprintf_msg(stddeb
,"\trcm: result = %08x\n", (unsigned)result
);
342 else dprintf_msg(stddeb
,"\trcm: bad hWnd\n");
344 /* Return the result to the sender task */
345 ReplyMessage( result
);
347 queue
->InSendMessageHandle
= prevSender
;
348 queue
->smResultCurrent
= prevCtrlPtr
;
350 dprintf_msg(stddeb
,"ReceiveMessage: done!\n");
353 /***********************************************************************
356 * Try to reply to all pending sent messages on exit.
358 void QUEUE_FlushMessages( HQUEUE16 hQueue
)
360 MESSAGEQUEUE
*queue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
);
364 MESSAGEQUEUE
*senderQ
= (MESSAGEQUEUE
*)GlobalLock16( queue
->hSendingTask
);
365 QSMCTRL
* CtrlPtr
= queue
->smResultCurrent
;
369 if( !(queue
->hSendingTask
= senderQ
->hPrevSendingTask
) )
370 queue
->wakeBits
&= ~QS_SENDMESSAGE
;
371 QUEUE_SetWakeBit( senderQ
, QS_SMPARAMSFREE
);
373 queue
->smResultCurrent
= CtrlPtr
;
374 while( senderQ
->wakeBits
& QS_SMRESULT
) OldYield();
376 senderQ
->SendMessageReturn
= 0;
377 senderQ
->smResult
= queue
->smResultCurrent
;
378 QUEUE_SetWakeBit( senderQ
, QS_SMRESULT
);
380 if( (senderQ
= (MESSAGEQUEUE
*)GlobalLock16( queue
->hSendingTask
)) )
381 CtrlPtr
= senderQ
->smResultInit
;
383 queue
->InSendMessageHandle
= 0;
387 /***********************************************************************
390 * Add a message to the queue. Return FALSE if queue is full.
392 BOOL32
QUEUE_AddMsg( HQUEUE16 hQueue
, MSG16
* msg
, DWORD extraInfo
)
395 MESSAGEQUEUE
*msgQueue
;
397 SIGNAL_MaskAsyncEvents( TRUE
);
399 if (!(msgQueue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
))) return FALSE
;
400 pos
= msgQueue
->nextFreeMessage
;
402 /* Check if queue is full */
403 if ((pos
== msgQueue
->nextMessage
) && (msgQueue
->msgCount
> 0))
405 SIGNAL_MaskAsyncEvents( FALSE
);
406 fprintf(stderr
,"MSG_AddMsg // queue is full !\n");
411 msgQueue
->messages
[pos
].msg
= *msg
;
412 msgQueue
->messages
[pos
].extraInfo
= extraInfo
;
413 if (pos
< msgQueue
->queueSize
-1) pos
++;
415 msgQueue
->nextFreeMessage
= pos
;
416 msgQueue
->msgCount
++;
418 SIGNAL_MaskAsyncEvents( FALSE
);
420 QUEUE_SetWakeBit( msgQueue
, QS_POSTMESSAGE
);
425 /***********************************************************************
428 * Find a message matching the given parameters. Return -1 if none available.
430 int QUEUE_FindMsg( MESSAGEQUEUE
* msgQueue
, HWND32 hwnd
, int first
, int last
)
432 int i
, pos
= msgQueue
->nextMessage
;
434 dprintf_msg(stddeb
,"QUEUE_FindMsg: hwnd=%04x pos=%d\n", hwnd
, pos
);
436 if (!msgQueue
->msgCount
) return -1;
437 if (!hwnd
&& !first
&& !last
) return pos
;
439 for (i
= 0; i
< msgQueue
->msgCount
; i
++)
441 MSG16
* msg
= &msgQueue
->messages
[pos
].msg
;
443 if (!hwnd
|| (msg
->hwnd
== hwnd
))
445 if (!first
&& !last
) return pos
;
446 if ((msg
->message
>= first
) && (msg
->message
<= last
)) return pos
;
448 if (pos
< msgQueue
->queueSize
-1) pos
++;
455 /***********************************************************************
458 * Remove a message from the queue (pos must be a valid position).
460 void QUEUE_RemoveMsg( MESSAGEQUEUE
* msgQueue
, int pos
)
462 SIGNAL_MaskAsyncEvents( TRUE
);
464 if (pos
>= msgQueue
->nextMessage
)
466 for ( ; pos
> msgQueue
->nextMessage
; pos
--)
467 msgQueue
->messages
[pos
] = msgQueue
->messages
[pos
-1];
468 msgQueue
->nextMessage
++;
469 if (msgQueue
->nextMessage
>= msgQueue
->queueSize
)
470 msgQueue
->nextMessage
= 0;
474 for ( ; pos
< msgQueue
->nextFreeMessage
; pos
++)
475 msgQueue
->messages
[pos
] = msgQueue
->messages
[pos
+1];
476 if (msgQueue
->nextFreeMessage
) msgQueue
->nextFreeMessage
--;
477 else msgQueue
->nextFreeMessage
= msgQueue
->queueSize
-1;
479 msgQueue
->msgCount
--;
480 if (!msgQueue
->msgCount
) msgQueue
->wakeBits
&= ~QS_POSTMESSAGE
;
482 SIGNAL_MaskAsyncEvents( FALSE
);
486 /***********************************************************************
489 * Wake a queue upon reception of a hardware event.
491 static void QUEUE_WakeSomeone( UINT message
)
496 MESSAGEQUEUE
*queue
= pCursorQueue
;
498 if( (message
>= WM_KEYFIRST
) && (message
<= WM_KEYLAST
) )
501 if( pActiveQueue
) queue
= pActiveQueue
;
505 wakeBit
= (message
== WM_MOUSEMOVE
) ? QS_MOUSEMOVE
: QS_MOUSEBUTTON
;
506 if( (hwnd
= GetCapture32()) )
507 if( (wndPtr
= WIN_FindWndPtr( hwnd
)) )
508 queue
= (MESSAGEQUEUE
*)GlobalLock16( wndPtr
->hmemTaskQ
);
511 if( (hwnd
= GetSysModalWindow16()) )
512 if( (wndPtr
= WIN_FindWndPtr( hwnd
)) )
513 queue
= (MESSAGEQUEUE
*)GlobalLock16( wndPtr
->hmemTaskQ
);
517 queue
= GlobalLock16( hFirstQueue
);
520 if (queue
->wakeMask
& wakeBit
) break;
521 queue
= GlobalLock16( queue
->next
);
525 dprintf_msg(stddeb
,"WakeSomeone: couldn't find queue\n");
530 QUEUE_SetWakeBit( queue
, wakeBit
);
534 /***********************************************************************
537 * Add an event to the system message queue.
538 * Note: the position is relative to the desktop window.
540 void hardware_event( WORD message
, WORD wParam
, LONG lParam
,
541 int xPos
, int yPos
, DWORD time
, DWORD extraInfo
)
546 if (!sysMsgQueue
) return;
547 pos
= sysMsgQueue
->nextFreeMessage
;
549 /* Merge with previous event if possible */
551 if ((message
== WM_MOUSEMOVE
) && sysMsgQueue
->msgCount
)
554 else pos
= sysMsgQueue
->queueSize
- 1;
555 msg
= &sysMsgQueue
->messages
[pos
].msg
;
556 if ((msg
->message
== message
) && (msg
->wParam
== wParam
))
557 sysMsgQueue
->msgCount
--; /* Merge events */
559 pos
= sysMsgQueue
->nextFreeMessage
; /* Don't merge */
562 /* Check if queue is full */
564 if ((pos
== sysMsgQueue
->nextMessage
) && sysMsgQueue
->msgCount
)
566 /* Queue is full, beep (but not on every mouse motion...) */
567 if (message
!= WM_MOUSEMOVE
) MessageBeep32(0);
573 msg
= &sysMsgQueue
->messages
[pos
].msg
;
575 msg
->message
= message
;
576 msg
->wParam
= wParam
;
577 msg
->lParam
= lParam
;
579 msg
->pt
.x
= xPos
& 0xffff;
580 msg
->pt
.y
= yPos
& 0xffff;
581 sysMsgQueue
->messages
[pos
].extraInfo
= extraInfo
;
582 if (pos
< sysMsgQueue
->queueSize
- 1) pos
++;
584 sysMsgQueue
->nextFreeMessage
= pos
;
585 sysMsgQueue
->msgCount
++;
586 QUEUE_WakeSomeone( message
);
590 /***********************************************************************
593 HTASK16
QUEUE_GetQueueTask( HQUEUE16 hQueue
)
595 MESSAGEQUEUE
*queue
= GlobalLock16( hQueue
);
596 return (queue
) ? queue
->hTask
: 0 ;
600 /***********************************************************************
601 * QUEUE_IncPaintCount
603 void QUEUE_IncPaintCount( HQUEUE16 hQueue
)
607 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
))) return;
608 queue
->wPaintCount
++;
609 QUEUE_SetWakeBit( queue
, QS_PAINT
);
613 /***********************************************************************
614 * QUEUE_DecPaintCount
616 void QUEUE_DecPaintCount( HQUEUE16 hQueue
)
620 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
))) return;
621 queue
->wPaintCount
--;
622 if (!queue
->wPaintCount
) queue
->wakeBits
&= ~QS_PAINT
;
626 /***********************************************************************
627 * QUEUE_IncTimerCount
629 void QUEUE_IncTimerCount( HQUEUE16 hQueue
)
633 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
))) return;
634 queue
->wTimerCount
++;
635 QUEUE_SetWakeBit( queue
, QS_TIMER
);
639 /***********************************************************************
640 * QUEUE_DecTimerCount
642 void QUEUE_DecTimerCount( HQUEUE16 hQueue
)
646 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
))) return;
647 queue
->wTimerCount
--;
648 if (!queue
->wTimerCount
) queue
->wakeBits
&= ~QS_TIMER
;
652 /***********************************************************************
653 * PostQuitMessage16 (USER.6)
655 void PostQuitMessage16( INT16 exitCode
)
657 PostQuitMessage32( exitCode
);
661 /***********************************************************************
662 * PostQuitMessage32 (USER32.420)
664 void PostQuitMessage32( INT32 exitCode
)
668 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) ))) return;
669 queue
->wPostQMsg
= TRUE
;
670 queue
->wExitCode
= (WORD
)exitCode
;
674 /***********************************************************************
675 * GetWindowTask16 (USER.224)
677 HTASK16
GetWindowTask16( HWND16 hwnd
)
679 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
681 if (!wndPtr
) return 0;
682 return QUEUE_GetQueueTask( wndPtr
->hmemTaskQ
);
685 /***********************************************************************
686 * GetWindowThreadProcessId (USER32.312)
688 DWORD
GetWindowThreadProcessId( HWND32 hwnd
, LPDWORD process
)
693 WND
*wndPtr
= WIN_FindWndPtr( hwnd
);
695 if (!wndPtr
) return 0;
696 htask
=QUEUE_GetQueueTask( wndPtr
->hmemTaskQ
);
697 tdb
= (TDB
*)GlobalLock16(htask
);
701 *process
= (DWORD
)tdb
->thdb
->process
;
702 return (DWORD
)tdb
->thdb
;
709 /***********************************************************************
710 * SetMessageQueue16 (USER.266)
712 BOOL16
SetMessageQueue16( INT16 size
)
714 return SetMessageQueue32( size
);
718 /***********************************************************************
719 * SetMessageQueue32 (USER32.493)
721 BOOL32
SetMessageQueue32( INT32 size
)
723 HQUEUE16 hQueue
, hNewQueue
;
724 MESSAGEQUEUE
*queuePtr
;
726 dprintf_msg(stddeb
,"SetMessageQueue: task %04x size %i\n", GetCurrentTask(), size
);
728 if ((size
> MAX_QUEUE_SIZE
) || (size
<= 0)) return TRUE
;
730 if( !(hNewQueue
= QUEUE_CreateMsgQueue( size
)))
732 dprintf_msg(stddeb
,"SetMessageQueue: failed!\n");
735 queuePtr
= (MESSAGEQUEUE
*)GlobalLock16( hNewQueue
);
737 SIGNAL_MaskAsyncEvents( TRUE
);
739 /* Copy data and free the old message queue */
740 if ((hQueue
= GetTaskQueue(0)) != 0)
742 MESSAGEQUEUE
*oldQ
= (MESSAGEQUEUE
*)GlobalLock16( hQueue
);
743 memcpy( &queuePtr
->reserved2
, &oldQ
->reserved2
,
744 (int)oldQ
->messages
- (int)(&oldQ
->reserved2
) );
745 HOOK_ResetQueueHooks( hNewQueue
);
746 if( WIN_GetDesktop()->hmemTaskQ
== hQueue
)
747 WIN_GetDesktop()->hmemTaskQ
= hNewQueue
;
748 WIN_ResetQueueWindows( WIN_GetDesktop()->child
, hQueue
, hNewQueue
);
749 QUEUE_DeleteMsgQueue( hQueue
);
752 /* Link new queue into list */
753 queuePtr
->hTask
= GetCurrentTask();
754 queuePtr
->next
= hFirstQueue
;
755 hFirstQueue
= hNewQueue
;
757 if( !queuePtr
->next
) pCursorQueue
= queuePtr
;
758 SetTaskQueue( 0, hNewQueue
);
760 SIGNAL_MaskAsyncEvents( FALSE
);
765 /***********************************************************************
766 * GetQueueStatus (USER.334)
768 DWORD
GetQueueStatus( UINT flags
)
773 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) ))) return 0;
774 ret
= MAKELONG( queue
->changeBits
, queue
->wakeBits
);
775 queue
->changeBits
= 0;
776 return ret
& MAKELONG( flags
, flags
);
780 /***********************************************************************
781 * GetInputState16 (USER.335)
783 BOOL16
GetInputState16(void)
785 return GetInputState32();
789 /***********************************************************************
790 * GetInputState32 (USER32.243)
792 BOOL32
GetInputState32(void)
796 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) )))
798 return queue
->wakeBits
& (QS_KEY
| QS_MOUSEBUTTON
);
802 /***********************************************************************
803 * GetMessagePos (USER.119) (USER32.271)
805 DWORD
GetMessagePos(void)
809 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) ))) return 0;
810 return queue
->GetMessagePosVal
;
814 /***********************************************************************
815 * GetMessageTime (USER.120) (USER32.272)
817 LONG
GetMessageTime(void)
821 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) ))) return 0;
822 return queue
->GetMessageTimeVal
;
826 /***********************************************************************
827 * GetMessageExtraInfo (USER.288) (USER32.270)
829 LONG
GetMessageExtraInfo(void)
833 if (!(queue
= (MESSAGEQUEUE
*)GlobalLock16( GetTaskQueue(0) ))) return 0;
834 return queue
->GetMessageExtraInfoVal
;