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

Release 970824 

Sat Aug 23 00:05:23 1997  Andreas Mohr <100.30936@germany.net>

	* [if1632/kernel.spec] [if1632/mmsystem.spec]
	Added some stubs.

	* [include/neexe.h] [loader/module.c]
	Added warning for OS/2 executables.

	* [multimedia/midi.c]
	Shortened MIDIOUT driver version string to be less than 31 chars.

	* [objects/gdiobj.c]
	Fixed DeleteObject32() to react properly when called with stock object.

Fri Aug 22 18:03:26 1997  Dimitrie O. Paun <dimi@cs.toronto.edu>

	* [controls/updown.c] [include/updown.h]
	First attempt at implementiong the UpDown class.

	* [controls/widgets.c]
	Added the UpDown class to be initialized by InitCommonControls().

Wed Aug 20 18:01:33 1997  Doug Ridgway <ridgway@routh.UCSD.EDU>

	* [graphics/*] [objects/*] [include/gdi.h]
	Made all GDI objects (except DCs) moveable.

Mon Aug 18 03:25:30 1997  Alex Korobka <alex@trantor.pharm.sunysb.edu>

	* [windows/event.c] [misc/winsock.c] [misc/winsock_dns.c]
	Removed IPC communication to speed up winsock services
	(tested only with 16-bit netscape 3.03).

	* [graphics/x11drv/xfont.c] [documentation/fonts]
	Miscellaneous improvements. Updated docs.

Sun Aug 17 20:39:55 1997  Ingo Schneider <schneidi@informatik.tu-muenchen.de>

	* [misc/comm.c]
	A couple of bug fixes.

Sun Aug 17 19:29:22 1997  Alexandre Julliard  <julliard@lrc.epfl.ch>

	* [debugger/dbg.y]
	Display next instruction after stepi/nexti.

	* [if1632/relay.c] [include/callback.h] [tools/build.c]
	Replaced CallTo32_LargeStack with the CALL_LARGE_STACK macro for
	better Winelib support.

	* [include/sigcontext.h]
	Renamed to sig_context.h to avoid conflicts with libc.

	* [*/*]
	All API functions are now prefixed with WINAPI in prevision of
	future Winelib integration.

	* [loader/signal.c] [memory/ldt.c]
	Fixed assembly code to be -fPIC compatible.

Thu Aug 14 14:38:15 1997  Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>

	* [if1632/crtdll.spec][win32/except.c]
	_global_unwind, _local_unwind stub added.

	* [objects/dib.c]	
	Don't read memory you don't even need for the target bitmap (fixes
	one 'lazy' program).

	* [if1632/relay.c][if1632/thunk.c][if1632/kernel32.spec]
	  [win32/ordinals.c][memory/selector.c][memory/global.c]
	  [include/callback.h]
	Added/moved some more win95 ordinal stuff. Implemented QT_Thunk
	(not 100% correct yet) and some friends.

	* [loader/pe_image.c]
	Add possibility to break at the DLL entrypoint.

	* [controls/static.c][misc/commdlg.c][scheduler/thread.c]
	Misc bugfixes and additions.

	* [misc/registry.c]
	The registry seems to be case-preserving but case-insensitive.

	* [memory/global.c]	
	Adapted to new /proc/meminfo format.

	* [objects/font.c][graphics/x11drv/xfont.c]
	FONT_SelectObject and GetTextMetrics* get passed ranges in logical
 	and not device points (thanks to Marion Reyzl for pointing this
 	out).

	* [windows/caret.c]
	Use the windows own DC if present (The caret coordinates are
	logical coordinates based on it). Fixes another AMIPRO problem.

Wed Aug  6 18:22:22 1997  Morten Welinder  <terra@diku.dk>

	* [controls/menu.c]
	General clean-up and Win32 work: split item_flags into fType and
	fState; split item_id into wID and hSubMenu.  Improved
	debug-printing.  Implemented InsertMenuItem32[AW],
	SetMenuDefaultItem32, and SetMenuItemInfo32[AW].  Fixed
	GetMenuItemInfo32[AW].

	* [if1632/user32.spec]
	Define above new functions.

	* [include/windows.h]
	Define MF_DEFAULT and MF_RIGHTJUSTIFY.  Prototype above functions.

	* [include/menu.h]
	Don't prototype now-static MENU_InitSysMenuPopup.

	* [include/comm.h]
	Reduce MAX_PORTS to 9 (which the profile code can handle).

Tue Aug  5 20:16:22 1997  Victor Schneider <vischne@ibm.net>

	* [library/winestub.c] [libtest/expand.c]
	These patches let people porting Windows apps compile them using
	the same conventions regarding global _argc and _argv as those on
	Windows C/C++ compilers.
This commit is contained in:
Alexandre Julliard 1997-08-24 16:00:30 +00:00
parent 641ee76ace
commit 670cdc45be
243 changed files with 13067 additions and 9089 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ANNOUNCE
View File

@ -1,13 +1,15 @@
This is release 970804 of Wine, the MS Windows emulator. This is still a
This is release 970824 of Wine, the MS Windows emulator. This is still a
developer's only release. There are many bugs and many unimplemented API
features. Most applications still do not work correctly.
Patches should be submitted to "julliard@lrc.epfl.ch". Please don't
forget to include a ChangeLog entry.
WHAT'S NEW with Wine-970804: (see ChangeLog for details)
- Joystick support.
- More Win32 stuff.
WHAT'S NEW with Wine-970824: (see ChangeLog for details)
- Better Win32 menu support.
- Improved Winsock.
- UpDown control.
- More undocumented Win95 hacks.
- Lots of bug fixes.
See the README file in the distribution for installation instructions.
@ -16,10 +18,10 @@ Because of lags created by using mirror, this message may reach you before
the release is available at the ftp sites. The sources will be available
from the following locations:
ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-970804.tar.gz
ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-970804.tar.gz
ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-970804.tar.gz
ftp://ftp.progsoc.uts.edu.au/pub/Wine/development/Wine-970804.tar.gz
ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-970824.tar.gz
ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-970824.tar.gz
ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-970824.tar.gz
ftp://ftp.progsoc.uts.edu.au/pub/Wine/development/Wine-970824.tar.gz
It should also be available from any site that mirrors tsx-11 or sunsite.

3
BUGS
View File

@ -42,9 +42,6 @@ Miscellaneous:
* "Cursor XXXX has more than 1 bpp!"
* 32-bit Freecell segfaults when started from the Progman (looks like
a problem with cards.dll).
* Margins in edit controls are too wide.
* SGI window manager treats Wine windows as topmost.

125
ChangeLog
View File

@ -1,3 +1,128 @@
----------------------------------------------------------------------
Sat Aug 23 00:05:23 1997 Andreas Mohr <100.30936@germany.net>
* [if1632/kernel.spec] [if1632/mmsystem.spec]
Added some stubs.
* [include/neexe.h] [loader/module.c]
Added warning for OS/2 executables.
* [multimedia/midi.c]
Shortened MIDIOUT driver version string to be less than 31 chars.
* [objects/gdiobj.c]
Fixed DeleteObject32() to react properly when called with stock object.
Fri Aug 22 18:03:26 1997 Dimitrie O. Paun <dimi@cs.toronto.edu>
* [controls/updown.c] [include/updown.h]
First attempt at implementiong the UpDown class.
* [controls/widgets.c]
Added the UpDown class to be initialized by InitCommonControls().
Wed Aug 20 18:01:33 1997 Doug Ridgway <ridgway@routh.UCSD.EDU>
* [graphics/*] [objects/*] [include/gdi.h]
Made all GDI objects (except DCs) moveable.
Mon Aug 18 03:25:30 1997 Alex Korobka <alex@trantor.pharm.sunysb.edu>
* [windows/event.c] [misc/winsock.c] [misc/winsock_dns.c]
Removed IPC communication to speed up winsock services
(tested only with 16-bit netscape 3.03).
* [graphics/x11drv/xfont.c] [documentation/fonts]
Miscellaneous improvements. Updated docs.
Sun Aug 17 20:39:55 1997 Ingo Schneider <schneidi@informatik.tu-muenchen.de>
* [misc/comm.c]
A couple of bug fixes.
Sun Aug 17 19:29:22 1997 Alexandre Julliard <julliard@lrc.epfl.ch>
* [debugger/dbg.y]
Display next instruction after stepi/nexti.
* [if1632/relay.c] [include/callback.h] [tools/build.c]
Replaced CallTo32_LargeStack with the CALL_LARGE_STACK macro for
better Winelib support.
* [include/sigcontext.h]
Renamed to sig_context.h to avoid conflicts with libc.
* [*/*]
All API functions are now prefixed with WINAPI in prevision of
future Winelib integration.
* [loader/signal.c] [memory/ldt.c]
Fixed assembly code to be -fPIC compatible.
Thu Aug 14 14:38:15 1997 Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>
* [if1632/crtdll.spec][win32/except.c]
_global_unwind, _local_unwind stub added.
* [objects/dib.c]
Don't read memory you don't even need for the target bitmap (fixes
one 'lazy' program).
* [if1632/relay.c][if1632/thunk.c][if1632/kernel32.spec]
[win32/ordinals.c][memory/selector.c][memory/global.c]
[include/callback.h]
Added/moved some more win95 ordinal stuff. Implemented QT_Thunk
(not 100% correct yet) and some friends.
* [loader/pe_image.c]
Add possibility to break at the DLL entrypoint.
* [controls/static.c][misc/commdlg.c][scheduler/thread.c]
Misc bugfixes and additions.
* [misc/registry.c]
The registry seems to be case-preserving but case-insensitive.
* [memory/global.c]
Adapted to new /proc/meminfo format.
* [objects/font.c][graphics/x11drv/xfont.c]
FONT_SelectObject and GetTextMetrics* get passed ranges in logical
and not device points (thanks to Marion Reyzl for pointing this
out).
* [windows/caret.c]
Use the windows own DC if present (The caret coordinates are
logical coordinates based on it). Fixes another AMIPRO problem.
Wed Aug 6 18:22:22 1997 Morten Welinder <terra@diku.dk>
* [controls/menu.c]
General clean-up and Win32 work: split item_flags into fType and
fState; split item_id into wID and hSubMenu. Improved
debug-printing. Implemented InsertMenuItem32[AW],
SetMenuDefaultItem32, and SetMenuItemInfo32[AW]. Fixed
GetMenuItemInfo32[AW].
* [if1632/user32.spec]
Define above new functions.
* [include/windows.h]
Define MF_DEFAULT and MF_RIGHTJUSTIFY. Prototype above functions.
* [include/menu.h]
Don't prototype now-static MENU_InitSysMenuPopup.
* [include/comm.h]
Reduce MAX_PORTS to 9 (which the profile code can handle).
Tue Aug 5 20:16:22 1997 Victor Schneider <vischne@ibm.net>
* [library/winestub.c] [libtest/expand.c]
These patches let people porting Windows apps compile them using
the same conventions regarding global _argc and _argv as those on
Windows C/C++ compilers.
----------------------------------------------------------------------
Sun Aug 3 14:03:43 1997 Alexandre Julliard <julliard@lrc.epfl.ch>

3
README
View File

@ -83,7 +83,8 @@ UPDATE: Windows 95 components are known to cause more crashes compared
The best place to get help or to report bugs is the Usenet newsgroup
comp.emulators.ms-windows.wine. The Wine FAQ is posted there every
month.
month. Also, you may want to browse old messages on www.dejanews.com
to check whether your problem is already fixed.
If you add something, or fix a bug, please send a patch ('diff -u'
format preferred) to julliard@lrc.epfl.ch for inclusion in the next

1
controls/Makefile.in
View File

@ -16,6 +16,7 @@ C_SRCS = \
scroll.c \
static.c \
status.c \
updown.c \
widgets.c
all: $(MODULE).o

3
controls/button.c
View File

@ -71,7 +71,8 @@ static WORD checkBoxWidth = 0, checkBoxHeight = 0;
/***********************************************************************
* ButtonWndProc
*/
LRESULT ButtonWndProc(HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam, LPARAM lParam)
LRESULT WINAPI ButtonWndProc( HWND32 hWnd, UINT32 uMsg,
WPARAM32 wParam, LPARAM lParam )
{
RECT16 rect;
WND *wndPtr = WIN_FindWndPtr(hWnd);

33
controls/combo.c
View File

@ -83,30 +83,32 @@ static BOOL32 COMBO_Init()
*/
static LRESULT COMBO_NCCreate(WND* wnd, LPARAM lParam)
{
LPHEADCOMBO lphc;
LPHEADCOMBO lphc;
if ( wnd && COMBO_Init() &&
if ( wnd && COMBO_Init() &&
(lphc = HeapAlloc(GetProcessHeap(), 0, sizeof(HEADCOMBO))) )
{
LPCREATESTRUCT32A lpcs = (CREATESTRUCT32A*)lParam;
{
LPCREATESTRUCT32A lpcs = (CREATESTRUCT32A*)lParam;
memset( lphc, 0, sizeof(HEADCOMBO) );
memset( lphc, 0, sizeof(HEADCOMBO) );
*(LPHEADCOMBO*)wnd->wExtra = lphc;
/* some braindead apps do try to use scrollbar/border flags */
lphc->dwStyle = (lpcs->style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL));
wnd->dwStyle &= ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL);
lphc->dwStyle = (lpcs->style & ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL));
wnd->dwStyle &= ~(WS_BORDER | WS_HSCROLL | WS_VSCROLL);
if( !(lpcs->style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) )
lphc->dwStyle |= CBS_HASSTRINGS;
if( !(lpcs->style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) )
lphc->dwStyle |= CBS_HASSTRINGS;
if( !(wnd->dwExStyle & WS_EX_NOPARENTNOTIFY) )
lphc->wState |= CBF_NOTIFY;
dprintf_combo(stddeb, "COMBO_NCCreate: [0x%08x], style = %08x\n",
(UINT32)lphc, lphc->dwStyle );
dprintf_combo(stddeb, "COMBO_NCCreate: [0x%08x], style = %08x\n",
(UINT32)lphc, lphc->dwStyle );
return (LRESULT)(UINT32)wnd->hwndSelf;
}
return (LRESULT)FALSE;
return (LRESULT)(UINT32)wnd->hwndSelf;
}
return (LRESULT)FALSE;
}
/***********************************************************************
@ -1239,7 +1241,8 @@ static void COMBO_MouseMove( LPHEADCOMBO lphc, WPARAM32 wParam, LPARAM lParam )
*
* http://www.microsoft.com/msdn/sdk/platforms/doc/sdk/win32/ctrl/src/combobox_15.htm
*/
LRESULT ComboWndProc(HWND32 hwnd, UINT32 message, WPARAM32 wParam, LPARAM lParam)
LRESULT WINAPI ComboWndProc( HWND32 hwnd, UINT32 message,
WPARAM32 wParam, LPARAM lParam )
{
WND* pWnd = WIN_FindWndPtr(hwnd);

10
controls/desktop.c
View File

@ -131,8 +131,8 @@ static LRESULT DESKTOP_DoEraseBkgnd( HWND32 hwnd, HDC32 hdc,
*
* Window procedure for the desktop window.
*/
LRESULT DesktopWndProc( HWND32 hwnd, UINT32 message,
WPARAM32 wParam, LPARAM lParam )
LRESULT WINAPI DesktopWndProc( HWND32 hwnd, UINT32 message,
WPARAM32 wParam, LPARAM lParam )
{
WND *wndPtr = WIN_FindWndPtr( hwnd );
DESKTOPINFO *infoPtr = (DESKTOPINFO *)wndPtr->wExtra;
@ -169,7 +169,7 @@ LRESULT DesktopWndProc( HWND32 hwnd, UINT32 message,
/***********************************************************************
* SetDeskPattern (USER.279)
*/
BOOL16 SetDeskPattern(void)
BOOL16 WINAPI SetDeskPattern(void)
{
char buffer[100];
GetProfileString32A( "desktop", "Pattern", "(None)", buffer, 100 );
@ -180,7 +180,7 @@ BOOL16 SetDeskPattern(void)
/***********************************************************************
* SetDeskWallPaper16 (USER.285)
*/
BOOL16 SetDeskWallPaper16( LPCSTR filename )
BOOL16 WINAPI SetDeskWallPaper16( LPCSTR filename )
{
return SetDeskWallPaper32( filename );
}
@ -191,7 +191,7 @@ BOOL16 SetDeskWallPaper16( LPCSTR filename )
*
* FIXME: is there a unicode version?
*/
BOOL32 SetDeskWallPaper32( LPCSTR filename )
BOOL32 WINAPI SetDeskWallPaper32( LPCSTR filename )
{
HBITMAP32 hbitmap;
HDC32 hdc;

6
controls/edit.c
View File

@ -148,7 +148,8 @@ static __inline__ void EDIT_WM_Cut(WND *wnd, EDITSTATE *es);
/*
* This is the only exported function
*/
LRESULT EditWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam);
LRESULT WINAPI EditWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
/*
* Helper functions only valid for one type of control
*/
@ -297,7 +298,8 @@ static __inline__ void EDIT_WM_Cut(WND *wnd, EDITSTATE *es)
* names).
*
*/
LRESULT EditWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
LRESULT WINAPI EditWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam )
{
WND *wnd = WIN_FindWndPtr(hwnd);
EDITSTATE *es = *(EDITSTATE **)((wnd)->wExtra);

3
controls/icontitle.c
View File

@ -185,7 +185,8 @@ static BOOL32 ICONTITLE_Paint( WND* wnd, HDC32 hDC, BOOL32 bActive )
/***********************************************************************
* IconTitleWndProc
*/
LRESULT IconTitleWndProc( HWND32 hWnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam )
LRESULT WINAPI IconTitleWndProc( HWND32 hWnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam )
{
WND *wnd = WIN_FindWndPtr( hWnd );

17
controls/listbox.c
View File

@ -233,7 +233,8 @@ static LRESULT LISTBOX_SetTopItem( WND *wnd, LB_DESCR *descr, INT32 index,
{
INT32 diff = (descr->top_item - index) / descr->page_size * descr->column_width;
if (scroll && (abs(diff) < descr->width))
ScrollWindow32( wnd->hwndSelf, diff, 0, NULL, NULL );
ScrollWindowEx32( wnd->hwndSelf, diff, 0, NULL, NULL, 0, NULL,
SW_INVALIDATE | SW_ERASE );
else
scroll = FALSE;
}
@ -259,7 +260,8 @@ static LRESULT LISTBOX_SetTopItem( WND *wnd, LB_DESCR *descr, INT32 index,
diff = (descr->top_item - index) * descr->item_height;
if (abs(diff) < descr->height)
ScrollWindow32( wnd->hwndSelf, 0, diff, NULL, NULL );
ScrollWindowEx32( wnd->hwndSelf, 0, diff, NULL, NULL, 0, NULL,
SW_INVALIDATE | SW_ERASE );
else
scroll = FALSE;
}
@ -1006,7 +1008,8 @@ static void LISTBOX_SetHorizontalPos( WND *wnd, LB_DESCR *descr, INT32 pos )
descr->horz_pos = pos;
LISTBOX_UpdateScroll( wnd, descr );
if (abs(diff) < descr->width)
ScrollWindow32( wnd->hwndSelf, diff, 0, NULL, NULL );
ScrollWindowEx32( wnd->hwndSelf, diff, 0, NULL, NULL, 0, NULL,
SW_INVALIDATE | SW_ERASE );
else
InvalidateRect32( wnd->hwndSelf, NULL, TRUE );
}
@ -2019,6 +2022,8 @@ static BOOL32 LISTBOX_Create( WND *wnd, LPHEADCOMBO lphc )
*(LB_DESCR **)wnd->wExtra = descr;
/* if (wnd->dwExStyle & WS_EX_NOPARENTNOTIFY) descr->style &= ~LBS_NOTIFY;
*/
if (descr->style & LBS_EXTENDEDSEL) descr->style |= LBS_MULTIPLESEL;
if (descr->style & LBS_MULTICOLUMN) descr->style &= ~LBS_OWNERDRAWVARIABLE;
if (descr->style & LBS_OWNERDRAWVARIABLE) descr->style |= LBS_NOINTEGRALHEIGHT;
@ -2066,7 +2071,8 @@ static BOOL32 LISTBOX_Destroy( WND *wnd, LB_DESCR *descr )
/***********************************************************************
* ListBoxWndProc
*/
LRESULT ListBoxWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
LRESULT WINAPI ListBoxWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam )
{
LRESULT ret;
LB_DESCR *descr;
@ -2491,7 +2497,8 @@ LRESULT COMBO_Directory( LPHEADCOMBO lphc, UINT32 attrib, LPSTR dir, BOOL32 bLon
* NOTE: in Windows, winproc address of the ComboLBox is the same
* as that of the Listbox.
*/
LRESULT ComboLBWndProc(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
LRESULT WINAPI ComboLBWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam )
{
LRESULT lRet = 0;
WND *wnd = WIN_FindWndPtr( hwnd );

865
controls/menu.c
View File

File diff suppressed because it is too large Load Diff

48
controls/scroll.c
View File

@ -756,8 +756,8 @@ void SCROLL_HandleScrollEvent( HWND32 hwnd, INT32 nBar, UINT32 msg, POINT32 pt)
/***********************************************************************
* ScrollBarWndProc
*/
LRESULT ScrollBarWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
LPARAM lParam )
LRESULT WINAPI ScrollBarWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
LPARAM lParam )
{
switch(message)
{
@ -893,8 +893,8 @@ LRESULT ScrollBarWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
/*************************************************************************
* SetScrollInfo16 (USER.475)
*/
INT16 SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info,
BOOL16 bRedraw )
INT16 WINAPI SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info,
BOOL16 bRedraw )
{
return (INT16)SetScrollInfo32( hwnd, nBar, info, bRedraw );
}
@ -903,8 +903,8 @@ INT16 SetScrollInfo16( HWND16 hwnd, INT16 nBar, const SCROLLINFO *info,
/*************************************************************************
* SetScrollInfo32 (USER32.500)
*/
INT32 SetScrollInfo32( HWND32 hwnd, INT32 nBar, const SCROLLINFO *info,
BOOL32 bRedraw )
INT32 WINAPI SetScrollInfo32( HWND32 hwnd, INT32 nBar, const SCROLLINFO *info,
BOOL32 bRedraw )
{
SCROLLBAR_INFO *infoPtr;
UINT32 new_flags;
@ -1007,7 +1007,7 @@ INT32 SetScrollInfo32( HWND32 hwnd, INT32 nBar, const SCROLLINFO *info,
/*************************************************************************
* GetScrollInfo16 (USER.476)
*/
BOOL16 GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
BOOL16 WINAPI GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
{
return GetScrollInfo32( hwnd, nBar, info );
}
@ -1016,7 +1016,7 @@ BOOL16 GetScrollInfo16( HWND16 hwnd, INT16 nBar, LPSCROLLINFO info )
/*************************************************************************
* GetScrollInfo32 (USER32.283)
*/
BOOL32 GetScrollInfo32( HWND32 hwnd, INT32 nBar, LPSCROLLINFO info )
BOOL32 WINAPI GetScrollInfo32( HWND32 hwnd, INT32 nBar, LPSCROLLINFO info )
{
SCROLLBAR_INFO *infoPtr;
@ -1041,7 +1041,8 @@ BOOL32 GetScrollInfo32( HWND32 hwnd, INT32 nBar, LPSCROLLINFO info )
/*************************************************************************
* SetScrollPos16 (USER.62)
*/
INT16 SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos, BOOL16 bRedraw )
INT16 WINAPI SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos,
BOOL16 bRedraw )
{
return (INT16)SetScrollPos32( hwnd, nBar, nPos, bRedraw );
}
@ -1050,7 +1051,8 @@ INT16 SetScrollPos16( HWND16 hwnd, INT16 nBar, INT16 nPos, BOOL16 bRedraw )
/*************************************************************************
* SetScrollPos32 (USER32.501)
*/
INT32 SetScrollPos32( HWND32 hwnd, INT32 nBar, INT32 nPos, BOOL32 bRedraw )
INT32 WINAPI SetScrollPos32( HWND32 hwnd, INT32 nBar, INT32 nPos,
BOOL32 bRedraw )
{
SCROLLINFO info;
SCROLLBAR_INFO *infoPtr;
@ -1069,7 +1071,7 @@ INT32 SetScrollPos32( HWND32 hwnd, INT32 nBar, INT32 nPos, BOOL32 bRedraw )
/*************************************************************************
* GetScrollPos16 (USER.63)
*/
INT16 GetScrollPos16( HWND16 hwnd, INT16 nBar )
INT16 WINAPI GetScrollPos16( HWND16 hwnd, INT16 nBar )
{
return (INT16)GetScrollPos32( hwnd, nBar );
}
@ -1078,7 +1080,7 @@ INT16 GetScrollPos16( HWND16 hwnd, INT16 nBar )
/*************************************************************************
* GetScrollPos32 (USER32.284)
*/
INT32 GetScrollPos32( HWND32 hwnd, INT32 nBar )
INT32 WINAPI GetScrollPos32( HWND32 hwnd, INT32 nBar )
{
SCROLLBAR_INFO *infoPtr;
@ -1090,8 +1092,8 @@ INT32 GetScrollPos32( HWND32 hwnd, INT32 nBar )
/*************************************************************************
* SetScrollRange16 (USER.64)
*/
void SetScrollRange16( HWND16 hwnd, INT16 nBar, INT16 MinVal, INT16 MaxVal,
BOOL16 bRedraw )
void WINAPI SetScrollRange16( HWND16 hwnd, INT16 nBar,
INT16 MinVal, INT16 MaxVal, BOOL16 bRedraw )
{
/* Invalid range -> range is set to (0,0) */
if ((INT32)MaxVal - (INT32)MinVal > 0x7fff) MinVal = MaxVal = 0;
@ -1102,8 +1104,8 @@ void SetScrollRange16( HWND16 hwnd, INT16 nBar, INT16 MinVal, INT16 MaxVal,
/*************************************************************************
* SetScrollRange32 (USER32.502)
*/
BOOL32 SetScrollRange32( HWND32 hwnd, INT32 nBar, INT32 MinVal, INT32 MaxVal,
BOOL32 bRedraw )
BOOL32 WINAPI SetScrollRange32( HWND32 hwnd, INT32 nBar,
INT32 MinVal, INT32 MaxVal, BOOL32 bRedraw )
{
SCROLLINFO info;
@ -1153,7 +1155,8 @@ DWORD SCROLL_SetNCSbState(WND* wndPtr, int vMin, int vMax, int vPos,
/*************************************************************************
* GetScrollRange16 (USER.65)
*/
BOOL16 GetScrollRange16( HWND16 hwnd, INT16 nBar, LPINT16 lpMin, LPINT16 lpMax)
BOOL16 WINAPI GetScrollRange16( HWND16 hwnd, INT16 nBar,
LPINT16 lpMin, LPINT16 lpMax)
{
INT32 min, max;
BOOL16 ret = GetScrollRange32( hwnd, nBar, &min, &max );
@ -1166,7 +1169,8 @@ BOOL16 GetScrollRange16( HWND16 hwnd, INT16 nBar, LPINT16 lpMin, LPINT16 lpMax)
/*************************************************************************
* GetScrollRange32 (USER32.285)
*/
BOOL32 GetScrollRange32( HWND32 hwnd, INT32 nBar, LPINT32 lpMin, LPINT32 lpMax)
BOOL32 WINAPI GetScrollRange32( HWND32 hwnd, INT32 nBar,
LPINT32 lpMin, LPINT32 lpMax)
{
SCROLLBAR_INFO *infoPtr;
@ -1185,7 +1189,7 @@ BOOL32 GetScrollRange32( HWND32 hwnd, INT32 nBar, LPINT32 lpMin, LPINT32 lpMax)
/*************************************************************************
* ShowScrollBar16 (USER.267)
*/
void ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
void WINAPI ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
{
ShowScrollBar32( hwnd, nBar, fShow );
}
@ -1194,7 +1198,7 @@ void ShowScrollBar16( HWND16 hwnd, INT16 nBar, BOOL16 fShow )
/*************************************************************************
* ShowScrollBar32 (USER32.531)
*/
BOOL32 ShowScrollBar32( HWND32 hwnd, INT32 nBar, BOOL32 fShow )
BOOL32 WINAPI ShowScrollBar32( HWND32 hwnd, INT32 nBar, BOOL32 fShow )
{
WND *wndPtr = WIN_FindWndPtr( hwnd );
@ -1261,7 +1265,7 @@ BOOL32 ShowScrollBar32( HWND32 hwnd, INT32 nBar, BOOL32 fShow )
/*************************************************************************
* EnableScrollBar16 (USER.482)
*/
BOOL16 EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
BOOL16 WINAPI EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
{
return EnableScrollBar32( hwnd, nBar, flags );
}
@ -1270,7 +1274,7 @@ BOOL16 EnableScrollBar16( HWND16 hwnd, INT16 nBar, UINT16 flags )
/*************************************************************************
* EnableScrollBar32 (USER32.170)
*/
BOOL32 EnableScrollBar32( HWND32 hwnd, INT32 nBar, UINT32 flags )
BOOL32 WINAPI EnableScrollBar32( HWND32 hwnd, INT32 nBar, UINT32 flags )
{
SCROLLBAR_INFO *infoPtr;

10
controls/static.c
View File

@ -50,13 +50,17 @@ static HICON16 STATIC_SetIcon( WND *wndPtr, HICON16 hicon )
{
HICON16 prevIcon;
STATICINFO *infoPtr = (STATICINFO *)wndPtr->wExtra;
CURSORICONINFO *info = hicon?(CURSORICONINFO *) GlobalLock16( hicon ):NULL;
if ((wndPtr->dwStyle & 0x0f) != SS_ICON) return 0;
if (hicon && !info) {
fprintf(stderr,"STATIC_SetIcon: huh? hicon!=0, but info=0???\n");
return 0;
}
prevIcon = infoPtr->hIcon;
infoPtr->hIcon = hicon;
if (hicon)
{
CURSORICONINFO *info = (CURSORICONINFO *) GlobalLock16( hicon );
SetWindowPos32( wndPtr->hwndSelf, 0, 0, 0, info->nWidth, info->nHeight,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER );
GlobalUnlock16( hicon );
@ -95,8 +99,8 @@ static HICON16 STATIC_LoadIcon( WND *wndPtr, LPCSTR name )
/***********************************************************************
* StaticWndProc
*/
LRESULT StaticWndProc( HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam,
LPARAM lParam )
LRESULT WINAPI StaticWndProc( HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam,
LPARAM lParam )
{
LRESULT lResult = 0;
WND *wndPtr = WIN_FindWndPtr(hWnd);

11
controls/status.c
View File

@ -38,7 +38,8 @@ static STATUSWINDOWINFO *GetStatusInfo(HWND32 hwnd)
/***********************************************************************
* DrawStatusText32A (COMCTL32.3)
*/
void DrawStatusText32A( HDC32 hdc, LPRECT32 lprc, LPCSTR text, UINT32 style )
void WINAPI DrawStatusText32A( HDC32 hdc, LPRECT32 lprc, LPCSTR text,
UINT32 style )
{
RECT32 r, rt;
int oldbkmode;
@ -435,8 +436,8 @@ SW_Paint(STATUSWINDOWINFO *self, HWND32 hwnd)
return 0;
}
LRESULT StatusWindowProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam )
LRESULT WINAPI StatusWindowProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam )
{
STATUSWINDOWINFO *self;
@ -480,8 +481,8 @@ LRESULT StatusWindowProc( HWND32 hwnd, UINT32 msg,
/***********************************************************************
* CreateStatusWindow32A (COMCTL32.4)
*/
HWND32 CreateStatusWindow32A( INT32 style, LPCSTR text, HWND32 parent,
UINT32 wid )
HWND32 WINAPI CreateStatusWindow32A( INT32 style, LPCSTR text, HWND32 parent,
UINT32 wid )
{
HWND32 ret;
ATOM atom;

865
controls/updown.c Normal file
View File

@ -0,0 +1,865 @@
/*
* Updown control
*
* Copyright 1997 Dimitrie O. Paun
*
* TODO:
* - subclass the buddy window (in UPDOWN_SetBuddy) to process the
* arrow keys
* - I am not sure about the default values for the Min, Max, Pos
* (in the UPDOWN_INFO the fields: MinVal, MaxVal, CurVal)
* Testing:
* Not much. The following have not been tested at all:
* - horizontal arrows
* - listbox as buddy window
* - acceleration
* - base 16
* - UDS_ALIGNLEFT, ~UDS_WRAP
* - integers with thousand separators.
* Even though the above list seems rather large, the control seems to
* behave very well so I am confident it does work in most (all) of the
* untested cases.
* Problems:
* At the moment, the control will no draw itself very well because it
* uses some features in DrawEdge that are not yet implemented.
* In other words, there is no known problem, exempt for the things in
* the TODO list above.
*/
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "windows.h"
#include "winnls.h"
#include "syscolor.h"
#include "sysmetrics.h"
#include "updown.h"
#include "graphics.h"
#include "heap.h"
#include "win.h"
#include "stddebug.h"
/*#define DEBUG_UPDOWN*/
#include "debug.h"
/* Control configuration constants */
#define INITIAL_DELAY 500 /* initial timer until auto-increment kicks in */
#define REPEAT_DELAY 50 /* delay between auto-increments */
#define DEFAULT_WIDTH 10 /* default width of the ctrl */
#define DEFAULT_XSEP 0 /* default separation between buddy and crtl */
#define DEFAULT_ADDTOP 1 /* amount to extend above the buddy window */
#define DEFAULT_ADDBOT 1 /* amount to extend below the buddy window */
/* Work constants */
#define FLAG_INCR 0x01
#define FLAG_DECR 0x02
#define FLAG_MOUSEIN 0x04
#define FLAG_CLICKED (FLAG_INCR | FLAG_DECR)
#define TIMERID1 1
#define TIMERID2 2
static int accelIndex = -1;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define UNKNOWN_PARAM(msg, wParam, lParam) dprintf_updown(stddeb, \
"UpDown Ctrl: Unknown parameter(s) for message " #msg \
"(%04x): wp=%04x lp=%08lx\n", msg, wParam, lParam);
#define UPDOWN_GetInfoPtr(wndPtr) ((UPDOWN_INFO *)wndPtr->wExtra)
/***********************************************************************
* UPDOWN_InBounds
* Tests if a given value 'val' is between the Min&Max limits
*/
static BOOL32 UPDOWN_InBounds(WND *wndPtr, int val)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
if(infoPtr->MaxVal > infoPtr->MinVal)
return (infoPtr->MinVal <= val) && (val <= infoPtr->MaxVal);
else
return (infoPtr->MaxVal <= val) && (val <= infoPtr->MinVal);
}
/***********************************************************************
* UPDOWN_OffsetVal
* Tests if we can change the current value by delta. If so, it changes
* it and returns TRUE. Else, it leaves it unchanged and returns FALSE.
*/
static BOOL32 UPDOWN_OffsetVal(WND *wndPtr, int delta)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
/* check if we can do the modification first */
if(!UPDOWN_InBounds(wndPtr, infoPtr->CurVal+delta)){
if(wndPtr->dwStyle & UDS_WRAP)
delta += (delta < 0 ? -1 : 1) *
(infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1) *
(infoPtr->MinVal - infoPtr->MaxVal) +
(delta < 0 ? 1 : -1);
else
return FALSE;
}
infoPtr->CurVal += delta;
return TRUE;
}
/***********************************************************************
* UPDOWN_GetArrawRect
* wndPtr - pointer to the up-down wnd
* rect - will hold the rectangle
* incr - TRUE get the "increment" rect (up or right)
* FALSE get the "decrement" rect (down or left)
*
*/
static void UPDOWN_GetArrowRect(WND *wndPtr, RECT32 *rect, BOOL32 incr)
{
int len; /* will hold the width or height */
GetClientRect32(wndPtr->hwndSelf, rect);
if (wndPtr->dwStyle & UDS_HORZ) {
len = rect->right - rect->left; /* compute the width */
if (incr)
rect->left = len/2;
else
rect->right = len/2;
}
else {
len = rect->bottom - rect->top; /* compute the height */
if (incr)
rect->bottom = len/2;
else
rect->top = len/2;
}
}
/***********************************************************************
* UPDOWN_GetArrowFromPoint
* Returns the rectagle (for the up or down arrow) that contains pt.
* If it returns the up rect, it returns TRUE.
* If it returns the down rect, it returns FALSE.
*/
static int UPDOWN_GetArrowFromPoint(WND *wndPtr, RECT32 *rect, POINT32 pt)
{
UPDOWN_GetArrowRect(wndPtr, rect, TRUE);
if(PtInRect32(rect, pt))
return TRUE;
UPDOWN_GetArrowRect(wndPtr, rect, FALSE);
return FALSE;
}
/***********************************************************************
* UPDOWN_GetThousandSep
* Returns the thousand sep. If an error occurs, it returns ','.
*/
static char UPDOWN_GetThousandSep()
{
char sep[2];
if(GetLocaleInfo32A(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND,
sep, sizeof(sep)) != 1)
return ',';
return sep[0];
}
/***********************************************************************
* UPDOWN_GetBuddyInt
* Tries to read the pos from the buddy window and if it succeeds,
* it stores it in the control's CurVal
* returns:
* TRUE - if it read the integer from the buddy successfully
* FALSE - if an error occured
*/
static BOOL32 UPDOWN_GetBuddyInt(WND *wndPtr)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
char txt[20], sep, *src, *dst;
int newVal;
if (!IsWindow32(infoPtr->Buddy))
return FALSE;
/*if the buddy is a list window, we must set curr index */
if(WIDGETS_IsControl32(WIN_FindWndPtr(infoPtr->Buddy), BIC32_LISTBOX)){
newVal = SendMessage32A(infoPtr->Buddy, LB_GETCARETINDEX32, 0, 0);
if(newVal < 0)
return FALSE;
}
else{
/* we have a regural window, so will get the text */
if (!GetWindowText32A(infoPtr->Buddy, txt, sizeof(txt)))
return FALSE;
sep = UPDOWN_GetThousandSep();
/* now get rid of the separators */
for(src = dst = txt; *src; src++)
if(*src != sep)
*dst++ = *src;
*dst = 0;
/* try to convert the number and validate it */
newVal = strtol(txt, &src, infoPtr->Base);
if(*src || !UPDOWN_InBounds(wndPtr, newVal))
return FALSE;
dprintf_updown(stddeb, "UpDown Ctrl: new value(%d) read from buddy "
"(old=%d)\n", newVal, infoPtr->CurVal);
}
infoPtr->CurVal = newVal;
return TRUE;
}
/***********************************************************************
* UPDOWN_SetBuddyInt
* Tries to set the pos to the buddy window based on current pos
* returns:
* TRUE - if it set the caption of the buddy successfully
* FALSE - if an error occured
*/
static BOOL32 UPDOWN_SetBuddyInt(WND *wndPtr)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
char txt1[20], sep;
int len;
if (!IsWindow32(infoPtr->Buddy))
return FALSE;
dprintf_updown(stddeb, "UpDown Ctrl: set new value(%d) to buddy.\n",
infoPtr->CurVal);
/*if the buddy is a list window, we must set curr index */
if(WIDGETS_IsControl32(WIN_FindWndPtr(infoPtr->Buddy), BIC32_LISTBOX)){
SendMessage32A(infoPtr->Buddy, LB_SETCURSEL32, infoPtr->CurVal, 0);
}
else{ /* Regural window, so set caption to the number */
len = sprintf(txt1, (infoPtr->Base==16) ? "%X" : "%d", infoPtr->CurVal);
sep = UPDOWN_GetThousandSep();
if (!(wndPtr->dwStyle & UDS_NOTHOUSANDS)) {
char txt2[20], *src = txt1, *dst = txt2;
if(len%3 > 0){
strncpy(dst, src, len%3);
dst += len%3;
src += len%3;
}
for(len=0; *src; len++,src++){
if(len%3==0)
*dst++ = sep;
*dst++ = *src++;
}
*dst = 0; /* null terminate it */
strcpy(txt1, txt2); /* move it to the proper place */
}
SetWindowText32A(infoPtr->Buddy, txt1);
}
return TRUE;
}
/***********************************************************************
* UPDOWN_DrawArraw
* Draw the arrows for the up-down control. The arrows are drawn with the
* current pen and filled with the current brush.
* Input:
* hdc - the DC to draw on
* rect - rectangle holding the arrow
* incr - TRUE if we draw the "increment" arrow
* FALSE if we draw the "decrement" arrow
* pressed - TRUE if the arrow is pressed (clicked)
* FALSE if the arrow is not pressed (clicked)
* horz - TRUE if the arrow is horizontal
* FLASE if the arrow is vertical
*/
static void UPDOWN_DrawArrow(HDC32 hdc, RECT32 *rect, BOOL32 incr,
BOOL32 pressed, BOOL32 horz)
{
const int w = rect->right - rect->left;
const int h = rect->bottom - rect->top;
int offset = pressed ? 1 : 0, tmp;
POINT32 pts[3];
if(horz){ /* horizontal arrows */
pts[0].x = rect->right - max(2, w/3) + offset;
pts[0].y = rect->top + max(2, h/4) + offset;
pts[1].x = pts[0].x;
pts[1].y = rect->bottom - max(2, h/4) + offset;
pts[2].x = rect->left + w/3 + offset;
pts[2].y = (pts[0].y + pts[1].y)/2;
if(pts[2].x-2<rect->left)
pts[2].x = rect->left + 2;
if(pts[2].x <= pts[0].x)
pts[2].x = pts[0].x - 1;
if(incr){
tmp = pts[2].x;
pts[2].x = pts[0].x;
pts[0].x = pts[1].x = tmp;
}
}
else{ /* vertical arrows */
pts[0].x = rect->left + max(2, w/4) + offset;
pts[0].y = rect->top + max(2, h/3) + offset;
pts[1].x = rect->right- max(2, w/4) + offset;
pts[1].y = pts[0].y;
pts[2].x = (pts[0].x + pts[1].x)/2;
pts[2].y = pts[0].y + h/3 + offset;
if(pts[2].y+2>rect->bottom)
pts[2].y = rect->bottom - 2;
if(pts[2].y <= pts[0].y)
pts[2].y = pts[0].y + 1;
if(incr){
tmp = pts[2].y;
pts[2].y = pts[0].y;
pts[0].y = pts[1].y = tmp;
}
}
Polygon32(hdc, pts, 3);
}
/***********************************************************************
* UPDOWN_Paint
* Draw the arrows. The background need not be erased.
*/
static void UPDOWN_Paint(WND *wndPtr)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
PAINTSTRUCT32 ps;
BOOL32 prssed;
RECT32 rect;
HDC32 hdc;
HBRUSH32 oldBrush;
hdc = BeginPaint32( wndPtr->hwndSelf, &ps );
/*FIXME - this is just for test */
/* - when DrawEdge works properly, this should dissapear
as DrawEdge will erase the background */
/*oldBrush = SelectObject32(hdc, GetStockObject32(GRAY_BRUSH));
GetClientRect32(wndPtr->hwndSelf, &rect);
Rectangle32(hdc, rect.left, rect.top, rect.right, rect.bottom);
SelectObject32(hdc, oldBrush);*/
/* First select the proper brush */
oldBrush = wndPtr->dwStyle & WS_DISABLED ? GRAY_BRUSH : BLACK_BRUSH;
oldBrush = SelectObject32(hdc, GetStockObject32(oldBrush));
/* Draw the incr button */
UPDOWN_GetArrowRect(wndPtr, &rect, TRUE);
prssed = (infoPtr->Flags & FLAG_INCR) && (infoPtr->Flags & FLAG_MOUSEIN);
DrawEdge32(hdc, &rect, prssed ? EDGE_SUNKEN : EDGE_RAISED,
BF_RECT | BF_SOFT | BF_MIDDLE);
UPDOWN_DrawArrow(hdc, &rect, TRUE, prssed, wndPtr->dwStyle & UDS_HORZ);
/* Draw the decr button */
UPDOWN_GetArrowRect(wndPtr, &rect, FALSE);
prssed = (infoPtr->Flags & FLAG_DECR) && (infoPtr->Flags & FLAG_MOUSEIN);
DrawEdge32(hdc, &rect, prssed ? EDGE_SUNKEN : EDGE_RAISED,
BF_RECT | BF_SOFT | BF_MIDDLE);
UPDOWN_DrawArrow(hdc, &rect, FALSE, prssed, wndPtr->dwStyle & UDS_HORZ);
/* clean-up */
SelectObject32(hdc, oldBrush);
EndPaint32( wndPtr->hwndSelf, &ps );
}
/***********************************************************************
* UPDOWN_SetBuddy
* Tests if 'hwndBud' is a valid window handle. If not, returns FALSE.
* Else, sets it as a new Buddy.
* Then, it should subclass the buddy
* If window has the UDS_ARROWKEYS, it subcalsses the buddy window to
* process the UP/DOWN arrow keys.
* If window has the UDS_ALIGNLEFT or UDS_ALIGNRIGHT style
* the size/pos of the buddy and the control are adjusted accordingly.
*/
static BOOL32 UPDOWN_SetBuddy(WND *wndPtr, HWND32 hwndBud)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
RECT32 budRect; /* new coord for the buddy */
int x; /* new x position and width for the up-down */
/* Is is a valid bud? */
if(!IsWindow32(hwndBud))
return FALSE;
if(wndPtr->dwStyle & UDS_ARROWKEYS){
/* FIXME: we need to subclass the buddy to process the arrow keys. */
fprintf(stderr, "UpDown Ctrl: we should subclass the buddy window!\n");
}
/* do we need to do any adjustments? */
if(!(wndPtr->dwStyle & (UDS_ALIGNLEFT | UDS_ALIGNRIGHT)))
return TRUE;
/* Get the rect of the buddy relative to its parent */
GetWindowRect32(infoPtr->Buddy, &budRect);
MapWindowPoints32(HWND_DESKTOP, GetParent32(infoPtr->Buddy),
(POINT32 *)(&budRect.left), 2);
/* now do the positioning */
if(wndPtr->dwStyle & UDS_ALIGNRIGHT){
budRect.right -= DEFAULT_WIDTH+DEFAULT_XSEP;
x = budRect.right+DEFAULT_XSEP;
}
else{ /* UDS_ALIGNLEFT */
x = budRect.left;
budRect.left += DEFAULT_WIDTH+DEFAULT_XSEP;
}
/* first adjust the buddy to accomodate the up/down */
SetWindowPos32(infoPtr->Buddy, 0, budRect.left, budRect.top,
budRect.right - budRect.left, budRect.bottom - budRect.top,
SWP_NOACTIVATE|SWP_NOZORDER);
/* now position the up/down */
/* Since the UDS_ALIGN* flags were used, */
/* we will pick the position and size of the window. */
SetWindowPos32(wndPtr->hwndSelf,0,x,budRect.top-DEFAULT_ADDTOP,DEFAULT_WIDTH,
(budRect.bottom-budRect.top)+DEFAULT_ADDTOP+DEFAULT_ADDBOT,
SWP_NOACTIVATE|SWP_NOZORDER);
return TRUE;
}
/***********************************************************************
* UPDOWN_DoAction
*
* This function increments/decrements the CurVal by the
* 'delta' amount according to the 'incr' flag
* It notifies the parent as required.
* It handles wraping and non-wraping correctly.
* It is assumed that delta>0
*/
static void UPDOWN_DoAction(WND *wndPtr, int delta, BOOL32 incr)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
int old_val = infoPtr->CurVal;
NM_UPDOWN ni;
dprintf_updown(stddeb, "UpDown Ctrl action: %s by %d\n",
incr ? "inc" : "dec", delta);
/* check if we can do the modification first */
delta *= (incr ? 1 : -1) * (infoPtr->MaxVal < infoPtr->MinVal ? -1 : 1);
if(!UPDOWN_OffsetVal(wndPtr, delta))
return;
/* so, if we can do the change, recompute delta and restore old value */
delta = infoPtr->CurVal - old_val;
infoPtr->CurVal = old_val;
/* We must notify parent now to obtain permission */
ni.iPos = infoPtr->CurVal;
ni.iDelta = delta;
ni.hdr.hwndFrom = wndPtr->hwndSelf;
ni.hdr.idFrom = wndPtr->wIDmenu;
ni.hdr.code = UDN_DELTAPOS;
if(SendMessage32A(wndPtr->parent->hwndSelf,
WM_NOTIFY, wndPtr->wIDmenu, (LPARAM)&ni))
return; /* we are not allowed to change */
/* Now adjust value with (maybe new) delta */
if(!UPDOWN_OffsetVal(wndPtr, ni.iDelta))
return;
/* Now take care about our buddy */
if(!IsWindow32(infoPtr->Buddy))
return; /* Nothing else to do */
if(wndPtr->dwStyle & UDS_SETBUDDYINT)
UPDOWN_SetBuddyInt(wndPtr);
/* Also, notify it */
/* FIXME: do we need to send the notification only if
we do not have the UDS_SETBUDDYINT style set? */
SendMessage32A(infoPtr->Buddy,
wndPtr->dwStyle & UDS_HORZ ? WM_HSCROLL : WM_VSCROLL,
MAKELONG(incr ? SB_LINEUP : SB_LINEDOWN, infoPtr->CurVal),
wndPtr->hwndSelf);
}
/***********************************************************************
* UPDOWN_IsEnabled
*
* Returns TRUE if it is enabled as well as its buddy (if any)
* FALSE otherwise
*/
static BOOL32 UPDOWN_IsEnabled(WND *wndPtr)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
if(wndPtr->dwStyle & WS_DISABLED)
return FALSE;
return IsWindowEnabled32(infoPtr->Buddy);
}
/***********************************************************************
* UPDOWN_CancelMode
*
* Deletes any timers, releases the mouse and does redraw if necessary.
* If the control is not in "capture" mode, it does nothing.
* If the control was not in cancel mode, it returns FALSE.
* If the control was in cancel mode, it returns TRUE.
*/
static BOOL32 UPDOWN_CancelMode(WND *wndPtr)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
/* if not in 'capture' mode, do nothing */
if(!(infoPtr->Flags & FLAG_CLICKED))
return FALSE;
KillTimer32(wndPtr->hwndSelf, TIMERID1); /* kill all possible timers */
KillTimer32(wndPtr->hwndSelf, TIMERID2);
if(GetCapture32() == wndPtr->hwndSelf) /* let the mouse go */
ReleaseCapture(); /* if we still have it */
infoPtr->Flags = 0; /* get rid of any flags */
UPDOWN_Paint(wndPtr); /* redraw the control just in case */
return TRUE;
}
/***********************************************************************
* UPDOWN_HandleMouseEvent
*
* Handle a mouse event for the updown.
* 'pt' is the location of the mouse event in client or
* windows coordinates.
*/
static void UPDOWN_HandleMouseEvent(WND *wndPtr, UINT32 msg, POINT32 pt)
{
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
RECT32 rect;
int temp;
switch(msg)
{
case WM_LBUTTONDOWN: /* Initialise mouse tracking */
/* If we are already in the 'clicked' mode, then nothing to do */
if(infoPtr->Flags & FLAG_CLICKED)
return;
/* If the buddy is an edit, will set focus to it */
if(WIDGETS_IsControl32(WIN_FindWndPtr(infoPtr->Buddy), BIC32_EDIT))
SetFocus32(infoPtr->Buddy);
/* Now see which one is the 'active' arrow */
temp = UPDOWN_GetArrowFromPoint(wndPtr, &rect, pt);
/* Update the CurVal if necessary */
if(wndPtr->dwStyle & UDS_SETBUDDYINT)
UPDOWN_GetBuddyInt(wndPtr);
/* Before we proceed, see if we can spin... */
if(!(wndPtr->dwStyle & UDS_WRAP))
if(( temp && infoPtr->CurVal==infoPtr->MaxVal) ||
(!temp && infoPtr->CurVal==infoPtr->MinVal))
return;
/* Set up the correct flags */
infoPtr->Flags = 0;
infoPtr->Flags |= temp ? FLAG_INCR : FLAG_DECR;
infoPtr->Flags |= FLAG_MOUSEIN;
/* repaint the control */
UPDOWN_Paint(wndPtr);
/* process the click */
UPDOWN_DoAction(wndPtr, 1, infoPtr->Flags & FLAG_INCR);
/* now capture all mouse messages */
SetCapture32(wndPtr->hwndSelf);
/* and startup the first timer */
SetTimer32(wndPtr->hwndSelf, TIMERID1, INITIAL_DELAY, 0);
break;
case WM_MOUSEMOVE:
/* If we are not in the 'clicked' mode, then nothing to do */
if(!(infoPtr->Flags & FLAG_CLICKED))
return;
/* save the flags to see if any got modified */
temp = infoPtr->Flags;
/* Now get the 'active' arrow rectangle */
if (infoPtr->Flags & FLAG_INCR)
UPDOWN_GetArrowRect(wndPtr, &rect, TRUE);
else
UPDOWN_GetArrowRect(wndPtr, &rect, FALSE);
/* Update the flags if we are in/out */
if(PtInRect32(&rect, pt))
infoPtr->Flags |= FLAG_MOUSEIN;
else{
infoPtr->Flags &= ~FLAG_MOUSEIN;
if(accelIndex != -1) /* if we have accel info */
accelIndex = 0; /* reset it */
}
/* If state changed, redraw the control */
if(temp != infoPtr->Flags)
UPDOWN_Paint(wndPtr);
break;
default:
fprintf(stderr, "UpDown: Impossible case in proc "
"UPDOWN_HandleMouseEvent");
}
}
/***********************************************************************
* UpDownWndProc
*/
LRESULT WINAPI UpDownWindowProc(HWND32 hwnd, UINT32 message, WPARAM32 wParam,
LPARAM lParam)
{
WND *wndPtr = WIN_FindWndPtr(hwnd);
UPDOWN_INFO *infoPtr = UPDOWN_GetInfoPtr(wndPtr);
int temp;
switch(message)
{
case WM_CREATE:
/* initialize the info struct */
infoPtr->AccelCount=0; infoPtr->AccelVect=0;
infoPtr->CurVal=0; infoPtr->MinVal=0; infoPtr->MaxVal=100; /*FIXME*/
infoPtr->Base = 10; /* Default to base 10 */
infoPtr->Buddy = 0; /* No buddy window yet */
infoPtr->Flags = 0; /* And no flags */
/* Do we pick the buddy win ourselves? */
if(wndPtr->dwStyle & UDS_AUTOBUDDY)
UPDOWN_SetBuddy(wndPtr, GetWindow32(wndPtr->hwndSelf, GW_HWNDPREV));
dprintf_updown(stddeb, "UpDown Ctrl creation, hwnd=%04x\n", hwnd);
break;
case WM_DESTROY:
if(infoPtr->AccelVect)
free(infoPtr->AccelVect);
dprintf_updown(stddeb, "UpDown Ctrl destruction, hwnd=%04x\n", hwnd);
break;
case WM_ENABLE:
if(wndPtr->dwStyle & WS_DISABLED)
UPDOWN_CancelMode(wndPtr);
UPDOWN_Paint(wndPtr);
break;
case WM_TIMER:
/* if initial timer, kill it and start the repeat timer */
if(wParam == TIMERID1){
KillTimer32(hwnd, TIMERID1);
/* if no accel info given, used default timer */
if(infoPtr->AccelCount==0 || infoPtr->AccelVect==0){
accelIndex = -1;
temp = REPEAT_DELAY;
}
else{
accelIndex = 0; /* otherwise, use it */
temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
}
SetTimer32(hwnd, TIMERID2, temp, 0);
}
/* now, if the mouse is above us, do the thing...*/
if(infoPtr->Flags & FLAG_MOUSEIN){
temp = accelIndex==-1 ? 1 : infoPtr->AccelVect[accelIndex].nInc;
UPDOWN_DoAction(wndPtr, temp, infoPtr->Flags & FLAG_INCR);
if(accelIndex!=-1 && accelIndex < infoPtr->AccelCount-1){
KillTimer32(hwnd, TIMERID2);
accelIndex++; /* move to the next accel info */
temp = infoPtr->AccelVect[accelIndex].nSec * 1000 + 1;
/* make sure we have at least 1ms intervals */
SetTimer32(hwnd, TIMERID2, temp, 0);
}
}
break;
case WM_CANCELMODE:
UPDOWN_CancelMode(wndPtr);
break;
case WM_LBUTTONUP:
if(!UPDOWN_CancelMode(wndPtr))
break;
/*If we released the mouse and our buddy is an edit */
/* we must select all text in it. */
if(WIDGETS_IsControl32(WIN_FindWndPtr(infoPtr->Buddy), BIC32_EDIT))
SendMessage32A(infoPtr->Buddy, EM_SETSEL32, 0, MAKELONG(0, -1));
break;
case WM_LBUTTONDOWN:
case WM_MOUSEMOVE:
if(UPDOWN_IsEnabled(wndPtr)){
POINT32 pt;
CONV_POINT16TO32( (POINT16 *)&lParam, &pt );
UPDOWN_HandleMouseEvent( wndPtr, message, pt );
}
break;
case WM_KEYDOWN:
if((wndPtr->dwStyle & UDS_ARROWKEYS) && UPDOWN_IsEnabled(wndPtr)){
switch(wParam){
case VK_UP:
case VK_DOWN:
UPDOWN_GetBuddyInt(wndPtr);
UPDOWN_DoAction(wndPtr, 1, wParam==VK_UP);
break;
}
}
break;
case WM_PAINT:
UPDOWN_Paint(wndPtr);
break;
case UDM_GETACCEL:
if (wParam==0 && lParam==0) /*if both zero, */
return infoPtr->AccelCount; /*just return the accel count*/
if (wParam || lParam){
UNKNOWN_PARAM(UDM_GETACCEL, wParam, lParam);
return 0;
}
temp = min(infoPtr->AccelCount, wParam);
memcpy((void *)lParam, infoPtr->AccelVect, temp*sizeof(UDACCEL));
return temp;
case UDM_SETACCEL:
dprintf_updown(stddeb, "UpDown Ctrl new accel info, hwnd=%04x\n", hwnd);
if(infoPtr->AccelVect){
free(infoPtr->AccelVect);
infoPtr->AccelCount = 0;
infoPtr->AccelVect = 0;
}
if(wParam==0)
return TRUE;
infoPtr->AccelVect = malloc(wParam*sizeof(UDACCEL));
if(infoPtr->AccelVect==0)
return FALSE;
memcpy(infoPtr->AccelVect, (void*)lParam, wParam*sizeof(UDACCEL));
return TRUE;
case UDM_GETBASE:
if (wParam || lParam)
UNKNOWN_PARAM(UDM_GETBASE, wParam, lParam);
return infoPtr->Base;
case UDM_SETBASE:
dprintf_updown(stddeb, "UpDown Ctrl new base(%d), hwnd=%04x\n",
wParam, hwnd);
if ( !(wParam==10 || wParam==16) || lParam)
UNKNOWN_PARAM(UDM_SETBASE, wParam, lParam);
if (wParam==10 || wParam==16){
temp = infoPtr->Base;
infoPtr->Base = wParam;
return temp; /* return the prev base */
}
break;
case UDM_GETBUDDY:
if (wParam || lParam)
UNKNOWN_PARAM(UDM_GETBUDDY, wParam, lParam);
return infoPtr->Buddy;
case UDM_SETBUDDY:
if (lParam)
UNKNOWN_PARAM(UDM_SETBUDDY, wParam, lParam);
temp = infoPtr->Buddy;
infoPtr->Buddy = wParam;
UPDOWN_SetBuddy(wndPtr, wParam);
dprintf_updown(stddeb, "UpDown Ctrl new buddy(%04x), hwnd=%04x\n",
infoPtr->Buddy, hwnd);
return temp;
case UDM_GETPOS:
if (wParam || lParam)
UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
temp = UPDOWN_GetBuddyInt(wndPtr);
return MAKELONG(infoPtr->CurVal, temp ? 0 : 1);
case UDM_SETPOS:
if (wParam || HIWORD(lParam))
UNKNOWN_PARAM(UDM_GETPOS, wParam, lParam);
temp = SLOWORD(lParam);
dprintf_updown(stddeb, "UpDown Ctrl new value(%d), hwnd=%04x\n",
temp, hwnd);
if(!UPDOWN_InBounds(wndPtr, temp)){
if(temp < infoPtr->MinVal)
temp = infoPtr->MinVal;
if(temp > infoPtr->MaxVal)
temp = infoPtr->MaxVal;
}
wParam = infoPtr->CurVal; /* save prev value */
infoPtr->CurVal = temp; /* set the new value */
if(wndPtr->dwStyle & UDS_SETBUDDYINT)
UPDOWN_SetBuddyInt(wndPtr);
return wParam; /* return prev value */
case UDM_GETRANGE:
if (wParam || lParam)
UNKNOWN_PARAM(UDM_GETRANGE, wParam, lParam);
return MAKELONG(infoPtr->MaxVal, infoPtr->MinVal);
case UDM_SETRANGE:
if (wParam)
UNKNOWN_PARAM(UDM_SETRANGE, wParam, lParam); /* we must have: */
infoPtr->MaxVal = SLOWORD(lParam); /* UD_MINVAL <= Max <= UD_MAXVAL */
infoPtr->MinVal = SHIWORD(lParam); /* UD_MINVAL <= Min <= UD_MAXVAL */
/* |Max-Min| <= UD_MAXVAL */
dprintf_updown(stddeb, "UpDown Ctrl new range(%d to %d), hwnd=%04x\n",
infoPtr->MinVal, infoPtr->MaxVal, hwnd);
break;
default:
if (message >= WM_USER)
fprintf( stderr, "UpDown Ctrl: unknown msg %04x wp=%04x lp=%08lx\n",
message, wParam, lParam );
return DefWindowProc32A( hwnd, message, wParam, lParam );
}
return 0;
}
/***********************************************************************
* CreateUpDownControl (COMCTL32.14)
*/
HWND32 WINAPI CreateUpDownControl( DWORD style, INT32 x, INT32 y,
INT32 cx, INT32 cy, HWND32 parent,
INT32 id, HINSTANCE32 inst, HWND32 buddy,
INT32 maxVal, INT32 minVal, INT32 curVal )
{
HWND32 hUD = CreateWindow32A(UPDOWN_CLASS32A, 0, style, x, y, cx, cy,
parent, id, inst, 0);
if(hUD){
SendMessage32A(hUD, UDM_SETBUDDY, buddy, 0);
SendMessage32A(hUD, UDM_SETRANGE, 0, MAKELONG(maxVal, minVal));
SendMessage32A(hUD, UDM_SETPOS, 0, MAKELONG(curVal, 0));
}
return hUD;
}

29
controls/widgets.c
View File

@ -12,6 +12,7 @@
#include "static.h"
#include "status.h"
#include "scroll.h"
#include "updown.h"
#include "desktop.h"
#include "mdi.h"
#include "gdi.h"
@ -20,18 +21,18 @@
/* Window procedures */
extern LRESULT EditWndProc( HWND32 hwnd, UINT32 msg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT ComboWndProc( HWND32 hwnd, UINT32 msg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT ComboLBWndProc( HWND32 hwnd, UINT32 msg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT ListBoxWndProc( HWND32 hwnd, UINT32 msg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT PopupMenuWndProc( HWND32 hwnd, UINT32 msg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT IconTitleWndProc( HWND32 hwnd, UINT32 msg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT WINAPI EditWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI ComboWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI ComboLBWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI ListBoxWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI PopupMenuWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI IconTitleWndProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
/* Win16 class info */
@ -102,6 +103,8 @@ static WNDCLASS32A WIDGETS_CommonControls32[] =
{
{ CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW, StatusWindowProc, 0,
sizeof(STATUSWINDOWINFO), 0, 0, 0, 0, 0, STATUSCLASSNAME32A },
{ CS_GLOBALCLASS | CS_VREDRAW | CS_HREDRAW, UpDownWindowProc, 0,
sizeof(UPDOWN_INFO), 0, 0, 0, 0, 0, UPDOWN_CLASS32A }
};
#define NB_COMMON_CONTROLS32 \
@ -160,7 +163,7 @@ BOOL32 WIDGETS_Init(void)
/***********************************************************************
* InitCommonControls (COMCTL32.15)
*/
void InitCommonControls(void)
void WINAPI InitCommonControls(void)
{
int i;
char name[30];

8
debugger/dbg.y
View File

@ -504,8 +504,10 @@ static void DEBUG_Main( int signal )
DEBUG_SilentBackTrace();
}
if( signal != SIGTRAP )
{
if ((signal != SIGTRAP) ||
(dbg_exec_mode == EXEC_STEPI_OVER) ||
(dbg_exec_mode == EXEC_STEPI_INSTR))
{
/* Show where we crashed */
curr_frame = 0;
DEBUG_PrintAddress( &addr, dbg_mode, TRUE );
@ -515,7 +517,7 @@ static void DEBUG_Main( int signal )
DEBUG_Disasm( &addr, TRUE );
fprintf(stderr,"\n");
}
}
}
ret_ok = 0;
do

120
documentation/fonts
View File

@ -2,7 +2,7 @@
How To Convert Windows Fonts
============================
If you have access to Windows installation you should use
If you have access to a Windows installation you should use
fnt2bdf utility (found in the 'tools)' directory to convert
bitmap fonts (VGASYS.FON, SSERIFE.FON, and SERIFE.FON) into
the format that X Window System can recognize.
@ -21,18 +21,21 @@ Step 4. Run 'mkfontdir' for the directory you copied fonts to.
If you are already in X you should run 'xset fp rehash'
to make X server aware of the new fonts.
Step 5. Edit wine.conf file to remove aliases for the fonts
Step 5. Edit WINE.CONF file to remove aliases for the fonts
you've just installed.
Wine can get by without these fonts but 'the look and feel'
will be quite different. Also, some applications try to load
their custom fonts on the fly (WinWord 6.0) and since Wine does
WINE can get by without these fonts but 'the look and feel'
may be quite different. Also, some applications try to load
their custom fonts on the fly (WinWord 6.0) and since WINE does
not implement this yet it instead prints out something like;
STUB: AddFontResource( somefile.FON )
STUB: AddFontResource( SOMEFILE.FON )
You can convert this file too. Note that .FON file may not hold
any bitmap fonts and fnt2bdf will fail if this is the case.
any bitmap fonts and fnt2bdf will fail if this is the case. Also
note that although the above message will not disappear WINE will
work around the problem by using the font you extracted from the
SOMEFILE.FON.
What to do with TrueType fonts? There are several commercial
font tools that can convert them to the Type1 format but the
@ -44,53 +47,75 @@ However, there is a possibility of the native TrueType support
via FreeType renderer in the future (hint, hint :-)
WINE.CONF And Font Mapper
=========================
How To Add Font Aliases To WINE.CONF
====================================
Many Windows applications assume that fonts included in original Windows 3.1
distribution (Arial, Times New Roman, MS Sans Serif, etc.) are always present.
In order to make font mapper choose a closely related font you can add aliases
to the [fonts] section.
distribution are always present. By default Wine creates a number of aliases
that map them on the existing X fonts:
Windows font ...is mapped to... X font
"MS Sans Serif" -> "-adobe-helvetica-"
"MS Serif" -> "-bitstream-charter-"
"Times New Roman" -> "-adobe-times-"
"Arial" -> "-adobe-helvetica-"
There is no default alias for the "System" font. Also, no aliases are
created for the fonts that applications install at runtime. The recommended
way to deal with this problem is to convert the missing font (see above).
If it proves impossible, like in the case with TrueType fonts, you can force
the font mapper to choose a closely related X font by adding an alias to the
[fonts] section. Make sure that the X font actually exists (with xfontsel
tool).
AliasN = [Windows font], [X font] <, optional "mask X font" flag>
Example:
Alias0 = System, --international-, mask
Alias1 = Arial, -adobe-helvetica-
Alias2 = Times New Roman, -adobe-times-
Alias0 = System, --international-, subst
Alias1 = ...
...
Comments:
There must be no gaps in the sequence {0, ..., N} otherwise all aliases
* There must be no gaps in the sequence {0, ..., N} otherwise all aliases
after the first gap won't be read.
Usually font mapper translates X font names into font names visible to
* Usually font mapper translates X font names into font names visible to
Windows programs in the following fashion:
X font Converted name
X font ...will show up as... Extracted name
-adobe-helvetica-... "Helvetica"
-adobe-utopia-... "Utopia"
-misc-fixed-... "Fixed"
--international-... -> "International"
-adobe-helvetica-... -> "Helvetica"
-adobe-utopia-... -> "Utopia"
-misc-fixed-... -> "Fixed"
-...
-sony-fixed-... "Sony Fixed" (already have "Fixed")
-sony-fixed-... -> "Sony Fixed"
-...
Only converted names appear in the font selection dialogs. However,
if there is an alias with the "mask" flag set converted name will be
replaced by this alias.
Note that since -misc-fixed- and -sony-fixed- are different fonts
Wine modified the second extracted name to make sure Windows programs
can distinguish them because only extracted names appear in the font
selection dialogs.
* "Masking" alias replaces the original extracted name so that in the
example case we will have the following mapping:
--international- "System"
--international- -> "System"
Nonmasking aliases are translated only when program asks for a font
with the name that matches an alias.
"Nonmasking" aliases are transparent to the user and they do not
replace extracted names.
If you do not have an access to Windows fonts mentioned in the first
paragraph you should try to substitute them with similar X fonts.
Wine discards an alias when it sees that the native X font is
available.
* If you do not have access to Windows fonts mentioned in the first
paragraph you should try to substitute the "System" font with
nonmasking alias. 'xfontsel' will show you the fonts available to
X.
Alias.. = System, ...bold font without serifs
Alias.. = MS Sans Serif, ...helvetica-like font
Also, some Windows applications request fonts without specifying the
typeface name of the font. Font table starts with Arial in most Windows
@ -106,15 +131,16 @@ Comments:
It is better to have a scalable font family (bolds and italics included)
as the default choice because mapper checks all available fonts until
requested height and other attributes match perfectly or the end of the
font table is reached.
font table is reached. Typical X installations have scalable fonts in
the ../fonts/Type1 and ../fonts/Speedo directories.
Cached Font Metrics
===================
How To Manage Cached Font Metrics
=================================
WINE stores detailed information about available fonts in the ~/.wine/.cachedmetrics
file. You can copy it elsewhere and add this entry to the [fonts] section
in the WINE.CONF:
in your WINE.CONF:
FontMetrics = <file with metrics>
@ -122,3 +148,27 @@ If WINE detects changes in the X font configuration it will rebuild font
metrics from scratch and then it will overwrite ~/.wine/.cachedmetrics with
the new information. This process can take a while.
Too Small Or Too Large Fonts
============================
Windows programs may ask WINE to render a font with the height specified
in points. However, point-to-pixel ratio depends on the real physical size
of your display (15", 17", etc...). X tries to provide an estimate of that
but it can be quite different from the actual size. You can change this
ratio by adding the following entry to the [fonts] section:
Resolution = <integer value>
In general, higher numbers give you larger fonts. Try to experiment with
values in the 60 - 120 range. 96 is a good starting point.
"FONT_Init: failed to load ..." Messages On Startup
===================================================
The most likely cause is a broken fonts.dir file in one of your font
directories. You need to rerun 'mkfontdir' to rebuild this file. Read
its manpage for more information.

353
documentation/wine.texinfo
View File

@ -45,12 +45,14 @@ the section entitled ``License, Warranty, and Authors of Wine''.
@sp 4
FIXME: UNIX and POSIX trademarks. @*
DOS @*
X11 @*
MS-Windows, Windows-NT, Windows 95 are registered trademarks of
Microsoft Corp. Postscript is a registered trademark of Adobe Systems
Inc. All other product names mentioned herein are the trademarks of
their respective owners.
Microsoft, Windows, MS-Windows, Windows-NT, Windows 95, and MS-DOS are
registered trademarks of Microsoft Corporation.
NT is a trademark of Northern Telecom Limited.
C++Builder is a trademark of Borland International, Inc.
Postscript is a registered trademark of Adobe Systems Inc.
Other trademarks are the property of their respective owners, which may
be registered in certain jurisdictions.
@end ifinfo
@c begin chapters on right pages
@ -60,7 +62,7 @@ their respective owners.
@sp 10
@center @titlefont{The Wine Reference Manual}
@center Edition 0.0.2, 21 July 1997
@center Edition 0.0.3, 14 August 1997
@c The following two commands start the copyright page.
@ -81,10 +83,14 @@ the section entitled ``License, Warranty, and Authors of Wine''.
@sp 4
FIXME: UNIX and POSIX trademarks. @*
MS-Windows, Windows-NT, Windows 95 are registered trademarks of
Microsoft Corp. Postscript is a registered trademark of Adobe Systems
Inc. All other product names mentioned herein are the trademarks of
their respective owners.
X11 @*
Microsoft, Windows, MS-Windows, Windows-NT, Windows 95, and MS-DOS are
registered trademarks of Microsoft Corporation.
NT is a trademark of Northern Telecom Limited.
C++Builder is a trademark of Borland International, Inc.
Postscript is a registered trademark of Adobe Systems Inc.
Other trademarks are the property of their respective owners, which may
be registered in certain jurisdictions.
@end titlepage
@ -95,12 +101,12 @@ their respective owners.
@c Edit this macro manually in the above parts of the document
@macro winemanualversion
0.0.2
0.0.3
@end macro
@c Edit this macro manually in the above parts of the document
@macro winemanualdate
21 July 1997
14 August 1997
@end macro
@c Edit this macro manually into the TeX titlepage
@ -135,6 +141,11 @@ WIN16
Windows NT
@end macro
@c FIXME: automatical trademark reference
@macro WINNT40
Windows NT 4.0
@end macro
@c FIXME: automatical trademark reference
@macro WIN95
Windows 95
@ -409,12 +420,12 @@ You should consult the files @file{README}, @file{ANNOUNCE},
@file{RELEASE-NOTES}, @file{BUGS}, @file{LICENSE}, and @file{WARRANTY},
in the root directory of the Wine distribution.
The Wine FAQ, available from
@url{ftp://ftp.asgardpro.com/wine/dave/Wine.FAQ},
@url{ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/Wine.FAQ},
@url{ftp://rtfm.mit.edu/pub/usenet-by-group/comp.emulators.ms-windows.wine/WINE_(WINdows_Emulator)_Frequently_Asked_Questions},
@url{ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/Wine.FAQ},
@url{http://www.asgardpro.com/wine/index.html},
The Wine FAQ, available from @*
@url{ftp://ftp.asgardpro.com/wine/dave/Wine.FAQ}, @*
@url{ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/Wine.FAQ}, @*
@url{ftp://rtfm.mit.edu/pub/usenet-by-group/comp.emulators.ms-windows.wine/WINE_(WINdows_Emulator)_Frequently_Asked_Questions}, @*
@url{ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/Wine.FAQ}, @*
@url{http://www.asgardpro.com/wine/index.html}, @*
gives answer to a lot of questions.
The Wine USENET newsgroup is interesting for developers. It discusses technical
@ -702,8 +713,10 @@ This is not present in the @mswindows{} API. (Wine value: 0x0008).
The file is a directory. (Wine value: 0x0010).
@end defvr
@defvr_cw32 FILE_ATTRIBUTE_ARCHIVE
The file is an archive file. All non-directory files are reported by Wine
to have this attribute. (Wine value: 0x0020).
The file is an archive file. Currently, all non-directory files are
reported by Wine to have this attribute. This attribute is normally set
by @mswindows{} to indicate that a file is to be archived; when the file
is archived, the flag is cleared. (Wine value: 0x0020).
@end defvr
@defvr_cw32 FILE_ATTRIBUTE_NORMAL
The file does not have any other attributes set. This value must be used
@ -948,7 +961,21 @@ variable by specifying its name or its ordinal. Although reference by
name is the common usage, some program parts (notably DLL's themselves)
sometimes refer to DLL entries by ordinal. Therefore, the ordinals
cannot be chosen arbitrarily.
@* FIXME: is that correct?
Regular programs that are compiled and linked against @mswindows{} DLL's
will import DLL functions by name. This is therefore the default
behaviour. Most DLL functions will be imported by name in all cases.
Apparently, the @WIN32{} DLL's even show some difference in the mapping
of functions and ordinals on @WINNT{} and @WIN95{}. For most DLL
functions, the ordinal number will not matter.
There are some exceptions to that. Notable the KERNEL32 ordinals below
100 are (presently) unnamed and undocumented functions which can only be
imported by ordinal. These functions are called by some @mswindows{}
programs. Also the @file{shell32.dll} functions are reported to be
imported by ordinal in some other DLL's.
@xref{Getting information on the API}, for sources of further information.
@node Spec file header, Variable entry points, Ordinals, The spec files
@subsubsection The header of a @file{.spec}-file
@ -1034,7 +1061,8 @@ A @WIN16{} function that returns a 32 bit value.
@item register
A function using CPU registers to pass arguments.
@item stdcall
A normal @WIN32{} function.
A normal @WIN32{} function. @xref{Investigating the undocumented API},
for an explanation of the stdcall calling convention.
@item cdecl
A @WIN32{} function using the C calling conventions. (This is presently
only used for the built-in functions of the C runtime system).
@ -1097,6 +1125,9 @@ the called function will be passed a pointer to the first arg; in
See the @code{wsprintf}* functions in @file{user.spec} and
@file{user32.spec} for an example.
Sometimes it is not known how many arguments an undocumented DLL
function takes. @xref{Getting information on the API}, for some hints on
how to proceed in such a case.
@node Special entries, , Function entry points, The spec files
@subsubsection Special entries of @file{.spec}-files
@ -1132,8 +1163,10 @@ should do nothing but return a value.
@var{ORDINAL} is replaced by the ordinal number corresponding to the
function. @var{ARGLENGTH} is the number of bytes that need to be removed
from the stack before returning to the caller. @var{RETVALUE} is the
return value which will be passed back to the caller.
from the stack before returning to the caller. @xref{Investigating the
undocumented API}, for an explanation of the stdcall calling convention.
@var{RETVALUE} is the return value which will be passed back to the
caller.
@strong{Extern ordinals}
@ -1182,6 +1215,10 @@ If you are new to Wine and want to support this project, here are
some suggestions.
@menu
* Getting information on the API:: Official and unofficial sources
of information on the @WIN32{} API.
* Investigating the undocumented API:: You can find out some API
information on your own.
* Implementing an API type:: How to implement a data type
of the API (a checklist).
* Implementing an API function:: How to implement one function
@ -1198,9 +1235,268 @@ some suggestions.
@xref{Debugging}, for advice on how to debug Wine.
@xref{Applying patches}, for instructions on applying patches.
FIXME: what is most urgently needed
@node Implementing an API type, Implementing an API function, , The Wine Project
@node Getting information on the API, Investigating the undocumented API, , The Wine Project
@section Official and unofficial documentation on the @mswindows{} API
@cindex documentation of API functions
@cindex undocumented API functions
@strong{Official documentation}
For documentation on @WIN32{} API functions, you might try one of these
sources:
@itemize @bullet
@item
There is a free online version of the MSDN library (including
documentation for the @WIN32{} API) on
@url{http://www.microsoft.com/msdn/}.
@item
The @WINNT{} DDK gives information about some kernel (``executive'')
routines. Some of the function documentation might also apply to user
accessible DLL's.
@end itemize
@strong{Unofficial documentation}
Not all of the @WIN32{} API is well documented. Some functions are
obscured, and undocumented. @xref{Ordinals}, for information about
undocumented functions imported by ordinal. Getting to know what these
functions do can be tiresome and tedious. Here is a quote from a
news posting concerning two books that might help:
@c From: vischne@ibm.net-nospam (root)
@c Subject: Re: Functions
@c Newsgroups: comp.emulators.ms-windows.wine
@c Date: 24 Jul 97 16:45:11 GMT
@c Organization: The Light
@c NNTP-Posting-Host: 129.37.246.203
@c Message-ID: <33d78697.0@news3.ibm.net>
@quotation
Well actually, there are at least _two_ books that address these problems.
One is by Matt Pietrek, ``Windows 95 System Programming Secrets'', which
gives some auxiliary programs for helping ferret out the information, and
the other is by Shulman, ``Undocumented Windows 95''.
@end quotation
@xref{Ordinals}, for some notes on undocumented kernel functions.
@itemize @bullet
@item
@cindex book on undocumented API features by Pietrik
``Windows 95 System Programming Secrets'' @*
by Matt Pietrek @*
Book & Disk Edition @*
Paperback, 778 pages @*
Published by IDG Books Worldwide @*
Publication date: November 1, 1995 @*
Dimensions (in inches): 9.25 x 7.42 x 2.06 @*
ISBN: 1568843186 @*
@item
@cindex book on undocumented API features by Schulman
``Undocumented Windows; A Programmers Guide
to Reserved Microsoft Windows API Functions'' @*
by Andrew Schulman @*
Paperback, 715 pages @*
Published by Addison-Wesley Pub Co @*
Publication date: February 1, 1994 @*
Dimensions (in inches): 9.11 x 7.37 x 1.53 @*
ISBN: 0201608340 @*
@item
More books on these topics (including Schulman and Pietrik): @*
@url{http://www.sonic.net/~undoc/bookstore.html}
@item
More details about calling undocumented functions can be found at
@url{http://ftp.uni-mannheim.de/info/OReilly/windows/win95.update/dirty.html}.
@item
In 1993 Dr. Dobbs Journal published a column called ``Undocumented
Corner''.
@item
You might want to check out BYTE from December 1983 as well.
@* FIXME: is that to be taken seriously?
@item
And you might try to find out something on your own. @xref{Investigating
the undocumented API}, for details.
@end itemize
But, all in all, @url{news:comp.emulators.ms-windows.wine} says
@c From: dacut@henry.ece.cmu.edu (David A. Cuthbert)
@c Subject: Re: Getting Internet Explorer to work
@c Newsgroups: comp.emulators.ms-windows.wine
@c Date: 24 Jul 1997 03:10:30 GMT
@c Organization: Electrical & Computer Engineering, Carnegie Mellon University
@c Reply-To: henry.ece.cmu.edu!dacut
@c Message-ID: <5r6h36$86c@fs7.ece.cmu.edu>
@c NNTP-Posting-Host: henry.ece.cmu.edu
@quotation
Unfortunately, short of getting something like NuMega's SoftIce, I
don't think there's a ``good'' reference on the mystery <100 ordinals in
KERNEL32.DLL.
@end quotation
@node Investigating the undocumented API, Implementing an API type, Getting information on the API, The Wine Project
@section Investigating the undocumented API
@cindex undocumented API investigation
@cindex parameters of undocumented API functions
@cindex stdcall calling convention
@cindex C calling convention
@cindex API function parameters investigation
@cindex stack handling under stdcall calling
Besides reading the documentation in @ref{Getting information on the API},
you can find out some properties of API functions on your own.
Sometimes it is not known how many arguments an undocumented DLL
function takes. Here is a text from a news posting that gives some
hints on how you might proceed in this case.
@c The following text is closely quoted from:
@c From: dacut@henry.ece.cmu.edu (David A. Cuthbert)
@c Subject: Win32 stub functions (Claus Fischer, please read)
@c Newsgroups: comp.emulators.ms-windows.wine
@c Date: 7 Aug 1997 22:33:09 GMT
@c Organization: Electrical & Computer Engineering, Carnegie Mellon University
@c Reply-To: henry.ece.cmu.edu!dacut
@c Message-ID: <5sdif5$qt3@fs7.ece.cmu.edu>
The problem with implementing stubs for @WIN32{} functions is that it is
not sufficient to return a default value (usually 0) and leave the
stack the way we found it. For most @WIN32{} functions -- those that use
the @dfn{stdcall} calling convention -- the arguments sent to the function
are removed from the stack.
Some background: On the i386 class of machines, stack entries are
usually dword (4 bytes) in size, little-endian. The stack grows
downward in memory. The stack pointer, maintained in the @samp{esp}
register, points to the last valid entry; thus, the operation of
pushing a value onto the stack involves decrementing @samp{esp} and then
moving the value into the memory pointed to by esp (i.e., @code{push p}
in assembly resembles @code{*(--esp) = p;} in C). Removing (popping)
values off the stack is the reverse (i.e., @code{pop p} corresponds to
@code{p = *(esp++);}).
In the @dfn{stdcall} calling convention, arguments are pushed onto the
stack right-to-left. For example, the C call
@example
myfunction(40, 20, 70, 30);
@end example
is expressed in Intel assembly as:
@example
push 30
push 70
push 20
push 40
call myfunction
@end example
In addition, the called function is responsible for removing the
arguments off the stack. Thus, before the call to myfunction, the
stack would look like:
@example
[local variable or temporary]
[local variable or temporary]
30
70
20
esp -> 40
@end example
After the call returns, it should look like:
@example
[local variable or temporary]
esp -> [local variable or temporary]
@end example
To restore the stack to this state, the called function must know how
many arguments to remove (which is the number of arguments it takes).
This is a problem if the function is undocumented.
One way to attempt to document the number of arguments each function
takes is to create a wrapper around that function that detects the
stack offset. @file{WinRelay} (see below) was written to create such
wrappers. Essentially, each wrapper assumes that the function will take
a large number of arguments (by default, 64 in @file{WinRelay}). The
wrapper copies each of these arguments into its stack, calls the actual
function, and then calculates the number of arguments by checking esp
before and after the call.
@cindex bsod (blue screen of death)
@cindex blue screen of death
The main problem with this scheme is that the function must actually
be called from another program. Many of these functions are seldom
used. An attempt was made to aggressively query each function in a
given library (@file{ntdll.dll}) by passing 64 arguments, all 0, to each
function. Unfortunately, @WINNT40{} quickly goes to a blue screen
of death (@dfn{bsod}), even if the program is run from a
non-administrator account.
Another method that has been much more successful is to attempt to
figure out how many arguments each function is removing from the
stack. This instruction, @code{ret hhll} (where @samp{hhll} is the
number of bytes to remove, i.e. the number of arguments times 4), contains
the bytes @samp{0xc2 ll hh} in memory. It is a reasonable assumption
that few, if any, functions take more than 16 arguments; therefore,
@samp{hh} is 0x0 and @samp{ll} is less than 0x40. This utility,
@file{MakeSpec} (see below), simply queries the address of a function
and looks for the first occurrence of the bytes @samp{0xc2 ll 0x0},
where @math{@samp{ll} <= 0x40}.
Of course, this is not without errors. @code{ret 00ll} is not the only
instruction that can have the byte sequence @samp{0xc2 ll 0x0}; for
example, @code{push 0x000040c2} has the byte sequence
@samp{0x68 0xc2 0x40 0x0 0x0}, which matches the above. Properly, the
utility should look for this sequence only on an instruction boundary;
unfortunately, finding instruction boundaries on an i386 requires
implementing a full disassemble -- quite a daunting task. Besides,
the probability of having such a byte sequence that is not the actual
return instruction is fairly low.
Much more troublesome is the non-linear flow of a function. For
example, consider the following two functions:
@example
somefunction1:
jmp somefunction1_impl
somefunction2:
ret 0004
somefunction1_impl:
ret 0008
@end example
@file{MakeSpec} would incorrectly list both @code{somefunction1} and
@code{somefunction2} as taking only a single argument, whereas
@code{somefunction1} really takes two arguments.
With these limitations in mind, it is possible to implement more stubs
in Wine and, eventually, the functions themselves.
@c end of quote
The program @file{WinRelay} can be downloaded from
@url{http://www.ece.cmu.edu/afs/ece/usr/dacut/www/src},
and @file{MakeSpec} will be available from the same location. You can
compile them with Borland's C++Builder; you should not optimize when
compiling (@file{WinRelay} needs the stack frames).
@node Implementing an API type, Implementing an API function, Investigating the undocumented API, The Wine Project
@section Implementing an API type
Here is a checklist that should help you writing your first API type. It
@ -1278,6 +1574,11 @@ declared in Wine. Otherwise, start with the data types.
Find out how the function should be named in Wine and in the DLL's.
@xref{API function and type naming}, for details.
@item
Find out what the function should do. This may be tricky for
undocumented functions. @xref{Getting information on the API}, for some
hints.
@item
Find out where the function should go:
@enumerate

50
files/directory.c
View File

@ -179,7 +179,7 @@ int DIR_Init(void)
/***********************************************************************
* GetTempPath32A (KERNEL32.292)
*/
UINT32 GetTempPath32A( UINT32 count, LPSTR path )
UINT32 WINAPI GetTempPath32A( UINT32 count, LPSTR path )
{
if (path) lstrcpyn32A( path, DIR_TempDosDir, count );
return strlen( DIR_TempDosDir );
@ -189,7 +189,7 @@ UINT32 GetTempPath32A( UINT32 count, LPSTR path )
/***********************************************************************
* GetTempPath32W (KERNEL32.293)
*/
UINT32 GetTempPath32W( UINT32 count, LPWSTR path )
UINT32 WINAPI GetTempPath32W( UINT32 count, LPWSTR path )
{
if (path) lstrcpynAtoW( path, DIR_TempDosDir, count );
return strlen( DIR_TempDosDir );
@ -240,14 +240,14 @@ UINT32 DIR_GetDosPath( INT32 element, LPSTR path, UINT32 count )
/***********************************************************************
* GetTempDrive (KERNEL.92)
*/
BYTE GetTempDrive( BYTE ignored )
BYTE WINAPI GetTempDrive( BYTE ignored )
{
/* FIXME: apparently Windows does something with the ignored byte */
return DIR_TempDosDir[0];
}
UINT32 WIN16_GetTempDrive( BYTE ignored )
UINT32 WINAPI WIN16_GetTempDrive( BYTE ignored )
{
/* A closer look at krnl386.exe shows what the SDK doesn't mention:
*
@ -264,7 +264,7 @@ UINT32 WIN16_GetTempDrive( BYTE ignored )
/***********************************************************************
* GetWindowsDirectory16 (KERNEL.134)
*/
UINT16 GetWindowsDirectory16( LPSTR path, UINT16 count )
UINT16 WINAPI GetWindowsDirectory16( LPSTR path, UINT16 count )
{
return (UINT16)GetWindowsDirectory32A( path, count );
}
@ -273,7 +273,7 @@ UINT16 GetWindowsDirectory16( LPSTR path, UINT16 count )
/***********************************************************************
* GetWindowsDirectory32A (KERNEL32.311)
*/
UINT32 GetWindowsDirectory32A( LPSTR path, UINT32 count )
UINT32 WINAPI GetWindowsDirectory32A( LPSTR path, UINT32 count )
{
if (path) lstrcpyn32A( path, DIR_WindowsDosDir, count );
return strlen( DIR_WindowsDosDir );
@ -283,7 +283,7 @@ UINT32 GetWindowsDirectory32A( LPSTR path, UINT32 count )
/***********************************************************************
* GetWindowsDirectory32W (KERNEL32.312)
*/
UINT32 GetWindowsDirectory32W( LPWSTR path, UINT32 count )
UINT32 WINAPI GetWindowsDirectory32W( LPWSTR path, UINT32 count )
{
if (path) lstrcpynAtoW( path, DIR_WindowsDosDir, count );
return strlen( DIR_WindowsDosDir );
@ -293,7 +293,7 @@ UINT32 GetWindowsDirectory32W( LPWSTR path, UINT32 count )
/***********************************************************************
* GetSystemDirectory16 (KERNEL.135)
*/
UINT16 GetSystemDirectory16( LPSTR path, UINT16 count )
UINT16 WINAPI GetSystemDirectory16( LPSTR path, UINT16 count )
{
return (UINT16)GetSystemDirectory32A( path, count );
}
@ -302,7 +302,7 @@ UINT16 GetSystemDirectory16( LPSTR path, UINT16 count )
/***********************************************************************
* GetSystemDirectory32A (KERNEL32.282)
*/
UINT32 GetSystemDirectory32A( LPSTR path, UINT32 count )
UINT32 WINAPI GetSystemDirectory32A( LPSTR path, UINT32 count )
{
if (path) lstrcpyn32A( path, DIR_SystemDosDir, count );
return strlen( DIR_SystemDosDir );
@ -312,7 +312,7 @@ UINT32 GetSystemDirectory32A( LPSTR path, UINT32 count )
/***********************************************************************
* GetSystemDirectory32W (KERNEL32.283)
*/
UINT32 GetSystemDirectory32W( LPWSTR path, UINT32 count )
UINT32 WINAPI GetSystemDirectory32W( LPWSTR path, UINT32 count )
{
if (path) lstrcpynAtoW( path, DIR_SystemDosDir, count );
return strlen( DIR_SystemDosDir );
@ -322,7 +322,7 @@ UINT32 GetSystemDirectory32W( LPWSTR path, UINT32 count )
/***********************************************************************
* CreateDirectory16 (KERNEL.144)
*/
BOOL16 CreateDirectory16( LPCSTR path, LPVOID dummy )
BOOL16 WINAPI CreateDirectory16( LPCSTR path, LPVOID dummy )
{
dprintf_file( stddeb,"CreateDirectory16(%s,%p)\n", path, dummy );
return (BOOL16)CreateDirectory32A( path, NULL );
@ -332,7 +332,8 @@ BOOL16 CreateDirectory16( LPCSTR path, LPVOID dummy )
/***********************************************************************
* CreateDirectory32A (KERNEL32.39)
*/
BOOL32 CreateDirectory32A( LPCSTR path, LPSECURITY_ATTRIBUTES lpsecattribs )
BOOL32 WINAPI CreateDirectory32A( LPCSTR path,
LPSECURITY_ATTRIBUTES lpsecattribs )
{
DOS_FULL_NAME full_name;
LPCSTR unixName;
@ -357,7 +358,8 @@ BOOL32 CreateDirectory32A( LPCSTR path, LPSECURITY_ATTRIBUTES lpsecattribs )
/***********************************************************************
* CreateDirectory32W (KERNEL32.42)
*/
BOOL32 CreateDirectory32W( LPCWSTR path, LPSECURITY_ATTRIBUTES lpsecattribs )
BOOL32 WINAPI CreateDirectory32W( LPCWSTR path,
LPSECURITY_ATTRIBUTES lpsecattribs )
{
LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
BOOL32 ret = CreateDirectory32A( xpath, lpsecattribs );
@ -369,8 +371,8 @@ BOOL32 CreateDirectory32W( LPCWSTR path, LPSECURITY_ATTRIBUTES lpsecattribs )
/***********************************************************************
* CreateDirectoryEx32A (KERNEL32.40)
*/
BOOL32 CreateDirectoryEx32A( LPCSTR template, LPCSTR path,
LPSECURITY_ATTRIBUTES lpsecattribs)
BOOL32 WINAPI CreateDirectoryEx32A( LPCSTR template, LPCSTR path,
LPSECURITY_ATTRIBUTES lpsecattribs)
{
return CreateDirectory32A(path,lpsecattribs);
}
@ -379,8 +381,8 @@ BOOL32 CreateDirectoryEx32A( LPCSTR template, LPCSTR path,
/***********************************************************************
* CreateDirectoryEx32W (KERNEL32.41)
*/
BOOL32 CreateDirectoryEx32W( LPCWSTR template, LPCWSTR path,
LPSECURITY_ATTRIBUTES lpsecattribs)
BOOL32 WINAPI CreateDirectoryEx32W( LPCWSTR template, LPCWSTR path,
LPSECURITY_ATTRIBUTES lpsecattribs)
{
return CreateDirectory32W(path,lpsecattribs);
}
@ -389,7 +391,7 @@ BOOL32 CreateDirectoryEx32W( LPCWSTR template, LPCWSTR path,
/***********************************************************************
* RemoveDirectory16 (KERNEL)
*/
BOOL16 RemoveDirectory16( LPCSTR path )
BOOL16 WINAPI RemoveDirectory16( LPCSTR path )
{
return (BOOL16)RemoveDirectory32A( path );
}
@ -398,7 +400,7 @@ BOOL16 RemoveDirectory16( LPCSTR path )
/***********************************************************************
* RemoveDirectory32A (KERNEL32.437)
*/
BOOL32 RemoveDirectory32A( LPCSTR path )
BOOL32 WINAPI RemoveDirectory32A( LPCSTR path )
{
DOS_FULL_NAME full_name;
LPCSTR unixName;
@ -424,7 +426,7 @@ BOOL32 RemoveDirectory32A( LPCSTR path )
/***********************************************************************
* RemoveDirectory32W (KERNEL32.438)
*/
BOOL32 RemoveDirectory32W( LPCWSTR path )
BOOL32 WINAPI RemoveDirectory32W( LPCWSTR path )
{
LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
BOOL32 ret = RemoveDirectory32A( xpath );
@ -583,8 +585,8 @@ done:
/***********************************************************************
* SearchPath32A (KERNEL32.447)
*/
DWORD SearchPath32A( LPCSTR path, LPCSTR name, LPCSTR ext, DWORD buflen,
LPSTR buffer, LPSTR *lastpart )
DWORD WINAPI SearchPath32A( LPCSTR path, LPCSTR name, LPCSTR ext, DWORD buflen,
LPSTR buffer, LPSTR *lastpart )
{
LPSTR p, res;
DOS_FULL_NAME full_name;
@ -604,8 +606,8 @@ DWORD SearchPath32A( LPCSTR path, LPCSTR name, LPCSTR ext, DWORD buflen,
/***********************************************************************
* SearchPath32W (KERNEL32.448)
*/
DWORD SearchPath32W( LPCWSTR path, LPCWSTR name, LPCWSTR ext, DWORD buflen,
LPWSTR buffer, LPWSTR *lastpart )
DWORD WINAPI SearchPath32W( LPCWSTR path, LPCWSTR name, LPCWSTR ext,
DWORD buflen, LPWSTR buffer, LPWSTR *lastpart )
{
LPWSTR p;
LPSTR res;

51
files/dos_fs.c
View File

@ -764,7 +764,8 @@ BOOL32 DOSFS_GetFullName( LPCSTR name, BOOL32 check_last, DOS_FULL_NAME *full )
/***********************************************************************
* GetShortPathName32A (KERNEL32.271)
*/
DWORD GetShortPathName32A( LPCSTR longpath, LPSTR shortpath, DWORD shortlen )
DWORD WINAPI GetShortPathName32A( LPCSTR longpath, LPSTR shortpath,
DWORD shortlen )
{
DOS_FULL_NAME full_name;
@ -778,7 +779,8 @@ DWORD GetShortPathName32A( LPCSTR longpath, LPSTR shortpath, DWORD shortlen )
/***********************************************************************
* GetShortPathName32W (KERNEL32.272)
*/
DWORD GetShortPathName32W( LPCWSTR longpath, LPWSTR shortpath, DWORD shortlen )
DWORD WINAPI GetShortPathName32W( LPCWSTR longpath, LPWSTR shortpath,
DWORD shortlen )
{
DOS_FULL_NAME full_name;
DWORD ret = 0;
@ -877,7 +879,8 @@ static DWORD DOSFS_DoGetFullPathName( LPCSTR name, DWORD len, LPSTR result,
/***********************************************************************
* GetFullPathName32A (KERNEL32.272)
*/
DWORD GetFullPathName32A(LPCSTR name, DWORD len, LPSTR buffer, LPSTR *lastpart)
DWORD WINAPI GetFullPathName32A( LPCSTR name, DWORD len, LPSTR buffer,
LPSTR *lastpart )
{
DWORD ret = DOSFS_DoGetFullPathName( name, len, buffer, FALSE );
if (ret && lastpart)
@ -893,8 +896,8 @@ DWORD GetFullPathName32A(LPCSTR name, DWORD len, LPSTR buffer, LPSTR *lastpart)
/***********************************************************************
* GetFullPathName32W (KERNEL32.273)
*/
DWORD GetFullPathName32W( LPCWSTR name, DWORD len, LPWSTR buffer,
LPWSTR *lastpart )
DWORD WINAPI GetFullPathName32W( LPCWSTR name, DWORD len, LPWSTR buffer,
LPWSTR *lastpart )
{
LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
DWORD ret = DOSFS_DoGetFullPathName( nameA, len, (LPSTR)buffer, TRUE );
@ -1044,7 +1047,7 @@ int DOSFS_FindNext( const char *path, const char *short_mask,
/*************************************************************************
* FindFirstFile16 (KERNEL.413)
*/
HANDLE16 FindFirstFile16( LPCSTR path, WIN32_FIND_DATA32A *data )
HANDLE16 WINAPI FindFirstFile16( LPCSTR path, WIN32_FIND_DATA32A *data )
{
DOS_FULL_NAME full_name;
HGLOBAL16 handle;
@ -1076,7 +1079,7 @@ HANDLE16 FindFirstFile16( LPCSTR path, WIN32_FIND_DATA32A *data )
/*************************************************************************
* FindFirstFile32A (KERNEL32.123)
*/
HANDLE32 FindFirstFile32A( LPCSTR path, WIN32_FIND_DATA32A *data )
HANDLE32 WINAPI FindFirstFile32A( LPCSTR path, WIN32_FIND_DATA32A *data )
{
HANDLE32 handle = FindFirstFile16( path, data );
if (handle == INVALID_HANDLE_VALUE16) return INVALID_HANDLE_VALUE32;
@ -1087,7 +1090,7 @@ HANDLE32 FindFirstFile32A( LPCSTR path, WIN32_FIND_DATA32A *data )
/*************************************************************************
* FindFirstFile32W (KERNEL32.124)
*/
HANDLE32 FindFirstFile32W( LPCWSTR path, WIN32_FIND_DATA32W *data )
HANDLE32 WINAPI FindFirstFile32W( LPCWSTR path, WIN32_FIND_DATA32W *data )
{
WIN32_FIND_DATA32A dataA;
LPSTR pathA = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
@ -1111,7 +1114,7 @@ HANDLE32 FindFirstFile32W( LPCWSTR path, WIN32_FIND_DATA32W *data )
/*************************************************************************
* FindNextFile16 (KERNEL.414)
*/
BOOL16 FindNextFile16( HANDLE16 handle, WIN32_FIND_DATA32A *data )
BOOL16 WINAPI FindNextFile16( HANDLE16 handle, WIN32_FIND_DATA32A *data )
{
FIND_FIRST_INFO *info;
int count;
@ -1143,7 +1146,7 @@ BOOL16 FindNextFile16( HANDLE16 handle, WIN32_FIND_DATA32A *data )
/*************************************************************************
* FindNextFile32A (KERNEL32.126)
*/
BOOL32 FindNextFile32A( HANDLE32 handle, WIN32_FIND_DATA32A *data )
BOOL32 WINAPI FindNextFile32A( HANDLE32 handle, WIN32_FIND_DATA32A *data )
{
return FindNextFile16( handle, data );
}
@ -1152,7 +1155,7 @@ BOOL32 FindNextFile32A( HANDLE32 handle, WIN32_FIND_DATA32A *data )
/*************************************************************************
* FindNextFile32W (KERNEL32.127)
*/
BOOL32 FindNextFile32W( HANDLE32 handle, WIN32_FIND_DATA32W *data )
BOOL32 WINAPI FindNextFile32W( HANDLE32 handle, WIN32_FIND_DATA32W *data )
{
WIN32_FIND_DATA32A dataA;
if (!FindNextFile32A( handle, &dataA )) return FALSE;
@ -1171,7 +1174,7 @@ BOOL32 FindNextFile32W( HANDLE32 handle, WIN32_FIND_DATA32W *data )
/*************************************************************************
* FindClose16 (KERNEL.415)
*/
BOOL16 FindClose16( HANDLE16 handle )
BOOL16 WINAPI FindClose16( HANDLE16 handle )
{
FIND_FIRST_INFO *info;
@ -1191,7 +1194,7 @@ BOOL16 FindClose16( HANDLE16 handle )
/*************************************************************************
* FindClose32 (KERNEL32.119)
*/
BOOL32 FindClose32( HANDLE32 handle )
BOOL32 WINAPI FindClose32( HANDLE32 handle )
{
return FindClose16( (HANDLE16)handle );
}
@ -1419,7 +1422,7 @@ time_t DOSFS_FileTimeToUnixTime( const FILETIME *filetime, DWORD *remainder )
/***********************************************************************
* DosDateTimeToFileTime (KERNEL32.76)
*/
BOOL32 DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft )
BOOL32 WINAPI DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft)
{
struct tm newtm;
@ -1437,8 +1440,8 @@ BOOL32 DosDateTimeToFileTime( WORD fatdate, WORD fattime, LPFILETIME ft )
/***********************************************************************
* FileTimeToDosDateTime (KERNEL32.111)
*/
BOOL32 FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
LPWORD fattime )
BOOL32 WINAPI FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
LPWORD fattime )
{
time_t unixtime = DOSFS_FileTimeToUnixTime( ft, NULL );
struct tm *tm = localtime( &unixtime );
@ -1454,7 +1457,8 @@ BOOL32 FileTimeToDosDateTime( const FILETIME *ft, LPWORD fatdate,
/***********************************************************************
* LocalFileTimeToFileTime (KERNEL32.373)
*/
BOOL32 LocalFileTimeToFileTime( const FILETIME *localft, LPFILETIME utcft )
BOOL32 WINAPI LocalFileTimeToFileTime( const FILETIME *localft,
LPFILETIME utcft )
{
struct tm *xtm;
DWORD remainder;
@ -1470,7 +1474,8 @@ BOOL32 LocalFileTimeToFileTime( const FILETIME *localft, LPFILETIME utcft )
/***********************************************************************
* FileTimeToLocalFileTime (KERNEL32.112)
*/
BOOL32 FileTimeToLocalFileTime( const FILETIME *utcft, LPFILETIME localft )
BOOL32 WINAPI FileTimeToLocalFileTime( const FILETIME *utcft,
LPFILETIME localft )
{
struct tm *xtm;
DWORD remainder;
@ -1486,7 +1491,7 @@ BOOL32 FileTimeToLocalFileTime( const FILETIME *utcft, LPFILETIME localft )
/***********************************************************************
* FileTimeToSystemTime (KERNEL32.113)
*/
BOOL32 FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
BOOL32 WINAPI FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
{
struct tm *xtm;
DWORD remainder;
@ -1508,8 +1513,7 @@ BOOL32 FileTimeToSystemTime( const FILETIME *ft, LPSYSTEMTIME syst )
*
* returns array of strings terminated by \0, terminated by \0
*/
DWORD
QueryDosDevice32A(LPCSTR devname,LPSTR target,DWORD bufsize)
DWORD WINAPI QueryDosDevice32A(LPCSTR devname,LPSTR target,DWORD bufsize)
{
LPSTR s;
char buffer[200];
@ -1537,8 +1541,7 @@ QueryDosDevice32A(LPCSTR devname,LPSTR target,DWORD bufsize)
*
* returns array of strings terminated by \0, terminated by \0
*/
DWORD
QueryDosDevice32W(LPCWSTR devname,LPWSTR target,DWORD bufsize)
DWORD WINAPI QueryDosDevice32W(LPCWSTR devname,LPWSTR target,DWORD bufsize)
{
LPSTR devnameA = devname?HEAP_strdupWtoA(GetProcessHeap(),0,devname):NULL;
LPSTR targetA = (LPSTR)HEAP_xalloc(GetProcessHeap(),0,bufsize);
@ -1554,7 +1557,7 @@ QueryDosDevice32W(LPCWSTR devname,LPWSTR target,DWORD bufsize)
/***********************************************************************
* SystemTimeToFileTime (KERNEL32.526)
*/
BOOL32 SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
BOOL32 WINAPI SystemTimeToFileTime( const SYSTEMTIME *syst, LPFILETIME ft )
{
struct tm xtm;

56
files/drive.c
View File

@ -538,9 +538,9 @@ static int DRIVE_GetFreeSpace( int drive, DWORD *size, DWORD *available )
/***********************************************************************
* GetDiskFreeSpace16 (KERNEL.422)
*/
BOOL16 GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
BOOL16 WINAPI GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
return GetDiskFreeSpace32A( root, cluster_sectors, sector_bytes,
free_clusters, total_clusters );
@ -550,9 +550,9 @@ BOOL16 GetDiskFreeSpace16( LPCSTR root, LPDWORD cluster_sectors,
/***********************************************************************
* GetDiskFreeSpace32A (KERNEL32.206)
*/
BOOL32 GetDiskFreeSpace32A( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
BOOL32 WINAPI GetDiskFreeSpace32A( LPCSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
int drive;
DWORD size,available;
@ -583,9 +583,9 @@ BOOL32 GetDiskFreeSpace32A( LPCSTR root, LPDWORD cluster_sectors,
/***********************************************************************
* GetDiskFreeSpace32W (KERNEL32.207)
*/
BOOL32 GetDiskFreeSpace32W( LPCWSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
BOOL32 WINAPI GetDiskFreeSpace32W( LPCWSTR root, LPDWORD cluster_sectors,
LPDWORD sector_bytes, LPDWORD free_clusters,
LPDWORD total_clusters )
{
LPSTR xroot;
BOOL32 ret;
@ -601,7 +601,7 @@ BOOL32 GetDiskFreeSpace32W( LPCWSTR root, LPDWORD cluster_sectors,
/***********************************************************************
* GetDriveType16 (KERNEL.136)
*/
UINT16 GetDriveType16( UINT16 drive )
UINT16 WINAPI GetDriveType16( UINT16 drive )
{
dprintf_dosfs( stddeb, "GetDriveType16(%c:)\n", 'A' + drive );
switch(DRIVE_GetType(drive))
@ -619,7 +619,7 @@ UINT16 GetDriveType16( UINT16 drive )
/***********************************************************************
* GetDriveType32A (KERNEL32.208)
*/
UINT32 GetDriveType32A( LPCSTR root )
UINT32 WINAPI GetDriveType32A( LPCSTR root )
{
dprintf_dosfs( stddeb, "GetDriveType32A(%s)\n", root );
if (root[1] != ':')
@ -642,7 +642,7 @@ UINT32 GetDriveType32A( LPCSTR root )
/***********************************************************************
* GetDriveType32W (KERNEL32.209)
*/
UINT32 GetDriveType32W( LPCWSTR root )
UINT32 WINAPI GetDriveType32W( LPCWSTR root )
{
LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
UINT32 ret = GetDriveType32A( xpath );
@ -654,7 +654,7 @@ UINT32 GetDriveType32W( LPCWSTR root )
/***********************************************************************
* GetCurrentDirectory16 (KERNEL.411)
*/
UINT16 GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
UINT16 WINAPI GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
{
return (UINT16)GetCurrentDirectory32A( buflen, buf );
}
@ -665,7 +665,7 @@ UINT16 GetCurrentDirectory16( UINT16 buflen, LPSTR buf )
*
* Returns "X:\\path\\etc\\".
*/
UINT32 GetCurrentDirectory32A( UINT32 buflen, LPSTR buf )
UINT32 WINAPI GetCurrentDirectory32A( UINT32 buflen, LPSTR buf )
{
char *pref = "A:\\";
const char *s = DRIVE_GetDosCwd( DRIVE_GetCurrentDrive() );
@ -684,7 +684,7 @@ UINT32 GetCurrentDirectory32A( UINT32 buflen, LPSTR buf )
/***********************************************************************
* GetCurrentDirectory32W (KERNEL32.197)
*/
UINT32 GetCurrentDirectory32W( UINT32 buflen, LPWSTR buf )
UINT32 WINAPI GetCurrentDirectory32W( UINT32 buflen, LPWSTR buf )
{
LPSTR xpath = HeapAlloc( GetProcessHeap(), 0, buflen+1 );
UINT32 ret = GetCurrentDirectory32A( buflen, xpath );
@ -697,7 +697,7 @@ UINT32 GetCurrentDirectory32W( UINT32 buflen, LPWSTR buf )
/***********************************************************************
* SetCurrentDirectory (KERNEL.412)
*/
BOOL16 SetCurrentDirectory16( LPCSTR dir )
BOOL16 WINAPI SetCurrentDirectory16( LPCSTR dir )
{
return SetCurrentDirectory32A( dir );
}
@ -706,7 +706,7 @@ BOOL16 SetCurrentDirectory16( LPCSTR dir )
/***********************************************************************
* SetCurrentDirectory32A (KERNEL32.479)
*/
BOOL32 SetCurrentDirectory32A( LPCSTR dir )
BOOL32 WINAPI SetCurrentDirectory32A( LPCSTR dir )
{
int drive = DRIVE_GetCurrentDrive();
@ -730,7 +730,7 @@ BOOL32 SetCurrentDirectory32A( LPCSTR dir )
/***********************************************************************
* SetCurrentDirectory32W (KERNEL32.480)
*/
BOOL32 SetCurrentDirectory32W( LPCWSTR dirW )
BOOL32 WINAPI SetCurrentDirectory32W( LPCWSTR dirW )
{
LPSTR dir = HEAP_strdupWtoA( GetProcessHeap(), 0, dirW );
BOOL32 res = SetCurrentDirectory32A( dir );
@ -742,7 +742,7 @@ BOOL32 SetCurrentDirectory32W( LPCWSTR dirW )
/***********************************************************************
* GetLogicalDriveStrings32A (KERNEL32.231)
*/
UINT32 GetLogicalDriveStrings32A( UINT32 len, LPSTR buffer )
UINT32 WINAPI GetLogicalDriveStrings32A( UINT32 len, LPSTR buffer )
{
int drive, count;
@ -768,7 +768,7 @@ UINT32 GetLogicalDriveStrings32A( UINT32 len, LPSTR buffer )
/***********************************************************************
* GetLogicalDriveStrings32W (KERNEL32.232)
*/
UINT32 GetLogicalDriveStrings32W( UINT32 len, LPWSTR buffer )
UINT32 WINAPI GetLogicalDriveStrings32W( UINT32 len, LPWSTR buffer )
{
int drive, count;
@ -794,7 +794,7 @@ UINT32 GetLogicalDriveStrings32W( UINT32 len, LPWSTR buffer )
/***********************************************************************
* GetLogicalDrives (KERNEL32.233)
*/
DWORD GetLogicalDrives(void)
DWORD WINAPI GetLogicalDrives(void)
{
DWORD ret = 0;
int drive;
@ -808,9 +808,10 @@ DWORD GetLogicalDrives(void)
/***********************************************************************
* GetVolumeInformation32A (KERNEL32.309)
*/
BOOL32 GetVolumeInformation32A( LPCSTR root, LPSTR label, DWORD label_len,
DWORD *serial, DWORD *filename_len,
DWORD *flags, LPSTR fsname, DWORD fsname_len )
BOOL32 WINAPI GetVolumeInformation32A( LPCSTR root, LPSTR label,
DWORD label_len, DWORD *serial,
DWORD *filename_len, DWORD *flags,
LPSTR fsname, DWORD fsname_len )
{
int drive;
@ -843,9 +844,10 @@ BOOL32 GetVolumeInformation32A( LPCSTR root, LPSTR label, DWORD label_len,
/***********************************************************************
* GetVolumeInformation32W (KERNEL32.310)
*/
BOOL32 GetVolumeInformation32W( LPCWSTR root, LPWSTR label, DWORD label_len,
DWORD *serial, DWORD *filename_len,
DWORD *flags, LPWSTR fsname, DWORD fsname_len)
BOOL32 WINAPI GetVolumeInformation32W( LPCWSTR root, LPWSTR label,
DWORD label_len, DWORD *serial,
DWORD *filename_len, DWORD *flags,
LPWSTR fsname, DWORD fsname_len )
{
LPSTR xroot = HEAP_strdupWtoA( GetProcessHeap(), 0, root );
LPSTR xvolname = label ? HeapAlloc(GetProcessHeap(),0,label_len) : NULL;

129
files/file.c
View File

@ -376,8 +376,8 @@ BOOL32 FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
/***********************************************************************
* GetFileInformationByHandle (KERNEL32.219)
*/
DWORD GetFileInformationByHandle( HFILE32 hFile,
BY_HANDLE_FILE_INFORMATION *info )
DWORD WINAPI GetFileInformationByHandle( HFILE32 hFile,
BY_HANDLE_FILE_INFORMATION *info )
{
FILE_OBJECT *file;
DWORD ret = 0;
@ -400,7 +400,7 @@ DWORD GetFileInformationByHandle( HFILE32 hFile,
/**************************************************************************
* GetFileAttributes16 (KERNEL.420)
*/
DWORD GetFileAttributes16( LPCSTR name )
DWORD WINAPI GetFileAttributes16( LPCSTR name )
{
return GetFileAttributes32A( name );
}
@ -409,7 +409,7 @@ DWORD GetFileAttributes16( LPCSTR name )
/**************************************************************************
* GetFileAttributes32A (KERNEL32.217)
*/
DWORD GetFileAttributes32A( LPCSTR name )
DWORD WINAPI GetFileAttributes32A( LPCSTR name )
{
DOS_FULL_NAME full_name;
BY_HANDLE_FILE_INFORMATION info;
@ -425,7 +425,7 @@ DWORD GetFileAttributes32A( LPCSTR name )
/**************************************************************************
* GetFileAttributes32W (KERNEL32.218)
*/
DWORD GetFileAttributes32W( LPCWSTR name )
DWORD WINAPI GetFileAttributes32W( LPCWSTR name )
{
LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
DWORD res = GetFileAttributes32A( nameA );
@ -437,7 +437,7 @@ DWORD GetFileAttributes32W( LPCWSTR name )
/***********************************************************************
* GetFileSize (KERNEL32.220)
*/
DWORD GetFileSize( HFILE32 hFile, LPDWORD filesizehigh )
DWORD WINAPI GetFileSize( HFILE32 hFile, LPDWORD filesizehigh )
{
BY_HANDLE_FILE_INFORMATION info;
if (!GetFileInformationByHandle( hFile, &info )) return 0;
@ -449,8 +449,9 @@ DWORD GetFileSize( HFILE32 hFile, LPDWORD filesizehigh )
/***********************************************************************
* GetFileTime (KERNEL32.221)
*/
BOOL32 GetFileTime( HFILE32 hFile, FILETIME *lpCreationTime,
FILETIME *lpLastAccessTime, FILETIME *lpLastWriteTime )
BOOL32 WINAPI GetFileTime( HFILE32 hFile, FILETIME *lpCreationTime,
FILETIME *lpLastAccessTime,
FILETIME *lpLastWriteTime )
{
BY_HANDLE_FILE_INFORMATION info;
if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
@ -463,7 +464,7 @@ BOOL32 GetFileTime( HFILE32 hFile, FILETIME *lpCreationTime,
/***********************************************************************
* CompareFileTime (KERNEL32.28)
*/
INT32 CompareFileTime( LPFILETIME x, LPFILETIME y )
INT32 WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
{
if (!x || !y) return -1;
@ -517,8 +518,8 @@ HFILE32 FILE_Dup2( HFILE32 hFile1, HFILE32 hFile2 )
/***********************************************************************
* GetTempFileName16 (KERNEL.97)
*/
UINT16 GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
LPSTR buffer )
UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
LPSTR buffer )
{
char temppath[144];
@ -544,8 +545,8 @@ UINT16 GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
/***********************************************************************
* GetTempFileName32A (KERNEL32.290)
*/
UINT32 GetTempFileName32A( LPCSTR path, LPCSTR prefix, UINT32 unique,
LPSTR buffer)
UINT32 WINAPI GetTempFileName32A( LPCSTR path, LPCSTR prefix, UINT32 unique,
LPSTR buffer)
{
DOS_FULL_NAME full_name;
int i;
@ -603,8 +604,8 @@ UINT32 GetTempFileName32A( LPCSTR path, LPCSTR prefix, UINT32 unique,
/***********************************************************************
* GetTempFileName32W (KERNEL32.291)
*/
UINT32 GetTempFileName32W( LPCWSTR path, LPCWSTR prefix, UINT32 unique,
LPWSTR buffer )
UINT32 WINAPI GetTempFileName32W( LPCWSTR path, LPCWSTR prefix, UINT32 unique,
LPWSTR buffer )
{
LPSTR patha,prefixa;
char buffera[144];
@ -758,7 +759,7 @@ error: /* We get here if there was an error opening the file */
/***********************************************************************
* OpenFile16 (KERNEL.74)
*/
HFILE16 OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
{
return FILE_DoOpenFile( name, ofs, mode, FALSE );
}
@ -767,7 +768,7 @@ HFILE16 OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
/***********************************************************************
* OpenFile32 (KERNEL32.396)
*/
HFILE32 OpenFile32( LPCSTR name, OFSTRUCT *ofs, UINT32 mode )
HFILE32 WINAPI OpenFile32( LPCSTR name, OFSTRUCT *ofs, UINT32 mode )
{
return FILE_DoOpenFile( name, ofs, mode, TRUE );
}
@ -776,7 +777,7 @@ HFILE32 OpenFile32( LPCSTR name, OFSTRUCT *ofs, UINT32 mode )
/***********************************************************************
* _lclose16 (KERNEL.81)
*/
HFILE16 _lclose16( HFILE16 hFile )
HFILE16 WINAPI _lclose16( HFILE16 hFile )
{
dprintf_file( stddeb, "_lclose16: handle %d\n", hFile );
return CloseHandle( hFile ) ? 0 : HFILE_ERROR16;
@ -786,7 +787,7 @@ HFILE16 _lclose16( HFILE16 hFile )
/***********************************************************************
* _lclose32 (KERNEL32.592)
*/
HFILE32 _lclose32( HFILE32 hFile )
HFILE32 WINAPI _lclose32( HFILE32 hFile )
{
dprintf_file( stddeb, "_lclose32: handle %d\n", hFile );
return CloseHandle( hFile ) ? 0 : HFILE_ERROR32;
@ -796,7 +797,7 @@ HFILE32 _lclose32( HFILE32 hFile )
/***********************************************************************
* WIN16_hread
*/
LONG WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
{
LONG maxlen;
@ -813,7 +814,7 @@ LONG WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
/***********************************************************************
* WIN16_lread
*/
UINT16 WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
{
return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
}
@ -822,7 +823,7 @@ UINT16 WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
/***********************************************************************
* _lread32 (KERNEL32.596)
*/
UINT32 _lread32( HFILE32 hFile, LPVOID buffer, UINT32 count )
UINT32 WINAPI _lread32( HFILE32 hFile, LPVOID buffer, UINT32 count )
{
FILE_OBJECT *file;
UINT32 result;
@ -840,7 +841,7 @@ UINT32 _lread32( HFILE32 hFile, LPVOID buffer, UINT32 count )
/***********************************************************************
* _lread16 (KERNEL.82)
*/
UINT16 _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
{
return (UINT16)_lread32( hFile, buffer, (LONG)count );
}
@ -849,7 +850,7 @@ UINT16 _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
/***********************************************************************
* _lcreat16 (KERNEL.83)
*/
HFILE16 _lcreat16( LPCSTR path, INT16 attr )
HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
{
int mode = (attr & 1) ? 0444 : 0666;
dprintf_file( stddeb, "_lcreat16: %s %02x\n", path, attr );
@ -860,7 +861,7 @@ HFILE16 _lcreat16( LPCSTR path, INT16 attr )
/***********************************************************************
* _lcreat32 (KERNEL32.593)
*/
HFILE32 _lcreat32( LPCSTR path, INT32 attr )
HFILE32 WINAPI _lcreat32( LPCSTR path, INT32 attr )
{
int mode = (attr & 1) ? 0444 : 0666;
dprintf_file( stddeb, "_lcreat32: %s %02x\n", path, attr );
@ -882,8 +883,8 @@ HFILE32 _lcreat_uniq( LPCSTR path, INT32 attr )
/***********************************************************************
* SetFilePointer (KERNEL32.492)
*/
DWORD SetFilePointer( HFILE32 hFile, LONG distance, LONG *highword,
DWORD method )
DWORD WINAPI SetFilePointer( HFILE32 hFile, LONG distance, LONG *highword,
DWORD method )
{
FILE_OBJECT *file;
int origin, result;
@ -915,7 +916,7 @@ DWORD SetFilePointer( HFILE32 hFile, LONG distance, LONG *highword,
/***********************************************************************
* _llseek16 (KERNEL.84)
*/
LONG _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
{
return SetFilePointer( hFile, lOffset, NULL, nOrigin );
}
@ -924,7 +925,7 @@ LONG _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
/***********************************************************************
* _llseek32 (KERNEL32.594)
*/
LONG _llseek32( HFILE32 hFile, LONG lOffset, INT32 nOrigin )
LONG WINAPI _llseek32( HFILE32 hFile, LONG lOffset, INT32 nOrigin )
{
return SetFilePointer( hFile, lOffset, NULL, nOrigin );
}
@ -933,7 +934,7 @@ LONG _llseek32( HFILE32 hFile, LONG lOffset, INT32 nOrigin )
/***********************************************************************
* _lopen16 (KERNEL.85)
*/
HFILE16 _lopen16( LPCSTR path, INT16 mode )
HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
{
return _lopen32( path, mode );
}
@ -942,7 +943,7 @@ HFILE16 _lopen16( LPCSTR path, INT16 mode )
/***********************************************************************
* _lopen32 (KERNEL32.595)
*/
HFILE32 _lopen32( LPCSTR path, INT32 mode )
HFILE32 WINAPI _lopen32( LPCSTR path, INT32 mode )
{
INT32 unixMode;
@ -968,7 +969,7 @@ HFILE32 _lopen32( LPCSTR path, INT32 mode )
/***********************************************************************
* _lwrite16 (KERNEL.86)
*/
UINT16 _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
{
return (UINT16)_hwrite32( hFile, buffer, (LONG)count );
}
@ -976,7 +977,7 @@ UINT16 _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
/***********************************************************************
* _lwrite32 (KERNEL.86)
*/
UINT32 _lwrite32( HFILE32 hFile, LPCSTR buffer, UINT32 count )
UINT32 WINAPI _lwrite32( HFILE32 hFile, LPCSTR buffer, UINT32 count )
{
return (UINT32)_hwrite32( hFile, buffer, (LONG)count );
}
@ -985,7 +986,7 @@ UINT32 _lwrite32( HFILE32 hFile, LPCSTR buffer, UINT32 count )
/***********************************************************************
* _hread16 (KERNEL.349)
*/
LONG _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
{
return _lread32( hFile, buffer, count );
}
@ -994,7 +995,7 @@ LONG _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
/***********************************************************************
* _hread32 (KERNEL32.590)
*/
LONG _hread32( HFILE32 hFile, LPVOID buffer, LONG count)
LONG WINAPI _hread32( HFILE32 hFile, LPVOID buffer, LONG count)
{
return _lread32( hFile, buffer, count );
}
@ -1003,7 +1004,7 @@ LONG _hread32( HFILE32 hFile, LPVOID buffer, LONG count)
/***********************************************************************
* _hwrite16 (KERNEL.350)
*/
LONG _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
{
return _hwrite32( hFile, buffer, count );
}
@ -1012,7 +1013,7 @@ LONG _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
/***********************************************************************
* _hwrite32 (KERNEL32.591)
*/
LONG _hwrite32( HFILE32 hFile, LPCSTR buffer, LONG count )
LONG WINAPI _hwrite32( HFILE32 hFile, LPCSTR buffer, LONG count )
{
FILE_OBJECT *file;
LONG result;
@ -1042,7 +1043,7 @@ LONG _hwrite32( HFILE32 hFile, LPCSTR buffer, LONG count )
/***********************************************************************
* SetHandleCount16 (KERNEL.199)
*/
UINT16 SetHandleCount16( UINT16 count )
UINT16 WINAPI SetHandleCount16( UINT16 count )
{
HGLOBAL16 hPDB = GetCurrentPDB();
PDB *pdb = (PDB *)GlobalLock16( hPDB );
@ -1094,7 +1095,7 @@ UINT16 SetHandleCount16( UINT16 count )
/*************************************************************************
* SetHandleCount32 (KERNEL32.494)
*/
UINT32 SetHandleCount32( UINT32 count )
UINT32 WINAPI SetHandleCount32( UINT32 count )
{
return MIN( 256, count );
}
@ -1103,7 +1104,7 @@ UINT32 SetHandleCount32( UINT32 count )
/***********************************************************************
* FlushFileBuffers (KERNEL32.133)
*/
BOOL32 FlushFileBuffers( HFILE32 hFile )
BOOL32 WINAPI FlushFileBuffers( HFILE32 hFile )
{
FILE_OBJECT *file;
BOOL32 ret;
@ -1124,7 +1125,7 @@ BOOL32 FlushFileBuffers( HFILE32 hFile )
/**************************************************************************
* SetEndOfFile (KERNEL32.483)
*/
BOOL32 SetEndOfFile( HFILE32 hFile )
BOOL32 WINAPI SetEndOfFile( HFILE32 hFile )
{
FILE_OBJECT *file;
BOOL32 ret = TRUE;
@ -1145,7 +1146,7 @@ BOOL32 SetEndOfFile( HFILE32 hFile )
/***********************************************************************
* DeleteFile16 (KERNEL.146)
*/
BOOL16 DeleteFile16( LPCSTR path )
BOOL16 WINAPI DeleteFile16( LPCSTR path )
{
return DeleteFile32A( path );
}
@ -1154,7 +1155,7 @@ BOOL16 DeleteFile16( LPCSTR path )
/***********************************************************************
* DeleteFile32A (KERNEL32.71)
*/
BOOL32 DeleteFile32A( LPCSTR path )
BOOL32 WINAPI DeleteFile32A( LPCSTR path )
{
DOS_FULL_NAME full_name;
const char *unixName;
@ -1181,7 +1182,7 @@ BOOL32 DeleteFile32A( LPCSTR path )
/***********************************************************************
* DeleteFile32W (KERNEL32.72)
*/
BOOL32 DeleteFile32W( LPCWSTR path )
BOOL32 WINAPI DeleteFile32W( LPCWSTR path )
{
LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
BOOL32 ret = RemoveDirectory32A( xpath );
@ -1218,13 +1219,6 @@ LPVOID FILE_mmap( FILE_OBJECT *file, LPVOID start,
if (!file)
{
/* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
#ifdef MAP_SHARED
flags &= ~MAP_SHARED;
#endif
#ifdef MAP_PRIVATE
flags |= MAP_PRIVATE;
#endif
#ifdef MAP_ANON
flags |= MAP_ANON;
#else
@ -1240,6 +1234,13 @@ LPVOID FILE_mmap( FILE_OBJECT *file, LPVOID start,
}
fd = fdzero;
#endif /* MAP_ANON */
/* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */
#ifdef MAP_SHARED
flags &= ~MAP_SHARED;
#endif
#ifdef MAP_PRIVATE
flags |= MAP_PRIVATE;
#endif
}
else fd = file->unix_handle;
@ -1250,7 +1251,7 @@ LPVOID FILE_mmap( FILE_OBJECT *file, LPVOID start,
/***********************************************************************
* GetFileType (KERNEL32.222)
*/
DWORD GetFileType( HFILE32 hFile )
DWORD WINAPI GetFileType( HFILE32 hFile )
{
FILE_OBJECT *file = FILE_GetFile(hFile);
if (!file) return FILE_TYPE_UNKNOWN; /* FIXME: correct? */
@ -1264,7 +1265,7 @@ DWORD GetFileType( HFILE32 hFile )
*
*
*/
BOOL32 MoveFileEx32A( LPCSTR fn1, LPCSTR fn2, DWORD flag )
BOOL32 WINAPI MoveFileEx32A( LPCSTR fn1, LPCSTR fn2, DWORD flag )
{
DOS_FULL_NAME full_name1, full_name2;
int mode=0; /* mode == 1: use copy */
@ -1348,7 +1349,7 @@ BOOL32 MoveFileEx32A( LPCSTR fn1, LPCSTR fn2, DWORD flag )
/**************************************************************************
* MoveFileEx32W (KERNEL32.???)
*/
BOOL32 MoveFileEx32W( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
BOOL32 WINAPI MoveFileEx32W( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
{
LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
@ -1364,7 +1365,7 @@ BOOL32 MoveFileEx32W( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
*
* Move file or directory
*/
BOOL32 MoveFile32A( LPCSTR fn1, LPCSTR fn2 )
BOOL32 WINAPI MoveFile32A( LPCSTR fn1, LPCSTR fn2 )
{
DOS_FULL_NAME full_name1, full_name2;
struct stat fstat;
@ -1408,7 +1409,7 @@ BOOL32 MoveFile32A( LPCSTR fn1, LPCSTR fn2 )
/**************************************************************************
* MoveFile32W (KERNEL32.390)
*/
BOOL32 MoveFile32W( LPCWSTR fn1, LPCWSTR fn2 )
BOOL32 WINAPI MoveFile32W( LPCWSTR fn1, LPCWSTR fn2 )
{
LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
@ -1422,7 +1423,7 @@ BOOL32 MoveFile32W( LPCWSTR fn1, LPCWSTR fn2 )
/**************************************************************************
* CopyFile32A (KERNEL32.36)
*/
BOOL32 CopyFile32A( LPCSTR source, LPCSTR dest, BOOL32 fail_if_exists )
BOOL32 WINAPI CopyFile32A( LPCSTR source, LPCSTR dest, BOOL32 fail_if_exists )
{
HFILE32 h1, h2;
BY_HANDLE_FILE_INFORMATION info;
@ -1465,7 +1466,7 @@ done:
/**************************************************************************
* CopyFile32W (KERNEL32.37)
*/
BOOL32 CopyFile32W( LPCWSTR source, LPCWSTR dest, BOOL32 fail_if_exists )
BOOL32 WINAPI CopyFile32W( LPCWSTR source, LPCWSTR dest, BOOL32 fail_if_exists)
{
LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source );
LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, dest );
@ -1479,10 +1480,10 @@ BOOL32 CopyFile32W( LPCWSTR source, LPCWSTR dest, BOOL32 fail_if_exists )
/***********************************************************************
* SetFileTime (KERNEL32.493)
*/
BOOL32 SetFileTime( HFILE32 hFile,
const FILETIME *lpCreationTime,
const FILETIME *lpLastAccessTime,
const FILETIME *lpLastWriteTime )
BOOL32 WINAPI SetFileTime( HFILE32 hFile,
const FILETIME *lpCreationTime,
const FILETIME *lpLastAccessTime,
const FILETIME *lpLastWriteTime )
{
FILE_OBJECT *file = FILE_GetFile(hFile);
struct utimbuf utimbuf;
@ -1596,7 +1597,7 @@ static BOOL32 DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
/**************************************************************************
* LockFile (KERNEL32.511)
*/
BOOL32 LockFile(
BOOL32 WINAPI LockFile(
HFILE32 hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
{
@ -1647,7 +1648,7 @@ BOOL32 LockFile(
/**************************************************************************
* UnlockFile (KERNEL32.703)
*/
BOOL32 UnlockFile(
BOOL32 WINAPI UnlockFile(
HFILE32 hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
{

74
files/profile.c
View File

@ -766,15 +766,14 @@ char* PROFILE_GetStringItem( char* start )
for (lpchX = start, lpch = NULL; *lpchX != '\0'; lpchX++ )
{
if( isspace( *lpchX ) ) lpch = lpch ? lpch : lpchX;
else lpch = NULL;
if( *lpchX == ',' )
{
if( lpch ) *lpch = '\0'; else *lpchX = '\0';
while( *(++lpchX) )
if( !isspace(*lpchX) ) return lpchX;
}
else if( isspace( *lpchX ) && !lpch ) lpch = lpchX;
else lpch = NULL;
}
if( lpch ) *lpch = '\0';
return NULL;
@ -786,7 +785,7 @@ char* PROFILE_GetStringItem( char* start )
/***********************************************************************
* GetProfileInt16 (KERNEL.57)
*/
UINT16 GetProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val )
UINT16 WINAPI GetProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val )
{
return GetPrivateProfileInt16( section, entry, def_val, "win.ini" );
}
@ -795,7 +794,7 @@ UINT16 GetProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val )
/***********************************************************************
* GetProfileInt32A (KERNEL32.264)
*/
UINT32 GetProfileInt32A( LPCSTR section, LPCSTR entry, INT32 def_val )
UINT32 WINAPI GetProfileInt32A( LPCSTR section, LPCSTR entry, INT32 def_val )
{
return GetPrivateProfileInt32A( section, entry, def_val, "win.ini" );
}
@ -803,7 +802,7 @@ UINT32 GetProfileInt32A( LPCSTR section, LPCSTR entry, INT32 def_val )
/***********************************************************************
* GetProfileInt32W (KERNEL32.264)
*/
UINT32 GetProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val )
UINT32 WINAPI GetProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val )
{
if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
return GetPrivateProfileInt32W( section, entry, def_val, wininiW );
@ -812,8 +811,8 @@ UINT32 GetProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val )
/***********************************************************************
* GetProfileString16 (KERNEL.58)
*/
INT16 GetProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
LPSTR buffer, INT16 len )
INT16 WINAPI GetProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
LPSTR buffer, INT16 len )
{
return GetPrivateProfileString16( section, entry, def_val,
buffer, len, "win.ini" );
@ -822,8 +821,8 @@ INT16 GetProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
/***********************************************************************
* GetProfileString32A (KERNEL32.268)
*/
INT32 GetProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR def_val,
LPSTR buffer, INT32 len )
INT32 WINAPI GetProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR def_val,
LPSTR buffer, INT32 len )
{
return GetPrivateProfileString32A( section, entry, def_val,
buffer, len, "win.ini" );
@ -832,8 +831,8 @@ INT32 GetProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR def_val,
/***********************************************************************
* GetProfileString32W (KERNEL32.269)
*/
INT32 GetProfileString32W( LPCWSTR section,LPCWSTR entry,LPCWSTR def_val,
LPWSTR buffer, INT32 len )
INT32 WINAPI GetProfileString32W( LPCWSTR section, LPCWSTR entry,
LPCWSTR def_val, LPWSTR buffer, INT32 len )
{
if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
return GetPrivateProfileString32W( section, entry, def_val,
@ -844,7 +843,8 @@ INT32 GetProfileString32W( LPCWSTR section,LPCWSTR entry,LPCWSTR def_val,
/***********************************************************************
* WriteProfileString16 (KERNEL.59)
*/
BOOL16 WriteProfileString16( LPCSTR section, LPCSTR entry, LPCSTR string )
BOOL16 WINAPI WriteProfileString16( LPCSTR section, LPCSTR entry,
LPCSTR string )
{
return WritePrivateProfileString16( section, entry, string, "win.ini" );
}
@ -852,7 +852,8 @@ BOOL16 WriteProfileString16( LPCSTR section, LPCSTR entry, LPCSTR string )
/***********************************************************************
* WriteProfileString32A (KERNEL32.587)
*/
BOOL32 WriteProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR string )
BOOL32 WINAPI WriteProfileString32A( LPCSTR section, LPCSTR entry,
LPCSTR string )
{
return WritePrivateProfileString32A( section, entry, string, "win.ini" );
}
@ -860,7 +861,8 @@ BOOL32 WriteProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR string )
/***********************************************************************
* WriteProfileString32W (KERNEL32.588)
*/
BOOL32 WriteProfileString32W( LPCWSTR section, LPCWSTR entry, LPCWSTR string )
BOOL32 WINAPI WriteProfileString32W( LPCWSTR section, LPCWSTR entry,
LPCWSTR string )
{
if (!wininiW) wininiW = HEAP_strdupAtoW( SystemHeap, 0, "win.ini" );
return WritePrivateProfileString32W( section, entry, string, wininiW );
@ -870,8 +872,8 @@ BOOL32 WriteProfileString32W( LPCWSTR section, LPCWSTR entry, LPCWSTR string )
/***********************************************************************
* GetPrivateProfileInt16 (KERNEL.127)
*/
UINT16 GetPrivateProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val,
LPCSTR filename )
UINT16 WINAPI GetPrivateProfileInt16( LPCSTR section, LPCSTR entry,
INT16 def_val, LPCSTR filename )
{
long result=(long)GetPrivateProfileInt32A(section,entry,def_val,filename);
@ -884,8 +886,8 @@ UINT16 GetPrivateProfileInt16( LPCSTR section, LPCSTR entry, INT16 def_val,
/***********************************************************************
* GetPrivateProfileInt32A (KERNEL32.251)
*/
UINT32 GetPrivateProfileInt32A( LPCSTR section, LPCSTR entry, INT32 def_val,
LPCSTR filename )
UINT32 WINAPI GetPrivateProfileInt32A( LPCSTR section, LPCSTR entry,
INT32 def_val, LPCSTR filename )
{
char buffer[20];
char *p;
@ -902,8 +904,8 @@ UINT32 GetPrivateProfileInt32A( LPCSTR section, LPCSTR entry, INT32 def_val,
/***********************************************************************
* GetPrivateProfileInt32W (KERNEL32.252)
*/
UINT32 GetPrivateProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val,
LPCWSTR filename )
UINT32 WINAPI GetPrivateProfileInt32W( LPCWSTR section, LPCWSTR entry,
INT32 def_val, LPCWSTR filename )
{
LPSTR sectionA = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
LPSTR entryA = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
@ -918,8 +920,9 @@ UINT32 GetPrivateProfileInt32W( LPCWSTR section, LPCWSTR entry, INT32 def_val,
/***********************************************************************
* GetPrivateProfileString16 (KERNEL.128)
*/
INT16 GetPrivateProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
LPSTR buffer, INT16 len, LPCSTR filename )
INT16 WINAPI GetPrivateProfileString16( LPCSTR section, LPCSTR entry,
LPCSTR def_val, LPSTR buffer,
INT16 len, LPCSTR filename )
{
return GetPrivateProfileString32A(section,entry,def_val,buffer,len,filename);
}
@ -927,8 +930,9 @@ INT16 GetPrivateProfileString16( LPCSTR section, LPCSTR entry, LPCSTR def_val,
/***********************************************************************
* GetPrivateProfileString32A (KERNEL32.255)
*/
INT32 GetPrivateProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR def_val,
LPSTR buffer, INT32 len, LPCSTR filename )
INT32 WINAPI GetPrivateProfileString32A( LPCSTR section, LPCSTR entry,
LPCSTR def_val, LPSTR buffer,
INT32 len, LPCSTR filename )
{
if (PROFILE_Open( filename ))
return PROFILE_GetString( section, entry, def_val, buffer, len );
@ -939,9 +943,9 @@ INT32 GetPrivateProfileString32A( LPCSTR section, LPCSTR entry, LPCSTR def_val,
/***********************************************************************
* GetPrivateProfileString32W (KERNEL32.256)
*/
INT32 GetPrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
LPCWSTR def_val, LPWSTR buffer,
INT32 len, LPCWSTR filename )
INT32 WINAPI GetPrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
LPCWSTR def_val, LPWSTR buffer,
INT32 len, LPCWSTR filename )
{
LPSTR sectionA = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
LPSTR entryA = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
@ -964,8 +968,8 @@ INT32 GetPrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
/***********************************************************************
* WritePrivateProfileString16 (KERNEL.129)
*/
BOOL16 WritePrivateProfileString16(LPCSTR section,LPCSTR entry,LPCSTR string,
LPCSTR filename)
BOOL16 WINAPI WritePrivateProfileString16( LPCSTR section, LPCSTR entry,
LPCSTR string, LPCSTR filename )
{
return WritePrivateProfileString32A(section,entry,string,filename);
}
@ -973,8 +977,8 @@ BOOL16 WritePrivateProfileString16(LPCSTR section,LPCSTR entry,LPCSTR string,
/***********************************************************************
* WritePrivateProfileString32A (KERNEL32.582)
*/
BOOL32 WritePrivateProfileString32A(LPCSTR section,LPCSTR entry,LPCSTR string,
LPCSTR filename )
BOOL32 WINAPI WritePrivateProfileString32A( LPCSTR section, LPCSTR entry,
LPCSTR string, LPCSTR filename )
{
if (!PROFILE_Open( filename )) return FALSE;
if (!section) return PROFILE_FlushFile();
@ -984,8 +988,8 @@ BOOL32 WritePrivateProfileString32A(LPCSTR section,LPCSTR entry,LPCSTR string,
/***********************************************************************
* WritePrivateProfileString32W (KERNEL32.583)
*/
BOOL32 WritePrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
LPCWSTR string, LPCWSTR filename )
BOOL32 WINAPI WritePrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
LPCWSTR string, LPCWSTR filename )
{
LPSTR sectionA = HEAP_strdupWtoA( GetProcessHeap(), 0, section );
LPSTR entryA = HEAP_strdupWtoA( GetProcessHeap(), 0, entry );
@ -1004,7 +1008,7 @@ BOOL32 WritePrivateProfileString32W( LPCWSTR section, LPCWSTR entry,
/***********************************************************************
* WriteOutProfiles (KERNEL.315)
*/
void WriteOutProfiles(void)
void WINAPI WriteOutProfiles(void)
{
PROFILE_FlushFile();
}

38
graphics/bitblt.c
View File

@ -12,8 +12,8 @@
/***********************************************************************
* PatBlt16 (GDI.29)
*/
BOOL16 PatBlt16( HDC16 hdc, INT16 left, INT16 top,
INT16 width, INT16 height, DWORD rop)
BOOL16 WINAPI PatBlt16( HDC16 hdc, INT16 left, INT16 top,
INT16 width, INT16 height, DWORD rop)
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
@ -27,8 +27,8 @@ BOOL16 PatBlt16( HDC16 hdc, INT16 left, INT16 top,
/***********************************************************************
* PatBlt32 (GDI32.260)
*/
BOOL32 PatBlt32( HDC32 hdc, INT32 left, INT32 top,
INT32 width, INT32 height, DWORD rop)
BOOL32 WINAPI PatBlt32( HDC32 hdc, INT32 left, INT32 top,
INT32 width, INT32 height, DWORD rop)
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pPatBlt) return FALSE;
@ -42,8 +42,9 @@ BOOL32 PatBlt32( HDC32 hdc, INT32 left, INT32 top,
/***********************************************************************
* BitBlt16 (GDI.34)
*/
BOOL16 BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
INT16 height, HDC16 hdcSrc, INT16 xSrc, INT16 ySrc, DWORD rop)
BOOL16 WINAPI BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
INT16 height, HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
DWORD rop )
{
DC *dcDst, *dcSrc;
@ -63,8 +64,9 @@ BOOL16 BitBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst, INT16 width,
/***********************************************************************
* BitBlt32 (GDI32.10)
*/
BOOL32 BitBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst, INT32 width,
INT32 height, HDC32 hdcSrc, INT32 xSrc, INT32 ySrc, DWORD rop)
BOOL32 WINAPI BitBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst, INT32 width,
INT32 height, HDC32 hdcSrc, INT32 xSrc, INT32 ySrc,
DWORD rop )
{
DC *dcDst, *dcSrc;
@ -84,10 +86,10 @@ BOOL32 BitBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst, INT32 width,
/***********************************************************************
* StretchBlt16 (GDI.35)
*/
BOOL16 StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
INT16 widthDst, INT16 heightDst,
HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
INT16 widthSrc, INT16 heightSrc, DWORD rop )
BOOL16 WINAPI StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
INT16 widthDst, INT16 heightDst,
HDC16 hdcSrc, INT16 xSrc, INT16 ySrc,
INT16 widthSrc, INT16 heightSrc, DWORD rop )
{
DC *dcDst, *dcSrc;
@ -109,10 +111,10 @@ BOOL16 StretchBlt16( HDC16 hdcDst, INT16 xDst, INT16 yDst,
/***********************************************************************
* StretchBlt32 (GDI32.350)
*/
BOOL32 StretchBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst,
INT32 widthDst, INT32 heightDst,
HDC32 hdcSrc, INT32 xSrc, INT32 ySrc,
INT32 widthSrc, INT32 heightSrc, DWORD rop )
BOOL32 WINAPI StretchBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst,
INT32 widthDst, INT32 heightDst,
HDC32 hdcSrc, INT32 xSrc, INT32 ySrc,
INT32 widthSrc, INT32 heightSrc, DWORD rop )
{
DC *dcDst, *dcSrc;
@ -134,8 +136,8 @@ BOOL32 StretchBlt32( HDC32 hdcDst, INT32 xDst, INT32 yDst,
/***********************************************************************
* FastWindowFrame (GDI.400)
*/
BOOL16 FastWindowFrame( HDC16 hdc, const RECT16 *rect,
INT16 width, INT16 height, DWORD rop )
BOOL16 WINAPI FastWindowFrame( HDC16 hdc, const RECT16 *rect,
INT16 width, INT16 height, DWORD rop )
{
HBRUSH32 hbrush = SelectObject32( hdc, GetStockObject32( GRAY_BRUSH ) );
PatBlt32( hdc, rect->left, rect->top,

13
graphics/escape.c
View File

@ -9,19 +9,24 @@
#include "gdi.h"
#include "dc.h"
INT16 Escape16( HDC16 hdc, INT16 nEscape, INT16 cbInput,
SEGPTR lpszInData, SEGPTR lpvOutData )
INT16 WINAPI Escape16( HDC16 hdc, INT16 nEscape, INT16 cbInput,
SEGPTR lpszInData, SEGPTR lpvOutData )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pEscape) return 0;
return dc->funcs->pEscape( dc, nEscape, cbInput, lpszInData, lpvOutData );
}
INT32 Escape32( HDC32 hdc, INT32 nEscape, INT32 cbInput,
LPVOID lpszInData, LPVOID lpvOutData )
INT32 WINAPI Escape32( HDC32 hdc, INT32 nEscape, INT32 cbInput,
LPVOID lpszInData, LPVOID lpvOutData )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc || !dc->funcs->pEscape) return 0;
switch (nEscape) {
case GETSCALINGFACTOR:
return 1;
}
return dc->funcs->pEscape( dc, nEscape, cbInput,
(SEGPTR)lpszInData, (SEGPTR)lpvOutData );
}

24
graphics/fontengine.c
View File

@ -8,23 +8,20 @@
#include "windows.h"
/* GDI 300 */
WORD
EngineEnumerateFont(LPSTR fontname, FARPROC16 proc, DWORD data )
WORD WINAPI EngineEnumerateFont(LPSTR fontname, FARPROC16 proc, DWORD data )
{
printf("In engineEnumerateFont for %s\n",(fontname)?fontname:"NULL");
return 0;
}
#ifdef NOTDEF
/* GDI 301 */
WORD
EngineDeleteFont(LPFONTINFO16 lpFontInfo)
WORD WINAPI EngineDeleteFont(LPFONTINFO16 lpFontInfo)
{
return 0
}
#endif
/* GDI 302 */
WORD
EngineRealizeFont(LPLOGFONT16 lplogFont, LPTEXTXFORM16 lptextxform, LPFONTINFO16 lpfontInfo)
WORD WINAPI EngineRealizeFont(LPLOGFONT16 lplogFont, LPTEXTXFORM16 lptextxform, LPFONTINFO16 lpfontInfo)
{
printf("In EngineRealizeFont\n");
@ -32,27 +29,23 @@ EngineRealizeFont(LPLOGFONT16 lplogFont, LPTEXTXFORM16 lptextxform, LPFONTINFO16
}
#ifdef NOTDEF
/* GDI 303 */
WORD
EngineGetCharWidth(LPFONTINFO16 lpFontInfo, BYTE, BYTE, LPINT16)
WORD WINAPI EngineGetCharWidth(LPFONTINFO16 lpFontInfo, BYTE, BYTE, LPINT16)
{
return 0;
}
/* GDI 304 */
WORD
EngineSetFontContext(LPFONTINFO lpFontInfo, WORD data)
WORD WINAPI EngineSetFontContext(LPFONTINFO lpFontInfo, WORD data)
{
}
/* GDI 305 */
WORD
EngineGetGlyphBMP(WORD word, LPFONTINFO lpFontInfo, WORD, WORD, LPSTR string, DWORD dword, LPBITMAPMETRICS16 metrics)
WORD WINAPI EngineGetGlyphBMP(WORD word, LPFONTINFO lpFontInfo, WORD, WORD, LPSTR string, DWORD dword, LPBITMAPMETRICS16 metrics)
{
return 0;
}
/* GDI 306 */
DWORD
EngineMakeFontDir(HDC16 hdc, LPFONTDIR fontdir, LPCSTR string)
DWORD WINAPI EngineMakeFontDir(HDC16 hdc, LPFONTDIR fontdir, LPCSTR string)
{
return 0;
@ -60,8 +53,7 @@ EngineMakeFontDir(HDC16 hdc, LPFONTDIR fontdir, LPCSTR string)
/* GDI 314 */
WORD
EngineExtTextOut()
WORD WINAPI EngineExtTextOut()
{
}

72
graphics/mapping.c
View File

@ -37,7 +37,7 @@ void MAPPING_FixIsotropic( DC * dc )
/***********************************************************************
* DPtoLP16 (GDI.67)
*/
BOOL16 DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
BOOL16 WINAPI DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
@ -55,7 +55,7 @@ BOOL16 DPtoLP16( HDC16 hdc, LPPOINT16 points, INT16 count )
/***********************************************************************
* DPtoLP32 (GDI32.65)
*/
BOOL32 DPtoLP32( HDC32 hdc, LPPOINT32 points, INT32 count )
BOOL32 WINAPI DPtoLP32( HDC32 hdc, LPPOINT32 points, INT32 count )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
@ -73,7 +73,7 @@ BOOL32 DPtoLP32( HDC32 hdc, LPPOINT32 points, INT32 count )
/***********************************************************************
* LPtoDP16 (GDI.99)
*/
BOOL16 LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
BOOL16 WINAPI LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
@ -91,7 +91,7 @@ BOOL16 LPtoDP16( HDC16 hdc, LPPOINT16 points, INT16 count )
/***********************************************************************
* LPtoDP32 (GDI32.247)
*/
BOOL32 LPtoDP32( HDC32 hdc, LPPOINT32 points, INT32 count )
BOOL32 WINAPI LPtoDP32( HDC32 hdc, LPPOINT32 points, INT32 count )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
@ -109,7 +109,7 @@ BOOL32 LPtoDP32( HDC32 hdc, LPPOINT32 points, INT32 count )
/***********************************************************************
* SetMapMode16 (GDI.3)
*/
INT16 SetMapMode16( HDC16 hdc, INT16 mode )
INT16 WINAPI SetMapMode16( HDC16 hdc, INT16 mode )
{
return SetMapMode32( hdc, mode );
}
@ -118,7 +118,7 @@ INT16 SetMapMode16( HDC16 hdc, INT16 mode )
/***********************************************************************
* SetMapMode32 (GDI32.321)
*/
INT32 SetMapMode32( HDC32 hdc, INT32 mode )
INT32 WINAPI SetMapMode32( HDC32 hdc, INT32 mode )
{
INT32 prevMode;
DC * dc = DC_GetDCPtr( hdc );
@ -199,7 +199,7 @@ INT32 SetMapMode32( HDC32 hdc, INT32 mode )
/***********************************************************************
* SetViewportExt (GDI.14)
*/
DWORD SetViewportExt( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI SetViewportExt( HDC16 hdc, INT16 x, INT16 y )
{
SIZE32 size;
if (!SetViewportExtEx32( hdc, x, y, &size )) return 0;
@ -210,7 +210,7 @@ DWORD SetViewportExt( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* SetViewportExtEx16 (GDI.479)
*/
BOOL16 SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
BOOL16 WINAPI SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
{
SIZE32 size32;
BOOL16 ret = SetViewportExtEx32( hdc, x, y, &size32 );
@ -222,7 +222,7 @@ BOOL16 SetViewportExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
/***********************************************************************
* SetViewportExtEx32 (GDI32.340)
*/
BOOL32 SetViewportExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
BOOL32 WINAPI SetViewportExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -246,7 +246,7 @@ BOOL32 SetViewportExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
/***********************************************************************
* SetViewportOrg (GDI.13)
*/
DWORD SetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI SetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
{
POINT32 pt;
if (!SetViewportOrgEx32( hdc, x, y, &pt )) return 0;
@ -257,7 +257,7 @@ DWORD SetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* SetViewportOrgEx16 (GDI.480)
*/
BOOL16 SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
BOOL16 WINAPI SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
{
POINT32 pt32;
BOOL16 ret = SetViewportOrgEx32( hdc, x, y, &pt32 );
@ -269,7 +269,7 @@ BOOL16 SetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
/***********************************************************************
* SetViewportOrgEx32 (GDI32.341)
*/
BOOL32 SetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
BOOL32 WINAPI SetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -289,7 +289,7 @@ BOOL32 SetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
/***********************************************************************
* SetWindowExt (GDI.12)
*/
DWORD SetWindowExt( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI SetWindowExt( HDC16 hdc, INT16 x, INT16 y )
{
SIZE32 size;
if (!SetWindowExtEx32( hdc, x, y, &size )) return 0;
@ -300,7 +300,7 @@ DWORD SetWindowExt( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* SetWindowExtEx16 (GDI.481)
*/
BOOL16 SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
BOOL16 WINAPI SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
{
SIZE32 size32;
BOOL16 ret = SetWindowExtEx32( hdc, x, y, &size32 );
@ -312,7 +312,7 @@ BOOL16 SetWindowExtEx16( HDC16 hdc, INT16 x, INT16 y, LPSIZE16 size )
/***********************************************************************
* SetWindowExtEx32 (GDI32.344)
*/
BOOL32 SetWindowExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
BOOL32 WINAPI SetWindowExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -335,7 +335,7 @@ BOOL32 SetWindowExtEx32( HDC32 hdc, INT32 x, INT32 y, LPSIZE32 size )
/***********************************************************************
* SetWindowOrg (GDI.11)
*/
DWORD SetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI SetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
{
POINT32 pt;
if (!SetWindowOrgEx32( hdc, x, y, &pt )) return 0;
@ -346,7 +346,7 @@ DWORD SetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* SetWindowOrgEx16 (GDI.482)
*/
BOOL16 SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
BOOL16 WINAPI SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
{
POINT32 pt32;
BOOL16 ret = SetWindowOrgEx32( hdc, x, y, &pt32 );
@ -358,7 +358,7 @@ BOOL16 SetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
/***********************************************************************
* SetWindowOrgEx32 (GDI32.345)
*/
BOOL32 SetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
BOOL32 WINAPI SetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -377,7 +377,7 @@ BOOL32 SetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
/***********************************************************************
* OffsetViewportOrg (GDI.17)
*/
DWORD OffsetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI OffsetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
{
POINT32 pt;
if (!OffsetViewportOrgEx32( hdc, x, y, &pt )) return 0;
@ -388,7 +388,7 @@ DWORD OffsetViewportOrg( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* OffsetViewportOrgEx16 (GDI.476)
*/
BOOL16 OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
BOOL16 WINAPI OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt)
{
POINT32 pt32;
BOOL16 ret = OffsetViewportOrgEx32( hdc, x, y, &pt32 );
@ -400,7 +400,7 @@ BOOL16 OffsetViewportOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
/***********************************************************************
* OffsetViewportOrgEx32 (GDI32.257)
*/
BOOL32 OffsetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
BOOL32 WINAPI OffsetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt)
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -420,7 +420,7 @@ BOOL32 OffsetViewportOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
/***********************************************************************
* OffsetWindowOrg (GDI.15)
*/
DWORD OffsetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI OffsetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
{
POINT32 pt;
if (!OffsetWindowOrgEx32( hdc, x, y, &pt )) return 0;
@ -431,7 +431,7 @@ DWORD OffsetWindowOrg( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* OffsetWindowOrgEx16 (GDI.477)
*/
BOOL16 OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
BOOL16 WINAPI OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
{
POINT32 pt32;
BOOL16 ret = OffsetWindowOrgEx32( hdc, x, y, &pt32 );
@ -443,7 +443,7 @@ BOOL16 OffsetWindowOrgEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
/***********************************************************************
* OffsetWindowOrgEx32 (GDI32.258)
*/
BOOL32 OffsetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
BOOL32 WINAPI OffsetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -463,8 +463,8 @@ BOOL32 OffsetWindowOrgEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
/***********************************************************************
* ScaleViewportExt (GDI.18)
*/
DWORD ScaleViewportExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom )
DWORD WINAPI ScaleViewportExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom )
{
SIZE32 size;
if (!ScaleViewportExtEx32( hdc, xNum, xDenom, yNum, yDenom, &size ))
@ -476,8 +476,8 @@ DWORD ScaleViewportExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
/***********************************************************************
* ScaleViewportExtEx16 (GDI.484)
*/
BOOL16 ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom, LPSIZE16 size )
BOOL16 WINAPI ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom, LPSIZE16 size )
{
SIZE32 size32;
BOOL16 ret = ScaleViewportExtEx32( hdc, xNum, xDenom, yNum, yDenom,
@ -490,8 +490,8 @@ BOOL16 ScaleViewportExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
/***********************************************************************
* ScaleViewportExtEx32 (GDI32.293)
*/
BOOL32 ScaleViewportExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
INT32 yNum, INT32 yDenom, LPSIZE32 size )
BOOL32 WINAPI ScaleViewportExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
INT32 yNum, INT32 yDenom, LPSIZE32 size )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;
@ -517,8 +517,8 @@ BOOL32 ScaleViewportExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
/***********************************************************************
* ScaleWindowExt (GDI.16)
*/
DWORD ScaleWindowExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom )
DWORD WINAPI ScaleWindowExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom )
{
SIZE32 size;
if (!ScaleWindowExtEx32( hdc, xNum, xDenom, yNum, yDenom, &size ))
@ -530,8 +530,8 @@ DWORD ScaleWindowExt( HDC16 hdc, INT16 xNum, INT16 xDenom,
/***********************************************************************
* ScaleWindowExtEx16 (GDI.485)
*/
BOOL16 ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom, LPSIZE16 size )
BOOL16 WINAPI ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
INT16 yNum, INT16 yDenom, LPSIZE16 size )
{
SIZE32 size32;
BOOL16 ret = ScaleWindowExtEx32( hdc, xNum, xDenom, yNum, yDenom,
@ -544,8 +544,8 @@ BOOL16 ScaleWindowExtEx16( HDC16 hdc, INT16 xNum, INT16 xDenom,
/***********************************************************************
* ScaleWindowExtEx32 (GDI32.294)
*/
BOOL32 ScaleWindowExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
INT32 yNum, INT32 yDenom, LPSIZE32 size )
BOOL32 WINAPI ScaleWindowExtEx32( HDC32 hdc, INT32 xNum, INT32 xDenom,
INT32 yNum, INT32 yDenom, LPSIZE32 size )
{
DC * dc = DC_GetDCPtr( hdc );
if (!dc) return FALSE;

6
graphics/metafiledrv/init.c
View File

@ -138,7 +138,7 @@ static BOOL32 MFDRV_DeleteDC( DC *dc )
/**********************************************************************
* CreateMetafile16 (GDI.125)
*/
HDC16 CreateMetaFile16( LPCSTR filename )
HDC16 WINAPI CreateMetaFile16( LPCSTR filename )
{
DC *dc;
METAFILEDRV_PDEVICE *physDev;
@ -177,7 +177,7 @@ HDC16 CreateMetaFile16( LPCSTR filename )
/******************************************************************
* CloseMetafile16 (GDI.126)
*/
HMETAFILE16 CloseMetaFile16( HDC16 hdc )
HMETAFILE16 WINAPI CloseMetaFile16( HDC16 hdc )
{
DC *dc;
HMETAFILE16 hmf;
@ -231,7 +231,7 @@ HMETAFILE16 CloseMetaFile16( HDC16 hdc )
/******************************************************************
* DeleteMetafile16 (GDI.127)
*/
BOOL16 DeleteMetaFile16( HMETAFILE16 hmf )
BOOL16 WINAPI DeleteMetaFile16( HMETAFILE16 hmf )
{
return !GlobalFree16( hmf );
}

19
graphics/metafiledrv/objects.c
View File

@ -83,6 +83,7 @@ static HPEN32 MFDRV_PEN_SelectObject( DC * dc, HPEN32 hpen, PENOBJ * pen )
HGDIOBJ32 MFDRV_SelectObject( DC *dc, HGDIOBJ32 handle )
{
GDIOBJHDR * ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
HGDIOBJ32 ret = 0;
if (!ptr) return 0;
dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", dc->hSelf, handle );
@ -90,15 +91,21 @@ HGDIOBJ32 MFDRV_SelectObject( DC *dc, HGDIOBJ32 handle )
switch(ptr->wMagic)
{
case PEN_MAGIC:
return MFDRV_PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
ret = MFDRV_PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
break;
case BRUSH_MAGIC:
return MFDRV_BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
ret = MFDRV_BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
break;
case BITMAP_MAGIC:
return MFDRV_BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
ret = MFDRV_BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
break;
case FONT_MAGIC:
return MFDRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
ret = MFDRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
break;
case REGION_MAGIC:
return (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
break;
}
return 0;
GDI_HEAP_UNLOCK( handle );
return ret;
}

156
graphics/painting.c
View File

@ -29,7 +29,7 @@
/***********************************************************************
* LineTo16 (GDI.19)
*/
BOOL16 LineTo16( HDC16 hdc, INT16 x, INT16 y )
BOOL16 WINAPI LineTo16( HDC16 hdc, INT16 x, INT16 y )
{
return LineTo32( hdc, x, y );
}
@ -38,7 +38,7 @@ BOOL16 LineTo16( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* LineTo32 (GDI32.249)
*/
BOOL32 LineTo32( HDC32 hdc, INT32 x, INT32 y )
BOOL32 WINAPI LineTo32( HDC32 hdc, INT32 x, INT32 y )
{
DC * dc = DC_GetDCPtr( hdc );
@ -50,7 +50,7 @@ BOOL32 LineTo32( HDC32 hdc, INT32 x, INT32 y )
/***********************************************************************
* MoveTo (GDI.20)
*/
DWORD MoveTo( HDC16 hdc, INT16 x, INT16 y )
DWORD WINAPI MoveTo( HDC16 hdc, INT16 x, INT16 y )
{
POINT16 pt;
@ -63,7 +63,7 @@ DWORD MoveTo( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* MoveToEx16 (GDI.483)
*/
BOOL16 MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
BOOL16 WINAPI MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
{
POINT32 pt32;
@ -77,7 +77,7 @@ BOOL16 MoveToEx16( HDC16 hdc, INT16 x, INT16 y, LPPOINT16 pt )
/***********************************************************************
* MoveToEx32 (GDI32.254)
*/
BOOL32 MoveToEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
BOOL32 WINAPI MoveToEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
{
DC * dc = DC_GetDCPtr( hdc );
@ -89,8 +89,9 @@ BOOL32 MoveToEx32( HDC32 hdc, INT32 x, INT32 y, LPPOINT32 pt )
/***********************************************************************
* Arc16 (GDI.23)
*/
BOOL16 Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom,
INT16 xstart, INT16 ystart, INT16 xend, INT16 yend )
BOOL16 WINAPI Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
INT16 bottom, INT16 xstart, INT16 ystart,
INT16 xend, INT16 yend )
{
return Arc32( (HDC32)hdc, (INT32)left, (INT32)top, (INT32)right,
(INT32)bottom, (INT32)xstart, (INT32)ystart, (INT32)xend,
@ -101,8 +102,9 @@ BOOL16 Arc16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom,
/***********************************************************************
* Arc32 (GDI32.7)
*/
BOOL32 Arc32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom,
INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
BOOL32 WINAPI Arc32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
INT32 bottom, INT32 xstart, INT32 ystart,
INT32 xend, INT32 yend )
{
DC * dc = DC_GetDCPtr( hdc );
@ -114,8 +116,9 @@ BOOL32 Arc32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom,
/***********************************************************************
* Pie16 (GDI.26)
*/
BOOL16 Pie16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom,
INT16 xstart, INT16 ystart, INT16 xend, INT16 yend )
BOOL16 WINAPI Pie16( HDC16 hdc, INT16 left, INT16 top,
INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
INT16 xend, INT16 yend )
{
return Pie32( (HDC32)hdc, (INT32)left, (INT32)top, (INT32)right,
(INT32)bottom, (INT32)xstart, (INT32)ystart, (INT32)xend,
@ -126,8 +129,9 @@ BOOL16 Pie16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom,
/***********************************************************************
* Pie32 (GDI32.262)
*/
BOOL32 Pie32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom,
INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
BOOL32 WINAPI Pie32( HDC32 hdc, INT32 left, INT32 top,
INT32 right, INT32 bottom, INT32 xstart, INT32 ystart,
INT32 xend, INT32 yend )
{
DC * dc = DC_GetDCPtr( hdc );
@ -139,8 +143,9 @@ BOOL32 Pie32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom,
/***********************************************************************
* Chord16 (GDI.348)
*/
BOOL16 Chord16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom,
INT16 xstart, INT16 ystart, INT16 xend, INT16 yend )
BOOL16 WINAPI Chord16( HDC16 hdc, INT16 left, INT16 top,
INT16 right, INT16 bottom, INT16 xstart, INT16 ystart,
INT16 xend, INT16 yend )
{
return Chord32( hdc, left, top, right, bottom, xstart, ystart, xend, yend );
}
@ -149,8 +154,9 @@ BOOL16 Chord16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom,
/***********************************************************************
* Chord32 (GDI32.14)
*/
BOOL32 Chord32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom,
INT32 xstart, INT32 ystart, INT32 xend, INT32 yend )
BOOL32 WINAPI Chord32( HDC32 hdc, INT32 left, INT32 top,
INT32 right, INT32 bottom, INT32 xstart, INT32 ystart,
INT32 xend, INT32 yend )
{
DC * dc = DC_GetDCPtr( hdc );
@ -162,7 +168,8 @@ BOOL32 Chord32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom,
/***********************************************************************
* Ellipse16 (GDI.24)
*/
BOOL16 Ellipse16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom )
BOOL16 WINAPI Ellipse16( HDC16 hdc, INT16 left, INT16 top,
INT16 right, INT16 bottom )
{
return Ellipse32( hdc, left, top, right, bottom );
}
@ -171,7 +178,8 @@ BOOL16 Ellipse16( HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom )
/***********************************************************************
* Ellipse32 (GDI32.75)
*/
BOOL32 Ellipse32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom )
BOOL32 WINAPI Ellipse32( HDC32 hdc, INT32 left, INT32 top,
INT32 right, INT32 bottom )
{
DC * dc = DC_GetDCPtr( hdc );
@ -183,7 +191,8 @@ BOOL32 Ellipse32( HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom )
/***********************************************************************
* Rectangle16 (GDI.27)
*/
BOOL16 Rectangle16(HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom)
BOOL16 WINAPI Rectangle16( HDC16 hdc, INT16 left, INT16 top,
INT16 right, INT16 bottom )
{
return Rectangle32( hdc, left, top, right, bottom );
}
@ -192,7 +201,8 @@ BOOL16 Rectangle16(HDC16 hdc, INT16 left, INT16 top, INT16 right, INT16 bottom)
/***********************************************************************
* Rectangle32 (GDI32.283)
*/
BOOL32 Rectangle32(HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom)
BOOL32 WINAPI Rectangle32( HDC32 hdc, INT32 left, INT32 top,
INT32 right, INT32 bottom )
{
DC * dc = DC_GetDCPtr( hdc );
@ -204,8 +214,8 @@ BOOL32 Rectangle32(HDC32 hdc, INT32 left, INT32 top, INT32 right, INT32 bottom)
/***********************************************************************
* RoundRect16 (GDI.28)
*/
BOOL16 RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
INT16 bottom, INT16 ell_width, INT16 ell_height )
BOOL16 WINAPI RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
INT16 bottom, INT16 ell_width, INT16 ell_height )
{
return RoundRect32( hdc, left, top, right, bottom, ell_width, ell_height );
}
@ -214,8 +224,8 @@ BOOL16 RoundRect16( HDC16 hdc, INT16 left, INT16 top, INT16 right,
/***********************************************************************
* RoundRect32 (GDI32.291)
*/
BOOL32 RoundRect32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
INT32 bottom, INT32 ell_width, INT32 ell_height )
BOOL32 WINAPI RoundRect32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
INT32 bottom, INT32 ell_width, INT32 ell_height )
{
DC * dc = DC_GetDCPtr( hdc );
@ -227,7 +237,7 @@ BOOL32 RoundRect32( HDC32 hdc, INT32 left, INT32 top, INT32 right,
/***********************************************************************
* FillRect16 (USER.81)
*/
INT16 FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
INT16 WINAPI FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
{
HBRUSH16 prevBrush;
@ -246,7 +256,7 @@ INT16 FillRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
/***********************************************************************
* FillRect32 (USER32.196)
*/
INT32 FillRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
INT32 WINAPI FillRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
{
HBRUSH32 prevBrush;
@ -261,7 +271,7 @@ INT32 FillRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
/***********************************************************************
* InvertRect16 (USER.82)
*/
void InvertRect16( HDC16 hdc, const RECT16 *rect )
void WINAPI InvertRect16( HDC16 hdc, const RECT16 *rect )
{
PatBlt32( hdc, rect->left, rect->top,
rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
@ -271,7 +281,7 @@ void InvertRect16( HDC16 hdc, const RECT16 *rect )
/***********************************************************************
* InvertRect32 (USER32.329)
*/
void InvertRect32( HDC32 hdc, const RECT32 *rect )
void WINAPI InvertRect32( HDC32 hdc, const RECT32 *rect )
{
PatBlt32( hdc, rect->left, rect->top,
rect->right - rect->left, rect->bottom - rect->top, DSTINVERT );
@ -281,7 +291,7 @@ void InvertRect32( HDC32 hdc, const RECT32 *rect )
/***********************************************************************
* FrameRect16 (USER.83)
*/
INT16 FrameRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
INT16 WINAPI FrameRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
{
HBRUSH16 prevBrush;
int left, top, right, bottom;
@ -316,7 +326,7 @@ INT16 FrameRect16( HDC16 hdc, const RECT16 *rect, HBRUSH16 hbrush )
/***********************************************************************
* FrameRect32 (USER32.202)
*/
INT32 FrameRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
INT32 WINAPI FrameRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
{
RECT16 rect16;
CONV_RECT32TO16( rect, &rect16 );
@ -327,7 +337,7 @@ INT32 FrameRect32( HDC32 hdc, const RECT32 *rect, HBRUSH32 hbrush )
/***********************************************************************
* SetPixel16 (GDI.31)
*/
COLORREF SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
COLORREF WINAPI SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
{
return SetPixel32( hdc, x, y, color );
}
@ -336,7 +346,7 @@ COLORREF SetPixel16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
/***********************************************************************
* SetPixel32 (GDI32.327)
*/
COLORREF SetPixel32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
COLORREF WINAPI SetPixel32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
{
DC * dc = DC_GetDCPtr( hdc );
@ -348,7 +358,7 @@ COLORREF SetPixel32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
/***********************************************************************
* GetPixel16 (GDI.83)
*/
COLORREF GetPixel16( HDC16 hdc, INT16 x, INT16 y )
COLORREF WINAPI GetPixel16( HDC16 hdc, INT16 x, INT16 y )
{
return GetPixel32( hdc, x, y );
}
@ -357,7 +367,7 @@ COLORREF GetPixel16( HDC16 hdc, INT16 x, INT16 y )
/***********************************************************************
* GetPixel32 (GDI32.211)
*/
COLORREF GetPixel32( HDC32 hdc, INT32 x, INT32 y )
COLORREF WINAPI GetPixel32( HDC32 hdc, INT32 x, INT32 y )
{
DC * dc = DC_GetDCPtr( hdc );
@ -376,7 +386,7 @@ COLORREF GetPixel32( HDC32 hdc, INT32 x, INT32 y )
/***********************************************************************
* PaintRgn16 (GDI.43)
*/
BOOL16 PaintRgn16( HDC16 hdc, HRGN16 hrgn )
BOOL16 WINAPI PaintRgn16( HDC16 hdc, HRGN16 hrgn )
{
return PaintRgn32( hdc, hrgn );
}
@ -385,7 +395,7 @@ BOOL16 PaintRgn16( HDC16 hdc, HRGN16 hrgn )
/***********************************************************************
* PaintRgn32 (GDI32.259)
*/
BOOL32 PaintRgn32( HDC32 hdc, HRGN32 hrgn )
BOOL32 WINAPI PaintRgn32( HDC32 hdc, HRGN32 hrgn )
{
DC * dc = DC_GetDCPtr( hdc );
@ -397,7 +407,7 @@ BOOL32 PaintRgn32( HDC32 hdc, HRGN32 hrgn )
/***********************************************************************
* FillRgn16 (GDI.40)
*/
BOOL16 FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
BOOL16 WINAPI FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
{
return FillRgn32( hdc, hrgn, hbrush );
}
@ -406,7 +416,7 @@ BOOL16 FillRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush )
/***********************************************************************
* FillRgn32 (GDI32.101)
*/
BOOL32 FillRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush )
BOOL32 WINAPI FillRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush )
{
BOOL32 retval;
HBRUSH32 prevBrush = SelectObject32( hdc, hbrush );
@ -420,8 +430,8 @@ BOOL32 FillRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush )
/***********************************************************************
* FrameRgn16 (GDI.41)
*/
BOOL16 FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
INT16 nWidth, INT16 nHeight )
BOOL16 WINAPI FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
INT16 nWidth, INT16 nHeight )
{
return FrameRgn32( hdc, hrgn, hbrush, nWidth, nHeight );
}
@ -430,8 +440,8 @@ BOOL16 FrameRgn16( HDC16 hdc, HRGN16 hrgn, HBRUSH16 hbrush,
/***********************************************************************
* FrameRgn32 (GDI32.105)
*/
BOOL32 FrameRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush,
INT32 nWidth, INT32 nHeight )
BOOL32 WINAPI FrameRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush,
INT32 nWidth, INT32 nHeight )
{
HRGN32 tmp = CreateRectRgn32( 0, 0, 0, 0 );
if(!REGION_FrameRgn( tmp, hrgn, nWidth, nHeight )) return FALSE;
@ -444,7 +454,7 @@ BOOL32 FrameRgn32( HDC32 hdc, HRGN32 hrgn, HBRUSH32 hbrush,
/***********************************************************************
* InvertRgn16 (GDI.42)
*/
BOOL16 InvertRgn16( HDC16 hdc, HRGN16 hrgn )
BOOL16 WINAPI InvertRgn16( HDC16 hdc, HRGN16 hrgn )
{
return InvertRgn32( hdc, hrgn );
}
@ -453,7 +463,7 @@ BOOL16 InvertRgn16( HDC16 hdc, HRGN16 hrgn )
/***********************************************************************
* InvertRgn32 (GDI32.246)
*/
BOOL32 InvertRgn32( HDC32 hdc, HRGN32 hrgn )
BOOL32 WINAPI InvertRgn32( HDC32 hdc, HRGN32 hrgn )
{
HBRUSH32 prevBrush = SelectObject32( hdc, GetStockObject32(BLACK_BRUSH) );
INT32 prevROP = SetROP232( hdc, R2_NOT );
@ -467,7 +477,7 @@ BOOL32 InvertRgn32( HDC32 hdc, HRGN32 hrgn )
/***********************************************************************
* DrawFocusRect16 (USER.466)
*/
void DrawFocusRect16( HDC16 hdc, const RECT16* rc )
void WINAPI DrawFocusRect16( HDC16 hdc, const RECT16* rc )
{
RECT32 rect32;
CONV_RECT16TO32( rc, &rect32 );
@ -480,7 +490,7 @@ void DrawFocusRect16( HDC16 hdc, const RECT16* rc )
*
* FIXME: PatBlt(PATINVERT) with background brush.
*/
void DrawFocusRect32( HDC32 hdc, const RECT32* rc )
void WINAPI DrawFocusRect32( HDC32 hdc, const RECT32* rc )
{
HPEN32 hOldPen;
INT32 oldDrawMode, oldBkMode;
@ -515,7 +525,7 @@ void DrawFocusRect32( HDC32 hdc, const RECT32* rc )
/**********************************************************************
* Polyline16 (GDI.37)
*/
BOOL16 Polyline16( HDC16 hdc, LPPOINT16 pt, INT16 count )
BOOL16 WINAPI Polyline16( HDC16 hdc, LPPOINT16 pt, INT16 count )
{
register int i;
LPPOINT32 pt32 = (LPPOINT32)xmalloc(count*sizeof(POINT32));
@ -531,7 +541,7 @@ BOOL16 Polyline16( HDC16 hdc, LPPOINT16 pt, INT16 count )
/**********************************************************************
* Polyline32 (GDI32.276)
*/
BOOL32 Polyline32( HDC32 hdc, const LPPOINT32 pt, INT32 count )
BOOL32 WINAPI Polyline32( HDC32 hdc, const LPPOINT32 pt, INT32 count )
{
DC * dc = DC_GetDCPtr( hdc );
@ -543,7 +553,7 @@ BOOL32 Polyline32( HDC32 hdc, const LPPOINT32 pt, INT32 count )
/**********************************************************************
* Polygon16 (GDI.36)
*/
BOOL16 Polygon16( HDC16 hdc, LPPOINT16 pt, INT16 count )
BOOL16 WINAPI Polygon16( HDC16 hdc, LPPOINT16 pt, INT16 count )
{
register int i;
LPPOINT32 pt32 = (LPPOINT32)xmalloc(count*sizeof(POINT32));
@ -560,7 +570,7 @@ BOOL16 Polygon16( HDC16 hdc, LPPOINT16 pt, INT16 count )
/**********************************************************************
* Polygon32 (GDI32.275)
*/
BOOL32 Polygon32( HDC32 hdc, LPPOINT32 pt, INT32 count )
BOOL32 WINAPI Polygon32( HDC32 hdc, LPPOINT32 pt, INT32 count )
{
DC * dc = DC_GetDCPtr( hdc );
@ -572,7 +582,8 @@ BOOL32 Polygon32( HDC32 hdc, LPPOINT32 pt, INT32 count )
/**********************************************************************
* PolyPolygon16 (GDI.450)
*/
BOOL16 PolyPolygon16( HDC16 hdc, LPPOINT16 pt, LPINT16 counts, UINT16 polygons)
BOOL16 WINAPI PolyPolygon16( HDC16 hdc, LPPOINT16 pt, LPINT16 counts,
UINT16 polygons )
{
int i,nrpts;
LPPOINT32 pt32;
@ -597,7 +608,8 @@ BOOL16 PolyPolygon16( HDC16 hdc, LPPOINT16 pt, LPINT16 counts, UINT16 polygons)
/**********************************************************************
* PolyPolygon32 (GDI.450)
*/
BOOL32 PolyPolygon32( HDC32 hdc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
BOOL32 WINAPI PolyPolygon32( HDC32 hdc, LPPOINT32 pt, LPINT32 counts,
UINT32 polygons )
{
DC * dc = DC_GetDCPtr( hdc );
@ -608,8 +620,8 @@ BOOL32 PolyPolygon32( HDC32 hdc, LPPOINT32 pt, LPINT32 counts, UINT32 polygons)
/**********************************************************************
* ExtFloodFill16 (GDI.372)
*/
BOOL16 ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
UINT16 fillType )
BOOL16 WINAPI ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
UINT16 fillType )
{
return ExtFloodFill32( hdc, x, y, color, fillType );
}
@ -618,8 +630,8 @@ BOOL16 ExtFloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color,
/**********************************************************************
* ExtFloodFill32 (GDI32.96)
*/
BOOL32 ExtFloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color,
UINT32 fillType )
BOOL32 WINAPI ExtFloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color,
UINT32 fillType )
{
DC *dc = DC_GetDCPtr( hdc );
@ -631,7 +643,7 @@ BOOL32 ExtFloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color,
/**********************************************************************
* FloodFill16 (GDI.25)
*/
BOOL16 FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
BOOL16 WINAPI FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
{
return ExtFloodFill32( hdc, x, y, color, FLOODFILLBORDER );
}
@ -640,7 +652,7 @@ BOOL16 FloodFill16( HDC16 hdc, INT16 x, INT16 y, COLORREF color )
/**********************************************************************
* FloodFill32 (GDI32.104)
*/
BOOL32 FloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
BOOL32 WINAPI FloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
{
return ExtFloodFill32( hdc, x, y, color, FLOODFILLBORDER );
}
@ -649,7 +661,7 @@ BOOL32 FloodFill32( HDC32 hdc, INT32 x, INT32 y, COLORREF color )
/**********************************************************************
* DrawEdge16 (USER.659)
*/
BOOL16 DrawEdge16( HDC16 hdc, LPRECT16 rc, UINT16 edge, UINT16 flags )
BOOL16 WINAPI DrawEdge16( HDC16 hdc, LPRECT16 rc, UINT16 edge, UINT16 flags )
{
RECT32 rect32;
BOOL32 ret;
@ -664,7 +676,7 @@ BOOL16 DrawEdge16( HDC16 hdc, LPRECT16 rc, UINT16 edge, UINT16 flags )
/**********************************************************************
* DrawEdge32 (USER32.154)
*/
BOOL32 DrawEdge32( HDC32 hdc, LPRECT32 rc, UINT32 edge, UINT32 flags )
BOOL32 WINAPI DrawEdge32( HDC32 hdc, LPRECT32 rc, UINT32 edge, UINT32 flags )
{
HBRUSH32 hbrushOld;
@ -747,7 +759,8 @@ BOOL32 DrawEdge32( HDC32 hdc, LPRECT32 rc, UINT32 edge, UINT32 flags )
/**********************************************************************
* DrawFrameControl16 (USER.656)
*/
BOOL16 DrawFrameControl16( HDC16 hdc, LPRECT16 rc, UINT16 uType, UINT16 uState )
BOOL16 WINAPI DrawFrameControl16( HDC16 hdc, LPRECT16 rc, UINT16 uType,
UINT16 uState )
{
fprintf( stdnimp,"DrawFrameControl16(%x,%p,%d,%x), empty stub!\n",
hdc,rc,uType,uState );
@ -758,7 +771,8 @@ BOOL16 DrawFrameControl16( HDC16 hdc, LPRECT16 rc, UINT16 uType, UINT16 uState )
/**********************************************************************
* DrawFrameControl32 (USER32.157)
*/
BOOL32 DrawFrameControl32( HDC32 hdc, LPRECT32 rc, UINT32 uType, UINT32 uState )
BOOL32 WINAPI DrawFrameControl32( HDC32 hdc, LPRECT32 rc, UINT32 uType,
UINT32 uState )
{
fprintf( stdnimp,"DrawFrameControl32(%x,%p,%d,%x), empty stub!\n",
hdc,rc,uType,uState );
@ -768,10 +782,22 @@ BOOL32 DrawFrameControl32( HDC32 hdc, LPRECT32 rc, UINT32 uType, UINT32 uState )
/**********************************************************************
* DrawFrameControl32 (USER32.152)
*/
BOOL32 DrawAnimatedRects32( HWND32 hwnd, int idAni,
const LPRECT32 lprcFrom, const LPRECT32 lprcTo )
BOOL32 WINAPI DrawAnimatedRects32( HWND32 hwnd, int idAni,
const LPRECT32 lprcFrom,
const LPRECT32 lprcTo )
{
fprintf( stdnimp,"DrawAnimatedRects32(%x,%d,%p,%p), empty stub!\n",
hwnd, idAni, lprcFrom, lprcTo );
return TRUE;
}
BOOL32 WINAPI DrawState32A(
HDC32 hdc,HBRUSH32 hbrush,DRAWSTATEPROC drawstateproc,
LPARAM lparam,WPARAM32 wparam,INT32 x,INT32 y,INT32 z,INT32 a,UINT32 b
) {
fprintf(stderr,"DrawStateA(%x,%x,%p,0x%08lx,0x%08lx,%d,%d,%d,%d,%d),stub\n",
hdc,hbrush,drawstateproc,lparam,wparam,x,y,z,a,b
);
return TRUE;
}

45
graphics/win16drv/init.c
View File

@ -173,8 +173,9 @@ void InitDrawMode(LPDRAWMODE lpDrawMode)
* 1) Just count the number of fonts available.
* 2) Store all font data passed.
*/
WORD WineEnumDFontCallback(LPLOGFONT16 lpLogFont, LPTEXTMETRIC16 lpTextMetrics,
WORD wFontType, LONG lpvClientData)
WORD WINAPI WineEnumDFontCallback(LPLOGFONT16 lpLogFont,
LPTEXTMETRIC16 lpTextMetrics,
WORD wFontType, LONG lpvClientData)
{
int wRet = 0;
WEPFC *pWEPFC = (WEPFC *)lpvClientData;
@ -325,6 +326,12 @@ BOOL32 WIN16DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device, LPCSTR output,
(void *)&wepfc);
numFonts = wepfc.nCount;
}
else
{
/* If the number of fonts returned are zero we can not continue */
fprintf( stderr, "No fonts? Aborting CreateDC...\n");
return FALSE;
}
}
}
@ -476,20 +483,17 @@ struct hpq
static struct hpq *hpqueue;
HPQ
CreatePQ(int size)
HPQ WINAPI CreatePQ(int size)
{
printf("CreatePQ: %d\n",size);
return 1;
}
int
DeletePQ(HPQ hPQ)
int WINAPI DeletePQ(HPQ hPQ)
{
printf("DeletePQ: %x\n", hPQ);
return 0;
}
int
ExtractPQ(HPQ hPQ)
int WINAPI ExtractPQ(HPQ hPQ)
{
struct hpq *queue, *prev, *current, *currentPrev;
int key = 0, tag = -1;
@ -527,8 +531,7 @@ ExtractPQ(HPQ hPQ)
return tag;
}
int
InsertPQ(HPQ hPQ, int tag, int key)
int WINAPI InsertPQ(HPQ hPQ, int tag, int key)
{
struct hpq *queueItem = malloc(sizeof(struct hpq));
queueItem->next = hpqueue;
@ -539,14 +542,12 @@ InsertPQ(HPQ hPQ, int tag, int key)
printf("InsertPQ: %x %d %d\n", hPQ, tag, key);
return TRUE;
}
int
MinPQ(HPQ hPQ)
int WINAPI MinPQ(HPQ hPQ)
{
printf("MinPQ: %x\n", hPQ);
return 0;
}
int
SizePQ(HPQ hPQ, int sizechange)
int WINAPI SizePQ(HPQ hPQ, int sizechange)
{
printf("SizePQ: %x %d\n", hPQ, sizechange);
return -1;
@ -656,7 +657,7 @@ static int FreePrintJob(HANDLE16 hJob)
return nRet;
}
HANDLE16 OpenJob(LPSTR lpOutput, LPSTR lpTitle, HDC16 hDC)
HANDLE16 WINAPI OpenJob(LPSTR lpOutput, LPSTR lpTitle, HDC16 hDC)
{
HANDLE16 hHandle = SP_ERROR;
PPRINTJOB pPrintJob;
@ -690,7 +691,7 @@ HANDLE16 OpenJob(LPSTR lpOutput, LPSTR lpTitle, HDC16 hDC)
return hHandle;
}
int CloseJob(HANDLE16 hJob)
int WINAPI CloseJob(HANDLE16 hJob)
{
int nRet = SP_ERROR;
PPRINTJOB pPrintJob = NULL;
@ -708,7 +709,7 @@ int CloseJob(HANDLE16 hJob)
return nRet;
}
int WriteSpool(HANDLE16 hJob, LPSTR lpData, WORD cch)
int WINAPI WriteSpool(HANDLE16 hJob, LPSTR lpData, WORD cch)
{
int nRet = SP_ERROR;
PPRINTJOB pPrintJob = NULL;
@ -726,7 +727,7 @@ int WriteSpool(HANDLE16 hJob, LPSTR lpData, WORD cch)
return nRet;
}
int WriteDialog(HANDLE16 hJob, LPSTR lpMsg, WORD cchMsg)
int WINAPI WriteDialog(HANDLE16 hJob, LPSTR lpMsg, WORD cchMsg)
{
int nRet = 0;
@ -736,7 +737,7 @@ int WriteDialog(HANDLE16 hJob, LPSTR lpMsg, WORD cchMsg)
return nRet;
}
int DeleteJob(HANDLE16 hJob, WORD wNotUsed)
int WINAPI DeleteJob(HANDLE16 hJob, WORD wNotUsed)
{
int nRet;
@ -751,20 +752,20 @@ int DeleteJob(HANDLE16 hJob, WORD wNotUsed)
* when it has been processed. For simplicity they havn't been implemented.
* This means a whole job has to be processed before it is sent to the printer.
*/
int StartSpoolPage(HANDLE16 hJob)
int WINAPI StartSpoolPage(HANDLE16 hJob)
{
dprintf_win16drv(stddeb, "StartSpoolPage GDI.246 unimplemented\n");
return 1;
}
int EndSpoolPage(HANDLE16 hJob)
int WINAPI EndSpoolPage(HANDLE16 hJob)
{
dprintf_win16drv(stddeb, "EndSpoolPage GDI.247 unimplemented\n");
return 1;
}
DWORD GetSpoolJob(int nOption, LONG param)
DWORD WINAPI GetSpoolJob(int nOption, LONG param)
{
DWORD retval = 0;
dprintf_win16drv(stddeb, "In GetSpoolJob param 0x%lx noption %d\n",param, nOption);

15
graphics/win16drv/objects.c
View File

@ -24,11 +24,12 @@ extern HPEN32 WIN16DRV_PEN_SelectObject( DC * dc, HPEN32 hpen, PENOBJ * pen );
/***********************************************************************
* X11DRV_SelectObject
* WIN16DRV_SelectObject
*/
HGDIOBJ32 WIN16DRV_SelectObject( DC *dc, HGDIOBJ32 handle )
{
GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
HGDIOBJ32 ret = 0;
if (!ptr) return 0;
dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", dc->hSelf, handle );
@ -37,17 +38,17 @@ HGDIOBJ32 WIN16DRV_SelectObject( DC *dc, HGDIOBJ32 handle )
{
case PEN_MAGIC:
fprintf(stderr, "WIN16DRV_SelectObject for PEN not implemented\n");
return 0;
case BRUSH_MAGIC:
fprintf(stderr, "WIN16DRV_SelectObject for BRUSH not implemented\n");
return 0;
case BITMAP_MAGIC:
fprintf(stderr, "WIN16DRV_SelectObject for BITMAP not implemented\n");
return 0;
case FONT_MAGIC:
return WIN16DRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
ret = WIN16DRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
break;
case REGION_MAGIC:
return (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
break;
}
return 0;
GDI_HEAP_UNLOCK( handle );
return ret;
}

37
graphics/wing.c
View File

@ -66,7 +66,7 @@ static void __initWinG()
/***********************************************************************
* WinGCreateDC16 (WING.1001)
*/
HDC16 WinGCreateDC16(void)
HDC16 WINAPI WinGCreateDC16(void)
{
__initWinG();
@ -78,7 +78,7 @@ HDC16 WinGCreateDC16(void)
/***********************************************************************
* WinGRecommendDIBFormat16 (WING.1002)
*/
BOOL16 WinGRecommendDIBFormat16(BITMAPINFO *fmt)
BOOL16 WINAPI WinGRecommendDIBFormat16(BITMAPINFO *fmt)
{
fprintf(stdnimp,"WinGRecommendDIBFormat()\n");
@ -93,7 +93,8 @@ BOOL16 WinGRecommendDIBFormat16(BITMAPINFO *fmt)
/***********************************************************************
* WinGCreateBitmap16 (WING.1003)
*/
HBITMAP16 WinGCreateBitmap16(HDC16 winDC, BITMAPINFO *header, void **bits)
HBITMAP16 WINAPI WinGCreateBitmap16(HDC16 winDC, BITMAPINFO *header,
void **bits)
{
fprintf(stdnimp,"WinGCreateBitmap: empty stub! (expect failure)\n");
if( __WinGOK > 0 && header )
@ -126,7 +127,7 @@ HBITMAP16 WinGCreateBitmap16(HDC16 winDC, BITMAPINFO *header, void **bits)
if (hbitmap)
{
__ShmBitmapCtl* p = (__ShmBitmapCtl*)xmalloc(sizeof(__ShmBitmapCtl));
BITMAPOBJ* bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_LIN_ADDR( hbitmap );
BITMAPOBJ* bmpObjPtr = (BITMAPOBJ *) GDI_HEAP_LOCK( hbitmap );
bmpObjPtr->size.cx = 0;
bmpObjPtr->size.cy = 0;
@ -170,6 +171,7 @@ HBITMAP16 WinGCreateBitmap16(HDC16 winDC, BITMAPINFO *header, void **bits)
hbitmap = 0;
}
}
GDI_HEAP_UNLOCK( hbitmap );
return hbitmap;
}
}
@ -181,7 +183,7 @@ HBITMAP16 WinGCreateBitmap16(HDC16 winDC, BITMAPINFO *header, void **bits)
/***********************************************************************
* WinGGetDIBPointer (WING.1004)
*/
SEGPTR WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
SEGPTR WINAPI WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
{
#ifdef PRELIMINARY_WING16_SUPPORT
BITMAPOBJ* bmp = (BITMAPOBJ *) GDI_GetObjPtr( hWinGBitmap, BITMAP_MAGIC );
@ -192,6 +194,7 @@ SEGPTR WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
if( p )
{
if( bmpi ) memcpy( bmpi, &__bmpiWinG, sizeof(BITMAPINFOHEADER));
GDI_HEAP_UNLOCK( hWinGBitmap );
return p->bits;
}
}
@ -202,7 +205,8 @@ SEGPTR WinGGetDIBPointer16(HBITMAP16 hWinGBitmap, BITMAPINFO* bmpi)
/***********************************************************************
* WinGSetDIBColorTable (WING.1004)
*/
UINT16 WinGSetDIBColorTable16(HDC16 hWinGDC, UINT16 start, UINT16 num, RGBQUAD* pColor)
UINT16 WINAPI WinGSetDIBColorTable16(HDC16 hWinGDC, UINT16 start, UINT16 num,
RGBQUAD* pColor)
{
fprintf(stdnimp,"WinGSetDIBColorTable: empty stub!\n");
return num;
@ -211,8 +215,8 @@ UINT16 WinGSetDIBColorTable16(HDC16 hWinGDC, UINT16 start, UINT16 num, RGBQUAD*
/***********************************************************************
* WinGGetDIBColorTable16 (WING.1005)
*/
UINT16 WinGGetDIBColorTable16(HDC16 winDC, UINT16 start, UINT16 numentry,
RGBQUAD* colors)
UINT16 WINAPI WinGGetDIBColorTable16(HDC16 winDC, UINT16 start,
UINT16 numentry, RGBQUAD* colors)
{
fprintf(stdnimp,"WinGGetDIBColorTable: empty stub!\n");
return 0;
@ -221,7 +225,7 @@ UINT16 WinGGetDIBColorTable16(HDC16 winDC, UINT16 start, UINT16 numentry,
/***********************************************************************
* WinGCreateHalfTonePalette16 (WING.1007)
*/
HPALETTE16 WinGCreateHalfTonePalette16(void)
HPALETTE16 WINAPI WinGCreateHalfTonePalette16(void)
{
fprintf(stdnimp,"WinGCreateHalfTonePalette: empty stub!\n");
return 0;
@ -230,7 +234,8 @@ HPALETTE16 WinGCreateHalfTonePalette16(void)
/***********************************************************************
* WinGCreateHalfToneBrush16 (WING.1008)
*/
HPALETTE16 WinGCreateHalfToneBrush16(HDC16 winDC, COLORREF col, WING_DITHER_TYPE type)
HPALETTE16 WINAPI WinGCreateHalfToneBrush16(HDC16 winDC, COLORREF col,
WING_DITHER_TYPE type)
{
fprintf(stdnimp,"WinGCreateHalfToneBrush: empty stub!\n");
return 0;
@ -239,9 +244,10 @@ HPALETTE16 WinGCreateHalfToneBrush16(HDC16 winDC, COLORREF col, WING_DITHER_TYPE
/***********************************************************************
* WinGStretchBlt16 (WING.1009)
*/
BOOL16 WinGStretchBlt16(HDC16 destDC, INT16 xDest, INT16 yDest, INT16 widDest,
INT16 heiDest, HDC16 srcDC, INT16 xSrc, INT16 ySrc,
INT16 widSrc, INT16 heiSrc)
BOOL16 WINAPI WinGStretchBlt16(HDC16 destDC, INT16 xDest, INT16 yDest,
INT16 widDest, INT16 heiDest,
HDC16 srcDC, INT16 xSrc, INT16 ySrc,
INT16 widSrc, INT16 heiSrc)
{
return StretchBlt16(destDC, xDest, yDest, widDest, heiDest, srcDC, xSrc, ySrc, widSrc, heiSrc, SRCCOPY);
@ -252,8 +258,9 @@ BOOL16 WinGStretchBlt16(HDC16 destDC, INT16 xDest, INT16 yDest, INT16 widDest,
/***********************************************************************
* WinGBitBlt16 (WING.1010)
*/
BOOL16 WinGBitBlt16(HDC16 destDC, INT16 xDest, INT16 yDest, INT16 widDest,
INT16 heiDest, HDC16 srcDC, INT16 xSrc, INT16 ySrc)
BOOL16 WINAPI WinGBitBlt16(HDC16 destDC, INT16 xDest, INT16 yDest,
INT16 widDest, INT16 heiDest, HDC16 srcDC,
INT16 xSrc, INT16 ySrc)
{
/* destDC is a display DC, srcDC is a memory DC */

47
graphics/x11drv/bitblt.c
View File

@ -1341,6 +1341,34 @@ BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
return TRUE;
}
struct StretchBlt_params
{
DC *dcDst;
INT32 xDst;
INT32 yDst;
INT32 widthDst;
INT32 heightDst;
DC *dcSrc;
INT32 xSrc;
INT32 ySrc;
INT32 widthSrc;
INT32 heightSrc;
DWORD rop;
};
/***********************************************************************
* BITBLT_DoStretchBlt
*
* Wrapper function for BITBLT_InternalStretchBlt
* to use with CALL_LARGE_STACK.
*/
static int BITBLT_DoStretchBlt( const struct StretchBlt_params *p )
{
return (int)BITBLT_InternalStretchBlt( p->dcDst, p->xDst, p->yDst,
p->widthDst, p->heightDst,
p->dcSrc, p->xSrc, p->ySrc,
p->widthSrc, p->heightSrc, p->rop );
}
/***********************************************************************
* X11DRV_PatBlt
@ -1348,9 +1376,9 @@ BOOL32 BITBLT_InternalStretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
BOOL32 X11DRV_PatBlt( DC *dc, INT32 left, INT32 top,
INT32 width, INT32 height, DWORD rop )
{
return CallTo32_LargeStack( (int(*)())BITBLT_InternalStretchBlt, 11,
dc, left, top, width, height,
NULL, 0, 0, 0, 0, rop );
struct StretchBlt_params params = { dc, left, top, width, height,
NULL, 0, 0, 0, 0, rop };
return (BOOL32)CALL_LARGE_STACK( BITBLT_DoStretchBlt, &params );
}
@ -1361,9 +1389,9 @@ BOOL32 X11DRV_BitBlt( DC *dcDst, INT32 xDst, INT32 yDst,
INT32 width, INT32 height, DC *dcSrc,
INT32 xSrc, INT32 ySrc, DWORD rop )
{
return CallTo32_LargeStack( (int(*)())BITBLT_InternalStretchBlt, 11,
dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, width, height, rop );
struct StretchBlt_params params = { dcDst, xDst, yDst, width, height,
dcSrc, xSrc, ySrc, width, height, rop};
return (BOOL32)CALL_LARGE_STACK( BITBLT_DoStretchBlt, &params );
}
@ -1375,7 +1403,8 @@ BOOL32 X11DRV_StretchBlt( DC *dcDst, INT32 xDst, INT32 yDst,
DC *dcSrc, INT32 xSrc, INT32 ySrc,
INT32 widthSrc, INT32 heightSrc, DWORD rop )
{
return CallTo32_LargeStack( (int(*)())BITBLT_InternalStretchBlt, 11,
dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc, rop );
struct StretchBlt_params params = { dcDst, xDst, yDst, widthDst, heightDst,
dcSrc, xSrc, ySrc, widthSrc, heightSrc,
rop };
return (BOOL32)CALL_LARGE_STACK( BITBLT_DoStretchBlt, &params );
}

1
graphics/x11drv/brush.c
View File

@ -179,6 +179,7 @@ static BOOL32 BRUSH_SelectPatternBrush( DC * dc, HBITMAP32 hbitmap )
dc->u.x.brush.fillStyle = FillOpaqueStippled;
dc->u.x.brush.pixel = -1; /* Special case (see DC_SetupGCForBrush) */
}
GDI_HEAP_UNLOCK( hbitmap );
return TRUE;
}

1
graphics/x11drv/clipping.c
View File

@ -31,4 +31,5 @@ void X11DRV_SetDeviceClipping( DC * dc )
{
XSetClipRectangles( display, dc->u.x.gc, 0, 0, NULL, 0, 0 );
}
GDI_HEAP_UNLOCK( dc->w.hGCClipRgn );
}

46
graphics/x11drv/graphics.c
View File

@ -631,16 +631,29 @@ static void X11DRV_InternalFloodFill(XImage *image, DC *dc,
*
* Main flood-fill routine.
*/
static BOOL32 X11DRV_DoFloodFill( DC *dc, RECT32 *rect, INT32 x, INT32 y,
COLORREF color, UINT32 fillType )
struct FloodFill_params
{
DC *dc;
INT32 x;
INT32 y;
COLORREF color;
UINT32 fillType;
};
static BOOL32 X11DRV_DoFloodFill( const struct FloodFill_params *params )
{
XImage *image;
RECT32 rect;
DC *dc = params->dc;
if (GetRgnBox32( dc->w.hGCClipRgn, &rect ) == ERROR) return FALSE;
if (!(image = XGetImage( display, dc->u.x.drawable,
dc->w.DCOrgX + rect->left,
dc->w.DCOrgY + rect->top,
rect->right - rect->left,
rect->bottom - rect->top,
dc->w.DCOrgX + rect.left,
dc->w.DCOrgY + rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
AllPlanes, ZPixmap ))) return FALSE;
if (DC_SetupGCForBrush( dc ))
@ -648,11 +661,12 @@ static BOOL32 X11DRV_DoFloodFill( DC *dc, RECT32 *rect, INT32 x, INT32 y,
/* ROP mode is always GXcopy for flood-fill */
XSetFunction( display, dc->u.x.gc, GXcopy );
X11DRV_InternalFloodFill(image, dc,
XLPTODP(dc,x) - rect->left,
YLPTODP(dc,y) - rect->top,
dc->w.DCOrgX + rect->left,
dc->w.DCOrgY + rect->top,
COLOR_ToPhysical( dc, color ), fillType );
XLPTODP(dc,params->x) - rect.left,
YLPTODP(dc,params->y) - rect.top,
dc->w.DCOrgX + rect.left,
dc->w.DCOrgY + rect.top,
COLOR_ToPhysical( dc, params->color ),
params->fillType );
}
XDestroyImage( image );
@ -667,15 +681,11 @@ BOOL32
X11DRV_ExtFloodFill( DC *dc, INT32 x, INT32 y, COLORREF color,
UINT32 fillType )
{
RECT32 rect;
HDC32 hdc = dc->hSelf; /* FIXME */
struct FloodFill_params params = { dc, x, y, color, fillType };
dprintf_graphics( stddeb, "X11DRV_ExtFloodFill %d,%d %06lx %d\n",
x, y, color, fillType );
if (!PtVisible32( hdc, x, y )) return FALSE;
if (GetRgnBox32( dc->w.hGCClipRgn, &rect ) == ERROR) return FALSE;
return CallTo32_LargeStack( (int(*)())X11DRV_DoFloodFill, 6,
dc, &rect, x, y, color, fillType );
if (!PtVisible32( dc->hSelf, x, y )) return FALSE;
return CALL_LARGE_STACK( X11DRV_DoFloodFill, &params );
}

3
graphics/x11drv/init.c
View File

@ -136,6 +136,8 @@ BOOL32 X11DRV_Init(void)
X11DRV_DevCaps.rasterCaps |= RC_PALETTE;
X11DRV_DevCaps.sizePalette = DefaultVisual(display,DefaultScreen(display))->map_entries;
}
/* Resolution will be adjusted during the font init */
X11DRV_DevCaps.logPixelsX = (int)(X11DRV_DevCaps.horzRes * 25.4 / X11DRV_DevCaps.horzSize);
X11DRV_DevCaps.logPixelsY = (int)(X11DRV_DevCaps.vertRes * 25.4 / X11DRV_DevCaps.vertSize);
@ -177,6 +179,7 @@ static BOOL32 X11DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
dc->w.bitsPerPixel = bmp->bitmap.bmBitsPixel;
dc->w.hVisRgn = CreateRectRgn32( 0, 0, bmp->bitmap.bmWidth,
bmp->bitmap.bmHeight );
GDI_HEAP_UNLOCK( dc->w.hBitmap );
}
else
{

19
graphics/x11drv/objects.c
View File

@ -29,6 +29,7 @@ extern HPEN32 X11DRV_PEN_SelectObject( DC * dc, HPEN32 hpen, PENOBJ * pen );
HGDIOBJ32 X11DRV_SelectObject( DC *dc, HGDIOBJ32 handle )
{
GDIOBJHDR *ptr = GDI_GetObjPtr( handle, MAGIC_DONTCARE );
HGDIOBJ32 ret = 0;
if (!ptr) return 0;
dprintf_gdi(stddeb, "SelectObject: hdc=%04x %04x\n", dc->hSelf, handle );
@ -36,15 +37,21 @@ HGDIOBJ32 X11DRV_SelectObject( DC *dc, HGDIOBJ32 handle )
switch(ptr->wMagic)
{
case PEN_MAGIC:
return X11DRV_PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
ret = X11DRV_PEN_SelectObject( dc, handle, (PENOBJ *)ptr );
break;
case BRUSH_MAGIC:
return X11DRV_BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
ret = X11DRV_BRUSH_SelectObject( dc, handle, (BRUSHOBJ *)ptr );
break;
case BITMAP_MAGIC:
return X11DRV_BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
ret = X11DRV_BITMAP_SelectObject( dc, handle, (BITMAPOBJ *)ptr );
break;
case FONT_MAGIC:
return X11DRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
ret = X11DRV_FONT_SelectObject( dc, handle, (FONTOBJ *)ptr );
break;
case REGION_MAGIC:
return (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
ret = (HGDIOBJ16)SelectClipRgn16( dc->hSelf, handle );
break;
}
return 0;
GDI_HEAP_UNLOCK( handle );
return ret;
}

428
graphics/x11drv/xfont.c
View File

@ -48,11 +48,44 @@ typedef struct __fontAlias
struct __fontAlias* next;
} fontAlias;
typedef struct
{
LPSTR fatResource;
LPSTR fatAlias;
} aliasTemplate;
/* Font alias table - these 2 aliases are always present */
static fontAlias aliasTable[2] = {
{ "Helvetica", "Helv", &aliasTable[1] },
{ "Times", "Tms Rmn", NULL }
};
/* Optional built-in aliases, they are installed only when X
* cannot supply us with original MS fonts */
static int faTemplateNum = 4;
static aliasTemplate faTemplate[4] = {
{ "-adobe-helvetica-", "MS Sans Serif" },
{ "-bitstream-charter-", "MS Serif" },
{ "-adobe-times-", "Times New Roman" },
{ "-adobe-helvetica-", "Arial" }
};
/* Charset translation table, cp125-.. encoded fonts are produced by
* the fnt2bdf */
static int numCPTranslation = 8;
static BYTE CPTranslation[] = { EE_CHARSET, /* cp125-0 */
RUSSIAN_CHARSET, /* cp125-1 */
ANSI_CHARSET, /* cp125-2 */
GREEK_CHARSET, /* cp125-3 */
TURKISH_CHARSET, /* cp125-4 */
HEBREW_CHARSET, /* cp125-5 */
ARABIC_CHARSET, /* cp125-6 */
BALTIC_CHARSET /* cp125-7 */
};
UINT16 XTextCaps = TC_OP_CHARACTER | TC_OP_STROKE | TC_CP_STROKE |
TC_SA_DOUBLE | TC_SA_INTEGER | TC_SA_CONTIN |
TC_UA_ABLE | TC_SO_ABLE | TC_RA_ABLE;
@ -64,14 +97,17 @@ static const char* INIFontMetrics = "/.cachedmetrics";
static const char* INIFontSection = "fonts";
static const char* INISubSection = "Alias";
static const char* INIDefault = "Default";
static const char* INIResolution = "Resolution";
static const char* INIGlobalMetrics = "FontMetrics";
static const char* LFDSeparator = "*-";
static const char* localMSEncoding = "cp125-";
static const char* iso8859Encoding = "iso8859-";
static const char* iso646Encoding = "iso646.1991-";
static const char* ansiEncoding = "ansi-";
static fontResource* fontList = NULL;
static unsigned DefResolution = 0;
static fontResource* fontList = NULL;
static fontObject* fontCache = NULL; /* array */
static int fontCacheSize = FONTCACHE;
static int fontLF = -1, fontMRU = -1; /* last free, most recently used */
@ -317,28 +353,32 @@ static int LFD_InitFontInfo( fontInfo* fi, LPSTR lpstr )
*(lpch - 1) = LFDSeparator[1];
/* charset registry, charset encoding - */
if( strstr(lpch, "jisx") || strstr(lpch, "ksc") ) return FALSE; /* 2-byte stuff */
if( strstr(lpch, "jisx") ||
strstr(lpch, "ksc") ||
strstr(lpch, "gb2312") ) return FALSE; /* 2-byte stuff */
fi->df.dfCharSet = ANSI_CHARSET;
if( strstr(lpch, iso8859Encoding) )
{
fi->fi_flags |= FI_ENC_ISO8859;
fi->df.dfCharSet = ANSI_CHARSET;
}
else if( strstr(lpch, iso646Encoding) )
{
fi->fi_flags |= FI_ENC_ISO646;
fi->df.dfCharSet = ANSI_CHARSET;
}
else if( strstr(lpch, ansiEncoding) ) /* font2bdf produces -ansi-0 LFD */
{
else if( strstr(lpch, ansiEncoding) ) /* fnt2bdf produces -ansi-0 LFD */
fi->fi_flags |= FI_ENC_ANSI;
fi->df.dfCharSet = ANSI_CHARSET;
else /* ... and -cp125-x */
{
fi->df.dfCharSet = OEM_CHARSET;
if( !strncasecmp(lpch, localMSEncoding, 6) )
{
lpch = LFD_Advance( lpch, 1 );
if( lpch && (i = atoi( lpch )) < numCPTranslation )
{
fi->fi_flags |= FI_ENC_MSCODEPAGE;
fi->df.dfCharSet = CPTranslation[i];
}
}
else if( strstr(lpch, "fontspecific") )
fi->df.dfCharSet = SYMBOL_CHARSET;
}
else if( strstr(lpch, "fontspecific") )
fi->df.dfCharSet = SYMBOL_CHARSET;
else
fi->df.dfCharSet = OEM_CHARSET; /* FIXME: -cp126-.. from fnt2bdf */
return TRUE;
}
@ -348,7 +388,7 @@ static int LFD_InitFontInfo( fontInfo* fi, LPSTR lpstr )
static BOOL32 LFD_ComposeLFD( fontObject* fo,
INT32 height, LPSTR lpLFD, UINT32 uRelax )
{
int h, w, ch, point = 0;
int h, w, ch, enc_ch, point = 0;
char* lpch;
const char* lpEncoding = NULL;
@ -400,9 +440,12 @@ static BOOL32 LFD_ComposeLFD( fontObject* fo,
if( fo->fo_flags & FO_SYNTH_HEIGHT ) h = fo->fi->lfd_height;
else h = (fo->fi->lfd_height * height) / fo->fi->df.dfPixHeight;
if( fo->lf.lfWidth && (XTextCaps & TC_SF_X_YINDEP)
&& !(fo->fo_flags & FO_SYNTH_WIDTH) )
point = (fo->fi->lfd_decipoints * fo->lf.lfWidth) / fo->fi->df.dfAvgWidth;
if( XTextCaps & TC_SF_X_YINDEP )
if( fo->lf.lfWidth && !(fo->fo_flags & FO_SYNTH_WIDTH) )
point = (fo->fi->lfd_decipoints * fo->lf.lfWidth) / fo->fi->df.dfAvgWidth;
else
if( fo->fi->fi_flags & FI_SCALABLE ) /* adjust h/w ratio */
point = h * 72 * 10 / fo->fi->lfd_resolution;
/* spacing and width */
@ -411,16 +454,35 @@ static BOOL32 LFD_ComposeLFD( fontObject* fo,
else
w = ( fo->fi->fi_flags & FI_VARIABLEPITCH ) ? 'p' : LFDSeparator[0];
/* encoding, not quite there yet */
/* encoding */
enc_ch = '*';
if( fo->fi->df.dfCharSet == ANSI_CHARSET )
{
if( fo->fi->fi_flags & FI_ENC_ISO8859 )
lpEncoding = iso8859Encoding;
else if( fo->fi->fi_flags & FI_ENC_ISO646 )
lpEncoding = iso646Encoding;
else if( fo->fi->fi_flags & FI_ENC_MSCODEPAGE )
{
enc_ch = '2';
lpEncoding = localMSEncoding;
}
else lpEncoding = ansiEncoding;
} else lpEncoding = LFDSeparator;
}
else if( fo->fi->fi_flags & FI_ENC_MSCODEPAGE )
{
int i;
lpEncoding = localMSEncoding;
for( i = 0; i < numCPTranslation; i++ )
if( CPTranslation[i] == fo->fi->df.dfCharSet )
{
enc_ch = '0' + i;
break;
}
}
else lpEncoding = LFDSeparator; /* whatever */
lpch = lpLFD + lstrlen32A(lpLFD);
ch = (fo->fi->fi_flags & FI_SCALABLE) ? '0' : LFDSeparator[0];
@ -433,20 +495,20 @@ static BOOL32 LFD_ComposeLFD( fontObject* fo,
case 0:
if( point )
{
sprintf( lpch, "%i-%i-%i-%c-%c-*-%s*", h, point,
fo->fi->lfd_resolution, ch, w, lpEncoding );
sprintf( lpch, "%i-%i-%i-%c-%c-*-%s%c", h, point,
fo->fi->lfd_resolution, ch, w, lpEncoding, enc_ch );
break;
}
/* fall through */
case 1:
sprintf( lpch, "%i-*-%i-%c-%c-*-%s*", h,
fo->fi->lfd_resolution, ch, w, lpEncoding );
sprintf( lpch, "%i-*-%i-%c-%c-*-%s%c", h,
fo->fi->lfd_resolution, ch, w, lpEncoding, enc_ch );
break;
case 2:
sprintf( lpch, "%i-*-%i-%c-*-*-%s*",
h, fo->fi->lfd_resolution, ch, lpEncoding );
sprintf( lpch, "%i-*-%i-%c-*-*-%s%c",
h, fo->fi->lfd_resolution, ch, lpEncoding, enc_ch );
break;
case 3:
@ -668,7 +730,8 @@ static BYTE XFONT_FixupFlags( LPCSTR lfFaceName )
return FF_SWISS;
break;
case 'c':
case 'C': if(!lstrcmpi32A(lfFaceName, "Courier") )
case 'C': if(!lstrcmpi32A(lfFaceName, "Courier") ||
!lstrcmpi32A(lfFaceName, "Charter") )
return FF_ROMAN;
break;
case 'p':
@ -691,6 +754,18 @@ static BYTE XFONT_FixupFlags( LPCSTR lfFaceName )
}
/***********************************************************************
* XFONT_CheckResourceName
*/
static BOOL32 XFONT_CheckResourceName( LPSTR resource, LPCSTR name, INT32 n )
{
resource = LFD_Advance( resource, 2 );
if( resource )
return (!lstrncmpi32A( resource, name, n ));
return FALSE;
}
/***********************************************************************
* XFONT_WindowsNames
*
@ -711,17 +786,13 @@ static void XFONT_WindowsNames( char* buffer )
if( fr->fr_flags & FR_NAMESET ) continue; /* skip already assigned */
lpstr = LFD_Advance(fr->resource, 2);
i = lpstr - LFD_Advance( lpstr, 1 );
i = LFD_Advance( lpstr, 1 ) - lpstr;
for( pfr = fontList; pfr != fr ; pfr = pfr->next )
if( pfr->fr_flags & FR_NAMESET )
{
lpch = LFD_Advance(pfr->resource, 2);
if( XFONT_CheckResourceName( pfr->resource, lpstr, i ) )
break;
/* check if already have the same face name */
if( !lstrncmp32A(lpch, lpstr, i) ) break;
}
if( pfr != fr ) /* prepend vendor name */
lpstr = fr->resource + 1;
@ -781,10 +852,24 @@ static void XFONT_WindowsNames( char* buffer )
*/
static fontAlias* XFONT_CreateAlias( LPCSTR lpTypeFace, LPCSTR lpAlias )
{
int j;
fontAlias* pfa = aliasTable;
int j = lstrlen32A(lpTypeFace) + 1;
while( pfa->next ) pfa = pfa->next;
while( 1 )
{
/* check if we already got one */
if( !lstrcmpi32A( pfa->faTypeFace, lpAlias ) )
{
#ifdef DEBUG_FONT_INIT
dprintf_font(stddeb,"\tredundant alias '%s' -> '%s'\n", lpAlias, lpTypeFace );
#endif
return NULL;
}
if( pfa->next ) pfa = pfa->next;
else break;
}
j = lstrlen32A(lpTypeFace) + 1;
pfa->next = HeapAlloc( SystemHeap, 0, sizeof(fontAlias) +
j + lstrlen32A(lpAlias) + 1 );
if((pfa = pfa->next))
@ -814,54 +899,79 @@ static fontAlias* XFONT_CreateAlias( LPCSTR lpTypeFace, LPCSTR lpAlias )
* Alias0 = Arial, -adobe-helvetica-
* Alias1 = Times New Roman, -bitstream-courier-, 1
* ...
*
* Note that from 081797 and on we have built-in alias templates that take
* care of the necessary Windows typefaces.
*/
static void XFONT_LoadAliases( char** buffer, int buf_size )
{
char* lpResource, *lpAlias;
char subsection[32];
int i = 0;
int i = 0, j = 0;
BOOL32 bHaveAlias = TRUE, bSubst = FALSE;
if( buf_size < 128 )
*buffer = HeapReAlloc(SystemHeap, 0, *buffer, 256 );
do
{
wsprintf32A( subsection, "%s%i", INISubSection, i++ );
if( PROFILE_GetWineIniString( INIFontSection, subsection, "", *buffer, 128 ) )
if( j < faTemplateNum )
{
char* lpchX, *lpchW = *buffer;
/* built-in templates first */
while( isspace(*lpchW) ) lpchW++;
lpchX = PROFILE_GetStringItem( lpchW );
lpResource = faTemplate[j].fatResource;
lpAlias = faTemplate[j].fatAlias;
j++;
}
else
{
/* then WINE.CONF */
if( lpchX )
wsprintf32A( subsection, "%s%i", INISubSection, i++ );
if( (bHaveAlias = PROFILE_GetWineIniString( INIFontSection,
subsection, "", *buffer, 128 )) )
{
fontResource* fr;
lpAlias = *buffer;
while( isspace(*lpAlias) ) lpAlias++;
lpResource = PROFILE_GetStringItem( lpAlias );
bSubst = (PROFILE_GetStringItem( lpResource )) ? TRUE : FALSE;
}
}
if( bHaveAlias )
{
int length;
length = lstrlen32A( lpAlias );
if( lpResource && length )
{
fontResource* fr, *frMatch = NULL;
for (fr = fontList; fr ; fr = fr->next)
{
int j;
j = lstrlen32A( fr->resource );
if( !lstrncmpi32A( fr->resource, lpchX, j) )
if( !lstrcmpi32A( fr->resource, lpResource ) ) frMatch = fr;
if( XFONT_CheckResourceName( fr->resource, lpAlias, length ) )
{
char* lpch = PROFILE_GetStringItem( lpchX );
/* alias is not needed since the real font is present */
frMatch = NULL; break;
}
}
if( lpch )
{
if( frMatch )
{
if( bSubst )
{
#ifdef DEBUG_FONT_INIT
dprintf_font(stddeb, "\tsubstituted '%s' with %s\n",
fr->lfFaceName, lpchW );
dprintf_font(stddeb, "\tsubstituted '%s' with %s\n",
frMatch->lfFaceName, lpAlias );
#endif
lstrcpyn32A( fr->lfFaceName, lpchW, LF_FACESIZE );
fr->fr_flags |= FR_NAMESET;
}
else
{
/* create new entry in the alias table */
XFONT_CreateAlias(fr->lfFaceName, lpchW);
}
break;
lstrcpyn32A( frMatch->lfFaceName, lpAlias, LF_FACESIZE );
frMatch->fr_flags |= FR_NAMESET;
}
else
{
/* create new entry in the alias table */
XFONT_CreateAlias( frMatch->lfFaceName, lpAlias );
}
}
}
@ -883,8 +993,10 @@ static char* XFONT_UserMetricsCache( char* buffer, int* buf_size )
pwd = getpwuid(getuid());
if( pwd && pwd->pw_dir )
{
int i = lstrlen32A( pwd->pw_dir ) + lstrlen32A( INIWinePrefix ) + lstrlen32A( INIFontMetrics ) + 2;
if( i > *buf_size ) buffer = (char*) HeapReAlloc( SystemHeap, 0, buffer, *buf_size = i );
int i = lstrlen32A( pwd->pw_dir ) + lstrlen32A( INIWinePrefix ) +
lstrlen32A( INIFontMetrics ) + 2;
if( i > *buf_size )
buffer = (char*) HeapReAlloc( SystemHeap, 0, buffer, *buf_size = i );
lstrcpy32A( buffer, pwd->pw_dir );
strcat( buffer, INIWinePrefix );
strcat( buffer, INIFontMetrics );
@ -896,7 +1008,7 @@ static char* XFONT_UserMetricsCache( char* buffer, int* buf_size )
/***********************************************************************
* XFONT_ReadCachedMetrics
*/
static BOOL32 XFONT_ReadCachedMetrics( int fd, unsigned x_checksum, int x_count )
static BOOL32 XFONT_ReadCachedMetrics( int fd, int res, unsigned x_checksum, int x_count )
{
if( fd >= 0 )
{
@ -938,6 +1050,9 @@ static BOOL32 XFONT_ReadCachedMetrics( int fd, unsigned x_checksum, int x_count
(int)(pfi->next) != j++ ) goto fail;
pfi->df.dfFace = pfr->lfFaceName;
pfi->df.dfHorizRes = pfi->df.dfVertRes = res;
pfi->df.dfPoints = (INT16)(((INT32)(pfi->df.dfPixHeight -
pfi->df.dfInternalLeading) * 72) / res );
pfi->next = pfi + 1;
if( j > pfr->count ) break;
@ -1058,6 +1173,108 @@ static BOOL32 XFONT_WriteCachedMetrics( int fd, unsigned x_checksum, int x_count
return TRUE;
}
/***********************************************************************
* XFONT_CheckIniSection
*
* Examines wine.conf for old/invalid font entries and recommend changes to
* the user.
*
* Revision history
* 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
* Original implementation.
*/
static void XFONT_CheckIniCallback(char const *, char const *, void *);
static char const *fontmsgprologue =
"Wine warning:\n"
" The following entries in the [fonts] section of the wine.conf file are\n"
" obsolete or invalid:\n";
static char const *fontmsgepilogue =
" These entries should be eliminated or updated.\n"
" See the documentation/fonts file for more information.\n";
static int XFONT_CheckIniSection()
{
int found = 0;
PROFILE_EnumerateWineIniSection("Fonts", &XFONT_CheckIniCallback,
(void *)&found);
if(found)
fprintf(stderr, fontmsgepilogue);
return 1;
}
static void XFONT_CheckIniCallback(
char const *key,
char const *value,
void *found)
{
/* Ignore any keys that start with potential comment characters "'", '#',
or ';'. */
if(key[0] == '\'' || key[0] == '#' || key[0] == ';' || key[0] == '\0')
return;
/* Make sure this is a valid key */
if((strncasecmp(key, INISubSection, 5) == 0) ||
(strcasecmp(key, INIDefault) == 0) ||
(strcasecmp(key, INIGlobalMetrics) == 0) ||
(strcasecmp(key, INIResolution) == 0) )
{
/* Valid key; make sure the value doesn't contain a wildcard */
if(strchr(value, '*')) {
if(*(int *)found == 0) {
fprintf(stderr, fontmsgprologue);
++*(int *)found;
}
fprintf(stderr, " %s=%s [no wildcards allowed]\n", key, value);
}
}
else {
/* Not a valid key */
if(*(int *)found == 0) {
fprintf(stderr, fontmsgprologue);
++*(int *)found;
}
fprintf(stderr, " %s=%s [obsolete]\n", key, value);
}
return;
}
/***********************************************************************
* XFONT_GetPointResolution()
*
* Here we initialize DefResolution which is used in the
* XFONT_Match() penalty function. We also load the point
* resolution value (higher values result in larger fonts).
*/
static int XFONT_GetPointResolution( DeviceCaps* pDevCaps )
{
int i, j, point_resolution, num = 3;
int allowed_xfont_resolutions[3] = { 72, 75, 100 };
int best = 0, best_diff = 65536;
DefResolution = point_resolution = PROFILE_GetWineIniInt( INIFontSection, INIResolution, 0 );
if( !DefResolution ) DefResolution = point_resolution = pDevCaps->logPixelsY;
else pDevCaps->logPixelsX = pDevCaps->logPixelsY = DefResolution;
for( i = best = 0; i < num; i++ )
{
j = abs( DefResolution - allowed_xfont_resolutions[i] );
if( j < best_diff )
{
best = i;
best_diff = j;
}
}
DefResolution = allowed_xfont_resolutions[best];
return point_resolution;
}
/***********************************************************************
* X11DRV_FONT_Init
*
@ -1069,24 +1286,18 @@ BOOL32 X11DRV_FONT_Init( DeviceCaps* pDevCaps )
fontResource* fr, *pfr;
fontInfo* fi, *pfi;
unsigned x_checksum;
int i, j, k, x_count, fd = -1, buf_size = 0;
int i, j, res, x_count, fd = -1, buf_size = 0;
char* lpstr, *lpch, *lpmetrics, *buffer;
char** x_pattern;
DefResolution = PROFILE_GetWineIniInt( INIFontSection, "Resolution", 0 );
if( !DefResolution ) DefResolution = pDevCaps->logPixelsY;
XFONT_CheckIniSection();
i = abs(DefResolution - 72);
j = abs(DefResolution - 75);
k = abs(DefResolution - 100);
if( i < j ) DefResolution = ( i < k ) ? 72 : 100;
else DefResolution = ( j < k ) ? 75 : 100;
res = XFONT_GetPointResolution( pDevCaps );
x_pattern = XListFonts(display, "*", MAX_FONT_FAMILIES * 16, &x_count );
dprintf_font(stddeb,"Font Mapper: initializing %i fonts [LPY=%i, DR=%i]\n",
x_count, pDevCaps->logPixelsY, DefResolution);
dprintf_font(stddeb,"Font Mapper: initializing %i fonts [LPY=%i, XDR=%i, DR=%i]\n",
x_count, pDevCaps->logPixelsY, DefResolution, res);
for( i = x_checksum = 0; i < x_count; i++ )
{
#if 0
@ -1104,17 +1315,17 @@ BOOL32 X11DRV_FONT_Init( DeviceCaps* pDevCaps )
/* deal with systemwide font metrics cache */
if( PROFILE_GetWineIniString( INIFontSection, "FontMetrics", "", buffer, 128 ) )
if( PROFILE_GetWineIniString( INIFontSection, INIGlobalMetrics, "", buffer, 128 ) )
fd = open( buffer, O_RDONLY );
if( XFONT_ReadCachedMetrics(fd, x_checksum, x_count) == FALSE )
if( XFONT_ReadCachedMetrics(fd, res, x_checksum, x_count) == FALSE )
{
/* try per-user */
buffer = XFONT_UserMetricsCache( buffer, &buf_size );
if( buffer[0] )
{
fd = open( buffer, O_RDONLY );
if( XFONT_ReadCachedMetrics(fd, x_checksum, x_count) == FALSE )
if( XFONT_ReadCachedMetrics(fd, res, x_checksum, x_count) == FALSE )
lpmetrics = HEAP_strdupA( SystemHeap, 0, buffer ); /* update later on */
}
}
@ -1196,8 +1407,7 @@ BOOL32 X11DRV_FONT_Init( DeviceCaps* pDevCaps )
if( (x_fs = XLoadQueryFont(display, lpstr)) )
{
fi->df.dfHorizRes = pDevCaps->logPixelsX;
fi->df.dfVertRes = pDevCaps->logPixelsY;
fi->df.dfHorizRes = fi->df.dfVertRes = res;
XFONT_SetFontMetric( fi, fr, x_fs );
XFreeFont( display, x_fs );
@ -1301,7 +1511,7 @@ static INT32 XFONT_IsSubset(fontInfo* match, fontInfo* fi)
* weight, italics, underlines, strikeouts
*
* NOTE: you can experiment with different penalty weights to see what happens.
* http://premium.microsoft.com/msdn/library/techart/f30/f34/f40/d4d/sa8bf.htm
* http://premium.microsoft.com/msdn/library/techart/f365/f36b/f37b/d38b/sa8bf.htm
*/
static UINT32 XFONT_Match( fontMatch* pfm )
{
@ -1354,7 +1564,7 @@ static UINT32 XFONT_Match( fontMatch* pfm )
else /* expand only in integer multiples */
{
pfm->height = height - height%pfi->df.dfPixHeight;
penalty += (height - pfm->height) * pfm->height / height;
penalty += (height - pfm->height + 1) * height / pfi->df.dfPixHeight;
}
}
else /* can't be scaled at all */
@ -1431,18 +1641,6 @@ static UINT32 XFONT_MatchFIList( fontMatch* pfm )
return score;
}
/***********************************************************************
* XFONT_CheckAliasTable
*/
static LPSTR XFONT_CheckAliasTable( LPSTR lpAlias )
{
fontAlias* fa;
for( fa = aliasTable; fa; fa = fa->next )
if( !lstrcmpi32A( fa->faAlias, lpAlias ) ) return fa->faTypeFace;
return NULL;
}
/***********************************************************************
* XFONT_CheckFIList
*
@ -1515,9 +1713,17 @@ static BOOL32 XFONT_MatchDeviceFont( fontResource* start, fontMatch* pfm )
fontMatch fm = *pfm;
pfm->pfi = NULL;
if( fm.plf->lfFaceName[0] )
if( fm.plf->lfFaceName[0] )
{
LPSTR str = XFONT_CheckAliasTable( fm.plf->lfFaceName );
fontAlias* fa;
LPSTR str = NULL;
for( fa = aliasTable; fa; fa = fa->next )
if( !lstrcmpi32A( fa->faAlias, fm.plf->lfFaceName ) )
{
str = fa->faTypeFace;
break;
}
fm.pfr = XFONT_FindFIList( start, str ? str : fm.plf->lfFaceName );
}
@ -1827,11 +2033,17 @@ LPIFONTINFO16 XFONT_GetFontInfo( X_PHYSFONT pFont )
HFONT32 X11DRV_FONT_SelectObject( DC* dc, HFONT32 hfont, FONTOBJ* font )
{
HFONT32 hPrevFont = 0;
LOGFONT16 lf;
if( CHECK_PFONT(dc->u.x.font) )
XFONT_ReleaseCacheEntry( __PFONT(dc->u.x.font) );
dc->u.x.font = XFONT_RealizeFont( &font->logfont );
/* FIXME: do we need to pass anything back from here? */
memcpy(&lf,&font->logfont,sizeof(lf));
lf.lfWidth = font->logfont.lfWidth * dc->vportExtX/dc->wndExtX;
lf.lfHeight = font->logfont.lfHeight* dc->vportExtY/dc->wndExtY;
dc->u.x.font = XFONT_RealizeFont( &lf );
hPrevFont = dc->w.hFont;
dc->w.hFont = hfont;
@ -1966,7 +2178,7 @@ BOOL32 X11DRV_GetCharWidth( DC *dc, UINT32 firstChar, UINT32 lastChar,
* the pfr->resource field) with FR_SOFTFONT/FR_SOFTRESOURCE
* flag set.
*/
INT16 AddFontResource16( LPCSTR filename )
INT16 WINAPI AddFontResource16( LPCSTR filename )
{
return AddFontResource32A( filename );
}
@ -1975,7 +2187,7 @@ INT16 AddFontResource16( LPCSTR filename )
/***********************************************************************
* AddFontResource32A (GDI32.2)
*/
INT32 AddFontResource32A( LPCSTR str )
INT32 WINAPI AddFontResource32A( LPCSTR str )
{
if (HIWORD(str)) /* font file */
fprintf( stdnimp, "STUB: AddFontResource('%s')\n", str );
@ -1988,7 +2200,7 @@ INT32 AddFontResource32A( LPCSTR str )
/***********************************************************************
* AddFontResource32W (GDI32.4)
*/
INT32 AddFontResource32W( LPCWSTR str )
INT32 WINAPI AddFontResource32W( LPCWSTR str )
{
fprintf( stdnimp, "STUB: AddFontResource32W(%p)\n", str );
return 1;
@ -1997,7 +2209,7 @@ INT32 AddFontResource32W( LPCWSTR str )
/***********************************************************************
* RemoveFontResource16 (GDI.136)
*/
BOOL16 RemoveFontResource16( SEGPTR str )
BOOL16 WINAPI RemoveFontResource16( SEGPTR str )
{
if (HIWORD(str))
fprintf( stdnimp, "STUB: RemoveFontResource('%s')\n",
@ -2011,7 +2223,7 @@ BOOL16 RemoveFontResource16( SEGPTR str )
/***********************************************************************
* RemoveFontResource32A (GDI32.284)
*/
BOOL32 RemoveFontResource32A( LPCSTR str )
BOOL32 WINAPI RemoveFontResource32A( LPCSTR str )
{
if (HIWORD(str))
fprintf( stdnimp, "STUB: RemoveFontResource('%s')\n", str );
@ -2024,7 +2236,7 @@ BOOL32 RemoveFontResource32A( LPCSTR str )
/***********************************************************************
* RemoveFontResource32W (GDI32.286)
*/
BOOL32 RemoveFontResource32W( LPCWSTR str )
BOOL32 WINAPI RemoveFontResource32W( LPCWSTR str )
{
fprintf( stdnimp, "STUB: RemoveFontResource32W(%p)\n", str );
return TRUE;

2
if1632/builtin.c
View File

@ -154,7 +154,7 @@ static BUILTIN_DLL BuiltinDLLs[] =
{ &GDI32_Descriptor, 0 },
{ &KERNEL32_Descriptor, DLL_FLAG_ALWAYS_USED },
{ &LZ32_Descriptor, 0 },
{ &MPR_Descriptor, 0 },
{ &MPR_Descriptor, DLL_FLAG_NOT_USED },
{ &NTDLL_Descriptor, 0 },
{ &SHELL32_Descriptor, 0 },
{ &USER32_Descriptor, 0 },

2
if1632/comctl32.spec
View File

@ -20,7 +20,7 @@ base 2
11 stub MakeDragList
12 stub LBItemFromPt
13 stub DrawInsert
14 stub CreateUpDownControl
14 stdcall CreateUpDownControl(long long long long long long long long long long long long) CreateUpDownControl
15 stdcall InitCommonControls() InitCommonControls
16 stub CreateStatusWindow
17 stub CreateStatusWindowW

6
if1632/crtdll.spec
View File

@ -131,7 +131,7 @@ base 1
126 stub _getpid
127 stub _getsystime
128 stub _getw
129 stub _global_unwind2
129 register _global_unwind2(ptr) CRTDLL__global_unwind2
130 stub _heapchk
131 stub _heapmin
132 stub _heapset
@ -175,7 +175,7 @@ base 1
170 stub _kbhit
171 stub _lfind
172 stub _loaddll
173 stub _local_unwind2
173 register _local_unwind2(ptr long) CRTDLL__local_unwind2
174 stub _locking
175 stub _logb
176 stub _lrotl
@ -461,7 +461,7 @@ base 1
456 cdecl sin(long) CRTDLL_sin
457 cdecl sinh(long) CRTDLL_sinh
458 cdecl sprintf() CRTDLL_sprintf
459 cdecl sqrt(long) CRTDLL_sqrt
459 cdecl sqrt(long long) CRTDLL_sqrt
460 cdecl srand(long) CRTDLL_srand
461 cdecl sscanf() CRTDLL_sscanf
462 cdecl strcat(ptr ptr) strcat

94
if1632/dummy.c
View File

@ -1,47 +1,49 @@
#include <stdio.h>
long stub_GDI_379(void) { fprintf(stderr, "Warning: GDI_379:STARTPAGE unimplemented stub\n"); return 1; }
long stub_GDI_380(void) { fprintf(stderr, "Warning: GDI_380:ENDPAGE unimplemented stub\n"); return 1; }
long stub_GDI_381(void) { fprintf(stderr, "Warning: GDI_381:SETABORTPROC unimplemented stub\n"); return 1; }
long stub_GDI_382(void) { fprintf(stderr, "Warning: GDI_382:ABORTPROC unimplemented stub\n"); return 1; }
long stub_GDI_530(void) { fprintf(stderr, "Warning: GDI_530: unimplemented stub\n"); return 0; }
long stub_GDI_531(void) { fprintf(stderr, "Warning: GDI_531: unimplemented stub\n"); return 0; }
long stub_GDI_532(void) { fprintf(stderr, "Warning: GDI_532: unimplemented stub\n"); return 0; }
long stub_GDI_536(void) { fprintf(stderr, "Warning: GDI_536: unimplemented stub\n"); return 0; }
long stub_GDI_538(void) { fprintf(stderr, "Warning: GDI_538: unimplemented stub\n"); return 0; }
long stub_GDI_540(void) { fprintf(stderr, "Warning: GDI_540: unimplemented stub\n"); return 0; }
long stub_GDI_543(void) { fprintf(stderr, "Warning: GDI_543: unimplemented stub\n"); return 0; }
long stub_GDI_555(void) { fprintf(stderr, "Warning: GDI_555: unimplemented stub\n"); return 0; }
long stub_GDI_560(void) { fprintf(stderr, "Warning: GDI_560: unimplemented stub\n"); return 0; }
long stub_GDI_561(void) { fprintf(stderr, "Warning: GDI_561: unimplemented stub\n"); return 0; }
long stub_GDI_564(void) { fprintf(stderr, "Warning: GDI_564: unimplemented stub\n"); return 0; }
long stub_GDI_565(void) { fprintf(stderr, "Warning: GDI_565: unimplemented stub\n"); return 0; }
long stub_GDI_566(void) { fprintf(stderr, "Warning: GDI_566: unimplemented stub\n"); return 0; }
long stub_GDI_571(void) { fprintf(stderr, "Warning: GDI_571: unimplemented stub\n"); return 0; }
long stub_GDI_572(void) { fprintf(stderr, "Warning: GDI_572: unimplemented stub\n"); return 0; }
long stub_GDI_573(void) { fprintf(stderr, "Warning: GDI_573: unimplemented stub\n"); return 0; }
long stub_GDI_556(void) { fprintf(stderr, "Warning: GDI_556: unimplemented stub\n"); return 0; }
long stub_GDI_558(void) { fprintf(stderr, "Warning: GDI_558: unimplemented stub\n"); return 0; }
long stub_GDI_569(void) { fprintf(stderr, "Warning: GDI_569: unimplemented stub\n"); return 0; }
long stub_KERNEL_450(void) { fprintf(stderr, "Warning: KERNEL_450: unimplemented stub\n"); return 0; }
long stub_USER_489(void) { fprintf(stderr, "Warning: USER_489: unimplemented stub\n"); return 0; }
long stub_USER_490(void) { fprintf(stderr, "Warning: USER_490: unimplemented stub\n"); return 0; }
long stub_USER_492(void) { fprintf(stderr, "Warning: USER_492: unimplemented stub\n"); return 0; }
long stub_USER_496(void) { fprintf(stderr, "Warning: USER_496: unimplemented stub\n"); return 0; }
long stub_USER_902(void) { fprintf(stderr, "Warning: USER_902: unimplemented stub\n"); return 0; }
long stub_USER_905(void) { fprintf(stderr, "Warning: USER_905: unimplemented stub\n"); return 0; }
long stub_USER_906(void) { fprintf(stderr, "Warning: USER_906: unimplemented stub\n"); return 0; }
long stub_USER_907(void) { fprintf(stderr, "Warning: USER_907: unimplemented stub\n"); return 0; }
long stub_USER_909(void) { fprintf(stderr, "Warning: USER_909: unimplemented stub\n"); return 0; }
long stub_USER_910(void) { fprintf(stderr, "Warning: USER_910: unimplemented stub\n"); return 0; }
long stub_USER_911(void) { fprintf(stderr, "Warning: USER_911: unimplemented stub\n"); return 0; }
long stub_USER_912(void) { fprintf(stderr, "Warning: USER_912: unimplemented stub\n"); return 0; }
long stub_USER_913(void) { fprintf(stderr, "Warning: USER_913: unimplemented stub\n"); return 0; }
long stub_USER_914(void) { fprintf(stderr, "Warning: USER_914: unimplemented stub\n"); return 0; }
long stub_USER_915(void) { fprintf(stderr, "Warning: USER_915: unimplemented stub\n"); return 0; }
long stub_USER_916(void) { fprintf(stderr, "Warning: USER_916: unimplemented stub\n"); return 0; }
long stub_USER_918(void) { fprintf(stderr, "Warning: USER_918: unimplemented stub\n"); return 0; }
long stub_USER_919(void) { fprintf(stderr, "Warning: USER_919: unimplemented stub\n"); return 0; }
long stub_USER_920(void) { fprintf(stderr, "Warning: USER_920: unimplemented stub\n"); return 0; }
long stub_USER_922(void) { fprintf(stderr, "Warning: USER_922: unimplemented stub\n"); return 0; }
long stub_USER_923(void) { fprintf(stderr, "Warning: USER_923: unimplemented stub\n"); return 0; }
long stub_KERNEL_700(void) { fprintf(stderr, "Warning: KERNEL_700: unimplemented stub\n"); return 1; }
#include "wintypes.h"
long WINAPI stub_GDI_379(void) { fprintf(stderr, "Warning: GDI_379:STARTPAGE unimplemented stub\n"); return 1; }
long WINAPI stub_GDI_380(void) { fprintf(stderr, "Warning: GDI_380:ENDPAGE unimplemented stub\n"); return 1; }
long WINAPI stub_GDI_381(void) { fprintf(stderr, "Warning: GDI_381:SETABORTPROC unimplemented stub\n"); return 1; }
long WINAPI stub_GDI_382(void) { fprintf(stderr, "Warning: GDI_382:ABORTPROC unimplemented stub\n"); return 1; }
long WINAPI stub_GDI_530(void) { fprintf(stderr, "Warning: GDI_530: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_531(void) { fprintf(stderr, "Warning: GDI_531: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_532(void) { fprintf(stderr, "Warning: GDI_532: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_536(void) { fprintf(stderr, "Warning: GDI_536: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_538(void) { fprintf(stderr, "Warning: GDI_538: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_540(void) { fprintf(stderr, "Warning: GDI_540: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_543(void) { fprintf(stderr, "Warning: GDI_543: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_555(void) { fprintf(stderr, "Warning: GDI_555: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_560(void) { fprintf(stderr, "Warning: GDI_560: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_561(void) { fprintf(stderr, "Warning: GDI_561: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_564(void) { fprintf(stderr, "Warning: GDI_564: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_565(void) { fprintf(stderr, "Warning: GDI_565: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_566(void) { fprintf(stderr, "Warning: GDI_566: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_571(void) { fprintf(stderr, "Warning: GDI_571: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_572(void) { fprintf(stderr, "Warning: GDI_572: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_573(void) { fprintf(stderr, "Warning: GDI_573: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_556(void) { fprintf(stderr, "Warning: GDI_556: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_558(void) { fprintf(stderr, "Warning: GDI_558: unimplemented stub\n"); return 0; }
long WINAPI stub_GDI_569(void) { fprintf(stderr, "Warning: GDI_569: unimplemented stub\n"); return 0; }
long WINAPI stub_KERNEL_450(void) { fprintf(stderr, "Warning: KERNEL_450: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_489(void) { fprintf(stderr, "Warning: USER_489: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_490(void) { fprintf(stderr, "Warning: USER_490: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_492(void) { fprintf(stderr, "Warning: USER_492: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_496(void) { fprintf(stderr, "Warning: USER_496: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_902(void) { fprintf(stderr, "Warning: USER_902: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_905(void) { fprintf(stderr, "Warning: USER_905: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_906(void) { fprintf(stderr, "Warning: USER_906: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_907(void) { fprintf(stderr, "Warning: USER_907: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_909(void) { fprintf(stderr, "Warning: USER_909: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_910(void) { fprintf(stderr, "Warning: USER_910: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_911(void) { fprintf(stderr, "Warning: USER_911: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_912(void) { fprintf(stderr, "Warning: USER_912: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_913(void) { fprintf(stderr, "Warning: USER_913: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_914(void) { fprintf(stderr, "Warning: USER_914: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_915(void) { fprintf(stderr, "Warning: USER_915: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_916(void) { fprintf(stderr, "Warning: USER_916: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_918(void) { fprintf(stderr, "Warning: USER_918: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_919(void) { fprintf(stderr, "Warning: USER_919: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_920(void) { fprintf(stderr, "Warning: USER_920: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_922(void) { fprintf(stderr, "Warning: USER_922: unimplemented stub\n"); return 0; }
long WINAPI stub_USER_923(void) { fprintf(stderr, "Warning: USER_923: unimplemented stub\n"); return 0; }
long WINAPI stub_KERNEL_700(void) { fprintf(stderr, "Warning: KERNEL_700: unimplemented stub\n"); return 1; }
long WINAPI stub_KERNEL_449(void) { fprintf(stderr, "Warning: KERNEL_449: unimplemented stub\n"); return 0; }

2
if1632/gdi.spec
View File

@ -314,7 +314,7 @@ file gdi.exe
ScaleViewportExtEx16
485 pascal16 ScaleWindowExtEx(word s_word s_word s_word s_word ptr)
ScaleWindowExtEx16
486 stub GETASPECTRATIOFILTEREX
486 pascal16 GetAspectRatioFilterEx(word ptr) GetAspectRatioFilterEx16
489 stub CreateDIBSection
490 stub CloseEnhMetafile
491 stub CopyEnhMetafile

2
if1632/gdi32.spec
View File

@ -391,7 +391,7 @@ base 1
0379 stub GdiWinWatchOpen
0380 stub GetGlyphOutlineWow
0381 stub GetTextCharsetInfo
0382 stub TranslateCharsetInfo
0382 stdcall TranslateCharsetInfo(ptr ptr long) TranslateCharSetInfo
0383 stub UpdateICMRegKeyA
0384 stub UpdateICMRegKeyW
0385 stub gdiPlaySpoolStream

7
if1632/kernel.spec
View File

@ -243,6 +243,7 @@ file krnl386.exe
318 stub FatalExitHook
319 stub FlushCachedFileHandle
320 pascal16 IsTask(word) IsTask
321 stub KERNEL_321
323 return IsRomModule 2 0
324 pascal16 LogError(word ptr) LogError
325 pascal16 LogParamError(word ptr ptr) LogParamError
@ -304,7 +305,7 @@ file krnl386.exe
445 stub KERNEL_445
446 stub KERNEL_446
447 stub KERNEL_447
449 stub KERNEL_449
449 pascal KERNEL_449() stub_KERNEL_449
450 pascal16 KERNEL_450() stub_KERNEL_450
454 stub KERNEL_454
455 stub KERNEL_455
@ -321,7 +322,7 @@ file krnl386.exe
513 pascal LoadLibraryEx32W(ptr long long) LoadLibraryEx32W16
514 pascal16 FreeLibrary32W(long) FreeLibrary32
515 pascal GetProcAddress32W(long ptr) GetProcAddress32
516 stub GetVDMPointer32W
516 pascal GetVDMPointer32W(segptr long) GetVDMPointer32W
517 pascal CallProc32W() WIN16_CallProc32W
518 stub CallProcEx32W
519 stub KERNEL_519
@ -334,7 +335,7 @@ file krnl386.exe
612 stub KERNEL_612
613 stub KERNEL_613
614 stub KERNEL_614
619 stub KERNEL_619
619 pascal KERNEL_619(word long long) _KERNEL_619
621 stub KERNEL_621
627 stub IsBadFlatReadWritePtr
630 stub KERNEL_630

67
if1632/kernel32.spec
View File

@ -35,7 +35,7 @@ base 1
40 stdcall _KERNEL32_41(long long long long long) _KERNEL32_41
41 stub _KERNEL32_42
42 stdcall _KERNEL32_43(long ptr long ptr ptr) _KERNEL32_43
44 register _KERNEL32_45(long) _KERNEL32_45
44 register _KERNEL32_45() _KERNEL32_45
45 stdcall _KERNEL32_46(long long long long long) _KERNEL32_46
46 stub _KERNEL32_47
@ -44,7 +44,7 @@ base 1
51 register _KERNEL32_52(long) _KERNEL32_52
# WOW calls
53 stub WOWCallback16
53 stdcall WOWCallback16(long long) WOWCallback16
54 stub WOWCallback16Ex
55 stdcall WOWGetVDMPointer(long long long) WOWGetVDMPointer
56 stub WOWHandle32
@ -53,7 +53,7 @@ base 1
59 stub WOWGlobalLock16
60 stub WOWGlobalUnlock16
61 stub WOWGlobalFree16
62 stub WOWGlobalAllocLock16
62 stdcall WOWGlobalAllocLock16(long long ptr) WOWGlobalAllocLock16
63 stub WOWGlobalUnlockFree16
64 stub WOWGlobalLockSize16
65 stub WOWYield16
@ -78,10 +78,10 @@ base 1
84 stub RtlConvertUlongToLargeInteger
86 stdcall _KERNEL32_87() _KERNEL32_87
87 cdecl _KERNEL32_88(long long ptr) _KERNEL32_88
87 cdecl _KERNEL32_88() _KERNEL32_88
88 stub _KERNEL32_89
89 stub _KERNEL32_90
90 register _KERNEL32_91() _KERNEL32_91
89 register _KERNEL32_90() _KERNEL32_90
90 stub _KERNEL32_91
91 stub _KERNEL32_92
92 stdcall GETPWIN16LOCK(ptr) GetPWinLock
96 stub ENTERSYSLEVEL
@ -137,7 +137,7 @@ base 1
144 stub ConnectNamedPipe
145 stdcall ContinueDebugEvent(long long long) ContinueDebugEvent
146 stub ConvertDefaultLocale
147 stub ConvertToGlobalHandle
147 stdcall ConvertToGlobalHandle(long) ConvertToGlobalHandle
148 stdcall CopyFileA(ptr ptr long) CopyFile32A
149 stdcall CopyFileW(ptr ptr long) CopyFile32W
150 stub CreateConsoleScreenBuffer
@ -285,6 +285,7 @@ base 1
292 stdcall GetComputerNameA(ptr ptr) GetComputerName32A
293 stdcall GetComputerNameW(ptr ptr) GetComputerName32W
294 stdcall GetConsoleCP() GetConsoleCP
295 stub GetConsoleCursorInfo
296 stdcall GetConsoleMode(long ptr) GetConsoleMode
297 stdcall GetConsoleOutputCP() GetConsoleOutputCP
298 stdcall GetConsoleScreenBufferInfo(long ptr) GetConsoleScreenBufferInfo
@ -368,7 +369,7 @@ base 1
376 stub GetProcessShutdownParameters
377 stdcall GetProcessTimes(long ptr ptr ptr ptr) GetProcessTimes
378 stdcall GetProcessVersion(long) GetProcessVersion
379 stub GetProcessWorkingSetSize
379 stdcall GetProcessWorkingSetSize(long ptr ptr) GetProcessWorkingSetSize
380 stub GetProductName
381 stdcall GetProfileIntA(ptr ptr long) GetProfileInt32A
382 stdcall GetProfileIntW(ptr ptr long) GetProfileInt32W
@ -407,7 +408,7 @@ base 1
415 stdcall GetThreadContext(long ptr) GetThreadContext
416 stdcall GetThreadLocale() GetThreadLocale
417 stdcall GetThreadPriority(long) GetThreadPriority
418 stub GetThreadSelectorEntry
418 stdcall GetThreadSelectorEntry(long long ptr) GetThreadSelectorEntry
419 stub GetThreadTimes
420 stdcall GetTickCount() GetTickCount
421 stub GetTimeFormatA
@ -454,6 +455,7 @@ base 1
462 stdcall HeapFree(long long ptr) HeapFree
463 stdcall HeapLock(long) HeapLock
464 stdcall HeapReAlloc(long long ptr long) HeapReAlloc
465 stub HeapSetFlags
466 stdcall HeapSize(long long ptr) HeapSize
467 stdcall HeapUnlock(long) HeapUnlock
468 stdcall HeapValidate(long long ptr) HeapValidate
@ -461,10 +463,10 @@ base 1
470 stub InitAtomTable
471 stdcall InitializeCriticalSection(ptr) InitializeCriticalSection
472 stdcall InterlockedDecrement(ptr) InterlockedDecrement
473 stdcall InterlockedExchange(ptr) InterlockedExchange
473 stdcall InterlockedExchange(ptr long) InterlockedExchange
474 stdcall InterlockedIncrement(ptr) InterlockedIncrement
475 stub InvalidateNLSCache
476 stdcall IsBadCodePtr(ptr long) IsBadCodePtr32
476 stdcall IsBadCodePtr(ptr) IsBadCodePtr32
477 stdcall IsBadHugeReadPtr(ptr long) IsBadHugeReadPtr32
478 stdcall IsBadHugeWritePtr(ptr long) IsBadHugeWritePtr32
479 stdcall IsBadReadPtr(ptr long) IsBadReadPtr32
@ -483,7 +485,7 @@ base 1
492 stub LCMapStringW
493 stdcall LeaveCriticalSection(ptr) LeaveCriticalSection
494 stdcall LoadLibraryA(ptr) LoadLibrary32A
495 stub LoadLibraryExA
495 stdcall LoadLibraryExA(ptr long long) LoadLibraryEx32A
496 stub LoadLibraryExW
497 stdcall LoadLibraryW(ptr) LoadLibrary32W
498 stub LoadModule
@ -510,9 +512,8 @@ base 1
519 stub MapHModuleLS
520 stub MapHModuleSL
521 stdcall MapLS(ptr) MapLS
643 stdcall MapSL(long) MapSL
522 stdcall MapSL(long) MapSL
523 stub MapSLFix
522 stub MapSL
524 stdcall MapViewOfFile(long long long long long) MapViewOfFile
525 stdcall MapViewOfFileEx(long long long long long ptr) MapViewOfFileEx
526 stub Module32First
@ -523,6 +524,7 @@ base 1
531 stdcall MoveFileW(ptr ptr) MoveFile32W
532 stdcall MulDiv(long long long) MulDiv32
533 stdcall MultiByteToWideChar(long long ptr long ptr long) MultiByteToWideChar
534 stub NotifyNLSUserCache
535 stdcall OpenEventA(long long ptr) OpenEvent32A
536 stdcall OpenEventW(long long ptr) OpenEvent32W
537 stdcall OpenFile(ptr ptr long) OpenFile32
@ -546,7 +548,7 @@ base 1
555 stub Process32Next
556 stub PulseEvent
557 stub PurgeComm
558 stub QT_Thunk
558 register QT_Thunk() QT_Thunk
559 stdcall QueryDosDeviceA(ptr ptr long) QueryDosDevice32A
560 stdcall QueryDosDeviceW(ptr ptr long) QueryDosDevice32W
561 stub QueryNumberOfEventLogRecords
@ -566,7 +568,7 @@ base 1
575 stdcall ReadConsoleW(long ptr long ptr ptr) ReadConsole32W
576 stdcall ReadFile(long ptr long ptr ptr) ReadFile
577 stub ReadFileEx
578 stub ReadProcessMemory
578 stdcall ReadProcessMemory(long ptr ptr long ptr) ReadProcessMemory
579 stub RegisterServiceProcess
580 stdcall ReinitializeCriticalSection(ptr) ReinitializeCriticalSection
581 stdcall ReleaseMutex(long) ReleaseMutex
@ -579,16 +581,16 @@ base 1
588 stdcall RtlMoveMemory(ptr ptr long) RtlMoveMemory
589 register RtlUnwind(ptr long ptr long) RtlUnwind
590 stdcall RtlZeroMemory(ptr long) RtlZeroMemory
591 stub SMapLS
592 stub SMapLS_IP_EBP_12
593 stub SMapLS_IP_EBP_16
594 stub SMapLS_IP_EBP_20
595 stub SMapLS_IP_EBP_24
596 stub SMapLS_IP_EBP_28
597 stub SMapLS_IP_EBP_32
598 stub SMapLS_IP_EBP_36
599 stub SMapLS_IP_EBP_40
600 stub SMapLS_IP_EBP_8
591 register SMapLS() SMapLS
592 register SMapLS_IP_EBP_12() SMapLS_IP_EBP_12
593 register SMapLS_IP_EBP_16() SMapLS_IP_EBP_16
594 register SMapLS_IP_EBP_20() SMapLS_IP_EBP_20
595 register SMapLS_IP_EBP_24() SMapLS_IP_EBP_24
596 register SMapLS_IP_EBP_28() SMapLS_IP_EBP_28
597 register SMapLS_IP_EBP_32() SMapLS_IP_EBP_32
598 register SMapLS_IP_EBP_36() SMapLS_IP_EBP_36
599 register SMapLS_IP_EBP_40() SMapLS_IP_EBP_40
600 register SMapLS_IP_EBP_8() SMapLS_IP_EBP_8
601 stub SUnMapLS
602 stub SUnMapLS_IP_EBP_12
603 stub SUnMapLS_IP_EBP_16
@ -648,8 +650,8 @@ base 1
657 stub SetMailslotInfo
658 stub SetNamedPipeHandleState
659 stdcall SetPriorityClass(long long) SetPriorityClass
660 stub SetProcessShutdownParameters
661 stub SetProcessWorkingSetSize
660 stdcall SetProcessShutdownParameters(long long) SetProcessShutdownParameters
661 stdcall SetProcessWorkingSetSize(long long long) SetProcessWorkingSetSize
662 stdcall SetStdHandle(long long) SetStdHandle
663 stdcall SetSystemPowerState(long long) SetSystemPowerState
664 stdcall SetSystemTime(ptr) SetSystemTime
@ -672,11 +674,12 @@ base 1
681 stdcall SystemTimeToFileTime(ptr ptr) SystemTimeToFileTime
682 stub SystemTimeToTzSpecificLocalTime
683 stub TerminateProcess
684 stub TerminateThread
684 stdcall TerminateThread(long long) TerminateThread
685 stub Thread32First
686 stub Thread32Next
687 stdcall ThunkConnect32(ptr ptr ptr ptr ptr ptr) ThunkConnect32
688 stdcall TlsAlloc() TlsAlloc
689 stub TlsAllocInternal
690 stdcall TlsFree(long) TlsFree
691 stub TlsFreeInternal
692 stdcall TlsGetValue(long) TlsGetValue
@ -710,7 +713,7 @@ base 1
720 stub WaitForMultipleObjects
721 stub WaitForMultipleObjectsEx
722 stdcall WaitForSingleObject(long long) WaitForSingleObject
723 stub WaitForSingleObjectEx
723 stdcall WaitForSingleObjectEx(long long long) WaitForSingleObjectEx
724 stub WaitNamedPipeA
725 stub WaitNamedPipeW
726 stdcall WideCharToMultiByte(long long ptr long ptr long ptr ptr) WideCharToMultiByte
@ -798,8 +801,6 @@ base 1
805 stub GetConsoleCommandHistoryLengthA
806 stub GetConsoleCommandHistoryLengthW
807 stub GetConsoleCommandHistoryW
808 stub GetConsoleCursorInfo
809 stub GetConsoleCursorInfo
810 stub GetConsoleDisplayMode
811 stub GetConsoleFontInfo
812 stub GetConsoleFontSize
@ -812,12 +813,10 @@ base 1
819 stub HeapCreateTagsW
820 stub HeapExtend
821 stub HeapQueryTagW
822 stub HeapSetFlags
823 stub HeapSummary
824 stub HeapUsage
825 stub InvalidateConsoleDIBits
826 stub IsDebuggerPresent
827 stub NotifyNLSUserCache
828 stub OpenConsoleW
829 stub QueryWin31IniFilesMappedToRegistry
830 stub RegisterConsoleVDM

1
if1632/mmsystem.spec
View File

@ -42,6 +42,7 @@ type win16
305 pascal MIDIINCLOSE(word) midiInClose
306 pascal MIDIINPREPAREHEADER(word segptr word) midiInPrepareHeader
307 pascal MIDIINUNPREPAREHEADER(word segptr word) midiInUnprepareHeader
308 pascal MIDIINADDBUFFER(word segptr word) midiInAddBuffer
309 pascal MIDIINSTART(word) midiInStart
310 pascal MIDIINSTOP(word) midiInStop
311 pascal MIDIINRESET(word) midiInReset

16
if1632/ntdll.spec
View File

@ -874,20 +874,20 @@ base 0
870 stub _snwprintf
871 stub _splitpath
872 stub _strcmpi
873 stub _stricmp
873 stdcall _stricmp(ptr ptr) lstrcmpi32A
874 stub _strlwr
875 stub _strnicmp
876 stdcall _strupr(ptr) CRTDLL__strupr
877 stub _ultoa
878 stub _vsnprintf
879 stdcall _wcsicmp(ptr ptr) lstrcmpi32W
880 stub _wcslwr
881 stub _wcsnicmp
882 stub _wcsupr
880 stdcall _wcslwr(ptr) CRTDLL__wcslwr
881 stdcall _wcsnicmp(ptr ptr long) lstrncmpi32W
882 stdcall _wcsupr(ptr) CRTDLL__wcsupr
883 stub abs
884 stub atan
885 stdcall atoi(ptr) CRTDLL_atoi
886 stub atol
886 stdcall atol(ptr) CRTDLL_atol
887 stub ceil
888 stub cos
889 stub fabs
@ -917,10 +917,10 @@ base 0
913 stdcall sscanf() CRTDLL_sscanf
914 stub strcat
915 stdcall strchr(ptr long) strchr
916 stub strcmp
917 stub strcpy
916 stdcall strcmp(ptr ptr) lstrcmp32A
917 stdcall strcpy(ptr ptr) lstrcpy32A
918 stub strcspn
919 stub strlen
919 stdcall strlen(ptr) lstrlen32A
920 stub strncat
921 stub strncmp
922 stub strncpy

17
if1632/relay.c
View File

@ -35,6 +35,7 @@ BOOL32 RELAY_Init(void)
extern void CALLTO16_Start(), CALLTO16_End();
extern void CALLTO16_Ret_word(), CALLTO16_Ret_long();
extern int CALLTO32_LargeStack();
extern DWORD CALLTO16_RetAddr_word, CALLTO16_RetAddr_long;
codesel = GLOBAL_CreateBlock( GMEM_FIXED, (void *)CALLTO16_Start,
@ -49,6 +50,10 @@ BOOL32 RELAY_Init(void)
CALLTO16_RetAddr_long=MAKELONG( (int)CALLTO16_Ret_long-(int)CALLTO16_Start,
codesel );
/* Set the CallLargeStack function pointer */
IF1632_CallLargeStack = CALLTO32_LargeStack;
/* Initialize thunking */
return THUNK_Init();
@ -326,7 +331,7 @@ void RELAY_DebugCallTo32( unsigned int func, int nbargs, unsigned int arg1 )
/**********************************************************************
* Catch (KERNEL.55)
*/
INT16 Catch( LPCATCHBUF lpbuf )
INT16 WINAPI Catch( LPCATCHBUF lpbuf )
{
STACK16FRAME *pFrame = CURRENT_STACK16;
@ -363,7 +368,7 @@ INT16 Catch( LPCATCHBUF lpbuf )
/**********************************************************************
* Throw (KERNEL.56)
*/
INT16 Throw( LPCATCHBUF lpbuf, INT16 retval )
INT16 WINAPI Throw( LPCATCHBUF lpbuf, INT16 retval )
{
STACK16FRAME *pFrame;
WORD es = CURRENT_STACK16->es;
@ -394,8 +399,8 @@ INT16 Throw( LPCATCHBUF lpbuf, INT16 retval )
/**********************************************************************
* CallProc32W (KERNEL.56)
*/
DWORD
WIN16_CallProc32W() {
DWORD /*WINAPI*/ WIN16_CallProc32W()
{
DWORD *win_stack = (DWORD *)CURRENT_STACK16->args;
DWORD nrofargs = win_stack[0];
DWORD argconvmask = win_stack[1];
@ -429,6 +434,10 @@ WIN16_CallProc32W() {
break;
case 5: ret = CallTo32_5(proc32,args[0],args[1],args[2],args[3],args[4]);
break;
case 6: ret = CallTo32_6(proc32,args[0],args[1],args[2],args[3],args[4],args[5]);
break;
case 7: ret = CallTo32_7(proc32,args[0],args[1],args[2],args[3],args[4],args[5],args[6]);
break;
default:
/* FIXME: should go up to 32 arguments */
fprintf(stderr,"CallProc32W: unsupported number of arguments %ld, please report.\n",nrofargs);

9
if1632/shell32.spec
View File

@ -17,6 +17,7 @@ base 1
39 stdcall DragAcceptFiles(long long) DragAcceptFiles
40 stub DragFinish
42 stub DragQueryFile
47 stub SHELL32_47
48 stub DragQueryFileA
51 stub DragQueryFileAorW
52 stub DragQueryFileW
@ -31,9 +32,15 @@ base 1
136 stub ExtractIconExA
146 stub ExtractIconResInfoA
148 stub ExtractIconResInfoW
154 stub SHELL32_154
155 stub SHELL32_155
156 stub SHELL32_156
158 stub SHELL32_158
178 stub ExtractIconW
180 stub ExtractVersionResource16W
184 stub FindExecutableA
182 stub SHELL32_182
183 stub SHELL32_183
184 stdcall FindExecutableA(ptr ptr ptr) FindExecutable32A
185 stub FindExecutableW
186 return FreeIconList 4 0
187 stub InternalExtractIconListA

2
if1632/signal.c
View File

@ -28,7 +28,7 @@
#include "debugger.h"
#include "options.h"
#include "sigcontext.h"
#include "sig_context.h"
#include "miscemu.h"

642
if1632/thunk.c
View File

@ -1,7 +1,8 @@
/*
* Emulator thunks
* Emulator and Win95 thunks
*
* Copyright 1996 Alexandre Julliard
* Copyright 1997 Marcus Meissner
*/
#include "windows.h"
@ -134,8 +135,8 @@ static LRESULT THUNK_CallWndProc16( WNDPROC16 proc, HWND16 hwnd, UINT16 msg,
/***********************************************************************
* THUNK_EnumObjects16 (GDI.71)
*/
INT16 THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
GOBJENUMPROC16 func, LPARAM lParam )
INT16 WINAPI THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
GOBJENUMPROC16 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_ll );
return EnumObjects16( hdc, nObjType, (GOBJENUMPROC16)&thunk, lParam );
@ -145,8 +146,8 @@ INT16 THUNK_EnumObjects16( HDC16 hdc, INT16 nObjType,
/***********************************************************************
* THUNK_EnumObjects32 (GDI32.89)
*/
INT32 THUNK_EnumObjects32( HDC32 hdc, INT32 nObjType,
GOBJENUMPROC32 func, LPARAM lParam )
INT32 WINAPI THUNK_EnumObjects32( HDC32 hdc, INT32 nObjType,
GOBJENUMPROC32 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_2 );
return EnumObjects32( hdc, nObjType, (GOBJENUMPROC32)&thunk, lParam );
@ -156,8 +157,8 @@ INT32 THUNK_EnumObjects32( HDC32 hdc, INT32 nObjType,
/*************************************************************************
* THUNK_EnumFonts16 (GDI.70)
*/
INT16 THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
FONTENUMPROC16 func, LPARAM lParam )
INT16 WINAPI THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
FONTENUMPROC16 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_llwl );
return EnumFonts16( hdc, lpFaceName, (FONTENUMPROC16)&thunk, lParam );
@ -166,8 +167,8 @@ INT16 THUNK_EnumFonts16( HDC16 hdc, LPCSTR lpFaceName,
/*************************************************************************
* THUNK_EnumFonts32A (GDI32.84)
*/
INT32 THUNK_EnumFonts32A( HDC32 hdc, LPCSTR lpFaceName,
FONTENUMPROC32A func, LPARAM lParam )
INT32 WINAPI THUNK_EnumFonts32A( HDC32 hdc, LPCSTR lpFaceName,
FONTENUMPROC32A func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumFonts32A( hdc, lpFaceName, (FONTENUMPROC32A)&thunk, lParam );
@ -176,8 +177,8 @@ INT32 THUNK_EnumFonts32A( HDC32 hdc, LPCSTR lpFaceName,
/*************************************************************************
* THUNK_EnumFonts32W (GDI32.85)
*/
INT32 THUNK_EnumFonts32W( HDC32 hdc, LPCWSTR lpFaceName,
FONTENUMPROC32W func, LPARAM lParam )
INT32 WINAPI THUNK_EnumFonts32W( HDC32 hdc, LPCWSTR lpFaceName,
FONTENUMPROC32W func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumFonts32W( hdc, lpFaceName, (FONTENUMPROC32W)&thunk, lParam );
@ -186,8 +187,8 @@ INT32 THUNK_EnumFonts32W( HDC32 hdc, LPCWSTR lpFaceName,
/******************************************************************
* THUNK_EnumMetaFile16 (GDI.175)
*/
BOOL16 THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
MFENUMPROC16 func, LPARAM lParam )
BOOL16 WINAPI THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
MFENUMPROC16 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_wllwl );
return EnumMetaFile16( hdc, hmf, (MFENUMPROC16)&thunk, lParam );
@ -197,8 +198,8 @@ BOOL16 THUNK_EnumMetaFile16( HDC16 hdc, HMETAFILE16 hmf,
/*************************************************************************
* THUNK_EnumFontFamilies16 (GDI.330)
*/
INT16 THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
FONTENUMPROC16 func, LPARAM lParam )
INT16 WINAPI THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
FONTENUMPROC16 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_llwl );
return EnumFontFamilies16(hdc, lpszFamily, (FONTENUMPROC16)&thunk, lParam);
@ -208,8 +209,8 @@ INT16 THUNK_EnumFontFamilies16( HDC16 hdc, LPCSTR lpszFamily,
/*************************************************************************
* THUNK_EnumFontFamilies32A (GDI32.80)
*/
INT32 THUNK_EnumFontFamilies32A( HDC32 hdc, LPCSTR lpszFamily,
FONTENUMPROC32A func, LPARAM lParam )
INT32 WINAPI THUNK_EnumFontFamilies32A( HDC32 hdc, LPCSTR lpszFamily,
FONTENUMPROC32A func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumFontFamilies32A(hdc,lpszFamily,(FONTENUMPROC32A)&thunk,lParam);
@ -219,8 +220,8 @@ INT32 THUNK_EnumFontFamilies32A( HDC32 hdc, LPCSTR lpszFamily,
/*************************************************************************
* THUNK_EnumFontFamilies32W (GDI32.83)
*/
INT32 THUNK_EnumFontFamilies32W( HDC32 hdc, LPCWSTR lpszFamily,
FONTENUMPROC32W func, LPARAM lParam )
INT32 WINAPI THUNK_EnumFontFamilies32W( HDC32 hdc, LPCWSTR lpszFamily,
FONTENUMPROC32W func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumFontFamilies32W(hdc,lpszFamily,(FONTENUMPROC32W)&thunk,lParam);
@ -229,9 +230,9 @@ INT32 THUNK_EnumFontFamilies32W( HDC32 hdc, LPCWSTR lpszFamily,
/*************************************************************************
* THUNK_EnumFontFamiliesEx16 (GDI.613)
*/
INT16 THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
FONTENUMPROCEX16 func, LPARAM lParam,
DWORD reserved )
INT16 WINAPI THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
FONTENUMPROCEX16 func, LPARAM lParam,
DWORD reserved )
{
DECL_THUNK( thunk, func, CallTo16_word_llwl );
return EnumFontFamiliesEx16( hdc, lpLF, (FONTENUMPROCEX16)&thunk,
@ -242,9 +243,9 @@ INT16 THUNK_EnumFontFamiliesEx16( HDC16 hdc, LPLOGFONT16 lpLF,
/*************************************************************************
* THUNK_EnumFontFamiliesEx32A (GDI32.81)
*/
INT32 THUNK_EnumFontFamiliesEx32A( HDC32 hdc, LPLOGFONT32A lpLF,
FONTENUMPROCEX32A func, LPARAM lParam,
DWORD reserved)
INT32 WINAPI THUNK_EnumFontFamiliesEx32A( HDC32 hdc, LPLOGFONT32A lpLF,
FONTENUMPROCEX32A func, LPARAM lParam,
DWORD reserved)
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumFontFamiliesEx32A( hdc, lpLF, (FONTENUMPROCEX32A)&thunk,
@ -255,9 +256,9 @@ INT32 THUNK_EnumFontFamiliesEx32A( HDC32 hdc, LPLOGFONT32A lpLF,
/*************************************************************************
* THUNK_EnumFontFamiliesEx32W (GDI32.82)
*/
INT32 THUNK_EnumFontFamiliesEx32W( HDC32 hdc, LPLOGFONT32W lpLF,
FONTENUMPROCEX32W func, LPARAM lParam,
DWORD reserved )
INT32 WINAPI THUNK_EnumFontFamiliesEx32W( HDC32 hdc, LPLOGFONT32W lpLF,
FONTENUMPROCEX32W func, LPARAM lParam,
DWORD reserved )
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumFontFamiliesEx32W( hdc, lpLF, (FONTENUMPROCEX32W)&thunk,
@ -268,8 +269,8 @@ INT32 THUNK_EnumFontFamiliesEx32W( HDC32 hdc, LPLOGFONT32W lpLF,
/**********************************************************************
* THUNK_LineDDA16 (GDI.100)
*/
void THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd, INT16 nYEnd,
LINEDDAPROC16 func, LPARAM lParam )
void WINAPI THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd,
INT16 nYEnd, LINEDDAPROC16 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_wwl );
LineDDA16( nXStart, nYStart, nXEnd, nYEnd, (LINEDDAPROC16)&thunk, lParam );
@ -279,8 +280,8 @@ void THUNK_LineDDA16( INT16 nXStart, INT16 nYStart, INT16 nXEnd, INT16 nYEnd,
/**********************************************************************
* THUNK_LineDDA32 (GDI32.248)
*/
BOOL32 THUNK_LineDDA32( INT32 nXStart, INT32 nYStart, INT32 nXEnd, INT32 nYEnd,
LINEDDAPROC32 func, LPARAM lParam )
BOOL32 WINAPI THUNK_LineDDA32( INT32 nXStart, INT32 nYStart, INT32 nXEnd,
INT32 nYEnd, LINEDDAPROC32 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_3 );
return LineDDA32( nXStart, nYStart, nXEnd, nYEnd,
@ -291,7 +292,7 @@ BOOL32 THUNK_LineDDA32( INT32 nXStart, INT32 nYStart, INT32 nXEnd, INT32 nYEnd,
/*******************************************************************
* THUNK_EnumWindows16 (USER.54)
*/
BOOL16 THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
BOOL16 WINAPI THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_wl );
return EnumWindows16( (WNDENUMPROC16)&thunk, lParam );
@ -301,7 +302,7 @@ BOOL16 THUNK_EnumWindows16( WNDENUMPROC16 func, LPARAM lParam )
/*******************************************************************
* THUNK_EnumWindows32 (USER32.192)
*/
BOOL32 THUNK_EnumWindows32( WNDENUMPROC32 func, LPARAM lParam )
BOOL32 WINAPI THUNK_EnumWindows32( WNDENUMPROC32 func, LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_2 );
return EnumWindows32( (WNDENUMPROC32)&thunk, lParam );
@ -311,8 +312,8 @@ BOOL32 THUNK_EnumWindows32( WNDENUMPROC32 func, LPARAM lParam )
/**********************************************************************
* THUNK_EnumChildWindows16 (USER.55)
*/
BOOL16 THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
LPARAM lParam )
BOOL16 WINAPI THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_wl );
return EnumChildWindows16( parent, (WNDENUMPROC16)&thunk, lParam );
@ -322,8 +323,8 @@ BOOL16 THUNK_EnumChildWindows16( HWND16 parent, WNDENUMPROC16 func,
/**********************************************************************
* THUNK_EnumChildWindows32 (USER32.177)
*/
BOOL32 THUNK_EnumChildWindows32( HWND32 parent, WNDENUMPROC32 func,
LPARAM lParam )
BOOL32 WINAPI THUNK_EnumChildWindows32( HWND32 parent, WNDENUMPROC32 func,
LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_2 );
return EnumChildWindows32( parent, (WNDENUMPROC32)&thunk, lParam );
@ -333,8 +334,8 @@ BOOL32 THUNK_EnumChildWindows32( HWND32 parent, WNDENUMPROC32 func,
/**********************************************************************
* THUNK_EnumTaskWindows16 (USER.225)
*/
BOOL16 THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
LPARAM lParam )
BOOL16 WINAPI THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo16_word_wl );
return EnumTaskWindows16( hTask, (WNDENUMPROC16)&thunk, lParam );
@ -344,7 +345,8 @@ BOOL16 THUNK_EnumTaskWindows16( HTASK16 hTask, WNDENUMPROC16 func,
/**********************************************************************
* THUNK_EnumThreadWindows (USER32.189)
*/
BOOL32 THUNK_EnumThreadWindows( DWORD id, WNDENUMPROC32 func, LPARAM lParam )
BOOL32 WINAPI THUNK_EnumThreadWindows( DWORD id, WNDENUMPROC32 func,
LPARAM lParam )
{
DECL_THUNK( thunk, func, CallTo32_2 );
return EnumThreadWindows( id, (WNDENUMPROC32)&thunk, lParam );
@ -354,7 +356,7 @@ BOOL32 THUNK_EnumThreadWindows( DWORD id, WNDENUMPROC32 func, LPARAM lParam )
/***********************************************************************
* THUNK_EnumProps16 (USER.27)
*/
INT16 THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
INT16 WINAPI THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
{
DECL_THUNK( thunk, func, CallTo16_word_wlw );
return EnumProps16( hwnd, (PROPENUMPROC16)&thunk );
@ -364,7 +366,7 @@ INT16 THUNK_EnumProps16( HWND16 hwnd, PROPENUMPROC16 func )
/***********************************************************************
* THUNK_EnumProps32A (USER32.185)
*/
INT32 THUNK_EnumProps32A( HWND32 hwnd, PROPENUMPROC32A func )
INT32 WINAPI THUNK_EnumProps32A( HWND32 hwnd, PROPENUMPROC32A func )
{
DECL_THUNK( thunk, func, CallTo32_3 );
return EnumProps32A( hwnd, (PROPENUMPROC32A)&thunk );
@ -374,7 +376,7 @@ INT32 THUNK_EnumProps32A( HWND32 hwnd, PROPENUMPROC32A func )
/***********************************************************************
* THUNK_EnumProps32W (USER32.188)
*/
INT32 THUNK_EnumProps32W( HWND32 hwnd, PROPENUMPROC32W func )
INT32 WINAPI THUNK_EnumProps32W( HWND32 hwnd, PROPENUMPROC32W func )
{
DECL_THUNK( thunk, func, CallTo32_3 );
return EnumProps32W( hwnd, (PROPENUMPROC32W)&thunk );
@ -384,7 +386,8 @@ INT32 THUNK_EnumProps32W( HWND32 hwnd, PROPENUMPROC32W func )
/***********************************************************************
* THUNK_EnumPropsEx32A (USER32.186)
*/
INT32 THUNK_EnumPropsEx32A( HWND32 hwnd, PROPENUMPROCEX32A func, LPARAM lParam)
INT32 WINAPI THUNK_EnumPropsEx32A( HWND32 hwnd, PROPENUMPROCEX32A func,
LPARAM lParam)
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumPropsEx32A( hwnd, (PROPENUMPROCEX32A)&thunk, lParam );
@ -394,7 +397,8 @@ INT32 THUNK_EnumPropsEx32A( HWND32 hwnd, PROPENUMPROCEX32A func, LPARAM lParam)
/***********************************************************************
* THUNK_EnumPropsEx32W (USER32.187)
*/
INT32 THUNK_EnumPropsEx32W( HWND32 hwnd, PROPENUMPROCEX32W func, LPARAM lParam)
INT32 WINAPI THUNK_EnumPropsEx32W( HWND32 hwnd, PROPENUMPROCEX32W func,
LPARAM lParam)
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumPropsEx32W( hwnd, (PROPENUMPROCEX32W)&thunk, lParam );
@ -404,7 +408,8 @@ INT32 THUNK_EnumPropsEx32W( HWND32 hwnd, PROPENUMPROCEX32W func, LPARAM lParam)
/***********************************************************************
* THUNK_EnumSystemCodePages32A (KERNEL32.92)
*/
BOOL32 THUNK_EnumSystemCodePages32A( CODEPAGE_ENUMPROC32A func, DWORD flags )
BOOL32 WINAPI THUNK_EnumSystemCodePages32A( CODEPAGE_ENUMPROC32A func,
DWORD flags )
{
DECL_THUNK( thunk, func, CallTo32_1 );
return EnumSystemCodePages32A( (CODEPAGE_ENUMPROC32A)&thunk, flags );
@ -414,7 +419,8 @@ BOOL32 THUNK_EnumSystemCodePages32A( CODEPAGE_ENUMPROC32A func, DWORD flags )
/***********************************************************************
* THUNK_EnumSystemCodePages32W (KERNEL32.93)
*/
BOOL32 THUNK_EnumSystemCodePages32W( CODEPAGE_ENUMPROC32W func, DWORD flags )
BOOL32 WINAPI THUNK_EnumSystemCodePages32W( CODEPAGE_ENUMPROC32W func,
DWORD flags )
{
DECL_THUNK( thunk, func, CallTo32_1 );
return EnumSystemCodePages32W( (CODEPAGE_ENUMPROC32W)&thunk, flags );
@ -423,7 +429,7 @@ BOOL32 THUNK_EnumSystemCodePages32W( CODEPAGE_ENUMPROC32W func, DWORD flags )
/***********************************************************************
* THUNK_EnumSystemLocales32A (KERNEL32.92)
*/
BOOL32 THUNK_EnumSystemLocales32A( LOCALE_ENUMPROC32A func, DWORD flags )
BOOL32 WINAPI THUNK_EnumSystemLocales32A( LOCALE_ENUMPROC32A func, DWORD flags)
{
DECL_THUNK( thunk, func, CallTo32_1 );
return EnumSystemLocales32A( (LOCALE_ENUMPROC32A)&thunk, flags );
@ -433,7 +439,7 @@ BOOL32 THUNK_EnumSystemLocales32A( LOCALE_ENUMPROC32A func, DWORD flags )
/***********************************************************************
* THUNK_EnumSystemLocales32W (KERNEL32.93)
*/
BOOL32 THUNK_EnumSystemLocales32W( LOCALE_ENUMPROC32W func, DWORD flags )
BOOL32 WINAPI THUNK_EnumSystemLocales32W( LOCALE_ENUMPROC32W func, DWORD flags)
{
DECL_THUNK( thunk, func, CallTo32_1 );
return EnumSystemLocales32W( (LOCALE_ENUMPROC32W)&thunk, flags );
@ -442,7 +448,10 @@ BOOL32 THUNK_EnumSystemLocales32W( LOCALE_ENUMPROC32W func, DWORD flags )
/***********************************************************************
* THUNK_EnumResourceLanguages32W (KERNEL32.87)
*/
BOOL32 THUNK_EnumResourceLanguages32W( HMODULE32 hmod,LPCWSTR type,LPCWSTR name,ENUMRESLANGPROC32W func, LONG lParam )
BOOL32 WINAPI THUNK_EnumResourceLanguages32W( HMODULE32 hmod, LPCWSTR type,
LPCWSTR name,
ENUMRESLANGPROC32W func,
LONG lParam )
{
DECL_THUNK( thunk, func, CallTo32_5 );
return EnumResourceLanguages32W( hmod,type,name,(ENUMRESLANGPROC32W)&thunk, lParam );
@ -451,7 +460,10 @@ BOOL32 THUNK_EnumResourceLanguages32W( HMODULE32 hmod,LPCWSTR type,LPCWSTR name,
/***********************************************************************
* THUNK_EnumResourceLanguages32A (KERNEL32.86)
*/
BOOL32 THUNK_EnumResourceLanguages32A( HMODULE32 hmod,LPCSTR type,LPCSTR name,ENUMRESLANGPROC32A func, LONG lParam )
BOOL32 WINAPI THUNK_EnumResourceLanguages32A( HMODULE32 hmod, LPCSTR type,
LPCSTR name,
ENUMRESLANGPROC32A func,
LONG lParam )
{
DECL_THUNK( thunk, func, CallTo32_5 );
return EnumResourceLanguages32A( hmod,type,name,(ENUMRESLANGPROC32A)&thunk, lParam );
@ -460,8 +472,8 @@ BOOL32 THUNK_EnumResourceLanguages32A( HMODULE32 hmod,LPCSTR type,LPCSTR name,EN
/***********************************************************************
* THUNK_EnumResourceNames32A (KERNEL32.88)
*/
BOOL32 THUNK_EnumResourceNames32A( HMODULE32 hmod, LPCSTR type,
ENUMRESNAMEPROC32A func, LONG lParam )
BOOL32 WINAPI THUNK_EnumResourceNames32A( HMODULE32 hmod, LPCSTR type,
ENUMRESNAMEPROC32A func, LONG lParam)
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumResourceNames32A( hmod,type,(ENUMRESNAMEPROC32A)&thunk,lParam );
@ -470,8 +482,8 @@ BOOL32 THUNK_EnumResourceNames32A( HMODULE32 hmod, LPCSTR type,
/***********************************************************************
* THUNK_EnumResourceNames32W (KERNEL32.89)
*/
BOOL32 THUNK_EnumResourceNames32W( HMODULE32 hmod, LPCWSTR type,
ENUMRESNAMEPROC32W func, LONG lParam )
BOOL32 WINAPI THUNK_EnumResourceNames32W( HMODULE32 hmod, LPCWSTR type,
ENUMRESNAMEPROC32W func, LONG lParam)
{
DECL_THUNK( thunk, func, CallTo32_4 );
return EnumResourceNames32W( hmod,type,(ENUMRESNAMEPROC32W)&thunk, lParam);
@ -480,7 +492,8 @@ BOOL32 THUNK_EnumResourceNames32W( HMODULE32 hmod, LPCWSTR type,
/***********************************************************************
* THUNK_EnumResourceTypes32A (KERNEL32.90)
*/
BOOL32 THUNK_EnumResourceTypes32A( HMODULE32 hmod,ENUMRESTYPEPROC32A func, LONG lParam )
BOOL32 WINAPI THUNK_EnumResourceTypes32A( HMODULE32 hmod,
ENUMRESTYPEPROC32A func, LONG lParam)
{
DECL_THUNK( thunk, func, CallTo32_3 );
return EnumResourceTypes32A( hmod,(ENUMRESTYPEPROC32A)&thunk, lParam );
@ -489,7 +502,9 @@ BOOL32 THUNK_EnumResourceTypes32A( HMODULE32 hmod,ENUMRESTYPEPROC32A func, LONG
/***********************************************************************
* THUNK_EnumResourceTypes32W (KERNEL32.91)
*/
BOOL32 THUNK_EnumResourceTypes32W( HMODULE32 hmod,ENUMRESTYPEPROC32W func, LONG lParam )
BOOL32 WINAPI THUNK_EnumResourceTypes32W( HMODULE32 hmod,
ENUMRESTYPEPROC32W func,
LONG lParam )
{
DECL_THUNK( thunk, func, CallTo32_3 );
return EnumResourceTypes32W( hmod,(ENUMRESTYPEPROC32W)&thunk, lParam );
@ -499,9 +514,10 @@ BOOL32 THUNK_EnumResourceTypes32W( HMODULE32 hmod,ENUMRESTYPEPROC32W func, LONG
/***********************************************************************
* THUNK_GrayString16 (USER.185)
*/
BOOL16 THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr, GRAYSTRINGPROC16 func,
LPARAM lParam, INT16 cch, INT16 x, INT16 y,
INT16 cx, INT16 cy )
BOOL16 WINAPI THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr,
GRAYSTRINGPROC16 func, LPARAM lParam,
INT16 cch, INT16 x, INT16 y,
INT16 cx, INT16 cy )
{
DECL_THUNK( thunk, func, CallTo16_word_wlw );
if (!func)
@ -515,9 +531,10 @@ BOOL16 THUNK_GrayString16( HDC16 hdc, HBRUSH16 hbr, GRAYSTRINGPROC16 func,
/***********************************************************************
* THUNK_GrayString32A (USER32.314)
*/
BOOL32 THUNK_GrayString32A( HDC32 hdc, HBRUSH32 hbr, GRAYSTRINGPROC32 func,
LPARAM lParam, INT32 cch, INT32 x, INT32 y,
INT32 cx, INT32 cy )
BOOL32 WINAPI THUNK_GrayString32A( HDC32 hdc, HBRUSH32 hbr,
GRAYSTRINGPROC32 func, LPARAM lParam,
INT32 cch, INT32 x, INT32 y,
INT32 cx, INT32 cy )
{
DECL_THUNK( thunk, func, CallTo32_3 );
if (!func)
@ -531,9 +548,10 @@ BOOL32 THUNK_GrayString32A( HDC32 hdc, HBRUSH32 hbr, GRAYSTRINGPROC32 func,
/***********************************************************************
* THUNK_GrayString32W (USER32.315)
*/
BOOL32 THUNK_GrayString32W( HDC32 hdc, HBRUSH32 hbr, GRAYSTRINGPROC32 func,
LPARAM lParam, INT32 cch, INT32 x, INT32 y,
INT32 cx, INT32 cy )
BOOL32 WINAPI THUNK_GrayString32W( HDC32 hdc, HBRUSH32 hbr,
GRAYSTRINGPROC32 func,
LPARAM lParam, INT32 cch, INT32 x, INT32 y,
INT32 cx, INT32 cy )
{
DECL_THUNK( thunk, func, CallTo32_3 );
if (!func)
@ -547,7 +565,7 @@ BOOL32 THUNK_GrayString32W( HDC32 hdc, HBRUSH32 hbr, GRAYSTRINGPROC32 func,
/***********************************************************************
* THUNK_SetWindowsHook16 (USER.121)
*/
FARPROC16 THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
FARPROC16 WINAPI THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
{
HINSTANCE16 hInst = FarGetOwner( HIWORD(proc) );
HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
@ -560,7 +578,7 @@ FARPROC16 THUNK_SetWindowsHook16( INT16 id, HOOKPROC16 proc )
/***********************************************************************
* THUNK_UnhookWindowsHook16 (USER.234)
*/
BOOL16 THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
BOOL16 WINAPI THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
{
BOOL16 ret;
THUNK *thunk = THUNK_Find( (FARPROC16)proc );
@ -574,8 +592,8 @@ BOOL16 THUNK_UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
/***********************************************************************
* THUNK_SetWindowsHookEx16 (USER.291)
*/
HHOOK THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
HTASK16 hTask )
HHOOK WINAPI THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc,
HINSTANCE16 hInst, HTASK16 hTask )
{
THUNK *thunk = THUNK_Alloc( (FARPROC16)proc, (RELAY)CallTo16_long_wwl );
if (!thunk) return 0;
@ -586,7 +604,7 @@ HHOOK THUNK_SetWindowsHookEx16( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
/***********************************************************************
* THUNK_UnhookWindowHookEx16 (USER.292)
*/
BOOL16 THUNK_UnhookWindowsHookEx16( HHOOK hhook )
BOOL16 WINAPI THUNK_UnhookWindowsHookEx16( HHOOK hhook )
{
THUNK *thunk = (THUNK *)HOOK_GetProc16( hhook );
BOOL16 ret = UnhookWindowsHookEx16( hhook );
@ -598,7 +616,7 @@ BOOL16 THUNK_UnhookWindowsHookEx16( HHOOK hhook )
/***********************************************************************
* THUNK_CreateSystemTimer (SYSTEM.2)
*/
WORD THUNK_CreateSystemTimer( WORD rate, FARPROC16 callback )
WORD WINAPI THUNK_CreateSystemTimer( WORD rate, FARPROC16 callback )
{
THUNK *thunk = THUNK_Alloc( callback, (RELAY)CallTo16_word_ );
if (!thunk) return 0;
@ -609,7 +627,7 @@ WORD THUNK_CreateSystemTimer( WORD rate, FARPROC16 callback )
/***********************************************************************
* THUNK_KillSystemTimer (SYSTEM.3)
*/
WORD THUNK_KillSystemTimer( WORD timer )
WORD WINAPI THUNK_KillSystemTimer( WORD timer )
{
extern WORD SYSTEM_KillSystemTimer( WORD timer ); /* misc/system.c */
extern FARPROC16 SYSTEM_GetTimerProc( WORD timer ); /* misc/system.c */
@ -624,7 +642,7 @@ WORD THUNK_KillSystemTimer( WORD timer )
/***********************************************************************
* THUNK_SetUnhandledExceptionFilter (KERNEL32.516)
*/
LPTOP_LEVEL_EXCEPTION_FILTER THUNK_SetUnhandledExceptionFilter(
LPTOP_LEVEL_EXCEPTION_FILTER WINAPI THUNK_SetUnhandledExceptionFilter(
LPTOP_LEVEL_EXCEPTION_FILTER filter )
{
LPTOP_LEVEL_EXCEPTION_FILTER old;
@ -644,7 +662,7 @@ static FARPROC16 defDCHookProc = NULL;
/***********************************************************************
* THUNK_SetDCHook (GDI.190)
*/
BOOL16 THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
BOOL16 WINAPI THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
{
THUNK *thunk, *oldThunk;
@ -669,7 +687,7 @@ BOOL16 THUNK_SetDCHook( HDC16 hdc, FARPROC16 proc, DWORD dwHookData )
/***********************************************************************
* THUNK_GetDCHook (GDI.191)
*/
DWORD THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
DWORD WINAPI THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
{
THUNK *thunk = NULL;
DWORD ret = GetDCHook( hdc, (FARPROC16 *)&thunk );
@ -687,19 +705,81 @@ DWORD THUNK_GetDCHook( HDC16 hdc, FARPROC16 *phookProc )
return ret;
}
/***********************************************************************
* *
* Win95 internal thunks *
* *
***********************************************************************/
/***********************************************************************
* Generates a FT_Prolog call.
*
* 0FB6D1 movzbl edx,cl
* 8B1495xxxxxxxx mov edx,[4*edx + xxxxxxxx]
* 68xxxxxxxx push FT_Prolog
* C3 lret
*/
static void _write_ftprolog(LPBYTE start,DWORD thunkstart) {
LPBYTE x;
x = start;
*x++ = 0x0f;*x++=0xb6;*x++=0xd1; /* movzbl edx,cl */
*x++ = 0x8B;*x++=0x14;*x++=0x95;*(DWORD*)x= thunkstart;
x+=4; /* mov edx, [4*edx + thunkstart] */
*x++ = 0x68; *(DWORD*)x = (DWORD)GetProcAddress32(WIN32_GetModuleHandleA("KERNEL32"),"FT_Prolog");
x+=4; /* push FT_Prolog */
*x++ = 0xC3; /* lret */
/* fill rest with 0xCC / int 3 */
}
/***********************************************************************
* Generates a QT_Thunk style call.
*
* 33C9 xor ecx, ecx
* 8A4DFC mov cl , [ebp-04]
* 8B148Dxxxxxxxx mov edx, [4*ecx + (EAX+EDX)]
* B8yyyyyyyy mov eax, QT_Thunk
* FFE0 jmp eax
*/
static void _write_qtthunk(LPBYTE start,DWORD thunkstart) {
LPBYTE x;
x = start;
*x++ = 0x33;*x++=0xC9; /* xor ecx,ecx */
*x++ = 0x8A;*x++=0x4D;*x++=0xFC; /* movb cl,[ebp-04] */
*x++ = 0x8B;*x++=0x14;*x++=0x8D;*(DWORD*)x= thunkstart;
x+=4; /* mov edx, [4*ecx + (EAX+EDX) */
*x++ = 0xB8; *(DWORD*)x = (DWORD)GetProcAddress32(WIN32_GetModuleHandleA("KERNEL32"),"QT_Thunk");
x+=4; /* mov eax , QT_Thunk */
*x++ = 0xFF; *x++ = 0xE0; /* jmp eax */
/* should fill the rest of the 32 bytes with 0xCC */
}
/***********************************************************************
* ThunkConnect32 (KERNEL32)
* Connects a 32bit and a 16bit thunkbuffer.
*/
struct thunkstruct
{
char magic[4];
DWORD x1;
DWORD x2;
DWORD length;
DWORD ptr;
DWORD x0C;
DWORD x10;
DWORD x14;
DWORD x18;
DWORD x1C;
DWORD x20;
};
UINT32 ThunkConnect32( struct thunkstruct *ths, LPSTR thunkfun16,
LPSTR module16, LPSTR module32, HMODULE32 hmod32,
DWORD dllinitarg1 )
UINT32 WINAPI ThunkConnect32( struct thunkstruct *ths, LPSTR thunkfun16,
LPSTR module16, LPSTR module32, HMODULE32 hmod32,
DWORD dllinitarg1 )
{
HINSTANCE16 hmm;
SEGPTR thkbuf;
struct thunkstruct *ths16;
fprintf(stdnimp,"ThunkConnect32(<struct>,%s,%s,%s,%x,%lx)\n",
thunkfun16,module32,module16,hmod32,dllinitarg1
@ -710,8 +790,402 @@ UINT32 ThunkConnect32( struct thunkstruct *ths, LPSTR thunkfun16,
ths->magic[2],
ths->magic[3]
);
fprintf(stdnimp," x1 = %lx\n",ths->x1);
fprintf(stdnimp," x2 = %lx\n",ths->x2);
fprintf(stdnimp," length = %lx\n",ths->length);
if (lstrncmp32A(ths->magic,"SL01",4)&&lstrncmp32A(ths->magic,"LS01",4))
return 0;
hmm=LoadModule16(module16,NULL);
if (hmm<=32)
return 0;
thkbuf=(SEGPTR)WIN32_GetProcAddress16(hmm,thunkfun16);
if (!thkbuf)
return 0;
ths16=(struct thunkstruct*)PTR_SEG_TO_LIN(thkbuf);
if (lstrncmp32A(ths16->magic,ths->magic,4))
return 0;
if (!lstrncmp32A(ths->magic,"SL01",4)) {
if (ths16->length != ths->length)
return 0;
ths->x0C = (DWORD)ths16;
fprintf(stderr," ths16 magic is 0x%08lx\n",*(DWORD*)ths16->magic);
if (*((DWORD*)ths16->magic) != 0x0000304C)
return 0;
if (!*(WORD*)(((LPBYTE)ths16)+0x12))
return 0;
}
if (!lstrncmp32A(ths->magic,"LS01",4)) {
if (ths16->length != ths->length)
return 0;
ths->ptr = (DWORD)PTR_SEG_TO_LIN(ths16->ptr);
/* code offset for QT_Thunk is at 0x1C... */
_write_qtthunk (((LPBYTE)ths) + ths->x1C,ths->ptr);
/* code offset for FT_Prolog is at 0x20... */
_write_ftprolog(((LPBYTE)ths) + ths->x20,ths->ptr);
return 1;
}
return TRUE;
}
/**********************************************************************
* The infamous and undocumented QT_Thunk procedure.
*
* We get arguments in [EBP+8] up to [EBP+38].
* We have to set up a frame in the 16 bit stackframe.
* saved_ss_sp: bp+0x40
* bp+0x3c
* ...
* bp: bp+0x00
* sp:
*
*/
extern DWORD IF1632_Saved16_ss_sp;
VOID WINAPI QT_Thunk(CONTEXT *context)
{
CONTEXT context16;
LPBYTE curstack;
DWORD ret;
fprintf(stderr,"QT_Thunk(%08lx) ..",EDX_reg(context));
fprintf(stderr," argsize probably ebp-esp=%ld\n",
EBP_reg(context)-ESP_reg(context)
);
memcpy(&context16,context,sizeof(context16));
curstack = PTR_SEG_TO_LIN(IF1632_Saved16_ss_sp);
memcpy(curstack-0x40,(LPBYTE)EBP_reg(context),0x40);
EBP_reg(&context16) = LOWORD(IF1632_Saved16_ss_sp)-0x40;
IF1632_Saved16_ss_sp -= 0x3c;
CS_reg(&context16) = HIWORD(EDX_reg(context));
IP_reg(&context16) = LOWORD(EDX_reg(context));
#ifndef WINELIB
ret = CallTo16_regs_(&context16);
#endif
fprintf(stderr,". returned %08lx\n",ret);
EAX_reg(context) = ret;
IF1632_Saved16_ss_sp += 0x3c;
}
/**********************************************************************
* WOWCallback16 (KERNEL32.62)
*/
DWORD WINAPI WOWCallback16(FARPROC16 fproc,DWORD arg)
{
DWORD ret;
fprintf(stderr,"WOWCallback16(%p,0x%08lx) ",fproc,arg);
ret = CallTo16_long_l(fproc,arg);
fprintf(stderr,"... returns %ld\n",ret);
return ret;
}
/***********************************************************************
* _KERNEL32_52 (KERNEL32.52)
* FIXME: what does it really do?
*/
VOID WINAPI _KERNEL32_52(DWORD arg1,CONTEXT *regs)
{
fprintf(stderr,"_KERNE32_52(arg1=%08lx,%08lx)\n",arg1,EDI_reg(regs));
EAX_reg(regs) = (DWORD)WIN32_GetProcAddress16(EDI_reg(regs),"ThkBuf");
fprintf(stderr," GetProcAddress16(\"ThkBuf\") returns %08lx\n",
EAX_reg(regs)
);
}
/***********************************************************************
* _KERNEL32_43 (KERNEL32.42)
* A thunkbuffer link routine
* The thunkbuf looks like:
*
* 00: DWORD length ? don't know exactly
* 04: SEGPTR ptr ? where does it point to?
* The pointer ptr is written into the first DWORD of 'thunk'.
* (probably correct implemented)
*/
BOOL32 WINAPI _KERNEL32_43(LPDWORD thunk,LPCSTR thkbuf,DWORD len,
LPCSTR dll16,LPCSTR dll32)
{
HINSTANCE16 hmod;
LPDWORD addr;
SEGPTR segaddr;
fprintf(stderr,"_KERNEL32_43(%p,%s,0x%08lx,%s,%s)\n",thunk,thkbuf,len,dll16,dll32);
hmod = LoadLibrary16(dll16);
if (hmod<32) {
fprintf(stderr,"->failed to load 16bit DLL %s, error %d\n",dll16,hmod);
return NULL;
}
segaddr = (DWORD)WIN32_GetProcAddress16(hmod,(LPSTR)thkbuf);
if (!segaddr) {
fprintf(stderr,"->no %s exported from %s!\n",thkbuf,dll16);
return NULL;
}
addr = (LPDWORD)PTR_SEG_TO_LIN(segaddr);
if (addr[0] != len) {
fprintf(stderr,"->thkbuf length mismatch? %ld vs %ld\n",len,addr[0]);
return NULL;
}
if (!addr[1])
return 0;
fprintf(stderr," addr[1] is %08lx\n",addr[1]);
*(DWORD*)thunk = addr[1];
return addr[1];
}
/***********************************************************************
* _KERNEL32_45 (KERNEL32.44)
* Looks like another 32->16 thunk. Dunno why they need two of them.
* calls the win16 address in EAX with the current stack.
*
* FIXME: doesn't seem to work correctly yet...
*/
VOID WINAPI _KERNEL32_45(CONTEXT *context)
{
CONTEXT context16;
LPBYTE curstack;
DWORD ret,stacksize;
fprintf(stderr,"KERNEL32_45(%%eax=0x%08lx(%%cx=0x%04lx,%%edx=0x%08lx))\n",
(DWORD)EAX_reg(context),(DWORD)CX_reg(context),(DWORD)EDX_reg(context)
);
stacksize = EBP_reg(context)-ESP_reg(context);
fprintf(stderr," stacksize = %ld\n",stacksize);
memcpy(&context16,context,sizeof(context16));
curstack = PTR_SEG_TO_LIN(IF1632_Saved16_ss_sp);
memcpy(curstack-stacksize,(LPBYTE)EBP_reg(context),stacksize);
fprintf(stderr,"IF1632_Saved16_ss_sp is 0x%08lx\n",IF1632_Saved16_ss_sp);
EBP_reg(&context16) = LOWORD(IF1632_Saved16_ss_sp)-stacksize;
IF1632_Saved16_ss_sp -= stacksize;
DI_reg(&context16) = CX_reg(context);
CS_reg(&context16) = HIWORD(EAX_reg(context));
IP_reg(&context16) = LOWORD(EAX_reg(context));
/* some more registers spronged locally, but I don't think they are
* needed
*/
#ifndef WINELIB
ret = CallTo16_regs_(&context16);
#endif
fprintf(stderr,". returned %08lx\n",ret);
EAX_reg(context) = ret;
IF1632_Saved16_ss_sp += stacksize;
}
/***********************************************************************
* (KERNEL32.40)
* A thunk setup routine.
* Expects a pointer to a preinitialized thunkbuffer in the first argument
* looking like:
* 00..03: unknown (pointer, check _41, _43, _46)
* 04: EB1E jmp +0x20
*
* 06..23: unknown (space for replacement code, check .90)
*
* 24:>E800000000 call offset 29
* 29:>58 pop eax ( target of call )
* 2A: 2D25000000 sub eax,0x00000025 ( now points to offset 4 )
* 2F: BAxxxxxxxx mov edx,xxxxxxxx
* 34: 68yyyyyyyy push KERNEL32.90
* 39: C3 ret
*
* 3A: EB1E jmp +0x20
* 3E ... 59: unknown (space for replacement code?)
* 5A: E8xxxxxxxx call <32bitoffset xxxxxxxx>
* 5F: 5A pop edx
* 60: 81EA25xxxxxx sub edx, 0x25xxxxxx
* 66: 52 push edx
* 67: 68xxxxxxxx push xxxxxxxx
* 6C: 68yyyyyyyy push KERNEL32.89
* 71: C3 ret
* 72: end?
* This function checks if the code is there, and replaces the yyyyyyyy entries
* by the functionpointers.
* The thunkbuf looks like:
*
* 00: DWORD length ? don't know exactly
* 04: SEGPTR ptr ? where does it point to?
* The segpointer ptr is written into the first DWORD of 'thunk'.
* (probably correct implemented)
*/
LPVOID WINAPI _KERNEL32_41(LPBYTE thunk,LPCSTR thkbuf,DWORD len,LPCSTR dll16,
LPCSTR dll32)
{
HMODULE32 hkrnl32 = WIN32_GetModuleHandleA("KERNEL32");
HMODULE16 hmod;
LPDWORD addr,addr2;
DWORD segaddr;
fprintf(stderr,"KERNEL32_41(%p,%s,%ld,%s,%s)\n",
thunk,thkbuf,len,dll16,dll32
);
/* FIXME: add checks for valid code ... */
/* write pointers to kernel32.89 and kernel32.90 (+ordinal base of 1) */
*(DWORD*)(thunk+0x35) = (DWORD)GetProcAddress32(hkrnl32,(LPSTR)90);
*(DWORD*)(thunk+0x6D) = (DWORD)GetProcAddress32(hkrnl32,(LPSTR)89);
hmod = LoadLibrary16(dll16);
if (hmod<32) {
fprintf(stderr,"->failed to load 16bit DLL %s, error %d\n",dll16,hmod);
return NULL;
}
segaddr = (DWORD)WIN32_GetProcAddress16(hmod,(LPSTR)thkbuf);
if (!segaddr) {
fprintf(stderr,"->no %s exported from %s!\n",thkbuf,dll16);
return NULL;
}
addr = (LPDWORD)PTR_SEG_TO_LIN(segaddr);
if (addr[0] != len) {
fprintf(stderr,"->thkbuf length mismatch? %ld vs %ld\n",len,addr[0]);
return NULL;
}
addr2 = PTR_SEG_TO_LIN(addr[1]);
fprintf(stderr," addr2 is %08lx:%p\n",addr[1],addr2);
if (HIWORD(addr2))
*(DWORD*)thunk = (DWORD)addr2;
return addr2;
}
/***********************************************************************
* (KERNEL32.91)
* Thunk priming? function
* Rewrites the first part of the thunk to use the QT_Thunk interface
* and jumps to the start of that code.
*/
VOID WINAPI _KERNEL32_90(CONTEXT *context)
{
fprintf(stderr,"_KERNEL32_90(eax=0x%08lx,edx=0x%08lx,ebp[-4]=0x%02x,target = %08lx, *target =%08lx)\n",
EAX_reg(context),EDX_reg(context),((BYTE*)EBP_reg(context))[-4],
(*(DWORD*)(EAX_reg(context)+EDX_reg(context)))+4*(((BYTE*)EBP_reg(context))[-4]),
*(DWORD*)((*(DWORD*)(EAX_reg(context)+EDX_reg(context)))+4*(((BYTE*)EBP_reg(context))[-4]))
);
_write_qtthunk((LPBYTE)EAX_reg(context),*(DWORD*)(EAX_reg(context)+EDX_reg(context)));
/* we just call the real QT_Thunk right now
* we can bypass the relaycode, for we already have the registercontext
*/
EDX_reg(context) = *(DWORD*)((*(DWORD*)(EAX_reg(context)+EDX_reg(context)))+4*(((BYTE*)EBP_reg(context))[-4]));
return QT_Thunk(context);
}
/***********************************************************************
* (KERNEL32.45)
* Another thunkbuf link routine.
* The start of the thunkbuf looks like this:
* 00: DWORD length
* 04: SEGPTR address for thunkbuffer pointer
*/
VOID WINAPI _KERNEL32_46(LPBYTE thunk,LPSTR thkbuf,DWORD len,LPSTR dll16,
LPSTR dll32)
{
LPDWORD addr;
HMODULE16 hmod;
SEGPTR segaddr;
fprintf(stderr,"KERNEL32_46(%p,%s,%lx,%s,%s)\n",
thunk,thkbuf,len,dll16,dll32
);
hmod = LoadLibrary16(dll16);
if (hmod < 32) {
fprintf(stderr,"->couldn't load %s, error %d\n",dll16,hmod);
return;
}
segaddr = (SEGPTR)WIN32_GetProcAddress16(hmod,thkbuf);
if (!segaddr) {
fprintf(stderr,"-> haven't found %s in %s!\n",thkbuf,dll16);
return;
}
addr = (LPDWORD)PTR_SEG_TO_LIN(segaddr);
if (addr[0] != len) {
fprintf(stderr,"-> length of thkbuf differs from expected length! (%ld vs %ld)\n",addr[0],len);
return;
}
*(DWORD*)PTR_SEG_TO_LIN(addr[1]) = (DWORD)thunk;
}
/**********************************************************************
* _KERNEL32_87
* Check if thunking is initialized (ss selector set up etc.)
*/
BOOL32 WINAPI _KERNEL32_87()
{
fprintf(stderr,"KERNEL32_87 stub, returning TRUE\n");
return TRUE;
}
/**********************************************************************
* _KERNEL32_88
* One of the real thunking functions. This one seems to be for 32<->32
* thunks. It should probably be capable of crossing processboundaries.
*
* And YES, I've seen nr=48 (somewhere in the Win95 32<->16 OLE coupling)
*/
DWORD WINAPI _KERNEL32_88(DWORD *args)
{
DWORD nr = args[0];
DWORD flags = args[1];
FARPROC32 fun = (FARPROC32)args[2];
DWORD i,ret;
fprintf(stderr,"KERNEL32_88(%ld,0x%08lx,%p,[ ",nr,flags,fun);
for (i=0;i<nr/4;i++)
fprintf(stderr,"0x%08lx,",args[3+i]);
fprintf(stderr,"])");
#ifndef WINELIB
switch (nr) {
case 0: ret = CallTo32_0(fun);
break;
case 4: ret = CallTo32_1(fun,args[3]);
break;
case 8: ret = CallTo32_2(fun,args[3],args[4]);
break;
case 12: ret = CallTo32_3(fun,args[3],args[4],args[5]);
break;
case 16: ret = CallTo32_4(fun,args[3],args[4],args[5],args[6]);
break;
case 20: ret = CallTo32_5(fun,args[3],args[4],args[5],args[6],args[7]);
break;
case 24: ret = CallTo32_6(fun,args[3],args[4],args[5],args[6],args[7],args[8]);
break;
case 28: ret = CallTo32_7(fun,args[3],args[4],args[5],args[6],args[7],args[8],args[9]);
break;
case 32: ret = CallTo32_8(fun,args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10]);
break;
case 36: ret = CallTo32_9(fun,args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11]);
break;
case 40: ret = CallTo32_10(fun,args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12]);
break;
case 44: ret = CallTo32_11(fun,args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13]);
break;
case 48: ret = CallTo32_12(fun,args[3],args[4],args[5],args[6],args[7],args[8],args[9],args[10],args[11],args[12],args[13],args[14]);
break;
default:
fprintf(stderr," unsupported nr of arguments, %ld\n",nr);
ret = 0;
break;
}
#endif
fprintf(stderr," returning %ld ...\n",ret);
return ret;
}
/**********************************************************************
* KERNEL_619 (KERNEL)
* Seems to store y and z depending on x in some internal lists...
*/
WORD WINAPI _KERNEL_619(WORD x,DWORD y,DWORD z)
{
fprintf(stderr,"KERNEL_619(0x%04x,0x%08lx,0x%08lx)\n",x,y,z);
return x;
}

10
if1632/user.spec
View File

@ -283,7 +283,7 @@ file user.exe
276 stub LockMyTask
277 pascal16 GetDlgCtrlID(word) GetDlgCtrlID16
278 pascal16 GetDesktopHwnd() GetDesktopHwnd
279 stub OldSetDeskPattern
279 pascal16 OldSetDeskPattern() SetDeskPattern
280 pascal16 SetSystemMenu(word word) SetSystemMenu16
281 pascal16 GetSysColorBrush(word) GetSysColorBrush16
282 pascal16 SelectPalette(word word word) SelectPalette16
@ -382,12 +382,12 @@ file user.exe
431 pascal AnsiUpper(segstr) AnsiUpper16
432 pascal AnsiLower(segstr) AnsiLower16
433 pascal16 IsCharAlpha(byte) IsCharAlpha16
434 pascal16 IsCharAlphanumeric(byte) IsCharAlphanumeric16
434 pascal16 IsCharAlphaNumeric(byte) IsCharAlphaNumeric16
435 pascal16 IsCharUpper(byte) IsCharUpper16
436 pascal16 IsCharLower(byte) IsCharLower16
437 pascal16 AnsiUpperBuff(ptr word) AnsiUpperBuff16
438 pascal16 AnsiLowerBuff(ptr word) AnsiLowerBuff16
441 stub InsertMenuItem
441 pascal16 InsertMenuItem(word word word ptr) InsertMenuItem16
443 stub GetMenuItemInfo
445 pascal DefFrameProc(word word word word long) DefFrameProc16
446 stub SetMenuItemInfo
@ -503,8 +503,8 @@ file user.exe
804 stub CHOOSECOLOR_CALLBACK16
819 stub PeekMessage32
820 stub GetMessage32
821 stub TranslateMessage32
821 stub IsDialogMessage32
821 stub TranslateMessage32
#821 stub IsDialogMessage32 # FIXME: two ordinal 821???
822 stub DispatchMessage32
825 stub PostMessage32
826 stub PostThreadMessage32

14
if1632/user32.spec
View File

@ -165,7 +165,7 @@ base 1
0158 stdcall DrawIcon(long long long long) DrawIcon32
0159 stub DrawIconEx
0160 stdcall DrawMenuBar(long) DrawMenuBar32
0161 stub DrawStateA
0161 stdcall DrawStateA(long long ptr long long long long long long long) DrawState32A
0162 stub DrawStateW
0163 stdcall DrawTextA(long ptr long ptr long) DrawText32A
0164 stub DrawTextExA
@ -253,7 +253,7 @@ base 1
0246 stdcall GetKeyNameTextA(long ptr long) GetKeyNameText32A
0247 stdcall GetKeyNameTextW(long ptr long) GetKeyNameText32W
0248 stdcall GetKeyState(long) GetKeyState32
0249 stub GetKeyboardLayout
0249 stdcall GetKeyboardLayout(long) GetKeyboardLayout
0250 stub GetKeyboardLayoutList
0251 stub GetKeyboardLayoutNameA
0252 stub GetKeyboardLayoutNameW
@ -326,8 +326,8 @@ base 1
0319 stdcall InSendMessage() InSendMessage32
0320 stdcall InflateRect(ptr long long) InflateRect32
0321 stdcall InsertMenuA(long long long long ptr) InsertMenu32A
0322 stub InsertMenuItemA
0323 stub InsertMenuItemW
0322 stdcall InsertMenuItemA(long long long ptr) InsertMenuItem32A
0323 stdcall InsertMenuItemW(long long long ptr) InsertMenuItem32W
0324 stdcall InsertMenuW(long long long long ptr) InsertMenu32W
0325 stub InternalGetWindowText
0326 stdcall IntersectRect(ptr ptr ptr) IntersectRect32
@ -492,10 +492,10 @@ base 1
0485 stub SetLogonNotifyWindow
0486 stdcall SetMenu(long long) SetMenu32
0487 stub SetMenuContextHelpId
0488 stub SetMenuDefaultItem
0488 stdcall SetMenuDefaultItem(long long long) SetMenuDefaultItem32
0489 stdcall SetMenuItemBitmaps(long long long long long) SetMenuItemBitmaps32
0490 stub SetMenuItemInfoA
0491 stub SetMenuItemInfoW
0490 stdcall SetMenuItemInfoA(long long long ptr) SetMenuItemInfo32A
0491 stdcall SetMenuItemInfoW(long long long ptr) SetMenuItemInfo32W
0492 stub SetMessageExtraInfo
0493 stdcall SetMessageQueue(long) SetMessageQueue32
0494 stdcall SetParent(long long) SetParent32

54
if1632/winsock.spec
View File

@ -6,36 +6,36 @@
name winsock
type win16
1 pascal16 accept(word ptr ptr) WINSOCK_accept
2 pascal16 bind(word ptr word) WINSOCK_bind
3 pascal16 closesocket(word) WINSOCK_closesocket
4 pascal16 connect(word ptr word) WINSOCK_connect
5 pascal16 getpeername(word ptr ptr) WINSOCK_getpeername
6 pascal16 getsockname(word ptr ptr) WINSOCK_getsockname
7 pascal16 getsockopt(word word word ptr ptr) WINSOCK_getsockopt
1 pascal16 accept(word ptr ptr) WINSOCK_accept16
2 pascal16 bind(word ptr word) WINSOCK_bind16
3 pascal16 closesocket(word) WINSOCK_closesocket16
4 pascal16 connect(word ptr word) WINSOCK_connect16
5 pascal16 getpeername(word ptr ptr) WINSOCK_getpeername16
6 pascal16 getsockname(word ptr ptr) WINSOCK_getsockname16
7 pascal16 getsockopt(word word word ptr ptr) WINSOCK_getsockopt16
8 pascal htonl(long) WINSOCK_htonl
9 pascal16 htons(word) WINSOCK_htons
10 pascal inet_addr(ptr) WINSOCK_inet_addr
11 pascal inet_ntoa(long) WINSOCK_inet_ntoa
12 pascal16 ioctlsocket(word long ptr) WINSOCK_ioctlsocket
13 pascal16 listen(word word) WINSOCK_listen
12 pascal16 ioctlsocket(word long ptr) WINSOCK_ioctlsocket16
13 pascal16 listen(word word) WINSOCK_listen16
14 pascal ntohl(long) WINSOCK_ntohl
15 pascal16 ntohs(word) WINSOCK_ntohs
16 pascal16 recv(word ptr word word) WINSOCK_recv
17 pascal16 recvfrom(word ptr word word ptr ptr) WINSOCK_recvfrom
18 pascal16 select(word ptr ptr ptr ptr) WINSOCK_select
19 pascal16 send(word ptr word word) WINSOCK_send
20 pascal16 sendto(word ptr word word ptr word) WINSOCK_sendto
21 pascal16 setsockopt(word word word ptr word) WINSOCK_setsockopt
22 pascal16 shutdown(word word) WINSOCK_shutdown
23 pascal16 socket(word word word) WINSOCK_socket
51 pascal gethostbyaddr(ptr word word) WINSOCK_gethostbyaddr
52 pascal gethostbyname(ptr) WINSOCK_gethostbyname
53 pascal getprotobyname(ptr) WINSOCK_getprotobyname
54 pascal getprotobynumber(word) WINSOCK_getprotobynumber
55 pascal getservbyname(ptr ptr) WINSOCK_getservbyname
56 pascal getservbyport(word ptr) WINSOCK_getservbyport
57 pascal gethostname(ptr word) WINSOCK_gethostname
16 pascal16 recv(word ptr word word) WINSOCK_recv16
17 pascal16 recvfrom(word ptr word word ptr ptr) WINSOCK_recvfrom16
18 pascal16 select(word ptr ptr ptr ptr) WINSOCK_select16
19 pascal16 send(word ptr word word) WINSOCK_send16
20 pascal16 sendto(word ptr word word ptr word) WINSOCK_sendto16
21 pascal16 setsockopt(word word word ptr word) WINSOCK_setsockopt16
22 pascal16 shutdown(word word) WINSOCK_shutdown16
23 pascal16 socket(word word word) WINSOCK_socket16
51 pascal gethostbyaddr(ptr word word) WINSOCK_gethostbyaddr16
52 pascal gethostbyname(ptr) WINSOCK_gethostbyname16
53 pascal getprotobyname(ptr) WINSOCK_getprotobyname16
54 pascal getprotobynumber(word) WINSOCK_getprotobynumber16
55 pascal getservbyname(ptr ptr) WINSOCK_getservbyname16
56 pascal getservbyport(word ptr) WINSOCK_getservbyport16
57 pascal gethostname(ptr word) WINSOCK_gethostname16
101 pascal16 WSAAsyncSelect(word word word long) WSAAsyncSelect
102 pascal16 WSAAsyncGetHostByAddr(word word ptr word word segptr word)
WSAAsyncGetHostByAddr
@ -53,9 +53,9 @@ type win16
109 pascal16 WSASetBlockingHook(segptr) WSASetBlockingHook16
110 pascal16 WSAUnhookBlockingHook() WSAUnhookBlockingHook16
111 pascal16 WSAGetLastError() WSAGetLastError
112 pascal WSASetLastError(word) WSASetLastError
112 pascal WSASetLastError(word) WSASetLastError16
113 pascal16 WSACancelBlockingCall() WSACancelBlockingCall
114 pascal16 WSAIsBlocking() WSAIsBlocking
115 pascal WSAStartup(word ptr) WSAStartup
115 pascal WSAStartup(word ptr) WSAStartup16
116 pascal WSACleanup() WSACleanup
151 pascal16 __WSAFDIsSet(word ptr) __WSAFDIsSet
151 pascal16 __WSAFDIsSet(word ptr) __WSAFDIsSet16

4
if1632/winspool.spec
View File

@ -52,11 +52,11 @@ base 100
048 stub DeletePrinterIC
049 stub DevQueryPrint
050 stub DeviceCapabilities
051 stub DeviceCapabilitiesA
051 stdcall DeviceCapabilitiesA(ptr ptr long ptr ptr) DeviceCapabilities32A
052 stub DeviceCapabilitiesW
053 stub DeviceMode
054 stub DocumentEvent
055 stub DocumentPropertiesA
055 stdcall DocumentPropertiesA(long long ptr ptr ptr long) DocumentProperties32A
056 stub DocumentPropertiesW
057 stub EXTDEVICEMODE
058 stub EndDocPrinter

4
if1632/wprocs.spec
View File

@ -1,7 +1,6 @@
name wprocs
type win16
1 pascal WINPROC_CallProc16To32A(word word word long long) WINPROC_CallProc16To32A
10 pascal MDIClientWndProc(word word word long) MDIClientWndProc
14 pascal FileOpenDlgProc(word word word long) FileOpenDlgProc
15 pascal FileSaveDlgProc(word word word long) FileSaveDlgProc
@ -11,7 +10,7 @@ type win16
19 pascal PrintSetupDlgProc(word word word long) PrintSetupDlgProc
20 pascal PrintDlgProc(word word word long) PrintDlgProc
24 pascal16 TASK_Reschedule() TASK_Reschedule
27 pascal EntryAddrProc(word word) MODULE_GetEntryPoint
27 pascal EntryAddrProc(word word) EntryAddrProc
28 pascal MyAlloc(word word word) MODULE_AllocateSegment
30 pascal FormatCharDlgProc(word word word long) FormatCharDlgProc
@ -279,6 +278,7 @@ type win16
#
#400+VXD_ID register <VxD handler>() <VxD handler>
#
405 register VXD_Timer() VXD_Timer
414 register VXD_Comm() VXD_Comm
#415 register VXD_Printer() VXD_Printer
423 register VXD_Shell() VXD_Shell

60
if1632/wsock32.spec
View File

@ -2,36 +2,36 @@ name wsock32
type win32
base 0
001 stdcall accept(long ptr ptr) WINSOCK_accept
002 stdcall bind(long ptr long) WINSOCK_bind
003 stdcall closesocket(long) WINSOCK_closesocket
004 stdcall connect(long ptr long) WINSOCK_connect
005 stub getpeername
006 stdcall getsockname(long ptr ptr) WINSOCK_getsockname
007 stub getsockopt
001 stdcall accept(long ptr ptr) WINSOCK_accept32
002 stdcall bind(long ptr long) WINSOCK_bind32
003 stdcall closesocket(long) WINSOCK_closesocket32
004 stdcall connect(long ptr long) WINSOCK_connect32
005 stdcall getpeername(long ptr ptr) WINSOCK_getpeername32
006 stdcall getsockname(long ptr ptr) WINSOCK_getsockname32
007 stdcall getsockopt(long long long ptr ptr) WINSOCK_getsockopt32
008 stdcall htonl(long) WINSOCK_htonl
009 stdcall htons(long) WINSOCK_htons
010 stdcall inet_addr(ptr) inet_addr
011 stdcall inet_ntoa(ptr) inet_ntoa
012 stub ioctlsocket
013 stub listen
012 stdcall ioctlsocket(long long ptr) WINSOCK_ioctlsocket32
013 stdcall listen(long long) WINSOCK_listen32
014 stdcall ntohl(long) WINSOCK_ntohl
015 stdcall ntohs(long) WINSOCK_ntohs
016 stub recv
017 stub recvfrom
018 stub select
019 stub send
020 stub sendto
021 stub setsockopt
022 stub shutdown
023 stdcall socket(long long long) WINSOCK_socket
051 stdcall gethostbyaddr(ptr long long) WINSOCK_gethostbyaddr
052 stdcall gethostbyname(ptr) gethostbyname
053 stub getprotobyname
054 stub getprotobynumber
055 stdcall getservbyname(ptr ptr) getservbyname
056 stub getservbyport
057 stdcall gethostname(ptr long) gethostname
016 stdcall recv(long ptr long long) WINSOCK_recv32
017 stdcall recvfrom(long ptr long long ptr ptr) WINSOCK_recvfrom32
018 stdcall select(long ptr ptr ptr ptr) WINSOCK_select32
019 stdcall send(long ptr long long) WINSOCK_send32
020 stdcall sendto(long ptr long long ptr long) WINSOCK_sendto32
021 stdcall setsockopt(long long long ptr long) WINSOCK_setsockopt32
022 stdcall shutdown(long long) WINSOCK_shutdown32
023 stdcall socket(long long long) WINSOCK_socket32
051 stdcall gethostbyaddr(ptr long long) WINSOCK_gethostbyaddr32
052 stdcall gethostbyname(ptr) WINSOCK_gethostbyname32
053 stdcall getprotobyname(ptr) WINSOCK_getprotobyname32
054 stdcall getprotobynumber(long) WINSOCK_getprotobynumber32
055 stdcall getservbyname(ptr ptr) WINSOCK_getservbyname32
056 stdcall getservbyport(long ptr) WINSOCK_getservbyport32
057 stdcall gethostname(ptr long) WINSOCK_gethostname32
101 stub WSAAsyncSelect
102 stub WSAAsyncGetHostByAddr
103 stub WSAAsyncGetHostByName
@ -42,13 +42,13 @@ base 0
108 stub WSACancelAsyncRequest
109 stdcall WSASetBlockingHook(ptr) WSASetBlockingHook32
110 stdcall WSAUnhookBlockingHook() WSAUnhookBlockingHook32
111 stub WSAGetLastError
112 stub WSASetLastError
113 stub WSACancelBlockingCall
114 stub WSAIsBlocking
115 stdcall WSAStartup(long ptr) WSAStartup
111 stdcall WSAGetLastError() WSAGetLastError
112 stdcall WSASetLastError(long) WSASetLastError32
113 stdcall WSACancelBlockingCall() WSACancelBlockingCall
114 stdcall WSAIsBlocking() WSAIsBlocking
115 stdcall WSAStartup(long ptr) WSAStartup32
116 stdcall WSACleanup() WSACleanup
151 stub __WSAFDIsSet
151 stdcall __WSAFDIsSet(long ptr) __WSAFDIsSet32
#500 stub WEP
# applications *should* 'degrade gracefully if these are not present
# ... as it is, they don't

1
include/bitmap.h
View File

@ -53,6 +53,7 @@ extern BOOL32 BITMAP_Init(void);
extern INT16 BITMAP_GetObject16( BITMAPOBJ * bmp, INT16 count, LPVOID buffer );
extern INT32 BITMAP_GetObject32( BITMAPOBJ * bmp, INT32 count, LPVOID buffer );
extern BOOL32 BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bitmap );
extern XImage *BITMAP_GetXImage( const BITMAPOBJ *bmp );
/* objects/dib.c */
extern int DIB_GetDIBWidthBytes( int width, int depth );

4
include/button.h
View File

@ -28,7 +28,7 @@ typedef struct
#define BUTTON_STATE(hwnd) ((WIN_FindWndPtr(hwnd))->wExtra[0])
extern LRESULT ButtonWndProc( HWND32 hWnd, UINT32 uMsg,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI ButtonWndProc( HWND32 hWnd, UINT32 uMsg,
WPARAM32 wParam, LPARAM lParam );
#endif /* __WINE_BUTTON_H */

19
include/callback.h
View File

@ -10,17 +10,22 @@
#include "wintypes.h"
#include "winnt.h"
extern
int CallTo32_LargeStack( int (*func)(), int nbargs, ... );
extern int (*IF1632_CallLargeStack)( int (*func)(), void *arg );
#define CALL_LARGE_STACK(func,arg) \
(IF1632_CallLargeStack ? \
IF1632_CallLargeStack( (int(*)())(func), (void *)(arg) ) : \
((int(*)())(func))((void *)arg))
/* List of the 16-bit callback functions. This list is used */
/* by the build program to generate the file if1632/callto16.S */
#ifndef WINELIB
extern void CallTo16_regs_ ( const CONTEXT *context );
extern LONG CallTo16_regs_ ( const CONTEXT *context );
extern WORD CallTo16_word_ ( FARPROC16 );
extern WORD CallTo16_word_w ( FARPROC16, WORD );
extern LONG CallTo16_long_l ( FARPROC16, LONG );
extern WORD CallTo16_word_ww ( FARPROC16, WORD, WORD );
extern WORD CallTo16_word_wl ( FARPROC16, WORD, LONG );
extern WORD CallTo16_word_ll ( FARPROC16, LONG, LONG );
@ -67,6 +72,14 @@ extern LONG CallTo32_2( FARPROC32, DWORD, DWORD );
extern LONG CallTo32_3( FARPROC32, DWORD, DWORD, DWORD );
extern LONG CallTo32_4( FARPROC32, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_5( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_6( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_7( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_8( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_9( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_10( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_11( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_12( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
extern LONG CallTo32_13( FARPROC32, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD );
#define CallTaskStart32( func ) \
CallTo32_0( func )

2
include/color.h
View File

@ -17,7 +17,7 @@
extern void COLOR_Cleanup(void);
extern COLORREF COLOR_ToLogical(int pixel);
extern int COLOR_ToPhysical( DC *dc, COLORREF color );
extern int COLOR_SetMapping( PALETTEOBJ* pal, BOOL32 mapOnly );
extern int COLOR_SetMapping( PALETTEOBJ* pal, UINT32 uStart, UINT32 uNum, BOOL32 mapOnly );
extern BOOL32 COLOR_IsSolid( COLORREF color );
extern Colormap COLOR_GetColormap();
extern UINT16 COLOR_GetSystemPaletteSize();

1
include/combo.h
View File

@ -18,6 +18,7 @@
#define CBF_CAPTURE 0x0020
#define CBF_EDIT 0x0040
#define CBF_NORESIZE 0x0080
#define CBF_NOTIFY 0x0100
#define CBF_EUI 0x8000
/* Combo state struct */

2
include/comm.h
View File

@ -1,7 +1,7 @@
#ifndef __WINE_COMM_H
#define __WINE_COMM_H
#define MAX_PORTS 16
#define MAX_PORTS 9
struct DosDeviceStruct {
char *devicename; /* /dev/cua1 */

60
include/commctrl.h
View File

@ -7,7 +7,7 @@
#include "windows.h"
void InitCommonControls(void);
void WINAPI InitCommonControls(void);
/* StatusWindow */
@ -41,11 +41,61 @@ void InitCommonControls(void);
#define CCS_BOTTOM 0x0003
#define SBARS_SIZEGRIP 0x0100
HWND32 CreateStatusWindow32A(INT32,LPCSTR,HWND32,UINT32);
HWND32 CreateStatusWindow32W(INT32,LPCWSTR,HWND32,UINT32);
/* UpDown control */
#define UPDOWN_CLASS32A "msctls_updown32"
#define UPDOWN_CLASS32W "msctls_updown32"
#define UPDOWN_CLASS16 "msctls_updown"
#define UPDOWN_CLASS WINELIB_NAME_AW(UPDOWN_CLASS)
typedef struct tagUDACCEL
{
UINT32 nSec;
UINT32 nInc;
} UDACCEL;
typedef struct tagNM_UPDOWN
{
NMHDR hdr;
int iPos;
int iDelta;
} NM_UPDOWN;
#define UD_MAXVAL 0x7fff
#define UD_MINVAL 0x8001
#define UDS_WRAP 0x0001
#define UDS_SETBUDDYINT 0x0002
#define UDS_ALIGNRIGHT 0x0004
#define UDS_ALIGNLEFT 0x0008
#define UDS_AUTOBUDDY 0x0010
#define UDS_ARROWKEYS 0x0020
#define UDS_HORZ 0x0040
#define UDS_NOTHOUSANDS 0x0080
#define UDN_FIRST (0U-721)
#define UDN_DELTAPOS (UDN_FIRST - 1)
#define UDM_SETRANGE (WM_USER+101)
#define UDM_GETRANGE (WM_USER+102)
#define UDM_SETPOS (WM_USER+103)
#define UDM_GETPOS (WM_USER+104)
#define UDM_SETBUDDY (WM_USER+105)
#define UDM_GETBUDDY (WM_USER+106)
#define UDM_SETACCEL (WM_USER+107)
#define UDM_GETACCEL (WM_USER+108)
#define UDM_SETBASE (WM_USER+109)
#define UDM_GETBASE (WM_USER+110)
/* Functions prototypes */
HWND32 WINAPI CreateStatusWindow32A(INT32,LPCSTR,HWND32,UINT32);
HWND32 WINAPI CreateStatusWindow32W(INT32,LPCWSTR,HWND32,UINT32);
#define CreateStatusWindow WINELIB_NAME_AW(CreateStatusWindow)
VOID DrawStatusText32A(HDC32,LPRECT32,LPCSTR,UINT32);
VOID DrawStatusText32W(HDC32,LPRECT32,LPCWSTR,UINT32);
HWND32 WINAPI CreateUpDownControl(DWORD,INT32,INT32,INT32,INT32,HWND32,
INT32,HINSTANCE32,HWND32,INT32,INT32,INT32);
VOID WINAPI DrawStatusText32A(HDC32,LPRECT32,LPCSTR,UINT32);
VOID WINAPI DrawStatusText32W(HDC32,LPRECT32,LPCWSTR,UINT32);
#define DrawStatusText WINELIB_NAME_AW(DrawStatusText)
#endif /* __WINE_COMMCTRL_H */

47
include/commdlg.h
View File

@ -325,33 +325,32 @@ typedef DEVNAMES * LPDEVNAMES;
#define CDERR_NOHOOK 0x000B
#define CDERR_REGISTERMSGFAIL 0x000C
BOOL16 ChooseColor(LPCHOOSECOLOR lpChCol);
DWORD CommDlgExtendedError(void);
HWND16 FindText( SEGPTR find);
INT16 GetFileTitle16(LPCSTR lpFile, LPSTR lpTitle, UINT16 cbBuf);
INT16 GetFileTitle32A(LPCSTR lpFile, LPSTR lpTitle, UINT32 cbBuf);
INT16 GetFileTitle32W(LPCWSTR lpFile, LPWSTR lpTitle, UINT32 cbBuf);
BOOL16 WINAPI ChooseColor(LPCHOOSECOLOR lpChCol);
DWORD WINAPI CommDlgExtendedError(void);
HWND16 WINAPI FindText( SEGPTR find);
INT16 WINAPI GetFileTitle16(LPCSTR lpFile, LPSTR lpTitle, UINT16 cbBuf);
INT16 WINAPI GetFileTitle32A(LPCSTR lpFile, LPSTR lpTitle, UINT32 cbBuf);
INT16 WINAPI GetFileTitle32W(LPCWSTR lpFile, LPWSTR lpTitle, UINT32 cbBuf);
#define GetFileTitle WINELIB_NAME_AW(GetFileTitle)
BOOL16 GetOpenFileName16(SEGPTR ofn);
BOOL32 GetOpenFileName32A(LPOPENFILENAME32A ofn);
BOOL32 GetOpenFileName32W(LPOPENFILENAME32W ofn);
BOOL16 WINAPI GetOpenFileName16(SEGPTR ofn);
BOOL32 WINAPI GetOpenFileName32A(LPOPENFILENAME32A ofn);
BOOL32 WINAPI GetOpenFileName32W(LPOPENFILENAME32W ofn);
#define GetOpenFileName WINELIB_NAME_AW(GetOpenFileName)
BOOL16 GetSaveFileName16(SEGPTR ofn);
BOOL32 GetSaveFileName32A(LPOPENFILENAME32A ofn);
BOOL32 GetSaveFileName32W(LPOPENFILENAME32W ofn);
BOOL16 WINAPI GetSaveFileName16(SEGPTR ofn);
BOOL32 WINAPI GetSaveFileName32A(LPOPENFILENAME32A ofn);
BOOL32 WINAPI GetSaveFileName32W(LPOPENFILENAME32W ofn);
#define GetSaveFileName WINELIB_NAME_AW(GetSaveFileName)
BOOL16 PrintDlg( SEGPTR print);
HWND16 ReplaceText( SEGPTR find);
BOOL16 ChooseFont(LPCHOOSEFONT lpChFont);
LRESULT FileOpenDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT FileSaveDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT ColorDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT FindTextDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT ReplaceTextDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT PrintDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT PrintSetupDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT FormatCharDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
BOOL16 WINAPI PrintDlg( SEGPTR print);
HWND16 WINAPI ReplaceText( SEGPTR find);
BOOL16 WINAPI ChooseFont(LPCHOOSEFONT lpChFont);
LRESULT WINAPI FileOpenDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI FileSaveDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI ColorDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI FindTextDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI ReplaceTextDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI PrintDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI PrintSetupDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
LRESULT WINAPI FormatCharDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam, LPARAM lParam);
#ifdef __cplusplus
}

4
include/compobj.h
View File

@ -10,7 +10,7 @@ struct tagCLSID {
typedef struct tagCLSID CLSID;
OLESTATUS StringFromCLSID(const CLSID *id, LPSTR);
OLESTATUS CLSIDFromString(const LPCSTR, CLSID *);
OLESTATUS WINAPI StringFromCLSID(const CLSID *id, LPSTR);
OLESTATUS WINAPI CLSIDFromString(const LPCSTR, CLSID *);
#endif

49
include/debug.h
View File

@ -80,6 +80,7 @@
#undef DEBUG_TIMER
#undef DEBUG_TOOLHELP
#undef DEBUG_TWEAK
#undef DEBUG_UPDOWN
#undef DEBUG_VER
#undef DEBUG_VIRTUAL
#undef DEBUG_VXD
@ -164,6 +165,7 @@
#define DEBUG_TIMER
#define DEBUG_TOOLHELP
#define DEBUG_TWEAK
#define DEBUG_UPDOWN
#define DEBUG_VER
#define DEBUG_VIRTUAL
#define DEBUG_VXD
@ -546,6 +548,11 @@ short debug_msg_enabled[]={
#else
0,
#endif
#ifdef DEBUG_UPDOWN
1,
#else
0,
#endif
#ifdef DEBUG_VER
1,
#else
@ -1551,8 +1558,21 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_ver if(!debug_msg_enabled[74]) ; else fprintf
#define debugging_ver debug_msg_enabled[74]
#define dprintf_updown if(!debug_msg_enabled[74]) ; else fprintf
#define debugging_updown debug_msg_enabled[74]
#else
#ifdef DEBUG_UPDOWN
#define dprintf_updown fprintf
#define debugging_updown 1
#else
#define dprintf_updown while(0) fprintf
#define debugging_updown 0
#endif
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_ver if(!debug_msg_enabled[75]) ; else fprintf
#define debugging_ver debug_msg_enabled[75]
#else
#ifdef DEBUG_VER
#define dprintf_ver fprintf
@ -1564,8 +1584,8 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_virtual if(!debug_msg_enabled[75]) ; else fprintf
#define debugging_virtual debug_msg_enabled[75]
#define dprintf_virtual if(!debug_msg_enabled[76]) ; else fprintf
#define debugging_virtual debug_msg_enabled[76]
#else
#ifdef DEBUG_VIRTUAL
#define dprintf_virtual fprintf
@ -1577,8 +1597,8 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_vxd if(!debug_msg_enabled[76]) ; else fprintf
#define debugging_vxd debug_msg_enabled[76]
#define dprintf_vxd if(!debug_msg_enabled[77]) ; else fprintf
#define debugging_vxd debug_msg_enabled[77]
#else
#ifdef DEBUG_VXD
#define dprintf_vxd fprintf
@ -1590,8 +1610,8 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_win if(!debug_msg_enabled[77]) ; else fprintf
#define debugging_win debug_msg_enabled[77]
#define dprintf_win if(!debug_msg_enabled[78]) ; else fprintf
#define debugging_win debug_msg_enabled[78]
#else
#ifdef DEBUG_WIN
#define dprintf_win fprintf
@ -1603,8 +1623,8 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_win16drv if(!debug_msg_enabled[78]) ; else fprintf
#define debugging_win16drv debug_msg_enabled[78]
#define dprintf_win16drv if(!debug_msg_enabled[79]) ; else fprintf
#define debugging_win16drv debug_msg_enabled[79]
#else
#ifdef DEBUG_WIN16DRV
#define dprintf_win16drv fprintf
@ -1616,8 +1636,8 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_win32 if(!debug_msg_enabled[79]) ; else fprintf
#define debugging_win32 debug_msg_enabled[79]
#define dprintf_win32 if(!debug_msg_enabled[80]) ; else fprintf
#define debugging_win32 debug_msg_enabled[80]
#else
#ifdef DEBUG_WIN32
#define dprintf_win32 fprintf
@ -1629,8 +1649,8 @@ extern short debug_msg_enabled[];
#endif
#ifdef DEBUG_RUNTIME
#define dprintf_winsock if(!debug_msg_enabled[80]) ; else fprintf
#define debugging_winsock debug_msg_enabled[80]
#define dprintf_winsock if(!debug_msg_enabled[81]) ; else fprintf
#define debugging_winsock debug_msg_enabled[81]
#else
#ifdef DEBUG_WINSOCK
#define dprintf_winsock fprintf
@ -1719,6 +1739,7 @@ static char *debug_msg_name[] = {
"timer",
"toolhelp",
"tweak",
"updown",
"ver",
"virtual",
"vxd",

2
include/debugger.h
View File

@ -9,7 +9,7 @@
#include "winnt.h"
#include "selectors.h"
#include "sigcontext.h"
#include "sig_context.h"
#include "pe_image.h"
#define STEP_FLAG 0x100 /* single step flag */

4
include/desktop.h
View File

@ -18,7 +18,7 @@ typedef struct
} DESKTOPINFO;
extern BOOL32 DESKTOP_SetPattern( LPCSTR pattern );
extern LRESULT DesktopWndProc( HWND32 hwnd, UINT32 message,
WPARAM32 wParam, LPARAM lParam );
extern LRESULT WINAPI DesktopWndProc( HWND32 hwnd, UINT32 message,
WPARAM32 wParam, LPARAM lParam );
#endif /* __WINE_DESKTOP_H */

19
include/driver.h
View File

@ -57,14 +57,15 @@ typedef struct tagDRIVERITEM
DRIVERPROC16 lpDrvProc;
} DRIVERITEM, *LPDRIVERITEM;
LRESULT DefDriverProc(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
LPARAM dwParam1, LPARAM dwParam2);
HDRVR16 OpenDriver(LPSTR szDriverName, LPSTR szSectionName, LPARAM lParam2);
LRESULT CloseDriver(HDRVR16 hDriver, LPARAM lParam1, LPARAM lParam2);
LRESULT SendDriverMessage( HDRVR16 hDriver, UINT16 message, LPARAM lParam1,
LPARAM lParam2 );
HMODULE16 GetDriverModuleHandle(HDRVR16 hDriver);
HDRVR16 GetNextDriver(HDRVR16, DWORD);
BOOL16 GetDriverInfo(HDRVR16, DRIVERINFOSTRUCT16 *);
LRESULT WINAPI DefDriverProc(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
LPARAM dwParam1, LPARAM dwParam2);
HDRVR16 WINAPI OpenDriver(LPSTR szDriverName, LPSTR szSectionName,
LPARAM lParam2);
LRESULT WINAPI CloseDriver(HDRVR16 hDriver, LPARAM lParam1, LPARAM lParam2);
LRESULT WINAPI SendDriverMessage( HDRVR16 hDriver, UINT16 message,
LPARAM lParam1, LPARAM lParam2 );
HMODULE16 WINAPI GetDriverModuleHandle(HDRVR16 hDriver);
HDRVR16 WINAPI GetNextDriver(HDRVR16, DWORD);
BOOL16 WINAPI GetDriverInfo(HDRVR16, DRIVERINFOSTRUCT16 *);
#endif /* __WINE_DRIVER_H */

18
include/except.h
View File

@ -15,7 +15,7 @@
/* forward definition */
struct __EXCEPTION_FRAME;
typedef DWORD ( *PEXCEPTION_HANDLER)( PEXCEPTION_RECORD pexcrec,
typedef DWORD (CALLBACK *PEXCEPTION_HANDLER)( PEXCEPTION_RECORD pexcrec,
struct __EXCEPTION_FRAME *pestframe,
PCONTEXT pcontext,
LPVOID pdispatcher);
@ -36,9 +36,9 @@ typedef struct __EXCEPTION_FRAME
* Function definitions
*/
void RaiseException(DWORD exccode, DWORD excflags,
DWORD nargs, const LPDWORD pargs,
PCONTEXT pcontext /* Wine additional parameter */ );
void WINAPI RaiseException(DWORD exccode, DWORD excflags,
DWORD nargs, const LPDWORD pargs,
PCONTEXT pcontext /* Wine additional parameter */);
/*
* this undocumented function is called when an exception
@ -54,10 +54,10 @@ void RaiseException(DWORD exccode, DWORD excflags,
* context.
*/
void RtlUnwind( PEXCEPTION_FRAME pestframe,
LPVOID unusedEIP,
PEXCEPTION_RECORD pexcrec,
DWORD contextEAX,
PCONTEXT pcontext /* Wine additional parameter */ );
void WINAPI RtlUnwind( PEXCEPTION_FRAME pestframe,
LPVOID unusedEIP,
PEXCEPTION_RECORD pexcrec,
DWORD contextEAX,
PCONTEXT pcontext /* Wine additional parameter */ );
#endif /* __WINE_EXCEPT_H */

15
include/gdi.h
View File

@ -273,14 +273,21 @@ extern WORD GDI_HeapSel;
#define GDI_HEAP_ALLOC(size) \
LOCAL_Alloc( GDI_HeapSel, LMEM_FIXED, (size) )
#define GDI_HEAP_ALLOC_MOVEABLE(size) \
LOCAL_Alloc( GDI_HeapSel, LMEM_MOVEABLE, (size) )
#define GDI_HEAP_REALLOC(handle,size) \
LOCAL_ReAlloc( GDI_HeapSel, (handle), (size), LMEM_FIXED )
#define GDI_HEAP_FREE(handle) \
LOCAL_Free( GDI_HeapSel, (handle) )
#define GDI_HEAP_LIN_ADDR(handle) \
((handle) ? PTR_SEG_OFF_TO_LIN(GDI_HeapSel, (handle)) : NULL)
#define GDI_HEAP_SEG_ADDR(handle) \
((handle) ? PTR_SEG_OFF_TO_SEGPTR(GDI_HeapSel, (handle)) : (SEGPTR)0)
#define GDI_HEAP_LOCK(handle) \
LOCAL_Lock( GDI_HeapSel, (handle) )
#define GDI_HEAP_LOCK_SEGPTR(handle) \
LOCAL_LockSegptr( GDI_HeapSel, (handle) )
#define GDI_HEAP_UNLOCK(handle) \
((((HGDIOBJ16)(handle) >= FIRST_STOCK_HANDLE) && \
((HGDIOBJ16)(handle)<=LAST_STOCK_HANDLE)) ? \
0 : LOCAL_Unlock( GDI_HeapSel, (handle) ))
extern BOOL32 GDI_Init(void);
extern HGDIOBJ16 GDI_AllocObject( WORD, WORD );

71
include/listbox.h
View File

@ -1,71 +0,0 @@
/*
* Listbox definitions
*/
typedef struct tagLISTSTRUCT {
MEASUREITEMSTRUCT16 mis;
UINT16 itemState;
RECT16 itemRect;
HLOCAL16 hData;
char *itemText;
struct tagLISTSTRUCT *lpNext;
} LISTSTRUCT, *LPLISTSTRUCT;
typedef struct {
WORD FirstVisible;
WORD ItemsCount;
WORD ItemsVisible;
WORD ColumnsVisible;
WORD ItemsPerColumn;
short ItemFocused;
short PrevFocused;
WORD StdItemHeight;
WORD ColumnsWidth;
WORD DrawCtlType;
WORD CtlID;
LPLISTSTRUCT lpFirst;
HWND16 hSelf;
DWORD dwStyle; /* added for COMBOLBOX style faking */
HWND16 hParent;
HFONT16 hFont;
BOOL32 bRedrawFlag;
BOOL32 HasStrings;
BOOL32 OwnerDrawn;
WORD iNumStops;
LPINT16 TabStops;
BOOL32 needMeasure;
HGLOBAL16 HeapSel;
/* MDESC *Heap; */
} HEADLIST,*LPHEADLIST;
/* shared code between listbox and combo controls */
extern void CreateListBoxStruct(HWND16 hwnd, WORD CtlType, LONG styles, HWND16 parent);
extern void DestroyListBoxStruct(LPHEADLIST lphl);
extern void ListBoxSendNotification(LPHEADLIST lphl, WORD code);
extern LPLISTSTRUCT ListBoxGetItem(LPHEADLIST lphl, UINT16 uIndex);
extern int ListMaxFirstVisible(LPHEADLIST lphl);
extern int ListBoxScrollToFocus(LPHEADLIST lphl);
extern int ListBoxAddString(LPHEADLIST lphl, SEGPTR itemData);
extern int ListBoxInsertString(LPHEADLIST lphl, UINT16 uIndex, LPCSTR newstr);
extern int ListBoxGetText(LPHEADLIST lphl, UINT16 uIndex, LPSTR OutStr);
extern DWORD ListBoxGetItemData(LPHEADLIST lphl, UINT16 uIndex);
extern int ListBoxSetItemData(LPHEADLIST lphl, UINT16 uIndex, DWORD ItemData);
extern int ListBoxDeleteString(LPHEADLIST lphl, UINT16 uIndex);
extern int ListBoxFindString(LPHEADLIST lphl, UINT16 nFirst, SEGPTR MatchStr);
extern int ListBoxFindStringExact(LPHEADLIST lphl, UINT16 nFirst, SEGPTR MatchStr);
extern int ListBoxResetContent(LPHEADLIST lphl);
extern int ListBoxSetCurSel(LPHEADLIST lphl, WORD wIndex);
extern int ListBoxSetSel(LPHEADLIST lphl, WORD wIndex, WORD state);
extern int ListBoxGetSel(LPHEADLIST lphl, WORD wIndex);
extern LONG ListBoxDirectory(LPHEADLIST lphl, UINT16 attrib, LPCSTR filespec);
extern int ListBoxGetItemRect(LPHEADLIST lphl, WORD wIndex, LPRECT16 rect);
extern int ListBoxSetItemHeight(LPHEADLIST lphl, WORD wIndex, long height);
extern int ListBoxFindNextMatch(LPHEADLIST lphl, WORD wChar);
extern void ListBoxDrawItem (HWND16 hwnd, LPHEADLIST lphl, HDC16 hdc,
LPLISTSTRUCT lpls, RECT16 *rect, WORD itemAction,
WORD itemState);
extern int ListBoxFindMouse(LPHEADLIST lphl, int X, int Y);
extern void ListBoxAskMeasure(LPHEADLIST lphl, LPLISTSTRUCT lpls);

4
include/mdi.h
View File

@ -20,8 +20,8 @@
#define WM_MDICALCCHILDSCROLL 0x10AC /* this is exactly what Windows uses */
extern LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message,
WPARAM16 wParam, LPARAM lParam); /* mdi.c */
extern LRESULT WINAPI MDIClientWndProc(HWND16 hwnd, UINT16 message,
WPARAM16 wParam, LPARAM lParam);
typedef struct
{

1
include/menu.h
View File

@ -7,7 +7,6 @@
extern BOOL32 MENU_Init(void);
extern HMENU32 MENU_GetSysMenu(HWND32 hWndOwner, HMENU32 hSysPopup);
extern void MENU_InitSysMenuPopup(HMENU32 hmenu, DWORD style, DWORD clsStyle);
extern UINT32 MENU_GetMenuBarHeight( HWND32 hwnd, UINT32 menubarWidth,
INT32 orgX, INT32 orgY );
extern void MENU_TrackMouseMenuBar( WND *wnd, INT32 ht, POINT32 pt );

6
include/message.h
View File

@ -26,8 +26,12 @@ extern void TIMER_ExpireTimers(void);
extern BOOL32 TIMER_GetTimerMsg( MSG16 *msg, HWND32 hwnd,
HQUEUE16 hQueue, BOOL32 remove );
#define EVENT_IO_READ 0
#define EVENT_IO_WRITE 1
#define EVENT_IO_EXCEPT 2
/* event.c */
extern BOOL32 EVENT_WaitXEvent( BOOL32 sleep, BOOL32 peek );
extern BOOL32 EVENT_WaitNetEvent( BOOL32 sleep, BOOL32 peek );
extern void EVENT_Synchronize(void);
extern void EVENT_ProcessEvent( XEvent *event );
extern void EVENT_RegisterWindow( WND *pWnd );

300
include/mmsystem.h
View File

@ -108,7 +108,7 @@ typedef struct {
#define CALLBACK_TASK 0x00020000l /* dwCallback is a HTASK */
#define CALLBACK_FUNCTION 0x00030000l /* dwCallback is a FARPROC */
typedef void (*LPDRVCALLBACK) (HDRVR16 h, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
typedef void (CALLBACK *LPDRVCALLBACK) (HDRVR16 h, UINT16 uMessage, DWORD dwUser, DWORD dw1, DWORD dw2);
#define MM_MICROSOFT 1 /* Microsoft Corp. */
@ -129,10 +129,8 @@ typedef void (*LPDRVCALLBACK) (HDRVR16 h, UINT16 uMessage, DWORD dwUser, DWORD d
#define MM_PC_JOYSTICK 12 /* Joystick adapter */
WORD mmsystemGetVersion(void);
void OutputDebugStr(LPCSTR);
BOOL16 sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags);
WORD WINAPI mmsystemGetVersion(void);
BOOL16 WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags);
#define SND_SYNC 0x0000 /* play synchronously (default) */
#define SND_ASYNC 0x0001 /* play asynchronously */
@ -237,57 +235,60 @@ typedef struct {
WORD wBitsPerSample;
} PCMWAVEFORMAT, *LPPCMWAVEFORMAT;
UINT16 waveOutGetNumDevs(void);
UINT16 waveOutGetDevCaps(UINT16 uDeviceID, WAVEOUTCAPS * lpCaps,
UINT16 uSize);
UINT16 waveOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume);
UINT16 waveOutSetVolume(UINT16 uDeviceID, DWORD dwVolume);
UINT16 waveOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
UINT16 WINAPI waveOutGetNumDevs(void);
UINT16 WINAPI waveOutGetDevCaps(UINT16 uDeviceID, WAVEOUTCAPS * lpCaps,
UINT16 uSize);
UINT16 WINAPI waveOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume);
UINT16 WINAPI waveOutSetVolume(UINT16 uDeviceID, DWORD dwVolume);
UINT16 WINAPI waveOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 WINAPI waveGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 WINAPI waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID,
const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
UINT16 waveOutClose(HWAVEOUT16 hWaveOut);
UINT16 waveOutPrepareHeader(HWAVEOUT16 hWaveOut,
WAVEHDR * lpWaveOutHdr, UINT16 uSize);
UINT16 waveOutUnprepareHeader(HWAVEOUT16 hWaveOut,
WAVEHDR * lpWaveOutHdr, UINT16 uSize);
UINT16 waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
UINT16 uSize);
UINT16 waveOutPause(HWAVEOUT16 hWaveOut);
UINT16 waveOutRestart(HWAVEOUT16 hWaveOut);
UINT16 waveOutReset(HWAVEOUT16 hWaveOut);
UINT16 waveOutBreakLoop(HWAVEOUT16 hWaveOut);
UINT16 waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpInfo,
UINT16 uSize);
UINT16 waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch);
UINT16 waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch);
UINT16 waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate);
UINT16 waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate);
UINT16 waveOutGetID(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID);
UINT16 WINAPI waveOutClose(HWAVEOUT16 hWaveOut);
UINT16 WINAPI waveOutPrepareHeader(HWAVEOUT16 hWaveOut,
WAVEHDR *lpWaveOutHdr, UINT16 uSize);
UINT16 WINAPI waveOutUnprepareHeader(HWAVEOUT16 hWaveOut,
WAVEHDR *lpWaveOutHdr, UINT16 uSize);
UINT16 WINAPI waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr,
UINT16 uSize);
UINT16 WINAPI waveOutPause(HWAVEOUT16 hWaveOut);
UINT16 WINAPI waveOutRestart(HWAVEOUT16 hWaveOut);
UINT16 WINAPI waveOutReset(HWAVEOUT16 hWaveOut);
UINT16 WINAPI waveOutBreakLoop(HWAVEOUT16 hWaveOut);
UINT16 WINAPI waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpInfo,
UINT16 uSize);
UINT16 WINAPI waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch);
UINT16 WINAPI waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch);
UINT16 WINAPI waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate);
UINT16 WINAPI waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate);
UINT16 WINAPI waveOutGetID(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID);
DWORD waveOutMessage(HWAVEOUT16 hWaveOut, UINT16 uMessage, DWORD dw1, DWORD dw2);
DWORD WINAPI waveOutMessage(HWAVEOUT16 hWaveOut, UINT16 uMessage, DWORD dw1,
DWORD dw2);
UINT16 waveInGetNumDevs(void);
UINT16 waveInGetDevCaps(UINT16 uDeviceID, WAVEINCAPS * lpCaps,
UINT16 uSize);
UINT16 waveInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 waveInOpen(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
UINT16 waveInClose(HWAVEIN16 hWaveIn);
UINT16 waveInPrepareHeader(HWAVEIN16 hWaveIn,
WAVEHDR * lpWaveInHdr, UINT16 uSize);
UINT16 waveInUnprepareHeader(HWAVEIN16 hWaveIn,
WAVEHDR * lpWaveInHdr, UINT16 uSize);
UINT16 waveInAddBuffer(HWAVEIN16 hWaveIn,
WAVEHDR * lpWaveInHdr, UINT16 uSize);
UINT16 waveInStart(HWAVEIN16 hWaveIn);
UINT16 waveInStop(HWAVEIN16 hWaveIn);
UINT16 waveInReset(HWAVEIN16 hWaveIn);
UINT16 waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpInfo,
UINT16 uSize);
UINT16 waveInGetID(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID);
UINT16 WINAPI waveInGetNumDevs(void);
UINT16 WINAPI waveInGetDevCaps(UINT16 uDeviceID, WAVEINCAPS * lpCaps,
UINT16 uSize);
UINT16 WINAPI waveInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 WINAPI waveInOpen(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID,
const LPWAVEFORMAT lpFormat, DWORD dwCallback,
DWORD dwInstance, DWORD dwFlags);
UINT16 WINAPI waveInClose(HWAVEIN16 hWaveIn);
UINT16 WINAPI waveInPrepareHeader(HWAVEIN16 hWaveIn, WAVEHDR * lpWaveInHdr,
UINT16 uSize);
UINT16 WINAPI waveInUnprepareHeader(HWAVEIN16 hWaveIn, WAVEHDR * lpWaveInHdr,
UINT16 uSize);
UINT16 WINAPI waveInAddBuffer(HWAVEIN16 hWaveIn, WAVEHDR * lpWaveInHdr,
UINT16 uSize);
UINT16 WINAPI waveInStart(HWAVEIN16 hWaveIn);
UINT16 WINAPI waveInStop(HWAVEIN16 hWaveIn);
UINT16 WINAPI waveInReset(HWAVEIN16 hWaveIn);
UINT16 WINAPI waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpInfo,
UINT16 uSize);
UINT16 WINAPI waveInGetID(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID);
DWORD waveInMessage(HWAVEIN16 hWaveIn, UINT16 uMessage, DWORD dw1, DWORD dw2);
DWORD WINAPI waveInMessage(HWAVEIN16 hWaveIn, UINT16 uMessage, DWORD dw1,
DWORD dw2);
#define MIDIERR_UNPREPARED (MIDIERR_BASE + 0) /* header not prepared */
#define MIDIERR_STILLPLAYING (MIDIERR_BASE + 1) /* still something playing */
@ -370,51 +371,51 @@ typedef struct {
#define MHDR_PREPARED 0x00000002 /* set if header prepared */
#define MHDR_INQUEUE 0x00000004 /* reserved for driver */
UINT16 midiOutGetNumDevs(void);
UINT16 midiOutGetDevCaps(UINT16 uDeviceID,
UINT16 WINAPI midiOutGetNumDevs(void);
UINT16 WINAPI midiOutGetDevCaps(UINT16 uDeviceID,
MIDIOUTCAPS * lpCaps, UINT16 uSize);
UINT16 midiOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume);
UINT16 midiOutSetVolume(UINT16 uDeviceID, DWORD dwVolume);
UINT16 midiOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 midiOutOpen(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
UINT16 WINAPI midiOutGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume);
UINT16 WINAPI midiOutSetVolume(UINT16 uDeviceID, DWORD dwVolume);
UINT16 WINAPI midiOutGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 WINAPI midiGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 WINAPI midiOutOpen(HMIDIOUT16 * lphMidiOut, UINT16 uDeviceID,
DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
UINT16 midiOutClose(HMIDIOUT16 hMidiOut);
UINT16 midiOutPrepareHeader(HMIDIOUT16 hMidiOut,
UINT16 WINAPI midiOutClose(HMIDIOUT16 hMidiOut);
UINT16 WINAPI midiOutPrepareHeader(HMIDIOUT16 hMidiOut,
MIDIHDR * lpMidiOutHdr, UINT16 uSize);
UINT16 midiOutUnprepareHeader(HMIDIOUT16 hMidiOut,
UINT16 WINAPI midiOutUnprepareHeader(HMIDIOUT16 hMidiOut,
MIDIHDR * lpMidiOutHdr, UINT16 uSize);
UINT16 midiOutShortMsg(HMIDIOUT16 hMidiOut, DWORD dwMsg);
UINT16 midiOutLongMsg(HMIDIOUT16 hMidiOut,
UINT16 WINAPI midiOutShortMsg(HMIDIOUT16 hMidiOut, DWORD dwMsg);
UINT16 WINAPI midiOutLongMsg(HMIDIOUT16 hMidiOut,
MIDIHDR * lpMidiOutHdr, UINT16 uSize);
UINT16 midiOutReset(HMIDIOUT16 hMidiOut);
UINT16 midiOutCachePatches(HMIDIOUT16 hMidiOut,
UINT16 WINAPI midiOutReset(HMIDIOUT16 hMidiOut);
UINT16 WINAPI midiOutCachePatches(HMIDIOUT16 hMidiOut,
UINT16 uBank, WORD * lpwPatchArray, UINT16 uFlags);
UINT16 midiOutCacheDrumPatches(HMIDIOUT16 hMidiOut,
UINT16 WINAPI midiOutCacheDrumPatches(HMIDIOUT16 hMidiOut,
UINT16 uPatch, WORD * lpwKeyArray, UINT16 uFlags);
UINT16 midiOutGetID(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID);
UINT16 WINAPI midiOutGetID(HMIDIOUT16 hMidiOut, UINT16 * lpuDeviceID);
DWORD midiOutMessage(HMIDIOUT16 hMidiOut, UINT16 uMessage, DWORD dw1, DWORD dw2);
DWORD WINAPI midiOutMessage(HMIDIOUT16 hMidiOut, UINT16 uMessage, DWORD dw1, DWORD dw2);
UINT16 midiInGetNumDevs(void);
UINT16 midiInGetDevCaps(UINT16 uDeviceID,
UINT16 WINAPI midiInGetNumDevs(void);
UINT16 WINAPI midiInGetDevCaps(UINT16 uDeviceID,
LPMIDIINCAPS lpCaps, UINT16 uSize);
UINT16 midiInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 midiInOpen(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
UINT16 WINAPI midiInGetErrorText(UINT16 uError, LPSTR lpText, UINT16 uSize);
UINT16 WINAPI midiInOpen(HMIDIIN16 * lphMidiIn, UINT16 uDeviceID,
DWORD dwCallback, DWORD dwInstance, DWORD dwFlags);
UINT16 midiInClose(HMIDIIN16 hMidiIn);
UINT16 midiInPrepareHeader(HMIDIIN16 hMidiIn,
UINT16 WINAPI midiInClose(HMIDIIN16 hMidiIn);
UINT16 WINAPI midiInPrepareHeader(HMIDIIN16 hMidiIn,
MIDIHDR * lpMidiInHdr, UINT16 uSize);
UINT16 midiInUnprepareHeader(HMIDIIN16 hMidiIn,
UINT16 WINAPI midiInUnprepareHeader(HMIDIIN16 hMidiIn,
MIDIHDR * lpMidiInHdr, UINT16 uSize);
UINT16 midiInAddBuffer(HMIDIIN16 hMidiIn,
UINT16 WINAPI midiInAddBuffer(HMIDIIN16 hMidiIn,
MIDIHDR * lpMidiInHdr, UINT16 uSize);
UINT16 midiInStart(HMIDIIN16 hMidiIn);
UINT16 midiInStop(HMIDIIN16 hMidiIn);
UINT16 midiInReset(HMIDIIN16 hMidiIn);
UINT16 midiInGetID(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID);
UINT16 WINAPI midiInStart(HMIDIIN16 hMidiIn);
UINT16 WINAPI midiInStop(HMIDIIN16 hMidiIn);
UINT16 WINAPI midiInReset(HMIDIIN16 hMidiIn);
UINT16 WINAPI midiInGetID(HMIDIIN16 hMidiIn, UINT16 * lpuDeviceID);
DWORD midiInMessage(HMIDIIN16 hMidiIn, UINT16 uMessage, DWORD dw1, DWORD dw2);
DWORD WINAPI midiInMessage(HMIDIIN16 hMidiIn, UINT16 uMessage, DWORD dw1, DWORD dw2);
#define AUX_MAPPER (-1)
@ -433,12 +434,12 @@ typedef struct {
#define AUXCAPS_VOLUME 0x0001 /* supports volume control */
#define AUXCAPS_LRVOLUME 0x0002 /* separate left-right volume control */
UINT16 auxGetNumDevs(void);
UINT16 auxGetDevCaps(UINT16 uDeviceID, AUXCAPS * lpCaps, UINT16 uSize);
UINT16 auxSetVolume(UINT16 uDeviceID, DWORD dwVolume);
UINT16 auxGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume);
UINT16 WINAPI auxGetNumDevs(void);
UINT16 WINAPI auxGetDevCaps(UINT16 uDeviceID, AUXCAPS * lpCaps, UINT16 uSize);
UINT16 WINAPI auxSetVolume(UINT16 uDeviceID, DWORD dwVolume);
UINT16 WINAPI auxGetVolume(UINT16 uDeviceID, DWORD * lpdwVolume);
DWORD auxOutMessage(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2);
DWORD WINAPI auxOutMessage(UINT16 uDeviceID, UINT16 uMessage, DWORD dw1, DWORD dw2);
#define TIMERR_NOERROR (0) /* no error */
#define TIMERR_NOCANDO (TIMERR_BASE+1) /* request not completed */
@ -454,14 +455,14 @@ typedef struct {
UINT16 wPeriodMax; /* maximum period supported */
} TIMECAPS, *LPTIMECAPS;
UINT16 timeGetSystemTime(MMTIME * lpTime, UINT16 uSize);
DWORD timeGetTime(void);
UINT16 timeSetEvent(UINT16 uDelay, UINT16 uResolution,
UINT16 WINAPI timeGetSystemTime(MMTIME * lpTime, UINT16 uSize);
DWORD WINAPI timeGetTime(void);
UINT16 WINAPI timeSetEvent(UINT16 uDelay, UINT16 uResolution,
LPTIMECALLBACK lpFunction, DWORD dwUser, UINT16 uFlags);
UINT16 timeKillEvent(UINT16 uTimerID);
UINT16 timeGetDevCaps(TIMECAPS * lpTimeCaps, UINT16 uSize);
UINT16 timeBeginPeriod(UINT16 uPeriod);
UINT16 timeEndPeriod(UINT16 uPeriod);
UINT16 WINAPI timeKillEvent(UINT16 uTimerID);
UINT16 WINAPI timeGetDevCaps(TIMECAPS * lpTimeCaps, UINT16 uSize);
UINT16 WINAPI timeBeginPeriod(UINT16 uPeriod);
UINT16 WINAPI timeEndPeriod(UINT16 uPeriod);
#define JOYERR_NOERROR (0) /* no error */
#define JOYERR_PARMS (JOYERR_BASE+5) /* bad parameters */
@ -502,14 +503,14 @@ typedef struct {
UINT16 wButtons; /* button states */
} JOYINFO, *LPJOYINFO;
UINT16 joyGetDevCaps(UINT16 uJoyID, JOYCAPS * lpCaps, UINT16 uSize);
UINT16 joyGetNumDevs(void);
UINT16 joyGetPos(UINT16 uJoyID, JOYINFO * lpInfo);
UINT16 joyGetThreshold(UINT16 uJoyID, UINT16 * lpuThreshold);
UINT16 joyReleaseCapture(UINT16 uJoyID);
UINT16 joySetCapture(HWND16 hwnd, UINT16 uJoyID, UINT16 uPeriod,
UINT16 WINAPI joyGetDevCaps(UINT16 uJoyID, JOYCAPS * lpCaps, UINT16 uSize);
UINT16 WINAPI joyGetNumDevs(void);
UINT16 WINAPI joyGetPos(UINT16 uJoyID, JOYINFO * lpInfo);
UINT16 WINAPI joyGetThreshold(UINT16 uJoyID, UINT16 * lpuThreshold);
UINT16 WINAPI joyReleaseCapture(UINT16 uJoyID);
UINT16 WINAPI joySetCapture(HWND16 hwnd, UINT16 uJoyID, UINT16 uPeriod,
BOOL16 bChanged);
UINT16 joySetThreshold(UINT16 uJoyID, UINT16 uThreshold);
UINT16 WINAPI joySetThreshold(UINT16 uJoyID, UINT16 uThreshold);
#define MMIOERR_BASE 256
#define MMIOERR_FILENOTFOUND (MMIOERR_BASE + 1) /* file not found */
@ -526,8 +527,8 @@ UINT16 joySetThreshold(UINT16 uJoyID, UINT16 uThreshold);
#define CFSEPCHAR '+' /* compound file name separator char. */
typedef DWORD FOURCC; /* a four character code */
typedef LONG (*LPMMIOPROC)(LPSTR lpmmioinfo, UINT16 uMessage,
LPARAM lParam1, LPARAM lParam2);
typedef LONG (CALLBACK *LPMMIOPROC)(LPSTR lpmmioinfo, UINT16 uMessage,
LPARAM lParam1, LPARAM lParam2);
typedef struct {
DWORD dwFlags; /* general status flags */
@ -622,48 +623,49 @@ typedef struct _MMCKINFO
( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \
( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
FOURCC mmioStringToFOURCC(LPCSTR sz, UINT16 uFlags);
LPMMIOPROC mmioInstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
FOURCC WINAPI mmioStringToFOURCC(LPCSTR sz, UINT16 uFlags);
LPMMIOPROC WINAPI mmioInstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
DWORD dwFlags);
HMMIO16 mmioOpen(LPSTR szFileName, MMIOINFO * lpmmioinfo,
HMMIO16 WINAPI mmioOpen(LPSTR szFileName, MMIOINFO * lpmmioinfo,
DWORD dwOpenFlags);
UINT16 mmioRename(LPCSTR szFileName, LPCSTR szNewFileName,
UINT16 WINAPI mmioRename(LPCSTR szFileName, LPCSTR szNewFileName,
MMIOINFO * lpmmioinfo, DWORD dwRenameFlags);
UINT16 mmioClose(HMMIO16 hmmio, UINT16 uFlags);
LONG mmioRead(HMMIO16 hmmio, HPSTR pch, LONG cch);
LONG mmioWrite(HMMIO16 hmmio, HPCSTR pch, LONG cch);
LONG mmioSeek(HMMIO16 hmmio, LONG lOffset, int iOrigin);
UINT16 mmioGetInfo(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags);
UINT16 mmioSetInfo(HMMIO16 hmmio, const MMIOINFO * lpmmioinfo, UINT16 uFlags);
UINT16 mmioSetBuffer(HMMIO16 hmmio, LPSTR pchBuffer, LONG cchBuffer,
UINT16 WINAPI mmioClose(HMMIO16 hmmio, UINT16 uFlags);
LONG WINAPI mmioRead(HMMIO16 hmmio, HPSTR pch, LONG cch);
LONG WINAPI mmioWrite(HMMIO16 hmmio, HPCSTR pch, LONG cch);
LONG WINAPI mmioSeek(HMMIO16 hmmio, LONG lOffset, int iOrigin);
UINT16 WINAPI mmioGetInfo(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags);
UINT16 WINAPI mmioSetInfo(HMMIO16 hmmio, const MMIOINFO * lpmmioinfo, UINT16 uFlags);
UINT16 WINAPI mmioSetBuffer(HMMIO16 hmmio, LPSTR pchBuffer, LONG cchBuffer,
UINT16 uFlags);
UINT16 mmioFlush(HMMIO16 hmmio, UINT16 uFlags);
UINT16 mmioAdvance(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags);
LONG mmioSendMessage(HMMIO16 hmmio, UINT16 uMessage,
UINT16 WINAPI mmioFlush(HMMIO16 hmmio, UINT16 uFlags);
UINT16 WINAPI mmioAdvance(HMMIO16 hmmio, MMIOINFO * lpmmioinfo, UINT16 uFlags);
LONG WINAPI mmioSendMessage(HMMIO16 hmmio, UINT16 uMessage,
LPARAM lParam1, LPARAM lParam2);
UINT16 mmioDescend(HMMIO16 hmmio, MMCKINFO * lpck,
UINT16 WINAPI mmioDescend(HMMIO16 hmmio, MMCKINFO * lpck,
const MMCKINFO * lpckParent, UINT16 uFlags);
UINT16 mmioAscend(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags);
UINT16 mmioCreateChunk(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags);
UINT16 WINAPI mmioAscend(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags);
UINT16 WINAPI mmioCreateChunk(HMMIO16 hmmio, MMCKINFO * lpck, UINT16 uFlags);
typedef UINT16 (*YIELDPROC) (UINT16 uDeviceID, DWORD dwYieldData);
typedef UINT16 (CALLBACK *YIELDPROC) (UINT16 uDeviceID, DWORD dwYieldData);
DWORD mciSendCommand (UINT16 uDeviceID, UINT16 uMessage,
DWORD dwParam1, DWORD dwParam2);
DWORD mciSendString (LPCSTR lpstrCommand,
LPSTR lpstrReturnString, UINT16 uReturnLength, HWND16 hwndCallback);
UINT16 mciGetDeviceID (LPCSTR lpstrName);
UINT16 mciGetDeviceIDFromElementID (DWORD dwElementID,
LPCSTR lpstrType);
BOOL16 mciGetErrorString (DWORD wError, LPSTR lpstrBuffer,
UINT16 uLength);
BOOL16 mciSetYieldProc (UINT16 uDeviceID, YIELDPROC fpYieldProc,
DWORD dwYieldData);
DWORD WINAPI mciSendCommand (UINT16 uDeviceID, UINT16 uMessage,
DWORD dwParam1, DWORD dwParam2);
DWORD WINAPI mciSendString (LPCSTR lpstrCommand,
LPSTR lpstrReturnString, UINT16 uReturnLength,
HWND16 hwndCallback);
UINT16 WINAPI mciGetDeviceID (LPCSTR lpstrName);
UINT16 WINAPI mciGetDeviceIDFromElementID (DWORD dwElementID,
LPCSTR lpstrType);
BOOL16 WINAPI mciGetErrorString (DWORD wError, LPSTR lpstrBuffer,
UINT16 uLength);
BOOL16 WINAPI mciSetYieldProc (UINT16 uDeviceID, YIELDPROC fpYieldProc,
DWORD dwYieldData);
HTASK16 mciGetCreatorTask(UINT16 uDeviceID);
YIELDPROC mciGetYieldProc (UINT16 uDeviceID, DWORD * lpdwYieldData);
HTASK16 WINAPI mciGetCreatorTask(UINT16 uDeviceID);
YIELDPROC WINAPI mciGetYieldProc (UINT16 uDeviceID, DWORD * lpdwYieldData);
#define MCIERR_INVALID_DEVICE_ID (MCIERR_BASE + 1)
#define MCIERR_UNRECOGNIZED_KEYWORD (MCIERR_BASE + 3)
@ -1514,14 +1516,14 @@ typedef struct {
/* filled in by the driver */
} MCI_OPEN_DRIVER_PARMS, * LPMCI_OPEN_DRIVER_PARMS;
DWORD mciGetDriverData(UINT16 uDeviceID);
BOOL16 mciSetDriverData(UINT16 uDeviceID, DWORD dwData);
UINT16 mciDriverYield(UINT16 uDeviceID);
BOOL16 mciDriverNotify(HWND16 hwndCallback, UINT16 uDeviceID,
UINT16 uStatus);
UINT16 mciLoadCommandResource(HINSTANCE16 hInstance,
LPCSTR lpResName, UINT16 uType);
BOOL16 mciFreeCommandResource(UINT16 uTable);
DWORD WINAPI mciGetDriverData(UINT16 uDeviceID);
BOOL16 WINAPI mciSetDriverData(UINT16 uDeviceID, DWORD dwData);
UINT16 WINAPI mciDriverYield(UINT16 uDeviceID);
BOOL16 WINAPI mciDriverNotify(HWND16 hwndCallback, UINT16 uDeviceID,
UINT16 uStatus);
UINT16 WINAPI mciLoadCommandResource(HINSTANCE16 hInstance,
LPCSTR lpResName, UINT16 uType);
BOOL16 WINAPI mciFreeCommandResource(UINT16 uTable);
#define DCB_NULL 0x0000
#define DCB_WINDOW 0x0001 /* dwCallback is a HWND */
@ -1530,17 +1532,17 @@ BOOL16 mciFreeCommandResource(UINT16 uTable);
#define DCB_TYPEMASK 0x0007
#define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */
BOOL16 DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
DWORD auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
BOOL16 WINAPI DriverCallback(DWORD dwCallBack, UINT16 uFlags, HANDLE16 hDev,
WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
DWORD WINAPI auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
DWORD midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD WINAPI midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
DWORD modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD WINAPI modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
DWORD widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD WINAPI widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
DWORD wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD WINAPI wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2);
#endif /* __WINE_MMSYSTEM_H */

2
include/msdos.h
View File

@ -55,8 +55,6 @@ typedef struct
DWORD filesize; /* 1c file size */
} DOS_DIRENTRY_LAYOUT;
#define DOSVERSION 0x1606 /* Major version in low byte: DOS 6.22 */
#define WINDOSVER 0x0616 /* Windows reports the DOS version reversed */
#define WINVERSION 0x0a03 /* Windows version 3.10 */
#define MAX_DOS_DRIVES 26

1
include/neexe.h
View File

@ -37,6 +37,7 @@ typedef struct
#define IMAGE_DOS_SIGNATURE 0x5A4D /* MZ */
#define IMAGE_OS2_SIGNATURE 0x454E /* NE */
#define IMAGE_OS2_SIGNATURE_LE 0x454C /* LE */
#define IMAGE_OS2_SIGNATURE_LX 0x584C /* LX */
#define IMAGE_VXD_SIGNATURE 0x454C /* LE */
#define IMAGE_NT_SIGNATURE 0x00004550 /* PE00 */

128
include/ole.h
View File

@ -151,8 +151,8 @@ typedef struct _OLETARGETDEVICE {
} OLETARGETDEVICE;
typedef struct _OLESTREAM* LPOLESTREAM;
typedef struct _OLESTREAMVTBL {
DWORD (*Get)(LPOLESTREAM,LPSTR,DWORD);
DWORD (*Put)(LPOLESTREAM,LPSTR,DWORD);
DWORD (CALLBACK *Get)(LPOLESTREAM,LPSTR,DWORD);
DWORD (CALLBACK *Put)(LPOLESTREAM,LPSTR,DWORD);
} OLESTREAMVTBL;
typedef OLESTREAMVTBL* LPOLESTREAMVTBL;
typedef struct _OLESTREAM {
@ -162,15 +162,15 @@ typedef struct _OLESERVERDOC* LPOLESERVERDOC;
typedef struct _OLEOBJECT* LPOLEOBJECT;
typedef struct _OLECLIENT* LPOLECLIENT;
typedef struct _OLESERVERDOCVTBL {
OLESTATUS (*Save)(LPOLESERVERDOC);
OLESTATUS (*Close)(LPOLESERVERDOC);
OLESTATUS (*SetHostNames)(LPOLESERVERDOC,OLE_LPCSTR,OLE_LPCSTR);
OLESTATUS (*SetDocDimensions)(LPOLESERVERDOC,LPRECT16);
OLESTATUS (CALLBACK *Save)(LPOLESERVERDOC);
OLESTATUS (CALLBACK *Close)(LPOLESERVERDOC);
OLESTATUS (CALLBACK *SetHostNames)(LPOLESERVERDOC,OLE_LPCSTR,OLE_LPCSTR);
OLESTATUS (CALLBACK *SetDocDimensions)(LPOLESERVERDOC,LPRECT16);
#undef GetObject /* FIXME */
OLESTATUS (*GetObject)(LPOLESERVERDOC,OLE_LPCSTR,LPOLEOBJECT*,LPOLECLIENT);
OLESTATUS (*Release)(LPOLESERVERDOC);
OLESTATUS (*SetColorScheme)(LPOLESERVERDOC,LPLOGPALETTE);
OLESTATUS (*Execute)(LPOLESERVERDOC,HGLOBAL16);
OLESTATUS (CALLBACK *GetObject)(LPOLESERVERDOC,OLE_LPCSTR,LPOLEOBJECT*,LPOLECLIENT);
OLESTATUS (CALLBACK *Release)(LPOLESERVERDOC);
OLESTATUS (CALLBACK *SetColorScheme)(LPOLESERVERDOC,LPLOGPALETTE);
OLESTATUS (CALLBACK *Execute)(LPOLESERVERDOC,HGLOBAL16);
} OLESERVERDOCVTBL;
typedef OLESERVERDOCVTBL* LPOLESERVERDOCVTBL;
typedef struct _OLESERVERDOC {
@ -180,13 +180,13 @@ typedef struct _OLESERVERDOC {
typedef struct _OLESERVER* LPOLESERVER;
typedef struct _OLESERVERVTBL {
OLESTATUS (*Open)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,LPOLESERVERDOC *);
OLESTATUS (*Create)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,OLE_LPCSTR,LPOLESERVERDOC*);
OLESTATUS (*CreateFromTemplate)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,OLE_LPCSTR,OLE_LPCSTR,LPOLESERVERDOC *);
OLESTATUS (*Edit)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,OLE_LPCSTR,LPOLESERVERDOC *);
OLESTATUS (*Exit)(LPOLESERVER);
OLESTATUS (*Release)(LPOLESERVER);
OLESTATUS (*Execute)(LPOLESERVER);
OLESTATUS (CALLBACK *Open)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,LPOLESERVERDOC *);
OLESTATUS (CALLBACK *Create)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,OLE_LPCSTR,LPOLESERVERDOC*);
OLESTATUS (CALLBACK *CreateFromTemplate)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,OLE_LPCSTR,OLE_LPCSTR,LPOLESERVERDOC *);
OLESTATUS (CALLBACK *Edit)(LPOLESERVER,LHSERVERDOC,OLE_LPCSTR,OLE_LPCSTR,LPOLESERVERDOC *);
OLESTATUS (CALLBACK *Exit)(LPOLESERVER);
OLESTATUS (CALLBACK *Release)(LPOLESERVER);
OLESTATUS (CALLBACK *Execute)(LPOLESERVER);
} OLESERVERVTBL;
typedef OLESERVERVTBL *LPOLESERVERVTBL;
typedef struct _OLESERVER {
@ -194,7 +194,7 @@ typedef struct _OLESERVER {
/* server specific data */
} OLESERVER;
typedef struct _OLECLIENTVTBL {
int (*CallBack)(LPOLECLIENT,OLE_NOTIFICATION,LPOLEOBJECT);
int (CALLBACK *CallBack)(LPOLECLIENT,OLE_NOTIFICATION,LPOLEOBJECT);
} OLECLIENTVTBL;
typedef OLECLIENTVTBL *LPOLECLIENTVTBL;
@ -204,44 +204,44 @@ typedef struct _OLECLIENT {
} OLECLIENT;
typedef struct _OLEOBJECTVTBL {
void * (*QueryProtocol)(LPOLEOBJECT,OLE_LPCSTR);
OLESTATUS (*Release)(LPOLEOBJECT);
OLESTATUS (*Show)(LPOLEOBJECT,BOOL16);
OLESTATUS (*DoVerb)(LPOLEOBJECT,UINT16,BOOL16,BOOL16);
OLESTATUS (*GetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16 *);
OLESTATUS (*SetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16);
OLESTATUS (*SetTargetDevice)(LPOLEOBJECT,HGLOBAL16);
OLESTATUS (*SetBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS (*EnumFormats)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS (*SetColorScheme)(LPOLEOBJECT,LPLOGPALETTE);
OLESTATUS (*Delete)(LPOLEOBJECT);
OLESTATUS (*SetHostNames)(LPOLEOBJECT,OLE_LPCSTR,OLE_LPCSTR);
OLESTATUS (*SaveToStream)(LPOLEOBJECT,LPOLESTREAM);
OLESTATUS (*Clone)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,OLE_LPCSTR,LPOLEOBJECT *);
OLESTATUS (*CopyFromLink)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,OLE_LPCSTR,LPOLEOBJECT *);
OLESTATUS (*Equal)(LPOLEOBJECT,LPOLEOBJECT);
OLESTATUS (*CopyToClipBoard)(LPOLEOBJECT);
OLESTATUS (*Draw)(LPOLEOBJECT,HDC16,LPRECT16,LPRECT16,HDC16);
OLESTATUS (*Activate)(LPOLEOBJECT,UINT16,BOOL16,BOOL16,HWND16,LPRECT16);
OLESTATUS (*Execute)(LPOLEOBJECT,HGLOBAL16,UINT16);
OLESTATUS (*Close)(LPOLEOBJECT);
OLESTATUS (*Update)(LPOLEOBJECT);
OLESTATUS (*Reconnect)(LPOLEOBJECT);
OLESTATUS (*ObjectConvert)(LPOLEOBJECT,OLE_LPCSTR,LPOLECLIENT,LHCLIENTDOC,OLE_LPCSTR,LPOLEOBJECT*);
OLESTATUS (*GetLinkUpdateOptions)(LPOLEOBJECT,LPOLEOPT_UPDATE);
OLESTATUS (*SetLinkUpdateOptions)(LPOLEOBJECT,OLEOPT_UPDATE);
OLESTATUS (*Rename)(LPOLEOBJECT,OLE_LPCSTR);
OLESTATUS (*QueryName)(LPOLEOBJECT,LPSTR,LPUINT16);
OLESTATUS (*QueryType)(LPOLEOBJECT,LPLONG);
OLESTATUS (*QueryBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS (*QuerySize)(LPOLEOBJECT,LPDWORD);
OLESTATUS (*QueryOpen)(LPOLEOBJECT);
OLESTATUS (*QueryOutOfDate)(LPOLEOBJECT);
OLESTATUS (*QueryReleaseStatus)(LPOLEOBJECT);
OLESTATUS (*QueryReleaseError)(LPOLEOBJECT);
OLE_RELEASE_METHOD (*QueryReleaseMethod)(LPOLEOBJECT);
OLESTATUS (*RequestData)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS (*ObjectLong)(LPOLEOBJECT,UINT16,LPLONG);
void * (CALLBACK *QueryProtocol)(LPOLEOBJECT,OLE_LPCSTR);
OLESTATUS (CALLBACK *Release)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Show)(LPOLEOBJECT,BOOL16);
OLESTATUS (CALLBACK *DoVerb)(LPOLEOBJECT,UINT16,BOOL16,BOOL16);
OLESTATUS (CALLBACK *GetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16 *);
OLESTATUS (CALLBACK *SetData)(LPOLEOBJECT,OLECLIPFORMAT,HANDLE16);
OLESTATUS (CALLBACK *SetTargetDevice)(LPOLEOBJECT,HGLOBAL16);
OLESTATUS (CALLBACK *SetBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS (CALLBACK *EnumFormats)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS (CALLBACK *SetColorScheme)(LPOLEOBJECT,LPLOGPALETTE);
OLESTATUS (CALLBACK *Delete)(LPOLEOBJECT);
OLESTATUS (CALLBACK *SetHostNames)(LPOLEOBJECT,OLE_LPCSTR,OLE_LPCSTR);
OLESTATUS (CALLBACK *SaveToStream)(LPOLEOBJECT,LPOLESTREAM);
OLESTATUS (CALLBACK *Clone)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,OLE_LPCSTR,LPOLEOBJECT *);
OLESTATUS (CALLBACK *CopyFromLink)(LPOLEOBJECT,LPOLECLIENT,LHCLIENTDOC,OLE_LPCSTR,LPOLEOBJECT *);
OLESTATUS (CALLBACK *Equal)(LPOLEOBJECT,LPOLEOBJECT);
OLESTATUS (CALLBACK *CopyToClipBoard)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Draw)(LPOLEOBJECT,HDC16,LPRECT16,LPRECT16,HDC16);
OLESTATUS (CALLBACK *Activate)(LPOLEOBJECT,UINT16,BOOL16,BOOL16,HWND16,LPRECT16);
OLESTATUS (CALLBACK *Execute)(LPOLEOBJECT,HGLOBAL16,UINT16);
OLESTATUS (CALLBACK *Close)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Update)(LPOLEOBJECT);
OLESTATUS (CALLBACK *Reconnect)(LPOLEOBJECT);
OLESTATUS (CALLBACK *ObjectConvert)(LPOLEOBJECT,OLE_LPCSTR,LPOLECLIENT,LHCLIENTDOC,OLE_LPCSTR,LPOLEOBJECT*);
OLESTATUS (CALLBACK *GetLinkUpdateOptions)(LPOLEOBJECT,LPOLEOPT_UPDATE);
OLESTATUS (CALLBACK *SetLinkUpdateOptions)(LPOLEOBJECT,OLEOPT_UPDATE);
OLESTATUS (CALLBACK *Rename)(LPOLEOBJECT,OLE_LPCSTR);
OLESTATUS (CALLBACK *QueryName)(LPOLEOBJECT,LPSTR,LPUINT16);
OLESTATUS (CALLBACK *QueryType)(LPOLEOBJECT,LPLONG);
OLESTATUS (CALLBACK *QueryBounds)(LPOLEOBJECT,LPRECT16);
OLESTATUS (CALLBACK *QuerySize)(LPOLEOBJECT,LPDWORD);
OLESTATUS (CALLBACK *QueryOpen)(LPOLEOBJECT);
OLESTATUS (CALLBACK *QueryOutOfDate)(LPOLEOBJECT);
OLESTATUS (CALLBACK *QueryReleaseStatus)(LPOLEOBJECT);
OLESTATUS (CALLBACK *QueryReleaseError)(LPOLEOBJECT);
OLE_RELEASE_METHOD (CALLBACK *QueryReleaseMethod)(LPOLEOBJECT);
OLESTATUS (CALLBACK *RequestData)(LPOLEOBJECT,OLECLIPFORMAT);
OLESTATUS (CALLBACK *ObjectLong)(LPOLEOBJECT,UINT16,LPLONG);
} OLEOBJECTVTBL;
typedef OLEOBJECTVTBL* LPOLEOBJECTVTBL;
@ -250,13 +250,13 @@ typedef struct _OLEOBJECT {
} OLEOBJECT;
OLESTATUS OleRegisterServer(LPCSTR,LPOLESERVER,LHSERVER *,HINSTANCE16,OLE_SERVER_USE);
OLESTATUS OleUnblockServer(LHSERVER,BOOL16 *);
OLESTATUS OleRegisterServerDoc(LHSERVER,LPCSTR,LPOLESERVERDOC,LHSERVERDOC *);
OLESTATUS OleRegisterClientDoc(LPCSTR,LPCSTR,LONG,LHCLIENTDOC *);
OLESTATUS OleRenameClientDoc(LHCLIENTDOC,LPCSTR);
OLESTATUS OleRevokeServerDoc(LHSERVERDOC);
OLESTATUS OleRevokeClientDoc(LHCLIENTDOC);
OLESTATUS OleRevokeServer(LHSERVER);
OLESTATUS WINAPI OleRegisterServer(LPCSTR,LPOLESERVER,LHSERVER *,HINSTANCE16,OLE_SERVER_USE);
OLESTATUS WINAPI OleUnblockServer(LHSERVER,BOOL16 *);
OLESTATUS WINAPI OleRegisterServerDoc(LHSERVER,LPCSTR,LPOLESERVERDOC,LHSERVERDOC *);
OLESTATUS WINAPI OleRegisterClientDoc(LPCSTR,LPCSTR,LONG,LHCLIENTDOC *);
OLESTATUS WINAPI OleRenameClientDoc(LHCLIENTDOC,LPCSTR);
OLESTATUS WINAPI OleRevokeServerDoc(LHSERVERDOC);
OLESTATUS WINAPI OleRevokeClientDoc(LHCLIENTDOC);
OLESTATUS WINAPI OleRevokeServer(LHSERVER);
#endif /* __WINE_OLE_H */

4
include/peexe.h
View File

@ -97,6 +97,10 @@ typedef struct _IMAGE_OPTIONAL_HEADER
IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
} IMAGE_OPTIONAL_HEADER,*LPIMAGE_OPTIONAL_HEADER;
/* Possible Magic values */
#define IMAGE_NT_OPTIONAL_HDR_MAGIC 0x10b
#define IMAGE_ROM_OPTIONAL_HDR_MAGIC 0x107
/* These are indexes into the DataDirectory array */
#define IMAGE_FILE_EXPORT_DIRECTORY 0
#define IMAGE_FILE_IMPORT_DIRECTORY 1

4
include/scroll.h
View File

@ -19,8 +19,8 @@ typedef struct
UINT32 flags; /* EnableScrollBar flags */
} SCROLLBAR_INFO;
extern LRESULT ScrollBarWndProc( HWND32 hwnd, UINT32 uMsg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT WINAPI ScrollBarWndProc( HWND32 hwnd, UINT32 uMsg,
WPARAM32 wParam, LPARAM lParam );
extern void SCROLL_DrawScrollBar( HWND32 hwnd, HDC32 hdc, INT32 nBar,
BOOL32 arrows );
extern void SCROLL_HandleScrollEvent( HWND32 hwnd, INT32 nBar,

9
include/shell.h
View File

@ -65,10 +65,9 @@ DECL_WINELIB_TYPE_AW(SHFILEINFO);
#define SHGFI_SHELLICONSIZE 0x000000004 /* get shell size icon */
#define SHGFI_PIDL 0x000000008 /* pszPath is a pidl */
#define SHGFI_USEFILEATTRIBUTES 0x000000010 /* use passed dwFileAttribute */
DWORD SHGetFileInfo32A(LPCSTR,DWORD,SHFILEINFO32A*,UINT32,UINT32);
DWORD SHGetFileInfo32W(LPCWSTR,DWORD,SHFILEINFO32W*,UINT32,UINT32);
#define SHGetFileInfo WINELIB_NAME_AW(SHGetFileInfo)
DWORD WINAPI SHGetFileInfo32A(LPCSTR,DWORD,SHFILEINFO32A*,UINT32,UINT32);
DWORD WINAPI SHGetFileInfo32W(LPCWSTR,DWORD,SHFILEINFO32W*,UINT32,UINT32);
#define SHGetFileInfo WINELIB_NAME_AW(SHGetFileInfo)
#define SE_ERR_SHARE 26
#define SE_ERR_ASSOCINCOMPLETE 27
@ -77,6 +76,4 @@ DWORD SHGetFileInfo32W(LPCWSTR,DWORD,SHFILEINFO32W*,UINT32,UINT32);
#define SE_ERR_DDEBUSY 30
#define SE_ERR_NOASSOC 31
LRESULT AboutDlgProc(HWND32 hWnd,UINT32 msg,WPARAM16 wParam,LPARAM lParam);
#endif /* __WINE_SHELL_H */

6
include/sigcontext.h → include/sig_context.h
View File

@ -4,8 +4,8 @@
* Copyright 1995 Alexandre Julliard
*/
#ifndef __WINE_SIGCONTEXT_H
#define __WINE_SIGCONTEXT_H
#ifndef __WINE_SIG_CONTEXT_H
#define __WINE_SIG_CONTEXT_H
#ifdef WINELIB
#error This file must not be used in Winelib
@ -202,4 +202,4 @@ typedef struct _CONTEXT /* Note 1 */
#define FL_sig(context) (*(WORD*)&EFL_sig(context))
#endif /* __WINE_SIGCONTEXT_H */
#endif /* __WINE_SIG_CONTEXT_H */

4
include/static.h
View File

@ -17,7 +17,7 @@ typedef struct
HICON16 hIcon; /* Icon handle for SS_ICON controls */
} STATICINFO;
extern LRESULT StaticWndProc( HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam,
LPARAM lParam );
extern LRESULT WINAPI StaticWndProc( HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam,
LPARAM lParam );
#endif /* __WINE_STATIC_H */

4
include/status.h
View File

@ -7,8 +7,8 @@
#ifndef __WINE_STATUS_H
#define __WINE_STATUS_H
LRESULT StatusWindowProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
LRESULT WINAPI StatusWindowProc( HWND32 hwnd, UINT32 msg,
WPARAM32 wParam, LPARAM lParam );
typedef struct
{

2
include/stddebug.h
View File

@ -150,6 +150,7 @@
#undef DEBUG_TIMER
#undef DEBUG_TOOLHELP
#undef DEBUG_TWEAK
#undef DEBUG_UPDOWN
#undef DEBUG_VER
#undef DEBUG_VIRTUAL
#undef DEBUG_VXD
@ -234,6 +235,7 @@
#define DEBUG_TIMER
#define DEBUG_TOOLHELP
#define DEBUG_TWEAK
#define DEBUG_UPDOWN
#define DEBUG_VER
#define DEBUG_VIRTUAL
#define DEBUG_VXD

22
include/stress.h
View File

@ -11,17 +11,17 @@ extern "C" {
#define EDS_CUR 2
#define EDS_TEMP 3
BOOL16 AllocGDIMem(UINT16);
BOOL16 AllocMem(DWORD);
BOOL16 AllocUserMem(UINT16);
int AllocDiskSpace(long, UINT16);
int AllocFileHandles(int);
int GetFreeFileHandles(void);
void FreeAllGDIMem(void);
void FreeAllMem(void);
void FreeAllUserMem(void);
void UnAllocDiskSpace(UINT16);
void UnAllocFileHandles(void);
BOOL16 WINAPI AllocGDIMem(UINT16);
BOOL16 WINAPI AllocMem(DWORD);
BOOL16 WINAPI AllocUserMem(UINT16);
int WINAPI AllocDiskSpace(long, UINT16);
int WINAPI AllocFileHandles(int);
int WINAPI GetFreeFileHandles(void);
void WINAPI FreeAllGDIMem(void);
void WINAPI FreeAllMem(void);
void WINAPI FreeAllUserMem(void);
void WINAPI UnAllocDiskSpace(UINT16);
void WINAPI UnAllocFileHandles(void);
#ifdef __cplusplus
}

11
include/task.h
View File

@ -49,8 +49,12 @@ typedef struct
#define THUNK_MAGIC ('P' | ('T' << 8))
struct _THDB;
struct _WSINFO;
/* Task database. See 'Windows Internals' p. 226 */
/* Task database. See 'Windows Internals' p. 226.
* Note that 16-bit OLE 2 libs like to read it directly
* so we have to keep entry offsets as they are.
*/
typedef struct
{
HTASK16 hNext; /* 00 Selector of next TDB */
@ -82,8 +86,9 @@ typedef struct
DWORD int75 WINE_PACKED; /* 4a int 75 (80x87 error) handler */
DWORD compat_flags WINE_PACKED; /* 4e Compatibility flags */
BYTE unused4[2]; /* 52 */
struct _THDB *thdb; /* 54 Pointer to thread database */
BYTE unused5[8]; /* 58 */
struct _THDB *thdb; /* 54 Pointer to thread database */
struct _WSINFO *pwsi; /* 58 Socket control struct */
BYTE unused5[4]; /* 5B */
HANDLE16 hPDB; /* 60 Selector of PDB (i.e. PSP) */
SEGPTR dta WINE_PACKED; /* 62 Current DTA */
BYTE curdrive; /* 66 Current drive */

54
include/toolhelp.h
View File

@ -76,11 +76,13 @@ typedef struct
/* wFlags values */
#define GF_PDB_OWNER 0x0100 /* Low byte is KERNEL flags */
BOOL16 GlobalInfo( GLOBALINFO *pInfo );
BOOL16 GlobalFirst( GLOBALENTRY *pGlobal, WORD wFlags );
BOOL16 GlobalNext( GLOBALENTRY *pGlobal, WORD wFlags) ;
BOOL16 GlobalEntryHandle( GLOBALENTRY *pGlobal, HGLOBAL16 hItem );
BOOL16 GlobalEntryModule( GLOBALENTRY *pGlobal, HMODULE16 hModule, WORD wSeg );
WORD WINAPI GlobalHandleToSel( HGLOBAL16 handle );
BOOL16 WINAPI GlobalInfo( GLOBALINFO *pInfo );
BOOL16 WINAPI GlobalFirst( GLOBALENTRY *pGlobal, WORD wFlags );
BOOL16 WINAPI GlobalNext( GLOBALENTRY *pGlobal, WORD wFlags) ;
BOOL16 WINAPI GlobalEntryHandle( GLOBALENTRY *pGlobal, HGLOBAL16 hItem );
BOOL16 WINAPI GlobalEntryModule( GLOBALENTRY *pGlobal, HMODULE16 hModule,
WORD wSeg );
/* Local heap */
@ -154,9 +156,9 @@ typedef struct
#define LT_USER_HANDLETABLE 32
#define LT_USER_MAX LT_USER_HANDLETABLE
BOOL16 LocalInfo( LOCALINFO *pLocalInfo, HGLOBAL16 handle );
BOOL16 LocalFirst( LOCALENTRY *pLocalEntry, HGLOBAL16 handle );
BOOL16 LocalNext( LOCALENTRY *pLocalEntry );
BOOL16 WINAPI LocalInfo( LOCALINFO *pLocalInfo, HGLOBAL16 handle );
BOOL16 WINAPI LocalFirst( LOCALENTRY *pLocalEntry, HGLOBAL16 handle );
BOOL16 WINAPI LocalNext( LOCALENTRY *pLocalEntry );
/* modules */
@ -171,10 +173,10 @@ typedef struct
HANDLE16 wNext;
} MODULEENTRY, *LPMODULEENTRY;
BOOL16 ModuleFirst(MODULEENTRY *lpModule);
BOOL16 ModuleNext(MODULEENTRY *lpModule);
BOOL16 ModuleFindName(MODULEENTRY *lpModule, LPCSTR lpstrName);
BOOL16 ModuleFindHandle(MODULEENTRY *lpModule, HMODULE16 hModule);
BOOL16 WINAPI ModuleFirst(MODULEENTRY *lpModule);
BOOL16 WINAPI ModuleNext(MODULEENTRY *lpModule);
BOOL16 WINAPI ModuleFindName(MODULEENTRY *lpModule, LPCSTR lpstrName);
BOOL16 WINAPI ModuleFindHandle(MODULEENTRY *lpModule, HMODULE16 hModule);
/* tasks */
@ -197,12 +199,12 @@ typedef struct
HANDLE16 hNext;
} TASKENTRY, *LPTASKENTRY;
BOOL16 TaskFirst(LPTASKENTRY lpTask);
BOOL16 TaskNext(LPTASKENTRY lpTask);
BOOL16 TaskFindHandle(LPTASKENTRY lpTask, HTASK16 hTask);
DWORD TaskSetCSIP(HTASK16 hTask, WORD wCS, WORD wIP);
DWORD TaskGetCSIP(HTASK16 hTask);
BOOL16 TaskSwitch(HTASK16 hTask, DWORD dwNewCSIP);
BOOL16 WINAPI TaskFirst(LPTASKENTRY lpTask);
BOOL16 WINAPI TaskNext(LPTASKENTRY lpTask);
BOOL16 WINAPI TaskFindHandle(LPTASKENTRY lpTask, HTASK16 hTask);
DWORD WINAPI TaskSetCSIP(HTASK16 hTask, WORD wCS, WORD wIP);
DWORD WINAPI TaskGetCSIP(HTASK16 hTask);
BOOL16 WINAPI TaskSwitch(HTASK16 hTask, DWORD dwNewCSIP);
/* mem info */
@ -230,8 +232,8 @@ typedef struct
HGLOBAL16 hGDISegment;
} SYSHEAPINFO;
BOOL16 MemManInfo(LPMEMMANINFO lpEnhMode);
BOOL16 SystemHeapInfo( SYSHEAPINFO *pHeapInfo );
BOOL16 WINAPI MemManInfo(LPMEMMANINFO lpEnhMode);
BOOL16 WINAPI SystemHeapInfo( SYSHEAPINFO *pHeapInfo );
/* timer info */
@ -241,7 +243,7 @@ typedef struct tagTIMERINFO {
DWORD dwmsThisVM;
} TIMERINFO;
BOOL16 TimerCount( TIMERINFO *pTimerInfo );
BOOL16 WINAPI TimerCount( TIMERINFO *pTimerInfo );
/* Window classes */
@ -253,14 +255,14 @@ typedef struct
HANDLE16 wNext;
} CLASSENTRY;
BOOL16 ClassFirst( CLASSENTRY *pClassEntry );
BOOL16 ClassNext( CLASSENTRY *pClassEntry );
BOOL16 WINAPI ClassFirst( CLASSENTRY *pClassEntry );
BOOL16 WINAPI ClassNext( CLASSENTRY *pClassEntry );
/* Memory read/write */
DWORD MemoryRead( WORD sel, DWORD offset, void *buffer, DWORD count );
DWORD MemoryWrite( WORD sel, DWORD offset, void *buffer, DWORD count );
DWORD WINAPI MemoryRead( WORD sel, DWORD offset, void *buffer, DWORD count );
DWORD WINAPI MemoryWrite( WORD sel, DWORD offset, void *buffer, DWORD count );
/* flags to NotifyRegister() */
#define NF_NORMAL 0 /* everything except taskswitches, debugerrors,
@ -269,7 +271,7 @@ DWORD MemoryWrite( WORD sel, DWORD offset, void *buffer, DWORD count );
#define NF_TASKSWITCH 1 /* get taskswitch information */
#define NF_RIP 2 /* get debugerrors of system */
BOOL16 NotifyRegister(HTASK16 htask,FARPROC16 lpfnCallback,WORD wFlags);
BOOL16 WINAPI NotifyRegister(HTASK16 htask,FARPROC16 lpfnCallback,WORD wFlags);
#define NFY_UNKNOWN 0
#define NFY_LOADSEG 1

28
include/updown.h Normal file
View File

@ -0,0 +1,28 @@
/*
* Up-down class extra info
*
* Copyright 1997 Dimitrie O. Paun
*/
#ifndef __WINE_UPDOWN_H
#define __WINE_UPDOWN_H
#include "windows.h"
#include "commctrl.h"
typedef struct
{
UINT32 AccelCount; /* Number of elements in AccelVect */
UDACCEL* AccelVect; /* Vector containing AccelCount elements */
INT32 Base; /* Base to display nr in the buddy window */
INT32 CurVal; /* Current up-down value */
INT32 MinVal; /* Minimum up-down value */
INT32 MaxVal; /* Maximum up-down value */
HWND32 Buddy; /* Handle to the buddy window */
INT32 Flags; /* Internal Flags FLAG_* */
} UPDOWN_INFO;
LRESULT WINAPI UpDownWindowProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
LPARAM lParam);
#endif /* __WINE_UPDOWN_H */

9
include/ver.h
View File

@ -127,15 +127,6 @@ typedef struct tagVS_FIXEDFILEINFO {
DWORD dwFileDateLS;
} VS_FIXEDFILEINFO;
/* following two aren't in version.dll */
DWORD
GetFileResourceSize(LPCSTR filename,SEGPTR restype,SEGPTR resid,LPDWORD off);
DWORD
GetFileResource(LPCSTR filename,SEGPTR restype,SEGPTR resid,
DWORD off,DWORD reslen,LPVOID data
);
/* 20 GETFILEVERSIONINFORAW */

3
include/win.h
View File

@ -74,7 +74,7 @@ typedef struct tagWND
HWND32 hwndLastActive;/* Last active popup hwnd */
DWORD dwStyle; /* Window style (from CreateWindow) */
DWORD dwExStyle; /* Extended style (from CreateWindowEx) */
UINT16 wIDmenu; /* ID or hmenu (from CreateWindow) */
UINT32 wIDmenu; /* ID or hmenu (from CreateWindow) */
WORD flags; /* Misc. flags (see below) */
Window window; /* X window (only for top-level windows) */
HMENU16 hSysMenu; /* window's copy of System Menu */
@ -124,6 +124,7 @@ extern void WIN_SendParentNotify( HWND32 hwnd, WORD event,
extern void WIN_ResetQueueWindows( WND* wnd, HQUEUE16 hQueue, HQUEUE16 hNew );
extern BOOL32 WIN_CreateDesktopWindow(void);
extern HWND32 WIN_GetTopParent( HWND32 hwnd );
extern WND* WIN_GetTopParentPtr( WND* pWnd );
extern BOOL32 WIN_IsWindowDrawable(WND*, BOOL32 );
extern HINSTANCE16 WIN_GetWindowInstance( HWND32 hwnd );
extern WND** WIN_BuildWinArray( WND *wndPtr, UINT32 bwa, UINT32* pnum );

19
include/winbase.h
View File

@ -57,7 +57,6 @@
#define FS_CASE_IS_PRESERVED FILE_CASE_PRESERVED_NAMES
#define FS_UNICODE_STORED_ON_DISK FILE_UNICODE_ON_DISK
/*WINAPI int SetErrorMode(int);*/
#define STATUS_SUCCESS 0x00000000
#define STATUS_WAIT_0 0x00000000
@ -156,19 +155,17 @@ DECL_WINELIB_TYPE_AW(OSVERSIONINFO);
#define VER_PLATFORM_WIN32_NT 2
/*DWORD WINAPI GetVersion( void );*/
BOOL32 GetVersionEx32A(OSVERSIONINFO32A*);
BOOL32 GetVersionEx32W(OSVERSIONINFO32W*);
BOOL32 WINAPI GetVersionEx32A(OSVERSIONINFO32A*);
BOOL32 WINAPI GetVersionEx32W(OSVERSIONINFO32W*);
#define GetVersionEx WINELIB_NAME_AW(GetVersionEx)
/*int WinMain(HINSTANCE, HINSTANCE prev, char *cmd, int show);*/
HACCEL32 LoadAcceleratorsA( HINSTANCE32, const char *);
void DeleteCriticalSection(CRITICAL_SECTION *lpCrit);
void EnterCriticalSection(CRITICAL_SECTION *lpCrit);
void InitializeCriticalSection(CRITICAL_SECTION *lpCrit);
void LeaveCriticalSection(CRITICAL_SECTION *lpCrit);
HANDLE32 OpenProcess(DWORD access, BOOL32 inherit, DWORD id);
int TerminateProcess(HANDLE32 h, int ret);
void WINAPI DeleteCriticalSection(CRITICAL_SECTION *lpCrit);
void WINAPI EnterCriticalSection(CRITICAL_SECTION *lpCrit);
void WINAPI InitializeCriticalSection(CRITICAL_SECTION *lpCrit);
void WINAPI LeaveCriticalSection(CRITICAL_SECTION *lpCrit);
HANDLE32 WINAPI OpenProcess(DWORD access, BOOL32 inherit, DWORD id);
int WINAPI TerminateProcess(HANDLE32 h, int ret);
#endif /* __WINE_WINBASE_H */

5097
include/windows.h
View File

File diff suppressed because it is too large Load Diff

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