#include <string.h>
#include <debug.h>
+/*
+ * @implemented
+ */
LPARAM
STDCALL
GetMessageExtraInfo(VOID)
{
+ UNIMPLEMENTED;
return (LPARAM)0;
}
+
+/*
+ * @implemented
+ */
DWORD
STDCALL
GetMessagePos(VOID)
{
- return 0;
+ PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
+ return(MAKELONG(ThreadData->LastMessage.pt.x, ThreadData->LastMessage.pt.y));
}
-LONG
-STDCALL
+
+/*
+ * @implemented
+ */
+LONG STDCALL
GetMessageTime(VOID)
{
- return 0;
+ PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
+ return(ThreadData->LastMessage.time);
}
+
+
+/*
+ * @unimplemented
+ */
WINBOOL
STDCALL
InSendMessage(VOID)
return FALSE;
}
+
+/*
+ * @unimplemented
+ */
DWORD
STDCALL
InSendMessageEx(
LPVOID lpReserved)
{
+ UNIMPLEMENTED;
return 0;
}
+
+
+/*
+ * @unimplemented
+ */
WINBOOL
STDCALL
ReplyMessage(
LRESULT lResult)
{
+ UNIMPLEMENTED;
return FALSE;
}
+
+
+/*
+ * @unimplemented
+ */
LPARAM
STDCALL
SetMessageExtraInfo(
LPARAM lParam)
{
+ UNIMPLEMENTED;
return (LPARAM)0;
}
+
VOID STATIC
User32FreeAsciiConvertedMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
{
LPSTR TempString;
LPSTR InString;
InString = (LPSTR)lParam;
- TempString = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(InString));
+ TempString = RtlAllocateHeap(RtlGetProcessHeap(), 0, strlen(InString) + 1);
strcpy(TempString, InString);
RtlInitAnsiString(&AnsiString, TempString);
- UnicodeString.Length = wParam;
- UnicodeString.MaximumLength = wParam;
+ UnicodeString.Length = wParam * sizeof(WCHAR);
+ UnicodeString.MaximumLength = wParam * sizeof(WCHAR);
UnicodeString.Buffer = (PWSTR)lParam;
- RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
+ if (! NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeString,
+ &AnsiString,
+ FALSE)))
+ {
+ if (1 <= wParam)
+ {
+ UnicodeString.Buffer[0] = L'\0';
+ }
+ }
RtlFreeHeap(RtlGetProcessHeap(), 0, TempString);
break;
}
+ case WM_SETTEXT:
+ {
+ ANSI_STRING AnsiString;
+ RtlInitAnsiString(&AnsiString, (PSTR) lParam);
+ RtlFreeAnsiString(&AnsiString);
+ break;
+ }
case WM_NCCREATE:
{
CREATESTRUCTA* Cs;
Cs = (CREATESTRUCTA*)lParam;
RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszName);
- RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszClass);
+ if (HIWORD((ULONG)Cs->lpszClass) != 0)
+ {
+ RtlFreeHeap(RtlGetProcessHeap(), 0, (LPSTR)Cs->lpszClass);
+ }
RtlFreeHeap(RtlGetProcessHeap(), 0, Cs);
break;
}
}
}
+
VOID STATIC
User32ConvertToAsciiMessage(UINT* Msg, WPARAM* wParam, LPARAM* lParam)
{
RtlInitUnicodeString(&UString, CsW->lpszName);
RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
CsA->lpszName = AString.Buffer;
-
- RtlInitUnicodeString(&UString, CsW->lpszClass);
- RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
- CsA->lpszClass = AString.Buffer;
-
+ if (HIWORD((ULONG)CsW->lpszClass) != 0)
+ {
+ RtlInitUnicodeString(&UString, CsW->lpszClass);
+ RtlUnicodeStringToAnsiString(&AString, &UString, TRUE);
+ CsA->lpszClass = AString.Buffer;
+ }
(*lParam) = (LPARAM)CsA;
break;
}
+ case WM_SETTEXT:
+ {
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ RtlInitUnicodeString(&UnicodeString, (PWSTR) *lParam);
+ if (NT_SUCCESS(RtlUnicodeStringToAnsiString(&AnsiString,
+ &UnicodeString,
+ TRUE)))
+ {
+ *lParam = (LPARAM) AnsiString.Buffer;
+ }
+ break;
+ }
}
- return;
}
+
VOID STATIC
User32FreeUnicodeConvertedMessage(UINT Msg, WPARAM wParam, LPARAM lParam)
{
+ UNIMPLEMENTED;
}
+
VOID STATIC
User32ConvertToUnicodeMessage(UINT* Msg, WPARAM* wParam, LPARAM* lParam)
{
+ UNIMPLEMENTED;
}
+
+/*
+ * @implemented
+ */
LRESULT STDCALL
CallWindowProcA(WNDPROC lpPrevWndFunc,
HWND hWnd,
WPARAM wParam,
LPARAM lParam)
{
+ BOOL IsHandle;
+ if ((DWORD)lpPrevWndFunc > 0x80000000)
+ {
+ lpPrevWndFunc -= 0x80000000;
+ IsHandle = TRUE;
+ }
+ else
+ {
+ IsHandle = FALSE;
+ }
if (IsWindowUnicode(hWnd))
{
LRESULT Result;
}
}
+
+/*
+ * @implemented
+ */
LRESULT STDCALL
CallWindowProcW(WNDPROC lpPrevWndFunc,
HWND hWnd,
WPARAM wParam,
LPARAM lParam)
{
+ BOOL IsHandle;
+ if ((DWORD)lpPrevWndFunc > 0x80000000)
+ {
+ lpPrevWndFunc-= 0x80000000;
+ IsHandle = TRUE;
+ }
+ else
+ {
+ IsHandle = FALSE;
+ }
if (!IsWindowUnicode(hWnd))
{
LRESULT Result;
UnicodeMsg->wParam = UnicodeMsg->wParam / 2;
break;
}
+ case WM_SETTEXT:
+ {
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ RtlInitAnsiString(&AnsiString, (PSTR) AnsiMsg->lParam);
+ if (! NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeString,
+ &AnsiString,
+ TRUE)))
+ {
+ return FALSE;
+ }
+ UnicodeMsg->lParam = (LPARAM) UnicodeString.Buffer;
+ break;
+ }
}
- return(TRUE);
+ return TRUE;
}
+
BOOL
MsgiAnsiToUnicodeReply(LPMSG UnicodeMsg, LPMSG AnsiMsg, LRESULT Result)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, TempString);
break;
}
+ case WM_SETTEXT:
+ {
+ UNICODE_STRING UnicodeString;
+ RtlInitUnicodeString(&UnicodeString, (PCWSTR) UnicodeMsg->lParam);
+ RtlFreeUnicodeString(&UnicodeString);
+ break;
+ }
}
return(TRUE);
}
+/*
+ * @implemented
+ */
LRESULT STDCALL
DispatchMessageA(CONST MSG *lpmsg)
{
return(NtUserDispatchMessage(lpmsg));
}
+
+/*
+ * @implemented
+ */
LRESULT STDCALL
DispatchMessageW(CONST MSG *lpmsg)
{
return(NtUserDispatchMessage((LPMSG)lpmsg));
}
-WINBOOL
-STDCALL
-GetMessageA(
- LPMSG lpMsg,
- HWND hWnd,
- UINT wMsgFilterMin,
- UINT wMsgFilterMax)
+
+/*
+ * @implemented
+ */
+WINBOOL STDCALL
+GetMessageA(LPMSG lpMsg,
+ HWND hWnd,
+ UINT wMsgFilterMin,
+ UINT wMsgFilterMax)
{
- return NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
+ BOOL Res;
+ PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
+
+ Res = NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
+ if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
+ {
+ ThreadData->LastMessage = *lpMsg;
+ }
+ return(Res);
}
-WINBOOL
-STDCALL
-GetMessageW(
- LPMSG lpMsg,
- HWND hWnd,
- UINT wMsgFilterMin,
- UINT wMsgFilterMax)
+
+/*
+ * @implemented
+ */
+WINBOOL STDCALL
+GetMessageW(LPMSG lpMsg,
+ HWND hWnd,
+ UINT wMsgFilterMin,
+ UINT wMsgFilterMax)
{
- return NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
+ BOOL Res;
+ PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
+
+ Res = NtUserGetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
+ if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
+ {
+ ThreadData->LastMessage = *lpMsg;
+ }
+ return(Res);
}
-WINBOOL
-STDCALL
-PeekMessageA(
- LPMSG lpMsg,
- HWND hWnd,
- UINT wMsgFilterMin,
- UINT wMsgFilterMax,
- UINT wRemoveMsg)
+
+/*
+ * @implemented
+ */
+WINBOOL STDCALL
+PeekMessageA(LPMSG lpMsg,
+ HWND hWnd,
+ UINT wMsgFilterMin,
+ UINT wMsgFilterMax,
+ UINT wRemoveMsg)
{
- return NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
+ BOOL Res;
+ PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
+
+ Res = NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
+ if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
+ {
+ ThreadData->LastMessage = *lpMsg;
+ }
+ return(Res);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
PeekMessageW(
UINT wMsgFilterMax,
UINT wRemoveMsg)
{
- return NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
+ BOOL Res;
+ PUSER32_THREAD_DATA ThreadData = User32GetThreadData();
+
+ Res = NtUserPeekMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax, wRemoveMsg);
+ if (Res && lpMsg->message != WM_PAINT && lpMsg->message != WM_QUIT)
+ {
+ ThreadData->LastMessage = *lpMsg;
+ }
+ return(Res);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
PostMessageA(
return NtUserPostMessage(hWnd, Msg, wParam, lParam);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
PostMessageW(
return NtUserPostMessage(hWnd, Msg, wParam, lParam);
}
+
+/*
+ * @implemented
+ */
VOID
STDCALL
PostQuitMessage(
(void) NtUserPostMessage(NULL, WM_QUIT, nExitCode, 0);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
PostThreadMessageA(
return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
PostThreadMessageW(
return NtUserPostThreadMessage(idThread, Msg, wParam, lParam);
}
+
+/*
+ * @implemented
+ */
LRESULT STDCALL
SendMessageW(HWND hWnd,
UINT Msg,
}
+/*
+ * @implemented
+ */
LRESULT STDCALL
SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
return(Result);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
SendMessageCallbackA(
dwData);
}
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
SendMessageCallbackW(
dwData);
}
+
+/*
+ * @implemented
+ */
LRESULT
STDCALL
SendMessageTimeoutA(
UINT uTimeout,
PDWORD_PTR lpdwResult)
{
+ UNIMPLEMENTED;
return (LRESULT)0;
}
+
+/*
+ * @implemented
+ */
LRESULT
STDCALL
SendMessageTimeoutW(
UINT uTimeout,
PDWORD_PTR lpdwResult)
{
+ UNIMPLEMENTED;
return (LRESULT)0;
}
-
+/*
+ * @unimplemented
+ */
WINBOOL
STDCALL
SendNotifyMessageA(
WPARAM wParam,
LPARAM lParam)
{
+ UNIMPLEMENTED;
return FALSE;
}
+
+/*
+ * @unimplemented
+ */
WINBOOL
STDCALL
SendNotifyMessageW(
WPARAM wParam,
LPARAM lParam)
{
+ UNIMPLEMENTED;
return FALSE;
}
+
+/*
+ * @implemented
+ */
WINBOOL STDCALL
TranslateMessage(CONST MSG *lpMsg)
{
- return(NtUserTranslateMessage((LPMSG)lpMsg, 0));
+ return(TranslateMessageEx((LPMSG)lpMsg, 0));
}
+/*
+ * @implemented
+ */
+WINBOOL STDCALL
+TranslateMessageEx(CONST MSG *lpMsg, DWORD unk)
+{
+ return(NtUserTranslateMessage((LPMSG)lpMsg, unk));
+}
+
+
+/*
+ * @implemented
+ */
WINBOOL
STDCALL
WaitMessage(VOID)
{
- return FALSE;
+ return NtUserWaitMessage();
}
+
+/*
+ * @implemented
+ */
UINT STDCALL
RegisterWindowMessageA(LPCSTR lpString)
{
{
return(0);
}
- Atom = RegisterWindowMessageW(String.Buffer);
+ Atom = NtUserRegisterWindowMessage(&String);
RtlFreeUnicodeString(&String);
return(Atom);
}
+
+/*
+ * @implemented
+ */
UINT STDCALL
RegisterWindowMessageW(LPCWSTR lpString)
{
- return(NtUserRegisterWindowMessage(lpString));
+ UNICODE_STRING String;
+
+ RtlInitUnicodeString(&String, lpString);
+ return(NtUserRegisterWindowMessage(&String));
+}
+
+/*
+ * @implemented
+ */
+HWND STDCALL
+SetCapture(HWND hWnd)
+{
+ return(NtUserSetCapture(hWnd));
+}
+
+/*
+ * @implemented
+ */
+HWND STDCALL
+GetCapture(VOID)
+{
+ return(NtUserGetCapture());
}
+/*
+ * @implemented
+ */
+WINBOOL STDCALL
+ReleaseCapture(VOID)
+{
+ NtUserSetCapture(NULL);
+ return(TRUE);
+}
+
+
+/*
+ * @unimplemented
+ */
+DWORD
+STDCALL
+GetQueueStatus(UINT flags)
+{
+ DWORD ret;
+ WORD changed_bits, wake_bits;
+
+#if 0 /* wine stuff. don't know what it does... */
+
+ /* check for pending X events */
+ if (USER_Driver.pMsgWaitForMultipleObjectsEx)
+ USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
+#endif
+
+ ret = NtUserGetQueueStatus(TRUE /*ClearChanges*/);
+
+ changed_bits = LOWORD(ret);
+ wake_bits = HIWORD(ret);
+
+ return MAKELONG(changed_bits & flags, wake_bits & flags);
+}
+
+
+/*
+ * @unimplemented
+ */
+WINBOOL STDCALL GetInputState(VOID)
+{
+ DWORD ret;
+ WORD wake_bits;
+
+#if 0 /* wine stuff. don't know what it does... */
+
+ /* check for pending X events */
+ if (USER_Driver.pMsgWaitForMultipleObjectsEx)
+ USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
+#endif
+
+ ret = NtUserGetQueueStatus(FALSE /*ClearChanges*/);
+
+ wake_bits = HIWORD(ret);
+
+ return wake_bits & (QS_KEY | QS_MOUSEBUTTON);
+}
+
+/*
+ * @implemented
+ */
+WINBOOL STDCALL SetMessageQueue(int cMessagesMax)
+{
+ /* Function does nothing on 32 bit windows */
+ return TRUE;
+}
+
+
/* EOF */
git://git.jankratochvil.net / reactos.git / blobdiff