Mercurial > projects > dwt-win
view dwt/internal/win32/WINAPI.d @ 190:72ef824d4983
dwt.program.Program
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Mon, 17 Mar 2008 00:46:30 +0100 |
parents | 52c185ec49e8 |
children | 36f5cb12e1a2 |
line wrap: on
line source
/** * This module declared window APIs required by DWT but not in std.c.windows.windows, * The one in the std.c.windows.windows module are aliased */ module dwt.internal.win32.WINAPI; public import dwt.internal.win32.WINTYPES; //import tango_sys_win32.Types; //import STDWIN = tango_sys_win32.UserGdi; extern(Windows) { HRESULT AssocQueryStringA(ASSOCF flags, int str, LPCTSTR pszAssoc, LPCTSTR pszExtra, LPTSTR pszOut, DWORD *pcchOut); HRESULT AssocQueryStringW(ASSOCF flags, int str, LPCTSTR pszAssoc, LPCTSTR pszExtra, LPTSTR pszOut, DWORD *pcchOut); // BOOL GetWindowInfo(HWND, PWINDOWINFO); // BOOL EnumDisplayMonitors(HDC, RECT*, MONITORENUMPROC, LPARAM); // BOOL GetMonitorInfoA(HMONITOR, LPMONITORINFO); // WINBOOL GetBinaryTypeA(LPCSTR, LPDWORD); // DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD); // LPSTR GetEnvironmentStringsA(); // WINBOOL FreeEnvironmentStringsA(LPSTR); // DWORD FormatMessageA(DWORD, LPCVOID, DWORD, DWORD, LPSTR, DWORD, VA_LIST*); // HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // int lstrcmpA(LPCSTR, LPCSTR); // int lstrcmpiA(LPCSTR, LPCSTR); // LPSTR lstrcpynA(LPSTR, LPCSTR, int); // LPSTR lstrcpyA(LPSTR, LPCSTR); // LPSTR lstrcatA(LPSTR, LPCSTR); // int lstrlenA(LPCSTR); // HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, WINBOOL, LPCSTR); // HANDLE OpenMutexA(DWORD, WINBOOL, LPCSTR); // HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, WINBOOL, WINBOOL, LPCSTR); // HANDLE OpenEventA(DWORD, WINBOOL, LPCSTR); // HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR); // HANDLE OpenSemaphoreA(DWORD, WINBOOL, LPCSTR); // HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR); // HANDLE OpenFileMappingA(DWORD, WINBOOL, LPCSTR); // DWORD GetLogicalDriveStringsA(DWORD, LPSTR); HINST LoadLibraryA(LPCSTR); // HINST LoadLibraryExA(LPCSTR, HANDLE, DWORD); // DWORD GetModuleFileNameA(HINST, LPSTR, DWORD); HMODULE GetModuleHandleA(LPCSTR); // void FatalAppExitA(UINT); // LPSTR GetCommandLineA(); // DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD); // WINBOOL SetEnvironmentVariableA(LPCSTR, LPCSTR); // DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD); // void OutputDebugStringA(LPCSTR); // HRSRC FindResourceA(HINST, LPCSTR, LPCSTR); // HRSRC FindResourceExA(HINST, LPCSTR, LPCSTR, ushort); // WINBOOL EnumResourceTypesA(HINST, ENUMRESTYPEPROC, LONG); // WINBOOL EnumResourceNamesA(HINST, LPCSTR, ENUMRESNAMEPROC, LONG); // WINBOOL EnumResourceLanguagesA(HINST, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG); // HANDLE BeginUpdateResourceA(LPCSTR, WINBOOL); // WINBOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, ushort, LPVOID, DWORD); // WINBOOL EndUpdateResourceA(HANDLE, WINBOOL); // ATOM GlobalAddAtomA(LPCSTR); // ATOM GlobalFindAtomA(LPCSTR); // UINT GlobalGetAtomNameA(ATOM, LPSTR, int); // ATOM AddAtomA(LPCSTR); // ATOM FindAtomA(LPCSTR); // UINT GetAtomNameA(ATOM, LPSTR, int); // UINT GetProfileIntA(LPCSTR, LPCSTR, INT); // DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD); // WINBOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR); // DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD); // WINBOOL WriteProfileSectionA(LPCSTR, LPCSTR); // UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR); // DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR); // WINBOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR); // DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR); // WINBOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR); // UINT GetDriveTypeA(LPCSTR); // UINT GetSystemDirectoryA(LPSTR, UINT); // DWORD GetTempPathA(DWORD, LPSTR); // UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR); // UINT GetWindowsDirectoryA(LPSTR, UINT); // WINBOOL SetCurrentDirectoryA(LPCSTR); // DWORD GetCurrentDirectoryA(DWORD, LPSTR); // WINBOOL GetDiskFreeSpaceA(LPCSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES); // WINBOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES); // WINBOOL RemoveDirectoryA(LPCSTR); // DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*); // WINBOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR); // DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD); HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE); // WINBOOL SetFileAttributesA(LPCSTR, DWORD); // DWORD GetFileAttributesA(LPCSTR); // BOOL GetFileAttributesExA(LPCSTR, DWORD, WIN32_FILE_ATTRIBUTE_DATA*); // DWORD GetCompressedFileSizeA(LPCSTR, LPDWORD); // WINBOOL DeleteFileA(LPCSTR); // DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR); // WINBOOL CopyFileA(LPCSTR, LPCSTR, WINBOOL); // WINBOOL MoveFileA(LPCSTR, LPCSTR); // WINBOOL MoveFileExA(LPCSTR, LPCSTR, DWORD); // HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // WINBOOL GetNamedPipeHandleStateA(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPSTR, DWORD); // WINBOOL CallNamedPipeA(LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD); // WINBOOL WaitNamedPipeA(LPCSTR, DWORD); // WINBOOL SetVolumeLabelA(LPCSTR, LPCSTR); // WINBOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, LPDWORD, LPDWORD, LPDWORD, LPSTR, DWORD); // WINBOOL ClearEventLogA(HANDLE, LPCSTR); // WINBOOL BackupEventLogA(HANDLE, LPCSTR); // HANDLE OpenEventLogA(LPCSTR, LPCSTR); // HANDLE RegisterEventSourceA(LPCSTR, LPCSTR); // HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR); // WINBOOL ReadEventLogA(HANDLE, DWORD, DWORD, LPVOID, DWORD, LPDWORD, LPDWORD); // WINBOOL ReportEventA(HANDLE, ushort, ushort, DWORD, PSID, ushort, DWORD, LPCSTR*, LPVOID); // WINBOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, WINBOOL, LPDWORD, LPBOOL, LPBOOL); // WINBOOL ObjectOpenAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, WINBOOL, WINBOOL, LPBOOL); // WINBOOL ObjectPrivilegeAuditAlarmA(LPCSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET, WINBOOL); // WINBOOL ObjectCloseAuditAlarmA(LPCSTR, LPVOID, WINBOOL); // WINBOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, WINBOOL); // WINBOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); // WINBOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD); // HANDLE FindFirstChangeNotificationA(LPCSTR, WINBOOL, DWORD); // WINBOOL IsBadStringPtrA(LPCSTR, UINT); // WINBOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, LPDWORD, LPSTR, LPDWORD, PSID_NAME_USE); // WINBOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, LPDWORD, LPSTR, LPDWORD, PSID_NAME_USE); // WINBOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID); // WINBOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, LPDWORD); // WINBOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, LPDWORD, LPDWORD); // WINBOOL BuildCommDCBA(LPCSTR, LPDCB); // WINBOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS); // WINBOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG); // WINBOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, LPDWORD); // WINBOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD); // WINBOOL GetComputerNameA(LPSTR, LPDWORD); // WINBOOL SetComputerNameA(LPCSTR); // WINBOOL GetUserNameA(LPSTR, LPDWORD); // int wvsprintfA(LPSTR, LPCSTR, VA_LIST*); // HKL LoadKeyboardLayoutA(LPCSTR, UINT); // WINBOOL GetKeyboardLayoutNameA(LPSTR); // HDESK CreateDesktopA(LPSTR, LPSTR, LPDEVMODE, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // HDESK OpenDesktopA(LPSTR, DWORD, WINBOOL, DWORD); // WINBOOL EnumDesktopsA(HWINSTA, DESKTOPENUMPROC, LPARAM); // HWINSTA CreateWindowStationA(LPSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // HWINSTA OpenWindowStationA(LPSTR, WINBOOL, DWORD); // WINBOOL EnumWindowStationsA(ENUMWINDOWSTATIONPROC, LPARAM); // WINBOOL GetUserObjectInformationA(HANDLE, int, PVOID, DWORD, LPDWORD); // WINBOOL SetUserObjectInformationA(HANDLE, int, PVOID, DWORD); // UINT RegisterWindowMessageA(LPCSTR); WINBOOL GetMessageA(LPMSG, HWND, UINT, UINT); // LONG DispatchMessageA(LPMSG); WINBOOL PeekMessageA(LPMSG, HWND, UINT, UINT, UINT); // LRESULT SendMessageA(HWND, UINT, WPARAM, LPARAM); // LRESULT SendMessageTimeoutA(HWND, UINT, WPARAM, LPARAM, UINT, UINT, LPDWORD); // WINBOOL SendNotifyMessageA(HWND, UINT, WPARAM, LPARAM); // WINBOOL SendMessageCallbackA(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, DWORD); // WINBOOL PostMessageA(HWND, UINT, WPARAM, LPARAM); // WINBOOL PostThreadMessageA(DWORD, UINT, WPARAM, LPARAM); LRESULT DefWindowProcA(HWND, UINT, WPARAM, LPARAM); // LRESULT CallWindowProcA(WNDPROC, HWND, UINT, WPARAM, LPARAM); // ATOM RegisterClassA(LPWNDCLASS); // WINBOOL UnregisterClassA(LPCSTR, HINST); // WINBOOL GetClassInfoA(HINST, LPCSTR, LPWNDCLASS); // ATOM RegisterClassExA(LPWNDCLASSEX); // WINBOOL GetClassInfoExA(HINST, LPCSTR, LPWNDCLASSEX); HWND CreateWindowExA(DWORD, LPCSTR, LPCSTR, DWORD, int, int, int, int, HWND, HMENU, HINST, LPVOID); // HWND CreateDialogParamA(HINST, LPCSTR, HWND, DLGPROC, LPARAM); // HWND CreateDialogIndirectParamA(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM); // int DialogBoxParamA(HINST, LPCSTR, HWND, DLGPROC, LPARAM); // int DialogBoxIndirectParamA(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM); // WINBOOL SetDlgItemTextA(HWND, int, LPCSTR); // UINT GetDlgItemTextA(HWND, int, LPSTR, int); // LONG SendDlgItemMessageA(HWND, int, UINT, WPARAM, LPARAM); // LRESULT DefDlgProcA(HWND, UINT, WPARAM, LPARAM); // WINBOOL CallMsgFilterA(LPMSG, int); // UINT RegisterClipboardFormatA(LPCSTR); // int GetClipboardFormatNameA(UINT, LPSTR, int); // WINBOOL CharToOemA(LPCSTR, LPSTR); // WINBOOL OemToCharA(LPCSTR, LPSTR); // WINBOOL CharToOemBuffA(LPCSTR, LPSTR, DWORD); // WINBOOL OemToCharBuffA(LPCSTR, LPSTR, DWORD); // LPSTR CharUpperA(LPSTR); // DWORD CharUpperBuffA(LPSTR, DWORD); // LPSTR CharLowerA(LPSTR); // DWORD CharLowerBuffA(LPSTR, DWORD); // LPSTR CharNextA(LPCSTR); // LPSTR CharPrevA(LPCSTR, LPCSTR); // WINBOOL IsCharAlphaA(char); // WINBOOL IsCharAlphaNumericA(char); // WINBOOL IsCharUpperA(char); // WINBOOL IsCharLowerA(char); // int GetKeyNameTextA(LONG, LPSTR, int); // SHORT VkKeyScanA(char); // SHORT VkKeyScanExA(char, HKL); // UINT MapVirtualKeyA(UINT, UINT); // UINT MapVirtualKeyExA(UINT, UINT, HKL); // HACCEL LoadAcceleratorsA(HINST, LPCSTR); // HACCEL CreateAcceleratorTableA(LPACCEL, int); // int CopyAcceleratorTableA(HACCEL, LPACCEL, int); // int TranslateAcceleratorA(HWND, HACCEL, LPMSG); // HMENU LoadMenuA(HINST, LPCSTR); // HMENU LoadMenuIndirectA(LPMENUTEMPLATE); // WINBOOL ChangeMenuA(HMENU, UINT, LPCSTR, UINT, UINT); // int GetMenuStringA(HMENU, UINT, LPSTR, int, UINT); // WINBOOL InsertMenuA(HMENU, UINT, UINT, UINT, LPCSTR); // WINBOOL AppendMenuA(HMENU, UINT, UINT, LPCSTR); // WINBOOL ModifyMenuA(HMENU, UINT, UINT, UINT, LPCSTR); // WINBOOL InsertMenuItemA(HMENU, UINT, WINBOOL, LPCMENUITEMINFO); // WINBOOL GetMenuItemInfoA(HMENU, UINT, WINBOOL, LPMENUITEMINFO); // WINBOOL SetMenuItemInfoA(HMENU, UINT, WINBOOL, LPCMENUITEMINFO); // int DrawTextA(HDC, LPCSTR, int, LPRECT, UINT); // int DrawTextExA(HDC, LPSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS); // WINBOOL GrayStringA(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int); // WINBOOL DrawStateA(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int, UINT); // LONG TabbedTextOutA(HDC, int, int, LPCSTR, int, int, LPINT, int); // DWORD GetTabbedTextExtentA(HDC, LPCSTR, int, int, LPINT); // WINBOOL SetPropA(HWND, LPCSTR, HANDLE); // HANDLE GetPropA(HWND, LPCSTR); // HANDLE RemovePropA(HWND, LPCSTR); // int EnumPropsExA(HWND, PROPENUMPROCEX, LPARAM); // int EnumPropsA(HWND, PROPENUMPROC); // WINBOOL SetWindowTextA(HWND, LPCSTR); // int GetWindowTextA(HWND, LPSTR, int); // int GetWindowTextLengthA(HWND); int MessageBoxA(HWND, LPCSTR, LPCSTR, UINT); // int MessageBoxExA(HWND, LPCSTR, LPCSTR, UINT, ushort); // int MessageBoxIndirectA(LPMSGBOXPARAMS); // LONG GetWindowLongA(HWND, int); // LONG SetWindowLongA(HWND, int, LONG); // DWORD GetClassLongA(HWND, int); // DWORD SetClassLongA(HWND, int, LONG); // HWND FindWindowA(LPCSTR, LPCSTR); // HWND FindWindowExA(HWND, HWND, LPCSTR, LPCSTR); // int GetClassNameA(HWND, LPSTR, int); // HHOOK SetWindowsHookExA(int, HOOKPROC, HINST, DWORD); // HBITMAP LoadBitmapA(HINST, LPCSTR); HCURSOR LoadCursorA(HINST, LPCSTR); // HCURSOR LoadCursorFromFileA(LPCSTR); HICON LoadIconA(HINST, LPCSTR); // HANDLE LoadImageA(HINST, LPCSTR, UINT, int, int, UINT); // int LoadStringA(HINST, UINT, LPSTR, int); // WINBOOL IsDialogMessageA(HWND, LPMSG); // int DlgDirListA(HWND, LPSTR, int, int, UINT); // WINBOOL DlgDirSelectExA(HWND, LPSTR, int, int); // int DlgDirListComboBoxA(HWND, LPSTR, int, int, UINT); // WINBOOL DlgDirSelectComboBoxExA(HWND, LPSTR, int, int); // LRESULT DefFrameProcA(HWND, HWND, UINT, WPARAM, LPARAM); // LRESULT DefMDIChildProcA(HWND, UINT, WPARAM, LPARAM); // HWND CreateMDIWindowA(LPSTR, LPSTR, DWORD, int, int, int, int, HWND, HINST, LPARAM); // WINBOOL WinHelpA(HWND, LPCSTR, UINT, DWORD); // LONG ChangeDisplaySettingsA(LPDEVMODE, DWORD); // WINBOOL EnumDisplaySettingsA(LPCSTR, DWORD, LPDEVMODE); // WINBOOL SystemParametersInfoA(UINT, UINT, PVOID, UINT); // int AddFontResourceA(LPCSTR); // HMETAFILE CopyMetaFileA(HMETAFILE, LPCSTR); // HFONT CreateFontIndirectA(LPLOGFONT); // HDC CreateICA(LPCSTR, LPCSTR, LPCSTR, LPDEVMODE); // HDC CreateMetaFileA(LPCSTR); // WINBOOL CreateScalableFontResourceA(DWORD, LPCSTR, LPCSTR, LPCSTR); // int EnumFontFamiliesExA(HDC, LPLOGFONT, FONTENUMEXPROC, LPARAM, DWORD); // int EnumFontFamiliesA(HDC, LPCSTR, FONTENUMPROC, LPARAM); // int EnumFontsA(HDC, LPCSTR, ENUMFONTSPROC, LPARAM); // WINBOOL GetCharWidthA(HDC, UINT, UINT, LPINT); // WINBOOL GetCharWidth32A(HDC, UINT, UINT, LPINT); // WINBOOL GetCharWidthFloatA(HDC, UINT, UINT, PFLOAT); // WINBOOL GetCharABCWidthsA(HDC, UINT, UINT, LPABC); // WINBOOL GetCharABCWidthsFloatA(HDC, UINT, UINT, LPABCFLOAT); // DWORD GetGlyphOutlineA(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID, PMAT2); // HMETAFILE GetMetaFileA(LPCSTR); // UINT GetOutlineTextMetricsA(HDC, UINT, LPOUTLINETEXTMETRIC); // WINBOOL GetTextExtentPointA(HDC, LPCSTR, int, LPSIZE); // WINBOOL GetTextExtentPoint32A(HDC, LPCSTR, int, LPSIZE); // WINBOOL GetTextExtentExPointA(HDC, LPCSTR, int, int, LPINT, LPINT, LPSIZE); // DWORD GetCharacterPlacementA(HDC, LPCSTR, int, int, LPGCP_RESULTS, DWORD); // HDC ResetDCA(HDC, LPDEVMODE); // WINBOOL RemoveFontResourceA(LPCSTR); // HENHMETAFILE CopyEnhMetaFileA(HENHMETAFILE, LPCSTR); // HDC CreateEnhMetaFileA(HDC, LPCSTR, LPRECT, LPCSTR); // HENHMETAFILE GetEnhMetaFileA(LPCSTR); // UINT GetEnhMetaFileDescriptionA(HENHMETAFILE, UINT, LPSTR); WINBOOL GetTextMetricsA(HDC, LPTEXTMETRIC); // int StartDocA(HDC, PDOCINFO); int GetObjectA(HGDIOBJ, int, LPVOID); // WINBOOL TextOutA(HDC, int, int, LPCSTR, int); // WINBOOL ExtTextOutA(HDC, int, int, UINT, LPRECT, LPCSTR, UINT, LPINT); // WINBOOL PolyTextOutA(HDC, PPOLYTEXT, int); // int GetTextFaceA(HDC, int, LPSTR); // DWORD GetKerningPairsA(HDC, DWORD, LPKERNINGPAIR); // HCOLORSPACE CreateColorSpaceA(LPLOGCOLORSPACE); // WINBOOL GetLogColorSpaceA(HCOLORSPACE, LPLOGCOLORSPACE, DWORD); // WINBOOL GetICMProfileA(HDC, DWORD, LPSTR); // WINBOOL SetICMProfileA(HDC, LPSTR); // WINBOOL UpdateICMRegKeyA(DWORD, DWORD, LPSTR, UINT); // int EnumICMProfilesA(HDC, ICMENUMPROC, LPARAM); // int PropertySheetA(LPCPROPSHEETHEADER); // HIMAGELIST ImageList_LoadImageA(HINST, LPCSTR, int, int, COLORREF, UINT, UINT); // HWND CreateStatusWindowA(LONG, LPCSTR, HWND, UINT); // void DrawStatusTextA(HDC, LPRECT, LPCSTR); // WINBOOL GetOpenFileNameA(LPOPENFILENAME); // WINBOOL GetSaveFileNameA(LPOPENFILENAME); // int GetFileTitleA(LPCSTR, LPSTR, ushort); // WINBOOL ChooseColorA(LPCHOOSECOLOR); // HWND FindTextA(LPFINDREPLACE); // HWND ReplaceTextA(LPFINDREPLACE); // WINBOOL ChooseFontA(LPCHOOSEFONT); // WINBOOL PrintDlgA(LPPRINTDLG); // WINBOOL PageSetupDlgA(LPPAGESETUPDLG); // WINBOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION); // void GetStartupInfoA(LPSTARTUPINFO); // HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATA); // WINBOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATA); // WINBOOL GetVersionExA(LPOSVERSIONINFO); // HDC CreateDCA(LPCSTR, LPCSTR, LPCSTR, PDEVMODE); // DWORD VerInstallFileA(DWORD, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, PUINT); // DWORD GetFileVersionInfoSizeA(LPSTR, LPDWORD); // WINBOOL GetFileVersionInfoA(LPSTR, DWORD, DWORD, LPVOID); // DWORD VerLanguageNameA(DWORD, LPSTR, DWORD); // WINBOOL VerQueryValueA(LPVOID, LPSTR, LPVOID, PUINT); // DWORD VerFindFileA(DWORD, LPSTR, LPSTR, LPSTR, LPSTR, PUINT, LPSTR, PUINT); // LONG RegConnectRegistryA(LPSTR, HKEY, PHKEY); // LONG RegCreateKeyA(HKEY, LPCSTR, PHKEY); // LONG RegCreateKeyExA(HKEY, LPCSTR, DWORD, LPSTR, DWORD, REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD); // LONG RegDeleteKeyA(HKEY, LPCSTR); // LONG RegDeleteValueA(HKEY, LPCSTR); // LONG RegEnumKeyA(HKEY, DWORD, LPSTR, DWORD); // LONG RegEnumKeyExA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPSTR, LPDWORD, PFILETIME); // LONG RegEnumValueA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE, LPDWORD); // LONG RegLoadKeyA(HKEY, LPCSTR, LPCSTR); // LONG RegOpenKeyA(HKEY, LPCSTR, PHKEY); // LONG RegOpenKeyExA(HKEY, LPCSTR, DWORD, REGSAM, PHKEY); // LONG RegQueryInfoKeyA(HKEY, LPSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME); // LONG RegQueryValueA(HKEY, LPCSTR, LPSTR, PLONG); // LONG RegQueryMultipleValuesA(HKEY, PVALENT, DWORD, LPSTR, LPDWORD); // LONG RegQueryValueExA(HKEY, LPCSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD); // LONG RegReplaceKeyA(HKEY, LPCSTR, LPCSTR, LPCSTR); // LONG RegRestoreKeyA(HKEY, LPCSTR, DWORD); // LONG RegSaveKeyA(HKEY, LPCSTR, LPSECURITY_ATTRIBUTES); // LONG RegSetValueA(HKEY, LPCSTR, DWORD, LPCSTR, DWORD); // LONG RegSetValueExA(HKEY, LPCSTR, DWORD, DWORD, LPBYTE, DWORD); // LONG RegUnLoadKeyA(HKEY, LPCSTR); // WINBOOL InitiateSystemShutdownA(LPSTR, LPSTR, DWORD, WINBOOL, WINBOOL); // WINBOOL AbortSystemShutdownA(LPSTR); // int CompareStringA(LCID, DWORD, LPCSTR, int, LPCSTR, int); // int LCMapStringA(LCID, DWORD, LPCSTR, int, LPSTR, int); // int GetLocaleInfoA(LCID, LCTYPE, LPSTR, int); // WINBOOL SetLocaleInfoA(LCID, LCTYPE, LPCSTR); int GetTimeFormatA(LCID, DWORD, LPSYSTEMTIME, LPCSTR, LPSTR, int); int GetDateFormatA(LCID, DWORD, LPSYSTEMTIME, LPCSTR, LPSTR, int); // int GetNumberFormatA(LCID, DWORD, LPCSTR, PNUMBERFMT, LPSTR, int); // int GetCurrencyFormatA(LCID, DWORD, LPCSTR, PCURRENCYFMT, LPSTR, int); // WINBOOL EnumCalendarInfoA(CALINFO_ENUMPROC, LCID, CALID, CALTYPE); // WINBOOL EnumTimeFormatsA(TIMEFMT_ENUMPROC, LCID, DWORD); // WINBOOL EnumDateFormatsA(DATEFMT_ENUMPROC, LCID, DWORD); // WINBOOL GetStringTypeExA(LCID, DWORD, LPCSTR, int, LPWORD); // WINBOOL GetStringTypeA(LCID, DWORD, LPCSTR, int, LPWORD); // int FoldStringA(DWORD, LPCSTR, int, LPSTR, int); // WINBOOL EnumSystemLocalesA(LOCALE_ENUMPROC, DWORD); // WINBOOL EnumSystemCodePagesA(CODEPAGE_ENUMPROC, DWORD); // WINBOOL PeekConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD); // WINBOOL ReadConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD); // WINBOOL WriteConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD); // WINBOOL ReadConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT); // WINBOOL WriteConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT); // WINBOOL ReadConsoleOutputCharacterA(HANDLE, LPSTR, DWORD, COORD, LPDWORD); // WINBOOL WriteConsoleOutputCharacterA(HANDLE, LPCSTR, DWORD, COORD, LPDWORD); // WINBOOL FillConsoleOutputCharacterA(HANDLE, char, DWORD, COORD, LPDWORD); // WINBOOL ScrollConsoleScreenBufferA(HANDLE, PSMALL_RECT, PSMALL_RECT, COORD, PCHAR_INFO); // DWORD GetConsoleTitleA(LPSTR, DWORD); // WINBOOL SetConsoleTitleA(LPCSTR); // WINBOOL ReadConsoleA(HANDLE, LPVOID, DWORD, LPDWORD, LPVOID); // WINBOOL WriteConsoleA(HANDLE, POINTER, DWORD, LPDWORD, LPVOID); // DWORD WNetAddConnectionA(LPCSTR, LPCSTR, LPCSTR); // DWORD WNetAddConnection2A(LPNETRESOURCE, LPCSTR, LPCSTR, DWORD); // DWORD WNetAddConnection3A(HWND, LPNETRESOURCE, LPCSTR, LPCSTR, DWORD); // DWORD WNetCancelConnectionA(LPCSTR, WINBOOL); // DWORD WNetCancelConnection2A(LPCSTR, DWORD, WINBOOL); // DWORD WNetGetConnectionA(LPCSTR, LPSTR, LPDWORD); // DWORD WNetUseConnectionA(HWND, LPNETRESOURCE, LPCSTR, LPCSTR, DWORD, LPSTR, LPDWORD, LPDWORD); // DWORD WNetSetConnectionA(LPCSTR, DWORD, LPVOID); // DWORD WNetConnectionDialog1A(LPCONNECTDLGSTRUCT); // DWORD WNetDisconnectDialog1A(LPDISCDLGSTRUCT); // DWORD WNetOpenEnumA(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE); // DWORD WNetEnumResourceA(HANDLE, LPDWORD, LPVOID, LPDWORD); // DWORD WNetGetUniversalNameA(LPCSTR, DWORD, LPVOID, LPDWORD); // DWORD WNetGetUserA(LPCSTR, LPSTR, LPDWORD); // DWORD WNetGetProviderNameA(DWORD, LPSTR, LPDWORD); // DWORD WNetGetNetworkInformationA(LPCSTR, LPNETINFOSTRUCT); // DWORD WNetGetLastErrorA(LPDWORD, LPSTR, DWORD, LPSTR, DWORD); // DWORD MultinetGetConnectionPerformanceA(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT); // WINBOOL ChangeServiceConfigA(SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR); // SC_HANDLE CreateServiceA(SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR); // WINBOOL EnumDependentServicesA(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD); // WINBOOL EnumServicesStatusA(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL GetServiceKeyNameA(SC_HANDLE, LPCSTR, LPSTR, LPDWORD); // WINBOOL GetServiceDisplayNameA(SC_HANDLE, LPCSTR, LPSTR, LPDWORD); // SC_HANDLE OpenSCManagerA(LPCSTR, LPCSTR, DWORD); // SC_HANDLE OpenServiceA(SC_HANDLE, LPCSTR, DWORD); // WINBOOL QueryServiceConfigA(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD); // WINBOOL QueryServiceLockStatusA(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD, LPDWORD); // SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR, LPHANDLER_FUNCTION); // WINBOOL StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRY); // WINBOOL StartServiceA(SC_HANDLE, DWORD, LPCSTR); // uint DragQueryFileA(HDROP, uint, PCHAR, uint); // HICON ExtractAssociatedIconA(HINST, PCHAR, LPWORD); // HICON ExtractIconA(HINST, PCHAR, uint); // HINST FindExecutableA(PCHAR, PCHAR, PCHAR); // int ShellAboutA(HWND, PCHAR, PCHAR, HICON); // HINST ShellExecuteA(HWND, PCHAR, PCHAR, PCHAR, PCHAR, int); // HSZ DdeCreateStringHandleA(DWORD, PCHAR, int); // UINT DdeInitializeA(LPDWORD, PFNCALLBACK, DWORD, DWORD); // DWORD DdeQueryStringA(DWORD, HSZ, PCHAR, DWORD, int); // WINBOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE); // WINBOOL CreateProcessAsUserA(HANDLE, LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCTSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION); // WINBOOL GetBinaryTypeW(LPCWSTR, LPDWORD); // DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD); // LPWSTR GetEnvironmentStringsW(); // WINBOOL FreeEnvironmentStringsW(LPWSTR); // DWORD FormatMessageW(DWORD, LPCVOID, DWORD, DWORD, LPWSTR, DWORD, VA_LIST*); // HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // int lstrcmpW(LPCWSTR, LPCWSTR); // int lstrcmpiW(LPCWSTR, LPCWSTR); // LPWSTR lstrcpynW(LPWSTR, LPCWSTR, int); // LPWSTR lstrcpyW(LPWSTR, LPCWSTR); // LPWSTR lstrcatW(LPWSTR, LPCWSTR); // int lstrlenW(LPCWSTR); // HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, WINBOOL, LPCWSTR); // HANDLE OpenMutexW(DWORD, WINBOOL, LPCWSTR); // HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, WINBOOL, WINBOOL, LPCWSTR); // HANDLE OpenEventW(DWORD, WINBOOL, LPCWSTR); // HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR); // HANDLE OpenSemaphoreW(DWORD, WINBOOL, LPCWSTR); // HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR); // HANDLE OpenFileMappingW(DWORD, WINBOOL, LPCWSTR); // DWORD GetLogicalDriveStringsW(DWORD, LPWSTR); // HINST LoadLibraryW(LPCWSTR); // HINST LoadLibraryExW(LPCWSTR, HANDLE, DWORD); // DWORD GetModuleFileNameW(HINST, LPWSTR, DWORD); // HMODULE GetModuleHandleW(LPCWSTR); // void FatalAppExitW(UINT); // LPWSTR GetCommandLineW(); // DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD); // WINBOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR); // DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD); // void OutputDebugStringW(LPCWSTR); // HRSRC FindResourceW(HINST, LPCWSTR, LPCWSTR); // HRSRC FindResourceExW(HINST, LPCWSTR, LPCWSTR, ushort); // WINBOOL EnumResourceTypesW(HINST, ENUMRESTYPEPROC, LONG); // WINBOOL EnumResourceNamesW(HINST, LPCWSTR, ENUMRESNAMEPROC, LONG); // WINBOOL EnumResourceLanguagesW(HINST, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG); // HANDLE BeginUpdateResourceW(LPCWSTR, WINBOOL); // WINBOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, ushort, LPVOID, DWORD); // WINBOOL EndUpdateResourceW(HANDLE, WINBOOL); ATOM GlobalAddAtomW(LPCWSTR); // ATOM GlobalFindAtomW(LPCWSTR); // UINT GlobalGetAtomNameW(ATOM, LPWSTR, int); // ATOM AddAtomW(LPCWSTR); // ATOM FindAtomW(LPCWSTR); // UINT GetAtomNameW(ATOM, LPWSTR, int); // UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT); // DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD); // WINBOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR); // DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD); // WINBOOL WriteProfileSectionW(LPCWSTR, LPCWSTR); // UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR); // DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR); // WINBOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR); // DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR); // WINBOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR); // UINT GetDriveTypeW(LPCWSTR); // UINT GetSystemDirectoryW(LPWSTR, UINT); // DWORD GetTempPathW(DWORD, LPWSTR); // UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR); // UINT GetWindowsDirectoryW(LPWSTR, UINT); // WINBOOL SetCurrentDirectoryW(LPCWSTR); // DWORD GetCurrentDirectoryW(DWORD, LPWSTR); // WINBOOL GetDiskFreeSpaceW(LPCWSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES); // WINBOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES); // WINBOOL RemoveDirectoryW(LPCWSTR); // DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*); // WINBOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR); // DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD); HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE); // WINBOOL SetFileAttributesW(LPCWSTR, DWORD); // DWORD GetFileAttributesW(LPCWSTR); // BOOL GetFileAttributesExW(LPCWSTR, DWORD, WIN32_FILE_ATTRIBUTE_DATA*); // DWORD GetCompressedFileSizeW(LPCWSTR, LPDWORD); WINBOOL DeleteFileW(LPCWSTR); // DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR); // WINBOOL CopyFileW(LPCWSTR, LPCWSTR, WINBOOL); // WINBOOL MoveFileW(LPCWSTR, LPCWSTR); // WINBOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD); // HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // WINBOOL GetNamedPipeHandleStateW(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPWSTR, DWORD); // WINBOOL CallNamedPipeW(LPCWSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD); // WINBOOL WaitNamedPipeW(LPCWSTR, DWORD); // WINBOOL SetVolumeLabelW(LPCWSTR, LPCWSTR); // WINBOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, LPDWORD, LPDWORD, LPDWORD, LPWSTR, DWORD); // WINBOOL ClearEventLogW(HANDLE, LPCWSTR); // WINBOOL BackupEventLogW(HANDLE, LPCWSTR); // HANDLE OpenEventLogW(LPCWSTR, LPCWSTR); // HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR); // HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR); // WINBOOL ReadEventLogW(HANDLE, DWORD, DWORD, LPVOID, DWORD, LPDWORD, LPDWORD); // WINBOOL ReportEventW(HANDLE, ushort, ushort, DWORD, PSID, ushort, DWORD, LPCWSTR*, LPVOID); // WINBOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, WINBOOL, LPDWORD, LPBOOL, LPBOOL); // WINBOOL ObjectOpenAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, WINBOOL, WINBOOL, LPBOOL); // WINBOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET, WINBOOL); // WINBOOL ObjectCloseAuditAlarmW(LPCWSTR, LPVOID, WINBOOL); // WINBOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, WINBOOL); // WINBOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); // WINBOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD); // HANDLE FindFirstChangeNotificationW(LPCWSTR, WINBOOL, DWORD); // WINBOOL IsBadStringPtrW(LPCWSTR, UINT); // WINBOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE); // WINBOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE); // WINBOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID); // WINBOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, LPDWORD); // WINBOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, LPDWORD, LPDWORD); // WINBOOL BuildCommDCBW(LPCWSTR, LPDCB); // WINBOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS); // WINBOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG); // WINBOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, LPDWORD); // WINBOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD); // WINBOOL GetComputerNameW(LPWSTR, LPDWORD); // WINBOOL SetComputerNameW(LPCWSTR); // WINBOOL GetUserNameW(LPWSTR, LPDWORD); // int wvsprintfW(LPWSTR, LPCWSTR, VA_LIST*); // HKL LoadKeyboardLayoutW(LPCWSTR, UINT); // WINBOOL GetKeyboardLayoutNameW(LPWSTR); // HDESK CreateDesktopW(LPWSTR, LPWSTR, LPDEVMODE, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // HDESK OpenDesktopW(LPWSTR, DWORD, WINBOOL, DWORD); // WINBOOL EnumDesktopsW(HWINSTA, DESKTOPENUMPROC, LPARAM); // HWINSTA CreateWindowStationW(LPWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES); // HWINSTA OpenWindowStationW(LPWSTR, WINBOOL, DWORD); // WINBOOL EnumWindowStationsW(ENUMWINDOWSTATIONPROC, LPARAM); // WINBOOL GetUserObjectInformationW(HANDLE, int, PVOID, DWORD, LPDWORD); // WINBOOL SetUserObjectInformationW(HANDLE, int, PVOID, DWORD); // UINT RegisterWindowMessageW(LPCWSTR); // WINBOOL GetMessageW(LPMSG, HWND, UINT, UINT); // LONG DispatchMessageW(LPMSG); // WINBOOL PeekMessageW(LPMSG, HWND, UINT, UINT, UINT); // LRESULT SendMessageW(HWND, UINT, WPARAM, LPARAM); // LRESULT SendMessageTimeoutW(HWND, UINT, WPARAM, LPARAM, UINT, UINT, LPDWORD); // WINBOOL SendNotifyMessageW(HWND, UINT, WPARAM, LPARAM); // WINBOOL SendMessageCallbackW(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, DWORD); // WINBOOL PostMessageW(HWND, UINT, WPARAM, LPARAM); // WINBOOL PostThreadMessageW(DWORD, UINT, WPARAM, LPARAM); // LRESULT DefWindowProcW(HWND, UINT, WPARAM, LPARAM); // LRESULT CallWindowProcW(WNDPROC, HWND, UINT, WPARAM, LPARAM); // ATOM RegisterClassW(LPWNDCLASS); // WINBOOL UnregisterClassW(LPCWSTR, HINST); // WINBOOL GetClassInfoW(HINST, LPCWSTR, LPWNDCLASS); // ATOM RegisterClassExW(LPWNDCLASSEX); // WINBOOL GetClassInfoExW(HINST, LPCWSTR, LPWNDCLASSEX); // HWND CreateWindowExW(DWORD, LPCWSTR, LPCWSTR, DWORD, int, int, int, int, HWND, HMENU, HINST, LPVOID); // HWND CreateDialogParamW(HINST, LPCWSTR, HWND, DLGPROC, LPARAM); // HWND CreateDialogIndirectParamW(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM); // int DialogBoxParamW(HINST, LPCWSTR, HWND, DLGPROC, LPARAM); // int DialogBoxIndirectParamW(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM); // WINBOOL SetDlgItemTextW(HWND, int, LPCWSTR); // UINT GetDlgItemTextW(HWND, int, LPWSTR, int); // LONG SendDlgItemMessageW(HWND, int, UINT, WPARAM, LPARAM); // LRESULT DefDlgProcW(HWND, UINT, WPARAM, LPARAM); // WINBOOL CallMsgFilterW(LPMSG, int); // UINT RegisterClipboardFormatW(LPCWSTR); // int GetClipboardFormatNameW(UINT, LPWSTR, int); // WINBOOL CharToOemW(LPCWSTR, LPSTR); // WINBOOL OemToCharW(LPCSTR, LPWSTR); // WINBOOL CharToOemBuffW(LPCWSTR, LPSTR, DWORD); // WINBOOL OemToCharBuffW(LPCSTR, LPWSTR, DWORD); // LPWSTR CharUpperW(LPWSTR); // DWORD CharUpperBuffW(LPWSTR, DWORD); // LPWSTR CharLowerW(LPWSTR); // DWORD CharLowerBuffW(LPWSTR, DWORD); // LPWSTR CharNextW(LPCWSTR); // LPWSTR CharPrevW(LPCWSTR, LPCWSTR); // WINBOOL IsCharAlphaW(WCHAR); // WINBOOL IsCharAlphaNumericW(WCHAR); // WINBOOL IsCharUpperW(WCHAR); // WINBOOL IsCharLowerW(WCHAR); // int GetKeyNameTextW(LONG, LPWSTR, int); // SHORT VkKeyScanW(WCHAR); // SHORT VkKeyScanExW(WCHAR, HKL); // UINT MapVirtualKeyW(UINT, UINT); // UINT MapVirtualKeyExW(UINT, UINT, HKL); // HACCEL LoadAcceleratorsW(HINST, LPCWSTR); // HACCEL CreateAcceleratorTableW(LPACCEL, int); // int CopyAcceleratorTableW(HACCEL, LPACCEL, int); // int TranslateAcceleratorW(HWND, HACCEL, LPMSG); // HMENU LoadMenuW(HINST, LPCWSTR); // HMENU LoadMenuIndirectW(LPMENUTEMPLATE); // WINBOOL ChangeMenuW(HMENU, UINT, LPCWSTR, UINT, UINT); // int GetMenuStringW(HMENU, UINT, LPWSTR, int, UINT); // WINBOOL InsertMenuW(HMENU, UINT, UINT, UINT, LPCWSTR); // WINBOOL AppendMenuW(HMENU, UINT, UINT, LPCWSTR); // WINBOOL ModifyMenuW(HMENU, UINT, UINT, UINT, LPCWSTR); // WINBOOL InsertMenuItemW(HMENU, UINT, WINBOOL, LPCMENUITEMINFO); // WINBOOL GetMenuItemInfoW(HMENU, UINT, WINBOOL, LPMENUITEMINFO); // WINBOOL SetMenuItemInfoW(HMENU, UINT, WINBOOL, LPCMENUITEMINFO); // int DrawTextW(HDC, LPCWSTR, int, LPRECT, UINT); // int DrawTextExW(HDC, LPWSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS); // WINBOOL GrayStringW(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int); // WINBOOL DrawStateW(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int, UINT); // LONG TabbedTextOutW(HDC, int, int, LPCWSTR, int, int, LPINT, int); // DWORD GetTabbedTextExtentW(HDC, LPCWSTR, int, int, LPINT); WINBOOL SetPropW(HWND, LPCWSTR, HANDLE); HANDLE GetPropW(HWND, LPCWSTR); HANDLE RemovePropW(HWND, LPCWSTR); // int EnumPropsExW(HWND, PROPENUMPROCEX, LPARAM); // int EnumPropsW(HWND, PROPENUMPROC); // WINBOOL SetWindowTextW(HWND, LPCWSTR); // int GetWindowTextW(HWND, LPWSTR, int); // int GetWindowTextLengthW(HWND); // int MessageBoxW(HWND, LPCWSTR, LPCWSTR, UINT); // int MessageBoxExW(HWND, LPCWSTR, LPCWSTR, UINT, ushort); // int MessageBoxIndirectW(LPMSGBOXPARAMS); // LONG GetWindowLongW(HWND, int); // LONG SetWindowLongW(HWND, int, LONG); // DWORD GetClassLongW(HWND, int); // DWORD SetClassLongW(HWND, int, LONG); // HWND FindWindowW(LPCWSTR, LPCWSTR); // HWND FindWindowExW(HWND, HWND, LPCWSTR, LPCWSTR); int GetClassNameW(HWND, LPWSTR, int); // HHOOK SetWindowsHookExW(int, HOOKPROC, HINST, DWORD); // HBITMAP LoadBitmapW(HINST, LPCWSTR); HCURSOR LoadCursorW(HINST, LPCWSTR); // HCURSOR LoadCursorFromFileW(LPCWSTR); HICON LoadIconW(HINST, LPCWSTR); // HANDLE LoadImageW(HINST, LPCWSTR, UINT, int, int, UINT); // int LoadStringW(HINST, UINT, LPWSTR, int); // WINBOOL IsDialogMessageW(HWND, LPMSG); // int DlgDirListW(HWND, LPWSTR, int, int, UINT); // WINBOOL DlgDirSelectExW(HWND, LPWSTR, int, int); // int DlgDirListComboBoxW(HWND, LPWSTR, int, int, UINT); // WINBOOL DlgDirSelectComboBoxExW(HWND, LPWSTR, int, int); // LRESULT DefFrameProcW(HWND, HWND, UINT, WPARAM, LPARAM); // LRESULT DefMDIChildProcW(HWND, UINT, WPARAM, LPARAM); // HWND CreateMDIWindowW(LPWSTR, LPWSTR, DWORD, int, int, int, int, HWND, HINST, LPARAM); // WINBOOL WinHelpW(HWND, LPCWSTR, UINT, DWORD); // LONG ChangeDisplaySettingsW(LPDEVMODE, DWORD); // WINBOOL EnumDisplaySettingsW(LPCWSTR, DWORD, LPDEVMODE); // WINBOOL SystemParametersInfoW(UINT, UINT, PVOID, UINT); // int AddFontResourceW(LPCWSTR); // HMETAFILE CopyMetaFileW(HMETAFILE, LPCWSTR); // HFONT CreateFontIndirectW(PLOGFONT); // HFONT CreateFontW(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCWSTR); // HDC CreateICW(LPCWSTR, LPCWSTR, LPCWSTR, LPDEVMODE); // HDC CreateMetaFileW(LPCWSTR); // WINBOOL CreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR); // int EnumFontFamiliesExW(HDC, LPLOGFONT, FONTENUMEXPROC, LPARAM, DWORD); // int EnumFontFamiliesW(HDC, LPCWSTR, FONTENUMPROC, LPARAM); // int EnumFontsW(HDC, LPCWSTR, ENUMFONTSPROC, LPARAM); // WINBOOL GetCharWidthW(HDC, UINT, UINT, LPINT); // WINBOOL GetCharWidth32W(HDC, UINT, UINT, LPINT); // WINBOOL GetCharWidthFloatW(HDC, UINT, UINT, PFLOAT); // WINBOOL GetCharABCWidthsW(HDC, UINT, UINT, LPABC); // WINBOOL GetCharABCWidthsFloatW(HDC, UINT, UINT, LPABCFLOAT); // DWORD GetGlyphOutlineW(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID, PMAT2); // HMETAFILE GetMetaFileW(LPCWSTR); // UINT GetOutlineTextMetricsW(HDC, UINT, LPOUTLINETEXTMETRIC); // WINBOOL GetTextExtentPointW(HDC, LPCWSTR, int, LPSIZE); // WINBOOL GetTextExtentPoint32W(HDC, LPCWSTR, int, LPSIZE); // WINBOOL GetTextExtentExPointW(HDC, LPCWSTR, int, int, LPINT, LPINT, LPSIZE); // DWORD GetCharacterPlacementW(HDC, LPCWSTR, int, int, LPGCP_RESULTS, DWORD); // HDC ResetDCW(HDC, LPDEVMODE); // WINBOOL RemoveFontResourceW(LPCWSTR); // HENHMETAFILE CopyEnhMetaFileW(HENHMETAFILE, LPCWSTR); // HDC CreateEnhMetaFileW(HDC, LPCWSTR, LPRECT, LPCWSTR); // HENHMETAFILE GetEnhMetaFileW(LPCWSTR); // UINT GetEnhMetaFileDescriptionW(HENHMETAFILE, UINT, LPWSTR); // WINBOOL GetTextMetricsW(HDC, LPTEXTMETRIC); // int StartDocW(HDC, PDOCINFO); int GetObjectW(HGDIOBJ, int, LPVOID); // WINBOOL TextOutW(HDC, int, int, LPCWSTR, int); // WINBOOL ExtTextOutW(HDC, int, int, UINT, LPRECT, LPCWSTR, UINT, LPINT); // WINBOOL PolyTextOutW(HDC, PPOLYTEXT, int); // int GetTextFaceW(HDC, int, LPWSTR); // DWORD GetKerningPairsW(HDC, DWORD, LPKERNINGPAIR); // WINBOOL GetLogColorSpaceW(HCOLORSPACE, LPLOGCOLORSPACE, DWORD); // HCOLORSPACE CreateColorSpaceW(LPLOGCOLORSPACE); // WINBOOL GetICMProfileW(HDC, DWORD, LPWSTR); // WINBOOL SetICMProfileW(HDC, LPWSTR); // WINBOOL UpdateICMRegKeyW(DWORD, DWORD, LPWSTR, UINT); // int EnumICMProfilesW(HDC, ICMENUMPROC, LPARAM); // HPROPSHEETPAGE CreatePropertySheetPageW(LPCPROPSHEETPAGE); // int PropertySheetW(LPCPROPSHEETHEADER); // HIMAGELIST ImageList_LoadImageW(HINST, LPCWSTR, int, int, COLORREF, UINT, UINT); // HWND CreateStatusWindowW(LONG, LPCWSTR, HWND, UINT); // void DrawStatusTextW(HDC, LPRECT, LPCWSTR); // WINBOOL GetOpenFileNameW(LPOPENFILENAME); // WINBOOL GetSaveFileNameW(LPOPENFILENAME); // int GetFileTitleW(LPCWSTR, LPWSTR, ushort); // WINBOOL ChooseColorW(LPCHOOSECOLOR); // HWND ReplaceTextW(LPFINDREPLACE); // WINBOOL ChooseFontW(LPCHOOSEFONT); // HWND FindTextW(LPFINDREPLACE); // WINBOOL PrintDlgW(LPPRINTDLG); // WINBOOL PageSetupDlgW(LPPAGESETUPDLG); WINBOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION); void GetStartupInfoW(LPSTARTUPINFO); // HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW); // WINBOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW); // WINBOOL GetVersionExW(LPOSVERSIONINFO); // HDC CreateDCW(LPCWSTR, LPCWSTR, LPCWSTR, PDEVMODE); // HFONT CreateFontA(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCSTR); // DWORD VerInstallFileW(DWORD, LPWSTR, LPWSTR, LPWSTR, LPWSTR, LPWSTR, LPWSTR, PUINT); // DWORD GetFileVersionInfoSizeW(LPWSTR, LPDWORD); // WINBOOL GetFileVersionInfoW(LPWSTR, DWORD, DWORD, LPVOID); // DWORD VerLanguageNameW(DWORD, LPWSTR, DWORD); // WINBOOL VerQueryValueW(LPVOID, LPWSTR, LPVOID, PUINT); // DWORD VerFindFileW(DWORD, LPWSTR, LPWSTR, LPWSTR, LPWSTR, PUINT, LPWSTR, PUINT); // LONG RegSetValueExW(HKEY, LPCWSTR, DWORD, DWORD, LPBYTE, DWORD); // LONG RegUnLoadKeyW(HKEY, LPCWSTR); // WINBOOL InitiateSystemShutdownW(LPWSTR, LPWSTR, DWORD, WINBOOL, WINBOOL); // WINBOOL AbortSystemShutdownW(LPWSTR); // LONG RegRestoreKeyW(HKEY, LPCWSTR, DWORD); // LONG RegSaveKeyW(HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES); // LONG RegSetValueW(HKEY, LPCWSTR, DWORD, LPCWSTR, DWORD); // LONG RegQueryValueW(HKEY, LPCWSTR, LPWSTR, PLONG); // LONG RegQueryMultipleValuesW(HKEY, PVALENT, DWORD, LPWSTR, LPDWORD); // LONG RegQueryValueExW(HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD); // LONG RegReplaceKeyW(HKEY, LPCWSTR, LPCWSTR, LPCWSTR); // LONG RegConnectRegistryW(LPWSTR, HKEY, PHKEY); // LONG RegCreateKeyW(HKEY, LPCWSTR, PHKEY); // LONG RegCreateKeyExW(HKEY, LPCWSTR, DWORD, LPWSTR, DWORD, REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD); // LONG RegDeleteKeyW(HKEY, LPCWSTR); // LONG RegDeleteValueW(HKEY, LPCWSTR); // LONG RegEnumKeyW(HKEY, DWORD, LPWSTR, DWORD); // LONG RegEnumKeyExW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPWSTR, LPDWORD, PFILETIME); // LONG RegEnumValueW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE, LPDWORD); // LONG RegLoadKeyW(HKEY, LPCWSTR, LPCWSTR); // LONG RegOpenKeyW(HKEY, LPCWSTR, PHKEY); // LONG RegOpenKeyExW(HKEY, LPCWSTR, DWORD, REGSAM, PHKEY); // LONG RegQueryInfoKeyW(HKEY, LPWSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME); // int CompareStringW(LCID, DWORD, LPCWSTR, int, LPCWSTR, int); // int LCMapStringW(LCID, DWORD, LPCWSTR, int, LPWSTR, int); // int GetLocaleInfoW(LCID, LCTYPE, LPWSTR, int); // WINBOOL SetLocaleInfoW(LCID, LCTYPE, LPCWSTR); int GetTimeFormatW(LCID, DWORD, LPSYSTEMTIME, LPCWSTR, LPWSTR, int); int GetDateFormatW(LCID, DWORD, LPSYSTEMTIME, LPCWSTR, LPWSTR, int); // int GetNumberFormatW(LCID, DWORD, LPCWSTR, PNUMBERFMT, LPWSTR, int); // int GetCurrencyFormatW(LCID, DWORD, LPCWSTR, PCURRENCYFMT, LPWSTR, int); // WINBOOL EnumCalendarInfoW(CALINFO_ENUMPROC, LCID, CALID, CALTYPE); // WINBOOL EnumTimeFormatsW(TIMEFMT_ENUMPROC, LCID, DWORD); // WINBOOL EnumDateFormatsW(DATEFMT_ENUMPROC, LCID, DWORD); // WINBOOL GetStringTypeExW(LCID, DWORD, LPCWSTR, int, LPWORD); // WINBOOL GetStringTypeW(DWORD, LPCWSTR, int, LPWORD); // int FoldStringW(DWORD, LPCWSTR, int, LPWSTR, int); // WINBOOL EnumSystemLocalesW(LOCALE_ENUMPROC, DWORD); // WINBOOL EnumSystemCodePagesW(CODEPAGE_ENUMPROC, DWORD); // WINBOOL PeekConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD); // WINBOOL ReadConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD); // WINBOOL WriteConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD); // WINBOOL ReadConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT); // WINBOOL WriteConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT); // WINBOOL ReadConsoleOutputCharacterW(HANDLE, LPWSTR, DWORD, COORD, LPDWORD); // WINBOOL WriteConsoleOutputCharacterW(HANDLE, LPCWSTR, DWORD, COORD, LPDWORD); // WINBOOL FillConsoleOutputCharacterW(HANDLE, WCHAR, DWORD, COORD, LPDWORD); // WINBOOL ScrollConsoleScreenBufferW(HANDLE, PSMALL_RECT, PSMALL_RECT, COORD, PCHAR_INFO); // DWORD GetConsoleTitleW(LPWSTR, DWORD); // WINBOOL SetConsoleTitleW(LPCWSTR); // WINBOOL ReadConsoleW(HANDLE, LPVOID, DWORD, LPDWORD, LPVOID); // WINBOOL WriteConsoleW(HANDLE, POINTER, DWORD, LPDWORD, LPVOID); // DWORD WNetAddConnectionW(LPCWSTR, LPCWSTR, LPCWSTR); // DWORD WNetAddConnection2W(LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD); // DWORD WNetAddConnection3W(HWND, LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD); // DWORD WNetCancelConnectionW(LPCWSTR, WINBOOL); // DWORD WNetCancelConnection2W(LPCWSTR, DWORD, WINBOOL); // DWORD WNetGetConnectionW(LPCWSTR, LPWSTR, LPDWORD); // DWORD WNetUseConnectionW(HWND, LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPDWORD, LPDWORD); // DWORD WNetSetConnectionW(LPCWSTR, DWORD, LPVOID); // DWORD WNetConnectionDialog1W(LPCONNECTDLGSTRUCT); // DWORD WNetDisconnectDialog1W(LPDISCDLGSTRUCT); // DWORD WNetOpenEnumW(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE); // DWORD WNetEnumResourceW(HANDLE, LPDWORD, LPVOID, LPDWORD); // DWORD WNetGetUniversalNameW(LPCWSTR, DWORD, LPVOID, LPDWORD); // DWORD WNetGetUserW(LPCWSTR, LPWSTR, LPDWORD); // DWORD WNetGetProviderNameW(DWORD, LPWSTR, LPDWORD); // DWORD WNetGetNetworkInformationW(LPCWSTR, LPNETINFOSTRUCT); // DWORD WNetGetLastErrorW(LPDWORD, LPWSTR, DWORD, LPWSTR, DWORD); // DWORD MultinetGetConnectionPerformanceW(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT); // WINBOOL ChangeServiceConfigW(SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR); // SC_HANDLE CreateServiceW(SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR); // WINBOOL EnumDependentServicesW(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD); // WINBOOL EnumServicesStatusW(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL GetServiceKeyNameW(SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD); // WINBOOL GetServiceDisplayNameW(SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD); // SC_HANDLE OpenSCManagerW(LPCWSTR, LPCWSTR, DWORD); // SC_HANDLE OpenServiceW(SC_HANDLE, LPCWSTR, DWORD); // WINBOOL QueryServiceConfigW(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD); // WINBOOL QueryServiceLockStatusW(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD, LPDWORD); // SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR, LPHANDLER_FUNCTION); // WINBOOL StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRY); // WINBOOL StartServiceW(SC_HANDLE, DWORD, LPCWSTR); // uint DragQueryFileW(HDROP, uint, LPCWSTR, uint); // HICON ExtractAssociatedIconW(HINST, LPCWSTR, LPWORD); // HICON ExtractIconW(HINST, LPCWSTR, uint); // HINST FindExecutableW(LPCWSTR, LPCWSTR, LPCWSTR); // int ShellAboutW(HWND, LPCWSTR, LPCWSTR, HICON); // HINST ShellExecuteW(HWND, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, int); // HSZ DdeCreateStringHandleW(DWORD, LPCWSTR, int); // UINT DdeInitializeW(LPDWORD, PFNCALLBACK, DWORD, DWORD); // DWORD DdeQueryStringW(DWORD, HSZ, LPCWSTR, DWORD, int); // WINBOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE); // WINBOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION); // WINBOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, LPDWORD, LPDWORD, LPBOOL); // LONG InterlockedIncrement(LPLONG); // LONG InterlockedDecrement(LPLONG); // LONG InterlockedExchange(LPLONG, LONG); // WINBOOL FreeResource(HGLOBAL); // LPVOID LockResource(HGLOBAL); WINBOOL FreeLibrary(HINST); // void FreeLibraryAndExitThread(HMODULE, DWORD); // WINBOOL DisableThreadLibraryCalls(HMODULE); FARPROC GetProcAddress(HINST, LPCSTR); // DWORD GetVersion(); // HGLOBAL GlobalAlloc(UINT, DWORD); // HGLOBAL GlobalReAlloc(HGLOBAL, DWORD, UINT); // DWORD GlobalSize(HGLOBAL); // UINT GlobalFlags(HGLOBAL); // LPVOID GlobalLock(HGLOBAL); // HGLOBAL GlobalHandle(LPCVOID); // WINBOOL GlobalUnlock(HGLOBAL); // HGLOBAL GlobalFree(HGLOBAL); // UINT GlobalCompact(DWORD); // void GlobalFix(HGLOBAL); // void GlobalUnfix(HGLOBAL); // LPVOID GlobalWire(HGLOBAL); // WINBOOL GlobalUnWire(HGLOBAL); // void GlobalMemoryStatus(LPMEMORYSTATUS); // HLOCAL LocalAlloc(UINT, UINT); // HLOCAL LocalReAlloc(HLOCAL, UINT, UINT); // LPVOID LocalLock(HLOCAL); // HLOCAL LocalHandle(LPCVOID); // WINBOOL LocalUnlock(HLOCAL); // UINT LocalSize(HLOCAL); // UINT LocalFlags(HLOCAL); // HLOCAL LocalFree(HLOCAL); // UINT LocalShrink(HLOCAL, UINT); // UINT LocalCompact(UINT); // WINBOOL FlushInstructionCache(HANDLE, LPCVOID, DWORD); // LPVOID VirtualAlloc(LPVOID, DWORD, DWORD, DWORD); // WINBOOL VirtualFree(LPVOID, DWORD, DWORD); // WINBOOL VirtualProtect(LPVOID, DWORD, DWORD, PDWORD); // DWORD VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD); // WINBOOL VirtualProtectEx(HANDLE, LPVOID, DWORD, DWORD, PDWORD); // DWORD VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD); // HANDLE HeapCreate(DWORD, DWORD, DWORD); // WINBOOL HeapDestroy(HANDLE); // LPVOID HeapAlloc(HANDLE, DWORD, DWORD); // LPVOID HeapReAlloc(HANDLE, DWORD, LPVOID, DWORD); // WINBOOL HeapFree(HANDLE, DWORD, LPVOID); // DWORD HeapSize(HANDLE, DWORD, LPCVOID); // WINBOOL HeapValidate(HANDLE, DWORD, LPCVOID); // UINT HeapCompact(HANDLE, DWORD); // HANDLE GetProcessHeap(); // DWORD GetProcessHeaps(DWORD, PHANDLE); // WINBOOL HeapLock(HANDLE); // WINBOOL HeapUnlock(HANDLE); // WINBOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY); // WINBOOL GetProcessAffinityMask(HANDLE, LPDWORD, LPDWORD); // WINBOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); // WINBOOL GetProcessWorkingSetSize(HANDLE, LPDWORD, LPDWORD); // WINBOOL SetProcessWorkingSetSize(HANDLE, DWORD, DWORD); // HANDLE OpenProcess(DWORD, WINBOOL, DWORD); // HANDLE GetCurrentProcess(); // DWORD GetCurrentProcessId(); // void ExitProcess(UINT); // WINBOOL TerminateProcess(HANDLE, UINT); // WINBOOL GetExitCodeProcess(HANDLE, LPDWORD); // void FatalExit(int); // void RaiseException(DWORD, DWORD, DWORD); // LONG UnhandledExceptionFilter(EMPTYRECORD*); // HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD); // HANDLE GetCurrentThread(); // DWORD GetCurrentThreadId(); // DWORD SetThreadAffinityMask(HANDLE, DWORD); // WINBOOL SetThreadPriority(HANDLE, int); // int GetThreadPriority(HANDLE); // WINBOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME); // void ExitThread(DWORD); // WINBOOL TerminateThread(HANDLE, DWORD); // WINBOOL GetExitCodeThread(HANDLE, LPDWORD); // WINBOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY); // DWORD GetLastError(); // void SetLastError(DWORD); // HANDLE CreateIoCompletionPort(HANDLE, HANDLE, DWORD, DWORD); // UINT SetErrorMode(UINT); // WINBOOL ReadProcessMemory(HANDLE, LPCVOID, LPVOID, DWORD, LPDWORD); // WINBOOL WriteProcessMemory(HANDLE, LPVOID, LPVOID, DWORD, LPDWORD); // WINBOOL GetThreadContext(HANDLE, LPCONTEXT); // DWORD SuspendThread(HANDLE); // DWORD ResumeThread(HANDLE); // void DebugBreak(); // WINBOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD); // WINBOOL ContinueDebugEvent(DWORD, DWORD, DWORD); // WINBOOL DebugActiveProcess(DWORD); // void InitializeCriticalSection(LPCRITICAL_SECTION); // void EnterCriticalSection(LPCRITICAL_SECTION); // WINBOOL TryEnterCriticalSection(LPCRITICAL_SECTION); // void LeaveCriticalSection(LPCRITICAL_SECTION); // void DeleteCriticalSection(LPCRITICAL_SECTION); // WINBOOL SetEvent(HANDLE); // WINBOOL ResetEvent(HANDLE); // WINBOOL PulseEvent(HANDLE); // WINBOOL ReleaseSemaphore(HANDLE, LONG, LPLONG); // WINBOOL ReleaseMutex(HANDLE); DWORD WaitForSingleObject(HANDLE, DWORD); DWORD WaitForMultipleObjects(DWORD, HANDLE*, WINBOOL, DWORD); // void Sleep(DWORD); // HGLOBAL LoadResource(HINST, HRSRC); // DWORD SizeofResource(HINST, HRSRC); // ATOM GlobalDeleteAtom(ATOM); // WINBOOL InitAtomTable(DWORD); // ATOM DeleteAtom(ATOM); // UINT SetHandleCount(UINT); // DWORD GetLogicalDrives(); // WINBOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD); // WINBOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD); // WINBOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED); // WINBOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED); // WINBOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION); // DWORD GetFileType(HANDLE); // DWORD GetFileSize(HANDLE, LPDWORD); // HANDLE GetStdHandle(DWORD); // WINBOOL SetStdHandle(DWORD, HANDLE); // WINBOOL FlushFileBuffers(HANDLE); // WINBOOL DeviceIoControl(HANDLE, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED); // WINBOOL SetEndOfFile(HANDLE); // DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD); // WINBOOL FindClose(HANDLE); // WINBOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME); // WINBOOL SetFileTime(HANDLE, FILETIME*, FILETIME*, FILETIME*); WINBOOL CloseHandle(HANDLE); // WINBOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, LPHANDLE, DWORD, WINBOOL, DWORD); // WINBOOL GetHandleInformation(HANDLE, LPDWORD); // WINBOOL SetHandleInformation(HANDLE, DWORD, DWORD); // DWORD LoadModule(LPCSTR, LPVOID); // UINT WinExec(LPCSTR, UINT); // WINBOOL ClearCommBreak(HANDLE); // WINBOOL ClearCommError(HANDLE, LPDWORD, LPCOMSTAT); // WINBOOL SetupComm(HANDLE, DWORD, DWORD); // WINBOOL EscapeCommFunction(HANDLE, DWORD); // WINBOOL GetCommConfig(HANDLE, LPCOMMCONFIG, LPDWORD); // WINBOOL GetCommProperties(HANDLE, LPCOMMPROP); // WINBOOL GetCommModemStatus(HANDLE, PDWORD); // WINBOOL GetCommState(HANDLE, PDCB); // WINBOOL GetCommTimeouts(HANDLE, PCOMMTIMEOUTS); // WINBOOL PurgeComm(HANDLE, DWORD); // WINBOOL SetCommBreak(HANDLE); // WINBOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD); // WINBOOL SetCommMask(HANDLE, DWORD); // WINBOOL SetCommState(HANDLE, TDCB*); // WINBOOL SetCommTimeouts(HANDLE, TCOMMTIMEOUTS*); // WINBOOL TransmitCommChar(HANDLE, char); // WINBOOL WaitCommEvent(HANDLE, LPDWORD, LPOVERLAPPED); // DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, WINBOOL); // DWORD GetTapePosition(HANDLE, DWORD, LPDWORD, LPDWORD, LPDWORD); // DWORD PrepareTape(HANDLE, DWORD, WINBOOL); // DWORD EraseTape(HANDLE, DWORD, WINBOOL); // DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD); // DWORD WriteTapemark(HANDLE, DWORD, DWORD, WINBOOL); // DWORD GetTapeStatus(HANDLE); // DWORD GetTapeParameters(HANDLE, DWORD, LPDWORD, LPVOID); // DWORD SetTapeParameters(HANDLE, DWORD, LPVOID); // WINBOOL Beep(DWORD, DWORD); // int MulDiv(int, int, int); // void GetSystemTime(LPSYSTEMTIME); // void GetSystemTimeAsFileTime(FILETIME*); // WINBOOL SetSystemTime(SYSTEMTIME*); // void GetLocalTime(LPSYSTEMTIME); // WINBOOL SetLocalTime(SYSTEMTIME*); // void GetSystemInfo(LPSYSTEM_INFO); // WINBOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME); // DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION); // WINBOOL SetTimeZoneInformation(TIME_ZONE_INFORMATION*); // WINBOOL SystemTimeToFileTime(SYSTEMTIME*, LPFILETIME); // WINBOOL FileTimeToLocalFileTime(FILETIME*, LPFILETIME); // WINBOOL LocalFileTimeToFileTime(FILETIME*, LPFILETIME); // WINBOOL FileTimeToSystemTime(FILETIME*, LPSYSTEMTIME); // LONG CompareFileTime(FILETIME*, FILETIME*); // WINBOOL FileTimeToDosDateTime(FILETIME*, LPWORD, LPWORD); // WINBOOL DosDateTimeToFileTime(ushort, ushort, LPFILETIME); // DWORD GetTickCount(); // WINBOOL SetSystemTimeAdjustment(DWORD, WINBOOL); // WINBOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PWINBOOL); // WINBOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD); // WINBOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED); // WINBOOL DisconnectNamedPipe(HANDLE); // WINBOOL SetNamedPipeHandleState(HANDLE, LPDWORD, LPDWORD, LPDWORD); // WINBOOL GetNamedPipeInfo(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL PeekNamedPipe(HANDLE, LPVOID, DWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL TransactNamedPipe(HANDLE, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED); // WINBOOL GetMailslotInfo(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD); // WINBOOL SetMailslotInfo(HANDLE, DWORD); // LPVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD); // WINBOOL FlushViewOfFile(LPCVOID, DWORD); // WINBOOL UnmapViewOfFile(LPVOID); // HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT); // HFILE _lopen(LPCSTR, int); // HFILE _lcreat(LPCSTR, int); // UINT _lread(HFILE, LPVOID, UINT); // UINT _lwrite(HFILE, LPCSTR, UINT); // int _hread(HFILE, LPVOID, int); // int _hwrite(HFILE, LPCSTR, int); // HFILE _lclose(HFILE); // LONG _llseek(HFILE, LONG, int); // WINBOOL IsTextUnicode(LPVOID, int, LPINT); // DWORD TlsAlloc(); // LPVOID TlsGetValue(DWORD); // WINBOOL TlsSetValue(DWORD, LPVOID); // WINBOOL TlsFree(DWORD); // DWORD SleepEx(DWORD, WINBOOL); // DWORD WaitForSingleObjectEx(HANDLE, DWORD, WINBOOL); // DWORD WaitForMultipleObjectsEx(DWORD, HANDLE*, WINBOOL, DWORD, WINBOOL); // WINBOOL ReadFileEx(HANDLE, LPVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); // WINBOOL WriteFileEx(HANDLE, LPCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE); // WINBOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, WINBOOL, WINBOOL, LPVOID*); // WINBOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*); // WINBOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, WINBOOL, WINBOOL, LPVOID*); // WINBOOL SetProcessShutdownParameters(DWORD, DWORD); // WINBOOL GetProcessShutdownParameters(LPDWORD, LPDWORD); // void SetFileApisToOEM(); // void SetFileApisToANSI(); // WINBOOL AreFileApisANSI(); // WINBOOL CloseEventLog(HANDLE); // WINBOOL DeregisterEventSource(HANDLE); // WINBOOL NotifyChangeEventLog(HANDLE, HANDLE); // WINBOOL GetNumberOfEventLogRecords(HANDLE, PDWORD); // WINBOOL GetOldestEventLogRecord(HANDLE, PDWORD); // WINBOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE); // WINBOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD); // WINBOOL ImpersonateNamedPipeClient(HANDLE); // WINBOOL ImpersonateLoggedOnUser(HANDLE); // WINBOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL); // WINBOOL RevertToSelf(); // WINBOOL SetThreadToken(PHANDLE, HANDLE); // WINBOOL OpenProcessToken(HANDLE, DWORD, PHANDLE); // WINBOOL OpenThreadToken(HANDLE, DWORD, WINBOOL, PHANDLE); // WINBOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD, PDWORD); // WINBOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD); // WINBOOL AdjustTokenPrivileges(HANDLE, WINBOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); // WINBOOL AdjustTokenGroups(HANDLE, WINBOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD); // WINBOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, LPBOOL); // WINBOOL IsValidSid(PSID); // WINBOOL EqualSid(PSID, PSID); // WINBOOL EqualPrefixSid(PSID, PSID); // DWORD GetSidLengthRequired(UCHAR); // WINBOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, ubyte, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*); // PVOID FreeSid(PSID); // WINBOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, ubyte); // PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID); // PDWORD GetSidSubAuthority(PSID, DWORD); // PUCHAR GetSidSubAuthorityCount(PSID); // DWORD GetLengthSid(PSID); // WINBOOL CopySid(DWORD, PSID, PSID); // WINBOOL AreAllAccessesGranted(DWORD, DWORD); // WINBOOL AreAnyAccessesGranted(DWORD, DWORD); // void MapGenericMask(PDWORD); // WINBOOL IsValidAcl(PACL); // WINBOOL InitializeAcl(PACL, DWORD, DWORD); // WINBOOL GetAclInformation(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS); // WINBOOL SetAclInformation(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS); // WINBOOL AddAce(PACL, DWORD, DWORD, LPVOID, DWORD); // WINBOOL DeleteAce(PACL, DWORD); // WINBOOL GetAce(PACL, DWORD, LPVOID*); // WINBOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID); // WINBOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID); // WINBOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, WINBOOL, WINBOOL); // WINBOOL FindFirstFreeAce(PACL, LPVOID*); // WINBOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD); // WINBOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR); // DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR); // WINBOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, LPDWORD); // WINBOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, WINBOOL, PACL, WINBOOL); // WINBOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); // WINBOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, WINBOOL, PACL, WINBOOL); // WINBOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL); // WINBOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, WINBOOL); // WINBOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); // WINBOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, WINBOOL); // WINBOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL); // WINBOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, WINBOOL, HANDLE, PGENERIC_MAPPING); // WINBOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE); // WINBOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD); // WINBOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR); // WINBOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD); // WINBOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD, PACL, LPDWORD, PACL, LPDWORD, PSID, LPDWORD, PSID, LPDWORD); // WINBOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); // WINBOOL FindNextChangeNotification(HANDLE); // WINBOOL FindCloseChangeNotification(HANDLE); // WINBOOL VirtualLock(LPVOID, DWORD); // WINBOOL VirtualUnlock(LPVOID, DWORD); // LPVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPVOID); // WINBOOL SetPriorityClass(HANDLE, DWORD); // DWORD GetPriorityClass(HANDLE); // WINBOOL IsBadReadPtr(POINTER, UINT); // WINBOOL IsBadWritePtr(LPVOID, UINT); // WINBOOL IsBadHugeReadPtr(POINTER, UINT); // WINBOOL IsBadHugeWritePtr(LPVOID, UINT); // WINBOOL IsBadCodePtr(FARPROC); // WINBOOL AllocateLocallyUniqueId(PLUID); // WINBOOL QueryPerformanceCounter(PLARGE_INTEGER); // WINBOOL QueryPerformanceFrequency(PLARGE_INTEGER); // WINBOOL ActivateKeyboardLayout(HKL, UINT); // WINBOOL UnloadKeyboardLayout(HKL); // int GetKeyboardLayoutList(int, HKL*); // HKL GetKeyboardLayout(DWORD); // HDESK OpenInputDesktop(DWORD, WINBOOL, DWORD); // WINBOOL EnumDesktopWindows(HDESK, ENUMWINDOWSPROC, LPARAM); // WINBOOL SwitchDesktop(HDESK); // WINBOOL SetThreadDesktop(HDESK); // WINBOOL CloseDesktop(HDESK); // HDESK GetThreadDesktop(DWORD); // WINBOOL CloseWindowStation(HWINSTA); // WINBOOL SetProcessWindowStation(HWINSTA); // HWINSTA GetProcessWindowStation(); // WINBOOL SetUserObjectSecurity(HANDLE, PSECURITY_INFORMATION, PSECURITY_DESCRIPTOR); // WINBOOL GetUserObjectSecurity(HANDLE, PSECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD); // WINBOOL TranslateMessage(LPMSG); // WINBOOL SetMessageQueue(int); // WINBOOL RegisterHotKey(HWND, int, UINT, UINT); // WINBOOL UnregisterHotKey(HWND, int); // WINBOOL ExitWindowsEx(UINT, DWORD); // WINBOOL SwapMouseButton(WINBOOL); // DWORD GetMessagePos(); // LONG GetMessageTime(); // LONG GetMessageExtraInfo(); // LPARAM SetMessageExtraInfo(LPARAM); // int BroadcastSystemMessage(DWORD, LPDWORD, UINT, WPARAM, LPARAM); // WINBOOL AttachThreadInput(DWORD, DWORD, WINBOOL); // WINBOOL ReplyMessage(LRESULT); // WINBOOL WaitMessage(); // DWORD WaitForInputIdle(HANDLE, DWORD); // void PostQuitMessage(int); // WINBOOL InSendMessage(); // UINT GetDoubleClickTime(); // WINBOOL SetDoubleClickTime(UINT); // WINBOOL IsWindow(HWND); // WINBOOL IsMenu(HMENU); // WINBOOL IsChild(HWND, HWND); // WINBOOL DestroyWindow(HWND); WINBOOL ShowWindow(HWND, int); // WINBOOL ShowWindowAsync(HWND, int); // WINBOOL FlashWindow(HWND, WINBOOL); // WINBOOL ShowOwnedPopups(HWND, WINBOOL); // WINBOOL OpenIcon(HWND); // WINBOOL CloseWindow(HWND); // WINBOOL MoveWindow(HWND, int, int, int, int, WINBOOL); // WINBOOL SetWindowPos(HWND, HWND, int, int, int, int, UINT); // WINBOOL GetWindowPlacement(HWND, WINDOWPLACEMENT*); // WINBOOL SetWindowPlacement(HWND, WINDOWPLACEMENT*); // HDWP BeginDeferWindowPos(int); // HDWP DeferWindowPos(HDWP, HWND, HWND, int, int, int, int, UINT); // WINBOOL EndDeferWindowPos(HDWP); // WINBOOL IsWindowVisible(HWND); // WINBOOL IsIconic(HWND); // WINBOOL AnyPopup(); // WINBOOL BringWindowToTop(HWND); // WINBOOL IsZoomed(HWND); // WINBOOL EndDialog(HWND, int); HWND GetDlgItem(HWND, int); // WINBOOL SetDlgItemInt(HWND, int, UINT, WINBOOL); // UINT GetDlgItemInt(HWND, int, WINBOOL*, WINBOOL); // WINBOOL CheckDlgButton(HWND, int, UINT); // WINBOOL CheckRadioButton(HWND, int, int, int); // UINT IsDlgButtonChecked(HWND, int); // HWND GetNextDlgGroupItem(HWND, HWND, WINBOOL); // HWND GetNextDlgTabItem(HWND, HWND, WINBOOL); // int GetDlgCtrlID(HWND); // int GetDialogBaseUnits(); // WINBOOL OpenClipboard(HWND); // WINBOOL CloseClipboard(); // HWND GetClipboardOwner(); // HWND SetClipboardViewer(HWND); // HWND GetClipboardViewer(); // WINBOOL ChangeClipboardChain(HWND, HWND); // HANDLE SetClipboardData(UINT, HANDLE); // HANDLE GetClipboardData(UINT); // int CountClipboardFormats(); // UINT EnumClipboardFormats(UINT); // WINBOOL EmptyClipboard(); // WINBOOL IsClipboardFormatAvailable(UINT); // int GetPriorityClipboardFormat(UINT*, int); // HWND GetOpenClipboardWindow(); // LPSTR CharNextExA(ushort, LPCSTR, DWORD); // LPSTR CharPrevExA(ushort, LPCSTR, LPCSTR, DWORD); HWND SetFocus(HWND); // HWND GetActiveWindow(); HWND GetFocus(); // UINT GetKBCodePage(); // SHORT GetKeyState(int); SHORT GetAsyncKeyState(int); // WINBOOL GetKeyboardState(PBYTE); // WINBOOL SetKeyboardState(LPBYTE); // int GetKeyboardType(int); // int ToAscii(UINT, UINT, PBYTE, LPWORD, UINT); // int ToAsciiEx(UINT, UINT, PBYTE, LPWORD, UINT, HKL); // int ToUnicode(UINT, UINT, PBYTE, LPWSTR, int, UINT); // DWORD OemKeyScan(ushort); // void keybd_event(ubyte, ubyte, DWORD); // void mouse_event(DWORD, DWORD, DWORD, DWORD); // WINBOOL GetInputState(); // DWORD GetQueueStatus(UINT); // HWND GetCapture(); // HWND SetCapture(HWND); // WINBOOL ReleaseCapture(); // DWORD MsgWaitForMultipleObjects(DWORD, LPHANDLE, WINBOOL, DWORD, DWORD); // UINT SetTimer(HWND, UINT, UINT, TIMERPROC); // WINBOOL KillTimer(HWND, UINT); // WINBOOL IsWindowUnicode(HWND); // WINBOOL EnableWindow(HWND, WINBOOL); // WINBOOL IsWindowEnabled(HWND); // WINBOOL DestroyAcceleratorTable(HACCEL); // int GetSystemMetrics(int); // HMENU GetMenu(HWND); // WINBOOL SetMenu(HWND, HMENU); // WINBOOL HiliteMenuItem(HWND, HMENU, UINT, UINT); // UINT GetMenuState(HMENU, UINT, UINT); // WINBOOL DrawMenuBar(HWND); // HMENU GetSystemMenu(HWND, WINBOOL); // HMENU CreateMenu(); // HMENU CreatePopupMenu(); // WINBOOL DestroyMenu(HMENU); // DWORD CheckMenuItem(HMENU, UINT, UINT); // WINBOOL EnableMenuItem(HMENU, UINT, UINT); // HMENU GetSubMenu(HMENU, int); // UINT GetMenuItemID(HMENU, int); // int GetMenuItemCount(HMENU); // WINBOOL RemoveMenu(HMENU, UINT, UINT); // WINBOOL DeleteMenu(HMENU, UINT, UINT); // WINBOOL SetMenuItemBitmaps(HMENU, UINT, UINT, HBITMAP, HBITMAP); // LONG GetMenuCheckMarkDimensions(); WINBOOL TrackPopupMenu(HMENU, UINT, int, int, int, HWND, RECT*); // UINT GetMenuDefaultItem(HMENU, UINT, UINT); // WINBOOL SetMenuDefaultItem(HMENU, UINT, UINT); // WINBOOL GetMenuItemRect(HWND, HMENU, UINT, LPRECT); // int MenuItemFromPoint(HWND, HMENU, POINT); // DWORD DragObject(HWND, HWND, UINT, DWORD, HCURSOR); // WINBOOL DragDetect(HWND, POINT); // WINBOOL DrawIcon(HDC, int, int, HICON); WINBOOL UpdateWindow(HWND); HWND SetActiveWindow(HWND); // HWND GetForegroundWindow(); // WINBOOL PaintDesktop(HDC); WINBOOL SetForegroundWindow(HWND); HWND WindowFromDC(HDC); HDC GetDC(HWND); HDC GetDCEx(HWND, HRGN, DWORD); HDC GetWindowDC(HWND); int ReleaseDC(HWND, HDC); HDC BeginPaint(HWND, LPPAINTSTRUCT); WINBOOL EndPaint(HWND, LPPAINTSTRUCT); WINBOOL GetUpdateRect(HWND, LPRECT, WINBOOL); int GetUpdateRgn(HWND, HRGN, WINBOOL); int SetWindowRgn(HWND, HRGN, WINBOOL); int GetWindowRgn(HWND, HRGN); // int ExcludeUpdateRgn(HDC, HWND); WINBOOL InvalidateRect(HWND, RECT*, WINBOOL); WINBOOL ValidateRect(HWND, RECT*); WINBOOL InvalidateRgn(HWND, HRGN, WINBOOL); // WINBOOL ValidateRgn(HWND, HRGN); WINBOOL RedrawWindow(HWND, RECT*, HRGN, UINT); // WINBOOL LockWindowUpdate(HWND); // WINBOOL ScrollWindow(HWND, int, int, RECT*, RECT*); // WINBOOL ScrollDC(HDC, int, int, RECT*, RECT*, HRGN, LPRECT); int ScrollWindowEx(HWND, int, int, RECT*, RECT*, HRGN, LPRECT, UINT); // int SetScrollPos(HWND, int, int, WINBOOL); // int GetScrollPos(HWND, int); // WINBOOL SetScrollRange(HWND, int, int, int, WINBOOL); // WINBOOL GetScrollRange(HWND, int, LPINT, LPINT); WINBOOL ShowScrollBar(HWND, int, WINBOOL); WINBOOL EnableScrollBar(HWND, UINT, UINT); WINBOOL GetClientRect(HWND, LPRECT); WINBOOL GetWindowRect(HWND, LPRECT); // WINBOOL AdjustWindowRect(LPRECT, DWORD, WINBOOL); // WINBOOL AdjustWindowRectEx(LPRECT, DWORD, WINBOOL, DWORD); // WINBOOL SetWindowContextHelpId(HWND, DWORD); // DWORD GetWindowContextHelpId(HWND); // WINBOOL SetMenuContextHelpId(HMENU, DWORD); // DWORD GetMenuContextHelpId(HMENU); // WINBOOL MessageBeep(UINT); // int ShowCursor(WINBOOL); WINBOOL SetCursorPos(int, int); HCURSOR SetCursor(HCURSOR); // WINBOOL GetCursorPos(LPPOINT); // WINBOOL ClipCursor(RECT*); // WINBOOL GetClipCursor(LPRECT); // HCURSOR GetCursor(); WINBOOL CreateCaret(HWND, HBITMAP, int, int); // UINT GetCaretBlinkTime(); // WINBOOL SetCaretBlinkTime(UINT); // WINBOOL DestroyCaret(); WINBOOL HideCaret(HWND); WINBOOL ShowCaret(HWND); // WINBOOL SetCaretPos(int, int); // WINBOOL GetCaretPos(LPPOINT); WINBOOL ClientToScreen(HWND, LPPOINT); WINBOOL ScreenToClient(HWND, LPPOINT); int MapWindowPoints(HWND, HWND, LPPOINT, UINT); HWND WindowFromPoint(POINT); // HWND ChildWindowFromPoint(HWND, POINT); // DWORD GetSysColor(int); // HBRUSH GetSysColorBrush(int); // WINBOOL SetSysColors(int, WINT*, COLORREF*); // WINBOOL DrawFocusRect(HDC, RECT*); int FillRect(HDC, RECT*, HBRUSH); // int FrameRect(HDC, RECT*, HBRUSH); // WINBOOL InvertRect(HDC, RECT*); // WINBOOL SetRect(LPRECT, int, int, int, int); // WINBOOL SetRectEmpty(LPRECT); // WINBOOL CopyRect(LPRECT, RECT*); // WINBOOL InflateRect(LPRECT, int, int); // WINBOOL IntersectRect(LPRECT, RECT*, RECT*); // WINBOOL UnionRect(LPRECT, RECT*, RECT*); // WINBOOL SubtractRect(LPRECT, RECT*, RECT*); WINBOOL OffsetRect(LPRECT, int, int); // WINBOOL IsRectEmpty(RECT*); // WINBOOL EqualRect(RECT*, RECT*); // WINBOOL PtInRect(RECT*, POINT); // ushort GetWindowWord(HWND, int); // ushort SetWindowWord(HWND, int, ushort); // ushort GetClassWord(HWND, int); // ushort SetClassWord(HWND, int, ushort); // HWND GetDesktopWindow(); // HWND GetParent(HWND); // HWND SetParent(HWND, HWND); // WINBOOL EnumChildWindows(HWND, ENUMWINDOWSPROC, LPARAM); // WINBOOL EnumWindows(ENUMWINDOWSPROC, LPARAM); // WINBOOL EnumThreadWindows(DWORD, ENUMWINDOWSPROC, LPARAM); // HWND GetTopWindow(HWND); // DWORD GetWindowThreadProcessId(HWND, LPDWORD); // HWND GetLastActivePopup(HWND); // HWND GetWindow(HWND, UINT); // WINBOOL UnhookWindowsHook(int, HOOKPROC); // WINBOOL UnhookWindowsHookEx(HHOOK); // LRESULT CallNextHookEx(HHOOK, int, WPARAM, LPARAM); // WINBOOL CheckMenuRadioItem(HMENU, UINT, UINT, UINT, UINT); // HCURSOR CreateCursor(HINST, int, int, int, int, POINTER, POINTER); // WINBOOL DestroyCursor(HCURSOR); // WINBOOL SetSystemCursor(HCURSOR, DWORD); // HICON CreateIcon(HINST, int, int, ubyte, ubyte, ubyte*, ubyte*); // WINBOOL DestroyIcon(HICON); // int LookupIconIdFromDirectory(PBYTE, WINBOOL); // int LookupIconIdFromDirectoryEx(PBYTE, WINBOOL, int, int, UINT); // HICON CreateIconFromResource(PBYTE, DWORD, WINBOOL, DWORD); // HICON CreateIconFromResourceEx(PBYTE, DWORD, WINBOOL, DWORD, int, int, UINT); // HICON CopyImage(HANDLE, UINT, int, int, UINT); // HICON CreateIconIndirect(PICONINFO); // HICON CopyIcon(HICON); // WINBOOL GetIconInfo(HICON, PICONINFO); // WINBOOL MapDialogRect(HWND, LPRECT); // int SetScrollInfo(HWND, int, LPCSCROLLINFO, WINBOOL); // WINBOOL GetScrollInfo(HWND, int, LPSCROLLINFO); // WINBOOL TranslateMDISysAccel(HWND, LPMSG); // UINT ArrangeIconicWindows(HWND); // ushort TileWindows(HWND, UINT, RECT*, UINT, HWND*); // ushort CascadeWindows(HWND, UINT, RECT*, UINT, HWND*); // void SetLastErrorEx(DWORD); // void SetDebugErrorLevel(DWORD); // WINBOOL DrawEdge(HDC, LPRECT, UINT, UINT); // WINBOOL DrawFrameControl(HDC, LPRECT, UINT, UINT); // WINBOOL DrawCaption(HWND, HDC, RECT*, UINT); // WINBOOL DrawAnimatedRects(HWND, int, RECT*, RECT*); // WINBOOL TrackPopupMenuEx(HMENU, UINT, int, int, HWND, LPTPMPARAMS); // HWND ChildWindowFromPointEx(HWND, POINT, UINT); // WINBOOL DrawIconEx(HDC, int, int, HICON, int, int, UINT, HBRUSH, UINT); // WINBOOL AnimatePalette(HPALETTE, UINT, UINT, PALETTEENTRY*); // WINBOOL Arc(HDC, int, int, int, int, int, int, int, int); // WINBOOL BitBlt(HDC, int, int, int, int, HDC, int, int, DWORD); // WINBOOL CancelDC(HDC); // WINBOOL Chord(HDC, int, int, int, int, int, int, int, int); // HMETAFILE CloseMetaFile(HDC); // int CombineRgn(HRGN, HRGN, HRGN, int); // HBITMAP CreateBitmap(int, int, UINT, UINT, POINTER); // HBITMAP CreateBitmapIndirect(BITMAP*); // HBRUSH CreateBrushIndirect(LOGBRUSH*); // HBITMAP CreateCompatibleBitmap(HDC, int, int); // HBITMAP CreateDiscardableBitmap(HDC, int, int); HDC CreateCompatibleDC(HDC); // HBITMAP CreateDIBitmap(HDC, BITMAPINFOHEADER*, DWORD, POINTER, BITMAPINFO*, UINT); // HBRUSH CreateDIBPatternBrush(HGLOBAL, UINT); // HBRUSH CreateDIBPatternBrushPt(POINTER, UINT); // HRGN CreateEllipticRgn(int, int, int, int); // HRGN CreateEllipticRgnIndirect(RECT*); // HBRUSH CreateHatchBrush(int, COLORREF); // HPALETTE CreatePalette(LOGPALETTE*); HPEN CreatePen(int, int, COLORREF); // HPEN CreatePenIndirect(LOGPEN*); // HRGN CreatePolyPolygonRgn(POINT*, WINT*, int, int); // HBRUSH CreatePatternBrush(HBITMAP); HRGN CreateRectRgn(int, int, int, int); // HRGN CreateRectRgnIndirect(RECT*); // HRGN CreateRoundRectRgn(int, int, int, int, int, int); // HBRUSH CreateSolidBrush(COLORREF); WINBOOL DeleteDC(HDC); // WINBOOL DeleteMetaFile(HMETAFILE); WINBOOL DeleteObject(HGDIOBJ); // int DrawEscape(HDC, int, int, LPCSTR); // WINBOOL Ellipse(HDC, int, int, int, int); // int EnumObjects(HDC, int, ENUMOBJECTSPROC, LPARAM); // WINBOOL EqualRgn(HRGN, HRGN); // int Escape(HDC, int, int, LPCSTR, LPVOID); // int ExtEscape(HDC, int, int, LPCSTR, int, LPSTR); int ExcludeClipRect(HDC, int, int, int, int); HRGN ExtCreateRegion(XFORM*, DWORD, RGNDATA*); // WINBOOL ExtFloodFill(HDC, int, int, COLORREF, UINT); // WINBOOL FillRgn(HDC, HRGN, HBRUSH); // WINBOOL FloodFill(HDC, int, int, COLORREF); // WINBOOL FrameRgn(HDC, HRGN, HBRUSH, int, int); // int GetROP2(HDC); // WINBOOL GetAspectRatioFilterEx(HDC, LPSIZE); // COLORREF GetBkColor(HDC); // int GetBkMode(HDC); // LONG GetBitmapBits(HBITMAP, LONG, LPVOID); // WINBOOL GetBitmapDimensionEx(HBITMAP, LPSIZE); // UINT GetBoundsRect(HDC, LPRECT, UINT); // WINBOOL GetBrushOrgEx(HDC, LPPOINT); int GetClipBox(HDC, LPRECT); int GetClipRgn(HDC, HRGN); int GetMetaRgn(HDC, HRGN); HGDIOBJ GetCurrentObject(HDC, UINT); // WINBOOL GetCurrentPositionEx(HDC, LPPOINT); int GetDeviceCaps(HDC, int); // int GetDIBits(HDC, HBITMAP, UINT, UINT, LPVOID, LPBITMAPINFO, UINT); // DWORD GetFontData(HDC, DWORD, DWORD, LPVOID, DWORD); // int GetGraphicsMode(HDC); // int GetMapMode(HDC); // UINT GetMetaFileBitsEx(HMETAFILE, UINT, LPVOID); // COLORREF GetNearestColor(HDC, COLORREF); // UINT GetNearestPaletteIndex(HPALETTE, COLORREF); // DWORD GetObjectType(HGDIOBJ); // UINT GetPaletteEntries(HPALETTE, UINT, UINT, LPPALETTEENTRY); // COLORREF GetPixel(HDC, int, int); // int GetPixelFormat(HDC); int GetPolyFillMode(HDC); // WINBOOL GetRasterizerCaps(LPRASTERIZER_STATUS, UINT); // DWORD GetRegionData(HRGN, DWORD, LPRGNDATA); // int GetRgnBox(HRGN, LPRECT); HGDIOBJ GetStockObject(int); // int GetStretchBltMode(HDC); // UINT GetSystemPaletteEntries(HDC, UINT, UINT, LPPALETTEENTRY); // UINT GetSystemPaletteUse(HDC); // int GetTextCharacterExtra(HDC); // UINT GetTextAlign(HDC); // COLORREF GetTextColor(HDC); // int GetTextCharset(HDC); // int GetTextCharsetInfo(HDC, LPFONTSIGNATURE, DWORD); // WINBOOL TranslateCharsetInfo(DWORD*, LPCHARSETINFO, DWORD); // DWORD GetFontLanguageInfo(HDC); // WINBOOL GetViewportExtEx(HDC, LPSIZE); // WINBOOL GetViewportOrgEx(HDC, LPPOINT); // WINBOOL GetWindowExtEx(HDC, LPSIZE); WINBOOL GetWindowOrgEx(HDC, LPPOINT); // int IntersectClipRect(HDC, int, int, int, int); // WINBOOL InvertRgn(HDC, HRGN); // WINBOOL LineDDA(int, int, int, int, LINEDDAPROC, LPARAM); WINBOOL LineTo(HDC, int, int); // WINBOOL MaskBlt(HDC, int, int, int, int, HDC, int, int, HBITMAP, int, int, DWORD); // WINBOOL PlgBlt(HDC, POINT*, HDC, int, int, int, int, HBITMAP, int, int); // int OffsetClipRgn(HDC, int, int); // int OffsetRgn(HRGN, int, int); // WINBOOL PatBlt(HDC, int, int, int, int, DWORD); // WINBOOL Pie(HDC, int, int, int, int, int, int, int, int); // WINBOOL PlayMetaFile(HDC, HMETAFILE); // WINBOOL PaintRgn(HDC, HRGN); // WINBOOL PolyPolygon(HDC, POINT*, WINT*, int); // WINBOOL PtInRegion(HRGN, int, int); // WINBOOL PtVisible(HDC, int, int); // WINBOOL RectInRegion(HRGN, RECT*); // WINBOOL RectVisible(HDC, RECT*); // WINBOOL Rectangle(HDC, int, int, int, int); // WINBOOL RestoreDC(HDC, int); // UINT RealizePalette(HDC); WINBOOL RoundRect(HDC, int, int, int, int, int, int); // WINBOOL ResizePalette(HPALETTE, UINT); int SaveDC(HDC); int SelectClipRgn(HDC, HRGN); // int ExtSelectClipRgn(HDC, HRGN, int); int SetMetaRgn(HDC); HGDIOBJ SelectObject(HDC, HGDIOBJ); HPALETTE SelectPalette(HDC, HPALETTE, WINBOOL); COLORREF SetBkColor(HDC, COLORREF); int SetBkMode(HDC, int); // LONG SetBitmapBits(HBITMAP, DWORD, POINTER); // UINT SetBoundsRect(HDC, RECT*, UINT); // int SetDIBits(HDC, HBITMAP, UINT, UINT, POINTER, PBITMAPINFO, UINT); // int SetDIBitsToDevice(HDC, int, int, DWORD, DWORD, int, int, UINT, UINT, POINTER, BITMAPINFO*, UINT); // DWORD SetMapperFlags(HDC, DWORD); int SetGraphicsMode(HDC, int); // int SetMapMode(HDC, int); // HMETAFILE SetMetaFileBitsEx(UINT, ubyte*); // UINT SetPaletteEntries(HPALETTE, UINT, UINT, PALETTEENTRY*); COLORREF SetPixel(HDC, int, int, COLORREF); // WINBOOL SetPixelV(HDC, int, int, COLORREF); int SetPolyFillMode(HDC, int); WINBOOL StretchBlt(HDC, int, int, int, int, HDC, int, int, int, int, DWORD); WINBOOL SetRectRgn(HRGN, int, int, int, int); // int StretchDIBits(HDC, int, int, int, int, int, int, int, int, POINTER, BITMAPINFO*, UINT, DWORD); int SetROP2(HDC, int); int SetStretchBltMode(HDC, int); // UINT SetSystemPaletteUse(HDC, UINT); // int SetTextCharacterExtra(HDC, int); COLORREF SetTextColor(HDC, COLORREF); UINT SetTextAlign(HDC, UINT); // WINBOOL SetTextJustification(HDC, int, int); // WINBOOL UpdateColors(HDC); // WINBOOL PlayMetaFileRecord(HDC, LPHANDLETABLE, LPMETARECORD, UINT); // WINBOOL EnumMetaFile(HDC, HMETAFILE, ENUMMETAFILEPROC, LPARAM); // HENHMETAFILE CloseEnhMetaFile(HDC); // WINBOOL DeleteEnhMetaFile(HENHMETAFILE); // WINBOOL EnumEnhMetaFile(HDC, HENHMETAFILE, ENHMETAFILEPROC, LPVOID, RECT*); // UINT GetEnhMetaFileHeader(HENHMETAFILE, UINT, LPENHMETAHEADER); // UINT GetEnhMetaFilePaletteEntries(HENHMETAFILE, UINT, LPPALETTEENTRY); // UINT GetWinMetaFileBits(HENHMETAFILE, UINT, LPBYTE, WINT, HDC); // WINBOOL PlayEnhMetaFile(HDC, HENHMETAFILE, RECT*); // WINBOOL PlayEnhMetaFileRecord(HDC, LPHANDLETABLE, ENHMETARECORD*, UINT); // HENHMETAFILE SetEnhMetaFileBits(UINT, ubyte*); // HENHMETAFILE SetWinMetaFileBits(UINT, ubyte*, HDC, METAFILEPICT*); // WINBOOL GdiComment(HDC, UINT, ubyte*); // WINBOOL AngleArc(HDC, int, int, DWORD, FLOAT, FLOAT); // WINBOOL PolyPolyline(HDC, POINT*, DWORD*, DWORD); // WINBOOL GetWorldTransform(HDC, LPXFORM); WINBOOL SetWorldTransform(HDC, XFORM*); // WINBOOL ModifyWorldTransform(HDC, XFORM*, DWORD); // WINBOOL CombineTransform(LPXFORM, XFORM*, XFORM*); // HBITMAP CreateDIBSection(HDC, BITMAPINFO*, UINT, POINTER*, HANDLE, DWORD); // UINT GetDIBColorTable(HDC, UINT, UINT, RGBQUAD*); // UINT SetDIBColorTable(HDC, UINT, UINT, RGBQUAD*); // WINBOOL SetColorAdjustment(HDC, COLORADJUSTMENT*); // WINBOOL GetColorAdjustment(HDC, LPCOLORADJUSTMENT); // HPALETTE CreateHalftonePalette(HDC); // int EndDoc(HDC); // int StartPage(HDC); // int EndPage(HDC); // int AbortDoc(HDC); // int SetAbortProc(HDC, TABORTPROC); // WINBOOL ArcTo(HDC, int, int, int, int, int, int, int, int); WINBOOL BeginPath(HDC); // WINBOOL CloseFigure(HDC); WINBOOL EndPath(HDC); // WINBOOL FillPath(HDC); // WINBOOL FlattenPath(HDC); int GetPath(HDC, LPPOINT, LPBYTE, int); // HRGN PathToRegion(HDC); // WINBOOL PolyDraw(HDC, POINT*, ubyte*, int); // WINBOOL SelectClipPath(HDC, int); // int SetArcDirection(HDC, int); // WINBOOL SetMiterLimit(HDC, FLOAT, PFLOAT); // WINBOOL StrokeAndFillPath(HDC); // WINBOOL StrokePath(HDC); // WINBOOL WidenPath(HDC); HPEN ExtCreatePen(DWORD, DWORD, LOGBRUSH*, DWORD, DWORD*); // WINBOOL GetMiterLimit(HDC, PFLOAT); // int GetArcDirection(HDC); WINBOOL MoveToEx(HDC, int, int, LPPOINT); // HRGN CreatePolygonRgn(POINT*, int, int); // WINBOOL DPtoLP(HDC, LPPOINT, int); // WINBOOL LPtoDP(HDC, LPPOINT, int); // WINBOOL Polygon(HDC, POINT*, int); // WINBOOL Polyline(HDC, POINT*, int); // WINBOOL PolyBezier(HDC, POINT*, DWORD); // WINBOOL PolyBezierTo(HDC, POINT*, DWORD); // WINBOOL PolylineTo(HDC, POINT*, DWORD); // WINBOOL SetViewportExtEx(HDC, int, int, LPSIZE); // WINBOOL SetViewportOrgEx(HDC, int, int, LPPOINT); // WINBOOL SetWindowExtEx(HDC, int, int, LPSIZE); WINBOOL SetWindowOrgEx(HDC, int, int, LPPOINT); // WINBOOL OffsetViewportOrgEx(HDC, int, int, LPPOINT); // WINBOOL OffsetWindowOrgEx(HDC, int, int, LPPOINT); // WINBOOL ScaleViewportExtEx(HDC, int, int, int, int, LPSIZE); // WINBOOL ScaleWindowExtEx(HDC, int, int, int, int, LPSIZE); // WINBOOL SetBitmapDimensionEx(HBITMAP, int, int, LPSIZE); WINBOOL SetBrushOrgEx(HDC, int, int, LPPOINT); // WINBOOL GetDCOrgEx(HDC, LPPOINT); // WINBOOL FixBrushOrgEx(HDC, int, int, LPPOINT); // WINBOOL UnrealizeObject(HGDIOBJ); // WINBOOL GdiFlush(); // DWORD GdiSetBatchLimit(DWORD); // DWORD GdiGetBatchLimit(); // int SetICMMode(HDC, int); // WINBOOL CheckColorsInGamut(HDC, LPVOID, LPVOID, DWORD); // HANDLE GetColorSpace(HDC); // WINBOOL SetColorSpace(HDC, HCOLORSPACE); // WINBOOL DeleteColorSpace(HCOLORSPACE); // WINBOOL GetDeviceGammaRamp(HDC, LPVOID); // WINBOOL SetDeviceGammaRamp(HDC, LPVOID); // WINBOOL ColorMatchToTarget(HDC, HDC, DWORD); // HPROPSHEETPAGE CreatePropertySheetPageA(LPCPROPSHEETPAGE); // WINBOOL DestroyPropertySheetPage(HPROPSHEETPAGE); // void InitCommonControls(); // HIMAGELIST ImageList_Create(int, int, UINT, int, int); // WINBOOL ImageList_Destroy(HIMAGELIST); // int ImageList_GetImageCount(HIMAGELIST); // int ImageList_Add(HIMAGELIST, HBITMAP, HBITMAP); // int ImageList_ReplaceIcon(HIMAGELIST, int, HICON); // COLORREF ImageList_SetBkColor(HIMAGELIST, COLORREF); // COLORREF ImageList_GetBkColor(HIMAGELIST); // WINBOOL ImageList_SetOverlayImage(HIMAGELIST, int, int); WINBOOL ImageList_Draw(HIMAGELIST, int, HDC, int, int, UINT); // WINBOOL ImageList_Replace(HIMAGELIST, int, HBITMAP, HBITMAP); // int ImageList_AddMasked(HIMAGELIST, HBITMAP, COLORREF); // WINBOOL ImageList_DrawEx(HIMAGELIST, int, HDC, int, int, int, int, COLORREF, COLORREF, UINT); // WINBOOL ImageList_Remove(HIMAGELIST, int); // HICON ImageList_GetIcon(HIMAGELIST, int, UINT); WINBOOL ImageList_BeginDrag(HIMAGELIST, int, int, int); void ImageList_EndDrag(); WINBOOL ImageList_DragEnter(HWND, int, int); WINBOOL ImageList_DragLeave(HWND); WINBOOL ImageList_DragMove(int, int); // WINBOOL ImageList_SetDragCursorImage(HIMAGELIST, int, int, int); WINBOOL ImageList_DragShowNolock(WINBOOL); // HIMAGELIST ImageList_GetDragImage(POINT*, POINT*); // WINBOOL ImageList_GetIconSize(HIMAGELIST, int*, int*); // WINBOOL ImageList_SetIconSize(HIMAGELIST, int, int); // WINBOOL ImageList_GetImageInfo(HIMAGELIST, int, IMAGEINFO*); // HIMAGELIST ImageList_Merge(HIMAGELIST, int, HIMAGELIST, int, int, int); // HWND CreateToolbarEx(HWND, DWORD, UINT, int, HINST, UINT, LPCTBBUTTON, int, int, int, int, int, UINT); // HBITMAP CreateMappedBitmap(HINST, int, UINT, LPCOLORMAP, int); // void MenuHelp(UINT, WPARAM, LPARAM, HMENU, HINST, HWND); // WINBOOL ShowHideMenuCtl(HWND, UINT, LPINT); // void GetEffectiveClientRect(HWND, LPRECT); // WINBOOL MakeDragList(HWND); // void DrawInsert(HWND, HWND); // int LBItemFromPt(HWND, POINT, WINBOOL); // HWND CreateUpDownControl(DWORD, int, int, int, int, HWND, int, HINST, HWND, int, int, int); // LONG RegCloseKey(HKEY); // LONG RegSetKeySecurity(HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); // LONG RegFlushKey(HKEY); // LONG RegGetKeySecurity(HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, LPDWORD); // LONG RegNotifyChangeKeyValue(HKEY, WINBOOL, DWORD, HANDLE, WINBOOL); // WINBOOL IsValidCodePage(UINT); // UINT GetACP(); // UINT GetOEMCP(); // WINBOOL GetCPInfo(UINT, LPCPINFO); // WINBOOL IsDBCSLeadByte(ubyte); // WINBOOL IsDBCSLeadByteEx(UINT, ubyte); int MultiByteToWideChar(UINT, DWORD, LPCSTR, int, LPWSTR, int); int WideCharToMultiByte(UINT, DWORD, LPCWSTR, int, LPSTR, int, LPCSTR, LPBOOL); // WINBOOL IsValidLocale(LCID, DWORD); // LCID ConvertDefaultLocale(LCID); // LCID GetThreadLocale(); // WINBOOL SetThreadLocale(LCID); // LANGID GetSystemDefaultLangID(); // LANGID GetUserDefaultLangID(); // LCID GetSystemDefaultLCID(); // LCID GetUserDefaultLCID(); // WINBOOL ReadConsoleOutputAttribute(HANDLE, LPWORD, DWORD, COORD, LPDWORD); // WINBOOL WriteConsoleOutputAttribute(HANDLE, ushort*, DWORD, COORD, LPDWORD); // WINBOOL FillConsoleOutputAttribute(HANDLE, ushort, DWORD, COORD, LPDWORD); // WINBOOL GetConsoleMode(HANDLE, LPDWORD); // WINBOOL GetNumberOfConsoleInputEvents(HANDLE, PDWORD); // WINBOOL GetConsoleScreenBufferInfo(HANDLE, PCONSOLE_SCREEN_BUFFER_INFO); // COORD GetLargestConsoleWindowSize(HANDLE); // WINBOOL GetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO); // WINBOOL GetNumberOfConsoleMouseButtons(LPDWORD); // WINBOOL SetConsoleMode(HANDLE, DWORD); // WINBOOL SetConsoleActiveScreenBuffer(HANDLE); // WINBOOL FlushConsoleInputBuffer(HANDLE); // WINBOOL SetConsoleScreenBufferSize(HANDLE, COORD); // WINBOOL SetConsoleCursorPosition(HANDLE, COORD); // WINBOOL SetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO); // WINBOOL SetConsoleWindowInfo(HANDLE, WINBOOL, SMALL_RECT*); // WINBOOL SetConsoleTextAttribute(HANDLE, ushort); // WINBOOL SetConsoleCtrlHandler(PHANDLER_ROUTINE, WINBOOL); // WINBOOL GenerateConsoleCtrlEvent(DWORD, DWORD); // WINBOOL AllocConsole(); // WINBOOL FreeConsole(); // HANDLE CreateConsoleScreenBuffer(DWORD, DWORD, SECURITY_ATTRIBUTES*, DWORD, LPVOID); // UINT GetConsoleCP(); // WINBOOL SetConsoleCP(UINT); // UINT GetConsoleOutputCP(); // WINBOOL SetConsoleOutputCP(UINT); // DWORD WNetConnectionDialog(HWND, DWORD); // DWORD WNetDisconnectDialog(HWND, DWORD); // DWORD WNetCloseEnum(HANDLE); // WINBOOL CloseServiceHandle(SC_HANDLE); // WINBOOL ControlService(SC_HANDLE, DWORD, LPSERVICE_STATUS); // WINBOOL DeleteService(SC_HANDLE); // SC_LOCK LockServiceDatabase(SC_HANDLE); // WINBOOL NotifyBootConfigStatus(WINBOOL); // WINBOOL QueryServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD); // WINBOOL QueryServiceStatus(SC_HANDLE, LPSERVICE_STATUS); // WINBOOL SetServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR); // WINBOOL SetServiceStatus(SERVICE_STATUS_HANDLE, LPSERVICE_STATUS); // WINBOOL UnlockServiceDatabase(SC_LOCK); // int ChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR*); // int DescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR); // WINBOOL SetPixelFormat(HDC, int, PPIXELFORMATDESCRIPTOR); // WINBOOL SwapBuffers(HDC); // WINBOOL DragQueryPoint(HDROP, LPPOINT); // void DragFinish(HDROP); // void DragAcceptFiles(HWND, BOOL); // HICON DuplicateIcon(HINST, HICON); // BOOL DdeAbandonTransaction(DWORD, HCONV, DWORD); // PBYTE DdeAccessData(HDDEDATA, PDWORD); // HDDEDATA DdeAddData(HDDEDATA, PBYTE, DWORD, DWORD); // HDDEDATA DdeClientTransaction(PBYTE, DWORD, HCONV, HSZ, UINT, UINT, DWORD, PDWORD); // int DdeCmpStringHandles(HSZ, HSZ); // HCONV DdeConnect(DWORD, HSZ, HSZ, CONVCONTEXT*); // HCONVLIST DdeConnectList(DWORD, HSZ, HSZ, HCONVLIST, PCONVCONTEXT); // HDDEDATA DdeCreateDataHandle(DWORD, LPBYTE, DWORD, DWORD, HSZ, UINT, UINT); // WINBOOL DdeDisconnect(HCONV); // BOOL DdeDisconnectList(HCONVLIST); // BOOL DdeEnableCallback(DWORD, HCONV, UINT); // WINBOOL DdeFreeDataHandle(HDDEDATA); // WINBOOL DdeFreeStringHandle(DWORD, HSZ); // DWORD DdeGetData(HDDEDATA, ubyte*, DWORD, DWORD); // UINT DdeGetLastError(DWORD); // BOOL DdeImpersonateClient(HCONV); // BOOL DdeKeepStringHandle(DWORD, HSZ); // HDDEDATA DdeNameService(DWORD, HSZ, HSZ, UINT); // WINBOOL DdePostAdvise(DWORD, HSZ, HSZ); // UINT DdeQueryConvInfo(HCONV, DWORD, PCONVINFO); // HCONV DdeQueryNextServer(HCONVLIST, HCONV); // HCONV DdeReconnect(HCONV); // BOOL DdeSetUserHandle(HCONV, DWORD, DWORD); // BOOL DdeUnaccessData(HDDEDATA); // WINBOOL DdeUninitialize(DWORD); // void SHAddToRecentDocs(UINT); // LPITEMIDLIST SHBrowseForFolder(LPBROWSEINFO); // void SHChangeNotify(LONG, UINT, LPCVOID); // int SHFileOperation(LPSHFILEOPSTRUCT); // void SHFreeNameMappings(HANDLE); DWORD SHGetFileInfo(LPCTSTR, DWORD, SHFILEINFO*, UINT, UINT); // WINBOOL SHGetPathFromIDList(LPCITEMIDLIST, LPTSTR); // HRESULT SHGetSpecialFolderLocation(HWND, int, LPITEMIDLIST*); // THANDLE CreateThread(POINTER, DWORD, TFNTHREADSTARTROUTINE, POINTER, DWORD, DWORD*); // BOOL DdeSetQualityOfService(HWND, TSECURITYQUALITYOFSERVICE*, PSECURITYQUALITYOFSERVICE); // BOOL GetCommMask(THANDLE, DWORD*); // BOOL GetDiskFreeSpaceExA(LPCSTR, void*, void*, PLARGEINTEGER); // BOOL GetDiskFreeSpaceExW(LPWSTR, void*, void*, PLARGEINTEGER); // DWORD GetKerningPairs(HDC, DWORD, void*); // BOOL GetOverlappedResult(THANDLE, TOVERLAPPED*, DWORD*, BOOL); // BOOL GetQueuedCompletionStatus(THANDLE, DWORD*, DWORD*, POVERLAPPED*, DWORD); // BOOL GetSystemPowerStatus(TSYSTEMPOWERSTATUS*); // BOOL ReadFile(THANDLE, void*, DWORD, DWORD*, POVERLAPPED); // BOOL SetThreadContext(THANDLE, TCONTEXT*); // BOOL wglDescribeLayerPlane(HDC, int, int, uint, TLAYERPLANEDESCRIPTOR*); // int wglGetLayerPaletteEntries(HDC, int, int, int, void*); // int wglSetLayerPaletteEntries(HDC, int, int, int, void*); // DWORD WNetGetResourceParentA(PNETRESOURCEA, POINTER, DWORD*); // BOOL WriteFile(THANDLE, void*, DWORD, DWORD*, POVERLAPPED); // // BOOL CancelWaitableTimer(HANDLE hTimer); // HANDLE OpenWaitableTimerA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName); // HANDLE OpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName); // HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName); // HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName); // BOOL SetWaitableTimer(HANDLE hTimer, LARGE_INTEGER* pDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume); } //////////////////////////////////////////////////////////////////////////////////////// // dwt //////////////////////////////////////////////////////////////////////////////////////// alias HANDLE HPAINTBUFFER; extern (Windows){ int AddFontResourceExA(char* lpszFilename, int fl, void* pdv); int AddFontResourceExW(wchar* lpszFilename, int fl, void* pdv); BOOL AlphaBlend( HDC hdcDest, // handle to destination DC int nXOriginDest, // x-coord of upper-left corner int nYOriginDest, // y-coord of upper-left corner int nWidthDest, // destination width int nHeightDest, // destination height HDC hdcSrc, // handle to source DC int nXOriginSrc, // x-coord of upper-left corner int nYOriginSrc, // y-coord of upper-left corner int nWidthSrc, // source width int nHeightSrc, // source height BLENDFUNCTION blendFunction // alpha-blending function ); BOOL TransparentBlt( HDC hdcDest, // handle to destination DC int nXOriginDest, // x-coord of destination upper-left corner int nYOriginDest, // y-coord of destination upper-left corner int nWidthDest, // width of destination rectangle int hHeightDest, // height of destination rectangle HDC hdcSrc, // handle to source DC int nXOriginSrc, // x-coord of source upper-left corner int nYOriginSrc, // y-coord of source upper-left corner int nWidthSrc, // width of source rectangle int nHeightSrc, // height of source rectangle UINT crTransparent // color to make transparent ); int IIDFromString (wchar* lpsz, byte* lpiid); HRESULT ScriptJustify( SCRIPT_VISATTR* psva, int* piAdvance, int cGlyphs, int iDx, int iMinKashida, int* piJustify ); HRESULT ScriptRecordDigitSubstitution( LCID Locale, SCRIPT_DIGITSUBSTITUTE* psds ); HRESULT ScriptApplyDigitSubstitution( SCRIPT_DIGITSUBSTITUTE* psds, SCRIPT_CONTROL* psc, SCRIPT_STATE* pss ); // UxTheme.dll BOOL IsAppThemed(); HRESULT DrawThemeBackground( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, RECT *pRect, RECT *pClipRect ); HRESULT DrawThemeEdge( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pDestRect, UINT uEdge, UINT uFlags, LPRECT pContentRect ); HRESULT DrawThemeIcon( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCRECT pRect, HIMAGELIST himl, int iImageIndex ); HRESULT DrawThemeParentBackground( HWND hwnd, HDC hdc, RECT *prc ); HRESULT DrawThemeText( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, DWORD dwTextFlags2, LPCRECT pRect ); HTHEME OpenThemeData( HWND hwnd, LPCWSTR pszClassList ); HRESULT BufferedPaintInit(); HRESULT CloseThemeData( HTHEME hTheme ); HRESULT BufferedPaintUnInit(); BOOL IsHungAppWindow( HWND hWnd ); HPAINTBUFFER BeginBufferedPaint( HDC hdcTarget, RECT *prcTarget, uint/+BP_BUFFERFORMAT+/ dwFormat, void*/+BP_PAINTPARAMS+/ pPaintParams, HDC *phdc ); HRESULT EndBufferedPaint( HPAINTBUFFER hBufferedPaint, BOOL fUpdateTarget ); HRESULT GetThemeTextExtent( HTHEME hTheme, HDC hdc, int iPartId, int iStateId, LPCWSTR pszText, int iCharCount, DWORD dwTextFlags, LPCRECT pBoundingRect, LPRECT pExtentRect ); HRESULT SetWindowTheme( HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList ); //Kernel32.lib LANGID GetSystemDefaultUILanguage(); // Macro from winnt.h/windows.h WORD PRIMARYLANGID( WORD lgid ); //Gdi32.lib int IntersectClipRect( HDC hdc, // handle to DC int nLeftRect, // x-coord of upper-left corner int nTopRect, // y-coord of upper-left corner int nRightRect, // x-coord of lower-right corner int nBottomRect // y-coord of lower-right corner ); LRESULT CoCreateInstance( byte* rclsid, void* pUnkOuter, int dwClsContext, byte* riid, void* ppv ); /+ // kernel32 winxp/vista version(ANSI){ HANDLE CreateActCtxA( ACTCTXA* pActCtx ); } else{ HANDLE CreateActCtxW( ACTCTXW* pActCtx ); } BOOL ActivateActCtx( HACTCTX hActCtx, uint* lpCookie ); +/ } //-------------------------------------------------------------------------------------- // Windows API extern (Windows){ int AbortDoc(HDC hdc); HKL ActivateKeyboardLayout( HKL hkl, // handle to keyboard layout UINT Flags // keyboard layout flags ); BOOL AdjustWindowRectEx( LPRECT lpRect, // pointer to client-rectangle structure DWORD dwStyle, // window styles BOOL bMenu, // menu-present flag DWORD dwExStyle // extended style ); BOOL Arc( HDC hdc, // handle to device context int nLeftRect, // x-coord of bounding rectangle's upper-left corner int nTopRect, // y-coord of bounding rectangle's upper-left corner int nRightRect, // x-coord of bounding rectangle's lower-right corner int nBottomRect, // y-coord of bounding rectangle's lower-right corner int nXStartArc, // first radial ending point int nYStartArc, // first radial ending point int nXEndArc, // second radial ending point int nYEndArc // second radial ending point ); HDWP BeginDeferWindowPos( int nNumWindows ); //alias STDWIN.BeginPaint BeginPaint; BOOL BitBlt( HDC hdcDest, // handle to destination device context int nXDest, // x-coordinate of destination rectangle's upper-left corner int nYDest, // y-coordinate of destination rectangle's upper-left corner int nWidth, // width of destination rectangle int nHeight, // height of destination rectangle HDC hdcSrc, // handle to source device context int nXSrc, // x-coordinate of source rectangle's upper-left corner int nYSrc, // y-coordinate of source rectangle's upper-left corner DWORD dwRop // raster operation code ); BOOL BringWindowToTop( HWND hWnd // handle to window ); LRESULT CallNextHookEx( HHOOK hhk, // handle to current hook int nCode, // hook code passed to hook procedure WPARAM wParam, // value passed to hook procedure LPARAM lParam // value passed to hook procedure ); LRESULT CallWindowProcA( WNDPROC lpPrevWndFunc, // pointer to previous procedure HWND hWnd, // handle to window UINT Msg, // message WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); LRESULT CallWindowProcW( WNDPROC lpPrevWndFunc, // pointer to previous procedure HWND hWnd, // handle to window UINT Msg, // message WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); LPSTR CharLowerA( LPSTR lpsz // single character or pointer to string ); LPWSTR CharLowerW( LPWSTR lpsz // single character or pointer to string ); LPSTR CharUpperA( LPSTR lpsz // single character or pointer to string ); LPWSTR CharUpperW( LPWSTR lpsz // single character or pointer to string ); DWORD CheckMenuItem( HMENU hmenu, // handle to menu UINT uIDCheckItem, // menu item to check or uncheck UINT uCheck // menu item flags ); BOOL ChooseColorA( LPCHOOSECOLORA lpcc // pointer to structure with initialization data ); BOOL ChooseColorW( LPCHOOSECOLORW lpcc // pointer to structure with initialization data ); BOOL ChooseFontA( LPCHOOSEFONTA lpcf // pointer to structure with initialization data ); BOOL ChooseFontW( LPCHOOSEFONTW lpcf // pointer to structure with initialization data ); //alias STDWIN.ClientToScreen ClientToScreen; BOOL CloseClipboard(); int CombineRgn( HRGN hrgnDest, // handle to destination region HRGN hrgnSrc1, // handle to source region HRGN hrgnSrc2, // handle to source region int fnCombineMode // region combining mode ); //alias STDWIN.CloseHandle CloseHandle; DWORD CommDlgExtendedError(); version(WinCE){ BOOL CommandBar_AddAdornments(HWND hwndCB, DWORD dwFlags, DWORD dwReserved); HWND CommandBar_Create(HINSTANCE hInst, HWND hwndParent, int idCmdBar); void CommandBar_Destroy(HWND hwndCB); BOOL CommandBar_DrawMenuBar(HWND hwndCB, int iButton); int CommandBar_Height(HWND hwndCB); int CommandBar_InsertMenubarEx(HWND hwndCB, HINSTANCE hInst, int pszMenu, int iButton); int CommandBar_Show(HWND hwndCB, int fShow); } HANDLE CopyImage( HANDLE hImage, // handle to the image to copy UINT uType, // type of image to copy int cxDesired, // desired width of new image int cyDesired, // desired height of new image UINT fuFlags // copy flags ); HACCEL CreateAcceleratorTableA( LPACCEL lpaccl, // pointer to structure array with accelerator data int cEntries // number of structures in the array ); HACCEL CreateAcceleratorTableW( LPACCEL lpaccl, // pointer to structure array with accelerator data int cEntries // number of structures in the array ); HBITMAP CreateBitmap( int nWidth, // bitmap width, in pixels int nHeight, // bitmap height, in pixels UINT cPlanes, // number of color planes used by device UINT cBitsPerPel, // number of bits required to identify a color VOID *lpvBits // pointer to array containing color data ); //alias STDWIN.CreateCaret CreateCaret; HBITMAP CreateCompatibleBitmap( HDC hdc, // handle to device context int nWidth, // width of bitmap, in pixels int nHeight // height of bitmap, in pixels ); //alias STDWIN.CreateCompatibleDC CreateCompatibleDC; HCURSOR CreateCursor( HINSTANCE hInst, // handle to application instance int xHotSpot, // horizontal position of hot spot int yHotSpot, // vertical position of hot spot int nWidth, // cursor width int nHeight, // cursor height VOID *pvANDPlane, // pointer to AND bitmask array VOID *pvXORPlane // pointer to XOR bitmask array ); HDC CreateDCA( LPCSTR lpszDriver, // pointer to string specifying driver name LPCSTR lpszDevice, // pointer to string specifying device name LPCSTR lpszOutput, // do not use; set to NULL DEVMODE *lpInitData // pointer to optional printer data ); HDC CreateDCW( LPCWSTR lpszDriver, // pointer to string specifying driver name LPCWSTR lpszDevice, // pointer to string specifying device name LPCWSTR lpszOutput, // do not use; set to NULL DEVMODE *lpInitData // pointer to optional printer data ); HBITMAP CreateDIBSection( HDC hdc, // handle to device context BITMAPINFO *pbmi, // pointer to structure containing bitmap size, // format, and color data UINT iUsage, // color data type indicator: RGB values or // palette indexes VOID *ppvBits, // pointer to variable to receive a pointer to // the bitmap's bit values HANDLE hSection, // optional handle to a file mapping object DWORD dwOffset // offset to the bitmap bit values within the // file mapping object ); HANDLE CreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, // pointer to security attributes BOOL bManualReset, // flag for manual-reset event BOOL bInitialState, // flag for initial state LPCSTR lpName // pointer to event-object name ); HANDLE CreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, // pointer to security attributes BOOL bManualReset, // flag for manual-reset event BOOL bInitialState, // flag for initial state LPCWSTR lpName // pointer to event-object name ); //alias STDWIN.CreateFileA CreateFileA; //alias STDWIN.CreateFileW CreateFileW; HFONT CreateFontIndirectA(LOGFONTA* lplf ); HFONT CreateFontIndirectW(LOGFONTW* lplf ); HICON CreateIconIndirect( PICONINFO piconinfo // pointer to icon information structure ); HMENU CreateMenu(); HPALETTE CreatePalette( LOGPALETTE *lplgpl // pointer to logical color palette ); HBRUSH CreatePatternBrush( HBITMAP hbmp // handle to bitmap ); //alias STDWIN.CreatePen CreatePen; HRGN CreatePolygonRgn( POINT *lppt, // pointer to array of points int cPoints, // number of points in array int fnPolyFillMode // polygon-filling mode ); HMENU CreatePopupMenu(); //alias STDWIN.CreateRectRgn CreateRectRgn; HBRUSH CreateSolidBrush( COLORREF crColor // brush color value ); //alias STDWIN.CreateWindowExA CreateWindowExA; HWND CreateWindowExW( DWORD dwExStyle, // extended window style LPCWSTR lpClassName, // pointer to registered class name LPCWSTR lpWindowName, // pointer to window name DWORD dwStyle, // window style int x, // horizontal position of window int y, // vertical position of window int nWidth, // window width int nHeight, // window height HWND hWndParent, // handle to parent or owner window HMENU hMenu, // handle to menu, or child-window identifier HINSTANCE hInstance, // handle to application instance LPVOID lpParam // pointer to window-creation data ); LRESULT DefFrameProcA( HWND hWnd, // handle to MDI frame window HWND hWndMDIClient, // handle to MDI client window UINT uMsg, // message WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); LRESULT DefFrameProcW( HWND hWnd, // handle to MDI frame window HWND hWndMDIClient, // handle to MDI client window UINT uMsg, // message WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); LRESULT DefMDIChildProcA( HWND hWnd, // handle to MDI child window UINT uMsg, // message WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); LRESULT DefMDIChildProcW( HWND hWnd, // handle to MDI child window UINT uMsg, // message WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); //alias STDWIN.DefWindowProcA DefWindowProcA; LRESULT DefWindowProcW( HWND hWnd, // handle to window UINT Msg, // message identifier WPARAM wParam, // first message parameter LPARAM lParam // second message parameter ); HDWP DeferWindowPos( HDWP hWinPosInfo, // handle to internal structure HWND hWnd, // handle to window to position HWND hWndInsertAfter, // placement-order handle int x, // horizontal position int y, // vertical position int cx, // width int cy, // height UINT uFlags // window-positioning flags ); //alias STDWIN.DeleteDC DeleteDC; //alias STDWIN.DeleteFileA DeleteFileA; BOOL DeleteMenu( HMENU hMenu, // handle to menu UINT uPosition, // menu item identifier or position UINT uFlags // menu item flag ); //alias STDWIN.DeleteObject DeleteObject; BOOL DestroyAcceleratorTable( HACCEL hAccel // handle to accelerator table ); int DestroyCaret(); BOOL DestroyCursor( HCURSOR hCursor // handle to cursor to destroy ); BOOL DestroyIcon( HICON hIcon // handle to icon to destroy ); BOOL DestroyMenu( HMENU hMenu // handle to menu to destroy ); BOOL DestroyWindow( HWND hWnd // handle to window to destroy ); LONG DispatchMessageA( MSG *lpmsg // pointer to structure with message ); LONG DispatchMessageW( MSG *lpmsg // pointer to structure with message ); BOOL DragDetect( HWND hwnd, POINT pt ); void DragFinish( HDROP hDrop ); UINT DragQueryFileA( HDROP hDrop, UINT iFile, LPSTR lpszFile, UINT cch ); UINT DragQueryFileW( HDROP hDrop, UINT iFile, LPWSTR lpszFile, UINT cch ); BOOL DrawEdge( HDC hdc, // handle to device context LPRECT qrc, // pointer to rectangle coordinates UINT edge, // type of inner and outer edge to draw UINT grfFlags // type of border ); BOOL DrawFocusRect( HDC hDC, // handle to device context RECT *lprc // pointer to structure for rectangle ); BOOL DrawFrameControl( HDC hdc, // handle to device context LPRECT lprc, // pointer to bounding rectangle UINT uType, // frame-control type UINT uState // frame-control state ); BOOL DrawIconEx( HDC hdc, // handle to device context int xLeft, // x-coordinate of upper left corner int yTop, // y-coordinate of upper left corner HICON hIcon, // handle to icon to draw int cxWidth, // width of the icon int cyWidth, // height of the icon UINT istepIfAniCur, // index of frame in animated cursor HBRUSH hbrFlickerFreeDraw, // handle to background brush UINT diFlags // icon-drawing flags ); BOOL DrawMenuBar( HWND hWnd // handle to window with menu bar to redraw ); BOOL DrawStateA( HDC hdc, // handle to device context HBRUSH hbr, // handle to brush DRAWSTATEPROC lpOutputFunc, // pointer to callback function LPARAM lData, // image information WPARAM wData, // more image information int x, // horizontal location of image int y, // vertical location of image int cx, // width of image int cy, // height of image UINT fuFlags // image type and state ); BOOL DrawStateW( HDC hdc, // handle to device context HBRUSH hbr, // handle to brush DRAWSTATEPROC lpOutputFunc, // pointer to callback function LPARAM lData, // image information WPARAM wData, // more image information int x, // horizontal location of image int y, // vertical location of image int cx, // width of image int cy, // height of image UINT fuFlags // image type and state ); int DrawTextA( HDC hDC, // handle to device context LPCSTR lpString, // pointer to string to draw int nCount, // string length, in characters LPRECT lpRect, // pointer to struct with formatting dimensions UINT uFormat // text-drawing flags ); int DrawTextW( HDC hDC, // handle to device context LPCWSTR lpString, // pointer to string to draw int nCount, // string length, in characters LPRECT lpRect, // pointer to struct with formatting dimensions UINT uFormat // text-drawing flags ); BOOL Ellipse( HDC hdc, // handle to device context int nLeftRect, // x-coord of bounding rectangle's upper-left corner int nTopRect, // y-coord of bounding rectangle's upper-left corner int nRightRect, // x-coord of bounding rectangle's lower-right corner int nBottomRect // y-coord of bounding rectangle's lower-right corner ); BOOL EnableMenuItem( HMENU hMenu, // handle to menu UINT uIDEnableItem, // menu item to enable, disable, or gray UINT uEnable // menu item flags ); BOOL EnableWindow( HWND hWnd, BOOL bEnable ); BOOL EndDeferWindowPos( HDWP hWinPosInfo // handle to internal structure ); int EndDoc(HDC hDC); int EndPage(HDC hDC); BOOL EnumDisplayMonitors( HDC hdc, // handle to display DC LPCRECT lprcClip, // clipping rectangle MONITORENUMPROC lpfnEnum, // callback function LPARAM dwData // data for callback function ); int EnumFontFamiliesExA( HDC hdc, // handle to device context LPLOGFONTA lpLogfont, // pointer to logical font information FONTENUMEXPROC lpEnumFontFamExProc, // pointer to callback function LPARAM lParam, // application-supplied data DWORD dwFlags // reserved; must be zero ); int EnumFontFamiliesExW( HDC hdc, // handle to device context LPLOGFONTW lpLogfont, // pointer to logical font information FONTENUMEXPROC lpEnumFontFamExProc, // pointer to callback function LPARAM lParam, // application-supplied data DWORD dwFlags // reserved; must be zero ); int EnumFontFamiliesA( HDC hdc, // handle to device control LPCSTR lpszFamily, // pointer to family-name string FONTENUMPROC lpEnumFontFamProc, // pointer to callback function LPARAM lParam // pointer to application-supplied data ); int EnumFontFamiliesW( HDC hdc, // handle to device control LPCWSTR lpszFamily, // pointer to family-name string FONTENUMPROC lpEnumFontFamProc, // pointer to callback function LPARAM lParam // pointer to application-supplied data ); BOOL EnumSystemLanguageGroupsA( LANGUAGEGROUP_ENUMPROC pLangGroupEnumProc, // callback function DWORD dwFlags, // language groups LONG_PTR lParam // callback parameter ); BOOL EnumSystemLanguageGroupsW( LANGUAGEGROUP_ENUMPROC pLangGroupEnumProc, // callback function DWORD dwFlags, // language groups LONG_PTR lParam // callback parameter ); BOOL EnumSystemLocalesA( LOCALE_ENUMPROC lpLocaleEnumProc, // callback function DWORD dwFlags // locales ); BOOL EnumSystemLocalesW( LOCALE_ENUMPROC lpLocaleEnumProc, // callback function DWORD dwFlags // locales ); BOOL EqualRect( RECT *lprc1, // pointer to structure with first rectangle RECT *lprc2 // pointer to structure with second rectangle ); BOOL EqualRgn( HRGN hSrcRgn1, // handle to first region HRGN hSrcRgn2 // handle to second region ); DWORD ExpandEnvironmentStringsA( LPCSTR lpSrc, // pointer to string with environment variables LPSTR lpDst, // pointer to string with expanded environment // variables DWORD nSize // maximum characters in expanded string ); DWORD ExpandEnvironmentStringsW( LPCWSTR lpSrc, // pointer to string with environment variables LPWSTR lpDst, // pointer to string with expanded environment // variables DWORD nSize // maximum characters in expanded string ); BOOL ExtTextOutA( HDC hdc, // handle to device context int X, // x-coordinate of reference point int Y, // y-coordinate of reference point UINT fuOptions, // text-output options RECT *lprc, // optional clipping and/or opaquing rectangle LPCSTR lpString, // points to string UINT cbCount, // number of characters in string INT *lpDx // pointer to array of intercharacter spacing // values ); BOOL ExtTextOutW( HDC hdc, // handle to device context int X, // x-coordinate of reference point int Y, // y-coordinate of reference point UINT fuOptions, // text-output options RECT *lprc, // optional clipping and/or opaquing rectangle LPCWSTR lpString, // points to string UINT cbCount, // number of characters in string INT *lpDx // pointer to array of intercharacter spacing // values ); UINT ExtractIconExA( LPCSTR lpszFile, int nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons ); UINT ExtractIconExW( LPCWSTR lpszFile, int nIconIndex, HICON *phiconLarge, HICON *phiconSmall, UINT nIcons ); HRSRC FindResourceA( HMODULE hModule, // module handle LPCSTR lpName, // pointer to resource name LPCSTR lpType // pointer to resource type ); HRSRC FindResourceW( HMODULE hModule, // module handle LPCWSTR lpName, // pointer to resource name LPCWSTR lpType // pointer to resource type ); HWND FindWindowA( LPCSTR lpClassName, // pointer to class name LPCSTR lpWindowName // pointer to window name ); HWND FindWindowW( LPCWSTR lpClassName, // pointer to class name LPCWSTR lpWindowName // pointer to window name ); DWORD FormatMessageA( DWORD dwFlags, // source and processing options LPCVOID lpSource, // pointer to message source DWORD dwMessageId, // requested message identifier DWORD dwLanguageId, // language identifier for requested message LPSTR lpBuffer, // pointer to message buffer DWORD nSize, // maximum size of message buffer // va_list *Arguments // pointer to array of message inserts void* Arguments ); DWORD FormatMessageW( DWORD dwFlags, // source and processing options LPCVOID lpSource, // pointer to message source DWORD dwMessageId, // requested message identifier DWORD dwLanguageId, // language identifier for requested message LPWSTR lpBuffer, // pointer to message buffer DWORD nSize, // maximum size of message buffer // va_list *Arguments // pointer to array of message inserts void* Arguments ); DWORD GdiSetBatchLimit( DWORD dwLimit // batch limit ); UINT GetACP(); HWND GetActiveWindow(); COLORREF GetBkColor( HDC hdc // handle of device context ); HWND GetCapture(); BOOL GetCaretPos( LPPOINT lpPoint // address of structure to receive coordinates ); BOOL GetCharABCWidthsA( HDC hdc, // handle to device context UINT uFirstChar, // first character in range to query UINT uLastChar, // last character in range to query LPABC lpabc // pointer to character-width structure ); BOOL GetCharABCWidthsW( HDC hdc, // handle to device context UINT uFirstChar, // first character in range to query UINT uLastChar, // last character in range to query LPABC lpabc // pointer to character-width structure ); BOOL GetCharWidthA( HDC hdc, // handle to device context UINT iFirstChar, // first character in range to query UINT iLastChar, // last character in range to query LPINT lpBuffer // pointer to buffer for widths ); BOOL GetCharWidthW( HDC hdc, // handle to device context UINT iFirstChar, // first character in range to query UINT iLastChar, // last character in range to query LPINT lpBuffer // pointer to buffer for widths ); DWORD GetCharacterPlacementA( HDC hdc, // handle to device context LPCSTR lpString, // pointer to string int nCount, // number of characters in string int nMaxExtent, // maximum extent for displayed string LPGCP_RESULTS lpResults, // pointer to buffer for placement result DWORD dwFlags // placement flags ); DWORD GetCharacterPlacementW( HDC hdc, // handle to device context LPCWSTR lpString, // pointer to string int nCount, // number of characters in string int nMaxExtent, // maximum extent for displayed string LPGCP_RESULTS lpResults, // pointer to buffer for placement result DWORD dwFlags // placement flags ); BOOL GetClassInfoA( HINSTANCE hInstance, // handle of application instance LPCSTR lpClassName, // address of class name string LPWNDCLASSA lpWndClass // address of structure for class data ); BOOL GetClassInfoW( HINSTANCE hInstance, // handle of application instance LPCWSTR lpClassName, // address of class name string LPWNDCLASSW lpWndClass // address of structure for class data ); //alias STDWIN.GetClientRect GetClientRect; //alias STDWIN.GetClipBox GetClipBox; //alias STDWIN.GetClipRgn GetClipRgn; HANDLE GetClipboardData( UINT uFormat // clipboard format ); int GetClipboardFormatNameA( UINT format, // clipboard format to retrieve LPSTR lpszFormatName, // address of buffer for name int cchMaxCount // length of name string in characters ); int GetClipboardFormatNameW( UINT format, // clipboard format to retrieve LPWSTR lpszFormatName, // address of buffer for name int cchMaxCount // length of name string in characters ); BOOL GetComboBoxInfo( HWND hwndCombo, PCOMBOBOXINFO pcbi ); //alias STDWIN.GetCurrentObject GetCurrentObject; DWORD GetCurrentProcessId(); DWORD GetCurrentThreadId(); HCURSOR GetCursor(); BOOL GetCursorPos( LPPOINT lpPoint // address of structure for cursor position ); //alias STDWIN.GetDC GetDC; UINT GetDIBColorTable( HDC hdc, // handle to device context whose DIB is of // interest UINT uStartIndex, // color table index of first entry to retrieve UINT cEntries, // number of color table entries to retrieve RGBQUAD *pColors // pointer to buffer that receives color table // entries ); int GetDIBits( HDC hdc, // handle to device context HBITMAP hbmp, // handle to bitmap UINT uStartScan, // first scan line to set in destination bitmap UINT cScanLines, // number of scan lines to copy LPVOID lpvBits, // address of array for bitmap bits LPBITMAPINFO lpbi, // address of structure with bitmap data UINT uUsage // RGB or palette index ); HWND GetDesktopWindow(); int GetDialogBaseUnits(); int GetDoubleClickTime(); DWORD GetFontLanguageInfo( HDC hdc // handle to a device context ); BOOL GetGUIThreadInfo( DWORD idThread, LPGUITHREADINFO lpgui ); BOOL GetIconInfo( HICON hIcon, // icon handle PICONINFO piconinfo // address of icon structure ); int GetKeyNameTextA( LONG lParam, // second parameter of keyboard message LPSTR lpString, // pointer to buffer for key name int nSize // maximum length of key-name string length ); int GetKeyNameTextW( LONG lParam, // second parameter of keyboard message LPWSTR lpString, // pointer to buffer for key name int nSize // maximum length of key-name string length ); HKL GetKeyboardLayout( DWORD dwLayout // thread identifier ); SHORT GetKeyState( int nVirtKey // virtual-key code ); UINT GetKeyboardLayoutList( int nBuff, // size of buffer in array element HKL *lpList // buffer for keyboard layout handles ); BOOL GetKeyboardState( PBYTE lpKeyState // pointer to array to receive status data ); HWND GetLastActivePopup(HWND hWnd); DWORD GetLastError(); DWORD GetLayout( HDC hdc // handle to DC ); int GetLocaleInfoA( LCID Locale, // locale identifier LCTYPE LCType, // type of information LPSTR lpLCData, // address of buffer for information int cchData // size of buffer ); int GetLocaleInfoW( LCID Locale, // locale identifier LCTYPE LCType, // type of information LPWSTR lpLCData, // address of buffer for information int cchData // size of buffer ); HMENU GetMenu( HWND hWnd // handle to window ); BOOL GetMenuBarInfo( HWND hwnd, LONG idObject, LONG idItem, PMENUBARINFO pmbi ); UINT GetMenuDefaultItem( HMENU hMenu, UINT fByPos, UINT gmdiFlags ); BOOL GetMenuInfo( HMENU hmenu, LPCMENUINFO lpcmi ); int GetMenuItemCount(HMENU hMenu); BOOL GetMenuItemInfoA( HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii ); BOOL GetMenuItemInfoW( HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii ); BOOL GetMenuItemRect( HWND hWnd, HMENU hMenu, UINT uItem, LPRECT lprcItem ); BOOL GetMessageW( LPMSG lpMsg, // address of structure with message HWND hWnd, // handle of window UINT wMsgFilterMin, // first message UINT wMsgFilterMax // last message ); DWORD GetMessagePos(); LONG GetMessageTime(); DWORD GetModuleFileNameA( HMODULE hModule, // handle to module to find filename for LPSTR lpFilename, // pointer to buffer to receive module path DWORD nSize // size of buffer, in characters ); DWORD GetModuleFileNameW( HMODULE hModule, // handle to module to find filename for LPWSTR lpFilename, // pointer to buffer to receive module path DWORD nSize // size of buffer, in characters ); HMODULE GetModuleHandleW( LPCWSTR lpModuleName ); BOOL GetMonitorInfoA( HMONITOR hMonitor, // handle to display monitor LPMONITORINFO lpmi // pointer to display monitor information ); BOOL GetMonitorInfoW( HMONITOR hMonitor, // handle to display monitor LPMONITORINFO lpmi // pointer to display monitor information ); UINT GetNearestPaletteIndex( HPALETTE hpal, // handle of logical color palette COLORREF crColor // color to be matched ); BOOL GetOpenFileNameA( OPENFILENAMEA* lpofn // address of structure with initialization data ); BOOL GetOpenFileNameW( OPENFILENAMEW* lpofn // address of structure with initialization data ); UINT GetPaletteEntries( HPALETTE hpal, // handle to logical palette UINT iStartIndex, // first entry to retrieve UINT nEntries, // number of entries to retrieve LPPALETTEENTRY lppe // array that receives entries ); HWND GetParent( HWND hWnd // handle to child window ); COLORREF GetPixel( HDC hdc, // handle to device context int XPos, // x-coordinate of pixel int nYPos // y-coordinate of pixel ); HANDLE GetProcessHeap(); DWORD GetProfileStringA( LPCSTR lpAppName, // address of section name LPCSTR lpKeyName, // address of key name LPCSTR lpDefault, // address of default string LPSTR lpReturnedString, // address of destination buffer DWORD nSize // size of destination buffer ); DWORD GetProfileStringW( LPCWSTR lpAppName, // address of section name LPCWSTR lpKeyName, // address of key name LPCWSTR lpDefault, // address of default string LPWSTR lpReturnedString, // address of destination buffer DWORD nSize // size of destination buffer ); int GetROP2( HDC hdc // handle of device context ); int GetRandomRgn( HDC hdc, // handle to DC HRGN hrgn, // handle to region INT iNum // must be SYSRGN ); DWORD GetRegionData( HRGN hRgn, // handle to region DWORD dwCount, // size of buffer containing region data LPRGNDATA lpRgnData // pointer to region data ); int GetRgnBox( HRGN hrgn, // handle to a region LPRECT lprc // pointer that receives bounding rectangle ); BOOL GetSaveFileNameA( OPENFILENAMEA* lpofn // address of structure with initialization data ); BOOL GetSaveFileNameW( OPENFILENAME* lpofn // address of structure with initialization data ); BOOL GetScrollInfo( HWND hwnd, // handle to window with scroll bar int fnBar, // scroll bar flag LPSCROLLINFO lpsi // pointer to structure for scroll parameters ); //alias STDWIN.GetStockObject GetStockObject; DWORD GetSysColor( int nIndex // display element ); HBRUSH GetSysColorBrush( int nIndex // system color index ); HMENU GetSystemMenu( HWND hWnd, // handle to window to own window menu BOOL bRevert // reset flag ); int GetSystemMetrics( int nIndex // system metric or configuration setting to retrieve ); UINT GetSystemPaletteEntries( HDC hdc, // handle of device context UINT iStartIndex, // index of first entry to be retrieved UINT nEntries, // number of entries to be retrieved LPPALETTEENTRY lppe // array receiving system-palette entries ); int GetTextCharset( HDC hdc // handle to DC ); COLORREF GetTextColor( HDC hdc // handle to device context ); BOOL GetTextExtentPoint32A( HDC hdc, // handle to device context LPCSTR lpString, // pointer to text string int cbString, // number of characters in string LPSIZE lpSize // pointer to structure for string size ); BOOL GetTextExtentPoint32W( HDC hdc, // handle to device context LPCWSTR lpString, // pointer to text string int cbString, // number of characters in string LPSIZE lpSize // pointer to structure for string size ); BOOL GetTextMetricsW( HDC hdc, // handle to device context TEXTMETRICW* lptm // pointer to text metrics structure ); DWORD GetTickCount(); //alias STDWIN.GetUpdateRect GetUpdateRect; //alias STDWIN.GetUpdateRgn GetUpdateRgn; DWORD GetVersion(); BOOL GetVersionExA( LPOSVERSIONINFOA lpVersionInformation // pointer to version information structure ); BOOL GetVersionExW( LPOSVERSIONINFOW lpVersionInformation // pointer to version information structure ); HWND GetWindow( HWND hWnd, // handle to original window UINT uCmd // relationship flag ); LONG GetWindowLongA(HWND hWnd, int nIndex); LONG GetWindowLongW(HWND hWnd, int nIndex); BOOL GetWindowPlacement( HWND hWnd, WINDOWPLACEMENT *lpwndpl ); int GetWindowTextA( HWND hWnd, // handle to window or control with text LPSTR lpString, // address of buffer for text int nMaxCount // maximum number of characters to copy ); int GetWindowTextW( HWND hWnd, // handle to window or control with text LPWSTR lpString, // address of buffer for text int nMaxCount // maximum number of characters to copy ); int GetWindowTextLengthA(HWND hWnd); int GetWindowTextLengthW(HWND hWnd); DWORD GetWindowThreadProcessId( HWND hWnd, // handle to window LPDWORD lpdwProcessId // address of variable for process identifier ); HGLOBAL GlobalAlloc(UINT uFlags, SIZE_T dwBytes); HGLOBAL GlobalFree(HGLOBAL hMem); LPVOID GlobalLock(HGLOBAL hMem); SIZE_T GlobalSize(HGLOBAL hMem); BOOL GlobalUnlock(HGLOBAL hMem); BOOL GradientFill( HDC hdc, PTRIVERTEX pVertex, DWORD dwNumVertex, PVOID pMesh, DWORD dwNumMesh, DWORD dwMode ); LPVOID HeapAlloc( HANDLE hHeap, // handle to the private heap block DWORD dwFlags, // heap allocation control flags DWORD dwBytes // number of bytes to allocate ); BOOL HeapFree( HANDLE hHeap, // handle to the heap DWORD dwFlags, // heap freeing flags LPVOID lpMem // pointer to the memory to free ); //alias STDWIN.HideCaret HideCaret; int ImageList_Add( HIMAGELIST himl, HBITMAP hbmImage, HBITMAP hbmMask ); int ImageList_AddMasked( HIMAGELIST himl, HBITMAP hbmImage, COLORREF crMask ); HIMAGELIST ImageList_Create( int cx, int cy, UINT flags, int cInitial, int cGrow ); BOOL ImageList_Destroy( HIMAGELIST himl ); HICON ImageList_GetIcon( HIMAGELIST himl, int i, UINT flags ); BOOL ImageList_GetIconSize( HIMAGELIST himl, int *cx, int *cy ); int ImageList_GetImageCount( HIMAGELIST himl ); BOOL ImageList_Remove( HIMAGELIST himl, int i ); BOOL ImageList_Replace( HIMAGELIST himl, int i, HBITMAP hbmImage, HBITMAP hbmMask ); int ImageList_ReplaceIcon( HIMAGELIST himl, int i, HICON hicon ); BOOL ImageList_SetIconSize( HIMAGELIST himl, int cx, int cy ); HIMC ImmAssociateContext( HWND hWnd, HIMC hIMC ); HIMC ImmCreateContext(); int ImmDestroyContext(HIMC hIMC ); BOOL ImmGetCompositionFontA( HIMC hIMC, LPLOGFONTA lplf ); BOOL ImmGetCompositionFontW( HIMC hIMC, LOGFONTW* lplf ); LONG ImmGetCompositionStringA( HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen ); LONG ImmGetCompositionStringW( HIMC hIMC, DWORD dwIndex, LPVOID lpBuf, DWORD dwBufLen ); HIMC ImmGetContext( HWND hWnd ); BOOL ImmGetConversionStatus( HIMC hIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence ); HWND ImmGetDefaultIMEWnd(HWND hWnd ); BOOL ImmGetOpenStatus( HIMC hIMC ); BOOL ImmReleaseContext( HWND hWnd, HIMC hIMC ); BOOL ImmSetCompositionFontA( HIMC hIMC, LOGFONTA* lplf ); BOOL ImmSetCompositionFontW( HIMC hIMC, LOGFONTW* lplf ); BOOL ImmSetCompositionWindow( HIMC hIMC, LPCOMPOSITIONFORM lpCompForm ); BOOL ImmSetConversionStatus( HIMC hIMC, DWORD fdwConversion, DWORD fdwSentence ); BOOL ImmSetOpenStatus( HIMC hIMC, BOOL fOpen ); void InitCommonControls(); BOOL InitCommonControlsEx( LPINITCOMMONCONTROLSEX lpInitCtrls ); BOOL InsertMenuA( HMENU hMenu, // handle to menu UINT uPosition, // menu item that new menu item precedes UINT uFlags, // menu item flags UINT uIDNewItem, // menu item identifier or handle to drop-down // menu or submenu LPCSTR lpNewItem // menu item content ); BOOL InsertMenuW( HMENU hMenu, // handle to menu UINT uPosition, // menu item that new menu item precedes UINT uFlags, // menu item flags UINT uIDNewItem, // menu item identifier or handle to drop-down // menu or submenu LPCWSTR lpNewItem // menu item content ); BOOL InsertMenuItemA( HMENU hMenu, UINT uItem, BOOL fByPosition, MENUITEMINFOA* lpmii ); BOOL InsertMenuItemW( HMENU hMenu, UINT uItem, BOOL fByPosition, MENUITEMINFOW* lpmii ); BOOL IntersectRect( LPRECT lprcDst, // pointer to structure for intersection RECT *lprcSrc1, // pointer to structure with first rectangle RECT *lprcSrc2 // pointer to structure with second rectangle ); LONG InterlockedIncrement( LPLONG lpAddend // pointer to the variable to increment ); LONG InterlockedDecrement( LPLONG lpAddend // address of the variable to decrement ); BOOL IsDBCSLeadByte( BYTE TestChar // character to test ); BOOL IsIconic( HWND hWnd // handle to window ); BOOL IsWindow( HWND hWnd // handle to window ); BOOL IsWindowEnabled(HWND hWnd); BOOL IsWindowVisible(HWND hWnd); BOOL IsZoomed(HWND hWnd); BOOL KillTimer( HWND hWnd, // handle of window that installed timer UINT uIDEvent // timer identifier ); //alias STDWIN.LineTo LineTo; HBITMAP LoadBitmapA( HINSTANCE hInstance, // handle to application instance LPCSTR lpBitmapName // name of bitmap resource ); HBITMAP LoadBitmapW( HINSTANCE hInstance, // handle to application instance LPCWSTR lpBitmapName // name of bitmap resource ); HANDLE LoadImageA( HINSTANCE hinst, // handle of the instance containing the image LPCSTR lpszName, // name or identifier of image UINT uType, // type of image int cxDesired, // desired width int cyDesired, // desired height UINT fuLoad // load flags ); HANDLE LoadImageW( HINSTANCE hinst, // handle of the instance containing the image LPCWSTR lpszName, // name or identifier of image UINT uType, // type of image int cxDesired, // desired width int cyDesired, // desired height UINT fuLoad // load flags ); HINSTANCE LoadLibraryW(wchar* lpLibFileName ); HGLOBAL LoadResource( HMODULE hModule, // resource-module handle HRSRC hResInfo // resource handle ); int LoadStringA( HINSTANCE hInstance, UINT uID, LPSTR lpBuffer, int nBufferMax ); int LoadStringW( HINSTANCE hInstance, UINT uID, LPWSTR lpBuffer, int nBufferMax ); HLOCAL LocalFree( HLOCAL hMem // handle to local memory object ); LPVOID LockResource( HGLOBAL hResData // handle to resource to lock ); UINT MapVirtualKeyA( UINT uCode, // virtual-key code or scan code UINT uMapType // translation to perform ); UINT MapVirtualKeyW( UINT uCode, // virtual-key code or scan code UINT uMapType // translation to perform ); BOOL MessageBeep( UINT uType // sound type ); int MessageBoxW( HWND hWnd, // handle of owner window LPCWSTR lpText, // address of text in message box LPCWSTR lpCaption, // address of title of message box UINT uType // style of message box ); HMONITOR MonitorFromWindow( HWND hwnd, // handle to a window DWORD dwFlags // flags if no monitor intersects the window ); DWORD MsgWaitForMultipleObjectsEx( DWORD nCount, // number of handles in handle array LPHANDLE pHandles, // pointer to an object-handle array DWORD dwMilliseconds, // time-out interval in milliseconds DWORD dwWakeMask, // type of input events to wait for DWORD dwFlags // wait flags ); void NotifyWinEvent( DWORD event, HWND hwnd, LONG idObject, LONG idChild ); int OffsetRgn( HRGN hrgn, // handle to region int nXOffset, // offset along x-axis int nYOffset // offset along y-axis ); WINOLEAPI OleInitialize( LPVOID pvReserved //Reserved; must be NULL. ); void OleUninitialize(); BOOL OpenClipboard( HWND hWndNewOwner ); void OutputDebugStringA( LPCSTR lpOutputString ); void OutputDebugStringW( LPCWSTR lpOutputString ); BOOL PatBlt( HDC hdc, // handle to device context int nXLeft, // x-coord. of upper-left corner of rect. to be filled int nYLeft, // y-coord. of upper-left corner of rect. to be filled int nWidth, // width of rectangle to be filled int nHeight, // height of rectangle to be filled DWORD dwRop // raster operation code ); BOOL PeekMessageW( LPMSG lpMsg, // pointer to structure for message HWND hWnd, // handle to window UINT wMsgFilterMin, // first message UINT wMsgFilterMax, // last message UINT wRemoveMsg // removal flags ); BOOL Pie( HDC hdc, // handle to device context int nLeftRect, // x-coord of bounding rectangle's upper-left corner int nTopRect, // y-coord of bounding rectangle's upper-left corner int nRightRect, // x-coord of bounding rectangle's lower-right corner int nBottomRect, // y-coord of bounding rectangle's lower-right corner int nXRadial1, // x-coord of first radial's endpoint int nYRadial1, // y-coord of first radial's endpoint int nXRadial2, // x-coord of second radial's endpoint int nYRadial2 // y-coord of second radial's endpoint ); BOOL Polygon( HDC hdc, // handle to device context POINT *lpPoints, // pointer to polygon's vertices int nCount // count of polygon's vertices ); BOOL Polyline( HDC hdc, // handle to device context POINT *lppt, // pointer to array containing endpoints int cPoints // number of points in the array ); BOOL PostMessageA( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ); BOOL PostMessageW( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ); BOOL PostThreadMessageA( DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam ); BOOL PostThreadMessageW( DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam ); BOOL PrintDlgA( LPPRINTDLGA lppd ); BOOL PrintDlgW( LPPRINTDLGW lppd ); BOOL PtInRect( RECT *lprc, // rectangle POINT pt // point ); BOOL PtInRegion( HRGN hrgn, // handle to region int X, // x-coordinate of point int Y // y-coordinate of point ); UINT RealizePalette( HDC hdc // handle of device context ); BOOL RectInRegion( HRGN hrgn, // handle to region RECT *lprc // pointer to rectangle ); BOOL Rectangle( HDC hdc, // handle to device context int nLeftRect, // x-coord of bounding rectangle's upper-left corner int nTopRect, // y-coord of bounding rectangle's upper-left corner int nRightRect, // x-coord of bounding rectangle's lower-right corner int nBottomRect // y-coord of bounding rectangle's lower-right corner ); //alias STDWIN.RedrawWindow RedrawWindow; LONG RegCloseKey( HKEY hKey ); LONG RegEnumKeyExA( HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcName, LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcClass, PFILETIME lpftLastWriteTime ); LONG RegEnumKeyExW( HKEY hKey, DWORD dwIndex, LPWSTR lpName, LPDWORD lpcName, LPDWORD lpReserved, LPWSTR lpClass, LPDWORD lpcClass, PFILETIME lpftLastWriteTime ); LONG RegOpenKeyExA( HKEY hKey, LPSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult ); LONG RegOpenKeyExW( HKEY hKey, LPWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult ); LONG RegQueryInfoKeyA( HKEY hKey, LPSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime ); LONG RegQueryInfoKeyW( HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime ); LONG RegQueryValueExA( HKEY hKey, LPCSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData ); LONG RegQueryValueExW( HKEY hKey, LPCWSTR lpValueName, LPDWORD lpReserved, LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData ); ATOM RegisterClassA( WNDCLASSA *lpWndClass ); ATOM RegisterClassW( WNDCLASSW *lpWndClass ); UINT RegisterClipboardFormatA( LPCSTR lpszFormat ); UINT RegisterClipboardFormatW( LPCWSTR lpszFormat ); UINT RegisterWindowMessageA( LPCSTR lpString ); UINT RegisterWindowMessageW( LPCWSTR lpString ); BOOL ReleaseCapture(); BOOL RemoveMenu( HMENU hMenu, UINT uPosition, UINT uFlags ); BOOL RestoreDC( HDC hdc, // handle to DC int nSavedDC // restore state ); //alias STDWIN.RoundRect RoundRect; // basic void RtlMoveMemory(void* Destination, void* Source, DWORD Length); // extends void RtlMoveMemory(int Destination, void* Source, DWORD Length); void RtlMoveMemory(void* Destination, int Source, DWORD Length); void RtlMoveMemory(int Destination, int Source, DWORD Length); LPITEMIDLIST SHBrowseForFolderA( BROWSEINFOA* lpbi ); LPITEMIDLIST SHBrowseForFolderW( BROWSEINFOW* lpbi ); version(WinCE){ int SHCreateMenuBar(SHMENUBARINFO* pmb); } HRESULT SHGetMalloc( // LPMALLOC *ppMalloc LPVOID *ppMalloc ); BOOL SHGetPathFromIDListA( LPCITEMIDLIST pidl, LPSTR pszPath ); BOOL SHGetPathFromIDListW( LPCITEMIDLIST pidl, LPWSTR pszPath ); version(WinCE) { int SHHandleWMSettingChange(HWND hwnd, int wParam, int lParam, void* psai); int SHRecognizeGesture(void* shrg); void SHSendBackToFocusWindow(int uMsg, int wp, int lp); int SHSetAppKeyWndAssoc(byte bVk, HWND hwnd); int SHSipPreference(HWND hwnd, int st); } // USP methods (Unicode Complex Script processor) HRESULT ScriptBreak( WCHAR *pwcChars, int cChars, SCRIPT_ANALYSIS *psa, SCRIPT_LOGATTR *psla ); HRESULT ScriptCPtoX( int iCP, BOOL fTrailing, int cChars, int cGlyphs, WORD *pwLogClust, SCRIPT_VISATTR *psva, int *piAdvance, SCRIPT_ANALYSIS *psa, int *piX ); HRESULT ScriptCacheGetHeight( HDC hdc, SCRIPT_CACHE *psc, long *tmHeight ); HRESULT ScriptFreeCache( SCRIPT_CACHE *psc ); HRESULT ScriptGetFontProperties( HDC hdc, SCRIPT_CACHE *psc, SCRIPT_FONTPROPERTIES *sfp ); HRESULT ScriptGetLogicalWidths( SCRIPT_ANALYSIS *psa, int cChars, int cGlyphs, int *piGlyphWidth, WORD *pwLogClust, SCRIPT_VISATTR *psva, int *piDx ); HRESULT ScriptGetProperties( SCRIPT_PROPERTIES ***ppSp, int *piNumScripts ); HRESULT ScriptItemize( WCHAR *pwcInChars, int cInChars, int cMaxItems, SCRIPT_CONTROL *psControl, SCRIPT_STATE *psState, SCRIPT_ITEM *pItems, int *pcItems ); HRESULT ScriptLayout( int cRuns, BYTE *pbLevel, int *piVisualToLogical, int *piLogicalToVisual ); HRESULT ScriptPlace( HDC hdc, SCRIPT_CACHE *psc, WORD *pwGlyphs, int cGlyphs, SCRIPT_VISATTR *psva, SCRIPT_ANALYSIS *psa, int *piAdvance, GOFFSET *pGoffset, ABC *pABC ); HRESULT ScriptShape( HDC hdc, // in SCRIPT_CACHE *psc, // in/out WCHAR *pwcChars, // int cChars, int cMaxGlyphs, SCRIPT_ANALYSIS *psa, WORD *pwOutGlyphs, WORD *pwLogClust, SCRIPT_VISATTR *psva, int *pcGlyphs ); HRESULT ScriptTextOut( HDC hdc, // const SCRIPT_CACHE *psc, int x, int y, UINT fuOptions, RECT *lprc, // const SCRIPT_ANALYSIS *psa, // const WCHAR *pwcReserved, // const int iReserved, WORD *pwGlyphs, // int cGlyphs, int *piAdvance, // const int *piJustify, // const GOFFSET *pGoffset // const ); HRESULT ScriptXtoCP( int iX, int cChars, int cGlyphs, WORD *pwLogClust, // SCRIPT_VISATTR *psva, // int *piAdvance, // SCRIPT_ANALYSIS *psa, // int *piCP, int *piTrailing ); UINT SendInput( UINT nInputs, LPINPUT pInputs, int cbSize ); // the basic int SendMessageA(HWND hWnd, int msg, int wParam, int lParam ); int SendMessageW(HWND hWnd, int msg, int wParam, int lParam ); int SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, void* lParam ); int SendMessageW(HWND hWnd, UINT Msg, WPARAM wParam, void* lParam ); int SendMessageA(HWND hWnd, UINT Msg, void* wParam, LPARAM lParam ); int SendMessageW(HWND hWnd, UINT Msg, void* wParam, LPARAM lParam ); int SendMessageA(HWND hWnd, UINT Msg, void* wParam, void* lParam ); int SendMessageW(HWND hWnd, UINT Msg, void* wParam, void* lParam ); HWND SetCapture( HWND hWnd ); BOOL SetCaretPos( int X, int Y ); HANDLE SetClipboardData( UINT uFormat, HANDLE hMem ); UINT SetDIBColorTable( HDC hdc, // handle to device context whose DIB is of interest UINT uStartIndex, // color table index of first entry to set UINT cEntries, // number of color table entries to set RGBQUAD *pColors // pointer to array of color table entries ); UINT SetErrorMode( UINT uMode ); BOOL SetEvent( HANDLE hEvent // handle to event object ); void SetLastError( DWORD dwErrCode ); DWORD SetLayout( HDC hdc, // handle to DC DWORD dwLayout // layout options ); BOOL SetMenu( HWND hWnd, HMENU hMenu ); BOOL SetMenuDefaultItem( HMENU hMenu, UINT uItem, UINT fByPos ); BOOL SetMenuInfo( HMENU hmenu, LPCMENUINFO lpcmi ); BOOL SetMenuItemInfoA( HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFOA lpmii ); BOOL SetMenuItemInfoW( HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFOW lpmii ); UINT SetPaletteEntries( HPALETTE hpal, // handle to logical palette UINT iStart, // index of first entry to set UINT cEntries, // number of entries to set PALETTEENTRY *lppe // array of palette entries ); HWND SetParent( HWND hWndChild, HWND hWndNewParent ); // alias STDWIN.SetPixel SetPixel; // alias STDWIN.SetROP2 SetROP2; BOOL SetRect( LPRECT lprc, // rectangle int xLeft, // left side int yTop, // top side int xRight, // right side int yBottom // bottom side ); // alias STDWIN.SetRectRgn SetRectRgn; int SetScrollInfo( HWND hwnd, int fnBar, LPCSCROLLINFO lpsi, BOOL fRedraw ); UINT_PTR SetTimer( HWND hWnd, UINT_PTR nIDEvent, UINT uElapse, TIMERPROC lpTimerFunc ); LONG SetWindowLongA( HWND hWnd, int nIndex, LONG dwNewLong ); LONG SetWindowLongW( HWND hWnd, int nIndex, LONG dwNewLong ); BOOL SetWindowPlacement( HWND hWnd, WINDOWPLACEMENT *lpwndpl ); BOOL SetWindowPos( HWND hWnd, // handle to window HWND hWndInsertAfter, // placement-order handle int X, // horizontal position int Y, // vertical position int cx, // width int cy, // height UINT uFlags // window-positioning flags ); BOOL SetWindowTextA( HWND hWnd, LPCSTR lpString ); BOOL SetWindowTextW( HWND hWnd, LPCWSTR lpString ); HHOOK SetWindowsHookExA( int idHook, // type of hook to install HOOKPROC lpfn, // address of hook procedure HINSTANCE hMod, // handle to application instance DWORD dwThreadId // identity of thread to install hook for ); HHOOK SetWindowsHookExW( int idHook, // type of hook to install HOOKPROC lpfn, // address of hook procedure HINSTANCE hMod, // handle to application instance DWORD dwThreadId // identity of thread to install hook for ); BOOL ShellExecuteExA( LPSHELLEXECUTEINFOA lpExecInfo ); BOOL ShellExecuteExW( LPSHELLEXECUTEINFOW lpExecInfo ); BOOL Shell_NotifyIconA( DWORD dwMessage, PNOTIFYICONDATAA lpdata ); BOOL Shell_NotifyIconW( DWORD dwMessage, PNOTIFYICONDATAW lpdata ); BOOL ShowOwnedPopups( HWND hWnd, BOOL fShow ); version(WinCE) { BOOL SipGetInfo( SIPINFO *pSipInfo ); } DWORD SizeofResource( HMODULE hModule, // resource-module handle HRSRC hResInfo // resource handle ); void Sleep( DWORD dwMilliseconds ); int StartDocA( HDC hdc, // handle to DC DOCINFOA* lpdi // contains file names ); int StartDocW( HDC hdc, // handle to DC DOCINFOW* lpdi // contains file names ); int StartPage( HDC hDC // handle to DC ); // alias STDWIN.StretchBlt StretchBlt; BOOL SystemParametersInfoA( UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni ); BOOL SystemParametersInfoW( UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni ); int ToAscii( UINT uVirtKey, UINT uScanCode, PBYTE lpKeyState, LPWORD lpChar, UINT uFlags ); int ToUnicode( UINT wVirtKey, UINT wScanCode, PBYTE lpKeyState, LPWSTR pwszBuff, int cchBuff, UINT wFlags ); BOOL TrackMouseEvent( LPTRACKMOUSEEVENT lpEventTrack // pointer to a TRACKMOUSEEVENT structure ); int TranslateAcceleratorA( HWND hWnd, // handle to destination window HACCEL hAccTable, // handle to accelerator table LPMSG lpMsg // address of structure with message ); int TranslateAcceleratorW( HWND hWnd, // handle to destination window HACCEL hAccTable, // handle to accelerator table LPMSG lpMsg // address of structure with message ); UINT TranslateCharsetInfo( DWORD *lpSrc, LPCHARSETINFO lpCs, DWORD dwFlags ); BOOL TranslateMDISysAccel( HWND hWndClient, LPMSG lpMsg ); BOOL TranslateMessage( MSG *lpMsg // address of structure with message ); version(WinCE) { BOOL TransparentImage( HDC hdcDest, LONG DstX, LONG DstY, LONG DstCx, LONG DstCy, HANDLE hSrc, LONG SrcX, LONG SrcY, LONG SrcCx, LONG SrcCy, COLORREF TransparentColor ); } BOOL UnhookWindowsHookEx( HHOOK hhk // handle to hook procedure to remove ); BOOL UnregisterClassA( LPCSTR lpClassName, // address of class name string HINSTANCE hInstance // handle of application instance ); BOOL UnregisterClassW( LPCWSTR lpClassName, // address of class name string HINSTANCE hInstance // handle of application instance ); SHORT VkKeyScanA(char ch); SHORT VkKeyScanW(wchar ch); BOOL WaitMessage(); } extern (C) { int wcslen(wchar* string); }