/*
 * 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_T   WNDCLASS;

//alias TCLSID *REFCLSID;

//interface IUnknown{}
//alias IUnknown LPUNKNOWN;


struct SCRIPT_DIGITSUBSTITUTE {
  ushort NationalDigitLanguage;
  ushort TraditionalDigitLanguage;
  DWORD DigitSubstitute;
  DWORD dwReserved;
}

struct BUTTON_IMAGELIST {
    HIMAGELIST himl;
    RECT margin;
    UINT uAlign;
}

alias HANDLE HTHEME;

struct NMREBARCHILDSIZE {
    NMHDR hdr;
    UINT uBand;
    UINT wID;
    RECT rcChild;
    RECT rcBand;
}
const int MAX_LINKID_TEXT = 48;
const int L_MAX_URL_LENGTH = 2084;
struct LITEM {
    UINT mask;
    int iLink;
    UINT state;
    UINT stateMask;
    WCHAR szID[MAX_LINKID_TEXT];
    WCHAR szUrl[L_MAX_URL_LENGTH];
}
struct NMLINK {
    NMHDR hdr;
    LITEM item;
}
struct NMLVODSTATECHANGE {
  NMHDR hdr;
  int iFrom;
  int iTo;
  UINT uNewState;
  UINT uOldState;
}
struct NMTBHOTITEM {
    NMHDR hdr;
    int idOld;
    int idNew;
    DWORD dwFlags;
}
struct NMTVDISPINFO {
    NMHDR hdr;
    TVITEM item;
}
struct NMTVITEMCHANGE {
    NMHDR hdr;
    UINT uChanged;
    HTREEITEM hItem;
    UINT uStateNew;
    UINT uStateOld;
    LPARAM lParam;
}

struct ACTCTXA {
  ULONG cbSize;
  DWORD dwFlags;
  LPCSTR lpSource;
  USHORT wProcessorArchitecture;
  LANGID wLangId;
  LPCTSTR lpAssemblyDirectory;
  LPCTSTR lpResourceName;
  LPCTSTR lpApplicationName;
  HMODULE hModule;
}
struct ACTCTXW {
  ULONG cbSize;
  DWORD dwFlags;
  LPCWSTR lpSource;
  USHORT wProcessorArchitecture;
  LANGID wLangId;
  LPCTSTR lpAssemblyDirectory;
  LPCTSTR lpResourceName;
  LPCTSTR lpApplicationName;
  HMODULE hModule;
}
version(ANSI) alias ACTCTXA ACTCTX;
else          alias ACTCTXW ACTCTX;
alias HANDLE HACTCTX;

struct OSVERSIONINFOEX {
  DWORD dwOSVersionInfoSize;
  DWORD dwMajorVersion;
  DWORD dwMinorVersion;
  DWORD dwBuildNumber;
  DWORD dwPlatformId;
  TCHAR szCSDVersion[128];
  WORD wServicePackMajor;
  WORD wServicePackMinor;
  WORD wSuiteMask;
  BYTE wProductType;
  BYTE wReserved;
}



// ....
//--------------------------------------------------------------------------------

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, uint, uint, 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;
        KEYBDINPUT 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;

alias extern(Windows) int (*PFNTVCOMPARE)(LPARAM, LPARAM, LPARAM);
struct TVSORTCB {
    HTREEITEM hParent;
    PFNTVCOMPARE lpfnCompare;
    LPARAM lParam;
}




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