windows/queue.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include "module.h"
   9 #include "queue.h"
  10 #include "task.h"
  11 #include "win.h"
  12 #include "stddebug.h"
  13 #include "debug.h"
  14
  15 #define MAX_QUEUE_SIZE   120  /* Max. size of a message queue */
  16
  17 static HQUEUE16 hFirstQueue = 0;
  18 static HQUEUE16 hDoomedQueue = 0;
  19 static HQUEUE16 hmemSysMsgQueue = 0;
  20 static MESSAGEQUEUE *sysMsgQueue = NULL;
  21
  22 static MESSAGEQUEUE *pMouseQueue = NULL;  /* Queue for last mouse message */
  23 static MESSAGEQUEUE *pKbdQueue = NULL;    /* Queue for last kbd message */
  24
  25 MESSAGEQUEUE *pCursorQueue = NULL;
  26 MESSAGEQUEUE *pActiveQueue = NULL;
  27
  28 /***********************************************************************
  29  *           QUEUE_DumpQueue
  30  */
  31 void QUEUE_DumpQueue( HQUEUE16 hQueue )
  32 {
  33     MESSAGEQUEUE *pq;
  34
  35     if (!(pq = (MESSAGEQUEUE*) GlobalLock16( hQueue )) ||
  36         GlobalSize16(hQueue) < sizeof(MESSAGEQUEUE)+pq->queueSize*sizeof(QMSG))
  37     {
  38         fprintf( stderr, "%04x is not a queue handle\n", hQueue );
  39         return;
  40     }
  41
  42     fprintf( stderr,
  43              "next: %12.4x  Intertask SendMessage:\n"
  44              "hTask: %11.4x  ----------------------\n"
  45              "msgSize: %9.4x  hWnd: %10.4x\n"
  46              "msgCount: %8.4x  msg: %11.4x\n"
  47              "msgNext: %9.4x  wParam: %8.4x\n"
  48              "msgFree: %9.4x  lParam: %8.8x\n"
  49              "qSize: %11.4x  lRet: %10.8x\n"
  50              "wWinVer: %9.4x  ISMH: %10.4x\n"
  51              "paints: %10.4x  hSendTask: %5.4x\n"
  52              "timers: %10.4x  hPrevSend: %5.4x\n"
  53              "wakeBits: %8.4x\n"
  54              "wakeMask: %8.4x\n"
  55              "hCurHook: %8.4x\n",
  56              pq->next, pq->hTask, pq->msgSize, pq->hWnd,
  57              pq->msgCount, pq->msg, pq->nextMessage, pq->wParam,
  58              pq->nextFreeMessage, (unsigned)pq->lParam, pq->queueSize,
  59              (unsigned)pq->SendMessageReturn, pq->wWinVersion, pq->InSendMessageHandle,
  60              pq->wPaintCount, pq->hSendingTask, pq->wTimerCount,
  61              pq->hPrevSendingTask, pq->wakeBits, pq->wakeMask, pq->hCurHook);
  62 }
  63
  64
  65 /***********************************************************************
  66  *           QUEUE_WalkQueues
  67  */
  68 void QUEUE_WalkQueues(void)
  69 {
  70     HQUEUE16 hQueue = hFirstQueue;
  71
  72     fprintf( stderr, "Queue Size Msgs Task\n" );
  73     while (hQueue)
  74     {
  75         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( hQueue );
  76         if (!queue)
  77         {
  78             fprintf( stderr, "*** Bad queue handle %04x\n", hQueue );
  79             return;
  80         }
  81         fprintf( stderr, "%04x %5d %4d %04x %s\n",
  82                  hQueue, queue->msgSize, queue->msgCount, queue->hTask,
  83                  MODULE_GetModuleName( GetExePtr(queue->hTask) ) );
  84         hQueue = queue->next;
  85     }
  86     fprintf( stderr, "\n" );
  87 }
  88
  89
  90 /***********************************************************************
  91  *           QUEUE_IsDoomedQueue
  92  */
  93 BOOL32 QUEUE_IsDoomedQueue( HQUEUE16 hQueue )
  94 {
  95     return (hDoomedQueue && (hQueue == hDoomedQueue));
  96 }
  97
  98
  99 /***********************************************************************
 100  *           QUEUE_SetDoomedQueue
 101  */
 102 void QUEUE_SetDoomedQueue( HQUEUE16 hQueue )
 103 {
 104     hDoomedQueue = hQueue;
 105 }
 106
 107
 108 /***********************************************************************
 109  *           QUEUE_CreateMsgQueue
 110  *
 111  * Creates a message queue. Doesn't link it into queue list!
 112  */
 113 static HQUEUE16 QUEUE_CreateMsgQueue( int size )
 114 {
 115     HQUEUE16 hQueue;
 116     MESSAGEQUEUE * msgQueue;
 117     int queueSize;
 118     TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
 119
 120     dprintf_msg(stddeb,"Creating message queue...\n");
 121
 122     queueSize = sizeof(MESSAGEQUEUE) + size * sizeof(QMSG);
 123     if (!(hQueue = GlobalAlloc16( GMEM_FIXED | GMEM_ZEROINIT, queueSize )))
 124         return 0;
 125     msgQueue = (MESSAGEQUEUE *) GlobalLock16( hQueue );
 126     msgQueue->self        = hQueue;
 127     msgQueue->msgSize     = sizeof(QMSG);
 128     msgQueue->queueSize   = size;
 129     msgQueue->wakeBits    = msgQueue->changeBits = QS_SMPARAMSFREE;
 130     msgQueue->wWinVersion = pTask ? pTask->version : 0;
 131     GlobalUnlock16( hQueue );
 132     return hQueue;
 133 }
 134
 135
 136 /***********************************************************************
 137  *           QUEUE_DeleteMsgQueue
 138  *
 139  * Unlinks and deletes a message queue.
 140  */
 141 BOOL32 QUEUE_DeleteMsgQueue( HQUEUE16 hQueue )
 142 {
 143     MESSAGEQUEUE * msgQueue = (MESSAGEQUEUE*)GlobalLock16(hQueue);
 144     HQUEUE16  senderQ;
 145     HQUEUE16 *pPrev;
 146
 147     dprintf_msg(stddeb,"Deleting message queue %04x\n", hQueue);
 148
 149     if (!hQueue || !msgQueue)
 150     {
 151         dprintf_msg(stddeb,"DeleteMsgQueue: invalid argument.\n");
 152         return 0;
 153     }
 154     if( pCursorQueue == msgQueue ) pCursorQueue = NULL;
 155     if( pActiveQueue == msgQueue ) pActiveQueue = NULL;
 156
 157     /* flush sent messages */
 158     senderQ = msgQueue->hSendingTask;
 159     while( senderQ )
 160     {
 161       MESSAGEQUEUE* sq = (MESSAGEQUEUE*)GlobalLock16(senderQ);
 162       if( !sq ) break;
 163       sq->SendMessageReturn = 0L;
 164       QUEUE_SetWakeBit( sq, QS_SMRESULT );
 165       senderQ = sq->hPrevSendingTask;
 166     }
 167
 168     pPrev = &hFirstQueue;
 169     while (*pPrev && (*pPrev != hQueue))
 170     {
 171         MESSAGEQUEUE *msgQ = (MESSAGEQUEUE*)GlobalLock16(*pPrev);
 172         pPrev = &msgQ->next;
 173     }
 174     if (*pPrev) *pPrev = msgQueue->next;
 175     msgQueue->self = 0;
 176     GlobalFree16( hQueue );
 177     return 1;
 178 }
 179
 180
 181 /***********************************************************************
 182  *           QUEUE_CreateSysMsgQueue
 183  *
 184  * Create the system message queue, and set the double-click speed.
 185  * Must be called only once.
 186  */
 187 BOOL32 QUEUE_CreateSysMsgQueue( int size )
 188 {
 189     if (size > MAX_QUEUE_SIZE) size = MAX_QUEUE_SIZE;
 190     else if (size <= 0) size = 1;
 191     if (!(hmemSysMsgQueue = QUEUE_CreateMsgQueue( size ))) return FALSE;
 192     sysMsgQueue = (MESSAGEQUEUE *) GlobalLock16( hmemSysMsgQueue );
 193     return TRUE;
 194 }
 195
 196
 197 /***********************************************************************
 198  *           QUEUE_GetSysQueue
 199  */
 200 MESSAGEQUEUE *QUEUE_GetSysQueue(void)
 201 {
 202     return sysMsgQueue;
 203 }
 204
 205
 206 /***********************************************************************
 207  *           QUEUE_SetWakeBit
 208  *
 209  * See "Windows Internals", p.449
 210  */
 211 void QUEUE_SetWakeBit( MESSAGEQUEUE *queue, WORD bit )
 212 {
 213     dprintf_msg(stddeb,"SetWakeBit: queue = %04x (wm=%04x), bit = %04x\n",
 214                         queue->self, queue->wakeMask, bit );
 215
 216     if (bit & QS_MOUSE) pMouseQueue = queue;
 217     if (bit & QS_KEY) pKbdQueue = queue;
 218     queue->changeBits |= bit;
 219     queue->wakeBits   |= bit;
 220     if (queue->wakeMask & bit)
 221     {
 222         queue->wakeMask = 0;
 223         PostEvent( queue->hTask );
 224     }
 225 }
 226
 227
 228 /***********************************************************************
 229  *           QUEUE_ClearWakeBit
 230  */
 231 void QUEUE_ClearWakeBit( MESSAGEQUEUE *queue, WORD bit )
 232 {
 233     queue->changeBits &= ~bit;
 234     queue->wakeBits   &= ~bit;
 235 }
 236
 237
 238 /***********************************************************************
 239  *           QUEUE_WaitBits
 240  *
 241  * See "Windows Internals", p.447
 242  */
 243 void QUEUE_WaitBits( WORD bits )
 244 {
 245     MESSAGEQUEUE *queue;
 246
 247     dprintf_msg(stddeb,"WaitBits: q %04x waiting for %04x\n", GetTaskQueue(0), bits);
 248
 249     for (;;)
 250     {
 251         if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return;
 252
 253         if (queue->changeBits & bits)
 254         {
 255             /* One of the bits is set; we can return */
 256             queue->wakeMask = 0;
 257             return;
 258         }
 259         if (queue->wakeBits & QS_SENDMESSAGE)
 260         {
 261             /* Process the sent message immediately */
 262
 263             queue->wakeMask = 0;
 264             QUEUE_ReceiveMessage( queue );
 265             continue;                           /* nested sm crux */
 266         }
 267
 268         queue->wakeMask = bits | QS_SENDMESSAGE;
 269         if(queue->changeBits & bits) continue;
 270
 271         dprintf_msg(stddeb,"wb: (%04x) wakeMask is %04x, waiting\n", queue->self, queue->wakeMask);
 272
 273         WaitEvent( 0 );
 274     }
 275 }
 276
 277
 278 /***********************************************************************
 279  *           QUEUE_ReceiveMessage
 280  *
 281  * This routine is called when a sent message is waiting for the queue.
 282  */
 283 void QUEUE_ReceiveMessage( MESSAGEQUEUE *queue )
 284 {
 285     MESSAGEQUEUE *senderQ = NULL;
 286     HQUEUE16      prevSender = 0;
 287     QSMCTRL*      prevCtrlPtr = NULL;
 288     LRESULT       result = 0;
 289
 290     dprintf_msg(stddeb, "ReceiveMessage, queue %04x\n", queue->self );
 291     if (!(queue->wakeBits & QS_SENDMESSAGE) ||
 292         !(senderQ = (MESSAGEQUEUE*)GlobalLock16( queue->hSendingTask)))
 293         { dprintf_msg(stddeb,"\trcm: nothing to do\n"); return; }
 294
 295     queue->InSendMessageHandle = queue->hSendingTask;
 296     if( !(queue->hSendingTask = senderQ->hPrevSendingTask) )
 297     {
 298       queue->wakeBits &= ~QS_SENDMESSAGE;       /* no more sent messages */
 299       queue->changeBits &= ~QS_SENDMESSAGE;
 300     }
 301
 302     /* Remove sending queue from the list */
 303     prevSender                 = queue->InSendMessageHandle;
 304     prevCtrlPtr                = queue->smResultCurrent;
 305     queue->smResultCurrent     = senderQ->smResultInit;
 306
 307     dprintf_msg(stddeb, "\trcm: smResultCurrent = %08x, prevCtrl = %08x\n",
 308                                 (unsigned)queue->smResultCurrent, (unsigned)prevCtrlPtr );
 309     QUEUE_SetWakeBit( senderQ, QS_SMPARAMSFREE );
 310
 311     dprintf_msg(stddeb, "\trcm: calling wndproc - %04x %04x %04x %08x\n",
 312             senderQ->hWnd, senderQ->msg, senderQ->wParam, (unsigned)senderQ->lParam );
 313
 314     if (IsWindow( senderQ->hWnd ))
 315     {
 316         DWORD extraInfo = queue->GetMessageExtraInfoVal;
 317         queue->GetMessageExtraInfoVal = senderQ->GetMessageExtraInfoVal;
 318
 319         result = CallWindowProc16( (WNDPROC16)GetWindowLong16(senderQ->hWnd, GWL_WNDPROC),
 320                                    senderQ->hWnd, senderQ->msg, senderQ->wParam, senderQ->lParam );
 321
 322         queue->GetMessageExtraInfoVal = extraInfo;  /* Restore extra info */
 323         dprintf_msg(stddeb,"\trcm: result =  %08x\n", (unsigned)result );
 324     }
 325     else dprintf_msg(stddeb,"\trcm: bad hWnd\n");
 326
 327     /* Return the result to the sender task */
 328     ReplyMessage( result );
 329
 330     queue->InSendMessageHandle = prevSender;
 331     queue->smResultCurrent     = prevCtrlPtr;
 332
 333     dprintf_msg(stddeb,"ReceiveMessage: done!\n");
 334 }
 335
 336
 337 /***********************************************************************
 338  *           QUEUE_AddMsg
 339  *
 340  * Add a message to the queue. Return FALSE if queue is full.
 341  */
 342 BOOL32 QUEUE_AddMsg( HQUEUE16 hQueue, MSG16 * msg, DWORD extraInfo )
 343 {
 344     int pos;
 345     MESSAGEQUEUE *msgQueue;
 346
 347     if (!(msgQueue = (MESSAGEQUEUE *)GlobalLock16( hQueue ))) return FALSE;
 348     pos = msgQueue->nextFreeMessage;
 349
 350       /* Check if queue is full */
 351     if ((pos == msgQueue->nextMessage) && (msgQueue->msgCount > 0))
 352     {
 353         fprintf(stderr,"MSG_AddMsg // queue is full !\n");
 354         return FALSE;
 355     }
 356
 357       /* Store message */
 358     msgQueue->messages[pos].msg = *msg;
 359     msgQueue->messages[pos].extraInfo = extraInfo;
 360     if (pos < msgQueue->queueSize-1) pos++;
 361     else pos = 0;
 362     msgQueue->nextFreeMessage = pos;
 363     msgQueue->msgCount++;
 364     QUEUE_SetWakeBit( msgQueue, QS_POSTMESSAGE );
 365     return TRUE;
 366 }
 367
 368
 369 /***********************************************************************
 370  *           QUEUE_FindMsg
 371  *
 372  * Find a message matching the given parameters. Return -1 if none available.
 373  */
 374 int QUEUE_FindMsg( MESSAGEQUEUE * msgQueue, HWND32 hwnd, int first, int last )
 375 {
 376     int i, pos = msgQueue->nextMessage;
 377
 378     dprintf_msg(stddeb,"QUEUE_FindMsg: hwnd=%04x pos=%d\n", hwnd, pos );
 379
 380     if (!msgQueue->msgCount) return -1;
 381     if (!hwnd && !first && !last) return pos;
 382
 383     for (i = 0; i < msgQueue->msgCount; i++)
 384     {
 385         MSG16 * msg = &msgQueue->messages[pos].msg;
 386
 387         if (!hwnd || (msg->hwnd == hwnd))
 388         {
 389             if (!first && !last) return pos;
 390             if ((msg->message >= first) && (msg->message <= last)) return pos;
 391         }
 392         if (pos < msgQueue->queueSize-1) pos++;
 393         else pos = 0;
 394     }
 395     return -1;
 396 }
 397
 398
 399 /***********************************************************************
 400  *           QUEUE_RemoveMsg
 401  *
 402  * Remove a message from the queue (pos must be a valid position).
 403  */
 404 void QUEUE_RemoveMsg( MESSAGEQUEUE * msgQueue, int pos )
 405 {
 406     if (pos >= msgQueue->nextMessage)
 407     {
 408         for ( ; pos > msgQueue->nextMessage; pos--)
 409             msgQueue->messages[pos] = msgQueue->messages[pos-1];
 410         msgQueue->nextMessage++;
 411         if (msgQueue->nextMessage >= msgQueue->queueSize)
 412             msgQueue->nextMessage = 0;
 413     }
 414     else
 415     {
 416         for ( ; pos < msgQueue->nextFreeMessage; pos++)
 417             msgQueue->messages[pos] = msgQueue->messages[pos+1];
 418         if (msgQueue->nextFreeMessage) msgQueue->nextFreeMessage--;
 419         else msgQueue->nextFreeMessage = msgQueue->queueSize-1;
 420     }
 421     msgQueue->msgCount--;
 422     if (!msgQueue->msgCount) msgQueue->wakeBits &= ~QS_POSTMESSAGE;
 423 }
 424
 425
 426 /***********************************************************************
 427  *           QUEUE_WakeSomeone
 428  *
 429  * Wake a queue upon reception of a hardware event.
 430  */
 431 static void QUEUE_WakeSomeone( UINT message )
 432 {
 433     WND*          wndPtr = NULL;
 434     HWND          hwnd;
 435     WORD          wakeBit;
 436     MESSAGEQUEUE *queue = pCursorQueue;
 437
 438     if( (message >= WM_KEYFIRST) && (message <= WM_KEYLAST) )
 439     {
 440        wakeBit = QS_KEY;
 441        if( pActiveQueue ) queue = pActiveQueue;
 442     }
 443     else
 444     {
 445        wakeBit = (message == WM_MOUSEMOVE) ? QS_MOUSEMOVE : QS_MOUSEBUTTON;
 446        if( (hwnd = GetCapture32()) )
 447          if( (wndPtr = WIN_FindWndPtr( hwnd )) )
 448            queue = (MESSAGEQUEUE *)GlobalLock16( wndPtr->hmemTaskQ );
 449     }
 450
 451     if( (hwnd = GetSysModalWindow16()) )
 452       if( (wndPtr = WIN_FindWndPtr( hwnd )) )
 453         queue = (MESSAGEQUEUE *)GlobalLock16( wndPtr->hmemTaskQ );
 454
 455     if( !queue )
 456     {
 457       queue = GlobalLock16( hFirstQueue );
 458       while( queue )
 459       {
 460         if (queue->wakeMask & wakeBit) break;
 461         queue = GlobalLock16( queue->next );
 462       }
 463       if( !queue )
 464       {
 465         dprintf_msg(stddeb,"WakeSomeone: couldn't find queue\n");
 466         return;
 467       }
 468     }
 469
 470     QUEUE_SetWakeBit( queue, wakeBit );
 471 }
 472
 473
 474 /***********************************************************************
 475  *           hardware_event
 476  *
 477  * Add an event to the system message queue.
 478  * Note: the position is relative to the desktop window.
 479  */
 480 void hardware_event( WORD message, WORD wParam, LONG lParam,
 481                      int xPos, int yPos, DWORD time, DWORD extraInfo )
 482 {
 483     MSG16 *msg;
 484     int pos;
 485
 486     if (!sysMsgQueue) return;
 487     pos = sysMsgQueue->nextFreeMessage;
 488
 489       /* Merge with previous event if possible */
 490
 491     if ((message == WM_MOUSEMOVE) && sysMsgQueue->msgCount)
 492     {
 493         if (pos > 0) pos--;
 494         else pos = sysMsgQueue->queueSize - 1;
 495         msg = &sysMsgQueue->messages[pos].msg;
 496         if ((msg->message == message) && (msg->wParam == wParam))
 497             sysMsgQueue->msgCount--;  /* Merge events */
 498         else
 499             pos = sysMsgQueue->nextFreeMessage;  /* Don't merge */
 500     }
 501
 502       /* Check if queue is full */
 503
 504     if ((pos == sysMsgQueue->nextMessage) && sysMsgQueue->msgCount)
 505     {
 506         /* Queue is full, beep (but not on every mouse motion...) */
 507         if (message != WM_MOUSEMOVE) MessageBeep(0);
 508         return;
 509     }
 510
 511       /* Store message */
 512
 513     msg = &sysMsgQueue->messages[pos].msg;
 514     msg->hwnd    = 0;
 515     msg->message = message;
 516     msg->wParam  = wParam;
 517     msg->lParam  = lParam;
 518     msg->time    = time;
 519     msg->pt.x    = xPos & 0xffff;
 520     msg->pt.y    = yPos & 0xffff;
 521     sysMsgQueue->messages[pos].extraInfo = extraInfo;
 522     if (pos < sysMsgQueue->queueSize - 1) pos++;
 523     else pos = 0;
 524     sysMsgQueue->nextFreeMessage = pos;
 525     sysMsgQueue->msgCount++;
 526     QUEUE_WakeSomeone( message );
 527 }
 528
 529
 530 /***********************************************************************
 531  *           QUEUE_GetQueueTask
 532  */
 533 HTASK16 QUEUE_GetQueueTask( HQUEUE16 hQueue )
 534 {
 535     MESSAGEQUEUE *queue = GlobalLock16( hQueue );
 536     return (queue) ? queue->hTask : 0 ;
 537 }
 538
 539
 540 /***********************************************************************
 541  *           QUEUE_IncPaintCount
 542  */
 543 void QUEUE_IncPaintCount( HQUEUE16 hQueue )
 544 {
 545     MESSAGEQUEUE *queue;
 546
 547     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( hQueue ))) return;
 548     queue->wPaintCount++;
 549     QUEUE_SetWakeBit( queue, QS_PAINT );
 550 }
 551
 552
 553 /***********************************************************************
 554  *           QUEUE_DecPaintCount
 555  */
 556 void QUEUE_DecPaintCount( HQUEUE16 hQueue )
 557 {
 558     MESSAGEQUEUE *queue;
 559
 560     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( hQueue ))) return;
 561     queue->wPaintCount--;
 562     if (!queue->wPaintCount) queue->wakeBits &= ~QS_PAINT;
 563 }
 564
 565
 566 /***********************************************************************
 567  *           QUEUE_IncTimerCount
 568  */
 569 void QUEUE_IncTimerCount( HQUEUE16 hQueue )
 570 {
 571     MESSAGEQUEUE *queue;
 572
 573     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( hQueue ))) return;
 574     queue->wTimerCount++;
 575     QUEUE_SetWakeBit( queue, QS_TIMER );
 576 }
 577
 578
 579 /***********************************************************************
 580  *           QUEUE_DecTimerCount
 581  */
 582 void QUEUE_DecTimerCount( HQUEUE16 hQueue )
 583 {
 584     MESSAGEQUEUE *queue;
 585
 586     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( hQueue ))) return;
 587     queue->wTimerCount--;
 588     if (!queue->wTimerCount) queue->wakeBits &= ~QS_TIMER;
 589 }
 590
 591
 592 /***********************************************************************
 593  *           PostQuitMessage   (USER.6)
 594  */
 595 void PostQuitMessage( INT exitCode )
 596 {
 597     MESSAGEQUEUE *queue;
 598
 599     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return;
 600     queue->wPostQMsg = TRUE;
 601     queue->wExitCode = (WORD)exitCode;
 602 }
 603
 604
 605 /***********************************************************************
 606  *           GetWindowTask16   (USER.224)
 607  */
 608 HTASK16 GetWindowTask16( HWND16 hwnd )
 609 {
 610     WND *wndPtr = WIN_FindWndPtr( hwnd );
 611
 612     if (!wndPtr) return 0;
 613     return QUEUE_GetQueueTask( wndPtr->hmemTaskQ );
 614 }
 615
 616
 617 /***********************************************************************
 618  *           SetMessageQueue   (USER.266)
 619  */
 620 BOOL SetMessageQueue( int size )
 621 {
 622     HQUEUE16 hQueue, hNewQueue;
 623     MESSAGEQUEUE *queuePtr;
 624
 625     dprintf_msg(stddeb,"SetMessageQueue: task %04x size %i\n", GetCurrentTask(), size);
 626
 627     if ((size > MAX_QUEUE_SIZE) || (size <= 0)) return TRUE;
 628
 629     if( !(hNewQueue = QUEUE_CreateMsgQueue( size )))
 630     {
 631         dprintf_msg(stddeb,"SetMessageQueue: failed!\n");
 632         return FALSE;
 633     }
 634     queuePtr = (MESSAGEQUEUE *)GlobalLock16( hNewQueue );
 635
 636     /* Copy data and free the old message queue */
 637     if ((hQueue = GetTaskQueue(0)) != 0)
 638     {
 639        MESSAGEQUEUE *oldQ = (MESSAGEQUEUE *)GlobalLock16( hQueue );
 640        memcpy( &queuePtr->reserved2, &oldQ->reserved2,
 641                         (int)oldQ->messages - (int)(&oldQ->reserved2) );
 642        QUEUE_DeleteMsgQueue( hQueue );
 643     }
 644
 645     /* Link new queue into list */
 646     queuePtr->hTask = GetCurrentTask();
 647     queuePtr->next  = hFirstQueue;
 648     hFirstQueue = hNewQueue;
 649
 650     if( !queuePtr->next ) pCursorQueue = queuePtr;
 651
 652     SetTaskQueue( 0, hNewQueue );
 653     return TRUE;
 654 }
 655
 656
 657 /***********************************************************************
 658  *           GetQueueStatus   (USER.334)
 659  */
 660 DWORD GetQueueStatus( UINT flags )
 661 {
 662     MESSAGEQUEUE *queue;
 663     DWORD ret;
 664
 665     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 666     ret = MAKELONG( queue->changeBits, queue->wakeBits );
 667     queue->changeBits = 0;
 668     return ret & MAKELONG( flags, flags );
 669 }
 670
 671
 672 /***********************************************************************
 673  *           GetInputState   (USER.335)
 674  */
 675 BOOL GetInputState()
 676 {
 677     MESSAGEQUEUE *queue;
 678
 679     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return FALSE;
 680     return queue->wakeBits & (QS_KEY | QS_MOUSEBUTTON);
 681 }
 682
 683
 684 /***********************************************************************
 685  *           GetMessagePos   (USER.119)
 686  */
 687 DWORD GetMessagePos(void)
 688 {
 689     MESSAGEQUEUE *queue;
 690
 691     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 692     return queue->GetMessagePosVal;
 693 }
 694
 695
 696 /***********************************************************************
 697  *           GetMessageTime   (USER.120)
 698  */
 699 LONG GetMessageTime(void)
 700 {
 701     MESSAGEQUEUE *queue;
 702
 703     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 704     return queue->GetMessageTimeVal;
 705 }
 706
 707
 708 /***********************************************************************
 709  *           GetMessageExtraInfo   (USER.288)
 710  */
 711 LONG GetMessageExtraInfo(void)
 712 {
 713     MESSAGEQUEUE *queue;
 714
 715     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 716     return queue->GetMessageExtraInfoVal;
 717 }