mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-27 06:43:32 +00:00
1131 lines
33 KiB
C
1131 lines
33 KiB
C
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/*
|
|
* This file contains a series of C-style function prototypes for A/W-suffixed
|
|
* Win32 APIs defined by windows.h.
|
|
*
|
|
* This file is processed by make-windows-h-wrapper.py to generate a wrapper for
|
|
* the header which removes the defines usually implementing these aliases.
|
|
*
|
|
* Wrappers defined in this file will have the 'stdcall' calling convention,
|
|
* will be defined as 'inline', and will only be defined if the corresponding
|
|
* #define directive has not been #undef-ed.
|
|
*
|
|
* NOTE: This is *NOT* a real C header, but rather an input to the avove script.
|
|
* Only basic declarations in the form found here are allowed.
|
|
*/
|
|
|
|
LPTSTR GetCommandLine();
|
|
|
|
BOOL FreeEnvironmentStrings(LPTCH);
|
|
|
|
DWORD GetEnvironmentVariable(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL SetEnvironmentVariable(LPCTSTR, LPCTSTR);
|
|
|
|
DWORD ExpandEnvironmentStrings(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL SetCurrentDirectory(LPCTSTR);
|
|
|
|
DWORD GetCurrentDirectory(DWORD, LPTSTR);
|
|
|
|
DWORD SearchPath(LPCTSTR, LPCTSTR, LPCTSTR, DWORD, LPTSTR, LPTSTR*);
|
|
|
|
BOOL NeedCurrentDirectoryForExePath(LPCTSTR);
|
|
|
|
BOOL CreateDirectory(LPCTSTR, LPSECURITY_ATTRIBUTES);
|
|
|
|
HANDLE CreateFile(LPCTSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD,
|
|
HANDLE);
|
|
|
|
BOOL DeleteFile(LPCTSTR);
|
|
|
|
HANDLE FindFirstChangeNotification(LPCTSTR, BOOL, DWORD);
|
|
|
|
HANDLE FindFirstFile(LPCTSTR, LPWIN32_FIND_DATA);
|
|
|
|
HANDLE FindFirstFileEx(LPCTSTR, FINDEX_INFO_LEVELS, LPVOID, FINDEX_SEARCH_OPS,
|
|
LPVOID, DWORD);
|
|
|
|
BOOL FindNextFile(HANDLE, LPWIN32_FIND_DATA);
|
|
|
|
BOOL GetDiskFreeSpace(LPCTSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD);
|
|
|
|
BOOL GetDiskFreeSpaceEx(LPCTSTR, PULARGE_INTEGER, PULARGE_INTEGER,
|
|
PULARGE_INTEGER);
|
|
|
|
UINT GetDriveType(LPCTSTR);
|
|
|
|
DWORD GetFileAttributes(LPCTSTR);
|
|
|
|
BOOL GetFileAttributesEx(LPCTSTR, GET_FILEEX_INFO_LEVELS, LPVOID);
|
|
|
|
DWORD GetFinalPathNameByHandle(HANDLE, LPTSTR, DWORD, DWORD);
|
|
|
|
DWORD GetFullPathName(LPCTSTR, DWORD, LPTSTR, LPTSTR*);
|
|
|
|
DWORD GetLongPathName(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL RemoveDirectory(LPCTSTR);
|
|
|
|
BOOL SetFileAttributes(LPCTSTR, DWORD);
|
|
|
|
DWORD GetCompressedFileSize(LPCTSTR, LPDWORD);
|
|
|
|
DWORD GetTempPath(DWORD, LPTSTR);
|
|
|
|
BOOL GetVolumeInformation(LPCTSTR, LPTSTR, DWORD, LPDWORD, LPDWORD, LPDWORD,
|
|
LPTSTR, DWORD);
|
|
|
|
UINT GetTempFileName(LPCTSTR, LPCTSTR, UINT, LPTSTR);
|
|
|
|
void OutputDebugString(LPCTSTR);
|
|
|
|
void FatalAppExit(UINT, LPCTSTR);
|
|
|
|
HANDLE CreateMutex(LPSECURITY_ATTRIBUTES, BOOL, LPCTSTR);
|
|
|
|
HANDLE CreateEvent(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCTSTR);
|
|
|
|
HANDLE OpenEvent(DWORD, BOOL, LPCTSTR);
|
|
|
|
HANDLE CreateMutexEx(LPSECURITY_ATTRIBUTES, LPCTSTR, DWORD, DWORD);
|
|
|
|
HANDLE CreateEventEx(LPSECURITY_ATTRIBUTES, LPCTSTR, DWORD, DWORD);
|
|
|
|
BOOL CreateProcess(LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTES,
|
|
LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCTSTR,
|
|
LPSTARTUPINFO, LPPROCESS_INFORMATION);
|
|
|
|
BOOL CreateProcessAsUser(HANDLE, LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTES,
|
|
LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCTSTR,
|
|
LPSTARTUPINFO, LPPROCESS_INFORMATION);
|
|
|
|
UINT GetSystemDirectory(LPTSTR, UINT);
|
|
|
|
UINT GetWindowsDirectory(LPTSTR, UINT);
|
|
|
|
UINT GetSystemWindowsDirectory(LPTSTR, UINT);
|
|
|
|
BOOL GetComputerNameEx(COMPUTER_NAME_FORMAT, LPTSTR, LPDWORD);
|
|
|
|
BOOL GetVersionEx(LPOSVERSIONINFO);
|
|
|
|
BOOL SetComputerName(LPCTSTR);
|
|
|
|
BOOL SetComputerNameEx(COMPUTER_NAME_FORMAT, LPCTSTR);
|
|
|
|
BOOL LoadEnclaveImage(LPVOID, LPCTSTR);
|
|
|
|
UINT GetSystemWow64Directory(LPTSTR, UINT);
|
|
|
|
DWORD GetModuleFileName(HMODULE, LPTSTR, DWORD);
|
|
|
|
HMODULE GetModuleHandle(LPCTSTR);
|
|
|
|
BOOL GetModuleHandleEx(DWORD, LPCTSTR, HMODULE*);
|
|
|
|
HMODULE LoadLibraryEx(LPCTSTR, HANDLE, DWORD);
|
|
|
|
int LoadString(HINSTANCE, UINT, LPTSTR, int);
|
|
|
|
BOOL EnumResourceLanguagesEx(HMODULE, LPCTSTR, LPCTSTR, ENUMRESLANGPROC,
|
|
LONG_PTR, DWORD, LANGID);
|
|
|
|
BOOL EnumResourceNamesEx(HMODULE, LPCTSTR, ENUMRESNAMEPROC, LONG_PTR, DWORD,
|
|
LANGID);
|
|
|
|
BOOL EnumResourceTypesEx(HMODULE, ENUMRESTYPEPROC, LONG_PTR, DWORD, LANGID);
|
|
|
|
HMODULE LoadLibrary(LPCTSTR);
|
|
|
|
BOOL GetBinaryType(LPCTSTR, LPDWORD);
|
|
|
|
DWORD GetShortPathName(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
DWORD GetLongPathNameTransacted(LPCTSTR, LPTSTR, DWORD, HANDLE);
|
|
|
|
BOOL SetEnvironmentStrings(LPTCH);
|
|
|
|
BOOL SetFileShortName(HANDLE, LPCTSTR);
|
|
|
|
DWORD FormatMessage(DWORD, LPCVOID, DWORD, DWORD, LPTSTR, DWORD, va_list*);
|
|
|
|
HANDLE CreateMailslot(LPCTSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES);
|
|
|
|
BOOL EncryptFile(LPCTSTR);
|
|
|
|
BOOL DecryptFile(LPCTSTR, DWORD);
|
|
|
|
BOOL FileEncryptionStatus(LPCTSTR, LPDWORD);
|
|
|
|
DWORD OpenEncryptedFileRaw(LPCTSTR, ULONG, PVOID*);
|
|
|
|
HANDLE OpenMutex(DWORD, BOOL, LPCTSTR);
|
|
|
|
HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCTSTR);
|
|
|
|
HANDLE OpenSemaphore(DWORD, BOOL, LPCTSTR);
|
|
|
|
HANDLE CreateWaitableTimer(LPSECURITY_ATTRIBUTES, BOOL, LPCTSTR);
|
|
|
|
HANDLE OpenWaitableTimer(DWORD, BOOL, LPCTSTR);
|
|
|
|
HANDLE CreateSemaphoreEx(LPSECURITY_ATTRIBUTES, LONG, LONG, LPCTSTR, DWORD,
|
|
DWORD);
|
|
|
|
HANDLE CreateWaitableTimerEx(LPSECURITY_ATTRIBUTES, LPCTSTR, DWORD, DWORD);
|
|
|
|
HANDLE CreateFileMapping(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD,
|
|
LPCTSTR);
|
|
|
|
HANDLE CreateFileMappingNuma(HANDLE, LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD,
|
|
LPCTSTR, DWORD);
|
|
|
|
HANDLE OpenFileMapping(DWORD, BOOL, LPCTSTR);
|
|
|
|
DWORD GetLogicalDriveStrings(DWORD, LPTSTR);
|
|
|
|
void GetStartupInfo(LPSTARTUPINFO);
|
|
|
|
DWORD GetFirmwareEnvironmentVariable(LPCTSTR, LPCTSTR, PVOID, DWORD);
|
|
|
|
BOOL SetFirmwareEnvironmentVariable(LPCTSTR, LPCTSTR, PVOID, DWORD);
|
|
|
|
HRSRC FindResource(HMODULE, LPCTSTR, LPCTSTR);
|
|
|
|
HRSRC FindResourceEx(HMODULE, LPCTSTR, LPCTSTR, WORD);
|
|
|
|
BOOL EnumResourceTypes(HMODULE, ENUMRESTYPEPROC, LONG_PTR);
|
|
|
|
BOOL EnumResourceNames(HMODULE, LPCTSTR, ENUMRESNAMEPROC, LONG_PTR);
|
|
|
|
BOOL EnumResourceLanguages(HMODULE, LPCTSTR, LPCTSTR, ENUMRESLANGPROC,
|
|
LONG_PTR);
|
|
|
|
HANDLE BeginUpdateResource(LPCTSTR, BOOL);
|
|
|
|
BOOL UpdateResource(HANDLE, LPCTSTR, LPCTSTR, WORD, LPVOID, DWORD);
|
|
|
|
BOOL EndUpdateResource(HANDLE, BOOL);
|
|
|
|
ATOM GlobalAddAtom(LPCTSTR);
|
|
|
|
ATOM GlobalAddAtomEx(LPCTSTR, DWORD);
|
|
|
|
ATOM GlobalFindAtom(LPCTSTR);
|
|
|
|
UINT GlobalGetAtomName(ATOM, LPTSTR, int);
|
|
|
|
ATOM AddAtom(LPCTSTR);
|
|
|
|
ATOM FindAtom(LPCTSTR);
|
|
|
|
UINT GetAtomName(ATOM, LPTSTR, int);
|
|
|
|
UINT GetProfileInt(LPCTSTR, LPCTSTR, INT);
|
|
|
|
DWORD GetProfileString(LPCTSTR, LPCTSTR, LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL WriteProfileString(LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
DWORD GetProfileSection(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL WriteProfileSection(LPCTSTR, LPCTSTR);
|
|
|
|
UINT GetPrivateProfileInt(LPCTSTR, LPCTSTR, INT, LPCTSTR);
|
|
|
|
DWORD GetPrivateProfileString(LPCTSTR, LPCTSTR, LPCTSTR, LPTSTR, DWORD,
|
|
LPCTSTR);
|
|
|
|
BOOL WritePrivateProfileString(LPCTSTR, LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
DWORD GetPrivateProfileSection(LPCTSTR, LPTSTR, DWORD, LPCTSTR);
|
|
|
|
BOOL WritePrivateProfileSection(LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
DWORD GetPrivateProfileSectionNames(LPTSTR, DWORD, LPCTSTR);
|
|
|
|
BOOL GetPrivateProfileStruct(LPCTSTR, LPCTSTR, LPVOID, UINT, LPCTSTR);
|
|
|
|
BOOL WritePrivateProfileStruct(LPCTSTR, LPCTSTR, LPVOID, UINT, LPCTSTR);
|
|
|
|
BOOL SetDllDirectory(LPCTSTR);
|
|
|
|
DWORD GetDllDirectory(DWORD, LPTSTR);
|
|
|
|
BOOL CreateDirectoryEx(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES);
|
|
|
|
BOOL CreateDirectoryTransacted(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES, HANDLE);
|
|
|
|
BOOL RemoveDirectoryTransacted(LPCTSTR, HANDLE);
|
|
|
|
DWORD GetFullPathNameTransacted(LPCTSTR, DWORD, LPTSTR, LPTSTR*, HANDLE);
|
|
|
|
BOOL DefineDosDevice(DWORD, LPCTSTR, LPCTSTR);
|
|
|
|
DWORD QueryDosDevice(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
HANDLE CreateFileTransacted(LPCTSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD,
|
|
DWORD, HANDLE, HANDLE, PUSHORT, PVOID);
|
|
|
|
BOOL SetFileAttributesTransacted(LPCTSTR, DWORD, HANDLE);
|
|
|
|
BOOL GetFileAttributesTransacted(LPCTSTR, GET_FILEEX_INFO_LEVELS, LPVOID,
|
|
HANDLE);
|
|
|
|
DWORD GetCompressedFileSizeTransacted(LPCTSTR, LPDWORD, HANDLE);
|
|
|
|
BOOL DeleteFileTransacted(LPCTSTR, HANDLE);
|
|
|
|
BOOL CheckNameLegalDOS8Dot3(LPCTSTR, LPSTR, DWORD, PBOOL, PBOOL);
|
|
|
|
HANDLE FindFirstFileTransacted(LPCTSTR, FINDEX_INFO_LEVELS, LPVOID,
|
|
FINDEX_SEARCH_OPS, LPVOID, DWORD, HANDLE);
|
|
|
|
BOOL CopyFile(LPCTSTR, LPCTSTR, BOOL);
|
|
|
|
BOOL CopyFileEx(LPCTSTR, LPCTSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL, DWORD);
|
|
|
|
BOOL CopyFileTransacted(LPCTSTR, LPCTSTR, LPPROGRESS_ROUTINE, LPVOID, LPBOOL,
|
|
DWORD, HANDLE);
|
|
|
|
BOOL MoveFile(LPCTSTR, LPCTSTR);
|
|
|
|
BOOL MoveFileEx(LPCTSTR, LPCTSTR, DWORD);
|
|
|
|
BOOL MoveFileWithProgress(LPCTSTR, LPCTSTR, LPPROGRESS_ROUTINE, LPVOID, DWORD);
|
|
|
|
BOOL MoveFileTransacted(LPCTSTR, LPCTSTR, LPPROGRESS_ROUTINE, LPVOID, DWORD,
|
|
HANDLE);
|
|
|
|
BOOL ReplaceFile(LPCTSTR, LPCTSTR, LPCTSTR, DWORD, LPVOID, LPVOID);
|
|
|
|
BOOL CreateHardLink(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES);
|
|
|
|
BOOL CreateHardLinkTransacted(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES, HANDLE);
|
|
|
|
HANDLE CreateNamedPipe(LPCTSTR, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD,
|
|
LPSECURITY_ATTRIBUTES);
|
|
|
|
BOOL GetNamedPipeHandleState(HANDLE, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPTSTR,
|
|
DWORD);
|
|
|
|
BOOL CallNamedPipe(LPCTSTR, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, DWORD);
|
|
|
|
BOOL WaitNamedPipe(LPCTSTR, DWORD);
|
|
|
|
BOOL GetNamedPipeClientComputerName(HANDLE, LPTSTR, ULONG);
|
|
|
|
BOOL SetVolumeLabel(LPCTSTR, LPCTSTR);
|
|
|
|
BOOL ClearEventLog(HANDLE, LPCTSTR);
|
|
|
|
BOOL BackupEventLog(HANDLE, LPCTSTR);
|
|
|
|
HANDLE OpenEventLog(LPCTSTR, LPCTSTR);
|
|
|
|
HANDLE RegisterEventSource(LPCTSTR, LPCTSTR);
|
|
|
|
HANDLE OpenBackupEventLog(LPCTSTR, LPCTSTR);
|
|
|
|
BOOL ReadEventLog(HANDLE, DWORD, DWORD, LPVOID, DWORD, DWORD*, DWORD*);
|
|
|
|
BOOL ReportEvent(HANDLE, WORD, WORD, DWORD, PSID, WORD, DWORD, LPCTSTR*,
|
|
LPVOID);
|
|
|
|
BOOL AccessCheckAndAuditAlarm(LPCTSTR, LPVOID, LPTSTR, LPTSTR,
|
|
PSECURITY_DESCRIPTOR, DWORD, PGENERIC_MAPPING,
|
|
BOOL, LPDWORD, LPBOOL, LPBOOL);
|
|
|
|
BOOL AccessCheckByTypeAndAuditAlarm(LPCTSTR, LPVOID, LPCTSTR, LPCTSTR,
|
|
PSECURITY_DESCRIPTOR, PSID, DWORD,
|
|
AUDIT_EVENT_TYPE, DWORD, POBJECT_TYPE_LIST,
|
|
DWORD, PGENERIC_MAPPING, BOOL, LPDWORD,
|
|
LPBOOL, LPBOOL);
|
|
|
|
BOOL AccessCheckByTypeResultListAndAuditAlarm(LPCTSTR, LPVOID, LPCTSTR, LPCTSTR,
|
|
PSECURITY_DESCRIPTOR, PSID, DWORD,
|
|
AUDIT_EVENT_TYPE, DWORD,
|
|
POBJECT_TYPE_LIST, DWORD,
|
|
PGENERIC_MAPPING, BOOL, LPDWORD,
|
|
LPDWORD, LPBOOL);
|
|
|
|
BOOL AccessCheckByTypeResultListAndAuditAlarmByHandle(
|
|
LPCTSTR, LPVOID, HANDLE, LPCTSTR, LPCTSTR, PSECURITY_DESCRIPTOR, PSID,
|
|
DWORD, AUDIT_EVENT_TYPE, DWORD, POBJECT_TYPE_LIST, DWORD, PGENERIC_MAPPING,
|
|
BOOL, LPDWORD, LPDWORD, LPBOOL);
|
|
|
|
BOOL ObjectOpenAuditAlarm(LPCTSTR, LPVOID, LPTSTR, LPTSTR, PSECURITY_DESCRIPTOR,
|
|
HANDLE, DWORD, DWORD, PPRIVILEGE_SET, BOOL, BOOL,
|
|
LPBOOL);
|
|
|
|
BOOL ObjectPrivilegeAuditAlarm(LPCTSTR, LPVOID, HANDLE, DWORD, PPRIVILEGE_SET,
|
|
BOOL);
|
|
|
|
BOOL ObjectCloseAuditAlarm(LPCTSTR, LPVOID, BOOL);
|
|
|
|
BOOL ObjectDeleteAuditAlarm(LPCTSTR, LPVOID, BOOL);
|
|
|
|
BOOL PrivilegedServiceAuditAlarm(LPCTSTR, LPCTSTR, HANDLE, PPRIVILEGE_SET,
|
|
BOOL);
|
|
|
|
BOOL SetFileSecurity(LPCTSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR);
|
|
|
|
BOOL GetFileSecurity(LPCTSTR, SECURITY_INFORMATION, PSECURITY_DESCRIPTOR, DWORD,
|
|
LPDWORD);
|
|
|
|
BOOL IsBadStringPtr(LPCTSTR, UINT_PTR);
|
|
|
|
BOOL LookupAccountSid(LPCTSTR, PSID, LPTSTR, LPDWORD, LPTSTR, LPDWORD,
|
|
PSID_NAME_USE);
|
|
|
|
BOOL LookupAccountName(LPCTSTR, LPCTSTR, PSID, LPDWORD, LPTSTR, LPDWORD,
|
|
PSID_NAME_USE);
|
|
|
|
BOOL LookupAccountNameLocal(LPCTSTR, PSID, LPDWORD, LPTSTR, LPDWORD,
|
|
PSID_NAME_USE);
|
|
|
|
BOOL LookupAccountSidLocal(PSID, LPTSTR, LPDWORD, LPTSTR, LPDWORD,
|
|
PSID_NAME_USE);
|
|
|
|
BOOL LookupPrivilegeValue(LPCTSTR, LPCTSTR, PLUID);
|
|
|
|
BOOL LookupPrivilegeName(LPCTSTR, PLUID, LPTSTR, LPDWORD);
|
|
|
|
BOOL LookupPrivilegeDisplayName(LPCTSTR, LPCTSTR, LPTSTR, LPDWORD, LPDWORD);
|
|
|
|
BOOL BuildCommDCB(LPCTSTR, LPDCB);
|
|
|
|
BOOL BuildCommDCBAndTimeouts(LPCTSTR, LPDCB, LPCOMMTIMEOUTS);
|
|
|
|
BOOL CommConfigDialog(LPCTSTR, HWND, LPCOMMCONFIG);
|
|
|
|
BOOL GetDefaultCommConfig(LPCTSTR, LPCOMMCONFIG, LPDWORD);
|
|
|
|
BOOL SetDefaultCommConfig(LPCTSTR, LPCOMMCONFIG, DWORD);
|
|
|
|
BOOL GetComputerName(LPTSTR, LPDWORD);
|
|
|
|
BOOL DnsHostnameToComputerName(LPCTSTR, LPTSTR, LPDWORD);
|
|
|
|
BOOL GetUserName(LPTSTR, LPDWORD);
|
|
|
|
BOOL LogonUser(LPCTSTR, LPCTSTR, LPCTSTR, DWORD, DWORD, PHANDLE);
|
|
|
|
BOOL LogonUserEx(LPCTSTR, LPCTSTR, LPCTSTR, DWORD, DWORD, PHANDLE, PSID*,
|
|
PVOID*, LPDWORD, PQUOTA_LIMITS);
|
|
|
|
HANDLE CreatePrivateNamespace(LPSECURITY_ATTRIBUTES, LPVOID, LPCTSTR);
|
|
|
|
HANDLE OpenPrivateNamespace(LPVOID, LPCTSTR);
|
|
|
|
HANDLE CreateBoundaryDescriptor(LPCTSTR, ULONG);
|
|
|
|
BOOL GetCurrentHwProfile(LPHW_PROFILE_INFO);
|
|
|
|
BOOL VerifyVersionInfo(LPOSVERSIONINFOEX, DWORD, DWORDLONG);
|
|
|
|
HANDLE CreateJobObject(LPSECURITY_ATTRIBUTES, LPCTSTR);
|
|
|
|
HANDLE OpenJobObject(DWORD, BOOL, LPCTSTR);
|
|
|
|
HANDLE FindFirstVolume(LPTSTR, DWORD);
|
|
|
|
BOOL FindNextVolume(HANDLE, LPTSTR, DWORD);
|
|
|
|
HANDLE FindFirstVolumeMountPoint(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL FindNextVolumeMountPoint(HANDLE, LPTSTR, DWORD);
|
|
|
|
BOOL SetVolumeMountPoint(LPCTSTR, LPCTSTR);
|
|
|
|
BOOL DeleteVolumeMountPoint(LPCTSTR);
|
|
|
|
BOOL GetVolumeNameForVolumeMountPoint(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL GetVolumePathName(LPCTSTR, LPTSTR, DWORD);
|
|
|
|
BOOL GetVolumePathNamesForVolumeName(LPCTSTR, LPTCH, DWORD, PDWORD);
|
|
|
|
HANDLE CreateActCtx(PCACTCTX);
|
|
|
|
BOOL FindActCtxSectionString(DWORD, const GUID*, ULONG, LPCTSTR,
|
|
PACTCTX_SECTION_KEYED_DATA);
|
|
|
|
BOOLEAN CreateSymbolicLink(LPCTSTR, LPCTSTR, DWORD);
|
|
|
|
BOOLEAN CreateSymbolicLinkTransacted(LPCTSTR, LPCTSTR, DWORD, HANDLE);
|
|
|
|
int AddFontResource(LPCTSTR);
|
|
|
|
HMETAFILE CopyMetaFile(HMETAFILE, LPCTSTR);
|
|
|
|
HDC CreateDC(LPCTSTR, LPCTSTR, LPCTSTR, const DEVMODE*);
|
|
|
|
HFONT CreateFontIndirect(const LOGFONT*);
|
|
|
|
HFONT CreateFont(int, int, int, int, int, DWORD, DWORD, DWORD, DWORD, DWORD,
|
|
DWORD, DWORD, DWORD, LPCTSTR);
|
|
|
|
HDC CreateIC(LPCTSTR, LPCTSTR, LPCTSTR, const DEVMODE*);
|
|
|
|
HDC CreateMetaFile(LPCTSTR);
|
|
|
|
BOOL CreateScalableFontResource(DWORD, LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
int DeviceCapabilities(LPCTSTR, LPCTSTR, WORD, LPTSTR, const DEVMODE*);
|
|
|
|
int EnumFontFamiliesEx(HDC, LPLOGFONT, FONTENUMPROC, LPARAM, DWORD);
|
|
|
|
int EnumFontFamilies(HDC, LPCTSTR, FONTENUMPROC, LPARAM);
|
|
|
|
int EnumFonts(HDC, LPCTSTR, FONTENUMPROC, LPARAM);
|
|
|
|
BOOL GetCharWidth(HDC, UINT, UINT, LPINT);
|
|
|
|
BOOL GetCharWidth32(HDC, UINT, UINT, LPINT);
|
|
|
|
BOOL GetCharWidthFloat(HDC, UINT, UINT, PFLOAT);
|
|
|
|
BOOL GetCharABCWidths(HDC, UINT, UINT, LPABC);
|
|
|
|
BOOL GetCharABCWidthsFloat(HDC, UINT, UINT, LPABCFLOAT);
|
|
|
|
DWORD GetGlyphOutline(HDC, UINT, UINT, LPGLYPHMETRICS, DWORD, LPVOID,
|
|
const MAT2*);
|
|
|
|
HMETAFILE GetMetaFile(LPCTSTR);
|
|
|
|
UINT GetOutlineTextMetrics(HDC, UINT, LPOUTLINETEXTMETRIC);
|
|
|
|
BOOL GetTextExtentPoint(HDC, LPCTSTR, int, LPSIZE);
|
|
|
|
BOOL GetTextExtentPoint32(HDC, LPCTSTR, int, LPSIZE);
|
|
|
|
BOOL GetTextExtentExPoint(HDC, LPCTSTR, int, int, LPINT, LPINT, LPSIZE);
|
|
|
|
DWORD GetCharacterPlacement(HDC, LPCTSTR, int, int, LPGCP_RESULTS, DWORD);
|
|
|
|
DWORD GetGlyphIndices(HDC, LPCTSTR, int, LPWORD, DWORD);
|
|
|
|
int AddFontResourceEx(LPCTSTR, DWORD, PVOID);
|
|
|
|
BOOL RemoveFontResourceEx(LPCTSTR, DWORD, PVOID);
|
|
|
|
HFONT CreateFontIndirectEx(const ENUMLOGFONTEXDV*);
|
|
|
|
HDC ResetDC(HDC, const DEVMODE*);
|
|
|
|
BOOL RemoveFontResource(LPCTSTR);
|
|
|
|
HENHMETAFILE CopyEnhMetaFile(HENHMETAFILE, LPCTSTR);
|
|
|
|
HDC CreateEnhMetaFile(HDC, LPCTSTR, const RECT*, LPCTSTR);
|
|
|
|
HENHMETAFILE GetEnhMetaFile(LPCTSTR);
|
|
|
|
UINT GetEnhMetaFileDescription(HENHMETAFILE, UINT, LPTSTR);
|
|
|
|
BOOL GetTextMetrics(HDC, LPTEXTMETRIC);
|
|
|
|
int StartDoc(HDC, const DOCINFO*);
|
|
|
|
int GetObject(HANDLE, int, LPVOID);
|
|
|
|
BOOL TextOut(HDC, int, int, LPCTSTR, int);
|
|
|
|
BOOL ExtTextOut(HDC, int, int, UINT, const RECT*, LPCTSTR, UINT, const INT*);
|
|
|
|
BOOL PolyTextOut(HDC, const POLYTEXT*, int);
|
|
|
|
int GetTextFace(HDC, int, LPTSTR);
|
|
|
|
DWORD GetKerningPairs(HDC, DWORD, LPKERNINGPAIR);
|
|
|
|
BOOL GetLogColorSpace(HCOLORSPACE, LPLOGCOLORSPACE, DWORD);
|
|
|
|
HCOLORSPACE CreateColorSpace(LPLOGCOLORSPACE);
|
|
|
|
BOOL GetICMProfile(HDC, LPDWORD, LPTSTR);
|
|
|
|
BOOL SetICMProfile(HDC, LPTSTR);
|
|
|
|
int EnumICMProfiles(HDC, ICMENUMPROC, LPARAM);
|
|
|
|
BOOL UpdateICMRegKey(DWORD, LPTSTR, LPTSTR, UINT);
|
|
|
|
HKL LoadKeyboardLayout(LPCTSTR, UINT);
|
|
|
|
BOOL GetKeyboardLayoutName(LPTSTR);
|
|
|
|
HDESK CreateDesktop(LPCTSTR, LPCTSTR, DEVMODE*, DWORD, ACCESS_MASK,
|
|
LPSECURITY_ATTRIBUTES);
|
|
|
|
HDESK CreateDesktopEx(LPCTSTR, LPCTSTR, DEVMODE*, DWORD, ACCESS_MASK,
|
|
LPSECURITY_ATTRIBUTES, ULONG, PVOID);
|
|
|
|
HDESK OpenDesktop(LPCTSTR, DWORD, BOOL, ACCESS_MASK);
|
|
|
|
BOOL EnumDesktops(HWINSTA, DESKTOPENUMPROC, LPARAM);
|
|
|
|
HWINSTA CreateWindowStation(LPCTSTR, DWORD, ACCESS_MASK, LPSECURITY_ATTRIBUTES);
|
|
|
|
HWINSTA OpenWindowStation(LPCTSTR, BOOL, ACCESS_MASK);
|
|
|
|
BOOL EnumWindowStations(WINSTAENUMPROC, LPARAM);
|
|
|
|
BOOL GetUserObjectInformation(HANDLE, int, PVOID, DWORD, LPDWORD);
|
|
|
|
BOOL SetUserObjectInformation(HANDLE, int, PVOID, DWORD);
|
|
|
|
UINT RegisterWindowMessage(LPCTSTR);
|
|
|
|
BOOL GetMessage(LPMSG, HWND, UINT, UINT);
|
|
|
|
LRESULT DispatchMessage(const MSG*);
|
|
|
|
BOOL PeekMessage(LPMSG, HWND, UINT, UINT, UINT);
|
|
|
|
LRESULT SendMessage(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
LRESULT SendMessageTimeout(HWND, UINT, WPARAM, LPARAM, UINT, UINT, PDWORD_PTR);
|
|
|
|
BOOL SendNotifyMessage(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
BOOL SendMessageCallback(HWND, UINT, WPARAM, LPARAM, SENDASYNCPROC, ULONG_PTR);
|
|
|
|
long BroadcastSystemMessageEx(DWORD, LPDWORD, UINT, WPARAM, LPARAM, PBSMINFO);
|
|
|
|
long BroadcastSystemMessage(DWORD, LPDWORD, UINT, WPARAM, LPARAM);
|
|
|
|
HDEVNOTIFY RegisterDeviceNotification(HANDLE, LPVOID, DWORD);
|
|
|
|
BOOL PostMessage(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
BOOL PostThreadMessage(DWORD, UINT, WPARAM, LPARAM);
|
|
|
|
BOOL PostAppMessage(DWORD, UINT, WPARAM, LPARAM);
|
|
|
|
LRESULT DefWindowProc(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
LRESULT CallWindowProc(WNDPROC, HWND, UINT, WPARAM, LPARAM);
|
|
|
|
ATOM RegisterClass(const WNDCLASS*);
|
|
|
|
BOOL UnregisterClass(LPCTSTR, HINSTANCE);
|
|
|
|
BOOL GetClassInfo(HINSTANCE, LPCTSTR, LPWNDCLASS);
|
|
|
|
ATOM RegisterClassEx(const WNDCLASSEX*);
|
|
|
|
BOOL GetClassInfoEx(HINSTANCE, LPCTSTR, LPWNDCLASSEX);
|
|
|
|
HWND CreateWindowEx(DWORD, LPCTSTR, LPCTSTR, DWORD, int, int, int, int, HWND,
|
|
HMENU, HINSTANCE, LPVOID);
|
|
|
|
HWND CreateWindow(LPCTSTR, LPCTSTR, DWORD, int, int, int, int, HWND, HMENU,
|
|
HINSTANCE, LPVOID);
|
|
|
|
HWND CreateDialogParam(HINSTANCE, LPCTSTR, HWND, DLGPROC, LPARAM);
|
|
|
|
HWND CreateDialogIndirectParam(HINSTANCE, LPCDLGTEMPLATE, HWND, DLGPROC,
|
|
LPARAM);
|
|
|
|
HWND CreateDialog(HINSTANCE, LPCTSTR, HWND, DLGPROC);
|
|
|
|
HWND CreateDialogIndirect(HINSTANCE, LPCDLGTEMPLATE, HWND, DLGPROC);
|
|
|
|
INT_PTR DialogBoxParam(HINSTANCE, LPCTSTR, HWND, DLGPROC, LPARAM);
|
|
|
|
INT_PTR DialogBoxIndirectParam(HINSTANCE, LPCDLGTEMPLATE, HWND, DLGPROC,
|
|
LPARAM);
|
|
|
|
INT_PTR DialogBox(HINSTANCE, LPCTSTR, HWND, DLGPROC);
|
|
|
|
INT_PTR DialogBoxIndirect(HINSTANCE, LPCDLGTEMPLATE, HWND, DLGPROC);
|
|
|
|
BOOL SetDlgItemText(HWND, int, LPCTSTR);
|
|
|
|
UINT GetDlgItemText(HWND, int, LPTSTR, int);
|
|
|
|
LRESULT SendDlgItemMessage(HWND, int, UINT, WPARAM, LPARAM);
|
|
|
|
LRESULT DefDlgProc(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
BOOL CallMsgFilter(LPMSG, int);
|
|
|
|
UINT RegisterClipboardFormat(LPCTSTR);
|
|
|
|
int GetClipboardFormatName(UINT, LPTSTR, int);
|
|
|
|
BOOL CharToOem(LPCTSTR, LPSTR);
|
|
|
|
BOOL OemToChar(LPCSTR, LPTSTR);
|
|
|
|
BOOL CharToOemBuff(LPCTSTR, LPSTR, DWORD);
|
|
|
|
BOOL OemToCharBuff(LPCSTR, LPTSTR, DWORD);
|
|
|
|
LPTSTR CharUpper(LPTSTR);
|
|
|
|
DWORD CharUpperBuff(LPTSTR, DWORD);
|
|
|
|
LPTSTR CharLower(LPTSTR);
|
|
|
|
DWORD CharLowerBuff(LPTSTR, DWORD);
|
|
|
|
LPTSTR CharNext(LPCTSTR);
|
|
|
|
LPTSTR CharPrev(LPCTSTR, LPCTSTR);
|
|
|
|
BOOL IsCharAlpha(CHAR);
|
|
|
|
BOOL IsCharAlphaNumeric(CHAR);
|
|
|
|
BOOL IsCharUpper(CHAR);
|
|
|
|
BOOL IsCharLower(CHAR);
|
|
|
|
int GetKeyNameText(LONG, LPTSTR, int);
|
|
|
|
SHORT VkKeyScan(CHAR);
|
|
|
|
SHORT VkKeyScanEx(CHAR, HKL);
|
|
|
|
UINT MapVirtualKey(UINT, UINT);
|
|
|
|
UINT MapVirtualKeyEx(UINT, UINT, HKL);
|
|
|
|
HACCEL LoadAccelerators(HINSTANCE, LPCTSTR);
|
|
|
|
HACCEL CreateAcceleratorTable(LPACCEL, int);
|
|
|
|
int CopyAcceleratorTable(HACCEL, LPACCEL, int);
|
|
|
|
int TranslateAccelerator(HWND, HACCEL, LPMSG);
|
|
|
|
HMENU LoadMenu(HINSTANCE, LPCTSTR);
|
|
|
|
HMENU LoadMenuIndirect(const MENUTEMPLATE*);
|
|
|
|
BOOL ChangeMenu(HMENU, UINT, LPCTSTR, UINT, UINT);
|
|
|
|
int GetMenuString(HMENU, UINT, LPTSTR, int, UINT);
|
|
|
|
BOOL InsertMenu(HMENU, UINT, UINT, UINT_PTR, LPCTSTR);
|
|
|
|
BOOL AppendMenu(HMENU, UINT, UINT_PTR, LPCTSTR);
|
|
|
|
BOOL ModifyMenu(HMENU, UINT, UINT, UINT_PTR, LPCTSTR);
|
|
|
|
BOOL InsertMenuItem(HMENU, UINT, BOOL, LPCMENUITEMINFO);
|
|
|
|
BOOL GetMenuItemInfo(HMENU, UINT, BOOL, LPMENUITEMINFO);
|
|
|
|
BOOL SetMenuItemInfo(HMENU, UINT, BOOL, LPCMENUITEMINFO);
|
|
|
|
int DrawText(HDC, LPCTSTR, int, LPRECT, UINT);
|
|
|
|
int DrawTextEx(HDC, LPTSTR, int, LPRECT, UINT, LPDRAWTEXTPARAMS);
|
|
|
|
BOOL GrayString(HDC, HBRUSH, GRAYSTRINGPROC, LPARAM, int, int, int, int, int);
|
|
|
|
BOOL DrawState(HDC, HBRUSH, DRAWSTATEPROC, LPARAM, WPARAM, int, int, int, int,
|
|
UINT);
|
|
|
|
LONG TabbedTextOut(HDC, int, int, LPCTSTR, int, int, const INT*, int);
|
|
|
|
DWORD GetTabbedTextExtent(HDC, LPCTSTR, int, int, const INT*);
|
|
|
|
BOOL SetProp(HWND, LPCTSTR, HANDLE);
|
|
|
|
HANDLE GetProp(HWND, LPCTSTR);
|
|
|
|
HANDLE RemoveProp(HWND, LPCTSTR);
|
|
|
|
int EnumPropsEx(HWND, PROPENUMPROCEX, LPARAM);
|
|
|
|
int EnumProps(HWND, PROPENUMPROC);
|
|
|
|
BOOL SetWindowText(HWND, LPCTSTR);
|
|
|
|
int GetWindowText(HWND, LPTSTR, int);
|
|
|
|
int GetWindowTextLength(HWND);
|
|
|
|
int MessageBox(HWND, LPCTSTR, LPCTSTR, UINT);
|
|
|
|
int MessageBoxEx(HWND, LPCTSTR, LPCTSTR, UINT, WORD);
|
|
|
|
int MessageBoxIndirect(const MSGBOXPARAMS*);
|
|
|
|
LONG GetWindowLong(HWND, int);
|
|
|
|
LONG SetWindowLong(HWND, int, LONG);
|
|
|
|
LONG_PTR GetWindowLongPtr(HWND, int);
|
|
|
|
LONG_PTR SetWindowLongPtr(HWND, int, LONG_PTR);
|
|
|
|
DWORD GetClassLong(HWND, int);
|
|
|
|
DWORD SetClassLong(HWND, int, LONG);
|
|
|
|
ULONG_PTR GetClassLongPtr(HWND, int);
|
|
|
|
ULONG_PTR SetClassLongPtr(HWND, int, LONG_PTR);
|
|
|
|
HWND FindWindow(LPCTSTR, LPCTSTR);
|
|
|
|
HWND FindWindowEx(HWND, HWND, LPCTSTR, LPCTSTR);
|
|
|
|
int GetClassName(HWND, LPTSTR, int);
|
|
|
|
HHOOK SetWindowsHook(int, HOOKPROC);
|
|
|
|
HHOOK SetWindowsHookEx(int, HOOKPROC, HINSTANCE, DWORD);
|
|
|
|
HBITMAP LoadBitmap(HINSTANCE, LPCTSTR);
|
|
|
|
HCURSOR LoadCursor(HINSTANCE, LPCTSTR);
|
|
|
|
HCURSOR LoadCursorFromFile(LPCTSTR);
|
|
|
|
HICON LoadIcon(HINSTANCE, LPCTSTR);
|
|
|
|
UINT PrivateExtractIcons(LPCTSTR, int, int, int, HICON*, UINT*, UINT, UINT);
|
|
|
|
HANDLE LoadImage(HINSTANCE, LPCTSTR, UINT, int, int, UINT);
|
|
|
|
BOOL GetIconInfoEx(HICON, PICONINFOEX);
|
|
|
|
BOOL IsDialogMessage(HWND, LPMSG);
|
|
|
|
int DlgDirList(HWND, LPTSTR, int, int, UINT);
|
|
|
|
BOOL DlgDirSelectEx(HWND, LPTSTR, int, int);
|
|
|
|
int DlgDirListComboBox(HWND, LPTSTR, int, int, UINT);
|
|
|
|
BOOL DlgDirSelectComboBoxEx(HWND, LPTSTR, int, int);
|
|
|
|
LRESULT DefFrameProc(HWND, HWND, UINT, WPARAM, LPARAM);
|
|
|
|
LRESULT DefMDIChildProc(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
HWND CreateMDIWindow(LPCTSTR, LPCTSTR, DWORD, int, int, int, int, HWND,
|
|
HINSTANCE, LPARAM);
|
|
|
|
BOOL WinHelp(HWND, LPCTSTR, UINT, ULONG_PTR);
|
|
|
|
LONG ChangeDisplaySettings(DEVMODE*, DWORD);
|
|
|
|
LONG ChangeDisplaySettingsEx(LPCTSTR, DEVMODE*, HWND, DWORD, LPVOID);
|
|
|
|
BOOL EnumDisplaySettings(LPCTSTR, DWORD, DEVMODE*);
|
|
|
|
BOOL EnumDisplaySettingsEx(LPCTSTR, DWORD, DEVMODE*, DWORD);
|
|
|
|
BOOL EnumDisplayDevices(LPCTSTR, DWORD, PDISPLAY_DEVICE, DWORD);
|
|
|
|
BOOL SystemParametersInfo(UINT, UINT, PVOID, UINT);
|
|
|
|
BOOL GetMonitorInfo(HMONITOR, LPMONITORINFO);
|
|
|
|
UINT GetWindowModuleFileName(HWND, LPTSTR, UINT);
|
|
|
|
UINT RealGetWindowClass(HWND, LPTSTR, UINT);
|
|
|
|
BOOL GetAltTabInfo(HWND, int, PALTTABINFO, LPTSTR, UINT);
|
|
|
|
UINT GetRawInputDeviceInfo(HANDLE, UINT, LPVOID, PUINT);
|
|
|
|
int GetDateFormat(LCID, DWORD, const SYSTEMTIME*, LPCTSTR, LPTSTR, int);
|
|
|
|
int GetTimeFormat(LCID, DWORD, const SYSTEMTIME*, LPCTSTR, LPTSTR, int);
|
|
|
|
BOOL GetCPInfoEx(UINT, DWORD, LPCPINFOEX);
|
|
|
|
int CompareString(LCID, DWORD, PCNZTCH, int, PCNZTCH, int);
|
|
|
|
int GetLocaleInfo(LCID, LCTYPE, LPTSTR, int);
|
|
|
|
BOOL SetLocaleInfo(LCID, LCTYPE, LPCTSTR);
|
|
|
|
int GetCalendarInfo(LCID, CALID, CALTYPE, LPTSTR, int, LPDWORD);
|
|
|
|
BOOL SetCalendarInfo(LCID, CALID, CALTYPE, LPCTSTR);
|
|
|
|
int GetNumberFormat(LCID, DWORD, LPCTSTR, const NUMBERFMT*, LPTSTR, int);
|
|
|
|
int GetCurrencyFormat(LCID, DWORD, LPCTSTR, const CURRENCYFMT*, LPTSTR, int);
|
|
|
|
BOOL EnumCalendarInfo(CALINFO_ENUMPROC, LCID, CALID, CALTYPE);
|
|
|
|
BOOL EnumCalendarInfoEx(CALINFO_ENUMPROCEX, LCID, CALID, CALTYPE);
|
|
|
|
BOOL EnumTimeFormats(TIMEFMT_ENUMPROC, LCID, DWORD);
|
|
|
|
BOOL EnumDateFormats(DATEFMT_ENUMPROC, LCID, DWORD);
|
|
|
|
BOOL EnumDateFormatsEx(DATEFMT_ENUMPROCEX, LCID, DWORD);
|
|
|
|
int GetGeoInfo(GEOID, GEOTYPE, LPTSTR, int, LANGID);
|
|
|
|
BOOL GetStringTypeEx(LCID, DWORD, LPCTSTR, int, LPWORD);
|
|
|
|
int FoldString(DWORD, LPCTSTR, int, LPTSTR, int);
|
|
|
|
BOOL EnumSystemLocales(LOCALE_ENUMPROC, DWORD);
|
|
|
|
BOOL EnumSystemLanguageGroups(LANGUAGEGROUP_ENUMPROC, DWORD, LONG_PTR);
|
|
|
|
BOOL EnumLanguageGroupLocales(LANGGROUPLOCALE_ENUMPROC, LGRPID, DWORD,
|
|
LONG_PTR);
|
|
|
|
BOOL EnumUILanguages(UILANGUAGE_ENUMPROC, DWORD, LONG_PTR);
|
|
|
|
BOOL EnumSystemCodePages(CODEPAGE_ENUMPROC, DWORD);
|
|
|
|
BOOL ReadConsoleInput(HANDLE, PINPUT_RECORD, DWORD, LPDWORD);
|
|
|
|
BOOL PeekConsoleInput(HANDLE, PINPUT_RECORD, DWORD, LPDWORD);
|
|
|
|
BOOL ReadConsole(HANDLE, LPVOID, DWORD, LPDWORD, PCONSOLE_READCONSOLE_CONTROL);
|
|
|
|
BOOL WriteConsole(HANDLE, const void*, DWORD, LPDWORD, LPVOID);
|
|
|
|
BOOL FillConsoleOutputCharacter(HANDLE, CHAR, DWORD, COORD, LPDWORD);
|
|
|
|
BOOL WriteConsoleOutputCharacter(HANDLE, LPCTSTR, DWORD, COORD, LPDWORD);
|
|
|
|
BOOL ReadConsoleOutputCharacter(HANDLE, LPTSTR, DWORD, COORD, LPDWORD);
|
|
|
|
BOOL WriteConsoleInput(HANDLE, const INPUT_RECORD*, DWORD, LPDWORD);
|
|
|
|
BOOL ScrollConsoleScreenBuffer(HANDLE, const SMALL_RECT*, const SMALL_RECT*,
|
|
COORD, const CHAR_INFO*);
|
|
|
|
BOOL WriteConsoleOutput(HANDLE, const CHAR_INFO*, COORD, COORD, PSMALL_RECT);
|
|
|
|
BOOL ReadConsoleOutput(HANDLE, PCHAR_INFO, COORD, COORD, PSMALL_RECT);
|
|
|
|
DWORD GetConsoleTitle(LPTSTR, DWORD);
|
|
|
|
DWORD GetConsoleOriginalTitle(LPTSTR, DWORD);
|
|
|
|
BOOL SetConsoleTitle(LPCTSTR);
|
|
|
|
BOOL AddConsoleAlias(LPTSTR, LPTSTR, LPTSTR);
|
|
|
|
DWORD GetConsoleAlias(LPTSTR, LPTSTR, DWORD, LPTSTR);
|
|
|
|
DWORD GetConsoleAliasesLength(LPTSTR);
|
|
|
|
DWORD GetConsoleAliasExesLength();
|
|
|
|
DWORD GetConsoleAliases(LPTSTR, DWORD, LPTSTR);
|
|
|
|
DWORD GetConsoleAliasExes(LPTSTR, DWORD);
|
|
|
|
void ExpungeConsoleCommandHistory(LPTSTR);
|
|
|
|
BOOL SetConsoleNumberOfCommands(DWORD, LPTSTR);
|
|
|
|
DWORD GetConsoleCommandHistoryLength(LPTSTR);
|
|
|
|
DWORD GetConsoleCommandHistory(LPTSTR, DWORD, LPTSTR);
|
|
|
|
DWORD VerFindFile(DWORD, LPTSTR, LPTSTR, LPTSTR, LPTSTR, PUINT, LPTSTR, PUINT);
|
|
|
|
DWORD VerInstallFile(DWORD, LPTSTR, LPTSTR, LPTSTR, LPTSTR, LPTSTR, LPTSTR,
|
|
PUINT);
|
|
|
|
DWORD GetFileVersionInfoSize(LPCTSTR, LPDWORD);
|
|
|
|
BOOL GetFileVersionInfo(LPCTSTR, DWORD, DWORD, LPVOID);
|
|
|
|
DWORD GetFileVersionInfoSizeEx(DWORD, LPCTSTR, LPDWORD);
|
|
|
|
BOOL GetFileVersionInfoEx(DWORD, LPCTSTR, DWORD, DWORD, LPVOID);
|
|
|
|
DWORD VerLanguageName(DWORD, LPTSTR, DWORD);
|
|
|
|
BOOL VerQueryValue(LPCVOID, LPCTSTR, LPVOID*, PUINT);
|
|
|
|
LSTATUS RegConnectRegistry(LPCTSTR, HKEY, PHKEY);
|
|
|
|
LSTATUS RegConnectRegistryEx(LPCTSTR, HKEY, ULONG, PHKEY);
|
|
|
|
LSTATUS RegCreateKey(HKEY, LPCTSTR, PHKEY);
|
|
|
|
LSTATUS RegCreateKeyEx(HKEY, LPCTSTR, DWORD, LPTSTR, DWORD, REGSAM,
|
|
const LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD);
|
|
|
|
LSTATUS RegCreateKeyTransacted(HKEY, LPCTSTR, DWORD, LPTSTR, DWORD, REGSAM,
|
|
const LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD,
|
|
HANDLE, PVOID);
|
|
|
|
LSTATUS RegDeleteKey(HKEY, LPCTSTR);
|
|
|
|
LSTATUS RegDeleteKeyEx(HKEY, LPCTSTR, REGSAM, DWORD);
|
|
|
|
LSTATUS RegDeleteKeyTransacted(HKEY, LPCTSTR, REGSAM, DWORD, HANDLE, PVOID);
|
|
|
|
LSTATUS RegDeleteValue(HKEY, LPCTSTR);
|
|
|
|
LSTATUS RegEnumKey(HKEY, DWORD, LPTSTR, DWORD);
|
|
|
|
LSTATUS RegEnumKeyEx(HKEY, DWORD, LPTSTR, LPDWORD, LPDWORD, LPTSTR, LPDWORD,
|
|
PFILETIME);
|
|
|
|
LSTATUS RegEnumValue(HKEY, DWORD, LPTSTR, LPDWORD, LPDWORD, LPDWORD, LPBYTE,
|
|
LPDWORD);
|
|
|
|
LSTATUS RegLoadKey(HKEY, LPCTSTR, LPCTSTR);
|
|
|
|
LSTATUS RegOpenKey(HKEY, LPCTSTR, PHKEY);
|
|
|
|
LSTATUS RegOpenKeyEx(HKEY, LPCTSTR, DWORD, REGSAM, PHKEY);
|
|
|
|
LSTATUS RegOpenKeyTransacted(HKEY, LPCTSTR, DWORD, REGSAM, PHKEY, HANDLE,
|
|
PVOID);
|
|
|
|
LSTATUS RegQueryInfoKey(HKEY, LPTSTR, LPDWORD, LPDWORD, LPDWORD, LPDWORD,
|
|
LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME);
|
|
|
|
LSTATUS RegQueryValue(HKEY, LPCTSTR, LPTSTR, PLONG);
|
|
|
|
LSTATUS RegQueryMultipleValues(HKEY, PVALENT, DWORD, LPTSTR, LPDWORD);
|
|
|
|
LSTATUS RegQueryValueEx(HKEY, LPCTSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
|
|
|
|
LSTATUS RegReplaceKey(HKEY, LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
LSTATUS RegRestoreKey(HKEY, LPCTSTR, DWORD);
|
|
|
|
LSTATUS RegSaveKey(HKEY, LPCTSTR, const LPSECURITY_ATTRIBUTES);
|
|
|
|
LSTATUS RegSetValue(HKEY, LPCTSTR, DWORD, LPCTSTR, DWORD);
|
|
|
|
LSTATUS RegSetValueEx(HKEY, LPCTSTR, DWORD, DWORD, const BYTE*, DWORD);
|
|
|
|
LSTATUS RegUnLoadKey(HKEY, LPCTSTR);
|
|
|
|
LSTATUS RegDeleteKeyValue(HKEY, LPCTSTR, LPCTSTR);
|
|
|
|
LSTATUS RegSetKeyValue(HKEY, LPCTSTR, LPCTSTR, DWORD, LPCVOID, DWORD);
|
|
|
|
LSTATUS RegDeleteTree(HKEY, LPCTSTR);
|
|
|
|
LSTATUS RegCopyTree(HKEY, LPCTSTR, HKEY);
|
|
|
|
LSTATUS RegGetValue(HKEY, LPCTSTR, LPCTSTR, DWORD, LPDWORD, PVOID, LPDWORD);
|
|
|
|
LSTATUS RegLoadMUIString(HKEY, LPCTSTR, LPTSTR, DWORD, LPDWORD, DWORD, LPCTSTR);
|
|
|
|
LSTATUS RegLoadAppKey(LPCTSTR, PHKEY, REGSAM, DWORD, DWORD);
|
|
|
|
BOOL InitiateSystemShutdown(LPTSTR, LPTSTR, DWORD, BOOL, BOOL);
|
|
|
|
BOOL AbortSystemShutdown(LPTSTR);
|
|
|
|
BOOL InitiateSystemShutdownEx(LPTSTR, LPTSTR, DWORD, BOOL, BOOL, DWORD);
|
|
|
|
DWORD InitiateShutdown(LPTSTR, LPTSTR, DWORD, DWORD, DWORD);
|
|
|
|
LSTATUS RegSaveKeyEx(HKEY, LPCTSTR, const LPSECURITY_ATTRIBUTES, DWORD);
|
|
|
|
DWORD MultinetGetConnectionPerformance(LPNETRESOURCE, LPNETCONNECTINFOSTRUCT);
|
|
|
|
BOOL ChangeServiceConfig(SC_HANDLE, DWORD, DWORD, DWORD, LPCTSTR, LPCTSTR,
|
|
LPDWORD, LPCTSTR, LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
BOOL ChangeServiceConfig2(SC_HANDLE, DWORD, LPVOID);
|
|
|
|
SC_HANDLE CreateService(SC_HANDLE, LPCTSTR, LPCTSTR, DWORD, DWORD, DWORD, DWORD,
|
|
LPCTSTR, LPCTSTR, LPDWORD, LPCTSTR, LPCTSTR, LPCTSTR);
|
|
|
|
BOOL EnumDependentServices(SC_HANDLE, DWORD, LPENUM_SERVICE_STATUS, DWORD,
|
|
LPDWORD, LPDWORD);
|
|
|
|
BOOL EnumServicesStatus(SC_HANDLE, DWORD, DWORD, LPENUM_SERVICE_STATUS, DWORD,
|
|
LPDWORD, LPDWORD, LPDWORD);
|
|
|
|
BOOL EnumServicesStatusEx(SC_HANDLE, SC_ENUM_TYPE, DWORD, DWORD, LPBYTE, DWORD,
|
|
LPDWORD, LPDWORD, LPDWORD, LPCTSTR);
|
|
|
|
BOOL GetServiceKeyName(SC_HANDLE, LPCTSTR, LPTSTR, LPDWORD);
|
|
|
|
BOOL GetServiceDisplayName(SC_HANDLE, LPCTSTR, LPTSTR, LPDWORD);
|
|
|
|
SC_HANDLE OpenSCManager(LPCTSTR, LPCTSTR, DWORD);
|
|
|
|
SC_HANDLE OpenService(SC_HANDLE, LPCTSTR, DWORD);
|
|
|
|
BOOL QueryServiceConfig(SC_HANDLE, LPQUERY_SERVICE_CONFIG, DWORD, LPDWORD);
|
|
|
|
BOOL QueryServiceConfig2(SC_HANDLE, DWORD, LPBYTE, DWORD, LPDWORD);
|
|
|
|
BOOL QueryServiceLockStatus(SC_HANDLE, LPQUERY_SERVICE_LOCK_STATUS, DWORD,
|
|
LPDWORD);
|
|
|
|
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandler(LPCTSTR, LPHANDLER_FUNCTION);
|
|
|
|
SERVICE_STATUS_HANDLE RegisterServiceCtrlHandlerEx(LPCTSTR,
|
|
LPHANDLER_FUNCTION_EX,
|
|
LPVOID);
|
|
|
|
BOOL StartServiceCtrlDispatcher(const SERVICE_TABLE_ENTRY*);
|
|
|
|
BOOL StartService(SC_HANDLE, DWORD, LPCTSTR*);
|
|
|
|
DWORD NotifyServiceStatusChange(SC_HANDLE, DWORD, PSERVICE_NOTIFY);
|
|
|
|
BOOL ControlServiceEx(SC_HANDLE, DWORD, DWORD, PVOID);
|
|
|
|
HKL ImmInstallIME(LPCTSTR, LPCTSTR);
|
|
|
|
UINT ImmGetDescription(HKL, LPTSTR, UINT);
|
|
|
|
UINT ImmGetIMEFileName(HKL, LPTSTR, UINT);
|
|
|
|
LONG ImmGetCompositionString(HIMC, DWORD, LPVOID, DWORD);
|
|
|
|
BOOL ImmSetCompositionString(HIMC, DWORD, LPVOID, DWORD, LPVOID, DWORD);
|
|
|
|
DWORD ImmGetCandidateListCount(HIMC, LPDWORD);
|
|
|
|
DWORD ImmGetCandidateList(HIMC, DWORD, LPCANDIDATELIST, DWORD);
|
|
|
|
DWORD ImmGetGuideLine(HIMC, DWORD, LPTSTR, DWORD);
|
|
|
|
BOOL ImmGetCompositionFont(HIMC, LPLOGFONT);
|
|
|
|
BOOL ImmSetCompositionFont(HIMC, LPLOGFONT);
|
|
|
|
BOOL ImmConfigureIME(HKL, HWND, DWORD, LPVOID);
|
|
|
|
LRESULT ImmEscape(HKL, HIMC, UINT, LPVOID);
|
|
|
|
DWORD ImmGetConversionList(HKL, HIMC, LPCTSTR, LPCANDIDATELIST, DWORD, UINT);
|
|
|
|
BOOL ImmIsUIMessage(HWND, UINT, WPARAM, LPARAM);
|
|
|
|
BOOL ImmRegisterWord(HKL, LPCTSTR, DWORD, LPCTSTR);
|
|
|
|
BOOL ImmUnregisterWord(HKL, LPCTSTR, DWORD, LPCTSTR);
|
|
|
|
UINT ImmGetRegisterWordStyle(HKL, UINT, LPSTYLEBUF);
|
|
|
|
UINT ImmEnumRegisterWord(HKL, REGISTERWORDENUMPROC, LPCTSTR, DWORD, LPCTSTR,
|
|
LPVOID);
|
|
|
|
DWORD ImmGetImeMenuItems(HIMC, DWORD, DWORD, LPIMEMENUITEMINFO,
|
|
LPIMEMENUITEMINFO, DWORD);
|