/*
 * This module declared types required by DWT but not in std.c.windows.windows
 */
 
module dwt.internal.win32.WINTYPES;

public import tango.sys.win32.Types;

// missing in tango
//alias TLOGFONTA* LPLOGFONTA;
//alias TLOGFONTA LOGFONTA;
alias char CHAR;
alias OPENFILENAME OPENFILENAMEW;
alias OPENFILENAME OPENFILENAMEA;
alias WNDCLASS   WNDCLASSA;
alias WNDCLASSA* LPWNDCLASSA;


// ....


const int LF_FACESIZE = 32;
const int LF_FULLFACESIZE = 64;

alias HANDLE HIMC;
alias HANDLE HTREEITEM;
alias HANDLE HDWP;
alias HANDLE HIMAGELIST;
alias HANDLE HMONITOR;
alias HANDLE HHOOK;
alias HANDLE HDROP;
//alias HANDLE *LPHANDLE;

alias HRESULT WINOLEAPI;
alias LPRECT LPCRECT;
alias LPRECT LPCRECTL;
alias DWORD LGRPID;
//alias LONG LONG_PTR;
alias ULONG ULONG_PTR;
alias DWORD DWORD_PTR;
alias int INT_PTR;
//alias uint UINT_PTR;
alias DWORD LCID;
alias DWORD LCTYPE;
alias USHORT COLOR16;

alias POINT POINTL;

alias long LONGLONG;
alias ulong DWORDLONG;

alias LONGLONG  *PLONGLONG;
alias DWORDLONG *PDWORDLONG;
alias size_t    SIZE_T;
alias int       WPARAM_I;

version(ANSI){
    alias char  TCHAR;
}else{
    alias wchar TCHAR;
}


extern(Windows){

/**
 * Since Eclipse/SWT uses int as (msg, wparam, lparam) and some times check the value against (-1),
 * but WNDPROC_I declared in windows header the (msg, wparam) is UINT which will never be -1 but 0xFFFF or 
 * something else. This made some DWT API failed. to fix the problem, it better to declare (msg, wparam) 
 * as int like Eclispe/SWT does. and we alias int to WPARAM_I.
 */
alias LRESULT function(HWND, int, int, int) WNDPROC_I;
alias LRESULT function(int code, int wParam, LPARAM lParam) HOOKPROC_I;

// Windows CALLBACK declaration here
alias WNDPROC_I BFFCALLBACK;        // browse for fold 
alias WNDPROC_I LPCCHOOKPROC_I;     // choose color
alias WNDPROC_I LPCFHOOKPROC_I;     // choose font
alias WNDPROC_I LPPRINTHOOKPROC_I;  // print hook
alias WNDPROC_I LPSETUPHOOKPROC_I;  // print setup
alias WNDPROC_I TIMERPROC_I;        // timer

alias LRESULT function (
    int code,       // hook code
    int wParam,  // undefined
    int lParam   // address of structure with message data
) MESSAGEPROC;


//alias BOOL function (
//  HMONITOR hMonitor,  // handle to display monitor
//  HDC hdcMonitor,     // handle to monitor-appropriate device context
//  LPRECT lprcMonitor, // pointer to monitor intersection rectangle
//  LPARAM dwData       // data passed from EnumDisplayMonitors
//) MONITORENUMPROC;

//alias int function(
//  ENUMLOGFONT *lpelf,    // logical-font data
//  NEWTEXTMETRIC *lpntm,  // physical-font data
//  DWORD FontType,        // type of font
//  LPARAM lParam          // application-defined data
//)FONTENUMPROC;

//alias int function(
//  ENUMLOGFONTEX *lpelfe,    // logical-font data
//  NEWTEXTMETRICEX *lpntme,  // physical-font data
//  DWORD FontType,           // type of font
//  LPARAM lParam             // application-defined data
//)FONTENUMEXPROC;

alias BOOL function (
  LGRPID LanguageGroup,             // language-group identifier
  TCHAR* lpLanguageGroupString,     // language-group identifier string
  TCHAR* lpLanguageGroupNameString, // language-group name string 
  DWORD dwFlags,                    // options
  LONG_PTR  lParam                  // callback parameter
)LANGUAGEGROUP_ENUMPROC;

//alias BOOL function (
//  TCHAR* lpLocaleString   // locale identifier string
//)LOCALE_ENUMPROC;


// end of Windows CALLBACK declaration



//struct ABC { 
//    int     abcA; 
//    UINT    abcB; 
//    int     abcC; 
//}
//alias ABC* PABC, LPABC;

// declared in tango
//struct ACCEL {
//    align(1):
//    BYTE   fVirt; 
//    WORD   key; 
//    WORD   cmd;
//}
//alias ACCEL* PACCEL, LPACCEL;

// declared in phobos
//struct BITMAP {
//  int bmType;
//  int bmWidth;
//  int bmHeight;
//  int bmWidthBytes;
//  short bmPlanes;
//  short bmBitsPixel;
//  void* bmBits;
//}

//struct RGBQUAD { // rgbq 
//    byte    rgbBlue; 
//    byte    rgbGreen; 
//    byte    rgbRed; 
//    byte    rgbReserved; 
//}

// declared in phobos
//struct BITMAPINFO { // bmi 
//    BITMAPINFOHEADER bmiHeader; 
//    RGBQUAD          bmiColors[1]; 
//}

//struct BITMAPINFOHEADER {
//  int biSize;
//  int biWidth;
//  int biHeight;
//  short biPlanes;
//  short biBitCount;
//  int biCompression;
//  int biSizeImage;
//  int biXPelsPerMeter;
//  int biYPelsPerMeter;
//  int biClrUsed;
//  int biClrImportant;
//}


struct BROWSEINFOA {
    HWND hwndOwner; 
    LPCITEMIDLIST pidlRoot; 
    LPSTR pszDisplayName; 
    LPCSTR lpszTitle; 
    UINT ulFlags; 
    BFFCALLBACK lpfn;
    LPARAM lParam; 
    int iImage;
}

struct BROWSEINFOW {
    HWND hwndOwner; 
    LPCITEMIDLIST pidlRoot; 
    LPWSTR pszDisplayName; 
    LPCWSTR lpszTitle; 
    UINT ulFlags; 
    BFFCALLBACK lpfn;
    LPARAM lParam; 
    int iImage;
}
version(ANSI){
    alias BROWSEINFOA BROWSEINFO;
} else {
    alias BROWSEINFOW BROWSEINFO;
}
alias BROWSEINFO* PBROWSEINFO, LPBROWSEINFO;

//struct CHARSETINFO {
//    UINT ciCharset;
//    UINT ciACP;
//    FONTSIGNATURE fs;
//}alias CHARSETINFO* PCHARSETINFO, LPCHARSETINFO;


struct CHOOSECOLORA {
    DWORD        lStructSize; 
    HWND         hwndOwner; 
    HWND         hInstance; 
    COLORREF     rgbResult; 
    COLORREF*    lpCustColors; 
    DWORD        Flags; 
    LPARAM       lCustData; 
    LPCCHOOKPROC_I lpfnHook; 
    LPCSTR      lpTemplateName; 
}
alias CHOOSECOLORA* PCHOOSECOLORA, LPCHOOSECOLORA;
struct CHOOSECOLORW {
    DWORD        lStructSize; 
    HWND         hwndOwner; 
    HWND         hInstance; 
    COLORREF     rgbResult; 
    COLORREF*    lpCustColors; 
    DWORD        Flags; 
    LPARAM       lCustData; 
    LPCCHOOKPROC_I lpfnHook; 
    LPCWSTR      lpTemplateName; 
}
alias CHOOSECOLORW* PCHOOSECOLORW, LPCHOOSECOLORW;
version(ANSI){
    alias CHOOSECOLORA CHOOSECOLOR;
}else{
    alias CHOOSECOLORW CHOOSECOLOR;
}
alias CHOOSECOLOR* PCHOOSECOLOR, LPCHOOSECOLOR;


struct CHOOSEFONTA {
    // sizeof = 60 ???
//  align(2):   
    DWORD        lStructSize; 
    HWND         hwndOwner; 
    HDC          hDC; 
    LPLOGFONTA   lpLogFont; 
    INT          iPointSize; 
    DWORD        Flags; 
    DWORD        rgbColors; 
    LPARAM       lCustData; 
    LPCFHOOKPROC_I lpfnHook; 
    LPCSTR      lpTemplateName; 
    HINSTANCE    hInstance; 
    LPSTR       lpszStyle; 
    WORD         nFontType; 
    WORD         ___MISSING_ALIGNMENT__; 
    INT          nSizeMin; 
    INT          nSizeMax;  
}alias CHOOSEFONTA* PCHOOSEFONTA, LPCHOOSEFONTA;

struct CHOOSEFONTW {
    // sizeof = 60 ???
//  align(2):   
    DWORD        lStructSize; 
    HWND         hwndOwner; 
    HDC          hDC; 
    LOGFONTW*    lpLogFont; 
    INT          iPointSize; 
    DWORD        Flags; 
    DWORD        rgbColors; 
    LPARAM       lCustData; 
    LPCFHOOKPROC_I lpfnHook; 
    LPCWSTR      lpTemplateName; 
    HINSTANCE    hInstance; 
    LPWSTR       lpszStyle; 
    WORD         nFontType; 
    WORD         ___MISSING_ALIGNMENT__; 
    INT          nSizeMin; 
    INT          nSizeMax;  
}alias CHOOSEFONTW* PCHOOSEFONTW, LPCHOOSEFONTW;
version(ANSI){
    alias CHOOSEFONTA CHOOSEFONT;
}else{
    alias CHOOSEFONTW CHOOSEFONT;
}

struct COMBOBOXINFO {
    DWORD cbSize;
    RECT rcItem;
    RECT rcButton;
    DWORD stateButton;
    HWND hwndCombo;
    HWND hwndItem;
    HWND hwndList;
} alias COMBOBOXINFO* PCOMBOBOXINFO, LPCOMBOBOXINFO;

//struct COMPOSITIONFORM {
//    DWORD dwStyle;
//    POINT ptCurrentPos;
//    RECT rcArea;
//}
//alias COMPOSITIONFORM* LPCOMPOSITIONFORM;

struct CREATESTRUCT {
    int lpCreateParams; 
    HINSTANCE hInstance; 
    HMENU hMenu; 
    HWND hwndParent; 
    int cy; 
    int cx; 
    int y; 
    int x; 
    int style; 
    int lpszName; 
    int lpszClass; 
    int dwExStyle;  
}

const uint CCHDEVICENAME = 32;
const uint CCHFORMNAME = 32;

struct DEVMODEA {    // dvmd 
    BYTE   dmDeviceName[CCHDEVICENAME]; 
    WORD   dmSpecVersion; 
    WORD   dmDriverVersion; 
    WORD   dmSize; 
    WORD   dmDriverExtra; 
    DWORD  dmFields; 
//    union {
//      struct {
//        short dmOrientation;
//        short dmPaperSize;
//        short dmPaperLength;
//        short dmPaperWidth;
//      };
//      POINTL dmPosition;
//    };
    POINT  dmPosition;
    short  dmScale; 
    short  dmCopies; 
    short  dmDefaultSource; 
    short  dmPrintQuality; 
    short  dmColor; 
    short  dmDuplex; 
    short  dmYResolution; 
    short  dmTTOption; 
    short  dmCollate; 
    BYTE  dmFormName[CCHFORMNAME]; 
    WORD  dmLogPixels; 
    DWORD  dmBitsPerPel; 
    DWORD  dmPelsWidth; 
    DWORD  dmPelsHeight; 
    DWORD  dmDisplayFlags; 
    DWORD  dmDisplayFrequency; 
//#if(WINVER >= 0x0400) 
    DWORD  dmICMMethod;
    DWORD  dmICMIntent;
    DWORD  dmMediaType;
    DWORD  dmDitherType;
    DWORD  dmReserved1;
    DWORD  dmReserved2;
//#if (WINVER >= 0x0500) || (_WIN32_WINNT >= 0x0400)
    DWORD  dmPanningWidth;
    DWORD  dmPanningHeight;
//#endif
//#endif /* WINVER >= 0x0400 */
} 

struct DEVMODEW {    // dvmd 
    WCHAR  dmDeviceName[CCHDEVICENAME]; 
    WORD   dmSpecVersion; 
    WORD   dmDriverVersion; 
    WORD   dmSize; 
    WORD   dmDriverExtra; 
    DWORD  dmFields; 
//    union {
//      struct {
//        short dmOrientation;
//        short dmPaperSize;
//        short dmPaperLength;
//        short dmPaperWidth;
//      };
      POINTL dmPosition;
//    };
    short  dmScale; 
    short  dmCopies; 
    short  dmDefaultSource; 
    short  dmPrintQuality; 
    short  dmColor; 
    short  dmDuplex; 
    short  dmYResolution; 
    short  dmTTOption; 
    short  dmCollate; 
    WCHAR dmFormName[CCHFORMNAME]; 
    WORD  dmLogPixels; 
    DWORD  dmBitsPerPel; 
    DWORD  dmPelsWidth; 
    DWORD  dmPelsHeight; 
    DWORD  dmDisplayFlags; 
    DWORD  dmDisplayFrequency; 
//#if(WINVER >= 0x0400) 
    DWORD  dmICMMethod;
    DWORD  dmICMIntent;
    DWORD  dmMediaType;
    DWORD  dmDitherType;
    DWORD  dmReserved1;
    DWORD  dmReserved2;
//#if (WINVER >= 0x0500) || (_WIN32_WINNT >= 0x0400)
    DWORD  dmPanningWidth;
    DWORD  dmPanningHeight;
//#endif
//#endif /* WINVER >= 0x0400 */
}

//PORTING_TODO: defined in tango
//version(ANSI){
//    alias DEVMODEA DEVMODE;
//}else{
//    alias DEVMODEW DEVMODE;
//}
struct DEVNAMES {
    WORD wDriverOffset;
    WORD wDeviceOffset;
    WORD wOutputOffset;
    WORD wDefault;
}

struct DIBSECTION {
    // BITMAP
    int bmType;
    int bmWidth;
    int bmHeight;
    int bmWidthBytes;
    short bmPlanes;
    short bmBitsPixel;
    void* bmBits;
    // end BITMAP   
    int biSize;
    int biWidth;
    int biHeight;
    short biPlanes;
    short biBitCount;
    int biCompression;
    int biSizeImage;
    int biXPelsPerMeter;
    int biYPelsPerMeter;
    int biClrUsed;
    int biClrImportant;
    int dsBitfields0;
    int dsBitfields1;
    int dsBitfields2;
    int dshSection;
    int dsOffset;
}

struct DLLVERSIONINFO {
    DWORD cbSize;
    DWORD dwMajorVersion;
    DWORD dwMinorVersion;
    DWORD dwBuildNumber;
    DWORD dwPlatformID;
}

struct DOCINFOA {
    int     cbSize;
    LPCSTR   lpszDocName;
    LPCSTR   lpszOutput;
    LPCSTR   lpszDatatype;
    DWORD    fwType;
}

struct DOCINFOW {
    int     cbSize;
    LPCWSTR  lpszDocName;
    LPCWSTR  lpszOutput;
    LPCWSTR  lpszDatatype;
    DWORD    fwType;
} 
version(ANSI){
    alias DOCINFOA DOCINFO; 
}else{
    alias DOCINFOW DOCINFO;
}
alias DOCINFO* LPDOCINFO;


struct DRAWITEMSTRUCT {
    UINT  CtlType; 
    UINT  CtlID; 
    UINT  itemID; 
    UINT  itemAction; 
    UINT  itemState; 
    HWND  hwndItem; 
    HDC   hDC; 
    RECT  rcItem; 
    DWORD itemData;
}

struct DROPFILES {
    DWORD  pFiles; // Offset of the file list from the beginning of this structure, in bytes.
    POINT pt; // Drop point. The coordinates depend on fNC.
    BOOL fNC;   // Nonclient area flag. If this member is TRUE, pt specifies the screen 
                      // coordinates of a point in a window's nonclient area. If it is FALSE, 
                      // pt specifies the client coordinates of a point in the client area. 
    BOOL fWide; // Value that indicates whether the file contains ANSI or Unicode 
                      // characters. If it is zero, it contains ANSI characters. Otherwise, it 
                      // contains Unicode characters.
    
}


struct ENUMLOGFONTA { 
  LOGFONTA elfLogFont; 
  CHAR   elfFullName[LF_FULLFACESIZE]; 
  CHAR   elfStyle[LF_FACESIZE]; 
} 
struct ENUMLOGFONTW { 
  LOGFONTW elfLogFont; 
  WCHAR   elfFullName[LF_FULLFACESIZE]; 
  WCHAR   elfStyle[LF_FACESIZE]; 
}
struct ENUMLOGFONTEXA {
    LOGFONTA  elfLogFont;
    BYTE  elfFullName[LF_FULLFACESIZE];
    BYTE  elfStyle[LF_FACESIZE];
    BYTE  elfScript[LF_FACESIZE];
}
struct ENUMLOGFONTEXW {
    LOGFONTW  elfLogFont;
    WCHAR  elfFullName[LF_FULLFACESIZE];
    WCHAR  elfStyle[LF_FACESIZE];
    WCHAR  elfScript[LF_FACESIZE];
}
version(ANSI){
    alias ENUMLOGFONTA ENUMLOGFONT;
    alias ENUMLOGFONTEXA ENUMLOGFONTEX;
}else {
    alias ENUMLOGFONTW ENUMLOGFONT;
    alias ENUMLOGFONTEXW ENUMLOGFONTEX;
}

// in phobos aready
//struct FILETIME {
//    DWORD dwLowDateTime; 
//    DWORD dwHighDateTime; 
//}

struct FONTSIGNATURE {
    DWORD  fsUsb[4];
    DWORD  fsCsb[2];
}

struct GCP_RESULTSA {
    DWORD   lStructSize;
    LPSTR     lpOutString;
    UINT  *lpOrder;
    int   *lpDx;
    int   *lpCaretPos;
    LPSTR   lpClass;
    LPWSTR  lpGlyphs;
    UINT    nGlyphs;
    int     nMaxFit;
} 

struct GCP_RESULTSW {
    DWORD   lStructSize;
    LPWSTR    lpOutString;
    UINT  *lpOrder;
    int   *lpDx;
    int   *lpCaretPos;
    LPSTR   lpClass;
    LPWSTR  lpGlyphs;
    UINT    nGlyphs;
    int     nMaxFit;
}
version(ANSI){
    alias GCP_RESULTSA GCP_RESULTS;
}else{
    alias GCP_RESULTSW GCP_RESULTS;
}
//alias GCP_RESULTS* LPGCP_RESULTS;


struct GOFFSET {
  LONG  du;
  LONG  dv;
}

struct GRADIENT_RECT {
  ULONG    UpperLeft;
  ULONG    LowerRight;
}

struct GUITHREADINFO {
    DWORD cbSize;
    DWORD flags;
    HWND hwndActive;
    HWND hwndFocus;
    HWND hwndCapture;
    HWND hwndMenuOwner;
    HWND hwndMoveSize;
    HWND hwndCaret;
    RECT rcCaret;
}alias GUITHREADINFO* PGUITHREADINFO, LPGUITHREADINFO;

struct HDITEMA {
    UINT    mask; 
    int     cxy; 
    LPSTR  pszText; 
    HBITMAP hbm; 
    int     cchTextMax; 
    int     fmt; 
    LPARAM  lParam; 
    int     iImage;
    int     iOrder;
}
struct HDITEMW {
    UINT    mask; 
    int     cxy; 
    LPWSTR  pszText; 
    HBITMAP hbm; 
    int     cchTextMax; 
    int     fmt; 
    LPARAM  lParam; 
    int     iImage;
    int     iOrder;
}
version(ANSI){
    alias HDITEMA HDITEM;
}else{
    alias HDITEMW HDITEM;
}
alias HDITEM* LPHDITEM;

struct HELPINFO {
    UINT     cbSize; 
    int      iContextType;
    int      iCtrlId; 
    HANDLE   hItemHandle; 
    DWORD    dwContextId; 
    POINT    MousePos;
}

struct HIGHCONTRASTA {
    UINT             cbSize; 
    DWORD            dwFlags; 
    LPSTR           lpszDefaultScheme; 
}
struct HIGHCONTRASTW {
    UINT             cbSize; 
    DWORD            dwFlags; 
    LPWSTR           lpszDefaultScheme; 
}
version(ANSI){
    alias HIGHCONTRASTA HIGHCONTRAST;
}else{
    alias HIGHCONTRASTW HIGHCONTRAST;
}


//struct ICONINFO {
//   BOOL    fIcon; 
//   DWORD   xHotspot; 
//   DWORD   yHotspot; 
//   HBITMAP hbmMask; 
//   HBITMAP hbmColor;
//}
//alias ICONINFO*  PICONINFO, LPICONINFO;

struct INITCOMMONCONTROLSEX {
    DWORD dwSize;
    DWORD dwICC;
}alias INITCOMMONCONTROLSEX* PINITCOMMONCONTROLSEX, LPINITCOMMONCONTROLSEX;

struct INPUT {
    // Note: <Shawn> sizeof = 28
    int type;
//  union {
        MOUSEINPUT mi; 
//        KEYBOARDINPUT ki;
//        HARDWAREINPUT hi;
//    }
}alias INPUT* PINPUT, LPINPUT;

//struct ITEMIDLIST {
//    SHITEMID mkid;
//}
//alias ITEMIDLIST* PITEMIDLIST, LPITEMIDLIST, LPCITEMIDLIST;

struct KEYBDINPUT {
    WORD wVk;
    WORD wScan;
    DWORD dwFlags;
    DWORD time;
    ULONG_PTR dwExtraInfo;
}

union LARGE_INTEGER {
    struct {
        DWORD LowPart;
        LONG HighPart;
    };
    struct u {
        DWORD LowPart;
        LONG HighPart;
    };
    LONGLONG QuadPart;
}
alias LARGE_INTEGER * PLARGE_INTEGER;


struct LOGBRUSH {
  UINT     lbStyle; 
  COLORREF lbColor; 
  LONG     lbHatch; 
}

struct LOGFONTA {
  int lfHeight;    
  int lfWidth;    
  int lfEscapement; 
  int lfOrientation;    
  int lfWeight;    
  byte lfItalic;    
  byte lfUnderline; 
  byte lfStrikeOut;    
  byte lfCharSet;    
  byte lfOutPrecision; 
  byte lfClipPrecision;    
  byte lfQuality;    
  byte lfPitchAndFamily;
  char lfFaceName[LF_FACESIZE];   
}
alias LOGFONTA* LPLOGFONTA;

//struct LOGFONTW {
//   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; 
//   WCHAR lfFaceName[LF_FACESIZE];   
//}
//alias LOGFONTW* PLOGFONTW, LPLOGFONTW;
version(ANSI){
    alias LOGFONTA LOGFONT;
} else {
    alias LOGFONTW LOGFONT;
}


struct LOGPEN {
    UINT     lopnStyle; 
    POINT    lopnWidth; 
    COLORREF lopnColor;
}

struct LVCOLUMNA { 
    UINT mask; 
    int fmt; 
    int cx; 
    LPSTR pszText; 
    int cchTextMax; 
    int iSubItem; 
    int iImage;
    int iOrder;
}
struct LVCOLUMNW { 
    UINT mask; 
    int fmt; 
    int cx; 
    LPWSTR pszText; 
    int cchTextMax; 
    int iSubItem; 
    int iImage;
    int iOrder;
} 
version(ANSI){
    alias LVCOLUMNA LVCOLUMN;
}else{
    alias LVCOLUMNW LVCOLUMN;
}
alias LVCOLUMN* LPLVCOLUMN;

struct LVFINDINFOA {
    UINT flags;
    LPCSTR psz;
    LPARAM lParam;
    POINT pt;
    UINT vkDirection;
} 
alias LVFINDINFOA* LPFINDINFOA;
struct LVFINDINFOW {
    UINT flags;
    LPCWSTR psz;
    LPARAM lParam;
    POINT pt;
    UINT vkDirection;
} 
alias LVFINDINFOW* LPFINDINFOW;

version(ANSI){
    alias LVFINDINFOA LVFINDINFO;
}else{
    alias LVFINDINFOW LVFINDINFO;
}

struct LVHITTESTINFO {
    POINT pt; 
    UINT flags; 
    int iItem; 
    int iSubItem;
}


struct LVITEMA { 
    UINT   mask; 
    int    iItem; 
    int    iSubItem; 
    UINT   state; 
    UINT   stateMask; 
    LPSTR  pszText; 
    int    cchTextMax; 
    int    iImage; 
    LPARAM lParam;
    int iIndent;
} 
struct LVITEMW { 
    UINT   mask; 
    int    iItem; 
    int    iSubItem; 
    UINT   state; 
    UINT   stateMask; 
    LPWSTR  pszText; 
    int    cchTextMax; 
    int    iImage; 
    LPARAM lParam;
    int iIndent;
} 
version(ANSI){
    alias LVITEMA LVITEM;
}else{
    alias LVITEMW LVITEM;
}
alias LVITEM* LPLVITEM;

struct MARGINS {
    int cxLeftWidth;
    int cxRightWidth;
    int cyTopHeight;
    int cyBottomHeight;
}

struct MEASUREITEMSTRUCT {
    UINT   CtlType;
    UINT   CtlID;
    UINT   itemID;
    UINT   itemWidth;
    UINT   itemHeight;
    DWORD  itemData;
}

struct MENUBARINFO {
  DWORD cbSize;
  RECT  rcBar;
  HMENU hMenu;
  HWND  hwndMenu;
  BOOL  fBarFocused;
  BOOL  fFocused;
}alias MENUBARINFO* PMENUBARINFO, LPMENUBARINFO;

struct MENUINFO {
  DWORD   cbSize;
  DWORD   fMask;
  DWORD   dwStyle;
  UINT    cyMax;
  HBRUSH  hbrBack;
  DWORD   dwContextHelpID;
  ULONG_PTR  dwMenuData;
}
alias MENUINFO* PCMENUINFO, LPCMENUINFO, LPCCMENUINFO; 

/*
* Feature in Windows.  The hbmpItem field requires Windows 4.10
* or greater.  On Windows NT 4.0, passing in a larger struct size
* in the cbSize field does nothing.  On Windows 95, the MENUITEMINFO
* calls fail when the struct size is too large.  The fix is to ensure
* that the correct struct size is used for the Windows platform.
*/
struct MENUITEMINFOA
{
    UINT    cbSize;
    UINT    fMask;
    UINT    fType;          // used if MIIM_TYPE
    UINT    fState;         // used if MIIM_STATE
    UINT    wID;            // used if MIIM_ID
    HMENU   hSubMenu;       // used if MIIM_SUBMENU
    HBITMAP hbmpChecked;    // used if MIIM_CHECKMARKS
    HBITMAP hbmpUnchecked;  // used if MIIM_CHECKMARKS
    DWORD   dwItemData;     // used if MIIM_DATA
    LPSTR   dwTypeData;     // used if MIIM_TYPE
    UINT    cch;            // used if MIIM_TYPE
    HBITMAP hbmpItem;
}   
alias MENUITEMINFOA* PMENUITEMINFOA, LPMENUITEMINFOA;
struct MENUITEMINFOW
{
    UINT    cbSize;
    UINT    fMask;
    UINT    fType;          // used if MIIM_TYPE
    UINT    fState;         // used if MIIM_STATE
    UINT    wID;            // used if MIIM_ID
    HMENU   hSubMenu;       // used if MIIM_SUBMENU
    HBITMAP hbmpChecked;    // used if MIIM_CHECKMARKS
    HBITMAP hbmpUnchecked;  // used if MIIM_CHECKMARKS
    DWORD   dwItemData;     // used if MIIM_DATA
    LPWSTR  dwTypeData;     // used if MIIM_TYPE
    UINT    cch;            // used if MIIM_TYPE
    HBITMAP hbmpItem;
}   alias MENUITEMINFOW* PMENUITEMINFOW, LPMENUITEMINFOW;
//version(ANSI){
//    alias MENUITEMINFOA MENUITEMINFO;
//}else{
//    alias MENUITEMINFOW MENUITEMINFO;
//}
//alias MENUITEMINFO * LPMENUITEMINFO;


struct MINMAXINFO {
    POINT ptReserved;
    POINT ptMaxSize;
    POINT ptMaxPosition;
    POINT ptMinTrackSize;
    POINT ptMaxTrackSize;
}

//struct MONITORINFO {
//    DWORD  cbSize; 
//    RECT   rcMonitor; 
//    RECT   rcWork; 
//    DWORD  dwFlags;
//}
//alias MONITORINFO* PMONITORINFO, LPMONITORINFO; 

struct MOUSEINPUT {
    LONG    dx;
    LONG    dy;
    DWORD   mouseData;
    DWORD   dwFlags;
    DWORD   dwExtraInfo;
}

//struct MSG {
//  int hwnd;     
//  int message; 
//  int wParam; 
//  int lParam; 
//  int time; 
////    POINT pt;
//  int x, y;
//}

struct NEWTEXTMETRICA { // ntm 
    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; 
    DWORD  ntmFlags; 
    UINT   ntmSizeEM; 
    UINT   ntmCellHeight; 
    UINT   ntmAvgWidth; 
} 
struct NEWTEXTMETRICW { // ntm 
    LONG   tmHeight; 
    LONG   tmAscent; 
    LONG   tmDescent; 
    LONG   tmInternalLeading; 
    LONG   tmExternalLeading; 
    LONG   tmAveCharWidth; 
    LONG   tmMaxCharWidth; 
    LONG   tmWeight; 
    LONG   tmOverhang; 
    LONG   tmDigitizedAspectX; 
    LONG   tmDigitizedAspectY; 
    WCHAR  tmFirstChar; 
    WCHAR  tmLastChar; 
    WCHAR  tmDefaultChar; 
    WCHAR  tmBreakChar; 
    BYTE   tmItalic; 
    BYTE   tmUnderlined; 
    BYTE   tmStruckOut; 
    BYTE   tmPitchAndFamily; 
    BYTE   tmCharSet; 
    DWORD  ntmFlags; 
    UINT   ntmSizeEM; 
    UINT   ntmCellHeight; 
    UINT   ntmAvgWidth; 
} 
struct NEWTEXTMETRICEXA {
    NEWTEXTMETRICA  ntmentm;
    FONTSIGNATURE  ntmeFontSignature;
}
struct NEWTEXTMETRICEXW {
    NEWTEXTMETRICW  ntmentm;
    FONTSIGNATURE  ntmeFontSignature;
}
version(ANSI){
    alias NEWTEXTMETRICA NEWTEXTMETRIC;
    alias NEWTEXTMETRICEXA NEWTEXTMETRICEX;
}else{
    alias NEWTEXTMETRICW NEWTEXTMETRIC;
    alias NEWTEXTMETRICEXW NEWTEXTMETRICEX;
}

struct NMCUSTOMDRAW {
    NMHDR  hdr;
    DWORD  dwDrawStage;
    HDC    hdc;
    RECT   rc;
    DWORD  dwItemSpec;
    UINT   uItemState;
    LPARAM lItemlParam;
}

struct NMHDR {
    HWND  hwndFrom;
    UINT  idFrom;
    UINT  code;        
}

struct NMHEADER {
    NMHDR    hdr;
    int      iItem;
    int      iButton;
    HDITEM  *pitem;
}

struct NMLISTVIEW {
    NMHDR   hdr;
    int     iItem;
    int     iSubItem;
    UINT    uNewState;
    UINT    uOldState;
    UINT    uChanged;
    POINT   ptAction;
    LPARAM  lParam;
}

struct NMLVCUSTOMDRAW {
    NMCUSTOMDRAW nmcd;
    COLORREF clrText;
    COLORREF clrTextBk;
//#if (_WIN32_IE >= 0x0400)
    int iSubItem;
//#endif
}

struct NMLVDISPINFOA {
    NMHDR hdr;
    LVITEMA item;
}
struct NMLVDISPINFOW {
    NMHDR hdr;
    LVITEMW item;
}
version(ANSI){
    alias NMLVDISPINFOA NMLVDISPINFO;
}else{
    alias NMLVDISPINFOW NMLVDISPINFO;
}

struct NMLVFINDITEMA {
    NMHDR hdr;
    int iStart;
    LVFINDINFOA lvfi;
}

struct NMLVFINDITEMW {
    NMHDR hdr;
    int iStart;
    LVFINDINFOW lvfi;
}
version(ANSI){
    alias NMLVFINDITEMA NMLVFINDITEM;
}else{
    alias NMLVFINDITEMW NMLVFINDITEM;
}

struct NMREBARCHEVRON {
    NMHDR hdr;
    UINT uBand;
    UINT wID;
    LPARAM lParam;
    RECT rc;
    LPARAM lParamNM;
}

struct NMRGINFO {
    // NMHDR
    HWND hwndFrom; 
    int idFrom; 
    int code;
    // -end- NMHDR  
//  POINT ptAction;
    int x;
    int y;
    int dwItemSpec;
}
struct NMTOOLBARA {
    align(2):
    NMHDR    hdr;
    int      iItem;
    TBBUTTON tbButton;
    int      cchText;
    LPSTR   pszText;
} 
struct NMTOOLBARW {
    align(2):
    NMHDR    hdr;
    int      iItem;
    TBBUTTON tbButton;
    int      cchText;
    LPWSTR   pszText;
}
version(ANSI){
    alias NMTOOLBARA NMTOOLBAR;
}else{
    alias NMTOOLBARW NMTOOLBAR;
}
alias NMTOOLBAR* LPNMTOOLBAR;


struct NMTTDISPINFOA {
    NMHDR hdr;
    LPSTR lpszText;
    char szText[80];
    HINSTANCE hinst;
    UINT uFlags;
    LPARAM lParam;
}

struct NMTTDISPINFOW {
    NMHDR hdr;
    LPWSTR lpszText;
    WCHAR szText[80];
    HINSTANCE hinst;
    UINT uFlags;
    LPARAM lParam;
}
version(ANSI){
    alias NMTTDISPINFOA NMTTDISPINFO;
} else {
    alias NMTTDISPINFOW NMTTDISPINFO;
}

struct NMTVCUSTOMDRAW {
    NMCUSTOMDRAW nmcd;
    COLORREF clrText;
    COLORREF clrTextBk;
//#if (_WIN32_IE &gt;= 0x0400)
    int iLevel; // the iLevel field does not appear on WinCE
//#endif
}

version(ANSI){
    alias NONCLIENTMETRICSA NONCLIENTMETRICS;
} else {
    alias NONCLIENTMETRICSW NONCLIENTMETRICS;
}
struct NONCLIENTMETRICSA {
    int cbSize; 
    int iBorderWidth; 
    int iScrollWidth; 
    int iScrollHeight; 
    int iCaptionWidth; 
    int iCaptionHeight; 
    LOGFONTA lfCaptionFont;
    int iSmCaptionWidth; 
    int iSmCaptionHeight;
    LOGFONTA lfSmCaptionFont;
    int iMenuWidth; 
    int iMenuHeight;
    LOGFONTA lfMenuFont; 
    LOGFONTA lfStatusFont; 
    LOGFONTA lfMessageFont; 
}
struct NONCLIENTMETRICSW {
    int cbSize; 
    int iBorderWidth; 
    int iScrollWidth; 
    int iScrollHeight; 
    int iCaptionWidth; 
    int iCaptionHeight; 
    LOGFONTW lfCaptionFont;
    int iSmCaptionWidth; 
    int iSmCaptionHeight;
    LOGFONTW lfSmCaptionFont;
    int iMenuWidth; 
    int iMenuHeight;
    LOGFONTW lfMenuFont; 
    LOGFONTW lfStatusFont; 
    LOGFONTW lfMessageFont; 
}

struct NOTIFYICONDATAA {
    DWORD cbSize;
    HWND hWnd;
    UINT uID;
    UINT uFlags;
    UINT uCallbackMessage;
    HICON hIcon;
    char szTip[64];
    DWORD dwState;
    DWORD dwStateMask;
    char szInfo[256];
//  union {
//      UINT uTimeout;
        UINT uVersion;
//  };
    char szInfoTitle[64];
    DWORD dwInfoFlags;
//  GUID guidItem;
} alias NOTIFYICONDATAA* PNOTIFYICONDATAA, LPNOTIFYICONDATAA;

struct NOTIFYICONDATAW {
    DWORD cbSize;
    HWND hWnd;
    UINT uID;
    UINT uFlags;
    UINT uCallbackMessage;
    HICON hIcon;
    WCHAR szTip[64];
    DWORD dwState;
    DWORD dwStateMask;
    WCHAR szInfo[256];
//  union {
//      UINT uTimeout;
        UINT uVersion;
//  };
    WCHAR szInfoTitle[64];
    DWORD dwInfoFlags;
//  GUID guidItem;
}
alias NOTIFYICONDATAW* PNOTIFYICONDATAW, LPNOTIFYICONDATAW;
version(ANSI){
    alias NOTIFYICONDATAA NOTIFYICONDATA;
}else{
    alias NOTIFYICONDATAW NOTIFYICONDATA;
}

/* already in phobos now

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;
}

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

//PORTING_TODO: is needed?
//version(ANSI){
//    alias OPENFILENAMEA OPENFILENAME;
//}else{
//    alias OPENFILENAMEW OPENFILENAME;
//}


struct OSVERSIONINFOA {
    DWORD dwOSVersionInfoSize; 
    DWORD dwMajorVersion; 
    DWORD dwMinorVersion; 
    DWORD dwBuildNumber; 
    DWORD dwPlatformId; 
    CHAR szCSDVersion[ 128 ];
}alias OSVERSIONINFOA* POSVERSIONINFOA, LPOSVERSIONINFOA;

struct OSVERSIONINFOW {
    DWORD dwOSVersionInfoSize; 
    DWORD dwMajorVersion; 
    DWORD dwMinorVersion; 
    DWORD dwBuildNumber; 
    DWORD dwPlatformId; 
    WCHAR szCSDVersion[ 128 ];
}alias OSVERSIONINFOW* POSVERSIONINFOW, LPOSVERSIONINFOW;
version(ANSI){
    alias OSVERSIONINFOA OSVERSIONINFO;
}else{
    alias OSVERSIONINFOW OSVERSIONINFO;
}
//struct PAINTSTRUCT {
//  int hdc; 
//  int fErase;
////    RECT rcPaint;
//  public int left, top, right, bottom;
//  int fRestore; 
//  int fIncUpdate; 
//  byte rgbReserved[32]; 
//}
//alias windows.PAINTSTRUCT PAINTSTRUCT;

//struct POINT {
//  LONG x, y;
//}


struct PRINTDLGA {  // pd 
    align(2):
    DWORD     lStructSize; 
    HWND      hwndOwner; 
    HANDLE    hDevMode; 
    HANDLE    hDevNames; 
    HDC       hDC; 
    DWORD     Flags; 
    WORD      nFromPage; 
    WORD      nToPage; 
    WORD      nMinPage; 
    WORD      nMaxPage; 
    WORD      nCopies; 
    HINSTANCE hInstance; 
    DWORD     lCustData; 
    LPPRINTHOOKPROC_I lpfnPrintHook; 
    LPSETUPHOOKPROC_I lpfnSetupHook; 
    LPCSTR    lpPrintTemplateName; 
    LPCSTR    lpSetupTemplateName; 
    HANDLE    hPrintTemplate; 
    HANDLE    hSetupTemplate; 
}
alias PRINTDLGA* PPRINTDLGA, LPPRINTDLGA;
struct PRINTDLGW {  // pd 
    align(2):
    DWORD     lStructSize; 
    HWND      hwndOwner; 
    HANDLE    hDevMode; 
    HANDLE    hDevNames; 
    HDC       hDC; 
    DWORD     Flags; 
    WORD      nFromPage; 
    WORD      nToPage; 
    WORD      nMinPage; 
    WORD      nMaxPage; 
    WORD      nCopies; 
    HINSTANCE hInstance; 
    DWORD     lCustData; 
    LPPRINTHOOKPROC_I lpfnPrintHook; 
    LPSETUPHOOKPROC_I lpfnSetupHook; 
    LPCWSTR    lpPrintTemplateName; 
    LPCWSTR    lpSetupTemplateName; 
    HANDLE    hPrintTemplate; 
    HANDLE    hSetupTemplate; 
}
alias PRINTDLGW* PPRINTDLGW, LPPRINTDLGW;
version(ANSI){
    alias PRINTDLGA PRINTDLG;
}else{
    alias PRINTDLGW PRINTDLG;
}

struct REBARBANDINFOA {
    UINT        cbSize;
    UINT        fMask;
    UINT        fStyle;
    COLORREF    clrFore;
    COLORREF    clrBack;
    LPSTR      lpText;
    UINT        cch;
    int         iImage;
    HWND        hwndChild;
    UINT        cxMinChild;
    UINT        cyMinChild;
    UINT        cx;
    HBITMAP     hbmBack;
    UINT        wID;
    UINT        cyChild;  
    UINT        cyMaxChild;
    UINT        cyIntegral;
    UINT        cxIdeal;
    LPARAM      lParam;
    UINT        cxHeader;
    /* Note in WinCE.  The field cxHeader is not defined. */ 
}
struct REBARBANDINFOW {
    UINT        cbSize;
    UINT        fMask;
    UINT        fStyle;
    COLORREF    clrFore;
    COLORREF    clrBack;
    LPWSTR      lpText;
    UINT        cch;
    int         iImage;
    HWND        hwndChild;
    UINT        cxMinChild;
    UINT        cyMinChild;
    UINT        cx;
    HBITMAP     hbmBack;
    UINT        wID;
    UINT        cyChild;  
    UINT        cyMaxChild;
    UINT        cyIntegral;
    UINT        cxIdeal;
    LPARAM      lParam;
    UINT        cxHeader;
    /* Note in WinCE.  The field cxHeader is not defined. */ 
}
version(ANSI){
    alias REBARBANDINFOA REBARBANDINFO;
}else{
    alias REBARBANDINFOW REBARBANDINFO;
}

//struct RECT {
//  int left;
//  int top;
//  int right;
//  int bottom;
//}

//struct RGNDATA { 
//    RGNDATAHEADER rdh; 
//    char          Buffer[1]; 
//} alias RGNDATA* PRGNDATA, LPRGNDATA; 

struct RGNDATAHEADER { 
    DWORD dwSize; 
    DWORD iType; 
    DWORD nCount; 
    DWORD nRgnSize; 
    RECT  rcBound; 
} alias RGNDATAHEADER* PRGNDATAHEADER, LPRGNDATAHEADER; 


template BITWISE(T)
{
    // bit value set
    void btvs(T* pData, uint bitnum, uint val){
        *pData &=  ~(0x01 << bitnum);
        if(val) *pData |= (0x01 << bitnum); 
    }
    // bit value get
    T btvg(T* pData, uint bitnum){
        return cast(T)((*pData >> bitnum) & 0x01);
    }
}
alias BITWISE!(BYTE).btvs btvs;
alias BITWISE!(WORD).btvs btvs;
alias BITWISE!(DWORD).btvs btvs;
alias BITWISE!(BYTE).btvg btvg;
alias BITWISE!(WORD).btvg btvg;
alias BITWISE!(DWORD).btvg btvg;


struct SCRIPT_ANALYSIS {
    WORD BITS;
    SCRIPT_STATE s;

    // getter
    uint eScript()      { return BITS & 0x03FFU; }
    uint fRTL()         { return btvg(&BITS, 10); }
    uint fLayoutRTL()   { return btvg(&BITS, 11); } 
    uint fLinkBefore()  { return btvg(&BITS, 12); }
    uint fLinkAfter()   { return btvg(&BITS, 13); }
    uint fLogicalOrder(){ return btvg(&BITS, 14); }
    uint fNoGlyphIndex(){ return btvg(&BITS, 15); }
    // setter
    void eScript(uint val)      { BITS &= 0xFC00; BITS |= (val & 0x03FF); }
    void fRTL(uint val)         { btvs(&BITS, 10, val); }
    void fLayoutRTL(uint val)   { btvs(&BITS, 11, val); }
    void fLinkBefore(uint val)  { btvs(&BITS, 12, val); }
    void fLinkAfter(uint val)   { btvs(&BITS, 13, val); }
    void fLogicalOrder(uint val){ btvs(&BITS, 14, val); }
    void fNoGlyphIndex(uint val){ btvs(&BITS, 15, val); }
}

alias void *SCRIPT_CACHE;

struct SCRIPT_CONTROL {
    align(1):
    WORD uDefaultLanguage;
    BYTE BITS;
    BYTE fReserved;
    
    // getter    
    uint fContextDigits()       { return btvg(&BITS, 0); }
    uint fInvertPreBoundDir()   { return btvg(&BITS, 1); }
    uint fInvertPostBoundDir()  { return btvg(&BITS, 2); }
    uint fLinkStringBefore()    { return btvg(&BITS, 3); }
    uint fLinkStringAfter()     { return btvg(&BITS, 4); }
    uint fNeutralOverride()     { return btvg(&BITS, 5); }
    uint fNumericOverride()     { return btvg(&BITS, 6); }
    uint fLegacyBidiClass()     { return btvg(&BITS, 7); }
    
    void fContextDigits(uint val)       { btvs(&BITS, 0, val); } 
    void fInvertPreBoundDir(uint val)   { btvs(&BITS, 1, val); }
    void fInvertPostBoundDir(uint val)  { btvs(&BITS, 2, val); }
    void fLinkStringBefore(uint val)    { btvs(&BITS, 3, val); }
    void fLinkStringAfter(uint val)     { btvs(&BITS, 4, val); }
    void fNeutralOverride(uint val)     { btvs(&BITS, 5, val); }
    void fNumericOverride(uint val)     { btvs(&BITS, 6, val); }
    void fLegacyBidiClass(uint val)     { btvs(&BITS, 7, val); }
}

struct SCRIPT_FONTPROPERTIES {
  int   cBytes; 
  WORD  wgBlank; 
  WORD  wgDefault; 
  WORD  wgInvalid; 
  WORD  wgKashida; 
  int   iKashidaWidth; 
}

struct SCRIPT_ITEM {
    int iCharPos;
    SCRIPT_ANALYSIS a;
}

struct SCRIPT_LOGATTR {
    align(1):
    BYTE BITS;
    
    // gettter
    uint fSoftBreak()   { return btvg(&BITS, 0); }
    uint fWhiteSpace()  { return btvg(&BITS, 1); }
    uint fCharStop()    { return btvg(&BITS, 2); }
    uint fWordStop()    { return btvg(&BITS, 3); }
    uint fInvalid()     { return btvg(&BITS, 4); }
    uint fReserved()    { return cast(BYTE)(BITS>>5); }
      
    void fSoftBreak(uint val)   { btvs(&BITS, 0, val); } 
    void fWhiteSpace(uint val)  { btvs(&BITS, 1, val); } 
    void fCharStop(uint val)    { btvs(&BITS, 2, val); } 
    void fWordStop(uint val)    { btvs(&BITS, 3, val); } 
    void fInvalid(uint val)     { btvs(&BITS, 4, val); } 
    void fReserved(uint val)    { BITS &= 0x1F; BITS |= (val & 0x07)<<5; } 
}


struct SCRIPT_PROPERTIES {  
    DWORD   BITS1;
    DWORD   BITS2;
    
    uint langid()   { return BITS1 >> 16; } 
    uint fNumeric() { return btvg(&BITS1, 16); }
    uint fComplex() { return btvg(&BITS1, 17); }
    uint fNeedsWordBreaking()   { return btvg(&BITS1, 18); }  
    uint fNeedsCaretInfo()      { return btvg(&BITS1, 19); }    
    uint bCharSet()             { return (BITS1 >> 20) & 0xFF; }
    uint fControl()             { return btvg(&BITS1, 28); }
    uint fPrivateUseArea()      { return btvg(&BITS1, 29); }   
    uint fNeedsCharacterJustify(){ return btvg(&BITS1, 30); }
    uint fInvalidGlyph()        { return btvg(&BITS1, 31); }    
    uint fInvalidLogAttr()      { return btvg(&BITS2, 0); }
    uint fCDM()                 { return btvg(&BITS2, 1); }
    uint fAmbiguousCharSet()    { return btvg(&BITS2, 2); }
    uint fClusterSizeVaries()   { return btvg(&BITS2, 3); }
    uint fRejectInvalid()       { return btvg(&BITS2, 4); }
    
    void langid(uint val)       { BITS1 &= 0xFFFF0000; BITS1 |= (val & 0xFFFF); } 
    void fNumeric(uint val)             { btvs(&BITS1, 16, val); }
    void fComplex(uint val)             { btvs(&BITS1, 17, val); }
    void fNeedsWordBreaking(uint val)   { btvs(&BITS1, 18, val); }
    void fNeedsCaretInfo(uint val)      { btvs(&BITS1, 19, val); }
    void bCharSet(uint val)             { BITS1 &= 0xF00FFFFF; BITS1 |= (val & 0xFF)<<20; }
    void fControl(uint val)             { btvs(&BITS1, 28, val); }
    void fPrivateUseArea(uint val)      { btvs(&BITS1, 29, val); }
    void fNeedsCharacterJustify(uint val){ btvs(&BITS1, 30, val); } 
    void fInvalidGlyph(uint val)        { btvs(&BITS1, 31, val); } 
    void fInvalidLogAttr(uint val)      { btvs(&BITS2, 0, val); } 
    void fCDM(uint val)                 { btvs(&BITS2, 1, val); } 
    void fAmbiguousCharSet(uint val)    { btvs(&BITS2, 2, val); } 
    void fClusterSizeVaries(uint val)   { btvs(&BITS2, 3, val); } 
    void fRejectInvalid(uint val)       { btvs(&BITS2, 4, val); } 
}


struct SCRIPT_STATE {
    WORD BITS;
    // getter
    uint uBidiLevel()           { return (BITS & 0x1F);}
    uint fOverrideDirection()   { return btvg(&BITS, 5); }
    uint fInhibitSymSwap()      { return btvg(&BITS, 6); }
    uint fCharShape()           { return btvg(&BITS, 7); }
    uint fDigitSubstitute()     { return btvg(&BITS, 8); }
    uint fInhibitLigate()       { return btvg(&BITS, 9); }
    uint fDisplayZWG()          { return btvg(&BITS, 10); }
    uint fArabicNumContext()    { return btvg(&BITS, 11); }
    uint fGcpClusters()         { return btvg(&BITS, 12); }
    uint fReserved()            { return btvg(&BITS, 13); }
    uint fEngineReserved()      { return (BITS >> 14) & 0x03;}
    // setter
    void uBidiLevel(uint val)           { BITS &= 0xFFE0; BITS |= (val & 0x1F); }
    void fOverrideDirection(uint val)   { btvs(&BITS, 5, val); } 
    void fInhibitSymSwap(uint val)      { btvs(&BITS, 6, val); } 
    void fCharShape(uint val)           { btvs(&BITS, 7, val); } 
    void fDigitSubstitute(uint val)     { btvs(&BITS, 8, val); } 
    void fInhibitLigate(uint val)       { btvs(&BITS, 9, val); } 
    void fDisplayZWG(uint val)          { btvs(&BITS, 10, val); }
    void fArabicNumContext(uint val)    { btvs(&BITS, 11, val); }
    void fGcpClusters(uint val)         { btvs(&BITS, 12, val); }
    void fReserved(uint val)            { btvs(&BITS, 13, val); }
    void fEngineReserved(uint val)      { BITS &= 0x3FFF; BITS |= ((val & 0x03) << 14); }
}


struct SCRIPT_VISATTR { 
    align(1):
    BYTE BITS;
    BYTE fShapeReserved;
    
    // getter
    uint uJustification()   { return BITS & 0x0F; } 
    uint fClusterStart()    { return btvg(&BITS, 4); }
    uint fDiacritic()       { return btvg(&BITS, 5); }
    uint fZeroWidth()       { return btvg(&BITS, 6); }
    uint fReserved()        { return btvg(&BITS, 7); }
    
    // setter
    void uJustification(uint val)   { BITS &= 0xF0; BITS |= (val & 0x0F); } 
    void fClusterStart(uint val)    { btvs(&BITS, 4, val); }
    void fDiacritic(uint val)       { btvs(&BITS, 5, val); }
    void fZeroWidth(uint val)       { btvs(&BITS, 6, val); }
    void fReserved(uint val)        { btvs(&BITS, 7, val); }
}

//struct SCROLLINFO {
//    UINT cbSize; 
//    UINT fMask; 
//    int  nMin; 
//    int  nMax; 
//    UINT nPage; 
//    int  nPos; 
//    int  nTrackPos; 
//}
//alias SCROLLINFO* PSCROLLINFO, LPSCROLLINFO, LPCSCROLLINFO;

version(WinCE)
{
struct SHACTIVATEINFO {
    int cbSize;
    HWND hwndLastFocus;
    int fSipUp; 
    int fSipOnDeactivation; 
    int fActive; 
    int fReserved; 
}
}

struct SHELLEXECUTEINFOA {
    DWORD cbSize; 
    ULONG fMask; 
    HWND hwnd; 
    LPCSTR lpVerb; 
    LPCSTR lpFile; 
    LPCSTR lpParameters; 
    LPCSTR lpDirectory; 
    int nShow; 
    HINSTANCE hInstApp; 
 
    // Optional members 
    LPVOID lpIDList; 
    LPCSTR lpClass; 
    HKEY hkeyClass; 
    DWORD dwHotKey; 
    HANDLE hIcon; 
    HANDLE hProcess; 
} alias SHELLEXECUTEINFOA* PSHELLEXECUTEINFOA, LPSHELLEXECUTEINFOA;
struct SHELLEXECUTEINFOW {
    DWORD cbSize; 
    ULONG fMask; 
    HWND hwnd; 
    LPCWSTR lpVerb; 
    LPCWSTR lpFile; 
    LPCWSTR lpParameters; 
    LPCWSTR lpDirectory; 
    int nShow; 
    HINSTANCE hInstApp; 
 
    // Optional members 
    LPVOID lpIDList; 
    LPCWSTR lpClass; 
    HKEY hkeyClass; 
    DWORD dwHotKey; 
    HANDLE hIcon; 
    HANDLE hProcess; 
} alias SHELLEXECUTEINFOW* PSHELLEXECUTEINFOW, LPSHELLEXECUTEINFOW;
version(ANSI){
    alias SHELLEXECUTEINFOA SHELLEXECUTEINFO;
}else{
    alias SHELLEXECUTEINFOW SHELLEXECUTEINFO;
}
alias SHELLEXECUTEINFO* LPSHELLEXECUTEINFO;

struct SHITEMID { 
    USHORT cb; 
    BYTE   abID[1]; 
} 
alias SHITEMID* LPCSHITEMID; 

version(WinCE)
{
    struct SHMENUBARINFO {
        int cbSize;
        HWND hwndParent;
        int dwFlags;
        int nToolBarId;
        HINSTANCE hInstRes;
        int nBmpId;
        int cBmpImages;
        HWND hwndMB;
    }
    
    struct SHRGINFO {
        DWORD cbSize;
        HWND hwndClient;
        POINT ptDown;
        DWORD dwFlags;
    }
    
    struct SIPINFO {
        DWORD cbSize;
        DWORD fdwFlags;
        RECT rcVisibleDesktop;
        RECT rcSipRect; 
        DWORD dwImDataSize;
        VOID *pvImData;
    }
} // end of version WinCE

//struct SIZE {
//  LONG cx; 
//  LONG cy; 
//}
//alias SIZE* LPSIZE, LPSIZEL;
//alias SIZE SIZEL;


struct TBBUTTON {
    align(2):
    int     iBitmap; 
    int     idCommand; 
    BYTE    fsState; 
    BYTE    fsStyle; 
//#ifdef _WIN64
//    BYTE     bReserved[6]     // padding for alignment
//#elif defined(_WIN32)
//    BYTE     bReserved[2]     // padding for alignment
//#endif
    DWORD_PTR   dwData; 
    INT_PTR     iString;  
} 
alias TBBUTTON* PTBBUTTON, LPTBBUTTON; 

struct TBBUTTONINFOA{
    align(2):
    UINT cbSize;
    DWORD dwMask;
    int idCommand;
    int iImage;
    BYTE fsState;
    BYTE fsStyle;
    WORD cx;
    DWORD_PTR lParam;
    LPSTR pszText;
    int cchText;
} 
struct TBBUTTONINFOW{
    align(2):
    UINT cbSize;
    DWORD dwMask;
    int idCommand;
    int iImage;
    BYTE fsState;
    BYTE fsStyle;
    WORD cx;
    DWORD_PTR lParam;
    LPWSTR pszText;
    int cchText;
} 
version(ANSI){
    alias TBBUTTONINFOA TBBUTTONINFO;
}else{
    alias TBBUTTONINFOW TBBUTTONINFO;
}
alias TBBUTTONINFO* LPTBBUTTONINFO;


struct TCITEMA {
    UINT mask;
    DWORD dwState;
    DWORD dwStateMask;
    LPSTR pszText;
    int cchTextMax;
    int iImage;
}
struct TCITEMW {
    UINT mask;
    DWORD dwState;
    DWORD dwStateMask;
    LPWSTR pszText;
    int cchTextMax;
    int iImage;
    LPARAM lParam;
}
version(ANSI){
    alias TCITEMA TCITEM;
}else{
    alias TCITEMW TCITEM; 
}

// declared in phobos alread
//struct TEXTMETRICA {
//}
struct TEXTMETRICW {
    align(1):
    LONG tmHeight;
    LONG tmAscent; 
    LONG tmDescent;
    LONG tmInternalLeading;  
    LONG tmExternalLeading;
    LONG tmAveCharWidth;
    LONG tmMaxCharWidth;
    LONG tmWeight; 
    LONG tmOverhang;
    LONG tmDigitizedAspectX;
    LONG tmDigitizedAspectY;
    
    wchar tmFirstChar;
    wchar tmLastChar;
    wchar tmDefaultChar; 
    wchar tmBreakChar;
    
    BYTE tmItalic;
    BYTE tmUnderlined; 
    BYTE tmStruckOut;
    BYTE tmPitchAndFamily;
    BYTE tmCharSet;
}
version(ANSI){ 
    alias TEXTMETRICA TEXTMETRIC;
} else { 
    alias TEXTMETRICW TEXTMETRIC;
}

struct TOOLINFOA {
    UINT cbSize;
    UINT uFlags;
    HWND hwnd;
    UINT uId;
    RECT rect;
    HINSTANCE hinst;
    LPSTR lpszText;
    LPARAM lParam;
}
struct TOOLINFOW {
    UINT cbSize;
    UINT uFlags;
    HWND hwnd;
    UINT uId;
    RECT rect;
    HINSTANCE hinst;
    LPWSTR lpszText;
    LPARAM lParam;
}
version(ANSI){
    alias TOOLINFOA TOOLINFO;
}else{
    alias TOOLINFOW TOOLINFO;
}

struct TRACKMOUSEEVENT {
    DWORD cbSize;
    DWORD dwFlags;
    HWND hwndTrack;
    DWORD dwHoverTime;
}
alias TRACKMOUSEEVENT* PTRACKMOUSEEVENT, LPTRACKMOUSEEVENT;

struct TRIVERTEX {
  LONG        x;
  LONG        y;
  COLOR16     Red;
  COLOR16     Green;
  COLOR16     Blue;
  COLOR16     Alpha;
}
alias TRIVERTEX* PTRIVERTEX, LPTRIVERTEX;


struct TVHITTESTINFO {
    POINT pt;
    UINT flags;
    HTREEITEM hItem;
}


struct TVINSERTSTRUCTA {
    HTREEITEM hParent;
    HTREEITEM hInsertAfter;
    TVITEMA item;
}
struct TVINSERTSTRUCTW {
    HTREEITEM hParent;
    HTREEITEM hInsertAfter;
    TVITEMW item;
}
version(ANSI){
    alias TVINSERTSTRUCTA TVINSERTSTRUCT;
}else{
    alias TVINSERTSTRUCTW TVINSERTSTRUCT;
}


struct TVITEMA {
    UINT      mask;
    HTREEITEM hItem;
    UINT      state;
    UINT      stateMask;
    LPSTR    pszText;
    int       cchTextMax;
    int       iImage;
    int       iSelectedImage;
    int       cChildren;
    LPARAM    lParam;
} 
struct TVITEMW {
    UINT      mask;
    HTREEITEM hItem;
    UINT      state;
    UINT      stateMask;
    LPWSTR    pszText;
    int       cchTextMax;
    int       iImage;
    int       iSelectedImage;
    int       cChildren;
    LPARAM    lParam;
} 
version(ANSI){
    alias TVITEMA TVITEM;
}else{
    alias TVITEMW TVITEM;
}
alias TVITEM* LPTVITEM;

union ULARGE_INTEGER {
    struct {
        DWORD LowPart;
        DWORD HighPart;
    };
    struct u {
        DWORD LowPart;
        DWORD HighPart;
    };
    DWORDLONG QuadPart;
} 
alias ULARGE_INTEGER * PULARGE_INTEGER;

//struct WINDOWPLACEMENT {
//    UINT length;
//    UINT flags;
//    UINT showCmd;
//    POINT ptMinPosition;
//    POINT ptMaxPosition;
//    RECT rcNormalPosition;
//}
//
struct WINDOWPOS {
    HWND hwnd;
    HWND hwndInsertAfter;
    int x;
    int y;
    int cx;
    int cy;
    UINT flags;
}

// WNDCLASSA is declared in phobos
struct WNDCLASSW {
    UINT        style;
    WNDPROC_I     lpfnWndProc;
    int         cbClsExtra;
    int         cbWndExtra;
    HINSTANCE   hInstance;
    HICON       hIcon;
    HCURSOR     hCursor;
    HBRUSH      hbrBackground;
    LPCWSTR     lpszMenuName;
    LPCWSTR     lpszClassName;
}alias WNDCLASSW* PWNDCLASSW, LPWNDCLASSW;

// since phobos has alias WNDCLASSA to WNDCLASS, we have to alias it another name
version(ANSI){ 
    alias WNDCLASSA WNDCLASS_T;
}else{
    alias WNDCLASSW WNDCLASS_T;
}

}   // end of extern(Windows)