windows/message.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <errno.h>
  12
  13 #include "message.h"
  14 #include "win.h"
  15 #include "gdi.h"
  16 #include "sysmetrics.h"
  17 #include "hook.h"
  18 #include "event.h"
  19 #include "spy.h"
  20 #include "winpos.h"
  21 #include "atom.h"
  22 #include "dde.h"
  23 #include "queue.h"
  24 #include "stddebug.h"
  25 /* #define DEBUG_MSG */
  26 #include "debug.h"
  27
  28 #define HWND_BROADCAST16  ((HWND16)0xffff)
  29 #define HWND_BROADCAST32  ((HWND32)0xffffffff)
  30
  31 extern BYTE*    KeyStateTable;                           /* event.c */
  32 extern WPARAM   lastEventChar;                           /* event.c */
  33
  34 extern BOOL TIMER_CheckTimer( LONG *next, MSG *msg,
  35                               HWND hwnd, BOOL remove );  /* timer.c */
  36
  37 DWORD MSG_WineStartTicks;                                /* Ticks at Wine startup */
  38
  39 static WORD doubleClickSpeed = 452;
  40
  41 /***********************************************************************
  42  *           MSG_TranslateMouseMsg
  43  *
  44  * Translate an mouse hardware event into a real mouse message.
  45  * Return value indicates whether the translated message must be passed
  46  * to the user.
  47  * Actions performed:
  48  * - Find the window for this message.
  49  * - Translate button-down messages in double-clicks.
  50  * - Send the WM_NCHITTEST message to find where the cursor is.
  51  * - Activate the window if needed.
  52  * - Translate the message into a non-client message, or translate
  53  *   the coordinates to client coordinates.
  54  * - Send the WM_SETCURSOR message.
  55  */
  56 static BOOL MSG_TranslateMouseMsg( MSG *msg, BOOL remove )
  57 {
  58     WND *pWnd;
  59     BOOL eatMsg = FALSE;
  60     INT16 hittest;
  61     static DWORD lastClickTime = 0;
  62     static WORD  lastClickMsg = 0;
  63     static POINT16 lastClickPos = { 0, 0 };
  64     POINT16 pt = msg->pt;
  65     MOUSEHOOKSTRUCT hook = { msg->pt, 0, HTCLIENT, 0 };
  66
  67     BOOL mouseClick = ((msg->message == WM_LBUTTONDOWN) ||
  68                        (msg->message == WM_RBUTTONDOWN) ||
  69                        (msg->message == WM_MBUTTONDOWN));
  70
  71       /* Find the window */
  72
  73     if (GetCapture())
  74     {
  75         msg->hwnd = GetCapture();
  76         ScreenToClient16( msg->hwnd, &pt );
  77         msg->lParam = MAKELONG( pt.x, pt.y );
  78         /* No need to further process the message */
  79         hook.hwnd = msg->hwnd;
  80         return !HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
  81                                 msg->message, (LPARAM)MAKE_SEGPTR(&hook));
  82     }
  83
  84     hittest = WINPOS_WindowFromPoint( msg->pt, &pWnd );
  85     msg->hwnd = pWnd->hwndSelf;
  86     if ((hittest != HTERROR) && mouseClick)
  87     {
  88         HWND hwndTop = WIN_GetTopParent( msg->hwnd );
  89
  90         /* Send the WM_PARENTNOTIFY message */
  91
  92         WIN_SendParentNotify( msg->hwnd, msg->message, 0,
  93                               MAKELONG( msg->pt.x, msg->pt.y ) );
  94
  95         /* Activate the window if needed */
  96
  97         if (msg->hwnd != GetActiveWindow() && msg->hwnd != GetDesktopWindow())
  98         {
  99             LONG ret = SendMessage16( msg->hwnd, WM_MOUSEACTIVATE, hwndTop,
 100                                     MAKELONG( hittest, msg->message ) );
 101
 102             if ((ret == MA_ACTIVATEANDEAT) || (ret == MA_NOACTIVATEANDEAT))
 103                 eatMsg = TRUE;
 104
 105             if (((ret == MA_ACTIVATE) || (ret == MA_ACTIVATEANDEAT))
 106                 && hwndTop != GetActiveWindow() )
 107                 WINPOS_SetActiveWindow( hwndTop, TRUE , TRUE );
 108         }
 109     }
 110
 111       /* Send the WM_SETCURSOR message */
 112
 113     SendMessage16( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
 114                    MAKELONG( hittest, msg->message ));
 115     if (eatMsg) return FALSE;
 116
 117       /* Check for double-click */
 118
 119     if (mouseClick)
 120     {
 121         BOOL dbl_click = FALSE;
 122
 123         if ((msg->message == lastClickMsg) &&
 124             (msg->time - lastClickTime < doubleClickSpeed) &&
 125             (abs(msg->pt.x - lastClickPos.x) < SYSMETRICS_CXDOUBLECLK/2) &&
 126             (abs(msg->pt.y - lastClickPos.y) < SYSMETRICS_CYDOUBLECLK/2))
 127             dbl_click = TRUE;
 128
 129         if (dbl_click && (hittest == HTCLIENT))
 130         {
 131             /* Check whether window wants the double click message. */
 132             dbl_click = (pWnd->class->style & CS_DBLCLKS) != 0;
 133         }
 134
 135         if (dbl_click) switch(msg->message)
 136         {
 137             case WM_LBUTTONDOWN: msg->message = WM_LBUTTONDBLCLK; break;
 138             case WM_RBUTTONDOWN: msg->message = WM_RBUTTONDBLCLK; break;
 139             case WM_MBUTTONDOWN: msg->message = WM_MBUTTONDBLCLK; break;
 140         }
 141
 142         if (remove)
 143         {
 144             lastClickTime = msg->time;
 145             lastClickMsg  = msg->message;
 146             lastClickPos  = msg->pt;
 147         }
 148     }
 149
 150       /* Build the translated message */
 151
 152     if (hittest == HTCLIENT)
 153         ScreenToClient16( msg->hwnd, &pt );
 154     else
 155     {
 156         msg->wParam = hittest;
 157         msg->message += WM_NCLBUTTONDOWN - WM_LBUTTONDOWN;
 158     }
 159     msg->lParam = MAKELONG( pt.x, pt.y );
 160
 161     hook.hwnd = msg->hwnd;
 162     hook.wHitTestCode = hittest;
 163     return !HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
 164                             msg->message, (LPARAM)MAKE_SEGPTR(&hook));
 165 }
 166
 167
 168 /***********************************************************************
 169  *           MSG_TranslateKeyboardMsg
 170  *
 171  * Translate an keyboard hardware event into a real message.
 172  * Return value indicates whether the translated message must be passed
 173  * to the user.
 174  */
 175 static BOOL MSG_TranslateKeyboardMsg( MSG *msg, BOOL remove )
 176 {
 177       /* Should check Ctrl-Esc and PrintScreen here */
 178
 179     msg->hwnd = GetFocus();
 180     if (!msg->hwnd)
 181     {
 182           /* Send the message to the active window instead,  */
 183           /* translating messages to their WM_SYS equivalent */
 184
 185         msg->hwnd = GetActiveWindow();
 186
 187         if( msg->message < WM_SYSKEYDOWN )
 188             msg->message += WM_SYSKEYDOWN - WM_KEYDOWN;
 189     }
 190     return !HOOK_CallHooks( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
 191                             msg->wParam, msg->lParam );
 192 }
 193
 194
 195 /***********************************************************************
 196  *           MSG_PeekHardwareMsg
 197  *
 198  * Peek for a hardware message matching the hwnd and message filters.
 199  */
 200 static BOOL MSG_PeekHardwareMsg( MSG *msg, HWND hwnd, WORD first, WORD last,
 201                                  BOOL remove )
 202 {
 203     MESSAGEQUEUE *sysMsgQueue = QUEUE_GetSysQueue();
 204     int i, pos = sysMsgQueue->nextMessage;
 205
 206     /* If the queue is empty, attempt to fill it */
 207     if (!sysMsgQueue->msgCount && XPending(display)) MSG_WaitXEvent( 0 );
 208
 209     for (i = 0; i < sysMsgQueue->msgCount; i++, pos++)
 210     {
 211         if (pos >= sysMsgQueue->queueSize) pos = 0;
 212         *msg = sysMsgQueue->messages[pos].msg;
 213
 214           /* Translate message */
 215
 216         if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
 217         {
 218             if (!MSG_TranslateMouseMsg( msg, remove )) continue;
 219         }
 220         else if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
 221         {
 222             if (!MSG_TranslateKeyboardMsg( msg, remove )) continue;
 223         }
 224         else  /* Non-standard hardware event */
 225         {
 226             HARDWAREHOOKSTRUCT hook = { msg->hwnd, msg->message,
 227                                         msg->wParam, msg->lParam };
 228             if (HOOK_CallHooks( WH_HARDWARE, remove ? HC_ACTION : HC_NOREMOVE,
 229                                 0, (LPARAM)MAKE_SEGPTR(&hook) )) continue;
 230         }
 231
 232           /* Check message against filters */
 233
 234         if (hwnd && (msg->hwnd != hwnd)) continue;
 235         if ((first || last) &&
 236             ((msg->message < first) || (msg->message > last))) continue;
 237         if ((msg->hwnd != GetDesktopWindow()) &&
 238             (GetWindowTask(msg->hwnd) != GetCurrentTask()))
 239             continue;  /* Not for this task */
 240         if (remove)
 241         {
 242             MSG tmpMsg = *msg; /* FIXME */
 243             HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION,
 244                             0, (LPARAM)MAKE_SEGPTR(&tmpMsg) );
 245             QUEUE_RemoveMsg( sysMsgQueue, pos );
 246         }
 247         return TRUE;
 248     }
 249     return FALSE;
 250 }
 251
 252
 253 /**********************************************************************
 254  *           SetDoubleClickTime   (USER.20)
 255  */
 256 void SetDoubleClickTime( WORD interval )
 257 {
 258     doubleClickSpeed = interval ? interval : 500;
 259 }
 260
 261
 262 /**********************************************************************
 263  *           GetDoubleClickTime   (USER.21)
 264  */
 265 WORD GetDoubleClickTime()
 266 {
 267     return doubleClickSpeed;
 268 }
 269
 270
 271 /***********************************************************************
 272  *           MSG_GetHardwareMessage
 273  *
 274  * Like GetMessage(), but only return mouse and keyboard events.
 275  * Used internally for window moving and resizing. Mouse messages
 276  * are not translated.
 277  * Warning: msg->hwnd is always 0.
 278  */
 279 BOOL MSG_GetHardwareMessage( LPMSG msg )
 280 {
 281     int pos;
 282     XEvent event;
 283     MESSAGEQUEUE *sysMsgQueue = QUEUE_GetSysQueue();
 284
 285     while(1)
 286     {
 287         if ((pos = QUEUE_FindMsg( sysMsgQueue, 0, 0, 0 )) != -1)
 288         {
 289             *msg = sysMsgQueue->messages[pos].msg;
 290             QUEUE_RemoveMsg( sysMsgQueue, pos );
 291             break;
 292         }
 293         XNextEvent( display, &event );
 294         EVENT_ProcessEvent( &event );
 295     }
 296     return TRUE;
 297 }
 298
 299
 300 /***********************************************************************
 301  *           MSG_Synchronize
 302  *
 303  * Synchronize with the X server. Should not be used too often.
 304  */
 305 void MSG_Synchronize()
 306 {
 307     XEvent event;
 308
 309     XSync( display, False );
 310     while (XPending( display ))
 311     {
 312         XNextEvent( display, &event );
 313         EVENT_ProcessEvent( &event );
 314     }
 315 }
 316
 317
 318 /***********************************************************************
 319  *           MSG_WaitXEvent
 320  *
 321  * Wait for an X event, but at most maxWait milliseconds (-1 for no timeout).
 322  * Return TRUE if an event is pending, FALSE on timeout or error
 323  * (for instance lost connection with the server).
 324  */
 325 BOOL MSG_WaitXEvent( LONG maxWait )
 326 {
 327     fd_set read_set;
 328     struct timeval timeout;
 329     XEvent event;
 330     int fd = ConnectionNumber(display);
 331
 332     if (!XPending(display) && (maxWait != -1))
 333     {
 334         FD_ZERO( &read_set );
 335         FD_SET( fd, &read_set );
 336
 337         timeout.tv_usec = (maxWait % 1000) * 1000;
 338         timeout.tv_sec = maxWait / 1000;
 339
 340 #ifdef CONFIG_IPC
 341         sigsetjmp(env_wait_x, 1);
 342         stop_wait_op= CONT;
 343
 344         if (DDE_GetRemoteMessage()) {
 345             while(DDE_GetRemoteMessage())
 346                 ;
 347             return TRUE;
 348         }
 349         stop_wait_op= STOP_WAIT_X;
 350         /* The code up to the next "stop_wait_op= CONT" must be reentrant  */
 351         if (select( fd+1, &read_set, NULL, NULL, &timeout ) != 1 &&
 352             !XPending(display)) {
 353             stop_wait_op= CONT;
 354             return FALSE;
 355         } else {
 356             stop_wait_op= CONT;
 357         }
 358 #else  /* CONFIG_IPC */
 359         if (select( fd+1, &read_set, NULL, NULL, &timeout ) != 1)
 360             return FALSE;  /* Timeout or error */
 361 #endif  /* CONFIG_IPC */
 362
 363     }
 364
 365     /* Process the event (and possibly others that occurred in the meantime) */
 366     do
 367     {
 368
 369 #ifdef CONFIG_IPC
 370         if (DDE_GetRemoteMessage())
 371         {
 372             while(DDE_GetRemoteMessage()) ;
 373             return TRUE;
 374         }
 375 #endif  /* CONFIG_IPC */
 376
 377         XNextEvent( display, &event );
 378         EVENT_ProcessEvent( &event );
 379     }
 380     while (XPending( display ));
 381     return TRUE;
 382 }
 383
 384
 385 /***********************************************************************
 386  *           MSG_PeekMessage
 387  */
 388 static BOOL MSG_PeekMessage( LPMSG msg, HWND hwnd, WORD first, WORD last,
 389                              WORD flags, BOOL peek )
 390 {
 391     int pos, mask;
 392     MESSAGEQUEUE *msgQueue;
 393     HQUEUE        hQueue;
 394     LONG nextExp;  /* Next timer expiration time */
 395
 396 #ifdef CONFIG_IPC
 397     DDE_TestDDE(hwnd);  /* do we have dde handling in the window ?*/
 398     DDE_GetRemoteMessage();
 399 #endif  /* CONFIG_IPC */
 400
 401     if (first || last)
 402     {
 403         mask = QS_POSTMESSAGE;  /* Always selectioned */
 404         if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
 405         if ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) mask |= QS_MOUSE;
 406         if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
 407         if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
 408         if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
 409     }
 410     else mask = QS_MOUSE | QS_KEY | QS_POSTMESSAGE | QS_TIMER | QS_PAINT;
 411
 412     while(1)
 413     {
 414         hQueue   = GetTaskQueue(0);
 415         msgQueue = (MESSAGEQUEUE *)GlobalLock16( hQueue );
 416         if (!msgQueue) return FALSE;
 417
 418           /* First handle a message put by SendMessage() */
 419         if (msgQueue->status & QS_SENDMESSAGE)
 420         {
 421             if (!hwnd || (msgQueue->hWnd == hwnd))
 422             {
 423                 if ((!first && !last) ||
 424                     ((msgQueue->msg >= first) && (msgQueue->msg <= last)))
 425                 {
 426                     msg->hwnd    = msgQueue->hWnd;
 427                     msg->message = msgQueue->msg;
 428                     msg->wParam  = msgQueue->wParam;
 429                     msg->lParam  = msgQueue->lParam;
 430                     if (flags & PM_REMOVE) msgQueue->status &= ~QS_SENDMESSAGE;
 431                     break;
 432                 }
 433             }
 434         }
 435
 436           /* Now find a normal message */
 437         pos = QUEUE_FindMsg( msgQueue, hwnd, first, last );
 438         if (pos != -1)
 439         {
 440             QMSG *qmsg = &msgQueue->messages[pos];
 441             *msg = qmsg->msg;
 442             msgQueue->GetMessageTimeVal      = msg->time;
 443             msgQueue->GetMessagePosVal       = *(DWORD *)&msg->pt;
 444             msgQueue->GetMessageExtraInfoVal = qmsg->extraInfo;
 445
 446             if (flags & PM_REMOVE) QUEUE_RemoveMsg( msgQueue, pos );
 447             break;
 448         }
 449
 450           /* Now find a hardware event */
 451         if (MSG_PeekHardwareMsg( msg, hwnd, first, last, flags & PM_REMOVE ))
 452         {
 453             /* Got one */
 454             msgQueue->GetMessageTimeVal      = msg->time;
 455             msgQueue->GetMessagePosVal       = *(DWORD *)&msg->pt;
 456             msgQueue->GetMessageExtraInfoVal = 0;  /* Always 0 for now */
 457             break;
 458         }
 459
 460           /* Now handle a WM_QUIT message */
 461         if (msgQueue->wPostQMsg)
 462         {
 463             msg->hwnd    = hwnd;
 464             msg->message = WM_QUIT;
 465             msg->wParam  = msgQueue->wExitCode;
 466             msg->lParam  = 0;
 467             break;
 468         }
 469
 470           /* Now find a WM_PAINT message */
 471         if ((msgQueue->status & QS_PAINT) && (mask & QS_PAINT))
 472         {
 473             msg->hwnd = WIN_FindWinToRepaint( hwnd , hQueue );
 474             msg->message = WM_PAINT;
 475             msg->wParam = 0;
 476             msg->lParam = 0;
 477             if( msg->hwnd &&
 478               (!hwnd || msg->hwnd == hwnd || IsChild(hwnd,msg->hwnd)) )
 479               {
 480                 WND* wndPtr = WIN_FindWndPtr(msg->hwnd);
 481
 482                 /* FIXME: WM_PAINTICON should be sent sometimes */
 483
 484                 if( wndPtr->flags & WIN_INTERNAL_PAINT && !wndPtr->hrgnUpdate)
 485                   {
 486                     wndPtr->flags &= ~WIN_INTERNAL_PAINT;
 487                     QUEUE_DecPaintCount( hQueue );
 488                   }
 489                 break;
 490               }
 491         }
 492
 493           /* Finally handle WM_TIMER messages */
 494         if ((msgQueue->status & QS_TIMER) && (mask & QS_TIMER))
 495         {
 496             if (TIMER_CheckTimer( &nextExp, msg, hwnd, flags & PM_REMOVE ))
 497                 break;  /* Got a timer msg */
 498         }
 499         else nextExp = -1;  /* No timeout needed */
 500
 501         Yield();
 502
 503           /* Wait until something happens */
 504         if (peek)
 505         {
 506             if (!MSG_WaitXEvent( 0 )) return FALSE;  /* No pending event */
 507         }
 508         else  /* Wait for an event, then restart the loop */
 509             MSG_WaitXEvent( nextExp );
 510     }
 511
 512       /* We got a message */
 513     if (peek) return TRUE;
 514     else return (msg->message != WM_QUIT);
 515 }
 516
 517
 518 /***********************************************************************
 519  *           MSG_InternalGetMessage
 520  *
 521  * GetMessage() function for internal use. Behave like GetMessage(),
 522  * but also call message filters and optionally send WM_ENTERIDLE messages.
 523  * 'hwnd' must be the handle of the dialog or menu window.
 524  * 'code' is the message filter value (MSGF_??? codes).
 525  */
 526 BOOL MSG_InternalGetMessage( SEGPTR msg, HWND hwnd, HWND hwndOwner, short code,
 527                              WORD flags, BOOL sendIdle )
 528 {
 529     for (;;)
 530     {
 531         if (sendIdle)
 532         {
 533             if (!MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 534                                   0, 0, 0, flags, TRUE ))
 535             {
 536                   /* No message present -> send ENTERIDLE and wait */
 537                 SendMessage16( hwndOwner, WM_ENTERIDLE, code, (LPARAM)hwnd );
 538                 MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 539                                  0, 0, 0, flags, FALSE );
 540             }
 541         }
 542         else  /* Always wait for a message */
 543             MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 544                              0, 0, 0, flags, FALSE );
 545
 546         if (!CallMsgFilter( msg, code ))
 547             return (((MSG *)PTR_SEG_TO_LIN(msg))->message != WM_QUIT);
 548
 549           /* Message filtered -> remove it from the queue */
 550           /* if it's still there. */
 551         if (!(flags & PM_REMOVE))
 552             MSG_PeekMessage( (MSG *)PTR_SEG_TO_LIN(msg),
 553                              0, 0, 0, PM_REMOVE, TRUE );
 554     }
 555 }
 556
 557
 558 /***********************************************************************
 559  *           PeekMessage   (USER.109)
 560  */
 561 BOOL PeekMessage( LPMSG msg, HWND hwnd, WORD first, WORD last, WORD flags )
 562 {
 563     return MSG_PeekMessage( msg, hwnd, first, last, flags, TRUE );
 564 }
 565
 566
 567 /***********************************************************************
 568  *           GetMessage   (USER.108)
 569  */
 570 BOOL GetMessage( SEGPTR msg, HWND hwnd, UINT first, UINT last )
 571 {
 572     MSG* lpmsg = (MSG *)PTR_SEG_TO_LIN(msg);
 573     MSG_PeekMessage( lpmsg,
 574                      hwnd, first, last, PM_REMOVE, FALSE );
 575
 576     dprintf_msg(stddeb,"message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
 577                                                                  hwnd, first, last );
 578     HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, 0, (LPARAM)msg );
 579     return (lpmsg->message != WM_QUIT);
 580 }
 581
 582
 583 /***********************************************************************
 584  *           PostMessage   (USER.110)
 585  */
 586 BOOL PostMessage( HWND hwnd, WORD message, WORD wParam, LONG lParam )
 587 {
 588     MSG         msg;
 589     WND         *wndPtr;
 590
 591     msg.hwnd    = hwnd;
 592     msg.message = message;
 593     msg.wParam  = wParam;
 594     msg.lParam  = lParam;
 595     msg.time    = GetTickCount();
 596     msg.pt.x    = 0;
 597     msg.pt.y    = 0;
 598
 599 #ifdef CONFIG_IPC
 600     if (DDE_PostMessage(&msg))
 601        return TRUE;
 602 #endif  /* CONFIG_IPC */
 603
 604     if (hwnd == HWND_BROADCAST16)
 605     {
 606         dprintf_msg(stddeb,"PostMessage // HWND_BROADCAST !\n");
 607         for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
 608         {
 609             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
 610             {
 611                 dprintf_msg(stddeb,"BROADCAST Message to hWnd=%04x m=%04X w=%04X l=%08lX !\n",
 612                             wndPtr->hwndSelf, message, wParam, lParam);
 613                 PostMessage( wndPtr->hwndSelf, message, wParam, lParam );
 614             }
 615         }
 616         dprintf_msg(stddeb,"PostMessage // End of HWND_BROADCAST !\n");
 617         return TRUE;
 618     }
 619
 620     wndPtr = WIN_FindWndPtr( hwnd );
 621     if (!wndPtr || !wndPtr->hmemTaskQ) return FALSE;
 622
 623     return QUEUE_AddMsg( wndPtr->hmemTaskQ, &msg, 0 );
 624 }
 625
 626 /***********************************************************************
 627  *           PostAppMessage   (USER.116)
 628  */
 629 BOOL PostAppMessage( HTASK hTask, WORD message, WORD wParam, LONG lParam )
 630 {
 631     MSG         msg;
 632
 633     if (GetTaskQueue(hTask) == 0) return FALSE;
 634     msg.hwnd    = 0;
 635     msg.message = message;
 636     msg.wParam  = wParam;
 637     msg.lParam  = lParam;
 638     msg.time    = GetTickCount();
 639     msg.pt.x    = 0;
 640     msg.pt.y    = 0;
 641
 642     return QUEUE_AddMsg( GetTaskQueue(hTask), &msg, 0 );
 643 }
 644
 645
 646 /***********************************************************************
 647  *           SendMessage16   (USER.111)
 648  */
 649 LRESULT SendMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam)
 650 {
 651     WND * wndPtr;
 652     LRESULT ret;
 653     struct
 654     {
 655         LPARAM   lParam;
 656         WPARAM16 wParam;
 657         UINT16   wMsg;
 658         HWND16   hWnd;
 659     } msgstruct = { lParam, wParam, msg, hwnd };
 660
 661 #ifdef CONFIG_IPC
 662     MSG DDE_msg = { hwnd, msg, wParam, lParam };
 663     if (DDE_SendMessage(&DDE_msg)) return TRUE;
 664 #endif  /* CONFIG_IPC */
 665
 666     if (hwnd == HWND_BROADCAST16)
 667     {
 668         dprintf_msg(stddeb,"SendMessage // HWND_BROADCAST !\n");
 669         for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
 670         {
 671             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
 672             {
 673                 dprintf_msg(stddeb,"BROADCAST Message to hWnd=%04x m=%04X w=%04lX l=%08lX !\n",
 674                             wndPtr->hwndSelf, msg, (DWORD)wParam, lParam);
 675                 SendMessage16( wndPtr->hwndSelf, msg, wParam, lParam );
 676             }
 677         }
 678         dprintf_msg(stddeb,"SendMessage // End of HWND_BROADCAST !\n");
 679         return TRUE;
 680     }
 681
 682     HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 1,
 683                     (LPARAM)MAKE_SEGPTR(&msgstruct) );
 684     hwnd   = msgstruct.hWnd;
 685     msg    = msgstruct.wMsg;
 686     wParam = msgstruct.wParam;
 687     lParam = msgstruct.lParam;
 688
 689     SPY_EnterMessage( SPY_SENDMESSAGE16, hwnd, msg, wParam, lParam );
 690     if (!(wndPtr = WIN_FindWndPtr( hwnd )))
 691     {
 692         SPY_ExitMessage( SPY_RESULT_INVALIDHWND16, hwnd, msg, 0 );
 693         return 0;
 694     }
 695     ret = CallWindowProc16( wndPtr->lpfnWndProc, hwnd, msg, wParam, lParam );
 696     SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg, ret );
 697     return ret;
 698 }
 699
 700
 701 /***********************************************************************
 702  *           SendMessage32A   (USER32.453)
 703  */
 704 LRESULT SendMessage32A(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
 705 {
 706     WND * wndPtr;
 707     LRESULT ret;
 708
 709     if (hwnd == HWND_BROADCAST32)
 710     {
 711         for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
 712         {
 713             /* FIXME: should use something like EnumWindows here */
 714             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
 715                 SendMessage32A( wndPtr->hwndSelf, msg, wParam, lParam );
 716         }
 717         return TRUE;
 718     }
 719
 720     /* FIXME: call hooks */
 721
 722     SPY_EnterMessage( SPY_SENDMESSAGE32, hwnd, msg, wParam, lParam );
 723     if (!(wndPtr = WIN_FindWndPtr( hwnd )))
 724     {
 725         SPY_ExitMessage( SPY_RESULT_INVALIDHWND32, hwnd, msg, 0 );
 726         return 0;
 727     }
 728     ret = CallWindowProc32A( (WNDPROC32)wndPtr->lpfnWndProc,
 729                              hwnd, msg, wParam, lParam );
 730     SPY_ExitMessage( SPY_RESULT_OK32, hwnd, msg, ret );
 731     return ret;
 732 }
 733
 734
 735 /***********************************************************************
 736  *           SendMessage32W   (USER32.458)
 737  */
 738 LRESULT SendMessage32W(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
 739 {
 740     WND * wndPtr;
 741     LRESULT ret;
 742
 743     if (hwnd == HWND_BROADCAST32)
 744     {
 745         for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
 746         {
 747             /* FIXME: should use something like EnumWindows here */
 748             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
 749                 SendMessage32W( wndPtr->hwndSelf, msg, wParam, lParam );
 750         }
 751         return TRUE;
 752     }
 753
 754     /* FIXME: call hooks */
 755
 756     SPY_EnterMessage( SPY_SENDMESSAGE32, hwnd, msg, wParam, lParam );
 757     if (!(wndPtr = WIN_FindWndPtr( hwnd )))
 758     {
 759         SPY_ExitMessage( SPY_RESULT_INVALIDHWND32, hwnd, msg, 0 );
 760         return 0;
 761     }
 762     ret = CallWindowProc32W( (WNDPROC32)wndPtr->lpfnWndProc,
 763                              hwnd, msg, wParam, lParam );
 764     SPY_ExitMessage( SPY_RESULT_OK32, hwnd, msg, ret );
 765     return ret;
 766 }
 767
 768
 769 /***********************************************************************
 770  *           WaitMessage    (USER.112)
 771  */
 772 void WaitMessage( void )
 773 {
 774     MSG msg;
 775     MESSAGEQUEUE *queue;
 776     LONG nextExp = -1;  /* Next timer expiration time */
 777
 778 #ifdef CONFIG_IPC
 779     DDE_GetRemoteMessage();
 780 #endif  /* CONFIG_IPC */
 781
 782     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return;
 783     if ((queue->wPostQMsg) ||
 784         (queue->status & (QS_SENDMESSAGE | QS_PAINT)) ||
 785         (queue->msgCount) || (QUEUE_GetSysQueue()->msgCount) )
 786         return;
 787     if ((queue->status & QS_TIMER) &&
 788         TIMER_CheckTimer( &nextExp, &msg, 0, FALSE))
 789         return;
 790     /* FIXME: (dde) must check DDE & X-events simultaneously */
 791     MSG_WaitXEvent( nextExp );
 792 }
 793
 794
 795 /***********************************************************************
 796  *           TranslateMessage   (USER.113)
 797  *
 798  * This should call ToAscii but it is currently broken
 799  */
 800
 801 #define ASCII_CHAR_HACK 0x0800
 802
 803 BOOL TranslateMessage( LPMSG msg )
 804 {
 805     UINT message = msg->message;
 806     /* BYTE wparam[2]; */
 807
 808     if ((message == WM_KEYDOWN) || (message == WM_KEYUP) ||
 809         (message == WM_SYSKEYDOWN) || (message == WM_SYSKEYUP))
 810     {
 811         dprintf_msg(stddeb, "Translating key %04x, scancode %04x\n", msg->wParam,
 812                                                               HIWORD(msg->lParam) );
 813
 814         if( HIWORD(msg->lParam) & ASCII_CHAR_HACK )
 815
 816         /*  if( ToAscii( msg->wParam, HIWORD(msg->lParam), (LPSTR)&KeyStateTable,
 817                                       wparam, 0 ) )
 818          */
 819               {
 820                 message += 2 - (message & 0x0001);
 821
 822                 PostMessage( msg->hwnd, message, lastEventChar, msg->lParam );
 823
 824                 return TRUE;
 825               }
 826     }
 827     return FALSE;
 828 }
 829
 830
 831 /***********************************************************************
 832  *           DispatchMessage   (USER.114)
 833  */
 834 LONG DispatchMessage( const MSG* msg )
 835 {
 836     WND * wndPtr;
 837     LONG retval;
 838     int painting;
 839
 840       /* Process timer messages */
 841     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
 842     {
 843         if (msg->lParam)
 844         {
 845 /*            HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
 846             return CallWindowProc16( (WNDPROC)msg->lParam, msg->hwnd,
 847                                    msg->message, msg->wParam, GetTickCount() );
 848         }
 849     }
 850
 851     if (!msg->hwnd) return 0;
 852     if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
 853     if (!wndPtr->lpfnWndProc) return 0;
 854     painting = (msg->message == WM_PAINT);
 855     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
 856 /*    HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
 857
 858     SPY_EnterMessage( SPY_DISPATCHMESSAGE16, msg->hwnd, msg->message,
 859                       msg->wParam, msg->lParam );
 860     retval = CallWindowProc16( wndPtr->lpfnWndProc, msg->hwnd, msg->message,
 861                                msg->wParam, msg->lParam );
 862     SPY_ExitMessage( SPY_RESULT_OK16, msg->hwnd, msg->message, retval );
 863
 864     if (painting && (wndPtr = WIN_FindWndPtr( msg->hwnd )) &&
 865         (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
 866     {
 867         fprintf(stderr, "BeginPaint not called on WM_PAINT for hwnd %04x!\n",
 868                 msg->hwnd);
 869         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
 870         /* Validate the update region to avoid infinite WM_PAINT loop */
 871         ValidateRect32( msg->hwnd, NULL );
 872     }
 873     return retval;
 874 }
 875
 876
 877 /***********************************************************************
 878  *           RegisterWindowMessage16   (USER.118)
 879  */
 880 WORD RegisterWindowMessage16( SEGPTR str )
 881 {
 882     dprintf_msg(stddeb, "RegisterWindowMessage16: %08lx\n", (DWORD)str );
 883     return GlobalAddAtom16( str );
 884 }
 885
 886
 887 /***********************************************************************
 888  *           RegisterWindowMessage32A   (USER32.436)
 889  */
 890 WORD RegisterWindowMessage32A( LPCSTR str )
 891 {
 892     dprintf_msg(stddeb, "RegisterWindowMessage32A: %s\n", str );
 893     return GlobalAddAtom32A( str );
 894 }
 895
 896
 897 /***********************************************************************
 898  *           RegisterWindowMessage32W   (USER32.437)
 899  */
 900 WORD RegisterWindowMessage32W( LPCWSTR str )
 901 {
 902     dprintf_msg(stddeb, "RegisterWindowMessage32W: %p\n", str );
 903     return GlobalAddAtom32W( str );
 904 }
 905
 906
 907 /***********************************************************************
 908  *           GetTickCount    (USER.13) (KERNEL32.299)
 909  */
 910 DWORD GetTickCount(void)
 911 {
 912     struct timeval t;
 913     gettimeofday( &t, NULL );
 914     return ((t.tv_sec * 1000) + (t.tv_usec / 1000)) - MSG_WineStartTicks;
 915 }
 916
 917
 918 /***********************************************************************
 919  *           GetCurrentTime    (USER.15)
 920  *
 921  * (effectively identical to GetTickCount)
 922  */
 923 DWORD GetCurrentTime(void)
 924 {
 925     return GetTickCount();
 926 }
 927
 928
 929 /***********************************************************************
 930  *                      InSendMessage   (USER.192
 931  *
 932  * According to the book, this should return true iff the current message
 933  * was send from another application. In that case, the application should
 934  * invoke ReplyMessage before calling message relevant API.
 935  * Currently, Wine will always return FALSE, as there is no other app.
 936  */
 937 BOOL InSendMessage()
 938 {
 939         return FALSE;
 940 }