reactos/lib/user32/windows/message.c

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