void
Test_OneParamRoutine_SwapMouseButtons(void) /* 0x42 */
{
BOOL bInverse;
NtUserCallOneParam(TRUE, _ONEPARAM_ROUTINE_SWAPMOUSEBUTTON);
bInverse = (BOOL)NtUserCallOneParam(FALSE, _ONEPARAM_ROUTINE_SWAPMOUSEBUTTON);
TEST(bInverse == TRUE);
bInverse = (BOOL)NtUserCallOneParam(FALSE, _ONEPARAM_ROUTINE_SWAPMOUSEBUTTON);
TEST(bInverse == FALSE);
// TODO: test other values
}
void
Test_OneParamRoutine_CreateEmptyCurObject(void) /* XP/2k3 : 0x21, vista 0x25 */
{
HICON hIcon ;
/* Test 0 */
hIcon = (HICON) NtUserCallOneParam(0, _ONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT);
TEST(hIcon != NULL);
TEST(NtUserDestroyCursor(hIcon, 0) == TRUE);
/* Test Garbage */
hIcon = (HICON) NtUserCallOneParam(0xdeadbeef, _ONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT);
TEST(hIcon != NULL);
TEST(NtUserDestroyCursor(hIcon, 0xbaadf00d) == TRUE);
}
void
Test_OneParamRoutine_MapDesktopObject(void) /* 0x30 */
{
DWORD pObject;
HWND hWnd;
HMENU hMenu;
hWnd = GetDesktopWindow();
pObject = NtUserCallOneParam((DWORD)hWnd, _ONEPARAM_ROUTINE_MAPDEKTOPOBJECT);
TEST(pObject > 0);
TEST(pObject < 0x80000000);
hMenu = CreateMenu();
pObject = NtUserCallOneParam((DWORD)hMenu, _ONEPARAM_ROUTINE_MAPDEKTOPOBJECT);
DestroyMenu(hMenu);
TEST(pObject > 0);
TEST(pObject < 0x80000000);
}
void
Test_OneParamRoutine_BeginDeferWindowPos(void) /* 0x1e */
{
HDWP hWinPosInfo;
hWinPosInfo = (HDWP)NtUserCallOneParam(5, 0x1e);
TEST(hWinPosInfo != 0);
TEST(EndDeferWindowPos(hWinPosInfo) != 0);
}
void
Test_OneParamRoutine_WindowFromDC(void) /* 0x1f */
{
HDC hDC = GetDC(NULL);
HWND hWnd;
hWnd = (HWND)NtUserCallOneParam((DWORD)hDC, 0x1f);
TEST(hWnd != 0);
TEST(IsWindow(hWnd));
TEST(hWnd == GetDesktopWindow());
}
UINT InternalDdeInitialize(
LPDWORD pidInst,
PFNCALLBACK pfnCallback,
DWORD afCmd,
BOOL fUnicode)
{
UINT uiRet = DMLERR_MEMORY_ERROR;
register PCL_INSTANCE_INFO pcii;
if (afCmd & APPCLASS_MONITOR) {
afCmd |= CBF_MONMASK;
}
if (afCmd & APPCMD_CLIENTONLY) {
afCmd |= CBF_FAIL_CONNECTIONS;
}
EnterDDECrit;
if (*pidInst != 0) {
pcii = ValidateInstance((HANDLE)LongToHandle( *pidInst ));
if (pcii == NULL) {
uiRet = DMLERR_INVALIDPARAMETER;
goto Exit;
}
// only allow certain bits to be changed on reinitialize call
pcii->afCmd = (pcii->afCmd & ~(CBF_MASK | MF_MASK)) |
(afCmd & (CBF_MASK | MF_MASK));
LeaveDDECrit;
NtUserUpdateInstance(pcii->hInstServer, &pcii->MonitorFlags, afCmd);
return (DMLERR_NO_ERROR);
}
pcii = (PCL_INSTANCE_INFO)DDEMLAlloc(sizeof(CL_INSTANCE_INFO));
if (pcii == NULL) {
uiRet = DMLERR_MEMORY_ERROR;
goto Exit;
}
pcii->plaNameService = (LATOM *)DDEMLAlloc(sizeof(LATOM));
if (pcii->plaNameService == NULL) {
uiRet = DMLERR_MEMORY_ERROR;
goto Backout3;
}
// *pcii->plaNameService = 0; // zero init takes care of this
pcii->cNameServiceAlloc = 1;
/*
* Flag this window as being create from a diff hmod as the app so
* hotkeys don't take it as the first window created in the app and
* assign it as the hotkey.
*/
pcii->hwndMother = _CreateWindowEx(0, (LPTSTR)(gpsi->atomSysClass[ICLS_DDEMLMOTHER]), L"",
WS_POPUP, 0, 0, 0, 0, (HWND)0,
(HMENU)0, 0, (LPVOID)NULL, CW_FLAGS_DIFFHMOD);
if (pcii->hwndMother == 0) {
uiRet = DMLERR_SYS_ERROR;
goto Backout2;
}
SetWindowLongPtr(pcii->hwndMother, GWLP_INSTANCE_INFO, (LONG_PTR)pcii);
pcii->afCmd = afCmd | APPCMD_FILTERINITS;
pcii->pfnCallback = pfnCallback;
// pcii->LastError = DMLERR_NO_ERROR; // zero init
pcii->tid = GetCurrentThreadId();
// pcii->aServerLookup = NULL; // zero init
// pcii->cServerLookupAlloc = 0; // zero init
// pcii->ConvStartupState = 0; // zero init - Not blocked.
// pcii->flags = 0; // zero init
// pcii->cInDDEMLCallback = 0; // zero init
// pcii->pLinkCounts = NULL; // zero init
// Do this last when the client side is ready for whatever events
// flying around may come charging in.
LeaveDDECrit;
uiRet = NtUserDdeInitialize(&pcii->hInstServer,
&pcii->hwndEvent,
&pcii->MonitorFlags,
pcii->afCmd,
pcii);
EnterDDECrit;
if (uiRet != DMLERR_NO_ERROR) {
Backout:
NtUserDestroyWindow(pcii->hwndMother);
Backout2:
DDEMLFree(pcii->plaNameService);
Backout3:
DDEMLFree(pcii);
goto Exit;
}
pcii->hInstClient = AddInstance(pcii->hInstServer);
*pidInst = HandleToUlong(pcii->hInstClient);
if (pcii->hInstClient == 0) {
LeaveDDECrit;
NtUserCallOneParam((ULONG_PTR)pcii->hInstServer, SFI__CSDDEUNINITIALIZE);
EnterDDECrit;
uiRet = DMLERR_MEMORY_ERROR;
goto Backout;
}
SetHandleData(pcii->hInstClient, (ULONG_PTR)pcii);
pcii->next = pciiList;
pciiList = pcii;
if (fUnicode) {
pcii->flags |= IIF_UNICODE;
}
uiRet = DMLERR_NO_ERROR;
Exit:
LeaveDDECrit;
return (uiRet);
}
/***************************************************************************\
* DdeUninitialize (DDEML API)
*
* Description:
* Shuts down a DDEML instance and frees all associated resources.
*
* History:
* 11-12-91 sanfords Created.
\***************************************************************************/
BOOL DdeUninitialize(
DWORD idInst)
{
PCL_INSTANCE_INFO pcii, pciiPrev;
BOOL fRet = FALSE;
CheckDDECritOut;
EnterDDECrit;
pcii = ValidateInstance((HANDLE)LongToHandle( idInst ));
if (pcii == NULL) {
BestSetLastDDEMLError(DMLERR_INVALIDPARAMETER);
goto Exit;
}
/*
* If this thread is in the middle of a synchronous transaction or
* a callback, we need to back out of those first.
*/
if ((pcii->flags & IIF_IN_SYNC_XACT) || pcii->cInDDEMLCallback) {
pcii->afCmd |= APPCMD_UNINIT_ASAP;
fRet = TRUE;
goto Exit;
}
ApplyFunctionToObjects(HTYPE_CONVERSATION_LIST, InstFromHandle(pcii->hInstClient),
(PFNHANDLEAPPLY)DdeDisconnectList);
ApplyFunctionToObjects(HTYPE_CLIENT_CONVERSATION, InstFromHandle(pcii->hInstClient),
(PFNHANDLEAPPLY)DdeDisconnect);
ApplyFunctionToObjects(HTYPE_SERVER_CONVERSATION, InstFromHandle(pcii->hInstClient),
(PFNHANDLEAPPLY)DdeDisconnect);
ApplyFunctionToObjects(HTYPE_ZOMBIE_CONVERSATION, InstFromHandle(pcii->hInstClient),
(PFNHANDLEAPPLY)WaitForZombieTerminate);
ApplyFunctionToObjects(HTYPE_DATA_HANDLE, InstFromHandle(pcii->hInstClient),
(PFNHANDLEAPPLY)ApplyFreeDataHandle);
LeaveDDECrit;
NtUserCallOneParam((ULONG_PTR)pcii->hInstServer, SFI__CSDDEUNINITIALIZE);
NtUserDestroyWindow(pcii->hwndMother);
EnterDDECrit;
DDEMLFree(pcii->plaNameService);
DestroyInstance(pcii->hInstClient);
// unlink pcii from pciiList
if (pciiList == pcii) {
pciiList = pciiList->next;
} else {
for (pciiPrev = pciiList; pciiPrev != NULL && pciiPrev->next != pcii;
pciiPrev = pciiPrev->next) {
;
}
if (pciiPrev != NULL) {
pciiPrev->next = pcii->next;
}
}
DDEMLFree(pcii);
fRet = TRUE;
Exit:
LeaveDDECrit;
return (fRet);
}
DWORD _GetClassData(
PCLS pcls,
PWND pwnd, // used for transition to kernel-mode for GCL_WNDPROC
int index,
BOOL bAnsi)
{
DWORD dwData;
DWORD dwCPDType = 0;
index -= INDEX_OFFSET;
if (index < 0) {
RIPERR0(ERROR_INVALID_INDEX, RIP_VERBOSE, "");
return 0;
}
UserAssert(index >= 0);
UserAssert(index < sizeof(afClassDWord));
UserAssert(sizeof(afClassDWord) == sizeof(aiClassOffset));
if (afClassDWord[index]) {
dwData = *(DWORD *)(((BYTE *)pcls) + aiClassOffset[index]);
} else {
dwData = (DWORD)*(WORD *)(((BYTE *)pcls) + aiClassOffset[index]);
}
index += INDEX_OFFSET;
/*
* If we're returning an icon or cursor handle, do the reverse
* mapping here.
*/
switch(index) {
case GCL_MENUNAME:
if (pcls->lpszMenuName != MAKEINTRESOURCE(pcls->lpszMenuName)) {
/*
* The Menu Name is a real string: return the client-side address.
* (If the class was registered by another app this returns an
* address in that app's addr. space, but it's the best we can do)
*/
dwData = bAnsi ?
(DWORD)pcls->lpszClientAnsiMenuName :
(DWORD)pcls->lpszClientUnicodeMenuName;
}
break;
case GCL_HICON:
case GCL_HCURSOR:
case GCL_HICONSM:
/*
* We have to go to the kernel to convert the pcursor to a handle because
* cursors are allocated out of POOL, which is not accessable from the client.
*/
if (dwData) {
dwData = NtUserCallOneParam(dwData, SFI_KERNELPTOH);
}
break;
case GCL_WNDPROC:
{
/*
* Always return the client wndproc in case this is a server
* window class.
*/
if (pcls->flags & CSF_SERVERSIDEPROC) {
dwData = MapServerToClientPfn(dwData, bAnsi);
} else {
DWORD dwT = dwData;
dwData = MapClientNeuterToClientPfn(pcls, dwT, bAnsi);
/*
* If the client mapping didn't change the window proc then see if
* we need a callproc handle.
*/
if (dwData == dwT) {
/*
* Need to return a CallProc handle if there is an Ansi/Unicode mismatch
*/
if (bAnsi != !!(pcls->flags & CSF_ANSIPROC)) {
dwCPDType |= bAnsi ? CPD_ANSI_TO_UNICODE : CPD_UNICODE_TO_ANSI;
}
}
}
if (dwCPDType) {
DWORD dwCPD;
dwCPD = GetCPD(pwnd, dwCPDType | CPD_WNDTOCLS, dwData);
if (dwCPD) {
dwData = dwCPD;
} else {
RIPMSG0(RIP_WARNING, "GetClassLong unable to alloc CPD returning handle\n");
}
}
}
break;
/*
* WOW uses a pointer straight into the class structure.
*/
case GCL_WOWWORDS:
return (DWORD) pcls->adwWOW;
}
return dwData;
}
