ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reordered the CALLBACK and WINAPI directives so that it compiles with 

old g++ versions.
This commit is contained in:
Francois Gouget 2000-06-11 20:07:58 +00:00 committed by Alexandre Julliard
parent a537bec4d1
commit ae41e8c804
54 changed files with 333 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/animate.h
View File

@ -19,17 +19,17 @@ typedef struct tagANIMATE_INFO
* storage instead, which is not efficient on memory usage, but * storage instead, which is not efficient on memory usage, but
* will lead to less bugs in the future * will lead to less bugs in the future
*/ */
HIC (WINAPI* fnICOpen)(DWORD, DWORD, UINT); HIC WINAPI (*fnICOpen)(DWORD, DWORD, UINT);
LRESULT (WINAPI* fnICClose)(HIC); LRESULT WINAPI (*fnICClose)(HIC);
LRESULT (WINAPI* fnICSendMessage)(HIC, UINT, DWORD, DWORD); LRESULT WINAPI (*fnICSendMessage)(HIC, UINT, DWORD, DWORD);
DWORD (WINAPIV* fnICDecompress)(HIC,DWORD,LPBITMAPINFOHEADER,LPVOID,LPBITMAPINFOHEADER,LPVOID); DWORD WINAPIV (*fnICDecompress)(HIC,DWORD,LPBITMAPINFOHEADER,LPVOID,LPBITMAPINFOHEADER,LPVOID);
HMMIO (WINAPI* fnmmioOpenA)(LPSTR,MMIOINFO*,DWORD); HMMIO WINAPI (*fnmmioOpenA)(LPSTR,MMIOINFO*,DWORD);
MMRESULT (WINAPI * fnmmioClose)(HMMIO,UINT); MMRESULT WINAPI (*fnmmioClose)(HMMIO,UINT);
UINT (WINAPI * fnmmioAscend)(HMMIO,MMCKINFO*,UINT); UINT WINAPI (*fnmmioAscend)(HMMIO,MMCKINFO*,UINT);
UINT (WINAPI * fnmmioDescend)(HMMIO,MMCKINFO*,const MMCKINFO*,UINT); UINT WINAPI (*fnmmioDescend)(HMMIO,MMCKINFO*,const MMCKINFO*,UINT);
LONG (WINAPI * fnmmioSeek)(HMMIO,LONG,INT); LONG WINAPI (*fnmmioSeek)(HMMIO,LONG,INT);
LONG (WINAPI * fnmmioRead)(HMMIO,HPSTR,LONG); LONG WINAPI (*fnmmioRead)(HMMIO,HPSTR,LONG);
/* reference to input stream (file or resource) */ /* reference to input stream (file or resource) */
HGLOBAL hRes; HGLOBAL hRes;

20
include/callback.h
View File

@ -26,17 +26,17 @@ extern void THUNK_InitCallout(void);
typedef struct typedef struct
{ {
LONG (CALLBACK *CallRegisterShortProc)( CONTEXT86 *, INT ); LONG CALLBACK (*CallRegisterShortProc)( CONTEXT86 *, INT );
LONG (CALLBACK *CallRegisterLongProc)( CONTEXT86 *, INT ); LONG CALLBACK (*CallRegisterLongProc)( CONTEXT86 *, INT );
INT16 (CALLBACK *CallWindowsExitProc)( FARPROC16, INT16 ); INT16 CALLBACK (*CallWindowsExitProc)( FARPROC16, INT16 );
INT16 (CALLBACK *CallWordBreakProc)( EDITWORDBREAKPROC16, SEGPTR, INT16, INT16 CALLBACK (*CallWordBreakProc)( EDITWORDBREAKPROC16, SEGPTR, INT16,
INT16, INT16 ); INT16, INT16 );
VOID (CALLBACK *CallBootAppProc)( FARPROC16, HANDLE16, HFILE16 ); VOID CALLBACK (*CallBootAppProc)( FARPROC16, HANDLE16, HFILE16 );
WORD (CALLBACK *CallLoadAppSegProc)( FARPROC16, HANDLE16, HFILE16, WORD ); WORD CALLBACK (*CallLoadAppSegProc)( FARPROC16, HANDLE16, HFILE16, WORD );
WORD (CALLBACK *CallLocalNotifyFunc)( FARPROC16, WORD, HLOCAL16, WORD ); WORD CALLBACK (*CallLocalNotifyFunc)( FARPROC16, WORD, HLOCAL16, WORD );
HGLOBAL16 (CALLBACK *CallResourceHandlerProc)( FARPROC16, HGLOBAL16, HMODULE16, HRSRC16 ); HGLOBAL16 CALLBACK (*CallResourceHandlerProc)( FARPROC16, HGLOBAL16, HMODULE16, HRSRC16 );
DWORD (CALLBACK *CallUTProc)( FARPROC16, DWORD, DWORD ); DWORD CALLBACK (*CallUTProc)( FARPROC16, DWORD, DWORD );
LRESULT (CALLBACK *CallASPIPostProc)( FARPROC16, SEGPTR ); LRESULT CALLBACK (*CallASPIPostProc)( FARPROC16, SEGPTR );
} CALLBACKS_TABLE; } CALLBACKS_TABLE;
extern const CALLBACKS_TABLE *Callbacks; extern const CALLBACKS_TABLE *Callbacks;

12
include/commctrl.h
View File

@ -2049,7 +2049,7 @@ typedef struct tagTVDISPINFOW {
#define LPNMTVDISPINFO WINELIB_NAME_AW(LPNMTVDISPINFO) #define LPNMTVDISPINFO WINELIB_NAME_AW(LPNMTVDISPINFO)
#define TV_DISPINFO NMTVDISPINFO #define TV_DISPINFO NMTVDISPINFO
typedef INT (CALLBACK *PFNTVCOMPARE)(LPARAM, LPARAM, LPARAM); typedef INT CALLBACK (*PFNTVCOMPARE)(LPARAM, LPARAM, LPARAM);
typedef struct tagTVSORTCB typedef struct tagTVSORTCB
{ {
@ -2746,7 +2746,7 @@ typedef struct tagTCHITTESTINFO
#define TC_HITTESTINFO TCHITTESTINFO #define TC_HITTESTINFO TCHITTESTINFO
typedef INT (CALLBACK *PFNLVCOMPARE)(LPARAM, LPARAM, LPARAM); typedef INT CALLBACK (*PFNLVCOMPARE)(LPARAM, LPARAM, LPARAM);
typedef struct tagNMLVCACHEHINT typedef struct tagNMLVCACHEHINT
{ {
@ -3587,7 +3587,7 @@ LPVOID WINAPI DSA_GetItemPtr (const HDSA, INT);
INT WINAPI DSA_InsertItem (const HDSA, INT, LPVOID); INT WINAPI DSA_InsertItem (const HDSA, INT, LPVOID);
BOOL WINAPI DSA_SetItem (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); VOID WINAPI DSA_EnumCallback (const HDSA, DSAENUMPROC, LPARAM);
BOOL WINAPI DSA_DestroyCallback (const HDSA, DSAENUMPROC, LPARAM); BOOL WINAPI DSA_DestroyCallback (const HDSA, DSAENUMPROC, LPARAM);
@ -3615,7 +3615,7 @@ INT WINAPI DPA_InsertPtr (const HDPA, INT, LPVOID);
LPVOID WINAPI DPA_DeletePtr (const HDPA, INT); LPVOID WINAPI DPA_DeletePtr (const HDPA, INT);
BOOL WINAPI DPA_DeleteAllPtrs (const HDPA); 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); BOOL WINAPI DPA_Sort (const HDPA, PFNDPACOMPARE, LPARAM);
#define DPAS_SORTED 0x0001 #define DPAS_SORTED 0x0001
@ -3626,10 +3626,10 @@ INT WINAPI DPA_Search (const HDPA, LPVOID, INT, PFNDPACOMPARE, LPARAM, UINT);
#define DPAM_SORT 0x0001 #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); 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); VOID WINAPI DPA_EnumCallback (const HDPA, DPAENUMPROC, LPARAM);
BOOL WINAPI DPA_DestroyCallback (const HDPA, DPAENUMPROC, LPARAM); BOOL WINAPI DPA_DestroyCallback (const HDPA, DPAENUMPROC, LPARAM);

16
include/commdlg.h
View File

@ -48,7 +48,7 @@ extern "C" {
#define SAVE_DIALOG 1 #define SAVE_DIALOG 1
#define OPEN_DIALOG 2 #define OPEN_DIALOG 2
typedef UINT (CALLBACK *LPOFNHOOKPROC)(HWND,UINT,WPARAM,LPARAM); typedef UINT CALLBACK (*LPOFNHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef struct { typedef struct {
DWORD lStructSize; DWORD lStructSize;
@ -116,7 +116,7 @@ typedef struct
DECL_WINELIB_TYPE_AW(OFNOTIFY) DECL_WINELIB_TYPE_AW(OFNOTIFY)
DECL_WINELIB_TYPE_AW(LPOFNOTIFY) DECL_WINELIB_TYPE_AW(LPOFNOTIFY)
typedef UINT (CALLBACK *LPCCHOOKPROC) (HWND, UINT, WPARAM, LPARAM); typedef UINT CALLBACK (*LPCCHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef struct { typedef struct {
DWORD lStructSize; DWORD lStructSize;
@ -156,7 +156,7 @@ DECL_WINELIB_TYPE_AW(LPCHOOSECOLOR)
#define CC_ENABLETEMPLATE 0x00000020 #define CC_ENABLETEMPLATE 0x00000020
#define CC_ENABLETEMPLATEHANDLE 0x00000040 #define CC_ENABLETEMPLATEHANDLE 0x00000040
typedef UINT (CALLBACK *LPFRHOOKPROC)(HWND,UINT,WPARAM,LPARAM); typedef UINT CALLBACK (*LPFRHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef struct { typedef struct {
DWORD lStructSize; DWORD lStructSize;
@ -207,7 +207,7 @@ DECL_WINELIB_TYPE_AW(LPFINDREPLACE)
#define FR_HIDEMATCHCASE 0x00008000 #define FR_HIDEMATCHCASE 0x00008000
#define FR_HIDEWHOLEWORD 0x00010000 #define FR_HIDEWHOLEWORD 0x00010000
typedef UINT (CALLBACK *LPCFHOOKPROC)(HWND,UINT,WPARAM,LPARAM); typedef UINT CALLBACK (*LPCFHOOKPROC)(HWND,UINT,WPARAM,LPARAM);
typedef struct typedef struct
{ {
@ -391,8 +391,8 @@ DECL_WINELIB_TYPE_AW(LPCHOOSEFONT)
(void)SNDMSG(_hdlg, CDM_SETDEFEXT, 0, (LPARAM)(LPSTR)_pszext) (void)SNDMSG(_hdlg, CDM_SETDEFEXT, 0, (LPARAM)(LPSTR)_pszext)
typedef UINT (CALLBACK *LPPRINTHOOKPROC) (HWND, UINT, WPARAM, LPARAM); typedef UINT CALLBACK (*LPPRINTHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef UINT (CALLBACK *LPSETUPHOOKPROC) (HWND, UINT, WPARAM, LPARAM); typedef UINT CALLBACK (*LPSETUPHOOKPROC) (HWND, UINT, WPARAM, LPARAM);
typedef struct tagPDA typedef struct tagPDA
{ {
@ -487,8 +487,8 @@ typedef DEVNAMES * LPDEVNAMES;
#define WM_PSD_ENVSTAMPRECT (WM_USER+5) #define WM_PSD_ENVSTAMPRECT (WM_USER+5)
#define WM_PSD_YAFULLPAGERECT (WM_USER+6) #define WM_PSD_YAFULLPAGERECT (WM_USER+6)
typedef UINT (CALLBACK* LPPAGEPAINTHOOK)( HWND, UINT, WPARAM, LPARAM ); typedef UINT CALLBACK (*LPPAGEPAINTHOOK)( HWND, UINT, WPARAM, LPARAM );
typedef UINT (CALLBACK* LPPAGESETUPHOOK)( HWND, UINT, WPARAM, LPARAM ); typedef UINT CALLBACK (*LPPAGESETUPHOOK)( HWND, UINT, WPARAM, LPARAM );
typedef struct tagPSDA typedef struct tagPSDA
{ {

2
include/crtdll.h
View File

@ -27,7 +27,7 @@
/* function prototypes used in crtdll.c */ /* function prototypes used in crtdll.c */
extern int LastErrorToErrno(DWORD); extern int LastErrorToErrno(DWORD);
void * __cdecl CRTDLL_malloc( DWORD size ); void __cdecl *CRTDLL_malloc( DWORD size );
void __cdecl CRTDLL_free( void *ptr ); void __cdecl CRTDLL_free( void *ptr );
LPSTR __cdecl CRTDLL__mbsinc( LPCSTR str ); LPSTR __cdecl CRTDLL__mbsinc( LPCSTR str );

6
include/d3d.h
View File

@ -56,15 +56,15 @@ typedef struct IDirect3DDevice2 IDirect3DDevice2, *LPDIRECT3DDEVICE2;
typedef struct IDirect3DDevice3 IDirect3DDevice3, *LPDIRECT3DDEVICE3; typedef struct IDirect3DDevice3 IDirect3DDevice3, *LPDIRECT3DDEVICE3;
typedef struct IDirect3DDevice7 IDirect3DDevice7, *LPDIRECT3DDEVICE7; typedef struct IDirect3DDevice7 IDirect3DDevice7, *LPDIRECT3DDEVICE7;
typedef struct IDirect3DViewport2 IDirect3DViewport, *LPDIRECT3DVIEWPORT; typedef struct IDirect3DViewport IDirect3DViewport, *LPDIRECT3DVIEWPORT;
typedef struct IDirect3DViewport2 IDirect3DViewport2, *LPDIRECT3DVIEWPORT2; typedef struct IDirect3DViewport2 IDirect3DViewport2, *LPDIRECT3DVIEWPORT2;
typedef struct IDirect3DViewport3 IDirect3DViewport3, *LPDIRECT3DVIEWPORT3; typedef struct IDirect3DViewport3 IDirect3DViewport3, *LPDIRECT3DVIEWPORT3;
typedef struct IDirect3DMaterial2 IDirect3DMaterial, *LPDIRECT3DMATERIAL; typedef struct IDirect3DMaterial IDirect3DMaterial, *LPDIRECT3DMATERIAL;
typedef struct IDirect3DMaterial2 IDirect3DMaterial2, *LPDIRECT3DMATERIAL2; typedef struct IDirect3DMaterial2 IDirect3DMaterial2, *LPDIRECT3DMATERIAL2;
typedef struct IDirect3DMaterial3 IDirect3DMaterial3, *LPDIRECT3DMATERIAL3; typedef struct IDirect3DMaterial3 IDirect3DMaterial3, *LPDIRECT3DMATERIAL3;
typedef struct IDirect3DTexture2 IDirect3DTexture, *LPDIRECT3DTEXTURE; typedef struct IDirect3DTexture IDirect3DTexture, *LPDIRECT3DTEXTURE;
typedef struct IDirect3DTexture2 IDirect3DTexture2, *LPDIRECT3DTEXTURE2; typedef struct IDirect3DTexture2 IDirect3DTexture2, *LPDIRECT3DTEXTURE2;
typedef struct IDirect3DExecuteBuffer IDirect3DExecuteBuffer, *LPDIRECT3DEXECUTEBUFFER; typedef struct IDirect3DExecuteBuffer IDirect3DExecuteBuffer, *LPDIRECT3DEXECUTEBUFFER;

4
include/d3dcaps.h
View File

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

6
include/d3dtypes.h
View File

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

4
include/ddeml.h
View File

@ -219,9 +219,9 @@ DECLARE_HANDLE(HDDEDATA);
*******************************************************/ *******************************************************/
typedef HDDEDATA (CALLBACK *PFNCALLBACK16)(UINT16,UINT16,HCONV,HSZ,HSZ, typedef HDDEDATA CALLBACK (*PFNCALLBACK16)(UINT16,UINT16,HCONV,HSZ,HSZ,
HDDEDATA,DWORD,DWORD); HDDEDATA,DWORD,DWORD);
typedef HDDEDATA (CALLBACK *PFNCALLBACK)(UINT,UINT,HCONV,HSZ,HSZ, typedef HDDEDATA CALLBACK (*PFNCALLBACK)(UINT,UINT,HCONV,HSZ,HSZ,
HDDEDATA,DWORD,DWORD); HDDEDATA,DWORD,DWORD);
/*************************************************** /***************************************************

14
include/ddraw.h
View File

@ -41,7 +41,7 @@ DEFINE_GUID( IID_IDirectDrawGammaControl,0x69C11C3E,0xB46B,0x11D1,0xAD,0x7A,0x00
typedef struct IDirectDraw IDirectDraw,*LPDIRECTDRAW; typedef struct IDirectDraw IDirectDraw,*LPDIRECTDRAW;
typedef struct IDirectDraw2 IDirectDraw2,*LPDIRECTDRAW2; typedef struct IDirectDraw2 IDirectDraw2,*LPDIRECTDRAW2;
typedef struct IDirectDraw4 IDirectDraw4,*LPDIRECTDRAW4; typedef struct IDirectDraw4 IDirectDraw4,*LPDIRECTDRAW4;
typedef struct IDirectDraw4 IDirectDraw7,*LPDIRECTDRAW7; typedef struct IDirectDraw7 IDirectDraw7,*LPDIRECTDRAW7;
typedef struct IDirectDrawClipper IDirectDrawClipper,*LPDIRECTDRAWCLIPPER; typedef struct IDirectDrawClipper IDirectDrawClipper,*LPDIRECTDRAWCLIPPER;
typedef struct IDirectDrawPalette IDirectDrawPalette,*LPDIRECTDRAWPALETTE; typedef struct IDirectDrawPalette IDirectDrawPalette,*LPDIRECTDRAWPALETTE;
typedef struct IDirectDrawSurface IDirectDrawSurface,*LPDIRECTDRAWSURFACE; typedef struct IDirectDrawSurface IDirectDrawSurface,*LPDIRECTDRAWSURFACE;
@ -976,15 +976,15 @@ typedef struct {
DWORD dwReserved1; DWORD dwReserved1;
} DDCOLORCONTROL,*LPDDCOLORCONTROL; } DDCOLORCONTROL,*LPDDCOLORCONTROL;
typedef BOOL (CALLBACK * LPDDENUMCALLBACKA)(GUID *, LPSTR, LPSTR, LPVOID); typedef BOOL CALLBACK (*LPDDENUMCALLBACKA)(GUID *, LPSTR, LPSTR, LPVOID);
typedef BOOL (CALLBACK * LPDDENUMCALLBACKW)(GUID *, LPWSTR, LPWSTR, LPVOID); typedef BOOL CALLBACK (*LPDDENUMCALLBACKW)(GUID *, LPWSTR, LPWSTR, LPVOID);
DECL_WINELIB_TYPE_AW(LPDDENUMCALLBACK) DECL_WINELIB_TYPE_AW(LPDDENUMCALLBACK)
typedef HRESULT (CALLBACK * LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID); typedef HRESULT CALLBACK (*LPDDENUMMODESCALLBACK)(LPDDSURFACEDESC, LPVOID);
typedef HRESULT (CALLBACK * LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID); typedef HRESULT CALLBACK (*LPDDENUMSURFACESCALLBACK)(LPDIRECTDRAWSURFACE, LPDDSURFACEDESC, LPVOID);
typedef BOOL (CALLBACK * LPDDENUMCALLBACKEXA)(GUID *, LPSTR, LPSTR, LPVOID, HMONITOR); typedef BOOL CALLBACK (*LPDDENUMCALLBACKEXA)(GUID *, LPSTR, LPSTR, LPVOID, HMONITOR);
typedef BOOL (CALLBACK * LPDDENUMCALLBACKEXW)(GUID *, LPWSTR, LPWSTR, LPVOID, HMONITOR); typedef BOOL CALLBACK (*LPDDENUMCALLBACKEXW)(GUID *, LPWSTR, LPWSTR, LPVOID, HMONITOR);
DECL_WINELIB_TYPE_AW(LPDDENUMCALLBACKEX) DECL_WINELIB_TYPE_AW(LPDDENUMCALLBACKEX)
HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags); HRESULT WINAPI DirectDrawEnumerateExA( LPDDENUMCALLBACKEXA lpCallback, LPVOID lpContext, DWORD dwFlags);

14
include/dinput.h
View File

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

14
include/dplay.h
View File

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

6
include/dplobby.h
View File

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

4
include/dsound.h
View File

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

2
include/gdi.h
View File

@ -137,7 +137,7 @@ typedef struct
} WIN_DC_INFO; } WIN_DC_INFO;
typedef BOOL16 (CALLBACK *DCHOOKPROC)(HDC16,WORD,DWORD,LPARAM); typedef BOOL16 CALLBACK (*DCHOOKPROC)(HDC16,WORD,DWORD,LPARAM);
typedef struct tagDC typedef struct tagDC
{ {

20
include/imagehlp.h
View File

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

4
include/imm.h
View File

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

2
include/keyboard.h
View File

@ -20,7 +20,7 @@ typedef struct _KBINFO
} KBINFO, *LPKBINFO; } KBINFO, *LPKBINFO;
#include "poppack.h" #include "poppack.h"
typedef VOID (CALLBACK *LPKEYBD_EVENT_PROC)(BYTE,BYTE,DWORD,DWORD); typedef VOID CALLBACK (*LPKEYBD_EVENT_PROC)(BYTE,BYTE,DWORD,DWORD);
WORD WINAPI KEYBOARD_Inquire(LPKBINFO kbInfo); WORD WINAPI KEYBOARD_Inquire(LPKBINFO kbInfo);
VOID WINAPI KEYBOARD_Enable(LPKEYBD_EVENT_PROC lpKeybEventProc, VOID WINAPI KEYBOARD_Enable(LPKEYBD_EVENT_PROC lpKeybEventProc,

2
include/mmddk.h
View File

@ -278,7 +278,7 @@ typedef struct joycalibrate_tag {
typedef JOYCALIBRATE *LPJOYCALIBRATE; typedef JOYCALIBRATE *LPJOYCALIBRATE;
/* prototype for joystick message function */ /* prototype for joystick message function */
typedef UINT (CALLBACK JOYDEVMSGPROC)(DWORD dwID, UINT uMessage, LPARAM lParam1, LPARAM lParam2); typedef UINT CALLBACK (JOYDEVMSGPROC)(DWORD dwID, UINT uMessage, LPARAM lParam1, LPARAM lParam2);
typedef JOYDEVMSGPROC *LPJOYDEVMSGPROC; typedef JOYDEVMSGPROC *LPJOYDEVMSGPROC;
/* messages sent to joystick driver's DriverProc() function */ /* messages sent to joystick driver's DriverProc() function */

14
include/mmsystem.h
View File

@ -151,8 +151,8 @@ typedef struct {
#define CALLBACK_FUNCTION 0x00030000l /* dwCallback is a FARPROC */ #define CALLBACK_FUNCTION 0x00030000l /* dwCallback is a FARPROC */
#define CALLBACK_EVENT 0x00050000l /* dwCallback is an EVENT Handler */ #define CALLBACK_EVENT 0x00050000l /* dwCallback is an EVENT Handler */
typedef void (CALLBACK *LPDRVCALLBACK16) (HDRVR16 h, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2); typedef void CALLBACK (*LPDRVCALLBACK16) (HDRVR16 h, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
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. */ #define MM_MICROSOFT 1 /* Microsoft Corp. */
@ -775,8 +775,8 @@ DWORD WINAPI auxOutMessage(UINT,UINT,DWORD,DWORD);
#define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */ #define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */
#define TIMERR_STRUCT (TIMERR_BASE+33) /* time struct size */ #define TIMERR_STRUCT (TIMERR_BASE+33) /* time struct size */
typedef void (CALLBACK *LPTIMECALLBACK16)(UINT16 uTimerID, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2); typedef void CALLBACK (*LPTIMECALLBACK16)(UINT16 uTimerID, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
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_ONESHOT 0x0000 /* program timer for single event */
#define TIME_PERIODIC 0x0001 /* program for continuous periodic event */ #define TIME_PERIODIC 0x0001 /* program for continuous periodic event */
@ -1488,9 +1488,9 @@ UINT WINAPI mixerSetControlDetails(HMIXEROBJ,LPMIXERCONTROLDETAILS,DWORD);
#define CFSEPCHAR '+' /* compound file name separator char. */ #define CFSEPCHAR '+' /* compound file name separator char. */
typedef DWORD FOURCC; /* a four character code */ typedef DWORD FOURCC; /* a four character code */
typedef LONG (CALLBACK *LPMMIOPROC16)(LPSTR lpmmioinfo, UINT16 uMessage, typedef LONG CALLBACK (*LPMMIOPROC16)(LPSTR lpmmioinfo, UINT16 uMessage,
LPARAM lParam1, LPARAM lParam2); LPARAM lParam1, LPARAM lParam2);
typedef LONG (CALLBACK *LPMMIOPROC)(LPSTR lpmmioinfo, UINT uMessage, typedef LONG CALLBACK (*LPMMIOPROC)(LPSTR lpmmioinfo, UINT uMessage,
LPARAM lParam1, LPARAM lParam2); LPARAM lParam1, LPARAM lParam2);
typedef struct { typedef struct {
@ -1658,7 +1658,7 @@ UINT WINAPI mmioAscend(HMMIO,MMCKINFO*,UINT);
UINT16 WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16); UINT16 WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16);
UINT WINAPI mmioCreateChunk(HMMIO,MMCKINFO*,UINT); UINT WINAPI mmioCreateChunk(HMMIO,MMCKINFO*,UINT);
typedef UINT16 (CALLBACK *YIELDPROC)(UINT16,DWORD); typedef UINT16 CALLBACK (*YIELDPROC)(UINT16,DWORD);
DWORD WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD); DWORD WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD);
DWORD WINAPI mciSendCommandA(UINT,UINT,DWORD,DWORD); DWORD WINAPI mciSendCommandA(UINT,UINT,DWORD,DWORD);

40
include/msacm.h
View File

@ -191,35 +191,35 @@ extern "C" {
* Callbacks * Callbacks
*/ */
typedef BOOL (CALLBACK *ACMDRIVERENUMCB)( typedef BOOL CALLBACK (*ACMDRIVERENUMCB)(
HACMDRIVERID hadid, DWORD dwInstance, DWORD fdwSupport HACMDRIVERID hadid, DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL16 (CALLBACK *ACMDRIVERENUMCB16)( typedef BOOL16 CALLBACK (*ACMDRIVERENUMCB16)(
HACMDRIVERID16 hadid, DWORD dwInstance, DWORD fdwSupport HACMDRIVERID16 hadid, DWORD dwInstance, DWORD fdwSupport
); );
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROCA)( typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROCA)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
); );
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROCW)( typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROCW)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
); );
typedef UINT (CALLBACK *ACMFILTERCHOOSEHOOKPROC16)( typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROC16)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
); );
typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROCA)( typedef UINT CALLBACK (*ACMFORMATCHOOSEHOOKPROCA)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
); );
typedef UINT (CALLBACK *ACMFORMATCHOOSEHOOKPROCW)( typedef UINT CALLBACK (*ACMFORMATCHOOSEHOOKPROCW)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
); );
typedef UINT16 (CALLBACK *ACMFORMATCHOOSEHOOKPROC16)( typedef UINT16 CALLBACK (*ACMFORMATCHOOSEHOOKPROC16)(
HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam
); );
@ -614,62 +614,62 @@ typedef struct _ACMSTREAMHEADER
* Callbacks 2 * Callbacks 2
*/ */
typedef BOOL (CALLBACK *ACMFILTERENUMCBA)( typedef BOOL CALLBACK (*ACMFILTERENUMCBA)(
HACMDRIVERID hadid, PACMFILTERDETAILSA pafd, HACMDRIVERID hadid, PACMFILTERDETAILSA pafd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFILTERENUMCBW)( typedef BOOL CALLBACK (*ACMFILTERENUMCBW)(
HACMDRIVERID hadid, PACMFILTERDETAILSW pafd, HACMDRIVERID hadid, PACMFILTERDETAILSW pafd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL16 (CALLBACK *ACMFILTERENUMCB16)( typedef BOOL16 CALLBACK (*ACMFILTERENUMCB16)(
HACMDRIVERID16 hadid, LPACMFILTERDETAILS16 pafd, HACMDRIVERID16 hadid, LPACMFILTERDETAILS16 pafd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFILTERTAGENUMCBA)( typedef BOOL CALLBACK (*ACMFILTERTAGENUMCBA)(
HACMDRIVERID hadid, PACMFILTERTAGDETAILSA paftd, HACMDRIVERID hadid, PACMFILTERTAGDETAILSA paftd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFILTERTAGENUMCBW)( typedef BOOL CALLBACK (*ACMFILTERTAGENUMCBW)(
HACMDRIVERID hadid, PACMFILTERTAGDETAILSW paftd, HACMDRIVERID hadid, PACMFILTERTAGDETAILSW paftd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL16 (CALLBACK *ACMFILTERTAGENUMCB16)( typedef BOOL16 CALLBACK (*ACMFILTERTAGENUMCB16)(
HACMDRIVERID16 hadid, LPACMFILTERTAGDETAILS16 paftd, HACMDRIVERID16 hadid, LPACMFILTERTAGDETAILS16 paftd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFORMATENUMCBA)( typedef BOOL CALLBACK (*ACMFORMATENUMCBA)(
HACMDRIVERID hadid, PACMFORMATDETAILSA pafd, HACMDRIVERID hadid, PACMFORMATDETAILSA pafd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFORMATENUMCBW)( typedef BOOL CALLBACK (*ACMFORMATENUMCBW)(
HACMDRIVERID hadid, PACMFORMATDETAILSW pafd, HACMDRIVERID hadid, PACMFORMATDETAILSW pafd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL16 (CALLBACK *ACMFORMATENUMCB16)( typedef BOOL16 CALLBACK (*ACMFORMATENUMCB16)(
HACMDRIVERID16 hadid, LPACMFORMATDETAILS16 pafd, HACMDRIVERID16 hadid, LPACMFORMATDETAILS16 pafd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFORMATTAGENUMCBA)( typedef BOOL CALLBACK (*ACMFORMATTAGENUMCBA)(
HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd, HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL (CALLBACK *ACMFORMATTAGENUMCBW)( typedef BOOL CALLBACK (*ACMFORMATTAGENUMCBW)(
HACMDRIVERID hadid, PACMFORMATTAGDETAILSW paftd, HACMDRIVERID hadid, PACMFORMATTAGDETAILSW paftd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );
typedef BOOL16 (CALLBACK *ACMFORMATTAGENUMCB16)( typedef BOOL16 CALLBACK (*ACMFORMATTAGENUMCB16)(
HACMDRIVERID16 hadid, LPACMFORMATTAGDETAILS16 paftd, HACMDRIVERID16 hadid, LPACMFORMATTAGDETAILS16 paftd,
DWORD dwInstance, DWORD fdwSupport DWORD dwInstance, DWORD fdwSupport
); );

2
include/netspi.h
View File

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

2
include/ntddk.h
View File

@ -31,7 +31,7 @@ typedef struct _IO_STATUS_BLOCK
ULONG_PTR Information; ULONG_PTR Information;
} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved ); typedef VOID NTAPI (*PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
/* /*
registry registry

114
include/ole.h
View File

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

4
include/ole2.h
View File

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

8
include/oleauto.h
View File

@ -47,8 +47,8 @@ SafeArrayAllocDescriptor(UINT cDims, struct tagSAFEARRAY **ppsaOut);
HRESULT WINAPI HRESULT WINAPI
SafeArrayAllocData(struct tagSAFEARRAY *psa); SafeArrayAllocData(struct tagSAFEARRAY *psa);
struct tagSAFEARRAY* WINAPI struct tagSAFEARRAY WINAPI
SafeArrayCreate(VARTYPE vt, UINT cDims, struct tagSAFEARRAYBOUND *rgsabound); *SafeArrayCreate(VARTYPE vt, UINT cDims, struct tagSAFEARRAYBOUND *rgsabound);
HRESULT WINAPI HRESULT WINAPI
SafeArrayDestroyDescriptor(struct tagSAFEARRAY *psa); SafeArrayDestroyDescriptor(struct tagSAFEARRAY *psa);
@ -98,8 +98,8 @@ SafeArrayDestroy(struct tagSAFEARRAY *psa);
HRESULT WINAPI HRESULT WINAPI
SafeArrayCopy(struct tagSAFEARRAY *psa, struct tagSAFEARRAY **ppsaOut); SafeArrayCopy(struct tagSAFEARRAY *psa, struct tagSAFEARRAY **ppsaOut);
struct tagSAFEARRAY* WINAPI struct tagSAFEARRAY WINAPI
SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements); *SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements);
HRESULT WINAPI HRESULT WINAPI
SafeArrayRedim(struct tagSAFEARRAY *psa, struct tagSAFEARRAYBOUND *psaboundNew); SafeArrayRedim(struct tagSAFEARRAY *psa, struct tagSAFEARRAYBOUND *psaboundNew);

2
include/oledlg.h
View File

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

2
include/pe_image.h
View File

@ -47,7 +47,7 @@ extern BOOL PE_InitDLL(struct _wine_modref *wm, DWORD type, LPVOID lpReserved);
extern PIMAGE_RESOURCE_DIRECTORY GetResDirEntryA(PIMAGE_RESOURCE_DIRECTORY,LPCSTR,DWORD,BOOL); extern PIMAGE_RESOURCE_DIRECTORY GetResDirEntryA(PIMAGE_RESOURCE_DIRECTORY,LPCSTR,DWORD,BOOL);
extern PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY,LPCWSTR,DWORD,BOOL); extern PIMAGE_RESOURCE_DIRECTORY GetResDirEntryW(PIMAGE_RESOURCE_DIRECTORY,LPCWSTR,DWORD,BOOL);
typedef DWORD (CALLBACK*DLLENTRYPROC)(HMODULE,DWORD,LPVOID); typedef DWORD CALLBACK(*DLLENTRYPROC)(HMODULE,DWORD,LPVOID);
typedef struct { typedef struct {
WORD popl WINE_PACKED; /* 0x8f 0x05 */ WORD popl WINE_PACKED; /* 0x8f 0x05 */

2
include/process.h
View File

@ -157,7 +157,7 @@ extern BOOL PROCESS_Create( HFILE hFile, LPCSTR filename, LPCSTR cmd_line, LPCST
BOOL inherit, DWORD flags, BOOL inherit, DWORD flags,
STARTUPINFOA *startup, PROCESS_INFORMATION *info ); STARTUPINFOA *startup, PROCESS_INFORMATION *info );
static inline PDB * WINE_UNUSED PROCESS_Current(void) static inline PDB WINE_UNUSED *PROCESS_Current(void)
{ {
return NtCurrentTeb()->process; return NtCurrentTeb()->process;
} }

10
include/prsht.h
View File

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

2
include/richedit.h
View File

@ -57,7 +57,7 @@ extern "C" {
#define EM_GETWORDBREAKPROCEX (WM_USER + 80) #define EM_GETWORDBREAKPROCEX (WM_USER + 80)
#define EM_SETWORDBREAKPROCEX (WM_USER + 81) #define EM_SETWORDBREAKPROCEX (WM_USER + 81)
typedef DWORD (CALLBACK* EDITSTREAMCALLBACK)( DWORD, LPBYTE, LONG, LONG * ); typedef DWORD CALLBACK(* EDITSTREAMCALLBACK)( DWORD, LPBYTE, LONG, LONG * );
typedef struct typedef struct
{ {

2
include/server.h
View File

@ -1319,7 +1319,7 @@ extern void server_protocol_error( const char *err, ... ) WINE_NORETURN;
extern const char *get_config_dir(void); extern const char *get_config_dir(void);
/* get a pointer to the request buffer */ /* get a pointer to the request buffer */
static inline void * WINE_UNUSED get_req_buffer(void) static inline void WINE_UNUSED *get_req_buffer(void)
{ {
return NtCurrentTeb()->buffer; return NtCurrentTeb()->buffer;
} }

4
include/shlobj.h
View File

@ -186,7 +186,7 @@ void WINAPI WinExecErrorW(HWND hwnd,INT error, LPCWSTR lpstrFileName, LPCWSTR lp
/**************************************************************************** /****************************************************************************
* SHBrowseForFolder API * 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 { typedef struct tagBROWSEINFOA {
HWND hwndOwner; HWND hwndOwner;
@ -318,7 +318,7 @@ HRESULT WINAPI SHGetSpecialFolderLocation(HWND hwndOwner, INT nFolder, LPITEMIDL
* Look there for some clues on what to do here. * 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); HWND hwnd,UINT uMsg,UINT wParam,LPARAM lParam);
/* NF valid values for the "viewmode" item of the SHELLTEMPLATE*/ /* NF valid values for the "viewmode" item of the SHELLTEMPLATE*/

4
include/tapi.h
View File

@ -403,7 +403,7 @@ typedef struct linetranslateoutput_tag {
DWORD dwTranslateResults; DWORD dwTranslateResults;
} LINETRANSLATEOUTPUT, *LPLINETRANSLATEOUTPUT; } 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 { typedef struct _PHONEAPP {
int dummy; int dummy;
@ -500,7 +500,7 @@ typedef struct phonestatus_tag {
DWORD dwDevSpecificOffset; DWORD dwDevSpecificOffset;
} PHONESTATUS, *LPPHONESTATUS; } 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 { typedef struct varstring_tag {
DWORD dwTotalSize; DWORD dwTotalSize;

2
include/task.h
View File

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

2
include/user.h
View File

@ -37,7 +37,7 @@ typedef struct tagKEYBOARD_CONFIG {
BOOL auto_repeat; BOOL auto_repeat;
} KEYBOARD_CONFIG; } KEYBOARD_CONFIG;
typedef VOID (CALLBACK *LPMOUSE_EVENT_PROC)(DWORD,DWORD,DWORD,DWORD,DWORD); typedef VOID CALLBACK (*LPMOUSE_EVENT_PROC)(DWORD,DWORD,DWORD,DWORD,DWORD);
typedef struct tagUSER_DRIVER { typedef struct tagUSER_DRIVER {
/* event functions */ /* event functions */

30
include/winbase.h
View File

@ -15,7 +15,7 @@ extern "C" {
#define WEP_FREE_DLL 0 #define WEP_FREE_DLL 0
#define WEP_SYSTEM_EXIT 1 #define WEP_SYSTEM_EXIT 1
typedef DWORD (CALLBACK *LPTHREAD_START_ROUTINE)(LPVOID); typedef DWORD CALLBACK (*LPTHREAD_START_ROUTINE)(LPVOID);
#define EXCEPTION_DEBUG_EVENT 1 #define EXCEPTION_DEBUG_EVENT 1
#define CREATE_THREAD_DEBUG_EVENT 2 #define CREATE_THREAD_DEBUG_EVENT 2
@ -614,7 +614,7 @@ typedef struct {
HANDLE hEvent; HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED; } 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. /* Process startup information.
*/ */
@ -775,11 +775,11 @@ typedef struct _SYSTEM_POWER_STATUS
} SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS; } SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS;
typedef BOOL (CALLBACK *CODEPAGE_ENUMPROCA)(LPSTR); typedef BOOL CALLBACK (*CODEPAGE_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *CODEPAGE_ENUMPROCW)(LPWSTR); typedef BOOL CALLBACK (*CODEPAGE_ENUMPROCW)(LPWSTR);
DECL_WINELIB_TYPE_AW(CODEPAGE_ENUMPROC) DECL_WINELIB_TYPE_AW(CODEPAGE_ENUMPROC)
typedef BOOL (CALLBACK *LOCALE_ENUMPROCA)(LPSTR); typedef BOOL CALLBACK (*LOCALE_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK *LOCALE_ENUMPROCW)(LPWSTR); typedef BOOL CALLBACK (*LOCALE_ENUMPROCW)(LPWSTR);
DECL_WINELIB_TYPE_AW(LOCALE_ENUMPROC) DECL_WINELIB_TYPE_AW(LOCALE_ENUMPROC)
typedef struct tagSYSTEM_INFO typedef struct tagSYSTEM_INFO
@ -808,12 +808,12 @@ typedef struct tagSYSTEM_INFO
#define HIGH_PRIORITY_CLASS 0x00000080 #define HIGH_PRIORITY_CLASS 0x00000080
#define REALTIME_PRIORITY_CLASS 0x00000100 #define REALTIME_PRIORITY_CLASS 0x00000100
typedef BOOL (CALLBACK *ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG); typedef BOOL CALLBACK (*ENUMRESTYPEPROCA)(HMODULE,LPSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG); typedef BOOL CALLBACK (*ENUMRESTYPEPROCW)(HMODULE,LPWSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG); typedef BOOL CALLBACK (*ENUMRESNAMEPROCA)(HMODULE,LPCSTR,LPSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG); typedef BOOL CALLBACK (*ENUMRESNAMEPROCW)(HMODULE,LPCWSTR,LPWSTR,LONG);
typedef BOOL (CALLBACK *ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG); typedef BOOL CALLBACK (*ENUMRESLANGPROCA)(HMODULE,LPCSTR,LPCSTR,WORD,LONG);
typedef BOOL (CALLBACK *ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG); typedef BOOL CALLBACK (*ENUMRESLANGPROCW)(HMODULE,LPCWSTR,LPCWSTR,WORD,LONG);
DECL_WINELIB_TYPE_AW(ENUMRESTYPEPROC) DECL_WINELIB_TYPE_AW(ENUMRESTYPEPROC)
DECL_WINELIB_TYPE_AW(ENUMRESNAMEPROC) DECL_WINELIB_TYPE_AW(ENUMRESNAMEPROC)
@ -876,7 +876,7 @@ typedef struct _DllVersionInfo {
* This one seems to be a Win32 only definition. It also is defined with * This one seems to be a Win32 only definition. It also is defined with
* WINAPI instead of CALLBACK in the windows headers. * 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, LARGE_INTEGER, DWORD, DWORD, HANDLE,
HANDLE, LPVOID); HANDLE, LPVOID);
@ -1047,8 +1047,8 @@ typedef struct tagCOMMTIMEOUTS {
#include "poppack.h" #include "poppack.h"
typedef void (CALLBACK *PAPCFUNC)(ULONG_PTR); typedef void CALLBACK (*PAPCFUNC)(ULONG_PTR);
typedef void (CALLBACK *PTIMERAPCROUTINE)(LPVOID,DWORD,DWORD); typedef void CALLBACK (*PTIMERAPCROUTINE)(LPVOID,DWORD,DWORD);
BOOL WINAPI ClearCommError(INT,LPDWORD,LPCOMSTAT); BOOL WINAPI ClearCommError(INT,LPDWORD,LPCOMSTAT);
BOOL WINAPI BuildCommDCBA(LPCSTR,LPDCB); BOOL WINAPI BuildCommDCBA(LPCSTR,LPDCB);

4
include/wine/exception.h
View File

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

138
include/wine/obj_base.h
View File

@ -343,47 +343,47 @@ inline BOOL operator!=(const GUID& guidOne, const GUID& guidOther)
/* C++ interface */ /* C++ interface */
#define ICOM_METHOD(ret,xfn) \ #define ICOM_METHOD(ret,xfn) \
public: virtual ret (CALLBACK xfn)(void) = 0; public: virtual ret CALLBACK (xfn)(void) = 0;
#define ICOM_METHOD1(ret,xfn,ta,na) \ #define ICOM_METHOD1(ret,xfn,ta,na) \
public: virtual ret (CALLBACK xfn)(ta a) = 0; public: virtual ret CALLBACK (xfn)(ta a) = 0;
#define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \ #define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \
public: virtual ret (CALLBACK xfn)(ta a,tb b) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b) = 0;
#define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \ #define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c) = 0;
#define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \ #define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d) = 0;
#define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \ #define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d,te e) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e) = 0;
#define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \ #define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f) = 0;
#define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \ #define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g) = 0;
#define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \ #define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h) = 0;
#define ICOM_METHOD9(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \ #define ICOM_METHOD9(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh,ti,ni) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i) = 0;
#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) \ #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) \
public: virtual ret (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j) = 0; public: virtual ret CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i,tj j) = 0;
#define ICOM_VMETHOD(xfn) \ #define ICOM_VMETHOD(xfn) \
public: virtual void (CALLBACK xfn)(void) = 0; public: virtual void CALLBACK (xfn)(void) = 0;
#define ICOM_VMETHOD1(xfn,ta,na) \ #define ICOM_VMETHOD1(xfn,ta,na) \
public: virtual void (CALLBACK xfn)(ta a) = 0; public: virtual void CALLBACK (xfn)(ta a) = 0;
#define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \ #define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \
public: virtual void (CALLBACK xfn)(ta a,tb b) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b) = 0;
#define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \ #define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
public: virtual void (CALLBACK xfn)(ta a,tb b,tc c) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b,tc c) = 0;
#define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \ #define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
public: virtual void (CALLBACK xfn)(ta a,tb b,tc c,td d) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d) = 0;
#define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \ #define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
public: virtual void (CALLBACK xfn)(ta a,tb b,tc c,td d,te e) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e) = 0;
#define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \ #define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
public: virtual void (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f) = 0;
#define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \ #define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
public: virtual void (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g) = 0;
#define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \ #define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
public: virtual void (CALLBACK xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h) = 0; public: virtual void CALLBACK (xfn)(ta a,tb b,tc c,td d,te e,tf f,tg g,th h) = 0;
#ifdef ICOM_USE_COM_INTERFACE_ATTRIBUTE #ifdef ICOM_USE_COM_INTERFACE_ATTRIBUTE
@ -420,46 +420,46 @@ inline BOOL operator!=(const GUID& guidOne, const GUID& guidOther)
#ifdef __WINE__ #ifdef __WINE__
#define ICOM_METHOD(ret,xfn) \ #define ICOM_METHOD(ret,xfn) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me); ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me);
#define ICOM_METHOD1(ret,xfn,ta,na) \ #define ICOM_METHOD1(ret,xfn,ta,na) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a); ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a);
#define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \ #define ICOM_METHOD2(ret,xfn,ta,na,tb,nb) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b); ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b);
#define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \ #define ICOM_METHOD3(ret,xfn,ta,na,tb,nb,tc,nc) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c); ret CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
#define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \ #define ICOM_METHOD4(ret,xfn,ta,na,tb,nb,tc,nc,td,nd) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d); ret CALLBACK (*fn##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) \ #define ICOM_METHOD5(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e); ret CALLBACK (*fn##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) \ #define ICOM_METHOD6(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f); ret CALLBACK (*fn##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) \ #define ICOM_METHOD7(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g); ret CALLBACK (*fn##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) \ #define ICOM_METHOD8(ret,xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
ret (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h); ret CALLBACK (*fn##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) \ #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 *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h,ti i); ret CALLBACK (*fn##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) \ #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 *fn##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 (*fn##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_VMETHOD(xfn) \ #define ICOM_VMETHOD(xfn) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me); void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me);
#define ICOM_VMETHOD1(xfn,ta,na) \ #define ICOM_VMETHOD1(xfn,ta,na) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a); void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a);
#define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \ #define ICOM_VMETHOD2(xfn,ta,na,tb,nb) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b); void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b);
#define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \ #define ICOM_VMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c); void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c);
#define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \ #define ICOM_VMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d); void CALLBACK (*fn##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) \ #define ICOM_VMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e); void CALLBACK (*fn##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) \ #define ICOM_VMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f); void CALLBACK (*fn##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) \ #define ICOM_VMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g); void CALLBACK (*fn##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) \ #define ICOM_VMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,nh) \
void (CALLBACK *fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h); void CALLBACK (*fn##xfn)(ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
#define ICOM_CALL(xfn, p) ICOM_VTBL(p)->fn##xfn(p) #define ICOM_CALL(xfn, p) ICOM_VTBL(p)->fn##xfn(p)
#define ICOM_CALL1(xfn, p,a) ICOM_VTBL(p)->fn##xfn(p,a) #define ICOM_CALL1(xfn, p,a) ICOM_VTBL(p)->fn##xfn(p,a)
@ -478,65 +478,65 @@ inline BOOL operator!=(const GUID& guidOne, const GUID& guidOther)
/* WINELIB case */ /* WINELIB case */
#define ICOM_METHOD(ret,xfn) \ #define ICOM_METHOD(ret,xfn) \
ret (CALLBACK *xfn)(ICOM_INTERFACE* me); ret CALLBACK (*xfn)(ICOM_INTERFACE* me);
#define ICOM_METHOD1(ret,xfn,ta,na) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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_VMETHOD(xfn) \ #define ICOM_VMETHOD(xfn) \
void (CALLBACK *xfn)(ICOM_INTERFACE* me); void CALLBACK (*xfn)(ICOM_INTERFACE* me);
#define ICOM_VMETHOD1(xfn,ta,na) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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) \ #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_CVMETHOD(xfn) \ #define ICOM_CVMETHOD(xfn) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me); void CALLBACK (*xfn)(const ICOM_INTERFACE* me);
#define ICOM_CVMETHOD1(xfn,ta,na) \ #define ICOM_CVMETHOD1(xfn,ta,na) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a);
#define ICOM_CVMETHOD2(xfn,ta,na,tb,nb) \ #define ICOM_CVMETHOD2(xfn,ta,na,tb,nb) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b);
#define ICOM_CVMETHOD3(xfn,ta,na,tb,nb,tc,nc) \ #define ICOM_CVMETHOD3(xfn,ta,na,tb,nb,tc,nc) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c);
#define ICOM_CVMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \ #define ICOM_CVMETHOD4(xfn,ta,na,tb,nb,tc,nc,td,nd) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d);
#define ICOM_CVMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \ #define ICOM_CVMETHOD5(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e);
#define ICOM_CVMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \ #define ICOM_CVMETHOD6(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f);
#define ICOM_CVMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \ #define ICOM_CVMETHOD7(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g);
#define ICOM_CVMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \ #define ICOM_CVMETHOD8(xfn,ta,na,tb,nb,tc,nc,td,nd,te,ne,tf,nf,tg,ng,th,nh) \
void (CALLBACK *xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h); void CALLBACK (*xfn)(const ICOM_INTERFACE* me,ta a,tb b,tc c,td d,te e,tf f,tg g,th h);
#define ICOM_CALL(xfn, p) ICOM_VTBL(p)->xfn(p) #define ICOM_CALL(xfn, p) ICOM_VTBL(p)->xfn(p)
#define ICOM_CALL1(xfn, p,a) ICOM_VTBL(p)->xfn(p,a) #define ICOM_CALL1(xfn, p,a) ICOM_VTBL(p)->xfn(p,a)

2
include/wine/obj_channel.h
View File

@ -153,7 +153,7 @@ ICOM_DEFINE(IRpcProxyBuffer,IUnknown)
ICOM_METHOD1 (HRESULT, Connect, IUnknown*,pUnkServer) \ ICOM_METHOD1 (HRESULT, Connect, IUnknown*,pUnkServer) \
ICOM_VMETHOD ( Disconnect) \ ICOM_VMETHOD ( Disconnect) \
ICOM_METHOD2 (HRESULT, Invoke, RPCOLEMESSAGE*,_prpcmsg, IRpcChannelBuffer*,_pRpcChannelBuffer) \ ICOM_METHOD2 (HRESULT, Invoke, RPCOLEMESSAGE*,_prpcmsg, IRpcChannelBuffer*,_pRpcChannelBuffer) \
ICOM_METHOD1 (IRpcStubBuffer*,IsIIDSupported, REFIID,riid) \ ICOM_METHOD1 (LPRPCCHANNELBUFFER,IsIIDSupported, REFIID,riid) \
ICOM_METHOD (ULONG, CountRefs) \ ICOM_METHOD (ULONG, CountRefs) \
ICOM_METHOD1 (HRESULT, DebugServerQueryInterface, void**,ppv) \ ICOM_METHOD1 (HRESULT, DebugServerQueryInterface, void**,ppv) \
ICOM_VMETHOD1( DebugServerRelease, void*,pv) ICOM_VMETHOD1( DebugServerRelease, void*,pv)

8
include/wine/obj_misc.h
View File

@ -90,13 +90,13 @@ ICOM_DEFINE(IEnumUnknown,IUnknown)
#define IMallocSpy_METHODS \ #define IMallocSpy_METHODS \
ICOM_METHOD1 (ULONG,PreAlloc, ULONG,cbRequest) \ ICOM_METHOD1 (ULONG,PreAlloc, ULONG,cbRequest) \
ICOM_VMETHOD1( PostAlloc, void*,pActual) \ ICOM_VMETHOD1( PostAlloc, void*,pActual) \
ICOM_METHOD2 (void*,PreFree, void*,pRequest, BOOL,fSpyed) \ ICOM_METHOD2 (PVOID,PreFree, void*,pRequest, BOOL,fSpyed) \
ICOM_VMETHOD1( PostFree, BOOL,fSpyed) \ ICOM_VMETHOD1( PostFree, BOOL,fSpyed) \
ICOM_METHOD4 (ULONG,PreRealloc, void*,pRequest, ULONG,cbRequest, void**,ppNewRequest, BOOL,fSpyed) \ ICOM_METHOD4 (ULONG,PreRealloc, void*,pRequest, ULONG,cbRequest, void**,ppNewRequest, BOOL,fSpyed) \
ICOM_METHOD2 (void*,PostRealloc, void*,pActual, BOOL,fSpyed) \ ICOM_METHOD2 (PVOID,PostRealloc, void*,pActual, BOOL,fSpyed) \
ICOM_METHOD2 (void*,PreGetSize, void*,pRequest, BOOL,fSpyed) \ ICOM_METHOD2 (PVOID,PreGetSize, void*,pRequest, BOOL,fSpyed) \
ICOM_METHOD2 (ULONG,PostGetSize, ULONG,cbActual, BOOL,fSpyed) \ ICOM_METHOD2 (ULONG,PostGetSize, ULONG,cbActual, BOOL,fSpyed) \
ICOM_METHOD2 (void*,PreDidAlloc, void*,pRequest, BOOL,fSpyed) \ ICOM_METHOD2 (PVOID,PreDidAlloc, void*,pRequest, BOOL,fSpyed) \
ICOM_METHOD3 (int, PostDidAlloc, void*,pRequest, BOOL,fSpyed, int,fActual) \ ICOM_METHOD3 (int, PostDidAlloc, void*,pRequest, BOOL,fSpyed, int,fActual) \
ICOM_METHOD (int, PreHeapMinimize) \ ICOM_METHOD (int, PreHeapMinimize) \
ICOM_METHOD (int, PostHeapMinimize) ICOM_METHOD (int, PostHeapMinimize)

2
include/wine/obj_oleaut.h
View File

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

2
include/wine/obj_oleview.h
View File

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

4
include/wine/undocshell.h
View File

@ -381,7 +381,7 @@ BOOL WINAPI FileMenu_AppendItem(
#define FMF_NO_PROGRAM_GROUPS 0x04 #define FMF_NO_PROGRAM_GROUPS 0x04
/* FileMenu_InsertUsingPidl callback function */ /* FileMenu_InsertUsingPidl callback function */
typedef void (CALLBACK *LPFNFMCALLBACK)(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlFile); typedef void CALLBACK (*LPFNFMCALLBACK)(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlFile);
int WINAPI FileMenu_InsertUsingPidl( int WINAPI FileMenu_InsertUsingPidl(
HMENU hMenu, HMENU hMenu,
@ -910,7 +910,7 @@ BOOL WINAPI RegisterShellHook(
DWORD dwType); DWORD dwType);
/* SHCreateDefClassObject callback function */ /* SHCreateDefClassObject callback function */
typedef HRESULT (CALLBACK *LPFNCDCOCALLBACK)( typedef HRESULT CALLBACK (*LPFNCDCOCALLBACK)(
LPUNKNOWN pUnkOuter, LPUNKNOWN pUnkOuter,
REFIID riidObject, REFIID riidObject,
LPVOID *ppvObject); LPVOID *ppvObject);

22
include/wine/windef16.h
View File

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

12
include/wine/wingdi16.h
View File

@ -214,10 +214,10 @@ typedef struct
FONTSIGNATURE ntmeFontSignature; FONTSIGNATURE ntmeFontSignature;
} NEWTEXTMETRICEX16,*LPNEWTEXTMETRICEX16; } NEWTEXTMETRICEX16,*LPNEWTEXTMETRICEX16;
typedef INT16 (CALLBACK *FONTENUMPROC16)(SEGPTR,SEGPTR,UINT16,LPARAM); typedef INT16 CALLBACK (*FONTENUMPROC16)(SEGPTR,SEGPTR,UINT16,LPARAM);
typedef INT16 (CALLBACK *FONTENUMPROCEX16)(SEGPTR,SEGPTR,UINT16,LPARAM); typedef INT16 CALLBACK (*FONTENUMPROCEX16)(SEGPTR,SEGPTR,UINT16,LPARAM);
typedef VOID (CALLBACK *LINEDDAPROC16)(INT16,INT16,LPARAM); typedef VOID CALLBACK (*LINEDDAPROC16)(INT16,INT16,LPARAM);
typedef INT16 (CALLBACK *GOBJENUMPROC16)(SEGPTR,LPARAM); typedef INT16 CALLBACK (*GOBJENUMPROC16)(SEGPTR,LPARAM);
typedef struct typedef struct
{ {
@ -255,7 +255,7 @@ typedef struct
HMETAFILE16 hMF; HMETAFILE16 hMF;
} METAFILEPICT16, *LPMETAFILEPICT16; } METAFILEPICT16, *LPMETAFILEPICT16;
typedef INT16 (CALLBACK *MFENUMPROC16)(HDC16,HANDLETABLE16*,METARECORD*, typedef INT16 CALLBACK (*MFENUMPROC16)(HDC16,HANDLETABLE16*,METARECORD*,
INT16,LPARAM); INT16,LPARAM);
typedef struct typedef struct
{ {
@ -266,7 +266,7 @@ typedef struct
DWORD fwType; DWORD fwType;
} DOCINFO16, *LPDOCINFO16; } DOCINFO16, *LPDOCINFO16;
typedef BOOL16 (CALLBACK* ABORTPROC16)(HDC16, INT16); typedef BOOL16 CALLBACK (*ABORTPROC16)(HDC16, INT16);
#define INT_PD_DEFAULT_DEVMODE 1 #define INT_PD_DEFAULT_DEVMODE 1
#define INT_PD_DEFAULT_MODEL 2 #define INT_PD_DEFAULT_MODEL 2

2
include/wine/winuser16.h
View File

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

18
include/wingdi.h
View File

@ -1138,9 +1138,9 @@ typedef struct
DECL_WINELIB_TYPE_AW(NEWTEXTMETRICEX) DECL_WINELIB_TYPE_AW(NEWTEXTMETRICEX)
DECL_WINELIB_TYPE_AW(LPNEWTEXTMETRICEX) DECL_WINELIB_TYPE_AW(LPNEWTEXTMETRICEX)
typedef INT (CALLBACK *FONTENUMPROCA)(LPENUMLOGFONTA,LPNEWTEXTMETRICA, typedef INT CALLBACK (*FONTENUMPROCA)(LPENUMLOGFONTA,LPNEWTEXTMETRICA,
UINT,LPARAM); UINT,LPARAM);
typedef INT (CALLBACK *FONTENUMPROCW)(LPENUMLOGFONTW,LPNEWTEXTMETRICW, typedef INT CALLBACK (*FONTENUMPROCW)(LPENUMLOGFONTW,LPNEWTEXTMETRICW,
UINT,LPARAM); UINT,LPARAM);
DECL_WINELIB_TYPE_AW(FONTENUMPROC) DECL_WINELIB_TYPE_AW(FONTENUMPROC)
@ -1149,12 +1149,12 @@ typedef FONTENUMPROCW OLDFONTENUMPROCW;
DECL_WINELIB_TYPE_AW(OLDFONTENUMPROC) DECL_WINELIB_TYPE_AW(OLDFONTENUMPROC)
typedef INT (CALLBACK *FONTENUMPROCEXA)(LPENUMLOGFONTEXA,LPNEWTEXTMETRICEXA,UINT,LPARAM); typedef INT CALLBACK (*FONTENUMPROCEXA)(LPENUMLOGFONTEXA,LPNEWTEXTMETRICEXA,UINT,LPARAM);
typedef INT (CALLBACK *FONTENUMPROCEXW)(LPENUMLOGFONTEXW,LPNEWTEXTMETRICEXW,UINT,LPARAM); typedef INT CALLBACK (*FONTENUMPROCEXW)(LPENUMLOGFONTEXW,LPNEWTEXTMETRICEXW,UINT,LPARAM);
DECL_WINELIB_TYPE_AW(FONTENUMPROCEX) DECL_WINELIB_TYPE_AW(FONTENUMPROCEX)
typedef INT (CALLBACK *GOBJENUMPROC)(LPVOID,LPARAM); typedef INT CALLBACK (*GOBJENUMPROC)(LPVOID,LPARAM);
typedef VOID (CALLBACK *LINEDDAPROC)(INT,INT,LPARAM); typedef VOID CALLBACK (*LINEDDAPROC)(INT,INT,LPARAM);
/* tmPitchAndFamily bits */ /* tmPitchAndFamily bits */
#define TMPF_FIXED_PITCH 1 /* means variable pitch */ #define TMPF_FIXED_PITCH 1 /* means variable pitch */
@ -1942,7 +1942,7 @@ typedef struct
#define META_CREATEREGION 0x06FF #define META_CREATEREGION 0x06FF
#define META_UNKNOWN 0x0529 /* FIXME: unknown meta magic */ #define META_UNKNOWN 0x0529 /* FIXME: unknown meta magic */
typedef INT (CALLBACK *MFENUMPROC)(HDC,HANDLETABLE*,METARECORD*, typedef INT CALLBACK (*MFENUMPROC)(HDC,HANDLETABLE*,METARECORD*,
INT,LPARAM); INT,LPARAM);
/* enhanced metafile structures and functions */ /* enhanced metafile structures and functions */
@ -2540,7 +2540,7 @@ typedef struct {
BYTE Data[1]; BYTE Data[1];
} EMRGLSBOUNDEDRECORD, *PEMRGLSBOUNDEDRECORD; } EMRGLSBOUNDEDRECORD, *PEMRGLSBOUNDEDRECORD;
typedef INT (CALLBACK *ENHMFENUMPROC)(HDC, LPHANDLETABLE, typedef INT CALLBACK (*ENHMFENUMPROC)(HDC, LPHANDLETABLE,
LPENHMETARECORD, INT, LPVOID); LPENHMETARECORD, INT, LPVOID);
#define EMR_HEADER 1 #define EMR_HEADER 1
@ -3023,7 +3023,7 @@ typedef struct _RGNDATA {
char Buffer[1]; char Buffer[1];
} RGNDATA,*PRGNDATA,*LPRGNDATA; } RGNDATA,*PRGNDATA,*LPRGNDATA;
typedef BOOL (CALLBACK* ABORTPROC)(HDC, INT); typedef BOOL CALLBACK (*ABORTPROC)(HDC, INT);
typedef struct { typedef struct {
DWORD cb; DWORD cb;

8
include/wininet.h
View File

@ -475,7 +475,7 @@ BOOLAPI InternetGetLastResponseInfoA(LPDWORD ,LPSTR lpszBuffer ,LPDWORD);
BOOLAPI InternetGetLastResponseInfoW(LPDWORD ,LPWSTR lpszBuffer ,LPDWORD); BOOLAPI InternetGetLastResponseInfoW(LPDWORD ,LPWSTR lpszBuffer ,LPDWORD);
#define InternetGetLastResponseInfo WINELIB_NAME_AW(InternetGetLastResponseInfo); #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); LPVOID lpvStatusInformation ,DWORD);
typedef INTERNET_STATUS_CALLBACK * LPINTERNET_STATUS_CALLBACK; typedef INTERNET_STATUS_CALLBACK * LPINTERNET_STATUS_CALLBACK;
@ -902,7 +902,7 @@ INTERNETAPI HINTERNET WINAPI GopherOpenFileW(HINTERNET ,LPCWSTR ,LPCWSTR lpszVie
#define GopherOpenFile WINELIB_NAME_AW(GopherOpenFile) #define GopherOpenFile WINELIB_NAME_AW(GopherOpenFile)
/* /*
typedef BOOL (CALLBACK * GOPHER_ATTRIBUTE_ENUMERATOR)(LPGOPHER_ATTRIBUTE_TYPE ,DWORD); typedef BOOL CALLBACK (*GOPHER_ATTRIBUTE_ENUMERATOR)(LPGOPHER_ATTRIBUTE_TYPE ,DWORD);
BOOLAPI GopherGetAttributeA(HINTERNET ,LPCSTR ,LPCSTR lpszAttributeName ,LPBYTE , BOOLAPI GopherGetAttributeA(HINTERNET ,LPCSTR ,LPCSTR lpszAttributeName ,LPBYTE ,
DWORD ,LPDWORD ,GOPHER_ATTRIBUTE_ENUMERATOR lpfnEnumerator ,DWORD); DWORD ,LPDWORD ,GOPHER_ATTRIBUTE_ENUMERATOR lpfnEnumerator ,DWORD);
@ -1102,7 +1102,7 @@ BOOLAPI InternetCheckConnectionW(LPCWSTR ,DWORD ,DWORD);
#define FLAGS_ERROR_UI_SERIALIZE_DIALOGS 0x10 #define FLAGS_ERROR_UI_SERIALIZE_DIALOGS 0x10
DWORD InternetAuthNotifyCallback ( DWORD ,DWORD ,LPVOID ); 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 typedef struct
{ {
@ -1380,7 +1380,7 @@ INTERNETAPI BOOL WINAPI InternetGetConnectedState(LPDWORD ,DWORD);
#define INTERNET_CONNECTION_PROXY 4 #define INTERNET_CONNECTION_PROXY 4
#define INTERNET_CONNECTION_MODEM_BUSY 8 #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_CONNECT 0
#define INTERNET_CUSTOMDIAL_UNATTENDED 1 #define INTERNET_CUSTOMDIAL_UNATTENDED 1

2
include/winnetwk.h
View File

@ -368,7 +368,7 @@ typedef struct tagPASSWORD_CACHE_ENTRY
BYTE abResource[1]; BYTE abResource[1];
} PASSWORD_CACHE_ENTRY; } 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); UINT WINAPI WNetEnumCachedPasswords( LPSTR, WORD, BYTE, ENUMPASSWORDPROC, DWORD);
#endif /* _WINNETWK_H_ */ #endif /* _WINNETWK_H_ */

4
include/winnls.h
View File

@ -510,8 +510,8 @@ typedef struct
typedef DWORD CALTYPE; typedef DWORD CALTYPE;
typedef DWORD CALID; typedef DWORD CALID;
typedef BOOL (CALLBACK* CALINFO_ENUMPROCA)(LPSTR); typedef BOOL CALLBACK (*CALINFO_ENUMPROCA)(LPSTR);
typedef BOOL (CALLBACK* CALINFO_ENUMPROCW)(LPWSTR); typedef BOOL CALLBACK (*CALINFO_ENUMPROCW)(LPWSTR);
DECL_WINELIB_TYPE_AW(CALINFO_ENUMPROC) DECL_WINELIB_TYPE_AW(CALINFO_ENUMPROC)
BOOL WINAPI EnumCalendarInfoA(CALINFO_ENUMPROCA lpCalInfoEnumProc,LCID Locale,CALID Calendar,CALTYPE CalType); BOOL WINAPI EnumCalendarInfoA(CALINFO_ENUMPROCA lpCalInfoEnumProc,LCID Locale,CALID Calendar,CALTYPE CalType);

10
include/winnt.h
View File

@ -1109,7 +1109,7 @@ typedef struct __EXCEPTION_FRAME
* function pointer to a exception filter * 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; typedef PTOP_LEVEL_EXCEPTION_FILTER LPTOP_LEVEL_EXCEPTION_FILTER;
DWORD WINAPI UnhandledExceptionFilter( PEXCEPTION_POINTERS epointers ); DWORD WINAPI UnhandledExceptionFilter( PEXCEPTION_POINTERS epointers );
@ -1141,15 +1141,15 @@ typedef struct _NT_TIB
struct _TEB; struct _TEB;
#if defined(__i386__) && defined(__GNUC__) #if defined(__i386__) && defined(__GNUC__)
extern inline struct _TEB * WINAPI NtCurrentTeb(void); extern inline struct _TEB WINAPI *NtCurrentTeb(void);
extern inline struct _TEB * WINAPI NtCurrentTeb(void) extern inline struct _TEB WINAPI *NtCurrentTeb(void)
{ {
struct _TEB *teb; struct _TEB *teb;
__asm__(".byte 0x64\n\tmovl (0x18),%0" : "=r" (teb)); __asm__(".byte 0x64\n\tmovl (0x18),%0" : "=r" (teb));
return teb; return teb;
} }
#else #else
extern struct _TEB * WINAPI NtCurrentTeb(void); extern struct _TEB WINAPI *NtCurrentTeb(void);
#endif #endif
@ -1974,7 +1974,7 @@ typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
} IMAGE_RESOURCE_DATA_ENTRY,*PIMAGE_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 LPVOID DllHandle,DWORD Reason,LPVOID Reserved
); );

4
include/winsvc.h
View File

@ -27,8 +27,8 @@ typedef struct _SERVICE_STATUS {
/* Service main function prototype */ /* Service main function prototype */
typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR*); typedef VOID CALLBACK (*LPSERVICE_MAIN_FUNCTIONA)(DWORD,LPSTR*);
typedef VOID (CALLBACK *LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR*); typedef VOID CALLBACK (*LPSERVICE_MAIN_FUNCTIONW)(DWORD,LPWSTR*);
DECL_WINELIB_TYPE_AW(LPSERVICE_MAIN_FUNCTION) DECL_WINELIB_TYPE_AW(LPSERVICE_MAIN_FUNCTION)
/* Service start table */ /* Service start table */

6
include/winuser.h
View File

@ -1455,7 +1455,7 @@ typedef PVOID *LPMENUTEMPLATE;
#define HBMMENU_POPUP_MINIMIZE ((HBITMAP) 11) #define HBMMENU_POPUP_MINIMIZE ((HBITMAP) 11)
/* DrawState defines ... */ /* DrawState defines ... */
typedef BOOL (CALLBACK *DRAWSTATEPROC)(HDC,LPARAM,WPARAM,INT,INT); typedef BOOL CALLBACK (*DRAWSTATEPROC)(HDC,LPARAM,WPARAM,INT,INT);
/* WM_H/VSCROLL commands */ /* WM_H/VSCROLL commands */
#define SB_LINEUP 0 #define SB_LINEUP 0
@ -1802,7 +1802,7 @@ typedef struct
POINT MousePos; /* Mouse Position in screen co-ordinates */ POINT MousePos; /* Mouse Position in screen co-ordinates */
} HELPINFO,*LPHELPINFO; } HELPINFO,*LPHELPINFO;
typedef void (CALLBACK *MSGBOXCALLBACK)(LPHELPINFO lpHelpInfo); typedef void CALLBACK (*MSGBOXCALLBACK)(LPHELPINFO lpHelpInfo);
typedef struct typedef struct
{ {
@ -1906,7 +1906,7 @@ typedef struct tagMONITORINFOEXW
DECL_WINELIB_TYPE_AW(MONITORINFOEX) DECL_WINELIB_TYPE_AW(MONITORINFOEX)
DECL_WINELIB_TYPE_AW(LPMONITORINFOEX) DECL_WINELIB_TYPE_AW(LPMONITORINFOEX)
typedef BOOL (CALLBACK *MONITORENUMPROC)(HMONITOR,HDC,LPRECT,LPARAM); typedef BOOL CALLBACK (*MONITORENUMPROC)(HMONITOR,HDC,LPRECT,LPARAM);
/* FIXME: use this instead of LPCVOID for CreateDialogIndirectParam /* FIXME: use this instead of LPCVOID for CreateDialogIndirectParam
and DialogBoxIndirectParam */ and DialogBoxIndirectParam */