Mercurial > projects > dwt2

comparison org.eclipse.swt.win32.win32.x86/src/org/eclipse/swt/internal/win32/WINAPI.d @ 0:6dd524f61e62

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
add dwt win and basic java stuff
author Frank Benoit <benoit@tionex.de>
date Mon, 02 Mar 2009 14:44:16 +0100
parents
children 2847134a5fc0
comparison
equal deleted inserted replaced
-1:000000000000 0:6dd524f61e62
1 /**
2 * This module declared window APIs required by SWT but not in std.c.windows.windows,
3 * The one in the std.c.windows.windows module are aliased
4 */
5
6
7 module org.eclipse.swt.internal.win32.WINAPI;
8
9 public import org.eclipse.swt.internal.win32.WINTYPES;
10 //import tango_sys_win32.Types;
11 //import STDWIN = tango_sys_win32.UserGdi;
12
13 version(TANGOSVN){
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 ////////////////////////////////////////////////////////////////////////////////////////
1756 // org.eclipse.swt
1757 ////////////////////////////////////////////////////////////////////////////////////////
1758
1759 alias HANDLE HPAINTBUFFER;
1760
1761 extern (Windows){
1762 HRESULT AssocQueryStringA(ASSOCF flags, int str, LPCSTR pszAssoc, LPCSTR pszExtra, LPSTR pszOut, DWORD *pcchOut);
1763 HRESULT AssocQueryStringW(ASSOCF flags, int str, LPCWSTR pszAssoc, LPCWSTR pszExtra, LPWSTR pszOut, DWORD *pcchOut);
1764 int AddFontResourceExA(char* lpszFilename, int fl, void* pdv);
1765 int AddFontResourceExW(wchar* lpszFilename, int fl, void* pdv);
1766
1767 BOOL AlphaBlend(
1768 HDC hdcDest, // handle to destination DC
1769 int nXOriginDest, // x-coord of upper-left corner
1770 int nYOriginDest, // y-coord of upper-left corner
1771 int nWidthDest, // destination width
1772 int nHeightDest, // destination height
1773 HDC hdcSrc, // handle to source DC
1774 int nXOriginSrc, // x-coord of upper-left corner
1775 int nYOriginSrc, // y-coord of upper-left corner
1776 int nWidthSrc, // source width
1777 int nHeightSrc, // source height
1778 BLENDFUNCTION blendFunction // alpha-blending function
1779 );
1780 BOOL TransparentBlt(
1781 HDC hdcDest, // handle to destination DC
1782 int nXOriginDest, // x-coord of destination upper-left corner
1783 int nYOriginDest, // y-coord of destination upper-left corner
1784 int nWidthDest, // width of destination rectangle
1785 int hHeightDest, // height of destination rectangle
1786 HDC hdcSrc, // handle to source DC
1787 int nXOriginSrc, // x-coord of source upper-left corner
1788 int nYOriginSrc, // y-coord of source upper-left corner
1789 int nWidthSrc, // width of source rectangle
1790 int nHeightSrc, // height of source rectangle
1791 UINT crTransparent // color to make transparent
1792 );
1793 int IIDFromString (wchar* lpsz, byte* lpiid);
1794 HRESULT ScriptJustify(
1795 SCRIPT_VISATTR* psva,
1796 int* piAdvance,
1797 int cGlyphs,
1798 int iDx,
1799 int iMinKashida,
1800 int* piJustify
1801 );
1802
1803 HRESULT ScriptRecordDigitSubstitution(
1804 LCID Locale,
1805 SCRIPT_DIGITSUBSTITUTE* psds
1806 );
1807 HRESULT ScriptApplyDigitSubstitution(
1808 SCRIPT_DIGITSUBSTITUTE* psds,
1809 SCRIPT_CONTROL* psc,
1810 SCRIPT_STATE* pss
1811 );
1812
1813 // UxTheme.dll
1814 BOOL IsAppThemed();
1815
1816 HRESULT DrawThemeBackground(
1817 HTHEME hTheme,
1818 HDC hdc,
1819 int iPartId,
1820 int iStateId,
1821 RECT *pRect,
1822 RECT *pClipRect
1823 );
1824 HRESULT DrawThemeEdge(
1825 HTHEME hTheme,
1826 HDC hdc,
1827 int iPartId,
1828 int iStateId,
1829 LPCRECT pDestRect,
1830 UINT uEdge,
1831 UINT uFlags,
1832 LPRECT pContentRect
1833 );
1834 HRESULT DrawThemeIcon(
1835 HTHEME hTheme,
1836 HDC hdc,
1837 int iPartId,
1838 int iStateId,
1839 LPCRECT pRect,
1840 HIMAGELIST himl,
1841 int iImageIndex
1842 );
1843 HRESULT DrawThemeParentBackground(
1844 HWND hwnd,
1845 HDC hdc,
1846 RECT *prc
1847 );
1848 HRESULT DrawThemeText(
1849 HTHEME hTheme,
1850 HDC hdc,
1851 int iPartId,
1852 int iStateId,
1853 LPCWSTR pszText,
1854 int iCharCount,
1855 DWORD dwTextFlags,
1856 DWORD dwTextFlags2,
1857 LPCRECT pRect
1858 );
1859
1860 HTHEME OpenThemeData(
1861 HWND hwnd,
1862 LPCWSTR pszClassList
1863 );
1864 HRESULT BufferedPaintInit();
1865 HRESULT CloseThemeData(
1866 HTHEME hTheme
1867 );
1868 HRESULT BufferedPaintUnInit();
1869 //BOOL IsHungAppWindow(
1870 // HWND hWnd
1871 //);
1872 HPAINTBUFFER BeginBufferedPaint(
1873 HDC hdcTarget,
1874 RECT *prcTarget,
1875 uint/+BP_BUFFERFORMAT+/ dwFormat,
1876 void*/+BP_PAINTPARAMS+/ pPaintParams,
1877 HDC *phdc
1878 );
1879 HRESULT EndBufferedPaint(
1880 HPAINTBUFFER hBufferedPaint,
1881 BOOL fUpdateTarget
1882 );
1883
1884
1885 HRESULT GetThemeTextExtent(
1886 HTHEME hTheme,
1887 HDC hdc,
1888 int iPartId,
1889 int iStateId,
1890 LPCWSTR pszText,
1891 int iCharCount,
1892 DWORD dwTextFlags,
1893 LPCRECT pBoundingRect,
1894 LPRECT pExtentRect
1895 );
1896 HRESULT SetWindowTheme(
1897 HWND hwnd,
1898 LPCWSTR pszSubAppName,
1899 LPCWSTR pszSubIdList
1900 );
1901
1902 //Kernel32.lib
1903 //LANGID GetSystemDefaultUILanguage();
1904
1905 // Macro from winnt.h/windows.h
1906 WORD PRIMARYLANGID(
1907 WORD lgid
1908 );
1909
1910 //Gdi32.lib
1911 int IntersectClipRect(
1912 HDC hdc, // handle to DC
1913 int nLeftRect, // x-coord of upper-left corner
1914 int nTopRect, // y-coord of upper-left corner
1915 int nRightRect, // x-coord of lower-right corner
1916 int nBottomRect // y-coord of lower-right corner
1917 );
1918
1919 LRESULT CoCreateInstance(
1920 byte* rclsid, void* pUnkOuter, int dwClsContext, byte* riid, void* ppv
1921 );
1922 /+
1923 // kernel32 winxp/vista
1924 version(ANSI){
1925 HANDLE CreateActCtxA(
1926 ACTCTXA* pActCtx
1927 );
1928 }
1929 else{
1930 HANDLE CreateActCtxW(
1931 ACTCTXW* pActCtx
1932 );
1933 }
1934 BOOL ActivateActCtx(
1935 HACTCTX hActCtx,
1936 uint* lpCookie
1937 );
1938 +/
1939 }
1940 //--------------------------------------------------------------------------------------
1941
1942 // Windows API
1943 extern (Windows){
1944 int AbortDoc(HDC hdc);
1945 HKL ActivateKeyboardLayout(
1946 HKL hkl, // handle to keyboard layout
1947 UINT Flags // keyboard layout flags
1948 );
1949 BOOL AdjustWindowRectEx(
1950 LPRECT lpRect, // pointer to client-rectangle structure
1951 DWORD dwStyle, // window styles
1952 BOOL bMenu, // menu-present flag
1953 DWORD dwExStyle // extended style
1954 );
1955 BOOL Arc(
1956 HDC hdc, // handle to device context
1957 int nLeftRect, // x-coord of bounding rectangle's upper-left corner
1958 int nTopRect, // y-coord of bounding rectangle's upper-left corner
1959 int nRightRect, // x-coord of bounding rectangle's lower-right corner
1960 int nBottomRect, // y-coord of bounding rectangle's lower-right corner
1961 int nXStartArc, // first radial ending point
1962 int nYStartArc, // first radial ending point
1963 int nXEndArc, // second radial ending point
1964 int nYEndArc // second radial ending point
1965 );
1966 HDWP BeginDeferWindowPos(
1967 int nNumWindows
1968 );
1969 //alias STDWIN.BeginPaint BeginPaint;
1970 BOOL BitBlt(
1971 HDC hdcDest, // handle to destination device context
1972 int nXDest, // x-coordinate of destination rectangle's upper-left corner
1973 int nYDest, // y-coordinate of destination rectangle's upper-left corner
1974 int nWidth, // width of destination rectangle
1975 int nHeight, // height of destination rectangle
1976 HDC hdcSrc, // handle to source device context
1977 int nXSrc, // x-coordinate of source rectangle's upper-left corner
1978 int nYSrc, // y-coordinate of source rectangle's upper-left corner
1979 DWORD dwRop // raster operation code
1980 );
1981 BOOL BringWindowToTop(
1982 HWND hWnd // handle to window
1983 );
1984 LRESULT CallNextHookEx(
1985 HHOOK hhk, // handle to current hook
1986 int nCode, // hook code passed to hook procedure
1987 WPARAM wParam, // value passed to hook procedure
1988 LPARAM lParam // value passed to hook procedure
1989 );
1990 LRESULT CallWindowProcA(
1991 WNDPROC lpPrevWndFunc, // pointer to previous procedure
1992 HWND hWnd, // handle to window
1993 UINT Msg, // message
1994 WPARAM wParam, // first message parameter
1995 LPARAM lParam // second message parameter
1996 );
1997 LRESULT CallWindowProcW(
1998 WNDPROC lpPrevWndFunc, // pointer to previous procedure
1999 HWND hWnd, // handle to window
2000 UINT Msg, // message
2001 WPARAM wParam, // first message parameter
2002 LPARAM lParam // second message parameter
2003 );
2004 LPSTR CharLowerA(
2005 LPSTR lpsz // single character or pointer to string
2006 );
2007 LPWSTR CharLowerW(
2008 LPWSTR lpsz // single character or pointer to string
2009 );
2010 LPSTR CharUpperA(
2011 LPSTR lpsz // single character or pointer to string
2012 );
2013 LPWSTR CharUpperW(
2014 LPWSTR lpsz // single character or pointer to string
2015 );
2016 DWORD CheckMenuItem(
2017 HMENU hmenu, // handle to menu
2018 UINT uIDCheckItem, // menu item to check or uncheck
2019 UINT uCheck // menu item flags
2020 );
2021 BOOL ChooseColorA(
2022 LPCHOOSECOLORA lpcc // pointer to structure with initialization data
2023 );
2024 BOOL ChooseColorW(
2025 LPCHOOSECOLORW lpcc // pointer to structure with initialization data
2026 );
2027 BOOL ChooseFontA(
2028 LPCHOOSEFONTA lpcf // pointer to structure with initialization data
2029 );
2030 BOOL ChooseFontW(
2031 LPCHOOSEFONTW lpcf // pointer to structure with initialization data
2032 );
2033 //alias STDWIN.ClientToScreen ClientToScreen;
2034 BOOL CloseClipboard();
2035 int CombineRgn(
2036 HRGN hrgnDest, // handle to destination region
2037 HRGN hrgnSrc1, // handle to source region
2038 HRGN hrgnSrc2, // handle to source region
2039 int fnCombineMode // region combining mode
2040 );
2041 //alias STDWIN.CloseHandle CloseHandle;
2042 DWORD CommDlgExtendedError();
2043
2044 version(WinCE){
2045 BOOL CommandBar_AddAdornments(HWND hwndCB, DWORD dwFlags, DWORD dwReserved);
2046 HWND CommandBar_Create(HINSTANCE hInst, HWND hwndParent, int idCmdBar);
2047 void CommandBar_Destroy(HWND hwndCB);
2048 BOOL CommandBar_DrawMenuBar(HWND hwndCB, int iButton);
2049 int CommandBar_Height(HWND hwndCB);
2050 int CommandBar_InsertMenubarEx(HWND hwndCB, HINSTANCE hInst, int pszMenu, int iButton);
2051 int CommandBar_Show(HWND hwndCB, int fShow);
2052 }
2053
2054 HANDLE CopyImage(
2055 HANDLE hImage, // handle to the image to copy
2056 UINT uType, // type of image to copy
2057 int cxDesired, // desired width of new image
2058 int cyDesired, // desired height of new image
2059 UINT fuFlags // copy flags
2060 );
2061 HACCEL CreateAcceleratorTableA(
2062 LPACCEL lpaccl, // pointer to structure array with accelerator data
2063 int cEntries // number of structures in the array
2064 );
2065 HACCEL CreateAcceleratorTableW(
2066 LPACCEL lpaccl, // pointer to structure array with accelerator data
2067 int cEntries // number of structures in the array
2068 );
2069 HBITMAP CreateBitmap(
2070 int nWidth, // bitmap width, in pixels
2071 int nHeight, // bitmap height, in pixels
2072 UINT cPlanes, // number of color planes used by device
2073 UINT cBitsPerPel, // number of bits required to identify a color
2074 VOID *lpvBits // pointer to array containing color data
2075 );
2076 //alias STDWIN.CreateCaret CreateCaret;
2077 HBITMAP CreateCompatibleBitmap(
2078 HDC hdc, // handle to device context
2079 int nWidth, // width of bitmap, in pixels
2080 int nHeight // height of bitmap, in pixels
2081 );
2082 //alias STDWIN.CreateCompatibleDC CreateCompatibleDC;
2083 HCURSOR CreateCursor(
2084 HINSTANCE hInst, // handle to application instance
2085 int xHotSpot, // horizontal position of hot spot
2086 int yHotSpot, // vertical position of hot spot
2087 int nWidth, // cursor width
2088 int nHeight, // cursor height
2089 VOID *pvANDPlane, // pointer to AND bitmask array
2090 VOID *pvXORPlane // pointer to XOR bitmask array
2091 );
2092 HDC CreateDCA(
2093 LPCSTR lpszDriver, // pointer to string specifying driver name
2094 LPCSTR lpszDevice, // pointer to string specifying device name
2095 LPCSTR lpszOutput, // do not use; set to NULL
2096 DEVMODE *lpInitData
2097 // pointer to optional printer data
2098 );
2099 HDC CreateDCW(
2100 LPCWSTR lpszDriver, // pointer to string specifying driver name
2101 LPCWSTR lpszDevice, // pointer to string specifying device name
2102 LPCWSTR lpszOutput, // do not use; set to NULL
2103 DEVMODE *lpInitData
2104 // pointer to optional printer data
2105 );
2106 HBITMAP CreateDIBSection(
2107 HDC hdc, // handle to device context
2108 BITMAPINFO *pbmi, // pointer to structure containing bitmap size,
2109 // format, and color data
2110 UINT iUsage, // color data type indicator: RGB values or
2111 // palette indexes
2112 VOID **ppvBits, // pointer to variable to receive a pointer to
2113 // the bitmap's bit values
2114 HANDLE hSection, // optional handle to a file mapping object
2115 DWORD dwOffset // offset to the bitmap bit values within the
2116 // file mapping object
2117 );
2118 HANDLE CreateEventA(
2119 LPSECURITY_ATTRIBUTES lpEventAttributes,
2120 // pointer to security attributes
2121 BOOL bManualReset, // flag for manual-reset event
2122 BOOL bInitialState, // flag for initial state
2123 LPCSTR lpName // pointer to event-object name
2124 );
2125 HANDLE CreateEventW(
2126 LPSECURITY_ATTRIBUTES lpEventAttributes,
2127 // pointer to security attributes
2128 BOOL bManualReset, // flag for manual-reset event
2129 BOOL bInitialState, // flag for initial state
2130 LPCWSTR lpName // pointer to event-object name
2131 );
2132
2133 //alias STDWIN.CreateFileA CreateFileA;
2134 //alias STDWIN.CreateFileW CreateFileW;
2135 HFONT CreateFontIndirectA(LOGFONTA* lplf );
2136 HFONT CreateFontIndirectW(LOGFONTW* lplf );
2137 HICON CreateIconIndirect(
2138 PICONINFO piconinfo // pointer to icon information structure
2139 );
2140 HMENU CreateMenu();
2141 HPALETTE CreatePalette(
2142 LOGPALETTE *lplgpl // pointer to logical color palette
2143 );
2144 HBRUSH CreatePatternBrush(
2145 HBITMAP hbmp // handle to bitmap
2146 );
2147 //alias STDWIN.CreatePen CreatePen;
2148 HRGN CreatePolygonRgn(
2149 POINT *lppt, // pointer to array of points
2150 int cPoints, // number of points in array
2151 int fnPolyFillMode // polygon-filling mode
2152 );
2153 HMENU CreatePopupMenu();
2154 //alias STDWIN.CreateRectRgn CreateRectRgn;
2155 HBRUSH CreateSolidBrush(
2156 COLORREF crColor // brush color value
2157 );
2158
2159 //alias STDWIN.CreateWindowExA CreateWindowExA;
2160 HWND CreateWindowExW(
2161 DWORD dwExStyle, // extended window style
2162 LPCWSTR lpClassName, // pointer to registered class name
2163 LPCWSTR lpWindowName, // pointer to window name
2164 DWORD dwStyle, // window style
2165 int x, // horizontal position of window
2166 int y, // vertical position of window
2167 int nWidth, // window width
2168 int nHeight, // window height
2169 HWND hWndParent, // handle to parent or owner window
2170 HMENU hMenu, // handle to menu, or child-window identifier
2171 HINSTANCE hInstance, // handle to application instance
2172 LPVOID lpParam // pointer to window-creation data
2173 );
2174
2175 LRESULT DefFrameProcA(
2176 HWND hWnd, // handle to MDI frame window
2177 HWND hWndMDIClient, // handle to MDI client window
2178 UINT uMsg, // message
2179 WPARAM wParam, // first message parameter
2180 LPARAM lParam // second message parameter
2181 );
2182 LRESULT DefFrameProcW(
2183 HWND hWnd, // handle to MDI frame window
2184 HWND hWndMDIClient, // handle to MDI client window
2185 UINT uMsg, // message
2186 WPARAM wParam, // first message parameter
2187 LPARAM lParam // second message parameter
2188 );
2189 LRESULT DefMDIChildProcA(
2190 HWND hWnd, // handle to MDI child window
2191 UINT uMsg, // message
2192 WPARAM wParam, // first message parameter
2193 LPARAM lParam // second message parameter
2194 );
2195 LRESULT DefMDIChildProcW(
2196 HWND hWnd, // handle to MDI child window
2197 UINT uMsg, // message
2198 WPARAM wParam, // first message parameter
2199 LPARAM lParam // second message parameter
2200 );
2201 //alias STDWIN.DefWindowProcA DefWindowProcA;
2202 LRESULT DefWindowProcW(
2203 HWND hWnd, // handle to window
2204 UINT Msg, // message identifier
2205 WPARAM wParam, // first message parameter
2206 LPARAM lParam // second message parameter
2207 );
2208
2209 HDWP DeferWindowPos(
2210 HDWP hWinPosInfo, // handle to internal structure
2211 HWND hWnd, // handle to window to position
2212 HWND hWndInsertAfter, // placement-order handle
2213 int x, // horizontal position
2214 int y, // vertical position
2215 int cx, // width
2216 int cy, // height
2217 UINT uFlags // window-positioning flags
2218 );
2219
2220 //alias STDWIN.DeleteDC DeleteDC;
2221 //alias STDWIN.DeleteFileA DeleteFileA;
2222 BOOL DeleteMenu(
2223 HMENU hMenu, // handle to menu
2224 UINT uPosition, // menu item identifier or position
2225 UINT uFlags // menu item flag
2226 );
2227 //alias STDWIN.DeleteObject DeleteObject;
2228 BOOL DestroyAcceleratorTable(
2229 HACCEL hAccel // handle to accelerator table
2230 );
2231 int DestroyCaret();
2232 BOOL DestroyCursor(
2233 HCURSOR hCursor // handle to cursor to destroy
2234 );
2235 BOOL DestroyIcon(
2236 HICON hIcon // handle to icon to destroy
2237 );
2238 BOOL DestroyMenu(
2239 HMENU hMenu // handle to menu to destroy
2240 );
2241 BOOL DestroyWindow(
2242 HWND hWnd // handle to window to destroy
2243 );
2244 LONG DispatchMessageA(
2245 MSG *lpmsg // pointer to structure with message
2246 );
2247 LONG DispatchMessageW(
2248 MSG *lpmsg // pointer to structure with message
2249 );
2250 BOOL DragDetect(
2251 HWND hwnd,
2252 POINT pt
2253 );
2254 void DragFinish(
2255 HDROP hDrop
2256 );
2257 UINT DragQueryFileA(
2258 HDROP hDrop,
2259 UINT iFile,
2260 LPSTR lpszFile,
2261 UINT cch
2262 );
2263 UINT DragQueryFileW(
2264 HDROP hDrop,
2265 UINT iFile,
2266 LPWSTR lpszFile,
2267 UINT cch
2268 );
2269 BOOL DrawEdge(
2270 HDC hdc, // handle to device context
2271 LPRECT qrc, // pointer to rectangle coordinates
2272 UINT edge, // type of inner and outer edge to draw
2273 UINT grfFlags // type of border
2274 );
2275 BOOL DrawFocusRect(
2276 HDC hDC, // handle to device context
2277 RECT *lprc // pointer to structure for rectangle
2278 );
2279 BOOL DrawFrameControl(
2280 HDC hdc, // handle to device context
2281 LPRECT lprc, // pointer to bounding rectangle
2282 UINT uType, // frame-control type
2283 UINT uState // frame-control state
2284 );
2285 BOOL DrawIconEx(
2286 HDC hdc, // handle to device context
2287 int xLeft, // x-coordinate of upper left corner
2288 int yTop, // y-coordinate of upper left corner
2289 HICON hIcon, // handle to icon to draw
2290 int cxWidth, // width of the icon
2291 int cyWidth, // height of the icon
2292 UINT istepIfAniCur, // index of frame in animated cursor
2293 HBRUSH hbrFlickerFreeDraw, // handle to background brush
2294 UINT diFlags // icon-drawing flags
2295 );
2296 BOOL DrawMenuBar(
2297 HWND hWnd // handle to window with menu bar to redraw
2298 );
2299 BOOL DrawStateA(
2300 HDC hdc, // handle to device context
2301 HBRUSH hbr, // handle to brush
2302 DRAWSTATEPROC lpOutputFunc, // pointer to callback function
2303 LPARAM lData, // image information
2304 WPARAM wData, // more image information
2305 int x, // horizontal location of image
2306 int y, // vertical location of image
2307 int cx, // width of image
2308 int cy, // height of image
2309 UINT fuFlags // image type and state
2310 );
2311 BOOL DrawStateW(
2312 HDC hdc, // handle to device context
2313 HBRUSH hbr, // handle to brush
2314 DRAWSTATEPROC lpOutputFunc, // pointer to callback function
2315 LPARAM lData, // image information
2316 WPARAM wData, // more image information
2317 int x, // horizontal location of image
2318 int y, // vertical location of image
2319 int cx, // width of image
2320 int cy, // height of image
2321 UINT fuFlags // image type and state
2322 );
2323 int DrawTextA(
2324 HDC hDC, // handle to device context
2325 LPCSTR lpString, // pointer to string to draw
2326 int nCount, // string length, in characters
2327 LPRECT lpRect, // pointer to struct with formatting dimensions
2328 UINT uFormat // text-drawing flags
2329 );
2330 int DrawTextW(
2331 HDC hDC, // handle to device context
2332 LPCWSTR lpString, // pointer to string to draw
2333 int nCount, // string length, in characters
2334 LPRECT lpRect, // pointer to struct with formatting dimensions
2335 UINT uFormat // text-drawing flags
2336 );
2337
2338 BOOL Ellipse(
2339 HDC hdc, // handle to device context
2340 int nLeftRect, // x-coord of bounding rectangle's upper-left corner
2341 int nTopRect, // y-coord of bounding rectangle's upper-left corner
2342 int nRightRect, // x-coord of bounding rectangle's lower-right corner
2343 int nBottomRect // y-coord of bounding rectangle's lower-right corner
2344 );
2345 BOOL EnableMenuItem(
2346 HMENU hMenu, // handle to menu
2347 UINT uIDEnableItem, // menu item to enable, disable, or gray
2348 UINT uEnable // menu item flags
2349 );
2350 BOOL EnableWindow(
2351 HWND hWnd,
2352 BOOL bEnable
2353 );
2354 BOOL EndDeferWindowPos(
2355 HDWP hWinPosInfo // handle to internal structure
2356 );
2357 int EndDoc(HDC hDC);
2358 int EndPage(HDC hDC);
2359 BOOL EnumDisplayMonitors(
2360 HDC hdc, // handle to display DC
2361 LPCRECT lprcClip, // clipping rectangle
2362 MONITORENUMPROC lpfnEnum, // callback function
2363 LPARAM dwData // data for callback function
2364 );
2365 int EnumFontFamiliesExA(
2366 HDC hdc, // handle to device context
2367 LPLOGFONTA lpLogfont, // pointer to logical font information
2368 FONTENUMEXPROC lpEnumFontFamExProc,
2369 // pointer to callback function
2370 LPARAM lParam, // application-supplied data
2371 DWORD dwFlags // reserved; must be zero
2372 );
2373 int EnumFontFamiliesExW(
2374 HDC hdc, // handle to device context
2375 LPLOGFONTW lpLogfont, // pointer to logical font information
2376 FONTENUMEXPROC lpEnumFontFamExProc,
2377 // pointer to callback function
2378 LPARAM lParam, // application-supplied data
2379 DWORD dwFlags // reserved; must be zero
2380 );
2381
2382 int EnumFontFamiliesA(
2383 HDC hdc, // handle to device control
2384 LPCSTR lpszFamily, // pointer to family-name string
2385 FONTENUMPROC lpEnumFontFamProc,
2386 // pointer to callback function
2387 LPARAM lParam // pointer to application-supplied data
2388 );
2389 int EnumFontFamiliesW(
2390 HDC hdc, // handle to device control
2391 LPCWSTR lpszFamily, // pointer to family-name string
2392 FONTENUMPROC lpEnumFontFamProc,
2393 // pointer to callback function
2394 LPARAM lParam // pointer to application-supplied data
2395 );
2396 BOOL EqualRect(
2397 RECT *lprc1, // pointer to structure with first rectangle
2398 RECT *lprc2 // pointer to structure with second rectangle
2399 );
2400 BOOL EqualRgn(
2401 HRGN hSrcRgn1, // handle to first region
2402 HRGN hSrcRgn2 // handle to second region
2403 );
2404 DWORD ExpandEnvironmentStringsA(
2405 LPCSTR lpSrc, // pointer to string with environment variables
2406 LPSTR lpDst, // pointer to string with expanded environment
2407 // variables
2408 DWORD nSize // maximum characters in expanded string
2409 );
2410 DWORD ExpandEnvironmentStringsW(
2411 LPCWSTR lpSrc, // pointer to string with environment variables
2412 LPWSTR lpDst, // pointer to string with expanded environment
2413 // variables
2414 DWORD nSize // maximum characters in expanded string
2415 );
2416 BOOL ExtTextOutA(
2417 HDC hdc, // handle to device context
2418 int X, // x-coordinate of reference point
2419 int Y, // y-coordinate of reference point
2420 UINT fuOptions, // text-output options
2421 RECT *lprc, // optional clipping and/or opaquing rectangle
2422 LPCSTR lpString, // points to string
2423 UINT cbCount, // number of characters in string
2424 INT *lpDx // pointer to array of intercharacter spacing
2425 // values
2426 );
2427 BOOL ExtTextOutW(
2428 HDC hdc, // handle to device context
2429 int X, // x-coordinate of reference point
2430 int Y, // y-coordinate of reference point
2431 UINT fuOptions, // text-output options
2432 RECT *lprc, // optional clipping and/or opaquing rectangle
2433 LPCWSTR lpString, // points to string
2434 UINT cbCount, // number of characters in string
2435 INT *lpDx // pointer to array of intercharacter spacing
2436 // values
2437 );
2438 UINT ExtractIconExA(
2439 LPCSTR lpszFile,
2440 int nIconIndex,
2441 HICON *phiconLarge,
2442 HICON *phiconSmall,
2443 UINT nIcons
2444 );
2445 UINT ExtractIconExW(
2446 LPCWSTR lpszFile,
2447 int nIconIndex,
2448 HICON *phiconLarge,
2449 HICON *phiconSmall,
2450 UINT nIcons
2451 );
2452 HRSRC FindResourceA(
2453 HMODULE hModule, // module handle
2454 LPCSTR lpName, // pointer to resource name
2455 LPCSTR lpType // pointer to resource type
2456 );
2457 HRSRC FindResourceW(
2458 HMODULE hModule, // module handle
2459 LPCWSTR lpName, // pointer to resource name
2460 LPCWSTR lpType // pointer to resource type
2461 );
2462 HWND FindWindowA(
2463 LPCSTR lpClassName, // pointer to class name
2464 LPCSTR lpWindowName // pointer to window name
2465 );
2466 HWND FindWindowW(
2467 LPCWSTR lpClassName, // pointer to class name
2468 LPCWSTR lpWindowName // pointer to window name
2469 );
2470 DWORD FormatMessageA(
2471 DWORD dwFlags, // source and processing options
2472 LPCVOID lpSource, // pointer to message source
2473 DWORD dwMessageId, // requested message identifier
2474 DWORD dwLanguageId, // language identifier for requested message
2475 LPSTR lpBuffer, // pointer to message buffer
2476 DWORD nSize, // maximum size of message buffer
2477 // va_list *Arguments // pointer to array of message inserts
2478 void* Arguments
2479 );
2480 DWORD FormatMessageW(
2481 DWORD dwFlags, // source and processing options
2482 LPCVOID lpSource, // pointer to message source
2483 DWORD dwMessageId, // requested message identifier
2484 DWORD dwLanguageId, // language identifier for requested message
2485 LPWSTR lpBuffer, // pointer to message buffer
2486 DWORD nSize, // maximum size of message buffer
2487 // va_list *Arguments // pointer to array of message inserts
2488 void* Arguments
2489 );
2490 DWORD GdiSetBatchLimit(
2491 DWORD dwLimit // batch limit
2492 );
2493 UINT GetACP();
2494 HWND GetActiveWindow();
2495 COLORREF GetBkColor(
2496 HDC hdc // handle of device context
2497 );
2498 HWND GetCapture();
2499 BOOL GetCaretPos(
2500 LPPOINT lpPoint // address of structure to receive coordinates
2501 );
2502 BOOL GetCharABCWidthsA(
2503 HDC hdc, // handle to device context
2504 UINT uFirstChar, // first character in range to query
2505 UINT uLastChar, // last character in range to query
2506 LPABC lpabc // pointer to character-width structure
2507 );
2508 BOOL GetCharABCWidthsW(
2509 HDC hdc, // handle to device context
2510 UINT uFirstChar, // first character in range to query
2511 UINT uLastChar, // last character in range to query
2512 LPABC lpabc // pointer to character-width structure
2513 );
2514
2515 BOOL GetCharWidthA(
2516 HDC hdc, // handle to device context
2517 UINT iFirstChar, // first character in range to query
2518 UINT iLastChar, // last character in range to query
2519 LPINT lpBuffer // pointer to buffer for widths
2520 );
2521 BOOL GetCharWidthW(
2522 HDC hdc, // handle to device context
2523 UINT iFirstChar, // first character in range to query
2524 UINT iLastChar, // last character in range to query
2525 LPINT lpBuffer // pointer to buffer for widths
2526 );
2527 DWORD GetCharacterPlacementA(
2528 HDC hdc, // handle to device context
2529 LPCSTR lpString, // pointer to string
2530 int nCount, // number of characters in string
2531 int nMaxExtent, // maximum extent for displayed string
2532 LPGCP_RESULTS lpResults,
2533 // pointer to buffer for placement result
2534 DWORD dwFlags // placement flags
2535 );
2536 DWORD GetCharacterPlacementW(
2537 HDC hdc, // handle to device context
2538 LPCWSTR lpString, // pointer to string
2539 int nCount, // number of characters in string
2540 int nMaxExtent, // maximum extent for displayed string
2541 LPGCP_RESULTS lpResults,
2542 // pointer to buffer for placement result
2543 DWORD dwFlags // placement flags
2544 );
2545 BOOL GetClassInfoA(
2546 HINSTANCE hInstance, // handle of application instance
2547 LPCSTR lpClassName, // address of class name string
2548 LPWNDCLASSA lpWndClass // address of structure for class data
2549 );
2550 BOOL GetClassInfoW(
2551 HINSTANCE hInstance, // handle of application instance
2552 LPCWSTR lpClassName, // address of class name string
2553 LPWNDCLASSW lpWndClass // address of structure for class data
2554 );
2555 //alias STDWIN.GetClientRect GetClientRect;
2556 //alias STDWIN.GetClipBox GetClipBox;
2557 //alias STDWIN.GetClipRgn GetClipRgn;
2558 HANDLE GetClipboardData(
2559 UINT uFormat // clipboard format
2560 );
2561 int GetClipboardFormatNameA(
2562 UINT format, // clipboard format to retrieve
2563 LPSTR lpszFormatName, // address of buffer for name
2564 int cchMaxCount // length of name string in characters
2565 );
2566 int GetClipboardFormatNameW(
2567 UINT format, // clipboard format to retrieve
2568 LPWSTR lpszFormatName, // address of buffer for name
2569 int cchMaxCount // length of name string in characters
2570 );
2571 BOOL GetComboBoxInfo(
2572 HWND hwndCombo,
2573 PCOMBOBOXINFO pcbi
2574 );
2575 //alias STDWIN.GetCurrentObject GetCurrentObject;
2576 DWORD GetCurrentProcessId();
2577 DWORD GetCurrentThreadId();
2578 HCURSOR GetCursor();
2579 BOOL GetCursorPos(
2580 LPPOINT lpPoint // address of structure for cursor position
2581 );
2582 //alias STDWIN.GetDC GetDC;
2583 UINT GetDIBColorTable(
2584 HDC hdc, // handle to device context whose DIB is of
2585 // interest
2586 UINT uStartIndex, // color table index of first entry to retrieve
2587 UINT cEntries, // number of color table entries to retrieve
2588 RGBQUAD *pColors // pointer to buffer that receives color table
2589 // entries
2590 );
2591 int GetDIBits(
2592 HDC hdc, // handle to device context
2593 HBITMAP hbmp, // handle to bitmap
2594 UINT uStartScan, // first scan line to set in destination bitmap
2595 UINT cScanLines, // number of scan lines to copy
2596 LPVOID lpvBits, // address of array for bitmap bits
2597 LPBITMAPINFO lpbi, // address of structure with bitmap data
2598 UINT uUsage // RGB or palette index
2599 );
2600 HWND GetDesktopWindow();
2601 int GetDialogBaseUnits();
2602 int GetDoubleClickTime();
2603 DWORD GetFontLanguageInfo(
2604 HDC hdc // handle to a device context
2605 );
2606 BOOL GetGUIThreadInfo(
2607 DWORD idThread,
2608 LPGUITHREADINFO lpgui
2609 );
2610 BOOL GetIconInfo(
2611 HICON hIcon, // icon handle
2612 PICONINFO piconinfo // address of icon structure
2613 );
2614 int GetKeyNameTextA(
2615 LONG lParam, // second parameter of keyboard message
2616 LPSTR lpString, // pointer to buffer for key name
2617 int nSize // maximum length of key-name string length
2618 );
2619 int GetKeyNameTextW(
2620 LONG lParam, // second parameter of keyboard message
2621 LPWSTR lpString, // pointer to buffer for key name
2622 int nSize // maximum length of key-name string length
2623 );
2624 HKL GetKeyboardLayout(
2625 DWORD dwLayout // thread identifier
2626 );
2627 SHORT GetKeyState(
2628 int nVirtKey // virtual-key code
2629 );
2630 UINT GetKeyboardLayoutList(
2631 int nBuff, // size of buffer in array element
2632 HKL *lpList // buffer for keyboard layout handles
2633 );
2634 BOOL GetKeyboardState(
2635 PBYTE lpKeyState // pointer to array to receive status data
2636 );
2637 HWND GetLastActivePopup(HWND hWnd);
2638 DWORD GetLastError();
2639 DWORD GetLayout(
2640 HDC hdc // handle to DC
2641 );
2642 int GetLocaleInfoA(
2643 LCID Locale, // locale identifier
2644 LCTYPE LCType, // type of information
2645 LPSTR lpLCData, // address of buffer for information
2646 int cchData // size of buffer
2647 );
2648 int GetLocaleInfoW(
2649 LCID Locale, // locale identifier
2650 LCTYPE LCType, // type of information
2651 LPWSTR lpLCData, // address of buffer for information
2652 int cchData // size of buffer
2653 );
2654 HMENU GetMenu(
2655 HWND hWnd // handle to window
2656 );
2657 BOOL GetMenuBarInfo(
2658 HWND hwnd,
2659 LONG idObject,
2660 LONG idItem,
2661 PMENUBARINFO pmbi
2662 );
2663 UINT GetMenuDefaultItem(
2664 HMENU hMenu,
2665 UINT fByPos,
2666 UINT gmdiFlags
2667 );
2668 BOOL GetMenuInfo(
2669 HMENU hmenu,
2670 LPCMENUINFO lpcmi
2671 );
2672 int GetMenuItemCount(HMENU hMenu);
2673 BOOL GetMenuItemInfoA(
2674 HMENU hMenu,
2675 UINT uItem,
2676 BOOL fByPosition,
2677 LPMENUITEMINFO lpmii
2678 );
2679 BOOL GetMenuItemInfoW(
2680 HMENU hMenu,
2681 UINT uItem,
2682 BOOL fByPosition,
2683 LPMENUITEMINFO lpmii
2684 );
2685 BOOL GetMenuItemRect(
2686 HWND hWnd,
2687 HMENU hMenu,
2688 UINT uItem,
2689 LPRECT lprcItem
2690 );
2691 BOOL GetMessageW(
2692 LPMSG lpMsg, // address of structure with message
2693 HWND hWnd, // handle of window
2694 UINT wMsgFilterMin, // first message
2695 UINT wMsgFilterMax // last message
2696 );
2697 DWORD GetMessagePos();
2698 LONG GetMessageTime();
2699 DWORD GetModuleFileNameA(
2700 HMODULE hModule, // handle to module to find filename for
2701 LPSTR lpFilename, // pointer to buffer to receive module path
2702 DWORD nSize // size of buffer, in characters
2703 );
2704 DWORD GetModuleFileNameW(
2705 HMODULE hModule, // handle to module to find filename for
2706 LPWSTR lpFilename, // pointer to buffer to receive module path
2707 DWORD nSize // size of buffer, in characters
2708 );
2709 HMODULE GetModuleHandleW(
2710 LPCWSTR lpModuleName
2711 );
2712 BOOL GetMonitorInfoA(
2713 HMONITOR hMonitor, // handle to display monitor
2714 LPMONITORINFO lpmi // pointer to display monitor information
2715 );
2716 BOOL GetMonitorInfoW(
2717 HMONITOR hMonitor, // handle to display monitor
2718 LPMONITORINFO lpmi // pointer to display monitor information
2719 );
2720 UINT GetNearestPaletteIndex(
2721 HPALETTE hpal, // handle of logical color palette
2722 COLORREF crColor // color to be matched
2723 );
2724 BOOL GetOpenFileNameA(
2725 OPENFILENAMEA* lpofn // address of structure with initialization data
2726 );
2727 BOOL GetOpenFileNameW(
2728 OPENFILENAMEW* lpofn // address of structure with initialization data
2729 );
2730 UINT GetPaletteEntries(
2731 HPALETTE hpal, // handle to logical palette
2732 UINT iStartIndex, // first entry to retrieve
2733 UINT nEntries, // number of entries to retrieve
2734 LPPALETTEENTRY lppe // array that receives entries
2735 );
2736 HWND GetParent(
2737 HWND hWnd // handle to child window
2738 );
2739
2740 COLORREF GetPixel(
2741 HDC hdc, // handle to device context
2742 int XPos, // x-coordinate of pixel
2743 int nYPos // y-coordinate of pixel
2744 );
2745 HANDLE GetProcessHeap();
2746 DWORD GetProfileStringA(
2747 LPCSTR lpAppName, // address of section name
2748 LPCSTR lpKeyName, // address of key name
2749 LPCSTR lpDefault, // address of default string
2750 LPSTR lpReturnedString, // address of destination buffer
2751 DWORD nSize // size of destination buffer
2752 );
2753 DWORD GetProfileStringW(
2754 LPCWSTR lpAppName, // address of section name
2755 LPCWSTR lpKeyName, // address of key name
2756 LPCWSTR lpDefault, // address of default string
2757 LPWSTR lpReturnedString, // address of destination buffer
2758 DWORD nSize // size of destination buffer
2759 );
2760 int GetROP2(
2761 HDC hdc // handle of device context
2762 );
2763 int GetRandomRgn(
2764 HDC hdc, // handle to DC
2765 HRGN hrgn, // handle to region
2766 INT iNum // must be SYSRGN
2767 );
2768 DWORD GetRegionData(
2769 HRGN hRgn, // handle to region
2770 DWORD dwCount, // size of buffer containing region data
2771 LPRGNDATA lpRgnData // pointer to region data
2772 );
2773 int GetRgnBox(
2774 HRGN hrgn, // handle to a region
2775 LPRECT lprc // pointer that receives bounding rectangle
2776 );
2777 BOOL GetSaveFileNameA(
2778 OPENFILENAMEA* lpofn // address of structure with initialization data
2779 );
2780 BOOL GetSaveFileNameW(
2781 OPENFILENAME* lpofn // address of structure with initialization data
2782 );
2783 BOOL GetScrollInfo(
2784 HWND hwnd, // handle to window with scroll bar
2785 int fnBar, // scroll bar flag
2786 LPSCROLLINFO lpsi // pointer to structure for scroll parameters
2787 );
2788 //alias STDWIN.GetStockObject GetStockObject;
2789 DWORD GetSysColor(
2790 int nIndex // display element
2791 );
2792 HBRUSH GetSysColorBrush(
2793 int nIndex // system color index
2794 );
2795 HMENU GetSystemMenu(
2796 HWND hWnd, // handle to window to own window menu
2797 BOOL bRevert // reset flag
2798 );
2799 int GetSystemMetrics(
2800 int nIndex // system metric or configuration setting to retrieve
2801 );
2802 UINT GetSystemPaletteEntries(
2803 HDC hdc, // handle of device context
2804 UINT iStartIndex, // index of first entry to be retrieved
2805 UINT nEntries, // number of entries to be retrieved
2806 LPPALETTEENTRY lppe // array receiving system-palette entries
2807 );
2808 int GetTextCharset(
2809 HDC hdc // handle to DC
2810 );
2811 COLORREF GetTextColor(
2812 HDC hdc // handle to device context
2813 );
2814 BOOL GetTextExtentPoint32A(
2815 HDC hdc, // handle to device context
2816 LPCSTR lpString, // pointer to text string
2817 int cbString, // number of characters in string
2818 LPSIZE lpSize // pointer to structure for string size
2819 );
2820 BOOL GetTextExtentPoint32W(
2821 HDC hdc, // handle to device context
2822 LPCWSTR lpString, // pointer to text string
2823 int cbString, // number of characters in string
2824 LPSIZE lpSize // pointer to structure for string size
2825 );
2826 BOOL GetTextMetricsW(
2827 HDC hdc, // handle to device context
2828 TEXTMETRICW* lptm // pointer to text metrics structure
2829 );
2830 DWORD GetTickCount();
2831 //alias STDWIN.GetUpdateRect GetUpdateRect;
2832 //alias STDWIN.GetUpdateRgn GetUpdateRgn;
2833 DWORD GetVersion();
2834 BOOL GetVersionExA(
2835 LPOSVERSIONINFOA lpVersionInformation // pointer to version information structure
2836 );
2837 BOOL GetVersionExW(
2838 LPOSVERSIONINFOW lpVersionInformation // pointer to version information structure
2839 );
2840 HWND GetWindow(
2841 HWND hWnd, // handle to original window
2842 UINT uCmd // relationship flag
2843 );
2844 LONG GetWindowLongA(HWND hWnd, int nIndex);
2845 LONG GetWindowLongW(HWND hWnd, int nIndex);
2846
2847 BOOL GetWindowPlacement(
2848 HWND hWnd,
2849 WINDOWPLACEMENT *lpwndpl
2850 );
2851 int GetWindowTextA(
2852 HWND hWnd, // handle to window or control with text
2853 LPSTR lpString, // address of buffer for text
2854 int nMaxCount // maximum number of characters to copy
2855 );
2856 int GetWindowTextW(
2857 HWND hWnd, // handle to window or control with text
2858 LPWSTR lpString, // address of buffer for text
2859 int nMaxCount // maximum number of characters to copy
2860 );
2861 int GetWindowTextLengthA(HWND hWnd);
2862 int GetWindowTextLengthW(HWND hWnd);
2863 DWORD GetWindowThreadProcessId(
2864 HWND hWnd, // handle to window
2865 LPDWORD lpdwProcessId // address of variable for process identifier
2866 );
2867 HGLOBAL GlobalAlloc(UINT uFlags, SIZE_T dwBytes);
2868 HGLOBAL GlobalFree(HGLOBAL hMem);
2869 LPVOID GlobalLock(HGLOBAL hMem);
2870 SIZE_T GlobalSize(HGLOBAL hMem);
2871 BOOL GlobalUnlock(HGLOBAL hMem);
2872 BOOL GradientFill(
2873 HDC hdc,
2874 PTRIVERTEX pVertex,
2875 DWORD dwNumVertex,
2876 PVOID pMesh,
2877 DWORD dwNumMesh,
2878 DWORD dwMode
2879 );
2880 LPVOID HeapAlloc(
2881 HANDLE hHeap, // handle to the private heap block
2882 DWORD dwFlags, // heap allocation control flags
2883 DWORD dwBytes // number of bytes to allocate
2884 );
2885 BOOL HeapFree(
2886 HANDLE hHeap, // handle to the heap
2887 DWORD dwFlags, // heap freeing flags
2888 LPVOID lpMem // pointer to the memory to free
2889 );
2890 //alias STDWIN.HideCaret HideCaret;
2891 int ImageList_Add(
2892 HIMAGELIST himl,
2893 HBITMAP hbmImage,
2894 HBITMAP hbmMask
2895 );
2896 int ImageList_AddMasked(
2897 HIMAGELIST himl,
2898 HBITMAP hbmImage,
2899 COLORREF crMask
2900 );
2901 HIMAGELIST ImageList_Create(
2902 int cx,
2903 int cy,
2904 UINT flags,
2905 int cInitial,
2906 int cGrow
2907 );
2908 BOOL ImageList_Destroy(
2909 HIMAGELIST himl
2910 );
2911 HICON ImageList_GetIcon(
2912 HIMAGELIST himl,
2913 int i,
2914 UINT flags
2915 );
2916 BOOL ImageList_GetIconSize(
2917 HIMAGELIST himl,
2918 int *cx,
2919 int *cy
2920 );
2921 int ImageList_GetImageCount(
2922 HIMAGELIST himl
2923 );
2924 BOOL ImageList_Remove(
2925 HIMAGELIST himl,
2926 int i
2927 );
2928 BOOL ImageList_Replace(
2929 HIMAGELIST himl,
2930 int i,
2931 HBITMAP hbmImage,
2932 HBITMAP hbmMask
2933 );
2934 int ImageList_ReplaceIcon(
2935 HIMAGELIST himl,
2936 int i,
2937 HICON hicon
2938 );
2939 BOOL ImageList_SetIconSize(
2940 HIMAGELIST himl,
2941 int cx,
2942 int cy
2943 );
2944 HIMC ImmAssociateContext(
2945 HWND hWnd,
2946 HIMC hIMC
2947 );
2948 HIMC ImmCreateContext();
2949 int ImmDestroyContext(HIMC hIMC );
2950 BOOL ImmGetCompositionFontA(
2951 HIMC hIMC,
2952 LPLOGFONTA lplf
2953 );
2954 BOOL ImmGetCompositionFontW(
2955 HIMC hIMC,
2956 LOGFONTW* lplf
2957 );
2958 LONG ImmGetCompositionStringA(
2959 HIMC hIMC,
2960 DWORD dwIndex,
2961 LPVOID lpBuf,
2962 DWORD dwBufLen
2963 );
2964 LONG ImmGetCompositionStringW(
2965 HIMC hIMC,
2966 DWORD dwIndex,
2967 LPVOID lpBuf,
2968 DWORD dwBufLen
2969 );
2970 HIMC ImmGetContext(
2971 HWND hWnd
2972 );
2973 BOOL ImmGetConversionStatus(
2974 HIMC hIMC,
2975 LPDWORD lpfdwConversion,
2976 LPDWORD lpfdwSentence
2977 );
2978 HWND ImmGetDefaultIMEWnd(HWND hWnd );
2979 BOOL ImmGetOpenStatus(
2980 HIMC hIMC
2981 );
2982 BOOL ImmReleaseContext(
2983 HWND hWnd,
2984 HIMC hIMC
2985 );
2986 BOOL ImmSetCompositionFontA(
2987 HIMC hIMC,
2988 LOGFONTA* lplf
2989 );
2990 BOOL ImmSetCompositionFontW(
2991 HIMC hIMC,
2992 LOGFONTW* lplf
2993 );
2994 BOOL ImmSetCompositionWindow(
2995 HIMC hIMC,
2996 LPCOMPOSITIONFORM lpCompForm
2997 );
2998 BOOL ImmSetConversionStatus(
2999 HIMC hIMC,
3000 DWORD fdwConversion,
3001 DWORD fdwSentence
3002 );
3003 BOOL ImmSetOpenStatus(
3004 HIMC hIMC,
3005 BOOL fOpen
3006 );
3007 void InitCommonControls();
3008 BOOL InitCommonControlsEx(
3009 LPINITCOMMONCONTROLSEX lpInitCtrls
3010 );
3011 BOOL InsertMenuA(
3012 HMENU hMenu, // handle to menu
3013 UINT uPosition, // menu item that new menu item precedes
3014 UINT uFlags, // menu item flags
3015 UINT uIDNewItem, // menu item identifier or handle to drop-down
3016 // menu or submenu
3017 LPCSTR lpNewItem // menu item content
3018 );
3019 BOOL InsertMenuW(
3020 HMENU hMenu, // handle to menu
3021 UINT uPosition, // menu item that new menu item precedes
3022 UINT uFlags, // menu item flags
3023 UINT uIDNewItem, // menu item identifier or handle to drop-down
3024 // menu or submenu
3025 LPCWSTR lpNewItem // menu item content
3026 );
3027
3028 BOOL InsertMenuItemA(
3029 HMENU hMenu,
3030 UINT uItem,
3031 BOOL fByPosition,
3032 MENUITEMINFOA* lpmii
3033 );
3034 BOOL InsertMenuItemW(
3035 HMENU hMenu,
3036 UINT uItem,
3037 BOOL fByPosition,
3038 MENUITEMINFOW* lpmii
3039 );
3040 BOOL IntersectRect(
3041 LPRECT lprcDst, // pointer to structure for intersection
3042 RECT *lprcSrc1, // pointer to structure with first rectangle
3043 RECT *lprcSrc2 // pointer to structure with second rectangle
3044 );
3045 LONG InterlockedIncrement(
3046 LPLONG lpAddend // pointer to the variable to increment
3047 );
3048 LONG InterlockedDecrement(
3049 LPLONG lpAddend // address of the variable to decrement
3050 );
3051 BOOL IsDBCSLeadByte(
3052 BYTE TestChar // character to test
3053 );
3054 BOOL IsIconic(
3055 HWND hWnd // handle to window
3056 );
3057 BOOL IsWindow(
3058 HWND hWnd // handle to window
3059 );
3060 BOOL IsWindowEnabled(HWND hWnd);
3061 BOOL IsWindowVisible(HWND hWnd);
3062 BOOL IsZoomed(HWND hWnd);
3063 BOOL KillTimer(
3064 HWND hWnd, // handle of window that installed timer
3065 UINT uIDEvent // timer identifier
3066 );
3067 //alias STDWIN.LineTo LineTo;
3068 HBITMAP LoadBitmapA(
3069 HINSTANCE hInstance, // handle to application instance
3070 LPCSTR lpBitmapName // name of bitmap resource
3071 );
3072 HBITMAP LoadBitmapW(
3073 HINSTANCE hInstance, // handle to application instance
3074 LPCWSTR lpBitmapName // name of bitmap resource
3075 );
3076 HANDLE LoadImageA(
3077 HINSTANCE hinst, // handle of the instance containing the image
3078 LPCSTR lpszName, // name or identifier of image
3079 UINT uType, // type of image
3080 int cxDesired, // desired width
3081 int cyDesired, // desired height
3082 UINT fuLoad // load flags
3083 );
3084 HANDLE LoadImageW(
3085 HINSTANCE hinst, // handle of the instance containing the image
3086 LPCWSTR lpszName, // name or identifier of image
3087 UINT uType, // type of image
3088 int cxDesired, // desired width
3089 int cyDesired, // desired height
3090 UINT fuLoad // load flags
3091 );
3092 HINSTANCE LoadLibraryW(wchar* lpLibFileName );
3093 HGLOBAL LoadResource(
3094 HMODULE hModule, // resource-module handle
3095 HRSRC hResInfo // resource handle
3096 );
3097 int LoadStringA(
3098 HINSTANCE hInstance,
3099 UINT uID,
3100 LPSTR lpBuffer,
3101 int nBufferMax
3102 );
3103 int LoadStringW(
3104 HINSTANCE hInstance,
3105 UINT uID,
3106 LPWSTR lpBuffer,
3107 int nBufferMax
3108 );
3109 HLOCAL LocalFree(
3110 HLOCAL hMem // handle to local memory object
3111 );
3112 LPVOID LockResource(
3113 HGLOBAL hResData // handle to resource to lock
3114 );
3115 UINT MapVirtualKeyA(
3116 UINT uCode, // virtual-key code or scan code
3117 UINT uMapType // translation to perform
3118 );
3119 UINT MapVirtualKeyW(
3120 UINT uCode, // virtual-key code or scan code
3121 UINT uMapType // translation to perform
3122 );
3123 BOOL MessageBeep(
3124 UINT uType // sound type
3125 );
3126 int MessageBoxW(
3127 HWND hWnd, // handle of owner window
3128 LPCWSTR lpText, // address of text in message box
3129 LPCWSTR lpCaption, // address of title of message box
3130 UINT uType // style of message box
3131 );
3132 HMONITOR MonitorFromWindow(
3133 HWND hwnd, // handle to a window
3134 DWORD dwFlags // flags if no monitor intersects the window
3135 );
3136 DWORD MsgWaitForMultipleObjectsEx(
3137 DWORD nCount, // number of handles in handle array
3138 LPHANDLE pHandles, // pointer to an object-handle array
3139 DWORD dwMilliseconds, // time-out interval in milliseconds
3140 DWORD dwWakeMask, // type of input events to wait for
3141 DWORD dwFlags // wait flags
3142 );
3143 void NotifyWinEvent(
3144 DWORD event,
3145 HWND hwnd,
3146 LONG idObject,
3147 LONG idChild
3148 );
3149 int OffsetRgn(
3150 HRGN hrgn, // handle to region
3151 int nXOffset, // offset along x-axis
3152 int nYOffset // offset along y-axis
3153 );
3154 WINOLEAPI OleInitialize(
3155 LPVOID pvReserved //Reserved; must be NULL.
3156 );
3157 void OleUninitialize();
3158 BOOL OpenClipboard(
3159 HWND hWndNewOwner
3160 );
3161 void OutputDebugStringA(
3162 LPCSTR lpOutputString
3163 );
3164 void OutputDebugStringW(
3165 LPCWSTR lpOutputString
3166 );
3167 BOOL PatBlt(
3168 HDC hdc, // handle to device context
3169 int nXLeft, // x-coord. of upper-left corner of rect. to be filled
3170 int nYLeft, // y-coord. of upper-left corner of rect. to be filled
3171 int nWidth, // width of rectangle to be filled
3172 int nHeight, // height of rectangle to be filled
3173 DWORD dwRop // raster operation code
3174 );
3175 BOOL PeekMessageW(
3176 LPMSG lpMsg, // pointer to structure for message
3177 HWND hWnd, // handle to window
3178 UINT wMsgFilterMin, // first message
3179 UINT wMsgFilterMax, // last message
3180 UINT wRemoveMsg // removal flags
3181 );
3182 BOOL Pie(
3183 HDC hdc, // handle to device context
3184 int nLeftRect, // x-coord of bounding rectangle's upper-left corner
3185 int nTopRect, // y-coord of bounding rectangle's upper-left corner
3186 int nRightRect, // x-coord of bounding rectangle's lower-right corner
3187 int nBottomRect, // y-coord of bounding rectangle's lower-right corner
3188 int nXRadial1, // x-coord of first radial's endpoint
3189 int nYRadial1, // y-coord of first radial's endpoint
3190 int nXRadial2, // x-coord of second radial's endpoint
3191 int nYRadial2 // y-coord of second radial's endpoint
3192 );
3193 BOOL Polygon(
3194 HDC hdc, // handle to device context
3195 POINT *lpPoints, // pointer to polygon's vertices
3196 int nCount // count of polygon's vertices
3197 );
3198 BOOL Polyline(
3199 HDC hdc, // handle to device context
3200 POINT *lppt, // pointer to array containing endpoints
3201 int cPoints // number of points in the array
3202 );
3203 BOOL PostMessageA(
3204 HWND hWnd,
3205 UINT Msg,
3206 WPARAM wParam,
3207 LPARAM lParam
3208 );
3209 BOOL PostMessageW(
3210 HWND hWnd,
3211 UINT Msg,
3212 WPARAM wParam,
3213 LPARAM lParam
3214 );
3215 BOOL PostThreadMessageA(
3216 DWORD idThread,
3217 UINT Msg,
3218 WPARAM wParam,
3219 LPARAM lParam
3220 );
3221 BOOL PostThreadMessageW(
3222 DWORD idThread,
3223 UINT Msg,
3224 WPARAM wParam,
3225 LPARAM lParam
3226 );
3227 BOOL PtInRect(
3228 RECT *lprc, // rectangle
3229 POINT pt // point
3230 );
3231 BOOL PtInRegion(
3232 HRGN hrgn, // handle to region
3233 int X, // x-coordinate of point
3234 int Y // y-coordinate of point
3235 );
3236 UINT RealizePalette(
3237 HDC hdc // handle of device context
3238 );
3239 BOOL RectInRegion(
3240 HRGN hrgn, // handle to region
3241 RECT *lprc // pointer to rectangle
3242 );
3243 BOOL Rectangle(
3244 HDC hdc, // handle to device context
3245 int nLeftRect, // x-coord of bounding rectangle's upper-left corner
3246 int nTopRect, // y-coord of bounding rectangle's upper-left corner
3247 int nRightRect, // x-coord of bounding rectangle's lower-right corner
3248 int nBottomRect // y-coord of bounding rectangle's lower-right corner
3249 );
3250 //alias STDWIN.RedrawWindow RedrawWindow;
3251 LONG RegCloseKey(
3252 HKEY hKey
3253 );
3254 LONG RegEnumKeyExA(
3255 HKEY hKey,
3256 DWORD dwIndex,
3257 LPSTR lpName,
3258 LPDWORD lpcName,
3259 LPDWORD lpReserved,
3260 LPSTR lpClass,
3261 LPDWORD lpcClass,
3262 PFILETIME lpftLastWriteTime
3263 );
3264 LONG RegEnumKeyExW(
3265 HKEY hKey,
3266 DWORD dwIndex,
3267 LPWSTR lpName,
3268 LPDWORD lpcName,
3269 LPDWORD lpReserved,
3270 LPWSTR lpClass,
3271 LPDWORD lpcClass,
3272 PFILETIME lpftLastWriteTime
3273 );
3274 LONG RegOpenKeyExA(
3275 HKEY hKey,
3276 LPSTR lpSubKey,
3277 DWORD ulOptions,
3278 REGSAM samDesired,
3279 PHKEY phkResult
3280 );
3281 LONG RegOpenKeyExW(
3282 HKEY hKey,
3283 LPWSTR lpSubKey,
3284 DWORD ulOptions,
3285 REGSAM samDesired,
3286 PHKEY phkResult
3287 );
3288
3289 LONG RegQueryInfoKeyA(
3290 HKEY hKey,
3291 LPSTR lpClass,
3292 LPDWORD lpcClass,
3293 LPDWORD lpReserved,
3294 LPDWORD lpcSubKeys,
3295 LPDWORD lpcMaxSubKeyLen,
3296 LPDWORD lpcMaxClassLen,
3297 LPDWORD lpcValues,
3298 LPDWORD lpcMaxValueNameLen,
3299 LPDWORD lpcMaxValueLen,
3300 LPDWORD lpcbSecurityDescriptor,
3301 PFILETIME lpftLastWriteTime
3302 );
3303 LONG RegQueryInfoKeyW(
3304 HKEY hKey,
3305 LPWSTR lpClass,
3306 LPDWORD lpcClass,
3307 LPDWORD lpReserved,
3308 LPDWORD lpcSubKeys,
3309 LPDWORD lpcMaxSubKeyLen,
3310 LPDWORD lpcMaxClassLen,
3311 LPDWORD lpcValues,
3312 LPDWORD lpcMaxValueNameLen,
3313 LPDWORD lpcMaxValueLen,
3314 LPDWORD lpcbSecurityDescriptor,
3315 PFILETIME lpftLastWriteTime
3316 );
3317
3318 LONG RegQueryValueExA(
3319 HKEY hKey,
3320 LPCSTR lpValueName,
3321 LPDWORD lpReserved,
3322 LPDWORD lpType,
3323 LPBYTE lpData,
3324 LPDWORD lpcbData
3325 );
3326 LONG RegQueryValueExW(
3327 HKEY hKey,
3328 LPCWSTR lpValueName,
3329 LPDWORD lpReserved,
3330 LPDWORD lpType,
3331 LPBYTE lpData,
3332 LPDWORD lpcbData
3333 );
3334
3335 ATOM RegisterClassA(
3336 WNDCLASSA *lpWndClass
3337 );
3338 ATOM RegisterClassW(
3339 WNDCLASSW *lpWndClass
3340 );
3341 UINT RegisterClipboardFormatA(
3342 LPCSTR lpszFormat
3343 );
3344 UINT RegisterClipboardFormatW(
3345 LPCWSTR lpszFormat
3346 );
3347 UINT RegisterWindowMessageA(
3348 LPCSTR lpString
3349 );
3350 UINT RegisterWindowMessageW(
3351 LPCWSTR lpString
3352 );
3353 BOOL ReleaseCapture();
3354 BOOL RemoveMenu(
3355 HMENU hMenu,
3356 UINT uPosition,
3357 UINT uFlags
3358 );
3359 BOOL RestoreDC(
3360 HDC hdc, // handle to DC
3361 int nSavedDC // restore state
3362 );
3363 //alias STDWIN.RoundRect RoundRect;
3364
3365 // basic
3366 void RtlMoveMemory(void* Destination, void* Source, DWORD Length);
3367 // extends
3368 void RtlMoveMemory(int Destination, void* Source, DWORD Length);
3369 void RtlMoveMemory(void* Destination, int Source, DWORD Length);
3370 void RtlMoveMemory(int Destination, int Source, DWORD Length);
3371
3372 LPITEMIDLIST SHBrowseForFolderA(
3373 BROWSEINFOA* lpbi
3374 );
3375 LPITEMIDLIST SHBrowseForFolderW(
3376 BROWSEINFOW* lpbi
3377 );
3378 version(WinCE){
3379 int SHCreateMenuBar(SHMENUBARINFO* pmb);
3380 }
3381 HRESULT SHGetMalloc(
3382 // LPMALLOC *ppMalloc
3383 LPVOID *ppMalloc
3384 );
3385 BOOL SHGetPathFromIDListA(
3386 LPCITEMIDLIST pidl,
3387 LPSTR pszPath
3388 );
3389 BOOL SHGetPathFromIDListW(
3390 LPCITEMIDLIST pidl,
3391 LPWSTR pszPath
3392 );
3393 version(WinCE)
3394 {
3395 int SHHandleWMSettingChange(HWND hwnd, int wParam, int lParam, void* psai);
3396 int SHRecognizeGesture(void* shrg);
3397 void SHSendBackToFocusWindow(int uMsg, int wp, int lp);
3398 int SHSetAppKeyWndAssoc(byte bVk, HWND hwnd);
3399 int SHSipPreference(HWND hwnd, int st);
3400 }
3401
3402 // USP methods (Unicode Complex Script processor)
3403 HRESULT ScriptBreak(
3404 WCHAR *pwcChars,
3405 int cChars,
3406 SCRIPT_ANALYSIS *psa,
3407 SCRIPT_LOGATTR *psla
3408 );
3409 HRESULT ScriptCPtoX(
3410 int iCP,
3411 BOOL fTrailing,
3412 int cChars,
3413 int cGlyphs,
3414 WORD *pwLogClust,
3415 SCRIPT_VISATTR *psva,
3416 int *piAdvance,
3417 SCRIPT_ANALYSIS *psa,
3418 int *piX
3419 );
3420 HRESULT ScriptCacheGetHeight(
3421 HDC hdc,
3422 SCRIPT_CACHE *psc,
3423 long *tmHeight
3424 );
3425 HRESULT ScriptFreeCache(
3426 SCRIPT_CACHE *psc
3427 );
3428 HRESULT ScriptGetFontProperties(
3429 HDC hdc,
3430 SCRIPT_CACHE *psc,
3431 SCRIPT_FONTPROPERTIES *sfp
3432 );
3433 HRESULT ScriptGetLogicalWidths(
3434 SCRIPT_ANALYSIS *psa,
3435 int cChars,
3436 int cGlyphs,
3437 int *piGlyphWidth,
3438 WORD *pwLogClust,
3439 SCRIPT_VISATTR *psva,
3440 int *piDx
3441 );
3442 HRESULT ScriptGetProperties(
3443 SCRIPT_PROPERTIES ***ppSp,
3444 int *piNumScripts
3445 );
3446 HRESULT ScriptGetCMap(
3447 HDC hdc,
3448 SCRIPT_CACHE* psc,
3449 WCHAR* pwcInChars,
3450 int cChars,
3451 DWORD dwFlags,
3452 WORD* pwOutGlyphs
3453 );
3454 HRESULT ScriptStringAnalyse(
3455 HDC hdc,
3456 void* pString,
3457 int cString,
3458 int cGlyphs,
3459 int iCharset,
3460 DWORD dwFlags,
3461 int iReqWidth,
3462 SCRIPT_CONTROL* psControl,
3463 SCRIPT_STATE* psState,
3464 int* piDx,
3465 SCRIPT_TABDEF* pTabdef,
3466 BYTE* pbInClass,
3467 SCRIPT_STRING_ANALYSIS* pssa
3468 );
3469 HRESULT ScriptStringOut(
3470 SCRIPT_STRING_ANALYSIS ssa,
3471 int iX,
3472 int iY,
3473 UINT uOptions,
3474 RECT* prc,
3475 int iMinSel,
3476 int iMaxSel,
3477 BOOL fDisabled
3478 );
3479 HRESULT ScriptStringFree(
3480 SCRIPT_STRING_ANALYSIS* pssa
3481 );
3482
3483 HRESULT ScriptItemize(
3484 WCHAR *pwcInChars,
3485 int cInChars,
3486 int cMaxItems,
3487 SCRIPT_CONTROL *psControl,
3488 SCRIPT_STATE *psState,
3489 SCRIPT_ITEM *pItems,
3490 int *pcItems
3491 );
3492 HRESULT ScriptLayout(
3493 int cRuns,
3494 BYTE *pbLevel,
3495 int *piVisualToLogical,
3496 int *piLogicalToVisual
3497 );
3498 HRESULT ScriptPlace(
3499 HDC hdc,
3500 SCRIPT_CACHE *psc,
3501 WORD *pwGlyphs,
3502 int cGlyphs,
3503 SCRIPT_VISATTR *psva,
3504 SCRIPT_ANALYSIS *psa,
3505 int *piAdvance,
3506 GOFFSET *pGoffset,
3507 ABC *pABC
3508 );
3509 HRESULT ScriptShape(
3510 HDC hdc, // in
3511 SCRIPT_CACHE *psc, // in/out
3512 WCHAR *pwcChars, //
3513 int cChars,
3514 int cMaxGlyphs,
3515 SCRIPT_ANALYSIS *psa,
3516 WORD *pwOutGlyphs,
3517 WORD *pwLogClust,
3518 SCRIPT_VISATTR *psva,
3519 int *pcGlyphs
3520 );
3521 HRESULT ScriptTextOut(
3522 HDC hdc, // const
3523 SCRIPT_CACHE *psc,
3524 int x,
3525 int y,
3526 UINT fuOptions,
3527 RECT *lprc, // const
3528 SCRIPT_ANALYSIS *psa, // const
3529 WCHAR *pwcReserved, // const
3530 int iReserved,
3531 WORD *pwGlyphs, //
3532 int cGlyphs,
3533 int *piAdvance, // const
3534 int *piJustify, // const
3535 GOFFSET *pGoffset // const
3536 );
3537 HRESULT ScriptXtoCP(
3538 int iX,
3539 int cChars,
3540 int cGlyphs,
3541 WORD *pwLogClust, //
3542 SCRIPT_VISATTR *psva, //
3543 int *piAdvance, //
3544 SCRIPT_ANALYSIS *psa, //
3545 int *piCP,
3546 int *piTrailing
3547 );
3548 UINT SendInput(
3549 UINT nInputs,
3550 LPINPUT pInputs,
3551 int cbSize
3552 );
3553 // the basic
3554 int SendMessageA(HWND hWnd, int msg, int wParam, int lParam );
3555 int SendMessageW(HWND hWnd, int msg, int wParam, int lParam );
3556
3557 int SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, void* lParam );
3558 int SendMessageW(HWND hWnd, UINT Msg, WPARAM wParam, void* lParam );
3559 int SendMessageA(HWND hWnd, UINT Msg, void* wParam, LPARAM lParam );
3560 int SendMessageW(HWND hWnd, UINT Msg, void* wParam, LPARAM lParam );
3561 int SendMessageA(HWND hWnd, UINT Msg, void* wParam, void* lParam );
3562 int SendMessageW(HWND hWnd, UINT Msg, void* wParam, void* lParam );
3563
3564 HWND SetCapture(
3565 HWND hWnd
3566 );
3567 BOOL SetCaretPos(
3568 int X,
3569 int Y
3570 );
3571 HANDLE SetClipboardData(
3572 UINT uFormat,
3573 HANDLE hMem
3574 );
3575 UINT SetDIBColorTable(
3576 HDC hdc, // handle to device context whose DIB is of interest
3577 UINT uStartIndex, // color table index of first entry to set
3578 UINT cEntries, // number of color table entries to set
3579 RGBQUAD *pColors // pointer to array of color table entries
3580 );
3581 UINT SetErrorMode(
3582 UINT uMode
3583 );
3584 BOOL SetEvent(
3585 HANDLE hEvent // handle to event object
3586 );
3587 void SetLastError(
3588 DWORD dwErrCode
3589 );
3590 DWORD SetLayout(
3591 HDC hdc, // handle to DC
3592 DWORD dwLayout // layout options
3593 );
3594 BOOL SetMenu(
3595 HWND hWnd,
3596 HMENU hMenu
3597 );
3598 BOOL SetMenuDefaultItem(
3599 HMENU hMenu,
3600 UINT uItem,
3601 UINT fByPos
3602 );
3603 BOOL SetMenuInfo(
3604 HMENU hmenu,
3605 LPCMENUINFO lpcmi
3606 );
3607 BOOL SetMenuItemInfoA(
3608 HMENU hMenu,
3609 UINT uItem,
3610 BOOL fByPosition,
3611 LPMENUITEMINFOA lpmii
3612 );
3613 BOOL SetMenuItemInfoW(
3614 HMENU hMenu,
3615 UINT uItem,
3616 BOOL fByPosition,
3617 LPMENUITEMINFOW lpmii
3618 );
3619 UINT SetPaletteEntries(
3620 HPALETTE hpal, // handle to logical palette
3621 UINT iStart, // index of first entry to set
3622 UINT cEntries, // number of entries to set
3623 PALETTEENTRY *lppe // array of palette entries
3624 );
3625 HWND SetParent(
3626 HWND hWndChild,
3627 HWND hWndNewParent
3628 );
3629 // alias STDWIN.SetPixel SetPixel;
3630 // alias STDWIN.SetROP2 SetROP2;
3631 BOOL SetRect(
3632 LPRECT lprc, // rectangle
3633 int xLeft, // left side
3634 int yTop, // top side
3635 int xRight, // right side
3636 int yBottom // bottom side
3637 );
3638 // alias STDWIN.SetRectRgn SetRectRgn;
3639 int SetScrollInfo(
3640 HWND hwnd,
3641 int fnBar,
3642 LPCSCROLLINFO lpsi,
3643 BOOL fRedraw
3644 );
3645 UINT_PTR SetTimer(
3646 HWND hWnd,
3647 UINT_PTR nIDEvent,
3648 UINT uElapse,
3649 TIMERPROC lpTimerFunc
3650 );
3651 LONG SetWindowLongA(
3652 HWND hWnd,
3653 int nIndex,
3654 LONG dwNewLong
3655 );
3656 LONG SetWindowLongW(
3657 HWND hWnd,
3658 int nIndex,
3659 LONG dwNewLong
3660 );
3661
3662 BOOL SetWindowPlacement(
3663 HWND hWnd,
3664 WINDOWPLACEMENT *lpwndpl
3665 );
3666 BOOL SetWindowPos(
3667 HWND hWnd, // handle to window
3668 HWND hWndInsertAfter, // placement-order handle
3669 int X, // horizontal position
3670 int Y, // vertical position
3671 int cx, // width
3672 int cy, // height
3673 UINT uFlags // window-positioning flags
3674 );
3675 BOOL SetWindowTextA(
3676 HWND hWnd,
3677 LPCSTR lpString
3678 );
3679 BOOL SetWindowTextW(
3680 HWND hWnd,
3681 LPCWSTR lpString
3682 );
3683 HHOOK SetWindowsHookExA(
3684 int idHook, // type of hook to install
3685 HOOKPROC lpfn, // address of hook procedure
3686 HINSTANCE hMod, // handle to application instance
3687 DWORD dwThreadId // identity of thread to install hook for
3688 );
3689 HHOOK SetWindowsHookExW(
3690 int idHook, // type of hook to install
3691 HOOKPROC lpfn, // address of hook procedure
3692 HINSTANCE hMod, // handle to application instance
3693 DWORD dwThreadId // identity of thread to install hook for
3694 );
3695 BOOL ShellExecuteExA(
3696 LPSHELLEXECUTEINFOA lpExecInfo
3697 );
3698 BOOL ShellExecuteExW(
3699 LPSHELLEXECUTEINFOW lpExecInfo
3700 );
3701 BOOL Shell_NotifyIconA(
3702 DWORD dwMessage,
3703 PNOTIFYICONDATAA lpdata
3704 );
3705 BOOL Shell_NotifyIconW(
3706 DWORD dwMessage,
3707 PNOTIFYICONDATAW lpdata
3708 );
3709 BOOL ShowOwnedPopups(
3710 HWND hWnd,
3711 BOOL fShow
3712 );
3713 version(WinCE)
3714 {
3715 BOOL SipGetInfo(
3716 SIPINFO *pSipInfo
3717 );
3718 }
3719 DWORD SizeofResource(
3720 HMODULE hModule, // resource-module handle
3721 HRSRC hResInfo // resource handle
3722 );
3723 void Sleep(
3724 DWORD dwMilliseconds
3725 );
3726 int StartDocA(
3727 HDC hdc, // handle to DC
3728 DOCINFOA* lpdi // contains file names
3729 );
3730 int StartDocW(
3731 HDC hdc, // handle to DC
3732 DOCINFOW* lpdi // contains file names
3733 );
3734 int StartPage(
3735 HDC hDC // handle to DC
3736 );
3737 // alias STDWIN.StretchBlt StretchBlt;
3738 BOOL SystemParametersInfoA(
3739 UINT uiAction,
3740 UINT uiParam,
3741 PVOID pvParam,
3742 UINT fWinIni
3743 );
3744 BOOL SystemParametersInfoW(
3745 UINT uiAction,
3746 UINT uiParam,
3747 PVOID pvParam,
3748 UINT fWinIni
3749 );
3750 int ToAscii(
3751 UINT uVirtKey,
3752 UINT uScanCode,
3753 PBYTE lpKeyState,
3754 LPWORD lpChar,
3755 UINT uFlags
3756 );
3757 int ToUnicode(
3758 UINT wVirtKey,
3759 UINT wScanCode,
3760 PBYTE lpKeyState,
3761 LPWSTR pwszBuff,
3762 int cchBuff,
3763 UINT wFlags
3764 );
3765 BOOL TrackMouseEvent(
3766 LPTRACKMOUSEEVENT lpEventTrack // pointer to a TRACKMOUSEEVENT structure
3767 );
3768 int TranslateAcceleratorA(
3769 HWND hWnd, // handle to destination window
3770 HACCEL hAccTable, // handle to accelerator table
3771 LPMSG lpMsg // address of structure with message
3772 );
3773 int TranslateAcceleratorW(
3774 HWND hWnd, // handle to destination window
3775 HACCEL hAccTable, // handle to accelerator table
3776 LPMSG lpMsg // address of structure with message
3777 );
3778 UINT TranslateCharsetInfo(
3779 DWORD *lpSrc,
3780 LPCHARSETINFO lpCs,
3781 DWORD dwFlags
3782 );
3783 BOOL TranslateMDISysAccel(
3784 HWND hWndClient,
3785 LPMSG lpMsg
3786 );
3787 BOOL TranslateMessage(
3788 MSG *lpMsg // address of structure with message
3789 );
3790 version(WinCE)
3791 {
3792 BOOL TransparentImage(
3793 HDC hdcDest,
3794 LONG DstX,
3795 LONG DstY,
3796 LONG DstCx,
3797 LONG DstCy,
3798 HANDLE hSrc,
3799 LONG SrcX,
3800 LONG SrcY,
3801 LONG SrcCx,
3802 LONG SrcCy,
3803 COLORREF TransparentColor
3804 );
3805 }
3806 BOOL UnhookWindowsHookEx(
3807 HHOOK hhk // handle to hook procedure to remove
3808 );
3809 BOOL UnregisterClassA(
3810 LPCSTR lpClassName, // address of class name string
3811 HINSTANCE hInstance // handle of application instance
3812 );
3813 BOOL UnregisterClassW(
3814 LPCWSTR lpClassName, // address of class name string
3815 HINSTANCE hInstance // handle of application instance
3816 );
3817 SHORT VkKeyScanA(char ch);
3818 SHORT VkKeyScanW(wchar ch);
3819 BOOL WaitMessage();
3820
3821 BOOL GetScrollBarInfo(
3822 HWND hwnd,
3823 LONG idObject,
3824 PSCROLLBARINFO psbi
3825 );
3826
3827 }
3828
3829 extern (C)
3830 {
3831 int wcslen(wchar* string);
3832 }