reactos/lib/user32/windows/message.c

   1 /* $Id: message.c,v 1.26 2003/11/08 09:33:14 navaraf Exp $
   2  *
   3  * COPYRIGHT:       See COPYING in the top level directory
   4  * PROJECT:         ReactOS user32.dll
   5  * FILE:            lib/user32/windows/message.c
   6  * PURPOSE:         Messages
   7  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
   8  * UPDATE HISTORY:
   9  *      06-06-2001  CSH  Created
  10  */
  11 #include <windows.h>
  12 #include <user32.h>
  13 #include <string.h>
  14 #include <debug.h>
  15
  16 /*
  17  * @implemented
  18  */
  19 LPARAM
  20 STDCALL
  21 GetMessageExtraInfo(VOID)
  22 {
  23   UNIMPLEMENTED;
  24   return (LPARAM)0;
  25 }
  26
  27
  28 /*
  29  * @implemented
  30  */
  31 DWORD
  32 STDCALL
  33 GetMessagePos(VOID)
  34 {
  35   PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
  36   return(MAKELONG(ThreadData->LastMessage.pt.x, ThreadData->LastMessage.pt.y));
  37 }
  38
  39
  40 /*
  41  * @implemented
  42  */
  43 LONG STDCALL
  44 GetMessageTime(VOID)
  45 {
  46   PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
  47   return(ThreadData->LastMessage.time);
  48 }
  49
  50
  51 /*
  52  * @unimplemented
  53  */
  54 WINBOOL
  55 STDCALL
  56 InSendMessage(VOID)
  57 {
  58   return FALSE;
  59 }
  60
  61
  62 /*
  63  * @unimplemented
  64  */
  65 DWORD
  66 STDCALL
  67 InSendMessageEx(
  68   LPVOID lpReserved)
  69 {
  70   UNIMPLEMENTED;
  71   return 0;
  72 }
  73
  74
  75 /*
  76  * @unimplemented
  77  */
  78 WINBOOL
  79 STDCALL
  80 ReplyMessage(
  81   LRESULT lResult)
  82 {
  83   UNIMPLEMENTED;
  84   return FALSE;
  85 }
  86
  87
  88 /*
  89  * @unimplemented
  90  */
  91 LPARAM
  92 STDCALL
  93 SetMessageExtraInfo(
  94   LPARAM lParam)
  95 {
  96   UNIMPLEMENTED;
  97   return (LPARAM)0;
  98 }
  99
 100
 101 BOOL
 102 MsgiAnsiToUnicodeMessage(LPMSG UnicodeMsg, LPMSG AnsiMsg)
 103 {
 104   *UnicodeMsg = *AnsiMsg;
 105   switch (AnsiMsg->message)
 106     {
 107     case WM_GETTEXT:
 108     case WM_ASKCBFORMATNAME:
 109       {
 110         LPWSTR Buffer = HeapAlloc(GetProcessHeap(), 0,
 111            AnsiMsg->wParam * sizeof(WCHAR));
 112         if (!Buffer)
 113           {
 114             return FALSE;
 115           }
 116         UnicodeMsg->lParam = (LPARAM)Buffer;
 117         break;
 118       }
 119
 120     /* AnsiMsg->lParam is string (0-terminated) */
 121     case WM_SETTEXT:
 122     case WM_WININICHANGE:
 123     case WM_DEVMODECHANGE:
 124     case CB_DIR:
 125     case LB_DIR:
 126     case LB_ADDFILE:
 127     case EM_REPLACESEL:
 128       {
 129         UNICODE_STRING UnicodeString;
 130         RtlCreateUnicodeStringFromAsciiz(&UnicodeString, (LPSTR)AnsiMsg->lParam);
 131         UnicodeMsg->lParam = (LPARAM)UnicodeString.Buffer;
 132         break;
 133       }
 134
 135     case WM_NCCREATE:
 136     case WM_CREATE:
 137       {
 138         UNICODE_STRING UnicodeBuffer;
 139         struct s
 140         {
 141            CREATESTRUCTW cs;    /* new structure */
 142            LPCWSTR lpszName;    /* allocated Name */
 143            LPCWSTR lpszClass;   /* allocated Class */
 144         };
 145         struct s *xs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct s));
 146         if (!xs)
 147           {
 148             return FALSE;
 149           }
 150         xs->cs = *(CREATESTRUCTW *)AnsiMsg->lParam;
 151         if (HIWORD(xs->cs.lpszName))
 152           {
 153             RtlCreateUnicodeStringFromAsciiz(&UnicodeBuffer, (LPSTR)xs->cs.lpszName);
 154             xs->lpszName = xs->cs.lpszName = UnicodeBuffer.Buffer;
 155           }
 156         if (HIWORD(xs->cs.lpszClass))
 157           {
 158             RtlCreateUnicodeStringFromAsciiz(&UnicodeBuffer, (LPSTR)xs->cs.lpszClass);
 159             xs->lpszClass = xs->cs.lpszClass = UnicodeBuffer.Buffer;
 160           }
 161         UnicodeMsg->lParam = (LPARAM)xs;
 162         break;
 163       }
 164
 165     case WM_MDICREATE:
 166       {
 167         UNICODE_STRING UnicodeBuffer;
 168         MDICREATESTRUCTW *cs =
 169             (MDICREATESTRUCTW *)HeapAlloc(GetProcessHeap(), 0, sizeof(*cs));
 170
 171         if (!cs)
 172           {
 173             return FALSE;
 174           }
 175
 176         *cs = *(MDICREATESTRUCTW *)AnsiMsg->lParam;
 177
 178         if (HIWORD(cs->szClass))
 179           {
 180             RtlCreateUnicodeStringFromAsciiz(&UnicodeBuffer, (LPSTR)cs->szClass);
 181             cs->szClass = UnicodeBuffer.Buffer;
 182           }
 183
 184         RtlCreateUnicodeStringFromAsciiz(&UnicodeBuffer, (LPSTR)cs->szTitle);
 185         cs->szTitle = UnicodeBuffer.Buffer;
 186
 187         UnicodeMsg->lParam = (LPARAM)cs;
 188         break;
 189       }
 190     }
 191
 192   return TRUE;
 193 }
 194
 195
 196 BOOL
 197 MsgiAnsiToUnicodeReply(LPMSG UnicodeMsg, LPMSG AnsiMsg, LRESULT *Result)
 198 {
 199   switch (AnsiMsg->message)
 200     {
 201     case WM_GETTEXT:
 202     case WM_ASKCBFORMATNAME:
 203       {
 204         LPWSTR Buffer = (LPWSTR)UnicodeMsg->lParam;
 205         LPSTR AnsiBuffer = (LPSTR)AnsiMsg->lParam;
 206         if (UnicodeMsg->wParam > 0 &&
 207             !WideCharToMultiByte(CP_ACP, 0, Buffer, -1,
 208             AnsiBuffer, UnicodeMsg->wParam, NULL, NULL))
 209           {
 210             AnsiBuffer[UnicodeMsg->wParam - 1] = 0;
 211           }
 212         HeapFree(GetProcessHeap(), 0, Buffer);
 213         break;
 214       }
 215
 216     case WM_GETTEXTLENGTH:
 217     case CB_GETLBTEXTLEN:
 218     case LB_GETTEXTLEN:
 219       {
 220         /* FIXME: There may be one DBCS char for each Unicode char */
 221         *Result *= 2;
 222         break;
 223       }
 224
 225     case WM_SETTEXT:
 226     case WM_WININICHANGE:
 227     case WM_DEVMODECHANGE:
 228     case CB_DIR:
 229     case LB_DIR:
 230     case LB_ADDFILE:
 231     case EM_REPLACESEL:
 232       {
 233         UNICODE_STRING UnicodeString;
 234         RtlInitUnicodeString(&UnicodeString, (PCWSTR)UnicodeMsg->lParam);
 235         RtlFreeUnicodeString(&UnicodeString);
 236         break;
 237       }
 238
 239     case WM_NCCREATE:
 240     case WM_CREATE:
 241       {
 242         UNICODE_STRING UnicodeString;
 243         struct s
 244         {
 245            CREATESTRUCTW cs;    /* new structure */
 246            LPWSTR lpszName;     /* allocated Name */
 247            LPWSTR lpszClass;    /* allocated Class */
 248         };
 249         struct s *xs = (struct s *)UnicodeMsg->lParam;
 250         if (xs->lpszName)
 251           {
 252             RtlInitUnicodeString(&UnicodeString, (PCWSTR)xs->lpszName);
 253             RtlFreeUnicodeString(&UnicodeString);
 254           }
 255         if (xs->lpszClass)
 256           {
 257             RtlInitUnicodeString(&UnicodeString, (PCWSTR)xs->lpszClass);
 258             RtlFreeUnicodeString(&UnicodeString);
 259           }
 260         HeapFree(GetProcessHeap(), 0, xs);
 261       }
 262       break;
 263
 264     case WM_MDICREATE:
 265       {
 266         UNICODE_STRING UnicodeString;
 267         MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)UnicodeMsg->lParam;
 268         if (HIWORD(cs->szTitle))
 269           {
 270             RtlInitUnicodeString(&UnicodeString, (PCWSTR)cs->szTitle);
 271             RtlFreeUnicodeString(&UnicodeString);
 272           }
 273         if (HIWORD(cs->szClass))
 274           {
 275             RtlInitUnicodeString(&UnicodeString, (PCWSTR)cs->szClass);
 276             RtlFreeUnicodeString(&UnicodeString);
 277           }
 278         HeapFree(GetProcessHeap(), 0, cs);
 279       }
 280       break;
 281     }
 282   return(TRUE);
 283 }
 284
 285
 286 VOID STATIC
 287 User32ConvertToAsciiMessage(UINT* Msg, WPARAM* wParam, LPARAM* lParam)
 288 {
 289   switch((*Msg))
 290     {
 291     case WM_CREATE:
 292     case WM_NCCREATE:
 293       {
 294         CREATESTRUCTA* CsA;
 295         CREATESTRUCTW* CsW;
 296         UNICODE_STRING UString;
 297         ANSI_STRING AString;
 298
 299         CsW = (CREATESTRUCTW*)(*lParam);
 300         CsA = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(CREATESTRUCTA));
 301         memcpy(CsA, CsW, sizeof(CREATESTRUCTW));
 302
 303         RtlInitUnicodeString(&UString, CsW->lpszName);
 304         RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
 305         CsA->lpszName = AString.Buffer;
 306         if (HIWORD((ULONG)CsW->lpszClass) != 0)
 307           {
 308             RtlInitUnicodeString(&UString, CsW->lpszClass);
 309             RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
 310             CsA->lpszClass = AString.Buffer;
 311           }
 312         (*lParam) = (LPARAM)CsA;
 313         break;
 314       }
 315     case WM_SETTEXT:
 316       {
 317         ANSI_STRING AnsiString;
 318         UNICODE_STRING UnicodeString;
 319         RtlInitUnicodeString(&UnicodeString, (PWSTR) *lParam);
 320         if (NT_SUCCESS(RtlUnicodeStringToAnsiString(&AnsiString,
 321                                                     &UnicodeString,
 322                                                     TRUE)))
 323           {
 324             *lParam = (LPARAM) AnsiString.Buffer;
 325           }
 326         break;
 327       }
 328     }
 329 }
 330
 331
 332 VOID STATIC
 333 User32FreeAsciiConvertedMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
 334 {
 335   switch(Msg)
 336     {
 337     case WM_GETTEXT:
 338       {
 339         ANSI_STRING AnsiString;
 340         UNICODE_STRING UnicodeString;
 341         LPSTR TempString;
 342         LPSTR InString;
 343         InString = (LPSTR)lParam;
 344         TempString = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(InString) + 1);
 345         strcpy(TempString, InString);
 346         RtlInitAnsiString(&AnsiString, TempString);
 347         UnicodeString.Length = wParam * sizeof(WCHAR);
 348         UnicodeString.MaximumLength = wParam * sizeof(WCHAR);
 349         UnicodeString.Buffer = (PWSTR)lParam;
 350         if (! NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeString,
 351                                                       &AnsiString,
 352                                                       FALSE)))
 353           {
 354             if (1 <= wParam)
 355               {
 356                 UnicodeString.Buffer[0] = L'\0';
 357               }
 358           }
 359         RtlFreeHeap(RtlGetProcessHeap(), 0, TempString);
 360         break;
 361       }
 362     case WM_SETTEXT:
 363       {
 364         ANSI_STRING AnsiString;
 365         RtlInitAnsiString(&AnsiString, (PSTR) lParam);
 366         RtlFreeAnsiString(&AnsiString);
 367         break;
 368       }
 369     case WM_CREATE:
 370     case WM_NCCREATE:
 371       {
 372         CREATESTRUCTA* Cs;
 373
 374         Cs = (CREATESTRUCTA*)lParam;
 375         RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszName);
 376         if (HIWORD((ULONG)Cs->lpszClass) != 0)
 377           {
 378             RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszClass);
 379           }
 380         RtlFreeHeap(RtlGetProcessHeap(), 0, Cs);
 381         break;
 382       }
 383     }
 384 }
 385
 386
 387 /*
 388  * @implemented
 389  */
 390 LRESULT STDCALL
 391 CallWindowProcA(WNDPROC lpPrevWndFunc,
 392                 HWND hWnd,
 393                 UINT Msg,
 394                 WPARAM wParam,
 395                 LPARAM lParam)
 396 {
 397   MSG AnsiMsg;
 398   MSG UnicodeMsg;
 399   LRESULT Result;
 400   BOOL IsHandle;
 401
 402   if ((DWORD)lpPrevWndFunc > 0x80000000)
 403     {
 404       lpPrevWndFunc -= 0x80000000;
 405       IsHandle = TRUE;
 406     }
 407   else
 408     {
 409       IsHandle = FALSE;
 410     }
 411
 412   AnsiMsg.hwnd = hWnd;
 413   AnsiMsg.message = Msg;
 414   AnsiMsg.wParam = wParam;
 415   AnsiMsg.lParam = lParam;
 416
 417   if (IsWindowUnicode(hWnd))
 418     {
 419       if (!MsgiAnsiToUnicodeMessage(&UnicodeMsg, &AnsiMsg))
 420         {
 421           return(FALSE);
 422         }
 423       Result = lpPrevWndFunc(hWnd, Msg, wParam, lParam);
 424       if (!MsgiAnsiToUnicodeReply(&UnicodeMsg, &AnsiMsg, &Result))
 425         {
 426           return(FALSE);
 427         }
 428       return(Result);
 429     }
 430   else
 431     {
 432       return(lpPrevWndFunc(hWnd, Msg, wParam, lParam));
 433     }
 434 }
 435
 436
 437 /*
 438  * @implemented
 439  */
 440 LRESULT STDCALL
 441 CallWindowProcW(WNDPROC lpPrevWndFunc,
 442                 HWND hWnd,
 443                 UINT Msg,
 444                 WPARAM wParam,
 445                 LPARAM lParam)
 446 {
 447   BOOL IsHandle;
 448   if ((DWORD)lpPrevWndFunc > 0x80000000)
 449   {
 450           lpPrevWndFunc-= 0x80000000;
 451           IsHandle = TRUE;
 452   }
 453   else
 454   {
 455           IsHandle = FALSE;
 456   }
 457   if (!IsWindowUnicode(hWnd))
 458     {
 459       LRESULT Result;
 460       User32ConvertToAsciiMessage(&Msg, &wParam, &lParam);
 461       Result = lpPrevWndFunc(hWnd, Msg, wParam, lParam);
 462       User32FreeAsciiConvertedMessage(Msg, wParam, lParam);
 463       return(Result);
 464     }
 465   else
 466     {
 467       return(lpPrevWndFunc(hWnd, Msg, wParam, lParam));
 468     }
 469 }
 470
 471
 472 /*
 473  * @implemented
 474  */
 475 LRESULT STDCALL
 476 DispatchMessageA(CONST MSG *lpmsg)
 477 {
 478   return(NtUserDispatchMessage(lpmsg));
 479 }
 480
 481
 482 /*
 483  * @implemented
 484  */
 485 LRESULT STDCALL
 486 DispatchMessageW(CONST MSG *lpmsg)
 487 {
 488   return(NtUserDispatchMessage((LPMSG)lpmsg));
 489 }
 490
 491
 492 /*
 493  * @implemented
 494  */
 495 WINBOOL STDCALL
 496 GetMessageA(LPMSG lpMsg,
 497             HWND hWnd,
 498             UINT wMsgFilterMin,
 499             UINT wMsgFilterMax)
 500 {
 501   BOOL Res;
 502   PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
 503
 504   Res = NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
 505   if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
 506     {
 507       ThreadData->LastMessage = *lpMsg;
 508     }
 509   return(Res);
 510 }
 511
 512
 513 /*
 514  * @implemented
 515  */
 516 WINBOOL STDCALL
 517 GetMessageW(LPMSG lpMsg,
 518             HWND hWnd,
 519             UINT wMsgFilterMin,
 520             UINT wMsgFilterMax)
 521 {
 522   BOOL Res;
 523   PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
 524
 525   Res = NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
 526   if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
 527     {
 528       ThreadData->LastMessage = *lpMsg;
 529     }
 530   return(Res);
 531 }
 532
 533
 534 /*
 535  * @implemented
 536  */
 537 WINBOOL STDCALL
 538 PeekMessageA(LPMSG lpMsg,
 539              HWND hWnd,
 540              UINT wMsgFilterMin,
 541              UINT wMsgFilterMax,
 542              UINT wRemoveMsg)
 543 {
 544   BOOL Res;
 545   PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
 546
 547   Res =  NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 548   if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
 549     {
 550       ThreadData->LastMessage = *lpMsg;
 551     }
 552   return(Res);
 553 }
 554
 555
 556 /*
 557  * @implemented
 558  */
 559 WINBOOL
 560 STDCALL
 561 PeekMessageW(
 562   LPMSG lpMsg,
 563   HWND hWnd,
 564   UINT wMsgFilterMin,
 565   UINT wMsgFilterMax,
 566   UINT wRemoveMsg)
 567 {
 568   BOOL Res;
 569   PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
 570
 571   Res = NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 572   if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
 573     {
 574       ThreadData->LastMessage = *lpMsg;
 575     }
 576   return(Res);
 577 }
 578
 579
 580 /*
 581  * @implemented
 582  */
 583 WINBOOL
 584 STDCALL
 585 PostMessageA(
 586   HWND hWnd,
 587   UINT Msg,
 588   WPARAM wParam,
 589   LPARAM lParam)
 590 {
 591   return NtUserPostMessage(hWnd, Msg, wParam, lParam);
 592 }
 593
 594
 595 /*
 596  * @implemented
 597  */
 598 WINBOOL
 599 STDCALL
 600 PostMessageW(
 601   HWND hWnd,
 602   UINT Msg,
 603   WPARAM wParam,
 604   LPARAM lParam)
 605 {
 606   return NtUserPostMessage(hWnd, Msg, wParam, lParam);
 607 }
 608
 609
 610 /*
 611  * @implemented
 612  */
 613 VOID
 614 STDCALL
 615 PostQuitMessage(
 616   int nExitCode)
 617 {
 618   (void) NtUserPostMessage(NULL, WM_QUIT, nExitCode, 0);
 619 }
 620
 621
 622 /*
 623  * @implemented
 624  */
 625 WINBOOL
 626 STDCALL
 627 PostThreadMessageA(
 628   DWORD idThread,
 629   UINT Msg,
 630   WPARAM wParam,
 631   LPARAM lParam)
 632 {
 633   return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
 634 }
 635
 636
 637 /*
 638  * @implemented
 639  */
 640 WINBOOL
 641 STDCALL
 642 PostThreadMessageW(
 643   DWORD idThread,
 644   UINT Msg,
 645   WPARAM wParam,
 646   LPARAM lParam)
 647 {
 648   return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
 649 }
 650
 651
 652 /*
 653  * @implemented
 654  */
 655 LRESULT STDCALL
 656 SendMessageW(HWND hWnd,
 657              UINT Msg,
 658              WPARAM wParam,
 659              LPARAM lParam)
 660 {
 661   return(NtUserSendMessage(hWnd, Msg, wParam, lParam));
 662 }
 663
 664
 665 /*
 666  * @implemented
 667  */
 668 LRESULT STDCALL
 669 SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
 670 {
 671   MSG AnsiMsg;
 672   MSG UcMsg;
 673   LRESULT Result;
 674
 675   AnsiMsg.hwnd = hWnd;
 676   AnsiMsg.message = Msg;
 677   AnsiMsg.wParam = wParam;
 678   AnsiMsg.lParam = lParam;
 679
 680   if (!MsgiAnsiToUnicodeMessage(&UcMsg, &AnsiMsg))
 681     {
 682       return(FALSE);
 683     }
 684   Result = SendMessageW(UcMsg.hwnd, UcMsg.message, UcMsg.wParam, UcMsg.lParam);
 685   if (!MsgiAnsiToUnicodeReply(&UcMsg, &AnsiMsg, &Result))
 686     {
 687       return(FALSE);
 688     }
 689   return(Result);
 690 }
 691
 692
 693 /*
 694  * @implemented
 695  */
 696 WINBOOL
 697 STDCALL
 698 SendMessageCallbackA(
 699   HWND hWnd,
 700   UINT Msg,
 701   WPARAM wParam,
 702   LPARAM lParam,
 703   SENDASYNCPROC lpCallBack,
 704   ULONG_PTR dwData)
 705 {
 706   return NtUserSendMessageCallback(
 707     hWnd,
 708     Msg,
 709     wParam,
 710     lParam,
 711     lpCallBack,
 712     dwData);
 713 }
 714
 715
 716 /*
 717  * @implemented
 718  */
 719 WINBOOL
 720 STDCALL
 721 SendMessageCallbackW(
 722   HWND hWnd,
 723   UINT Msg,
 724   WPARAM wParam,
 725   LPARAM lParam,
 726   SENDASYNCPROC lpCallBack,
 727   ULONG_PTR dwData)
 728 {
 729   return NtUserSendMessageCallback(
 730     hWnd,
 731     Msg,
 732     wParam,
 733     lParam,
 734     lpCallBack,
 735     dwData);
 736 }
 737
 738
 739 /*
 740  * @implemented
 741  */
 742 LRESULT
 743 STDCALL
 744 SendMessageTimeoutA(
 745   HWND hWnd,
 746   UINT Msg,
 747   WPARAM wParam,
 748   LPARAM lParam,
 749   UINT fuFlags,
 750   UINT uTimeout,
 751   PDWORD_PTR lpdwResult)
 752 {
 753   UNIMPLEMENTED;
 754   return (LRESULT)0;
 755 }
 756
 757
 758 /*
 759  * @implemented
 760  */
 761 LRESULT
 762 STDCALL
 763 SendMessageTimeoutW(
 764   HWND hWnd,
 765   UINT Msg,
 766   WPARAM wParam,
 767   LPARAM lParam,
 768   UINT fuFlags,
 769   UINT uTimeout,
 770   PDWORD_PTR lpdwResult)
 771 {
 772   UNIMPLEMENTED;
 773   return (LRESULT)0;
 774 }
 775
 776
 777 /*
 778  * @unimplemented
 779  */
 780 WINBOOL
 781 STDCALL
 782 SendNotifyMessageA(
 783   HWND hWnd,
 784   UINT Msg,
 785   WPARAM wParam,
 786   LPARAM lParam)
 787 {
 788   UNIMPLEMENTED;
 789   return FALSE;
 790 }
 791
 792
 793 /*
 794  * @unimplemented
 795  */
 796 WINBOOL
 797 STDCALL
 798 SendNotifyMessageW(
 799   HWND hWnd,
 800   UINT Msg,
 801   WPARAM wParam,
 802   LPARAM lParam)
 803 {
 804   UNIMPLEMENTED;
 805   return FALSE;
 806 }
 807
 808
 809 /*
 810  * @implemented
 811  */
 812 WINBOOL STDCALL
 813 TranslateMessage(CONST MSG *lpMsg)
 814 {
 815   return(TranslateMessageEx((LPMSG)lpMsg, 0));
 816 }
 817
 818 /*
 819  * @implemented
 820  */
 821 WINBOOL STDCALL
 822 TranslateMessageEx(CONST MSG *lpMsg, DWORD unk)
 823 {
 824   return(NtUserTranslateMessage((LPMSG)lpMsg, (HKL)unk));
 825 }
 826
 827
 828 /*
 829  * @implemented
 830  */
 831 WINBOOL
 832 STDCALL
 833 WaitMessage(VOID)
 834 {
 835   return NtUserWaitMessage();
 836 }
 837
 838
 839 /*
 840  * @implemented
 841  */
 842 UINT STDCALL
 843 RegisterWindowMessageA(LPCSTR lpString)
 844 {
 845   UNICODE_STRING String;
 846   BOOLEAN Result;
 847   UINT Atom;
 848
 849   Result = RtlCreateUnicodeStringFromAsciiz(&String, (PCSZ)lpString);
 850   if (!Result)
 851     {
 852       return(0);
 853     }
 854   Atom = NtUserRegisterWindowMessage(&String);
 855   RtlFreeUnicodeString(&String);
 856   return(Atom);
 857 }
 858
 859
 860 /*
 861  * @implemented
 862  */
 863 UINT STDCALL
 864 RegisterWindowMessageW(LPCWSTR lpString)
 865 {
 866   UNICODE_STRING String;
 867
 868   RtlInitUnicodeString(&String, lpString);
 869   return(NtUserRegisterWindowMessage(&String));
 870 }
 871
 872 /*
 873  * @implemented
 874  */
 875 HWND STDCALL
 876 SetCapture(HWND hWnd)
 877 {
 878   return(NtUserSetCapture(hWnd));
 879 }
 880
 881 /*
 882  * @implemented
 883  */
 884 HWND STDCALL
 885 GetCapture(VOID)
 886 {
 887   return(NtUserGetCapture());
 888 }
 889
 890 /*
 891  * @implemented
 892  */
 893 WINBOOL STDCALL
 894 ReleaseCapture(VOID)
 895 {
 896   NtUserSetCapture(NULL);
 897   return(TRUE);
 898 }
 899
 900
 901 /*
 902  * @unimplemented
 903  */
 904 DWORD
 905 STDCALL
 906 GetQueueStatus(UINT flags)
 907 {
 908    DWORD ret;
 909    WORD changed_bits, wake_bits;
 910
 911 #if 0 /* wine stuff. don't know what it does... */
 912
 913    /* check for pending X events */
 914    if (USER_Driver.pMsgWaitForMultipleObjectsEx)
 915       USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
 916 #endif
 917
 918    ret = NtUserGetQueueStatus(TRUE /*ClearChanges*/);
 919
 920    changed_bits = LOWORD(ret);
 921    wake_bits = HIWORD(ret);
 922
 923    return MAKELONG(changed_bits & flags, wake_bits & flags);
 924 }
 925
 926
 927 /*
 928  * @unimplemented
 929  */
 930 WINBOOL STDCALL GetInputState(VOID)
 931 {
 932    DWORD ret;
 933    WORD  wake_bits;
 934
 935 #if 0 /* wine stuff. don't know what it does... */
 936
 937    /* check for pending X events */
 938    if (USER_Driver.pMsgWaitForMultipleObjectsEx)
 939      USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
 940 #endif
 941
 942    ret = NtUserGetQueueStatus(FALSE /*ClearChanges*/);
 943
 944    wake_bits = HIWORD(ret);
 945
 946    return wake_bits & (QS_KEY | QS_MOUSEBUTTON);
 947 }
 948
 949 /*
 950  * @implemented
 951  */
 952 WINBOOL STDCALL SetMessageQueue(int cMessagesMax)
 953 {
 954   /* Function does nothing on 32 bit windows */
 955   return TRUE;
 956 }
 957
 958
 959
 960 /* EOF */