lib/user32/windows/message.c

   1 /* $Id$
   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 }
 313
 314 WINBOOL
 315 STDCALL
 316 PostThreadMessageA(
 317   DWORD idThread,
 318   UINT Msg,
 319   WPARAM wParam,
 320   LPARAM lParam)
 321 {
 322   return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
 323 }
 324
 325 WINBOOL
 326 STDCALL
 327 PostThreadMessageW(
 328   DWORD idThread,
 329   UINT Msg,
 330   WPARAM wParam,
 331   LPARAM lParam)
 332 {
 333   return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
 334 }
 335
 336 LRESULT STDCALL
 337 SendMessageW(HWND hWnd,
 338              UINT Msg,
 339              WPARAM wParam,
 340              LPARAM lParam)
 341 {
 342   return(NtUserSendMessage(hWnd, Msg, wParam, lParam));
 343 }
 344
 345
 346 LRESULT STDCALL
 347 SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
 348 {
 349   MSG AnsiMsg;
 350   MSG UcMsg;
 351   LRESULT Result;
 352
 353   AnsiMsg.hwnd = hWnd;
 354   AnsiMsg.message = Msg;
 355   AnsiMsg.wParam = wParam;
 356   AnsiMsg.lParam = lParam;
 357
 358   if (!MsgiAnsiToUnicodeMessage(&UcMsg, &AnsiMsg))
 359     {
 360       return(FALSE);
 361     }
 362   Result = SendMessageW(UcMsg.hwnd, UcMsg.message, UcMsg.wParam, UcMsg.lParam);
 363   if (!MsgiAnsiToUnicodeReply(&UcMsg, &AnsiMsg, Result))
 364     {
 365       return(FALSE);
 366     }
 367   return(Result);
 368 }
 369
 370 WINBOOL
 371 STDCALL
 372 SendMessageCallbackA(
 373   HWND hWnd,
 374   UINT Msg,
 375   WPARAM wParam,
 376   LPARAM lParam,
 377   SENDASYNCPROC lpCallBack,
 378   ULONG_PTR dwData)
 379 {
 380   return NtUserSendMessageCallback(
 381     hWnd,
 382     Msg,
 383     wParam,
 384     lParam,
 385     lpCallBack,
 386     dwData);
 387 }
 388
 389 WINBOOL
 390 STDCALL
 391 SendMessageCallbackW(
 392   HWND hWnd,
 393   UINT Msg,
 394   WPARAM wParam,
 395   LPARAM lParam,
 396   SENDASYNCPROC lpCallBack,
 397   ULONG_PTR dwData)
 398 {
 399   return NtUserSendMessageCallback(
 400     hWnd,
 401     Msg,
 402     wParam,
 403     lParam,
 404     lpCallBack,
 405     dwData);
 406 }
 407
 408 LRESULT
 409 STDCALL
 410 SendMessageTimeoutA(
 411   HWND hWnd,
 412   UINT Msg,
 413   WPARAM wParam,
 414   LPARAM lParam,
 415   UINT fuFlags,
 416   UINT uTimeout,
 417   PDWORD_PTR lpdwResult)
 418 {
 419   return (LRESULT)0;
 420 }
 421
 422 LRESULT
 423 STDCALL
 424 SendMessageTimeoutW(
 425   HWND hWnd,
 426   UINT Msg,
 427   WPARAM wParam,
 428   LPARAM lParam,
 429   UINT fuFlags,
 430   UINT uTimeout,
 431   PDWORD_PTR lpdwResult)
 432 {
 433   return (LRESULT)0;
 434 }
 435
 436
 437
 438 WINBOOL
 439 STDCALL
 440 SendNotifyMessageA(
 441   HWND hWnd,
 442   UINT Msg,
 443   WPARAM wParam,
 444   LPARAM lParam)
 445 {
 446   return FALSE;
 447 }
 448
 449 WINBOOL
 450 STDCALL
 451 SendNotifyMessageW(
 452   HWND hWnd,
 453   UINT Msg,
 454   WPARAM wParam,
 455   LPARAM lParam)
 456 {
 457   return FALSE;
 458 }
 459
 460 WINBOOL STDCALL
 461 TranslateMessage(CONST MSG *lpMsg)
 462 {
 463   return(NtUserTranslateMessage((LPMSG)lpMsg, 0));
 464 }
 465
 466 WINBOOL
 467 STDCALL
 468 WaitMessage(VOID)
 469 {
 470   return FALSE;
 471 }
 472
 473 UINT STDCALL
 474 RegisterWindowMessageA(LPCSTR lpString)
 475 {
 476   UNICODE_STRING String;
 477   BOOLEAN Result;
 478   UINT Atom;
 479
 480   Result = RtlCreateUnicodeStringFromAsciiz(&String, (PCSZ)lpString);
 481   if (!Result)
 482     {
 483       return(0);
 484     }
 485   Atom = RegisterWindowMessageW(String.Buffer);
 486   RtlFreeUnicodeString(&String);
 487   return(Atom);
 488 }
 489
 490 UINT STDCALL
 491 RegisterWindowMessageW(LPCWSTR lpString)
 492 {
 493   return(NtUserRegisterWindowMessage(lpString));
 494 }
 495
 496
 497 /* EOF */