reactos/lib/user32/windows/message.c

   1 /* $Id: message.c,v 1.13 2003/05/02 07:52:33 gvg 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 LPARAM
  17 STDCALL
  18 GetMessageExtraInfo(VOID)
  19 {
  20   return (LPARAM)0;
  21 }
  22
  23 DWORD
  24 STDCALL
  25 GetMessagePos(VOID)
  26 {
  27   return 0;
  28 }
  29
  30 LONG
  31 STDCALL
  32 GetMessageTime(VOID)
  33 {
  34   return 0;
  35 }
  36 WINBOOL
  37 STDCALL
  38 InSendMessage(VOID)
  39 {
  40   return FALSE;
  41 }
  42
  43 DWORD
  44 STDCALL
  45 InSendMessageEx(
  46   LPVOID lpReserved)
  47 {
  48   return 0;
  49 }
  50 WINBOOL
  51 STDCALL
  52 ReplyMessage(
  53   LRESULT lResult)
  54 {
  55   return FALSE;
  56 }
  57 LPARAM
  58 STDCALL
  59 SetMessageExtraInfo(
  60   LPARAM lParam)
  61 {
  62   return (LPARAM)0;
  63 }
  64
  65 VOID STATIC
  66 User32FreeAsciiConvertedMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
  67 {
  68   switch(Msg)
  69     {
  70     case WM_GETTEXT:
  71       {
  72         ANSI_STRING AnsiString;
  73         UNICODE_STRING UnicodeString;
  74         LPSTR TempString;
  75         LPSTR InString;
  76         InString = (LPSTR)lParam;
  77         TempString = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(InString));
  78         strcpy(TempString, InString);
  79         RtlInitAnsiString(&AnsiString, TempString);
  80         UnicodeString.Length = wParam;
  81         UnicodeString.MaximumLength = wParam;
  82         UnicodeString.Buffer = (PWSTR)lParam;
  83         RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
  84         RtlFreeHeap(RtlGetProcessHeap(), 0, TempString);
  85         break;
  86       }
  87     case WM_NCCREATE:
  88       {
  89         CREATESTRUCTA* Cs;
  90
  91         Cs = (CREATESTRUCTA*)lParam;
  92         RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszName);
  93         RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszClass);
  94         RtlFreeHeap(RtlGetProcessHeap(), 0, Cs);
  95         break;
  96       }
  97     }
  98 }
  99
 100 VOID STATIC
 101 User32ConvertToAsciiMessage(UINT* Msg, WPARAM* wParam, LPARAM* lParam)
 102 {
 103   switch((*Msg))
 104     {
 105     case WM_NCCREATE:
 106       {
 107         CREATESTRUCTA* CsA;
 108         CREATESTRUCTW* CsW;
 109         UNICODE_STRING UString;
 110         ANSI_STRING AString;
 111
 112         CsW = (CREATESTRUCTW*)(*lParam);
 113         CsA = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(CREATESTRUCTA));
 114         memcpy(CsA, CsW, sizeof(CREATESTRUCTW));
 115
 116         RtlInitUnicodeString(&UString, CsW->lpszName);
 117         RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
 118         CsA->lpszName = AString.Buffer;
 119
 120         RtlInitUnicodeString(&UString, CsW->lpszClass);
 121         RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
 122         CsA->lpszClass = AString.Buffer;
 123
 124         (*lParam) = (LPARAM)CsA;
 125         break;
 126       }
 127     }
 128   return;
 129 }
 130
 131 VOID STATIC
 132 User32FreeUnicodeConvertedMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
 133 {
 134 }
 135
 136 VOID STATIC
 137 User32ConvertToUnicodeMessage(UINT* Msg, WPARAM* wParam, LPARAM* lParam)
 138 {
 139 }
 140
 141 LRESULT STDCALL
 142 CallWindowProcA(WNDPROC lpPrevWndFunc,
 143                 HWND hWnd,
 144                 UINT Msg,
 145                 WPARAM wParam,
 146                 LPARAM lParam)
 147 {
 148   if (IsWindowUnicode(hWnd))
 149     {
 150       LRESULT Result;
 151       User32ConvertToUnicodeMessage(&Msg, &wParam, &lParam);
 152       Result = lpPrevWndFunc(hWnd, Msg, wParam, lParam);
 153       User32FreeUnicodeConvertedMessage(Msg, wParam, lParam);
 154       return(Result);
 155     }
 156   else
 157     {
 158       return(lpPrevWndFunc(hWnd, Msg, wParam, lParam));
 159     }
 160 }
 161
 162 LRESULT STDCALL
 163 CallWindowProcW(WNDPROC lpPrevWndFunc,
 164                 HWND hWnd,
 165                 UINT Msg,
 166                 WPARAM wParam,
 167                 LPARAM lParam)
 168 {
 169   if (!IsWindowUnicode(hWnd))
 170     {
 171       LRESULT Result;
 172       User32ConvertToAsciiMessage(&Msg, &wParam, &lParam);
 173       Result = lpPrevWndFunc(hWnd, Msg, wParam, lParam);
 174       User32FreeAsciiConvertedMessage(Msg, wParam, lParam);
 175       return(Result);
 176     }
 177   else
 178     {
 179       return(lpPrevWndFunc(hWnd, Msg, wParam, lParam));
 180     }
 181 }
 182
 183
 184 BOOL
 185 MsgiAnsiToUnicodeMessage(LPMSG UnicodeMsg, LPMSG AnsiMsg)
 186 {
 187   *UnicodeMsg = *AnsiMsg;
 188   switch (AnsiMsg->message)
 189     {
 190     case WM_GETTEXT:
 191       {
 192         UnicodeMsg->wParam = UnicodeMsg->wParam / 2;
 193         break;
 194       }
 195     }
 196   return(TRUE);
 197 }
 198
 199 BOOL
 200 MsgiAnsiToUnicodeReply(LPMSG UnicodeMsg, LPMSG AnsiMsg, LRESULT Result)
 201 {
 202   switch (AnsiMsg->message)
 203     {
 204     case WM_GETTEXT:
 205       {
 206         ANSI_STRING AnsiString;
 207         UNICODE_STRING UnicodeString;
 208         LPWSTR TempString;
 209         LPWSTR InString;
 210         InString = (LPWSTR)UnicodeMsg->lParam;
 211         TempString = RtlAllocateHeap(RtlGetProcessHeap(), 0,
 212                                      wcslen(InString) * sizeof(WCHAR));
 213         wcscpy(TempString, InString);
 214         RtlInitUnicodeString(&UnicodeString, TempString);
 215         AnsiString.Length = AnsiMsg->wParam;
 216         AnsiString.MaximumLength = AnsiMsg->wParam;
 217         AnsiString.Buffer = (PSTR)AnsiMsg->lParam;
 218         RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
 219         RtlFreeHeap(RtlGetProcessHeap(), 0, TempString);
 220         break;
 221       }
 222     }
 223   return(TRUE);
 224 }
 225
 226
 227 LRESULT STDCALL
 228 DispatchMessageA(CONST MSG *lpmsg)
 229 {
 230   return(NtUserDispatchMessage(lpmsg));
 231 }
 232
 233 LRESULT STDCALL
 234 DispatchMessageW(CONST MSG *lpmsg)
 235 {
 236   return(NtUserDispatchMessage((LPMSG)lpmsg));
 237 }
 238
 239 WINBOOL
 240 STDCALL
 241 GetMessageA(
 242   LPMSG lpMsg,
 243   HWND hWnd,
 244   UINT wMsgFilterMin,
 245   UINT wMsgFilterMax)
 246 {
 247   return NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
 248 }
 249
 250 WINBOOL
 251 STDCALL
 252 GetMessageW(
 253   LPMSG lpMsg,
 254   HWND hWnd,
 255   UINT wMsgFilterMin,
 256   UINT wMsgFilterMax)
 257 {
 258   return NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
 259 }
 260
 261 WINBOOL
 262 STDCALL
 263 PeekMessageA(
 264   LPMSG lpMsg,
 265   HWND hWnd,
 266   UINT wMsgFilterMin,
 267   UINT wMsgFilterMax,
 268   UINT wRemoveMsg)
 269 {
 270   return NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 271 }
 272
 273 WINBOOL
 274 STDCALL
 275 PeekMessageW(
 276   LPMSG lpMsg,
 277   HWND hWnd,
 278   UINT wMsgFilterMin,
 279   UINT wMsgFilterMax,
 280   UINT wRemoveMsg)
 281 {
 282   return NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
 283 }
 284
 285 WINBOOL
 286 STDCALL
 287 PostMessageA(
 288   HWND hWnd,
 289   UINT Msg,
 290   WPARAM wParam,
 291   LPARAM lParam)
 292 {
 293   return NtUserPostMessage(hWnd, Msg, wParam, lParam);
 294 }
 295
 296 WINBOOL
 297 STDCALL
 298 PostMessageW(
 299   HWND hWnd,
 300   UINT Msg,
 301   WPARAM wParam,
 302   LPARAM lParam)
 303 {
 304   return NtUserPostMessage(hWnd, Msg, wParam, lParam);
 305 }
 306
 307 VOID
 308 STDCALL
 309 PostQuitMessage(
 310   int nExitCode)
 311 {
 312   (void) NtUserPostMessage(NULL, WM_QUIT, nExitCode, 0);
 313 }
 314
 315 WINBOOL
 316 STDCALL
 317 PostThreadMessageA(
 318   DWORD idThread,
 319   UINT Msg,
 320   WPARAM wParam,
 321   LPARAM lParam)
 322 {
 323   return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
 324 }
 325
 326 WINBOOL
 327 STDCALL
 328 PostThreadMessageW(
 329   DWORD idThread,
 330   UINT Msg,
 331   WPARAM wParam,
 332   LPARAM lParam)
 333 {
 334   return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
 335 }
 336
 337 LRESULT STDCALL
 338 SendMessageW(HWND hWnd,
 339              UINT Msg,
 340              WPARAM wParam,
 341              LPARAM lParam)
 342 {
 343   return(NtUserSendMessage(hWnd, Msg, wParam, lParam));
 344 }
 345
 346
 347 LRESULT STDCALL
 348 SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
 349 {
 350   MSG AnsiMsg;
 351   MSG UcMsg;
 352   LRESULT Result;
 353
 354   AnsiMsg.hwnd = hWnd;
 355   AnsiMsg.message = Msg;
 356   AnsiMsg.wParam = wParam;
 357   AnsiMsg.lParam = lParam;
 358
 359   if (!MsgiAnsiToUnicodeMessage(&UcMsg, &AnsiMsg))
 360     {
 361       return(FALSE);
 362     }
 363   Result = SendMessageW(UcMsg.hwnd, UcMsg.message, UcMsg.wParam, UcMsg.lParam);
 364   if (!MsgiAnsiToUnicodeReply(&UcMsg, &AnsiMsg, Result))
 365     {
 366       return(FALSE);
 367     }
 368   return(Result);
 369 }
 370
 371 WINBOOL
 372 STDCALL
 373 SendMessageCallbackA(
 374   HWND hWnd,
 375   UINT Msg,
 376   WPARAM wParam,
 377   LPARAM lParam,
 378   SENDASYNCPROC lpCallBack,
 379   ULONG_PTR dwData)
 380 {
 381   return NtUserSendMessageCallback(
 382     hWnd,
 383     Msg,
 384     wParam,
 385     lParam,
 386     lpCallBack,
 387     dwData);
 388 }
 389
 390 WINBOOL
 391 STDCALL
 392 SendMessageCallbackW(
 393   HWND hWnd,
 394   UINT Msg,
 395   WPARAM wParam,
 396   LPARAM lParam,
 397   SENDASYNCPROC lpCallBack,
 398   ULONG_PTR dwData)
 399 {
 400   return NtUserSendMessageCallback(
 401     hWnd,
 402     Msg,
 403     wParam,
 404     lParam,
 405     lpCallBack,
 406     dwData);
 407 }
 408
 409 LRESULT
 410 STDCALL
 411 SendMessageTimeoutA(
 412   HWND hWnd,
 413   UINT Msg,
 414   WPARAM wParam,
 415   LPARAM lParam,
 416   UINT fuFlags,
 417   UINT uTimeout,
 418   PDWORD_PTR lpdwResult)
 419 {
 420   return (LRESULT)0;
 421 }
 422
 423 LRESULT
 424 STDCALL
 425 SendMessageTimeoutW(
 426   HWND hWnd,
 427   UINT Msg,
 428   WPARAM wParam,
 429   LPARAM lParam,
 430   UINT fuFlags,
 431   UINT uTimeout,
 432   PDWORD_PTR lpdwResult)
 433 {
 434   return (LRESULT)0;
 435 }
 436
 437
 438
 439 WINBOOL
 440 STDCALL
 441 SendNotifyMessageA(
 442   HWND hWnd,
 443   UINT Msg,
 444   WPARAM wParam,
 445   LPARAM lParam)
 446 {
 447   return FALSE;
 448 }
 449
 450 WINBOOL
 451 STDCALL
 452 SendNotifyMessageW(
 453   HWND hWnd,
 454   UINT Msg,
 455   WPARAM wParam,
 456   LPARAM lParam)
 457 {
 458   return FALSE;
 459 }
 460
 461 WINBOOL STDCALL
 462 TranslateMessage(CONST MSG *lpMsg)
 463 {
 464   return(NtUserTranslateMessage((LPMSG)lpMsg, 0));
 465 }
 466
 467 WINBOOL
 468 STDCALL
 469 WaitMessage(VOID)
 470 {
 471   return FALSE;
 472 }
 473
 474 UINT STDCALL
 475 RegisterWindowMessageA(LPCSTR lpString)
 476 {
 477   UNICODE_STRING String;
 478   BOOLEAN Result;
 479   UINT Atom;
 480
 481   Result = RtlCreateUnicodeStringFromAsciiz(&String, (PCSZ)lpString);
 482   if (!Result)
 483     {
 484       return(0);
 485     }
 486   Atom = NtUserRegisterWindowMessage(&String);
 487   RtlFreeUnicodeString(&String);
 488   return(Atom);
 489 }
 490
 491 UINT STDCALL
 492 RegisterWindowMessageW(LPCWSTR lpString)
 493 {
 494   UNICODE_STRING String;
 495
 496   RtlInitUnicodeString(&String, lpString);
 497   return(NtUserRegisterWindowMessage(&String));
 498 }
 499
 500
 501 /* EOF */