lstrcpy(ptr + 1, szExt);
}
-BOOL CALLBACK DifficultyDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
+INT_PTR CALLBACK DifficultyDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
}
-BOOL CALLBACK CardBackDlgProc(HWND hDlg,
+INT_PTR CALLBACK CardBackDlgProc(HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
int test[] = { LOWORD(lParam) - 260, LOWORD(lParam) - 140, LOWORD(lParam) - 20 };
SendMessage(hStatusBar, WM_SIZE, wParam, lParam);
- SendMessage(hStatusBar, SB_SETPARTS, 3, (int)&test);
+ SendMessage(hStatusBar, SB_SETPARTS, 3, (LPARAM)&test);
MoveWindow(hScrollbox, 56, 49, LOWORD(lParam) - 56, HIWORD(lParam) - 72, TRUE);
//InvalidateRect(hwnd, NULL, TRUE);
}
/* Toolbar buttons */
static const TBBUTTON Buttons[] =
{ /* iBitmap, idCommand, fsState, fsStyle, bReserved[2], dwData, iString */
- { 0, ID_INSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (int) szInstallBtn},
- { 1, ID_UNINSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (int) szUninstallBtn},
- { 2, ID_MODIFY, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (int) szModifyBtn},
+ { 0, ID_INSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (INT_PTR)szInstallBtn},
+ { 1, ID_UNINSTALL, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (INT_PTR)szUninstallBtn},
+ { 2, ID_MODIFY, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, (INT_PTR)szModifyBtn},
{ 5, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0},
{ 3, ID_REFRESH, TBSTATE_ENABLED, BTNS_BUTTON | BTNS_AUTOSIZE, {0}, 0, 0},
{ 5, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0},
#include "stdafx.h"
#include "audio_resampler_acm.hpp"
+#include <stdio.h>
continue;
errno = 0;
- req.bytesReady = (DWORD)outPtr - (DWORD)&req.mesout;
+ req.bytesReady = (DWORD_PTR)outPtr - (DWORD_PTR)&req.mesout;
//printf("Bytes Ready=%u\n", req.bytesReady);
send(req.sock, (const char*)&req.mesout, req.bytesReady, 0);
errno = WSAGetLastError();
PLOCALGROUP_INFO_1 pBuffer;
DWORD entriesread;
DWORD totalentries;
- DWORD resume_handle = 0;
+ DWORD_PTR resume_handle = 0;
DWORD i;
LV_ITEM lvi;
INT iItem;
PLOCALGROUP_INFO_1 pBuffer;
DWORD entriesread;
DWORD totalentries;
- DWORD resume_handle = 0;
+ DWORD_PTR resume_handle = 0;
DWORD i;
LV_ITEM lvi;
INT iItem;
static HRESULT InvalidCall(LPDIRECT3DDEVICE9_INT This, LPSTR ErrorMsg)
{
- DPRINT1(ErrorMsg);
+ DPRINT1("%s",ErrorMsg);
UNLOCK_D3DDEVICE9();
return D3DERR_INVALIDCALL;
}
HRESULT AlignedAlloc(IN OUT LPVOID *ppObject, IN SIZE_T dwSize)
{
- ULONG AddressOffset;
+ ULONG_PTR AddressOffset;
ULONG AlignedMask = MEM_ALIGNMENT - 1;
CHAR *AlignedPtr;
ULONG_PTR *AlignedOffsetPtr;
if (AlignedPtr == 0)
return DDERR_OUTOFMEMORY;
- AddressOffset = MEM_ALIGNMENT - ((ULONG)AlignedPtr & AlignedMask);
+ AddressOffset = MEM_ALIGNMENT - ((ULONG_PTR)AlignedPtr & AlignedMask);
AlignedPtr += AddressOffset;
/* Get our hdc for the active window */
- hDC = GetDC(lpLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
+ hDC = GetDC((HWND)lpLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
DX_WINDBG_trace();
/* Get our hdc for the active window */
- hDC = GetDC(lpUnLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
+ hDC = GetDC((HWND)lpUnLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
if (device->driver)
flags |= WAVE_DIRECTSOUND;
- hres = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode, device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD)device, flags));
+ hres = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode, device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD_PTR)device, flags));
if (FAILED(hres)) {
WARN("waveOutOpen failed\n");
if (device->driver)
S(prop).Set = *guidPropSet;
S(prop).Id = dwPropID;
S(prop).Flags = 0; /* unused */
- S(prop).InstanceId = (ULONG)This->dsb->device;
+ S(prop).InstanceId = (ULONG_PTR)This->dsb->device;
hres = IDsDriverPropertySet_Get(ps, &prop, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
S(prop).Set = *guidPropSet;
S(prop).Id = dwPropID;
S(prop).Flags = 0; /* unused */
- S(prop).InstanceId = (ULONG)This->dsb->device;
+ S(prop).InstanceId = (ULONG_PTR)This->dsb->device;
hres = IDsDriverPropertySet_Set(ps,&prop,pInstanceData,cbInstanceData,pPropData,cbPropData);
IDsDriverPropertySet_Release(ps);
BOOL
CallClient(
DeviceInfo* device_info,
- DWORD message,
- DWORD parameter1,
- DWORD parameter2)
+ DWORD_PTR message,
+ DWORD_PTR parameter1,
+ DWORD_PTR parameter2)
{
- DPRINT("Calling client - callback 0x%x mmhandle 0x%x\n", (int) device_info->callback, (int) device_info->mme_handle);
+ DPRINT("Calling client - callback 0x%x mmhandle 0x%x\n", (int) device_info->callback, device_info->mme_handle);
return DriverCallback(device_info->callback,
HIWORD(device_info->flags),
device_info->mme_handle,
header->dwFlags |= MHDR_DONE;
header->dwFlags &= ~ MHDR_INQUEUE;
- DPRINT("Success? %d\n", (int) CallClient(the_device, MOM_DONE, (DWORD) header, 0));
+ DPRINT("Success? %d\n", CallClient(the_device, MOM_DONE, (DWORD_PTR) header, 0));
return MMSYSERR_NOERROR;
}
modMessage(
UINT device_id,
UINT message,
- DWORD private_data,
- DWORD parameter1,
- DWORD parameter2)
+ DWORD_PTR private_data,
+ DWORD_PTR parameter1,
+ DWORD_PTR parameter2)
{
switch ( message )
{
<?xml version="1.0"?>
<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
<group>
-<module name="comctl32" type="win32dll" baseaddress="${BASEADDRESS_COMCTL32}" installbase="system32" installname="comctl32.dll" allowwarnings="true">
+<module name="comctl32" type="win32dll" baseaddress="${BASEADDRESS_COMCTL32}" installbase="system32" installname="comctl32.dll" unicode="yes" allowwarnings="true">
<autoregister infsection="OleControlDlls" type="DllInstall" />
<importlibrary definition="comctl32.spec" />
<include base="comctl32">.</include>
RtlEnterCriticalSection(&PolicyHandleTableLock);
if (RtlIsValidIndexHandle(&PolicyHandleTable,
- (ULONG)ObjectHandle,
+ HandleToUlong(ObjectHandle),
(PRTL_HANDLE_TABLE_ENTRY*)&ReferencedPolicy) &&
!(ReferencedPolicy->Flags & POLICY_DELETE))
{
DWORD
GetDeviceCapabilities(
DeviceType device_type,
- DWORD device_id,
- PVOID capabilities,
+ UINT device_id,
+ DWORD_PTR capabilities,
DWORD capabilities_size)
{
MMRESULT result;
DWORD
OpenDevice(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
PVOID open_descriptor,
DWORD flags,
- DWORD private_handle)
+ DWORD_PTR private_handle)
{
SessionInfo* session_info;
MMRESULT result;
DWORD
CloseDevice(
- DWORD private_handle)
+ DWORD_PTR private_handle)
{
MMRESULT result;
SessionInfo* session_info = (SessionInfo*) private_handle;
MMRESULT
CobbleDeviceName(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
PWCHAR out_device_name)
{
WCHAR base_device_name[MAX_DEVICE_NAME_LENGTH];
MMRESULT
OpenKernelDevice(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
DWORD access,
HANDLE* handle)
{
struct _SessionInfo* next;
DeviceType device_type;
- DWORD device_id;
+ UINT device_id;
HANDLE kernel_device_handle;
BOOL is_paused;
/* Stuff passed to us from winmm */
- DWORD app_user_data;
- DWORD callback;
+ DWORD_PTR app_user_data;
+ DWORD_PTR callback;
DWORD flags;
NotifyClient(
SessionInfo* session_info,
DWORD message,
- DWORD parameter1,
- DWORD parameter2);
+ DWORD_PTR parameter1,
+ DWORD_PTR parameter2);
/*
MMRESULT
CobbleDeviceName(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
PWCHAR out_device_name);
MMRESULT
OpenKernelDevice(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
DWORD access,
HANDLE* handle);
MMRESULT
CreateSession(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
SessionInfo** session_info);
VOID
SessionInfo*
GetSession(
DeviceType device_type,
- DWORD device_id);
+ UINT device_id);
MMRESULT
StartSessionThread(SessionInfo* session_info);
DWORD
HandleBySessionThread(
- DWORD private_handle,
- DWORD message,
- DWORD parameter);
+ DWORD_PTR private_handle,
+ DWORD_PTR message,
+ DWORD_PTR parameter);
/* General */
DWORD
GetDeviceCapabilities(
DeviceType device_type,
- DWORD device_id,
- PVOID capabilities,
+ UINT device_id,
+ DWORD_PTR capabilities,
DWORD capabilities_size);
DWORD
OpenDevice(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
PVOID open_descriptor,
DWORD flags,
- DWORD private_handle);
+ DWORD_PTR private_handle);
DWORD
CloseDevice(
- DWORD private_handle);
+ DWORD_PTR private_handle);
DWORD
PauseDevice(
DWORD
WriteWaveBuffer(
- DWORD private_handle,
+ DWORD_PTR private_handle,
PWAVEHDR wave_header,
DWORD wave_header_size);
NotifyClient(
SessionInfo* session_info,
DWORD message,
- DWORD parameter1,
- DWORD parameter2)
+ DWORD_PTR parameter1,
+ DWORD_PTR parameter2)
{
return DriverCallback(session_info->callback,
HIWORD(session_info->flags),
DWORD APIENTRY
wodMessage(
- DWORD device_id,
- DWORD message,
- DWORD private_handle,
- DWORD parameter1,
- DWORD parameter2)
+ UINT device_id,
+ UINT message,
+ DWORD_PTR private_handle,
+ DWORD_PTR parameter1,
+ DWORD_PTR parameter2)
{
switch ( message )
{
DPRINT("WODM_GETDEVCAPS\n");
return GetDeviceCapabilities(WaveOutDevice,
device_id,
- (PVOID) parameter1,
+ parameter1,
parameter2);
/* http://www.osronline.com/ddkx/w98ddk/mmedia_4p85.htm */
SessionInfo*
GetSession(
DeviceType device_type,
- DWORD device_id)
+ UINT device_id)
{
SessionInfo* session_info;
MMRESULT
CreateSession(
DeviceType device_type,
- DWORD device_id,
+ UINT device_id,
SessionInfo** session_info)
{
HANDLE heap = GetProcessHeap();
result = mmTaskCreate(task,
&session_info->thread.handle,
- (DWORD) session_info);
+ (DWORD_PTR)session_info);
if ( result != MMSYSERR_NOERROR )
{
DWORD
HandleBySessionThread(
- DWORD private_handle,
- DWORD message,
- DWORD parameter)
+ DWORD_PTR private_handle,
+ DWORD_PTR message,
+ DWORD_PTR parameter)
{
return CallSessionThread((SessionInfo*) private_handle,
message,
wave_header->dwFlags |= WHDR_INQUEUE;
/* Save our handle in the header */
- wave_header->reserved = (DWORD) session_info;
+ wave_header->reserved = (DWORD_PTR) session_info;
/* Locate the end of the queue */
previous_node = NULL;
message = (session_info->device_type == WaveOutDevice) ? WOM_DONE :
WIM_DATA;
- DPRINT("Notifying client that buffer 0x%x is done\n", (int) header);
+ DPRINT("Notifying client that buffer 0x%p is done\n", header);
/* Notify the client */
- NotifyClient(session_info, message, (DWORD) header, 0);
+ NotifyClient(session_info, message, (DWORD_PTR) header, 0);
}
}
DWORD
WriteWaveBuffer(
- DWORD private_handle,
+ DWORD_PTR private_handle,
PWAVEHDR wave_header,
DWORD wave_header_size)
{
return TRUE;
}
-static BOOL CALLBACK
+static INT_PTR CALLBACK
StatusMessageWindowProc(
IN HWND hwndDlg,
IN UINT uMsg,
This->lpNetMan = NULL;
This->pHead = NULL;
- if (InterlockedCompareExchangePointer((volatile void **)&cached_This, This, NULL) != NULL)
+ if (InterlockedCompareExchangePointer((void **)&cached_This, This, NULL) != NULL)
{
CoTaskMemFree(This);
}
#include "opengl32.h"
+#if defined(_M_IX86)
C_ASSERT(FIELD_OFFSET(TEB, glTable) == 0xbe8);
+#endif
int WINAPI glEmptyFunc0( void ) { return 0; }
int WINAPI glEmptyFunc4( long l1 ) { return 0; }
if (ReadPwrScheme(uiID,&tmp))
{
- if (RegOpenKeyEx(HKEY_CURRENT_USER,szUserPowerConfigSubKey,(DWORD)NULL,KEY_ALL_ACCESS,&hKey) != ERROR_SUCCESS)
+ if (RegOpenKeyEx(HKEY_CURRENT_USER,szUserPowerConfigSubKey,0,KEY_ALL_ACCESS,&hKey) != ERROR_SUCCESS)
{
return FALSE;
}
swprintf(Buf,L"%i",uiID);
- if (RegSetValueExW(hKey,szCurrentPowerPolicies,(DWORD)NULL,REG_SZ,(CONST BYTE *)Buf,strlenW(Buf)*sizeof(WCHAR)) == ERROR_SUCCESS)
+ if (RegSetValueExW(hKey,szCurrentPowerPolicies,0,REG_SZ,(CONST BYTE *)Buf,strlenW(Buf)*sizeof(WCHAR)) == ERROR_SUCCESS)
{
RegCloseKey(hKey);
if ((lpGlobalPowerPolicy != NULL) || (lpPowerPolicy != NULL))
&hKey))
return FALSE;
- if (RegSetValueExW(hKey,szPolicies,(DWORD)NULL,REG_BINARY,(const unsigned char *)&gupp,sizeof(GLOBAL_USER_POWER_POLICY)) == ERROR_SUCCESS)
+ if (RegSetValueExW(hKey,szPolicies,0,REG_BINARY,(const unsigned char *)&gupp,sizeof(GLOBAL_USER_POWER_POLICY)) == ERROR_SUCCESS)
{
RegCloseKey(hKey);
&hKey))
return FALSE;
- if (RegSetValueExW(hKey,szPolicies,(DWORD)NULL,REG_BINARY,(const unsigned char *)&gmpp,sizeof(GLOBAL_MACHINE_POWER_POLICY)) == ERROR_SUCCESS)
+ if (RegSetValueExW(hKey,szPolicies,0,REG_BINARY,(const unsigned char *)&gmpp,sizeof(GLOBAL_MACHINE_POWER_POLICY)) == ERROR_SUCCESS)
{
RegCloseKey(hKey);
return TRUE;
if (RegCreateKey(HKEY_LOCAL_MACHINE,Buf, &hKey) == ERROR_SUCCESS)
{
- RegSetValueExW(hKey,szPolicies,(DWORD)NULL,REG_BINARY,(const unsigned char *)pMachineProcessorPowerPolicy,sizeof(MACHINE_PROCESSOR_POWER_POLICY));
+ RegSetValueExW(hKey,szPolicies,0,REG_BINARY,(const unsigned char *)pMachineProcessorPowerPolicy,sizeof(MACHINE_PROCESSOR_POWER_POLICY));
RegCloseKey(hKey);
return TRUE;
}
&hKey) != ERROR_SUCCESS)
return;
swprintf(Buf,L"%i",g_LastID);
- RegSetValueExW(hKey,szLastID,(DWORD)NULL,REG_SZ,(CONST BYTE *)Buf,strlenW(Buf)*sizeof(WCHAR));
+ RegSetValueExW(hKey,szLastID,0,REG_SZ,(CONST BYTE *)Buf,strlenW(Buf)*sizeof(WCHAR));
RegCloseKey(hKey);
}
if (RegCreateKey(HKEY_CURRENT_USER,Buf,&hKey) == ERROR_SUCCESS)
{
- RegSetValueExW(hKey,szName,(DWORD)NULL,REG_SZ,(const unsigned char *)lpszName,strlenW((const char *)lpszName)*sizeof(WCHAR));
- RegSetValueExW(hKey,szDescription,(DWORD)NULL,REG_SZ,(const unsigned char *)lpszDescription,strlenW((const char *)lpszDescription)*sizeof(WCHAR));
+ RegSetValueExW(hKey,szName,0,REG_SZ,(const unsigned char *)lpszName,strlenW((const char *)lpszName)*sizeof(WCHAR));
+ RegSetValueExW(hKey,szDescription,0,REG_SZ,(const unsigned char *)lpszDescription,strlenW((const char *)lpszDescription)*sizeof(WCHAR));
RegCloseKey(hKey);
return WritePwrPolicy(puiID,pPowerPolicy);
}
if (RegCreateKey(HKEY_CURRENT_USER,Buf,&hKey) == ERROR_SUCCESS)
{
- RegSetValueExW(hKey,szPolicies,(DWORD)NULL,REG_BINARY,(const unsigned char *)&pPowerPolicy->user,sizeof(USER_POWER_POLICY));
+ RegSetValueExW(hKey,szPolicies,0,REG_BINARY,(const unsigned char *)&pPowerPolicy->user,sizeof(USER_POWER_POLICY));
RegCloseKey(hKey);
swprintf(Buf,L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Controls Folder\\PowerCfg\\PowerPolicies\\%i",*puiID);
if (RegCreateKey(HKEY_LOCAL_MACHINE,Buf,&hKey) == ERROR_SUCCESS)
{
- RegSetValueExW(hKey,szPolicies,(DWORD)NULL,REG_BINARY,(const unsigned char *)&pPowerPolicy->mach,sizeof(MACHINE_POWER_POLICY));
+ RegSetValueExW(hKey,szPolicies,0,REG_BINARY,(const unsigned char *)&pPowerPolicy->mach,sizeof(MACHINE_POWER_POLICY));
RegCloseKey(hKey);
return TRUE;
}
}
/* return current process */
- *Context->lpidProcess = (DWORD)CurrentProcess->UniqueProcessId;
+ *Context->lpidProcess = (DWORD_PTR)CurrentProcess->UniqueProcessId;
/* go to next array slot */
Context->lpidProcess++;
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#define LARGEINT_PROTOS
-#define LargeIntegerDivide RtlLargeIntegerDivide
-#define ExtendedIntegerMultiply RtlExtendedIntegerMultiply
-#define ConvertUlongToLargeInteger RtlConvertUlongToLargeInteger
-#define LargeIntegerSubtract RtlLargeIntegerSubtract
#define MAX_PROPERTY_SHEET_PAGE 32
#define WIN32_NO_STATUS
static
-LARGE_INTEGER
-GetFreeBytesShare(LARGE_INTEGER TotalNumberOfFreeBytes, LARGE_INTEGER TotalNumberOfBytes)
+ULONGLONG
+GetFreeBytesShare(ULONGLONG TotalNumberOfFreeBytes, ULONGLONG TotalNumberOfBytes)
{
- LARGE_INTEGER Temp, Result, Remainder;
+ ULONGLONG Temp;
- if (TotalNumberOfFreeBytes.QuadPart == 0LL)
+ if (TotalNumberOfFreeBytes == 0LL)
{
- return ConvertUlongToLargeInteger(0);
+ return 0;
}
- Temp = LargeIntegerDivide(TotalNumberOfBytes, ConvertUlongToLargeInteger(100), &Remainder);
- if (Temp.QuadPart >= TotalNumberOfFreeBytes.QuadPart)
+ Temp = TotalNumberOfBytes / 100;
+ if (Temp >= TotalNumberOfFreeBytes)
{
- Result = ConvertUlongToLargeInteger(1);
- }else
+ return 1;
+ }
+ else
{
- Result = LargeIntegerDivide(TotalNumberOfFreeBytes, Temp, &Remainder);
+ return TotalNumberOfFreeBytes / Temp;
}
-
- return Result;
}
static
HBRUSH hMagBrush;
RECT rect;
LONG horzsize;
- LARGE_INTEGER Result;
+ LONGLONG Result;
WCHAR szBuffer[20];
hBlueBrush = CreateSolidBrush(RGB(0, 0, 255));
hMagBrush = CreateSolidBrush(RGB(255, 0, 255));
SendDlgItemMessageW(hwndDlg, 14006, WM_GETTEXT, 20, (LPARAM)szBuffer);
- Result.QuadPart = _wtoi(szBuffer);
+ Result = _wtoi(szBuffer);
CopyRect(&rect, &drawItem->rcItem);
horzsize = rect.right - rect.left;
- Result.QuadPart = (Result.QuadPart * horzsize) / 100;
+ Result = (Result * horzsize) / 100;
- rect.right = drawItem->rcItem.right - Result.QuadPart;
+ rect.right = drawItem->rcItem.right - Result;
FillRect(drawItem->hDC, &rect, hBlueBrush);
rect.left = rect.right;
rect.right = drawItem->rcItem.right;
if(GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailable, (PULARGE_INTEGER)&TotalNumberOfBytes, (PULARGE_INTEGER)&TotalNumberOfFreeBytes))
{
WCHAR szResult[128];
- LARGE_INTEGER Result;
+ LONGLONG Result;
#ifdef IOCTL_DISK_GET_LENGTH_INFO_IMPLEMENTED
HANDLE hVolume;
DWORD BytesReturned = 0;
if (StrFormatByteSizeW(FreeBytesAvailable.QuadPart, szResult, sizeof(szResult) / sizeof(WCHAR)))
SendDlgItemMessageW(hwndDlg, 14005, WM_SETTEXT, (WPARAM)NULL, (LPARAM)szResult);
- Result = GetFreeBytesShare(TotalNumberOfFreeBytes, TotalNumberOfBytes);
+ Result = GetFreeBytesShare(TotalNumberOfFreeBytes.QuadPart, TotalNumberOfBytes.QuadPart);
/* set free bytes percentage */
- swprintf(szResult, L"%02d%%", Result.QuadPart);
+ swprintf(szResult, L"%02d%%", Result);
SendDlgItemMessageW(hwndDlg, 14006, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);
/* store used share amount */
- Result = LargeIntegerSubtract(ConvertUlongToLargeInteger(100), Result);
- swprintf(szResult, L"%02d%%", Result.QuadPart);
+ Result = 100 - Result;
+ swprintf(szResult, L"%02d%%", Result);
SendDlgItemMessageW(hwndDlg, 14004, WM_SETTEXT, (WPARAM)0, (LPARAM)szResult);
if (DriveType == DRIVE_FIXED)
{
SH_FileVersionQuerySetListText(hwndDlg, pBuf, wOriginalFilename, &str, lang, code);
SH_FileVersionQuerySetListText(hwndDlg, pBuf, wProductName, &str, lang, code);
SH_FileVersionQuerySetListText(hwndDlg, pBuf, wProductVersion, &str, lang, code);
- SetWindowLongPtr(hwndDlg, DWL_USER, (LONG)pBuf);
+ SetWindowLongPtr(hwndDlg, DWL_USER, (LONG_PTR)pBuf);
/* select first item */
hDlgCtrl = GetDlgItem(hwndDlg, 14009);
#define MRUF_STRING_LIST 0
-typedef int (WINAPI *CREATEMRULISTPROCW)(
+typedef HANDLE (WINAPI *CREATEMRULISTPROCW)(
LPMRUINFO lpmi
);
static HRESULT WINAPI SHEOWCm_fnQueryInterface(IContextMenu2 *iface, REFIID riid, LPVOID *ppvObj);
static ULONG WINAPI SHEOWCm_fnRelease(IContextMenu2 *iface);
-int OpenMRUList(HKEY hKey);
+HANDLE OpenMRUList(HKEY hKey);
void LoadItemFromHKCU(POPEN_WITH_CONTEXT pContext, WCHAR * szExt);
void LoadItemFromHKCR(POPEN_WITH_CONTEXT pContext, WCHAR * szExt);
void InsertOpenWithItem(POPEN_WITH_CONTEXT pContext, WCHAR * szAppName);
WCHAR * pFileExt;
HKEY hKey;
LONG result;
- int hList;
+ HANDLE hList;
/* get file extension */
pFileExt = wcsrchr(szFileName, L'.');
}
/* insert the entry */
- result = (*AddMRUStringW)((HANDLE)hList, szAppName);
+ result = (*AddMRUStringW)(hList, szAppName);
/* close mru list */
(*FreeMRUListProc)((HANDLE)hList);
}
-static BOOL CALLBACK OpenWithProgrammDlg(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
+static INT_PTR CALLBACK OpenWithProgrammDlg(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPMEASUREITEMSTRUCT lpmis;
LPDRAWITEMSTRUCT lpdis;
FIXME("implement me :)))\n");
}
-int
+HANDLE
OpenMRUList(HKEY hKey)
{
MRUINFO info;
void
AddItemFromMRUList(POPEN_WITH_CONTEXT pContext, HKEY hKey)
{
- int hList;
+ HANDLE hList;
int nItem, nCount, nResult;
WCHAR szBuffer[MAX_PATH];
#define AdminToolsHELLVIEWCOLUMNS (4)
-#define _IPersistFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
+#define _IPersistFolder2_Offset ((INT_PTR)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
#define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder2_Offset);
#define _IUnknown_(This) (IShellFolder*)&(This->lpVtbl)
static const IPersistFolder2Vtbl vt_NP_PersistFolder2;
static const IContextMenu2Vtbl vt_ContextMenu2FontItem;
-#define _IPersistFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
+#define _IPersistFolder2_Offset ((INT_PTR)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
#define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder2_Offset);
-#define _IContextMenuFontItem_Offset ((int)(&(((IGenericSFImpl*)0)->lpVtblContextMenuFontItem)))
+#define _IContextMenuFontItem_Offset ((INT_PTR)(&(((IGenericSFImpl*)0)->lpVtblContextMenuFontItem)))
#define _ICOM_THIS_From_IContextMenu2FontItem(class, name) class* This = (class*)(((char*)name)-_IContextMenuFontItem_Offset);
#define _IUnknown_(This) (IUnknown*)&(This->lpVtbl)
static const IPersistFolder2Vtbl vt_NP_PersistFolder2;
-#define _IPersistFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
+#define _IPersistFolder2_Offset ((INT_PTR)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
#define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder2_Offset);
#define _IUnknown_(This) ((IUnknown*)&(This)->lpVtbl)
LPITEMIDLIST pidl;
} IExtractIconWImpl;
-#define _IExtractIconA_Offset ((int)(&(((IExtractIconWImpl*)0)->lpvtblExtractIconA)))
+#define _IExtractIconA_Offset ((INT_PTR)(&(((IExtractIconWImpl*)0)->lpvtblExtractIconA)))
#define _ICOM_THIS_From_IExtractIconA(class, name) class* This = (class*)(((char*)name)-_IExtractIconA_Offset);
static shvheader PrinterSFHeader[] = {
int dwAttributes; /* attributes returned by GetAttributesOf FIXME: use it */
} IGenericSFImpl;
-#define _IPersistFolder2_Offset ((int)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
+#define _IPersistFolder2_Offset ((INT_PTR)(&(((IGenericSFImpl*)0)->lpVtblPersistFolder2)))
#define _ICOM_THIS_From_IPersistFolder2(class, name) class* This = (class*)(((char*)name)-_IPersistFolder2_Offset);
#define _IUnknown_(This) (IShellFolder*)&(This->lpVtbl)
for ( i = 0; i < DeviceCount; ++ i )
{
- Result = ListSoundDevice(DeviceType, (PVOID) i, &SoundDevice);
+ Result = ListSoundDevice(DeviceType, UlongToPtr(i), &SoundDevice);
if ( ! MMSUCCESS(Result) )
{
WSPAPI
WPUCreateSocketHandle(
IN DWORD dwCatalogEntryId,
- IN DWORD dwContext,
+ IN DWORD_PTR dwContext,
OUT LPINT lpErrno);
int
WPUQueryBlockingCallback(
IN DWORD dwCatalogEntryId,
OUT LPBLOCKINGCALLBACK FAR* lplpfnCallback,
- OUT LPDWORD lpdwContext,
+ OUT PDWORD_PTR lpdwContext,
OUT LPINT lpErrno);
INT
WSPAPI
WPUQuerySocketHandleContext(
IN SOCKET s,
- OUT LPDWORD lpContext,
+ OUT PDWORD_PTR lpContext,
OUT LPINT lpErrno);
INT
WPUQueueApc(
IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
- IN DWORD dwContext,
+ IN DWORD_PTR dwContext,
OUT LPINT lpErrno);
BOOL
#endif
#endif
-#define CALLBACK __stdcall
-
#include "wine/winbase16.h"
#include "windef.h"
#include "winbase.h"
SOCKET
WSPAPI
WPUCreateSocketHandle(IN DWORD dwCatalogEntryId,
- IN DWORD dwContext,
+ IN DWORD_PTR dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
WSPAPI
WPUQueryBlockingCallback(IN DWORD dwCatalogEntryId,
OUT LPBLOCKINGCALLBACK FAR* lplpfnCallback,
- OUT LPDWORD lpdwContext,
+ OUT PDWORD_PTR lpdwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
INT
WSPAPI
WPUQuerySocketHandleContext(IN SOCKET s,
- OUT LPDWORD lpContext,
+ OUT PDWORD_PTR lpContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
WSPAPI
WPUQueueApc(IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
- IN DWORD dwContext,
+ IN DWORD_PTR dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED
500 stub WEP
-@ stdcall GetAddrInfoW(wstr wstr ptr ptr)
+# @ stdcall GetAddrInfoW(wstr wstr ptr ptr)
@ stdcall WSApSetPostRoutine(ptr)
@ stdcall WPUCompleteOverlappedRequest(long ptr long long ptr)
@ stdcall WSAAccept(long ptr ptr ptr long)
SOCKET
WSPAPI
WPUCreateSocketHandle(IN DWORD dwCatalogEntryId,
- IN DWORD dwContext,
+ IN DWORD_PTR dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED;
INT
WSPAPI
WPUQuerySocketHandleContext(IN SOCKET s,
- OUT LPDWORD lpContext,
+ OUT PDWORD_PTR lpContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED;
WSPAPI
WPUQueueApc(IN LPWSATHREADID lpThreadId,
IN LPWSAUSERAPC lpfnUserApc,
- IN DWORD dwContext,
+ IN DWORD_PTR dwContext,
OUT LPINT lpErrno)
{
UNIMPLEMENTED;
DWORD dwFlags;
TCHAR szDesc[256];
TCHAR szDrvname[256];
- DWORD dnDevNode;
+ DWORD_PTR dnDevNode;
WORD wVxdId;
WORD wReserved;
ULONG ulDeviceNum;
GUID Set;
ULONG Id;
ULONG Flags;
- ULONG InstanceId;
+ ULONG_PTR InstanceId;
} DUMMYSTRUCTNAME;
ULONGLONG Alignment;
} DSPROPERTY,*PDSPROPERTY;
typedef INT (WSPAPI *LPWPUCLOSESOCKETHANDLE)(SOCKET,LPINT);
typedef INT (WSPAPI *LPWPUCLOSETHREAD)(LPWSATHREADID,LPINT);
typedef WSAEVENT (WSPAPI *LPWPUCREATEEVENT)(LPINT);
-typedef SOCKET (WSPAPI *LPWPUCREATESOCKETHANDLE)(DWORD,DWORD,LPINT);
+typedef SOCKET (WSPAPI *LPWPUCREATESOCKETHANDLE)(DWORD,DWORD_PTR,LPINT);
typedef INT (WSPAPI *LPWPUFDISSET)(SOCKET,LPFD_SET);
typedef INT (WSPAPI *LPWPUGETPROVIDERPATH)(LPGUID,LPWSTR,LPINT,LPINT);
typedef SOCKET (WSPAPI *LPWPUMODIFYIFSHANDLE)(DWORD,SOCKET,LPINT);
typedef INT (WSPAPI *LPWPUOPENCURRENTTHREAD)(LPWSATHREADID,LPINT);
typedef BOOL (WSPAPI *LPWPUPOSTMESSAGE)(HWND,UINT,WPARAM,LPARAM);
-typedef INT (WSPAPI *LPWPUQUERYBLOCKINGCALLBACK)(DWORD,LPBLOCKINGCALLBACK FAR*,LPDWORD,LPINT);
-typedef INT (WSPAPI *LPWPUQUERYSOCKETHANDLECONTEXT)(SOCKET,LPDWORD,LPINT);
-typedef INT (WSPAPI *LPWPUQUEUEAPC)(LPWSATHREADID,LPWSAUSERAPC,DWORD,LPINT);
+typedef INT (WSPAPI *LPWPUQUERYBLOCKINGCALLBACK)(DWORD,LPBLOCKINGCALLBACK FAR*,PDWORD_PTR,LPINT);
+typedef INT (WSPAPI *LPWPUQUERYSOCKETHANDLECONTEXT)(SOCKET,PDWORD_PTR,LPINT);
+typedef INT (WSPAPI *LPWPUQUEUEAPC)(LPWSATHREADID,LPWSAUSERAPC,DWORD_PTR,LPINT);
typedef BOOL (WSPAPI *LPWPURESETEVENT)(WSAEVENT,LPINT);
typedef BOOL (WSPAPI *LPWPUSETEVENT)(WSAEVENT,LPINT);
typedef INT (WSAAPI *LPNSPSTARTUP)(LPGUID,LPNSP_ROUTINE);