Mercurial > projects > dwt-win

comparison dwt/internal/win32/WINAPI.d @ 339:210994f12c4c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixes for dmd 1.041 and tango 0.99.8
author Frank Benoit <benoit@tionex.de>
date Sat, 28 Mar 2009 03:12:07 +0100
parents 240db000bbcd
children
comparison
equal deleted inserted replaced
338:ecb375fd8f95 339:210994f12c4c
8 8
9 public import dwt.internal.win32.WINTYPES; 9 public import dwt.internal.win32.WINTYPES;
10 //import tango_sys_win32.Types; 10 //import tango_sys_win32.Types;
11 //import STDWIN = tango_sys_win32.UserGdi; 11 //import STDWIN = tango_sys_win32.UserGdi;
12 12
13 version(TANGOSVN){ 13 import tango.sys.win32.Types;
14 import tango.sys.win32.Types;
15 }
16 else{ // !TANGOSVN
17
18 extern(Windows)
19 {
20
21 // BOOL GetWindowInfo(HWND, PWINDOWINFO);
22 // BOOL EnumDisplayMonitors(HDC, RECT*, MONITORENUMPROC, LPARAM);
23 // BOOL GetMonitorInfoA(HMONITOR, LPMONITORINFO);
24 // WINBOOL GetBinaryTypeA(LPCSTR, LPDWORD);
25 // DWORD GetShortPathNameA(LPCSTR, LPSTR, DWORD);
26 // LPSTR GetEnvironmentStringsA();
27 // WINBOOL FreeEnvironmentStringsA(LPSTR);
28 // DWORD FormatMessageA(DWORD, LPCVOID, DWORD, DWORD, LPSTR, DWORD, VA_LIST*);
29 // HANDLE CreateMailslotA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
30 // int lstrcmpA(LPCSTR, LPCSTR);
31 // int lstrcmpiA(LPCSTR, LPCSTR);
32 // LPSTR lstrcpynA(LPSTR, LPCSTR, int);
33 // LPSTR lstrcpyA(LPSTR, LPCSTR);
34 // LPSTR lstrcatA(LPSTR, LPCSTR);
35 // int lstrlenA(LPCSTR);
36 // HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES, WINBOOL, LPCSTR);
37 // HANDLE OpenMutexA(DWORD, WINBOOL, LPCSTR);
38 // HANDLE CreateEventA(LPSECURITY_ATTRIBUTES, WINBOOL, WINBOOL, LPCSTR);
39 // HANDLE OpenEventA(DWORD, WINBOOL, LPCSTR);
40 // HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCSTR);
41 // HANDLE OpenSemaphoreA(DWORD, WINBOOL, LPCSTR);
42 // HANDLE CreateFileMappingA(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR);
43 // HANDLE OpenFileMappingA(DWORD, WINBOOL, LPCSTR);
44 // DWORD GetLogicalDriveStringsA(DWORD, LPSTR);
45 HINST LoadLibraryA(LPCSTR);
46 // HINST LoadLibraryExA(LPCSTR, HANDLE, DWORD);
47 // DWORD GetModuleFileNameA(HINST, LPSTR, DWORD);
48 HMODULE GetModuleHandleA(LPCSTR);
49 // void FatalAppExitA(UINT);
50 // LPSTR GetCommandLineA();
51 // DWORD GetEnvironmentVariableA(LPCSTR, LPSTR, DWORD);
52 // WINBOOL SetEnvironmentVariableA(LPCSTR, LPCSTR);
53 // DWORD ExpandEnvironmentStringsA(LPCSTR, LPSTR, DWORD);
54 // void OutputDebugStringA(LPCSTR);
55 // HRSRC FindResourceA(HINST, LPCSTR, LPCSTR);
56 // HRSRC FindResourceExA(HINST, LPCSTR, LPCSTR, ushort);
57 // WINBOOL EnumResourceTypesA(HINST, ENUMRESTYPEPROC, LONG);
58 // WINBOOL EnumResourceNamesA(HINST, LPCSTR, ENUMRESNAMEPROC, LONG);
59 // WINBOOL EnumResourceLanguagesA(HINST, LPCSTR, LPCSTR, ENUMRESLANGPROC, LONG);
60 // HANDLE BeginUpdateResourceA(LPCSTR, WINBOOL);
61 // WINBOOL UpdateResourceA(HANDLE, LPCSTR, LPCSTR, ushort, LPVOID, DWORD);
62 // WINBOOL EndUpdateResourceA(HANDLE, WINBOOL);
63 // ATOM GlobalAddAtomA(LPCSTR);
64 // ATOM GlobalFindAtomA(LPCSTR);
65 // UINT GlobalGetAtomNameA(ATOM, LPSTR, int);
66 // ATOM AddAtomA(LPCSTR);
67 // ATOM FindAtomA(LPCSTR);
68 // UINT GetAtomNameA(ATOM, LPSTR, int);
69 // UINT GetProfileIntA(LPCSTR, LPCSTR, INT);
70 // DWORD GetProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD);
71 // WINBOOL WriteProfileStringA(LPCSTR, LPCSTR, LPCSTR);
72 // DWORD GetProfileSectionA(LPCSTR, LPSTR, DWORD);
73 // WINBOOL WriteProfileSectionA(LPCSTR, LPCSTR);
74 // UINT GetPrivateProfileIntA(LPCSTR, LPCSTR, INT, LPCSTR);
75 // DWORD GetPrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPSTR, DWORD, LPCSTR);
76 // WINBOOL WritePrivateProfileStringA(LPCSTR, LPCSTR, LPCSTR, LPCSTR);
77 // DWORD GetPrivateProfileSectionA(LPCSTR, LPSTR, DWORD, LPCSTR);
78 // WINBOOL WritePrivateProfileSectionA(LPCSTR, LPCSTR, LPCSTR);
79 // UINT GetDriveTypeA(LPCSTR);
80 // UINT GetSystemDirectoryA(LPSTR, UINT);
81 // DWORD GetTempPathA(DWORD, LPSTR);
82 // UINT GetTempFileNameA(LPCSTR, LPCSTR, UINT, LPSTR);
83 // UINT GetWindowsDirectoryA(LPSTR, UINT);
84 // WINBOOL SetCurrentDirectoryA(LPCSTR);
85 // DWORD GetCurrentDirectoryA(DWORD, LPSTR);
86 // WINBOOL GetDiskFreeSpaceA(LPCSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
87 // WINBOOL CreateDirectoryA(LPCSTR, LPSECURITY_ATTRIBUTES);
88 // WINBOOL CreateDirectoryExA(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
89 // WINBOOL RemoveDirectoryA(LPCSTR);
90 // DWORD GetFullPathNameA(LPCSTR, DWORD, LPSTR, LPSTR*);
91 // WINBOOL DefineDosDeviceA(DWORD, LPCSTR, LPCSTR);
92 // DWORD QueryDosDeviceA(LPCSTR, LPSTR, DWORD);
93 HANDLE CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
94 // WINBOOL SetFileAttributesA(LPCSTR, DWORD);
95 // DWORD GetFileAttributesA(LPCSTR);
96 // BOOL GetFileAttributesExA(LPCSTR, DWORD, WIN32_FILE_ATTRIBUTE_DATA*);
97 // DWORD GetCompressedFileSizeA(LPCSTR, LPDWORD);
98 // WINBOOL DeleteFileA(LPCSTR);
99 // DWORD SearchPathA(LPCSTR, LPCSTR, LPCSTR, DWORD, LPSTR, LPSTR);
100 // WINBOOL CopyFileA(LPCSTR, LPCSTR, WINBOOL);
101 // WINBOOL MoveFileA(LPCSTR, LPCSTR);
102 // WINBOOL MoveFileExA(LPCSTR, LPCSTR, DWORD);
103 // HANDLE CreateNamedPipeA(LPCSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
104 // WINBOOL GetNamedPipeHandleStateA(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPSTR, DWORD);
105 // WINBOOL CallNamedPipeA(LPCSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD);
106 // WINBOOL WaitNamedPipeA(LPCSTR, DWORD);
107 // WINBOOL SetVolumeLabelA(LPCSTR, LPCSTR);
108 // WINBOOL GetVolumeInformationA(LPCSTR, LPSTR, DWORD, LPDWORD, LPDWORD, LPDWORD, LPSTR, DWORD);
109 // WINBOOL ClearEventLogA(HANDLE, LPCSTR);
110 // WINBOOL BackupEventLogA(HANDLE, LPCSTR);
111 // HANDLE OpenEventLogA(LPCSTR, LPCSTR);
112 // HANDLE RegisterEventSourceA(LPCSTR, LPCSTR);
113 // HANDLE OpenBackupEventLogA(LPCSTR, LPCSTR);
114 // WINBOOL ReadEventLogA(HANDLE, DWORD, DWORD, LPVOID, DWORD, LPDWORD, LPDWORD);
115 // WINBOOL ReportEventA(HANDLE, ushort, ushort, DWORD, PSID, ushort, DWORD, LPCSTR*, LPVOID);
116 // WINBOOL AccessCheckAndAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, WINBOOL, LPDWORD, LPBOOL, LPBOOL);
117 // WINBOOL ObjectOpenAuditAlarmA(LPCSTR, LPVOID, LPSTR, LPSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, WINBOOL, WINBOOL, LPBOOL);
118 // WINBOOL ObjectPrivilegeAuditAlarmA(LPCSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET, WINBOOL);
119 // WINBOOL ObjectCloseAuditAlarmA(LPCSTR, LPVOID, WINBOOL);
120 // WINBOOL PrivilegedServiceAuditAlarmA(LPCSTR, LPCSTR, HANDLE, PPRIVILEGE_SET, WINBOOL);
121 // WINBOOL SetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
122 // WINBOOL GetFileSecurityA(LPCSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
123 // HANDLE FindFirstChangeNotificationA(LPCSTR, WINBOOL, DWORD);
124 // WINBOOL IsBadStringPtrA(LPCSTR, UINT);
125 // WINBOOL LookupAccountSidA(LPCSTR, PSID, LPSTR, LPDWORD, LPSTR, LPDWORD, PSID_NAME_USE);
126 // WINBOOL LookupAccountNameA(LPCSTR, LPCSTR, PSID, LPDWORD, LPSTR, LPDWORD, PSID_NAME_USE);
127 // WINBOOL LookupPrivilegeValueA(LPCSTR, LPCSTR, PLUID);
128 // WINBOOL LookupPrivilegeNameA(LPCSTR, PLUID, LPSTR, LPDWORD);
129 // WINBOOL LookupPrivilegeDisplayNameA(LPCSTR, LPCSTR, LPSTR, LPDWORD, LPDWORD);
130 // WINBOOL BuildCommDCBA(LPCSTR, LPDCB);
131 // WINBOOL BuildCommDCBAndTimeoutsA(LPCSTR, LPDCB, LPCOMMTIMEOUTS);
132 // WINBOOL CommConfigDialogA(LPCSTR, HWND, LPCOMMCONFIG);
133 // WINBOOL GetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, LPDWORD);
134 // WINBOOL SetDefaultCommConfigA(LPCSTR, LPCOMMCONFIG, DWORD);
135 // WINBOOL GetComputerNameA(LPSTR, LPDWORD);
136 // WINBOOL SetComputerNameA(LPCSTR);
137 // WINBOOL GetUserNameA(LPSTR, LPDWORD);
138 // int wvsprintfA(LPSTR, LPCSTR, VA_LIST*);
139 // HKL LoadKeyboardLayoutA(LPCSTR, UINT);
140 // WINBOOL GetKeyboardLayoutNameA(LPSTR);
141 // HDESK CreateDesktopA(LPSTR, LPSTR, LPDEVMODE, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
142 // HDESK OpenDesktopA(LPSTR, DWORD, WINBOOL, DWORD);
143 // WINBOOL EnumDesktopsA(HWINSTA, DESKTOPENUMPROC, LPARAM);
144 // HWINSTA CreateWindowStationA(LPSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
145 // HWINSTA OpenWindowStationA(LPSTR, WINBOOL, DWORD);
146 // WINBOOL EnumWindowStationsA(ENUMWINDOWSTATIONPROC, LPARAM);
147 // WINBOOL GetUserObjectInformationA(HANDLE, int, PVOID, DWORD, LPDWORD);
148 // WINBOOL SetUserObjectInformationA(HANDLE, int, PVOID, DWORD);
149 // UINT RegisterWindowMessageA(LPCSTR);
150 WINBOOL GetMessageA(LPMSG, HWND, UINT, UINT);
151 // LONG DispatchMessageA(LPMSG);
152 WINBOOL PeekMessageA(LPMSG, HWND, UINT, UINT, UINT);
153 // LRESULT SendMessageA(HWND, UINT, WPARAM, LPARAM);
154 // LRESULT SendMessageTimeoutA(HWND, UINT, WPARAM, LPARAM, UINT, UINT, LPDWORD);
155 // WINBOOL SendNotifyMessageA(HWND, UINT, WPARAM, LPARAM);
156 // WINBOOL SendMessageCallbackA(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, DWORD);
157 // WINBOOL PostMessageA(HWND, UINT, WPARAM, LPARAM);
158 // WINBOOL PostThreadMessageA(DWORD, UINT, WPARAM, LPARAM);
159 LRESULT DefWindowProcA(HWND, UINT, WPARAM, LPARAM);
160 // LRESULT CallWindowProcA(WNDPROC, HWND, UINT, WPARAM, LPARAM);
161 // ATOM RegisterClassA(LPWNDCLASSA);
162 // WINBOOL UnregisterClassA(LPCSTR, HINST);
163 // WINBOOL GetClassInfoA(HINST, LPCSTR, LPWNDCLASS);
164 // ATOM RegisterClassExA(LPWNDCLASSEX);
165 // WINBOOL GetClassInfoExA(HINST, LPCSTR, LPWNDCLASSEX);
166 HWND CreateWindowExA(DWORD, LPCSTR, LPCSTR, DWORD, int, int, int, int, HWND, HMENU, HINST, LPVOID);
167 // HWND CreateDialogParamA(HINST, LPCSTR, HWND, DLGPROC, LPARAM);
168 // HWND CreateDialogIndirectParamA(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
169 // int DialogBoxParamA(HINST, LPCSTR, HWND, DLGPROC, LPARAM);
170 // int DialogBoxIndirectParamA(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
171 // WINBOOL SetDlgItemTextA(HWND, int, LPCSTR);
172 // UINT GetDlgItemTextA(HWND, int, LPSTR, int);
173 // LONG SendDlgItemMessageA(HWND, int, UINT, WPARAM, LPARAM);
174 // LRESULT DefDlgProcA(HWND, UINT, WPARAM, LPARAM);
175 // WINBOOL CallMsgFilterA(LPMSG, int);
176 // UINT RegisterClipboardFormatA(LPCSTR);
177 // int GetClipboardFormatNameA(UINT, LPSTR, int);
178 // WINBOOL CharToOemA(LPCSTR, LPSTR);
179 // WINBOOL OemToCharA(LPCSTR, LPSTR);
180 // WINBOOL CharToOemBuffA(LPCSTR, LPSTR, DWORD);
181 // WINBOOL OemToCharBuffA(LPCSTR, LPSTR, DWORD);
182 // LPSTR CharUpperA(LPSTR);
183 // DWORD CharUpperBuffA(LPSTR, DWORD);
184 // LPSTR CharLowerA(LPSTR);
185 // DWORD CharLowerBuffA(LPSTR, DWORD);
186 // LPSTR CharNextA(LPCSTR);
187 // LPSTR CharPrevA(LPCSTR, LPCSTR);
188 // WINBOOL IsCharAlphaA(char);
189 // WINBOOL IsCharAlphaNumericA(char);
190 // WINBOOL IsCharUpperA(char);
191 // WINBOOL IsCharLowerA(char);
192 // int GetKeyNameTextA(LONG, LPSTR, int);
193 // SHORT VkKeyScanA(char);
194 // SHORT VkKeyScanExA(char, HKL);
195 // UINT MapVirtualKeyA(UINT, UINT);
196 // UINT MapVirtualKeyExA(UINT, UINT, HKL);
197 // HACCEL LoadAcceleratorsA(HINST, LPCSTR);
198 // HACCEL CreateAcceleratorTableA(LPACCEL, int);
199 // int CopyAcceleratorTableA(HACCEL, LPACCEL, int);
200 // int TranslateAcceleratorA(HWND, HACCEL, LPMSG);
201 // HMENU LoadMenuA(HINST, LPCSTR);
202 // HMENU LoadMenuIndirectA(LPMENUTEMPLATE);
203 // WINBOOL ChangeMenuA(HMENU, UINT, LPCSTR, UINT, UINT);
204 // int GetMenuStringA(HMENU, UINT, LPSTR, int, UINT);
205 // WINBOOL InsertMenuA(HMENU, UINT, UINT, UINT, LPCSTR);
206 // WINBOOL AppendMenuA(HMENU, UINT, UINT, LPCSTR);
207 // WINBOOL ModifyMenuA(HMENU, UINT, UINT, UINT, LPCSTR);
208 // WINBOOL InsertMenuItemA(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
209 // WINBOOL GetMenuItemInfoA(HMENU, UINT, WINBOOL, LPMENUITEMINFO);
210 // WINBOOL SetMenuItemInfoA(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
211 // int DrawTextA(HDC, LPCSTR, int, LPRECT, UINT);
212 // int DrawTextExA(HDC, LPSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS);
213 // WINBOOL GrayStringA(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int);
214 // WINBOOL DrawStateA(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int, UINT);
215 // LONG TabbedTextOutA(HDC, int, int, LPCSTR, int, int, LPINT, int);
216 // DWORD GetTabbedTextExtentA(HDC, LPCSTR, int, int, LPINT);
217 // WINBOOL SetPropA(HWND, LPCSTR, HANDLE);
218 // HANDLE GetPropA(HWND, LPCSTR);
219 // HANDLE RemovePropA(HWND, LPCSTR);
220 // int EnumPropsExA(HWND, PROPENUMPROCEX, LPARAM);
221 // int EnumPropsA(HWND, PROPENUMPROC);
222 // WINBOOL SetWindowTextA(HWND, LPCSTR);
223 // int GetWindowTextA(HWND, LPSTR, int);
224 // int GetWindowTextLengthA(HWND);
225 int MessageBoxA(HWND, LPCSTR, LPCSTR, UINT);
226 // int MessageBoxExA(HWND, LPCSTR, LPCSTR, UINT, ushort);
227 // int MessageBoxIndirectA(LPMSGBOXPARAMS);
228 // LONG GetWindowLongA(HWND, int);
229 // LONG SetWindowLongA(HWND, int, LONG);
230 // DWORD GetClassLongA(HWND, int);
231 // DWORD SetClassLongA(HWND, int, LONG);
232 // HWND FindWindowA(LPCSTR, LPCSTR);
233 // HWND FindWindowExA(HWND, HWND, LPCSTR, LPCSTR);
234 // int GetClassNameA(HWND, LPSTR, int);
235 // HHOOK SetWindowsHookExA(int, HOOKPROC, HINST, DWORD);
236 // HBITMAP LoadBitmapA(HINST, LPCSTR);
237 HCURSOR LoadCursorA(HINST, LPCSTR);
238 // HCURSOR LoadCursorFromFileA(LPCSTR);
239 HICON LoadIconA(HINST, LPCSTR);
240 // HANDLE LoadImageA(HINST, LPCSTR, UINT, int, int, UINT);
241 // int LoadStringA(HINST, UINT, LPSTR, int);
242 // WINBOOL IsDialogMessageA(HWND, LPMSG);
243 // int DlgDirListA(HWND, LPSTR, int, int, UINT);
244 // WINBOOL DlgDirSelectExA(HWND, LPSTR, int, int);
245 // int DlgDirListComboBoxA(HWND, LPSTR, int, int, UINT);
246 // WINBOOL DlgDirSelectComboBoxExA(HWND, LPSTR, int, int);
247 // LRESULT DefFrameProcA(HWND, HWND, UINT, WPARAM, LPARAM);
248 // LRESULT DefMDIChildProcA(HWND, UINT, WPARAM, LPARAM);
249 // HWND CreateMDIWindowA(LPSTR, LPSTR, DWORD, int, int, int, int, HWND, HINST, LPARAM);
250 // WINBOOL WinHelpA(HWND, LPCSTR, UINT, DWORD);
251 // LONG ChangeDisplaySettingsA(LPDEVMODE, DWORD);
252 // WINBOOL EnumDisplaySettingsA(LPCSTR, DWORD, LPDEVMODE);
253 // WINBOOL SystemParametersInfoA(UINT, UINT, PVOID, UINT);
254 // int AddFontResourceA(LPCSTR);
255 // HMETAFILE CopyMetaFileA(HMETAFILE, LPCSTR);
256 // HFONT CreateFontIndirectA(LPLOGFONT);
257 // HDC CreateICA(LPCSTR, LPCSTR, LPCSTR, LPDEVMODE);
258 // HDC CreateMetaFileA(LPCSTR);
259 // WINBOOL CreateScalableFontResourceA(DWORD, LPCSTR, LPCSTR, LPCSTR);
260 // int EnumFontFamiliesExA(HDC, LPLOGFONT, FONTENUMEXPROC, LPARAM, DWORD);
261 // int EnumFontFamiliesA(HDC, LPCSTR, FONTENUMPROC, LPARAM);
262 // int EnumFontsA(HDC, LPCSTR, ENUMFONTSPROC, LPARAM);
263 // WINBOOL GetCharWidthA(HDC, UINT, UINT, LPINT);
264 // WINBOOL GetCharWidth32A(HDC, UINT, UINT, LPINT);
265 // WINBOOL GetCharWidthFloatA(HDC, UINT, UINT, PFLOAT);
266 // WINBOOL GetCharABCWidthsA(HDC, UINT, UINT, LPABC);
267 // WINBOOL GetCharABCWidthsFloatA(HDC, UINT, UINT, LPABCFLOAT);
268 // DWORD GetGlyphOutlineA(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID, PMAT2);
269 // HMETAFILE GetMetaFileA(LPCSTR);
270 UINT GetOutlineTextMetricsA(HDC, UINT, LPOUTLINETEXTMETRIC);
271 // WINBOOL GetTextExtentPointA(HDC, LPCSTR, int, LPSIZE);
272 // WINBOOL GetTextExtentPoint32A(HDC, LPCSTR, int, LPSIZE);
273 // WINBOOL GetTextExtentExPointA(HDC, LPCSTR, int, int, LPINT, LPINT, LPSIZE);
274 // DWORD GetCharacterPlacementA(HDC, LPCSTR, int, int, LPGCP_RESULTS, DWORD);
275 // HDC ResetDCA(HDC, LPDEVMODE);
276 // WINBOOL RemoveFontResourceA(LPCSTR);
277 // HENHMETAFILE CopyEnhMetaFileA(HENHMETAFILE, LPCSTR);
278 HDC CreateEnhMetaFileA(HDC, LPCSTR, LPRECT, LPCSTR);
279 // HENHMETAFILE GetEnhMetaFileA(LPCSTR);
280 // UINT GetEnhMetaFileDescriptionA(HENHMETAFILE, UINT, LPSTR);
281 WINBOOL GetTextMetricsA(HDC, LPTEXTMETRIC);
282 // int StartDocA(HDC, PDOCINFO);
283 int GetObjectA(HGDIOBJ, int, LPVOID);
284 // WINBOOL TextOutA(HDC, int, int, LPCSTR, int);
285 // WINBOOL ExtTextOutA(HDC, int, int, UINT, LPRECT, LPCSTR, UINT, LPINT);
286 // WINBOOL PolyTextOutA(HDC, PPOLYTEXT, int);
287 // int GetTextFaceA(HDC, int, LPSTR);
288 // DWORD GetKerningPairsA(HDC, DWORD, LPKERNINGPAIR);
289 // HCOLORSPACE CreateColorSpaceA(LPLOGCOLORSPACE);
290 // WINBOOL GetLogColorSpaceA(HCOLORSPACE, LPLOGCOLORSPACE, DWORD);
291 // WINBOOL GetICMProfileA(HDC, DWORD, LPSTR);
292 // WINBOOL SetICMProfileA(HDC, LPSTR);
293 // WINBOOL UpdateICMRegKeyA(DWORD, DWORD, LPSTR, UINT);
294 // int EnumICMProfilesA(HDC, ICMENUMPROC, LPARAM);
295 // int PropertySheetA(LPCPROPSHEETHEADER);
296 // HIMAGELIST ImageList_LoadImageA(HINST, LPCSTR, int, int, COLORREF, UINT, UINT);
297 // HWND CreateStatusWindowA(LONG, LPCSTR, HWND, UINT);
298 // void DrawStatusTextA(HDC, LPRECT, LPCSTR);
299 // WINBOOL GetOpenFileNameA(LPOPENFILENAME);
300 // WINBOOL GetSaveFileNameA(LPOPENFILENAME);
301 // int GetFileTitleA(LPCSTR, LPSTR, ushort);
302 // WINBOOL ChooseColorA(LPCHOOSECOLOR);
303 // HWND FindTextA(LPFINDREPLACE);
304 // HWND ReplaceTextA(LPFINDREPLACE);
305 // WINBOOL ChooseFontA(LPCHOOSEFONT);
306 WINBOOL PrintDlgA(LPPRINTDLG);
307 // WINBOOL PageSetupDlgA(LPPAGESETUPDLG);
308 // WINBOOL CreateProcessA(LPCSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
309 // void GetStartupInfoA(LPSTARTUPINFO);
310 // HANDLE FindFirstFileA(LPCSTR, LPWIN32_FIND_DATA);
311 // WINBOOL FindNextFileA(HANDLE, LPWIN32_FIND_DATA);
312 // WINBOOL GetVersionExA(LPOSVERSIONINFO);
313 // HDC CreateDCA(LPCSTR, LPCSTR, LPCSTR, PDEVMODE);
314 // DWORD VerInstallFileA(DWORD, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, LPSTR, PUINT);
315 // DWORD GetFileVersionInfoSizeA(LPSTR, LPDWORD);
316 // WINBOOL GetFileVersionInfoA(LPSTR, DWORD, DWORD, LPVOID);
317 // DWORD VerLanguageNameA(DWORD, LPSTR, DWORD);
318 // WINBOOL VerQueryValueA(LPVOID, LPSTR, LPVOID, PUINT);
319 // DWORD VerFindFileA(DWORD, LPSTR, LPSTR, LPSTR, LPSTR, PUINT, LPSTR, PUINT);
320 // LONG RegConnectRegistryA(LPSTR, HKEY, PHKEY);
321 // LONG RegCreateKeyA(HKEY, LPCSTR, PHKEY);
322 // LONG RegCreateKeyExA(HKEY, LPCSTR, DWORD, LPSTR, DWORD, REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD);
323 // LONG RegDeleteKeyA(HKEY, LPCSTR);
324 // LONG RegDeleteValueA(HKEY, LPCSTR);
325 // LONG RegEnumKeyA(HKEY, DWORD, LPSTR, DWORD);
326 // LONG RegEnumKeyExA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPSTR, LPDWORD, PFILETIME);
327 // LONG RegEnumValueA(HKEY, DWORD, LPSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
328 // LONG RegLoadKeyA(HKEY, LPCSTR, LPCSTR);
329 // LONG RegOpenKeyA(HKEY, LPCSTR, PHKEY);
330 // LONG RegOpenKeyExA(HKEY, LPCSTR, DWORD, REGSAM, PHKEY);
331 // LONG RegQueryInfoKeyA(HKEY, LPSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME);
332 // LONG RegQueryValueA(HKEY, LPCSTR, LPSTR, PLONG);
333 // LONG RegQueryMultipleValuesA(HKEY, PVALENT, DWORD, LPSTR, LPDWORD);
334 // LONG RegQueryValueExA(HKEY, LPCSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
335 // LONG RegReplaceKeyA(HKEY, LPCSTR, LPCSTR, LPCSTR);
336 // LONG RegRestoreKeyA(HKEY, LPCSTR, DWORD);
337 // LONG RegSaveKeyA(HKEY, LPCSTR, LPSECURITY_ATTRIBUTES);
338 // LONG RegSetValueA(HKEY, LPCSTR, DWORD, LPCSTR, DWORD);
339 // LONG RegSetValueExA(HKEY, LPCSTR, DWORD, DWORD, LPBYTE, DWORD);
340 // LONG RegUnLoadKeyA(HKEY, LPCSTR);
341 // WINBOOL InitiateSystemShutdownA(LPSTR, LPSTR, DWORD, WINBOOL, WINBOOL);
342 // WINBOOL AbortSystemShutdownA(LPSTR);
343 // int CompareStringA(LCID, DWORD, LPCSTR, int, LPCSTR, int);
344 // int LCMapStringA(LCID, DWORD, LPCSTR, int, LPSTR, int);
345 // int GetLocaleInfoA(LCID, LCTYPE, LPSTR, int);
346 // WINBOOL SetLocaleInfoA(LCID, LCTYPE, LPCSTR);
347 int GetTimeFormatA(LCID, DWORD, LPSYSTEMTIME, LPCSTR, LPSTR, int);
348 int GetDateFormatA(LCID, DWORD, LPSYSTEMTIME, LPCSTR, LPSTR, int);
349 // int GetNumberFormatA(LCID, DWORD, LPCSTR, PNUMBERFMT, LPSTR, int);
350 // int GetCurrencyFormatA(LCID, DWORD, LPCSTR, PCURRENCYFMT, LPSTR, int);
351 // WINBOOL EnumCalendarInfoA(CALINFO_ENUMPROC, LCID, CALID, CALTYPE);
352 // WINBOOL EnumTimeFormatsA(TIMEFMT_ENUMPROC, LCID, DWORD);
353 // WINBOOL EnumDateFormatsA(DATEFMT_ENUMPROC, LCID, DWORD);
354 // WINBOOL GetStringTypeExA(LCID, DWORD, LPCSTR, int, LPWORD);
355 // WINBOOL GetStringTypeA(LCID, DWORD, LPCSTR, int, LPWORD);
356 // int FoldStringA(DWORD, LPCSTR, int, LPSTR, int);
357 // WINBOOL EnumSystemLocalesA(LOCALE_ENUMPROC, DWORD);
358 // WINBOOL EnumSystemCodePagesA(CODEPAGE_ENUMPROC, DWORD);
359 // WINBOOL PeekConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
360 // WINBOOL ReadConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
361 // WINBOOL WriteConsoleInputA(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
362 // WINBOOL ReadConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
363 // WINBOOL WriteConsoleOutputA(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
364 // WINBOOL ReadConsoleOutputCharacterA(HANDLE, LPSTR, DWORD, COORD, LPDWORD);
365 // WINBOOL WriteConsoleOutputCharacterA(HANDLE, LPCSTR, DWORD, COORD, LPDWORD);
366 // WINBOOL FillConsoleOutputCharacterA(HANDLE, char, DWORD, COORD, LPDWORD);
367 // WINBOOL ScrollConsoleScreenBufferA(HANDLE, PSMALL_RECT, PSMALL_RECT, COORD, PCHAR_INFO);
368 // DWORD GetConsoleTitleA(LPSTR, DWORD);
369 // WINBOOL SetConsoleTitleA(LPCSTR);
370 // WINBOOL ReadConsoleA(HANDLE, LPVOID, DWORD, LPDWORD, LPVOID);
371 // WINBOOL WriteConsoleA(HANDLE, POINTER, DWORD, LPDWORD, LPVOID);
372 // DWORD WNetAddConnectionA(LPCSTR, LPCSTR, LPCSTR);
373 // DWORD WNetAddConnection2A(LPNETRESOURCE, LPCSTR, LPCSTR, DWORD);
374 // DWORD WNetAddConnection3A(HWND, LPNETRESOURCE, LPCSTR, LPCSTR, DWORD);
375 // DWORD WNetCancelConnectionA(LPCSTR, WINBOOL);
376 // DWORD WNetCancelConnection2A(LPCSTR, DWORD, WINBOOL);
377 // DWORD WNetGetConnectionA(LPCSTR, LPSTR, LPDWORD);
378 // DWORD WNetUseConnectionA(HWND, LPNETRESOURCE, LPCSTR, LPCSTR, DWORD, LPSTR, LPDWORD, LPDWORD);
379 // DWORD WNetSetConnectionA(LPCSTR, DWORD, LPVOID);
380 // DWORD WNetConnectionDialog1A(LPCONNECTDLGSTRUCT);
381 // DWORD WNetDisconnectDialog1A(LPDISCDLGSTRUCT);
382 // DWORD WNetOpenEnumA(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE);
383 // DWORD WNetEnumResourceA(HANDLE, LPDWORD, LPVOID, LPDWORD);
384 // DWORD WNetGetUniversalNameA(LPCSTR, DWORD, LPVOID, LPDWORD);
385 // DWORD WNetGetUserA(LPCSTR, LPSTR, LPDWORD);
386 // DWORD WNetGetProviderNameA(DWORD, LPSTR, LPDWORD);
387 // DWORD WNetGetNetworkInformationA(LPCSTR, LPNETINFOSTRUCT);
388 // DWORD WNetGetLastErrorA(LPDWORD, LPSTR, DWORD, LPSTR, DWORD);
389 // DWORD MultinetGetConnectionPerformanceA(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT);
390 // WINBOOL ChangeServiceConfigA(SC_HANDLE, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR, LPCSTR);
391 // SC_HANDLE CreateServiceA(SC_HANDLE, LPCSTR, LPCSTR, DWORD, DWORD, DWORD, DWORD, LPCSTR, LPCSTR, LPDWORD, LPCSTR, LPCSTR, LPCSTR);
392 // WINBOOL EnumDependentServicesA(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD);
393 // WINBOOL EnumServicesStatusA(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD, LPDWORD);
394 // WINBOOL GetServiceKeyNameA(SC_HANDLE, LPCSTR, LPSTR, LPDWORD);
395 // WINBOOL GetServiceDisplayNameA(SC_HANDLE, LPCSTR, LPSTR, LPDWORD);
396 // SC_HANDLE OpenSCManagerA(LPCSTR, LPCSTR, DWORD);
397 // SC_HANDLE OpenServiceA(SC_HANDLE, LPCSTR, DWORD);
398 // WINBOOL QueryServiceConfigA(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD);
399 // WINBOOL QueryServiceLockStatusA(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD, LPDWORD);
400 // SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerA(LPCSTR, LPHANDLER_FUNCTION);
401 // WINBOOL StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRY);
402 // WINBOOL StartServiceA(SC_HANDLE, DWORD, LPCSTR);
403 // uint DragQueryFileA(HDROP, uint, PCHAR, uint);
404 // HICON ExtractAssociatedIconA(HINST, PCHAR, LPWORD);
405 // HICON ExtractIconA(HINST, PCHAR, uint);
406 // HINST FindExecutableA(PCHAR, PCHAR, PCHAR);
407 // int ShellAboutA(HWND, PCHAR, PCHAR, HICON);
408 // HINST ShellExecuteA(HWND, PCHAR, PCHAR, PCHAR, PCHAR, int);
409 // HSZ DdeCreateStringHandleA(DWORD, PCHAR, int);
410 // UINT DdeInitializeA(LPDWORD, PFNCALLBACK, DWORD, DWORD);
411 // DWORD DdeQueryStringA(DWORD, HSZ, PCHAR, DWORD, int);
412 // WINBOOL LogonUserA(LPSTR, LPSTR, LPSTR, DWORD, DWORD, PHANDLE);
413 // WINBOOL CreateProcessAsUserA(HANDLE, LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCTSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
414 // WINBOOL GetBinaryTypeW(LPCWSTR, LPDWORD);
415 // DWORD GetShortPathNameW(LPCWSTR, LPWSTR, DWORD);
416 // LPWSTR GetEnvironmentStringsW();
417 // WINBOOL FreeEnvironmentStringsW(LPWSTR);
418 // DWORD FormatMessageW(DWORD, LPCVOID, DWORD, DWORD, LPWSTR, DWORD, VA_LIST*);
419 // HANDLE CreateMailslotW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
420 // int lstrcmpW(LPCWSTR, LPCWSTR);
421 // int lstrcmpiW(LPCWSTR, LPCWSTR);
422 // LPWSTR lstrcpynW(LPWSTR, LPCWSTR, int);
423 // LPWSTR lstrcpyW(LPWSTR, LPCWSTR);
424 // LPWSTR lstrcatW(LPWSTR, LPCWSTR);
425 // int lstrlenW(LPCWSTR);
426 // HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES, WINBOOL, LPCWSTR);
427 // HANDLE OpenMutexW(DWORD, WINBOOL, LPCWSTR);
428 // HANDLE CreateEventW(LPSECURITY_ATTRIBUTES, WINBOOL, WINBOOL, LPCWSTR);
429 // HANDLE OpenEventW(DWORD, WINBOOL, LPCWSTR);
430 // HANDLE CreateSemaphoreW(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCWSTR);
431 // HANDLE OpenSemaphoreW(DWORD, WINBOOL, LPCWSTR);
432 // HANDLE CreateFileMappingW(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCWSTR);
433 // HANDLE OpenFileMappingW(DWORD, WINBOOL, LPCWSTR);
434 // DWORD GetLogicalDriveStringsW(DWORD, LPWSTR);
435 // HINST LoadLibraryW(LPCWSTR);
436 // HINST LoadLibraryExW(LPCWSTR, HANDLE, DWORD);
437 // DWORD GetModuleFileNameW(HINST, LPWSTR, DWORD);
438 // HMODULE GetModuleHandleW(LPCWSTR);
439 // void FatalAppExitW(UINT);
440 // LPWSTR GetCommandLineW();
441 // DWORD GetEnvironmentVariableW(LPCWSTR, LPWSTR, DWORD);
442 // WINBOOL SetEnvironmentVariableW(LPCWSTR, LPCWSTR);
443 // DWORD ExpandEnvironmentStringsW(LPCWSTR, LPWSTR, DWORD);
444 // void OutputDebugStringW(LPCWSTR);
445 // HRSRC FindResourceW(HINST, LPCWSTR, LPCWSTR);
446 // HRSRC FindResourceExW(HINST, LPCWSTR, LPCWSTR, ushort);
447 // WINBOOL EnumResourceTypesW(HINST, ENUMRESTYPEPROC, LONG);
448 // WINBOOL EnumResourceNamesW(HINST, LPCWSTR, ENUMRESNAMEPROC, LONG);
449 // WINBOOL EnumResourceLanguagesW(HINST, LPCWSTR, LPCWSTR, ENUMRESLANGPROC, LONG);
450 // HANDLE BeginUpdateResourceW(LPCWSTR, WINBOOL);
451 // WINBOOL UpdateResourceW(HANDLE, LPCWSTR, LPCWSTR, ushort, LPVOID, DWORD);
452 // WINBOOL EndUpdateResourceW(HANDLE, WINBOOL);
453 ATOM GlobalAddAtomW(LPCWSTR);
454 // ATOM GlobalFindAtomW(LPCWSTR);
455 // UINT GlobalGetAtomNameW(ATOM, LPWSTR, int);
456 // ATOM AddAtomW(LPCWSTR);
457 // ATOM FindAtomW(LPCWSTR);
458 // UINT GetAtomNameW(ATOM, LPWSTR, int);
459 // UINT GetProfileIntW(LPCWSTR, LPCWSTR, INT);
460 // DWORD GetProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD);
461 // WINBOOL WriteProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR);
462 // DWORD GetProfileSectionW(LPCWSTR, LPWSTR, DWORD);
463 // WINBOOL WriteProfileSectionW(LPCWSTR, LPCWSTR);
464 // UINT GetPrivateProfileIntW(LPCWSTR, LPCWSTR, INT, LPCWSTR);
465 // DWORD GetPrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPWSTR, DWORD, LPCWSTR);
466 // WINBOOL WritePrivateProfileStringW(LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
467 // DWORD GetPrivateProfileSectionW(LPCWSTR, LPWSTR, DWORD, LPCWSTR);
468 // WINBOOL WritePrivateProfileSectionW(LPCWSTR, LPCWSTR, LPCWSTR);
469 // UINT GetDriveTypeW(LPCWSTR);
470 // UINT GetSystemDirectoryW(LPWSTR, UINT);
471 // DWORD GetTempPathW(DWORD, LPWSTR);
472 // UINT GetTempFileNameW(LPCWSTR, LPCWSTR, UINT, LPWSTR);
473 // UINT GetWindowsDirectoryW(LPWSTR, UINT);
474 // WINBOOL SetCurrentDirectoryW(LPCWSTR);
475 // DWORD GetCurrentDirectoryW(DWORD, LPWSTR);
476 // WINBOOL GetDiskFreeSpaceW(LPCWSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
477 // WINBOOL CreateDirectoryW(LPCWSTR, LPSECURITY_ATTRIBUTES);
478 // WINBOOL CreateDirectoryExW(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
479 // WINBOOL RemoveDirectoryW(LPCWSTR);
480 // DWORD GetFullPathNameW(LPCWSTR, DWORD, LPWSTR, LPWSTR*);
481 // WINBOOL DefineDosDeviceW(DWORD, LPCWSTR, LPCWSTR);
482 // DWORD QueryDosDeviceW(LPCWSTR, LPWSTR, DWORD);
483 HANDLE CreateFileW(LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE);
484 // WINBOOL SetFileAttributesW(LPCWSTR, DWORD);
485 // DWORD GetFileAttributesW(LPCWSTR);
486 // BOOL GetFileAttributesExW(LPCWSTR, DWORD, WIN32_FILE_ATTRIBUTE_DATA*);
487 // DWORD GetCompressedFileSizeW(LPCWSTR, LPDWORD);
488 WINBOOL DeleteFileW(LPCWSTR);
489 // DWORD SearchPathW(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPWSTR);
490 // WINBOOL CopyFileW(LPCWSTR, LPCWSTR, WINBOOL);
491 // WINBOOL MoveFileW(LPCWSTR, LPCWSTR);
492 // WINBOOL MoveFileExW(LPCWSTR, LPCWSTR, DWORD);
493 // HANDLE CreateNamedPipeW(LPCWSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
494 // WINBOOL GetNamedPipeHandleStateW(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPWSTR, DWORD);
495 // WINBOOL CallNamedPipeW(LPCWSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD);
496 // WINBOOL WaitNamedPipeW(LPCWSTR, DWORD);
497 // WINBOOL SetVolumeLabelW(LPCWSTR, LPCWSTR);
498 // WINBOOL GetVolumeInformationW(LPCWSTR, LPWSTR, DWORD, LPDWORD, LPDWORD, LPDWORD, LPWSTR, DWORD);
499 // WINBOOL ClearEventLogW(HANDLE, LPCWSTR);
500 // WINBOOL BackupEventLogW(HANDLE, LPCWSTR);
501 // HANDLE OpenEventLogW(LPCWSTR, LPCWSTR);
502 // HANDLE RegisterEventSourceW(LPCWSTR, LPCWSTR);
503 // HANDLE OpenBackupEventLogW(LPCWSTR, LPCWSTR);
504 // WINBOOL ReadEventLogW(HANDLE, DWORD, DWORD, LPVOID, DWORD, LPDWORD, LPDWORD);
505 // WINBOOL ReportEventW(HANDLE, ushort, ushort, DWORD, PSID, ushort, DWORD, LPCWSTR*, LPVOID);
506 // WINBOOL AccessCheckAndAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING, WINBOOL, LPDWORD, LPBOOL, LPBOOL);
507 // WINBOOL ObjectOpenAuditAlarmW(LPCWSTR, LPVOID, LPWSTR, LPWSTR, PSECURITY_DESCRIPTOR, HANDLE, DWORD, DWORD, PPRIVILEGE_SET, WINBOOL, WINBOOL, LPBOOL);
508 // WINBOOL ObjectPrivilegeAuditAlarmW(LPCWSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET, WINBOOL);
509 // WINBOOL ObjectCloseAuditAlarmW(LPCWSTR, LPVOID, WINBOOL);
510 // WINBOOL PrivilegedServiceAuditAlarmW(LPCWSTR, LPCWSTR, HANDLE, PPRIVILEGE_SET, WINBOOL);
511 // WINBOOL SetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
512 // WINBOOL GetFileSecurityW(LPCWSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
513 // HANDLE FindFirstChangeNotificationW(LPCWSTR, WINBOOL, DWORD);
514 // WINBOOL IsBadStringPtrW(LPCWSTR, UINT);
515 // WINBOOL LookupAccountSidW(LPCWSTR, PSID, LPWSTR, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE);
516 // WINBOOL LookupAccountNameW(LPCWSTR, LPCWSTR, PSID, LPDWORD, LPWSTR, LPDWORD, PSID_NAME_USE);
517 // WINBOOL LookupPrivilegeValueW(LPCWSTR, LPCWSTR, PLUID);
518 // WINBOOL LookupPrivilegeNameW(LPCWSTR, PLUID, LPWSTR, LPDWORD);
519 // WINBOOL LookupPrivilegeDisplayNameW(LPCWSTR, LPCWSTR, LPWSTR, LPDWORD, LPDWORD);
520 // WINBOOL BuildCommDCBW(LPCWSTR, LPDCB);
521 // WINBOOL BuildCommDCBAndTimeoutsW(LPCWSTR, LPDCB, LPCOMMTIMEOUTS);
522 // WINBOOL CommConfigDialogW(LPCWSTR, HWND, LPCOMMCONFIG);
523 // WINBOOL GetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, LPDWORD);
524 // WINBOOL SetDefaultCommConfigW(LPCWSTR, LPCOMMCONFIG, DWORD);
525 // WINBOOL GetComputerNameW(LPWSTR, LPDWORD);
526 // WINBOOL SetComputerNameW(LPCWSTR);
527 // WINBOOL GetUserNameW(LPWSTR, LPDWORD);
528 // int wvsprintfW(LPWSTR, LPCWSTR, VA_LIST*);
529 // HKL LoadKeyboardLayoutW(LPCWSTR, UINT);
530 // WINBOOL GetKeyboardLayoutNameW(LPWSTR);
531 // HDESK CreateDesktopW(LPWSTR, LPWSTR, LPDEVMODE, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
532 // HDESK OpenDesktopW(LPWSTR, DWORD, WINBOOL, DWORD);
533 // WINBOOL EnumDesktopsW(HWINSTA, DESKTOPENUMPROC, LPARAM);
534 // HWINSTA CreateWindowStationW(LPWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
535 // HWINSTA OpenWindowStationW(LPWSTR, WINBOOL, DWORD);
536 // WINBOOL EnumWindowStationsW(ENUMWINDOWSTATIONPROC, LPARAM);
537 // WINBOOL GetUserObjectInformationW(HANDLE, int, PVOID, DWORD, LPDWORD);
538 // WINBOOL SetUserObjectInformationW(HANDLE, int, PVOID, DWORD);
539 // UINT RegisterWindowMessageW(LPCWSTR);
540 // WINBOOL GetMessageW(LPMSG, HWND, UINT, UINT);
541 // LONG DispatchMessageW(LPMSG);
542 // WINBOOL PeekMessageW(LPMSG, HWND, UINT, UINT, UINT);
543 // LRESULT SendMessageW(HWND, UINT, WPARAM, LPARAM);
544 // LRESULT SendMessageTimeoutW(HWND, UINT, WPARAM, LPARAM, UINT, UINT, LPDWORD);
545 // WINBOOL SendNotifyMessageW(HWND, UINT, WPARAM, LPARAM);
546 // WINBOOL SendMessageCallbackW(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, DWORD);
547 // WINBOOL PostMessageW(HWND, UINT, WPARAM, LPARAM);
548 // WINBOOL PostThreadMessageW(DWORD, UINT, WPARAM, LPARAM);
549 // LRESULT DefWindowProcW(HWND, UINT, WPARAM, LPARAM);
550 // LRESULT CallWindowProcW(WNDPROC, HWND, UINT, WPARAM, LPARAM);
551 // ATOM RegisterClassW(LPWNDCLASSW);
552 // WINBOOL UnregisterClassW(LPCWSTR, HINST);
553 // WINBOOL GetClassInfoW(HINST, LPCWSTR, LPWNDCLASS);
554 // ATOM RegisterClassExW(LPWNDCLASSEX);
555 // WINBOOL GetClassInfoExW(HINST, LPCWSTR, LPWNDCLASSEX);
556 // HWND CreateWindowExW(DWORD, LPCWSTR, LPCWSTR, DWORD, int, int, int, int, HWND, HMENU, HINST, LPVOID);
557 // HWND CreateDialogParamW(HINST, LPCWSTR, HWND, DLGPROC, LPARAM);
558 // HWND CreateDialogIndirectParamW(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
559 // int DialogBoxParamW(HINST, LPCWSTR, HWND, DLGPROC, LPARAM);
560 // int DialogBoxIndirectParamW(HINST, LPCDLGTEMPLATE, HWND, DLGPROC, LPARAM);
561 // WINBOOL SetDlgItemTextW(HWND, int, LPCWSTR);
562 // UINT GetDlgItemTextW(HWND, int, LPWSTR, int);
563 // LONG SendDlgItemMessageW(HWND, int, UINT, WPARAM, LPARAM);
564 // LRESULT DefDlgProcW(HWND, UINT, WPARAM, LPARAM);
565 // WINBOOL CallMsgFilterW(LPMSG, int);
566 // UINT RegisterClipboardFormatW(LPCWSTR);
567 // int GetClipboardFormatNameW(UINT, LPWSTR, int);
568 // WINBOOL CharToOemW(LPCWSTR, LPSTR);
569 // WINBOOL OemToCharW(LPCSTR, LPWSTR);
570 // WINBOOL CharToOemBuffW(LPCWSTR, LPSTR, DWORD);
571 // WINBOOL OemToCharBuffW(LPCSTR, LPWSTR, DWORD);
572 // LPWSTR CharUpperW(LPWSTR);
573 // DWORD CharUpperBuffW(LPWSTR, DWORD);
574 // LPWSTR CharLowerW(LPWSTR);
575 // DWORD CharLowerBuffW(LPWSTR, DWORD);
576 // LPWSTR CharNextW(LPCWSTR);
577 // LPWSTR CharPrevW(LPCWSTR, LPCWSTR);
578 // WINBOOL IsCharAlphaW(WCHAR);
579 // WINBOOL IsCharAlphaNumericW(WCHAR);
580 // WINBOOL IsCharUpperW(WCHAR);
581 // WINBOOL IsCharLowerW(WCHAR);
582 // int GetKeyNameTextW(LONG, LPWSTR, int);
583 // SHORT VkKeyScanW(WCHAR);
584 // SHORT VkKeyScanExW(WCHAR, HKL);
585 // UINT MapVirtualKeyW(UINT, UINT);
586 // UINT MapVirtualKeyExW(UINT, UINT, HKL);
587 // HACCEL LoadAcceleratorsW(HINST, LPCWSTR);
588 // HACCEL CreateAcceleratorTableW(LPACCEL, int);
589 // int CopyAcceleratorTableW(HACCEL, LPACCEL, int);
590 // int TranslateAcceleratorW(HWND, HACCEL, LPMSG);
591 // HMENU LoadMenuW(HINST, LPCWSTR);
592 // HMENU LoadMenuIndirectW(LPMENUTEMPLATE);
593 // WINBOOL ChangeMenuW(HMENU, UINT, LPCWSTR, UINT, UINT);
594 // int GetMenuStringW(HMENU, UINT, LPWSTR, int, UINT);
595 // WINBOOL InsertMenuW(HMENU, UINT, UINT, UINT, LPCWSTR);
596 // WINBOOL AppendMenuW(HMENU, UINT, UINT, LPCWSTR);
597 // WINBOOL ModifyMenuW(HMENU, UINT, UINT, UINT, LPCWSTR);
598 // WINBOOL InsertMenuItemW(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
599 // WINBOOL GetMenuItemInfoW(HMENU, UINT, WINBOOL, LPMENUITEMINFO);
600 // WINBOOL SetMenuItemInfoW(HMENU, UINT, WINBOOL, LPCMENUITEMINFO);
601 // int DrawTextW(HDC, LPCWSTR, int, LPRECT, UINT);
602 // int DrawTextExW(HDC, LPWSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS);
603 // WINBOOL GrayStringW(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int);
604 // WINBOOL DrawStateW(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int, UINT);
605 // LONG TabbedTextOutW(HDC, int, int, LPCWSTR, int, int, LPINT, int);
606 // DWORD GetTabbedTextExtentW(HDC, LPCWSTR, int, int, LPINT);
607 WINBOOL SetPropW(HWND, LPCWSTR, HANDLE);
608 HANDLE GetPropW(HWND, LPCWSTR);
609 HANDLE RemovePropW(HWND, LPCWSTR);
610 // int EnumPropsExW(HWND, PROPENUMPROCEX, LPARAM);
611 // int EnumPropsW(HWND, PROPENUMPROC);
612 // WINBOOL SetWindowTextW(HWND, LPCWSTR);
613 // int GetWindowTextW(HWND, LPWSTR, int);
614 // int GetWindowTextLengthW(HWND);
615 // int MessageBoxW(HWND, LPCWSTR, LPCWSTR, UINT);
616 // int MessageBoxExW(HWND, LPCWSTR, LPCWSTR, UINT, ushort);
617 // int MessageBoxIndirectW(LPMSGBOXPARAMS);
618 // LONG GetWindowLongW(HWND, int);
619 // LONG SetWindowLongW(HWND, int, LONG);
620 // DWORD GetClassLongW(HWND, int);
621 // DWORD SetClassLongW(HWND, int, LONG);
622 // HWND FindWindowW(LPCWSTR, LPCWSTR);
623 // HWND FindWindowExW(HWND, HWND, LPCWSTR, LPCWSTR);
624 int GetClassNameW(HWND, LPWSTR, int);
625 // HHOOK SetWindowsHookExW(int, HOOKPROC, HINST, DWORD);
626 // HBITMAP LoadBitmapW(HINST, LPCWSTR);
627 HCURSOR LoadCursorW(HINST, LPCWSTR);
628 // HCURSOR LoadCursorFromFileW(LPCWSTR);
629 HICON LoadIconW(HINST, LPCWSTR);
630 // HANDLE LoadImageW(HINST, LPCWSTR, UINT, int, int, UINT);
631 // int LoadStringW(HINST, UINT, LPWSTR, int);
632 // WINBOOL IsDialogMessageW(HWND, LPMSG);
633 // int DlgDirListW(HWND, LPWSTR, int, int, UINT);
634 // WINBOOL DlgDirSelectExW(HWND, LPWSTR, int, int);
635 // int DlgDirListComboBoxW(HWND, LPWSTR, int, int, UINT);
636 // WINBOOL DlgDirSelectComboBoxExW(HWND, LPWSTR, int, int);
637 // LRESULT DefFrameProcW(HWND, HWND, UINT, WPARAM, LPARAM);
638 // LRESULT DefMDIChildProcW(HWND, UINT, WPARAM, LPARAM);
639 // HWND CreateMDIWindowW(LPWSTR, LPWSTR, DWORD, int, int, int, int, HWND, HINST, LPARAM);
640 // WINBOOL WinHelpW(HWND, LPCWSTR, UINT, DWORD);
641 // LONG ChangeDisplaySettingsW(LPDEVMODE, DWORD);
642 // WINBOOL EnumDisplaySettingsW(LPCWSTR, DWORD, LPDEVMODE);
643 // WINBOOL SystemParametersInfoW(UINT, UINT, PVOID, UINT);
644 // int AddFontResourceW(LPCWSTR);
645 // HMETAFILE CopyMetaFileW(HMETAFILE, LPCWSTR);
646 // HFONT CreateFontIndirectW(PLOGFONT);
647 // HFONT CreateFontW(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCWSTR);
648 // HDC CreateICW(LPCWSTR, LPCWSTR, LPCWSTR, LPDEVMODE);
649 // HDC CreateMetaFileW(LPCWSTR);
650 // WINBOOL CreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR);
651 // int EnumFontFamiliesExW(HDC, LPLOGFONT, FONTENUMEXPROC, LPARAM, DWORD);
652 // int EnumFontFamiliesW(HDC, LPCWSTR, FONTENUMPROC, LPARAM);
653 // int EnumFontsW(HDC, LPCWSTR, ENUMFONTSPROC, LPARAM);
654 // WINBOOL GetCharWidthW(HDC, UINT, UINT, LPINT);
655 // WINBOOL GetCharWidth32W(HDC, UINT, UINT, LPINT);
656 // WINBOOL GetCharWidthFloatW(HDC, UINT, UINT, PFLOAT);
657 // WINBOOL GetCharABCWidthsW(HDC, UINT, UINT, LPABC);
658 // WINBOOL GetCharABCWidthsFloatW(HDC, UINT, UINT, LPABCFLOAT);
659 // DWORD GetGlyphOutlineW(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID, PMAT2);
660 // HMETAFILE GetMetaFileW(LPCWSTR);
661 UINT GetOutlineTextMetricsW(HDC, UINT, LPOUTLINETEXTMETRIC);
662 // WINBOOL GetTextExtentPointW(HDC, LPCWSTR, int, LPSIZE);
663 // WINBOOL GetTextExtentPoint32W(HDC, LPCWSTR, int, LPSIZE);
664 // WINBOOL GetTextExtentExPointW(HDC, LPCWSTR, int, int, LPINT, LPINT, LPSIZE);
665 // DWORD GetCharacterPlacementW(HDC, LPCWSTR, int, int, LPGCP_RESULTS, DWORD);
666 // HDC ResetDCW(HDC, LPDEVMODE);
667 // WINBOOL RemoveFontResourceW(LPCWSTR);
668 // HENHMETAFILE CopyEnhMetaFileW(HENHMETAFILE, LPCWSTR);
669 HDC CreateEnhMetaFileW(HDC, LPCWSTR, LPRECT, LPCWSTR);
670 // HENHMETAFILE GetEnhMetaFileW(LPCWSTR);
671 // UINT GetEnhMetaFileDescriptionW(HENHMETAFILE, UINT, LPWSTR);
672 // WINBOOL GetTextMetricsW(HDC, LPTEXTMETRIC);
673 // int StartDocW(HDC, PDOCINFO);
674 int GetObjectW(HGDIOBJ, int, LPVOID);
675 // WINBOOL TextOutW(HDC, int, int, LPCWSTR, int);
676 // WINBOOL ExtTextOutW(HDC, int, int, UINT, LPRECT, LPCWSTR, UINT, LPINT);
677 // WINBOOL PolyTextOutW(HDC, PPOLYTEXT, int);
678 // int GetTextFaceW(HDC, int, LPWSTR);
679 // DWORD GetKerningPairsW(HDC, DWORD, LPKERNINGPAIR);
680 // WINBOOL GetLogColorSpaceW(HCOLORSPACE, LPLOGCOLORSPACE, DWORD);
681 // HCOLORSPACE CreateColorSpaceW(LPLOGCOLORSPACE);
682 // WINBOOL GetICMProfileW(HDC, DWORD, LPWSTR);
683 // WINBOOL SetICMProfileW(HDC, LPWSTR);
684 // WINBOOL UpdateICMRegKeyW(DWORD, DWORD, LPWSTR, UINT);
685 // int EnumICMProfilesW(HDC, ICMENUMPROC, LPARAM);
686 // HPROPSHEETPAGE CreatePropertySheetPageW(LPCPROPSHEETPAGE);
687 // int PropertySheetW(LPCPROPSHEETHEADER);
688 // HIMAGELIST ImageList_LoadImageW(HINST, LPCWSTR, int, int, COLORREF, UINT, UINT);
689 // HWND CreateStatusWindowW(LONG, LPCWSTR, HWND, UINT);
690 // void DrawStatusTextW(HDC, LPRECT, LPCWSTR);
691 // WINBOOL GetOpenFileNameW(LPOPENFILENAME);
692 // WINBOOL GetSaveFileNameW(LPOPENFILENAME);
693 // int GetFileTitleW(LPCWSTR, LPWSTR, ushort);
694 // WINBOOL ChooseColorW(LPCHOOSECOLOR);
695 // HWND ReplaceTextW(LPFINDREPLACE);
696 // WINBOOL ChooseFontW(LPCHOOSEFONT);
697 // HWND FindTextW(LPFINDREPLACE);
698 WINBOOL PrintDlgW(LPPRINTDLG);
699 // WINBOOL PageSetupDlgW(LPPAGESETUPDLG);
700 WINBOOL CreateProcessW(LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
701 void GetStartupInfoW(LPSTARTUPINFO);
702 // HANDLE FindFirstFileW(LPCWSTR, LPWIN32_FIND_DATAW);
703 // WINBOOL FindNextFileW(HANDLE, LPWIN32_FIND_DATAW);
704 // WINBOOL GetVersionExW(LPOSVERSIONINFO);
705 // HDC CreateDCW(LPCWSTR, LPCWSTR, LPCWSTR, PDEVMODE);
706 // HFONT CreateFontA(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPCSTR);
707 // DWORD VerInstallFileW(DWORD, LPWSTR, LPWSTR, LPWSTR, LPWSTR, LPWSTR, LPWSTR, PUINT);
708 // DWORD GetFileVersionInfoSizeW(LPWSTR, LPDWORD);
709 // WINBOOL GetFileVersionInfoW(LPWSTR, DWORD, DWORD, LPVOID);
710 // DWORD VerLanguageNameW(DWORD, LPWSTR, DWORD);
711 // WINBOOL VerQueryValueW(LPVOID, LPWSTR, LPVOID, PUINT);
712 // DWORD VerFindFileW(DWORD, LPWSTR, LPWSTR, LPWSTR, LPWSTR, PUINT, LPWSTR, PUINT);
713 // LONG RegSetValueExW(HKEY, LPCWSTR, DWORD, DWORD, LPBYTE, DWORD);
714 // LONG RegUnLoadKeyW(HKEY, LPCWSTR);
715 // WINBOOL InitiateSystemShutdownW(LPWSTR, LPWSTR, DWORD, WINBOOL, WINBOOL);
716 // WINBOOL AbortSystemShutdownW(LPWSTR);
717 // LONG RegRestoreKeyW(HKEY, LPCWSTR, DWORD);
718 // LONG RegSaveKeyW(HKEY, LPCWSTR, LPSECURITY_ATTRIBUTES);
719 // LONG RegSetValueW(HKEY, LPCWSTR, DWORD, LPCWSTR, DWORD);
720 // LONG RegQueryValueW(HKEY, LPCWSTR, LPWSTR, PLONG);
721 // LONG RegQueryMultipleValuesW(HKEY, PVALENT, DWORD, LPWSTR, LPDWORD);
722 // LONG RegQueryValueExW(HKEY, LPCWSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
723 // LONG RegReplaceKeyW(HKEY, LPCWSTR, LPCWSTR, LPCWSTR);
724 // LONG RegConnectRegistryW(LPWSTR, HKEY, PHKEY);
725 // LONG RegCreateKeyW(HKEY, LPCWSTR, PHKEY);
726 // LONG RegCreateKeyExW(HKEY, LPCWSTR, DWORD, LPWSTR, DWORD, REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD);
727 // LONG RegDeleteKeyW(HKEY, LPCWSTR);
728 // LONG RegDeleteValueW(HKEY, LPCWSTR);
729 // LONG RegEnumKeyW(HKEY, DWORD, LPWSTR, DWORD);
730 // LONG RegEnumKeyExW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPWSTR, LPDWORD, PFILETIME);
731 // LONG RegEnumValueW(HKEY, DWORD, LPWSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
732 // LONG RegLoadKeyW(HKEY, LPCWSTR, LPCWSTR);
733 // LONG RegOpenKeyW(HKEY, LPCWSTR, PHKEY);
734 // LONG RegOpenKeyExW(HKEY, LPCWSTR, DWORD, REGSAM, PHKEY);
735 // LONG RegQueryInfoKeyW(HKEY, LPWSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME);
736 // int CompareStringW(LCID, DWORD, LPCWSTR, int, LPCWSTR, int);
737 // int LCMapStringW(LCID, DWORD, LPCWSTR, int, LPWSTR, int);
738 // int GetLocaleInfoW(LCID, LCTYPE, LPWSTR, int);
739 // WINBOOL SetLocaleInfoW(LCID, LCTYPE, LPCWSTR);
740 int GetTimeFormatW(LCID, DWORD, LPSYSTEMTIME, LPCWSTR, LPWSTR, int);
741 int GetDateFormatW(LCID, DWORD, LPSYSTEMTIME, LPCWSTR, LPWSTR, int);
742 // int GetNumberFormatW(LCID, DWORD, LPCWSTR, PNUMBERFMT, LPWSTR, int);
743 // int GetCurrencyFormatW(LCID, DWORD, LPCWSTR, PCURRENCYFMT, LPWSTR, int);
744 // WINBOOL EnumCalendarInfoW(CALINFO_ENUMPROC, LCID, CALID, CALTYPE);
745 // WINBOOL EnumTimeFormatsW(TIMEFMT_ENUMPROC, LCID, DWORD);
746 // WINBOOL EnumDateFormatsW(DATEFMT_ENUMPROC, LCID, DWORD);
747 // WINBOOL GetStringTypeExW(LCID, DWORD, LPCWSTR, int, LPWORD);
748 // WINBOOL GetStringTypeW(DWORD, LPCWSTR, int, LPWORD);
749 // int FoldStringW(DWORD, LPCWSTR, int, LPWSTR, int);
750 // WINBOOL EnumSystemLocalesW(LOCALE_ENUMPROC, DWORD);
751 // WINBOOL EnumSystemCodePagesW(CODEPAGE_ENUMPROC, DWORD);
752 // WINBOOL PeekConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
753 // WINBOOL ReadConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
754 // WINBOOL WriteConsoleInputW(HANDLE, PINPUTRECORD, DWORD, LPDWORD);
755 // WINBOOL ReadConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
756 // WINBOOL WriteConsoleOutputW(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
757 // WINBOOL ReadConsoleOutputCharacterW(HANDLE, LPWSTR, DWORD, COORD, LPDWORD);
758 // WINBOOL WriteConsoleOutputCharacterW(HANDLE, LPCWSTR, DWORD, COORD, LPDWORD);
759 // WINBOOL FillConsoleOutputCharacterW(HANDLE, WCHAR, DWORD, COORD, LPDWORD);
760 // WINBOOL ScrollConsoleScreenBufferW(HANDLE, PSMALL_RECT, PSMALL_RECT, COORD, PCHAR_INFO);
761 // DWORD GetConsoleTitleW(LPWSTR, DWORD);
762 // WINBOOL SetConsoleTitleW(LPCWSTR);
763 // WINBOOL ReadConsoleW(HANDLE, LPVOID, DWORD, LPDWORD, LPVOID);
764 // WINBOOL WriteConsoleW(HANDLE, POINTER, DWORD, LPDWORD, LPVOID);
765 // DWORD WNetAddConnectionW(LPCWSTR, LPCWSTR, LPCWSTR);
766 // DWORD WNetAddConnection2W(LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD);
767 // DWORD WNetAddConnection3W(HWND, LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD);
768 // DWORD WNetCancelConnectionW(LPCWSTR, WINBOOL);
769 // DWORD WNetCancelConnection2W(LPCWSTR, DWORD, WINBOOL);
770 // DWORD WNetGetConnectionW(LPCWSTR, LPWSTR, LPDWORD);
771 // DWORD WNetUseConnectionW(HWND, LPNETRESOURCE, LPCWSTR, LPCWSTR, DWORD, LPWSTR, LPDWORD, LPDWORD);
772 // DWORD WNetSetConnectionW(LPCWSTR, DWORD, LPVOID);
773 // DWORD WNetConnectionDialog1W(LPCONNECTDLGSTRUCT);
774 // DWORD WNetDisconnectDialog1W(LPDISCDLGSTRUCT);
775 // DWORD WNetOpenEnumW(DWORD, DWORD, DWORD, LPNETRESOURCE, LPHANDLE);
776 // DWORD WNetEnumResourceW(HANDLE, LPDWORD, LPVOID, LPDWORD);
777 // DWORD WNetGetUniversalNameW(LPCWSTR, DWORD, LPVOID, LPDWORD);
778 // DWORD WNetGetUserW(LPCWSTR, LPWSTR, LPDWORD);
779 // DWORD WNetGetProviderNameW(DWORD, LPWSTR, LPDWORD);
780 // DWORD WNetGetNetworkInformationW(LPCWSTR, LPNETINFOSTRUCT);
781 // DWORD WNetGetLastErrorW(LPDWORD, LPWSTR, DWORD, LPWSTR, DWORD);
782 // DWORD MultinetGetConnectionPerformanceW(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT);
783 // WINBOOL ChangeServiceConfigW(SC_HANDLE, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR);
784 // SC_HANDLE CreateServiceW(SC_HANDLE, LPCWSTR, LPCWSTR, DWORD, DWORD, DWORD, DWORD, LPCWSTR, LPCWSTR, LPDWORD, LPCWSTR, LPCWSTR, LPCWSTR);
785 // WINBOOL EnumDependentServicesW(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD);
786 // WINBOOL EnumServicesStatusW(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD, LPDWORD, LPDWORD, LPDWORD);
787 // WINBOOL GetServiceKeyNameW(SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD);
788 // WINBOOL GetServiceDisplayNameW(SC_HANDLE, LPCWSTR, LPWSTR, LPDWORD);
789 // SC_HANDLE OpenSCManagerW(LPCWSTR, LPCWSTR, DWORD);
790 // SC_HANDLE OpenServiceW(SC_HANDLE, LPCWSTR, DWORD);
791 // WINBOOL QueryServiceConfigW(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD);
792 // WINBOOL QueryServiceLockStatusW(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD, LPDWORD);
793 // SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerW(LPCWSTR, LPHANDLER_FUNCTION);
794 // WINBOOL StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRY);
795 // WINBOOL StartServiceW(SC_HANDLE, DWORD, LPCWSTR);
796 // uint DragQueryFileW(HDROP, uint, LPCWSTR, uint);
797 // HICON ExtractAssociatedIconW(HINST, LPCWSTR, LPWORD);
798 // HICON ExtractIconW(HINST, LPCWSTR, uint);
799 // HINST FindExecutableW(LPCWSTR, LPCWSTR, LPCWSTR);
800 // int ShellAboutW(HWND, LPCWSTR, LPCWSTR, HICON);
801 // HINST ShellExecuteW(HWND, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, int);
802 // HSZ DdeCreateStringHandleW(DWORD, LPCWSTR, int);
803 // UINT DdeInitializeW(LPDWORD, PFNCALLBACK, DWORD, DWORD);
804 // DWORD DdeQueryStringW(DWORD, HSZ, LPCWSTR, DWORD, int);
805 // WINBOOL LogonUserW(LPWSTR, LPWSTR, LPWSTR, DWORD, DWORD, PHANDLE);
806 // WINBOOL CreateProcessAsUserW(HANDLE, LPCWSTR, LPWSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, WINBOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
807 // WINBOOL AccessCheck(PSECURITY_DESCRIPTOR, HANDLE, DWORD, PGENERIC_MAPPING, PPRIVILEGE_SET, LPDWORD, LPDWORD, LPBOOL);
808 // LONG InterlockedIncrement(LPLONG);
809 // LONG InterlockedDecrement(LPLONG);
810 // LONG InterlockedExchange(LPLONG, LONG);
811 // WINBOOL FreeResource(HGLOBAL);
812 // LPVOID LockResource(HGLOBAL);
813 WINBOOL FreeLibrary(HINST);
814 // void FreeLibraryAndExitThread(HMODULE, DWORD);
815 // WINBOOL DisableThreadLibraryCalls(HMODULE);
816 FARPROC GetProcAddress(HINST, LPCSTR);
817 // DWORD GetVersion();
818 // HGLOBAL GlobalAlloc(UINT, DWORD);
819 // HGLOBAL GlobalReAlloc(HGLOBAL, DWORD, UINT);
820 // DWORD GlobalSize(HGLOBAL);
821 // UINT GlobalFlags(HGLOBAL);
822 // LPVOID GlobalLock(HGLOBAL);
823 // HGLOBAL GlobalHandle(LPCVOID);
824 // WINBOOL GlobalUnlock(HGLOBAL);
825 // HGLOBAL GlobalFree(HGLOBAL);
826 // UINT GlobalCompact(DWORD);
827 // void GlobalFix(HGLOBAL);
828 // void GlobalUnfix(HGLOBAL);
829 // LPVOID GlobalWire(HGLOBAL);
830 // WINBOOL GlobalUnWire(HGLOBAL);
831 // void GlobalMemoryStatus(LPMEMORYSTATUS);
832 // HLOCAL LocalAlloc(UINT, UINT);
833 // HLOCAL LocalReAlloc(HLOCAL, UINT, UINT);
834 // LPVOID LocalLock(HLOCAL);
835 // HLOCAL LocalHandle(LPCVOID);
836 // WINBOOL LocalUnlock(HLOCAL);
837 // UINT LocalSize(HLOCAL);
838 // UINT LocalFlags(HLOCAL);
839 // HLOCAL LocalFree(HLOCAL);
840 // UINT LocalShrink(HLOCAL, UINT);
841 // UINT LocalCompact(UINT);
842 // WINBOOL FlushInstructionCache(HANDLE, LPCVOID, DWORD);
843 // LPVOID VirtualAlloc(LPVOID, DWORD, DWORD, DWORD);
844 // WINBOOL VirtualFree(LPVOID, DWORD, DWORD);
845 // WINBOOL VirtualProtect(LPVOID, DWORD, DWORD, PDWORD);
846 // DWORD VirtualQuery(LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD);
847 // WINBOOL VirtualProtectEx(HANDLE, LPVOID, DWORD, DWORD, PDWORD);
848 // DWORD VirtualQueryEx(HANDLE, LPCVOID, PMEMORY_BASIC_INFORMATION, DWORD);
849 // HANDLE HeapCreate(DWORD, DWORD, DWORD);
850 // WINBOOL HeapDestroy(HANDLE);
851 // LPVOID HeapAlloc(HANDLE, DWORD, DWORD);
852 // LPVOID HeapReAlloc(HANDLE, DWORD, LPVOID, DWORD);
853 // WINBOOL HeapFree(HANDLE, DWORD, LPVOID);
854 // DWORD HeapSize(HANDLE, DWORD, LPCVOID);
855 // WINBOOL HeapValidate(HANDLE, DWORD, LPCVOID);
856 // UINT HeapCompact(HANDLE, DWORD);
857 // HANDLE GetProcessHeap();
858 // DWORD GetProcessHeaps(DWORD, PHANDLE);
859 // WINBOOL HeapLock(HANDLE);
860 // WINBOOL HeapUnlock(HANDLE);
861 // WINBOOL HeapWalk(HANDLE, LPPROCESS_HEAP_ENTRY);
862 // WINBOOL GetProcessAffinityMask(HANDLE, LPDWORD, LPDWORD);
863 // WINBOOL GetProcessTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
864 // WINBOOL GetProcessWorkingSetSize(HANDLE, LPDWORD, LPDWORD);
865 // WINBOOL SetProcessWorkingSetSize(HANDLE, DWORD, DWORD);
866 // HANDLE OpenProcess(DWORD, WINBOOL, DWORD);
867 // HANDLE GetCurrentProcess();
868 // DWORD GetCurrentProcessId();
869 // void ExitProcess(UINT);
870 // WINBOOL TerminateProcess(HANDLE, UINT);
871 // WINBOOL GetExitCodeProcess(HANDLE, LPDWORD);
872 // void FatalExit(int);
873 // void RaiseException(DWORD, DWORD, DWORD);
874 // LONG UnhandledExceptionFilter(EMPTYRECORD*);
875 // HANDLE CreateRemoteThread(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
876 // HANDLE GetCurrentThread();
877 // DWORD GetCurrentThreadId();
878 // DWORD SetThreadAffinityMask(HANDLE, DWORD);
879 // WINBOOL SetThreadPriority(HANDLE, int);
880 // int GetThreadPriority(HANDLE);
881 // WINBOOL GetThreadTimes(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
882 // void ExitThread(DWORD);
883 // WINBOOL TerminateThread(HANDLE, DWORD);
884 // WINBOOL GetExitCodeThread(HANDLE, LPDWORD);
885 // WINBOOL GetThreadSelectorEntry(HANDLE, DWORD, LPLDT_ENTRY);
886 // DWORD GetLastError();
887 // void SetLastError(DWORD);
888 // HANDLE CreateIoCompletionPort(HANDLE, HANDLE, DWORD, DWORD);
889 // UINT SetErrorMode(UINT);
890 // WINBOOL ReadProcessMemory(HANDLE, LPCVOID, LPVOID, DWORD, LPDWORD);
891 // WINBOOL WriteProcessMemory(HANDLE, LPVOID, LPVOID, DWORD, LPDWORD);
892 // WINBOOL GetThreadContext(HANDLE, LPCONTEXT);
893 // DWORD SuspendThread(HANDLE);
894 // DWORD ResumeThread(HANDLE);
895 // void DebugBreak();
896 // WINBOOL WaitForDebugEvent(LPDEBUG_EVENT, DWORD);
897 // WINBOOL ContinueDebugEvent(DWORD, DWORD, DWORD);
898 // WINBOOL DebugActiveProcess(DWORD);
899 // void InitializeCriticalSection(LPCRITICAL_SECTION);
900 // void EnterCriticalSection(LPCRITICAL_SECTION);
901 // WINBOOL TryEnterCriticalSection(LPCRITICAL_SECTION);
902 // void LeaveCriticalSection(LPCRITICAL_SECTION);
903 // void DeleteCriticalSection(LPCRITICAL_SECTION);
904 // WINBOOL SetEvent(HANDLE);
905 // WINBOOL ResetEvent(HANDLE);
906 // WINBOOL PulseEvent(HANDLE);
907 // WINBOOL ReleaseSemaphore(HANDLE, LONG, LPLONG);
908 // WINBOOL ReleaseMutex(HANDLE);
909 DWORD WaitForSingleObject(HANDLE, DWORD);
910 DWORD WaitForMultipleObjects(DWORD, HANDLE*, WINBOOL, DWORD);
911 // void Sleep(DWORD);
912 // HGLOBAL LoadResource(HINST, HRSRC);
913 // DWORD SizeofResource(HINST, HRSRC);
914 // ATOM GlobalDeleteAtom(ATOM);
915 // WINBOOL InitAtomTable(DWORD);
916 // ATOM DeleteAtom(ATOM);
917 // UINT SetHandleCount(UINT);
918 // DWORD GetLogicalDrives();
919 // WINBOOL LockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
920 // WINBOOL UnlockFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
921 // WINBOOL LockFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPOVERLAPPED);
922 // WINBOOL UnlockFileEx(HANDLE, DWORD, DWORD, DWORD, LPOVERLAPPED);
923 // WINBOOL GetFileInformationByHandle(HANDLE, LPBY_HANDLE_FILE_INFORMATION);
924 // DWORD GetFileType(HANDLE);
925 // DWORD GetFileSize(HANDLE, LPDWORD);
926 // HANDLE GetStdHandle(DWORD);
927 // WINBOOL SetStdHandle(DWORD, HANDLE);
928 // WINBOOL FlushFileBuffers(HANDLE);
929 // WINBOOL DeviceIoControl(HANDLE, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
930 // WINBOOL SetEndOfFile(HANDLE);
931 // DWORD SetFilePointer(HANDLE, LONG, PLONG, DWORD);
932 // WINBOOL FindClose(HANDLE);
933 // WINBOOL GetFileTime(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME);
934 // WINBOOL SetFileTime(HANDLE, FILETIME*, FILETIME*, FILETIME*);
935 WINBOOL CloseHandle(HANDLE);
936 // WINBOOL DuplicateHandle(HANDLE, HANDLE, HANDLE, LPHANDLE, DWORD, WINBOOL, DWORD);
937 // WINBOOL GetHandleInformation(HANDLE, LPDWORD);
938 // WINBOOL SetHandleInformation(HANDLE, DWORD, DWORD);
939 // DWORD LoadModule(LPCSTR, LPVOID);
940 // UINT WinExec(LPCSTR, UINT);
941 // WINBOOL ClearCommBreak(HANDLE);
942 // WINBOOL ClearCommError(HANDLE, LPDWORD, LPCOMSTAT);
943 // WINBOOL SetupComm(HANDLE, DWORD, DWORD);
944 // WINBOOL EscapeCommFunction(HANDLE, DWORD);
945 // WINBOOL GetCommConfig(HANDLE, LPCOMMCONFIG, LPDWORD);
946 // WINBOOL GetCommProperties(HANDLE, LPCOMMPROP);
947 // WINBOOL GetCommModemStatus(HANDLE, PDWORD);
948 // WINBOOL GetCommState(HANDLE, PDCB);
949 // WINBOOL GetCommTimeouts(HANDLE, PCOMMTIMEOUTS);
950 // WINBOOL PurgeComm(HANDLE, DWORD);
951 // WINBOOL SetCommBreak(HANDLE);
952 // WINBOOL SetCommConfig(HANDLE, LPCOMMCONFIG, DWORD);
953 // WINBOOL SetCommMask(HANDLE, DWORD);
954 // WINBOOL SetCommState(HANDLE, TDCB*);
955 // WINBOOL SetCommTimeouts(HANDLE, TCOMMTIMEOUTS*);
956 // WINBOOL TransmitCommChar(HANDLE, char);
957 // WINBOOL WaitCommEvent(HANDLE, LPDWORD, LPOVERLAPPED);
958 // DWORD SetTapePosition(HANDLE, DWORD, DWORD, DWORD, DWORD, WINBOOL);
959 // DWORD GetTapePosition(HANDLE, DWORD, LPDWORD, LPDWORD, LPDWORD);
960 // DWORD PrepareTape(HANDLE, DWORD, WINBOOL);
961 // DWORD EraseTape(HANDLE, DWORD, WINBOOL);
962 // DWORD CreateTapePartition(HANDLE, DWORD, DWORD, DWORD);
963 // DWORD WriteTapemark(HANDLE, DWORD, DWORD, WINBOOL);
964 // DWORD GetTapeStatus(HANDLE);
965 // DWORD GetTapeParameters(HANDLE, DWORD, LPDWORD, LPVOID);
966 // DWORD SetTapeParameters(HANDLE, DWORD, LPVOID);
967 // WINBOOL Beep(DWORD, DWORD);
968 // int MulDiv(int, int, int);
969 // void GetSystemTime(LPSYSTEMTIME);
970 // void GetSystemTimeAsFileTime(FILETIME*);
971 // WINBOOL SetSystemTime(SYSTEMTIME*);
972 // void GetLocalTime(LPSYSTEMTIME);
973 // WINBOOL SetLocalTime(SYSTEMTIME*);
974 // void GetSystemInfo(LPSYSTEM_INFO);
975 // WINBOOL SystemTimeToTzSpecificLocalTime(LPTIME_ZONE_INFORMATION, LPSYSTEMTIME, LPSYSTEMTIME);
976 // DWORD GetTimeZoneInformation(LPTIME_ZONE_INFORMATION);
977 // WINBOOL SetTimeZoneInformation(TIME_ZONE_INFORMATION*);
978 // WINBOOL SystemTimeToFileTime(SYSTEMTIME*, LPFILETIME);
979 // WINBOOL FileTimeToLocalFileTime(FILETIME*, LPFILETIME);
980 // WINBOOL LocalFileTimeToFileTime(FILETIME*, LPFILETIME);
981 // WINBOOL FileTimeToSystemTime(FILETIME*, LPSYSTEMTIME);
982 // LONG CompareFileTime(FILETIME*, FILETIME*);
983 // WINBOOL FileTimeToDosDateTime(FILETIME*, LPWORD, LPWORD);
984 // WINBOOL DosDateTimeToFileTime(ushort, ushort, LPFILETIME);
985 // DWORD GetTickCount();
986 // WINBOOL SetSystemTimeAdjustment(DWORD, WINBOOL);
987 // WINBOOL GetSystemTimeAdjustment(PDWORD, PDWORD, PWINBOOL);
988 // WINBOOL CreatePipe(PHANDLE, PHANDLE, LPSECURITY_ATTRIBUTES, DWORD);
989 // WINBOOL ConnectNamedPipe(HANDLE, LPOVERLAPPED);
990 // WINBOOL DisconnectNamedPipe(HANDLE);
991 // WINBOOL SetNamedPipeHandleState(HANDLE, LPDWORD, LPDWORD, LPDWORD);
992 // WINBOOL GetNamedPipeInfo(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
993 // WINBOOL PeekNamedPipe(HANDLE, LPVOID, DWORD, LPDWORD, LPDWORD, LPDWORD);
994 // WINBOOL TransactNamedPipe(HANDLE, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
995 // WINBOOL GetMailslotInfo(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
996 // WINBOOL SetMailslotInfo(HANDLE, DWORD);
997 // LPVOID MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, DWORD);
998 // WINBOOL FlushViewOfFile(LPCVOID, DWORD);
999 // WINBOOL UnmapViewOfFile(LPVOID);
1000 // HFILE OpenFile(LPCSTR, LPOFSTRUCT, UINT);
1001 // HFILE _lopen(LPCSTR, int);
1002 // HFILE _lcreat(LPCSTR, int);
1003 // UINT _lread(HFILE, LPVOID, UINT);
1004 // UINT _lwrite(HFILE, LPCSTR, UINT);
1005 // int _hread(HFILE, LPVOID, int);
1006 // int _hwrite(HFILE, LPCSTR, int);
1007 // HFILE _lclose(HFILE);
1008 // LONG _llseek(HFILE, LONG, int);
1009 // WINBOOL IsTextUnicode(LPVOID, int, LPINT);
1010 // DWORD TlsAlloc();
1011 // LPVOID TlsGetValue(DWORD);
1012 // WINBOOL TlsSetValue(DWORD, LPVOID);
1013 // WINBOOL TlsFree(DWORD);
1014 // DWORD SleepEx(DWORD, WINBOOL);
1015 // DWORD WaitForSingleObjectEx(HANDLE, DWORD, WINBOOL);
1016 // DWORD WaitForMultipleObjectsEx(DWORD, HANDLE*, WINBOOL, DWORD, WINBOOL);
1017 // WINBOOL ReadFileEx(HANDLE, LPVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
1018 // WINBOOL WriteFileEx(HANDLE, LPCVOID, DWORD, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE);
1019 // WINBOOL BackupRead(HANDLE, LPBYTE, DWORD, LPDWORD, WINBOOL, WINBOOL, LPVOID*);
1020 // WINBOOL BackupSeek(HANDLE, DWORD, DWORD, LPDWORD, LPDWORD, LPVOID*);
1021 // WINBOOL BackupWrite(HANDLE, LPBYTE, DWORD, LPDWORD, WINBOOL, WINBOOL, LPVOID*);
1022 // WINBOOL SetProcessShutdownParameters(DWORD, DWORD);
1023 // WINBOOL GetProcessShutdownParameters(LPDWORD, LPDWORD);
1024 // void SetFileApisToOEM();
1025 // void SetFileApisToANSI();
1026 // WINBOOL AreFileApisANSI();
1027 // WINBOOL CloseEventLog(HANDLE);
1028 // WINBOOL DeregisterEventSource(HANDLE);
1029 // WINBOOL NotifyChangeEventLog(HANDLE, HANDLE);
1030 // WINBOOL GetNumberOfEventLogRecords(HANDLE, PDWORD);
1031 // WINBOOL GetOldestEventLogRecord(HANDLE, PDWORD);
1032 // WINBOOL DuplicateToken(HANDLE, SECURITY_IMPERSONATION_LEVEL, PHANDLE);
1033 // WINBOOL GetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
1034 // WINBOOL ImpersonateNamedPipeClient(HANDLE);
1035 // WINBOOL ImpersonateLoggedOnUser(HANDLE);
1036 // WINBOOL ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL);
1037 // WINBOOL RevertToSelf();
1038 // WINBOOL SetThreadToken(PHANDLE, HANDLE);
1039 // WINBOOL OpenProcessToken(HANDLE, DWORD, PHANDLE);
1040 // WINBOOL OpenThreadToken(HANDLE, DWORD, WINBOOL, PHANDLE);
1041 // WINBOOL GetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD, PDWORD);
1042 // WINBOOL SetTokenInformation(HANDLE, TOKEN_INFORMATION_CLASS, LPVOID, DWORD);
1043 // WINBOOL AdjustTokenPrivileges(HANDLE, WINBOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
1044 // WINBOOL AdjustTokenGroups(HANDLE, WINBOOL, PTOKEN_GROUPS, DWORD, PTOKEN_GROUPS, PDWORD);
1045 // WINBOOL PrivilegeCheck(HANDLE, PPRIVILEGE_SET, LPBOOL);
1046 // WINBOOL IsValidSid(PSID);
1047 // WINBOOL EqualSid(PSID, PSID);
1048 // WINBOOL EqualPrefixSid(PSID, PSID);
1049 // DWORD GetSidLengthRequired(UCHAR);
1050 // WINBOOL AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY, ubyte, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, PSID*);
1051 // PVOID FreeSid(PSID);
1052 // WINBOOL InitializeSid(PSID, PSID_IDENTIFIER_AUTHORITY, ubyte);
1053 // PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(PSID);
1054 // PDWORD GetSidSubAuthority(PSID, DWORD);
1055 // PUCHAR GetSidSubAuthorityCount(PSID);
1056 // DWORD GetLengthSid(PSID);
1057 // WINBOOL CopySid(DWORD, PSID, PSID);
1058 // WINBOOL AreAllAccessesGranted(DWORD, DWORD);
1059 // WINBOOL AreAnyAccessesGranted(DWORD, DWORD);
1060 // void MapGenericMask(PDWORD);
1061 // WINBOOL IsValidAcl(PACL);
1062 // WINBOOL InitializeAcl(PACL, DWORD, DWORD);
1063 // WINBOOL GetAclInformation(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS);
1064 // WINBOOL SetAclInformation(PACL, LPVOID, DWORD, ACL_INFORMATION_CLASS);
1065 // WINBOOL AddAce(PACL, DWORD, DWORD, LPVOID, DWORD);
1066 // WINBOOL DeleteAce(PACL, DWORD);
1067 // WINBOOL GetAce(PACL, DWORD, LPVOID*);
1068 // WINBOOL AddAccessAllowedAce(PACL, DWORD, DWORD, PSID);
1069 // WINBOOL AddAccessDeniedAce(PACL, DWORD, DWORD, PSID);
1070 // WINBOOL AddAuditAccessAce(PACL, DWORD, DWORD, PSID, WINBOOL, WINBOOL);
1071 // WINBOOL FindFirstFreeAce(PACL, LPVOID*);
1072 // WINBOOL InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR, DWORD);
1073 // WINBOOL IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR);
1074 // DWORD GetSecurityDescriptorLength(PSECURITY_DESCRIPTOR);
1075 // WINBOOL GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, LPDWORD);
1076 // WINBOOL SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, WINBOOL, PACL, WINBOOL);
1077 // WINBOOL GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
1078 // WINBOOL SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, WINBOOL, PACL, WINBOOL);
1079 // WINBOOL GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR, LPBOOL, PACL*, LPBOOL);
1080 // WINBOOL SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID, WINBOOL);
1081 // WINBOOL GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
1082 // WINBOOL SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID, WINBOOL);
1083 // WINBOOL GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR, PSID*, LPBOOL);
1084 // WINBOOL CreatePrivateObjectSecurity(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, WINBOOL, HANDLE, PGENERIC_MAPPING);
1085 // WINBOOL SetPrivateObjectSecurity(SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR*, PGENERIC_MAPPING, HANDLE);
1086 // WINBOOL GetPrivateObjectSecurity(PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, PDWORD);
1087 // WINBOOL DestroyPrivateObjectSecurity(PSECURITY_DESCRIPTOR);
1088 // WINBOOL MakeSelfRelativeSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD);
1089 // WINBOOL MakeAbsoluteSD(PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR, LPDWORD, PACL, LPDWORD, PACL, LPDWORD, PSID, LPDWORD, PSID, LPDWORD);
1090 // WINBOOL SetKernelObjectSecurity(HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
1091 // WINBOOL FindNextChangeNotification(HANDLE);
1092 // WINBOOL FindCloseChangeNotification(HANDLE);
1093 // WINBOOL VirtualLock(LPVOID, DWORD);
1094 // WINBOOL VirtualUnlock(LPVOID, DWORD);
1095 // LPVOID MapViewOfFileEx(HANDLE, DWORD, DWORD, DWORD, DWORD, LPVOID);
1096 // WINBOOL SetPriorityClass(HANDLE, DWORD);
1097 // DWORD GetPriorityClass(HANDLE);
1098 // WINBOOL IsBadReadPtr(POINTER, UINT);
1099 // WINBOOL IsBadWritePtr(LPVOID, UINT);
1100 // WINBOOL IsBadHugeReadPtr(POINTER, UINT);
1101 // WINBOOL IsBadHugeWritePtr(LPVOID, UINT);
1102 // WINBOOL IsBadCodePtr(FARPROC);
1103 // WINBOOL AllocateLocallyUniqueId(PLUID);
1104 // WINBOOL QueryPerformanceCounter(PLARGE_INTEGER);
1105 // WINBOOL QueryPerformanceFrequency(PLARGE_INTEGER);
1106 // WINBOOL ActivateKeyboardLayout(HKL, UINT);
1107 // WINBOOL UnloadKeyboardLayout(HKL);
1108 // int GetKeyboardLayoutList(int, HKL*);
1109 // HKL GetKeyboardLayout(DWORD);
1110 // HDESK OpenInputDesktop(DWORD, WINBOOL, DWORD);
1111 // WINBOOL EnumDesktopWindows(HDESK, ENUMWINDOWSPROC, LPARAM);
1112 // WINBOOL SwitchDesktop(HDESK);
1113 // WINBOOL SetThreadDesktop(HDESK);
1114 // WINBOOL CloseDesktop(HDESK);
1115 // HDESK GetThreadDesktop(DWORD);
1116 // WINBOOL CloseWindowStation(HWINSTA);
1117 // WINBOOL SetProcessWindowStation(HWINSTA);
1118 // HWINSTA GetProcessWindowStation();
1119 // WINBOOL SetUserObjectSecurity(HANDLE, PSECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
1120 // WINBOOL GetUserObjectSecurity(HANDLE, PSECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
1121 // WINBOOL TranslateMessage(LPMSG);
1122 // WINBOOL SetMessageQueue(int);
1123 // WINBOOL RegisterHotKey(HWND, int, UINT, UINT);
1124 // WINBOOL UnregisterHotKey(HWND, int);
1125 // WINBOOL ExitWindowsEx(UINT, DWORD);
1126 // WINBOOL SwapMouseButton(WINBOOL);
1127 // DWORD GetMessagePos();
1128 // LONG GetMessageTime();
1129 // LONG GetMessageExtraInfo();
1130 // LPARAM SetMessageExtraInfo(LPARAM);
1131 // int BroadcastSystemMessage(DWORD, LPDWORD, UINT, WPARAM, LPARAM);
1132 // WINBOOL AttachThreadInput(DWORD, DWORD, WINBOOL);
1133 // WINBOOL ReplyMessage(LRESULT);
1134 // WINBOOL WaitMessage();
1135 // DWORD WaitForInputIdle(HANDLE, DWORD);
1136 // void PostQuitMessage(int);
1137 // WINBOOL InSendMessage();
1138 // UINT GetDoubleClickTime();
1139 // WINBOOL SetDoubleClickTime(UINT);
1140 // WINBOOL IsWindow(HWND);
1141 // WINBOOL IsMenu(HMENU);
1142 // WINBOOL IsChild(HWND, HWND);
1143 // WINBOOL DestroyWindow(HWND);
1144 WINBOOL ShowWindow(HWND, int);
1145 // WINBOOL ShowWindowAsync(HWND, int);
1146 // WINBOOL FlashWindow(HWND, WINBOOL);
1147 // WINBOOL ShowOwnedPopups(HWND, WINBOOL);
1148 // WINBOOL OpenIcon(HWND);
1149 // WINBOOL CloseWindow(HWND);
1150 // WINBOOL MoveWindow(HWND, int, int, int, int, WINBOOL);
1151 // WINBOOL SetWindowPos(HWND, HWND, int, int, int, int, UINT);
1152 // WINBOOL GetWindowPlacement(HWND, WINDOWPLACEMENT*);
1153 // WINBOOL SetWindowPlacement(HWND, WINDOWPLACEMENT*);
1154 // HDWP BeginDeferWindowPos(int);
1155 // HDWP DeferWindowPos(HDWP, HWND, HWND, int, int, int, int, UINT);
1156 // WINBOOL EndDeferWindowPos(HDWP);
1157 // WINBOOL IsWindowVisible(HWND);
1158 // WINBOOL IsIconic(HWND);
1159 // WINBOOL AnyPopup();
1160 // WINBOOL BringWindowToTop(HWND);
1161 // WINBOOL IsZoomed(HWND);
1162 // WINBOOL EndDialog(HWND, int);
1163 HWND GetDlgItem(HWND, int);
1164 // WINBOOL SetDlgItemInt(HWND, int, UINT, WINBOOL);
1165 // UINT GetDlgItemInt(HWND, int, WINBOOL*, WINBOOL);
1166 // WINBOOL CheckDlgButton(HWND, int, UINT);
1167 // WINBOOL CheckRadioButton(HWND, int, int, int);
1168 // UINT IsDlgButtonChecked(HWND, int);
1169 // HWND GetNextDlgGroupItem(HWND, HWND, WINBOOL);
1170 // HWND GetNextDlgTabItem(HWND, HWND, WINBOOL);
1171 // int GetDlgCtrlID(HWND);
1172 // int GetDialogBaseUnits();
1173 // WINBOOL OpenClipboard(HWND);
1174 // WINBOOL CloseClipboard();
1175 // HWND GetClipboardOwner();
1176 // HWND SetClipboardViewer(HWND);
1177 // HWND GetClipboardViewer();
1178 // WINBOOL ChangeClipboardChain(HWND, HWND);
1179 // HANDLE SetClipboardData(UINT, HANDLE);
1180 // HANDLE GetClipboardData(UINT);
1181 // int CountClipboardFormats();
1182 // UINT EnumClipboardFormats(UINT);
1183 // WINBOOL EmptyClipboard();
1184 // WINBOOL IsClipboardFormatAvailable(UINT);
1185 // int GetPriorityClipboardFormat(UINT*, int);
1186 // HWND GetOpenClipboardWindow();
1187 // LPSTR CharNextExA(ushort, LPCSTR, DWORD);
1188 // LPSTR CharPrevExA(ushort, LPCSTR, LPCSTR, DWORD);
1189 HWND SetFocus(HWND);
1190 // HWND GetActiveWindow();
1191 HWND GetFocus();
1192 // UINT GetKBCodePage();
1193 // SHORT GetKeyState(int);
1194 SHORT GetAsyncKeyState(int);
1195 // WINBOOL GetKeyboardState(PBYTE);
1196 // WINBOOL SetKeyboardState(LPBYTE);
1197 // int GetKeyboardType(int);
1198 // int ToAscii(UINT, UINT, PBYTE, LPWORD, UINT);
1199 // int ToAsciiEx(UINT, UINT, PBYTE, LPWORD, UINT, HKL);
1200 // int ToUnicode(UINT, UINT, PBYTE, LPWSTR, int, UINT);
1201 // DWORD OemKeyScan(ushort);
1202 // void keybd_event(ubyte, ubyte, DWORD);
1203 // void mouse_event(DWORD, DWORD, DWORD, DWORD);
1204 // WINBOOL GetInputState();
1205 // DWORD GetQueueStatus(UINT);
1206 // HWND GetCapture();
1207 // HWND SetCapture(HWND);
1208 // WINBOOL ReleaseCapture();
1209 // DWORD MsgWaitForMultipleObjects(DWORD, LPHANDLE, WINBOOL, DWORD, DWORD);
1210 // UINT SetTimer(HWND, UINT, UINT, TIMERPROC);
1211 // WINBOOL KillTimer(HWND, UINT);
1212 // WINBOOL IsWindowUnicode(HWND);
1213 // WINBOOL EnableWindow(HWND, WINBOOL);
1214 // WINBOOL IsWindowEnabled(HWND);
1215 // WINBOOL DestroyAcceleratorTable(HACCEL);
1216 // int GetSystemMetrics(int);
1217 // HMENU GetMenu(HWND);
1218 // WINBOOL SetMenu(HWND, HMENU);
1219 // WINBOOL HiliteMenuItem(HWND, HMENU, UINT, UINT);
1220 // UINT GetMenuState(HMENU, UINT, UINT);
1221 // WINBOOL DrawMenuBar(HWND);
1222 // HMENU GetSystemMenu(HWND, WINBOOL);
1223 // HMENU CreateMenu();
1224 // HMENU CreatePopupMenu();
1225 // WINBOOL DestroyMenu(HMENU);
1226 // DWORD CheckMenuItem(HMENU, UINT, UINT);
1227 // WINBOOL EnableMenuItem(HMENU, UINT, UINT);
1228 // HMENU GetSubMenu(HMENU, int);
1229 // UINT GetMenuItemID(HMENU, int);
1230 // int GetMenuItemCount(HMENU);
1231 // WINBOOL RemoveMenu(HMENU, UINT, UINT);
1232 // WINBOOL DeleteMenu(HMENU, UINT, UINT);
1233 // WINBOOL SetMenuItemBitmaps(HMENU, UINT, UINT, HBITMAP, HBITMAP);
1234 // LONG GetMenuCheckMarkDimensions();
1235 WINBOOL TrackPopupMenu(HMENU, UINT, int, int, int, HWND, RECT*);
1236 // UINT GetMenuDefaultItem(HMENU, UINT, UINT);
1237 // WINBOOL SetMenuDefaultItem(HMENU, UINT, UINT);
1238 // WINBOOL GetMenuItemRect(HWND, HMENU, UINT, LPRECT);
1239 // int MenuItemFromPoint(HWND, HMENU, POINT);
1240 // DWORD DragObject(HWND, HWND, UINT, DWORD, HCURSOR);
1241 // WINBOOL DragDetect(HWND, POINT);
1242 // WINBOOL DrawIcon(HDC, int, int, HICON);
1243 WINBOOL UpdateWindow(HWND);
1244 HWND SetActiveWindow(HWND);
1245 // HWND GetForegroundWindow();
1246 // WINBOOL PaintDesktop(HDC);
1247 WINBOOL SetForegroundWindow(HWND);
1248 HWND WindowFromDC(HDC);
1249 HDC GetDC(HWND);
1250 HDC GetDCEx(HWND, HRGN, DWORD);
1251 HDC GetWindowDC(HWND);
1252 int ReleaseDC(HWND, HDC);
1253 HDC BeginPaint(HWND, LPPAINTSTRUCT);
1254 WINBOOL EndPaint(HWND, LPPAINTSTRUCT);
1255 WINBOOL GetUpdateRect(HWND, LPRECT, WINBOOL);
1256 int GetUpdateRgn(HWND, HRGN, WINBOOL);
1257 int SetWindowRgn(HWND, HRGN, WINBOOL);
1258 int GetWindowRgn(HWND, HRGN);
1259 // int ExcludeUpdateRgn(HDC, HWND);
1260 WINBOOL InvalidateRect(HWND, RECT*, WINBOOL);
1261 WINBOOL ValidateRect(HWND, RECT*);
1262 WINBOOL InvalidateRgn(HWND, HRGN, WINBOOL);
1263 // WINBOOL ValidateRgn(HWND, HRGN);
1264 WINBOOL RedrawWindow(HWND, RECT*, HRGN, UINT);
1265 // WINBOOL LockWindowUpdate(HWND);
1266 // WINBOOL ScrollWindow(HWND, int, int, RECT*, RECT*);
1267 // WINBOOL ScrollDC(HDC, int, int, RECT*, RECT*, HRGN, LPRECT);
1268 int ScrollWindowEx(HWND, int, int, RECT*, RECT*, HRGN, LPRECT, UINT);
1269 // int SetScrollPos(HWND, int, int, WINBOOL);
1270 // int GetScrollPos(HWND, int);
1271 // WINBOOL SetScrollRange(HWND, int, int, int, WINBOOL);
1272 // WINBOOL GetScrollRange(HWND, int, LPINT, LPINT);
1273 WINBOOL ShowScrollBar(HWND, int, WINBOOL);
1274 WINBOOL EnableScrollBar(HWND, UINT, UINT);
1275 WINBOOL GetClientRect(HWND, LPRECT);
1276 WINBOOL GetWindowRect(HWND, LPRECT);
1277 // WINBOOL AdjustWindowRect(LPRECT, DWORD, WINBOOL);
1278 // WINBOOL AdjustWindowRectEx(LPRECT, DWORD, WINBOOL, DWORD);
1279 // WINBOOL SetWindowContextHelpId(HWND, DWORD);
1280 // DWORD GetWindowContextHelpId(HWND);
1281 // WINBOOL SetMenuContextHelpId(HMENU, DWORD);
1282 // DWORD GetMenuContextHelpId(HMENU);
1283 // WINBOOL MessageBeep(UINT);
1284 // int ShowCursor(WINBOOL);
1285 WINBOOL SetCursorPos(int, int);
1286 HCURSOR SetCursor(HCURSOR);
1287 // WINBOOL GetCursorPos(LPPOINT);
1288 // WINBOOL ClipCursor(RECT*);
1289 // WINBOOL GetClipCursor(LPRECT);
1290 // HCURSOR GetCursor();
1291 WINBOOL CreateCaret(HWND, HBITMAP, int, int);
1292 // UINT GetCaretBlinkTime();
1293 // WINBOOL SetCaretBlinkTime(UINT);
1294 // WINBOOL DestroyCaret();
1295 WINBOOL HideCaret(HWND);
1296 WINBOOL ShowCaret(HWND);
1297 // WINBOOL SetCaretPos(int, int);
1298 // WINBOOL GetCaretPos(LPPOINT);
1299 WINBOOL ClientToScreen(HWND, LPPOINT);
1300 WINBOOL ScreenToClient(HWND, LPPOINT);
1301 int MapWindowPoints(HWND, HWND, LPPOINT, UINT);
1302 HWND WindowFromPoint(POINT);
1303 // HWND ChildWindowFromPoint(HWND, POINT);
1304 // DWORD GetSysColor(int);
1305 // HBRUSH GetSysColorBrush(int);
1306 // WINBOOL SetSysColors(int, WINT*, COLORREF*);
1307 // WINBOOL DrawFocusRect(HDC, RECT*);
1308 int FillRect(HDC, RECT*, HBRUSH);
1309 // int FrameRect(HDC, RECT*, HBRUSH);
1310 // WINBOOL InvertRect(HDC, RECT*);
1311 // WINBOOL SetRect(LPRECT, int, int, int, int);
1312 // WINBOOL SetRectEmpty(LPRECT);
1313 // WINBOOL CopyRect(LPRECT, RECT*);
1314 // WINBOOL InflateRect(LPRECT, int, int);
1315 // WINBOOL IntersectRect(LPRECT, RECT*, RECT*);
1316 // WINBOOL UnionRect(LPRECT, RECT*, RECT*);
1317 // WINBOOL SubtractRect(LPRECT, RECT*, RECT*);
1318 WINBOOL OffsetRect(LPRECT, int, int);
1319 // WINBOOL IsRectEmpty(RECT*);
1320 // WINBOOL EqualRect(RECT*, RECT*);
1321 // WINBOOL PtInRect(RECT*, POINT);
1322 // ushort GetWindowWord(HWND, int);
1323 // ushort SetWindowWord(HWND, int, ushort);
1324 // ushort GetClassWord(HWND, int);
1325 // ushort SetClassWord(HWND, int, ushort);
1326 // HWND GetDesktopWindow();
1327 // HWND GetParent(HWND);
1328 // HWND SetParent(HWND, HWND);
1329 // WINBOOL EnumChildWindows(HWND, ENUMWINDOWSPROC, LPARAM);
1330 // WINBOOL EnumWindows(ENUMWINDOWSPROC, LPARAM);
1331 // WINBOOL EnumThreadWindows(DWORD, ENUMWINDOWSPROC, LPARAM);
1332 // HWND GetTopWindow(HWND);
1333 // DWORD GetWindowThreadProcessId(HWND, LPDWORD);
1334 // HWND GetLastActivePopup(HWND);
1335 // HWND GetWindow(HWND, UINT);
1336 // WINBOOL UnhookWindowsHook(int, HOOKPROC);
1337 // WINBOOL UnhookWindowsHookEx(HHOOK);
1338 // LRESULT CallNextHookEx(HHOOK, int, WPARAM, LPARAM);
1339 // WINBOOL CheckMenuRadioItem(HMENU, UINT, UINT, UINT, UINT);
1340 // HCURSOR CreateCursor(HINST, int, int, int, int, POINTER, POINTER);
1341 // WINBOOL DestroyCursor(HCURSOR);
1342 // WINBOOL SetSystemCursor(HCURSOR, DWORD);
1343 // HICON CreateIcon(HINST, int, int, ubyte, ubyte, ubyte*, ubyte*);
1344 // WINBOOL DestroyIcon(HICON);
1345 // int LookupIconIdFromDirectory(PBYTE, WINBOOL);
1346 // int LookupIconIdFromDirectoryEx(PBYTE, WINBOOL, int, int, UINT);
1347 // HICON CreateIconFromResource(PBYTE, DWORD, WINBOOL, DWORD);
1348 // HICON CreateIconFromResourceEx(PBYTE, DWORD, WINBOOL, DWORD, int, int, UINT);
1349 // HICON CopyImage(HANDLE, UINT, int, int, UINT);
1350 // HICON CreateIconIndirect(PICONINFO);
1351 // HICON CopyIcon(HICON);
1352 // WINBOOL GetIconInfo(HICON, PICONINFO);
1353 // WINBOOL MapDialogRect(HWND, LPRECT);
1354 // int SetScrollInfo(HWND, int, LPCSCROLLINFO, WINBOOL);
1355 // WINBOOL GetScrollInfo(HWND, int, LPSCROLLINFO);
1356 // WINBOOL TranslateMDISysAccel(HWND, LPMSG);
1357 // UINT ArrangeIconicWindows(HWND);
1358 // ushort TileWindows(HWND, UINT, RECT*, UINT, HWND*);
1359 // ushort CascadeWindows(HWND, UINT, RECT*, UINT, HWND*);
1360 // void SetLastErrorEx(DWORD);
1361 // void SetDebugErrorLevel(DWORD);
1362 // WINBOOL DrawEdge(HDC, LPRECT, UINT, UINT);
1363 // WINBOOL DrawFrameControl(HDC, LPRECT, UINT, UINT);
1364 // WINBOOL DrawCaption(HWND, HDC, RECT*, UINT);
1365 // WINBOOL DrawAnimatedRects(HWND, int, RECT*, RECT*);
1366 // WINBOOL TrackPopupMenuEx(HMENU, UINT, int, int, HWND, LPTPMPARAMS);
1367 // HWND ChildWindowFromPointEx(HWND, POINT, UINT);
1368 // WINBOOL DrawIconEx(HDC, int, int, HICON, int, int, UINT, HBRUSH, UINT);
1369 // WINBOOL AnimatePalette(HPALETTE, UINT, UINT, PALETTEENTRY*);
1370 // WINBOOL Arc(HDC, int, int, int, int, int, int, int, int);
1371 // WINBOOL BitBlt(HDC, int, int, int, int, HDC, int, int, DWORD);
1372 // WINBOOL CancelDC(HDC);
1373 // WINBOOL Chord(HDC, int, int, int, int, int, int, int, int);
1374 HMETAFILE CloseMetaFile(HDC);
1375 // int CombineRgn(HRGN, HRGN, HRGN, int);
1376 // HBITMAP CreateBitmap(int, int, UINT, UINT, POINTER);
1377 // HBITMAP CreateBitmapIndirect(BITMAP*);
1378 // HBRUSH CreateBrushIndirect(LOGBRUSH*);
1379 // HBITMAP CreateCompatibleBitmap(HDC, int, int);
1380 // HBITMAP CreateDiscardableBitmap(HDC, int, int);
1381 HDC CreateCompatibleDC(HDC);
1382 // HBITMAP CreateDIBitmap(HDC, BITMAPINFOHEADER*, DWORD, POINTER, BITMAPINFO*, UINT);
1383 // HBRUSH CreateDIBPatternBrush(HGLOBAL, UINT);
1384 // HBRUSH CreateDIBPatternBrushPt(POINTER, UINT);
1385 // HRGN CreateEllipticRgn(int, int, int, int);
1386 // HRGN CreateEllipticRgnIndirect(RECT*);
1387 // HBRUSH CreateHatchBrush(int, COLORREF);
1388 // HPALETTE CreatePalette(LOGPALETTE*);
1389 HPEN CreatePen(int, int, COLORREF);
1390 // HPEN CreatePenIndirect(LOGPEN*);
1391 // HRGN CreatePolyPolygonRgn(POINT*, WINT*, int, int);
1392 // HBRUSH CreatePatternBrush(HBITMAP);
1393 HRGN CreateRectRgn(int, int, int, int);
1394 // HRGN CreateRectRgnIndirect(RECT*);
1395 // HRGN CreateRoundRectRgn(int, int, int, int, int, int);
1396 // HBRUSH CreateSolidBrush(COLORREF);
1397 WINBOOL DeleteDC(HDC);
1398 // WINBOOL DeleteMetaFile(HMETAFILE);
1399 WINBOOL DeleteObject(HGDIOBJ);
1400 // int DrawEscape(HDC, int, int, LPCSTR);
1401 // WINBOOL Ellipse(HDC, int, int, int, int);
1402 // int EnumObjects(HDC, int, ENUMOBJECTSPROC, LPARAM);
1403 // WINBOOL EqualRgn(HRGN, HRGN);
1404 // int Escape(HDC, int, int, LPCSTR, LPVOID);
1405 // int ExtEscape(HDC, int, int, LPCSTR, int, LPSTR);
1406 int ExcludeClipRect(HDC, int, int, int, int);
1407 HRGN ExtCreateRegion(XFORM*, DWORD, RGNDATA*);
1408 // WINBOOL ExtFloodFill(HDC, int, int, COLORREF, UINT);
1409 // WINBOOL FillRgn(HDC, HRGN, HBRUSH);
1410 // WINBOOL FloodFill(HDC, int, int, COLORREF);
1411 // WINBOOL FrameRgn(HDC, HRGN, HBRUSH, int, int);
1412 // int GetROP2(HDC);
1413 // WINBOOL GetAspectRatioFilterEx(HDC, LPSIZE);
1414 // COLORREF GetBkColor(HDC);
1415 // int GetBkMode(HDC);
1416 // LONG GetBitmapBits(HBITMAP, LONG, LPVOID);
1417 // WINBOOL GetBitmapDimensionEx(HBITMAP, LPSIZE);
1418 // UINT GetBoundsRect(HDC, LPRECT, UINT);
1419 // WINBOOL GetBrushOrgEx(HDC, LPPOINT);
1420 int GetClipBox(HDC, LPRECT);
1421 int GetClipRgn(HDC, HRGN);
1422 int GetMetaRgn(HDC, HRGN);
1423 HGDIOBJ GetCurrentObject(HDC, UINT);
1424 // WINBOOL GetCurrentPositionEx(HDC, LPPOINT);
1425 int GetDeviceCaps(HDC, int);
1426 // int GetDIBits(HDC, HBITMAP, UINT, UINT, LPVOID, LPBITMAPINFO, UINT);
1427 // DWORD GetFontData(HDC, DWORD, DWORD, LPVOID, DWORD);
1428 // int GetGraphicsMode(HDC);
1429 // int GetMapMode(HDC);
1430 // UINT GetMetaFileBitsEx(HMETAFILE, UINT, LPVOID);
1431 // COLORREF GetNearestColor(HDC, COLORREF);
1432 // UINT GetNearestPaletteIndex(HPALETTE, COLORREF);
1433 // DWORD GetObjectType(HGDIOBJ);
1434 // UINT GetPaletteEntries(HPALETTE, UINT, UINT, LPPALETTEENTRY);
1435 // COLORREF GetPixel(HDC, int, int);
1436 // int GetPixelFormat(HDC);
1437 int GetPolyFillMode(HDC);
1438 // WINBOOL GetRasterizerCaps(LPRASTERIZER_STATUS, UINT);
1439 // DWORD GetRegionData(HRGN, DWORD, LPRGNDATA);
1440 // int GetRgnBox(HRGN, LPRECT);
1441 HGDIOBJ GetStockObject(int);
1442 // int GetStretchBltMode(HDC);
1443 // UINT GetSystemPaletteEntries(HDC, UINT, UINT, LPPALETTEENTRY);
1444 // UINT GetSystemPaletteUse(HDC);
1445 // int GetTextCharacterExtra(HDC);
1446 // UINT GetTextAlign(HDC);
1447 // COLORREF GetTextColor(HDC);
1448 // int GetTextCharset(HDC);
1449 // int GetTextCharsetInfo(HDC, LPFONTSIGNATURE, DWORD);
1450 // WINBOOL TranslateCharsetInfo(DWORD*, LPCHARSETINFO, DWORD);
1451 // DWORD GetFontLanguageInfo(HDC);
1452 // WINBOOL GetViewportExtEx(HDC, LPSIZE);
1453 // WINBOOL GetViewportOrgEx(HDC, LPPOINT);
1454 // WINBOOL GetWindowExtEx(HDC, LPSIZE);
1455 WINBOOL GetWindowOrgEx(HDC, LPPOINT);
1456 // int IntersectClipRect(HDC, int, int, int, int);
1457 // WINBOOL InvertRgn(HDC, HRGN);
1458 // WINBOOL LineDDA(int, int, int, int, LINEDDAPROC, LPARAM);
1459 WINBOOL LineTo(HDC, int, int);
1460 // WINBOOL MaskBlt(HDC, int, int, int, int, HDC, int, int, HBITMAP, int, int, DWORD);
1461 // WINBOOL PlgBlt(HDC, POINT*, HDC, int, int, int, int, HBITMAP, int, int);
1462 // int OffsetClipRgn(HDC, int, int);
1463 // int OffsetRgn(HRGN, int, int);
1464 // WINBOOL PatBlt(HDC, int, int, int, int, DWORD);
1465 // WINBOOL Pie(HDC, int, int, int, int, int, int, int, int);
1466 // WINBOOL PlayMetaFile(HDC, HMETAFILE);
1467 // WINBOOL PaintRgn(HDC, HRGN);
1468 // WINBOOL PolyPolygon(HDC, POINT*, WINT*, int);
1469 // WINBOOL PtInRegion(HRGN, int, int);
1470 // WINBOOL PtVisible(HDC, int, int);
1471 // WINBOOL RectInRegion(HRGN, RECT*);
1472 // WINBOOL RectVisible(HDC, RECT*);
1473 // WINBOOL Rectangle(HDC, int, int, int, int);
1474 // WINBOOL RestoreDC(HDC, int);
1475 // UINT RealizePalette(HDC);
1476 WINBOOL RoundRect(HDC, int, int, int, int, int, int);
1477 // WINBOOL ResizePalette(HPALETTE, UINT);
1478 int SaveDC(HDC);
1479 int SelectClipRgn(HDC, HRGN);
1480 // int ExtSelectClipRgn(HDC, HRGN, int);
1481 int SetMetaRgn(HDC);
1482 HGDIOBJ SelectObject(HDC, HGDIOBJ);
1483 HPALETTE SelectPalette(HDC, HPALETTE, WINBOOL);
1484 COLORREF SetBkColor(HDC, COLORREF);
1485 int SetBkMode(HDC, int);
1486 // LONG SetBitmapBits(HBITMAP, DWORD, POINTER);
1487 // UINT SetBoundsRect(HDC, RECT*, UINT);
1488 // int SetDIBits(HDC, HBITMAP, UINT, UINT, POINTER, PBITMAPINFO, UINT);
1489 // int SetDIBitsToDevice(HDC, int, int, DWORD, DWORD, int, int, UINT, UINT, POINTER, BITMAPINFO*, UINT);
1490 // DWORD SetMapperFlags(HDC, DWORD);
1491 int SetGraphicsMode(HDC, int);
1492 // int SetMapMode(HDC, int);
1493 // HMETAFILE SetMetaFileBitsEx(UINT, ubyte*);
1494 // UINT SetPaletteEntries(HPALETTE, UINT, UINT, PALETTEENTRY*);
1495 COLORREF SetPixel(HDC, int, int, COLORREF);
1496 // WINBOOL SetPixelV(HDC, int, int, COLORREF);
1497 int SetPolyFillMode(HDC, int);
1498 WINBOOL StretchBlt(HDC, int, int, int, int, HDC, int, int, int, int, DWORD);
1499 WINBOOL SetRectRgn(HRGN, int, int, int, int);
1500 // int StretchDIBits(HDC, int, int, int, int, int, int, int, int, POINTER, BITMAPINFO*, UINT, DWORD);
1501 int SetROP2(HDC, int);
1502 int SetStretchBltMode(HDC, int);
1503 // UINT SetSystemPaletteUse(HDC, UINT);
1504 // int SetTextCharacterExtra(HDC, int);
1505 COLORREF SetTextColor(HDC, COLORREF);
1506 UINT SetTextAlign(HDC, UINT);
1507 // WINBOOL SetTextJustification(HDC, int, int);
1508 // WINBOOL UpdateColors(HDC);
1509 // WINBOOL PlayMetaFileRecord(HDC, LPHANDLETABLE, LPMETARECORD, UINT);
1510 // WINBOOL EnumMetaFile(HDC, HMETAFILE, ENUMMETAFILEPROC, LPARAM);
1511 HENHMETAFILE CloseEnhMetaFile(HDC);
1512 WINBOOL DeleteEnhMetaFile(HENHMETAFILE);
1513 WINBOOL EnumEnhMetaFile(HDC, HENHMETAFILE, ENHMETAFILEPROC, LPVOID, RECT*);
1514 // UINT GetEnhMetaFileHeader(HENHMETAFILE, UINT, LPENHMETAHEADER);
1515 // UINT GetEnhMetaFilePaletteEntries(HENHMETAFILE, UINT, LPPALETTEENTRY);
1516 // UINT GetWinMetaFileBits(HENHMETAFILE, UINT, LPBYTE, WINT, HDC);
1517 // WINBOOL PlayEnhMetaFile(HDC, HENHMETAFILE, RECT*);
1518 // WINBOOL PlayEnhMetaFileRecord(HDC, LPHANDLETABLE, ENHMETARECORD*, UINT);
1519 // HENHMETAFILE SetEnhMetaFileBits(UINT, ubyte*);
1520 // HENHMETAFILE SetWinMetaFileBits(UINT, ubyte*, HDC, METAFILEPICT*);
1521 // WINBOOL GdiComment(HDC, UINT, ubyte*);
1522 // WINBOOL AngleArc(HDC, int, int, DWORD, FLOAT, FLOAT);
1523 // WINBOOL PolyPolyline(HDC, POINT*, DWORD*, DWORD);
1524 // WINBOOL GetWorldTransform(HDC, LPXFORM);
1525 WINBOOL SetWorldTransform(HDC, XFORM*);
1526 // WINBOOL ModifyWorldTransform(HDC, XFORM*, DWORD);
1527 // WINBOOL CombineTransform(LPXFORM, XFORM*, XFORM*);
1528 // HBITMAP CreateDIBSection(HDC, BITMAPINFO*, UINT, POINTER*, HANDLE, DWORD);
1529 // UINT GetDIBColorTable(HDC, UINT, UINT, RGBQUAD*);
1530 // UINT SetDIBColorTable(HDC, UINT, UINT, RGBQUAD*);
1531 // WINBOOL SetColorAdjustment(HDC, COLORADJUSTMENT*);
1532 // WINBOOL GetColorAdjustment(HDC, LPCOLORADJUSTMENT);
1533 // HPALETTE CreateHalftonePalette(HDC);
1534 // int EndDoc(HDC);
1535 // int StartPage(HDC);
1536 // int EndPage(HDC);
1537 // int AbortDoc(HDC);
1538 // int SetAbortProc(HDC, TABORTPROC);
1539 // WINBOOL ArcTo(HDC, int, int, int, int, int, int, int, int);
1540 WINBOOL BeginPath(HDC);
1541 // WINBOOL CloseFigure(HDC);
1542 WINBOOL EndPath(HDC);
1543 // WINBOOL FillPath(HDC);
1544 // WINBOOL FlattenPath(HDC);
1545 int GetPath(HDC, LPPOINT, LPBYTE, int);
1546 // HRGN PathToRegion(HDC);
1547 // WINBOOL PolyDraw(HDC, POINT*, ubyte*, int);
1548 // WINBOOL SelectClipPath(HDC, int);
1549 // int SetArcDirection(HDC, int);
1550 // WINBOOL SetMiterLimit(HDC, FLOAT, PFLOAT);
1551 // WINBOOL StrokeAndFillPath(HDC);
1552 // WINBOOL StrokePath(HDC);
1553 // WINBOOL WidenPath(HDC);
1554 HPEN ExtCreatePen(DWORD, DWORD, LOGBRUSH*, DWORD, DWORD*);
1555 // WINBOOL GetMiterLimit(HDC, PFLOAT);
1556 // int GetArcDirection(HDC);
1557 WINBOOL MoveToEx(HDC, int, int, LPPOINT);
1558 // HRGN CreatePolygonRgn(POINT*, int, int);
1559 // WINBOOL DPtoLP(HDC, LPPOINT, int);
1560 // WINBOOL LPtoDP(HDC, LPPOINT, int);
1561 // WINBOOL Polygon(HDC, POINT*, int);
1562 // WINBOOL Polyline(HDC, POINT*, int);
1563 // WINBOOL PolyBezier(HDC, POINT*, DWORD);
1564 // WINBOOL PolyBezierTo(HDC, POINT*, DWORD);
1565 // WINBOOL PolylineTo(HDC, POINT*, DWORD);
1566 // WINBOOL SetViewportExtEx(HDC, int, int, LPSIZE);
1567 // WINBOOL SetViewportOrgEx(HDC, int, int, LPPOINT);
1568 // WINBOOL SetWindowExtEx(HDC, int, int, LPSIZE);
1569 WINBOOL SetWindowOrgEx(HDC, int, int, LPPOINT);
1570 // WINBOOL OffsetViewportOrgEx(HDC, int, int, LPPOINT);
1571 // WINBOOL OffsetWindowOrgEx(HDC, int, int, LPPOINT);
1572 // WINBOOL ScaleViewportExtEx(HDC, int, int, int, int, LPSIZE);
1573 // WINBOOL ScaleWindowExtEx(HDC, int, int, int, int, LPSIZE);
1574 // WINBOOL SetBitmapDimensionEx(HBITMAP, int, int, LPSIZE);
1575 WINBOOL SetBrushOrgEx(HDC, int, int, LPPOINT);
1576 // WINBOOL GetDCOrgEx(HDC, LPPOINT);
1577 // WINBOOL FixBrushOrgEx(HDC, int, int, LPPOINT);
1578 // WINBOOL UnrealizeObject(HGDIOBJ);
1579 // WINBOOL GdiFlush();
1580 // DWORD GdiSetBatchLimit(DWORD);
1581 // DWORD GdiGetBatchLimit();
1582 // int SetICMMode(HDC, int);
1583 // WINBOOL CheckColorsInGamut(HDC, LPVOID, LPVOID, DWORD);
1584 // HANDLE GetColorSpace(HDC);
1585 // WINBOOL SetColorSpace(HDC, HCOLORSPACE);
1586 // WINBOOL DeleteColorSpace(HCOLORSPACE);
1587 // WINBOOL GetDeviceGammaRamp(HDC, LPVOID);
1588 // WINBOOL SetDeviceGammaRamp(HDC, LPVOID);
1589 // WINBOOL ColorMatchToTarget(HDC, HDC, DWORD);
1590 // HPROPSHEETPAGE CreatePropertySheetPageA(LPCPROPSHEETPAGE);
1591 // WINBOOL DestroyPropertySheetPage(HPROPSHEETPAGE);
1592 // void InitCommonControls();
1593 // HIMAGELIST ImageList_Create(int, int, UINT, int, int);
1594 // WINBOOL ImageList_Destroy(HIMAGELIST);
1595 // int ImageList_GetImageCount(HIMAGELIST);
1596 // int ImageList_Add(HIMAGELIST, HBITMAP, HBITMAP);
1597 // int ImageList_ReplaceIcon(HIMAGELIST, int, HICON);
1598 // COLORREF ImageList_SetBkColor(HIMAGELIST, COLORREF);
1599 // COLORREF ImageList_GetBkColor(HIMAGELIST);
1600 // WINBOOL ImageList_SetOverlayImage(HIMAGELIST, int, int);
1601 WINBOOL ImageList_Draw(HIMAGELIST, int, HDC, int, int, UINT);
1602 // WINBOOL ImageList_Replace(HIMAGELIST, int, HBITMAP, HBITMAP);
1603 // int ImageList_AddMasked(HIMAGELIST, HBITMAP, COLORREF);
1604 // WINBOOL ImageList_DrawEx(HIMAGELIST, int, HDC, int, int, int, int, COLORREF, COLORREF, UINT);
1605 // WINBOOL ImageList_Remove(HIMAGELIST, int);
1606 // HICON ImageList_GetIcon(HIMAGELIST, int, UINT);
1607 WINBOOL ImageList_BeginDrag(HIMAGELIST, int, int, int);
1608 void ImageList_EndDrag();
1609 WINBOOL ImageList_DragEnter(HWND, int, int);
1610 WINBOOL ImageList_DragLeave(HWND);
1611 WINBOOL ImageList_DragMove(int, int);
1612 // WINBOOL ImageList_SetDragCursorImage(HIMAGELIST, int, int, int);
1613 WINBOOL ImageList_DragShowNolock(WINBOOL);
1614 // HIMAGELIST ImageList_GetDragImage(POINT*, POINT*);
1615 // WINBOOL ImageList_GetIconSize(HIMAGELIST, int*, int*);
1616 // WINBOOL ImageList_SetIconSize(HIMAGELIST, int, int);
1617 // WINBOOL ImageList_GetImageInfo(HIMAGELIST, int, IMAGEINFO*);
1618 // HIMAGELIST ImageList_Merge(HIMAGELIST, int, HIMAGELIST, int, int, int);
1619 // HWND CreateToolbarEx(HWND, DWORD, UINT, int, HINST, UINT, LPCTBBUTTON, int, int, int, int, int, UINT);
1620 // HBITMAP CreateMappedBitmap(HINST, int, UINT, LPCOLORMAP, int);
1621 // void MenuHelp(UINT, WPARAM, LPARAM, HMENU, HINST, HWND);
1622 // WINBOOL ShowHideMenuCtl(HWND, UINT, LPINT);
1623 // void GetEffectiveClientRect(HWND, LPRECT);
1624 // WINBOOL MakeDragList(HWND);
1625 // void DrawInsert(HWND, HWND);
1626 // int LBItemFromPt(HWND, POINT, WINBOOL);
1627 // HWND CreateUpDownControl(DWORD, int, int, int, int, HWND, int, HINST, HWND, int, int, int);
1628 // LONG RegCloseKey(HKEY);
1629 // LONG RegSetKeySecurity(HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
1630 // LONG RegFlushKey(HKEY);
1631 // LONG RegGetKeySecurity(HKEY, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, LPDWORD);
1632 // LONG RegNotifyChangeKeyValue(HKEY, WINBOOL, DWORD, HANDLE, WINBOOL);
1633 // WINBOOL IsValidCodePage(UINT);
1634 // UINT GetACP();
1635 // UINT GetOEMCP();
1636 // WINBOOL GetCPInfo(UINT, LPCPINFO);
1637 // WINBOOL IsDBCSLeadByte(ubyte);
1638 // WINBOOL IsDBCSLeadByteEx(UINT, ubyte);
1639 int MultiByteToWideChar(UINT, DWORD, LPCSTR, int, LPWSTR, int);
1640 int WideCharToMultiByte(UINT, DWORD, LPCWSTR, int, LPSTR, int, LPCSTR, LPBOOL);
1641 // WINBOOL IsValidLocale(LCID, DWORD);
1642 // LCID ConvertDefaultLocale(LCID);
1643 // LCID GetThreadLocale();
1644 // WINBOOL SetThreadLocale(LCID);
1645 // LANGID GetSystemDefaultLangID();
1646 // LANGID GetUserDefaultLangID();
1647 // LCID GetSystemDefaultLCID();
1648 // LCID GetUserDefaultLCID();
1649 // WINBOOL ReadConsoleOutputAttribute(HANDLE, LPWORD, DWORD, COORD, LPDWORD);
1650 // WINBOOL WriteConsoleOutputAttribute(HANDLE, ushort*, DWORD, COORD, LPDWORD);
1651 // WINBOOL FillConsoleOutputAttribute(HANDLE, ushort, DWORD, COORD, LPDWORD);
1652 // WINBOOL GetConsoleMode(HANDLE, LPDWORD);
1653 // WINBOOL GetNumberOfConsoleInputEvents(HANDLE, PDWORD);
1654 // WINBOOL GetConsoleScreenBufferInfo(HANDLE, PCONSOLE_SCREEN_BUFFER_INFO);
1655 // COORD GetLargestConsoleWindowSize(HANDLE);
1656 // WINBOOL GetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO);
1657 // WINBOOL GetNumberOfConsoleMouseButtons(LPDWORD);
1658 // WINBOOL SetConsoleMode(HANDLE, DWORD);
1659 // WINBOOL SetConsoleActiveScreenBuffer(HANDLE);
1660 // WINBOOL FlushConsoleInputBuffer(HANDLE);
1661 // WINBOOL SetConsoleScreenBufferSize(HANDLE, COORD);
1662 // WINBOOL SetConsoleCursorPosition(HANDLE, COORD);
1663 // WINBOOL SetConsoleCursorInfo(HANDLE, PCONSOLE_CURSOR_INFO);
1664 // WINBOOL SetConsoleWindowInfo(HANDLE, WINBOOL, SMALL_RECT*);
1665 // WINBOOL SetConsoleTextAttribute(HANDLE, ushort);
1666 // WINBOOL SetConsoleCtrlHandler(PHANDLER_ROUTINE, WINBOOL);
1667 // WINBOOL GenerateConsoleCtrlEvent(DWORD, DWORD);
1668 // WINBOOL AllocConsole();
1669 // WINBOOL FreeConsole();
1670 // HANDLE CreateConsoleScreenBuffer(DWORD, DWORD, SECURITY_ATTRIBUTES*, DWORD, LPVOID);
1671 // UINT GetConsoleCP();
1672 // WINBOOL SetConsoleCP(UINT);
1673 // UINT GetConsoleOutputCP();
1674 // WINBOOL SetConsoleOutputCP(UINT);
1675 // DWORD WNetConnectionDialog(HWND, DWORD);
1676 // DWORD WNetDisconnectDialog(HWND, DWORD);
1677 // DWORD WNetCloseEnum(HANDLE);
1678 // WINBOOL CloseServiceHandle(SC_HANDLE);
1679 // WINBOOL ControlService(SC_HANDLE, DWORD, LPSERVICE_STATUS);
1680 // WINBOOL DeleteService(SC_HANDLE);
1681 // SC_LOCK LockServiceDatabase(SC_HANDLE);
1682 // WINBOOL NotifyBootConfigStatus(WINBOOL);
1683 // WINBOOL QueryServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
1684 // WINBOOL QueryServiceStatus(SC_HANDLE, LPSERVICE_STATUS);
1685 // WINBOOL SetServiceObjectSecurity(SC_HANDLE, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
1686 // WINBOOL SetServiceStatus(SERVICE_STATUS_HANDLE, LPSERVICE_STATUS);
1687 // WINBOOL UnlockServiceDatabase(SC_LOCK);
1688 // int ChoosePixelFormat(HDC, PIXELFORMATDESCRIPTOR*);
1689 // int DescribePixelFormat(HDC, int, UINT, LPPIXELFORMATDESCRIPTOR);
1690 // WINBOOL SetPixelFormat(HDC, int, PPIXELFORMATDESCRIPTOR);
1691 // WINBOOL SwapBuffers(HDC);
1692 // WINBOOL DragQueryPoint(HDROP, LPPOINT);
1693 // void DragFinish(HDROP);
1694 // void DragAcceptFiles(HWND, BOOL);
1695 // HICON DuplicateIcon(HINST, HICON);
1696 // BOOL DdeAbandonTransaction(DWORD, HCONV, DWORD);
1697 // PBYTE DdeAccessData(HDDEDATA, PDWORD);
1698 // HDDEDATA DdeAddData(HDDEDATA, PBYTE, DWORD, DWORD);
1699 // HDDEDATA DdeClientTransaction(PBYTE, DWORD, HCONV, HSZ, UINT, UINT, DWORD, PDWORD);
1700 // int DdeCmpStringHandles(HSZ, HSZ);
1701 // HCONV DdeConnect(DWORD, HSZ, HSZ, CONVCONTEXT*);
1702 // HCONVLIST DdeConnectList(DWORD, HSZ, HSZ, HCONVLIST, PCONVCONTEXT);
1703 // HDDEDATA DdeCreateDataHandle(DWORD, LPBYTE, DWORD, DWORD, HSZ, UINT, UINT);
1704 // WINBOOL DdeDisconnect(HCONV);
1705 // BOOL DdeDisconnectList(HCONVLIST);
1706 // BOOL DdeEnableCallback(DWORD, HCONV, UINT);
1707 // WINBOOL DdeFreeDataHandle(HDDEDATA);
1708 // WINBOOL DdeFreeStringHandle(DWORD, HSZ);
1709 // DWORD DdeGetData(HDDEDATA, ubyte*, DWORD, DWORD);
1710 // UINT DdeGetLastError(DWORD);
1711 // BOOL DdeImpersonateClient(HCONV);
1712 // BOOL DdeKeepStringHandle(DWORD, HSZ);
1713 // HDDEDATA DdeNameService(DWORD, HSZ, HSZ, UINT);
1714 // WINBOOL DdePostAdvise(DWORD, HSZ, HSZ);
1715 // UINT DdeQueryConvInfo(HCONV, DWORD, PCONVINFO);
1716 // HCONV DdeQueryNextServer(HCONVLIST, HCONV);
1717 // HCONV DdeReconnect(HCONV);
1718 // BOOL DdeSetUserHandle(HCONV, DWORD, DWORD);
1719 // BOOL DdeUnaccessData(HDDEDATA);
1720 // WINBOOL DdeUninitialize(DWORD);
1721 // void SHAddToRecentDocs(UINT);
1722 // LPITEMIDLIST SHBrowseForFolder(LPBROWSEINFO);
1723 // void SHChangeNotify(LONG, UINT, LPCVOID);
1724 // int SHFileOperation(LPSHFILEOPSTRUCT);
1725 // void SHFreeNameMappings(HANDLE);
1726 DWORD SHGetFileInfo(LPCTSTR, DWORD, SHFILEINFO*, UINT, UINT);
1727 // WINBOOL SHGetPathFromIDList(LPCITEMIDLIST, LPTSTR);
1728 // HRESULT SHGetSpecialFolderLocation(HWND, int, LPITEMIDLIST*);
1729 // THANDLE CreateThread(POINTER, DWORD, TFNTHREADSTARTROUTINE, POINTER, DWORD, DWORD*);
1730 // BOOL DdeSetQualityOfService(HWND, TSECURITYQUALITYOFSERVICE*, PSECURITYQUALITYOFSERVICE);
1731 // BOOL GetCommMask(THANDLE, DWORD*);
1732 // BOOL GetDiskFreeSpaceExA(LPCSTR, void*, void*, PLARGEINTEGER);
1733 // BOOL GetDiskFreeSpaceExW(LPWSTR, void*, void*, PLARGEINTEGER);
1734 // DWORD GetKerningPairs(HDC, DWORD, void*);
1735 // BOOL GetOverlappedResult(THANDLE, TOVERLAPPED*, DWORD*, BOOL);
1736 // BOOL GetQueuedCompletionStatus(THANDLE, DWORD*, DWORD*, POVERLAPPED*, DWORD);
1737 // BOOL GetSystemPowerStatus(TSYSTEMPOWERSTATUS*);
1738 // BOOL ReadFile(THANDLE, void*, DWORD, DWORD*, POVERLAPPED);
1739 // BOOL SetThreadContext(THANDLE, TCONTEXT*);
1740 // BOOL wglDescribeLayerPlane(HDC, int, int, uint, TLAYERPLANEDESCRIPTOR*);
1741 // int wglGetLayerPaletteEntries(HDC, int, int, int, void*);
1742 // int wglSetLayerPaletteEntries(HDC, int, int, int, void*);
1743 // DWORD WNetGetResourceParentA(PNETRESOURCEA, POINTER, DWORD*);
1744 // BOOL WriteFile(THANDLE, void*, DWORD, DWORD*, POVERLAPPED);
1745 //
1746 // BOOL CancelWaitableTimer(HANDLE hTimer);
1747 // HANDLE OpenWaitableTimerA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCSTR lpTimerName);
1748 // HANDLE OpenWaitableTimerW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCWSTR lpTimerName);
1749 // HANDLE CreateWaitableTimerA(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCSTR lpTimerName);
1750 // HANDLE CreateWaitableTimerW(LPSECURITY_ATTRIBUTES lpTimerAttributes, BOOL bManualReset, LPCWSTR lpTimerName);
1751 // BOOL SetWaitableTimer(HANDLE hTimer, LARGE_INTEGER* pDueTime, LONG lPeriod, PTIMERAPCROUTINE pfnCompletionRoutine, LPVOID lpArgToCompletionRoutine, BOOL fResume);
1752 }
1753
1754 } // !TANGOSVN
1755 //////////////////////////////////////////////////////////////////////////////////////// 14 ////////////////////////////////////////////////////////////////////////////////////////
1756 // dwt 15 // dwt
1757 //////////////////////////////////////////////////////////////////////////////////////// 16 ////////////////////////////////////////////////////////////////////////////////////////
1758 17
1759 alias HANDLE HPAINTBUFFER; 18 alias HANDLE HPAINTBUFFER;