windows-h-unicode.decls.h

mozilla-central/config/windows-h-unicode.decls.h

Enable keyboard shortcuts

Source code

File a bug in Firefox Build System :: General

Revision control

Copy as Markdown

Other Tools

/* -*- 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);