mirror of
https://gitlab.winehq.org/wine/wine.git
synced 2024-11-21 17:09:06 -07:00
Compare commits
1 commit
a1757b7ad6
...
e287fe3b26
| Author | SHA1 | Date | |
|---|---|---|---|
|
e287fe3b26 |
57 changed files with 547 additions and 1542 deletions
1
configure
generated
vendored
1
configure
generated
vendored
|
|
@ -23070,7 +23070,6 @@ wine_fn_config_makefile programs/msidb enable_msidb
|
|||
wine_fn_config_makefile programs/msiexec enable_msiexec
|
||||
wine_fn_config_makefile programs/msinfo32 enable_msinfo32
|
||||
wine_fn_config_makefile programs/net enable_net
|
||||
wine_fn_config_makefile programs/net/tests enable_tests
|
||||
wine_fn_config_makefile programs/netsh enable_netsh
|
||||
wine_fn_config_makefile programs/netstat enable_netstat
|
||||
wine_fn_config_makefile programs/ngen enable_ngen
|
||||
|
|
|
|||
|
|
@ -3468,7 +3468,6 @@ WINE_CONFIG_MAKEFILE(programs/msidb)
|
|||
WINE_CONFIG_MAKEFILE(programs/msiexec)
|
||||
WINE_CONFIG_MAKEFILE(programs/msinfo32)
|
||||
WINE_CONFIG_MAKEFILE(programs/net)
|
||||
WINE_CONFIG_MAKEFILE(programs/net/tests)
|
||||
WINE_CONFIG_MAKEFILE(programs/netsh)
|
||||
WINE_CONFIG_MAKEFILE(programs/netstat)
|
||||
WINE_CONFIG_MAKEFILE(programs/ngen)
|
||||
|
|
|
|||
|
|
@ -300,6 +300,20 @@ BOOL WINAPI SymGetSearchPath(HANDLE hProcess, PSTR szSearchPath,
|
|||
return ret;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
* invade_process
|
||||
*
|
||||
* SymInitialize helper: loads in dbghelp all known (and loaded modules)
|
||||
* this assumes that hProcess is a handle on a valid process
|
||||
*/
|
||||
static BOOL WINAPI process_invade_cb(PCWSTR name, ULONG64 base, ULONG size, PVOID user)
|
||||
{
|
||||
HANDLE hProcess = user;
|
||||
|
||||
SymLoadModuleExW(hProcess, 0, name, NULL, base, size, NULL, 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
const WCHAR *process_getenv(const struct process *process, const WCHAR *name)
|
||||
{
|
||||
size_t name_len;
|
||||
|
|
@ -418,10 +432,7 @@ static BOOL check_live_target(struct process* pcs, BOOL wow64, BOOL child_wow64)
|
|||
|
||||
TRACE("got debug info address %#I64x from PEB %p\n", base, pbi.PebBaseAddress);
|
||||
if (!elf_read_wine_loader_dbg_info(pcs, base) && !macho_read_wine_loader_dbg_info(pcs, base))
|
||||
{
|
||||
WARN("couldn't load process debug info at %#I64x\n", base);
|
||||
pcs->loader = &empty_loader_ops;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -499,9 +510,8 @@ BOOL WINAPI SymInitializeW(HANDLE hProcess, PCWSTR UserSearchPath, BOOL fInvadeP
|
|||
if (check_live_target(pcs, wow64, child_wow64))
|
||||
{
|
||||
if (fInvadeProcess)
|
||||
module_refresh_list(pcs);
|
||||
else
|
||||
pcs->loader->synchronize_module_list(pcs);
|
||||
EnumerateLoadedModulesW64(hProcess, process_invade_cb, hProcess);
|
||||
if (pcs->loader) pcs->loader->synchronize_module_list(pcs);
|
||||
}
|
||||
else if (fInvadeProcess)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -743,7 +743,6 @@ extern BOOL module_remove(struct process* pcs,
|
|||
extern void module_set_module(struct module* module, const WCHAR* name);
|
||||
extern WCHAR* get_wine_loader_name(struct process *pcs) __WINE_DEALLOC(HeapFree, 3) __WINE_MALLOC;
|
||||
extern BOOL module_is_wine_host(const WCHAR* module_name, const WCHAR* ext);
|
||||
extern BOOL module_refresh_list(struct process *pcs);
|
||||
|
||||
/* msc.c */
|
||||
extern BOOL pe_load_debug_directory(const struct process* pcs,
|
||||
|
|
|
|||
|
|
@ -1785,6 +1785,7 @@ BOOL elf_read_wine_loader_dbg_info(struct process* pcs, ULONG_PTR addr)
|
|||
{
|
||||
ERR("Unable to access ELF libraries (outside 32bit limit)\n");
|
||||
module_remove(pcs, elf_info.module);
|
||||
pcs->loader = &empty_loader_ops;
|
||||
return FALSE;
|
||||
}
|
||||
TRACE("Found ELF debug header %#I64x\n", elf_info.dbg_hdr_addr);
|
||||
|
|
|
|||
|
|
@ -24,8 +24,6 @@
|
|||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "ntstatus.h"
|
||||
#define WIN32_NO_STATUS
|
||||
#include "dbghelp_private.h"
|
||||
#include "image_private.h"
|
||||
#include "psapi.h"
|
||||
|
|
@ -1319,11 +1317,7 @@ BOOL WINAPI EnumerateLoadedModulesW64(HANDLE process,
|
|||
size_t sysdir_len = 0, wowdir_len = 0;
|
||||
|
||||
/* process might not be a handle to a live process */
|
||||
if (!IsWow64Process2(process, &pcs_machine, &native_machine))
|
||||
{
|
||||
SetLastError(STATUS_INVALID_CID);
|
||||
return FALSE;
|
||||
}
|
||||
if (!IsWow64Process2(process, &pcs_machine, &native_machine)) return FALSE;
|
||||
with_32bit_modules = sizeof(void*) > sizeof(int) &&
|
||||
pcs_machine != IMAGE_FILE_MACHINE_UNKNOWN &&
|
||||
(dbghelp_options & SYMOPT_INCLUDE_32BIT_MODULES);
|
||||
|
|
@ -1606,41 +1600,18 @@ void module_reset_debug_info(struct module* module)
|
|||
module->sources = NULL;
|
||||
}
|
||||
|
||||
static BOOL WINAPI process_invade_cb(PCWSTR name, ULONG64 base, ULONG size, PVOID user)
|
||||
{
|
||||
HANDLE hProcess = user;
|
||||
|
||||
/* Note: this follows native behavior:
|
||||
* If a PE module has been unloaded from debuggee, it's not immediately removed
|
||||
* from module list in dbghelp.
|
||||
* Removal may eventually happen when loading a another module with SymLoadModule:
|
||||
* if the module to be loaded overlaps an existing one, SymLoadModule will
|
||||
* automatically unload the eldest one.
|
||||
*/
|
||||
SymLoadModuleExW(hProcess, 0, name, NULL, base, size, NULL, 0);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL module_refresh_list(struct process *pcs)
|
||||
{
|
||||
BOOL ret;
|
||||
|
||||
ret = pcs->loader->synchronize_module_list(pcs);
|
||||
ret = EnumerateLoadedModulesW64(pcs->handle, process_invade_cb, pcs->handle) && ret;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/******************************************************************
|
||||
* SymRefreshModuleList (DBGHELP.@)
|
||||
*/
|
||||
BOOL WINAPI SymRefreshModuleList(HANDLE hProcess)
|
||||
{
|
||||
struct process *pcs;
|
||||
struct process* pcs;
|
||||
|
||||
TRACE("(%p)\n", hProcess);
|
||||
|
||||
if (!(pcs = process_find_by_handle(hProcess))) return FALSE;
|
||||
return module_refresh_list(pcs);
|
||||
|
||||
return pcs->loader->synchronize_module_list(pcs);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
|
|
|||
|
|
@ -372,29 +372,6 @@ static unsigned get_native_module_count(HANDLE proc)
|
|||
return count;
|
||||
}
|
||||
|
||||
struct module_present
|
||||
{
|
||||
const WCHAR* module_name;
|
||||
BOOL found;
|
||||
};
|
||||
|
||||
static BOOL CALLBACK is_module_present_cb(const WCHAR* name, DWORD64 base, void* usr)
|
||||
{
|
||||
struct module_present* present = usr;
|
||||
if (!wcsicmp(name, present->module_name))
|
||||
{
|
||||
present->found = TRUE;
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL is_module_present(HANDLE proc, const WCHAR* module_name)
|
||||
{
|
||||
struct module_present present = { .module_name = module_name };
|
||||
return SymEnumerateModulesW64(proc, is_module_present_cb, &present) && present.found;
|
||||
}
|
||||
|
||||
struct nth_module
|
||||
{
|
||||
HANDLE proc;
|
||||
|
|
@ -447,28 +424,6 @@ static BOOL wrapper_EnumerateLoadedModulesW64(HANDLE proc, PENUMLOADED_MODULES_C
|
|||
return ret;
|
||||
}
|
||||
|
||||
/* wrapper around SymRefreshModuleList which sometimes fails (it's very likely implemented on top
|
||||
* of EnumerateLoadedModulesW64 on native too)
|
||||
*/
|
||||
static BOOL wrapper_SymRefreshModuleList(HANDLE proc)
|
||||
{
|
||||
BOOL ret;
|
||||
int retry;
|
||||
int retry_count = !strcmp(winetest_platform, "wine") ? 1 : 5;
|
||||
|
||||
for (retry = retry_count - 1; retry >= 0; retry--)
|
||||
{
|
||||
ret = SymRefreshModuleList(proc);
|
||||
if (ret || (GetLastError() != STATUS_INFO_LENGTH_MISMATCH && GetLastError() == STATUS_PARTIAL_COPY))
|
||||
break;
|
||||
Sleep(10);
|
||||
}
|
||||
if (retry + 1 < retry_count)
|
||||
trace("used wrapper retry: ret=%d retry=%d top=%d\n", ret, retry, retry_count);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static BOOL test_modules(void)
|
||||
{
|
||||
BOOL ret;
|
||||
|
|
@ -537,7 +492,6 @@ static BOOL test_modules(void)
|
|||
|
||||
ret = SymRefreshModuleList(dummy);
|
||||
ok(!ret, "SymRefreshModuleList should have failed\n");
|
||||
ok(GetLastError() == STATUS_INVALID_CID, "Unexpected last error %lx\n", GetLastError());
|
||||
|
||||
count = get_module_count(dummy);
|
||||
ok(count == 0, "Unexpected count (%u instead of 0)\n", count);
|
||||
|
|
@ -871,11 +825,6 @@ static void test_loaded_modules(void)
|
|||
ok(ret, "got error %lu\n", GetLastError());
|
||||
strcat(buffer, "\\msinfo32.exe");
|
||||
|
||||
/* testing invalid process handle */
|
||||
ret = wrapper_EnumerateLoadedModulesW64((HANDLE)(ULONG_PTR)0xffffffc0, NULL, FALSE);
|
||||
ok(!ret, "EnumerateLoadedModulesW64 should have failed\n");
|
||||
ok(GetLastError() == STATUS_INVALID_CID, "Unexpected last error %lx\n", GetLastError());
|
||||
|
||||
/* testing with child process of different machines */
|
||||
ret = CreateProcessA(NULL, buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
|
||||
ok(ret, "CreateProcess failed: %lu\n", GetLastError());
|
||||
|
|
@ -936,10 +885,9 @@ static void test_loaded_modules(void)
|
|||
|
||||
pcskind = get_process_kind(pi.hProcess);
|
||||
|
||||
ret = wrapper_SymRefreshModuleList(pi.hProcess);
|
||||
ok(ret || broken(GetLastError() == STATUS_PARTIAL_COPY /* Win11 in some cases */ ||
|
||||
GetLastError() == STATUS_INFO_LENGTH_MISMATCH /* Win11 in some cases */),
|
||||
"SymRefreshModuleList failed: %lx\n", GetLastError());
|
||||
ret = SymRefreshModuleList(pi.hProcess);
|
||||
todo_wine_if(pcskind == PCSKIND_WOW64)
|
||||
ok(ret || broken(GetLastError() == STATUS_PARTIAL_COPY /* Win11 in some cases */), "SymRefreshModuleList failed: %lu\n", GetLastError());
|
||||
|
||||
if (!strcmp(winetest_platform, "wine"))
|
||||
{
|
||||
|
|
@ -997,8 +945,8 @@ static void test_loaded_modules(void)
|
|||
"Wrong directory aggregation count %u %u\n",
|
||||
aggregation.count_systemdir, aggregation.count_wowdir);
|
||||
}
|
||||
ret = wrapper_SymRefreshModuleList(pi.hProcess);
|
||||
ok(ret, "SymRefreshModuleList failed: %lx\n", GetLastError());
|
||||
ret = SymRefreshModuleList(pi.hProcess);
|
||||
ok(ret, "SymRefreshModuleList failed: %lu\n", GetLastError());
|
||||
|
||||
if (!strcmp(winetest_platform, "wine"))
|
||||
{
|
||||
|
|
@ -1059,8 +1007,8 @@ static void test_loaded_modules(void)
|
|||
break;
|
||||
}
|
||||
|
||||
ret = wrapper_SymRefreshModuleList(pi.hProcess);
|
||||
ok(ret, "SymRefreshModuleList failed: %lx\n", GetLastError());
|
||||
ret = SymRefreshModuleList(pi.hProcess);
|
||||
ok(ret, "SymRefreshModuleList failed: %lu\n", GetLastError());
|
||||
|
||||
if (!strcmp(winetest_platform, "wine"))
|
||||
{
|
||||
|
|
@ -1581,75 +1529,6 @@ static void test_function_tables(void)
|
|||
SymCleanup(GetCurrentProcess());
|
||||
}
|
||||
|
||||
static void test_refresh_modules(void)
|
||||
{
|
||||
BOOL ret;
|
||||
unsigned count, count_current;
|
||||
HMODULE hmod;
|
||||
IMAGEHLP_MODULEW64 module_info = { .SizeOfStruct = sizeof(module_info) };
|
||||
|
||||
/* pick a DLL: which isn't already loaded by test, and that will not load other DLLs for deps */
|
||||
static const WCHAR* unused_dll = L"psapi";
|
||||
|
||||
ret = SymInitialize(GetCurrentProcess(), 0, TRUE);
|
||||
ok(ret, "SymInitialize failed: %lu\n", GetLastError());
|
||||
|
||||
count = get_module_count(GetCurrentProcess());
|
||||
ok(count, "Unexpected module count %u\n", count);
|
||||
|
||||
ret = SymCleanup(GetCurrentProcess());
|
||||
ok(ret, "SymCleanup failed: %lu\n", GetLastError());
|
||||
|
||||
ret = SymInitialize(GetCurrentProcess(), 0, FALSE);
|
||||
ok(ret, "SymInitialize failed: %lu\n", GetLastError());
|
||||
|
||||
count_current = get_module_count(GetCurrentProcess());
|
||||
ok(!count_current, "Unexpected module count %u\n", count_current);
|
||||
|
||||
ret = wrapper_SymRefreshModuleList(GetCurrentProcess());
|
||||
ok(ret, "SymRefreshModuleList failed: %lx\n", GetLastError());
|
||||
|
||||
count_current = get_module_count(GetCurrentProcess());
|
||||
ok(count == count_current, "Unexpected module count %u, %u\n", count, count_current);
|
||||
|
||||
hmod = GetModuleHandleW(unused_dll);
|
||||
ok(hmod == NULL, "Expecting DLL %ls not be loaded\n", unused_dll);
|
||||
|
||||
hmod = LoadLibraryW(unused_dll);
|
||||
ok(hmod != NULL, "LoadLibraryW failed: %lu\n", GetLastError());
|
||||
|
||||
count_current = get_module_count(GetCurrentProcess());
|
||||
ok(count == count_current, "Unexpected module count %u, %u\n", count, count_current);
|
||||
ret = is_module_present(GetCurrentProcess(), unused_dll);
|
||||
ok(!ret, "Couldn't find module %ls\n", unused_dll);
|
||||
|
||||
ret = wrapper_SymRefreshModuleList(GetCurrentProcess());
|
||||
ok(ret, "SymRefreshModuleList failed: %lx\n", GetLastError());
|
||||
|
||||
count_current = get_module_count(GetCurrentProcess());
|
||||
ok(count + 1 == count_current, "Unexpected module count %u, %u\n", count, count_current);
|
||||
ret = is_module_present(GetCurrentProcess(), unused_dll);
|
||||
ok(ret, "Couldn't find module %ls\n", unused_dll);
|
||||
|
||||
ret = FreeLibrary(hmod);
|
||||
ok(ret, "LoadLibraryW failed: %lu\n", GetLastError());
|
||||
|
||||
count_current = get_module_count(GetCurrentProcess());
|
||||
ok(count + 1 == count_current, "Unexpected module count %u, %u\n", count, count_current);
|
||||
|
||||
ret = wrapper_SymRefreshModuleList(GetCurrentProcess());
|
||||
ok(ret, "SymRefreshModuleList failed: %lx\n", GetLastError());
|
||||
|
||||
/* SymRefreshModuleList() doesn't remove the unloaded modules... */
|
||||
count_current = get_module_count(GetCurrentProcess());
|
||||
ok(count + 1 == count_current, "Unexpected module count %u != %u\n", count, count_current);
|
||||
ret = is_module_present(GetCurrentProcess(), unused_dll);
|
||||
ok(ret, "Couldn't find module %ls\n", unused_dll);
|
||||
|
||||
ret = SymCleanup(GetCurrentProcess());
|
||||
ok(ret, "SymCleanup failed: %lu\n", GetLastError());
|
||||
}
|
||||
|
||||
START_TEST(dbghelp)
|
||||
{
|
||||
BOOL ret;
|
||||
|
|
@ -1680,7 +1559,6 @@ START_TEST(dbghelp)
|
|||
test_modules_overlap();
|
||||
test_loaded_modules();
|
||||
test_live_modules();
|
||||
test_refresh_modules();
|
||||
}
|
||||
test_function_tables();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -306,13 +306,20 @@ static void warp_check( struct mouse *impl, BOOL force )
|
|||
|
||||
if (force || (impl->need_warp && (now - impl->last_warped > interval)))
|
||||
{
|
||||
RECT rect, new_rect;
|
||||
POINT mapped_center;
|
||||
RECT rect;
|
||||
|
||||
impl->last_warped = now;
|
||||
impl->need_warp = FALSE;
|
||||
if (!GetClientRect( impl->base.win, &rect )) return;
|
||||
MapWindowPoints( impl->base.win, 0, (POINT *)&rect, 2 );
|
||||
if (!impl->clipped)
|
||||
{
|
||||
mapped_center.x = (rect.left + rect.right) / 2;
|
||||
mapped_center.y = (rect.top + rect.bottom) / 2;
|
||||
TRACE( "Warping mouse to x %+ld, y %+ld.\n", mapped_center.x, mapped_center.y );
|
||||
SetCursorPos( mapped_center.x, mapped_center.y );
|
||||
}
|
||||
if (impl->base.dwCoopLevel & DISCL_EXCLUSIVE)
|
||||
{
|
||||
/* make sure we clip even if the window covers the whole screen */
|
||||
|
|
@ -321,14 +328,8 @@ static void warp_check( struct mouse *impl, BOOL force )
|
|||
rect.right = min( rect.right, rect.left + GetSystemMetrics( SM_CXVIRTUALSCREEN ) - 2 );
|
||||
rect.bottom = min( rect.bottom, rect.top + GetSystemMetrics( SM_CYVIRTUALSCREEN ) - 2 );
|
||||
TRACE("Clipping mouse to %s\n", wine_dbgstr_rect( &rect ));
|
||||
impl->clipped = ClipCursor( &rect );
|
||||
}
|
||||
if (!impl->clipped)
|
||||
{
|
||||
mapped_center.x = (rect.left + rect.right) / 2;
|
||||
mapped_center.y = (rect.top + rect.bottom) / 2;
|
||||
TRACE( "Warping mouse to x %+ld, y %+ld.\n", mapped_center.x, mapped_center.y );
|
||||
SetCursorPos( mapped_center.x, mapped_center.y );
|
||||
ClipCursor( &rect );
|
||||
impl->clipped = GetClipCursor( &new_rect ) && EqualRect( &rect, &new_rect );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1281,28 +1281,17 @@ static HRESULT WINAPI IDirectPlay4Impl_Close( IDirectPlay4 *iface )
|
|||
return hr;
|
||||
}
|
||||
|
||||
HRESULT DP_CreateGroup( IDirectPlayImpl *This, void *msgHeader, const DPID *lpid,
|
||||
const DPNAME *lpName, void *data, DWORD dataSize, DWORD dwFlags, DPID idParent,
|
||||
BOOL bAnsi )
|
||||
static lpGroupData DP_CreateGroup( IDirectPlayImpl *This, const DPID *lpid, const DPNAME *lpName,
|
||||
DWORD dwFlags, DPID idParent, BOOL bAnsi )
|
||||
{
|
||||
struct GroupList *groupList = NULL;
|
||||
struct GroupData *parent = NULL;
|
||||
lpGroupData lpGData;
|
||||
HRESULT hr;
|
||||
|
||||
if( DPID_SYSTEM_GROUP != *lpid )
|
||||
{
|
||||
parent = DP_FindAnyGroup( This, idParent );
|
||||
if( !parent )
|
||||
return DPERR_INVALIDGROUP;
|
||||
}
|
||||
|
||||
/* Allocate the new space and add to end of high level group list */
|
||||
lpGData = calloc( 1, sizeof( *lpGData ) );
|
||||
|
||||
if( lpGData == NULL )
|
||||
{
|
||||
return DPERR_OUTOFMEMORY;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
DPQ_INIT(lpGData->groups);
|
||||
|
|
@ -1315,7 +1304,7 @@ HRESULT DP_CreateGroup( IDirectPlayImpl *This, void *msgHeader, const DPID *lpid
|
|||
if ( !lpGData->name )
|
||||
{
|
||||
free( lpGData );
|
||||
return DPERR_OUTOFMEMORY;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
lpGData->nameA = DP_DuplicateName( lpName, TRUE, bAnsi );
|
||||
|
|
@ -1323,10 +1312,11 @@ HRESULT DP_CreateGroup( IDirectPlayImpl *This, void *msgHeader, const DPID *lpid
|
|||
{
|
||||
free( lpGData->name );
|
||||
free( lpGData );
|
||||
return DPERR_OUTOFMEMORY;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
lpGData->parent = idParent;
|
||||
/* FIXME: Should we check that the parent exists? */
|
||||
lpGData->parent = idParent;
|
||||
|
||||
/* FIXME: Should we validate the dwFlags? */
|
||||
lpGData->dwFlags = dwFlags;
|
||||
|
|
@ -1338,83 +1328,12 @@ HRESULT DP_CreateGroup( IDirectPlayImpl *This, void *msgHeader, const DPID *lpid
|
|||
free( lpGData->nameA );
|
||||
free( lpGData->name );
|
||||
free( lpGData );
|
||||
return DPERR_OUTOFMEMORY;
|
||||
}
|
||||
|
||||
if( DPID_SYSTEM_GROUP == *lpid )
|
||||
{
|
||||
This->dp2->lpSysGroup = lpGData;
|
||||
TRACE( "Inserting system group\n" );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Insert into the parent group */
|
||||
groupList = calloc( 1, sizeof( *groupList ) );
|
||||
if( !groupList )
|
||||
{
|
||||
free( lpGData->nameA );
|
||||
free( lpGData->name );
|
||||
free( lpGData );
|
||||
return DPERR_OUTOFMEMORY;
|
||||
}
|
||||
groupList->lpGData = lpGData;
|
||||
|
||||
DPQ_INSERT( parent->groups, groupList, groups );
|
||||
}
|
||||
|
||||
/* Something is now referencing this data */
|
||||
lpGData->uRef++;
|
||||
|
||||
DP_SetGroupData( lpGData, DPSET_REMOTE, data, dataSize );
|
||||
|
||||
/* FIXME: We should only create the system group if GetCaps returns
|
||||
* DPCAPS_GROUPOPTIMIZED.
|
||||
*/
|
||||
|
||||
/* Let the SP know that we've created this group */
|
||||
if( This->dp2->spData.lpCB->CreateGroup )
|
||||
{
|
||||
DPSP_CREATEGROUPDATA data;
|
||||
DWORD dwCreateFlags = 0;
|
||||
|
||||
TRACE( "Calling SP CreateGroup\n" );
|
||||
|
||||
if( !parent )
|
||||
dwCreateFlags |= DPLAYI_GROUP_SYSGROUP;
|
||||
|
||||
if( !msgHeader )
|
||||
dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
|
||||
|
||||
if( dwFlags & DPGROUP_HIDDEN )
|
||||
dwCreateFlags |= DPLAYI_GROUP_HIDDEN;
|
||||
|
||||
data.idGroup = *lpid;
|
||||
data.dwFlags = dwCreateFlags;
|
||||
data.lpSPMessageHeader = msgHeader;
|
||||
data.lpISP = This->dp2->spData.lpISP;
|
||||
|
||||
hr = (*This->dp2->spData.lpCB->CreateGroup)( &data );
|
||||
if( FAILED( hr ) )
|
||||
{
|
||||
if( groupList )
|
||||
{
|
||||
DPQ_REMOVE( parent->groups, groupList, groups );
|
||||
free( groupList );
|
||||
}
|
||||
else
|
||||
{
|
||||
This->dp2->lpSysGroup = NULL;
|
||||
}
|
||||
free( lpGData->nameA );
|
||||
free( lpGData->name );
|
||||
free( lpGData );
|
||||
return hr;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TRACE( "Created group id 0x%08lx\n", *lpid );
|
||||
|
||||
return DP_OK;
|
||||
return lpGData;
|
||||
}
|
||||
|
||||
/* This method assumes that all links to it are already deleted */
|
||||
|
|
@ -1475,7 +1394,7 @@ static lpGroupData DP_FindAnyGroup( IDirectPlayImpl *This, DPID dpid )
|
|||
static HRESULT DP_IF_CreateGroup( IDirectPlayImpl *This, void *lpMsgHdr, DPID *lpidGroup,
|
||||
DPNAME *lpGroupName, void *lpData, DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi )
|
||||
{
|
||||
HRESULT hr;
|
||||
lpGroupData lpGData;
|
||||
|
||||
TRACE( "(%p)->(%p,%p,%p,%p,0x%08lx,0x%08lx,%u)\n",
|
||||
This, lpMsgHdr, lpidGroup, lpGroupName, lpData, dwDataSize,
|
||||
|
|
@ -1502,12 +1421,61 @@ static HRESULT DP_IF_CreateGroup( IDirectPlayImpl *This, void *lpMsgHdr, DPID *l
|
|||
}
|
||||
}
|
||||
|
||||
hr = DP_CreateGroup( This, lpMsgHdr, lpidGroup, lpGroupName, lpData, dwDataSize, dwFlags,
|
||||
DPID_NOPARENT_GROUP, bAnsi );
|
||||
lpGData = DP_CreateGroup( This, lpidGroup, lpGroupName, dwFlags,
|
||||
DPID_NOPARENT_GROUP, bAnsi );
|
||||
|
||||
if( FAILED( hr ) )
|
||||
if( lpGData == NULL )
|
||||
{
|
||||
return hr;
|
||||
return DPERR_CANTADDPLAYER; /* yes player not group */
|
||||
}
|
||||
|
||||
if( DPID_SYSTEM_GROUP == *lpidGroup )
|
||||
{
|
||||
This->dp2->lpSysGroup = lpGData;
|
||||
TRACE( "Inserting system group\n" );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Insert into the system group */
|
||||
lpGroupList lpGroup = calloc( 1, sizeof( *lpGroup ) );
|
||||
lpGroup->lpGData = lpGData;
|
||||
|
||||
DPQ_INSERT( This->dp2->lpSysGroup->groups, lpGroup, groups );
|
||||
}
|
||||
|
||||
/* Something is now referencing this data */
|
||||
lpGData->uRef++;
|
||||
|
||||
/* Set all the important stuff for the group */
|
||||
DP_SetGroupData( lpGData, DPSET_REMOTE, lpData, dwDataSize );
|
||||
|
||||
/* FIXME: We should only create the system group if GetCaps returns
|
||||
* DPCAPS_GROUPOPTIMIZED.
|
||||
*/
|
||||
|
||||
/* Let the SP know that we've created this group */
|
||||
if( This->dp2->spData.lpCB->CreateGroup )
|
||||
{
|
||||
DPSP_CREATEGROUPDATA data;
|
||||
DWORD dwCreateFlags = 0;
|
||||
|
||||
TRACE( "Calling SP CreateGroup\n" );
|
||||
|
||||
if( *lpidGroup == DPID_NOPARENT_GROUP )
|
||||
dwCreateFlags |= DPLAYI_GROUP_SYSGROUP;
|
||||
|
||||
if( lpMsgHdr == NULL )
|
||||
dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
|
||||
|
||||
if( dwFlags & DPGROUP_HIDDEN )
|
||||
dwCreateFlags |= DPLAYI_GROUP_HIDDEN;
|
||||
|
||||
data.idGroup = *lpidGroup;
|
||||
data.dwFlags = dwCreateFlags;
|
||||
data.lpSPMessageHeader = lpMsgHdr;
|
||||
data.lpISP = This->dp2->spData.lpISP;
|
||||
|
||||
(*This->dp2->spData.lpCB->CreateGroup)( &data );
|
||||
}
|
||||
|
||||
/* Inform all other peers of the creation of a new group. If there are
|
||||
|
|
@ -4490,7 +4458,9 @@ static HRESULT DP_IF_CreateGroupInGroup( IDirectPlayImpl *This, void *lpMsgHdr,
|
|||
DPID *lpidGroup, DPNAME *lpGroupName, void *lpData, DWORD dwDataSize, DWORD dwFlags,
|
||||
BOOL bAnsi )
|
||||
{
|
||||
HRESULT hr;
|
||||
lpGroupData lpGParentData;
|
||||
lpGroupList lpGList;
|
||||
lpGroupData lpGData;
|
||||
|
||||
TRACE( "(%p)->(0x%08lx,%p,%p,%p,0x%08lx,0x%08lx,%u)\n",
|
||||
This, idParentGroup, lpidGroup, lpGroupName, lpData,
|
||||
|
|
@ -4501,12 +4471,48 @@ static HRESULT DP_IF_CreateGroupInGroup( IDirectPlayImpl *This, void *lpMsgHdr,
|
|||
return DPERR_UNINITIALIZED;
|
||||
}
|
||||
|
||||
hr = DP_CreateGroup(This, lpMsgHdr, lpidGroup, lpGroupName, lpData, dwDataSize, dwFlags,
|
||||
idParentGroup, bAnsi );
|
||||
/* Verify that the specified parent is valid */
|
||||
if( ( lpGParentData = DP_FindAnyGroup(This, idParentGroup ) ) == NULL )
|
||||
return DPERR_INVALIDGROUP;
|
||||
|
||||
if( FAILED( hr ) )
|
||||
lpGData = DP_CreateGroup(This, lpidGroup, lpGroupName, dwFlags, idParentGroup, bAnsi );
|
||||
|
||||
if( lpGData == NULL )
|
||||
{
|
||||
return hr;
|
||||
return DPERR_CANTADDPLAYER; /* yes player not group */
|
||||
}
|
||||
|
||||
/* Something else is referencing this data */
|
||||
lpGData->uRef++;
|
||||
|
||||
DP_SetGroupData( lpGData, DPSET_REMOTE, lpData, dwDataSize );
|
||||
|
||||
/* The list has now been inserted into the interface group list. We now
|
||||
need to put a "shortcut" to this group in the parent group */
|
||||
lpGList = calloc( 1, sizeof( *lpGList ) );
|
||||
if( lpGList == NULL )
|
||||
{
|
||||
FIXME( "Memory leak\n" );
|
||||
return DPERR_CANTADDPLAYER; /* yes player not group */
|
||||
}
|
||||
|
||||
lpGList->lpGData = lpGData;
|
||||
|
||||
DPQ_INSERT( lpGParentData->groups, lpGList, groups );
|
||||
|
||||
/* Let the SP know that we've created this group */
|
||||
if( This->dp2->spData.lpCB->CreateGroup )
|
||||
{
|
||||
DPSP_CREATEGROUPDATA data;
|
||||
|
||||
TRACE( "Calling SP CreateGroup\n" );
|
||||
|
||||
data.idGroup = *lpidGroup;
|
||||
data.dwFlags = dwFlags;
|
||||
data.lpSPMessageHeader = lpMsgHdr;
|
||||
data.lpISP = This->dp2->spData.lpISP;
|
||||
|
||||
(*This->dp2->spData.lpCB->CreateGroup)( &data );
|
||||
}
|
||||
|
||||
/* Inform all other peers of the creation of a new group. If there are
|
||||
|
|
|
|||
|
|
@ -218,9 +218,6 @@ HRESULT DP_HandleGameMessage( IDirectPlayImpl *This, void *messageBody, DWORD me
|
|||
HRESULT DP_CreatePlayer( IDirectPlayImpl *This, void *msgHeader, DPID *lpid, DPNAME *lpName,
|
||||
void *data, DWORD dataSize, void *spData, DWORD spDataSize, DWORD dwFlags,
|
||||
HANDLE hEvent, struct PlayerData **playerData, BOOL bAnsi );
|
||||
HRESULT DP_CreateGroup( IDirectPlayImpl *This, void *msgHeader, const DPID *lpid,
|
||||
const DPNAME *lpName, void *data, DWORD dataSize, DWORD dwFlags,
|
||||
DPID idParent, BOOL bAnsi );
|
||||
|
||||
/* DP SP external interfaces into DirectPlay */
|
||||
extern HRESULT DP_GetSPPlayerData( IDirectPlayImpl *lpDP, DPID idPlayer, void **lplpData );
|
||||
|
|
|
|||
|
|
@ -676,30 +676,6 @@ HRESULT DP_MSG_ForwardPlayerCreation( IDirectPlayImpl *This, DPID dpidServer, WC
|
|||
return hr;
|
||||
}
|
||||
}
|
||||
for( i = 0; i < enumPlayersReply->groupCount; ++i )
|
||||
{
|
||||
DPPLAYERINFO playerInfo;
|
||||
|
||||
hr = DP_MSG_ReadSuperPackedPlayer( (char *) enumPlayersReply, &offset, dwMsgSize,
|
||||
&playerInfo );
|
||||
if( FAILED( hr ) )
|
||||
{
|
||||
free( msgHeader );
|
||||
free( lpMsg );
|
||||
return hr;
|
||||
}
|
||||
|
||||
hr = DP_CreateGroup( This, msgHeader, &playerInfo.id, &playerInfo.name,
|
||||
playerInfo.playerData, playerInfo.playerDataLength,
|
||||
playerInfo.flags & ~DPLAYI_PLAYER_PLAYERLOCAL, playerInfo.parentId,
|
||||
FALSE );
|
||||
if( FAILED( hr ) )
|
||||
{
|
||||
free( msgHeader );
|
||||
free( lpMsg );
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if( envelope->wCommandId == DPMSGCMD_GETNAMETABLEREPLY )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1224,14 +1224,12 @@ static void checkGameMessage_( int line, GameMessage *message, DPID expectedFrom
|
|||
static unsigned short receiveEnumSessionsRequest_( int line, SOCKET sock, const GUID *expectedAppGuid,
|
||||
const WCHAR *expectedPassword, DWORD expectedFlags )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
EnumSessionsRequest request;
|
||||
WCHAR password[ 256 ];
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
DWORD expectedPasswordSize;
|
||||
unsigned short port;
|
||||
DWORD expectedSize;
|
||||
|
|
@ -1269,7 +1267,6 @@ static unsigned short receiveEnumSessionsRequest_( int line, SOCKET sock, const
|
|||
#define sendEnumSessionsReply( sock, port, dpsd ) sendEnumSessionsReply_( __LINE__, sock, port, dpsd )
|
||||
static void sendEnumSessionsReply_( int line, SOCKET sock, unsigned short port, const DPSESSIONDESC2 *dpsd )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -1298,7 +1295,6 @@ static void sendEnumSessionsReply_( int line, SOCKET sock, unsigned short port,
|
|||
.nameOffset = sizeof( reply.reply ),
|
||||
},
|
||||
};
|
||||
#include "poppack.h"
|
||||
DWORD passwordSize;
|
||||
int wsResult;
|
||||
DWORD size;
|
||||
|
|
@ -1318,13 +1314,11 @@ static void sendEnumSessionsReply_( int line, SOCKET sock, unsigned short port,
|
|||
#define receiveRequestPlayerId( sock, expectedFlags, flagsTodo ) receiveRequestPlayerId_( __LINE__, sock, expectedFlags, flagsTodo )
|
||||
static unsigned short receiveRequestPlayerId_( int line, SOCKET sock, DWORD expectedFlags )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
RequestPlayerId request;
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
unsigned short port;
|
||||
int wsResult;
|
||||
|
||||
|
|
@ -1341,7 +1335,6 @@ static unsigned short receiveRequestPlayerId_( int line, SOCKET sock, DWORD expe
|
|||
#define sendRequestPlayerReply( sock, port, id, result ) sendRequestPlayerReply_( __LINE__, sock, port, id, result )
|
||||
static void sendRequestPlayerReply_( int line, SOCKET sock, unsigned short port, DPID id, HRESULT result )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -1369,7 +1362,6 @@ static void sendRequestPlayerReply_( int line, SOCKET sock, unsigned short port,
|
|||
.result = result,
|
||||
},
|
||||
};
|
||||
#include "poppack.h"
|
||||
int wsResult;
|
||||
|
||||
wsResult = send( sock, (char *) &reply, sizeof( reply ), 0 );
|
||||
|
|
@ -1382,13 +1374,11 @@ static unsigned short receiveAddForwardRequest_( int line, SOCKET sock, DPID exp
|
|||
const WCHAR *expectedPassword, DWORD expectedTickCount,
|
||||
unsigned short *udpPort )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
AddForwardRequest request;
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
DWORD expectedPasswordSize;
|
||||
WCHAR password[ 256 ];
|
||||
unsigned short port;
|
||||
|
|
@ -1437,53 +1427,25 @@ static void sendSuperEnumPlayersReply_( int line, SOCKET sock, unsigned short tc
|
|||
{
|
||||
#define SHORT_NAME L"short name"
|
||||
#define LONG_NAME L"long name"
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
SuperEnumPlayersReply reply;
|
||||
DPSESSIONDESC2 dpsd;
|
||||
WCHAR sessionName[ 256 ];
|
||||
struct
|
||||
{
|
||||
SuperPackedPlayer superPackedPlayer;
|
||||
BYTE spDataLength;
|
||||
SpData spData;
|
||||
} player0;
|
||||
struct
|
||||
{
|
||||
SuperPackedPlayer superPackedPlayer;
|
||||
BYTE spDataLength;
|
||||
SpData spData;
|
||||
} player1;
|
||||
struct
|
||||
{
|
||||
SuperPackedPlayer superPackedPlayer;
|
||||
WCHAR shortName[ ARRAYSIZE( SHORT_NAME ) ];
|
||||
WCHAR longName[ ARRAYSIZE( LONG_NAME ) ];
|
||||
BYTE playerDataLength;
|
||||
BYTE playerData[ 4 ];
|
||||
BYTE spDataLength;
|
||||
SpData spData;
|
||||
} player2;
|
||||
struct
|
||||
{
|
||||
SuperPackedPlayer superPackedPlayer;
|
||||
BYTE spDataLength;
|
||||
SpData spData;
|
||||
} player3;
|
||||
struct
|
||||
{
|
||||
SuperPackedPlayer superPackedPlayer;
|
||||
WCHAR shortName[ ARRAYSIZE( SHORT_NAME ) ];
|
||||
WCHAR longName[ ARRAYSIZE( LONG_NAME ) ];
|
||||
BYTE playerDataLength;
|
||||
BYTE playerData[ 4 ];
|
||||
BYTE spDataLength;
|
||||
SpData spData;
|
||||
BYTE playerCount;
|
||||
DPID playerIds[ 1 ];
|
||||
} group0;
|
||||
SuperPackedPlayer superPackedPlayer0;
|
||||
BYTE spDataLength0;
|
||||
SpData spData0;
|
||||
SuperPackedPlayer superPackedPlayer1;
|
||||
BYTE spDataLength1;
|
||||
SpData spData1;
|
||||
SuperPackedPlayer superPackedPlayer2;
|
||||
WCHAR shortName[ ARRAYSIZE( SHORT_NAME ) ];
|
||||
WCHAR longName[ ARRAYSIZE( LONG_NAME ) ];
|
||||
BYTE playerDataLength2;
|
||||
BYTE playerData[ 4 ];
|
||||
BYTE spDataLength2;
|
||||
SpData spData2;
|
||||
} reply =
|
||||
{
|
||||
.spHeader =
|
||||
|
|
@ -1503,8 +1465,8 @@ static void sendSuperEnumPlayersReply_( int line, SOCKET sock, unsigned short tc
|
|||
.command = 41,
|
||||
.version = 14,
|
||||
},
|
||||
.playerCount = 4,
|
||||
.groupCount = 1,
|
||||
.playerCount = 3,
|
||||
.groupCount = 0,
|
||||
.packedOffset = sizeof( reply.reply ) + sizeof( reply.dpsd ) + sizeof( reply.sessionName ),
|
||||
.shortcutCount = 0,
|
||||
.descriptionOffset = sizeof( reply.reply ),
|
||||
|
|
@ -1512,143 +1474,77 @@ static void sendSuperEnumPlayersReply_( int line, SOCKET sock, unsigned short tc
|
|||
.passwordOffset = 0,
|
||||
},
|
||||
.dpsd = *dpsd,
|
||||
.player0 =
|
||||
.superPackedPlayer0 =
|
||||
{
|
||||
.superPackedPlayer =
|
||||
.size = 16,
|
||||
.flags = 0x5,
|
||||
.id = 0x12345678,
|
||||
.infoMask = 0x4,
|
||||
.versionOrSystemPlayerId = 14,
|
||||
},
|
||||
.spDataLength0 = sizeof( SpData ),
|
||||
.spData0 =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.size = 16,
|
||||
.flags = 0x5,
|
||||
.id = 0x12345678,
|
||||
.infoMask = 0x4,
|
||||
.versionOrSystemPlayerId = 14,
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.spDataLength = sizeof( SpData ),
|
||||
.spData =
|
||||
.udpAddr =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.udpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
},
|
||||
.player1 =
|
||||
.superPackedPlayer1 =
|
||||
{
|
||||
.superPackedPlayer =
|
||||
.size = 16,
|
||||
.flags = 0xf,
|
||||
.id = 0x51573,
|
||||
.infoMask = 0x4,
|
||||
.versionOrSystemPlayerId = 14,
|
||||
},
|
||||
.spDataLength1 = sizeof( SpData ),
|
||||
.spData1 =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.size = 16,
|
||||
.flags = 0xf,
|
||||
.id = 0x51573,
|
||||
.infoMask = 0x4,
|
||||
.versionOrSystemPlayerId = 14,
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.spDataLength = sizeof( SpData ),
|
||||
.spData =
|
||||
.udpAddr =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.udpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
},
|
||||
.player2 =
|
||||
.superPackedPlayer2 =
|
||||
{
|
||||
.superPackedPlayer =
|
||||
{
|
||||
.size = 16,
|
||||
.flags = 0x8,
|
||||
.id = 0x1337,
|
||||
.infoMask = 0x17,
|
||||
.versionOrSystemPlayerId = 0x51573,
|
||||
},
|
||||
.shortName = SHORT_NAME,
|
||||
.longName = LONG_NAME,
|
||||
.playerDataLength = 4,
|
||||
.playerData = { 1, 2, 3, 4, },
|
||||
.spDataLength = sizeof( SpData ),
|
||||
.spData =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.udpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
},
|
||||
.size = 16,
|
||||
.flags = 0x8,
|
||||
.id = 0x1337,
|
||||
.infoMask = 0x17,
|
||||
.versionOrSystemPlayerId = 0x51573,
|
||||
},
|
||||
.player3 =
|
||||
.shortName = SHORT_NAME,
|
||||
.longName = LONG_NAME,
|
||||
.playerDataLength2 = 4,
|
||||
.playerData = { 1, 2, 3, 4, },
|
||||
.spDataLength2 = sizeof( SpData ),
|
||||
.spData2 =
|
||||
{
|
||||
.superPackedPlayer =
|
||||
.tcpAddr =
|
||||
{
|
||||
.size = 16,
|
||||
.flags = 0x8,
|
||||
.id = 0xd00de,
|
||||
.infoMask = 0x4,
|
||||
.versionOrSystemPlayerId = 0x51573,
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.spDataLength = sizeof( SpData ),
|
||||
.spData =
|
||||
.udpAddr =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.udpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
},
|
||||
.group0 =
|
||||
{
|
||||
.superPackedPlayer =
|
||||
{
|
||||
.size = 16,
|
||||
.flags = 0x48,
|
||||
.id = 0x5e7,
|
||||
.infoMask = 0x57,
|
||||
.versionOrSystemPlayerId = 0x51573,
|
||||
},
|
||||
.shortName = SHORT_NAME,
|
||||
.longName = LONG_NAME,
|
||||
.playerDataLength = 4,
|
||||
.playerData = { 1, 2, 3, 4, },
|
||||
.spDataLength = sizeof( SpData ),
|
||||
.spData =
|
||||
{
|
||||
.tcpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( tcpPort ),
|
||||
},
|
||||
.udpAddr =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons( udpPort ),
|
||||
},
|
||||
},
|
||||
.playerCount = 1,
|
||||
.playerIds = { 0xd00de, },
|
||||
},
|
||||
};
|
||||
#include "poppack.h"
|
||||
#undef LONG_NAME
|
||||
#undef SHORT_NAME
|
||||
int wsResult;
|
||||
|
|
@ -1665,7 +1561,6 @@ static void sendSuperEnumPlayersReply_( int line, SOCKET sock, unsigned short tc
|
|||
#define sendAddForwardReply( sock, port, result ) sendAddForwardReply_( __LINE__, sock, port, result )
|
||||
static void sendAddForwardReply_( int line, SOCKET sock, unsigned short port, HRESULT result )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -1692,7 +1587,6 @@ static void sendAddForwardReply_( int line, SOCKET sock, unsigned short port, HR
|
|||
.result = result,
|
||||
},
|
||||
};
|
||||
#include "poppack.h"
|
||||
int wsResult;
|
||||
|
||||
wsResult = send( sock, (char *) &reply, sizeof( reply ), 0 );
|
||||
|
|
@ -1702,7 +1596,6 @@ static void sendAddForwardReply_( int line, SOCKET sock, unsigned short port, HR
|
|||
#define sendAddForward( sock, port, tcpPort, udpPort ) sendAddForward_( __LINE__, sock, port, tcpPort, udpPort )
|
||||
static void sendAddForward_( int line, SOCKET sock, unsigned short port, unsigned short tcpPort, unsigned short udpPort )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -1760,7 +1653,6 @@ static void sendAddForward_( int line, SOCKET sock, unsigned short port, unsigne
|
|||
},
|
||||
},
|
||||
};
|
||||
#include "poppack.h"
|
||||
|
||||
int wsResult;
|
||||
|
||||
|
|
@ -1771,13 +1663,11 @@ static void sendAddForward_( int line, SOCKET sock, unsigned short port, unsigne
|
|||
#define receiveAddForwardAck( sock, expectedPlayerId ) receiveAddForwardAck_( __LINE__, sock, expectedPlayerId )
|
||||
static unsigned short receiveAddForwardAck_( int line, SOCKET sock, DPID expectedPlayerId )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
AddForwardAck request;
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
unsigned short port;
|
||||
int wsResult;
|
||||
|
||||
|
|
@ -1798,13 +1688,11 @@ static unsigned short receiveCreatePlayer_( int line, SOCKET sock, DPID expected
|
|||
const WCHAR *expectedShortName, const WCHAR *expectedLongName,
|
||||
void *expectedPlayerData, DWORD expectedPlayerDataSize )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
CreatePlayer request;
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
DWORD expectedShortNameSize;
|
||||
DWORD expectedLongNameSize;
|
||||
WCHAR shortName[ 256 ];
|
||||
|
|
@ -1887,7 +1775,6 @@ static unsigned short receiveCreatePlayer_( int line, SOCKET sock, DPID expected
|
|||
static void sendCreatePlayer_( int line, SOCKET sock, unsigned short tcpPort, unsigned short udpPort,
|
||||
const WCHAR *shortName, const WCHAR *longName, void *playerData, DWORD playerDataSize )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -1933,7 +1820,6 @@ static void sendCreatePlayer_( int line, SOCKET sock, unsigned short tcpPort, un
|
|||
},
|
||||
},
|
||||
};
|
||||
#include "poppack.h"
|
||||
SpData spData = {
|
||||
.tcpAddr.sin_family = AF_INET,
|
||||
.tcpAddr.sin_port = htons( tcpPort ),
|
||||
|
|
@ -1991,14 +1877,12 @@ static void sendCreatePlayer_( int line, SOCKET sock, unsigned short tcpPort, un
|
|||
static unsigned short receiveGuaranteedGameMessage_( int line, SOCKET sock, DPID expectedFromId, DPID expectedToId,
|
||||
void *expectedData, DWORD expectedDataSize )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
GameMessage request;
|
||||
BYTE data[ 256 ];
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
unsigned short port;
|
||||
int wsResult;
|
||||
|
||||
|
|
@ -2019,13 +1903,11 @@ static unsigned short receiveGuaranteedGameMessage_( int line, SOCKET sock, DPID
|
|||
static void receiveGameMessage_( int line, SOCKET sock, DPID expectedFromId, DPID expectedToId, void *expectedData,
|
||||
DWORD expectedDataSize )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
GameMessage request;
|
||||
BYTE data[ 256 ];
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
int wsResult;
|
||||
|
||||
DWORD expectedSize = sizeof( request.request ) + expectedDataSize;
|
||||
|
|
@ -2042,7 +1924,6 @@ static void receiveGameMessage_( int line, SOCKET sock, DPID expectedFromId, DPI
|
|||
static void sendGuaranteedGameMessage_( int line, SOCKET sock, unsigned short port, DPID fromId, DPID toId, void *data,
|
||||
DWORD dataSize )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -2064,7 +1945,6 @@ static void sendGuaranteedGameMessage_( int line, SOCKET sock, unsigned short po
|
|||
.toId = toId,
|
||||
}
|
||||
};
|
||||
#include "poppack.h"
|
||||
int wsResult;
|
||||
|
||||
wsResult = send( sock, (char *) &request, sizeof( request ), 0 );
|
||||
|
|
@ -2078,7 +1958,6 @@ static void sendGuaranteedGameMessage_( int line, SOCKET sock, unsigned short po
|
|||
sendGameMessage_( __LINE__, sock, fromId, toId, data, dataSize )
|
||||
static void sendGameMessage_( int line, SOCKET sock, DPID fromId, DPID toId, void *data, DWORD dataSize )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
GameMessage request;
|
||||
|
|
@ -2091,7 +1970,6 @@ static void sendGameMessage_( int line, SOCKET sock, DPID fromId, DPID toId, voi
|
|||
.toId = toId,
|
||||
}
|
||||
};
|
||||
#include "poppack.h"
|
||||
int wsResult;
|
||||
DWORD size;
|
||||
|
||||
|
|
@ -2107,7 +1985,6 @@ static void sendGameMessage_( int line, SOCKET sock, DPID fromId, DPID toId, voi
|
|||
sendPing_( __LINE__, sock, port, fromId, tickCount )
|
||||
static void sendPing_( int line, SOCKET sock, unsigned short port, DPID fromId, DWORD tickCount )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
|
|
@ -2135,7 +2012,6 @@ static void sendPing_( int line, SOCKET sock, unsigned short port, DPID fromId,
|
|||
.tickCount = tickCount,
|
||||
}
|
||||
};
|
||||
#include "poppack.h"
|
||||
int wsResult;
|
||||
|
||||
wsResult = send( sock, (char *) &request, sizeof( request ), 0 );
|
||||
|
|
@ -2146,13 +2022,11 @@ static void sendPing_( int line, SOCKET sock, unsigned short port, DPID fromId,
|
|||
receivePingReply_( __LINE__, sock, expectedFromId, expectedTickCount )
|
||||
static unsigned short receivePingReply_( int line, SOCKET sock, DPID expectedFromId, DWORD expectedTickCount )
|
||||
{
|
||||
#include "pshpack1.h"
|
||||
struct
|
||||
{
|
||||
SpHeader spHeader;
|
||||
Ping request;
|
||||
} request;
|
||||
#include "poppack.h"
|
||||
unsigned short port;
|
||||
int wsResult;
|
||||
|
||||
|
|
@ -2830,7 +2704,7 @@ static BOOL CALLBACK checkPlayerListCallback( DPID dpid, DWORD playerType, const
|
|||
HRESULT hr;
|
||||
|
||||
if ( player->actualCount )
|
||||
todo_wine ok_( __FILE__, data->line )( 0, "duplicate player dpid %#lx.\n", dpid );
|
||||
ok_( __FILE__, data->line )( 0, "duplicate player dpid %#lx.\n", dpid );
|
||||
ok_( __FILE__, data->line )( playerType == player->expectedPlayerType, "got player type %lu.\n",
|
||||
playerType );
|
||||
if ( player->expectedShortName )
|
||||
|
|
@ -2853,28 +2727,20 @@ static BOOL CALLBACK checkPlayerListCallback( DPID dpid, DWORD playerType, const
|
|||
ok_( __FILE__, data->line )( !name->lpszLongNameA, "got long name %s.\n",
|
||||
wine_dbgstr_a( name->lpszLongNameA ) );
|
||||
}
|
||||
todo_wine_if( playerType == DPPLAYERTYPE_GROUP && flags == DPENUMPLAYERS_LOCAL )
|
||||
ok_( __FILE__, data->line )( flags == player->expectedFlags, "got flags %#lx.\n", flags );
|
||||
ok_( __FILE__, data->line )( flags == player->expectedFlags, "got flags %#lx.\n", flags );
|
||||
|
||||
memset( &playerData, 0xcc, sizeof( playerData ) );
|
||||
playerDataSize = sizeof( playerData );
|
||||
if ( playerType == DPPLAYERTYPE_PLAYER )
|
||||
hr = IDirectPlayX_GetPlayerData( data->dp, dpid, playerData, &playerDataSize, DPGET_REMOTE );
|
||||
else
|
||||
hr = IDirectPlayX_GetGroupData( data->dp, dpid, playerData, &playerDataSize, DPGET_REMOTE );
|
||||
hr = IDirectPlayX_GetPlayerData( data->dp, dpid, playerData, &playerDataSize, DPGET_REMOTE );
|
||||
ok_( __FILE__, data->line )( hr == DP_OK, "GetPlayerData() returned %#lx.\n", hr );
|
||||
todo_wine_if( playerType == DPPLAYERTYPE_GROUP )
|
||||
ok_( __FILE__, data->line )( playerDataSize == player->expectedPlayerDataSize,
|
||||
"got player data size %lu.\n", playerDataSize );
|
||||
ok_( __FILE__, data->line )( playerDataSize == player->expectedPlayerDataSize,
|
||||
"got player data size %lu.\n", playerDataSize );
|
||||
ok_( __FILE__, data->line )( !memcmp( playerData, player->expectedPlayerData, player->expectedPlayerDataSize ),
|
||||
"player data doesn't match.\n" );
|
||||
|
||||
memset( &nameData, 0xcc, sizeof( nameData ) );
|
||||
nameDataSize = sizeof( nameData );
|
||||
if ( playerType == DPPLAYERTYPE_PLAYER )
|
||||
hr = IDirectPlayX_GetPlayerName( data->dp, dpid, &nameData, &nameDataSize );
|
||||
else
|
||||
hr = IDirectPlayX_GetGroupName( data->dp, dpid, &nameData, &nameDataSize );
|
||||
hr = IDirectPlayX_GetPlayerName( data->dp, dpid, &nameData, &nameDataSize );
|
||||
ok_( __FILE__, data->line )( hr == DP_OK, "GetPlayerName() returned %#lx.\n", hr );
|
||||
ok_( __FILE__, data->line )( ((DPNAME *) nameData)->dwSize == sizeof( DPNAME ),
|
||||
"got name size %lu.\n", ((DPNAME *) nameData)->dwSize );
|
||||
|
|
@ -2930,8 +2796,7 @@ static BOOL CALLBACK checkPlayerListCallback( DPID dpid, DWORD playerType, const
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
#define checkPlayerList( dp, expectedPlayers, expectedPlayerCount ) \
|
||||
checkPlayerList_( __LINE__, dp, expectedPlayers, expectedPlayerCount )
|
||||
#define checkPlayerList( dp, expectedPlayers, expectedPlayerCount ) checkPlayerList_( __LINE__, dp, expectedPlayers, expectedPlayerCount )
|
||||
static void checkPlayerList_( int line, IDirectPlay4 *dp, ExpectedPlayer *expectedPlayers, int expectedPlayerCount )
|
||||
{
|
||||
CheckPlayerListCallbackData data = {
|
||||
|
|
@ -2952,51 +2817,6 @@ static void checkPlayerList_( int line, IDirectPlay4 *dp, ExpectedPlayer *expect
|
|||
data.actualPlayerCount );
|
||||
}
|
||||
|
||||
#define checkGroupPlayerList( dp, group, expectedPlayers, expectedPlayerCount ) \
|
||||
checkGroupPlayerList_( __LINE__, dp, group, expectedPlayers, expectedPlayerCount )
|
||||
static void checkGroupPlayerList_( int line, DPID group, IDirectPlay4 *dp, ExpectedPlayer *expectedPlayers,
|
||||
int expectedPlayerCount )
|
||||
{
|
||||
CheckPlayerListCallbackData data = {
|
||||
.line = line,
|
||||
.dp = dp,
|
||||
.expectedPlayers = expectedPlayers,
|
||||
.expectedPlayerCount = expectedPlayerCount,
|
||||
};
|
||||
HRESULT hr;
|
||||
|
||||
hr = IDirectPlayX_EnumGroupPlayers( dp, group, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_LOCAL );
|
||||
ok_( __FILE__, line )( hr == DP_OK, "EnumGroupPlayers() returned %#lx.\n", hr );
|
||||
|
||||
hr = IDirectPlayX_EnumGroupPlayers( dp, group, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_REMOTE );
|
||||
ok_( __FILE__, line )( hr == DP_OK, "EnumGroupPlayers() returned %#lx.\n", hr );
|
||||
|
||||
todo_wine ok_( __FILE__, line )( data.actualPlayerCount == data.expectedPlayerCount, "got player count %d.\n",
|
||||
data.actualPlayerCount );
|
||||
}
|
||||
|
||||
#define checkGroupList( dp, expectedGroups, expectedGroupCount ) \
|
||||
checkGroupList_( __LINE__, dp, expectedGroups, expectedGroupCount )
|
||||
static void checkGroupList_( int line, IDirectPlay4 *dp, ExpectedPlayer *expectedGroups, int expectedGroupCount )
|
||||
{
|
||||
CheckPlayerListCallbackData data = {
|
||||
.line = line,
|
||||
.dp = dp,
|
||||
.expectedPlayers = expectedGroups,
|
||||
.expectedPlayerCount = expectedGroupCount,
|
||||
};
|
||||
HRESULT hr;
|
||||
|
||||
hr = IDirectPlayX_EnumGroups( dp, NULL, checkPlayerListCallback, &data, DPENUMGROUPS_LOCAL );
|
||||
ok_( __FILE__, line )( hr == DP_OK, "EnumGroups() returned %#lx.\n", hr );
|
||||
|
||||
hr = IDirectPlayX_EnumGroups( dp, NULL, checkPlayerListCallback, &data, DPENUMGROUPS_REMOTE );
|
||||
ok_( __FILE__, line )( hr == DP_OK, "EnumGroups() returned %#lx.\n", hr );
|
||||
|
||||
todo_wine ok_( __FILE__, line )( data.actualPlayerCount == data.expectedPlayerCount, "got group count %d.\n",
|
||||
data.actualPlayerCount );
|
||||
}
|
||||
|
||||
#define checkPlayerExists( dp, expectedDpid, expectedPlayerType, expectedShortName, expectedLongName, expectedFlags, \
|
||||
expectedPlayerData, expectedPlayerDataSize ) \
|
||||
checkPlayerExists_( __LINE__, dp, expectedDpid, expectedPlayerType, expectedShortName, expectedLongName, \
|
||||
|
|
@ -3098,36 +2918,9 @@ static void check_Open_( int line, IDirectPlay4A *dp, DPSESSIONDESC2 *dpsd, cons
|
|||
.expectedPlayerData = expectedPlayerData,
|
||||
.expectedPlayerDataSize = sizeof( expectedPlayerData ),
|
||||
},
|
||||
{
|
||||
.expectedDpid = 0xd00de,
|
||||
.expectedPlayerType = DPPLAYERTYPE_PLAYER,
|
||||
.expectedFlags = DPENUMPLAYERS_REMOTE,
|
||||
},
|
||||
};
|
||||
ExpectedPlayer expectedGroups[] =
|
||||
{
|
||||
{
|
||||
.expectedDpid = 0x5e7,
|
||||
.expectedPlayerType = DPPLAYERTYPE_GROUP,
|
||||
.expectedShortName = "short name",
|
||||
.expectedLongName = "long name",
|
||||
.expectedFlags = DPENUMPLAYERS_REMOTE,
|
||||
.expectedPlayerData = expectedPlayerData,
|
||||
.expectedPlayerDataSize = sizeof( expectedPlayerData ),
|
||||
},
|
||||
};
|
||||
ExpectedPlayer expectedGroupPlayers[] =
|
||||
{
|
||||
{
|
||||
.expectedDpid = 0xd00de,
|
||||
.expectedPlayerType = DPPLAYERTYPE_PLAYER,
|
||||
.expectedFlags = DPENUMPLAYERS_REMOTE,
|
||||
},
|
||||
};
|
||||
|
||||
checkPlayerList_( line, dp, expectedPlayers, ARRAYSIZE( expectedPlayers ) );
|
||||
checkGroupList_( line, dp, expectedGroups, ARRAYSIZE( expectedGroups ) );
|
||||
checkGroupPlayerList_( line, 0x5e7, dp, expectedGroupPlayers, ARRAYSIZE( expectedGroupPlayers ) );
|
||||
|
||||
hr = IDirectPlayX_Close( dp );
|
||||
checkHR( DP_OK, hr );
|
||||
|
|
@ -4855,20 +4648,20 @@ static void test_CreatePlayer(void)
|
|||
|
||||
/* Player name */
|
||||
dpid = 0xdeadbeef;
|
||||
check_CreatePlayer( dp, &dpid, NULL, 0, DP_OK, 2, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 2 );
|
||||
check_CreatePlayer( dp, &dpid, NULL, 0, DP_OK, 2, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 1 );
|
||||
|
||||
dpid = 0xdeadbeef;
|
||||
check_CreatePlayer( dp, &dpid, &fullName, 0, DP_OK, 3, recvSock, TRUE, 0x8, L"short player name",
|
||||
"short player name", L"long player name", "long player name", 3 );
|
||||
"short player name", L"long player name", "long player name", 2 );
|
||||
|
||||
name = fullName;
|
||||
name.dwSize = 1;
|
||||
dpid = 0xdeadbeef;
|
||||
check_CreatePlayer( dp, &dpid, &name, 0, DP_OK, 4, recvSock, TRUE, 0x8, L"short player name", "short player name",
|
||||
L"long player name", "long player name", 4 );
|
||||
L"long player name", "long player name", 3 );
|
||||
|
||||
dpid = 0xdeadbeef;
|
||||
check_CreatePlayer( dp, &dpid, &nullName, 0, DP_OK, 5, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 5 );
|
||||
check_CreatePlayer( dp, &dpid, &nullName, 0, DP_OK, 5, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 4 );
|
||||
|
||||
/* Null dpid */
|
||||
dpid = 0xdeadbeef;
|
||||
|
|
@ -4876,11 +4669,11 @@ static void test_CreatePlayer(void)
|
|||
|
||||
/* Flags */
|
||||
dpid = 0xdeadbeef;
|
||||
check_CreatePlayer( dp, &dpid, NULL, 0, DP_OK, 6, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 6 );
|
||||
check_CreatePlayer( dp, &dpid, NULL, 0, DP_OK, 6, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 5 );
|
||||
|
||||
dpid = 0xdeadbeef;
|
||||
check_CreatePlayer( dp, &dpid, NULL, DPPLAYER_SPECTATOR, DP_OK, 7, recvSock, TRUE, 0x208, NULL, NULL, NULL, NULL,
|
||||
7 );
|
||||
6 );
|
||||
|
||||
closesocket( recvSock );
|
||||
closesocket( sendSock );
|
||||
|
|
@ -5127,7 +4920,7 @@ static void test_CREATEPLAYER(void)
|
|||
checkPlayerExists( dp, 0x07734, DPPLAYERTYPE_PLAYER, "new player short name", "new player long name",
|
||||
DPENUMPLAYERS_REMOTE, playerData, sizeof( playerData ) );
|
||||
|
||||
dpid = checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x07734, 4, playerData, sizeof( playerData ),
|
||||
dpid = checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x07734, 3, playerData, sizeof( playerData ),
|
||||
"new player short name", "new player long name", 0, 0 );
|
||||
ok( dpid == 0x11223344, "got destination id %#lx.\n", dpid );
|
||||
|
||||
|
|
@ -8059,7 +7852,7 @@ static void test_Send(void)
|
|||
createPlayer( dp, 0x07734, NULL, NULL, 0, 0, sendSock, recvSock );
|
||||
createPlayer( dp, 0x14, NULL, NULL, 0, 0, sendSock, recvSock );
|
||||
|
||||
checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x14, 3, NULL, 0, NULL, NULL, 0, DPPLAYER_LOCAL );
|
||||
checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x14, 2, NULL, 0, NULL, NULL, 0, DPPLAYER_LOCAL );
|
||||
|
||||
hr = IDirectPlayX_Send( dp, 0x07734, 0xdeadbeef, DPSEND_GUARANTEED, data, sizeof( data ) );
|
||||
todo_wine ok( hr == DPERR_INVALIDPARAM, "got hr %#lx.\n", hr );
|
||||
|
|
@ -8496,7 +8289,7 @@ static void test_Receive(void)
|
|||
waitResult = WaitForSingleObject( event0, 2000 );
|
||||
ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
|
||||
|
||||
checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x14, 3, NULL, 0, NULL, NULL, 0, DPPLAYER_LOCAL );
|
||||
checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x14, 2, NULL, 0, NULL, NULL, 0, DPPLAYER_LOCAL );
|
||||
|
||||
sendGuaranteedGameMessage( sendSock, 2349, 0x1337, 0x07734, data0, sizeof( data0 ) );
|
||||
sendGuaranteedGameMessage( sendSock, 2349, 0x1337, 0x14, data1, sizeof( data1 ) );
|
||||
|
|
|
|||
|
|
@ -2388,19 +2388,7 @@ static void WINAPI WineJSDispatch_Free(IWineJSDispatch *iface)
|
|||
{
|
||||
jsdisp_t *This = impl_from_IWineJSDispatch(iface);
|
||||
jsdisp_free(This);
|
||||
}
|
||||
|
||||
static HRESULT WINAPI WineJSDispatch_GetPropertyFlags(IWineJSDispatch *iface, DISPID id, UINT32 *ret)
|
||||
{
|
||||
jsdisp_t *This = impl_from_IWineJSDispatch(iface);
|
||||
dispex_prop_t *prop = get_prop(This, id);
|
||||
|
||||
if(!prop || prop->type == PROP_DELETED || prop->type == PROP_PROTREF)
|
||||
return DISP_E_MEMBERNOTFOUND;
|
||||
|
||||
*ret = prop->flags & PROPF_PUBLIC_MASK;
|
||||
return S_OK;
|
||||
}
|
||||
}
|
||||
|
||||
static HRESULT WINAPI WineJSDispatch_GetScriptGlobal(IWineJSDispatch *iface, IWineJSDispatchHost **ret)
|
||||
{
|
||||
|
|
@ -2434,7 +2422,6 @@ static IWineJSDispatchVtbl DispatchExVtbl = {
|
|||
DispatchEx_GetNextDispID,
|
||||
DispatchEx_GetNameSpaceParent,
|
||||
WineJSDispatch_Free,
|
||||
WineJSDispatch_GetPropertyFlags,
|
||||
WineJSDispatch_GetScriptGlobal,
|
||||
};
|
||||
|
||||
|
|
@ -3295,14 +3282,8 @@ HRESULT jsdisp_define_property(jsdisp_t *obj, const WCHAR *name, property_desc_t
|
|||
if(desc->explicit_value) {
|
||||
if(prop->type == PROP_JSVAL)
|
||||
jsval_release(prop->u.val);
|
||||
else {
|
||||
if(prop->type == PROP_EXTERN && obj->builtin_info->prop_delete) {
|
||||
hres = obj->builtin_info->prop_delete(obj, prop->u.id);
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
}
|
||||
else
|
||||
prop->type = PROP_JSVAL;
|
||||
}
|
||||
hres = jsval_copy(desc->value, &prop->u.val);
|
||||
if(FAILED(hres)) {
|
||||
prop->u.val = jsval_undefined();
|
||||
|
|
|
|||
|
|
@ -943,7 +943,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Function", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Function", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->function_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -952,7 +952,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Object", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Object", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->object_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -961,7 +961,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Array", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Array", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->array_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -970,7 +970,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Boolean", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Boolean", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->bool_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -979,7 +979,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Date", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Date", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->date_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -988,7 +988,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Enumerator", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Enumerator", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->enumerator_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -997,42 +997,42 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Error", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Error", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"EvalError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"EvalError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->eval_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"RangeError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"RangeError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->range_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"ReferenceError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"ReferenceError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->reference_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"RegExpError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"RegExpError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->regexp_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"SyntaxError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"SyntaxError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->syntax_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"TypeError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"TypeError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->type_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"URIError", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"URIError", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->uri_error_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1041,7 +1041,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Number", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Number", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->number_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1050,7 +1050,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"RegExp", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"RegExp", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->regexp_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1059,7 +1059,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"String", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"String", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->string_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1068,7 +1068,7 @@ static HRESULT init_constructors(script_ctx_t *ctx, jsdisp_t *object_prototype)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"VBArray", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"VBArray", PROPF_WRITABLE,
|
||||
jsval_obj(ctx->vbarray_constr));
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1105,7 +1105,7 @@ HRESULT init_global(script_ctx_t *ctx)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Math", PROPF_CONFIGURABLE | PROPF_WRITABLE, jsval_obj(math));
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Math", PROPF_WRITABLE, jsval_obj(math));
|
||||
jsdisp_release(math);
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1117,7 +1117,7 @@ HRESULT init_global(script_ctx_t *ctx)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"JSON", PROPF_CONFIGURABLE | PROPF_WRITABLE, jsval_obj(json));
|
||||
hres = jsdisp_define_data_property(ctx->global, L"JSON", PROPF_WRITABLE, jsval_obj(json));
|
||||
jsdisp_release(json);
|
||||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
|
@ -1127,7 +1127,7 @@ HRESULT init_global(script_ctx_t *ctx)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"ActiveXObject", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"ActiveXObject", PROPF_WRITABLE,
|
||||
jsval_obj(constr));
|
||||
jsdisp_release(constr);
|
||||
if(FAILED(hres))
|
||||
|
|
|
|||
|
|
@ -51,7 +51,6 @@ interface IWineJSDispatchHost;
|
|||
interface IWineJSDispatch : IDispatchEx
|
||||
{
|
||||
void Free();
|
||||
HRESULT GetPropertyFlags(DISPID id, UINT32 *ret);
|
||||
HRESULT GetScriptGlobal(IWineJSDispatchHost **ret);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -903,7 +903,7 @@ HRESULT init_set_constructor(script_ctx_t *ctx)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Set", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Set", PROPF_WRITABLE,
|
||||
jsval_obj(constructor));
|
||||
jsdisp_release(constructor);
|
||||
if(FAILED(hres))
|
||||
|
|
@ -918,7 +918,7 @@ HRESULT init_set_constructor(script_ctx_t *ctx)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Map", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"Map", PROPF_WRITABLE,
|
||||
jsval_obj(constructor));
|
||||
jsdisp_release(constructor);
|
||||
if(FAILED(hres))
|
||||
|
|
@ -933,7 +933,7 @@ HRESULT init_set_constructor(script_ctx_t *ctx)
|
|||
if(FAILED(hres))
|
||||
return hres;
|
||||
|
||||
hres = jsdisp_define_data_property(ctx->global, L"WeakMap", PROPF_CONFIGURABLE | PROPF_WRITABLE,
|
||||
hres = jsdisp_define_data_property(ctx->global, L"WeakMap", PROPF_WRITABLE,
|
||||
jsval_obj(constructor));
|
||||
jsdisp_release(constructor);
|
||||
return hres;
|
||||
|
|
|
|||
|
|
@ -50,6 +50,5 @@ void update_browser_script_mode(GeckoBrowser*,IUri*);
|
|||
BOOL find_global_prop(HTMLInnerWindow*,const WCHAR*,DWORD,ScriptHost**,DISPID*);
|
||||
HRESULT global_prop_still_exists(HTMLInnerWindow*,global_prop_t*);
|
||||
IDispatch *get_script_disp(ScriptHost*);
|
||||
IWineJSDispatch *get_script_jsdisp(ScriptHost*);
|
||||
IActiveScriptSite *get_first_script_site(HTMLInnerWindow*);
|
||||
void initialize_script_global(HTMLInnerWindow*);
|
||||
|
|
|
|||
|
|
@ -4029,9 +4029,7 @@ static HRESULT HTMLWindow_next_dispid(DispatchEx *dispex, DISPID id, DISPID *pid
|
|||
HRESULT HTMLWindow_get_prop_desc(DispatchEx *dispex, DISPID id, struct property_info *desc)
|
||||
{
|
||||
HTMLInnerWindow *This = impl_from_DispatchEx(dispex);
|
||||
IWineJSDispatch *jsdisp;
|
||||
global_prop_t *prop;
|
||||
HRESULT hres = S_OK;
|
||||
|
||||
if(id - MSHTML_DISPID_CUSTOM_MIN >= This->global_prop_cnt)
|
||||
return DISP_E_MEMBERNOTFOUND;
|
||||
|
|
@ -4040,22 +4038,10 @@ HRESULT HTMLWindow_get_prop_desc(DispatchEx *dispex, DISPID id, struct property_
|
|||
desc->name = prop->name;
|
||||
desc->id = id;
|
||||
desc->flags = PROPF_WRITABLE | PROPF_CONFIGURABLE;
|
||||
desc->iid = 0;
|
||||
|
||||
switch(prop->type) {
|
||||
case GLOBAL_SCRIPTVAR: {
|
||||
if((jsdisp = get_script_jsdisp(prop->script_host)))
|
||||
hres = IWineJSDispatch_GetPropertyFlags(jsdisp, prop->id, &desc->flags);
|
||||
break;
|
||||
}
|
||||
case GLOBAL_DISPEXVAR:
|
||||
if(prop->type == GLOBAL_DISPEXVAR)
|
||||
desc->flags |= PROPF_ENUMERABLE;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return hres;
|
||||
desc->iid = 0;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HTMLInnerWindow *HTMLWindow_get_script_global(DispatchEx *dispex)
|
||||
|
|
|
|||
|
|
@ -85,7 +85,7 @@ struct ScriptHost {
|
|||
SCRIPTSTATE script_state;
|
||||
|
||||
HTMLInnerWindow *window;
|
||||
IWineJSDispatch *script_jsdisp;
|
||||
IDispatchEx *script_dispex;
|
||||
|
||||
GUID guid;
|
||||
struct list entry;
|
||||
|
|
@ -264,7 +264,7 @@ static BOOL init_script_engine(ScriptHost *script_host, IActiveScript *script)
|
|||
if(FAILED(hres))
|
||||
WARN("GetScriptDispatch failed: %08lx\n", hres);
|
||||
else {
|
||||
IDispatch_QueryInterface(script_disp, &IID_IWineJSDispatch, (void**)&script_host->script_jsdisp);
|
||||
IDispatch_QueryInterface(script_disp, &IID_IDispatchEx, (void**)&script_host->script_dispex);
|
||||
IDispatch_Release(script_disp);
|
||||
}
|
||||
}
|
||||
|
|
@ -301,8 +301,8 @@ static void release_script_engine(ScriptHost *This)
|
|||
unlink_ref(&This->parse);
|
||||
}
|
||||
|
||||
if(This->script_jsdisp)
|
||||
IWineJSDispatch_Release(This->script_jsdisp);
|
||||
if(This->script_dispex)
|
||||
IDispatchEx_Release(This->script_dispex);
|
||||
IActiveScript_Release(This->script);
|
||||
This->script = NULL;
|
||||
This->script_state = SCRIPTSTATE_UNINITIALIZED;
|
||||
|
|
@ -1588,11 +1588,6 @@ IDispatch *get_script_disp(ScriptHost *script_host)
|
|||
return disp;
|
||||
}
|
||||
|
||||
IWineJSDispatch *get_script_jsdisp(ScriptHost *script_host)
|
||||
{
|
||||
return script_host->script_jsdisp;
|
||||
}
|
||||
|
||||
IActiveScriptSite *get_first_script_site(HTMLInnerWindow *window)
|
||||
{
|
||||
if(list_empty(&window->script_hosts)) {
|
||||
|
|
@ -1855,9 +1850,9 @@ HRESULT global_prop_still_exists(HTMLInnerWindow *window, global_prop_t *prop)
|
|||
|
||||
if(!prop->script_host->script)
|
||||
return E_UNEXPECTED;
|
||||
if(!prop->script_host->script_jsdisp)
|
||||
if(!prop->script_host->script_dispex)
|
||||
return S_OK;
|
||||
return IWineJSDispatch_GetMemberProperties(prop->script_host->script_jsdisp, prop->id, 0, &properties);
|
||||
return IDispatchEx_GetMemberProperties(prop->script_host->script_dispex, prop->id, 0, &properties);
|
||||
}
|
||||
case GLOBAL_ELEMENTVAR: {
|
||||
IHTMLElement *elem;
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@ var JS_E_NUMBER_EXPECTED = 0x800a1389;
|
|||
var JS_E_FUNCTION_EXPECTED = 0x800a138a;
|
||||
var JS_E_DATE_EXPECTED = 0x800a138e;
|
||||
var JS_E_OBJECT_EXPECTED = 0x800a138f;
|
||||
var JS_E_UNDEFINED_VARIABLE = 0x800a1391;
|
||||
var JS_E_BOOLEAN_EXPECTED = 0x800a1392;
|
||||
var JS_E_VBARRAY_EXPECTED = 0x800a1395;
|
||||
var JS_E_ENUMERATOR_EXPECTED = 0x800a1397;
|
||||
|
|
@ -2154,109 +2153,6 @@ sync_test("builtin_context", function() {
|
|||
ok(obj.length === 1, "obj.length = " + obj.length);
|
||||
});
|
||||
|
||||
sync_test("globals override", function() {
|
||||
wineprop = 1337; /* global */
|
||||
ok(window.hasOwnProperty("wineprop"), "wineprop not a prop of window");
|
||||
ok(window.wineprop === 1337, "window.wineprop = " + window.wineprop);
|
||||
ok(wineprop === 1337, "wineprop = " + wineprop);
|
||||
|
||||
var i, desc, r = Object.defineProperty(window, "wineprop", { value: 42, configurable: true });
|
||||
ok(r === window, "defineProperty(window.wineprop) returned " + r);
|
||||
ok(window.hasOwnProperty("wineprop"), "wineprop not a prop of window after override");
|
||||
ok(window.wineprop === 42, "window.wineprop after override = " + window.wineprop);
|
||||
ok(wineprop === 42, "wineprop after override = " + wineprop);
|
||||
|
||||
r = (delete window.wineprop);
|
||||
ok(r === true, "delete window.wineprop returned " + r);
|
||||
ok(!("wineprop" in window), "wineprop in window after delete");
|
||||
|
||||
/* configurable */
|
||||
var builtins = [
|
||||
"ActiveXObject",
|
||||
"Array",
|
||||
"ArrayBuffer",
|
||||
"Boolean",
|
||||
"CollectGarbage",
|
||||
"DataView",
|
||||
"Date",
|
||||
"decodeURI",
|
||||
"decodeURIComponent",
|
||||
"encodeURI",
|
||||
"encodeURIComponent",
|
||||
"Enumerator",
|
||||
"Error",
|
||||
"escape",
|
||||
"EvalError",
|
||||
"Function",
|
||||
"isFinite",
|
||||
"isNaN",
|
||||
"JSON",
|
||||
"Map",
|
||||
"Math",
|
||||
"Number",
|
||||
"parseFloat",
|
||||
"parseInt",
|
||||
"RangeError",
|
||||
"ReferenceError",
|
||||
"RegExp",
|
||||
"ScriptEngine",
|
||||
"ScriptEngineBuildVersion",
|
||||
"ScriptEngineMajorVersion",
|
||||
"ScriptEngineMinorVersion",
|
||||
"Set",
|
||||
"String",
|
||||
"SyntaxError",
|
||||
"TypeError",
|
||||
"unescape",
|
||||
"URIError",
|
||||
"VBArray",
|
||||
"WeakMap"
|
||||
];
|
||||
for(i = 0; i < builtins.length; i++) {
|
||||
desc = Object.getOwnPropertyDescriptor(window, builtins[i]);
|
||||
ok(desc !== undefined, "getOwnPropertyDescriptor('" + builtins[i] + "' returned undefined");
|
||||
ok(desc.configurable === true, builtins[i] + " not configurable");
|
||||
ok(desc.enumerable === false, builtins[i] + " is enumerable");
|
||||
ok(desc.writable === true, builtins[i] + " not writable");
|
||||
|
||||
r = Object.defineProperty(window, builtins[i], { value: 12, configurable: true, writable: true });
|
||||
ok(r === window, "defineProperty('" + builtins[i] + "' returned " + r);
|
||||
r = Object.getOwnPropertyDescriptor(window, builtins[i]);
|
||||
ok(r !== undefined, "getOwnPropertyDescriptor('" + builtins[i] + "' after override returned undefined");
|
||||
ok(r.value === 12, builtins[i] + " value = " + r.value);
|
||||
|
||||
r = eval(builtins[i]);
|
||||
ok(r === window[builtins[i]], "Global " + builtins[i] + " does not match redefined window." + builtins[i]);
|
||||
r = (delete window[builtins[i]]);
|
||||
ok(r === true, "delete window." + builtins[i] + " returned " + r);
|
||||
ok(!(builtins[i] in window), builtins[i] + " in window after delete");
|
||||
try {
|
||||
eval(builtins[i]);
|
||||
ok(false, "expected exception retrieving global " + builtins[i] + " after delete.");
|
||||
}catch(ex) {
|
||||
r = ex.number >>> 0;
|
||||
ok(r === JS_E_UNDEFINED_VARIABLE, "retrieving global " + builtins[i] + " after delete threw " + r);
|
||||
}
|
||||
|
||||
r = Object.defineProperty(window, builtins[i], desc);
|
||||
ok(r === window, "defineProperty('" + builtins[i] + "' to restore returned " + r);
|
||||
}
|
||||
|
||||
/* non-configurable */
|
||||
builtins = [
|
||||
"undefined",
|
||||
"Infinity",
|
||||
"NaN"
|
||||
];
|
||||
for(i = 0; i < builtins.length; i++) {
|
||||
desc = Object.getOwnPropertyDescriptor(window, builtins[i]);
|
||||
ok(desc !== undefined, "getOwnPropertyDescriptor('" + builtins[i] + "' returned undefined");
|
||||
ok(desc.configurable === false, builtins[i] + " is configurable");
|
||||
ok(desc.enumerable === false, builtins[i] + " is enumerable");
|
||||
ok(desc.writable === false, builtins[i] + " is writable");
|
||||
}
|
||||
});
|
||||
|
||||
sync_test("host this", function() {
|
||||
var tests = [ undefined, null, external.nullDisp, function() {}, [0], "foobar", true, 42, new Number(42), external.testHostContext(true), window, document ];
|
||||
var i, obj = Object.create(Function.prototype);
|
||||
|
|
|
|||
|
|
@ -687,7 +687,7 @@ static void invoke_system_apc( const union apc_call *call, union apc_result *res
|
|||
/***********************************************************************
|
||||
* server_select
|
||||
*/
|
||||
unsigned int server_select( const union select_op *select_op, data_size_t size, UINT flags,
|
||||
unsigned int server_select( const select_op_t *select_op, data_size_t size, UINT flags,
|
||||
timeout_t abs_timeout, context_t *context, struct user_apc *user_apc )
|
||||
{
|
||||
unsigned int ret;
|
||||
|
|
@ -740,7 +740,7 @@ unsigned int server_select( const union select_op *select_op, data_size_t size,
|
|||
|
||||
/* don't signal multiple times */
|
||||
if (size >= sizeof(select_op->signal_and_wait) && select_op->op == SELECT_SIGNAL_AND_WAIT)
|
||||
size = offsetof( union select_op, signal_and_wait.signal );
|
||||
size = offsetof( select_op_t, signal_and_wait.signal );
|
||||
}
|
||||
pthread_sigmask( SIG_SETMASK, &old_set, NULL );
|
||||
if (signaled) break;
|
||||
|
|
@ -763,7 +763,7 @@ unsigned int server_select( const union select_op *select_op, data_size_t size,
|
|||
/***********************************************************************
|
||||
* server_wait
|
||||
*/
|
||||
unsigned int server_wait( const union select_op *select_op, data_size_t size, UINT flags,
|
||||
unsigned int server_wait( const select_op_t *select_op, data_size_t size, UINT flags,
|
||||
const LARGE_INTEGER *timeout )
|
||||
{
|
||||
timeout_t abs_timeout = timeout ? timeout->QuadPart : TIMEOUT_INFINITE;
|
||||
|
|
|
|||
|
|
@ -993,7 +993,7 @@ NTSTATUS WINAPI NtSetInformationDebugObject( HANDLE handle, DEBUGOBJECTINFOCLASS
|
|||
|
||||
|
||||
/* convert the server event data to an NT state change; helper for NtWaitForDebugEvent */
|
||||
static NTSTATUS event_data_to_state_change( const union debug_event_data *data, DBGUI_WAIT_STATE_CHANGE *state )
|
||||
static NTSTATUS event_data_to_state_change( const debug_event_t *data, DBGUI_WAIT_STATE_CHANGE *state )
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
@ -1098,7 +1098,7 @@ static NTSTATUS get_image_machine( HANDLE handle, USHORT *machine )
|
|||
NTSTATUS WINAPI NtWaitForDebugEvent( HANDLE handle, BOOLEAN alertable, LARGE_INTEGER *timeout,
|
||||
DBGUI_WAIT_STATE_CHANGE *state )
|
||||
{
|
||||
union debug_event_data data;
|
||||
debug_event_t data;
|
||||
unsigned int ret;
|
||||
BOOL wait = TRUE;
|
||||
|
||||
|
|
@ -1572,7 +1572,7 @@ NTSTATUS WINAPI NtQueryTimer( HANDLE handle, TIMER_INFORMATION_CLASS class,
|
|||
NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles, BOOLEAN wait_any,
|
||||
BOOLEAN alertable, const LARGE_INTEGER *timeout )
|
||||
{
|
||||
union select_op select_op;
|
||||
select_op_t select_op;
|
||||
UINT i, flags = SELECT_INTERRUPTIBLE;
|
||||
|
||||
if (!count || count > MAXIMUM_WAIT_OBJECTS) return STATUS_INVALID_PARAMETER_1;
|
||||
|
|
@ -1580,7 +1580,7 @@ NTSTATUS WINAPI NtWaitForMultipleObjects( DWORD count, const HANDLE *handles, BO
|
|||
if (alertable) flags |= SELECT_ALERTABLE;
|
||||
select_op.wait.op = wait_any ? SELECT_WAIT : SELECT_WAIT_ALL;
|
||||
for (i = 0; i < count; i++) select_op.wait.handles[i] = wine_server_obj_handle( handles[i] );
|
||||
return server_wait( &select_op, offsetof( union select_op, wait.handles[count] ), flags, timeout );
|
||||
return server_wait( &select_op, offsetof( select_op_t, wait.handles[count] ), flags, timeout );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1599,7 +1599,7 @@ NTSTATUS WINAPI NtWaitForSingleObject( HANDLE handle, BOOLEAN alertable, const L
|
|||
NTSTATUS WINAPI NtSignalAndWaitForSingleObject( HANDLE signal, HANDLE wait,
|
||||
BOOLEAN alertable, const LARGE_INTEGER *timeout )
|
||||
{
|
||||
union select_op select_op;
|
||||
select_op_t select_op;
|
||||
UINT flags = SELECT_INTERRUPTIBLE;
|
||||
|
||||
if (!signal) return STATUS_INVALID_HANDLE;
|
||||
|
|
@ -1883,7 +1883,7 @@ NTSTATUS WINAPI NtOpenKeyedEvent( HANDLE *handle, ACCESS_MASK access, const OBJE
|
|||
NTSTATUS WINAPI NtWaitForKeyedEvent( HANDLE handle, const void *key,
|
||||
BOOLEAN alertable, const LARGE_INTEGER *timeout )
|
||||
{
|
||||
union select_op select_op;
|
||||
select_op_t select_op;
|
||||
UINT flags = SELECT_INTERRUPTIBLE;
|
||||
|
||||
if (!handle) handle = keyed_event;
|
||||
|
|
@ -1902,7 +1902,7 @@ NTSTATUS WINAPI NtWaitForKeyedEvent( HANDLE handle, const void *key,
|
|||
NTSTATUS WINAPI NtReleaseKeyedEvent( HANDLE handle, const void *key,
|
||||
BOOLEAN alertable, const LARGE_INTEGER *timeout )
|
||||
{
|
||||
union select_op select_op;
|
||||
select_op_t select_op;
|
||||
UINT flags = SELECT_INTERRUPTIBLE;
|
||||
|
||||
if (!handle) handle = keyed_event;
|
||||
|
|
|
|||
|
|
@ -1512,7 +1512,7 @@ NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_c
|
|||
DWORD i;
|
||||
obj_handle_t handle = 0;
|
||||
client_ptr_t params[EXCEPTION_MAXIMUM_PARAMETERS];
|
||||
union select_op select_op;
|
||||
select_op_t select_op;
|
||||
sigset_t old_set;
|
||||
|
||||
if (!peb->BeingDebugged) return 0; /* no debugger present */
|
||||
|
|
@ -1545,7 +1545,7 @@ NTSTATUS send_debug_event( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_c
|
|||
contexts_to_server( server_contexts, context );
|
||||
server_contexts[0].flags |= SERVER_CTX_EXEC_SPACE;
|
||||
server_contexts[0].exec_space.space.space = exception ? EXEC_SPACE_EXCEPTION : EXEC_SPACE_SYSCALL;
|
||||
server_select( &select_op, offsetof( union select_op, wait.handles[1] ), SELECT_INTERRUPTIBLE,
|
||||
server_select( &select_op, offsetof( select_op_t, wait.handles[1] ), SELECT_INTERRUPTIBLE,
|
||||
TIMEOUT_INFINITE, server_contexts, NULL );
|
||||
|
||||
SERVER_START_REQ( get_exception_status )
|
||||
|
|
|
|||
|
|
@ -208,9 +208,9 @@ extern void start_server( BOOL debug );
|
|||
extern unsigned int server_call_unlocked( void *req_ptr );
|
||||
extern void server_enter_uninterrupted_section( pthread_mutex_t *mutex, sigset_t *sigset );
|
||||
extern void server_leave_uninterrupted_section( pthread_mutex_t *mutex, sigset_t *sigset );
|
||||
extern unsigned int server_select( const union select_op *select_op, data_size_t size, UINT flags,
|
||||
extern unsigned int server_select( const select_op_t *select_op, data_size_t size, UINT flags,
|
||||
timeout_t abs_timeout, context_t *context, struct user_apc *user_apc );
|
||||
extern unsigned int server_wait( const union select_op *select_op, data_size_t size, UINT flags,
|
||||
extern unsigned int server_wait( const select_op_t *select_op, data_size_t size, UINT flags,
|
||||
const LARGE_INTEGER *timeout );
|
||||
extern unsigned int server_queue_process_apc( HANDLE process, const union apc_call *call,
|
||||
union apc_result *result );
|
||||
|
|
|
|||
|
|
@ -506,7 +506,7 @@ static NTSTATUS WINAPI dispatch_irp_completion( DEVICE_OBJECT *device, IRP *irp,
|
|||
|
||||
struct dispatch_context
|
||||
{
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
HANDLE handle;
|
||||
struct irp_data *irp_data;
|
||||
ULONG in_size;
|
||||
|
|
|
|||
|
|
@ -4067,8 +4067,11 @@ static void test_SetForegroundWindow(HWND hwnd)
|
|||
while (PeekMessageA(&msg, 0, 0, 0, PM_REMOVE)) DispatchMessageA(&msg);
|
||||
if (0) check_wnd_state(hwnd2, hwnd2, hwnd2, 0);
|
||||
|
||||
ok(GetActiveWindow() == hwnd2, "Expected active window %p, got %p.\n", hwnd2, GetActiveWindow());
|
||||
ok(GetFocus() == hwnd2, "Expected focus window %p, got %p.\n", hwnd2, GetFocus());
|
||||
/* FIXME: these tests are failing because of a race condition
|
||||
* between internal focus state applied immediately and X11 focus
|
||||
* message coming late */
|
||||
todo_wine ok(GetActiveWindow() == hwnd2, "Expected active window %p, got %p.\n", hwnd2, GetActiveWindow());
|
||||
todo_wine ok(GetFocus() == hwnd2, "Expected focus window %p, got %p.\n", hwnd2, GetFocus());
|
||||
|
||||
SetForegroundWindow(hwnd);
|
||||
check_wnd_state(hwnd, hwnd, hwnd, 0);
|
||||
|
|
|
|||
|
|
@ -2729,7 +2729,7 @@ int peek_message( MSG *msg, const struct peek_message_filter *filter )
|
|||
{
|
||||
NTSTATUS res;
|
||||
size_t size = 0;
|
||||
const union message_data *msg_data = buffer;
|
||||
const message_data_t *msg_data = buffer;
|
||||
UINT wake_mask, signal_bits, wake_bits, changed_bits, clear_bits = 0;
|
||||
|
||||
/* use the same logic as in server/queue.c get_message */
|
||||
|
|
@ -3320,7 +3320,7 @@ BOOL WINAPI NtUserGetMessage( MSG *msg, HWND hwnd, UINT first, UINT last )
|
|||
static BOOL put_message_in_queue( const struct send_message_info *info, size_t *reply_size )
|
||||
{
|
||||
struct packed_message data;
|
||||
union message_data msg_data;
|
||||
message_data_t msg_data;
|
||||
unsigned int res;
|
||||
int i;
|
||||
timeout_t timeout = TIMEOUT_INFINITE;
|
||||
|
|
|
|||
|
|
@ -275,11 +275,10 @@ static void handle_DeviceMatchingCallback(void *context, IOReturn result, void *
|
|||
.serialnumber = {'0','0','0','0',0},
|
||||
};
|
||||
struct iohid_device *impl;
|
||||
USAGE_AND_PAGE usages;
|
||||
CFStringRef str;
|
||||
|
||||
usages.UsagePage = CFNumberToDWORD(IOHIDDeviceGetProperty(IOHIDDevice, CFSTR(kIOHIDPrimaryUsagePageKey)));
|
||||
usages.Usage = CFNumberToDWORD(IOHIDDeviceGetProperty(IOHIDDevice, CFSTR(kIOHIDPrimaryUsageKey)));
|
||||
desc.usages.UsagePage = CFNumberToDWORD(IOHIDDeviceGetProperty(IOHIDDevice, CFSTR(kIOHIDPrimaryUsagePageKey)));
|
||||
desc.usages.Usage = CFNumberToDWORD(IOHIDDeviceGetProperty(IOHIDDevice, CFSTR(kIOHIDPrimaryUsageKey)));
|
||||
|
||||
desc.vid = CFNumberToDWORD(IOHIDDeviceGetProperty(IOHIDDevice, CFSTR(kIOHIDVendorIDKey)));
|
||||
desc.pid = CFNumberToDWORD(IOHIDDeviceGetProperty(IOHIDDevice, CFSTR(kIOHIDProductIDKey)));
|
||||
|
|
@ -290,8 +289,8 @@ static void handle_DeviceMatchingCallback(void *context, IOReturn result, void *
|
|||
desc.is_bluetooth = !CFStringCompare(str, CFSTR(kIOHIDTransportBluetoothValue), 0) ||
|
||||
!CFStringCompare(str, CFSTR(kIOHIDTransportBluetoothLowEnergyValue), 0);
|
||||
|
||||
if (usages.UsagePage != HID_USAGE_PAGE_GENERIC ||
|
||||
!(usages.Usage == HID_USAGE_GENERIC_JOYSTICK || usages.Usage == HID_USAGE_GENERIC_GAMEPAD))
|
||||
if (desc.usages.UsagePage != HID_USAGE_PAGE_GENERIC ||
|
||||
!(desc.usages.Usage == HID_USAGE_GENERIC_JOYSTICK || desc.usages.Usage == HID_USAGE_GENERIC_GAMEPAD))
|
||||
{
|
||||
/* winebus isn't currently meant to handle anything but these, and
|
||||
* opening keyboards, mice, or the Touch Bar on older MacBooks triggers
|
||||
|
|
|
|||
|
|
@ -198,7 +198,7 @@ static void set_hat_value(struct unix_device *iface, int index, int value)
|
|||
hid_device_set_hatswitch_y(iface, index, y);
|
||||
}
|
||||
|
||||
static BOOL descriptor_add_haptic(struct sdl_device *impl, BOOL force)
|
||||
static BOOL descriptor_add_haptic(struct sdl_device *impl)
|
||||
{
|
||||
USHORT i, count = 0;
|
||||
USAGE usages[16];
|
||||
|
|
@ -227,16 +227,16 @@ static BOOL descriptor_add_haptic(struct sdl_device *impl, BOOL force)
|
|||
if ((impl->effect_support & EFFECT_SUPPORT_PHYSICAL))
|
||||
{
|
||||
/* SDL_HAPTIC_SQUARE doesn't exist */
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_SINE)) usages[count++] = PID_USAGE_ET_SINE;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_TRIANGLE)) usages[count++] = PID_USAGE_ET_TRIANGLE;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_SAWTOOTHUP)) usages[count++] = PID_USAGE_ET_SAWTOOTH_UP;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_SAWTOOTHDOWN)) usages[count++] = PID_USAGE_ET_SAWTOOTH_DOWN;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_SPRING)) usages[count++] = PID_USAGE_ET_SPRING;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_DAMPER)) usages[count++] = PID_USAGE_ET_DAMPER;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_INERTIA)) usages[count++] = PID_USAGE_ET_INERTIA;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_FRICTION)) usages[count++] = PID_USAGE_ET_FRICTION;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_CONSTANT)) usages[count++] = PID_USAGE_ET_CONSTANT_FORCE;
|
||||
if (force || (impl->effect_support & SDL_HAPTIC_RAMP)) usages[count++] = PID_USAGE_ET_RAMP;
|
||||
if (impl->effect_support & SDL_HAPTIC_SINE) usages[count++] = PID_USAGE_ET_SINE;
|
||||
if (impl->effect_support & SDL_HAPTIC_TRIANGLE) usages[count++] = PID_USAGE_ET_TRIANGLE;
|
||||
if (impl->effect_support & SDL_HAPTIC_SAWTOOTHUP) usages[count++] = PID_USAGE_ET_SAWTOOTH_UP;
|
||||
if (impl->effect_support & SDL_HAPTIC_SAWTOOTHDOWN) usages[count++] = PID_USAGE_ET_SAWTOOTH_DOWN;
|
||||
if (impl->effect_support & SDL_HAPTIC_SPRING) usages[count++] = PID_USAGE_ET_SPRING;
|
||||
if (impl->effect_support & SDL_HAPTIC_DAMPER) usages[count++] = PID_USAGE_ET_DAMPER;
|
||||
if (impl->effect_support & SDL_HAPTIC_INERTIA) usages[count++] = PID_USAGE_ET_INERTIA;
|
||||
if (impl->effect_support & SDL_HAPTIC_FRICTION) usages[count++] = PID_USAGE_ET_FRICTION;
|
||||
if (impl->effect_support & SDL_HAPTIC_CONSTANT) usages[count++] = PID_USAGE_ET_CONSTANT_FORCE;
|
||||
if (impl->effect_support & SDL_HAPTIC_RAMP) usages[count++] = PID_USAGE_ET_RAMP;
|
||||
|
||||
if (!hid_device_add_physical(&impl->unix_device, usages, count))
|
||||
return FALSE;
|
||||
|
|
@ -360,7 +360,7 @@ static NTSTATUS build_joystick_report_descriptor(struct unix_device *iface)
|
|||
if (!hid_device_end_input_report(iface))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
if (!descriptor_add_haptic(impl, physical_usage.Usage == HID_USAGE_SIMULATION_AUTOMOBILE_SIMULATION_DEVICE))
|
||||
if (!descriptor_add_haptic(impl))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
if (!hid_device_end_report_descriptor(iface))
|
||||
|
|
@ -414,7 +414,7 @@ static NTSTATUS build_controller_report_descriptor(struct unix_device *iface)
|
|||
if (!hid_device_end_input_report(iface))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
if (!descriptor_add_haptic(impl, FALSE))
|
||||
if (!descriptor_add_haptic(impl))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
if (!hid_device_end_report_descriptor(iface))
|
||||
|
|
@ -443,12 +443,17 @@ static void sdl_device_destroy(struct unix_device *iface)
|
|||
static NTSTATUS sdl_device_start(struct unix_device *iface)
|
||||
{
|
||||
struct sdl_device *impl = impl_from_unix_device(iface);
|
||||
NTSTATUS status;
|
||||
|
||||
pthread_mutex_lock(&sdl_cs);
|
||||
impl->started = TRUE;
|
||||
|
||||
if (impl->sdl_controller) status = build_controller_report_descriptor(iface);
|
||||
else status = build_joystick_report_descriptor(iface);
|
||||
impl->started = !status;
|
||||
|
||||
pthread_mutex_unlock(&sdl_cs);
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
return status;
|
||||
}
|
||||
|
||||
static void sdl_device_stop(struct unix_device *iface)
|
||||
|
|
@ -590,7 +595,7 @@ static NTSTATUS sdl_device_physical_effect_control(struct unix_device *iface, BY
|
|||
|
||||
TRACE("iface %p, index %u, control %04x, iterations %u.\n", iface, index, control, iterations);
|
||||
|
||||
if (id < 0) return STATUS_SUCCESS;
|
||||
if (impl->effect_ids[index] < 0) return STATUS_UNSUCCESSFUL;
|
||||
|
||||
switch (control)
|
||||
{
|
||||
|
|
@ -986,6 +991,8 @@ static void sdl_add_device(unsigned int index)
|
|||
if (controller)
|
||||
{
|
||||
desc.is_gamepad = TRUE;
|
||||
desc.usages.UsagePage = HID_USAGE_PAGE_GENERIC;
|
||||
desc.usages.Usage = HID_USAGE_GENERIC_GAMEPAD;
|
||||
axis_count = 6;
|
||||
}
|
||||
else
|
||||
|
|
@ -993,12 +1000,12 @@ static void sdl_add_device(unsigned int index)
|
|||
int button_count = pSDL_JoystickNumButtons(joystick);
|
||||
axis_count = pSDL_JoystickNumAxes(joystick);
|
||||
desc.is_gamepad = (axis_count == 6 && button_count >= 14);
|
||||
desc.usages.UsagePage = HID_USAGE_PAGE_GENERIC;
|
||||
desc.usages.Usage = HID_USAGE_GENERIC_JOYSTICK;
|
||||
}
|
||||
|
||||
for (axis_offset = 0; axis_offset < axis_count; axis_offset += (options.split_controllers ? 6 : axis_count))
|
||||
{
|
||||
NTSTATUS status;
|
||||
|
||||
if (!axis_offset) strcpy(buffer, product);
|
||||
else snprintf(buffer, ARRAY_SIZE(buffer), "%s %d", product, axis_offset / 6);
|
||||
ntdll_umbstowcs(buffer, strlen(buffer) + 1, desc.product, ARRAY_SIZE(desc.product));
|
||||
|
|
@ -1012,15 +1019,6 @@ static void sdl_add_device(unsigned int index)
|
|||
impl->id = id;
|
||||
impl->axis_offset = axis_offset;
|
||||
|
||||
if (impl->sdl_controller) status = build_controller_report_descriptor(&impl->unix_device);
|
||||
else status = build_joystick_report_descriptor(&impl->unix_device);
|
||||
if (status)
|
||||
{
|
||||
list_remove(&impl->unix_device.entry);
|
||||
impl->unix_device.vtbl->destroy(&impl->unix_device);
|
||||
return;
|
||||
}
|
||||
|
||||
bus_event_queue_device_created(&event_queue, &impl->unix_device, &desc);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -728,6 +728,12 @@ static void lnxev_device_destroy(struct unix_device *iface)
|
|||
|
||||
static NTSTATUS lnxev_device_start(struct unix_device *iface)
|
||||
{
|
||||
struct lnxev_device *impl = lnxev_impl_from_unix_device(iface);
|
||||
NTSTATUS status;
|
||||
|
||||
if ((status = build_report_descriptor(iface, impl->base.udev_device)))
|
||||
return status;
|
||||
|
||||
pthread_mutex_lock(&udev_cs);
|
||||
start_polling_device(iface);
|
||||
pthread_mutex_unlock(&udev_cs);
|
||||
|
|
@ -1248,6 +1254,7 @@ static void udev_add_device(struct udev_device *dev, int fd)
|
|||
#ifdef HAS_PROPER_INPUT_HEADER
|
||||
else if (!strcmp(subsystem, "input"))
|
||||
{
|
||||
const USAGE_AND_PAGE device_usage = *what_am_I(dev, fd);
|
||||
static const WCHAR evdev[] = {'e','v','d','e','v',0};
|
||||
struct input_id device_id = {0};
|
||||
char buffer[MAX_PATH];
|
||||
|
|
@ -1268,6 +1275,8 @@ static void udev_add_device(struct udev_device *dev, int fd)
|
|||
|
||||
if (!desc.serialnumber[0] && ioctl(fd, EVIOCGUNIQ(sizeof(buffer)), buffer) >= 0)
|
||||
ntdll_umbstowcs(buffer, strlen(buffer) + 1, desc.serialnumber, ARRAY_SIZE(desc.serialnumber));
|
||||
|
||||
desc.usages = device_usage;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -1312,13 +1321,6 @@ static void udev_add_device(struct udev_device *dev, int fd)
|
|||
strcpy(impl->devnode, devnode);
|
||||
impl->device_fd = fd;
|
||||
|
||||
if (build_report_descriptor(&impl->unix_device, impl->udev_device))
|
||||
{
|
||||
list_remove(&impl->unix_device.entry);
|
||||
impl->unix_device.vtbl->destroy(&impl->unix_device);
|
||||
return;
|
||||
}
|
||||
|
||||
bus_event_queue_device_created(&event_queue, &impl->unix_device, &desc);
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -417,7 +417,7 @@ static DWORD check_bus_option(const WCHAR *option, DWORD default_value)
|
|||
return default_value;
|
||||
}
|
||||
|
||||
static BOOL is_hidraw_enabled(WORD vid, WORD pid, const USAGE_AND_PAGE *usages, UINT buttons)
|
||||
static BOOL is_hidraw_enabled(WORD vid, WORD pid, const USAGE_AND_PAGE *usages)
|
||||
{
|
||||
char buffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[1024])];
|
||||
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
|
||||
|
|
@ -436,48 +436,6 @@ static BOOL is_hidraw_enabled(WORD vid, WORD pid, const USAGE_AND_PAGE *usages,
|
|||
if (is_dualshock4_gamepad(vid, pid)) prefer_hidraw = TRUE;
|
||||
if (is_dualsense_gamepad(vid, pid)) prefer_hidraw = TRUE;
|
||||
|
||||
switch (vid)
|
||||
{
|
||||
case 0x044f:
|
||||
if (pid == 0xb679) prefer_hidraw = TRUE; /* ThrustMaster T-Rudder */
|
||||
if (pid == 0xb687) prefer_hidraw = TRUE; /* ThrustMaster TWCS Throttle */
|
||||
if (pid == 0xb10a) prefer_hidraw = TRUE; /* ThrustMaster T.16000M Joystick */
|
||||
break;
|
||||
case 0x16d0:
|
||||
if (pid == 0x0d61) prefer_hidraw = TRUE; /* Simucube 2 Sport */
|
||||
if (pid == 0x0d60) prefer_hidraw = TRUE; /* Simucube 2 Pro */
|
||||
if (pid == 0x0d5f) prefer_hidraw = TRUE; /* Simucube 2 Ultimate */
|
||||
if (pid == 0x0d5a) prefer_hidraw = TRUE; /* Simucube 1 */
|
||||
break;
|
||||
case 0x0eb7:
|
||||
if (pid == 0x183b) prefer_hidraw = TRUE; /* Fanatec ClubSport Pedals v3 */
|
||||
if (pid == 0x1839) prefer_hidraw = TRUE; /* Fanatec ClubSport Pedals v1/v2 */
|
||||
break;
|
||||
case 0x231d:
|
||||
/* comes with 128 buttons in the default configuration */
|
||||
if (buttons == 128) prefer_hidraw = TRUE;
|
||||
/* if customized, less than 128 buttons may be shown, decide by PID */
|
||||
if (pid == 0x0200) prefer_hidraw = TRUE; /* VKBsim Gladiator EVO Right Grip */
|
||||
if (pid == 0x0201) prefer_hidraw = TRUE; /* VKBsim Gladiator EVO Left Grip */
|
||||
if (pid == 0x0126) prefer_hidraw = TRUE; /* VKB-Sim Space Gunfighter */
|
||||
if (pid == 0x0127) prefer_hidraw = TRUE; /* VKB-Sim Space Gunfighter L */
|
||||
break;
|
||||
case 0x3344:
|
||||
/* comes with 31 buttons in the default configuration, or 128 max */
|
||||
if ((buttons == 31) || (buttons == 128)) prefer_hidraw = TRUE;
|
||||
/* users may have configured button limits, usually 32/50/64 */
|
||||
if ((buttons == 32) || (buttons == 50) || (buttons == 64)) prefer_hidraw = TRUE;
|
||||
/* if customized, arbitrary amount of buttons may be shown, decide by PID */
|
||||
if (pid == 0x412f) prefer_hidraw = TRUE; /* Virpil Constellation ALPHA-R */
|
||||
if (pid == 0x812c) prefer_hidraw = TRUE; /* Virpil Constellation ALPHA-L */
|
||||
break;
|
||||
case 0x03eb:
|
||||
/* users may have configured button limits, usually 32/50/64 */
|
||||
if ((buttons == 32) || (buttons == 50) || (buttons == 64)) prefer_hidraw = TRUE;
|
||||
if (pid == 0x2055) prefer_hidraw = TRUE; /* ATMEL/VIRPIL/200325 VPC Throttle MT-50 CM2 */
|
||||
break;
|
||||
}
|
||||
|
||||
RtlInitUnicodeString(&str, L"EnableHidraw");
|
||||
if (!NtQueryValueKey(driver_key, &str, KeyValuePartialInformation, info,
|
||||
sizeof(buffer) - sizeof(WCHAR), &size))
|
||||
|
|
@ -726,41 +684,22 @@ static NTSTATUS get_device_descriptors(UINT64 unix_device, BYTE **report_desc, U
|
|||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
static USAGE_AND_PAGE get_device_usages(UINT64 unix_device, UINT *buttons)
|
||||
static USAGE_AND_PAGE get_hidraw_device_usages(UINT64 unix_device)
|
||||
{
|
||||
HIDP_DEVICE_DESC device_desc;
|
||||
USAGE_AND_PAGE usages = {0};
|
||||
UINT i, count = 0, report_desc_length;
|
||||
HIDP_BUTTON_CAPS *button_caps;
|
||||
UINT report_desc_length;
|
||||
BYTE *report_desc;
|
||||
NTSTATUS status;
|
||||
HIDP_CAPS caps;
|
||||
|
||||
if (!(status = get_device_descriptors(unix_device, &report_desc, &report_desc_length, &device_desc)))
|
||||
{
|
||||
PHIDP_PREPARSED_DATA preparsed = device_desc.CollectionDesc[0].PreparsedData;
|
||||
usages.UsagePage = device_desc.CollectionDesc[0].UsagePage;
|
||||
usages.Usage = device_desc.CollectionDesc[0].Usage;
|
||||
|
||||
if ((status = HidP_GetCaps(preparsed, &caps)) == HIDP_STATUS_SUCCESS &&
|
||||
(button_caps = malloc(sizeof(*button_caps) * caps.NumberInputButtonCaps)))
|
||||
{
|
||||
status = HidP_GetButtonCaps(HidP_Input, button_caps, &caps.NumberInputButtonCaps, preparsed);
|
||||
if (status != HIDP_STATUS_SUCCESS) WARN("HidP_GetButtonCaps returned %#lx\n", status);
|
||||
else for (i = 0; i < caps.NumberInputButtonCaps; i++)
|
||||
{
|
||||
if (button_caps[i].UsagePage != HID_USAGE_PAGE_BUTTON) continue;
|
||||
if (button_caps[i].IsRange) count = max(count, button_caps[i].Range.UsageMax);
|
||||
else count = max(count, button_caps[i].NotRange.Usage);
|
||||
}
|
||||
free(button_caps);
|
||||
}
|
||||
|
||||
HidP_FreeCollectionDescription(&device_desc);
|
||||
RtlFreeHeap(GetProcessHeap(), 0, report_desc);
|
||||
}
|
||||
|
||||
*buttons = count;
|
||||
return usages;
|
||||
}
|
||||
|
||||
|
|
@ -810,21 +749,18 @@ static DWORD CALLBACK bus_main_thread(void *args)
|
|||
case BUS_EVENT_TYPE_DEVICE_CREATED:
|
||||
{
|
||||
struct device_desc desc = event->device_created.desc;
|
||||
USAGE_AND_PAGE usages;
|
||||
UINT buttons;
|
||||
|
||||
usages = get_device_usages(event->device, &buttons);
|
||||
if (!desc.is_hidraw != !is_hidraw_enabled(desc.vid, desc.pid, &usages, buttons))
|
||||
if (desc.is_hidraw && !desc.usages.UsagePage) desc.usages = get_hidraw_device_usages(event->device);
|
||||
if (!desc.is_hidraw != !is_hidraw_enabled(desc.vid, desc.pid, &desc.usages))
|
||||
{
|
||||
struct device_remove_params params = {.device = event->device};
|
||||
WARN("ignoring %shidraw device %04x:%04x with usages %04x:%04x\n", desc.is_hidraw ? "" : "non-",
|
||||
desc.vid, desc.pid, usages.UsagePage, usages.Usage);
|
||||
desc.vid, desc.pid, desc.usages.UsagePage, desc.usages.Usage);
|
||||
winebus_call(device_remove, ¶ms);
|
||||
break;
|
||||
}
|
||||
|
||||
TRACE("creating %shidraw device %04x:%04x with usages %04x:%04x\n", desc.is_hidraw ? "" : "non-",
|
||||
desc.vid, desc.pid, usages.UsagePage, usages.Usage);
|
||||
desc.vid, desc.pid, desc.usages.UsagePage, desc.usages.Usage);
|
||||
|
||||
device = bus_create_hid_device(&event->device_created.desc, event->device);
|
||||
if (device) IoInvalidateDeviceRelations(bus_pdo, BusRelations);
|
||||
|
|
|
|||
|
|
@ -49,6 +49,14 @@ static void mouse_destroy(struct unix_device *iface)
|
|||
|
||||
static NTSTATUS mouse_start(struct unix_device *iface)
|
||||
{
|
||||
const USAGE_AND_PAGE device_usage = {.UsagePage = HID_USAGE_PAGE_GENERIC, .Usage = HID_USAGE_GENERIC_MOUSE};
|
||||
if (!hid_device_begin_report_descriptor(iface, &device_usage))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_add_buttons(iface, HID_USAGE_PAGE_BUTTON, 1, 3))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_end_report_descriptor(iface))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
@ -115,21 +123,9 @@ static const struct device_desc mouse_device_desc =
|
|||
|
||||
static NTSTATUS mouse_device_create(void *args)
|
||||
{
|
||||
const USAGE_AND_PAGE device_usage = {.UsagePage = HID_USAGE_PAGE_GENERIC, .Usage = HID_USAGE_GENERIC_MOUSE};
|
||||
struct device_create_params *params = args;
|
||||
struct unix_device *iface;
|
||||
|
||||
if (!(iface = hid_device_create(&mouse_vtbl, sizeof(struct mouse_device))))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_begin_report_descriptor(iface, &device_usage))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_add_buttons(iface, HID_USAGE_PAGE_BUTTON, 1, 3))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_end_report_descriptor(iface))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
params->desc = mouse_device_desc;
|
||||
params->device = (UINT_PTR)iface;
|
||||
params->device = (UINT_PTR)hid_device_create(&mouse_vtbl, sizeof(struct mouse_device));
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
@ -144,6 +140,14 @@ static void keyboard_destroy(struct unix_device *iface)
|
|||
|
||||
static NTSTATUS keyboard_start(struct unix_device *iface)
|
||||
{
|
||||
const USAGE_AND_PAGE device_usage = {.UsagePage = HID_USAGE_PAGE_GENERIC, .Usage = HID_USAGE_GENERIC_KEYBOARD};
|
||||
if (!hid_device_begin_report_descriptor(iface, &device_usage))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_add_buttons(iface, HID_USAGE_PAGE_KEYBOARD, 0, 101))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_end_report_descriptor(iface))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
@ -210,21 +214,9 @@ static const struct device_desc keyboard_device_desc =
|
|||
|
||||
static NTSTATUS keyboard_device_create(void *args)
|
||||
{
|
||||
const USAGE_AND_PAGE device_usage = {.UsagePage = HID_USAGE_PAGE_GENERIC, .Usage = HID_USAGE_GENERIC_KEYBOARD};
|
||||
struct device_create_params *params = args;
|
||||
struct unix_device *iface;
|
||||
|
||||
if (!(iface = hid_device_create(&keyboard_vtbl, sizeof(struct keyboard_device))))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_begin_report_descriptor(iface, &device_usage))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_add_buttons(iface, HID_USAGE_PAGE_KEYBOARD, 0, 101))
|
||||
return STATUS_NO_MEMORY;
|
||||
if (!hid_device_end_report_descriptor(iface))
|
||||
return STATUS_NO_MEMORY;
|
||||
|
||||
params->desc = keyboard_device_desc;
|
||||
params->device = (UINT_PTR)iface;
|
||||
params->device = (UINT_PTR)hid_device_create(&keyboard_vtbl, sizeof(struct keyboard_device));
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ struct device_desc
|
|||
UINT version;
|
||||
UINT input;
|
||||
UINT uid;
|
||||
USAGE_AND_PAGE usages;
|
||||
BOOL is_gamepad;
|
||||
BOOL is_hidraw;
|
||||
BOOL is_bluetooth;
|
||||
|
|
@ -150,8 +151,8 @@ enum unix_funcs
|
|||
static inline const char *debugstr_device_desc(struct device_desc *desc)
|
||||
{
|
||||
if (!desc) return "(null)";
|
||||
return wine_dbg_sprintf("{vid %04x, pid %04x, version %04x, input %d, uid %08x, is_gamepad %u, is_hidraw %u, is_bluetooth %u}",
|
||||
desc->vid, desc->pid, desc->version, desc->input, desc->uid,
|
||||
return wine_dbg_sprintf("{vid %04x, pid %04x, version %04x, input %d, uid %08x, usage %04x:%04x, is_gamepad %u, is_hidraw %u, is_bluetooth %u}",
|
||||
desc->vid, desc->pid, desc->version, desc->input, desc->uid, desc->usages.UsagePage, desc->usages.Usage,
|
||||
desc->is_gamepad, desc->is_hidraw, desc->is_bluetooth);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -73,8 +73,7 @@ BOOL X11DRV_CreateDesktop( const WCHAR *name, UINT width, UINT height )
|
|||
|
||||
/* Create window */
|
||||
win_attr.event_mask = ExposureMask | KeyPressMask | KeyReleaseMask | EnterWindowMask |
|
||||
PointerMotionMask | ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
|
||||
PropertyChangeMask;
|
||||
PointerMotionMask | ButtonPressMask | ButtonReleaseMask | FocusChangeMask;
|
||||
win_attr.cursor = XCreateFontCursor( display, XC_top_left_arrow );
|
||||
|
||||
if (default_visual.visual != DefaultVisual( display, DefaultScreen(display) ))
|
||||
|
|
|
|||
|
|
@ -1104,7 +1104,7 @@ static BOOL X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
|
|||
struct x11drv_win_data *data;
|
||||
RECT rect;
|
||||
POINT pos = {event->x, event->y};
|
||||
UINT config_cmd, state_cmd;
|
||||
UINT config_cmd;
|
||||
|
||||
if (!hwnd) return FALSE;
|
||||
if (!(data = get_win_data( hwnd ))) return FALSE;
|
||||
|
|
@ -1123,24 +1123,17 @@ static BOOL X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev )
|
|||
SetRect( &rect, pos.x, pos.y, pos.x + event->width, pos.y + event->height );
|
||||
window_configure_notify( data, event->serial, &rect );
|
||||
|
||||
state_cmd = window_update_client_state( data );
|
||||
config_cmd = window_update_client_config( data );
|
||||
rect = window_rect_from_visible( &data->rects, data->current_state.rect );
|
||||
release_win_data( data );
|
||||
|
||||
if (state_cmd)
|
||||
{
|
||||
if (LOWORD(state_cmd) == SC_RESTORE && HIWORD(state_cmd)) NtUserSetActiveWindow( hwnd );
|
||||
send_message( hwnd, WM_SYSCOMMAND, LOWORD(state_cmd), 0 );
|
||||
}
|
||||
|
||||
if (config_cmd)
|
||||
{
|
||||
if (LOWORD(config_cmd) == SC_MOVE) NtUserSetRawWindowPos( hwnd, rect, HIWORD(config_cmd), FALSE );
|
||||
else send_message( hwnd, WM_SYSCOMMAND, LOWORD(config_cmd), 0 );
|
||||
}
|
||||
|
||||
return config_cmd || state_cmd;
|
||||
return !!config_cmd;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1200,19 +1193,36 @@ static int get_window_xembed_info( Display *display, Window window )
|
|||
*
|
||||
* Handle a PropertyNotify for WM_STATE.
|
||||
*/
|
||||
static void handle_wm_state_notify( HWND hwnd, XPropertyEvent *event )
|
||||
static void handle_wm_state_notify( HWND hwnd, XPropertyEvent *event, BOOL update_window )
|
||||
{
|
||||
struct x11drv_win_data *data;
|
||||
UINT value = 0, state_cmd = 0, config_cmd = 0;
|
||||
RECT rect;
|
||||
UINT value = 0, state_cmd = 0;
|
||||
|
||||
if (!(data = get_win_data( hwnd ))) return;
|
||||
if (event->state == PropertyNewValue) value = get_window_wm_state( event->display, event->window );
|
||||
window_wm_state_notify( data, event->serial, value );
|
||||
if (update_window) window_wm_state_notify( data, event->serial, value );
|
||||
|
||||
state_cmd = window_update_client_state( data );
|
||||
config_cmd = window_update_client_config( data );
|
||||
rect = window_rect_from_visible( &data->rects, data->current_state.rect );
|
||||
switch(event->state)
|
||||
{
|
||||
case PropertyDelete:
|
||||
TRACE( "%p/%lx: WM_STATE deleted from %d\n", data->hwnd, data->whole_window, data->wm_state );
|
||||
data->wm_state = WithdrawnState;
|
||||
break;
|
||||
case PropertyNewValue:
|
||||
{
|
||||
int old_state = data->wm_state;
|
||||
int new_state = get_window_wm_state( event->display, data->whole_window );
|
||||
if (new_state != -1 && new_state != data->wm_state)
|
||||
{
|
||||
TRACE( "%p/%lx: new WM_STATE %d from %d\n",
|
||||
data->hwnd, data->whole_window, new_state, old_state );
|
||||
data->wm_state = new_state;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (update_window) state_cmd = window_update_client_state( data );
|
||||
|
||||
release_win_data( data );
|
||||
|
||||
|
|
@ -1221,12 +1231,6 @@ static void handle_wm_state_notify( HWND hwnd, XPropertyEvent *event )
|
|||
if (LOWORD(state_cmd) == SC_RESTORE && HIWORD(state_cmd)) NtUserSetActiveWindow( hwnd );
|
||||
send_message( hwnd, WM_SYSCOMMAND, LOWORD(state_cmd), 0 );
|
||||
}
|
||||
|
||||
if (config_cmd)
|
||||
{
|
||||
if (LOWORD(config_cmd) == SC_MOVE) NtUserSetRawWindowPos( hwnd, rect, HIWORD(config_cmd), FALSE );
|
||||
else send_message( hwnd, WM_SYSCOMMAND, LOWORD(config_cmd), 0 );
|
||||
}
|
||||
}
|
||||
|
||||
static void handle_xembed_info_notify( HWND hwnd, XPropertyEvent *event )
|
||||
|
|
@ -1243,30 +1247,12 @@ static void handle_xembed_info_notify( HWND hwnd, XPropertyEvent *event )
|
|||
static void handle_net_wm_state_notify( HWND hwnd, XPropertyEvent *event )
|
||||
{
|
||||
struct x11drv_win_data *data;
|
||||
UINT value = 0, state_cmd = 0, config_cmd = 0;
|
||||
RECT rect;
|
||||
UINT value = 0;
|
||||
|
||||
if (!(data = get_win_data( hwnd ))) return;
|
||||
if (event->state == PropertyNewValue) value = get_window_net_wm_state( event->display, event->window );
|
||||
window_net_wm_state_notify( data, event->serial, value );
|
||||
|
||||
state_cmd = window_update_client_state( data );
|
||||
config_cmd = window_update_client_config( data );
|
||||
rect = window_rect_from_visible( &data->rects, data->current_state.rect );
|
||||
|
||||
release_win_data( data );
|
||||
|
||||
if (state_cmd)
|
||||
{
|
||||
if (LOWORD(state_cmd) == SC_RESTORE && HIWORD(state_cmd)) NtUserSetActiveWindow( hwnd );
|
||||
send_message( hwnd, WM_SYSCOMMAND, LOWORD(state_cmd), 0 );
|
||||
}
|
||||
|
||||
if (config_cmd)
|
||||
{
|
||||
if (LOWORD(config_cmd) == SC_MOVE) NtUserSetRawWindowPos( hwnd, rect, HIWORD(config_cmd), FALSE );
|
||||
else send_message( hwnd, WM_SYSCOMMAND, LOWORD(config_cmd), 0 );
|
||||
}
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
|
|
@ -1277,13 +1263,79 @@ static BOOL X11DRV_PropertyNotify( HWND hwnd, XEvent *xev )
|
|||
XPropertyEvent *event = &xev->xproperty;
|
||||
|
||||
if (!hwnd) return FALSE;
|
||||
if (event->atom == x11drv_atom(WM_STATE)) handle_wm_state_notify( hwnd, event );
|
||||
if (event->atom == x11drv_atom(WM_STATE)) handle_wm_state_notify( hwnd, event, TRUE );
|
||||
if (event->atom == x11drv_atom(_XEMBED_INFO)) handle_xembed_info_notify( hwnd, event );
|
||||
if (event->atom == x11drv_atom(_NET_WM_STATE)) handle_net_wm_state_notify( hwnd, event );
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/* event filter to wait for a WM_STATE change notification on a window */
|
||||
static Bool is_wm_state_notify( Display *display, XEvent *event, XPointer arg )
|
||||
{
|
||||
if (event->xany.window != (Window)arg) return 0;
|
||||
return (event->type == DestroyNotify ||
|
||||
(event->type == PropertyNotify && event->xproperty.atom == x11drv_atom(WM_STATE)));
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* wait_for_withdrawn_state
|
||||
*/
|
||||
void wait_for_withdrawn_state( HWND hwnd, BOOL set )
|
||||
{
|
||||
Display *display = thread_display();
|
||||
struct x11drv_win_data *data;
|
||||
DWORD end = NtGetTickCount() + 2000;
|
||||
|
||||
TRACE( "waiting for window %p to become %swithdrawn\n", hwnd, set ? "" : "not " );
|
||||
|
||||
for (;;)
|
||||
{
|
||||
XEvent event;
|
||||
Window window;
|
||||
int count = 0;
|
||||
|
||||
if (!(data = get_win_data( hwnd ))) break;
|
||||
if (!data->managed || data->embedded || data->display != display) break;
|
||||
if (!(window = data->whole_window)) break;
|
||||
if (!data->mapped == !set)
|
||||
{
|
||||
TRACE( "window %p/%lx now %smapped\n", hwnd, window, data->mapped ? "" : "un" );
|
||||
break;
|
||||
}
|
||||
if ((data->wm_state == WithdrawnState) != !set)
|
||||
{
|
||||
TRACE( "window %p/%lx state now %d\n", hwnd, window, data->wm_state );
|
||||
break;
|
||||
}
|
||||
release_win_data( data );
|
||||
|
||||
while (XCheckIfEvent( display, &event, is_wm_state_notify, (char *)window ))
|
||||
{
|
||||
count++;
|
||||
if (XFilterEvent( &event, None )) continue; /* filtered, ignore it */
|
||||
if (event.type == DestroyNotify) call_event_handler( display, &event );
|
||||
else handle_wm_state_notify( hwnd, &event.xproperty, FALSE );
|
||||
}
|
||||
|
||||
if (!count)
|
||||
{
|
||||
struct pollfd pfd;
|
||||
int timeout = end - NtGetTickCount();
|
||||
|
||||
pfd.fd = ConnectionNumber(display);
|
||||
pfd.events = POLLIN;
|
||||
if (timeout <= 0 || poll( &pfd, 1, timeout ) != 1)
|
||||
{
|
||||
FIXME( "window %p/%lx wait timed out\n", hwnd, window );
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
release_win_data( data );
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************
|
||||
* SetFocus (X11DRV.@)
|
||||
*
|
||||
|
|
|
|||
|
|
@ -1213,10 +1213,7 @@ static void window_set_net_wm_state( struct x11drv_win_data *data, UINT new_stat
|
|||
{
|
||||
UINT i, count, old_state = data->pending_state.net_wm_state;
|
||||
|
||||
data->desired_state.net_wm_state = new_state;
|
||||
if (!data->whole_window) return; /* no window, nothing to update */
|
||||
if (data->wm_state_serial) return; /* another WM_STATE update is pending, wait for it to complete */
|
||||
/* we ignore and override previous _NET_WM_STATE update requests */
|
||||
if (old_state == new_state) return; /* states are the same, nothing to update */
|
||||
|
||||
if (data->pending_state.wm_state == IconicState) return; /* window is iconic, don't update its state now */
|
||||
|
|
@ -1270,8 +1267,6 @@ static void window_set_net_wm_state( struct x11drv_win_data *data, UINT new_stat
|
|||
SubstructureRedirectMask | SubstructureNotifyMask, &xev );
|
||||
}
|
||||
}
|
||||
|
||||
XFlush( data->display );
|
||||
}
|
||||
|
||||
static void window_set_config( struct x11drv_win_data *data, const RECT *new_rect, BOOL above )
|
||||
|
|
@ -1280,7 +1275,6 @@ static void window_set_config( struct x11drv_win_data *data, const RECT *new_rec
|
|||
const RECT *old_rect = &data->pending_state.rect;
|
||||
XWindowChanges changes;
|
||||
|
||||
data->desired_state.rect = *new_rect;
|
||||
if (!data->whole_window) return; /* no window, nothing to update */
|
||||
if (EqualRect( old_rect, new_rect )) return; /* rects are the same, nothing to update */
|
||||
|
||||
|
|
@ -1334,7 +1328,7 @@ static void update_net_wm_states( struct x11drv_win_data *data )
|
|||
|
||||
style = NtUserGetWindowLongW( data->hwnd, GWL_STYLE );
|
||||
if (style & WS_MINIMIZE)
|
||||
new_state |= data->desired_state.net_wm_state & ((1 << NET_WM_STATE_FULLSCREEN)|(1 << NET_WM_STATE_MAXIMIZED));
|
||||
new_state |= data->pending_state.net_wm_state & ((1 << NET_WM_STATE_FULLSCREEN)|(1 << NET_WM_STATE_MAXIMIZED));
|
||||
if (data->is_fullscreen)
|
||||
{
|
||||
if ((style & WS_MAXIMIZE) && (style & WS_CAPTION) == WS_CAPTION)
|
||||
|
|
@ -1418,9 +1412,7 @@ static void window_set_wm_state( struct x11drv_win_data *data, UINT new_state )
|
|||
{
|
||||
UINT old_state = data->pending_state.wm_state;
|
||||
|
||||
data->desired_state.wm_state = new_state;
|
||||
if (!data->whole_window) return; /* no window, nothing to update */
|
||||
if (data->wm_state_serial) return; /* another WM_STATE update is pending, wait for it to complete */
|
||||
if (old_state == new_state) return; /* states are the same, nothing to update */
|
||||
|
||||
data->pending_state.wm_state = new_state;
|
||||
|
|
@ -1446,11 +1438,6 @@ static void window_set_wm_state( struct x11drv_win_data *data, UINT new_state )
|
|||
if (!data->embedded) XIconifyWindow( data->display, data->whole_window, data->vis.screen );
|
||||
break;
|
||||
}
|
||||
|
||||
/* override redirect windows won't receive WM_STATE property changes */
|
||||
if (!data->managed) data->wm_state_serial = 0;
|
||||
|
||||
XFlush( data->display );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1462,6 +1449,7 @@ static void map_window( HWND hwnd, DWORD new_style )
|
|||
struct x11drv_win_data *data;
|
||||
|
||||
make_owner_managed( hwnd );
|
||||
wait_for_withdrawn_state( hwnd, TRUE );
|
||||
|
||||
if (!(data = get_win_data( hwnd ))) return;
|
||||
|
||||
|
|
@ -1475,6 +1463,7 @@ static void map_window( HWND hwnd, DWORD new_style )
|
|||
sync_window_style( data );
|
||||
|
||||
window_set_wm_state( data, (new_style & WS_MINIMIZE) ? IconicState : NormalState );
|
||||
XFlush( data->display );
|
||||
|
||||
data->mapped = TRUE;
|
||||
data->iconic = (new_style & WS_MINIMIZE) != 0;
|
||||
|
|
@ -1491,6 +1480,8 @@ static void unmap_window( HWND hwnd )
|
|||
{
|
||||
struct x11drv_win_data *data;
|
||||
|
||||
wait_for_withdrawn_state( hwnd, FALSE );
|
||||
|
||||
if (!(data = get_win_data( hwnd ))) return;
|
||||
|
||||
if (data->mapped)
|
||||
|
|
@ -1509,10 +1500,6 @@ UINT window_update_client_state( struct x11drv_win_data *data )
|
|||
if (!data->managed) return 0; /* unmanaged windows are managed by the Win32 side */
|
||||
if (!data->mapped) return 0; /* ignore state changes on invisible windows */
|
||||
|
||||
if (data->wm_state_serial) return 0; /* another WM_STATE update is pending, wait for it to complete */
|
||||
if (data->net_wm_state_serial) return 0; /* another _NET_WM_STATE update is pending, wait for it to complete */
|
||||
if (data->configure_serial) return 0; /* another config update is pending, wait for it to complete */
|
||||
|
||||
if (data->iconic && data->current_state.wm_state == NormalState) /* restore window */
|
||||
{
|
||||
data->iconic = FALSE;
|
||||
|
|
@ -1553,8 +1540,6 @@ UINT window_update_client_config( struct x11drv_win_data *data )
|
|||
if (!data->mapped) return 0; /* ignore config changes on invisible windows */
|
||||
if (data->iconic) return 0; /* ignore config changes on minimized windows */
|
||||
|
||||
if (data->wm_state_serial) return 0; /* another WM_STATE update is pending, wait for it to complete */
|
||||
if (data->net_wm_state_serial) return 0; /* another _NET_WM_STATE update is pending, wait for it to complete */
|
||||
if (data->configure_serial) return 0; /* another config update is pending, wait for it to complete */
|
||||
|
||||
if ((old_style & WS_CAPTION) == WS_CAPTION || !data->is_fullscreen)
|
||||
|
|
@ -1587,7 +1572,7 @@ UINT window_update_client_config( struct x11drv_win_data *data )
|
|||
|
||||
void window_wm_state_notify( struct x11drv_win_data *data, unsigned long serial, UINT value )
|
||||
{
|
||||
UINT *desired = &data->desired_state.wm_state, *pending = &data->pending_state.wm_state, *current = &data->current_state.wm_state;
|
||||
UINT *pending = &data->pending_state.wm_state, *current = &data->current_state.wm_state;
|
||||
unsigned long *expect_serial = &data->wm_state_serial;
|
||||
const char *reason = NULL, *expected, *received;
|
||||
|
||||
|
|
@ -1612,20 +1597,16 @@ void window_wm_state_notify( struct x11drv_win_data *data, unsigned long serial,
|
|||
else
|
||||
{
|
||||
WARN( "window %p/%lx, %s%s%s\n", data->hwnd, data->whole_window, reason, received, expected );
|
||||
*desired = *pending = value; /* avoid requesting the same state again */
|
||||
*pending = value; /* avoid requesting the same state again */
|
||||
}
|
||||
|
||||
*current = value;
|
||||
*expect_serial = 0;
|
||||
|
||||
/* send any pending changes from the desired state */
|
||||
window_set_wm_state( data, data->desired_state.wm_state );
|
||||
window_set_net_wm_state( data, data->desired_state.net_wm_state );
|
||||
}
|
||||
|
||||
void window_net_wm_state_notify( struct x11drv_win_data *data, unsigned long serial, UINT value )
|
||||
{
|
||||
UINT *desired = &data->desired_state.net_wm_state, *pending = &data->pending_state.net_wm_state, *current = &data->current_state.net_wm_state;
|
||||
UINT *pending = &data->pending_state.net_wm_state, *current = &data->current_state.net_wm_state;
|
||||
unsigned long *expect_serial = &data->net_wm_state_serial;
|
||||
const char *reason = NULL, *expected, *received;
|
||||
|
||||
|
|
@ -1648,20 +1629,16 @@ void window_net_wm_state_notify( struct x11drv_win_data *data, unsigned long ser
|
|||
else
|
||||
{
|
||||
WARN( "window %p/%lx, %s%s%s\n", data->hwnd, data->whole_window, reason, received, expected );
|
||||
*desired = *pending = value; /* avoid requesting the same state again */
|
||||
*pending = value; /* avoid requesting the same state again */
|
||||
}
|
||||
|
||||
*current = value;
|
||||
*expect_serial = 0;
|
||||
|
||||
/* send any pending changes from the desired state */
|
||||
window_set_wm_state( data, data->desired_state.wm_state );
|
||||
window_set_net_wm_state( data, data->desired_state.net_wm_state );
|
||||
}
|
||||
|
||||
void window_configure_notify( struct x11drv_win_data *data, unsigned long serial, const RECT *value )
|
||||
{
|
||||
RECT *desired = &data->desired_state.rect, *pending = &data->pending_state.rect, *current = &data->current_state.rect;
|
||||
RECT *pending = &data->pending_state.rect, *current = &data->current_state.rect;
|
||||
unsigned long *expect_serial = &data->configure_serial;
|
||||
const char *reason = NULL, *expected, *received;
|
||||
|
||||
|
|
@ -1684,7 +1661,7 @@ void window_configure_notify( struct x11drv_win_data *data, unsigned long serial
|
|||
else
|
||||
{
|
||||
WARN( "window %p/%lx, %s%s%s\n", data->hwnd, data->whole_window, reason, received, expected );
|
||||
*desired = *pending = *value; /* avoid requesting the same state again */
|
||||
*pending = *value; /* avoid requesting the same state again */
|
||||
}
|
||||
|
||||
*current = *value;
|
||||
|
|
@ -1697,7 +1674,7 @@ BOOL window_has_pending_wm_state( HWND hwnd, UINT state )
|
|||
BOOL pending;
|
||||
|
||||
if (!(data = get_win_data( hwnd ))) return FALSE;
|
||||
if (state != -1 && data->desired_state.wm_state != state) pending = FALSE;
|
||||
if (state != -1 && data->pending_state.wm_state != state) pending = FALSE;
|
||||
else pending = !!data->wm_state_serial;
|
||||
release_win_data( data );
|
||||
|
||||
|
|
@ -2067,7 +2044,6 @@ static void create_whole_window( struct x11drv_win_data *data )
|
|||
if (!data->whole_window) goto done;
|
||||
SetRect( &data->current_state.rect, pos.x, pos.y, pos.x + cx, pos.y + cy );
|
||||
data->pending_state.rect = data->current_state.rect;
|
||||
data->desired_state.rect = data->current_state.rect;
|
||||
|
||||
x11drv_xinput2_enable( data->display, data->whole_window );
|
||||
set_initial_wm_hints( data->display, data->whole_window );
|
||||
|
|
@ -2122,9 +2098,9 @@ static void destroy_whole_window( struct x11drv_win_data *data, BOOL already_des
|
|||
if (data->whole_colormap) XFreeColormap( data->display, data->whole_colormap );
|
||||
data->whole_window = data->client_window = 0;
|
||||
data->whole_colormap = 0;
|
||||
data->wm_state = WithdrawnState;
|
||||
data->mapped = FALSE;
|
||||
|
||||
memset( &data->desired_state, 0, sizeof(data->desired_state) );
|
||||
memset( &data->pending_state, 0, sizeof(data->pending_state) );
|
||||
memset( &data->current_state, 0, sizeof(data->current_state) );
|
||||
data->wm_state_serial = 0;
|
||||
|
|
|
|||
|
|
@ -633,13 +633,13 @@ struct x11drv_win_data
|
|||
UINT net_wm_fullscreen_monitors_set : 1; /* is _NET_WM_FULLSCREEN_MONITORS set */
|
||||
UINT is_fullscreen : 1; /* is the window visible rect fullscreen */
|
||||
UINT parent_invalid : 1; /* is the parent host window possibly invalid */
|
||||
int wm_state; /* current value of the WM_STATE property */
|
||||
Window embedder; /* window id of embedder */
|
||||
Pixmap icon_pixmap;
|
||||
Pixmap icon_mask;
|
||||
unsigned long *icon_bits;
|
||||
unsigned int icon_size;
|
||||
|
||||
struct window_state desired_state; /* window state tracking the desired / win32 state */
|
||||
struct window_state pending_state; /* window state tracking the pending / requested state */
|
||||
struct window_state current_state; /* window state tracking the current X11 state */
|
||||
unsigned long wm_state_serial; /* serial of last pending WM_STATE request */
|
||||
|
|
@ -665,6 +665,7 @@ extern void window_configure_notify( struct x11drv_win_data *data, unsigned long
|
|||
extern UINT window_update_client_state( struct x11drv_win_data *data );
|
||||
extern UINT window_update_client_config( struct x11drv_win_data *data );
|
||||
|
||||
extern void wait_for_withdrawn_state( HWND hwnd, BOOL set );
|
||||
extern Window init_clip_window(void);
|
||||
extern void update_user_time( Time time );
|
||||
extern UINT get_window_net_wm_state( Display *display, Window window );
|
||||
|
|
|
|||
|
|
@ -1240,211 +1240,3 @@ HRESULT WINAPI RoResolveNamespace(HSTRING name, HSTRING windowsMetaDataDir,
|
|||
|
||||
return RO_E_METADATA_NAME_NOT_FOUND;
|
||||
}
|
||||
|
||||
struct parse_type_context
|
||||
{
|
||||
DWORD allocated_parts_count;
|
||||
DWORD parts_count;
|
||||
HSTRING *parts;
|
||||
};
|
||||
|
||||
static HRESULT add_part(struct parse_type_context *context, const WCHAR *part, size_t length)
|
||||
{
|
||||
DWORD new_parts_count;
|
||||
HSTRING *new_parts;
|
||||
HRESULT hr;
|
||||
|
||||
if (context->parts_count == context->allocated_parts_count)
|
||||
{
|
||||
new_parts_count = context->allocated_parts_count ? context->allocated_parts_count * 2 : 4;
|
||||
new_parts = CoTaskMemRealloc(context->parts, new_parts_count * sizeof(*context->parts));
|
||||
if (!new_parts)
|
||||
return E_OUTOFMEMORY;
|
||||
|
||||
context->allocated_parts_count = new_parts_count;
|
||||
context->parts = new_parts;
|
||||
}
|
||||
|
||||
if (FAILED(hr = WindowsCreateString(part, length, &context->parts[context->parts_count])))
|
||||
return hr;
|
||||
|
||||
context->parts_count++;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static HRESULT parse_part(struct parse_type_context *context, const WCHAR *input, unsigned int length)
|
||||
{
|
||||
const WCHAR *start, *end, *ptr;
|
||||
|
||||
start = input;
|
||||
end = start + length;
|
||||
|
||||
/* Remove leading spaces */
|
||||
while (start < end && *start == ' ')
|
||||
start++;
|
||||
|
||||
/* Remove trailing spaces */
|
||||
while (end - 1 >= start && end[-1] == ' ')
|
||||
end--;
|
||||
|
||||
/* Only contains spaces */
|
||||
if (start == end)
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
|
||||
/* Has spaces in the middle */
|
||||
for (ptr = start; ptr < end; ptr++)
|
||||
{
|
||||
if (*ptr == ' ')
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
}
|
||||
|
||||
return add_part(context, start, end - start);
|
||||
}
|
||||
|
||||
static HRESULT parse_type(struct parse_type_context *context, const WCHAR *input, unsigned int length)
|
||||
{
|
||||
unsigned int i, parameter_count, nested_level;
|
||||
const WCHAR *start, *end, *part_start, *ptr;
|
||||
HRESULT hr;
|
||||
|
||||
start = input;
|
||||
end = start + length;
|
||||
part_start = start;
|
||||
ptr = start;
|
||||
|
||||
/* Read until the end of input or '`' or '<' or '>' or ',' */
|
||||
while (ptr < end && *ptr != '`' && *ptr != '<' && *ptr != '>' && *ptr != ',')
|
||||
ptr++;
|
||||
|
||||
/* If the type name has '`' and there are characters before '`' */
|
||||
if (ptr > start && ptr < end && *ptr == '`')
|
||||
{
|
||||
/* Move past the '`' */
|
||||
ptr++;
|
||||
|
||||
/* Read the number of type parameters, expecting '1' to '9' */
|
||||
if (!(ptr < end && *ptr >= '1' && *ptr <= '9'))
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
parameter_count = *ptr - '0';
|
||||
|
||||
/* Move past the number of type parameters, expecting '<' */
|
||||
ptr++;
|
||||
if (!(ptr < end && *ptr == '<'))
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
|
||||
/* Add the name of parameterized interface, e.g., the "interface`1" in "interface`1<parameter>" */
|
||||
if (FAILED(hr = parse_part(context, part_start, ptr - part_start)))
|
||||
return hr;
|
||||
|
||||
/* Move past the '<' */
|
||||
ptr++;
|
||||
nested_level = 1;
|
||||
|
||||
/* Read parameters inside brackets, e.g., the "p1" and "p2" in "interface`2<p1, p2>" */
|
||||
for (i = 0; i < parameter_count; i++)
|
||||
{
|
||||
/* Read a new parameter */
|
||||
part_start = ptr;
|
||||
|
||||
/* Read until ','. The comma must be at the same nested bracket level */
|
||||
while (ptr < end)
|
||||
{
|
||||
if (*ptr == '<')
|
||||
{
|
||||
nested_level++;
|
||||
ptr++;
|
||||
}
|
||||
else if (*ptr == '>')
|
||||
{
|
||||
/* The last parameter before '>' */
|
||||
if (i == parameter_count - 1 && nested_level == 1)
|
||||
{
|
||||
if (FAILED(hr = parse_type(context, part_start, ptr - part_start)))
|
||||
return hr;
|
||||
|
||||
nested_level--;
|
||||
ptr++;
|
||||
|
||||
/* Finish reading all parameters */
|
||||
break;
|
||||
}
|
||||
|
||||
nested_level--;
|
||||
ptr++;
|
||||
}
|
||||
else if (*ptr == ',' && nested_level == 1)
|
||||
{
|
||||
/* Parse the parameter, which can be another parameterized type */
|
||||
if (FAILED(hr = parse_type(context, part_start, ptr - part_start)))
|
||||
return hr;
|
||||
|
||||
/* Move past the ',' */
|
||||
ptr++;
|
||||
|
||||
/* Finish reading one parameter */
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
ptr++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Mismatching brackets or not enough parameters */
|
||||
if (nested_level != 0 || i != parameter_count)
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
|
||||
/* The remaining characters must be spaces */
|
||||
while (ptr < end)
|
||||
{
|
||||
if (*ptr++ != ' ')
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
}
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
/* Contain invalid '`', '<', '>' or ',' */
|
||||
else if (ptr != end)
|
||||
{
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
}
|
||||
/* Non-parameterized */
|
||||
else
|
||||
{
|
||||
return parse_part(context, part_start, ptr - part_start);
|
||||
}
|
||||
}
|
||||
|
||||
HRESULT WINAPI RoParseTypeName(HSTRING type_name, DWORD *parts_count, HSTRING **parts)
|
||||
{
|
||||
struct parse_type_context context = {0};
|
||||
const WCHAR *input;
|
||||
unsigned int i;
|
||||
HRESULT hr;
|
||||
|
||||
TRACE("%s %p %p.\n", debugstr_hstring(type_name), parts_count, parts);
|
||||
|
||||
/* Empty string */
|
||||
if (!WindowsGetStringLen(type_name))
|
||||
return E_INVALIDARG;
|
||||
|
||||
input = WindowsGetStringRawBuffer(type_name, NULL);
|
||||
/* The string has a leading space */
|
||||
if (input[0] == ' ')
|
||||
return RO_E_METADATA_INVALID_TYPE_FORMAT;
|
||||
|
||||
*parts_count = 0;
|
||||
*parts = NULL;
|
||||
if (FAILED(hr = parse_type(&context, input, wcslen(input))))
|
||||
{
|
||||
for (i = 0; i < context.parts_count; i++)
|
||||
WindowsDeleteString(context.parts[i]);
|
||||
CoTaskMemFree(context.parts);
|
||||
return hr;
|
||||
}
|
||||
|
||||
*parts_count = context.parts_count;
|
||||
*parts = context.parts;
|
||||
return S_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -814,159 +814,11 @@ static void test_RoResolveNamespace(void)
|
|||
RoUninitialize();
|
||||
}
|
||||
|
||||
static void test_RoParseTypeName(void)
|
||||
{
|
||||
static const struct
|
||||
{
|
||||
const WCHAR *type_name;
|
||||
HRESULT hr;
|
||||
DWORD parts_count;
|
||||
const WCHAR *parts[16];
|
||||
}
|
||||
tests[] =
|
||||
{
|
||||
/* Invalid type names */
|
||||
{L"", E_INVALIDARG},
|
||||
{L" ", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"`", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"<", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L">", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L",", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"<>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"`<>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a b", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a,b", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"1<>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L" a", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L" a ", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a<", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a<>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`<>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`1<>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a<b>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`<b> ", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"`1<b>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L" a`1<b>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`1<b>c", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`1<b,>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`2<b, <c, d>>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`10<b1, b2, b3, b4, b5, b6, b7, b8, b9, b10>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`0xa<b1, b2, b3, b4, b5, b6, b7, b8, b9, b10>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
{L"a`a<b1, b2, b3, b4, b5, b6, b7, b8, b9, b10>", RO_E_METADATA_INVALID_TYPE_FORMAT},
|
||||
/* Valid type names */
|
||||
{L"1", S_OK, 1, {L"1"}},
|
||||
{L"a", S_OK, 1, {L"a"}},
|
||||
{L"-", S_OK, 1, {L"-"}},
|
||||
{L"a ", S_OK, 1, {L"a"}},
|
||||
{L"0`1<b>", S_OK, 2, {L"0`1", L"b"}},
|
||||
{L"a`1<b>", S_OK, 2, {L"a`1", L"b"}},
|
||||
{L"a`1<b> ", S_OK, 2, {L"a`1", L"b"}},
|
||||
{L"a`1<b >", S_OK, 2, {L"a`1", L"b"}},
|
||||
{L"a`1< b>", S_OK, 2, {L"a`1", L"b"}},
|
||||
{L"a`1< b >", S_OK, 2, {L"a`1", L"b"}},
|
||||
{L"a`2<b,c>", S_OK, 3, {L"a`2", L"b", L"c"}},
|
||||
{L"a`2<b, c>", S_OK, 3, {L"a`2", L"b", L"c"}},
|
||||
{L"a`2<b ,c>", S_OK, 3, {L"a`2", L"b", L"c"}},
|
||||
{L"a`2<b , c>", S_OK, 3, {L"a`2", L"b", L"c"}},
|
||||
{L"a`3<b, c, d>", S_OK, 4, {L"a`3", L"b", L"c", L"d"}},
|
||||
{L"a`1<b`1<c>>", S_OK, 3, {L"a`1", L"b`1", L"c"}},
|
||||
{L"a`1<b`2<c, d>>", S_OK, 4, {L"a`1", L"b`2", L"c", L"d"}},
|
||||
{L"a`2<b`2<c, d>, e>", S_OK, 5, {L"a`2", L"b`2", L"c", L"d", L"e"}},
|
||||
{L"a`2<b, c`2<d, e>>", S_OK, 5, {L"a`2", L"b", L"c`2", L"d", L"e"}},
|
||||
{L"a`9<b1, b2, b3, b4, b5, b6, b7, b8, b9>", S_OK, 10, {L"a`9", L"b1", L"b2", L"b3", L"b4", L"b5", L"b6", L"b7", L"b8", L"b9"}},
|
||||
{L"Windows.Foundation.IExtensionInformation", S_OK, 1, {L"Windows.Foundation.IExtensionInformation"}},
|
||||
{L"Windows.Foundation.IReference`1<Windows.UI.Color>", S_OK, 2, {L"Windows.Foundation.IReference`1", L"Windows.UI.Color"}},
|
||||
{L"Windows.Foundation.Collections.IIterator`1<Windows.Foundation.Collections.IMapView`2<Windows.Foundation.Collections.IVector`1<String>, String>>",
|
||||
S_OK, 5, {L"Windows.Foundation.Collections.IIterator`1",
|
||||
L"Windows.Foundation.Collections.IMapView`2",
|
||||
L"Windows.Foundation.Collections.IVector`1",
|
||||
L"String",
|
||||
L"String"}},
|
||||
};
|
||||
HSTRING type_name, *parts;
|
||||
const WCHAR *buffer;
|
||||
DWORD parts_count;
|
||||
unsigned int i, j;
|
||||
HRESULT hr;
|
||||
|
||||
/* Parameter checks */
|
||||
hr = WindowsCreateString(L"a", 1, &type_name);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
|
||||
hr = RoParseTypeName(NULL, &parts_count, &parts);
|
||||
ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
|
||||
|
||||
/* Crash on Windows */
|
||||
if (0)
|
||||
{
|
||||
hr = RoParseTypeName(type_name, NULL, &parts);
|
||||
ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
|
||||
|
||||
hr = RoParseTypeName(type_name, &parts_count, NULL);
|
||||
ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
|
||||
}
|
||||
|
||||
hr = RoParseTypeName(type_name, &parts_count, &parts);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
ok(parts_count == 1, "Got unexpected %ld.\n", parts_count);
|
||||
hr = WindowsDeleteString(parts[0]);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
CoTaskMemFree(parts);
|
||||
hr = WindowsDeleteString(type_name);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
|
||||
/* Parsing checks */
|
||||
for (i = 0; i < ARRAY_SIZE(tests); i++)
|
||||
{
|
||||
winetest_push_context("%s", wine_dbgstr_w(tests[i].type_name));
|
||||
|
||||
if (tests[i].type_name)
|
||||
{
|
||||
hr = WindowsCreateString(tests[i].type_name, wcslen(tests[i].type_name), &type_name);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
}
|
||||
else
|
||||
{
|
||||
type_name = NULL;
|
||||
}
|
||||
|
||||
parts_count = 0;
|
||||
hr = RoParseTypeName(type_name, &parts_count, &parts);
|
||||
ok(hr == tests[i].hr, "Got unexpected hr %#lx.\n", hr);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
hr = WindowsDeleteString(type_name);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
winetest_pop_context();
|
||||
continue;
|
||||
}
|
||||
ok(parts_count == tests[i].parts_count, "Got unexpected %lu.\n", parts_count);
|
||||
|
||||
for (j = 0; j < parts_count; j++)
|
||||
{
|
||||
winetest_push_context("%s", wine_dbgstr_w(tests[i].parts[j]));
|
||||
|
||||
buffer = WindowsGetStringRawBuffer(parts[j], NULL);
|
||||
ok(!lstrcmpW(tests[i].parts[j], buffer), "Got unexpected %s.\n", wine_dbgstr_w(buffer));
|
||||
hr = WindowsDeleteString(parts[j]);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
|
||||
winetest_pop_context();
|
||||
}
|
||||
CoTaskMemFree(parts);
|
||||
|
||||
hr = WindowsDeleteString(type_name);
|
||||
ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
|
||||
winetest_pop_context();
|
||||
}
|
||||
}
|
||||
|
||||
START_TEST(wintypes)
|
||||
{
|
||||
IsWow64Process(GetCurrentProcess(), &is_wow64);
|
||||
|
||||
test_IApiInformationStatics();
|
||||
test_IPropertyValueStatics();
|
||||
test_RoParseTypeName();
|
||||
test_RoResolveNamespace();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,5 +7,5 @@
|
|||
@ stub RoGetMetaDataFile
|
||||
@ stdcall RoIsApiContractMajorVersionPresent(wstr long ptr)
|
||||
@ stub RoIsApiContractPresent
|
||||
@ stdcall RoParseTypeName(ptr ptr ptr)
|
||||
@ stub RoParseTypeName
|
||||
@ stdcall RoResolveNamespace(ptr ptr long ptr ptr ptr ptr ptr)
|
||||
|
|
|
|||
|
|
@ -23,7 +23,6 @@
|
|||
#include <hstring.h>
|
||||
|
||||
HRESULT WINAPI RoIsApiContractMajorVersionPresent(const WCHAR *, UINT16, BOOL *);
|
||||
HRESULT WINAPI RoParseTypeName(HSTRING, DWORD *, HSTRING **);
|
||||
HRESULT WINAPI RoResolveNamespace(HSTRING, HSTRING, DWORD, const HSTRING *, DWORD *, HSTRING **, DWORD *, HSTRING **);
|
||||
|
||||
#endif /* _ROMETADATARESOLUTION_H */
|
||||
|
|
|
|||
34
include/wine/server_protocol.h
generated
34
include/wine/server_protocol.h
generated
|
|
@ -57,7 +57,7 @@ struct request_max_size
|
|||
|
||||
|
||||
|
||||
union debug_event_data
|
||||
typedef union
|
||||
{
|
||||
int code;
|
||||
struct
|
||||
|
|
@ -109,7 +109,7 @@ union debug_event_data
|
|||
int __pad;
|
||||
mod_handle_t base;
|
||||
} unload_dll;
|
||||
};
|
||||
} debug_event_t;
|
||||
|
||||
|
||||
enum context_exec_space
|
||||
|
|
@ -312,7 +312,7 @@ struct winevent_msg_data
|
|||
|
||||
};
|
||||
|
||||
union hw_input
|
||||
typedef union
|
||||
{
|
||||
int type;
|
||||
struct
|
||||
|
|
@ -342,15 +342,15 @@ union hw_input
|
|||
lparam_t lparam;
|
||||
struct hid_input hid;
|
||||
} hw;
|
||||
};
|
||||
} hw_input_t;
|
||||
|
||||
union message_data
|
||||
typedef union
|
||||
{
|
||||
unsigned char bytes[1];
|
||||
struct hardware_msg_data hardware;
|
||||
struct callback_msg_data callback;
|
||||
struct winevent_msg_data winevent;
|
||||
};
|
||||
} message_data_t;
|
||||
|
||||
|
||||
struct filesystem_event
|
||||
|
|
@ -435,7 +435,7 @@ struct object_type_info
|
|||
|
||||
};
|
||||
|
||||
enum select_opcode
|
||||
enum select_op
|
||||
{
|
||||
SELECT_NONE,
|
||||
SELECT_WAIT,
|
||||
|
|
@ -445,28 +445,28 @@ enum select_opcode
|
|||
SELECT_KEYED_EVENT_RELEASE
|
||||
};
|
||||
|
||||
union select_op
|
||||
typedef union
|
||||
{
|
||||
enum select_opcode op;
|
||||
enum select_op op;
|
||||
struct
|
||||
{
|
||||
enum select_opcode op;
|
||||
enum select_op op;
|
||||
obj_handle_t handles[MAXIMUM_WAIT_OBJECTS];
|
||||
int __pad;
|
||||
} wait;
|
||||
struct
|
||||
{
|
||||
enum select_opcode op;
|
||||
enum select_op op;
|
||||
obj_handle_t wait;
|
||||
obj_handle_t signal;
|
||||
} signal_and_wait;
|
||||
struct
|
||||
{
|
||||
enum select_opcode op;
|
||||
enum select_op op;
|
||||
obj_handle_t handle;
|
||||
client_ptr_t key;
|
||||
} keyed_event;
|
||||
};
|
||||
} select_op_t;
|
||||
|
||||
enum apc_type
|
||||
{
|
||||
|
|
@ -748,7 +748,7 @@ enum irp_type
|
|||
IRP_CALL_CANCEL
|
||||
};
|
||||
|
||||
union irp_params
|
||||
typedef union
|
||||
{
|
||||
enum irp_type type;
|
||||
struct
|
||||
|
|
@ -816,7 +816,7 @@ union irp_params
|
|||
int __pad;
|
||||
client_ptr_t irp;
|
||||
} cancel;
|
||||
};
|
||||
} irp_params_t;
|
||||
|
||||
|
||||
typedef struct
|
||||
|
|
@ -2970,7 +2970,7 @@ struct send_hardware_message_request
|
|||
{
|
||||
struct request_header __header;
|
||||
user_handle_t win;
|
||||
union hw_input input;
|
||||
hw_input_t input;
|
||||
unsigned int flags;
|
||||
/* VARARG(report,bytes); */
|
||||
char __pad_60[4];
|
||||
|
|
@ -5239,7 +5239,7 @@ struct get_next_device_request_request
|
|||
struct get_next_device_request_reply
|
||||
{
|
||||
struct reply_header __header;
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
obj_handle_t next;
|
||||
thread_id_t client_tid;
|
||||
client_ptr_t client_thread;
|
||||
|
|
|
|||
|
|
@ -365,7 +365,7 @@ int __cdecl wmain(int argc, const WCHAR* argv[])
|
|||
if(arg_is(argv[2], L"/help"))
|
||||
output_string(STRING_STOP_USAGE);
|
||||
else if(!net_service(NET_STOP, argv[2]))
|
||||
return 2;
|
||||
return 1;
|
||||
}
|
||||
else if(arg_is(argv[1], L"use"))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,4 +0,0 @@
|
|||
TESTDLL = net.exe
|
||||
|
||||
SOURCES = \
|
||||
net.c
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
/*
|
||||
* Copyright 2024 Fabian Maurer
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2.1 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with this library; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
#include "wine/test.h"
|
||||
|
||||
static HANDLE nul_file;
|
||||
|
||||
#define check_exit_code(x) ok(r == (x), "got exit code %ld, expected %d\n", r, (x))
|
||||
|
||||
/* Copied and modified from the reg.exe tests */
|
||||
#define run_net_exe(c,r) run_net_exe_(__FILE__,__LINE__,c,r)
|
||||
static BOOL run_net_exe_(const char *file, unsigned line, const char *cmd, DWORD *rc)
|
||||
{
|
||||
STARTUPINFOA si = {sizeof(STARTUPINFOA)};
|
||||
PROCESS_INFORMATION pi;
|
||||
BOOL bret;
|
||||
DWORD ret;
|
||||
char cmdline[256];
|
||||
|
||||
si.dwFlags = STARTF_USESTDHANDLES;
|
||||
si.hStdInput = nul_file;
|
||||
si.hStdOutput = nul_file;
|
||||
si.hStdError = nul_file;
|
||||
|
||||
strcpy(cmdline, cmd);
|
||||
if (!CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
|
||||
return FALSE;
|
||||
|
||||
ret = WaitForSingleObject(pi.hProcess, 10000);
|
||||
if (ret == WAIT_TIMEOUT)
|
||||
TerminateProcess(pi.hProcess, 1);
|
||||
|
||||
bret = GetExitCodeProcess(pi.hProcess, rc);
|
||||
ok_(__FILE__, line)(bret, "GetExitCodeProcess failed: %ld\n", GetLastError());
|
||||
|
||||
CloseHandle(pi.hThread);
|
||||
CloseHandle(pi.hProcess);
|
||||
return bret;
|
||||
}
|
||||
|
||||
static void test_stop(void)
|
||||
{
|
||||
DWORD r;
|
||||
|
||||
/* Stop non existing service */
|
||||
|
||||
run_net_exe("net stop non-existing-service", &r);
|
||||
check_exit_code(2);
|
||||
}
|
||||
|
||||
START_TEST(net)
|
||||
{
|
||||
SECURITY_ATTRIBUTES secattr = {sizeof(SECURITY_ATTRIBUTES), NULL, TRUE};
|
||||
|
||||
nul_file = CreateFileA("NUL", GENERIC_READ | GENERIC_WRITE, 0, &secattr, OPEN_EXISTING,
|
||||
FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
|
||||
test_stop();
|
||||
|
||||
CloseHandle(nul_file);
|
||||
}
|
||||
|
|
@ -48,7 +48,7 @@ struct debug_event
|
|||
struct file *file; /* file object for events that need one */
|
||||
enum debug_event_state state; /* event state */
|
||||
int status; /* continuation status */
|
||||
union debug_event_data data; /* event data */
|
||||
debug_event_t data; /* event data */
|
||||
};
|
||||
|
||||
static const WCHAR debug_obj_name[] = {'D','e','b','u','g','O','b','j','e','c','t'};
|
||||
|
|
@ -142,7 +142,7 @@ static client_ptr_t get_teb_user_ptr( struct thread *thread )
|
|||
|
||||
static void fill_exception_event( struct debug_event *event, const void *arg )
|
||||
{
|
||||
const union debug_event_data *data = arg;
|
||||
const debug_event_t *data = arg;
|
||||
event->data.exception = data->exception;
|
||||
event->data.exception.nb_params = min( event->data.exception.nb_params, EXCEPTION_MAXIMUM_PARAMETERS );
|
||||
}
|
||||
|
|
@ -641,7 +641,7 @@ DECL_HANDLER(queue_exception_event)
|
|||
reply->handle = 0;
|
||||
if (debug_obj)
|
||||
{
|
||||
union debug_event_data data;
|
||||
debug_event_t data;
|
||||
struct debug_event *event;
|
||||
struct thread *thread = current;
|
||||
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ struct irp_call
|
|||
struct device_file *file; /* file containing this irp */
|
||||
struct thread *thread; /* thread that queued the irp */
|
||||
struct async *async; /* pending async op */
|
||||
union irp_params params; /* irp parameters */
|
||||
irp_params_t params; /* irp parameters */
|
||||
struct iosb *iosb; /* I/O status block */
|
||||
int canceled; /* the call was canceled */
|
||||
client_ptr_t user_ptr; /* client side pointer */
|
||||
|
|
@ -348,8 +348,7 @@ static void irp_call_destroy( struct object *obj )
|
|||
if (irp->thread) release_object( irp->thread );
|
||||
}
|
||||
|
||||
static struct irp_call *create_irp( struct device_file *file, const union irp_params *params,
|
||||
struct async *async )
|
||||
static struct irp_call *create_irp( struct device_file *file, const irp_params_t *params, struct async *async )
|
||||
{
|
||||
struct irp_call *irp;
|
||||
|
||||
|
|
@ -456,7 +455,7 @@ static struct object *device_open_file( struct object *obj, unsigned int access,
|
|||
if (device->manager)
|
||||
{
|
||||
struct irp_call *irp;
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
params.create.type = IRP_CALL_CREATE;
|
||||
|
|
@ -513,7 +512,7 @@ static int device_file_close_handle( struct object *obj, struct process *process
|
|||
if (!file->closed && file->device->manager && obj->handle_count == 1) /* last handle */
|
||||
{
|
||||
struct irp_call *irp;
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
file->closed = 1;
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
|
|
@ -543,7 +542,7 @@ static void device_file_destroy( struct object *obj )
|
|||
release_object( file->device );
|
||||
}
|
||||
|
||||
static int fill_irp_params( struct device_manager *manager, struct irp_call *irp, union irp_params *params )
|
||||
static int fill_irp_params( struct device_manager *manager, struct irp_call *irp, irp_params_t *params )
|
||||
{
|
||||
switch (irp->params.type)
|
||||
{
|
||||
|
|
@ -596,7 +595,7 @@ static void free_irp_params( struct irp_call *irp )
|
|||
}
|
||||
|
||||
/* queue an irp to the device */
|
||||
static void queue_irp( struct device_file *file, const union irp_params *params, struct async *async )
|
||||
static void queue_irp( struct device_file *file, const irp_params_t *params, struct async *async )
|
||||
{
|
||||
struct irp_call *irp = create_irp( file, params, async );
|
||||
if (!irp) return;
|
||||
|
|
@ -616,7 +615,7 @@ static enum server_fd_type device_file_get_fd_type( struct fd *fd )
|
|||
static void device_file_get_volume_info( struct fd *fd, struct async *async, unsigned int info_class )
|
||||
{
|
||||
struct device_file *file = get_fd_user( fd );
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
params.volume.type = IRP_CALL_VOLUME;
|
||||
|
|
@ -627,7 +626,7 @@ static void device_file_get_volume_info( struct fd *fd, struct async *async, uns
|
|||
static void device_file_read( struct fd *fd, struct async *async, file_pos_t pos )
|
||||
{
|
||||
struct device_file *file = get_fd_user( fd );
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
params.read.type = IRP_CALL_READ;
|
||||
|
|
@ -639,7 +638,7 @@ static void device_file_read( struct fd *fd, struct async *async, file_pos_t pos
|
|||
static void device_file_write( struct fd *fd, struct async *async, file_pos_t pos )
|
||||
{
|
||||
struct device_file *file = get_fd_user( fd );
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
params.write.type = IRP_CALL_WRITE;
|
||||
|
|
@ -651,7 +650,7 @@ static void device_file_write( struct fd *fd, struct async *async, file_pos_t po
|
|||
static void device_file_flush( struct fd *fd, struct async *async )
|
||||
{
|
||||
struct device_file *file = get_fd_user( fd );
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
params.flush.type = IRP_CALL_FLUSH;
|
||||
|
|
@ -661,7 +660,7 @@ static void device_file_flush( struct fd *fd, struct async *async )
|
|||
static void device_file_ioctl( struct fd *fd, ioctl_code_t code, struct async *async )
|
||||
{
|
||||
struct device_file *file = get_fd_user( fd );
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
memset( ¶ms, 0, sizeof(params) );
|
||||
params.ioctl.type = IRP_CALL_IOCTL;
|
||||
|
|
@ -672,7 +671,7 @@ static void device_file_ioctl( struct fd *fd, ioctl_code_t code, struct async *a
|
|||
static void cancel_irp_call( struct irp_call *irp )
|
||||
{
|
||||
struct irp_call *cancel_irp;
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
irp->canceled = 1;
|
||||
if (!irp->user_ptr || !irp->file || !irp->file->device->manager) return;
|
||||
|
|
@ -843,7 +842,7 @@ void free_kernel_objects( struct object *obj )
|
|||
{
|
||||
struct kernel_object *kernel_object = LIST_ENTRY( ptr, struct kernel_object, list_entry );
|
||||
struct irp_call *irp;
|
||||
union irp_params params;
|
||||
irp_params_t params;
|
||||
|
||||
assert( !kernel_object->owned );
|
||||
|
||||
|
|
|
|||
|
|
@ -248,7 +248,7 @@ static void keyed_event_dump( struct object *obj, int verbose )
|
|||
fputs( "Keyed event\n", stderr );
|
||||
}
|
||||
|
||||
static enum select_opcode matching_op( enum select_opcode op )
|
||||
static enum select_op matching_op( enum select_op op )
|
||||
{
|
||||
return op ^ (SELECT_KEYED_EVENT_WAIT ^ SELECT_KEYED_EVENT_RELEASE);
|
||||
}
|
||||
|
|
@ -257,7 +257,7 @@ static int keyed_event_signaled( struct object *obj, struct wait_queue_entry *en
|
|||
{
|
||||
struct wait_queue_entry *ptr;
|
||||
struct process *process;
|
||||
enum select_opcode select_op;
|
||||
enum select_op select_op;
|
||||
|
||||
assert( obj->ops == &keyed_event_ops );
|
||||
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ struct request_max_size
|
|||
|
||||
|
||||
/* debug event data */
|
||||
union debug_event_data
|
||||
typedef union
|
||||
{
|
||||
int code; /* event code */
|
||||
struct
|
||||
|
|
@ -125,7 +125,7 @@ union debug_event_data
|
|||
int __pad;
|
||||
mod_handle_t base; /* base address of the dll */
|
||||
} unload_dll;
|
||||
};
|
||||
} debug_event_t;
|
||||
|
||||
|
||||
enum context_exec_space
|
||||
|
|
@ -328,7 +328,7 @@ struct winevent_msg_data
|
|||
/* followed by module name if any */
|
||||
};
|
||||
|
||||
union hw_input
|
||||
typedef union
|
||||
{
|
||||
int type;
|
||||
struct
|
||||
|
|
@ -358,15 +358,15 @@ union hw_input
|
|||
lparam_t lparam; /* parameters */
|
||||
struct hid_input hid; /* defined in ntuser.h */
|
||||
} hw;
|
||||
};
|
||||
} hw_input_t;
|
||||
|
||||
union message_data
|
||||
typedef union
|
||||
{
|
||||
unsigned char bytes[1]; /* raw data for sent messages */
|
||||
struct hardware_msg_data hardware;
|
||||
struct callback_msg_data callback;
|
||||
struct winevent_msg_data winevent;
|
||||
};
|
||||
} message_data_t;
|
||||
|
||||
/* structure returned in filesystem events */
|
||||
struct filesystem_event
|
||||
|
|
@ -451,7 +451,7 @@ struct object_type_info
|
|||
/* VARARG(name,unicode_str); */
|
||||
};
|
||||
|
||||
enum select_opcode
|
||||
enum select_op
|
||||
{
|
||||
SELECT_NONE,
|
||||
SELECT_WAIT,
|
||||
|
|
@ -461,28 +461,28 @@ enum select_opcode
|
|||
SELECT_KEYED_EVENT_RELEASE
|
||||
};
|
||||
|
||||
union select_op
|
||||
typedef union
|
||||
{
|
||||
enum select_opcode op;
|
||||
enum select_op op;
|
||||
struct
|
||||
{
|
||||
enum select_opcode op; /* SELECT_WAIT or SELECT_WAIT_ALL */
|
||||
enum select_op op; /* SELECT_WAIT or SELECT_WAIT_ALL */
|
||||
obj_handle_t handles[MAXIMUM_WAIT_OBJECTS];
|
||||
int __pad;
|
||||
} wait;
|
||||
struct
|
||||
{
|
||||
enum select_opcode op; /* SELECT_SIGNAL_AND_WAIT */
|
||||
enum select_op op; /* SELECT_SIGNAL_AND_WAIT */
|
||||
obj_handle_t wait;
|
||||
obj_handle_t signal; /* must be last in the structure so we can remove it on retries */
|
||||
} signal_and_wait;
|
||||
struct
|
||||
{
|
||||
enum select_opcode op; /* SELECT_KEYED_EVENT_WAIT or SELECT_KEYED_EVENT_RELEASE */
|
||||
enum select_op op; /* SELECT_KEYED_EVENT_WAIT or SELECT_KEYED_EVENT_RELEASE */
|
||||
obj_handle_t handle;
|
||||
client_ptr_t key;
|
||||
} keyed_event;
|
||||
};
|
||||
} select_op_t;
|
||||
|
||||
enum apc_type
|
||||
{
|
||||
|
|
@ -764,7 +764,7 @@ enum irp_type
|
|||
IRP_CALL_CANCEL
|
||||
};
|
||||
|
||||
union irp_params
|
||||
typedef union
|
||||
{
|
||||
enum irp_type type; /* irp call type */
|
||||
struct
|
||||
|
|
@ -832,7 +832,7 @@ union irp_params
|
|||
int __pad;
|
||||
client_ptr_t irp; /* opaque ptr for canceled irp */
|
||||
} cancel;
|
||||
};
|
||||
} irp_params_t;
|
||||
|
||||
/* information about a PE image mapping, roughly equivalent to SECTION_IMAGE_INFORMATION */
|
||||
typedef struct
|
||||
|
|
@ -2241,7 +2241,7 @@ enum message_type
|
|||
/* Send a hardware message to a thread queue */
|
||||
@REQ(send_hardware_message)
|
||||
user_handle_t win; /* window handle */
|
||||
union hw_input input; /* input data */
|
||||
hw_input_t input; /* input data */
|
||||
unsigned int flags; /* flags (see below) */
|
||||
VARARG(report,bytes); /* HID report data */
|
||||
@REPLY
|
||||
|
|
@ -3695,7 +3695,7 @@ typedef union
|
|||
data_size_t result; /* IOSB result of the previous irp */
|
||||
VARARG(data,bytes); /* output data of the previous irp */
|
||||
@REPLY
|
||||
union irp_params params; /* irp parameters */
|
||||
irp_params_t params; /* irp parameters */
|
||||
obj_handle_t next; /* handle to the next irp */
|
||||
thread_id_t client_tid; /* tid of thread calling irp */
|
||||
client_ptr_t client_thread; /* pointer to thread object of calling irp */
|
||||
|
|
|
|||
|
|
@ -2106,7 +2106,7 @@ static void rawkeyboard_init( struct rawinput *rawinput, RAWKEYBOARD *keyboard,
|
|||
keyboard->ExtraInformation = info;
|
||||
}
|
||||
|
||||
static void rawhid_init( struct rawinput *rawinput, RAWHID *hid, const union hw_input *input )
|
||||
static void rawhid_init( struct rawinput *rawinput, RAWHID *hid, const hw_input_t *input )
|
||||
{
|
||||
rawinput->type = RIM_TYPEHID;
|
||||
rawinput->device = input->hw.hid.device;
|
||||
|
|
@ -2203,7 +2203,7 @@ static void dispatch_rawinput_message( struct desktop *desktop, struct rawinput_
|
|||
}
|
||||
|
||||
/* queue a hardware message for a mouse event */
|
||||
static int queue_mouse_message( struct desktop *desktop, user_handle_t win, const union hw_input *input,
|
||||
static int queue_mouse_message( struct desktop *desktop, user_handle_t win, const hw_input_t *input,
|
||||
unsigned int origin, struct msg_queue *sender )
|
||||
{
|
||||
const desktop_shm_t *desktop_shm = desktop->shared;
|
||||
|
|
@ -2309,7 +2309,7 @@ static int queue_mouse_message( struct desktop *desktop, user_handle_t win, cons
|
|||
return wait;
|
||||
}
|
||||
|
||||
static int queue_keyboard_message( struct desktop *desktop, user_handle_t win, const union hw_input *input,
|
||||
static int queue_keyboard_message( struct desktop *desktop, user_handle_t win, const hw_input_t *input,
|
||||
unsigned int origin, struct msg_queue *sender, int repeat );
|
||||
|
||||
static void key_repeat_timeout( void *private )
|
||||
|
|
@ -2329,7 +2329,7 @@ static void stop_key_repeat( struct desktop *desktop )
|
|||
}
|
||||
|
||||
/* queue a hardware message for a keyboard event */
|
||||
static int queue_keyboard_message( struct desktop *desktop, user_handle_t win, const union hw_input *input,
|
||||
static int queue_keyboard_message( struct desktop *desktop, user_handle_t win, const hw_input_t *input,
|
||||
unsigned int origin, struct msg_queue *sender, int repeat )
|
||||
{
|
||||
const desktop_shm_t *desktop_shm = desktop->shared;
|
||||
|
|
@ -2502,7 +2502,7 @@ struct pointer
|
|||
struct desktop *desktop;
|
||||
user_handle_t win;
|
||||
int primary;
|
||||
union hw_input input;
|
||||
hw_input_t input;
|
||||
};
|
||||
|
||||
static void queue_pointer_message( struct pointer *pointer, int repeated );
|
||||
|
|
@ -2524,7 +2524,7 @@ static void queue_pointer_message( struct pointer *pointer, int repeated )
|
|||
struct hw_msg_source source = { IMDT_UNAVAILABLE, IMDT_TOUCH };
|
||||
struct desktop *desktop = pointer->desktop;
|
||||
const desktop_shm_t *desktop_shm = desktop->shared;
|
||||
const union hw_input *input = &pointer->input;
|
||||
const hw_input_t *input = &pointer->input;
|
||||
unsigned int i, wparam = input->hw.wparam;
|
||||
timeout_t time = get_tick_count();
|
||||
user_handle_t win = pointer->win;
|
||||
|
|
@ -2600,7 +2600,7 @@ static struct pointer *find_pointer_from_id( struct desktop *desktop, unsigned i
|
|||
|
||||
/* queue a hardware message for a custom type of event */
|
||||
static void queue_custom_hardware_message( struct desktop *desktop, user_handle_t win,
|
||||
unsigned int origin, const union hw_input *input )
|
||||
unsigned int origin, const hw_input_t *input )
|
||||
{
|
||||
const desktop_shm_t *desktop_shm = desktop->shared;
|
||||
struct hw_msg_source source = { IMDT_UNAVAILABLE, origin };
|
||||
|
|
|
|||
10
server/request_handlers.h
generated
10
server/request_handlers.h
generated
|
|
@ -604,12 +604,16 @@ C_ASSERT( sizeof(client_ptr_t) == 8 );
|
|||
C_ASSERT( sizeof(context_t) == 1728 );
|
||||
C_ASSERT( sizeof(cursor_pos_t) == 24 );
|
||||
C_ASSERT( sizeof(data_size_t) == 4 );
|
||||
C_ASSERT( sizeof(debug_event_t) == 160 );
|
||||
C_ASSERT( sizeof(file_pos_t) == 8 );
|
||||
C_ASSERT( sizeof(generic_map_t) == 16 );
|
||||
C_ASSERT( sizeof(hw_input_t) == 40 );
|
||||
C_ASSERT( sizeof(int) == 4 );
|
||||
C_ASSERT( sizeof(ioctl_code_t) == 4 );
|
||||
C_ASSERT( sizeof(irp_params_t) == 32 );
|
||||
C_ASSERT( sizeof(lparam_t) == 8 );
|
||||
C_ASSERT( sizeof(mem_size_t) == 8 );
|
||||
C_ASSERT( sizeof(message_data_t) == 48 );
|
||||
C_ASSERT( sizeof(mod_handle_t) == 8 );
|
||||
C_ASSERT( sizeof(obj_handle_t) == 4 );
|
||||
C_ASSERT( sizeof(obj_locator_t) == 16 );
|
||||
|
|
@ -618,6 +622,7 @@ C_ASSERT( sizeof(pe_image_info_t) == 88 );
|
|||
C_ASSERT( sizeof(process_id_t) == 4 );
|
||||
C_ASSERT( sizeof(property_data_t) == 16 );
|
||||
C_ASSERT( sizeof(rectangle_t) == 16 );
|
||||
C_ASSERT( sizeof(select_op_t) == 264 );
|
||||
C_ASSERT( sizeof(short int) == 2 );
|
||||
C_ASSERT( sizeof(startup_info_t) == 96 );
|
||||
C_ASSERT( sizeof(struct async_data) == 40 );
|
||||
|
|
@ -637,11 +642,6 @@ C_ASSERT( sizeof(timeout_t) == 8 );
|
|||
C_ASSERT( sizeof(udp_endpoint) == 32 );
|
||||
C_ASSERT( sizeof(union apc_call) == 64 );
|
||||
C_ASSERT( sizeof(union apc_result) == 40 );
|
||||
C_ASSERT( sizeof(union debug_event_data) == 160 );
|
||||
C_ASSERT( sizeof(union hw_input) == 40 );
|
||||
C_ASSERT( sizeof(union irp_params) == 32 );
|
||||
C_ASSERT( sizeof(union message_data) == 48 );
|
||||
C_ASSERT( sizeof(union select_op) == 264 );
|
||||
C_ASSERT( sizeof(unsigned __int64) == 8 );
|
||||
C_ASSERT( sizeof(unsigned char) == 1 );
|
||||
C_ASSERT( sizeof(unsigned int) == 4 );
|
||||
|
|
|
|||
4
server/request_trace.h
generated
4
server/request_trace.h
generated
|
|
@ -9,9 +9,9 @@ static void dump_abstime( const char *prefix, const abstime_t *val );
|
|||
static void dump_apc_result( const char *prefix, const union apc_result *val );
|
||||
static void dump_async_data( const char *prefix, const struct async_data *val );
|
||||
static void dump_generic_map( const char *prefix, const generic_map_t *val );
|
||||
static void dump_hw_input( const char *prefix, const union hw_input *val );
|
||||
static void dump_hw_input( const char *prefix, const hw_input_t *val );
|
||||
static void dump_ioctl_code( const char *prefix, const ioctl_code_t *val );
|
||||
static void dump_irp_params( const char *prefix, const union irp_params *val );
|
||||
static void dump_irp_params( const char *prefix, const irp_params_t *val );
|
||||
static void dump_luid( const char *prefix, const struct luid *val );
|
||||
static void dump_obj_locator( const char *prefix, const obj_locator_t *val );
|
||||
static void dump_rectangle( const char *prefix, const rectangle_t *val );
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ struct thread_wait
|
|||
int count; /* count of objects */
|
||||
int flags;
|
||||
int abandoned;
|
||||
enum select_opcode select;
|
||||
enum select_op select;
|
||||
client_ptr_t key; /* wait key for keyed events */
|
||||
client_ptr_t cookie; /* magic cookie to return to client */
|
||||
abstime_t when;
|
||||
|
|
@ -721,7 +721,7 @@ struct thread *get_wait_queue_thread( struct wait_queue_entry *entry )
|
|||
return entry->wait->thread;
|
||||
}
|
||||
|
||||
enum select_opcode get_wait_queue_select_op( struct wait_queue_entry *entry )
|
||||
enum select_op get_wait_queue_select_op( struct wait_queue_entry *entry )
|
||||
{
|
||||
return entry->wait->select;
|
||||
}
|
||||
|
|
@ -775,7 +775,7 @@ static unsigned int end_wait( struct thread *thread, unsigned int status )
|
|||
}
|
||||
|
||||
/* build the thread wait structure */
|
||||
static int wait_on( const union select_op *select_op, unsigned int count, struct object *objects[],
|
||||
static int wait_on( const select_op_t *select_op, unsigned int count, struct object *objects[],
|
||||
int flags, abstime_t when )
|
||||
{
|
||||
struct thread_wait *wait;
|
||||
|
|
@ -812,7 +812,7 @@ static int wait_on( const union select_op *select_op, unsigned int count, struct
|
|||
return current->wait ? 1 : 0;
|
||||
}
|
||||
|
||||
static int wait_on_handles( const union select_op *select_op, unsigned int count, const obj_handle_t *handles,
|
||||
static int wait_on_handles( const select_op_t *select_op, unsigned int count, const obj_handle_t *handles,
|
||||
int flags, abstime_t when )
|
||||
{
|
||||
struct object *objects[MAXIMUM_WAIT_OBJECTS];
|
||||
|
|
@ -981,7 +981,7 @@ static int signal_object( obj_handle_t handle )
|
|||
}
|
||||
|
||||
/* select on a list of handles */
|
||||
static int select_on( const union select_op *select_op, data_size_t op_size, client_ptr_t cookie,
|
||||
static int select_on( const select_op_t *select_op, data_size_t op_size, client_ptr_t cookie,
|
||||
int flags, abstime_t when )
|
||||
{
|
||||
int ret;
|
||||
|
|
@ -996,8 +996,8 @@ static int select_on( const union select_op *select_op, data_size_t op_size, cli
|
|||
|
||||
case SELECT_WAIT:
|
||||
case SELECT_WAIT_ALL:
|
||||
count = (op_size - offsetof( union select_op, wait.handles )) / sizeof(select_op->wait.handles[0]);
|
||||
if (op_size < offsetof( union select_op, wait.handles ) || count > MAXIMUM_WAIT_OBJECTS)
|
||||
count = (op_size - offsetof( select_op_t, wait.handles )) / sizeof(select_op->wait.handles[0]);
|
||||
if (op_size < offsetof( select_op_t, wait.handles ) || count > MAXIMUM_WAIT_OBJECTS)
|
||||
{
|
||||
set_error( STATUS_INVALID_PARAMETER );
|
||||
return 1;
|
||||
|
|
@ -1580,7 +1580,7 @@ DECL_HANDLER(resume_thread)
|
|||
/* select on a handle list */
|
||||
DECL_HANDLER(select)
|
||||
{
|
||||
union select_op select_op;
|
||||
select_op_t select_op;
|
||||
data_size_t op_size, ctx_size;
|
||||
struct context *ctx;
|
||||
struct thread_apc *apc;
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ extern struct thread *get_thread_from_handle( obj_handle_t handle, unsigned int
|
|||
extern struct thread *get_thread_from_tid( int tid );
|
||||
extern struct thread *get_thread_from_pid( int pid );
|
||||
extern struct thread *get_wait_queue_thread( struct wait_queue_entry *entry );
|
||||
extern enum select_opcode get_wait_queue_select_op( struct wait_queue_entry *entry );
|
||||
extern enum select_op get_wait_queue_select_op( struct wait_queue_entry *entry );
|
||||
extern client_ptr_t get_wait_queue_key( struct wait_queue_entry *entry );
|
||||
extern void make_wait_abandoned( struct wait_queue_entry *entry );
|
||||
extern void set_wait_status( struct wait_queue_entry *entry, int status );
|
||||
|
|
|
|||
|
|
@ -387,7 +387,7 @@ static void dump_async_data( const char *prefix, const struct async_data *data )
|
|||
fputc( '}', stderr );
|
||||
}
|
||||
|
||||
static void dump_irp_params( const char *prefix, const union irp_params *data )
|
||||
static void dump_irp_params( const char *prefix, const irp_params_t *data )
|
||||
{
|
||||
switch (data->type)
|
||||
{
|
||||
|
|
@ -449,7 +449,7 @@ static void dump_irp_params( const char *prefix, const union irp_params *data )
|
|||
}
|
||||
}
|
||||
|
||||
static void dump_hw_input( const char *prefix, const union hw_input *input )
|
||||
static void dump_hw_input( const char *prefix, const hw_input_t *input )
|
||||
{
|
||||
switch (input->type)
|
||||
{
|
||||
|
|
@ -582,7 +582,7 @@ static void dump_varargs_apc_result( const char *prefix, data_size_t size )
|
|||
|
||||
static void dump_varargs_select_op( const char *prefix, data_size_t size )
|
||||
{
|
||||
union select_op data;
|
||||
select_op_t data;
|
||||
|
||||
if (!size)
|
||||
{
|
||||
|
|
@ -601,9 +601,9 @@ static void dump_varargs_select_op( const char *prefix, data_size_t size )
|
|||
case SELECT_WAIT:
|
||||
case SELECT_WAIT_ALL:
|
||||
fprintf( stderr, "%s", data.op == SELECT_WAIT ? "WAIT" : "WAIT_ALL" );
|
||||
if (size > offsetof( union select_op, wait.handles ))
|
||||
if (size > offsetof( select_op_t, wait.handles ))
|
||||
dump_handles( ",handles=", data.wait.handles,
|
||||
min( size, sizeof(data.wait) ) - offsetof( union select_op, wait.handles ));
|
||||
min( size, sizeof(data.wait) ) - offsetof( select_op_t, wait.handles ));
|
||||
break;
|
||||
case SELECT_SIGNAL_AND_WAIT:
|
||||
fprintf( stderr, "SIGNAL_AND_WAIT,signal=%04x,wait=%04x",
|
||||
|
|
@ -887,7 +887,7 @@ static void dump_varargs_contexts( const char *prefix, data_size_t size )
|
|||
|
||||
static void dump_varargs_debug_event( const char *prefix, data_size_t size )
|
||||
{
|
||||
union debug_event_data event;
|
||||
debug_event_t event;
|
||||
|
||||
if (!size)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ struct key_repeat
|
|||
int enable; /* enable auto-repeat */
|
||||
timeout_t delay; /* auto-repeat delay */
|
||||
timeout_t period; /* auto-repeat period */
|
||||
union hw_input input; /* the input to repeat */
|
||||
hw_input_t input; /* the input to repeat */
|
||||
user_handle_t win; /* target window for input event */
|
||||
struct timeout_user *timeout; /* timeout for repeat */
|
||||
};
|
||||
|
|
|
|||
|
|
@ -38,33 +38,33 @@ my %formats =
|
|||
"timeout_t" => [ 8, 8 ],
|
||||
"abstime_t" => [ 8, 8 ],
|
||||
"rectangle_t" => [ 16, 4 ],
|
||||
"irp_params_t" => [ 32, 8 ],
|
||||
"generic_map_t" => [ 16, 4 ],
|
||||
"ioctl_code_t" => [ 4, 4 ],
|
||||
"hw_input_t" => [ 40, 8 ],
|
||||
"obj_locator_t" => [ 16, 8 ],
|
||||
# varargs-only structures
|
||||
"context_t" => [ 1728, 8 ],
|
||||
"cursor_pos_t" => [ 24, 8 ],
|
||||
"debug_event_t" => [ 160, 8 ],
|
||||
"message_data_t" => [ 48, 8 ],
|
||||
"pe_image_info_t" => [ 88, 8 ],
|
||||
"property_data_t" => [ 16, 8 ],
|
||||
"select_op_t" => [ 264, 8 ],
|
||||
"startup_info_t" => [ 96, 4 ],
|
||||
"tcp_connection" => [ 60, 4 ],
|
||||
"udp_endpoint" => [ 32, 4 ],
|
||||
"union apc_call" => [ 64, 8 ],
|
||||
"union apc_result" => [ 40, 8 ],
|
||||
"struct async_data" => [ 40, 8 ],
|
||||
"union debug_event_data" => [ 160, 8 ],
|
||||
"struct filesystem_event" => [ 12, 4 ],
|
||||
"struct handle_info" => [ 20, 4 ],
|
||||
"union hw_input" => [ 40, 8 ],
|
||||
"union irp_params" => [ 32, 8 ],
|
||||
"struct luid" => [ 8, 4 ],
|
||||
"struct luid_attr" => [ 12, 4 ],
|
||||
"union message_data" => [ 48, 8 ],
|
||||
"struct object_attributes" => [ 16, 4 ],
|
||||
"struct object_type_info" => [ 44, 4 ],
|
||||
"struct process_info" => [ 40, 8 ],
|
||||
"struct rawinput_device" => [ 12, 4 ],
|
||||
"union select_op" => [ 264, 8 ],
|
||||
"struct thread_info" => [ 40, 8 ],
|
||||
"struct user_apc" => [ 40, 8 ],
|
||||
);
|
||||
|
|
|
|||
Loading…
Reference in a new issue