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

Moved all Win16 definitions out of the standard Windows headers.

This commit is contained in:
Alexandre Julliard 2000-09-26 22:20:14 +00:00
parent 4ca7e6343f
commit 83f52d11c1
116 changed files with 1721 additions and 1757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
controls/listbox.c
View File

@ -2830,7 +2830,7 @@ static inline LRESULT WINAPI ListBoxWndProc_locked( WND* wnd, UINT msg,
case WM_DRAGMOVE:
if( !descr->lphc )
{
LPDRAGINFO dragInfo = (LPDRAGINFO)PTR_SEG_TO_LIN( (SEGPTR)lParam );
LPDRAGINFO16 dragInfo = (LPDRAGINFO16)PTR_SEG_TO_LIN( (SEGPTR)lParam );
dragInfo->l = LISTBOX_GetItemFromPoint( wnd, descr, dragInfo->pt.x,
dragInfo->pt.y );
return SendMessageA( descr->owner, msg, wParam, lParam );

6
controls/menu.c
View File

@ -2205,7 +2205,7 @@ BOOL MENU_IsMenuActive(void)
*
* Walks menu chain trying to find a menu pt maps to.
*/
static HMENU MENU_PtMenu( HMENU hMenu, POINT16 pt )
static HMENU MENU_PtMenu( HMENU hMenu, POINT pt )
{
POPUPMENU *menu = MENU_GetMenu( hMenu );
register UINT ht = menu->FocusedItem;
@ -2749,9 +2749,7 @@ static INT MENU_TrackMenu( HMENU hmenu, UINT wFlags, INT x, INT y,
if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST))
{
/* Find a menu for this mouse event */
POINT16 pt16;
CONV_POINT32TO16( &msg.pt, &pt16 );
hmenu = MENU_PtMenu( mt.hTopMenu, pt16 );
hmenu = MENU_PtMenu( mt.hTopMenu, msg.pt );
switch(msg.message)
{

3
controls/scroll.c
View File

@ -1136,7 +1136,8 @@ LRESULT WINAPI ScrollBarWndProc( HWND hwnd, UINT message, WPARAM wParam,
case WM_SYSTIMER:
{
POINT pt;
CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
pt.x = SLOWORD(lParam);
pt.y = SHIWORD(lParam);
SCROLL_HandleScrollEvent( hwnd, SB_CTL, message, pt );
}
break;

6
dlls/comctl32/progress.c
View File

@ -262,7 +262,7 @@ static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message,
UNKNOWN_PARAM(PBM_DELTAPOS, wParam, lParam);
temp = infoPtr->CurVal;
if(wParam != 0){
infoPtr->CurVal += (UINT16)wParam;
infoPtr->CurVal += (WORD)wParam;
PROGRESS_CoercePos (hwnd);
PROGRESS_Refresh (hwnd);
}
@ -273,7 +273,7 @@ static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message,
UNKNOWN_PARAM(PBM_SETPOS, wParam, lParam);
temp = infoPtr->CurVal;
if(temp != wParam){
infoPtr->CurVal = (UINT16)wParam;
infoPtr->CurVal = (WORD)wParam;
PROGRESS_CoercePos(hwnd);
PROGRESS_Refresh (hwnd);
}
@ -297,7 +297,7 @@ static LRESULT WINAPI ProgressWindowProc(HWND hwnd, UINT message,
if (lParam)
UNKNOWN_PARAM(PBM_SETSTEP, wParam, lParam);
temp = infoPtr->Step;
infoPtr->Step = (UINT16)wParam;
infoPtr->Step = (WORD)wParam;
return temp;
case PBM_STEPIT:

4
dlls/comctl32/status.c
View File

@ -29,8 +29,8 @@ typedef struct
typedef struct
{
UINT16 numParts;
UINT16 textHeight;
WORD numParts;
WORD textHeight;
UINT height;
BOOL simple;
HWND hwndToolTip;

24
dlls/comctl32/treeview.c
View File

@ -3526,8 +3526,8 @@ TREEVIEW_TrackMouse(TREEVIEW_INFO *infoPtr, POINT pt)
{
if (msg.message == WM_MOUSEMOVE)
{
pt.x = (LONG)(INT16)LOWORD(msg.lParam);
pt.y = (LONG)(INT16)HIWORD(msg.lParam);
pt.x = SLOWORD(msg.lParam);
pt.y = SHIWORD(msg.lParam);
if (PtInRect(&r, pt))
continue;
else
@ -3571,8 +3571,8 @@ TREEVIEW_LButtonDoubleClick(TREEVIEW_INFO *infoPtr, LPARAM lParam)
KillTimer(infoPtr->hwnd, TV_EDIT_TIMER);
}
hit.pt.x = (LONG)(INT16)LOWORD(lParam);
hit.pt.y = (LONG)(INT16)HIWORD(lParam);
hit.pt.x = SLOWORD(lParam);
hit.pt.y = SHIWORD(lParam);
wineItem = (TREEVIEW_ITEM *)TREEVIEW_HitTest(infoPtr, &hit);
if (!wineItem)
@ -3642,8 +3642,8 @@ TREEVIEW_LButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
return 0;
}
ht.pt.x = (LONG)(INT16)LOWORD(lParam);
ht.pt.y = (LONG)(INT16)HIWORD(lParam);
ht.pt.x = SLOWORD(lParam);
ht.pt.y = SHIWORD(lParam);
TREEVIEW_HitTest(infoPtr, &ht);
TRACE("item %d \n", TREEVIEW_GetItemIndex(infoPtr, ht.hItem));
@ -3791,8 +3791,8 @@ TREEVIEW_RButtonDown(TREEVIEW_INFO *infoPtr, LPARAM lParam)
return 0;
}
ht.pt.x = (LONG)(INT16)LOWORD(lParam);
ht.pt.y = (LONG)(INT16)HIWORD(lParam);
ht.pt.x = SLOWORD(lParam);
ht.pt.y = SHIWORD(lParam);
TREEVIEW_HitTest(infoPtr, &ht);
@ -4205,7 +4205,7 @@ TREEVIEW_VScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
case SB_THUMBPOSITION:
newFirstVisible = TREEVIEW_GetListItem(infoPtr,
infoPtr->root->firstChild,
(LONG)(INT16)HIWORD(wParam));
(LONG)(SHORT)HIWORD(wParam));
break;
case SB_ENDSCROLL:
@ -4265,7 +4265,7 @@ TREEVIEW_HScroll(TREEVIEW_INFO *infoPtr, WPARAM wParam)
case SB_THUMBTRACK:
case SB_THUMBPOSITION:
scrollX = (int)(INT16)HIWORD(wParam);
scrollX = (int)(SHORT)HIWORD(wParam);
break;
case SB_ENDSCROLL:
@ -4655,8 +4655,8 @@ TREEVIEW_Size(TREEVIEW_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
{
if (wParam == SIZE_RESTORED)
{
infoPtr->clientWidth = (LONG)(INT16)LOWORD(lParam);
infoPtr->clientHeight = (LONG)(INT16)HIWORD(lParam);
infoPtr->clientWidth = SLOWORD(lParam);
infoPtr->clientHeight = SHIWORD(lParam);
TREEVIEW_RecalculateVisibleOrder(infoPtr, NULL);
TREEVIEW_SetFirstVisible(infoPtr, infoPtr->firstVisible, TRUE);

3
dlls/comctl32/updown.c
View File

@ -810,7 +810,8 @@ static LRESULT WINAPI UpDownWindowProc(HWND hwnd, UINT message, WPARAM wParam,
case WM_MOUSEMOVE:
if(UPDOWN_IsEnabled(hwnd)){
POINT pt;
CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
pt.x = SLOWORD(lParam);
pt.y = SHIWORD(lParam);
UPDOWN_HandleMouseEvent (hwnd, message, pt );
}
break;

1
dlls/commdlg/cdlg.h
View File

@ -8,6 +8,7 @@
#define _WINE_DLL_CDLG_H
#include "dlgs.h"
#include "wine/windef16.h"
/*---------------- 16-bit ----------------*/
extern HINSTANCE16 COMMDLG_hInstance;

13
dlls/commdlg/colordlg.c
View File

@ -34,9 +34,8 @@ DEFAULT_DEBUG_CHANNEL(commdlg);
static LRESULT WINAPI ColorDlgProc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam );
#define CONV_POINTSTOPOINT( ps, p ) \
((p)->x = (LONG)(ps)->x, (p)->y = (LONG)(ps)->y)
#define CONV_LPARAMTOPOINT(lp,p) do { (p)->x = SLOWORD(lp); (p)->y = SHIWORD(lp); } while(0)
static const COLORREF predefcolors[6][8]=
{
{ 0x008080FFL, 0x0080FFFFL, 0x0080FF80L, 0x0080FF00L,
@ -243,7 +242,7 @@ static int CC_MouseCheckPredefColorArray( LCCPRIV lpp, HWND hDlg, int dlgitem, i
RECT rect;
int dx, dy, x, y;
CONV_POINTSTOPOINT(&(MAKEPOINTS(lParam)) , &point);
CONV_LPARAMTOPOINT(lParam, &point);
ClientToScreen(hDlg, &point);
hwnd = GetDlgItem(hDlg, dlgitem);
GetWindowRect(hwnd, &rect);
@ -278,7 +277,7 @@ static int CC_MouseCheckUserColorArray( LCCPRIV lpp, HWND hDlg, int dlgitem, int
int dx, dy, x, y;
COLORREF *crarr = lpp->lpcc->lpCustColors;
CONV_POINTSTOPOINT(&(MAKEPOINTS(lParam)), &point);
CONV_LPARAMTOPOINT(lParam, &point);
ClientToScreen(hDlg, &point);
hwnd = GetDlgItem(hDlg, dlgitem);
GetWindowRect(hwnd, &rect);
@ -320,7 +319,7 @@ static int CC_MouseCheckColorGraph( HWND hDlg, int dlgitem, int *hori, int *vert
RECT rect;
long x,y;
CONV_POINTSTOPOINT(&(MAKEPOINTS(lParam)), &point);
CONV_LPARAMTOPOINT(lParam, &point);
ClientToScreen(hDlg, &point);
hwnd = GetDlgItem( hDlg, dlgitem );
GetWindowRect(hwnd, &rect);
@ -353,7 +352,7 @@ static int CC_MouseCheckResultWindow( HWND hDlg, LPARAM lParam )
POINT point;
RECT rect;
CONV_POINTSTOPOINT(&(MAKEPOINTS(lParam)), &point);
CONV_LPARAMTOPOINT(lParam, &point);
ClientToScreen(hDlg, &point);
hwnd = GetDlgItem(hDlg, 0x2c5);
GetWindowRect(hwnd, &rect);

1
dlls/dsound/dsound_main.c
View File

@ -38,6 +38,7 @@
#include "winuser.h"
#include "winerror.h"
#include "mmsystem.h"
#include "wine/windef16.h"
#include "debugtools.h"
#include "initguid.h"

2
dlls/gdi/bidi16.c
View File

@ -4,7 +4,7 @@
*/
#include "windef.h"
#include "wingdi.h"
#include "wine/wingdi16.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(gdi);

1
dlls/gdi/printdrv.c
View File

@ -15,6 +15,7 @@
#include <fcntl.h>
#include "ldt.h"
#include "winbase.h"
#include "wine/winbase16.h"
#include "wine/wingdi16.h"
#include "winspool.h"
#include "winerror.h"

1
dlls/kernel/stress.c
View File

@ -1,5 +1,6 @@
#include <limits.h>
#include "windef.h"
#include "wine/windef16.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(stress);

1
dlls/kernel/utthunk.c
View File

@ -5,7 +5,6 @@
*/
#include "wine/winbase16.h"
#include "windef.h"
#include "heap.h"
#include "module.h"
#include "selectors.h"

18
dlls/kernel/wowthunk.c
View File

@ -17,6 +17,24 @@
DEFAULT_DEBUG_CHANNEL(thunk);
/*
* These are the 16-bit side WOW routines. They reside in wownt16.h
* in the SDK; since we don't support Win16 source code anyway, I've
* placed them here for compilation with Wine ...
*/
DWORD WINAPI GetVDMPointer32W16(SEGPTR,UINT16);
DWORD WINAPI LoadLibraryEx32W16(LPCSTR,DWORD,DWORD);
DWORD WINAPI GetProcAddress32W16(DWORD,LPCSTR);
DWORD WINAPI FreeLibrary32W16(DWORD);
#define CPEX_DEST_STDCALL 0x00000000L
#define CPEX_DEST_CDECL 0x80000000L
DWORD WINAPI CallProcExW16(VOID);
DWORD WINAPI CallProcEx32W16(VOID);
/*
* 32-bit WOW routines (in WOW32, but actually forwarded to KERNEL32)
*/

9
dlls/lzexpand/lzexpand_main.c
View File

@ -22,6 +22,15 @@
DEFAULT_DEBUG_CHANNEL(file);
LONG WINAPI CopyLZFile16(HFILE16,HFILE16);
INT16 WINAPI GetExpandedName16(LPCSTR,LPSTR);
void WINAPI LZClose16(HFILE16);
LONG WINAPI LZCopy16(HFILE16,HFILE16);
HFILE16 WINAPI LZInit16(HFILE16);
HFILE16 WINAPI LZOpenFile16(LPCSTR,LPOFSTRUCT,UINT16);
INT16 WINAPI LZRead16(HFILE16,LPVOID,UINT16);
LONG WINAPI LZSeek16(HFILE16,LONG,INT16);
INT16 WINAPI LZStart16(void);
/* The readahead length of the decompressor. Reading single bytes
* using _lread() would be SLOW.

5
dlls/msacm/msacm_main.c
View File

@ -6,10 +6,13 @@
#include "winbase.h"
#include "winerror.h"
#include "mmsystem.h"
#include "msacm.h"
#include "msacmdrv.h"
#include "wineacm.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(msacm)
DEFAULT_DEBUG_CHANNEL(msacm);
/***********************************************************************
* acmGetVersion (MSACM.7)

2
dlls/msacm/msacmdrv.h
View File

@ -6,6 +6,7 @@
#define __WINE_MSACMDRV_H
#include "windef.h"
#include "wine/windef16.h"
#include "msacm.h"
/***********************************************************************
@ -114,7 +115,6 @@ typedef struct _ACMDRVSTREAMINSTANCE
HACMSTREAM has;
} ACMDRVSTREAMINSTANCE, *PACMDRVSTREAMINSTANCE;
typedef struct _ACMDRVSTREAMHEADER16 *LPACMDRVSTREAMHEADER16;
typedef struct _ACMDRVSTREAMHEADER16 {
DWORD cbStruct;

266
dlls/msacm/wineacm.h
View File

@ -1,4 +1,268 @@
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
#ifndef __WINE_WINEACM_H
#define __WINE_WINEACM_H
#include "wine/windef16.h"
#include "wine/mmsystem16.h"
/***********************************************************************
* Win16 definitions
*/
typedef BOOL16 CALLBACK (*ACMDRIVERENUMCB16)(
HACMDRIVERID16 hadid, DWORD dwInstance, DWORD fdwSupport
);
typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROC16)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
typedef UINT16 CALLBACK (*ACMFORMATCHOOSEHOOKPROC16)(
HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam
);
typedef struct _ACMDRIVERDETAILS16
{
DWORD cbStruct;
FOURCC fccType;
FOURCC fccComp;
WORD wMid;
WORD wPid;
DWORD vdwACM;
DWORD vdwDriver;
DWORD fdwSupport;
DWORD cFormatTags;
DWORD cFilterTags;
HICON16 hicon;
CHAR szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS];
CHAR szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS];
CHAR szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS];
CHAR szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS];
CHAR szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS];
} ACMDRIVERDETAILS16, *NPACMDRIVERDETAILS16, *LPACMDRIVERDETAILS16;
typedef struct _ACMFILTERCHOOSE16
{
DWORD cbStruct;
DWORD fdwStyle;
HWND16 hwndOwner;
LPWAVEFILTER pwfltr;
DWORD cbwfltr;
LPCSTR pszTitle;
char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
char szFilter[ACMFILTERDETAILS_FILTER_CHARS];
LPSTR pszName;
DWORD cchName;
DWORD fdwEnum;
LPWAVEFILTER pwfltrEnum;
HINSTANCE16 hInstance;
LPCSTR pszTemplateName;
LPARAM lCustData;
ACMFILTERCHOOSEHOOKPROC16 pfnHook;
} ACMFILTERCHOOSE16, *NPACMFILTERCHOOSE16, *LPACMFILTERCHOOSE16;
typedef struct _ACMFILTERDETAILS16
{
DWORD cbStruct;
DWORD dwFilterIndex;
DWORD dwFilterTag;
DWORD fdwSupport;
LPWAVEFILTER pwfltr;
DWORD cbwfltr;
CHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS];
} ACMFILTERDETAILS16, *NPACMFILTERDETAILS16, *LPACMFILTERDETAILS16;
typedef struct _ACMFILTERTAGDETAILS16
{
DWORD cbStruct;
DWORD dwFilterTagIndex;
DWORD dwFilterTag;
DWORD cbFilterSize;
DWORD fdwSupport;
DWORD cStandardFilters;
CHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
} ACMFILTERTAGDETAILS16, *NPACMFILTERTAGDETAILS16, *LPACMFILTERTAGDETAILS16;
typedef struct _ACMFORMATCHOOSE16
{
DWORD cbStruct;
DWORD fdwStyle;
HWND16 hwndOwner;
LPWAVEFORMATEX pwfx;
DWORD cbwfx;
LPCSTR pszTitle;
CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
LPSTR pszName;
DWORD cchName;
DWORD fdwEnum;
LPWAVEFORMATEX pwfxEnum;
HINSTANCE16 hInstance;
LPCSTR pszTemplateName;
LPARAM lCustData;
ACMFORMATCHOOSEHOOKPROC16 pfnHook;
} ACMFORMATCHOOSE16, *NPACMFORMATCHOOSE16, *LPACMFORMATCHOOSE16;
typedef struct _ACMFORMATDETAILS16
{
DWORD cbStruct;
DWORD dwFormatIndex;
DWORD dwFormatTag;
DWORD fdwSupport;
LPWAVEFORMATEX pwfx;
DWORD cbwfx;
CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
} ACMFORMATDETAILS16, *NPACMFORMATDETAILS16, *LPACMFORMATDETAILS16;
typedef struct _ACMFORMATTAGDETAILS16
{
DWORD cbStruct;
DWORD dwFormatTagIndex;
DWORD dwFormatTag;
DWORD cbFormatSize;
DWORD fdwSupport;
DWORD cStandardFormats;
CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
} ACMFORMATTAGDETAILS16, *NPACMFORMATTAGDETAILS16, *LPACMFORMATTAGDETAILS16;
typedef ACMSTREAMHEADER ACMSTREAMHEADER16, *NPACMSTREAMHEADER16, *LPACMSTREAMHEADER16;
typedef BOOL16 CALLBACK (*ACMFILTERENUMCB16)(
HACMDRIVERID16 hadid, LPACMFILTERDETAILS16 pafd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL16 CALLBACK (*ACMFILTERTAGENUMCB16)(
HACMDRIVERID16 hadid, LPACMFILTERTAGDETAILS16 paftd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL16 CALLBACK (*ACMFORMATENUMCB16)(
HACMDRIVERID16 hadid, LPACMFORMATDETAILS16 pafd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL16 CALLBACK (*ACMFORMATTAGENUMCB16)(
HACMDRIVERID16 hadid, LPACMFORMATTAGDETAILS16 paftd,
DWORD dwInstance, DWORD fdwSupport
);
/***********************************************************************
* Functions - Win16
*/
DWORD WINAPI acmGetVersion16(
);
MMRESULT16 WINAPI acmMetrics16(
HACMOBJ16 hao, UINT16 uMetric, LPVOID pMetric
);
MMRESULT16 WINAPI acmDriverEnum16(
ACMDRIVERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmDriverDetails16(
HACMDRIVERID16 hadid, LPACMDRIVERDETAILS16 padd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmDriverAdd16(
LPHACMDRIVERID16 phadid, HINSTANCE16 hinstModule,
LPARAM lParam, DWORD dwPriority, DWORD fdwAdd
);
MMRESULT16 WINAPI acmDriverRemove16(
HACMDRIVERID16 hadid, DWORD fdwRemove
);
MMRESULT16 WINAPI acmDriverOpen16(
LPHACMDRIVER16 phad, HACMDRIVERID16 hadid, DWORD fdwOpen
);
MMRESULT16 WINAPI acmDriverClose16(
HACMDRIVER16 had, DWORD fdwClose
);
LRESULT WINAPI acmDriverMessage16(
HACMDRIVER16 had, UINT16 uMsg, LPARAM lParam1, LPARAM lParam2
);
MMRESULT16 WINAPI acmDriverID16(
HACMOBJ16 hao, LPHACMDRIVERID16 phadid, DWORD fdwDriverID
);
MMRESULT16 WINAPI acmDriverPriority16(
HACMDRIVERID16 hadid, DWORD dwPriority, DWORD fdwPriority
);
MMRESULT16 WINAPI acmFormatTagDetails16(
HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFormatTagEnum16(
HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd,
ACMFORMATTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmFormatChoose16(
LPACMFORMATCHOOSE16 pafmtc
);
MMRESULT16 WINAPI acmFormatDetails16(
HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFormatEnum16(
HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd,
ACMFORMATENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmFormatSuggest16(
HACMDRIVER16 had, LPWAVEFORMATEX pwfxSrc,
LPWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest
);
MMRESULT16 WINAPI acmFilterTagDetails16(
HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFilterTagEnum16(
HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd,
ACMFILTERTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmFilterChoose16(
LPACMFILTERCHOOSE16 pafltrc
);
MMRESULT16 WINAPI acmFilterDetails16(
HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFilterEnum16(
HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd,
ACMFILTERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmStreamOpen16(
LPHACMSTREAM16 phas, HACMDRIVER16 had,
LPWAVEFORMATEX pwfxSrc, LPWAVEFORMATEX pwfxDst,
LPWAVEFILTER pwfltr, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen
);
MMRESULT16 WINAPI acmStreamClose16(
HACMSTREAM16 has, DWORD fdwClose
);
MMRESULT16 WINAPI acmStreamSize16(
HACMSTREAM16 has, DWORD cbInput,
LPDWORD pdwOutputBytes, DWORD fdwSize
);
MMRESULT16 WINAPI acmStreamConvert16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwConvert
);
MMRESULT16 WINAPI acmStreamReset16(
HACMSTREAM16 has, DWORD fdwReset
);
MMRESULT16 WINAPI acmStreamPrepareHeader16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwPrepare
);
MMRESULT16 WINAPI acmStreamUnprepareHeader16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwUnprepare
);
/***********************************************************************
* Wine specific - Win32
@ -80,3 +344,5 @@ extern HINSTANCE MSACM_hInstance32;
#define IDD_ACMFILTERCHOOSE_CMB_FILTER 102
#define IDD_ACMFILTERCHOOSE_BTN_SETNAME 103
#define IDD_ACMFILTERCHOOSE_BTN_DELNAME 104
#endif /* __WINE_WINEACM_H */

2
dlls/msvideo/drawdib.c
View File

@ -10,8 +10,10 @@
#include "wingdi.h"
#include "winuser.h"
#include "winbase.h"
#include "wine/winbase16.h"
#include "debugtools.h"
#include "vfw.h"
#include "vfw16.h"
#include "windef.h"
DEFAULT_DEBUG_CHANNEL(msvideo);

2
dlls/msvideo/msvideo_main.c
View File

@ -15,6 +15,8 @@
#include "wingdi.h"
#include "winuser.h"
#include "vfw.h"
#include "vfw16.h"
#include "wine/winbase16.h"
#include "wine/winestring.h"
#include "debugtools.h"
#include "ldt.h"

107
dlls/msvideo/vfw16.h Normal file
View File

@ -0,0 +1,107 @@
#ifndef __WINE_VFW16_H
#define __WINE_VFW16_H
#include "vfw.h"
#include "wine/windef16.h"
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef HANDLE16 HDRAWDIB16;
#include "pshpack1.h"
typedef struct {
DWORD dwSize;
DWORD fccType;
DWORD fccHandler;
DWORD dwFlags;
DWORD dwVersion;
DWORD dwVersionICM;
/*
* under Win16, normal chars are used
*/
CHAR szName[16];
CHAR szDescription[128];
CHAR szDriver[128];
} ICINFO16;
typedef struct {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiSrc;
LPVOID lpSrc;
LPBITMAPINFOHEADER lpbiDst;
LPVOID lpDst;
INT16 xDst; /* destination rectangle */
INT16 yDst;
INT16 dxDst;
INT16 dyDst;
INT16 xSrc; /* source rectangle */
INT16 ySrc;
INT16 dxSrc;
INT16 dySrc;
} ICDECOMPRESSEX16;
typedef struct {
DWORD dwFlags;
HPALETTE16 hpal;
HWND16 hwnd;
HDC16 hdc;
INT16 xDst;
INT16 yDst;
INT16 dxDst;
INT16 dyDst;
LPBITMAPINFOHEADER lpbi;
INT16 xSrc;
INT16 ySrc;
INT16 dxSrc;
INT16 dySrc;
DWORD dwRate;
DWORD dwScale;
} ICDRAWBEGIN16;
#include "poppack.h"
LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD dw1, DWORD dw2);
HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHangler, UINT16 wMode);
HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
typedef struct {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiIn;
LPBITMAPINFOHEADER lpbiSuggest;
INT16 dxSrc;
INT16 dySrc;
INT16 dxDst;
INT16 dyDst;
HIC16 hicDecompressor;
} ICDRAWSUGGEST16;
DWORD VFWAPIV ICDrawBegin16(
HIC16 hic,
DWORD dwFlags,/* flags */
HPALETTE16 hpal, /* palette to draw with */
HWND16 hwnd, /* window to draw to */
HDC16 hdc, /* HDC to draw to */
INT16 xDst, /* destination rectangle */
INT16 yDst,
INT16 dxDst,
INT16 dyDst,
LPBITMAPINFOHEADER lpbi, /* format of frame to draw */
INT16 xSrc, /* source rectangle */
INT16 ySrc,
INT16 dxSrc,
INT16 dySrc,
DWORD dwRate, /* frames/second = (dwRate/dwScale) */
DWORD dwScale
);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __WINE_VFW16_H */

1
dlls/ole32/compobj.c
View File

@ -32,6 +32,7 @@
#include "wine/obj_storage.h"
#include "wine/obj_clientserver.h"
#include "ole.h"
#include "ifs.h"
#include "compobj.h"

3
dlls/ole32/ifs.c
View File

@ -17,9 +17,10 @@
#include "module.h"
#include "debugtools.h"
#include "ole.h"
#include "ifs.h"
DEFAULT_DEBUG_CHANNEL(relay)
DEFAULT_DEBUG_CHANNEL(relay);
/* --- IUnknown implementation */

1
dlls/ole32/ole2nls.c
View File

@ -13,6 +13,7 @@
#include "windef.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/windef16.h"
#include "heap.h"
#include "options.h"
#include "winver.h"

1
dlls/oleaut32/ole2disp.c
View File

@ -8,6 +8,7 @@
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "wine/windef16.h"
#include "olectl.h"
#include "oleauto.h"
#include "heap.h"

1
dlls/oleaut32/typelib.c
View File

@ -32,6 +32,7 @@
#include "winreg.h" /* for HKEY_LOCAL_MACHINE */
#include "winnls.h" /* for PRIMARYLANGID */
#include "wine/winestring.h"
#include "ole.h"
#include "heap.h"
#include "wine/obj_base.h"
#include "debugtools.h"

3
dlls/oleaut32/typelib.h
View File

@ -8,9 +8,8 @@
#ifndef _WINE_TYPELIB_H
#define _WINE_TYPELIB_H
#include "oleauto.h"
#include "wine/windef16.h"
#define TLBMAGIC2 "MSFT"
#define TLBMAGIC1 "SLTG"

2
dlls/olecli/olecli_main.c
View File

@ -6,7 +6,7 @@
/* At the moment, these are only empty stubs.
*/
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wtypes.h"
#include "ldt.h"

2
dlls/olesvr/olesvr_main.c
View File

@ -7,7 +7,7 @@
/* At the moment, these are only empty stubs.
*/
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "wtypes.h"
#include "ole.h"

1
dlls/rpcrt4/rpcrt4_main.c
View File

@ -6,6 +6,7 @@
#include "config.h"
#include "windef.h"
#include "wine/windef16.h"
#include "winerror.h"
#include "winbase.h"
#include "rpc.h"

3
dlls/setupapi/setupx_main.c
View File

@ -6,7 +6,8 @@
* FIXME: Rather non-functional functions for now.
*/
#include "windows.h"
#include "winreg.h"
#include "wine/winuser16.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(setupx);

6
dlls/shell32/pidl.c
View File

@ -1225,11 +1225,11 @@ LPITEMIDLIST _ILCreateSpecial(LPCSTR szGUID)
* uInSize = size of data (raw)
*/
LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT uInSize)
{
LPITEMIDLIST pidlOut = NULL, pidlTemp = NULL;
LPPIDLDATA pData;
UINT16 uSize = 0;
UINT uSize = 0;
LPSTR pszDest;
TRACE("(0x%02x %p %i)\n",type,pIn,uInSize);
@ -1307,7 +1307,7 @@ LPITEMIDLIST _ILCreate(PIDLTYPE type, LPCVOID pIn, UINT16 uInSize)
* RETURNS
* strlen (lpszText)
*/
DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT16 uSize)
DWORD _ILGetDrive(LPCITEMIDLIST pidl,LPSTR pOut, UINT uSize)
{ TRACE("(%p,%p,%u)\n",pidl,pOut,uSize);
if(_ILIsMyComputer(pidl))

4
dlls/shell32/pidl.h
View File

@ -127,7 +127,7 @@ void _ILGetFileType (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize);
DWORD _ILGetFileAttributes (LPCITEMIDLIST pidl, LPSTR pOut, UINT uOutSize);
BOOL _ILGetFileDateTime (LPCITEMIDLIST pidl, FILETIME *ft);
DWORD _ILGetDrive (LPCITEMIDLIST, LPSTR, UINT16);
DWORD _ILGetDrive (LPCITEMIDLIST, LPSTR, UINT);
/*
* testing simple pidls
@ -143,7 +143,7 @@ BOOL _ILIsPidlSimple (LPCITEMIDLIST pidl);
/*
* simple pidls from strings
*/
LPITEMIDLIST _ILCreate (PIDLTYPE,LPCVOID,UINT16);
LPITEMIDLIST _ILCreate (PIDLTYPE,LPCVOID,UINT);
LPITEMIDLIST _ILCreateDesktop (void);
LPITEMIDLIST _ILCreateMyComputer (void);

22
dlls/shell32/shell.c
View File

@ -964,17 +964,6 @@ HICON16 WINAPI ExtractIconEx16(
return ret;
}
/*************************************************************************
* ExtractAssociatedIconA
*
* Return icon for given file (either from file itself or from associated
* executable) and patch parameters if needed.
*/
HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
{ TRACE("\n");
return ExtractAssociatedIcon16(hInst,lpIconPath,lpiIcon);
}
/*************************************************************************
* ExtractAssociatedIcon [SHELL.36]
*
@ -1017,6 +1006,17 @@ HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16 hInst, LPSTR lpIconPath, LPWO
return hIcon;
}
/*************************************************************************
* ExtractAssociatedIconA
*
* Return icon for given file (either from file itself or from associated
* executable) and patch parameters if needed.
*/
HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
{ TRACE("\n");
return ExtractAssociatedIcon16(hInst,lpIconPath,lpiIcon);
}
/*************************************************************************
* FindEnvironmentString [SHELL.38]
*

4
dlls/shell32/shell32_main.c
View File

@ -612,7 +612,7 @@ BOOL WINAPI AboutDlgProc( HWND hWnd, UINT msg, WPARAM wParam,
case WM_QUERYDROPOBJECT:
if( wParam == 0 )
{ LPDRAGINFO lpDragInfo = (LPDRAGINFO)PTR_SEG_TO_LIN((SEGPTR)lParam);
{ LPDRAGINFO16 lpDragInfo = (LPDRAGINFO16)PTR_SEG_TO_LIN((SEGPTR)lParam);
if( lpDragInfo && lpDragInfo->wFlags == DRAGOBJ_DATA )
{ RECT rect;
if( __get_dropline( hWnd, &rect ) )
@ -631,7 +631,7 @@ BOOL WINAPI AboutDlgProc( HWND hWnd, UINT msg, WPARAM wParam,
case WM_DROPOBJECT:
if( wParam == hWnd )
{ LPDRAGINFO lpDragInfo = (LPDRAGINFO)PTR_SEG_TO_LIN((SEGPTR)lParam);
{ LPDRAGINFO16 lpDragInfo = (LPDRAGINFO16)PTR_SEG_TO_LIN((SEGPTR)lParam);
if( lpDragInfo && lpDragInfo->wFlags == DRAGOBJ_DATA && lpDragInfo->hList )
{ char* pstr = (char*)GlobalLock16( (HGLOBAL16)(lpDragInfo->hList) );
if( pstr )

16
dlls/shell32/shell32_main.h
View File

@ -14,6 +14,7 @@
#include "wine/obj_shellview.h"
#include "wine/obj_shelllink.h"
#include "wine/obj_extracticon.h"
#include "wine/windef16.h"
/*******************************************
* global SHELL32.DLL variables
@ -160,10 +161,21 @@ void FreeChangeNotifications(void);
/* file operation */
BOOL SHELL_DeleteDirectoryA(LPCSTR pszDir, BOOL bShowUI);
HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16,LPCSTR,UINT16,WORD);
extern HINSTANCE SHELL_FindExecutable(LPCSTR,LPCSTR ,LPSTR);
/* 16-bit functions */
void WINAPI DragAcceptFiles16(HWND16 hWnd, BOOL16 b);
UINT16 WINAPI DragQueryFile16(HDROP16 hDrop, WORD wFile, LPSTR lpszFile, WORD wLength);
void WINAPI DragFinish16(HDROP16 h);
BOOL16 WINAPI DragQueryPoint16(HDROP16 hDrop, POINT16 *p);
HINSTANCE16 WINAPI ShellExecute16(HWND16,LPCSTR,LPCSTR,LPCSTR,LPCSTR,INT16);
HICON16 WINAPI ExtractIcon16(HINSTANCE16,LPCSTR,UINT16);
HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16,LPSTR,LPWORD);
HICON16 WINAPI ExtractIconEx16 ( LPCSTR, INT16, HICON16 *, HICON16 *, UINT16 );
HINSTANCE16 WINAPI FindExecutable16(LPCSTR,LPCSTR,LPSTR);
HGLOBAL16 WINAPI InternalExtractIcon16(HINSTANCE16,LPCSTR,UINT16,WORD);
BOOL16 WINAPI ShellAbout16(HWND16,LPCSTR,LPCSTR,HICON16);
inline static BOOL SHELL_OsIsUnicode(void)
{
/* if high-bit of version is 0, we are emulating NT */

2
dlls/user/bidi16.c
View File

@ -5,7 +5,7 @@
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "wine/winuser16.h"
#include "winerror.h"
#include "debugtools.h"

1
dlls/user/ddeml.c
View File

@ -15,6 +15,7 @@
#include "wingdi.h"
#include "winuser.h"
#include "ddeml.h"
#include "ddeml16.h"
#include "winerror.h"
#include "heap.h"
#include "debugtools.h"

79
dlls/user/ddeml16.h Normal file
View File

@ -0,0 +1,79 @@
/*
* DDEML 16-bit library definitions
*
* Copyright 1997 Alexandre Julliard
* Copyright 1997 Len White
*/
#ifndef __WINE_WINE_DDEML16_H
#define __WINE_WINE_DDEML16_H
#include "windef.h"
#include "wine/windef16.h"
#define QID_SYNC16 -1L
typedef HDDEDATA CALLBACK (*PFNCALLBACK16)(UINT16,UINT16,HCONV,HSZ,HSZ,HDDEDATA,DWORD,DWORD);
/***************************************************
Externally visible data structures
***************************************************/
typedef struct
{
UINT16 cb;
UINT16 wFlags;
UINT16 wCountryID;
INT16 iCodePage;
DWORD dwLangID;
DWORD dwSecurity;
} CONVCONTEXT16, *LPCONVCONTEXT16;
typedef struct
{
DWORD cb;
DWORD hUser;
HCONV hConvPartner;
HSZ hszSvcPartner;
HSZ hszServiceReq;
HSZ hszTopic;
HSZ hszItem;
UINT16 wFmt;
UINT16 wType;
UINT16 wStatus;
UINT16 wConvst;
UINT16 wLastError;
HCONVLIST hConvList;
CONVCONTEXT16 ConvCtxt;
} CONVINFO16, *LPCONVINFO16;
/* Interface Definitions */
UINT16 WINAPI DdeInitialize16(LPDWORD,PFNCALLBACK16,DWORD,DWORD);
BOOL16 WINAPI DdeUninitialize16(DWORD);
HCONVLIST WINAPI DdeConnectList16(DWORD,HSZ,HSZ,HCONVLIST,LPCONVCONTEXT16);
HCONV WINAPI DdeQueryNextServer16(HCONVLIST, HCONV);
BOOL16 WINAPI DdeDisconnectList16(HCONVLIST);
HCONV WINAPI DdeConnect16(DWORD,HSZ,HSZ,LPCONVCONTEXT16);
BOOL16 WINAPI DdeDisconnect16(HCONV);
BOOL16 WINAPI DdeSetUserHandle16(HCONV,DWORD,DWORD);
HDDEDATA WINAPI DdeCreateDataHandle16(DWORD,LPBYTE,DWORD,DWORD,HSZ,UINT16,UINT16);
HSZ WINAPI DdeCreateStringHandle16(DWORD,LPCSTR,INT16);
BOOL16 WINAPI DdeFreeStringHandle16(DWORD,HSZ);
BOOL16 WINAPI DdeFreeDataHandle16(HDDEDATA);
BOOL16 WINAPI DdeKeepStringHandle16(DWORD,HSZ);
HDDEDATA WINAPI DdeClientTransaction16(LPVOID,DWORD,HCONV,HSZ,UINT16,UINT16,DWORD,LPDWORD);
BOOL16 WINAPI DdeAbandonTransaction16(DWORD,HCONV,DWORD);
BOOL16 WINAPI DdePostAdvise16(DWORD,HSZ,HSZ);
HDDEDATA WINAPI DdeAddData16(HDDEDATA,LPBYTE,DWORD,DWORD);
LPBYTE WINAPI DdeAccessData16(HDDEDATA,LPDWORD);
BOOL16 WINAPI DdeUnaccessData16(HDDEDATA);
BOOL16 WINAPI DdeEnableCallback16(DWORD,HCONV,UINT16);
INT16 WINAPI DdeCmpStringHandles16(HSZ,HSZ);
HDDEDATA WINAPI DdeNameService16(DWORD,HSZ,HSZ,UINT16);
UINT16 WINAPI DdeGetLastError16(DWORD);
UINT16 WINAPI DdeQueryConvInfo16(HCONV,DWORD,LPCONVINFO16);
#endif /* __WINE_WINE_DDEML16_H */

3
dlls/version/ver16.c
View File

@ -5,11 +5,12 @@
*/
#include "winbase.h"
#include "wine/winbase16.h"
#include "winver.h"
#include "ldt.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(ver)
DEFAULT_DEBUG_CHANNEL(ver);
/*************************************************************************

1
dlls/win32s/w32sys.c
View File

@ -6,6 +6,7 @@
*/
#include "windef.h"
#include "wine/windef16.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(dll);

64
include/aspi.h → dlls/winaspi/aspi.h
View File

@ -10,70 +10,6 @@
extern "C" {
#endif /* #ifdef __cplusplus */
/* Stuff in BOTH spec */
/* SCSI Miscellaneous Stuff */
#define SENSE_LEN 14
#define SRB_DIR_SCSI 0x00
#define SRB_POSTING 0x01
#define SRB_ENABLE_RESIDUAL_COUNT 0x04
#define SRB_DIR_IN 0x08
#define SRB_DIR_OUT 0x10
/* ASPI Command Definitions */
#define SC_HA_INQUIRY 0x00
#define SC_GET_DEV_TYPE 0x01
#define SC_EXEC_SCSI_CMD 0x02
#define SC_ABORT_SRB 0x03
#define SC_RESET_DEV 0x04
#define SC_SET_HA_PARMS 0x05
#define SC_GET_DISK_INFO 0x06
/* SRB status codes */
#define SS_PENDING 0x00
#define SS_COMP 0x01
#define SS_ABORTED 0x02
#define SS_ABORT_FAIL 0x03
#define SS_ERR 0x04
#define SS_INVALID_CMD 0x80
#define SS_INVALID_HA 0x81
#define SS_NO_DEVICE 0x82
#define SS_INVALID_SRB 0xE0
#define SS_OLD_MANAGER 0xE1
#define SS_BUFFER_ALIGN 0xE1 // Win32
#define SS_ILLEGAL_MODE 0xE2
#define SS_NO_ASPI 0xE3
#define SS_FAILED_INIT 0xE4
#define SS_ASPI_IS_BUSY 0xE5
#define SS_BUFFER_TO_BIG 0xE6
#define SS_MISMATCHED_COMPONENTS 0xE7 // DLLs/EXE version mismatch
#define SS_NO_ADAPTERS 0xE8
#define SS_INSUFFICIENT_RESOURCES 0xE9
#define SS_ASPI_IS_SHUTDOWN 0xEA
#define SS_BAD_INSTALL 0xEB
/* Host status codes */
#define HASTAT_OK 0x00
#define HASTAT_SEL_TO 0x11
#define HASTAT_DO_DU 0x12
#define HASTAT_BUS_FREE 0x13
#define HASTAT_PHASE_ERR 0x14
#define HASTAT_TIMEOUT 0x09
#define HASTAT_COMMAND_TIMEOUT 0x0B
#define HASTAT_MESSAGE_REJECT 0x0D
#define HASTAT_BUS_RESET 0x0E
#define HASTAT_PARITY_ERROR 0x0F
#define HASTAT_REQUEST_SENSE_FAILED 0x10
/*********** OLD ****************/
/* Target status codes */

5
dlls/winaspi/winaspi16.c
View File

@ -11,9 +11,10 @@
#include <stdio.h>
#include "winbase.h"
#include "wine/windef16.h"
#include "aspi.h"
#include "winescsi.h"
#include "winaspi.h"
#include "wine/winaspi.h"
#include "options.h"
#include "heap.h"
#include "debugtools.h"
@ -391,7 +392,7 @@ error_exit:
* GetASPISupportInfo16 (WINASPI.1)
*/
WORD WINAPI GetASPISupportInfo16()
WORD WINAPI GetASPISupportInfo16(void)
{
#ifdef linux
TRACE("GETASPISupportInfo16\n");

10
dlls/winmm/mmsystem.c
View File

@ -1733,7 +1733,7 @@ UINT WINAPI mciGetDeviceIDW(LPCWSTR lpwstrName)
/**************************************************************************
* MCI_DefYieldProc [internal]
*/
UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data)
UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
{
INT16 ret;
@ -1756,7 +1756,7 @@ UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data)
/**************************************************************************
* mciSetYieldProc [MMSYSTEM.714]
*/
BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC fpYieldProc, DWORD dwYieldData)
BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC16 fpYieldProc, DWORD dwYieldData)
{
LPWINE_MCIDRIVER wmd;
@ -1767,7 +1767,7 @@ BOOL16 WINAPI mciSetYieldProc16(UINT16 uDeviceID, YIELDPROC fpYieldProc, DWORD d
return FALSE;
}
wmd->lpfnYieldProc = fpYieldProc;
wmd->lpfnYieldProc = (YIELDPROC)fpYieldProc;
wmd->dwYieldData = dwYieldData;
wmd->bIs32 = FALSE;
@ -1819,7 +1819,7 @@ UINT WINAPI mciGetDeviceIDFromElementIDW(DWORD dwElementID, LPCWSTR lpstrType)
/**************************************************************************
* mciGetYieldProc [MMSYSTEM.716]
*/
YIELDPROC WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
YIELDPROC16 WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
{
LPWINE_MCIDRIVER wmd;
@ -1837,7 +1837,7 @@ YIELDPROC WINAPI mciGetYieldProc16(UINT16 uDeviceID, DWORD* lpdwYieldData)
WARN("Proc is 32 bit\n");
return NULL;
}
return wmd->lpfnYieldProc;
return (YIELDPROC16)wmd->lpfnYieldProc;
}
/**************************************************************************

1
dlls/winmm/sound16.c
View File

@ -6,6 +6,7 @@
#include <stdlib.h>
#include "windef.h"
#include "wine/windef16.h"
#include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(sound);

2
dlls/winmm/winemm.h
View File

@ -155,7 +155,7 @@ extern UINT MCI_GetDriverFromString(LPCSTR str);
extern DWORD MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr);
extern const char* MCI_MessageToString(UINT16 wMsg);
extern UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data);
extern UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data);
extern LRESULT MCI_CleanUp(LRESULT dwRet, UINT wMsg, DWORD dwParam2, BOOL bIs32);

9
dlls/winsock/socket.c
View File

@ -74,6 +74,15 @@
#ifdef HAVE_NET_IF_H
# include <net/if.h>
#endif
#ifdef HAVE_IPX_GNU
# include <netipx/ipx.h>
# define HAVE_IPX
#endif
#ifdef HAVE_IPX_LINUX
# include <asm/types.h>
# include <linux/ipx.h>
# define HAVE_IPX
#endif
#include "wine/winbase16.h"
#include "wingdi.h"

1
dlls/winspool/info.c
View File

@ -15,6 +15,7 @@
#include "winbase.h"
#include "winerror.h"
#include "winreg.h"
#include "wine/windef16.h"
#include "wine/unicode.h"
#include "debugtools.h"
#include "heap.h"

28
files/file.c
View File

@ -343,6 +343,30 @@ int FILE_GetUnixHandle( HANDLE handle, DWORD access )
}
/*************************************************************************
* FILE_OpenConsole
*
* Open a handle to the current process console.
*/
static HANDLE FILE_OpenConsole( BOOL output, DWORD access, LPSECURITY_ATTRIBUTES sa )
{
int ret = -1;
SERVER_START_REQ
{
struct open_console_request *req = server_alloc_req( sizeof(*req), 0 );
req->output = output;
req->access = access;
req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
SetLastError(0);
if (!server_call( REQ_OPEN_CONSOLE )) ret = req->handle;
}
SERVER_END_REQ;
return ret;
}
/***********************************************************************
* FILE_CreateFile
*
@ -508,8 +532,8 @@ HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
return HFILE_ERROR;
/* Open a console for CONIN$ or CONOUT$ */
if (!strcasecmp(filename, "CONIN$")) return CONSOLE_OpenHandle( FALSE, access, sa );
if (!strcasecmp(filename, "CONOUT$")) return CONSOLE_OpenHandle( TRUE, access, sa );
if (!strcasecmp(filename, "CONIN$")) return FILE_OpenConsole( FALSE, access, sa );
if (!strcasecmp(filename, "CONOUT$")) return FILE_OpenConsole( TRUE, access, sa );
if (DOSFS_GetDevice( filename ))
{

1
if1632/snoop.c
View File

@ -10,6 +10,7 @@
#include "winbase.h"
#include "windef.h"
#include "winnt.h"
#include "wine/winbase16.h"
#include "heap.h"
#include "global.h"
#include "selectors.h"

4
include/Makefile.in
View File

@ -14,6 +14,7 @@ INSTALLED_INCLUDES = \
d3d.h \
d3dcaps.h \
d3dtypes.h \
d3dvec.inl \
dde.h \
ddeml.h \
ddraw.h \
@ -54,7 +55,6 @@ INSTALLED_INCLUDES = \
pshpack2.h \
pshpack4.h \
pshpack8.h \
queue.h \
ras.h \
regstr.h \
richedit.h \
@ -116,7 +116,6 @@ INSTALLED_INCLUDES = \
wine/obj_shelllink.h \
wine/obj_shellview.h \
wine/obj_storage.h \
wine/port.h \
wine/unicode.h \
winerror.h \
wingdi.h \
@ -133,6 +132,7 @@ INSTALLED_INCLUDES = \
winsvc.h \
winuser.h \
winver.h \
wnaspi32.h \
wownt32.h \
wtypes.h

4
include/basetsd.h
View File

@ -6,10 +6,6 @@
#ifndef __WINE_BASETSD_H
#define __WINE_BASETSD_H
#ifdef __WINE__
#include "config.h"
#endif /* defined(__WINE__) */
#ifdef __cplusplus
extern "C" {
#endif /* defined(__cplusplus) */

1
include/builtin16.h
View File

@ -8,6 +8,7 @@
#define __WINE_BUILTIN16_H
#include "windef.h"
#include "wine/windef16.h"
#include "ldt.h"
struct _CONTEXT86;

1
include/cdrom.h
View File

@ -13,6 +13,7 @@
#include <stdlib.h>
#include <unistd.h>
#include "windef.h"
#include "wine/windef16.h"
#ifdef HAVE_LINUX_CDROM_H
# include <linux/cdrom.h>

1
include/clipboard.h
View File

@ -2,6 +2,7 @@
#define __WINE_CLIPBOARD_H
#include "windef.h"
#include "wine/windef16.h"
struct tagWND;

25
include/commdlg.h
View File

@ -9,9 +9,7 @@
extern "C" {
#endif
#include "windef.h" /* needed for CHOOSEFONT structure */
#include "wingdi.h"
#include "winuser.h"
#include "prsht.h"
#include "pshpack1.h"
#define OFN_READONLY 0x00000001
@ -223,8 +221,8 @@ typedef struct
LPCSTR lpTemplateName;
HINSTANCE hInstance;
LPSTR lpszStyle;
UINT16 nFontType;
UINT16 ___MISSING_ALIGNMENT__;
WORD nFontType;
WORD ___MISSING_ALIGNMENT__;
INT nSizeMin;
INT nSizeMax;
} CHOOSEFONTA, *LPCHOOSEFONTA;
@ -243,8 +241,8 @@ typedef struct
LPCWSTR lpTemplateName;
HINSTANCE hInstance;
LPWSTR lpszStyle;
UINT16 nFontType;
UINT16 ___MISSING_ALIGNMENT__;
WORD nFontType;
WORD ___MISSING_ALIGNMENT__;
INT nSizeMin;
INT nSizeMax;
} CHOOSEFONTW, *LPCHOOSEFONTW;
@ -468,12 +466,13 @@ DECL_WINELIB_TYPE_AW(LPPRINTDLG)
#define PD_HIDEPRINTTOFILE 0x00100000
#define PD_NONETWORKBUTTON 0x00200000
typedef struct {
UINT16 wDriverOffset;
UINT16 wDeviceOffset;
UINT16 wOutputOffset;
UINT16 wDefault;
} DEVNAMES;
typedef struct
{
WORD wDriverOffset;
WORD wDeviceOffset;
WORD wOutputOffset;
WORD wDefault;
} DEVNAMES;
typedef DEVNAMES * LPDEVNAMES;
#define DN_DEFAULTPRN 0x0001

2
include/dce.h
View File

@ -52,7 +52,7 @@ extern void DCE_Init(void);
extern DCE* DCE_AllocDCE( HWND hWnd, DCE_TYPE type );
extern DCE* DCE_FreeDCE( DCE *dce );
extern void DCE_FreeWindowDCE( struct tagWND* );
extern INT16 DCE_ExcludeRgn( HDC, struct tagWND*, HRGN );
extern INT DCE_ExcludeRgn( HDC, struct tagWND*, HRGN );
extern HRGN DCE_GetVisRgn( HWND, WORD, HWND, WORD );
extern BOOL DCE_InvalidateDCE( struct tagWND*, const RECT* );

77
include/ddeml.h
View File

@ -25,7 +25,6 @@ extern "C" {
#define MSGF_DDEMGR 0x8001
#define QID_SYNC16 -1L
#define QID_SYNC 0xFFFFFFFF
/* Type variation for MS deliberate departures from ANSI standards
@ -219,8 +218,6 @@ DECLARE_HANDLE(HDDEDATA);
*******************************************************/
typedef HDDEDATA CALLBACK (*PFNCALLBACK16)(UINT16,UINT16,HCONV,HSZ,HSZ,
HDDEDATA,DWORD,DWORD);
typedef HDDEDATA CALLBACK (*PFNCALLBACK)(UINT,UINT,HCONV,HSZ,HSZ,
HDDEDATA,DWORD,DWORD);
@ -230,16 +227,6 @@ typedef HDDEDATA CALLBACK (*PFNCALLBACK)(UINT,UINT,HCONV,HSZ,HSZ,
***************************************************/
typedef struct
{
UINT16 cb;
UINT16 wFlags;
UINT16 wCountryID;
INT16 iCodePage;
DWORD dwLangID;
DWORD dwSecurity;
} CONVCONTEXT16, *LPCONVCONTEXT16;
typedef struct
{
UINT cb;
@ -250,24 +237,6 @@ typedef struct
DWORD dwSecurity;
} CONVCONTEXT, *LPCONVCONTEXT;
typedef struct
{
DWORD cb;
DWORD hUser;
HCONV hConvPartner;
HSZ hszSvcPartner;
HSZ hszServiceReq;
HSZ hszTopic;
HSZ hszItem;
UINT16 wFmt;
UINT16 wType;
UINT16 wStatus;
UINT16 wConvst;
UINT16 wLastError;
HCONVLIST hConvList;
CONVCONTEXT16 ConvCtxt;
} CONVINFO16, *LPCONVINFO16;
typedef struct
{
DWORD cb;
@ -291,65 +260,39 @@ typedef struct
/* Interface Definitions */
UINT16 WINAPI DdeInitialize16(LPDWORD,PFNCALLBACK16,DWORD,DWORD);
UINT WINAPI DdeInitializeA(LPDWORD,PFNCALLBACK,DWORD,DWORD);
UINT WINAPI DdeInitializeW(LPDWORD,PFNCALLBACK,DWORD,DWORD);
#define DdeInitialize WINELIB_NAME_AW(DdeInitialize)
BOOL16 WINAPI DdeUninitialize16(DWORD);
BOOL WINAPI DdeUninitialize(DWORD);
HCONVLIST WINAPI DdeConnectList16(DWORD,HSZ,HSZ,HCONVLIST,LPCONVCONTEXT16);
HCONVLIST WINAPI DdeConnectList(DWORD,HSZ,HSZ,HCONVLIST,LPCONVCONTEXT);
HCONV WINAPI DdeQueryNextServer16(HCONVLIST, HCONV);
HCONV WINAPI DdeQueryNextServer(HCONVLIST, HCONV);
DWORD WINAPI DdeQueryStringA(DWORD, HSZ, LPSTR, DWORD, INT);
DWORD WINAPI DdeQueryStringW(DWORD, HSZ, LPWSTR, DWORD, INT);
#define DdeQueryString WINELIB_NAME_AW(DdeQueryString)
BOOL16 WINAPI DdeDisconnectList16(HCONVLIST);
BOOL WINAPI DdeDisconnectList(HCONVLIST);
HCONV WINAPI DdeConnect16(DWORD,HSZ,HSZ,LPCONVCONTEXT16);
BOOL WINAPI DdeDisconnectList(HCONVLIST);
HCONV WINAPI DdeConnect(DWORD,HSZ,HSZ,LPCONVCONTEXT);
BOOL16 WINAPI DdeDisconnect16(HCONV);
BOOL WINAPI DdeDisconnect(HCONV);
BOOL16 WINAPI DdeSetUserHandle16(HCONV,DWORD,DWORD);
HDDEDATA WINAPI DdeCreateDataHandle16(DWORD,LPBYTE,DWORD,DWORD,HSZ,UINT16,UINT16);
BOOL WINAPI DdeDisconnect(HCONV);
HDDEDATA WINAPI DdeCreateDataHandle(DWORD,LPBYTE,DWORD,DWORD,HSZ,UINT,UINT);
HCONV WINAPI DdeReconnect(HCONV);
HSZ WINAPI DdeCreateStringHandle16(DWORD,LPCSTR,INT16);
HSZ WINAPI DdeCreateStringHandleA(DWORD,LPCSTR,INT);
HSZ WINAPI DdeCreateStringHandleW(DWORD,LPCWSTR,INT);
#define DdeCreateStringHandle WINELIB_NAME_AW(DdeCreateStringHandle)
BOOL16 WINAPI DdeFreeStringHandle16(DWORD,HSZ);
BOOL WINAPI DdeFreeStringHandle(DWORD,HSZ);
BOOL16 WINAPI DdeFreeDataHandle16(HDDEDATA);
BOOL WINAPI DdeFreeDataHandle(HDDEDATA);
BOOL16 WINAPI DdeKeepStringHandle16(DWORD,HSZ);
BOOL WINAPI DdeKeepStringHandle(DWORD,HSZ);
HDDEDATA WINAPI DdeClientTransaction16(LPVOID,DWORD,HCONV,HSZ,UINT16,
UINT16,DWORD,LPDWORD);
HDDEDATA WINAPI DdeClientTransaction(LPBYTE,DWORD,HCONV,HSZ,UINT,
UINT,DWORD,LPDWORD);
BOOL WINAPI DdeFreeStringHandle(DWORD,HSZ);
BOOL WINAPI DdeFreeDataHandle(HDDEDATA);
BOOL WINAPI DdeKeepStringHandle(DWORD,HSZ);
HDDEDATA WINAPI DdeClientTransaction(LPBYTE,DWORD,HCONV,HSZ,UINT,UINT,DWORD,LPDWORD);
BOOL WINAPI DdeImpersonateClient(HCONV);
BOOL16 WINAPI DdeAbandonTransaction16(DWORD,HCONV,DWORD);
BOOL16 WINAPI DdePostAdvise16(DWORD,HSZ,HSZ);
BOOL WINAPI DdePostAdvise(DWORD,HSZ,HSZ);
HDDEDATA WINAPI DdeAddData16(HDDEDATA,LPBYTE,DWORD,DWORD);
BOOL WINAPI DdePostAdvise(DWORD,HSZ,HSZ);
HDDEDATA WINAPI DdeAddData(HDDEDATA,LPBYTE,DWORD,DWORD);
DWORD WINAPI DdeGetData(HDDEDATA,LPBYTE,DWORD,DWORD);
LPBYTE WINAPI DdeAccessData16(HDDEDATA,LPDWORD);
LPBYTE WINAPI DdeAccessData(HDDEDATA,LPDWORD);
BOOL16 WINAPI DdeUnaccessData16(HDDEDATA);
BOOL WINAPI DdeUnaccessData(HDDEDATA);
BOOL16 WINAPI DdeEnableCallback16(DWORD,HCONV,UINT16);
BOOL WINAPI DdeEnableCallback(DWORD,HCONV,UINT);
INT16 WINAPI DdeCmpStringHandles16(HSZ,HSZ);
BOOL WINAPI DdeUnaccessData(HDDEDATA);
BOOL WINAPI DdeEnableCallback(DWORD,HCONV,UINT);
INT WINAPI DdeCmpStringHandles(HSZ,HSZ);
BOOL WINAPI DdeSetUserHandle(HCONV,DWORD,DWORD);
HDDEDATA WINAPI DdeNameService16(DWORD,HSZ,HSZ,UINT16);
HDDEDATA WINAPI DdeNameService(DWORD,HSZ,HSZ,UINT);
UINT16 WINAPI DdeGetLastError16(DWORD);
UINT WINAPI DdeGetLastError(DWORD);
UINT16 WINAPI DdeQueryConvInfo16(HCONV,DWORD,LPCONVINFO16);
UINT WINAPI DdeGetLastError(DWORD);
UINT WINAPI DdeQueryConvInfo(HCONV,DWORD,LPCONVINFO);
#ifdef __cplusplus

1
include/dinput.h
View File

@ -3,7 +3,6 @@
#include "windef.h" /* for MAX_PATH */
#include "unknwn.h"
#include "mouse.h"
#define DIRECTINPUT_VERSION 0x0500

1
include/file.h
View File

@ -9,6 +9,7 @@
#include <time.h> /* time_t */
#include "winbase.h"
#include "wine/windef16.h" /* HFILE16 */
#define MAX_PATHNAME_LEN 1024

1
include/global.h
View File

@ -8,6 +8,7 @@
#define __WINE_GLOBAL_H
#include "windef.h"
#include "wine/windef16.h"
/* memory/global.c */
extern HGLOBAL16 GLOBAL_CreateBlock( UINT16 flags, const void *ptr, DWORD size,

1
include/local.h
View File

@ -8,6 +8,7 @@
#define __WINE_LOCAL_H
#include "windef.h"
#include "wine/windef16.h"
/* These function are equivalent to the Local* API functions, */
/* excepted that they need DS as the first parameter. This */

23
include/lzexpand.h
View File

@ -23,27 +23,18 @@ extern "C" {
#define LZERROR_UNKNOWNALG -8 /* -8 */
VOID WINAPI LZDone(void);
LONG WINAPI CopyLZFile16(HFILE16,HFILE16);
LONG WINAPI CopyLZFile(HFILE,HFILE);
HFILE16 WINAPI LZOpenFile16(LPCSTR,LPOFSTRUCT,UINT16);
HFILE WINAPI LZOpenFileA(LPCSTR,LPOFSTRUCT,UINT);
HFILE WINAPI LZOpenFileW(LPCWSTR,LPOFSTRUCT,UINT);
HFILE WINAPI LZOpenFileA(LPCSTR,LPOFSTRUCT,UINT);
HFILE WINAPI LZOpenFileW(LPCWSTR,LPOFSTRUCT,UINT);
#define LZOpenFile WINELIB_NAME_AW(LZOpenFile)
INT16 WINAPI LZRead16(HFILE16,LPVOID,UINT16);
INT WINAPI LZRead(HFILE,LPVOID,UINT);
INT16 WINAPI LZStart16(void);
INT WINAPI LZStart(void);
void WINAPI LZClose16(HFILE16);
INT WINAPI LZRead(HFILE,LPVOID,UINT);
INT WINAPI LZStart(void);
void WINAPI LZClose(HFILE);
LONG WINAPI LZCopy16(HFILE16,HFILE16);
LONG WINAPI LZCopy(HFILE,HFILE);
HFILE16 WINAPI LZInit16(HFILE16);
HFILE WINAPI LZInit(HFILE);
LONG WINAPI LZSeek16(HFILE16,LONG,INT16);
HFILE WINAPI LZInit(HFILE);
LONG WINAPI LZSeek(HFILE,LONG,INT);
INT16 WINAPI GetExpandedName16(LPCSTR,LPSTR);
INT WINAPI GetExpandedNameA(LPCSTR,LPSTR);
INT WINAPI GetExpandedNameW(LPCWSTR,LPWSTR);
INT WINAPI GetExpandedNameA(LPCSTR,LPSTR);
INT WINAPI GetExpandedNameW(LPCWSTR,LPWSTR);
#define GetExpandedName WINELIB_NAME_AW(GetExpandedName)
#ifdef __cplusplus

1
include/message.h
View File

@ -8,6 +8,7 @@
#define __WINE_MESSAGE_H
#include "windef.h"
#include "wine/windef16.h"
struct tagMSG;

9
include/miscemu.h
View File

@ -9,6 +9,7 @@
#include "winnt.h"
#include "ldt.h"
#include "wine/windef16.h"
/* msdos/dosconf.c */
extern int DOSCONF_ReadConfig(void);
@ -121,8 +122,8 @@ typedef struct
#include "poppack.h"
extern HANDLE16 DOSMEM_BiosDataSeg;
extern HANDLE16 DOSMEM_BiosSysSeg;
extern WORD DOSMEM_BiosDataSeg;
extern WORD DOSMEM_BiosSysSeg;
extern BIOSDATA * DOSMEM_BiosData();
extern BYTE * DOSMEM_BiosSys();
@ -141,9 +142,9 @@ extern BOOL DOSMEM_Init(BOOL);
extern void DOSMEM_Tick(WORD timer);
extern WORD DOSMEM_AllocSelector(WORD);
extern char * DOSMEM_MemoryBase(void);
extern LPVOID DOSMEM_GetBlock(UINT size, UINT16* p);
extern LPVOID DOSMEM_GetBlock(UINT size, WORD* p);
extern BOOL DOSMEM_FreeBlock(void* ptr);
extern LPVOID DOSMEM_ResizeBlock(void* ptr, UINT size, UINT16* p);
extern LPVOID DOSMEM_ResizeBlock(void* ptr, UINT size, WORD* p);
extern UINT DOSMEM_Available(void);
extern LPVOID DOSMEM_MapRealToLinear(DWORD); /* real-mode to linear */
extern LPVOID DOSMEM_MapDosToLinear(UINT); /* linear DOS to Wine */

1
include/mmddk.h
View File

@ -15,6 +15,7 @@
#include "mmsystem.h"
#include "winbase.h"
#include "wine/mmsystem16.h"
#define MAX_MIDIINDRV (16)
/* For now I'm making 16 the maximum number of midi devices one can

565
include/mmsystem.h
View File

File diff suppressed because it is too large Load Diff

1
include/module.h
View File

@ -9,6 +9,7 @@
#include "windef.h"
#include "winbase.h"
#include "wine/windef16.h"
/* In-memory module structure. See 'Windows Internals' p. 219 */
typedef struct _NE_MODULE

261
include/msacm.h
View File

@ -91,15 +91,12 @@ extern "C" {
#define ACMHELPMSGSTRINGA "acmchoose_help"
#define ACMHELPMSGSTRINGW L"acmchoose_help"
#define ACMHELPMSGSTRING16 "acmchoose_help"
#define ACMHELPMSGCONTEXTMENUA "acmchoose_contextmenu"
#define ACMHELPMSGCONTEXTMENUW L"acmchoose_contextmenu"
#define ACMHELPMSGCONTEXTMENU16 "acmchoose_contextmenu"
#define ACMHELPMSGCONTEXTHELPA "acmchoose_contexthelp"
#define ACMHELPMSGCONTEXTHELPW L"acmchoose_contexthelp"
#define ACMHELPMSGCONTEXTHELP16 "acmchoose_contexthelp"
#define MM_ACM_FORMATCHOOSE 0x8000
@ -194,10 +191,6 @@ typedef BOOL CALLBACK (*ACMDRIVERENUMCB)(
HACMDRIVERID hadid, DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL16 CALLBACK (*ACMDRIVERENUMCB16)(
HACMDRIVERID16 hadid, DWORD dwInstance, DWORD fdwSupport
);
typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROCA)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
@ -207,10 +200,6 @@ typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROCW)(
);
#define ACMFILTERCHOOSEHOOKPROC WINELIB_NAME_AW(ACMFILTERCHOOSEHOOKPROC)
typedef UINT CALLBACK (*ACMFILTERCHOOSEHOOKPROC16)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
typedef UINT CALLBACK (*ACMFORMATCHOOSEHOOKPROCA)(
HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam
);
@ -220,10 +209,6 @@ typedef UINT CALLBACK (*ACMFORMATCHOOSEHOOKPROCW)(
);
#define ACMFORMATCHOOSEHOOKPROC WINELIB_NAME_AW(ACMFORMATCHOOSEHOOKPROC)
typedef UINT16 CALLBACK (*ACMFORMATCHOOSEHOOKPROC16)(
HWND16 hwnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam
);
/***********************************************************************
* Structures
*/
@ -283,32 +268,6 @@ typedef struct _ACMDRIVERDETAILSW
DECL_WINELIB_TYPE_AW(ACMDRIVERDETAILS);
DECL_WINELIB_TYPE_AW(PACMDRIVERDETAILS);
typedef struct _ACMDRIVERDETAILS16
{
DWORD cbStruct;
FOURCC fccType;
FOURCC fccComp;
WORD wMid;
WORD wPid;
DWORD vdwACM;
DWORD vdwDriver;
DWORD fdwSupport;
DWORD cFormatTags;
DWORD cFilterTags;
HICON16 hicon;
CHAR szShortName[ACMDRIVERDETAILS_SHORTNAME_CHARS];
CHAR szLongName[ACMDRIVERDETAILS_LONGNAME_CHARS];
CHAR szCopyright[ACMDRIVERDETAILS_COPYRIGHT_CHARS];
CHAR szLicensing[ACMDRIVERDETAILS_LICENSING_CHARS];
CHAR szFeatures[ACMDRIVERDETAILS_FEATURES_CHARS];
} ACMDRIVERDETAILS16, *NPACMDRIVERDETAILS16, *LPACMDRIVERDETAILS16;
typedef struct _ACMFILTERCHOOSEA
{
DWORD cbStruct;
@ -364,32 +323,6 @@ typedef struct _ACMFILTERCHOOSEW
DECL_WINELIB_TYPE_AW(ACMFILTERCHOOSE);
DECL_WINELIB_TYPE_AW(PACMFILTERCHOOSE);
typedef struct _ACMFILTERCHOOSE16
{
DWORD cbStruct;
DWORD fdwStyle;
HWND16 hwndOwner;
LPWAVEFILTER pwfltr;
DWORD cbwfltr;
LPCSTR pszTitle;
char szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
char szFilter[ACMFILTERDETAILS_FILTER_CHARS];
LPSTR pszName;
DWORD cchName;
DWORD fdwEnum;
LPWAVEFILTER pwfltrEnum;
HINSTANCE16 hInstance;
LPCSTR pszTemplateName;
LPARAM lCustData;
ACMFILTERCHOOSEHOOKPROC16 pfnHook;
} ACMFILTERCHOOSE16, *NPACMFILTERCHOOSE16, *LPACMFILTERCHOOSE16;
typedef struct _ACMFILTERDETAILSA
{
DWORD cbStruct;
@ -415,17 +348,6 @@ typedef struct _ACMFILTERDETAILSW
DECL_WINELIB_TYPE_AW(ACMFILTERDETAILS);
DECL_WINELIB_TYPE_AW(PACMFILTERDETAILS);
typedef struct _ACMFILTERDETAILS16
{
DWORD cbStruct;
DWORD dwFilterIndex;
DWORD dwFilterTag;
DWORD fdwSupport;
LPWAVEFILTER pwfltr;
DWORD cbwfltr;
CHAR szFilter[ACMFILTERDETAILS_FILTER_CHARS];
} ACMFILTERDETAILS16, *NPACMFILTERDETAILS16, *LPACMFILTERDETAILS16;
typedef struct _ACMFILTERTAGDETAILSA
{
DWORD cbStruct;
@ -451,17 +373,6 @@ typedef struct _ACMFILTERTAGDETAILSW
DECL_WINELIB_TYPE_AW(ACMFILTERTAGDETAILS);
DECL_WINELIB_TYPE_AW(PACMFILTERTAGDETAILS);
typedef struct _ACMFILTERTAGDETAILS16
{
DWORD cbStruct;
DWORD dwFilterTagIndex;
DWORD dwFilterTag;
DWORD cbFilterSize;
DWORD fdwSupport;
DWORD cStandardFilters;
CHAR szFilterTag[ACMFILTERTAGDETAILS_FILTERTAG_CHARS];
} ACMFILTERTAGDETAILS16, *NPACMFILTERTAGDETAILS16, *LPACMFILTERTAGDETAILS16;
typedef struct _ACMFORMATCHOOSEA
{
DWORD cbStruct;
@ -517,32 +428,6 @@ typedef struct _ACMFORMATCHOOSEW
DECL_WINELIB_TYPE_AW(ACMFORMATCHOOSE);
DECL_WINELIB_TYPE_AW(PACMFORMATCHOOSE);
typedef struct _ACMFORMATCHOOSE16
{
DWORD cbStruct;
DWORD fdwStyle;
HWND16 hwndOwner;
LPWAVEFORMATEX pwfx;
DWORD cbwfx;
LPCSTR pszTitle;
CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
LPSTR pszName;
DWORD cchName;
DWORD fdwEnum;
LPWAVEFORMATEX pwfxEnum;
HINSTANCE16 hInstance;
LPCSTR pszTemplateName;
LPARAM lCustData;
ACMFORMATCHOOSEHOOKPROC16 pfnHook;
} ACMFORMATCHOOSE16, *NPACMFORMATCHOOSE16, *LPACMFORMATCHOOSE16;
typedef struct _ACMFORMATDETAILSA
{
DWORD cbStruct;
@ -568,17 +453,6 @@ typedef struct _ACMFORMATDETAILSW
DECL_WINELIB_TYPE_AW(ACMFORMATDETAILS);
DECL_WINELIB_TYPE_AW(PACMFORMATDETAILS);
typedef struct _ACMFORMATDETAILS16
{
DWORD cbStruct;
DWORD dwFormatIndex;
DWORD dwFormatTag;
DWORD fdwSupport;
LPWAVEFORMATEX pwfx;
DWORD cbwfx;
CHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS];
} ACMFORMATDETAILS16, *NPACMFORMATDETAILS16, *LPACMFORMATDETAILS16;
typedef struct _ACMFORMATTAGDETAILSA
{
DWORD cbStruct;
@ -604,17 +478,6 @@ typedef struct _ACMFORMATTAGDETAILSW
DECL_WINELIB_TYPE_AW(ACMFORMATTAGDETAILS);
DECL_WINELIB_TYPE_AW(PACMFORMATTAGDETAILS);
typedef struct _ACMFORMATTAGDETAILS16
{
DWORD cbStruct;
DWORD dwFormatTagIndex;
DWORD dwFormatTag;
DWORD cbFormatSize;
DWORD fdwSupport;
DWORD cStandardFormats;
CHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS];
} ACMFORMATTAGDETAILS16, *NPACMFORMATTAGDETAILS16, *LPACMFORMATTAGDETAILS16;
typedef struct _ACMSTREAMHEADER
{
DWORD cbStruct;
@ -629,8 +492,7 @@ typedef struct _ACMSTREAMHEADER
DWORD cbDstLengthUsed;
DWORD dwDstUser;
DWORD dwReservedDriver[10];
} ACMSTREAMHEADER16, *NPACMSTREAMHEADER16, *LPACMSTREAMHEADER16,
ACMSTREAMHEADER, *PACMSTREAMHEADER;
} ACMSTREAMHEADER, *PACMSTREAMHEADER;
/***********************************************************************
* Callbacks 2
@ -648,11 +510,6 @@ typedef BOOL CALLBACK (*ACMFILTERENUMCBW)(
#define ACMFILTERENUMCB WINELIB_NAME_AW(ACMFILTERENUMCB)
typedef BOOL16 CALLBACK (*ACMFILTERENUMCB16)(
HACMDRIVERID16 hadid, LPACMFILTERDETAILS16 pafd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFILTERTAGENUMCBA)(
HACMDRIVERID hadid, PACMFILTERTAGDETAILSA paftd,
DWORD dwInstance, DWORD fdwSupport
@ -665,11 +522,6 @@ typedef BOOL CALLBACK (*ACMFILTERTAGENUMCBW)(
#define ACMFILTERTAGENUMCB WINELIB_NAME_AW(ACMFILTERTAGENUMCB)
typedef BOOL16 CALLBACK (*ACMFILTERTAGENUMCB16)(
HACMDRIVERID16 hadid, LPACMFILTERTAGDETAILS16 paftd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFORMATENUMCBA)(
HACMDRIVERID hadid, PACMFORMATDETAILSA pafd,
DWORD dwInstance, DWORD fdwSupport
@ -682,11 +534,6 @@ typedef BOOL CALLBACK (*ACMFORMATENUMCBW)(
#define ACMFORMATENUMCB WINELIB_NAME_AW(ACMFORMATENUMCB)
typedef BOOL16 CALLBACK (*ACMFORMATENUMCB16)(
HACMDRIVERID16 hadid, LPACMFORMATDETAILS16 pafd,
DWORD dwInstance, DWORD fdwSupport
);
typedef BOOL CALLBACK (*ACMFORMATTAGENUMCBA)(
HACMDRIVERID hadid, PACMFORMATTAGDETAILSA paftd,
DWORD dwInstance, DWORD fdwSupport
@ -699,112 +546,6 @@ typedef BOOL CALLBACK (*ACMFORMATTAGENUMCBW)(
#define ACMFORMATTAGENUMCB WINELIB_NAME_AW(ACMFORMATTAGENUMCB)
typedef BOOL16 CALLBACK (*ACMFORMATTAGENUMCB16)(
HACMDRIVERID16 hadid, LPACMFORMATTAGDETAILS16 paftd,
DWORD dwInstance, DWORD fdwSupport
);
/***********************************************************************
* Functions - Win16
*/
DWORD WINAPI acmGetVersion16(
);
MMRESULT16 WINAPI acmMetrics16(
HACMOBJ16 hao, UINT16 uMetric, LPVOID pMetric
);
MMRESULT16 WINAPI acmDriverEnum16(
ACMDRIVERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmDriverDetails16(
HACMDRIVERID16 hadid, LPACMDRIVERDETAILS16 padd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmDriverAdd16(
LPHACMDRIVERID16 phadid, HINSTANCE16 hinstModule,
LPARAM lParam, DWORD dwPriority, DWORD fdwAdd
);
MMRESULT16 WINAPI acmDriverRemove16(
HACMDRIVERID16 hadid, DWORD fdwRemove
);
MMRESULT16 WINAPI acmDriverOpen16(
LPHACMDRIVER16 phad, HACMDRIVERID16 hadid, DWORD fdwOpen
);
MMRESULT16 WINAPI acmDriverClose16(
HACMDRIVER16 had, DWORD fdwClose
);
LRESULT WINAPI acmDriverMessage16(
HACMDRIVER16 had, UINT16 uMsg, LPARAM lParam1, LPARAM lParam2
);
MMRESULT16 WINAPI acmDriverID16(
HACMOBJ16 hao, LPHACMDRIVERID16 phadid, DWORD fdwDriverID
);
MMRESULT16 WINAPI acmDriverPriority16(
HACMDRIVERID16 hadid, DWORD dwPriority, DWORD fdwPriority
);
MMRESULT16 WINAPI acmFormatTagDetails16(
HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFormatTagEnum16(
HACMDRIVER16 had, LPACMFORMATTAGDETAILS16 paftd,
ACMFORMATTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmFormatChoose16(
LPACMFORMATCHOOSE16 pafmtc
);
MMRESULT16 WINAPI acmFormatDetails16(
HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFormatEnum16(
HACMDRIVER16 had, LPACMFORMATDETAILS16 pafd,
ACMFORMATENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmFormatSuggest16(
HACMDRIVER16 had, LPWAVEFORMATEX pwfxSrc,
LPWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest
);
MMRESULT16 WINAPI acmFilterTagDetails16(
HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFilterTagEnum16(
HACMDRIVER16 had, LPACMFILTERTAGDETAILS16 paftd,
ACMFILTERTAGENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmFilterChoose16(
LPACMFILTERCHOOSE16 pafltrc
);
MMRESULT16 WINAPI acmFilterDetails16(
HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd, DWORD fdwDetails
);
MMRESULT16 WINAPI acmFilterEnum16(
HACMDRIVER16 had, LPACMFILTERDETAILS16 pafd,
ACMFILTERENUMCB16 fnCallback, DWORD dwInstance, DWORD fdwEnum
);
MMRESULT16 WINAPI acmStreamOpen16(
LPHACMSTREAM16 phas, HACMDRIVER16 had,
LPWAVEFORMATEX pwfxSrc, LPWAVEFORMATEX pwfxDst,
LPWAVEFILTER pwfltr, DWORD dwCallback,
DWORD dwInstance, DWORD fdwOpen
);
MMRESULT16 WINAPI acmStreamClose16(
HACMSTREAM16 has, DWORD fdwClose
);
MMRESULT16 WINAPI acmStreamSize16(
HACMSTREAM16 has, DWORD cbInput,
LPDWORD pdwOutputBytes, DWORD fdwSize
);
MMRESULT16 WINAPI acmStreamConvert16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwConvert
);
MMRESULT16 WINAPI acmStreamReset16(
HACMSTREAM16 has, DWORD fdwReset
);
MMRESULT16 WINAPI acmStreamPrepareHeader16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwPrepare
);
MMRESULT16 WINAPI acmStreamUnprepareHeader16(
HACMSTREAM16 has, LPACMSTREAMHEADER16 pash, DWORD fdwUnprepare
);
/***********************************************************************
* Functions - Win32
*/

1
include/neexe.h
View File

@ -5,6 +5,7 @@
#define __WINE_NEEXE_H
#include "windef.h"
#include "wine/windef16.h"
/*
* NE Header FORMAT FLAGS

4
include/nonclient.h
View File

@ -14,10 +14,10 @@ struct tagWND;
extern LONG NC_HandleNCPaint( HWND hwnd , HRGN clip);
extern LONG NC_HandleNCActivate( struct tagWND *pwnd, WPARAM16 wParam );
extern LONG NC_HandleNCCalcSize( struct tagWND *pWnd, RECT *winRect );
extern LONG NC_HandleNCHitTest( HWND hwnd, POINT16 pt );
extern LONG NC_HandleNCHitTest( HWND hwnd, POINT pt );
extern LONG NC_HandleNCLButtonDown( struct tagWND* pWnd, WPARAM16 wParam, LPARAM lParam );
extern LONG NC_HandleNCLButtonDblClk( struct tagWND *pWnd, WPARAM16 wParam, LPARAM lParam);
extern LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt );
extern LONG NC_HandleSysCommand( HWND hwnd, WPARAM wParam, POINT pt );
extern LONG NC_HandleSetCursor( HWND hwnd, WPARAM16 wParam, LPARAM lParam );
extern void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down );
extern BOOL NC_DrawSysButton95( HWND hwnd, HDC hdc, BOOL down );

1
include/ntsecapi.h
View File

@ -1,7 +1,6 @@
#ifndef __WINE_NTSECAPI_H
#define __WINE_NTSECAPI_H
#include "ntdef.h"
#include "winnt.h"
#ifdef __cplusplus

78
include/ole.h
View File

@ -9,6 +9,17 @@
extern "C" {
#endif
#include "windef.h"
#include "wine/windef16.h"
#include "wine/obj_base.h"
#include "wine/obj_misc.h"
#include "wine/obj_storage.h"
#include "wine/obj_moniker.h"
#include "wine/obj_dataobject.h"
#include "wine/obj_dragdrop.h"
struct tagLOGPALETTE;
/* object types */
#define OT_LINK 1
#define OT_EMBEDDED 2
@ -148,15 +159,7 @@ typedef struct _OLETARGETDEVICE {
BYTE otdData[1];
/* ... */
} OLETARGETDEVICE;
typedef struct _OLESTREAM* LPOLESTREAM;
typedef struct _OLESTREAMVTBL {
DWORD CALLBACK (*Get)(LPOLESTREAM,LPSTR,DWORD);
DWORD CALLBACK (*Put)(LPOLESTREAM,LPSTR,DWORD);
} OLESTREAMVTBL;
typedef OLESTREAMVTBL* LPOLESTREAMVTBL;
typedef struct _OLESTREAM {
LPOLESTREAMVTBL lpstbl;
} OLESTREAM;
typedef struct _OLESERVERDOC* LPOLESERVERDOC;
typedef struct _OLEOBJECT* LPOLEOBJECT;
typedef struct _OLECLIENT* LPOLECLIENT;
@ -172,7 +175,7 @@ typedef struct _OLESERVERDOCVTBL {
OLESTATUS CALLBACK (*GetObject)(LPOLESERVERDOC,LPCOLESTR16,LPOLEOBJECT*,LPOLECLIENT);
#endif
OLESTATUS CALLBACK (*Release)(LPOLESERVERDOC);
OLESTATUS CALLBACK (*SetColorScheme)(LPOLESERVERDOC,LPLOGPALETTE);
OLESTATUS CALLBACK (*SetColorScheme)(LPOLESERVERDOC,struct tagLOGPALETTE*);
OLESTATUS CALLBACK (*Execute)(LPOLESERVERDOC,HGLOBAL16);
} OLESERVERDOCVTBL;
typedef OLESERVERDOCVTBL* LPOLESERVERDOCVTBL;
@ -206,6 +209,8 @@ typedef struct _OLECLIENT {
/* client data... */
} OLECLIENT;
struct _OLESTREAM;
typedef struct _OLEOBJECTVTBL {
void CALLBACK *(*QueryProtocol)(LPOLEOBJECT,LPCOLESTR16);
OLESTATUS CALLBACK (*Release)(LPOLEOBJECT);
@ -216,10 +221,10 @@ typedef struct _OLEOBJECTVTBL {
OLESTATUS CALLBACK (*SetTargetDevice)(LPOLEOBJECT,HGLOBAL16);
OLESTATUS CALLBACK (*SetBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS CALLBACK (*EnumFormats)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS CALLBACK (*SetColorScheme)(LPOLEOBJECT,LPLOGPALETTE);
OLESTATUS CALLBACK (*SetColorScheme)(LPOLEOBJECT,struct tagLOGPALETTE*);
OLESTATUS CALLBACK (*Delete)(LPOLEOBJECT);
OLESTATUS CALLBACK (*SetHostNames)(LPOLEOBJECT,LPCOLESTR16,LPCOLESTR16);
OLESTATUS CALLBACK (*SaveToStream)(LPOLEOBJECT,LPOLESTREAM);
OLESTATUS CALLBACK (*SaveToStream)(LPOLEOBJECT,struct _OLESTREAM*);
OLESTATUS CALLBACK (*Clone)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT *);
OLESTATUS CALLBACK (*CopyFromLink)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,LPCOLESTR16,LPOLEOBJECT *);
OLESTATUS CALLBACK (*Equal)(LPOLEOBJECT,LPOLEOBJECT);
@ -253,6 +258,42 @@ typedef struct _OLEOBJECT {
} OLEOBJECT;
typedef struct IMalloc16 IMalloc16,*LPMALLOC16;
#define ICOM_INTERFACE IMalloc16
#define IMalloc16_METHODS \
ICOM_METHOD1 (LPVOID,Alloc, DWORD,cb) \
ICOM_METHOD2 (LPVOID,Realloc, LPVOID,pv, DWORD,cb) \
ICOM_VMETHOD1( Free, LPVOID,pv) \
ICOM_METHOD1(DWORD, GetSize, LPVOID,pv) \
ICOM_METHOD1(INT16, DidAlloc, LPVOID,pv) \
ICOM_METHOD (LPVOID,HeapMinimize)
#define IMalloc16_IMETHODS \
IUnknown_IMETHODS \
IMalloc16_METHODS
ICOM_DEFINE(IMalloc16,IUnknown)
#undef ICOM_INTERFACE
/*** IUnknown methods ***/
#define IMalloc16_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IMalloc16_AddRef(p) ICOM_CALL (AddRef,p)
#define IMalloc16_Release(p) ICOM_CALL (Release,p)
/*** IMalloc16 methods ***/
#define IMalloc16_Alloc(p,a) ICOM_CALL1(Alloc,p,a)
#define IMalloc16_Realloc(p,a,b) ICOM_CALL2(Realloc,p,a,b)
#define IMalloc16_Free(p,a) ICOM_CALL1(Free,p,a)
#define IMalloc16_GetSize(p,a) ICOM_CALL1(GetSize,p,a)
#define IMalloc16_DidAlloc(p,a) ICOM_CALL1(DidAlloc,p,a)
#define IMalloc16_HeapMinimize(p) ICOM_CALL (HeapMinimize,p)
HRESULT WINAPI CoCreateStandardMalloc16(DWORD dwMemContext, LPMALLOC16* lpMalloc);
HRESULT WINAPI CoGetMalloc16(DWORD dwMemContext,LPMALLOC16* lpMalloc);
HRESULT WINAPI CoInitialize16(LPVOID lpReserved);
HRESULT WINAPI CoLockObjectExternal16(LPUNKNOWN,BOOL16,BOOL16);
HRESULT WINAPI CoRegisterClassObject16(REFCLSID,LPUNKNOWN,DWORD,DWORD,LPDWORD);
void WINAPI CoUninitialize16(void);
HRESULT WINAPI DoDragDrop16(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
OLESTATUS WINAPI OleRegisterServer16(LPCSTR,LPOLESERVER,LHSERVER *,HINSTANCE16,OLE_SERVER_USE);
OLESTATUS WINAPI OleUnblockServer16(LHSERVER,BOOL16 *);
OLESTATUS WINAPI OleRegisterServerDoc16(LHSERVER,LPCSTR,LPOLESERVERDOC,LHSERVERDOC *);
@ -269,9 +310,16 @@ OLESTATUS WINAPI OleCreateLinkFromClip16(
OLESTATUS WINAPI OleQueryLinkFromClip16(LPCSTR name, UINT16 render, UINT16 clipformat);
OLESTATUS WINAPI OleQueryCreateFromClip16(LPCSTR name, UINT16 render, UINT16 clipformat);
OLESTATUS WINAPI OleQueryType16(LPOLEOBJECT oleob, SEGPTR xlong);
OLESTATUS WINAPI OleCreateFromClip16(
LPCSTR name, LPOLECLIENT olecli, LHCLIENTDOC hclientdoc, LPCSTR xname,
LPOLEOBJECT *lpoleob, UINT16 render, UINT16 clipformat);
OLESTATUS WINAPI OleCreateFromClip16(LPCSTR,LPOLECLIENT,LHCLIENTDOC,LPCSTR,LPOLEOBJECT*,UINT16,UINT16);
HRESULT WINAPI RegisterDragDrop16(HWND16,LPDROPTARGET);
HRESULT WINAPI RevokeDragDrop16(HWND16);
BSTR16 WINAPI SysAllocString16(LPCOLESTR16);
INT16 WINAPI SysReAllocString16(LPBSTR16,LPCOLESTR16);
VOID WINAPI SysFreeString16(BSTR16);
BSTR16 WINAPI SysAllocStringLen16(const char*, int);
int WINAPI SysReAllocStringLen16(BSTR16*, const char*, int);
int WINAPI SysStringLen16(BSTR16);
#ifdef __cplusplus
} /*extern*/

3
include/ole2.h
View File

@ -38,11 +38,8 @@ extern "C" {
/*
* API declarations
*/
HRESULT WINAPI RegisterDragDrop16(HWND16,LPDROPTARGET);
HRESULT WINAPI RegisterDragDrop(HWND,LPDROPTARGET);
HRESULT WINAPI RevokeDragDrop16(HWND16);
HRESULT WINAPI RevokeDragDrop(HWND);
HRESULT WINAPI DoDragDrop16(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
HRESULT WINAPI DoDragDrop(LPDATAOBJECT,LPDROPSOURCE,DWORD,DWORD*);
HRESULT WINAPI OleLoadFromStream(IStream *pStm,REFIID iidInterface,void** ppvObj);
HRESULT WINAPI OleSaveToStream(IPersistStream *pPStm,IStream *pStm);

19
include/oleauto.h
View File

@ -18,18 +18,11 @@ struct tagVARIANT;
extern "C" {
#endif
BSTR16 WINAPI SysAllocString16(LPCOLESTR16);
BSTR WINAPI SysAllocString(const OLECHAR*);
INT16 WINAPI SysReAllocString16(LPBSTR16,LPCOLESTR16);
INT WINAPI SysReAllocString(LPBSTR,const OLECHAR*);
VOID WINAPI SysFreeString16(BSTR16);
VOID WINAPI SysFreeString(BSTR);
BSTR16 WINAPI SysAllocStringLen16(const char*, int);
BSTR WINAPI SysAllocStringLen(const OLECHAR*, UINT);
int WINAPI SysReAllocStringLen16(BSTR16*, const char*, int);
int WINAPI SysReAllocStringLen(BSTR*, const OLECHAR*, UINT);
int WINAPI SysStringLen16(BSTR16);
int WINAPI SysStringLen(BSTR);
/*****************************************************************
@ -486,24 +479,24 @@ HRESULT WINAPI VarDecFromDisp32(IDispatch*pdispIn, LCID lcid, DECIMAL*pdecOut);
#endif
typedef struct tagPARAMDATA {
OLECHAR16 * szName; /* parameter name */
OLECHAR * szName; /* parameter name */
VARTYPE vt; /* parameter type */
} PARAMDATA, * LPPARAMDATA;
typedef struct tagMETHODDATA {
OLECHAR16 * szName; /* method name */
PARAMDATA * ppdata; /* pointer to an array of PARAMDATAs */
OLECHAR * szName; /* method name */
PARAMDATA * ppdata; /* pointer to an array of PARAMDATAs */
DISPID dispid; /* method ID */
UINT16 iMeth; /* method index */
UINT iMeth; /* method index */
CALLCONV cc; /* calling convention */
UINT16 cArgs; /* count of arguments */
UINT cArgs; /* count of arguments */
WORD wFlags; /* same wFlags as on IDispatch::Invoke() */
VARTYPE vtReturn;
} METHODDATA, * LPMETHODDATA;
typedef struct tagINTERFACEDATA {
METHODDATA * pmethdata; /* pointer to an array of METHODDATAs */
UINT16 cMembers; /* count of members */
UINT cMembers; /* count of members */
} INTERFACEDATA, * LPINTERFACEDATA;
typedef enum tagREGKIND

46
include/shellapi.h
View File

@ -29,18 +29,14 @@ typedef struct _DRAGINFOW
DWORD grfKeyState;
} DRAGINFOW, LPDRAGINFOW;
void WINAPI DragAcceptFiles(HWND hWnd, BOOL b);
void WINAPI DragAcceptFiles16(HWND16 hWnd, BOOL16 b);
DECL_WINELIB_TYPE_AW(DRAGINFO)
DECL_WINELIB_TYPE_AW(LPDRAGINFO)
UINT16 WINAPI DragQueryFile16(HDROP16 hDrop, WORD wFile, LPSTR lpszFile, WORD wLength);
void WINAPI DragAcceptFiles(HWND hWnd, BOOL b);
UINT WINAPI DragQueryFileA(HDROP hDrop, UINT lFile, LPSTR lpszFile, UINT lLength);
UINT WINAPI DragQueryFileW(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength);
#define DragQueryFile WINELIB_NAME_AW(DragQueryFile)
void WINAPI DragFinish16(HDROP16 h);
#define DragQueryFile WINELIB_NAME_AW(DragQueryFile)
void WINAPI DragFinish(HDROP h);
BOOL16 WINAPI DragQueryPoint16(HDROP16 hDrop, POINT16 *p);
BOOL WINAPI DragQueryPoint(HDROP hDrop, POINT *p);
#define NIF_MESSAGE 0x00000001
@ -207,7 +203,6 @@ DWORD WINAPI SHFileOperationW (LPSHFILEOPSTRUCTW lpFileOp);
#define SE_ERR_DDEBUSY 30
#define SE_ERR_NOASSOC 31
HINSTANCE16 WINAPI ShellExecute16(HWND16,LPCSTR,LPCSTR,LPCSTR,LPCSTR,INT16);
HINSTANCE WINAPI ShellExecuteA(HWND,LPCSTR,LPCSTR,LPCSTR,LPCSTR,INT);
HINSTANCE WINAPI ShellExecuteW(HWND,LPCWSTR,LPCWSTR,LPCWSTR,LPCWSTR,INT);
#define ShellExecute WINELIB_NAME_AW(ShellExecute)
@ -247,30 +242,21 @@ BOOL WINAPI Shell_NotifyIconW(DWORD dwMessage, PNOTIFYICONDATAW lpData);
* Misc
*/
HICON16 WINAPI ExtractIcon16(HINSTANCE16,LPCSTR,UINT16);
HICON WINAPI ExtractIconA(HINSTANCE,LPCSTR,UINT);
HICON WINAPI ExtractIconW(HINSTANCE,LPCWSTR,UINT);
HICON WINAPI ExtractIconA(HINSTANCE,LPCSTR,UINT);
HICON WINAPI ExtractIconW(HINSTANCE,LPCWSTR,UINT);
#define ExtractIcon WINELIB_NAME_AW(ExtractIcon)
HICON16 WINAPI ExtractAssociatedIcon16(HINSTANCE16,LPSTR,LPWORD);
HICON WINAPI ExtractAssociatedIconA(HINSTANCE,LPSTR,LPWORD);
HICON WINAPI ExtractAssociatedIconW(HINSTANCE,LPWSTR,LPWORD);
HICON WINAPI ExtractAssociatedIconA(HINSTANCE,LPSTR,LPWORD);
HICON WINAPI ExtractAssociatedIconW(HINSTANCE,LPWSTR,LPWORD);
#define ExtractAssociatedIcon WINELIB_NAME_AW(ExtractAssociatedIcon)
HICON16 WINAPI ExtractIconEx16 ( LPCSTR, INT16, HICON16 *, HICON16 *, UINT16 );
HICON WINAPI ExtractIconExA( LPCSTR, INT, HICON *, HICON *, UINT );
HICON WINAPI ExtractIconExW( LPCWSTR, INT, HICON *, HICON *, UINT );
#define ExtractIconEx WINELIB_NAME_AW(ExtractIconEx)
HICON WINAPI ExtractIconExAW(LPCVOID, INT, HICON *, HICON *, UINT );
HINSTANCE16 WINAPI FindExecutable16(LPCSTR,LPCSTR,LPSTR);
HINSTANCE WINAPI FindExecutableA(LPCSTR,LPCSTR,LPSTR);
HINSTANCE WINAPI FindExecutableW(LPCWSTR,LPCWSTR,LPWSTR);
HICON WINAPI ExtractIconExA( LPCSTR, INT, HICON *, HICON *, UINT );
HICON WINAPI ExtractIconExW( LPCWSTR, INT, HICON *, HICON *, UINT );
#define ExtractIconEx WINELIB_NAME_AW(ExtractIconEx)
HICON WINAPI ExtractIconExAW(LPCVOID, INT, HICON *, HICON *, UINT );
HINSTANCE WINAPI FindExecutableA(LPCSTR,LPCSTR,LPSTR);
HINSTANCE WINAPI FindExecutableW(LPCWSTR,LPCWSTR,LPWSTR);
#define FindExecutable WINELIB_NAME_AW(FindExecutable)
BOOL16 WINAPI ShellAbout16(HWND16,LPCSTR,LPCSTR,HICON16);
BOOL WINAPI ShellAboutA(HWND,LPCSTR,LPCSTR,HICON);
BOOL WINAPI ShellAboutW(HWND,LPCWSTR,LPCWSTR,HICON);
BOOL WINAPI ShellAboutA(HWND,LPCSTR,LPCSTR,HICON);
BOOL WINAPI ShellAboutW(HWND,LPCWSTR,LPCWSTR,HICON);
#define ShellAbout WINELIB_NAME_AW(ShellAbout)
#ifdef __cplusplus

1
include/task.h
View File

@ -8,6 +8,7 @@
#define __WINE_TASK_H
#include "windef.h"
#include "wine/windef16.h"
#include "pshpack1.h"

1
include/thread.h
View File

@ -10,6 +10,7 @@
#include "config.h"
#include "ntdef.h" /* UNICODE_STRING */
#include "wine/windef16.h"
struct _PDB;
struct __EXCEPTION_FRAME;

1
include/toolhelp.h
View File

@ -2,6 +2,7 @@
#define __WINE_TOOLHELP_H
#include "windef.h"
#include "wine/windef16.h"
#define MAX_DATA 11
#define MAX_MODULE_NAME 9

101
include/vfw.h
View File

@ -1,8 +1,6 @@
#ifndef __WINE_VFW_H
#define __WINE_VFW_H
#include "config.h" /* for inline */
#include "windef.h"
#include "mmsystem.h"
#include "wingdi.h"
@ -15,7 +13,6 @@
extern "C" {
#endif /* __cplusplus */
typedef HANDLE16 HDRAWDIB16;
typedef HANDLE HDRAWDIB;
HWND VFWAPIV MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile);
@ -299,25 +296,6 @@ typedef struct {
/* 238: */
} ICINFO;
#include "pshpack1.h"
typedef struct {
DWORD dwSize;
DWORD fccType;
DWORD fccHandler;
DWORD dwFlags;
DWORD dwVersion;
DWORD dwVersionICM;
/*
* under Win16, normal chars are used
*/
CHAR szName[16];
CHAR szDescription[128];
CHAR szDriver[128];
} ICINFO16;
#include "poppack.h"
/* ICINFO.dwFlags */
#define VIDCF_QUALITY 0x0001 /* supports quality */
#define VIDCF_CRUNCH 0x0002 /* supports crunching to a frame size */
@ -383,28 +361,6 @@ typedef struct {
INT dySrc;
} ICDECOMPRESSEX;
#include "pshpack1.h"
typedef struct {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiSrc;
LPVOID lpSrc;
LPBITMAPINFOHEADER lpbiDst;
LPVOID lpDst;
INT16 xDst; /* destination rectangle */
INT16 yDst;
INT16 dxDst;
INT16 dyDst;
INT16 xSrc; /* source rectangle */
INT16 ySrc;
INT16 dxSrc;
INT16 dySrc;
} ICDECOMPRESSEX16;
#include "poppack.h"
DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,LPVOID lpData,LPBITMAPINFOHEADER lpbi,LPVOID lpBits);
#define ICDecompressBegin(hic, lpbiInput, lpbiOutput) \
@ -443,7 +399,6 @@ DWORD VFWAPIV ICDecompress(HIC hic,DWORD dwFlags,LPBITMAPINFOHEADER lpbiFormat,L
#define ICDecompressEnd(hic) ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0)
LRESULT VFWAPI ICSendMessage(HIC hic, UINT msg, DWORD dw1, DWORD dw2);
LRESULT VFWAPI ICSendMessage16(HIC16 hic, UINT16 msg, DWORD dw1, DWORD dw2);
inline static LRESULT VFWAPI ICDecompressEx(HIC hic, DWORD dwFlags,
LPBITMAPINFOHEADER lpbiSrc, LPVOID lpSrc,
@ -557,12 +512,10 @@ BOOL VFWAPI ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR
BOOL VFWAPI ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags);
LRESULT VFWAPI ICGetInfo(HIC hic,ICINFO *picinfo, DWORD cb);
HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode);
HIC16 VFWAPI ICOpen16(DWORD fccType, DWORD fccHangler, UINT16 wMode);
HIC VFWAPI ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler);
LRESULT VFWAPI ICClose(HIC hic);
HIC VFWAPI ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
HIC16 VFWAPI ICLocate16(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags);
HIC VFWAPI ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy);
/* Values for wFlags of ICInstall() */
@ -608,17 +561,6 @@ typedef struct {
HIC hicDecompressor;
} ICDRAWSUGGEST;
typedef struct {
DWORD dwFlags;
LPBITMAPINFOHEADER lpbiIn;
LPBITMAPINFOHEADER lpbiSuggest;
INT16 dxSrc;
INT16 dySrc;
INT16 dxDst;
INT16 dyDst;
HIC16 hicDecompressor;
} ICDRAWSUGGEST16;
typedef struct {
DWORD dwFlags;
int iStart;
@ -645,25 +587,6 @@ DWORD VFWAPIV ICDrawBegin(
DWORD dwScale
);
DWORD VFWAPIV ICDrawBegin16(
HIC16 hic,
DWORD dwFlags,/* flags */
HPALETTE16 hpal, /* palette to draw with */
HWND16 hwnd, /* window to draw to */
HDC16 hdc, /* HDC to draw to */
INT16 xDst, /* destination rectangle */
INT16 yDst,
INT16 dxDst,
INT16 dyDst,
LPBITMAPINFOHEADER lpbi, /* format of frame to draw */
INT16 xSrc, /* source rectangle */
INT16 ySrc,
INT16 dxSrc,
INT16 dySrc,
DWORD dwRate, /* frames/second = (dwRate/dwScale) */
DWORD dwScale
);
/* as passed to ICM_DRAW_BEGIN */
typedef struct {
DWORD dwFlags;
@ -683,28 +606,6 @@ typedef struct {
DWORD dwScale;
} ICDRAWBEGIN;
#include "pshpack1.h"
typedef struct {
DWORD dwFlags;
HPALETTE16 hpal;
HWND16 hwnd;
HDC16 hdc;
INT16 xDst;
INT16 yDst;
INT16 dxDst;
INT16 dyDst;
LPBITMAPINFOHEADER lpbi;
INT16 xSrc;
INT16 ySrc;
INT16 dxSrc;
INT16 dySrc;
DWORD dwRate;
DWORD dwScale;
} ICDRAWBEGIN16;
#include "poppack.h"
#define ICDRAW_HURRYUP 0x80000000L /* don't draw just buffer (hurry up!) */
#define ICDRAW_UPDATE 0x40000000L /* don't draw just update screen */
#define ICDRAW_PREROLL 0x20000000L /* this frame is before real start */
@ -899,7 +800,7 @@ typedef struct {
DWORD dwSuggestedBufferSize;
DWORD dwQuality;
DWORD dwSampleSize;
RECT16 rcFrame; /* word.word - word.word in file */
struct { SHORT left, top, right, bottom; } rcFrame; /* word.word - word.word in file */
} AVIStreamHeader;
/* AVIINDEXENTRY.dwFlags */

1
include/win.h
View File

@ -11,6 +11,7 @@
#include "wingdi.h"
#include "winproc.h"
#include "winuser.h"
#include "wine/windef16.h"
#define WND_MAGIC 0x444e4957 /* 'WIND' */

52
include/winbase.h
View File

@ -253,7 +253,6 @@ typedef struct
#define PROCESS_HEAP_ENTRY_MOVEABLE 0x0010
#define PROCESS_HEAP_ENTRY_DDESHARE 0x0020
#define INVALID_HANDLE_VALUE16 ((HANDLE16) -1)
#define INVALID_HANDLE_VALUE ((HANDLE) -1)
#define TLS_OUT_OF_INDEXES ((DWORD)0xFFFFFFFF)
@ -288,7 +287,6 @@ typedef struct
#define TWOSTOPBITS 2
#define IGNORE 0
#define INFINITE16 0xFFFF
#define INFINITE 0xFFFFFFFF
#define CE_RXOVER 0x0001
@ -980,15 +978,6 @@ typedef DWORD CALLBACK (*LPPROGRESS_ROUTINE)(LARGE_INTEGER, LARGE_INTEGER, LARGE
#define CRITICAL_SECTION_INIT { 0, -1, 0, 0, 0, 0 }
#endif
typedef struct {
DWORD dwOSVersionInfoSize;
DWORD dwMajorVersion;
DWORD dwMinorVersion;
DWORD dwBuildNumber;
DWORD dwPlatformId;
CHAR szCSDVersion[128];
} OSVERSIONINFO16;
typedef struct {
DWORD dwOSVersionInfoSize;
DWORD dwMajorVersion;
@ -1208,7 +1197,6 @@ typedef void CALLBACK (*PAPCFUNC)(ULONG_PTR);
typedef void CALLBACK (*PTIMERAPCROUTINE)(LPVOID,DWORD,DWORD);
/*DWORD WINAPI GetVersion( void );*/
BOOL16 WINAPI GetVersionEx16(OSVERSIONINFO16*);
BOOL WINAPI GetVersionExA(OSVERSIONINFOA*);
BOOL WINAPI GetVersionExW(OSVERSIONINFOW*);
#define GetVersionEx WINELIB_NAME_AW(GetVersionEx)
@ -1243,11 +1231,8 @@ BOOL WINAPI GetBinaryTypeA( LPCSTR lpApplicationName, LPDWORD lpBinaryType );
BOOL WINAPI GetBinaryTypeW( LPCWSTR lpApplicationName, LPDWORD lpBinaryType );
#define GetBinaryType WINELIB_NAME_AW(GetBinaryType)
BOOL16 WINAPI GetWinDebugInfo16(LPWINDEBUGINFO,UINT16);
BOOL16 WINAPI SetWinDebugInfo16(LPWINDEBUGINFO);
/* Declarations for functions that exist only in Win32 */
BOOL WINAPI AddAccessAllowedAce(PACL,DWORD,DWORD,PSID);
BOOL WINAPI AttachThreadInput(DWORD,DWORD,BOOL);
BOOL WINAPI AccessCheck(PSECURITY_DESCRIPTOR,HANDLE,DWORD,PGENERIC_MAPPING,PPRIVILEGE_SET,LPDWORD,LPDWORD,LPBOOL);
@ -1516,8 +1501,8 @@ BOOL WINAPI LookupPrivilegeValueA(LPCSTR,LPCSTR,LPVOID);
BOOL WINAPI LookupPrivilegeValueW(LPCWSTR,LPCWSTR,LPVOID);
#define LookupPrivilegeValue WINELIB_NAME_AW(LookupPrivilegeValue)
BOOL WINAPI MakeSelfRelativeSD(PSECURITY_DESCRIPTOR,PSECURITY_DESCRIPTOR,LPDWORD);
HMODULE WINAPI MapHModuleSL(HMODULE16);
HMODULE16 WINAPI MapHModuleLS(HMODULE);
HMODULE WINAPI MapHModuleSL(WORD);
WORD WINAPI MapHModuleLS(HMODULE);
SEGPTR WINAPI MapLS(LPVOID);
LPVOID WINAPI MapSL(SEGPTR);
LPVOID WINAPI MapViewOfFile(HANDLE,DWORD,DWORD,DWORD,DWORD);
@ -1693,17 +1678,15 @@ void WINAPI FatalAppExitW(UINT,LPCWSTR);
ATOM WINAPI FindAtomA(LPCSTR);
ATOM WINAPI FindAtomW(LPCWSTR);
#define FindAtom WINELIB_NAME_AW(FindAtom)
BOOL WINAPI FindClose(HANDLE);
HANDLE16 WINAPI FindFirstFile16(LPCSTR,LPWIN32_FIND_DATAA);
HANDLE WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
HANDLE WINAPI FindFirstFileW(LPCWSTR,LPWIN32_FIND_DATAW);
BOOL WINAPI FindClose(HANDLE);
HANDLE WINAPI FindFirstFileA(LPCSTR,LPWIN32_FIND_DATAA);
HANDLE WINAPI FindFirstFileW(LPCWSTR,LPWIN32_FIND_DATAW);
#define FindFirstFile WINELIB_NAME_AW(FindFirstFile)
HANDLE WINAPI FindFirstFileExA(LPCSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
HANDLE WINAPI FindFirstFileExW(LPCWSTR,FINDEX_INFO_LEVELS,LPVOID,FINDEX_SEARCH_OPS,LPVOID,DWORD);
#define FindFirstFileEx WINELIB_NAME_AW(FindFirstFileEx)
BOOL16 WINAPI FindNextFile16(HANDLE16,LPWIN32_FIND_DATAA);
BOOL WINAPI FindNextFileA(HANDLE,LPWIN32_FIND_DATAA);
BOOL WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
BOOL WINAPI FindNextFileA(HANDLE,LPWIN32_FIND_DATAA);
BOOL WINAPI FindNextFileW(HANDLE,LPWIN32_FIND_DATAW);
#define FindNextFile WINELIB_NAME_AW(FindNextFile)
HRSRC WINAPI FindResourceA(HMODULE,LPCSTR,LPCSTR);
HRSRC WINAPI FindResourceW(HMODULE,LPCWSTR,LPCWSTR);
@ -1796,7 +1779,6 @@ UINT WINAPI GetWindowsDirectoryW(LPWSTR,UINT);
ATOM WINAPI GlobalAddAtomA(LPCSTR);
ATOM WINAPI GlobalAddAtomW(LPCWSTR);
#define GlobalAddAtom WINELIB_NAME_AW(GlobalAddAtom)
HGLOBAL16 WINAPI GlobalAlloc16(UINT16,DWORD);
HGLOBAL WINAPI GlobalAlloc(UINT,DWORD);
DWORD WINAPI GlobalCompact(DWORD);
ATOM WINAPI GlobalDeleteAtom(ATOM);
@ -1804,26 +1786,18 @@ ATOM WINAPI GlobalFindAtomA(LPCSTR);
ATOM WINAPI GlobalFindAtomW(LPCWSTR);
#define GlobalFindAtom WINELIB_NAME_AW(GlobalFindAtom)
UINT WINAPI GlobalFlags(HGLOBAL);
HGLOBAL16 WINAPI GlobalFree16(HGLOBAL16);
HGLOBAL WINAPI GlobalFree(HGLOBAL);
UINT WINAPI GlobalGetAtomNameA(ATOM,LPSTR,INT);
UINT WINAPI GlobalGetAtomNameW(ATOM,LPWSTR,INT);
#define GlobalGetAtomName WINELIB_NAME_AW(GlobalGetAtomName)
HGLOBAL WINAPI GlobalHandle(LPCVOID);
WORD WINAPI GlobalFix16(HGLOBAL16);
HGLOBAL WINAPI GlobalHandle(LPCVOID);
VOID WINAPI GlobalFix(HGLOBAL);
LPVOID WINAPI GlobalLock16(HGLOBAL16);
LPVOID WINAPI GlobalLock(HGLOBAL);
HGLOBAL WINAPI GlobalReAlloc(HGLOBAL,DWORD,UINT);
DWORD WINAPI GlobalSize16(HGLOBAL16);
HGLOBAL WINAPI GlobalReAlloc(HGLOBAL,DWORD,UINT);
DWORD WINAPI GlobalSize(HGLOBAL);
VOID WINAPI GlobalUnfix16(HGLOBAL16);
VOID WINAPI GlobalUnfix(HGLOBAL);
BOOL16 WINAPI GlobalUnlock16(HGLOBAL16);
BOOL WINAPI GlobalUnlock(HGLOBAL);
BOOL16 WINAPI GlobalUnWire16(HGLOBAL16);
BOOL WINAPI GlobalUnWire(HGLOBAL);
SEGPTR WINAPI GlobalWire16(HGLOBAL16);
BOOL WINAPI GlobalUnlock(HGLOBAL);
BOOL WINAPI GlobalUnWire(HGLOBAL);
LPVOID WINAPI GlobalWire(HGLOBAL);
BOOL WINAPI InitAtomTable(DWORD);
BOOL WINAPI IsBadCodePtr(FARPROC);
@ -1857,8 +1831,7 @@ BOOL WINAPI LocalUnlock(HLOCAL);
LPVOID WINAPI LockResource(HGLOBAL);
#define LockSegment(handle) GlobalFix((HANDLE)(handle))
#define MakeProcInstance(proc,inst) (proc)
HFILE16 WINAPI OpenFile16(LPCSTR,OFSTRUCT*,UINT16);
HFILE WINAPI OpenFile(LPCSTR,OFSTRUCT*,UINT);
HFILE WINAPI OpenFile(LPCSTR,OFSTRUCT*,UINT);
VOID WINAPI OutputDebugStringA(LPCSTR);
VOID WINAPI OutputDebugStringW(LPCWSTR);
#define OutputDebugString WINELIB_NAME_AW(OutputDebugString)
@ -1919,7 +1892,6 @@ LONG WINAPI _llseek(HFILE,LONG,INT);
HFILE WINAPI _lopen(LPCSTR,INT);
UINT WINAPI _lread(HFILE,LPVOID,UINT);
UINT WINAPI _lwrite(HFILE,LPCSTR,UINT);
SEGPTR WINAPI WIN16_GlobalLock16(HGLOBAL16);
INT WINAPI lstrcmpA(LPCSTR,LPCSTR);
INT WINAPI lstrcmpW(LPCWSTR,LPCWSTR);
#define lstrcmp WINELIB_NAME_AW(lstrcmp)

4
include/wincon.h
View File

@ -176,8 +176,4 @@ BOOL WINAPI GetConsoleScreenBufferInfo(HANDLE hConsoleOutput,
BOOL WINAPI SetConsoleScreenBufferSize(HANDLE hConsoleOutput,
COORD dwSize);
#ifdef __WINE__
extern HANDLE CONSOLE_OpenHandle( BOOL output, DWORD access, LPSECURITY_ATTRIBUTES sa );
#endif
#endif /* __WINE_WINCON_H */

39
include/windef.h
View File

@ -8,7 +8,6 @@
#define __WINE_WINDEF_H
#ifdef __WINE__
# include "config.h"
# undef UNICODE
#endif /* __WINE__ */
@ -337,12 +336,6 @@ typedef VOID CALLBACK (*TIMERPROC)(HWND,UINT,UINT,DWORD);
typedef BOOL CALLBACK (*WNDENUMPROC)(HWND,LPARAM);
typedef LRESULT CALLBACK (*WNDPROC)(HWND,UINT,WPARAM,LPARAM);
/*----------------------------------------------------------------------------
** FIXME: Better isolate Wine's reliance on the xxx16 type definitions.
** For now, we just isolate them to make the situation clear.
**--------------------------------------------------------------------------*/
#include "wine/windef16.h"
/* Define some empty macros for compatibility with Windows code. */
#ifndef __WINE__
@ -377,8 +370,8 @@ typedef LRESULT CALLBACK (*WNDPROC)(HWND,UINT,WPARAM,LPARAM);
#define LOWORD(l) ((WORD)(DWORD)(l))
#define HIWORD(l) ((WORD)((DWORD)(l) >> 16))
#define SLOWORD(l) ((INT16)(LONG)(l))
#define SHIWORD(l) ((INT16)((LONG)(l) >> 16))
#define SLOWORD(l) ((SHORT)(LONG)(l))
#define SHIWORD(l) ((SHORT)((LONG)(l) >> 16))
#define MAKEWORD(low,high) ((WORD)(((BYTE)(low)) | ((WORD)((BYTE)(high))) << 8))
#define MAKELONG(low,high) ((LONG)(((WORD)(low)) | (((DWORD)((WORD)(high))) << 16)))
@ -443,7 +436,6 @@ typedef LRESULT CALLBACK (*WNDPROC)(HWND,UINT,WPARAM,LPARAM);
#define _MAX_FNAME 255
#define _MAX_EXT 256
#define HFILE_ERROR16 ((HFILE16)-1)
#define HFILE_ERROR ((HFILE)-1)
/* The SIZE structure */
@ -455,11 +447,6 @@ typedef struct tagSIZE
typedef SIZE SIZEL, *PSIZEL, *LPSIZEL;
#define CONV_SIZE16TO32(s16,s32) \
((s32)->cx = (INT)(s16)->cx, (s32)->cy = (INT)(s16)->cy)
#define CONV_SIZE32TO16(s32,s16) \
((s16)->cx = (INT16)(s32)->cx, (s16)->cy = (INT16)(s32)->cy)
/* The POINT structure */
typedef struct tagPOINT
{
@ -473,25 +460,14 @@ typedef struct _POINTL
LONG y;
} POINTL;
#define CONV_POINT16TO32(p16,p32) \
((p32)->x = (INT)(p16)->x, (p32)->y = (INT)(p16)->y)
#define CONV_POINT32TO16(p32,p16) \
((p16)->x = (INT16)(p32)->x, (p16)->y = (INT16)(p32)->y)
#define MAKEPOINT16(l) (*((POINT16 *)&(l)))
/* The POINTS structure */
typedef struct tagPOINTS
{
SHORT x;
SHORT y;
SHORT x;
SHORT y;
} POINTS, *PPOINTS, *LPPOINTS;
#define MAKEPOINTS(l) (*((POINTS *)&(l)))
/* The RECT structure */
typedef struct tagRECT
{
@ -513,13 +489,6 @@ typedef struct tagRECTL
typedef const RECTL *LPCRECTL;
#define CONV_RECT16TO32(r16,r32) \
((r32)->left = (INT)(r16)->left, (r32)->top = (INT)(r16)->top, \
(r32)->right = (INT)(r16)->right, (r32)->bottom = (INT)(r16)->bottom)
#define CONV_RECT32TO16(r32,r16) \
((r16)->left = (INT16)(r32)->left, (r16)->top = (INT16)(r32)->top, \
(r16)->right = (INT16)(r32)->right, (r16)->bottom = (INT16)(r32)->bottom)
#ifdef __cplusplus
}
#endif

10
include/wine/exception.h
View File

@ -9,7 +9,6 @@
#include <setjmp.h>
#include "winnt.h"
#include "thread.h"
/* The following definitions allow using exceptions in Wine and Winelib code
*
@ -145,9 +144,9 @@ static inline EXCEPTION_FRAME * WINE_UNUSED __wine_push_frame( EXCEPTION_FRAME *
: "=&r" (prev) : "r" (frame) : "memory" );
return prev;
#else
TEB *teb = NtCurrentTeb();
frame->Prev = teb->except;
teb->except = frame;
NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
frame->Prev = (void *)teb->ExceptionList;
teb->ExceptionList = (void *)frame;
return frame->Prev;
#endif
}
@ -160,7 +159,8 @@ static inline EXCEPTION_FRAME * WINE_UNUSED __wine_pop_frame( EXCEPTION_FRAME *f
return frame->Prev;
#else
NtCurrentTeb()->except = frame->Prev;
NT_TIB *teb = (NT_TIB *)NtCurrentTeb();
teb->ExceptionList = (void *)frame->Prev;
return frame->Prev;
#endif
}

2
include/wine/keyboard16.h
View File

@ -2,7 +2,9 @@
#define __WINE_WINE_KEYBOARD16_H
#include "windef.h"
#include "wine/windef16.h"
VOID WINAPI ScreenSwitchEnable16(WORD);
INT16 WINAPI ToAscii16(UINT16,UINT16,LPBYTE,LPVOID,UINT16);
WORD WINAPI VkKeyScan16(CHAR);
INT16 WINAPI AnsiToOem16(LPCSTR,LPSTR);

569
include/wine/mmsystem16.h Normal file
View File

@ -0,0 +1,569 @@
/*
* MMSYSTEM - Multimedia Wine Extension ... :-)
*/
#ifndef __WINE_WINE_MMSYSTEM16_H
#define __WINE_WINE_MMSYSTEM16_H
#ifdef __cplusplus
extern "C" {
#endif
#include "windef.h"
#include "wine/windef16.h"
typedef UINT16 MMVERSION16;
typedef UINT16 MCIDEVICEID16;
typedef UINT16 MMRESULT16;
typedef struct {
UINT16 wType; /* indicates the contents of the union */
union {
DWORD ms; /* milliseconds */
DWORD sample; /* samples */
DWORD cb; /* byte count */
struct { /* SMPTE */
BYTE hour; /* hours */
BYTE min; /* minutes */
BYTE sec; /* seconds */
BYTE frame; /* frames */
BYTE fps; /* frames per second */
BYTE dummy; /* pad */
} smpte;
struct { /* MIDI */
DWORD songptrpos; /* song pointer position */
} midi;
} u;
} MMTIME16, *LPMMTIME16;
typedef struct {
DWORD dwDCISize;
LPCSTR lpszDCISectionName;
LPCSTR lpszDCIAliasName;
} DRVCONFIGINFO16, *LPDRVCONFIGINFO16;
/* GetDriverInfo16 references this structure, so this a struct defined
* in the Win16 API.
* GetDriverInfo has been deprecated in Win32.
*/
typedef struct
{
UINT16 length;
HDRVR16 hDriver;
HINSTANCE16 hModule;
CHAR szAliasName[128];
} DRIVERINFOSTRUCT16, *LPDRIVERINFOSTRUCT16;
LRESULT WINAPI DefDriverProc16(DWORD,HDRVR16,UINT16,LPARAM,LPARAM);
HDRVR16 WINAPI OpenDriver16(LPCSTR,LPCSTR,LPARAM);
LRESULT WINAPI CloseDriver16(HDRVR16,LPARAM,LPARAM);
LRESULT WINAPI SendDriverMessage16(HDRVR16,UINT16,LPARAM,LPARAM);
HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16);
HDRVR16 WINAPI GetNextDriver16(HDRVR16,DWORD);
BOOL16 WINAPI GetDriverInfo16(HDRVR16,DRIVERINFOSTRUCT16 *);
typedef void CALLBACK (*LPDRVCALLBACK16) (HDRVR16,UINT16,DWORD,DWORD,DWORD);
typedef LPDRVCALLBACK16 LPWAVECALLBACK16;
UINT16 WINAPI mmsystemGetVersion16(void);
BOOL16 WINAPI sndPlaySound16(LPCSTR,UINT16);
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN]; /* product name (0 terminated string) */
DWORD dwFormats; /* formats supported */
WORD wChannels; /* number of sources supported */
DWORD dwSupport; /* functionality supported by driver */
} WAVEOUTCAPS16, *LPWAVEOUTCAPS16;
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN]; /* product name (0 terminated string) */
DWORD dwFormats; /* formats supported */
WORD wChannels; /* number of channels supported */
} WAVEINCAPS16, *LPWAVEINCAPS16;
UINT16 WINAPI waveOutGetNumDevs16(void);
UINT16 WINAPI waveOutGetDevCaps16(UINT16,LPWAVEOUTCAPS16,UINT16);
UINT16 WINAPI waveOutGetVolume16(UINT16,DWORD*);
UINT16 WINAPI waveOutSetVolume16(UINT16,DWORD);
UINT16 WINAPI waveOutGetErrorText16(UINT16,LPSTR,UINT16);
UINT16 WINAPI waveOutOpen16(HWAVEOUT16*,UINT16,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
UINT16 WINAPI waveOutClose16(HWAVEOUT16);
UINT16 WINAPI waveOutPrepareHeader16(HWAVEOUT16,WAVEHDR*,UINT16);
UINT16 WINAPI waveOutUnprepareHeader16(HWAVEOUT16,WAVEHDR*,UINT16);
UINT16 WINAPI waveOutWrite16(HWAVEOUT16,WAVEHDR*,UINT16);
UINT16 WINAPI waveOutPause16(HWAVEOUT16);
UINT16 WINAPI waveOutRestart16(HWAVEOUT16);
UINT16 WINAPI waveOutReset16(HWAVEOUT16);
UINT16 WINAPI waveOutBreakLoop16(HWAVEOUT16);
UINT16 WINAPI waveOutGetPosition16(HWAVEOUT16,LPMMTIME16,UINT16);
UINT16 WINAPI waveOutGetPitch16(HWAVEOUT16,DWORD*);
UINT16 WINAPI waveOutSetPitch16(HWAVEOUT16,DWORD);
UINT16 WINAPI waveOutGetPlaybackRate16(HWAVEOUT16,DWORD*);
UINT16 WINAPI waveOutSetPlaybackRate16(HWAVEOUT16,DWORD);
UINT16 WINAPI waveOutGetID16(HWAVEOUT16,UINT16*);
DWORD WINAPI waveOutMessage16(HWAVEOUT16,UINT16,DWORD,DWORD);
UINT16 WINAPI waveInGetNumDevs16(void);
UINT16 WINAPI waveInGetDevCaps16(UINT16,LPWAVEINCAPS16,UINT16);
UINT16 WINAPI waveInGetErrorText16(UINT16,LPSTR,UINT16);
UINT16 WINAPI waveInOpen16(HWAVEIN16*,UINT16,const LPWAVEFORMATEX,DWORD,DWORD,DWORD);
UINT16 WINAPI waveInClose16(HWAVEIN16);
UINT16 WINAPI waveInPrepareHeader16(HWAVEIN16,WAVEHDR*,UINT16);
UINT16 WINAPI waveInUnprepareHeader16(HWAVEIN16,WAVEHDR*,UINT16);
UINT16 WINAPI waveInAddBuffer16(HWAVEIN16,WAVEHDR*,UINT16);
UINT16 WINAPI waveInStart16(HWAVEIN16);
UINT16 WINAPI waveInStop16(HWAVEIN16);
UINT16 WINAPI waveInReset16(HWAVEIN16);
UINT16 WINAPI waveInGetPosition16(HWAVEIN16,LPMMTIME16,UINT16);
UINT16 WINAPI waveInGetID16(HWAVEIN16,UINT16*);
DWORD WINAPI waveInMessage16(HWAVEIN16,UINT16,DWORD,DWORD);
typedef LPDRVCALLBACK16 LPMIDICALLBACK16;
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
WORD wTechnology; /* type of device */
WORD wVoices; /* # of voices (internal synth only) */
WORD wNotes; /* max # of notes (internal synth only) */
WORD wChannelMask; /* channels used (internal synth only) */
DWORD dwSupport; /* functionality supported by driver */
} MIDIOUTCAPS16, *LPMIDIOUTCAPS16;
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN];/* product name (NULL terminated string) */
DWORD dwSupport; /* included in win95 and higher */
} MIDIINCAPS16, *LPMIDIINCAPS16;
typedef struct midihdr16_tag {
LPSTR lpData; /* pointer to locked data block */
DWORD dwBufferLength; /* length of data in data block */
DWORD dwBytesRecorded;/* used for input only */
DWORD dwUser; /* for client's use */
DWORD dwFlags; /* assorted flags (see defines) */
struct midihdr16_tag *lpNext; /* reserved for driver */
DWORD reserved; /* reserved for driver */
} MIDIHDR16, *LPMIDIHDR16;
UINT16 WINAPI midiOutGetNumDevs16(void);
UINT16 WINAPI midiOutGetDevCaps16(UINT16,LPMIDIOUTCAPS16,UINT16);
UINT16 WINAPI midiOutGetVolume16(UINT16,DWORD*);
UINT16 WINAPI midiOutSetVolume16(UINT16,DWORD);
UINT16 WINAPI midiOutGetErrorText16(UINT16,LPSTR,UINT16);
UINT16 WINAPI midiOutOpen16(HMIDIOUT16*,UINT16,DWORD,DWORD,DWORD);
UINT16 WINAPI midiOutClose16(HMIDIOUT16);
UINT16 WINAPI midiOutPrepareHeader16(HMIDIOUT16,MIDIHDR16*,UINT16);
UINT16 WINAPI midiOutUnprepareHeader16(HMIDIOUT16,MIDIHDR16*,UINT16);
UINT16 WINAPI midiOutShortMsg16(HMIDIOUT16,DWORD);
UINT16 WINAPI midiOutLongMsg16(HMIDIOUT16,MIDIHDR16*,UINT16);
UINT16 WINAPI midiOutReset16(HMIDIOUT16);
UINT16 WINAPI midiOutCachePatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
UINT16 WINAPI midiOutCacheDrumPatches16(HMIDIOUT16,UINT16,WORD*,UINT16);
UINT16 WINAPI midiOutGetID16(HMIDIOUT16,UINT16*);
DWORD WINAPI midiOutMessage16(HMIDIOUT16,UINT16,DWORD,DWORD);
UINT16 WINAPI midiInGetNumDevs16(void);
UINT16 WINAPI midiInGetDevCaps16(UINT16,LPMIDIINCAPS16,UINT16);
UINT16 WINAPI midiInGetErrorText16(UINT16,LPSTR,UINT16);
UINT16 WINAPI midiInOpen16(HMIDIIN16*,UINT16,DWORD,DWORD,DWORD);
UINT16 WINAPI midiInClose16(HMIDIIN16);
UINT16 WINAPI midiInPrepareHeader16(HMIDIIN16,MIDIHDR16*,UINT16);
UINT16 WINAPI midiInUnprepareHeader16(HMIDIIN16,MIDIHDR16*,UINT16);
UINT16 WINAPI midiInAddBuffer16(HMIDIIN16,MIDIHDR16*,UINT16);
UINT16 WINAPI midiInStart16(HMIDIIN16);
UINT16 WINAPI midiInStop16(HMIDIIN16);
UINT16 WINAPI midiInReset16(HMIDIIN16);
UINT16 WINAPI midiInGetID16(HMIDIIN16,UINT16*);
DWORD WINAPI midiInMessage16(HMIDIIN16,UINT16,DWORD,DWORD);
MMRESULT16 WINAPI midiStreamClose16(HMIDISTRM16 hms);
MMRESULT16 WINAPI midiStreamOpen16(HMIDISTRM16*,LPUINT16,DWORD,DWORD,DWORD,DWORD);
MMRESULT16 WINAPI midiStreamOut16(HMIDISTRM16,LPMIDIHDR16,UINT16);
MMRESULT16 WINAPI midiStreamPause16(HMIDISTRM16);
MMRESULT16 WINAPI midiStreamPosition16(HMIDISTRM16,LPMMTIME16,UINT16);
MMRESULT16 WINAPI midiStreamProperty16(HMIDISTRM16,LPBYTE,DWORD);
MMRESULT16 WINAPI midiStreamRestart16(HMIDISTRM16);
MMRESULT16 WINAPI midiStreamStop16(HMIDISTRM16);
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN]; /* product name (NULL terminated string) */
WORD wTechnology; /* type of device */
DWORD dwSupport; /* functionality supported by driver */
} AUXCAPS16, *LPAUXCAPS16;
typedef void CALLBACK (*LPTIMECALLBACK16)(UINT16,UINT16,DWORD,DWORD,DWORD);
typedef struct {
UINT16 wPeriodMin; /* minimum period supported */
UINT16 wPeriodMax; /* maximum period supported */
} TIMECAPS16,*LPTIMECAPS16;
typedef struct {
WORD wMid; /* manufacturer ID */
WORD wPid; /* product ID */
char szPname[MAXPNAMELEN]; /* product name (NULL terminated string) */
UINT16 wXmin; /* minimum x position value */
UINT16 wXmax; /* maximum x position value */
UINT16 wYmin; /* minimum y position value */
UINT16 wYmax; /* maximum y position value */
UINT16 wZmin; /* minimum z position value */
UINT16 wZmax; /* maximum z position value */
UINT16 wNumButtons; /* number of buttons */
UINT16 wPeriodMin; /* minimum message period when captured */
UINT16 wPeriodMax; /* maximum message period when captured */
/* win95,nt4 additions: */
UINT16 wRmin; /* minimum r position value */
UINT16 wRmax; /* maximum r position value */
UINT16 wUmin; /* minimum u (5th axis) position value */
UINT16 wUmax; /* maximum u (5th axis) position value */
UINT16 wVmin; /* minimum v (6th axis) position value */
UINT16 wVmax; /* maximum v (6th axis) position value */
UINT16 wCaps; /* joystick capabilites */
UINT16 wMaxAxes; /* maximum number of axes supported */
UINT16 wNumAxes; /* number of axes in use */
UINT16 wMaxButtons; /* maximum number of buttons supported */
CHAR szRegKey[MAXPNAMELEN]; /* registry key */
CHAR szOEMVxD[MAX_JOYSTICKOEMVXDNAME]; /* OEM VxD in use */
} JOYCAPS16, *LPJOYCAPS16;
typedef struct {
UINT16 wXpos; /* x position */
UINT16 wYpos; /* y position */
UINT16 wZpos; /* z position */
UINT16 wButtons; /* button states */
} JOYINFO16, *LPJOYINFO16;
typedef struct {
WORD wMid; /* manufacturer id */
WORD wPid; /* product id */
MMVERSION16 vDriverVersion; /* version of the driver */
CHAR szPname[MAXPNAMELEN]; /* product name */
DWORD fdwSupport; /* misc. support bits */
DWORD cDestinations; /* count of destinations */
} MIXERCAPS16,*LPMIXERCAPS16;
typedef struct {
DWORD cbStruct; /* size of MIXERLINE structure */
DWORD dwDestination; /* zero based destination index */
DWORD dwSource; /* zero based source index (if source) */
DWORD dwLineID; /* unique line id for mixer device */
DWORD fdwLine; /* state/information about line */
DWORD dwUser; /* driver specific information */
DWORD dwComponentType; /* component type line connects to */
DWORD cChannels; /* number of channels line supports */
DWORD cConnections; /* number of connections [possible] */
DWORD cControls; /* number of controls at this line */
CHAR szShortName[MIXER_SHORT_NAME_CHARS];
CHAR szName[MIXER_LONG_NAME_CHARS];
struct {
DWORD dwType; /* MIXERLINE_TARGETTYPE_xxxx */
DWORD dwDeviceID; /* target device ID of device type */
WORD wMid; /* of target device */
WORD wPid; /* " */
MMVERSION16 vDriverVersion; /* " */
CHAR szPname[MAXPNAMELEN]; /* " */
} Target;
} MIXERLINE16, *LPMIXERLINE16;
typedef struct {
DWORD cbStruct; /* size in bytes of MIXERCONTROL */
DWORD dwControlID; /* unique control id for mixer device */
DWORD dwControlType; /* MIXERCONTROL_CONTROLTYPE_xxx */
DWORD fdwControl; /* MIXERCONTROL_CONTROLF_xxx */
DWORD cMultipleItems; /* if MIXERCONTROL_CONTROLF_MULTIPLE set */
CHAR szShortName[MIXER_SHORT_NAME_CHARS];
CHAR szName[MIXER_LONG_NAME_CHARS];
union {
struct {
LONG lMinimum; /* signed minimum for this control */
LONG lMaximum; /* signed maximum for this control */
} DUMMYSTRUCTNAME;
struct {
DWORD dwMinimum; /* unsigned minimum for this control */
DWORD dwMaximum; /* unsigned maximum for this control */
} DUMMYSTRUCTNAME1;
DWORD dwReserved[6];
} Bounds;
union {
DWORD cSteps; /* # of steps between min & max */
DWORD cbCustomData; /* size in bytes of custom data */
DWORD dwReserved[6]; /* !!! needed? we have cbStruct.... */
} Metrics;
} MIXERCONTROL16, *LPMIXERCONTROL16;
typedef struct {
DWORD cbStruct; /* size in bytes of MIXERLINECONTROLS */
DWORD dwLineID; /* line id (from MIXERLINE.dwLineID) */
union {
DWORD dwControlID; /* MIXER_GETLINECONTROLSF_ONEBYID */
DWORD dwControlType; /* MIXER_GETLINECONTROLSF_ONEBYTYPE */
} DUMMYUNIONNAME;
DWORD cControls; /* count of controls pmxctrl points to */
DWORD cbmxctrl; /* size in bytes of _one_ MIXERCONTROL */
LPMIXERCONTROL16 pamxctrl;/* pointer to first MIXERCONTROL array */
} MIXERLINECONTROLS16, *LPMIXERLINECONTROLS16;
typedef struct {
DWORD cbStruct; /* size in bytes of MIXERCONTROLDETAILS */
DWORD dwControlID; /* control id to get/set details on */
DWORD cChannels; /* number of channels in paDetails array */
union {
HWND16 hwndOwner; /* for MIXER_SETCONTROLDETAILSF_CUSTOM */
DWORD cMultipleItems; /* if _MULTIPLE, the number of items per channel */
} DUMMYUNIONNAME;
DWORD cbDetails; /* size of _one_ details_XX struct */
LPVOID paDetails; /* pointer to array of details_XX structs */
} MIXERCONTROLDETAILS16,*LPMIXERCONTROLDETAILS16;
typedef struct {
DWORD dwParam1;
DWORD dwParam2;
CHAR szName[MIXER_LONG_NAME_CHARS];
} MIXERCONTROLDETAILS_LISTTEXT16,*LPMIXERCONTROLDETAILS_LISTTEXT16;
typedef LRESULT CALLBACK (*LPMMIOPROC16)(LPSTR lpmmioinfo,UINT16 uMessage,
LPARAM lParam1,LPARAM lParam2);
typedef struct {
DWORD dwFlags; /* general status flags */
FOURCC fccIOProc; /* pointer to I/O procedure */
LPMMIOPROC16 pIOProc; /* pointer to I/O procedure */
UINT16 wErrorRet; /* place for error to be returned */
HTASK16 hTask; /* alternate local task */
/* fields maintained by MMIO functions during buffered I/O */
LONG cchBuffer; /* size of I/O buffer (or 0L) */
HPSTR pchBuffer; /* start of I/O buffer (or NULL) */
HPSTR pchNext; /* pointer to next byte to read/write */
HPSTR pchEndRead; /* pointer to last valid byte to read */
HPSTR pchEndWrite; /* pointer to last byte to write */
LONG lBufOffset; /* disk offset of start of buffer */
/* fields maintained by I/O procedure */
LONG lDiskOffset; /* disk offset of next read or write */
DWORD adwInfo[3]; /* data specific to type of MMIOPROC */
/* other fields maintained by MMIO */
DWORD dwReserved1; /* reserved for MMIO use */
DWORD dwReserved2; /* reserved for MMIO use */
HMMIO16 hmmio; /* handle to open file */
} MMIOINFO16, *LPMMIOINFO16;
typedef UINT16 CALLBACK (*YIELDPROC16)(UINT16,DWORD);
UINT16 WINAPI auxGetNumDevs16(void);
UINT16 WINAPI auxGetDevCaps16 (UINT16,LPAUXCAPS16,UINT16);
UINT16 WINAPI auxSetVolume16(UINT16,DWORD);
UINT16 WINAPI auxGetVolume16(UINT16,LPDWORD);
DWORD WINAPI auxOutMessage16(UINT16,UINT16,DWORD,DWORD);
MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16,UINT16);
MMRESULT16 WINAPI timeSetEvent16(UINT16,UINT16,LPTIMECALLBACK16,DWORD,UINT16);
MMRESULT16 WINAPI timeKillEvent16(UINT16);
MMRESULT16 WINAPI timeGetDevCaps16(LPTIMECAPS16,UINT16);
MMRESULT16 WINAPI timeBeginPeriod16(UINT16);
MMRESULT16 WINAPI timeEndPeriod16(UINT16);
MMRESULT16 WINAPI joyGetDevCaps16 (UINT16,LPJOYCAPS16,UINT16);
UINT16 WINAPI joyGetNumDevs16(void);
MMRESULT16 WINAPI joyGetPos16(UINT16,LPJOYINFO16);
MMRESULT16 WINAPI joyGetPosEx16(UINT16,LPJOYINFOEX);
MMRESULT16 WINAPI joyGetThreshold16(UINT16,UINT16*);
MMRESULT16 WINAPI joyReleaseCapture16(UINT16);
MMRESULT16 WINAPI joySetCapture16(HWND16,UINT16,UINT16,BOOL16);
MMRESULT16 WINAPI joySetThreshold16(UINT16,UINT16);
UINT16 WINAPI mixerGetNumDevs16(void);
UINT16 WINAPI mixerOpen16(LPHMIXER16,UINT16,DWORD,DWORD,DWORD);
UINT16 WINAPI mixerClose16(HMIXER16);
UINT16 WINAPI mixerMessage16(HMIXER16,UINT16,DWORD,DWORD);
UINT16 WINAPI mixerGetDevCaps16(UINT16,LPMIXERCAPS16,UINT16);
UINT16 WINAPI mixerGetLineInfo16(HMIXEROBJ16,LPMIXERLINE16,DWORD);
UINT16 WINAPI mixerGetID16(HMIXEROBJ16,LPUINT16,DWORD);
UINT16 WINAPI mixerGetLineControls16(HMIXEROBJ16,LPMIXERLINECONTROLS16,DWORD);
UINT16 WINAPI mixerGetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
UINT16 WINAPI mixerSetControlDetails16(HMIXEROBJ16,LPMIXERCONTROLDETAILS16,DWORD);
LPMMIOPROC16 WINAPI mmioInstallIOProc16(FOURCC,LPMMIOPROC16,DWORD);
FOURCC WINAPI mmioStringToFOURCC16(LPCSTR,UINT16);
HMMIO16 WINAPI mmioOpen16(LPSTR,MMIOINFO16*,DWORD);
UINT16 WINAPI mmioRename16(LPCSTR,LPCSTR,MMIOINFO16*,DWORD);
MMRESULT16 WINAPI mmioClose16(HMMIO16,UINT16);
LONG WINAPI mmioRead16(HMMIO16,HPSTR,LONG);
LONG WINAPI mmioWrite16(HMMIO16,HPCSTR,LONG);
LONG WINAPI mmioSeek16(HMMIO16,LONG,INT16);
MMRESULT16 WINAPI mmioGetInfo16(HMMIO16,MMIOINFO16*,UINT16);
MMRESULT16 WINAPI mmioSetInfo16(HMMIO16,const MMIOINFO16*,UINT16);
UINT16 WINAPI mmioSetBuffer16(HMMIO16,LPSTR,LONG,UINT16);
UINT16 WINAPI mmioFlush16(HMMIO16,UINT16);
UINT16 WINAPI mmioAdvance16(HMMIO16,MMIOINFO16*,UINT16);
LONG WINAPI mmioSendMessage16(HMMIO16,UINT16,LPARAM,LPARAM);
UINT16 WINAPI mmioDescend16(HMMIO16,MMCKINFO*,const MMCKINFO*,UINT16);
UINT16 WINAPI mmioAscend16(HMMIO16,MMCKINFO*,UINT16);
UINT16 WINAPI mmioCreateChunk16(HMMIO16,MMCKINFO*,UINT16);
DWORD WINAPI mciSendCommand16(UINT16,UINT16,DWORD,DWORD);
DWORD WINAPI mciSendString16(LPCSTR,LPSTR,UINT16,HWND16);
UINT16 WINAPI mciGetDeviceID16(LPCSTR);
UINT16 WINAPI mciGetDeviceIDFromElementID16(DWORD,LPCSTR);
BOOL16 WINAPI mciGetErrorString16 (DWORD,LPSTR,UINT16);
BOOL16 WINAPI mciSetYieldProc16(UINT16,YIELDPROC16,DWORD);
HTASK16 WINAPI mciGetCreatorTask16(UINT16);
YIELDPROC16 WINAPI mciGetYieldProc16(UINT16,DWORD*);
typedef struct {
DWORD dwCallback;
WORD wDeviceID;
WORD wReserved0;
LPSTR lpstrDeviceType;
LPSTR lpstrElementName;
LPSTR lpstrAlias;
} MCI_OPEN_PARMS16, *LPMCI_OPEN_PARMS16;
typedef struct {
DWORD dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
} MCI_INFO_PARMS16, *LPMCI_INFO_PARMS16;
typedef struct {
DWORD dwCallback;
LPSTR lpstrReturn;
DWORD dwRetSize;
DWORD dwNumber;
WORD wDeviceType;
WORD wReserved0;
} MCI_SYSINFO_PARMS16, *LPMCI_SYSINFO_PARMS16;
typedef struct {
DWORD dwCallback;
UINT16 nVirtKey;
WORD wReserved0;
HWND16 hwndBreak;
WORD wReserved1;
} MCI_BREAK_PARMS16, *LPMCI_BREAK_PARMS16;
typedef struct {
DWORD dwCallback;
LPCSTR lpfilename;
} MCI_LOAD_PARMS16, *LPMCI_LOAD_PARMS16;
typedef struct {
DWORD dwCallback;
LPCSTR lpstrCommand;
} MCI_VD_ESCAPE_PARMS16, *LPMCI_VD_ESCAPE_PARMS16;
typedef struct {
DWORD dwCallback;
MCIDEVICEID16 wDeviceID;
WORD wReserved0;
SEGPTR lpstrDeviceType;
SEGPTR lpstrElementName;
SEGPTR lpstrAlias;
DWORD dwBufferSeconds;
} MCI_WAVE_OPEN_PARMS16, *LPMCI_WAVE_OPEN_PARMS16;
typedef struct {
DWORD dwCallback;
DWORD dwTimeFormat;
DWORD dwAudio;
UINT16 wInput;
UINT16 wReserved0;
UINT16 wOutput;
UINT16 wReserved1;
UINT16 wFormatTag;
UINT16 wReserved2;
UINT16 nChannels;
UINT16 wReserved3;
DWORD nSamplesPerSec;
DWORD nAvgBytesPerSec;
UINT16 nBlockAlign;
UINT16 wReserved4;
UINT16 wBitsPerSample;
UINT16 wReserved5;
} MCI_WAVE_SET_PARMS16, * LPMCI_WAVE_SET_PARMS16;
typedef struct {
DWORD dwCallback;
UINT16 wDeviceID;
UINT16 wReserved0;
SEGPTR lpstrDeviceType;
SEGPTR lpstrElementName;
SEGPTR lpstrAlias;
DWORD dwStyle;
HWND16 hWndParent;
UINT16 wReserved1;
} MCI_ANIM_OPEN_PARMS16, *LPMCI_ANIM_OPEN_PARMS16;
typedef struct {
DWORD dwCallback;
HWND16 hWnd;
WORD wReserved1;
WORD nCmdShow;
WORD wReserved2;
LPCSTR lpstrText;
} MCI_ANIM_WINDOW_PARMS16, *LPMCI_ANIM_WINDOW_PARMS16;
typedef struct {
DWORD dwCallback;
#ifdef MCI_USE_OFFEXT
POINT16 ptOffset;
POINT16 ptExtent;
#else /* ifdef MCI_USE_OFFEXT */
RECT16 rc;
#endif /* ifdef MCI_USE_OFFEXT */
} MCI_ANIM_RECT_PARMS16, *LPMCI_ANIM_RECT_PARMS16;
typedef struct {
DWORD dwCallback;
RECT16 rc;
HDC16 hDC;
} MCI_ANIM_UPDATE_PARMS16, *LPMCI_ANIM_UPDATE_PARMS16;
typedef struct {
DWORD dwCallback;
MCIDEVICEID16 wDeviceID;
WORD wReserved0;
LPCSTR lpstrDeviceType;
LPCSTR lpstrElementName;
LPCSTR lpstrAlias;
DWORD dwStyle;
HWND16 hWndParent;
WORD wReserved1;
} MCI_OVLY_OPEN_PARMS16, *LPMCI_OVLY_OPEN_PARMS16;
typedef struct {
DWORD dwCallback;
HWND16 hWnd;
WORD wReserved1;
UINT16 nCmdShow;
WORD wReserved2;
LPCSTR lpstrText;
} MCI_OVLY_WINDOW_PARMS16, *LPMCI_OVLY_WINDOW_PARMS16;
typedef struct {
DWORD dwCallback;
#ifdef MCI_USE_OFFEXT
POINT16 ptOffset;
POINT16 ptExtent;
#else /* ifdef MCI_USE_OFFEXT */
RECT16 rc;
#endif /* ifdef MCI_USE_OFFEXT */
} MCI_OVLY_RECT_PARMS16, *LPMCI_OVLY_RECT_PARMS16;
typedef struct {
DWORD dwCallback;
LPCSTR lpfilename;
RECT16 rc;
} MCI_OVLY_SAVE_PARMS16, *LPMCI_OVLY_SAVE_PARMS16;
typedef struct {
DWORD dwCallback;
LPCSTR lpfilename;
RECT16 rc;
} MCI_OVLY_LOAD_PARMS16, *LPMCI_OVLY_LOAD_PARMS16;
#endif /* __WINE_WINE_MMSYSTEM16_H */

38
include/wine/obj_base.h
View File

@ -553,7 +553,6 @@ DEFINE_OLEGUID(IID_IClassFactory, 0x00000001L, 0, 0);
typedef struct IClassFactory IClassFactory, *LPCLASSFACTORY;
DEFINE_OLEGUID(IID_IMalloc, 0x00000002L, 0, 0);
typedef struct IMalloc16 IMalloc16,*LPMALLOC16;
typedef struct IMalloc IMalloc,*LPMALLOC;
DEFINE_OLEGUID(IID_IUnknown, 0x00000000L, 0, 0);
@ -630,33 +629,6 @@ ICOM_DEFINE(IClassFactory,IUnknown)
/*****************************************************************************
* IMalloc interface
*/
#define ICOM_INTERFACE IMalloc16
#define IMalloc16_METHODS \
ICOM_METHOD1 (LPVOID,Alloc, DWORD,cb) \
ICOM_METHOD2 (LPVOID,Realloc, LPVOID,pv, DWORD,cb) \
ICOM_VMETHOD1( Free, LPVOID,pv) \
ICOM_METHOD1(DWORD, GetSize, LPVOID,pv) \
ICOM_METHOD1(INT16, DidAlloc, LPVOID,pv) \
ICOM_METHOD (LPVOID,HeapMinimize)
#define IMalloc16_IMETHODS \
IUnknown_IMETHODS \
IMalloc16_METHODS
ICOM_DEFINE(IMalloc16,IUnknown)
#undef ICOM_INTERFACE
/*** IUnknown methods ***/
#define IMalloc16_QueryInterface(p,a,b) ICOM_CALL2(QueryInterface,p,a,b)
#define IMalloc16_AddRef(p) ICOM_CALL (AddRef,p)
#define IMalloc16_Release(p) ICOM_CALL (Release,p)
/*** IMalloc16 methods ***/
#define IMalloc16_Alloc(p,a) ICOM_CALL1(Alloc,p,a)
#define IMalloc16_Realloc(p,a,b) ICOM_CALL2(Realloc,p,a,b)
#define IMalloc16_Free(p,a) ICOM_CALL1(Free,p,a)
#define IMalloc16_GetSize(p,a) ICOM_CALL1(GetSize,p,a)
#define IMalloc16_DidAlloc(p,a) ICOM_CALL1(DidAlloc,p,a)
#define IMalloc16_HeapMinimize(p) ICOM_CALL (HeapMinimize,p)
#define ICOM_INTERFACE IMalloc
#define IMalloc_METHODS \
ICOM_METHOD1 (LPVOID,Alloc, DWORD,cb) \
@ -688,9 +660,6 @@ ICOM_DEFINE(IMalloc,IUnknown)
extern "C" {
#endif
HRESULT WINAPI CoCreateStandardMalloc16(DWORD dwMemContext, LPMALLOC16* lpMalloc);
HRESULT WINAPI CoGetMalloc16(DWORD dwMemContext,LPMALLOC16* lpMalloc);
HRESULT WINAPI CoGetMalloc(DWORD dwMemContext,LPMALLOC* lpMalloc);
LPVOID WINAPI CoTaskMemAlloc(ULONG size);
@ -719,11 +688,9 @@ HRESULT WINAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwCl
HRESULT WINAPI CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID iid, LPVOID *ppv);
HRESULT WINAPI CoInitialize16(LPVOID lpReserved);
HRESULT WINAPI CoInitialize(LPVOID lpReserved);
HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit);
void WINAPI CoUninitialize16(void);
void WINAPI CoUninitialize(void);
typedef enum tagCOINIT
@ -738,7 +705,6 @@ typedef enum tagCOINIT
/* FIXME: not implemented */
BOOL WINAPI CoIsOle1Class(REFCLSID rclsid);
HRESULT WINAPI CoLockObjectExternal16(LPUNKNOWN pUnk, BOOL16 fLock, BOOL16 fLastUnlockReleases);
HRESULT WINAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
/* class registration flags; passed to CoRegisterClassObject */
@ -750,14 +716,10 @@ typedef enum tagREGCLS
REGCLS_SUSPENDED = 4
} REGCLS;
HRESULT WINAPI CoRegisterClassObject16(REFCLSID rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister);
HRESULT WINAPI CoRegisterClassObject(REFCLSID rclsid,LPUNKNOWN pUnk,DWORD dwClsContext,DWORD flags,LPDWORD lpdwRegister);
HRESULT WINAPI CoRevokeClassObject(DWORD dwRegister);
void WINAPI CoUninitialize16(void);
void WINAPI CoUninitialize(void);
/*****************************************************************************
* COM Server dll - exports
*/

104
include/winaspi.h → include/wine/winaspi.h
View File

@ -4,17 +4,12 @@
* All DOS ASPI structures are the same as WINASPI
*/
/* If __WINE__ is not defined, extra typedefs are defined to be
* source compatible with the regular winaspi.h.
*/
#ifndef __WINASPI_H__
#define __WINASPI_H__
#define FAR
/* Include base aspi defs */
#include "aspi.h"
#include "wnaspi32.h"
#include "pshpack1.h"
#ifdef __cplusplus
extern "C" {
#endif /* #ifdef __cplusplus */
@ -23,9 +18,11 @@ extern "C" {
#define ASPI_DOS 1
#define ASPI_WIN16 2
#include "pshpack1.h"
/* SRB HA_INQUIRY */
struct tagSRB16_HaInquiry {
typedef struct tagSRB16_HaInquiry {
BYTE SRB_Cmd;
BYTE SRB_Status;
BYTE SRB_HaId;
@ -38,9 +35,9 @@ struct tagSRB16_HaInquiry {
BYTE HA_Identifier[16];
BYTE HA_Unique[16];
BYTE HA_ExtBuffer[4];
} WINE_PACKED;
} SRB_HaInquiry16, *PSRB_HaInquiry16, *LPSRB_HaInquiry16;
struct tagSRB16_GDEVBlock {
typedef struct tagSRB16_GDEVBlock {
BYTE SRB_Cmd; /* ASPI command code = SC_GET_DEV_TYPE */
BYTE SRB_Status; /* ASPI command status byte */
BYTE SRB_HaId; /* ASPI host adapter number */
@ -49,11 +46,10 @@ struct tagSRB16_GDEVBlock {
BYTE SRB_Target; /* Target's SCSI ID */
BYTE SRB_Lun; /* Target's LUN number */
BYTE SRB_DeviceType; /* Target's peripheral device type */
} WINE_PACKED;
} SRB_GDEVBlock16, *PSRB_GDEVBlock16, *LPSRB_GDEVBlock16;
struct tagSRB16_ExecSCSICmd {
typedef struct tagSRB16_ExecSCSICmd {
BYTE SRB_Cmd; /* ASPI command code (W) */
BYTE SRB_Status; /* ASPI command status byte (R) */
BYTE SRB_HaId; /* ASPI host adapter number (W) */
@ -75,18 +71,19 @@ struct tagSRB16_ExecSCSICmd {
* BYTE CDBByte[6]; * SCSI CDB (W) *
* BYTE SenseArea6[SENSE_LEN]; * Request Sense buffer (R) *
*/
} WINE_PACKED;
} SRB_ExecSCSICmd16, *PSRB_ExecSCSICmd16, *LPSRB_ExecSCSICmd16;
struct tagSRB16_Abort {
typedef struct tagSRB16_Abort {
BYTE SRB_Cmd; /* ASPI command code = SC_ABORT_SRB */
BYTE SRB_Status; /* ASPI command status byte */
BYTE SRB_HaId; /* ASPI host adapter number */
BYTE SRB_Flags; /* ASPI request flags */
DWORD SRB_Hdr_Rsvd; /* Reserved, MUST = 0 */
SEGPTR SRB_ToAbort; /* Pointer to SRB to abort */
} WINE_PACKED;
} SRB_Abort16, *PSRB_Abort16, *LPSRB_Abort16;
struct tagSRB16_BusDeviceReset {
typedef struct tagSRB16_BusDeviceReset {
BYTE SRB_Cmd; /* ASPI command code = SC_RESET_DEV */
BYTE SRB_Status; /* ASPI command status byte */
BYTE SRB_HaId; /* ASPI host adapter number */
@ -99,78 +96,33 @@ struct tagSRB16_BusDeviceReset {
BYTE SRB_TargStat; /* Target Status */
FARPROC16 SRB_PostProc; /* Post routine */
BYTE SRB_ResetRsvd2[34]; /* Reserved, MUST = 0 */
} WINE_PACKED;
} SRB_BusDeviceReset16, *PSRB_BusDeviceReset16, *LPSRB_BusDeviceReset16;
struct tagSRB16_Common {
typedef struct tagSRB16_Common {
BYTE SRB_Cmd; /* ASPI command code = SC_ABORT_SRB */
BYTE SRB_Status; /* ASPI command status byte */
BYTE SRB_HaId; /* ASPI host adapter number */
BYTE SRB_Flags; /* ASPI request flags */
DWORD SRB_Hdr_Rsvd; /* Reserved, MUST = 0 */
} WINE_PACKED;
} SRB_Common16, *PSRB_Common16, *LPSRB_Common16;
union tagSRB16 {
struct tagSRB16_Common common;
struct tagSRB16_HaInquiry inquiry;
struct tagSRB16_ExecSCSICmd cmd;
struct tagSRB16_Abort abort;
struct tagSRB16_BusDeviceReset reset;
struct tagSRB16_GDEVBlock devtype;
};
typedef union tagSRB16 {
SRB_Common16 common;
SRB_HaInquiry16 inquiry;
SRB_ExecSCSICmd16 cmd;
SRB_Abort16 abort;
SRB_BusDeviceReset16 reset;
SRB_GDEVBlock16 devtype;
} SRB16, *LPSRB16;
#ifndef __WINE__
/* These typedefs would conflict with WNASPI32 typedefs, but
* would make it easier to port WINASPI source to WINE */
typedef struct tagSRB16_HaInquiry
SRB_HAInquiry, *PSRB_HAInquiry, FAR *LPSRB_HAInquiry;
#include "poppack.h"
typedef struct tagSRB16_GDEVBlock
SRB_GDEVBlock, *PSRB_GDEVBlock, FAR *LPSRB_GDEVBlock;
typedef struct tagSRB16_ExecSCSICmd
SRB_ExecSCSICmd, *PSRB_ExecSCSICmd, FAR *LPSRB_ExecSCSICmd;
typedef struct tagSRB16_Abort
SRB_Abort, *PSRB_Abort, FAR *LPSRB_Abort;
typedef struct tagSRB16_BusDeviceReset
SRB_BusDeviceReset, *PSRB_BusDeviceReset, FAR *LPSRB_BusDeviceReset;
typedef struct tagSRB16_Common
SRB_Common, *PSRB_Common, FAR *LPSRB_Common;
typedef union tagSRB16 SRB, FAR *LPSRB;
extern WORD FAR PASCAL SendASPICommand( LPSRB );
extern WORD FAR PASCAL GetASPISupportInfo( VOID );
#endif
/* These are the typedefs for WINE */
typedef struct tagSRB16_HaInquiry
SRB_HAInquiry16, *PSRB_HAInquiry16, FAR *LPSRB_HAInquiry16;
typedef struct tagSRB16_GDEVBlock
SRB_GDEVBlock16, *PSRB_GDEVBlock16, FAR *LPSRB_GDEVBlock16;
typedef struct tagSRB16_ExecSCSICmd
SRB_ExecSCSICmd16, *PSRB_ExecSCSICmd16, FAR *LPSRB_ExecSCSICmd16;
typedef struct tagSRB16_Abort
SRB_Abort16, *PSRB_Abort16, FAR *LPSRB_Abort16;
typedef struct tagSRB16_BusDeviceReset
SRB_BusDeviceReset16, *PSRB_BusDeviceReset16, FAR *LPSRB_BusDeviceReset16;
typedef struct tagSRB16_Common
SRB_Common16, *PSRB_Common16, FAR *LPSRB_Common16;
typedef union tagSRB16 SRB16, FAR *LPSRB16;
extern WORD WINAPI SendASPICommand16(SEGPTR);
extern WORD WINAPI GetASPISupportInfo16(void);
#ifdef __cplusplus
}
#endif /* #ifdef __cplusplus */
#include "poppack.h"
#endif /* __WINE_WINASPI_H */

40
include/wine/winbase16.h
View File

@ -2,6 +2,9 @@
#define __WINE_WINE_WINBASE16_H
#include "windef.h"
#include "winbase.h"
#include "wine/windef16.h"
#include "pshpack1.h"
typedef struct _SEGINFO {
UINT16 offSegment;
@ -13,7 +16,6 @@ typedef struct _SEGINFO {
UINT16 reserved[2];
} SEGINFO;
/* GetWinFlags */
#define WF_PMODE 0x0001
@ -36,6 +38,19 @@ typedef struct _SEGINFO {
#include "poppack.h"
#define INVALID_HANDLE_VALUE16 ((HANDLE16) -1)
#define INFINITE16 0xFFFF
typedef struct {
DWORD dwOSVersionInfoSize;
DWORD dwMajorVersion;
DWORD dwMinorVersion;
DWORD dwBuildNumber;
DWORD dwPlatformId;
CHAR szCSDVersion[128];
} OSVERSIONINFO16;
/* undocumented functions */
WORD WINAPI AllocCStoDSAlias16(WORD);
WORD WINAPI AllocDStoCSAlias16(WORD);
@ -105,6 +120,7 @@ VOID WINAPI hmemcpy16(LPVOID,LPCVOID,LONG);
INT16 WINAPI AccessResource16(HINSTANCE16,HRSRC16);
ATOM WINAPI AddAtom16(LPCSTR);
UINT16 WINAPI CompareString16(DWORD,DWORD,LPCSTR,DWORD,LPCSTR,DWORD);
BOOL16 WINAPI CreateDirectory16(LPCSTR,LPVOID);
BOOL16 WINAPI DefineHandleTable16(WORD);
ATOM WINAPI DeleteAtom16(ATOM);
@ -114,6 +130,8 @@ void WINAPI FatalAppExit16(UINT16,LPCSTR);
ATOM WINAPI FindAtom16(LPCSTR);
BOOL16 WINAPI FindClose16(HANDLE16);
VOID WINAPI FreeLibrary16(HINSTANCE16);
HANDLE16 WINAPI FindFirstFile16(LPCSTR,LPWIN32_FIND_DATAA);
BOOL16 WINAPI FindNextFile16(HANDLE16,LPWIN32_FIND_DATAA);
HRSRC16 WINAPI FindResource16(HINSTANCE16,SEGPTR,SEGPTR);
BOOL16 WINAPI FreeModule16(HMODULE16);
void WINAPI FreeProcInstance16(FARPROC16);
@ -122,6 +140,7 @@ UINT16 WINAPI GetAtomName16(ATOM,LPSTR,INT16);
UINT16 WINAPI GetCurrentDirectory16(UINT16,LPSTR);
BOOL16 WINAPI GetDiskFreeSpace16(LPCSTR,LPDWORD,LPDWORD,LPDWORD,LPDWORD);
UINT16 WINAPI GetDriveType16(UINT16); /* yes, the arguments differ */
INT16 WINAPI GetLocaleInfo16(LCID,LCTYPE,LPSTR,INT16);
DWORD WINAPI GetFileAttributes16(LPCSTR);
DWORD WINAPI GetFreeSpace16(UINT16);
INT16 WINAPI GetModuleFileName16(HINSTANCE16,LPSTR,INT16);
@ -136,14 +155,27 @@ UINT16 WINAPI GetProfileInt16(LPCSTR,LPCSTR,INT16);
INT16 WINAPI GetProfileSection16(LPCSTR,LPSTR,UINT16);
WORD WINAPI GetProfileSectionNames16(LPSTR,WORD);
INT16 WINAPI GetProfileString16(LPCSTR,LPCSTR,LPCSTR,LPSTR,UINT16);
DWORD WINAPI GetSelectorBase(WORD);
BOOL16 WINAPI GetStringType16(LCID,DWORD,LPCSTR,INT16,LPWORD);
UINT16 WINAPI GetSystemDirectory16(LPSTR,UINT16);
UINT16 WINAPI GetTempFileName16(BYTE,LPCSTR,UINT16,LPSTR);
LONG WINAPI GetVersion16(void);
BOOL16 WINAPI GetVersionEx16(OSVERSIONINFO16*);
BOOL16 WINAPI GetWinDebugInfo16(LPWINDEBUGINFO,UINT16);
UINT16 WINAPI GetWindowsDirectory16(LPSTR,UINT16);
HGLOBAL16 WINAPI GlobalAlloc16(UINT16,DWORD);
DWORD WINAPI GlobalCompact16(DWORD);
LPVOID WINAPI GlobalLock16(HGLOBAL16);
WORD WINAPI GlobalFix16(HGLOBAL16);
UINT16 WINAPI GlobalFlags16(HGLOBAL16);
HGLOBAL16 WINAPI GlobalFree16(HGLOBAL16);
DWORD WINAPI GlobalHandle16(WORD);
HGLOBAL16 WINAPI GlobalReAlloc16(HGLOBAL16,DWORD,UINT16);
DWORD WINAPI GlobalSize16(HGLOBAL16);
VOID WINAPI GlobalUnfix16(HGLOBAL16);
BOOL16 WINAPI GlobalUnlock16(HGLOBAL16);
BOOL16 WINAPI GlobalUnWire16(HGLOBAL16);
SEGPTR WINAPI GlobalWire16(HGLOBAL16);
WORD WINAPI InitAtomTable16(WORD);
BOOL16 WINAPI IsBadCodePtr16(SEGPTR);
BOOL16 WINAPI IsBadHugeReadPtr16(SEGPTR,DWORD);
@ -168,6 +200,7 @@ BOOL16 WINAPI LocalUnlock16(HLOCAL16);
LPVOID WINAPI LockResource16(HGLOBAL16);
HGLOBAL16 WINAPI LockSegment16(HGLOBAL16);
FARPROC16 WINAPI MakeProcInstance16(FARPROC16,HANDLE16);
HFILE16 WINAPI OpenFile16(LPCSTR,OFSTRUCT*,UINT16);
DWORD WINAPI RegCloseKey16(HKEY);
DWORD WINAPI RegCreateKey16(HKEY,LPCSTR,LPHKEY);
DWORD WINAPI RegDeleteKey16(HKEY,LPCSTR);
@ -184,7 +217,9 @@ BOOL16 WINAPI SetCurrentDirectory16(LPCSTR);
UINT16 WINAPI SetErrorMode16(UINT16);
BOOL16 WINAPI SetFileAttributes16(LPCSTR,DWORD);
UINT16 WINAPI SetHandleCount16(UINT16);
WORD WINAPI SetSelectorBase(WORD,DWORD);
LONG WINAPI SetSwapAreaSize16(WORD);
BOOL16 WINAPI SetWinDebugInfo16(LPWINDEBUGINFO);
DWORD WINAPI SizeofResource16(HMODULE16,HRSRC16);
void WINAPI UnlockSegment16(HGLOBAL16);
BOOL16 WINAPI WritePrivateProfileString16(LPCSTR,LPCSTR,LPCSTR,LPCSTR);
@ -207,13 +242,12 @@ UINT16 WINAPI _lwrite16(HFILE16,LPCSTR,UINT16);
BOOL16 WINAPI WritePrivateProfileSection16(LPCSTR,LPCSTR,LPCSTR);
BOOL16 WINAPI WritePrivateProfileStruct16(LPCSTR,LPCSTR,LPVOID,UINT16,LPCSTR);
BOOL16 WINAPI WriteProfileSection16(LPCSTR,LPCSTR);
DWORD WINAPI GetSelectorBase(WORD);
WORD WINAPI SetSelectorBase(WORD,DWORD);
/* Extra functions that don't exist in the Windows API */
HPEN16 WINAPI GetSysColorPen16(INT16);
UINT WINAPI WIN16_GetTempDrive(BYTE);
SEGPTR WINAPI WIN16_GlobalLock16(HGLOBAL16);
SEGPTR WINAPI WIN16_LockResource16(HGLOBAL16);
LONG WINAPI WIN16_hread(HFILE16,SEGPTR,LONG);
UINT16 WINAPI WIN16_lread(HFILE16,SEGPTR,UINT16);

20
include/wine/windef16.h
View File

@ -22,6 +22,8 @@ typedef UINT16 WPARAM16;
typedef INT16 *LPINT16;
typedef UINT16 *LPUINT16;
#define HFILE_ERROR16 ((HFILE16)-1)
#define DECLARE_HANDLE16(a) \
typedef HANDLE16 a##16; \
typedef a##16 *P##a##16; \
@ -81,6 +83,7 @@ typedef HANDLE16 HGLOBAL16;
typedef HANDLE16 HLOCAL16;
/* The SIZE structure */
typedef struct
{
INT16 cx;
@ -105,6 +108,23 @@ typedef struct
INT16 bottom;
} RECT16, *LPRECT16;
#define CONV_SIZE16TO32(s16,s32) \
((s32)->cx = (INT)(s16)->cx, (s32)->cy = (INT)(s16)->cy)
#define CONV_SIZE32TO16(s32,s16) \
((s16)->cx = (INT16)(s32)->cx, (s16)->cy = (INT16)(s32)->cy)
#define CONV_POINT16TO32(p16,p32) \
((p32)->x = (INT)(p16)->x, (p32)->y = (INT)(p16)->y)
#define CONV_POINT32TO16(p32,p16) \
((p16)->x = (INT16)(p32)->x, (p16)->y = (INT16)(p32)->y)
#define CONV_RECT16TO32(r16,r32) \
((r32)->left = (INT)(r16)->left, (r32)->top = (INT)(r16)->top, \
(r32)->right = (INT)(r16)->right, (r32)->bottom = (INT)(r16)->bottom)
#define CONV_RECT32TO16(r32,r16) \
((r16)->left = (INT16)(r32)->left, (r16)->top = (INT16)(r32)->top, \
(r16)->right = (INT16)(r32)->right, (r16)->bottom = (INT16)(r32)->bottom)
/* Callback function pointers types */
typedef LRESULT CALLBACK (*DRIVERPROC16)(DWORD,HDRVR16,UINT16,LPARAM,LPARAM);

1
include/wine/wingdi16.h
View File

@ -3,6 +3,7 @@
#include "windef.h"
#include "wingdi.h"
#include "wine/winbase16.h"
#include "pshpack1.h"

1
include/wine/winnet16.h
View File

@ -9,6 +9,7 @@
#define __WINE_WINNET16_H
#include "windef.h"
#include "wine/windef16.h"
/*
* Remote printing

36
include/wine/winsock16.h
View File

@ -4,6 +4,14 @@
#include "windef.h"
#include "pshpack1.h"
typedef UINT16 SOCKET16;
typedef struct
{
UINT16 fd_count; /* how many are SET? */
SOCKET16 fd_array[FD_SETSIZE]; /* an array of SOCKETs */
} ws_fd_set16;
/* ws_hostent16, ws_protoent16, ws_servent16, ws_netent16
* are 1-byte aligned here ! */
typedef struct ws_hostent16
@ -40,4 +48,32 @@ typedef struct ws_netent16
#include "poppack.h"
#define WS_FD_CLR16(fd, set) __WS_FD_CLR((fd),(set), ws_fd_set16)
#define WS_FD_SET16(fd, set) __WS_FD_SET((fd),(set), ws_fd_set16)
#define WS_FD_ZERO16(set) (((ws_fd_set16*)(set))->fd_count=0)
#define WS_FD_ISSET16(fd, set) __WSAFDIsSet16((SOCKET16)(fd), (ws_fd_set16*)(set))
#define INVALID_SOCKET16 ((SOCKET16)(~0))
INT16 WINAPI __WSAFDIsSet16( SOCKET16, ws_fd_set16 * );
INT16 WINAPI WSAStartup16(UINT16 wVersionRequired, LPWSADATA lpWSAData);
void WINAPI WSASetLastError16(INT16 iError);
INT16 WINAPI WSAUnhookBlockingHook16(void);
FARPROC16 WINAPI WSASetBlockingHook16(FARPROC16 lpBlockFunc);
HANDLE16 WINAPI WSAAsyncGetServByName16(HWND16 hWnd, UINT16 wMsg, LPCSTR name, LPCSTR proto,
SEGPTR buf, INT16 buflen);
HANDLE16 WINAPI WSAAsyncGetServByPort16(HWND16 hWnd, UINT16 wMsg, INT16 port,
LPCSTR proto, SEGPTR buf, INT16 buflen);
HANDLE16 WINAPI WSAAsyncGetProtoByName16(HWND16 hWnd, UINT16 wMsg,
LPCSTR name, SEGPTR buf, INT16 buflen);
HANDLE16 WINAPI WSAAsyncGetProtoByNumber16(HWND16 hWnd, UINT16 wMsg,
INT16 number, SEGPTR buf, INT16 buflen);
HANDLE16 WINAPI WSAAsyncGetHostByName16(HWND16 hWnd, UINT16 wMsg,
LPCSTR name, SEGPTR buf, INT16 buflen);
HANDLE16 WINAPI WSAAsyncGetHostByAddr16(HWND16 hWnd, UINT16 wMsg, LPCSTR addr,
INT16 len, INT16 type, SEGPTR buf, INT16 buflen);
INT16 WINAPI WSACancelAsyncRequest16(HANDLE16 hAsyncTaskHandle);
INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, LONG lEvent);
INT16 WINAPI WSARecvEx16(SOCKET16 s, char *buf, INT16 len, INT16 *flags);
#endif /* __WINE_WINE_WINSOCK16_H */

40
include/wine/winuser16.h
View File

@ -52,6 +52,23 @@ typedef struct tagDCB16
} DCB16, *LPDCB16;
typedef struct
{
LPARAM lParam;
WPARAM16 wParam;
UINT16 message;
HWND16 hwnd;
} CWPSTRUCT16, *LPCWPSTRUCT16;
typedef struct
{
LRESULT lResult;
LPARAM lParam;
WPARAM16 wParam;
DWORD message;
HWND16 hwnd;
} CWPRETSTRUCT16, *LPCWPRETSTRUCT16;
/* SetWindowPlacement() struct */
typedef struct
{
@ -843,6 +860,7 @@ BOOL16 WINAPI RedrawWindow16(HWND16,const RECT16*,HRGN16,UINT16);
ATOM WINAPI RegisterClass16(const WNDCLASS16*);
ATOM WINAPI RegisterClassEx16(const WNDCLASSEX16*);
UINT16 WINAPI RegisterClipboardFormat16(LPCSTR);
BOOL WINAPI RegisterShellHook16(HWND16,UINT16);
INT16 WINAPI ReleaseDC16(HWND16,HDC16);
BOOL16 WINAPI RemoveMenu16(HMENU16,UINT16,UINT16);
HANDLE16 WINAPI RemoveProp16(HWND16,LPCSTR);
@ -948,4 +966,26 @@ BYTE WINAPI GetTempDrive(BYTE);
FARPROC16 WINAPI SetTaskSignalProc(HTASK16,FARPROC16);
/* DragObject stuff */
typedef struct
{
HWND16 hWnd;
HANDLE16 hScope;
WORD wFlags;
HANDLE16 hList;
HANDLE16 hOfStruct;
POINT16 pt WINE_PACKED;
LONG l WINE_PACKED;
} DRAGINFO16, *LPDRAGINFO16;
#define DRAGOBJ_PROGRAM 0x0001
#define DRAGOBJ_DATA 0x0002
#define DRAGOBJ_DIRECTORY 0x0004
#define DRAGOBJ_MULTIPLE 0x0008
#define DRAGOBJ_EXTERNAL 0x8000
#define DRAG_PRINT 0x544E5250
#define DRAG_FILE 0x454C4946
#endif /* __WINE_WINE_WINUSER16_H */

2
include/wingdi.h
View File

@ -1628,6 +1628,8 @@ typedef struct
DWORD bfOffBits;
} BITMAPFILEHEADER;
#define MAKEPOINTS(l) (*((POINTS *)&(l)))
typedef struct
{
DWORD biSize;

12
include/winnls.h
View File

@ -1,13 +1,6 @@
#ifndef __WINE_WINNLS_H
#define __WINE_WINNLS_H
#ifdef HAVE_WCTYPE_H
/* Sun Bug Workaround */
#ifdef __WINE__
# undef wsprintf
#endif
#endif
#include "windef.h"
#define MB_PRECOMPOSED 0x00000001
@ -521,11 +514,6 @@ BOOL WINAPI EnumCalendarInfoA(CALINFO_ENUMPROCA lpCalInfoEnumProc,LCID Locale,CA
BOOL WINAPI EnumCalendarInfoW(CALINFO_ENUMPROCW lpCalInfoEnumProc,LCID Locale,CALID Calendar,CALTYPE CalType);
#define EnumCalendarInfo WINELIB_NAME_AW(EnumCalendarInfo)
/* FIXME: This does not belong to an interface file */
UINT16 WINAPI CompareString16(DWORD,DWORD,LPCSTR,DWORD,LPCSTR,DWORD);
INT16 WINAPI GetLocaleInfo16(LCID,LCTYPE,LPSTR,INT16);
BOOL16 WINAPI GetStringType16(LCID,DWORD,LPCSTR,INT16,LPWORD);
LCID WINAPI ConvertDefaultLocale(LCID Locale);
BOOL WINAPI GetCPInfo(UINT,LPCPINFO);

1
include/winproc.h
View File

@ -8,6 +8,7 @@
#define __WINE_WINPROC_H
#include "windef.h"
#include "wine/windef16.h"
typedef enum
{

76
include/winsock.h
View File

@ -25,19 +25,7 @@
#include <sys/socket.h>
#include <sys/ioctl.h>
#ifdef HAVE_IPX_GNU
# include <netipx/ipx.h>
# define HAVE_IPX
#endif
#ifdef HAVE_IPX_LINUX
# include <asm/types.h>
# include <linux/ipx.h>
# define HAVE_IPX
#endif
#include "windef.h"
#include "task.h"
#ifdef __cplusplus
extern "C" {
@ -79,20 +67,10 @@ typedef struct ws_netent
#include "pshpack1.h"
/* Win16 socket-related types */
typedef UINT16 SOCKET16;
typedef UINT SOCKET;
typedef struct sockaddr ws_sockaddr;
typedef struct
{
UINT16 fd_count; /* how many are SET? */
SOCKET16 fd_array[FD_SETSIZE]; /* an array of SOCKETs */
} ws_fd_set16;
typedef struct ws_fd_set32_struct
{
UINT fd_count; /* how many are SET? */
@ -102,11 +80,10 @@ typedef struct ws_fd_set32_struct
/* ws_fd_set operations */
INT16 WINAPI __WSAFDIsSet16( SOCKET16, ws_fd_set16 * );
INT WINAPI __WSAFDIsSet( SOCKET, ws_fd_set32 * );
#define __WS_FD_CLR(fd, set, cast) do { \
UINT16 __i; \
UINT __i; \
for (__i = 0; __i < ((cast*)(set))->fd_count ; __i++) \
{ \
if (((cast*)(set))->fd_array[__i] == fd) \
@ -122,20 +99,14 @@ INT WINAPI __WSAFDIsSet( SOCKET, ws_fd_set32 * );
} \
} \
} while(0)
#define WS_FD_CLR16(fd, set) __WS_FD_CLR((fd),(set), ws_fd_set16)
#define WS_FD_CLR(fd, set) __WS_FD_CLR((fd),(set), ws_fd_set32)
#define __WS_FD_SET(fd, set, cast) do { \
if (((cast*)(set))->fd_count < FD_SETSIZE) \
((cast*)(set))->fd_array[((cast*)(set))->fd_count++]=(fd);\
} while(0)
#define WS_FD_SET16(fd, set) __WS_FD_SET((fd),(set), ws_fd_set16)
#define WS_FD_SET(fd, set) __WS_FD_SET((fd),(set), ws_fd_set32)
#define WS_FD_ZERO16(set) (((ws_fd_set16*)(set))->fd_count=0)
#define WS_FD_ZERO(set) (((ws_fd_set32*)(set))->fd_count=0)
#define WS_FD_ISSET16(fd, set) __WSAFDIsSet16((SOCKET16)(fd), (ws_fd_set16*)(set))
#define WS_FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (ws_fd_set32*)(set))
/*
@ -146,7 +117,7 @@ struct ws_in_addr
{
union {
struct { BYTE s_b1,s_b2,s_b3,s_b4; } S_un_b;
struct { UINT16 s_w1,s_w2; } S_un_w;
struct { WORD s_w1,s_w2; } S_un_w;
UINT S_addr;
} S_un;
#define ws_addr S_un.S_addr /* can be used for most tcp & ip code */
@ -159,8 +130,8 @@ struct ws_in_addr
struct ws_sockaddr_in
{
INT16 sin_family;
UINT16 sin_port;
SHORT sin_family;
WORD sin_port;
struct ws_in_addr sin_addr;
BYTE sin_zero[8];
};
@ -173,20 +144,17 @@ typedef struct WSAData {
WORD wHighVersion;
char szDescription[WSADESCRIPTION_LEN+1];
char szSystemStatus[WSASYS_STATUS_LEN+1];
UINT16 iMaxSockets;
UINT16 iMaxUdpDg;
WORD iMaxSockets;
WORD iMaxUdpDg;
SEGPTR lpVendorInfo;
} WSADATA, *LPWSADATA;
#include "poppack.h"
/* ------ no Win16 structure defs (1-byte alignment) beyond this line! ------ */
/*
* This is used instead of -1, since the
* SOCKET type is unsigned.
*/
#define INVALID_SOCKET16 (~0)
#define INVALID_SOCKET (~0)
#define SOCKET_ERROR (-1)
@ -394,56 +362,28 @@ extern "C" {
/* Microsoft Windows Extension function prototypes */
INT16 WINAPI WSAStartup16(UINT16 wVersionRequired, LPWSADATA lpWSAData);
INT WINAPI WSAStartup(UINT wVersionRequired, LPWSADATA lpWSAData);
void WINAPI WSASetLastError16(INT16 iError);
void WINAPI WSASetLastError(INT iError);
INT WINAPI WSACleanup(void);
INT WINAPI WSAGetLastError(void);
BOOL WINAPI WSAIsBlocking(void);
INT WINAPI WSACancelBlockingCall(void);
INT16 WINAPI WSAUnhookBlockingHook16(void);
INT WINAPI WSAUnhookBlockingHook(void);
FARPROC16 WINAPI WSASetBlockingHook16(FARPROC16 lpBlockFunc);
FARPROC WINAPI WSASetBlockingHook(FARPROC lpBlockFunc);
HANDLE16 WINAPI WSAAsyncGetServByName16(HWND16 hWnd, UINT16 wMsg, LPCSTR name, LPCSTR proto,
SEGPTR buf, INT16 buflen);
HANDLE WINAPI WSAAsyncGetServByName(HWND hWnd, UINT uMsg, LPCSTR name, LPCSTR proto,
LPSTR sbuf, INT buflen);
HANDLE16 WINAPI WSAAsyncGetServByPort16(HWND16 hWnd, UINT16 wMsg, INT16 port,
LPCSTR proto, SEGPTR buf, INT16 buflen);
HANDLE WINAPI WSAAsyncGetServByPort(HWND hWnd, UINT uMsg, INT port,
LPCSTR proto, LPSTR sbuf, INT buflen);
HANDLE16 WINAPI WSAAsyncGetProtoByName16(HWND16 hWnd, UINT16 wMsg,
LPCSTR name, SEGPTR buf, INT16 buflen);
HANDLE WINAPI WSAAsyncGetProtoByName(HWND hWnd, UINT uMsg,
LPCSTR name, LPSTR sbuf, INT buflen);
HANDLE16 WINAPI WSAAsyncGetProtoByNumber16(HWND16 hWnd, UINT16 wMsg,
INT16 number, SEGPTR buf, INT16 buflen);
HANDLE WINAPI WSAAsyncGetProtoByNumber(HWND hWnd, UINT uMsg,
INT number, LPSTR sbuf, INT buflen);
HANDLE16 WINAPI WSAAsyncGetHostByName16(HWND16 hWnd, UINT16 wMsg,
LPCSTR name, SEGPTR buf, INT16 buflen);
HANDLE WINAPI WSAAsyncGetHostByName(HWND hWnd, UINT uMsg,
LPCSTR name, LPSTR sbuf, INT buflen);
HANDLE16 WINAPI WSAAsyncGetHostByAddr16(HWND16 hWnd, UINT16 wMsg, LPCSTR addr,
INT16 len, INT16 type, SEGPTR buf, INT16 buflen);
HANDLE WINAPI WSAAsyncGetHostByAddr(HWND hWnd, UINT uMsg, LPCSTR addr,
INT len, INT type, LPSTR sbuf, INT buflen);
INT16 WINAPI WSACancelAsyncRequest16(HANDLE16 hAsyncTaskHandle);
INT WINAPI WSACancelAsyncRequest(HANDLE hAsyncTaskHandle);
INT16 WINAPI WSAAsyncSelect16(SOCKET16 s, HWND16 hWnd, UINT16 wMsg, LONG lEvent);
INT WINAPI WSAAsyncSelect(SOCKET s, HWND hWnd, UINT uMsg, LONG lEvent);
INT16 WINAPI WSARecvEx16(SOCKET16 s, char *buf, INT16 len, INT16 *flags);
INT WINAPI WSARecvEx(SOCKET s, char *buf, INT len, INT *flags);
/*
@ -485,10 +425,10 @@ INT WINAPI WSARecvEx(SOCKET s, char *buf, INT len, INT *flags);
struct ws_sockaddr_ipx
{
INT16 sipx_family;
SHORT sipx_family;
UINT sipx_network;
CHAR sipx_node[6];
UINT16 sipx_port;
WORD sipx_port;
};
#include "poppack.h"

Some files were not shown because too many files have changed in this diff Show More