windows/message.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 /*
   8  * This code assumes that there is only one Windows task (hence
   9  * one message queue).
  10  */
  11
  12 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
  13
  14 #include <stdlib.h>
  15
  16 #include "message.h"
  17 #include "win.h"
  18
  19
  20 #define MAX_QUEUE_SIZE   120  /* Max. size of a message queue */
  21
  22 extern HWND WIN_FindWinToRepaint( HWND hwnd );
  23
  24 extern Display * XT_display;
  25 extern Screen * XT_screen;
  26 extern XtAppContext XT_app_context;
  27
  28 static MESSAGEQUEUE * msgQueue = NULL;
  29
  30
  31 /***********************************************************************
  32  *           MSG_GetMessageType
  33  *
  34  */
  35 int MSG_GetMessageType( int msg )
  36 {
  37     if ((msg >= WM_KEYFIRST) && (msg <= WM_KEYLAST)) return QS_KEY;
  38     else if ((msg >= WM_MOUSEFIRST) && (msg <= WM_MOUSELAST))
  39     {
  40         if (msg == WM_MOUSEMOVE) return QS_MOUSEMOVE;
  41         else return QS_MOUSEBUTTON;
  42     }
  43     else if (msg == WM_PAINT) return QS_PAINT;
  44     else if (msg == WM_TIMER) return QS_TIMER;
  45     return QS_POSTMESSAGE;
  46 }
  47
  48
  49 /***********************************************************************
  50  *           MSG_AddMsg
  51  *
  52  * Add a message to the queue. Return FALSE if queue is full.
  53  */
  54 int MSG_AddMsg( MSG * msg, DWORD extraInfo )
  55 {
  56     int pos, type;
  57
  58     if (!msgQueue) return FALSE;
  59     pos = msgQueue->nextFreeMessage;
  60
  61       /* No need to store WM_PAINT messages */
  62     if (msg->message == WM_PAINT) return TRUE;
  63
  64       /* Check if queue is full */
  65     if ((pos == msgQueue->nextMessage) && (msgQueue->msgCount > 0))
  66         return FALSE;
  67
  68       /* Store message */
  69     msgQueue->messages[pos].msg = *msg;
  70     msgQueue->messages[pos].extraInfo = extraInfo;
  71
  72       /* Store message type */
  73     type = MSG_GetMessageType( msg->message );
  74     msgQueue->status |= type;
  75     msgQueue->tempStatus |= type;
  76
  77     if (pos < msgQueue->queueSize-1) pos++;
  78     else pos = 0;
  79     msgQueue->nextFreeMessage = pos;
  80     msgQueue->msgCount++;
  81
  82     return TRUE;
  83 }
  84
  85
  86 /***********************************************************************
  87  *           MSG_FindMsg
  88  *
  89  * Find a message matching the given parameters. Return -1 if none available.
  90  */
  91 int MSG_FindMsg( HWND hwnd, int first, int last )
  92 {
  93     int i, pos = msgQueue->nextMessage;
  94
  95     if (!msgQueue->msgCount) return -1;
  96     if (!hwnd && !first && !last) return pos;
  97
  98     for (i = 0; i < msgQueue->msgCount; i++)
  99     {
 100         MSG * msg = &msgQueue->messages[pos].msg;
 101
 102         if (!hwnd || (msg->hwnd == hwnd))
 103         {
 104             if (!first && !last) return pos;
 105             if ((msg->message >= first) && (msg->message <= last)) return pos;
 106         }
 107         if (pos < msgQueue->queueSize-1) pos++;
 108         else pos = 0;
 109     }
 110     return -1;
 111 }
 112
 113
 114 /***********************************************************************
 115  *           MSG_RemoveMsg
 116  *
 117  * Remove a message from the queue (pos must be a valid position).
 118  */
 119 void MSG_RemoveMsg( int pos )
 120 {
 121     int i, type;
 122     QMSG * qmsg;
 123
 124     if (!msgQueue) return;
 125     qmsg = &msgQueue->messages[pos];
 126
 127     if (pos >= msgQueue->nextMessage)
 128     {
 129         int count = pos - msgQueue->nextMessage;
 130         if (count) memmove( &msgQueue->messages[msgQueue->nextMessage+1],
 131                             &msgQueue->messages[msgQueue->nextMessage],
 132                             count * sizeof(QMSG) );
 133         msgQueue->nextMessage++;
 134         if (msgQueue->nextMessage >= msgQueue->queueSize)
 135             msgQueue->nextMessage = 0;
 136     }
 137     else
 138     {
 139         int count = msgQueue->nextFreeMessage - pos;
 140         if (count) memmove( &msgQueue->messages[pos],
 141                             &msgQueue->messages[pos+1], count * sizeof(QMSG) );
 142         if (msgQueue->nextFreeMessage) msgQueue->nextFreeMessage--;
 143         else msgQueue->nextFreeMessage = msgQueue->queueSize-1;
 144     }
 145     msgQueue->msgCount--;
 146
 147       /* Recalc status */
 148     type = 0;
 149     pos = msgQueue->nextMessage;
 150     for (i = 0; i < msgQueue->msgCount; i++)
 151     {
 152         type |= MSG_GetMessageType( msgQueue->messages[pos].msg.message );
 153         if (++pos >= msgQueue->queueSize-1) pos = 0;
 154     }
 155     msgQueue->status = (msgQueue->status & QS_SENDMESSAGE) | type;
 156     msgQueue->tempStatus = 0;
 157 }
 158
 159
 160 /***********************************************************************
 161  *           SetMessageQueue  (USER.266)
 162  */
 163 BOOL SetMessageQueue( int size )
 164 {
 165     int queueSize;
 166
 167       /* Free the old message queue */
 168     if (msgQueue) free(msgQueue);
 169
 170     if ((size > MAX_QUEUE_SIZE) || (size <= 0)) return FALSE;
 171
 172     queueSize = sizeof(MESSAGEQUEUE) + size * sizeof(QMSG);
 173     msgQueue = (MESSAGEQUEUE *) malloc(queueSize);
 174     if (!msgQueue) return FALSE;
 175
 176     msgQueue->next = 0;
 177     msgQueue->hTask = 0;
 178     msgQueue->msgSize = sizeof(QMSG);
 179     msgQueue->msgCount = 0;
 180     msgQueue->nextMessage = 0;
 181     msgQueue->nextFreeMessage = 0;
 182     msgQueue->queueSize = size;
 183     msgQueue->GetMessageTimeVal = 0;
 184     msgQueue->GetMessagePosVal = 0;
 185     msgQueue->GetMessageExtraInfoVal = 0;
 186     msgQueue->lParam = 0;
 187     msgQueue->wParam = 0;
 188     msgQueue->msg = 0;
 189     msgQueue->hWnd = 0;
 190     msgQueue->wPostQMsg = 0;
 191     msgQueue->wExitCode = 0;
 192     msgQueue->InSendMessageHandle = 0;
 193     msgQueue->tempStatus = 0;
 194     msgQueue->status = 0;
 195
 196     return TRUE;
 197 }
 198
 199
 200 /***********************************************************************
 201  *           PostQuitMessage   (USER.6)
 202  */
 203 void PostQuitMessage( int exitCode )
 204 {
 205     if (!msgQueue) return;
 206     msgQueue->wPostQMsg = TRUE;
 207     msgQueue->wExitCode = exitCode;
 208 }
 209
 210
 211 /***********************************************************************
 212  *           GetQueueStatus   (USER.334)
 213  */
 214 DWORD GetQueueStatus( int flags )
 215 {
 216     unsigned long ret = (msgQueue->status << 16) | msgQueue->tempStatus;
 217     if (flags & QS_PAINT)
 218     {
 219         if (WIN_FindWinToRepaint(0)) ret |= QS_PAINT | (QS_PAINT << 16);
 220     }
 221     msgQueue->tempStatus = 0;
 222     return ret & ((flags << 16) | flags);
 223 }
 224
 225
 226 /***********************************************************************
 227  *           GetInputState   (USER.335)
 228  */
 229 BOOL GetInputState()
 230 {
 231     return msgQueue->status & (QS_KEY | QS_MOUSEBUTTON);
 232 }
 233
 234
 235 /***********************************************************************
 236  *           MSG_PeekMessage
 237  */
 238 BOOL MSG_PeekMessage( LPMSG msg, HWND hwnd, WORD first, WORD last, WORD flags )
 239 {
 240     int pos;
 241
 242       /* First handle a WM_QUIT message */
 243     if (msgQueue->wPostQMsg)
 244     {
 245         msg->hwnd    = hwnd;
 246         msg->message = WM_QUIT;
 247         msg->wParam  = msgQueue->wExitCode;
 248         msg->lParam  = 0;
 249         return TRUE;
 250     }
 251
 252       /* Then handle a message put by SendMessage() */
 253     if (msgQueue->status & QS_SENDMESSAGE)
 254     {
 255         if (!hwnd || (msgQueue->hWnd == hwnd))
 256         {
 257             if ((!first && !last) ||
 258                 ((msgQueue->msg >= first) && (msgQueue->msg <= last)))
 259             {
 260                 msg->hwnd    = msgQueue->hWnd;
 261                 msg->message = msgQueue->msg;
 262                 msg->wParam  = msgQueue->wParam;
 263                 msg->lParam  = msgQueue->lParam;
 264                 if (flags & PM_REMOVE) msgQueue->status &= ~QS_SENDMESSAGE;
 265                 return TRUE;
 266             }
 267         }
 268
 269     }
 270
 271       /* Now find a normal message */
 272     pos = MSG_FindMsg( hwnd, first, last );
 273     if (pos != -1)
 274     {
 275         QMSG *qmsg = &msgQueue->messages[pos];
 276         *msg = qmsg->msg;
 277         msgQueue->GetMessageTimeVal      = msg->time;
 278         msgQueue->GetMessagePosVal       = *(DWORD *)&msg->pt;
 279         msgQueue->GetMessageExtraInfoVal = qmsg->extraInfo;
 280
 281         if (flags & PM_REMOVE) MSG_RemoveMsg(pos);
 282         return TRUE;
 283     }
 284
 285       /* If nothing else, return a WM_PAINT message */
 286     if ((!first && !last) || ((first <= WM_PAINT) && (last >= WM_PAINT)))
 287     {
 288         msg->hwnd = WIN_FindWinToRepaint( hwnd );
 289         msg->message = WM_PAINT;
 290         msg->wParam = 0;
 291         msg->lParam = 0;
 292         return (msg->hwnd != 0);
 293     }
 294     return FALSE;
 295 }
 296
 297
 298 /***********************************************************************
 299  *           PeekMessage   (USER.109)
 300  */
 301 BOOL PeekMessage( LPMSG msg, HWND hwnd, WORD first, WORD last, WORD flags )
 302 {
 303     while (XtAppPending( XT_app_context ))
 304         XtAppProcessEvent( XT_app_context, XtIMAll );
 305
 306     return MSG_PeekMessage( msg, hwnd, first, last, flags );
 307 }
 308
 309
 310 /***********************************************************************
 311  *           GetMessage   (USER.108)
 312  */
 313 BOOL GetMessage( LPMSG msg, HWND hwnd, WORD first, WORD last )
 314 {
 315     while(1)
 316     {
 317         if (MSG_PeekMessage( msg, hwnd, first, last, PM_REMOVE )) break;
 318         XtAppProcessEvent( XT_app_context, XtIMAll );
 319     }
 320
 321     return (msg->message != WM_QUIT);
 322 }
 323
 324
 325 /***********************************************************************
 326  *           PostMessage   (USER.110)
 327  */
 328 BOOL PostMessage( HWND hwnd, WORD message, WORD wParam, LONG lParam )
 329 {
 330     MSG msg;
 331
 332     msg.hwnd    = hwnd;
 333     msg.message = message;
 334     msg.wParam  = wParam;
 335     msg.lParam  = lParam;
 336     msg.time    = GetTickCount();
 337     msg.pt.x    = 0;
 338     msg.pt.y    = 0;
 339
 340     return MSG_AddMsg( &msg, 0 );
 341 }
 342
 343
 344 /***********************************************************************
 345  *           SendMessage   (USER.111)
 346  */
 347 LONG SendMessage( HWND hwnd, WORD msg, WORD wParam, LONG lParam )
 348 {
 349     LONG retval = 0;
 350     WND * wndPtr = WIN_FindWndPtr( hwnd );
 351     if (wndPtr)
 352     {
 353         retval = CallWindowProc( wndPtr->lpfnWndProc, hwnd, msg,
 354                                  wParam, lParam );
 355         GlobalUnlock( hwnd );
 356     }
 357     return retval;
 358 }
 359
 360
 361 /***********************************************************************
 362  *           TranslateMessage   (USER.113)
 363  */
 364 BOOL TranslateMessage( LPMSG msg )
 365 {
 366     int message = msg->message;
 367
 368     if ((message == WM_KEYDOWN) || (message == WM_KEYUP) ||
 369         (message == WM_SYSKEYDOWN) || (message == WM_SYSKEYUP))
 370     {
 371 #ifdef DEBUG_MSG
 372         printf( "Translating key message\n" );
 373 #endif
 374         return TRUE;
 375     }
 376     return FALSE;
 377 }
 378
 379
 380 /***********************************************************************
 381  *           DispatchMessage   (USER.114)
 382  */
 383 LONG DispatchMessage( LPMSG msg )
 384 {
 385     LONG retval = 0;
 386     WND * wndPtr = WIN_FindWndPtr( msg->hwnd );
 387
 388 #ifdef DEBUG_MSG
 389     printf( "Dispatch message hwnd=%08x msg=%d w=%d l=%d time=%u pt=%d,%d\n",
 390             msg->hwnd, msg->message, msg->wParam, msg->lParam,
 391             msg->time, msg->pt.x, msg->pt.y );
 392 #endif
 393     if (wndPtr)
 394     {
 395         retval = CallWindowProc(wndPtr->lpfnWndProc, msg->hwnd, msg->message,
 396                                 msg->wParam, msg->lParam );
 397         GlobalUnlock( msg->hwnd );
 398     }
 399     return retval;
 400 }
 401
 402
 403 /***********************************************************************
 404  *           GetMessagePos   (USER.119)
 405  */
 406 DWORD GetMessagePos(void)
 407 {
 408     return msgQueue->GetMessagePosVal;
 409 }
 410
 411
 412 /***********************************************************************
 413  *           GetMessageTime   (USER.120)
 414  */
 415 LONG GetMessageTime(void)
 416 {
 417     return msgQueue->GetMessageTimeVal;
 418 }
 419
 420 /***********************************************************************
 421  *           GetMessageExtraInfo   (USER.288)
 422  */
 423 LONG GetMessageExtraInfo(void)
 424 {
 425     return msgQueue->GetMessageExtraInfoVal;
 426 }
 427