windows/message.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <sys/time.h>
   9 #include <sys/types.h>
  10 #include <errno.h>
  11
  12 #include "message.h"
  13 #include "win.h"
  14 #include "gdi.h"
  15 #include "sysmetrics.h"
  16 #include "hook.h"
  17 #include "event.h"
  18 #include "spy.h"
  19 #include "winpos.h"
  20 #include "atom.h"
  21 #include "dde.h"
  22 #include "stddebug.h"
  23 /* #define DEBUG_MSG */
  24 #include "debug.h"
  25
  26
  27 #define HWND_BROADCAST  ((HWND)0xffff)
  28
  29 #define MAX_QUEUE_SIZE   120  /* Max. size of a message queue */
  30
  31
  32 extern BOOL TIMER_CheckTimer( LONG *next, MSG *msg,
  33                               HWND hwnd, BOOL remove );  /* timer.c */
  34
  35   /* System message queue (for hardware events) */
  36 static HANDLE hmemSysMsgQueue = 0;
  37 static MESSAGEQUEUE * sysMsgQueue = NULL;
  38
  39   /* Double-click time */
  40 static int doubleClickSpeed = 452;
  41
  42
  43 /***********************************************************************
  44  *           MSG_CreateMsgQueue
  45  *
  46  * Create a message queue.
  47  */
  48 static HANDLE MSG_CreateMsgQueue( int size )
  49 {
  50     HANDLE hQueue;
  51     MESSAGEQUEUE * msgQueue;
  52     int queueSize;
  53
  54     queueSize = sizeof(MESSAGEQUEUE) + size * sizeof(QMSG);
  55     if (!(hQueue = GlobalAlloc( GMEM_FIXED | GMEM_ZEROINIT, queueSize )))
  56         return 0;
  57     msgQueue = (MESSAGEQUEUE *) GlobalLock( hQueue );
  58     msgQueue->msgSize = sizeof(QMSG);
  59     msgQueue->queueSize = size;
  60     msgQueue->wWinVersion = 0;  /* FIXME? */
  61     GlobalUnlock( hQueue );
  62     return hQueue;
  63 }
  64
  65
  66 /***********************************************************************
  67  *           MSG_CreateSysMsgQueue
  68  *
  69  * Create the system message queue, and set the double-click speed.
  70  * Must be called only once.
  71  */
  72 BOOL MSG_CreateSysMsgQueue( int size )
  73 {
  74     if (size > MAX_QUEUE_SIZE) size = MAX_QUEUE_SIZE;
  75     else if (size <= 0) size = 1;
  76     if (!(hmemSysMsgQueue = MSG_CreateMsgQueue( size ))) return FALSE;
  77     sysMsgQueue = (MESSAGEQUEUE *) GlobalLock( hmemSysMsgQueue );
  78     doubleClickSpeed = GetProfileInt( "windows", "DoubleClickSpeed", 452 );
  79     return TRUE;
  80 }
  81
  82
  83 /***********************************************************************
  84  *           MSG_AddMsg
  85  *
  86  * Add a message to the queue. Return FALSE if queue is full.
  87  */
  88 static int MSG_AddMsg( HANDLE hQueue, MSG * msg, DWORD extraInfo )
  89 {
  90     int pos;
  91     MESSAGEQUEUE *msgQueue;
  92
  93     if (!(msgQueue = (MESSAGEQUEUE *)GlobalLock( hQueue ))) return FALSE;
  94     pos = msgQueue->nextFreeMessage;
  95
  96       /* Check if queue is full */
  97     if ((pos == msgQueue->nextMessage) && (msgQueue->msgCount > 0)) {
  98                 fprintf(stderr,"MSG_AddMsg // queue is full !\n");
  99                 return FALSE;
 100                 }
 101
 102       /* Store message */
 103     msgQueue->messages[pos].msg = *msg;
 104     msgQueue->messages[pos].extraInfo = extraInfo;
 105     if (pos < msgQueue->queueSize-1) pos++;
 106     else pos = 0;
 107     msgQueue->nextFreeMessage = pos;
 108     msgQueue->msgCount++;
 109     msgQueue->status |= QS_POSTMESSAGE;
 110     msgQueue->tempStatus |= QS_POSTMESSAGE;
 111     return TRUE;
 112 }
 113
 114
 115 /***********************************************************************
 116  *           MSG_FindMsg
 117  *
 118  * Find a message matching the given parameters. Return -1 if none available.
 119  */
 120 static int MSG_FindMsg(MESSAGEQUEUE * msgQueue, HWND hwnd, int first, int last)
 121 {
 122     int i, pos = msgQueue->nextMessage;
 123
 124     dprintf_msg(stddeb,"MSG_FindMsg: hwnd=0x"NPFMT"\n\n", hwnd );
 125
 126     if (!msgQueue->msgCount) return -1;
 127     if (!hwnd && !first && !last) return pos;
 128
 129     for (i = 0; i < msgQueue->msgCount; i++)
 130     {
 131         MSG * msg = &msgQueue->messages[pos].msg;
 132
 133         if (!hwnd || (msg->hwnd == hwnd))
 134         {
 135             if (!first && !last) return pos;
 136             if ((msg->message >= first) && (msg->message <= last)) return pos;
 137         }
 138         if (pos < msgQueue->queueSize-1) pos++;
 139         else pos = 0;
 140     }
 141     return -1;
 142 }
 143
 144
 145 /***********************************************************************
 146  *           MSG_RemoveMsg
 147  *
 148  * Remove a message from the queue (pos must be a valid position).
 149  */
 150 static void MSG_RemoveMsg( MESSAGEQUEUE * msgQueue, int pos )
 151 {
 152     if (pos >= msgQueue->nextMessage)
 153     {
 154         for ( ; pos > msgQueue->nextMessage; pos--)
 155             msgQueue->messages[pos] = msgQueue->messages[pos-1];
 156         msgQueue->nextMessage++;
 157         if (msgQueue->nextMessage >= msgQueue->queueSize)
 158             msgQueue->nextMessage = 0;
 159     }
 160     else
 161     {
 162         for ( ; pos < msgQueue->nextFreeMessage; pos++)
 163             msgQueue->messages[pos] = msgQueue->messages[pos+1];
 164         if (msgQueue->nextFreeMessage) msgQueue->nextFreeMessage--;
 165         else msgQueue->nextFreeMessage = msgQueue->queueSize-1;
 166     }
 167     msgQueue->msgCount--;
 168     if (!msgQueue->msgCount) msgQueue->status &= ~QS_POSTMESSAGE;
 169     msgQueue->tempStatus = 0;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           MSG_GetWindowForEvent
 175  *
 176  * Find the window and hittest for a mouse event.
 177  */
 178 static INT MSG_GetWindowForEvent( POINT pt, HWND *phwnd )
 179 {
 180     WND *wndPtr;
 181     HWND hwnd;
 182     INT hittest = HTERROR;
 183     INT x, y;
 184
 185     *phwnd = hwnd = GetDesktopWindow();
 186     x = pt.x;
 187     y = pt.y;
 188     while (hwnd)
 189     {
 190           /* If point is in window, and window is visible, and it  */
 191           /* is enabled (or it's a top-level window), then explore */
 192           /* its children. Otherwise, go to the next window.       */
 193
 194         wndPtr = WIN_FindWndPtr( hwnd );
 195         if ((wndPtr->dwStyle & WS_VISIBLE) &&
 196             (!(wndPtr->dwStyle & WS_DISABLED) ||
 197              !(wndPtr->dwStyle & WS_CHILD)) &&
 198             (x >= wndPtr->rectWindow.left) &&
 199             (x < wndPtr->rectWindow.right) &&
 200             (y >= wndPtr->rectWindow.top) &&
 201             (y < wndPtr->rectWindow.bottom))
 202         {
 203             *phwnd = hwnd;
 204             x -= wndPtr->rectClient.left;
 205             y -= wndPtr->rectClient.top;
 206               /* If window is minimized or disabled, ignore its children */
 207             if ((wndPtr->dwStyle & WS_MINIMIZE) ||
 208                 (wndPtr->dwStyle & WS_DISABLED)) break;
 209             hwnd = wndPtr->hwndChild;
 210         }
 211         else hwnd = wndPtr->hwndNext;
 212     }
 213
 214     /* Make point relative to parent again */
 215
 216     wndPtr = WIN_FindWndPtr( *phwnd );
 217     x += wndPtr->rectClient.left;
 218     y += wndPtr->rectClient.top;
 219
 220     /* Send the WM_NCHITTEST message */
 221
 222     while (*phwnd)
 223     {
 224         wndPtr = WIN_FindWndPtr( *phwnd );
 225         if (wndPtr->dwStyle & WS_DISABLED) hittest = HTERROR;
 226         else hittest = (INT)SendMessage( *phwnd, WM_NCHITTEST, 0,
 227                                          MAKELONG( pt.x, pt.y ) );
 228         if (hittest != HTTRANSPARENT) break;  /* Found the window */
 229         hwnd = wndPtr->hwndNext;
 230         while (hwnd)
 231         {
 232             WND *nextPtr = WIN_FindWndPtr( hwnd );
 233             if ((nextPtr->dwStyle & WS_VISIBLE) &&
 234                 (x >= nextPtr->rectWindow.left) &&
 235                 (x < nextPtr->rectWindow.right) &&
 236                 (y >= nextPtr->rectWindow.top) &&
 237                 (y < nextPtr->rectWindow.bottom)) break;
 238             hwnd = nextPtr->hwndNext;
 239         }
 240         if (hwnd) *phwnd = hwnd; /* Found a suitable sibling */
 241         else  /* Go back to the parent */
 242         {
 243             if (!(*phwnd = wndPtr->hwndParent)) break;
 244             wndPtr = WIN_FindWndPtr( *phwnd );
 245             x += wndPtr->rectClient.left;
 246             y += wndPtr->rectClient.top;
 247         }
 248     }
 249
 250     if (!*phwnd) *phwnd = GetDesktopWindow();
 251     return hittest;
 252 }
 253
 254
 255 /***********************************************************************
 256  *           MSG_TranslateMouseMsg
 257  *
 258  * Translate an mouse hardware event into a real mouse message.
 259  * Return value indicates whether the translated message must be passed
 260  * to the user.
 261  * Actions performed:
 262  * - Find the window for this message.
 263  * - Translate button-down messages in double-clicks.
 264  * - Send the WM_NCHITTEST message to find where the cursor is.
 265  * - Activate the window if needed.
 266  * - Translate the message into a non-client message, or translate
 267  *   the coordinates to client coordinates.
 268  * - Send the WM_SETCURSOR message.
 269  */
 270 static BOOL MSG_TranslateMouseMsg( MSG *msg, BOOL remove )
 271 {
 272     BOOL eatMsg = FALSE;
 273     INT hittest;
 274     static DWORD lastClickTime = 0;
 275     static WORD  lastClickMsg = 0;
 276     static POINT lastClickPos = { 0, 0 };
 277     POINT pt = msg->pt;
 278     MOUSEHOOKSTRUCT hook = { msg->pt, 0, HTCLIENT, 0 };
 279
 280     BOOL mouseClick = ((msg->message == WM_LBUTTONDOWN) ||
 281                        (msg->message == WM_RBUTTONDOWN) ||
 282                        (msg->message == WM_MBUTTONDOWN));
 283
 284       /* Find the window */
 285
 286     if (GetCapture())
 287     {
 288         msg->hwnd = GetCapture();
 289         ScreenToClient( msg->hwnd, &pt );
 290         msg->lParam = MAKELONG( pt.x, pt.y );
 291         /* No need to further process the message */
 292         hook.hwnd = msg->hwnd;
 293         return !HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
 294                                 msg->message, (LPARAM)MAKE_SEGPTR(&hook));
 295     }
 296
 297     if ((hittest = MSG_GetWindowForEvent( msg->pt, &msg->hwnd )) != HTERROR)
 298     {
 299
 300         /* Send the WM_PARENTNOTIFY message */
 301
 302         if (mouseClick) WIN_SendParentNotify( msg->hwnd, msg->message, 0,
 303                                             MAKELONG( msg->pt.x, msg->pt.y ) );
 304
 305         /* Activate the window if needed */
 306
 307         if (mouseClick)
 308         {
 309             HWND hwndTop = WIN_GetTopParent( msg->hwnd );
 310             if (hwndTop != GetActiveWindow())
 311             {
 312                 LONG ret = SendMessage( msg->hwnd, WM_MOUSEACTIVATE,
 313                                         (WPARAM)hwndTop,
 314                                         MAKELONG( hittest, msg->message ) );
 315                 if ((ret == MA_ACTIVATEANDEAT) || (ret == MA_NOACTIVATEANDEAT))
 316                     eatMsg = TRUE;
 317                 if ((ret == MA_ACTIVATE) || (ret == MA_ACTIVATEANDEAT))
 318                 {
 319                     SetWindowPos( hwndTop, HWND_TOP, 0, 0, 0, 0,
 320                                  SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
 321                     WINPOS_ChangeActiveWindow( hwndTop, TRUE );
 322                 }
 323             }
 324         }
 325     }
 326
 327       /* Send the WM_SETCURSOR message */
 328
 329     SendMessage( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
 330                  MAKELONG( hittest, msg->message ));
 331     if (eatMsg) return FALSE;
 332
 333       /* Check for double-click */
 334
 335     if (mouseClick)
 336     {
 337         BOOL dbl_click = FALSE;
 338
 339         if ((msg->message == lastClickMsg) &&
 340             (msg->time - lastClickTime < doubleClickSpeed) &&
 341             (abs(msg->pt.x - lastClickPos.x) < SYSMETRICS_CXDOUBLECLK/2) &&
 342             (abs(msg->pt.y - lastClickPos.y) < SYSMETRICS_CYDOUBLECLK/2))
 343             dbl_click = TRUE;
 344
 345         if (dbl_click && (hittest == HTCLIENT))
 346         {
 347             /* Check whether window wants the double click message. */
 348             WND * wndPtr = WIN_FindWndPtr( msg->hwnd );
 349             if (!wndPtr || !(WIN_CLASS_STYLE(wndPtr) & CS_DBLCLKS))
 350                 dbl_click = FALSE;
 351         }
 352
 353         if (dbl_click) switch(msg->message)
 354         {
 355             case WM_LBUTTONDOWN: msg->message = WM_LBUTTONDBLCLK; break;
 356             case WM_RBUTTONDOWN: msg->message = WM_RBUTTONDBLCLK; break;
 357             case WM_MBUTTONDOWN: msg->message = WM_MBUTTONDBLCLK; break;
 358         }
 359
 360         if (remove)
 361         {
 362             lastClickTime = msg->time;
 363             lastClickMsg  = msg->message;
 364             lastClickPos  = msg->pt;
 365         }
 366     }
 367
 368       /* Build the translated message */
 369
 370     if (hittest == HTCLIENT)
 371         ScreenToClient( msg->hwnd, &pt );
 372     else
 373     {
 374         msg->wParam = hittest;
 375         msg->message += WM_NCLBUTTONDOWN - WM_LBUTTONDOWN;
 376     }
 377     msg->lParam = MAKELONG( pt.x, pt.y );
 378
 379     hook.hwnd = msg->hwnd;
 380     hook.wHitTestCode = hittest;
 381     return !HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
 382                             msg->message, (LPARAM)MAKE_SEGPTR(&hook));
 383 }
 384
 385
 386 /***********************************************************************
 387  *           MSG_TranslateKeyboardMsg
 388  *
 389  * Translate an keyboard hardware event into a real message.
 390  * Return value indicates whether the translated message must be passed
 391  * to the user.
 392  */
 393 static BOOL MSG_TranslateKeyboardMsg( MSG *msg, BOOL remove )
 394 {
 395       /* Should check Ctrl-Esc and PrintScreen here */
 396
 397     msg->hwnd = GetFocus();
 398     if (!msg->hwnd)
 399     {
 400           /* Send the message to the active window instead,  */
 401           /* translating messages to their WM_SYS equivalent */
 402         msg->hwnd = GetActiveWindow();
 403         msg->message += WM_SYSKEYDOWN - WM_KEYDOWN;
 404     }
 405     return !HOOK_CallHooks( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
 406                             msg->wParam, msg->lParam );
 407 }
 408
 409
 410 /***********************************************************************
 411  *           MSG_PeekHardwareMsg
 412  *
 413  * Peek for a hardware message matching the hwnd and message filters.
 414  */
 415 static BOOL MSG_PeekHardwareMsg( MSG *msg, HWND hwnd, WORD first, WORD last,
 416                                  BOOL remove )
 417 {
 418     int i, pos = sysMsgQueue->nextMessage;
 419
 420     for (i = 0; i < sysMsgQueue->msgCount; i++, pos++)
 421     {
 422         if (pos >= sysMsgQueue->queueSize) pos = 0;
 423         *msg = sysMsgQueue->messages[pos].msg;
 424
 425           /* Translate message */
 426
 427         if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
 428         {
 429             if (!MSG_TranslateMouseMsg( msg, remove )) continue;
 430         }
 431         else if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
 432         {
 433             if (!MSG_TranslateKeyboardMsg( msg, remove )) continue;
 434         }
 435         else  /* Non-standard hardware event */
 436         {
 437             HARDWAREHOOKSTRUCT hook = { msg->hwnd, msg->message,
 438                                         msg->wParam, msg->lParam };
 439             if (HOOK_CallHooks( WH_HARDWARE, remove ? HC_ACTION : HC_NOREMOVE,
 440                                 0, (LPARAM)MAKE_SEGPTR(&hook) )) continue;
 441         }
 442
 443           /* Check message against filters */
 444
 445         if (hwnd && (msg->hwnd != hwnd)) continue;
 446         if ((first || last) &&
 447             ((msg->message < first) || (msg->message > last))) continue;
 448         if ((msg->hwnd != GetDesktopWindow()) &&
 449             (GetWindowTask(msg->hwnd) != GetCurrentTask()))
 450             continue;  /* Not for this task */
 451         if (remove)
 452         {
 453             MSG tmpMsg = *msg; /* FIXME */
 454             HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION,
 455                             0, (LPARAM)MAKE_SEGPTR(&tmpMsg) );
 456             MSG_RemoveMsg( sysMsgQueue, pos );
 457         }
 458         return TRUE;
 459     }
 460     return FALSE;
 461 }
 462
 463
 464 /**********************************************************************
 465  *              SetDoubleClickTime  (USER.20)
 466  */
 467 void SetDoubleClickTime( WORD interval )
 468 {
 469     if (interval == 0)
 470         doubleClickSpeed = 500;
 471     else
 472         doubleClickSpeed = interval;
 473 }
 474
 475
 476 /**********************************************************************
 477  *              GetDoubleClickTime  (USER.21)
 478  */
 479 WORD GetDoubleClickTime()
 480 {
 481         return (WORD)doubleClickSpeed;
 482 }
 483
 484
 485 /***********************************************************************
 486  *           MSG_IncPaintCount
 487  */
 488 void MSG_IncPaintCount( HANDLE hQueue )
 489 {
 490     MESSAGEQUEUE *queue;
 491
 492     if (!(queue = (MESSAGEQUEUE *)GlobalLock( hQueue ))) return;
 493     queue->wPaintCount++;
 494     queue->status |= QS_PAINT;
 495     queue->tempStatus |= QS_PAINT;
 496 }
 497
 498
 499 /***********************************************************************
 500  *           MSG_DecPaintCount
 501  */
 502 void MSG_DecPaintCount( HANDLE hQueue )
 503 {
 504     MESSAGEQUEUE *queue;
 505
 506     if (!(queue = (MESSAGEQUEUE *)GlobalLock( hQueue ))) return;
 507     queue->wPaintCount--;
 508     if (!queue->wPaintCount) queue->status &= ~QS_PAINT;
 509 }
 510
 511
 512 /***********************************************************************
 513  *           MSG_IncTimerCount
 514  */
 515 void MSG_IncTimerCount( HANDLE hQueue )
 516 {
 517     MESSAGEQUEUE *queue;
 518
 519     if (!(queue = (MESSAGEQUEUE *)GlobalLock( hQueue ))) return;
 520     queue->wTimerCount++;
 521     queue->status |= QS_TIMER;
 522     queue->tempStatus |= QS_TIMER;
 523 }
 524
 525
 526 /***********************************************************************
 527  *           MSG_DecTimerCount
 528  */
 529 void MSG_DecTimerCount( HANDLE hQueue )
 530 {
 531     MESSAGEQUEUE *queue;
 532
 533     if (!(queue = (MESSAGEQUEUE *)GlobalLock( hQueue ))) return;
 534     queue->wTimerCount--;
 535     if (!queue->wTimerCount) queue->status &= ~QS_TIMER;
 536 }
 537
 538
 539 /***********************************************************************
 540  *           hardware_event
 541  *
 542  * Add an event to the system message queue.
 543  * Note: the position is relative to the desktop window.
 544  */
 545 void hardware_event( WORD message, WORD wParam, LONG lParam,
 546                      int xPos, int yPos, DWORD time, DWORD extraInfo )
 547 {
 548     MSG *msg;
 549     int pos;
 550
 551     if (!sysMsgQueue) return;
 552     pos = sysMsgQueue->nextFreeMessage;
 553
 554       /* Merge with previous event if possible */
 555
 556     if ((message == WM_MOUSEMOVE) && sysMsgQueue->msgCount)
 557     {
 558         if (pos > 0) pos--;
 559         else pos = sysMsgQueue->queueSize - 1;
 560         msg = &sysMsgQueue->messages[pos].msg;
 561         if ((msg->message == message) && (msg->wParam == wParam))
 562             sysMsgQueue->msgCount--;  /* Merge events */
 563         else
 564             pos = sysMsgQueue->nextFreeMessage;  /* Don't merge */
 565     }
 566
 567       /* Check if queue is full */
 568
 569     if ((pos == sysMsgQueue->nextMessage) && sysMsgQueue->msgCount)
 570     {
 571         /* Queue is full, beep (but not on every mouse motion...) */
 572         if (message != WM_MOUSEMOVE) MessageBeep(0);
 573         return;
 574     }
 575
 576       /* Store message */
 577
 578     msg = &sysMsgQueue->messages[pos].msg;
 579     msg->hwnd    = 0;
 580     msg->message = message;
 581     msg->wParam  = wParam;
 582     msg->lParam  = lParam;
 583     msg->time    = time;
 584     msg->pt.x    = xPos & 0xffff;
 585     msg->pt.y    = yPos & 0xffff;
 586     sysMsgQueue->messages[pos].extraInfo = extraInfo;
 587     if (pos < sysMsgQueue->queueSize - 1) pos++;
 588     else pos = 0;
 589     sysMsgQueue->nextFreeMessage = pos;
 590     sysMsgQueue->msgCount++;
 591 }
 592
 593
 594 /***********************************************************************
 595  *           MSG_GetHardwareMessage
 596  *
 597  * Like GetMessage(), but only return mouse and keyboard events.
 598  * Used internally for window moving and resizing. Mouse messages
 599  * are not translated.
 600  * Warning: msg->hwnd is always 0.
 601  */
 602 BOOL MSG_GetHardwareMessage( LPMSG msg )
 603 {
 604     int pos;
 605     XEvent event;
 606
 607     while(1)
 608     {
 609         if ((pos = MSG_FindMsg( sysMsgQueue, 0, 0, 0 )) != -1)
 610         {
 611             *msg = sysMsgQueue->messages[pos].msg;
 612             MSG_RemoveMsg( sysMsgQueue, pos );
 613             break;
 614         }
 615         XNextEvent( display, &event );
 616         EVENT_ProcessEvent( &event );
 617     }
 618     return TRUE;
 619 }
 620
 621
 622 /***********************************************************************
 623  *           SetMessageQueue  (USER.266)
 624  */
 625 BOOL SetMessageQueue( int size )
 626 {
 627     HGLOBAL hQueue;
 628     MESSAGEQUEUE *queuePtr;
 629
 630     if ((size > MAX_QUEUE_SIZE) || (size <= 0)) return TRUE;
 631
 632       /* Free the old message queue */
 633     if ((hQueue = GetTaskQueue(0)) != 0)
 634     {
 635         GlobalUnlock( hQueue );
 636         GlobalFree( hQueue );
 637     }
 638
 639     if (!(hQueue = MSG_CreateMsgQueue( size ))) return FALSE;
 640     queuePtr = (MESSAGEQUEUE *)GlobalLock( hQueue );
 641     queuePtr->hTask = GetCurrentTask();
 642     SetTaskQueue( 0, hQueue );
 643     return TRUE;
 644 }
 645
 646
 647 /***********************************************************************
 648  *           GetWindowTask  (USER.224)
 649  */
 650 HTASK GetWindowTask( HWND hwnd )
 651 {
 652     WND *wndPtr = WIN_FindWndPtr( hwnd );
 653     MESSAGEQUEUE *queuePtr;
 654
 655     if (!wndPtr) return 0;
 656     queuePtr = (MESSAGEQUEUE *)GlobalLock( wndPtr->hmemTaskQ );
 657     if (!queuePtr) return 0;
 658     return queuePtr->hTask;
 659 }
 660
 661
 662 /***********************************************************************
 663  *           PostQuitMessage   (USER.6)
 664  */
 665 void PostQuitMessage( int exitCode )
 666 {
 667     MESSAGEQUEUE *queue;
 668
 669     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return;
 670     queue->wPostQMsg = TRUE;
 671     queue->wExitCode = exitCode;
 672 }
 673
 674
 675 /***********************************************************************
 676  *           GetQueueStatus   (USER.334)
 677  */
 678 DWORD GetQueueStatus( int flags )
 679 {
 680     MESSAGEQUEUE *queue;
 681     DWORD ret;
 682
 683     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return 0;
 684     ret = MAKELONG( queue->tempStatus, queue->status );
 685     queue->tempStatus = 0;
 686     return ret & MAKELONG( flags, flags );
 687 }
 688
 689
 690 /***********************************************************************
 691  *           GetInputState   (USER.335)
 692  */
 693 BOOL GetInputState()
 694 {
 695     MESSAGEQUEUE *queue;
 696
 697     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return FALSE;
 698     return queue->status & (QS_KEY | QS_MOUSEBUTTON);
 699 }
 700
 701
 702 /***********************************************************************
 703  *           MSG_Synchronize
 704  *
 705  * Synchronize with the X server. Should not be used too often.
 706  */
 707 void MSG_Synchronize()
 708 {
 709     XEvent event;
 710
 711     XSync( display, False );
 712     while (XPending( display ))
 713     {
 714         XNextEvent( display, &event );
 715         EVENT_ProcessEvent( &event );
 716     }
 717 }
 718
 719
 720 /***********************************************************************
 721  *           MSG_WaitXEvent
 722  *
 723  * Wait for an X event, but at most maxWait milliseconds (-1 for no timeout).
 724  * Return TRUE if an event is pending, FALSE on timeout or error
 725  * (for instance lost connection with the server).
 726  */
 727 BOOL MSG_WaitXEvent( LONG maxWait )
 728 {
 729     fd_set read_set;
 730     struct timeval timeout;
 731     XEvent event;
 732     int fd = ConnectionNumber(display);
 733
 734     if (!XPending(display) && (maxWait != -1))
 735     {
 736         FD_ZERO( &read_set );
 737         FD_SET( fd, &read_set );
 738
 739         timeout.tv_usec = (maxWait % 1000) * 1000;
 740         timeout.tv_sec = maxWait / 1000;
 741
 742 #ifdef CONFIG_IPC
 743         sigsetjmp(env_wait_x, 1);
 744         stop_wait_op= CONT;
 745
 746         if (DDE_GetRemoteMessage()) {
 747             while(DDE_GetRemoteMessage())
 748                 ;
 749             return TRUE;
 750         }
 751         stop_wait_op= STOP_WAIT_X;
 752         /* The code up to the next "stop_wait_op= CONT" must be reentrant  */
 753         if (select( fd+1, &read_set, NULL, NULL, &timeout ) != 1 &&
 754             !XPending(display)) {
 755             stop_wait_op= CONT;
 756             return FALSE;
 757         } else {
 758             stop_wait_op= CONT;
 759         }
 760 #else  /* CONFIG_IPC */
 761         if (select( fd+1, &read_set, NULL, NULL, &timeout ) != 1)
 762             return FALSE;  /* Timeout or error */
 763 #endif  /* CONFIG_IPC */
 764
 765     }
 766
 767     /* Process the event (and possibly others that occurred in the meantime) */
 768     do
 769     {
 770
 771 #ifdef CONFIG_IPC
 772         if (DDE_GetRemoteMessage())
 773         {
 774             while(DDE_GetRemoteMessage()) ;
 775             return TRUE;
 776         }
 777 #endif  /* CONFIG_IPC */
 778
 779         XNextEvent( display, &event );
 780         EVENT_ProcessEvent( &event );
 781     }
 782     while (XPending( display ));
 783     return TRUE;
 784 }
 785
 786
 787 /***********************************************************************
 788  *           MSG_PeekMessage
 789  */
 790 static BOOL MSG_PeekMessage( LPMSG msg, HWND hwnd, WORD first, WORD last,
 791                              WORD flags, BOOL peek )
 792 {
 793     int pos, mask;
 794     MESSAGEQUEUE *msgQueue;
 795     LONG nextExp;  /* Next timer expiration time */
 796
 797 #ifdef CONFIG_IPC
 798     DDE_TestDDE(hwnd);  /* do we have dde handling in the window ?*/
 799     DDE_GetRemoteMessage();
 800 #endif  /* CONFIG_IPC */
 801
 802     if (first || last)
 803     {
 804         mask = QS_POSTMESSAGE;  /* Always selectioned */
 805         if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
 806         if ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) mask |= QS_MOUSE;
 807         if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
 808         if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
 809         if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
 810     }
 811     else mask = QS_MOUSE | QS_KEY | QS_POSTMESSAGE | QS_TIMER | QS_PAINT;
 812
 813     while(1)
 814     {
 815         msgQueue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) );
 816         if (!msgQueue) return FALSE;
 817
 818           /* First handle a message put by SendMessage() */
 819         if (msgQueue->status & QS_SENDMESSAGE)
 820         {
 821             if (!hwnd || (msgQueue->hWnd == hwnd))
 822             {
 823                 if ((!first && !last) ||
 824                     ((msgQueue->msg >= first) && (msgQueue->msg <= last)))
 825                 {
 826                     msg->hwnd    = msgQueue->hWnd;
 827                     msg->message = msgQueue->msg;
 828                     msg->wParam  = msgQueue->wParam;
 829                     msg->lParam  = msgQueue->lParam;
 830                     if (flags & PM_REMOVE) msgQueue->status &= ~QS_SENDMESSAGE;
 831                     break;
 832                 }
 833             }
 834         }
 835
 836           /* Now find a normal message */
 837         pos = MSG_FindMsg( msgQueue, hwnd, first, last );
 838         if (pos != -1)
 839         {
 840             QMSG *qmsg = &msgQueue->messages[pos];
 841             *msg = qmsg->msg;
 842             msgQueue->GetMessageTimeVal      = msg->time;
 843             msgQueue->GetMessagePosVal       = *(DWORD *)&msg->pt;
 844             msgQueue->GetMessageExtraInfoVal = qmsg->extraInfo;
 845
 846             if (flags & PM_REMOVE) MSG_RemoveMsg( msgQueue, pos );
 847             break;
 848         }
 849
 850           /* Now find a hardware event */
 851         if (MSG_PeekHardwareMsg( msg, hwnd, first, last, flags & PM_REMOVE ))
 852         {
 853             /* Got one */
 854             msgQueue->GetMessageTimeVal      = msg->time;
 855             msgQueue->GetMessagePosVal       = *(DWORD *)&msg->pt;
 856             msgQueue->GetMessageExtraInfoVal = 0;  /* Always 0 for now */
 857             break;
 858         }
 859
 860           /* Now handle a WM_QUIT message */
 861         if (msgQueue->wPostQMsg)
 862         {
 863             msg->hwnd    = hwnd;
 864             msg->message = WM_QUIT;
 865             msg->wParam  = msgQueue->wExitCode;
 866             msg->lParam  = 0;
 867             break;
 868         }
 869
 870           /* Now find a WM_PAINT message */
 871         if ((msgQueue->status & QS_PAINT) && (mask & QS_PAINT))
 872         {
 873             msg->hwnd = WIN_FindWinToRepaint( hwnd );
 874             msg->message = WM_PAINT;
 875             msg->wParam = 0;
 876             msg->lParam = 0;
 877             if (msg->hwnd != 0) break;
 878         }
 879
 880           /* Finally handle WM_TIMER messages */
 881         if ((msgQueue->status & QS_TIMER) && (mask & QS_TIMER))
 882         {
 883             if (TIMER_CheckTimer( &nextExp, msg, hwnd, flags & PM_REMOVE ))
 884                 break;  /* Got a timer msg */
 885         }
 886         else nextExp = -1;  /* No timeout needed */
 887
 888         Yield();
 889
 890           /* Wait until something happens */
 891         if (peek)
 892         {
 893             if (!MSG_WaitXEvent( 0 )) return FALSE;  /* No pending event */
 894         }
 895         else  /* Wait for an event, then restart the loop */
 896             MSG_WaitXEvent( nextExp );
 897     }
 898
 899       /* We got a message */
 900     if (peek) return TRUE;
 901     else return (msg->message != WM_QUIT);
 902 }
 903
 904
 905 /***********************************************************************
 906  *           MSG_InternalGetMessage
 907  *
 908  * GetMessage() function for internal use. Behave like GetMessage(),
 909  * but also call message filters and optionally send WM_ENTERIDLE messages.
 910  * 'hwnd' must be the handle of the dialog or menu window.
 911  * 'code' is the message filter value (MSGF_??? codes).
 912  */
 913 BOOL MSG_InternalGetMessage( SEGPTR msg, HWND hwnd, HWND hwndOwner, short code,
 914                              WORD flags, BOOL sendIdle )
 915 {
 916     for (;;)
 917     {
 918         if (sendIdle)
 919         {
 920             if (!MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 921                                   0, 0, 0, flags, TRUE ))
 922             {
 923                   /* No message present -> send ENTERIDLE and wait */
 924                 SendMessage( hwndOwner, WM_ENTERIDLE, code, (LPARAM)hwnd );
 925                 MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 926                                  0, 0, 0, flags, FALSE );
 927             }
 928         }
 929         else  /* Always wait for a message */
 930             MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 931                              0, 0, 0, flags, FALSE );
 932
 933         if (!CallMsgFilter( msg, code ))
 934             return (((MSG *)PTR_SEG_TO_LIN(msg))->message != WM_QUIT);
 935
 936           /* Message filtered -> remove it from the queue */
 937           /* if it's still there. */
 938         if (!(flags & PM_REMOVE))
 939             MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 940                              0, 0, 0, PM_REMOVE, TRUE );
 941     }
 942 }
 943
 944
 945 /***********************************************************************
 946  *           PeekMessage   (USER.109)
 947  */
 948 BOOL PeekMessage( LPMSG msg, HWND hwnd, WORD first, WORD last, WORD flags )
 949 {
 950     return MSG_PeekMessage( msg, hwnd, first, last, flags, TRUE );
 951 }
 952
 953
 954 /***********************************************************************
 955  *           GetMessage   (USER.108)
 956  */
 957 BOOL GetMessage( SEGPTR msg, HWND hwnd, UINT first, UINT last )
 958 {
 959     MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 960                      hwnd, first, last, PM_REMOVE, FALSE );
 961     HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, 0, (LPARAM)msg );
 962     return (((MSG *)PTR_SEG_TO_LIN(msg))->message != WM_QUIT);
 963 }
 964
 965
 966
 967 /***********************************************************************
 968  *           PostMessage   (USER.110)
 969  */
 970 BOOL PostMessage( HWND hwnd, WORD message, WORD wParam, LONG lParam )
 971 {
 972     MSG         msg;
 973     WND         *wndPtr;
 974
 975     msg.hwnd    = hwnd;
 976     msg.message = message;
 977     msg.wParam  = wParam;
 978     msg.lParam  = lParam;
 979     msg.time    = GetTickCount();
 980     msg.pt.x    = 0;
 981     msg.pt.y    = 0;
 982
 983 #ifdef CONFIG_IPC
 984     if (DDE_PostMessage(&msg))
 985        return TRUE;
 986 #endif  /* CONFIG_IPC */
 987
 988     if (hwnd == HWND_BROADCAST) {
 989       dprintf_msg(stddeb,"PostMessage // HWND_BROADCAST !\n");
 990       hwnd = GetTopWindow(GetDesktopWindow());
 991       while (hwnd) {
 992         if (!(wndPtr = WIN_FindWndPtr(hwnd))) break;
 993         if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION) {
 994           dprintf_msg(stddeb,"BROADCAST Message to hWnd="NPFMT" m=%04X w=%04X l=%08lX !\n",
 995                       hwnd, message, wParam, lParam);
 996           PostMessage(hwnd, message, wParam, lParam);
 997         }
 998         hwnd = wndPtr->hwndNext;
 999       }
1000       dprintf_msg(stddeb,"PostMessage // End of HWND_BROADCAST !\n");
1001       return TRUE;
1002     }
1003
1004     wndPtr = WIN_FindWndPtr( hwnd );
1005     if (!wndPtr || !wndPtr->hmemTaskQ) return FALSE;
1006
1007     return MSG_AddMsg( wndPtr->hmemTaskQ, &msg, 0 );
1008 }
1009
1010 /***********************************************************************
1011  *           PostAppMessage   (USER.116)
1012  */
1013 BOOL PostAppMessage( HTASK hTask, WORD message, WORD wParam, LONG lParam )
1014 {
1015     MSG         msg;
1016
1017     if (GetTaskQueue(hTask) == 0) return FALSE;
1018     msg.hwnd    = 0;
1019     msg.message = message;
1020     msg.wParam  = wParam;
1021     msg.lParam  = lParam;
1022     msg.time    = GetTickCount();
1023     msg.pt.x    = 0;
1024     msg.pt.y    = 0;
1025
1026     return MSG_AddMsg( GetTaskQueue(hTask), &msg, 0 );
1027 }
1028
1029
1030 /***********************************************************************
1031  *           SendMessage   (USER.111)
1032  */
1033 LRESULT SendMessage( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1034 {
1035     WND * wndPtr;
1036     LONG ret;
1037     struct
1038     {
1039         LPARAM lParam;
1040         WPARAM wParam;
1041         UINT wMsg;
1042         HWND hWnd;
1043     } msgstruct = { lParam, wParam, msg, hwnd };
1044
1045 #ifdef CONFIG_IPC
1046     MSG DDE_msg = { hwnd, msg, wParam, lParam };
1047     if (DDE_SendMessage(&DDE_msg)) return TRUE;
1048 #endif  /* CONFIG_IPC */
1049
1050     if (hwnd == HWND_BROADCAST)
1051     {
1052         dprintf_msg(stddeb,"SendMessage // HWND_BROADCAST !\n");
1053         hwnd = GetTopWindow(GetDesktopWindow());
1054         while (hwnd)
1055         {
1056             if (!(wndPtr = WIN_FindWndPtr(hwnd))) break;
1057             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
1058             {
1059                 dprintf_msg(stddeb,"BROADCAST Message to hWnd="NPFMT" m=%04X w=%04lX l=%08lX !\n",
1060                             hwnd, msg, (DWORD)wParam, lParam);
1061                  ret |= SendMessage( hwnd, msg, wParam, lParam );
1062             }
1063             hwnd = wndPtr->hwndNext;
1064         }
1065         dprintf_msg(stddeb,"SendMessage // End of HWND_BROADCAST !\n");
1066         return TRUE;
1067     }
1068
1069     EnterSpyMessage(SPY_SENDMESSAGE, hwnd, msg, wParam, lParam);
1070
1071     HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 1, MAKE_SEGPTR(&msgstruct) );
1072     if (!(wndPtr = WIN_FindWndPtr( hwnd )))
1073     {
1074         ExitSpyMessage(SPY_RESULT_INVALIDHWND,hwnd,msg,0);
1075         return 0;
1076     }
1077     ret = CallWindowProc( wndPtr->lpfnWndProc, msgstruct.hWnd, msgstruct.wMsg,
1078                           msgstruct.wParam, msgstruct.lParam );
1079     ExitSpyMessage(SPY_RESULT_OK,hwnd,msg,ret);
1080     return ret;
1081 }
1082
1083
1084 /***********************************************************************
1085  *           WaitMessage    (USER.112)
1086  */
1087 void WaitMessage( void )
1088 {
1089     MSG msg;
1090     MESSAGEQUEUE *queue;
1091     LONG nextExp = -1;  /* Next timer expiration time */
1092
1093 #ifdef CONFIG_IPC
1094     DDE_GetRemoteMessage();
1095 #endif  /* CONFIG_IPC */
1096
1097     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return;
1098     if ((queue->wPostQMsg) ||
1099         (queue->status & (QS_SENDMESSAGE | QS_PAINT)) ||
1100         (queue->msgCount) || (sysMsgQueue->msgCount) )
1101         return;
1102     if ((queue->status & QS_TIMER) &&
1103         TIMER_CheckTimer( &nextExp, &msg, 0, FALSE))
1104         return;
1105     /* FIXME: (dde) must check DDE & X-events simultaneously */
1106     MSG_WaitXEvent( nextExp );
1107 }
1108
1109
1110 /***********************************************************************
1111  *           TranslateMessage   (USER.113)
1112  */
1113 BOOL TranslateMessage( LPMSG msg )
1114 {
1115     int message = msg->message;
1116
1117     if ((message == WM_KEYDOWN) || (message == WM_KEYUP) ||
1118         (message == WM_SYSKEYDOWN) || (message == WM_SYSKEYUP))
1119     {
1120         dprintf_msg(stddeb, "Translating key message\n" );
1121         return TRUE;
1122     }
1123     return FALSE;
1124 }
1125
1126
1127 /***********************************************************************
1128  *           DispatchMessage   (USER.114)
1129  */
1130 LONG DispatchMessage( LPMSG msg )
1131 {
1132     WND * wndPtr;
1133     LONG retval;
1134     int painting;
1135
1136     EnterSpyMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
1137                      msg->wParam, msg->lParam );
1138
1139       /* Process timer messages */
1140     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
1141     {
1142         if (msg->lParam)
1143         {
1144             HINSTANCE ds = msg->hwnd ? WIN_GetWindowInstance( msg->hwnd )
1145                                      : (HINSTANCE)CURRENT_DS;
1146 /*            HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1147             return CallWndProc( (WNDPROC)msg->lParam, ds, msg->hwnd,
1148                                 msg->message, msg->wParam, GetTickCount() );
1149         }
1150     }
1151
1152     if (!msg->hwnd) return 0;
1153     if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
1154     if (!wndPtr->lpfnWndProc) return 0;
1155     painting = (msg->message == WM_PAINT);
1156     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
1157 /*    HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1158     retval = CallWindowProc( wndPtr->lpfnWndProc, msg->hwnd, msg->message,
1159                              msg->wParam, msg->lParam );
1160     if (painting && IsWindow(msg->hwnd) &&
1161         (wndPtr->flags & WIN_NEEDS_BEGINPAINT))
1162     {
1163         fprintf(stderr, "BeginPaint not called on WM_PAINT for hwnd "NPFMT"!\n",
1164                 msg->hwnd);
1165         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
1166     }
1167     return retval;
1168 }
1169
1170
1171 /***********************************************************************
1172  *           GetMessagePos   (USER.119)
1173  */
1174 DWORD GetMessagePos(void)
1175 {
1176     MESSAGEQUEUE *queue;
1177
1178     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return 0;
1179     return queue->GetMessagePosVal;
1180 }
1181
1182
1183 /***********************************************************************
1184  *           GetMessageTime   (USER.120)
1185  */
1186 LONG GetMessageTime(void)
1187 {
1188     MESSAGEQUEUE *queue;
1189
1190     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return 0;
1191     return queue->GetMessageTimeVal;
1192 }
1193
1194
1195 /***********************************************************************
1196  *           GetMessageExtraInfo   (USER.288)
1197  */
1198 LONG GetMessageExtraInfo(void)
1199 {
1200     MESSAGEQUEUE *queue;
1201
1202     if (!(queue = (MESSAGEQUEUE *)GlobalLock( GetTaskQueue(0) ))) return 0;
1203     return queue->GetMessageExtraInfoVal;
1204 }
1205
1206
1207 /***********************************************************************
1208  *           RegisterWindowMessage   (USER.118)
1209  */
1210 WORD RegisterWindowMessage( SEGPTR str )
1211 {
1212     dprintf_msg(stddeb, "RegisterWindowMessage: '%08lx'\n", str );
1213     return GlobalAddAtom( str );
1214 }
1215
1216
1217 /***********************************************************************
1218  *           GetTickCount    (USER.13) (KERNEL32.299)
1219  */
1220 DWORD GetTickCount(void)
1221 {
1222     struct timeval t;
1223     gettimeofday( &t, NULL );
1224     return (t.tv_sec * 1000) + (t.tv_usec / 1000);
1225 }
1226
1227 /***********************************************************************
1228  *           GetCurrentTime  (effectively identical to GetTickCount)
1229  */
1230 DWORD GetCurrentTime(void)
1231 {
1232   return GetTickCount();
1233 }
1234
1235 /***********************************************************************
1236  *                      InSendMessage   (USER.192
1237  *
1238  * According to the book, this should return true iff the current message
1239  * was send from another application. In that case, the application should
1240  * invoke ReplyMessage before calling message relevant API.
1241  * Currently, Wine will always return FALSE, as there is no other app.
1242  */
1243 BOOL InSendMessage()
1244 {
1245         return FALSE;
1246 }