marko10_000
/
wine-wine
forked from Mirrors/wine-wine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move __stdcall/__cdecl to the right place.

oldstable
Patrik Stridvall 2002-01-31 23:22:07 +00:00 committed by Alexandre Julliard
parent d4c0ff155e
commit f94462fb75
50 changed files with 377 additions and 377 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/callback.h
View File

@ -11,20 +11,20 @@
#include "winnt.h"
typedef struct {
void WINAPI (*LoadDosExe)( LPCSTR filename, HANDLE hFile );
void (WINAPI *LoadDosExe)( LPCSTR filename, HANDLE hFile );
/* DPMI functions */
void WINAPI (*CallRMInt)( CONTEXT86 *context );
void WINAPI (*CallRMProc)( CONTEXT86 *context, int iret );
void WINAPI (*AllocRMCB)( CONTEXT86 *context );
void WINAPI (*FreeRMCB)( CONTEXT86 *context );
void (WINAPI *CallRMInt)( CONTEXT86 *context );
void (WINAPI *CallRMProc)( CONTEXT86 *context, int iret );
void (WINAPI *AllocRMCB)( CONTEXT86 *context );
void (WINAPI *FreeRMCB)( CONTEXT86 *context );
/* I/O functions */
void WINAPI (*SetTimer)( unsigned ticks );
unsigned WINAPI (*GetTimer)( void );
BOOL WINAPI (*inport)( int port, int size, DWORD *res );
BOOL WINAPI (*outport)( int port, int size, DWORD val );
void WINAPI (*ASPIHandler)( CONTEXT86 *context );
void (WINAPI *SetTimer)( unsigned ticks );
unsigned (WINAPI *GetTimer)( void );
BOOL (WINAPI *inport)( int port, int size, DWORD *res );
BOOL (WINAPI *outport)( int port, int size, DWORD val );
void (WINAPI *ASPIHandler)( CONTEXT86 *context );
} DOSVM_TABLE;
extern DOSVM_TABLE Dosvm;

12
include/commctrl.h
View File

@ -2197,7 +2197,7 @@ typedef struct tagTVDISPINFOW {
#define LPNMTVDISPINFO WINELIB_NAME_AW(LPNMTVDISPINFO)
#define TV_DISPINFO NMTVDISPINFO
typedef INT CALLBACK (*PFNTVCOMPARE)(LPARAM, LPARAM, LPARAM);
typedef INT (CALLBACK *PFNTVCOMPARE)(LPARAM, LPARAM, LPARAM);
typedef struct tagTVSORTCB
{
@ -2954,7 +2954,7 @@ typedef struct tagTCHITTESTINFO
#define TC_HITTESTINFO TCHITTESTINFO
typedef INT CALLBACK (*PFNLVCOMPARE)(LPARAM, LPARAM, LPARAM);
typedef INT (CALLBACK *PFNLVCOMPARE)(LPARAM, LPARAM, LPARAM);
#define NMLVCUSTOMDRAW_V3_SIZE CCSIZEOF_STRUCT(NMLCUSTOMDRW, clrTextBk)
@ -4020,7 +4020,7 @@ LPVOID WINAPI DSA_GetItemPtr (const HDSA, INT);
INT WINAPI DSA_InsertItem (const HDSA, INT, LPVOID);
BOOL WINAPI DSA_SetItem (const HDSA, INT, LPVOID);
typedef INT CALLBACK (*DSAENUMPROC)(LPVOID, DWORD);
typedef INT (CALLBACK *DSAENUMPROC)(LPVOID, DWORD);
VOID WINAPI DSA_EnumCallback (const HDSA, DSAENUMPROC, LPARAM);
BOOL WINAPI DSA_DestroyCallback (const HDSA, DSAENUMPROC, LPARAM);
@ -4048,7 +4048,7 @@ INT WINAPI DPA_InsertPtr (const HDPA, INT, LPVOID);
LPVOID WINAPI DPA_DeletePtr (const HDPA, INT);
BOOL WINAPI DPA_DeleteAllPtrs (const HDPA);
typedef INT CALLBACK (*PFNDPACOMPARE)(LPVOID, LPVOID, LPARAM);
typedef INT (CALLBACK *PFNDPACOMPARE)(LPVOID, LPVOID, LPARAM);
BOOL WINAPI DPA_Sort (const HDPA, PFNDPACOMPARE, LPARAM);
#define DPAS_SORTED 0x0001
@ -4059,10 +4059,10 @@ INT WINAPI DPA_Search (const HDPA, LPVOID, INT, PFNDPACOMPARE, LPARAM, UINT);
#define DPAM_SORT 0x0001
typedef PVOID CALLBACK (*PFNDPAMERGE)(DWORD,PVOID,PVOID,LPARAM);
typedef PVOID (CALLBACK *PFNDPAMERGE)(DWORD,PVOID,PVOID,LPARAM);
BOOL WINAPI DPA_Merge (const HDPA, const HDPA, DWORD, PFNDPACOMPARE, PFNDPAMERGE, LPARAM);
typedef INT CALLBACK (*DPAENUMPROC)(LPVOID, DWORD);
typedef INT (CALLBACK *DPAENUMPROC)(LPVOID, DWORD);
VOID WINAPI DPA_EnumCallback (const HDPA, DPAENUMPROC, LPARAM);
BOOL WINAPI DPA_DestroyCallback (const HDPA, DPAENUMPROC, LPARAM);

16
include/commdlg.h
View File

@ -50,7 +50,7 @@ extern "C" {
#define SAVE_DIALOG 1
#define OPEN_DIALOG 2
typedef UINT CALLBACK (*LPOFNHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef UINT (CALLBACK *LPOFNHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef struct {
DWORD lStructSize;
@ -118,7 +118,7 @@ typedef struct
DECL_WINELIB_TYPE_AW(OFNOTIFY)
DECL_WINELIB_TYPE_AW(LPOFNOTIFY)
typedef UINT CALLBACK (*LPCCHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef UINT (CALLBACK *LPCCHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef struct {
DWORD lStructSize;
@ -160,7 +160,7 @@ DECL_WINELIB_TYPE_AW(LPCHOOSECOLOR)
#define CC_SOLIDCOLOR 0x00000080
#define CC_ANYCOLOR 0x00000100
typedef UINT CALLBACK (*LPFRHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef UINT (CALLBACK *LPFRHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef struct {
DWORD lStructSize;
@ -211,7 +211,7 @@ DECL_WINELIB_TYPE_AW(LPFINDREPLACE)
#define FR_HIDEMATCHCASE 0x00008000
#define FR_HIDEWHOLEWORD 0x00010000
typedef UINT CALLBACK (*LPCFHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef UINT (CALLBACK *LPCFHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef struct
{
@ -423,8 +423,8 @@ static const WCHAR HELPMSGSTRINGW[] = { 'c','o','m','m','d','l','g','_',
(void)SNDMSG(_hdlg, CDM_SETDEFEXT, 0, (LPARAM)(LPSTR)_pszext)
typedef UINT CALLBACK (*LPPRINTHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef UINT CALLBACK (*LPSETUPHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef UINT (CALLBACK *LPPRINTHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef UINT (CALLBACK *LPSETUPHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef struct tagPDA
{
@ -520,8 +520,8 @@ typedef DEVNAMES * LPDEVNAMES;
#define WM_PSD_ENVSTAMPRECT (WM_USER+5)
#define WM_PSD_YAFULLPAGERECT (WM_USER+6)
typedef UINT CALLBACK (*LPPAGEPAINTHOOK)( HWND, UINT, WPARAM, LPARAM );
typedef UINT CALLBACK (*LPPAGESETUPHOOK)( HWND, UINT, WPARAM, LPARAM );
typedef UINT (CALLBACK *LPPAGEPAINTHOOK)( HWND, UINT, WPARAM, LPARAM );
typedef UINT (CALLBACK *LPPAGESETUPHOOK)( HWND, UINT, WPARAM, LPARAM );
typedef struct tagPSDA
{

4
include/d3dcaps.h
View File

@ -329,8 +329,8 @@ typedef struct _D3DDeviceDesc7 {
#define D3DVTXPCAPS_POSITIONALLIGHTS 0x00000010
#define D3DVTXPCAPS_LOCALVIEWER 0x00000020
typedef HRESULT CALLBACK (*LPD3DENUMDEVICESCALLBACK)(LPGUID lpGuid,LPSTR lpDeviceDescription,LPSTR lpDeviceName,LPD3DDEVICEDESC,LPD3DDEVICEDESC,LPVOID);
typedef HRESULT CALLBACK (*LPD3DENUMDEVICESCALLBACK7)(LPSTR lpDeviceDescription, LPSTR lpDeviceName, LPD3DDEVICEDESC7, LPVOID);
typedef HRESULT (CALLBACK *LPD3DENUMDEVICESCALLBACK)(LPGUID lpGuid,LPSTR lpDeviceDescription,LPSTR lpDeviceName,LPD3DDEVICEDESC,LPD3DDEVICEDESC,LPVOID);
typedef HRESULT (CALLBACK *LPD3DENUMDEVICESCALLBACK7)(LPSTR lpDeviceDescription, LPSTR lpDeviceName, LPD3DDEVICEDESC7, LPVOID);
#define D3DFDS_COLORMODEL 0x00000001
#define D3DFDS_GUID 0x00000002

38
include/d3dhal.h
View File

@ -89,17 +89,17 @@ typedef struct _D3DHAL_TEXTURESWAPDATA *LPD3DHAL_TEXTURESWAPDATA;
typedef struct _D3DHAL_TEXTUREGETSURFDATA *LPD3DHAL_TEXTUREGETSURFDATA;
typedef struct _D3DHAL_GETSTATEDATA *LPD3DHAL_GETSTATEDATA;
typedef DWORD PASCAL (*LPD3DHAL_CONTEXTCREATECB) (LPD3DHAL_CONTEXTCREATEDATA);
typedef DWORD PASCAL (*LPD3DHAL_CONTEXTDESTROYCB) (LPD3DHAL_CONTEXTDESTROYDATA);
typedef DWORD PASCAL (*LPD3DHAL_CONTEXTDESTROYALLCB)(LPD3DHAL_CONTEXTDESTROYALLDATA);
typedef DWORD PASCAL (*LPD3DHAL_SCENECAPTURECB) (LPD3DHAL_SCENECAPTUREDATA);
typedef DWORD PASCAL (*LPD3DHAL_RENDERSTATECB) (LPD3DHAL_RENDERSTATEDATA);
typedef DWORD PASCAL (*LPD3DHAL_RENDERPRIMITIVECB) (LPD3DHAL_RENDERPRIMITIVEDATA);
typedef DWORD PASCAL (*LPD3DHAL_TEXTURECREATECB) (LPD3DHAL_TEXTURECREATEDATA);
typedef DWORD PASCAL (*LPD3DHAL_TEXTUREDESTROYCB) (LPD3DHAL_TEXTUREDESTROYDATA);
typedef DWORD PASCAL (*LPD3DHAL_TEXTURESWAPCB) (LPD3DHAL_TEXTURESWAPDATA);
typedef DWORD PASCAL (*LPD3DHAL_TEXTUREGETSURFCB) (LPD3DHAL_TEXTUREGETSURFDATA);
typedef DWORD PASCAL (*LPD3DHAL_GETSTATECB) (LPD3DHAL_GETSTATEDATA);
typedef DWORD (PASCAL *LPD3DHAL_CONTEXTCREATECB) (LPD3DHAL_CONTEXTCREATEDATA);
typedef DWORD (PASCAL *LPD3DHAL_CONTEXTDESTROYCB) (LPD3DHAL_CONTEXTDESTROYDATA);
typedef DWORD (PASCAL *LPD3DHAL_CONTEXTDESTROYALLCB)(LPD3DHAL_CONTEXTDESTROYALLDATA);
typedef DWORD (PASCAL *LPD3DHAL_SCENECAPTURECB) (LPD3DHAL_SCENECAPTUREDATA);
typedef DWORD (PASCAL *LPD3DHAL_RENDERSTATECB) (LPD3DHAL_RENDERSTATEDATA);
typedef DWORD (PASCAL *LPD3DHAL_RENDERPRIMITIVECB) (LPD3DHAL_RENDERPRIMITIVEDATA);
typedef DWORD (PASCAL *LPD3DHAL_TEXTURECREATECB) (LPD3DHAL_TEXTURECREATEDATA);
typedef DWORD (PASCAL *LPD3DHAL_TEXTUREDESTROYCB) (LPD3DHAL_TEXTUREDESTROYDATA);
typedef DWORD (PASCAL *LPD3DHAL_TEXTURESWAPCB) (LPD3DHAL_TEXTURESWAPDATA);
typedef DWORD (PASCAL *LPD3DHAL_TEXTUREGETSURFCB) (LPD3DHAL_TEXTUREGETSURFDATA);
typedef DWORD (PASCAL *LPD3DHAL_GETSTATECB) (LPD3DHAL_GETSTATEDATA);
typedef struct _D3DHAL_CALLBACKS {
DWORD dwSize;
@ -147,11 +147,11 @@ typedef struct _D3DHAL_DRAWONEPRIMITIVEDATA *LPD3DHAL_DRAWONEPRIMITIVEDATA;
typedef struct _D3DHAL_DRAWONEINDEXEDPRIMITIVEDATA *LPD3DHAL_DRAWONEINDEXEDPRIMITIVEDATA;
typedef struct _D3DHAL_DRAWPRIMITIVESDATA *LPD3DHAL_DRAWPRIMITIVESDATA;
typedef DWORD PASCAL (*LPD3DHAL_SETRENDERTARGETCB) (LPD3DHAL_SETRENDERTARGETDATA);
typedef DWORD PASCAL (*LPD3DHAL_CLEARCB) (LPD3DHAL_CLEARDATA);
typedef DWORD PASCAL (*LPD3DHAL_DRAWONEPRIMITIVECB) (LPD3DHAL_DRAWONEPRIMITIVEDATA);
typedef DWORD PASCAL (*LPD3DHAL_DRAWONEINDEXEDPRIMITIVECB)(LPD3DHAL_DRAWONEINDEXEDPRIMITIVEDATA);
typedef DWORD PASCAL (*LPD3DHAL_DRAWPRIMITIVESCB) (LPD3DHAL_DRAWPRIMITIVESDATA);
typedef DWORD (PASCAL *LPD3DHAL_SETRENDERTARGETCB) (LPD3DHAL_SETRENDERTARGETDATA);
typedef DWORD (PASCAL *LPD3DHAL_CLEARCB) (LPD3DHAL_CLEARDATA);
typedef DWORD (PASCAL *LPD3DHAL_DRAWONEPRIMITIVECB) (LPD3DHAL_DRAWONEPRIMITIVEDATA);
typedef DWORD (PASCAL *LPD3DHAL_DRAWONEINDEXEDPRIMITIVECB)(LPD3DHAL_DRAWONEINDEXEDPRIMITIVEDATA);
typedef DWORD (PASCAL *LPD3DHAL_DRAWPRIMITIVESCB) (LPD3DHAL_DRAWPRIMITIVESDATA);
typedef struct _D3DHAL_CALLBACKS2 {
DWORD dwSize;
@ -167,9 +167,9 @@ typedef struct _D3DHAL_CLEAR2DATA *LPD3DHAL_CLEAR2DATA;
typedef struct _D3DHAL_VALIDATETEXTURESTAGESTATEDATA *LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA;
typedef struct _D3DHAL_DRAWPRIMITIVES2DATA *LPD3DHAL_DRAWPRIMITIVES2DATA;
typedef DWORD PASCAL (*LPD3DHAL_CLEAR2CB) (LPD3DHAL_CLEAR2DATA);
typedef DWORD PASCAL (*LPD3DHAL_VALIDATETEXTURESTAGESTATECB)(LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA);
typedef DWORD PASCAL (*LPD3DHAL_DRAWPRIMITIVES2CB) (LPD3DHAL_DRAWPRIMITIVES2DATA);
typedef DWORD (PASCAL *LPD3DHAL_CLEAR2CB) (LPD3DHAL_CLEAR2DATA);
typedef DWORD (PASCAL *LPD3DHAL_VALIDATETEXTURESTAGESTATECB)(LPD3DHAL_VALIDATETEXTURESTAGESTATEDATA);
typedef DWORD (PASCAL *LPD3DHAL_DRAWPRIMITIVES2CB) (LPD3DHAL_DRAWPRIMITIVES2DATA);
typedef struct _D3DHAL_CALLBACKS3 {
DWORD dwSize;

6
include/d3dtypes.h
View File

@ -55,9 +55,9 @@ typedef LONG D3DFIXED;
#define D3DENUMRET_CANCEL DDENUMRET_CANCEL
#define D3DENUMRET_OK DDENUMRET_OK
typedef HRESULT CALLBACK (*LPD3DVALIDATECALLBACK)(LPVOID lpUserArg, DWORD dwOffset);
typedef HRESULT CALLBACK (*LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC lpDdsd, LPVOID lpContext);
typedef HRESULT CALLBACK (*LPD3DENUMPIXELFORMATSCALLBACK)(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext);
typedef HRESULT (CALLBACK *LPD3DVALIDATECALLBACK)(LPVOID lpUserArg, DWORD dwOffset);
typedef HRESULT (CALLBACK *LPD3DENUMTEXTUREFORMATSCALLBACK)(LPDDSURFACEDESC lpDdsd, LPVOID lpContext);
typedef HRESULT (CALLBACK *LPD3DENUMPIXELFORMATSCALLBACK)(LPDDPIXELFORMAT lpDDPixFmt, LPVOID lpContext);
typedef DWORD D3DCOLOR, *LPD3DCOLOR;

2
include/ddeml.h
View File

@ -265,7 +265,7 @@ DECLARE_HANDLE(HDDEDATA);
*******************************************************/
typedef HDDEDATA CALLBACK (*PFNCALLBACK)(UINT, UINT, HCONV, HSZ, HSZ,
typedef HDDEDATA (CALLBACK *PFNCALLBACK)(UINT, UINT, HCONV, HSZ, HSZ,
HDDEDATA, DWORD, DWORD);
/***************************************************

18
include/ddraw.h
View File

@ -1022,18 +1022,18 @@ typedef struct {
WORD blue[256];
} DDGAMMARAMP,*LPDDGAMMARAMP;
typedef BOOL CALLBACK (*LPDDENUMCALLBACKA)(GUID *, LPSTR, LPSTR, LPVOID);
typedef BOOL CALLBACK (*LPDDENUMCALLBACKW)(GUID *, LPWSTR, LPWSTR, LPVOID);
typedef BOOL (CALLBACK *LPDDENUMCALLBACKA)(GUID *, LPSTR, LPSTR, LPVOID);
typedef BOOL (CALLBACK *LPDDENUMCALLBACKW)(GUID *, LPWSTR, LPWSTR, LPVOID);
DECL_WINELIB_TYPE_AW(LPDDENUMCALLBACK)
typedef HRESULT CALLBACK (*LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);
typedef HRESULT CALLBACK (*LPDDENUMMODESCALLBACK2)(LPDDSURFACEDESC2, LPVOID);
typedef HRESULT CALLBACK (*LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID);
typedef HRESULT CALLBACK (*LPDDENUMSURFACESCALLBACK2)(LPDIRECTDRAWSURFACE4, LPDDSURFACEDESC2, LPVOID);
typedef HRESULT CALLBACK (*LPDDENUMSURFACESCALLBACK7)(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2, LPVOID);
typedef HRESULT (CALLBACK *LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);
typedef HRESULT (CALLBACK *LPDDENUMMODESCALLBACK2)(LPDDSURFACEDESC2, LPVOID);
typedef HRESULT (CALLBACK *LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID);
typedef HRESULT (CALLBACK *LPDDENUMSURFACESCALLBACK2)(LPDIRECTDRAWSURFACE4, LPDDSURFACEDESC2, LPVOID);
typedef HRESULT (CALLBACK *LPDDENUMSURFACESCALLBACK7)(LPDIRECTDRAWSURFACE7, LPDDSURFACEDESC2, LPVOID);
typedef BOOL CALLBACK (*LPDDENUMCALLBACKEXA)(GUID *, LPSTR, LPSTR, LPVOID, HMONITOR);
typedef BOOL CALLBACK (*LPDDENUMCALLBACKEXW)(GUID *, LPWSTR, LPWSTR, LPVOID, HMONITOR);
typedef BOOL (CALLBACK *LPDDENUMCALLBACKEXA)(GUID *, LPSTR, LPSTR, LPVOID, HMONITOR);
typedef BOOL (CALLBACK *LPDDENUMCALLBACKEXW)(GUID *, LPWSTR, LPWSTR, LPVOID, HMONITOR);
DECL_WINELIB_TYPE_AW(LPDDENUMCALLBACKEX)
HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);

78
include/ddrawi.h
View File

@ -47,7 +47,7 @@ typedef struct {
ULONG_PTR dwReserved2;
} DDVERSIONDATA,*LPDDVERSIONDATA;
typedef DWORD PASCAL (*LPDD32BITDRIVERINIT)(DWORD dwContext);
typedef DWORD (PASCAL *LPDD32BITDRIVERINIT)(DWORD dwContext);
/* pointer to video memory */
typedef ULONG_PTR FLATPTR;
@ -277,16 +277,16 @@ typedef struct _DDHAL_GETSCANLINEDATA *LPDDHAL_GETSCANLINEDATA;
typedef struct _DDHAL_SETEXCLUSIVEMODEDATA *LPDDHAL_SETEXCLUSIVEMODEDATA;
typedef struct _DDHAL_FLIPTOGDISURFACEDATA *LPDDHAL_FLIPTOGDISURFACEDATA;
typedef DWORD PASCAL (*LPDDHAL_DESTROYDRIVER) (LPDDHAL_DESTROYDRIVERDATA);
typedef DWORD PASCAL (*LPDDHAL_CREATESURFACE) (LPDDHAL_CREATESURFACEDATA);
typedef DWORD PASCAL (*LPDDHAL_SETCOLORKEY) (LPDDHAL_DRVSETCOLORKEYDATA);
typedef DWORD PASCAL (*LPDDHAL_SETMODE) (LPDDHAL_SETMODEDATA);
typedef DWORD PASCAL (*LPDDHAL_WAITFORVERTICALBLANK)(LPDDHAL_WAITFORVERTICALBLANKDATA);
typedef DWORD PASCAL (*LPDDHAL_CANCREATESURFACE) (LPDDHAL_CANCREATESURFACEDATA );
typedef DWORD PASCAL (*LPDDHAL_CREATEPALETTE) (LPDDHAL_CREATEPALETTEDATA);
typedef DWORD PASCAL (*LPDDHAL_GETSCANLINE) (LPDDHAL_GETSCANLINEDATA);
typedef DWORD PASCAL (*LPDDHAL_SETEXCLUSIVEMODE) (LPDDHAL_SETEXCLUSIVEMODEDATA);
typedef DWORD PASCAL (*LPDDHAL_FLIPTOGDISURFACE) (LPDDHAL_FLIPTOGDISURFACEDATA);
typedef DWORD (PASCAL *LPDDHAL_DESTROYDRIVER) (LPDDHAL_DESTROYDRIVERDATA);
typedef DWORD (PASCAL *LPDDHAL_CREATESURFACE) (LPDDHAL_CREATESURFACEDATA);
typedef DWORD (PASCAL *LPDDHAL_SETCOLORKEY) (LPDDHAL_DRVSETCOLORKEYDATA);
typedef DWORD (PASCAL *LPDDHAL_SETMODE) (LPDDHAL_SETMODEDATA);
typedef DWORD (PASCAL *LPDDHAL_WAITFORVERTICALBLANK)(LPDDHAL_WAITFORVERTICALBLANKDATA);
typedef DWORD (PASCAL *LPDDHAL_CANCREATESURFACE) (LPDDHAL_CANCREATESURFACEDATA );
typedef DWORD (PASCAL *LPDDHAL_CREATEPALETTE) (LPDDHAL_CREATEPALETTEDATA);
typedef DWORD (PASCAL *LPDDHAL_GETSCANLINE) (LPDDHAL_GETSCANLINEDATA);
typedef DWORD (PASCAL *LPDDHAL_SETEXCLUSIVEMODE) (LPDDHAL_SETEXCLUSIVEMODEDATA);
typedef DWORD (PASCAL *LPDDHAL_FLIPTOGDISURFACE) (LPDDHAL_FLIPTOGDISURFACEDATA);
typedef struct _DDHAL_DDCALLBACKS {
DWORD dwSize;
@ -318,19 +318,19 @@ typedef struct _DDHAL_UPDATEOVERLAYDATA *LPDDHAL_UPDATEOVERLAYDATA;
typedef struct _DDHAL_SETOVERLAYPOSITIONDATA *LPDDHAL_SETOVERLAYPOSITIONDATA;
typedef struct _DDHAL_SETPALETTEDATA *LPDDHAL_SETPALETTEDATA;
typedef DWORD PASCAL (*LPDDHALSURFCB_DESTROYSURFACE) (LPDDHAL_DESTROYSURFACEDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_FLIP) (LPDDHAL_FLIPDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_SETCLIPLIST) (LPDDHAL_SETCLIPLISTDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_LOCK) (LPDDHAL_LOCKDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_UNLOCK) (LPDDHAL_UNLOCKDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_BLT) (LPDDHAL_BLTDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_SETCOLORKEY) (LPDDHAL_SETCOLORKEYDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_ADDATTACHEDSURFACE)(LPDDHAL_ADDATTACHEDSURFACEDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_GETBLTSTATUS) (LPDDHAL_GETBLTSTATUSDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_GETFLIPSTATUS) (LPDDHAL_GETFLIPSTATUSDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_UPDATEOVERLAY) (LPDDHAL_UPDATEOVERLAYDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_SETOVERLAYPOSITION)(LPDDHAL_SETOVERLAYPOSITIONDATA);
typedef DWORD PASCAL (*LPDDHALSURFCB_SETPALETTE) (LPDDHAL_SETPALETTEDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_DESTROYSURFACE) (LPDDHAL_DESTROYSURFACEDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_FLIP) (LPDDHAL_FLIPDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_SETCLIPLIST) (LPDDHAL_SETCLIPLISTDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_LOCK) (LPDDHAL_LOCKDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_UNLOCK) (LPDDHAL_UNLOCKDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_BLT) (LPDDHAL_BLTDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_SETCOLORKEY) (LPDDHAL_SETCOLORKEYDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_ADDATTACHEDSURFACE)(LPDDHAL_ADDATTACHEDSURFACEDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_GETBLTSTATUS) (LPDDHAL_GETBLTSTATUSDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_GETFLIPSTATUS) (LPDDHAL_GETFLIPSTATUSDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_UPDATEOVERLAY) (LPDDHAL_UPDATEOVERLAYDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_SETOVERLAYPOSITION)(LPDDHAL_SETOVERLAYPOSITIONDATA);
typedef DWORD (PASCAL *LPDDHALSURFCB_SETPALETTE) (LPDDHAL_SETPALETTEDATA);
typedef struct _DDHAL_DDSURFACECALLBACKS {
DWORD dwSize;
@ -354,8 +354,8 @@ typedef struct _DDHAL_DDSURFACECALLBACKS {
typedef struct _DDHAL_DESTROYPALETTEDATA *LPDDHAL_DESTROYPALETTEDATA;
typedef struct _DDHAL_SETENTRIESDATA *LPDDHAL_SETENTRIESDATA;
typedef DWORD PASCAL (*LPDDHALPALCB_DESTROYPALETTE)(LPDDHAL_DESTROYPALETTEDATA);
typedef DWORD PASCAL (*LPDDHALPALCB_SETENTRIES) (LPDDHAL_SETENTRIESDATA);
typedef DWORD (PASCAL *LPDDHALPALCB_DESTROYPALETTE)(LPDDHAL_DESTROYPALETTEDATA);
typedef DWORD (PASCAL *LPDDHALPALCB_SETENTRIES) (LPDDHAL_SETENTRIESDATA);
typedef struct _DDHAL_DDPALETTECALLBACKS {
DWORD dwSize;
@ -364,11 +364,11 @@ typedef struct _DDHAL_DDPALETTECALLBACKS {
LPDDHALPALCB_SETENTRIES SetEntries;
} DDHAL_DDPALETTECALLBACKS,*LPDDHAL_DDPALETTECALLBACKS;
typedef DWORD PASCAL (*LPDDHALEXEBUFCB_CANCREATEEXEBUF)(LPDDHAL_CANCREATESURFACEDATA);
typedef DWORD PASCAL (*LPDDHALEXEBUFCB_CREATEEXEBUF) (LPDDHAL_CREATESURFACEDATA);
typedef DWORD PASCAL (*LPDDHALEXEBUFCB_DESTROYEXEBUF) (LPDDHAL_DESTROYSURFACEDATA);
typedef DWORD PASCAL (*LPDDHALEXEBUFCB_LOCKEXEBUF) (LPDDHAL_LOCKDATA);
typedef DWORD PASCAL (*LPDDHALEXEBUFCB_UNLOCKEXEBUF) (LPDDHAL_UNLOCKDATA);
typedef DWORD (PASCAL *LPDDHALEXEBUFCB_CANCREATEEXEBUF)(LPDDHAL_CANCREATESURFACEDATA);
typedef DWORD (PASCAL *LPDDHALEXEBUFCB_CREATEEXEBUF) (LPDDHAL_CREATESURFACEDATA);
typedef DWORD (PASCAL *LPDDHALEXEBUFCB_DESTROYEXEBUF) (LPDDHAL_DESTROYSURFACEDATA);
typedef DWORD (PASCAL *LPDDHALEXEBUFCB_LOCKEXEBUF) (LPDDHAL_LOCKDATA);
typedef DWORD (PASCAL *LPDDHALEXEBUFCB_UNLOCKEXEBUF) (LPDDHAL_UNLOCKDATA);
typedef struct _DDHAL_DDEXEBUFCALLBACKS {
DWORD dwSize;
@ -384,9 +384,9 @@ typedef struct _DDHAL_GETAVAILDRIVERMEMORYDATA *LPDDHAL_GETAVAILDRIVERMEMORYDATA
typedef struct _DDHAL_UPDATENONLOCALHEAPDATA *LPDDHAL_UPDATENONLOCALHEAPDATA;
typedef struct _DDHAL_GETHEAPALIGNMENTDATA *LPDDHAL_GETHEAPALIGNMENTDATA;
typedef DWORD PASCAL (*LPDDHAL_GETAVAILDRIVERMEMORY)(LPDDHAL_GETAVAILDRIVERMEMORYDATA);
typedef DWORD PASCAL (*LPDDHAL_UPDATENONLOCALHEAP) (LPDDHAL_UPDATENONLOCALHEAPDATA);
typedef DWORD PASCAL (*LPDDHAL_GETHEAPALIGNMENT) (LPDDHAL_GETHEAPALIGNMENTDATA);
typedef DWORD (PASCAL *LPDDHAL_GETAVAILDRIVERMEMORY)(LPDDHAL_GETAVAILDRIVERMEMORYDATA);
typedef DWORD (PASCAL *LPDDHAL_UPDATENONLOCALHEAP) (LPDDHAL_UPDATENONLOCALHEAPDATA);
typedef DWORD (PASCAL *LPDDHAL_GETHEAPALIGNMENT) (LPDDHAL_GETHEAPALIGNMENTDATA);
typedef struct _DDHAL_DDMISCELLANEOUSCALLBACKS {
DWORD dwSize;
@ -401,9 +401,9 @@ typedef struct _DDHAL_CREATESURFACEEXDATA *LPDDHAL_CREATESURFACEEXDATA;
typedef struct _DDHAL_GETDRIVERSTATEDATA *LPDDHAL_GETDRIVERSTATEDATA;
typedef struct _DDHAL_DESTROYDDLOCALDATA *LPDDHAL_DESTROYDDLOCALDATA;
typedef DWORD PASCAL (*LPDDHAL_CREATESURFACEEX)(LPDDHAL_CREATESURFACEEXDATA);
typedef DWORD PASCAL (*LPDDHAL_GETDRIVERSTATE) (LPDDHAL_GETDRIVERSTATEDATA);
typedef DWORD PASCAL (*LPDDHAL_DESTROYDDLOCAL) (LPDDHAL_DESTROYDDLOCALDATA);
typedef DWORD (PASCAL *LPDDHAL_CREATESURFACEEX)(LPDDHAL_CREATESURFACEEXDATA);
typedef DWORD (PASCAL *LPDDHAL_GETDRIVERSTATE) (LPDDHAL_GETDRIVERSTATEDATA);
typedef DWORD (PASCAL *LPDDHAL_DESTROYDDLOCAL) (LPDDHAL_DESTROYDDLOCALDATA);
typedef struct _DDHAL_DDMISCELLANEOUS2CALLBACKS {
DWORD dwSize;
@ -414,7 +414,7 @@ typedef struct _DDHAL_DDMISCELLANEOUS2CALLBACKS {
LPDDHAL_DESTROYDDLOCAL DestroyDDLocal;
} DDHAL_DDMISCELLANEOUS2CALLBACKS,*LPDDHAL_DDMISCELLANEOUS2CALLBACKS;
typedef HRESULT WINAPI (*LPDDGAMMACALIBRATORPROC)(LPDDGAMMARAMP, LPBYTE);
typedef HRESULT (WINAPI *LPDDGAMMACALIBRATORPROC)(LPDDGAMMARAMP, LPBYTE);
/*****************************************************************************
* driver info structure
@ -422,7 +422,7 @@ typedef HRESULT WINAPI (*LPDDGAMMACALIBRATORPROC)(LPDDGAMMARAMP, LPBYTE);
* The HAL is queried for additional callbacks via the GetDriverInfo callback.
*/
typedef struct _DDHAL_GETDRIVERINFODATA *LPDDHAL_GETDRIVERINFODATA;
typedef DWORD PASCAL (*LPDDHAL_GETDRIVERINFO)(LPDDHAL_GETDRIVERINFODATA);
typedef DWORD (PASCAL *LPDDHAL_GETDRIVERINFO)(LPDDHAL_GETDRIVERINFODATA);
typedef struct _DDHALINFO {
DWORD dwSize;

16
include/dinput.h
View File

@ -252,15 +252,15 @@ DECL_WINELIB_TYPE_AW(DIDEVICEINSTANCE)
DECL_WINELIB_TYPE_AW(LPDIDEVICEINSTANCE)
DECL_WINELIB_TYPE_AW(LPCDIDEVICEINSTANCE)
typedef BOOL CALLBACK (*LPDIENUMDEVICESCALLBACKA)(LPCDIDEVICEINSTANCEA,LPVOID);
typedef BOOL CALLBACK (*LPDIENUMDEVICESCALLBACKW)(LPCDIDEVICEINSTANCEW,LPVOID);
typedef BOOL (CALLBACK *LPDIENUMDEVICESCALLBACKA)(LPCDIDEVICEINSTANCEA,LPVOID);
typedef BOOL (CALLBACK *LPDIENUMDEVICESCALLBACKW)(LPCDIDEVICEINSTANCEW,LPVOID);
DECL_WINELIB_TYPE_AW(LPDIENUMDEVICESCALLBACK)
typedef BOOL CALLBACK (*LPDIENUMDEVICEOBJECTSCALLBACKA)(LPCDIDEVICEOBJECTINSTANCEA, LPVOID);
typedef BOOL CALLBACK (*LPDIENUMDEVICEOBJECTSCALLBACKW)(LPCDIDEVICEOBJECTINSTANCEW,LPVOID);
typedef BOOL (CALLBACK *LPDIENUMDEVICEOBJECTSCALLBACKA)(LPCDIDEVICEOBJECTINSTANCEA, LPVOID);
typedef BOOL (CALLBACK *LPDIENUMDEVICEOBJECTSCALLBACKW)(LPCDIDEVICEOBJECTINSTANCEW,LPVOID);
DECL_WINELIB_TYPE_AW(LPDIENUMDEVICEOBJECTSCALLBACK)
typedef BOOL CALLBACK (*LPDIENUMCREATEDEFFECTOBJECTSCALLBACK)(LPDIRECTINPUTEFFECT, LPVOID);
typedef BOOL (CALLBACK *LPDIENUMCREATEDEFFECTOBJECTSCALLBACK)(LPDIRECTINPUTEFFECT, LPVOID);
#define DIK_ESCAPE 0x01
#define DIK_1 0x02
@ -661,8 +661,8 @@ typedef const DIEFFECTINFOA *LPCDIEFFECTINFOA;
typedef const DIEFFECTINFOW *LPCDIEFFECTINFOW;
typedef const DIEFFECTINFO *LPCDIEFFECTINFO;
typedef BOOL CALLBACK (*LPDIENUMEFFECTSCALLBACKA)(LPCDIEFFECTINFOA, LPVOID);
typedef BOOL CALLBACK (*LPDIENUMEFFECTSCALLBACKW)(LPCDIEFFECTINFOW, LPVOID);
typedef BOOL (CALLBACK *LPDIENUMEFFECTSCALLBACKA)(LPCDIEFFECTINFOA, LPVOID);
typedef BOOL (CALLBACK *LPDIENUMEFFECTSCALLBACKW)(LPCDIEFFECTINFOW, LPVOID);
typedef struct DIEFFESCAPE {
DWORD dwSize;
@ -771,7 +771,7 @@ typedef struct DIFILEEFFECT {
} DIFILEEFFECT, *LPDIFILEEFFECT;
typedef const DIFILEEFFECT *LPCDIFILEEFFECT;
typedef BOOL CALLBACK (*LPDIENUMEFFECTSINFILECALLBACK)(LPCDIFILEEFFECT , LPVOID);
typedef BOOL (CALLBACK *LPDIENUMEFFECTSINFILECALLBACK)(LPCDIFILEEFFECT , LPVOID);
/*****************************************************************************

14
include/dplay.h
View File

@ -337,14 +337,14 @@ typedef const DPCREDENTIALS *LPCDPCREDENTIALS;
typedef BOOL CALLBACK (*LPDPENUMDPCALLBACKW)(
typedef BOOL (CALLBACK *LPDPENUMDPCALLBACKW)(
LPGUID lpguidSP,
LPWSTR lpSPName,
DWORD dwMajorVersion,
DWORD dwMinorVersion,
LPVOID lpContext);
typedef BOOL CALLBACK (*LPDPENUMDPCALLBACKA)(
typedef BOOL (CALLBACK *LPDPENUMDPCALLBACKA)(
LPGUID lpguidSP,
LPSTR lpSPName, /* ptr to str w/ driver description */
DWORD dwMajorVersion, /* Major # of driver spec in lpguidSP */
@ -358,7 +358,7 @@ typedef const GUID *LPCGUID;
typedef const DPNAME *LPCDPNAME;
typedef BOOL CALLBACK (*LPDPENUMCONNECTIONSCALLBACK)(
typedef BOOL (CALLBACK *LPDPENUMCONNECTIONSCALLBACK)(
LPCGUID lpguidSP,
LPVOID lpConnection,
DWORD dwConnectionSize,
@ -366,7 +366,7 @@ typedef BOOL CALLBACK (*LPDPENUMCONNECTIONSCALLBACK)(
DWORD dwFlags,
LPVOID lpContext);
typedef BOOL CALLBACK (*LPDPENUMSESSIONSCALLBACK)(
typedef BOOL (CALLBACK *LPDPENUMSESSIONSCALLBACK)(
LPDPSESSIONDESC lpDPSessionDesc,
LPVOID lpContext,
LPDWORD lpdwTimeOut,
@ -377,21 +377,21 @@ extern HRESULT WINAPI DirectPlayEnumerateA( LPDPENUMDPCALLBACKA, LPVOID );
extern HRESULT WINAPI DirectPlayEnumerateW( LPDPENUMDPCALLBACKW, LPVOID );
extern HRESULT WINAPI DirectPlayCreate( LPGUID lpGUID, LPDIRECTPLAY2 *lplpDP, IUnknown *pUnk);
typedef BOOL CALLBACK (*LPDPENUMPLAYERSCALLBACK)(
typedef BOOL (CALLBACK *LPDPENUMPLAYERSCALLBACK)(
DPID dpId,
LPSTR lpFriendlyName,
LPSTR lpFormalName,
DWORD dwFlags,
LPVOID lpContext );
typedef BOOL CALLBACK (*LPDPENUMPLAYERSCALLBACK2)(
typedef BOOL (CALLBACK *LPDPENUMPLAYERSCALLBACK2)(
DPID dpId,
DWORD dwPlayerType,
LPCDPNAME lpName,
DWORD dwFlags,
LPVOID lpContext );
typedef BOOL CALLBACK (*LPDPENUMSESSIONSCALLBACK2)(
typedef BOOL (CALLBACK *LPDPENUMSESSIONSCALLBACK2)(
LPCDPSESSIONDESC2 lpThisSD,
LPDWORD lpdwTimeOut,
DWORD dwFlags,

6
include/dplobby.h
View File

@ -330,18 +330,18 @@ extern HRESULT WINAPI DirectPlayLobbyCreateA(LPGUID, LPDIRECTPLAYLOBBYA*, IUnkno
typedef BOOL CALLBACK (*LPDPENUMADDRESSCALLBACK)(
typedef BOOL (CALLBACK *LPDPENUMADDRESSCALLBACK)(
REFGUID guidDataType,
DWORD dwDataSize,
LPCVOID lpData,
LPVOID lpContext );
typedef BOOL CALLBACK (*LPDPLENUMADDRESSTYPESCALLBACK)(
typedef BOOL (CALLBACK *LPDPLENUMADDRESSTYPESCALLBACK)(
REFGUID guidDataType,
LPVOID lpContext,
DWORD dwFlags );
typedef BOOL CALLBACK (*LPDPLENUMLOCALAPPLICATIONSCALLBACK)(
typedef BOOL (CALLBACK *LPDPLENUMLOCALAPPLICATIONSCALLBACK)(
LPCDPLAPPINFO lpAppInfo,
LPVOID lpContext,
DWORD dwFlags );

4
include/dsound.h
View File

@ -215,8 +215,8 @@ typedef const GUID *LPCGUID;
typedef LPVOID* LPLPVOID;
typedef BOOL CALLBACK (*LPDSENUMCALLBACKW)(LPGUID,LPWSTR,LPWSTR,LPVOID);
typedef BOOL CALLBACK (*LPDSENUMCALLBACKA)(LPGUID,LPSTR,LPSTR,LPVOID);
typedef BOOL (CALLBACK *LPDSENUMCALLBACKW)(LPGUID,LPWSTR,LPWSTR,LPVOID);
typedef BOOL (CALLBACK *LPDSENUMCALLBACKA)(LPGUID,LPSTR,LPSTR,LPVOID);
extern HRESULT WINAPI DirectSoundCreate(LPCGUID lpGUID,LPDIRECTSOUND * ppDS,IUnknown *pUnkOuter );
extern HRESULT WINAPI DirectSoundEnumerateA(LPDSENUMCALLBACKA, LPVOID);

20
include/imagehlp.h
View File

@ -279,47 +279,47 @@ typedef struct _IMAGEHLP_DUPLICATE_SYMBOL {
* Callbacks
*/
typedef BOOL CALLBACK (*PIMAGEHLP_STATUS_ROUTINE)(
typedef BOOL (CALLBACK *PIMAGEHLP_STATUS_ROUTINE)(
IMAGEHLP_STATUS_REASON Reason, LPSTR ImageName, LPSTR DllName,
ULONG Va, ULONG Parameter
);
typedef BOOL CALLBACK (*PSYM_ENUMMODULES_CALLBACK)(
typedef BOOL (CALLBACK *PSYM_ENUMMODULES_CALLBACK)(
LPSTR ModuleName, ULONG BaseOfDll, PVOID UserContext
);
typedef BOOL CALLBACK (*PSYM_ENUMSYMBOLS_CALLBACK)(
typedef BOOL (CALLBACK *PSYM_ENUMSYMBOLS_CALLBACK)(
LPSTR SymbolName, ULONG SymbolAddress, ULONG SymbolSize,
PVOID UserContext
);
typedef BOOL CALLBACK (*PENUMLOADED_MODULES_CALLBACK)(
typedef BOOL (CALLBACK *PENUMLOADED_MODULES_CALLBACK)(
LPSTR ModuleName, ULONG ModuleBase, ULONG ModuleSize,
PVOID UserContext
);
typedef BOOL CALLBACK (*PSYMBOL_REGISTERED_CALLBACK)(
typedef BOOL (CALLBACK *PSYMBOL_REGISTERED_CALLBACK)(
HANDLE hProcess, ULONG ActionCode, PVOID CallbackData,
PVOID UserContext
);
typedef BOOL CALLBACK (*DIGEST_FUNCTION)(
typedef BOOL (CALLBACK *DIGEST_FUNCTION)(
DIGEST_HANDLE refdata, PBYTE pData, DWORD dwLength
);
typedef BOOL CALLBACK (*PREAD_PROCESS_MEMORY_ROUTINE)(
typedef BOOL (CALLBACK *PREAD_PROCESS_MEMORY_ROUTINE)(
HANDLE hProcess, PCVOID lpBaseAddress, PVOID lpBuffer,
DWORD nSize, PDWORD lpNumberOfBytesRead
);
typedef PVOID CALLBACK (*PFUNCTION_TABLE_ACCESS_ROUTINE)(
typedef PVOID (CALLBACK *PFUNCTION_TABLE_ACCESS_ROUTINE)(
HANDLE hProcess, DWORD AddrBase
);
typedef DWORD CALLBACK (*PGET_MODULE_BASE_ROUTINE)(
typedef DWORD (CALLBACK *PGET_MODULE_BASE_ROUTINE)(
HANDLE hProcess, DWORD ReturnAddress);
typedef DWORD CALLBACK (*PTRANSLATE_ADDRESS_ROUTINE)(
typedef DWORD (CALLBACK *PTRANSLATE_ADDRESS_ROUTINE)(
HANDLE hProcess, HANDLE hThread, PADDRESS lpaddr
);

4
include/imm.h
View File

@ -15,8 +15,8 @@ typedef HANDLE HIMC;
typedef HANDLE HIMCC;
typedef int CALLBACK (*REGISTERWORDENUMPROCA)(LPCSTR, DWORD, LPCSTR, LPVOID);
typedef int CALLBACK (*REGISTERWORDENUMPROCW)(LPCWSTR, DWORD, LPCWSTR, LPVOID);
typedef int (CALLBACK *REGISTERWORDENUMPROCA)(LPCSTR, DWORD, LPCSTR, LPVOID);
typedef int (CALLBACK *REGISTERWORDENUMPROCW)(LPCWSTR, DWORD, LPCWSTR, LPVOID);
typedef struct tagCANDIDATEFORM
{

4
include/miscemu.h
View File

@ -156,7 +156,7 @@ extern UINT DOSMEM_MapLinearToDos(LPVOID); /* linear Wine to DOS */
extern BOOL INSTR_EmulateInstruction( CONTEXT86 *context );
/* msdos/interrupts.c */
typedef void WINAPI (*INTPROC)(CONTEXT86*);
typedef void (WINAPI *INTPROC)(CONTEXT86*);
extern FARPROC16 INT_GetPMHandler( BYTE intnum );
extern void INT_SetPMHandler( BYTE intnum, FARPROC16 handler );
@ -196,7 +196,7 @@ extern void WINAPI INT_Int2aHandler(CONTEXT86*);
extern void WINAPI INT_Int2fHandler(CONTEXT86*);
/* msdos/dpmi.c */
typedef void WINAPI (*RMCBPROC)(CONTEXT86*);
typedef void (WINAPI *RMCBPROC)(CONTEXT86*);
extern void WINAPI INT_Int31Handler(CONTEXT86*);
extern BOOL DPMI_LoadDosSystem(void);
extern FARPROC16 WINAPI DPMI_AllocInternalRMCB(RMCBPROC);

10
include/mmsystem.h
View File

@ -28,7 +28,7 @@ DECLARE_OLD_HANDLE(HMMIO);
#include "pshpack1.h"
typedef LRESULT CALLBACK (*DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
typedef LRESULT (CALLBACK *DRIVERPROC)(DWORD,HDRVR,UINT,LPARAM,LPARAM);
#define MAXWAVEDRIVERS 10
#define MAXMIDIDRIVERS 10
@ -210,7 +210,7 @@ DWORD WINAPI GetDriverFlags(HDRVR hDriver);
#define WINE_GDF_16BIT 0x10000000
#endif
typedef void CALLBACK (*LPDRVCALLBACK) (HDRVR h, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef void (CALLBACK *LPDRVCALLBACK) (HDRVR h, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
#define MM_MICROSOFT 1 /* Microsoft Corp. */
@ -690,7 +690,7 @@ DWORD WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
#define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */
#define TIMERR_STRUCT (TIMERR_BASE+33) /* time struct size */
typedef void CALLBACK (*LPTIMECALLBACK)(UINT uTimerID, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef void (CALLBACK *LPTIMECALLBACK)(UINT uTimerID, UINT uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
#define TIME_ONESHOT 0x0000 /* program timer for single event */
#define TIME_PERIODIC 0x0001 /* program for continuous periodic event */
@ -1249,7 +1249,7 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
#define CFSEPCHAR '+' /* compound file name separator char. */
typedef DWORD FOURCC; /* a four character code */
typedef LRESULT CALLBACK (*LPMMIOPROC) (LPSTR lpmmioinfo, UINT uMessage,
typedef LRESULT (CALLBACK *LPMMIOPROC) (LPSTR lpmmioinfo, UINT uMessage,
LPARAM lParam1, LPARAM lParam2);
typedef struct {
@ -1377,7 +1377,7 @@ MMRESULT WINAPI mmioDescend(HMMIO,MMCKINFO*,const MMCKINFO*,UINT);
MMRESULT WINAPI mmioAscend(HMMIO,MMCKINFO*,UINT);
MMRESULT WINAPI mmioCreateChunk(HMMIO,MMCKINFO*,UINT);
typedef UINT CALLBACK (*YIELDPROC)(MCIDEVICEID,DWORD);
typedef UINT (CALLBACK *YIELDPROC)(MCIDEVICEID,DWORD);
DWORD WINAPI mciSendCommandA(UINT,UINT,DWORD,DWORD);
DWORD WINAPI mciSendCommandW(UINT,UINT,DWORD,DWORD);

26
include/msacm.h
View File

@ -201,24 +201,24 @@ DECLARE_OLD_HANDLE(HACMOBJ);
* Callbacks
*/
typedef BOOL CALLBACK (*ACMDRIVERENUMCB)(
typedef BOOL (CALLBACK *ACMDRIVERENUMCB)(
HACMDRIVERID hadid, DWORD dwInstance, DWORD fdwSupport
);
typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROCA)(
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROCA)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROCW)(
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROCW)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
#define ACMFILTERCHOOSEHOOKPROC WINELIB_NAME_AW(ACMFILTERCHOOSEHOOKPROC)
typedef UINT CALLBACK (*ACMFORMATCHOOSEHOOKPROCA)(
typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROCA)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
typedef UINT CALLBACK (*ACMFORMATCHOOSEHOOKPROCW)(
typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROCW)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
#define ACMFORMATCHOOSEHOOKPROC WINELIB_NAME_AW(ACMFORMATCHOOSEHOOKPROC)
@ -519,48 +519,48 @@ typedef struct _ACMSTREAMHEADER
* Callbacks 2
*/
typedef BOOL CALLBACK (*ACMFILTERENUMCBA)(
typedef BOOL (CALLBACK *ACMFILTERENUMCBA)(
HACMDRIVERID hadid, PACMFILTERDETAILSA pafd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFILTERENUMCBW)(
typedef BOOL (CALLBACK *ACMFILTERENUMCBW)(
HACMDRIVERID hadid, PACMFILTERDETAILSW pafd,
DWORD dwInstance, DWORD fdwSupport
);
#define ACMFILTERENUMCB WINELIB_NAME_AW(ACMFILTERENUMCB)
typedef BOOL CALLBACK (*ACMFILTERTAGENUMCBA)(
typedef BOOL (CALLBACK *ACMFILTERTAGENUMCBA)(
HACMDRIVERID hadid, PACMFILTERTAGDETAILSA paftd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFILTERTAGENUMCBW)(
typedef BOOL (CALLBACK *ACMFILTERTAGENUMCBW)(
HACMDRIVERID hadid, PACMFILTERTAGDETAILSW paftd,
DWORD dwInstance, DWORD fdwSupport
);
#define ACMFILTERTAGENUMCB WINELIB_NAME_AW(ACMFILTERTAGENUMCB)
typedef BOOL CALLBACK (*ACMFORMATENUMCBA)(
typedef BOOL (CALLBACK *ACMFORMATENUMCBA)(
HACMDRIVERID hadid, PACMFORMATDETAILSA pafd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFORMATENUMCBW)(
typedef BOOL (CALLBACK *ACMFORMATENUMCBW)(
HACMDRIVERID hadid, PACMFORMATDETAILSW pafd,
DWORD dwInstance, DWORD fdwSupport
);
#define ACMFORMATENUMCB WINELIB_NAME_AW(ACMFORMATENUMCB)
typedef BOOL CALLBACK (*ACMFORMATTAGENUMCBA)(
typedef BOOL (CALLBACK *ACMFORMATTAGENUMCBA)(
HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFORMATTAGENUMCBW)(
typedef BOOL (CALLBACK *ACMFORMATTAGENUMCBW)(
HACMDRIVERID hadid, PACMFORMATTAGDETAILSW paftd,
DWORD dwInstance, DWORD fdwSupport
);

2
include/netspi.h
View File

@ -124,7 +124,7 @@ typedef struct
} NOTIFYPERFORMANCEA, *LPNOTIFYPERFORMANCEA;
typedef DWORD CALLBACK (*NOTIFYCALLBACK)(LPNOTIFYINFO,LPVOID);
typedef DWORD (CALLBACK *NOTIFYCALLBACK)(LPNOTIFYINFO,LPVOID);
DWORD WINAPI NPSNotifyRegisterA(enum NOTIFYTYPE,NOTIFYCALLBACK);
#define NPSNotifyRegister WINELIB_NAME_AW(NPSNotifyRegister)

108
include/ole.h
View File

@ -164,19 +164,19 @@ typedef struct _OLESERVERDOC* LPOLESERVERDOC;
typedef struct _OLEOBJECT* LPOLEOBJECT;
typedef struct _OLECLIENT* LPOLECLIENT;
typedef struct _OLESERVERDOCVTBL {
OLESTATUS CALLBACK (*Save)(LPOLESERVERDOC);
OLESTATUS CALLBACK (*Close)(LPOLESERVERDOC);
OLESTATUS CALLBACK (*SetHostNames)(LPOLESERVERDOC,LPCOLESTR16,LPCOLESTR16);
OLESTATUS CALLBACK (*SetDocDimensions)(LPOLESERVERDOC,LPRECT16);
OLESTATUS (CALLBACK *Save)(LPOLESERVERDOC);
OLESTATUS (CALLBACK *Close)(LPOLESERVERDOC);
OLESTATUS (CALLBACK *SetHostNames)(LPOLESERVERDOC,LPCOLESTR16,LPCOLESTR16);
OLESTATUS (CALLBACK *SetDocDimensions)(LPOLESERVERDOC,LPRECT16);
#ifdef __WINE__
/* GetObject is a WINELIB_NAME macro so it cannot be used in Wine itself */
OLESTATUS CALLBACK (*pGetObject)(LPOLESERVERDOC,LPCOLESTR16,LPOLEOBJECT*,LPOLECLIENT);
OLESTATUS (CALLBACK *pGetObject)(LPOLESERVERDOC,LPCOLESTR16,LPOLEOBJECT*,LPOLECLIENT);
#else
OLESTATUS CALLBACK (*GetObject)(LPOLESERVERDOC,LPCOLESTR16,LPOLEOBJECT*,LPOLECLIENT);
OLESTATUS (CALLBACK *GetObject)(LPOLESERVERDOC,LPCOLESTR16,LPOLEOBJECT*,LPOLECLIENT);
#endif
OLESTATUS CALLBACK (*Release)(LPOLESERVERDOC);
OLESTATUS CALLBACK (*SetColorScheme)(LPOLESERVERDOC,struct tagLOGPALETTE*);
OLESTATUS CALLBACK (*Execute)(LPOLESERVERDOC,HGLOBAL16);
OLESTATUS (CALLBACK *Release)(LPOLESERVERDOC);
OLESTATUS (CALLBACK *SetColorScheme)(LPOLESERVERDOC,struct tagLOGPALETTE*);
OLESTATUS (CALLBACK *Execute)(LPOLESERVERDOC,HGLOBAL16);
} OLESERVERDOCVTBL;
typedef OLESERVERDOCVTBL* LPOLESERVERDOCVTBL;
typedef struct _OLESERVERDOC {
@ -186,13 +186,13 @@ typedef struct _OLESERVERDOC {
typedef struct _OLESERVER* LPOLESERVER;
typedef struct _OLESERVERVTBL {
OLESTATUS CALLBACK (*Open)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPOLESERVERDOC *);
OLESTATUS CALLBACK (*Create)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPCOLESTR16,LPOLESERVERDOC*);
OLESTATUS CALLBACK (*CreateFromTemplate)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPCOLESTR16,LPCOLESTR16,LPOLESERVERDOC *);
OLESTATUS CALLBACK (*Edit)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPCOLESTR16,LPOLESERVERDOC *);
OLESTATUS CALLBACK (*Exit)(LPOLESERVER);
OLESTATUS CALLBACK (*Release)(LPOLESERVER);
OLESTATUS CALLBACK (*Execute)(LPOLESERVER);
OLESTATUS (CALLBACK *Open)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPOLESERVERDOC *);
OLESTATUS (CALLBACK *Create)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPCOLESTR16,LPOLESERVERDOC*);
OLESTATUS (CALLBACK *CreateFromTemplate)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPCOLESTR16,LPCOLESTR16,LPOLESERVERDOC *);
OLESTATUS (CALLBACK *Edit)(LPOLESERVER,LHSERVERDOC,LPCOLESTR16,LPCOLESTR16,LPOLESERVERDOC *);
OLESTATUS (CALLBACK *Exit)(LPOLESERVER);
OLESTATUS (CALLBACK *Release)(LPOLESERVER);
OLESTATUS (CALLBACK *Execute)(LPOLESERVER);
} OLESERVERVTBL;
typedef OLESERVERVTBL *LPOLESERVERVTBL;
typedef struct _OLESERVER {
@ -200,7 +200,7 @@ typedef struct _OLESERVER {
/* server specific data */
} OLESERVER;
typedef struct _OLECLIENTVTBL {
int CALLBACK (*CallBack)(LPOLECLIENT,OLE_NOTIFICATION,LPOLEOBJECT);
int (CALLBACK *CallBack)(LPOLECLIENT,OLE_NOTIFICATION,LPOLEOBJECT);
} OLECLIENTVTBL;
typedef OLECLIENTVTBL *LPOLECLIENTVTBL;
@ -213,43 +213,43 @@ struct _OLESTREAM;
typedef struct _OLEOBJECTVTBL {
void CALLBACK *(*QueryProtocol)(LPOLEOBJECT,LPCOLESTR16);
OLESTATUS CALLBACK (*Release)(LPOLEOBJECT);
OLESTATUS CALLBACK (*Show)(LPOLEOBJECT,BOOL16);
OLESTATUS CALLBACK (*DoVerb)(LPOLEOBJECT,UINT16,BOOL16,BOOL16);
OLESTATUS CALLBACK (*GetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16 *);
OLESTATUS CALLBACK (*SetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16);
OLESTATUS CALLBACK (*SetTargetDevice)(LPOLEOBJECT,HGLOBAL16);
OLESTATUS CALLBACK (*SetBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS CALLBACK (*EnumFormats)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS CALLBACK (*SetColorScheme)(LPOLEOBJECT,struct tagLOGPALETTE*);
OLESTATUS CALLBACK (*Delete)(LPOLEOBJECT);
OLESTATUS CALLBACK (*SetHostNames)(LPOLEOBJECT,LPCOLESTR16,LPCOLESTR16);
OLESTATUS CALLBACK (*SaveToStream)(LPOLEOBJECT,struct _OLESTREAM*);
OLESTATUS CALLBACK (*Clone)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT *);
OLESTATUS CALLBACK (*CopyFromLink)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT *);
OLESTATUS CALLBACK (*Equal)(LPOLEOBJECT,LPOLEOBJECT);
OLESTATUS CALLBACK (*CopyToClipBoard)(LPOLEOBJECT);
OLESTATUS CALLBACK (*Draw)(LPOLEOBJECT,HDC16,LPRECT16,LPRECT16,HDC16);
OLESTATUS CALLBACK (*Activate)(LPOLEOBJECT,UINT16,BOOL16,BOOL16,HWND16,LPRECT16);
OLESTATUS CALLBACK (*Execute)(LPOLEOBJECT,HGLOBAL16,UINT16);
OLESTATUS CALLBACK (*Close)(LPOLEOBJECT);
OLESTATUS CALLBACK (*Update)(LPOLEOBJECT);
OLESTATUS CALLBACK (*Reconnect)(LPOLEOBJECT);
OLESTATUS CALLBACK (*ObjectConvert)(LPOLEOBJECT,LPCOLESTR16,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT*);
OLESTATUS CALLBACK (*GetLinkUpdateOptions)(LPOLEOBJECT,LPOLEOPT_UPDATE);
OLESTATUS CALLBACK (*SetLinkUpdateOptions)(LPOLEOBJECT,OLEOPT_UPDATE);
OLESTATUS CALLBACK (*Rename)(LPOLEOBJECT,LPCOLESTR16);
OLESTATUS CALLBACK (*QueryName)(LPOLEOBJECT,LPSTR,LPUINT16);
OLESTATUS CALLBACK (*QueryType)(LPOLEOBJECT,LPLONG);
OLESTATUS CALLBACK (*QueryBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS CALLBACK (*QuerySize)(LPOLEOBJECT,LPDWORD);
OLESTATUS CALLBACK (*QueryOpen)(LPOLEOBJECT);
OLESTATUS CALLBACK (*QueryOutOfDate)(LPOLEOBJECT);
OLESTATUS CALLBACK (*QueryReleaseStatus)(LPOLEOBJECT);
OLESTATUS CALLBACK (*QueryReleaseError)(LPOLEOBJECT);
OLE_RELEASE_METHOD CALLBACK (*QueryReleaseMethod)(LPOLEOBJECT);
OLESTATUS CALLBACK (*RequestData)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS CALLBACK (*ObjectLong)(LPOLEOBJECT,UINT16,LPLONG);
OLESTATUS (CALLBACK *Release)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Show)(LPOLEOBJECT,BOOL16);
OLESTATUS (CALLBACK *DoVerb)(LPOLEOBJECT,UINT16,BOOL16,BOOL16);
OLESTATUS (CALLBACK *GetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16 *);
OLESTATUS (CALLBACK *SetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16);
OLESTATUS (CALLBACK *SetTargetDevice)(LPOLEOBJECT,HGLOBAL16);
OLESTATUS (CALLBACK *SetBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS (CALLBACK *EnumFormats)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS (CALLBACK *SetColorScheme)(LPOLEOBJECT,struct tagLOGPALETTE*);
OLESTATUS (CALLBACK *Delete)(LPOLEOBJECT);
OLESTATUS (CALLBACK *SetHostNames)(LPOLEOBJECT,LPCOLESTR16,LPCOLESTR16);
OLESTATUS (CALLBACK *SaveToStream)(LPOLEOBJECT,struct _OLESTREAM*);
OLESTATUS (CALLBACK *Clone)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT *);
OLESTATUS (CALLBACK *CopyFromLink)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT *);
OLESTATUS (CALLBACK *Equal)(LPOLEOBJECT,LPOLEOBJECT);
OLESTATUS (CALLBACK *CopyToClipBoard)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Draw)(LPOLEOBJECT,HDC16,LPRECT16,LPRECT16,HDC16);
OLESTATUS (CALLBACK *Activate)(LPOLEOBJECT,UINT16,BOOL16,BOOL16,HWND16,LPRECT16);
OLESTATUS (CALLBACK *Execute)(LPOLEOBJECT,HGLOBAL16,UINT16);
OLESTATUS (CALLBACK *Close)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Update)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Reconnect)(LPOLEOBJECT);
OLESTATUS (CALLBACK *ObjectConvert)(LPOLEOBJECT,LPCOLESTR16,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT*);
OLESTATUS (CALLBACK *GetLinkUpdateOptions)(LPOLEOBJECT,LPOLEOPT_UPDATE);
OLESTATUS (CALLBACK *SetLinkUpdateOptions)(LPOLEOBJECT,OLEOPT_UPDATE);
OLESTATUS (CALLBACK *Rename)(LPOLEOBJECT,LPCOLESTR16);
OLESTATUS (CALLBACK *QueryName)(LPOLEOBJECT,LPSTR,LPUINT16);
OLESTATUS (CALLBACK *QueryType)(LPOLEOBJECT,LPLONG);
OLESTATUS (CALLBACK *QueryBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS (CALLBACK *QuerySize)(LPOLEOBJECT,LPDWORD);
OLESTATUS (CALLBACK *QueryOpen)(LPOLEOBJECT);
OLESTATUS (CALLBACK *QueryOutOfDate)(LPOLEOBJECT);
OLESTATUS (CALLBACK *QueryReleaseStatus)(LPOLEOBJECT);
OLESTATUS (CALLBACK *QueryReleaseError)(LPOLEOBJECT);
OLE_RELEASE_METHOD (CALLBACK *QueryReleaseMethod)(LPOLEOBJECT);
OLESTATUS (CALLBACK *RequestData)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS (CALLBACK *ObjectLong)(LPOLEOBJECT,UINT16,LPLONG);
} OLEOBJECTVTBL;
typedef OLEOBJECTVTBL* LPOLEOBJECTVTBL;

4
include/ole2.h
View File

@ -122,8 +122,8 @@ BOOL WINAPI IsValidInterface(LPUNKNOWN punk);
typedef struct _OLESTREAM* LPOLESTREAM;
typedef struct _OLESTREAMVTBL {
DWORD CALLBACK (*Get)(LPOLESTREAM,LPSTR,DWORD);
DWORD CALLBACK (*Put)(LPOLESTREAM,LPSTR,DWORD);
DWORD (CALLBACK *Get)(LPOLESTREAM,LPSTR,DWORD);
DWORD (CALLBACK *Put)(LPOLESTREAM,LPSTR,DWORD);
} OLESTREAMVTBL;
typedef OLESTREAMVTBL* LPOLESTREAMVTBL;
typedef struct _OLESTREAM {

2
include/oledlg.h
View File

@ -94,7 +94,7 @@ typedef struct IOleUIObjInfoW IOleUIObjInfoW, *POLEUIOBJINFOW, *LPOLEUIOBJINFOW;
#define OPF_SHOWHELP 0x00000004L
#define OPF_DISABLECONVERT 0x00000008L
typedef UINT CALLBACK (*LPFNOLEUIHOOK)(HWND, UINT, WPARAM, LPARAM);
typedef UINT (CALLBACK *LPFNOLEUIHOOK)(HWND, UINT, WPARAM, LPARAM);
/*****************************************************************************
* INSERT OBJECT DIALOG

10
include/prsht.h
View File

@ -26,11 +26,11 @@ struct _PSP;
typedef struct _PSP *HPROPSHEETPAGE;
typedef UINT CALLBACK (*LPFNPSPCALLBACKA)(HWND, UINT, struct _PROPSHEETPAGEA*);
typedef UINT CALLBACK (*LPFNPSPCALLBACKW)(HWND, UINT, struct _PROPSHEETPAGEW*);
typedef INT CALLBACK (*PFNPROPSHEETCALLBACK)(HWND, UINT, LPARAM);
typedef BOOL CALLBACK (*LPFNADDPROPSHEETPAGE)(HPROPSHEETPAGE, LPARAM);
typedef BOOL CALLBACK (*LPFNADDPROPSHEETPAGES)(LPVOID, LPFNADDPROPSHEETPAGE, LPARAM);
typedef UINT (CALLBACK *LPFNPSPCALLBACKA)(HWND, UINT, struct _PROPSHEETPAGEA*);
typedef UINT (CALLBACK *LPFNPSPCALLBACKW)(HWND, UINT, struct _PROPSHEETPAGEW*);
typedef INT (CALLBACK *PFNPROPSHEETCALLBACK)(HWND, UINT, LPARAM);
typedef BOOL (CALLBACK *LPFNADDPROPSHEETPAGE)(HPROPSHEETPAGE, LPARAM);
typedef BOOL (CALLBACK *LPFNADDPROPSHEETPAGES)(LPVOID, LPFNADDPROPSHEETPAGE, LPARAM);
/*
* Property sheet support (structures)

2
include/richedit.h
View File

@ -136,7 +136,7 @@ static const WCHAR RICHEDIT_CLASS20W[] = { 'R','i','c','h','E','d','i','t','2','
#define EN_ALIGNRTL 0x0711
typedef DWORD CALLBACK(* EDITSTREAMCALLBACK)( DWORD, LPBYTE, LONG, LONG * );
typedef DWORD (CALLBACK * EDITSTREAMCALLBACK)( DWORD, LPBYTE, LONG, LONG * );
/* Rich edit control styles */
#define ES_SAVESEL 0x00008000

4
include/setupapi.h
View File

@ -26,9 +26,9 @@ typedef struct _INFCONTEXT
UINT Line;
} INFCONTEXT, *PINFCONTEXT;
typedef UINT CALLBACK (*PSP_FILE_CALLBACK_A)( PVOID Context, UINT Notification,
typedef UINT (CALLBACK *PSP_FILE_CALLBACK_A)( PVOID Context, UINT Notification,
UINT Param1, UINT Param2 );
typedef UINT CALLBACK (*PSP_FILE_CALLBACK_W)( PVOID Context, UINT Notification,
typedef UINT (CALLBACK *PSP_FILE_CALLBACK_W)( PVOID Context, UINT Notification,
UINT Param1, UINT Param2 );
#define PSP_FILE_CALLBACK WINELIB_NAME_AW(PSP_FILE_CALLBACK_)

4
include/shlobj.h
View File

@ -221,7 +221,7 @@ void WINAPI WinExecErrorW(HWND hwnd,INT error, LPCWSTR lpstrFileName, LPCWSTR lp
/****************************************************************************
* SHBrowseForFolder API
*/
typedef INT CALLBACK (*BFFCALLBACK)(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData);
typedef INT (CALLBACK *BFFCALLBACK)(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData);
typedef struct tagBROWSEINFOA {
HWND hwndOwner;
@ -340,7 +340,7 @@ HRESULT WINAPI SHGetSpecialFolderLocation(HWND hwndOwner, INT nFolder, LPITEMIDL
* Look there for some clues on what to do here.
*/
typedef HRESULT CALLBACK (*SHELLVIEWPROC)(DWORD dwUserParam,LPSHELLFOLDER psf,
typedef HRESULT (CALLBACK *SHELLVIEWPROC)(DWORD dwUserParam,LPSHELLFOLDER psf,
HWND hwnd,UINT uMsg,UINT wParam,LPARAM lParam);
/* NF valid values for the "viewmode" item of the SHELLTEMPLATE*/

2
include/shlwapi.h
View File

@ -700,7 +700,7 @@ typedef struct _DllVersionInfo {
#define DLLVER_PLATFORM_WINDOWS 0x01 /* Win9x */
#define DLLVER_PLATFORM_NT 0x02 /* WinNT */
typedef HRESULT CALLBACK (*DLLGETVERSIONPROC)(DLLVERSIONINFO *);
typedef HRESULT (CALLBACK *DLLGETVERSIONPROC)(DLLVERSIONINFO *);
#ifdef __cplusplus
} /* extern "C" */

4
include/tapi.h
View File

@ -424,7 +424,7 @@ typedef struct linetranslateoutput_tag {
DWORD dwTranslateResults;
} LINETRANSLATEOUTPUT, *LPLINETRANSLATEOUTPUT;
typedef void CALLBACK (*LINECALLBACK)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
typedef void (CALLBACK *LINECALLBACK)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD);
typedef struct _PHONEAPP {
int dummy;
@ -521,7 +521,7 @@ typedef struct phonestatus_tag {
DWORD dwDevSpecificOffset;
} PHONESTATUS, *LPPHONESTATUS;
typedef void CALLBACK (*PHONECALLBACK)(HANDLE, DWORD, DWORD, DWORD, DWORD, DWORD);
typedef void (CALLBACK *PHONECALLBACK)(HANDLE, DWORD, DWORD, DWORD, DWORD, DWORD);
typedef struct varstring_tag {
DWORD dwTotalSize;

2
include/task.h
View File

@ -55,7 +55,7 @@ struct _WSINFO;
struct _NE_MODULE;
/* signal proc typedef */
typedef void CALLBACK (*USERSIGNALPROC)(HANDLE16, UINT16, UINT16,
typedef void (CALLBACK *USERSIGNALPROC)(HANDLE16, UINT16, UINT16,
HINSTANCE16, HQUEUE16);
/* Task database. See 'Windows Internals' p. 226.

10
include/vfw.h
View File

@ -232,8 +232,8 @@ typedef struct {
DWORD dwScale;
DWORD dwOverheadPerFrame;
DWORD dwReserved2;
LONG CALLBACK (*GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
LONG CALLBACK (*PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
LONG (CALLBACK *GetData)(LPARAM lInput,LONG lFrame,LPVOID lpBits,LONG len);
LONG (CALLBACK *PutData)(LPARAM lOutput,LONG lFrame,LPVOID lpBits,LONG len);
} ICCOMPRESSFRAMES;
typedef struct {
@ -246,8 +246,8 @@ typedef struct {
#define ICSTATUS_ERROR 3
#define ICSTATUS_YIELD 4
/* FIXME: some X11 libs define Status as int... */
/* LONG CALLBACK (*zStatus)(LPARAM lParam, UINT message, LONG l); */
LONG CALLBACK (*zStatus)(LPARAM lParam, UINT message, LONG l);
/* LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l); */
LONG (CALLBACK *zStatus)(LPARAM lParam, UINT message, LONG l);
} ICSETSTATUSPROC;
/* Values for wMode of ICOpen() */
@ -663,7 +663,7 @@ inline static LRESULT VFWAPI ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpb
ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0)
inline static LRESULT VFWAPI ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam,
LONG CALLBACK (*fpfnStatus)(LPARAM, UINT, LONG))
LONG (CALLBACK *fpfnStatus)(LPARAM, UINT, LONG))
{
ICSETSTATUSPROC ic;

24
include/winbase.h
View File

@ -20,9 +20,9 @@ extern "C" {
#define WEP_FREE_DLL 0
#define WEP_SYSTEM_EXIT 1
typedef DWORD CALLBACK (*LPTHREAD_START_ROUTINE)(LPVOID);
typedef DWORD (CALLBACK *LPTHREAD_START_ROUTINE)(LPVOID);
typedef VOID WINAPI (*PFIBER_START_ROUTINE)( LPVOID lpFiberParameter );
typedef VOID (WINAPI *PFIBER_START_ROUTINE)( LPVOID lpFiberParameter );
typedef PFIBER_START_ROUTINE LPFIBER_START_ROUTINE;
typedef RTL_CRITICAL_SECTION CRITICAL_SECTION;
@ -448,7 +448,7 @@ typedef struct {
HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED;
typedef VOID CALLBACK (*LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped);
typedef VOID (CALLBACK *LPOVERLAPPED_COMPLETION_ROUTINE)(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped);
/* Process startup information.
*/
@ -648,12 +648,12 @@ typedef struct tagSYSTEM_INFO
WORD wProcessorRevision;
} SYSTEM_INFO, *LPSYSTEM_INFO;
typedef BOOL CALLBACK (*ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG);
typedef BOOL CALLBACK (*ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG);
typedef BOOL CALLBACK (*ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG);
typedef BOOL CALLBACK (*ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG);
typedef BOOL CALLBACK (*ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG);
typedef BOOL CALLBACK (*ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG);
typedef BOOL (CALLBACK *ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG);
typedef BOOL (CALLBACK *ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG);
DECL_WINELIB_TYPE_AW(ENUMRESTYPEPROC)
DECL_WINELIB_TYPE_AW(ENUMRESNAMEPROC)
@ -708,7 +708,7 @@ typedef struct _WIN32_FILE_ATTRIBUTES_DATA {
* This one seems to be a Win32 only definition. It also is defined with
* WINAPI instead of CALLBACK in the windows headers.
*/
typedef DWORD CALLBACK (*LPPROGRESS_ROUTINE)(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER,
typedef DWORD (CALLBACK *LPPROGRESS_ROUTINE)(LARGE_INTEGER, LARGE_INTEGER, LARGE_INTEGER,
LARGE_INTEGER, DWORD, DWORD, HANDLE,
HANDLE, LPVOID);
@ -975,8 +975,8 @@ typedef struct tagCOMMTIMEOUTS {
DWORD WriteTotalTimeoutConstant;
} COMMTIMEOUTS,*LPCOMMTIMEOUTS;
typedef void CALLBACK (*PAPCFUNC)(ULONG_PTR);
typedef void CALLBACK (*PTIMERAPCROUTINE)(LPVOID,DWORD,DWORD);
typedef void (CALLBACK *PAPCFUNC)(ULONG_PTR);
typedef void (CALLBACK *PTIMERAPCROUTINE)(LPVOID,DWORD,DWORD);
typedef enum _COMPUTER_NAME_FORMAT
{

4
include/windef.h
View File

@ -93,8 +93,8 @@ typedef HICON HCURSOR;
/* Callback function pointers types */
typedef INT CALLBACK (*FARPROC)();
typedef INT CALLBACK (*PROC)();
typedef INT (CALLBACK *FARPROC)();
typedef INT (CALLBACK *PROC)();
/* Macros to split words and longs. */

4
include/wine/exception.h
View File

@ -101,8 +101,8 @@
} while (0);
typedef DWORD CALLBACK (*__WINE_FILTER)(PEXCEPTION_POINTERS);
typedef void CALLBACK (*__WINE_FINALLY)(BOOL);
typedef DWORD (CALLBACK *__WINE_FILTER)(PEXCEPTION_POINTERS);
typedef void (CALLBACK *__WINE_FINALLY)(BOOL);
#define WINE_EXCEPTION_FILTER(func) DWORD WINAPI func( EXCEPTION_POINTERS *__eptr )
#define WINE_FINALLY_FUNC(func) void WINAPI func( BOOL __normal )

8
include/wine/mmsystem16.h
View File

@ -60,7 +60,7 @@ HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16);
HDRVR16 WINAPI GetNextDriver16(HDRVR16,DWORD);
BOOL16 WINAPI GetDriverInfo16(HDRVR16,DRIVERINFOSTRUCT16 *);
typedef void CALLBACK (*LPDRVCALLBACK16) (HDRVR16,UINT16,DWORD,DWORD,DWORD);
typedef void (CALLBACK *LPDRVCALLBACK16) (HDRVR16,UINT16,DWORD,DWORD,DWORD);
typedef LPDRVCALLBACK16 LPWAVECALLBACK16;
UINT16 WINAPI mmsystemGetVersion16(void);
@ -200,7 +200,7 @@ typedef struct {
DWORD dwSupport; /* functionality supported by driver */
} AUXCAPS16, *LPAUXCAPS16;
typedef void CALLBACK (*LPTIMECALLBACK16)(UINT16,UINT16,DWORD,DWORD,DWORD);
typedef void (CALLBACK *LPTIMECALLBACK16)(UINT16,UINT16,DWORD,DWORD,DWORD);
typedef struct {
UINT16 wPeriodMin; /* minimum period supported */
@ -330,7 +330,7 @@ typedef struct {
CHAR szName[MIXER_LONG_NAME_CHARS];
} MIXERCONTROLDETAILS_LISTTEXT16,*LPMIXERCONTROLDETAILS_LISTTEXT16;
typedef LRESULT CALLBACK (*LPMMIOPROC16)(LPSTR lpmmioinfo,UINT16 uMessage,
typedef LRESULT (CALLBACK *LPMMIOPROC16)(LPSTR lpmmioinfo,UINT16 uMessage,
LPARAM lParam1,LPARAM lParam2);
typedef struct {
@ -355,7 +355,7 @@ typedef struct {
HMMIO16 hmmio; /* handle to open file */
} MMIOINFO16, *LPMMIOINFO16;
typedef UINT16 CALLBACK (*YIELDPROC16)(UINT16,DWORD);
typedef UINT16 (CALLBACK *YIELDPROC16)(UINT16,DWORD);
UINT16 WINAPI auxGetNumDevs16(void);
UINT16 WINAPI auxGetDevCaps16 (UINT16,LPAUXCAPS16,UINT16);

108
include/wine/obj_base.h
View File

@ -442,114 +442,114 @@ INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax);
/* C interface */
#define ICOM_METHOD(ret,xfn) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me);
#define ICOM_METHOD1(ret,xfn,ta,na) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a);
#define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b);
#define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
#define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
#define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
#define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
#define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
#define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
#define ICOM_METHOD9(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
#define ICOM_METHOD10(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
#define ICOM_METHOD11(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
#define ICOM_METHOD12(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l);
#define ICOM_METHOD13(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m);
#define ICOM_METHOD14(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n);
#define ICOM_METHOD15(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o);
#define ICOM_METHOD16(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p);
#define ICOM_METHOD17(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q);
#define ICOM_METHOD18(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r);
#define ICOM_METHOD19(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s);
#define ICOM_METHOD20(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t);
#define ICOM_METHOD21(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u);
#define ICOM_METHOD22(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v);
#define ICOM_METHOD23(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w);
#define ICOM_METHOD24(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw,tx,nx) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x);
#define ICOM_METHOD25(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw,tx,nx,ty,ny) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y);
#define ICOM_METHOD26(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw,tx,nx,ty,ny,tz,nz) \
ret CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y,tz z);
ret (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y,tz z);
#define ICOM_VMETHOD(xfn) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me);
void (CALLBACK *xfn)(ICOM_INTERFACE* me);
#define ICOM_VMETHOD1(xfn,ta,na) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a);
#define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b);
#define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
#define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
#define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
#define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
#define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
#define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,nh) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
#define ICOM_VMETHOD9(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ni) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i);
#define ICOM_VMETHOD10(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,nj) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j);
#define ICOM_VMETHOD11(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,nk) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k);
#define ICOM_VMETHOD12(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l);
#define ICOM_VMETHOD13(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m);
#define ICOM_VMETHOD14(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n);
#define ICOM_VMETHOD15(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o);
#define ICOM_VMETHOD16(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p);
#define ICOM_VMETHOD17(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q);
#define ICOM_VMETHOD18(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r);
#define ICOM_VMETHOD19(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s);
#define ICOM_VMETHOD20(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t);
#define ICOM_VMETHOD21(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u);
#define ICOM_VMETHOD22(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v);
#define ICOM_VMETHOD23(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w);
#define ICOM_VMETHOD24(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw,tx,nx) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x);
#define ICOM_VMETHOD25(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw,tx,nx,ty,ny) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y);
#define ICOM_VMETHOD26(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni,tj,nj,tk,nk,tl,nl,tm,nm,tn,nn,to,no,tp,np,tq,nq,tr,nr,ts,ns,tt,nt,tu,nu,tv,nv,tw,nw,tx,nx,ty,ny,tz,nz) \
void CALLBACK (*xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y,tz z);
void (CALLBACK *xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j,tk k,tl l,tm m,tn n,to o,tp p,tq q,tr r,ts s,tt t,tu u,tv v,tw w,tx x,ty y,tz z);
#define ICOM_VTABLE(iface) iface##Vtbl

2
include/wine/obj_oleaut.h
View File

@ -234,7 +234,7 @@ typedef struct tagEXCEPINFO
BSTR bstrHelpFile;
DWORD dwHelpContext;
PVOID pvReserved;
HRESULT __stdcall (*pfnDeferredFillIn)(struct tagEXCEPINFO *);
HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *);
SCODE scode;
} EXCEPINFO, * LPEXCEPINFO;

2
include/wine/obj_oleview.h
View File

@ -30,7 +30,7 @@ typedef struct IViewObject2 IViewObject2, *LPVIEWOBJECT2;
/*****************************************************************************
* IViewObject interface
*/
typedef BOOL CALLBACK (*IVO_ContCallback)(DWORD);
typedef BOOL (CALLBACK *IVO_ContCallback)(DWORD);
#define ICOM_INTERFACE IViewObject
#define IViewObject_METHODS \

22
include/wine/windef16.h
View File

@ -117,16 +117,16 @@ typedef struct
/* Callback function pointers types */
typedef LRESULT CALLBACK (*DRIVERPROC16)(DWORD,HDRVR16,UINT16,LPARAM,LPARAM);
typedef BOOL16 CALLBACK (*DLGPROC16)(HWND16,UINT16,WPARAM16,LPARAM);
typedef INT16 CALLBACK (*EDITWORDBREAKPROC16)(LPSTR,INT16,INT16,INT16);
typedef LRESULT CALLBACK (*FARPROC16)();
typedef INT16 CALLBACK (*PROC16)();
typedef BOOL16 CALLBACK (*GRAYSTRINGPROC16)(HDC16,LPARAM,INT16);
typedef LRESULT CALLBACK (*HOOKPROC16)(INT16,WPARAM16,LPARAM);
typedef BOOL16 CALLBACK (*PROPENUMPROC16)(HWND16,SEGPTR,HANDLE16);
typedef VOID CALLBACK (*TIMERPROC16)(HWND16,UINT16,UINT16,DWORD);
typedef LRESULT CALLBACK (*WNDENUMPROC16)(HWND16,LPARAM);
typedef LRESULT CALLBACK (*WNDPROC16)(HWND16,UINT16,WPARAM16,LPARAM);
typedef LRESULT (CALLBACK *DRIVERPROC16)(DWORD,HDRVR16,UINT16,LPARAM,LPARAM);
typedef BOOL16 (CALLBACK *DLGPROC16)(HWND16,UINT16,WPARAM16,LPARAM);
typedef INT16 (CALLBACK *EDITWORDBREAKPROC16)(LPSTR,INT16,INT16,INT16);
typedef LRESULT (CALLBACK *FARPROC16)();
typedef INT16 (CALLBACK *PROC16)();
typedef BOOL16 (CALLBACK *GRAYSTRINGPROC16)(HDC16,LPARAM,INT16);
typedef LRESULT (CALLBACK *HOOKPROC16)(INT16,WPARAM16,LPARAM);
typedef BOOL16 (CALLBACK *PROPENUMPROC16)(HWND16,SEGPTR,HANDLE16);
typedef VOID (CALLBACK *TIMERPROC16)(HWND16,UINT16,UINT16,DWORD);
typedef LRESULT (CALLBACK *WNDENUMPROC16)(HWND16,LPARAM);
typedef LRESULT (CALLBACK *WNDPROC16)(HWND16,UINT16,WPARAM16,LPARAM);
#endif /* __WINE_WINDEF16_H */

14
include/wine/wingdi16.h
View File

@ -216,11 +216,11 @@ typedef struct
FONTSIGNATURE ntmFontSig;
} NEWTEXTMETRICEX16,*LPNEWTEXTMETRICEX16;
typedef BOOL16 CALLBACK (*DCHOOKPROC)(HDC16,WORD,DWORD,LPARAM);
typedef INT16 CALLBACK (*FONTENUMPROC16)(SEGPTR,SEGPTR,UINT16,LPARAM);
typedef INT16 CALLBACK (*FONTENUMPROCEX16)(SEGPTR,SEGPTR,UINT16,LPARAM);
typedef VOID CALLBACK (*LINEDDAPROC16)(INT16,INT16,LPARAM);
typedef INT16 CALLBACK (*GOBJENUMPROC16)(SEGPTR,LPARAM);
typedef BOOL16 (CALLBACK *DCHOOKPROC)(HDC16,WORD,DWORD,LPARAM);
typedef INT16 (CALLBACK *FONTENUMPROC16)(SEGPTR,SEGPTR,UINT16,LPARAM);
typedef INT16 (CALLBACK *FONTENUMPROCEX16)(SEGPTR,SEGPTR,UINT16,LPARAM);
typedef VOID (CALLBACK *LINEDDAPROC16)(INT16,INT16,LPARAM);
typedef INT16 (CALLBACK *GOBJENUMPROC16)(SEGPTR,LPARAM);
typedef struct
@ -288,7 +288,7 @@ typedef struct {
} EMRPOLYPOLYLINE16, *PEMRPOLYPOLYLINE16,
EMRPOLYPOLYGON16, *PEMRPOLYPOLYGON16;
typedef INT16 CALLBACK (*MFENUMPROC16)(HDC16,HANDLETABLE16*,METARECORD*,
typedef INT16 (CALLBACK *MFENUMPROC16)(HDC16,HANDLETABLE16*,METARECORD*,
INT16,LPARAM);
typedef struct
{
@ -299,7 +299,7 @@ typedef struct
DWORD fwType;
} DOCINFO16, *LPDOCINFO16;
typedef BOOL16 CALLBACK (*ABORTPROC16)(HDC16, INT16);
typedef BOOL16 (CALLBACK *ABORTPROC16)(HDC16, INT16);
#define INT_PD_DEFAULT_DEVMODE 1
#define INT_PD_DEFAULT_MODEL 2

2
include/wine/winuser16.h
View File

@ -171,7 +171,7 @@ typedef struct {
} MENUITEMINFO16, *LPMENUITEMINFO16;
/* DrawState defines ... */
typedef BOOL16 CALLBACK (*DRAWSTATEPROC16)(HDC16,LPARAM,WPARAM16,INT16,INT16);
typedef BOOL16 (CALLBACK *DRAWSTATEPROC16)(HDC16,LPARAM,WPARAM16,INT16,INT16);
/* Listbox messages */
#define LB_ADDSTRING16 (WM_USER+1)

18
include/wingdi.h
View File

@ -1148,9 +1148,9 @@ typedef struct
DECL_WINELIB_TYPE_AW(NEWTEXTMETRICEX)
DECL_WINELIB_TYPE_AW(LPNEWTEXTMETRICEX)
typedef int CALLBACK (*OLDFONTENUMPROCA)(const LOGFONTA*,const TEXTMETRICA*,
typedef int (CALLBACK *OLDFONTENUMPROCA)(const LOGFONTA*,const TEXTMETRICA*,
DWORD,LPARAM);
typedef int CALLBACK (*OLDFONTENUMPROCW)(const LOGFONTW*,const TEXTMETRICW*,
typedef int (CALLBACK *OLDFONTENUMPROCW)(const LOGFONTW*,const TEXTMETRICW*,
DWORD,LPARAM);
DECL_WINELIB_TYPE_AW(OLDFONTENUMPROC)
@ -1158,12 +1158,12 @@ typedef OLDFONTENUMPROCA FONTENUMPROCA;
typedef OLDFONTENUMPROCW FONTENUMPROCW;
DECL_WINELIB_TYPE_AW(FONTENUMPROC)
typedef int CALLBACK (*FONTENUMPROCEXA)(LPENUMLOGFONTEXA,LPNEWTEXTMETRICEXA,DWORD,LPARAM);
typedef int CALLBACK (*FONTENUMPROCEXW)(LPENUMLOGFONTEXW,LPNEWTEXTMETRICEXW,DWORD,LPARAM);
typedef int (CALLBACK *FONTENUMPROCEXA)(LPENUMLOGFONTEXA,LPNEWTEXTMETRICEXA,DWORD,LPARAM);
typedef int (CALLBACK *FONTENUMPROCEXW)(LPENUMLOGFONTEXW,LPNEWTEXTMETRICEXW,DWORD,LPARAM);
DECL_WINELIB_TYPE_AW(FONTENUMPROCEX)
typedef INT CALLBACK (*GOBJENUMPROC)(LPVOID,LPARAM);
typedef VOID CALLBACK (*LINEDDAPROC)(INT,INT,LPARAM);
typedef INT (CALLBACK *GOBJENUMPROC)(LPVOID,LPARAM);
typedef VOID (CALLBACK *LINEDDAPROC)(INT,INT,LPARAM);
/* tmPitchAndFamily bits */
#define TMPF_FIXED_PITCH 1 /* means variable pitch */
@ -1902,7 +1902,7 @@ typedef struct
#define META_CREATEREGION 0x06FF
#define META_UNKNOWN 0x0529 /* FIXME: unknown meta magic */
typedef INT CALLBACK (*MFENUMPROC)(HDC,HANDLETABLE*,METARECORD*,
typedef INT (CALLBACK *MFENUMPROC)(HDC,HANDLETABLE*,METARECORD*,
INT,LPARAM);
/* enhanced metafile structures and functions */
@ -2471,7 +2471,7 @@ typedef struct {
BYTE Data[1];
} EMRGLSBOUNDEDRECORD, *PEMRGLSBOUNDEDRECORD;
typedef INT CALLBACK (*ENHMFENUMPROC)(HDC, LPHANDLETABLE,
typedef INT (CALLBACK *ENHMFENUMPROC)(HDC, LPHANDLETABLE,
LPENHMETARECORD, INT, LPVOID);
#define EMR_HEADER 1
@ -2954,7 +2954,7 @@ typedef struct _RGNDATA {
char Buffer[1];
} RGNDATA,*PRGNDATA,*LPRGNDATA;
typedef BOOL CALLBACK (*ABORTPROC)(HDC, INT);
typedef BOOL (CALLBACK *ABORTPROC)(HDC, INT);
typedef struct {
DWORD cb;

10
include/wininet.h
View File

@ -475,7 +475,7 @@ BOOLAPI InternetGetLastResponseInfoA(LPDWORD ,LPSTR lpszBuffer ,LPDWORD);
BOOLAPI InternetGetLastResponseInfoW(LPDWORD ,LPWSTR lpszBuffer ,LPDWORD);
#define InternetGetLastResponseInfo WINELIB_NAME_AW(InternetGetLastResponseInfo)
typedef VOID CALLBACK (*INTERNET_STATUS_CALLBACK)(HINTERNET ,DWORD ,DWORD ,
typedef VOID (CALLBACK *INTERNET_STATUS_CALLBACK)(HINTERNET ,DWORD ,DWORD ,
LPVOID lpvStatusInformation ,DWORD);
typedef INTERNET_STATUS_CALLBACK * LPINTERNET_STATUS_CALLBACK;
@ -926,8 +926,8 @@ INTERNETAPI HINTERNET WINAPI GopherOpenFileA(HINTERNET ,LPCSTR ,LPCSTR lpszView
INTERNETAPI HINTERNET WINAPI GopherOpenFileW(HINTERNET ,LPCWSTR ,LPCWSTR lpszView ,DWORD ,DWORD);
#define GopherOpenFile WINELIB_NAME_AW(GopherOpenFile)
typedef BOOL CALLBACK (*GOPHER_ATTRIBUTE_ENUMERATORA)(LPGOPHER_ATTRIBUTE_TYPEA ,DWORD);
typedef BOOL CALLBACK (*GOPHER_ATTRIBUTE_ENUMERATORW)(LPGOPHER_ATTRIBUTE_TYPEW ,DWORD);
typedef BOOL (CALLBACK *GOPHER_ATTRIBUTE_ENUMERATORA)(LPGOPHER_ATTRIBUTE_TYPEA ,DWORD);
typedef BOOL (CALLBACK *GOPHER_ATTRIBUTE_ENUMERATORW)(LPGOPHER_ATTRIBUTE_TYPEW ,DWORD);
DECL_WINELIB_TYPE_AW(GOPHER_ATTRIBUTE_ENUMERATOR)
@ -1129,7 +1129,7 @@ BOOLAPI InternetCheckConnectionW(LPCWSTR ,DWORD ,DWORD);
#define FLAGS_ERROR_UI_SERIALIZE_DIALOGS 0x10
DWORD InternetAuthNotifyCallback ( DWORD ,DWORD ,LPVOID );
typedef DWORD CALLBACK (*PFN_AUTH_NOTIFY) (DWORD,DWORD,LPVOID);
typedef DWORD (CALLBACK *PFN_AUTH_NOTIFY) (DWORD,DWORD,LPVOID);
typedef struct
{
@ -1407,7 +1407,7 @@ INTERNETAPI BOOL WINAPI InternetGetConnectedState(LPDWORD ,DWORD);
#define INTERNET_CONNECTION_PROXY 4
#define INTERNET_CONNECTION_MODEM_BUSY 8
typedef DWORD CALLBACK (*PFN_DIAL_HANDLER) (HWND,LPCSTR,DWORD,LPDWORD);
typedef DWORD (CALLBACK *PFN_DIAL_HANDLER) (HWND,LPCSTR,DWORD,LPDWORD);
#define INTERNET_CUSTOMDIAL_CONNECT 0
#define INTERNET_CUSTOMDIAL_UNATTENDED 1

2
include/winnetwk.h
View File

@ -368,7 +368,7 @@ typedef struct tagPASSWORD_CACHE_ENTRY
BYTE abResource[1];
} PASSWORD_CACHE_ENTRY;
typedef BOOL CALLBACK (*ENUMPASSWORDPROC)(PASSWORD_CACHE_ENTRY *, DWORD);
typedef BOOL (CALLBACK *ENUMPASSWORDPROC)(PASSWORD_CACHE_ENTRY *, DWORD);
UINT WINAPI WNetEnumCachedPasswords( LPSTR, WORD, BYTE, ENUMPASSWORDPROC, DWORD);
#endif /* _WINNETWK_H_ */

28
include/winnls.h
View File

@ -396,20 +396,20 @@ DECL_WINELIB_TYPE_AW(LPCURRENCYFMT)
/* Define a bunch of callback types */
#if defined(STRICT) || defined(__WINE__)
typedef BOOL CALLBACK (*CALINFO_ENUMPROCA)(LPSTR);
typedef BOOL CALLBACK (*CALINFO_ENUMPROCW)(LPWSTR);
typedef BOOL CALLBACK (*CALINFO_ENUMPROCEXA)(LPSTR,CALID);
typedef BOOL CALLBACK (*CALINFO_ENUMPROCEXW)(LPWSTR,CALID);
typedef BOOL CALLBACK (*CODEPAGE_ENUMPROCA)(LPSTR);
typedef BOOL CALLBACK (*CODEPAGE_ENUMPROCW)(LPWSTR);
typedef BOOL CALLBACK (*DATEFMT_ENUMPROCA)(LPSTR);
typedef BOOL CALLBACK (*DATEFMT_ENUMPROCW)(LPWSTR);
typedef BOOL CALLBACK (*DATEFMT_ENUMPROCEXA)(LPSTR,CALID);
typedef BOOL CALLBACK (*DATEFMT_ENUMPROCEXW)(LPWSTR,CALID);
typedef BOOL CALLBACK (*LOCALE_ENUMPROCA)(LPSTR);
typedef BOOL CALLBACK (*LOCALE_ENUMPROCW)(LPWSTR);
typedef BOOL CALLBACK (*TIMEFMT_ENUMPROCA)(LPSTR);
typedef BOOL CALLBACK (*TIMEFMT_ENUMPROCW)(LPWSTR);
typedef BOOL (CALLBACK *CALINFO_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *CALINFO_ENUMPROCW)(LPWSTR);
typedef BOOL (CALLBACK *CALINFO_ENUMPROCEXA)(LPSTR,CALID);
typedef BOOL (CALLBACK *CALINFO_ENUMPROCEXW)(LPWSTR,CALID);
typedef BOOL (CALLBACK *CODEPAGE_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *CODEPAGE_ENUMPROCW)(LPWSTR);
typedef BOOL (CALLBACK *DATEFMT_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *DATEFMT_ENUMPROCW)(LPWSTR);
typedef BOOL (CALLBACK *DATEFMT_ENUMPROCEXA)(LPSTR,CALID);
typedef BOOL (CALLBACK *DATEFMT_ENUMPROCEXW)(LPWSTR,CALID);
typedef BOOL (CALLBACK *LOCALE_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *LOCALE_ENUMPROCW)(LPWSTR);
typedef BOOL (CALLBACK *TIMEFMT_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *TIMEFMT_ENUMPROCW)(LPWSTR);
#else
typedef FARPROC CALINFO_ENUMPROCA;
typedef FARPROC CALINFO_ENUMPROCW;

4
include/winnt.h
View File

@ -2301,7 +2301,7 @@ typedef struct __EXCEPTION_FRAME
* function pointer to a exception filter
*/
typedef LONG CALLBACK (*PTOP_LEVEL_EXCEPTION_FILTER)(PEXCEPTION_POINTERS ExceptionInfo);
typedef LONG (CALLBACK *PTOP_LEVEL_EXCEPTION_FILTER)(PEXCEPTION_POINTERS ExceptionInfo);
typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
DWORD WINAPI UnhandledExceptionFilter( PEXCEPTION_POINTERS epointers );
@ -3188,7 +3188,7 @@ typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
} IMAGE_RESOURCE_DATA_ENTRY,*PIMAGE_RESOURCE_DATA_ENTRY;
typedef VOID CALLBACK (*PIMAGE_TLS_CALLBACK)(
typedef VOID (CALLBACK *PIMAGE_TLS_CALLBACK)(
LPVOID DllHandle,DWORD Reason,LPVOID Reserved
);

4
include/winsock2.h
View File

@ -249,7 +249,7 @@ typedef struct _QUALITYOFSERVICE {
WSABUF ProviderSpecific;
} QOS, *LPQOS;
typedef int CALLBACK (*LPCONDITIONPROC)
typedef int (CALLBACK *LPCONDITIONPROC)
(
LPWSABUF lpCallerId,
LPWSABUF lpCallerData,
@ -261,7 +261,7 @@ typedef int CALLBACK (*LPCONDITIONPROC)
DWORD dwCallbackData
);
typedef void CALLBACK (*LPWSAOVERLAPPED_COMPLETION_ROUTINE)
typedef void (CALLBACK *LPWSAOVERLAPPED_COMPLETION_ROUTINE)
(
DWORD dwError,
DWORD cbTransferred,

6
include/winsvc.h
View File

@ -98,8 +98,8 @@ typedef struct _SERVICE_STATUS {
/* Service main function prototype */
typedef VOID CALLBACK (*LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR*);
typedef VOID CALLBACK (*LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR*);
typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR*);
typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR*);
DECL_WINELIB_TYPE_AW(LPSERVICE_MAIN_FUNCTION)
/* Service start table */
@ -136,7 +136,7 @@ DECL_WINELIB_TYPE_AW(LPENUM_SERVICE_STATUS)
/* Service control handler function prototype */
typedef VOID WINAPI (*LPHANDLER_FUNCTION)(DWORD);
typedef VOID (WINAPI *LPHANDLER_FUNCTION)(DWORD);
/* API function prototypes */

36
include/winuser.h
View File

@ -12,21 +12,21 @@ extern "C" {
/* Define a bunch of callback types */
#if defined(STRICT) || defined(__WINE__)
typedef BOOL CALLBACK (*DLGPROC)(HWND,UINT,WPARAM,LPARAM);
typedef BOOL CALLBACK (*DRAWSTATEPROC)(HDC,LPARAM,WPARAM,int,int);
typedef INT CALLBACK (*EDITWORDBREAKPROCA)(LPSTR,INT,INT,INT);
typedef INT CALLBACK (*EDITWORDBREAKPROCW)(LPWSTR,INT,INT,INT);
typedef BOOL CALLBACK (*GRAYSTRINGPROC)(HDC,LPARAM,INT);
typedef LRESULT CALLBACK (*HOOKPROC)(INT,WPARAM,LPARAM);
typedef BOOL CALLBACK (*NAMEENUMPROCA)(LPSTR,LPARAM);
typedef BOOL CALLBACK (*NAMEENUMPROCW)(LPWSTR,LPARAM);
typedef BOOL CALLBACK (*PROPENUMPROCA)(HWND,LPCSTR,HANDLE);
typedef BOOL CALLBACK (*PROPENUMPROCW)(HWND,LPCWSTR,HANDLE);
typedef BOOL CALLBACK (*PROPENUMPROCEXA)(HWND,LPCSTR,HANDLE,ULONG_PTR);
typedef BOOL CALLBACK (*PROPENUMPROCEXW)(HWND,LPCWSTR,HANDLE,ULONG_PTR);
typedef VOID CALLBACK (*SENDASYNCPROC)(HWND,UINT,ULONG_PTR,LRESULT);
typedef VOID CALLBACK (*TIMERPROC)(HWND,UINT,UINT,DWORD);
typedef BOOL CALLBACK (*WNDENUMPROC)(HWND,LPARAM);
typedef BOOL (CALLBACK *DLGPROC)(HWND,UINT,WPARAM,LPARAM);
typedef BOOL (CALLBACK *DRAWSTATEPROC)(HDC,LPARAM,WPARAM,int,int);
typedef INT (CALLBACK *EDITWORDBREAKPROCA)(LPSTR,INT,INT,INT);
typedef INT (CALLBACK *EDITWORDBREAKPROCW)(LPWSTR,INT,INT,INT);
typedef BOOL (CALLBACK *GRAYSTRINGPROC)(HDC,LPARAM,INT);
typedef LRESULT (CALLBACK *HOOKPROC)(INT,WPARAM,LPARAM);
typedef BOOL (CALLBACK *NAMEENUMPROCA)(LPSTR,LPARAM);
typedef BOOL (CALLBACK *NAMEENUMPROCW)(LPWSTR,LPARAM);
typedef BOOL (CALLBACK *PROPENUMPROCA)(HWND,LPCSTR,HANDLE);
typedef BOOL (CALLBACK *PROPENUMPROCW)(HWND,LPCWSTR,HANDLE);
typedef BOOL (CALLBACK *PROPENUMPROCEXA)(HWND,LPCSTR,HANDLE,ULONG_PTR);
typedef BOOL (CALLBACK *PROPENUMPROCEXW)(HWND,LPCWSTR,HANDLE,ULONG_PTR);
typedef VOID (CALLBACK *SENDASYNCPROC)(HWND,UINT,ULONG_PTR,LRESULT);
typedef VOID (CALLBACK *TIMERPROC)(HWND,UINT,UINT,DWORD);
typedef BOOL (CALLBACK *WNDENUMPROC)(HWND,LPARAM);
#else
typedef FARPROC DLGPROC;
typedef FARPROC DRAWSTATEPROC;
@ -50,7 +50,7 @@ typedef NAMEENUMPROCA DESKTOPENUMPROCA;
typedef NAMEENUMPROCW WINSTAENUMPROCW;
typedef NAMEENUMPROCW DESKTOPENUMPROCW;
typedef LRESULT CALLBACK (*WNDPROC)(HWND,UINT,WPARAM,LPARAM);
typedef LRESULT (CALLBACK *WNDPROC)(HWND,UINT,WPARAM,LPARAM);
DECL_WINELIB_TYPE_AW(DESKTOPENUMPROC)
DECL_WINELIB_TYPE_AW(EDITWORDBREAKPROC)
@ -2237,7 +2237,7 @@ typedef struct
POINT MousePos; /* Mouse Position in screen co-ordinates */
} HELPINFO,*LPHELPINFO;
typedef void CALLBACK (*MSGBOXCALLBACK)(LPHELPINFO lpHelpInfo);
typedef void (CALLBACK *MSGBOXCALLBACK)(LPHELPINFO lpHelpInfo);
typedef struct
{
@ -2304,7 +2304,7 @@ typedef struct tagMONITORINFOEXW
DECL_WINELIB_TYPE_AW(MONITORINFOEX)
DECL_WINELIB_TYPE_AW(LPMONITORINFOEX)
typedef BOOL CALLBACK (*MONITORENUMPROC)(HMONITOR,HDC,LPRECT,LPARAM);
typedef BOOL (CALLBACK *MONITORENUMPROC)(HMONITOR,HDC,LPRECT,LPARAM);
#include "pshpack2.h"

2
include/ws2spi.h
View File

@ -13,7 +13,7 @@
extern "C" {
#endif /* defined(__cplusplus) */
typedef BOOL WINAPI (*LPWPUPOSTMESSAGE)(HWND,UINT,WPARAM,LPARAM);
typedef BOOL (WINAPI *LPWPUPOSTMESSAGE)(HWND,UINT,WPARAM,LPARAM);
#ifdef __cplusplus
} /* extern "C" */

2
tools/winebuild/spec16.c
View File

@ -353,7 +353,7 @@ static void BuildCallFrom16Func( FILE *outfile, char *profile, char *prefix, int
ret_type = reg_func? "void" : short_ret ? "unsigned short" : "unsigned int";
fprintf( outfile, "typedef %s __stdcall (*proc_%s_t)( ", ret_type, profile );
fprintf( outfile, "typedef %s (__stdcall *proc_%s_t)( ", ret_type, profile );
args = profile + 7;
for ( i = 0; args[i]; i++ )
{