Logo Search packages:      
Sourcecode: ldc version File versions

windows.d

/* Windows is a registered trademark of Microsoft Corporation in the United
States and other countries. */

module std.c.windows.windows;

version (Windows)
{
}
else
{
    static assert(0);         // Windows only
}

extern (Windows)
{
    alias uint ULONG;
    alias ULONG *PULONG;
    alias ushort USHORT;
    alias USHORT *PUSHORT;
    alias ubyte UCHAR;
    alias UCHAR *PUCHAR;
    alias char *PSZ;
    alias wchar WCHAR;

    alias void VOID;
    alias char CHAR;
    alias short SHORT;
    alias int LONG;
    alias CHAR *LPSTR;
    alias CHAR *PSTR;
    alias CHAR *LPCSTR;
    alias CHAR *PCSTR;
    alias LPSTR LPTCH, PTCH;
    alias LPSTR PTSTR, LPTSTR;
    alias LPCSTR LPCTSTR;

    alias WCHAR* LPWSTR, LPCWSTR, PCWSTR;

    alias uint DWORD;
    alias int BOOL;
    alias ubyte BYTE;
    alias ushort WORD;
    alias float FLOAT;
    alias FLOAT *PFLOAT;
    alias BOOL *PBOOL;
    alias BOOL *LPBOOL;
    alias BYTE *PBYTE;
    alias BYTE *LPBYTE;
    alias int *PINT;
    alias int *LPINT;
    alias WORD *PWORD;
    alias WORD *LPWORD;
    alias int *LPLONG;
    alias DWORD *PDWORD;
    alias DWORD *LPDWORD;
    alias void *LPVOID;
    alias void *LPCVOID;

    alias int INT;
    alias uint UINT;
    alias uint *PUINT;

    typedef void *HANDLE;
    alias void *PVOID;
    alias HANDLE HGLOBAL;
    alias HANDLE HLOCAL;
    alias LONG HRESULT;
    alias LONG SCODE;
    alias HANDLE HINSTANCE;
    alias HINSTANCE HMODULE;
    alias HANDLE HWND;

    alias HANDLE HGDIOBJ;
    alias HANDLE HACCEL;
    alias HANDLE HBITMAP;
    alias HANDLE HBRUSH;
    alias HANDLE HCOLORSPACE;
    alias HANDLE HDC;
    alias HANDLE HGLRC;
    alias HANDLE HDESK;
    alias HANDLE HENHMETAFILE;
    alias HANDLE HFONT;
    alias HANDLE HICON;
    alias HANDLE HMENU;
    alias HANDLE HMETAFILE;
    alias HANDLE HPALETTE;
    alias HANDLE HPEN;
    alias HANDLE HRGN;
    alias HANDLE HRSRC;
    alias HANDLE HSTR;
    alias HANDLE HTASK;
    alias HANDLE HWINSTA;
    alias HANDLE HKL;
    alias HICON HCURSOR;

    alias HANDLE HKEY;
    alias HKEY *PHKEY;
    alias DWORD ACCESS_MASK;
    alias ACCESS_MASK *PACCESS_MASK;
    alias ACCESS_MASK REGSAM;

    alias int (*FARPROC)();

    alias UINT WPARAM;
    alias LONG LPARAM;
    alias LONG LRESULT;

    alias DWORD   COLORREF;
    alias DWORD   *LPCOLORREF;
    alias WORD    ATOM;

version (0)
{   // Properly prototyped versions
    alias BOOL function(HWND, UINT, WPARAM, LPARAM) DLGPROC;
    alias VOID function(HWND, UINT, UINT, DWORD) TIMERPROC;
    alias BOOL function(HDC, LPARAM, int) GRAYSTRINGPROC;
    alias BOOL function(HWND, LPARAM) WNDENUMPROC;
    alias LRESULT function(int code, WPARAM wParam, LPARAM lParam) HOOKPROC;
    alias VOID function(HWND, UINT, DWORD, LRESULT) SENDASYNCPROC;
    alias BOOL function(HWND, LPCSTR, HANDLE) PROPENUMPROCA;
    alias BOOL function(HWND, LPCWSTR, HANDLE) PROPENUMPROCW;
    alias BOOL function(HWND, LPSTR, HANDLE, DWORD) PROPENUMPROCEXA;
    alias BOOL function(HWND, LPWSTR, HANDLE, DWORD) PROPENUMPROCEXW;
    alias int function(LPSTR lpch, int ichCurrent, int cch, int code)
       EDITWORDBREAKPROCA;
    alias int function(LPWSTR lpch, int ichCurrent, int cch, int code)
       EDITWORDBREAKPROCW;
    alias BOOL function(HDC hdc, LPARAM lData, WPARAM wData, int cx, int cy)
       DRAWSTATEPROC;
}
else
{
    alias FARPROC DLGPROC;
    alias FARPROC TIMERPROC;
    alias FARPROC GRAYSTRINGPROC;
    alias FARPROC WNDENUMPROC;
    alias FARPROC HOOKPROC;
    alias FARPROC SENDASYNCPROC;
    alias FARPROC EDITWORDBREAKPROCA;
    alias FARPROC EDITWORDBREAKPROCW;
    alias FARPROC PROPENUMPROCA;
    alias FARPROC PROPENUMPROCW;
    alias FARPROC PROPENUMPROCEXA;
    alias FARPROC PROPENUMPROCEXW;
    alias FARPROC DRAWSTATEPROC;
}

WORD HIWORD(int l) { return cast(WORD)((l >> 16) & 0xFFFF); }
WORD LOWORD(int l) { return cast(WORD)l; }
bool FAILED(int status) { return status < 0; }
bool SUCCEEDED(int Status) { return Status >= 0; }

enum : int
{
    FALSE = 0,
    TRUE = 1,
}

enum : uint
{
    MAX_PATH = 260,
    HINSTANCE_ERROR = 32,
}

enum
{
      ERROR_SUCCESS =                    0,
      ERROR_INVALID_FUNCTION =           1,
      ERROR_FILE_NOT_FOUND =             2,
      ERROR_PATH_NOT_FOUND =             3,
      ERROR_TOO_MANY_OPEN_FILES =        4,
      ERROR_ACCESS_DENIED =              5,
      ERROR_INVALID_HANDLE =             6,
      ERROR_NO_MORE_FILES =              18,
      ERROR_MORE_DATA =          234,
      ERROR_NO_MORE_ITEMS =            259,
}

enum
{
      DLL_PROCESS_ATTACH = 1,
      DLL_THREAD_ATTACH =  2,
      DLL_THREAD_DETACH =  3,
      DLL_PROCESS_DETACH = 0,
}

enum
{
    FILE_BEGIN           = 0,
    FILE_CURRENT         = 1,
    FILE_END             = 2,
}

enum : uint
{
    DELETE =                           0x00010000,
    READ_CONTROL =                     0x00020000,
    WRITE_DAC =                        0x00040000,
    WRITE_OWNER =                      0x00080000,
    SYNCHRONIZE =                      0x00100000,

    STANDARD_RIGHTS_REQUIRED =         0x000F0000,
    STANDARD_RIGHTS_READ =             READ_CONTROL,
    STANDARD_RIGHTS_WRITE =            READ_CONTROL,
    STANDARD_RIGHTS_EXECUTE =          READ_CONTROL,
    STANDARD_RIGHTS_ALL =              0x001F0000,
    SPECIFIC_RIGHTS_ALL =              0x0000FFFF,
    ACCESS_SYSTEM_SECURITY =           0x01000000,
    MAXIMUM_ALLOWED =                  0x02000000,

    GENERIC_READ                     = 0x80000000,
    GENERIC_WRITE                    = 0x40000000,
    GENERIC_EXECUTE                  = 0x20000000,
    GENERIC_ALL                      = 0x10000000,
}

enum
{
    FILE_SHARE_READ                 = 0x00000001,
    FILE_SHARE_WRITE                = 0x00000002,
    FILE_SHARE_DELETE               = 0x00000004,  
    FILE_ATTRIBUTE_READONLY         = 0x00000001,  
    FILE_ATTRIBUTE_HIDDEN           = 0x00000002,  
    FILE_ATTRIBUTE_SYSTEM           = 0x00000004,  
    FILE_ATTRIBUTE_DIRECTORY        = 0x00000010,  
    FILE_ATTRIBUTE_ARCHIVE          = 0x00000020,  
    FILE_ATTRIBUTE_NORMAL           = 0x00000080,  
    FILE_ATTRIBUTE_TEMPORARY        = 0x00000100,  
    FILE_ATTRIBUTE_COMPRESSED       = 0x00000800,  
    FILE_ATTRIBUTE_OFFLINE          = 0x00001000,  
    FILE_NOTIFY_CHANGE_FILE_NAME    = 0x00000001,   
    FILE_NOTIFY_CHANGE_DIR_NAME     = 0x00000002,   
    FILE_NOTIFY_CHANGE_ATTRIBUTES   = 0x00000004,   
    FILE_NOTIFY_CHANGE_SIZE         = 0x00000008,   
    FILE_NOTIFY_CHANGE_LAST_WRITE   = 0x00000010,   
    FILE_NOTIFY_CHANGE_LAST_ACCESS  = 0x00000020,   
    FILE_NOTIFY_CHANGE_CREATION     = 0x00000040,   
    FILE_NOTIFY_CHANGE_SECURITY     = 0x00000100,   
    FILE_ACTION_ADDED               = 0x00000001,   
    FILE_ACTION_REMOVED             = 0x00000002,   
    FILE_ACTION_MODIFIED            = 0x00000003,   
    FILE_ACTION_RENAMED_OLD_NAME    = 0x00000004,   
    FILE_ACTION_RENAMED_NEW_NAME    = 0x00000005,   
    FILE_CASE_SENSITIVE_SEARCH      = 0x00000001,  
    FILE_CASE_PRESERVED_NAMES       = 0x00000002,  
    FILE_UNICODE_ON_DISK            = 0x00000004,  
    FILE_PERSISTENT_ACLS            = 0x00000008,  
    FILE_FILE_COMPRESSION           = 0x00000010,  
    FILE_VOLUME_IS_COMPRESSED       = 0x00008000,  
}

const DWORD MAILSLOT_NO_MESSAGE = cast(DWORD)-1;
const DWORD MAILSLOT_WAIT_FOREVER = cast(DWORD)-1; 

enum : uint
{
    FILE_FLAG_WRITE_THROUGH         = 0x80000000,
    FILE_FLAG_OVERLAPPED            = 0x40000000,
    FILE_FLAG_NO_BUFFERING          = 0x20000000,
    FILE_FLAG_RANDOM_ACCESS         = 0x10000000,
    FILE_FLAG_SEQUENTIAL_SCAN       = 0x08000000,
    FILE_FLAG_DELETE_ON_CLOSE       = 0x04000000,
    FILE_FLAG_BACKUP_SEMANTICS      = 0x02000000,
    FILE_FLAG_POSIX_SEMANTICS       = 0x01000000,
}

enum
{
    CREATE_NEW          = 1,
    CREATE_ALWAYS       = 2,
    OPEN_EXISTING       = 3,
    OPEN_ALWAYS         = 4,
    TRUNCATE_EXISTING   = 5,
}

const HANDLE INVALID_HANDLE_VALUE = cast(HANDLE)-1;
const DWORD INVALID_SET_FILE_POINTER = cast(DWORD)-1;
const DWORD INVALID_FILE_SIZE = cast(DWORD)0xFFFFFFFF;

struct OVERLAPPED {
    DWORD   Internal;
    DWORD   InternalHigh;
    DWORD   Offset;
    DWORD   OffsetHigh;
    HANDLE  hEvent;
}

struct SECURITY_ATTRIBUTES {
    DWORD nLength;
    void *lpSecurityDescriptor;
    BOOL bInheritHandle;
}

alias SECURITY_ATTRIBUTES* PSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES;

struct FILETIME {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
}
alias FILETIME* PFILETIME, LPFILETIME;

struct WIN32_FIND_DATA {
    DWORD dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD nFileSizeHigh;
    DWORD nFileSizeLow;
    DWORD dwReserved0;
    DWORD dwReserved1;
    char   cFileName[MAX_PATH];
    char   cAlternateFileName[ 14 ];
}

struct WIN32_FIND_DATAW {
    DWORD dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    DWORD nFileSizeHigh;
    DWORD nFileSizeLow;
    DWORD dwReserved0;
    DWORD dwReserved1;
    wchar  cFileName[ 260  ];
    wchar  cAlternateFileName[ 14 ];
}

export
{
BOOL SetCurrentDirectoryA(LPCSTR lpPathName);
BOOL SetCurrentDirectoryW(LPCWSTR lpPathName);
DWORD GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer);
DWORD GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer);
BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL CreateDirectoryW(LPCWSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL CreateDirectoryExA(LPCSTR lpTemplateDirectory, LPCSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL CreateDirectoryExW(LPCWSTR lpTemplateDirectory, LPCWSTR lpNewDirectory, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL RemoveDirectoryA(LPCSTR lpPathName);
BOOL RemoveDirectoryW(LPCWSTR lpPathName);

BOOL   CloseHandle(HANDLE hObject);

HANDLE CreateFileA(char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
      SECURITY_ATTRIBUTES *lpSecurityAttributes, DWORD dwCreationDisposition,
      DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
HANDLE CreateFileW(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
      SECURITY_ATTRIBUTES *lpSecurityAttributes, DWORD dwCreationDisposition,
      DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);

BOOL   DeleteFileA(char *lpFileName);
BOOL   DeleteFileW(LPCWSTR lpFileName);

BOOL   FindClose(HANDLE hFindFile);
HANDLE FindFirstFileA(char *lpFileName, WIN32_FIND_DATA* lpFindFileData);
HANDLE FindFirstFileW(LPCWSTR lpFileName, WIN32_FIND_DATAW* lpFindFileData);
BOOL   FindNextFileA(HANDLE hFindFile, WIN32_FIND_DATA* lpFindFileData);
BOOL   FindNextFileW(HANDLE hFindFile, WIN32_FIND_DATAW* lpFindFileData);
BOOL   GetExitCodeThread(HANDLE hThread, DWORD *lpExitCode);
DWORD  GetLastError();
DWORD  GetFileAttributesA(char *lpFileName);
DWORD  GetFileAttributesW(wchar *lpFileName);
DWORD  GetFileSize(HANDLE hFile, DWORD *lpFileSizeHigh);
BOOL   CopyFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName, BOOL bFailIfExists);
BOOL   CopyFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName, BOOL bFailIfExists);
BOOL   MoveFileA(char *from, char *to);
BOOL   MoveFileW(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName);
BOOL   ReadFile(HANDLE hFile, void *lpBuffer, DWORD nNumberOfBytesToRead,
      DWORD *lpNumberOfBytesRead, OVERLAPPED *lpOverlapped);
DWORD  SetFilePointer(HANDLE hFile, LONG lDistanceToMove,
      LONG *lpDistanceToMoveHigh, DWORD dwMoveMethod);
BOOL   WriteFile(HANDLE hFile, void *lpBuffer, DWORD nNumberOfBytesToWrite,
      DWORD *lpNumberOfBytesWritten, OVERLAPPED *lpOverlapped);
DWORD  GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize);
}

struct MEMORYSTATUS {
    DWORD dwLength;
    DWORD dwMemoryLoad;
    DWORD dwTotalPhys;
    DWORD dwAvailPhys;
    DWORD dwTotalPageFile;
    DWORD dwAvailPageFile;
    DWORD dwTotalVirtual;
    DWORD dwAvailVirtual;
};
alias MEMORYSTATUS *LPMEMORYSTATUS;


export
{
 LONG  InterlockedIncrement(LPLONG lpAddend);
 LONG  InterlockedDecrement(LPLONG lpAddend);
 LONG  InterlockedExchange(LPLONG Target, LONG Value);
 LONG  InterlockedExchangeAdd(LPLONG Addend, LONG Value);
 PVOID InterlockedCompareExchange(PVOID *Destination, PVOID Exchange, PVOID Comperand);
 BOOL  FreeResource(HGLOBAL hResData);
 LPVOID LockResource(HGLOBAL hResData);
}

HMODULE LoadLibraryA(LPCSTR lpLibFileName);
FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName);
DWORD GetVersion();
BOOL FreeLibrary(HMODULE hLibModule);
void FreeLibraryAndExitThread(HMODULE hLibModule, DWORD dwExitCode);
BOOL DisableThreadLibraryCalls(HMODULE hLibModule);

//
// Registry Specific Access Rights.
//

enum
{
      KEY_QUERY_VALUE =         0x0001,
      KEY_SET_VALUE =           0x0002,
      KEY_CREATE_SUB_KEY =      0x0004,
      KEY_ENUMERATE_SUB_KEYS =  0x0008,
      KEY_NOTIFY =              0x0010,
      KEY_CREATE_LINK =         0x0020,

      KEY_READ =       cast(int)((STANDARD_RIGHTS_READ | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY)   & ~SYNCHRONIZE),
      KEY_WRITE =      cast(int)((STANDARD_RIGHTS_WRITE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY) & ~SYNCHRONIZE),
      KEY_EXECUTE =    cast(int)(KEY_READ & ~SYNCHRONIZE),
      KEY_ALL_ACCESS = cast(int)((STANDARD_RIGHTS_ALL | KEY_QUERY_VALUE | KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS | KEY_NOTIFY | KEY_CREATE_LINK) & ~SYNCHRONIZE),
}

//
// Key creation/open disposition
//

const int REG_CREATED_NEW_KEY =         0x00000001;   // New Registry Key created
const int REG_OPENED_EXISTING_KEY =     0x00000002;   // Existing Key opened


//
//
// Predefined Value Types.
//
enum
{
      REG_NONE =                    0,   // No value type
      REG_SZ =                      1,   // Unicode nul terminated string
      REG_EXPAND_SZ =               2,   // Unicode nul terminated string
                                            // (with environment variable references)
      REG_BINARY =                  3,   // Free form binary
      REG_DWORD =                   4,   // 32-bit number
      REG_DWORD_LITTLE_ENDIAN =     4,   // 32-bit number (same as REG_DWORD)
      REG_DWORD_BIG_ENDIAN =        5,   // 32-bit number
      REG_LINK =                    6,   // Symbolic Link (unicode)
      REG_MULTI_SZ =                7,   // Multiple Unicode strings
      REG_RESOURCE_LIST =           8,   // Resource list in the resource map
      REG_FULL_RESOURCE_DESCRIPTOR = 9,  // Resource list in the hardware description
      REG_RESOURCE_REQUIREMENTS_LIST = 10,
      REG_QWORD =             11,
      REG_QWORD_LITTLE_ENDIAN =     11,
}

/*
 * MessageBox() Flags
 */
enum
{
      MB_OK =                       0x00000000,
      MB_OKCANCEL =                 0x00000001,
      MB_ABORTRETRYIGNORE =         0x00000002,
      MB_YESNOCANCEL =              0x00000003,
      MB_YESNO =                    0x00000004,
      MB_RETRYCANCEL =              0x00000005,


      MB_ICONHAND =                 0x00000010,
      MB_ICONQUESTION =             0x00000020,
      MB_ICONEXCLAMATION =          0x00000030,
      MB_ICONASTERISK =             0x00000040,


      MB_USERICON =                 0x00000080,
      MB_ICONWARNING =              MB_ICONEXCLAMATION,
      MB_ICONERROR =                MB_ICONHAND,


      MB_ICONINFORMATION =          MB_ICONASTERISK,
      MB_ICONSTOP =                 MB_ICONHAND,

      MB_DEFBUTTON1 =               0x00000000,
      MB_DEFBUTTON2 =               0x00000100,
      MB_DEFBUTTON3 =               0x00000200,

      MB_DEFBUTTON4 =               0x00000300,


      MB_APPLMODAL =                0x00000000,
      MB_SYSTEMMODAL =              0x00001000,
      MB_TASKMODAL =                0x00002000,

      MB_HELP =                     0x00004000, // Help Button


      MB_NOFOCUS =                  0x00008000,
      MB_SETFOREGROUND =            0x00010000,
      MB_DEFAULT_DESKTOP_ONLY =     0x00020000,


      MB_TOPMOST =                  0x00040000,
      MB_RIGHT =                    0x00080000,
      MB_RTLREADING =               0x00100000,


      MB_TYPEMASK =                 0x0000000F,
      MB_ICONMASK =                 0x000000F0,
      MB_DEFMASK =                  0x00000F00,
      MB_MODEMASK =                 0x00003000,
      MB_MISCMASK =                 0x0000C000,
}


int MessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType);
int MessageBoxExA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType, WORD wLanguageId);

const HKEY HKEY_CLASSES_ROOT =           cast(HKEY)(0x80000000);
const HKEY HKEY_CURRENT_USER =           cast(HKEY)(0x80000001);
const HKEY HKEY_LOCAL_MACHINE =          cast(HKEY)(0x80000002);
const HKEY HKEY_USERS =                  cast(HKEY)(0x80000003);
const HKEY HKEY_PERFORMANCE_DATA =       cast(HKEY)(0x80000004);
const HKEY HKEY_PERFORMANCE_TEXT =       cast(HKEY)(0x80000050);
const HKEY HKEY_PERFORMANCE_NLSTEXT =    cast(HKEY)(0x80000060);
const HKEY HKEY_CURRENT_CONFIG =         cast(HKEY)(0x80000005);
const HKEY HKEY_DYN_DATA =               cast(HKEY)(0x80000006);

enum
{
      REG_OPTION_RESERVED =         (0x00000000),   // Parameter is reserved

      REG_OPTION_NON_VOLATILE =     (0x00000000),   // Key is preserved
                                                    // when system is rebooted

      REG_OPTION_VOLATILE =         (0x00000001),   // Key is not preserved
                                                    // when system is rebooted

      REG_OPTION_CREATE_LINK =      (0x00000002),   // Created key is a
                                                    // symbolic link

      REG_OPTION_BACKUP_RESTORE =   (0x00000004),   // open for backup or restore
                                                    // special access rules
                                                    // privilege required

      REG_OPTION_OPEN_LINK =        (0x00000008),   // Open symbolic link

      REG_LEGAL_OPTION = (REG_OPTION_RESERVED | REG_OPTION_NON_VOLATILE | REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK | REG_OPTION_BACKUP_RESTORE | REG_OPTION_OPEN_LINK),
}

export LONG RegDeleteKeyA(HKEY hKey, LPCSTR lpSubKey);
export LONG RegDeleteValueA(HKEY hKey, LPCSTR lpValueName);

export LONG  RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName, LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass, FILETIME* lpftLastWriteTime);
export LONG RegEnumValueA(HKEY hKey, DWORD dwIndex, LPSTR lpValueName, LPDWORD lpcbValueName, LPDWORD lpReserved,
    LPDWORD lpType, LPBYTE lpData, LPDWORD lpcbData);

export LONG RegCloseKey(HKEY hKey);
export LONG RegFlushKey(HKEY hKey);

export LONG RegOpenKeyA(HKEY hKey, LPCSTR lpSubKey, PHKEY phkResult);
export LONG RegOpenKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult);

export LONG RegQueryInfoKeyA(HKEY hKey, LPSTR lpClass, LPDWORD lpcbClass,
    LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcbMaxSubKeyLen, LPDWORD lpcbMaxClassLen,
    LPDWORD lpcValues, LPDWORD lpcbMaxValueNameLen, LPDWORD lpcbMaxValueLen, LPDWORD lpcbSecurityDescriptor,
    PFILETIME lpftLastWriteTime);

export LONG RegQueryValueA(HKEY hKey, LPCSTR lpSubKey, LPSTR lpValue,
    LPLONG lpcbValue);

export LONG RegCreateKeyExA(HKEY hKey, LPCSTR lpSubKey, DWORD Reserved, LPSTR lpClass,
   DWORD dwOptions, REGSAM samDesired, SECURITY_ATTRIBUTES* lpSecurityAttributes,
    PHKEY phkResult, LPDWORD lpdwDisposition);

export LONG RegSetValueExA(HKEY hKey, LPCSTR lpValueName, DWORD Reserved, DWORD dwType, BYTE* lpData, DWORD cbData);

struct MEMORY_BASIC_INFORMATION {
    PVOID BaseAddress;
    PVOID AllocationBase;
    DWORD AllocationProtect;
    DWORD RegionSize;
    DWORD State;
    DWORD Protect;
    DWORD Type;
}
alias MEMORY_BASIC_INFORMATION* PMEMORY_BASIC_INFORMATION;

enum
{
      SECTION_QUERY       = 0x0001,
      SECTION_MAP_WRITE   = 0x0002,
      SECTION_MAP_READ    = 0x0004,
      SECTION_MAP_EXECUTE = 0x0008,
      SECTION_EXTEND_SIZE = 0x0010,

      SECTION_ALL_ACCESS = cast(int)(STANDARD_RIGHTS_REQUIRED|SECTION_QUERY| SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE | SECTION_EXTEND_SIZE),
      PAGE_NOACCESS          = 0x01,
      PAGE_READONLY          = 0x02,
      PAGE_READWRITE         = 0x04,
      PAGE_WRITECOPY         = 0x08,
      PAGE_EXECUTE           = 0x10,
      PAGE_EXECUTE_READ      = 0x20,
      PAGE_EXECUTE_READWRITE = 0x40,
      PAGE_EXECUTE_WRITECOPY = 0x80,
      PAGE_GUARD            = 0x100,
      PAGE_NOCACHE          = 0x200,
      MEM_COMMIT           = 0x1000,
      MEM_RESERVE          = 0x2000,
      MEM_DECOMMIT         = 0x4000,
      MEM_RELEASE          = 0x8000,
      MEM_FREE            = 0x10000,
      MEM_PRIVATE         = 0x20000,
      MEM_MAPPED          = 0x40000,
      MEM_RESET           = 0x80000,
      MEM_TOP_DOWN       = 0x100000,
      SEC_FILE           = 0x800000,
      SEC_IMAGE         = 0x1000000,
      SEC_RESERVE       = 0x4000000,
      SEC_COMMIT        = 0x8000000,
      SEC_NOCACHE      = 0x10000000,
      MEM_IMAGE        = SEC_IMAGE,
}

enum
{
      FILE_MAP_COPY =       SECTION_QUERY,
      FILE_MAP_WRITE =      SECTION_MAP_WRITE,
      FILE_MAP_READ =       SECTION_MAP_READ,
      FILE_MAP_ALL_ACCESS = SECTION_ALL_ACCESS,
}


//
// Define access rights to files and directories
//

//
// The FILE_READ_DATA and FILE_WRITE_DATA constants are also defined in
// devioctl.h as FILE_READ_ACCESS and FILE_WRITE_ACCESS. The values for these
// constants *MUST* always be in sync.
// The values are redefined in devioctl.h because they must be available to
// both DOS and NT.
//

enum
{
      FILE_READ_DATA =            ( 0x0001 ),   // file & pipe
      FILE_LIST_DIRECTORY =       ( 0x0001 ),    // directory

      FILE_WRITE_DATA =           ( 0x0002 ),    // file & pipe
      FILE_ADD_FILE =             ( 0x0002 ),    // directory

      FILE_APPEND_DATA =          ( 0x0004 ),    // file
      FILE_ADD_SUBDIRECTORY =     ( 0x0004 ),    // directory
      FILE_CREATE_PIPE_INSTANCE = ( 0x0004 ),    // named pipe

      FILE_READ_EA =              ( 0x0008 ),    // file & directory

      FILE_WRITE_EA =             ( 0x0010 ),    // file & directory

      FILE_EXECUTE =              ( 0x0020 ),    // file
      FILE_TRAVERSE =             ( 0x0020 ),    // directory

      FILE_DELETE_CHILD =         ( 0x0040 ),    // directory

      FILE_READ_ATTRIBUTES =      ( 0x0080 ),    // all

      FILE_WRITE_ATTRIBUTES =     ( 0x0100 ),    // all

      FILE_ALL_ACCESS =     cast(int)(STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF),

      FILE_GENERIC_READ =         cast(int)(STANDARD_RIGHTS_READ  | FILE_READ_DATA |  FILE_READ_ATTRIBUTES |                 FILE_READ_EA |  SYNCHRONIZE),

      FILE_GENERIC_WRITE =        cast(int)(STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA |  FILE_WRITE_ATTRIBUTES |                      FILE_WRITE_EA  |  FILE_APPEND_DATA |  SYNCHRONIZE),

      FILE_GENERIC_EXECUTE =      cast(int)(STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES |                 FILE_EXECUTE |  SYNCHRONIZE),
}

export
{
 BOOL GlobalUnlock(HGLOBAL hMem);
 HGLOBAL GlobalFree(HGLOBAL hMem);
 UINT GlobalCompact(DWORD dwMinFree);
 void GlobalFix(HGLOBAL hMem);
 void GlobalUnfix(HGLOBAL hMem);
 LPVOID GlobalWire(HGLOBAL hMem);
 BOOL GlobalUnWire(HGLOBAL hMem);
 void GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer);
 HLOCAL LocalAlloc(UINT uFlags, UINT uBytes);
 HLOCAL LocalReAlloc(HLOCAL hMem, UINT uBytes, UINT uFlags);
 LPVOID LocalLock(HLOCAL hMem);
 HLOCAL LocalHandle(LPCVOID pMem);
 BOOL LocalUnlock(HLOCAL hMem);
 UINT LocalSize(HLOCAL hMem);
 UINT LocalFlags(HLOCAL hMem);
 HLOCAL LocalFree(HLOCAL hMem);
 UINT LocalShrink(HLOCAL hMem, UINT cbNewSize);
 UINT LocalCompact(UINT uMinFree);
 BOOL FlushInstructionCache(HANDLE hProcess, LPCVOID lpBaseAddress, DWORD dwSize);
 LPVOID VirtualAlloc(LPVOID lpAddress, DWORD dwSize, DWORD flAllocationType, DWORD flProtect);
 BOOL VirtualFree(LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType);
 BOOL VirtualProtect(LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
 DWORD VirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength);
 LPVOID VirtualAllocEx(HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD flAllocationType, DWORD flProtect);
 BOOL VirtualFreeEx(HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD dwFreeType);
 BOOL VirtualProtectEx(HANDLE hProcess, LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
 DWORD VirtualQueryEx(HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength);
}

struct SYSTEMTIME
{
    WORD wYear;
    WORD wMonth;
    WORD wDayOfWeek;
    WORD wDay;
    WORD wHour;
    WORD wMinute;
    WORD wSecond;
    WORD wMilliseconds;
}

struct TIME_ZONE_INFORMATION {
    LONG Bias;
    WCHAR StandardName[ 32 ];
    SYSTEMTIME StandardDate;
    LONG StandardBias;
    WCHAR DaylightName[ 32 ];
    SYSTEMTIME DaylightDate;
    LONG DaylightBias;
}

enum
{
      TIME_ZONE_ID_UNKNOWN =  0,
      TIME_ZONE_ID_STANDARD = 1,
      TIME_ZONE_ID_DAYLIGHT = 2,
}

export void GetSystemTime(SYSTEMTIME* lpSystemTime);
export void GetSystemTimeAsFileTime(FILETIME* lpSystemTimeAsFileTime);
export BOOL SetSystemTime(SYSTEMTIME* lpSystemTime);
export void GetLocalTime(SYSTEMTIME* lpSystemTime);
export BOOL SetLocalTime(SYSTEMTIME* lpSystemTime);
export BOOL SystemTimeToTzSpecificLocalTime(TIME_ZONE_INFORMATION* lpTimeZoneInformation, SYSTEMTIME* lpUniversalTime, SYSTEMTIME* lpLocalTime);
export DWORD GetTimeZoneInformation(TIME_ZONE_INFORMATION* lpTimeZoneInformation);
export BOOL SetTimeZoneInformation(TIME_ZONE_INFORMATION* lpTimeZoneInformation);

export BOOL SystemTimeToFileTime(SYSTEMTIME *lpSystemTime, FILETIME* lpFileTime);
export BOOL FileTimeToLocalFileTime(FILETIME *lpFileTime, FILETIME* lpLocalFileTime);
export BOOL LocalFileTimeToFileTime(FILETIME *lpLocalFileTime, FILETIME* lpFileTime);
export BOOL FileTimeToSystemTime(FILETIME *lpFileTime, SYSTEMTIME* lpSystemTime);
export LONG CompareFileTime(FILETIME *lpFileTime1, FILETIME *lpFileTime2);
export BOOL FileTimeToDosDateTime(FILETIME *lpFileTime, WORD* lpFatDate, WORD* lpFatTime);
export BOOL DosDateTimeToFileTime(WORD wFatDate, WORD wFatTime, FILETIME* lpFileTime);
export DWORD GetTickCount();
export BOOL SetSystemTimeAdjustment(DWORD dwTimeAdjustment, BOOL bTimeAdjustmentDisabled);
export BOOL GetSystemTimeAdjustment(DWORD* lpTimeAdjustment, DWORD* lpTimeIncrement, BOOL* lpTimeAdjustmentDisabled);
export DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, void* *Arguments);export DWORD FormatMessageW(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, void* *Arguments);

enum
{
      FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x00000100,
      FORMAT_MESSAGE_IGNORE_INSERTS =  0x00000200,
      FORMAT_MESSAGE_FROM_STRING =     0x00000400,
      FORMAT_MESSAGE_FROM_HMODULE =    0x00000800,
      FORMAT_MESSAGE_FROM_SYSTEM =     0x00001000,
      FORMAT_MESSAGE_ARGUMENT_ARRAY =  0x00002000,
      FORMAT_MESSAGE_MAX_WIDTH_MASK =  0x000000FF,
};


//
//  Language IDs.
//
//  The following two combinations of primary language ID and
//  sublanguage ID have special semantics:
//
//    Primary Language ID   Sublanguage ID      Result
//    -------------------   ---------------     ------------------------
//    LANG_NEUTRAL          SUBLANG_NEUTRAL     Language neutral
//    LANG_NEUTRAL          SUBLANG_DEFAULT     User default language
//    LANG_NEUTRAL          SUBLANG_SYS_DEFAULT System default language
//

//
//  Primary language IDs.
//

enum
{
      LANG_NEUTRAL                     = 0x00,

      LANG_AFRIKAANS                   = 0x36,
      LANG_ALBANIAN                    = 0x1c,
      LANG_ARABIC                      = 0x01,
      LANG_BASQUE                      = 0x2d,
      LANG_BELARUSIAN                  = 0x23,
      LANG_BULGARIAN                   = 0x02,
      LANG_CATALAN                     = 0x03,
      LANG_CHINESE                     = 0x04,
      LANG_CROATIAN                    = 0x1a,
      LANG_CZECH                       = 0x05,
      LANG_DANISH                      = 0x06,
      LANG_DUTCH                       = 0x13,
      LANG_ENGLISH                     = 0x09,
      LANG_ESTONIAN                    = 0x25,
      LANG_FAEROESE                    = 0x38,
      LANG_FARSI                       = 0x29,
      LANG_FINNISH                     = 0x0b,
      LANG_FRENCH                      = 0x0c,
      LANG_GERMAN                      = 0x07,
      LANG_GREEK                       = 0x08,
      LANG_HEBREW                      = 0x0d,
      LANG_HUNGARIAN                   = 0x0e,
      LANG_ICELANDIC                   = 0x0f,
      LANG_INDONESIAN                  = 0x21,
      LANG_ITALIAN                     = 0x10,
      LANG_JAPANESE                    = 0x11,
      LANG_KOREAN                      = 0x12,
      LANG_LATVIAN                     = 0x26,
      LANG_LITHUANIAN                  = 0x27,
      LANG_NORWEGIAN                   = 0x14,
      LANG_POLISH                      = 0x15,
      LANG_PORTUGUESE                  = 0x16,
      LANG_ROMANIAN                    = 0x18,
      LANG_RUSSIAN                     = 0x19,
      LANG_SERBIAN                     = 0x1a,
      LANG_SLOVAK                      = 0x1b,
      LANG_SLOVENIAN                   = 0x24,
      LANG_SPANISH                     = 0x0a,
      LANG_SWEDISH                     = 0x1d,
      LANG_THAI                        = 0x1e,
      LANG_TURKISH                     = 0x1f,
      LANG_UKRAINIAN                   = 0x22,
      LANG_VIETNAMESE                  = 0x2a,
}
//
//  Sublanguage IDs.
//
//  The name immediately following SUBLANG_ dictates which primary
//  language ID that sublanguage ID can be combined with to form a
//  valid language ID.
//
enum
{
      SUBLANG_NEUTRAL =                  0x00,    // language neutral
      SUBLANG_DEFAULT =                  0x01,    // user default
      SUBLANG_SYS_DEFAULT =              0x02,    // system default

      SUBLANG_ARABIC_SAUDI_ARABIA =      0x01,    // Arabic (Saudi Arabia)
      SUBLANG_ARABIC_IRAQ =              0x02,    // Arabic (Iraq)
      SUBLANG_ARABIC_EGYPT =             0x03,    // Arabic (Egypt)
      SUBLANG_ARABIC_LIBYA =             0x04,    // Arabic (Libya)
      SUBLANG_ARABIC_ALGERIA =           0x05,    // Arabic (Algeria)
      SUBLANG_ARABIC_MOROCCO =           0x06,    // Arabic (Morocco)
      SUBLANG_ARABIC_TUNISIA =           0x07,    // Arabic (Tunisia)
      SUBLANG_ARABIC_OMAN =              0x08,    // Arabic (Oman)
      SUBLANG_ARABIC_YEMEN =             0x09,    // Arabic (Yemen)
      SUBLANG_ARABIC_SYRIA =             0x0a,    // Arabic (Syria)
      SUBLANG_ARABIC_JORDAN =            0x0b,    // Arabic (Jordan)
      SUBLANG_ARABIC_LEBANON =           0x0c,    // Arabic (Lebanon)
      SUBLANG_ARABIC_KUWAIT =            0x0d,    // Arabic (Kuwait)
      SUBLANG_ARABIC_UAE =               0x0e,    // Arabic (U.A.E)
      SUBLANG_ARABIC_BAHRAIN =           0x0f,    // Arabic (Bahrain)
      SUBLANG_ARABIC_QATAR =             0x10,    // Arabic (Qatar)
      SUBLANG_CHINESE_TRADITIONAL =      0x01,    // Chinese (Taiwan)
      SUBLANG_CHINESE_SIMPLIFIED =       0x02,    // Chinese (PR China)
      SUBLANG_CHINESE_HONGKONG =         0x03,    // Chinese (Hong Kong)
      SUBLANG_CHINESE_SINGAPORE =        0x04,    // Chinese (Singapore)
      SUBLANG_DUTCH =                    0x01,    // Dutch
      SUBLANG_DUTCH_BELGIAN =            0x02,    // Dutch (Belgian)
      SUBLANG_ENGLISH_US =               0x01,    // English (USA)
      SUBLANG_ENGLISH_UK =               0x02,    // English (UK)
      SUBLANG_ENGLISH_AUS =              0x03,    // English (Australian)
      SUBLANG_ENGLISH_CAN =              0x04,    // English (Canadian)
      SUBLANG_ENGLISH_NZ =               0x05,    // English (New Zealand)
      SUBLANG_ENGLISH_EIRE =             0x06,    // English (Irish)
      SUBLANG_ENGLISH_SOUTH_AFRICA =     0x07,    // English (South Africa)
      SUBLANG_ENGLISH_JAMAICA =          0x08,    // English (Jamaica)
      SUBLANG_ENGLISH_CARIBBEAN =        0x09,    // English (Caribbean)
      SUBLANG_ENGLISH_BELIZE =           0x0a,    // English (Belize)
      SUBLANG_ENGLISH_TRINIDAD =         0x0b,    // English (Trinidad)
      SUBLANG_FRENCH =                   0x01,    // French
      SUBLANG_FRENCH_BELGIAN =           0x02,    // French (Belgian)
      SUBLANG_FRENCH_CANADIAN =          0x03,    // French (Canadian)
      SUBLANG_FRENCH_SWISS =             0x04,    // French (Swiss)
      SUBLANG_FRENCH_LUXEMBOURG =        0x05,    // French (Luxembourg)
      SUBLANG_GERMAN =                   0x01,    // German
      SUBLANG_GERMAN_SWISS =             0x02,    // German (Swiss)
      SUBLANG_GERMAN_AUSTRIAN =          0x03,    // German (Austrian)
      SUBLANG_GERMAN_LUXEMBOURG =        0x04,    // German (Luxembourg)
      SUBLANG_GERMAN_LIECHTENSTEIN =     0x05,    // German (Liechtenstein)
      SUBLANG_ITALIAN =                  0x01,    // Italian
      SUBLANG_ITALIAN_SWISS =            0x02,    // Italian (Swiss)
      SUBLANG_KOREAN =                   0x01,    // Korean (Extended Wansung)
      SUBLANG_KOREAN_JOHAB =             0x02,    // Korean (Johab)
      SUBLANG_NORWEGIAN_BOKMAL =         0x01,    // Norwegian (Bokmal)
      SUBLANG_NORWEGIAN_NYNORSK =        0x02,    // Norwegian (Nynorsk)
      SUBLANG_PORTUGUESE =               0x02,    // Portuguese
      SUBLANG_PORTUGUESE_BRAZILIAN =     0x01,    // Portuguese (Brazilian)
      SUBLANG_SERBIAN_LATIN =            0x02,    // Serbian (Latin)
      SUBLANG_SERBIAN_CYRILLIC =         0x03,    // Serbian (Cyrillic)
      SUBLANG_SPANISH =                  0x01,    // Spanish (Castilian)
      SUBLANG_SPANISH_MEXICAN =          0x02,    // Spanish (Mexican)
      SUBLANG_SPANISH_MODERN =           0x03,    // Spanish (Modern)
      SUBLANG_SPANISH_GUATEMALA =        0x04,    // Spanish (Guatemala)
      SUBLANG_SPANISH_COSTA_RICA =       0x05,    // Spanish (Costa Rica)
      SUBLANG_SPANISH_PANAMA =           0x06,    // Spanish (Panama)
      SUBLANG_SPANISH_DOMINICAN_REPUBLIC = 0x07,  // Spanish (Dominican Republic)
      SUBLANG_SPANISH_VENEZUELA =        0x08,    // Spanish (Venezuela)
      SUBLANG_SPANISH_COLOMBIA =         0x09,    // Spanish (Colombia)
      SUBLANG_SPANISH_PERU =             0x0a,    // Spanish (Peru)
      SUBLANG_SPANISH_ARGENTINA =        0x0b,    // Spanish (Argentina)
      SUBLANG_SPANISH_ECUADOR =          0x0c,    // Spanish (Ecuador)
      SUBLANG_SPANISH_CHILE =            0x0d,    // Spanish (Chile)
      SUBLANG_SPANISH_URUGUAY =          0x0e,    // Spanish (Uruguay)
      SUBLANG_SPANISH_PARAGUAY =         0x0f,    // Spanish (Paraguay)
      SUBLANG_SPANISH_BOLIVIA =          0x10,    // Spanish (Bolivia)
      SUBLANG_SPANISH_EL_SALVADOR =      0x11,    // Spanish (El Salvador)
      SUBLANG_SPANISH_HONDURAS =         0x12,    // Spanish (Honduras)
      SUBLANG_SPANISH_NICARAGUA =        0x13,    // Spanish (Nicaragua)
      SUBLANG_SPANISH_PUERTO_RICO =      0x14,    // Spanish (Puerto Rico)
      SUBLANG_SWEDISH =                  0x01,    // Swedish
      SUBLANG_SWEDISH_FINLAND =          0x02,    // Swedish (Finland)
}
//
//  Sorting IDs.
//

enum
{
      SORT_DEFAULT                   = 0x0,    // sorting default

      SORT_JAPANESE_XJIS             = 0x0,    // Japanese XJIS order
      SORT_JAPANESE_UNICODE          = 0x1,    // Japanese Unicode order

      SORT_CHINESE_BIG5              = 0x0,    // Chinese BIG5 order
      SORT_CHINESE_PRCP              = 0x0,    // PRC Chinese Phonetic order
      SORT_CHINESE_UNICODE           = 0x1,    // Chinese Unicode order
      SORT_CHINESE_PRC               = 0x2,    // PRC Chinese Stroke Count order

      SORT_KOREAN_KSC                = 0x0,    // Korean KSC order
      SORT_KOREAN_UNICODE            = 0x1,    // Korean Unicode order

      SORT_GERMAN_PHONE_BOOK         = 0x1,    // German Phone Book order
}

// end_r_winnt

//
//  A language ID is a 16 bit value which is the combination of a
//  primary language ID and a secondary language ID.  The bits are
//  allocated as follows:
//
//       +-----------------------+-------------------------+
//       |     Sublanguage ID    |   Primary Language ID   |
//       +-----------------------+-------------------------+
//        15                   10 9                       0   bit
//
//
//  Language ID creation/extraction macros:
//
//    MAKELANGID    - construct language id from a primary language id and
//                    a sublanguage id.
//    PRIMARYLANGID - extract primary language id from a language id.
//    SUBLANGID     - extract sublanguage id from a language id.
//

int MAKELANGID(int p, int s) { return ((cast(WORD)s) << 10) | cast(WORD)p; }
WORD PRIMARYLANGID(int lgid) { return cast(WORD)(lgid & 0x3ff); }
WORD SUBLANGID(int lgid)     { return cast(WORD)(lgid >> 10); }


struct FLOATING_SAVE_AREA {
    DWORD   ControlWord;
    DWORD   StatusWord;
    DWORD   TagWord;
    DWORD   ErrorOffset;
    DWORD   ErrorSelector;
    DWORD   DataOffset;
    DWORD   DataSelector;
    BYTE    RegisterArea[80 ];
    DWORD   Cr0NpxState;
}

enum
{
      SIZE_OF_80387_REGISTERS =      80,
//
// The following flags control the contents of the CONTEXT structure.
//
      CONTEXT_i386 =    0x00010000,    // this assumes that i386 and
      CONTEXT_i486 =    0x00010000,    // i486 have identical context records

      CONTEXT_CONTROL =         (CONTEXT_i386 | 0x00000001), // SS:SP, CS:IP, FLAGS, BP
      CONTEXT_INTEGER =         (CONTEXT_i386 | 0x00000002), // AX, BX, CX, DX, SI, DI
      CONTEXT_SEGMENTS =        (CONTEXT_i386 | 0x00000004), // DS, ES, FS, GS
      CONTEXT_FLOATING_POINT =  (CONTEXT_i386 | 0x00000008), // 387 state
      CONTEXT_DEBUG_REGISTERS = (CONTEXT_i386 | 0x00000010), // DB 0-3,6,7

      CONTEXT_FULL = (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS),
}

struct CONTEXT
{

    //
    // The flags values within this flag control the contents of
    // a CONTEXT record.
    //
    // If the context record is used as an input parameter, then
    // for each portion of the context record controlled by a flag
    // whose value is set, it is assumed that that portion of the
    // context record contains valid context. If the context record
    // is being used to modify a threads context, then only that
    // portion of the threads context will be modified.
    //
    // If the context record is used as an IN OUT parameter to capture
    // the context of a thread, then only those portions of the thread's
    // context corresponding to set flags will be returned.
    //
    // The context record is never used as an OUT only parameter.
    //

    DWORD ContextFlags;

    //
    // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
    // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
    // included in CONTEXT_FULL.
    //

    DWORD   Dr0;
    DWORD   Dr1;
    DWORD   Dr2;
    DWORD   Dr3;
    DWORD   Dr6;
    DWORD   Dr7;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
    //

    FLOATING_SAVE_AREA FloatSave;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_SEGMENTS.
    //

    DWORD   SegGs;
    DWORD   SegFs;
    DWORD   SegEs;
    DWORD   SegDs;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_INTEGER.
    //

    DWORD   Edi;
    DWORD   Esi;
    DWORD   Ebx;
    DWORD   Edx;
    DWORD   Ecx;
    DWORD   Eax;

    //
    // This section is specified/returned if the
    // ContextFlags word contians the flag CONTEXT_CONTROL.
    //

    DWORD   Ebp;
    DWORD   Eip;
    DWORD   SegCs;              // MUST BE SANITIZED
    DWORD   EFlags;             // MUST BE SANITIZED
    DWORD   Esp;
    DWORD   SegSs;
}

enum
{
      THREAD_BASE_PRIORITY_LOWRT =  15,  // value that gets a thread to LowRealtime-1
      THREAD_BASE_PRIORITY_MAX =    2,   // maximum thread base priority boost
      THREAD_BASE_PRIORITY_MIN =    -2,  // minimum thread base priority boost
      THREAD_BASE_PRIORITY_IDLE =   -15, // value that gets a thread to idle

      THREAD_PRIORITY_LOWEST =          THREAD_BASE_PRIORITY_MIN,
      THREAD_PRIORITY_BELOW_NORMAL =    (THREAD_PRIORITY_LOWEST+1),
      THREAD_PRIORITY_NORMAL =          0,
      THREAD_PRIORITY_HIGHEST =         THREAD_BASE_PRIORITY_MAX,
      THREAD_PRIORITY_ABOVE_NORMAL =    (THREAD_PRIORITY_HIGHEST-1),
      THREAD_PRIORITY_ERROR_RETURN =    int.max,

      THREAD_PRIORITY_TIME_CRITICAL =   THREAD_BASE_PRIORITY_LOWRT,
      THREAD_PRIORITY_IDLE =            THREAD_BASE_PRIORITY_IDLE,
}

export HANDLE GetCurrentThread();
export BOOL GetProcessTimes(HANDLE hProcess, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
export HANDLE GetCurrentProcess();
export BOOL DuplicateHandle (HANDLE sourceProcess, HANDLE sourceThread,
        HANDLE targetProcessHandle, HANDLE *targetHandle, DWORD access, 
        BOOL inheritHandle, DWORD options);
export DWORD GetCurrentThreadId();
export BOOL SetThreadPriority(HANDLE hThread, int nPriority);
export BOOL SetThreadPriorityBoost(HANDLE hThread, BOOL bDisablePriorityBoost);
export BOOL GetThreadPriorityBoost(HANDLE hThread, PBOOL pDisablePriorityBoost);
export BOOL GetThreadTimes(HANDLE hThread, LPFILETIME lpCreationTime, LPFILETIME lpExitTime, LPFILETIME lpKernelTime, LPFILETIME lpUserTime);
export int GetThreadPriority(HANDLE hThread);
export BOOL GetThreadContext(HANDLE hThread, CONTEXT* lpContext);
export BOOL SetThreadContext(HANDLE hThread, CONTEXT* lpContext);
export DWORD SuspendThread(HANDLE hThread);
export DWORD ResumeThread(HANDLE hThread);
export DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
export DWORD WaitForMultipleObjects(DWORD nCount, HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds);
export void Sleep(DWORD dwMilliseconds);

export BOOL QueryPerformanceCounter(long* lpPerformanceCount);
export BOOL QueryPerformanceFrequency(long* lpFrequency);

enum
{
      WM_NOTIFY =                       0x004E,
      WM_INPUTLANGCHANGEREQUEST =       0x0050,
      WM_INPUTLANGCHANGE =              0x0051,
      WM_TCARD =                        0x0052,
      WM_HELP =                         0x0053,
      WM_USERCHANGED =                  0x0054,
      WM_NOTIFYFORMAT =                 0x0055,

      NFR_ANSI =                             1,
      NFR_UNICODE =                          2,
      NF_QUERY =                             3,
      NF_REQUERY =                           4,

      WM_CONTEXTMENU =                  0x007B,
      WM_STYLECHANGING =                0x007C,
      WM_STYLECHANGED =                 0x007D,
      WM_DISPLAYCHANGE =                0x007E,
      WM_GETICON =                      0x007F,
      WM_SETICON =                      0x0080,



      WM_NCCREATE =                     0x0081,
      WM_NCDESTROY =                    0x0082,
      WM_NCCALCSIZE =                   0x0083,
      WM_NCHITTEST =                    0x0084,
      WM_NCPAINT =                      0x0085,
      WM_NCACTIVATE =                   0x0086,
      WM_GETDLGCODE =                   0x0087,

      WM_NCMOUSEMOVE =                  0x00A0,
      WM_NCLBUTTONDOWN =                0x00A1,
      WM_NCLBUTTONUP =                  0x00A2,
      WM_NCLBUTTONDBLCLK =              0x00A3,
      WM_NCRBUTTONDOWN =                0x00A4,
      WM_NCRBUTTONUP =                  0x00A5,
      WM_NCRBUTTONDBLCLK =              0x00A6,
      WM_NCMBUTTONDOWN =                0x00A7,
      WM_NCMBUTTONUP =                  0x00A8,
      WM_NCMBUTTONDBLCLK =              0x00A9,

      WM_KEYFIRST =                     0x0100,
      WM_KEYDOWN =                      0x0100,
      WM_KEYUP =                        0x0101,
      WM_CHAR =                         0x0102,
      WM_DEADCHAR =                     0x0103,
      WM_SYSKEYDOWN =                   0x0104,
      WM_SYSKEYUP =                     0x0105,
      WM_SYSCHAR =                      0x0106,
      WM_SYSDEADCHAR =                  0x0107,
      WM_KEYLAST =                      0x0108,


      WM_IME_STARTCOMPOSITION =         0x010D,
      WM_IME_ENDCOMPOSITION =           0x010E,
      WM_IME_COMPOSITION =              0x010F,
      WM_IME_KEYLAST =                  0x010F,


      WM_INITDIALOG =                   0x0110,
      WM_COMMAND =                      0x0111,
      WM_SYSCOMMAND =                   0x0112,
      WM_TIMER =                        0x0113,
      WM_HSCROLL =                      0x0114,
      WM_VSCROLL =                      0x0115,
      WM_INITMENU =                     0x0116,
      WM_INITMENUPOPUP =                0x0117,
      WM_MENUSELECT =                   0x011F,
      WM_MENUCHAR =                     0x0120,
      WM_ENTERIDLE =                    0x0121,

      WM_CTLCOLORMSGBOX =               0x0132,
      WM_CTLCOLOREDIT =                 0x0133,
      WM_CTLCOLORLISTBOX =              0x0134,
      WM_CTLCOLORBTN =                  0x0135,
      WM_CTLCOLORDLG =                  0x0136,
      WM_CTLCOLORSCROLLBAR =            0x0137,
      WM_CTLCOLORSTATIC =               0x0138,



      WM_MOUSEFIRST =                   0x0200,
      WM_MOUSEMOVE =                    0x0200,
      WM_LBUTTONDOWN =                  0x0201,
      WM_LBUTTONUP =                    0x0202,
      WM_LBUTTONDBLCLK =                0x0203,
      WM_RBUTTONDOWN =                  0x0204,
      WM_RBUTTONUP =                    0x0205,
      WM_RBUTTONDBLCLK =                0x0206,
      WM_MBUTTONDOWN =                  0x0207,
      WM_MBUTTONUP =                    0x0208,
      WM_MBUTTONDBLCLK =                0x0209,



      WM_MOUSELAST =                    0x0209,








      WM_PARENTNOTIFY =                 0x0210,
      MENULOOP_WINDOW =                 0,
      MENULOOP_POPUP =                  1,
      WM_ENTERMENULOOP =                0x0211,
      WM_EXITMENULOOP =                 0x0212,


      WM_NEXTMENU =                     0x0213,
}

enum
{
/*
 * Dialog Box Command IDs
 */
      IDOK =                1,
      IDCANCEL =            2,
      IDABORT =             3,
      IDRETRY =             4,
      IDIGNORE =            5,
      IDYES =               6,
      IDNO =                7,

      IDCLOSE =         8,
      IDHELP =          9,


// end_r_winuser



/*
 * Control Manager Structures and Definitions
 */



// begin_r_winuser

/*
 * Edit Control Styles
 */
      ES_LEFT =             0x0000,
      ES_CENTER =           0x0001,
      ES_RIGHT =            0x0002,
      ES_MULTILINE =        0x0004,
      ES_UPPERCASE =        0x0008,
      ES_LOWERCASE =        0x0010,
      ES_PASSWORD =         0x0020,
      ES_AUTOVSCROLL =      0x0040,
      ES_AUTOHSCROLL =      0x0080,
      ES_NOHIDESEL =        0x0100,
      ES_OEMCONVERT =       0x0400,
      ES_READONLY =         0x0800,
      ES_WANTRETURN =       0x1000,

      ES_NUMBER =           0x2000,


// end_r_winuser



/*
 * Edit Control Notification Codes
 */
      EN_SETFOCUS =         0x0100,
      EN_KILLFOCUS =        0x0200,
      EN_CHANGE =           0x0300,
      EN_UPDATE =           0x0400,
      EN_ERRSPACE =         0x0500,
      EN_MAXTEXT =          0x0501,
      EN_HSCROLL =          0x0601,
      EN_VSCROLL =          0x0602,


/* Edit control EM_SETMARGIN parameters */
      EC_LEFTMARGIN =       0x0001,
      EC_RIGHTMARGIN =      0x0002,
      EC_USEFONTINFO =      0xffff,




// begin_r_winuser

/*
 * Edit Control Messages
 */
      EM_GETSEL =               0x00B0,
      EM_SETSEL =               0x00B1,
      EM_GETRECT =              0x00B2,
      EM_SETRECT =              0x00B3,
      EM_SETRECTNP =            0x00B4,
      EM_SCROLL =               0x00B5,
      EM_LINESCROLL =           0x00B6,
      EM_SCROLLCARET =          0x00B7,
      EM_GETMODIFY =            0x00B8,
      EM_SETMODIFY =            0x00B9,
      EM_GETLINECOUNT =         0x00BA,
      EM_LINEINDEX =            0x00BB,
      EM_SETHANDLE =            0x00BC,
      EM_GETHANDLE =            0x00BD,
      EM_GETTHUMB =             0x00BE,
      EM_LINELENGTH =           0x00C1,
      EM_REPLACESEL =           0x00C2,
      EM_GETLINE =              0x00C4,
      EM_LIMITTEXT =            0x00C5,
      EM_CANUNDO =              0x00C6,
      EM_UNDO =                 0x00C7,
      EM_FMTLINES =             0x00C8,
      EM_LINEFROMCHAR =         0x00C9,
      EM_SETTABSTOPS =          0x00CB,
      EM_SETPASSWORDCHAR =      0x00CC,
      EM_EMPTYUNDOBUFFER =      0x00CD,
      EM_GETFIRSTVISIBLELINE =  0x00CE,
      EM_SETREADONLY =          0x00CF,
      EM_SETWORDBREAKPROC =     0x00D0,
      EM_GETWORDBREAKPROC =     0x00D1,
      EM_GETPASSWORDCHAR =      0x00D2,

      EM_SETMARGINS =           0x00D3,
      EM_GETMARGINS =           0x00D4,
      EM_SETLIMITTEXT =         EM_LIMITTEXT, /* ;win40 Name change */
      EM_GETLIMITTEXT =         0x00D5,
      EM_POSFROMCHAR =          0x00D6,
      EM_CHARFROMPOS =          0x00D7,



// end_r_winuser


/*
 * EDITWORDBREAKPROC code values
 */
      WB_LEFT =            0,
      WB_RIGHT =           1,
      WB_ISDELIMITER =     2,

// begin_r_winuser

/*
 * Button Control Styles
 */
      BS_PUSHBUTTON =       0x00000000,
      BS_DEFPUSHBUTTON =    0x00000001,
      BS_CHECKBOX =         0x00000002,
      BS_AUTOCHECKBOX =     0x00000003,
      BS_RADIOBUTTON =      0x00000004,
      BS_3STATE =           0x00000005,
      BS_AUTO3STATE =       0x00000006,
      BS_GROUPBOX =         0x00000007,
      BS_USERBUTTON =       0x00000008,
      BS_AUTORADIOBUTTON =  0x00000009,
      BS_OWNERDRAW =        0x0000000B,
      BS_LEFTTEXT =         0x00000020,

      BS_TEXT =             0x00000000,
      BS_ICON =             0x00000040,
      BS_BITMAP =           0x00000080,
      BS_LEFT =             0x00000100,
      BS_RIGHT =            0x00000200,
      BS_CENTER =           0x00000300,
      BS_TOP =              0x00000400,
      BS_BOTTOM =           0x00000800,
      BS_VCENTER =          0x00000C00,
      BS_PUSHLIKE =         0x00001000,
      BS_MULTILINE =        0x00002000,
      BS_NOTIFY =           0x00004000,
      BS_FLAT =             0x00008000,
      BS_RIGHTBUTTON =      BS_LEFTTEXT,



/*
 * User Button Notification Codes
 */
      BN_CLICKED =          0,
      BN_PAINT =            1,
      BN_HILITE =           2,
      BN_UNHILITE =         3,
      BN_DISABLE =          4,
      BN_DOUBLECLICKED =    5,

      BN_PUSHED =           BN_HILITE,
      BN_UNPUSHED =         BN_UNHILITE,
      BN_DBLCLK =           BN_DOUBLECLICKED,
      BN_SETFOCUS =         6,
      BN_KILLFOCUS =        7,

/*
 * Button Control Messages
 */
      BM_GETCHECK =        0x00F0,
      BM_SETCHECK =        0x00F1,
      BM_GETSTATE =        0x00F2,
      BM_SETSTATE =        0x00F3,
      BM_SETSTYLE =        0x00F4,

      BM_CLICK =           0x00F5,
      BM_GETIMAGE =        0x00F6,
      BM_SETIMAGE =        0x00F7,

      BST_UNCHECKED =      0x0000,
      BST_CHECKED =        0x0001,
      BST_INDETERMINATE =  0x0002,
      BST_PUSHED =         0x0004,
      BST_FOCUS =          0x0008,


/*
 * Static Control Constants
 */
      SS_LEFT =             0x00000000,
      SS_CENTER =           0x00000001,
      SS_RIGHT =            0x00000002,
      SS_ICON =             0x00000003,
      SS_BLACKRECT =        0x00000004,
      SS_GRAYRECT =         0x00000005,
      SS_WHITERECT =        0x00000006,
      SS_BLACKFRAME =       0x00000007,
      SS_GRAYFRAME =        0x00000008,
      SS_WHITEFRAME =       0x00000009,
      SS_USERITEM =         0x0000000A,
      SS_SIMPLE =           0x0000000B,
      SS_LEFTNOWORDWRAP =   0x0000000C,

      SS_OWNERDRAW =        0x0000000D,
      SS_BITMAP =           0x0000000E,
      SS_ENHMETAFILE =      0x0000000F,
      SS_ETCHEDHORZ =       0x00000010,
      SS_ETCHEDVERT =       0x00000011,
      SS_ETCHEDFRAME =      0x00000012,
      SS_TYPEMASK =         0x0000001F,

      SS_NOPREFIX =         0x00000080, /* Don't do "&" character translation */

      SS_NOTIFY =           0x00000100,
      SS_CENTERIMAGE =      0x00000200,
      SS_RIGHTJUST =        0x00000400,
      SS_REALSIZEIMAGE =    0x00000800,
      SS_SUNKEN =           0x00001000,
      SS_ENDELLIPSIS =      0x00004000,
      SS_PATHELLIPSIS =     0x00008000,
      SS_WORDELLIPSIS =     0x0000C000,
      SS_ELLIPSISMASK =     0x0000C000,


// end_r_winuser


/*
 * Static Control Mesages
 */
      STM_SETICON =         0x0170,
      STM_GETICON =         0x0171,

      STM_SETIMAGE =        0x0172,
      STM_GETIMAGE =        0x0173,
      STN_CLICKED =         0,
      STN_DBLCLK =          1,
      STN_ENABLE =          2,
      STN_DISABLE =         3,

      STM_MSGMAX =          0x0174,
}


enum
{
/*
 * Window Messages
 */

      WM_NULL =                         0x0000,
      WM_CREATE =                       0x0001,
      WM_DESTROY =                      0x0002,
      WM_MOVE =                         0x0003,
      WM_SIZE =                         0x0005,

      WM_ACTIVATE =                     0x0006,
/*
 * WM_ACTIVATE state values
 */
      WA_INACTIVE =     0,
      WA_ACTIVE =       1,
      WA_CLICKACTIVE =  2,

      WM_SETFOCUS =                     0x0007,
      WM_KILLFOCUS =                    0x0008,
      WM_ENABLE =                       0x000A,
      WM_SETREDRAW =                    0x000B,
      WM_SETTEXT =                      0x000C,
      WM_GETTEXT =                      0x000D,
      WM_GETTEXTLENGTH =                0x000E,
      WM_PAINT =                        0x000F,
      WM_CLOSE =                        0x0010,
      WM_QUERYENDSESSION =              0x0011,
      WM_QUIT =                         0x0012,
      WM_QUERYOPEN =                    0x0013,
      WM_ERASEBKGND =                   0x0014,
      WM_SYSCOLORCHANGE =               0x0015,
      WM_ENDSESSION =                   0x0016,
      WM_SHOWWINDOW =                   0x0018,
      WM_WININICHANGE =                 0x001A,

      WM_SETTINGCHANGE =                WM_WININICHANGE,



      WM_DEVMODECHANGE =                0x001B,
      WM_ACTIVATEAPP =                  0x001C,
      WM_FONTCHANGE =                   0x001D,
      WM_TIMECHANGE =                   0x001E,
      WM_CANCELMODE =                   0x001F,
      WM_SETCURSOR =                    0x0020,
      WM_MOUSEACTIVATE =                0x0021,
      WM_CHILDACTIVATE =                0x0022,
      WM_QUEUESYNC =                    0x0023,

      WM_GETMINMAXINFO =                0x0024,
}

struct RECT
{
    LONG    left;
    LONG    top;
    LONG    right;
    LONG    bottom;
}
alias RECT* PRECT, NPRECT, LPRECT;

struct PAINTSTRUCT {
    HDC         hdc;
    BOOL        fErase;
    RECT        rcPaint;
    BOOL        fRestore;
    BOOL        fIncUpdate;
    BYTE        rgbReserved[32];
}
alias PAINTSTRUCT* PPAINTSTRUCT, NPPAINTSTRUCT, LPPAINTSTRUCT;

// flags for GetDCEx()

enum
{
      DCX_WINDOW =           0x00000001,
      DCX_CACHE =            0x00000002,
      DCX_NORESETATTRS =     0x00000004,
      DCX_CLIPCHILDREN =     0x00000008,
      DCX_CLIPSIBLINGS =     0x00000010,
      DCX_PARENTCLIP =       0x00000020,
      DCX_EXCLUDERGN =       0x00000040,
      DCX_INTERSECTRGN =     0x00000080,
      DCX_EXCLUDEUPDATE =    0x00000100,
      DCX_INTERSECTUPDATE =  0x00000200,
      DCX_LOCKWINDOWUPDATE = 0x00000400,
      DCX_VALIDATE =         0x00200000,
}

export
{
 BOOL UpdateWindow(HWND hWnd);
 HWND SetActiveWindow(HWND hWnd);
 HWND GetForegroundWindow();
 BOOL PaintDesktop(HDC hdc);
 BOOL SetForegroundWindow(HWND hWnd);
 HWND WindowFromDC(HDC hDC);
 HDC GetDC(HWND hWnd);
 HDC GetDCEx(HWND hWnd, HRGN hrgnClip, DWORD flags);
 HDC GetWindowDC(HWND hWnd);
 int ReleaseDC(HWND hWnd, HDC hDC);
 HDC BeginPaint(HWND hWnd, LPPAINTSTRUCT lpPaint);
 BOOL EndPaint(HWND hWnd, PAINTSTRUCT *lpPaint);
 BOOL GetUpdateRect(HWND hWnd, LPRECT lpRect, BOOL bErase);
 int GetUpdateRgn(HWND hWnd, HRGN hRgn, BOOL bErase);
 int SetWindowRgn(HWND hWnd, HRGN hRgn, BOOL bRedraw);
 int GetWindowRgn(HWND hWnd, HRGN hRgn);
 int ExcludeUpdateRgn(HDC hDC, HWND hWnd);
 BOOL InvalidateRect(HWND hWnd, RECT *lpRect, BOOL bErase);
 BOOL ValidateRect(HWND hWnd, RECT *lpRect);
 BOOL InvalidateRgn(HWND hWnd, HRGN hRgn, BOOL bErase);
 BOOL ValidateRgn(HWND hWnd, HRGN hRgn);
 BOOL RedrawWindow(HWND hWnd, RECT *lprcUpdate, HRGN hrgnUpdate, UINT flags);
}

// flags for RedrawWindow()
enum
{
      RDW_INVALIDATE =          0x0001,
      RDW_INTERNALPAINT =       0x0002,
      RDW_ERASE =               0x0004,
      RDW_VALIDATE =            0x0008,
      RDW_NOINTERNALPAINT =     0x0010,
      RDW_NOERASE =             0x0020,
      RDW_NOCHILDREN =          0x0040,
      RDW_ALLCHILDREN =         0x0080,
      RDW_UPDATENOW =           0x0100,
      RDW_ERASENOW =            0x0200,
      RDW_FRAME =               0x0400,
      RDW_NOFRAME =             0x0800,
}

export
{
 BOOL GetClientRect(HWND hWnd, LPRECT lpRect);
 BOOL GetWindowRect(HWND hWnd, LPRECT lpRect);
 BOOL AdjustWindowRect(LPRECT lpRect, DWORD dwStyle, BOOL bMenu);
 BOOL AdjustWindowRectEx(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle);
 HFONT CreateFontA(int, int, int, int, int, DWORD,
                             DWORD, DWORD, DWORD, DWORD, DWORD,
                             DWORD, DWORD, LPCSTR);
 HFONT CreateFontW(int, int, int, int, int, DWORD,
                             DWORD, DWORD, DWORD, DWORD, DWORD,
                             DWORD, DWORD, LPCWSTR);
}

enum
{
      OUT_DEFAULT_PRECIS =          0,
      OUT_STRING_PRECIS =           1,
      OUT_CHARACTER_PRECIS =        2,
      OUT_STROKE_PRECIS =           3,
      OUT_TT_PRECIS =               4,
      OUT_DEVICE_PRECIS =           5,
      OUT_RASTER_PRECIS =           6,
      OUT_TT_ONLY_PRECIS =          7,
      OUT_OUTLINE_PRECIS =          8,
      OUT_SCREEN_OUTLINE_PRECIS =   9,

      CLIP_DEFAULT_PRECIS =     0,
      CLIP_CHARACTER_PRECIS =   1,
      CLIP_STROKE_PRECIS =      2,
      CLIP_MASK =               0xf,
      CLIP_LH_ANGLES =          (1<<4),
      CLIP_TT_ALWAYS =          (2<<4),
      CLIP_EMBEDDED =           (8<<4),

      DEFAULT_QUALITY =         0,
      DRAFT_QUALITY =           1,
      PROOF_QUALITY =           2,

      NONANTIALIASED_QUALITY =  3,
      ANTIALIASED_QUALITY =     4,


      DEFAULT_PITCH =           0,
      FIXED_PITCH =             1,
      VARIABLE_PITCH =          2,

      MONO_FONT =               8,


      ANSI_CHARSET =            0,
      DEFAULT_CHARSET =         1,
      SYMBOL_CHARSET =          2,
      SHIFTJIS_CHARSET =        128,
      HANGEUL_CHARSET =         129,
      GB2312_CHARSET =          134,
      CHINESEBIG5_CHARSET =     136,
      OEM_CHARSET =             255,

      JOHAB_CHARSET =           130,
      HEBREW_CHARSET =          177,
      ARABIC_CHARSET =          178,
      GREEK_CHARSET =           161,
      TURKISH_CHARSET =         162,
      VIETNAMESE_CHARSET =      163,
      THAI_CHARSET =            222,
      EASTEUROPE_CHARSET =      238,
      RUSSIAN_CHARSET =         204,

      MAC_CHARSET =             77,
      BALTIC_CHARSET =          186,

      FS_LATIN1 =               0x00000001L,
      FS_LATIN2 =               0x00000002L,
      FS_CYRILLIC =             0x00000004L,
      FS_GREEK =                0x00000008L,
      FS_TURKISH =              0x00000010L,
      FS_HEBREW =               0x00000020L,
      FS_ARABIC =               0x00000040L,
      FS_BALTIC =               0x00000080L,
      FS_VIETNAMESE =           0x00000100L,
      FS_THAI =                 0x00010000L,
      FS_JISJAPAN =             0x00020000L,
      FS_CHINESESIMP =          0x00040000L,
      FS_WANSUNG =              0x00080000L,
      FS_CHINESETRAD =          0x00100000L,
      FS_JOHAB =                0x00200000L,
      FS_SYMBOL =               cast(int)0x80000000L,


/* Font Families */
      FF_DONTCARE =         (0<<4), /* Don't care or don't know. */
      FF_ROMAN =            (1<<4), /* Variable stroke width, serifed. */
                                    /* Times Roman, Century Schoolbook, etc. */
      FF_SWISS =            (2<<4), /* Variable stroke width, sans-serifed. */
                                    /* Helvetica, Swiss, etc. */
      FF_MODERN =           (3<<4), /* Constant stroke width, serifed or sans-serifed. */
                                    /* Pica, Elite, Courier, etc. */
      FF_SCRIPT =           (4<<4), /* Cursive, etc. */
      FF_DECORATIVE =       (5<<4), /* Old English, etc. */

/* Font Weights */
      FW_DONTCARE =         0,
      FW_THIN =             100,
      FW_EXTRALIGHT =       200,
      FW_LIGHT =            300,
      FW_NORMAL =           400,
      FW_MEDIUM =           500,
      FW_SEMIBOLD =         600,
      FW_BOLD =             700,
      FW_EXTRABOLD =        800,
      FW_HEAVY =            900,

      FW_ULTRALIGHT =       FW_EXTRALIGHT,
      FW_REGULAR =          FW_NORMAL,
      FW_DEMIBOLD =         FW_SEMIBOLD,
      FW_ULTRABOLD =        FW_EXTRABOLD,
      FW_BLACK =            FW_HEAVY,

      PANOSE_COUNT =               10,
      PAN_FAMILYTYPE_INDEX =        0,
      PAN_SERIFSTYLE_INDEX =        1,
      PAN_WEIGHT_INDEX =            2,
      PAN_PROPORTION_INDEX =        3,
      PAN_CONTRAST_INDEX =          4,
      PAN_STROKEVARIATION_INDEX =   5,
      PAN_ARMSTYLE_INDEX =          6,
      PAN_LETTERFORM_INDEX =        7,
      PAN_MIDLINE_INDEX =           8,
      PAN_XHEIGHT_INDEX =           9,

      PAN_CULTURE_LATIN =           0,
}

struct RGBQUAD {
        BYTE    rgbBlue;
        BYTE    rgbGreen;
        BYTE    rgbRed;
        BYTE    rgbReserved;
}
alias RGBQUAD* LPRGBQUAD;

struct BITMAPINFOHEADER
{
        DWORD      biSize;
        LONG       biWidth;
        LONG       biHeight;
        WORD       biPlanes;
        WORD       biBitCount;
        DWORD      biCompression;
        DWORD      biSizeImage;
        LONG       biXPelsPerMeter;
        LONG       biYPelsPerMeter;
        DWORD      biClrUsed;
        DWORD      biClrImportant;
}
alias BITMAPINFOHEADER* LPBITMAPINFOHEADER, PBITMAPINFOHEADER;

struct BITMAPINFO {
    BITMAPINFOHEADER    bmiHeader;
    RGBQUAD             bmiColors[1];
}
alias BITMAPINFO* LPBITMAPINFO, PBITMAPINFO;

struct PALETTEENTRY {
    BYTE        peRed;
    BYTE        peGreen;
    BYTE        peBlue;
    BYTE        peFlags;
}
alias PALETTEENTRY* PPALETTEENTRY, LPPALETTEENTRY;

struct LOGPALETTE {
    WORD        palVersion;
    WORD        palNumEntries;
    PALETTEENTRY        palPalEntry[1];
}
alias LOGPALETTE* PLOGPALETTE, NPLOGPALETTE, LPLOGPALETTE;

/* Pixel format descriptor */
struct PIXELFORMATDESCRIPTOR
{
    WORD  nSize;
    WORD  nVersion;
    DWORD dwFlags;
    BYTE  iPixelType;
    BYTE  cColorBits;
    BYTE  cRedBits;
    BYTE  cRedShift;
    BYTE  cGreenBits;
    BYTE  cGreenShift;
    BYTE  cBlueBits;
    BYTE  cBlueShift;
    BYTE  cAlphaBits;
    BYTE  cAlphaShift;
    BYTE  cAccumBits;
    BYTE  cAccumRedBits;
    BYTE  cAccumGreenBits;
    BYTE  cAccumBlueBits;
    BYTE  cAccumAlphaBits;
    BYTE  cDepthBits;
    BYTE  cStencilBits;
    BYTE  cAuxBuffers;
    BYTE  iLayerType;
    BYTE  bReserved;
    DWORD dwLayerMask;
    DWORD dwVisibleMask;
    DWORD dwDamageMask;
}
alias PIXELFORMATDESCRIPTOR* PPIXELFORMATDESCRIPTOR, LPPIXELFORMATDESCRIPTOR;


export
{
 BOOL   RoundRect(HDC, int, int, int, int, int, int);
 BOOL   ResizePalette(HPALETTE, UINT);
 int    SaveDC(HDC);
 int    SelectClipRgn(HDC, HRGN);
 int    ExtSelectClipRgn(HDC, HRGN, int);
 int    SetMetaRgn(HDC);
 HGDIOBJ   SelectObject(HDC, HGDIOBJ);
 HPALETTE   SelectPalette(HDC, HPALETTE, BOOL);
 COLORREF   SetBkColor(HDC, COLORREF);
 int     SetBkMode(HDC, int);
 LONG    SetBitmapBits(HBITMAP, DWORD, void *);
 UINT    SetBoundsRect(HDC,   RECT *, UINT);
 int     SetDIBits(HDC, HBITMAP, UINT, UINT, void *, BITMAPINFO *, UINT);
 int     SetDIBitsToDevice(HDC, int, int, DWORD, DWORD, int,
        int, UINT, UINT, void *, BITMAPINFO *, UINT);
 DWORD   SetMapperFlags(HDC, DWORD);
 int     SetGraphicsMode(HDC hdc, int iMode);
 int     SetMapMode(HDC, int);
 HMETAFILE     SetMetaFileBitsEx(UINT, BYTE *);
 UINT    SetPaletteEntries(HPALETTE, UINT, UINT, PALETTEENTRY *);
 COLORREF   SetPixel(HDC, int, int, COLORREF);
 BOOL     SetPixelV(HDC, int, int, COLORREF);
 BOOL    SetPixelFormat(HDC, int, PIXELFORMATDESCRIPTOR *);
 int     SetPolyFillMode(HDC, int);
 BOOL    StretchBlt(HDC, int, int, int, int, HDC, int, int, int, int, DWORD);
 BOOL    SetRectRgn(HRGN, int, int, int, int);
 int     StretchDIBits(HDC, int, int, int, int, int, int, int, int,
         void *, BITMAPINFO *, UINT, DWORD);
 int     SetROP2(HDC, int);
 int     SetStretchBltMode(HDC, int);
 UINT    SetSystemPaletteUse(HDC, UINT);
 int     SetTextCharacterExtra(HDC, int);
 COLORREF   SetTextColor(HDC, COLORREF);
 UINT    SetTextAlign(HDC, UINT);
 BOOL    SetTextJustification(HDC, int, int);
 BOOL    UpdateColors(HDC);
}

/* Text Alignment Options */
enum
{
      TA_NOUPDATECP =                0,
      TA_UPDATECP =                  1,

      TA_LEFT =                      0,
      TA_RIGHT =                     2,
      TA_CENTER =                    6,

      TA_TOP =                       0,
      TA_BOTTOM =                    8,
      TA_BASELINE =                  24,

      TA_RTLREADING =                256,
      TA_MASK =       (TA_BASELINE+TA_CENTER+TA_UPDATECP+TA_RTLREADING),
}

struct POINT
{
    LONG  x;
    LONG  y;
}
alias POINT* PPOINT, NPPOINT, LPPOINT;


export
{
 BOOL    MoveToEx(HDC, int, int, LPPOINT);
 BOOL    TextOutA(HDC, int, int, LPCSTR, int);
 BOOL    TextOutW(HDC, int, int, LPCWSTR, int);
}

export void PostQuitMessage(int nExitCode);
export LRESULT DefWindowProcA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
export HMODULE GetModuleHandleA(LPCSTR lpModuleName);

alias LRESULT (* WNDPROC)(HWND, UINT, WPARAM, LPARAM);

struct WNDCLASSEXA {
    UINT        cbSize;
    /* Win 3.x */
    UINT        style;
    WNDPROC     lpfnWndProc;
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;
    LPCSTR      lpszMenuName;
    LPCSTR      lpszClassName;
    /* Win 4.0 */
    HICON       hIconSm;
}
alias WNDCLASSEXA* PWNDCLASSEXA, NPWNDCLASSEXA, LPWNDCLASSEXA;


struct WNDCLASSA {
    UINT        style;
    WNDPROC     lpfnWndProc;
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;
    LPCSTR      lpszMenuName;
    LPCSTR      lpszClassName;
}
alias WNDCLASSA* PWNDCLASSA, NPWNDCLASSA, LPWNDCLASSA;
alias WNDCLASSA WNDCLASS;

/*
 * Window Styles
 */
enum : uint
{
      WS_OVERLAPPED =       0x00000000,
      WS_POPUP =            0x80000000,
      WS_CHILD =            0x40000000,
      WS_MINIMIZE =         0x20000000,
      WS_VISIBLE =          0x10000000,
      WS_DISABLED =         0x08000000,
      WS_CLIPSIBLINGS =     0x04000000,
      WS_CLIPCHILDREN =     0x02000000,
      WS_MAXIMIZE =         0x01000000,
      WS_CAPTION =          0x00C00000,  /* WS_BORDER | WS_DLGFRAME  */
      WS_BORDER =           0x00800000,
      WS_DLGFRAME =         0x00400000,
      WS_VSCROLL =          0x00200000,
      WS_HSCROLL =          0x00100000,
      WS_SYSMENU =          0x00080000,
      WS_THICKFRAME =       0x00040000,
      WS_GROUP =            0x00020000,
      WS_TABSTOP =          0x00010000,

      WS_MINIMIZEBOX =      0x00020000,
      WS_MAXIMIZEBOX =      0x00010000,

      WS_TILED =            WS_OVERLAPPED,
      WS_ICONIC =           WS_MINIMIZE,
      WS_SIZEBOX =          WS_THICKFRAME,

/*
 * Common Window Styles
 */
      WS_OVERLAPPEDWINDOW = (WS_OVERLAPPED |            WS_CAPTION |  WS_SYSMENU |  WS_THICKFRAME |            WS_MINIMIZEBOX |                 WS_MAXIMIZEBOX),
      WS_TILEDWINDOW =      WS_OVERLAPPEDWINDOW,
      WS_POPUPWINDOW =      (WS_POPUP |  WS_BORDER |  WS_SYSMENU),
      WS_CHILDWINDOW =      (WS_CHILD),
}

/*
 * Class styles
 */
enum
{
      CS_VREDRAW =          0x0001,
      CS_HREDRAW =          0x0002,
      CS_KEYCVTWINDOW =     0x0004,
      CS_DBLCLKS =          0x0008,
      CS_OWNDC =            0x0020,
      CS_CLASSDC =          0x0040,
      CS_PARENTDC =         0x0080,
      CS_NOKEYCVT =         0x0100,
      CS_NOCLOSE =          0x0200,
      CS_SAVEBITS =         0x0800,
      CS_BYTEALIGNCLIENT =  0x1000,
      CS_BYTEALIGNWINDOW =  0x2000,
      CS_GLOBALCLASS =      0x4000,


      CS_IME =              0x00010000,
}

export
{
 HICON LoadIconA(HINSTANCE hInstance, LPCSTR lpIconName);
 HICON LoadIconW(HINSTANCE hInstance, LPCWSTR lpIconName);
 HCURSOR LoadCursorA(HINSTANCE hInstance, LPCSTR lpCursorName);
 HCURSOR LoadCursorW(HINSTANCE hInstance, LPCWSTR lpCursorName);
}

const LPSTR IDI_APPLICATION =     cast(LPSTR)(32512);

const LPSTR IDC_ARROW =           cast(LPSTR)(32512);
const LPSTR IDC_CROSS =           cast(LPSTR)(32515);

/*
 * Color Types
 */
enum
{
      CTLCOLOR_MSGBOX =         0,
      CTLCOLOR_EDIT =           1,
      CTLCOLOR_LISTBOX =        2,
      CTLCOLOR_BTN =            3,
      CTLCOLOR_DLG =            4,
      CTLCOLOR_SCROLLBAR =      5,
      CTLCOLOR_STATIC =         6,
      CTLCOLOR_MAX =            7,

      COLOR_SCROLLBAR =         0,
      COLOR_BACKGROUND =        1,
      COLOR_ACTIVECAPTION =     2,
      COLOR_INACTIVECAPTION =   3,
      COLOR_MENU =              4,
      COLOR_WINDOW =            5,
      COLOR_WINDOWFRAME =       6,
      COLOR_MENUTEXT =          7,
      COLOR_WINDOWTEXT =        8,
      COLOR_CAPTIONTEXT =       9,
      COLOR_ACTIVEBORDER =      10,
      COLOR_INACTIVEBORDER =    11,
      COLOR_APPWORKSPACE =      12,
      COLOR_HIGHLIGHT =         13,
      COLOR_HIGHLIGHTTEXT =     14,
      COLOR_BTNFACE =           15,
      COLOR_BTNSHADOW =         16,
      COLOR_GRAYTEXT =          17,
      COLOR_BTNTEXT =           18,
      COLOR_INACTIVECAPTIONTEXT = 19,
      COLOR_BTNHIGHLIGHT =      20,


      COLOR_3DDKSHADOW =        21,
      COLOR_3DLIGHT =           22,
      COLOR_INFOTEXT =          23,
      COLOR_INFOBK =            24,

      COLOR_DESKTOP =           COLOR_BACKGROUND,
      COLOR_3DFACE =            COLOR_BTNFACE,
      COLOR_3DSHADOW =          COLOR_BTNSHADOW,
      COLOR_3DHIGHLIGHT =       COLOR_BTNHIGHLIGHT,
      COLOR_3DHILIGHT =         COLOR_BTNHIGHLIGHT,
      COLOR_BTNHILIGHT =        COLOR_BTNHIGHLIGHT,
}

const int CW_USEDEFAULT = cast(int)0x80000000;
/*
 * Special value for CreateWindow, et al.
 */
const HWND HWND_DESKTOP = (cast(HWND)0);


export ATOM RegisterClassA(WNDCLASSA *lpWndClass);

export HWND CreateWindowExA(
    DWORD dwExStyle,
    LPCSTR lpClassName,
    LPCSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent ,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam);


HWND CreateWindowA(
    LPCSTR lpClassName,
    LPCSTR lpWindowName,
    DWORD dwStyle,
    int X,
    int Y,
    int nWidth,
    int nHeight,
    HWND hWndParent ,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam)
{
    return CreateWindowExA(0, lpClassName, lpWindowName, dwStyle, X, Y, nWidth, nHeight, hWndParent, hMenu, hInstance, lpParam);
}

/*
 * Message structure
 */
struct MSG {
    HWND        hwnd;
    UINT        message;
    WPARAM      wParam;
    LPARAM      lParam;
    DWORD       time;
    POINT       pt;
}
alias MSG* PMSG, NPMSG, LPMSG;

export
{
 BOOL GetMessageA(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax);
 BOOL TranslateMessage(MSG *lpMsg);
 LONG DispatchMessageA(MSG *lpMsg);
 BOOL PeekMessageA(MSG *lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg);
 HWND GetFocus();
}

export DWORD ExpandEnvironmentStringsA(LPCSTR lpSrc, LPSTR lpDst, DWORD nSize);

export
{
 BOOL IsValidCodePage(UINT CodePage);
 UINT GetACP();
 UINT GetOEMCP();
 //BOOL GetCPInfo(UINT CodePage, LPCPINFO lpCPInfo);
 BOOL IsDBCSLeadByte(BYTE TestChar);
 BOOL IsDBCSLeadByteEx(UINT CodePage, BYTE TestChar);
 int MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cchMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
 int WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int cchWideChar, LPSTR lpMultiByteStr, int cchMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar);
}

export HANDLE CreateFileMappingA(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCSTR lpName);
export HANDLE CreateFileMappingW(HANDLE hFile, LPSECURITY_ATTRIBUTES lpFileMappingAttributes, DWORD flProtect, DWORD dwMaximumSizeHigh, DWORD dwMaximumSizeLow, LPCWSTR lpName);

export BOOL GetMailslotInfo(HANDLE hMailslot, LPDWORD lpMaxMessageSize, LPDWORD lpNextSize, LPDWORD lpMessageCount, LPDWORD lpReadTimeout);
export BOOL SetMailslotInfo(HANDLE hMailslot, DWORD lReadTimeout);
export LPVOID MapViewOfFile(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap);
export LPVOID MapViewOfFileEx(HANDLE hFileMappingObject, DWORD dwDesiredAccess, DWORD dwFileOffsetHigh, DWORD dwFileOffsetLow, DWORD dwNumberOfBytesToMap, LPVOID lpBaseAddress);
export BOOL FlushViewOfFile(LPCVOID lpBaseAddress, DWORD dwNumberOfBytesToFlush);
export BOOL UnmapViewOfFile(LPCVOID lpBaseAddress);

export  HGDIOBJ   GetStockObject(int);
export BOOL ShowWindow(HWND hWnd, int nCmdShow);

/* Stock Logical Objects */
enum
{     WHITE_BRUSH =         0,
      LTGRAY_BRUSH =        1,
      GRAY_BRUSH =          2,
      DKGRAY_BRUSH =        3,
      BLACK_BRUSH =         4,
      NULL_BRUSH =          5,
      HOLLOW_BRUSH =        NULL_BRUSH,
      WHITE_PEN =           6,
      BLACK_PEN =           7,
      NULL_PEN =            8,
      OEM_FIXED_FONT =      10,
      ANSI_FIXED_FONT =     11,
      ANSI_VAR_FONT =       12,
      SYSTEM_FONT =         13,
      DEVICE_DEFAULT_FONT = 14,
      DEFAULT_PALETTE =     15,
      SYSTEM_FIXED_FONT =   16,
      DEFAULT_GUI_FONT =    17,
      STOCK_LAST =          17,
}

/*
 * ShowWindow() Commands
 */
enum
{     SW_HIDE =             0,
      SW_SHOWNORMAL =       1,
      SW_NORMAL =           1,
      SW_SHOWMINIMIZED =    2,
      SW_SHOWMAXIMIZED =    3,
      SW_MAXIMIZE =         3,
      SW_SHOWNOACTIVATE =   4,
      SW_SHOW =             5,
      SW_MINIMIZE =         6,
      SW_SHOWMINNOACTIVE =  7,
      SW_SHOWNA =           8,
      SW_RESTORE =          9,
      SW_SHOWDEFAULT =      10,
      SW_MAX =              10,
}

struct TEXTMETRICA
{
    LONG        tmHeight;
    LONG        tmAscent;
    LONG        tmDescent;
    LONG        tmInternalLeading;
    LONG        tmExternalLeading;
    LONG        tmAveCharWidth;
    LONG        tmMaxCharWidth;
    LONG        tmWeight;
    LONG        tmOverhang;
    LONG        tmDigitizedAspectX;
    LONG        tmDigitizedAspectY;
    BYTE        tmFirstChar;
    BYTE        tmLastChar;
    BYTE        tmDefaultChar;
    BYTE        tmBreakChar;
    BYTE        tmItalic;
    BYTE        tmUnderlined;
    BYTE        tmStruckOut;
    BYTE        tmPitchAndFamily;
    BYTE        tmCharSet;
}

export  BOOL   GetTextMetricsA(HDC, TEXTMETRICA*);

/*
 * Scroll Bar Constants
 */
enum
{     SB_HORZ =             0,
      SB_VERT =             1,
      SB_CTL =              2,
      SB_BOTH =             3,
}

/*
 * Scroll Bar Commands
 */
enum
{     SB_LINEUP =           0,
      SB_LINELEFT =         0,
      SB_LINEDOWN =         1,
      SB_LINERIGHT =        1,
      SB_PAGEUP =           2,
      SB_PAGELEFT =         2,
      SB_PAGEDOWN =         3,
      SB_PAGERIGHT =        3,
      SB_THUMBPOSITION =    4,
      SB_THUMBTRACK =       5,
      SB_TOP =              6,
      SB_LEFT =             6,
      SB_BOTTOM =           7,
      SB_RIGHT =            7,
      SB_ENDSCROLL =        8,
}

export int SetScrollPos(HWND hWnd, int nBar, int nPos, BOOL bRedraw);
export int GetScrollPos(HWND hWnd, int nBar);
export BOOL SetScrollRange(HWND hWnd, int nBar, int nMinPos, int nMaxPos, BOOL bRedraw);
export BOOL GetScrollRange(HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos);
export BOOL ShowScrollBar(HWND hWnd, int wBar, BOOL bShow);
export BOOL EnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows);

/*
 * LockWindowUpdate API
 */

export BOOL LockWindowUpdate(HWND hWndLock);
export BOOL ScrollWindow(HWND hWnd, int XAmount, int YAmount, RECT* lpRect, RECT* lpClipRect);
export BOOL ScrollDC(HDC hDC, int dx, int dy, RECT* lprcScroll, RECT* lprcClip, HRGN hrgnUpdate, LPRECT lprcUpdate);
export int ScrollWindowEx(HWND hWnd, int dx, int dy, RECT* prcScroll, RECT* prcClip, HRGN hrgnUpdate, LPRECT prcUpdate, UINT flags);

/*
 * Virtual Keys, Standard Set
 */
enum
{     VK_LBUTTON =        0x01,
      VK_RBUTTON =        0x02,
      VK_CANCEL =         0x03,
      VK_MBUTTON =        0x04, /* NOT contiguous with L & RBUTTON */

      VK_BACK =           0x08,
      VK_TAB =            0x09,

      VK_CLEAR =          0x0C,
      VK_RETURN =         0x0D,

      VK_SHIFT =          0x10,
      VK_CONTROL =        0x11,
      VK_MENU =           0x12,
      VK_PAUSE =          0x13,
      VK_CAPITAL =        0x14,


      VK_ESCAPE =         0x1B,

      VK_SPACE =          0x20,
      VK_PRIOR =          0x21,
      VK_NEXT =           0x22,
      VK_END =            0x23,
      VK_HOME =           0x24,
      VK_LEFT =           0x25,
      VK_UP =             0x26,
      VK_RIGHT =          0x27,
      VK_DOWN =           0x28,
      VK_SELECT =         0x29,
      VK_PRINT =          0x2A,
      VK_EXECUTE =        0x2B,
      VK_SNAPSHOT =       0x2C,
      VK_INSERT =         0x2D,
      VK_DELETE =         0x2E,
      VK_HELP =           0x2F,

/* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
/* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */

      VK_LWIN =           0x5B,
      VK_RWIN =           0x5C,
      VK_APPS =           0x5D,

      VK_NUMPAD0 =        0x60,
      VK_NUMPAD1 =        0x61,
      VK_NUMPAD2 =        0x62,
      VK_NUMPAD3 =        0x63,
      VK_NUMPAD4 =        0x64,
      VK_NUMPAD5 =        0x65,
      VK_NUMPAD6 =        0x66,
      VK_NUMPAD7 =        0x67,
      VK_NUMPAD8 =        0x68,
      VK_NUMPAD9 =        0x69,
      VK_MULTIPLY =       0x6A,
      VK_ADD =            0x6B,
      VK_SEPARATOR =      0x6C,
      VK_SUBTRACT =       0x6D,
      VK_DECIMAL =        0x6E,
      VK_DIVIDE =         0x6F,
      VK_F1 =             0x70,
      VK_F2 =             0x71,
      VK_F3 =             0x72,
      VK_F4 =             0x73,
      VK_F5 =             0x74,
      VK_F6 =             0x75,
      VK_F7 =             0x76,
      VK_F8 =             0x77,
      VK_F9 =             0x78,
      VK_F10 =            0x79,
      VK_F11 =            0x7A,
      VK_F12 =            0x7B,
      VK_F13 =            0x7C,
      VK_F14 =            0x7D,
      VK_F15 =            0x7E,
      VK_F16 =            0x7F,
      VK_F17 =            0x80,
      VK_F18 =            0x81,
      VK_F19 =            0x82,
      VK_F20 =            0x83,
      VK_F21 =            0x84,
      VK_F22 =            0x85,
      VK_F23 =            0x86,
      VK_F24 =            0x87,

      VK_NUMLOCK =        0x90,
      VK_SCROLL =         0x91,

/*
 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
 * Used only as parameters to GetAsyncKeyState() and GetKeyState().
 * No other API or message will distinguish left and right keys in this way.
 */
      VK_LSHIFT =         0xA0,
      VK_RSHIFT =         0xA1,
      VK_LCONTROL =       0xA2,
      VK_RCONTROL =       0xA3,
      VK_LMENU =          0xA4,
      VK_RMENU =          0xA5,


      VK_PROCESSKEY =     0xE5,


      VK_ATTN =           0xF6,
      VK_CRSEL =          0xF7,
      VK_EXSEL =          0xF8,
      VK_EREOF =          0xF9,
      VK_PLAY =           0xFA,
      VK_ZOOM =           0xFB,
      VK_NONAME =         0xFC,
      VK_PA1 =            0xFD,
      VK_OEM_CLEAR =      0xFE,
}

export LRESULT SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

alias UINT (*LPOFNHOOKPROC) (HWND, UINT, WPARAM, LPARAM);

struct OPENFILENAMEA {
   DWORD        lStructSize;
   HWND         hwndOwner;
   HINSTANCE    hInstance;
   LPCSTR       lpstrFilter;
   LPSTR        lpstrCustomFilter;
   DWORD        nMaxCustFilter;
   DWORD        nFilterIndex;
   LPSTR        lpstrFile;
   DWORD        nMaxFile;
   LPSTR        lpstrFileTitle;
   DWORD        nMaxFileTitle;
   LPCSTR       lpstrInitialDir;
   LPCSTR       lpstrTitle;
   DWORD        Flags;
   WORD         nFileOffset;
   WORD         nFileExtension;
   LPCSTR       lpstrDefExt;
   LPARAM       lCustData;
   LPOFNHOOKPROC lpfnHook;
   LPCSTR       lpTemplateName;
}
alias OPENFILENAMEA *LPOPENFILENAMEA;

struct OPENFILENAMEW {
   DWORD        lStructSize;
   HWND         hwndOwner;
   HINSTANCE    hInstance;
   LPCWSTR      lpstrFilter;
   LPWSTR       lpstrCustomFilter;
   DWORD        nMaxCustFilter;
   DWORD        nFilterIndex;
   LPWSTR       lpstrFile;
   DWORD        nMaxFile;
   LPWSTR       lpstrFileTitle;
   DWORD        nMaxFileTitle;
   LPCWSTR      lpstrInitialDir;
   LPCWSTR      lpstrTitle;
   DWORD        Flags;
   WORD         nFileOffset;
   WORD         nFileExtension;
   LPCWSTR      lpstrDefExt;
   LPARAM       lCustData;
   LPOFNHOOKPROC lpfnHook;
   LPCWSTR      lpTemplateName;
}
alias OPENFILENAMEW *LPOPENFILENAMEW;

BOOL          GetOpenFileNameA(LPOPENFILENAMEA);
BOOL          GetOpenFileNameW(LPOPENFILENAMEW);

BOOL          GetSaveFileNameA(LPOPENFILENAMEA);
BOOL          GetSaveFileNameW(LPOPENFILENAMEW);

short         GetFileTitleA(LPCSTR, LPSTR, WORD);
short         GetFileTitleW(LPCWSTR, LPWSTR, WORD);

enum
{
      PM_NOREMOVE =         0x0000,
      PM_REMOVE =           0x0001,
      PM_NOYIELD =          0x0002,
}

/* Bitmap Header Definition */
struct BITMAP
{
    LONG        bmType;
    LONG        bmWidth;
    LONG        bmHeight;
    LONG        bmWidthBytes;
    WORD        bmPlanes;
    WORD        bmBitsPixel;
    LPVOID      bmBits;
}
alias BITMAP* PBITMAP, NPBITMAP, LPBITMAP;


export  HDC       CreateCompatibleDC(HDC);

export  int     GetObjectA(HGDIOBJ, int, LPVOID);
export  int     GetObjectW(HGDIOBJ, int, LPVOID);
export  BOOL   DeleteDC(HDC);

struct LOGFONTA
{
    LONG      lfHeight;
    LONG      lfWidth;
    LONG      lfEscapement;
    LONG      lfOrientation;
    LONG      lfWeight;
    BYTE      lfItalic;
    BYTE      lfUnderline;
    BYTE      lfStrikeOut;
    BYTE      lfCharSet;
    BYTE      lfOutPrecision;
    BYTE      lfClipPrecision;
    BYTE      lfQuality;
    BYTE      lfPitchAndFamily;
    CHAR      lfFaceName[32 ];
}
alias LOGFONTA* PLOGFONTA, NPLOGFONTA, LPLOGFONTA;

export HMENU LoadMenuA(HINSTANCE hInstance, LPCSTR lpMenuName);
export HMENU LoadMenuW(HINSTANCE hInstance, LPCWSTR lpMenuName);

export HMENU GetSubMenu(HMENU hMenu, int nPos);

export HBITMAP LoadBitmapA(HINSTANCE hInstance, LPCSTR lpBitmapName);
export HBITMAP LoadBitmapW(HINSTANCE hInstance, LPCWSTR lpBitmapName);

LPSTR MAKEINTRESOURCEA(int i) { return cast(LPSTR)(cast(DWORD)(cast(WORD)(i))); }

export  HFONT     CreateFontIndirectA(LOGFONTA *);

export BOOL MessageBeep(UINT uType);
export int ShowCursor(BOOL bShow);
export BOOL SetCursorPos(int X, int Y);
export HCURSOR SetCursor(HCURSOR hCursor);
export BOOL GetCursorPos(LPPOINT lpPoint);
export BOOL ClipCursor( RECT *lpRect);
export BOOL GetClipCursor(LPRECT lpRect);
export HCURSOR GetCursor();
export BOOL CreateCaret(HWND hWnd, HBITMAP hBitmap , int nWidth, int nHeight);
export UINT GetCaretBlinkTime();
export BOOL SetCaretBlinkTime(UINT uMSeconds);
export BOOL DestroyCaret();
export BOOL HideCaret(HWND hWnd);
export BOOL ShowCaret(HWND hWnd);
export BOOL SetCaretPos(int X, int Y);
export BOOL GetCaretPos(LPPOINT lpPoint);
export BOOL ClientToScreen(HWND hWnd, LPPOINT lpPoint);
export BOOL ScreenToClient(HWND hWnd, LPPOINT lpPoint);
export int MapWindowPoints(HWND hWndFrom, HWND hWndTo, LPPOINT lpPoints, UINT cPoints);
export HWND WindowFromPoint(POINT Point);
export HWND ChildWindowFromPoint(HWND hWndParent, POINT Point);


export BOOL TrackPopupMenu(HMENU hMenu, UINT uFlags, int x, int y,
      int nReserved, HWND hWnd, RECT *prcRect);

align (2) struct DLGTEMPLATE {
    DWORD style;
    DWORD dwExtendedStyle;
    WORD cdit;
    short x;
    short y;
    short cx;
    short cy;
}
alias DLGTEMPLATE *LPDLGTEMPLATEA;
alias DLGTEMPLATE *LPDLGTEMPLATEW;


alias LPDLGTEMPLATEA LPDLGTEMPLATE;

alias  DLGTEMPLATE *LPCDLGTEMPLATEA;
alias  DLGTEMPLATE *LPCDLGTEMPLATEW;


alias LPCDLGTEMPLATEA LPCDLGTEMPLATE;


export int DialogBoxParamA(HINSTANCE hInstance, LPCSTR lpTemplateName,
      HWND hWndParent, DLGPROC lpDialogFunc, LPARAM dwInitParam);
export int DialogBoxIndirectParamA(HINSTANCE hInstance,
      LPCDLGTEMPLATEA hDialogTemplate, HWND hWndParent, DLGPROC lpDialogFunc,
      LPARAM dwInitParam);

enum : DWORD
{
      SRCCOPY =             cast(DWORD)0x00CC0020, /* dest = source                   */
      SRCPAINT =            cast(DWORD)0x00EE0086, /* dest = source OR dest           */
      SRCAND =              cast(DWORD)0x008800C6, /* dest = source AND dest          */
      SRCINVERT =           cast(DWORD)0x00660046, /* dest = source XOR dest          */
      SRCERASE =            cast(DWORD)0x00440328, /* dest = source AND (NOT dest)   */
      NOTSRCCOPY =          cast(DWORD)0x00330008, /* dest = (NOT source)             */
      NOTSRCERASE =         cast(DWORD)0x001100A6, /* dest = (NOT src) AND (NOT dest) */
      MERGECOPY =           cast(DWORD)0x00C000CA, /* dest = (source AND pattern)     */
      MERGEPAINT =          cast(DWORD)0x00BB0226, /* dest = (NOT source) OR dest     */
      PATCOPY =             cast(DWORD)0x00F00021, /* dest = pattern                  */
      PATPAINT =            cast(DWORD)0x00FB0A09, /* dest = DPSnoo                   */
      PATINVERT =           cast(DWORD)0x005A0049, /* dest = pattern XOR dest         */
      DSTINVERT =           cast(DWORD)0x00550009, /* dest = (NOT dest)               */
      BLACKNESS =           cast(DWORD)0x00000042, /* dest = BLACK                    */
      WHITENESS =           cast(DWORD)0x00FF0062, /* dest = WHITE                    */
}

enum
{
      SND_SYNC =            0x0000, /* play synchronously (default) */
      SND_ASYNC =           0x0001, /* play asynchronously */
      SND_NODEFAULT =       0x0002, /* silence (!default) if sound not found */
      SND_MEMORY =          0x0004, /* pszSound points to a memory file */
      SND_LOOP =            0x0008, /* loop the sound until next sndPlaySound */
      SND_NOSTOP =          0x0010, /* don't stop any currently playing sound */

      SND_NOWAIT =      0x00002000, /* don't wait if the driver is busy */
      SND_ALIAS =       0x00010000, /* name is a registry alias */
      SND_ALIAS_ID =    0x00110000, /* alias is a predefined ID */
      SND_FILENAME =    0x00020000, /* name is file name */
      SND_RESOURCE =    0x00040004, /* name is resource name or atom */

      SND_PURGE =           0x0040, /* purge non-static events for task */
      SND_APPLICATION =     0x0080, /* look for application specific association */


      SND_ALIAS_START = 0,     /* alias base */
}

export  BOOL   PlaySoundA(LPCSTR pszSound, HMODULE hmod, DWORD fdwSound);
export  BOOL   PlaySoundW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound);

export  int     GetClipBox(HDC, LPRECT);
export  int     GetClipRgn(HDC, HRGN);
export  int     GetMetaRgn(HDC, HRGN);
export  HGDIOBJ   GetCurrentObject(HDC, UINT);
export  BOOL    GetCurrentPositionEx(HDC, LPPOINT);
export  int     GetDeviceCaps(HDC, int);

struct LOGPEN
  {
    UINT        lopnStyle;
    POINT       lopnWidth;
    COLORREF    lopnColor;
}
alias LOGPEN* PLOGPEN, NPLOGPEN, LPLOGPEN;

enum
{
      PS_SOLID =            0,
      PS_DASH =             1, /* -------  */
      PS_DOT =              2, /* .......  */
      PS_DASHDOT =          3, /* _._._._  */
      PS_DASHDOTDOT =       4, /* _.._.._  */
      PS_NULL =             5,
      PS_INSIDEFRAME =      6,
      PS_USERSTYLE =        7,
      PS_ALTERNATE =        8,
      PS_STYLE_MASK =       0x0000000F,

      PS_ENDCAP_ROUND =     0x00000000,
      PS_ENDCAP_SQUARE =    0x00000100,
      PS_ENDCAP_FLAT =      0x00000200,
      PS_ENDCAP_MASK =      0x00000F00,

      PS_JOIN_ROUND =       0x00000000,
      PS_JOIN_BEVEL =       0x00001000,
      PS_JOIN_MITER =       0x00002000,
      PS_JOIN_MASK =        0x0000F000,

      PS_COSMETIC =         0x00000000,
      PS_GEOMETRIC =        0x00010000,
      PS_TYPE_MASK =        0x000F0000,
}

export  HPALETTE   CreatePalette(LOGPALETTE *);
export  HPEN      CreatePen(int, int, COLORREF);
export  HPEN      CreatePenIndirect(LOGPEN *);
export  HRGN      CreatePolyPolygonRgn(POINT *, INT *, int, int);
export  HBRUSH    CreatePatternBrush(HBITMAP);
export  HRGN      CreateRectRgn(int, int, int, int);
export  HRGN      CreateRectRgnIndirect(RECT *);
export  HRGN      CreateRoundRectRgn(int, int, int, int, int, int);
export  BOOL      CreateScalableFontResourceA(DWORD, LPCSTR, LPCSTR, LPCSTR);
export  BOOL      CreateScalableFontResourceW(DWORD, LPCWSTR, LPCWSTR, LPCWSTR);

COLORREF RGB(int r, int g, int b)
{
    return cast(COLORREF)
      ((cast(BYTE)r|(cast(WORD)(cast(BYTE)g)<<8))|((cast(DWORD)cast(BYTE)b)<<16));
}

export  BOOL   LineTo(HDC, int, int);
export  BOOL   DeleteObject(HGDIOBJ);
export int FillRect(HDC hDC,  RECT *lprc, HBRUSH hbr);


export BOOL EndDialog(HWND hDlg, int nResult);
export HWND GetDlgItem(HWND hDlg, int nIDDlgItem);

export BOOL SetDlgItemInt(HWND hDlg, int nIDDlgItem, UINT uValue, BOOL bSigned);
export UINT GetDlgItemInt(HWND hDlg, int nIDDlgItem, BOOL *lpTranslated,
    BOOL bSigned);

export BOOL SetDlgItemTextA(HWND hDlg, int nIDDlgItem, LPCSTR lpString);
export BOOL SetDlgItemTextW(HWND hDlg, int nIDDlgItem, LPCWSTR lpString);

export UINT GetDlgItemTextA(HWND hDlg, int nIDDlgItem, LPSTR lpString, int nMaxCount);
export UINT GetDlgItemTextW(HWND hDlg, int nIDDlgItem, LPWSTR lpString, int nMaxCount);

export BOOL CheckDlgButton(HWND hDlg, int nIDButton, UINT uCheck);
export BOOL CheckRadioButton(HWND hDlg, int nIDFirstButton, int nIDLastButton,
    int nIDCheckButton);

export UINT IsDlgButtonChecked(HWND hDlg, int nIDButton);

export HWND SetFocus(HWND hWnd);

export int wsprintfA(LPSTR, LPCSTR, ...);
export int wsprintfW(LPWSTR, LPCWSTR, ...);

const uint INFINITE = uint.max;
const uint WAIT_OBJECT_0 = 0;

export HANDLE CreateSemaphoreA(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCTSTR lpName);
export HANDLE OpenSemaphoreA(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCTSTR lpName);
export BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);
}

Generated by  Doxygen 1.6.0   Back to index