From d96231af459a94ab3089ad723b9ce4e31e36858e Mon Sep 17 00:00:00 2001 From: oro06 Date: Mon, 22 Aug 2005 17:27:28 +0000 Subject: [PATCH] + Added WinCE API files updated from Win32 * unidef.inc complete git-svn-id: trunk@918 - --- .gitattributes | 9 + rtl/wince/windows.pp | 89 + rtl/wince/wininc/base.inc | 994 ++++ rtl/wince/wininc/defines.inc | 6362 ++++++++++++++++++++++++++ rtl/wince/wininc/errors.inc | 1174 +++++ rtl/wince/wininc/func.inc | 2387 ++++++++++ rtl/wince/wininc/messages.inc | 1314 ++++++ rtl/wince/wininc/redef.inc | 1104 +++++ rtl/wince/wininc/struct.inc | 8054 +++++++++++++++++++++++++++++++++ rtl/wince/wininc/unidef.inc | 571 +++ 10 files changed, 22058 insertions(+) create mode 100644 rtl/wince/windows.pp create mode 100644 rtl/wince/wininc/base.inc create mode 100644 rtl/wince/wininc/defines.inc create mode 100644 rtl/wince/wininc/errors.inc create mode 100644 rtl/wince/wininc/func.inc create mode 100644 rtl/wince/wininc/messages.inc create mode 100644 rtl/wince/wininc/redef.inc create mode 100644 rtl/wince/wininc/struct.inc create mode 100644 rtl/wince/wininc/unidef.inc diff --git a/.gitattributes b/.gitattributes index 1484d752ac..263b5ab16a 100644 --- a/.gitattributes +++ b/.gitattributes @@ -4185,6 +4185,15 @@ rtl/wince/Makefile.fpc svneol=native#text/plain rtl/wince/arm/wprt0.as svneol=native#text/plain rtl/wince/i386/wprt0.as svneol=native#text/plain rtl/wince/system.pp svneol=native#text/plain +rtl/wince/windows.pp -text +rtl/wince/wininc/base.inc -text +rtl/wince/wininc/defines.inc -text +rtl/wince/wininc/errors.inc -text +rtl/wince/wininc/func.inc -text +rtl/wince/wininc/messages.inc -text +rtl/wince/wininc/redef.inc -text +rtl/wince/wininc/struct.inc -text +rtl/wince/wininc/unidef.inc -text rtl/x86_64/int64p.inc svneol=native#text/plain rtl/x86_64/makefile.cpu -text rtl/x86_64/math.inc svneol=native#text/plain diff --git a/rtl/wince/windows.pp b/rtl/wince/windows.pp new file mode 100644 index 0000000000..999187f0eb --- /dev/null +++ b/rtl/wince/windows.pp @@ -0,0 +1,89 @@ +{ + This file is part of the Free Pascal run time library. + This unit contains the record definition for the Win32 API + Copyright (c) 1999-2000 by Florian KLaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + ********************************************************************** + + Changes : + + 08/15/2005 update for wince4.2 port,ORO06 +} + +unit windows; + +{$ifndef NO_SMART_LINK} +{$smartlink on} +{$endif} + +{ stuff like array of const is used } +{$mode objfpc} +{$calling stdcall} + +interface + + +{$define read_interface} +{$undef read_implementation} + + +{$ifdef UNDER_CE} +{$define UNICODE} //ce is unicode only +//{$define _X86_} //for testing compilation +{$calling cedcl} +{$endif UNDER_CE} + +{$i base.inc} +{$i errors.inc} +{$i defines.inc} +{$i struct.inc} +{$i messages.inc} + +{$ifndef UNDER_CE} +{$i ascfun.inc} +{$i unifun.inc} +{$endif UNDER_CE} + +{$ifdef UNICODE} +{$i unidef.inc} +{$else not UNICODE} +{$i ascdef.inc} +{$endif UNICODE} + +{$i func.inc} +{$i redef.inc} + +implementation + +{$undef read_interface} +{$define read_implementation} + +{$i base.inc} +{$i errors.inc} +{$i defines.inc} +{$i struct.inc} +{$i messages.inc} + +{$ifndef UNDER_CE} +{$i ascfun.inc} +{$i unifun.inc} +{$endif UNDER_CE} + +{$ifdef UNICODE} +{$i unidef.inc} +{$else not UNICODE} +{$i ascdef.inc} +{$endif UNICODE} + +{$i func.inc} +{$i redef.inc} + +end. diff --git a/rtl/wince/wininc/base.inc b/rtl/wince/wininc/base.inc new file mode 100644 index 0000000000..813c0a460e --- /dev/null +++ b/rtl/wince/wininc/base.inc @@ -0,0 +1,994 @@ +{ + This file is part of the Free Pascal run time library. + This unit contains base definition for the Win32 API + Copyright (c) 1999-2000 by Florian Klaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ + Base.h + + Base definitions + + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + + Author: Scott Christley + + This file is part of the Windows32 API Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Changes : + + 08/15/2005 update for wince4.2 port,ORO06 +} + +{$ifdef read_interface} + +{$PACKRECORDS C} + const + ANYSIZE_ARRAY = 1; //~winnt, moved from define to compile SID + type + ATOM = word; //windef + TAtom = ATOM; + + WINBOOL = longbool; + BOOL = WINBOOL; //windef + + CALTYPE = cardinal; + CALID = cardinal; + + CCHAR = char; //winnt + + COLORREF = Cardinal; //windef + TCOLORREF = cardinal; + + SHORT = smallint; //winnt + WINT = longint; + LONG = longint; //winnt + DWORD = Cardinal; //windef + + PINTEGER = ^longint; + PBOOL = ^BOOL; //windef + + LONGLONG = int64; //winnt + PLONGLONG = ^LONGLONG; //winnt + ULONGLONG = qword; //+winnt + PULONGLONG = ^ULONGLONG; //+winnt + + DWORDLONG = qword; { was unsigned long } + PDWORDLONG = ^DWORDLONG; + + HANDLE = System.THandle; + HRESULT = System.HResult; //winnt LONG + PHRESULT= ^HRESULT; + + HACCEL = HANDLE; //windef + HBITMAP = HANDLE; //windef + HBRUSH = HANDLE; //windef + HCOLORSPACE = HANDLE; //windef + HCONV = HANDLE; + HCONVLIST = HANDLE; + HCURSOR = HANDLE; //windef + HDBC = HANDLE; + HDC = HANDLE; //windef + HDDEDATA = HANDLE; + HDESK = HANDLE; //windef + HDROP = HANDLE; + HDWP = HANDLE; + HENHMETAFILE = HANDLE; //windef + HENV = HANDLE; + HEVENT = HANDLE; //+windef + HFILE = HANDLE; //windef + HFONT = HANDLE; //windef + HGDIOBJ = HANDLE; //windef + HGLOBAL = HANDLE; //windef + HGLRC = HANDLE; //windef + HHOOK = HANDLE; //windef + HICON = HCURSOR; //~windef + LPHICON = ^HICON; //+tapi + HIMAGELIST = HANDLE; + HINST = HANDLE; { Not HINSTANCE, else it has problems with the var HInstance } + HKEY = HANDLE; //windef + HKL = HANDLE; //windef + HLOCAL = HANDLE; //windef + HMENU = HANDLE; //windef + HMETAFILE = HANDLE; //windef + HMODULE = HANDLE; //windef + HMONITOR = HANDLE; //+windef + HPALETTE = HANDLE; //windef + HPEN = HANDLE; //windef + HRASCONN = HANDLE; + HRGN = HANDLE; //windef + HRSRC = HANDLE; //windef + HSTMT = HANDLE; + HSTR = HANDLE; //windef + HSZ = HANDLE; + HTASK = HANDLE; //windef + HWINSTA = HANDLE; //windef + HWND = HANDLE; //windef + HWINEVENTHOOK = HANDLE; //+windef + + LANGID = word; //winnt + LCID = DWORD; //winnt + PLCID = ^LCID; //+winnt + LCTYPE = DWORD; + LPARAM = longint; //windef LONG_PTR + + LP = ^word; + LPBOOL = ^WINBOOL; //windef + LPBYTE = ^BYTE; //windef + LPCCH = PCHAR; //winnt + LPCH = PCHAR; //winnt + + LPCOLORREF = ^COLORREF; //windef + + LPCSTR = Pchar; //winnt +{$ifdef UNICODE} + LPCTSTR = Pwidechar; //winnt +{$else} + LPCTSTR = Pchar; //winnt +{$endif} + + LPCWCH = Pwidechar; //winnt + LPCWSTR = Pwidechar; //winnt + + LPDWORD = ^DWORD; //windef + + LPHANDLE = ^HANDLE; //windef + LPINT = ^longint; //windef + LPLONG = ^longint; //windef + + LPSTR = Pchar; //winnt +{$ifdef UNICODE} + LPTCH = Pwidechar; + LPTSTR = Pwidechar; +{$else} + LPTCH = Pchar; + LPTSTR = Pchar; +{$endif} + + LRESULT = longint; //windef LONG_PTR + + LPVOID = pointer; //windef + + LPCVOID = pointer; //windef + + LPWCH = Pwidechar; + LPWORD = ^word; //windef + LPWSTR = Pwidechar; //winnt + + // + // Locally Unique Identifier + // + //winnt : declaration moved and changed : was in struct as LUID = TlargeInteger + LUID = record + LowPart : DWORD; + HighPart : LONG ; + end; + TLUID = LUID; + PLUID = ^LUID; + + NWPSTR = Pwidechar; //winnt + + PWINBOOL = ^WINBOOL; + PBOOLEAN = ^BYTE; + + PBYTE = ^BYTE; //windef + + PCCH = PCHAR; //winnt + PCH = PCHAR; //winnt + + PCSTR = Pchar; + + PCWCH = Pwidechar; //winnt + PCWSTR = Pwidechar; //winnt + + PDWORD = ^DWORD; //windef + + PHANDLE = ^HANDLE; //windef + PHKEY = ^HKEY; //windef + + PINT = ^longint; + PLONG = ^longint; //windef + PSHORT = ^SHORT; //windef + LPSHORT = ^SHORT; //+windef + + PSTR = Pchar; + + PSZ = Pchar; //winnt +{$ifdef UNICODE} + PTBYTE = ^word; //winnt + PTCH = Pwidechar; + PTCHAR = Pwidechar; //winnt + PTSTR = Pwidechar; +{$else} + PTBYTE = ^byte; + PTCH = Pchar; + PTCHAR = Pchar; + PTSTR = Pchar; +{$endif} + + PUCHAR = ^byte; //windef + PWCH = Pwidechar; //winnt + PWCHAR = Pwidechar; //winnt + + PWORD = ^word; //windef + PUINT = ^Cardinal; //windef + PULONG = ^Cardinal; //windef + PUSHORT = ^word; //windef + + PVOID = pointer; + + RETCODE = SHORT; + + SC_HANDLE = HANDLE; + SC_LOCK = LPVOID; + LPSC_HANDLE = ^SC_HANDLE; + SPHANDLE = ^HANDLE; //+windef + + SERVICE_STATUS_HANDLE = DWORD; + SIZE_T = Cardinal; //+winnt +{$ifdef UNICODE} + TBYTE = word; + TCHAR = word; + BCHAR = word; +{$else} + TBYTE = byte; + TCHAR = char; + BCHAR = BYTE; +{$endif} + + UCHAR = byte; //windef + WCHAR = WideChar; //winnt + + UINT = Cardinal; //windef + ULONG = Cardinal; //windef + USHORT = word; //windef + + PLPSTR = ^LPSTR; + PLPWStr= ^LPWStr; + + FLOAT = single; //+windef + PFLOAT = ^FLOAT; //+windef + WCHAR_T = USHORT; //+stdlib + WINT_T = WCHAR_T; //+stdlib + WCTYPE_T = WCHAR_T; //+stdlib + TIME_T=ULONG; //+stdlib + WPARAM = Longint; //windef UINT_PTR +{ + Enumerations +} + + ACL_INFORMATION_CLASS = (AclRevisionInformation := 1,AclSizeInformation + ); + + _ACL_INFORMATION_CLASS = ACL_INFORMATION_CLASS; + + MEDIA_TYPE = (Unknown,F5_1Pt2_512,F3_1Pt44_512,F3_2Pt88_512, + F3_20Pt8_512,F3_720_512,F5_360_512,F5_320_512, + F5_320_1024,F5_180_512,F5_160_512,RemovableMedia, + FixedMedia); + + _MEDIA_TYPE = MEDIA_TYPE; + + const + RASCS_DONE = $2000; + RASCS_PAUSED = $1000; + + type + + RASCONNSTATE = (RASCS_OpenPort := 0,RASCS_PortOpened, + RASCS_ConnectDevice,RASCS_DeviceConnected, + RASCS_AllDevicesConnected,RASCS_Authenticate, + RASCS_AuthNotify,RASCS_AuthRetry,RASCS_AuthCallback, + RASCS_AuthChangePassword,RASCS_AuthProject, + RASCS_AuthLinkSpeed,RASCS_AuthAck,RASCS_ReAuthenticate, + RASCS_Authenticated,RASCS_PrepareForCallback, + RASCS_WaitForModemReset,RASCS_WaitForCallback, + RASCS_Projected,RASCS_StartAuthentication, + RASCS_CallbackComplete,RASCS_LogonNetwork, + RASCS_Interactive := RASCS_PAUSED,RASCS_RetryAuthentication, + RASCS_CallbackSetByCaller,RASCS_PasswordExpired, + RASCS_Connected := RASCS_DONE,RASCS_Disconnected + ); + + _RASCONNSTATE = RASCONNSTATE; + + RASPROJECTION = (RASP_Amb := $10000,RASP_PppNbf := $803F,RASP_PppIpx := $802B, + RASP_PppIp := $8021); + + _RASPROJECTION = RASPROJECTION; + + PSECURITY_DESCRIPTO = PVOID; //+winnt + SECURITY_IMPERSONATION_LEVEL = (SecurityAnonymous,SecurityIdentification, + SecurityImpersonation,SecurityDelegation + ); + + _SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL; + + SID_IDENTIFIER_AUTHORITY_REC = array[0..5] of BYTE; //~ added for pre-defined SID declaration + SID_IDENTIFIER_AUTHORITY = record //~winnt, moved to declare pre-defined SID + Value : SID_IDENTIFIER_AUTHORITY_REC; + end; + LPSID_IDENTIFIER_AUTHORITY = ^SID_IDENTIFIER_AUTHORITY; + PSID_IDENTIFIER_AUTHORITY = ^SID_IDENTIFIER_AUTHORITY; + _SID_IDENTIFIER_AUTHORITY = SID_IDENTIFIER_AUTHORITY; + TSIDIDENTIFIERAUTHORITY = SID_IDENTIFIER_AUTHORITY; + PSIDIDENTIFIERAUTHORITY = ^SID_IDENTIFIER_AUTHORITY; + + + SID = record //~wint + Revision : Byte; + SubAuthorityCount : Byte; + IdentifierAuthority : SID_IDENTIFIER_AUTHORITY; + SubAuthority : Array [0..ANYSIZE_ARRAY-1] of DWORD; + end; + _SID = SID; + PSID = ^SID; + + SID_NAME_USE = ( //~winnt, added SidTypeComputer + SidTypeUser:= 1, + SidTypeGroup, + SidTypeDomain, + SidTypeAlias, + SidTypeWellKnownGroup, + SidTypeDeletedAccount, + SidTypeInvalid, + SidTypeUnknown, + SidTypeComputer); + + PSID_NAME_USE = ^SID_NAME_USE; //winnt + _SID_NAME_USE = SID_NAME_USE; + + TOKEN_INFORMATION_CLASS = (TokenUser := 1,TokenGroups,TokenPrivileges, + TokenOwner,TokenPrimaryGroup,TokenDefaultDacl, + TokenSource,TokenType,TokenImpersonationLevel, + TokenStatistics); + + _TOKEN_INFORMATION_CLASS = TOKEN_INFORMATION_CLASS; + TTokenInformationClass = TOKEN_INFORMATION_CLASS; + + TOKEN_TYPE = (TokenPrimary := 1,TokenImpersonation + ); + + tagTOKEN_TYPE = TOKEN_TYPE; + + { + Macros + } + + { was #define dname(params) def_expr } + { argument types are unknown } + function GetBValue(rgb : longint) : BYTE; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GetGValue(rgb : longint) : BYTE; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GetRValue(rgb : longint) : BYTE; + + { was #define dname(params) def_expr } + { argument types are unknown } + function RGB(r,g,b : longint) : DWORD; + + { Not convertable by H2PAS + #define HANDLE_WM_NOTIFY(hwnd, wParam, lParam, fn) \ + (fn)((hwnd), (int)(wParam), (NMHDR FAR )(lParam)) + } + + { was #define dname(params) def_expr } + { argument types are unknown } + function HIBYTE(w : longint) : BYTE; //windef + + { was #define dname(params) def_expr } + { argument types are unknown } + function HIWORD(l : longint) : WORD; //windef + + { was #define dname(params) def_expr } + { argument types are unknown } + function LOBYTE(w : longint) : BYTE; //windef + + { was #define dname(params) def_expr } + { argument types are unknown } + function LOWORD(l : longint) : WORD; //windef + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELONG(a,b : longint) : LONG; //windef + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEWORD(a,b : longint) : WORD; //windef + + { original Cygnus headers also had the following defined: } + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function SEXT_HIWORD(l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function ZEXT_HIWORD(l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function SEXT_LOWORD(l : longint) : longint; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function INDEXTOOVERLAYMASK(i : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function INDEXTOSTATEIMAGEMASK(i : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEINTATOM(i : longint) : LPTSTR; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEINTRESOURCE(i : longint) : LPTSTR; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function MAKELANGID(p,s : longint) : longint; //winnt + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function PRIMARYLANGID(lgid : longint) : WORD; //winnt + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function SUBLANGID(lgid : longint) : longint; //winnt + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function LANGIDFROMLCID(lcid : longint) : WORD; + + { was #define dname(params) def_expr } + { argument types are unknown } + function SORTIDFROMLCID(lcid : longint) : WORD; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELCID(lgid,srtid : longint) : DWORD; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELPARAM(l,h : longint) : LPARAM; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELRESULT(l,h : longint) : LRESULT; + + { Not convertable by H2PAS + #define MAKEPOINTS(l) ( ((POINTS FAR ) & (l))) + } + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEROP4(fore,back : longint) : DWORD; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEWPARAM(l,h : longint) : WPARAM; + +{$ifndef max} + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function max(a,b : longint) : longint; //windef + { return type might be wrong } + +{$endif} +{$ifndef min} + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function min(a,b : longint) : longint; //windef + { return type might be wrong } + +{$endif} + { was #define dname(params) def_expr } + { argument types are unknown } + function PALETTEINDEX(i : longint) : COLORREF; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function PALETTERGB(r,g,b : longint) : longint; + { return type might be wrong } + + (* Not convertable by H2PAS + #define POINTSTOPOINT(pt, pts) {(pt).x = (SHORT) LOWORD(pts); \ + (pt).y = (SHORT) HIWORD(pts);} + #define POINTTOPOINTS(pt) \ + (MAKELONG((short) ((pt).x), (short) ((pt).y))) + *) + { already declared before + #define INDEXTOOVERLAYMASK(i) ((i) << 8) + #define INDEXTOSTATEIMAGEMASK(i) ((i) << 12) + } + { Not convertable by H2PAS + #ifdef UNICODE + #define TEXT(quote) L##quote + #else + #define TEXT(quote) quote + #endif + } + + { + Definitions for callback procedures + } + + type + + BFFCALLBACK = function (_para1:HWND; _para2:UINT; _para3:LPARAM; _para4:LPARAM):longint;stdcall; + + LPCCHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + LPCFHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + PTHREAD_START_ROUTINE = Pointer; + + LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE; + + EDITSTREAMCALLBACK = function (_para1:DWORD; _para2:LPBYTE; _para3:LONG; _para4:LONG):DWORD;stdcall; + + LPFRHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + LPOFNHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + LPPRINTHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + LPSETUPHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + DLGPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):LRESULT;stdcall; + + PFNPROPSHEETCALLBACK = function (_para1:HWND; _para2:UINT; _para3:LPARAM):longint;stdcall; + + LPSERVICE_MAIN_FUNCTION = procedure (_para1:DWORD; _para2:LPTSTR);stdcall; + + PFNTVCOMPARE = function (_para1:LPARAM; _para2:LPARAM; _para3:LPARAM):longint;stdcall; + + WNDPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):LRESULT;stdcall; + + + FARPROC = pointer; //windef + NEARPROC= FARPROC; //+windef + PROC = FARPROC; //~windef + + ENUMRESTYPEPROC = function (_para1:HANDLE; _para2:LPTSTR; _para3:LONG):WINBOOL;stdcall; + + ENUMRESNAMEPROC = function (_para1:HANDLE; _para2:LPCTSTR; _para3:LPTSTR; _para4:LONG):WINBOOL;stdcall; + + ENUMRESLANGPROC = function (_para1:HANDLE; _para2:LPCTSTR; _para3:LPCTSTR; _para4:WORD; _para5:LONG):WINBOOL;stdcall; + + DESKTOPENUMPROC = FARPROC; + + ENUMWINDOWSPROC = function (_para1:HWND; _para2:LPARAM):WINBOOL;stdcall; + + ENUMWINDOWSTATIONPROC = function (_para1:LPTSTR; _para2:LPARAM):WINBOOL;stdcall; + + SENDASYNCPROC = procedure (_para1:HWND; _para2:UINT; _para3:DWORD; _para4:LRESULT);stdcall; + + TIMERPROC = procedure (_para1:HWND; _para2:UINT; _para3:UINT; _para4:DWORD);stdcall; + + GRAYSTRINGPROC = FARPROC; + + DRAWSTATEPROC = function (_para1:HDC; _para2:LPARAM; _para3:WPARAM; _para4:longint; _para5:longint):WINBOOL;stdcall; + + PROPENUMPROCEX = function (_para1:HWND; _para2:LPCTSTR; _para3:HANDLE; _para4:DWORD):WINBOOL;stdcall; + + PROPENUMPROC = function (_para1:HWND; _para2:LPCTSTR; _para3:HANDLE):WINBOOL;stdcall; + + HOOKPROC = function (_para1:longint; _para2:WPARAM; _para3:LPARAM):LRESULT;stdcall; + + ENUMOBJECTSPROC = procedure (_para1:LPVOID; _para2:LPARAM);stdcall; + + LINEDDAPROC = procedure (_para1:longint; _para2:longint; _para3:LPARAM);stdcall; + + TABORTPROC = function (_para1:HDC; _para2:longint):WINBOOL;stdcall; + + LPPAGEPAINTHOOK = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + LPPAGESETUPHOOK = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT;stdcall; + + ICMENUMPROC = function (_para1:LPTSTR; _para2:LPARAM):longint;stdcall; + + EDITWORDBREAKPROCEX = function (_para1:pchar; _para2:LONG; _para3:BYTE; _para4:WINT):LONG;stdcall; + + PFNLVCOMPARE = function (_para1:LPARAM; _para2:LPARAM; _para3:LPARAM):longint;stdcall; + + LOCALE_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall; + + CODEPAGE_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall; + CODEPAGE_ENUMPROCW = function (_para1:LPWSTR):WINBOOL; //+winnls + DATEFMT_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall; + + TIMEFMT_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall; + + CALINFO_ENUMPROC = function (_para1:LPTSTR):WINBOOL;stdcall; + + PHANDLER_ROUTINE = function (_para1:DWORD):WINBOOL;stdcall; + + LPHANDLER_FUNCTION = function (_para1:DWORD):WINBOOL;stdcall; + + PFNGETPROFILEPATH = function (_para1:LPCTSTR; _para2:LPSTR; _para3:UINT):UINT;stdcall; + + PFNRECONCILEPROFILE = function (_para1:LPCTSTR; _para2:LPCTSTR; _para3:DWORD):UINT;stdcall; + + PFNPROCESSPOLICIES = function (_para1:HWND; _para2:LPCTSTR; _para3:LPCTSTR; _para4:LPCTSTR; _para5:DWORD):WINBOOL;stdcall; + const + SE_CREATE_TOKEN_NAME = 'SeCreateTokenPrivilege'; + SE_ASSIGNPRIMARYTOKEN_NAME = 'SeAssignPrimaryTokenPrivilege'; + SE_LOCK_MEMORY_NAME = 'SeLockMemoryPrivilege'; + SE_INCREASE_QUOTA_NAME = 'SeIncreaseQuotaPrivilege'; + SE_UNSOLICITED_INPUT_NAME = 'SeUnsolicitedInputPrivilege'; + SE_MACHINE_ACCOUNT_NAME = 'SeMachineAccountPrivilege'; + SE_TCB_NAME = 'SeTcbPrivilege'; + SE_SECURITY_NAME = 'SeSecurityPrivilege'; + SE_TAKE_OWNERSHIP_NAME = 'SeTakeOwnershipPrivilege'; + SE_LOAD_DRIVER_NAME = 'SeLoadDriverPrivilege'; + SE_SYSTEM_PROFILE_NAME = 'SeSystemProfilePrivilege'; + SE_SYSTEMTIME_NAME = 'SeSystemtimePrivilege'; + SE_PROF_SINGLE_PROCESS_NAME = 'SeProfileSingleProcessPrivilege'; + SE_INC_BASE_PRIORITY_NAME = 'SeIncreaseBasePriorityPrivilege'; + SE_CREATE_PAGEFILE_NAME = 'SeCreatePagefilePrivilege'; + SE_CREATE_PERMANENT_NAME = 'SeCreatePermanentPrivilege'; + SE_BACKUP_NAME = 'SeBackupPrivilege'; + SE_RESTORE_NAME = 'SeRestorePrivilege'; + SE_SHUTDOWN_NAME = 'SeShutdownPrivilege'; + SE_DEBUG_NAME = 'SeDebugPrivilege'; + SE_AUDIT_NAME = 'SeAuditPrivilege'; + SE_SYSTEM_ENVIRONMENT_NAME = 'SeSystemEnvironmentPrivilege'; + SE_CHANGE_NOTIFY_NAME = 'SeChangeNotifyPrivilege'; + SE_REMOTE_SHUTDOWN_NAME = 'SeRemoteShutdownPrivilege'; + + //SERVICES_ACTIVE_DATABASEW L"ServicesActive" + //#define SERVICES_FAILED_DATABASEW L"ServicesFailed" + SERVICES_ACTIVE_DATABASEA = 'ServicesActive'; + SERVICES_FAILED_DATABASEA = 'ServicesFailed'; + { Not convertable by H2PAS + #define SC_GROUP_IDENTIFIERW L'+' + } + SC_GROUP_IDENTIFIERA = '+'; +{$ifdef UNICODE} + //temporary removed to compile in unicode, ORO06 08/2005 + //SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEW; + //SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEW; + //SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERW; + SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA; + SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA; + SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA; +{$else} + SERVICES_ACTIVE_DATABASE = SERVICES_ACTIVE_DATABASEA; + SERVICES_FAILED_DATABASE = SERVICES_FAILED_DATABASEA; + SC_GROUP_IDENTIFIER = SC_GROUP_IDENTIFIERA; +{$endif} + +type + + { PFNCALLBACK = CALLB; } + PFNCALLBACK = function(_para1, _para2: UINT;_para3: HCONV;_para4, _para5: HSZ; _para6: HDDEDATA;_para7 ,_para8 :DWORD): HDDEData;stdcall; + { CALLB = procedure ;CDECL; } + CALLB = PFNCALLBACK; + + + SECURITY_CONTEXT_TRACKING_MODE = WINBOOL; + { End of stuff from ddeml.h in old Cygnus headers } + { ----------------------------------------------- } + + WNDENUMPROC = FARPROC; + + ENHMFENUMPROC = FARPROC; + + CCSTYLE = DWORD; + + PCCSTYLE = ^CCSTYLE; + + LPCCSTYLE = ^CCSTYLE; + + CCSTYLEFLAGA = DWORD; + + PCCSTYLEFLAGA = ^CCSTYLEFLAGA; + + LPCCSTYLEFLAGA = ^CCSTYLEFLAGA; + +{$endif read_interface} + + +{$ifdef read_implementation} + + { was #define dname(params) def_expr } + { argument types are unknown } + function GetBValue(rgb : longint) : BYTE; + begin + GetBValue:=BYTE(rgb shr 16); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GetGValue(rgb : longint) : BYTE; + begin + GetGValue:=BYTE((WORD(rgb)) shr 8); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GetRValue(rgb : longint) : BYTE; + begin + GetRValue:=BYTE(rgb); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function RGB(r,g,b : longint) : DWORD; + begin + RGB:=DWORD(((DWORD(BYTE(r))) or ((DWORD(WORD(g))) shl 8)) or ((DWORD(BYTE(b))) shl 16)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function HIBYTE(w : longint) : BYTE; + begin + HIBYTE:=BYTE(((WORD(w)) shr 8) and $FF); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function HIWORD(l : longint) : WORD; + begin + HIWORD:=WORD(((DWORD(l)) shr 16) and $FFFF); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function LOBYTE(w : longint) : BYTE; + begin + LOBYTE:=BYTE(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function LOWORD(l : longint) : WORD; + begin + LOWORD:=WORD(l); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELONG(a,b : longint) : LONG; + begin + MAKELONG:=LONG((WORD(a)) or ((DWORD(WORD(b))) shl 16)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEWORD(a,b : longint) : WORD; + begin + MAKEWORD:=WORD((BYTE(a)) or ((WORD(BYTE(b))) shl 8)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function SEXT_HIWORD(l : longint) : longint; + { return type might be wrong } + begin + SEXT_HIWORD:=(longint(l)) shr 16; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function ZEXT_HIWORD(l : longint) : longint; + { return type might be wrong } + begin + ZEXT_HIWORD:=(Cardinal(l)) shr 16; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function SEXT_LOWORD(l : longint) : longint; + begin + SEXT_LOWORD:=longint(SHORT(l)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function INDEXTOOVERLAYMASK(i : longint) : longint; + { return type might be wrong } + begin + INDEXTOOVERLAYMASK:=i shl 8; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function INDEXTOSTATEIMAGEMASK(i : longint) : longint; + { return type might be wrong } + begin + INDEXTOSTATEIMAGEMASK:=i shl 12; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEINTATOM(i : longint) : LPTSTR; + begin + MAKEINTATOM:=LPTSTR(DWORD(WORD(i))); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEINTRESOURCE(i : longint) : LPTSTR; + begin + MAKEINTRESOURCE:=LPTSTR(DWORD(WORD(i))); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function MAKELANGID(p,s : longint) : longint; + { return type might be wrong } + begin + MAKELANGID:=((WORD(s)) shl 10) or (WORD(p)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function PRIMARYLANGID(lgid : longint) : WORD; + begin + { PRIMARYLANGID:=WORD(lgid(@($3ff))); + h2pas error here corrected by hand PM } + PRIMARYLANGID:=WORD(lgid) and ($3ff); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function SUBLANGID(lgid : longint) : longint; + { return type might be wrong } + begin + SUBLANGID:=(WORD(lgid)) shr 10; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function LANGIDFROMLCID(lcid : longint) : WORD; + begin + LANGIDFROMLCID:=WORD(lcid); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function SORTIDFROMLCID(lcid : longint) : WORD; + begin + SORTIDFROMLCID:=WORD(((DWORD(lcid)) and $000FFFFF) shr 16); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELCID(lgid,srtid : longint) : DWORD; + begin + MAKELCID:=DWORD(((DWORD(WORD(srtid))) shl 16) or (DWORD(WORD(lgid)))); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELPARAM(l,h : longint) : LPARAM; + begin + MAKELPARAM:=LPARAM(MAKELONG(l,h)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKELRESULT(l,h : longint) : LRESULT; + begin + MAKELRESULT:=LRESULT(MAKELONG(l,h)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEROP4(fore,back : longint) : DWORD; + begin + MAKEROP4:=DWORD((DWORD(back shl 8) and $FF000000) or DWORD(fore)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function MAKEWPARAM(l,h : longint) : WPARAM; + begin + MAKEWPARAM:=WPARAM(MAKELONG(l,h)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function max(a,b : longint) : longint; + { return type might be wrong } + var + if_local1 : longint; + (* result types are not known *) + begin + if a > b then + if_local1:=a + else + if_local1:=b; + max:=if_local1; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function min(a,b : longint) : longint; + { return type might be wrong } + var + if_local1 : longint; + (* result types are not known *) + begin + if a < b then + if_local1:=a + else + if_local1:=b; + min:=if_local1; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function PALETTEINDEX(i : longint) : COLORREF; + begin + PALETTEINDEX:=COLORREF($01000000 or (DWORD(WORD(i)))); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function PALETTERGB(r,g,b : longint) : longint; + { return type might be wrong } + begin + PALETTERGB:=$02000000 or (RGB(r,g,b)); + end; + +{$endif read_implementation} + diff --git a/rtl/wince/wininc/defines.inc b/rtl/wince/wininc/defines.inc new file mode 100644 index 0000000000..776c23def6 --- /dev/null +++ b/rtl/wince/wininc/defines.inc @@ -0,0 +1,6362 @@ +{ + This file is part of the Free Pascal run time library. + This unit contains the constant definitions for the Win32 API + Copyright (c) 1999-2000 by Florian Klaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ + Defines.h + + Windows32 API definitions + + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + + Author: Scott Christley + + This file is part of the Windows32 API Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + + Changes : + + 08/15/2005 update for wince4.2 port,ORO06 +} + +{$ifdef read_interface} + +{$ifdef WINCE} + const + UserDLL = KernelDLL; + SecurDLL = KernelDLL; + GdiDLL = KernelDLL; + ComctlDLL = 'commctrl'; + ComctlDLLCore = KernelDLL; + ComdlgDLL = 'commdlg'; + ComdlgDLLCore = KernelDLL; + VersionDLL = KernelDLL; + AdvapiDLL = KernelDLL; + MprDLL = KernelDLL; + ShellDLLCore = KernelDLL; +{$endif WINCE} + +{$ifdef WIN32} + const + UserDLL = 'user32'; + SecurDLL = 'secur32'; + GdiDLL = 'gdi32'; + ComctlDLL = 'comctl32'; + ComctlDLLCore = ComctlDLL; + ComdlgDLL = 'comdlg32'; + ComdlgDLLCore = ComdlgDLL; + VersionDLL = 'version'; + AdvApiDLL = 'advapi32'; + MprDLL = 'mpr'; + ShellDLLCore = 'shell32'; +{$endif WIN32} + +{$PACKRECORDS C} + + { was #define dname def_expr } + function UNICODE_NULL : WCHAR; + + const + NULL=0; //+windef + //FALSE=0; //+windef, removed can't compile + //TRUE=1; //+windef, removed can't compile + MAX_PATH = 260; //windef + LF_FACESIZE = 32; + LF_FULLFACESIZE = 64; + ELF_VENDOR_SIZE = 4; + SECURITY_STATIC_TRACKING = 0; + SECURITY_DYNAMIC_TRACKING = 1; + MAX_DEFAULTCHAR = 2; + MAX_LEADBYTES = 12; + EXCEPTION_MAXIMUM_PARAMETERS = 15; //winnt + CCHDEVICENAME = 32; + CCHFORMNAME = 32; + MENU_TEXT_LEN = 40; + MAX_LANA = 254; + NCBNAMSZ = 16; + NETBIOS_NAME_LEN = 16; + OFS_MAXPATHNAME = 128; + MAX_TAB_STOPS = 32; + RAS_MaxCallbackNumber = 128; + RAS_MaxDeviceName = 128; + RAS_MaxDeviceType = 16; + RAS_MaxEntryName = 256; + RAS_MaxIpAddress = 15; + RAS_MaxIpxAddress = 21; + RAS_MaxPhoneNumber = 128; + UNLEN = 256; + PWLEN = 256; + CNLEN = 15; + DNLEN = 15; + { Unsigned types max } + MAXDWORD = $FFFFFFFF; //winnt + MAXWORD = $FFFF; //winnt + MAXBYTE = $FF; //winnt + { Signed types max/min } + MINCHAR = $80; //winnt + MAXCHAR = $7F; //winnt + MINSHORT = $8000; //winnt + MAXSHORT = $7FFF; //winnt + MINLONG = $80000000; //winnt + MAXLONG = $7FFFFFFF; //winnt + { _llseek } + FILE_BEGIN = 0; + FILE_CURRENT = 1; + FILE_END = 2; + { _lopen, LZOpenFile, OpenFile } + OF_READ = 0; + OF_READWRITE = 2; + OF_WRITE = 1; + OF_SHARE_COMPAT = 0; + OF_SHARE_DENY_NONE = 64; + OF_SHARE_DENY_READ = 48; + OF_SHARE_DENY_WRITE = 32; + OF_SHARE_EXCLUSIVE = 16; + OF_CANCEL = 2048; + OF_CREATE = 4096; + OF_DELETE = 512; + OF_EXIST = 16384; + OF_PARSE = 256; + OF_PROMPT = 8192; + OF_REOPEN = 32768; + OF_VERIFY = 1024; + { ActivateKeyboardLayout, LoadKeyboardLayout } + HKL_NEXT = 1; + HKL_PREV = 0; + KLF_REORDER = 8; + KLF_UNLOADPREVIOUS = 4; + KLF_ACTIVATE = 1; + KLF_NOTELLSHELL = 128; + KLF_REPLACELANG = 16; + KLF_SUBSTITUTE_OK = 2; + { AppendMenu } + MF_BITMAP = $4; + MF_DISABLED = $2; + MF_ENABLED = 0; + MF_GRAYED = $1; + MF_HELP = $4000; + MF_MENUBARBREAK = $20; + MF_MENUBREAK = $40; + MF_MOUSESELECT = $8000; + MF_OWNERDRAW = $100; + MF_POPUP = $10; + MF_SEPARATOR = $800; + MF_STRING = 0; + MF_SYSMENU = $2000; + MF_USECHECKBITMAPS = $200; + { Ternary Raster Operations - BitBlt } + BLACKNESS = $00000042; + NOTSRCERASE = $001100A6; + NOTSRCCOPY = $00330008; + SRCERASE = $00440328; + DSTINVERT = $00550009; + PATINVERT = $005A0049; + SRCINVERT = $00660046; + SRCAND = $008800C6; + MERGEPAINT = $00BB0226; + MERGECOPY = $00C000CA; + SRCCOPY = $00CC0020; + SRCPAINT = $00EE0086; + PATCOPY = $00F00021; + PATPAINT = $00FB0A09; + WHITENESS = $00FF0062; + { Binary Raster Operations } + R2_BLACK = 1; + R2_COPYPEN = 13; + R2_MASKNOTPEN = 3; + R2_MASKPEN = 9; + R2_MASKPENNOT = 5; + R2_MERGENOTPEN = 12; + R2_MERGEPEN = 15; + R2_MERGEPENNOT = 14; + R2_NOP = 11; + R2_NOT = 6; + R2_NOTCOPYPEN = 4; + R2_NOTMASKPEN = 8; + R2_NOTMERGEPEN = 2; + R2_NOTXORPEN = 10; + R2_WHITE = 16; + R2_XORPEN = 7; + { BroadcastSystemMessage } + BSF_FLUSHDISK = 4; + BSF_FORCEIFHUNG = 32; + BSF_IGNORECURRENTTASK = 2; + BSF_NOHANG = 8; + BSF_POSTMESSAGE = 16; + BSF_QUERY = 1; + BSM_ALLCOMPONENTS = 0; + BSM_APPLICATIONS = 8; + BSM_INSTALLABLEDRIVERS = 4; + BSM_NETDRIVER = 2; + BSM_VXDS = 1; + BROADCAST_QUERY_DENY = 1112363332; + { BrowseCallbackProc } + { CallNamedPipe } + NMPWAIT_NOWAIT = 1; + NMPWAIT_WAIT_FOREVER = -(1); + NMPWAIT_USE_DEFAULT_WAIT = 0; + { CascadeWindows, TileWindows } + MDITILE_SKIPDISABLED = 2; + MDITILE_HORIZONTAL = 1; + MDITILE_VERTICAL = 0; + { CBTProc } + HCBT_ACTIVATE = 5; + HCBT_CLICKSKIPPED = 6; + HCBT_CREATEWND = 3; + HCBT_DESTROYWND = 4; + HCBT_KEYSKIPPED = 7; + HCBT_MINMAX = 1; + HCBT_MOVESIZE = 0; + HCBT_QS = 2; + HCBT_SETFOCUS = 9; + HCBT_SYSCOMMAND = 8; + { ChangeDisplaySettings } + DM_BITSPERPEL = $40000; + DM_PELSWIDTH = $80000; + DM_PELSHEIGHT = $100000; + DM_DISPLAYFLAGS = $200000; + DM_DISPLAYFREQUENCY = $400000; + CDS_UPDATEREGISTRY = 1; + CDS_TEST = 2; + CDS_FULLSCREEN = 4; + CDS_GLOBAL = 8; + CDS_SET_PRIMARY = $10; + CDS_RESET = $40000000; + CDS_SETRECT = $20000000; + CDS_NORESET = $10000000; + DISP_CHANGE_SUCCESSFUL = 0; + DISP_CHANGE_RESTART = 1; + DISP_CHANGE_BADFLAGS = -(4); + DISP_CHANGE_FAILED = -(1); + DISP_CHANGE_BADMODE = -(2); + DISP_CHANGE_NOTUPDATED = -(3); + { ChangeServiceConfig } + SERVICE_NO_CHANGE = -(1); + SERVICE_WIN32_OWN_PROCESS = 16; + SERVICE_WIN32_SHARE_PROCESS = 32; + SERVICE_KERNEL_DRIVER = 1; + SERVICE_FILE_SYSTEM_DRIVER = 2; + SERVICE_INTERACTIVE_PROCESS = 256; + SERVICE_BOOT_START = 0; + SERVICE_SYSTEM_START = 1; + SERVICE_AUTO_START = 2; + SERVICE_DEMAND_START = 3; + SERVICE_DISABLED = 4; + { SERVICE_STATUS structure } + SERVICE_STOPPED = 1; + SERVICE_START_PENDING = 2; + SERVICE_STOP_PENDING = 3; + SERVICE_RUNNING = 4; + SERVICE_CONTINUE_PENDING = 5; + SERVICE_PAUSE_PENDING = 6; + SERVICE_PAUSED = 7; + SERVICE_ACCEPT_STOP = 1; + SERVICE_ACCEPT_PAUSE_CONTINUE = 2; + SERVICE_ACCEPT_SHUTDOWN = 4; + { CheckDlgButton } + BST_CHECKED = 1; + BST_INDETERMINATE = 2; + BST_UNCHECKED = 0; + BST_FOCUS = 8; + BST_PUSHED = 4; + { CheckMenuItem, HiliteMenuItem } + MF_BYCOMMAND = 0; + MF_BYPOSITION = $400; + MF_CHECKED = $8; + MF_UNCHECKED = 0; + MF_HILITE = $80; + MF_UNHILITE = 0; + { ChildWindowFromPointEx } + CWP_ALL = 0; + CWP_SKIPINVISIBLE = 1; + CWP_SKIPDISABLED = 2; + CWP_SKIPTRANSPARENT = 4; + { ClearCommError } + CE_BREAK = 16; + CE_DNS = 2048; + CE_FRAME = 8; + CE_IOE = 1024; + CE_MODE = 32768; + CE_OOP = 4096; + CE_OVERRUN = 2; + CE_PTO = 512; + CE_RXOVER = 1; + CE_RXPARITY = 4; + CE_TXFULL = 256; + { ChooseMatchToTarget } + { CombineRgn } + RGN_AND = 1; + RGN_COPY = 5; + RGN_DIFF = 4; + RGN_OR = 2; + RGN_XOR = 3; + NULLREGION = 1; + SIMPLEREGION = 2; + COMPLEXREGION = 3; + ERROR = 0; + { CommonDlgExtendedError } + CDERR_DIALOGFAILURE = $ffff; + CDERR_FINDRESFAILURE = 6; + CDERR_INITIALIZATION = 2; + CDERR_LOADRESFAILURE = 7; + CDERR_LOADSTRFAILURE = 5; + CDERR_LOCKRESFAILURE = 8; + CDERR_MEMALLOCFAILURE = 9; + CDERR_MEMLOCKFAILURE = 10; + CDERR_NOHINSTANCE = 4; + CDERR_NOHOOK = 11; + CDERR_NOTEMPLATE = 3; + CDERR_REGISTERMSGFAIL = 12; + CDERR_STRUCTSIZE = 1; + PDERR_CREATEICFAILURE = $1000 + 10; + PDERR_DEFAULTDIFFERENT = $1000 + 12; + PDERR_DNDMMISMATCH = $1000 + 9; + PDERR_GETDEVMODEFAIL = $1000 + 5; + PDERR_INITFAILURE = $1000 + 6; + PDERR_LOADDRVFAILURE = $1000 + 4; + PDERR_NODEFAULTPRN = $1000 + 8; + PDERR_NODEVICES = $1000 + 7; + PDERR_PARSEFAILURE = $1000 + 2; + PDERR_PRINTERNOTFOUND = $1000 + 11; + PDERR_RETDEFFAILURE = $1000 + 3; + PDERR_SETUPFAILURE = $1000 + 1; + CFERR_MAXLESSTHANMIN = $2000 + 2; + CFERR_NOFONTS = $2000 + 1; + FNERR_BUFFERTOOSMALL = $3000 + 3; + FNERR_INVALIDFILENAME = $3000 + 2; + FNERR_SUBCLASSFAILURE = $3000 + 1; + FRERR_BUFFERLENGTHZERO = $4000 + 1; + { CompareString, LCMapString } + //LOCALE_SYSTEM_DEFAULT = $800; //-winnt, replaced by function + //LOCALE_USER_DEFAULT = $400; //-winnt, replaced by function + NORM_IGNORECASE = 1; + NORM_IGNOREKANATYPE = 65536; + NORM_IGNORENONSPACE = 2; + NORM_IGNORESYMBOLS = 4; + NORM_IGNOREWIDTH = 131072; + SORT_STRINGSORT = 4096; + LCMAP_BYTEREV = 2048; + LCMAP_FULLWIDTH = 8388608; + LCMAP_HALFWIDTH = 4194304; + LCMAP_HIRAGANA = 1048576; + LCMAP_KATAKANA = 2097152; + LCMAP_LOWERCASE = 256; + LCMAP_SORTKEY = 1024; + LCMAP_UPPERCASE = 512; + { ContinueDebugEvent } + DBG_CONTINUE = $10002; + DBG_CONTROL_BREAK = $40010008; + DBG_CONTROL_C = $40010005; + DBG_EXCEPTION_NOT_HANDLED = $80010001; + DBG_TERMINATE_THREAD = $40010003; + DBG_TERMINATE_PROCESS = $40010004; + { ControlService } + SERVICE_CONTROL_STOP = 1; + SERVICE_CONTROL_PAUSE = 2; + SERVICE_CONTROL_CONTINUE = 3; + SERVICE_CONTROL_INTERROGATE = 4; + SERVICE_CONTROL_SHUTDOWN = 5; + { CopyImage, LoadImage } + IMAGE_BITMAP = 0; + IMAGE_CURSOR = 2; + IMAGE_ENHMETAFILE = 1; + IMAGE_ICON = 1; + LR_COPYDELETEORG = 8; + LR_COPYRETURNORG = 4; + LR_MONOCHROME = 1; + LR_CREATEDIBSECTION = 8192; + LR_DEFAULTSIZE = 64; + { CreateDesktop } + DF_ALLOWOTHERACCOUNTHOOK = $1; + DESKTOP_CREATEMENU = $4; + DESKTOP_CREATEWINDOW = $2; + DESKTOP_ENUMERATE = $40; + DESKTOP_HOOKCONTROL = $8; + DESKTOP_JOURNALPLAYBACK = $20; + DESKTOP_JOURNALRECORD = $10; + DESKTOP_READOBJECTS = $1; + DESKTOP_SWITCHDESKTOP = $100; + DESKTOP_WRITEOBJECTS = $80; + WSF_VISIBLE = $1; + { CreateDIBitmap } + CBM_INIT = $4; + DIB_PAL_COLORS = 1; + DIB_RGB_COLORS = 0; + { file & pipe } + FILE_READ_DATA = $0001; + { directory } + FILE_LIST_DIRECTORY = $0001; + { file & pipe } + FILE_WRITE_DATA = $0002; + { directory } + FILE_ADD_FILE = $0002; + { file } + FILE_APPEND_DATA = $0004; + { directory } + FILE_ADD_SUBDIRECTORY = $0004; + { named pipe } + FILE_CREATE_PIPE_INSTANCE = $0004; + { file & directory } + FILE_READ_EA = $0008; + FILE_READ_PROPERTIES = FILE_READ_EA; + { file & directory } + FILE_WRITE_EA = $0010; + FILE_WRITE_PROPERTIES = FILE_WRITE_EA; + { file } + FILE_EXECUTE = $0020; + { directory } + FILE_TRAVERSE = $0020; + { directory } + FILE_DELETE_CHILD = $0040; + { all } + FILE_READ_ATTRIBUTES = $0080; + { all } + FILE_WRITE_ATTRIBUTES = $0100; + { displaced lower + #define FILE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF) + + #define FILE_GENERIC_READ (STANDARD_RIGHTS_READ |\ + FILE_READ_DATA |\ + FILE_READ_ATTRIBUTES |\ + FILE_READ_EA |\ + SYNCHRONIZE) + + + #define FILE_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ + FILE_WRITE_DATA |\ + FILE_WRITE_ATTRIBUTES |\ + FILE_WRITE_EA |\ + FILE_APPEND_DATA |\ + SYNCHRONIZE) + + + #define FILE_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE |\ + FILE_READ_ATTRIBUTES |\ + FILE_EXECUTE |\ + SYNCHRONIZE) + } + FILE_SHARE_DELETE = 4; + FILE_SHARE_READ = 1; + FILE_SHARE_WRITE = 2; + CONSOLE_TEXTMODE_BUFFER = 1; + CREATE_NEW = 1; + CREATE_ALWAYS = 2; + OPEN_EXISTING = 3; + OPEN_ALWAYS = 4; + TRUNCATE_EXISTING = 5; + FILE_ATTRIBUTE_ARCHIVE = 32; + FILE_ATTRIBUTE_COMPRESSED = 2048; + FILE_ATTRIBUTE_NORMAL = 128; + FILE_ATTRIBUTE_DIRECTORY = 16; + FILE_ATTRIBUTE_HIDDEN = 2; + FILE_ATTRIBUTE_READONLY = 1; + FILE_ATTRIBUTE_SYSTEM = 4; + FILE_ATTRIBUTE_TEMPORARY = 256; + FILE_FLAG_WRITE_THROUGH = $80000000; + FILE_FLAG_OVERLAPPED = 1073741824; + FILE_FLAG_NO_BUFFERING = 536870912; + FILE_FLAG_RANDOM_ACCESS = 268435456; + FILE_FLAG_SEQUENTIAL_SCAN = 134217728; + FILE_FLAG_DELETE_ON_CLOSE = 67108864; + FILE_FLAG_BACKUP_SEMANTICS = 33554432; + FILE_FLAG_POSIX_SEMANTICS = 16777216; + SECURITY_ANONYMOUS = 0; + SECURITY_IDENTIFICATION = 65536; + SECURITY_IMPERSONATION = 131072; + SECURITY_DELEGATION = 196608; + SECURITY_CONTEXT_TRACKING = 262144; + SECURITY_EFFECTIVE_ONLY = 524288; + SECURITY_SQOS_PRESENT = 1048576; + { CreateFileMapping, VirtualAlloc, VirtualFree, VirtualProtect } + SEC_COMMIT = 134217728; + SEC_IMAGE = 16777216; + SEC_NOCACHE = 268435456; + SEC_RESERVE = 67108864; + PAGE_READONLY = 2; + PAGE_READWRITE = 4; + PAGE_WRITECOPY = 8; + PAGE_EXECUTE = 16; + PAGE_EXECUTE_READ = 32; + PAGE_EXECUTE_READWRITE = 64; + PAGE_EXECUTE_WRITECOPY = 128; + PAGE_GUARD = 256; + PAGE_NOACCESS = 1; + PAGE_NOCACHE = 512; + MEM_COMMIT = 4096; + MEM_FREE = 65536; + MEM_RESERVE = 8192; + MEM_IMAGE = 16777216; + MEM_MAPPED = 262144; + MEM_PRIVATE = 131072; + MEM_DECOMMIT = 16384; + MEM_RELEASE = 32768; + MEM_TOP_DOWN = 1048576; + EXCEPTION_GUARD_PAGE = $80000001; + SECTION_EXTEND_SIZE = $10; + SECTION_MAP_READ = $4; + SECTION_MAP_WRITE = $2; + SECTION_QUERY = $1; + SECTION_ALL_ACCESS = $f001f; + { CreateFont } + FW_DONTCARE = 0; + FW_THIN = 100; + FW_EXTRALIGHT = 200; + FW_LIGHT = 300; + FW_NORMAL = 400; + FW_REGULAR = FW_NORMAL; + FW_MEDIUM = 500; + FW_SEMIBOLD = 600; + FW_BOLD = 700; + FW_EXTRABOLD = 800; + FW_HEAVY = 900; + ANSI_CHARSET = 0; + DEFAULT_CHARSET = 1; + SYMBOL_CHARSET = 2; + SHIFTJIS_CHARSET = 128; + HANGEUL_CHARSET = 129; + GB2312_CHARSET = 134; + CHINESEBIG5_CHARSET = 136; + GREEK_CHARSET = 161; + TURKISH_CHARSET = 162; + HEBREW_CHARSET = 177; + ARABIC_CHARSET = 178; + BALTIC_CHARSET = 186; + RUSSIAN_CHARSET = 204; + THAI_CHARSET = 222; + EASTEUROPE_CHARSET = 238; + + OEM_CHARSET = 255; + OEM_CERTIFY_TRUST = 2; //+windef + OEM_CERTIFY_RUN = 1; //+windef + OEM_CERTIFY_FALSE = 0; //+windef + + OUT_DEFAULT_PRECIS = 0; + OUT_STRING_PRECIS = 1; + OUT_CHARACTER_PRECIS = 2; + OUT_STROKE_PRECIS = 3; + OUT_TT_PRECIS = 4; + OUT_DEVICE_PRECIS = 5; + OUT_RASTER_PRECIS = 6; + OUT_TT_ONLY_PRECIS = 7; + OUT_OUTLINE_PRECIS = 8; + CLIP_DEFAULT_PRECIS = 0; + CLIP_CHARACTER_PRECIS = 1; + CLIP_STROKE_PRECIS = 2; + CLIP_MASK = 15; + CLIP_LH_ANGLES = 16; + CLIP_TT_ALWAYS = 32; + CLIP_EMBEDDED = 128; + DEFAULT_QUALITY = 0; + DRAFT_QUALITY = 1; + PROOF_QUALITY = 2; + NONANTIALIASED_QUALITY = 3; + ANTIALIASED_QUALITY = 4; + DEFAULT_PITCH = 0; + FIXED_PITCH = 1; + VARIABLE_PITCH = 2; + MONO_FONT = 8; + FF_DECORATIVE = 80; + FF_DONTCARE = 0; + FF_MODERN = 48; + FF_ROMAN = 16; + FF_SCRIPT = 64; + FF_SWISS = 32; + { CreateHatchBrush } + HS_BDIAGONAL = 3; + HS_CROSS = 4; + HS_DIAGCROSS = 5; + HS_FDIAGONAL = 2; + HS_HORIZONTAL = 0; + HS_VERTICAL = 1; + { CreateIconFromResourceEx } + LR_DEFAULTCOLOR = 0; + LR_LOADREALSIZE = 128; + { already defined above !! + #define LR_MONOCHROME (1) + } + { CreateMailslot, GetMailslotInfo } + MAILSLOT_WAIT_FOREVER = $ffffffff; + MAILSLOT_NO_MESSAGE = $ffffffff; + { CreateMappedBitmap } + CMB_MASKED = 2; + { CreateNamedPipe } + PIPE_ACCESS_DUPLEX = 3; + PIPE_ACCESS_INBOUND = 1; + PIPE_ACCESS_OUTBOUND = 2; + //WRITE_DAC = $40000; //~winnt, moved to ACCESS_TYPES + //WRITE_OWNER = $80000; //~winnt, moved to ACCESS_TYPES + //ACCESS_SYSTEM_SECURITY = $1000000; //~winnt, moved to ACCESS_TYPES + PIPE_TYPE_BYTE = 0; + PIPE_TYPE_MESSAGE = 4; + PIPE_READMODE_BYTE = 0; + PIPE_READMODE_MESSAGE = 2; + PIPE_WAIT = 0; + PIPE_NOWAIT = 1; + { CreatePen, ExtCreatePen } + PS_GEOMETRIC = 65536; + PS_COSMETIC = 0; + PS_ALTERNATE = 8; + PS_SOLID = 0; + PS_DASH = 1; + PS_DOT = 2; + PS_DASHDOT = 3; + PS_DASHDOTDOT = 4; + PS_NULL = 5; + PS_USERSTYLE = 7; + PS_INSIDEFRAME = 6; + PS_ENDCAP_ROUND = 0; + PS_ENDCAP_SQUARE = 256; + PS_ENDCAP_FLAT = 512; + PS_JOIN_BEVEL = 4096; + PS_JOIN_MITER = 8192; + PS_JOIN_ROUND = 0; + PS_STYLE_MASK = 15; + PS_ENDCAP_MASK = 3840; + PS_TYPE_MASK = 983040; + { CreatePolygonRgn } + ALTERNATE = 1; + WINDING = 2; + { CreateProcess } + CREATE_DEFAULT_ERROR_MODE = 67108864; + CREATE_NEW_CONSOLE = 16; + CREATE_NEW_PROCESS_GROUP = 512; + CREATE_SEPARATE_WOW_VDM = 2048; + CREATE_SUSPENDED = 4; + CREATE_UNICODE_ENVIRONMENT = 1024; + DEBUG_PROCESS = 1; + DEBUG_ONLY_THIS_PROCESS = 2; + DETACHED_PROCESS = 8; + HIGH_PRIORITY_CLASS = 128; + IDLE_PRIORITY_CLASS = 64; + NORMAL_PRIORITY_CLASS = 32; + REALTIME_PRIORITY_CLASS = 256; + { CreateService } + SERVICE_ALL_ACCESS = $f01ff; + SERVICE_CHANGE_CONFIG = 2; + SERVICE_ENUMERATE_DEPENDENTS = 8; + SERVICE_INTERROGATE = 128; + SERVICE_PAUSE_CONTINUE = 64; + SERVICE_QUERY_CONFIG = 1; + SERVICE_QUERY_STATUS = 4; + SERVICE_START = 16; + SERVICE_STOP = 32; + SERVICE_USER_DEFINED_CONTROL = 256; + SERVICE_DELETE = $10000; + SERVICE_READ_CONTROL = $20000; + SERVICE_GENERIC_EXECUTE = $20000000; + { already defined above !! + #define SERVICE_WIN32_OWN_PROCESS (16) + #define SERVICE_WIN32_SHARE_PROCESS (32) + #define SERVICE_KERNEL_DRIVER (1) + #define SERVICE_FILE_SYSTEM_DRIVER (2) + #define SERVICE_INTERACTIVE_PROCESS (256) + #define SERVICE_BOOT_START (0) + #define SERVICE_SYSTEM_START (1) + #define SERVICE_AUTO_START (2) + #define SERVICE_DEMAND_START (3) + #define SERVICE_DISABLED (4) + } + SERVICE_ERROR_IGNORE = 0; + SERVICE_ERROR_NORMAL = 1; + SERVICE_ERROR_SEVERE = 2; + SERVICE_ERROR_CRITICAL = 3; + { CreateTapePartition, WriteTapemark } + TAPE_FIXED_PARTITIONS = 0; + TAPE_INITIATOR_PARTITIONS = $2; + TAPE_SELECT_PARTITIONS = $1; + TAPE_FILEMARKS = $1; + TAPE_LONG_FILEMARKS = $3; + TAPE_SETMARKS = 0; + TAPE_SHORT_FILEMARKS = $2; + { CreateWindow } + CW_USEDEFAULT = $80000000; + WS_BORDER = $800000; + WS_CAPTION = $c00000; + WS_CHILD = $40000000; + WS_CHILDWINDOW = $40000000; + WS_CLIPCHILDREN = $2000000; + WS_CLIPSIBLINGS = $4000000; + WS_DISABLED = $8000000; + WS_DLGFRAME = $400000; + WS_GROUP = $20000; + WS_HSCROLL = $100000; + WS_ICONIC = $20000000; + WS_MAXIMIZE = $1000000; + WS_MAXIMIZEBOX = $10000; + WS_MINIMIZE = $20000000; + WS_MINIMIZEBOX = $20000; + WS_OVERLAPPED = 0; + WS_OVERLAPPEDWINDOW = $cf0000; + WS_POPUP = LONG($80000000); + WS_POPUPWINDOW = LONG($80880000); + WS_SIZEBOX = $40000; + WS_SYSMENU = $80000; + WS_TABSTOP = $10000; + WS_THICKFRAME = $40000; + WS_TILED = 0; + WS_TILEDWINDOW = $cf0000; + WS_VISIBLE = $10000000; + WS_VSCROLL = $200000; + MDIS_ALLCHILDSTYLES = $1; + BS_3STATE = $5; + BS_AUTO3STATE = $6; + BS_AUTOCHECKBOX = $3; + BS_AUTORADIOBUTTON = $9; + BS_BITMAP = $80; + BS_BOTTOM = $800; + BS_CENTER = $300; + BS_CHECKBOX = $2; + BS_DEFPUSHBUTTON = $1; + BS_GROUPBOX = $7; + BS_ICON = $40; + BS_LEFT = $100; + BS_LEFTTEXT = $20; + BS_MULTILINE = $2000; + BS_NOTIFY = $4000; + BS_OWNERDRAW = $b; + BS_PUSHBUTTON = 0; + BS_PUSHLIKE = $1000; + BS_RADIOBUTTON = $4; + BS_RIGHT = $200; + BS_RIGHTBUTTON = $20; + BS_TEXT = 0; + BS_TOP = $400; + BS_USERBUTTON = $8; + BS_VCENTER = $c00; + BS_FLAT = $8000; + CBS_AUTOHSCROLL = $40; + CBS_DISABLENOSCROLL = $800; + CBS_DROPDOWN = $2; + CBS_DROPDOWNLIST = $3; + CBS_HASSTRINGS = $200; + CBS_LOWERCASE = $4000; + CBS_NOINTEGRALHEIGHT = $400; + CBS_OEMCONVERT = $80; + CBS_OWNERDRAWFIXED = $10; + CBS_OWNERDRAWVARIABLE = $20; + CBS_SIMPLE = $1; + CBS_SORT = $100; + CBS_UPPERCASE = $2000; + ES_AUTOHSCROLL = $80; + ES_AUTOVSCROLL = $40; + ES_CENTER = $1; + ES_LEFT = 0; + ES_LOWERCASE = $10; + ES_MULTILINE = $4; + ES_NOHIDESEL = $100; + ES_NUMBER = $2000; + ES_OEMCONVERT = $400; + ES_PASSWORD = $20; + ES_READONLY = $800; + ES_RIGHT = $2; + ES_UPPERCASE = $8; + ES_WANTRETURN = $1000; + LBS_DISABLENOSCROLL = $1000; + LBS_EXTENDEDSEL = $800; + LBS_HASSTRINGS = $40; + LBS_MULTICOLUMN = $200; + LBS_MULTIPLESEL = $8; + LBS_NODATA = $2000; + LBS_NOINTEGRALHEIGHT = $100; + LBS_NOREDRAW = $4; + LBS_NOSEL = $4000; + LBS_NOTIFY = $1; + LBS_OWNERDRAWFIXED = $10; + LBS_OWNERDRAWVARIABLE = $20; + LBS_SORT = $2; + LBS_STANDARD = $a00003; + LBS_USETABSTOPS = $80; + LBS_WANTKEYBOARDINPUT = $400; + SBS_BOTTOMALIGN = $4; + SBS_HORZ = 0; + SBS_LEFTALIGN = $2; + SBS_RIGHTALIGN = $4; + SBS_SIZEBOX = $8; + SBS_SIZEBOXBOTTOMRIGHTALIGN = $4; + SBS_SIZEBOXTOPLEFTALIGN = $2; + SBS_SIZEGRIP = $10; + SBS_TOPALIGN = $2; + SBS_VERT = $1; + SS_BITMAP = $e; + SS_BLACKFRAME = $7; + SS_BLACKRECT = $4; + SS_CENTER = $1; + SS_CENTERIMAGE = $200; + SS_ENHMETAFILE = $f; + SS_ETCHEDFRAME = $12; + SS_ETCHEDHORZ = $10; + SS_ETCHEDVERT = $11; + SS_GRAYFRAME = $8; + SS_GRAYRECT = $5; + SS_ICON = $3; + SS_LEFT = 0; + SS_LEFTNOWORDWRAP = $c; + SS_NOPREFIX = $80; + SS_NOTIFY = $100; + SS_OWNERDRAW = $d; + SS_REALSIZEIMAGE = $800; + SS_RIGHT = $2; + SS_RIGHTJUST = $400; + SS_SIMPLE = $b; + SS_SUNKEN = $1000; + SS_USERITEM = $a; + SS_WHITEFRAME = $9; + SS_WHITERECT = $6; + DS_3DLOOK = $4; + DS_ABSALIGN = $1; + DS_CENTER = $800; + DS_CENTERMOUSE = $1000; + DS_CONTEXTHELP = $2000; + DS_CONTROL = $400; + DS_FIXEDSYS = $8; + DS_LOCALEDIT = $20; + DS_MODALFRAME = $80; + DS_NOFAILCREATE = $10; + DS_NOIDLEMSG = $100; + DS_SETFONT = $40; + DS_SETFOREGROUND = $200; + DS_SYSMODAL = $2; + { CreateWindowEx } + WS_EX_ACCEPTFILES = $10; + WS_EX_APPWINDOW = $40000; + WS_EX_CLIENTEDGE = $200; + WS_EX_CONTEXTHELP = $400; + WS_EX_CONTROLPARENT = $10000; + WS_EX_DLGMODALFRAME = $1; + WS_EX_LEFT = 0; + WS_EX_LEFTSCROLLBAR = $4000; + WS_EX_LTRREADING = 0; + WS_EX_MDICHILD = $40; + WS_EX_NOPARENTNOTIFY = $4; + WS_EX_OVERLAPPEDWINDOW = $300; + WS_EX_PALETTEWINDOW = $188; + WS_EX_RIGHT = $1000; + WS_EX_RIGHTSCROLLBAR = 0; + WS_EX_RTLREADING = $2000; + WS_EX_STATICEDGE = $20000; + WS_EX_TOOLWINDOW = $80; + WS_EX_TOPMOST = $8; + WS_EX_TRANSPARENT = $20; + WS_EX_WINDOWEDGE = $100; + { CreateWindowStation } + WINSTA_ACCESSCLIPBOARD = $4; + WINSTA_ACCESSGLOBALATOMS = $20; + WINSTA_CREATEDESKTOP = $8; + WINSTA_ENUMDESKTOPS = $1; + WINSTA_ENUMERATE = $100; + WINSTA_EXITWINDOWS = $40; + WINSTA_READATTRIBUTES = $2; + WINSTA_READSCREEN = $200; + WINSTA_WRITEATTRIBUTES = $10; + { DdeCallback } + { DdeClientTransaction } + { DdeEnableCallback } + { DdeGetLastError } + { DdeInitialize } + { DdeNameService } + { DebugProc } + WH_CALLWNDPROC = 4; + WH_CALLWNDPROCRET = 12; + WH_CBT = 5; + WH_DEBUG = 9; + WH_GETMESSAGE = 3; + WH_JOURNALPLAYBACK = 1; + WH_JOURNALRECORD = 0; + WH_KEYBOARD = 2; + WH_MOUSE = 7; + WH_MSGFILTER = -(1); + WH_SHELL = 10; + WH_SYSMSGFILTER = 6; + { already defined above !! + #define WH_MSGFILTER (-1) } + WH_FOREGROUNDIDLE = 11; + { DefineDosDevice } + DDD_RAW_TARGET_PATH = 1; + DDD_REMOVE_DEFINITION = 2; + DDD_EXACT_MATCH_ON_REMOVE = 4; + { DeviceCapbilities } + DC_BINNAMES = 12; //windef + DC_BINS = 6; //windef + DC_COPIES = 18; //windef + DC_DRIVER = 11; //windef + DC_DATATYPE_PRODUCED = 21; + DC_DUPLEX = 7; //windef + DC_EMF_COMPLIANT = 20; + DC_ENUMRESOLUTIONS = 13; //windef + DC_EXTRA = 9; //windef + DC_FIELDS = 1; //windef + DC_FILEDEPENDENCIES = 14; //windef + DC_MAXEXTENT = 5; //windef + DC_MINEXTENT = 4; //windef + DC_ORIENTATION = 17; //windef + DC_PAPERNAMES = 16; //windef + DC_PAPERS = 2; //windef + DC_PAPERSIZE = 3; //windef + DC_SIZE = 8; //windef + DC_TRUETYPE = 15; //windef + DCTT_BITMAP = $1; + DCTT_DOWNLOAD = $2; + DCTT_SUBDEV = $4; + DC_VERSION = 10; //windef + DC_BINADJUST = 19; + { already defined above !! + #define DC_DATATYPE_PRODUCED (21) + } + { DeviceIoControl } + { DlgDirList } + DDL_ARCHIVE = 32; + DDL_DIRECTORY = 16; + DDL_DRIVES = 16384; + DDL_EXCLUSIVE = 32768; + DDL_HIDDEN = 2; + DDL_READONLY = 1; + DDL_READWRITE = 0; + DDL_SYSTEM = 4; + DDL_POSTMSGS = 8192; + { DllEntryPoint } + DLL_PROCESS_ATTACH = 1; + DLL_THREAD_ATTACH = 2; + DLL_PROCESS_DETACH = 0; + DLL_THREAD_DETACH = 3; + { DocumentProperties } + DM_IN_BUFFER = 8; //windef + DM_MODIFY = 8; //windef + DM_IN_PROMPT = 4; //windef + DM_PROMPT = 4; //windef + DM_OUT_BUFFER = 2; //windef + DM_COPY = 2; //windef + DM_UPDATE = 1; //windef + { DrawAnimatedRects } + IDANI_OPEN = 1; + IDANI_CLOSE = 2; + { DrawCaption } + DC_ACTIVE = 1; + DC_SMALLCAP = 2; + { DrawEdge } + BDR_RAISEDINNER = 4; + BDR_SUNKENINNER = 8; + BDR_RAISEDOUTER = 1; + BDR_SUNKENOUTER = 1; + EDGE_BUMP = 9; + EDGE_ETCHED = 6; + EDGE_RAISED = 5; + EDGE_SUNKEN = 10; + BF_ADJUST = 8192; + BF_BOTTOM = 8; + BF_BOTTOMLEFT = 9; + BF_BOTTOMRIGHT = 12; + BF_DIAGONAL = 16; + BF_DIAGONAL_ENDBOTTOMLEFT = 25; + BF_DIAGONAL_ENDBOTTOMRIGHT = 28; + BF_DIAGONAL_ENDTOPLEFT = 19; + BF_DIAGONAL_ENDTOPRIGHT = 22; + BF_FLAT = 16384; + BF_LEFT = 1; + BF_MIDDLE = 2048; + BF_MONO = 32768; + BF_RECT = 15; + BF_RIGHT = 4; + BF_SOFT = 4096; + BF_TOP = 2; + BF_TOPLEFT = 3; + BF_TOPRIGHT = 6; + { DrawFrameControl } + DFC_BUTTON = 4; + DFC_CAPTION = 1; + DFC_MENU = 2; + DFC_SCROLL = 3; + DFCS_BUTTON3STATE = 8; + DFCS_BUTTONCHECK = 0; + DFCS_BUTTONPUSH = 16; + DFCS_BUTTONRADIO = 4; + DFCS_BUTTONRADIOIMAGE = 1; + DFCS_BUTTONRADIOMASK = 2; + DFCS_CAPTIONCLOSE = 0; + DFCS_CAPTIONHELP = 4; + DFCS_CAPTIONMAX = 2; + DFCS_CAPTIONMIN = 1; + DFCS_CAPTIONRESTORE = 3; + DFCS_MENUARROW = 0; + DFCS_MENUBULLET = 2; + DFCS_MENUCHECK = 1; + DFCS_SCROLLCOMBOBOX = 5; + DFCS_SCROLLDOWN = 1; + DFCS_SCROLLLEFT = 2; + DFCS_SCROLLRIGHT = 3; + DFCS_SCROLLSIZEGRIP = 8; + DFCS_SCROLLUP = 0; + DFCS_ADJUSTRECT = 8192; + DFCS_CHECKED = 1024; + DFCS_FLAT = 16384; + DFCS_INACTIVE = 256; + DFCS_MONO = 32768; + DFCS_PUSHED = 512; + { DrawIconEx } + DI_COMPAT = 4; + DI_DEFAULTSIZE = 8; + DI_IMAGE = 2; + DI_MASK = 1; + DI_NORMAL = 3; + { DrawState } + DST_BITMAP = 4; + DST_COMPLEX = 0; + DST_ICON = 3; + DST_PREFIXTEXT = 2; + DST_TEXT = 1; + DSS_NORMAL = 0; + DSS_UNION = 16; + DSS_DISABLED = 32; + DSS_MONO = 128; + { DrawStatusText } + SBT_NOBORDERS = 256; + SBT_OWNERDRAW = 4096; + SBT_POPOUT = 512; + SBT_RTLREADING = 1024; + { DrawText, DrawTextEx } + DT_BOTTOM = 8; + DT_CALCRECT = 1024; + DT_CENTER = 1; + DT_EDITCONTROL = 8192; + DT_END_ELLIPSIS = 32768; + DT_PATH_ELLIPSIS = 16384; + DT_EXPANDTABS = 64; + DT_EXTERNALLEADING = 512; + DT_LEFT = 0; + DT_MODIFYSTRING = 65536; + DT_NOCLIP = 256; + DT_NOPREFIX = 2048; + DT_RIGHT = 2; + DT_RTLREADING = 131072; + DT_SINGLELINE = 32; + DT_TABSTOP = 128; + DT_TOP = 0; + DT_VCENTER = 4; + DT_WORDBREAK = 16; + DT_INTERNAL = 4096; + { DuplicateHandle, MapViewOfFile } + DUPLICATE_CLOSE_SOURCE = 1; + DUPLICATE_SAME_ACCESS = 2; + FILE_MAP_ALL_ACCESS = $f001f; + FILE_MAP_READ = 4; + FILE_MAP_WRITE = 2; + FILE_MAP_COPY = 1; + MUTEX_ALL_ACCESS = $1f0001; + MUTEX_MODIFY_STATE = 1; + //SYNCHRONIZE = $100000; //~winnt, move to ACCESS_TYPE + SEMAPHORE_ALL_ACCESS = $1f0003; + SEMAPHORE_MODIFY_STATE = 2; + EVENT_ALL_ACCESS = $1f0003; + EVENT_MODIFY_STATE = 2; + KEY_ALL_ACCESS = $f003f; + KEY_CREATE_LINK = 32; + KEY_CREATE_SUB_KEY = 4; + KEY_ENUMERATE_SUB_KEYS = 8; + KEY_EXECUTE = $20019; + KEY_NOTIFY = 16; + KEY_QUERY_VALUE = 1; + KEY_READ = $20019; + KEY_SET_VALUE = 2; + KEY_WRITE = $20006; + PROCESS_ALL_ACCESS = $1f0fff; + PROCESS_CREATE_PROCESS = 128; + PROCESS_CREATE_THREAD = 2; + PROCESS_DUP_HANDLE = 64; + PROCESS_QUERY_INFORMATION = 1024; + PROCESS_SET_INFORMATION = 512; + PROCESS_TERMINATE = 1; + PROCESS_VM_OPERATION = 8; + PROCESS_VM_READ = 16; + PROCESS_VM_WRITE = 32; + THREAD_ALL_ACCESS = $1f03ff; + THREAD_DIRECT_IMPERSONATION = 512; + THREAD_GET_CONTEXT = 8; + THREAD_IMPERSONATE = 256; + THREAD_QUERY_INFORMATION = 64; + THREAD_SET_CONTEXT = 16; + THREAD_SET_INFORMATION = 32; + THREAD_SET_THREAD_TOKEN = 128; + THREAD_SUSPEND_RESUME = 2; + THREAD_TERMINATE = 1; + { EditWordBreakProc } + WB_ISDELIMITER = 2; + WB_LEFT = 0; + WB_RIGHT = 1; + { EnableScrollBar } + SB_BOTH = 3; + SB_CTL = 2; + SB_HORZ = 0; + SB_VERT = 1; + ESB_DISABLE_BOTH = 3; + ESB_DISABLE_DOWN = 2; + ESB_DISABLE_LEFT = 1; + ESB_DISABLE_LTUP = 1; + ESB_DISABLE_RIGHT = 2; + ESB_DISABLE_RTDN = 2; + ESB_DISABLE_UP = 1; + ESB_ENABLE_BOTH = 0; + { Scroll Bar notifications } + SB_LINEUP = 0; + SB_LINEDOWN = 1; + SB_LINELEFT = 0; + SB_LINERIGHT = 1; + SB_PAGEUP = 2; + SB_PAGEDOWN = 3; + SB_PAGELEFT = 2; + SB_PAGERIGHT = 3; + SB_THUMBPOSITION = 4; + SB_THUMBTRACK = 5; + SB_ENDSCROLL = 8; + SB_LEFT = 6; + SB_RIGHT = 7; + SB_BOTTOM = 7; + SB_TOP = 6; + { EnumCalendarInfo } + ENUM_ALL_CALENDARS = -(1); + { EnumDateFormats } + DATE_SHORTDATE = 1; + DATE_LONGDATE = 2; + { EnumDependentServices } + SERVICE_ACTIVE = 1; + SERVICE_INACTIVE = 2; + { EnumFontFamExProc } + DEVICE_FONTTYPE = 2; + RASTER_FONTTYPE = 1; + TRUETYPE_FONTTYPE = 4; + { EnumObjects, GetCurrentObject, GetObjectType } + OBJ_BRUSH = 2; + OBJ_PEN = 1; + OBJ_PAL = 5; + OBJ_FONT = 6; + OBJ_BITMAP = 7; + OBJ_EXTPEN = 11; + OBJ_REGION = 8; + OBJ_DC = 3; + OBJ_MEMDC = 10; + OBJ_METAFILE = 9; + OBJ_METADC = 4; + OBJ_ENHMETAFILE = 13; + OBJ_ENHMETADC = 12; + { EnumPrinters } + { EnumProtocols } + { EnumResLangProc } + { was #define dname def_expr } + function RT_ACCELERATOR : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_BITMAP : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_DIALOG : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_FONT : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_FONTDIR : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_MENU : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_RCDATA : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_STRING : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_MESSAGETABLE : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_CURSOR : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_GROUP_CURSOR : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_ICON : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_GROUP_ICON : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function RT_VERSION : LPTSTR; + { return type might be wrong } + + { EnumServicesStatus } + + const + SERVICE_WIN32 = 48; + SERVICE_DRIVER = 11; + { EnumSystemCodePages } + CP_INSTALLED = 1; + CP_SUPPORTED = 2; + { EnumSystemLocales } + LCID_INSTALLED = 1; + LCID_SUPPORTED = 2; + { EraseTape } + TAPE_ERASE_LONG = $1; + TAPE_ERASE_SHORT = 0; + { Escape } + SP_ERROR = -(1); + SP_OUTOFDISK = -(4); + SP_OUTOFMEMORY = -(5); + SP_USERABORT = -(3); + PHYSICALWIDTH = 110; + PHYSICALHEIGHT = 111; + PHYSICALOFFSETX = 112; + PHYSICALOFFSETY = 113; + SCALINGFACTORX = 114; + SCALINGFACTORY = 115; + QUERYESCSUPPORT = 8; + {ABORTDOC = 2; conflicts with AbortDoc function } + cABORTDOC = 2; + {ENDDOC = 11; conflicts with AbortDoc function } + cENDDOC = 11; + GETPHYSPAGESIZE = 12; + GETPRINTINGOFFSET = 13; + GETSCALINGFACTOR = 14; + NEWFRAME = 1; + NEXTBAND = 3; + PASSTHROUGH = 19; + {SETABORTPROC = 9; conflicts with AbortDoc function } + cSETABORTPROC = 9; + {STARTDOC = 10; conflicts with AbortDoc function } + cSTARTDOC = 10; + { EscapeCommFunction } + CLRDTR = 6; + CLRRTS = 4; + SETDTR = 5; + SETRTS = 3; + SETXOFF = 1; + SETXON = 2; + SETBREAK = 8; + CLRBREAK = 9; + { ExitWindowsEx } + EWX_FORCE = 4; + EWX_LOGOFF = 0; + EWX_POWEROFF = 8; + EWX_REBOOT = 2; + EWX_SHUTDOWN = 1; + { ExtFloodFill } + FLOODFILLBORDER = 0; + FLOODFILLSURFACE = 1; + { ExtTextOut } + ETO_CLIPPED = 4; + ETO_GLYPH_INDEX = 16; + ETO_OPAQUE = 2; + ETO_RTLREADING = 128; + { FillConsoleOutputAttribute } + FOREGROUND_BLUE = 1; + FOREGROUND_GREEN = 2; + FOREGROUND_RED = 4; + FOREGROUND_INTENSITY = 8; + BACKGROUND_BLUE = 16; + BACKGROUND_GREEN = 32; + BACKGROUND_RED = 64; + BACKGROUND_INTENSITY = 128; + { FindFirstChangeNotification } + FILE_NOTIFY_CHANGE_FILE_NAME = 1; + FILE_NOTIFY_CHANGE_DIR_NAME = 2; + FILE_NOTIFY_CHANGE_ATTRIBUTES = 4; + FILE_NOTIFY_CHANGE_SIZE = 8; + FILE_NOTIFY_CHANGE_LAST_WRITE = 16; + FILE_NOTIFY_CHANGE_SECURITY = 256; + { FindFirstPrinterChangeNotification } + { FindNextPrinterNotification } + { FMExtensionProc } + { FoldString } + MAP_FOLDCZONE = 16; + MAP_FOLDDIGITS = 128; + MAP_PRECOMPOSED = 32; + MAP_COMPOSITE = 64; + { ForegroundIdleProc } + HC_ACTION = 0; + { FormatMessage } + FORMAT_MESSAGE_ALLOCATE_BUFFER = 256; + FORMAT_MESSAGE_IGNORE_INSERTS = 512; + FORMAT_MESSAGE_FROM_STRING = 1024; + FORMAT_MESSAGE_FROM_HMODULE = 2048; + FORMAT_MESSAGE_FROM_SYSTEM = 4096; + FORMAT_MESSAGE_ARGUMENT_ARRAY = 8192; + FORMAT_MESSAGE_MAX_WIDTH_MASK = 255; + { GdiComment } + GDICOMMENT_WINDOWS_METAFILE = -(2147483647); + GDICOMMENT_BEGINGROUP = 2; + GDICOMMENT_ENDGROUP = 3; + GDICOMMENT_MULTIFORMATS = 1073741828; + GDICOMMENT_IDENTIFIER = 1128875079; + { GenerateConsoleCtrlEvent, HandlerRoutine } + CTRL_C_EVENT = 0; + CTRL_BREAK_EVENT = 1; + CTRL_CLOSE_EVENT = 2; + CTRL_LOGOFF_EVENT = 5; + CTRL_SHUTDOWN_EVENT = 6; + { GetAddressByName } + { GetArcDirection } + AD_COUNTERCLOCKWISE = 1; + AD_CLOCKWISE = 2; + { GetBinaryTypes } + SCS_32BIT_BINARY = 0; + SCS_DOS_BINARY = 1; + SCS_OS216_BINARY = 5; + SCS_PIF_BINARY = 3; + SCS_POSIX_BINARY = 4; + SCS_WOW_BINARY = 2; + { GetBoundsRect, SetBoundsRect } + DCB_DISABLE = 8; + DCB_ENABLE = 4; + DCB_RESET = 1; + DCB_SET = 3; + DCB_ACCUMULATE = 2; + { GetCharacterPlacement, GetFontLanguageInfo } + GCP_DBCS = 1; + GCP_ERROR = $8000; + GCP_CLASSIN = $80000; + GCP_DIACRITIC = 256; + GCP_DISPLAYZWG = $400000; + GCP_GLYPHSHAPE = 16; + GCP_JUSTIFY = $10000; + GCP_JUSTIFYIN = $200000; + GCP_KASHIDA = 1024; + GCP_LIGATE = 32; + GCP_MAXEXTENT = $100000; + GCP_NEUTRALOVERRIDE = $2000000; + GCP_NUMERICOVERRIDE = $1000000; + GCP_NUMERICSLATIN = $4000000; + GCP_NUMERICSLOCAL = $8000000; + GCP_REORDER = 2; + GCP_SYMSWAPOFF = $800000; + GCP_USEKERNING = 8; + FLI_GLYPHS = $40000; + FLI_MASK = $103b; + { GetClassLong, GetClassWord } + GCW_ATOM = -(32); + GCL_CBCLSEXTRA = -(20); + GCL_CBWNDEXTRA = -(18); + GCL_HBRBACKGROUND = -(10); + GCL_HCURSOR = -(12); + GCL_HICON = -(14); + GCL_HICONSM = -(34); + GCL_HMODULE = -(16); + GCL_MENUNAME = -(8); + GCL_STYLE = -(26); + GCL_WNDPROC = -(24); + { GetClipboardFormat, SetClipboardData } + CF_BITMAP = 2; + CF_DIB = 8; + CF_PALETTE = 9; + CF_ENHMETAFILE = 14; + CF_METAFILEPICT = 3; + CF_OEMTEXT = 7; + CF_TEXT = 1; + CF_UNICODETEXT = 13; + CF_DIF = 5; + CF_DSPBITMAP = 130; + CF_DSPENHMETAFILE = 142; + CF_DSPMETAFILEPICT = 131; + CF_DSPTEXT = 129; + CF_GDIOBJFIRST = 768; + CF_GDIOBJLAST = 1023; + CF_HDROP = 15; + CF_LOCALE = 16; + CF_OWNERDISPLAY = 128; + CF_PENDATA = 10; + CF_PRIVATEFIRST = 512; + CF_PRIVATELAST = 767; + CF_RIFF = 11; + CF_SYLK = 4; + CF_WAVE = 12; + CF_TIFF = 6; + { GetCommMask } + EV_BREAK = 64; + EV_CTS = 8; + EV_DSR = 16; + EV_ERR = 128; + EV_EVENT1 = 2048; + EV_EVENT2 = 4096; + EV_PERR = 512; + EV_RING = 256; + EV_RLSD = 32; + EV_RX80FULL = 1024; + EV_RXCHAR = 1; + EV_RXFLAG = 2; + EV_TXEMPTY = 4; + { GetCommModemStatus } + MS_CTS_ON = $10; + MS_DSR_ON = $20; + MS_RING_ON = $40; + MS_RLSD_ON = $80; + { GetComputerName } + MAX_COMPUTERNAME_LENGTH = 15; + { GetConsoleMode } + ENABLE_LINE_INPUT = 2; + ENABLE_ECHO_INPUT = 4; + ENABLE_PROCESSED_INPUT = 1; + ENABLE_WINDOW_INPUT = 8; + ENABLE_MOUSE_INPUT = 16; + ENABLE_PROCESSED_OUTPUT = 1; + ENABLE_WRAP_AT_EOL_OUTPUT = 2; + { GetCPInfo } + CP_ACP = 0; + CP_MACCP = 2; + CP_OEMCP = 1; + { GetDateFormat } + { already defined above !! + #define DATE_SHORTDATE (1) + #define DATE_LONGDATE (2) + } + DATE_USE_ALT_CALENDAR = 4; + { GetDCEx } + DCX_WINDOW = $1; + DCX_CACHE = $2; + DCX_PARENTCLIP = $20; + DCX_CLIPSIBLINGS = $10; + DCX_CLIPCHILDREN = $8; + DCX_NORESETATTRS = $4; + DCX_LOCKWINDOWUPDATE = $400; + DCX_EXCLUDERGN = $40; + DCX_INTERSECTRGN = $80; + DCX_VALIDATE = $200000; + { GetDeviceCaps } + DRIVERVERSION = 0; + TECHNOLOGY = 2; + DT_PLOTTER = 0; + DT_RASDISPLAY = 1; + DT_RASPRINTER = 2; + DT_RASCAMERA = 3; + DT_CHARSTREAM = 4; + DT_METAFILE = 5; + DT_DISPFILE = 6; + HORZSIZE = 4; + VERTSIZE = 6; + HORZRES = 8; + VERTRES = 10; + LOGPIXELSX = 88; + LOGPIXELSY = 90; + BITSPIXEL = 12; + PLANES = 14; + NUMBRUSHES = 16; + NUMPENS = 18; + NUMFONTS = 22; + NUMCOLORS = 24; + ASPECTX = 40; + ASPECTY = 42; + ASPECTXY = 44; + PDEVICESIZE = 26; + CLIPCAPS = 36; + SIZEPALETTE = 104; + NUMRESERVED = 106; + COLORRES = 108; + { already defined above !! + #define PHYSICALWIDTH (110) + #define PHYSICALHEIGHT (111) + #define PHYSICALOFFSETX (112) + #define PHYSICALOFFSETY (113) + #define SCALINGFACTORX (114) + #define SCALINGFACTORY (115) + } + VREFRESH = 116; + DESKTOPHORZRES = 118; + DESKTOPVERTRES = 117; + BLTALIGNMENT = 119; + RASTERCAPS = 38; + RC_BANDING = 2; + RC_BITBLT = 1; + RC_BITMAP64 = 8; + RC_DI_BITMAP = 128; + RC_DIBTODEV = 512; + RC_FLOODFILL = 4096; + RC_GDI20_OUTPUT = 16; + RC_PALETTE = 256; + RC_SCALING = 4; + RC_STRETCHBLT = 2048; + RC_STRETCHDIB = 8192; + CURVECAPS = 28; + CC_NONE = 0; + CC_CIRCLES = 1; + CC_PIE = 2; + CC_CHORD = 4; + CC_ELLIPSES = 8; + CC_WIDE = 16; + CC_STYLED = 32; + CC_WIDESTYLED = 64; + CC_INTERIORS = 128; + CC_ROUNDRECT = 256; + LINECAPS = 30; + LC_NONE = 0; + LC_POLYLINE = 2; + LC_MARKER = 4; + LC_POLYMARKER = 8; + LC_WIDE = 16; + LC_STYLED = 32; + LC_WIDESTYLED = 64; + LC_INTERIORS = 128; + POLYGONALCAPS = 32; + PC_NONE = 0; + PC_POLYGON = 1; + PC_RECTANGLE = 2; + PC_WINDPOLYGON = 4; + PC_SCANLINE = 8; + PC_WIDE = 16; + PC_STYLED = 32; + PC_WIDESTYLED = 64; + PC_INTERIORS = 128; + TEXTCAPS = 34; + TC_OP_CHARACTER = 1; + TC_OP_STROKE = 2; + TC_CP_STROKE = 4; + TC_CR_90 = 8; + TC_CR_ANY = 16; + TC_SF_X_YINDEP = 32; + TC_SA_DOUBLE = 64; + TC_SA_INTEGER = 128; + TC_SA_CONTIN = 256; + TC_EA_DOUBLE = 512; + TC_IA_ABLE = 1024; + TC_UA_ABLE = 2048; + TC_SO_ABLE = 4096; + TC_RA_ABLE = 8192; + TC_VA_ABLE = 16384; + TC_RESERVED = 32768; + TC_SCROLLBLT = 65536; + PC_PATHS = 512; + { GetDriveType } + DRIVE_REMOVABLE = 2; + DRIVE_FIXED = 3; + DRIVE_REMOTE = 4; + DRIVE_CDROM = 5; + DRIVE_RAMDISK = 6; + DRIVE_UNKNOWN = 0; + DRIVE_NO_ROOT_DIR = 1; + { GetExceptionCode } + EXCEPTION_ACCESS_VIOLATION = $c0000005; + EXCEPTION_BREAKPOINT = $80000003; + EXCEPTION_DATATYPE_MISALIGNMENT = $80000002; + EXCEPTION_SINGLE_STEP = $80000004; + EXCEPTION_ARRAY_BOUNDS_EXCEEDED = $c000008c; + EXCEPTION_FLT_DENORMAL_OPERAND = $c000008d; + EXCEPTION_FLT_DIVIDE_BY_ZERO = $c000008e; + EXCEPTION_FLT_INEXACT_RESULT = $c000008f; + EXCEPTION_FLT_INVALID_OPERATION = $c0000090; + EXCEPTION_FLT_OVERFLOW = $c0000091; + EXCEPTION_FLT_STACK_CHECK = $c0000092; + EXCEPTION_FLT_UNDERFLOW = $c0000093; + EXCEPTION_INT_DIVIDE_BY_ZERO = $c0000094; + EXCEPTION_INT_OVERFLOW = $c0000095; + EXCEPTION_INVALID_HANDLE = $c0000008; + EXCEPTION_PRIV_INSTRUCTION = $c0000096; + EXCEPTION_NONCONTINUABLE_EXCEPTION = $c0000025; + EXCEPTION_NONCONTINUABLE = $1; //winnt + EXCEPTION_UNWINDING = $2; //+winnt + EXCEPTION_EXIT_UNWIND = $4; //+winnt + EXCEPTION_STACK_INVALID = $8; //+winnt + EXCEPTION_NESTED_CALL = $10; //+winnt + EXCEPTION_TARGET_UNWIND = $20; //+winnt + EXCEPTION_COLLIDED_UNWIND = $40; //+winnt + EXCEPTION_UNWIND = EXCEPTION_UNWINDING or EXCEPTION_EXIT_UNWIND or + EXCEPTION_TARGET_UNWIND or EXCEPTION_COLLIDED_UNWIND; //+winnt + EXCEPTION_STACK_OVERFLOW = $c00000fd; + EXCEPTION_INVALID_DISPOSITION = $c0000026; + EXCEPTION_IN_PAGE_ERROR = $c0000006; + EXCEPTION_ILLEGAL_INSTRUCTION = $c000001d; + EXCEPTION_POSSIBLE_DEADLOCK = $c0000194; + + function IS_UNWINDING( Flag : Longint) : boolean; //+winnt + function IS_DISPATCHING( Flag : Longint) : boolean; //+winnt + function IS_TARGET_UNWIND( Flag : Longint) : Longint; //+winnt + + { GetFileType } + const + FILE_TYPE_UNKNOWN = 0; + FILE_TYPE_DISK = 1; + FILE_TYPE_CHAR = 2; + FILE_TYPE_PIPE = 3; + { GetGlyphOutline } + GGO_BITMAP = 1; + GGO_NATIVE = 2; + GGO_METRICS = 0; + GGO_GRAY2_BITMAP = 4; + GGO_GRAY4_BITMAP = 5; + GGO_GRAY8_BITMAP = 6; + GDI_ERROR = $ffffffff; + { GetGraphicsMode } + GM_COMPATIBLE = 1; + GM_ADVANCED = 2; + { GetHandleInformation } + HANDLE_FLAG_INHERIT = 1; + HANDLE_FLAG_PROTECT_FROM_CLOSE = 2; + { GetIconInfo } + { was #define dname def_expr } + function IDC_ARROW : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_IBEAM : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_WAIT : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_CROSS : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_UPARROW : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_SIZENWSE : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_SIZENESW : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_SIZEWE : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_SIZENS : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_SIZEALL : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_NO : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_APPSTARTING : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_HELP : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDI_APPLICATION : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDI_HAND : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDI_QUESTION : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDI_EXCLAMATION : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDI_ASTERISK : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDI_WINLOGO : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_SIZE : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_ICON : LPTSTR; + { return type might be wrong } + + { was #define dname def_expr } + function IDC_HAND : LPTSTR; + { return type might be wrong } + + { GetMapMode } + + const + MM_ANISOTROPIC = 8; + MM_HIENGLISH = 5; + MM_HIMETRIC = 3; + MM_ISOTROPIC = 7; + MM_LOENGLISH = 4; + MM_LOMETRIC = 2; + MM_TEXT = 1; + MM_TWIPS = 6; + { GetMenuDefaultItem } + GMDI_GOINTOPOPUPS = $2; + GMDI_USEDISABLED = $1; + { PeekMessage } + PM_NOREMOVE = 0; + PM_REMOVE = 1; + PM_NOYIELD = 2; + { GetNamedPipeHandleState } + { PIPE_NOWAIT = 1; already above } + { PIPE_READMODE_MESSAGE = 2;already above } + { GetNamedPipeInfo } + PIPE_CLIENT_END = 0; + PIPE_SERVER_END = 1; + { PIPE_TYPE_MESSAGE = 4;already above } + { GetNextWindow, GetWindow } + GW_HWNDNEXT = 2; + GW_HWNDPREV = 3; + GW_CHILD = 5; + GW_HWNDFIRST = 0; + GW_HWNDLAST = 1; + GW_OWNER = 4; + GW_MAX = 5; //+winuser + + { GetPath } + PT_MOVETO = 6; + PT_LINETO = 2; + PT_BEZIERTO = 4; + PT_CLOSEFIGURE = 1; + { GetProcessShutdownParameters } + SHUTDOWN_NORETRY = 1; + { GetQueueStatus } + QS_ALLEVENTS = 191; + QS_ALLINPUT = 255; + QS_HOTKEY = 128; + QS_INPUT = 7; + QS_KEY = 1; + QS_MOUSE = 6; + QS_MOUSEBUTTON = 4; + QS_MOUSEMOVE = 2; + QS_PAINT = 32; + QS_POSTMESSAGE = 8; + QS_SENDMESSAGE = 64; + QS_TIMER = 16; + { GetScrollInfo, SetScrollInfo } + SIF_ALL = 23; + SIF_PAGE = 2; + SIF_POS = 4; + SIF_RANGE = 1; + SIF_DISABLENOSCROLL = 8; + { GetStdHandle } + { was #define dname def_expr } + function STD_INPUT_HANDLE : DWORD; + + { was #define dname def_expr } + function STD_OUTPUT_HANDLE : DWORD; + + { was #define dname def_expr } + function STD_ERROR_HANDLE : DWORD; + + { was #define dname def_expr } +Const + INVALID_HANDLE_VALUE = HANDLE(-1); + + { GetStockObject } + + const + BLACK_BRUSH = 4; + DKGRAY_BRUSH = 3; + GRAY_BRUSH = 2; + HOLLOW_BRUSH = 5; + LTGRAY_BRUSH = 1; + NULL_BRUSH = 5; + WHITE_BRUSH = 0; + BLACK_PEN = 7; + NULL_PEN = 8; + WHITE_PEN = 6; + ANSI_FIXED_FONT = 11; + ANSI_VAR_FONT = 12; + DEVICE_DEFAULT_FONT = 14; + DEFAULT_GUI_FONT = 17; + OEM_FIXED_FONT = 10; + SYSTEM_FONT = 13; + SYSTEM_FIXED_FONT = 16; + DEFAULT_PALETTE = 15; + { GetStringTypeA } + CT_CTYPE1 = 1; + CT_CTYPE2 = 2; + CT_CTYPE3 = 4; + C1_UPPER = 1; + C1_LOWER = 2; + C1_DIGIT = 4; + C1_SPACE = 8; + C1_PUNCT = 16; + C1_CNTRL = 32; + C1_BLANK = 64; + C1_XDIGIT = 128; + C1_ALPHA = 256; + C2_LEFTTORIGHT = 1; + C2_RIGHTTOLEFT = 2; + C2_EUROPENUMBER = 3; + C2_EUROPESEPARATOR = 4; + C2_EUROPETERMINATOR = 5; + C2_ARABICNUMBER = 6; + C2_COMMONSEPARATOR = 7; + C2_BLOCKSEPARATOR = 8; + C2_SEGMENTSEPARATOR = 9; + C2_WHITESPACE = 10; + C2_OTHERNEUTRAL = 11; + C2_NOTAPPLICABLE = 0; + C3_NONSPACING = 1; + C3_DIACRITIC = 2; + C3_VOWELMARK = 4; + C3_SYMBOL = 8; + C3_KATAKANA = 16; + C3_HIRAGANA = 32; + C3_HALFWIDTH = 64; + C3_FULLWIDTH = 128; + C3_IDEOGRAPH = 256; + C3_KASHIDA = 512; + C3_ALPHA = 32768; + C3_NOTAPPLICABLE = 0; + { GetSysColor } + COLOR_3DDKSHADOW = 21; + COLOR_3DFACE = 15; + COLOR_3DHILIGHT = 20; + COLOR_3DLIGHT = 22; + COLOR_BTNHILIGHT = 20; + COLOR_3DSHADOW = 16; + COLOR_ACTIVEBORDER = 10; + COLOR_ACTIVECAPTION = 2; + COLOR_APPWORKSPACE = 12; + COLOR_BACKGROUND = 1; + COLOR_DESKTOP = 1; + COLOR_BTNFACE = 15; + COLOR_BTNHIGHLIGHT = 20; + COLOR_BTNSHADOW = 16; + COLOR_BTNTEXT = 18; + COLOR_CAPTIONTEXT = 9; + COLOR_GRAYTEXT = 17; + COLOR_HIGHLIGHT = 13; + COLOR_HIGHLIGHTTEXT = 14; + COLOR_INACTIVEBORDER = 11; + COLOR_INACTIVECAPTION = 3; + COLOR_INACTIVECAPTIONTEXT = 19; + COLOR_INFOBK = 24; + COLOR_INFOTEXT = 23; + COLOR_MENU = 4; + COLOR_MENUTEXT = 7; + COLOR_SCROLLBAR = 0; + COLOR_WINDOW = 5; + COLOR_WINDOWFRAME = 6; + COLOR_WINDOWTEXT = 8; + { GetSystemMetrics } + SM_CYMIN = 29; + SM_CXMIN = 28; + SM_ARRANGE = 56; + SM_CLEANBOOT = 67; + { The right value for SM_CEMETRICS for NT 3.5 is 75. For Windows 95 + and NT 4.0, it is 76. The meaning is undocumented, anyhow. } + SM_CMETRICS = 76; + SM_CMOUSEBUTTONS = 43; + SM_CXBORDER = 5; + SM_CYBORDER = 6; + SM_CXCURSOR = 13; + SM_CYCURSOR = 14; + SM_CXDLGFRAME = 7; + SM_CYDLGFRAME = 8; + SM_CXDOUBLECLK = 36; + SM_CYDOUBLECLK = 37; + SM_CXDRAG = 68; + SM_CYDRAG = 69; + SM_CXEDGE = 45; + SM_CYEDGE = 46; + SM_CXFIXEDFRAME = 7; + SM_CYFIXEDFRAME = 8; + SM_CXFRAME = 32; + SM_CYFRAME = 33; + SM_CXFULLSCREEN = 16; + SM_CYFULLSCREEN = 17; + SM_CXHSCROLL = 21; + SM_CYHSCROLL = 3; + SM_CXHTHUMB = 10; + SM_CXICON = 11; + SM_CYICON = 12; + SM_CXICONSPACING = 38; + SM_CYICONSPACING = 39; + SM_CXMAXIMIZED = 61; + SM_CYMAXIMIZED = 62; + SM_CXMAXTRACK = 59; + SM_CYMAXTRACK = 60; + SM_CXMENUCHECK = 71; + SM_CYMENUCHECK = 72; + SM_CXMENUSIZE = 54; + SM_CYMENUSIZE = 55; + SM_CXMINIMIZED = 57; + SM_CYMINIMIZED = 58; + SM_CXMINSPACING = 47; + SM_CYMINSPACING = 48; + SM_CXMINTRACK = 34; + SM_CYMINTRACK = 35; + SM_CXSCREEN = 0; + SM_CYSCREEN = 1; + SM_CXSIZE = 30; + SM_CYSIZE = 31; + SM_CXSIZEFRAME = 32; + SM_CYSIZEFRAME = 33; + SM_CXSMICON = 49; + SM_CYSMICON = 50; + SM_CXSMSIZE = 52; + SM_CYSMSIZE = 53; + SM_CXVSCROLL = 2; + {SM_CYHSCROLL = 3;already above } + {SM_CXHSCROLL = 21;already above } + SM_CYVSCROLL = 20; + SM_CYVTHUMB = 9; + SM_CYCAPTION = 4; + SM_CYKANJIWINDOW = 18; + SM_CYMENU = 15; + SM_CYSMCAPTION = 51; + SM_DBCSENABLED = 42; + SM_DEBUG = 22; + SM_MENUDROPALIGNMENT = 40; + SM_MIDEASTENABLED = 74; + SM_MOUSEPRESENT = 19; + SM_MOUSEWHEELPRESENT = 75; + SM_NETWORK = 63; + SM_PENWINDOWS = 41; + SM_SECURE = 44; + SM_SHOWSOUNDS = 70; + SM_SLOWMACHINE = 73; + SM_SWAPBUTTON = 23; + ARW_BOTTOMLEFT = 0; + ARW_BOTTOMRIGHT = $1; + ARW_HIDE = $8; + ARW_TOPLEFT = $2; + ARW_TOPRIGHT = $3; + ARW_DOWN = $4; + ARW_LEFT = 0; + ARW_RIGHT = 0; + ARW_UP = $4; + { GetSystemPaletteUse } + SYSPAL_NOSTATIC = 2; + SYSPAL_STATIC = 1; + SYSPAL_ERROR = 0; + { GetTapeParameters, SetTapeParameters } + GET_TAPE_MEDIA_INFORMATION = 0; + GET_TAPE_DRIVE_INFORMATION = 1; + SET_TAPE_MEDIA_INFORMATION = 0; + SET_TAPE_DRIVE_INFORMATION = 1; + { GetTapePosition } + TAPE_ABSOLUTE_POSITION = 0; + TAPE_LOGICAL_POSITION = $1; + { GetTextAlign } + TA_BASELINE = 24; + TA_BOTTOM = 8; + TA_TOP = 0; + TA_CENTER = 6; + TA_LEFT = 0; + TA_RIGHT = 2; + TA_RTLREADING = 256; + TA_NOUPDATECP = 0; + TA_UPDATECP = 1; + VTA_BASELINE = 24; + VTA_CENTER = 6; + { GetThreadPriority } + THREAD_PRIORITY_ABOVE_NORMAL = 1; + THREAD_PRIORITY_BELOW_NORMAL = -(1); + THREAD_PRIORITY_HIGHEST = 2; + THREAD_PRIORITY_IDLE = -(15); + THREAD_PRIORITY_LOWEST = -(2); + THREAD_PRIORITY_NORMAL = 0; + THREAD_PRIORITY_TIME_CRITICAL = 15; + THREAD_PRIORITY_ERROR_RETURN = 2147483647; + TLS_MINIMUM_AVAILABLE = 64; + { GetTimeFormat } + TIME_NOMINUTESORSECONDS = 1; + TIME_NOSECONDS = 2; + TIME_NOTIMEMARKER = 4; + TIME_FORCE24HOURFORMAT = 8; + { GetTimeZoneInformation } + { was #define dname def_expr } + + + const + TIME_ZONE_ID_INVALID = DWORD(-1); + TIME_ZONE_ID_UNKNOWN = 0; + TIME_ZONE_ID_STANDARD = 1; + TIME_ZONE_ID_DAYLIGHT = 2; + { GetUserObjectInformation } + UOI_FLAGS = 1; + UOI_NAME = 2; + UOI_TYPE = 3; + { GetVolumeInformation } + FS_CASE_IS_PRESERVED = 2; + FS_CASE_SENSITIVE = 1; + FS_UNICODE_STORED_ON_DISK = 4; + FS_PERSISTENT_ACLS = 8; + FS_FILE_COMPRESSION = 16; + FS_VOL_IS_COMPRESSED = 32768; + { GetWindowLong } + GWL_EXSTYLE = -(20); + GWL_STYLE = -(16); + GWL_WNDPROC = -(4); + GWL_HINSTANCE = -(6); + GWL_HWNDPARENT = -(8); + GWL_ID = -(12); + GWL_USERDATA = -(21); + DWL_DLGPROC = 4; + DWL_MSGRESULT = 0; + DWL_USER = 8; + { GlobalAlloc, GlobalFlags } + GMEM_FIXED = 0; + GMEM_MOVEABLE = 2; + GPTR = 64; + GHND = 66; + GMEM_DDESHARE = 8192; + GMEM_DISCARDABLE = 256; + GMEM_LOWER = 4096; + GMEM_NOCOMPACT = 16; + GMEM_NODISCARD = 32; + GMEM_NOT_BANKED = 4096; + GMEM_NOTIFY = 16384; + GMEM_SHARE = 8192; + GMEM_ZEROINIT = 64; + GMEM_DISCARDED = 16384; + GMEM_INVALID_HANDLE = 32768; + GMEM_LOCKCOUNT = 255; + { HeapAlloc, HeapReAlloc } + HEAP_GENERATE_EXCEPTIONS = 4; + HEAP_NO_SERIALIZE = 1; + HEAP_ZERO_MEMORY = 8; + STATUS_NO_MEMORY = $c0000017; + STATUS_ACCESS_VIOLATION = $c0000005; + HEAP_REALLOC_IN_PLACE_ONLY = 16; + { ImageList_Create } + ILC_COLOR = 0; + ILC_COLOR4 = 4; + ILC_COLOR8 = 8; + ILC_COLOR16 = 16; + ILC_COLOR24 = 24; + ILC_COLOR32 = 32; + ILC_COLORDDB = 254; + ILC_MASK = 1; + ILC_PALETTE = 2048; + { ImageList_Draw, ImageList_DrawEx } + ILD_BLEND25 = 2; + ILD_BLEND50 = 4; + ILD_SELECTED = 4; + ILD_BLEND = 4; + ILD_FOCUS = 2; + ILD_MASK = 16; + ILD_NORMAL = 0; + ILD_TRANSPARENT = 1; + CLR_NONE = $ffffffff; + CLR_DEFAULT = $ff000000; + CLR_INVALID = $FFFFFFFF; + { ImageList_LoadImage } + {LR_DEFAULTCOLOR = 0;already above } + LR_LOADFROMFILE = 16; + LR_LOADMAP3DCOLORS = 4096; + LR_LOADTRANSPARENT = 32; + {LR_MONOCHROME = 1;already above } + { ImmConfigureIME } + IME_CONFIG_GENERAL = 1; + IME_CONFIG_REGISTERWORD = 2; + IME_CONFIG_SELECTDICTIONARY = 3; + { ImmGetConversionList } + GCL_CONVERSION = 1; + GCL_REVERSECONVERSION = 2; + GCL_REVERSE_LENGTH = 3; + { ImmGetGuideLine } + GGL_LEVEL = 1; + GGL_INDEX = 2; + GGL_STRING = 3; + GGL_PRIVATE = 4; + GL_LEVEL_ERROR = 2; + GL_LEVEL_FATAL = 1; + GL_LEVEL_INFORMATION = 4; + GL_LEVEL_NOGUIDELINE = 0; + GL_LEVEL_WARNING = 3; + GL_ID_CANNOTSAVE = 17; + GL_ID_NOCONVERT = 32; + GL_ID_NODICTIONARY = 16; + GL_ID_NOMODULE = 1; + GL_ID_READINGCONFLICT = 35; + GL_ID_TOOMANYSTROKE = 34; + GL_ID_TYPINGERROR = 33; + GL_ID_UNKNOWN = 0; + GL_ID_INPUTREADING = 36; + GL_ID_INPUTRADICAL = 37; + GL_ID_INPUTCODE = 38; + GL_ID_CHOOSECANDIDATE = 40; + GL_ID_REVERSECONVERSION = 41; + { ImmGetProperty } + IGP_PROPERTY = 4; + IGP_CONVERSION = 8; + IGP_SENTENCE = 12; + IGP_UI = 16; + IGP_SETCOMPSTR = 20; + IGP_SELECT = 24; + IME_PROP_AT_CARET = 65536; + IME_PROP_SPECIAL_UI = 131072; + IME_PROP_CANDLIST_START_FROM_1 = 262144; + IME_PROP_UNICODE = 524288; + UI_CAP_2700 = 1; + UI_CAP_ROT90 = 2; + UI_CAP_ROTANY = 4; + SCS_CAP_COMPSTR = 1; + SCS_CAP_MAKEREAD = 2; + SELECT_CAP_CONVERSION = 1; + SELECT_CAP_SENTENCE = 2; + { ImmNotifyIME } + NI_CHANGECANDIDATELIST = 19; + NI_CLOSECANDIDATE = 17; + NI_COMPOSITIONSTR = 21; + NI_OPENCANDIDATE = 16; + NI_SELECTCANDIDATESTR = 18; + NI_SETCANDIDATE_PAGESIZE = 23; + NI_SETCANDIDATE_PAGESTART = 22; + CPS_CANCEL = 4; + CPS_COMPLETE = 1; + CPS_CONVERT = 2; + CPS_REVERT = 3; + { ImmSetCompositionString } + SCS_SETSTR = 9; + SCS_CHANGEATTR = 18; + SCS_CHANGECLAUSE = 36; + { ImmUnregisterWord } + IME_REGWORD_STYLE_EUDC = 1; + IME_REGWORD_STYLE_USER_FIRST = $80000000; + IME_REGWORD_STYLE_USER_LAST = -(1); + { InitializeSecurityDescriptor } + SECURITY_DESCRIPTOR_REVISION = 1; + { IsTextUnicode } + IS_TEXT_UNICODE_ASCII16 = 1; + IS_TEXT_UNICODE_REVERSE_ASCII16 = 16; + IS_TEXT_UNICODE_STATISTICS = 2; + IS_TEXT_UNICODE_REVERSE_STATISTICS = 32; + IS_TEXT_UNICODE_CONTROLS = 4; + IS_TEXT_UNICODE_REVERSE_CONTROLS = 64; + IS_TEXT_UNICODE_SIGNATURE = 8; + IS_TEXT_UNICODE_REVERSE_SIGNATURE = 128; + IS_TEXT_UNICODE_ILLEGAL_CHARS = 256; + IS_TEXT_UNICODE_ODD_LENGTH = 512; + IS_TEXT_UNICODE_NULL_BYTES = 4096; + IS_TEXT_UNICODE_UNICODE_MASK = 15; + IS_TEXT_UNICODE_REVERSE_MASK = 240; + IS_TEXT_UNICODE_NOT_UNICODE_MASK = 3840; + IS_TEXT_UNICODE_NOT_ASCII_MASK = 61440; + { JournalPlaybackProc, KeyboardProc } + HC_GETNEXT = 1; + HC_SKIP = 2; + HC_SYSMODALOFF = 5; + HC_SYSMODALON = 4; + HC_NOREMOVE = 3; + { keybd_event } + KEYEVENTF_EXTENDEDKEY = 1; + KEYEVENTF_KEYUP = 2; + { LoadBitmap } + OBM_BTNCORNERS = 32758; + OBM_BTSIZE = 32761; + OBM_CHECK = 32760; + OBM_CHECKBOXES = 32759; + OBM_CLOSE = 32754; + OBM_COMBO = 32738; + OBM_DNARROW = 32752; + OBM_DNARROWD = 32742; + OBM_DNARROWI = 32736; + OBM_LFARROW = 32750; + OBM_LFARROWI = 32734; + OBM_LFARROWD = 32740; + OBM_MNARROW = 32739; + OBM_OLD_CLOSE = 32767; + OBM_OLD_DNARROW = 32764; + OBM_OLD_LFARROW = 32762; + OBM_OLD_REDUCE = 32757; + OBM_OLD_RESTORE = 32755; + OBM_OLD_RGARROW = 32763; + OBM_OLD_UPARROW = 32765; + OBM_OLD_ZOOM = 32756; + OBM_REDUCE = 32749; + OBM_REDUCED = 32746; + OBM_RESTORE = 32747; + OBM_RESTORED = 32744; + OBM_RGARROW = 32751; + OBM_RGARROWD = 32741; + OBM_RGARROWI = 32735; + OBM_SIZE = 32766; + OBM_UPARROW = 32753; + OBM_UPARROWD = 32743; + OBM_UPARROWI = 32737; + OBM_ZOOM = 32748; + OBM_ZOOMD = 32745; + { LoadLibraryEx } + DONT_RESOLVE_DLL_REFERENCES = 1; + LOAD_LIBRARY_AS_DATAFILE = 2; + LOAD_WITH_ALTERED_SEARCH_PATH = 8; + { LocalAlloc, LocalFlags } + LPTR = 64; + LHND = 66; + NONZEROLHND = 2; + NONZEROLPTR = 0; + LMEM_NONZEROLHND = 2; + LMEM_NONZEROLPTR = 0; + LMEM_FIXED = 0; + LMEM_MOVEABLE = 2; + LMEM_NOCOMPACT = 16; + LMEM_NODISCARD = 32; + LMEM_ZEROINIT = 64; + LMEM_MODIFY = 128; + LMEM_LOCKCOUNT = 255; + LMEM_DISCARDABLE = 3840; + LMEM_DISCARDED = 16384; + LMEM_INVALID_HANDLE = 32768; + { LockFileEx } + LOCKFILE_FAIL_IMMEDIATELY = 1; + LOCKFILE_EXCLUSIVE_LOCK = 2; + { LogonUser } + { LZCopy, LZInit, LZRead } + { MessageBeep, MessageBox } + MB_USERICON = $80; + MB_ICONASTERISK = $40; + MB_ICONEXCLAMATION = $30; + MB_ICONWARNING = $30; + MB_ICONERROR = $10; + MB_ICONHAND = $10; + MB_ICONQUESTION = $20; + MB_OK = 0; + MB_ABORTRETRYIGNORE = $2; + MB_APPLMODAL = 0; + MB_DEFAULT_DESKTOP_ONLY = $20000; + MB_HELP = $4000; + MB_RIGHT = $80000; + MB_RTLREADING = $100000; + MB_TOPMOST = $40000; + MB_DEFBUTTON1 = 0; + MB_DEFBUTTON2 = $100; + MB_DEFBUTTON3 = $200; + MB_DEFBUTTON4 = $300; + MB_ICONINFORMATION = $40; + MB_ICONSTOP = $10; + MB_OKCANCEL = $1; + MB_RETRYCANCEL = $5; + MB_SERVICE_NOTIFICATION = $40000; + MB_SETFOREGROUND = $10000; + MB_SYSTEMMODAL = $1000; + MB_TASKMODAL = $2000; + MB_YESNO = $4; + MB_YESNOCANCEL = $3; + IDABORT = 3; + IDCANCEL = 2; + IDCLOSE = 8; + IDHELP = 9; + IDIGNORE = 5; + IDNO = 7; + IDOK = 1; + IDRETRY = 4; + IDYES = 6; + { MessageProc } + MSGF_DIALOGBOX = 0; + MSGF_MENU = 2; + MSGF_NEXTWINDOW = 6; + MSGF_SCROLLBAR = 5; + MSGF_MAINLOOP = 8; + MSGF_USER = 4096; + { ModifyWorldTransform } + MWT_IDENTITY = 1; + MWT_LEFTMULTIPLY = 2; + MWT_RIGHTMULTIPLY = 3; + { mouse_event } + MOUSEEVENTF_ABSOLUTE = 32768; + MOUSEEVENTF_MOVE = 1; + MOUSEEVENTF_LEFTDOWN = 2; + MOUSEEVENTF_LEFTUP = 4; + MOUSEEVENTF_RIGHTDOWN = 8; + MOUSEEVENTF_RIGHTUP = 16; + MOUSEEVENTF_MIDDLEDOWN = 32; + MOUSEEVENTF_MIDDLEUP = 64; + { MoveFileEx } + MOVEFILE_REPLACE_EXISTING = 1; + MOVEFILE_COPY_ALLOWED = 2; + MOVEFILE_DELAY_UNTIL_REBOOT = 4; + { MsgWaitForMultipleObjects, WaitForMultipleObjectsEx } + WAIT_OBJECT_0 = 0; + WAIT_ABANDONED_0 = $80; + WAIT_TIMEOUT = $102; + WAIT_IO_COMPLETION = $c0; + WAIT_ABANDONED = $80; + WAIT_FAILED = $ffffffff; + MAXIMUM_WAIT_OBJECTS = $40; //winnt + MAXIMUM_SUSPEND_COUNT = MAXCHAR; //~winnt + { MultiByteToWideChar } + MB_PRECOMPOSED = 1; + MB_COMPOSITE = 2; + MB_ERR_INVALID_CHARS = 8; + MB_USEGLYPHCHARS = 4; + { NDdeSetTrustedShare } + { NetAccessCheck } + { NetServerEnum } + { NetServiceControl } + { NetUserEnum } + { OpenProcessToken } + TOKEN_ADJUST_DEFAULT = 128; + TOKEN_ADJUST_GROUPS = 64; + TOKEN_ADJUST_PRIVILEGES = 32; + TOKEN_ALL_ACCESS = $f00ff; + TOKEN_ASSIGN_PRIMARY = 1; + TOKEN_DUPLICATE = 2; + TOKEN_EXECUTE = $20000; + TOKEN_IMPERSONATE = 4; + TOKEN_QUERY = 8; + TOKEN_QUERY_SOURCE = 16; + TOKEN_READ = $20008; + TOKEN_WRITE = $200e0; + { OpenSCManager } + SC_MANAGER_ALL_ACCESS = $f003f; + SC_MANAGER_CONNECT = 1; + SC_MANAGER_CREATE_SERVICE = 2; + SC_MANAGER_ENUMERATE_SERVICE = 4; + SC_MANAGER_LOCK = 8; + SC_MANAGER_QUERY_LOCK_STATUS = 16; + SC_MANAGER_MODIFY_BOOT_CONFIG = 32; + { PostMessage } + { was #define dname def_expr } + function HWND_BROADCAST : HWND; + + { PrepareTape } + + const + TAPE_FORMAT = $5; + TAPE_LOAD = 0; + TAPE_LOCK = $3; + TAPE_TENSION = $2; + TAPE_UNLOAD = $1; + TAPE_UNLOCK = $4; + { PropertySheet } + IS_PSREBOOTSYSTEM = 3; + IS_PSRESTARTWINDOWS = 2; + { PropSheetPageProc } + PSPCB_CREATE = 2; + PSPCB_RELEASE = 1; + { PurgeComm } + PURGE_TXABORT = 1; + PURGE_RXABORT = 2; + PURGE_TXCLEAR = 4; + PURGE_RXCLEAR = 8; + { QueryServiceObjectSecurity } + OWNER_SECURITY_INFORMATION = $1; + GROUP_SECURITY_INFORMATION = $2; + DACL_SECURITY_INFORMATION = $4; + SACL_SECURITY_INFORMATION = $8; + { ReadEventLog, ReportEvent } + EVENTLOG_FORWARDS_READ = 4; + EVENTLOG_BACKWARDS_READ = 8; + EVENTLOG_SEEK_READ = 2; + EVENTLOG_SEQUENTIAL_READ = 1; + EVENTLOG_ERROR_TYPE = 1; + EVENTLOG_WARNING_TYPE = 2; + EVENTLOG_INFORMATION_TYPE = 4; + EVENTLOG_AUDIT_SUCCESS = 8; + EVENTLOG_AUDIT_FAILURE = 16; + { RedrawWindow } + RDW_ERASE = 4; + RDW_FRAME = 1024; + RDW_INTERNALPAINT = 2; + RDW_INVALIDATE = 1; + RDW_NOERASE = 32; + RDW_NOFRAME = 2048; + RDW_NOINTERNALPAINT = 16; + RDW_VALIDATE = 8; + RDW_ERASENOW = 512; + RDW_UPDATENOW = 256; + RDW_ALLCHILDREN = 128; + RDW_NOCHILDREN = 64; + { RegCreateKey } + { was #define dname def_expr } + function HKEY_CLASSES_ROOT : HKEY; + + { was #define dname def_expr } + function HKEY_CURRENT_USER : HKEY; + + { was #define dname def_expr } + function HKEY_LOCAL_MACHINE : HKEY; + + { was #define dname def_expr } + function HKEY_USERS : HKEY; + + { was #define dname def_expr } + function HKEY_PERFORMANCE_DATA : HKEY; + + { was #define dname def_expr } + function HKEY_CURRENT_CONFIG : HKEY; + + { was #define dname def_expr } + function HKEY_DYN_DATA : HKEY; + + { RegCreateKeyEx } + + const + REG_OPTION_VOLATILE = $1; + REG_OPTION_NON_VOLATILE = 0; + REG_CREATED_NEW_KEY = $1; + REG_OPENED_EXISTING_KEY = $2; + { RegEnumValue } + REG_BINARY = 3; + REG_DWORD = 4; + REG_DWORD_LITTLE_ENDIAN = 4; + REG_DWORD_BIG_ENDIAN = 5; + REG_EXPAND_SZ = 2; + REG_FULL_RESOURCE_DESCRIPTOR = 9; + REG_LINK = 6; + REG_MULTI_SZ = 7; + REG_NONE = 0; + REG_RESOURCE_LIST = 8; + REG_RESOURCE_REQUIREMENTS_LIST = 10; + REG_SZ = 1; + { RegisterHotKey } + MOD_ALT = 1; + MOD_CONTROL = 2; + MOD_SHIFT = 4; + MOD_WIN = 8; + IDHOT_SNAPDESKTOP = -(2); + IDHOT_SNAPWINDOW = -(1); + { RegNotifyChangeKeyValue } + REG_NOTIFY_CHANGE_NAME = $1; + REG_NOTIFY_CHANGE_ATTRIBUTES = $2; + REG_NOTIFY_CHANGE_LAST_SET = $4; + REG_NOTIFY_CHANGE_SECURITY = $8; + { ScrollWindowEx } + SW_ERASE = 4; + SW_INVALIDATE = 2; + SW_SCROLLCHILDREN = 1; + { SendMessageTimeout } + SMTO_ABORTIFHUNG = 2; + SMTO_BLOCK = 1; + SMTO_NORMAL = 0; + { SetBkMode } + OPAQUE = 2; + TRANSPARENT = 1; + { SetDebugErrorLevel } + SLE_ERROR = 1; + SLE_MINORERROR = 2; + SLE_WARNING = 3; + { SetErrorMode } + SEM_FAILCRITICALERRORS = 1; + SEM_NOALIGNMENTFAULTEXCEPT = 4; + SEM_NOGPFAULTERRORBOX = 2; + SEM_NOOPENFILEERRORBOX = 32768; + { SetICMMode } + ICM_ON = 2; + ICM_OFF = 1; + ICM_QUERY = 3; + { SetJob } + { Locale Information } + LOCALE_ILANGUAGE = 1; + LOCALE_SLANGUAGE = 2; + LOCALE_SENGLANGUAGE = 4097; + LOCALE_SABBREVLANGNAME = 3; + LOCALE_SNATIVELANGNAME = 4; + LOCALE_ICOUNTRY = 5; + LOCALE_SCOUNTRY = 6; + LOCALE_SENGCOUNTRY = 4098; + LOCALE_SABBREVCTRYNAME = 7; + LOCALE_SNATIVECTRYNAME = 8; + LOCALE_IDEFAULTLANGUAGE = 9; + LOCALE_IDEFAULTCOUNTRY = 10; + LOCALE_IDEFAULTANSICODEPAGE = 4100; + LOCALE_IDEFAULTCODEPAGE = 11; + LOCALE_SLIST = 12; + LOCALE_IMEASURE = 13; + LOCALE_SDECIMAL = 14; + LOCALE_STHOUSAND = 15; + LOCALE_SGROUPING = 16; + LOCALE_IDIGITS = 17; + LOCALE_ILZERO = 18; + LOCALE_INEGNUMBER = 4112; + LOCALE_SCURRENCY = 20; + LOCALE_SMONDECIMALSEP = 22; + LOCALE_SMONTHOUSANDSEP = 23; + LOCALE_SMONGROUPING = 24; + LOCALE_ICURRDIGITS = 25; + LOCALE_ICURRENCY = 27; + LOCALE_INEGCURR = 28; + LOCALE_SDATE = 29; + LOCALE_STIME = 30; + LOCALE_STIMEFORMAT = 4099; + LOCALE_SSHORTDATE = 31; + LOCALE_SLONGDATE = 32; + LOCALE_IDATE = 33; + LOCALE_ILDATE = 34; + LOCALE_ITIME = 35; + LOCALE_ITLZERO = 37; + LOCALE_IDAYLZERO = 38; + LOCALE_IMONLZERO = 39; + LOCALE_S1159 = 40; + LOCALE_S2359 = 41; + LOCALE_ICALENDARTYPE = 4105; + LOCALE_IOPTIONALCALENDAR = 4107; + LOCALE_IFIRSTDAYOFWEEK = 4108; + LOCALE_IFIRSTWEEKOFYEAR = 4109; + LOCALE_SDAYNAME1 = 42; + LOCALE_SDAYNAME2 = 43; + LOCALE_SDAYNAME3 = 44; + LOCALE_SDAYNAME4 = 45; + LOCALE_SDAYNAME5 = 46; + LOCALE_SDAYNAME6 = 47; + LOCALE_SDAYNAME7 = 48; + LOCALE_SABBREVDAYNAME1 = 49; + LOCALE_SABBREVDAYNAME2 = 50; + LOCALE_SABBREVDAYNAME3 = 51; + LOCALE_SABBREVDAYNAME4 = 52; + LOCALE_SABBREVDAYNAME5 = 53; + LOCALE_SABBREVDAYNAME6 = 54; + LOCALE_SABBREVDAYNAME7 = 55; + LOCALE_SMONTHNAME1 = 56; + LOCALE_SMONTHNAME2 = 57; + LOCALE_SMONTHNAME3 = 58; + LOCALE_SMONTHNAME4 = 59; + LOCALE_SMONTHNAME5 = 60; + LOCALE_SMONTHNAME6 = 61; + LOCALE_SMONTHNAME7 = 62; + LOCALE_SMONTHNAME8 = 63; + LOCALE_SMONTHNAME9 = 64; + LOCALE_SMONTHNAME10 = 65; + LOCALE_SMONTHNAME11 = 66; + LOCALE_SMONTHNAME12 = 67; + LOCALE_SMONTHNAME13 = 4110; + LOCALE_SABBREVMONTHNAME1 = 68; + LOCALE_SABBREVMONTHNAME2 = 69; + LOCALE_SABBREVMONTHNAME3 = 70; + LOCALE_SABBREVMONTHNAME4 = 71; + LOCALE_SABBREVMONTHNAME5 = 72; + LOCALE_SABBREVMONTHNAME6 = 73; + LOCALE_SABBREVMONTHNAME7 = 74; + LOCALE_SABBREVMONTHNAME8 = 75; + LOCALE_SABBREVMONTHNAME9 = 76; + LOCALE_SABBREVMONTHNAME10 = 77; + LOCALE_SABBREVMONTHNAME11 = 78; + LOCALE_SABBREVMONTHNAME12 = 79; + LOCALE_SABBREVMONTHNAME13 = 4111; + LOCALE_SPOSITIVESIGN = 80; + LOCALE_SNEGATIVESIGN = 81; + LOCALE_IPOSSIGNPOSN = 82; + LOCALE_INEGSIGNPOSN = 83; + LOCALE_IPOSSYMPRECEDES = 84; + LOCALE_IPOSSEPBYSPACE = 85; + LOCALE_INEGSYMPRECEDES = 86; + LOCALE_INEGSEPBYSPACE = 87; + LOCALE_NOUSEROVERRIDE = $80000000; + LOCALE_USE_CP_ACP = $40000000; // use the system ACP + LOCALE_RETURN_NUMBER = $20000000; // return number instead + { Calendar Type Information } + CAL_ICALINTVALUE = 1; + CAL_IYEAROFFSETRANGE = 3; + CAL_SABBREVDAYNAME1 = 14; + CAL_SABBREVDAYNAME2 = 15; + CAL_SABBREVDAYNAME3 = 16; + CAL_SABBREVDAYNAME4 = 17; + CAL_SABBREVDAYNAME5 = 18; + CAL_SABBREVDAYNAME6 = 19; + CAL_SABBREVDAYNAME7 = 20; + CAL_SABBREVMONTHNAME1 = 34; + CAL_SABBREVMONTHNAME2 = 35; + CAL_SABBREVMONTHNAME3 = 36; + CAL_SABBREVMONTHNAME4 = 37; + CAL_SABBREVMONTHNAME5 = 38; + CAL_SABBREVMONTHNAME6 = 39; + CAL_SABBREVMONTHNAME7 = 40; + CAL_SABBREVMONTHNAME8 = 41; + CAL_SABBREVMONTHNAME9 = 42; + CAL_SABBREVMONTHNAME10 = 43; + CAL_SABBREVMONTHNAME11 = 44; + CAL_SABBREVMONTHNAME12 = 45; + CAL_SABBREVMONTHNAME13 = 46; + CAL_SCALNAME = 2; + CAL_SDAYNAME1 = 7; + CAL_SDAYNAME2 = 8; + CAL_SDAYNAME3 = 9; + CAL_SDAYNAME4 = 10; + CAL_SDAYNAME5 = 11; + CAL_SDAYNAME6 = 12; + CAL_SDAYNAME7 = 13; + CAL_SERASTRING = 4; + CAL_SLONGDATE = 6; + CAL_SMONTHNAME1 = 21; + CAL_SMONTHNAME2 = 22; + CAL_SMONTHNAME3 = 23; + CAL_SMONTHNAME4 = 24; + CAL_SMONTHNAME5 = 25; + CAL_SMONTHNAME6 = 26; + CAL_SMONTHNAME7 = 27; + CAL_SMONTHNAME8 = 28; + CAL_SMONTHNAME9 = 29; + CAL_SMONTHNAME10 = 30; + CAL_SMONTHNAME11 = 31; + CAL_SMONTHNAME12 = 32; + CAL_SMONTHNAME13 = 33; + CAL_SSHORTDATE = 5; + { SetProcessWorkingSetSize } + PROCESS_SET_QUOTA = 256; + { SetPrinter } + { SetService } + { SetStretchBltMode } + BLACKONWHITE = 1; + COLORONCOLOR = 3; + HALFTONE = 4; + STRETCH_ANDSCANS = 1; + STRETCH_DELETESCANS = 3; + STRETCH_HALFTONE = 4; + STRETCH_ORSCANS = 2; + WHITEONBLACK = 2; + { SetSystemCursor } + OCR_NORMAL = 32512; + OCR_IBEAM = 32513; + OCR_WAIT = 32514; + OCR_CROSS = 32515; + OCR_UP = 32516; + OCR_SIZE = 32640; + OCR_ICON = 32641; + OCR_SIZENWSE = 32642; + OCR_SIZENESW = 32643; + OCR_SIZEWE = 32644; + OCR_SIZENS = 32645; + OCR_SIZEALL = 32646; + OCR_NO = 32648; + OCR_APPSTARTING = 32650; + { SetTapePosition } + TAPE_ABSOLUTE_BLOCK = $1; + TAPE_LOGICAL_BLOCK = $2; + TAPE_REWIND = 0; + TAPE_SPACE_END_OF_DATA = $4; + TAPE_SPACE_FILEMARKS = $6; + TAPE_SPACE_RELATIVE_BLOCKS = $5; + TAPE_SPACE_SEQUENTIAL_FMKS = $7; + TAPE_SPACE_SEQUENTIAL_SMKS = $9; + TAPE_SPACE_SETMARKS = $8; + { SetUnhandledExceptionFilter } + EXCEPTION_EXECUTE_HANDLER = 1; + EXCEPTION_CONTINUE_EXECUTION = -(1); + EXCEPTION_CONTINUE_SEARCH = 0; + { SetWindowPos, DeferWindowPos } + { was #define dname def_expr } + function HWND_BOTTOM : HWND; + + { was #define dname def_expr } + function HWND_NOTOPMOST : HWND; + + { was #define dname def_expr } + function HWND_TOP : HWND; + + { was #define dname def_expr } + function HWND_TOPMOST : HWND; + + + const + SWP_DRAWFRAME = 32; + SWP_FRAMECHANGED = 32; + SWP_HIDEWINDOW = 128; + SWP_NOACTIVATE = 16; + SWP_NOCOPYBITS = 256; + SWP_NOMOVE = 2; + SWP_NOSIZE = 1; + SWP_NOREDRAW = 8; + SWP_NOZORDER = 4; + SWP_SHOWWINDOW = 64; + SWP_NOOWNERZORDER = 512; + SWP_NOREPOSITION = 512; + SWP_NOSENDCHANGING = 1024; + { SHAddToRecentDocs } + { SHAppBarMessage } + { SHChangeNotify } + { ShellProc } + HSHELL_ACTIVATESHELLWINDOW = 3; + HSHELL_GETMINRECT = 5; + HSHELL_LANGUAGE = 8; + HSHELL_REDRAW = 6; + HSHELL_TASKMAN = 7; + HSHELL_WINDOWACTIVATED = 4; + HSHELL_WINDOWCREATED = 1; + HSHELL_WINDOWDESTROYED = 2; + { SHGetFileInfo } + { SHGetSpecialFolderLocation } + { ShowWindow } + SW_HIDE = 0; + SW_MAXIMIZE = 3; + SW_MINIMIZE = 6; + SW_NORMAL = 1; + SW_RESTORE = 9; + SW_SHOW = 5; + SW_SHOWDEFAULT = 10; + SW_SHOWMAXIMIZED = 3; + SW_SHOWMINIMIZED = 2; + SW_SHOWMINNOACTIVE = 7; + SW_SHOWNA = 8; + SW_SHOWNOACTIVATE = 4; + SW_SHOWNORMAL = 1; + WPF_RESTORETOMAXIMIZED = 2; + WPF_SETMINPOSITION = 1; + { SID } + //////////////////////////////////////////////////////////////////////// + // // + // Security Id (SID) // + // // + //////////////////////////////////////////////////////////////////////// + // + // + // Pictorially the structure of an SID is as follows: + // + // 1 1 1 1 1 1 + // 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 + // +---------------------------------------------------------------+ + // | SubAuthorityCount |Reserved1 (SBZ)| Revision | + // +---------------------------------------------------------------+ + // | IdentifierAuthority[0] | + // +---------------------------------------------------------------+ + // | IdentifierAuthority[1] | + // +---------------------------------------------------------------+ + // | IdentifierAuthority[2] | + // +---------------------------------------------------------------+ + // | | + // +- - - - - - - - SubAuthority[] - - - - - - - - -+ + // | | + // +---------------------------------------------------------------+ + // + // + SID_REVISION =1; // Current revision level + SID_MAX_SUB_AUTHORITIES = 15; + SID_RECOMMENDED_SUB_AUTHORITIES = 1; // Will change to around 6 + // in a future release. + + + { Sleep } + INFINITE = $FFFFFFFF; + { SystemParametersInfo } + SPI_GETACCESSTIMEOUT = 60; + SPI_GETANIMATION = 72; + SPI_GETBEEP = 1; + SPI_GETBORDER = 5; + SPI_GETDEFAULTINPUTLANG = 89; + SPI_GETDRAGFULLWINDOWS = 38; + SPI_GETFASTTASKSWITCH = 35; + SPI_GETFILTERKEYS = 50; + SPI_GETFONTSMOOTHING = 74; + SPI_GETGRIDGRANULARITY = 18; + SPI_GETHIGHCONTRAST = 66; + SPI_GETICONMETRICS = 45; + SPI_GETICONTITLELOGFONT = 31; + SPI_GETICONTITLEWRAP = 25; + SPI_GETKEYBOARDDELAY = 22; + SPI_GETKEYBOARDPREF = 68; + SPI_GETKEYBOARDSPEED = 10; + SPI_GETLOWPOWERACTIVE = 83; + SPI_GETLOWPOWERTIMEOUT = 79; + SPI_GETMENUDROPALIGNMENT = 27; + SPI_GETMINIMIZEDMETRICS = 43; + SPI_GETMOUSE = 3; + SPI_GETMOUSEKEYS = 54; + SPI_GETMOUSETRAILS = 94; + SPI_GETNONCLIENTMETRICS = 41; + SPI_GETPOWEROFFACTIVE = 84; + SPI_GETPOWEROFFTIMEOUT = 80; + SPI_GETSCREENREADER = 70; + SPI_GETSCREENSAVEACTIVE = 16; + SPI_GETSCREENSAVETIMEOUT = 14; + SPI_GETSERIALKEYS = 62; + SPI_GETSHOWSOUNDS = 56; + SPI_GETSOUNDSENTRY = 64; + SPI_GETSTICKYKEYS = 58; + SPI_GETTOGGLEKEYS = 52; + SPI_GETWINDOWSEXTENSION = 92; + SPI_GETWORKAREA = 48; + SPI_ICONHORIZONTALSPACING = 13; + SPI_ICONVERTICALSPACING = 24; + SPI_LANGDRIVER = 12; + SPI_SCREENSAVERRUNNING = 97; + SPI_SETACCESSTIMEOUT = 61; + SPI_SETANIMATION = 73; + SPI_SETBEEP = 2; + SPI_SETBORDER = 6; + SPI_SETDEFAULTINPUTLANG = 90; + SPI_SETDESKPATTERN = 21; + SPI_SETDESKWALLPAPER = 20; + SPI_SETDOUBLECLICKTIME = 32; + SPI_SETDOUBLECLKHEIGHT = 30; + SPI_SETDOUBLECLKWIDTH = 29; + SPI_SETDRAGFULLWINDOWS = 37; + SPI_SETDRAGHEIGHT = 77; + SPI_SETDRAGWIDTH = 76; + SPI_SETFASTTASKSWITCH = 36; + SPI_SETFILTERKEYS = 51; + SPI_SETFONTSMOOTHING = 75; + SPI_SETGRIDGRANULARITY = 19; + SPI_SETHANDHELD = 78; + SPI_SETHIGHCONTRAST = 67; + SPI_SETICONMETRICS = 46; + SPI_SETICONTITLELOGFONT = 34; + SPI_SETICONTITLEWRAP = 26; + SPI_SETKEYBOARDDELAY = 23; + SPI_SETKEYBOARDPREF = 69; + SPI_SETKEYBOARDSPEED = 11; + SPI_SETLANGTOGGLE = 91; + SPI_SETLOWPOWERACTIVE = 85; + SPI_SETLOWPOWERTIMEOUT = 81; + SPI_SETMENUDROPALIGNMENT = 28; + SPI_SETMINIMIZEDMETRICS = 44; + SPI_SETMOUSE = 4; + SPI_SETMOUSEBUTTONSWAP = 33; + SPI_SETMOUSEKEYS = 55; + SPI_SETMOUSETRAILS = 93; + SPI_SETNONCLIENTMETRICS = 42; + SPI_SETPENWINDOWS = 49; + SPI_SETPOWEROFFACTIVE = 86; + SPI_SETPOWEROFFTIMEOUT = 82; + SPI_SETSCREENREADER = 71; + SPI_SETSCREENSAVEACTIVE = 17; + SPI_SETSCREENSAVETIMEOUT = 15; + SPI_SETSERIALKEYS = 63; + SPI_SETSHOWSOUNDS = 57; + SPI_SETSOUNDSENTRY = 65; + SPI_SETSTICKYKEYS = 59; + SPI_SETTOGGLEKEYS = 53; + SPI_SETWORKAREA = 47; + SPIF_UPDATEINIFILE = 1; + SPIF_SENDWININICHANGE = 2; + SPIF_SENDCHANGE = 2; + { TrackPopupMenu, TrackPopMenuEx } + TPM_CENTERALIGN = $4; + TPM_LEFTALIGN = 0; + TPM_RIGHTALIGN = $8; + TPM_LEFTBUTTON = 0; + TPM_RIGHTBUTTON = $2; + TPM_HORIZONTAL = 0; + TPM_VERTICAL = $40; + { TranslateCharsetInfo } + TCI_SRCCHARSET = 1; + TCI_SRCCODEPAGE = 2; + TCI_SRCFONTSIG = 3; + { VerFindFile } + VFFF_ISSHAREDFILE = 1; + VFF_CURNEDEST = 1; + VFF_FILEINUSE = 2; + VFF_BUFFTOOSMALL = 4; + { VerInstallFile } + VIFF_FORCEINSTALL = 1; + VIFF_DONTDELETEOLD = 2; + VIF_TEMPFILE = $1; + VIF_MISMATCH = $2; + VIF_SRCOLD = $4; + VIF_DIFFLANG = $8; + VIF_DIFFCODEPG = $10; + VIF_DIFFTYPE = $20; + VIF_WRITEPROT = $40; + VIF_FILEINUSE = $80; + VIF_OUTOFSPACE = $100; + VIF_ACCESSVIOLATION = $200; + VIF_SHARINGVIOLATION = $400; + VIF_CANNOTCREATE = $800; + VIF_CANNOTDELETE = $1000; + VIF_CANNOTDELETECUR = $4000; + VIF_CANNOTRENAME = $2000; + VIF_OUTOFMEMORY = $8000; + VIF_CANNOTREADSRC = $10000; + VIF_CANNOTREADDST = $20000; + VIF_BUFFTOOSMALL = $40000; + { WideCharToMultiByte } + WC_COMPOSITECHECK = 512; + WC_DISCARDNS = 16; + WC_SEPCHARS = 32; + WC_DEFAULTCHAR = 64; + { WinHelp } + HELP_COMMAND = $102; + HELP_CONTENTS = $3; + HELP_CONTEXT = $1; + HELP_CONTEXTPOPUP = $8; + HELP_FORCEFILE = $9; + HELP_HELPONHELP = $4; + HELP_INDEX = $3; + HELP_KEY = $101; + HELP_MULTIKEY = $201; + HELP_PARTIALKEY = $105; + HELP_QUIT = $2; + HELP_SETCONTENTS = $5; + HELP_SETINDEX = $5; + HELP_CONTEXTMENU = $a; + HELP_FINDER = $b; + HELP_WM_HELP = $c; + HELP_TCARD = $8000; + HELP_TCARD_DATA = $10; + HELP_TCARD_OTHER_CALLER = $11; + { WNetAddConnectino2 } + CONNECT_UPDATE_PROFILE = 1; + { WNetConnectionDialog, WNetDisconnectDialog, WNetOpenEnum } + RESOURCETYPE_DISK = 1; + RESOURCETYPE_PRINT = 2; + RESOURCETYPE_ANY = 0; + RESOURCE_CONNECTED = 1; + RESOURCE_GLOBALNET = 2; + RESOURCE_REMEMBERED = 3; + RESOURCEUSAGE_CONNECTABLE = 1; + RESOURCEUSAGE_CONTAINER = 2; + { WNetGetResourceInformation, WNetGetResourceParent } + WN_BAD_NETNAME = $43; + WN_EXTENDED_ERROR = $4b8; + WN_MORE_DATA = $ea; + WN_NO_NETWORK = $4c6; + WN_SUCCESS = 0; + WN_ACCESS_DENIED = $5; + WN_BAD_PROVIDER = $4b4; + WN_NOT_AUTHENTICATED = $4dc; + { WNetGetUniversalName } + UNIVERSAL_NAME_INFO_LEVEL = 1; + REMOTE_NAME_INFO_LEVEL = 2; + { GetExitCodeThread } + STILL_ACTIVE = $103; + { COMMPROP structure } + SP_SERIALCOMM = $1; + BAUD_075 = $1; + BAUD_110 = $2; + BAUD_134_5 = $4; + BAUD_150 = $8; + BAUD_300 = $10; + BAUD_600 = $20; + BAUD_1200 = $40; + BAUD_1800 = $80; + BAUD_2400 = $100; + BAUD_4800 = $200; + BAUD_7200 = $400; + BAUD_9600 = $800; + BAUD_14400 = $1000; + BAUD_19200 = $2000; + BAUD_38400 = $4000; + BAUD_56K = $8000; + BAUD_57600 = $40000; + BAUD_115200 = $20000; + BAUD_128K = $10000; + BAUD_USER = $10000000; + PST_FAX = $21; + PST_LAT = $101; + PST_MODEM = $6; + PST_NETWORK_BRIDGE = $100; + PST_PARALLELPORT = $2; + PST_RS232 = $1; + PST_RS422 = $3; + PST_RS423 = $4; + PST_RS449 = $5; + PST_SCANNER = $22; + PST_TCPIP_TELNET = $102; + PST_UNSPECIFIED = 0; + PST_X25 = $103; + PCF_16BITMODE = $200; + PCF_DTRDSR = $1; + PCF_INTTIMEOUTS = $80; + PCF_PARITY_CHECK = $8; + PCF_RLSD = $4; + PCF_RTSCTS = $2; + PCF_SETXCHAR = $20; + PCF_SPECIALCHARS = $100; + PCF_TOTALTIMEOUTS = $40; + PCF_XONXOFF = $10; + SP_BAUD = $2; + SP_DATABITS = $4; + SP_HANDSHAKING = $10; + SP_PARITY = $1; + SP_PARITY_CHECK = $20; + SP_RLSD = $40; + SP_STOPBITS = $8; + DATABITS_5 = 1; + DATABITS_6 = 2; + DATABITS_7 = 4; + DATABITS_8 = 8; + DATABITS_16 = 16; + DATABITS_16X = 32; + STOPBITS_10 = 1; + STOPBITS_15 = 2; + STOPBITS_20 = 4; + PARITY_NONE = 256; + PARITY_ODD = 512; + PARITY_EVEN = 1024; + PARITY_MARK = 2048; + PARITY_SPACE = 4096; + COMMPROP_INITIALIZED = $e73cf52e; + { DCB structure } + CBR_110 = 110; + CBR_300 = 300; + CBR_600 = 600; + CBR_1200 = 1200; + CBR_2400 = 2400; + CBR_4800 = 4800; + CBR_9600 = 9600; + CBR_14400 = 14400; + CBR_19200 = 19200; + CBR_38400 = 38400; + CBR_56000 = 56000; + CBR_57600 = 57600; + CBR_115200 = 115200; + CBR_128000 = 128000; + CBR_256000 = 256000; + DTR_CONTROL_DISABLE = 0; + DTR_CONTROL_ENABLE = 1; + DTR_CONTROL_HANDSHAKE = 2; + RTS_CONTROL_DISABLE = 0; + RTS_CONTROL_ENABLE = 1; + RTS_CONTROL_HANDSHAKE = 2; + RTS_CONTROL_TOGGLE = 3; + EVENPARITY = 2; + MARKPARITY = 3; + NOPARITY = 0; + ODDPARITY = 1; + SPACEPARITY = 4; + ONESTOPBIT = 0; + ONE5STOPBITS = 1; + TWOSTOPBITS = 2; + { Debugging events } + CREATE_PROCESS_DEBUG_EVENT = 3; + CREATE_THREAD_DEBUG_EVENT = 2; + EXCEPTION_DEBUG_EVENT = 1; + EXIT_PROCESS_DEBUG_EVENT = 5; + EXIT_THREAD_DEBUG_EVENT = 4; + LOAD_DLL_DEBUG_EVENT = 6; + OUTPUT_DEBUG_STRING_EVENT = 8; + UNLOAD_DLL_DEBUG_EVENT = 7; + RIP_EVENT = 9; + { PROCESS_HEAP_ENTRY structure } + PROCESS_HEAP_REGION = 1; + PROCESS_HEAP_UNCOMMITTED_RANGE = 2; + PROCESS_HEAP_ENTRY_BUSY = 4; + PROCESS_HEAP_ENTRY_MOVEABLE = 16; + PROCESS_HEAP_ENTRY_DDESHARE = 32; + { Win32s } + HINSTANCE_ERROR = 32; + { WIN32_STREAM_ID structure } + BACKUP_DATA = 1; + BACKUP_EA_DATA = 2; + BACKUP_SECURITY_DATA = 3; + BACKUP_ALTERNATE_DATA = 4; + BACKUP_LINK = 5; + STREAM_MODIFIED_WHEN_READ = 1; + STREAM_CONTAINS_SECURITY = 2; + { STARTUPINFO structure } + STARTF_USESHOWWINDOW = 1; + STARTF_USEPOSITION = 4; + STARTF_USESIZE = 2; + STARTF_USECOUNTCHARS = 8; + STARTF_USEFILLATTRIBUTE = 16; + STARTF_RUNFULLSCREEN = 32; + STARTF_FORCEONFEEDBACK = 64; + STARTF_FORCEOFFFEEDBACK = 128; + STARTF_USESTDHANDLES = 256; + STARTF_USEHOTKEY = 512; + { OSVERSIONINFO structure } + VER_PLATFORM_WIN32s = 0; + VER_PLATFORM_WIN32_WINDOWS = 1; + VER_PLATFORM_WIN32_NT = 2; + { More versions } + VER_SERVER_NT = $80000000; //winnt + VER_WORKSTATION_NT = $40000000; //winnt + VER_SUITE_SMALLBUSINESS = $00000001; //winnt + VER_SUITE_ENTERPRISE = $00000002; //winnt + VER_SUITE_BACKOFFICE = $00000004; //winnt + VER_SUITE_COMMUNICATIONS = $00000008; //winnt + VER_SUITE_TERMINAL = $00000010; //winnt + VER_SUITE_SMALLBUSINESS_RESTRICTED = $00000020; //winnt + VER_SUITE_EMBEDDEDNT = $00000040; + VER_SUITE_DATACENTER = $00000080; + VER_SUITE_SINGLEUSERTS = $00000100; + VER_SUITE_PERSONAL = $00000200; + VER_SUITE_BLADE = $00000400; + VER_SUITE_EMBEDDED_RESTRICTED = $00000800; + { PROPSHEETPAGE structure } + MAXPROPPAGES = 100; + PSP_DEFAULT = 0; + PSP_DLGINDIRECT = 1; + PSP_HASHELP = 32; + PSP_USECALLBACK = 128; + PSP_USEHICON = 2; + PSP_USEICONID = 4; + PSP_USEREFPARENT = 64; + PSP_USETITLE = 8; + PSP_RTLREADING = 16; + { PROPSHEETHEADER structure } + PSH_DEFAULT = 0; + PSH_HASHELP = 512; + PSH_MODELESS = 1024; + PSH_NOAPPLYNOW = 128; + PSH_PROPSHEETPAGE = 8; + PSH_PROPTITLE = 1; + PSH_USECALLBACK = 256; + PSH_USEHICON = 2; + PSH_USEICONID = 4; + PSH_USEPSTARTPAGE = 64; + PSH_WIZARD = 32; + PSH_RTLREADING = 2048; + PSCB_INITIALIZED = 1; + PSCB_PRECREATE = 2; + { PSN_APPLY message } + PSNRET_NOERROR = 0; + PSNRET_INVALID_NOCHANGEPAGE = 2; + { Property Sheet } + PSBTN_APPLYNOW = 4; + PSBTN_BACK = 0; + PSBTN_CANCEL = 5; + PSBTN_FINISH = 2; + PSBTN_HELP = 6; + PSBTN_NEXT = 1; + PSBTN_OK = 3; + PSWIZB_BACK = 1; + PSWIZB_NEXT = 2; + PSWIZB_FINISH = 4; + PSWIZB_DISABLEDFINISH = 8; + ID_PSREBOOTSYSTEM = 3; + ID_PSRESTARTWINDOWS = 2; + WIZ_BODYCX = 184; + WIZ_BODYX = 92; + WIZ_CXBMP = 80; + WIZ_CXDLG = 276; + WIZ_CYDLG = 140; + { VX_FIXEDFILEINFO structure } + { was #define dname def_expr } + function VS_FILE_INFO : LPTSTR; + { return type might be wrong } + + + const + VS_VERSION_INFO = 1; + VS_FF_DEBUG = $1; + VS_FF_INFOINFERRED = $10; + VS_FF_PATCHED = $4; + VS_FF_PRERELEASE = $2; + VS_FF_PRIVATEBUILD = $8; + VS_FF_SPECIALBUILD = $20; + VOS_UNKNOWN = 0; + VOS_DOS = $10000; + VOS_OS216 = $20000; + VOS_OS232 = $30000; + VOS_NT = $40000; + VOS_DOS_WINDOWS16 = $10001; + VOS_DOS_WINDOWS32 = $10004; + VOS_OS216_PM16 = $20002; + VOS_OS232_PM32 = $30003; + VOS_NT_WINDOWS32 = $40004; + VFT_UNKNOWN = 0; + VFT_APP = $1; + VFT_DLL = $2; + VFT_DRV = $3; + VFT_FONT = $4; + VFT_VXD = $5; + VFT_STATIC_LIB = $7; + VFT2_UNKNOWN = 0; + VFT2_DRV_PRINTER = $1; + VFT2_DRV_KEYBOARD = $2; + VFT2_DRV_LANGUAGE = $3; + VFT2_DRV_DISPLAY = $4; + VFT2_DRV_MOUSE = $5; + VFT2_DRV_NETWORK = $6; + VFT2_DRV_SYSTEM = $7; + VFT2_DRV_INSTALLABLE = $8; + VFT2_DRV_SOUND = $9; + VFT2_FONT_RASTER = $1; + VFT2_FONT_VECTOR = $2; + VFT2_FONT_TRUETYPE = $3; + { PANOSE structure } + PAN_ANY = 0; + PAN_NO_FIT = 1; + PAN_FAMILY_TEXT_DISPLAY = 2; + PAN_FAMILY_SCRIPT = 3; + PAN_FAMILY_DECORATIVE = 4; + PAN_FAMILY_PICTORIAL = 5; + PAN_SERIF_COVE = 2; + PAN_SERIF_OBTUSE_COVE = 3; + PAN_SERIF_SQUARE_COVE = 4; + PAN_SERIF_OBTUSE_SQUARE_COVE = 5; + PAN_SERIF_SQUARE = 6; + PAN_SERIF_THIN = 7; + PAN_SERIF_BONE = 8; + PAN_SERIF_EXAGGERATED = 9; + PAN_SERIF_TRIANGLE = 10; + PAN_SERIF_NORMAL_SANS = 11; + PAN_SERIF_OBTUSE_SANS = 12; + PAN_SERIF_PERP_SANS = 13; + PAN_SERIF_FLARED = 14; + PAN_SERIF_ROUNDED = 15; + PAN_WEIGHT_VERY_LIGHT = 2; + PAN_WEIGHT_LIGHT = 3; + PAN_WEIGHT_THIN = 4; + PAN_WEIGHT_BOOK = 5; + PAN_WEIGHT_MEDIUM = 6; + PAN_WEIGHT_DEMI = 7; + PAN_WEIGHT_BOLD = 8; + PAN_WEIGHT_HEAVY = 9; + PAN_WEIGHT_BLACK = 10; + PAN_WEIGHT_NORD = 11; + PAN_PROP_OLD_STYLE = 2; + PAN_PROP_MODERN = 3; + PAN_PROP_EVEN_WIDTH = 4; + PAN_PROP_EXPANDED = 5; + PAN_PROP_CONDENSED = 6; + PAN_PROP_VERY_EXPANDED = 7; + PAN_PROP_VERY_CONDENSED = 8; + PAN_PROP_MONOSPACED = 9; + PAN_CONTRAST_NONE = 2; + PAN_CONTRAST_VERY_LOW = 3; + PAN_CONTRAST_LOW = 4; + PAN_CONTRAST_MEDIUM_LOW = 5; + PAN_CONTRAST_MEDIUM = 6; + PAN_CONTRAST_MEDIUM_HIGH = 7; + PAN_CONTRAST_HIGH = 8; + PAN_CONTRAST_VERY_HIGH = 9; + PAN_STROKE_GRADUAL_DIAG = 2; + PAN_STROKE_GRADUAL_TRAN = 3; + PAN_STROKE_GRADUAL_VERT = 4; + PAN_STROKE_GRADUAL_HORZ = 5; + PAN_STROKE_RAPID_VERT = 6; + PAN_STROKE_RAPID_HORZ = 7; + PAN_STROKE_INSTANT_VERT = 8; + PAN_STRAIGHT_ARMS_HORZ = 2; + PAN_STRAIGHT_ARMS_WEDGE = 3; + PAN_STRAIGHT_ARMS_VERT = 4; + PAN_STRAIGHT_ARMS_SINGLE_SERIF = 5; + PAN_STRAIGHT_ARMS_DOUBLE_SERIF = 6; + PAN_BENT_ARMS_HORZ = 7; + PAN_BENT_ARMS_VERT = 9; + PAN_BENT_ARMS_WEDGE = 8; + PAN_BENT_ARMS_SINGLE_SERIF = 10; + PAN_BENT_ARMS_DOUBLE_SERIF = 11; + PAN_LETT_NORMAL_CONTACT = 2; + PAN_LETT_NORMAL_WEIGHTED = 3; + PAN_LETT_NORMAL_BOXED = 4; + PAN_LETT_NORMAL_FLATTENED = 5; + PAN_LETT_NORMAL_ROUNDED = 6; + PAN_LETT_NORMAL_OFF_CENTER = 7; + PAN_LETT_NORMAL_SQUARE = 8; + PAN_LETT_OBLIQUE_CONTACT = 9; + PAN_LETT_OBLIQUE_WEIGHTED = 10; + PAN_LETT_OBLIQUE_BOXED = 11; + PAN_LETT_OBLIQUE_FLATTENED = 12; + PAN_LETT_OBLIQUE_ROUNDED = 13; + PAN_LETT_OBLIQUE_OFF_CENTER = 14; + PAN_LETT_OBLIQUE_SQUARE = 15; + PAN_MIDLINE_STANDARD_TRIMMED = 2; + PAN_MIDLINE_STANDARD_POINTED = 3; + PAN_MIDLINE_STANDARD_SERIFED = 4; + PAN_MIDLINE_HIGH_TRIMMED = 5; + PAN_MIDLINE_HIGH_POINTED = 6; + PAN_MIDLINE_HIGH_SERIFED = 7; + PAN_MIDLINE_CONSTANT_TRIMMED = 8; + PAN_MIDLINE_CONSTANT_POINTED = 9; + PAN_MIDLINE_CONSTANT_SERIFED = 10; + PAN_MIDLINE_LOW_TRIMMED = 11; + PAN_MIDLINE_LOW_POINTED = 12; + PAN_MIDLINE_LOW_SERIFED = 13; + PAN_XHEIGHT_CONSTANT_SMALL = 2; + PAN_XHEIGHT_CONSTANT_STD = 3; + PAN_XHEIGHT_CONSTANT_LARGE = 4; + PAN_XHEIGHT_DUCKING_SMALL = 5; + PAN_XHEIGHT_DUCKING_STD = 6; + PAN_XHEIGHT_DUCKING_LARGE = 7; + { PALETTENTRY structure } + PC_EXPLICIT = 2; + PC_NOCOLLAPSE = 4; + PC_RESERVED = 1; + { LOGBRUSH structure } + BS_DIBPATTERN = 5; + BS_DIBPATTERN8X8 = 8; + BS_DIBPATTERNPT = 6; + BS_HATCHED = 2; + BS_HOLLOW = 1; + BS_NULL = 1; + BS_PATTERN = 3; + BS_PATTERN8X8 = 7; + BS_SOLID = 0; + { DEVMODE structure } + DM_ORIENTATION = $1; + DM_PAPERSIZE = $2; + DM_PAPERLENGTH = $4; + DM_PAPERWIDTH = $8; + DM_SCALE = $10; + DM_COPIES = $100; + DM_DEFAULTSOURCE = $200; + DM_PRINTQUALITY = $400; + DM_COLOR = $800; + DM_DUPLEX = $1000; + DM_YRESOLUTION = $2000; + DM_TTOPTION = $4000; + DM_COLLATE = $8000; + DM_FORMNAME = $10000; + DM_LOGPIXELS = $20000; + {DM_BITSPERPEL = $40000; + DM_PELSWIDTH = $80000; + DM_PELSHEIGHT = $100000; + DM_DISPLAYFLAGS = $200000; + DM_DISPLAYFREQUENCY = $400000;already above } + DM_ICMMETHOD = $800000; + DM_ICMINTENT = $1000000; + DM_MEDIATYPE = $2000000; + DM_DITHERTYPE = $4000000; + DMORIENT_LANDSCAPE = 2; + DMORIENT_PORTRAIT = 1; + DMPAPER_LETTER = 1; + DMPAPER_LEGAL = 5; + DMPAPER_A4 = 9; + DMPAPER_CSHEET = 24; + DMPAPER_DSHEET = 25; + DMPAPER_ESHEET = 26; + DMPAPER_LETTERSMALL = 2; + DMPAPER_TABLOID = 3; + DMPAPER_LEDGER = 4; + DMPAPER_STATEMENT = 6; + DMPAPER_EXECUTIVE = 7; + DMPAPER_A3 = 8; + DMPAPER_A4SMALL = 10; + DMPAPER_A5 = 11; + DMPAPER_B4 = 12; + DMPAPER_B5 = 13; + DMPAPER_FOLIO = 14; + DMPAPER_QUARTO = 15; + DMPAPER_10X14 = 16; + DMPAPER_11X17 = 17; + DMPAPER_NOTE = 18; + DMPAPER_ENV_9 = 19; + DMPAPER_ENV_10 = 20; + DMPAPER_ENV_11 = 21; + DMPAPER_ENV_12 = 22; + DMPAPER_ENV_14 = 23; + DMPAPER_ENV_DL = 27; + DMPAPER_ENV_C5 = 28; + DMPAPER_ENV_C3 = 29; + DMPAPER_ENV_C4 = 30; + DMPAPER_ENV_C6 = 31; + DMPAPER_ENV_C65 = 32; + DMPAPER_ENV_B4 = 33; + DMPAPER_ENV_B5 = 34; + DMPAPER_ENV_B6 = 35; + DMPAPER_ENV_ITALY = 36; + DMPAPER_ENV_MONARCH = 37; + DMPAPER_ENV_PERSONAL = 38; + DMPAPER_FANFOLD_US = 39; + DMPAPER_FANFOLD_STD_GERMAN = 40; + DMPAPER_FANFOLD_LGL_GERMAN = 41; + DMRES_HIGH = -(4); + DMRES_MEDIUM = -(3); + DMRES_LOW = -(2); + DMRES_DRAFT = -(1); + DMCOLOR_COLOR = 2; + DMCOLOR_MONOCHROME = 1; + DMDUP_SIMPLEX = 1; + DMDUP_HORIZONTAL = 3; + DMDUP_VERTICAL = 2; + DMTT_BITMAP = 1; + DMTT_DOWNLOAD = 2; + DMTT_SUBDEV = 3; + DMCOLLATE_TRUE = 1; + DMCOLLATE_FALSE = 0; + DM_GRAYSCALE = 1; + DM_INTERLACED = 2; + DMICMMETHOD_NONE = 1; + DMICMMETHOD_SYSTEM = 2; + DMICMMETHOD_DRIVER = 3; + DMICMMETHOD_DEVICE = 4; + DMICMMETHOD_USER = 256; + DMICM_SATURATE = 1; + DMICM_CONTRAST = 2; + DMICM_COLORMETRIC = 3; + DMICM_USER = 256; + DMMEDIA_STANDARD = 1; + DMMEDIA_GLOSSY = 3; + DMMEDIA_TRANSPARENCY = 2; + DMMEDIA_USER = 256; + DMDITHER_NONE = 1; + DMDITHER_COARSE = 2; + DMDITHER_FINE = 3; + DMDITHER_LINEART = 4; + DMDITHER_GRAYSCALE = 10; + DMDITHER_USER = 256; + { RGNDATAHEADER structure } + RDH_RECTANGLES = 1; + { TTPOLYGONHEADER structure } + TT_POLYGON_TYPE = 24; + { TTPOLYCURVE structure } + TT_PRIM_LINE = 1; + TT_PRIM_QSPLINE = 2; + { GCP_RESULTS structure } + GCPCLASS_ARABIC = 2; + GCPCLASS_HEBREW = 2; + GCPCLASS_LATIN = 1; + GCPCLASS_LATINNUMBER = 5; + GCPCLASS_LOCALNUMBER = 4; + GCPCLASS_LATINNUMERICSEPARATOR = 7; + GCPCLASS_LATINNUMERICTERMINATOR = 6; + GCPCLASS_NEUTRAL = 3; + GCPCLASS_NUMERICSEPARATOR = 8; + GCPCLASS_PREBOUNDLTR = 128; + GCPCLASS_PREBOUNDRTL = 64; + GCPCLASS_POSTBOUNDLTR = 32; + GCPCLASS_POSTBOUNDRTL = 16; + GCPGLYPH_LINKBEFORE = 32768; + GCPGLYPH_LINKAFTER = 16384; + { RASTERIZER_STATUS structure } + TT_AVAILABLE = 1; + TT_ENABLED = 2; + { COLORADJUSTMENT structure } + CA_NEGATIVE = 1; + CA_LOG_FILTER = 2; + ILLUMINANT_DEVICE_DEFAULT = 0; + ILLUMINANT_A = 1; + ILLUMINANT_B = 2; + ILLUMINANT_C = 3; + ILLUMINANT_D50 = 4; + ILLUMINANT_D55 = 5; + ILLUMINANT_D65 = 6; + ILLUMINANT_D75 = 7; + ILLUMINANT_F2 = 8; + ILLUMINANT_TUNGSTEN = 1; + ILLUMINANT_DAYLIGHT = 3; + ILLUMINANT_FLUORESCENT = 8; + ILLUMINANT_NTSC = 3; + { DOCINFO structure } + DI_APPBANDING = 1; + { EMRMETAHEADER structure } + EMR_HEADER = 1; + ENHMETA_SIGNATURE = 1179469088; + { RTF event masks } + ENM_CHANGE = 1; + ENM_CORRECTTEXT = 4194304; + ENM_DROPFILES = 1048576; + ENM_KEYEVENTS = 65536; + ENM_MOUSEEVENTS = 131072; + ENM_PROTECTED = 2097152; + ENM_REQUESTRESIZE = 262144; + ENM_SCROLL = 4; + ENM_SELCHANGE = 524288; + ENM_UPDATE = 2; + ENM_NONE = 0; + { RTF styles } + ES_DISABLENOSCROLL = 8192; + ES_EX_NOCALLOLEINIT = 16777216; + ES_NOIME = 524288; + ES_SAVESEL = 32768; + ES_SELFIME = 262144; + ES_SUNKEN = 16384; + ES_VERTICAL = 4194304; + ES_SELECTIONBAR = 16777216; + { EM_SETOPTIONS message } + ECOOP_SET = 1; + ECOOP_OR = 2; + ECOOP_AND = 3; + ECOOP_XOR = 4; + ECO_AUTOWORDSELECTION = 1; + ECO_AUTOVSCROLL = 64; + ECO_AUTOHSCROLL = 128; + ECO_NOHIDESEL = 256; + ECO_READONLY = 2048; + ECO_WANTRETURN = 4096; + ECO_SAVESEL = 32768; + ECO_SELECTIONBAR = 16777216; + ECO_VERTICAL = 4194304; + { EM_SETCHARFORMAT message } + SCF_WORD = 2; + SCF_SELECTION = 1; + { EM_STREAMOUT message } + SF_TEXT = 1; + SF_RTF = 2; + SF_RTFNOOBJS = 3; + SF_TEXTIZED = 4; + SFF_SELECTION = 32768; + SFF_PLAINRTF = 16384; + { EM_FINDWORDBREAK message } + WB_CLASSIFY = 3; + {WB_ISDELIMITER = 2; + WB_LEFT = 0; already above } + WB_LEFTBREAK = 6; + WB_PREVBREAK = 6; + WB_MOVEWORDLEFT = 4; + WB_MOVEWORDPREV = 4; + WB_MOVEWORDRIGHT = 5; + WB_MOVEWORDNEXT = 5; + {WB_RIGHT = 1;already above } + WB_RIGHTBREAK = 7; + WB_NEXTBREAK = 7; + { EM_GETPUNCTUATION message } + PC_LEADING = 2; + PC_FOLLOWING = 1; + PC_DELIMITER = 4; + PC_OVERFLOW = 3; + { EM_SETWORDWRAPMODE message } + WBF_WORDWRAP = 16; + WBF_WORDBREAK = 32; + WBF_OVERFLOW = 64; + WBF_LEVEL1 = 128; + WBF_LEVEL2 = 256; + WBF_CUSTOM = 512; + WBF_BREAKAFTER = 64; + WBF_BREAKLINE = 32; + WBF_ISWHITE = 16; + { CHARFORMAT structure } + CFM_BOLD = 1; + CFM_COLOR = 1073741824; + CFM_FACE = 536870912; + CFM_ITALIC = 2; + CFM_OFFSET = 268435456; + CFM_PROTECTED = 16; + CFM_SIZE = $80000000; + CFM_STRIKEOUT = 8; + CFM_UNDERLINE = 4; + CFE_AUTOCOLOR = 1073741824; + CFE_BOLD = 1; + CFE_ITALIC = 2; + CFE_STRIKEOUT = 8; + CFE_UNDERLINE = 4; + CFE_PROTECTED = 16; + { PARAFORMAT structure } + PFM_ALIGNMENT = 8; + PFM_NUMBERING = 32; + PFM_OFFSET = 4; + PFM_OFFSETINDENT = $80000000; + PFM_RIGHTINDENT = 2; + PFM_STARTINDENT = 1; + PFM_TABSTOPS = 16; + PFN_BULLET = 1; + PFA_LEFT = 1; + PFA_RIGHT = 2; + PFA_CENTER = 3; + { SELCHANGE structure } + SEL_EMPTY = 0; + SEL_TEXT = 1; + SEL_OBJECT = 2; + SEL_MULTICHAR = 4; + SEL_MULTIOBJECT = 8; + { RTF clipboard formats } + CF_RTF = 'Rich Text Format'; + CF_RETEXTOBJ = 'RichEdit Text and Objects'; + { DRAWITEMSTRUCT structure } + ODT_BUTTON = 4; + ODT_COMBOBOX = 3; + ODT_LISTBOX = 2; + ODT_LISTVIEW = 102; + ODT_MENU = 1; + ODT_STATIC = 5; + ODT_TAB = 101; + ODT_HEADER = 100; + ODA_DRAWENTIRE = 1; + ODA_FOCUS = 4; + ODA_SELECT = 2; + ODS_CHECKED = 8; + ODS_COMBOBOXEDIT = 4096; + ODS_DEFAULT = 32; + ODS_DISABLED = 4; + ODS_FOCUS = 16; + ODS_GRAYED = 2; + ODS_SELECTED = 1; + { Common control window classes } + ANIMATE_CLASSW = 'SysAnimate32'; + HOTKEY_CLASSW = 'msctls_hotkey32'; + PROGRESS_CLASSW = 'msctls_progress32'; + STATUSCLASSNAMEW = 'msctls_statusbar32'; + TOOLBARCLASSNAMEW = 'ToolbarWindow32'; + TOOLTIPS_CLASSW = 'tooltips_class32'; + TRACKBAR_CLASSW = 'msctls_trackbar32'; + UPDOWN_CLASSW = 'msctls_updown32'; + WC_HEADERW = 'SysHeader32'; + WC_LISTVIEWW = 'SysListView32'; + WC_TABCONTROLW = 'SysTabControl32'; + WC_TREEVIEWW = 'SysTreeView32'; + { Common control styles } + CCS_ADJUSTABLE = $20; + CCS_BOTTOM = $3; + CCS_NODIVIDER = $40; + CCS_NOMOVEY = $2; + CCS_NOPARENTALIGN = $8; + CCS_NORESIZE = $4; + CCS_TOP = $1; + ANIMATE_CLASSA = 'SysAnimate32'; + HOTKEY_CLASSA = 'msctls_hotkey32'; + PROGRESS_CLASSA = 'msctls_progress32'; + STATUSCLASSNAMEA = 'msctls_statusbar32'; + TOOLBARCLASSNAMEA = 'ToolbarWindow32'; + TOOLTIPS_CLASSA = 'tooltips_class32'; + TRACKBAR_CLASSA = 'msctls_trackbar32'; + UPDOWN_CLASSA = 'msctls_updown32'; + WC_HEADERA = 'SysHeader32'; + WC_LISTVIEWA = 'SysListView32'; + WC_TABCONTROLA = 'SysTabControl32'; + WC_TREEVIEWA = 'SysTreeView32'; +{$ifdef UNICODE} + + const + ANIMATE_CLASS = ANIMATE_CLASSW; + HOTKEY_CLASS = HOTKEY_CLASSW; + PROGRESS_CLASS = PROGRESS_CLASSW; + STATUSCLASSNAME = STATUSCLASSNAMEW; + TOOLBARCLASSNAME = TOOLBARCLASSNAMEW; + TOOLTIPS_CLASS = TOOLTIPS_CLASSW; + TRACKBAR_CLASS = TRACKBAR_CLASSW; + UPDOWN_CLASS = UPDOWN_CLASSW; + WC_HEADER = WC_HEADERW; + WC_LISTVIEW = WC_LISTVIEWW; + WC_TABCONTROL = WC_TABCONTROLW; + WC_TREEVIEW = WC_TREEVIEWW; +{$else} + + const + ANIMATE_CLASS = ANIMATE_CLASSA; + HOTKEY_CLASS = HOTKEY_CLASSA; + PROGRESS_CLASS = PROGRESS_CLASSA; + STATUSCLASSNAME = STATUSCLASSNAMEA; + TOOLBARCLASSNAME = TOOLBARCLASSNAMEA; + TOOLTIPS_CLASS = TOOLTIPS_CLASSA; + TRACKBAR_CLASS = TRACKBAR_CLASSA; + UPDOWN_CLASS = UPDOWN_CLASSA; + WC_HEADER = WC_HEADERA; + WC_LISTVIEW = WC_LISTVIEWA; + WC_TABCONTROL = WC_TABCONTROLA; + WC_TREEVIEW = WC_TREEVIEWA; +{$endif} + { UNICODE } + { Header control styles } + + const + HDS_BUTTONS = 2; + HDS_HIDDEN = 8; + HDS_HORZ = 0; + { HD_ITEM structure } + HDI_BITMAP = 16; + HDI_FORMAT = 4; + HDI_HEIGHT = 1; + HDI_LPARAM = 8; + HDI_TEXT = 2; + HDI_WIDTH = 1; + HDF_CENTER = 2; + HDF_LEFT = 0; + HDF_RIGHT = 1; + HDF_RTLREADING = 4; + HDF_BITMAP = 8192; + HDF_OWNERDRAW = 32768; + HDF_STRING = 16384; + HDF_JUSTIFYMASK = 3; + { HD_HITTESTINFO structure } + HHT_NOWHERE = 1; + HHT_ONDIVIDER = 4; + HHT_ONDIVOPEN = 8; + HHT_ONHEADER = 2; + HHT_TOLEFT = 2048; + HHT_TORIGHT = 1024; + { TBADDBITMAP structure } + { was #define dname def_expr } + function HINST_COMMCTRL : HINST; + + + const + IDB_STD_LARGE_COLOR = 1; + IDB_STD_SMALL_COLOR = 0; + IDB_VIEW_LARGE_COLOR = 5; + IDB_VIEW_SMALL_COLOR = 4; + STD_COPY = 1; + STD_CUT = 0; + STD_DELETE = 5; + STD_FILENEW = 6; + STD_FILEOPEN = 7; + STD_FILESAVE = 8; + STD_FIND = 12; + STD_HELP = 11; + STD_PASTE = 2; + STD_PRINT = 14; + STD_PRINTPRE = 9; + STD_PROPERTIES = 10; + STD_REDOW = 4; + STD_REPLACE = 13; + STD_UNDO = 3; + VIEW_LARGEICONS = 0; + VIEW_SMALLICONS = 1; + VIEW_LIST = 2; + VIEW_DETAILS = 3; + VIEW_SORTNAME = 4; + VIEW_SORTSIZE = 5; + VIEW_SORTDATE = 6; + VIEW_SORTTYPE = 7; + { Toolbar styles } + TBSTYLE_ALTDRAG = 1024; + TBSTYLE_TOOLTIPS = 256; + TBSTYLE_WRAPABLE = 512; + TBSTYLE_BUTTON = 0; + TBSTYLE_CHECK = 2; + TBSTYLE_CHECKGROUP = 6; + TBSTYLE_GROUP = 4; + TBSTYLE_SEP = 1; + { Toolbar states } + TBSTATE_CHECKED = 1; + TBSTATE_ENABLED = 4; + TBSTATE_HIDDEN = 8; + TBSTATE_INDETERMINATE = 16; + TBSTATE_PRESSED = 2; + TBSTATE_WRAP = 32; + { Tooltip styles } + TTS_ALWAYSTIP = 1; + TTS_NOPREFIX = 2; + { TOOLINFO structure } + TTF_IDISHWND = 1; + TTF_CENTERTIP = 2; + TTF_RTLREADING = 4; + TTF_SUBCLASS = 16; + { TTM_SETDELAYTIME message } + TTDT_AUTOMATIC = 0; + TTDT_AUTOPOP = 2; + TTDT_INITIAL = 3; + TTDT_RESHOW = 1; + { Status window } + SBARS_SIZEGRIP = 256; + {SBARS_SIZEGRIP = 256;already above } + { DL_DRAGGING message } + DL_MOVECURSOR = 3; + DL_COPYCURSOR = 2; + DL_STOPCURSOR = 1; + { Up-down control styles } + UDS_ALIGNLEFT = 8; + UDS_ALIGNRIGHT = 4; + UDS_ARROWKEYS = 32; + UDS_AUTOBUDDY = 16; + UDS_HORZ = 64; + UDS_NOTHOUSANDS = 128; + UDS_SETBUDDYINT = 2; + UDS_WRAP = 1; + { UDM_SETRANGE message } + UD_MAXVAL = 32767; + UD_MINVAL = -(32767); + { HKM_GETHOTKEY message } + HOTKEYF_ALT = 4; + HOTKEYF_CONTROL = 2; + HOTKEYF_EXT = 8; + HOTKEYF_SHIFT = 1; + { HKM_SETRULES message } + HKCOMB_A = 8; + HKCOMB_C = 4; + HKCOMB_CA = 64; + HKCOMB_NONE = 1; + HKCOMB_S = 2; + HKCOMB_SA = 32; + HKCOMB_SC = 16; + HKCOMB_SCA = 128; + { Trackbar styles } + TBS_HORZ = 0; + TBS_VERT = 2; + TBS_AUTOTICKS = 1; + TBS_NOTICKS = 16; + TBS_TOP = 4; + TBS_BOTTOM = 0; + TBS_LEFT = 4; + TBS_RIGHT = 0; + TBS_BOTH = 8; + TBS_ENABLESELRANGE = 32; + TBS_FIXEDLENGTH = 64; + TBS_NOTHUMB = 128; + TB_BOTTOM = 7; + TB_ENDTRACK = 8; + TB_LINEDOWN = 1; + TB_LINEUP = 0; + TB_PAGEDOWN = 3; + TB_PAGEUP = 2; + TB_THUMBPOSITION = 4; + TB_THUMBTRACK = 5; + TB_TOP = 6; + { List view styles } + LVS_ALIGNLEFT = 2048; + LVS_ALIGNTOP = 0; + LVS_AUTOARRANGE = 256; + LVS_EDITLABELS = 512; + LVS_ICON = 0; + LVS_LIST = 3; + LVS_NOCOLUMNHEADER = 16384; + LVS_NOLABELWRAP = 128; + LVS_NOSCROLL = 8192; + LVS_NOSORTHEADER = 32768; + LVS_OWNERDRAWFIXED = 1024; + LVS_REPORT = 1; + LVS_SHAREIMAGELISTS = 64; + LVS_SHOWSELALWAYS = 8; + LVS_SINGLESEL = 4; + LVS_SMALLICON = 2; + LVS_SORTASCENDING = 16; + LVS_SORTDESCENDING = 32; + LVS_TYPESTYLEMASK = 64512; + LVSIL_NORMAL = 0; + LVSIL_SMALL = 1; + LVSIL_STATE = 2; + LVIS_CUT = 4; + LVIS_DROPHILITED = 8; + LVIS_FOCUSED = 1; + LVIS_SELECTED = 2; + LVIS_OVERLAYMASK = 3840; + LVIS_STATEIMAGEMASK = 61440; + { was #define dname def_expr } + function LPSTR_TEXTCALLBACKW : LPWSTR; + + { was #define dname def_expr } + function LPSTR_TEXTCALLBACKA : LPSTR; + +{$ifdef UNICODE} + + {const this is a function in fact !! + LPSTR_TEXTCALLBACK = LPSTR_TEXTCALLBACKW;} + function LPSTR_TEXTCALLBACK : LPWSTR; + +{$else} + + {const + LPSTR_TEXTCALLBACK = LPSTR_TEXTCALLBACKA; } + function LPSTR_TEXTCALLBACK : LPSTR; +{$endif} + { UNICODE } + { LV_ITEM structure } + + const + LVIF_TEXT = 1; + LVIF_IMAGE = 2; + LVIF_PARAM = 4; + LVIF_STATE = 8; + LVIF_DI_SETITEM = 4096; + { LVM_GETNEXTITEM structure } + LVNI_ABOVE = 256; + LVNI_ALL = 0; + LVNI_BELOW = 512; + LVNI_TOLEFT = 1024; + LVNI_TORIGHT = 2048; + LVNI_CUT = 4; + LVNI_DROPHILITED = 8; + LVNI_FOCUSED = 1; + LVNI_SELECTED = 2; + { LV_FINDINFO structure } + LVFI_PARAM = 1; + LVFI_PARTIAL = 8; + LVFI_STRING = 2; + LVFI_WRAP = 32; + LVFI_NEARESTXY = 64; + { LV_HITTESTINFO structure } + LVHT_ABOVE = 8; + LVHT_BELOW = 16; + LVHT_NOWHERE = 1; + LVHT_ONITEMICON = 2; + LVHT_ONITEMLABEL = 4; + LVHT_ONITEMSTATEICON = 8; + LVHT_TOLEFT = 64; + LVHT_TORIGHT = 32; + { LV_COLUMN structure } + LVCF_FMT = 1; + LVCF_SUBITEM = 8; + LVCF_TEXT = 4; + LVCF_WIDTH = 2; + LVCFMT_CENTER = 2; + LVCFMT_LEFT = 0; + LVCFMT_RIGHT = 1; + { ListView_GetItemRect } + LVIR_BOUNDS = 0; + LVIR_ICON = 1; + LVIR_LABEL = 2; + LVIR_SELECTBOUNDS = 3; + { LVM_ARRANGE message } + LVA_ALIGNLEFT = 1; + LVA_ALIGNTOP = 2; + LVA_DEFAULT = 0; + LVA_SNAPTOGRID = 5; + { LVM_SETCOLUMNWIDTH message } + LVSCW_AUTOSIZE = -(1); + LVSCW_AUTOSIZE_USEHEADER = -(2); + { Tree View styles } + TVS_DISABLEDRAGDROP = 16; + TVS_EDITLABELS = 8; + TVS_HASBUTTONS = 1; + TVS_HASLINES = 2; + TVS_LINESATROOT = 4; + TVS_SHOWSELALWAYS = 32; + { Tree View states } + TVIS_BOLD = 16; + TVIS_CUT = 4; + TVIS_DROPHILITED = 8; + TVIS_EXPANDED = 32; + TVIS_EXPANDEDONCE = 64; + TVIS_FOCUSED = 1; + TVIS_OVERLAYMASK = 3840; + TVIS_SELECTED = 2; + TVIS_STATEIMAGEMASK = 61440; + TVIS_USERMASK = 61440; + { TV_ITEM structure } + TVIF_CHILDREN = 64; + TVIF_HANDLE = 16; + TVIF_IMAGE = 2; + TVIF_PARAM = 4; + TVIF_SELECTEDIMAGE = 32; + TVIF_STATE = 8; + TVIF_TEXT = 1; + I_CHILDRENCALLBACK = -(1); + I_IMAGECALLBACK = -(1); + { TV_INSERTSTRUCT structure } + { added manually PM, TREEITEM is not defined in the C headers } + type + TREEITEM = record + end; + HTREEITEM = ^TREEITEM; + TTREEITEM = TREEITEM; + PTREEITEM = ^TREEITEM; + + { was #define dname def_expr } + function TVI_ROOT : HTREEITEM; + + { was #define dname def_expr } + function TVI_FIRST : HTREEITEM; + + { was #define dname def_expr } + function TVI_LAST : HTREEITEM; + + { was #define dname def_expr } + function TVI_SORT : HTREEITEM; + + { TV_HITTESTINFO structure } + + const + TVHT_ABOVE = 256; + TVHT_BELOW = 512; + TVHT_NOWHERE = 1; + TVHT_ONITEM = 70; + TVHT_ONITEMBUTTON = 16; + TVHT_ONITEMICON = 2; + TVHT_ONITEMINDENT = 8; + TVHT_ONITEMLABEL = 4; + TVHT_ONITEMRIGHT = 32; + TVHT_ONITEMSTATEICON = 64; + TVHT_TOLEFT = 2048; + TVHT_TORIGHT = 1024; + { TVM_EXPAND message } + TVE_COLLAPSE = 1; + TVE_COLLAPSERESET = 32768; + TVE_EXPAND = 2; + TVE_TOGGLE = 3; + { TVM_GETIMAGELIST message } + TVSIL_NORMAL = 0; + TVSIL_STATE = 2; + { TVM_GETNEXTITEM message } + TVGN_CARET = 9; + TVGN_CHILD = 4; + TVGN_DROPHILITE = 8; + TVGN_FIRSTVISIBLE = 5; + TVGN_NEXT = 1; + TVGN_NEXTVISIBLE = 6; + TVGN_PARENT = 3; + TVGN_PREVIOUS = 2; + TVGN_PREVIOUSVISIBLE = 7; + TVGN_ROOT = 0; + { TVN_SELCHANGED message } + TVC_BYKEYBOARD = 2; + TVC_BYMOUSE = 1; + TVC_UNKNOWN = 0; + { Tab control styles } + TCS_BUTTONS = 256; + TCS_FIXEDWIDTH = 1024; + TCS_FOCUSNEVER = 32768; + TCS_FOCUSONBUTTONDOWN = 4096; + TCS_FORCEICONLEFT = 16; + TCS_FORCELABELLEFT = 32; + TCS_MULTILINE = 512; + TCS_OWNERDRAWFIXED = 8192; + TCS_RAGGEDRIGHT = 2048; + TCS_RIGHTJUSTIFY = 0; + TCS_SINGLELINE = 0; + TCS_TABS = 0; + TCS_TOOLTIPS = 16384; + { TC_ITEM structure } + TCIF_TEXT = 1; + TCIF_IMAGE = 2; + TCIF_PARAM = 8; + TCIF_RTLREADING = 4; + { TC_HITTESTINFO structure } + TCHT_NOWHERE = 1; + TCHT_ONITEM = 6; + TCHT_ONITEMICON = 2; + TCHT_ONITEMLABEL = 4; + { Animation control styles } + ACS_AUTOPLAY = 4; + ACS_CENTER = 1; + ACS_TRANSPARENT = 2; + { MODEMDEVCAPS structure } + DIALOPTION_BILLING = 64; + DIALOPTION_QUIET = 128; + DIALOPTION_DIALTONE = 256; + MDMVOLFLAG_LOW = 1; + MDMVOLFLAG_MEDIUM = 2; + MDMVOLFLAG_HIGH = 4; + MDMVOL_LOW = 0; + MDMVOL_MEDIUM = 1; + MDMVOL_HIGH = 2; + MDMSPKRFLAG_OFF = 1; + MDMSPKRFLAG_DIAL = 2; + MDMSPKRFLAG_ON = 4; + MDMSPKRFLAG_CALLSETUP = 8; + MDMSPKR_OFF = 0; + MDMSPKR_DIAL = 1; + MDMSPKR_ON = 2; + MDMSPKR_CALLSETUP = 3; + MDM_BLIND_DIAL = 512; + MDM_CCITT_OVERRIDE = 64; + MDM_CELLULAR = 8; + MDM_COMPRESSION = 1; + MDM_ERROR_CONTROL = 2; + MDM_FLOWCONTROL_HARD = 16; + MDM_FLOWCONTROL_SOFT = 32; + MDM_FORCED_EC = 4; + MDM_SPEED_ADJUST = 128; + MDM_TONE_DIAL = 256; + MDM_V23_OVERRIDE = 1024; + { Languages } + // + // Language IDs. + // + // The following two combinations of primary language ID and + // sublanguage ID have special semantics: + // + // Primary Language ID Sublanguage ID Result + // ------------------- --------------- ------------------------ + // LANG_NEUTRAL SUBLANG_NEUTRAL Language neutral + // LANG_NEUTRAL SUBLANG_DEFAULT User default language + // LANG_NEUTRAL SUBLANG_SYS_DEFAULT System default language + // LANG_INVARIANT SUBLANG_NEUTRAL Invariant locale + // + + // + // Primary language IDs. + // + + LANG_NEUTRAL = $00; + LANG_INVARIANT = $7f; + + LANG_AFRIKAANS = $36; + LANG_ALBANIAN = $1c; + LANG_ARABIC = $01; + LANG_ARMENIAN = $2b; + LANG_ASSAMESE = $4d; + LANG_AZERI = $2c; + LANG_BASQUE = $2d; + LANG_BELARUSIAN = $23; + LANG_BENGALI = $45; + LANG_BULGARIAN = $02; + LANG_CATALAN = $03; + LANG_CHINESE = $04; + LANG_CROATIAN = $1a; + LANG_CZECH = $05; + LANG_DANISH = $06; + LANG_DIVEHI = $65; + LANG_DUTCH = $13; + LANG_ENGLISH = $09; + LANG_ESTONIAN = $25; + LANG_FAEROESE = $38; + LANG_FARSI = $29; + LANG_FINNISH = $0b; + LANG_FRENCH = $0c; + LANG_GALICIAN = $56; + LANG_GEORGIAN = $37; + LANG_GERMAN = $07; + LANG_GREEK = $08; + LANG_GUJARATI = $47; + LANG_HEBREW = $0d; + LANG_HINDI = $39; + LANG_HUNGARIAN = $0e; + LANG_ICELANDIC = $0f; + LANG_INDONESIAN = $21; + LANG_ITALIAN = $10; + LANG_JAPANESE = $11; + LANG_KANNADA = $4b; + LANG_KASHMIRI = $60; + LANG_KAZAK = $3f; + LANG_KONKANI = $57; + LANG_KOREAN = $12; + LANG_KYRGYZ = $40; + LANG_LATVIAN = $26; + LANG_LITHUANIAN = $27; + LANG_MACEDONIAN = $2f; // the Former Yugoslav Republic of Macedonia + LANG_MALAY = $3e; + LANG_MALAYALAM = $4c; + LANG_MANIPURI = $58; + LANG_MARATHI = $4e; + LANG_MONGOLIAN = $50; + LANG_NEPALI = $61; + LANG_NORWEGIAN = $14; + LANG_ORIYA = $48; + LANG_POLISH = $15; + LANG_PORTUGUESE = $16; + LANG_PUNJABI = $46; + LANG_ROMANIAN = $18; + LANG_RUSSIAN = $19; + LANG_SANSKRIT = $4f; + LANG_SERBIAN = $1a; + LANG_SINDHI = $59; + LANG_SLOVAK = $1b; + LANG_SLOVENIAN = $24; + LANG_SPANISH = $0a; + LANG_SWAHILI = $41; + LANG_SWEDISH = $1d; + LANG_SYRIAC = $5a; + LANG_TAMIL = $49; + LANG_TATAR = $44; + LANG_TELUGU = $4a; + LANG_THAI = $1e; + LANG_TURKISH = $1f; + LANG_UKRAINIAN = $22; + LANG_URDU = $20; + LANG_UZBEK = $43; + LANG_VIETNAMESE = $2a; + + // + // Sublanguage IDs. + // + // The name immediately following SUBLANG_ dictates which primary + // language ID that sublanguage ID can be combined with to form a + // valid language ID. + // + + SUBLANG_NEUTRAL = $00; // language neutral + SUBLANG_DEFAULT = $01; // user default + SUBLANG_SYS_DEFAULT = $02; // system default + + SUBLANG_ARABIC_SAUDI_ARABIA = $01; // Arabic (Saudi Arabia) + SUBLANG_ARABIC_IRAQ = $02; // Arabic (Iraq) + SUBLANG_ARABIC_EGYPT = $03; // Arabic (Egypt) + SUBLANG_ARABIC_LIBYA = $04; // Arabic (Libya) + SUBLANG_ARABIC_ALGERIA = $05; // Arabic (Algeria) + SUBLANG_ARABIC_MOROCCO = $06; // Arabic (Morocco) + SUBLANG_ARABIC_TUNISIA = $07; // Arabic (Tunisia) + SUBLANG_ARABIC_OMAN = $08; // Arabic (Oman) + SUBLANG_ARABIC_YEMEN = $09; // Arabic (Yemen) + SUBLANG_ARABIC_SYRIA = $0a; // Arabic (Syria) + SUBLANG_ARABIC_JORDAN = $0b; // Arabic (Jordan) + SUBLANG_ARABIC_LEBANON = $0c; // Arabic (Lebanon) + SUBLANG_ARABIC_KUWAIT = $0d; // Arabic (Kuwait) + SUBLANG_ARABIC_UAE = $0e; // Arabic (U.A.E) + SUBLANG_ARABIC_BAHRAIN = $0f; // Arabic (Bahrain) + SUBLANG_ARABIC_QATAR = $10; // Arabic (Qatar) + SUBLANG_AZERI_LATIN = $01; // Azeri (Latin) + SUBLANG_AZERI_CYRILLIC = $02; // Azeri (Cyrillic) + SUBLANG_CHINESE_TRADITIONAL = $01; // Chinese (Taiwan) + SUBLANG_CHINESE_SIMPLIFIED = $02; // Chinese (PR China) + SUBLANG_CHINESE_HONGKONG = $03; // Chinese (Hong Kong S.A.R., P.R.C.) + SUBLANG_CHINESE_SINGAPORE = $04; // Chinese (Singapore) + SUBLANG_CHINESE_MACAU = $05; // Chinese (Macau S.A.R.) + SUBLANG_DUTCH = $01; // Dutch + SUBLANG_DUTCH_BELGIAN = $02; // Dutch (Belgian) + SUBLANG_ENGLISH_US = $01; // English (USA) + SUBLANG_ENGLISH_UK = $02; // English (UK) + SUBLANG_ENGLISH_AUS = $03; // English (Australian) + SUBLANG_ENGLISH_CAN = $04; // English (Canadian) + SUBLANG_ENGLISH_NZ = $05; // English (New Zealand) + SUBLANG_ENGLISH_EIRE = $06; // English (Irish) + SUBLANG_ENGLISH_SOUTH_AFRICA = $07; // English (South Africa) + SUBLANG_ENGLISH_JAMAICA = $08; // English (Jamaica) + SUBLANG_ENGLISH_CARIBBEAN = $09; // English (Caribbean) + SUBLANG_ENGLISH_BELIZE = $0a; // English (Belize) + SUBLANG_ENGLISH_TRINIDAD = $0b; // English (Trinidad) + SUBLANG_ENGLISH_ZIMBABWE = $0c; // English (Zimbabwe) + SUBLANG_ENGLISH_PHILIPPINES = $0d; // English (Philippines) + SUBLANG_FRENCH = $01; // French + SUBLANG_FRENCH_BELGIAN = $02; // French (Belgian) + SUBLANG_FRENCH_CANADIAN = $03; // French (Canadian) + SUBLANG_FRENCH_SWISS = $04; // French (Swiss) + SUBLANG_FRENCH_LUXEMBOURG = $05; // French (Luxembourg) + SUBLANG_FRENCH_MONACO = $06; // French (Monaco) + SUBLANG_GERMAN = $01; // German + SUBLANG_GERMAN_SWISS = $02; // German (Swiss) + SUBLANG_GERMAN_AUSTRIAN = $03; // German (Austrian) + SUBLANG_GERMAN_LUXEMBOURG = $04; // German (Luxembourg) + SUBLANG_GERMAN_LIECHTENSTEIN = $05; // German (Liechtenstein) + SUBLANG_ITALIAN = $01; // Italian + SUBLANG_ITALIAN_SWISS = $02; // Italian (Swiss) + SUBLANG_KASHMIRI_SASIA = $02; // Kashmiri (South Asia) + SUBLANG_KASHMIRI_INDIA = $02; // For app compatibility only + SUBLANG_KOREAN = $01; // Korean (Extended Wansung) + SUBLANG_LITHUANIAN = $01; // Lithuanian + SUBLANG_MALAY_MALAYSIA = $01; // Malay (Malaysia) + SUBLANG_MALAY_BRUNEI_DARUSSALAM = $02; // Malay (Brunei Darussalam) + SUBLANG_NEPALI_INDIA = $02; // Nepali (India) + SUBLANG_NORWEGIAN_BOKMAL = $01; // Norwegian (Bokmal) + SUBLANG_NORWEGIAN_NYNORSK = $02; // Norwegian (Nynorsk) + SUBLANG_PORTUGUESE = $02; // Portuguese + SUBLANG_PORTUGUESE_BRAZILIAN = $01; // Portuguese (Brazilian) + SUBLANG_SERBIAN_LATIN = $02; // Serbian (Latin) + SUBLANG_SERBIAN_CYRILLIC = $03; // Serbian (Cyrillic) + SUBLANG_SPANISH = $01; // Spanish (Castilian) + SUBLANG_SPANISH_MEXICAN = $02; // Spanish (Mexican) + SUBLANG_SPANISH_MODERN = $03; // Spanish (Spain) + SUBLANG_SPANISH_GUATEMALA = $04; // Spanish (Guatemala) + SUBLANG_SPANISH_COSTA_RICA = $05; // Spanish (Costa Rica) + SUBLANG_SPANISH_PANAMA = $06; // Spanish (Panama) + SUBLANG_SPANISH_DOMINICAN_REPUBLIC = $07; // Spanish (Dominican Republic) + SUBLANG_SPANISH_VENEZUELA = $08; // Spanish (Venezuela) + SUBLANG_SPANISH_COLOMBIA = $09; // Spanish (Colombia) + SUBLANG_SPANISH_PERU = $0a; // Spanish (Peru) + SUBLANG_SPANISH_ARGENTINA = $0b; // Spanish (Argentina) + SUBLANG_SPANISH_ECUADOR = $0c; // Spanish (Ecuador) + SUBLANG_SPANISH_CHILE = $0d; // Spanish (Chile) + SUBLANG_SPANISH_URUGUAY = $0e; // Spanish (Uruguay) + SUBLANG_SPANISH_PARAGUAY = $0f; // Spanish (Paraguay) + SUBLANG_SPANISH_BOLIVIA = $10; // Spanish (Bolivia) + SUBLANG_SPANISH_EL_SALVADOR = $11; // Spanish (El Salvador) + SUBLANG_SPANISH_HONDURAS = $12; // Spanish (Honduras) + SUBLANG_SPANISH_NICARAGUA = $13; // Spanish (Nicaragua) + SUBLANG_SPANISH_PUERTO_RICO = $14; // Spanish (Puerto Rico) + SUBLANG_SWEDISH = $01; // Swedish + SUBLANG_SWEDISH_FINLAND = $02; // Swedish (Finland) + SUBLANG_URDU_PAKISTAN = $01; // Urdu (Pakistan) + SUBLANG_URDU_INDIA = $02; // Urdu (India) + SUBLANG_UZBEK_LATIN = $01; // Uzbek (Latin) + SUBLANG_UZBEK_CYRILLIC = $02; // Uzbek (Cyrillic) + + // + // Sorting IDs. + // + + SORT_DEFAULT = $0; // sorting default + + SORT_JAPANESE_XJIS = $0; // Japanese XJIS order + SORT_JAPANESE_UNICODE = $1; // Japanese Unicode order + + SORT_CHINESE_BIG5 = $0; // Chinese BIG5 order + SORT_CHINESE_PRCP = $0; // PRC Chinese Phonetic order + SORT_CHINESE_UNICODE = $1; // Chinese Unicode order + SORT_CHINESE_PRC = $2; // PRC Chinese Stroke Count order + SORT_CHINESE_BOPOMOFO = $3; // Traditional Chinese Bopomofo order + + SORT_KOREAN_KSC = $0; // Korean KSC order + SORT_KOREAN_UNICODE = $1; // Korean Unicode order + + SORT_GERMAN_PHONE_BOOK = $1; // German Phone Book order + + SORT_HUNGARIAN_DEFAULT = $0; // Hungarian Default order + SORT_HUNGARIAN_TECHNICAL = $1; // Hungarian Technical order + + SORT_GEORGIAN_TRADITIONAL = $0; // Georgian Traditional order + SORT_GEORGIAN_MODERN = $1; // Georgian Modern order + + + { SYSTEM_INFO structure } + PROCESSOR_INTEL_386 = 386; + PROCESSOR_INTEL_486 = 486; + PROCESSOR_INTEL_PENTIUM = 586; + PROCESSOR_MIPS_R4000 = 4000; + PROCESSOR_ALPHA_21064 = 21064; + { FSCTL_SET_COMPRESSION } + COMPRESSION_FORMAT_NONE = 0; + COMPRESSION_FORMAT_DEFAULT = 1; + COMPRESSION_FORMAT_LZNT1 = 2; + { TAPE_GET_DRIVE_PARAMETERS structure } + TAPE_DRIVE_COMPRESSION = 131072; + TAPE_DRIVE_ECC = 65536; + TAPE_DRIVE_ERASE_BOP_ONLY = 64; + TAPE_DRIVE_ERASE_LONG = 32; + TAPE_DRIVE_ERASE_IMMEDIATE = 128; + TAPE_DRIVE_ERASE_SHORT = 16; + TAPE_DRIVE_FIXED = 1; + TAPE_DRIVE_FIXED_BLOCK = 1024; + TAPE_DRIVE_INITIATOR = 4; + TAPE_DRIVE_PADDING = 262144; + TAPE_DRIVE_GET_ABSOLUTE_BLK = 1048576; + TAPE_DRIVE_GET_LOGICAL_BLK = 2097152; + TAPE_DRIVE_REPORT_SMKS = 524288; + TAPE_DRIVE_SELECT = 2; + TAPE_DRIVE_SET_EOT_WZ_SIZE = 4194304; + TAPE_DRIVE_TAPE_CAPACITY = 256; + TAPE_DRIVE_TAPE_REMAINING = 512; + TAPE_DRIVE_VARIABLE_BLOCK = 2048; + TAPE_DRIVE_WRITE_PROTECT = 4096; + TAPE_DRIVE_ABS_BLK_IMMED = -(2147475456); + TAPE_DRIVE_ABSOLUTE_BLK = -(2147479552); + TAPE_DRIVE_END_OF_DATA = -(2147418112); + TAPE_DRIVE_FILEMARKS = -(2147221504); + TAPE_DRIVE_LOAD_UNLOAD = -(2147483647); + TAPE_DRIVE_LOAD_UNLD_IMMED = -(2147483616); + TAPE_DRIVE_LOCK_UNLOCK = -(2147483644); + TAPE_DRIVE_LOCK_UNLK_IMMED = -(2147483520); + TAPE_DRIVE_LOG_BLK_IMMED = -(2147450880); + TAPE_DRIVE_LOGICAL_BLK = -(2147467264); + TAPE_DRIVE_RELATIVE_BLKS = -(2147352576); + TAPE_DRIVE_REVERSE_POSITION = -(2143289344); + TAPE_DRIVE_REWIND_IMMEDIATE = -(2147483640); + TAPE_DRIVE_SEQUENTIAL_FMKS = -(2146959360); + TAPE_DRIVE_SEQUENTIAL_SMKS = -(2145386496); + TAPE_DRIVE_SET_BLOCK_SIZE = -(2147483632); + TAPE_DRIVE_SET_COMPRESSION = -(2147483136); + TAPE_DRIVE_SET_ECC = -(2147483392); + TAPE_DRIVE_SET_PADDING = -(2147482624); + TAPE_DRIVE_SET_REPORT_SMKS = -(2147481600); + TAPE_DRIVE_SETMARKS = -(2146435072); + TAPE_DRIVE_SPACE_IMMEDIATE = -(2139095040); + TAPE_DRIVE_TENSION = -(2147483646); + TAPE_DRIVE_TENSION_IMMED = -(2147483584); + TAPE_DRIVE_WRITE_FILEMARKS = -(2113929216); + TAPE_DRIVE_WRITE_LONG_FMKS = -(2013265920); + TAPE_DRIVE_WRITE_MARK_IMMED = -(1879048192); + TAPE_DRIVE_WRITE_SETMARKS = -(2130706432); + TAPE_DRIVE_WRITE_SHORT_FMKS = -(2080374784); + { ACCESS_MASK, ACCESS TYPES } + DELETE = $00010000; //+winnt + READ_CONTROL = $00020000; //+winnt + WRITE_DAC = $00040000; //winnt + WRITE_OWNER = $00080000; //winnt + SYNCHRONIZE = $00100000; //winnt + // + // MaximumAllowed access type + // + MAXIMUM_ALLOWED = $2000000; //winnt + GENERIC_READ = $80000000; //winnt + GENERIC_WRITE = $40000000; //winnt + GENERIC_EXECUTE = $20000000; //+winnt + GENERIC_ALL = $10000000; //winnt + { Standard rights } + STANDARD_RIGHTS_REQUIRED = $f0000; //winnt + STANDARD_RIGHTS_WRITE = READ_CONTROL; //~winnt + STANDARD_RIGHTS_READ = READ_CONTROL; //~winnt + STANDARD_RIGHTS_EXECUTE = READ_CONTROL; //~winnt + STANDARD_RIGHTS_ALL = $1f0000; + SPECIFIC_RIGHTS_ALL = $ffff; + // + // AccessSystemAcl access type + // + ACCESS_SYSTEM_SECURITY = $1000000; + { SID } + ///////////////////////////////////////////////////////////////////////////// + // // + // Universal well-known SIDs // + // // + // Null SID S-1-0-0 // + // World S-1-1-0 // + // Local S-1-2-0 // + // Creator Owner ID S-1-3-0 // + // Creator Group ID S-1-3-1 // + // Creator Owner Server ID S-1-3-2 // + // Creator Group Server ID S-1-3-3 // + // // + // (Non-unique IDs) S-1-4 // + // // + ///////////////////////////////////////////////////////////////////////////// + + SECURITY_NULL_SID_AUTHORITY : SID_IDENTIFIER_AUTHORITY_REC = ( 0,0,0,0,0,0); //+winnt + SECURITY_WORLD_SID_AUTHORITY : SID_IDENTIFIER_AUTHORITY_REC = (0,0,0,0,0,1); //+winnt + SECURITY_LOCAL_SID_AUTHORITY : SID_IDENTIFIER_AUTHORITY_REC = (0,0,0,0,0,2); //+winnt + SECURITY_CREATOR_SID_AUTHORITY : SID_IDENTIFIER_AUTHORITY_REC = (0,0,0,0,0,3);//+winnt + SECURITY_NON_UNIQUE_AUTHORITY : SID_IDENTIFIER_AUTHORITY_REC = (0,0,0,0,0,4); //+winnt + SECURITY_NULL_RID = 0; //winnt + SECURITY_WORLD_RID = 0; //winnt + SECURITY_LOCAL_RID = 0; //winnt + SECURITY_CREATOR_OWNER_RID = 0; //winnt + SECURITY_CREATOR_GROUP_RID = $1; //winnt + SECURITY_CREATOR_OWNER_SERVER_RID = $2; //+winnt + SECURITY_CREATOR_GROUP_SERVER_RID = $3; //+winnt + ///////////////////////////////////////////////////////////////////////////// + // // + // NT well-known SIDs // + // // + // NT Authority S-1-5 // + // Dialup S-1-5-1 // + // // + // Network S-1-5-2 // + // Batch S-1-5-3 // + // Interactive S-1-5-4 // + // Service S-1-5-6 // + // AnonymousLogon S-1-5-7 (aka null logon session) // + // Proxy S-1-5-8 // + // ServerLogon S-1-5-9 (aka domain controller account) // + // Self S-1-5-10 (self RID) // + // Authenticated User S-1-5-11 (Authenticated user somewhere) // + // Restricted Code S-1-5-12 (Running restricted code) // + // // + // (Logon IDs) S-1-5-5-X-Y // + // // + // (NT non-unique IDs) S-1-5-0x15-... // + // // + // (Built-in domain) s-1-5-0x20 // + // // + ///////////////////////////////////////////////////////////////////////////// + SECURITY_NT_AUTHORITY : SID_IDENTIFIER_AUTHORITY_REC = (0,0,0,0,0,5); //+winnt + + SECURITY_DIALUP_RID = $1; //winnt + SECURITY_NETWORK_RID = $2; //winnt + SECURITY_BATCH_RID = $3; //winnt + SECURITY_INTERACTIVE_RID = $4; //winnt + SECURITY_LOGON_IDS_RID = $5; //winnt + SECURITY_LOGON_IDS_RID_COUNT = $3; //winnt + SECURITY_SERVICE_RID = $6; //winnt + SECURITY_ANONYMOUS_LOGON_RID = $00000007; //+winnt + SECURITY_PROXY_RID = $00000008; //+winnt + SECURITY_ENTERPRISE_CONTROLLERS_RID = $00000009; //+winnt + SECURITY_SERVER_LOGON_RID = SECURITY_ENTERPRISE_CONTROLLERS_RID; //+winnt + SECURITY_PRINCIPAL_SELF_RID = $0000000A; //+winnt + SECURITY_AUTHENTICATED_USER_RID = $0000000B; //+winnt + SECURITY_RESTRICTED_CODE_RID = $0000000C; //+winnt + + SECURITY_LOCAL_SYSTEM_RID = $12; //winnt + SECURITY_NT_NON_UNIQUE = $00000015; //+winnt + SECURITY_BUILTIN_DOMAIN_RID = $20; //winnt + // Well-known users ... + DOMAIN_USER_RID_ADMIN = $1f4; //winnt + DOMAIN_USER_RID_GUEST = $1f5; //winnt + DOMAIN_USER_RID_KRBTGT = $000001F6; //+winnt + // well-known groups ... + DOMAIN_GROUP_RID_ADMINS = $200; //winnt + DOMAIN_GROUP_RID_USERS = $201; //winnt + DOMAIN_GROUP_RID_GUESTS = $00000202; //+winnt + DOMAIN_GROUP_RID_COMPUTERS = $00000203; //+winnt + DOMAIN_GROUP_RID_CONTROLLERS = $00000204; //+winnt + DOMAIN_GROUP_RID_CERT_ADMINS = $00000205; //+winnt + DOMAIN_GROUP_RID_SCHEMA_ADMINS = $00000206; //+winnt + DOMAIN_GROUP_RID_ENTERPRISE_ADMINS = $00000207; //+winnt + // well-known aliases ... + DOMAIN_ALIAS_RID_ADMINS = $220; //winnt + DOMAIN_ALIAS_RID_USERS = $221; //winnt + DOMAIN_ALIAS_RID_GUESTS = $222; //winnt + DOMAIN_ALIAS_RID_POWER_USERS = $223; //winnt + DOMAIN_ALIAS_RID_ACCOUNT_OPS = $224; //winnt + DOMAIN_ALIAS_RID_SYSTEM_OPS = $225; //winnt + DOMAIN_ALIAS_RID_PRINT_OPS = $226; //winnt + DOMAIN_ALIAS_RID_BACKUP_OPS = $227; //winnt + DOMAIN_ALIAS_RID_REPLICATOR = $228; //winnt + + // + // Allocate the System Luid. The first 1000 LUIDs are reserved. + // Use #999 here (0x3E7 = 999) + // + SYSTEM_LUID : LUID = ( LowPart: $3E7; HighPart: $0 ); + ANONYMOUS_LOGON_LUID : LUID = (LowPart: $3e6; HighPart: $0 ); + + // + // Group attributes + // + SE_GROUP_MANDATORY = $1; //winnt + SE_GROUP_ENABLED_BY_DEFAULT = $2; //winnt + SE_GROUP_ENABLED = $4; //winnt + SE_GROUP_OWNER = $8; //winnt + SE_GROUP_USE_FOR_DENY_ONLY = $00000010; //+winnt + SE_GROUP_LOGON_ID = $c0000000; //winnt + + { ACL Defines } + ACL_REVISION = 2; + ACL_REVISION_DS = 4; //+winnt + // This is the history of ACL revisions. Add a new one whenever + // ACL_REVISION is updated + ACL_REVISION1=1; //+winnt + ACL_REVISION2=2; //+winnt + ACL_REVISION3=3; //+winnt + ACL_REVISION4=4; //+winnt + MIN_ACL_REVISION=ACL_REVISION2; //+winnt + MAX_ACL_REVISION=ACL_REVISION4; //+winnt + { ACE_HEADER structure } + ACCESS_MIN_MS_ACE_TYPE = $0; //+winnt + ACCESS_ALLOWED_ACE_TYPE = $0; + ACCESS_DENIED_ACE_TYPE = $1; + SYSTEM_AUDIT_ACE_TYPE = $2; + SYSTEM_ALARM_ACE_TYPE = $3; + ACCESS_MAX_MS_V2_ACE_TYPE = $3; //+winnt + ACCESS_ALLOWED_COMPOUND_ACE_TYPE = $4; //+winnt + ACCESS_MAX_MS_V3_ACE_TYPE = $4; + + ACCESS_MIN_MS_OBJECT_ACE_TYPE = $5; //+winnt + ACCESS_ALLOWED_OBJECT_ACE_TYPE = $5; //+winnt + ACCESS_DENIED_OBJECT_ACE_TYPE = $6; //+winnt + SYSTEM_AUDIT_OBJECT_ACE_TYPE = $7; //+winnt + SYSTEM_ALARM_OBJECT_ACE_TYPE = $8; //+winnt + ACCESS_MAX_MS_OBJECT_ACE_TYPE = $8; //+winnt + + ACCESS_MAX_MS_V4_ACE_TYPE = $8; //+winnt + ACCESS_MAX_MS_ACE_TYPE = $8; //+winnt + + { ACE flags in the ACE_HEADER structure } + // + // The following are the inherit flags that go into the AceFlags field + // of an Ace header. + // + OBJECT_INHERIT_ACE = $1; //winnt + CONTAINER_INHERIT_ACE = $2; //winnt + NO_PROPAGATE_INHERIT_ACE = $4; //winnt + INHERIT_ONLY_ACE = $8; //winnt + INHERITED_ACE = $10; //+winnt + VALID_INHERIT_FLAGS = $1F; //+winnt + // The following are the currently defined ACE flags that go into the + // AceFlags field of an ACE header. Each ACE type has its own set of + // AceFlags. + // + // SUCCESSFUL_ACCESS_ACE_FLAG - used only with system audit and alarm ACE + // types to indicate that a message is generated for successful accesses. + // + // FAILED_ACCESS_ACE_FLAG - used only with system audit and alarm ACE types + // to indicate that a message is generated for failed accesses. + // + // + // SYSTEM_AUDIT and SYSTEM_ALARM AceFlags + // + // These control the signaling of audit and alarms for success or failure. + // + SUCCESSFUL_ACCESS_ACE_FLAG = $40; //winnt + FAILED_ACCESS_ACE_FLAG = $80; //winnt + { SECURITY_DESCRIPTOR_CONTROL } + {SECURITY_DESCRIPTOR_REVISION = 1;already defined above } + SECURITY_DESCRIPTOR_MIN_LENGTH = 20; + SE_OWNER_DEFAULTED = 1; + SE_GROUP_DEFAULTED = 2; + SE_DACL_PRESENT = 4; + SE_DACL_DEFAULTED = 8; + SE_SACL_PRESENT = 16; + SE_SACL_DEFAULTED = 32; + SE_SELF_RELATIVE = 32768; + { PRIVILEGE_SET } + SE_PRIVILEGE_ENABLED_BY_DEFAULT = $1; + SE_PRIVILEGE_ENABLED = $2; + SE_PRIVILEGE_USED_FOR_ACCESS = $80000000; + PRIVILEGE_SET_ALL_NECESSARY = $1; + { OPENFILENAME structure } + OFN_ALLOWMULTISELECT = $200; + OFN_CREATEPROMPT = $2000; + OFN_ENABLEHOOK = $20; + OFN_ENABLETEMPLATE = $40; + OFN_ENABLETEMPLATEHANDLE = $80; + OFN_EXPLORER = $80000; + OFN_EXTENSIONDIFFERENT = $400; + OFN_FILEMUSTEXIST = $1000; + OFN_HIDEREADONLY = $4; + OFN_LONGNAMES = $200000; + OFN_NOCHANGEDIR = $8; + OFN_NODEREFERENCELINKS = $100000; + OFN_NOLONGNAMES = $40000; + OFN_NONETWORKBUTTON = $20000; + OFN_NOREADONLYRETURN = $8000; + OFN_NOTESTFILECREATE = $10000; + OFN_NOVALIDATE = $100; + OFN_OVERWRITEPROMPT = $2; + OFN_PATHMUSTEXIST = $800; + OFN_READONLY = $1; + OFN_SHAREAWARE = $4000; + OFN_SHOWHELP = $10; + { SHAREVISTRING message } + OFN_SHAREFALLTHROUGH = $2; + OFN_SHARENOWARN = $1; + OFN_SHAREWARN = 0; + { Open/Save notifications } + CDN_INITDONE = $fffffda7; + CDN_SELCHANGE = $fffffda6; + CDN_FOLDERCHANGE = $fffffda5; + CDN_SHAREVIOLATION = $fffffda4; + CDN_HELP = $fffffda3; + CDN_FILEOK = $fffffda2; + CDN_TYPECHANGE = $fffffda1; + { Open/Save messages } + CDM_GETFILEPATH = $465; + CDM_GETFOLDERIDLIST = $467; + CDM_GETFOLDERPATH = $466; + CDM_GETSPEC = $464; + CDM_HIDECONTROL = $469; + CDM_SETCONTROLTEXT = $468; + CDM_SETDEFEXT = $46a; + { CHOOSECOLOR structure } + CC_ENABLEHOOK = $10; + CC_ENABLETEMPLATE = $20; + CC_ENABLETEMPLATEHANDLE = $40; + CC_FULLOPEN = $2; + CC_PREVENTFULLOPEN = $4; + CC_RGBINIT = $1; + CC_SHOWHELP = $8; + CC_SOLIDCOLOR = $80; + { FINDREPLACE structure } + FR_DIALOGTERM = $40; + FR_DOWN = $1; + FR_ENABLEHOOK = $100; + FR_ENABLETEMPLATE = $200; + FR_ENABLETEMPLATEHANDLE = $2000; + FR_FINDNEXT = $8; + FR_HIDEUPDOWN = $4000; + FR_HIDEMATCHCASE = $8000; + FR_HIDEWHOLEWORD = $10000; + FR_MATCHCASE = $4; + FR_NOMATCHCASE = $800; + FR_NOUPDOWN = $400; + FR_NOWHOLEWORD = $1000; + FR_REPLACE = $10; + FR_REPLACEALL = $20; + FR_SHOWHELP = $80; + FR_WHOLEWORD = $2; + { CHOOSEFONT structure } + CF_APPLY = $200; + CF_ANSIONLY = $400; + CF_BOTH = $3; + CF_TTONLY = $40000; + CF_EFFECTS = $100; + CF_ENABLEHOOK = $8; + CF_ENABLETEMPLATE = $10; + CF_ENABLETEMPLATEHANDLE = $20; + CF_FIXEDPITCHONLY = $4000; + CF_FORCEFONTEXIST = $10000; + CF_INITTOLOGFONTSTRUCT = $40; + CF_LIMITSIZE = $2000; + CF_NOOEMFONTS = $800; + CF_NOFACESEL = $80000; + CF_NOSCRIPTSEL = $800000; + CF_NOSTYLESEL = $100000; + CF_NOSIZESEL = $200000; + CF_NOSIMULATIONS = $1000; + CF_NOVECTORFONTS = $800; + CF_NOVERTFONTS = $1000000; + CF_PRINTERFONTS = $2; + CF_SCALABLEONLY = $20000; + CF_SCREENFONTS = $1; + CF_SCRIPTSONLY = $400; + CF_SELECTSCRIPT = $400000; + CF_SHOWHELP = $4; + CF_USESTYLE = $80; + CF_WYSIWYG = $8000; + BOLD_FONTTYPE = $100; + ITALIC_FONTTYPE = $200; + PRINTER_FONTTYPE = $4000; + REGULAR_FONTTYPE = $400; + SCREEN_FONTTYPE = $2000; + SIMULATED_FONTTYPE = $8000; + { Common dialog messages } + COLOROKSTRINGW = 'commdlg_ColorOK'; + FILEOKSTRINGW = 'commdlg_FileNameOK'; + FINDMSGSTRINGW = 'commdlg_FindReplace'; + HELPMSGSTRINGW = 'commdlg_help'; + LBSELCHSTRINGW = 'commdlg_LBSelChangedNotify'; + SETRGBSTRINGW = 'commdlg_SetRGBColor'; + SHAREVISTRINGW = 'commdlg_ShareViolation'; + COLOROKSTRINGA = 'commdlg_ColorOK'; + FILEOKSTRINGA = 'commdlg_FileNameOK'; + FINDMSGSTRINGA = 'commdlg_FindReplace'; + HELPMSGSTRINGA = 'commdlg_help'; + LBSELCHSTRINGA = 'commdlg_LBSelChangedNotify'; + SETRGBSTRINGA = 'commdlg_SetRGBColor'; + SHAREVISTRINGA = 'commdlg_ShareViolation'; +{$ifdef UNICODE} + + const + COLOROKSTRING = COLOROKSTRINGW; + FILEOKSTRING = FILEOKSTRINGW; + FINDMSGSTRING = FINDMSGSTRINGW; + HELPMSGSTRING = HELPMSGSTRINGW; + LBSELCHSTRING = LBSELCHSTRINGW; + SETRGBSTRING = SETRGBSTRINGW; + SHAREVISTRING = SHAREVISTRINGW; +{$else} + + const + COLOROKSTRING = COLOROKSTRINGA; + FILEOKSTRING = FILEOKSTRINGA; + FINDMSGSTRING = FINDMSGSTRINGA; + HELPMSGSTRING = HELPMSGSTRINGA; + LBSELCHSTRING = LBSELCHSTRINGA; + SETRGBSTRING = SETRGBSTRINGA; + SHAREVISTRING = SHAREVISTRINGA; +{$endif} + { LBSELCHSTRING message } + + const + CD_LBSELCHANGE = 0; + CD_LBSELADD = 2; + CD_LBSELSUB = 1; + CD_LBSELNOITEMS = -(1); + { DEVNAMES structure } + DN_DEFAULTPRN = 1; + { PRINTDLG structure } + PD_ALLPAGES = 0; + PD_COLLATE = 16; + PD_DISABLEPRINTTOFILE = 524288; + PD_ENABLEPRINTHOOK = 4096; + PD_ENABLEPRINTTEMPLATE = 16384; + PD_ENABLEPRINTTEMPLATEHANDLE = 65536; + PD_ENABLESETUPHOOK = 8192; + PD_ENABLESETUPTEMPLATE = 32768; + PD_ENABLESETUPTEMPLATEHANDLE = 131072; + PD_HIDEPRINTTOFILE = 1048576; + PD_NOPAGENUMS = 8; + PD_NOSELECTION = 4; + PD_NOWARNING = 128; + PD_PAGENUMS = 2; + PD_PRINTSETUP = 64; + PD_PRINTTOFILE = 32; + PD_RETURNDC = 256; + PD_RETURNDEFAULT = 1024; + PD_RETURNIC = 512; + PD_SELECTION = 1; + PD_SHOWHELP = 2048; + PD_USEDEVMODECOPIES = 262144; + PD_USEDEVMODECOPIESANDCOLLATE = 262144; + { PAGESETUPDLG structure } + PSD_DEFAULTMINMARGINS = 0; + PSD_DISABLEMARGINS = 16; + PSD_DISABLEORIENTATION = 256; + PSD_DISABLEPAGEPAINTING = 524288; + PSD_DISABLEPAPER = 512; + PSD_DISABLEPRINTER = 32; + PSD_ENABLEPAGEPAINTHOOK = 262144; + PSD_ENABLEPAGESETUPHOOK = 8192; + PSD_ENABLEPAGESETUPTEMPLATE = 32768; + PSD_ENABLEPAGESETUPTEMPLATEHANDLE = 131072; + PSD_INHUNDREDTHSOFMILLIMETERS = 8; + PSD_INTHOUSANDTHSOFINCHES = 4; + PSD_INWININIINTLMEASURE = 0; + PSD_MARGINS = 2; + PSD_MINMARGINS = 1; + PSD_NOWARNING = 128; + PSD_RETURNDEFAULT = 1024; + PSD_SHOWHELP = 2048; + { WM_SHOWWINDOW message } + SW_OTHERUNZOOM = 4; + SW_OTHERZOOM = 2; + SW_PARENTCLOSING = 1; + SW_PARENTOPENING = 3; + { Virtual Key codes } + VK_LBUTTON = 1; + VK_RBUTTON = 2; + VK_CANCEL = 3; + VK_MBUTTON = 4; + VK_BACK = 8; + VK_TAB = 9; + VK_CLEAR = 12; + VK_RETURN = 13; + VK_SHIFT = 16; + VK_CONTROL = 17; + VK_MENU = 18; + VK_PAUSE = 19; + VK_CAPITAL = 20; + VK_ESCAPE = 27; + VK_SPACE = 32; + VK_PRIOR = 33; + VK_NEXT = 34; + VK_END = 35; + VK_HOME = 36; + VK_LEFT = 37; + VK_UP = 38; + VK_RIGHT = 39; + VK_DOWN = 40; + VK_SELECT = 41; + VK_PRINT = 42; + VK_EXECUTE = 43; + VK_SNAPSHOT = 44; + VK_INSERT = 45; + VK_DELETE = 46; + VK_HELP = 47; + VK_0 = 48; + VK_1 = 49; + VK_2 = 50; + VK_3 = 51; + VK_4 = 52; + VK_5 = 53; + VK_6 = 54; + VK_7 = 55; + VK_8 = 56; + VK_9 = 57; + VK_A = 65; + VK_B = 66; + VK_C = 67; + VK_D = 68; + VK_E = 69; + VK_F = 70; + VK_G = 71; + VK_H = 72; + VK_I = 73; + VK_J = 74; + VK_K = 75; + VK_L = 76; + VK_M = 77; + VK_N = 78; + VK_O = 79; + VK_P = 80; + VK_Q = 81; + VK_R = 82; + VK_S = 83; + VK_T = 84; + VK_U = 85; + VK_V = 86; + VK_W = 87; + VK_X = 88; + VK_Y = 89; + VK_Z = 90; + VK_LWIN = 91; + VK_RWIN = 92; + VK_APPS = 93; + VK_NUMPAD0 = 96; + VK_NUMPAD1 = 97; + VK_NUMPAD2 = 98; + VK_NUMPAD3 = 99; + VK_NUMPAD4 = 100; + VK_NUMPAD5 = 101; + VK_NUMPAD6 = 102; + VK_NUMPAD7 = 103; + VK_NUMPAD8 = 104; + VK_NUMPAD9 = 105; + VK_MULTIPLY = 106; + VK_ADD = 107; + VK_SEPARATOR = 108; + VK_SUBTRACT = 109; + VK_DECIMAL = 110; + VK_DIVIDE = 111; + VK_F1 = 112; + VK_F2 = 113; + VK_F3 = 114; + VK_F4 = 115; + VK_F5 = 116; + VK_F6 = 117; + VK_F7 = 118; + VK_F8 = 119; + VK_F9 = 120; + VK_F10 = 121; + VK_F11 = 122; + VK_F12 = 123; + VK_F13 = 124; + VK_F14 = 125; + VK_F15 = 126; + VK_F16 = 127; + VK_F17 = 128; + VK_F18 = 129; + VK_F19 = 130; + VK_F20 = 131; + VK_F21 = 132; + VK_F22 = 133; + VK_F23 = 134; + VK_F24 = 135; + { GetAsyncKeyState } + VK_NUMLOCK = 144; + VK_SCROLL = 145; + VK_LSHIFT = 160; + VK_LCONTROL = 162; + VK_LMENU = 164; + VK_RSHIFT = 161; + VK_RCONTROL = 163; + VK_RMENU = 165; + { ImmGetVirtualKey } + VK_PROCESSKEY = 229; + { Keystroke Message Flags } + KF_ALTDOWN = 8192; + KF_DLGMODE = 2048; + KF_EXTENDED = 256; + KF_MENUMODE = 4096; + KF_REPEAT = 16384; + KF_UP = 32768; + { GetKeyboardLayoutName } + KL_NAMELENGTH = 9; + { WM_ACTIVATE message } + WA_ACTIVE = 1; + WA_CLICKACTIVE = 2; + WA_INACTIVE = 0; + { WM_ACTIVATE message } + PWR_CRITICALRESUME = 3; + PWR_SUSPENDREQUEST = 1; + PWR_SUSPENDRESUME = 2; + PWR_FAIL = -(1); + PWR_OK = 1; + { WM_NOTIFYFORMAT message } + NF_QUERY = 3; + NF_REQUERY = 4; + NFR_ANSI = 1; + NFR_UNICODE = 2; + { WM_SIZING message } + WMSZ_BOTTOM = 6; + WMSZ_BOTTOMLEFT = 7; + WMSZ_BOTTOMRIGHT = 8; + WMSZ_LEFT = 1; + WMSZ_RIGHT = 2; + WMSZ_TOP = 3; + WMSZ_TOPLEFT = 4; + WMSZ_TOPRIGHT = 5; + { WM_MOUSEACTIVATE message } + MA_ACTIVATE = 1; + MA_ACTIVATEANDEAT = 2; + MA_NOACTIVATE = 3; + MA_NOACTIVATEANDEAT = 4; + { WM_SIZE message } + SIZE_MAXHIDE = 4; + SIZE_MAXIMIZED = 2; + SIZE_MAXSHOW = 3; + SIZE_MINIMIZED = 1; + SIZE_RESTORED = 0; + { WM_NCCALCSIZE message } + WVR_ALIGNTOP = 16; + WVR_ALIGNLEFT = 32; + WVR_ALIGNBOTTOM = 64; + WVR_ALIGNRIGHT = 128; + WVR_HREDRAW = 256; + WVR_VREDRAW = 512; + WVR_REDRAW = 768; + WVR_VALIDRECTS = 1024; + { WM_NCHITTEST message } + HTBOTTOM = 15; + HTBOTTOMLEFT = 16; + HTBOTTOMRIGHT = 17; + HTCAPTION = 2; + HTCLIENT = 1; + HTERROR = -(2); + HTGROWBOX = 4; + HTHSCROLL = 6; + HTLEFT = 10; + HTMENU = 5; + HTNOWHERE = 0; + HTREDUCE = 8; + HTRIGHT = 11; + HTSIZE = 4; + HTSYSMENU = 3; + HTTOP = 12; + HTTOPLEFT = 13; + HTTOPRIGHT = 14; + HTTRANSPARENT = -(1); + HTVSCROLL = 7; + HTZOOM = 9; + { Mouse messages } + MK_CONTROL = 8; + MK_LBUTTON = 1; + MK_MBUTTON = 16; + MK_RBUTTON = 2; + MK_SHIFT = 4; + { WNDCLASS structure } + CS_BYTEALIGNCLIENT = 4096; + CS_BYTEALIGNWINDOW = 8192; + CS_CLASSDC = 64; + CS_DBLCLKS = 8; + CS_GLOBALCLASS = 16384; + CS_HREDRAW = 2; + CS_KEYCVTWINDOW = 4; + CS_NOCLOSE = 512; + CS_NOKEYCVT = 256; + CS_OWNDC = 32; + CS_PARENTDC = 128; + CS_SAVEBITS = 2048; + CS_VREDRAW = 1; + DLGWINDOWEXTRA = 30; + { ACCEL structure } + FALT = 16; + FCONTROL = 8; + FNOINVERT = 2; + FSHIFT = 4; + FVIRTKEY = 1; + { MENUITEMINFO structure } + MIIM_CHECKMARKS = 8; + MIIM_DATA = 32; + MIIM_ID = 2; + MIIM_STATE = 1; + MIIM_SUBMENU = 4; + MIIM_TYPE = 16; + MFT_BITMAP = $4; + MFT_MENUBARBREAK = $20; + MFT_MENUBREAK = $40; + MFT_OWNERDRAW = $100; + MFT_RADIOCHECK = $200; + MFT_RIGHTJUSTIFY = $4000; + MFT_SEPARATOR = $800; + MFT_STRING = 0; + MFS_CHECKED = $8; + MFS_DEFAULT = $1000; + MFS_DISABLED = $3; + MFS_ENABLED = 0; + MFS_GRAYED = $3; + MFS_HILITE = $80; + MFS_UNCHECKED = 0; + MFS_UNHILITE = 0; + { SERIALKEYS structure } + SERKF_AVAILABLE = 2; + SERKF_INDICATOR = 4; + SERKF_SERIALKEYSON = 1; + { FILTERKEYS structure } + FKF_AVAILABLE = 2; + FKF_CLICKON = 64; + FKF_FILTERKEYSON = 1; + FKF_HOTKEYACTIVE = 4; + FKF_HOTKEYSOUND = 16; + FKF_CONFIRMHOTKEY = 8; + FKF_INDICATOR = 32; + { HELPINFO structure } + HELPINFO_MENUITEM = 2; + HELPINFO_WINDOW = 1; + { WM_PRINT message } + PRF_CHECKVISIBLE = $1; + PRF_CHILDREN = $10; + PRF_CLIENT = $4; + PRF_ERASEBKGND = $8; + PRF_NONCLIENT = $2; + PRF_OWNED = $20; + { MapWindowPoints } + { was #define dname def_expr } + function HWND_DESKTOP : HWND; + + { WM_SYSCOMMAND message } + + const + SC_CLOSE = 61536; + SC_CONTEXTHELP = 61824; + SC_DEFAULT = 61792; + SC_HOTKEY = 61776; + SC_HSCROLL = 61568; + SC_KEYMENU = 61696; + SC_MAXIMIZE = 61488; + SC_ZOOM = 61488; + SC_MINIMIZE = 61472; + SC_ICON = 61472; + SC_MONITORPOWER = 61808; + SC_MOUSEMENU = 61584; + SC_MOVE = 61456; + SC_NEXTWINDOW = 61504; + SC_PREVWINDOW = 61520; + SC_RESTORE = 61728; + SC_SCREENSAVE = 61760; + SC_SIZE = 61440; + SC_TASKLIST = 61744; + SC_VSCROLL = 61552; + { DM_GETDEFID message } + DC_HASDEFID = 21323; + { WM_GETDLGCODE message } + DLGC_BUTTON = 8192; + DLGC_DEFPUSHBUTTON = 16; + DLGC_HASSETSEL = 8; + DLGC_RADIOBUTTON = 64; + DLGC_STATIC = 256; + DLGC_UNDEFPUSHBUTTON = 32; + DLGC_WANTALLKEYS = 4; + DLGC_WANTARROWS = 1; + DLGC_WANTCHARS = 128; + DLGC_WANTMESSAGE = 4; + DLGC_WANTTAB = 2; + { EM_SETMARGINS message } + EC_LEFTMARGIN = 1; + EC_RIGHTMARGIN = 2; + EC_USEFONTINFO = 65535; + { LB_SETCOUNT message } + LB_ERR = -(1); + LB_ERRSPACE = -(2); + LB_OKAY = 0; + { CB_DIR message } + CB_ERR = -(1); + CB_ERRSPACE = -(2); + { WM_IME_CONTROL message } + IMC_GETCANDIDATEPOS = 7; + IMC_GETCOMPOSITIONFONT = 9; + IMC_GETCOMPOSITIONWINDOW = 11; + IMC_GETSTATUSWINDOWPOS = 15; + IMC_CLOSESTATUSWINDOW = 33; + IMC_OPENSTATUSWINDOW = 34; + IMC_SETCANDIDATEPOS = 8; + IMC_SETCOMPOSITIONFONT = 10; + IMC_SETCOMPOSITIONWINDOW = 12; + IMC_SETSTATUSWINDOWPOS = 16; + { WM_IME_CONTROL message } + IMN_CHANGECANDIDATE = 3; + IMN_CLOSECANDIDATE = 4; + IMN_CLOSESTATUSWINDOW = 1; + IMN_GUIDELINE = 13; + IMN_OPENCANDIDATE = 5; + IMN_OPENSTATUSWINDOW = 2; + IMN_SETCANDIDATEPOS = 9; + IMN_SETCOMPOSITIONFONT = 10; + IMN_SETCOMPOSITIONWINDOW = 11; + IMN_SETCONVERSIONMODE = 6; + IMN_SETOPENSTATUS = 8; + IMN_SETSENTENCEMODE = 7; + IMN_SETSTATUSWINDOWPOS = 12; + IMN_PRIVATE = 14; + { STICKYKEYS structure } + SKF_AUDIBLEFEEDBACK = 64; + SKF_AVAILABLE = 2; + SKF_CONFIRMHOTKEY = 8; + SKF_HOTKEYACTIVE = 4; + SKF_HOTKEYSOUND = 16; + SKF_INDICATOR = 32; + SKF_STICKYKEYSON = 1; + SKF_TRISTATE = 128; + SKF_TWOKEYSOFF = 256; + { MOUSEKEYS structure } + MKF_AVAILABLE = 2; + MKF_CONFIRMHOTKEY = 8; + MKF_HOTKEYACTIVE = 4; + MKF_HOTKEYSOUND = 16; + MKF_INDICATOR = 32; + MKF_MOUSEKEYSON = 1; + MKF_MODIFIERS = 64; + MKF_REPLACENUMBERS = 128; + { SOUNDSENTRY structure } + SSF_AVAILABLE = 2; + SSF_SOUNDSENTRYON = 1; + SSTF_BORDER = 2; + SSTF_CHARS = 1; + SSTF_DISPLAY = 3; + SSTF_NONE = 0; + SSGF_DISPLAY = 3; + SSGF_NONE = 0; + SSWF_CUSTOM = 4; + SSWF_DISPLAY = 3; + SSWF_NONE = 0; + SSWF_TITLE = 1; + SSWF_WINDOW = 2; + { ACCESSTIMEOUT structure } + ATF_ONOFFFEEDBACK = 2; + ATF_TIMEOUTON = 1; + { HIGHCONTRAST structure } + HCF_AVAILABLE = 2; + HCF_CONFIRMHOTKEY = 8; + HCF_HIGHCONTRASTON = 1; + HCF_HOTKEYACTIVE = 4; + HCF_HOTKEYAVAILABLE = 64; + HCF_HOTKEYSOUND = 16; + HCF_INDICATOR = 32; + { TOGGLEKEYS structure } + TKF_AVAILABLE = 2; + TKF_CONFIRMHOTKEY = 8; + TKF_HOTKEYACTIVE = 4; + TKF_HOTKEYSOUND = 16; + TKF_TOGGLEKEYSON = 1; + { Installable Policy } + PP_DISPLAYERRORS = 1; + { SERVICE_INFO structure } + RESOURCEDISPLAYTYPE_DOMAIN = 1; + RESOURCEDISPLAYTYPE_FILE = 4; + RESOURCEDISPLAYTYPE_GENERIC = 0; + RESOURCEDISPLAYTYPE_GROUP = 5; + RESOURCEDISPLAYTYPE_SERVER = 2; + RESOURCEDISPLAYTYPE_SHARE = 3; + { KEY_EVENT_RECORD structure } + CAPSLOCK_ON = 128; + ENHANCED_KEY = 256; + LEFT_ALT_PRESSED = 2; + LEFT_CTRL_PRESSED = 8; + NUMLOCK_ON = 32; + RIGHT_ALT_PRESSED = 1; + RIGHT_CTRL_PRESSED = 4; + SCROLLLOCK_ON = 64; + SHIFT_PRESSED = 16; + { MOUSE_EVENT_RECORD structure } + FROM_LEFT_1ST_BUTTON_PRESSED = 1; + RIGHTMOST_BUTTON_PRESSED = 2; + FROM_LEFT_2ND_BUTTON_PRESSED = 4; + FROM_LEFT_3RD_BUTTON_PRESSED = 8; + FROM_LEFT_4TH_BUTTON_PRESSED = 16; + DOUBLE_CLICK = 2; + MOUSE_MOVED = 1; + { INPUT_RECORD structure } + KEY_EVENT = 1; + _MOUSE_EVENT = 2; {conflict with function mouse_event} + cMOUSE_EVENT = 2; + WINDOW_BUFFER_SIZE_EVENT = 4; + MENU_EVENT = 8; + FOCUS_EVENT = 16; + { BITMAPINFOHEADER structure } + BI_RGB = 0; + BI_RLE8 = 1; + BI_RLE4 = 2; + BI_BITFIELDS = 3; + { Extensions to OpenGL } + { ChoosePixelFormat } + PFD_DOUBLEBUFFER = $1; + PFD_STEREO = $2; + PFD_DRAW_TO_WINDOW = $4; + PFD_DRAW_TO_BITMAP = $8; + PFD_SUPPORT_GDI = $10; + PFD_SUPPORT_OPENGL = $20; + PFD_DEPTH_DONTCARE = $20000000; + PFD_DOUBLEBUFFER_DONTCARE = $40000000; + PFD_STEREO_DONTCARE = $80000000; + PFD_TYPE_RGBA = 0; + PFD_TYPE_COLORINDEX = 1; + PFD_MAIN_PLANE = 0; + PFD_OVERLAY_PLANE = 1; + PFD_UNDERLAY_PLANE = -(1); + { wglUseFontOutlines } + WGL_FONT_LINES = 0; + WGL_FONT_POLYGONS = 1; + { LAYERPLANEDESCRIPTOR structure } + { PIXELFORMATDESCRIPTOR structure } + PFD_GENERIC_FORMAT = $40; + PFD_NEED_PALETTE = $80; + PFD_NEED_SYSTEM_PALETTE = $100; + PFD_SWAP_EXCHANGE = $200; + PFD_SWAP_COPY = $400; + PFD_SWAP_LAYER_BUFFERS = $800; + PFD_GENERIC_ACCELERATED = $1000; + PFD_SUPPORT_DIRECTDRAW = $2000; + { TEXTMETRIC structure } + TMPF_FIXED_PITCH = $1; + TMPF_VECTOR = $2; + TMPF_TRUETYPE = $4; + TMPF_DEVICE = $8; + WM_CTLCOLOR = 25; + + { --------------------- old stuff, need to organize! --------------- } + { BEGINNING of windowsx.h stuff from old headers: } + { Not convertable by H2PAS + #define __CRACK_VOID_F(fn,args) (void)(fn args) + #define __CRACK_BOOL_F(fn,args) (BOOL)(fn args) + #define __CRACK_HMENU_F(fn,args) (HMENU)(fn args) + #define __CRACK_HWND_F(fn,args) (HWND)(fn args) + #define __CRACK_LONG_F(fn, args) (LRESULT)(fn args) + #define __CRACK_ZERO_F(fn, args) (fn args,0) + } + { was #define dname(params) def_expr } + function GetFirstChild(h:HWND):HWND; + + { was #define dname(params) def_expr } + function GetNextSibling(h:HWND):HWND; + + { was #define dname(params) def_expr } + function GetWindowID(h:HWND):longint; + + { was #define dname(params) def_expr } + function SubclassWindow(h:HWND; p:LONG):LONG; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_COMMAND_CMD(w,l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_COMMAND_ID(w,l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_CTLCOLOR_HDC(w,l,msg : longint) : HDC; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_CTLCOLOR_HWND(w,l,msg : longint) : HWND; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_HSCROLL_CODE(w,l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_HSCROLL_HWND(w,l : longint) : HWND; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_HSCROLL_POS(w,l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_MDIACTIVATE_FACTIVATE(h,a,b : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_MDIACTIVATE_HWNDACTIVATE(a,b : longint) : HWND; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_MDIACTIVATE_HWNDDEACT(a,b : longint) : HWND; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_VSCROLL_CODE(w,l : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_VSCROLL_HWND(w,l : longint) : HWND; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_VSCROLL_POS(w,l : longint) : longint; + { return type might be wrong } + + { Not convertable by H2PAS + #define FORWARD_WM_CLOSE(h, fn) __CRACK_VOID_F(fn,(h, WM_CLOSE, 0, 0)) + #define FORWARD_WM_COMMAND(h, id, c, n, fn) __CRACK_VOID_F(fn,(h, WM_COMMAND, MAKEWPARAM(id,n), (LPARAM)c)) + #define FORWARD_WM_CREATE(h, p, fn) __CRACK_BOOL_F(fn,(h, WM_CREATE, 0, (LPARAM)p)) + #define FORWARD_WM_DESTROY(h, fn) __CRACK_VOID_F(fn,(h, WM_DESTROY, 0, 0)) + #define FORWARD_WM_ENABLE(h, e, fn) __CRACK_VOID_F(fn,(h, WM_ENABLE, (WPARAM)e, 0)) + #define FORWARD_WM_INITDIALOG(h, c, l, fn) __CRACK_BOOL_F(fn,(h, WM_INITDIALOG, (WPARAM)c, l)) + #define FORWARD_WM_MDICASCADE(h, c, fn) __CRACK_BOOL_F(fn,(h, WM_MDICASCADE, (WPARAM)c, 0)) + #define FORWARD_WM_MDIDESTROY(h, d, fn) __CRACK_VOID_F(fn,(h, WM_MDIDESTROY, (WPARAM)d, 0)) + #define FORWARD_WM_MDIGETACTIVE(h, fn) __CRACK_HWND_F(fn,(h, WM_MDIGETACTIVE, 0, 0)) + #define FORWARD_WM_MDIICONARRANGE(h, fn) __CRACK_VOID_F(fn,(h, WM_MDIICONARRANGE, 0, 0)) + #define FORWARD_WM_MDISETMENU(h, fr, hf, hw, fn) __CRACK_HMENU_F(fn,(h, WM_MDISETMENU, (WPARAM)((fr) ? (hf) : 0), (LPARAM)(hw))) + #define FORWARD_WM_MDITILE(h, c, fn) __CRACK_BOOL_F(fn,(h, WM_MDITILE, (WPARAM)(c), 0)) + #define FORWARD_WM_PAINT(h, fn) __CRACK_VOID_F(fn,(h, WM_PAINT, 0, 0)) + #define FORWARD_WM_QUERYENDSESSION(h, fn) __CRACK_BOOL_F(fn,(h, WM_QUERYENDSESSION, 0, 0)) + #define FORWARD_WM_SIZE(h, state, cx, cy, fn) __CRACK_VOID_F(fn,(h, WM_SIZE, (WPARAM)state, MAKELPARAM(cx, cy))) + #define FORWARD_WM_SYSCOMMAND(h, c, x, y, fn) __CRACK_VOID_F(fn,(h, WM_SYSCOMMAND, (WPARAM)c, MAKELPARAM(x, y))) + + #define HANDLE_WM_CLOSE(h, w, l, fn) __CRACK_ZERO_F(fn,(h)); + #define HANDLE_WM_COMMAND(h, w, l, fn) __CRACK_ZERO_F(fn,(h, SEXT_LOWORD(w), (HWND)l, HIWORD(w))) + #define HANDLE_WM_CREATE(h, w, l, fn) (LRESULT)((fn(h, (CREATESTRUCT )l)) ? 0 : -1) + #define HANDLE_WM_DESTROY(h, w, l, fn) __CRACK_ZERO_F(fn,(h)) + #define HANDLE_WM_ENABLE(h, w, l, fn) __CRACK_ZERO_F(fn,(h, (BOOL)w)) + #define HANDLE_WM_INITDIALOG(h, w, l, fn) __CRACK_LONG_F(fn,(h, (HWND)w, l)) + #define HANDLE_WM_MDICASCADE(h, w, l, fn) __CRACK_LONG_F(fn, (h, (UINT)w) + #define HANDLE_WM_MDIDESTROY(h, w, l, fn) __CRACK_ZERO_F(fn,(h, (HWND)w)) + #define HANDLE_WM_MDIGETACTIVE(h, w, l, fn) __CRACK_LONG_F(fn,(h)) + #define HANDLE_WM_MDIICONARRANGE(h, w, l, fn) __CRACK_ZERO_F(fn,(h)) + #define HANDLE_WM_MDISETMENU(h, w, l, fn) __CRACK_LONG_F(fn,(h, (BOOL)w, (HMENU)w, (HMENU)l) + #define HANDLE_WM_MDITILE(h, w, l, fn) __CRACK_LONG_F(fn,(h, (UINT)w)) + #define HANDLE_WM_PAINT(h, w, l, fn) __CRACK_ZERO_F(fn,(h)) + #define HANDLE_WM_QUERYENDSESSION(h, w, l, fn) MAKELRESULT(fn(h), 0) + #define HANDLE_WM_SIZE(h, w, l, fn) __CRACK_ZERO_F(fn,(h, (UINT)w, SEXT_LOWORD(l), SEXT_HIWORD(l))) + #define HANDLE_WM_SYSCOMMAND(h, w, l, fn) __CRACK_ZERO_F(fn,(h, (UINT)w, SEXT_LOWORD(l), SEXT_HIWORD(l))) + } + { Totally disgusting! get wParam and lParam from the environment ! } + { Not convertable by H2PAS + #define HANDLE_MSG(h, message, fn) case message: return HANDLE_##message(h, wParam, lParam, fn) + } + { END OF windowsx.h stuff from old headers } + { ------------------------------------------------------------------ } + { BEGINNING of shellapi.h stuff from old headers } + + const + SE_ERR_SHARE = 26; + SE_ERR_ASSOCINCOMPLETE = 27; + SE_ERR_DDETIMEOUT = 28; + SE_ERR_DDEFAIL = 29; + SE_ERR_DDEBUSY = 30; + SE_ERR_NOASSOC = 31; + { END OF shellapi.h stuff from old headers } + { ------------------------------------------------------------------ } + { From ddeml.h in old Cygnus headers } + XCLASS_BOOL = $1000; + XCLASS_DATA = $2000; + XCLASS_FLAGS = $4000; + XCLASS_MASK = $fc00; + XCLASS_NOTIFICATION = $8000; + XTYPF_NOBLOCK = $0002; + XTYP_ADVDATA = $4010; + XTYP_ADVREQ = $2022; + XTYP_ADVSTART = $1030; + XTYP_ADVSTOP = $8040; + XTYP_CONNECT = $1062; + XTYP_CONNECT_CONFIRM = $8072; + XTYP_DISCONNECT = $80c2; + XTYP_EXECUTE = $4050; + XTYP_POKE = $4090; + XTYP_REQUEST = $20b0; + XTYP_WILDCONNECT = $20E2; + XTYP_REGISTER = $80A2; + XTYP_ERROR = $8002; + XTYP_XACT_COMPLETE = $8080; + XTYP_UNREGISTER = $80D2; + DMLERR_DLL_USAGE = $4004; + DMLERR_INVALIDPARAMETER = $4006; + DMLERR_NOTPROCESSED = $4009; + DMLERR_POSTMSG_FAILED = $400c; + DMLERR_SERVER_DIED = $400e; + DMLERR_SYS_ERROR = $400f; + DMLERR_BUSY = $4001; + DMLERR_DATAACKTIMEOUT = $4002; + DMLERR_ADVACKTIMEOUT = $4000; + DMLERR_DLL_NOT_INITIALIZED = $4003; + DMLERR_LOW_MEMORY = $4007; + DMLERR_MEMORY_ERROR = $4008; + DMLERR_POKEACKTIMEOUT = $400b; + DMLERR_NO_CONV_ESTABLISHED = $400a; + DMLERR_REENTRANCY = $400d; + DMLERR_UNFOUND_QUEUE_ID = $4011; + DMLERR_UNADVACKTIMEOUT = $4010; + DMLERR_EXECACKTIMEOUT = $4005; + DDE_FACK = $8000; + DDE_FNOTPROCESSED = $0000; + DNS_REGISTER = $0001; + DNS_UNREGISTER = $0002; + CP_WINANSI = 1004; + CP_WINUNICODE = 1200; + { Not convertable by H2PAS + #define EXPENTRY CALLBACK + } + APPCLASS_STANDARD = $00000000; + { End of stuff from ddeml.h in old Cygnus headers } + { ----------------------------------------------- } + BKMODE_LAST = 2; + CTLCOLOR_MSGBOX = 0; + CTLCOLOR_EDIT = 1; + CTLCOLOR_LISTBOX = 2; + CTLCOLOR_BTN = 3; + CTLCOLOR_DLG = 4; + CTLCOLOR_SCROLLBAR = 5; + CTLCOLOR_STATIC = 6; + CTLCOLOR_MAX = 7; + META_SETMAPMODE = $0103; + META_SETWINDOWORG = $020B; + META_SETWINDOWEXT = $020C; + POLYFILL_LAST = 2; + STATUS_WAIT_0 = $00000000; + STATUS_ABANDONED_WAIT_0 = $00000080; + STATUS_USER_APC = $000000C0; + STATUS_TIMEOUT = $00000102; + STATUS_PENDING = $00000103; + STATUS_GUARD_PAGE_VIOLATION = $80000001; + STATUS_DATATYPE_MISALIGNMENT = $80000002; + STATUS_BREAKPOINT = $80000003; + STATUS_SINGLE_STEP = $80000004; + STATUS_IN_PAGE_ERROR = $C0000006; + STATUS_INVALID_HANDLE = $C0000008; + STATUS_ILLEGAL_INSTRUCTION = $C000001D; + STATUS_NONCONTINUABLE_EXCEPTION = $C0000025; + STATUS_INVALID_DISPOSITION = $C0000026; + STATUS_ARRAY_BOUNDS_EXCEEDED = $C000008C; + STATUS_FLOAT_DENORMAL_OPERAND = $C000008D; + STATUS_FLOAT_DIVIDE_BY_ZERO = $C000008E; + STATUS_FLOAT_INEXACT_RESULT = $C000008F; + STATUS_FLOAT_INVALID_OPERATION = $C0000090; + STATUS_FLOAT_OVERFLOW = $C0000091; + STATUS_FLOAT_STACK_CHECK = $C0000092; + STATUS_FLOAT_UNDERFLOW = $C0000093; + STATUS_INTEGER_DIVIDE_BY_ZERO = $C0000094; + STATUS_INTEGER_OVERFLOW = $C0000095; + STATUS_PRIVILEGED_INSTRUCTION = $C0000096; + STATUS_STACK_OVERFLOW = $C00000FD; + STATUS_CONTROL_C_EXIT = $C000013A; +{$define EXCEPTION_CTRL_C} + PROCESSOR_ARCHITECTURE_INTEL = 0; + PROCESSOR_ARCHITECTURE_MIPS = 1; + PROCESSOR_ARCHITECTURE_ALPHA = 2; + PROCESSOR_ARCHITECTURE_PPC = 3; + { was #define dname(params) def_expr } + function FreeModule(h:HINST):WINBOOL; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function MakeProcInstance(p,i : longint) : longint; + { return type might be wrong } + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function FreeProcInstance(p : longint) : longint; + { return type might be wrong } + + + const + { _fmemcpy = memcpy; these are functions } + { Used by wxwindows. } + SIZEFULLSCREEN = SIZE_MAXIMIZED; + SIZENORMAL = SIZE_RESTORED; + SIZEICONIC = SIZE_MINIMIZED; + { NPLOGPALETTE = PLOGPALETTE; probably a type } + { In the old winnt.h } + (* Not convertable by H2PAS anyhow with if 0 + #if 0 + #ifdef __ANAL__ + #define DECLARE_HANDLE(h) struct h##__ { int dummy; }; typedef struct h##__ h + #else + #define DECLARE_HANDLE(h) typedef void h + #endif + DECLARE_HANDLE(HANDLE); + #endif + *) + +{$ifdef _X86_} //+winnt + + { x86 } + { The doc refered me to winnt.h, so I had to look... } + + const + SIZE_OF_80387_REGISTERS = 80; //winnt + MAXIMUM_SUPPORTED_EXTENSION = 512; //winnt + { Values for contextflags } + CONTEXT_i386 = $10000; + CONTEXT_i486 = $10000; //+winnt + CONTEXT_CONTROL = CONTEXT_i386 or 1; + CONTEXT_INTEGER = CONTEXT_i386 or 2; + CONTEXT_SEGMENTS = CONTEXT_i386 or 4; + CONTEXT_FLOATING_POINT = CONTEXT_i386 or 8; + CONTEXT_DEBUG_REGISTERS = CONTEXT_i386 or $10; + CONTEXT_EXTENDED_REGISTERS = CONTEXT_i386 or $20; //+winnt + CONTEXT_FULL = (CONTEXT_CONTROL or CONTEXT_INTEGER) or CONTEXT_SEGMENTS; + { our own invention } + FLAG_TRACE_BIT = $100; + CONTEXT_DEBUGGER = CONTEXT_FULL or CONTEXT_FLOATING_POINT; +{$endif _X86_} + +{$ifdef _MIPS_} //+winnt all block added +// +// Processor Feature Values used in IsProcessorFeaturePresent API +// + PF_MIPS_MIPSII = $81000001; // MIPSII instruction set + PF_MIPS_MIPSIII = $81000002; // MIPSIII instruction set + PF_MIPS_MIPSIV = $81000003; // MIPSIV instruction set + PF_MIPS_SMART_ASE = $81000004; // MIPS smart card arch. specific ext. + PF_MIPS_MIPS16 = $81000005; // MIPS16 instruction set + PF_MIPS_MIPS32 = $81000006; // MIPS32 instruction set + PF_MIPS_MIPS64 = $81000007; // MIPS64 instruction set + PF_MIPS_FPU = $81000008; // FPU support + PF_MIPS_CPU_4KEX = $81000009; // "R4K" exception model + PF_MIPS_CPU_4KTLB = $8100000A; // "R4K" TLB handler + PF_MIPS_CPU_32FPR = $8100000B; // 32 dbl. prec. FP registers + PF_MIPS_CPU_COUNTER = $8100000C; // Cycle count/compare + PF_MIPS_CPU_WATCH = $8100000D; // watchpoint registers + PF_MIPS_CPU_DIVEC = $8100000E; // dedicated interrupt vector + PF_MIPS_CPU_VCE = $8100000F; // virt. coherence conflict possible + PF_MIPS_CPU_CACHE_CDEX = $81000010; // Create_Dirty_Exclusive CACHE op + PF_MIPS_CPU_MCHECK = $81000011; // Machine check exception + PF_MIPS_CPU_EJTAG = $81000012; // EJTAG exception + PF_MIPS_PERF_COUNTER = $81000013; // perf counter + PF_MIPS_ARCH_2 = $81000014; // arch. release 2 + + CONTEXT_R4000 = $00010000; // r4000 context + + CONTEXT_CONTROL = CONTEXT_R4000 or $00000001; + CONTEXT_FLOATING_POINT = CONTEXT_R4000 or $00000002; + CONTEXT_INTEGER = CONTEXT_R4000 or $00000004; + CONTEXT_EXTENDED_FLOAT = CONTEXT_FLOATING_POINT or $00000008; + CONTEXT_EXTENDED_INTEGER = CONTEXT_INTEGER or $00000010; + CONTEXT_FULL = CONTEXT_CONTROL or CONTEXT_FLOATING_POINT or + CONTEXT_INTEGER or CONTEXT_EXTENDED_INTEGER; +{$ifdef _MIPS64} //+winnt + CONTEXT32_LENGTH=$1B8; +{$else} + CONTEXT32_LENGTH=$130; // The original 32-bit Context length (pre NT 4.0) +{$endif _MIPS64} + +{$endif _MIPS_} //+winnt + +{$ifdef _PPC_} //~winnt, now _PPC_ instead of __PPC__, moved after mips + const + CONTEXT_CONTROL = 1; + CONTEXT_FLOATING_POINT = 2; + CONTEXT_INTEGER = 4; + CONTEXT_DEBUG_REGISTERS = 8; + CONTEXT_FULL = (CONTEXT_CONTROL or CONTEXT_FLOATING_POINT) or CONTEXT_INTEGER; + CONTEXT_DEBUGGER = CONTEXT_FULL; +{$endif _PPC_} //~winnt + +{$ifdef _MPPC_} //+winnt all block + const + CONTEXT_CONTROL = 1; + CONTEXT_FLOATING_POINT = 2; + CONTEXT_INTEGER = 4; + CONTEXT_DEBUG_REGISTERS = 8; + CONTEXT_FULL = (CONTEXT_CONTROL or CONTEXT_FLOATING_POINT) or CONTEXT_INTEGER; +{$endif _MPPC_} //+winnt + +{$ifdef _IA64_} //+winnt all block + SIZE_OF_80387_REGISTERS = 80; + CONTEXT_IA64 = $00080000; // IA64 context + CONTEXT_CONTROL = CONTEXT_IA64 or $00000001; + CONTEXT_LOWER_FLOATING_POINT = CONTEXT_IA64 or $00000002; + CONTEXT_HIGHER_FLOATING_POINT = CONTEXT_IA64 or $00000004; + CONTEXT_INTEGER = CONTEXT_IA64 or $00000008; + CONTEXT_DEBUG = CONTEXT_IA64 or $00000010; + + CONTEXT_FLOATING_POINT = CONTEXT_LOWER_FLOATING_POINT or CONTEXT_HIGHER_FLOATING_POINT; + CONTEXT_FULL = CONTEXT_CONTROL or CONTEXT_FLOATING_POINT or CONTEXT_INTEGER; + + CONTEXT_i386 = $00010000; // this assumes that i386 and + CONTEXT_i486 = $00010000; // i486 have identical context records + CONTEXT_X86 = $00010000; // X86 have identical context records + + CONTEXT86_CONTROL = CONTEXT_i386 or $00000001; // SS:SP, CS:IP, FLAGS, BP + CONTEXT86_INTEGER = CONTEXT_i386 or $00000002; // AX, BX, CX, DX, SI, DI + CONTEXT86_SEGMENTS = CONTEXT_i386 or $00000004; // DS, ES, FS, GS + CONTEXT86_FLOATING_POINT = CONTEXT_i386 or $00000008; // 387 state + CONTEXT86_DEBUG_REGISTERS = CONTEXT_i386 or $00000010; // DB 0-3,6,7 + + CONTEXT86_FULL = CONTEXT86_CONTROL or CONTEXT86_INTEGER or CONTEXT86_SEGMENTS; // context corresponding to set flags will be returned. +{$endif _IA64_} //+winnt + +{$ifdef SHx} //+winnt all block added +// +// Processor Feature Values used in IsProcessorFeaturePresent API +// + PF_SHX_SH3 = $82000001; + PF_SHX_SH4 = $82000002; + PF_SHX_SH5 = $82000003; + PF_SHX_DSP = $82000004; + PF_SHX_FPU = $82000005; +// +// The following flags control the contents of the CONTEXT structure. +// + CONTEXT_SH3 = $00000040; + CONTEXT_SH4 = $000000c0; // CONTEXT_SH3 | 0x80 - must contain the SH3 bits + +{$ifdef SH3} + CONTEXT_CONTROL = CONTEXT_SH3 or $00000001; + CONTEXT_INTEGER = CONTEXT_SH3 or $00000002; + CONTEXT_DEBUG_REGISTERS = CONTEXT_SH3 or $00000008; + CONTEXT_DSP_REGISTERS = CONTEXT_SH3 or $00000010; + CONTEXT_FULL = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_DEBUG_REGISTERS or CONTEXT_DSP_REGISTERS; +{$else} // SH4 + CONTEXT_CONTROL = CONTEXT_SH4 or $00000001; + CONTEXT_INTEGER = CONTEXT_SH4 or $00000002; + CONTEXT_DEBUG_REGISTERS = CONTEXT_SH4 or $00000008; + CONTEXT_FLOATING_POINT = CONTEXT_SH4 or $00000004; + CONTEXT_FULL = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_DEBUG_REGISTERS or CONTEXT_FLOATING_POINT; +{$endif SH3} + +{$endif SHx} //+winnt + +{$ifdef ARM} //+winnt all block added +// +// Processor Feature Values used in IsProcessorFeaturePresent API +// + PF_ARM_V4 = $80000001; + PF_ARM_V5 = $80000002; + PF_ARM_V6 = $80000003; + PF_ARM_V7 = $80000004; + PF_ARM_THUMB = $80000005; + PF_ARM_JAZELLE = $80000006; + PF_ARM_DSP = $80000007; + PF_ARM_MOVE_CP = $80000008; + PF_ARM_VFP10 = $80000009; + PF_ARM_MPU = $8000000A; + PF_ARM_WRITE_BUFFER = $8000000B; + PF_ARM_MBX = $8000000C; + PF_ARM_L2CACHE = $8000000D; + PF_ARM_PHYSICALLY_TAGGED_CACHE = $8000000E; + PF_ARM_VFP_SINGLE_PRECISION = $8000000F; + PF_ARM_VFP_DOUBLE_PRECISION = $80000010; + PF_ARM_ITCM = $80000011; + PF_ARM_DTCM = $80000012; + PF_ARM_UNIFIED_CACHE = $80000013; + PF_ARM_WRITE_BACK_CACHE = $80000014; + PF_ARM_CACHE_CAN_BE_LOCKED_DOWN = $80000015; + PF_ARM_L2CACHE_MEMORY_MAPPED = $80000016; + PF_ARM_L2CACHE_COPROC = $80000017; + + +// Specific OEM extentions + PF_ARM_INTEL_XSCALE = $80010001; + PF_ARM_INTEL_PMU = $80010002; + PF_ARM_INTEL_WMMX = $80010003; + + CONTEXT_ARM = $0000040; + CONTEXT_CONTROL = CONTEXT_ARM or $00000001; + CONTEXT_INTEGER = CONTEXT_ARM or $00000002; + CONTEXT_FLOATING_POINT = CONTEXT_ARM or $00000004; + + CONTEXT_FULL = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_FLOATING_POINT; + + NUM_VFP_REGS = 32; + NUM_EXTRA_CONTROL_REGS = 8; + +{$endif ARM} //+winnt + + const + { ASCIICHAR = AsciiChar; this is the kind of thing that can + make problems for FPC !! } + { ignored in H2PAS + #define FAR + handled in H2PAS + #define PACKED __attribute__((packed)) + } + FILTER_TEMP_DUPLICATE_ACCOUNT = $0001; + FILTER_NORMAL_ACCOUNT = $0002; + FILTER_INTERDOMAIN_TRUST_ACCOUNT = $0008; + FILTER_WORKSTATION_TRUST_ACCOUNT = $0010; + FILTER_SERVER_TRUST_ACCOUNT = $0020; + LOGON32_LOGON_INTERACTIVE = $02; + LOGON32_LOGON_BATCH = $04; + LOGON32_LOGON_SERVICE = $05; + LOGON32_PROVIDER_DEFAULT = $00; + LOGON32_PROVIDER_WINNT35 = $01; + QID_SYNC = $FFFFFFFF; + { Magic numbers in PE executable header. } + { e_magic field } + IMAGE_DOS_SIGNATURE = $5a4d; + { nt_signature field } + IMAGE_NT_SIGNATURE = $4550; + + + { Severity values } + SEVERITY_SUCCESS = 0; + SEVERITY_ERROR = 1; + + { Variant type codes (wtypes.h). + Some, not all though } + VT_EMPTY = 0; + VT_NULL = 1; + VT_I2 = 2; + VT_I4 = 3; + VT_R4 = 4; + VT_R8 = 5; + VT_BSTR = 8; + VT_ERROR = 10; + VT_BOOL = 11; + VT_UI1 = 17; + VT_BYREF = $4000; + VT_RESERVED = $8000; + +{ Define the facility codes } + +const + FACILITY_WINDOWS = 8; + FACILITY_STORAGE = 3; + FACILITY_RPC = 1; + FACILITY_SSPI = 9; + FACILITY_WIN32 = 7; + FACILITY_CONTROL = 10; + FACILITY_NULL = 0; + FACILITY_INTERNET = 12; + FACILITY_ITF = 4; + FACILITY_DISPATCH = 2; + FACILITY_CERT = 11; + +{ Manually added, bug 2672} + ICON_SMALL = 0; + ICON_BIG = 1; + + // For the TRackMouseEvent + TME_HOVER = $00000001; + TME_LEAVE = $00000002; + TME_QUERY = $40000000; + TME_CANCEL = DWORD($80000000); + HOVER_DEFAULT = DWORD($FFFFFFFF); + +// Manually added, bug 3270 + COLOR_HOTLIGHT = 26; + COLOR_GRADIENTACTIVECAPTION = 27; + COLOR_GRADIENTINACTIVECAPTION = 28; + COLOR_MENUHILIGHT = 29; + COLOR_MENUBAR = 30; + + WM_APP = $8000; + + + +{$endif read_interface} + + +{$ifdef read_implementation} + + { was #define dname def_expr } + function UNICODE_NULL : WCHAR; + begin + UNICODE_NULL:=#0; + end; + + { was #define dname def_expr } + function RT_ACCELERATOR : LPTSTR; + { return type might be wrong } + begin + RT_ACCELERATOR:=MAKEINTRESOURCE(9); + end; + + { was #define dname def_expr } + function RT_BITMAP : LPTSTR; + { return type might be wrong } + begin + RT_BITMAP:=MAKEINTRESOURCE(2); + end; + + { was #define dname def_expr } + function RT_DIALOG : LPTSTR; + { return type might be wrong } + begin + RT_DIALOG:=MAKEINTRESOURCE(5); + end; + + { was #define dname def_expr } + function RT_FONT : LPTSTR; + { return type might be wrong } + begin + RT_FONT:=MAKEINTRESOURCE(8); + end; + + { was #define dname def_expr } + function RT_FONTDIR : LPTSTR; + { return type might be wrong } + begin + RT_FONTDIR:=MAKEINTRESOURCE(7); + end; + + { was #define dname def_expr } + function RT_MENU : LPTSTR; + { return type might be wrong } + begin + RT_MENU:=MAKEINTRESOURCE(4); + end; + + { was #define dname def_expr } + function RT_RCDATA : LPTSTR; + { return type might be wrong } + begin + RT_RCDATA:=MAKEINTRESOURCE(10); + end; + + { was #define dname def_expr } + function RT_STRING : LPTSTR; + { return type might be wrong } + begin + RT_STRING:=MAKEINTRESOURCE(6); + end; + + { was #define dname def_expr } + function RT_MESSAGETABLE : LPTSTR; + { return type might be wrong } + begin + RT_MESSAGETABLE:=MAKEINTRESOURCE(11); + end; + + { was #define dname def_expr } + function RT_CURSOR : LPTSTR; + { return type might be wrong } + begin + RT_CURSOR:=MAKEINTRESOURCE(1); + end; + + { was #define dname def_expr } + function RT_GROUP_CURSOR : LPTSTR; + { return type might be wrong } + begin + RT_GROUP_CURSOR:=MAKEINTRESOURCE(12); + end; + + { was #define dname def_expr } + function RT_ICON : LPTSTR; + { return type might be wrong } + begin + RT_ICON:=MAKEINTRESOURCE(3); + end; + + { was #define dname def_expr } + function RT_GROUP_ICON : LPTSTR; + { return type might be wrong } + begin + RT_GROUP_ICON:=MAKEINTRESOURCE(13); + end; + + { was #define dname def_expr } + function RT_VERSION : LPTSTR; + { return type might be wrong } + begin + RT_VERSION:=MAKEINTRESOURCE(16); + end; + + { was #define dname def_expr } + function IDC_ARROW : LPTSTR; + { return type might be wrong } + begin + IDC_ARROW:=MAKEINTRESOURCE(32512); + end; + + { was #define dname def_expr } + function IDC_IBEAM : LPTSTR; + { return type might be wrong } + begin + IDC_IBEAM:=MAKEINTRESOURCE(32513); + end; + + { was #define dname def_expr } + function IDC_WAIT : LPTSTR; + { return type might be wrong } + begin + IDC_WAIT:=MAKEINTRESOURCE(32514); + end; + + { was #define dname def_expr } + function IDC_CROSS : LPTSTR; + { return type might be wrong } + begin + IDC_CROSS:=MAKEINTRESOURCE(32515); + end; + + { was #define dname def_expr } + function IDC_UPARROW : LPTSTR; + { return type might be wrong } + begin + IDC_UPARROW:=MAKEINTRESOURCE(32516); + end; + + { was #define dname def_expr } + function IDC_SIZENWSE : LPTSTR; + { return type might be wrong } + begin + IDC_SIZENWSE:=MAKEINTRESOURCE(32642); + end; + + { was #define dname def_expr } + function IDC_SIZENESW : LPTSTR; + { return type might be wrong } + begin + IDC_SIZENESW:=MAKEINTRESOURCE(32643); + end; + + { was #define dname def_expr } + function IDC_SIZEWE : LPTSTR; + { return type might be wrong } + begin + IDC_SIZEWE:=MAKEINTRESOURCE(32644); + end; + + { was #define dname def_expr } + function IDC_SIZENS : LPTSTR; + { return type might be wrong } + begin + IDC_SIZENS:=MAKEINTRESOURCE(32645); + end; + + { was #define dname def_expr } + function IDC_SIZEALL : LPTSTR; + { return type might be wrong } + begin + IDC_SIZEALL:=MAKEINTRESOURCE(32646); + end; + + { was #define dname def_expr } + function IDC_NO : LPTSTR; + { return type might be wrong } + begin + IDC_NO:=MAKEINTRESOURCE(32648); + end; + + { was #define dname def_expr } + function IDC_APPSTARTING : LPTSTR; + { return type might be wrong } + begin + IDC_APPSTARTING:=MAKEINTRESOURCE(32650); + end; + + { was #define dname def_expr } + function IDC_HELP : LPTSTR; + { return type might be wrong } + begin + IDC_HELP:=MAKEINTRESOURCE(32651); + end; + + { was #define dname def_expr } + function IDI_APPLICATION : LPTSTR; + { return type might be wrong } + begin + IDI_APPLICATION:=MAKEINTRESOURCE(32512); + end; + + { was #define dname def_expr } + function IDI_HAND : LPTSTR; + { return type might be wrong } + begin + IDI_HAND:=MAKEINTRESOURCE(32513); + end; + + { was #define dname def_expr } + function IDI_QUESTION : LPTSTR; + { return type might be wrong } + begin + IDI_QUESTION:=MAKEINTRESOURCE(32514); + end; + + { was #define dname def_expr } + function IDI_EXCLAMATION : LPTSTR; + { return type might be wrong } + begin + IDI_EXCLAMATION:=MAKEINTRESOURCE(32515); + end; + + { was #define dname def_expr } + function IDI_ASTERISK : LPTSTR; + { return type might be wrong } + begin + IDI_ASTERISK:=MAKEINTRESOURCE(32516); + end; + + { was #define dname def_expr } + function IDI_WINLOGO : LPTSTR; + { return type might be wrong } + begin + IDI_WINLOGO:=MAKEINTRESOURCE(32517); + end; + + { was #define dname def_expr } + function IDC_SIZE : LPTSTR; + { return type might be wrong } + begin + IDC_SIZE:=MAKEINTRESOURCE(32640); + end; + + { was #define dname def_expr } + function IDC_ICON : LPTSTR; + { return type might be wrong } + begin + IDC_ICON:=MAKEINTRESOURCE(32641); + end; + + { was #define dname def_expr } + function IDC_HAND : LPTSTR; + { return type might be wrong } + begin + IDC_HAND:=MAKEINTRESOURCE(32649); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function IS_UNWINDING( Flag : Longint) : boolean; + begin + IS_UNWINDING:=(Flag and EXCEPTION_UNWIND)<>0; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function IS_DISPATCHING( Flag : Longint) : boolean; + begin + IS_DISPATCHING:=(Flag and EXCEPTION_UNWIND)=0; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function IS_TARGET_UNWIND( Flag : Longint) : Longint; + begin + IS_TARGET_UNWIND:=(Flag and EXCEPTION_TARGET_UNWIND); + end; + + { was #define dname def_expr } + function STD_INPUT_HANDLE : DWORD; + begin + STD_INPUT_HANDLE:=DWORD(-(10)); + end; + + { was #define dname def_expr } + function STD_OUTPUT_HANDLE : DWORD; + begin + STD_OUTPUT_HANDLE:=DWORD(-(11)); + end; + + { was #define dname def_expr } + function STD_ERROR_HANDLE : DWORD; + begin + STD_ERROR_HANDLE:=DWORD(-(12)); + end; + + { was #define dname def_expr } +{ + function INVALID_HANDLE_VALUE : HANDLE; + begin + INVALID_HANDLE_VALUE:=HANDLE(-(1)); + end; +} + + { was #define dname def_expr } + function HWND_BROADCAST : HWND; + begin + HWND_BROADCAST:=HWND($FFFF); + end; + + { was #define dname def_expr } + function HKEY_CLASSES_ROOT : HKEY; + begin + HKEY_CLASSES_ROOT:=HKEY($80000000); + end; + + { was #define dname def_expr } + function HKEY_CURRENT_USER : HKEY; + begin + HKEY_CURRENT_USER:=HKEY($80000001); + end; + + { was #define dname def_expr } + function HKEY_LOCAL_MACHINE : HKEY; + begin + HKEY_LOCAL_MACHINE:=HKEY($80000002); + end; + + { was #define dname def_expr } + function HKEY_USERS : HKEY; + begin + HKEY_USERS:=HKEY($80000003); + end; + + { was #define dname def_expr } + function HKEY_PERFORMANCE_DATA : HKEY; + begin + HKEY_PERFORMANCE_DATA:=HKEY($80000004); + end; + + { was #define dname def_expr } + function HKEY_CURRENT_CONFIG : HKEY; + begin + HKEY_CURRENT_CONFIG:=HKEY($80000005); + end; + + { was #define dname def_expr } + function HKEY_DYN_DATA : HKEY; + begin + HKEY_DYN_DATA:=HKEY($80000006); + end; + + { was #define dname def_expr } + function HWND_BOTTOM : HWND; + begin + HWND_BOTTOM:=HWND(1); + end; + + { was #define dname def_expr } + function HWND_NOTOPMOST : HWND; + begin + HWND_NOTOPMOST:=HWND(-(2)); + end; + + { was #define dname def_expr } + function HWND_TOP : HWND; + begin + HWND_TOP:=HWND(0); + end; + + { was #define dname def_expr } + function HWND_TOPMOST : HWND; + begin + HWND_TOPMOST:=HWND(-(1)); + end; + + { was #define dname def_expr } + function VS_FILE_INFO : LPTSTR; + { return type might be wrong } + begin + VS_FILE_INFO:=MAKEINTRESOURCE(16); + end; + + { was #define dname def_expr } + function HINST_COMMCTRL : HINST; + begin + HINST_COMMCTRL:=HINST(-(1)); + end; + + { was #define dname def_expr } + function LPSTR_TEXTCALLBACKW : LPWSTR; + begin + LPSTR_TEXTCALLBACKW:=LPWSTR(-(1)); + end; + + { was #define dname def_expr } + function LPSTR_TEXTCALLBACKA : LPSTR; + begin + LPSTR_TEXTCALLBACKA:=LPSTR(-(1)); + end; +{$ifdef UNICODE} + + {const this is a function in fact !! + LPSTR_TEXTCALLBACK = LPSTR_TEXTCALLBACKW;} + function LPSTR_TEXTCALLBACK : LPWSTR; + begin + LPSTR_TEXTCALLBACK:=LPWSTR(-(1)); + end; + +{$else} + + {const + LPSTR_TEXTCALLBACK = LPSTR_TEXTCALLBACKA; } + function LPSTR_TEXTCALLBACK : LPSTR; + begin + LPSTR_TEXTCALLBACK:=LPSTR(-(1)); + end; +{$endif} + + { was #define dname def_expr } + function TVI_ROOT : HTREEITEM; + begin + TVI_ROOT:=HTREEITEM($FFFF0000); + end; + + { was #define dname def_expr } + function TVI_FIRST : HTREEITEM; + begin + TVI_FIRST:=HTREEITEM($FFFF0001); + end; + + { was #define dname def_expr } + function TVI_LAST : HTREEITEM; + begin + TVI_LAST:=HTREEITEM($FFFF0002); + end; + + { was #define dname def_expr } + function TVI_SORT : HTREEITEM; + begin + TVI_SORT:=HTREEITEM($FFFF0003); + end; + + { was #define dname def_expr } + function HWND_DESKTOP : HWND; + begin + HWND_DESKTOP:=HWND(0); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function MakeProcInstance(p,i : longint) : longint; + { return type might be wrong } + begin + MakeProcInstance:=p; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function FreeProcInstance(p : longint) : longint; + { return type might be wrong } + begin + FreeProcInstance:=p; + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_COMMAND_CMD(w,l : longint) : longint; + { return type might be wrong } + begin + GET_WM_COMMAND_CMD:=HIWORD(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_COMMAND_ID(w,l : longint) : longint; + { return type might be wrong } + begin + GET_WM_COMMAND_ID:=LOWORD(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_CTLCOLOR_HDC(w,l,msg : longint) : HDC; + begin + GET_WM_CTLCOLOR_HDC:=HDC(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_CTLCOLOR_HWND(w,l,msg : longint) : HWND; + begin + GET_WM_CTLCOLOR_HWND:=HWND(l); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_HSCROLL_CODE(w,l : longint) : longint; + { return type might be wrong } + begin + GET_WM_HSCROLL_CODE:=LOWORD(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_HSCROLL_HWND(w,l : longint) : HWND; + begin + GET_WM_HSCROLL_HWND:=HWND(l); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_HSCROLL_POS(w,l : longint) : longint; + { return type might be wrong } + begin + GET_WM_HSCROLL_POS:=HIWORD(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_MDIACTIVATE_FACTIVATE(h,a,b : longint) : longint; + { return type might be wrong } + begin + GET_WM_MDIACTIVATE_FACTIVATE:=longint(b = LONG(h)); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_MDIACTIVATE_HWNDACTIVATE(a,b : longint) : HWND; + begin + GET_WM_MDIACTIVATE_HWNDACTIVATE:=HWND(b); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_MDIACTIVATE_HWNDDEACT(a,b : longint) : HWND; + begin + GET_WM_MDIACTIVATE_HWNDDEACT:=HWND(a); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_VSCROLL_CODE(w,l : longint) : longint; + { return type might be wrong } + begin + GET_WM_VSCROLL_CODE:=LOWORD(w); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + function GET_WM_VSCROLL_HWND(w,l : longint) : HWND; + begin + GET_WM_VSCROLL_HWND:=HWND(l); + end; + + { was #define dname(params) def_expr } + { argument types are unknown } + { return type might be wrong } + function GET_WM_VSCROLL_POS(w,l : longint) : longint; + { return type might be wrong } + begin + GET_WM_VSCROLL_POS:=HIWORD(w); + end; + + { was #define dname(params) def_expr } + function FreeModule(h:HINST):WINBOOL; + begin + FreeModule:=FreeLibrary(h); + end; + + { was #define dname(params) def_expr } + function GetNextSibling(h:HWND):HWND; + begin + GetNextSibling:=GetWindow(h,GW_HWNDNEXT); + end; + { was #define dname(params) def_expr } + function GetWindowID(h:HWND):longint; + begin + GetWindowID:=GetDlgCtrlID(h); + end; + + { was #define dname(params) def_expr } + function SubclassWindow(h:HWND; p:LONG):LONG; + begin + SubclassWindow:=SetWindowLong(h,GWL_WNDPROC,p); + end; + + { was #define dname(params) def_expr } + function GetFirstChild(h:HWND):HWND; + begin + //GetFirstChild:=GetTopWindow(h); + GetFirstChild:=GetWindow(h,GW_CHILD); + end; + +{$ifdef WINCE} +{$endif WINCE} + +{$ifdef WIN32} +{$endif WIN32} + +{$endif read_implementation} + diff --git a/rtl/wince/wininc/errors.inc b/rtl/wince/wininc/errors.inc new file mode 100644 index 0000000000..ae2e14d7cb --- /dev/null +++ b/rtl/wince/wininc/errors.inc @@ -0,0 +1,1174 @@ +{ + This file is part of the Free Pascal run time library. + This unit contains the error code definition for the Win32 API + + Copyright (c) 1999-2001 by Florian Klaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ + + Errors.h + + + Windows32 API error codes + + + Copyright (C) 1996 Free Software Foundation, Inc. + + + Author: Scott Christley + + + This file is part of the Windows32 API Library. + + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Changes : + + 08/15/2005 update for wince4.2 port,ORO06 +} + +{$ifdef read_interface} + + const + APPLICATION_ERROR_MASK = $20000000; //+winnt + LZERROR_UNKNOWNALG = -(8); + LZERROR_BADVALUE = -(7); + LZERROR_GLOBLOCK = -(6); + LZERROR_GLOBALLOC = -(5); + LZERROR_WRITE = -(4); + LZERROR_READ = -(3); + LZERROR_BADOUTHANDLE = -(2); + LZERROR_BADINHANDLE = -(1); + NO_ERROR = 0; + ERROR_SUCCESS = 0; + ERROR_INVALID_FUNCTION = 1; + ERROR_FILE_NOT_FOUND = 2; + ERROR_PATH_NOT_FOUND = 3; + ERROR_TOO_MANY_OPEN_FILES = 4; + ERROR_ACCESS_DENIED = 5; + ERROR_INVALID_HANDLE = 6; + ERROR_ARENA_TRASHED = 7; + ERROR_NOT_ENOUGH_MEMORY = 8; + ERROR_INVALID_BLOCK = 9; + ERROR_BAD_ENVIRONMENT = 10; + ERROR_BAD_FORMAT = 11; + ERROR_INVALID_ACCESS = 12; + ERROR_INVALID_DATA = 13; + ERROR_OUTOFMEMORY = 14; + ERROR_INVALID_DRIVE = 15; + ERROR_CURRENT_DIRECTORY = 16; + ERROR_NOT_SAME_DEVICE = 17; + ERROR_NO_MORE_FILES = 18; + ERROR_WRITE_PROTECT = 19; + ERROR_BAD_UNIT = 20; + ERROR_NOT_READY = 21; + ERROR_BAD_COMMAND = 22; + ERROR_CRC = 23; + ERROR_BAD_LENGTH = 24; + ERROR_SEEK = 25; + ERROR_NOT_DOS_DISK = 26; + ERROR_SECTOR_NOT_FOUND = 27; + ERROR_OUT_OF_PAPER = 28; + ERROR_WRITE_FAULT = 29; + ERROR_READ_FAULT = 30; + ERROR_GEN_FAILURE = 31; + ERROR_SHARING_VIOLATION = 32; + ERROR_LOCK_VIOLATION = 33; + ERROR_WRONG_DISK = 34; + ERROR_SHARING_BUFFER_EXCEEDED = 36; + ERROR_HANDLE_EOF = 38; + ERROR_HANDLE_DISK_FULL = 39; + ERROR_NOT_SUPPORTED = 50; + ERROR_REM_NOT_LIST = 51; + ERROR_DUP_NAME = 52; + ERROR_BAD_NETPATH = 53; + ERROR_NETWORK_BUSY = 54; + ERROR_DEV_NOT_EXIST = 55; + ERROR_TOO_MANY_CMDS = 56; + ERROR_ADAP_HDW_ERR = 57; + ERROR_BAD_NET_RESP = 58; + ERROR_UNEXP_NET_ERR = 59; + ERROR_BAD_REM_ADAP = 60; + ERROR_PRINTQ_FULL = 61; + ERROR_NO_SPOOL_SPACE = 62; + ERROR_PRINT_CANCELLED = 63; + ERROR_NETNAME_DELETED = 64; + ERROR_NETWORK_ACCESS_DENIED = 65; + ERROR_BAD_DEV_TYPE = 66; + ERROR_BAD_NET_NAME = 67; + ERROR_TOO_MANY_NAMES = 68; + ERROR_TOO_MANY_SESS = 69; + ERROR_SHARING_PAUSED = 70; + ERROR_REQ_NOT_ACCEP = 71; + ERROR_REDIR_PAUSED = 72; + ERROR_FILE_EXISTS = 80; + ERROR_CANNOT_MAKE = 82; + ERROR_FAIL_I24 = 83; + ERROR_OUT_OF_STRUCTURES = 84; + ERROR_ALREADY_ASSIGNED = 85; + ERROR_INVALID_PASSWORD = 86; + ERROR_INVALID_PARAMETER = 87; + ERROR_NET_WRITE_FAULT = 88; + ERROR_NO_PROC_SLOTS = 89; + ERROR_TOO_MANY_SEMAPHORES = 100; + ERROR_EXCL_SEM_ALREADY_OWNED = 101; + ERROR_SEM_IS_SET = 102; + ERROR_TOO_MANY_SEM_REQUESTS = 103; + ERROR_INVALID_AT_INTERRUPT_TIME = 104; + ERROR_SEM_OWNER_DIED = 105; + ERROR_SEM_USER_LIMIT = 106; + ERROR_DISK_CHANGE = 107; + ERROR_DRIVE_LOCKED = 108; + ERROR_BROKEN_PIPE = 109; + ERROR_OPEN_FAILED = 110; + ERROR_BUFFER_OVERFLOW = 111; + ERROR_DISK_FULL = 112; + ERROR_NO_MORE_SEARCH_HANDLES = 113; + ERROR_INVALID_TARGET_HANDLE = 114; + ERROR_INVALID_CATEGORY = 117; + ERROR_INVALID_VERIFY_SWITCH = 118; + ERROR_BAD_DRIVER_LEVEL = 119; + ERROR_CALL_NOT_IMPLEMENTED = 120; + ERROR_SEM_TIMEOUT = 121; + ERROR_INSUFFICIENT_BUFFER = 122; + ERROR_INVALID_NAME = 123; + ERROR_INVALID_LEVEL = 124; + ERROR_NO_VOLUME_LABEL = 125; + ERROR_MOD_NOT_FOUND = 126; + ERROR_PROC_NOT_FOUND = 127; + ERROR_WAIT_NO_CHILDREN = 128; + ERROR_CHILD_NOT_COMPLETE = 129; + ERROR_DIRECT_ACCESS_HANDLE = 130; + ERROR_NEGATIVE_SEEK = 131; + ERROR_SEEK_ON_DEVICE = 132; + ERROR_IS_JOIN_TARGET = 133; + ERROR_IS_JOINED = 134; + ERROR_IS_SUBSTED = 135; + ERROR_NOT_JOINED = 136; + ERROR_NOT_SUBSTED = 137; + ERROR_JOIN_TO_JOIN = 138; + ERROR_SUBST_TO_SUBST = 139; + ERROR_JOIN_TO_SUBST = 140; + ERROR_SUBST_TO_JOIN = 141; + ERROR_BUSY_DRIVE = 142; + ERROR_SAME_DRIVE = 143; + ERROR_DIR_NOT_ROOT = 144; + ERROR_DIR_NOT_EMPTY = 145; + ERROR_IS_SUBST_PATH = 146; + ERROR_IS_JOIN_PATH = 147; + ERROR_PATH_BUSY = 148; + ERROR_IS_SUBST_TARGET = 149; + ERROR_SYSTEM_TRACE = 150; + ERROR_INVALID_EVENT_COUNT = 151; + ERROR_TOO_MANY_MUXWAITERS = 152; + ERROR_INVALID_LIST_FORMAT = 153; + ERROR_LABEL_TOO_LONG = 154; + ERROR_TOO_MANY_TCBS = 155; + ERROR_SIGNAL_REFUSED = 156; + ERROR_DISCARDED = 157; + ERROR_NOT_LOCKED = 158; + ERROR_BAD_THREADID_ADDR = 159; + ERROR_BAD_ARGUMENTS = 160; + ERROR_BAD_PATHNAME = 161; + ERROR_SIGNAL_PENDING = 162; + ERROR_MAX_THRDS_REACHED = 164; + ERROR_LOCK_FAILED = 167; + ERROR_BUSY = 170; + ERROR_CANCEL_VIOLATION = 173; + ERROR_ATOMIC_LOCKS_NOT_SUPPORTED = 174; + ERROR_INVALID_SEGMENT_NUMBER = 180; + ERROR_INVALID_ORDINAL = 182; + ERROR_ALREADY_EXISTS = 183; + ERROR_INVALID_FLAG_NUMBER = 186; + ERROR_SEM_NOT_FOUND = 187; + ERROR_INVALID_STARTING_CODESEG = 188; + ERROR_INVALID_STACKSEG = 189; + ERROR_INVALID_MODULETYPE = 190; + ERROR_INVALID_EXE_SIGNATURE = 191; + ERROR_EXE_MARKED_INVALID = 192; + ERROR_BAD_EXE_FORMAT = 193; + ERROR_ITERATED_DATA_EXCEEDS_64k = 194; + ERROR_INVALID_MINALLOCSIZE = 195; + ERROR_DYNLINK_FROM_INVALID_RING = 196; + ERROR_IOPL_NOT_ENABLED = 197; + ERROR_INVALID_SEGDPL = 198; + ERROR_AUTODATASEG_EXCEEDS_64k = 199; + ERROR_RING2SEG_MUST_BE_MOVABLE = 200; + ERROR_RELOC_CHAIN_XEEDS_SEGLIM = 201; + ERROR_INFLOOP_IN_RELOC_CHAIN = 202; + ERROR_ENVVAR_NOT_FOUND = 203; + ERROR_NO_SIGNAL_SENT = 205; + ERROR_FILENAME_EXCED_RANGE = 206; + ERROR_RING2_STACK_IN_USE = 207; + ERROR_META_EXPANSION_TOO_LONG = 208; + ERROR_INVALID_SIGNAL_NUMBER = 209; + ERROR_THREAD_1_INACTIVE = 210; + ERROR_LOCKED = 212; + ERROR_TOO_MANY_MODULES = 214; + ERROR_NESTING_NOT_ALLOWED = 215; + ERROR_BAD_PIPE = 230; + ERROR_PIPE_BUSY = 231; + ERROR_NO_DATA = 232; + ERROR_PIPE_NOT_CONNECTED = 233; + ERROR_MORE_DATA = 234; + ERROR_VC_DISCONNECTED = 240; + ERROR_INVALID_EA_NAME = 254; + ERROR_EA_LIST_INCONSISTENT = 255; + ERROR_NO_MORE_ITEMS = 259; + ERROR_CANNOT_COPY = 266; + ERROR_DIRECTORY = 267; + ERROR_EAS_DIDNT_FIT = 275; + ERROR_EA_FILE_CORRUPT = 276; + ERROR_EA_TABLE_FULL = 277; + ERROR_INVALID_EA_HANDLE = 278; + ERROR_EAS_NOT_SUPPORTED = 282; + ERROR_NOT_OWNER = 288; + ERROR_TOO_MANY_POSTS = 298; + ERROR_PARTIAL_COPY = 299; + ERROR_MR_MID_NOT_FOUND = 317; + ERROR_INVALID_ADDRESS = 487; + ERROR_ARITHMETIC_OVERFLOW = 534; + ERROR_PIPE_CONNECTED = 535; + ERROR_PIPE_LISTENING = 536; + ERROR_EA_ACCESS_DENIED = 994; + ERROR_OPERATION_ABORTED = 995; + ERROR_IO_INCOMPLETE = 996; + ERROR_IO_PENDING = 997; + ERROR_NOACCESS = 998; + ERROR_SWAPERROR = 999; + ERROR_STACK_OVERFLOW = 1001; + ERROR_INVALID_MESSAGE = 1002; + ERROR_CAN_NOT_COMPLETE = 1003; + ERROR_INVALID_FLAGS = 1004; + ERROR_UNRECOGNIZED_VOLUME = 1005; + ERROR_FILE_INVALID = 1006; + ERROR_FULLSCREEN_MODE = 1007; + ERROR_NO_TOKEN = 1008; + ERROR_BADDB = 1009; + ERROR_BADKEY = 1010; + ERROR_CANTOPEN = 1011; + ERROR_CANTREAD = 1012; + ERROR_CANTWRITE = 1013; + ERROR_REGISTRY_RECOVERED = 1014; + ERROR_REGISTRY_CORRUPT = 1015; + ERROR_REGISTRY_IO_FAILED = 1016; + ERROR_NOT_REGISTRY_FILE = 1017; + ERROR_KEY_DELETED = 1018; + ERROR_NO_LOG_SPACE = 1019; + ERROR_KEY_HAS_CHILDREN = 1020; + ERROR_CHILD_MUST_BE_VOLATILE = 1021; + ERROR_NOTIFY_ENUM_DIR = 1022; + ERROR_DEPENDENT_SERVICES_RUNNING = 1051; + ERROR_INVALID_SERVICE_CONTROL = 1052; + ERROR_SERVICE_REQUEST_TIMEOUT = 1053; + ERROR_SERVICE_NO_THREAD = 1054; + ERROR_SERVICE_DATABASE_LOCKED = 1055; + ERROR_SERVICE_ALREADY_RUNNING = 1056; + ERROR_INVALID_SERVICE_ACCOUNT = 1057; + ERROR_SERVICE_DISABLED = 1058; + ERROR_CIRCULAR_DEPENDENCY = 1059; + ERROR_SERVICE_DOES_NOT_EXIST = 1060; + ERROR_SERVICE_CANNOT_ACCEPT_CTRL = 1061; + ERROR_SERVICE_NOT_ACTIVE = 1062; + ERROR_FAILED_SERVICE_CONTROLLER_CONNECT = 1063; + ERROR_EXCEPTION_IN_SERVICE = 1064; + ERROR_DATABASE_DOES_NOT_EXIST = 1065; + ERROR_SERVICE_SPECIFIC_ERROR = 1066; + ERROR_PROCESS_ABORTED = 1067; + ERROR_SERVICE_DEPENDENCY_FAIL = 1068; + ERROR_SERVICE_LOGON_FAILED = 1069; + ERROR_SERVICE_START_HANG = 1070; + ERROR_INVALID_SERVICE_LOCK = 1071; + ERROR_SERVICE_MARKED_FOR_DELETE = 1072; + ERROR_SERVICE_EXISTS = 1073; + ERROR_ALREADY_RUNNING_LKG = 1074; + ERROR_SERVICE_DEPENDENCY_DELETED = 1075; + ERROR_BOOT_ALREADY_ACCEPTED = 1076; + ERROR_SERVICE_NEVER_STARTED = 1077; + ERROR_DUPLICATE_SERVICE_NAME = 1078; + ERROR_END_OF_MEDIA = 1100; + ERROR_FILEMARK_DETECTED = 1101; + ERROR_BEGINNING_OF_MEDIA = 1102; + ERROR_SETMARK_DETECTED = 1103; + ERROR_NO_DATA_DETECTED = 1104; + ERROR_PARTITION_FAILURE = 1105; + ERROR_INVALID_BLOCK_LENGTH = 1106; + ERROR_DEVICE_NOT_PARTITIONED = 1107; + ERROR_UNABLE_TO_LOCK_MEDIA = 1108; + ERROR_UNABLE_TO_UNLOAD_MEDIA = 1109; + ERROR_MEDIA_CHANGED = 1110; + ERROR_BUS_RESET = 1111; + ERROR_NO_MEDIA_IN_DRIVE = 1112; + ERROR_NO_UNICODE_TRANSLATION = 1113; + ERROR_DLL_INIT_FAILED = 1114; + ERROR_SHUTDOWN_IN_PROGRESS = 1115; + ERROR_NO_SHUTDOWN_IN_PROGRESS = 1116; + ERROR_IO_DEVICE = 1117; + ERROR_SERIAL_NO_DEVICE = 1118; + ERROR_IRQ_BUSY = 1119; + ERROR_MORE_WRITES = 1120; + ERROR_COUNTER_TIMEOUT = 1121; + ERROR_FLOPPY_ID_MARK_NOT_FOUND = 1122; + ERROR_FLOPPY_WRONG_CYLINDER = 1123; + ERROR_FLOPPY_UNKNOWN_ERROR = 1124; + ERROR_FLOPPY_BAD_REGISTERS = 1125; + ERROR_DISK_RECALIBRATE_FAILED = 1126; + ERROR_DISK_OPERATION_FAILED = 1127; + ERROR_DISK_RESET_FAILED = 1128; + ERROR_EOM_OVERFLOW = 1129; + ERROR_NOT_ENOUGH_SERVER_MEMORY = 1130; + ERROR_POSSIBLE_DEADLOCK = 1131; + ERROR_MAPPED_ALIGNMENT = 1132; + ERROR_SET_POWER_STATE_VETOED = 1140; + ERROR_SET_POWER_STATE_FAILED = 1141; + ERROR_OLD_WIN_VERSION = 1150; + ERROR_APP_WRONG_OS = 1151; + ERROR_SINGLE_INSTANCE_APP = 1152; + ERROR_RMODE_APP = 1153; + ERROR_INVALID_DLL = 1154; + ERROR_NO_ASSOCIATION = 1155; + ERROR_DDE_FAIL = 1156; + ERROR_DLL_NOT_FOUND = 1157; + ERROR_BAD_USERNAME = 2202; + ERROR_NOT_CONNECTED = 2250; + ERROR_OPEN_FILES = 2401; + ERROR_ACTIVE_CONNECTIONS = 2402; + ERROR_DEVICE_IN_USE = 2404; + ERROR_BAD_DEVICE = 1200; + ERROR_CONNECTION_UNAVAIL = 1201; + ERROR_DEVICE_ALREADY_REMEMBERED = 1202; + ERROR_NO_NET_OR_BAD_PATH = 1203; + ERROR_BAD_PROVIDER = 1204; + ERROR_CANNOT_OPEN_PROFILE = 1205; + ERROR_BAD_PROFILE = 1206; + ERROR_NOT_CONTAINER = 1207; + ERROR_EXTENDED_ERROR = 1208; + ERROR_INVALID_GROUPNAME = 1209; + ERROR_INVALID_COMPUTERNAME = 1210; + ERROR_INVALID_EVENTNAME = 1211; + ERROR_INVALID_DOMAINNAME = 1212; + ERROR_INVALID_SERVICENAME = 1213; + ERROR_INVALID_NETNAME = 1214; + ERROR_INVALID_SHARENAME = 1215; + ERROR_INVALID_PASSWORDNAME = 1216; + ERROR_INVALID_MESSAGENAME = 1217; + ERROR_INVALID_MESSAGEDEST = 1218; + ERROR_SESSION_CREDENTIAL_CONFLICT = 1219; + ERROR_REMOTE_SESSION_LIMIT_EXCEEDED = 1220; + ERROR_DUP_DOMAINNAME = 1221; + ERROR_NO_NETWORK = 1222; + ERROR_CANCELLED = 1223; + ERROR_USER_MAPPED_FILE = 1224; + ERROR_CONNECTION_REFUSED = 1225; + ERROR_GRACEFUL_DISCONNECT = 1226; + ERROR_ADDRESS_ALREADY_ASSOCIATED = 1227; + ERROR_ADDRESS_NOT_ASSOCIATED = 1228; + ERROR_CONNECTION_INVALID = 1229; + ERROR_CONNECTION_ACTIVE = 1230; + ERROR_NETWORK_UNREACHABLE = 1231; + ERROR_HOST_UNREACHABLE = 1232; + ERROR_PROTOCOL_UNREACHABLE = 1233; + ERROR_PORT_UNREACHABLE = 1234; + ERROR_REQUEST_ABORTED = 1235; + ERROR_CONNECTION_ABORTED = 1236; + ERROR_RETRY = 1237; + ERROR_CONNECTION_COUNT_LIMIT = 1238; + ERROR_LOGIN_TIME_RESTRICTION = 1239; + ERROR_LOGIN_WKSTA_RESTRICTION = 1240; + ERROR_INCORRECT_ADDRESS = 1241; + ERROR_ALREADY_REGISTERED = 1242; + ERROR_SERVICE_NOT_FOUND = 1243; + ERROR_NOT_AUTHENTICATED = 1244; + ERROR_NOT_LOGGED_ON = 1245; + ERROR_CONTINUE = 1246; + ERROR_ALREADY_INITIALIZED = 1247; + ERROR_NO_MORE_DEVICES = 1248; + ERROR_NOT_ALL_ASSIGNED = 1300; + ERROR_SOME_NOT_MAPPED = 1301; + ERROR_NO_QUOTAS_FOR_ACCOUNT = 1302; + ERROR_LOCAL_USER_SESSION_KEY = 1303; + ERROR_NULL_LM_PASSWORD = 1304; + ERROR_UNKNOWN_REVISION = 1305; + ERROR_REVISION_MISMATCH = 1306; + ERROR_INVALID_OWNER = 1307; + ERROR_INVALID_PRIMARY_GROUP = 1308; + ERROR_NO_IMPERSONATION_TOKEN = 1309; + ERROR_CANT_DISABLE_MANDATORY = 1310; + ERROR_NO_LOGON_SERVERS = 1311; + ERROR_NO_SUCH_LOGON_SESSION = 1312; + ERROR_NO_SUCH_PRIVILEGE = 1313; + ERROR_PRIVILEGE_NOT_HELD = 1314; + ERROR_INVALID_ACCOUNT_NAME = 1315; + ERROR_USER_EXISTS = 1316; + ERROR_NO_SUCH_USER = 1317; + ERROR_GROUP_EXISTS = 1318; + ERROR_NO_SUCH_GROUP = 1319; + ERROR_MEMBER_IN_GROUP = 1320; + ERROR_MEMBER_NOT_IN_GROUP = 1321; + ERROR_LAST_ADMIN = 1322; + ERROR_WRONG_PASSWORD = 1323; + ERROR_ILL_FORMED_PASSWORD = 1324; + ERROR_PASSWORD_RESTRICTION = 1325; + ERROR_LOGON_FAILURE = 1326; + ERROR_ACCOUNT_RESTRICTION = 1327; + ERROR_INVALID_LOGON_HOURS = 1328; + ERROR_INVALID_WORKSTATION = 1329; + ERROR_PASSWORD_EXPIRED = 1330; + ERROR_ACCOUNT_DISABLED = 1331; + ERROR_NONE_MAPPED = 1332; + ERROR_TOO_MANY_LUIDS_REQUESTED = 1333; + ERROR_LUIDS_EXHAUSTED = 1334; + ERROR_INVALID_SUB_AUTHORITY = 1335; + ERROR_INVALID_ACL = 1336; + ERROR_INVALID_SID = 1337; + ERROR_INVALID_SECURITY_DESCR = 1338; + ERROR_BAD_INHERITANCE_ACL = 1340; + ERROR_SERVER_DISABLED = 1341; + ERROR_SERVER_NOT_DISABLED = 1342; + ERROR_INVALID_ID_AUTHORITY = 1343; + ERROR_ALLOTTED_SPACE_EXCEEDED = 1344; + ERROR_INVALID_GROUP_ATTRIBUTES = 1345; + ERROR_BAD_IMPERSONATION_LEVEL = 1346; + ERROR_CANT_OPEN_ANONYMOUS = 1347; + ERROR_BAD_VALIDATION_CLASS = 1348; + ERROR_BAD_TOKEN_TYPE = 1349; + ERROR_NO_SECURITY_ON_OBJECT = 1350; + ERROR_CANT_ACCESS_DOMAIN_INFO = 1351; + ERROR_INVALID_SERVER_STATE = 1352; + ERROR_INVALID_DOMAIN_STATE = 1353; + ERROR_INVALID_DOMAIN_ROLE = 1354; + ERROR_NO_SUCH_DOMAIN = 1355; + ERROR_DOMAIN_EXISTS = 1356; + ERROR_DOMAIN_LIMIT_EXCEEDED = 1357; + ERROR_INTERNAL_DB_CORRUPTION = 1358; + ERROR_INTERNAL_ERROR = 1359; + ERROR_GENERIC_NOT_MAPPED = 1360; + ERROR_BAD_DESCRIPTOR_FORMAT = 1361; + ERROR_NOT_LOGON_PROCESS = 1362; + ERROR_LOGON_SESSION_EXISTS = 1363; + ERROR_NO_SUCH_PACKAGE = 1364; + ERROR_BAD_LOGON_SESSION_STATE = 1365; + ERROR_LOGON_SESSION_COLLISION = 1366; + ERROR_INVALID_LOGON_TYPE = 1367; + ERROR_CANNOT_IMPERSONATE = 1368; + ERROR_RXACT_INVALID_STATE = 1369; + ERROR_RXACT_COMMIT_FAILURE = 1370; + ERROR_SPECIAL_ACCOUNT = 1371; + ERROR_SPECIAL_GROUP = 1372; + ERROR_SPECIAL_USER = 1373; + ERROR_MEMBERS_PRIMARY_GROUP = 1374; + ERROR_TOKEN_ALREADY_IN_USE = 1375; + ERROR_NO_SUCH_ALIAS = 1376; + ERROR_MEMBER_NOT_IN_ALIAS = 1377; + ERROR_MEMBER_IN_ALIAS = 1378; + ERROR_ALIAS_EXISTS = 1379; + ERROR_LOGON_NOT_GRANTED = 1380; + ERROR_TOO_MANY_SECRETS = 1381; + ERROR_SECRET_TOO_LONG = 1382; + ERROR_INTERNAL_DB_ERROR = 1383; + ERROR_TOO_MANY_CONTEXT_IDS = 1384; + ERROR_LOGON_TYPE_NOT_GRANTED = 1385; + ERROR_NT_CROSS_ENCRYPTION_REQUIRED = 1386; + ERROR_NO_SUCH_MEMBER = 1387; + ERROR_INVALID_MEMBER = 1388; + ERROR_TOO_MANY_SIDS = 1389; + ERROR_LM_CROSS_ENCRYPTION_REQUIRED = 1390; + ERROR_NO_INHERITANCE = 1391; + ERROR_FILE_CORRUPT = 1392; + ERROR_DISK_CORRUPT = 1393; + ERROR_NO_USER_SESSION_KEY = 1394; + ERROR_LICENSE_QUOTA_EXCEEDED = 1395; + ERROR_INVALID_WINDOW_HANDLE = 1400; + ERROR_INVALID_MENU_HANDLE = 1401; + ERROR_INVALID_CURSOR_HANDLE = 1402; + ERROR_INVALID_ACCEL_HANDLE = 1403; + ERROR_INVALID_HOOK_HANDLE = 1404; + ERROR_INVALID_DWP_HANDLE = 1405; + ERROR_TLW_WITH_WSCHILD = 1406; + ERROR_CANNOT_FIND_WND_CLASS = 1407; + ERROR_WINDOW_OF_OTHER_THREAD = 1408; + ERROR_HOTKEY_ALREADY_REGISTERED = 1409; + ERROR_CLASS_ALREADY_EXISTS = 1410; + ERROR_CLASS_DOES_NOT_EXIST = 1411; + ERROR_CLASS_HAS_WINDOWS = 1412; + ERROR_INVALID_INDEX = 1413; + ERROR_INVALID_ICON_HANDLE = 1414; + ERROR_PRIVATE_DIALOG_INDEX = 1415; + ERROR_LISTBOX_ID_NOT_FOUND = 1416; + ERROR_NO_WILDCARD_CHARACTERS = 1417; + ERROR_CLIPBOARD_NOT_OPEN = 1418; + ERROR_HOTKEY_NOT_REGISTERED = 1419; + ERROR_WINDOW_NOT_DIALOG = 1420; + ERROR_CONTROL_ID_NOT_FOUND = 1421; + ERROR_INVALID_COMBOBOX_MESSAGE = 1422; + ERROR_WINDOW_NOT_COMBOBOX = 1423; + ERROR_INVALID_EDIT_HEIGHT = 1424; + ERROR_DC_NOT_FOUND = 1425; + ERROR_INVALID_HOOK_FILTER = 1426; + ERROR_INVALID_FILTER_PROC = 1427; + ERROR_HOOK_NEEDS_HMOD = 1428; + ERROR_GLOBAL_ONLY_HOOK = 1429; + ERROR_JOURNAL_HOOK_SET = 1430; + ERROR_HOOK_NOT_INSTALLED = 1431; + ERROR_INVALID_LB_MESSAGE = 1432; + ERROR_SETCOUNT_ON_BAD_LB = 1433; + ERROR_LB_WITHOUT_TABSTOPS = 1434; + ERROR_DESTROY_OBJECT_OF_OTHER_THREAD = 1435; + ERROR_CHILD_WINDOW_MENU = 1436; + ERROR_NO_SYSTEM_MENU = 1437; + ERROR_INVALID_MSGBOX_STYLE = 1438; + ERROR_INVALID_SPI_VALUE = 1439; + ERROR_SCREEN_ALREADY_LOCKED = 1440; + ERROR_HWNDS_HAVE_DIFF_PARENT = 1441; + ERROR_NOT_CHILD_WINDOW = 1442; + ERROR_INVALID_GW_COMMAND = 1443; + ERROR_INVALID_THREAD_ID = 1444; + ERROR_NON_MDICHILD_WINDOW = 1445; + ERROR_POPUP_ALREADY_ACTIVE = 1446; + ERROR_NO_SCROLLBARS = 1447; + ERROR_INVALID_SCROLLBAR_RANGE = 1448; + ERROR_INVALID_SHOWWIN_COMMAND = 1449; + ERROR_NO_SYSTEM_RESOURCES = 1450; + ERROR_NONPAGED_SYSTEM_RESOURCES = 1451; + ERROR_PAGED_SYSTEM_RESOURCES = 1452; + ERROR_WORKING_SET_QUOTA = 1453; + ERROR_PAGEFILE_QUOTA = 1454; + ERROR_COMMITMENT_LIMIT = 1455; + ERROR_MENU_ITEM_NOT_FOUND = 1456; + ERROR_INVALID_KEYBOARD_HANDLE = 1457; + ERROR_HOOK_TYPE_NOT_ALLOWED = 1458; + ERROR_REQUIRES_INTERACTIVE_WINDOWSTATION = 1459; + ERROR_TIMEOUT = 1460; + ERROR_EVENTLOG_FILE_CORRUPT = 1500; + ERROR_EVENTLOG_CANT_START = 1501; + ERROR_LOG_FILE_FULL = 1502; + ERROR_EVENTLOG_FILE_CHANGED = 1503; + RPC_S_INVALID_STRING_BINDING = 1700; + RPC_S_WRONG_KIND_OF_BINDING = 1701; + RPC_S_INVALID_BINDING = 1702; + RPC_S_PROTSEQ_NOT_SUPPORTED = 1703; + RPC_S_INVALID_RPC_PROTSEQ = 1704; + RPC_S_INVALID_STRING_UUID = 1705; + RPC_S_INVALID_ENDPOINT_FORMAT = 1706; + RPC_S_INVALID_NET_ADDR = 1707; + RPC_S_NO_ENDPOINT_FOUND = 1708; + RPC_S_INVALID_TIMEOUT = 1709; + RPC_S_OBJECT_NOT_FOUND = 1710; + RPC_S_ALREADY_REGISTERED = 1711; + RPC_S_TYPE_ALREADY_REGISTERED = 1712; + RPC_S_ALREADY_LISTENING = 1713; + RPC_S_NO_PROTSEQS_REGISTERED = 1714; + RPC_S_NOT_LISTENING = 1715; + RPC_S_UNKNOWN_MGR_TYPE = 1716; + RPC_S_UNKNOWN_IF = 1717; + RPC_S_NO_BINDINGS = 1718; + RPC_S_NO_PROTSEQS = 1719; + RPC_S_CANT_CREATE_ENDPOINT = 1720; + RPC_S_OUT_OF_RESOURCES = 1721; + RPC_S_SERVER_UNAVAILABLE = 1722; + RPC_S_SERVER_TOO_BUSY = 1723; + RPC_S_INVALID_NETWORK_OPTIONS = 1724; + RPC_S_NO_CALL_ACTIVE = 1725; + RPC_S_CALL_FAILED = 1726; + RPC_S_CALL_FAILED_DNE = 1727; + RPC_S_PROTOCOL_ERROR = 1728; + RPC_S_UNSUPPORTED_TRANS_SYN = 1730; + RPC_S_UNSUPPORTED_TYPE = 1732; + RPC_S_INVALID_TAG = 1733; + RPC_S_INVALID_BOUND = 1734; + RPC_S_NO_ENTRY_NAME = 1735; + RPC_S_INVALID_NAME_SYNTAX = 1736; + RPC_S_UNSUPPORTED_NAME_SYNTAX = 1737; + RPC_S_UUID_NO_ADDRESS = 1739; + RPC_S_DUPLICATE_ENDPOINT = 1740; + RPC_S_UNKNOWN_AUTHN_TYPE = 1741; + RPC_S_MAX_CALLS_TOO_SMALL = 1742; + RPC_S_STRING_TOO_LONG = 1743; + RPC_S_PROTSEQ_NOT_FOUND = 1744; + RPC_S_PROCNUM_OUT_OF_RANGE = 1745; + RPC_S_BINDING_HAS_NO_AUTH = 1746; + RPC_S_UNKNOWN_AUTHN_SERVICE = 1747; + RPC_S_UNKNOWN_AUTHN_LEVEL = 1748; + RPC_S_INVALID_AUTH_IDENTITY = 1749; + RPC_S_UNKNOWN_AUTHZ_SERVICE = 1750; + EPT_S_INVALID_ENTRY = 1751; + EPT_S_CANT_PERFORM_OP = 1752; + EPT_S_NOT_REGISTERED = 1753; + RPC_S_NOTHING_TO_EXPORT = 1754; + RPC_S_INCOMPLETE_NAME = 1755; + RPC_S_INVALID_VERS_OPTION = 1756; + RPC_S_NO_MORE_MEMBERS = 1757; + RPC_S_NOT_ALL_OBJS_UNEXPORTED = 1758; + RPC_S_INTERFACE_NOT_FOUND = 1759; + RPC_S_ENTRY_ALREADY_EXISTS = 1760; + RPC_S_ENTRY_NOT_FOUND = 1761; + RPC_S_NAME_SERVICE_UNAVAILABLE = 1762; + RPC_S_INVALID_NAF_ID = 1763; + RPC_S_CANNOT_SUPPORT = 1764; + RPC_S_NO_CONTEXT_AVAILABLE = 1765; + RPC_S_INTERNAL_ERROR = 1766; + RPC_S_ZERO_DIVIDE = 1767; + RPC_S_ADDRESS_ERROR = 1768; + RPC_S_FP_DIV_ZERO = 1769; + RPC_S_FP_UNDERFLOW = 1770; + RPC_S_FP_OVERFLOW = 1771; + RPC_X_NO_MORE_ENTRIES = 1772; + RPC_X_SS_CHAR_TRANS_OPEN_FAIL = 1773; + RPC_X_SS_CHAR_TRANS_SHORT_FILE = 1774; + RPC_X_SS_IN_NULL_CONTEXT = 1775; + RPC_X_SS_CONTEXT_DAMAGED = 1777; + RPC_X_SS_HANDLES_MISMATCH = 1778; + RPC_X_SS_CANNOT_GET_CALL_HANDLE = 1779; + RPC_X_NULL_REF_POINTER = 1780; + RPC_X_ENUM_VALUE_OUT_OF_RANGE = 1781; + RPC_X_BYTE_COUNT_TOO_SMALL = 1782; + RPC_X_BAD_STUB_DATA = 1783; + ERROR_INVALID_USER_BUFFER = 1784; + ERROR_UNRECOGNIZED_MEDIA = 1785; + ERROR_NO_TRUST_LSA_SECRET = 1786; + ERROR_NO_TRUST_SAM_ACCOUNT = 1787; + ERROR_TRUSTED_DOMAIN_FAILURE = 1788; + ERROR_TRUSTED_RELATIONSHIP_FAILURE = 1789; + ERROR_TRUST_FAILURE = 1790; + RPC_S_CALL_IN_PROGRESS = 1791; + ERROR_NETLOGON_NOT_STARTED = 1792; + ERROR_ACCOUNT_EXPIRED = 1793; + ERROR_REDIRECTOR_HAS_OPEN_HANDLES = 1794; + ERROR_PRINTER_DRIVER_ALREADY_INSTALLED = 1795; + ERROR_UNKNOWN_PORT = 1796; + ERROR_UNKNOWN_PRINTER_DRIVER = 1797; + ERROR_UNKNOWN_PRINTPROCESSOR = 1798; + ERROR_INVALID_SEPARATOR_FILE = 1799; + ERROR_INVALID_PRIORITY = 1800; + ERROR_INVALID_PRINTER_NAME = 1801; + ERROR_PRINTER_ALREADY_EXISTS = 1802; + ERROR_INVALID_PRINTER_COMMAND = 1803; + ERROR_INVALID_DATATYPE = 1804; + ERROR_INVALID_ENVIRONMENT = 1805; + RPC_S_NO_MORE_BINDINGS = 1806; + ERROR_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT = 1807; + ERROR_NOLOGON_WORKSTATION_TRUST_ACCOUNT = 1808; + ERROR_NOLOGON_SERVER_TRUST_ACCOUNT = 1809; + ERROR_DOMAIN_TRUST_INCONSISTENT = 1810; + ERROR_SERVER_HAS_OPEN_HANDLES = 1811; + ERROR_RESOURCE_DATA_NOT_FOUND = 1812; + ERROR_RESOURCE_TYPE_NOT_FOUND = 1813; + ERROR_RESOURCE_NAME_NOT_FOUND = 1814; + ERROR_RESOURCE_LANG_NOT_FOUND = 1815; + ERROR_NOT_ENOUGH_QUOTA = 1816; + RPC_S_NO_INTERFACES = 1817; + RPC_S_CALL_CANCELLED = 1818; + RPC_S_BINDING_INCOMPLETE = 1819; + RPC_S_COMM_FAILURE = 1820; + RPC_S_UNSUPPORTED_AUTHN_LEVEL = 1821; + RPC_S_NO_PRINC_NAME = 1822; + RPC_S_NOT_RPC_ERROR = 1823; + RPC_S_UUID_LOCAL_ONLY = 1824; + RPC_S_SEC_PKG_ERROR = 1825; + RPC_S_NOT_CANCELLED = 1826; + RPC_X_INVALID_ES_ACTION = 1827; + RPC_X_WRONG_ES_VERSION = 1828; + RPC_X_WRONG_STUB_VERSION = 1829; + RPC_X_INVALID_PIPE_OBJECT = 1830; + RPC_X_INVALID_PIPE_OPERATION = 1831; + RPC_S_GROUP_MEMBER_NOT_FOUND = 1898; + EPT_S_CANT_CREATE = 1899; + RPC_S_INVALID_OBJECT = 1900; + ERROR_INVALID_TIME = 1901; + ERROR_INVALID_FORM_NAME = 1902; + ERROR_INVALID_FORM_SIZE = 1903; + ERROR_ALREADY_WAITING = 1904; + ERROR_PRINTER_DELETED = 1905; + ERROR_INVALID_PRINTER_STATE = 1906; + ERROR_PASSWORD_MUST_CHANGE = 1907; + ERROR_DOMAIN_CONTROLLER_NOT_FOUND = 1908; + ERROR_ACCOUNT_LOCKED_OUT = 1909; + OR_INVALID_OXID = 1910; + OR_INVALID_OID = 1911; + OR_INVALID_SET = 1912; + RPC_S_SEND_INCOMPLETE = 1913; + ERROR_NO_BROWSER_SERVERS_FOUND = 6118; + ERROR_INVALID_PIXEL_FORMAT = 2000; + ERROR_BAD_DRIVER = 2001; + ERROR_INVALID_WINDOW_STYLE = 2002; + ERROR_METAFILE_NOT_SUPPORTED = 2003; + ERROR_TRANSFORM_NOT_SUPPORTED = 2004; + ERROR_CLIPPING_NOT_SUPPORTED = 2005; + ERROR_UNKNOWN_PRINT_MONITOR = 3000; + ERROR_PRINTER_DRIVER_IN_USE = 3001; + ERROR_SPOOL_FILE_NOT_FOUND = 3002; + ERROR_SPL_NO_STARTDOC = 3003; + ERROR_SPL_NO_ADDJOB = 3004; + ERROR_PRINT_PROCESSOR_ALREADY_INSTALLED = 3005; + ERROR_PRINT_MONITOR_ALREADY_INSTALLED = 3006; + ERROR_INVALID_PRINT_MONITOR = 3007; + ERROR_PRINT_MONITOR_IN_USE = 3008; + ERROR_PRINTER_HAS_JOBS_QUEUED = 3009; + ERROR_SUCCESS_REBOOT_REQUIRED = 3010; + ERROR_SUCCESS_RESTART_REQUIRED = 3011; + ERROR_WINS_INTERNAL = 4000; + ERROR_CAN_NOT_DEL_LOCAL_WINS = 4001; + ERROR_STATIC_INIT = 4002; + ERROR_INC_BACKUP = 4003; + ERROR_FULL_BACKUP = 4004; + ERROR_REC_NON_EXISTENT = 4005; + ERROR_RPL_NOT_ALLOWED = 4006; + ERROR_SEVERITY_SUCCESS = $00000000; //+winnt + ERROR_SEVERITY_INFORMATIONAL = $40000000; //+winnt + ERROR_SEVERITY_WARNING = $80000000; //+winnt + ERROR_SEVERITY_ERROR = $C0000000; //+winnt + {ERROR_NO_BROWSER_SERVERS_FOUND = 6118; already above } + + E_UNEXPECTED = DWORD($8000FFFF); + E_NOTIMPL = DWORD($80004001); + E_OUTOFMEMORY = DWORD($8007000E); + E_INVALIDARG = DWORD($80070057); + E_NOINTERFACE = HRESULT($80004002); + E_POINTER = DWORD($80004003); + E_HANDLE = DWORD($80070006); + E_ABORT = DWORD($80004004); + E_FAIL = DWORD($80004005); + E_ACCESSDENIED = DWORD($80070005); + E_PENDING = DWORD($8000000A); + CO_E_INIT_TLS = DWORD($80004006); + CO_E_INIT_SHARED_ALLOCATOR = DWORD($80004007); + CO_E_INIT_MEMORY_ALLOCATOR = DWORD($80004008); + CO_E_INIT_CLASS_CACHE = DWORD($80004009); + CO_E_INIT_RPC_CHANNEL = DWORD($8000400A); + CO_E_INIT_TLS_SET_CHANNEL_CONTROL = DWORD($8000400B); + CO_E_INIT_TLS_CHANNEL_CONTROL = DWORD($8000400C); + CO_E_INIT_UNACCEPTED_USER_ALLOCATOR = DWORD($8000400D); + CO_E_INIT_SCM_MUTEX_EXISTS = DWORD($8000400E); + CO_E_INIT_SCM_FILE_MAPPING_EXISTS = DWORD($8000400F); + CO_E_INIT_SCM_MAP_VIEW_OF_FILE = DWORD($80004010); + CO_E_INIT_SCM_EXEC_FAILURE = DWORD($80004011); + CO_E_INIT_ONLY_SINGLE_THREADED = DWORD($80004012); + CO_E_CANT_REMOTE = DWORD($80004013); + CO_E_BAD_SERVER_NAME = DWORD($80004014); + CO_E_WRONG_SERVER_IDENTITY = DWORD($80004015); + CO_E_OLE1DDE_DISABLED = DWORD($80004016); + CO_E_RUNAS_SYNTAX = DWORD($80004017); + CO_E_CREATEPROCESS_FAILURE = DWORD($80004018); + CO_E_RUNAS_CREATEPROCESS_FAILURE = DWORD($80004019); + CO_E_RUNAS_LOGON_FAILURE = DWORD($8000401A); + CO_E_LAUNCH_PERMSSION_DENIED = DWORD($8000401B); + CO_E_START_SERVICE_FAILURE = DWORD($8000401C); + CO_E_REMOTE_COMMUNICATION_FAILURE = DWORD($8000401D); + CO_E_SERVER_START_TIMEOUT = DWORD($8000401E); + CO_E_CLSREG_INCONSISTENT = DWORD($8000401F); + CO_E_IIDREG_INCONSISTENT = DWORD($80004020); + CO_E_NOT_SUPPORTED = DWORD($80004021); + + CO_E_FIRST = DWORD($800401F0); + CO_E_LAST = DWORD($800401FF); + CO_S_FIRST = $401F0; + CO_S_LAST = $401FF; + S_OK = $00000000; + S_FALSE = $00000001; + + CO_E_NOTINITIALIZED = DWORD($800401F0); + CO_E_ALREADYINITIALIZED = DWORD($800401F1); + CO_E_CANTDETERMINECLASS = DWORD($800401F2); + CO_E_CLASSSTRING = DWORD($800401F3); + CO_E_IIDSTRING = DWORD($800401F4); + CO_E_APPNOTFOUND = DWORD($800401F5); + CO_E_APPSINGLEUSE = DWORD($800401F6); + CO_E_ERRORINAPP = DWORD($800401F7); + CO_E_DLLNOTFOUND = DWORD($800401F8); + CO_E_ERRORINDLL = DWORD($800401F9); + CO_E_WRONGOSFORAPP = DWORD($800401FA); + CO_E_OBJNOTREG = DWORD($800401FB); + CO_E_OBJISREG = DWORD($800401FC); + CO_E_OBJNOTCONNECTED = DWORD($800401FD); + CO_E_APPDIDNTREG = DWORD($800401FE); + CO_E_RELEASED = DWORD($800401FF); + + OLE_E_FIRST = $80040000; + OLE_E_LAST = $800400FF; + OLE_S_FIRST = $00040000; + OLE_S_LAST = $000400FF; + OLE_E_OLEVERB = $80040000; + OLE_E_ADVF = $80040001; + OLE_E_ENUM_NOMORE = $80040002; + OLE_E_ADVISENOTSUPPORTED = $80040003; + OLE_E_NOCONNECTION = $80040004; + OLE_E_NOTRUNNING = $80040005; + OLE_E_NOCACHE = $80040006; + OLE_E_BLANK = $80040007; + OLE_E_CLASSDIFF = $80040008; + OLE_E_CANT_GETMONIKER = $80040009; + OLE_E_CANT_BINDTOSOURCE = $8004000A; + OLE_E_STATIC = $8004000B; + OLE_E_PROMPTSAVECANCELLED = $8004000C; + OLE_E_INVALIDRECT = $8004000D; + OLE_E_WRONGCOMPOBJ = $8004000E; + OLE_E_INVALIDHWND = $8004000F; + OLE_E_NOT_INPLACEACTIVE = $80040010; + OLE_E_CANTCONVERT = $80040011; + OLE_E_NOSTORAGE = $80040012; + DV_E_FORMATETC = $80040064; + DV_E_DVTARGETDEVICE = $80040065; + DV_E_STGMEDIUM = $80040066; + DV_E_STATDATA = $80040067; + DV_E_LINDEX = $80040068; + DV_E_TYMED = $80040069; + DV_E_CLIPFORMAT = $8004006A; + DV_E_DVASPECT = $8004006B; + DV_E_DVTARGETDEVICE_SIZE = $8004006C; + DV_E_NOIVIEWOBJECT = $8004006D; + DRAGDROP_E_FIRST = $80040100; + DRAGDROP_E_LAST = $8004010F; + DRAGDROP_S_FIRST = $00040100; + DRAGDROP_S_LAST = $0004010F; + DRAGDROP_E_NOTREGISTERED = $80040100; + DRAGDROP_E_ALREADYREGISTERED = $80040101; + DRAGDROP_E_INVALIDHWND = $80040102; + CLASSFACTORY_E_FIRST = $80040110; + CLASSFACTORY_E_LAST = $8004011F; + CLASSFACTORY_S_FIRST = $00040110; + CLASSFACTORY_S_LAST = $0004011F; + CLASS_E_NOAGGREGATION = $80040110; + CLASS_E_CLASSNOTAVAILABLE = $80040111; + MARSHAL_E_FIRST = $80040120; + MARSHAL_E_LAST = $8004012F; + MARSHAL_S_FIRST = $00040120; + MARSHAL_S_LAST = $0004012F; + DATA_E_FIRST = $80040130; + DATA_E_LAST = $8004013F; + DATA_S_FIRST = $00040130; + DATA_S_LAST = $0004013F; + VIEW_E_FIRST = $80040140; + VIEW_E_LAST = $8004014F; + VIEW_S_FIRST = $00040140; + VIEW_S_LAST = $0004014F; + VIEW_E_DRAW = $80040140; + REGDB_E_FIRST = $80040150; + REGDB_E_LAST = $8004015F; + REGDB_S_FIRST = $00040150; + REGDB_S_LAST = $0004015F; + REGDB_E_READREGDB = $80040150; + REGDB_E_WRITEREGDB = $80040151; + REGDB_E_KEYMISSING = $80040152; + REGDB_E_INVALIDVALUE = $80040153; + REGDB_E_CLASSNOTREG = $80040154; + REGDB_E_IIDNOTREG = $80040155; + CACHE_E_FIRST = $80040170; + CACHE_E_LAST = $8004017F; + CACHE_S_FIRST = $00040170; + CACHE_S_LAST = $0004017F; + CACHE_E_NOCACHE_UPDATED = $80040170; + OLEOBJ_E_FIRST = $80040180; + OLEOBJ_E_LAST = $8004018F; + OLEOBJ_S_FIRST = $00040180; + OLEOBJ_S_LAST = $0004018F; + OLEOBJ_E_NOVERBS = $80040180; + OLEOBJ_E_INVALIDVERB = $80040181; + CLIENTSITE_E_FIRST = $80040190; + CLIENTSITE_E_LAST = $8004019F; + CLIENTSITE_S_FIRST = $00040190; + CLIENTSITE_S_LAST = $0004019F; + INPLACE_E_NOTUNDOABLE = $800401A0; + INPLACE_E_NOTOOLSPACE = $800401A1; + INPLACE_E_FIRST = $800401A0; + INPLACE_E_LAST = $800401AF; + INPLACE_S_FIRST = $000401A0; + INPLACE_S_LAST = $000401AF; + ENUM_E_FIRST = $800401B0; + ENUM_E_LAST = $800401BF; + ENUM_S_FIRST = $000401B0; + ENUM_S_LAST = $000401BF; + CONVERT10_E_FIRST = $800401C0; + CONVERT10_E_LAST = $800401CF; + CONVERT10_S_FIRST = $000401C0; + CONVERT10_S_LAST = $000401CF; + CONVERT10_E_OLESTREAM_GET = $800401C0; + CONVERT10_E_OLESTREAM_PUT = $800401C1; + CONVERT10_E_OLESTREAM_FMT = $800401C2; + CONVERT10_E_OLESTREAM_BITMAP_TO_DIB = $800401C3; + CONVERT10_E_STG_FMT = $800401C4; + CONVERT10_E_STG_NO_STD_STREAM = $800401C5; + CONVERT10_E_STG_DIB_TO_BITMAP = $800401C6; + CLIPBRD_E_FIRST = $800401D0; + CLIPBRD_E_LAST = $800401DF; + CLIPBRD_S_FIRST = $000401D0; + CLIPBRD_S_LAST = $000401DF; + CLIPBRD_E_CANT_OPEN = $800401D0; + CLIPBRD_E_CANT_EMPTY = $800401D1; + CLIPBRD_E_CANT_SET = $800401D2; + CLIPBRD_E_BAD_DATA = $800401D3; + CLIPBRD_E_CANT_CLOSE = $800401D4; + MK_E_FIRST = $800401E0; + MK_E_LAST = $800401EF; + MK_S_FIRST = $000401E0; + MK_S_LAST = $000401EF; + MK_E_CONNECTMANUALLY = $800401E0; + MK_E_EXCEEDEDDEADLINE = $800401E1; + MK_E_NEEDGENERIC = $800401E2; + MK_E_UNAVAILABLE = $800401E3; + MK_E_SYNTAX = $800401E4; + MK_E_NOOBJECT = $800401E5; + MK_E_INVALIDEXTENSION = $800401E6; + MK_E_INTERMEDIATEINTERFACENOTSUPPORTED = $800401E7; + MK_E_NOTBINDABLE = $800401E8; + MK_E_NOTBOUND = $800401E9; + MK_E_CANTOPENFILE = $800401EA; + MK_E_MUSTBOTHERUSER = $800401EB; + MK_E_NOINVERSE = $800401EC; + MK_E_NOSTORAGE = $800401ED; + MK_E_NOPREFIX = $800401EE; + MK_E_ENUMERATION_FAILED = $800401EF; + OLE_S_USEREG = $00040000; + OLE_S_STATIC = $00040001; + OLE_S_MAC_CLIPFORMAT = $00040002; + DRAGDROP_S_DROP = $00040100; + DRAGDROP_S_CANCEL = $00040101; + DRAGDROP_S_USEDEFAULTCURSORS = $00040102; + DATA_S_SAMEFORMATETC = $00040130; + VIEW_S_ALREADY_FROZEN = $00040140; + CACHE_S_FORMATETC_NOTSUPPORTED = $00040170; + CACHE_S_SAMECACHE = $00040171; + CACHE_S_SOMECACHES_NOTUPDATED = $00040172; + OLEOBJ_S_INVALIDVERB = $00040180; + OLEOBJ_S_CANNOT_DOVERB_NOW = $00040181; + OLEOBJ_S_INVALIDHWND = $00040182; + INPLACE_S_TRUNCATED = $000401A0; + CONVERT10_S_NO_PRESENTATION = $000401C0; + MK_S_REDUCED_TO_SELF = $000401E2; + MK_S_ME = $000401E4; + MK_S_HIM = $000401E5; + MK_S_US = $000401E6; + MK_S_MONIKERALREADYREGISTERED = $000401E7; + CO_E_CLASS_CREATE_FAILED = $80080001; + CO_E_SCM_ERROR = $80080002; + CO_E_SCM_RPC_FAILURE = $80080003; + CO_E_BAD_PATH = $80080004; + CO_E_SERVER_EXEC_FAILURE = $80080005; + CO_E_OBJSRV_RPC_FAILURE = $80080006; + MK_E_NO_NORMALIZED = $80080007; + CO_E_SERVER_STOPPING = $80080008; + MEM_E_INVALID_ROOT = $80080009; + MEM_E_INVALID_LINK = $80080010; + MEM_E_INVALID_SIZE = $80080011; + CO_S_NOTALLINTERFACES = $00080012; + DISP_E_UNKNOWNINTERFACE = $80020001; + DISP_E_MEMBERNOTFOUND = $80020003; + DISP_E_PARAMNOTFOUND = $80020004; + DISP_E_TYPEMISMATCH = $80020005; + DISP_E_UNKNOWNNAME = $80020006; + DISP_E_NONAMEDARGS = $80020007; + DISP_E_BADVARTYPE = $80020008; + DISP_E_EXCEPTION = $80020009; + DISP_E_OVERFLOW = $8002000A; + DISP_E_BADINDEX = $8002000B; + DISP_E_UNKNOWNLCID = $8002000C; + DISP_E_ARRAYISLOCKED = $8002000D; + DISP_E_BADPARAMCOUNT = $8002000E; + DISP_E_PARAMNOTOPTIONAL = $8002000F; + DISP_E_BADCALLEE = $80020010; + DISP_E_NOTACOLLECTION = $80020011; + TYPE_E_BUFFERTOOSMALL = $80028016; + TYPE_E_INVDATAREAD = $80028018; + TYPE_E_UNSUPFORMAT = $80028019; + TYPE_E_REGISTRYACCESS = $8002801C; + TYPE_E_LIBNOTREGISTERED = $8002801D; + TYPE_E_UNDEFINEDTYPE = $80028027; + TYPE_E_QUALIFIEDNAMEDISALLOWED = $80028028; + TYPE_E_INVALIDSTATE = $80028029; + TYPE_E_WRONGTYPEKIND = $8002802A; + TYPE_E_ELEMENTNOTFOUND = $8002802B; + TYPE_E_AMBIGUOUSNAME = $8002802C; + TYPE_E_NAMECONFLICT = $8002802D; + TYPE_E_UNKNOWNLCID = $8002802E; + TYPE_E_DLLFUNCTIONNOTFOUND = $8002802F; + TYPE_E_BADMODULEKIND = $800288BD; + TYPE_E_SIZETOOBIG = $800288C5; + TYPE_E_DUPLICATEID = $800288C6; + TYPE_E_INVALIDID = $800288CF; + TYPE_E_TYPEMISMATCH = $80028CA0; + TYPE_E_OUTOFBOUNDS = $80028CA1; + TYPE_E_IOERROR = $80028CA2; + TYPE_E_CANTCREATETMPFILE = $80028CA3; + TYPE_E_CANTLOADLIBRARY = $80029C4A; + TYPE_E_INCONSISTENTPROPFUNCS = $80029C83; + TYPE_E_CIRCULARTYPE = $80029C84; + STG_E_INVALIDFUNCTION = $80030001; + STG_E_FILENOTFOUND = $80030002; + STG_E_PATHNOTFOUND = $80030003; + STG_E_TOOMANYOPENFILES = $80030004; + STG_E_ACCESSDENIED = $80030005; + STG_E_INVALIDHANDLE = $80030006; + STG_E_INSUFFICIENTMEMORY = $80030008; + STG_E_INVALIDPOINTER = $80030009; + STG_E_NOMOREFILES = $80030012; + STG_E_DISKISWRITEPROTECTED = $80030013; + STG_E_SEEKERROR = $80030019; + STG_E_WRITEFAULT = $8003001D; + STG_E_READFAULT = $8003001E; + STG_E_SHAREVIOLATION = $80030020; + STG_E_LOCKVIOLATION = $80030021; + STG_E_FILEALREADYEXISTS = $80030050; + STG_E_INVALIDPARAMETER = $80030057; + STG_E_MEDIUMFULL = $80030070; + STG_E_PROPSETMISMATCHED = $800300F0; + STG_E_ABNORMALAPIEXIT = $800300FA; + STG_E_INVALIDHEADER = $800300FB; + STG_E_INVALIDNAME = $800300FC; + STG_E_UNKNOWN = $800300FD; + STG_E_UNIMPLEMENTEDFUNCTION = $800300FE; + STG_E_INVALIDFLAG = $800300FF; + STG_E_INUSE = $80030100; + STG_E_NOTCURRENT = $80030101; + STG_E_REVERTED = $80030102; + STG_E_CANTSAVE = $80030103; + STG_E_OLDFORMAT = $80030104; + STG_E_OLDDLL = $80030105; + STG_E_SHAREREQUIRED = $80030106; + STG_E_NOTFILEBASEDSTORAGE = $80030107; + STG_E_EXTANTMARSHALLINGS = $80030108; + STG_E_DOCFILECORRUPT = $80030109; + STG_E_BADBASEADDRESS = $80030110; + STG_E_INCOMPLETE = $80030201; + STG_E_TERMINATED = $80030202; + STG_S_CONVERTED = $00030200; + STG_S_BLOCK = $00030201; + STG_S_RETRYNOW = $00030202; + STG_S_MONITORING = $00030203; + RPC_E_CALL_REJECTED = $80010001; + RPC_E_CALL_CANCELED = $80010002; + RPC_E_CANTPOST_INSENDCALL = $80010003; + RPC_E_CANTCALLOUT_INASYNCCALL = $80010004; + RPC_E_CANTCALLOUT_INEXTERNALCALL = $80010005; + RPC_E_CONNECTION_TERMINATED = $80010006; + RPC_E_SERVER_DIED = $80010007; + RPC_E_CLIENT_DIED = $80010008; + RPC_E_INVALID_DATAPACKET = $80010009; + RPC_E_CANTTRANSMIT_CALL = $8001000A; + RPC_E_CLIENT_CANTMARSHAL_DATA = $8001000B; + RPC_E_CLIENT_CANTUNMARSHAL_DATA = $8001000C; + RPC_E_SERVER_CANTMARSHAL_DATA = $8001000D; + RPC_E_SERVER_CANTUNMARSHAL_DATA = $8001000E; + RPC_E_INVALID_DATA = $8001000F; + RPC_E_INVALID_PARAMETER = $80010010; + RPC_E_CANTCALLOUT_AGAIN = $80010011; + RPC_E_SERVER_DIED_DNE = $80010012; + RPC_E_SYS_CALL_FAILED = $80010100; + RPC_E_OUT_OF_RESOURCES = $80010101; + RPC_E_ATTEMPTED_MULTITHREAD = $80010102; + RPC_E_NOT_REGISTERED = $80010103; + RPC_E_FAULT = $80010104; + RPC_E_SERVERFAULT = $80010105; + RPC_E_CHANGED_MODE = $80010106; + RPC_E_INVALIDMETHOD = $80010107; + RPC_E_DISCONNECTED = $80010108; + RPC_E_RETRY = $80010109; + RPC_E_SERVERCALL_RETRYLATER = $8001010A; + RPC_E_SERVERCALL_REJECTED = $8001010B; + RPC_E_INVALID_CALLDATA = $8001010C; + RPC_E_CANTCALLOUT_ININPUTSYNCCALL = $8001010D; + RPC_E_WRONG_THREAD = $8001010E; + RPC_E_THREAD_NOT_INIT = $8001010F; + RPC_E_VERSION_MISMATCH = $80010110; + RPC_E_INVALID_HEADER = $80010111; + RPC_E_INVALID_EXTENSION = $80010112; + RPC_E_INVALID_IPID = $80010113; + RPC_E_INVALID_OBJECT = $80010114; + RPC_S_CALLPENDING = $80010115; + RPC_S_WAITONTIMER = $80010116; + RPC_E_CALL_COMPLETE = $80010117; + RPC_E_UNSECURE_CALL = $80010118; + RPC_E_TOO_LATE = $80010119; + RPC_E_NO_GOOD_SECURITY_PACKAGES = $8001011A; + RPC_E_ACCESS_DENIED = $8001011B; + RPC_E_REMOTE_DISABLED = $8001011C; + RPC_E_INVALID_OBJREF = $8001011D; + RPC_E_UNEXPECTED = $8001FFFF; + NTE_BAD_UID = $80090001; + NTE_BAD_HASH = $80090002; + NTE_BAD_KEY = $80090003; + NTE_BAD_LEN = $80090004; + NTE_BAD_DATA = $80090005; + NTE_BAD_SIGNATURE = $80090006; + NTE_BAD_VER = $80090007; + NTE_BAD_ALGID = $80090008; + NTE_BAD_FLAGS = $80090009; + NTE_BAD_TYPE = $8009000A; + NTE_BAD_KEY_STATE = $8009000B; + NTE_BAD_HASH_STATE = $8009000C; + NTE_NO_KEY = $8009000D; + NTE_NO_MEMORY = $8009000E; + NTE_EXISTS = $8009000F; + NTE_PERM = $80090010; + NTE_NOT_FOUND = $80090011; + NTE_DOUBLE_ENCRYPT = $80090012; + NTE_BAD_PROVIDER = $80090013; + NTE_BAD_PROV_TYPE = $80090014; + NTE_BAD_PUBLIC_KEY = $80090015; + NTE_BAD_KEYSET = $80090016; + NTE_PROV_TYPE_NOT_DEF = $80090017; + NTE_PROV_TYPE_ENTRY_BAD = $80090018; + NTE_KEYSET_NOT_DEF = $80090019; + NTE_KEYSET_ENTRY_BAD = $8009001A; + NTE_PROV_TYPE_NO_MATCH = $8009001B; + NTE_SIGNATURE_FILE_BAD = $8009001C; + NTE_PROVIDER_DLL_FAIL = $8009001D; + NTE_PROV_DLL_NOT_FOUND = $8009001E; + NTE_BAD_KEYSET_PARAM = $8009001F; + NTE_FAIL = $80090020; + NTE_SYS_ERR = $80090021; + NTE_OP_OK = 0; + TRUST_E_PROVIDER_UNKNOWN = $800B0001; + TRUST_E_ACTION_UNKNOWN = $800B0002; + TRUST_E_SUBJECT_FORM_UNKNOWN = $800B0003; + TRUST_E_SUBJECT_NOT_TRUSTED = $800B0004; + DIGSIG_E_ENCODE = $800B0005; + DIGSIG_E_DECODE = $800B0006; + DIGSIG_E_EXTENSIBILITY = $800B0007; + DIGSIG_E_CRYPTO = $800B0008; + PERSIST_E_SIZEDEFINITE = $800B0009; + PERSIST_E_SIZEINDEFINITE = $800B000A; + PERSIST_E_NOTSELFSIZING = $800B000B; + TRUST_E_NOSIGNATURE = $800B0100; + CERT_E_EXPIRED = $800B0101; + CERT_E_VALIDIYPERIODNESTING = $800B0102; + CERT_E_ROLE = $800B0103; + CERT_E_PATHLENCONST = $800B0104; + CERT_E_CRITICAL = $800B0105; + CERT_E_PURPOSE = $800B0106; + CERT_E_ISSUERCHAINING = $800B0107; + CERT_E_MALFORMED = $800B0108; + CERT_E_UNTRUSTEDROOT = $800B0109; + CERT_E_CHAINING = $800B010A; + +{$endif read_interface} + diff --git a/rtl/wince/wininc/func.inc b/rtl/wince/wininc/func.inc new file mode 100644 index 0000000000..eb61d679a1 --- /dev/null +++ b/rtl/wince/wininc/func.inc @@ -0,0 +1,2387 @@ +{ + This file is part of the Free Pascal run time library. + This unit contains the record definition for the Win32 API + Copyright (c) 1999-2000 by Florian KLaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + + +{ + Functions.h + + Declarations for all the Windows32 API Functions + + Copyright (C) 1996, 1997 Free Software Foundation, Inc. + + Author: Scott Christley + + This file is part of the Windows32 API Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Changes : + + 22/15/2005 update for wince4.2 port, orinaudo@gmail.com +} + +{$ifdef read_interface} +//begin common win32 & wince +function FreeLibrary(hLibModule:HMODULE):WINBOOL; external KernelDLL name 'FreeLibrary'; +procedure FreeLibraryAndExitThread(hLibModule:HMODULE; dwExitCode:DWORD); external KernelDLL name 'FreeLibraryAndExitThread'; +function GetDlgCtrlID(hWnd:HWND):longint; external UserDLL name 'GetDlgCtrlID'; +function GetWindow(hWnd:HWND; uCmd:UINT):HWND; external UserDLL name 'GetWindow'; +function InterlockedIncrement(lpAddend:LPLONG):LONG; external KernelDLL name 'InterlockedIncrement'; +function InterlockedDecrement(lpAddend:LPLONG):LONG; external KernelDLL name 'InterlockedDecrement'; +function InterlockedCompareExchange( var Destination:LPLONG; Exchange:LONG; Comperand:LONG):LONG; external KernelDLL name 'InterlockedCompareExchange'; +function InterlockedExchange(Target:LPLONG; Value:LONG):LONG; external KernelDLL name 'InterlockedExchange'; +function InterlockedExchangeAdd( Addend:LPLONG; Value:LONG):LONG; external KernelDLL name 'InterlockedExchangeAdd'; +function InterlockedTestExchange( Target:LPLONG; oldValue:LONG; newValue:LONG):LONG; external KernelDLL name 'InterlockedTestExchange'; +//end common win32 & wince + +{$ifdef WINCE} +//begin wince only + +//end wince only +{$endif WINCE} + +{$ifdef WIN32} +//begin win32 only +function AccessCheck(pSecurityDescriptor:PSECURITY_DESCRIPTOR; ClientToken:HANDLE; DesiredAccess:DWORD; GenericMapping:PGENERIC_MAPPING; PrivilegeSet:PPRIVILEGE_SET;PrivilegeSetLength:LPDWORD; + GrantedAccess:LPDWORD; AccessStatus:LPBOOL):WINBOOL; external 'advapi32' name 'AccessCheck'; +//end win32 only + + +//begin win32 or wince not checked +function LockResource(hResData:HGLOBAL):LPVOID; external 'kernel32' name 'LockResource'; +function FreeResource(hResData:HGLOBAL):WINBOOL; external 'kernel32' name 'FreeResource'; +{$ifdef Unknown_functions} +{ WARNING: function not found !!} +function WinMain(hInstance:HINST; hPrevInstance:HINST; lpCmdLine:LPSTR; nShowCmd:longint):longint; external External_library name 'WinMain'; +{$endif Unknown_functions} +function DisableThreadLibraryCalls(hLibModule:HMODULE):WINBOOL; external 'kernel32' name 'DisableThreadLibraryCalls'; +function GetProcAddress(hModule:HINST; lpProcName:LPCSTR):FARPROC; external 'kernel32' name 'GetProcAddress'; +function GetVersion:DWORD; external 'kernel32' name 'GetVersion'; +function GlobalAlloc(uFlags:UINT; dwBytes:DWORD):HGLOBAL; external 'kernel32' name 'GlobalAlloc'; +function GlobalDiscard(hglbMem:HGLOBAL):HGLOBAL; +function GlobalReAlloc(hMem:HGLOBAL; dwBytes:DWORD; uFlags:UINT):HGLOBAL; external 'kernel32' name 'GlobalReAlloc'; +function GlobalSize(hMem:HGLOBAL):DWORD; external 'kernel32' name 'GlobalSize'; +function GlobalFlags(hMem:HGLOBAL):UINT; external 'kernel32' name 'GlobalFlags'; +function GlobalLock(hMem:HGLOBAL):LPVOID; external 'kernel32' name 'GlobalLock'; +function GlobalHandle(pMem:LPCVOID):HGLOBAL; external 'kernel32' name 'GlobalHandle'; +function GlobalUnlock(hMem:HGLOBAL):WINBOOL; external 'kernel32' name 'GlobalUnlock'; +function GlobalFree(hMem:HGLOBAL):HGLOBAL; external 'kernel32' name 'GlobalFree'; +function GlobalCompact(dwMinFree:DWORD):UINT; external 'kernel32' name 'GlobalCompact'; +procedure GlobalFix(hMem:HGLOBAL); external 'kernel32' name 'GlobalFix'; +procedure GlobalUnfix(hMem:HGLOBAL); external 'kernel32' name 'GlobalUnfix'; +function GlobalWire(hMem:HGLOBAL):LPVOID; external 'kernel32' name 'GlobalWire'; +function GlobalUnWire(hMem:HGLOBAL):WINBOOL; external 'kernel32' name 'GlobalUnWire'; +procedure GlobalMemoryStatus(lpBuffer:LPMEMORYSTATUS); external 'kernel32' name 'GlobalMemoryStatus'; +function LocalAlloc(uFlags:UINT; uBytes:UINT):HLOCAL; external 'kernel32' name 'LocalAlloc'; +function LocalDiscard(hlocMem:HLOCAL):HLOCAL; +function LocalReAlloc(hMem:HLOCAL; uBytes:UINT; uFlags:UINT):HLOCAL; external 'kernel32' name 'LocalReAlloc'; +function LocalLock(hMem:HLOCAL):LPVOID; external 'kernel32' name 'LocalLock'; +function LocalHandle(pMem:LPCVOID):HLOCAL; external 'kernel32' name 'LocalHandle'; +function LocalUnlock(hMem:HLOCAL):WINBOOL; external 'kernel32' name 'LocalUnlock'; +function LocalSize(hMem:HLOCAL):UINT; external 'kernel32' name 'LocalSize'; +function LocalFlags(hMem:HLOCAL):UINT; external 'kernel32' name 'LocalFlags'; +function LocalFree(hMem:HLOCAL):HLOCAL; external 'kernel32' name 'LocalFree'; +function LocalShrink(hMem:HLOCAL; cbNewSize:UINT):UINT; external 'kernel32' name 'LocalShrink'; +function LocalCompact(uMinFree:UINT):UINT; external 'kernel32' name 'LocalCompact'; +function FlushInstructionCache(hProcess:HANDLE; lpBaseAddress:LPCVOID; dwSize:DWORD):WINBOOL; external 'kernel32' name 'FlushInstructionCache'; +function VirtualAlloc(lpAddress:LPVOID; dwSize:DWORD; flAllocationType:DWORD; flProtect:DWORD):LPVOID; external 'kernel32' name 'VirtualAlloc'; +function VirtualFree(lpAddress:LPVOID; dwSize:DWORD; dwFreeType:DWORD):WINBOOL; external 'kernel32' name 'VirtualFree'; +function VirtualProtect(lpAddress:LPVOID; dwSize:DWORD; flNewProtect:DWORD; lpflOldProtect:PDWORD):WINBOOL; external 'kernel32' name 'VirtualProtect'; +function VirtualQuery(lpAddress:LPCVOID; lpBuffer:PMEMORY_BASIC_INFORMATION; dwLength:DWORD):DWORD; external 'kernel32' name 'VirtualQuery'; +function VirtualProtectEx(hProcess:HANDLE; lpAddress:LPVOID; dwSize:DWORD; flNewProtect:DWORD; lpflOldProtect:PDWORD):WINBOOL; external 'kernel32' name 'VirtualProtectEx'; +function VirtualQueryEx(hProcess:HANDLE; lpAddress:LPCVOID; lpBuffer:PMEMORY_BASIC_INFORMATION; dwLength:DWORD):DWORD; external 'kernel32' name 'VirtualQueryEx'; +function HeapCreate(flOptions:DWORD; dwInitialSize:DWORD; dwMaximumSize:DWORD):HANDLE; external 'kernel32' name 'HeapCreate'; +function HeapDestroy(hHeap:HANDLE):WINBOOL; external 'kernel32' name 'HeapDestroy'; +function HeapAlloc(hHeap:HANDLE; dwFlags:DWORD; dwBytes:DWORD):LPVOID; external 'kernel32' name 'HeapAlloc'; +function HeapReAlloc(hHeap:HANDLE; dwFlags:DWORD; lpMem:LPVOID; dwBytes:DWORD):LPVOID; external 'kernel32' name 'HeapReAlloc'; +function HeapFree(hHeap:HANDLE; dwFlags:DWORD; lpMem:LPVOID):WINBOOL; external 'kernel32' name 'HeapFree'; +function HeapSize(hHeap:HANDLE; dwFlags:DWORD; lpMem:LPCVOID):DWORD; external 'kernel32' name 'HeapSize'; +function HeapValidate(hHeap:HANDLE; dwFlags:DWORD; lpMem:LPCVOID):WINBOOL; external 'kernel32' name 'HeapValidate'; +function HeapCompact(hHeap:HANDLE; dwFlags:DWORD):UINT; external 'kernel32' name 'HeapCompact'; +function GetProcessHeap:HANDLE; external 'kernel32' name 'GetProcessHeap'; +function GetProcessHeaps(NumberOfHeaps:DWORD; ProcessHeaps:PHANDLE):DWORD; external 'kernel32' name 'GetProcessHeaps'; +function HeapLock(hHeap:HANDLE):WINBOOL; external 'kernel32' name 'HeapLock'; +function HeapUnlock(hHeap:HANDLE):WINBOOL; external 'kernel32' name 'HeapUnlock'; +function HeapWalk(hHeap:HANDLE; lpEntry:LPPROCESS_HEAP_ENTRY):WINBOOL; external 'kernel32' name 'HeapWalk'; +function GetProcessAffinityMask(hProcess:HANDLE; lpProcessAffinityMask:LPDWORD; lpSystemAffinityMask:LPDWORD):WINBOOL; external 'kernel32' name 'GetProcessAffinityMask'; +function GetProcessTimes(hProcess:HANDLE; lpCreationTime:LPFILETIME; lpExitTime:LPFILETIME; lpKernelTime:LPFILETIME; lpUserTime:LPFILETIME):WINBOOL; external 'kernel32' name 'GetProcessTimes'; +function GetProcessWorkingSetSize(hProcess:HANDLE; lpMinimumWorkingSetSize:LPDWORD; lpMaximumWorkingSetSize:LPDWORD):WINBOOL; external 'kernel32' name 'GetProcessWorkingSetSize'; +function SetProcessWorkingSetSize(hProcess:HANDLE; dwMinimumWorkingSetSize:DWORD; dwMaximumWorkingSetSize:DWORD):WINBOOL; external 'kernel32' name 'SetProcessWorkingSetSize'; +function OpenProcess(dwDesiredAccess:DWORD; bInheritHandle:WINBOOL; dwProcessId:DWORD):HANDLE; external 'kernel32' name 'OpenProcess'; +function GetCurrentProcess:HANDLE; external 'kernel32' name 'GetCurrentProcess'; +function GetCurrentProcessId:DWORD; external 'kernel32' name 'GetCurrentProcessId'; +procedure ExitProcess(uExitCode:UINT);external 'kernel32' name 'ExitProcess'; +function TerminateProcess(hProcess:HANDLE; uExitCode:UINT):WINBOOL; external 'kernel32' name 'TerminateProcess'; +function GetExitCodeProcess(hProcess:HANDLE; lpExitCode:LPDWORD):WINBOOL; external 'kernel32' name 'GetExitCodeProcess'; +procedure FatalExit(ExitCode:longint); external 'kernel32' name 'FatalExit'; +procedure RaiseException(dwExceptionCode:DWORD; dwExceptionFlags:DWORD; nNumberOfArguments:DWORD; lpArguments:LPDWORD); external 'kernel32' name 'RaiseException'; +function UnhandledExceptionFilter(ExceptionInfo:lpemptyrecord):LONG; external 'kernel32' name 'UnhandledExceptionFilter'; +function CreateRemoteThread(hProcess:HANDLE; lpThreadAttributes:LPSECURITY_ATTRIBUTES; dwStackSize:DWORD; lpStartAddress:LPTHREAD_START_ROUTINE; lpParameter:LPVOID; + dwCreationFlags:DWORD; lpThreadId:LPDWORD):HANDLE; external 'kernel32' name 'CreateRemoteThread'; +function GetCurrentThread:HANDLE; external 'kernel32' name 'GetCurrentThread'; +function GetCurrentThreadId:DWORD; external 'kernel32' name 'GetCurrentThreadId'; +function SetThreadAffinityMask(hThread:HANDLE; dwThreadAffinityMask:DWORD):DWORD; external 'kernel32' name 'SetThreadAffinityMask'; +function SetThreadPriority(hThread:HANDLE; nPriority:longint):WINBOOL; external 'kernel32' name 'SetThreadPriority'; +function GetThreadPriority(hThread:HANDLE):longint; external 'kernel32' name 'GetThreadPriority'; +function GetThreadTimes(hThread:HANDLE; lpCreationTime:LPFILETIME; lpExitTime:LPFILETIME; lpKernelTime:LPFILETIME; lpUserTime:LPFILETIME):WINBOOL; external 'kernel32' name 'GetThreadTimes'; +procedure ExitThread(dwExitCode:DWORD); external 'kernel32' name 'ExitThread'; +function TerminateThread(hThread:HANDLE; dwExitCode:DWORD):WINBOOL; external 'kernel32' name 'TerminateThread'; +function GetExitCodeThread(hThread:HANDLE; lpExitCode:LPDWORD):WINBOOL; external 'kernel32' name 'GetExitCodeThread'; +{$ifdef LPLDT_ENTRY} +function GetThreadSelectorEntry(hThread:HANDLE; dwSelector:DWORD; lpSelectorEntry:LPLDT_ENTRY):WINBOOL; external 'kernel32' name 'GetThreadSelectorEntry'; +{$endif LPLDT_ENTRY} +function GetLastError:DWORD; external 'kernel32' name 'GetLastError'; +procedure SetLastError(dwErrCode:DWORD); external 'kernel32' name 'SetLastError'; +function CreateIoCompletionPort(FileHandle:HANDLE; ExistingCompletionPort:HANDLE; CompletionKey:DWORD; NumberOfConcurrentThreads:DWORD):HANDLE; external 'kernel32' name 'CreateIoCompletionPort'; +function SetErrorMode(uMode:UINT):UINT; external 'kernel32' name 'SetErrorMode'; +function ReadProcessMemory(hProcess:HANDLE; lpBaseAddress:LPCVOID; lpBuffer:LPVOID; nSize:DWORD; lpNumberOfBytesRead:LPDWORD):WINBOOL; external 'kernel32' name 'ReadProcessMemory'; +function WriteProcessMemory(hProcess:HANDLE; lpBaseAddress:LPVOID; lpBuffer:LPVOID; nSize:DWORD; lpNumberOfBytesWritten:LPDWORD):WINBOOL; external 'kernel32' name 'WriteProcessMemory'; +function GetThreadContext(hThread:HANDLE; lpContext:LPCONTEXT):WINBOOL; external 'kernel32' name 'GetThreadContext'; +function SuspendThread(hThread:HANDLE):DWORD; external 'kernel32' name 'SuspendThread'; +function ResumeThread(hThread:HANDLE):DWORD; external 'kernel32' name 'ResumeThread'; +procedure DebugBreak; external 'kernel32' name 'DebugBreak'; +function WaitForDebugEvent(lpDebugEvent:LPDEBUG_EVENT; dwMilliseconds:DWORD):WINBOOL; external 'kernel32' name 'WaitForDebugEvent'; +function ContinueDebugEvent(dwProcessId:DWORD; dwThreadId:DWORD; dwContinueStatus:DWORD):WINBOOL; external 'kernel32' name 'ContinueDebugEvent'; +function DebugActiveProcess(dwProcessId:DWORD):WINBOOL; external 'kernel32' name 'DebugActiveProcess'; +procedure InitializeCriticalSection(lpCriticalSection:LPCRITICAL_SECTION); external 'kernel32' name 'InitializeCriticalSection'; +procedure EnterCriticalSection(lpCriticalSection:LPCRITICAL_SECTION); external 'kernel32' name 'EnterCriticalSection'; +procedure LeaveCriticalSection(lpCriticalSection:LPCRITICAL_SECTION); external 'kernel32' name 'LeaveCriticalSection'; +procedure DeleteCriticalSection(lpCriticalSection:LPCRITICAL_SECTION); external 'kernel32' name 'DeleteCriticalSection'; +function SetEvent(hEvent:HANDLE):WINBOOL; external 'kernel32' name 'SetEvent'; +function ResetEvent(hEvent:HANDLE):WINBOOL; external 'kernel32' name 'ResetEvent'; +function PulseEvent(hEvent:HANDLE):WINBOOL; external 'kernel32' name 'PulseEvent'; +function ReleaseSemaphore(hSemaphore:HANDLE; lReleaseCount:LONG; lpPreviousCount:LPLONG):WINBOOL; external 'kernel32' name 'ReleaseSemaphore'; +function ReleaseMutex(hMutex:HANDLE):WINBOOL; external 'kernel32' name 'ReleaseMutex'; +function WaitForSingleObject(hHandle:HANDLE; dwMilliseconds:DWORD):DWORD; external 'kernel32' name 'WaitForSingleObject'; +function WaitForMultipleObjects(nCount:DWORD; lpHandles : PWOHandleArray; bWaitAll:WINBOOL; dwMilliseconds:DWORD):DWORD; external 'kernel32' name 'WaitForMultipleObjects'; +procedure Sleep(dwMilliseconds:DWORD); external 'kernel32' name 'Sleep'; +function LoadResource(hModule:HINST; hResInfo:HRSRC):HGLOBAL; external 'kernel32' name 'LoadResource'; +function SizeofResource(hModule:HINST; hResInfo:HRSRC):DWORD; external 'kernel32' name 'SizeofResource'; +function GlobalDeleteAtom(nAtom:ATOM):ATOM; external 'kernel32' name 'GlobalDeleteAtom'; +function InitAtomTable(nSize:DWORD):WINBOOL; external 'kernel32' name 'InitAtomTable'; +function DeleteAtom(nAtom:ATOM):ATOM; external 'kernel32' name 'DeleteAtom'; +function SetHandleCount(uNumber:UINT):UINT; external 'kernel32' name 'SetHandleCount'; +function GetLogicalDrives:DWORD; external 'kernel32' name 'GetLogicalDrives'; +function LockFile(hFile:HANDLE; dwFileOffsetLow:DWORD; dwFileOffsetHigh:DWORD; nNumberOfBytesToLockLow:DWORD; nNumberOfBytesToLockHigh:DWORD):WINBOOL; external 'kernel32' name 'LockFile'; +function UnlockFile(hFile:HANDLE; dwFileOffsetLow:DWORD; dwFileOffsetHigh:DWORD; nNumberOfBytesToUnlockLow:DWORD; nNumberOfBytesToUnlockHigh:DWORD):WINBOOL; external 'kernel32' name 'UnlockFile'; +function LockFileEx(hFile:HANDLE; dwFlags:DWORD; dwReserved:DWORD; nNumberOfBytesToLockLow:DWORD; nNumberOfBytesToLockHigh:DWORD;lpOverlapped:LPOVERLAPPED):WINBOOL; external 'kernel32' name 'LockFileEx'; +function UnlockFileEx(hFile:HANDLE; dwReserved:DWORD; nNumberOfBytesToUnlockLow:DWORD; nNumberOfBytesToUnlockHigh:DWORD; lpOverlapped:LPOVERLAPPED):WINBOOL; external 'kernel32' name 'UnlockFileEx'; +function GetFileInformationByHandle(hFile:HANDLE; lpFileInformation:LPBY_HANDLE_FILE_INFORMATION):WINBOOL; external 'kernel32' name 'GetFileInformationByHandle'; +function GetFileType(hFile:HANDLE):DWORD; external 'kernel32' name 'GetFileType'; +function GetFileSize(hFile:HANDLE; lpFileSizeHigh:LPDWORD):DWORD; external 'kernel32' name 'GetFileSize'; +function GetStdHandle(nStdHandle:DWORD):HANDLE; external 'kernel32' name 'GetStdHandle'; +function SetStdHandle(nStdHandle:DWORD; hHandle:HANDLE):WINBOOL; external 'kernel32' name 'SetStdHandle'; +function FlushFileBuffers(hFile:HANDLE):WINBOOL; external 'kernel32' name 'FlushFileBuffers'; +function DeviceIoControl(hDevice:HANDLE; dwIoControlCode:DWORD; lpInBuffer:LPVOID; nInBufferSize:DWORD; lpOutBuffer:LPVOID;nOutBufferSize:DWORD; lpBytesReturned:LPDWORD; lpOverlapped:LPOVERLAPPED):WINBOOL; external 'kernel32' name 'DeviceIoControl'; +function SetEndOfFile(hFile:HANDLE):WINBOOL; external 'kernel32' name 'SetEndOfFile'; +function SetFilePointer(hFile:HANDLE; lDistanceToMove:LONG; lpDistanceToMoveHigh:PLONG; dwMoveMethod:DWORD):DWORD; external 'kernel32' name 'SetFilePointer'; +function FindClose(hFindFile:HANDLE):WINBOOL; external 'kernel32' name 'FindClose'; +function GetFileTime(hFile:HANDLE; lpCreationTime:LPFILETIME; lpLastAccessTime:LPFILETIME; lpLastWriteTime:LPFILETIME):WINBOOL; external 'kernel32' name 'GetFileTime'; +function SetFileTime(hFile:HANDLE; lpCreationTime:LPFILETIME; lpLastAccessTime:LPFILETIME; lpLastWriteTime:LPFILETIME):WINBOOL; external 'kernel32' name 'SetFileTime'; +function CloseHandle(hObject:HANDLE):WINBOOL; external 'kernel32' name 'CloseHandle'; +function DuplicateHandle(hSourceProcessHandle:HANDLE; hSourceHandle:HANDLE; hTargetProcessHandle:HANDLE; lpTargetHandle:LPHANDLE; dwDesiredAccess:DWORD;bInheritHandle:WINBOOL; dwOptions:DWORD):WINBOOL; external 'kernel32' name 'DuplicateHandle'; +function GetHandleInformation(hObject:HANDLE; lpdwFlags:LPDWORD):WINBOOL; external 'kernel32' name 'GetHandleInformation'; +function SetHandleInformation(hObject:HANDLE; dwMask:DWORD; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'SetHandleInformation'; +function LoadModule(lpModuleName:LPCSTR; lpParameterBlock:LPVOID):DWORD; external 'kernel32' name 'LoadModule'; +function WinExec(lpCmdLine:LPCSTR; uCmdShow:UINT):UINT; external 'kernel32' name 'WinExec'; +function ClearCommBreak(hFile:HANDLE):WINBOOL; external 'kernel32' name 'ClearCommBreak'; +function ClearCommError(hFile:HANDLE; lpErrors:LPDWORD; lpStat:LPCOMSTAT):WINBOOL; external 'kernel32' name 'ClearCommError'; +function SetupComm(hFile:HANDLE; dwInQueue:DWORD; dwOutQueue:DWORD):WINBOOL; external 'kernel32' name 'SetupComm'; +function EscapeCommFunction(hFile:HANDLE; dwFunc:DWORD):WINBOOL; external 'kernel32' name 'EscapeCommFunction'; +function GetCommConfig(hCommDev:HANDLE; lpCC:LPCOMMCONFIG; lpdwSize:LPDWORD):WINBOOL; external 'kernel32' name 'GetCommConfig'; +function GetCommProperties(hFile:HANDLE; lpCommProp:LPCOMMPROP):WINBOOL; external 'kernel32' name 'GetCommProperties'; +function GetCommModemStatus(hFile:HANDLE; lpModemStat:PDWORD):WINBOOL; external 'kernel32' name 'GetCommModemStatus'; +function GetCommState(hFile:HANDLE; lpDCB:PDCB):WINBOOL; external 'kernel32' name 'GetCommState'; +function GetCommTimeouts(hFile:HANDLE; lpCommTimeouts:PCOMMTIMEOUTS):WINBOOL; external 'kernel32' name 'GetCommTimeouts'; +function PurgeComm(hFile:HANDLE; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'PurgeComm'; +function SetCommBreak(hFile:HANDLE):WINBOOL; external 'kernel32' name 'SetCommBreak'; +function SetCommConfig(hCommDev:HANDLE; lpCC:LPCOMMCONFIG; dwSize:DWORD):WINBOOL; external 'kernel32' name 'SetCommConfig'; +function SetCommMask(hFile:HANDLE; dwEvtMask:DWORD):WINBOOL; external 'kernel32' name 'SetCommMask'; +function SetCommState(hFile:HANDLE; lpDCB:LPDCB):WINBOOL; external 'kernel32' name 'SetCommState'; +function SetCommTimeouts(hFile:HANDLE; lpCommTimeouts:LPCOMMTIMEOUTS):WINBOOL; external 'kernel32' name 'SetCommTimeouts'; +function TransmitCommChar(hFile:HANDLE; cChar:char):WINBOOL; external 'kernel32' name 'TransmitCommChar'; +function WaitCommEvent(hFile:HANDLE; lpEvtMask:LPDWORD; lpOverlapped:LPOVERLAPPED):WINBOOL; external 'kernel32' name 'WaitCommEvent'; +function SetTapePosition(hDevice:HANDLE; dwPositionMethod:DWORD; dwPartition:DWORD; dwOffsetLow:DWORD; dwOffsetHigh:DWORD;bImmediate:WINBOOL):DWORD; external 'kernel32' name 'SetTapePosition'; +function GetTapePosition(hDevice:HANDLE; dwPositionType:DWORD; lpdwPartition:LPDWORD; lpdwOffsetLow:LPDWORD; lpdwOffsetHigh:LPDWORD):DWORD; external 'kernel32' name 'GetTapePosition'; +function PrepareTape(hDevice:HANDLE; dwOperation:DWORD; bImmediate:WINBOOL):DWORD; external 'kernel32' name 'PrepareTape'; +function EraseTape(hDevice:HANDLE; dwEraseType:DWORD; bImmediate:WINBOOL):DWORD; external 'kernel32' name 'EraseTape'; +function CreateTapePartition(hDevice:HANDLE; dwPartitionMethod:DWORD; dwCount:DWORD; dwSize:DWORD):DWORD; external 'kernel32' name 'CreateTapePartition'; +function WriteTapemark(hDevice:HANDLE; dwTapemarkType:DWORD; dwTapemarkCount:DWORD; bImmediate:WINBOOL):DWORD; external 'kernel32' name 'WriteTapemark'; +function GetTapeStatus(hDevice:HANDLE):DWORD; external 'kernel32' name 'GetTapeStatus'; +function GetTapeParameters(hDevice:HANDLE; dwOperation:DWORD; lpdwSize:LPDWORD; lpTapeInformation:LPVOID):DWORD; external 'kernel32' name 'GetTapeParameters'; +function SetTapeParameters(hDevice:HANDLE; dwOperation:DWORD; lpTapeInformation:LPVOID):DWORD; external 'kernel32' name 'SetTapeParameters'; +function Beep(dwFreq:DWORD; dwDuration:DWORD):WINBOOL; external 'kernel32' name 'Beep'; +{$ifdef Unknown_functions} +{ WARNING: functions not found !!} +procedure OpenSound; external External_library name 'OpenSound'; +procedure CloseSound; external External_library name 'CloseSound'; +procedure StartSound; external External_library name 'StartSound'; +procedure StopSound; external External_library name 'StopSound'; +function WaitSoundState(nState:DWORD):DWORD; external External_library name 'WaitSoundState'; +function SyncAllVoices:DWORD; external External_library name 'SyncAllVoices'; +function CountVoiceNotes(nVoice:DWORD):DWORD; external External_library name 'CountVoiceNotes'; +function GetThresholdEvent:LPDWORD; external External_library name 'GetThresholdEvent'; +function GetThresholdStatus:DWORD; external External_library name 'GetThresholdStatus'; +function SetSoundNoise(nSource:DWORD; nDuration:DWORD):DWORD; external External_library name 'SetSoundNoise'; +function SetVoiceAccent(nVoice:DWORD; nTempo:DWORD; nVolume:DWORD; nMode:DWORD; nPitch:DWORD):DWORD; external External_library name 'SetVoiceAccent'; +function SetVoiceEnvelope(nVoice:DWORD; nShape:DWORD; nRepeat:DWORD):DWORD; external External_library name 'SetVoiceEnvelope'; +function SetVoiceNote(nVoice:DWORD; nValue:DWORD; nLength:DWORD; nCdots:DWORD):DWORD; external External_library name 'SetVoiceNote'; +function SetVoiceQueueSize(nVoice:DWORD; nBytes:DWORD):DWORD; external External_library name 'SetVoiceQueueSize'; +function SetVoiceSound(nVoice:DWORD; Frequency:DWORD; nDuration:DWORD):DWORD; external External_library name 'SetVoiceSound'; +function SetVoiceThreshold(nVoice:DWORD; nNotes:DWORD):DWORD; external External_library name 'SetVoiceThreshold'; +{$endif Unknown_functions} +function MulDiv(nNumber:longint; nNumerator:longint; nDenominator:longint):longint; external 'kernel32' name 'MulDiv'; +procedure GetSystemTime(lpSystemTime:LPSYSTEMTIME); external 'kernel32' name 'GetSystemTime'; +procedure GetSystemTimeAsFileTime(lpSystemTimeAsFileTime:LPFILETIME); external 'kernel32' name 'GetSystemTimeAsFileTime'; +function SetSystemTime(lpSystemTime:LPSYSTEMTIME):WINBOOL; external 'kernel32' name 'SetSystemTime'; +procedure GetLocalTime(lpSystemTime:LPSYSTEMTIME); external 'kernel32' name 'GetLocalTime'; +function SetLocalTime(lpSystemTime:LPSYSTEMTIME):WINBOOL; external 'kernel32' name 'SetLocalTime'; +procedure GetSystemInfo(lpSystemInfo:LPSYSTEM_INFO); external 'kernel32' name 'GetSystemInfo'; +function SystemTimeToTzSpecificLocalTime(lpTimeZoneInformation:LPTIME_ZONE_INFORMATION; lpUniversalTime:LPSYSTEMTIME; lpLocalTime:LPSYSTEMTIME):WINBOOL; external 'kernel32' name 'SystemTimeToTzSpecificLocalTime'; +function GetTimeZoneInformation(lpTimeZoneInformation:LPTIME_ZONE_INFORMATION):DWORD; external 'kernel32' name 'GetTimeZoneInformation'; +function SetTimeZoneInformation(lpTimeZoneInformation:LPTIME_ZONE_INFORMATION):WINBOOL; external 'kernel32' name 'SetTimeZoneInformation'; +function SystemTimeToFileTime(lpSystemTime:LPSYSTEMTIME; lpFileTime:LPFILETIME):WINBOOL; external 'kernel32' name 'SystemTimeToFileTime'; +function FileTimeToLocalFileTime(lpFileTime:LPFILETIME; lpLocalFileTime:LPFILETIME):WINBOOL; external 'kernel32' name 'FileTimeToLocalFileTime'; +function LocalFileTimeToFileTime(lpLocalFileTime:LPFILETIME; lpFileTime:LPFILETIME):WINBOOL; external 'kernel32' name 'LocalFileTimeToFileTime'; +function FileTimeToSystemTime(lpFileTime:LPFILETIME; lpSystemTime:LPSYSTEMTIME):WINBOOL; external 'kernel32' name 'FileTimeToSystemTime'; +function CompareFileTime(lpFileTime1:LPFILETIME; lpFileTime2:LPFILETIME):LONG; external 'kernel32' name 'CompareFileTime'; +function FileTimeToDosDateTime(lpFileTime:LPFILETIME; lpFatDate:LPWORD; lpFatTime:LPWORD):WINBOOL; external 'kernel32' name 'FileTimeToDosDateTime'; +function DosDateTimeToFileTime(wFatDate:WORD; wFatTime:WORD; lpFileTime:LPFILETIME):WINBOOL; external 'kernel32' name 'DosDateTimeToFileTime'; +function GetTickCount:DWORD; external 'kernel32' name 'GetTickCount'; +function SetSystemTimeAdjustment(dwTimeAdjustment:DWORD; bTimeAdjustmentDisabled:WINBOOL):WINBOOL; external 'kernel32' name 'SetSystemTimeAdjustment'; +function GetSystemTimeAdjustment(lpTimeAdjustment:PDWORD; lpTimeIncrement:PDWORD; lpTimeAdjustmentDisabled:PWINBOOL):WINBOOL; external 'kernel32' name 'GetSystemTimeAdjustment'; +function CreatePipe(hReadPipe:PHANDLE; hWritePipe:PHANDLE; lpPipeAttributes:LPSECURITY_ATTRIBUTES; nSize:DWORD):WINBOOL; external 'kernel32' name 'CreatePipe'; +function ConnectNamedPipe(hNamedPipe:HANDLE; lpOverlapped:LPOVERLAPPED):WINBOOL; external 'kernel32' name 'ConnectNamedPipe'; +function DisconnectNamedPipe(hNamedPipe:HANDLE):WINBOOL; external 'kernel32' name 'DisconnectNamedPipe'; +function SetNamedPipeHandleState(hNamedPipe:HANDLE; lpMode:LPDWORD; lpMaxCollectionCount:LPDWORD; lpCollectDataTimeout:LPDWORD):WINBOOL; external 'kernel32' name 'SetNamedPipeHandleState'; +function GetNamedPipeInfo(hNamedPipe:HANDLE; lpFlags:LPDWORD; lpOutBufferSize:LPDWORD; lpInBufferSize:LPDWORD; lpMaxInstances:LPDWORD):WINBOOL; external 'kernel32' name 'GetNamedPipeInfo'; +function PeekNamedPipe(hNamedPipe:HANDLE; lpBuffer:LPVOID; nBufferSize:DWORD; lpBytesRead:LPDWORD; lpTotalBytesAvail:LPDWORD;lpBytesLeftThisMessage:LPDWORD):WINBOOL; external 'kernel32' name 'PeekNamedPipe'; +function TransactNamedPipe(hNamedPipe:HANDLE; lpInBuffer:LPVOID; nInBufferSize:DWORD; lpOutBuffer:LPVOID; nOutBufferSize:DWORD;lpBytesRead:LPDWORD; lpOverlapped:LPOVERLAPPED):WINBOOL; external 'kernel32' name 'TransactNamedPipe'; +function GetMailslotInfo(hMailslot:HANDLE; lpMaxMessageSize:LPDWORD; lpNextSize:LPDWORD; lpMessageCount:LPDWORD; lpReadTimeout:LPDWORD):WINBOOL; external 'kernel32' name 'GetMailslotInfo'; +function SetMailslotInfo(hMailslot:HANDLE; lReadTimeout:DWORD):WINBOOL; external 'kernel32' name 'SetMailslotInfo'; +function MapViewOfFile(hFileMappingObject:HANDLE; dwDesiredAccess:DWORD; dwFileOffsetHigh:DWORD; dwFileOffsetLow:DWORD; dwNumberOfBytesToMap:DWORD):LPVOID; external 'kernel32' name 'MapViewOfFile'; +function FlushViewOfFile(lpBaseAddress:LPCVOID; dwNumberOfBytesToFlush:DWORD):WINBOOL; external 'kernel32' name 'FlushViewOfFile'; +function UnmapViewOfFile(lpBaseAddress:LPVOID):WINBOOL; external 'kernel32' name 'UnmapViewOfFile'; +function OpenFile(lpFileName:LPCSTR; lpReOpenBuff:LPOFSTRUCT; uStyle:UINT):HFILE; external 'kernel32' name 'OpenFile'; +function _lopen(lpPathName:LPCSTR; iReadWrite:longint):HFILE; external 'kernel32' name '_lopen'; +function _lcreat(lpPathName:LPCSTR; iAttribute:longint):HFILE; external 'kernel32' name '_lcreat'; +function _lread(hFile:HFILE; lpBuffer:LPVOID; uBytes:UINT):UINT; external 'kernel32' name '_lread'; +function _lwrite(hFile:HFILE; lpBuffer:LPCSTR; uBytes:UINT):UINT; external 'kernel32' name '_lwrite'; +function _hread(hFile:HFILE; lpBuffer:LPVOID; lBytes:longint):longint; external 'kernel32' name '_hread'; +function _hwrite(hFile:HFILE; lpBuffer:LPCSTR; lBytes:longint):longint; external 'kernel32' name '_hwrite'; +function _lclose(hFile:HFILE):HFILE; external 'kernel32' name '_lclose'; +function _llseek(hFile:HFILE; lOffset:LONG; iOrigin:longint):LONG; external 'kernel32' name '_llseek'; +function IsTextUnicode(lpBuffer:LPVOID; cb:longint; lpi:LPINT):WINBOOL; external 'advapi32' name 'IsTextUnicode'; +function TlsAlloc:DWORD; external 'kernel32' name 'TlsAlloc'; +function TlsGetValue(dwTlsIndex:DWORD):LPVOID; external 'kernel32' name 'TlsGetValue'; +function TlsSetValue(dwTlsIndex:DWORD; lpTlsValue:LPVOID):WINBOOL; external 'kernel32' name 'TlsSetValue'; +function TlsFree(dwTlsIndex:DWORD):WINBOOL; external 'kernel32' name 'TlsFree'; +function SleepEx(dwMilliseconds:DWORD; bAlertable:WINBOOL):DWORD; external 'kernel32' name 'SleepEx'; +function WaitForSingleObjectEx(hHandle:HANDLE; dwMilliseconds:DWORD; bAlertable:WINBOOL):DWORD; external 'kernel32' name 'WaitForSingleObjectEx'; +function WaitForMultipleObjectsEx(nCount:DWORD; lpHandles:LPHANDLE; bWaitAll:WINBOOL; dwMilliseconds:DWORD; bAlertable:WINBOOL):DWORD; external 'kernel32' name 'WaitForMultipleObjectsEx'; +function ReadFileEx(hFile:HANDLE; lpBuffer:LPVOID; nNumberOfBytesToRead:DWORD; lpOverlapped:LPOVERLAPPED; lpCompletionRoutine:LPOVERLAPPED_COMPLETION_ROUTINE):WINBOOL; external 'kernel32' name 'ReadFileEx'; +function WriteFileEx(hFile:HANDLE; lpBuffer:LPCVOID; nNumberOfBytesToWrite:DWORD; lpOverlapped:LPOVERLAPPED; lpCompletionRoutine:LPOVERLAPPED_COMPLETION_ROUTINE):WINBOOL; external 'kernel32' name 'WriteFileEx'; +function BackupRead(hFile:HANDLE; lpBuffer:LPBYTE; nNumberOfBytesToRead:DWORD; lpNumberOfBytesRead:LPDWORD; bAbort:WINBOOL;bProcessSecurity:WINBOOL; var lpContext:LPVOID):WINBOOL; external 'kernel32' name 'BackupRead'; +function BackupSeek(hFile:HANDLE; dwLowBytesToSeek:DWORD; dwHighBytesToSeek:DWORD; lpdwLowByteSeeked:LPDWORD; lpdwHighByteSeeked:LPDWORD;var lpContext:LPVOID):WINBOOL; external 'kernel32' name 'BackupSeek'; +function BackupWrite(hFile:HANDLE; lpBuffer:LPBYTE; nNumberOfBytesToWrite:DWORD; lpNumberOfBytesWritten:LPDWORD; bAbort:WINBOOL;bProcessSecurity:WINBOOL; var lpContext:LPVOID):WINBOOL; external 'kernel32' name 'BackupWrite'; +function SetProcessShutdownParameters(dwLevel:DWORD; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'SetProcessShutdownParameters'; +function GetProcessShutdownParameters(lpdwLevel:LPDWORD; lpdwFlags:LPDWORD):WINBOOL; external 'kernel32' name 'GetProcessShutdownParameters'; +procedure SetFileApisToOEM; external 'kernel32' name 'SetFileApisToOEM'; +procedure SetFileApisToANSI; external 'kernel32' name 'SetFileApisToANSI'; +function AreFileApisANSI:WINBOOL; external 'kernel32' name 'AreFileApisANSI'; +function CloseEventLog(hEventLog:HANDLE):WINBOOL; external 'advapi32' name 'CloseEventLog'; +function DeregisterEventSource(hEventLog:HANDLE):WINBOOL; external 'advapi32' name 'DeregisterEventSource'; +function NotifyChangeEventLog(hEventLog:HANDLE; hEvent:HANDLE):WINBOOL; external 'advapi32' name 'NotifyChangeEventLog'; +function GetNumberOfEventLogRecords(hEventLog:HANDLE; NumberOfRecords:PDWORD):WINBOOL; external 'advapi32' name 'GetNumberOfEventLogRecords'; +function GetOldestEventLogRecord(hEventLog:HANDLE; OldestRecord:PDWORD):WINBOOL; external 'advapi32' name 'GetOldestEventLogRecord'; +function DuplicateToken(ExistingTokenHandle:HANDLE; ImpersonationLevel:SECURITY_IMPERSONATION_LEVEL; DuplicateTokenHandle:PHANDLE):WINBOOL; external 'advapi32' name 'DuplicateToken'; +function GetKernelObjectSecurity(Handle:HANDLE; RequestedInformation:SECURITY_INFORMATION; pSecurityDescriptor:PSECURITY_DESCRIPTOR; nLength:DWORD; lpnLengthNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'GetKernelObjectSecurity'; +function ImpersonateNamedPipeClient(hNamedPipe:HANDLE):WINBOOL; external 'advapi32' name 'ImpersonateNamedPipeClient'; +function ImpersonateLoggedOnUser(hToken:HANDLE):WINBOOL; external 'advapi32' name 'ImpersonateLoggedOnUser'; +function ImpersonateSelf(ImpersonationLevel:SECURITY_IMPERSONATION_LEVEL):WINBOOL; external 'advapi32' name 'ImpersonateSelf'; +function RevertToSelf:WINBOOL; external 'advapi32' name 'RevertToSelf'; +function SetThreadToken(Thread:PHANDLE; Token:HANDLE):WINBOOL; external 'advapi32' name 'SetThreadToken'; +{ function AccessCheck(pSecurityDescriptor:PSECURITY_DESCRIPTOR; ClientToken:HANDLE; DesiredAccess:DWORD; GenericMapping:PGENERIC_MAPPING; PrivilegeSet:PPRIVILEGE_SET;PrivilegeSetLength:LPDWORD; + GrantedAccess:LPDWORD; AccessStatus:LPBOOL):WINBOOL; external 'advapi32' name 'AccessCheck'; +} +function OpenProcessToken(ProcessHandle:HANDLE; DesiredAccess:DWORD; TokenHandle:PHANDLE):WINBOOL; external 'advapi32' name 'OpenProcessToken'; +function OpenThreadToken(ThreadHandle:HANDLE; DesiredAccess:DWORD; OpenAsSelf:WINBOOL; TokenHandle:PHANDLE):WINBOOL; external 'advapi32' name 'OpenThreadToken'; +function GetTokenInformation(TokenHandle:HANDLE; TokenInformationClass:TOKEN_INFORMATION_CLASS; TokenInformation:LPVOID; TokenInformationLength:DWORD; ReturnLength:PDWORD):WINBOOL; external 'advapi32' name 'GetTokenInformation'; +function SetTokenInformation(TokenHandle:HANDLE; TokenInformationClass:TOKEN_INFORMATION_CLASS; TokenInformation:LPVOID; TokenInformationLength:DWORD):WINBOOL; external 'advapi32' name 'SetTokenInformation'; +function AdjustTokenPrivileges(TokenHandle:HANDLE; DisableAllPrivileges:WINBOOL; NewState:PTOKEN_PRIVILEGES; BufferLength:DWORD; PreviousState:PTOKEN_PRIVILEGES;ReturnLength:PDWORD):WINBOOL; external 'advapi32' name 'AdjustTokenPrivileges'; +function AdjustTokenGroups(TokenHandle:HANDLE; ResetToDefault:WINBOOL; NewState:PTOKEN_GROUPS; BufferLength:DWORD; PreviousState:PTOKEN_GROUPS;ReturnLength:PDWORD):WINBOOL; external 'advapi32' name 'AdjustTokenGroups'; +function PrivilegeCheck(ClientToken:HANDLE; RequiredPrivileges:PPRIVILEGE_SET; pfResult:LPBOOL):WINBOOL; external 'advapi32' name 'PrivilegeCheck'; +function IsValidSid(pSid:PSID):WINBOOL; external 'advapi32' name 'IsValidSid'; +function EqualSid(pSid1:PSID; pSid2:PSID):WINBOOL; external 'advapi32' name 'EqualSid'; +function EqualPrefixSid(pSid1:PSID; pSid2:PSID):WINBOOL; external 'advapi32' name 'EqualPrefixSid'; +function GetSidLengthRequired(nSubAuthorityCount:UCHAR):DWORD; external 'advapi32' name 'GetSidLengthRequired'; +function AllocateAndInitializeSid(pIdentifierAuthority:PSID_IDENTIFIER_AUTHORITY; nSubAuthorityCount:BYTE; nSubAuthority0:DWORD; nSubAuthority1:DWORD; nSubAuthority2:DWORD;nSubAuthority3:DWORD; nSubAuthority4:DWORD; + nSubAuthority5:DWORD; nSubAuthority6:DWORD; nSubAuthority7:DWORD;var pSid:PSID):WINBOOL; external 'advapi32' name 'AllocateAndInitializeSid'; +function FreeSid(pSid:PSID):PVOID; external 'advapi32' name 'FreeSid'; +function InitializeSid(Sid:PSID; pIdentifierAuthority:PSID_IDENTIFIER_AUTHORITY; nSubAuthorityCount:BYTE):WINBOOL; external 'advapi32' name 'InitializeSid'; +function GetSidIdentifierAuthority(pSid:PSID):PSID_IDENTIFIER_AUTHORITY; external 'advapi32' name 'GetSidIdentifierAuthority'; +function GetSidSubAuthority(pSid:PSID; nSubAuthority:DWORD):PDWORD; external 'advapi32' name 'GetSidSubAuthority'; +function GetSidSubAuthorityCount(pSid:PSID):PUCHAR; external 'advapi32' name 'GetSidSubAuthorityCount'; +function GetLengthSid(pSid:PSID):DWORD; external 'advapi32' name 'GetLengthSid'; +function CopySid(nDestinationSidLength:DWORD; pDestinationSid:PSID; pSourceSid:PSID):WINBOOL; external 'advapi32' name 'CopySid'; +function AreAllAccessesGranted(GrantedAccess:DWORD; DesiredAccess:DWORD):WINBOOL; external 'advapi32' name 'AreAllAccessesGranted'; +function AreAnyAccessesGranted(GrantedAccess:DWORD; DesiredAccess:DWORD):WINBOOL; external 'advapi32' name 'AreAnyAccessesGranted'; +procedure MapGenericMask(AccessMask:PDWORD; GenericMapping:PGENERIC_MAPPING); external 'advapi32' name 'MapGenericMask'; +function IsValidAcl(pAcl:PACL):WINBOOL; external 'advapi32' name 'IsValidAcl'; +function InitializeAcl(pAcl:PACL; nAclLength:DWORD; dwAclRevision:DWORD):WINBOOL; external 'advapi32' name 'InitializeAcl'; +function GetAclInformation(pAcl:PACL; pAclInformation:LPVOID; nAclInformationLength:DWORD; dwAclInformationClass:ACL_INFORMATION_CLASS):WINBOOL; external 'advapi32' name 'GetAclInformation'; +function SetAclInformation(pAcl:PACL; pAclInformation:LPVOID; nAclInformationLength:DWORD; dwAclInformationClass:ACL_INFORMATION_CLASS):WINBOOL; external 'advapi32' name 'SetAclInformation'; +function AddAce(pAcl:PACL; dwAceRevision:DWORD; dwStartingAceIndex:DWORD; pAceList:LPVOID; nAceListLength:DWORD):WINBOOL; external 'advapi32' name 'AddAce'; +function DeleteAce(pAcl:PACL; dwAceIndex:DWORD):WINBOOL; external 'advapi32' name 'DeleteAce'; +function GetAce(pAcl:PACL; dwAceIndex:DWORD; var pAce:LPVOID):WINBOOL; external 'advapi32' name 'GetAce'; +function AddAccessAllowedAce(pAcl:PACL; dwAceRevision:DWORD; AccessMask:DWORD; pSid:PSID):WINBOOL; external 'advapi32' name 'AddAccessAllowedAce'; +function AddAccessDeniedAce(pAcl:PACL; dwAceRevision:DWORD; AccessMask:DWORD; pSid:PSID):WINBOOL; external 'advapi32' name 'AddAccessDeniedAce'; +function AddAuditAccessAce(pAcl:PACL; dwAceRevision:DWORD; dwAccessMask:DWORD; pSid:PSID; bAuditSuccess:WINBOOL;bAuditFailure:WINBOOL):WINBOOL; external 'advapi32' name 'AddAuditAccessAce'; +function FindFirstFreeAce(pAcl:PACL; var pAce:LPVOID):WINBOOL; external 'advapi32' name 'FindFirstFreeAce'; +function InitializeSecurityDescriptor(pSecurityDescriptor:PSECURITY_DESCRIPTOR; dwRevision:DWORD):WINBOOL; external 'advapi32' name 'InitializeSecurityDescriptor'; +function IsValidSecurityDescriptor(pSecurityDescriptor:PSECURITY_DESCRIPTOR):WINBOOL; external 'advapi32' name 'IsValidSecurityDescriptor'; +function GetSecurityDescriptorLength(pSecurityDescriptor:PSECURITY_DESCRIPTOR):DWORD; external 'advapi32' name 'GetSecurityDescriptorLength'; +function GetSecurityDescriptorControl(pSecurityDescriptor:PSECURITY_DESCRIPTOR; pControl:PSECURITY_DESCRIPTOR_CONTROL; lpdwRevision:LPDWORD):WINBOOL; external 'advapi32' name 'GetSecurityDescriptorControl'; +function SetSecurityDescriptorDacl(pSecurityDescriptor:PSECURITY_DESCRIPTOR; bDaclPresent:WINBOOL; pDacl:PACL; bDaclDefaulted:WINBOOL):WINBOOL; external 'advapi32' name 'SetSecurityDescriptorDacl'; +function GetSecurityDescriptorDacl(pSecurityDescriptor:PSECURITY_DESCRIPTOR; lpbDaclPresent:LPBOOL; var pDacl:PACL; lpbDaclDefaulted:LPBOOL):WINBOOL; external 'advapi32' name 'GetSecurityDescriptorDacl'; +function SetSecurityDescriptorSacl(pSecurityDescriptor:PSECURITY_DESCRIPTOR; bSaclPresent:WINBOOL; pSacl:PACL; bSaclDefaulted:WINBOOL):WINBOOL; external 'advapi32' name 'SetSecurityDescriptorSacl'; +function GetSecurityDescriptorSacl(pSecurityDescriptor:PSECURITY_DESCRIPTOR; lpbSaclPresent:LPBOOL; var pSacl:PACL; lpbSaclDefaulted:LPBOOL):WINBOOL; external 'advapi32' name 'GetSecurityDescriptorSacl'; +function SetSecurityDescriptorOwner(pSecurityDescriptor:PSECURITY_DESCRIPTOR; pOwner:PSID; bOwnerDefaulted:WINBOOL):WINBOOL; external 'advapi32' name 'SetSecurityDescriptorOwner'; +function GetSecurityDescriptorOwner(pSecurityDescriptor:PSECURITY_DESCRIPTOR; var pOwner:PSID; lpbOwnerDefaulted:LPBOOL):WINBOOL; external 'advapi32' name 'GetSecurityDescriptorOwner'; +function SetSecurityDescriptorGroup(pSecurityDescriptor:PSECURITY_DESCRIPTOR; pGroup:PSID; bGroupDefaulted:WINBOOL):WINBOOL; external 'advapi32' name 'SetSecurityDescriptorGroup'; +function GetSecurityDescriptorGroup(pSecurityDescriptor:PSECURITY_DESCRIPTOR; var pGroup:PSID; lpbGroupDefaulted:LPBOOL):WINBOOL; external 'advapi32' name 'GetSecurityDescriptorGroup'; +function CreatePrivateObjectSecurity(ParentDescriptor:PSECURITY_DESCRIPTOR; CreatorDescriptor:PSECURITY_DESCRIPTOR; var NewDescriptor:PSECURITY_DESCRIPTOR; + IsDirectoryObject:WINBOOL; Token:HANDLE;GenericMapping:PGENERIC_MAPPING):WINBOOL; external 'advapi32' name 'CreatePrivateObjectSecurity'; +function SetPrivateObjectSecurity(SecurityInformation:SECURITY_INFORMATION; ModificationDescriptor:PSECURITY_DESCRIPTOR; var ObjectsSecurityDescriptor:PSECURITY_DESCRIPTOR; GenericMapping:PGENERIC_MAPPING; Token:HANDLE):WINBOOL; + external 'advapi32' name 'SetPrivateObjectSecurity'; +function GetPrivateObjectSecurity(ObjectDescriptor:PSECURITY_DESCRIPTOR; SecurityInformation:SECURITY_INFORMATION; ResultantDescriptor:PSECURITY_DESCRIPTOR; + DescriptorLength:DWORD; ReturnLength:PDWORD):WINBOOL;external 'advapi32' name 'GetPrivateObjectSecurity'; +function DestroyPrivateObjectSecurity(ObjectDescriptor:PSECURITY_DESCRIPTOR):WINBOOL; external 'advapi32' name 'DestroyPrivateObjectSecurity'; +function MakeSelfRelativeSD(pAbsoluteSecurityDescriptor:PSECURITY_DESCRIPTOR; pSelfRelativeSecurityDescriptor:PSECURITY_DESCRIPTOR; lpdwBufferLength:LPDWORD):WINBOOL; external 'advapi32' name 'MakeSelfRelativeSD'; +function MakeAbsoluteSD(pSelfRelativeSecurityDescriptor:PSECURITY_DESCRIPTOR; pAbsoluteSecurityDescriptor:PSECURITY_DESCRIPTOR; lpdwAbsoluteSecurityDescriptorSize:LPDWORD; pDacl:PACL; lpdwDaclSize:LPDWORD;pSacl:PACL; + lpdwSaclSize:LPDWORD; pOwner:PSID; lpdwOwnerSize:LPDWORD; pPrimaryGroup:PSID;lpdwPrimaryGroupSize:LPDWORD):WINBOOL; external 'advapi32' name 'MakeAbsoluteSD'; +function SetKernelObjectSecurity(Handle:HANDLE; SecurityInformation:SECURITY_INFORMATION; SecurityDescriptor:PSECURITY_DESCRIPTOR):WINBOOL; external 'advapi32' name 'SetKernelObjectSecurity'; +function FindNextChangeNotification(hChangeHandle:HANDLE):WINBOOL; external 'kernel32' name 'FindNextChangeNotification'; +function FindCloseChangeNotification(hChangeHandle:HANDLE):WINBOOL; external 'kernel32' name 'FindCloseChangeNotification'; +function VirtualLock(lpAddress:LPVOID; dwSize:DWORD):WINBOOL; external 'kernel32' name 'VirtualLock'; +function VirtualUnlock(lpAddress:LPVOID; dwSize:DWORD):WINBOOL; external 'kernel32' name 'VirtualUnlock'; +function MapViewOfFileEx(hFileMappingObject:HANDLE; dwDesiredAccess:DWORD; dwFileOffsetHigh:DWORD; dwFileOffsetLow:DWORD; dwNumberOfBytesToMap:DWORD;lpBaseAddress:LPVOID):LPVOID; external 'kernel32' name 'MapViewOfFileEx'; +function SetPriorityClass(hProcess:HANDLE; dwPriorityClass:DWORD):WINBOOL; external 'kernel32' name 'SetPriorityClass'; +function GetPriorityClass(hProcess:HANDLE):DWORD; external 'kernel32' name 'GetPriorityClass'; +function IsBadReadPtr(lp:pointer; ucb:UINT):WINBOOL; external 'kernel32' name 'IsBadReadPtr'; +function IsBadWritePtr(lp:LPVOID; ucb:UINT):WINBOOL; external 'kernel32' name 'IsBadWritePtr'; +function IsBadHugeReadPtr(lp:pointer; ucb:UINT):WINBOOL; external 'kernel32' name 'IsBadHugeReadPtr'; +function IsBadHugeWritePtr(lp:LPVOID; ucb:UINT):WINBOOL; external 'kernel32' name 'IsBadHugeWritePtr'; +function IsBadCodePtr(lpfn:FARPROC):WINBOOL; external 'kernel32' name 'IsBadCodePtr'; +function AllocateLocallyUniqueId(Luid:PLUID):WINBOOL; external 'advapi32' name 'AllocateLocallyUniqueId'; +function QueryPerformanceCounter(lpPerformanceCount:PLARGE_INTEGER):WINBOOL; external 'kernel32' name 'QueryPerformanceCounter'; +function QueryPerformanceFrequency(lpFrequency:PLARGE_INTEGER):WINBOOL; external 'kernel32' name 'QueryPerformanceFrequency'; +procedure MoveMemory(Destination:PVOID; Source:pointer; Length:DWORD); +procedure CopyMemory(Destination:PVOID; Source:pointer; Length:DWORD); +procedure FillMemory(Destination:PVOID; Length:DWORD; Fill:BYTE); +procedure ZeroMemory(Destination:PVOID; Length:DWORD); +{$ifdef WIN95} +function ActivateKeyboardLayout(hkl:HKL; Flags:UINT):HKL; external 'user32' name 'ActivateKeyboardLayout'; +{$else} +function ActivateKeyboardLayout(hkl:HKL; Flags:UINT):WINBOOL; external 'user32' name 'ActivateKeyboardLayout'; +{$endif} +function UnloadKeyboardLayout(hkl:HKL):WINBOOL; external 'user32' name 'UnloadKeyboardLayout'; +function GetKeyboardLayoutList(nBuff:longint; var lpList:HKL):longint; external 'user32' name 'GetKeyboardLayoutList'; +function GetKeyboardLayout(dwLayout:DWORD):HKL; external 'user32' name 'GetKeyboardLayout'; +function OpenInputDesktop(dwFlags:DWORD; fInherit:WINBOOL; dwDesiredAccess:DWORD):HDESK; external 'user32' name 'OpenInputDesktop'; +function EnumDesktopWindows(hDesktop:HDESK; lpfn:ENUMWINDOWSPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumDesktopWindows'; +function SwitchDesktop(hDesktop:HDESK):WINBOOL; external 'user32' name 'SwitchDesktop'; +function SetThreadDesktop(hDesktop:HDESK):WINBOOL; external 'user32' name 'SetThreadDesktop'; +function CloseDesktop(hDesktop:HDESK):WINBOOL; external 'user32' name 'CloseDesktop'; +function GetThreadDesktop(dwThreadId:DWORD):HDESK; external 'user32' name 'GetThreadDesktop'; +function CloseWindowStation(hWinSta:HWINSTA):WINBOOL; external 'user32' name 'CloseWindowStation'; +function SetProcessWindowStation(hWinSta:HWINSTA):WINBOOL; external 'user32' name 'SetProcessWindowStation'; +function GetProcessWindowStation:HWINSTA; external 'user32' name 'GetProcessWindowStation'; +function SetUserObjectSecurity(hObj:HANDLE; pSIRequested:PSECURITY_INFORMATION; pSID:PSECURITY_DESCRIPTOR):WINBOOL; external 'user32' name 'SetUserObjectSecurity'; + +function GetUserObjectSecurity(hObj:HANDLE; pSIRequested:PSECURITY_INFORMATION; pSID:PSECURITY_DESCRIPTOR; nLength:DWORD; lpnLengthNeeded:LPDWORD):WINBOOL; external 'user32' name 'GetUserObjectSecurity'; +function TranslateMessage(lpMsg:LPMSG):WINBOOL; external 'user32' name 'TranslateMessage'; +function SetMessageQueue(cMessagesMax:longint):WINBOOL; external 'user32' name 'SetMessageQueue'; +function RegisterHotKey(hWnd:HWND; anID:longint; fsModifiers:UINT; vk:UINT):WINBOOL; external 'user32' name 'RegisterHotKey'; +function UnregisterHotKey(hWnd:HWND; anID:longint):WINBOOL; external 'user32' name 'UnregisterHotKey'; +function ExitWindowsEx(uFlags:UINT; dwReserved:DWORD):WINBOOL; external 'user32' name 'ExitWindowsEx'; +function SwapMouseButton(fSwap:WINBOOL):WINBOOL; external 'user32' name 'SwapMouseButton'; +function GetMessagePos:DWORD; external 'user32' name 'GetMessagePos'; +function GetMessageTime:LONG; external 'user32' name 'GetMessageTime'; +function GetMessageExtraInfo:LONG; external 'user32' name 'GetMessageExtraInfo'; +function SetMessageExtraInfo(lParam:LPARAM):LPARAM; external 'user32' name 'SetMessageExtraInfo'; +function BroadcastSystemMessage(_para1:DWORD; _para2:LPDWORD; _para3:UINT; _para4:WPARAM; _para5:LPARAM):longint; external 'user32' name 'BroadcastSystemMessage'; +function AttachThreadInput(idAttach:DWORD; idAttachTo:DWORD; fAttach:WINBOOL):WINBOOL; external 'user32' name 'AttachThreadInput'; +function ReplyMessage(lResult:LRESULT):WINBOOL; external 'user32' name 'ReplyMessage'; +function WaitMessage:WINBOOL; external 'user32' name 'WaitMessage'; +function WaitForInputIdle(hProcess:HANDLE; dwMilliseconds:DWORD):DWORD; external 'user32' name 'WaitForInputIdle'; +procedure PostQuitMessage(nExitCode:longint); external 'user32' name 'PostQuitMessage'; +function InSendMessage:WINBOOL; external 'user32' name 'InSendMessage'; +function GetDoubleClickTime:UINT; external 'user32' name 'GetDoubleClickTime'; +function SetDoubleClickTime(_para1:UINT):WINBOOL; external 'user32' name 'SetDoubleClickTime'; +function IsWindow(hWnd:HWND):WINBOOL; external 'user32' name 'IsWindow'; +function IsMenu(hMenu:HMENU):WINBOOL; external 'user32' name 'IsMenu'; +function IsChild(hWndParent:HWND; hWnd:HWND):WINBOOL; external 'user32' name 'IsChild'; +function DestroyWindow(hWnd:HWND):WINBOOL; external 'user32' name 'DestroyWindow'; +function ShowWindow(hWnd:HWND; nCmdShow:longint):WINBOOL; external 'user32' name 'ShowWindow'; +function ShowWindowAsync(hWnd:HWND; nCmdShow:longint):WINBOOL; external 'user32' name 'ShowWindowAsync'; +function FlashWindow(hWnd:HWND; bInvert:WINBOOL):WINBOOL; external 'user32' name 'FlashWindow'; +function ShowOwnedPopups(hWnd:HWND; fShow:WINBOOL):WINBOOL; external 'user32' name 'ShowOwnedPopups'; +function OpenIcon(hWnd:HWND):WINBOOL; external 'user32' name 'OpenIcon'; +function CloseWindow(hWnd:HWND):WINBOOL; external 'user32' name 'CloseWindow'; +function MoveWindow(hWnd:HWND; X:longint; Y:longint; nWidth:longint; nHeight:longint;bRepaint:WINBOOL):WINBOOL; external 'user32' name 'MoveWindow'; +function SetWindowPos(hWnd:HWND; hWndInsertAfter:HWND; X:longint; Y:longint; cx:longint;cy:longint; uFlags:UINT):WINBOOL; external 'user32' name 'SetWindowPos'; +function GetWindowPlacement(hWnd:HWND; var lpwndpl:WINDOWPLACEMENT):WINBOOL; external 'user32' name 'GetWindowPlacement'; +function SetWindowPlacement(hWnd:HWND; var lpwndpl:WINDOWPLACEMENT):WINBOOL; external 'user32' name 'SetWindowPlacement'; +function GetWindowPlacement(hWnd:HWND; lpwndpl:PWINDOWPLACEMENT):WINBOOL; external 'user32' name 'GetWindowPlacement'; +function SetWindowPlacement(hWnd:HWND; lpwndpl:PWINDOWPLACEMENT):WINBOOL; external 'user32' name 'SetWindowPlacement'; +function BeginDeferWindowPos(nNumWindows:longint):HDWP; external 'user32' name 'BeginDeferWindowPos'; +function DeferWindowPos(hWinPosInfo:HDWP; hWnd:HWND; hWndInsertAfter:HWND; x:longint; y:longint;cx:longint; cy:longint; uFlags:UINT):HDWP; external 'user32' name 'DeferWindowPos'; +function EndDeferWindowPos(hWinPosInfo:HDWP):WINBOOL; external 'user32' name 'EndDeferWindowPos'; +function IsWindowVisible(hWnd:HWND):WINBOOL; external 'user32' name 'IsWindowVisible'; +function IsIconic(hWnd:HWND):WINBOOL; external 'user32' name 'IsIconic'; +function AnyPopup:WINBOOL; external 'user32' name 'AnyPopup'; +function BringWindowToTop(hWnd:HWND):WINBOOL; external 'user32' name 'BringWindowToTop'; +function IsZoomed(hWnd:HWND):WINBOOL; external 'user32' name 'IsZoomed'; +function EndDialog(hDlg:HWND; nResult:longint):WINBOOL; external 'user32' name 'EndDialog'; +function GetDlgItem(hDlg:HWND; nIDDlgItem:longint):HWND; external 'user32' name 'GetDlgItem'; +function SetDlgItemInt(hDlg:HWND; nIDDlgItem:longint; uValue:UINT; bSigned:WINBOOL):WINBOOL; external 'user32' name 'SetDlgItemInt'; +function GetDlgItemInt(hDlg:HWND; nIDDlgItem:longint; var lpTranslated:WINBOOL; bSigned:WINBOOL):UINT; external 'user32' name 'GetDlgItemInt'; +function CheckDlgButton(hDlg:HWND; nIDButton:longint; uCheck:UINT):WINBOOL; external 'user32' name 'CheckDlgButton'; +function CheckRadioButton(hDlg:HWND; nIDFirstButton:longint; nIDLastButton:longint; nIDCheckButton:longint):WINBOOL; external 'user32' name 'CheckRadioButton'; +function IsDlgButtonChecked(hDlg:HWND; nIDButton:longint):UINT; external 'user32' name 'IsDlgButtonChecked'; +function GetNextDlgGroupItem(hDlg:HWND; hCtl:HWND; bPrevious:WINBOOL):HWND; external 'user32' name 'GetNextDlgGroupItem'; +function GetNextDlgTabItem(hDlg:HWND; hCtl:HWND; bPrevious:WINBOOL):HWND; external 'user32' name 'GetNextDlgTabItem'; +function GetDialogBaseUnits:longint; external 'user32' name 'GetDialogBaseUnits'; +function OpenClipboard(hWndNewOwner:HWND):WINBOOL; external 'user32' name 'OpenClipboard'; +function CloseClipboard:WINBOOL; external 'user32' name 'CloseClipboard'; +function GetClipboardOwner:HWND; external 'user32' name 'GetClipboardOwner'; +function SetClipboardViewer(hWndNewViewer:HWND):HWND; external 'user32' name 'SetClipboardViewer'; +function GetClipboardViewer:HWND; external 'user32' name 'GetClipboardViewer'; +function ChangeClipboardChain(hWndRemove:HWND; hWndNewNext:HWND):WINBOOL; external 'user32' name 'ChangeClipboardChain'; +function SetClipboardData(uFormat:UINT; hMem:HANDLE):HANDLE; external 'user32' name 'SetClipboardData'; +function GetClipboardData(uFormat:UINT):HANDLE; external 'user32' name 'GetClipboardData'; +function CountClipboardFormats:longint; external 'user32' name 'CountClipboardFormats'; +function EnumClipboardFormats(format:UINT):UINT; external 'user32' name 'EnumClipboardFormats'; +function EmptyClipboard:WINBOOL; external 'user32' name 'EmptyClipboard'; +function IsClipboardFormatAvailable(format:UINT):WINBOOL; external 'user32' name 'IsClipboardFormatAvailable'; +function GetPriorityClipboardFormat(var paFormatPriorityList:UINT; cFormats:longint):longint; external 'user32' name 'GetPriorityClipboardFormat'; +function GetOpenClipboardWindow:HWND; external 'user32' name 'GetOpenClipboardWindow'; +function CharNextExA(CodePage:WORD; lpCurrentChar:LPCSTR; dwFlags:DWORD):LPSTR; external 'user32' name 'CharNextExA'; +function CharPrevExA(CodePage:WORD; lpStart:LPCSTR; lpCurrentChar:LPCSTR; dwFlags:DWORD):LPSTR; external 'user32' name 'CharPrevExA'; +function SetFocus(hWnd:HWND):HWND; external 'user32' name 'SetFocus'; +function GetActiveWindow:HWND; external 'user32' name 'GetActiveWindow'; +function GetFocus:HWND; external 'user32' name 'GetFocus'; +function GetKBCodePage:UINT; external 'user32' name 'GetKBCodePage'; +function GetKeyState(nVirtKey:longint):SHORT; external 'user32' name 'GetKeyState'; +function GetAsyncKeyState(vKey:longint):SHORT; external 'user32' name 'GetAsyncKeyState'; +function GetKeyboardState(lpKeyState:PBYTE):WINBOOL; external 'user32' name 'GetKeyboardState'; +function SetKeyboardState(lpKeyState:LPBYTE):WINBOOL; external 'user32' name 'SetKeyboardState'; +function GetKeyboardType(nTypeFlag:longint):longint; external 'user32' name 'GetKeyboardType'; +function ToAscii(uVirtKey:UINT; uScanCode:UINT; lpKeyState:PBYTE; lpChar:LPWORD; uFlags:UINT):longint; external 'user32' name 'ToAscii'; +function ToAsciiEx(uVirtKey:UINT; uScanCode:UINT; lpKeyState:PBYTE; lpChar:LPWORD; uFlags:UINT;dwhkl:HKL):longint; external 'user32' name 'ToAsciiEx'; +function ToUnicode(wVirtKey:UINT; wScanCode:UINT; lpKeyState:PBYTE; pwszBuff:LPWSTR; cchBuff:longint;wFlags:UINT):longint; external 'user32' name 'ToUnicode'; +function OemKeyScan(wOemChar:WORD):DWORD; external 'user32' name 'OemKeyScan'; +procedure keybd_event(bVk:BYTE; bScan:BYTE; dwFlags:DWORD; dwExtraInfo:DWORD); external 'user32' name 'keybd_event'; +procedure mouse_event(dwFlags:DWORD; dx:DWORD; dy:DWORD; cButtons:DWORD; dwExtraInfo:DWORD); external 'user32' name 'mouse_event'; +function GetInputState:WINBOOL; external 'user32' name 'GetInputState'; +function GetQueueStatus(flags:UINT):DWORD; external 'user32' name 'GetQueueStatus'; +function GetCapture:HWND; external 'user32' name 'GetCapture'; +function SetCapture(hWnd:HWND):HWND; external 'user32' name 'SetCapture'; +function ReleaseCapture:WINBOOL; external 'user32' name 'ReleaseCapture'; +function MsgWaitForMultipleObjects(nCount:DWORD; pHandles:LPHANDLE; fWaitAll:WINBOOL; dwMilliseconds:DWORD; dwWakeMask:DWORD):DWORD; external 'user32' name 'MsgWaitForMultipleObjects'; +function SetTimer(hWnd:HWND; nIDEvent:UINT; uElapse:UINT; lpTimerFunc:TIMERPROC):UINT; external 'user32' name 'SetTimer'; +function KillTimer(hWnd:HWND; uIDEvent:UINT):WINBOOL; external 'user32' name 'KillTimer'; +function IsWindowUnicode(hWnd:HWND):WINBOOL; external 'user32' name 'IsWindowUnicode'; +function EnableWindow(hWnd:HWND; bEnable:WINBOOL):WINBOOL; external 'user32' name 'EnableWindow'; +function IsWindowEnabled(hWnd:HWND):WINBOOL; external 'user32' name 'IsWindowEnabled'; +function DestroyAcceleratorTable(hAccel:HACCEL):WINBOOL; external 'user32' name 'DestroyAcceleratorTable'; +function GetSystemMetrics(nIndex:longint):longint; external 'user32' name 'GetSystemMetrics'; +function GetMenu(hWnd:HWND):HMENU; external 'user32' name 'GetMenu'; +function SetMenu(hWnd:HWND; hMenu:HMENU):WINBOOL; external 'user32' name 'SetMenu'; +function HiliteMenuItem(hWnd:HWND; hMenu:HMENU; uIDHiliteItem:UINT; uHilite:UINT):WINBOOL; external 'user32' name 'HiliteMenuItem'; +function GetMenuState(hMenu:HMENU; uId:UINT; uFlags:UINT):UINT; external 'user32' name 'GetMenuState'; +function DrawMenuBar(hWnd:HWND):WINBOOL; external 'user32' name 'DrawMenuBar'; +function GetSystemMenu(hWnd:HWND; bRevert:WINBOOL):HMENU; external 'user32' name 'GetSystemMenu'; +function CreateMenu:HMENU; external 'user32' name 'CreateMenu'; +function CreatePopupMenu:HMENU; external 'user32' name 'CreatePopupMenu'; +function DestroyMenu(hMenu:HMENU):WINBOOL; external 'user32' name 'DestroyMenu'; +function CheckMenuItem(hMenu:HMENU; uIDCheckItem:UINT; uCheck:UINT):DWORD; external 'user32' name 'CheckMenuItem'; +function EnableMenuItem(hMenu:HMENU; uIDEnableItem:UINT; uEnable:UINT):WINBOOL; external 'user32' name 'EnableMenuItem'; +function GetSubMenu(hMenu:HMENU; nPos:longint):HMENU; external 'user32' name 'GetSubMenu'; +function GetMenuItemID(hMenu:HMENU; nPos:longint):UINT; external 'user32' name 'GetMenuItemID'; +function GetMenuItemCount(hMenu:HMENU):longint; external 'user32' name 'GetMenuItemCount'; +function RemoveMenu(hMenu:HMENU; uPosition:UINT; uFlags:UINT):WINBOOL; external 'user32' name 'RemoveMenu'; +function DeleteMenu(hMenu:HMENU; uPosition:UINT; uFlags:UINT):WINBOOL; external 'user32' name 'DeleteMenu'; +function SetMenuItemBitmaps(hMenu:HMENU; uPosition:UINT; uFlags:UINT; hBitmapUnchecked:HBITMAP; hBitmapChecked:HBITMAP):WINBOOL; external 'user32' name 'SetMenuItemBitmaps'; +function GetMenuCheckMarkDimensions:LONG; external 'user32' name 'GetMenuCheckMarkDimensions'; +function TrackPopupMenu(hMenu:HMENU; uFlags:UINT; x:longint; y:longint; nReserved:longint;hWnd:HWND; var prcRect:RECT):WINBOOL; external 'user32' name 'TrackPopupMenu'; +function GetMenuDefaultItem(hMenu:HMENU; fByPos:UINT; gmdiFlags:UINT):UINT; external 'user32' name 'GetMenuDefaultItem'; +function SetMenuDefaultItem(hMenu:HMENU; uItem:UINT; fByPos:UINT):WINBOOL; external 'user32' name 'SetMenuDefaultItem'; +function GetMenuItemRect(hWnd:HWND; hMenu:HMENU; uItem:UINT; lprcItem:LPRECT):WINBOOL; external 'user32' name 'GetMenuItemRect'; +function MenuItemFromPoint(hWnd:HWND; hMenu:HMENU; ptScreen:POINT):longint; {external 'user32' name 'MenuItemFromPoint';bug 1807 } +function DragObject(_para1:HWND; _para2:HWND; _para3:UINT; _para4:DWORD; _para5:HCURSOR):DWORD; external 'user32' name 'DragObject'; +function DragDetect(hwnd:HWND; pt:POINT):WINBOOL; {external 'user32' name 'DragDetect';bug 1807 } +function DrawIcon(hDC:HDC; X:longint; Y:longint; hIcon:HICON):WINBOOL; external 'user32' name 'DrawIcon'; +function UpdateWindow(hWnd:HWND):WINBOOL; external 'user32' name 'UpdateWindow'; +function SetActiveWindow(hWnd:HWND):HWND; external 'user32' name 'SetActiveWindow'; +function GetForegroundWindow:HWND; external 'user32' name 'GetForegroundWindow'; +function PaintDesktop(hdc:HDC):WINBOOL; external 'user32' name 'PaintDesktop'; +function SetForegroundWindow(hWnd:HWND):WINBOOL; external 'user32' name 'SetForegroundWindow'; +function WindowFromDC(hDC:HDC):HWND; external 'user32' name 'WindowFromDC'; +function GetDC(hWnd:HWND):HDC; external 'user32' name 'GetDC'; +function GetDCEx(hWnd:HWND; hrgnClip:HRGN; flags:DWORD):HDC; external 'user32' name 'GetDCEx'; +function GetWindowDC(hWnd:HWND):HDC; external 'user32' name 'GetWindowDC'; +function ReleaseDC(hWnd:HWND; hDC:HDC):longint; external 'user32' name 'ReleaseDC'; +function BeginPaint(hWnd:HWND; lpPaint:LPPAINTSTRUCT):HDC; external 'user32' name 'BeginPaint'; +function EndPaint(hWnd:HWND; lpPaint:LPPAINTSTRUCT):WINBOOL; external 'user32' name 'EndPaint'; +function GetUpdateRect(hWnd:HWND; lpRect:LPRECT; bErase:WINBOOL):WINBOOL; external 'user32' name 'GetUpdateRect'; +function GetUpdateRgn(hWnd:HWND; hRgn:HRGN; bErase:WINBOOL):longint; external 'user32' name 'GetUpdateRgn'; +function SetWindowRgn(hWnd:HWND; hRgn:HRGN; bRedraw:WINBOOL):longint; external 'user32' name 'SetWindowRgn'; +function GetWindowRgn(hWnd:HWND; hRgn:HRGN):longint; external 'user32' name 'GetWindowRgn'; +function ExcludeUpdateRgn(hDC:HDC; hWnd:HWND):longint; external 'user32' name 'ExcludeUpdateRgn'; +function InvalidateRect(hWnd:HWND; var lpRect:RECT; bErase:WINBOOL):WINBOOL; external 'user32' name 'InvalidateRect'; +function InvalidateRect(hWnd:HWND;lpRect:LPRECT; bErase:WINBOOL):WINBOOL; external 'user32' name 'InvalidateRect'; +function ValidateRect(hWnd:HWND; var lpRect:RECT):WINBOOL; external 'user32' name 'ValidateRect'; +function ValidateRect(hWnd:HWND;lpRect:LPRECT):WINBOOL; external 'user32' name 'ValidateRect'; +function InvalidateRgn(hWnd:HWND; hRgn:HRGN; bErase:WINBOOL):WINBOOL; external 'user32' name 'InvalidateRgn'; +function ValidateRgn(hWnd:HWND; hRgn:HRGN):WINBOOL; external 'user32' name 'ValidateRgn'; +function RedrawWindow(hWnd:HWND; var lprcUpdate:RECT; hrgnUpdate:HRGN; flags:UINT):WINBOOL; external 'user32' name 'RedrawWindow'; +function RedrawWindow(hWnd:HWND; lprcUpdate:LPRECT; hrgnUpdate:HRGN; flags:UINT):WINBOOL; external 'user32' name 'RedrawWindow'; +function LockWindowUpdate(hWndLock:HWND):WINBOOL; external 'user32' name 'LockWindowUpdate'; +function ScrollWindow(hWnd:HWND; XAmount:longint; YAmount:longint; var lpRect:RECT; var lpClipRect:RECT):WINBOOL; external 'user32' name 'ScrollWindow'; +function ScrollDC(hDC:HDC; dx:longint; dy:longint; var lprcScroll:RECT; var lprcClip:RECT;hrgnUpdate:HRGN; lprcUpdate:LPRECT):WINBOOL; external 'user32' name 'ScrollDC'; +function ScrollWindowEx(hWnd:HWND; dx:longint; dy:longint; var prcScroll:RECT; var prcClip:RECT;hrgnUpdate:HRGN; prcUpdate:LPRECT; flags:UINT):longint; external 'user32' name 'ScrollWindowEx'; +function SetScrollPos(hWnd:HWND; nBar:longint; nPos:longint; bRedraw:WINBOOL):longint; external 'user32' name 'SetScrollPos'; +function GetScrollPos(hWnd:HWND; nBar:longint):longint; external 'user32' name 'GetScrollPos'; +function SetScrollRange(hWnd:HWND; nBar:longint; nMinPos:longint; nMaxPos:longint; bRedraw:WINBOOL):WINBOOL; external 'user32' name 'SetScrollRange'; +function GetScrollRange(hWnd:HWND; nBar:longint; lpMinPos:LPINT; lpMaxPos:LPINT):WINBOOL; external 'user32' name 'GetScrollRange'; +function ShowScrollBar(hWnd:HWND; wBar:longint; bShow:WINBOOL):WINBOOL; external 'user32' name 'ShowScrollBar'; +function EnableScrollBar(hWnd:HWND; wSBflags:UINT; wArrows:UINT):WINBOOL; external 'user32' name 'EnableScrollBar'; +function GetClientRect(hWnd:HWND; lpRect:LPRECT):WINBOOL; external 'user32' name 'GetClientRect'; +function GetWindowRect(hWnd:HWND; lpRect:LPRECT):WINBOOL; external 'user32' name 'GetWindowRect'; +function AdjustWindowRect(lpRect:LPRECT; dwStyle:DWORD; bMenu:WINBOOL):WINBOOL; external 'user32' name 'AdjustWindowRect'; +function AdjustWindowRectEx(lpRect:LPRECT; dwStyle:DWORD; bMenu:WINBOOL; dwExStyle:DWORD):WINBOOL; external 'user32' name 'AdjustWindowRectEx'; +function SetWindowContextHelpId(_para1:HWND; _para2:DWORD):WINBOOL; external 'user32' name 'SetWindowContextHelpId'; +function GetWindowContextHelpId(_para1:HWND):DWORD; external 'user32' name 'GetWindowContextHelpId'; +function SetMenuContextHelpId(_para1:HMENU; _para2:DWORD):WINBOOL; external 'user32' name 'SetMenuContextHelpId'; +function GetMenuContextHelpId(_para1:HMENU):DWORD; external 'user32' name 'GetMenuContextHelpId'; +function MessageBeep(uType:UINT):WINBOOL; external 'user32' name 'MessageBeep'; +function ShowCursor(bShow:WINBOOL):longint; external 'user32' name 'ShowCursor'; +function SetCursorPos(X:longint; Y:longint):WINBOOL; external 'user32' name 'SetCursorPos'; +function SetCursor(hCursor:HCURSOR):HCURSOR; external 'user32' name 'SetCursor'; +function GetCursorPos(lpPoint:LPPOINT):WINBOOL; external 'user32' name 'GetCursorPos'; +function ClipCursor(lpRect:LPRECT):WINBOOL; external 'user32' name 'ClipCursor'; +function GetClipCursor(lpRect:LPRECT):WINBOOL; external 'user32' name 'GetClipCursor'; +function GetCursor:HCURSOR; external 'user32' name 'GetCursor'; +function CreateCaret(hWnd:HWND; hBitmap:HBITMAP; nWidth:longint; nHeight:longint):WINBOOL; external 'user32' name 'CreateCaret'; +function GetCaretBlinkTime:UINT; external 'user32' name 'GetCaretBlinkTime'; +function SetCaretBlinkTime(uMSeconds:UINT):WINBOOL; external 'user32' name 'SetCaretBlinkTime'; +function DestroyCaret:WINBOOL; external 'user32' name 'DestroyCaret'; +function HideCaret(hWnd:HWND):WINBOOL; external 'user32' name 'HideCaret'; +function ShowCaret(hWnd:HWND):WINBOOL; external 'user32' name 'ShowCaret'; +function SetCaretPos(X:longint; Y:longint):WINBOOL; external 'user32' name 'SetCaretPos'; +function GetCaretPos(lpPoint:LPPOINT):WINBOOL; external 'user32' name 'GetCaretPos'; +function ClientToScreen(hWnd:HWND; lpPoint:LPPOINT):WINBOOL; external 'user32' name 'ClientToScreen'; +function ScreenToClient(hWnd:HWND; lpPoint:LPPOINT):WINBOOL; external 'user32' name 'ScreenToClient'; +function MapWindowPoints(hWndFrom:HWND; hWndTo:HWND; lpPoints:LPPOINT; cPoints:UINT):longint; external 'user32' name 'MapWindowPoints'; +function WindowFromPoint(Point:POINT):HWND; { external 'user32' name 'WindowFromPoint';bug 1807 } +function ChildWindowFromPoint(hWndParent:HWND; Point:POINT):HWND; { external 'user32' name 'ChildWindowFromPoint';bug 1807 } +function GetSysColor(nIndex:longint):DWORD; external 'user32' name 'GetSysColor'; +function GetSysColorBrush(nIndex:longint):HBRUSH; external 'user32' name 'GetSysColorBrush'; +function SetSysColors(cElements:longint; var lpaElements:wINT; var lpaRgbValues:COLORREF):WINBOOL; external 'user32' name 'SetSysColors'; +function DrawFocusRect(hDC:HDC; var lprc:RECT):WINBOOL; external 'user32' name 'DrawFocusRect'; +function FillRect(hDC:HDC; const lprc:RECT; hbr:HBRUSH):longint; external 'user32' name 'FillRect'; +function FrameRect(hDC:HDC; var lprc:RECT; hbr:HBRUSH):longint; external 'user32' name 'FrameRect'; +function InvertRect(hDC:HDC; var lprc:RECT):WINBOOL; external 'user32' name 'InvertRect'; +function SetRect(lprc:LPRECT; xLeft:longint; yTop:longint; xRight:longint; yBottom:longint):WINBOOL; external 'user32' name 'SetRect'; +function SetRectEmpty(lprc:LPRECT):WINBOOL; external 'user32' name 'SetRectEmpty'; +function CopyRect(lprcDst:LPRECT; var lprcSrc:RECT):WINBOOL; external 'user32' name 'CopyRect'; +function InflateRect(lprc:LPRECT; dx:longint; dy:longint):WINBOOL; external 'user32' name 'InflateRect'; +function IntersectRect(lprcDst:LPRECT; var lprcSrc1:RECT; var lprcSrc2:RECT):WINBOOL; external 'user32' name 'IntersectRect'; +function UnionRect(lprcDst:LPRECT; var lprcSrc1:RECT; var lprcSrc2:RECT):WINBOOL; external 'user32' name 'UnionRect'; +function SubtractRect(lprcDst:LPRECT; var lprcSrc1:RECT; var lprcSrc2:RECT):WINBOOL; external 'user32' name 'SubtractRect'; +function OffsetRect(lprc:LPRECT; dx:longint; dy:longint):WINBOOL; external 'user32' name 'OffsetRect'; +function IsRectEmpty(var lprc:RECT):WINBOOL; external 'user32' name 'IsRectEmpty'; +function EqualRect(var lprc1:RECT; var lprc2:RECT):WINBOOL; external 'user32' name 'EqualRect'; +function PtInRect(var lprc:RECT; pt:POINT):WINBOOL; {external 'user32' name 'PtInRect';bug 1807 } +function PtInRect(lprc:LPRECT; pt:POINT):WINBOOL; +function GetWindowWord(hWnd:HWND; nIndex:longint):WORD; external 'user32' name 'GetWindowWord'; +function SetWindowWord(hWnd:HWND; nIndex:longint; wNewWord:WORD):WORD; external 'user32' name 'SetWindowWord'; +function GetClassWord(hWnd:HWND; nIndex:longint):WORD; external 'user32' name 'GetClassWord'; +function SetClassWord(hWnd:HWND; nIndex:longint; wNewWord:WORD):WORD; external 'user32' name 'SetClassWord'; +function GetDesktopWindow:HWND; external 'user32' name 'GetDesktopWindow'; +function GetParent(hWnd:HWND):HWND; external 'user32' name 'GetParent'; +function SetParent(hWndChild:HWND; hWndNewParent:HWND):HWND; external 'user32' name 'SetParent'; +function EnumChildWindows(hWndParent:HWND; lpEnumFunc:ENUMWINDOWSPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumChildWindows'; +function EnumWindows(lpEnumFunc:ENUMWINDOWSPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumWindows'; +function EnumThreadWindows(dwThreadId:DWORD; lpfn:ENUMWINDOWSPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumThreadWindows'; +function EnumTaskWindows(hTask:HWND; lpfn:FARPROC; lParam: LPARAM): BOOL;external 'user32' name 'EnumThreadWindows'; +function GetTopWindow(hWnd:HWND):HWND; external 'user32' name 'GetTopWindow'; +function GetWindowThreadProcessId(hWnd:HWND; lpdwProcessId:LPDWORD):DWORD; external 'user32' name 'GetWindowThreadProcessId'; +function GetLastActivePopup(hWnd:HWND):HWND; external 'user32' name 'GetLastActivePopup'; +function UnhookWindowsHook(nCode:longint; pfnFilterProc:HOOKPROC):WINBOOL; external 'user32' name 'UnhookWindowsHook'; +function UnhookWindowsHookEx(hhk:HHOOK):WINBOOL; external 'user32' name 'UnhookWindowsHookEx'; +function CallNextHookEx(hhk:HHOOK; nCode:longint; wParam:WPARAM; lParam:LPARAM):LRESULT; external 'user32' name 'CallNextHookEx'; +function CheckMenuRadioItem(_para1:HMENU; _para2:UINT; _para3:UINT; _para4:UINT; _para5:UINT):WINBOOL; external 'user32' name 'CheckMenuRadioItem'; +function CreateCursor(hInst:HINST; xHotSpot:longint; yHotSpot:longint; nWidth:longint; nHeight:longint;pvANDPlane:pointer; pvXORPlane:pointer):HCURSOR; external 'user32' name 'CreateCursor'; +function DestroyCursor(hCursor:HCURSOR):WINBOOL; external 'user32' name 'DestroyCursor'; +function SetSystemCursor(hcur:HCURSOR; anID:DWORD):WINBOOL; external 'user32' name 'SetSystemCursor'; +function CreateIcon(hInstance:HINST; nWidth:longint; nHeight:longint; cPlanes:BYTE; cBitsPixel:BYTE;var lpbANDbits:BYTE; var lpbXORbits:BYTE):HICON; external 'user32' name 'CreateIcon'; +function DestroyIcon(hIcon:HICON):WINBOOL; external 'user32' name 'DestroyIcon'; +function LookupIconIdFromDirectory(presbits:PBYTE; fIcon:WINBOOL):longint; external 'user32' name 'LookupIconIdFromDirectory'; +function LookupIconIdFromDirectoryEx(presbits:PBYTE; fIcon:WINBOOL; cxDesired:longint; cyDesired:longint; Flags:UINT):longint; external 'user32' name 'LookupIconIdFromDirectoryEx'; +function CreateIconFromResource(presbits:PBYTE; dwResSize:DWORD; fIcon:WINBOOL; dwVer:DWORD):HICON; external 'user32' name 'CreateIconFromResource'; +function CreateIconFromResourceEx(presbits:PBYTE; dwResSize:DWORD; fIcon:WINBOOL; dwVer:DWORD; cxDesired:longint;cyDesired:longint; Flags:UINT):HICON; external 'user32' name 'CreateIconFromResourceEx'; +function CopyImage(_para1:HANDLE; _para2:UINT; _para3:longint; _para4:longint; _para5:UINT):HICON; external 'user32' name 'CopyImage'; +function CreateIconIndirect(piconinfo:PICONINFO):HICON; external 'user32' name 'CreateIconIndirect'; +function CopyIcon(hIcon:HICON):HICON; external 'user32' name 'CopyIcon'; +function GetIconInfo(hIcon:HICON; piconinfo:PICONINFO):WINBOOL; external 'user32' name 'GetIconInfo'; +function MapDialogRect(hDlg:HWND; lpRect:LPRECT):WINBOOL; external 'user32' name 'MapDialogRect'; +function SetScrollInfo(_para1:HWND; _para2:longint; _para3:LPCSCROLLINFO; _para4:WINBOOL):longint; external 'user32' name 'SetScrollInfo'; +function GetScrollInfo(_para1:HWND; _para2:longint; _para3:LPSCROLLINFO):WINBOOL; external 'user32' name 'GetScrollInfo'; +function TranslateMDISysAccel(hWndClient:HWND; lpMsg:LPMSG):WINBOOL; external 'user32' name 'TranslateMDISysAccel'; +function ArrangeIconicWindows(hWnd:HWND):UINT; external 'user32' name 'ArrangeIconicWindows'; +function TileWindows(hwndParent:HWND; wHow:UINT; var lpRect:RECT; cKids:UINT; var lpKids:HWND):WORD; external 'user32' name 'TileWindows'; +function CascadeWindows(hwndParent:HWND; wHow:UINT; var lpRect:RECT; cKids:UINT; var lpKids:HWND):WORD; external 'user32' name 'CascadeWindows'; +procedure SetLastErrorEx(dwErrCode:DWORD; dwType:DWORD); external 'user32' name 'SetLastErrorEx'; +procedure SetDebugErrorLevel(dwLevel:DWORD); external 'user32' name 'SetDebugErrorLevel'; +function DrawEdge(hdc:HDC; qrc:LPRECT; edge:UINT; grfFlags:UINT):WINBOOL; external 'user32' name 'DrawEdge'; +function DrawFrameControl(_para1:HDC; _para2:LPRECT; _para3:UINT; _para4:UINT):WINBOOL; external 'user32' name 'DrawFrameControl'; +function DrawCaption(_para1:HWND; _para2:HDC; var _para3:RECT; _para4:UINT):WINBOOL; external 'user32' name 'DrawCaption'; +function DrawAnimatedRects(hwnd:HWND; idAni:longint; var lprcFrom:RECT; var lprcTo:RECT):WINBOOL; external 'user32' name 'DrawAnimatedRects'; +function TrackPopupMenuEx(_para1:HMENU; _para2:UINT; _para3:longint; _para4:longint; _para5:HWND;_para6:LPTPMPARAMS):WINBOOL; external 'user32' name 'TrackPopupMenuEx'; +function ChildWindowFromPointEx(_para1:HWND; _para2:POINT; _para3:UINT):HWND; {external 'user32' name 'ChildWindowFromPointEx';} +function DrawIconEx(hdc:HDC; xLeft:longint; yTop:longint; hIcon:HICON; cxWidth:longint;cyWidth:longint; istepIfAniCur:UINT; hbrFlickerFreeDraw:HBRUSH; diFlags:UINT):WINBOOL; external 'user32' name 'DrawIconEx'; +function AnimatePalette(_para1:HPALETTE; _para2:UINT; _para3:UINT; var _para4:PALETTEENTRY):WINBOOL; external 'gdi32' name 'AnimatePalette'; +function Arc(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint; _para7:longint; _para8:longint; _para9:longint):WINBOOL; external 'gdi32' name 'Arc'; +function BitBlt(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:HDC; _para7:longint; _para8:longint; _para9:DWORD):WINBOOL; external 'gdi32' name 'BitBlt'; +function CancelDC(_para1:HDC):WINBOOL; external 'gdi32' name 'CancelDC'; +function Chord(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint; _para7:longint; _para8:longint; _para9:longint):WINBOOL; external 'gdi32' name 'Chord'; +function CloseMetaFile(_para1:HDC):HMETAFILE; external 'gdi32' name 'CloseMetaFile'; +function CombineRgn(_para1:HRGN; _para2:HRGN; _para3:HRGN; _para4:longint):longint; external 'gdi32' name 'CombineRgn'; +function CreateBitmap(_para1:longint; _para2:longint; _para3:UINT; _para4:UINT; _para5:pointer):HBITMAP; external 'gdi32' name 'CreateBitmap'; +function CreateBitmapIndirect(var _para1:BITMAP):HBITMAP; external 'gdi32' name 'CreateBitmapIndirect'; +function CreateBrushIndirect(var _para1:LOGBRUSH):HBRUSH; external 'gdi32' name 'CreateBrushIndirect'; +function CreateCompatibleBitmap(_para1:HDC; _para2:longint; _para3:longint):HBITMAP; external 'gdi32' name 'CreateCompatibleBitmap'; +function CreateDiscardableBitmap(_para1:HDC; _para2:longint; _para3:longint):HBITMAP; external 'gdi32' name 'CreateDiscardableBitmap'; +function CreateCompatibleDC(_para1:HDC):HDC; external 'gdi32' name 'CreateCompatibleDC'; +function CreateDIBitmap(_para1:HDC; var _para2:BITMAPINFOHEADER; _para3:DWORD; _para4:pointer; var _para5:BITMAPINFO;_para6:UINT):HBITMAP; external 'gdi32' name 'CreateDIBitmap'; +function CreateDIBPatternBrush(_para1:HGLOBAL; _para2:UINT):HBRUSH; external 'gdi32' name 'CreateDIBPatternBrush'; +function CreateDIBPatternBrushPt(_para1:pointer; _para2:UINT):HBRUSH; external 'gdi32' name 'CreateDIBPatternBrushPt'; +function CreateEllipticRgn(_para1:longint; _para2:longint; _para3:longint; _para4:longint):HRGN; external 'gdi32' name 'CreateEllipticRgn'; +function CreateEllipticRgnIndirect(var _para1:RECT):HRGN; external 'gdi32' name 'CreateEllipticRgnIndirect'; +function CreateHatchBrush(_para1:longint; _para2:COLORREF):HBRUSH; external 'gdi32' name 'CreateHatchBrush'; +function CreatePalette(var _para1:LOGPALETTE):HPALETTE; external 'gdi32' name 'CreatePalette'; +function CreatePen(_para1:longint; _para2:longint; _para3:COLORREF):HPEN; external 'gdi32' name 'CreatePen'; +function CreatePenIndirect(var _para1:LOGPEN):HPEN; external 'gdi32' name 'CreatePenIndirect'; +function CreatePolyPolygonRgn(var _para1:POINT; var _para2:wINT; _para3:longint; _para4:longint):HRGN; external 'gdi32' name 'CreatePolyPolygonRgn'; +function CreatePatternBrush(_para1:HBITMAP):HBRUSH; external 'gdi32' name 'CreatePatternBrush'; +function CreateRectRgn(_para1:longint; _para2:longint; _para3:longint; _para4:longint):HRGN; external 'gdi32' name 'CreateRectRgn'; +function CreateRectRgnIndirect(var _para1:RECT):HRGN; external 'gdi32' name 'CreateRectRgnIndirect'; +function CreateRoundRectRgn(_para1:longint; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint):HRGN; external 'gdi32' name 'CreateRoundRectRgn'; +function CreateSolidBrush(_para1:COLORREF):HBRUSH; external 'gdi32' name 'CreateSolidBrush'; +function DeleteDC(_para1:HDC):WINBOOL; external 'gdi32' name 'DeleteDC'; +function DeleteMetaFile(_para1:HMETAFILE):WINBOOL; external 'gdi32' name 'DeleteMetaFile'; +function DeleteObject(_para1:HGDIOBJ):WINBOOL; external 'gdi32' name 'DeleteObject'; +function DrawEscape(_para1:HDC; _para2:longint; _para3:longint; _para4:LPCSTR):longint; external 'gdi32' name 'DrawEscape'; +function Ellipse(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint):WINBOOL; external 'gdi32' name 'Ellipse'; +function EnumObjects(_para1:HDC; _para2:longint; _para3:ENUMOBJECTSPROC; _para4:LPARAM):longint; external 'gdi32' name 'EnumObjects'; +function EqualRgn(_para1:HRGN; _para2:HRGN):WINBOOL; external 'gdi32' name 'EqualRgn'; +function Escape(_para1:HDC; _para2:longint; _para3:longint; _para4:LPCSTR; _para5:LPVOID):longint; external 'gdi32' name 'Escape'; +function ExtEscape(_para1:HDC; _para2:longint; _para3:longint; _para4:LPCSTR; _para5:longint;_para6:LPSTR):longint; external 'gdi32' name 'ExtEscape'; +function ExcludeClipRect(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint):longint; external 'gdi32' name 'ExcludeClipRect'; +function ExtCreateRegion(var _para1:XFORM; _para2:DWORD; var _para3:RGNDATA):HRGN; external 'gdi32' name 'ExtCreateRegion'; +function ExtFloodFill(_para1:HDC; _para2:longint; _para3:longint; _para4:COLORREF; _para5:UINT):WINBOOL; external 'gdi32' name 'ExtFloodFill'; +function FillRgn(_para1:HDC; _para2:HRGN; _para3:HBRUSH):WINBOOL; external 'gdi32' name 'FillRgn'; +function FloodFill(_para1:HDC; _para2:longint; _para3:longint; _para4:COLORREF):WINBOOL; external 'gdi32' name 'FloodFill'; +function FrameRgn(_para1:HDC; _para2:HRGN; _para3:HBRUSH; _para4:longint; _para5:longint):WINBOOL; external 'gdi32' name 'FrameRgn'; +function GetROP2(_para1:HDC):longint; external 'gdi32' name 'GetROP2'; +function GetAspectRatioFilterEx(_para1:HDC; _para2:LPSIZE):WINBOOL; external 'gdi32' name 'GetAspectRatioFilterEx'; +function GetBkColor(_para1:HDC):COLORREF; external 'gdi32' name 'GetBkColor'; +function GetBkMode(_para1:HDC):longint; external 'gdi32' name 'GetBkMode'; +function GetBitmapBits(_para1:HBITMAP; _para2:LONG; _para3:LPVOID):LONG; external 'gdi32' name 'GetBitmapBits'; +function GetBitmapDimensionEx(_para1:HBITMAP; _para2:LPSIZE):WINBOOL; external 'gdi32' name 'GetBitmapDimensionEx'; +function GetBoundsRect(_para1:HDC; _para2:LPRECT; _para3:UINT):UINT; external 'gdi32' name 'GetBoundsRect'; +function GetBrushOrgEx(_para1:HDC; _para2:LPPOINT):WINBOOL; external 'gdi32' name 'GetBrushOrgEx'; +function GetClipBox(_para1:HDC; _para2:LPRECT):longint; external 'gdi32' name 'GetClipBox'; +function GetClipRgn(_para1:HDC; _para2:HRGN):longint; external 'gdi32' name 'GetClipRgn'; +function GetMetaRgn(_para1:HDC; _para2:HRGN):longint; external 'gdi32' name 'GetMetaRgn'; +function GetCurrentObject(_para1:HDC; _para2:UINT):HGDIOBJ; external 'gdi32' name 'GetCurrentObject'; +function GetCurrentPositionEx(_para1:HDC; _para2:LPPOINT):WINBOOL; external 'gdi32' name 'GetCurrentPositionEx'; +function GetDeviceCaps(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'GetDeviceCaps'; +function GetDIBits(_para1:HDC; _para2:HBITMAP; _para3:UINT; _para4:UINT; _para5:LPVOID;_para6:LPBITMAPINFO; _para7:UINT):longint; external 'gdi32' name 'GetDIBits'; +function GetFontData(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:LPVOID; _para5:DWORD):DWORD; external 'gdi32' name 'GetFontData'; +function GetGraphicsMode(_para1:HDC):longint; external 'gdi32' name 'GetGraphicsMode'; +function GetMapMode(_para1:HDC):longint; external 'gdi32' name 'GetMapMode'; +function GetMetaFileBitsEx(_para1:HMETAFILE; _para2:UINT; _para3:LPVOID):UINT; external 'gdi32' name 'GetMetaFileBitsEx'; +function GetNearestColor(_para1:HDC; _para2:COLORREF):COLORREF; external 'gdi32' name 'GetNearestColor'; +function GetNearestPaletteIndex(_para1:HPALETTE; _para2:COLORREF):UINT; external 'gdi32' name 'GetNearestPaletteIndex'; +function GetObjectType(h:HGDIOBJ):DWORD; external 'gdi32' name 'GetObjectType'; +function GetPaletteEntries(_para1:HPALETTE; _para2:UINT; _para3:UINT; _para4:LPPALETTEENTRY):UINT; external 'gdi32' name 'GetPaletteEntries'; +function GetPixel(_para1:HDC; _para2:longint; _para3:longint):COLORREF; external 'gdi32' name 'GetPixel'; +function GetPixelFormat(_para1:HDC):longint; external 'gdi32' name 'GetPixelFormat'; +function GetPolyFillMode(_para1:HDC):longint; external 'gdi32' name 'GetPolyFillMode'; +function GetRasterizerCaps(_para1:LPRASTERIZER_STATUS; _para2:UINT):WINBOOL; external 'gdi32' name 'GetRasterizerCaps'; +function GetRegionData(_para1:HRGN; _para2:DWORD; _para3:LPRGNDATA):DWORD; external 'gdi32' name 'GetRegionData'; +function GetRgnBox(_para1:HRGN; _para2:LPRECT):longint; external 'gdi32' name 'GetRgnBox'; +function GetStockObject(_para1:longint):HGDIOBJ; external 'gdi32' name 'GetStockObject'; +function GetStretchBltMode(_para1:HDC):longint; external 'gdi32' name 'GetStretchBltMode'; +function GetSystemPaletteEntries(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPPALETTEENTRY):UINT; external 'gdi32' name 'GetSystemPaletteEntries'; +function GetSystemPaletteUse(_para1:HDC):UINT; external 'gdi32' name 'GetSystemPaletteUse'; +function GetTextCharacterExtra(_para1:HDC):longint; external 'gdi32' name 'GetTextCharacterExtra'; +function GetTextAlign(_para1:HDC):UINT; external 'gdi32' name 'GetTextAlign'; +function GetTextColor(_para1:HDC):COLORREF; external 'gdi32' name 'GetTextColor'; +function GetTextCharset(hdc:HDC):longint; external 'gdi32' name 'GetTextCharset'; +function GetTextCharsetInfo(hdc:HDC; lpSig:LPFONTSIGNATURE; dwFlags:DWORD):longint; external 'gdi32' name 'GetTextCharsetInfo'; +function TranslateCharsetInfo(var lpSrc:DWORD; lpCs:LPCHARSETINFO; dwFlags:DWORD):WINBOOL; external 'gdi32' name 'TranslateCharsetInfo'; +function GetFontLanguageInfo(_para1:HDC):DWORD; external 'gdi32' name 'GetFontLanguageInfo'; +function GetViewportExtEx(_para1:HDC; _para2:LPSIZE):WINBOOL; external 'gdi32' name 'GetViewportExtEx'; +function GetViewportOrgEx(_para1:HDC; _para2:LPPOINT):WINBOOL; external 'gdi32' name 'GetViewportOrgEx'; +function GetWindowExtEx(_para1:HDC; _para2:LPSIZE):WINBOOL; external 'gdi32' name 'GetWindowExtEx'; +function GetWindowOrgEx(_para1:HDC; _para2:LPPOINT):WINBOOL; external 'gdi32' name 'GetWindowOrgEx'; +function IntersectClipRect(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint):longint; external 'gdi32' name 'IntersectClipRect'; +function InvertRgn(_para1:HDC; _para2:HRGN):WINBOOL; external 'gdi32' name 'InvertRgn'; +function LineDDA(_para1:longint; _para2:longint; _para3:longint; _para4:longint; _para5:LINEDDAPROC;_para6:LPARAM):WINBOOL; external 'gdi32' name 'LineDDA'; +function LineTo(_para1:HDC; _para2:longint; _para3:longint):WINBOOL; external 'gdi32' name 'LineTo'; +function MaskBlt(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:HDC; _para7:longint; _para8:longint; _para9:HBITMAP; _para10:longint;_para11:longint; _para12:DWORD):WINBOOL; external 'gdi32' name 'MaskBlt'; +function PlgBlt(_para1:HDC; var _para2:POINT; _para3:HDC; _para4:longint; _para5:longint;_para6:longint; _para7:longint; _para8:HBITMAP; _para9:longint; _para10:longint):WINBOOL; external 'gdi32' name 'PlgBlt'; +function OffsetClipRgn(_para1:HDC; _para2:longint; _para3:longint):longint; external 'gdi32' name 'OffsetClipRgn'; +function OffsetRgn(_para1:HRGN; _para2:longint; _para3:longint):longint; external 'gdi32' name 'OffsetRgn'; +function PatBlt(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:DWORD):WINBOOL; external 'gdi32' name 'PatBlt'; +function Pie(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint; _para7:longint; _para8:longint; _para9:longint):WINBOOL; external 'gdi32' name 'Pie'; +function PlayMetaFile(_para1:HDC; _para2:HMETAFILE):WINBOOL; external 'gdi32' name 'PlayMetaFile'; +function PaintRgn(_para1:HDC; _para2:HRGN):WINBOOL; external 'gdi32' name 'PaintRgn'; +function PolyPolygon(_para1:HDC; var _para2:POINT; var _para3:wINT; _para4:longint):WINBOOL; external 'gdi32' name 'PolyPolygon'; +function PtInRegion(_para1:HRGN; _para2:longint; _para3:longint):WINBOOL; external 'gdi32' name 'PtInRegion'; +function PtVisible(_para1:HDC; _para2:longint; _para3:longint):WINBOOL; external 'gdi32' name 'PtVisible'; +function RectInRegion(_para1:HRGN; var _para2:RECT):WINBOOL; external 'gdi32' name 'RectInRegion'; +function RectVisible(_para1:HDC; var _para2:RECT):WINBOOL; external 'gdi32' name 'RectVisible'; +function Rectangle(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint):WINBOOL; external 'gdi32' name 'Rectangle'; +function RestoreDC(_para1:HDC; _para2:longint):WINBOOL; external 'gdi32' name 'RestoreDC'; +function RealizePalette(_para1:HDC):UINT; external 'gdi32' name 'RealizePalette'; +function RoundRect(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint; _para7:longint):WINBOOL; external 'gdi32' name 'RoundRect'; +function ResizePalette(_para1:HPALETTE; _para2:UINT):WINBOOL; external 'gdi32' name 'ResizePalette'; +function SaveDC(_para1:HDC):longint; external 'gdi32' name 'SaveDC'; +function SelectClipRgn(_para1:HDC; _para2:HRGN):longint; external 'gdi32' name 'SelectClipRgn'; +function ExtSelectClipRgn(_para1:HDC; _para2:HRGN; _para3:longint):longint; external 'gdi32' name 'ExtSelectClipRgn'; +function SetMetaRgn(_para1:HDC):longint; external 'gdi32' name 'SetMetaRgn'; +function SelectObject(_para1:HDC; _para2:HGDIOBJ):HGDIOBJ; external 'gdi32' name 'SelectObject'; +function SelectPalette(_para1:HDC; _para2:HPALETTE; _para3:WINBOOL):HPALETTE; external 'gdi32' name 'SelectPalette'; +function SetBkColor(_para1:HDC; _para2:COLORREF):COLORREF; external 'gdi32' name 'SetBkColor'; +function SetBkMode(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetBkMode'; +function SetBitmapBits(_para1:HBITMAP; _para2:DWORD; _para3:pointer):LONG; external 'gdi32' name 'SetBitmapBits'; +function SetBoundsRect(_para1:HDC; var _para2:RECT; _para3:UINT):UINT; external 'gdi32' name 'SetBoundsRect'; +function SetDIBits(_para1:HDC; _para2:HBITMAP; _para3:UINT; _para4:UINT; _para5:pointer;_para6:PBITMAPINFO; _para7:UINT):longint; external 'gdi32' name 'SetDIBits'; +function SetDIBitsToDevice(_para1:HDC; _para2:longint; _para3:longint; _para4:DWORD; _para5:DWORD;_para6:longint; _para7:longint; _para8:UINT; _para9:UINT; _para10:pointer;var _para11:BITMAPINFO; _para12:UINT):longint; + external 'gdi32' name 'SetDIBitsToDevice'; +function SetMapperFlags(_para1:HDC; _para2:DWORD):DWORD; external 'gdi32' name 'SetMapperFlags'; +function SetGraphicsMode(hdc:HDC; iMode:longint):longint; external 'gdi32' name 'SetGraphicsMode'; +function SetMapMode(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetMapMode'; +function SetMetaFileBitsEx(_para1:UINT; var _para2:BYTE):HMETAFILE; external 'gdi32' name 'SetMetaFileBitsEx'; +function SetPaletteEntries(_para1:HPALETTE; _para2:UINT; _para3:UINT; var _para4:PALETTEENTRY):UINT; external 'gdi32' name 'SetPaletteEntries'; +function SetPixel(_para1:HDC; _para2:longint; _para3:longint; _para4:COLORREF):COLORREF; external 'gdi32' name 'SetPixel'; +function SetPixelV(_para1:HDC; _para2:longint; _para3:longint; _para4:COLORREF):WINBOOL; external 'gdi32' name 'SetPixelV'; +function SetPolyFillMode(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetPolyFillMode'; +function StretchBlt(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:HDC; _para7:longint; _para8:longint; _para9:longint; _para10:longint;_para11:DWORD):WINBOOL; external 'gdi32' name 'StretchBlt'; +function SetRectRgn(_para1:HRGN; _para2:longint; _para3:longint; _para4:longint; _para5:longint):WINBOOL; external 'gdi32' name 'SetRectRgn'; +function StretchDIBits(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint; _para7:longint; _para8:longint; _para9:longint; _para10:pointer;var _para11:BITMAPINFO; _para12:UINT; _para13:DWORD):longint; + external 'gdi32' name 'StretchDIBits'; +function SetROP2(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetROP2'; +function SetStretchBltMode(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetStretchBltMode'; +function SetSystemPaletteUse(_para1:HDC; _para2:UINT):UINT; external 'gdi32' name 'SetSystemPaletteUse'; +function SetTextCharacterExtra(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetTextCharacterExtra'; +function SetTextColor(_para1:HDC; _para2:COLORREF):COLORREF; external 'gdi32' name 'SetTextColor'; +function SetTextAlign(_para1:HDC; _para2:UINT):UINT; external 'gdi32' name 'SetTextAlign'; +function SetTextJustification(_para1:HDC; _para2:longint; _para3:longint):WINBOOL; external 'gdi32' name 'SetTextJustification'; +function UpdateColors(_para1:HDC):WINBOOL; external 'gdi32' name 'UpdateColors'; +function PlayMetaFileRecord(_para1:HDC; _para2:LPHANDLETABLE; _para3:LPMETARECORD; _para4:UINT):WINBOOL; external 'gdi32' name 'PlayMetaFileRecord'; +function EnumMetaFile(_para1:HDC; _para2:HMETAFILE; _para3:ENUMMETAFILEPROC; _para4:LPARAM):WINBOOL; external 'gdi32' name 'EnumMetaFile'; +function CloseEnhMetaFile(_para1:HDC):HENHMETAFILE; external 'gdi32' name 'CloseEnhMetaFile'; +function DeleteEnhMetaFile(_para1:HENHMETAFILE):WINBOOL; external 'gdi32' name 'DeleteEnhMetaFile'; +function EnumEnhMetaFile(_para1:HDC; _para2:HENHMETAFILE; _para3:ENHMETAFILEPROC; _para4:LPVOID; var _para5:RECT):WINBOOL; external 'gdi32' name 'EnumEnhMetaFile'; +function GetEnhMetaFileHeader(_para1:HENHMETAFILE; _para2:UINT; _para3:LPENHMETAHEADER):UINT; external 'gdi32' name 'GetEnhMetaFileHeader'; +function GetEnhMetaFilePaletteEntries(_para1:HENHMETAFILE; _para2:UINT; _para3:LPPALETTEENTRY):UINT; external 'gdi32' name 'GetEnhMetaFilePaletteEntries'; +function GetWinMetaFileBits(_para1:HENHMETAFILE; _para2:UINT; _para3:LPBYTE; _para4:wINT; _para5:HDC):UINT; external 'gdi32' name 'GetWinMetaFileBits'; +function PlayEnhMetaFile(_para1:HDC; _para2:HENHMETAFILE; var _para3:RECT):WINBOOL; external 'gdi32' name 'PlayEnhMetaFile'; +function PlayEnhMetaFileRecord(_para1:HDC; _para2:LPHANDLETABLE; var _para3:ENHMETARECORD; _para4:UINT):WINBOOL; external 'gdi32' name 'PlayEnhMetaFileRecord'; +function SetEnhMetaFileBits(_para1:UINT; var _para2:BYTE):HENHMETAFILE; external 'gdi32' name 'SetEnhMetaFileBits'; +function SetWinMetaFileBits(_para1:UINT; var _para2:BYTE; _para3:HDC; var _para4:METAFILEPICT):HENHMETAFILE; external 'gdi32' name 'SetWinMetaFileBits'; +function GdiComment(_para1:HDC; _para2:UINT; var _para3:BYTE):WINBOOL; external 'gdi32' name 'GdiComment'; +function AngleArc(_para1:HDC; _para2:longint; _para3:longint; _para4:DWORD; _para5:Single;_para6:Single):WINBOOL; external 'gdi32' name 'AngleArc'; +function PolyPolyline(_para1:HDC; var _para2:POINT; var _para3:DWORD; _para4:DWORD):WINBOOL; external 'gdi32' name 'PolyPolyline'; +function GetWorldTransform(_para1:HDC; _para2:LPXFORM):WINBOOL; external 'gdi32' name 'GetWorldTransform'; +function SetWorldTransform(_para1:HDC; var _para2:XFORM):WINBOOL; external 'gdi32' name 'SetWorldTransform'; +function ModifyWorldTransform(_para1:HDC; var _para2:XFORM; _para3:DWORD):WINBOOL; external 'gdi32' name 'ModifyWorldTransform'; +function CombineTransform(_para1:LPXFORM; var _para2:XFORM; var _para3:XFORM):WINBOOL; external 'gdi32' name 'CombineTransform'; +function CreateDIBSection(_para1:HDC; var _para2:BITMAPINFO; _para3:UINT; var _para4:pointer; _para5:HANDLE;_para6:DWORD):HBITMAP; external 'gdi32' name 'CreateDIBSection'; +function GetDIBColorTable(_para1:HDC; _para2:UINT; _para3:UINT; var _para4:RGBQUAD):UINT; external 'gdi32' name 'GetDIBColorTable'; +function SetDIBColorTable(_para1:HDC; _para2:UINT; _para3:UINT; var _para4:RGBQUAD):UINT; external 'gdi32' name 'SetDIBColorTable'; +function SetColorAdjustment(_para1:HDC; var _para2:COLORADJUSTMENT):WINBOOL; external 'gdi32' name 'SetColorAdjustment'; +function GetColorAdjustment(_para1:HDC; _para2:LPCOLORADJUSTMENT):WINBOOL; external 'gdi32' name 'GetColorAdjustment'; +function CreateHalftonePalette(_para1:HDC):HPALETTE; external 'gdi32' name 'CreateHalftonePalette'; +function EndDoc(_para1:HDC):longint; external 'gdi32' name 'EndDoc'; +function StartPage(_para1:HDC):longint; external 'gdi32' name 'StartPage'; +function EndPage(_para1:HDC):longint; external 'gdi32' name 'EndPage'; +function AbortDoc(_para1:HDC):longint; external 'gdi32' name 'AbortDoc'; +function SetAbortProc(_para1:HDC; _para2:TABORTPROC):longint; external 'gdi32' name 'SetAbortProc'; +{function AbortPath(_para1:HDC):WINBOOL; external 'gdi32' name 'AbortPath';} +function ArcTo(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:longint; _para7:longint; _para8:longint; _para9:longint):WINBOOL; external 'gdi32' name 'ArcTo'; +function BeginPath(_para1:HDC):WINBOOL; external 'gdi32' name 'BeginPath'; +function CloseFigure(_para1:HDC):WINBOOL; external 'gdi32' name 'CloseFigure'; +function EndPath(_para1:HDC):WINBOOL; external 'gdi32' name 'EndPath'; +function FillPath(_para1:HDC):WINBOOL; external 'gdi32' name 'FillPath'; +function FlattenPath(_para1:HDC):WINBOOL; external 'gdi32' name 'FlattenPath'; +function GetPath(_para1:HDC; _para2:LPPOINT; _para3:LPBYTE; _para4:longint):longint; external 'gdi32' name 'GetPath'; +function PathToRegion(_para1:HDC):HRGN; external 'gdi32' name 'PathToRegion'; +function PolyDraw(_para1:HDC; var _para2:POINT; var _para3:BYTE; _para4:longint):WINBOOL; external 'gdi32' name 'PolyDraw'; +function SelectClipPath(_para1:HDC; _para2:longint):WINBOOL; external 'gdi32' name 'SelectClipPath'; +function SetArcDirection(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetArcDirection'; +function SetMiterLimit(_para1:HDC; _para2:Single; _para3:PSingle):WINBOOL; external 'gdi32' name 'SetMiterLimit'; +function StrokeAndFillPath(_para1:HDC):WINBOOL; external 'gdi32' name 'StrokeAndFillPath'; +function StrokePath(_para1:HDC):WINBOOL; external 'gdi32' name 'StrokePath'; +function WidenPath(_para1:HDC):WINBOOL; external 'gdi32' name 'WidenPath'; +function ExtCreatePen(_para1:DWORD; _para2:DWORD; var _para3:LOGBRUSH; _para4:DWORD; var _para5:DWORD):HPEN; external 'gdi32' name 'ExtCreatePen'; +function GetMiterLimit(_para1:HDC; _para2:PSingle):WINBOOL; external 'gdi32' name 'GetMiterLimit'; +function GetArcDirection(_para1:HDC):longint; external 'gdi32' name 'GetArcDirection'; +function MoveToEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'MoveToEx'; +function CreatePolygonRgn(var _para1:POINT; _para2:longint; _para3:longint):HRGN; external 'gdi32' name 'CreatePolygonRgn'; +function DPtoLP(_para1:HDC; _para2:LPPOINT; _para3:longint):WINBOOL; external 'gdi32' name 'DPtoLP'; +function LPtoDP(_para1:HDC; _para2:LPPOINT; _para3:longint):WINBOOL; external 'gdi32' name 'LPtoDP'; +function Polygon(_para1:HDC; _para2:LPPOINT; _para3:longint):WINBOOL; external 'gdi32' name 'Polygon'; +function Polyline(_para1:HDC; _para2:LPPOINT; _para3:longint):WINBOOL; external 'gdi32' name 'Polyline'; +function PolyBezier(_para1:HDC; _para2:LPPOINT; _para3:DWORD):WINBOOL; external 'gdi32' name 'PolyBezier'; +function PolyBezierTo(_para1:HDC; _para2:POINT; _para3:DWORD):WINBOOL; external 'gdi32' name 'PolyBezierTo'; +function PolylineTo(_para1:HDC; _para2:LPPOINT; _para3:DWORD):WINBOOL; external 'gdi32' name 'PolylineTo'; +function SetViewportExtEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'SetViewportExtEx'; +function SetViewportOrgEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'SetViewportOrgEx'; +function SetWindowExtEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'SetWindowExtEx'; +function SetWindowOrgEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'SetWindowOrgEx'; +function OffsetViewportOrgEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'OffsetViewportOrgEx'; +function OffsetWindowOrgEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'OffsetWindowOrgEx'; +function ScaleViewportExtEx(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:LPSIZE):WINBOOL; external 'gdi32' name 'ScaleViewportExtEx'; +function ScaleWindowExtEx(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:LPSIZE):WINBOOL; external 'gdi32' name 'ScaleWindowExtEx'; +function SetBitmapDimensionEx(_para1:HBITMAP; _para2:longint; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'SetBitmapDimensionEx'; +function SetBrushOrgEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'SetBrushOrgEx'; +function GetDCOrgEx(_para1:HDC; _para2:LPPOINT):WINBOOL; external 'gdi32' name 'GetDCOrgEx'; +function FixBrushOrgEx(_para1:HDC; _para2:longint; _para3:longint; _para4:LPPOINT):WINBOOL; external 'gdi32' name 'FixBrushOrgEx'; +function UnrealizeObject(_para1:HGDIOBJ):WINBOOL; external 'gdi32' name 'UnrealizeObject'; +function GdiFlush:WINBOOL; external 'gdi32' name 'GdiFlush'; +function GdiSetBatchLimit(_para1:DWORD):DWORD; external 'gdi32' name 'GdiSetBatchLimit'; +function GdiGetBatchLimit:DWORD; external 'gdi32' name 'GdiGetBatchLimit'; +function SetICMMode(_para1:HDC; _para2:longint):longint; external 'gdi32' name 'SetICMMode'; +function CheckColorsInGamut(_para1:HDC; _para2:LPVOID; _para3:LPVOID; _para4:DWORD):WINBOOL; external 'gdi32' name 'CheckColorsInGamut'; +function GetColorSpace(_para1:HDC):HANDLE; external 'gdi32' name 'GetColorSpace'; +function SetColorSpace(_para1:HDC; _para2:HCOLORSPACE):WINBOOL; external 'gdi32' name 'SetColorSpace'; +function DeleteColorSpace(_para1:HCOLORSPACE):WINBOOL; external 'gdi32' name 'DeleteColorSpace'; +function GetDeviceGammaRamp(_para1:HDC; _para2:LPVOID):WINBOOL; external 'gdi32' name 'GetDeviceGammaRamp'; +function SetDeviceGammaRamp(_para1:HDC; _para2:LPVOID):WINBOOL; external 'gdi32' name 'SetDeviceGammaRamp'; +function ColorMatchToTarget(_para1:HDC; _para2:HDC; _para3:DWORD):WINBOOL; external 'gdi32' name 'ColorMatchToTarget'; +function CreatePropertySheetPageA(lppsp:LPCPROPSHEETPAGE):HPROPSHEETPAGE; external 'comctl32' name 'CreatePropertySheetPageA'; +function DestroyPropertySheetPage(hPSPage:HPROPSHEETPAGE):WINBOOL; external 'comctl32' name 'DestroyPropertySheetPage'; +procedure InitCommonControls; external 'comctl32' name 'InitCommonControls'; +function ImageList_AddIcon(himl:HIMAGELIST; hicon:HICON):longint; +function ImageList_Create(cx:longint; cy:longint; flags:UINT; cInitial:longint; cGrow:longint):HIMAGELIST; external 'comctl32' name 'ImageList_Create'; +function ImageList_Destroy(himl:HIMAGELIST):WINBOOL; external 'comctl32' name 'ImageList_Destroy'; +function ImageList_GetImageCount(himl:HIMAGELIST):longint; external 'comctl32' name 'ImageList_GetImageCount'; +function ImageList_Add(himl:HIMAGELIST; hbmImage:HBITMAP; hbmMask:HBITMAP):longint; external 'comctl32' name 'ImageList_Add'; +function ImageList_ReplaceIcon(himl:HIMAGELIST; i:longint; hicon:HICON):longint; external 'comctl32' name 'ImageList_ReplaceIcon'; +function ImageList_SetBkColor(himl:HIMAGELIST; clrBk:COLORREF):COLORREF; external 'comctl32' name 'ImageList_SetBkColor'; +function ImageList_GetBkColor(himl:HIMAGELIST):COLORREF; external 'comctl32' name 'ImageList_GetBkColor'; +function ImageList_SetOverlayImage(himl:HIMAGELIST; iImage:longint; iOverlay:longint):WINBOOL; external 'comctl32' name 'ImageList_SetOverlayImage'; +function ImageList_Draw(himl:HIMAGELIST; i:longint; hdcDst:HDC; x:longint; y:longint;fStyle:UINT):WINBOOL; external 'comctl32' name 'ImageList_Draw'; +function ImageList_Replace(himl:HIMAGELIST; i:longint; hbmImage:HBITMAP; hbmMask:HBITMAP):WINBOOL; external 'comctl32' name 'ImageList_Replace'; +function ImageList_AddMasked(himl:HIMAGELIST; hbmImage:HBITMAP; crMask:COLORREF):longint; external 'comctl32' name 'ImageList_AddMasked'; +function ImageList_DrawEx(himl:HIMAGELIST; i:longint; hdcDst:HDC; x:longint; y:longint;dx:longint; dy:longint; rgbBk:COLORREF; rgbFg:COLORREF; fStyle:UINT):WINBOOL; external 'comctl32' name 'ImageList_DrawEx'; +function ImageList_Remove(himl:HIMAGELIST; i:longint):WINBOOL; external 'comctl32' name 'ImageList_Remove'; +function ImageList_GetIcon(himl:HIMAGELIST; i:longint; flags:UINT):HICON; external 'comctl32' name 'ImageList_GetIcon'; +function ImageList_BeginDrag(himlTrack:HIMAGELIST; iTrack:longint; dxHotspot:longint; dyHotspot:longint):WINBOOL; external 'comctl32' name 'ImageList_BeginDrag'; +procedure ImageList_EndDrag; external 'comctl32' name 'ImageList_EndDrag'; +function ImageList_DragEnter(hwndLock:HWND; x:longint; y:longint):WINBOOL; external 'comctl32' name 'ImageList_DragEnter'; +function ImageList_DragLeave(hwndLock:HWND):WINBOOL; external 'comctl32' name 'ImageList_DragLeave'; +function ImageList_DragMove(x:longint; y:longint):WINBOOL; external 'comctl32' name 'ImageList_DragMove'; +function ImageList_SetDragCursorImage(himlDrag:HIMAGELIST; iDrag:longint; dxHotspot:longint; dyHotspot:longint):WINBOOL; external 'comctl32' name 'ImageList_SetDragCursorImage'; +function ImageList_DragShowNolock(fShow:WINBOOL):WINBOOL; external 'comctl32' name 'ImageList_DragShowNolock'; +function ImageList_GetDragImage(ppt:LPPOINT; pptHotspot:LPPOINT):HIMAGELIST; external 'comctl32' name 'ImageList_GetDragImage'; +function ImageList_GetIconSize(himl:HIMAGELIST; var cx:longint; var cy:longint):WINBOOL; external 'comctl32' name 'ImageList_GetIconSize'; +function ImageList_SetIconSize(himl:HIMAGELIST; cx:longint; cy:longint):WINBOOL; external 'comctl32' name 'ImageList_SetIconSize'; +function ImageList_GetImageInfo(himl:HIMAGELIST; i:longint; var pImageInfo:IMAGEINFO):WINBOOL; external 'comctl32' name 'ImageList_GetImageInfo'; +function ImageList_Merge(himl1:HIMAGELIST; i1:longint; himl2:HIMAGELIST; i2:longint; dx:longint;dy:longint):HIMAGELIST; external 'comctl32' name 'ImageList_Merge'; +function ImageList_SetImageCount(himl: HIMAGELIST; uNewCount: UINT): Integer; external 'comctl32.dll' name 'ImageList_SetImageCount'; + +function CreateToolbarEx(hwnd:HWND; ws:DWORD; wID:UINT; nBitmaps:longint; hBMInst:HINST;wBMID:UINT; lpButtons:LPCTBBUTTON; iNumButtons:longint; dxButton:longint; dyButton:longint;dxBitmap:longint; + dyBitmap:longint; uStructSize:UINT):HWND; external 'comctl32' name 'CreateToolbarEx'; +function CreateMappedBitmap(hInstance:HINST; idBitmap:longint; wFlags:UINT; lpColorMap:LPCOLORMAP; iNumMaps:longint):HBITMAP; external 'comctl32' name 'CreateMappedBitmap'; +procedure MenuHelp(uMsg:UINT; wParam:WPARAM; lParam:LPARAM; hMainMenu:HMENU; hInst:HINST;hwndStatus:HWND; var lpwIDs:UINT); external 'comctl32' name 'MenuHelp'; +function ShowHideMenuCtl(hWnd:HWND; uFlags:UINT; lpInfo:LPINT):WINBOOL; external 'comctl32' name 'ShowHideMenuCtl'; +procedure GetEffectiveClientRect(hWnd:HWND; lprc:LPRECT; lpInfo:LPINT); external 'comctl32' name 'GetEffectiveClientRect'; +function MakeDragList(hLB:HWND):WINBOOL; external 'comctl32' name 'MakeDragList'; +procedure DrawInsert(handParent:HWND; hLB:HWND; nItem:longint); external 'comctl32' name 'DrawInsert'; +function LBItemFromPt(hLB:HWND; pt:POINT; bAutoScroll:WINBOOL):longint; { external 'comctl32' name 'LBItemFromPt';} +function CreateUpDownControl(dwStyle:DWORD; x:longint; y:longint; cx:longint; cy:longint;hParent:HWND; nID:longint; hInst:HINST; hBuddy:HWND; nUpper:longint;nLower:longint; nPos:longint):HWND; external 'comctl32' name 'CreateUpDownControl'; +function RegCloseKey(hKey:HKEY):LONG; external 'advapi32' name 'RegCloseKey'; +function RegSetKeySecurity(hKey:HKEY; SecurityInformation:SECURITY_INFORMATION; pSecurityDescriptor:PSECURITY_DESCRIPTOR):LONG; external 'advapi32' name 'RegSetKeySecurity'; +function RegFlushKey(hKey:HKEY):LONG; external 'advapi32' name 'RegFlushKey'; +function RegGetKeySecurity(hKey:HKEY; SecurityInformation:SECURITY_INFORMATION; pSecurityDescriptor:PSECURITY_DESCRIPTOR; lpcbSecurityDescriptor:LPDWORD):LONG; external 'advapi32' name 'RegGetKeySecurity'; +function RegNotifyChangeKeyValue(hKey:HKEY; bWatchSubtree:WINBOOL; dwNotifyFilter:DWORD; hEvent:HANDLE; fAsynchronus:WINBOOL):LONG; external 'advapi32' name 'RegNotifyChangeKeyValue'; +function IsValidCodePage(CodePage:UINT):WINBOOL; external 'kernel32' name 'IsValidCodePage'; +function GetACP:UINT; external 'kernel32' name 'GetACP'; +function GetOEMCP:UINT; external 'kernel32' name 'GetOEMCP'; +function GetCPInfo(_para1:UINT; _para2:LPCPINFO):WINBOOL; external 'kernel32' name 'GetCPInfo'; +function IsDBCSLeadByte(TestChar:BYTE):WINBOOL; external 'kernel32' name 'IsDBCSLeadByte'; +function IsDBCSLeadByteEx(CodePage:UINT; TestChar:BYTE):WINBOOL; external 'kernel32' name 'IsDBCSLeadByteEx'; +function MultiByteToWideChar(CodePage:UINT; dwFlags:DWORD; lpMultiByteStr:LPCSTR; cchMultiByte:longint; lpWideCharStr:LPWSTR;cchWideChar:longint):longint; external 'kernel32' name 'MultiByteToWideChar'; +function WideCharToMultiByte(CodePage:UINT; dwFlags:DWORD; lpWideCharStr:LPCWSTR; cchWideChar:longint; lpMultiByteStr:LPSTR;cchMultiByte:longint; lpDefaultChar:LPCSTR; lpUsedDefaultChar:LPBOOL):longint; external 'kernel32' name 'WideCharToMultiByte'; +function IsValidLocale(Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'IsValidLocale'; +function ConvertDefaultLocale(Locale:LCID):LCID; external 'kernel32' name 'ConvertDefaultLocale'; +function GetThreadLocale:LCID; external 'kernel32' name 'GetThreadLocale'; +function SetThreadLocale(Locale:LCID):WINBOOL; external 'kernel32' name 'SetThreadLocale'; +function GetSystemDefaultLangID:LANGID; external 'kernel32' name 'GetSystemDefaultLangID'; +function GetUserDefaultLangID:LANGID; external 'kernel32' name 'GetUserDefaultLangID'; +function GetSystemDefaultLCID:LCID; external 'kernel32' name 'GetSystemDefaultLCID'; +function GetUserDefaultLCID:LCID; external 'kernel32' name 'GetUserDefaultLCID'; +function ReadConsoleOutputAttribute(hConsoleOutput:HANDLE; lpAttribute:LPWORD; nLength:DWORD; dwReadCoord:COORD; lpNumberOfAttrsRead:LPDWORD):WINBOOL; external 'kernel32' name 'ReadConsoleOutputAttribute'; +function WriteConsoleOutputAttribute(hConsoleOutput:HANDLE; var lpAttribute:WORD; nLength:DWORD; dwWriteCoord:COORD; lpNumberOfAttrsWritten:LPDWORD):WINBOOL; external 'kernel32' name 'WriteConsoleOutputAttribute'; +function FillConsoleOutputAttribute(hConsoleOutput:HANDLE; wAttribute:WORD; nLength:DWORD; dwWriteCoord:COORD; lpNumberOfAttrsWritten:LPDWORD):WINBOOL; external 'kernel32' name 'FillConsoleOutputAttribute'; +function GetConsoleMode(hConsoleHandle:HANDLE; lpMode:LPDWORD):WINBOOL; external 'kernel32' name 'GetConsoleMode'; +function GetNumberOfConsoleInputEvents(hConsoleInput:HANDLE; lpNumberOfEvents:PDWORD):WINBOOL; external 'kernel32' name 'GetNumberOfConsoleInputEvents'; +function GetConsoleScreenBufferInfo(hConsoleOutput:HANDLE; lpConsoleScreenBufferInfo:PCONSOLE_SCREEN_BUFFER_INFO):WINBOOL; external 'kernel32' name 'GetConsoleScreenBufferInfo'; +//function GetLargestConsoleWindowSize(hConsoleOutput:HANDLE):COORD; external 'kernel32' name 'GetLargestConsoleWindowSize'; +function GetLargestConsoleWindowSize(hConsoleOutput:HANDLE):COORD; +function GetConsoleCursorInfo(hConsoleOutput:HANDLE; lpConsoleCursorInfo:PCONSOLE_CURSOR_INFO):WINBOOL; external 'kernel32' name 'GetConsoleCursorInfo'; +function GetNumberOfConsoleMouseButtons(lpNumberOfMouseButtons:LPDWORD):WINBOOL; external 'kernel32' name 'GetNumberOfConsoleMouseButtons'; +function SetConsoleMode(hConsoleHandle:HANDLE; dwMode:DWORD):WINBOOL; external 'kernel32' name 'SetConsoleMode'; +function SetConsoleActiveScreenBuffer(hConsoleOutput:HANDLE):WINBOOL; external 'kernel32' name 'SetConsoleActiveScreenBuffer'; +function FlushConsoleInputBuffer(hConsoleInput:HANDLE):WINBOOL; external 'kernel32' name 'FlushConsoleInputBuffer'; +function SetConsoleScreenBufferSize(hConsoleOutput:HANDLE; dwSize:COORD):WINBOOL; external 'kernel32' name 'SetConsoleScreenBufferSize'; +function SetConsoleCursorPosition(hConsoleOutput:HANDLE; dwCursorPosition:COORD):WINBOOL; external 'kernel32' name 'SetConsoleCursorPosition'; +function SetConsoleCursorInfo(hConsoleOutput:HANDLE; lpConsoleCursorInfo:PCONSOLE_CURSOR_INFO):WINBOOL; external 'kernel32' name 'SetConsoleCursorInfo'; +function SetConsoleWindowInfo(hConsoleOutput:HANDLE; bAbsolute:WINBOOL; var lpConsoleWindow:SMALL_RECT):WINBOOL; external 'kernel32' name 'SetConsoleWindowInfo'; +function SetConsoleTextAttribute(hConsoleOutput:HANDLE; wAttributes:WORD):WINBOOL; external 'kernel32' name 'SetConsoleTextAttribute'; +function SetConsoleCtrlHandler(HandlerRoutine:PHANDLER_ROUTINE; Add:WINBOOL):WINBOOL; external 'kernel32' name 'SetConsoleCtrlHandler'; +function GenerateConsoleCtrlEvent(dwCtrlEvent:DWORD; dwProcessGroupId:DWORD):WINBOOL; external 'kernel32' name 'GenerateConsoleCtrlEvent'; +function AllocConsole:WINBOOL; external 'kernel32' name 'AllocConsole'; +function FreeConsole:WINBOOL; external 'kernel32' name 'FreeConsole'; +function CreateConsoleScreenBuffer(dwDesiredAccess:DWORD; dwShareMode:DWORD; var lpSecurityAttributes:SECURITY_ATTRIBUTES; dwFlags:DWORD; lpScreenBufferData:LPVOID):HANDLE; external 'kernel32' name 'CreateConsoleScreenBuffer'; +function GetConsoleCP:UINT; external 'kernel32' name 'GetConsoleCP'; +function SetConsoleCP(wCodePageID:UINT):WINBOOL; external 'kernel32' name 'SetConsoleCP'; +function GetConsoleOutputCP:UINT; external 'kernel32' name 'GetConsoleOutputCP'; +function SetConsoleOutputCP(wCodePageID:UINT):WINBOOL; external 'kernel32' name 'SetConsoleOutputCP'; +function WNetConnectionDialog(hwnd:HWND; dwType:DWORD):DWORD; external 'mpr' name 'WNetConnectionDialog'; +function WNetDisconnectDialog(hwnd:HWND; dwType:DWORD):DWORD; external 'mpr' name 'WNetDisconnectDialog'; +function WNetCloseEnum(hEnum:HANDLE):DWORD; external 'mpr' name 'WNetCloseEnum'; +function CloseServiceHandle(hSCObject:SC_HANDLE):WINBOOL; external 'advapi32' name 'CloseServiceHandle'; +function ControlService(hService:SC_HANDLE; dwControl:DWORD; lpServiceStatus:LPSERVICE_STATUS):WINBOOL; external 'advapi32' name 'ControlService'; +function DeleteService(hService:SC_HANDLE):WINBOOL; external 'advapi32' name 'DeleteService'; +function LockServiceDatabase(hSCManager:SC_HANDLE):SC_LOCK; external 'advapi32' name 'LockServiceDatabase'; +function NotifyBootConfigStatus(BootAcceptable:WINBOOL):WINBOOL; external 'advapi32' name 'NotifyBootConfigStatus'; +function QueryServiceObjectSecurity(hService:SC_HANDLE; dwSecurityInformation:SECURITY_INFORMATION; lpSecurityDescriptor:PSECURITY_DESCRIPTOR; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL;external 'advapi32' name 'QueryServiceObjectSecurity'; +function QueryServiceStatus(hService:SC_HANDLE; lpServiceStatus:LPSERVICE_STATUS):WINBOOL; external 'advapi32' name 'QueryServiceStatus'; +function SetServiceObjectSecurity(hService:SC_HANDLE; dwSecurityInformation:SECURITY_INFORMATION; lpSecurityDescriptor:PSECURITY_DESCRIPTOR):WINBOOL;external 'advapi32' name 'SetServiceObjectSecurity'; +function SetServiceStatus(hServiceStatus:SERVICE_STATUS_HANDLE; lpServiceStatus:LPSERVICE_STATUS):WINBOOL; external 'advapi32' name 'SetServiceStatus'; +function UnlockServiceDatabase(ScLock:SC_LOCK):WINBOOL; external 'advapi32' name 'UnlockServiceDatabase'; +function ChoosePixelFormat(_para1:HDC; _para2:PPIXELFORMATDESCRIPTOR):longint; external 'gdi32' name 'ChoosePixelFormat'; +function DescribePixelFormat(_para1:HDC; _para2:longint; _para3:UINT; _para4:LPPIXELFORMATDESCRIPTOR):longint; external 'gdi32' name 'DescribePixelFormat'; +{$ifdef Unknown_functions}{ WARNING: function is not in my gdi32.dll !! PM}function GetEnhMetaFilePixelFormat(_para1:HENHMETAFILE; _para2:DWORD; var _para3:PIXELFORMATDESCRIPTOR):UINT; external 'gdi32' name 'GetEnhMetaFilePixelFormat'; +{$endif Unknown_functions}{ function GetPixelFormat(_para1:HDC):longint; external 'gdi32' name 'GetPixelFormat'; } +function SetPixelFormat(_para1:HDC; _para2:longint;_para3:PPIXELFORMATDESCRIPTOR):WINBOOL; external 'gdi32' name 'SetPixelFormat'; +function SwapBuffers(_para1:HDC):WINBOOL; external 'gdi32' name 'SwapBuffers'; +function DragQueryPoint(_para1:HDROP; _para2:LPPOINT):WINBOOL; external 'shell32' name 'DragQueryPoint'; +procedure DragFinish(_para1:HDROP); external 'shell32' name 'DragFinish'; +procedure DragAcceptFiles(_para1:HWND; _para2:WINBOOL); external 'shell32' name 'DragAcceptFiles'; +function DuplicateIcon(_para1:HINST; _para2:HICON):HICON; external 'shell32' name 'DuplicateIcon'; +function DdeAbandonTransaction(_para1:DWORD; _para2:HCONV; _para3:DWORD):BOOL;external 'user32' name 'DdeAbandonTransaction'; +function DdeAccessData(_para1:HDDEDATA; _para2:PDWORD):PBYTE;external 'user32' name 'DdeAccessData'; +function DdeAddData(_para1:HDDEDATA; _para2:PBYTE; _para3:DWORD; _para4:DWORD):HDDEDATA;external 'user32' name 'DdeAddData'; +{ This is only a prototype PM +function DdeCallback(_para1, _para2:UINT; _para3:HCONV; _para4, _para5:HSZ;_para6: HDDEDATA; _para7, _para8:PDWORD):HDDEDATA;external 'user32' name 'DdeCallback';} +function DdeClientTransaction(_para1:PBYTE; _para2:DWORD; _para3:HCONV; _para4:HSZ; _para5:UINT; + _para6:UINT; _para7:DWORD; _para8:PDWORD):HDDEDATA;external 'user32' name 'DdeClientTransaction'; +function DdeCmpStringHandles(_para1:HSZ; _para2:HSZ):longint; external 'user32' name 'DdeCmpStringHandles'; +function DdeConnect(_para1:DWORD; _para2:HSZ; _para3:HSZ; var _para4:CONVCONTEXT):HCONV; external 'user32' name 'DdeConnect'; +function DdeConnectList(_para1:DWORD; _para2:HSZ; _para3:HSZ; _para4:HCONVLIST; _para5:PCONVCONTEXT):HCONVLIST;external 'user32' name 'DdeConnectList'; +function DdeCreateDataHandle(_para1:DWORD; _para2:LPBYTE; _para3:DWORD; _para4:DWORD; _para5:HSZ;_para6:UINT; _para7:UINT):HDDEDATA; external 'user32' name 'DdeCreateDataHandle'; +function DdeDisconnect(_para1:HCONV):WINBOOL; external 'user32' name 'DdeDisconnect'; +function DdeDisconnectList(_para1:HCONVLIST):BOOL;external 'user32' name 'DdeDisconnectList'; +function DdeEnableCallback(_para1:DWORD; _para2:HCONV; _para3:UINT):BOOL;external 'user32' name 'DdeEnableCallback'; +function DdeFreeDataHandle(_para1:HDDEDATA):WINBOOL; external 'user32' name 'DdeFreeDataHandle'; +function DdeFreeStringHandle(_para1:DWORD;_para2:HSZ):WINBOOL; external 'user32' name 'DdeFreeStringHandle'; +function DdeGetData(_para1:HDDEDATA;_para2:LPBYTE; _para3:DWORD; _para4:DWORD):DWORD; external 'user32' name 'DdeGetData'; +function DdeGetLastError(_para1:DWORD):UINT; external 'user32' name 'DdeGetLastError'; +function DdeImpersonateClient(_para1:HCONV):BOOL;external 'user32' name 'DdeImpersonateClient'; +function DdeKeepStringHandle(_para1:DWORD; _para2:HSZ):BOOL;external 'user32' name 'DdeKeepStringHandle'; +function DdeNameService(_para1:DWORD; _para2:HSZ; _para3:HSZ; _para4:UINT):HDDEDATA; external 'user32' name 'DdeNameService'; +function DdePostAdvise(_para1:DWORD; _para2:HSZ; _para3:HSZ):WINBOOL; external 'user32' name 'DdePostAdvise'; +function DdeQueryConvInfo(_para1:HCONV; _para2:DWORD; _para3:PCONVINFO):UINT;external 'user32' name 'DdeQueryConvInfo'; +function DdeQueryNextServer(_para1:HCONVLIST; _para2:HCONV):HCONV;external 'user32' name 'DdeQueryNextServer'; +function DdeReconnect(_para1:HCONV):HCONV; external 'user32' name 'DdeReconnect'; +function DdeSetUserHandle(_para1:HCONV; _para2:DWORD; _para3:DWORD):BOOL;external 'user32' name 'DdeSetUserHandle'; +function DdeUnaccessData(_para1:HDDEDATA):BOOL;external 'user32' name 'DdeUnaccessData'; +function DdeUninitialize(_para1:DWORD):WINBOOL; external 'user32' name 'DdeUninitialize'; +{$ifdef Unknown_functions} +function NetUserEnum(_para1:LPWSTR; _para2:DWORD; _para3:DWORD; var _para4:LPBYTE; _para5:DWORD;_para6:LPDWORD; _para7:LPDWORD; _para8:LPDWORD):DWORD; external 'netapi32' name 'NetUserEnum'; +function NetApiBufferFree(_para1:LPVOID):DWORD; external 'netapi32' name 'NetApiBufferFree'; +function NetUserGetInfo(_para1:LPWSTR; _para2:LPWSTR; _para3:DWORD; _para4:LPBYTE):DWORD; external 'netapi32' name 'NetUserGetInfo'; +function NetGetDCName(_para1:LPWSTR; _para2:LPWSTR; var _para3:LPBYTE):DWORD; external 'netapi32' name 'NetGetDCName'; +function NetGroupEnum(_para1:LPWSTR; _para2:DWORD; var _para3:LPBYTE; _para4:DWORD; _para5:LPDWORD;_para6:LPDWORD; _para7:LPDWORD):DWORD; external 'netapi32' name 'NetGroupEnum'; +function NetLocalGroupEnum(_para1:LPWSTR; _para2:DWORD; var _para3:LPBYTE; _para4:DWORD; _para5:LPDWORD;_para6:LPDWORD; _para7:LPDWORD):DWORD; external 'netapi32' name 'NetLocalGroupEnum'; +{$endif Unknown_functions} +procedure SHAddToRecentDocs(_para1:UINT; _para2:LPCVOID); external 'shell32' name 'SHAddToRecentDocs'; +function SHBrowseForFolder(_para1:LPBROWSEINFO):LPITEMIDLIST; external 'shell32' name 'SHBrowseForFolder'; +procedure SHChangeNotify(_para1:LONG; _para2:UINT; _para3:LPCVOID; _para4:LPCVOID); external 'shell32' name 'SHChangeNotify'; +function SHFileOperation(_para1:LPSHFILEOPSTRUCT):longint; external 'shell32' name 'SHFileOperation'; +procedure SHFreeNameMappings(_para1:HANDLE); external 'shell32' name 'SHFreeNameMappings'; +function SHGetFileInfo(_para1:LPCTSTR; _para2:DWORD; var _para3:SHFILEINFO; _para4:UINT; _para5:UINT):DWORD; external 'shell32' name 'SHGetFileInfo'; +function SHGetPathFromIDList(_para1:LPCITEMIDLIST; _para2:LPTSTR):WINBOOL; external 'shell32' name 'SHGetPathFromIDList'; +function SHGetSpecialFolderLocation(_para1:HWND; _para2:longint; var _para3:LPITEMIDLIST):HRESULT; external 'shell32' name 'SHGetSpecialFolderLocation'; + +{ was missing, bug report 1808 PM } +function CommDlgExtendedError : DWORD; external 'comdlg32' name 'CommDlgExtendedError'; + +{ wgl Windows OpenGL helper functions } +function wglUseFontBitmaps(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:DWORD):WINBOOL; external 'opengl32' name 'wglUseFontBitmapsA'; +function wglCreateContext(_para1:HDC):HGLRC; external 'opengl32' name 'wglCreateContext'; +function wglCreateLayerContext(_para1:HDC; _para2:longint):HGLRC; external 'opengl32' name 'wglCreateLayerContext'; +function wglCopyContext(_para1:HGLRC; _para2:HGLRC; _para3:UINT):WINBOOL; external 'opengl32' name 'wglCopyContext'; +function wglDeleteContext(_para1:HGLRC):WINBOOL; external 'opengl32' name 'wglDeleteContext'; +function wglGetCurrentContext:HGLRC; external 'opengl32' name 'wglGetCurrentContext'; +function wglGetCurrentDC:HDC; external 'opengl32' name 'wglGetCurrentDC'; +function wglMakeCurrent(_para1:HDC; _para2:HGLRC):WINBOOL; external 'opengl32' name 'wglMakeCurrent'; +function wglShareLists(_para1:HGLRC; _para2:HGLRC):WINBOOL; external 'opengl32' name 'wglShareLists'; +function wglUseFontBitmapsW(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:DWORD):WINBOOL; external 'opengl32' name 'wglUseFontBitmapsW'; +{ Delphi doesn't declare these, but we do: } +function wglUseFontOutlines(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:DWORD; _para5:Single; + _para6:Single; _para7:longint; _para8:LPGLYPHMETRICSFLOAT):WINBOOL; external 'opengl32' name 'wglUseFontOutlinesA'; +function wglUseFontBitmapsA(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:DWORD):WINBOOL; external 'opengl32' name 'wglUseFontBitmapsA'; +function wglUseFontOutlinesA(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:DWORD; _para5:Single; + _para6:Single; _para7:longint; _para8:LPGLYPHMETRICSFLOAT):WINBOOL; external 'opengl32' name 'wglUseFontOutlinesA'; +function wglDescribeLayerPlane(_para1:HDC; _para2:longint; _para3:longint; _para4:UINT; _para5:LPLAYERPLANEDESCRIPTOR):WINBOOL; external 'opengl32' name 'wglDescribeLayerPlane'; +function wglGetLayerPaletteEntries(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; var _para5:COLORREF):longint; external 'opengl32' name 'wglGetLayerPaletteEntries'; +function wglGetProcAddress(_para1:LPCSTR):PROC; external 'opengl32' name 'wglGetProcAddress'; +function wglRealizeLayerPalette(_para1:HDC; _para2:longint; _para3:WINBOOL):WINBOOL; external 'opengl32' name 'wglRealizeLayerPalette'; +function wglSetLayerPaletteEntries(_para1:HDC; _para2:longint; _para3:longint; _para4:longint; var _para5:COLORREF):longint; external 'opengl32' name 'wglSetLayerPaletteEntries'; +function wglSwapLayerBuffers(_para1:HDC; _para2:UINT):WINBOOL; external 'opengl32' name 'wglSwapLayerBuffers'; +function wglUseFontOutlinesW(_para1:HDC; _para2:DWORD; _para3:DWORD; _para4:DWORD; _para5:Single; + _para6:Single; _para7:longint; _para8:LPGLYPHMETRICSFLOAT):WINBOOL; external 'opengl32' name 'wglUseFontOutlinesW'; + +{ translated macros } +function Animate_Create(hWndP:HWND; id:HMENU;dwStyle:DWORD;hInstance:HINST):HWND; +function Animate_Open(hwnd : HWND;szName : LPTSTR) : LRESULT; +function Animate_Play(hwnd : HWND;from,_to : longint;rep : UINT) : LRESULT; +function Animate_Stop(hwnd : HWND) : LRESULT; +function Animate_Close(hwnd : HWND) : LRESULT; +function Animate_Seek(hwnd : HWND;frame : longint) : LRESULT; +function PropSheet_AddPage(hPropSheetDlg : HWND;hpage : HPROPSHEETPAGE) : LRESULT; +function PropSheet_Apply(hPropSheetDlg : HWND) : LRESULT; +function PropSheet_CancelToClose(hPropSheetDlg : HWND) : LRESULT; +function PropSheet_Changed(hPropSheetDlg,hwndPage : HWND) : LRESULT; +function PropSheet_GetCurrentPageHwnd(hDlg : HWND) : LRESULT; +function PropSheet_GetTabControl(hPropSheetDlg : HWND) : LRESULT; +function PropSheet_IsDialogMessage(hDlg : HWND;pMsg : longint) : LRESULT; +function PropSheet_PressButton(hPropSheetDlg : HWND;iButton : longint) : LRESULT; +function PropSheet_QuerySiblings(hPropSheetDlg : HWND;param1,param2 : longint) : LRESULT; +function PropSheet_RebootSystem(hPropSheetDlg : HWND) : LRESULT; +function PropSheet_RemovePage(hPropSheetDlg : HWND;hpage : HPROPSHEETPAGE; index : longint) : LRESULT; +function PropSheet_RestartWindows(hPropSheetDlg : HWND) : LRESULT; +function PropSheet_SetCurSel(hPropSheetDlg : HWND;hpage : HPROPSHEETPAGE; index : longint) : LRESULT; +function PropSheet_SetCurSelByID(hPropSheetDlg : HWND; id : longint) : LRESULT; +function PropSheet_SetFinishText(hPropSheetDlg:HWND;lpszText : LPTSTR) : LRESULT; +function PropSheet_SetTitle(hPropSheetDlg:HWND;dwStyle:DWORD;lpszText : LPCTSTR) : LRESULT; +function PropSheet_SetWizButtons(hPropSheetDlg:HWND;dwFlags : DWORD) : LRESULT; +function PropSheet_UnChanged(hPropSheetDlg:HWND;hwndPage : HWND) : LRESULT; +function Header_DeleteItem(hwndHD:HWND;index : longint) : WINBOOL; +function Header_GetItem(hwndHD:HWND;index:longint;var hdi : HD_ITEM) : WINBOOL; +function Header_GetItemCount(hwndHD : HWND) : longint; +function Header_InsertItem(hwndHD:HWND;index : longint;var hdi : HD_ITEM) : longint; +function Header_Layout(hwndHD:HWND;var layout : HD_LAYOUT) : WINBOOL; +function Header_SetItem(hwndHD:HWND;index : longint;var hdi : HD_ITEM) : WINBOOL; +function ListView_Arrange(hwndLV:HWND;code : UINT) : LRESULT; +function ListView_CreateDragImage(hwnd:HWND;i : longint;lpptUpLeft : LPPOINT) : LRESULT; +function ListView_DeleteAllItems(hwnd : HWND) : LRESULT; +function ListView_DeleteColumn(hwnd:HWND;iCol : longint) : LRESULT; +function ListView_DeleteItem(hwnd:HWND;iItem : longint) : LRESULT; +function ListView_EditLabel(hwndLV:HWND;i : longint) : LRESULT; +function ListView_EnsureVisible(hwndLV:HWND;i,fPartialOK : longint) : LRESULT; +function ListView_FindItem(hwnd:HWND;iStart : longint;var lvfi : LV_FINDINFO) : longint; +function ListView_GetBkColor(hwnd : HWND) : LRESULT; +function ListView_GetCallbackMask(hwnd : HWND) : LRESULT; +function ListView_GetColumn(hwnd:HWND;iCol : longint;var col : LV_COLUMN) : LRESULT; +function ListView_GetColumnWidth(hwnd:HWND;iCol : longint) : LRESULT; +function ListView_GetCountPerPage(hwndLV : HWND) : LRESULT; +function ListView_GetEditControl(hwndLV : HWND) : LRESULT; +function ListView_GetImageList(hwnd:HWND;iImageList : wINT) : LRESULT; +function ListView_GetISearchString(hwndLV:HWND;lpsz : LPTSTR) : LRESULT; +function ListView_GetItem(hwnd:HWND;var item : LV_ITEM) : LRESULT; +function ListView_GetItemCount(hwnd : HWND) : LRESULT; +function ListView_GetItemPosition(hwndLV:HWND;i : longint;var pt : POINT) : longint; +function ListView_GetItemSpacing(hwndLV:HWND;fSmall : longint) : LRESULT; +function ListView_GetItemState(hwndLV:HWND;i,mask : longint) : LRESULT; +function ListView_GetNextItem(hwnd:HWND; iStart, flags : longint) : LRESULT; +function ListView_GetOrigin(hwndLV:HWND;var pt : POINT) : LRESULT; +function ListView_GetSelectedCount(hwndLV : HWND) : LRESULT; +function ListView_GetStringWidth(hwndLV:HWND;psz : LPCTSTR) : LRESULT; +function ListView_GetTextBkColor(hwnd : HWND) : LRESULT; +function ListView_GetTextColor(hwnd : HWND) : LRESULT; +function ListView_GetTopIndex(hwndLV : HWND) : LRESULT; +function ListView_GetViewRect(hwnd:HWND;var rc : RECT) : LRESULT; +function ListView_HitTest(hwndLV:HWND;var info : LV_HITTESTINFO) : LRESULT; +function ListView_InsertColumn(hwnd:HWND;iCol : longint;var col : LV_COLUMN) : LRESULT; +function ListView_InsertItem(hwnd:HWND;var item : LV_ITEM) : LRESULT; +function ListView_RedrawItems(hwndLV:HWND;iFirst,iLast : longint) : LRESULT; +function ListView_Scroll(hwndLV:HWND;dx,dy : longint) : LRESULT; +function ListView_SetBkColor(hwnd:HWND;clrBk : COLORREF) : LRESULT; +function ListView_SetCallbackMask(hwnd:HWND;mask : UINT) : LRESULT; +function ListView_SetColumn(hwnd:HWND;iCol : longint; var col : LV_COLUMN) : LRESULT; +function ListView_SetColumnWidth(hwnd:HWND;iCol,cx : longint) : LRESULT; +function ListView_SetImageList(hwnd:HWND;himl : longint;iImageList : HIMAGELIST) : LRESULT; +function ListView_SetItem(hwnd:HWND;var item : LV_ITEM) : LRESULT; +function ListView_SetItemCount(hwndLV:HWND;cItems : longint) : LRESULT; +function ListView_SetItemPosition(hwndLV:HWND;i,x,y : longint) : LRESULT; +function ListView_SetItemPosition32(hwndLV:HWND;i,x,y : longint) : LRESULT; +function ListView_SetItemState(hwndLV:HWND; i, data, mask:longint) : LRESULT; +function ListView_SetItemText(hwndLV:HWND; i, iSubItem_:longint;pszText_ : LPTSTR) : LRESULT; +function ListView_SetTextBkColor(hwnd:HWND;clrTextBk : COLORREF) : LRESULT; +function ListView_SetTextColor(hwnd:HWND;clrText : COLORREF) : LRESULT; +function ListView_SortItems(hwndLV:HWND;_pfnCompare:PFNLVCOMPARE;_lPrm : LPARAM) : LRESULT; +function ListView_Update(hwndLV:HWND;i : longint) : LRESULT; +function TreeView_InsertItem(hwnd:HWND;lpis : LPTV_INSERTSTRUCT) : LRESULT; +function TreeView_DeleteItem(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_DeleteAllItems(hwnd : HWND) : LRESULT; +function TreeView_Expand(hwnd:HWND;hitem:HTREEITEM;code : longint) : LRESULT; +function TreeView_GetCount(hwnd : HWND) : LRESULT; +function TreeView_GetIndent(hwnd : HWND) : LRESULT; +function TreeView_SetIndent(hwnd:HWND;indent : longint) : LRESULT; +function TreeView_GetImageList(hwnd:HWND;iImage : WPARAM) : LRESULT; +function TreeView_SetImageList(hwnd:HWND;himl:HIMAGELIST;iImage : WPARAM) : LRESULT; +function TreeView_GetNextItem(hwnd:HWND;hitem:HTREEITEM;code : longint) : LRESULT; +function TreeView_GetChild(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetNextSibling(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetPrevSibling(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetParent(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetFirstVisible(hwnd : HWND) : LRESULT; +function TreeView_GetNextVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetPrevVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetSelection(hwnd : HWND) : LRESULT; +function TreeView_GetDropHilight(hwnd : HWND) : LRESULT; +function TreeView_GetRoot(hwnd : HWND) : LRESULT; +function TreeView_Select(hwnd:HWND;hitem:HTREEITEM;code : longint) : LRESULT; +function TreeView_SelectItem(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_SelectDropTarget(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_SelectSetFirstVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetItem(hwnd:HWND;var item : TV_ITEM) : LRESULT; +function TreeView_SetItem(hwnd:HWND;var item : TV_ITEM) : LRESULT; +function TreeView_EditLabel(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_GetEditControl(hwnd : HWND) : LRESULT; +function TreeView_GetVisibleCount(hwnd : HWND) : LRESULT; +function TreeView_HitTest(hwnd:HWND;lpht : LPTV_HITTESTINFO) : LRESULT; +function TreeView_CreateDragImage(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_SortChildren(hwnd:HWND;hitem:HTREEITEM;recurse : longint) : LRESULT; +function TreeView_EnsureVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +function TreeView_SortChildrenCB(hwnd:HWND;psort:LPTV_SORTCB;recurse : longint) : LRESULT; +function TreeView_EndEditLabelNow(hwnd:HWND;fCancel : longint) : LRESULT; +function TreeView_GetISearchString(hwndTV:HWND;lpsz : LPTSTR) : LRESULT; +function TabCtrl_GetImageList(hwnd : HWND) : LRESULT; +function TabCtrl_SetImageList(hwnd:HWND;himl : HIMAGELIST) : LRESULT; +function TabCtrl_GetItemCount(hwnd : HWND) : LRESULT; +function TabCtrl_GetItem(hwnd:HWND;iItem : longint;var item : TC_ITEM) : LRESULT; +function TabCtrl_SetItem(hwnd:HWND;iItem : longint;var item : TC_ITEM) : LRESULT; +function TabCtrl_InsertItem(hwnd:HWND;iItem : longint;var item : TC_ITEM) : LRESULT; +function TabCtrl_DeleteItem(hwnd:HWND;i : longint) : LRESULT; +function TabCtrl_DeleteAllItems(hwnd : HWND) : LRESULT; +function TabCtrl_GetItemRect(hwnd:HWND;i : longint;var rc : RECT) : LRESULT; +function TabCtrl_GetCurSel(hwnd : HWND) : LRESULT; +function TabCtrl_SetCurSel(hwnd:HWND;i : longint) : LRESULT; +function TabCtrl_HitTest(hwndTC:HWND;var info : TC_HITTESTINFO) : LRESULT; +function TabCtrl_SetItemExtra(hwndTC:HWND;cb : longint) : LRESULT; +function TabCtrl_AdjustRect(hwnd:HWND;bLarger:WINBOOL;var rc : RECT) : LRESULT; +function TabCtrl_SetItemSize(hwnd:HWND;x,y : longint) : LRESULT; +function TabCtrl_RemoveImage(hwnd:HWND;i : WPARAM) : LRESULT; +function TabCtrl_SetPadding(hwnd:HWND;cx,cy : longint) : LRESULT; +function TabCtrl_GetRowCount(hwnd : HWND) : LRESULT; +function TabCtrl_GetToolTips(hwnd : HWND) : LRESULT; +function TabCtrl_SetToolTips(hwnd:HWND;hwndTT : longint) : LRESULT; +function TabCtrl_GetCurFocus(hwnd : HWND) : LRESULT; +function TabCtrl_SetCurFocus(hwnd:HWND;i : longint) : LRESULT; +function SNDMSG(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; +function CommDlg_OpenSave_GetSpecA(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +function CommDlg_OpenSave_GetSpecW(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +{$ifndef Unicode} +function CommDlg_OpenSave_GetSpec(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +{$else Unicode} +function CommDlg_OpenSave_GetSpec(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +{$endif Unicode} +function CommDlg_OpenSave_GetFilePathA(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +function CommDlg_OpenSave_GetFilePathW(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +{$ifndef Unicode} +function CommDlg_OpenSave_GetFilePath(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +{$else Unicode} +function CommDlg_OpenSave_GetFilePath(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +{$endif Unicode} +function CommDlg_OpenSave_GetFolderPathA(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +function CommDlg_OpenSave_GetFolderPathW(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +{$ifndef Unicode} +function CommDlg_OpenSave_GetFolderPath(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +{$else Unicode} +function CommDlg_OpenSave_GetFolderPath(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +{$endif Unicode} +function CommDlg_OpenSave_GetFolderIDList(_hdlg:HWND;_pidl:LPVOID;_cbmax : longint) : LRESULT; +function CommDlg_OpenSave_SetControlText(_hdlg:HWND;_id : longint;_text : LPSTR) : LRESULT; +function CommDlg_OpenSave_HideControl(_hdlg:HWND;_id : longint) : LRESULT; +function CommDlg_OpenSave_SetDefExt(_hdlg:HWND;_pszext : LPSTR) : LRESULT; + +function GetNextWindow(hWnd:HWND; uCmd:UINT):HWND; external 'user32' name 'GetWindow'; + +function GlobalAllocPtr(flags,cb:DWord):Pointer; +function GlobalFreePtr(lp:Pointer):Pointer; +function GlobalUnlockPtr(lp:pointer):Pointer; +function GlobalLockPtr(lp:pointer):Pointer; +function GlobalReAllocPtr(lp:Pointer;cbNew,flags:DWord):Pointer; +function GlobalPtrHandle(lp:pointer):Pointer; +function SetLayeredWindowAttributes(HWND:hwnd;crKey :COLORREF;bAlpha : byte;dwFlags : DWORD):WINBOOL; external 'user32' name 'SetLayeredWindowAttributes'; +//end win32 or wince not checked + +{$endif WIN32} + + +{$endif read_interface} + + +{$ifdef read_implementation} + + +{ Win32 API calling convention + pushes POINT struct passed by value directly + on stack instead of just pushing an address + to overcome this we use a internal function + that just pushes the two arguments. + Bug report 1807. PM } + +//begin common win32 & wince + +//end common win32 & wince + +{$ifdef WINCE} +//begin wince only + +//end wince only +{$endif WINCE} + +{$ifdef WIN32} + +//begin win32 only +//end win32 only + +//begin win32 or wince not checked +function Internal_MenuItemFromPoint(hWnd:HWND; hMenu:HMENU; ptScreenX, ptScreenY : LONG):longint; external 'user32' name 'MenuItemFromPoint'; + +function MenuItemFromPoint(hWnd:HWND; hMenu:HMENU; ptScreen:POINT):longint; {external 'user32' name 'MenuItemFromPoint';} +begin + MenuItemFromPoint:=Internal_MenuItemFromPoint(hWnd, hMenu, ptScreen.X, ptScreen.Y); +end; + +function Internal_DragDetect(hwnd:HWND; ptX, ptY : LONG):WINBOOL; external 'user32' name 'DragDetect'; + +function DragDetect(hwnd:HWND; pt:POINT):WINBOOL; {external 'user32' name 'DragDetect';} +begin + DragDetect:=Internal_DragDetect(hWnd, pt.X, pt.Y); +end; + +function Internal_WindowFromPoint(PointX,PointY : LONG):HWND; external 'user32' name 'WindowFromPoint'; + +function WindowFromPoint(Point:POINT):HWND; +begin + WindowFromPoint:=Internal_WindowFromPoint(Point.X, Point.Y); +end; + +function Internal_ChildWindowFromPoint(hWndParent:HWND; PointX,PointY : LONG):HWND; external 'user32' name 'ChildWindowFromPoint'; + +function ChildWindowFromPoint(hWndParent:HWND; Point:POINT):HWND; +begin + ChildWindowFromPoint:=Internal_ChildWindowFromPoint(hWndParent, Point.X, Point.Y); +end; + +function Internal_PtInRect(var lprc:RECT; ptX,ptY : LONG):WINBOOL; external 'user32' name 'PtInRect'; + +function PtInRect(var lprc:RECT; pt:POINT):WINBOOL; +begin + PtInRect:=Internal_PtInRect(lprc,pt.X,pt.Y); +end; + +function PtInRect(lprc:LPRECT; pt:POINT):WINBOOL; +begin + PtInRect:=Internal_PtInRect(lprc^,pt.X,pt.Y); +end; + +function Internal_ChildWindowFromPointEx(_para1:HWND; _para2X,_Para2Y : LONG; _para3:UINT):HWND; external 'user32' name 'ChildWindowFromPointEx'; + +function ChildWindowFromPointEx(_para1:HWND; _para2:POINT; _para3:UINT):HWND; +begin + ChildWindowFromPointEx:=Internal_ChildWindowFromPointEx(_para1,_para2.X,_para2.Y,_para3); +end; + +function Internal_LBItemFromPt(hLB:HWND; ptX, ptY : LONG; bAutoScroll:WINBOOL):longint; external 'comctl32' name 'LBItemFromPt'; + +function LBItemFromPt(hLB:HWND; pt:POINT; bAutoScroll:WINBOOL):longint; { external 'comctl32' name 'LBItemFromPt';} +begin + LBItemFromPt:=Internal_LBItemFromPt(hLB, pt.X, pt.Y, bAutoScroll); +end; + +{ End of bug fixes for bug report 1807. PM } + +function GlobalDiscard(hglbMem:HGLOBAL):HGLOBAL; +begin + GlobalDiscard:=GlobalReAlloc(hglbMem,0,GMEM_MOVEABLE); +end; + + +function LocalDiscard(hlocMem:HLOCAL):HLOCAL; +begin + LocalDiscard := LocalReAlloc(hlocMem,0,LMEM_MOVEABLE); +end; + + +procedure MoveMemory(Destination:PVOID; Source:pointer; Length:DWORD); +begin + Move(Source^,Destination^,Length); +end; + + +procedure CopyMemory(Destination:PVOID; Source:pointer; Length:DWORD); +begin + Move(Source^, Destination^, Length); +end; + + +procedure FillMemory(Destination:PVOID; Length:DWORD; Fill:BYTE); +begin + FillChar(Destination^,Length,Char(Fill)); +end; + + +procedure ZeroMemory(Destination:PVOID; Length:DWORD); +begin + FillChar(Destination^,Length,#0); +end; + + +function GlobalAllocPtr(flags,cb:DWord):Pointer; +begin + GlobalAllocPtr:=GlobalLock(GlobalAlloc(flags,cb)); +end; + + +function GlobalFreePtr(lp:Pointer):Pointer; +begin + GlobalFreePtr:=Pointer(GlobalFree(HWND(GlobalUnlockPtr(lp)))); +end; + + +function GlobalUnlockPtr(lp:pointer):Pointer; +begin + GlobalUnlock(GlobalHandle(lp)); + GlobalUnlockPtr:=lp; +end; + + +function GlobalLockPtr(lp:pointer):Pointer; +begin + GlobalLockPtr:=GlobalLock(GlobalHandle(lp)); +end; + + +function GlobalReAllocPtr(lp:Pointer;cbNew,flags:DWord):Pointer; +begin + GlobalReAllocPtr:=GlobalLock(GlobalReAlloc(HWND(GlobalUnlockPtr(lp)),cbNew,flags)); +end; + + +function GlobalPtrHandle(lp:pointer):Pointer; +begin + GlobalPtrHandle:=Pointer(GlobalHandle(lp)); +end; + + +function ImageList_AddIcon(himl:HIMAGELIST; hicon:HICON):longint; +begin + ImageList_AddIcon:=ImageList_ReplaceIcon(himl,-(1),hicon); +end; + + +function Animate_Create(hWndP:HWND; id:HMENU;dwStyle:DWORD;hInstance:HINST):HWND; +begin + Animate_Create:=CreateWindow(LPCTSTR(ANIMATE_CLASS),nil,dwStyle,0,0,0,0,hwndP,id,hInstance,nil); +end; + + +function Animate_Open(hwnd : HWND;szName : LPTSTR) : LRESULT; +begin + Animate_Open:=SendMessage(hwnd,ACM_OPEN,0,LPARAM(szName)); +end; + + +function Animate_Play(hwnd : HWND;from,_to : longint;rep : UINT) : LRESULT; +begin + Animate_Play:=SendMessage(hwnd,ACM_PLAY,WPARAM(rep),LPARAM(MAKELONG(from,_to))); +end; + + +function Animate_Stop(hwnd : HWND) : LRESULT; +begin + Animate_Stop:=SendMessage(hwnd,ACM_STOP,0,0); +end; + + +function Animate_Close(hwnd : HWND) : LRESULT; +begin + Animate_Close:=Animate_Open(hwnd,nil); +end; + + +function Animate_Seek(hwnd : HWND;frame : longint) : LRESULT; +begin + Animate_Seek:=Animate_Play(hwnd,frame,frame,1); +end; + + +function PropSheet_AddPage(hPropSheetDlg : HWND;hpage : HPROPSHEETPAGE) : LRESULT; +begin + PropSheet_AddPage:=SendMessage(hPropSheetDlg,PSM_ADDPAGE,0,LPARAM(hpage)); +end; + + +function PropSheet_Apply(hPropSheetDlg : HWND) : LRESULT; +begin + PropSheet_Apply:=SendMessage(hPropSheetDlg,PSM_APPLY,0,0); +end; + + +function PropSheet_CancelToClose(hPropSheetDlg : HWND) : LRESULT; +begin + PropSheet_CancelToClose:=SendMessage(hPropSheetDlg,PSM_CANCELTOCLOSE,0,0); +end; + + +function PropSheet_Changed(hPropSheetDlg,hwndPage : HWND) : LRESULT; +begin + PropSheet_Changed:=SendMessage(hPropSheetDlg,PSM_CHANGED,WPARAM(hwndPage),0); +end; + + +function PropSheet_GetCurrentPageHwnd(hDlg : HWND) : LRESULT; +begin + PropSheet_GetCurrentPageHwnd:=SendMessage(hDlg,PSM_GETCURRENTPAGEHWND,0,0); +end; + + +function PropSheet_GetTabControl(hPropSheetDlg : HWND) : LRESULT; +begin + PropSheet_GetTabControl:=SendMessage(hPropSheetDlg,PSM_GETTABCONTROL,0,0); +end; + + +function PropSheet_IsDialogMessage(hDlg : HWND;pMsg : longint) : LRESULT; +begin + PropSheet_IsDialogMessage:=SendMessage(hDlg,PSM_ISDIALOGMESSAGE,0,LPARAM(pMsg)); +end; + + +function PropSheet_PressButton(hPropSheetDlg : HWND;iButton : longint) : LRESULT; +begin + PropSheet_PressButton:=SendMessage(hPropSheetDlg,PSM_PRESSBUTTON,WPARAM(longint(iButton)),0); +end; + + +function PropSheet_QuerySiblings(hPropSheetDlg : HWND;param1,param2 : longint) : LRESULT; +begin + PropSheet_QuerySiblings:=SendMessage(hPropSheetDlg,PSM_QUERYSIBLINGS,WPARAM(param1),LPARAM(param2)); +end; + + +function PropSheet_RebootSystem(hPropSheetDlg : HWND) : LRESULT; +begin + PropSheet_RebootSystem:=SendMessage(hPropSheetDlg,PSM_REBOOTSYSTEM,0,0); +end; + + +function PropSheet_RemovePage(hPropSheetDlg : HWND;hpage : HPROPSHEETPAGE; index : longint) : LRESULT; +begin + PropSheet_RemovePage:=SendMessage(hPropSheetDlg,PSM_REMOVEPAGE,WPARAM(index),LPARAM(hpage)); +end; + + +function PropSheet_RestartWindows(hPropSheetDlg : HWND) : LRESULT; +begin + PropSheet_RestartWindows:=SendMessage(hPropSheetDlg,PSM_RESTARTWINDOWS,0,0); +end; + + +function PropSheet_SetCurSel(hPropSheetDlg : HWND;hpage : HPROPSHEETPAGE; index : longint) : LRESULT; +begin + PropSheet_SetCurSel:=SendMessage(hPropSheetDlg,PSM_SETCURSEL,WPARAM(index),LPARAM(hpage)); +end; + + +function PropSheet_SetCurSelByID(hPropSheetDlg : HWND; id : longint) : LRESULT; +begin + PropSheet_SetCurSelByID:=SendMessage(hPropSheetDlg,PSM_SETCURSELID,0,LPARAM(id)); +end; + + +function PropSheet_SetFinishText(hPropSheetDlg:HWND;lpszText : LPTSTR) : LRESULT; +begin + PropSheet_SetFinishText:=SendMessage(hPropSheetDlg,PSM_SETFINISHTEXT,0,LPARAM(lpszText)); +end; + + +function PropSheet_SetTitle(hPropSheetDlg:HWND;dwStyle:DWORD;lpszText : LPCTSTR) : LRESULT; +begin + PropSheet_SetTitle:=SendMessage(hPropSheetDlg,PSM_SETTITLE,WPARAM(dwStyle),LPARAM(lpszText)); +end; + + +function PropSheet_SetWizButtons(hPropSheetDlg:HWND;dwFlags : DWORD) : LRESULT; +begin + PropSheet_SetWizButtons:=SendMessage(hPropSheetDlg,PSM_SETWIZBUTTONS,0,LPARAM(dwFlags)); +end; + + +function PropSheet_UnChanged(hPropSheetDlg:HWND;hwndPage : HWND) : LRESULT; +begin + PropSheet_UnChanged:=SendMessage(hPropSheetDlg,PSM_UNCHANGED,WPARAM(hwndPage),0); +end; + + +function Header_DeleteItem(hwndHD:HWND;index : longint) : WINBOOL; +begin + Header_DeleteItem:=WINBOOL(SendMessage(hwndHD,HDM_DELETEITEM,WPARAM(index),0)); +end; + + +function Header_GetItem(hwndHD:HWND;index:longint;var hdi : HD_ITEM) : WINBOOL; +begin + Header_GetItem:=WINBOOL(SendMessage(hwndHD,HDM_GETITEM,WPARAM(index),LPARAM(@hdi))); +end; + + +function Header_GetItemCount(hwndHD : HWND) : longint; +begin + Header_GetItemCount:=longint(SendMessage(hwndHD,HDM_GETITEMCOUNT,0,0)); +end; + + +function Header_InsertItem(hwndHD:HWND;index : longint;var hdi : HD_ITEM) : longint; +begin + Header_InsertItem:=longint(SendMessage(hwndHD,HDM_INSERTITEM,WPARAM(index),LPARAM(@hdi))); +end; + + +function Header_Layout(hwndHD:HWND;var layout : HD_LAYOUT) : WINBOOL; +begin + Header_Layout:=WINBOOL(SendMessage(hwndHD,HDM_LAYOUT,0,LPARAM(@layout))); +end; + + +function Header_SetItem(hwndHD:HWND;index : longint;var hdi : HD_ITEM) : WINBOOL; +begin + Header_SetItem:=WINBOOL(SendMessage(hwndHD,HDM_SETITEM,WPARAM(index),LPARAM(@hdi))); +end; + + +function ListView_Arrange(hwndLV:HWND;code : UINT) : LRESULT; +begin + ListView_Arrange:=SendMessage(hwndLV,LVM_ARRANGE,WPARAM(UINT(code)),0); +end; + + +function ListView_CreateDragImage(hwnd:HWND;i : longint;lpptUpLeft : LPPOINT) : LRESULT; +begin + ListView_CreateDragImage:=SendMessage(hwnd,LVM_CREATEDRAGIMAGE,WPARAM(i),LPARAM(lpptUpLeft)); +end; + + +function ListView_DeleteAllItems(hwnd : HWND) : LRESULT; +begin + ListView_DeleteAllItems:=SendMessage(hwnd,LVM_DELETEALLITEMS,0,0); +end; + + +function ListView_DeleteColumn(hwnd:HWND;iCol : longint) : LRESULT; +begin + ListView_DeleteColumn:=SendMessage(hwnd,LVM_DELETECOLUMN,WPARAM(iCol),0); +end; + + +function ListView_DeleteItem(hwnd:HWND;iItem : longint) : LRESULT; +begin + ListView_DeleteItem:=SendMessage(hwnd,LVM_DELETEITEM,WPARAM(iItem),0); +end; + + +function ListView_EditLabel(hwndLV:HWND;i : longint) : LRESULT; +begin + ListView_EditLabel:=SendMessage(hwndLV,LVM_EDITLABEL,WPARAM(longint(i)),0); +end; + + +function ListView_EnsureVisible(hwndLV:HWND;i,fPartialOK : longint) : LRESULT; +begin + ListView_EnsureVisible:=SendMessage(hwndLV,LVM_ENSUREVISIBLE,WPARAM(i),MAKELPARAM(fPartialOK,0)); +end; + + +function ListView_FindItem(hwnd:HWND;iStart : longint;var lvfi : LV_FINDINFO) : longint; +begin + ListView_FindItem:=SendMessage(hwnd,LVM_FINDITEM,WPARAM(iStart),LPARAM(@lvfi)); +end; + + +function ListView_GetBkColor(hwnd : HWND) : LRESULT; +begin + ListView_GetBkColor:=SendMessage(hwnd,LVM_GETBKCOLOR,0,0); +end; + + +function ListView_GetCallbackMask(hwnd : HWND) : LRESULT; +begin + ListView_GetCallbackMask:=SendMessage(hwnd,LVM_GETCALLBACKMASK,0,0); +end; + + +function ListView_GetColumn(hwnd:HWND;iCol : longint;var col : LV_COLUMN) : LRESULT; +begin + ListView_GetColumn:=SendMessage(hwnd,LVM_GETCOLUMN,WPARAM(iCol),LPARAM(@col)); +end; + + +function ListView_GetColumnWidth(hwnd:HWND;iCol : longint) : LRESULT; +begin + ListView_GetColumnWidth:=SendMessage(hwnd,LVM_GETCOLUMNWIDTH,WPARAM(iCol),0); +end; + + +function ListView_GetCountPerPage(hwndLV : HWND) : LRESULT; +begin + ListView_GetCountPerPage:=SendMessage(hwndLV,LVM_GETCOUNTPERPAGE,0,0); +end; + + +function ListView_GetEditControl(hwndLV : HWND) : LRESULT; +begin + ListView_GetEditControl:=SendMessage(hwndLV,LVM_GETEDITCONTROL,0,0); +end; + + +function ListView_GetImageList(hwnd:HWND;iImageList : wINT) : LRESULT; +begin + ListView_GetImageList:=SendMessage(hwnd,LVM_GETIMAGELIST,WPARAM(iImageList),0); +end; + + +function ListView_GetISearchString(hwndLV:HWND;lpsz : LPTSTR) : LRESULT; +begin + ListView_GetISearchString:=SendMessage(hwndLV,LVM_GETISEARCHSTRING,0,LPARAM(lpsz)); +end; + + +function ListView_GetItem(hwnd:HWND;var item : LV_ITEM) : LRESULT; +begin + ListView_GetItem:=SendMessage(hwnd,LVM_GETITEM,0,LPARAM(@item)); +end; + + +function ListView_GetItemCount(hwnd : HWND) : LRESULT; +begin + ListView_GetItemCount:=SendMessage(hwnd,LVM_GETITEMCOUNT,0,0); +end; + + +function ListView_GetItemPosition(hwndLV:HWND;i : longint;var pt : POINT) : longint; +begin + ListView_GetItemPosition:=SendMessage(hwndLV,LVM_GETITEMPOSITION,WPARAM(longint(i)),LPARAM(@pt)); +end; + + +function ListView_GetItemSpacing(hwndLV:HWND;fSmall : longint) : LRESULT; +begin + ListView_GetItemSpacing:=SendMessage(hwndLV,LVM_GETITEMSPACING,fSmall,0); +end; + + +function ListView_GetItemState(hwndLV:HWND;i,mask : longint) : LRESULT; +begin + ListView_GetItemState:=SendMessage(hwndLV,LVM_GETITEMSTATE,WPARAM(i),LPARAM(mask)); +end; + + +function ListView_GetNextItem(hwnd:HWND; iStart, flags : longint) : LRESULT; +begin + ListView_GetNextItem:=SendMessage(hwnd, LVM_GETNEXTITEM, WPARAM(iStart), LPARAM(flags)); +end; + + +function ListView_GetOrigin(hwndLV:HWND;var pt : POINT) : LRESULT; +begin + ListView_GetOrigin:=SendMessage(hwndLV,LVM_GETORIGIN,WPARAM(0),LPARAM(@pt)); +end; + + +function ListView_GetSelectedCount(hwndLV : HWND) : LRESULT; +begin + ListView_GetSelectedCount:=SendMessage(hwndLV,LVM_GETSELECTEDCOUNT,0,0); +end; + + +function ListView_GetStringWidth(hwndLV:HWND;psz : LPCTSTR) : LRESULT; +begin + ListView_GetStringWidth:=SendMessage(hwndLV,LVM_GETSTRINGWIDTH,0,LPARAM(psz)); +end; + + +function ListView_GetTextBkColor(hwnd : HWND) : LRESULT; +begin + ListView_GetTextBkColor:=SendMessage(hwnd,LVM_GETTEXTBKCOLOR,0,0); +end; + + +function ListView_GetTextColor(hwnd : HWND) : LRESULT; +begin + ListView_GetTextColor:=SendMessage(hwnd,LVM_GETTEXTCOLOR,0,0); +end; + + +function ListView_GetTopIndex(hwndLV : HWND) : LRESULT; +begin + ListView_GetTopIndex:=SendMessage(hwndLV,LVM_GETTOPINDEX,0,0); +end; + + +function ListView_GetViewRect(hwnd:HWND;var rc : RECT) : LRESULT; +begin + ListView_GetViewRect:=SendMessage(hwnd,LVM_GETVIEWRECT,0,LPARAM(@rc)); +end; + + +function ListView_HitTest(hwndLV:HWND;var info : LV_HITTESTINFO) : LRESULT; +begin + ListView_HitTest:=SendMessage(hwndLV,LVM_HITTEST,0,LPARAM(@info)); +end; + + +function ListView_InsertColumn(hwnd:HWND;iCol : longint;var col : LV_COLUMN) : LRESULT; +begin + ListView_InsertColumn:=SendMessage(hwnd,LVM_INSERTCOLUMN,WPARAM(iCol),LPARAM(@col)); +end; + + +function ListView_InsertItem(hwnd:HWND;var item : LV_ITEM) : LRESULT; +begin + ListView_InsertItem:=SendMessage(hwnd,LVM_INSERTITEM,0,LPARAM(@item)); +end; + + +function ListView_RedrawItems(hwndLV:HWND;iFirst,iLast : longint) : LRESULT; +begin + ListView_RedrawItems:=SendMessage(hwndLV,LVM_REDRAWITEMS,WPARAM(iFirst),LPARAM(iLast)); +end; + + +function ListView_Scroll(hwndLV:HWND;dx,dy : longint) : LRESULT; +begin + ListView_Scroll:=SendMessage(hwndLV,LVM_SCROLL,WPARAM(dx),LPARAM(dy)); +end; + + +function ListView_SetBkColor(hwnd:HWND;clrBk : COLORREF) : LRESULT; +begin + ListView_SetBkColor:=SendMessage(hwnd,LVM_SETBKCOLOR,0,LPARAM(clrBk)); +end; + + +function ListView_SetCallbackMask(hwnd:HWND;mask : UINT) : LRESULT; +begin + ListView_SetCallbackMask:=SendMessage(hwnd,LVM_SETCALLBACKMASK,WPARAM(mask),0); +end; + + +function ListView_SetColumn(hwnd:HWND;iCol : longint; var col : LV_COLUMN) : LRESULT; +begin + ListView_SetColumn:=SendMessage(hwnd,LVM_SETCOLUMN,WPARAM(iCol),LPARAM(@col)); +end; + + +function ListView_SetColumnWidth(hwnd:HWND;iCol,cx : longint) : LRESULT; +begin + ListView_SetColumnWidth:=SendMessage(hwnd,LVM_SETCOLUMNWIDTH,WPARAM(iCol),MAKELPARAM(cx,0)); +end; + + +function ListView_SetImageList(hwnd:HWND;himl : longint;iImageList : HIMAGELIST) : LRESULT; +begin + ListView_SetImageList:=SendMessage(hwnd,LVM_SETIMAGELIST,WPARAM(iImageList),LPARAM(UINT(himl))); +end; + + +function ListView_SetItem(hwnd:HWND;var item : LV_ITEM) : LRESULT; +begin + ListView_SetItem:=SendMessage(hwnd,LVM_SETITEM,0,LPARAM(@item)); +end; + + +function ListView_SetItemCount(hwndLV:HWND;cItems : longint) : LRESULT; +begin + ListView_SetItemCount:=SendMessage(hwndLV,LVM_SETITEMCOUNT,WPARAM(cItems),0); +end; + + +function ListView_SetItemPosition(hwndLV:HWND;i,x,y : longint) : LRESULT; +begin + ListView_SetItemPosition:=SendMessage(hwndLV,LVM_SETITEMPOSITION,WPARAM(i),MAKELPARAM(x,y)); +end; + + +function ListView_SetItemPosition32(hwndLV:HWND;i,x,y : longint) : LRESULT; +var + ptNewPos : POINT; +begin + ptNewPos.x:=x; + ptNewPos.y:=y; + ListView_SetItemPosition32:=SendMessage(hwndLV, LVM_SETITEMPOSITION32, WPARAM(i),LPARAM(@ptNewPos)); +end; + + +function ListView_SetItemState(hwndLV:HWND; i, data, mask:longint) : LRESULT; +var + _gnu_lvi : LV_ITEM; +begin + _gnu_lvi.stateMask:=mask; + _gnu_lvi.state:=data; + ListView_SetItemState:=SendMessage(hwndLV, LVM_SETITEMSTATE, WPARAM(i),LPARAM(@_gnu_lvi)); +end; + + +function ListView_SetItemText(hwndLV:HWND; i, iSubItem_:longint;pszText_ : LPTSTR) : LRESULT; +var + _gnu_lvi : LV_ITEM; +begin + _gnu_lvi.iSubItem:=iSubItem_; + _gnu_lvi.pszText:=pszText_; + ListView_SetItemText:=SendMessage(hwndLV, LVM_SETITEMTEXT, WPARAM(i),LPARAM(@_gnu_lvi)); +end; + + +function ListView_SetTextBkColor(hwnd:HWND;clrTextBk : COLORREF) : LRESULT; +begin + ListView_SetTextBkColor:=SendMessage(hwnd,LVM_SETTEXTBKCOLOR,0,LPARAM(clrTextBk)); +end; + + +function ListView_SetTextColor(hwnd:HWND;clrText : COLORREF) : LRESULT; +begin + ListView_SetTextColor:=SendMessage(hwnd,LVM_SETTEXTCOLOR,0,LPARAM(clrText)); +end; + + +function ListView_SortItems(hwndLV:HWND;_pfnCompare:PFNLVCOMPARE;_lPrm : LPARAM) : LRESULT; +begin + ListView_SortItems:=SendMessage(hwndLV,LVM_SORTITEMS,WPARAM(_lPrm),LPARAM(_pfnCompare)); +end; + + +function ListView_Update(hwndLV:HWND;i : longint) : LRESULT; +begin + ListView_Update:=SendMessage(hwndLV,LVM_UPDATE,WPARAM(i),0); +end; + + +function TreeView_InsertItem(hwnd:HWND;lpis : LPTV_INSERTSTRUCT) : LRESULT; +begin + TreeView_InsertItem:=SendMessage(hwnd,TVM_INSERTITEM,0,LPARAM(lpis)); +end; + + +function TreeView_DeleteItem(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_DeleteItem:=SendMessage(hwnd,TVM_DELETEITEM,0,LPARAM(hitem)); +end; + + +function TreeView_DeleteAllItems(hwnd : HWND) : LRESULT; +begin + TreeView_DeleteAllItems:=SendMessage(hwnd,TVM_DELETEITEM,0,LPARAM(TVI_ROOT)); +end; + + +function TreeView_Expand(hwnd:HWND;hitem:HTREEITEM;code : longint) : LRESULT; +begin + TreeView_Expand:=SendMessage(hwnd,TVM_EXPAND,WPARAM(code),LPARAM(hitem)); +end; + + +function TreeView_GetCount(hwnd : HWND) : LRESULT; +begin + TreeView_GetCount:=SendMessage(hwnd,TVM_GETCOUNT,0,0); +end; + + +function TreeView_GetIndent(hwnd : HWND) : LRESULT; +begin + TreeView_GetIndent:=SendMessage(hwnd,TVM_GETINDENT,0,0); +end; + + +function TreeView_SetIndent(hwnd:HWND;indent : longint) : LRESULT; +begin + TreeView_SetIndent:=SendMessage(hwnd,TVM_SETINDENT,WPARAM(indent),0); +end; + + +function TreeView_GetImageList(hwnd:HWND;iImage : WPARAM) : LRESULT; +begin + TreeView_GetImageList:=SendMessage(hwnd,TVM_GETIMAGELIST,iImage,0); +end; + + +function TreeView_SetImageList(hwnd:HWND;himl:HIMAGELIST;iImage : WPARAM) : LRESULT; +begin + TreeView_SetImageList:=SendMessage(hwnd,TVM_SETIMAGELIST,iImage,LPARAM(UINT(himl))); +end; + + +function TreeView_GetNextItem(hwnd:HWND;hitem:HTREEITEM;code : longint) : LRESULT; +begin + TreeView_GetNextItem:=SendMessage(hwnd,TVM_GETNEXTITEM,WPARAM(code),LPARAM(hitem)); +end; + + +function TreeView_GetChild(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_GetChild:=TreeView_GetNextItem(hwnd,hitem,TVGN_CHILD); +end; + + +function TreeView_GetNextSibling(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_GetNextSibling:=TreeView_GetNextItem(hwnd,hitem,TVGN_NEXT); +end; + + +function TreeView_GetPrevSibling(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_GetPrevSibling:=TreeView_GetNextItem(hwnd,hitem,TVGN_PREVIOUS); +end; + + +function TreeView_GetParent(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_GetParent:=TreeView_GetNextItem(hwnd,hitem,TVGN_PARENT); +end; + + +function TreeView_GetFirstVisible(hwnd : HWND) : LRESULT; +begin + TreeView_GetFirstVisible:=TreeView_GetNextItem(hwnd,HTREEITEM(nil),TVGN_FIRSTVISIBLE); +end; + + +function TreeView_GetNextVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_GetNextVisible:=TreeView_GetNextItem(hwnd,hitem,TVGN_NEXTVISIBLE); +end; + + +function TreeView_GetPrevVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_GetPrevVisible:=TreeView_GetNextItem(hwnd,hitem,TVGN_PREVIOUSVISIBLE); +end; + + +function TreeView_GetSelection(hwnd : HWND) : LRESULT; +begin + TreeView_GetSelection:=TreeView_GetNextItem(hwnd,HTREEITEM(nil),TVGN_CARET); +end; + + +function TreeView_GetDropHilight(hwnd : HWND) : LRESULT; +begin + TreeView_GetDropHilight:=TreeView_GetNextItem(hwnd,HTREEITEM(nil),TVGN_DROPHILITE); +end; + + +function TreeView_GetRoot(hwnd : HWND) : LRESULT; +begin + TreeView_GetRoot:=TreeView_GetNextItem(hwnd,HTREEITEM(nil),TVGN_ROOT); +end; + + +function TreeView_Select(hwnd:HWND;hitem:HTREEITEM;code : longint) : LRESULT; +begin + TreeView_Select:=SendMessage(hwnd,TVM_SELECTITEM,WPARAM(code),LPARAM(hitem)); +end; + + +function TreeView_SelectItem(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_SelectItem:=TreeView_Select(hwnd,hitem,TVGN_CARET); +end; + + +function TreeView_SelectDropTarget(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_SelectDropTarget:=TreeView_Select(hwnd,hitem,TVGN_DROPHILITE); +end; + + +function TreeView_SelectSetFirstVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_SelectSetFirstVisible:=TreeView_Select(hwnd,hitem,TVGN_FIRSTVISIBLE); +end; + + +function TreeView_GetItem(hwnd:HWND;var item : TV_ITEM) : LRESULT; +begin + TreeView_GetItem:=SendMessage(hwnd,TVM_GETITEM,0,LPARAM(@item)); +end; + + +function TreeView_SetItem(hwnd:HWND;var item : TV_ITEM) : LRESULT; +begin + TreeView_SetItem:=SendMessage(hwnd,TVM_SETITEM,0,LPARAM(@item)); +end; + + +function TreeView_EditLabel(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_EditLabel:=SendMessage(hwnd,TVM_EDITLABEL,0,LPARAM(hitem)); +end; + + +function TreeView_GetEditControl(hwnd : HWND) : LRESULT; +begin + TreeView_GetEditControl:=SendMessage(hwnd,TVM_GETEDITCONTROL,0,0); +end; + + +function TreeView_GetVisibleCount(hwnd : HWND) : LRESULT; +begin + TreeView_GetVisibleCount:=SendMessage(hwnd,TVM_GETVISIBLECOUNT,0,0); +end; + + +function TreeView_HitTest(hwnd:HWND;lpht : LPTV_HITTESTINFO) : LRESULT; +begin + TreeView_HitTest:=SendMessage(hwnd,TVM_HITTEST,0,LPARAM(lpht)); +end; + + +function TreeView_CreateDragImage(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_CreateDragImage:=SendMessage(hwnd,TVM_CREATEDRAGIMAGE,0,LPARAM(hitem)); +end; + + +function TreeView_SortChildren(hwnd:HWND;hitem:HTREEITEM;recurse : longint) : LRESULT; +begin + TreeView_SortChildren:=SendMessage(hwnd,TVM_SORTCHILDREN,WPARAM(recurse),LPARAM(hitem)); +end; + + +function TreeView_EnsureVisible(hwnd:HWND;hitem : HTREEITEM) : LRESULT; +begin + TreeView_EnsureVisible:=SendMessage(hwnd,TVM_ENSUREVISIBLE,0,LPARAM(hitem)); +end; + + +function TreeView_SortChildrenCB(hwnd:HWND;psort:LPTV_SORTCB;recurse : longint) : LRESULT; +begin + TreeView_SortChildrenCB:=SendMessage(hwnd,TVM_SORTCHILDRENCB,WPARAM(recurse),LPARAM(psort)); +end; + + +function TreeView_EndEditLabelNow(hwnd:HWND;fCancel : longint) : LRESULT; +begin + TreeView_EndEditLabelNow:=SendMessage(hwnd,TVM_ENDEDITLABELNOW,WPARAM(fCancel),0); +end; + + +function TreeView_GetISearchString(hwndTV:HWND;lpsz : LPTSTR) : LRESULT; +begin + TreeView_GetISearchString:=SendMessage(hwndTV,TVM_GETISEARCHSTRING,0,LPARAM(lpsz)); +end; + + +function TabCtrl_GetImageList(hwnd : HWND) : LRESULT; +begin + TabCtrl_GetImageList:=SendMessage(hwnd,TCM_GETIMAGELIST,0,0); +end; + + +function TabCtrl_SetImageList(hwnd:HWND;himl : HIMAGELIST) : LRESULT; +begin + TabCtrl_SetImageList:=SendMessage(hwnd,TCM_SETIMAGELIST,0,LPARAM(UINT(himl))); +end; + + +function TabCtrl_GetItemCount(hwnd : HWND) : LRESULT; +begin + TabCtrl_GetItemCount:=SendMessage(hwnd,TCM_GETITEMCOUNT,0,0); +end; + + +function TabCtrl_GetItem(hwnd:HWND;iItem : longint;var item : TC_ITEM) : LRESULT; +begin + TabCtrl_GetItem:=SendMessage(hwnd,TCM_GETITEM,WPARAM(iItem),LPARAM(@item)); +end; + + +function TabCtrl_SetItem(hwnd:HWND;iItem : longint;var item : TC_ITEM) : LRESULT; +begin + TabCtrl_SetItem:=SendMessage(hwnd,TCM_SETITEM,WPARAM(iItem),LPARAM(@item)); +end; + + +function TabCtrl_InsertItem(hwnd:HWND;iItem : longint;var item : TC_ITEM) : LRESULT; +begin + TabCtrl_InsertItem:=SendMessage(hwnd,TCM_INSERTITEM,WPARAM(iItem),LPARAM(@item)); +end; + + +function TabCtrl_DeleteItem(hwnd:HWND;i : longint) : LRESULT; +begin + TabCtrl_DeleteItem:=SendMessage(hwnd,TCM_DELETEITEM,WPARAM(i),0); +end; + + +function TabCtrl_DeleteAllItems(hwnd : HWND) : LRESULT; +begin + TabCtrl_DeleteAllItems:=SendMessage(hwnd,TCM_DELETEALLITEMS,0,0); +end; + + +function TabCtrl_GetItemRect(hwnd:HWND;i : longint;var rc : RECT) : LRESULT; +begin + TabCtrl_GetItemRect:=SendMessage(hwnd,TCM_GETITEMRECT,WPARAM(longint(i)),LPARAM(@rc)); +end; + + +function TabCtrl_GetCurSel(hwnd : HWND) : LRESULT; +begin + TabCtrl_GetCurSel:=SendMessage(hwnd,TCM_GETCURSEL,0,0); +end; + + +function TabCtrl_SetCurSel(hwnd:HWND;i : longint) : LRESULT; +begin + TabCtrl_SetCurSel:=SendMessage(hwnd,TCM_SETCURSEL,WPARAM(i),0); +end; + + +function TabCtrl_HitTest(hwndTC:HWND;var info : TC_HITTESTINFO) : LRESULT; +begin + TabCtrl_HitTest:=SendMessage(hwndTC,TCM_HITTEST,0,LPARAM(@info)); +end; + + +function TabCtrl_SetItemExtra(hwndTC:HWND;cb : longint) : LRESULT; +begin + TabCtrl_SetItemExtra:=SendMessage(hwndTC,TCM_SETITEMEXTRA,WPARAM(cb),0); +end; + + +function TabCtrl_AdjustRect(hwnd:HWND;bLarger:WINBOOL;var rc : RECT) : LRESULT; +begin + TabCtrl_AdjustRect:=SendMessage(hwnd,TCM_ADJUSTRECT,WPARAM(bLarger),LPARAM(@rc)); +end; + + +function TabCtrl_SetItemSize(hwnd:HWND;x,y : longint) : LRESULT; +begin + TabCtrl_SetItemSize:=SendMessage(hwnd,TCM_SETITEMSIZE,0,MAKELPARAM(x,y)); +end; + + +function TabCtrl_RemoveImage(hwnd:HWND;i : WPARAM) : LRESULT; +begin + TabCtrl_RemoveImage:=SendMessage(hwnd,TCM_REMOVEIMAGE,i,0); +end; + + +function TabCtrl_SetPadding(hwnd:HWND;cx,cy : longint) : LRESULT; +begin + TabCtrl_SetPadding:=SendMessage(hwnd,TCM_SETPADDING,0,MAKELPARAM(cx,cy)); +end; + + +function TabCtrl_GetRowCount(hwnd : HWND) : LRESULT; +begin + TabCtrl_GetRowCount:=SendMessage(hwnd,TCM_GETROWCOUNT,0,0); +end; + + +function TabCtrl_GetToolTips(hwnd : HWND) : LRESULT; +begin + TabCtrl_GetToolTips:=SendMessage(hwnd,TCM_GETTOOLTIPS,0,0); +end; + + +function TabCtrl_SetToolTips(hwnd:HWND;hwndTT : longint) : LRESULT; +begin + TabCtrl_SetToolTips:=SendMessage(hwnd,TCM_SETTOOLTIPS,WPARAM(hwndTT),0); +end; + + +function TabCtrl_GetCurFocus(hwnd : HWND) : LRESULT; +begin + TabCtrl_GetCurFocus:=SendMessage(hwnd,TCM_GETCURFOCUS,0,0); +end; + + +function TabCtrl_SetCurFocus(hwnd:HWND;i : longint) : LRESULT; +begin + TabCtrl_SetCurFocus:=SendMessage(hwnd,TCM_SETCURFOCUS,i,0); +end; + + +function SNDMSG(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; +begin + SNDMSG:=SendMessage(hWnd,Msg,wParam,lParam); +end; + + +function CommDlg_OpenSave_GetSpecA(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetSpecA:=SNDMSG(_hdlg,CDM_GETSPEC,WPARAM(_cbmax),LPARAM(_psz)); +end; + + +function CommDlg_OpenSave_GetSpecW(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetSpecW:=SNDMSG(_hdlg,CDM_GETSPEC,WPARAM(_cbmax),LPARAM(_psz)); +end; + + +{$ifndef Unicode} +function CommDlg_OpenSave_GetSpec(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetSpec:=SNDMSG(_hdlg,CDM_GETSPEC,WPARAM(_cbmax),LPARAM(_psz)); +end; +{$else Unicode} +function CommDlg_OpenSave_GetSpec(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetSpec:=SNDMSG(_hdlg,CDM_GETSPEC,WPARAM(_cbmax),LPARAM(_psz)); +end; +{$endif Unicode} + + +function CommDlg_OpenSave_GetFilePathA(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFilePathA:=SNDMSG(_hdlg,CDM_GETFILEPATH,WPARAM(_cbmax),LPARAM(_psz)); +end; + + +function CommDlg_OpenSave_GetFilePathW(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFilePathW:=SNDMSG(_hdlg,CDM_GETFILEPATH,WPARAM(_cbmax),LPARAM(LPWSTR(_psz))); +end; + +{$ifndef Unicode} +function CommDlg_OpenSave_GetFilePath(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFilePath:=SNDMSG(_hdlg,CDM_GETFILEPATH,WPARAM(_cbmax),LPARAM(_psz)); +end; +{$else Unicode} +function CommDlg_OpenSave_GetFilePath(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFilePath:=SNDMSG(_hdlg,CDM_GETFILEPATH,WPARAM(_cbmax),LPARAM(_psz)); +end; +{$endif Unicode} + +function CommDlg_OpenSave_GetFolderPathA(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFolderPathA:=SNDMSG(_hdlg,CDM_GETFOLDERPATH,WPARAM(_cbmax),LPARAM(LPSTR(_psz))); +end; + + +function CommDlg_OpenSave_GetFolderPathW(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFolderPathW:=SNDMSG(_hdlg,CDM_GETFOLDERPATH,WPARAM(_cbmax),LPARAM(LPWSTR(_psz))); +end; + +{$ifndef Unicode} +function CommDlg_OpenSave_GetFolderPath(_hdlg:HWND;_psz:LPSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFolderPath:=SNDMSG(_hdlg,CDM_GETFOLDERPATH,WPARAM(_cbmax),LPARAM(LPSTR(_psz))); +end; +{$else Unicode} +function CommDlg_OpenSave_GetFolderPath(_hdlg:HWND;_psz:LPWSTR;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFolderPath:=SNDMSG(_hdlg,CDM_GETFOLDERPATH,WPARAM(_cbmax),LPARAM(LPWSTR(_psz))); +end; +{$endif Unicode} + +function CommDlg_OpenSave_GetFolderIDList(_hdlg:HWND;_pidl:LPVOID;_cbmax : longint) : LRESULT; +begin + CommDlg_OpenSave_GetFolderIDList:=SNDMSG(_hdlg,CDM_GETFOLDERIDLIST,WPARAM(_cbmax),LPARAM(_pidl)); +end; + + +function CommDlg_OpenSave_SetControlText(_hdlg:HWND;_id : longint;_text : LPSTR) : LRESULT; +begin + CommDlg_OpenSave_SetControlText:=SNDMSG(_hdlg,CDM_SETCONTROLTEXT,WPARAM(_id),LPARAM(_text)); +end; + + +function CommDlg_OpenSave_HideControl(_hdlg:HWND;_id : longint) : LRESULT; +begin + CommDlg_OpenSave_HideControl:=SNDMSG(_hdlg,CDM_HIDECONTROL,WPARAM(_id),0); +end; + + +function CommDlg_OpenSave_SetDefExt(_hdlg:HWND;_pszext : LPSTR) : LRESULT; +begin + CommDlg_OpenSave_SetDefExt:=SNDMSG(_hdlg,CDM_SETDEFEXT,0,LPARAM(_pszext)); +end; + +function InternalGetLargestConsoleWindowSize(hConsoleOutput:HANDLE):DWord; external 'kernel32' name 'GetLargestConsoleWindowSize'; + +function GetLargestConsoleWindowSize(hConsoleOutput:HANDLE):COORD; +var + res : dword; +begin + res:=InternalGetLargestConsoleWindowSize(hConsoleOutput); + GetLargestConsoleWindowSize:=COORD(res); +end; +//end win32 or wince not checked + +{$endif WIN32} + + +{$endif read_implementation} + diff --git a/rtl/wince/wininc/messages.inc b/rtl/wince/wininc/messages.inc new file mode 100644 index 0000000000..164b50a1c0 --- /dev/null +++ b/rtl/wince/wininc/messages.inc @@ -0,0 +1,1314 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 1999-2000 by Florian Klaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ + Messages.h Windows32 API message definitions + Copyright (C) 1996 Free Software Foundation, Inc. + + Author: Scott Christley + + This file is part of the Windows32 API Library. + + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Changes : + + 08/15/2005 update for wince4.2 port,ORO06 +} + +{$ifdef read_interface} + + const + ACM_OPENW = 1127; + ACM_OPENA = 1124; + {$ifdef UNICODE} + const + ACM_OPEN = ACM_OPENW; + {$else} + const + ACM_OPEN = ACM_OPENA; + {$endif} + { UNICODE } + + const + ACM_PLAY = 1125; + ACM_STOP = 1126; + ACN_START = 1; + ACN_STOP = 2; + { Buttons } + BM_CLICK = 245; + BM_GETCHECK = 240; + BM_GETIMAGE = 246; + BM_GETSTATE = 242; + BM_SETCHECK = 241; + BM_SETIMAGE = 247; + BM_SETSTATE = 243; + BM_SETSTYLE = 244; + BN_CLICKED = 0; + BN_DBLCLK = 5; + BN_DISABLE = 4; + BN_DOUBLECLICKED = 5; + BN_HILITE = 2; + BN_KILLFOCUS = 7; + BN_PAINT = 1; + BN_PUSHED = 2; + BN_SETFOCUS = 6; + BN_UNHILITE = 3; + BN_UNPUSHED = 3; + { Combo Box } + CB_ADDSTRING = 323; + CB_DELETESTRING = 324; + CB_DIR = 325; + CB_FINDSTRING = 332; + CB_FINDSTRINGEXACT = 344; + CB_GETCOUNT = 326; + CB_GETCURSEL = 327; + CB_GETDROPPEDCONTROLRECT = 338; + CB_GETDROPPEDSTATE = 343; + CB_GETDROPPEDWIDTH = 351; + CB_GETEDITSEL = 320; + CB_GETEXTENDEDUI = 342; + CB_GETHORIZONTALEXTENT = 349; + CB_GETITEMDATA = 336; + CB_GETITEMHEIGHT = 340; + CB_GETLBTEXT = 328; + CB_GETLBTEXTLEN = 329; + CB_GETLOCALE = 346; + CB_GETTOPINDEX = 347; + CB_INITSTORAGE = 353; + CB_INSERTSTRING = 330; + CB_LIMITTEXT = 321; + CB_RESETCONTENT = 331; + CB_SELECTSTRING = 333; + CB_SETCURSEL = 334; + CB_SETDROPPEDWIDTH = 352; + CB_SETEDITSEL = 322; + CB_SETEXTENDEDUI = 341; + CB_SETHORIZONTALEXTENT = 350; + CB_SETITEMDATA = 337; + CB_SETITEMHEIGHT = 339; + CB_SETLOCALE = 345; + CB_SETTOPINDEX = 348; + CB_SHOWDROPDOWN = 335; + { Combo Box notifications } + CBN_CLOSEUP = 8; + CBN_DBLCLK = 2; + CBN_DROPDOWN = 7; + CBN_EDITCHANGE = 5; + CBN_EDITUPDATE = 6; + CBN_ERRSPACE = -(1); + CBN_KILLFOCUS = 4; + CBN_SELCHANGE = 1; + CBN_SELENDCANCEL = 10; + CBN_SELENDOK = 9; + CBN_SETFOCUS = 3; + { Control Panel } + { Device messages } + { Drag list box } + DL_BEGINDRAG = 1157; + DL_CANCELDRAG = 1160; + DL_DRAGGING = 1158; + DL_DROPPED = 1159; + { Default push button } + DM_GETDEFID = 1024; + DM_REPOSITION = 1026; + DM_SETDEFID = 1025; + { RTF control } + EM_CANPASTE = 1074; + EM_CANUNDO = 198; + EM_CHARFROMPOS = 215; + EM_DISPLAYBAND = 1075; + EM_EMPTYUNDOBUFFER = 205; + EM_EXGETSEL = 1076; + EM_EXLIMITTEXT = 1077; + EM_EXLINEFROMCHAR = 1078; + EM_EXSETSEL = 1079; + EM_FINDTEXT = 1080; + EM_FINDTEXTEX = 1103; + EM_FINDWORDBREAK = 1100; + EM_FMTLINES = 200; + EM_FORMATRANGE = 1081; + EM_GETCHARFORMAT = 1082; + EM_GETEVENTMASK = 1083; + EM_GETFIRSTVISIBLELINE = 206; + EM_GETHANDLE = 189; + EM_GETLIMITTEXT = 213; + EM_GETLINE = 196; + EM_GETLINECOUNT = 186; + EM_GETMARGINS = 212; + EM_GETMODIFY = 184; + EM_GETIMECOLOR = 1129; + EM_GETIMEOPTIONS = 1131; + EM_GETOPTIONS = 1102; + EM_GETOLEINTERFACE = 1084; + EM_GETPARAFORMAT = 1085; + EM_GETPASSWORDCHAR = 210; + EM_GETPUNCTUATION = 1125; + EM_GETRECT = 178; + EM_GETSEL = 176; + EM_GETSELTEXT = 1086; + EM_GETTEXTRANGE = 1099; + EM_GETTHUMB = 190; + EM_GETWORDBREAKPROC = 209; + EM_GETWORDBREAKPROCEX = 1104; + EM_GETWORDWRAPMODE = 1127; + EM_HIDESELECTION = 1087; + EM_LIMITTEXT = 197; + EM_LINEFROMCHAR = 201; + EM_LINEINDEX = 187; + EM_LINELENGTH = 193; + EM_LINESCROLL = 182; + EM_PASTESPECIAL = 1088; + EM_POSFROMCHAR = 214; + EM_REPLACESEL = 194; + EM_REQUESTRESIZE = 1089; + EM_SCROLL = 181; + EM_SCROLLCARET = 183; + EM_SELECTIONTYPE = 1090; + EM_SETBKGNDCOLOR = 1091; + EM_SETCHARFORMAT = 1092; + EM_SETEVENTMASK = 1093; + EM_SETHANDLE = 188; + EM_SETIMECOLOR = 1128; + EM_SETIMEOPTIONS = 1130; + EM_SETLIMITTEXT = 197; + EM_SETMARGINS = 211; + EM_SETMODIFY = 185; + EM_SETOLECALLBACK = 1094; + EM_SETOPTIONS = 1101; + EM_SETPARAFORMAT = 1095; + EM_SETPASSWORDCHAR = 204; + EM_SETPUNCTUATION = 1124; + EM_SETREADONLY = 207; + EM_SETRECT = 179; + EM_SETRECTNP = 180; + EM_SETSEL = 177; + EM_SETTABSTOPS = 203; + EM_SETTARGETDEVICE = 1096; + EM_SETWORDBREAKPROC = 208; + EM_SETWORDBREAKPROCEX = 1105; + EM_SETWORDWRAPMODE = 1126; + EM_STREAMIN = 1097; + EM_STREAMOUT = 1098; + EM_UNDO = 199; + { Edit control } + EN_CHANGE = 768; + EN_CORRECTTEXT = 1797; + EN_DROPFILES = 1795; + EN_ERRSPACE = 1280; + EN_HSCROLL = 1537; + EN_IMECHANGE = 1799; + EN_KILLFOCUS = 512; + EN_MAXTEXT = 1281; + EN_MSGFILTER = 1792; + EN_OLEOPFAILED = 1801; + EN_PROTECTED = 1796; + EN_REQUESTRESIZE = 1793; + EN_SAVECLIPBOARD = 1800; + EN_SELCHANGE = 1794; + EN_SETFOCUS = 256; + EN_STOPNOUNDO = 1798; + EN_UPDATE = 1024; + EN_VSCROLL = 1538; + { File Manager extensions } + { File Manager extensions DLL events } + { Header control } + HDM_DELETEITEM = 4610; + HDM_GETITEMW = 4619; + HDM_INSERTITEMW = 4618; + HDM_SETITEMW = 4620; + HDM_GETITEMA = 4611; + HDM_INSERTITEMA = 4609; + HDM_SETITEMA = 4612; +{$ifdef UNICODE} + + const + HDM_GETITEM = HDM_GETITEMW; + HDM_INSERTITEM = HDM_INSERTITEMW; + HDM_SETITEM = HDM_SETITEMW; +{$else} + + const + HDM_GETITEM = HDM_GETITEMA; + HDM_INSERTITEM = HDM_INSERTITEMA; + HDM_SETITEM = HDM_SETITEMA; +{$endif} + { UNICODE } + + const + HDM_GETITEMCOUNT = 4608; + HDM_HITTEST = 4614; + HDM_LAYOUT = 4613; + { Header control notifications } + HDN_BEGINTRACKW = -(326); + HDN_DIVIDERDBLCLICKW = -(325); + HDN_ENDTRACKW = -(327); + HDN_ITEMCHANGEDW = -(321); + HDN_ITEMCHANGINGW = -(320); + HDN_ITEMCLICKW = -(322); + HDN_ITEMDBLCLICKW = -(323); + HDN_TRACKW = -(328); + HDN_BEGINTRACKA = -(306); + HDN_DIVIDERDBLCLICKA = -(305); + HDN_ENDTRACKA = -(307); + HDN_ITEMCHANGEDA = -(301); + HDN_ITEMCHANGINGA = -(300); + HDN_ITEMCLICKA = -(302); + HDN_ITEMDBLCLICKA = -(303); + HDN_TRACKA = -(308); +{$ifdef UNICODE} + + const + HDN_BEGINTRACK = HDN_BEGINTRACKW; + HDN_DIVIDERDBLCLICK = HDN_DIVIDERDBLCLICKW; + HDN_ENDTRACK = HDN_ENDTRACKW; + HDN_ITEMCHANGED = HDN_ITEMCHANGEDW; + HDN_ITEMCHANGING = HDN_ITEMCHANGINGW; + HDN_ITEMCLICK = HDN_ITEMCLICKW; + HDN_ITEMDBLCLICK = HDN_ITEMDBLCLICKW; + HDN_TRACK = HDN_TRACKW; +{$else} + + const + HDN_BEGINTRACK = HDN_BEGINTRACKA; + HDN_DIVIDERDBLCLICK = HDN_DIVIDERDBLCLICKA; + HDN_ENDTRACK = HDN_ENDTRACKA; + HDN_ITEMCHANGED = HDN_ITEMCHANGEDA; + HDN_ITEMCHANGING = HDN_ITEMCHANGINGA; + HDN_ITEMCLICK = HDN_ITEMCLICKA; + HDN_ITEMDBLCLICK = HDN_ITEMDBLCLICKA; + HDN_TRACK = HDN_TRACKA; +{$endif} + { UNICODE } + { Hot key control } + + const + HKM_GETHOTKEY = 1026; + HKM_SETHOTKEY = 1025; + HKM_SETRULES = 1027; + { List box } + LB_ADDFILE = 406; + LB_ADDSTRING = 384; + LB_DELETESTRING = 386; + LB_DIR = 397; + LB_FINDSTRING = 399; + LB_FINDSTRINGEXACT = 418; + LB_GETANCHORINDEX = 413; + LB_GETCARETINDEX = 415; + LB_GETCOUNT = 395; + LB_GETCURSEL = 392; + LB_GETHORIZONTALEXTENT = 403; + LB_GETITEMDATA = 409; + LB_GETITEMHEIGHT = 417; + LB_GETITEMRECT = 408; + LB_GETLOCALE = 422; + LB_GETSEL = 391; + LB_GETSELCOUNT = 400; + LB_GETSELITEMS = 401; + LB_GETTEXT = 393; + LB_GETTEXTLEN = 394; + LB_GETTOPINDEX = 398; + LB_INITSTORAGE = 424; + LB_INSERTSTRING = 385; + LB_ITEMFROMPOINT = 425; + LB_RESETCONTENT = 388; + LB_SELECTSTRING = 396; + LB_SELITEMRANGE = 411; + LB_SELITEMRANGEEX = 387; + LB_SETANCHORINDEX = 412; + LB_SETCARETINDEX = 414; + LB_SETCOLUMNWIDTH = 405; + LB_SETCOUNT = 423; + LB_SETCURSEL = 390; + LB_SETHORIZONTALEXTENT = 404; + LB_SETITEMDATA = 410; + LB_SETITEMHEIGHT = 416; + LB_SETLOCALE = 421; + LB_SETSEL = 389; + LB_SETTABSTOPS = 402; + LB_SETTOPINDEX = 407; + { List box notifications } + LBN_DBLCLK = 2; + LBN_ERRSPACE = -(2); + LBN_KILLFOCUS = 5; + LBN_SELCANCEL = 3; + LBN_SELCHANGE = 1; + LBN_SETFOCUS = 4; + { List view control } + LVM_ARRANGE = 4118; + LVM_CREATEDRAGIMAGE = 4129; + LVM_DELETEALLITEMS = 4105; + LVM_DELETECOLUMN = 4124; + LVM_DELETEITEM = 4104; + LVM_ENSUREVISIBLE = 4115; + LVM_GETBKCOLOR = 4096; + LVM_GETCALLBACKMASK = 4106; + LVM_GETCOLUMNWIDTH = 4125; + LVM_GETCOUNTPERPAGE = 4136; + LVM_GETEDITCONTROL = 4120; + LVM_GETIMAGELIST = 4098; + LVM_EDITLABELW = 4214; + LVM_FINDITEMW = 4179; + LVM_GETCOLUMNW = 4191; + LVM_GETISEARCHSTRINGW = 4213; + LVM_GETITEMW = 4171; + LVM_GETITEMTEXTW = 4211; + LVM_GETSTRINGWIDTHW = 4183; + LVM_INSERTCOLUMNW = 4193; + LVM_INSERTITEMW = 4173; + LVM_SETCOLUMNW = 4192; + LVM_SETITEMW = 4172; + LVM_SETITEMTEXTW = 4212; + LVM_EDITLABELA = 4119; + LVM_FINDITEMA = 4109; + LVM_GETCOLUMNA = 4121; + LVM_GETISEARCHSTRINGA = 4148; + LVM_GETITEMA = 4101; + LVM_GETITEMTEXTA = 4141; + LVM_GETSTRINGWIDTHA = 4113; + LVM_INSERTCOLUMNA = 4123; + LVM_INSERTITEMA = 4103; + LVM_SETCOLUMNA = 4122; + LVM_SETITEMA = 4102; + LVM_SETITEMTEXTA = 4142; +{$ifdef UNICODE} + + const + LVM_EDITLABEL = LVM_EDITLABELW; + LVM_FINDITEM = LVM_FINDITEMW; + LVM_GETCOLUMN = LVM_GETCOLUMNW; + LVM_GETISEARCHSTRING = LVM_GETISEARCHSTRINGW; + LVM_GETITEM = LVM_GETITEMW; + LVM_GETITEMTEXT = LVM_GETITEMTEXTW; + LVM_GETSTRINGWIDTH = LVM_GETSTRINGWIDTHW; + LVM_INSERTCOLUMN = LVM_INSERTCOLUMNW; + LVM_INSERTITEM = LVM_INSERTITEMW; + LVM_SETCOLUMN = LVM_SETCOLUMNW; + LVM_SETITEM = LVM_SETITEMW; + LVM_SETITEMTEXT = LVM_SETITEMTEXTW; +{$else} + + const + LVM_EDITLABEL = LVM_EDITLABELA; + LVM_FINDITEM = LVM_FINDITEMA; + LVM_GETCOLUMN = LVM_GETCOLUMNA; + LVM_GETISEARCHSTRING = LVM_GETISEARCHSTRINGA; + LVM_GETITEM = LVM_GETITEMA; + LVM_GETITEMTEXT = LVM_GETITEMTEXTA; + LVM_GETSTRINGWIDTH = LVM_GETSTRINGWIDTHA; + LVM_INSERTCOLUMN = LVM_INSERTCOLUMNA; + LVM_INSERTITEM = LVM_INSERTITEMA; + LVM_SETCOLUMN = LVM_SETCOLUMNA; + LVM_SETITEM = LVM_SETITEMA; + LVM_SETITEMTEXT = LVM_SETITEMTEXTA; +{$endif} + { UNICODE } + + const + LVM_GETITEMCOUNT = 4100; + LVM_GETITEMPOSITION = 4112; + LVM_GETITEMRECT = 4110; + LVM_GETITEMSPACING = 4147; + LVM_GETITEMSTATE = 4140; + LVM_GETNEXTITEM = 4108; + LVM_GETORIGIN = 4137; + LVM_GETSELECTEDCOUNT = 4146; + LVM_GETTEXTBKCOLOR = 4133; + LVM_GETTEXTCOLOR = 4131; + LVM_GETTOPINDEX = 4135; + LVM_GETVIEWRECT = 4130; + LVM_HITTEST = 4114; + LVM_REDRAWITEMS = 4117; + LVM_SCROLL = 4116; + LVM_SETBKCOLOR = 4097; + LVM_SETCALLBACKMASK = 4107; + LVM_SETCOLUMNWIDTH = 4126; + LVM_SETIMAGELIST = 4099; + LVM_SETITEMCOUNT = 4143; + LVM_SETITEMPOSITION = 4111; + LVM_SETITEMPOSITION32 = 4145; + LVM_SETITEMSTATE = 4139; + LVM_SETTEXTBKCOLOR = 4134; + LVM_SETTEXTCOLOR = 4132; + LVM_SORTITEMS = 4144; + LVM_UPDATE = 4138; + { List view control notifications } + LVN_BEGINDRAG = -(109); + LVN_BEGINRDRAG = -(111); + LVN_COLUMNCLICK = -(108); + LVN_DELETEALLITEMS = -(104); + LVN_DELETEITEM = -(103); + LVN_BEGINLABELEDITW = -(175); + LVN_ENDLABELEDITW = -(176); + LVN_GETDISPINFOW = -(177); + LVN_SETDISPINFOW = -(178); + LVN_BEGINLABELEDITA = -(105); + LVN_ENDLABELEDITA = -(106); + LVN_GETDISPINFOA = -(150); + LVN_SETDISPINFOA = -(151); +{$ifdef UNICODE} + + const + LVN_BEGINLABELEDIT = LVN_BEGINLABELEDITW; + LVN_ENDLABELEDIT = LVN_ENDLABELEDITW; + LVN_GETDISPINFO = LVN_GETDISPINFOW; + LVN_SETDISPINFO = LVN_SETDISPINFOW; +{$else} + + const + LVN_BEGINLABELEDIT = LVN_BEGINLABELEDITA; + LVN_ENDLABELEDIT = LVN_ENDLABELEDITA; + LVN_GETDISPINFO = LVN_GETDISPINFOA; + LVN_SETDISPINFO = LVN_SETDISPINFOA; +{$endif} + { UNICODE } + + const + LVN_INSERTITEM = -(102); + LVN_ITEMCHANGED = -(101); + LVN_ITEMCHANGING = -(100); + LVN_KEYDOWN = -(155); + { Control notification } + NM_CLICK = -(2); + NM_DBLCLK = -(3); + NM_KILLFOCUS = -(8); + NM_OUTOFMEMORY = -(1); + NM_RCLICK = -(5); + NM_RDBLCLK = -(6); + NM_RETURN = -(4); + NM_SETFOCUS = -(7); + { Power status } + { Progress bar control } + PBM_DELTAPOS = 1027; + PBM_SETPOS = 1026; + PBM_SETRANGE = 1025; + PBM_SETSTEP = 1028; + PBM_STEPIT = 1029; + { Property sheets } + PSM_ADDPAGE = 1127; + PSM_APPLY = 1134; + PSM_CANCELTOCLOSE = 1131; + PSM_CHANGED = 1128; + PSM_GETTABCONTROL = 1140; + PSM_GETCURRENTPAGEHWND = 1142; + PSM_ISDIALOGMESSAGE = 1141; + PSM_PRESSBUTTON = 1137; + PSM_QUERYSIBLINGS = 1132; + PSM_REBOOTSYSTEM = 1130; + PSM_REMOVEPAGE = 1126; + PSM_RESTARTWINDOWS = 1129; + PSM_SETCURSEL = 1125; + PSM_SETCURSELID = 1138; + PSM_SETFINISHTEXTW = 1145; + PSM_SETTITLEW = 1144; + PSM_SETFINISHTEXTA = 1139; + PSM_SETTITLEA = 1135; +{$ifdef UNICODE} + + const + PSM_SETFINISHTEXT = PSM_SETFINISHTEXTW; + PSM_SETTITLE = PSM_SETTITLEW; +{$else} + + const + PSM_SETFINISHTEXT = PSM_SETFINISHTEXTA; + PSM_SETTITLE = PSM_SETTITLEA; +{$endif} + { UNICODE } + + const + PSM_SETWIZBUTTONS = 1136; + PSM_UNCHANGED = 1133; + { Property sheet notifications } + PSN_APPLY = -(202); + PSN_HELP = -(205); + PSN_KILLACTIVE = -(201); + PSN_QUERYCANCEL = -(209); + PSN_RESET = -(203); + PSN_SETACTIVE = -(200); + PSN_WIZBACK = -(206); + PSN_WIZFINISH = -(208); + PSN_WIZNEXT = -(207); + { Status window } + SB_GETBORDERS = 1031; + SB_GETPARTS = 1030; + SB_GETRECT = 1034; + SB_GETTEXTW = 1037; + SB_GETTEXTLENGTHW = 1036; + SB_SETTEXTW = 1035; + SB_GETTEXTA = 1026; + SB_GETTEXTLENGTHA = 1027; + SB_SETTEXTA = 1025; +{$ifdef UNICODE} + + const + SB_GETTEXT = SB_GETTEXTW; + SB_GETTEXTLENGTH = SB_GETTEXTLENGTHW; + SB_SETTEXT = SB_SETTEXTW; +{$else} + + const + SB_GETTEXT = SB_GETTEXTA; + SB_GETTEXTLENGTH = SB_GETTEXTLENGTHA; + SB_SETTEXT = SB_SETTEXTA; +{$endif} + { UNICODE } + + const + SB_SETMINHEIGHT = 1032; + SB_SETPARTS = 1028; + SB_SIMPLE = 1033; + { Scroll bar control } + SBM_ENABLE_ARROWS = 228; + SBM_GETPOS = 225; + SBM_GETRANGE = 227; + SBM_GETSCROLLINFO = 234; + SBM_SETPOS = 224; + SBM_SETRANGE = 226; + SBM_SETRANGEREDRAW = 230; + SBM_SETSCROLLINFO = 233; + { Static control } + STM_GETICON = 369; + STM_GETIMAGE = 371; + STM_SETICON = 368; + STM_SETIMAGE = 370; + { Static control notifications } + STN_CLICKED = 0; + STN_DBLCLK = 1; + STN_DISABLE = 3; + STN_ENABLE = 2; + { Toolbar control } + TB_ADDBITMAP = 1043; + TB_ADDBUTTONS = 1044; + TB_AUTOSIZE = 1057; + TB_BUTTONCOUNT = 1048; + TB_BUTTONSTRUCTSIZE = 1054; + TB_CHANGEBITMAP = 1067; + TB_CHECKBUTTON = 1026; + TB_COMMANDTOINDEX = 1049; + TB_CUSTOMIZE = 1051; + TB_DELETEBUTTON = 1046; + TB_ENABLEBUTTON = 1025; + TB_GETBITMAP = 1068; + TB_GETBITMAPFLAGS = 1065; + TB_GETBUTTON = 1047; + TB_ADDSTRINGW = 1101; + TB_GETBUTTONTEXTW = 1099; + TB_SAVERESTOREW = 1100; + TB_ADDSTRINGA = 1052; + TB_GETBUTTONTEXTA = 1069; + TB_SAVERESTOREA = 1050; +{$ifdef UNICODE} + + const + TB_ADDSTRING = TB_ADDSTRINGW; + TB_GETBUTTONTEXT = TB_GETBUTTONTEXTW; + TB_SAVERESTORE = TB_SAVERESTOREW; +{$else} + + const + TB_ADDSTRING = TB_ADDSTRINGA; + TB_GETBUTTONTEXT = TB_GETBUTTONTEXTA; + TB_SAVERESTORE = TB_SAVERESTOREA; +{$endif} + { UNICODE } + + const + TB_GETITEMRECT = 1053; + TB_GETROWS = 1064; + TB_GETSTATE = 1042; + TB_GETTOOLTIPS = 1059; + TB_HIDEBUTTON = 1028; + TB_INDETERMINATE = 1029; + TB_INSERTBUTTON = 1045; + TB_ISBUTTONCHECKED = 1034; + TB_ISBUTTONENABLED = 1033; + TB_ISBUTTONHIDDEN = 1036; + TB_ISBUTTONINDETERMINATE = 1037; + TB_ISBUTTONPRESSED = 1035; + TB_PRESSBUTTON = 1027; + TB_SETBITMAPSIZE = 1056; + TB_SETBUTTONSIZE = 1055; + TB_SETCMDID = 1066; + TB_SETPARENT = 1061; + TB_SETROWS = 1063; + TB_SETSTATE = 1041; + TB_SETTOOLTIPS = 1060; + { Track bar control } + TBM_CLEARSEL = 1043; + TBM_CLEARTICS = 1033; + TBM_GETCHANNELRECT = 1050; + TBM_GETLINESIZE = 1048; + TBM_GETNUMTICS = 1040; + TBM_GETPAGESIZE = 1046; + TBM_GETPOS = 1024; + TBM_GETPTICS = 1038; + TBM_GETRANGEMAX = 1026; + TBM_GETRANGEMIN = 1025; + TBM_GETSELEND = 1042; + TBM_GETSELSTART = 1041; + TBM_GETTHUMBLENGTH = 1052; + TBM_GETTHUMBRECT = 1049; + TBM_GETTIC = 1027; + TBM_GETTICPOS = 1039; + TBM_SETLINESIZE = 1047; + TBM_SETPAGESIZE = 1045; + TBM_SETPOS = 1029; + TBM_SETRANGE = 1030; + TBM_SETRANGEMAX = 1032; + TBM_SETRANGEMIN = 1031; + TBM_SETSEL = 1034; + TBM_SETSELEND = 1036; + TBM_SETSELSTART = 1035; + TBM_SETTHUMBLENGTH = 1051; + TBM_SETTIC = 1028; + TBM_SETTICFREQ = 1044; + { Tool bar control notifications } + TBN_BEGINADJUST = -(703); + TBN_BEGINDRAG = -(701); + TBN_CUSTHELP = -(709); + TBN_ENDADJUST = -(704); + TBN_ENDDRAG = -(702); + TBN_GETBUTTONINFOW = -(720); + TBN_GETBUTTONINFOA = -(700); + +{$ifdef UNICODE} + + const + TBN_GETBUTTONINFO = TBN_GETBUTTONINFOW; +{$else} + + const + TBN_GETBUTTONINFO = TBN_GETBUTTONINFOA; +{$endif} + { UNICODE } + + const + TBN_QUERYDELETE = -(707); + TBN_QUERYINSERT = -(706); + TBN_RESET = -(705); + TBN_TOOLBARCHANGE = -(708); + { Tab control } + TCM_ADJUSTRECT = 4904; + TCM_DELETEALLITEMS = 4873; + TCM_DELETEITEM = 4872; + TCM_GETCURFOCUS = 4911; + TCM_GETCURSEL = 4875; + TCM_GETIMAGELIST = 4866; + TCM_GETITEMW = 4924; + TCM_INSERTITEMW = 4926; + TCM_SETITEMW = 4925; + TCM_GETITEMA = 4869; + TCM_INSERTITEMA = 4871; + TCM_SETITEMA = 4870; + +{$ifdef UNICODE} + const + TCM_GETITEM = TCM_GETITEMW; //~wint, W was missing + TCM_INSERTITEM = TCM_INSERTITEMW; + TCM_SETITEM = TCM_SETITEMW; +{$else} + + const + TCM_GETITEM = TCM_GETITEMA; + TCM_INSERTITEM = TCM_INSERTITEMA; + TCM_SETITEM = TCM_SETITEMA; +{$endif} + { UNICODE } + + const + TCM_GETITEMCOUNT = 4868; + TCM_GETITEMRECT = 4874; + TCM_GETROWCOUNT = 4908; + TCM_GETTOOLTIPS = 4909; + TCM_HITTEST = 4877; + TCM_REMOVEIMAGE = 4906; + TCM_SETCURFOCUS = 4912; + TCM_SETCURSEL = 4876; + TCM_SETIMAGELIST = 4867; + TCM_SETITEMEXTRA = 4878; + TCM_SETITEMSIZE = 4905; + TCM_SETPADDING = 4907; + TCM_SETTOOLTIPS = 4910; + { Tab control notifications } + TCN_KEYDOWN = -(550); + TCN_SELCHANGE = -(551); + TCN_SELCHANGING = -(552); + { Tool tip control } + TTM_ACTIVATE = 1025; + TTM_ADDTOOLW = 1074; + TTM_DELTOOLW = 1075; + TTM_ENUMTOOLSW = 1082; + TTM_GETCURRENTTOOLW = 1083; + TTM_GETTEXTW = 1080; + TTM_GETTOOLINFOW = 1077; + TTM_HITTESTW = 1079; + TTM_NEWTOOLRECTW = 1076; + TTM_SETTOOLINFOW = 1078; + TTM_UPDATETIPTEXTW = 1081; + TTM_ADDTOOLA = 1028; + TTM_DELTOOLA = 1029; + TTM_ENUMTOOLSA = 1038; + TTM_GETCURRENTTOOLA = 1039; + TTM_GETTEXTA = 1035; + TTM_GETTOOLINFOA = 1032; + TTM_HITTESTA = 1034; + TTM_NEWTOOLRECTA = 1030; + TTM_SETTOOLINFOA = 1033; + TTM_UPDATETIPTEXTA = 1036; +{$ifdef UNICODE} + + const + TTM_ADDTOOL = TTM_ADDTOOLW; + TTM_DELTOOL = TTM_DELTOOLW; + TTM_ENUMTOOLS = TTM_ENUMTOOLSW; + TTM_GETCURRENTTOOL = TTM_GETCURRENTTOOLW; + TTM_GETTEXT = TTM_GETTEXTW; + TTM_GETTOOLINFO = TTM_GETTOOLINFOW; + TTM_HITTEST = TTM_HITTESTW; + TTM_NEWTOOLRECT = TTM_NEWTOOLRECTW; + TTM_SETTOOLINFO = TTM_SETTOOLINFOW; + TTM_UPDATETIPTEXT = TTM_UPDATETIPTEXTW; +{$else} + + const + TTM_ADDTOOL = TTM_ADDTOOLA; + TTM_DELTOOL = TTM_DELTOOLA; + TTM_ENUMTOOLS = TTM_ENUMTOOLSA; + TTM_GETCURRENTTOOL = TTM_GETCURRENTTOOLA; + TTM_GETTEXT = TTM_GETTEXTA; + TTM_GETTOOLINFO = TTM_GETTOOLINFOA; + TTM_HITTEST = TTM_HITTESTA; + TTM_NEWTOOLRECT = TTM_NEWTOOLRECTA; + TTM_SETTOOLINFO = TTM_SETTOOLINFOA; + TTM_UPDATETIPTEXT = TTM_UPDATETIPTEXTA; +{$endif} + { UNICODE } + + const + TTM_GETTOOLCOUNT = 1037; + TTM_RELAYEVENT = 1031; + TTM_SETDELAYTIME = 1027; + TTM_WINDOWFROMPOINT = 1040; + { Tool tip control notification } + TTN_NEEDTEXTW = -(530); + TTN_NEEDTEXTA = -(520); +{$ifdef UNICODE} + + const + TTN_NEEDTEXT = TTN_NEEDTEXTW; +{$else} + + const + TTN_NEEDTEXT = TTN_NEEDTEXTA; +{$endif} + { UNICODE } + + const + TTN_POP = -(522); + TTN_SHOW = -(521); + { Tree view control } + TVM_CREATEDRAGIMAGE = 4370; + TVM_DELETEITEM = 4353; + TVM_ENDEDITLABELNOW = 4374; + TVM_ENSUREVISIBLE = 4372; + TVM_EXPAND = 4354; + TVM_GETCOUNT = 4357; + TVM_GETEDITCONTROL = 4367; + TVM_GETIMAGELIST = 4360; + TVM_GETINDENT = 4358; + TVM_GETITEMRECT = 4356; + TVM_GETNEXTITEM = 4362; + TVM_GETVISIBLECOUNT = 4368; + TVM_HITTEST = 4369; + TVM_EDITLABELW = 4417; + TVM_GETISEARCHSTRINGW = 4416; + TVM_GETITEMW = 4414; + TVM_INSERTITEMW = 4402; + TVM_SETITEMW = 4415; + TVM_EDITLABELA = 4366; + TVM_GETISEARCHSTRINGA = 4375; + TVM_GETITEMA = 4364; + TVM_INSERTITEMA = 4352; + TVM_SETITEMA = 4365; +{$ifdef UNICODE} + + const + TVM_EDITLABEL = TVM_EDITLABELW; + TVM_GETISEARCHSTRING = TVM_GETISEARCHSTRINGW; + TVM_GETITEM = TVM_GETITEMW; + TVM_INSERTITEM = TVM_INSERTITEMW; + TVM_SETITEM = TVM_SETITEMW; +{$else} + + const + TVM_EDITLABEL = TVM_EDITLABELA; + TVM_GETISEARCHSTRING = TVM_GETISEARCHSTRINGA; + TVM_GETITEM = TVM_GETITEMA; + TVM_INSERTITEM = TVM_INSERTITEMA; + TVM_SETITEM = TVM_SETITEMA; +{$endif} + { UNICODE } + + const + TVM_SELECTITEM = 4363; + TVM_SETIMAGELIST = 4361; + TVM_SETINDENT = 4359; + TVM_SORTCHILDREN = 4371; + TVM_SORTCHILDRENCB = 4373; + { Tree view control notification } + TVN_KEYDOWN = -(412); + TVN_BEGINDRAGW = -(456); + TVN_BEGINLABELEDITW = -(459); + TVN_BEGINRDRAGW = -(457); + TVN_DELETEITEMW = -(458); + TVN_ENDLABELEDITW = -(460); + TVN_GETDISPINFOW = -(452); + TVN_ITEMEXPANDEDW = -(455); + TVN_ITEMEXPANDINGW = -(454); + TVN_SELCHANGEDW = -(451); + TVN_SELCHANGINGW = -(450); + TVN_SETDISPINFOW = -(453); + TVN_BEGINDRAGA = -(407); + TVN_BEGINLABELEDITA = -(410); + TVN_BEGINRDRAGA = -(408); + TVN_DELETEITEMA = -(409); + TVN_ENDLABELEDITA = -(411); + TVN_GETDISPINFOA = -(403); + TVN_ITEMEXPANDEDA = -(406); + TVN_ITEMEXPANDINGA = -(405); + TVN_SELCHANGEDA = -(402); + TVN_SELCHANGINGA = -(401); + TVN_SETDISPINFOA = -(404); +{$ifdef UNICODE} + + const + TVN_BEGINDRAG = TVN_BEGINDRAGW; + TVN_BEGINLABELEDIT = TVN_BEGINLABELEDITW; + TVN_BEGINRDRAG = TVN_BEGINRDRAGW; + TVN_DELETEITEM = TVN_DELETEITEMW; + TVN_ENDLABELEDIT = TVN_ENDLABELEDITW; + TVN_GETDISPINFO = TVN_GETDISPINFOW; + TVN_ITEMEXPANDED = TVN_ITEMEXPANDEDW; + TVN_ITEMEXPANDING = TVN_ITEMEXPANDINGW; + TVN_SELCHANGED = TVN_SELCHANGEDW; + TVN_SELCHANGING = TVN_SELCHANGINGW; + TVN_SETDISPINFO = TVN_SETDISPINFOW; +{$else} + + const + TVN_BEGINDRAG = TVN_BEGINDRAGA; + TVN_BEGINLABELEDIT = TVN_BEGINLABELEDITA; + TVN_BEGINRDRAG = TVN_BEGINRDRAGA; + TVN_DELETEITEM = TVN_DELETEITEMA; + TVN_ENDLABELEDIT = TVN_ENDLABELEDITA; + TVN_GETDISPINFO = TVN_GETDISPINFOA; + TVN_ITEMEXPANDED = TVN_ITEMEXPANDEDA; + TVN_ITEMEXPANDING = TVN_ITEMEXPANDINGA; + TVN_SELCHANGED = TVN_SELCHANGEDA; + TVN_SELCHANGING = TVN_SELCHANGINGA; + TVN_SETDISPINFO = TVN_SETDISPINFOA; +{$endif} + { UNICODE } + { Up/down control } + + const + UDM_GETACCEL = 1132; + UDM_GETBASE = 1134; + UDM_GETBUDDY = 1130; + UDM_GETPOS = 1128; + UDM_GETPOS32 = 1138; + UDM_GETRANGE = 1126; + UDM_GETRANGE32 = 1136; + UDM_SETACCEL = 1131; + UDM_SETBASE = 1133; + UDM_SETBUDDY = 1129; + UDM_SETPOS = 1127; + UDM_SETPOS32 = 1137; + UDM_SETRANGE = 1125; + UDM_SETRANGE32 = 1135; + { Up/down control notification } + UDN_DELTAPOS = -(722); + { Window messages } + WM_ACTIVATE = 6; + WM_ACTIVATEAPP = 28; + WM_ASKCBFORMATNAME = 780; + WM_CANCELJOURNAL = 75; + WM_CANCELMODE = 31; + WM_CAPTURECHANGED = 533; + WM_CHANGECBCHAIN = 781; + WM_CHAR = 258; + WM_CHARTOITEM = 47; + WM_CHILDACTIVATE = 34; + WM_CHOOSEFONT_GETLOGFONT = 1025; + WM_CHOOSEFONT_SETLOGFONT = 1125; + WM_CHOOSEFONT_SETFLAGS = 1126; + WM_CLEAR = 771; + WM_CLOSE = 16; + WM_COMMAND = 273; + WM_COMPACTING = 65; + WM_COMPAREITEM = 57; + WM_CONTEXTMENU = 123; + WM_COPY = 769; + WM_COPYDATA = 74; + WM_CREATE = 1; + WM_CTLCOLORBTN = 309; + WM_CTLCOLORDLG = 310; + WM_CTLCOLOREDIT = 307; + WM_CTLCOLORLISTBOX = 308; + WM_CTLCOLORMSGBOX = 306; + WM_CTLCOLORSCROLLBAR = 311; + WM_CTLCOLORSTATIC = 312; + WM_CUT = 768; + WM_DEADCHAR = 259; + WM_DELETEITEM = 45; + WM_DESTROY = 2; + WM_DESTROYCLIPBOARD = 775; + WM_DEVICECHANGE = 537; + WM_DEVMODECHANGE = 27; + WM_DISPLAYCHANGE = 126; + WM_DRAWCLIPBOARD = 776; + WM_DRAWITEM = 43; + WM_DROPFILES = 563; + WM_ENABLE = 10; + WM_ENDSESSION = 22; + WM_ENTERIDLE = 289; + WM_ENTERMENULOOP = 529; + WM_ENTERSIZEMOVE = 561; + WM_ERASEBKGND = 20; + WM_EXITMENULOOP = 530; + WM_EXITSIZEMOVE = 562; + WM_FONTCHANGE = 29; + WM_GETDLGCODE = 135; + WM_GETFONT = 49; + WM_GETHOTKEY = 51; + WM_GETICON = 127; + WM_GETMINMAXINFO = 36; + WM_GETTEXT = 13; + WM_GETTEXTLENGTH = 14; + WM_HELP = 83; + WM_HOTKEY = 786; + WM_HSCROLL = 276; + WM_HSCROLLCLIPBOARD = 782; + WM_ICONERASEBKGND = 39; + WM_IME_CHAR = 646; + WM_IME_COMPOSITION = 271; + WM_IME_COMPOSITIONFULL = 644; + WM_IME_CONTROL = 643; + WM_IME_ENDCOMPOSITION = 270; + WM_IME_KEYDOWN = 656; + WM_IME_KEYUP = 657; + WM_IME_NOTIFY = 642; + WM_IME_SELECT = 645; + WM_IME_SETCONTEXT = 641; + WM_IME_STARTCOMPOSITION = 269; + WM_INITDIALOG = 272; + WM_INITMENU = 278; + WM_INITMENUPOPUP = 279; + WM_INPUTLANGCHANGE = 81; + WM_INPUTLANGCHANGEREQUEST = 80; + WM_KEYDOWN = 256; + WM_KEYUP = 257; + WM_KILLFOCUS = 8; + WM_LBUTTONDBLCLK = 515; + WM_LBUTTONDOWN = 513; + WM_LBUTTONUP = 514; + WM_MBUTTONDBLCLK = 521; + WM_MBUTTONDOWN = 519; + WM_MBUTTONUP = 520; + WM_MDIACTIVATE = 546; + WM_MDICASCADE = 551; + WM_MDICREATE = 544; + WM_MDIDESTROY = 545; + WM_MDIGETACTIVE = 553; + WM_MDIICONARRANGE = 552; + WM_MDIMAXIMIZE = 549; + WM_MDINEXT = 548; + WM_MDIREFRESHMENU = 564; + WM_MDIRESTORE = 547; + WM_MDISETMENU = 560; + WM_MDITILE = 550; + WM_MEASUREITEM = 44; + WM_MENUCHAR = 288; + WM_MENUSELECT = 287; + WM_MOUSEACTIVATE = 33; + WM_MOUSEMOVE = 512; + WM_MOUSEWHEEL = 522; + WM_MOUSEHOVER = 673; + WM_MOUSELEAVE = 675; + WM_MOVE = 3; + WM_MOVING = 534; + WM_NCACTIVATE = 134; + WM_NCCALCSIZE = 131; + WM_NCCREATE = 129; + WM_NCDESTROY = 130; + WM_NCHITTEST = 132; + WM_NCLBUTTONDBLCLK = 163; + WM_NCLBUTTONDOWN = 161; + WM_NCLBUTTONUP = 162; + WM_NCMBUTTONDBLCLK = 169; + WM_NCMBUTTONDOWN = 167; + WM_NCMBUTTONUP = 168; + WM_NCMOUSEMOVE = 160; + WM_NCPAINT = 133; + WM_NCRBUTTONDBLCLK = 166; + WM_NCRBUTTONDOWN = 164; + WM_NCRBUTTONUP = 165; + WM_NEXTDLGCTL = 40; + WM_NOTIFY = 78; + WM_NOTIFYFORMAT = 85; + WM_NULL = 0; + WM_PAINT = 15; + WM_PAINTCLIPBOARD = 777; + WM_PAINTICON = 38; + WM_PALETTECHANGED = 785; + WM_PALETTEISCHANGING = 784; + WM_PARENTNOTIFY = 528; + WM_PASTE = 770; + WM_PENWINFIRST = 896; + WM_PENWINLAST = 911; + WM_POWER = 72; + WM_POWERBROADCAST = 536; + WM_PRINT = 791; + WM_PRINTCLIENT = 792; + WM_PSD_ENVSTAMPRECT = 1029; + WM_PSD_FULLPAGERECT = 1025; + WM_PSD_GREEKTEXTRECT = 1028; + WM_PSD_MARGINRECT = 1027; + WM_PSD_MINMARGINRECT = 1026; + WM_PSD_PAGESETUPDLG = 1024; + WM_PSD_YAFULLPAGERECT = 1030; + WM_QUERYDRAGICON = 55; + WM_QUERYENDSESSION = 17; + WM_QUERYNEWPALETTE = 783; + WM_QUERYOPEN = 19; + WM_QUEUESYNC = 35; + WM_QUIT = 18; + WM_RBUTTONDBLCLK = 518; + WM_RBUTTONDOWN = 516; + WM_RBUTTONUP = 517; + WM_RENDERALLFORMATS = 774; + WM_RENDERFORMAT = 773; + WM_SETCURSOR = 32; + WM_SETFOCUS = 7; + WM_SETFONT = 48; + WM_SETHOTKEY = 50; + WM_SETICON = 128; + WM_SETREDRAW = 11; + WM_SETTEXT = 12; + WM_SETTINGCHANGE = 26; + WM_SHOWWINDOW = 24; + WM_SIZE = 5; + WM_SIZECLIPBOARD = 779; + WM_SIZING = 532; + WM_SPOOLERSTATUS = 42; + WM_STYLECHANGED = 125; + WM_STYLECHANGING = 124; + WM_SYSCHAR = 262; + WM_SYSCOLORCHANGE = 21; + WM_SYSCOMMAND = 274; + WM_SYSDEADCHAR = 263; + WM_SYSKEYDOWN = 260; + WM_SYSKEYUP = 261; + WM_TCARD = 82; + WM_TIMECHANGE = 30; + WM_TIMER = 275; + WM_UNDO = 772; + WM_USER = 1024; + WM_USERCHANGED = 84; + WM_VKEYTOITEM = 46; + WM_VSCROLL = 277; + WM_VSCROLLCLIPBOARD = 778; + WM_WINDOWPOSCHANGED = 71; + WM_WINDOWPOSCHANGING = 70; + WM_WININICHANGE = 26; + { Window message ranges } + WM_KEYFIRST = 256; + WM_KEYLAST = 264; + WM_MOUSEFIRST = 512; + WM_MOUSELAST = 525; + WM_XBUTTONDOWN = 523; + WM_XBUTTONUP = 524; + WM_XBUTTONDBLCLK = 525; + +Type +{$ifdef MESSAGESUNIT} + + MSG = Windows.MSG; + TMessage = Windows.TMessage; + TWMSize = Windows.TWMSize; + TWMNoParams = Windows.TWMNoParams; + TWMScroll = Windows.TWMScroll; + TWMGetText = Windows.TWMGetText; + TWMKillFocus = Windows.TWMKillFocus; + TWMSetCursor = Windows.TWMSetCursor; + TWMSetFocus = Windows.TWMSetFocus; + TWMSetFont = Windows.TWMSetFont; + TWMShowWindow = Windows.TWMShowWindow; + TWMEraseBkgnd = Windows.TWMEraseBkgnd; + LPMSG = Windows.MSG; + tagMSG = Windows.tagMSG; + TMSG = Windows.TMSG; + PMSG = Windows.PMSG; + PMessage = Windows.PMessage; + TWMGetDlgCode = TWMNoParams; + TWMFontChange = TWMNoParams; + TWMGetFont = TWMNoParams; + TWMHScroll = TWMScroll; + TWMVScroll = TWMScroll; + TWMGetTextLength = TWMNoParams; + +{$else} + + MSG = record + hwnd : HWND; + message : UINT; + wParam : WPARAM; + lParam : LPARAM; + time : DWORD; + pt : POINT; + end; + + LPMSG = ^MSG; + tagMSG = MSG; + TMSG = MSG; + PMSG = ^MSG; + + + PMessage = ^TMessage; + TMessage = packed record {fields according to ICS} + msg : UINT; + case longint of + 0: ( + wParam : WPARAM; + lParam : LPARAM; + Result : LRESULT; + ); + 1: ( + wParamlo, + wParamhi : WORD; // Is there Windows type for half an wparam? + lParamlo, + lParamhi : WORD; + Resultlo, + Resulthi : WORD; + ); + end; + + TWMSize = packed record + Msg: Cardinal; + SizeType : LongInt; + Width : Word; + Height : Word; + Result : LongInt; + End; + + TWMNoParams = packed record + Msg : Cardinal; + Unused : array[0..3] of Word; + Result : Longint; + end; + + TWMGetDlgCode = TWMNoParams; + TWMFontChange = TWMNoParams; + TWMGetFont = TWMNoParams; + + TWMScroll = record + Msg : Cardinal; + ScrollCode : SmallInt; + Pos : SmallInt; + ScrollBar : HWND; + Result : LongInt; + end; + + TWMHScroll = TWMScroll; + TWMVScroll = TWMScroll; + + TWMGetText = packed record + Msg : Cardinal; + TextMax : LongInt; + Text : PChar; + Result : LongInt; + end; + + TWMGetTextLength = TWMNoParams; + + TWMKillFocus = packed record + Msg : Cardinal; + FocusedWnd : HWND; + UnUsed : LongInt; + Result : LongInt; + End; + + TWMSetCursor = packed record + Msg : Cardinal; + CursorWnd : HWND; + HitTest : Word; + MouseMsg : Word; + Result : LongInt; + end; + + TWMSetFocus = packed record + Msg : Cardinal; + FocusedWnd : HWND; + Unused : LongInt; + Result : LongInt; + end; + + TWMSetFont = packed record + Msg : Cardinal; + Font : HFONT; + Redraw : WordBool; + Unused : Word; + Result : LongInt; + end; + + TWMShowWindow = packed record + Msg : Cardinal; + Show : BOOL; + Status : LongInt; + Result : LongInt; + end; + + TWMEraseBkgnd = packed record + Msg: Cardinal; + DC: HDC; + Unused: Longint; + Result: Longint; + end; + +{$endif messagesunit} + +{$endif read_interface} + diff --git a/rtl/wince/wininc/redef.inc b/rtl/wince/wininc/redef.inc new file mode 100644 index 0000000000..f986b30575 --- /dev/null +++ b/rtl/wince/wininc/redef.inc @@ -0,0 +1,1104 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 1999-2001 by the Free Pascal development team + + This file defines type names as they are used by Delphi + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + ********************************************************************** + + Changes : + + 22/15/2005 update for wince4.2 port, orinaudo@gmail.com + +} + +{$ifdef read_interface} + +//begin common win32 & wince + +//end common win32 & wince + +{$ifdef WINCE} +//begin wince only + +//end wince only +{$endif WINCE} + +{$ifdef WIN32} +//begin win32 or wince not checked +type + PIID = PGUID; + TIID = TGUID; + THANDLE = HANDLE; + + PSmallRect = ^TSmallRect; + TSmallRect = SMALL_RECT; + + PCharInfo = ^TCharInfo; + TCharInfo = _CHAR_INFO; + + TFarProc = FARPROC; + TFNDlgProc = FARPROC; + TFNThreadStartRoutine = FARPROC; + TFNTimerAPCRoutine = FARPROC; + TFNFiberStartRoutine = FARPROC; + + PObjectTypeList = ^TObjectTypeList; + _OBJECT_TYPE_LIST = record + Level: WORD; + Sbz: WORD; + ObjectType: PGUID; + end; + TObjectTypeList = _OBJECT_TYPE_LIST; + OBJECT_TYPE_LIST = _OBJECT_TYPE_LIST; + + AUDIT_EVENT_TYPE = DWORD; + + PBlendFunction = ^TBlendFunction; + _BLENDFUNCTION = packed record + BlendOp: BYTE; + BlendFlags: BYTE; + SourceConstantAlpha: BYTE; + AlphaFormat: BYTE; + end; + TBlendFunction = _BLENDFUNCTION; + BLENDFUNCTION = _BLENDFUNCTION; + + _WIN_CERTIFICATE = Packed Record + dwLength : DWord; + wRevision : Word; + wCertificateType : Word; + bCertificate : Array[0..0] of Byte; + End; + TWinCertificate = _WIN_CERTIFICATE; + PWinCertificate = ^TWinCertificate; + + TMaxLogPalette = Packed Record + palVersion : Word; + palNumEntries : Word; + palPalEntry : array[Byte] of TPaletteEntry; + end; + PMaxLogPalette = ^TMaxLogPalette; + + +const + { dll names } + advapi32 = 'advapi32.dll'; + kernel32 = 'kernel32.dll'; + mpr = 'mpr.dll'; + version = 'version.dll'; + comctl32 = 'comctl32.dll'; + gdi32 = 'gdi32.dll'; + opengl32 = 'opengl32.dll'; + user32 = 'user32.dll'; + wintrust = 'wintrust.dll'; + + { Openfile Share modes normally declared in sysutils } + fmShareCompat = $00000000; + fmShareExclusive = $10; + fmShareDenyWrite = $20; + fmShareDenyRead = $30; + fmShareDenyNone = $40; + + { HRESULT codes, delphilike } + NOERROR = 0; + +const + { Severity values } + FACILITY_NT_BIT = $10000000; + HFILE_ERROR = HFILE(-1); + +// +// A language ID is a 16 bit value which is the combination of a +// primary language ID and a secondary language ID. The bits are +// allocated as follows: +// +// +-----------------------+-------------------------+ +// | Sublanguage ID | Primary Language ID | +// +-----------------------+-------------------------+ +// 15 10 9 0 bit +// +// +// Language ID creation/extraction macros: +// +// MAKELANGID - construct language id from a primary language id and +// a sublanguage id. +// PRIMARYLANGID - extract primary language id from a language id. +// SUBLANGID - extract sublanguage id from a language id. +// + +function MAKELANGID(PrimaryLang, SubLang: USHORT): WORD; +function PRIMARYLANGID(LangId: WORD): WORD; +function SUBLANGID(LangId: WORD): WORD; + +// +// A locale ID is a 32 bit value which is the combination of a +// language ID, a sort ID, and a reserved area. The bits are +// allocated as follows: +// +// +-------------+---------+-------------------------+ +// | Reserved | Sort ID | Language ID | +// +-------------+---------+-------------------------+ +// 31 20 19 16 15 0 bit +// +// +// Locale ID creation/extraction macros: +// +// MAKELCID - construct the locale id from a language id and a sort id. +// MAKESORTLCID - construct the locale id from a language id, sort id, and sort version. +// LANGIDFROMLCID - extract the language id from a locale id. +// SORTIDFROMLCID - extract the sort id from a locale id. +// SORTVERSIONFROMLCID - extract the sort version from a locale id. +// + +const + NLS_VALID_LOCALE_MASK = $000fffff; //winnt + +function MAKELCID(LangId, SortId: WORD): DWORD; //winnt +function MAKESORTLCID(LangId, SortId, SortVersion: WORD): DWORD; //winnt +function LANGIDFROMLCID(LocaleId: LCID): WORD; //winnt +function SORTIDFROMLCID(LocaleId: LCID): WORD; //winnt +function SORTVERSIONFROMLCID(LocaleId: LCID): WORD; //winnt + +// +// Default System and User IDs for language and locale. +// + +function LANG_SYSTEM_DEFAULT: WORD; //winnt +function LANG_USER_DEFAULT: WORD; //winnt +function LOCALE_SYSTEM_DEFAULT: DWORD; //+winnt +function LOCALE_USER_DEFAULT: DWORD; //+winnt +function LOCALE_NEUTRAL: DWORD; //winnt +function LOCALE_INVARIANT: DWORD; //winnt + + +function Succeeded(Status : HRESULT) : BOOL; +function Failed(Status : HRESULT) : BOOL; +function IsError(Status : HRESULT) : BOOL; +function HResultCode(hr : HRESULT) : Longint; +function HResultFacility(hr : HRESULT) : Longint; +function HResultSeverity(hr : HRESULT) : Longint; +function MakeResult(p1,p2,mask : Longint) : HRESULT; +function HResultFromWin32(x : Longint) : HRESULT; +function HResultFromNT(x : Longint) : HRESULT; + +procedure InitializeCriticalSection(var CriticalSection : TRTLCriticalSection); external 'kernel32' name 'InitializeCriticalSection'; +procedure EnterCriticalSection(var CriticalSection : TRTLCriticalSection); external 'kernel32' name 'EnterCriticalSection'; +procedure LeaveCriticalSection(var CriticalSection : TRTLCriticalSection); external 'kernel32' name 'LeaveCriticalSection'; +procedure DeleteCriticalSection(var CriticalSection : TRTLCriticalSection); external 'kernel32' name 'DeleteCriticalSection'; +function InitializeCriticalSectionAndSpinCount(var CriticalSection : TRTLCriticalSection;dwSpinCount : DWORD) : BOOL; external 'kernel32' name 'InitializeCriticalSectionAndSpinCount'; +function SetCriticalSectionSpinCount(var CriticalSection : TRTLCriticalSection;dwSpinCount : DWORD ): DWORD; external 'kernel32' name 'SetCriticalSectionSpinCount'; +function TryEnterCriticalSection(var CriticalSection : TRTLCriticalSection) : BOOL; external 'kernel32' name 'TryEnterCriticalSection'; + +//function _lwrite(hFile: HFILE; const lpBuffer: LPCSTR; uBytes: UINT): UINT; external 'kernel32' name '_lwrite'; +//function AccessCheck(pSecurityDescriptor: PSecurityDescriptor; ClientToken: THandle; DesiredAccess: DWORD; const GenericMapping: TGenericMapping; var PrivilegeSet: TPrivilegeSet; var PrivilegeSetLength: DWORD; var GrantedAccess: DWORD; +// var AccessStatus: BOOL): BOOL; external 'advapi32' name 'AccessCheck'; +//function AccessCheckAndAuditAlarm(SubsystemName: PChar; HandleId: Pointer; ObjectTypeName, ObjectName: PChar; SecurityDescriptor: PSecurityDescriptor; DesiredAccess: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; +// var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; external 'advapi32' name 'AccessCheckAndAuditAlarmA'; +//function AccessCheckAndAuditAlarmA(SubsystemName: LPCSTR; HandleId: Pointer; ObjectTypeName, ObjectName: LPCSTR; SecurityDescriptor: PSecurityDescriptor; DesiredAccess: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; +// var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; external 'advapi32' name 'AccessCheckAndAuditAlarmA'; +//function AccessCheckAndAuditAlarmW(SubsystemName: LPWSTR; HandleId: Pointer; ObjectTypeName, ObjectName: LPWSTR; SecurityDescriptor: PSecurityDescriptor; DesiredAccess: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; +// var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; external 'advapi32' name 'AccessCheckAndAuditAlarmW'; +//function AccessCheckByType(pSecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; ClientToken: THandle; DesiredAccess: DWORD; ObjectTypeList: PObjectTypeList; const GenericMapping: TGenericMapping; ObjectTypeListLength: DWORD; +// var PrivilegeSet: TPrivilegeSet; var PrivilegeSetLength: DWORD; var GrantedAccess: DWORD; var AccessStatus: BOOL): BOOL;external 'advapi32' name 'AccessCheckByType'; +//function AccessCheckByTypeAndAuditAlarm(SubsystemName: PChar; HandleId: Pointer; ObjectTypeName, ObjectName: PChar; SecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD; +// ObjectTypeList: PObjectTypeList; ObjectTypeListLength: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; +// external 'advapi32' name 'AccessCheckByTypeAndAuditAlarm'; +//function AccessCheckByTypeAndAuditAlarmA(SubsystemName: LPCSTR; HandleId: Pointer; ObjectTypeName, ObjectName: LPCSTR; SecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD; +// ObjectTypeList: PObjectTypeList; ObjectTypeListLength: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; +// external 'advapi32' name 'AccessCheckByTypeAndAuditAlarmA'; +//function AccessCheckByTypeAndAuditAlarmW(SubsystemName: LPWSTR; HandleId: Pointer; ObjectTypeName, ObjectName: LPWSTR; SecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; Flags: DWORD; +// ObjectTypeList: PObjectTypeList; ObjectTypeListLength: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; var GrantedAccess: DWORD; var AccessStatus, pfGenerateOnClose: BOOL): BOOL; +// external 'advapi32' name 'AccessCheckByTypeAndAuditAlarmW'; +//function AccessCheckByTypeResultList(pSecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; ClientToken: THandle; DesiredAccess: DWORD; ObjectTypeList: PObjectTypeList; const GenericMapping: TGenericMapping; ObjectTypeListLength: DWORD; +// var PrivilegeSet: TPrivilegeSet; var PrivilegeSetLength: DWORD; var GrantedAccess: DWORD; var AccessStatusList: DWORD): BOOL;external 'advapi32' name 'AccessCheckByTypeResultList'; +//function AccessCheckByTypeResultListAndAuditAlarm(SubsystemName: PChar; HandleId: Pointer; ObjectTypeName, ObjectName: PChar; SecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; +// Flags: DWORD; ObjectTypeList: PObjectTypeList; ObjectTypeListLength: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; var GrantedAccess: DWORD; var AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; +// external 'advapi32' name 'AccessCheckByTypeResultListAndAuditAlarmA'; +//function AccessCheckByTypeResultListAndAuditAlarmA(SubsystemName: LPCSTR; HandleId: Pointer; ObjectTypeName, ObjectName: LPCSTR; SecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; +// Flags: DWORD; ObjectTypeList: PObjectTypeList; ObjectTypeListLength: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; var GrantedAccess: DWORD; var AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; +// external 'advapi32' name 'AccessCheckByTypeResultListAndAuditAlarmA'; +//function AccessCheckByTypeResultListAndAuditAlarmW(SubsystemName: LPWSTR; HandleId: Pointer; ObjectTypeName, ObjectName: LPWSTR; SecurityDescriptor: PSecurityDescriptor; PrincipalSelfSid: PSID; DesiredAccess: DWORD; AuditType: AUDIT_EVENT_TYPE; +// Flags: DWORD; ObjectTypeList: PObjectTypeList; ObjectTypeListLength: DWORD; const GenericMapping: TGenericMapping; ObjectCreation: BOOL; var GrantedAccess: DWORD; var AccessStatusList: DWORD; var pfGenerateOnClose: BOOL): BOOL; +// external 'advapi32' name 'AccessCheckByTypeResultListAndAuditAlarmW'; +//function AddAccessAllowedAce(var pAcl: TACL; dwAceRevision: DWORD; AccessMask: DWORD; pSid: PSID): BOOL; external 'advapi32' name 'AddAccessAllowedAce'; +//function AddAccessAllowedAceEx(var pAcl: TACL; dwAceRevision: DWORD; AceFlags: DWORD; AccessMask: DWORD; pSid: PSID): BOOL;external 'advapi32' name 'AddAccessAllowedAceEx'; +//function AddAccessAllowedObjectAce(var pAcl: TACL; dwAceRevision: DWORD; AceFlags: DWORD; AccessMask: DWORD; ObjectTypeGuid, InheritedObjectTypeGuid: PGuid; pSid: Pointer): BOOL;external 'advapi32' name 'AddAccessAllowedObjectAce'; +//function AddAccessDeniedAce(var pAcl: TACL; dwAceRevision: DWORD; AccessMask: DWORD; pSid: PSID): BOOL; external 'advapi32' name 'AddAccessDeniedAce'; +//function AddAccessDeniedAceEx(var pAcl: TACL; dwAceRevision: DWORD; ACEFlags: DWORD; AccessMask: DWORD; pSid: PSID): BOOL;external 'advapi32' name 'AddAccessDeniedAceEx'; +//function AddAccessDeniedObjectAce(var pAcl: TACL; dwAceRevision: DWORD; AceFlags: DWORD; AccessMask: DWORD; ObjectTypeGuid, InheritedObjectTypeGuid: PGuid; pSid: Pointer): BOOL;external 'advapi32' name 'AddAccessDeniedObjectAce'; +//function AddAce(var pAcl: TACL; dwAceRevision, dwStartingAceIndex: DWORD; pAceList: Pointer; nAceListLength: DWORD): BOOL; external 'advapi32' name 'AddAce'; +//function AddAuditAccessAce(var pAcl: TACL; dwAceRevision: DWORD; dwAccessMask: DWORD; pSid: Pointer; bAuditSuccess, bAuditFailure: BOOL): BOOL; external 'advapi32' name 'AddAuditAccessAce'; +//function AddAuditAccessAceEx(var pAcl: TACL; dwAceRevision: DWORD; AceFlags: DWORD; dwAccessMask: DWORD; pSid: Pointer; bAuditSuccess, bAuditFailure: BOOL): BOOL;external 'advapi32' name 'AddAuditAccessAceEx'; +//function AddAuditAccessObjectAce(var pAcl: TACL; dwAceRevision: DWORD; AceFlags: DWORD; AccessMask: DWORD; ObjectTypeGuid, InheritedObjectTypeGuid: PGuid; pSid: Pointer; bAuditSuccess, bAuditFailure: BOOL): BOOL; +// external 'advapi32' name 'AddAuditAccessObjectAce'; +//function AdjustTokenGroups(TokenHandle: THandle; ResetToDefault: BOOL; const NewState: TTokenGroups; BufferLength: DWORD; var PreviousState: TTokenGroups; var ReturnLength: DWORD): BOOL; external 'advapi32' name 'AdjustTokenGroups'; +function AdjustTokenPrivileges(TokenHandle: THandle; DisableAllPrivileges: BOOL; const NewState: TTokenPrivileges; BufferLength: DWORD; + var PreviousState: TTokenPrivileges; var ReturnLength: DWORD): BOOL; external 'advapi32' name 'AdjustTokenPrivileges'; +function AdjustWindowRect(var lpRect: TRect; dwStyle: DWORD; bMenu: BOOL): BOOL; external 'user32' name 'AdjustWindowRect'; +function AdjustWindowRectEx(var lpRect: TRect; dwStyle: DWORD; bMenu: BOOL; dwExStyle: DWORD): BOOL; external 'user32' name 'AdjustWindowRectEx'; +function AllocateAndInitializeSid(const pIdentifierAuthority: TSIDIdentifierAuthority; nSubAuthorityCount: Byte; nSubAuthority0, nSubAuthority1: DWORD; nSubAuthority2, nSubAuthority3, nSubAuthority4: DWORD; + nSubAuthority5, nSubAuthority6, nSubAuthority7:DWORD; var pSid: Pointer): BOOL; external 'advapi32' name 'AllocateAndInitializeSid'; +function AllocateLocallyUniqueId(var Luid: TLargeInteger): BOOL; external 'advapi32' name 'AllocateLocallyUniqueId'; +//function AlphaDIBBlend(DC: HDC; p2, p3, p4, p5: Integer; const p6: Pointer; const p7: PBitmapInfo; p8: UINT; p9, p10, p11, p12: Integer; p13: TBlendFunction): BOOL;external 'gdi32' name 'AlphaDIBBlend'; +function BackupRead(hFile: THandle; lpBuffer: PByte; nNumberOfBytesToRead: DWORD; var lpNumberOfBytesRead: DWORD; bAbort: BOOL; bProcessSecurity: BOOL; var lpContext: Pointer): BOOL; external 'kernel32' name 'BackupRead'; +function BackupSeek(hFile: THandle; dwLowBytesToSeek, dwHighBytesToSeek: DWORD; var lpdwLowByteSeeked, lpdwHighByteSeeked: DWORD; lpContext: Pointer): BOOL; external 'kernel32' name 'BackupSeek'; +function BackupWrite(hFile: THandle; lpBuffer: PByte; nNumberOfBytesToWrite: DWORD; var lpNumberOfBytesWritten: DWORD; bAbort, bProcessSecurity: BOOL; var lpContext: Pointer): BOOL; external 'kernel32' name 'BackupWrite'; +function BeginPaint(hWnd: HWND; var lpPaint: TPaintStruct): HDC; external 'user32' name 'BeginPaint'; +function BuildCommDCB(lpDef: PChar; var lpDCB: TDCB): BOOL;external 'kernel32' name 'BuildCommDCBA'; +function BuildCommDCBA(lpDef: LPCSTR; var lpDCB: TDCB): BOOL; external 'kernel32' name 'BuildCommDCBA'; +function BuildCommDCBAndTimeouts(lpDef: PChar; var lpDCB: TDCB; var lpCommTimeouts: TCommTimeouts): BOOL;external 'kernel32' name 'BuildCommDCBAndTimeoutsA'; +function BuildCommDCBAndTimeoutsA(lpDef: LPCSTR; var lpDCB: TDCB; var lpCommTimeouts: TCommTimeouts): BOOL; external 'kernel32' name 'BuildCommDCBAndTimeoutsA'; +function BuildCommDCBAndTimeoutsW(lpDef: LPWSTR; var lpDCB: TDCB; var lpCommTimeouts: TCommTimeouts): BOOL; external 'kernel32' name 'BuildCommDCBAndTimeoutsW'; +function BuildCommDCBW(lpDef: LPWSTR; var lpDCB: TDCB): BOOL; external 'kernel32' name 'BuildCommDCBW'; +function CallMsgFilter(var lpMsg: TMsg; nCode: Integer): BOOL;external 'user32' name 'CallMsgFilterA'; +function CallMsgFilterA(var lpMsg: TMsg; nCode: Integer): BOOL; external 'user32' name 'CallMsgFilterA'; +function CallMsgFilterW(var lpMsg: TMsg; nCode: Integer): BOOL; external 'user32' name 'CallMsgFilterW'; +function CallNamedPipe(lpNamedPipeName: PChar; lpInBuffer: Pointer; nInBufferSize: DWORD; lpOutBuffer: Pointer; nOutBufferSize: DWORD; var lpBytesRead: DWORD; nTimeOut: DWORD): BOOL;external 'kernel32' name 'CallNamedPipeA'; +function CallNamedPipeA(lpNamedPipeName: LPCSTR; lpInBuffer: Pointer; nInBufferSize: DWORD; lpOutBuffer: Pointer; nOutBufferSize: DWORD; var lpBytesRead: DWORD; nTimeOut: DWORD): BOOL; external 'kernel32' name 'CallNamedPipeA'; +function CallNamedPipeW(lpNamedPipeName: LPWSTR; lpInBuffer: Pointer; nInBufferSize: DWORD; lpOutBuffer: Pointer; nOutBufferSize: DWORD; var lpBytesRead: DWORD; nTimeOut: DWORD): BOOL; external 'kernel32' name 'CallNamedPipeW'; +function CoRegisterClassObject(const _para1:TCLSID; _para2:IUnknown; _para3:DWORD; _para4:DWORD; out_para5:DWORD):HRESULT;external 'ole32.dll' name 'CoRegisterClassObject'; +function ChangeDisplaySettings(var lpDevMode: TDeviceMode; dwFlags: DWORD): Longint;external 'user32' name 'ChangeDisplaySettingsA'; +function ChangeDisplaySettingsA(var lpDevMode: TDeviceModeA; dwFlags: DWORD): Longint; external 'user32' name 'ChangeDisplaySettingsA'; +{$ifdef support_smartlink} +function ChangeDisplaySettingsEx(lpszDeviceName: PChar; var lpDevMode: TDeviceMode; wnd: HWND; dwFlags: DWORD; lParam: Pointer): Longint;external 'user32' name 'ChangeDisplaySettingsExA'; +function ChangeDisplaySettingsExA(lpszDeviceName: LPCSTR; var lpDevMode: TDeviceModeA; wnd: HWND; dwFlags: DWORD; lParam: Pointer): Longint;external 'user32' name 'ChangeDisplaySettingsExA'; +function ChangeDisplaySettingsExW(lpszDeviceName: LPWSTR; var lpDevMode: TDeviceModeW; wnd: HWND; dwFlags: DWORD; lParam: Pointer): Longint;external 'user32' name 'ChangeDisplaySettingsExW'; +{$endif support_smartlink} +function ChangeDisplaySettingsW(var lpDevMode: TDeviceModeW; dwFlags: DWORD): Longint; external 'user32' name 'ChangeDisplaySettingsW'; +//function CheckColorsInGamut(DC: HDC; var RGBQuads, Results; Count: DWORD): BOOL; external 'gdi32' name 'CheckColorsInGamut'; +function ChoosePixelFormat(_para1:HDC; var _para2:PIXELFORMATDESCRIPTOR):longint; external 'gdi32' name 'ChoosePixelFormat'; +function ClearCommError(hFile: THandle; var lpErrors: DWORD; lpStat: PComStat): BOOL; external 'kernel32' name 'ClearCommError'; +function ClientToScreen(hWnd: HWND; var lpPoint: TPoint): BOOL; external 'user32' name 'ClientToScreen'; +function ClipCursor(var lpRect:RECT):WINBOOL; external 'user32' name 'ClipCursor'; +//function CombineTransform(var p1: TXForm; const p2, p3: TXForm): BOOL; external 'gdi32' name 'CombineTransform'; +function CommConfigDialog(lpszName: PChar; hWnd: HWND; var lpCC: TCommConfig): BOOL;external 'kernel32' name 'CommConfigDialogA'; +function CommConfigDialogA(lpszName: LPCSTR; hWnd: HWND; var lpCC: TCommConfig): BOOL; external 'kernel32' name 'CommConfigDialogA'; +function CommConfigDialogW(lpszName: LPWSTR; hWnd: HWND; var lpCC: TCommConfig): BOOL; external 'kernel32' name 'CommConfigDialogW'; +//function CompareFileTime(const lpFileTime1, lpFileTime2: TFileTime): Longint; external 'kernel32' name 'CompareFileTime'; +//function ConvertToAutoInheritPrivateObjectSecurity(ParentDescriptor, CurrentSecurityDescriptor: PSecurityDescriptor; var NewDescriptor: PSecurityDescriptor; ObjectType: PGUID; IsDirectoryObject: BOOL; const GenericMapping: TGenericMapping): BOOL; +// external 'advapi32' name 'ConvertToAutoInheritPrivateObjectSecurity'; +function CopyAcceleratorTable(hAccelSrc: HACCEL; var lpAccelDst; cAccelEntries: Integer): Integer;external 'user32' name 'CopyAcceleratorTableA'; +function CopyAcceleratorTableA(hAccelSrc: HACCEL; var lpAccelDst; cAccelEntries: Integer): Integer; external 'user32' name 'CopyAcceleratorTableA'; +function CopyAcceleratorTableW(hAccelSrc: HACCEL; var lpAccelDst; cAccelEntries: Integer): Integer; external 'user32' name 'CopyAcceleratorTableW'; +function CopyRect(var lprcDst: TRect; const lprcSrc: TRect): BOOL; external 'user32' name 'CopyRect'; +function CreateAcceleratorTable(var Accel; Count: Integer): HACCEL;external 'user32' name 'CreateAcceleratorTableA'; +function CreateAcceleratorTableA(var Accel; Count: Integer): HACCEL; external 'user32' name 'CreateAcceleratorTableA'; +function CreateAcceleratorTableW(var Accel; Count: Integer): HACCEL; external 'user32' name 'CreateAcceleratorTableW'; +//function CreateBitmapIndirect(const p1: TBitmap): HBITMAP; external 'gdi32' name 'CreateBitmapIndirect'; +//function CreateBrushIndirect(const p1: TLogBrush): HBRUSH; external 'gdi32' name 'CreateBrushIndirect'; +function CreateColorSpace(var ColorSpace: TLogColorSpace): HCOLORSPACE;external 'gdi32' name 'CreateColorSpaceA'; +function CreateColorSpaceA(var ColorSpace: TLogColorSpaceA): HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceA'; +//function CreateColorSpaceW(var ColorSpace: TLogColorSpaceW): HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceW'; +function CreateDialogIndirectParam(hInstance: HINST; const lpTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): HWND;external 'user32' name 'CreateDialogIndirectParamA'; +//function CreateDialogIndirectParamA(hInstance: HINST; const lpTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): HWND; external 'user32' name 'CreateDialogIndirectParamA'; +//function CreateDialogIndirectParamW(hInstance: HINST; const lpTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): HWND; external 'user32' name 'CreateDialogIndirectParamW'; +//function CreateDIBitmap(DC: HDC; var InfoHeader: TBitmapInfoHeader; dwUsage: DWORD; InitBits: PChar; var InitInfo: TBitmapInfo; wUsage: UINT): HBITMAP; external 'gdi32' name 'CreateDIBitmap'; +//function CreateDIBPatternBrushPt(const p1: Pointer; p2: UINT): HBRUSH; external 'gdi32' name 'CreateDIBPatternBrushPt'; +//function CreateDIBSection(DC: HDC; const p2: TBitmapInfo; p3: UINT; var p4: Pointer; p5: THandle; p6: DWORD): HBITMAP; external 'gdi32' name 'CreateDIBSection'; +//function CreateEllipticRgnIndirect(const p1: TRect): HRGN; external 'gdi32' name 'CreateEllipticRgnIndirect'; +//function CreateFontIndirect(const p1: TLogFont): HFONT;external 'gdi32' name 'CreateFontIndirectA'; +//function CreateFontIndirectA(const p1: TLogFontA): HFONT; external 'gdi32' name 'CreateFontIndirectA'; +//function CreateFontIndirectEx(const p1: PEnumLogFontExDV): HFONT;external 'gdi32' name 'CreateFontIndirectExA'; +//function CreateFontIndirectExA(const p1: PEnumLogFontExDVA): HFONT;external 'gdi32' name 'CreateFontIndirectExA'; +//function CreateFontIndirectExW(const p1: PEnumLogFontExDVW): HFONT;external 'gdi32' name 'CreateFontIndirectExW'; +//function CreateFontIndirectW(const p1: TLogFontW): HFONT; external 'gdi32' name 'CreateFontIndirectW'; +function CreateIconIndirect(var piconinfo: TIconInfo): HICON; external 'user32' name 'CreateIconIndirect'; +//function CreatePalette(const LogPalette: TLogPalette): HPalette; external 'gdi32' name 'CreatePalette'; +//function CreatePenIndirect(const LogPen: TLogPen): HPEN; external 'gdi32' name 'CreatePenIndirect'; +function CreatePipe(var hReadPipe, hWritePipe: THandle; lpPipeAttributes: PSecurityAttributes; nSize: DWORD): BOOL; external 'kernel32' name 'CreatePipe'; +function CreatePolygonRgn(const Points; Count, FillMode: Integer): HRGN; external 'gdi32' name 'CreatePolygonRgn'; +function CreatePolyPolygonRgn(const pPtStructs; const pIntArray; p3, p4: Integer): HRGN; external 'gdi32' name 'CreatePolyPolygonRgn'; +//function CreatePrivateObjectSecurity(ParentDescriptor, CreatorDescriptor: PSecurityDescriptor; var NewDescriptor: PSecurityDescriptor; IsDirectoryObject: BOOL; Token: THandle; const GenericMapping: TGenericMapping): BOOL; +// external 'advapi32' name 'CreatePrivateObjectSecurity'; +//function CreatePrivateObjectSecurityEx(ParentDescriptor, CreatorDescriptor: PSecurityDescriptor; var NewDescriptor: PSecurityDescriptor; ObjectType: PGUID; IsContainerObject: BOOL; AutoInheritFlags: ULONG; Token: THandle; +// const GenericMapping: TGenericMapping): BOOL;external 'advapi32' name 'CreatePrivateObjectSecurityEx'; +function CreateProcess(lpApplicationName: PChar; lpCommandLine: PChar; lpProcessAttributes, lpThreadAttributes: PSecurityAttributes; bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer; lpCurrentDirectory: PChar; + const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): BOOL;external 'kernel32' name 'CreateProcessA'; +function CreateProcessA(lpApplicationName: LPCSTR; lpCommandLine: LPCSTR; lpProcessAttributes, lpThreadAttributes: PSecurityAttributes; bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer; lpCurrentDirectory: LPCSTR; + const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): BOOL; external 'kernel32' name 'CreateProcessA'; +//function CreateProcessAsUser(hToken: THandle; lpApplicationName: PChar; lpCommandLine: PChar; lpProcessAttributes: PSecurityAttributes; lpThreadAttributes: PSecurityAttributes; bInheritHandles: BOOL; dwCreationFlags: DWORD; +// lpEnvironment: Pointer; lpCurrentDirectory: PChar; const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): BOOL;external 'advapi32' name 'CreateProcessAsUserA'; +//function CreateProcessAsUserA(hToken: THandle; lpApplicationName: LPCSTR; lpCommandLine: LPCSTR; lpProcessAttributes: PSecurityAttributes; lpThreadAttributes: PSecurityAttributes; bInheritHandles: BOOL; dwCreationFlags: DWORD; +// lpEnvironment: Pointer; lpCurrentDirectory: LPCSTR; const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): BOOL; external 'advapi32' name 'CreateProcessAsUserA'; +//function CreateProcessAsUserW(hToken: THandle; lpApplicationName: LPWSTR; lpCommandLine: LPWSTR; lpProcessAttributes: PSecurityAttributes; lpThreadAttributes: PSecurityAttributes; bInheritHandles: BOOL; dwCreationFlags: DWORD; +// lpEnvironment: Pointer; lpCurrentDirectory: LPWSTR; const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): BOOL; external 'advapi32' name 'CreateProcessAsUserW'; +function CreateProcessW(lpApplicationName: LPWSTR; lpCommandLine: LPWSTR; lpProcessAttributes, lpThreadAttributes: PSecurityAttributes; bInheritHandles: BOOL; dwCreationFlags: DWORD; lpEnvironment: Pointer; lpCurrentDirectory: LPWSTR; + const lpStartupInfo: TStartupInfo; var lpProcessInformation: TProcessInformation): BOOL; external 'kernel32' name 'CreateProcessW'; +//function CreateRectRgnIndirect(const p1: TRect): HRGN; external 'gdi32' name 'CreateRectRgnIndirect'; +function CreateRemoteThread(hProcess: THandle; lpThreadAttributes: Pointer; dwStackSize: DWORD; lpStartAddress: TFNThreadStartRoutine; lpParameter: Pointer; dwCreationFlags: DWORD; var lpThreadId: DWORD): THandle; + external 'kernel32' name 'CreateRemoteThread'; +function CreateThread(lpThreadAttributes: Pointer; dwStackSize: DWORD; lpStartAddress: TFNThreadStartRoutine; lpParameter: Pointer; dwCreationFlags: DWORD; var lpThreadId: DWORD): THandle; external 'kernel32' name 'CreateThread'; +function DdeSetQualityOfService(hWndClient: HWnd; const pqosNew: TSecurityQualityOfService; pqosPrev: PSecurityQualityOfService): BOOL;external 'user32' name 'DdeSetQualityOfService'; +//function DeleteAce(var pAcl: TACL; dwAceIndex: DWORD): BOOL; external 'advapi32' name 'DeleteAce'; +function DescribePixelFormat(DC: HDC; p2: Integer; p3: UINT; var p4: TPixelFormatDescriptor): BOOL; external 'gdi32' name 'DescribePixelFormat'; +//function DestroyPrivateObjectSecurity(var ObjectDescriptor: PSecurityDescriptor): BOOL; external 'advapi32' name 'DestroyPrivateObjectSecurity'; +function DeviceIoControl(hDevice: THandle; dwIoControlCode: DWORD; lpInBuffer: Pointer; nInBufferSize: DWORD; lpOutBuffer: Pointer; nOutBufferSize: DWORD; var lpBytesReturned: DWORD; lpOverlapped: POverlapped): BOOL; + external 'kernel32' name 'DeviceIoControl'; +function DialogBoxIndirectParam(hInstance: HINST; const lpDialogTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): Integer;external 'user32' name 'DialogBoxIndirectParamA'; +function DialogBoxIndirectParamA(hInstance: HINST; const lpDialogTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): Integer; external 'user32' name 'DialogBoxIndirectParamA'; +function DialogBoxIndirectParamW(hInstance: HINST; const lpDialogTemplate: TDlgTemplate; hWndParent: HWND; lpDialogFunc: TFNDlgProc; dwInitParam: LPARAM): Integer; external 'user32' name 'DialogBoxIndirectParamW'; +function DispatchMessage(const lpMsg: TMsg): Longint;external 'user32' name 'DispatchMessageA'; +function DispatchMessageA(const lpMsg: TMsg): Longint; external 'user32' name 'DispatchMessageA'; +function DispatchMessageW(const lpMsg: TMsg): Longint; external 'user32' name 'DispatchMessageW'; +function DosDateTimeToFileTime(wFatDate, wFatTime: Word; var lpFileTime: TFileTime): BOOL; external 'kernel32' name 'DosDateTimeToFileTime'; +function DPtoLP(DC: HDC; var Points; Count: Integer): BOOL; external 'gdi32' name 'DPtoLP'; +// function DrawAnimatedRects(hwnd: HWND; idAni: Integer; const lprcFrom, lprcTo: TRect): BOOL; external 'user32' name 'DrawAnimatedRects'; +//function DrawCaption(p1: HWND; p2: HDC; const p3: TRect; p4: UINT): BOOL; external 'user32' name 'DrawCaption'; +function DrawEdge(hdc: HDC; var qrc: TRect; edge: UINT; grfFlags: UINT): BOOL; external 'user32' name 'DrawEdge'; +//function DrawFocusRect(hDC: HDC; const lprc: TRect): BOOL; external 'user32' name 'DrawFocusRect'; +function DrawFrameControl(DC: HDC; const Rect: TRect; uType, uState: UINT): BOOL; external 'user32' name 'DrawFrameControl'; +function DrawText(hDC: HDC; lpString: PChar; nCount: Integer; var lpRect: TRect; uFormat: UINT): Integer;external 'user32' name 'DrawTextA'; +function DrawTextA(hDC: HDC; lpString: LPCSTR; nCount: Integer; var lpRect: TRect; uFormat: UINT): Integer; external 'user32' name 'DrawTextA'; +function DrawTextEx(DC: HDC; lpchText: PChar; cchText: Integer; var p4: TRect; dwDTFormat: UINT; DTParams: PDrawTextParams): Integer;external 'user32' name 'DrawTextExA'; +function DrawTextExA(DC: HDC; lpchText: LPCSTR; cchText: Integer; var p4: TRect; dwDTFormat: UINT; DTParams: PDrawTextParams): Integer; external 'user32' name 'DrawTextExA'; +function DrawTextExW(DC: HDC; lpchText: LPWSTR; cchText: Integer; var p4: TRect; dwDTFormat: UINT; DTParams: PDrawTextParams): Integer; external 'user32' name 'DrawTextExW'; +function DrawTextW(hDC: HDC; lpString: LPWSTR; nCount: Integer; var lpRect: TRect; uFormat: UINT): Integer; external 'user32' name 'DrawTextW'; +//function DuplicateTokenEx(hExistingToken: THandle; dwDesiredAccess: DWORD; lpTokenAttributes: PSecurityAttributes; ImpersonationLevel: TSecurityImpersonationLevel; TokenType: TTokenType; var phNewToken: THandle): BOOL; +// external 'advapi32' name 'DuplicateTokenEx'; +function EndPaint(hWnd: HWND; const lpPaint: TPaintStruct): BOOL; external 'user32' name 'EndPaint'; +//function EnumDisplayDevices(Unused: Pointer; iDevNum: DWORD; var lpDisplayDevice: TDisplayDevice; dwFlags: DWORD): BOOL;external 'user32' name 'EnumDisplayDevicesA'; +//function EnumDisplayDevicesA(Unused: Pointer; iDevNum: DWORD; var lpDisplayDevice: TDisplayDeviceA; dwFlags: DWORD): BOOL;external 'user32' name 'EnumDisplayDevicesA'; +//function EnumDisplayDevicesW(Unused: Pointer; iDevNum: DWORD; var lpDisplayDevice: TDisplayDeviceW; dwFlags: DWORD): BOOL;external 'user32' name 'EnumDisplayDevicesW'; +function EnumDisplaySettings(lpszDeviceName: PChar; iModeNum: DWORD; var lpDevMode: TDeviceMode): BOOL;external 'user32' name 'EnumDisplaySettingsA'; +function EnumDisplaySettingsA(lpszDeviceName: LPCSTR; iModeNum: DWORD; var lpDevMode: TDeviceModeA): BOOL; external 'user32' name 'EnumDisplaySettingsA'; +function EnumDisplaySettingsW(lpszDeviceName: LPWSTR; iModeNum: DWORD; var lpDevMode: TDeviceModeW): BOOL; external 'user32' name 'EnumDisplaySettingsW'; +//function EnumEnhMetaFile(DC: HDC; p2: HENHMETAFILE; p3: TFNEnhMFEnumProc; p4: Pointer; const p5: TRect): BOOL; external 'gdi32' name 'EnumEnhMetaFile'; +//function EnumFontFamiliesEx(DC: HDC; var p2: TLogFont; p3: TFNFontEnumProc; p4: LPARAM; p5: DWORD): BOOL;external 'gdi32' name 'EnumFontFamiliesExA'; +//function EnumFontFamiliesExA(DC: HDC; var p2: TLogFontA; p3: TFNFontEnumProcA; p4: LPARAM; p5: DWORD): BOOL; external 'gdi32' name 'EnumFontFamiliesExA'; +//function EnumFontFamiliesExW(DC: HDC; var p2: TLogFontW; p3: TFNFontEnumProcW; p4: LPARAM; p5: DWORD): BOOL; external 'gdi32' name 'EnumFontFamiliesExW'; +//function EqualRect(const lprc1, lprc2: TRect): BOOL; external 'user32' name 'EqualRect'; +function ExtCreatePen(PenStyle, Width: DWORD; const Brush: TLogBrush; StyleCount: DWORD; Style: Pointer): HPEN; external 'gdi32' name 'ExtCreatePen'; +function ExtCreateRegion(p1: PXForm; p2: DWORD; const p3: TRgnData): HRGN; external 'gdi32' name 'ExtCreateRegion'; +// function ExtEscape(DC: HDC; p2, p3: Integer; const p4: LPCSTR; p5: Integer; p6: LPSTR): Integer; external 'gdi32' name 'ExtEscape'; +function FileTimeToDosDateTime(const lpFileTime: TFileTime; var lpFatDate, lpFatTime: Word): BOOL; external 'kernel32' name 'FileTimeToDosDateTime'; +function FileTimeToLocalFileTime(const lpFileTime: TFileTime; var lpLocalFileTime: TFileTime): BOOL; external 'kernel32' name 'FileTimeToLocalFileTime'; +function FileTimeToSystemTime(const lpFileTime: TFileTime; var lpSystemTime: TSystemTime): BOOL; external 'kernel32' name 'FileTimeToSystemTime'; +function FillConsoleOutputAttribute(hConsoleOutput: THandle; wAttribute: Word; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfAttrsWritten: DWORD): BOOL; external 'kernel32' name 'FillConsoleOutputAttribute'; +function FillConsoleOutputCharacter(hConsoleOutput: THandle; cCharacter: Char; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfCharsWritten: DWORD): BOOL;external 'kernel32' name 'FillConsoleOutputCharacterA'; +function FillConsoleOutputCharacterA(hConsoleOutput: THandle; cCharacter: AnsiChar; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfCharsWritten: DWORD): BOOL; external 'kernel32' name 'FillConsoleOutputCharacterA'; +function FillConsoleOutputCharacterW(hConsoleOutput: THandle; cCharacter: WideChar; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfCharsWritten: DWORD): BOOL; external 'kernel32' name 'FillConsoleOutputCharacterW'; +//function FillRect(hDC: HDC; const lprc: TRect; hbr: HBRUSH): Integer; external 'user32' name 'FillRect'; +function FindFirstFile(lpFileName: PChar; var lpFindFileData: TWIN32FindData): THandle;external 'kernel32' name 'FindFirstFileA'; +function FindFirstFileA(lpFileName: LPCSTR; var lpFindFileData: TWIN32FindDataA): THandle; external 'kernel32' name 'FindFirstFileA'; +//function FindFirstFileW(lpFileName: LPWSTR; var lpFindFileData: TWIN32FindDataW): THandle; external 'kernel32' name 'FindFirstFileW'; +//function FindFirstFreeAce(var pAcl: TACL; var pAce: Pointer): BOOL; external 'advapi32' name 'FindFirstFreeAce'; +function FindNextFile(hFindFile: THandle; var lpFindFileData: TWIN32FindData): BOOL;external 'kernel32' name 'FindNextFileA'; +function FindNextFileA(hFindFile: THandle; var lpFindFileData: TWIN32FindDataA): BOOL; external 'kernel32' name 'FindNextFileA'; +//function FindNextFileW(hFindFile: THandle; var lpFindFileData: TWIN32FindDataW): BOOL; external 'kernel32' name 'FindNextFileW'; +//function FlushInstructionCache(hProcess: THandle; const lpBaseAddress: Pointer; dwSize: DWORD): BOOL; external 'kernel32' name 'FlushInstructionCache'; +//function FlushViewOfFile(const lpBaseAddress: Pointer; dwNumberOfBytesToFlush: DWORD): BOOL; external 'kernel32' name 'FlushViewOfFile'; +//function FrameRect(hDC: HDC; const lprc: TRect; hbr: HBRUSH): Integer; external 'user32' name 'FrameRect'; +//function GetAce(const pAcl: TACL; dwAceIndex: DWORD; var pAce: Pointer): BOOL; external 'advapi32' name 'GetAce'; +//function GetAclInformation(const pAcl: TACL; pAclInformation: Pointer; nAclInformationLength: DWORD; dwAclInformationClass: TAclInformationClass): BOOL; external 'advapi32' name 'GetAclInformation'; +//function GetAltTabInfo(hwnd: HWND; iItem: Integer; var pati: TAltTabInfo; pszItemText: PChar; cchItemText: UINT): BOOL;external 'user32' name 'GetAltTabInfoA'; +//function GetAltTabInfoA(hwnd: HWND; iItem: Integer; var pati: TAltTabInfo; pszItemText: LPCSTR; cchItemText: UINT): BOOL;external 'user32' name 'GetAltTabInfoA'; +//function GetAltTabInfoW(hwnd: HWND; iItem: Integer; var pati: TAltTabInfo; pszItemText: LPWSTR; cchItemText: UINT): BOOL;external 'user32' name 'GetAltTabInfoW'; +function GetAspectRatioFilterEx(DC: HDC; var p2: TSize): BOOL; external 'gdi32' name 'GetAspectRatioFilterEx'; +function GetBinaryType(lpApplicationName: PChar; var lpBinaryType: DWORD): BOOL;external 'kernel32' name 'GetBinaryTypeA'; +function GetBinaryTypeA(lpApplicationName: LPCSTR; var lpBinaryType: DWORD): BOOL; external 'kernel32' name 'GetBinaryTypeA'; +function GetBinaryTypeW(lpApplicationName: LPWSTR; var lpBinaryType: DWORD): BOOL; external 'kernel32' name 'GetBinaryTypeW'; +function GetBitmapDimensionEx(p1: HBITMAP; var p2: TSize): BOOL; external 'gdi32' name 'GetBitmapDimensionEx'; +function GetBoundsRect(DC: HDC; var p2: TRect; p3: UINT): UINT; external 'gdi32' name 'GetBoundsRect'; +function GetBrushOrgEx(DC: HDC; var p2: TPoint): BOOL; external 'gdi32' name 'GetBrushOrgEx'; +function GetCaretPos(var lpPoint: TPoint): BOOL; external 'user32' name 'GetCaretPos'; +function GetCharABCWidths(DC: HDC; p2, p3: UINT; const ABCStructs): BOOL;external 'gdi32' name 'GetCharABCWidthsA'; +function GetCharABCWidthsA(DC: HDC; p2, p3: UINT; const ABCStructs): BOOL; external 'gdi32' name 'GetCharABCWidthsA'; +function GetCharABCWidthsFloat(DC: HDC; p2, p3: UINT; const ABCFloatSturcts): BOOL;external 'gdi32' name 'GetCharABCWidthsFloatA'; +function GetCharABCWidthsFloatA(DC: HDC; p2, p3: UINT; const ABCFloatSturcts): BOOL; external 'gdi32' name 'GetCharABCWidthsFloatA'; +function GetCharABCWidthsFloatW(DC: HDC; p2, p3: UINT; const ABCFloatSturcts): BOOL; external 'gdi32' name 'GetCharABCWidthsFloatW'; +//function GetCharABCWidthsI(DC: HDC; p2, p3: UINT; p4: PWORD; const Widths): BOOL;external 'gdi32' name 'GetCharABCWidthsI'; +function GetCharABCWidthsW(DC: HDC; p2, p3: UINT; const ABCStructs): BOOL; external 'gdi32' name 'GetCharABCWidthsW'; +function GetCharacterPlacement(DC: HDC; p2: PChar; p3, p4: BOOL; var p5: TGCPResults; p6: DWORD): DWORD;external 'gdi32' name 'GetCharacterPlacementA'; +function GetCharacterPlacementA(DC: HDC; p2: LPCSTR; p3, p4: BOOL; var p5: TGCPResults; p6: DWORD): DWORD; external 'gdi32' name 'GetCharacterPlacementA'; +function GetCharacterPlacementW(DC: HDC; p2: LPWSTR; p3, p4: BOOL; var p5: TGCPResults; p6: DWORD): DWORD; external 'gdi32' name 'GetCharacterPlacementW'; +function GetCharWidth(DC: HDC; p2, p3: UINT; const Widths): BOOL;external 'gdi32' name 'GetCharWidthA'; +function GetCharWidth32(DC: HDC; p2, p3: UINT; const Widths): BOOL;external 'gdi32' name 'GetCharWidth32A'; +function GetCharWidth32A(DC: HDC; p2, p3: UINT; const Widths): BOOL; external 'gdi32' name 'GetCharWidth32A'; +function GetCharWidth32W(DC: HDC; p2, p3: UINT; const Widths): BOOL; external 'gdi32' name 'GetCharWidth32W'; +function GetCharWidthA(DC: HDC; p2, p3: UINT; const Widths): BOOL; external 'gdi32' name 'GetCharWidthA'; +function GetCharWidthFloat(DC: HDC; p2, p3: UINT; const Widths): BOOL;external 'gdi32' name 'GetCharWidthFloatA'; +function GetCharWidthFloatA(DC: HDC; p2, p3: UINT; const Widths): BOOL; external 'gdi32' name 'GetCharWidthFloatA'; +function GetCharWidthFloatW(DC: HDC; p2, p3: UINT; const Widths): BOOL; external 'gdi32' name 'GetCharWidthFloatW'; +//function GetCharWidthI(DC: HDC; p2, p3: UINT; p4: PWORD; const Widths): BOOL;external 'gdi32' name 'GetCharWidthI'; +function GetCharWidthW(DC: HDC; p2, p3: UINT; const Widths): BOOL; external 'gdi32' name 'GetCharWidthW'; +function GetClassInfo(hInstance: HINST; lpClassName: PChar; var lpWndClass: TWndClass): BOOL;external 'user32' name 'GetClassInfoA'; +function GetClassInfoA(hInstance: HINST; lpClassName: LPCSTR; var lpWndClass: TWndClassA): BOOL; external 'user32' name 'GetClassInfoA'; +function GetClassInfoEx(Instance: HINST; Classname: PChar; var WndClass: TWndClassEx): BOOL;external 'user32' name 'GetClassInfoExA'; +//function GetClassInfoExA(Instance: HINST; Classname: LPCSTR; var WndClass: TWndClassExA): BOOL; external 'user32' name 'GetClassInfoExA'; +//function GetClassInfoExW(Instance: HINST; Classname: LPWSTR; var WndClass: TWndClassExW): BOOL; external 'user32' name 'GetClassInfoExW'; +//function GetClassInfoW(hInstance: HINST; lpClassName: LPWSTR; var lpWndClass: TWndClassW): BOOL; external 'user32' name 'GetClassInfoW'; +function GetClientRect(hWnd: HWND; var lpRect: TRect): BOOL; external 'user32' name 'GetClientRect'; +function GetClipBox(DC: HDC; var Rect: TRect): Integer; external 'gdi32' name 'GetClipBox'; +function GetClipCursor(var lpRect: TRect): BOOL; external 'user32' name 'GetClipCursor'; +function GetColorAdjustment(DC: HDC; var p2: TColorAdjustment): BOOL; external 'gdi32' name 'GetColorAdjustment'; +function GetCommConfig(hCommDev: THandle; var lpCC: TCommConfig; var lpdwSize: DWORD): BOOL; external 'kernel32' name 'GetCommConfig'; +function GetCommMask(hFile: THandle; var lpEvtMask: DWORD): BOOL; external 'kernel32' name 'GetCommMask'; +function GetCommModemStatus(hFile: THandle; var lpModemStat: DWORD): BOOL; external 'kernel32' name 'GetCommModemStatus'; +function GetCommProperties(hFile: THandle; var lpCommProp: TCommProp): BOOL; external 'kernel32' name 'GetCommProperties'; +function GetCommState(hFile: THandle; var lpDCB: TDCB): BOOL; external 'kernel32' name 'GetCommState'; +function GetCommTimeouts(hFile: THandle; var lpCommTimeouts: TCommTimeouts): BOOL; external 'kernel32' name 'GetCommTimeouts'; +function GetComputerName(lpBuffer: PChar; var nSize: DWORD): BOOL;external 'kernel32' name 'GetComputerNameA'; +function GetComputerNameA(lpBuffer: LPCSTR; var nSize: DWORD): BOOL; external 'kernel32' name 'GetComputerNameA'; +function GetComputerNameW(lpBuffer: LPWSTR; var nSize: DWORD): BOOL; external 'kernel32' name 'GetComputerNameW'; +function GetConsoleCursorInfo(hConsoleOutput: THandle; var lpConsoleCursorInfo: TConsoleCursorInfo): BOOL; external 'kernel32' name 'GetConsoleCursorInfo'; +function GetConsoleMode(hConsoleHandle: THandle; var lpMode: DWORD): BOOL; external 'kernel32' name 'GetConsoleMode'; +function GetConsoleScreenBufferInfo(hConsoleOutput: THandle; var lpConsoleScreenBufferInfo: TConsoleScreenBufferInfo): BOOL; external 'kernel32' name 'GetConsoleScreenBufferInfo'; +function GetCPInfo(CodePage: UINT; var lpCPInfo: TCPInfo): BOOL;external 'kernel32' name 'GetCPInfo'; +//function GetCurrentHwProfile(var lpHwProfileInfo: THWProfileInfo): BOOL;external 'advapi32' name 'GetCurrentHwProfileA'; +//function GetCurrentHwProfileA(var lpHwProfileInfo: THWProfileInfoA): BOOL;external 'advapi32' name 'GetCurrentHwProfileA'; +//function GetCurrentHwProfileW(var lpHwProfileInfo: THWProfileInfoW): BOOL;external 'advapi32' name 'GetCurrentHwProfileW'; +{$ifdef support_smartlink} +function GetCursorInfo(var pci: TCursorInfo): BOOL;external 'user32' name 'GetCursorInfo'; +{$endif support_smartlink} +function GetCursorPos(var lpPoint: TPoint): BOOL; external 'user32' name 'GetCursorPos'; +function GetDCOrgEx(DC: HDC; var Origin: TPoint): BOOL; external 'gdi32' name 'GetDCOrgEx'; +function GetDefaultCommConfig(lpszName: PChar; var lpCC: TCommConfig; var lpdwSize: DWORD): BOOL;external 'kernel32' name 'GetDefaultCommConfigA'; +function GetDefaultCommConfigA(lpszName: LPCSTR; var lpCC: TCommConfig; var lpdwSize: DWORD): BOOL; external 'kernel32' name 'GetDefaultCommConfigA'; +function GetDefaultCommConfigW(lpszName: LPWSTR; var lpCC: TCommConfig; var lpdwSize: DWORD): BOOL; external 'kernel32' name 'GetDefaultCommConfigW'; +function GetDeviceGammaRamp(DC: HDC; var Ramp): BOOL; external 'gdi32' name 'GetDeviceGammaRamp'; +function GetDIBColorTable(DC: HDC; p2, p3: UINT; var RGBQuadStructs): UINT; external 'gdi32' name 'GetDIBColorTable'; +function GetDIBits(DC: HDC; Bitmap: HBitmap; StartScan, NumScans: UINT; Bits: Pointer; var BitInfo: TBitmapInfo; Usage: UINT): Integer; external 'gdi32' name 'GetDIBits'; +function GetDiskFreeSpace(lpRootPathName: PChar; var lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL;external 'kernel32' name 'GetDiskFreeSpaceA'; +function GetDiskFreeSpaceA(lpRootPathName: LPCSTR; var lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL; external 'kernel32' name 'GetDiskFreeSpaceA'; +function GetDiskFreeSpaceEx(lpDirectoryName: PChar; var lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes: TLargeInteger; lpTotalNumberOfFreeBytes: PLargeInteger): BOOL;external 'kernel32' name 'GetDiskFreeSpaceExA'; +function GetDiskFreeSpaceExA(lpDirectoryName: LPCSTR; var lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes: TLargeInteger; lpTotalNumberOfFreeBytes: PLargeInteger): BOOL;external 'kernel32' name 'GetDiskFreeSpaceExA'; +function GetDiskFreeSpaceExW(lpDirectoryName: LPWSTR; var lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes: TLargeInteger; lpTotalNumberOfFreeBytes: PLargeInteger): BOOL;external 'kernel32' name 'GetDiskFreeSpaceExW'; +function GetDiskFreeSpaceW(lpRootPathName: LPWSTR; var lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters: DWORD): BOOL; external 'kernel32' name 'GetDiskFreeSpaceW'; +function GetDiskFreeSpaceEx(lpDirectoryName: PChar; lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes:pLargeInteger; lpTotalNumberOfFreeBytes: PLargeInteger): BOOL;external 'kernel32' name 'GetDiskFreeSpaceExA'; +function GetDiskFreeSpaceExA(lpDirectoryName: LPCSTR; lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes: pLargeInteger; lpTotalNumberOfFreeBytes: PLargeInteger): BOOL;external 'kernel32' name 'GetDiskFreeSpaceExA'; +function GetDiskFreeSpaceExW(lpDirectoryName: LPWSTR; lpFreeBytesAvailableToCaller, lpTotalNumberOfBytes: pLargeInteger; lpTotalNumberOfFreeBytes: PLargeInteger): BOOL;external 'kernel32' name 'GetDiskFreeSpaceExW'; +//function GetEnhMetaFilePixelFormat(p1: HENHMETAFILE; p2: Cardinal; var p3: TPixelFormatDescriptor): UINT;external 'gdi32' name 'GetEnhMetaFilePixelFormat'; +function GetExitCodeProcess(hProcess: THandle; var lpExitCode: DWORD): BOOL; external 'kernel32' name 'GetExitCodeProcess'; +function GetExitCodeThread(hThread: THandle; var lpExitCode: DWORD): BOOL; external 'kernel32' name 'GetExitCodeThread'; +function GetFileInformationByHandle(hFile: THandle; var lpFileInformation: TByHandleFileInformation): BOOL; external 'kernel32' name 'GetFileInformationByHandle'; +//function GetFileSecurity(lpFileName: PChar; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL;external 'advapi32' name 'GetFileSecurityA'; +//function GetFileSecurityA(lpFileName: LPCSTR; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL; external 'advapi32' name 'GetFileSecurityA'; +//function GetFileSecurityW(lpFileName: LPWSTR; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL; external 'advapi32' name 'GetFileSecurityW'; +function GetFileVersionInfoSize(lptstrFilename: PChar; var lpdwHandle: DWORD): DWORD;external 'version' name 'GetFileVersionInfoSizeA'; +function GetFileVersionInfoSizeA(lptstrFilename: LPCSTR; var lpdwHandle: DWORD): DWORD; external 'version' name 'GetFileVersionInfoSizeA'; +function GetFileVersionInfoSizeW(lptstrFilename: LPWSTR; var lpdwHandle: DWORD): DWORD; external 'version' name 'GetFileVersionInfoSizeW'; +// removed because old definition was wrong ! +// function GetFullPathName(lpFileName: PChar; nBufferLength: DWORD; lpBuffer: PChar; var lpFilePart: PChar): DWORD;external 'kernel32' name 'GetFullPathNameA'; +// function GetFullPathNameA(lpFileName: LPCSTR; nBufferLength: DWORD; lpBuffer: LPCSTR; var lpFilePart: LPCSTR): DWORD; external 'kernel32' name 'GetFullPathNameA'; +// function GetFullPathNameW(lpFileName: LPWSTR; nBufferLength: DWORD; lpBuffer: LPWSTR; var lpFilePart: LPWSTR): DWORD; external 'kernel32' name 'GetFullPathNameW'; +function GetGlyphOutline(DC: HDC; p2, p3: UINT; const p4: TGlyphMetrics; p5: DWORD; p6: Pointer; const p7: TMat2): DWORD;external 'gdi32' name 'GetGlyphOutlineA'; +function GetGlyphOutlineA(DC: HDC; p2, p3: UINT; const p4: TGlyphMetrics; p5: DWORD; p6: Pointer; const p7: TMat2): DWORD; external 'gdi32' name 'GetGlyphOutlineA'; +function GetGlyphOutlineW(DC: HDC; p2, p3: UINT; const p4: TGlyphMetrics; p5: DWORD; p6: Pointer; const p7: TMat2): DWORD; external 'gdi32' name 'GetGlyphOutlineW'; +//function GetGUIThreadInfo(idThread: DWORD; var pgui: TGUIThreadinfo): BOOL;external 'user32' name 'GetGUIThreadInfo'; +function GetHandleInformation(hObject: THandle; var lpdwFlags: DWORD): BOOL; external 'kernel32' name 'GetHandleInformation'; +//function GetICMProfile(DC: HDC; var Size: DWORD; Name: PChar): BOOL;external 'gdi32' name 'GetICMProfileA'; +//function GetICMProfileA(DC: HDC; var Size: DWORD; Name: LPCSTR): BOOL; external 'gdi32' name 'GetICMProfileA'; +//function GetICMProfileW(DC: HDC; var Size: DWORD; Name: LPWSTR): BOOL; external 'gdi32' name 'GetICMProfileW'; +function GetIconInfo(hIcon: HICON; var piconinfo: TIconInfo): BOOL; external 'user32' name 'GetIconInfo'; +//function GetKernelObjectSecurity(Handle: THandle; RequestedInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL; external 'advapi32' name 'GetKernelObjectSecurity'; +function GetKerningPairs(DC: HDC; Count: DWORD; var KerningPairs): DWORD;external 'gdi32' name 'GetKerningPairs'; +function GetKeyboardLayoutList(nBuff: Integer; var List): UINT; external 'user32' name 'GetKeyboardLayoutList'; +//function GetKeyboardState(var KeyState: TKeyboardState): BOOL; external 'user32' name 'GetKeyboardState'; +//function GetLastInputInfo(var plii: TLastInputInfo): BOOL;external 'user32' name 'GetLastInputInfo'; +procedure GetSystemTime(var lpSystemTime:SYSTEMTIME); external 'kernel32' name 'GetSystemTime'; +procedure GetLocalTime(var SystemTime: SYSTEMTIME); external 'kernel32' name 'GetLocalTime'; +procedure GetSystemInfo(var SystemInfo:SYSTEM_INFO); external 'kernel32' name 'GetSystemInfo'; +function SetSystemTime(var lpSystemTime:SYSTEMTIME):WINBOOL; external 'kernel32' name 'SetSystemTime'; +function SetLocalTime(var lpSystemTime:SYSTEMTIME):WINBOOL; external 'kernel32' name 'SetLocalTime'; +function GetLogColorSpace(p1: HCOLORSPACE; var ColorSpace: TLogColorSpace; Size: DWORD): BOOL;external 'gdi32' name 'GetLogColorSpaceA'; +function GetLogColorSpaceA(p1: HCOLORSPACE; var ColorSpace: TLogColorSpaceA; Size: DWORD): BOOL; external 'gdi32' name 'GetLogColorSpaceA'; +//function GetLogColorSpaceW(p1: HCOLORSPACE; var ColorSpace: TLogColorSpaceW; Size: DWORD): BOOL; external 'gdi32' name 'GetLogColorSpaceW'; +function GetMailslotInfo(hMailslot: THandle; lpMaxMessageSize: Pointer; var lpNextSize: DWORD; lpMessageCount, lpReadTimeout: Pointer): BOOL; external 'kernel32' name 'GetMailslotInfo'; +//function GetMenuBarInfo(hend: HWND; idObject, idItem: Longint; var pmbi: TMenuBarInfo): BOOL;external 'user32' name 'GetMenuBarInfo'; +//function GetMenuInfo(hMenu: HMENU; var lpmi: TMenuInfo): BOOL;external 'user32' name 'GetMenuInfo'; +function GetMenuItemInfo(p1: HMENU; p2: UINT; p3: BOOL; var p4: TMenuItemInfo): BOOL;external 'user32' name 'GetMenuItemInfoA'; +function GetMenuItemInfoA(p1: HMENU; p2: UINT; p3: BOOL; var p4: TMenuItemInfoA): BOOL; external 'user32' name 'GetMenuItemInfoA'; +//function GetMenuItemInfoW(p1: HMENU; p2: UINT; p3: BOOL; var p4: TMenuItemInfoW): BOOL; external 'user32' name 'GetMenuItemInfoW'; +function GetMenuItemRect(hWnd: HWND; hMenu: HMENU; uItem: UINT; var lprcItem: TRect): BOOL; external 'user32' name 'GetMenuItemRect'; +function GetMessage(var lpMsg: TMsg; hWnd: HWND; wMsgFilterMin, wMsgFilterMax: UINT): BOOL;external 'user32' name 'GetMessageA'; +function GetMessageA(var lpMsg: TMsg; hWnd: HWND; wMsgFilterMin, wMsgFilterMax: UINT): BOOL; external 'user32' name 'GetMessageA'; +function GetMessageW(var lpMsg: TMsg; hWnd: HWND; wMsgFilterMin, wMsgFilterMax: UINT): BOOL; external 'user32' name 'GetMessageW'; +function GetMiterLimit(DC: HDC; var Limit: Single): BOOL; external 'gdi32' name 'GetMiterLimit'; +//function GetMouseMovePoints(cbSize: UINT; var lppt, lpptBuf: TMouseMovePoint; nBufPoints: Integer; resolution: DWORD): Integer;external 'user32' name 'GetMouseMovePoints'; +function GetNamedPipeInfo(hNamedPipe: THandle; var lpFlags: DWORD; lpOutBufferSize, lpInBufferSize, lpMaxInstances: Pointer): BOOL; external 'kernel32' name 'GetNamedPipeInfo'; +function GetNumberOfConsoleInputEvents(hConsoleInput: THandle; var lpNumberOfEvents: DWORD): BOOL; external 'kernel32' name 'GetNumberOfConsoleInputEvents'; +function GetNumberOfConsoleMouseButtons(var lpNumberOfMouseButtons: DWORD): BOOL; external 'kernel32' name 'GetNumberOfConsoleMouseButtons'; +//function GetNumberOfEventLogRecords(hEventLog: THandle; var NumberOfRecords: DWORD): BOOL; external 'advapi32' name 'GetNumberOfEventLogRecords'; +//function GetOldestEventLogRecord(hEventLog: THandle; var OldestRecord: DWORD): BOOL; external 'advapi32' name 'GetOldestEventLogRecord'; +function GetOverlappedResult(hFile: THandle; const lpOverlapped: TOverlapped; var lpNumberOfBytesTransferred: DWORD; bWait: BOOL): BOOL; external 'kernel32' name 'GetOverlappedResult'; +function GetPaletteEntries(Palette: HPALETTE; StartIndex, NumEntries: UINT; var PaletteEntries): UINT; external 'gdi32' name 'GetPaletteEntries'; +function GetPath(DC: HDC; var Points, Types; nSize: Integer): Integer; external 'gdi32' name 'GetPath'; +function GetPriorityClipboardFormat(var paFormatPriorityList; cFormats: Integer): Integer; external 'user32' name 'GetPriorityClipboardFormat'; +//function GetPrivateObjectSecurity(ObjectDescriptor: PSecurityDescriptor; SecurityInformation: SECURITY_INFORMATION; ResultantDescriptor: PSecurityDescriptor; DescriptorLength: DWORD; var ReturnLength: DWORD): BOOL; +// external 'advapi32' name 'GetPrivateObjectSecurity'; +function GetProcessAffinityMask(hProcess: THandle; var lpProcessAffinityMask, lpSystemAffinityMask: DWORD): BOOL; external 'kernel32' name 'GetProcessAffinityMask'; +function GetProcessHeaps(NumberOfHeaps: DWORD; var ProcessHeaps: THandle): DWORD;external 'kernel32' name 'GetProcessHeaps'; +{$ifdef support_smartlink} +function GetProcessPriorityBoost(hThread: THandle; var DisablePriorityBoost: Bool): BOOL;external 'kernel32' name 'GetProcessPriorityBoost'; +{$endif support_smartlink} +function GetProcessShutdownParameters(var lpdwLevel, lpdwFlags: DWORD): BOOL; external 'kernel32' name 'GetProcessShutdownParameters'; +function GetProcessTimes(hProcess: THandle; var lpCreationTime, lpExitTime, lpKernelTime, lpUserTime: TFileTime): BOOL; external 'kernel32' name 'GetProcessTimes'; +function GetProcessWorkingSetSize(hProcess: THandle; var lpMinimumWorkingSetSize, lpMaximumWorkingSetSize: DWORD): BOOL; external 'kernel32' name 'GetProcessWorkingSetSize'; +function GetQueuedCompletionStatus(CompletionPort: THandle; var lpNumberOfBytesTransferred, lpCompletionKey: DWORD; var lpOverlapped: POverlapped; dwMilliseconds: DWORD): BOOL; external 'kernel32' name 'GetQueuedCompletionStatus'; +function GetRasterizerCaps(var p1: TRasterizerStatus; p2: UINT): BOOL; external 'gdi32' name 'GetRasterizerCaps'; +function GetRgnBox(RGN: HRGN; var p2: TRect): Integer; external 'gdi32' name 'GetRgnBox'; +function GetScrollInfo(hWnd: HWND; BarFlag: Integer; var ScrollInfo: TScrollInfo): BOOL; external 'user32' name 'GetScrollInfo'; +function GetScrollRange(hWnd: HWND; nBar: Integer; var lpMinPos, lpMaxPos: Integer): BOOL; external 'user32' name 'GetScrollRange'; +//function GetSecurityDescriptorControl(pSecurityDescriptor: PSecurityDescriptor; var pControl: SECURITY_DESCRIPTOR_CONTROL; var lpdwRevision: DWORD): BOOL; external 'advapi32' name 'GetSecurityDescriptorControl'; +//function GetSecurityDescriptorDacl(pSecurityDescriptor: PSecurityDescriptor; var lpbDaclPresent: BOOL; var pDacl: PACL; var lpbDaclDefaulted: BOOL): BOOL; external 'advapi32' name 'GetSecurityDescriptorDacl'; +//function GetSecurityDescriptorGroup(pSecurityDescriptor: PSecurityDescriptor; var pGroup: PSID; var lpbGroupDefaulted: BOOL): BOOL; external 'advapi32' name 'GetSecurityDescriptorGroup'; +//function GetSecurityDescriptorOwner(pSecurityDescriptor: PSecurityDescriptor; var pOwner: PSID; var lpbOwnerDefaulted: BOOL): BOOL; external 'advapi32' name 'GetSecurityDescriptorOwner'; +//function GetSecurityDescriptorSacl(pSecurityDescriptor: PSecurityDescriptor; var lpbSaclPresent: BOOL; var pSacl: PACL; var lpbSaclDefaulted: BOOL): BOOL; external 'advapi32' name 'GetSecurityDescriptorSacl'; +function GetStringTypeA(Locale: LCID; dwInfoType: DWORD; const lpSrcStr: LPCSTR; cchSrc: BOOL; var lpCharType: Word): BOOL;external 'kernel32' name 'GetStringTypeA'; +function GetStringTypeEx(Locale: LCID; dwInfoType: DWORD; lpSrcStr: PChar; cchSrc: Integer; var lpCharType): BOOL;external 'kernel32' name 'GetStringTypeExA'; +function GetStringTypeExA(Locale: LCID; dwInfoType: DWORD; lpSrcStr: LPCSTR; cchSrc: Integer; var lpCharType): BOOL; external 'kernel32' name 'GetStringTypeExA'; +function GetStringTypeExW(Locale: LCID; dwInfoType: DWORD; lpSrcStr: LPWSTR; cchSrc: Integer; var lpCharType): BOOL; external 'kernel32' name 'GetStringTypeExW'; +function GetStringTypeW(dwInfoType: DWORD; const lpSrcStr: WCHAR; cchSrc: BOOL; var lpCharType: Word): BOOL;external 'kernel32' name 'GetStringTypeW'; +function GetSystemPaletteEntries(DC: HDC; StartIndex, NumEntries: UINT; var PaletteEntries): UINT; external 'gdi32' name 'GetSystemPaletteEntries'; +function GetSystemPowerStatus(var lpSystemPowerStatus: TSystemPowerStatus): BOOL;external 'kernel32' name 'GetSystemPowerStatus'; +function GetSystemTimeAdjustment(var lpTimeAdjustment, lpTimeIncrement: DWORD; var lpTimeAdjustmentDisabled: BOOL): BOOL; external 'kernel32' name 'GetSystemTimeAdjustment'; +procedure GetSystemTimeAsFileTime(var lpSystemTimeAsFileTime:TFILETIME); external 'kernel32' name 'GetSystemTimeAsFileTime'; +function GetTabbedTextExtent(hDC: HDC; lpString: PChar; nCount, nTabPositions: Integer; var lpnTabStopPositions): DWORD;external 'user32' name 'GetTabbedTextExtentA'; +function GetTabbedTextExtentA(hDC: HDC; lpString: LPCSTR; nCount, nTabPositions: Integer; var lpnTabStopPositions): DWORD; external 'user32' name 'GetTabbedTextExtentA'; +function GetTabbedTextExtentW(hDC: HDC; lpString: LPWSTR; nCount, nTabPositions: Integer; var lpnTabStopPositions): DWORD; external 'user32' name 'GetTabbedTextExtentW'; +function GetTapeParameters(hDevice: THandle; dwOperation: DWORD; var lpdwSize: DWORD; lpTapeInformation: Pointer): DWORD; external 'kernel32' name 'GetTapeParameters'; +function GetTapePosition(hDevice: THandle; dwPositionType: DWORD; var lpdwPartition, lpdwOffsetLow: DWORD; lpdwOffsetHigh: Pointer): DWORD; external 'kernel32' name 'GetTapePosition'; +function GetTextExtentExPoint(DC: HDC; p2: PChar; p3, p4: Integer; p5, p6: PInteger; var p7: TSize): BOOL;external 'gdi32' name 'GetTextExtentExPointA'; +function GetTextExtentExPointA(DC: HDC; p2: LPCSTR; p3, p4: Integer; p5, p6: PInteger; var p7: TSize): BOOL; external 'gdi32' name 'GetTextExtentExPointA'; +//function GetTextExtentExPointI(DC: HDC; p2: PWORD; p3, p4: Integer; p5, p6: PINT; var p7: TSize): BOOL;external 'gdi32' name 'GetTextExtentExPointI'; +function GetTextExtentExPointW(DC: HDC; p2: LPWSTR; p3, p4: Integer; p5, p6: PInteger; var p7: TSize): BOOL; external 'gdi32' name 'GetTextExtentExPointW'; +function GetTextExtentPoint(DC: HDC; Str: PChar; Count: Integer; var Size: TSize): BOOL;external 'gdi32' name 'GetTextExtentPointA'; +function GetTextExtentPoint32(DC: HDC; Str: PChar; Count: Integer; var Size: TSize): BOOL;external 'gdi32' name 'GetTextExtentPoint32A'; +function GetTextExtentPoint32A(DC: HDC; Str: LPCSTR; Count: Integer; var Size: TSize): BOOL; external 'gdi32' name 'GetTextExtentPoint32A'; +function GetTextExtentPoint32W(DC: HDC; Str: LPWSTR; Count: Integer; var Size: TSize): BOOL; external 'gdi32' name 'GetTextExtentPoint32W'; +function GetTextExtentPointA(DC: HDC; Str: LPCSTR; Count: Integer; var Size: TSize): BOOL; external 'gdi32' name 'GetTextExtentPointA'; +//function GetTextExtentPointI(DC: HDC; p2: PWORD; p3: Integer; var p4: TSize): BOOL;external 'gdi32' name 'GetTextExtentPointI'; +function GetTextExtentPointW(DC: HDC; Str: LPWSTR; Count: Integer; var Size: TSize): BOOL; external 'gdi32' name 'GetTextExtentPointW'; +function GetTextMetrics(DC: HDC; var TM: TTextMetric): BOOL;external 'gdi32' name 'GetTextMetricsA'; +//function GetTextMetricsA(DC: HDC; var TM: TTextMetricA): BOOL; external 'gdi32' name 'GetTextMetricsA'; +//function GetTextMetricsW(DC: HDC; var TM: TTextMetricW): BOOL; external 'gdi32' name 'GetTextMetricsW'; +function GetThreadContext(hThread: THandle; var lpContext: TContext): BOOL; external 'kernel32' name 'GetThreadContext'; +{$ifdef support_smartlink} +function GetThreadPriorityBoost(hThread: THandle; var DisablePriorityBoost: Bool): BOOL;external 'kernel32' name 'GetThreadPriorityBoost'; +{$endif support_smartlink} +{$ifdef TLDTEntry} +function GetThreadSelectorEntry(hThread: THandle; dwSelector: DWORD; var lpSelectorEntry: TLDTEntry): BOOL; external 'kernel32' name 'GetThreadSelectorEntry'; +{$endif TLDTEntry} +function GetThreadTimes(hThread: THandle; var lpCreationTime, lpExitTime, lpKernelTime, lpUserTime: TFileTime): BOOL; external 'kernel32' name 'GetThreadTimes'; +function GetTimeZoneInformation(var lpTimeZoneInformation: TTimeZoneInformation): DWORD; external 'kernel32' name 'GetTimeZoneInformation'; +//function GetTitleBarInfo(hwnd: HWND; var pti: TTitleBarInfo): BOOL;external 'user32' name 'GetTitleBarInfo'; +//function GetTokenInformation(TokenHandle: THandle; TokenInformationClass: TTokenInformationClass; TokenInformation: Pointer; TokenInformationLength: DWORD; var ReturnLength: DWORD): BOOL; external 'advapi32' name 'GetTokenInformation'; +function GetUpdateRect(hWnd: HWND; var lpRect: TRect; bErase: BOOL): BOOL; external 'user32' name 'GetUpdateRect'; +function GetUserName(lpBuffer: PChar; var nSize: DWORD): BOOL;external 'advapi32' name 'GetUserNameA'; +function GetUserNameA(lpBuffer: LPCSTR; var nSize: DWORD): BOOL; external 'advapi32' name 'GetUserNameA'; +function GetUserNameW(lpBuffer: LPWSTR; var nSize: DWORD): BOOL; external 'advapi32' name 'GetUserNameW'; +function GetUserObjectInformation(hObj: THandle; nIndex: Integer; pvInfo: Pointer; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL;external 'user32' name 'GetUserObjectInformationA'; +function GetUserObjectInformationA(hObj: THandle; nIndex: Integer; pvInfo: Pointer; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL; external 'user32' name 'GetUserObjectInformationA'; +function GetUserObjectInformationW(hObj: THandle; nIndex: Integer; pvInfo: Pointer; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL; external 'user32' name 'GetUserObjectInformationW'; +function GetUserObjectSecurity(hObj: THandle; var pSIRequested: DWORD; pSID: PSecurityDescriptor; nLength: DWORD; var lpnLengthNeeded: DWORD): BOOL; external 'user32' name 'GetUserObjectSecurity'; +function GetVersionEx(var lpVersionInformation: TOSVersionInfo): BOOL;external 'kernel32' name 'GetVersionExA'; +function GetVersionExA(var lpVersionInformation: TOSVersionInfo): BOOL; external 'kernel32' name 'GetVersionExA'; +function GetVersionExW(var lpVersionInformation: TOSVersionInfoW): BOOL; external 'kernel32' name 'GetVersionExW'; +function GetViewportExtEx(DC: HDC; var Size: TSize): BOOL; external 'gdi32' name 'GetViewportExtEx'; +function GetViewportOrgEx(DC: HDC; var Point: TPoint): BOOL; external 'gdi32' name 'GetViewportOrgEx'; +function GetVolumeInformation(lpRootPathName: PChar; lpVolumeNameBuffer: PChar; nVolumeNameSize: DWORD; lpVolumeSerialNumber: PDWORD; var lpMaximumComponentLength, lpFileSystemFlags: DWORD; + lpFileSystemNameBuffer: PChar; nFileSystemNameSize: DWORD): BOOL; external 'kernel32' name 'GetVolumeInformationA'; +function GetVolumeInformationA(lpRootPathName: LPCSTR; lpVolumeNameBuffer: LPCSTR; nVolumeNameSize: DWORD; lpVolumeSerialNumber: PDWORD; var lpMaximumComponentLength, lpFileSystemFlags: DWORD; + lpFileSystemNameBuffer: LPCSTR; nFileSystemNameSize: DWORD): BOOL; external 'kernel32' name 'GetVolumeInformationA'; +function GetVolumeInformationW(lpRootPathName: LPWSTR; lpVolumeNameBuffer: LPWSTR; nVolumeNameSize: DWORD; lpVolumeSerialNumber: PDWORD; var lpMaximumComponentLength, lpFileSystemFlags: DWORD; + lpFileSystemNameBuffer: LPWSTR; nFileSystemNameSize: DWORD): BOOL; external 'kernel32' name 'GetVolumeInformationW'; +function GetWindowExtEx(DC: HDC; var Size: TSize): BOOL; external 'gdi32' name 'GetWindowExtEx'; +//function GetWindowInfo(hwnd: HWND; var pwi: TWindowInfo): BOOL;external 'user32' name 'GetWindowInfo'; +function GetWindowOrgEx(DC: HDC; var Point: TPoint): BOOL; external 'gdi32' name 'GetWindowOrgEx'; +function GetWindowRect(hWnd: HWND; var lpRect: TRect): BOOL; external 'user32' name 'GetWindowRect'; +function GetWorldTransform(DC: HDC; var p2: TXForm): BOOL; external 'gdi32' name 'GetWorldTransform'; +//function GradientFill(DC: HDC; var p2: TTriVertex; p3: ULONG; p4: Pointer; p5, p6: ULONG): BOOL;external 'gdi32' name 'GradientFill'; +procedure GlobalMemoryStatus(var Buffer: MEMORYSTATUS); external 'kernel32' name 'GlobalMemoryStatus'; +function HeapWalk(hHeap: THandle; var lpEntry: TProcessHeapEntry): BOOL; external 'kernel32' name 'HeapWalk'; +function ImageList_GetDragImage(var ppt:POINT; var pptHotspot:POINT):HIMAGELIST; external 'comctl32' name 'ImageList_GetDragImage'; +function InflateRect(var lprc: TRect; dx, dy: Integer): BOOL; external 'user32' name 'InflateRect'; +function InitializeAcl(var pAcl: TACL; nAclLength, dwAclRevision: DWORD): BOOL; external 'advapi32' name 'InitializeAcl'; +{$ifdef support_smartlink} +function InitializeCriticalSectionAndSpinCount(var lpCriticalSection: TRTLCriticalSection; dwSpinCount: DWORD): BOOL;external 'kernel32' name 'InitializeCriticalSectionAndSpinCount'; +{$endif support_smartlink} +function InitializeSid(Sid: Pointer; const pIdentifierAuthority: TSIDIdentifierAuthority; nSubAuthorityCount: Byte): BOOL; external 'advapi32' name 'InitializeSid'; +function InsertMenuItem(p1: HMENU; p2: UINT; p3: BOOL; const p4: TMenuItemInfo): BOOL;external 'user32' name 'InsertMenuItemA'; +function InsertMenuItemA(p1: HMENU; p2: UINT; p3: BOOL; const p4: TMenuItemInfoA): BOOL; external 'user32' name 'InsertMenuItemA'; +//function InsertMenuItemW(p1: HMENU; p2: UINT; p3: BOOL; const p4: TMenuItemInfoW): BOOL; external 'user32' name 'InsertMenuItemW'; +{$ifdef support_smartlink} +function InterlockedCompareExchange(var Destination: Pointer; Exchange: Pointer; Comperand: Pointer): Pointer;external 'kernel32' name 'InterlockedCompareExchange'; +{$endif support_smartlink} +function InterlockedDecrement(var Addend: longint): longint; external 'kernel32' name 'InterlockedDecrement'; +function InterlockedExchange(var Target: longint; Value: longint): longint; external 'kernel32' name 'InterlockedExchange'; +function InterlockedIncrement(var Addend: longint): longint; external 'kernel32' name 'InterlockedIncrement'; +function IntersectRect(var lprcDst: TRect; const lprcSrc1, lprcSrc2: TRect): BOOL; external 'user32' name 'IntersectRect'; +//function InvertRect(hDC: HDC; const lprc: TRect): BOOL; external 'user32' name 'InvertRect'; +function IsDialogMessage(hDlg: HWND; var lpMsg: TMsg): BOOL;external 'user32' name 'IsDialogMessageA'; +function IsDialogMessageA(hDlg: HWND; var lpMsg: TMsg): BOOL; external 'user32' name 'IsDialogMessageA'; +function IsDialogMessageW(hDlg: HWND; var lpMsg: TMsg): BOOL; external 'user32' name 'IsDialogMessageW'; +//function IsRectEmpty(const lprc: TRect): BOOL; external 'user32' name 'IsRectEmpty'; +function IsValidAcl(const pAcl: TACL): BOOL; external 'advapi32' name 'IsValidAcl'; +function LocalFileTimeToFileTime(const lpLocalFileTime: TFileTime; var lpFileTime: TFileTime): BOOL; external 'kernel32' name 'LocalFileTimeToFileTime'; +function LockFileEx(hFile: THandle; dwFlags, dwReserved: DWORD; nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh: DWORD; const lpOverlapped: TOverlapped): BOOL; external 'kernel32' name 'LockFileEx'; +function LogonUser(lpszUsername, lpszDomain, lpszPassword: PChar; dwLogonType, dwLogonProvider: DWORD; var phToken: THandle): BOOL;external 'advapi32' name 'LogonUserA'; +function LogonUserA(lpszUsername, lpszDomain, lpszPassword: LPCSTR; dwLogonType, dwLogonProvider: DWORD; var phToken: THandle): BOOL; external 'advapi32' name 'LogonUserA'; +function LogonUserW(lpszUsername, lpszDomain, lpszPassword: LPWSTR; dwLogonType, dwLogonProvider: DWORD; var phToken: THandle): BOOL; external 'advapi32' name 'LogonUserW'; +function LookupAccountName(lpSystemName, lpAccountName: PChar; Sid: PSID; var cbSid: DWORD; ReferencedDomainName: PChar; var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL;external 'advapi32' name 'LookupAccountNameA'; +function LookupAccountNameA(lpSystemName, lpAccountName: LPCSTR; Sid: PSID; var cbSid: DWORD; ReferencedDomainName: LPCSTR; var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; external 'advapi32' name 'LookupAccountNameA'; +function LookupAccountNameW(lpSystemName, lpAccountName: LPWSTR; Sid: PSID; var cbSid: DWORD; ReferencedDomainName: LPWSTR; var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; external 'advapi32' name 'LookupAccountNameW'; +function LookupAccountSid(lpSystemName: PChar; Sid: PSID; Name: PChar; var cbName: DWORD; ReferencedDomainName: PChar; var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL;external 'advapi32' name 'LookupAccountSidA'; +function LookupAccountSidA(lpSystemName: LPCSTR; Sid: PSID; Name: LPCSTR; var cbName: DWORD; ReferencedDomainName: LPCSTR; var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; external 'advapi32' name 'LookupAccountSidA'; +function LookupAccountSidW(lpSystemName: LPWSTR; Sid: PSID; Name: LPWSTR; var cbName: DWORD; ReferencedDomainName: LPWSTR; var cbReferencedDomainName: DWORD; var peUse: SID_NAME_USE): BOOL; external 'advapi32' name 'LookupAccountSidW'; +function LookupPrivilegeDisplayName(lpSystemName, lpName: LPCSTR; lpDisplayName: PChar; var cbDisplayName, lpLanguageId: DWORD): BOOL;external 'advapi32' name 'LookupPrivilegeDisplayNameA'; +function LookupPrivilegeDisplayNameA(lpSystemName, lpName: LPCSTR; lpDisplayName: LPCSTR; var cbDisplayName, lpLanguageId: DWORD): BOOL; external 'advapi32' name 'LookupPrivilegeDisplayNameA'; +function LookupPrivilegeDisplayNameW(lpSystemName, lpName: LPCSTR; lpDisplayName: LPWSTR; var cbDisplayName, lpLanguageId: DWORD): BOOL; external 'advapi32' name 'LookupPrivilegeDisplayNameW'; +function LookupPrivilegeName(lpSystemName: PChar; var lpLuid: TLargeInteger; lpName: PChar; var cbName: DWORD): BOOL;external 'advapi32' name 'LookupPrivilegeNameA'; +function LookupPrivilegeNameA(lpSystemName: LPCSTR; var lpLuid: TLargeInteger; lpName: LPCSTR; var cbName: DWORD): BOOL; external 'advapi32' name 'LookupPrivilegeNameA'; +function LookupPrivilegeNameW(lpSystemName: LPWSTR; var lpLuid: TLargeInteger; lpName: LPWSTR; var cbName: DWORD): BOOL; external 'advapi32' name 'LookupPrivilegeNameW'; +function LookupPrivilegeValue(lpSystemName, lpName: PChar; var lpLuid: TLargeInteger): BOOL;external 'advapi32' name 'LookupPrivilegeValueA'; +function LookupPrivilegeValueA(lpSystemName, lpName: LPCSTR; var lpLuid: TLargeInteger): BOOL; external 'advapi32' name 'LookupPrivilegeValueA'; +function LookupPrivilegeValueW(lpSystemName, lpName: LPWSTR; var lpLuid: TLargeInteger): BOOL; external 'advapi32' name 'LookupPrivilegeValueW'; +function LPtoDP(DC: HDC; var Points; Count: Integer): BOOL; external 'gdi32' name 'LPtoDP'; +function MakeAbsoluteSD(pSelfRelativeSecurityDescriptor: PSecurityDescriptor; pAbsoluteSecurityDescriptor: PSecurityDescriptor; var lpdwAbsoluteSecurityDescriptorSi: DWORD; var pDacl: TACL; var lpdwDaclSize: DWORD; var pSacl: TACL; + var lpdwSaclSize: DWORD; pOwner: PSID; var lpdwOwnerSize: DWORD; pPrimaryGroup: Pointer; var lpdwPrimaryGroupSize: DWORD): BOOL; external 'advapi32' name 'MakeAbsoluteSD'; +function MakeSelfRelativeSD(pAbsoluteSecurityDescriptor: PSecurityDescriptor; pSelfRelativeSecurityDescriptor: PSecurityDescriptor; var lpdwBufferLength: DWORD): BOOL; external 'advapi32' name 'MakeSelfRelativeSD'; +function MapDialogRect(hDlg: HWND; var lpRect: TRect): BOOL; external 'user32' name 'MapDialogRect'; +function MapWindowPoints(hWndFrom, hWndTo: HWND; var lpPoints; cPoints: UINT): Integer; external 'user32' name 'MapWindowPoints'; +function MessageBoxIndirect(const MsgBoxParams: TMsgBoxParams): BOOL;external 'user32' name 'MessageBoxIndirectA'; +function MessageBoxIndirectA(const MsgBoxParams: TMsgBoxParamsA): BOOL; external 'user32' name 'MessageBoxIndirectA'; +//function MessageBoxIndirectW(const MsgBoxParams: TMsgBoxParamsW): BOOL; external 'user32' name 'MessageBoxIndirectW'; +//function ModifyWorldTransform(DC: HDC; const p2: TXForm; p3: DWORD): BOOL; external 'gdi32' name 'ModifyWorldTransform'; +function MsgWaitForMultipleObjects(nCount: DWORD; var pHandles; fWaitAll: BOOL; dwMilliseconds, dwWakeMask: DWORD): DWORD;external 'user32' name 'MsgWaitForMultipleObjects'; +{$ifdef support_smartlink} +function MsgWaitForMultipleObjectsEx(nCount: DWORD; var pHandles; dwMilliseconds, dwWakeMask, dwFlags: DWORD): DWORD;external 'user32' name 'MsgWaitForMultipleObjectsEx'; +{$endif support_smartlink} +// function MultiByteToWideChar(CodePage: UINT; dwFlags: DWORD; const lpMultiByteStr: LPCSTR; cchMultiByte: Integer; lLPWSTRStr: LPWSTR; cchWideChar: Integer): Integer; external 'kernel32' name 'MultiByteToWideChar'; +function ObjectOpenAuditAlarm(SubsystemName: PChar; HandleId: Pointer; ObjectTypeName: PChar; ObjectName: PChar; pSecurityDescriptor: PSecurityDescriptor; ClientToken: THandle; DesiredAccess, GrantedAccess: DWORD; var Privileges: TPrivilegeSet; + ObjectCreation, AccessGranted: BOOL; var GenerateOnClose: BOOL): BOOL;external 'advapi32' name 'ObjectOpenAuditAlarmA'; +function ObjectOpenAuditAlarmA(SubsystemName: LPCSTR; HandleId: Pointer; ObjectTypeName: LPCSTR; ObjectName: LPCSTR; pSecurityDescriptor: PSecurityDescriptor; ClientToken: THandle; DesiredAccess, GrantedAccess: DWORD; var Privileges: TPrivilegeSet; + ObjectCreation, AccessGranted: BOOL; var GenerateOnClose: BOOL): BOOL; external 'advapi32' name 'ObjectOpenAuditAlarmA'; +function ObjectOpenAuditAlarmW(SubsystemName: LPWSTR; HandleId: Pointer; ObjectTypeName: LPWSTR; ObjectName: LPWSTR; pSecurityDescriptor: PSecurityDescriptor; ClientToken: THandle; DesiredAccess, GrantedAccess: DWORD; var Privileges: TPrivilegeSet; + ObjectCreation, AccessGranted: BOOL; var GenerateOnClose: BOOL): BOOL; external 'advapi32' name 'ObjectOpenAuditAlarmW'; +function ObjectPrivilegeAuditAlarm(SubsystemName: PChar; HandleId: Pointer; ClientToken: THandle; DesiredAccess: DWORD; var Privileges: TPrivilegeSet; AccessGranted: BOOL): BOOL;external 'advapi32' name 'ObjectPrivilegeAuditAlarmA'; +function ObjectPrivilegeAuditAlarmA(SubsystemName: LPCSTR; HandleId: Pointer; ClientToken: THandle; DesiredAccess: DWORD; var Privileges: TPrivilegeSet; AccessGranted: BOOL): BOOL; external 'advapi32' name 'ObjectPrivilegeAuditAlarmA'; +function ObjectPrivilegeAuditAlarmW(SubsystemName: LPWSTR; HandleId: Pointer; ClientToken: THandle; DesiredAccess: DWORD; var Privileges: TPrivilegeSet; AccessGranted: BOOL): BOOL; external 'advapi32' name 'ObjectPrivilegeAuditAlarmW'; + +function OffsetRect(var lprc: TRect; dx, dy: Integer): BOOL; external 'user32' name 'OffsetRect'; +function OffsetViewportOrgEx(DC: HDC; X, Y: Integer; var Points): BOOL; external 'gdi32' name 'OffsetViewportOrgEx'; +function OffsetWindowOrgEx(DC: HDC; X, Y: Integer; var Points): BOOL; external 'gdi32' name 'OffsetWindowOrgEx'; +function OpenFile(const lpFileName: LPCSTR; var lpReOpenBuff: TOFStruct; uStyle: UINT): HFILE; external 'kernel32' name 'OpenFile'; +function OpenProcessToken(ProcessHandle: THandle; DesiredAccess: DWORD; var TokenHandle: THandle): BOOL; external 'advapi32' name 'OpenProcessToken'; +function OpenThreadToken(ThreadHandle: THandle; DesiredAccess: DWORD; OpenAsSelf: BOOL; var TokenHandle: THandle): BOOL; external 'advapi32' name 'OpenThreadToken'; +function PeekConsoleInput(hConsoleInput: THandle; var lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL;external 'kernel32' name 'PeekConsoleInputA'; +function PeekConsoleInputA(hConsoleInput: THandle; var lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; external 'kernel32' name 'PeekConsoleInputA'; +function PeekConsoleInputW(hConsoleInput: THandle; var lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; external 'kernel32' name 'PeekConsoleInputW'; +function PeekMessage(var lpMsg: TMsg; hWnd: HWND; wMsgFilterMin, wMsgFilterMax, wRemoveMsg: UINT): BOOL;external 'user32' name 'PeekMessageA'; +function PeekMessageA(var lpMsg: TMsg; hWnd: HWND; wMsgFilterMin, wMsgFilterMax, wRemoveMsg: UINT): BOOL; external 'user32' name 'PeekMessageA'; +function PeekMessageW(var lpMsg: TMsg; hWnd: HWND; wMsgFilterMin, wMsgFilterMax, wRemoveMsg: UINT): BOOL; external 'user32' name 'PeekMessageW'; +//function PlayEnhMetaFile(DC: HDC; p2: HENHMETAFILE; const p3: TRect): BOOL; external 'gdi32' name 'PlayEnhMetaFile'; +function PlayEnhMetaFileRecord(DC: HDC; var p2: THandleTable; const p3: TEnhMetaRecord; p4: UINT): BOOL; external 'gdi32' name 'PlayEnhMetaFileRecord'; +function PlayMetaFileRecord(DC: HDC; const p2: THandleTable; const p3: TMetaRecord; p4: UINT): BOOL; external 'gdi32' name 'PlayMetaFileRecord'; +function PlgBlt(DC: HDC; const PointsArray; p3: HDC; p4, p5, p6, p7: Integer; p8: HBITMAP; p9, p10: Integer): BOOL; external 'gdi32' name 'PlgBlt'; +function PolyBezier(DC: HDC; const Points; Count: DWORD): BOOL; external 'gdi32' name 'PolyBezier'; +function PolyBezierTo(DC: HDC; const Points; Count: DWORD): BOOL; external 'gdi32' name 'PolyBezierTo'; +function PolyDraw(DC: HDC; const Points, Types; cCount: Integer): BOOL; external 'gdi32' name 'PolyDraw'; +function Polygon(DC: HDC; var Points; Count: Integer): BOOL; external 'gdi32' name 'Polygon'; +function Polyline(DC: HDC; var Points; Count: Integer): BOOL; external 'gdi32' name 'Polyline'; +function PolyLineTo(DC: HDC; const Points; Count: DWORD): BOOL; external 'gdi32' name 'PolylineTo'; +function PolyPolygon(DC: HDC; var Points; var nPoints; p4: Integer): BOOL; external 'gdi32' name 'PolyPolygon'; +function PolyPolyline(DC: HDC; const PointStructs; const Points; p4: DWORD): BOOL; external 'gdi32' name 'PolyPolyline'; +function PolyTextOut(DC: HDC; const PolyTextArray; Strings: Integer): BOOL;external 'gdi32' name 'PolyTextOutA'; +function PolyTextOutA(DC: HDC; const PolyTextArray; Strings: Integer): BOOL; external 'gdi32' name 'PolyTextOutA'; +function PolyTextOutW(DC: HDC; const PolyTextArray; Strings: Integer): BOOL; external 'gdi32' name 'PolyTextOutW'; +function PrivilegeCheck(ClientToken: THandle; const RequiredPrivileges: TPrivilegeSet; var pfResult: BOOL): BOOL; external 'advapi32' name 'PrivilegeCheck'; +function PrivilegedServiceAuditAlarm(SubsystemName, ServiceName: PChar; ClientToken: THandle; var Privileges: TPrivilegeSet; AccessGranted: BOOL): BOOL;external 'advapi32' name 'PrivilegedServiceAuditAlarmA'; +function PrivilegedServiceAuditAlarmA(SubsystemName, ServiceName: LPCSTR; ClientToken: THandle; var Privileges: TPrivilegeSet; AccessGranted: BOOL): BOOL; external 'advapi32' name 'PrivilegedServiceAuditAlarmA'; +function PrivilegedServiceAuditAlarmW(SubsystemName, ServiceName: LPWSTR; ClientToken: THandle; var Privileges: TPrivilegeSet; AccessGranted: BOOL): BOOL; external 'advapi32' name 'PrivilegedServiceAuditAlarmW'; +//function PtInRect(const lprc: TRect; pt: TPoint): BOOL; external 'user32' name 'PtInRect'; +function QueryPerformanceCounter(var lpPerformanceCount: TLargeInteger): BOOL; external 'kernel32' name 'QueryPerformanceCounter'; +function QueryPerformanceFrequency(var lpFrequency: TLargeInteger): BOOL; external 'kernel32' name 'QueryPerformanceFrequency'; +//function QueryRecoveryAgents(p1: PChar; var p2: Pointer; var p3: TRecoveryAgentInformation): DWORD;external 'kernel32' name 'QueryRecoveryAgentsA'; +//function QueryRecoveryAgentsA(p1: LPCSTR; var p2: Pointer; var p3: TRecoveryAgentInformationA): DWORD;external 'kernel32' name 'QueryRecoveryAgentsA'; +//function QueryRecoveryAgentsW(p1: LPWSTR; var p2: Pointer; var p3: TRecoveryAgentInformationW): DWORD;external 'kernel32' name 'QueryRecoveryAgentsW'; +procedure RaiseException(dwExceptionCode:DWORD; dwExceptionFlags:DWORD; nNumberOfArguments:DWORD; var lpArguments:DWORD); external 'kernel32' name 'RaiseException'; +function UnhandledExceptionFilter(var ExceptionInfo:emptyrecord):LONG; external 'kernel32' name 'UnhandledExceptionFilter'; +function ReadConsole(hConsoleInput: THandle; lpBuffer: Pointer; nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD; lpReserved: Pointer): BOOL;external 'kernel32' name 'ReadConsoleA'; +function ReadConsoleA(hConsoleInput: THandle; lpBuffer: Pointer; nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD; lpReserved: Pointer): BOOL; external 'kernel32' name 'ReadConsoleA'; +function ReadConsoleInput(hConsoleInput: THandle; var lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL;external 'kernel32' name 'ReadConsoleInputA'; +function ReadConsoleInputA(hConsoleInput: THandle; var lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; external 'kernel32' name 'ReadConsoleInputA'; +function ReadConsoleInputW(hConsoleInput: THandle; var lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsRead: DWORD): BOOL; external 'kernel32' name 'ReadConsoleInputW'; +function ReadConsoleOutput(hConsoleOutput: THandle; lpBuffer: Pointer; dwBufferSize, dwBufferCoord: TCoord; var lpReadRegion: TSmallRect): BOOL;external 'kernel32' name 'ReadConsoleOutputA'; +function ReadConsoleOutputA(hConsoleOutput: THandle; lpBuffer: Pointer; dwBufferSize, dwBufferCoord: TCoord; var lpReadRegion: TSmallRect): BOOL; external 'kernel32' name 'ReadConsoleOutputA'; +function ReadConsoleOutputAttribute(hConsoleOutput: THandle; lpAttribute: Pointer; nLength: DWORD; dwReadCoord: TCoord; var lpNumberOfAttrsRead: DWORD): BOOL;external 'kernel32' name 'ReadConsoleOutputAttribute'; +function ReadConsoleOutputCharacter(hConsoleOutput: THandle; lpCharacter: LPCSTR; nLength: DWORD; dwReadCoord: TCoord; var lpNumberOfCharsRead: DWORD): BOOL;external 'kernel32' name 'ReadConsoleOutputCharacterA'; +function ReadConsoleOutputCharacterA(hConsoleOutput: THandle; lpCharacter: LPCSTR; nLength: DWORD; dwReadCoord: TCoord; var lpNumberOfCharsRead: DWORD): BOOL; external 'kernel32' name 'ReadConsoleOutputCharacterA'; +function ReadConsoleOutputCharacterW(hConsoleOutput: THandle; lpCharacter: LPCSTR; nLength: DWORD; dwReadCoord: TCoord; var lpNumberOfCharsRead: DWORD): BOOL; external 'kernel32' name 'ReadConsoleOutputCharacterW'; +function ReadConsoleOutputW(hConsoleOutput: THandle; lpBuffer: Pointer; dwBufferSize, dwBufferCoord: TCoord; var lpReadRegion: TSmallRect): BOOL; external 'kernel32' name 'ReadConsoleOutputW'; +function ReadConsoleW(hConsoleInput: THandle; lpBuffer: Pointer; nNumberOfCharsToRead: DWORD; var lpNumberOfCharsRead: DWORD; lpReserved: Pointer): BOOL; external 'kernel32' name 'ReadConsoleW'; +function ReadEventLog(hEventLog: THandle; dwReadFlags, dwRecordOffset: DWORD; lpBuffer: Pointer; nNumberOfBytesToRead: DWORD; var pnBytesRead, pnMinNumberOfBytesNeeded: DWORD): BOOL;external 'advapi32' name 'ReadEventLogA'; +function ReadEventLogA(hEventLog: THandle; dwReadFlags, dwRecordOffset: DWORD; lpBuffer: Pointer; nNumberOfBytesToRead: DWORD; var pnBytesRead, pnMinNumberOfBytesNeeded: DWORD): BOOL; external 'advapi32' name 'ReadEventLogA'; +function ReadEventLogW(hEventLog: THandle; dwReadFlags, dwRecordOffset: DWORD; lpBuffer: Pointer; nNumberOfBytesToRead: DWORD; var pnBytesRead, pnMinNumberOfBytesNeeded: DWORD): BOOL; external 'advapi32' name 'ReadEventLogW'; +function ReadFile(hFile: THandle; var Buffer; nNumberOfBytesToRead: DWORD; var lpNumberOfBytesRead: DWORD; lpOverlapped: POverlapped): BOOL; external 'kernel32' name 'ReadFile'; +function ReadProcessMemory(hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer; nSize: DWORD; var lpNumberOfBytesRead: DWORD): BOOL; external 'kernel32' name 'ReadProcessMemory'; +//function RectInRegion(RGN: HRGN; const p2: TRect): BOOL; external 'gdi32' name 'RectInRegion'; +//function RectVisible(DC: HDC; const Rect: TRect): BOOL; external 'gdi32' name 'RectVisible'; +function RegConnectRegistry(lpMachineName: PChar; hKey: HKEY; var phkResult: HKEY): Longint;external 'advapi32' name 'RegConnectRegistryA'; +function RegConnectRegistryA(lpMachineName: LPCSTR; hKey: HKEY; var phkResult: HKEY): Longint; external 'advapi32' name 'RegConnectRegistryA'; +function RegConnectRegistryW(lpMachineName: LPWSTR; hKey: HKEY; var phkResult: HKEY): Longint; external 'advapi32' name 'RegConnectRegistryW'; +function RegCreateKey(hKey: HKEY; lpSubKey: PChar; var phkResult: HKEY): Longint;external 'advapi32' name 'RegCreateKeyA'; +function RegCreateKeyA(hKey: HKEY; lpSubKey: LPCSTR; var phkResult: HKEY): Longint; external 'advapi32' name 'RegCreateKeyA'; +function RegCreateKeyEx(hKey: HKEY; lpSubKey: PChar; Reserved: DWORD; lpClass: PChar; dwOptions: DWORD; samDesired: REGSAM; lpSecurityAttributes: PSecurityAttributes; var phkResult: HKEY; lpdwDisposition: PDWORD): Longint; + external 'advapi32' name 'RegCreateKeyExA'; +function RegCreateKeyExA(hKey: HKEY; lpSubKey: LPCSTR; Reserved: DWORD; lpClass: LPCSTR; dwOptions: DWORD; samDesired: REGSAM; lpSecurityAttributes: PSecurityAttributes; var phkResult: HKEY; lpdwDisposition: PDWORD): Longint; + external 'advapi32' name 'RegCreateKeyExA'; +function RegCreateKeyExW(hKey: HKEY; lpSubKey: LPWSTR; Reserved: DWORD; lpClass: LPWSTR; dwOptions: DWORD; samDesired: REGSAM; lpSecurityAttributes: PSecurityAttributes; var phkResult: HKEY; lpdwDisposition: PDWORD): Longint; + external 'advapi32' name 'RegCreateKeyExW'; +function RegCreateKeyW(hKey: HKEY; lpSubKey: LPWSTR; var phkResult: HKEY): Longint; external 'advapi32' name 'RegCreateKeyW'; +function RegEnumKeyEx(hKey: HKEY; dwIndex: DWORD; lpName: PChar; var lpcbName: DWORD; lpReserved: Pointer; lpClass: PChar; lpcbClass: PDWORD; lpftLastWriteTime: PFileTime): Longint;external 'advapi32' name 'RegEnumKeyExA'; +function RegEnumKeyExA(hKey: HKEY; dwIndex: DWORD; lpName: LPCSTR; var lpcbName: DWORD; lpReserved: Pointer; lpClass: LPCSTR; lpcbClass: PDWORD; lpftLastWriteTime: PFileTime): Longint; external 'advapi32' name 'RegEnumKeyExA'; +function RegEnumKeyExW(hKey: HKEY; dwIndex: DWORD; lpName: LPWSTR; var lpcbName: DWORD; lpReserved: Pointer; lpClass: LPWSTR; lpcbClass: PDWORD; lpftLastWriteTime: PFileTime): Longint; external 'advapi32' name 'RegEnumKeyExW'; +function RegEnumValue(hKey: HKEY; dwIndex: DWORD; lpValueName: PChar; var lpcbValueName: DWORD; lpReserved: Pointer; lpType: PDWORD; lpData: PByte; lpcbData: PDWORD): Longint;external 'advapi32' name 'RegEnumValueA'; +function RegEnumValueA(hKey: HKEY; dwIndex: DWORD; lpValueName: PChar; var lpcbValueName: DWORD; lpReserved: Pointer; lpType: PDWORD; lpData: PByte; lpcbData: PDWORD): Longint; external 'advapi32' name 'RegEnumValueA'; +function RegEnumValueW(hKey: HKEY; dwIndex: DWORD; lpValueName: PChar; var lpcbValueName: DWORD; lpReserved: Pointer; lpType: PDWORD; lpData: PByte; lpcbData: PDWORD): Longint; external 'advapi32' name 'RegEnumValueW'; +function RegGetKeySecurity(hKey: HKEY; SecurityInformation: SECURITY_INFORMATION; pSecurityDescriptor: PSecurityDescriptor; var lpcbSecurityDescriptor: DWORD): Longint; external 'advapi32' name 'RegGetKeySecurity'; +function RegisterClass(const lpWndClass: TWndClass): ATOM;external 'user32' name 'RegisterClassA'; +function RegisterClassA(const lpWndClass: TWndClassA): ATOM; external 'user32' name 'RegisterClassA'; +function RegisterClassEx(const WndClass: TWndClassEx): ATOM;external 'user32' name 'RegisterClassExA'; +function RegisterClassExA(const WndClass: TWndClassExA): ATOM; external 'user32' name 'RegisterClassExA'; +function RegisterClassExW(const WndClass: TWndClassExW): ATOM; external 'user32' name 'RegisterClassExW'; +function RegisterClassW(const lpWndClass: TWndClassW): ATOM; external 'user32' name 'RegisterClassW'; +function RegOpenKey(hKey: HKEY; lpSubKey: PChar; var phkResult: HKEY): Longint;external 'advapi32' name 'RegOpenKeyA'; +function RegOpenKeyA(hKey: HKEY; lpSubKey: LPCSTR; var phkResult: HKEY): Longint; external 'advapi32' name 'RegOpenKeyA'; +function RegOpenKeyEx(hKey: HKEY; lpSubKey: PChar; ulOptions: DWORD; samDesired: REGSAM; var phkResult: HKEY): Longint;external 'advapi32' name 'RegOpenKeyExA'; +function RegOpenKeyExA(hKey: HKEY; lpSubKey: LPCSTR; ulOptions: DWORD; samDesired: REGSAM; var phkResult: HKEY): Longint; external 'advapi32' name 'RegOpenKeyExA'; +function RegOpenKeyExW(hKey: HKEY; lpSubKey: LPWSTR; ulOptions: DWORD; samDesired: REGSAM; var phkResult: HKEY): Longint; external 'advapi32' name 'RegOpenKeyExW'; +function RegOpenKeyW(hKey: HKEY; lpSubKey: LPWSTR; var phkResult: HKEY): Longint; external 'advapi32' name 'RegOpenKeyW'; +function RegQueryMultipleValues(hKey: HKEY; var ValList; NumVals: DWORD; lpValueBuf: PChar; var ldwTotsize: DWORD): Longint;external 'advapi32' name 'RegQueryMultipleValuesA'; +function RegQueryMultipleValuesA(hKey: HKEY; var ValList; NumVals: DWORD; lpValueBuf: LPCSTR; var ldwTotsize: DWORD): Longint; external 'advapi32' name 'RegQueryMultipleValuesA'; +function RegQueryMultipleValuesW(hKey: HKEY; var ValList; NumVals: DWORD; lpValueBuf: LPWSTR; var ldwTotsize: DWORD): Longint; external 'advapi32' name 'RegQueryMultipleValuesW'; +function RegQueryValue(hKey: HKEY; lpSubKey: PChar; lpValue: PChar; var lpcbValue: Longint): Longint;external 'advapi32' name 'RegQueryValueA'; +function RegQueryValueA(hKey: HKEY; lpSubKey: LPCSTR; lpValue: LPCSTR; var lpcbValue: Longint): Longint; external 'advapi32' name 'RegQueryValueA'; +function RegQueryValueW(hKey: HKEY; lpSubKey: LPWSTR; lpValue: LPWSTR; var lpcbValue: Longint): Longint; external 'advapi32' name 'RegQueryValueW'; +function ResetDC(DC: HDC; const p2: TDeviceMode): HDC;external 'gdi32' name 'ResetDCA'; +function ResetDCA(DC: HDC; const p2: TDeviceModeA): HDC; external 'gdi32' name 'ResetDCA'; +//function ResetDCW(DC: HDC; const p2: TDeviceModeW): HDC; external 'gdi32' name 'ResetDCW'; +function ScreenToClient(hWnd: HWND; var lpPoint: TPoint): BOOL; external 'user32' name 'ScreenToClient'; +function ScrollConsoleScreenBuffer(hConsoleOutput: THandle; const lpScrollRectangle: TSmallRect; const lpClipRectangle: TSmallRect; dwDestinationOrigin: TCoord; var lpFill: TCharInfo): BOOL;external 'kernel32' name 'ScrollConsoleScreenBufferA'; +function ScrollConsoleScreenBufferA(hConsoleOutput: THandle; const lpScrollRectangle: TSmallRect; const lpClipRectangle: TSmallRect; dwDestinationOrigin: TCoord; var lpFill: TCharInfo): BOOL; external 'kernel32' name 'ScrollConsoleScreenBufferA'; +function ScrollConsoleScreenBufferW(hConsoleOutput: THandle; const lpScrollRectangle: TSmallRect; const lpClipRectangle: TSmallRect; dwDestinationOrigin: TCoord; var lpFill: TCharInfo): BOOL; external 'kernel32' name 'ScrollConsoleScreenBufferW'; +function ScrollWindow(hWnd:HWND; XAmount:longint; YAmount:longint;lpRect:lpRECT; lpClipRect:lpRECT):WINBOOL; external 'user32' name 'ScrollWindow'; +function ScrollWindowEx(hWnd:HWND; dx:longint; dy:longint; prcScroll:lpRECT; prcClip:lpRECT;hrgnUpdate:HRGN; prcUpdate:LPRECT; flags:UINT):longint; external 'user32' name 'ScrollWindowEx'; +//function ScrollDC(DC: HDC; DX, DY: Integer; var Scroll, Clip: TRect; Rgn: HRGN; Update: PRect): BOOL; external 'user32' name 'ScrollDC'; +//function SearchPath(lpPath, lpFileName, lpExtension: PChar; nBufferLength: DWORD; lpBuffer: PChar; var lpFilePart: PChar): DWORD;external 'kernel32' name 'SearchPathA'; +//function SearchPathA(lpPath, lpFileName, lpExtension: LPCSTR; nBufferLength: DWORD; lpBuffer: LPCSTR; var lpFilePart: LPCSTR): DWORD; external 'kernel32' name 'SearchPathA'; +//function SearchPathW(lpPath, lpFileName, lpExtension: LPWSTR; nBufferLength: DWORD; lpBuffer: LPWSTR; var lpFilePart: LPWSTR): DWORD; external 'kernel32' name 'SearchPathW'; +//function SendInput(cInputs: UINT; var pInputs: TInput; cbSize: Integer): UINT;external 'user32' name 'SendInput'; +function SendMessageTimeout(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM; fuFlags, uTimeout: UINT; var lpdwResult: DWORD): LRESULT;external 'user32' name 'SendMessageTimeoutA'; +function SendMessageTimeoutA(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM; fuFlags, uTimeout: UINT; var lpdwResult: DWORD): LRESULT; external 'user32' name 'SendMessageTimeoutA'; +function SendMessageTimeoutW(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM; fuFlags, uTimeout: UINT; var lpdwResult: DWORD): LRESULT; external 'user32' name 'SendMessageTimeoutW'; +//function SetAclInformation(var pAcl: TACL; pAclInformation: Pointer; nAclInformationLength: DWORD; dwAclInformationClass: TAclInformationClass): BOOL; external 'advapi32' name 'SetAclInformation'; +//function SetColorAdjustment(DC: HDC; const p2: TColorAdjustment): BOOL; external 'gdi32' name 'SetColorAdjustment'; +function SetCommConfig(hCommDev: THandle; const lpCC: TCommConfig; dwSize: DWORD): BOOL; external 'kernel32' name 'SetCommConfig'; +function SetCommState(hFile: THandle; const lpDCB: TDCB): BOOL; external 'kernel32' name 'SetCommState'; +function SetCommTimeouts(hFile: THandle; const lpCommTimeouts: TCommTimeouts): BOOL; external 'kernel32' name 'SetCommTimeouts'; +function SetConsoleCursorInfo(hConsoleOutput: THandle; const lpConsoleCursorInfo: TConsoleCursorInfo): BOOL; external 'kernel32' name 'SetConsoleCursorInfo'; +//function SetConsoleWindowInfo(hConsoleOutput: THandle; bAbsolute: BOOL; const lpConsoleWindow: TSmallRect): BOOL; external 'kernel32' name 'SetConsoleWindowInfo'; +{$ifdef support_smartlink} +function SetCriticalSectionSpinCount(var lpCriticalSection: TRTLCriticalSection; dwSpinCount: DWORD): DWORD;external 'kernel32' name 'SetCriticalSectionSpinCount'; +{$endif support_smartlink} +function SetDeviceGammaRamp(DC: HDC; var Ramp): BOOL; external 'gdi32' name 'SetDeviceGammaRamp'; +function SetDIBColorTable(DC: HDC; p2, p3: UINT; var RGBQuadSTructs): UINT; external 'gdi32' name 'SetDIBColorTable'; +function SetDIBits(DC: HDC; Bitmap: HBITMAP; StartScan, NumScans: UINT; Bits: Pointer; var BitsInfo: TBitmapInfo; Usage: UINT): Integer; external 'gdi32' name 'SetDIBits'; +//function SetDIBitsToDevice(DC: HDC; DestX, DestY: Integer; Width, Height: DWORD; SrcX, SrcY: Integer; nStartScan, NumScans: UINT; Bits: Pointer; var BitsInfo: TBitmapInfo; Usage: UINT): Integer; external 'gdi32' name 'SetDIBitsToDevice'; +function SetFileTime(hFile:HANDLE; var lpCreationTime:FILETIME; var lpLastAccessTime:FILETIME; var lpLastWriteTime:FILETIME):WINBOOL; external 'kernel32' name 'SetFileTime'; +//function SetKeyboardState(var KeyState: TKeyboardState): BOOL; external 'user32' name 'SetKeyboardState'; +//function SetLocalTime(const lpSystemTime: TSystemTime): BOOL; external 'kernel32' name 'SetLocalTime'; +//function SetMenuInfo(hMenu: HMENU; const lpcmi: TMenuInfo): BOOL;external 'user32' name 'SetMenuInfo'; +function SetMenuItemInfo(p1: HMENU; p2: UINT; p3: BOOL; const p4: TMenuItemInfo): BOOL;external 'user32' name 'SetMenuItemInfoA'; +function SetMenuItemInfoA(p1: HMENU; p2: UINT; p3: BOOL; const p4: TMenuItemInfoA): BOOL; external 'user32' name 'SetMenuItemInfoA'; +//function SetMenuItemInfoW(p1: HMENU; p2: UINT; p3: BOOL; const p4: TMenuItemInfoW): BOOL; external 'user32' name 'SetMenuItemInfoW'; +function SetMetaFileBitsEx(p1: UINT; const p2: PChar): HMETAFILE; external 'gdi32' name 'SetMetaFileBitsEx'; +function SetNamedPipeHandleState(hNamedPipe: THandle; var lpMode: DWORD; lpMaxCollectionCount, lpCollectDataTimeout: Pointer): BOOL; external 'kernel32' name 'SetNamedPipeHandleState'; +function SetPaletteEntries(Palette: HPALETTE; StartIndex, NumEntries: UINT; var PaletteEntries): UINT; external 'gdi32' name 'SetPaletteEntries'; +//function SetPrivateObjectSecurity(SecurityInformation: SECURITY_INFORMATION; ModificationDescriptor: PSecurityDescriptor; var ObjectsSecurityDescriptor: PSecurityDescriptor; const GenericMapping: TGenericMapping; Token: THandle): BOOL; +// external 'advapi32' name 'SetPrivateObjectSecurity'; +//function SetPrivateObjectSecurityEx(SecurityInformation: SECURITY_INFORMATION; ModificationDescriptor: PSecurityDescriptor; var ObjectsSecurityDescriptor: PSecurityDescriptor; AutoInheritFlags: ULONG; +// const GenericMapping: TGenericMapping; Token: THandle): BOOL;external 'advapi32' name 'SetPrivateObjectSecurityEx'; +function SetRect(var lprc: TRect; xLeft, yTop, xRight, yBottom: Integer): BOOL; external 'user32' name 'SetRect'; +function SetRectEmpty(var lprc: TRect): BOOL; external 'user32' name 'SetRectEmpty'; +function SetScrollInfo(hWnd: HWND; BarFlag: Integer; const ScrollInfo: TScrollInfo; Redraw: BOOL): Integer; external 'user32' name 'SetScrollInfo'; +function SetSysColors(cElements: Integer; const lpaElements; const lpaRgbValues): BOOL; external 'user32' name 'SetSysColors'; +//function SetSystemTime(const lpSystemTime: TSystemTime): BOOL; external 'kernel32' name 'SetSystemTime'; +function SetThreadContext(hThread: THandle; const lpContext: TContext): BOOL; external 'kernel32' name 'SetThreadContext'; +//function SetTimeZoneInformation(const lpTimeZoneInformation: TTimeZoneInformation): BOOL; external 'kernel32' name 'SetTimeZoneInformation'; +function SetUserObjectSecurity(hObj: THandle; var pSIRequested: DWORD; pSID: PSecurityDescriptor): BOOL;external 'user32' name 'SetUserObjectSecurity'; +function SetWaitableTimer(hTimer: THandle; const lpDueTime: TLargeInteger; lPeriod: Longint; pfnCompletionRoutine: TFNTimerAPCRoutine; lpArgToCompletionRoutine: Pointer; fResume: BOOL): BOOL;external 'kernel32' name 'SetWaitableTimer'; +function SetWinMetaFileBits(p1: UINT; p2: PChar; p3: HDC; const p4: TMetaFilePict): HENHMETAFILE; external 'gdi32' name 'SetWinMetaFileBits'; +//function SetWorldTransform(DC: HDC; const p2: TXForm): BOOL; external 'gdi32' name 'SetWorldTransform'; +function StartDoc(DC: HDC; const p2: TDocInfo): Integer;external 'gdi32' name 'StartDocA'; +function StartDocA(DC: HDC; const p2: TDocInfoA): Integer; external 'gdi32' name 'StartDocA'; +//function StartDocW(DC: HDC; const p2: TDocInfoW): Integer; external 'gdi32' name 'StartDocW'; +//function StretchDIBits(DC: HDC; DestX, DestY, DestWidth, DestHegiht, SrcX, SrcY, SrcWidth, SrcHeight: Integer; Bits: Pointer; var BitsInfo: TBitmapInfo; Usage: UINT; Rop: DWORD): Integer; external 'gdi32' name 'StretchDIBits'; +function SubtractRect(var lprcDst: TRect; const lprcSrc1, lprcSrc2: TRect): BOOL; external 'user32' name 'SubtractRect'; +function SystemTimeToFileTime(const lpSystemTime: TSystemTime; var lpFileTime: TFileTime): BOOL; external 'kernel32' name 'SystemTimeToFileTime'; +function SystemTimeToTzSpecificLocalTime(lpTimeZoneInformation: PTimeZoneInformation; var lpUniversalTime, lpLocalTime: TSystemTime): BOOL; external 'kernel32' name 'SystemTimeToTzSpecificLocalTime'; +function TabbedTextOut(hDC: HDC; X, Y: Integer; lpString: PChar; nCount, nTabPositions: Integer; var lpnTabStopPositions; nTabOrigin: Integer): Longint;external 'user32' name 'TabbedTextOutA'; +function TabbedTextOutA(hDC: HDC; X, Y: Integer; lpString: LPCSTR; nCount, nTabPositions: Integer; var lpnTabStopPositions; nTabOrigin: Integer): Longint; external 'user32' name 'TabbedTextOutA'; +function TabbedTextOutW(hDC: HDC; X, Y: Integer; lpString: LPWSTR; nCount, nTabPositions: Integer; var lpnTabStopPositions; nTabOrigin: Integer): Longint; external 'user32' name 'TabbedTextOutW'; +//function ToAscii(uVirtKey, uScanCode: UINT; const KeyState: TKeyboardState; lpChar: PChar; uFlags: UINT): Integer; external 'user32' name 'ToAscii'; +//function ToAsciiEx(uVirtKey: UINT; uScanCode: UINT; const KeyState: TKeyboardState; lpChar: PChar; uFlags: UINT; dwhkl: HKL): Integer; external 'user32' name 'ToAsciiEx'; +//function ToUnicode(wVirtKey, wScanCode: UINT; const KeyState: TKeyboardState; var pwszBuff; cchBuff: Integer; wFlags: UINT): Integer; external 'user32' name 'ToUnicode'; +// Careful, NT and higher only. +function TrackMouseEvent(var EventTrack: TTrackMouseEvent): BOOL;external 'user32' name 'TrackMouseEvent'; +function TrackMouseEvent(lpEventTrack: PTrackMouseEvent): BOOL;external 'user32' name 'TrackMouseEvent'; +function TransactNamedPipe(hNamedPipe: THandle; lpInBuffer: Pointer; nInBufferSize: DWORD; lpOutBuffer: Pointer; nOutBufferSize: DWORD; var lpBytesRead: DWORD; lpOverlapped: POverlapped): BOOL; external 'kernel32' name 'TransactNamedPipe'; +function TranslateAccelerator(hWnd: HWND; hAccTable: HACCEL; var lpMsg: TMsg): Integer;external 'user32' name 'TranslateAcceleratorA'; +function TranslateAcceleratorA(hWnd: HWND; hAccTable: HACCEL; var lpMsg: TMsg): Integer; external 'user32' name 'TranslateAcceleratorA'; +function TranslateAcceleratorW(hWnd: HWND; hAccTable: HACCEL; var lpMsg: TMsg): Integer; external 'user32' name 'TranslateAcceleratorW'; +function TranslateCharsetInfo(var lpSrc: DWORD; var lpCs: TCharsetInfo; dwFlags: DWORD): BOOL; external 'gdi32' name 'TranslateCharsetInfo'; +function TranslateMDISysAccel(hWndClient: HWND; const lpMsg: TMsg): BOOL; external 'user32' name 'TranslateMDISysAccel'; +function TranslateMessage(const lpMsg: TMsg): BOOL; external 'user32' name 'TranslateMessage'; +//function TransparentDIBits(DC: HDC; p2, p3, p4, p5: Integer; const p6: Pointer; const p7: PBitmapInfo; p8: UINT; p9, p10, p11, p12: Integer; p13: UINT): BOOL;external 'gdi32' name 'TransparentDIBits'; +{$ifdef support_smartlink} +function TryEnterCriticalSection(var lpCriticalSection: TRTLCriticalSection): BOOL;external 'kernel32' name 'TryEnterCriticalSection'; +{$endif support_smartlink} +function UnhandledExceptionFilter(const ExceptionInfo: TExceptionPointers): Longint; external 'kernel32' name 'UnhandledExceptionFilter'; +function UnionRect(var lprcDst: TRect; const lprcSrc1, lprcSrc2: TRect): BOOL; external 'user32' name 'UnionRect'; +function UnlockFileEx(hFile: THandle; dwReserved, nNumberOfBytesToUnlockLow: DWORD; nNumberOfBytesToUnlockHigh: DWORD; const lpOverlapped: TOverlapped): BOOL; external 'kernel32' name 'UnlockFileEx'; +function VerFindFile(uFlags: DWORD; szFileName, szWinDir, szAppDir, szCurDir: PChar; var lpuCurDirLen: UINT; szDestDir: PChar; var lpuDestDirLen: UINT): DWORD;external 'version' name 'VerFindFileA'; +function VerFindFileA(uFlags: DWORD; szFileName, szWinDir, szAppDir, szCurDir: LPCSTR; var lpuCurDirLen: UINT; szDestDir: LPCSTR; var lpuDestDirLen: UINT): DWORD; external 'version' name 'VerFindFileA'; +function VerFindFileW(uFlags: DWORD; szFileName, szWinDir, szAppDir, szCurDir: LPWSTR; var lpuCurDirLen: UINT; szDestDir: LPWSTR; var lpuDestDirLen: UINT): DWORD; external 'version' name 'VerFindFileW'; +function VerInstallFile(uFlags: DWORD; szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile: PChar; var lpuTmpFileLen: UINT): DWORD;external 'version' name 'VerInstallFileA'; +function VerInstallFileA(uFlags: DWORD; szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile: LPCSTR; var lpuTmpFileLen: UINT): DWORD; external 'version' name 'VerInstallFileA'; +function VerInstallFileW(uFlags: DWORD; szSrcFileName, szDestFileName, szSrcDir, szDestDir, szCurDir, szTmpFile: LPWSTR; var lpuTmpFileLen: UINT): DWORD; external 'version' name 'VerInstallFileW'; +function VerQueryValue(pBlock: Pointer; lpSubBlock: PChar; var lplpBuffer: Pointer; var puLen: UINT): BOOL;external 'version' name 'VerQueryValueA'; +function VerQueryValueA(pBlock: Pointer; lpSubBlock: LPCSTR; var lplpBuffer: Pointer; var puLen: UINT): BOOL; external 'version' name 'VerQueryValueA'; +function VerQueryValueW(pBlock: Pointer; lpSubBlock: LPWSTR; var lplpBuffer: Pointer; var puLen: UINT): BOOL; external 'version' name 'VerQueryValueW'; +function VirtualQuery(lpAddress: Pointer; var lpBuffer: TMemoryBasicInformation; dwLength: DWORD): DWORD; external 'kernel32' name 'VirtualQuery'; +function VirtualQueryEx(hProcess: THandle; lpAddress: Pointer; var lpBuffer: TMemoryBasicInformation; dwLength: DWORD): DWORD; external 'kernel32' name 'VirtualQueryEx'; +function WaitCommEvent(hFile: THandle; var lpEvtMask: DWORD; lpOverlapped: POverlapped): BOOL; external 'kernel32' name 'WaitCommEvent'; +function WaitForDebugEvent(var lpDebugEvent: TDebugEvent; dwMilliseconds: DWORD): BOOL; external 'kernel32' name 'WaitForDebugEvent'; +function wglDescribeLayerPlane(p1: HDC; p2, p3: Integer; p4: Cardinal; var p5: TLayerPlaneDescriptor): BOOL;external 'opengl32' name 'wglDescribeLayerPlane'; +function wglGetLayerPaletteEntries(p1: HDC; p2, p3, p4: Integer; var pcr): Integer;external 'opengl32' name 'wglGetLayerPaletteEntries'; +function wglSetLayerPaletteEntries(p1: HDC; p2, p3, p4: Integer; var pcr): Integer;external 'opengl32' name 'wglSetLayerPaletteEntries'; +//function wglSwapMultipleBuffers(p1: UINT; const p2: PWGLSwap): DWORD;external 'opengl32' name 'wglSwapMultipleBuffers'; +//function WinSubmitCertificate(var lpCertificate: TWinCertificate): BOOL;external 'imaghlp' name 'WinSubmitCertificate'; +//function WinVerifyTrust(hwnd: HWND; const ActionID: TGUID; ActionData: Pointer): Longint;external 'imaghlp' name 'WinVerifyTrust'; +function WNetAddConnection2(var lpNetResource: TNetResource; lpPassword, lpUserName: PChar; dwFlags: DWORD): DWORD;external 'mpr' name 'WNetAddConnection2A'; +function WNetAddConnection2A(var lpNetResource: TNetResourceA; lpPassword, lpUserName: LPCSTR; dwFlags: DWORD): DWORD; external 'mpr' name 'WNetAddConnection2A'; +//function WNetAddConnection2W(var lpNetResource: TNetResourceW; lpPassword, lpUserName: LPWSTR; dwFlags: DWORD): DWORD; external 'mpr' name 'WNetAddConnection2W'; +function WNetAddConnection3(hwndOwner: HWND; var lpNetResource: TNetResource; lpPassword, lpUserName: PChar; dwFlags: DWORD): DWORD;external 'mpr' name 'WNetAddConnection3A'; +function WNetAddConnection3A(hwndOwner: HWND; var lpNetResource: TNetResourceA; lpPassword, lpUserName: LPCSTR; dwFlags: DWORD): DWORD; external 'mpr' name 'WNetAddConnection3A'; +//function WNetAddConnection3W(hwndOwner: HWND; var lpNetResource: TNetResourceW; lpPassword, lpUserName: LPWSTR; dwFlags: DWORD): DWORD; external 'mpr' name 'WNetAddConnection3W'; +function WNetConnectionDialog1(var lpConnDlgStruct: TConnectDlgStruct): DWORD;external 'mpr' name 'WNetConnectionDialog1A'; +function WNetConnectionDialog1A(var lpConnDlgStruct: TConnectDlgStruct): DWORD; external 'mpr' name 'WNetConnectionDialog1A'; +//function WNetConnectionDialog1W(var lpConnDlgStruct: TConnectDlgStruct): DWORD; external 'mpr' name 'WNetConnectionDialog1W'; +function WNetDisconnectDialog1(var lpConnDlgStruct: TDiscDlgStruct): DWORD;external 'mpr' name 'WNetDisconnectDialog1A'; +function WNetDisconnectDialog1A(var lpConnDlgStruct: TDiscDlgStructA): DWORD; external 'mpr' name 'WNetDisconnectDialog1A'; +//function WNetDisconnectDialog1W(var lpConnDlgStruct: TDiscDlgStructW): DWORD; external 'mpr' name 'WNetDisconnectDialog1W'; +function WNetEnumResource(hEnum: THandle; var lpcCount: DWORD; lpBuffer: Pointer; var lpBufferSize: DWORD): DWORD;external 'mpr' name 'WNetEnumResourceA'; +function WNetEnumResourceA(hEnum: THandle; var lpcCount: DWORD; lpBuffer: Pointer; var lpBufferSize: DWORD): DWORD; external 'mpr' name 'WNetEnumResourceA'; +function WNetEnumResourceW(hEnum: THandle; var lpcCount: DWORD; lpBuffer: Pointer; var lpBufferSize: DWORD): DWORD; external 'mpr' name 'WNetEnumResourceW'; +function WNetGetConnection(lpLocalName: PChar; lpRemoteName: PChar; var lpnLength: DWORD): DWORD;external 'mpr' name 'WNetGetConnectionA'; +function WNetGetConnectionA(lpLocalName: LPCSTR; lpRemoteName: LPCSTR; var lpnLength: DWORD): DWORD; external 'mpr' name 'WNetGetConnectionA'; +function WNetGetConnectionW(lpLocalName: LPWSTR; lpRemoteName: LPWSTR; var lpnLength: DWORD): DWORD; external 'mpr' name 'WNetGetConnectionW'; +function WNetGetLastError(var lpError: DWORD; lpErrorBuf: PChar; nErrorBufSize: DWORD; lpNameBuf: PChar; nNameBufSize: DWORD): DWORD;external 'mpr' name 'WNetGetLastErrorA'; +function WNetGetLastErrorA(var lpError: DWORD; lpErrorBuf: LPCSTR; nErrorBufSize: DWORD; lpNameBuf: LPCSTR; nNameBufSize: DWORD): DWORD; external 'mpr' name 'WNetGetLastErrorA'; +function WNetGetLastErrorW(var lpError: DWORD; lpErrorBuf: LPWSTR; nErrorBufSize: DWORD; lpNameBuf: LPWSTR; nNameBufSize: DWORD): DWORD; external 'mpr' name 'WNetGetLastErrorW'; +function WNetGetNetworkInformation(lpProvider: PChar; var lpNetInfoStruct: TNetInfoStruct): DWORD;external 'mpr' name 'WNetGetNetworkInformationA'; +function WNetGetNetworkInformationA(lpProvider: LPCSTR; var lpNetInfoStruct: TNetInfoStruct): DWORD; external 'mpr' name 'WNetGetNetworkInformationA'; +function WNetGetNetworkInformationW(lpProvider: LPWSTR; var lpNetInfoStruct: TNetInfoStruct): DWORD; external 'mpr' name 'WNetGetNetworkInformationW'; +function WNetGetProviderName(dwNetType: DWORD; lpProviderName: PChar; var lpBufferSize: DWORD): DWORD;external 'mpr' name 'WNetGetProviderNameA'; +function WNetGetProviderNameA(dwNetType: DWORD; lpProviderName: LPCSTR; var lpBufferSize: DWORD): DWORD; external 'mpr' name 'WNetGetProviderNameA'; +function WNetGetProviderNameW(dwNetType: DWORD; lpProviderName: LPWSTR; var lpBufferSize: DWORD): DWORD; external 'mpr' name 'WNetGetProviderNameW'; +function WNetGetResourceParent(lpNetResource: PNetResource; lpBuffer: Pointer; var cbBuffer: DWORD): DWORD;external 'mpr' name 'WNetGetResourceParentA'; +function WNetGetResourceParentA(lpNetResource: PNetResourceA; lpBuffer: Pointer; var cbBuffer: DWORD): DWORD;external 'mpr' name 'WNetGetResourceParentA'; +//function WNetGetResourceParentW(lpNetResource: PNetResourceW; lpBuffer: Pointer; var cbBuffer: DWORD): DWORD;external 'mpr' name 'WNetGetResourceParentW'; +function WNetGetUniversalName(lpLocalPath: PChar; dwInfoLevel: DWORD; lpBuffer: Pointer; var lpBufferSize: DWORD): DWORD;external 'mpr' name 'WNetGetUniversalNameA'; +function WNetGetUniversalNameA(lpLocalPath: LPCSTR; dwInfoLevel: DWORD; lpBuffer: Pointer; var lpBufferSize: DWORD): DWORD; external 'mpr' name 'WNetGetUniversalNameA'; +function WNetGetUniversalNameW(lpLocalPath: LPWSTR; dwInfoLevel: DWORD; lpBuffer: Pointer; var lpBufferSize: DWORD): DWORD; external 'mpr' name 'WNetGetUniversalNameW'; +function WNetGetUser(lpName: PChar; lpUserName: PChar; var lpnLength: DWORD): DWORD;external 'mpr' name 'WNetGetUserA'; +function WNetGetUserA(lpName: LPCSTR; lpUserName: LPCSTR; var lpnLength: DWORD): DWORD; external 'mpr' name 'WNetGetUserA'; +function WNetGetUserW(lpName: LPWSTR; lpUserName: LPWSTR; var lpnLength: DWORD): DWORD; external 'mpr' name 'WNetGetUserW'; +function WNetOpenEnum(dwScope, dwType, dwUsage: DWORD; lpNetResource: PNetResource; var lphEnum: THandle): DWORD;external 'mpr' name 'WNetOpenEnumA'; +function WNetOpenEnumA(dwScope, dwType, dwUsage: DWORD; lpNetResource: PNetResourceA; var lphEnum: THandle): DWORD; external 'mpr' name 'WNetOpenEnumA'; +//function WNetOpenEnumW(dwScope, dwType, dwUsage: DWORD; lpNetResource: PNetResourceW; var lphEnum: THandle): DWORD; external 'mpr' name 'WNetOpenEnumW'; +function WNetUseConnection(hwndOwner: HWND; var lpNetResource: TNetResource; lpUserID: PChar; lpPassword: PChar; dwFlags: DWORD; lpAccessName: PChar; var lpBufferSize: DWORD; var lpResult: DWORD): DWORD;external 'mpr' name 'WNetUseConnectionA'; +function WNetUseConnectionA(hwndOwner: HWND; var lpNetResource: TNetResourceA; lpUserID: LPCSTR; lpPassword: LPCSTR; dwFlags: DWORD; lpAccessName: LPCSTR; var lpBufferSize: DWORD; var lpResult: DWORD): DWORD; external 'mpr' name 'WNetUseConnectionA'; +//function WNetUseConnectionW(hwndOwner: HWND; var lpNetResource: TNetResourceW; lpUserID: LPWSTR; lpPassword: LPWSTR; dwFlags: DWORD; lpAccessName: LPWSTR; var lpBufferSize: DWORD; var lpResult: DWORD): DWORD; external 'mpr' name 'WNetUseConnectionW'; +function WriteConsole(hConsoleOutput: THandle; const lpBuffer: Pointer; nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD; lpReserved: Pointer): BOOL;external 'kernel32' name 'WriteConsoleA'; +function WriteConsoleA(hConsoleOutput: THandle; const lpBuffer: Pointer; nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD; lpReserved: Pointer): BOOL; external 'kernel32' name 'WriteConsoleA'; +function WriteConsoleInput(hConsoleInput: THandle; const lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL;external 'kernel32' name 'WriteConsoleInputA'; +function WriteConsoleInputA(hConsoleInput: THandle; const lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; external 'kernel32' name 'WriteConsoleInputA'; +function WriteConsoleInputW(hConsoleInput: THandle; const lpBuffer: TInputRecord; nLength: DWORD; var lpNumberOfEventsWritten: DWORD): BOOL; external 'kernel32' name 'WriteConsoleInputW'; +function WriteConsoleOutput(hConsoleOutput: THandle; lpBuffer: Pointer; dwBufferSize, dwBufferCoord: TCoord; var lpWriteRegion: TSmallRect): BOOL;external 'kernel32' name 'WriteConsoleOutputA'; +function WriteConsoleOutputA(hConsoleOutput: THandle; lpBuffer: Pointer; dwBufferSize, dwBufferCoord: TCoord; var lpWriteRegion: TSmallRect): BOOL; external 'kernel32' name 'WriteConsoleOutputA'; +function WriteConsoleOutputAttribute(hConsoleOutput: THandle; lpAttribute: Pointer; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfAttrsWritten: DWORD): BOOL; external 'kernel32' name 'WriteConsoleOutputAttribute'; +function WriteConsoleOutputCharacter(hConsoleOutput: THandle;lpCharacter: PChar; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfCharsWritten: DWORD): BOOL;external 'kernel32' name 'WriteConsoleOutputCharacterA'; +function WriteConsoleOutputCharacterA(hConsoleOutput: THandle;lpCharacter: LPCSTR; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfCharsWritten: DWORD): BOOL; external 'kernel32' name 'WriteConsoleOutputCharacterA'; +function WriteConsoleOutputCharacterW(hConsoleOutput: THandle;lpCharacter: LPWSTR; nLength: DWORD; dwWriteCoord: TCoord; var lpNumberOfCharsWritten: DWORD): BOOL; external 'kernel32' name 'WriteConsoleOutputCharacterW'; +function WriteConsoleOutputW(hConsoleOutput: THandle; lpBuffer: Pointer; dwBufferSize, dwBufferCoord: TCoord; var lpWriteRegion: TSmallRect): BOOL; external 'kernel32' name 'WriteConsoleOutputW'; +function WriteConsoleW(hConsoleOutput: THandle; const lpBuffer: Pointer; nNumberOfCharsToWrite: DWORD; var lpNumberOfCharsWritten: DWORD; lpReserved: Pointer): BOOL; external 'kernel32' name 'WriteConsoleW'; +function WriteFile(hFile: THandle; const Buffer; nNumberOfBytesToWrite: DWORD; var lpNumberOfBytesWritten: DWORD; lpOverlapped: POverlapped): BOOL; external 'kernel32' name 'WriteFile'; +function WriteFileEx(hFile: THandle; lpBuffer: Pointer; nNumberOfBytesToWrite: DWORD; const lpOverlapped: TOverlapped; lpCompletionRoutine: FARPROC): BOOL; external 'kernel32' name 'WriteFileEx'; +function WriteProcessMemory(hProcess: THandle; const lpBaseAddress: Pointer; lpBuffer: Pointer; nSize: DWORD; var lpNumberOfBytesWritten: DWORD): BOOL; external 'kernel32' name 'WriteProcessMemory'; + +// these are old Win16 funcs that under win32 are aliases for several char* funcs. +// exist under Win32 (even in SDK's from 2002), but are officially "depreciated" +function AnsiNext(const lpsz: LPCSTR): LPSTR;external 'user32' name 'CharNextA'; +function AnsiPrev(const lpszStart: LPCSTR; const lpszCurrent: LPCSTR): LPSTR;external 'user32' name 'CharPrevA'; +function AnsiToOem(const lpszSrc: LPCSTR; lpszDst: LPSTR): BOOL;external 'user32' name 'CharToOemA'; +function OemToAnsi(const lpszSrc: LPCSTR; lpszDst: LPSTR): BOOL;external 'user32' name 'OemToCharA'; +function AnsiToOemBuff(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):WINBOOL; external 'user32' name 'CharToOemBuffA'; +function OemToAnsiBuff(lpszSrc:LPCSTR; lpszDst:LPSTR; cchDstLength:DWORD):WINBOOL; external 'user32' name 'OemToCharBuffA'; +function AnsiUpper(lpsz:LPSTR):LPSTR; external 'user32' name 'CharUpperA'; +function AnsiUpperBuff(lpsz:LPSTR; cchLength:DWORD):DWORD; external 'user32' name 'CharUpperBuffA'; +function AnsiLower(lpsz:LPSTR):LPSTR; external 'user32' name 'CharLowerA'; +function AnsiLowerBuff(lpsz:LPSTR; cchLength:DWORD):DWORD; external 'user32' name 'CharLowerBuffA'; +//end win32 or wince not checked + +{$endif WIN32} + + +{$endif read_interface} + + +{$ifdef read_implementation} + +//begin common win32 & wince +//end common win32 & wince + +{$ifdef WINCE} +//begin wince only +//end wince only +{$endif WINCE} + +{$ifdef WIN32} +//begin win32 or wince not checked +function Succeeded(Status : HRESULT) : BOOL; + begin + Succeeded:=Status and HRESULT($80000000)=0; + end; + +function Failed(Status : HRESULT) : BOOL; + begin + Failed:=Status and HRESULT($80000000)<>0; + end; + +function IsError(Status : HRESULT) : BOOL; + begin + IsError:=(Status shr 31)=SEVERITY_ERROR; + end; + +function HResultCode(hr : HRESULT) : Longint; + begin + HResultCode:=hr and $0000ffff; + end; + +function HResultFacility(hr : HRESULT) : Longint; + begin + HResultFacility:=(hr shr 16) and $00001fff; + end; + +function HResultSeverity(hr : HRESULT) : Longint; + begin + HResultSeverity:=(hr shr 31) and $00000001; + end; + +function MakeResult(p1,p2,mask : Longint): HRESULT; + begin + MakeResult:=(p1 shl 31) or (p2 shl 16) or mask; + end; + +function HResultFromWin32(x : Longint) : HRESULT; + begin + HResultFromWin32:=x; + if HResultFromWin32<>0 then + HResultFromWin32:=((HResultFromWin32 and $0000ffff) or + (FACILITY_WIN32 shl 16) or HRESULT($80000000)); + end; + +function HResultFromNT(x : Longint) : HRESULT; + begin + HResultFromNT:=x or FACILITY_NT_BIT; + end; + +function MAKELANGID(PrimaryLang, SubLang: USHORT): WORD; +begin + MAKELANGID := (SubLang shl 10) or PrimaryLang; +end; + +function PRIMARYLANGID(LangId: WORD): WORD; +begin + PRIMARYLANGID := LangId and $3FF; +end; + +function SUBLANGID(LangId: WORD): WORD; +begin + SUBLANGID := LangId shr 10; +end; + +function MAKELCID(LangId, SortId: WORD): DWORD; +begin + MAKELCID := (DWORD(SortId) shl 16) or DWORD(LangId); +end; + +function MAKESORTLCID(LangId, SortId, SortVersion: WORD): DWORD; +begin + MAKESORTLCID := MAKELCID(LangId, SortId) or (SortVersion shl 20); +end; + +function LANGIDFROMLCID(LocaleId: LCID): WORD; +begin + LANGIDFROMLCID := WORD(LocaleId); +end; + +function SORTIDFROMLCID(LocaleId: LCID): WORD; +begin + SORTIDFROMLCID := WORD((DWORD(LocaleId) shr 16) and $F); +end; + +function SORTVERSIONFROMLCID(LocaleId: LCID): WORD; +begin + SORTVERSIONFROMLCID := WORD((DWORD(LocaleId) shr 20) and $F); +end; + +function LANG_SYSTEM_DEFAULT: WORD; +begin + LANG_SYSTEM_DEFAULT := MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT); +end; + +function LANG_USER_DEFAULT: WORD; +begin + LANG_USER_DEFAULT := MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT); +end; + +function LOCALE_SYSTEM_DEFAULT: DWORD; +begin + LOCALE_SYSTEM_DEFAULT:= MAKELCID(LANG_SYSTEM_DEFAULT, SORT_DEFAULT); +end; + +function LOCALE_USER_DEFAULT: DWORD; +begin + LOCALE_USER_DEFAULT:= MAKELCID(LANG_USER_DEFAULT, SORT_DEFAULT); +end; + +function LOCALE_NEUTRAL: DWORD; +begin + LOCALE_NEUTRAL := MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), SORT_DEFAULT); +end; + +function LOCALE_INVARIANT: DWORD; +begin + LOCALE_INVARIANT := MAKELCID(MAKELANGID(LANG_INVARIANT, SUBLANG_NEUTRAL), SORT_DEFAULT); +end; +//end win32 or wince not checked + +{$endif WIN32} + + +{$endif read_implementation} + diff --git a/rtl/wince/wininc/struct.inc b/rtl/wince/wininc/struct.inc new file mode 100644 index 0000000000..9314f91502 --- /dev/null +++ b/rtl/wince/wininc/struct.inc @@ -0,0 +1,8054 @@ +{ + This file is part of the Free Pascal run time library. + This unit contains the record definition for the Win32 API + Copyright (c) 1999-2000 by Florian KLaempfl, + member of the Free Pascal development team. + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ + Structures.h + + Declarations for all the Windows32 API Structures + + Copyright (C) 1996 Free Software Foundation, Inc. + + Author: Scott Christley + Date: 1996 + + This file is part of the Windows32 API Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + + Changes : + + 22/15/2005 update for wince4.2 port, orinaudo@gmail.com + +} + +{$ifdef read_interface} + + type + + { WARNING + the variable argument list + is not implemented for FPC + va_list is just a dummy record + MvdV: Nevertheless it should be a pointer type, not a record} + + va_list = pchar; + + ABC = record + abcA : longint; + abcB : UINT; + abcC : longint; + end; + LPABC = ^ABC; + _ABC = ABC; + TABC = ABC; + PABC = ^ABC; + + ABCFLOAT = record + abcfA : Single; + abcfB : Single; + abcfC : Single; + end; + LPABCFLOAT = ^ABCFLOAT; + _ABCFLOAT = ABCFLOAT; + TABCFLOAT = ABCFLOAT; + PABCFLOAT = ^ABCFLOAT; + + ACCEL = record + fVirt : BYTE; + key : WORD; + cmd : WORD; + end; + LPACCEL = ^ACCEL; + _ACCEL = ACCEL; + TACCEL = ACCEL; + PACCEL = ^ACCEL; + + // + // The structure of an ACE is a common ace header followed by ace type + // specific data. Pictorally the structure of the common ace header is + // as follows: + // + // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 + // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 + // +---------------+-------+-------+---------------+---------------+ + // | AceSize | AceFlags | AceType | + // +---------------+-------+-------+---------------+---------------+ + // + // AceType denotes the type of the ace, there are some predefined ace + // types + // + // AceSize is the size, in bytes, of ace. + // + // AceFlags are the Ace flags for audit and inheritance, defined shortly. + + ACE_HEADER = record //winnt + AceType : BYTE; + AceFlags : BYTE; + AceSize : WORD; + end; + _ACE_HEADER = ACE_HEADER; + TACE_HEADER = ACE_HEADER; + PACE_HEADER = ^ACE_HEADER; + + ACCESS_MASK = DWORD; //winnt + PACCESS_MASK = ^ACCESS_MASK; //+winnt + + REGSAM = ACCESS_MASK; + + ACCESS_ALLOWED_ACE = record + Header : ACE_HEADER; + Mask : ACCESS_MASK; + SidStart : DWORD; + end; + _ACCESS_ALLOWED_ACE = ACCESS_ALLOWED_ACE; + TACCESS_ALLOWED_ACE = ACCESS_ALLOWED_ACE; + PACCESS_ALLOWED_ACE = ^ACCESS_ALLOWED_ACE; + + ACCESS_DENIED_ACE = record + Header : ACE_HEADER; + Mask : ACCESS_MASK; + SidStart : DWORD; + end; + _ACCESS_DENIED_ACE = ACCESS_DENIED_ACE; + TACCESS_DENIED_ACE = ACCESS_DENIED_ACE; + + ACCESSTIMEOUT = record + cbSize : UINT; + dwFlags : DWORD; + iTimeOutMSec : DWORD; + end; + _ACCESSTIMEOUT = ACCESSTIMEOUT; + TACCESSTIMEOUT = ACCESSTIMEOUT; + PACCESSTIMEOUT = ^ACCESSTIMEOUT; + + PACCESS_TOKEN = PVOID; //+winnt + + //////////////////////////////////////////////////////////////////////// + // // + // ACL and ACE // + // // + //////////////////////////////////////////////////////////////////////// + + // + // Define an ACL and the ACE format. The structure of an ACL header + // followed by one or more ACEs. Pictorally the structure of an ACL header + // is as follows: + // + // 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 + // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 + // +-------------------------------+---------------+---------------+ + // | AclSize | Sbz1 | AclRevision | + // +-------------------------------+---------------+---------------+ + // | Sbz2 | AceCount | + // +-------------------------------+-------------------------------+ + // + // The current AclRevision is defined to be ACL_REVISION. + // + // AclSize is the size, in bytes, allocated for the ACL. This includes + // the ACL header, ACES, and remaining free space in the buffer. + // + // AceCount is the number of ACES in the ACL. + // + + ACL = record //winnt + AclRevision : BYTE; + Sbz1 : BYTE; + AclSize : WORD; + AceCount : WORD; + Sbz2 : WORD; + end; + PACL = ^ACL; + _ACL = ACL; + TACL = ACL; + + ACL_REVISION_INFORMATION = record + AclRevision : DWORD; + end; + _ACL_REVISION_INFORMATION = ACL_REVISION_INFORMATION; + TACLREVISIONINFORMATION = ACL_REVISION_INFORMATION; + PACLREVISIONINFORMATION = ^ACL_REVISION_INFORMATION; + + ACL_SIZE_INFORMATION = record + AceCount : DWORD; + AclBytesInUse : DWORD; + AclBytesFree : DWORD; + end; + _ACL_SIZE_INFORMATION = ACL_SIZE_INFORMATION; + TACLSIZEINFORMATION = ACL_SIZE_INFORMATION; + PACLSIZEINFORMATION = ^ACL_SIZE_INFORMATION; + + ACTION_HEADER = record + transport_id : ULONG; + action_code : USHORT; + reserved : USHORT; + end; + _ACTION_HEADER = ACTION_HEADER; + TACTIONHEADER = ACTION_HEADER; + PACTIONHEADER = ^ACTION_HEADER; + + ADAPTER_STATUS = record + adapter_address : array[0..5] of UCHAR; + rev_major : UCHAR; + reserved0 : UCHAR; + adapter_type : UCHAR; + rev_minor : UCHAR; + duration : WORD; + frmr_recv : WORD; + frmr_xmit : WORD; + iframe_recv_err : WORD; + xmit_aborts : WORD; + xmit_success : DWORD; + recv_success : DWORD; + iframe_xmit_err : WORD; + recv_buff_unavail : WORD; + t1_timeouts : WORD; + ti_timeouts : WORD; + reserved1 : DWORD; + free_ncbs : WORD; + max_cfg_ncbs : WORD; + max_ncbs : WORD; + xmit_buf_unavail : WORD; + max_dgram_size : WORD; + pending_sess : WORD; + max_cfg_sess : WORD; + max_sess : WORD; + max_sess_pkt_size : WORD; + name_count : WORD; + end; + _ADAPTER_STATUS = ADAPTER_STATUS; + TADAPTERSTATUS = ADAPTER_STATUS; + PADAPTERSTATUS = ^ADAPTER_STATUS; + + ADDJOB_INFO_1 = record + Path : LPTSTR; + JobId : DWORD; + end; + _ADDJOB_INFO_1 = ADDJOB_INFO_1; + TADDJOB_INFO_1 = ADDJOB_INFO_1; + PADDJOB_INFO_1 = ^ADDJOB_INFO_1; + + ANIMATIONINFO = record + cbSize : UINT; + iMinAnimate : longint; + end; + LPANIMATIONINFO = ^ANIMATIONINFO; + _ANIMATIONINFO = ANIMATIONINFO; + TANIMATIONINFO = ANIMATIONINFO; + PANIMATIONINFO = ^ANIMATIONINFO; + + POINT = record + x : LONG; + y : LONG; + end; + LPPOINT = ^POINT; + tagPOINT = POINT; + TPOINT = POINT; + PPOINT = ^POINT; + + RECT = record + case Integer of + 0: (Left,Top,Right,Bottom : Longint); + 1: (TopLeft,BottomRight : TPoint); + end; + LPRECT = ^RECT; + _RECT = RECT; + TRECT = RECT; + PRECT = ^RECT; + tagRECT = RECT; //+windef + + RECTL = record + left : LONG; + top : LONG; + right : LONG; + bottom : LONG; + end; + _RECTL = RECTL; + TRECTL = RECTL; + PRECTL = ^RECTL; + + APPBARDATA = record + cbSize : DWORD; + hWnd : HWND; + uCallbackMessage : UINT; + uEdge : UINT; + rc : RECT; + lParam : LPARAM; + end; + _AppBarData = APPBARDATA; + TAppBarData = APPBARDATA; + PAppBarData = ^APPBARDATA; + + BITMAP = record + bmType : LONG; + bmWidth : LONG; + bmHeight : LONG; + bmWidthBytes : LONG; + bmPlanes : WORD; + bmBitsPixel : WORD; + bmBits : LPVOID; + end; + PBITMAP = ^BITMAP; + NPBITMAP = ^BITMAP; + LPBITMAP = ^BITMAP; + tagBITMAP = BITMAP; + TBITMAP = BITMAP; + + BITMAPCOREHEADER = record + bcSize : DWORD; + bcWidth : WORD; + bcHeight : WORD; + bcPlanes : WORD; + bcBitCount : WORD; + end; + tagBITMAPCOREHEADER = BITMAPCOREHEADER; + TBITMAPCOREHEADER = BITMAPCOREHEADER; + PBITMAPCOREHEADER = ^BITMAPCOREHEADER; + + RGBTRIPLE = record + rgbtBlue : BYTE; + rgbtGreen : BYTE; + rgbtRed : BYTE; + end; + tagRGBTRIPLE = RGBTRIPLE; + TRGBTRIPLE = RGBTRIPLE; + PRGBTRIPLE = ^RGBTRIPLE; + + BITMAPCOREINFO = record + bmciHeader : BITMAPCOREHEADER; + bmciColors : array[0..0] of RGBTRIPLE; + end; + PBITMAPCOREINFO = ^BITMAPCOREINFO; + LPBITMAPCOREINFO = ^BITMAPCOREINFO; + _BITMAPCOREINFO = BITMAPCOREINFO; + TBITMAPCOREINFO = BITMAPCOREINFO; + +(* error + WORD bfReserved1; + WORD bfReserved2; + in declarator_list *) + + BITMAPINFOHEADER = record + biSize : DWORD; + biWidth : LONG; + biHeight : LONG; + biPlanes : WORD; + biBitCount : WORD; + biCompression : DWORD; + biSizeImage : DWORD; + biXPelsPerMeter : LONG; + biYPelsPerMeter : LONG; + biClrUsed : DWORD; + biClrImportant : DWORD; + end; + LPBITMAPINFOHEADER = ^BITMAPINFOHEADER; + TBITMAPINFOHEADER = BITMAPINFOHEADER; + PBITMAPINFOHEADER = ^BITMAPINFOHEADER; + + RGBQUAD = record + rgbBlue : BYTE; + rgbGreen : BYTE; + rgbRed : BYTE; + rgbReserved : BYTE; + end; + tagRGBQUAD = RGBQUAD; + TRGBQUAD = RGBQUAD; + PRGBQUAD = ^RGBQUAD; + + BITMAPINFO = record + bmiHeader : BITMAPINFOHEADER; + bmiColors : array[0..0] of RGBQUAD; + end; + LPBITMAPINFO = ^BITMAPINFO; + PBITMAPINFO = ^BITMAPINFO; + TBITMAPINFO = BITMAPINFO; + + FXPT2DOT30 = longint; + LPFXPT2DOT30 = ^FXPT2DOT30; + TPFXPT2DOT30 = FXPT2DOT30; + PPFXPT2DOT30 = ^FXPT2DOT30; + + CIEXYZ = record + ciexyzX : FXPT2DOT30; + ciexyzY : FXPT2DOT30; + ciexyzZ : FXPT2DOT30; + end; + tagCIEXYZ = CIEXYZ; + LPCIEXYZ = ^CIEXYZ; + TPCIEXYZ = CIEXYZ; + PCIEXYZ = ^CIEXYZ; + + CIEXYZTRIPLE = record + ciexyzRed : CIEXYZ; + ciexyzGreen : CIEXYZ; + ciexyzBlue : CIEXYZ; + end; + tagCIEXYZTRIPLE = CIEXYZTRIPLE; + LPCIEXYZTRIPLE = ^CIEXYZTRIPLE; + TCIEXYZTRIPLE = CIEXYZTRIPLE; + PCIEXYZTRIPLE = ^CIEXYZTRIPLE; + + BITMAPV4HEADER = record + bV4Size : DWORD; + bV4Width : LONG; + bV4Height : LONG; + bV4Planes : WORD; + bV4BitCount : WORD; + bV4V4Compression : DWORD; + bV4SizeImage : DWORD; + bV4XPelsPerMeter : LONG; + bV4YPelsPerMeter : LONG; + bV4ClrUsed : DWORD; + bV4ClrImportant : DWORD; + bV4RedMask : DWORD; + bV4GreenMask : DWORD; + bV4BlueMask : DWORD; + bV4AlphaMask : DWORD; + bV4CSType : DWORD; + bV4Endpoints : CIEXYZTRIPLE; + bV4GammaRed : DWORD; + bV4GammaGreen : DWORD; + bV4GammaBlue : DWORD; + end; + LPBITMAPV4HEADER = ^BITMAPV4HEADER; + TBITMAPV4HEADER = BITMAPV4HEADER; + PBITMAPV4HEADER = ^BITMAPV4HEADER; + + BITMAPFILEHEADER = packed record + bfType : Word; + bfSize : DWord; + bfReserved1 : Word; + bfReserved2 : Word; + bfOffBits : DWord; + end; + + BLOB = record + cbSize : ULONG; + pBlobData : ^BYTE; + end; + _BLOB = BLOB; + TBLOB = BLOB; + PBLOB = ^BLOB; + + SHITEMID = record + cb : USHORT; + abID : array[0..0] of BYTE; + end; + LPSHITEMID = ^SHITEMID; + LPCSHITEMID = ^SHITEMID; + _SHITEMID = SHITEMID; + TSHITEMID = SHITEMID; + PSHITEMID = ^SHITEMID; + + ITEMIDLIST = record + mkid : SHITEMID; + end; + LPITEMIDLIST = ^ITEMIDLIST; + LPCITEMIDLIST = ^ITEMIDLIST; + _ITEMIDLIST = ITEMIDLIST; + TITEMIDLIST = ITEMIDLIST; + PITEMIDLIST = ^ITEMIDLIST; + + BROWSEINFO = record + hwndOwner : HWND; + pidlRoot : LPCITEMIDLIST; + pszDisplayName : LPSTR; + lpszTitle : LPCSTR; + ulFlags : UINT; + lpfn : BFFCALLBACK; + lParam : LPARAM; + iImage : longint; + end; + LPBROWSEINFO = ^BROWSEINFO; + _browseinfo = BROWSEINFO; + Tbrowseinfo = BROWSEINFO; + PBROWSEINFO = ^BROWSEINFO; + + FILETIME = record + dwLowDateTime : DWORD; + dwHighDateTime : DWORD; + end; + LPFILETIME = ^FILETIME; + _FILETIME = FILETIME; + TFILETIME = FILETIME; + PFILETIME = ^FILETIME; + + _GET_FILEEX_INFO_LEVELS=(GetFileExInfoStandard,GetFileExMaxInfoLevel); //+winbase + GET_FILEEX_INFO_LEVELS=_GET_FILEEX_INFO_LEVELS; //+winbase + + _FINDEX_INFO_LEVELS = (FindExInfoStandard,FindExInfoMaxInfoLevel); //+winbase + FINDEX_INFO_LEVELS = _FINDEX_INFO_LEVELS; //+winbase + + _FINDEX_SEARCH_OPS = ( FindExSearchNameMatch, FindExSearchLimitToDirectories, + FindExSearchLimitToDevices, FindExSearchMaxSearchOp); + FINDEX_SEARCH_OPS=_FINDEX_SEARCH_OPS; + + BY_HANDLE_FILE_INFORMATION = record + dwFileAttributes : DWORD; + ftCreationTime : FILETIME; + ftLastAccessTime : FILETIME; + ftLastWriteTime : FILETIME; + dwVolumeSerialNumber : DWORD; + nFileSizeHigh : DWORD; + nFileSizeLow : DWORD; + nNumberOfLinks : DWORD; + nFileIndexHigh : DWORD; + nFileIndexLow : DWORD; + end; + LPBY_HANDLE_FILE_INFORMATION = ^BY_HANDLE_FILE_INFORMATION; + _BY_HANDLE_FILE_INFORMATION = BY_HANDLE_FILE_INFORMATION; + TBYHANDLEFILEINFORMATION = BY_HANDLE_FILE_INFORMATION; + PBYHANDLEFILEINFORMATION = ^BY_HANDLE_FILE_INFORMATION; + + FIXED = record + fract : WORD; + value : integer; + end; + _FIXED = FIXED; + TFIXED = FIXED; + PFIXED = ^FIXED; + + POINTFX = record + x : FIXED; + y : FIXED; + end; + tagPOINTFX = POINTFX; + TPOINTFX = POINTFX; + PPOINTFX = ^POINTFX; + + POINTL = record + x : LONG; + y : LONG; + end; + _POINTL = POINTL; + TPOINTL = POINTL; + PPOINTL = ^POINTL; + + TSmallPoint = record + X, + Y : SmallInt; + end; + + + POINTS = record + x : SHORT; + y : SHORT; + end; + tagPOINTS = POINTS; //windef + TPOINTS = POINTS; + PPOINTS = ^POINTS; + + CANDIDATEFORM = record + dwIndex : DWORD; + dwStyle : DWORD; + ptCurrentPos : POINT; + rcArea : RECT; + end; + LPCANDIDATEFORM = ^CANDIDATEFORM; + _tagCANDIDATEFORM = CANDIDATEFORM; + TCANDIDATEFORM = CANDIDATEFORM; + PCANDIDATEFORM = ^CANDIDATEFORM; + + CANDIDATELIST = record + dwSize : DWORD; + dwStyle : DWORD; + dwCount : DWORD; + dwSelection : DWORD; + dwPageStart : DWORD; + dwPageSize : DWORD; + dwOffset : array[0..0] of DWORD; + end; + LPCANDIDATELIST = ^CANDIDATELIST; + _tagCANDIDATELIST = CANDIDATELIST; + TCANDIDATELIST = CANDIDATELIST; + PCANDIDATELIST = ^CANDIDATELIST; + + CREATESTRUCT = record + lpCreateParams : LPVOID; + hInstance : HINST; + hMenu : HMENU; + hwndParent : HWND; + cy : longint; + cx : longint; + y : longint; + x : longint; + style : LONG; + lpszName : LPCTSTR; + lpszClass : LPCTSTR; + dwExStyle : DWORD; + end; + LPCREATESTRUCT = ^CREATESTRUCT; + tagCREATESTRUCT = CREATESTRUCT; + TCREATESTRUCT = CREATESTRUCT; + PCREATESTRUCT = ^CREATESTRUCT; + + CBT_CREATEWND = record + lpcs : LPCREATESTRUCT; + hwndInsertAfter : HWND; + end; + tagCBT_CREATEWND = CBT_CREATEWND; + TCBT_CREATEWND = CBT_CREATEWND; + PCBT_CREATEWND = ^CBT_CREATEWND; + + CBTACTIVATESTRUCT = record + fMouse : WINBOOL; + hWndActive : HWND; + end; + tagCBTACTIVATESTRUCT = CBTACTIVATESTRUCT; + TCBTACTIVATESTRUCT = CBTACTIVATESTRUCT; + PCBTACTIVATESTRUCT = ^CBTACTIVATESTRUCT; + + + CHAR_INFO = record + case longint of + 0 : ( UnicodeChar : WCHAR; + Attributes : Word); + 1 : ( AsciiChar : CHAR ); + end; + _CHAR_INFO = CHAR_INFO; + TCHAR_INFO = CHAR_INFO; + PCHAR_INFO = ^CHAR_INFO; + + CHARFORMAT = record + cbSize : UINT; + dwMask : DWORD; + dwEffects : DWORD; + yHeight : LONG; + yOffset : LONG; + crTextColor : COLORREF; + bCharSet : BYTE; + bPitchAndFamily : BYTE; + szFaceName : array[0..(LF_FACESIZE)-1] of TCHAR; + end; + _charformat = CHARFORMAT; + Tcharformat = CHARFORMAT; + Pcharformat = ^CHARFORMAT; + + CHARRANGE = record + cpMin : LONG; + cpMax : LONG; + end; + _charrange = CHARRANGE; + Tcharrange = CHARRANGE; + Pcharrange = ^CHARRANGE; + + CHARSET = record + aflBlock : array[0..2] of DWORD; + flLang : DWORD; + end; + tagCHARSET = CHARSET; + TCHARSET = CHARSET; + PCHARSET = ^CHARSET; + + FONTSIGNATURE = record + fsUsb : array[0..3] of DWORD; + fsCsb : array[0..1] of DWORD; + end; + LPFONTSIGNATURE = ^FONTSIGNATURE; + tagFONTSIGNATURE = FONTSIGNATURE; + TFONTSIGNATURE = FONTSIGNATURE; + PFONTSIGNATURE = ^FONTSIGNATURE; + + FLOAT128 = record //+winnt + LowPart : int64; + HighPart : int64; + end; + PFLOAT128 = ^FLOAT128; + + CHARSETINFO = record + ciCharset : UINT; + ciACP : UINT; + fs : FONTSIGNATURE; + end; + LPCHARSETINFO = ^CHARSETINFO; + TCHARSETINFO = CHARSETINFO; + PCHARSETINFO = ^CHARSETINFO; + + {CHOOSECOLOR = record confilcts with function ChooseColor } + TCHOOSECOLOR = record + lStructSize : DWORD; + hwndOwner : HWND; + hInstance : HWND; + rgbResult : COLORREF; + lpCustColors : ^COLORREF; + Flags : DWORD; + lCustData : LPARAM; + lpfnHook : LPCCHOOKPROC; + lpTemplateName : LPCTSTR; + end; + LPCHOOSECOLOR = ^TCHOOSECOLOR; + PCHOOSECOLOR = ^TCHOOSECOLOR; + + LOGFONT = record + lfHeight : LONG; + lfWidth : LONG; + lfEscapement : LONG; + lfOrientation : LONG; + lfWeight : LONG; + lfItalic : BYTE; + lfUnderline : BYTE; + lfStrikeOut : BYTE; + lfCharSet : BYTE; + lfOutPrecision : BYTE; + lfClipPrecision : BYTE; + lfQuality : BYTE; + lfPitchAndFamily : BYTE; + lfFaceName : array[0..(LF_FACESIZE)-1] of TCHAR; + end; + LPLOGFONT = ^LOGFONT; + TLOGFONT = LOGFONT; + TLOGFONTA = LOGFONT; + PLOGFONT = ^LOGFONT; + PLOGFONTA = PLOGFONT; + + LOGFONTW = record + lfHeight: LONG; + lfWidth: LONG; + lfEscapement: LONG; + lfOrientation: LONG; + lfWeight: LONG; + lfItalic: BYTE; + lfUnderline: BYTE; + lfStrikeOut: BYTE; + lfCharSet: BYTE; + lfOutPrecision: BYTE; + lfClipPrecision: BYTE; + lfQuality: BYTE; + lfPitchAndFamily: BYTE; + lfFaceName: array [0..LF_FACESIZE - 1] of WCHAR; + end; + LPLOGFONTW = ^LOGFONTW; + NPLOGFONTW = ^LOGFONTW; + tagLOGFONTW = LOGFONTW; + TLogFontW = LOGFONTW; + PLogFontW = ^TLogFontW; + + TCHOOSEFONTW = record //+commdlg + lStructSize : DWORD; + hwndOwner : HWND; + hDC : HDC; + lpLogFont : LPLOGFONTW; + iPointSize : Integer; + Flags : DWORD; + rgbColors : DWORD; + lCustData : LPARAM; + lpfnHook : LPCFHOOKPROC; + lpTemplateName : LPCWSTR; + hInstance : HINST; + lpszStyle : LPTSTR; + nFontType : WORD; + ___MISSING_ALIGNMENT__ : WORD; + nSizeMin : Integer; + nSizeMax : Integer; + end; + tagCHOOSEFONTW = TCHOOSEFONTW; //+commdlg + LPCHOOSEFONTW = ^TCHOOSEFONTW; //+commdlg + PCHOOSEFONTW = ^TCHOOSEFONTW; //+commdlg + + {CHOOSEFONT = record conflicts with ChooseFont function } + TCHOOSEFONT = record + lStructSize : DWORD; + hwndOwner : HWND; + hDC : HDC; + lpLogFont : LPLOGFONT; + iPointSize : WINT; + Flags : DWORD; + rgbColors : DWORD; + lCustData : LPARAM; + lpfnHook : LPCFHOOKPROC; + lpTemplateName : LPCTSTR; + hInstance : HINST; + lpszStyle : LPTSTR; + nFontType : WORD; + ___MISSING_ALIGNMENT__ : WORD; + nSizeMin : WINT; + nSizeMax : WINT; + end; + LPCHOOSEFONT = ^TCHOOSEFONT; + PCHOOSEFONT = ^TCHOOSEFONT; + + CIDA = record + cidl : UINT; + aoffset : array[0..0] of UINT; + end; + LPIDA = ^CIDA; + _IDA = CIDA; + TIDA = CIDA; + PIDA = ^CIDA; + + CLIENTCREATESTRUCT = record + hWindowMenu : HANDLE; + idFirstChild : UINT; + end; + LPCLIENTCREATESTRUCT = ^CLIENTCREATESTRUCT; + tagCLIENTCREATESTRUCT = CLIENTCREATESTRUCT; + TCLIENTCREATESTRUCT = CLIENTCREATESTRUCT; + PCLIENTCREATESTRUCT = ^CLIENTCREATESTRUCT; + + CMINVOKECOMMANDINFO = record + cbSize : DWORD; + fMask : DWORD; + hwnd : HWND; + lpVerb : LPCSTR; + lpParameters : LPCSTR; + lpDirectory : LPCSTR; + nShow : longint; + dwHotKey : DWORD; + hIcon : HANDLE; + end; + LPCMINVOKECOMMANDINFO = ^CMINVOKECOMMANDINFO; + _CMInvokeCommandInfo = CMINVOKECOMMANDINFO; + TCMInvokeCommandInfo = CMINVOKECOMMANDINFO; + PCMInvokeCommandInfo = ^CMINVOKECOMMANDINFO; + + COLORADJUSTMENT = record + caSize : WORD; + caFlags : WORD; + caIlluminantIndex : WORD; + caRedGamma : WORD; + caGreenGamma : WORD; + caBlueGamma : WORD; + caReferenceBlack : WORD; + caReferenceWhite : WORD; + caContrast : SHORT; + caBrightness : SHORT; + caColorfulness : SHORT; + caRedGreenTint : SHORT; + end; + LPCOLORADJUSTMENT = ^COLORADJUSTMENT; + tagCOLORADJUSTMENT = COLORADJUSTMENT; + TCOLORADJUSTMENT = COLORADJUSTMENT; + PCOLORADJUSTMENT = ^COLORADJUSTMENT; + + COLORMAP = record + from : COLORREF; + _to : COLORREF; + end; + LPCOLORMAP = ^COLORMAP; + _COLORMAP = COLORMAP; + TCOLORMAP = COLORMAP; + PCOLORMAP = ^COLORMAP; + + DCB = record + DCBlength : DWORD; + BaudRate : DWORD; + flags : DWORD; + wReserved : WORD; + XonLim : WORD; + XoffLim : WORD; + ByteSize : BYTE; + Parity : BYTE; + StopBits : BYTE; + XonChar : char; + XoffChar : char; + ErrorChar : char; + EofChar : char; + EvtChar : char; + wReserved1 : WORD; + end; + LPDCB = ^DCB; + _DCB = DCB; + TDCB = DCB; + PDCB = ^DCB; + + const + bm_DCB_fBinary = $1; + bp_DCB_fBinary = 0; + bm_DCB_fParity = $2; + bp_DCB_fParity = 1; + bm_DCB_fOutxCtsFlow = $4; + bp_DCB_fOutxCtsFlow = 2; + bm_DCB_fOutxDsrFlow = $8; + bp_DCB_fOutxDsrFlow = 3; + bm_DCB_fDtrControl = $30; + bp_DCB_fDtrControl = 4; + bm_DCB_fDsrSensitivity = $40; + bp_DCB_fDsrSensitivity = 6; + bm_DCB_fTXContinueOnXoff = $80; + bp_DCB_fTXContinueOnXoff = 7; + bm_DCB_fOutX = $100; + bp_DCB_fOutX = 8; + bm_DCB_fInX = $200; + bp_DCB_fInX = 9; + bm_DCB_fErrorChar = $400; + bp_DCB_fErrorChar = 10; + bm_DCB_fNull = $800; + bp_DCB_fNull = 11; + bm_DCB_fRtsControl = $3000; + bp_DCB_fRtsControl = 12; + bm_DCB_fAbortOnError = $4000; + bp_DCB_fAbortOnError = 14; + bm_DCB_fDummy2 = $FFFF8000; + bp_DCB_fDummy2 = 15; + function fBinary(var a : DCB) : DWORD; + procedure set_fBinary(var a : DCB; __fBinary : DWORD); + function fParity(var a : DCB) : DWORD; + procedure set_fParity(var a : DCB; __fParity : DWORD); + function fOutxCtsFlow(var a : DCB) : DWORD; + procedure set_fOutxCtsFlow(var a : DCB; __fOutxCtsFlow : DWORD); + function fOutxDsrFlow(var a : DCB) : DWORD; + procedure set_fOutxDsrFlow(var a : DCB; __fOutxDsrFlow : DWORD); + function fDtrControl(var a : DCB) : DWORD; + procedure set_fDtrControl(var a : DCB; __fDtrControl : DWORD); + function fDsrSensitivity(var a : DCB) : DWORD; + procedure set_fDsrSensitivity(var a : DCB; __fDsrSensitivity : DWORD); + function fTXContinueOnXoff(var a : DCB) : DWORD; + procedure set_fTXContinueOnXoff(var a : DCB; __fTXContinueOnXoff : DWORD); + function fOutX(var a : DCB) : DWORD; + procedure set_fOutX(var a : DCB; __fOutX : DWORD); + function fInX(var a : DCB) : DWORD; + procedure set_fInX(var a : DCB; __fInX : DWORD); + function fErrorChar(var a : DCB) : DWORD; + procedure set_fErrorChar(var a : DCB; __fErrorChar : DWORD); + function fNull(var a : DCB) : DWORD; + procedure set_fNull(var a : DCB; __fNull : DWORD); + function fRtsControl(var a : DCB) : DWORD; + procedure set_fRtsControl(var a : DCB; __fRtsControl : DWORD); + function fAbortOnError(var a : DCB) : DWORD; + procedure set_fAbortOnError(var a : DCB; __fAbortOnError : DWORD); + function fDummy2(var a : DCB) : DWORD; + procedure set_fDummy2(var a : DCB; __fDummy2 : DWORD); + + type + + COMMCONFIG = record + dwSize : DWORD; + wVersion : WORD; + wReserved : WORD; + dcb : DCB; + dwProviderSubType : DWORD; + dwProviderOffset : DWORD; + dwProviderSize : DWORD; + wcProviderData : array[0..0] of WCHAR; + end; + LPCOMMCONFIG = ^COMMCONFIG; + _COMM_CONFIG = COMMCONFIG; + TCOMMCONFIG = COMMCONFIG; + PCOMMCONFIG = ^COMMCONFIG; + + COMMPROP = record + wPacketLength : WORD; + wPacketVersion : WORD; + dwServiceMask : DWORD; + dwReserved1 : DWORD; + dwMaxTxQueue : DWORD; + dwMaxRxQueue : DWORD; + dwMaxBaud : DWORD; + dwProvSubType : DWORD; + dwProvCapabilities : DWORD; + dwSettableParams : DWORD; + dwSettableBaud : DWORD; + wSettableData : WORD; + wSettableStopParity : WORD; + dwCurrentTxQueue : DWORD; + dwCurrentRxQueue : DWORD; + dwProvSpec1 : DWORD; + dwProvSpec2 : DWORD; + wcProvChar : array[0..0] of WCHAR; + end; + LPCOMMPROP = ^COMMPROP; + _COMMPROP = COMMPROP; + TCOMMPROP = COMMPROP; + PCOMMPROP = ^COMMPROP; + + COMMTIMEOUTS = record + ReadIntervalTimeout : DWORD; + ReadTotalTimeoutMultiplier : DWORD; + ReadTotalTimeoutConstant : DWORD; + WriteTotalTimeoutMultiplier : DWORD; + WriteTotalTimeoutConstant : DWORD; + end; + LPCOMMTIMEOUTS = ^COMMTIMEOUTS; + _COMMTIMEOUTS = COMMTIMEOUTS; + TCOMMTIMEOUTS = COMMTIMEOUTS; + PCOMMTIMEOUTS = ^COMMTIMEOUTS; + + COMPAREITEMSTRUCT = record + CtlType : UINT; + CtlID : UINT; + hwndItem : HWND; + itemID1 : UINT; + itemData1 : DWORD; + itemID2 : UINT; + itemData2 : DWORD; + end; + tagCOMPAREITEMSTRUCT = COMPAREITEMSTRUCT; + TCOMPAREITEMSTRUCT = COMPAREITEMSTRUCT; + PCOMPAREITEMSTRUCT = ^COMPAREITEMSTRUCT; + + COMPCOLOR = record + crText : COLORREF; + crBackground : COLORREF; + dwEffects : DWORD; + end; + TCOMPCOLOR = COMPCOLOR; + PCOMPCOLOR = ^COMPCOLOR; + + COMPOSITIONFORM = record + dwStyle : DWORD; + ptCurrentPos : POINT; + rcArea : RECT; + end; + LPCOMPOSITIONFORM = ^COMPOSITIONFORM; + _tagCOMPOSITIONFORM = COMPOSITIONFORM; + TCOMPOSITIONFORM = COMPOSITIONFORM; + PCOMPOSITIONFORM = ^COMPOSITIONFORM; + +// TComStatFlags = set of (fCtsHold, fDsrHold, fRlsdHold , fXoffHold , +// fXoffSent , fEof , fTxim , fReserved); + + COMSTAT = record + flag0 : DWORD; // can't use tcomstatflags, set packing issues + // and conflicts with macro's + cbInQue : DWORD; + cbOutQue : DWORD; + end; + LPCOMSTAT = ^COMSTAT; + _COMSTAT = COMSTAT; + TCOMSTAT = COMSTAT; + PCOMSTAT = ^COMSTAT; + const + bm_COMSTAT_fCtsHold = $1; + bp_COMSTAT_fCtsHold = 0; + bm_COMSTAT_fDsrHold = $2; + bp_COMSTAT_fDsrHold = 1; + bm_COMSTAT_fRlsdHold = $4; + bp_COMSTAT_fRlsdHold = 2; + bm_COMSTAT_fXoffHold = $8; + bp_COMSTAT_fXoffHold = 3; + bm_COMSTAT_fXoffSent = $10; + bp_COMSTAT_fXoffSent = 4; + bm_COMSTAT_fEof = $20; + bp_COMSTAT_fEof = 5; + bm_COMSTAT_fTxim = $40; + bp_COMSTAT_fTxim = 6; + bm_COMSTAT_fReserved = $FFFFFF80; + bp_COMSTAT_fReserved = 7; + function fCtsHold(var a : COMSTAT) : DWORD; // should be renamed to get_? + procedure set_fCtsHold(var a : COMSTAT; __fCtsHold : DWORD); + function fDsrHold(var a : COMSTAT) : DWORD; + procedure set_fDsrHold(var a : COMSTAT; __fDsrHold : DWORD); + function fRlsdHold(var a : COMSTAT) : DWORD; + procedure set_fRlsdHold(var a : COMSTAT; __fRlsdHold : DWORD); + function fXoffHold(var a : COMSTAT) : DWORD; + procedure set_fXoffHold(var a : COMSTAT; __fXoffHold : DWORD); + function fXoffSent(var a : COMSTAT) : DWORD; + procedure set_fXoffSent(var a : COMSTAT; __fXoffSent : DWORD); + function fEof(var a : COMSTAT) : DWORD; + procedure set_fEof(var a : COMSTAT; __fEof : DWORD); + function fTxim(var a : COMSTAT) : DWORD; + procedure set_fTxim(var a : COMSTAT; __fTxim : DWORD); + function fReserved(var a : COMSTAT) : DWORD; + procedure set_fReserved(var a : COMSTAT; __fReserved : DWORD); + + type + + CONSOLE_CURSOR_INFO = record + dwSize : DWORD; + bVisible : WINBOOL; + end; + PCONSOLE_CURSOR_INFO = ^CONSOLE_CURSOR_INFO; + _CONSOLE_CURSOR_INFO = CONSOLE_CURSOR_INFO; + TCONSOLECURSORINFO = CONSOLE_CURSOR_INFO; + PCONSOLECURSORINFO = ^CONSOLE_CURSOR_INFO; + TCURSORINFO = CONSOLE_CURSOR_INFO; + + COORD = record + X : SHORT; + Y : SHORT; + end; + _COORD = COORD; + TCOORD = COORD; + PCOORD = ^COORD; + + SMALL_RECT = record + Left : SHORT; + Top : SHORT; + Right : SHORT; + Bottom : SHORT; + end; + _SMALL_RECT = SMALL_RECT; + TSMALL_RECT = SMALL_RECT; + PSMALL_RECT = ^SMALL_RECT; + + CONSOLE_SCREEN_BUFFER_INFO = packed record + dwSize : COORD; + dwCursorPosition : COORD; + wAttributes : WORD; + srWindow : SMALL_RECT; + dwMaximumWindowSize : COORD; + end; + PCONSOLE_SCREEN_BUFFER_INFO = ^CONSOLE_SCREEN_BUFFER_INFO; + _CONSOLE_SCREEN_BUFFER_INFO = CONSOLE_SCREEN_BUFFER_INFO; + TCONSOLESCREENBUFFERINFO = CONSOLE_SCREEN_BUFFER_INFO; + PCONSOLESCREENBUFFERINFO = ^CONSOLE_SCREEN_BUFFER_INFO; + +{$ifdef _X86_} //+winnt + type + FLOATING_SAVE_AREA = record //~winnt + ControlWord : DWORD; + StatusWord : DWORD; + TagWord : DWORD; + ErrorOffset : DWORD; + ErrorSelector : DWORD; + DataOffset : DWORD; + DataSelector : DWORD; + RegisterArea : array[0..SIZE_OF_80387_REGISTERS-1] of BYTE; //~winnt + Cr0NpxState : DWORD; + end; + _FLOATING_SAVE_AREA = FLOATING_SAVE_AREA; //winnt + TFLOATINGSAVEAREA = FLOATING_SAVE_AREA; //winnt + PFLOATING_SAVE_AREA = ^FLOATING_SAVE_AREA; //~winnt + +// +// Context Frame +// +// This frame has a several purposes: 1) it is used as an argument to +// NtContinue, 2) is is used to constuct a call frame for APC delivery, +// and 3) it is used in the user level thread creation routines. +// +// The layout of the record conforms to a standard call frame. +// + + CONTEXT = record //winnt + ContextFlags : DWORD; + Dr0 : DWORD; + Dr1 : DWORD; + Dr2 : DWORD; + Dr3 : DWORD; + Dr6 : DWORD; + Dr7 : DWORD; + FloatSave : FLOATING_SAVE_AREA; + SegGs : DWORD; + SegFs : DWORD; + SegEs : DWORD; + SegDs : DWORD; + Edi : DWORD; + Esi : DWORD; + Ebx : DWORD; + Edx : DWORD; + Ecx : DWORD; + Eax : DWORD; + Ebp : DWORD; + Eip : DWORD; + SegCs : DWORD; + EFlags : DWORD; + Esp : DWORD; + SegSs : DWORD; + end; + + LDT_ENTRY = record //~winnt, moved into _X86_ + LimitLow : WORD; + BaseLow : WORD; + HighWord : record + case longint of + 0 : ( Bytes : record + BaseMid : BYTE; + Flags1 : BYTE; + Flags2 : BYTE; + BaseHi : BYTE; + end ); + 1 : ( Bits : record + flag0 : longint; + end ); + end; + end; + LPLDT_ENTRY = ^LDT_ENTRY; + PLDT_ENTRY = ^LDT_ENTRY; + _LDT_ENTRY = LDT_ENTRY; + TLDTENTRY = LDT_ENTRY; + PLDTENTRY = ^LDT_ENTRY; + +{$endif _X86_} //+winnt + +{$ifdef _MIPS_} //+winnt all block added +// +// Context Frame +// +// N.B. This frame must be exactly a multiple of 16 bytes in length. +// +// This frame has a several purposes: 1) it is used as an argument to +// NtContinue, 2) it is used to constuct a call frame for APC delivery, +// 3) it is used to construct a call frame for exception dispatching +// in user mode, and 4) it is used in the user level thread creation +// routines. +// +// The layout of the record conforms to a standard call frame. +// + type + {$ifdef _MIPS64} //+winnt + FREG_TYPE = ULONGLONG; + REG_TYPE = ULONGLONG; + {$else} + FREG_TYPE = DWORD; + REG_TYPE = ULONG; + {$endif _MIPS64} + CONTEXT = record //+winnt + Argument : Array[0..3] of REG_TYPE; + FltF0 : FREG_TYPE; + FltF1 : FREG_TYPE; + FltF2 : FREG_TYPE; + FltF3 : FREG_TYPE; + FltF4 : FREG_TYPE; + FltF5 : FREG_TYPE; + FltF6 : FREG_TYPE; + FltF7 : FREG_TYPE; + FltF8 : FREG_TYPE; + FltF9 : FREG_TYPE; + FltF10 : FREG_TYPE; + FltF11 : FREG_TYPE; + FltF12 : FREG_TYPE; + FltF13 : FREG_TYPE; + FltF14 : FREG_TYPE; + FltF15 : FREG_TYPE; + FltF16 : FREG_TYPE; + FltF17 : FREG_TYPE; + FltF18 : FREG_TYPE; + FltF19 : FREG_TYPE; + FltF20 : FREG_TYPE; + FltF21 : FREG_TYPE; + FltF22 : FREG_TYPE; + FltF23 : FREG_TYPE; + FltF24 : FREG_TYPE; + FltF25 : FREG_TYPE; + FltF26 : FREG_TYPE; + FltF27 : FREG_TYPE; + FltF28 : FREG_TYPE; + FltF29 : FREG_TYPE; + FltF30 : FREG_TYPE; + FltF31 : FREG_TYPE; + + IntZero : REG_TYPE; + IntAt : REG_TYPE; + IntV0 : REG_TYPE; + IntV1 : REG_TYPE; + IntA0 : REG_TYPE; + IntA1 : REG_TYPE; + IntA2 : REG_TYPE; + IntA3 : REG_TYPE; + IntT0 : REG_TYPE; + IntT1 : REG_TYPE; + IntT2 : REG_TYPE; + IntT3 : REG_TYPE; + IntT4 : REG_TYPE; + IntT5 : REG_TYPE; + IntT6 : REG_TYPE; + IntT7 : REG_TYPE; + IntS0 : REG_TYPE; + IntS1 : REG_TYPE; + IntS2 : REG_TYPE; + IntS3 : REG_TYPE; + IntS4 : REG_TYPE; + IntS5 : REG_TYPE; + IntS6 : REG_TYPE; + IntS7 : REG_TYPE; + IntT8 : REG_TYPE; + IntT9 : REG_TYPE; + IntK0 : REG_TYPE; + IntK1 : REG_TYPE; + IntGp : REG_TYPE; + IntSp : REG_TYPE; + IntS8 : REG_TYPE; + IntRa : REG_TYPE; + IntLo : REG_TYPE; + IntHi : REG_TYPE; + + Fsr : DWORD; + Fir : DWORD; + Psr : DWORD; + ContextFlags : DWORD; + Fill : Array[0..1] of DWORD; + end; + +{$endif _MIPS_} //+winnt + +{$ifdef _PPC_} //+winnt + { Floating point registers returned when CONTEXT_FLOATING_POINT is set } + { Integer registers returned when CONTEXT_INTEGER is set. } + { Condition register } + { Fixed point exception register } + { The following are set when CONTEXT_CONTROL is set. } + { Machine status register } + { Instruction address register } + { Link register } + { Control register } + { Control which context values are returned } + { Registers returned if CONTEXT_DEBUG_REGISTERS is set. } + { Breakpoint Register 1 } + { Breakpoint Register 2 } + { Breakpoint Register 3 } + { Breakpoint Register 4 } + { Breakpoint Register 5 } + { Breakpoint Register 6 } + { Debug Status Register } + { Debug Control Register } + + type + + CONTEXT = record + Fpr0 : double; + Fpr1 : double; + Fpr2 : double; + Fpr3 : double; + Fpr4 : double; + Fpr5 : double; + Fpr6 : double; + Fpr7 : double; + Fpr8 : double; + Fpr9 : double; + Fpr10 : double; + Fpr11 : double; + Fpr12 : double; + Fpr13 : double; + Fpr14 : double; + Fpr15 : double; + Fpr16 : double; + Fpr17 : double; + Fpr18 : double; + Fpr19 : double; + Fpr20 : double; + Fpr21 : double; + Fpr22 : double; + Fpr23 : double; + Fpr24 : double; + Fpr25 : double; + Fpr26 : double; + Fpr27 : double; + Fpr28 : double; + Fpr29 : double; + Fpr30 : double; + Fpr31 : double; + Fpscr : double; + Gpr0 : DWORD; + Gpr1 : DWORD; + Gpr2 : DWORD; + Gpr3 : DWORD; + Gpr4 : DWORD; + Gpr5 : DWORD; + Gpr6 : DWORD; + Gpr7 : DWORD; + Gpr8 : DWORD; + Gpr9 : DWORD; + Gpr10 : DWORD; + Gpr11 : DWORD; + Gpr12 : DWORD; + Gpr13 : DWORD; + Gpr14 : DWORD; + Gpr15 : DWORD; + Gpr16 : DWORD; + Gpr17 : DWORD; + Gpr18 : DWORD; + Gpr19 : DWORD; + Gpr20 : DWORD; + Gpr21 : DWORD; + Gpr22 : DWORD; + Gpr23 : DWORD; + Gpr24 : DWORD; + Gpr25 : DWORD; + Gpr26 : DWORD; + Gpr27 : DWORD; + Gpr28 : DWORD; + Gpr29 : DWORD; + Gpr30 : DWORD; + Gpr31 : DWORD; + Cr : DWORD; + Xer : DWORD; + Msr : DWORD; + Iar : DWORD; + Lr : DWORD; + Ctr : DWORD; + ContextFlags : DWORD; + Fill : array[0..2] of DWORD; + Dr0 : DWORD; + Dr1 : DWORD; + Dr2 : DWORD; + Dr3 : DWORD; + Dr4 : DWORD; + Dr5 : DWORD; + Dr6 : DWORD; + Dr7 : DWORD; + end; + _STACK_FRAME_HEADER = record // GPR 1 points here + BackChain : DWORD; // Addr of previous frame + Reserved1 : DWORD; // Reserved + + Parameter0 : DWORD; // First 8 parameter words are + Parameter1 : DWORD; // always present + Parameter2 : DWORD; + Parameter3 : DWORD; + Parameter4 : DWORD; + Parameter5 : DWORD; + Parameter6 : DWORD; + Parameter7 : DWORD; + end; + + PSTACK_FRAME_HEADER=^STACK_FRAME_HEADER; + {$endif _PPC_} //~winnt + + {$ifdef _MPPC_} //+winnt all block + type + CONTEXT = record + Fpr0 : double; + Fpr1 : double; + Fpr2 : double; + Fpr3 : double; + Fpr4 : double; + Fpr5 : double; + Fpr6 : double; + Fpr7 : double; + Fpr8 : double; + Fpr9 : double; + Fpr10 : double; + Fpr11 : double; + Fpr12 : double; + Fpr13 : double; + Fpr14 : double; + Fpr15 : double; + Fpr16 : double; + Fpr17 : double; + Fpr18 : double; + Fpr19 : double; + Fpr20 : double; + Fpr21 : double; + Fpr22 : double; + Fpr23 : double; + Fpr24 : double; + Fpr25 : double; + Fpr26 : double; + Fpr27 : double; + Fpr28 : double; + Fpr29 : double; + Fpr30 : double; + Fpr31 : double; + Fpscr : double; + Gpr0 : DWORD; + Gpr1 : DWORD; + Gpr2 : DWORD; + Gpr3 : DWORD; + Gpr4 : DWORD; + Gpr5 : DWORD; + Gpr6 : DWORD; + Gpr7 : DWORD; + Gpr8 : DWORD; + Gpr9 : DWORD; + Gpr10 : DWORD; + Gpr11 : DWORD; + Gpr12 : DWORD; + Gpr13 : DWORD; + Gpr14 : DWORD; + Gpr15 : DWORD; + Gpr16 : DWORD; + Gpr17 : DWORD; + Gpr18 : DWORD; + Gpr19 : DWORD; + Gpr20 : DWORD; + Gpr21 : DWORD; + Gpr22 : DWORD; + Gpr23 : DWORD; + Gpr24 : DWORD; + Gpr25 : DWORD; + Gpr26 : DWORD; + Gpr27 : DWORD; + Gpr28 : DWORD; + Gpr29 : DWORD; + Gpr30 : DWORD; + Gpr31 : DWORD; + Cr : DWORD; + Xer : DWORD; + Msr : DWORD; + Iar : DWORD; + Lr : DWORD; + Ctr : DWORD; + ContextFlags : DWORD; + Fill : array[0..2] of DWORD; + Dr0 : DWORD; + Dr1 : DWORD; + Dr2 : DWORD; + Dr3 : DWORD; + Dr4 : DWORD; + Dr5 : DWORD; + Dr6 : DWORD; + Dr7 : DWORD; + end; + _STACK_FRAME_HEADER = record // GPR 1 points here + BackChain : DWORD; // Addr of previous frame + GlueSaved1 : DWORD; // Used by glue code + GlueSaved2 : DWORD; + Reserved1 : DWORD; + Spare1 : DWORD; + Spare2 : DWORD; + + Parameter0 : DWORD; // First 8 parameter words are + Parameter1 : DWORD; // always present + Parameter2 : DWORD; + Parameter3 : DWORD; + Parameter4 : DWORD; + Parameter5 : DWORD; + Parameter6 : DWORD; + Parameter7 : DWORD; + end; + + PSTACK_FRAME_HEADER=^STACK_FRAME_HEADER; + + {$endif _MPPC_} //+winnt + + {$ifdef _IA64_} //+winnt all block + type + CONTEXT = record + + ContextFlags : DWORD; + Fill1 : array[0..2] of DWORD; + DbI0 : ULONGLONG; // Instruction debug registers + DbI1 : ULONGLONG; + DbI2 : ULONGLONG; + DbI3 : ULONGLONG; + DbI4 : ULONGLONG; + DbI5 : ULONGLONG; + DbI6 : ULONGLONG; + DbI7 : ULONGLONG; + + DbD0 : ULONGLONG; // Data debug registers + DbD1 : ULONGLONG; + DbD2 : ULONGLONG; + DbD3 : ULONGLONG; + DbD4 : ULONGLONG; + DbD5 : ULONGLONG; + DbD6 : ULONGLONG; + DbD7 : ULONGLONG; + + FltS0 : FLOAT128; // Lower floating point (f2-f5) - saved (preserved) + FltS1 : FLOAT128; + FltS2 : FLOAT128; + FltS3 : FLOAT128; + FltT0 : FLOAT128; // Lower floating point (f6-f15) - temporary (volatile) + FltT1 : FLOAT128; + FltT2 : FLOAT128; + FltT3 : FLOAT128; + FltT4 : FLOAT128; + FltT5 : FLOAT128; + FltT6 : FLOAT128; + FltT7 : FLOAT128; + FltT8 : FLOAT128; + FltT9 : FLOAT128; + FltS4 : FLOAT128; // Higher floating point (f16-f31) - saved (preserved) + FltS5 : FLOAT128; + FltS6 : FLOAT128; + FltS7 : FLOAT128; + FltS8 : FLOAT128; + FltS9 : FLOAT128; + FltS10 : FLOAT128; + FltS11 : FLOAT128; + FltS12 : FLOAT128; + FltS13 : FLOAT128; + FltS14 : FLOAT128; + FltS15 : FLOAT128; + FltS16 : FLOAT128; + FltS17 : FLOAT128; + FltS18 : FLOAT128; + FltS19 : FLOAT128; + + FltF32 : FLOAT128; // Higher floating point (f32-f127) - temporary (volatile) + FltF33 : FLOAT128; + FltF34 : FLOAT128; + FltF35 : FLOAT128; + FltF36 : FLOAT128; + FltF37 : FLOAT128; + FltF38 : FLOAT128; + FltF39 : FLOAT128; + + FltF40 : FLOAT128; + FltF41 : FLOAT128; + FltF42 : FLOAT128; + FltF43 : FLOAT128; + FltF44 : FLOAT128; + FltF45 : FLOAT128; + FltF46 : FLOAT128; + FltF47 : FLOAT128; + FltF48 : FLOAT128; + FltF49 : FLOAT128; + + FltF50 : FLOAT128; + FltF51 : FLOAT128; + FltF52 : FLOAT128; + FltF53 : FLOAT128; + FltF54 : FLOAT128; + FltF55 : FLOAT128; + FltF56 : FLOAT128; + FltF57 : FLOAT128; + FltF58 : FLOAT128; + FltF59 : FLOAT128; + + FltF60 : FLOAT128; + FltF61 : FLOAT128; + FltF62 : FLOAT128; + FltF63 : FLOAT128; + FltF64 : FLOAT128; + FltF65 : FLOAT128; + FltF66 : FLOAT128; + FltF67 : FLOAT128; + FltF68 : FLOAT128; + FltF69 : FLOAT128; + + FltF70 : FLOAT128; + FltF71 : FLOAT128; + FltF72 : FLOAT128; + FltF73 : FLOAT128; + FltF74 : FLOAT128; + FltF75 : FLOAT128; + FltF76 : FLOAT128; + FltF77 : FLOAT128; + FltF78 : FLOAT128; + FltF79 : FLOAT128; + + FltF80 : FLOAT128; + FltF81 : FLOAT128; + FltF82 : FLOAT128; + FltF83 : FLOAT128; + FltF84 : FLOAT128; + FltF85 : FLOAT128; + FltF86 : FLOAT128; + FltF87 : FLOAT128; + FltF88 : FLOAT128; + FltF89 : FLOAT128; + + FltF90 : FLOAT128; + FltF91 : FLOAT128; + FltF92 : FLOAT128; + FltF93 : FLOAT128; + FltF94 : FLOAT128; + FltF95 : FLOAT128; + FltF96 : FLOAT128; + FltF97 : FLOAT128; + FltF98 : FLOAT128; + FltF99 : FLOAT128; + + FltF100 : FLOAT128; + FltF101 : FLOAT128; + FltF102 : FLOAT128; + FltF103 : FLOAT128; + FltF104 : FLOAT128; + FltF105 : FLOAT128; + FltF106 : FLOAT128; + FltF107 : FLOAT128; + FltF108 : FLOAT128; + FltF109 : FLOAT128; + + FltF110 : FLOAT128; + FltF111 : FLOAT128; + FltF112 : FLOAT128; + FltF113 : FLOAT128; + FltF114 : FLOAT128; + FltF115 : FLOAT128; + FltF116 : FLOAT128; + FltF117 : FLOAT128; + FltF118 : FLOAT128; + FltF119 : FLOAT128; + + FltF120 : FLOAT128; + FltF121 : FLOAT128; + FltF122 : FLOAT128; + FltF123 : FLOAT128; + FltF124 : FLOAT128; + FltF125 : FLOAT128; + FltF126 : FLOAT128; + FltF127 : FLOAT128; + + StFPSR : ULONGLONG; // FP status + StFSR : ULONGLONG; // x86 FP status (a copy of AR28) + StFIR : ULONGLONG; // x86 FP status (a copy of AR29) + StFDR : ULONGLONG; // x86 FP status (a copy of AR30) + + IntGp : ULONGLONG; // global pointer (r1) - temporary (volatile) + IntT0 : ULONGLONG; // integer registers (r2-r3) - temporary (volatile) + IntT1 : ULONGLONG; + IntS0 : ULONGLONG; // integer registers (r4-r7) - saved (preserved) + IntS1 : ULONGLONG; + IntS2 : ULONGLONG; + IntS3 : ULONGLONG; + IntV0 : ULONGLONG; // return value (r8) - temporary (volatile) + IntT2 : ULONGLONG; // integer registers (r9-r11) - temporary (volatile) + IntT3 : ULONGLONG; + IntT4 : ULONGLONG; + IntSP : ULONGLONG; // stack pointer (r12) - special + IntTeb : ULONGLONG; // teb (r13) - special + IntT5 : ULONGLONG; // integer registers (r14-r31) - temporary (volatile) + IntT6 : ULONGLONG; + IntT7 : ULONGLONG; + IntT8 : ULONGLONG; + IntT9 : ULONGLONG; + IntT10 : ULONGLONG; + IntT11 : ULONGLONG; + IntT12 : ULONGLONG; + IntT13 : ULONGLONG; + IntT14 : ULONGLONG; + IntT15 : ULONGLONG; + IntT16 : ULONGLONG; + IntT17 : ULONGLONG; + IntT18 : ULONGLONG; + IntT19 : ULONGLONG; + IntT20 : ULONGLONG; + IntT21 : ULONGLONG; + IntT22 : ULONGLONG; + + IntNats : ULONGLONG; // Nat bits for general registers + // r1-r31 in bit positions 1 to 31. + Preds : ULONGLONG; // predicates - saved (preserved) + BrRp : ULONGLONG; // return pointer (b0) - saved (preserved) + BrS0 : ULONGLONG; // branch registers (b1-b5) - saved (preserved) + BrS1 : ULONGLONG; + BrS2 : ULONGLONG; + BrS3 : ULONGLONG; + BrS4 : ULONGLONG; + + BrT0 : ULONGLONG; // branch registers (b6-b7) - temporary (volatile) + BrT1 : ULONGLONG; + // iA32 related Interger registers + SegCSD : ULONGLONG; // iA32 CSDescriptor (Ar25) + SegSSD : ULONGLONG; // iA32 SSDescriptor (Ar26) + + // Other application registers + ApUNAT : ULONGLONG; // User Nat collection register - saved (preserved) + ApLC : ULONGLONG; // Loop counter register - saved (preserved) + ApEC : ULONGLONG; // Epilog counter register - saved (preserved) + ApCCV : ULONGLONG; // CMPXCHG value register - temporary (volatile) + ApDCR : ULONGLONG; // Default control register (TBD) + + // Register stack info + RsPFS : ULONGLONG; // Previous function state - saved (preserved) + RsBSP : ULONGLONG; // Backing store pointer - saved (preserved) + RsBSPSTORE : ULONGLONG; // BSP Store - saved (preserved) + RsRSC : ULONGLONG; // RSE configuration - temporary (volatile) + RsRNAT : ULONGLONG; // RSE Nat collection register - saved (preserved) + // iA32 related control registers + Eflag : ULONGLONG; // Eflag copy of Ar24 + Cflag : ULONGLONG; // Cr0+Cr4 copy of Ar27 + + // Trap Status Information + StIPSR : ULONGLONG; // Interruption Processor Status + StIIP : ULONGLONG; // Interruption IP + StIFS : ULONGLONG; // Interruption Function State + + end; + + FLOATING_SAVE_AREA = record + ControlWord : DWORD; + StatusWord : DWORD; + TagWord : DWORD; + ErrorOffset : DWORD; + ErrorSelector : DWORD; + DataOffset : DWORD; + DataSelector : DWORD; + RegisterArea : array[0..SIZE_OF_80387_REGISTERS-1] of BYTE; + Cr0NpxState : DWORD; + end; + _FLOATING_SAVE_AREA = FLOATING_SAVE_AREA; + TFLOATINGSAVEAREA = FLOATING_SAVE_AREA; + PFLOATING_SAVE_AREA = ^FLOATING_SAVE_AREA; + + CONTEXT86 = record + ContextFlags : DWORD; + Dr0 : DWORD; + Dr1 : DWORD; + Dr2 : DWORD; + Dr3 : DWORD; + Dr6 : DWORD; + Dr7 : DWORD; + FloatSave : FLOATING_SAVE_AREA; + SegGs : DWORD; + SegFs : DWORD; + SegEs : DWORD; + SegDs : DWORD; + Edi : DWORD; + Esi : DWORD; + Ebx : DWORD; + Edx : DWORD; + Ecx : DWORD; + Eax : DWORD; + Ebp : DWORD; + Eip : DWORD; + SegCs : DWORD; + EFlags : DWORD; + Esp : DWORD; + SegSs : DWORD; + end; + + LDT_ENTRY = record + LimitLow : WORD; + BaseLow : WORD; + HighWord : record + case longint of + 0 : ( Bytes : record + BaseMid : BYTE; + Flags1 : BYTE; + Flags2 : BYTE; + BaseHi : BYTE; + end ); + 1 : ( Bits : record + flag0 : longint; + end ); + end; + end; + LPLDT_ENTRY = ^LDT_ENTRY; + PLDT_ENTRY = ^LDT_ENTRY; + _LDT_ENTRY = LDT_ENTRY; + TLDTENTRY = LDT_ENTRY; + PLDTENTRY = ^LDT_ENTRY; + + PLABEL_DESCRIPTOR = record + EntryPoint : ULONGLONG; + GlobalPointer : ULONGLONG; + end; + _PLABEL_DESCRIPTOR = PLABEL_DESCRIPTOR; + PPLABEL_DESCRIPTOR = ^PLABEL_DESCRIPTOR; + + + {$endif _IA64_} //+winnt + + {$ifdef SHx} //+winnt all block added + //These are the debug or break registers on the SH3 + DEBUG_REGISTERS = RECORD + BarA : ULONG; + BasrA : UCHAR; + BamrA : UCHAR; + BbrA : USHORT; + BarB : ULONG; + BasrB : UCHAR; + BamrB : UCHAR; + BbrB : USHORT; + BdrB : ULONG; + BdmrB : ULONG; + Brcr : USHORT; + Align : USHORT; + end; + _DEBUG_REGISTERS=DEBUG_REZGISTERS; + PDEBUG_REGISTERS=^DEBUG_REZGISTERS; + + CONTEXT = record + ContextFlags : ULONG; + PR : ULONG; + MACH : ULONG; + MACL : ULONG; + GBR : ULONG; + R0 : ULONG; + R1 : ULONG; + R2 : ULONG; + R3 : ULONG; + R4 : ULONG; + R5 : ULONG; + R6 : ULONG; + R7 : ULONG; + R8 : ULONG; + R9 : ULONG; + R10 : ULONG; + R11 : ULONG; + R12 : ULONG; + R13 : ULONG; + R14 : ULONG; + R15 : ULONG; + + // N.B. The registers r15 and ra are defined in the integer section, + // but are considered part of the control context rather than part of + // the integer context. + // + + Fir : ULONG; + Psr : ULONG; + + {$ifndef SH3e} + {$ifndef SH4} + OldStuff : Array[0..1] of ULONG; + DebugRegisters : DEBUG_REGISTERS; + DSR : ULONG; + MOD_ : ULONG; // MOD replaced by MOD_ + RS : ULONG; + RE : ULONG; + A0 : ULONG; + A1 : ULONG; + M0 : ULONG; + M1 : ULONG; + X0 : ULONG; + X1 : ULONG; + Y0 : ULONG; + Y1 : ULONG; + // The guard bit registers are 8 bits long, but can only be saved and + // restored using 16 or 32 bit moves. Note, the contents of the guard + // bit register are in the upper 8 bits. + A0G : USHORT; + A1G : USHORT; + {$else} + Fpscr : ULONG; + Fpul : ULONG; + FRegs : Array[0..15] of ULONG; + xFRegs : Array[0..15] of ULONG; + {$endif SH4} + {$else} + Fpscr : ULONG; + Fpul : ULONG; + FRegs : Array[0..15] of ULONG; + {$endif SH3e} + end; + + {$endif SHx} //+winnt + + {$ifdef ARM} //+winnt all block added + CONTEXT = record + ContextFlags : ULONG; + R0 : ULONG; + R1 : ULONG; + R2 : ULONG; + R3 : ULONG; + R4 : ULONG; + R5 : ULONG; + R6 : ULONG; + R7 : ULONG; + R8 : ULONG; + R9 : ULONG; + R10 : ULONG; + R11 : ULONG; + R12 : ULONG; + + SP : ULONG; + Lr : ULONG; + Pc : ULONG; + Psr : ULONG; + Fpscr : ULONG; + FpExc : ULONG; + S : Array [0..NUM_VFP_REGS] of ULONG; + FpExtra : Array [0..NUM_EXTRA_CONTROL_REGS-1] of ULONG; + end; + {$endif ARM} //+winnt + + LPCONTEXT = ^CONTEXT; + _CONTEXT = CONTEXT; + TCONTEXT = CONTEXT; + PCONTEXT = ^CONTEXT; //winnt + + type + + LIST_ENTRY = record //winnt + Flink : ^_LIST_ENTRY; + Blink : ^_LIST_ENTRY; + end; + _LIST_ENTRY = LIST_ENTRY; + TLISTENTRY = LIST_ENTRY; + PLISTENTRY = ^LIST_ENTRY; + + CRITICAL_SECTION_DEBUG = record + _Type : WORD; + CreatorBackTraceIndex : WORD; + CriticalSection : ^_CRITICAL_SECTION; + ProcessLocksList : LIST_ENTRY; + EntryCount : DWORD; + ContentionCount : DWORD; + Depth : DWORD; + OwnerBackTrace : array[0..4] of PVOID; + end; + LPCRITICAL_SECTION_DEBUG = ^CRITICAL_SECTION_DEBUG; + PCRITICAL_SECTION_DEBUG = ^CRITICAL_SECTION_DEBUG; + _CRITICAL_SECTION_DEBUG = CRITICAL_SECTION_DEBUG; + TCRITICALSECTIONDEBUG = CRITICAL_SECTION_DEBUG; + PCRITICALSECTIONDEBUG = ^CRITICAL_SECTION_DEBUG; + + CRITICAL_SECTION = TRTLCriticalSection; + _CRITICAL_SECTION = TRTLCriticalSection; + TCRITICAL_SECTION = TRTLCriticalSection; + PCRITICAL_SECTION = PRTLCriticalSection; + LPCRITICAL_SECTION = PRTLCriticalSection; + TCRITICALSECTION = TRTLCriticalSection; + PCRITICALSECTION = PRTLCriticalSection; + + { SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode; } + + SECURITY_QUALITY_OF_SERVICE = record + Length : DWORD; + ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL; + ContextTrackingMode : WINBOOL; + EffectiveOnly : BOOLEAN; + end; + PSECURITY_QUALITY_OF_SERVICE = ^SECURITY_QUALITY_OF_SERVICE; + _SECURITY_QUALITY_OF_SERVICE = SECURITY_QUALITY_OF_SERVICE; + TSECURITYQUALITYOFSERVICE = SECURITY_QUALITY_OF_SERVICE; + PSECURITYQUALITYOFSERVICE = ^SECURITY_QUALITY_OF_SERVICE; + + CONVCONTEXT = record + cb : UINT; + wFlags : UINT; + wCountryID : UINT; + iCodePage : longint; + dwLangID : DWORD; + dwSecurity : DWORD; + qos : SECURITY_QUALITY_OF_SERVICE; + end; + tagCONVCONTEXT = CONVCONTEXT; + TCONVCONTEXT = CONVCONTEXT; + PCONVCONTEXT = ^CONVCONTEXT; + + CONVINFO = record + cb : DWORD; + hUser : DWORD; + hConvPartner : HCONV; + hszSvcPartner : HSZ; + hszServiceReq : HSZ; + hszTopic : HSZ; + hszItem : HSZ; + wFmt : UINT; + wType : UINT; + wStatus : UINT; + wConvst : UINT; + wLastError : UINT; + hConvList : HCONVLIST; + ConvCtxt : CONVCONTEXT; + _hwnd : HWND; + hwndPartner : HWND; + end; + tagCONVINFO = CONVINFO; + TCONVINFO = CONVINFO; + PCONVINFO = ^CONVINFO; + + COPYDATASTRUCT = record + dwData : DWORD; + cbData : DWORD; + lpData : PVOID; + end; + tagCOPYDATASTRUCT = COPYDATASTRUCT; + TCOPYDATASTRUCT = COPYDATASTRUCT; + PCOPYDATASTRUCT = ^COPYDATASTRUCT; + + CPINFO = record + MaxCharSize : UINT; + DefaultChar : array[0..(MAX_DEFAULTCHAR)-1] of BYTE; + LeadByte : array[0..(MAX_LEADBYTES)-1] of BYTE; + end; + LPCPINFO = ^CPINFO; + _cpinfo = CPINFO; + Tcpinfo = CPINFO; + Pcpinfo = ^CPINFO; + + CPLINFO = record + idIcon : longint; + idName : longint; + idInfo : longint; + lData : LONG; + end; + tagCPLINFO = CPLINFO; + TCPLINFO = CPLINFO; + PCPLINFO = ^CPLINFO; + + CREATE_PROCESS_DEBUG_INFO = record + hFile : HANDLE; + hProcess : HANDLE; + hThread : HANDLE; + lpBaseOfImage : LPVOID; + dwDebugInfoFileOffset : DWORD; + nDebugInfoSize : DWORD; + lpThreadLocalBase : LPVOID; + lpStartAddress : LPTHREAD_START_ROUTINE; + lpImageName : LPVOID; + fUnicode : WORD; + end; + _CREATE_PROCESS_DEBUG_INFO = CREATE_PROCESS_DEBUG_INFO; + TCREATEPROCESSDEBUGINFO = CREATE_PROCESS_DEBUG_INFO; + PCREATEPROCESSDEBUGINFO = ^CREATE_PROCESS_DEBUG_INFO; + + CREATE_THREAD_DEBUG_INFO = record + hThread : HANDLE; + lpThreadLocalBase : LPVOID; + lpStartAddress : LPTHREAD_START_ROUTINE; + end; + _CREATE_THREAD_DEBUG_INFO = CREATE_THREAD_DEBUG_INFO; + TCREATETHREADDEBUGINFO = CREATE_THREAD_DEBUG_INFO; + PCREATETHREADDEBUGINFO = ^CREATE_THREAD_DEBUG_INFO; + (* + TODO: sockets + typedef struct _SOCKET_ADDRESS { + LPSOCKADDR lpSockaddr ; + INT iSockaddrLength ; + } SOCKET_ADDRESS, PSOCKET_ADDRESS, LPSOCKET_ADDRESS; + } + { + typedef struct _CSADDR_INFO { + SOCKET_ADDRESS LocalAddr; + SOCKET_ADDRESS RemoteAddr; + INT iSocketType; + INT iProtocol; + } CSADDR_INFO; + *) + + CURRENCYFMT = record + NumDigits : UINT; + LeadingZero : UINT; + Grouping : UINT; + lpDecimalSep : LPTSTR; + lpThousandSep : LPTSTR; + NegativeOrder : UINT; + PositiveOrder : UINT; + lpCurrencySymbol : LPTSTR; + end; + _currencyfmt = CURRENCYFMT; + Tcurrencyfmt = CURRENCYFMT; + Pcurrencyfmt = ^CURRENCYFMT; + + CURSORSHAPE = record + xHotSpot : longint; + yHotSpot : longint; + cx : longint; + cy : longint; + cbWidth : longint; + Planes : BYTE; + BitsPixel : BYTE; + end; + LPCURSORSHAPE = ^CURSORSHAPE; + tagCURSORSHAPE = CURSORSHAPE; + TCURSORSHAPE = CURSORSHAPE; + PCURSORSHAPE = ^CURSORSHAPE; + + CWPRETSTRUCT = record + lResult : LRESULT; + lParam : LPARAM; + wParam : WPARAM; + message : DWORD; + hwnd : HWND; + end; + tagCWPRETSTRUCT = CWPRETSTRUCT; + TCWPRETSTRUCT = CWPRETSTRUCT; + PCWPRETSTRUCT = ^CWPRETSTRUCT; + + CWPSTRUCT = record + lParam : LPARAM; + wParam : WPARAM; + message : UINT; + hwnd : HWND; + end; + tagCWPSTRUCT = CWPSTRUCT; + TCWPSTRUCT = CWPSTRUCT; + PCWPSTRUCT = ^CWPSTRUCT; + + DATATYPES_INFO_1 = record + pName : LPTSTR; + end; + _DATATYPES_INFO_1 = DATATYPES_INFO_1; + TDATATYPESINFO1 = DATATYPES_INFO_1; + PDATATYPESINFO1 = ^DATATYPES_INFO_1; + + DDEACK = record + flag0 : word; + end; + TDDEACK = DDEACK; + PDDEACK = ^DDEACK; + const + bm_DDEACK_bAppReturnCode = $FF; + bp_DDEACK_bAppReturnCode = 0; + bm_DDEACK_reserved = $3F00; + bp_DDEACK_reserved = 8; + bm_DDEACK_fBusy = $4000; + bp_DDEACK_fBusy = 14; + bm_DDEACK_fAck = $8000; + bp_DDEACK_fAck = 15; + function bAppReturnCode(var a : DDEACK) : word; + procedure set_bAppReturnCode(var a : DDEACK; __bAppReturnCode : word); + function reserved(var a : DDEACK) : word; + procedure set_reserved(var a : DDEACK; __reserved : word); + function fBusy(var a : DDEACK) : word; + procedure set_fBusy(var a : DDEACK; __fBusy : word); + function fAck(var a : DDEACK) : word; + procedure set_fAck(var a : DDEACK; __fAck : word); + + type + + DDEADVISE = record + flag0 : word; + cfFormat : integer; + end; + TDDEADVISE = DDEADVISE; + PDDEADVISE = ^DDEADVISE; + const + bm_DDEADVISE_reserved = $3FFF; + bp_DDEADVISE_reserved = 0; + bm_DDEADVISE_fDeferUpd = $4000; + bp_DDEADVISE_fDeferUpd = 14; + bm_DDEADVISE_fAckReq = $8000; + bp_DDEADVISE_fAckReq = 15; + function reserved(var a : DDEADVISE) : word; + procedure set_reserved(var a : DDEADVISE; __reserved : word); + function fDeferUpd(var a : DDEADVISE) : word; + procedure set_fDeferUpd(var a : DDEADVISE; __fDeferUpd : word); + function fAckReq(var a : DDEADVISE) : word; + procedure set_fAckReq(var a : DDEADVISE; __fAckReq : word); + + type + + DDEDATA = record + flag0 : word; + cfFormat : integer; + Value : array[0..0] of BYTE; + end; + PDDEDATA = ^DDEDATA; + const + bm_DDEDATA_unused = $FFF; + bp_DDEDATA_unused = 0; + bm_DDEDATA_fResponse = $1000; + bp_DDEDATA_fResponse = 12; + bm_DDEDATA_fRelease = $2000; + bp_DDEDATA_fRelease = 13; + bm_DDEDATA_reserved = $4000; + bp_DDEDATA_reserved = 14; + bm_DDEDATA_fAckReq = $8000; + bp_DDEDATA_fAckReq = 15; + function unused(var a : DDEDATA) : word; + procedure set_unused(var a : DDEDATA; __unused : word); + function fResponse(var a : DDEDATA) : word; + procedure set_fResponse(var a : DDEDATA; __fResponse : word); + function fRelease(var a : DDEDATA) : word; + procedure set_fRelease(var a : DDEDATA; __fRelease : word); + function reserved(var a : DDEDATA) : word; + procedure set_reserved(var a : DDEDATA; __reserved : word); + function fAckReq(var a : DDEDATA) : word; + procedure set_fAckReq(var a : DDEDATA; __fAckReq : word); + + type + + DDELN = record + flag0 : word; + cfFormat : integer; + end; + TDDELN = DDELN; + PDDELN = ^DDELN; + const + bm_DDELN_unused = $1FFF; + bp_DDELN_unused = 0; + bm_DDELN_fRelease = $2000; + bp_DDELN_fRelease = 13; + bm_DDELN_fDeferUpd = $4000; + bp_DDELN_fDeferUpd = 14; + bm_DDELN_fAckReq = $8000; + bp_DDELN_fAckReq = 15; + function unused(var a : DDELN) : word; + procedure set_unused(var a : DDELN; __unused : word); + function fRelease(var a : DDELN) : word; + procedure set_fRelease(var a : DDELN; __fRelease : word); + function fDeferUpd(var a : DDELN) : word; + procedure set_fDeferUpd(var a : DDELN; __fDeferUpd : word); + function fAckReq(var a : DDELN) : word; + procedure set_fAckReq(var a : DDELN; __fAckReq : word); + + type + + DDEML_MSG_HOOK_DATA = record + uiLo : UINT; + uiHi : UINT; + cbData : DWORD; + Data : array[0..7] of DWORD; + end; + tagDDEML_MSG_HOOK_DATA = DDEML_MSG_HOOK_DATA; + TDDEMLMSGHOOKDATA = DDEML_MSG_HOOK_DATA; + PDDEMLMSGHOOKDATA = ^DDEML_MSG_HOOK_DATA; + + DDEPOKE = record + flag0 : word; + cfFormat : integer; + Value : array[0..0] of BYTE; + end; + TDDEPOKE = DDEPOKE; + PDDEPOKE = ^DDEPOKE; + const + bm_DDEPOKE_unused = $1FFF; + bp_DDEPOKE_unused = 0; + bm_DDEPOKE_fRelease = $2000; + bp_DDEPOKE_fRelease = 13; + bm_DDEPOKE_fReserved = $C000; + bp_DDEPOKE_fReserved = 14; + function unused(var a : DDEPOKE) : word; + procedure set_unused(var a : DDEPOKE; __unused : word); + function fRelease(var a : DDEPOKE) : word; + procedure set_fRelease(var a : DDEPOKE; __fRelease : word); + function fReserved(var a : DDEPOKE) : word; + procedure set_fReserved(var a : DDEPOKE; __fReserved : word); + + type + + DDEUP = record + flag0 : word; + cfFormat : integer; + rgb : array[0..0] of BYTE; + end; + TDDEUP = DDEUP; + PDDEUP = ^DDEUP; + const + bm_DDEUP_unused = $FFF; + bp_DDEUP_unused = 0; + bm_DDEUP_fAck = $1000; + bp_DDEUP_fAck = 12; + bm_DDEUP_fRelease = $2000; + bp_DDEUP_fRelease = 13; + bm_DDEUP_fReserved = $4000; + bp_DDEUP_fReserved = 14; + bm_DDEUP_fAckReq = $8000; + bp_DDEUP_fAckReq = 15; + function unused(var a : DDEUP) : word; + procedure set_unused(var a : DDEUP; __unused : word); + function fAck(var a : DDEUP) : word; + procedure set_fAck(var a : DDEUP; __fAck : word); + function fRelease(var a : DDEUP) : word; + procedure set_fRelease(var a : DDEUP; __fRelease : word); + function fReserved(var a : DDEUP) : word; + procedure set_fReserved(var a : DDEUP; __fReserved : word); + function fAckReq(var a : DDEUP) : word; + procedure set_fAckReq(var a : DDEUP; __fAckReq : word); + + type + + // definition of _exception struct - this struct is passed to the matherr + // routine when a floating point exception is detected + _EXCEPTION = record //+stdlib + type_ : Integer; //identifier type replaced by Type_ for compilation + Name : PChar; // name of function where error occured + arg1 : double; // first argument to function + arg2 : double; // second argument (if any) to function + retval : double; // value to be returned by function + end; + + EXCEPTION_RECORD = record //winnt + ExceptionCode : DWORD; + ExceptionFlags : DWORD; + ExceptionRecord : ^_EXCEPTION_RECORD; + ExceptionAddress : PVOID; + NumberParameters : DWORD; + ExceptionInformation : array[0..(EXCEPTION_MAXIMUM_PARAMETERS)-1] of Pointer; //~winnt, was DWORD, SDK:ULONG_PTR + end; + PEXCEPTION_RECORD = ^EXCEPTION_RECORD; + _EXCEPTION_RECORD = EXCEPTION_RECORD; + TEXCEPTIONRECORD = EXCEPTION_RECORD; + PEXCEPTIONRECORD = ^EXCEPTION_RECORD; + + EXCEPTION_DEBUG_INFO = record + ExceptionRecord : EXCEPTION_RECORD; + dwFirstChance : DWORD; + end; + PEXCEPTION_DEBUG_INFO = ^EXCEPTION_DEBUG_INFO; + _EXCEPTION_DEBUG_INFO = EXCEPTION_DEBUG_INFO; + TEXCEPTIONDEBUGINFO = EXCEPTION_DEBUG_INFO; + PEXCEPTIONDEBUGINFO = ^EXCEPTION_DEBUG_INFO; + + EXIT_PROCESS_DEBUG_INFO = record + dwExitCode : DWORD; + end; + _EXIT_PROCESS_DEBUG_INFO = EXIT_PROCESS_DEBUG_INFO; + TEXITPROCESSDEBUGINFO = EXIT_PROCESS_DEBUG_INFO; + PEXITPROCESSDEBUGINFO = ^EXIT_PROCESS_DEBUG_INFO; + + + EXIT_THREAD_DEBUG_INFO = record + dwExitCode : DWORD; + end; + _EXIT_THREAD_DEBUG_INFO = EXIT_THREAD_DEBUG_INFO; + TEXITTHREADDEBUGINFO = EXIT_THREAD_DEBUG_INFO; + PEXITTHREADDEBUGINFO = ^EXIT_THREAD_DEBUG_INFO; + + LOAD_DLL_DEBUG_INFO = record + hFile : HANDLE; + lpBaseOfDll : LPVOID; + dwDebugInfoFileOffset : DWORD; + nDebugInfoSize : DWORD; + lpImageName : LPVOID; + fUnicode : WORD; + end; + _LOAD_DLL_DEBUG_INFO = LOAD_DLL_DEBUG_INFO; + TLOADDLLDEBUGINFO = LOAD_DLL_DEBUG_INFO; + PLOADDLLDEBUGINFO = ^LOAD_DLL_DEBUG_INFO; + + UNLOAD_DLL_DEBUG_INFO = record + lpBaseOfDll : LPVOID; + end; + _UNLOAD_DLL_DEBUG_INFO = UNLOAD_DLL_DEBUG_INFO; + TUNLOADDLLDEBUGINFO = UNLOAD_DLL_DEBUG_INFO; + PUNLOADDLLDEBUGINFO = ^UNLOAD_DLL_DEBUG_INFO; + + OUTPUT_DEBUG_STRING_INFO = record + lpDebugStringData : LPSTR; + fUnicode : WORD; + nDebugStringLength : WORD; + end; + _OUTPUT_DEBUG_STRING_INFO = OUTPUT_DEBUG_STRING_INFO; + TOUTPUTDEBUGSTRINGINFO = OUTPUT_DEBUG_STRING_INFO; + POUTPUTDEBUGSTRINGINFO = ^OUTPUT_DEBUG_STRING_INFO; + + RIP_INFO = record + dwError : DWORD; + dwType : DWORD; + end; + _RIP_INFO = RIP_INFO; + TRIPINFO = RIP_INFO; + PRIPINFO = ^RIP_INFO; + + DEBUG_EVENT = record + dwDebugEventCode : DWORD; + dwProcessId : DWORD; + dwThreadId : DWORD; + u : record + case longint of + 0 : ( Exception : EXCEPTION_DEBUG_INFO ); + 1 : ( CreateThread : CREATE_THREAD_DEBUG_INFO ); + 2 : ( CreateProcessInfo : CREATE_PROCESS_DEBUG_INFO ); + 3 : ( ExitThread : EXIT_THREAD_DEBUG_INFO ); + 4 : ( ExitProcess : EXIT_PROCESS_DEBUG_INFO ); + 5 : ( LoadDll : LOAD_DLL_DEBUG_INFO ); + 6 : ( UnloadDll : UNLOAD_DLL_DEBUG_INFO ); + 7 : ( DebugString : OUTPUT_DEBUG_STRING_INFO ); + 8 : ( RipInfo : RIP_INFO ); + end; + end; + LPDEBUG_EVENT = ^DEBUG_EVENT; + _DEBUG_EVENT = DEBUG_EVENT; + TDEBUGEVENT = DEBUG_EVENT; + PDEBUGEVENT = ^DEBUG_EVENT; + + DEBUGHOOKINFO = record + idThread : DWORD; + idThreadInstaller : DWORD; + lParam : LPARAM; + wParam : WPARAM; + code : longint; + end; + tagDEBUGHOOKINFO = DEBUGHOOKINFO; + TDEBUGHOOKINFO = DEBUGHOOKINFO; + PDEBUGHOOKINFO = ^DEBUGHOOKINFO; + + DELETEITEMSTRUCT = record + CtlType : UINT; + CtlID : UINT; + itemID : UINT; + hwndItem : HWND; + itemData : UINT; + end; + tagDELETEITEMSTRUCT = DELETEITEMSTRUCT; + TDELETEITEMSTRUCT = DELETEITEMSTRUCT; + PDELETEITEMSTRUCT = ^DELETEITEMSTRUCT; + + DEV_BROADCAST_HDR = record + dbch_size : ULONG; + dbch_devicetype : ULONG; + dbch_reserved : ULONG; + end; + PDEV_BROADCAST_HDR = ^DEV_BROADCAST_HDR; + _DEV_BROADCAST_HDR = DEV_BROADCAST_HDR; + TDEVBROADCASTHDR = DEV_BROADCAST_HDR; + PDEVBROADCASTHDR = ^DEV_BROADCAST_HDR; + + DEV_BROADCAST_OEM = record + dbco_size : ULONG; + dbco_devicetype : ULONG; + dbco_reserved : ULONG; + dbco_identifier : ULONG; + dbco_suppfunc : ULONG; + end; + PDEV_BROADCAST_OEM = ^DEV_BROADCAST_OEM; + _DEV_BROADCAST_OEM = DEV_BROADCAST_OEM; + TDEVBROADCASTOEM = DEV_BROADCAST_OEM; + PDEVBROADCASTOEM = ^DEV_BROADCAST_OEM; + + DEV_BROADCAST_PORT = record + dbcp_size : ULONG; + dbcp_devicetype : ULONG; + dbcp_reserved : ULONG; + dbcp_name : array[0..0] of char; + end; + PDEV_BROADCAST_PORT = ^DEV_BROADCAST_PORT; + _DEV_BROADCAST_PORT = DEV_BROADCAST_PORT; + TDEVBROADCASTPORT = DEV_BROADCAST_PORT; + PDEVBROADCASTPORT = ^DEV_BROADCAST_PORT; + + _DEV_BROADCAST_USERDEFINED = record + dbud_dbh : _DEV_BROADCAST_HDR; + dbud_szName : array[0..0] of char; + dbud_rgbUserDefined : array[0..0] of BYTE; + end; + TDEVBROADCASTUSERDEFINED = _DEV_BROADCAST_USERDEFINED; + PDEVBROADCASTUSERDEFINED = ^_DEV_BROADCAST_USERDEFINED; + + DEV_BROADCAST_VOLUME = record + dbcv_size : ULONG; + dbcv_devicetype : ULONG; + dbcv_reserved : ULONG; + dbcv_unitmask : ULONG; + dbcv_flags : USHORT; + end; + PDEV_BROADCAST_VOLUME = ^DEV_BROADCAST_VOLUME; + _DEV_BROADCAST_VOLUME = DEV_BROADCAST_VOLUME; + TDEVBROADCASTVOLUME = DEV_BROADCAST_VOLUME; + PDEVBROADCASTVOLUME = ^DEV_BROADCAST_VOLUME; + + DEVMODE = record + dmDeviceName : array[0..(CCHDEVICENAME)-1] of BCHAR; + dmSpecVersion : WORD; + dmDriverVersion : WORD; + dmSize : WORD; + dmDriverExtra : WORD; + dmFields : DWORD; + case byte of + 1: (dmOrientation : SmallInt; + dmPaperSize : SmallInt; + dmPaperLength : SmallInt; + dmPaperWidth : SmallInt; + dmScale : SmallInt; + dmCopies : SmallInt; + dmDefaultSource : SmallInt; + dmPrintQuality : SmallInt; + dmColor : SmallInt; + dmDuplex : SmallInt; + dmYResolution : SmallInt; + dmTTOption : SmallInt; + dmCollate : SmallInt; + dmFormName : array[0..(CCHFORMNAME)-1] of BCHAR; + dmLogPixels : WORD; + dmBitsPerPel : DWORD; + dmPelsWidth : DWORD; + dmPelsHeight : DWORD; + dmDisplayFlags : DWORD; + dmDisplayFrequency : DWORD; + dmICMMethod : DWORD; + dmICMIntent : DWORD; + dmMediaType : DWORD; + dmDitherType : DWORD; + dmICCManufacturer : DWORD; + dmICCModel : DWORD + ); + 2: (dmPosition: POINTL; + dmDisplayOrientation: DWORD; + dmDisplayFixedOutput: DWORD; + ); + end; + + LPDEVMODE = ^DEVMODE; + _devicemode = DEVMODE; + devicemode = DEVMODE; + tdevicemode = DEVMODE; + tdevicemodeA = DEVMODE; + PDeviceModeA = LPDEVMODE; + PDeviceMode = LPDEVMODE; + TDEVMODE = DEVMODE; + PDEVMODE = LPDEVMODE; + + + devmodeW = record + dmDeviceName : array[0.. CCHDEVICENAME-1] of WCHAR; + dmSpecVersion : WORD; + dmDriverVersion: WORD; + dmSize : WORD; + dmDriverExtra : WORD; + dmFields : DWORD; + dmOrientation : short; + dmPaperSize : short; + dmPaperLength : short; + dmPaperWidth : short; + dmScale : short; + dmCopies : short; + dmDefaultSource: short; + dmPrintQuality : short; + dmColor : short; + dmDuplex : short; + dmYResolution : short; + dmTTOption : short; + dmCollate : short; + dmFormName : array [0..CCHFORMNAME-1] of wchar; + dmLogPixels : WORD; + dmBitsPerPel : DWORD; + dmPelsWidth : DWORD; + dmPelsHeight : DWORD; + dmDisplayFlags : DWORD; + dmDisplayFrequency : DWORD; + dmICMMethod : DWORD; + dmICMIntent : DWORD; + dmMediaType : DWORD; + dmDitherType : DWORD; + dmReserved1 : DWORD; + dmReserved2 : DWORD; + dmPanningWidth : DWORD; + dmPanningHeight: DWORD; + end; + + LPDEVMODEW = ^DEVMODEW; + _devicemodeW = DEVMODEW; + devicemodeW = DEVMODEW; + TDeviceModeW = DEVMODEW; + PDeviceModeW = LPDEVMODEW; + TDEVMODEW = DEVMODEW; + + PDEVMODEW = LPDEVMODEW; + + DEVNAMES = record + wDriverOffset : WORD; + wDeviceOffset : WORD; + wOutputOffset : WORD; + wDefault : WORD; + end; + LPDEVNAMES = ^DEVNAMES; + tagDEVNAMES = DEVNAMES; + TDEVNAMES = DEVNAMES; + PDEVNAMES = ^DEVNAMES; + + DIBSECTION = record + dsBm : BITMAP; + dsBmih : BITMAPINFOHEADER; + dsBitfields : array[0..2] of DWORD; + dshSection : HANDLE; + dsOffset : DWORD; + end; + tagDIBSECTION = DIBSECTION; + TDIBSECTION = DIBSECTION; + PDIBSECTION = ^DIBSECTION; + + LARGE_INTEGER = record //winnt + case byte of + 0: (LowPart : DWORD; + HighPart : LONG); + 1: (QuadPart : LONGLONG); + end; + PLARGE_INTEGER = ^LARGE_INTEGER; //winnt + _LARGE_INTEGER = LARGE_INTEGER; //winnt + + TLargeInteger = Int64; + PLargeInteger = ^TLargeInteger; + + ULARGE_INTEGER = record + case byte of + 0: (LowPart : DWORD; + HighPart : DWORD); + 1: (QuadPart : LONGLONG); + end; + PULARGE_INTEGER = ^ULARGE_INTEGER; + _ULARGE_INTEGER = ULARGE_INTEGER; + + TULargeInteger = QWord; + PULargeInteger = ^TULargeInteger; + + DISK_GEOMETRY = record + Cylinders : LARGE_INTEGER; + MediaType : MEDIA_TYPE; + TracksPerCylinder : DWORD; + SectorsPerTrack : DWORD; + BytesPerSector : DWORD; + end; + _DISK_GEOMETRY = DISK_GEOMETRY; + TDISKGEOMETRY = DISK_GEOMETRY; + PDISKGEOMETRY = ^DISK_GEOMETRY; + + DISK_PERFORMANCE = record + BytesRead : LARGE_INTEGER; + BytesWritten : LARGE_INTEGER; + ReadTime : LARGE_INTEGER; + WriteTime : LARGE_INTEGER; + ReadCount : DWORD; + WriteCount : DWORD; + QueueDepth : DWORD; + end; + _DISK_PERFORMANCE = DISK_PERFORMANCE; + TDISKPERFORMANCE = DISK_PERFORMANCE; + PDISKPERFORMANCE = ^DISK_PERFORMANCE; + + DLGITEMTEMPLATE = packed record + style : DWORD; + dwExtendedStyle : DWORD; + x : integer; + y : integer; + cx : integer; + cy : integer; + id : WORD; + end; + LPDLGITEMTEMPLATE = ^DLGITEMTEMPLATE; + TDLGITEMTEMPLATE = DLGITEMTEMPLATE; + PDLGITEMTEMPLATE = ^DLGITEMTEMPLATE; + + DLGTEMPLATE = packed record + style : DWORD; + dwExtendedStyle : DWORD; + cdit : WORD; + x : integer; + y : integer; + cx : integer; + cy : integer; + end; + LPDLGTEMPLATE = ^DLGTEMPLATE; + LPCDLGTEMPLATE = ^DLGTEMPLATE; + LPCDLGTEMPLATEW = ^DLGTEMPLATE; //+winuser + TDLGTEMPLATE = DLGTEMPLATE; + PDLGTEMPLATE = ^DLGTEMPLATE; + + DOC_INFO_1 = record + pDocName : LPTSTR; + pOutputFile : LPTSTR; + pDatatype : LPTSTR; + end; + _DOC_INFO_1 = DOC_INFO_1; + TDOCINFO1 = DOC_INFO_1; + PDOCINFO1 = ^DOC_INFO_1; + + DOC_INFO_2 = record + pDocName : LPTSTR; + pOutputFile : LPTSTR; + pDatatype : LPTSTR; + dwMode : DWORD; + JobId : DWORD; + end; + _DOC_INFO_2 = DOC_INFO_2; + TDOCINFO2 = DOC_INFO_2; + PDOCINFO2 = ^DOC_INFO_2; + + DOCINFO = record + cbSize : longint; + lpszDocName : LPCTSTR; + lpszOutput : LPCTSTR; + lpszDatatype : LPCTSTR; + fwType : DWORD; + end; + TDOCINFO = DOCINFO; + TDOCINFOA = DOCINFO; + PDOCINFO = ^DOCINFO; + + DOCINFOW = record //+wingdi + cbSize : Integer; + lpszDocName : LPCWSTR; + lpszOutput : LPCWSTR; + lpszDatatype : LPCWSTR; + fwType : DWORD; + end; + _DOCINFOW=DOCINFOW; //+wingdi + LPDOCINFOW=^PDOCINFO; //+wingdi + PDOCINFOW=^PDOCINFO; //+wingdi + + DRAGLISTINFO = record + uNotification : UINT; + hWnd : HWND; + ptCursor : POINT; + end; + LPDRAGLISTINFO = ^DRAGLISTINFO; + TDRAGLISTINFO = DRAGLISTINFO; + PDRAGLISTINFO = ^DRAGLISTINFO; + + DRAWITEMSTRUCT = record + CtlType : UINT; + CtlID : UINT; + itemID : UINT; + itemAction : UINT; + itemState : UINT; + hwndItem : HWND; + hDC : HDC; + rcItem : RECT; + itemData : DWORD; + end; + LPDRAWITEMSTRUCT = ^DRAWITEMSTRUCT; + tagDRAWITEMSTRUCT = DRAWITEMSTRUCT; + TDRAWITEMSTRUCT = DRAWITEMSTRUCT; + PDRAWITEMSTRUCT = ^DRAWITEMSTRUCT; + + DRAWTEXTPARAMS = record + cbSize : UINT; + iTabLength : longint; + iLeftMargin : longint; + iRightMargin : longint; + uiLengthDrawn : UINT; + end; + LPDRAWTEXTPARAMS = ^DRAWTEXTPARAMS; + TDRAWTEXTPARAMS = DRAWTEXTPARAMS; + PDRAWTEXTPARAMS = ^DRAWTEXTPARAMS; + + PARTITION_INFORMATION = record + PartitionType : BYTE; + BootIndicator : BOOLEAN; + RecognizedPartition : BOOLEAN; + RewritePartition : BOOLEAN; + StartingOffset : LARGE_INTEGER; + PartitionLength : LARGE_INTEGER; + HiddenSectors : LARGE_INTEGER; + end; + _PARTITION_INFORMATION = PARTITION_INFORMATION; + TPARTITIONINFORMATION = PARTITION_INFORMATION; + PPARTITIONINFORMATION = ^PARTITION_INFORMATION; + + DRIVE_LAYOUT_INFORMATION = record + PartitionCount : DWORD; + Signature : DWORD; + PartitionEntry : array[0..0] of PARTITION_INFORMATION; + end; + _DRIVE_LAYOUT_INFORMATION = DRIVE_LAYOUT_INFORMATION; + TDRIVELAYOUTINFORMATION = DRIVE_LAYOUT_INFORMATION; + PDRIVELAYOUTINFORMATION = ^DRIVE_LAYOUT_INFORMATION; + + DRIVER_INFO_1 = record + pName : LPTSTR; + end; + _DRIVER_INFO_1 = DRIVER_INFO_1; + TDRIVERINFO1 = DRIVER_INFO_1; + PDRIVERINFO1 = ^DRIVER_INFO_1; + + DRIVER_INFO_2 = record + cVersion : DWORD; + pName : LPTSTR; + pEnvironment : LPTSTR; + pDriverPath : LPTSTR; + pDataFile : LPTSTR; + pConfigFile : LPTSTR; + end; + _DRIVER_INFO_2 = DRIVER_INFO_2; + TDRIVERINFO2 = DRIVER_INFO_2; + PDRIVERINFO2 = ^DRIVER_INFO_2; + + DRIVER_INFO_3 = record + cVersion : DWORD; + pName : LPTSTR; + pEnvironment : LPTSTR; + pDriverPath : LPTSTR; + pDataFile : LPTSTR; + pConfigFile : LPTSTR; + pHelpFile : LPTSTR; + pDependentFiles : LPTSTR; + pMonitorName : LPTSTR; + pDefaultDataType : LPTSTR; + end; + _DRIVER_INFO_3 = DRIVER_INFO_3; + TDRIVERINFO3 = DRIVER_INFO_3; + PDRIVERINFO3 = ^DRIVER_INFO_3; + + EDITSTREAM = record + dwCookie : DWORD; + dwError : DWORD; + pfnCallback : EDITSTREAMCALLBACK; + end; + _editstream = EDITSTREAM; + Teditstream = EDITSTREAM; + Peditstream = ^EDITSTREAM; + + EMR = record + iType : DWORD; + nSize : DWORD; + end; + tagEMR = EMR; + TEMR = EMR; + PEMR = ^EMR; + + EMRANGLEARC = record + emr : EMR; + ptlCenter : POINTL; + nRadius : DWORD; + eStartAngle : Single; + eSweepAngle : Single; + end; + tagEMRANGLEARC = EMRANGLEARC; + TEMRANGLEARC = EMRANGLEARC; + PEMRANGLEARC = ^EMRANGLEARC; + + EMRARC = record + emr : EMR; + rclBox : RECTL; + ptlStart : POINTL; + ptlEnd : POINTL; + end; + tagEMRARC = EMRARC; + TEMRARC = EMRARC; + PEMRARC = ^EMRARC; + + EMRARCTO = EMRARC; + TEMRARCTO = EMRARC; + PEMRARCTO = ^EMRARC; + + EMRCHORD = EMRARC; + TEMRCHORD = EMRARC; + PEMRCHORD = ^EMRARC; + + EMRPIE = EMRARC; + TEMRPIE = EMRARC; + PEMRPIE = ^EMRARC; + + XFORM = record + eM11 : Single; + eM12 : Single; + eM21 : Single; + eM22 : Single; + eDx : Single; + eDy : Single; + end; + LPXFORM = ^XFORM; + _XFORM = XFORM; + TXFORM = XFORM; + PXFORM = ^XFORM; + + EMRBITBLT = record + emr : EMR; + rclBounds : RECTL; + xDest : LONG; + yDest : LONG; + cxDest : LONG; + cyDest : LONG; + dwRop : DWORD; + xSrc : LONG; + ySrc : LONG; + xformSrc : XFORM; + crBkColorSrc : COLORREF; + iUsageSrc : DWORD; + offBmiSrc : DWORD; + offBitsSrc : DWORD; + cbBitsSrc : DWORD; + end; + tagEMRBITBLT = EMRBITBLT; + TEMRBITBLT = EMRBITBLT; + PEMRBITBLT = ^EMRBITBLT; + + LOGBRUSH = record + lbStyle : UINT; + lbColor : COLORREF; + lbHatch : LONG; + end; + tagLOGBRUSH = LOGBRUSH; + TLOGBRUSH = LOGBRUSH; + PLOGBRUSH = ^LOGBRUSH; + + EMRCREATEBRUSHINDIRECT = record + emr : EMR; + ihBrush : DWORD; + lb : LOGBRUSH; + end; + tagEMRCREATEBRUSHINDIRECT = EMRCREATEBRUSHINDIRECT; + TEMRCREATEBRUSHINDIRECT = EMRCREATEBRUSHINDIRECT; + PEMRCREATEBRUSHINDIRECT = ^EMRCREATEBRUSHINDIRECT; + + LCSCSTYPE = LONG; + + LCSGAMUTMATCH = LONG; + + LOGCOLORSPACE = record + lcsSignature : DWORD; + lcsVersion : DWORD; + lcsSize : DWORD; + lcsCSType : LCSCSTYPE; + lcsIntent : LCSGAMUTMATCH; + lcsEndpoints : CIEXYZTRIPLE; + lcsGammaRed : DWORD; + lcsGammaGreen : DWORD; + lcsGammaBlue : DWORD; + lcsFilename : array[0..(MAX_PATH)-1] of TCHAR; + end; + LPLOGCOLORSPACE = ^LOGCOLORSPACE; + tagLOGCOLORSPACE = LOGCOLORSPACE; + TLOGCOLORSPACE = LOGCOLORSPACE; + TLOGCOLORSPACEA = LOGCOLORSPACE; + PLOGCOLORSPACE = ^LOGCOLORSPACE; + + EMRCREATECOLORSPACE = record + emr : EMR; + ihCS : DWORD; + lcs : LOGCOLORSPACE; + end; + tagEMRCREATECOLORSPACE = EMRCREATECOLORSPACE; + TEMRCREATECOLORSPACE = EMRCREATECOLORSPACE; + PEMRCREATECOLORSPACE = ^EMRCREATECOLORSPACE; + + EMRCREATEDIBPATTERNBRUSHPT = record + emr : EMR; + ihBrush : DWORD; + iUsage : DWORD; + offBmi : DWORD; + cbBmi : DWORD; + offBits : DWORD; + cbBits : DWORD; + end; + tagEMRCREATEDIBPATTERNBRUSHPT = EMRCREATEDIBPATTERNBRUSHPT; + TEMRCREATEDIBPATTERNBRUSHPT = EMRCREATEDIBPATTERNBRUSHPT; + PEMRCREATEDIBPATTERNBRUSHPT = EMRCREATEDIBPATTERNBRUSHPT; + + EMRCREATEMONOBRUSH = record + emr : EMR; + ihBrush : DWORD; + iUsage : DWORD; + offBmi : DWORD; + cbBmi : DWORD; + offBits : DWORD; + cbBits : DWORD; + end; + tagEMRCREATEMONOBRUSH = EMRCREATEMONOBRUSH; + TEMRCREATEMONOBRUSH = EMRCREATEMONOBRUSH; + PEMRCREATEMONOBRUSH = ^EMRCREATEMONOBRUSH; + + PALETTEENTRY = record + peRed : BYTE; + peGreen : BYTE; + peBlue : BYTE; + peFlags : BYTE; + end; + LPPALETTEENTRY = ^PALETTEENTRY; + tagPALETTEENTRY = PALETTEENTRY; + TPALETTEENTRY = PALETTEENTRY; + PPALETTEENTRY = ^PALETTEENTRY; + + LOGPALETTE = record + palVersion : WORD; + palNumEntries : WORD; + palPalEntry : array[0..0] of PALETTEENTRY; + end; + LPLOGPALETTE = ^LOGPALETTE; + tagLOGPALETTE = LOGPALETTE; + TLOGPALETTE = LOGPALETTE; + PLOGPALETTE = ^LOGPALETTE; + + EMRCREATEPALETTE = record + emr : EMR; + ihPal : DWORD; + lgpl : LOGPALETTE; + end; + tagEMRCREATEPALETTE = EMRCREATEPALETTE; + TEMRCREATEPALETTE = EMRCREATEPALETTE; + PEMRCREATEPALETTE = ^EMRCREATEPALETTE; + + LOGPEN = record + lopnStyle : UINT; + lopnWidth : POINT; + lopnColor : COLORREF; + end; + tagLOGPEN = LOGPEN; + TLOGPEN = LOGPEN; + PLOGPEN = ^LOGPEN; + + EMRCREATEPEN = record + emr : EMR; + ihPen : DWORD; + lopn : LOGPEN; + end; + tagEMRCREATEPEN = EMRCREATEPEN; + TEMRCREATEPEN = EMRCREATEPEN; + PEMRCREATEPEN = ^EMRCREATEPEN; + + EMRELLIPSE = record + emr : EMR; + rclBox : RECTL; + end; + tagEMRELLIPSE = EMRELLIPSE; + TEMRELLIPSE = EMRELLIPSE; + PEMRELLIPSE = ^EMRELLIPSE; + + EMRRECTANGLE = EMRELLIPSE; + TEMRRECTANGLE = EMRELLIPSE; + PEMRRECTANGLE = ^EMRELLIPSE; + + EMREOF = record + emr : EMR; + nPalEntries : DWORD; + offPalEntries : DWORD; + nSizeLast : DWORD; + end; + tagEMREOF = EMREOF; + TEMREOF = EMREOF; + PEMREOF = ^EMREOF; + + EMREXCLUDECLIPRECT = record + emr : EMR; + rclClip : RECTL; + end; + tagEMREXCLUDECLIPRECT = EMREXCLUDECLIPRECT; + TEMREXCLUDECLIPRECT = EMREXCLUDECLIPRECT; + PEMREXCLUDECLIPRECT = ^EMREXCLUDECLIPRECT; + + EMRINTERSECTCLIPRECT = EMREXCLUDECLIPRECT; + TEMRINTERSECTCLIPRECT = EMREXCLUDECLIPRECT; + PEMRINTERSECTCLIPRECT = ^EMREXCLUDECLIPRECT; + + PANOSE = record + bFamilyType : BYTE; + bSerifStyle : BYTE; + bWeight : BYTE; + bProportion : BYTE; + bContrast : BYTE; + bStrokeVariation : BYTE; + bArmStyle : BYTE; + bLetterform : BYTE; + bMidline : BYTE; + bXHeight : BYTE; + end; + tagPANOSE = PANOSE; + TPANOSE = PANOSE; + PPANOSE = ^PANOSE; + + EXTLOGFONT = record + elfLogFont : LOGFONT; + elfFullName : array[0..(LF_FULLFACESIZE)-1] of BCHAR; + elfStyle : array[0..(LF_FACESIZE)-1] of BCHAR; + elfVersion : DWORD; + elfStyleSize : DWORD; + elfMatch : DWORD; + elfReserved : DWORD; + elfVendorId : array[0..(ELF_VENDOR_SIZE)-1] of BYTE; + elfCulture : DWORD; + elfPanose : PANOSE; + end; + tagEXTLOGFONT = EXTLOGFONT; + TEXTLOGFONT = EXTLOGFONT; + PEXTLOGFONT = ^EXTLOGFONT; + + EMREXTCREATEFONTINDIRECTW = record + emr : EMR; + ihFont : DWORD; + elfw : EXTLOGFONT; + end; + tagEMREXTCREATEFONTINDIRECTW = EMREXTCREATEFONTINDIRECTW; + TEMREXTCREATEFONTINDIRECTW = EMREXTCREATEFONTINDIRECTW; + PEMREXTCREATEFONTINDIRECTW = ^EMREXTCREATEFONTINDIRECTW; + + + EXTLOGPEN = record + elpPenStyle : UINT; + elpWidth : UINT; + elpBrushStyle : UINT; + elpColor : COLORREF; + elpHatch : LONG; + elpNumEntries : DWORD; + elpStyleEntry : array[0..0] of DWORD; + end; + tagEXTLOGPEN = EXTLOGPEN; + TEXTLOGPEN = EXTLOGPEN; + PEXTLOGPEN = ^EXTLOGPEN; + + EMREXTCREATEPEN = record + emr : EMR; + ihPen : DWORD; + offBmi : DWORD; + cbBmi : DWORD; + offBits : DWORD; + cbBits : DWORD; + elp : EXTLOGPEN; + end; + tagEMREXTCREATEPEN = EMREXTCREATEPEN; + TEMREXTCREATEPEN = EMREXTCREATEPEN; + PEMREXTCREATEPEN = ^EMREXTCREATEPEN; + + EMREXTFLOODFILL = record + emr : EMR; + ptlStart : POINTL; + crColor : COLORREF; + iMode : DWORD; + end; + tagEMREXTFLOODFILL = EMREXTFLOODFILL; + TEMREXTFLOODFILL = EMREXTFLOODFILL; + PEMREXTFLOODFILL = ^EMREXTFLOODFILL; + + EMREXTSELECTCLIPRGN = record + emr : EMR; + cbRgnData : DWORD; + iMode : DWORD; + RgnData : array[0..0] of BYTE; + end; + tagEMREXTSELECTCLIPRGN = EMREXTSELECTCLIPRGN; + TEMREXTSELECTCLIPRGN = EMREXTSELECTCLIPRGN; + PEMREXTSELECTCLIPRGN = ^EMREXTSELECTCLIPRGN; + + EMRTEXT = record + ptlReference : POINTL; + nChars : DWORD; + offString : DWORD; + fOptions : DWORD; + rcl : RECTL; + offDx : DWORD; + end; + tagEMRTEXT = EMRTEXT; + TEMRTEXT = EMRTEXT; + PEMRTEXT = ^EMRTEXT; + + EMREXTTEXTOUTA = record + emr : EMR; + rclBounds : RECTL; + iGraphicsMode : DWORD; + exScale : Single; + eyScale : Single; + emrtext : EMRTEXT; + end; + tagEMREXTTEXTOUTA = EMREXTTEXTOUTA; + TEMREXTTEXTOUTA = EMREXTTEXTOUTA; + PEMREXTTEXTOUTA = ^EMREXTTEXTOUTA; + + EMREXTTEXTOUTW = EMREXTTEXTOUTA; + TEMREXTTEXTOUTW = EMREXTTEXTOUTA; + PEMREXTTEXTOUTW = ^EMREXTTEXTOUTA; + + EMRFILLPATH = record + emr : EMR; + rclBounds : RECTL; + end; + tagEMRFILLPATH = EMRFILLPATH; + TEMRFILLPATH = EMRFILLPATH; + PEMRFILLPATH = ^EMRFILLPATH; + + EMRSTROKEANDFILLPATH = EMRFILLPATH; + TEMRSTROKEANDFILLPATH = EMRFILLPATH; + PEMRSTROKEANDFILLPATH = ^EMRFILLPATH; + + EMRSTROKEPATH = EMRFILLPATH; + TEMRSTROKEPATH = EMRFILLPATH; + PEMRSTROKEPATH = ^EMRFILLPATH; + + EMRFILLRGN = record + emr : EMR; + rclBounds : RECTL; + cbRgnData : DWORD; + ihBrush : DWORD; + RgnData : array[0..0] of BYTE; + end; + tagEMRFILLRGN = EMRFILLRGN; + TEMRFILLRGN = EMRFILLRGN; + PEMRFILLRGN = ^EMRFILLRGN; + + EMRFORMAT = record + dSignature : DWORD; + nVersion : DWORD; + cbData : DWORD; + offData : DWORD; + end; + tagEMRFORMAT = EMRFORMAT; + TEMRFORMAT = EMRFORMAT; + PEMRFORMAT = ^EMRFORMAT; + + SIZE = record + cx : LONG; + cy : LONG; + end; + LPSIZE = ^SIZE; + tagSIZE = SIZE; + TSIZE = SIZE; + PSIZE = ^SIZE; + + SIZEL = SIZE; //windef + TSIZEL = SIZE; //windef + PSIZEL = ^SIZE; + LPSIZEL = ^SIZE; + + EMRFRAMERGN = record + emr : EMR; + rclBounds : RECTL; + cbRgnData : DWORD; + ihBrush : DWORD; + szlStroke : SIZEL; + RgnData : array[0..0] of BYTE; + end; + tagEMRFRAMERGN = EMRFRAMERGN; + TEMRFRAMERGN = EMRFRAMERGN; + PEMRFRAMERGN = ^EMRFRAMERGN; + + EMRGDICOMMENT = record + emr : EMR; + cbData : DWORD; + Data : array[0..0] of BYTE; + end; + tagEMRGDICOMMENT = EMRGDICOMMENT; + TEMRGDICOMMENT = EMRGDICOMMENT; + PEMRGDICOMMENT = ^EMRGDICOMMENT; + + EMRINVERTRGN = record + emr : EMR; + rclBounds : RECTL; + cbRgnData : DWORD; + RgnData : array[0..0] of BYTE; + end; + tagEMRINVERTRGN = EMRINVERTRGN; + TEMRINVERTRGN = EMRINVERTRGN; + PEMRINVERTRGN = ^EMRINVERTRGN; + + EMRPAINTRGN = EMRINVERTRGN; + TEMRPAINTRGN = EMRINVERTRGN; + PEMRPAINTRGN = ^EMRINVERTRGN; + + EMRLINETO = record + emr : EMR; + ptl : POINTL; + end; + tagEMRLINETO = EMRLINETO; + TEMRLINETO = EMRLINETO; + PEMRLINETO = ^EMRLINETO; + + EMRMOVETOEX = EMRLINETO; + TEMRMOVETOEX = EMRLINETO; + PEMRMOVETOEX = ^EMRLINETO; + + EMRMASKBLT = record + emr : EMR; + rclBounds : RECTL; + xDest : LONG; + yDest : LONG; + cxDest : LONG; + cyDest : LONG; + dwRop : DWORD; + xSrc : LONG; + ySrc : LONG; + xformSrc : XFORM; + crBkColorSrc : COLORREF; + iUsageSrc : DWORD; + offBmiSrc : DWORD; + cbBmiSrc : DWORD; + offBitsSrc : DWORD; + cbBitsSrc : DWORD; + xMask : LONG; + yMask : LONG; + iUsageMask : DWORD; + offBmiMask : DWORD; + cbBmiMask : DWORD; + offBitsMask : DWORD; + cbBitsMask : DWORD; + end; + tagEMRMASKBLT = EMRMASKBLT; + TEMRMASKBLT = EMRMASKBLT; + PEMRMASKBLT = ^EMRMASKBLT; + + EMRMODIFYWORLDTRANSFORM = record + emr : EMR; + xform : XFORM; + iMode : DWORD; + end; + tagEMRMODIFYWORLDTRANSFORM = EMRMODIFYWORLDTRANSFORM; + TEMRMODIFYWORLDTRANSFORM = EMRMODIFYWORLDTRANSFORM; + PEMRMODIFYWORLDTRANSFORM = EMRMODIFYWORLDTRANSFORM; + + EMROFFSETCLIPRGN = record + emr : EMR; + ptlOffset : POINTL; + end; + tagEMROFFSETCLIPRGN = EMROFFSETCLIPRGN; + TEMROFFSETCLIPRGN = EMROFFSETCLIPRGN; + PEMROFFSETCLIPRGN = ^EMROFFSETCLIPRGN; + + EMRPLGBLT = record + emr : EMR; + rclBounds : RECTL; + aptlDest : array[0..2] of POINTL; + xSrc : LONG; + ySrc : LONG; + cxSrc : LONG; + cySrc : LONG; + xformSrc : XFORM; + crBkColorSrc : COLORREF; + iUsageSrc : DWORD; + offBmiSrc : DWORD; + cbBmiSrc : DWORD; + offBitsSrc : DWORD; + cbBitsSrc : DWORD; + xMask : LONG; + yMask : LONG; + iUsageMask : DWORD; + offBmiMask : DWORD; + cbBmiMask : DWORD; + offBitsMask : DWORD; + cbBitsMask : DWORD; + end; + tagEMRPLGBLT = EMRPLGBLT; + TEMRPLGBLT = EMRPLGBLT; + PEMRPLGBLT = ^EMRPLGBLT; + + EMRPOLYDRAW = record + emr : EMR; + rclBounds : RECTL; + cptl : DWORD; + aptl : array[0..0] of POINTL; + abTypes : array[0..0] of BYTE; + end; + tagEMRPOLYDRAW = EMRPOLYDRAW; + TEMRPOLYDRAW = EMRPOLYDRAW; + PEMRPOLYDRAW = ^EMRPOLYDRAW; + + EMRPOLYDRAW16 = record + emr : EMR; + rclBounds : RECTL; + cpts : DWORD; + apts : array[0..0] of POINTS; + abTypes : array[0..0] of BYTE; + end; + tagEMRPOLYDRAW16 = EMRPOLYDRAW16; + TEMRPOLYDRAW16 = EMRPOLYDRAW16; + PEMRPOLYDRAW16 = ^EMRPOLYDRAW16; + + EMRPOLYLINE = record + emr : EMR; + rclBounds : RECTL; + cptl : DWORD; + aptl : array[0..0] of POINTL; + end; + tagEMRPOLYLINE = EMRPOLYLINE; + TEMRPOLYLINE = EMRPOLYLINE; + PEMRPOLYLINE = ^EMRPOLYLINE; + + EMRPOLYBEZIER = EMRPOLYLINE; + TEMRPOLYBEZIER = EMRPOLYLINE; + PEMRPOLYBEZIER = ^EMRPOLYLINE; + + EMRPOLYGON = EMRPOLYLINE; + TEMRPOLYGON = EMRPOLYLINE; + PEMRPOLYGON = ^EMRPOLYLINE; + + EMRPOLYBEZIERTO = EMRPOLYLINE; + TEMRPOLYBEZIERTO = EMRPOLYLINE; + PEMRPOLYBEZIERTO = ^EMRPOLYLINE; + + EMRPOLYLINETO = EMRPOLYLINE; + TEMRPOLYLINETO = EMRPOLYLINE; + PEMRPOLYLINETO = ^EMRPOLYLINE; + + EMRPOLYLINE16 = record + emr : EMR; + rclBounds : RECTL; + cpts : DWORD; + apts : array[0..0] of POINTL; + end; + tagEMRPOLYLINE16 = EMRPOLYLINE16; + TEMRPOLYLINE16 = EMRPOLYLINE16; + PEMRPOLYLINE16 = ^EMRPOLYLINE16; + + EMRPOLYBEZIER16 = EMRPOLYLINE16; + TEMRPOLYBEZIER16 = EMRPOLYLINE16; + PEMRPOLYBEZIER16 = ^EMRPOLYLINE16; + + EMRPOLYGON16 = EMRPOLYLINE16; + TEMRPOLYGON16 = EMRPOLYLINE16; + PEMRPOLYGON16 = ^EMRPOLYLINE16; + + EMRPOLYBEZIERTO16 = EMRPOLYLINE16; + TEMRPOLYBEZIERTO16 = EMRPOLYLINE16; + PEMRPOLYBEZIERTO16 = ^EMRPOLYLINE16; + + EMRPOLYLINETO16 = EMRPOLYLINE16; + TEMRPOLYLINETO16 = EMRPOLYLINE16; + PEMRPOLYLINETO16 = ^EMRPOLYLINE16; + + EMRPOLYPOLYLINE = record + emr : EMR; + rclBounds : RECTL; + nPolys : DWORD; + cptl : DWORD; + aPolyCounts : array[0..0] of DWORD; + aptl : array[0..0] of POINTL; + end; + tagEMRPOLYPOLYLINE = EMRPOLYPOLYLINE; + TEMRPOLYPOLYLINE = EMRPOLYPOLYLINE; + PEMRPOLYPOLYLINE = ^EMRPOLYPOLYLINE; + + EMRPOLYPOLYGON = EMRPOLYPOLYLINE; + TEMRPOLYPOLYGON = EMRPOLYPOLYLINE; + PEMRPOLYPOLYGON = ^EMRPOLYPOLYLINE; + + EMRPOLYPOLYLINE16 = record + emr : EMR; + rclBounds : RECTL; + nPolys : DWORD; + cpts : DWORD; + aPolyCounts : array[0..0] of DWORD; + apts : array[0..0] of POINTS; + end; + tagEMRPOLYPOLYLINE16 = EMRPOLYPOLYLINE16; + TEMRPOLYPOLYLINE16 = EMRPOLYPOLYLINE16; + PEMRPOLYPOLYLINE16 = ^EMRPOLYPOLYLINE16; + + EMRPOLYPOLYGON16 = EMRPOLYPOLYLINE16; + TEMRPOLYPOLYGON16 = EMRPOLYPOLYLINE16; + PEMRPOLYPOLYGON16 = ^EMRPOLYPOLYLINE16; + + EMRPOLYTEXTOUTA = record + emr : EMR; + rclBounds : RECTL; + iGraphicsMode : DWORD; + exScale : Single; + eyScale : Single; + cStrings : LONG; + aemrtext : array[0..0] of EMRTEXT; + end; + tagEMRPOLYTEXTOUTA = EMRPOLYTEXTOUTA; + TEMRPOLYTEXTOUTA = EMRPOLYTEXTOUTA; + PEMRPOLYTEXTOUTA = ^EMRPOLYTEXTOUTA; + + EMRPOLYTEXTOUTW = EMRPOLYTEXTOUTA; + TEMRPOLYTEXTOUTW = EMRPOLYTEXTOUTA; + PEMRPOLYTEXTOUTW = ^EMRPOLYTEXTOUTA; + + EMRRESIZEPALETTE = record + emr : EMR; + ihPal : DWORD; + cEntries : DWORD; + end; + tagEMRRESIZEPALETTE = EMRRESIZEPALETTE; + TEMRRESIZEPALETTE = EMRRESIZEPALETTE; + PEMRRESIZEPALETTE = ^EMRRESIZEPALETTE; + + EMRRESTOREDC = record + emr : EMR; + iRelative : LONG; + end; + tagEMRRESTOREDC = EMRRESTOREDC; + TEMRRESTOREDC = EMRRESTOREDC; + PEMRRESTOREDC = ^EMRRESTOREDC; + + EMRROUNDRECT = record + emr : EMR; + rclBox : RECTL; + szlCorner : SIZEL; + end; + tagEMRROUNDRECT = EMRROUNDRECT; + TEMRROUNDRECT = EMRROUNDRECT; + PEMRROUNDRECT = ^EMRROUNDRECT; + + EMRSCALEVIEWPORTEXTEX = record + emr : EMR; + xNum : LONG; + xDenom : LONG; + yNum : LONG; + yDenom : LONG; + end; + tagEMRSCALEVIEWPORTEXTEX = EMRSCALEVIEWPORTEXTEX; + TEMRSCALEVIEWPORTEXTEX = EMRSCALEVIEWPORTEXTEX; + PEMRSCALEVIEWPORTEXTEX = ^EMRSCALEVIEWPORTEXTEX; + + EMRSCALEWINDOWEXTEX = EMRSCALEVIEWPORTEXTEX; + TEMRSCALEWINDOWEXTEX = EMRSCALEVIEWPORTEXTEX; + PEMRSCALEWINDOWEXTEX = ^EMRSCALEVIEWPORTEXTEX; + + EMRSELECTCOLORSPACE = record + emr : EMR; + ihCS : DWORD; + end; + tagEMRSELECTCOLORSPACE = EMRSELECTCOLORSPACE; + TEMRSELECTCOLORSPACE = EMRSELECTCOLORSPACE; + PEMRSELECTCOLORSPACE = ^EMRSELECTCOLORSPACE; + + EMRDELETECOLORSPACE = EMRSELECTCOLORSPACE; + TEMRDELETECOLORSPACE = EMRSELECTCOLORSPACE; + PEMRDELETECOLORSPACE = ^EMRSELECTCOLORSPACE; + + EMRSELECTOBJECT = record + emr : EMR; + ihObject : DWORD; + end; + tagEMRSELECTOBJECT = EMRSELECTOBJECT; + TEMRSELECTOBJECT = EMRSELECTOBJECT; + PEMRSELECTOBJECT = ^EMRSELECTOBJECT; + + EMRDELETEOBJECT = EMRSELECTOBJECT; + TEMRDELETEOBJECT = EMRSELECTOBJECT; + PEMRDELETEOBJECT = ^EMRSELECTOBJECT; + + EMRSELECTPALETTE = record + emr : EMR; + ihPal : DWORD; + end; + tagEMRSELECTPALETTE = EMRSELECTPALETTE; + TEMRSELECTPALETTE = EMRSELECTPALETTE; + PEMRSELECTPALETTE = ^EMRSELECTPALETTE; + + EMRSETARCDIRECTION = record + emr : EMR; + iArcDirection : DWORD; + end; + tagEMRSETARCDIRECTION = EMRSETARCDIRECTION; + TEMRSETARCDIRECTION = EMRSETARCDIRECTION; + PEMRSETARCDIRECTION = ^EMRSETARCDIRECTION; + + EMRSETBKCOLOR = record + emr : EMR; + crColor : COLORREF; + end; + tagEMRSETTEXTCOLOR = EMRSETBKCOLOR; + TEMRSETBKCOLOR = EMRSETBKCOLOR; + PEMRSETBKCOLOR = ^EMRSETBKCOLOR; + + EMRSETTEXTCOLOR = EMRSETBKCOLOR; + TEMRSETTEXTCOLOR = EMRSETBKCOLOR; + PEMRSETTEXTCOLOR = ^EMRSETBKCOLOR; + + EMRSETCOLORADJUSTMENT = record + emr : EMR; + ColorAdjustment : COLORADJUSTMENT; + end; + tagEMRSETCOLORADJUSTMENT = EMRSETCOLORADJUSTMENT; + TEMRSETCOLORADJUSTMENT = EMRSETCOLORADJUSTMENT; + PEMRSETCOLORADJUSTMENT = ^EMRSETCOLORADJUSTMENT; + + EMRSETDIBITSTODEVICE = record + emr : EMR; + rclBounds : RECTL; + xDest : LONG; + yDest : LONG; + xSrc : LONG; + ySrc : LONG; + cxSrc : LONG; + cySrc : LONG; + offBmiSrc : DWORD; + cbBmiSrc : DWORD; + offBitsSrc : DWORD; + cbBitsSrc : DWORD; + iUsageSrc : DWORD; + iStartScan : DWORD; + cScans : DWORD; + end; + tagEMRSETDIBITSTODEVICE = EMRSETDIBITSTODEVICE; + TEMRSETDIBITSTODEVICE = EMRSETDIBITSTODEVICE; + PEMRSETDIBITSTODEVICE = ^EMRSETDIBITSTODEVICE; + + EMRSETMAPPERFLAGS = record + emr : EMR; + dwFlags : DWORD; + end; + tagEMRSETMAPPERFLAGS = EMRSETMAPPERFLAGS; + TEMRSETMAPPERFLAGS = EMRSETMAPPERFLAGS; + PEMRSETMAPPERFLAGS = ^EMRSETMAPPERFLAGS; + + EMRSETMITERLIMIT = record + emr : EMR; + eMiterLimit : Single; + end; + tagEMRSETMITERLIMIT = EMRSETMITERLIMIT; + TEMRSETMITERLIMIT = EMRSETMITERLIMIT; + PEMRSETMITERLIMIT = ^EMRSETMITERLIMIT; + + EMRSETPALETTEENTRIES = record + emr : EMR; + ihPal : DWORD; + iStart : DWORD; + cEntries : DWORD; + aPalEntries : array[0..0] of PALETTEENTRY; + end; + tagEMRSETPALETTEENTRIES = EMRSETPALETTEENTRIES; + TEMRSETPALETTEENTRIES = EMRSETPALETTEENTRIES; + PEMRSETPALETTEENTRIES = ^EMRSETPALETTEENTRIES; + + EMRSETPIXELV = record + emr : EMR; + ptlPixel : POINTL; + crColor : COLORREF; + end; + tagEMRSETPIXELV = EMRSETPIXELV; + TEMRSETPIXELV = EMRSETPIXELV; + PEMRSETPIXELV = ^EMRSETPIXELV; + + EMRSETVIEWPORTEXTEX = record + emr : EMR; + szlExtent : SIZEL; + end; + tagEMRSETVIEWPORTEXTEX = EMRSETVIEWPORTEXTEX; + TEMRSETVIEWPORTEXTEX = EMRSETVIEWPORTEXTEX; + PEMRSETVIEWPORTEXTEX = ^EMRSETVIEWPORTEXTEX; + + EMRSETWINDOWEXTEX = EMRSETVIEWPORTEXTEX; + TEMRSETWINDOWEXTEX = EMRSETVIEWPORTEXTEX; + PEMRSETWINDOWEXTEX = ^EMRSETVIEWPORTEXTEX; + + EMRSETVIEWPORTORGEX = record + emr : EMR; + ptlOrigin : POINTL; + end; + tagEMRSETVIEWPORTORGEX = EMRSETVIEWPORTORGEX; + TEMRSETVIEWPORTORGEX = EMRSETVIEWPORTORGEX; + PEMRSETVIEWPORTORGEX = ^EMRSETVIEWPORTORGEX; + + EMRSETWINDOWORGEX = EMRSETVIEWPORTORGEX; + TEMRSETWINDOWORGEX = EMRSETVIEWPORTORGEX; + PEMRSETWINDOWORGEX = ^EMRSETVIEWPORTORGEX; + + EMRSETBRUSHORGEX = EMRSETVIEWPORTORGEX; + TEMRSETBRUSHORGEX = EMRSETVIEWPORTORGEX; + PEMRSETBRUSHORGEX = ^EMRSETVIEWPORTORGEX; + + EMRSETWORLDTRANSFORM = record + emr : EMR; + xform : XFORM; + end; + tagEMRSETWORLDTRANSFORM = EMRSETWORLDTRANSFORM; + TEMRSETWORLDTRANSFORM = EMRSETWORLDTRANSFORM; + PEMRSETWORLDTRANSFORM = ^EMRSETWORLDTRANSFORM; + + EMRSTRETCHBLT = record + emr : EMR; + rclBounds : RECTL; + xDest : LONG; + yDest : LONG; + cxDest : LONG; + cyDest : LONG; + dwRop : DWORD; + xSrc : LONG; + ySrc : LONG; + xformSrc : XFORM; + crBkColorSrc : COLORREF; + iUsageSrc : DWORD; + offBmiSrc : DWORD; + cbBmiSrc : DWORD; + offBitsSrc : DWORD; + cbBitsSrc : DWORD; + cxSrc : LONG; + cySrc : LONG; + end; + tagEMRSTRETCHBLT = EMRSTRETCHBLT; + TEMRSTRETCHBLT = EMRSTRETCHBLT; + PEMRSTRETCHBLT = ^EMRSTRETCHBLT; + + EMRSTRETCHDIBITS = record + emr : EMR; + rclBounds : RECTL; + xDest : LONG; + yDest : LONG; + xSrc : LONG; + ySrc : LONG; + cxSrc : LONG; + cySrc : LONG; + offBmiSrc : DWORD; + cbBmiSrc : DWORD; + offBitsSrc : DWORD; + cbBitsSrc : DWORD; + iUsageSrc : DWORD; + dwRop : DWORD; + cxDest : LONG; + cyDest : LONG; + end; + tagEMRSTRETCHDIBITS = EMRSTRETCHDIBITS; + TEMRSTRETCHDIBITS = EMRSTRETCHDIBITS; + PEMRSTRETCHDIBITS = ^EMRSTRETCHDIBITS; + + EMRABORTPATH = record + emr : EMR; + end; + TEMRABORTPATH = EMRABORTPATH; + PEMRABORTPATH = ^EMRABORTPATH; + + tagABORTPATH = EMRABORTPATH; + TABORTPATH = EMRABORTPATH; + + EMRBEGINPATH = EMRABORTPATH; + TEMRBEGINPATH = EMRABORTPATH; + PEMRBEGINPATH = ^EMRABORTPATH; + + EMRENDPATH = EMRABORTPATH; + TEMRENDPATH = EMRABORTPATH; + PEMRENDPATH = ^EMRABORTPATH; + + EMRCLOSEFIGURE = EMRABORTPATH; + TEMRCLOSEFIGURE = EMRABORTPATH; + PEMRCLOSEFIGURE = ^EMRABORTPATH; + + EMRFLATTENPATH = EMRABORTPATH; + TEMRFLATTENPATH = EMRABORTPATH; + PEMRFLATTENPATH = ^EMRABORTPATH; + + EMRWIDENPATH = EMRABORTPATH; + TEMRWIDENPATH = EMRABORTPATH; + PEMRWIDENPATH = ^EMRABORTPATH; + + EMRSETMETARGN = EMRABORTPATH; + TEMRSETMETARGN = EMRABORTPATH; + PEMRSETMETARGN = ^EMRABORTPATH; + + EMRSAVEDC = EMRABORTPATH; + TEMRSAVEDC = EMRABORTPATH; + PEMRSAVEDC = ^EMRABORTPATH; + + EMRREALIZEPALETTE = EMRABORTPATH; + TEMRREALIZEPALETTE = EMRABORTPATH; + PEMRREALIZEPALETTE = ^EMRABORTPATH; + + EMRSELECTCLIPPATH = record + emr : EMR; + iMode : DWORD; + end; + tagEMRSELECTCLIPPATH = EMRSELECTCLIPPATH; + TEMRSELECTCLIPPATH = EMRSELECTCLIPPATH; + PEMRSELECTCLIPPATH = ^EMRSELECTCLIPPATH; + + EMRSETBKMODE = EMRSELECTCLIPPATH; + TEMRSETBKMODE = EMRSELECTCLIPPATH; + PEMRSETBKMODE = ^EMRSELECTCLIPPATH; + + EMRSETMAPMODE = EMRSELECTCLIPPATH; + TEMRSETMAPMODE = EMRSELECTCLIPPATH; + PEMRSETMAPMODE = ^EMRSELECTCLIPPATH; + + EMRSETPOLYFILLMODE = EMRSELECTCLIPPATH; + TEMRSETPOLYFILLMODE = EMRSELECTCLIPPATH; + PEMRSETPOLYFILLMODE = ^EMRSELECTCLIPPATH; + + EMRSETROP2 = EMRSELECTCLIPPATH; + TEMRSETROP2 = EMRSELECTCLIPPATH; + PEMRSETROP2 = ^EMRSELECTCLIPPATH; + + EMRSETSTRETCHBLTMODE = EMRSELECTCLIPPATH; + TEMRSETSTRETCHBLTMODE = EMRSELECTCLIPPATH; + PEMRSETSTRETCHBLTMODE = ^EMRSELECTCLIPPATH; + + EMRSETTEXTALIGN = EMRSELECTCLIPPATH; + TEMRSETTEXTALIGN = EMRSELECTCLIPPATH; + PEMRSETTEXTALIGN = ^EMRSELECTCLIPPATH; + + EMRENABLEICM = EMRSELECTCLIPPATH; + TEMRENABLEICM = EMRSELECTCLIPPATH; + PEMRENABLEICM = ^EMRSELECTCLIPPATH; + + NMHDR = record + hwndFrom : HWND; + idFrom : UINT; + code : UINT; + end; + tagNMHDR = NMHDR; + TNMHDR = NMHDR; + PNMHDR = ^NMHDR; + + ENCORRECTTEXT = record + nmhdr : NMHDR; + chrg : CHARRANGE; + seltyp : WORD; + end; + _encorrecttext = ENCORRECTTEXT; + Tencorrecttext = ENCORRECTTEXT; + Pencorrecttext = ^ENCORRECTTEXT; + + ENDROPFILES = record + nmhdr : NMHDR; + hDrop : HANDLE; + cp : LONG; + fProtected : WINBOOL; + end; + _endropfiles = ENDROPFILES; + Tendropfiles = ENDROPFILES; + Pendropfiles = ^ENDROPFILES; + + ENSAVECLIPBOARD = record + nmhdr : NMHDR; + cObjectCount : LONG; + cch : LONG; + end; + TENSAVECLIPBOARD = ENSAVECLIPBOARD; + PENSAVECLIPBOARD = ^ENSAVECLIPBOARD; + + ENOLEOPFAILED = record + nmhdr : NMHDR; + iob : LONG; + lOper : LONG; + hr : HRESULT; + end; + TENOLEOPFAILED = ENOLEOPFAILED; + PENOLEOPFAILED = ^ENOLEOPFAILED; + + ENHMETAHEADER = record + iType : DWORD; + nSize : DWORD; + rclBounds : RECTL; + rclFrame : RECTL; + dSignature : DWORD; + nVersion : DWORD; + nBytes : DWORD; + nRecords : DWORD; + nHandles : WORD; + sReserved : WORD; + nDescription : DWORD; + offDescription : DWORD; + nPalEntries : DWORD; + szlDevice : SIZEL; + szlMillimeters : SIZEL; + end; + LPENHMETAHEADER = ^ENHMETAHEADER; + tagENHMETAHEADER = ENHMETAHEADER; + TENHMETAHEADER = ENHMETAHEADER; + PENHMETAHEADER = ^ENHMETAHEADER; + + ENHMETARECORD = record + iType : DWORD; + nSize : DWORD; + dParm : array[0..0] of DWORD; + end; + LPENHMETARECORD = ^ENHMETARECORD; + tagENHMETARECORD = ENHMETARECORD; + TENHMETARECORD = ENHMETARECORD; + PENHMETARECORD = ^ENHMETARECORD; + + ENPROTECTED = record + nmhdr : NMHDR; + msg : UINT; + wParam : WPARAM; + lParam : LPARAM; + chrg : CHARRANGE; + end; + _enprotected = ENPROTECTED; + Tenprotected = ENPROTECTED; + Penprotected = ^ENPROTECTED; + + SERVICE_STATUS = record + dwServiceType : DWORD; + dwCurrentState : DWORD; + dwControlsAccepted : DWORD; + dwWin32ExitCode : DWORD; + dwServiceSpecificExitCode : DWORD; + dwCheckPoint : DWORD; + dwWaitHint : DWORD; + end; + LPSERVICE_STATUS = ^SERVICE_STATUS; + _SERVICE_STATUS = SERVICE_STATUS; + TSERVICESTATUS = SERVICE_STATUS; + PSERVICESTATUS = ^SERVICE_STATUS; + + ENUM_SERVICE_STATUS = record + lpServiceName : LPTSTR; + lpDisplayName : LPTSTR; + ServiceStatus : SERVICE_STATUS; + end; + LPENUM_SERVICE_STATUS = ^ENUM_SERVICE_STATUS; + _ENUM_SERVICE_STATUS = ENUM_SERVICE_STATUS; + TENUMSERVICESTATUS = ENUM_SERVICE_STATUS; + PENUMSERVICESTATUS = ^ENUM_SERVICE_STATUS; + + ENUMLOGFONT = record + elfLogFont : LOGFONT; + elfFullName : array[0..(LF_FULLFACESIZE)-1] of BCHAR; + elfStyle : array[0..(LF_FACESIZE)-1] of BCHAR; + end; + tagENUMLOGFONT = ENUMLOGFONT; + TENUMLOGFONT = ENUMLOGFONT; + PENUMLOGFONT = ^ENUMLOGFONT; + + ENUMLOGFONTEX = record + elfLogFont : LOGFONT; + elfFullName : array[0..(LF_FULLFACESIZE)-1] of BCHAR; + elfStyle : array[0..(LF_FACESIZE)-1] of BCHAR; + elfScript : array[0..(LF_FACESIZE)-1] of BCHAR; + end; + tagENUMLOGFONTEX = ENUMLOGFONTEX; + TENUMLOGFONTEX = ENUMLOGFONTEX; + PENUMLOGFONTEX = ^ENUMLOGFONTEX; + { + Then follow: + + TCHAR SourceName[] + TCHAR Computername[] + SID UserSid + TCHAR Strings[] + BYTE Data[] + CHAR Pad[] + DWORD Length; + } + + EVENTLOGRECORD = record + Length : DWORD; + Reserved : DWORD; + RecordNumber : DWORD; + TimeGenerated : DWORD; + TimeWritten : DWORD; + EventID : DWORD; + EventType : WORD; + NumStrings : WORD; + EventCategory : WORD; + ReservedFlags : WORD; + ClosingRecordNumber : DWORD; + StringOffset : DWORD; + UserSidLength : DWORD; + UserSidOffset : DWORD; + DataLength : DWORD; + DataOffset : DWORD; + end; + _EVENTLOGRECORD = EVENTLOGRECORD; + TEVENTLOGRECORD = EVENTLOGRECORD; + PEVENTLOGRECORD = ^EVENTLOGRECORD; + + EVENTMSG = record + message : UINT; + paramL : UINT; + paramH : UINT; + time : DWORD; + hwnd : HWND; + end; + tagEVENTMSG = EVENTMSG; + TEVENTMSG = EVENTMSG; + PEVENTMSG = ^EVENTMSG; + + EXCEPTION_POINTERS = record //winnt + ExceptionRecord : PEXCEPTION_RECORD; + ContextRecord : PCONTEXT; + end; + LPEXCEPTION_POINTERS = ^EXCEPTION_POINTERS; + PEXCEPTION_POINTERS = ^EXCEPTION_POINTERS; + _EXCEPTION_POINTERS = EXCEPTION_POINTERS; + TEXCEPTIONPOINTERS = EXCEPTION_POINTERS; + PEXCEPTIONPOINTERS = ^EXCEPTION_POINTERS; + + EXT_BUTTON = record + idCommand : WORD; + idsHelp : WORD; + fsStyle : WORD; + end; + LPEXT_BUTTON = ^EXT_BUTTON; + _EXT_BUTTON = EXT_BUTTON; + TEXTBUTTON = EXT_BUTTON; + PEXTBUTTON = ^EXT_BUTTON; + + FILTERKEYS = record + cbSize : UINT; + dwFlags : DWORD; + iWaitMSec : DWORD; + iDelayMSec : DWORD; + iRepeatMSec : DWORD; + iBounceMSec : DWORD; + end; + tagFILTERKEYS = FILTERKEYS; + TFILTERKEYS = FILTERKEYS; + PFILTERKEYS = ^FILTERKEYS; + + FIND_NAME_BUFFER = record + length : UCHAR; + access_control : UCHAR; + frame_control : UCHAR; + destination_addr : array[0..5] of UCHAR; + source_addr : array[0..5] of UCHAR; + routing_info : array[0..17] of UCHAR; + end; + _FIND_NAME_BUFFER = FIND_NAME_BUFFER; + TFINDNAMEBUFFER = FIND_NAME_BUFFER; + PFINDNAMEBUFFER = ^FIND_NAME_BUFFER; + + FIND_NAME_HEADER = record + node_count : WORD; + reserved : UCHAR; + unique_group : UCHAR; + end; + _FIND_NAME_HEADER = FIND_NAME_HEADER; + TFINDNAMEHEADER = FIND_NAME_HEADER; + PFINDNAMEHEADER = ^FIND_NAME_HEADER; + + FINDREPLACE = record + lStructSize : DWORD; + hwndOwner : HWND; + hInstance : HINST; + Flags : DWORD; + lpstrFindWhat : LPTSTR; + lpstrReplaceWith : LPTSTR; + wFindWhatLen : WORD; + wReplaceWithLen : WORD; + lCustData : LPARAM; + lpfnHook : LPFRHOOKPROC; + lpTemplateName : LPCTSTR; + end; + LPFINDREPLACE = ^FINDREPLACE; + TFINDREPLACE = FINDREPLACE; + PFINDREPLACE = ^FINDREPLACE; + + {FINDTEXT = record conflicts with FindText function } + TFINDTEXT = record + chrg : CHARRANGE; + lpstrText : LPSTR; + end; + _findtext = TFINDTEXT; + Pfindtext = ^TFINDTEXT; + + FINDTEXTEX = record + chrg : CHARRANGE; + lpstrText : LPSTR; + chrgText : CHARRANGE; + end; + _findtextex = FINDTEXTEX; + Tfindtextex = FINDTEXTEX; + Pfindtextex = ^FINDTEXTEX; + + FMS_GETDRIVEINFO = record + dwTotalSpace : DWORD; + dwFreeSpace : DWORD; + szPath : array[0..259] of TCHAR; + szVolume : array[0..13] of TCHAR; + szShare : array[0..127] of TCHAR; + end; + _FMS_GETDRIVEINFO = FMS_GETDRIVEINFO; + TFMSGETDRIVEINFO = FMS_GETDRIVEINFO; + PFMSGETDRIVEINFO = ^FMS_GETDRIVEINFO; + + FMS_GETFILESEL = record + ftTime : FILETIME; + dwSize : DWORD; + bAttr : BYTE; + szName : array[0..259] of TCHAR; + end; + _FMS_GETFILESEL = FMS_GETFILESEL; + TFMSGETFILESEL = FMS_GETFILESEL; + PFMSGETFILESEL = ^FMS_GETFILESEL; + + FMS_LOAD = record + dwSize : DWORD; + szMenuName : array[0..(MENU_TEXT_LEN)-1] of TCHAR; + hMenu : HMENU; + wMenuDelta : UINT; + end; + _FMS_LOAD = FMS_LOAD; + TFMSLOAD = FMS_LOAD; + PFMSLOAD = ^FMS_LOAD; + + FMS_TOOLBARLOAD = record + dwSize : DWORD; + lpButtons : LPEXT_BUTTON; + cButtons : WORD; + cBitmaps : WORD; + idBitmap : WORD; + hBitmap : HBITMAP; + end; + _FMS_TOOLBARLOAD = FMS_TOOLBARLOAD; + TFMSTOOLBARLOAD = FMS_TOOLBARLOAD; + PFMSTOOLBARLOAD = ^FMS_TOOLBARLOAD; + + FOCUS_EVENT_RECORD = record + bSetFocus : WINBOOL; + end; + _FOCUS_EVENT_RECORD = FOCUS_EVENT_RECORD; + TFOCUSEVENTRECORD = FOCUS_EVENT_RECORD; + PFOCUSEVENTRECORD = ^FOCUS_EVENT_RECORD; + + FORM_INFO_1 = record + Flags : DWORD; + pName : LPTSTR; + Size : SIZEL; + ImageableArea : RECTL; + end; + _FORM_INFO_1 = FORM_INFO_1; + TFORMINFO1 = FORM_INFO_1; + PFORMINFO1 = ^FORM_INFO_1; + + FORMAT_PARAMETERS = record + MediaType : MEDIA_TYPE; + StartCylinderNumber : DWORD; + EndCylinderNumber : DWORD; + StartHeadNumber : DWORD; + EndHeadNumber : DWORD; + end; + _FORMAT_PARAMETERS = FORMAT_PARAMETERS; + TFORMATPARAMETERS = FORMAT_PARAMETERS; + PFORMATPARAMETERS = ^FORMAT_PARAMETERS; + + FORMATRANGE = record + _hdc : HDC; + hdcTarget : HDC; + rc : RECT; + rcPage : RECT; + chrg : CHARRANGE; + end; + _formatrange = FORMATRANGE; + Tformatrange = FORMATRANGE; + Pformatrange = ^FORMATRANGE; + + GCP_RESULTS = record + lStructSize : DWORD; + lpOutString : LPTSTR; + lpOrder : ^UINT; + lpDx : ^WINT; + lpCaretPos : ^WINT; + lpClass : LPTSTR; + lpGlyphs : ^UINT; + nGlyphs : UINT; + nMaxFit : UINT; + end; + LPGCP_RESULTS = ^GCP_RESULTS; + tagGCP_RESULTS = GCP_RESULTS; + TGCPRESULTS = GCP_RESULTS; + PGCPRESULTS = ^GCP_RESULTS; +// +// Define the generic mapping array. This is used to denote the +// mapping of each generic access right to a specific access mask. +// + GENERIC_MAPPING = record //winnt + GenericRead : ACCESS_MASK; + GenericWrite : ACCESS_MASK; + GenericExecute : ACCESS_MASK; + GenericAll : ACCESS_MASK; + end; + PGENERIC_MAPPING = ^GENERIC_MAPPING; + _GENERIC_MAPPING = GENERIC_MAPPING; + TGENERICMAPPING = GENERIC_MAPPING; + PGENERICMAPPING = ^GENERIC_MAPPING; + + GLYPHMETRICS = record + gmBlackBoxX : UINT; + gmBlackBoxY : UINT; + gmptGlyphOrigin : POINT; + gmCellIncX : integer; + gmCellIncY : integer; + end; + LPGLYPHMETRICS = ^GLYPHMETRICS; + _GLYPHMETRICS = GLYPHMETRICS; + TGLYPHMETRICS = GLYPHMETRICS; + PGLYPHMETRICS = ^GLYPHMETRICS; + + HANDLETABLE = record + objectHandle : array[0..0] of HGDIOBJ; + end; + tagHANDLETABLE = HANDLETABLE; + THANDLETABLE = HANDLETABLE; + LPHANDLETABLE = ^HANDLETABLE; + + HD_HITTESTINFO = record + pt : POINT; + flags : UINT; + iItem : longint; + end; + _HD_HITTESTINFO = HD_HITTESTINFO; + THDHITTESTINFO = HD_HITTESTINFO; + PHDHITTESTINFO = ^HD_HITTESTINFO; + + HD_ITEM = record + mask : UINT; + cxy : longint; + pszText : LPTSTR; + hbm : HBITMAP; + cchTextMax : longint; + fmt : longint; + lParam : LPARAM; + end; + _HD_ITEM = HD_ITEM; + THDITEM = HD_ITEM; + PHDITEM = ^HD_ITEM; + + WINDOWPOS = record + _hwnd : HWND; + hwndInsertAfter : HWND; + x : longint; + y : longint; + cx : longint; + cy : longint; + flags : UINT; + end; + LPWINDOWPOS = ^WINDOWPOS; + _WINDOWPOS = WINDOWPOS; + TWINDOWPOS = WINDOWPOS; + PWINDOWPOS = ^WINDOWPOS; + + HD_LAYOUT = record + prc : ^RECT; + pwpos : ^WINDOWPOS; + end; + _HD_LAYOUT = HD_LAYOUT; + THDLAYOUT = HD_LAYOUT; + PHDLAYOUT = ^HD_LAYOUT; + + HD_NOTIFY = record + hdr : NMHDR; + iItem : longint; + iButton : longint; + pitem : ^HD_ITEM; + end; + _HD_NOTIFY = HD_NOTIFY; + THDNOTIFY = HD_NOTIFY; + PHDNOTIFY = ^HD_NOTIFY; + + HELPINFO = record + cbSize : UINT; + iContextType : longint; + iCtrlId : longint; + hItemHandle : HANDLE; + dwContextId : DWORD; + MousePos : POINT; + end; + LPHELPINFO = ^HELPINFO; + tagHELPINFO = HELPINFO; + THELPINFO = HELPINFO; + PHELPINFO = ^HELPINFO; + + HELPWININFO = record + wStructSize : longint; + x : longint; + y : longint; + dx : longint; + dy : longint; + wMax : longint; + rgchMember : array[0..1] of TCHAR; + end; + THELPWININFO = HELPWININFO; + PHELPWININFO = ^HELPWININFO; + + HIGHCONTRAST = record + cbSize : UINT; + dwFlags : DWORD; + lpszDefaultScheme : LPTSTR; + end; + LPHIGHCONTRAST = ^HIGHCONTRAST; + tagHIGHCONTRAST = HIGHCONTRAST; + THIGHCONTRAST = HIGHCONTRAST; + PHIGHCONTRAST = ^HIGHCONTRAST; + + HSZPAIR = record + hszSvc : HSZ; + hszTopic : HSZ; + end; + tagHSZPAIR = HSZPAIR; + THSZPAIR = HSZPAIR; + PHSZPAIR = ^HSZPAIR; + + ICONINFO = record + fIcon : WINBOOL; + xHotspot : DWORD; + yHotspot : DWORD; + hbmMask : HBITMAP; + hbmColor : HBITMAP; + end; + _ICONINFO = ICONINFO; + TICONINFO = ICONINFO; + PICONINFO = ^ICONINFO; + + ICONMETRICS = record + cbSize : UINT; + iHorzSpacing : longint; + iVertSpacing : longint; + iTitleWrap : longint; + lfFont : LOGFONT; + end; + LPICONMETRICS = ^ICONMETRICS; + tagICONMETRICS = ICONMETRICS; + TICONMETRICS = ICONMETRICS; + PICONMETRICS = ^ICONMETRICS; + + IMAGEINFO = record + hbmImage : HBITMAP; + hbmMask : HBITMAP; + Unused1 : longint; + Unused2 : longint; + rcImage : RECT; + end; + _IMAGEINFO = IMAGEINFO; + TIMAGEINFO = IMAGEINFO; + PIMAGEINFO = ^IMAGEINFO; + + KEY_EVENT_RECORD = packed record + bKeyDown : WINBOOL; + wRepeatCount : WORD; + wVirtualKeyCode : WORD; + wVirtualScanCode : WORD; + case longint of + 0 : ( UnicodeChar : WCHAR; + dwControlKeyState : DWORD; ); + 1 : ( AsciiChar : CHAR ); + end; + _KEY_EVENT_RECORD = KEY_EVENT_RECORD; + TKEYEVENTRECORD = KEY_EVENT_RECORD; + PKEYEVENTRECORD = ^KEY_EVENT_RECORD; + + MOUSE_EVENT_RECORD = record + dwMousePosition : COORD; + dwButtonState : DWORD; + dwControlKeyState : DWORD; + dwEventFlags : DWORD; + end; + _MOUSE_EVENT_RECORD = MOUSE_EVENT_RECORD; + TMOUSEEVENTRECORD = MOUSE_EVENT_RECORD; + PMOUSEEVENTRECORD = ^MOUSE_EVENT_RECORD; + + WINDOW_BUFFER_SIZE_RECORD = record + dwSize : COORD; + end; + _WINDOW_BUFFER_SIZE_RECORD = WINDOW_BUFFER_SIZE_RECORD; + TWINDOWBUFFERSIZERECORD = WINDOW_BUFFER_SIZE_RECORD; + PWINDOWBUFFERSIZERECORD = ^WINDOW_BUFFER_SIZE_RECORD; + + MENU_EVENT_RECORD = record + dwCommandId : UINT; + end; + PMENU_EVENT_RECORD = ^MENU_EVENT_RECORD; + _MENU_EVENT_RECORD = MENU_EVENT_RECORD; + TMENUEVENTRECORD = MENU_EVENT_RECORD; + PMENUEVENTRECORD = ^MENU_EVENT_RECORD; + + INPUT_RECORD = record + EventType: Word; + Reserved: Word; + Event : record case longint of + 0 : ( KeyEvent : KEY_EVENT_RECORD ); + 1 : ( MouseEvent : MOUSE_EVENT_RECORD ); + 2 : ( WindowBufferSizeEvent : WINDOW_BUFFER_SIZE_RECORD ); + 3 : ( MenuEvent : MENU_EVENT_RECORD ); + 4 : ( FocusEvent : FOCUS_EVENT_RECORD ); + end; + end; + PINPUT_RECORD = ^INPUT_RECORD; + _INPUT_RECORD = INPUT_RECORD; + TINPUTRECORD = INPUT_RECORD; + PINPUTRECORD = ^INPUT_RECORD; + + SYSTEMTIME = record + case integer of + 1 : ( + wYear : WORD; + wMonth : WORD; + wDayOfWeek : WORD; + wDay : WORD; + wHour : WORD; + wMinute : WORD; + wSecond : WORD; + wMilliseconds : WORD; + ); + { Compatibility for FPC } + 2 : ( + Year : WORD; + Month : WORD; + DayOfWeek : WORD; + Day : WORD; + Hour : WORD; + Minute : WORD; + Second : WORD; + Millisecond : WORD; + ); + end; + LPSYSTEMTIME = ^SYSTEMTIME; + _SYSTEMTIME = SYSTEMTIME; + TSYSTEMTIME = SYSTEMTIME; + PSYSTEMTIME = ^SYSTEMTIME; + + JOB_INFO_1 = record + JobId : DWORD; + pPrinterName : LPTSTR; + pMachineName : LPTSTR; + pUserName : LPTSTR; + pDocument : LPTSTR; + pDatatype : LPTSTR; + pStatus : LPTSTR; + Status : DWORD; + Priority : DWORD; + Position : DWORD; + TotalPages : DWORD; + PagesPrinted : DWORD; + Submitted : SYSTEMTIME; + end; + _JOB_INFO_1 = JOB_INFO_1; + TJOBINFO1 = JOB_INFO_1; + PJOBINFO1 = ^JOB_INFO_1; + + SID_AND_ATTRIBUTES = record //~winnt, moved with SID declarations + Sid : PSID; + Attributes : DWORD; + end; + _SID_AND_ATTRIBUTES = SID_AND_ATTRIBUTES; + TSIDANDATTRIBUTES = SID_AND_ATTRIBUTES; + PSIDANDATTRIBUTES = ^SID_AND_ATTRIBUTES; + + SID_AND_ATTRIBUTES_ARRAY = array[0..(ANYSIZE_ARRAY)-1] of SID_AND_ATTRIBUTES; //winnt + PSID_AND_ATTRIBUTES_ARRAY = ^SID_AND_ATTRIBUTES_ARRAY; + TSIDANDATTRIBUTESARRAY = SID_AND_ATTRIBUTES_ARRAY; + PSIDANDATTRIBUTESARRAY = ^SID_AND_ATTRIBUTES_ARRAY; + + SECURITY_DESCRIPTOR_CONTROL = WORD; + PSECURITY_DESCRIPTOR_CONTROL = ^SECURITY_DESCRIPTOR_CONTROL; + TSECURITYDESCRIPTORCONTROL = SECURITY_DESCRIPTOR_CONTROL; + PSECURITYDESCRIPTORCONTROL = ^SECURITY_DESCRIPTOR_CONTROL; + + SECURITY_DESCRIPTOR = record + Revision : BYTE; + Sbz1 : BYTE; + Control : SECURITY_DESCRIPTOR_CONTROL; + Owner : PSID; + Group : PSID; + Sacl : PACL; + Dacl : PACL; + end; + PSECURITY_DESCRIPTOR = ^SECURITY_DESCRIPTOR; + _SECURITY_DESCRIPTOR = SECURITY_DESCRIPTOR; + TSECURITYDESCRIPTOR = SECURITY_DESCRIPTOR; + PSECURITYDESCRIPTOR = ^SECURITY_DESCRIPTOR; + + JOB_INFO_2 = record + JobId : DWORD; + pPrinterName : LPTSTR; + pMachineName : LPTSTR; + pUserName : LPTSTR; + pDocument : LPTSTR; + pNotifyName : LPTSTR; + pDatatype : LPTSTR; + pPrintProcessor : LPTSTR; + pParameters : LPTSTR; + pDriverName : LPTSTR; + pDevMode : LPDEVMODE; + pStatus : LPTSTR; + pSecurityDescriptor : PSECURITY_DESCRIPTOR; + Status : DWORD; + Priority : DWORD; + Position : DWORD; + StartTime : DWORD; + UntilTime : DWORD; + TotalPages : DWORD; + Size : DWORD; + Submitted : SYSTEMTIME; + Time : DWORD; + PagesPrinted : DWORD; + end; + _JOB_INFO_2 = JOB_INFO_2; + TJOBINFO2 = JOB_INFO_2; + PJOBINFO2 = ^JOB_INFO_2; + + KERNINGPAIR = record + wFirst : WORD; + wSecond : WORD; + iKernAmount : longint; + end; + LPKERNINGPAIR = ^KERNINGPAIR; + tagKERNINGPAIR = KERNINGPAIR; + TKERNINGPAIR = KERNINGPAIR; + PKERNINGPAIR = ^KERNINGPAIR; + + LANA_ENUM = record + length : UCHAR; + lana : array[0..(MAX_LANA)-1] of UCHAR; + end; + _LANA_ENUM = LANA_ENUM; + TLANAENUM = LANA_ENUM; + PLANAENUM = ^LANA_ENUM; + const + bm_LDT_ENTRY_BaseMid = $FF; + bp_LDT_ENTRY_BaseMid = 0; + bm_LDT_ENTRY_Type = $1F00; + bp_LDT_ENTRY_Type = 8; + bm_LDT_ENTRY_Dpl = $6000; + bp_LDT_ENTRY_Dpl = 13; + bm_LDT_ENTRY_Pres = $8000; + bp_LDT_ENTRY_Pres = 15; + bm_LDT_ENTRY_LimitHi = $F0000; + bp_LDT_ENTRY_LimitHi = 16; + bm_LDT_ENTRY_Sys = $100000; + bp_LDT_ENTRY_Sys = 20; + bm_LDT_ENTRY_Reserved_0 = $200000; + bp_LDT_ENTRY_Reserved_0 = 21; + bm_LDT_ENTRY_Default_Big = $400000; + bp_LDT_ENTRY_Default_Big = 22; + bm_LDT_ENTRY_Granularity = $800000; + bp_LDT_ENTRY_Granularity = 23; + bm_LDT_ENTRY_BaseHi = $FF000000; + bp_LDT_ENTRY_BaseHi = 24; + + type + + LOCALESIGNATURE = record + lsUsb : array[0..3] of DWORD; + lsCsbDefault : array[0..1] of DWORD; + lsCsbSupported : array[0..1] of DWORD; + end; + tagLOCALESIGNATURE = LOCALESIGNATURE; + TLOCALESIGNATURE = LOCALESIGNATURE; + PLOCALESIGNATURE = ^LOCALESIGNATURE; + + LOCALGROUP_MEMBERS_INFO_0 = record + lgrmi0_sid : PSID; + end; + _LOCALGROUP_MEMBERS_INFO_0 = LOCALGROUP_MEMBERS_INFO_0; + TLOCALGROUPMEMBERSINFO0 = LOCALGROUP_MEMBERS_INFO_0; + PLOCALGROUPMEMBERSINFO0 = ^LOCALGROUP_MEMBERS_INFO_0; + + LOCALGROUP_MEMBERS_INFO_3 = record + lgrmi3_domainandname : LPWSTR; + end; + _LOCALGROUP_MEMBERS_INFO_3 = LOCALGROUP_MEMBERS_INFO_3; + TLOCALGROUPMEMBERSINFO3 = LOCALGROUP_MEMBERS_INFO_3; + PLOCALGROUPMEMBERSINFO3 = ^LOCALGROUP_MEMBERS_INFO_3; + + FXPT16DOT16 = longint; + LPFXPT16DOT16 = ^FXPT16DOT16; + TFXPT16DOT16 = FXPT16DOT16; + PFXPT16DOT16 = ^FXPT16DOT16; + + LUID_AND_ATTRIBUTES = record //winnt + Luid : LUID; + Attributes : DWORD; + end; + _LUID_AND_ATTRIBUTES = LUID_AND_ATTRIBUTES; + TLUIDANDATTRIBUTES = LUID_AND_ATTRIBUTES; + PLUIDANDATTRIBUTES = ^LUID_AND_ATTRIBUTES; + + LUID_AND_ATTRIBUTES_ARRAY = array[0..(ANYSIZE_ARRAY)-1] of LUID_AND_ATTRIBUTES; + PLUID_AND_ATTRIBUTES_ARRAY = ^LUID_AND_ATTRIBUTES_ARRAY; + TLUIDANDATTRIBUTESARRAY = LUID_AND_ATTRIBUTES_ARRAY; + PLUIDANDATTRIBUTESARRAY = ^LUID_AND_ATTRIBUTES_ARRAY; + + LV_COLUMN = record + mask : UINT; + fmt : longint; + cx : longint; + pszText : LPTSTR; + cchTextMax : longint; + iSubItem : longint; + end; + _LV_COLUMN = LV_COLUMN; + TLVCOLUMN = LV_COLUMN; + PLVCOLUMN = ^LV_COLUMN; + + LV_ITEM = record + mask : UINT; + iItem : longint; + iSubItem : longint; + state : UINT; + stateMask : UINT; + pszText : LPTSTR; + cchTextMax : longint; + iImage : longint; + lParam : LPARAM; + end; + _LV_ITEM = LV_ITEM; + TLVITEM = LV_ITEM; + PLVITEM = ^LV_ITEM; + + LV_DISPINFO = record + hdr : NMHDR; + item : LV_ITEM; + end; + tagLV_DISPINFO = LV_DISPINFO; + TLVDISPINFO = LV_DISPINFO; + PLVDISPINFO = ^LV_DISPINFO; + + LV_FINDINFO = record + flags : UINT; + psz : LPCTSTR; + lParam : LPARAM; + pt : POINT; + vkDirection : UINT; + end; + _LV_FINDINFO = LV_FINDINFO; + TLVFINDINFO = LV_FINDINFO; + PLVFINDINFO = ^LV_FINDINFO; + + LV_HITTESTINFO = record + pt : POINT; + flags : UINT; + iItem : longint; + end; + _LV_HITTESTINFO = LV_HITTESTINFO; + TLVHITTESTINFO = LV_HITTESTINFO; + PLVHITTESTINFO = ^LV_HITTESTINFO; + + LV_KEYDOWN = record + hdr : NMHDR; + wVKey : WORD; + flags : UINT; + end; + tagLV_KEYDOWN = LV_KEYDOWN; + TLVKEYDOWN = LV_KEYDOWN; + PLVKEYDOWN = ^LV_KEYDOWN; + + MAT2 = record + eM11 : FIXED; + eM12 : FIXED; + eM21 : FIXED; + eM22 : FIXED; + end; + _MAT2 = MAT2; + TMAT2 = MAT2; + PMAT2 = ^MAT2; + + MDICREATESTRUCT = record + szClass : LPCTSTR; + szTitle : LPCTSTR; + hOwner : HANDLE; + x : longint; + y : longint; + cx : longint; + cy : longint; + style : DWORD; + lParam : LPARAM; + end; + LPMDICREATESTRUCT = ^MDICREATESTRUCT; + tagMDICREATESTRUCT = MDICREATESTRUCT; + TMDICREATESTRUCT = MDICREATESTRUCT; + PMDICREATESTRUCT = ^MDICREATESTRUCT; + + MEASUREITEMSTRUCT = record + CtlType : UINT; + CtlID : UINT; + itemID : UINT; + itemWidth : UINT; + itemHeight : UINT; + itemData : DWORD; + end; + LPMEASUREITEMSTRUCT = ^MEASUREITEMSTRUCT; + tagMEASUREITEMSTRUCT = MEASUREITEMSTRUCT; + TMEASUREITEMSTRUCT = MEASUREITEMSTRUCT; + PMEASUREITEMSTRUCT = ^MEASUREITEMSTRUCT; + + MEMORY_BASIC_INFORMATION = record + BaseAddress : PVOID; + AllocationBase : PVOID; + AllocationProtect : DWORD; + RegionSize : DWORD; + State : DWORD; + Protect : DWORD; + _Type : DWORD; + end; + PMEMORY_BASIC_INFORMATION = ^MEMORY_BASIC_INFORMATION; + _MEMORY_BASIC_INFORMATION = MEMORY_BASIC_INFORMATION; + TMEMORYBASICINFORMATION = MEMORY_BASIC_INFORMATION; + PMEMORYBASICINFORMATION = ^MEMORY_BASIC_INFORMATION; + + MEMORYSTATUS = record + dwLength : DWORD; + dwMemoryLoad : DWORD; + dwTotalPhys : DWORD; + dwAvailPhys : DWORD; + dwTotalPageFile : DWORD; + dwAvailPageFile : DWORD; + dwTotalVirtual : DWORD; + dwAvailVirtual : DWORD; + end; + LPMEMORYSTATUS = ^MEMORYSTATUS; + _MEMORYSTATUS = MEMORYSTATUS; + TMEMORYSTATUS = MEMORYSTATUS; + PMEMORYSTATUS = ^MEMORYSTATUS; + + MENUEX_TEMPLATE_HEADER = record + wVersion : WORD; + wOffset : WORD; + dwHelpId : DWORD; + end; + TMENUXTEMPLATEHEADER = MENUEX_TEMPLATE_HEADER; + PMENUXTEMPLATEHEADER = ^MENUEX_TEMPLATE_HEADER; + + MENUEX_TEMPLATE_ITEM = record + dwType : DWORD; + dwState : DWORD; + uId : UINT; + bResInfo : BYTE; + szText : array[0..0] of WCHAR; + dwHelpId : DWORD; + end; + TMENUEXTEMPLATEITEM = MENUEX_TEMPLATE_ITEM; + PMENUEXTEMPLATEITEM = ^MENUEX_TEMPLATE_ITEM; + + MENUITEMINFO = record + cbSize : UINT; + fMask : UINT; + fType : UINT; + fState : UINT; + wID : UINT; + hSubMenu : HMENU; + hbmpChecked : HBITMAP; + hbmpUnchecked : HBITMAP; + dwItemData : DWORD; + dwTypeData : LPTSTR; + cch : UINT; + end; + LPMENUITEMINFO = ^MENUITEMINFO; + LPCMENUITEMINFO = ^MENUITEMINFO; + tagMENUITEMINFO = MENUITEMINFO; + TMENUITEMINFO = MENUITEMINFO; + TMENUITEMINFOA = MENUITEMINFO; + PMENUITEMINFO = ^MENUITEMINFO; + + MENUITEMTEMPLATE = record + mtOption : WORD; + mtID : WORD; + mtString : array[0..0] of WCHAR; + end; + TMENUITEMTEMPLATE = MENUITEMTEMPLATE; + PMENUITEMTEMPLATE = ^MENUITEMTEMPLATE; + + MENUITEMTEMPLATEHEADER = record + versionNumber : WORD; + offset : WORD; + end; + TMENUITEMTEMPLATEHEADER = MENUITEMTEMPLATEHEADER; + PMENUITEMTEMPLATEHEADER = ^MENUITEMTEMPLATEHEADER; + + MENUTEMPLATE = record + end; + LPMENUTEMPLATE = ^MENUTEMPLATE; + TMENUTEMPLATE = MENUTEMPLATE; + PMENUTEMPLATE = ^MENUTEMPLATE; + + METAFILEPICT = record + mm : LONG; + xExt : LONG; + yExt : LONG; + hMF : HMETAFILE; + end; + LPMETAFILEPICT = ^METAFILEPICT; + tagMETAFILEPICT = METAFILEPICT; + TMETAFILEPICT = METAFILEPICT; + PMETAFILEPICT = ^METAFILEPICT; + + METAHEADER = packed record + mtType : WORD; + mtHeaderSize : WORD; + mtVersion : WORD; + mtSize : DWORD; + mtNoObjects : WORD; + mtMaxRecord : DWORD; + mtNoParameters : WORD; + end; + tagMETAHEADER = METAHEADER; + TMETAHEADER = METAHEADER; + PMETAHEADER = ^METAHEADER; + + METARECORD = record + rdSize : DWORD; + rdFunction : WORD; + rdParm : array[0..0] of WORD; + end; + LPMETARECORD = ^METARECORD; + tagMETARECORD = METARECORD; + TMETARECORD = METARECORD; + PMETARECORD = ^METARECORD; + + MINIMIZEDMETRICS = record + cbSize : UINT; + iWidth : longint; + iHorzGap : longint; + iVertGap : longint; + iArrange : longint; + end; + LPMINIMIZEDMETRICS = ^MINIMIZEDMETRICS; + tagMINIMIZEDMETRICS = MINIMIZEDMETRICS; + TMINIMIZEDMETRICS = MINIMIZEDMETRICS; + PMINIMIZEDMETRICS = ^MINIMIZEDMETRICS; + + MINMAXINFO = record + ptReserved : POINT; + ptMaxSize : POINT; + ptMaxPosition : POINT; + ptMinTrackSize : POINT; + ptMaxTrackSize : POINT; + end; + tagMINMAXINFO = MINMAXINFO; + TMINMAXINFO = MINMAXINFO; + PMINMAXINFO = ^MINMAXINFO; + + MODEMDEVCAPS = record + dwActualSize : DWORD; + dwRequiredSize : DWORD; + dwDevSpecificOffset : DWORD; + dwDevSpecificSize : DWORD; + dwModemProviderVersion : DWORD; + dwModemManufacturerOffset : DWORD; + dwModemManufacturerSize : DWORD; + dwModemModelOffset : DWORD; + dwModemModelSize : DWORD; + dwModemVersionOffset : DWORD; + dwModemVersionSize : DWORD; + dwDialOptions : DWORD; + dwCallSetupFailTimer : DWORD; + dwInactivityTimeout : DWORD; + dwSpeakerVolume : DWORD; + dwSpeakerMode : DWORD; + dwModemOptions : DWORD; + dwMaxDTERate : DWORD; + dwMaxDCERate : DWORD; + abVariablePortion : array[0..0] of BYTE; + end; + LPMODEMDEVCAPS = ^MODEMDEVCAPS; + TMODEMDEVCAPS = MODEMDEVCAPS; + PMODEMDEVCAPS = ^MODEMDEVCAPS; + + modemdevcaps_tag = MODEMDEVCAPS; + + MODEMSETTINGS = record + dwActualSize : DWORD; + dwRequiredSize : DWORD; + dwDevSpecificOffset : DWORD; + dwDevSpecificSize : DWORD; + dwCallSetupFailTimer : DWORD; + dwInactivityTimeout : DWORD; + dwSpeakerVolume : DWORD; + dwSpeakerMode : DWORD; + dwPreferredModemOptions : DWORD; + dwNegotiatedModemOptions : DWORD; + dwNegotiatedDCERate : DWORD; + abVariablePortion : array[0..0] of BYTE; + end; + LPMODEMSETTINGS = ^MODEMSETTINGS; + TMODEMSETTINGS = MODEMSETTINGS; + PMODEMSETTINGS = ^MODEMSETTINGS; + + modemsettings_tag = MODEMSETTINGS; + + MONCBSTRUCT = record + cb : UINT; + dwTime : DWORD; + hTask : HANDLE; + dwRet : DWORD; + wType : UINT; + wFmt : UINT; + hConv : HCONV; + hsz1 : HSZ; + hsz2 : HSZ; + hData : HDDEDATA; + dwData1 : DWORD; + dwData2 : DWORD; + cc : CONVCONTEXT; + cbData : DWORD; + Data : array[0..7] of DWORD; + end; + tagMONCBSTRUCT = MONCBSTRUCT; + TMONCBSTRUCT = MONCBSTRUCT; + PMONCBSTRUCT = ^MONCBSTRUCT; + + MONCONVSTRUCT = record + cb : UINT; + fConnect : WINBOOL; + dwTime : DWORD; + hTask : HANDLE; + hszSvc : HSZ; + hszTopic : HSZ; + hConvClient : HCONV; + hConvServer : HCONV; + end; + tagMONCONVSTRUCT = MONCONVSTRUCT; + TMONCONVSTRUCT = MONCONVSTRUCT; + PMONCONVSTRUCT = ^MONCONVSTRUCT; + + MONERRSTRUCT = record + cb : UINT; + wLastError : UINT; + dwTime : DWORD; + hTask : HANDLE; + end; + tagMONERRSTRUCT = MONERRSTRUCT; + TMONERRSTRUCT = MONERRSTRUCT; + PMONERRSTRUCT = ^MONERRSTRUCT; + + MONHSZSTRUCT = record + cb : UINT; + fsAction : WINBOOL; + dwTime : DWORD; + hsz : HSZ; + hTask : HANDLE; + str : array[0..0] of TCHAR; + end; + tagMONHSZSTRUCT = MONHSZSTRUCT; + TMONHSZSTRUCT = MONHSZSTRUCT; + PMONHSZSTRUCT = ^MONHSZSTRUCT; + + MONITOR_INFO_1 = record + pName : LPTSTR; + end; + _MONITOR_INFO_1 = MONITOR_INFO_1; + TMONITORINFO1 = MONITOR_INFO_1; + PMONITORINFO1 = ^MONITOR_INFO_1; + + MONITOR_INFO_2 = record + pName : LPTSTR; + pEnvironment : LPTSTR; + pDLLName : LPTSTR; + end; + _MONITOR_INFO_2 = MONITOR_INFO_2; + TMONITORINFO2 = MONITOR_INFO_2; + PMONITORINFO2 = ^MONITOR_INFO_2; + + MONLINKSTRUCT = record + cb : UINT; + dwTime : DWORD; + hTask : HANDLE; + fEstablished : WINBOOL; + fNoData : WINBOOL; + hszSvc : HSZ; + hszTopic : HSZ; + hszItem : HSZ; + wFmt : UINT; + fServer : WINBOOL; + hConvServer : HCONV; + hConvClient : HCONV; + end; + tagMONLINKSTRUCT = MONLINKSTRUCT; + TMONLINKSTRUCT = MONLINKSTRUCT; + PMONLINKSTRUCT = ^MONLINKSTRUCT; + + MONMSGSTRUCT = record + cb : UINT; + hwndTo : HWND; + dwTime : DWORD; + hTask : HANDLE; + wMsg : UINT; + wParam : WPARAM; + lParam : LPARAM; + dmhd : DDEML_MSG_HOOK_DATA; + end; + tagMONMSGSTRUCT = MONMSGSTRUCT; + TMONMSGSTRUCT = MONMSGSTRUCT; + PMONMSGSTRUCT = ^MONMSGSTRUCT; + + MOUSEHOOKSTRUCT = record + pt : POINT; + hwnd : HWND; + wHitTestCode : UINT; + dwExtraInfo : DWORD; + end; + LPMOUSEHOOKSTRUCT = ^MOUSEHOOKSTRUCT; + tagMOUSEHOOKSTRUCT = MOUSEHOOKSTRUCT; + TMOUSEHOOKSTRUCT = MOUSEHOOKSTRUCT; + PMOUSEHOOKSTRUCT = ^MOUSEHOOKSTRUCT; + + MOUSEKEYS = record + cbSize : DWORD; + dwFlags : DWORD; + iMaxSpeed : DWORD; + iTimeToMaxSpeed : DWORD; + iCtrlSpeed : DWORD; + dwReserved1 : DWORD; + dwReserved2 : DWORD; + end; + TMOUSEKEYS = MOUSEKEYS; + PMOUSEKEYS = ^MOUSEKEYS; + + MSGBOXCALLBACK = procedure (lpHelpInfo:LPHELPINFO);stdcall; + TMSGBOXCALLBACK = MSGBOXCALLBACK; + + MSGBOXPARAMS = record + cbSize : UINT; + hwndOwner : HWND; + hInstance : HINST; + lpszText : LPCSTR; + lpszCaption : LPCSTR; + dwStyle : DWORD; + lpszIcon : LPCSTR; + dwContextHelpId : DWORD; + lpfnMsgBoxCallback : MSGBOXCALLBACK; + dwLanguageId : DWORD; + end; + LPMSGBOXPARAMS = ^MSGBOXPARAMS; + TMSGBOXPARAMS = MSGBOXPARAMS; + TMSGBOXPARAMSA = MSGBOXPARAMS; + PMSGBOXPARAMS = ^MSGBOXPARAMS; + + MSGFILTER = record + nmhdr : NMHDR; + msg : UINT; + wParam : WPARAM; + lParam : LPARAM; + end; + _msgfilter = MSGFILTER; + Tmsgfilter = MSGFILTER; + Pmsgfilter = ^MSGFILTER; + + MULTIKEYHELP = record + mkSize : DWORD; + mkKeylist : TCHAR; + szKeyphrase : array[0..0] of TCHAR; + end; + tagMULTIKEYHELP = MULTIKEYHELP; + TMULTIKEYHELP = MULTIKEYHELP; + PMULTIKEYHELP = ^MULTIKEYHELP; + + EXTENDED_NAME_FORMAT=( + // unknown name type + NameUnknown = 0, + // CN=Spencer Katt, OU=Software, OU=Engineering, O=Widget, C=US + NameFullyQualifiedDN = 1, + // Engineering\SpencerK + NameSamCompatible = 2, + // Probably "Spencer Katt" but could be something else. I.e. The + // display name is not necessarily the defining RDN. + NameDisplay = 3, + // xxx@engineering.widget.com where xxx could be "SpencerK" or + // anything else. Could be multi-valued to handle migration and aliasing. + NameDomainSimple = 4, + // xxx@widget.com where xxx could be "SpencerK" or anything else. + // Could be multi-valued to handle migration and aliasing. + NameEnterpriseSimple = 5, + // String-ized GUID as returned by IIDFromString(). + // eg: {4fa050f0-f561-11cf-bdd9-00aa003a77b6} + NameUniqueId = 6, + // engineering.widget.com/software/spencer katt + NameCanonical = 7, + // local logon name + NameWindowsCeLocal = $80000001); //+winbase + PEXTENDED_NAME_FORMAT=^EXTENDED_NAME_FORMAT; //+winbase + + NAME_BUFFER = record + name : array[0..(NCBNAMSZ)-1] of UCHAR; + name_num : UCHAR; + name_flags : UCHAR; + end; + _NAME_BUFFER = NAME_BUFFER; + TNAMEBUFFER = NAME_BUFFER; + PNAMEBUFFER = ^NAME_BUFFER; + + p_NCB = ^_NCB; + NCB = record + ncb_command : UCHAR; + ncb_retcode : UCHAR; + ncb_lsn : UCHAR; + ncb_num : UCHAR; + ncb_buffer : PUCHAR; + ncb_length : WORD; + ncb_callname : array[0..(NCBNAMSZ)-1] of UCHAR; + ncb_name : array[0..(NCBNAMSZ)-1] of UCHAR; + ncb_rto : UCHAR; + ncb_sto : UCHAR; + ncb_post : procedure (_para1:p_NCB);CDECL; + ncb_lana_num : UCHAR; + ncb_cmd_cplt : UCHAR; + ncb_reserve : array[0..9] of UCHAR; + ncb_event : HANDLE; + end; + _NCB = NCB; + TNCB = NCB; + PNCB = ^NCB; + + NCCALCSIZE_PARAMS = record + rgrc : array[0..2] of RECT; + lppos : PWINDOWPOS; + end; + _NCCALCSIZE_PARAMS = NCCALCSIZE_PARAMS; + TNCCALCSIZEPARAMS = NCCALCSIZE_PARAMS; + PNCCALCSIZEPARAMS = ^NCCALCSIZE_PARAMS; + + NDDESHAREINFO = record + lRevision : LONG; + lpszShareName : LPTSTR; + lShareType : LONG; + lpszAppTopicList : LPTSTR; + fSharedFlag : LONG; + fService : LONG; + fStartAppFlag : LONG; + nCmdShow : LONG; + qModifyId : array[0..1] of LONG; + cNumItems : LONG; + lpszItemList : LPTSTR; + end; + _NDDESHAREINFO = NDDESHAREINFO; + TNDDESHAREINFO = NDDESHAREINFO; + PNDDESHAREINFO = ^NDDESHAREINFO; + + NETRESOURCE = record + dwScope : DWORD; + dwType : DWORD; + dwDisplayType : DWORD; + dwUsage : DWORD; + lpLocalName : LPTSTR; + lpRemoteName : LPTSTR; + lpComment : LPTSTR; + lpProvider : LPTSTR; + end; + LPNETRESOURCE = ^NETRESOURCE; + _NETRESOURCE = NETRESOURCE; + TNETRESOURCE = NETRESOURCE; + TNETRESOURCEA = NETRESOURCE; + PNETRESOURCE = ^NETRESOURCE; + PNETRESOURCEA = ^NETRESOURCE; + + NETRESOURCEW = record //+winnetwk + dwScope : DWORD; + dwType : DWORD; + dwDisplayType : DWORD; + dwUsage : DWORD; + lpLocalName : LPWSTR; + lpRemoteName : LPWSTR; + lpComment : LPWSTR; + lpProvider : LPWSTR; + end; + LPNETRESOURCEW = ^NETRESOURCEW; //+winnetwk + _NETRESOURCEW = NETRESOURCEW; //+winnetwk + + NEWCPLINFO = record + dwSize : DWORD; + dwFlags : DWORD; + dwHelpContext : DWORD; + lData : LONG; + hIcon : HICON; + szName : array[0..31] of TCHAR; + szInfo : array[0..63] of TCHAR; + szHelpFile : array[0..127] of TCHAR; + end; + tagNEWCPLINFO = NEWCPLINFO; + TNEWCPLINFO = NEWCPLINFO; + PNEWCPLINFO = ^NEWCPLINFO; + + NEWTEXTMETRIC = record + tmHeight : LONG; + tmAscent : LONG; + tmDescent : LONG; + tmInternalLeading : LONG; + tmExternalLeading : LONG; + tmAveCharWidth : LONG; + tmMaxCharWidth : LONG; + tmWeight : LONG; + tmOverhang : LONG; + tmDigitizedAspectX : LONG; + tmDigitizedAspectY : LONG; + tmFirstChar : BCHAR; + tmLastChar : BCHAR; + tmDefaultChar : BCHAR; + tmBreakChar : BCHAR; + tmItalic : BYTE; + tmUnderlined : BYTE; + tmStruckOut : BYTE; + tmPitchAndFamily : BYTE; + tmCharSet : BYTE; + ntmFlags : DWORD; + ntmSizeEM : UINT; + ntmCellHeight : UINT; + ntmAvgWidth : UINT; + end; + tagNEWTEXTMETRIC = NEWTEXTMETRIC; + TNEWTEXTMETRIC = NEWTEXTMETRIC; + PNEWTEXTMETRIC = ^NEWTEXTMETRIC; + + NEWTEXTMETRICEX = record + ntmentm : NEWTEXTMETRIC; + ntmeFontSignature : FONTSIGNATURE; + end; + tagNEWTEXTMETRICEX = NEWTEXTMETRICEX; + TNEWTEXTMETRICEX = NEWTEXTMETRICEX; + PNEWTEXTMETRICEX = ^NEWTEXTMETRICEX; + + NM_LISTVIEW = record + hdr : NMHDR; + iItem : longint; + iSubItem : longint; + uNewState : UINT; + uOldState : UINT; + uChanged : UINT; + ptAction : POINT; + lParam : LPARAM; + end; + tagNM_LISTVIEW = NM_LISTVIEW; + TNMLISTVIEW = NM_LISTVIEW; + PNMLISTVIEW = ^NM_LISTVIEW; + + TV_ITEM = record + mask : UINT; + hItem : HTREEITEM; + state : UINT; + stateMask : UINT; + pszText : LPTSTR; + cchTextMax : longint; + iImage : longint; + iSelectedImage : longint; + cChildren : longint; + lParam : LPARAM; + end; + LPTV_ITEM = ^TV_ITEM; + _TV_ITEM = TV_ITEM; + TTVITEM = TV_ITEM; + PTVITEM = ^TV_ITEM; + + NM_TREEVIEW = record + hdr : NMHDR; + action : UINT; + itemOld : TV_ITEM; + itemNew : TV_ITEM; + ptDrag : POINT; + end; + LPNM_TREEVIEW = ^NM_TREEVIEW; + _NM_TREEVIEW = NM_TREEVIEW; + TNMTREEVIEW = NM_TREEVIEW; + PNMTREEVIEW = ^NM_TREEVIEW; + + NM_UPDOWNW = record + hdr : NMHDR; + iPos : longint; + iDelta : longint; + end; + _NM_UPDOWN = NM_UPDOWNW; + TNMUPDOWN = NM_UPDOWNW; + PNMUPDOWN = ^NM_UPDOWNW; + + NONCLIENTMETRICS = record + cbSize : UINT; + iBorderWidth : longint; + iScrollWidth : longint; + iScrollHeight : longint; + iCaptionWidth : longint; + iCaptionHeight : longint; + lfCaptionFont : LOGFONT; + iSmCaptionWidth : longint; + iSmCaptionHeight : longint; + lfSmCaptionFont : LOGFONT; + iMenuWidth : longint; + iMenuHeight : longint; + lfMenuFont : LOGFONT; + lfStatusFont : LOGFONT; + lfMessageFont : LOGFONT; + end; + LPNONCLIENTMETRICS = ^NONCLIENTMETRICS; + tagNONCLIENTMETRICS = NONCLIENTMETRICS; + TNONCLIENTMETRICS = NONCLIENTMETRICS; + PNONCLIENTMETRICS = ^NONCLIENTMETRICS; + + SERVICE_ADDRESS = record + dwAddressType : DWORD; + dwAddressFlags : DWORD; + dwAddressLength : DWORD; + dwPrincipalLength : DWORD; + lpAddress : ^BYTE; + lpPrincipal : ^BYTE; + end; + _SERVICE_ADDRESS = SERVICE_ADDRESS; + TSERVICEADDRESS = SERVICE_ADDRESS; + PSERVICEADDRESS = ^SERVICE_ADDRESS; + + SERVICE_ADDRESSES = record + dwAddressCount : DWORD; + Addresses : array[0..0] of SERVICE_ADDRESS; + end; + LPSERVICE_ADDRESSES = ^SERVICE_ADDRESSES; + _SERVICE_ADDRESSES = SERVICE_ADDRESSES; + TSERVICEADDRESSES = SERVICE_ADDRESSES; + PSERVICEADDRESSES = ^SERVICE_ADDRESSES; + + GUID = system.tguid; //winnt + LPGUID = ^GUID; + _GUID = GUID; + TGUID = GUID; + PGUID = ^GUID; + + CLSID = GUID; + LPCLSID = ^CLSID; + TCLSID = CLSID; + PCLSID = ^CLSID; + + SERVICE_INFO = record + lpServiceType : LPGUID; + lpServiceName : LPTSTR; + lpComment : LPTSTR; + lpLocale : LPTSTR; + dwDisplayHint : DWORD; + dwVersion : DWORD; + dwTime : DWORD; + lpMachineName : LPTSTR; + lpServiceAddress : LPSERVICE_ADDRESSES; + ServiceSpecificInfo : BLOB; + end; + _SERVICE_INFO = SERVICE_INFO; + TSERVICEINFO = SERVICE_INFO; + PSERVICEINFO = ^SERVICE_INFO; + + NS_SERVICE_INFO = record + dwNameSpace : DWORD; + ServiceInfo : SERVICE_INFO; + end; + _NS_SERVICE_INFO = NS_SERVICE_INFO; + TNSSERVICEINFO = NS_SERVICE_INFO; + PNSSERVICEINFO = ^NS_SERVICE_INFO; + + NUMBERFMT = record + NumDigits : UINT; + LeadingZero : UINT; + Grouping : UINT; + lpDecimalSep : LPTSTR; + lpThousandSep : LPTSTR; + NegativeOrder : UINT; + end; + _numberfmt = NUMBERFMT; + Tnumberfmt = NUMBERFMT; + Pnumberfmt = ^NUMBERFMT; + + OFSTRUCT = record + cBytes : BYTE; + fFixedDisk : BYTE; + nErrCode : WORD; + Reserved1 : WORD; + Reserved2 : WORD; + szPathName : array[0..(OFS_MAXPATHNAME)-1] of CHAR; + end; + LPOFSTRUCT = ^OFSTRUCT; + _OFSTRUCT = OFSTRUCT; + TOFSTRUCT = OFSTRUCT; + POFSTRUCT = ^OFSTRUCT; + + OPENFILENAME = record + lStructSize : DWORD; + hwndOwner : HWND; + hInstance : HINST; + lpstrFilter : LPCTSTR; + lpstrCustomFilter : LPTSTR; + nMaxCustFilter : DWORD; + nFilterIndex : DWORD; + lpstrFile : LPTSTR; + nMaxFile : DWORD; + lpstrFileTitle : LPTSTR; + nMaxFileTitle : DWORD; + lpstrInitialDir : LPCTSTR; + lpstrTitle : LPCTSTR; + Flags : DWORD; + nFileOffset : WORD; + nFileExtension : WORD; + lpstrDefExt : LPCTSTR; + lCustData : DWORD; + lpfnHook : LPOFNHOOKPROC; + lpTemplateName : LPCTSTR; + end; + LPOPENFILENAME = ^OPENFILENAME; + TOPENFILENAME = OPENFILENAME; + POPENFILENAME = ^OPENFILENAME; + + tagOFN = OPENFILENAME; + TOFN = OPENFILENAME; + POFN = ^OPENFILENAME; + + OPENFILENAMEW = record //+commdlg + lStructSize : DWORD; + hwndOwner : HWND; + hInstance : HINST; + lpstrFilter : LPCWSTR; + lpstrCustomFilter : LPWSTR; + nMaxCustFilter : DWORD; + nFilterIndex : DWORD; + lpstrFile : LPWSTR; + nMaxFile : DWORD; + lpstrFileTitle : LPWSTR; + nMaxFileTitle : DWORD; + lpstrInitialDir : LPCWSTR; + lpstrTitle : LPCWSTR; + Flags : DWORD; + nFileOffset : WORD; + nFileExtension : WORD; + lpstrDefExt : LPCWSTR; + lCustData : LPARAM; + lpfnHook : LPOFNHOOKPROC; + lpTemplateName : LPCWSTR; + end; + LPOPENFILENAMEW = ^OPENFILENAMEW; //+commdlg + tagOFNW = OPENFILENAMEW; //+commdlg + + OFNOTIFY = record + hdr : NMHDR; + lpOFN : LPOPENFILENAME; + pszFile : LPTSTR; + end; + LPOFNOTIFY = ^OFNOTIFY; + _OFNOTIFY = OFNOTIFY; + TOFNOTIFY = OFNOTIFY; + POFNOTIFY = ^OFNOTIFY; + + OSVERSIONINFO = record + dwOSVersionInfoSize : DWORD; + dwMajorVersion : DWORD; + dwMinorVersion : DWORD; + dwBuildNumber : DWORD; + dwPlatformId : DWORD; + szCSDVersion : array[0..127] of TCHAR; + end; + LPOSVERSIONINFO = ^OSVERSIONINFO; + _OSVERSIONINFO = OSVERSIONINFO; + TOSVERSIONINFO = OSVERSIONINFO; + POSVERSIONINFO = ^OSVERSIONINFO; + + OSVERSIONINFOW = record + dwOSVersionInfoSize : DWORD; + dwMajorVersion : DWORD; + dwMinorVersion : DWORD; + dwBuildNumber : DWORD; + dwPlatformId : DWORD; + szCSDVersion : array[0..127] of WCHAR; + end; + LPOSVERSIONINFOW = ^OSVERSIONINFOW; + _OSVERSIONINFOW = OSVERSIONINFOW; + TOSVERSIONINFOW = OSVERSIONINFOW; + POSVERSIONINFOW = ^OSVERSIONINFOW; + + + + + + TEXTMETRIC = record + tmHeight : LONG; + tmAscent : LONG; + tmDescent : LONG; + tmInternalLeading : LONG; + tmExternalLeading : LONG; + tmAveCharWidth : LONG; + tmMaxCharWidth : LONG; + tmWeight : LONG; + tmOverhang : LONG; + tmDigitizedAspectX : LONG; + tmDigitizedAspectY : LONG; + tmFirstChar : BCHAR; + tmLastChar : BCHAR; + tmDefaultChar : BCHAR; + tmBreakChar : BCHAR; + tmItalic : BYTE; + tmUnderlined : BYTE; + tmStruckOut : BYTE; + tmPitchAndFamily : BYTE; + tmCharSet : BYTE; + end; + LPTEXTMETRIC = ^TEXTMETRIC; + tagTEXTMETRIC = TEXTMETRIC; + TTEXTMETRIC = TEXTMETRIC; + PTEXTMETRIC = ^TEXTMETRIC; + + TEXTMETRICW = record + tmHeight : LONG; + tmAscent : LONG; + tmDescent : LONG; + tmInternalLeading : LONG; + tmExternalLeading : LONG; + tmAveCharWidth : LONG; + tmMaxCharWidth : LONG; + tmWeight : LONG; + tmOverhang : LONG; + tmDigitizedAspectX : LONG; + tmDigitizedAspectY : LONG; + tmFirstChar : WCHAR; + tmLastChar : WCHAR; + tmDefaultChar : WCHAR; + tmBreakChar : WCHAR; + tmItalic : BYTE; + tmUnderlined : BYTE; + tmStruckOut : BYTE; + tmPitchAndFamily : BYTE; + tmCharSet : BYTE; + end; + LPTEXTMETRICW = ^TEXTMETRICW; + tagTEXTMETRICW = TEXTMETRICW; + TTEXTMETRICW = TEXTMETRICW; + PTEXTMETRICW = ^TEXTMETRICW; + + + OUTLINETEXTMETRIC = record + otmSize : UINT; + otmTextMetrics : TEXTMETRIC; + otmFiller : BYTE; + otmPanoseNumber : PANOSE; + otmfsSelection : UINT; + otmfsType : UINT; + otmsCharSlopeRise : longint; + otmsCharSlopeRun : longint; + otmItalicAngle : longint; + otmEMSquare : UINT; + otmAscent : longint; + otmDescent : longint; + otmLineGap : UINT; + otmsCapEmHeight : UINT; + otmsXHeight : UINT; + otmrcFontBox : RECT; + otmMacAscent : longint; + otmMacDescent : longint; + otmMacLineGap : UINT; + otmusMinimumPPEM : UINT; + otmptSubscriptSize : POINT; + otmptSubscriptOffset : POINT; + otmptSuperscriptSize : POINT; + otmptSuperscriptOffset : POINT; + otmsStrikeoutSize : UINT; + otmsStrikeoutPosition : longint; + otmsUnderscoreSize : longint; + otmsUnderscorePosition : longint; + otmpFamilyName : PSTR; + otmpFaceName : PSTR; + otmpStyleName : PSTR; + otmpFullName : PSTR; + end; + LPOUTLINETEXTMETRIC = ^OUTLINETEXTMETRIC; + _OUTLINETEXTMETRIC = OUTLINETEXTMETRIC; + TOUTLINETEXTMETRIC = OUTLINETEXTMETRIC; + POUTLINETEXTMETRIC = ^OUTLINETEXTMETRIC; + + OVERLAPPED = record + Internal : DWORD; + InternalHigh : DWORD; + Offset : DWORD; + OffsetHigh : DWORD; + hEvent : HANDLE; + end; + LPOVERLAPPED = ^OVERLAPPED; + _OVERLAPPED = OVERLAPPED; + TOVERLAPPED = OVERLAPPED; + POVERLAPPED = ^OVERLAPPED; + + {PAGESETUPDLG = record conflicts with function PageSetupDlg } + TPAGESETUPDLG = record + lStructSize : DWORD; + hwndOwner : HWND; + hDevMode : HGLOBAL; + hDevNames : HGLOBAL; + Flags : DWORD; + ptPaperSize : POINT; + rtMinMargin : RECT; + rtMargin : RECT; + hInstance : HINST; + lCustData : LPARAM; + lpfnPageSetupHook : LPPAGESETUPHOOK; + lpfnPagePaintHook : LPPAGEPAINTHOOK; + lpPageSetupTemplateName : LPCTSTR; + hPageSetupTemplate : HGLOBAL; + end; + LPPAGESETUPDLG = ^TPAGESETUPDLG; + PPAGESETUPDLG = ^TPAGESETUPDLG; + + tagPSD = TPAGESETUPDLG; + TPSD = TPAGESETUPDLG; + PPSD = ^TPAGESETUPDLG; + + TPAGESETUPDLGW = record //+commdlg + lStructSize : DWORD; + hwndOwner : HWND; + hDevMode : HGLOBAL; + hDevNames : HGLOBAL; + Flags : DWORD; + ptPaperSize : POINT; // ignored in CE + rtMinMargin : RECT; + rtMargin : RECT; + hInstance : HINST; + lCustData : LPARAM; + lpfnPageSetupHook : LPPAGESETUPHOOK; + lpfnPagePaintHook : LPPAGEPAINTHOOK; // ignored in CE + lpPageSetupTemplateName : LPCWSTR; + hPageSetupTemplate : HGLOBAL; + end; + LPPAGESETUPDLGW = ^TPAGESETUPDLGW; //+commdlg + tagPSDW = TPAGESETUPDLGW; //+commdlg + + PAINTSTRUCT = record + hdc : HDC; + fErase : WINBOOL; + rcPaint : RECT; + fRestore : WINBOOL; + fIncUpdate : WINBOOL; + rgbReserved : array[0..31] of BYTE; + end; + LPPAINTSTRUCT = ^PAINTSTRUCT; + tagPAINTSTRUCT = PAINTSTRUCT; + TPAINTSTRUCT = PAINTSTRUCT; + PPAINTSTRUCT = ^PAINTSTRUCT; + + PARAFORMAT = record + cbSize : UINT; + dwMask : DWORD; + wNumbering : WORD; + wReserved : WORD; + dxStartIndent : LONG; + dxRightIndent : LONG; + dxOffset : LONG; + wAlignment : WORD; + cTabCount : SHORT; + rgxTabs : array[0..(MAX_TAB_STOPS)-1] of LONG; + end; + _paraformat = PARAFORMAT; + Tparaformat = PARAFORMAT; + Pparaformat = ^PARAFORMAT; + + PERF_COUNTER_BLOCK = record + ByteLength : DWORD; + end; + _PERF_COUNTER_BLOCK = PERF_COUNTER_BLOCK; + TPERFCOUNTERBLOCK = PERF_COUNTER_BLOCK; + PPERFCOUNTERBLOCK = ^PERF_COUNTER_BLOCK; + + PERF_COUNTER_DEFINITION = record + ByteLength : DWORD; + CounterNameTitleIndex : DWORD; + CounterNameTitle : LPWSTR; + CounterHelpTitleIndex : DWORD; + CounterHelpTitle : LPWSTR; + DefaultScale : DWORD; + DetailLevel : DWORD; + CounterType : DWORD; + CounterSize : DWORD; + CounterOffset : DWORD; + end; + _PERF_COUNTER_DEFINITION = PERF_COUNTER_DEFINITION; + TPERFCOUNTERDEFINITION = PERF_COUNTER_DEFINITION; + PPERFCOUNTERDEFINITION = ^PERF_COUNTER_DEFINITION; + + PERF_DATA_BLOCK = record + Signature : array[0..3] of WCHAR; + LittleEndian : DWORD; + Version : DWORD; + Revision : DWORD; + TotalByteLength : DWORD; + HeaderLength : DWORD; + NumObjectTypes : DWORD; + DefaultObject : DWORD; + SystemTime : SYSTEMTIME; + PerfTime : LARGE_INTEGER; + PerfFreq : LARGE_INTEGER; + PerfTime100nSec : LARGE_INTEGER; + SystemNameLength : DWORD; + SystemNameOffset : DWORD; + end; + _PERF_DATA_BLOCK = PERF_DATA_BLOCK; + TPERFDATABLOCK = PERF_DATA_BLOCK; + PPERFDATABLOCK = ^PERF_DATA_BLOCK; + + PERF_INSTANCE_DEFINITION = record + ByteLength : DWORD; + ParentObjectTitleIndex : DWORD; + ParentObjectInstance : DWORD; + UniqueID : DWORD; + NameOffset : DWORD; + NameLength : DWORD; + end; + _PERF_INSTANCE_DEFINITION = PERF_INSTANCE_DEFINITION; + TPERFINSTANCEDEFINITION = PERF_INSTANCE_DEFINITION; + PPERFINSTANCEDEFINITION = PERF_INSTANCE_DEFINITION; + + PERF_OBJECT_TYPE = record + TotalByteLength : DWORD; + DefinitionLength : DWORD; + HeaderLength : DWORD; + ObjectNameTitleIndex : DWORD; + ObjectNameTitle : LPWSTR; + ObjectHelpTitleIndex : DWORD; + ObjectHelpTitle : LPWSTR; + DetailLevel : DWORD; + NumCounters : DWORD; + DefaultCounter : DWORD; + NumInstances : DWORD; + CodePage : DWORD; + PerfTime : LARGE_INTEGER; + PerfFreq : LARGE_INTEGER; + end; + _PERF_OBJECT_TYPE = PERF_OBJECT_TYPE; + TPERFOBJECTTYPE = PERF_OBJECT_TYPE; + PPERFOBJECTTYPE = ^PERF_OBJECT_TYPE; + + POLYTEXT = record + x : longint; + y : longint; + n : UINT; + lpstr : LPCTSTR; + uiFlags : UINT; + rcl : RECT; + pdx : ^longint; + end; + _POLYTEXT = POLYTEXT; + TPOLYTEXT = POLYTEXT; + PPOLYTEXT = ^POLYTEXT; + + PORT_INFO_1 = record + pName : LPTSTR; + end; + _PORT_INFO_1 = PORT_INFO_1; + TPORTINFO1 = PORT_INFO_1; + PPORTINFO1 = ^PORT_INFO_1; + + PORT_INFO_2 = record + pPortName : LPSTR; + pMonitorName : LPSTR; + pDescription : LPSTR; + fPortType : DWORD; + Reserved : DWORD; + end; + _PORT_INFO_2 = PORT_INFO_2; + TPORTINFO2 = PORT_INFO_2; + PPORTINFO2 = ^PORT_INFO_2; + + PREVENT_MEDIA_REMOVAL = record + PreventMediaRemoval : BOOLEAN; + end; + _PREVENT_MEDIA_REMOVAL = PREVENT_MEDIA_REMOVAL; + TPREVENTMEDIAREMOVAL = PREVENT_MEDIA_REMOVAL; + PPREVENTMEDIAREMOVAL = ^PREVENT_MEDIA_REMOVAL; + + {PRINTDLG = record conflicts with PrintDlg function } + TPRINTDLG = packed record + lStructSize : DWORD; + hwndOwner : HWND; + hDevMode : HANDLE; + hDevNames : HANDLE; + hDC : HDC; + Flags : DWORD; + nFromPage : WORD; + nToPage : WORD; + nMinPage : WORD; + nMaxPage : WORD; + nCopies : WORD; + hInstance : HINST; + lCustData : DWORD; + lpfnPrintHook : LPPRINTHOOKPROC; + lpfnSetupHook : LPSETUPHOOKPROC; + lpPrintTemplateName : LPCTSTR; + lpSetupTemplateName : LPCTSTR; + hPrintTemplate : HANDLE; + hSetupTemplate : HANDLE; + end; + LPPRINTDLG = ^TPRINTDLG; + PPRINTDLG = ^TPRINTDLG; + + tagPD = TPRINTDLG; + TPD = TPRINTDLG; + PPD = ^TPRINTDLG; + + PRINTER_DEFAULTS = record + pDatatype : LPTSTR; + pDevMode : LPDEVMODE; + DesiredAccess : ACCESS_MASK; + end; + _PRINTER_DEFAULTS = PRINTER_DEFAULTS; + TPRINTERDEFAULTS = PRINTER_DEFAULTS; + PPRINTERDEFAULTS = ^PRINTER_DEFAULTS; + + PRINTER_INFO_1 = record + Flags : DWORD; + pDescription : LPTSTR; + pName : LPTSTR; + pComment : LPTSTR; + end; + LPPRINTER_INFO_1 = ^PRINTER_INFO_1; + PPRINTER_INFO_1 = ^PRINTER_INFO_1; + _PRINTER_INFO_1 = PRINTER_INFO_1; + TPRINTERINFO1 = PRINTER_INFO_1; + PPRINTERINFO1 = ^PRINTER_INFO_1; + + PRINTER_INFO_2 = record + pServerName : LPTSTR; + pPrinterName : LPTSTR; + pShareName : LPTSTR; + pPortName : LPTSTR; + pDriverName : LPTSTR; + pComment : LPTSTR; + pLocation : LPTSTR; + pDevMode : LPDEVMODE; + pSepFile : LPTSTR; + pPrintProcessor : LPTSTR; + pDatatype : LPTSTR; + pParameters : LPTSTR; + pSecurityDescriptor : PSECURITY_DESCRIPTOR; + Attributes : DWORD; + Priority : DWORD; + DefaultPriority : DWORD; + StartTime : DWORD; + UntilTime : DWORD; + Status : DWORD; + cJobs : DWORD; + AveragePPM : DWORD; + end; + _PRINTER_INFO_2 = PRINTER_INFO_2; + TPRINTERINFO2 = PRINTER_INFO_2; + PPRINTERINFO2 = ^PRINTER_INFO_2; + + PRINTER_INFO_3 = record + pSecurityDescriptor : PSECURITY_DESCRIPTOR; + end; + _PRINTER_INFO_3 = PRINTER_INFO_3; + TPRINTERINFO3 = PRINTER_INFO_3; + PPRINTERINFO3 = ^PRINTER_INFO_3; + + PRINTER_INFO_4 = record + pPrinterName : LPTSTR; + pServerName : LPTSTR; + Attributes : DWORD; + end; + _PRINTER_INFO_4 = PRINTER_INFO_4; + TPRINTERINFO4 = PRINTER_INFO_4; + PPRINTERINFO4 = ^PRINTER_INFO_4; + + PRINTER_INFO_5 = record + pPrinterName : LPTSTR; + pPortName : LPTSTR; + Attributes : DWORD; + DeviceNotSelectedTimeout : DWORD; + TransmissionRetryTimeout : DWORD; + end; + _PRINTER_INFO_5 = PRINTER_INFO_5; + TPRINTERINFO5 = PRINTER_INFO_5; + PPRINTERINFO5 = ^PRINTER_INFO_5; + + PRINTER_NOTIFY_INFO_DATA = record + _Type : WORD; + Field : WORD; + Reserved : DWORD; + Id : DWORD; + NotifyData : record + case longint of + 0 : ( adwData : array[0..1] of DWORD ); + 1 : ( Data : record + cbBuf : DWORD; + pBuf : LPVOID; + end ); + end; + end; + _PRINTER_NOTIFY_INFO_DATA = PRINTER_NOTIFY_INFO_DATA; + TPRINTERNOTIFYINFODATA = PRINTER_NOTIFY_INFO_DATA; + PPRINTERNOTIFYINFODATA = ^PRINTER_NOTIFY_INFO_DATA; + + PRINTER_NOTIFY_INFO = record + Version : DWORD; + Flags : DWORD; + Count : DWORD; + aData : array[0..0] of PRINTER_NOTIFY_INFO_DATA; + end; + _PRINTER_NOTIFY_INFO = PRINTER_NOTIFY_INFO; + TPRINTERNOTIFYINFO = PRINTER_NOTIFY_INFO; + PPRINTERNOTIFYINFO = ^PRINTER_NOTIFY_INFO; + + PRINTER_NOTIFY_OPTIONS_TYPE = record + _Type : WORD; + Reserved0 : WORD; + Reserved1 : DWORD; + Reserved2 : DWORD; + Count : DWORD; + pFields : PWORD; + end; + PPRINTER_NOTIFY_OPTIONS_TYPE = ^PRINTER_NOTIFY_OPTIONS_TYPE; + _PRINTER_NOTIFY_OPTIONS_TYPE = PRINTER_NOTIFY_OPTIONS_TYPE; + TPRINTERNOTIFYOPTIONSTYPE = PRINTER_NOTIFY_OPTIONS_TYPE; + PPRINTERNOTIFYOPTIONSTYPE = ^PRINTER_NOTIFY_OPTIONS_TYPE; + + PRINTER_NOTIFY_OPTIONS = record + Version : DWORD; + Flags : DWORD; + Count : DWORD; + pTypes : PPRINTER_NOTIFY_OPTIONS_TYPE; + end; + _PRINTER_NOTIFY_OPTIONS = PRINTER_NOTIFY_OPTIONS; + TPRINTERNOTIFYOPTIONS = PRINTER_NOTIFY_OPTIONS; + PPRINTERNOTIFYOPTIONS = ^PRINTER_NOTIFY_OPTIONS; + + PRINTPROCESSOR_INFO_1 = record + pName : LPTSTR; + end; + _PRINTPROCESSOR_INFO_1 = PRINTPROCESSOR_INFO_1; + TPRINTPROCESSORINFO1 = PRINTPROCESSOR_INFO_1; + PPRINTPROCESSORINFO1 = ^PRINTPROCESSOR_INFO_1; + + PRIVILEGE_SET = record + PrivilegeCount : DWORD; + Control : DWORD; + Privilege : array[0..(ANYSIZE_ARRAY)-1] of LUID_AND_ATTRIBUTES; + end; + LPPRIVILEGE_SET = ^PRIVILEGE_SET; + PPRIVILEGE_SET = ^PRIVILEGE_SET; + _PRIVILEGE_SET = PRIVILEGE_SET; + TPRIVILEGESET = PRIVILEGE_SET; + PPRIVILEGESET = ^PRIVILEGE_SET; + + PROCESS_HEAPENTRY = record + lpData : PVOID; + cbData : DWORD; + cbOverhead : BYTE; + iRegionIndex : BYTE; + wFlags : WORD; + dwCommittedSize : DWORD; + dwUnCommittedSize : DWORD; + lpFirstBlock : LPVOID; + lpLastBlock : LPVOID; + hMem : HANDLE; + end; + LPPROCESS_HEAP_ENTRY = ^PROCESS_HEAPENTRY; + _PROCESS_HEAP_ENTRY = PROCESS_HEAPENTRY; + TPROCESSHEAPENTRY = PROCESS_HEAPENTRY; + PPROCESSHEAPENTRY = ^PROCESS_HEAPENTRY; + + PROCESS_INFORMATION = record + hProcess : HANDLE; + hThread : HANDLE; + dwProcessId : DWORD; + dwThreadId : DWORD; + end; + LPPROCESS_INFORMATION = ^PROCESS_INFORMATION; + _PROCESS_INFORMATION = PROCESS_INFORMATION; + TPROCESSINFORMATION = PROCESS_INFORMATION; + PPROCESSINFORMATION = ^PROCESS_INFORMATION; + + LPFNPSPCALLBACK = function (_para1:HWND; _para2:UINT; _para3:LPVOID):UINT;stdcall; + TFNPSPCALLBACK = LPFNPSPCALLBACK; + + PROPSHEETPAGE = record + dwSize : DWORD; + dwFlags : DWORD; + hInstance : HINST; + case longint of + 0 : (pszTemplate : LPCTSTR); + 1 : (pResource : LPCDLGTEMPLATE; + case longint of + 0 : (hIcon : HICON); + 1 : (pszIcon : LPCTSTR; + pszTitle : LPCTSTR; + pfnDlgProc : DLGPROC; + lParam : LPARAM; + pfnCallback : LPFNPSPCALLBACK; + pcRefParent : ^UINT; + ); + ); + end; + LPPROPSHEETPAGE = ^PROPSHEETPAGE; + LPCPROPSHEETPAGE = ^PROPSHEETPAGE; + _PROPSHEETPAGE = PROPSHEETPAGE; + TPROPSHEETPAGE = PROPSHEETPAGE; + PPROPSHEETPAGE = ^PROPSHEETPAGE; + + emptyrecord = record + end; + lpemptyrecord = ^emptyrecord; + HPROPSHEETPAGE = ^emptyrecord; + + PROPSHEETHEADER = record + dwSize : DWORD; + dwFlags : DWORD; + hwndParent : HWND; + hInstance : HINST; + case longint of + 0 : (hIcon : HICON); + 1 : (pszIcon : LPCTSTR; + pszCaption : LPCTSTR; + nPages : UINT; + case longint of + 0 : (nStartPage : UINT); + 1 : (pStartPage : LPCTSTR; + case longint of + 0 : (ppsp : LPCPROPSHEETPAGE); + 1 : (phpage : ^HPROPSHEETPAGE; + pfnCallback : PFNPROPSHEETCALLBACK; + case longint of + 0 : (hbmWatermark : HBITMAP); + 1 : (pszbmWatermark : LPCTSTR; + hplWatermark : HPALETTE; + case longint of + 0 : (hbmHeader : HBITMAP); + 1 : (pszbmHeader: PAnsiChar); + ); + ); + ); + ); + end; + LPPROPSHEETHEADER = ^PROPSHEETHEADER; + LPCPROPSHEETHEADER = ^PROPSHEETHEADER; + _PROPSHEETHEADER = PROPSHEETHEADER; + TPROPSHEETHEADER = PROPSHEETHEADER; + PPROPSHEETHEADER = ^PROPSHEETHEADER; + + PROPSHEETHEADERW = record //prsht + dwSize : DWORD; + dwFlags : DWORD; + hwndParent : HWND; + hInstance : HINST; + case longint of + 0 : (hIcon : HICON); + 1 : (pszIcon : LPCWSTR; + pszCaption : LPCWSTR; + nPages : UINT; + case longint of + 0 : (nStartPage : UINT); + 1 : (pStartPage : LPCWSTR; + case longint of + 0 : (ppsp : LPCPROPSHEETPAGE); + 1 : (phpage : ^HPROPSHEETPAGE; + pfnCallback : PFNPROPSHEETCALLBACK; + ); + ); + ); + end; + LPCPROPSHEETHEADERW = ^PROPSHEETHEADERW; + _PROPSHEETHEADERW = PROPSHEETHEADERW; + + { PropertySheet callbacks } + LPFNADDPROPSHEETPAGE = function (_para1:HPROPSHEETPAGE; _para2:LPARAM):WINBOOL;stdcall; + TFNADDPROPSHEETPAGE = LPFNADDPROPSHEETPAGE; + + LPFNADDPROPSHEETPAGES = function (_para1:LPVOID; _para2:LPFNADDPROPSHEETPAGE; _para3:LPARAM):WINBOOL;stdcall; + TFNADDPROPSHEETPAGES = LPFNADDPROPSHEETPAGES; + + PROTOCOL_INFO = record + dwServiceFlags : DWORD; + iAddressFamily : WINT; + iMaxSockAddr : WINT; + iMinSockAddr : WINT; + iSocketType : WINT; + iProtocol : WINT; + dwMessageSize : DWORD; + lpProtocol : LPTSTR; + end; + _PROTOCOL_INFO = PROTOCOL_INFO; + TPROTOCOLINFO = PROTOCOL_INFO; + PPROTOCOLINFO = ^PROTOCOL_INFO; + + PROVIDOR_INFO_1 = record + pName : LPTSTR; + pEnvironment : LPTSTR; + pDLLName : LPTSTR; + end; + _PROVIDOR_INFO_1 = PROVIDOR_INFO_1; + TPROVIDORINFO1 = PROVIDOR_INFO_1; + PPROVIDORINFO1 = ^PROVIDOR_INFO_1; + + PSHNOTIFY = record + hdr : NMHDR; + lParam : LPARAM; + end; + LPPSHNOTIFY = ^PSHNOTIFY; + _PSHNOTIFY = PSHNOTIFY; + TPSHNOTIFY = PSHNOTIFY; + PPSHNOTIFY = ^PSHNOTIFY; + + PUNCTUATION = record + iSize : UINT; + szPunctuation : LPSTR; + end; + _punctuation = PUNCTUATION; + Tpunctuation = PUNCTUATION; + Ppunctuation = ^PUNCTUATION; + + QUERY_SERVICE_CONFIG = record + dwServiceType : DWORD; + dwStartType : DWORD; + dwErrorControl : DWORD; + lpBinaryPathName : LPTSTR; + lpLoadOrderGroup : LPTSTR; + dwTagId : DWORD; + lpDependencies : LPTSTR; + lpServiceStartName : LPTSTR; + lpDisplayName : LPTSTR; + end; + LPQUERY_SERVICE_CONFIG = ^QUERY_SERVICE_CONFIG; + _QUERY_SERVICE_CONFIG = QUERY_SERVICE_CONFIG; + TQUERYSERVICECONFIG = QUERY_SERVICE_CONFIG; + PQUERYSERVICECONFIG = ^QUERY_SERVICE_CONFIG; + + QUERY_SERVICE_LOCK_STATUS = record + fIsLocked : DWORD; + lpLockOwner : LPTSTR; + dwLockDuration : DWORD; + end; + LPQUERY_SERVICE_LOCK_STATUS = ^QUERY_SERVICE_LOCK_STATUS; + _QUERY_SERVICE_LOCK_STATUS = QUERY_SERVICE_LOCK_STATUS; + TQUERYSERVICELOCKSTATUS = QUERY_SERVICE_LOCK_STATUS; + PQUERYSERVICELOCKSTATUS = ^QUERY_SERVICE_LOCK_STATUS; + + RASAMB = record + dwSize : DWORD; + dwError : DWORD; + szNetBiosError : array[0..(NETBIOS_NAME_LEN + 1)-1] of TCHAR; + bLana : BYTE; + end; + _RASAMB = RASAMB; + TRASAMB = RASAMB; + PRASAMB = ^RASAMB; + + RASCONN = record + dwSize : DWORD; + hrasconn : HRASCONN; + szEntryName : array[0..(RAS_MaxEntryName + 1)-1] of TCHAR; + szDeviceType : array[0..(RAS_MaxDeviceType + 1)-1] of CHAR; + szDeviceName : array[0..(RAS_MaxDeviceName + 1)-1] of CHAR; + end; + _RASCONN = RASCONN; + TRASCONN = RASCONN; + PRASCONN = ^RASCONN; + + RASCONNSTATUS = record + dwSize : DWORD; + rasconnstate : RASCONNSTATE; + dwError : DWORD; + szDeviceType : array[0..(RAS_MaxDeviceType + 1)-1] of TCHAR; + szDeviceName : array[0..(RAS_MaxDeviceName + 1)-1] of TCHAR; + end; + _RASCONNSTATUS = RASCONNSTATUS; + TRASCONNSTATUS = RASCONNSTATUS; + PRASCONNSTATUS = ^RASCONNSTATUS; + + RASDIALEXTENSIONS = record + dwSize : DWORD; + dwfOptions : DWORD; + hwndParent : HWND; + reserved : DWORD; + end; + _RASDIALEXTENSIONS = RASDIALEXTENSIONS; + TRASDIALEXTENSIONS = RASDIALEXTENSIONS; + PRASDIALEXTENSIONS = ^RASDIALEXTENSIONS; + + RASDIALPARAMS = record + dwSize : DWORD; + szEntryName : array[0..(RAS_MaxEntryName + 1)-1] of TCHAR; + szPhoneNumber : array[0..(RAS_MaxPhoneNumber + 1)-1] of TCHAR; + szCallbackNumber : array[0..(RAS_MaxCallbackNumber + 1)-1] of TCHAR; + szUserName : array[0..(UNLEN + 1)-1] of TCHAR; + szPassword : array[0..(PWLEN + 1)-1] of TCHAR; + szDomain : array[0..(DNLEN + 1)-1] of TCHAR; + end; + _RASDIALPARAMS = RASDIALPARAMS; + TRASDIALPARAMS = RASDIALPARAMS; + PRASDIALPARAMS = ^RASDIALPARAMS; + + RASENTRYNAME = record + dwSize : DWORD; + szEntryName : array[0..(RAS_MaxEntryName + 1)-1] of TCHAR; + end; + _RASENTRYNAME = RASENTRYNAME; + TRASENTRYNAME = RASENTRYNAME; + PRASENTRYNAME = ^RASENTRYNAME; + + RASPPPIP = record + dwSize : DWORD; + dwError : DWORD; + szIpAddress : array[0..(RAS_MaxIpAddress + 1)-1] of TCHAR; + end; + _RASPPPIP = RASPPPIP; + TRASPPPIP = RASPPPIP; + PRASPPPIP = ^RASPPPIP; + + RASPPPIPX = record + dwSize : DWORD; + dwError : DWORD; + szIpxAddress : array[0..(RAS_MaxIpxAddress + 1)-1] of TCHAR; + end; + _RASPPPIPX = RASPPPIPX; + TRASPPPIPX = RASPPPIPX; + PRASPPPIPX = ^RASPPPIPX; + + RASPPPNBF = record + dwSize : DWORD; + dwError : DWORD; + dwNetBiosError : DWORD; + szNetBiosError : array[0..(NETBIOS_NAME_LEN + 1)-1] of TCHAR; + szWorkstationName : array[0..(NETBIOS_NAME_LEN + 1)-1] of TCHAR; + bLana : BYTE; + end; + _RASPPPNBF = RASPPPNBF; + TRASPPPNBF = RASPPPNBF; + PRASPPPNBF = ^RASPPPNBF; + + RASTERIZER_STATUS = record + nSize : integer; + wFlags : integer; + nLanguageID : integer; + end; + LPRASTERIZER_STATUS = ^RASTERIZER_STATUS; + _RASTERIZER_STATUS = RASTERIZER_STATUS; + TRASTERIZERSTATUS = RASTERIZER_STATUS; + PRASTERIZERSTATUS = ^RASTERIZER_STATUS; + + REASSIGN_BLOCKS = record + Reserved : WORD; + Count : WORD; + BlockNumber : array[0..0] of DWORD; + end; + _REASSIGN_BLOCKS = REASSIGN_BLOCKS; + TREASSIGNBLOCKS = REASSIGN_BLOCKS; + PREASSIGNBLOCKS = ^REASSIGN_BLOCKS; + + REMOTE_NAME_INFO = record + lpUniversalName : LPTSTR; + lpConnectionName : LPTSTR; + lpRemainingPath : LPTSTR; + end; + _REMOTE_NAME_INFO = REMOTE_NAME_INFO; + TREMOTENAMEINFO = REMOTE_NAME_INFO; + PREMOTENAMEINFO = ^REMOTE_NAME_INFO; + + (* + TODO: OLE + typedef struct _reobject { + DWORD cbStruct; + LONG cp; + CLSID clsid; + LPOLEOBJECT poleobj; + LPSTORAGE pstg; + LPOLECLIENTSITE polesite; + SIZEL sizel; + DWORD dvaspect; + DWORD dwFlags; + DWORD dwUser; + } REOBJECT; + *) + + REPASTESPECIAL = record + dwAspect : DWORD; + dwParam : DWORD; + end; + _repastespecial = REPASTESPECIAL; + Trepastespecial = REPASTESPECIAL; + Prepastespecial = ^REPASTESPECIAL; + + REQRESIZE = record + nmhdr : NMHDR; + rc : RECT; + end; + _reqresize = REQRESIZE; + Treqresize = REQRESIZE; + Preqresize = ^REQRESIZE; + + RGNDATAHEADER = record + dwSize : DWORD; + iType : DWORD; + nCount : DWORD; + nRgnSize : DWORD; + rcBound : RECT; + end; + _RGNDATAHEADER = RGNDATAHEADER; + TRGNDATAHEADER = RGNDATAHEADER; + PRGNDATAHEADER = ^RGNDATAHEADER; + + RGNDATA = record + rdh : RGNDATAHEADER; + Buffer : array[0..0] of char; + end; + LPRGNDATA = ^RGNDATA; + _RGNDATA = RGNDATA; + TRGNDATA = RGNDATA; + PRGNDATA = ^RGNDATA; + + SCROLLINFO = record + cbSize : UINT; + fMask : UINT; + nMin : longint; + nMax : longint; + nPage : UINT; + nPos : longint; + nTrackPos : longint; + end; + LPSCROLLINFO = ^SCROLLINFO; + LPCSCROLLINFO = ^SCROLLINFO; + tagSCROLLINFO = SCROLLINFO; + TSCROLLINFO = SCROLLINFO; + PSCROLLINFO = ^SCROLLINFO; + + SECURITY_ATTRIBUTES = record + nLength : DWORD; + lpSecurityDescriptor : LPVOID; + bInheritHandle : WINBOOL; + end; + LPSECURITY_ATTRIBUTES = ^SECURITY_ATTRIBUTES; + _SECURITY_ATTRIBUTES = SECURITY_ATTRIBUTES; + TSECURITYATTRIBUTES = SECURITY_ATTRIBUTES; + PSECURITYATTRIBUTES = ^SECURITY_ATTRIBUTES; + + SECURITY_INFORMATION = DWORD; + PSECURITY_INFORMATION = ^SECURITY_INFORMATION; + TSECURITYINFORMATION = SECURITY_INFORMATION; + PSECURITYINFORMATION = ^SECURITY_INFORMATION; + + SELCHANGE = record + nmhdr : NMHDR; + chrg : CHARRANGE; + seltyp : WORD; + end; + _selchange = SELCHANGE; + Tselchange = SELCHANGE; + Pselchange = ^SELCHANGE; + + SERIALKEYS = record + cbSize : DWORD; + dwFlags : DWORD; + lpszActivePort : LPSTR; + lpszPort : LPSTR; + iBaudRate : DWORD; + iPortState : DWORD; + end; + LPSERIALKEYS = ^SERIALKEYS; + tagSERIALKEYS = SERIALKEYS; + TSERIALKEYS = SERIALKEYS; + PSERIALKEYS = ^SERIALKEYS; + + SERVICE_TABLE_ENTRY = record + lpServiceName : LPTSTR; + lpServiceProc : LPSERVICE_MAIN_FUNCTION; + end; + LPSERVICE_TABLE_ENTRY = ^SERVICE_TABLE_ENTRY; + _SERVICE_TABLE_ENTRY = SERVICE_TABLE_ENTRY; + TSERVICETABLEENTRY = SERVICE_TABLE_ENTRY; + PSERVICETABLEENTRY = ^SERVICE_TABLE_ENTRY; + + SERVICE_TYPE_VALUE_ABS = record + dwNameSpace : DWORD; + dwValueType : DWORD; + dwValueSize : DWORD; + lpValueName : LPTSTR; + lpValue : PVOID; + end; + _SERVICE_TYPE_VALUE_ABS = SERVICE_TYPE_VALUE_ABS; + TSERVICETYPEVALUEABS = SERVICE_TYPE_VALUE_ABS; + PSERVICETYPEVALUEABS = ^SERVICE_TYPE_VALUE_ABS; + + SERVICE_TYPE_INFO_ABS = record + lpTypeName : LPTSTR; + dwValueCount : DWORD; + Values : array[0..0] of SERVICE_TYPE_VALUE_ABS; + end; + _SERVICE_TYPE_INFO_ABS = SERVICE_TYPE_INFO_ABS; + TSERVICETYPEINFOABS = SERVICE_TYPE_INFO_ABS; + PSERVICETYPEINFOABS = ^SERVICE_TYPE_INFO_ABS; + + SESSION_BUFFER = record + lsn : UCHAR; + state : UCHAR; + local_name : array[0..(NCBNAMSZ)-1] of UCHAR; + remote_name : array[0..(NCBNAMSZ)-1] of UCHAR; + rcvs_outstanding : UCHAR; + sends_outstanding : UCHAR; + end; + _SESSION_BUFFER = SESSION_BUFFER; + TSESSIONBUFFER = SESSION_BUFFER; + PSESSIONBUFFER = ^SESSION_BUFFER; + + SESSION_HEADER = record + sess_name : UCHAR; + num_sess : UCHAR; + rcv_dg_outstanding : UCHAR; + rcv_any_outstanding : UCHAR; + end; + _SESSION_HEADER = SESSION_HEADER; + TSESSIONHEADER = SESSION_HEADER; + PSESSIONHEADER = ^SESSION_HEADER; + + SET_PARTITION_INFORMATION = record + PartitionType : BYTE; + end; + _SET_PARTITION_INFORMATION = SET_PARTITION_INFORMATION; + TSETPARTITIONINFORMATION = SET_PARTITION_INFORMATION; + PSETPARTITIONINFORMATION = ^SET_PARTITION_INFORMATION; + + SHELLEXECUTEINFO = record //+shellapi + cbSize: DWORD; + fMask: ULONG; + hwnd: HWND; + lpVerb: LPCTSTR; + lpFile: LPCTSTR; + lpParameters: LPCTSTR; + lpDirectory: LPCTSTR; + nShow: Integer ; + hInstApp: HINST; + // Optional fields + lpIDList: LPVOID; + lpClass: LPCTSTR; + hkeyClass: HKEY; + dwHotKey: DWORD; + hIcon: HANDLE; + hProcess :HANDLE; + end; + _SHELLEXECUTEINFO=SHELLEXECUTEINFO; //+shellapi + LPSHELLEXECUTEINFO=^SHELLEXECUTEINFO; //+shellapi + + SHCONTF = (SHCONTF_FOLDERS := 32,SHCONTF_NONFOLDERS := 64, + SHCONTF_INCLUDEHIDDEN := 128); + tagSHCONTF = SHCONTF; + TSHCONTF = SHCONTF; + + SHFILEINFO = record + hIcon : HICON; + iIcon : longint; + dwAttributes : DWORD; + szDisplayName : array[0..(MAX_PATH)-1] of char; + szTypeName : array[0..79] of char; + end; + _SHFILEINFO = SHFILEINFO; + TSHFILEINFO = SHFILEINFO; + PSHFILEINFO = ^SHFILEINFO; + + FILEOP_FLAGS = WORD; + TFILEOPFLAGS = FILEOP_FLAGS; + PFILEOPFLAGS = ^FILEOP_FLAGS; + + SHFILEOPSTRUCT = record + hwnd : HWND; + wFunc : UINT; + pFrom : LPCSTR; + pTo : LPCSTR; + fFlags : FILEOP_FLAGS; + fAnyOperationsAborted : WINBOOL; + hNameMappings : LPVOID; + lpszProgressTitle : LPCSTR; + end; + LPSHFILEOPSTRUCT = ^SHFILEOPSTRUCT; + _SHFILEOPSTRUCT = SHFILEOPSTRUCT; + TSHFILEOPSTRUCT = SHFILEOPSTRUCT; + PSHFILEOPSTRUCT = ^SHFILEOPSTRUCT; + + SHGNO = (SHGDN_NORMAL := 0,SHGDN_INFOLDER := 1, + SHGDN_FORPARSING := $8000); + tagSHGDN = SHGNO; + TSHGDN = SHGNO; + + SHNAMEMAPPING = record + pszOldPath : LPSTR; + pszNewPath : LPSTR; + cchOldPath : longint; + cchNewPath : longint; + end; + LPSHNAMEMAPPING = ^SHNAMEMAPPING; + _SHNAMEMAPPING = SHNAMEMAPPING; + TSHNAMEMAPPING = SHNAMEMAPPING; + PSHNAMEMAPPING = ^SHNAMEMAPPING; + + SINGLE_LIST_ENTRY = record + Next : ^_SINGLE_LIST_ENTRY; + end; + _SINGLE_LIST_ENTRY = SINGLE_LIST_ENTRY; + TSINGLELISTENTRY = SINGLE_LIST_ENTRY; + PSINGLELISTENTRY = ^SINGLE_LIST_ENTRY; + + SOUNDSENTRY = record + cbSize : UINT; + dwFlags : DWORD; + iFSTextEffect : DWORD; + iFSTextEffectMSec : DWORD; + iFSTextEffectColorBits : DWORD; + iFSGrafEffect : DWORD; + iFSGrafEffectMSec : DWORD; + iFSGrafEffectColor : DWORD; + iWindowsEffect : DWORD; + iWindowsEffectMSec : DWORD; + lpszWindowsEffectDLL : LPTSTR; + iWindowsEffectOrdinal : DWORD; + end; + LPSOUNDSENTRY = ^SOUNDSENTRY; + tagSOUNDSENTRY = SOUNDSENTRY; + TSOUNDSENTRY = SOUNDSENTRY; + PSOUNDSENTRY = ^SOUNDSENTRY; + + STARTUPINFO = record + cb : DWORD; + lpReserved : LPTSTR; + lpDesktop : LPTSTR; + lpTitle : LPTSTR; + dwX : DWORD; + dwY : DWORD; + dwXSize : DWORD; + dwYSize : DWORD; + dwXCountChars : DWORD; + dwYCountChars : DWORD; + dwFillAttribute : DWORD; + dwFlags : DWORD; + wShowWindow : WORD; + cbReserved2 : WORD; + lpReserved2 : LPBYTE; + hStdInput : HANDLE; + hStdOutput : HANDLE; + hStdError : HANDLE; + end; + LPSTARTUPINFO = ^STARTUPINFO; + _STARTUPINFO = STARTUPINFO; + TSTARTUPINFO = STARTUPINFO; + PSTARTUPINFO = ^STARTUPINFO; + + STICKYKEYS = record + cbSize : DWORD; + dwFlags : DWORD; + end; + LPSTICKYKEYS = ^STICKYKEYS; + tagSTICKYKEYS = STICKYKEYS; + TSTICKYKEYS = STICKYKEYS; + PSTICKYKEYS = ^STICKYKEYS; + + STRRET = record + uType : UINT; + DUMMYUNIONNAME : record + case longint of + 0 : ( pOleStr : LPWSTR ); + 1 : ( uOffset : UINT ); + 2 : ( cStr : array[0..(MAX_PATH)-1] of char ); + end; + end; + LPSTRRET = ^STRRET; + _STRRET = STRRET; + TSTRRET = STRRET; + PSTRRET = ^STRRET; + + STYLEBUF = record + dwStyle : DWORD; + szDescription : array[0..31] of CHAR; + end; + LPSTYLEBUF = ^STYLEBUF; + _tagSTYLEBUF = STYLEBUF; + TSTYLEBUF = STYLEBUF; + PSTYLEBUF = ^STYLEBUF; + + STYLESTRUCT = record + styleOld : DWORD; + styleNew : DWORD; + end; + LPSTYLESTRUCT = ^STYLESTRUCT; + tagSTYLESTRUCT = STYLESTRUCT; + TSTYLESTRUCT = STYLESTRUCT; + PSTYLESTRUCT = ^STYLESTRUCT; + + SYSTEM_AUDIT_ACE = record + Header : ACE_HEADER; + Mask : ACCESS_MASK; + SidStart : DWORD; + end; + _SYSTEM_AUDIT_ACE = SYSTEM_AUDIT_ACE; + TSYSTEMAUDITACE = SYSTEM_AUDIT_ACE; + PSYSTEMAUDITACE = ^SYSTEM_AUDIT_ACE; + + SYSTEM_INFO = record + u : record + case longint of + 0 : ( dwOemId : DWORD ); + 1 : ( s : record + wProcessorArchitecture : WORD; + wReserved : WORD; + end ); + end; + dwPageSize : DWORD; + lpMinimumApplicationAddress : LPVOID; + lpMaximumApplicationAddress : LPVOID; + dwActiveProcessorMask : DWORD; + dwNumberOfProcessors : DWORD; + dwProcessorType : DWORD; + dwAllocationGranularity : DWORD; + wProcessorLevel : WORD; + wProcessorRevision : WORD; + end; + LPSYSTEM_INFO = ^SYSTEM_INFO; + _SYSTEM_INFO = SYSTEM_INFO; + TSYSTEMINFO = SYSTEM_INFO; + PSYSTEMINFO = ^SYSTEM_INFO; + + SYSTEM_POWER_STATUS = record + ACLineStatus : BYTE; + BatteryFlag : BYTE; + BatteryLifePercent : BYTE; + Reserved1 : BYTE; + BatteryLifeTime : DWORD; + BatteryFullLifeTime : DWORD; + end; + _SYSTEM_POWER_STATUS = SYSTEM_POWER_STATUS; + TSYSTEMPOWERSTATUS = SYSTEM_POWER_STATUS; + PSYSTEMPOWERSTATUS = ^SYSTEM_POWER_STATUS; + + LPSYSTEM_POWER_STATUS = ^emptyrecord; + + TAPE_ERASE = record + _Type : ULONG; + end; + _TAPE_ERASE = TAPE_ERASE; + TTAPEERASE = TAPE_ERASE; + PTAPEERASE = ^TAPE_ERASE; + + TAPE_GET_DRIVE_PARAMETERS = record + ECC : BOOLEAN; + Compression : BOOLEAN; + DataPadding : BOOLEAN; + ReportSetmarks : BOOLEAN; + DefaultBlockSize : ULONG; + MaximumBlockSize : ULONG; + MinimumBlockSize : ULONG; + MaximumPartitionCount : ULONG; + FeaturesLow : ULONG; + FeaturesHigh : ULONG; + EOTWarningZoneSize : ULONG; + end; + _TAPE_GET_DRIVE_PARAMETERS = TAPE_GET_DRIVE_PARAMETERS; + TTAPEGETDRIVEPARAMETERS = TAPE_GET_DRIVE_PARAMETERS; + PTAPEGETDRIVEPARAMETERS = ^TAPE_GET_DRIVE_PARAMETERS; + + TAPE_GET_MEDIA_PARAMETERS = record + Capacity : LARGE_INTEGER; + Remaining : LARGE_INTEGER; + BlockSize : DWORD; + PartitionCount : DWORD; + WriteProtected : BOOLEAN; + end; + _TAPE_GET_MEDIA_PARAMETERS = TAPE_GET_MEDIA_PARAMETERS; + TTAPEGETMEDIAPARAMETERS = TAPE_GET_MEDIA_PARAMETERS; + PTAPEGETMEDIAPARAMETERS = ^TAPE_GET_MEDIA_PARAMETERS; + + TAPE_GET_POSITION = record + _Type : ULONG; + Partition : ULONG; + OffsetLow : ULONG; + OffsetHigh : ULONG; + end; + _TAPE_GET_POSITION = TAPE_GET_POSITION; + TTAPEGETPOSITION = TAPE_GET_POSITION; + PTAPEGETPOSITION = ^TAPE_GET_POSITION; + + TAPE_PREPARE = record + Operation : ULONG; + end; + _TAPE_PREPARE = TAPE_PREPARE; + TTAPEPREPARE = TAPE_PREPARE; + PTAPEPREPARE = ^TAPE_PREPARE; + + TAPE_SET_DRIVE_PARAMETERS = record + ECC : BOOLEAN; + Compression : BOOLEAN; + DataPadding : BOOLEAN; + ReportSetmarks : BOOLEAN; + EOTWarningZoneSize : ULONG; + end; + _TAPE_SET_DRIVE_PARAMETERS = TAPE_SET_DRIVE_PARAMETERS; + TTAPESETDRIVEPARAMETERS = TAPE_SET_DRIVE_PARAMETERS; + PTAPESETDRIVEPARAMETERS = ^TAPE_SET_DRIVE_PARAMETERS; + + TAPE_SET_MEDIA_PARAMETERS = record + BlockSize : ULONG; + end; + _TAPE_SET_MEDIA_PARAMETERS = TAPE_SET_MEDIA_PARAMETERS; + TTAPESETMEDIAPARAMETERS = TAPE_SET_MEDIA_PARAMETERS; + PTAPESETMEDIAPARAMETERS = ^TAPE_SET_MEDIA_PARAMETERS; + + TAPE_SET_POSITION = record + Method : ULONG; + Partition : ULONG; + OffsetLow : ULONG; + OffsetHigh : ULONG; + end; + _TAPE_SET_POSITION = TAPE_SET_POSITION; + TTAPESETPOSITION = TAPE_SET_POSITION; + PTAPESETPOSITION = ^TAPE_SET_POSITION; + + TAPE_WRITE_MARKS = record + _Type : ULONG; + Count : ULONG; + end; + _TAPE_WRITE_MARKS = TAPE_WRITE_MARKS; + TTAPEWRITEMARKS = TAPE_WRITE_MARKS; + PTAPEWRITEMARKS = ^TAPE_WRITE_MARKS; + + TBADDBITMAP = record + hInst : HINST; + nID : UINT; + end; + LPTBADDBITMAP = ^TBADDBITMAP; + TTBADDBITMAP = TBADDBITMAP; + PTBADDBITMAP = ^TBADDBITMAP; + + TBBUTTON = record + iBitmap : longint; + idCommand : longint; + fsState : BYTE; + fsStyle : BYTE; + dwData : DWORD; + iString : longint; + end; + LPTBBUTTON = ^TBBUTTON; + LPCTBBUTTON = ^TBBUTTON; + _TBBUTTON = TBBUTTON; + TTBBUTTON = TBBUTTON; + PTBBUTTON = ^TBBUTTON; + + TBNOTIFY = record + hdr : NMHDR; + iItem : longint; + tbButton : TBBUTTON; + cchText : longint; + pszText : LPTSTR; + end; + LPTBNOTIFY = ^TBNOTIFY; + TTBNOTIFY = TBNOTIFY; + PTBNOTIFY = ^TBNOTIFY; + + TBSAVEPARAMS = record + hkr : HKEY; + pszSubKey : LPCTSTR; + pszValueName : LPCTSTR; + end; + TTBSAVEPARAMS = TBSAVEPARAMS; + PTBSAVEPARAMS = ^TBSAVEPARAMS; + + TC_HITTESTINFO = record + pt : POINT; + flags : UINT; + end; + _TC_HITTESTINFO = TC_HITTESTINFO; + TTCHITTESTINFO = TC_HITTESTINFO; + PTCHITTESTINFO = ^TC_HITTESTINFO; + + TC_ITEM = record + mask : UINT; + lpReserved1 : UINT; + lpReserved2 : UINT; + pszText : LPTSTR; + cchTextMax : longint; + iImage : longint; + lParam : LPARAM; + end; + _TC_ITEM = TC_ITEM; + TTCITEM = TC_ITEM; + PTCITEM = ^TC_ITEM; + + TC_ITEMHEADER = record + mask : UINT; + lpReserved1 : UINT; + lpReserved2 : UINT; + pszText : LPTSTR; + cchTextMax : longint; + iImage : longint; + end; + _TC_ITEMHEADER = TC_ITEMHEADER; + TTCITEMHEADER = TC_ITEMHEADER; + PTCITEMHEADER = ^TC_ITEMHEADER; + + TC_KEYDOWN = record + hdr : NMHDR; + wVKey : WORD; + flags : UINT; + end; + _TC_KEYDOWN = TC_KEYDOWN; + TTCKEYDOWN = TC_KEYDOWN; + PTCKEYDOWN = ^TC_KEYDOWN; + + TEXTRANGE = record + chrg : CHARRANGE; + lpstrText : LPSTR; + end; + _textrange = TEXTRANGE; + Ttextrange = TEXTRANGE; + Ptextrange = ^TEXTRANGE; + + TIME_ZONE_INFORMATION = record + Bias : LONG; + StandardName : array[0..31] of WCHAR; + StandardDate : SYSTEMTIME; + StandardBias : LONG; + DaylightName : array[0..31] of WCHAR; + DaylightDate : SYSTEMTIME; + DaylightBias : LONG; + end; + LPTIME_ZONE_INFORMATION = ^TIME_ZONE_INFORMATION; + _TIME_ZONE_INFORMATION = TIME_ZONE_INFORMATION; + TTIMEZONEINFORMATION = TIME_ZONE_INFORMATION; + PTIMEZONEINFORMATION = ^TIME_ZONE_INFORMATION; + + TOGGLEKEYS = record + cbSize : DWORD; + dwFlags : DWORD; + end; + tagTOGGLEKEYS = TOGGLEKEYS; + TTOGGLEKEYS = TOGGLEKEYS; + PTOGGLEKEYS = ^TOGGLEKEYS; + + TOKEN_SOURCE = record + SourceName : array[0..7] of CHAR; + SourceIdentifier : LUID; + end; + _TOKEN_SOURCE = TOKEN_SOURCE; + TTOKENSOURCE = TOKEN_SOURCE; + PTOKENSOURCE = ^TOKEN_SOURCE; + + TOKEN_CONTROL = record + TokenId : LUID; + AuthenticationId : LUID; + ModifiedId : LUID; + TokenSource : TOKEN_SOURCE; + end; + _TOKEN_CONTROL = TOKEN_CONTROL; + TTOKENCONTROL = TOKEN_CONTROL; + PTOKENCONTROL = ^TOKEN_CONTROL; + + TOKEN_DEFAULT_DACL = record + DefaultDacl : PACL; + end; + _TOKEN_DEFAULT_DACL = TOKEN_DEFAULT_DACL; + TTOKENDEFAULTDACL = TOKEN_DEFAULT_DACL; + PTOKENDEFAULTDACL = ^TOKEN_DEFAULT_DACL; + + TOKEN_GROUPS = record + GroupCount : DWORD; + Groups : array[0..(ANYSIZE_ARRAY)-1] of SID_AND_ATTRIBUTES; + end; + PTOKEN_GROUPS = ^TOKEN_GROUPS; + LPTOKEN_GROUPS = ^TOKEN_GROUPS; + _TOKEN_GROUPS = TOKEN_GROUPS; + TTOKENGROUPS = TOKEN_GROUPS; + PTOKENGROUPS = ^TOKEN_GROUPS; + + TOKEN_OWNER = record + Owner : PSID; + end; + _TOKEN_OWNER = TOKEN_OWNER; + TTOKENOWNER = TOKEN_OWNER; + PTOKENOWNER = ^TOKEN_OWNER; + + TOKEN_PRIMARY_GROUP = record + PrimaryGroup : PSID; + end; + _TOKEN_PRIMARY_GROUP = TOKEN_PRIMARY_GROUP; + TTOKENPRIMARYGROUP = TOKEN_PRIMARY_GROUP; + PTOKENPRIMARYGROUP = ^TOKEN_PRIMARY_GROUP; + + TOKEN_PRIVILEGES = packed record + PrivilegeCount : DWORD; + Privileges : array[0..(ANYSIZE_ARRAY)-1] of LUID_AND_ATTRIBUTES; + end; + + PTOKEN_PRIVILEGES = ^TOKEN_PRIVILEGES; + LPTOKEN_PRIVILEGES = ^TOKEN_PRIVILEGES; + _TOKEN_PRIVILEGES = TOKEN_PRIVILEGES; + TTOKENPRIVILEGES = TOKEN_PRIVILEGES; + PTOKENPRIVILEGES = ^TOKEN_PRIVILEGES; + + TOKEN_STATISTICS = record + TokenId : LUID; + AuthenticationId : LUID; + ExpirationTime : LARGE_INTEGER; + TokenType : TOKEN_TYPE; + ImpersonationLevel : SECURITY_IMPERSONATION_LEVEL; + DynamicCharged : DWORD; + DynamicAvailable : DWORD; + GroupCount : DWORD; + PrivilegeCount : DWORD; + ModifiedId : LUID; + end; + _TOKEN_STATISTICS = TOKEN_STATISTICS; + TTOKENSTATISTICS = TOKEN_STATISTICS; + PTOKENSTATISTICS = ^TOKEN_STATISTICS; + + TOKEN_USER = record + User : SID_AND_ATTRIBUTES; + end; + _TOKEN_USER = TOKEN_USER; + TTOKENUSER = TOKEN_USER; + PTOKENUSER = ^TOKEN_USER; + + TOOLINFO = record + cbSize : UINT; + uFlags : UINT; + hwnd : HWND; + uId : UINT; + rect : RECT; + hinst : HINST; + lpszText : LPTSTR; + end; + LPTOOLINFO = ^TOOLINFO; + TTOOLINFO = TOOLINFO; + PTOOLINFO = ^TOOLINFO; + + TOOLTIPTEXT = record + hdr : NMHDR; + lpszText : LPTSTR; + szText : array[0..79] of char; + hinst : HINST; + uFlags : UINT; + end; + LPTOOLTIPTEXT = ^TOOLTIPTEXT; + TTOOLTIPTEXT = TOOLTIPTEXT; + PTOOLTIPTEXT = ^TOOLTIPTEXT; + + TPMPARAMS = record + cbSize : UINT; + rcExclude : RECT; + end; + LPTPMPARAMS = ^TPMPARAMS; + tagTPMPARAMS = TPMPARAMS; + TTPMPARAMS = TPMPARAMS; + PTPMPARAMS = ^TPMPARAMS; + + TRANSMIT_FILE_BUFFERS = record + Head : PVOID; + HeadLength : DWORD; + Tail : PVOID; + TailLength : DWORD; + end; + _TRANSMIT_FILE_BUFFERS = TRANSMIT_FILE_BUFFERS; + TTRANSMITFILEBUFFERS = TRANSMIT_FILE_BUFFERS; + PTRANSMITFILEBUFFERS = ^TRANSMIT_FILE_BUFFERS; + + TTHITTESTINFO = record + hwnd : HWND; + pt : POINT; + ti : TOOLINFO; + end; + LPHITTESTINFO = ^TTHITTESTINFO; + _TT_HITTESTINFO = TTHITTESTINFO; + TTTHITTESTINFO = TTHITTESTINFO; + PTTHITTESTINFO = ^TTHITTESTINFO; + + TTPOLYCURVE = record + wType : WORD; + cpfx : WORD; + apfx : array[0..0] of POINTFX; + end; + LPTTPOLYCURVE = ^TTPOLYCURVE; + tagTTPOLYCURVE = TTPOLYCURVE; + TTTPOLYCURVE = TTPOLYCURVE; + PTTPOLYCURVE = ^TTPOLYCURVE; + + TTPOLYGONHEADER = record + cb : DWORD; + dwType : DWORD; + pfxStart : POINTFX; + end; + LPTTPOLYGONHEADER = ^TTPOLYGONHEADER; + _TTPOLYGONHEADER = TTPOLYGONHEADER; + TTTPOLYGONHEADER = TTPOLYGONHEADER; + PTTPOLYGONHEADER = ^TTPOLYGONHEADER; + + TV_DISPINFO = record + hdr : NMHDR; + item : TV_ITEM; + end; + _TV_DISPINFO = TV_DISPINFO; + TTVDISPINFO = TV_DISPINFO; + PTVDISPINFO = ^TV_DISPINFO; + + TV_HITTESTINFO = record + pt : POINT; + flags : UINT; + hItem : HTREEITEM; + end; + LPTV_HITTESTINFO = ^TV_HITTESTINFO; + _TVHITTESTINFO = TV_HITTESTINFO; + TTVHITTESTINFO = TV_HITTESTINFO; + PTVHITTESTINFO = ^TV_HITTESTINFO; + + TV_INSERTSTRUCT = record + hParent : HTREEITEM; + hInsertAfter : HTREEITEM; + item : TV_ITEM; + end; + LPTV_INSERTSTRUCT = ^TV_INSERTSTRUCT; + _TV_INSERTSTRUCT = TV_INSERTSTRUCT; + TTVINSERTSTRUCT = TV_INSERTSTRUCT; + PTVINSERTSTRUCT = ^TV_INSERTSTRUCT; + + TV_KEYDOWN = record + hdr : NMHDR; + wVKey : WORD; + flags : UINT; + end; + _TV_KEYDOWN = TV_KEYDOWN; + TTVKEYDOWN = TV_KEYDOWN; + PTVKEYDOWN = ^TV_KEYDOWN; + + TV_SORTCB = record + hParent : HTREEITEM; + lpfnCompare : PFNTVCOMPARE; + lParam : LPARAM; + end; + LPTV_SORTCB = ^TV_SORTCB; + _TV_SORTCB = TV_SORTCB; + TTVSORTCB = TV_SORTCB; + PTVSORTCB = ^TV_SORTCB; + + UDACCEL = record + nSec : UINT; + nInc : UINT; + end; + TUDACCEL = UDACCEL; + PUDACCEL = ^UDACCEL; + + + UNIVERSAL_NAME_INFO = record + lpUniversalName : LPTSTR; + end; + _UNIVERSAL_NAME_INFO = UNIVERSAL_NAME_INFO; + TUNIVERSALNAMEINFO = UNIVERSAL_NAME_INFO; + PUNIVERSALNAMEINFO = ^UNIVERSAL_NAME_INFO; + + USEROBJECTFLAGS = record + fInherit : WINBOOL; + fReserved : WINBOOL; + dwFlags : DWORD; + end; + tagUSEROBJECTFLAGS = USEROBJECTFLAGS; + TUSEROBJECTFLAGS = USEROBJECTFLAGS; + PUSEROBJECTFLAGS = ^USEROBJECTFLAGS; + + VALENT = record + ve_valuename : LPTSTR; + ve_valuelen : DWORD; + ve_valueptr : DWORD; + ve_type : DWORD; + end; + TVALENT = VALENT; + PVALENT = ^VALENT; + + value_ent = VALENT; + Tvalue_ent = VALENT; + Pvalue_ent = ^VALENT; + + VERIFY_INFORMATION = record + StartingOffset : LARGE_INTEGER; + Length : DWORD; + end; + _VERIFY_INFORMATION = VERIFY_INFORMATION; + TVERIFYINFORMATION = VERIFY_INFORMATION; + PVERIFYINFORMATION = ^VERIFY_INFORMATION; + + VS_FIXEDFILEINFO = record + dwSignature : DWORD; + dwStrucVersion : DWORD; + dwFileVersionMS : DWORD; + dwFileVersionLS : DWORD; + dwProductVersionMS : DWORD; + dwProductVersionLS : DWORD; + dwFileFlagsMask : DWORD; + dwFileFlags : DWORD; + dwFileOS : DWORD; + dwFileType : DWORD; + dwFileSubtype : DWORD; + dwFileDateMS : DWORD; + dwFileDateLS : DWORD; + end; + _VS_FIXEDFILEINFO = VS_FIXEDFILEINFO; + TVSFIXEDFILEINFO = VS_FIXEDFILEINFO; + PVSFIXEDFILEINFO = ^VS_FIXEDFILEINFO; + + WIN32_FIND_DATA = record + dwFileAttributes : DWORD; + ftCreationTime : FILETIME; + ftLastAccessTime : FILETIME; + ftLastWriteTime : FILETIME; + nFileSizeHigh : DWORD; + nFileSizeLow : DWORD; + dwReserved0 : DWORD; + dwReserved1 : DWORD; + cFileName : array[0..(MAX_PATH)-1] of TCHAR; + cAlternateFileName : array[0..13] of TCHAR; + end; + LPWIN32_FIND_DATA = ^WIN32_FIND_DATA; + PWIN32_FIND_DATA = ^WIN32_FIND_DATA; + _WIN32_FIND_DATA = WIN32_FIND_DATA; + TWIN32FINDDATA = WIN32_FIND_DATA; + TWIN32FINDDATAA = WIN32_FIND_DATA; + PWIN32FINDDATA = ^WIN32_FIND_DATA; + + WIN32_FIND_DATAW = record + dwFileAttributes : DWORD; + ftCreationTime : FILETIME; + ftLastAccessTime : FILETIME; + ftLastWriteTime : FILETIME; + nFileSizeHigh : DWORD; + nFileSizeLow : DWORD; + dwReserved0 : DWORD; + dwReserved1 : DWORD; + cFileName : array[0..(MAX_PATH)-1] of WCHAR; + cAlternateFileName : array[0..13] of WCHAR; + end; + LPWIN32_FIND_DATAW = ^WIN32_FIND_DATAW; + PWIN32_FIND_DATAW = ^WIN32_FIND_DATAW; + _WIN32_FIND_DATAW = WIN32_FIND_DATAW; + TWIN32FINDDATAW = WIN32_FIND_DATAW; + PWIN32FINDDATAW = ^WIN32_FIND_DATAW; + + WIN32_STREAM_ID = record + dwStreamId : DWORD; + dwStreamAttributes : DWORD; + Size : LARGE_INTEGER; + dwStreamNameSize : DWORD; + cStreamName : ^WCHAR; + end; + _WIN32_STREAM_ID = WIN32_STREAM_ID; + TWIN32STREAMID = WIN32_STREAM_ID; + PWIN32STREAMID = ^WIN32_STREAM_ID; + + WINDOWPLACEMENT = record + length : UINT; + flags : UINT; + showCmd : UINT; + ptMinPosition : POINT; + ptMaxPosition : POINT; + rcNormalPosition : RECT; + end; + _WINDOWPLACEMENT = WINDOWPLACEMENT; + TWINDOWPLACEMENT = WINDOWPLACEMENT; + PWINDOWPLACEMENT = ^WINDOWPLACEMENT; + + WNDCLASS = record + style : UINT; + lpfnWndProc : WNDPROC; + cbClsExtra : longint; + cbWndExtra : longint; + hInstance : HANDLE; + hIcon : HICON; + hCursor : HCURSOR; + hbrBackground : HBRUSH; + lpszMenuName : LPCTSTR; + lpszClassName : LPCTSTR; + end; + LPWNDCLASS = ^WNDCLASS; + _WNDCLASS = WNDCLASS; + TWNDCLASS = WNDCLASS; + TWNDCLASSA = WNDCLASS; + PWNDCLASS = ^WNDCLASS; + + + WNDCLASSW = record + style : UINT; + lpfnWndProc : WNDPROC; + cbClsExtra : longint; + cbWndExtra : longint; + hInstance : HANDLE; + hIcon : HICON; + hCursor : HCURSOR; + hbrBackground : HBRUSH; + lpszMenuName : LPCWSTR; + lpszClassName : LPCWSTR; + end; + LPWNDCLASSW = ^WNDCLASSW; + _WNDCLASSW = WNDCLASSW; + TWNDCLASSW = WNDCLASSW; + PWNDCLASSW = ^WNDCLASSW; + + WNDCLASSEX = record + cbSize : UINT; + style : UINT; + lpfnWndProc : WNDPROC; + cbClsExtra : longint; + cbWndExtra : longint; + hInstance : HANDLE; + hIcon : HICON; + hCursor : HCURSOR; + hbrBackground : HBRUSH; + lpszMenuName : LPCTSTR; + lpszClassName : LPCTSTR; + hIconSm : HANDLE; + end; + LPWNDCLASSEX = ^WNDCLASSEX; + _WNDCLASSEX = WNDCLASSEX; + TWNDCLASSEX = WNDCLASSEX; + TWNDCLASSEXA = WNDCLASSEX; + PWNDCLASSEX = ^WNDCLASSEX; + + WNDCLASSEXW = record + cbSize : UINT; + style : UINT; + lpfnWndProc : WNDPROC; + cbClsExtra : longint; + cbWndExtra : longint; + hInstance : HANDLE; + hIcon : HICON; + hCursor : HCURSOR; + hbrBackground : HBRUSH; + lpszMenuName : LPCWSTR; + lpszClassName : LPCWSTR; + hIconSm : HANDLE; + end; + LPWNDCLASSEXW = ^WNDCLASSEXW; + _WNDCLASSEXW = WNDCLASSEXW; + TWNDCLASSEXW = WNDCLASSEXW; + PWNDCLASSEXW = ^WNDCLASSEXW; + + CONNECTDLGSTRUCT = record + cbStructure : DWORD; + hwndOwner : HWND; + lpConnRes : LPNETRESOURCE; + dwFlags : DWORD; + dwDevNum : DWORD; + end; + LPCONNECTDLGSTRUCT = ^CONNECTDLGSTRUCT; + _CONNECTDLGSTRUCT = CONNECTDLGSTRUCT; + TCONNECTDLGSTRUCT = CONNECTDLGSTRUCT; + PCONNECTDLGSTRUCT = ^CONNECTDLGSTRUCT; + + CONNECTDLGSTRUCTW = record //+winnetwk + cbStructure : DWORD; + hwndOwner : HWND; + lpConnRes : LPNETRESOURCEW; + dwFlags : DWORD; + dwDevNum : DWORD; + end; + LPCONNECTDLGSTRUCTW = ^CONNECTDLGSTRUCTW; //+winnetwk + _CONNECTDLGSTRUCTW = CONNECTDLGSTRUCTW; //+winnetwk + + DISCDLGSTRUCT = record + cbStructure : DWORD; + hwndOwner : HWND; + lpLocalName : LPTSTR; + lpRemoteName : LPTSTR; + dwFlags : DWORD; + end; + LPDISCDLGSTRUCT = ^DISCDLGSTRUCT; + _DISCDLGSTRUCT = DISCDLGSTRUCT; + TDISCDLGSTRUCT = DISCDLGSTRUCT; + TDISCDLGSTRUCTA = DISCDLGSTRUCT; + PDISCDLGSTRUCT = ^DISCDLGSTRUCT; + + DISCDLGSTRUCTW = record //+winnetwk + cbStructure : DWORD; + hwndOwner : HWND; + lpLocalName : LPWSTR; + lpRemoteName : LPWSTR; + dwFlags : DWORD; + end; + LPDISCDLGSTRUCTW = ^DISCDLGSTRUCTW; //+winnetwk + _DISCDLGSTRUCTW = DISCDLGSTRUCTW; //+winnetwk + + NETINFOSTRUCT = record + cbStructure : DWORD; + dwProviderVersion : DWORD; + dwStatus : DWORD; + dwCharacteristics : DWORD; + dwHandle : DWORD; + wNetType : WORD; + dwPrinters : DWORD; + dwDrives : DWORD; + end; + LPNETINFOSTRUCT = ^NETINFOSTRUCT; + _NETINFOSTRUCT = NETINFOSTRUCT; + TNETINFOSTRUCT = NETINFOSTRUCT; + PNETINFOSTRUCT = ^NETINFOSTRUCT; + + NETCONNECTINFOSTRUCT = record + cbStructure : DWORD; + dwFlags : DWORD; + dwSpeed : DWORD; + dwDelay : DWORD; + dwOptDataSize : DWORD; + end; + LPNETCONNECTINFOSTRUCT = ^NETCONNECTINFOSTRUCT; + _NETCONNECTINFOSTRUCT = NETCONNECTINFOSTRUCT; + TNETCONNECTINFOSTRUCT = NETCONNECTINFOSTRUCT; + PNETCONNECTINFOSTRUCT = ^NETCONNECTINFOSTRUCT; + + ENUMMETAFILEPROC = function (_para1:HDC; _para2:HANDLETABLE; _para3:METARECORD; _para4:longint; _para5:LPARAM):longint;stdcall; + + ENHMETAFILEPROC = function (_para1:HDC; _para2:HANDLETABLE; _para3:ENHMETARECORD; _para4:longint; _para5:LPARAM):longint;stdcall; + + ENUMFONTSPROC = function (_para1:LPLOGFONT; _para2:LPTEXTMETRIC; _para3:DWORD; _para4:LPARAM):longint;stdcall; + + FONTENUMPROC = function (var _para1:ENUMLOGFONT; var _para2:NEWTEXTMETRIC; _para3:longint; _para4:LPARAM):longint;stdcall; + + FONTENUMEXPROC = function (var _para1:ENUMLOGFONTEX;var _para2:NEWTEXTMETRICEX; _para3:longint; _para4:LPARAM):longint;stdcall; + + LPOVERLAPPED_COMPLETION_ROUTINE = procedure (_para1:DWORD; _para2:DWORD; _para3:LPOVERLAPPED);stdcall; + + { Structures for the extensions to OpenGL } + + POINTFLOAT = record + x : Single; + y : Single; + end; + _POINTFLOAT = POINTFLOAT; + TPOINTFLOAT = POINTFLOAT; + PPOINTFLOAT = ^POINTFLOAT; + + GLYPHMETRICSFLOAT = record + gmfBlackBoxX : Single; + gmfBlackBoxY : Single; + gmfptGlyphOrigin : POINTFLOAT; + gmfCellIncX : Single; + gmfCellIncY : Single; + end; + LPGLYPHMETRICSFLOAT = ^GLYPHMETRICSFLOAT; + _GLYPHMETRICSFLOAT = GLYPHMETRICSFLOAT; + TGLYPHMETRICSFLOAT = GLYPHMETRICSFLOAT; + PGLYPHMETRICSFLOAT = ^GLYPHMETRICSFLOAT; + + LAYERPLANEDESCRIPTOR = record + nSize : WORD; + nVersion : WORD; + dwFlags : DWORD; + iPixelType : BYTE; + cColorBits : BYTE; + cRedBits : BYTE; + cRedShift : BYTE; + cGreenBits : BYTE; + cGreenShift : BYTE; + cBlueBits : BYTE; + cBlueShift : BYTE; + cAlphaBits : BYTE; + cAlphaShift : BYTE; + cAccumBits : BYTE; + cAccumRedBits : BYTE; + cAccumGreenBits : BYTE; + cAccumBlueBits : BYTE; + cAccumAlphaBits : BYTE; + cDepthBits : BYTE; + cStencilBits : BYTE; + cAuxBuffers : BYTE; + iLayerPlane : BYTE; + bReserved : BYTE; + crTransparent : COLORREF; + end; + LPLAYERPLANEDESCRIPTOR = ^LAYERPLANEDESCRIPTOR; + tagLAYERPLANEDESCRIPTOR = LAYERPLANEDESCRIPTOR; + TLAYERPLANEDESCRIPTOR = LAYERPLANEDESCRIPTOR; + PLAYERPLANEDESCRIPTOR = ^LAYERPLANEDESCRIPTOR; + + PIXELFORMATDESCRIPTOR = record + nSize : WORD; + nVersion : WORD; + dwFlags : DWORD; + iPixelType : BYTE; + cColorBits : BYTE; + cRedBits : BYTE; + cRedShift : BYTE; + cGreenBits : BYTE; + cGreenShift : BYTE; + cBlueBits : BYTE; + cBlueShift : BYTE; + cAlphaBits : BYTE; + cAlphaShift : BYTE; + cAccumBits : BYTE; + cAccumRedBits : BYTE; + cAccumGreenBits : BYTE; + cAccumBlueBits : BYTE; + cAccumAlphaBits : BYTE; + cDepthBits : BYTE; + cStencilBits : BYTE; + cAuxBuffers : BYTE; + iLayerType : BYTE; + bReserved : BYTE; + dwLayerMask : DWORD; + dwVisibleMask : DWORD; + dwDamageMask : DWORD; + end; + LPPIXELFORMATDESCRIPTOR = ^PIXELFORMATDESCRIPTOR; + tagPIXELFORMATDESCRIPTOR = PIXELFORMATDESCRIPTOR; + TPIXELFORMATDESCRIPTOR = PIXELFORMATDESCRIPTOR; + PPIXELFORMATDESCRIPTOR = ^PIXELFORMATDESCRIPTOR; + + USER_INFO_2 = record + usri2_name : LPWSTR; + usri2_password : LPWSTR; + usri2_password_age : DWORD; + usri2_priv : DWORD; + usri2_home_dir : LPWSTR; + usri2_comment : LPWSTR; + usri2_flags : DWORD; + usri2_script_path : LPWSTR; + usri2_auth_flags : DWORD; + usri2_full_name : LPWSTR; + usri2_usr_comment : LPWSTR; + usri2_parms : LPWSTR; + usri2_workstations : LPWSTR; + usri2_last_logon : DWORD; + usri2_last_logoff : DWORD; + usri2_acct_expires : DWORD; + usri2_max_storage : DWORD; + usri2_units_per_week : DWORD; + usri2_logon_hours : PBYTE; + usri2_bad_pw_count : DWORD; + usri2_num_logons : DWORD; + usri2_logon_server : LPWSTR; + usri2_country_code : DWORD; + usri2_code_page : DWORD; + end; + PUSER_INFO_2 = ^USER_INFO_2; + LPUSER_INFO_2 = ^USER_INFO_2; + TUSERINFO2 = USER_INFO_2; + PUSERINFO2 = ^USER_INFO_2; + + USER_INFO_0 = record + usri0_name : LPWSTR; + end; + PUSER_INFO_0 = ^USER_INFO_0; + LPUSER_INFO_0 = ^USER_INFO_0; + TUSERINFO0 = USER_INFO_0; + PUSERINFO0 = ^USER_INFO_0; + + USER_INFO_3 = record + usri3_name : LPWSTR; + usri3_password : LPWSTR; + usri3_password_age : DWORD; + usri3_priv : DWORD; + usri3_home_dir : LPWSTR; + usri3_comment : LPWSTR; + usri3_flags : DWORD; + usri3_script_path : LPWSTR; + usri3_auth_flags : DWORD; + usri3_full_name : LPWSTR; + usri3_usr_comment : LPWSTR; + usri3_parms : LPWSTR; + usri3_workstations : LPWSTR; + usri3_last_logon : DWORD; + usri3_last_logoff : DWORD; + usri3_acct_expires : DWORD; + usri3_max_storage : DWORD; + usri3_units_per_week : DWORD; + usri3_logon_hours : PBYTE; + usri3_bad_pw_count : DWORD; + usri3_num_logons : DWORD; + usri3_logon_server : LPWSTR; + usri3_country_code : DWORD; + usri3_code_page : DWORD; + usri3_user_id : DWORD; + usri3_primary_group_id : DWORD; + usri3_profile : LPWSTR; + usri3_home_dir_drive : LPWSTR; + usri3_password_expired : DWORD; + end; + PUSER_INFO_3 = ^USER_INFO_3; + LPUSER_INFO_3 = ^USER_INFO_3; + TUSERINFO3 = USER_INFO_3; + PUSERINFO3 = ^USER_INFO_3; + + GROUP_INFO_2 = record + grpi2_name : LPWSTR; + grpi2_comment : LPWSTR; + grpi2_group_id : DWORD; + grpi2_attributes : DWORD; + end; + PGROUP_INFO_2 = ^GROUP_INFO_2; + TGROUPINFO2 = GROUP_INFO_2; + PGROUPINFO2 = ^GROUP_INFO_2; + + LOCALGROUP_INFO_0 = record + lgrpi0_name : LPWSTR; + end; + PLOCALGROUP_INFO_0 = ^LOCALGROUP_INFO_0; + LPLOCALGROUP_INFO_0 = ^LOCALGROUP_INFO_0; + TLOCALGROUPINFO0 = LOCALGROUP_INFO_0; + PLOCALGROUPINFO0 = ^LOCALGROUP_INFO_0; + + { PE executable header. } + { Magic number, 0x5a4d } + { Bytes on last page of file, 0x90 } + { Pages in file, 0x3 } + { Relocations, 0x0 } + { Size of header in paragraphs, 0x4 } + { Minimum extra paragraphs needed, 0x0 } + { Maximum extra paragraphs needed, 0xFFFF } + { Initial (relative) SS value, 0x0 } + { Initial SP value, 0xb8 } + { Checksum, 0x0 } + { Initial IP value, 0x0 } + { Initial (relative) CS value, 0x0 } + { File address of relocation table, 0x40 } + { Overlay number, 0x0 } + { Reserved words, all 0x0 } + { OEM identifier (for e_oeminfo), 0x0 } + { OEM information; e_oemid specific, 0x0 } + { Reserved words, all 0x0 } + { File address of new exe header, 0x80 } + { We leave out the next two fields, since they aren't in the header file } + { DWORD dos_message[16]; text which always follows dos header } + { DWORD nt_signature; required NT signature, 0x4550 } + + IMAGE_DOS_HEADER = record + e_magic : WORD; + e_cblp : WORD; + e_cp : WORD; + e_crlc : WORD; + e_cparhdr : WORD; + e_minalloc : WORD; + e_maxalloc : WORD; + e_ss : WORD; + e_sp : WORD; + e_csum : WORD; + e_ip : WORD; + e_cs : WORD; + e_lfarlc : WORD; + e_ovno : WORD; + e_res : array[0..3] of WORD; + e_oemid : WORD; + e_oeminfo : WORD; + e_res2 : array[0..9] of WORD; + e_lfanew : LONG; + end; + PIMAGE_DOS_HEADER = ^IMAGE_DOS_HEADER; + TIMAGEDOSHEADER = IMAGE_DOS_HEADER; + PIMAGEDOSHEADER = ^IMAGE_DOS_HEADER; + + _NOTIFYICONDATAA = record + cbSize: DWORD; + Wnd: HWND; + uID: UINT; + uFlags: UINT; + uCallbackMessage: UINT; + hIcon: HICON; + szTip: array [0..63] of Char; + end; + _NOTIFYICONDATA = _NOTIFYICONDATAA; + + _NOTIFYICONDATAW = record + cbSize: DWORD; + Wnd: HWND; + uID: UINT; + uFlags: UINT; + uCallbackMessage: UINT; + hIcon: HICON; + szTip: array [0..63] of Word; + end; + TNotifyIconDataA = _NOTIFYICONDATAA; + TNotifyIconDataW = _NOTIFYICONDATAW; + TNotifyIconData = TNotifyIconDataA; + NOTIFYICONDATAA = _NOTIFYICONDATAA; + NOTIFYICONDATAW = _NOTIFYICONDATAW; + NOTIFYICONDATA = NOTIFYICONDATAA; + PNotifyIconDataA = ^TNotifyIconDataA; + PNotifyIconDataW = ^TNotifyIconDataW; + PNotifyIconData = PNotifyIconDataA; + + TWOHandleArray = array[0..MAXIMUM_WAIT_OBJECTS-1] of HANDLE; + PWOHandleArray = ^TWOHandleArray; + + MMRESULT = Longint; + +type + PWaveFormatEx = ^TWaveFormatEx; + TWaveFormatEx = packed record + wFormatTag: Word; { format type } + nChannels: Word; { number of channels (i.e. mono, stereo, etc.) } + nSamplesPerSec: DWORD; { sample rate } + nAvgBytesPerSec: DWORD; { for buffer estimation } + nBlockAlign: Word; { block size of data } + wBitsPerSample: Word; { number of bits per sample of mono data } + cbSize: Word; { the count in bytes of the size of } + end; + + _WIN32_FILE_ATTRIBUTE_DATA = packed record + dwFileAttributes: DWORD; + ftCreationTime: FILETIME; + ftLastAccessTime: FILETIME; + ftLastWriteTime: FILETIME; + nFileSizeHigh: DWORD; + nFileSizeLow: DWORD; + end; + WIN32_FILE_ATTRIBUTE_DATA = _WIN32_FILE_ATTRIBUTE_DATA ; + LPWIN32_FILE_ATTRIBUTE_DATA = ^_WIN32_FILE_ATTRIBUTE_DATA; + TWIN32FILEATTRIBUTEDATA = _WIN32_FILE_ATTRIBUTE_DATA ; + PWIN32FILEATTRIBUTEDATA = ^_WIN32_FILE_ATTRIBUTE_DATA; + + // TrackMouseEvent. NT or higher only. + TTrackMouseEvent = Record + cbSize : DWORD; + dwFlags : DWORD; + hwndTrack : HWND; + dwHoverTime : DWORD; + end; + PTrackMouseEvent = ^TTrackMouseEvent; + +{$endif read_interface} + + +{$ifdef read_implementation} + + function fBinary(var a : DCB) : DWORD; + begin + fBinary:=(a.flags and bm_DCB_fBinary) shr bp_DCB_fBinary; + end; + + procedure set_fBinary(var a : DCB; __fBinary : DWORD); + begin + a.flags:=a.flags or ((__fBinary shl bp_DCB_fBinary) and bm_DCB_fBinary); + end; + + function fParity(var a : DCB) : DWORD; + begin + fParity:=(a.flags and bm_DCB_fParity) shr bp_DCB_fParity; + end; + + procedure set_fParity(var a : DCB; __fParity : DWORD); + begin + a.flags:=a.flags or ((__fParity shl bp_DCB_fParity) and bm_DCB_fParity); + end; + + function fOutxCtsFlow(var a : DCB) : DWORD; + begin + fOutxCtsFlow:=(a.flags and bm_DCB_fOutxCtsFlow) shr bp_DCB_fOutxCtsFlow; + end; + + procedure set_fOutxCtsFlow(var a : DCB; __fOutxCtsFlow : DWORD); + begin + a.flags:=a.flags or ((__fOutxCtsFlow shl bp_DCB_fOutxCtsFlow) and bm_DCB_fOutxCtsFlow); + end; + + function fOutxDsrFlow(var a : DCB) : DWORD; + begin + fOutxDsrFlow:=(a.flags and bm_DCB_fOutxDsrFlow) shr bp_DCB_fOutxDsrFlow; + end; + + procedure set_fOutxDsrFlow(var a : DCB; __fOutxDsrFlow : DWORD); + begin + a.flags:=a.flags or ((__fOutxDsrFlow shl bp_DCB_fOutxDsrFlow) and bm_DCB_fOutxDsrFlow); + end; + + function fDtrControl(var a : DCB) : DWORD; + begin + fDtrControl:=(a.flags and bm_DCB_fDtrControl) shr bp_DCB_fDtrControl; + end; + + procedure set_fDtrControl(var a : DCB; __fDtrControl : DWORD); + begin + a.flags:=a.flags or ((__fDtrControl shl bp_DCB_fDtrControl) and bm_DCB_fDtrControl); + end; + + function fDsrSensitivity(var a : DCB) : DWORD; + begin + fDsrSensitivity:=(a.flags and bm_DCB_fDsrSensitivity) shr bp_DCB_fDsrSensitivity; + end; + + procedure set_fDsrSensitivity(var a : DCB; __fDsrSensitivity : DWORD); + begin + a.flags:=a.flags or ((__fDsrSensitivity shl bp_DCB_fDsrSensitivity) and bm_DCB_fDsrSensitivity); + end; + + function fTXContinueOnXoff(var a : DCB) : DWORD; + begin + fTXContinueOnXoff:=(a.flags and bm_DCB_fTXContinueOnXoff) shr bp_DCB_fTXContinueOnXoff; + end; + + procedure set_fTXContinueOnXoff(var a : DCB; __fTXContinueOnXoff : DWORD); + begin + a.flags:=a.flags or ((__fTXContinueOnXoff shl bp_DCB_fTXContinueOnXoff) and bm_DCB_fTXContinueOnXoff); + end; + + function fOutX(var a : DCB) : DWORD; + begin + fOutX:=(a.flags and bm_DCB_fOutX) shr bp_DCB_fOutX; + end; + + procedure set_fOutX(var a : DCB; __fOutX : DWORD); + begin + a.flags:=a.flags or ((__fOutX shl bp_DCB_fOutX) and bm_DCB_fOutX); + end; + + function fInX(var a : DCB) : DWORD; + begin + fInX:=(a.flags and bm_DCB_fInX) shr bp_DCB_fInX; + end; + + procedure set_fInX(var a : DCB; __fInX : DWORD); + begin + a.flags:=a.flags or ((__fInX shl bp_DCB_fInX) and bm_DCB_fInX); + end; + + function fErrorChar(var a : DCB) : DWORD; + begin + fErrorChar:=(a.flags and bm_DCB_fErrorChar) shr bp_DCB_fErrorChar; + end; + + procedure set_fErrorChar(var a : DCB; __fErrorChar : DWORD); + begin + a.flags:=a.flags or ((__fErrorChar shl bp_DCB_fErrorChar) and bm_DCB_fErrorChar); + end; + + function fNull(var a : DCB) : DWORD; + begin + fNull:=(a.flags and bm_DCB_fNull) shr bp_DCB_fNull; + end; + + procedure set_fNull(var a : DCB; __fNull : DWORD); + begin + a.flags:=a.flags or ((__fNull shl bp_DCB_fNull) and bm_DCB_fNull); + end; + + function fRtsControl(var a : DCB) : DWORD; + begin + fRtsControl:=(a.flags and bm_DCB_fRtsControl) shr bp_DCB_fRtsControl; + end; + + procedure set_fRtsControl(var a : DCB; __fRtsControl : DWORD); + begin + a.flags:=a.flags or ((__fRtsControl shl bp_DCB_fRtsControl) and bm_DCB_fRtsControl); + end; + + function fAbortOnError(var a : DCB) : DWORD; + begin + fAbortOnError:=(a.flags and bm_DCB_fAbortOnError) shr bp_DCB_fAbortOnError; + end; + + procedure set_fAbortOnError(var a : DCB; __fAbortOnError : DWORD); + begin + a.flags:=a.flags or ((__fAbortOnError shl bp_DCB_fAbortOnError) and bm_DCB_fAbortOnError); + end; + + function fDummy2(var a : DCB) : DWORD; + begin + fDummy2:=(a.flags and bm_DCB_fDummy2) shr bp_DCB_fDummy2; + end; + + procedure set_fDummy2(var a : DCB; __fDummy2 : DWORD); + begin + a.flags:=a.flags or ((__fDummy2 shl bp_DCB_fDummy2) and bm_DCB_fDummy2); + end; + + function fCtsHold(var a : COMSTAT) : DWORD; + begin + fCtsHold:=(a.flag0 and bm_COMSTAT_fCtsHold) shr bp_COMSTAT_fCtsHold; + end; + + procedure set_fCtsHold(var a : COMSTAT; __fCtsHold : DWORD); + begin + a.flag0:=a.flag0 or ((__fCtsHold shl bp_COMSTAT_fCtsHold) and bm_COMSTAT_fCtsHold); + end; + + function fDsrHold(var a : COMSTAT) : DWORD; + begin + fDsrHold:=(a.flag0 and bm_COMSTAT_fDsrHold) shr bp_COMSTAT_fDsrHold; + end; + + procedure set_fDsrHold(var a : COMSTAT; __fDsrHold : DWORD); + begin + a.flag0:=a.flag0 or ((__fDsrHold shl bp_COMSTAT_fDsrHold) and bm_COMSTAT_fDsrHold); + end; + + function fRlsdHold(var a : COMSTAT) : DWORD; + begin + fRlsdHold:=(a.flag0 and bm_COMSTAT_fRlsdHold) shr bp_COMSTAT_fRlsdHold; + end; + + procedure set_fRlsdHold(var a : COMSTAT; __fRlsdHold : DWORD); + begin + a.flag0:=a.flag0 or ((__fRlsdHold shl bp_COMSTAT_fRlsdHold) and bm_COMSTAT_fRlsdHold); + end; + + function fXoffHold(var a : COMSTAT) : DWORD; + begin + fXoffHold:=(a.flag0 and bm_COMSTAT_fXoffHold) shr bp_COMSTAT_fXoffHold; + end; + + procedure set_fXoffHold(var a : COMSTAT; __fXoffHold : DWORD); + begin + a.flag0:=a.flag0 or ((__fXoffHold shl bp_COMSTAT_fXoffHold) and bm_COMSTAT_fXoffHold); + end; + + function fXoffSent(var a : COMSTAT) : DWORD; + begin + fXoffSent:=(a.flag0 and bm_COMSTAT_fXoffSent) shr bp_COMSTAT_fXoffSent; + end; + + procedure set_fXoffSent(var a : COMSTAT; __fXoffSent : DWORD); + begin + a.flag0:=a.flag0 or ((__fXoffSent shl bp_COMSTAT_fXoffSent) and bm_COMSTAT_fXoffSent); + end; + + function fEof(var a : COMSTAT) : DWORD; + begin + fEof:=(a.flag0 and bm_COMSTAT_fEof) shr bp_COMSTAT_fEof; + end; + + procedure set_fEof(var a : COMSTAT; __fEof : DWORD); + begin + a.flag0:=a.flag0 or ((__fEof shl bp_COMSTAT_fEof) and bm_COMSTAT_fEof); + end; + + function fTxim(var a : COMSTAT) : DWORD; + begin + fTxim:=(a.flag0 and bm_COMSTAT_fTxim) shr bp_COMSTAT_fTxim; + end; + + procedure set_fTxim(var a : COMSTAT; __fTxim : DWORD); + begin + a.flag0:=a.flag0 or ((__fTxim shl bp_COMSTAT_fTxim) and bm_COMSTAT_fTxim); + end; + + function fReserved(var a : COMSTAT) : DWORD; + begin + fReserved:=(a.flag0 and bm_COMSTAT_fReserved) shr bp_COMSTAT_fReserved; + end; + + procedure set_fReserved(var a : COMSTAT; __fReserved : DWORD); + begin + a.flag0:=a.flag0 or ((__fReserved shl bp_COMSTAT_fReserved) and bm_COMSTAT_fReserved); + end; + + function bAppReturnCode(var a : DDEACK) : word; + begin + bAppReturnCode:=(a.flag0 and bm_DDEACK_bAppReturnCode) shr bp_DDEACK_bAppReturnCode; + end; + + procedure set_bAppReturnCode(var a : DDEACK; __bAppReturnCode : word); + begin + a.flag0:=a.flag0 or ((__bAppReturnCode shl bp_DDEACK_bAppReturnCode) and bm_DDEACK_bAppReturnCode); + end; + + function reserved(var a : DDEACK) : word; + begin + reserved:=(a.flag0 and bm_DDEACK_reserved) shr bp_DDEACK_reserved; + end; + + procedure set_reserved(var a : DDEACK; __reserved : word); + begin + a.flag0:=a.flag0 or ((__reserved shl bp_DDEACK_reserved) and bm_DDEACK_reserved); + end; + + function fBusy(var a : DDEACK) : word; + begin + fBusy:=(a.flag0 and bm_DDEACK_fBusy) shr bp_DDEACK_fBusy; + end; + + procedure set_fBusy(var a : DDEACK; __fBusy : word); + begin + a.flag0:=a.flag0 or ((__fBusy shl bp_DDEACK_fBusy) and bm_DDEACK_fBusy); + end; + + function fAck(var a : DDEACK) : word; + begin + fAck:=(a.flag0 and bm_DDEACK_fAck) shr bp_DDEACK_fAck; + end; + + procedure set_fAck(var a : DDEACK; __fAck : word); + begin + a.flag0:=a.flag0 or ((__fAck shl bp_DDEACK_fAck) and bm_DDEACK_fAck); + end; + + function reserved(var a : DDEADVISE) : word; + begin + reserved:=(a.flag0 and bm_DDEADVISE_reserved) shr bp_DDEADVISE_reserved; + end; + + procedure set_reserved(var a : DDEADVISE; __reserved : word); + begin + a.flag0:=a.flag0 or ((__reserved shl bp_DDEADVISE_reserved) and bm_DDEADVISE_reserved); + end; + + function fDeferUpd(var a : DDEADVISE) : word; + begin + fDeferUpd:=(a.flag0 and bm_DDEADVISE_fDeferUpd) shr bp_DDEADVISE_fDeferUpd; + end; + + procedure set_fDeferUpd(var a : DDEADVISE; __fDeferUpd : word); + begin + a.flag0:=a.flag0 or ((__fDeferUpd shl bp_DDEADVISE_fDeferUpd) and bm_DDEADVISE_fDeferUpd); + end; + + function fAckReq(var a : DDEADVISE) : word; + begin + fAckReq:=(a.flag0 and bm_DDEADVISE_fAckReq) shr bp_DDEADVISE_fAckReq; + end; + + procedure set_fAckReq(var a : DDEADVISE; __fAckReq : word); + begin + a.flag0:=a.flag0 or ((__fAckReq shl bp_DDEADVISE_fAckReq) and bm_DDEADVISE_fAckReq); + end; + + function unused(var a : DDEDATA) : word; + begin + unused:=(a.flag0 and bm_DDEDATA_unused) shr bp_DDEDATA_unused; + end; + + procedure set_unused(var a : DDEDATA; __unused : word); + begin + a.flag0:=a.flag0 or ((__unused shl bp_DDEDATA_unused) and bm_DDEDATA_unused); + end; + + function fResponse(var a : DDEDATA) : word; + begin + fResponse:=(a.flag0 and bm_DDEDATA_fResponse) shr bp_DDEDATA_fResponse; + end; + + procedure set_fResponse(var a : DDEDATA; __fResponse : word); + begin + a.flag0:=a.flag0 or ((__fResponse shl bp_DDEDATA_fResponse) and bm_DDEDATA_fResponse); + end; + + function fRelease(var a : DDEDATA) : word; + begin + fRelease:=(a.flag0 and bm_DDEDATA_fRelease) shr bp_DDEDATA_fRelease; + end; + + procedure set_fRelease(var a : DDEDATA; __fRelease : word); + begin + a.flag0:=a.flag0 or ((__fRelease shl bp_DDEDATA_fRelease) and bm_DDEDATA_fRelease); + end; + + function reserved(var a : DDEDATA) : word; + begin + reserved:=(a.flag0 and bm_DDEDATA_reserved) shr bp_DDEDATA_reserved; + end; + + procedure set_reserved(var a : DDEDATA; __reserved : word); + begin + a.flag0:=a.flag0 or ((__reserved shl bp_DDEDATA_reserved) and bm_DDEDATA_reserved); + end; + + function fAckReq(var a : DDEDATA) : word; + begin + fAckReq:=(a.flag0 and bm_DDEDATA_fAckReq) shr bp_DDEDATA_fAckReq; + end; + + procedure set_fAckReq(var a : DDEDATA; __fAckReq : word); + begin + a.flag0:=a.flag0 or ((__fAckReq shl bp_DDEDATA_fAckReq) and bm_DDEDATA_fAckReq); + end; + + function unused(var a : DDELN) : word; + begin + unused:=(a.flag0 and bm_DDELN_unused) shr bp_DDELN_unused; + end; + + procedure set_unused(var a : DDELN; __unused : word); + begin + a.flag0:=a.flag0 or ((__unused shl bp_DDELN_unused) and bm_DDELN_unused); + end; + + function fRelease(var a : DDELN) : word; + begin + fRelease:=(a.flag0 and bm_DDELN_fRelease) shr bp_DDELN_fRelease; + end; + + procedure set_fRelease(var a : DDELN; __fRelease : word); + begin + a.flag0:=a.flag0 or ((__fRelease shl bp_DDELN_fRelease) and bm_DDELN_fRelease); + end; + + function fDeferUpd(var a : DDELN) : word; + begin + fDeferUpd:=(a.flag0 and bm_DDELN_fDeferUpd) shr bp_DDELN_fDeferUpd; + end; + + procedure set_fDeferUpd(var a : DDELN; __fDeferUpd : word); + begin + a.flag0:=a.flag0 or ((__fDeferUpd shl bp_DDELN_fDeferUpd) and bm_DDELN_fDeferUpd); + end; + + function fAckReq(var a : DDELN) : word; + begin + fAckReq:=(a.flag0 and bm_DDELN_fAckReq) shr bp_DDELN_fAckReq; + end; + + procedure set_fAckReq(var a : DDELN; __fAckReq : word); + begin + a.flag0:=a.flag0 or ((__fAckReq shl bp_DDELN_fAckReq) and bm_DDELN_fAckReq); + end; + + function unused(var a : DDEPOKE) : word; + begin + unused:=(a.flag0 and bm_DDEPOKE_unused) shr bp_DDEPOKE_unused; + end; + + procedure set_unused(var a : DDEPOKE; __unused : word); + begin + a.flag0:=a.flag0 or ((__unused shl bp_DDEPOKE_unused) and bm_DDEPOKE_unused); + end; + + function fRelease(var a : DDEPOKE) : word; + begin + fRelease:=(a.flag0 and bm_DDEPOKE_fRelease) shr bp_DDEPOKE_fRelease; + end; + + procedure set_fRelease(var a : DDEPOKE; __fRelease : word); + begin + a.flag0:=a.flag0 or ((__fRelease shl bp_DDEPOKE_fRelease) and bm_DDEPOKE_fRelease); + end; + + function fReserved(var a : DDEPOKE) : word; + begin + fReserved:=(a.flag0 and bm_DDEPOKE_fReserved) shr bp_DDEPOKE_fReserved; + end; + + procedure set_fReserved(var a : DDEPOKE; __fReserved : word); + begin + a.flag0:=a.flag0 or ((__fReserved shl bp_DDEPOKE_fReserved) and bm_DDEPOKE_fReserved); + end; + + function unused(var a : DDEUP) : word; + begin + unused:=(a.flag0 and bm_DDEUP_unused) shr bp_DDEUP_unused; + end; + + procedure set_unused(var a : DDEUP; __unused : word); + begin + a.flag0:=a.flag0 or ((__unused shl bp_DDEUP_unused) and bm_DDEUP_unused); + end; + + function fAck(var a : DDEUP) : word; + begin + fAck:=(a.flag0 and bm_DDEUP_fAck) shr bp_DDEUP_fAck; + end; + + procedure set_fAck(var a : DDEUP; __fAck : word); + begin + a.flag0:=a.flag0 or ((__fAck shl bp_DDEUP_fAck) and bm_DDEUP_fAck); + end; + + function fRelease(var a : DDEUP) : word; + begin + fRelease:=(a.flag0 and bm_DDEUP_fRelease) shr bp_DDEUP_fRelease; + end; + + procedure set_fRelease(var a : DDEUP; __fRelease : word); + begin + a.flag0:=a.flag0 or ((__fRelease shl bp_DDEUP_fRelease) and bm_DDEUP_fRelease); + end; + + function fReserved(var a : DDEUP) : word; + begin + fReserved:=(a.flag0 and bm_DDEUP_fReserved) shr bp_DDEUP_fReserved; + end; + + procedure set_fReserved(var a : DDEUP; __fReserved : word); + begin + a.flag0:=a.flag0 or ((__fReserved shl bp_DDEUP_fReserved) and bm_DDEUP_fReserved); + end; + + function fAckReq(var a : DDEUP) : word; + begin + fAckReq:=(a.flag0 and bm_DDEUP_fAckReq) shr bp_DDEUP_fAckReq; + end; + + procedure set_fAckReq(var a : DDEUP; __fAckReq : word); + begin + a.flag0:=a.flag0 or ((__fAckReq shl bp_DDEUP_fAckReq) and bm_DDEUP_fAckReq); + end; + +{$endif read_implementation} + diff --git a/rtl/wince/wininc/unidef.inc b/rtl/wince/wininc/unidef.inc new file mode 100644 index 0000000000..a963b2f54b --- /dev/null +++ b/rtl/wince/wininc/unidef.inc @@ -0,0 +1,571 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 1999-2000 by the Free Pascal development team. + + Contains the Unicode functions for windows unit + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ + UnicodeFunctions.h + + Declarations for all the Windows32 API Unicode Functions + + Copyright (C) 1996 Free Software Foundation, Inc. + + Author: Scott Christley + Date: 1996 + + This file is part of the Windows32 API Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + If you are interested in a warranty or support for this source code, + contact Scott Christley for more information. + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, + 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + Changes : + + 22/15/2005 update for wince4.2 port, orinaudo@gmail.com +} + +{$ifdef read_interface} + +//begin common win32 & wince + +function AddFontResource(_para1:LPCWSTR):Integer; external GdiDLL name 'AddFontResourceW'; +function AppendMenu(hMenu:HMENU; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCWSTR):WINBOOL; external UserDLL name 'AppendMenuW'; +function CallWindowProc(lpPrevWndFunc:WNDPROC; hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external UserDLL name 'CallWindowProcW'; +function ChangeDisplaySettingsEx( lpszDeviceName:LPCTSTR; lpDevMode:LPDEVMODE; hwnd:HWND; dwflags:DWORD; lParam:LPVOID):LONG; external UserDLL name 'ChangeDisplaySettingsEx'; //+windows +function CharLower(lpsz:LPWSTR):LPWSTR; external UserDLL name 'CharLowerW'; +function CharLowerBuff(lpsz:LPWSTR; cchLength:DWORD):DWORD; external UserDLL name 'CharLowerBuffW'; +function CharNext(lpsz:LPCWSTR):LPWSTR; external UserDLL name 'CharNextW'; +function CharPrev(lpszStart:LPCWSTR; lpszCurrent:LPCWSTR):LPWSTR; external UserDLL name 'CharPrevW'; +function CharUpper(lpsz:LPWSTR):LPWSTR; external UserDLL name 'CharUpperW'; +function CharUpperBuff(lpsz:LPWSTR; cchLength:DWORD):DWORD; external UserDLL name 'CharUpperBuffW'; +function ChooseFont(_para1:LPCHOOSEFONTW):WINBOOL; external ComdlgDLL name 'ChooseFontW'; +function CompareString(Locale:LCID; dwCmpFlags:DWORD; lpString1:LPCWSTR; cchCount1:longint; lpString2:LPCWSTR;cchCount2:longint):longint; external KernelDLL name 'CompareStringW'; +function CopyFile(lpExistingFileName:LPCWSTR; lpNewFileName:LPCWSTR; bFailIfExists:WINBOOL):WINBOOL; external KernelDLL name 'CopyFileW'; +function CreateAcceleratorTable(_para1:LPACCEL; _para2:Integer):HACCEL; external UserDLL name 'CreateAcceleratorTableW'; +function CreateDC(_para1:LPCWSTR; _para2:LPCWSTR; _para3:LPCWSTR; _para4:pDEVMODE):HDC; external GdiDLL name 'CreateDCW'; +function CreateDialogIndirect(hInstance:HINST; lpTemplate:LPCDLGTEMPLATEW; hWndParent:HWND; lpDialogFunc:DLGPROC):HWND; +function CreateDialogIndirectParam(hInstance:HINST; lpTemplate:LPCDLGTEMPLATEW; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):HWND; external UserDLL name 'CreateDialogIndirectParamW'; +function CreateDirectory(lpPathName:LPCWSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):WINBOOL; external KernelDLL name 'CreateDirectoryW'; +function CreateEvent(lpEventAttributes:LPSECURITY_ATTRIBUTES; bManualReset:WINBOOL; bInitialState:WINBOOL; lpName:LPCWSTR):HANDLE; external KernelDLL name 'CreateEventW'; +function CreateEnhMetaFile(_para1:HDC; _para2:LPCWSTR; _para3:LPRECT; _para4:LPCWSTR):HDC; external GdiDLL name 'CreateEnhMetaFileW'; +function CreateFile(lpFileName:LPCWSTR; dwDesiredAccess:DWORD; dwShareMode:DWORD; lpSecurityAttributes:LPSECURITY_ATTRIBUTES; dwCreationDisposition:DWORD;dwFlagsAndAttributes:DWORD; hTemplateFile:HANDLE):HANDLE; external KernelDLL name 'CreateFileW'; +function CreateFileMapping(hFile:HANDLE; lpFileMappingAttributes:LPSECURITY_ATTRIBUTES; flProtect:DWORD; dwMaximumSizeHigh:DWORD; dwMaximumSizeLow:DWORD;lpName:LPCWSTR):HANDLE; external KernelDLL name 'CreateFileMappingW'; +function CreateFontIndirect(_para1:PLOGFONT):HFONT; external GdiDLL name 'CreateFontIndirectW'; +function CreateMutex(lpMutexAttributes:LPSECURITY_ATTRIBUTES; bInitialOwner:WINBOOL; lpName:LPCWSTR):HANDLE; external KernelDLL name 'CreateMutexW'; +function CreateProcess(pszImageName:LPCWSTR; pszCmdLine:LPCWSTR; psaProcess:LPSECURITY_ATTRIBUTES; psaThread:LPSECURITY_ATTRIBUTES; bInheritHandles:WINBOOL;fdwCreate:DWORD; lpEnvironment:LPVOID; + pszCurDir:LPCWSTR; psiStartInfo:LPSTARTUPINFO; pProcInfo:LPPROCESS_INFORMATION):WINBOOL; external KernelDLL name 'CreateProcessW'; +function CreatePropertySheetPage(lppsp:LPCPROPSHEETPAGE):HPROPSHEETPAGE; external ComctlDLL name 'CreatePropertySheetPageW'; +function CreateSemaphore(lpSemaphoreAttributes:LPSECURITY_ATTRIBUTES; lInitialCount:LONG; lMaximumCount:LONG; lpName:LPCWSTR):HANDLE; external KernelDLL name 'CreateSemaphoreW'; +function CreateStatusWindow(style:LONG; lpszText:LPCWSTR; hwndParent:HWND; wID:UINT):HWND; external ComctlDll name 'CreateStatusWindowW'; +function CreateWindow(lpClassName:LPCWSTR; lpWindowName:LPCWSTR; dwStyle:DWORD; X:longint;Y:longint; nWidth:longint; nHeight:longint; hWndParent:HWND; hMenu:HMENU;hInstance:HINST; lpParam:LPVOID):HWND; +function CreateWindowEx(dwExStyle:DWORD; lpClassName:LPCWSTR; lpWindowName:LPCWSTR; dwStyle:DWORD; X:Integer;Y:Integer; nWidth:Integer; nHeight:Integer; hWndParent:HWND; hMenu:HMENU;hInstance:HINST; lpParam:LPVOID):HWND; + external UserDLL name 'CreateWindowExW'; +function DeleteFile(lpFileName:LPCWSTR):WINBOOL; external KernelDLL name 'DeleteFileW'; +function DefDlgProc(hDlg:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external UserDLL name 'DefDlgProcW'; +function DefWindowProc(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external UserDLL name 'DefWindowProcW'; +function DialogBoxIndirect(hInstance:HINST; lpTemplate:LPCDLGTEMPLATEW; hWndParent:HWND; lpDialogFunc:DLGPROC):longint; +function DialogBoxIndirectParam(hInstance:HINST; hDialogTemplate:LPCDLGTEMPLATEW; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):Integer; external UserDLL name 'DialogBoxIndirectParamW'; +function DispatchMessage(lpMsg:LPMSG):LONG; external UserDLL name 'DispatchMessageW'; +function DrawText(hDC:HDC; lpString:LPCWSTR; nCount:Integer; lpRect:LPRECT; uFormat:UINT):Integer; external UserDLL name 'DrawTextW'; +procedure DrawStatusText(hDC:HDC; lprc:LPRECT; pszText:LPCWSTR; uFlags:UINT); external ComctlDLL name 'DrawStatusTextW'; +function EnumCalendarInfo(lpCalInfoEnumProc:CALINFO_ENUMPROC; Locale:LCID; Calendar:CALID; CalType:CALTYPE):WINBOOL; external KernelDLL name 'EnumCalendarInfoW'; +function EnumDateFormats(lpDateFmtEnumProc:DATEFMT_ENUMPROC; Locale:LCID; dwFlags:DWORD):WINBOOL; external KernelDLL name 'EnumDateFormatsW'; +function EnumFonts(_para1:HDC; _para2:LPCWSTR; _para3:ENUMFONTSPROC; _para4:LPARAM):Integer; external GdiDLL name 'EnumFontsW'; +function EnumFontFamilies(_para1:HDC; _para2:LPCWSTR; _para3:FONTENUMPROC; _para4:LPARAM):Integer; external GdiDLL name 'EnumFontFamiliesW'; +function EnumSystemCodePages(lpCodePageEnumProc:CODEPAGE_ENUMPROCW; dwFlags:DWORD):WINBOOL; external KernelDLL name 'EnumSystemCodePagesW'; +function EnumSystemLocales(lpLocaleEnumProc:LOCALE_ENUMPROC; dwFlags:DWORD):WINBOOL; external KernelDLL name 'EnumSystemLocalesW'; +function EnumTimeFormats(lpTimeFmtEnumProc:TIMEFMT_ENUMPROC; Locale:LCID; dwFlags:DWORD):WINBOOL; external KernelDLL name 'EnumTimeFormatsW'; +function ExtTextOut(_para1:HDC; _para2:Integer; _para3:Integer; _para4:UINT; _para5:LPRECT;_para6:LPCWSTR; _para7:UINT; _para8:LPINT):WINBOOL; external GdiDLL name 'ExtTextOutW'; +function ExtractIconEx(lpszFile:LPCTSTR; nIconIndex:Integer; phiconLarge: LPHICON; phiconSmall:LPHICON; nIcons:UINT):UINT; external ShellDLLCore name 'ExtractIconExW'; +function FoldString(dwMapFlags:DWORD; lpSrcStr:LPCWSTR; cchSrc:Integer; lpDestStr:LPWSTR; cchDest:Integer):Integer; external KernelDLL name 'FoldStringW'; +function FormatMessage(dwFlags:DWORD; lpSource:LPCVOID; dwMessageId:DWORD; dwLanguageId:DWORD; lpBuffer:LPWSTR;nSize:DWORD; Arguments:va_list):DWORD; external KernelDLL name 'FormatMessageW'; +function FindFirstChangeNotification(lpPathName:LPCWSTR; bWatchSubtree:WINBOOL; dwNotifyFilter:DWORD):HANDLE; external KernelDLL name 'FindFirstChangeNotificationW'; +function FindFirstFile(lpFileName:LPCWSTR; lpFindFileData:LPWIN32_FIND_DATAW):HANDLE; external KernelDLL name 'FindFirstFileW'; +function FindFirstFileEx(lpFileName:LPCWSTR; lpInfoLevelId:FINDEX_INFO_LEVELS; lpFindFileData:LPVOID; fSearchOp:FINDEX_SEARCH_OPS; lpSearchFilter:LPVOID; dwAdditionalFlags:DWORD):HANDLE; external KernelDLL name 'FindFirstFileExW'; //+winbase +function FindNextFile(hFindFile:HANDLE; lpFindFileData:LPWIN32_FIND_DATAW):WINBOOL; external KernelDLL name 'FindNextFileW'; +function FindResource(hModule:HMODULE; lpName:LPCWSTR; lpType:LPCWSTR):HRSRC; external KernelDLL name 'FindResourceW'; //~winbase hModule is HMODULE +function FindWindow(lpClassName:LPCWSTR; lpWindowName:LPCWSTR):HWND; external UserDLL name 'FindWindowW'; +function GetClassName(hWnd:HWND; lpClassName:LPWSTR; nMaxCount:Integer):Integer; external UserDLL name 'GetClassNameW'; +function GetClassInfo(hInstance:HINST; lpClassName:LPCWSTR; lpWndClass:LPWNDCLASS):WINBOOL; external UserDLL name 'GetClassInfoW'; +function GetClassLong(hWnd:HWND; nIndex:Integer):DWORD; external UserDLL name 'GetClassLongW'; +function GetClipboardFormatName(format:UINT; lpszFormatName:LPWSTR; cchMaxCount:Integer):longint; external UserDLL name 'GetClipboardFormatNameW'; +function GetCommandLine : LPWSTR; external KernelDLL name 'GetCommandLineW'; +function GetCurrencyFormat(Locale:LCID; dwFlags:DWORD; lpValue:LPCWSTR; lpFormat:PCURRENCYFMT; lpCurrencyStr:LPWSTR;cchCurrency:Integer):Integer; external KernelDLL name 'GetCurrencyFormatW'; +function GetDateFormat(Locale:LCID; dwFlags:DWORD; lpDate:LPSYSTEMTIME; lpFormat:LPCWSTR; lpDateStr:LPWSTR;cchDate:Integer):Integer; external KernelDLL name 'GetDateFormatW'; +function GetDiskFreeSpaceEx(lpDirectoryName:LPCWSTR; lpFreeBytesAvailableToCaller:PULARGE_INTEGER; lpTotalNumberOfBytes:PULARGE_INTEGER; lpTotalNumberOfFreeBytes:PULARGE_INTEGER):WINBOOL; external KernelDLL name 'GetDiskFreeSpaceExW'; //+winbase +function GetDlgItemText(hDlg:HWND; nIDDlgItem:Integer; lpString:LPWSTR; nMaxCount:Integer):UINT; external UserDLL name 'GetDlgItemTextW'; +function GetFileAttributes(lpFileName:LPCWSTR):DWORD; external KernelDLL name 'GetFileAttributesW'; +function GetFileAttributesEx(lpFileName:LPCWSTR; fInfoLevelId:GET_FILEEX_INFO_LEVELS; lpFileInformation:LPVOID):WINBOOL; external KernelDLL name 'GetFileAttributesExW'; //+winbase +function GetFileVersionInfoSize(lptstrFilename:LPWSTR; lpdwHandle:LPDWORD):DWORD; external VersionDLL name 'GetFileVersionInfoSizeW'; +function GetFileVersionInfo(lptstrFilename:LPWSTR; dwHandle:DWORD; dwLen:DWORD; lpData:LPVOID):WINBOOL; external VersionDLL name 'GetFileVersionInfoW'; +function GetKeyboardLayoutName(pwszKLID:LPWSTR):WINBOOL; external UserDLL name 'GetKeyboardLayoutNameW'; +function GetLocaleInfo(Locale:LCID; LCType:LCTYPE; lpLCData:LPWSTR; cchData:Integer):Integer; external KernelDLL name 'GetLocaleInfoW'; +function GetMenuItemInfo(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPMENUITEMINFO):WINBOOL; external UserDLL name 'GetMenuItemInfoW'; +function GetMessage(lpMsg:LPMSG; hWnd:HWND; wMsgFilterMin:UINT; wMsgFilterMax:UINT):WINBOOL; external UserDLL name 'GetMessageW'; +function GetModuleFileName(hModule:HMODULE; lpFilename:LPWSTR; nSize:DWORD):DWORD; external KernelDLL name 'GetModuleFileNameW'; +function GetModuleHandle(lpModuleName:LPCWSTR):HMODULE; external KernelDLL name 'GetModuleHandleW'; +function GetNumberFormat(Locale:LCID; dwFlags:DWORD; lpValue:LPCWSTR; lpFormat:PNUMBERFMT; lpNumberStr:LPWSTR;cchNumber:Integer):Integer; external KernelDLL name 'GetNumberFormatW'; +function GetObject(_para1:HGDIOBJ; _para2:Integer; _para3:LPVOID):Integer; external GdiDLL name 'GetObjectW'; +function GetObjectType(h:HGDIOBJ):DWORD; external GdiDLL name 'GetObjectType'; //+wingdi +//warning not exported from comdgl32(win32)/commdlg(wince) but coredll +function GetOpenFileName(_para1:LPOPENFILENAMEW):WINBOOL; external ComdlgDLLCore name 'GetOpenFileNameW'; +//warning not exported from comdgl32(win32)/commdlg(wince) but coredll +function GetSaveFileName(_para1:LPOPENFILENAMEW):WINBOOL; external ComdlgDLLCore name 'GetSaveFileNameW'; +function GetStringTypeEx(Locale:LCID; dwInfoType:DWORD; lpSrcStr:LPCWSTR; cchSrc:Integer; lpCharType:LPWORD):WINBOOL; external KernelDLL name 'GetStringTypeExW'; +function GetTempFileName(lpPathName:LPCWSTR; lpPrefixString:LPCWSTR; uUnique:UINT; lpTempFileName:LPWSTR):UINT; external KernelDLL name 'GetTempFileNameW'; +function GetTempPath(nBufferLength:DWORD; lpBuffer:LPWSTR):DWORD; external KernelDLL name 'GetTempPathW'; +function GetTextExtentExPoint(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:longint; _para5:LPINT;_para6:LPINT; _para7:LPSIZE):WINBOOL; external GdiDLL name 'GetTextExtentExPointW'; +function GetTextFace(_para1:HDC; _para2:Integer; _para3:LPWSTR):Integer; external GdiDLL name 'GetTextFaceW'; +function GetTextMetrics(_para1:HDC; _para2:LPTEXTMETRICW):WINBOOL; external GdiDLL name 'GetTextMetricsW'; +function GetTimeFormat(Locale:LCID; dwFlags:DWORD; lpTime:LPSYSTEMTIME; lpFormat:LPCWSTR; lpTimeStr:LPWSTR;cchTime:Integer):Integer; external KernelDLL name 'GetTimeFormatW'; +function GetUserNameEx(NameFormat:EXTENDED_NAME_FORMAT; lpNameBuffer:LPWSTR; nSize:PULONG):WINBOOL; external SecurDLL name 'GetUserNameExW'; +function GetVersionEx(VersionInformation:LPOSVERSIONINFOW):WINBOOL; external KernelDLL name 'GetVersionExW'; +function GetWindowText(hWnd:HWND; lpString:LPWSTR; nMaxCount:Integer):Integer; external UserDLL name 'GetWindowTextW'; +function GetWindowTextLength(hWnd:HWND):Integer; external UserDLL name 'GetWindowTextLengthW'; +function GetWindowLong(hWnd:HWND; nIndex:Integer):LONG; external UserDLL name 'GetWindowLongW'; +function GlobalAddAtom(lpString:LPCWSTR):ATOM; external KernelDLL name 'GlobalAddAtomW'; +function GlobalFindAtom(lpString:LPCWSTR):ATOM; external KernelDLL name 'GlobalFindAtomW'; +function IsDialogMessage(hDlg:HWND; lpMsg:LPMSG):WINBOOL; external UserDLL name 'IsDialogMessageW'; +function InsertMenu(hMenu:HMENU; uPosition:UINT; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCWSTR):WINBOOL; external UserDLL name 'InsertMenuW'; +function LCMapString(Locale:LCID; dwMapFlags:DWORD; lpSrcStr:LPCWSTR; cchSrc:longint; lpDestStr:LPWSTR;cchDest:longint):Integer; external KernelDLL name 'LCMapStringW'; +function LoadAccelerators(hInstance:HINST; lpTableName:LPCWSTR):HACCEL; external UserDLL name 'LoadAcceleratorsW'; +function LoadBitmap(hInstance:HINST; lpBitmapName:LPCWSTR):HBITMAP; external UserDLL name 'LoadBitmapW'; +function LoadCursor(hInstance:HINST; lpCursorName:LPCWSTR):HCURSOR; external UserDLL name 'LoadCursorW'; +function LoadIcon(hInstance:HINST; lpIconName:LPCWSTR):HICON; external UserDLL name 'LoadIconW'; +function LoadImage(_para1:HINST; _para2:LPCWSTR; _para3:UINT; _para4:Integer; _para5:Integer;_para6:UINT):HANDLE; external UserDLL name 'LoadImageW'; +function LoadKeyboardLayout(pwszKLID:LPCWSTR; Flags:UINT):HKL; external UserDLL name 'LoadKeyboardLayoutW'; +function LoadLibrary(lpLibFileName:LPCWSTR):HINST; external KernelDLL name 'LoadLibraryW'; +function LoadLibraryEx(lpLibFileName:LPCWSTR; hFile:HANDLE; dwFlags:DWORD):HINST; external KernelDLL name 'LoadLibraryExW'; +function LoadMenu(hInstance:HINST; lpMenuName:LPCWSTR):HMENU; external UserDLL name 'LoadMenuW'; +function LoadString(hInstance:HINST; uID:UINT; lpBuffer:LPWSTR; nBufferMax:Integer):longint; external UserDLL name 'LoadStringW'; +function lstrcmp(lpString1:LPCWSTR; lpString2:LPCWSTR):Integer; external KernelDLL name 'lstrcmpW'; //~winbase result is int +function lstrcmpi(lpString1:LPCWSTR; lpString2:LPCWSTR):Integer; external KernelDLL name 'lstrcmpiW'; //~winbase result is int +function MapVirtualKey(uCode:UINT; uMapType:UINT):UINT; external UserDLL name 'MapVirtualKeyW'; +function MessageBox(hWnd:HWND; lpText:LPCWSTR; lpCaption:LPCWSTR; uType:UINT):Integer; external UserDLL name 'MessageBoxW'; //~winuser, result declared as int +function MoveFile(lpExistingFileName:LPCWSTR; lpNewFileName:LPCWSTR):WINBOOL; external KernelDLL name 'MoveFileW'; +function OpenEvent(dwDesiredAccess:DWORD; bInheritHandle:WINBOOL; lpName:LPCWSTR):HANDLE; external KernelDLL name 'OpenEventW'; +procedure OutputDebugString(lpOutputString:LPCWSTR); external KernelDLL name 'OutputDebugStringW'; +function PageSetupDlg(_para1:LPPAGESETUPDLGW):WINBOOL; external ComdlgDLL name 'PageSetupDlgW'; +function PeekMessage(lpMsg:LPMSG; hWnd:HWND; wMsgFilterMin:UINT; wMsgFilterMax:UINT; wRemoveMsg:UINT):WINBOOL; external UserDLL name 'PeekMessageW'; +function PostThreadMessage(idThread:DWORD; Msg:UINT; wParam:WPARAM; lParam:LPARAM):WINBOOL; external UserDLL name 'PostThreadMessageW'; +function PostMessage(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):WINBOOL; external UserDLL name 'PostMessageW'; +function PropertySheet(lppsph:LPCPROPSHEETHEADERW):longint; external ComctlDll name 'PropertySheetW'; +function RegCreateKeyEx(hKey:HKEY; lpSubKey:LPCWSTR; Reserved:DWORD; lpClass:LPWSTR; dwOptions:DWORD;samDesired:REGSAM; lpSecurityAttributes:LPSECURITY_ATTRIBUTES; phkResult:PHKEY; lpdwDisposition:LPDWORD):LONG; + external AdvapiDLL name 'RegCreateKeyExW'; +function RegDeleteKey(hKey:HKEY; lpSubKey:LPCWSTR):LONG; external AdvapiDLL name 'RegDeleteKeyW'; +function RegDeleteValue(hKey:HKEY; lpValueName:LPCWSTR):LONG; external AdvapiDLL name 'RegDeleteValueW'; +function RegEnumKeyEx(hKey:HKEY; dwIndex:DWORD; lpName:LPWSTR; lpcbName:LPDWORD; lpReserved:LPDWORD;lpClass:LPWSTR; lpcbClass:LPDWORD; lpftLastWriteTime:PFILETIME):LONG; external AdvapiDLL name 'RegEnumKeyExW'; +function RegEnumValue(hKey:HKEY; dwIndex:DWORD; lpValueName:LPWSTR; lpcbValueName:LPDWORD; lpReserved:LPDWORD;lpType:LPDWORD; lpData:LPBYTE; lpcbData:LPDWORD):LONG; external AdvapiDLL name 'RegEnumValueW'; +function RegisterClass(lpWndClass:LPWNDCLASS):ATOM; external UserDLL name 'RegisterClassW'; +function RegisterClipboardFormat(lpszFormat:LPCWSTR):UINT; external UserDLL name 'RegisterClipboardFormatW'; +function RegisterWindowMessage(lpString:LPCWSTR):UINT; external KernelDLL name 'RegisterWindowMessageW'; +function RegQueryInfoKey(hKey:HKEY; lpClass:LPWSTR; lpcbClass:LPDWORD; lpReserved:LPDWORD; lpcSubKeys:LPDWORD;lpcbMaxSubKeyLen:LPDWORD; lpcbMaxClassLen:LPDWORD; lpcValues:LPDWORD; lpcbMaxValueNameLen:LPDWORD; + lpcbMaxValueLen:LPDWORD;lpcbSecurityDescriptor:LPDWORD; lpftLastWriteTime:PFILETIME):LONG; external AdvapiDLL name 'RegQueryInfoKeyW'; +function RegOpenKeyEx(hKey:HKEY; lpSubKey:LPCWSTR; ulOptions:DWORD; samDesired:REGSAM; phkResult:PHKEY):LONG; external AdvapiDLL name 'RegOpenKeyExW'; +function RegQueryValueEx(hKey:HKEY; lpValueName:LPCWSTR; lpReserved:LPDWORD; lpType:LPDWORD; lpData:LPBYTE;lpcbData:LPDWORD):LONG; external AdvapiDLL name 'RegQueryValueExW';function RegSetValueEx(hKey:HKEY; lpValueName:LPCWSTR; Reserved:DWORD; dwType:DWORD; lpData:LPBYTE;cbData:DWORD):LONG; external AdvapiDLL name 'RegSetValueExW'; +function RemoveDirectory(lpPathName:LPCWSTR):WINBOOL; external KernelDLL name 'RemoveDirectoryW'; +function RemoveFontResource(_para1:LPCWSTR):WINBOOL; external GdiDLL name 'RemoveFontResourceW'; +function SendDlgItemMessage(hDlg:HWND; nIDDlgItem:Integer; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LONG; external UserDLL name 'SendDlgItemMessageW'; +function SendMessage(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external UserDLL name 'SendMessageW'; +function SendNotifyMessage(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):WINBOOL; external UserDLL name 'SendNotifyMessageW'; +function SetClassLong(hWnd:HWND; nIndex:Integer; dwNewLong:LONG):DWORD; external UserDLL name 'SetClassLongW'; + +function SetDlgItemText(hDlg:HWND; nIDDlgItem:Integer; lpString:LPCWSTR):WINBOOL; external UserDLL name 'SetDlgItemTextW'; +function SetFileAttributes(lpFileName:LPCWSTR; dwFileAttributes:DWORD):WINBOOL; external KernelDLL name 'SetFileAttributesW'; +function SetLocaleInfo(Locale:LCID; LCType:LCTYPE; lpLCData:LPCWSTR):WINBOOL; external KernelDLL name 'SetLocaleInfoW'; +function SetMenuItemInfo(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFO):WINBOOL; external UserDLL name 'SetMenuItemInfoW'; +function SetWindowsHookEx(idHook:longint; lpfn:HOOKPROC; hmod:HINST; dwThreadId:DWORD):HHOOK; external UserDLL name 'SetWindowsHookExW'; +function SetWindowText(hWnd:HWND; lpString:LPCWSTR):WINBOOL; external UserDLL name 'SetWindowTextW'; +function SetWindowLong(hWnd:HWND; nIndex:Integer; dwNewLong:LONG):LONG; external UserDLL name 'SetWindowLongW'; //~winuser nIndex is int + +function ShellExecuteEx(lpExecInfo:LPSHELLEXECUTEINFO):WINBOOL; external ShellDLLCore name 'ShellExecuteEx'; //+shellapi +function SystemParametersInfo(uiAction:UINT; uiParam:UINT; pvParam:PVOID; fWinIni:UINT):WINBOOL; external UserDLL name 'SystemParametersInfoW'; +function StartDoc(_para1:HDC; _para2:PDOCINFOW):Integer; external GdiDLL name 'StartDocW'; +function TranslateAccelerator(hWnd:HWND; hAccTable:HACCEL; lpMsg:LPMSG):Integer; external UserDLL name 'TranslateAcceleratorW'; +function UnregisterClass(lpClassName:LPCWSTR; hInstance:HINST):WINBOOL; external UserDLL name 'UnregisterClassW'; +function VerQueryValue(pBlock:LPVOID; lpSubBlock:LPWSTR; lplpBuffer:LPVOID; puLen:PUINT):WINBOOL; external versionDLL name 'VerQueryValueW'; +function WNetAddConnection3(hwndOwner:HWND; lpNetResource:LPNETRESOURCE; lpPassword:LPCWSTR; lpUserName:LPCWSTR; dwFlags:DWORD):DWORD; external MprDLL name 'WNetAddConnection3W'; +function WNetCancelConnection2(lpName:LPCWSTR; dwFlags:DWORD; fForce:WINBOOL):DWORD; external MprDLL name 'WNetCancelConnection2W'; +function WNetConnectionDialog1(lpConnDlgStruct:LPCONNECTDLGSTRUCTW):DWORD; external MprDLL name 'WNetConnectionDialog1W'; +function WNetDisconnectDialog1(lpConnDlgStruct:LPDISCDLGSTRUCTW):DWORD; external MprDLL name 'WNetDisconnectDialog1W'; +function WNetEnumResource(hEnum:HANDLE; lpcCount:LPDWORD; lpBuffer:LPVOID; lpBufferSize:LPDWORD):DWORD; external MprDLL name 'WNetEnumResourceW'; +function WNetGetConnection(lpLocalName:LPCWSTR; lpRemoteName:LPWSTR; lpnLength:LPDWORD):DWORD; external MprDLL name 'WNetGetConnectionW'; +function WNetGetUniversalName(lpLocalPath:LPCWSTR; dwInfoLevel:DWORD; lpBuffer:LPVOID; lpBufferSize:LPDWORD):DWORD; external MprDLL name 'WNetGetUniversalNameW'; +function WNetGetUser(lpName:LPCWSTR; lpUserName:LPWSTR; lpnLength:LPDWORD):DWORD; external MprDLL name 'WNetGetUserW'; +function WNetOpenEnum(dwScope:DWORD; dwType:DWORD; dwUsage:DWORD; lpNetResource:LPNETRESOURCEW; lphEnum:LPHANDLE):DWORD; external MprDLL name 'WNetOpenEnumW'; +function wsprintf(lpBuffer:LPWSTR; lpFormat:LPCWSTR; const args:array of const):Integer; external UserDLL name 'wsprintfW'; //~winuser Result is int, cedcl directive removed, API doc say nothing about calling convention +function wsprintf(lpBuffer:LPWSTR; lpFormat:LPCWSTR):Integer; external UserDLL name 'wsprintfW'; //~winuser Result is int, API doc say nothing about calling convention +function wvsprintf(_para1:LPWSTR; _para2:LPCWSTR; arglist:va_list):Integer; external UserDLL name 'wvsprintfW'; //~winuser nIndex is int + +//end common win32 & wince + +{$ifdef WINCE} +//begin wince only + +//'ChooseColorW' not exported but 'ChooseColor' yes +function ChooseColor(_para1:LPCHOOSECOLOR):WINBOOL; external ComdlgDLL name 'ChooseColor'; +//'EnumDisplaySettingsW' not exported but 'EnumDisplaySettings' with widechar header is +function EnumDisplaySettings(lpszDeviceName:LPCWSTR; iModeNum:DWORD; lpDevMode:LPDEVMODEW):WINBOOL; external UserDLL name 'EnumDisplaySettings'; +//'EnumPropsExW' not exported but 'EnumPropsEx' with widechar header is +function EnumPropsEx(hWnd:HWND; lpEnumFunc:PROPENUMPROCEX; lParam:LPARAM):Integer; external UserDLL name 'EnumPropsEx'; +//'...W' not exported but '...' is +function GetCharABCWidths(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABC):WINBOOL; external GdiDLL name 'GetCharABCWidths'; +function GetCharWidth32(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external GdiDLL name 'GetCharWidth32'; +//'GetPropW', not exported but 'GetProp' with widechar header are +function GetProp(hWnd:HWND; lpString:LPCWSTR):HANDLE; external UserDLL name 'GetProp'; +//!header specific to CE, not in comctl32(win32)/commctl(wince) but in coredll +function ImageList_LoadImage(hi:HINST; lpbmp:LPCSTR; cx:Integer; cGrow:Integer; crMask:COLORREF;uType:UINT; uFlags:UINT):HIMAGELIST; external ComctlDLLCore name 'ImageList_LoadImage'; +//'RemovePropW' not exported but 'RemoveProp' with widechar header is +function RemoveProp(hWnd:HWND; lpString:LPCWSTR):HANDLE; external UserDLL name 'RemoveProp'; +//'SendMessageTimeoutW' not exported but 'SendMessageTimeout' yes +function SendMessageTimeout(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM; fuFlags:UINT;uTimeout:UINT; lpdwResult:LPDWORD):LRESULT; external UserDLL name 'SendMessageTimeout'; +//'SetPropW' not exported but 'SetProp' with widechar header is +function SetProp(hWnd:HWND; lpString:LPCWSTR; hData:HANDLE):WINBOOL; external UserDLL name 'SetProp'; +//not exported as PrintDlgW but PrintDlg +function PrintDlg(_para1:LPPRINTDLG):WINBOOL; external ComdlgDLL name 'PrintDlg'; +//not exported as RegSaveKeyW but RegSaveKey +function RegSaveKey(hKey:HKEY; lpFile:LPCTSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):LONG; external AdvapiDLL name 'RegSaveKey'; +//not exported as RegReplaceKeyW but RegReplaceKey +function RegReplaceKey(hKey:HKEY; lpSubKey:LPCTSTR; lpNewFile:LPCTSTR; lpOldFile:LPCTSTR):LONG; external AdvapiDLL name 'RegReplaceKey'; +//not exported as Shell_NotifyIconW but Shell_NotifyIcon +function Shell_NotifyIcon(dwMessage: DWORD; lpData: PNotifyIconDataA): WINBOOL; external ShellDLLCore name 'Shell_NotifyIcon'; +//end wince only + +{$endif WINCE} + +{$ifdef WIN32} +//begin win32 only ie not exist in wince4.2 second release lib imported functions from dlls +function AbortSystemShutdown(lpMachineName:LPWSTR):WINBOOL; external 'advapi32' name 'AbortSystemShutdownW'; +function AccessCheckAndAuditAlarm(SubsystemName:LPCWSTR; HandleId:LPVOID; ObjectTypeName:LPWSTR; ObjectName:LPWSTR; SecurityDescriptor:PSECURITY_DESCRIPTOR;DesiredAccess:DWORD; GenericMapping:PGENERIC_MAPPING; ObjectCreation:WINBOOL; +function AddAtom(lpString:LPCWSTR):ATOM; external 'kernel32' name 'AddAtomW'; +function CopyMetaFile(_para1:HMETAFILE; _para2:LPCWSTR):HMETAFILE; external 'gdi32' name 'CopyMetaFileW'; +function CreateFont(_para1:longint; _para2:longint; _para3:longint; _para4:longint; _para5:longint;_para6:DWORD; _para7:DWORD; _para8:DWORD; _para9:DWORD; _para10:DWORD;_para11:DWORD; _para12:DWORD; _para13:DWORD; _para14:LPCWSTR):HFONT; + external 'gdi32' name 'CreateFontW'; +function BackupEventLog(hEventLog:HANDLE; lpBackupFileName:LPCWSTR):WINBOOL; external 'advapi32' name 'BackupEventLogW'; +function BeginUpdateResource(pFileName:LPCWSTR; bDeleteExistingResources:WINBOOL):HANDLE; external 'kernel32' name 'BeginUpdateResourceW'; +function BuildCommDCB(lpDef:LPCWSTR; lpDCB:LPDCB):WINBOOL; external 'kernel32' name 'BuildCommDCBW'; +function BuildCommDCBAndTimeouts(lpDef:LPCWSTR; lpDCB:LPDCB; lpCommTimeouts:LPCOMMTIMEOUTS):WINBOOL; external 'kernel32' name 'BuildCommDCBAndTimeoutsW'; +function CallMsgFilter(lpMsg:LPMSG; nCode:longint):WINBOOL; external 'user32' name 'CallMsgFilterW'; +function CallNamedPipe(lpNamedPipeName:LPCWSTR; lpInBuffer:LPVOID; nInBufferSize:DWORD; lpOutBuffer:LPVOID; nOutBufferSize:DWORD;lpBytesRead:LPDWORD; nTimeOut:DWORD):WINBOOL; external 'kernel32' name 'CallNamedPipeW'; +function ChangeDisplaySettings(lpDevMode:LPDEVMODE; dwFlags:DWORD):LONG; external 'user32' name 'ChangeDisplaySettingsW'; +function ChangeMenu(hMenu:HMENU; cmd:UINT; lpszNewItem:LPCWSTR; cmdInsert:UINT; flags:UINT):WINBOOL; external 'user32' name 'ChangeMenuW'; +function CharToOem(lpszSrc:LPCWSTR; lpszDst:LPSTR):WINBOOL; external 'user32' name 'CharToOemW'; +function CharToOemBuff(lpszSrc:LPCWSTR; lpszDst:LPSTR; cchDstLength:DWORD):WINBOOL; external 'user32' name 'CharToOemBuffW'; +function ChangeServiceConfig(hService:SC_HANDLE; dwServiceType:DWORD; dwStartType:DWORD; dwErrorControl:DWORD; lpBinaryPathName:LPCWSTR;lpLoadOrderGroup:LPCWSTR; lpdwTagId:LPDWORD; lpDependencies:LPCWSTR; lpServiceStartName:LPCWSTR; + lpPassword:LPCWSTR;lpDisplayName:LPCWSTR):WINBOOL; external 'advapi32' name 'ChangeServiceConfigW'; +function ChooseColor(_para1:LPCHOOSECOLOR):WINBOOL; external 'comdlg32' name 'ChooseColorW'; +function ClearEventLog(hEventLog:HANDLE; lpBackupFileName:LPCWSTR):WINBOOL; external 'advapi32' name 'ClearEventLogW'; +function CommConfigDialog(lpszName:LPCWSTR; hWnd:HWND; lpCC:LPCOMMCONFIG):WINBOOL; external 'kernel32' name 'CommConfigDialogW'; +function CopyAcceleratorTable(hAccelSrc:HACCEL; lpAccelDst:LPACCEL; cAccelEntries:longint):longint; external 'user32' name 'CopyAcceleratorTableW'; +function CopyEnhMetaFile(_para1:HENHMETAFILE; _para2:LPCWSTR):HENHMETAFILE; external 'gdi32' name 'CopyEnhMetaFileW'; +function CreateColorSpace(_para1:LPLOGCOLORSPACE):HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceW'; +function CreateDesktop(lpszDesktop:LPWSTR; lpszDevice:LPWSTR; pDevmode:LPDEVMODE; dwFlags:DWORD; dwDesiredAccess:DWORD;lpsa:LPSECURITY_ATTRIBUTES):HDESK; external 'user32' name 'CreateDesktopW'; +function CreateDialog(hInstance:HINST; lpName:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC):HWND; +function CreateDialogParam(hInstance:HINST; lpTemplateName:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):HWND; external 'user32' name 'CreateDialogParamW'; +function CreateDirectoryEx(lpTemplateDirectory:LPCWSTR; lpNewDirectory:LPCWSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):WINBOOL; external 'kernel32' name 'CreateDirectoryExW'; +function CreateIC(_para1:LPCWSTR; _para2:LPCWSTR; _para3:LPCWSTR; _para4:LPDEVMODE):HDC; external 'gdi32' name 'CreateICW'; +function CreateMailslot(lpName:LPCWSTR; nMaxMessageSize:DWORD; lReadTimeout:DWORD; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):HANDLE; external 'kernel32' name 'CreateMailslotW'; +function CreateMDIWindow(lpClassName:LPWSTR; lpWindowName:LPWSTR; dwStyle:DWORD; X:longint; Y:longint;nWidth:longint; nHeight:longint; hWndParent:HWND; hInstance:HINST; lParam:LPARAM):HWND; external 'user32' name 'CreateMDIWindowW'; +function CreateMetaFile(_para1:LPCWSTR):HDC; external 'gdi32' name 'CreateMetaFileW'; +function CreateNamedPipe(lpName:LPCWSTR; dwOpenMode:DWORD; dwPipeMode:DWORD; nMaxInstances:DWORD; nOutBufferSize:DWORD;nInBufferSize:DWORD; nDefaultTimeOut:DWORD; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):HANDLE; + external 'kernel32' name 'CreateNamedPipeW'; +function CreateProcessAsUser(_para1:HANDLE; _para2:LPCWSTR; _para3:LPWSTR; _para4:LPSECURITY_ATTRIBUTES; _para5:LPSECURITY_ATTRIBUTES;_para6:WINBOOL; _para7:DWORD; _para8:LPVOID; _para9:LPCWSTR; + _para10:LPSTARTUPINFO;_para11:LPPROCESS_INFORMATION):WINBOOL; external 'advapi32' name 'CreateProcessAsUserW'; +function CreateScalableFontResource(_para1:DWORD; _para2:LPCWSTR; _para3:LPCWSTR; _para4:LPCWSTR):WINBOOL; external 'gdi32' name 'CreateScalableFontResourceW'; +function CreateService(hSCManager:SC_HANDLE; lpServiceName:LPCWSTR; lpDisplayName:LPCWSTR; dwDesiredAccess:DWORD; dwServiceType:DWORD;dwStartType:DWORD; dwErrorControl:DWORD; lpBinaryPathName:LPCWSTR; lpLoadOrderGroup:LPCWSTR; + lpdwTagId:LPDWORD;lpDependencies:LPCWSTR; lpServiceStartName:LPCWSTR; lpPassword:LPCWSTR):SC_HANDLE; external AdvapiDLL name 'CreateServiceW'; +function CreateWindowStation(lpwinsta:LPWSTR; dwReserved:DWORD; dwDesiredAccess:DWORD; lpsa:LPSECURITY_ATTRIBUTES):HWINSTA; external 'user32' name 'CreateWindowStationW'; +function DdeCreateStringHandle(_para1:DWORD; _para2:LPCWSTR; _para3:longint):HSZ; external 'user32' name 'DdeCreateStringHandleW'; +function DdeInitialize(_para1:LPDWORD; _para2:PFNCALLBACK; _para3:DWORD; _para4:DWORD):UINT; external 'user32' name 'DdeInitializeW'; +function DdeQueryString(_para1:DWORD; _para2:HSZ; _para3:LPCWSTR; _para4:DWORD; _para5:longint):DWORD; external 'user32' name 'DdeQueryStringW'; +function DefineDosDevice(dwFlags:DWORD; lpDeviceName:LPCWSTR; lpTargetPath:LPCWSTR):WINBOOL; external 'kernel32' name 'DefineDosDeviceW'; +function DefFrameProc(hWnd:HWND; hWndMDIClient:HWND; uMsg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external 'user32' name 'DefFrameProcW'; +function DefMDIChildProc(hWnd:HWND; uMsg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external 'user32' name 'DefMDIChildProcW'; +function DialogBox(hInstance:HINST; lpTemplate:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC):longint; +function DialogBoxParam(hInstance:HINST; lpTemplateName:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):longint; external 'user32' name 'DialogBoxParamW'; +function DlgDirList(hDlg:HWND; lpPathSpec:LPWSTR; nIDListBox:longint; nIDStaticPath:longint; uFileType:UINT):longint; external 'user32' name 'DlgDirListW'; +function DlgDirSelectEx(hDlg:HWND; lpString:LPWSTR; nCount:longint; nIDListBox:longint):WINBOOL; external 'user32' name 'DlgDirSelectExW'; +function DlgDirListComboBox(hDlg:HWND; lpPathSpec:LPWSTR; nIDComboBox:longint; nIDStaticPath:longint; uFiletype:UINT):longint; external 'user32' name 'DlgDirListComboBoxW'; +function DlgDirSelectComboBoxEx(hDlg:HWND; lpString:LPWSTR; nCount:longint; nIDComboBox:longint):WINBOOL; external 'user32' name 'DlgDirSelectComboBoxExW'; +function DragQueryFile(_para1:HDROP; _para2:cardinal; _para3:LPCWSTR; _para4:cardinal):cardinal; external 'shell32' name 'DragQueryFileW'; +function DrawState(_para1:HDC; _para2:HBRUSH; _para3:DRAWSTATEPROC; _para4:LPARAM; _para5:WPARAM;_para6:longint; _para7:longint; _para8:longint; _para9:longint; _para10:UINT):WINBOOL; external 'user32' name 'DrawStateW'; +function DrawTextEx(_para1:HDC; _para2:LPWSTR; _para3:longint; _para4:LPRECT; _para5:UINT;_para6:LPDRAWTEXTPARAMS):longint; external 'user32' name 'DrawTextExW'; +function EndUpdateResource(hUpdate:HANDLE; fDiscard:WINBOOL):WINBOOL; external 'kernel32' name 'EndUpdateResourceW'; +function EnumDependentServices(hService:SC_HANDLE; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUS; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD;lpServicesReturned:LPDWORD):WINBOOL; external 'advapi32' name 'EnumDependentServicesW'; +function EnumDesktops(hwinsta:HWINSTA; lpEnumFunc:DESKTOPENUMPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumDesktopsW'; +function EnumDisplaySettings(lpszDeviceName:LPCWSTR; iModeNum:DWORD; lpDevMode:LPDEVMODEW):WINBOOL; external UserDLL name 'EnumDisplaySettingsW'; +function EnumFontFamiliesEx(_para1:HDC; _para2:LPLOGFONT; _para3:FONTENUMEXPROC; _para4:LPARAM; _para5:DWORD):longint; external 'gdi32' name 'EnumFontFamiliesExW'; +function EnumICMProfiles(_para1:HDC; _para2:ICMENUMPROC; _para3:LPARAM):longint; external 'gdi32' name 'EnumICMProfilesW'; +function EnumProps(hWnd:HWND; lpEnumFunc:PROPENUMPROC):longint; external 'user32' name 'EnumPropsW'; +function EnumResourceTypes(hModule:HINST; lpEnumFunc:ENUMRESTYPEPROC; lParam:LONG):WINBOOL; external 'kernel32' name 'EnumResourceTypesW'; +function EnumResourceNames(hModule:HINST; lpType:LPCWSTR; lpEnumFunc:ENUMRESNAMEPROC; lParam:LONG):WINBOOL; external 'kernel32' name 'EnumResourceNamesW'; +function EnumResourceLanguages(hModule:HINST; lpType:LPCWSTR; lpName:LPCWSTR; lpEnumFunc:ENUMRESLANGPROC; lParam:LONG):WINBOOL; external 'kernel32' name 'EnumResourceLanguagesW'; +function EnumServicesStatus(hSCManager:SC_HANDLE; dwServiceType:DWORD; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUS; cbBufSize:DWORD;pcbBytesNeeded:LPDWORD; lpServicesReturned:LPDWORD; lpResumeHandle:LPDWORD):WINBOOL; + external 'advapi32' name 'EnumServicesStatusW'; +function EnumWindowStations(lpEnumFunc:ENUMWINDOWSTATIONPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumWindowStationsW'; +function ExpandEnvironmentStrings(lpSrc:LPCWSTR; lpDst:LPWSTR; nSize:DWORD):DWORD; external 'kernel32' name 'ExpandEnvironmentStringsW'; +function ExtractIcon(_para1:HINST; _para2:LPCWSTR; _para3:cardinal):HICON; external 'shell32' name 'ExtractIconW'; +function ExtractAssociatedIcon(_para1:HINST; _para2:LPCWSTR; _para3:LPWORD):HICON; external 'shell32' name 'ExtractAssociatedIconW'; +procedure FatalAppExit(uAction:UINT; lpMessageText:LPCWSTR); external 'kernel32' name 'FatalAppExitW'; +function FillConsoleOutputCharacter(hConsoleOutput:HANDLE; cCharacter:WCHAR; nLength:DWORD; dwWriteCoord:COORD; lpNumberOfCharsWritten:LPDWORD):WINBOOL; external 'kernel32' name 'FillConsoleOutputCharacterW'; +function FindAtom(lpString:LPCWSTR):ATOM; external 'kernel32' name 'FindAtomW'; +function FindExecutable(_para1:LPCWSTR; _para2:LPCWSTR; _para3:LPCWSTR):HINST; external 'shell32' name 'FindExecutableW'; +function FindResourceEx(hModule:HINST; lpType:LPCWSTR; lpName:LPCWSTR; wLanguage:WORD):HRSRC; external 'kernel32' name 'FindResourceExW'; +function FindText(_para1:LPFINDREPLACE):HWND; external 'comdlg32' name 'FindTextW'; +function FindWindowEx(_para1:HWND; _para2:HWND; _para3:LPCWSTR; _para4:LPCWSTR):HWND; external 'user32' name 'FindWindowExW'; +function FreeEnvironmentStrings(_para1:LPWSTR):WINBOOL; external 'kernel32' name 'FreeEnvironmentStringsW'; +function GetAtomName(nAtom:ATOM; lpBuffer:LPWSTR; nSize:longint):UINT; external 'kernel32' name 'GetAtomNameW'; +function GetBinaryType(lpApplicationName:LPCWSTR; lpBinaryType:LPDWORD):WINBOOL; external 'kernel32' name 'GetBinaryTypeW'; +function GetCharABCWidthsFloat(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABCFLOAT):WINBOOL; external 'gdi32' name 'GetCharABCWidthsFloatW'; +function GetCharacterPlacement(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:longint; _para5:LPGCP_RESULTS;_para6:DWORD):DWORD; external 'gdi32' name 'GetCharacterPlacementW'; +function GetCharWidth(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external 'gdi32' name 'GetCharWidthW'; +function GetCharWidthFloat(_para1:HDC; _para2:UINT; _para3:UINT; _para4:PSingle):WINBOOL; external 'gdi32' name 'GetCharWidthFloatW'; +function GetCompressedFileSize(lpFileName:LPCWSTR; lpFileSizeHigh:LPDWORD):DWORD; external 'kernel32' name 'GetCompressedFileSizeW'; +function GetComputerName(lpBuffer:LPWSTR; nSize:LPDWORD):WINBOOL; external 'kernel32' name 'GetComputerNameW'; +function GetCharABCWidths(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABC):WINBOOL; external GdiDLL name 'GetCharABCWidthsW'; +function GetCharWidth32(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external GdiDLL name 'GetCharWidth32W'; +function GetClassInfoEx(_para1:HINST; _para2:LPCWSTR; _para3:LPWNDCLASSEX):WINBOOL; external 'user32' name 'GetClassInfoExW'; +function GetConsoleTitle(lpConsoleTitle:LPWSTR; nSize:DWORD):DWORD; external 'kernel32' name 'GetConsoleTitleW'; +function GetCurrentDirectory(nBufferLength:DWORD; lpBuffer:LPWSTR):DWORD; external 'kernel32' name 'GetCurrentDirectoryW'; +function GetDefaultCommConfig(lpszName:LPCWSTR; lpCC:LPCOMMCONFIG; lpdwSize:LPDWORD):WINBOOL; external 'kernel32' name 'GetDefaultCommConfigW'; +function GetDiskFreeSpace(lpRootPathName:LPCWSTR; lpSectorsPerCluster:LPDWORD; lpBytesPerSector:LPDWORD; lpNumberOfFreeClusters:LPDWORD; lpTotalNumberOfClusters:LPDWORD):WINBOOL; external 'kernel32' name 'GetDiskFreeSpaceW'; +function GetDriveType(lpRootPathName:LPCWSTR):UINT; external 'kernel32' name 'GetDriveTypeW'; +function GetEnhMetaFile(_para1:LPCWSTR):HENHMETAFILE; external 'gdi32' name 'GetEnhMetaFileW'; +function GetEnhMetaFileDescription(_para1:HENHMETAFILE; _para2:UINT; _para3:LPWSTR):UINT; external 'gdi32' name 'GetEnhMetaFileDescriptionW'; +function GetEnvironmentStrings : LPWSTR; external 'kernel32' name 'GetEnvironmentStringsW'; +function GetEnvironmentVariable(lpName:LPCWSTR; lpBuffer:LPWSTR; nSize:DWORD):DWORD; external 'kernel32' name 'GetEnvironmentVariableW'; +function GetFileSecurity(lpFileName:LPCWSTR; RequestedInformation:SECURITY_INFORMATION; pSecurityDescriptor:PSECURITY_DESCRIPTOR; nLength:DWORD; lpnLengthNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'GetFileSecurityW'; +function GetFileTitle(_para1:LPCWSTR; _para2:LPWSTR; _para3:WORD):integer; external 'comdlg32' name 'GetFileTitleW'; +function GetFullPathName(lpFileName:LPCWSTR; nBufferLength:DWORD; lpBuffer:LPWSTR; var lpFilePart:LPWSTR):DWORD; external 'kernel32' name 'GetFullPathNameW'; +function GetGlyphOutline(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPGLYPHMETRICS; _para5:DWORD;_para6:LPVOID; _para7:PMAT2):DWORD; external 'gdi32' name 'GetGlyphOutlineW'; +function GetICMProfile(_para1:HDC; _para2:DWORD; _para3:LPWSTR):WINBOOL; external 'gdi32' name 'GetICMProfileW'; +function GetKeyNameText(lParam:LONG; lpString:LPWSTR; nSize:longint):longint; external 'user32' name 'GetKeyNameTextW'; +function GetKerningPairs(_para1:HDC; _para2:DWORD; _para3:LPKERNINGPAIR):DWORD; external 'gdi32' name 'GetKerningPairsW'; +function GetLogColorSpace(_para1:HCOLORSPACE; _para2:LPLOGCOLORSPACE; _para3:DWORD):WINBOOL; external 'gdi32' name 'GetLogColorSpaceW'; +function GetLogicalDriveStrings(nBufferLength:DWORD; lpBuffer:LPWSTR):DWORD; external 'kernel32' name 'GetLogicalDriveStringsW'; +function GetMenuString(hMenu:HMENU; uIDItem:UINT; lpString:LPWSTR; nMaxCount:longint; uFlag:UINT):longint; external 'user32' name 'GetMenuStringW'; +function GetMetaFile(_para1:LPCWSTR):HMETAFILE; external 'gdi32' name 'GetMetaFileW'; +function GetNamedPipeHandleState(hNamedPipe:HANDLE; lpState:LPDWORD; lpCurInstances:LPDWORD; lpMaxCollectionCount:LPDWORD; lpCollectDataTimeout:LPDWORD;lpUserName:LPWSTR; nMaxUserNameSize:DWORD):WINBOOL; + external 'kernel32' name 'GetNamedPipeHandleStateW'; +function GetTextExtentPoint(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentPointW'; +function GetTextExtentPoint32(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentPoint32W'; +function GetOutlineTextMetrics(_para1:HDC; _para2:UINT; _para3:LPOUTLINETEXTMETRIC):UINT; external 'gdi32' name 'GetOutlineTextMetricsW'; +function GetProfileInt(lpAppName:LPCWSTR; lpKeyName:LPCWSTR; nDefault:WINT):UINT; external 'kernel32' name 'GetProfileIntW'; +function GetProfileString(lpAppName:LPCWSTR; lpKeyName:LPCWSTR; lpDefault:LPCWSTR; lpReturnedString:LPWSTR; nSize:DWORD):DWORD; external 'kernel32' name 'GetProfileStringW'; +function GetProfileSection(lpAppName:LPCWSTR; lpReturnedString:LPWSTR; nSize:DWORD):DWORD; external 'kernel32' name 'GetProfileSectionW'; +function GetProp(hWnd:HWND; lpString:LPCWSTR):HANDLE; external 'user32' name 'GetPropW'; +function GetPrivateProfileInt(lpAppName:LPCWSTR; lpKeyName:LPCWSTR; nDefault:WINT; lpFileName:LPCWSTR):UINT; external 'kernel32' name 'GetPrivateProfileIntW'; +function GetPrivateProfileString(lpAppName:LPCWSTR; lpKeyName:LPCWSTR; lpDefault:LPCWSTR; lpReturnedString:LPWSTR; nSize:DWORD;lpFileName:LPCWSTR):DWORD; external 'kernel32' name 'GetPrivateProfileStringW'; +function GetPrivateProfileSection(lpAppName:LPCWSTR; lpReturnedString:LPWSTR; nSize:DWORD; lpFileName:LPCWSTR):DWORD; external 'kernel32' name 'GetPrivateProfileSectionW'; +function GetServiceKeyName(hSCManager:SC_HANDLE; lpDisplayName:LPCWSTR; lpServiceName:LPWSTR; lpcchBuffer:LPDWORD):WINBOOL; external 'advapi32' name 'GetServiceKeyNameW'; +function GetServiceDisplayName(hSCManager:SC_HANDLE; lpServiceName:LPCWSTR; lpDisplayName:LPWSTR; lpcchBuffer:LPDWORD):WINBOOL; external 'advapi32' name 'GetServiceDisplayNameW'; +function GetShortPathName(lpszLongPath:LPCWSTR; lpszShortPath:LPWSTR; cchBuffer:DWORD):DWORD; external 'kernel32' name 'GetShortPathNameW'; +procedure GetStartupInfo(lpStartupInfo:LPSTARTUPINFO); external 'kernel32' name 'GetStartupInfoW'; +function GetStringType(dwInfoType:DWORD; lpSrcStr:LPCWSTR; cchSrc:longint; lpCharType:LPWORD):WINBOOL; external 'kernel32' name 'GetStringTypeW'; +function GetSystemDirectory(lpBuffer:LPWSTR; uSize:UINT):UINT; external 'kernel32' name 'GetSystemDirectoryW'; +function GetTabbedTextExtent(hDC:HDC; lpString:LPCWSTR; nCount:longint; nTabPositions:longint; lpnTabStopPositions:LPINT):DWORD; external 'user32' name 'GetTabbedTextExtentW'; +function GetUserName(lpBuffer:LPWSTR; nSize:LPDWORD):WINBOOL; external 'advapi32' name 'GetUserNameW'; +function GetUserObjectInformation(hObj:HANDLE; nIndex:longint; pvInfo:PVOID; nLength:DWORD; lpnLengthNeeded:LPDWORD):WINBOOL; external 'user32' name 'GetUserObjectInformationW'; +function GetVolumeInformation(lpRootPathName:LPCWSTR; lpVolumeNameBuffer:LPWSTR; nVolumeNameSize:DWORD; lpVolumeSerialNumber:LPDWORD; lpMaximumComponentLength:LPDWORD;lpFileSystemFlags:LPDWORD; lpFileSystemNameBuffer:LPWSTR; + nFileSystemNameSize:DWORD):WINBOOL; external 'kernel32' name 'GetVolumeInformationW'; +function GetWindowsDirectory(lpBuffer:LPWSTR; uSize:UINT):UINT; external 'kernel32' name 'GetWindowsDirectoryW'; +function GlobalGetAtomName(nAtom:ATOM; lpBuffer:LPWSTR; nSize:longint):UINT; external 'kernel32' name 'GlobalGetAtomNameW'; +function GrayString(hDC:HDC; hBrush:HBRUSH; lpOutputFunc:GRAYSTRINGPROC; lpData:LPARAM; nCount:longint;X:longint; Y:longint; nWidth:longint; nHeight:longint):WINBOOL; external 'user32' name 'GrayStringW'; +function ImageList_LoadImage(hi:HINST; lpbmp:LPCWSTR; cx:longint; cGrow:longint; crMask:COLORREF;uType:UINT; uFlags:UINT):HIMAGELIST; external 'comctl32' name 'ImageList_LoadImageW'; +function IsBadStringPtr(lpsz:LPCWSTR; ucchMax:UINT):WINBOOL; external 'kernel32' name 'IsBadStringPtrW'; +function IsCharAlpha(ch:WCHAR):WINBOOL; external 'user32' name 'IsCharAlphaW'; +function IsCharAlphaNumeric(ch:WCHAR):WINBOOL; external 'user32' name 'IsCharAlphaNumericW'; +function IsCharUpper(ch:WCHAR):WINBOOL; external 'user32' name 'IsCharUpperW'; +function IsCharLower(ch:WCHAR):WINBOOL; external 'user32' name 'IsCharLowerW'; +function InitiateSystemShutdown(lpMachineName:LPWSTR; lpMessage:LPWSTR; dwTimeout:DWORD; bForceAppsClosed:WINBOOL; bRebootAfterShutdown:WINBOOL):WINBOOL; external 'advapi32' name 'InitiateSystemShutdownW'; +function InsertMenuItem(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFO):WINBOOL; external 'user32' name 'InsertMenuItemW'; +function LoadCursorFromFile(lpFileName:LPCWSTR):HCURSOR; external 'user32' name 'LoadCursorFromFileW'; +function LoadMenuIndirect(lpMenuTemplate:LPMENUTEMPLATE):HMENU; external 'user32' name 'LoadMenuIndirectW'; +function LogonUser(_para1:LPWSTR; _para2:LPWSTR; _para3:LPWSTR; _para4:DWORD; _para5:DWORD;_para6:PHANDLE):WINBOOL; external 'advapi32' name 'LogonUserW'; +function LookupAccountName(lpSystemName:LPCWSTR; lpAccountName:LPCWSTR; Sid:PSID; cbSid:LPDWORD; ReferencedDomainName:LPWSTR;cbReferencedDomainName:LPDWORD; peUse:PSID_NAME_USE):WINBOOL; external 'advapi32' name 'LookupAccountNameW'; +function LookupAccountSid(lpSystemName:LPCWSTR; Sid:PSID; Name:LPWSTR; cbName:LPDWORD; ReferencedDomainName:LPWSTR;cbReferencedDomainName:LPDWORD; peUse:PSID_NAME_USE):WINBOOL; external 'advapi32' name 'LookupAccountSidW'; +function LookupPrivilegeDisplayName(lpSystemName:LPCWSTR; lpName:LPCWSTR; lpDisplayName:LPWSTR; cbDisplayName:LPDWORD; lpLanguageId:LPDWORD):WINBOOL; external 'advapi32' name 'LookupPrivilegeDisplayNameW'; +function LookupPrivilegeName(lpSystemName:LPCWSTR; lpLuid:PLUID; lpName:LPWSTR; cbName:LPDWORD):WINBOOL; external 'advapi32' name 'LookupPrivilegeNameW'; +function LookupPrivilegeValue(lpSystemName:LPCWSTR; lpName:LPCWSTR; lpLuid:PLUID):WINBOOL; external 'advapi32' name 'LookupPrivilegeValueW'; +function lstrcat(lpString1:LPWSTR; lpString2:LPCWSTR):LPWSTR; external 'kernel32' name 'lstrcatW'; +function lstrcpyn(lpString1:LPWSTR; lpString2:LPCWSTR; iMaxLength:longint):LPWSTR; external 'kernel32' name 'lstrcpynW'; +function lstrcpy(lpString1:LPWSTR; lpString2:LPCWSTR):LPWSTR; external 'kernel32' name 'lstrcpyW'; +function lstrlen(lpString:LPCWSTR):longint; external 'kernel32' name 'lstrlenW'; +function MapVirtualKeyEx(uCode:UINT; uMapType:UINT; dwhkl:HKL):UINT; external 'user32' name 'MapVirtualKeyExW'; +function ModifyMenu(hMnu:HMENU; uPosition:UINT; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCWSTR):WINBOOL; external 'user32' name 'ModifyMenuW'; +function MoveFileEx(lpExistingFileName:LPCWSTR; lpNewFileName:LPCWSTR; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'MoveFileExW'; +function MessageBoxEx(hWnd:HWND; lpText:LPCWSTR; lpCaption:LPCWSTR; uType:UINT; wLanguageId:WORD):longint; external UserDll name 'MessageBoxExW'; +function MessageBoxIndirect(_para1:LPMSGBOXPARAMS):longint; external UserDll name 'MessageBoxIndirectW'; +function MultinetGetConnectionPerformance(lpNetResource:LPNETRESOURCE; lpNetConnectInfoStruct:LPNETCONNECTINFOSTRUCT):DWORD; external 'mpr' name 'MultinetGetConnectionPerformanceW'; +function ObjectCloseAuditAlarm(SubsystemName:LPCWSTR; HandleId:LPVOID; GenerateOnClose:WINBOOL):WINBOOL; external 'advapi32' name 'ObjectCloseAuditAlarmW'; +function ObjectOpenAuditAlarm(SubsystemName:LPCWSTR; HandleId:LPVOID; ObjectTypeName:LPWSTR; ObjectName:LPWSTR; pSecurityDescriptor:PSECURITY_DESCRIPTOR;ClientToken:HANDLE; DesiredAccess:DWORD; GrantedAccess:DWORD; + Privileges:PPRIVILEGE_SET; ObjectCreation:WINBOOL;AccessGranted:WINBOOL; GenerateOnClose:LPBOOL):WINBOOL; external 'advapi32' name 'ObjectOpenAuditAlarmW'; +function ObjectPrivilegeAuditAlarm(SubsystemName:LPCWSTR; HandleId:LPVOID; ClientToken:HANDLE; DesiredAccess:DWORD; Privileges:PPRIVILEGE_SET;AccessGranted:WINBOOL):WINBOOL; external 'advapi32' name 'ObjectPrivilegeAuditAlarmW'; +function OemToChar(lpszSrc:LPCSTR; lpszDst:LPWSTR):WINBOOL; external 'user32' name 'OemToCharW'; +function OemToCharBuff(lpszSrc:LPCSTR; lpszDst:LPWSTR; cchDstLength:DWORD):WINBOOL; external 'user32' name 'OemToCharBuffW'; +function OpenBackupEventLog(lpUNCServerName:LPCWSTR; lpFileName:LPCWSTR):HANDLE; external 'advapi32' name 'OpenBackupEventLogW'; +function OpenDesktop(lpszDesktop:LPWSTR; dwFlags:DWORD; fInherit:WINBOOL; dwDesiredAccess:DWORD):HDESK; external 'user32' name 'OpenDesktopW'; +function OpenEventLog(lpUNCServerName:LPCWSTR; lpSourceName:LPCWSTR):HANDLE; external 'advapi32' name 'OpenEventLogW'; +function OpenFileMapping(dwDesiredAccess:DWORD; bInheritHandle:WINBOOL; lpName:LPCWSTR):HANDLE; external 'kernel32' name 'OpenFileMappingW'; +function OpenMutex(dwDesiredAccess:DWORD; bInheritHandle:WINBOOL; lpName:LPCWSTR):HANDLE; external 'kernel32' name 'OpenMutexW'; +function OpenSCManager(lpMachineName:LPCWSTR; lpDatabaseName:LPCWSTR; dwDesiredAccess:DWORD):SC_HANDLE; external 'advapi32' name 'OpenSCManagerW'; +function OpenSemaphore(dwDesiredAccess:DWORD; bInheritHandle:WINBOOL; lpName:LPCWSTR):HANDLE; external 'kernel32' name 'OpenSemaphoreW'; +function OpenService(hSCManager:SC_HANDLE; lpServiceName:LPCWSTR; dwDesiredAccess:DWORD):SC_HANDLE; external 'advapi32' name 'OpenServiceW'; +function OpenWindowStation(lpszWinSta:LPWSTR; fInherit:WINBOOL; dwDesiredAccess:DWORD):HWINSTA; external 'user32' name 'OpenWindowStationW'; +function PeekConsoleInput(hConsoleInput:HANDLE; lpBuffer:PINPUTRECORD; nLength:DWORD; lpNumberOfEventsRead:LPDWORD):WINBOOL; external 'kernel32' name 'PeekConsoleInputW'; +function PolyTextOut(_para1:HDC; _para2:PPOLYTEXT; _para3:longint):WINBOOL; external 'gdi32' name 'PolyTextOutW'; +function PrintDlg(_para1:LPPRINTDLG):WINBOOL; external 'comdlg32' name 'PrintDlgW'; +function PrivilegedServiceAuditAlarm(SubsystemName:LPCWSTR; ServiceName:LPCWSTR; ClientToken:HANDLE; Privileges:PPRIVILEGE_SET; AccessGranted:WINBOOL):WINBOOL; external 'advapi32' name 'PrivilegedServiceAuditAlarmW'; +function QueryDosDevice(lpDeviceName:LPCWSTR; lpTargetPath:LPWSTR; ucchMax:DWORD):DWORD; external 'kernel32' name 'QueryDosDeviceW'; +function QueryServiceConfig(hService:SC_HANDLE; lpServiceConfig:LPQUERY_SERVICE_CONFIG; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceConfigW'; +function QueryServiceLockStatus(hSCManager:SC_HANDLE; lpLockStatus:LPQUERY_SERVICE_LOCK_STATUS; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceLockStatusW'; +function ReadConsole(hConsoleInput:HANDLE; lpBuffer:LPVOID; nNumberOfCharsToRead:DWORD; lpNumberOfCharsRead:LPDWORD; lpReserved:LPVOID):WINBOOL; external 'kernel32' name 'ReadConsoleW'; +function ReadConsoleInput(hConsoleInput:HANDLE; lpBuffer:PINPUTRECORD; nLength:DWORD; lpNumberOfEventsRead:LPDWORD):WINBOOL; external 'kernel32' name 'ReadConsoleInputW'; +function ReadConsoleOutput(hConsoleOutput:HANDLE; lpBuffer:PCHAR_INFO; dwBufferSize:COORD; dwBufferCoord:COORD; lpReadRegion:PSMALL_RECT):WINBOOL; external 'kernel32' name 'ReadConsoleOutputW'; +function ReadConsoleOutputCharacter(hConsoleOutput:HANDLE; lpCharacter:LPWSTR; nLength:DWORD; dwReadCoord:COORD; lpNumberOfCharsRead:LPDWORD):WINBOOL; external 'kernel32' name 'ReadConsoleOutputCharacterW'; +function ReadEventLog(hEventLog:HANDLE; dwReadFlags:DWORD; dwRecordOffset:DWORD; lpBuffer:LPVOID; nNumberOfBytesToRead:DWORD;pnBytesRead:LPDWORD; pnMinNumberOfBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'ReadEventLogW'; +function RegConnectRegistry(lpMachineName:LPWSTR; hKey:HKEY; phkResult:PHKEY):LONG; external 'advapi32' name 'RegConnectRegistryW'; +function RegisterClassEx(_para1:LPWNDCLASSEXW):ATOM; external 'user32' name 'RegisterClassExW'; +function RegisterEventSource(lpUNCServerName:LPCWSTR; lpSourceName:LPCWSTR):HANDLE; external 'advapi32' name 'RegisterEventSourceW'; +function RegisterServiceCtrlHandler(lpServiceName:LPCWSTR; lpHandlerProc:LPHANDLER_FUNCTION):SERVICE_STATUS_HANDLE; external 'advapi32' name 'RegisterServiceCtrlHandlerW'; +function RegEnumKey(hKey:HKEY; dwIndex:DWORD; lpName:LPWSTR; cbName:DWORD):LONG; external 'advapi32' name 'RegEnumKeyW'; +function RegLoadKey(hKey:HKEY; lpSubKey:LPCWSTR; lpFile:LPCWSTR):LONG; external 'advapi32' name 'RegLoadKeyW'; +function RegOpenKey(hKey:HKEY; lpSubKey:LPCWSTR; phkResult:PHKEY):LONG; external 'advapi32' name 'RegOpenKeyW'; +function RegQueryMultipleValues(hKey:HKEY; val_list:PVALENT; num_vals:DWORD; lpValueBuf:LPWSTR; ldwTotsize:LPDWORD):LONG; external 'advapi32' name 'RegQueryMultipleValuesW'; +function RegQueryValue(hKey:HKEY; lpSubKey:LPCWSTR; lpValue:LPWSTR; lpcbValue:PLONG):LONG; external 'advapi32' name 'RegQueryValueW'; +function RegRestoreKey(hKey:HKEY; lpFile:LPCWSTR; dwFlags:DWORD):LONG; external 'advapi32' name 'RegRestoreKeyW'; +function RegSetValue(hKey:HKEY; lpSubKey:LPCWSTR; dwType:DWORD; lpData:LPCWSTR; cbData:DWORD):LONG; external 'advapi32' name 'RegSetValueW'; +function RegSaveKey(hKey:HKEY; lpFile:LPCWSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):LONG; external 'advapi32' name 'RegSaveKeyW'; +function RegUnLoadKey(hKey:HKEY; lpSubKey:LPCWSTR):LONG; external 'advapi32' name 'RegUnLoadKeyW'; +function RemoveProp(hWnd:HWND; lpString:LPCWSTR):HANDLE; external 'user32' name 'RemovePropW'; +function RegCreateKey(hKey:HKEY; lpSubKey:LPCWSTR; phkResult:PHKEY):LONG; external 'advapi32' name 'RegCreateKeyW'; +function RegReplaceKey(hKey:HKEY; lpSubKey:LPCWSTR; lpNewFile:LPCWSTR; lpOldFile:LPCWSTR):LONG; external 'advapi32' name 'RegReplaceKeyW'; +function ReplaceText(_para1:LPFINDREPLACE):HWND; external 'comdlg32' name 'ReplaceTextW'; +function ReportEvent(hEventLog:HANDLE; wType:WORD; wCategory:WORD; dwEventID:DWORD; lpUserSid:PSID;wNumStrings:WORD; dwDataSize:DWORD; lpStrings:LPCWSTR; lpRawData:LPVOID):WINBOOL; external 'advapi32' name 'ReportEventW'; + GrantedAccess:LPDWORD; AccessStatus:LPBOOL;pfGenerateOnClose:LPBOOL):WINBOOL; external 'advapi32' name 'AccessCheckAndAuditAlarmW'; +function ResetDC(_para1:HDC; _para2:LPDEVMODE):HDC; external 'gdi32' name 'ResetDCW'; +function ScrollConsoleScreenBuffer(hConsoleOutput:HANDLE; lpScrollRectangle:PSMALL_RECT; lpClipRectangle:PSMALL_RECT; dwDestinationOrigin:COORD; lpFill:PCHAR_INFO):WINBOOL; external 'kernel32' name 'ScrollConsoleScreenBufferW'; +function SearchPath(lpPath:LPCWSTR; lpFileName:LPCWSTR; lpExtension:LPCWSTR; nBufferLength:DWORD; lpBuffer:LPWSTR;lpFilePart:LPWSTR):DWORD; external 'kernel32' name 'SearchPathW'; +function SendMessageCallback(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM; lpResultCallBack:SENDASYNCPROC;dwData:DWORD):WINBOOL; external 'user32' name 'SendMessageCallbackW'; +function SendMessageTimeout(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM; fuFlags:UINT;uTimeout:UINT; lpdwResult:LPDWORD):LRESULT; external 'user32' name 'SendMessageTimeoutW'; +function SetComputerName(lpComputerName:LPCWSTR):WINBOOL; external 'kernel32' name 'SetComputerNameW'; +function SetConsoleTitle(lpConsoleTitle:LPCWSTR):WINBOOL; external 'kernel32' name 'SetConsoleTitleW'; +function SetCurrentDirectory(lpPathName:LPCWSTR):WINBOOL; external 'kernel32' name 'SetCurrentDirectoryW'; +function SetDefaultCommConfig(lpszName:LPCWSTR; lpCC:LPCOMMCONFIG; dwSize:DWORD):WINBOOL; external 'kernel32' name 'SetDefaultCommConfigW'; +function SetEnvironmentVariable(lpName:LPCWSTR; lpValue:LPCWSTR):WINBOOL; external 'kernel32' name 'SetEnvironmentVariableW'; +function SetFileSecurity(lpFileName:LPCWSTR; SecurityInformation:SECURITY_INFORMATION; pSecurityDescriptor:PSECURITY_DESCRIPTOR):WINBOOL; external 'advapi32' name 'SetFileSecurityW'; +function SetICMProfile(_para1:HDC; _para2:LPWSTR):WINBOOL; external 'gdi32' name 'SetICMProfileW'; +function SetProp(hWnd:HWND; lpString:LPCWSTR; hData:HANDLE):WINBOOL; external 'user32' name 'SetPropW'; +function SetUserObjectInformation(hObj:HANDLE; nIndex:longint; pvInfo:PVOID; nLength:DWORD):WINBOOL; external 'user32' name 'SetUserObjectInformationW'; +function SetVolumeLabel(lpRootPathName:LPCWSTR; lpVolumeName:LPCWSTR):WINBOOL; external 'kernel32' name 'SetVolumeLabelW'; +function ShellAbout(_para1:HWND; _para2:LPCWSTR; _para3:LPCWSTR; _para4:HICON):longint; external 'shell32' name 'ShellAboutW'; +function ShellExecute(_para1:HWND; _para2:LPCWSTR; _para3:LPCWSTR; _para4:LPCWSTR; _para5:LPCWSTR;_para6:longint):HINST; external 'shell32' name 'ShellExecuteW'; +function Shell_NotifyIcon(dwMessage: DWORD; lpData: PNotifyIconDataA): WINBOOL; external 'shell32' name 'Shell_NotifyIconW'; +function StartServiceCtrlDispatcher(lpServiceStartTable:LPSERVICE_TABLE_ENTRY):WINBOOL; external 'advapi32' name 'StartServiceCtrlDispatcherW'; +function StartService(hService:SC_HANDLE; dwNumServiceArgs:DWORD; lpServiceArgVectors:LPCWSTR):WINBOOL; external 'advapi32' name 'StartServiceW'; +function TabbedTextOut(hDC:HDC; X:longint; Y:longint; lpString:LPCWSTR; nCount:longint;nTabPositions:longint; lpnTabStopPositions:LPINT; nTabOrigin:longint):LONG; external 'user32' name 'TabbedTextOutW'; +function TextOut(_para1:HDC; _para2:longint; _para3:longint; _para4:LPCWSTR; _para5:longint):WINBOOL; external 'gdi32' name 'TextOutW'; +function UpdateICMRegKey(_para1:DWORD; _para2:DWORD; _para3:LPWSTR; _para4:UINT):WINBOOL; external 'gdi32' name 'UpdateICMRegKeyW'; +function UpdateResource(hUpdate:HANDLE; lpType:LPCWSTR; lpName:LPCWSTR; wLanguage:WORD; lpData:LPVOID;cbData:DWORD):WINBOOL; external 'kernel32' name 'UpdateResourceW'; +function VerFindFile(uFlags:DWORD; szFileName:LPWSTR; szWinDir:LPWSTR; szAppDir:LPWSTR; szCurDir:LPWSTR;lpuCurDirLen:PUINT; szDestDir:LPWSTR; lpuDestDirLen:PUINT):DWORD; external 'version' name 'VerFindFileW'; +function VerInstallFile(uFlags:DWORD; szSrcFileName:LPWSTR; szDestFileName:LPWSTR; szSrcDir:LPWSTR; szDestDir:LPWSTR;szCurDir:LPWSTR; szTmpFile:LPWSTR; lpuTmpFileLen:PUINT):DWORD; external 'version' name 'VerInstallFileW'; +function VerLanguageName(wLang:DWORD; szLang:LPWSTR; nSize:DWORD):DWORD; external 'kernel32' name 'VerLanguageNameW'; +function VkKeyScan(ch:WCHAR):SHORT; external 'user32' name 'VkKeyScanW'; +function VkKeyScanEx(ch:WCHAR; dwhkl:HKL):SHORT; external 'user32' name 'VkKeyScanExW'; +function WaitNamedPipe(lpNamedPipeName:LPCWSTR; nTimeOut:DWORD):WINBOOL; external 'kernel32' name 'WaitNamedPipeW'; +function WinHelp(hWndMain:HWND; lpszHelp:LPCWSTR; uCommand:UINT; dwData:DWORD):WINBOOL; external 'user32' name 'WinHelpW'; +function WNetAddConnection(lpRemoteName:LPCWSTR; lpPassword:LPCWSTR; lpLocalName:LPCWSTR):DWORD; external 'mpr' name 'WNetAddConnectionW'; +function WNetAddConnection2(lpNetResource:LPNETRESOURCE; lpPassword:LPCWSTR; lpUserName:LPCWSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection2W'; +function WNetCancelConnection(lpName:LPCWSTR; fForce:WINBOOL):DWORD; external 'mpr' name 'WNetCancelConnectionW'; +function WNetGetProviderName(dwNetType:DWORD; lpProviderName:LPWSTR; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetGetProviderNameW'; +function WNetGetNetworkInformation(lpProvider:LPCWSTR; lpNetInfoStruct:LPNETINFOSTRUCT):DWORD; external 'mpr' name 'WNetGetNetworkInformationW'; +function WNetGetLastError(lpError:LPDWORD; lpErrorBuf:LPWSTR; nErrorBufSize:DWORD; lpNameBuf:LPWSTR; nNameBufSize:DWORD):DWORD; external 'mpr' name 'WNetGetLastErrorW'; +function WNetSetConnection(lpName:LPCWSTR; dwProperties:DWORD; pvValues:LPVOID):DWORD; external 'mpr' name 'WNetSetConnectionW'; +function WNetUseConnection(hwndOwner:HWND; lpNetResource:LPNETRESOURCE; lpUserID:LPCWSTR; lpPassword:LPCWSTR; dwFlags:DWORD;lpAccessName:LPWSTR; lpBufferSize:LPDWORD; lpResult:LPDWORD):DWORD; external 'mpr' name 'WNetUseConnectionW'; +function WriteConsole(hConsoleOutput:HANDLE;lpBuffer:pointer; nNumberOfCharsToWrite:DWORD; lpNumberOfCharsWritten:LPDWORD; lpReserved:LPVOID):WINBOOL; external 'kernel32' name 'WriteConsoleW'; +function WriteConsoleInput(hConsoleInput:HANDLE; lpBuffer:PINPUTRECORD; nLength:DWORD; lpNumberOfEventsWritten:LPDWORD):WINBOOL; external 'kernel32' name 'WriteConsoleInputW'; +function WriteConsoleOutput(hConsoleOutput:HANDLE; lpBuffer:PCHAR_INFO; dwBufferSize:COORD; dwBufferCoord:COORD; lpWriteRegion:PSMALL_RECT):WINBOOL; external 'kernel32' name 'WriteConsoleOutputW'; +function WriteConsoleOutputCharacter(hConsoleOutput:HANDLE; lpCharacter:LPCWSTR; nLength:DWORD; dwWriteCoord:COORD; lpNumberOfCharsWritten:LPDWORD):WINBOOL; external 'kernel32' name 'WriteConsoleOutputCharacterW'; +function WritePrivateProfileSection(lpAppName:LPCWSTR; lpString:LPCWSTR; lpFileName:LPCWSTR):WINBOOL; external 'kernel32' name 'WritePrivateProfileSectionW'; +function WritePrivateProfileString(lpAppName:LPCWSTR; lpKeyName:LPCWSTR; lpString:LPCWSTR; lpFileName:LPCWSTR):WINBOOL; external 'kernel32' name 'WritePrivateProfileStringW'; +function WriteProfileSection(lpAppName:LPCWSTR; lpString:LPCWSTR):WINBOOL; external 'kernel32' name 'WriteProfileSectionW'; +function WriteProfileString(lpAppName:LPCWSTR; lpKeyName:LPCWSTR; lpString:LPCWSTR):WINBOOL; external 'kernel32' name 'WriteProfileStringW'; + +//end win32 only +{$endif WIN32} + +{$endif read_interface} + + +{$ifdef read_implementation} + +//begin common win32 & wince + +function CreateWindow(lpClassName:LPCWSTR; lpWindowName:LPCWSTR; dwStyle:DWORD; X:Integer;Y:Integer; nWidth:Integer; nHeight:Integer; hWndParent:HWND; hMenu:HMENU;hInstance:HINST; lpParam:LPVOID):HWND; +begin + CreateWindow:=CreateWindowEx(0,lpClassName,lpWindowName,dwStyle,x,y,nWidth,nHeight,hWndParent,hMenu,hInstance,lpParam); +end; + +function CreateDialogIndirect(hInstance:HINST; lpTemplate:LPCDLGTEMPLATE; hWndParent:HWND; lpDialogFunc:DLGPROC):HWND; +begin + CreateDialogIndirect:=CreateDialogIndirectParam(hInstance,lpTemplate,hWndParent,lpDialogFunc,0); +end; + +function DialogBoxIndirect(hInstance:HINST; lpTemplate:LPCDLGTEMPLATEW; hWndParent:HWND; lpDialogFunc:DLGPROC):longint; +begin + DialogBoxIndirect:=DialogBoxIndirectParam(hInstance,lpTemplate,hWndParent,lpDialogFunc,0); +end; + +//end common win32 & wince + +{$ifdef WINCE} +//begin wince only + +//end wince only +{$endif WINCE} + +{$ifdef WIN32} +//begin win32 only + +function CreateDialog(hInstance:HINST; lpName:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC):HWND; +begin + CreateDialog:=CreateDialogParam(hInstance,lpName,hWndParent,lpDialogFunc,0); +end; + +function DialogBox(hInstance:HINST; lpTemplate:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC):longint; +begin + DialogBox:=DialogBoxParam(hInstance,lpTemplate,hWndParent,lpDialogFunc,0); +end; + +//end win32 only + + + +{$endif WIN32} + +{$endif read_implementation} +