2044 lines
32 KiB
C
2044 lines
32 KiB
C
|
|
#include <Protocol/H2OWindow.h>
|
|
|
|
H2O_WINDOW_PROTOCOL *gH2OWindow;
|
|
|
|
LRESULT
|
|
DefWindowProc (
|
|
HWND hwnd,
|
|
UINT msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return gH2OWindow->DefWindowProc (
|
|
hwnd,
|
|
msg,
|
|
wParam,
|
|
lParam
|
|
);
|
|
}
|
|
|
|
void
|
|
MwSetKeyboardTranslator (
|
|
LPFN_KEYBTRANSLATE pFn
|
|
)
|
|
{
|
|
gH2OWindow->MwSetKeyboardTranslator (pFn);
|
|
}
|
|
|
|
HDC
|
|
GetDCEx (
|
|
HWND hwnd,
|
|
HRGN hrgnClip,
|
|
DWORD flags
|
|
)
|
|
{
|
|
return gH2OWindow->GetDCEx (
|
|
hwnd,
|
|
hrgnClip,
|
|
flags
|
|
);
|
|
}
|
|
|
|
HDC
|
|
GetDC (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->GetDC (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
HDC
|
|
GetWindowDC (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindowDC (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
int
|
|
ReleaseDC (
|
|
HWND hwnd,
|
|
HDC hdc
|
|
)
|
|
{
|
|
return gH2OWindow->ReleaseDC (
|
|
hwnd,
|
|
hdc
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
DeleteDC (
|
|
HDC hdc
|
|
)
|
|
{
|
|
return gH2OWindow->DeleteDC (
|
|
hdc
|
|
);
|
|
}
|
|
|
|
HDC
|
|
BeginPaint (
|
|
HWND hwnd,
|
|
LPPAINTSTRUCT lpPaint
|
|
)
|
|
{
|
|
return gH2OWindow->BeginPaint (
|
|
hwnd,
|
|
lpPaint
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
EndPaint (
|
|
HWND hwnd,
|
|
CONST PAINTSTRUCT *lpPaint
|
|
)
|
|
{
|
|
return gH2OWindow->EndPaint (
|
|
hwnd,
|
|
lpPaint
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
SetTextColor (
|
|
HDC hdc,
|
|
COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->SetTextColor (
|
|
hdc,
|
|
crColor
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
GetTextColor (
|
|
HDC hdc
|
|
)
|
|
{
|
|
return gH2OWindow->GetTextColor (
|
|
hdc
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
SetBkColor (
|
|
HDC hdc,
|
|
COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->SetBkColor (
|
|
hdc,
|
|
crColor
|
|
);
|
|
}
|
|
|
|
int
|
|
SetBkMode (
|
|
HDC hdc,
|
|
int iBkMode
|
|
)
|
|
{
|
|
return gH2OWindow->SetBkMode (
|
|
hdc,
|
|
iBkMode
|
|
);
|
|
}
|
|
|
|
UINT
|
|
SetTextAlign (
|
|
HDC hdc,
|
|
UINT fMode
|
|
)
|
|
{
|
|
return gH2OWindow->SetTextAlign (
|
|
hdc,
|
|
fMode
|
|
);
|
|
}
|
|
|
|
UINT
|
|
GetTextAlign (
|
|
HDC hdc
|
|
)
|
|
{
|
|
return gH2OWindow->GetTextAlign (
|
|
hdc
|
|
);
|
|
}
|
|
|
|
int
|
|
SetROP2 (
|
|
HDC hdc,
|
|
int fnDrawMode
|
|
)
|
|
{
|
|
return gH2OWindow->SetROP2 (
|
|
hdc,
|
|
fnDrawMode
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
GetPixel (
|
|
HDC hdc,
|
|
int x,
|
|
int y
|
|
)
|
|
{
|
|
return gH2OWindow->GetPixel (
|
|
hdc,
|
|
x,
|
|
y
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
SetPixel (
|
|
HDC hdc,
|
|
int x,
|
|
int y,
|
|
COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->SetPixel (
|
|
hdc,
|
|
x,
|
|
y,
|
|
crColor
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
MoveToEx (
|
|
HDC hdc,
|
|
int x,
|
|
int y,
|
|
LPPOINT lpPoint
|
|
)
|
|
{
|
|
return gH2OWindow->MoveToEx (
|
|
hdc,
|
|
x,
|
|
y,
|
|
lpPoint
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
LineTo (
|
|
HDC hdc,
|
|
int x,
|
|
int y
|
|
)
|
|
{
|
|
return gH2OWindow->LineTo (
|
|
hdc,
|
|
x,
|
|
y
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
Polyline (
|
|
HDC hdc,
|
|
CONST POINT *lppt,
|
|
int cPoints
|
|
)
|
|
{
|
|
return gH2OWindow->Polyline (
|
|
hdc,
|
|
lppt,
|
|
cPoints
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
Rectangle (
|
|
HDC hdc,
|
|
int nLeft,
|
|
int nTop,
|
|
int nRight,
|
|
int nBottom
|
|
)
|
|
{
|
|
return gH2OWindow->Rectangle (
|
|
hdc,
|
|
nLeft,
|
|
nTop,
|
|
nRight,
|
|
nBottom
|
|
);
|
|
}
|
|
//
|
|
//BOOL
|
|
//Ellipse (
|
|
//HDC hdc,
|
|
//int nLeftRect,
|
|
//int nTopRect,
|
|
//int nRightRect,
|
|
//int nBottomRect
|
|
//)
|
|
//{
|
|
//return gH2OWindow->Ellipse (
|
|
// hdc,
|
|
// nLeftRect,
|
|
// nTopRect,
|
|
// nRightRect,
|
|
// nBottomRect
|
|
// );
|
|
//}
|
|
|
|
BOOL
|
|
Polygon (
|
|
HDC hdc,
|
|
CONST POINT *lpPoints,
|
|
int nCount
|
|
)
|
|
{
|
|
return gH2OWindow->Polygon (
|
|
hdc,
|
|
lpPoints,
|
|
nCount
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
PolyPolygon (
|
|
HDC hdc,
|
|
CONST POINT *lpPoints,
|
|
LPINT lpPolyCounts,
|
|
int nCount
|
|
)
|
|
{
|
|
return gH2OWindow->PolyPolygon (
|
|
hdc,
|
|
lpPoints,
|
|
lpPolyCounts,
|
|
nCount
|
|
);
|
|
}
|
|
|
|
int
|
|
FillRect (
|
|
HDC hdc,
|
|
CONST RECT *lprc,
|
|
HBRUSH hbr
|
|
)
|
|
{
|
|
return gH2OWindow->FillRect (
|
|
hdc,
|
|
lprc,
|
|
hbr
|
|
);
|
|
}
|
|
|
|
void
|
|
MwSetTextCoding (
|
|
long mode
|
|
)
|
|
{
|
|
gH2OWindow->MwSetTextCoding (
|
|
mode
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
TextOut (
|
|
HDC Hdc,
|
|
int x,
|
|
int y,
|
|
LPCWSTR String,
|
|
int cbString
|
|
)
|
|
{
|
|
return gH2OWindow->TextOut (
|
|
Hdc,
|
|
x,
|
|
y,
|
|
String,
|
|
cbString
|
|
);
|
|
}
|
|
//
|
|
//BOOL
|
|
//TextOutW (
|
|
//HDC hdc,
|
|
//int x,
|
|
//int y,
|
|
//LPCWSTR lpszString,
|
|
//int cbString
|
|
//)
|
|
//{
|
|
//return gH2OWindow->TextOutW (
|
|
// hdc,
|
|
// x,
|
|
// y,
|
|
// lpszString,
|
|
// cbString
|
|
// );
|
|
//}
|
|
|
|
//BOOL
|
|
//ExtTextOutW (
|
|
//HDC hdc,
|
|
//int x,
|
|
//int y,
|
|
//UINT fuOptions,
|
|
//CONST RECT *lprc
|
|
//)
|
|
//{
|
|
//gH2OWindow->ExtTextOutW (
|
|
// hdc,
|
|
// x,
|
|
// y,
|
|
// fuOptions,
|
|
// lprc
|
|
// );
|
|
//}
|
|
|
|
//int
|
|
//DrawTextA (
|
|
//HDC hdc,
|
|
//LPCSTR lpString,
|
|
//int nCount,
|
|
//LPRECT lpRect,
|
|
//UINT uFormat
|
|
//)
|
|
//{
|
|
//return gH2OWindow->DrawTextA (
|
|
// hdc,
|
|
// lpString,
|
|
// nCount,
|
|
// lpRect,
|
|
// uFormat
|
|
// );
|
|
//}
|
|
|
|
int
|
|
DrawText (
|
|
HDC hdc,
|
|
LPCWSTR lpString,
|
|
int nCount,
|
|
LPRECT lpRect,
|
|
UINT uFormat
|
|
)
|
|
{
|
|
return gH2OWindow->DrawText (
|
|
hdc,
|
|
lpString,
|
|
nCount,
|
|
lpRect,
|
|
uFormat
|
|
);
|
|
}
|
|
|
|
DWORD
|
|
GetSysColor (
|
|
int nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetSysColor (
|
|
nIndex
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
SetSysColor (
|
|
int nIndex,
|
|
COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->SetSysColor (
|
|
nIndex,
|
|
crColor
|
|
);
|
|
}
|
|
|
|
HBRUSH
|
|
GetSysColorBrush (
|
|
int nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetSysColorBrush (
|
|
nIndex
|
|
);
|
|
}
|
|
|
|
HGDIOBJ
|
|
GetStockObject (
|
|
int nObject
|
|
)
|
|
{
|
|
return gH2OWindow->GetStockObject (
|
|
nObject
|
|
);
|
|
}
|
|
|
|
HGDIOBJ
|
|
SelectObject (
|
|
HDC hdc,
|
|
HGDIOBJ hObject
|
|
)
|
|
{
|
|
return gH2OWindow->SelectObject (
|
|
hdc,
|
|
hObject
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
DeleteObject (
|
|
HGDIOBJ hObject
|
|
)
|
|
{
|
|
return gH2OWindow->DeleteObject (
|
|
hObject
|
|
);
|
|
}
|
|
|
|
int
|
|
SelectClipRgn (
|
|
HDC hdc,
|
|
HRGN hrgn
|
|
)
|
|
{
|
|
return gH2OWindow->SelectClipRgn (
|
|
hdc,
|
|
hrgn
|
|
);
|
|
}
|
|
|
|
int
|
|
ExtSelectClipRgn (
|
|
HDC hdc,
|
|
HRGN hrgn,
|
|
int fnMode
|
|
)
|
|
{
|
|
return gH2OWindow->ExtSelectClipRgn (
|
|
hdc,
|
|
hrgn,
|
|
fnMode
|
|
);
|
|
}
|
|
|
|
int
|
|
GetUpdateRgn (
|
|
HWND hwnd,
|
|
HRGN hrgn,
|
|
BOOL bErase
|
|
)
|
|
{
|
|
return gH2OWindow->GetUpdateRgn (
|
|
hwnd,
|
|
hrgn,
|
|
bErase
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
GetUpdateRect (
|
|
HWND hwnd,
|
|
LPRECT lpRect,
|
|
BOOL bErase
|
|
)
|
|
{
|
|
return gH2OWindow->GetUpdateRect (
|
|
hwnd,
|
|
lpRect,
|
|
bErase
|
|
);
|
|
}
|
|
|
|
HBRUSH
|
|
CreateSolidBrush (
|
|
COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->CreateSolidBrush (
|
|
crColor
|
|
);
|
|
}
|
|
|
|
HPEN
|
|
CreatePen (
|
|
int nPenStyle,
|
|
int nWidth,
|
|
COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->CreatePen (
|
|
nPenStyle,
|
|
nWidth,
|
|
crColor
|
|
);
|
|
}
|
|
|
|
HBITMAP
|
|
CreateCompatibleBitmap (
|
|
HDC hdc,
|
|
int nWidth,
|
|
int nHeight
|
|
)
|
|
{
|
|
return gH2OWindow->CreateCompatibleBitmap (
|
|
hdc,
|
|
nWidth,
|
|
nHeight
|
|
);
|
|
}
|
|
|
|
HDC
|
|
CreateCompatibleDC (
|
|
HDC hdc
|
|
)
|
|
{
|
|
return gH2OWindow->CreateCompatibleDC (
|
|
hdc
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
BitBlt (
|
|
HDC hdcDest,
|
|
int nXDest,
|
|
int nYDest,
|
|
int nWidth,
|
|
int nHeight,
|
|
HDC hdcSrc,
|
|
int nXSrc,
|
|
int nYSrc,
|
|
DWORD dwRop
|
|
)
|
|
{
|
|
return gH2OWindow->BitBlt (
|
|
hdcDest,
|
|
nXDest,
|
|
nYDest,
|
|
nWidth,
|
|
nHeight,
|
|
hdcSrc,
|
|
nXSrc,
|
|
nYSrc,
|
|
dwRop
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
StretchBlt (
|
|
HDC hdcDest,
|
|
int nXOriginDest,
|
|
int nYOriginDest,
|
|
int nWidthDest,
|
|
int nHeightDest,
|
|
HDC hdcSrc,
|
|
int nXOriginSrc,
|
|
int nYOriginSrc,
|
|
int nWidthSrc,
|
|
int nHeightSrc,
|
|
DWORD dwRop
|
|
)
|
|
{
|
|
return gH2OWindow->StretchBlt (
|
|
hdcDest,
|
|
nXOriginDest,
|
|
nYOriginDest,
|
|
nWidthDest,
|
|
nHeightDest,
|
|
hdcSrc,
|
|
nXOriginSrc,
|
|
nYOriginSrc,
|
|
nWidthSrc,
|
|
nHeightSrc,
|
|
dwRop
|
|
);
|
|
}
|
|
//
|
|
//UINT
|
|
//GetSystemPaletteEntries (
|
|
//HDC hdc,
|
|
//UINT iStartIndex,
|
|
//UINT nEntries
|
|
//)
|
|
//{
|
|
//gH2OWindow->GetSystemPaletteEntries (
|
|
// hdc,
|
|
// iStartIndex,
|
|
// nEntries
|
|
// );
|
|
//}
|
|
|
|
int
|
|
GetDeviceCaps (
|
|
HDC hdc,
|
|
int nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetDeviceCaps (
|
|
hdc,
|
|
nIndex
|
|
);
|
|
}
|
|
|
|
//BOOL
|
|
//DrawFocusRect (
|
|
//HDC hdc,
|
|
//LPRECT prect
|
|
//)
|
|
//{
|
|
//return gH2OWindow->DrawFocusRect (
|
|
// hdc,
|
|
// prect
|
|
// );
|
|
//}
|
|
//
|
|
//LONG
|
|
//TabbedTextOut (
|
|
//HDC hdc,
|
|
//int x,
|
|
//int y,
|
|
//LPCTSTR lpszString,
|
|
//int cbString
|
|
//)
|
|
//{
|
|
//gH2OWindow->TabbedTextOut (
|
|
// hdc,
|
|
// x,
|
|
// y,
|
|
// lpszString,
|
|
// cbString
|
|
// );
|
|
//}
|
|
|
|
//DWORD
|
|
//GetTabbedTextExtent (
|
|
//HDC hdc,
|
|
//int x,
|
|
//int y,
|
|
//LPCTSTR lpszString,
|
|
//int cbString
|
|
//)
|
|
//{
|
|
//gH2OWindow->GetTabbedTextExtent (
|
|
// hdc,
|
|
// x,
|
|
// y,
|
|
// lpszString,
|
|
// cbString
|
|
// );
|
|
//}
|
|
|
|
//int
|
|
//MulDiv (
|
|
//int nMultiplicand,
|
|
//int nMultiplier,
|
|
//int nDivisor
|
|
//)
|
|
//{
|
|
//gH2OWindow->MulDiv (
|
|
// nMultiplicand,
|
|
// nMultiplier,
|
|
// nDivisor
|
|
// );
|
|
//}
|
|
|
|
BOOL
|
|
GetTextExtentPoint32 (
|
|
HDC hdc, /* handle to DC*/
|
|
LPCWSTR lpszStr, /* character string*/
|
|
int cchString, /* number of characters*/
|
|
LPSIZE lpSize /* string dimensions*/
|
|
)
|
|
{
|
|
return gH2OWindow->GetTextExtentPoint32 (
|
|
hdc, /* handle to DC*/
|
|
lpszStr, /* character string*/
|
|
cchString, /* number of characters*/
|
|
lpSize /* string dimensions*/
|
|
);
|
|
}
|
|
|
|
UINT64
|
|
GetTickCount (
|
|
VOID
|
|
)
|
|
{
|
|
return gH2OWindow->GetTickCount ();
|
|
}
|
|
//
|
|
//VOID
|
|
//Sleep (
|
|
//DWORD dwMilliseconds
|
|
//)
|
|
//{
|
|
//gH2OWindow->Sleep (
|
|
// dwMilliseconds
|
|
// );
|
|
//}
|
|
|
|
INT
|
|
OffsetRgn (
|
|
HRGN hrgn,
|
|
INT x,
|
|
INT y
|
|
)
|
|
{
|
|
return gH2OWindow->OffsetRgn (
|
|
hrgn,
|
|
x,
|
|
y
|
|
);
|
|
}
|
|
|
|
INT
|
|
GetRgnBox (
|
|
HRGN hrgn,
|
|
LPRECT rect
|
|
)
|
|
{
|
|
return gH2OWindow->GetRgnBox (
|
|
hrgn,
|
|
rect
|
|
);
|
|
}
|
|
|
|
HRGN
|
|
CreateRectRgn (
|
|
INT left,
|
|
INT top,
|
|
INT right,
|
|
INT bottom
|
|
)
|
|
{
|
|
return gH2OWindow->CreateRectRgn (
|
|
left,
|
|
top,
|
|
right,
|
|
bottom
|
|
);
|
|
}
|
|
|
|
HRGN
|
|
CreateRectRgnIndirect (
|
|
const RECT* rect
|
|
)
|
|
{
|
|
return gH2OWindow->CreateRectRgnIndirect (
|
|
rect
|
|
);
|
|
}
|
|
|
|
VOID
|
|
SetRectRgn (
|
|
HRGN hrgn,
|
|
INT left,
|
|
INT top,
|
|
INT right,
|
|
INT bottom
|
|
)
|
|
{
|
|
gH2OWindow->SetRectRgn (
|
|
hrgn,
|
|
left,
|
|
top,
|
|
right,
|
|
bottom
|
|
);
|
|
}
|
|
|
|
HRGN
|
|
CreateRoundRectRgn (
|
|
INT left,
|
|
INT top,
|
|
INT right,
|
|
INT bottom,
|
|
INT ellipse_width,
|
|
INT ellipse_height
|
|
)
|
|
{
|
|
return gH2OWindow->CreateRoundRectRgn (
|
|
left,
|
|
top,
|
|
right,
|
|
bottom,
|
|
ellipse_width,
|
|
ellipse_height
|
|
);
|
|
}
|
|
|
|
HRGN
|
|
CreateEllipticRgn (
|
|
INT left,
|
|
INT top,
|
|
INT right,
|
|
INT bottom
|
|
)
|
|
{
|
|
return gH2OWindow->CreateEllipticRgn (
|
|
left,
|
|
top,
|
|
right,
|
|
bottom
|
|
);
|
|
}
|
|
|
|
HRGN
|
|
CreateEllipticRgnIndirect (
|
|
const RECT *rect
|
|
)
|
|
{
|
|
return gH2OWindow->CreateEllipticRgnIndirect (
|
|
rect
|
|
);
|
|
}
|
|
|
|
HRGN
|
|
CreatePolygonRgn (
|
|
const POINT *points,
|
|
INT count,
|
|
INT mode
|
|
)
|
|
{
|
|
return gH2OWindow->CreatePolygonRgn (
|
|
points,
|
|
count,
|
|
mode
|
|
);
|
|
}
|
|
|
|
DWORD
|
|
GetRegionData (
|
|
HRGN hrgn,
|
|
DWORD count,
|
|
LPRGNDATA rgndata
|
|
)
|
|
{
|
|
return gH2OWindow->GetRegionData (
|
|
hrgn,
|
|
count,
|
|
rgndata
|
|
);
|
|
}
|
|
//
|
|
//HRGN
|
|
//ExtCreateRegion (
|
|
//const XFORM* lpXform,
|
|
//DWORD dwCount,
|
|
//const RGNDATA* rgndata
|
|
//)
|
|
//{
|
|
//gH2OWindow->ExtCreateRegion (
|
|
// lpXform,
|
|
// dwCount,
|
|
// rgndata
|
|
// );
|
|
//}
|
|
|
|
BOOL
|
|
PtInRegion (
|
|
HRGN hrgn,
|
|
INT x,
|
|
INT y
|
|
)
|
|
{
|
|
return gH2OWindow->PtInRegion (
|
|
hrgn,
|
|
x,
|
|
y
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
RectInRegion (
|
|
HRGN hrgn,
|
|
const RECT *rect
|
|
)
|
|
{
|
|
return gH2OWindow->RectInRegion (
|
|
hrgn,
|
|
rect
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
EqualRgn (
|
|
HRGN hrgn1,
|
|
HRGN hrgn2
|
|
)
|
|
{
|
|
return gH2OWindow->EqualRgn (
|
|
hrgn1,
|
|
hrgn2
|
|
);
|
|
}
|
|
|
|
INT
|
|
CombineRgn (
|
|
HRGN hDest,
|
|
HRGN hSrc1,
|
|
HRGN hSrc2,
|
|
INT mode
|
|
)
|
|
{
|
|
return gH2OWindow->CombineRgn (
|
|
hDest,
|
|
hSrc1,
|
|
hSrc2,
|
|
mode
|
|
);
|
|
}
|
|
|
|
LRESULT
|
|
CallWindowProc (
|
|
WNDPROC lpPrevWndFunc,
|
|
HWND hwnd,
|
|
UINT Msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return gH2OWindow->CallWindowProc (
|
|
lpPrevWndFunc,
|
|
hwnd,
|
|
Msg,
|
|
wParam,
|
|
lParam
|
|
);
|
|
}
|
|
|
|
LRESULT
|
|
SendMessage (
|
|
HWND hwnd,
|
|
UINT Msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return gH2OWindow->SendMessage (
|
|
hwnd,
|
|
Msg,
|
|
wParam,
|
|
lParam
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
PostMessage (
|
|
HWND hwnd,
|
|
UINT Msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return gH2OWindow->PostMessage (
|
|
hwnd,
|
|
Msg,
|
|
wParam,
|
|
lParam
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
PostThreadMessage (
|
|
DWORD dwThreadId,
|
|
UINT Msg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return gH2OWindow->PostThreadMessage (
|
|
dwThreadId,
|
|
Msg,
|
|
wParam,
|
|
lParam
|
|
);
|
|
}
|
|
|
|
VOID
|
|
PostQuitMessage (
|
|
int nExitCode
|
|
)
|
|
{
|
|
gH2OWindow->PostQuitMessage (
|
|
nExitCode
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
PeekMessage (
|
|
LPMSG lpMsg,
|
|
HWND hwnd,
|
|
UINT uMsgFilterMin,
|
|
UINT uMsgFilterMax,
|
|
UINT32 wRemoveMsg
|
|
)
|
|
{
|
|
return gH2OWindow->PeekMessage (
|
|
lpMsg,
|
|
hwnd,
|
|
uMsgFilterMin,
|
|
uMsgFilterMax,
|
|
wRemoveMsg
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
GetMessage (
|
|
LPMSG lpMsg,
|
|
HWND hwnd,
|
|
UINT wMsgFilterMin,
|
|
UINT wMsgFilterMax
|
|
)
|
|
{
|
|
return gH2OWindow->GetMessage (
|
|
lpMsg,
|
|
hwnd,
|
|
wMsgFilterMin,
|
|
wMsgFilterMax
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
TranslateMessage (
|
|
CONST MSG *lpMsg
|
|
)
|
|
{
|
|
return gH2OWindow->TranslateMessage (
|
|
lpMsg
|
|
);
|
|
}
|
|
|
|
LRESULT
|
|
DispatchMessage (
|
|
CONST MSG *lpMsg
|
|
)
|
|
{
|
|
return gH2OWindow->DispatchMessage (
|
|
lpMsg
|
|
);
|
|
}
|
|
|
|
ATOM
|
|
RegisterClass (
|
|
CONST WNDCLASS *lpWndClass
|
|
)
|
|
{
|
|
return gH2OWindow->RegisterClass (
|
|
lpWndClass
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
UnregisterClass (
|
|
LPCWSTR lpClassName,
|
|
HINSTANCE hInstance
|
|
)
|
|
{
|
|
return gH2OWindow->UnregisterClass (
|
|
lpClassName,
|
|
hInstance
|
|
);
|
|
}
|
|
|
|
HWND
|
|
CreateWindowEx (
|
|
UINT32 dwExStyle,
|
|
LPCWSTR lpClassName,
|
|
LPCWSTR lpWindowName,
|
|
UINT32 dwStyle,
|
|
INT32 x,
|
|
INT32 y,
|
|
INT32 nWidth,
|
|
INT32 nHeight,
|
|
HWND hwndParent,
|
|
HMENU hMenu,
|
|
HINSTANCE hInstance,
|
|
LPVOID lpParam
|
|
)
|
|
{
|
|
return gH2OWindow->CreateWindowEx (
|
|
dwExStyle,
|
|
lpClassName,
|
|
lpWindowName,
|
|
dwStyle,
|
|
x,
|
|
y,
|
|
nWidth,
|
|
nHeight,
|
|
hwndParent,
|
|
hMenu,
|
|
hInstance,
|
|
lpParam
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
DestroyWindow (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->DestroyWindow (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
IsWindow (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->IsWindow (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
ShowWindow (
|
|
HWND hwnd,
|
|
int nCmdShow
|
|
)
|
|
{
|
|
return gH2OWindow->ShowWindow (
|
|
hwnd,
|
|
nCmdShow
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
InvalidateRect (
|
|
HWND hwnd,
|
|
CONST RECT *lpRect,
|
|
BOOL bErase
|
|
)
|
|
{
|
|
return gH2OWindow->InvalidateRect (
|
|
hwnd,
|
|
lpRect,
|
|
bErase
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
InvalidateRgn (
|
|
HWND hwnd,
|
|
HRGN hrgn,
|
|
BOOL bErase
|
|
)
|
|
{
|
|
return gH2OWindow->InvalidateRgn (
|
|
hwnd,
|
|
hrgn,
|
|
bErase
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
ValidateRect (
|
|
HWND hwnd,
|
|
CONST RECT *lprc
|
|
)
|
|
{
|
|
return gH2OWindow->ValidateRect (
|
|
hwnd,
|
|
lprc
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
ValidateRgn (
|
|
HWND hwnd,
|
|
HRGN hrgn
|
|
)
|
|
{
|
|
return gH2OWindow->ValidateRgn (
|
|
hwnd,
|
|
hrgn
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
UpdateWindow (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->UpdateWindow (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
HWND
|
|
GetFocus (
|
|
VOID
|
|
)
|
|
{
|
|
return gH2OWindow->GetFocus ();
|
|
|
|
}
|
|
|
|
HWND
|
|
SetFocus (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->SetFocus (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
SetForegroundWindow (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->SetForegroundWindow (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
HWND
|
|
SetActiveWindow (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->SetActiveWindow (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
HWND
|
|
GetActiveWindow (
|
|
VOID
|
|
)
|
|
{
|
|
return gH2OWindow->GetActiveWindow ();
|
|
}
|
|
|
|
BOOL
|
|
BringWindowToTop (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->BringWindowToTop (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
HWND
|
|
GetDesktopWindow (
|
|
VOID
|
|
)
|
|
{
|
|
return gH2OWindow->GetDesktopWindow ();
|
|
}
|
|
|
|
HWND
|
|
GetParent (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->GetParent (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
EnableWindow (
|
|
HWND hwnd,
|
|
BOOL bEnable
|
|
)
|
|
{
|
|
return gH2OWindow->EnableWindow (
|
|
hwnd,
|
|
bEnable
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
AdjustWindowRectEx (
|
|
LPRECT lpRect,
|
|
DWORD dwStyle,
|
|
BOOL bMenu,
|
|
DWORD dwExStyle
|
|
)
|
|
{
|
|
return gH2OWindow->AdjustWindowRectEx (
|
|
lpRect,
|
|
dwStyle,
|
|
bMenu,
|
|
dwExStyle
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
GetClientRect (
|
|
HWND hwnd,
|
|
LPRECT lpRect
|
|
)
|
|
{
|
|
return gH2OWindow->GetClientRect (
|
|
hwnd,
|
|
lpRect
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
GetWindowRect (
|
|
HWND hwnd,
|
|
LPRECT lpRect
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindowRect (
|
|
hwnd,
|
|
lpRect
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
ClientToScreen (
|
|
HWND hwnd,
|
|
LPPOINT lpPoint
|
|
)
|
|
{
|
|
return gH2OWindow->ClientToScreen (
|
|
hwnd,
|
|
lpPoint
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
ScreenToClient (
|
|
HWND hwnd,
|
|
LPPOINT lpPoint
|
|
)
|
|
{
|
|
return gH2OWindow->ScreenToClient (
|
|
hwnd,
|
|
lpPoint
|
|
);
|
|
}
|
|
|
|
int
|
|
MapWindowPoints (
|
|
HWND hwndFrom,
|
|
HWND hwndTo,
|
|
LPPOINT lpPoints,
|
|
UINT cPoints
|
|
)
|
|
{
|
|
return gH2OWindow->MapWindowPoints (
|
|
hwndFrom,
|
|
hwndTo,
|
|
lpPoints,
|
|
cPoints
|
|
);
|
|
}
|
|
|
|
|
|
//
|
|
//LONG
|
|
//GetWindowLong (
|
|
//HWND hwnd,
|
|
//int nIndex
|
|
//)
|
|
//{
|
|
//return gH2OWindow->GetWindowLong (
|
|
// hwnd,
|
|
// nIndex
|
|
// );
|
|
//}
|
|
|
|
INTN
|
|
GetWindowLongPtr (
|
|
HWND hwnd,
|
|
INT32 nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindowLongPtr (
|
|
hwnd,
|
|
nIndex
|
|
);
|
|
}
|
|
//
|
|
//LONG
|
|
//SetWindowLong (
|
|
//HWND hwnd,
|
|
//int nIndex,
|
|
//LONG lNewLong
|
|
//)
|
|
//{
|
|
//return gH2OWindow->SetWindowLong (
|
|
// hwnd,
|
|
// nIndex,
|
|
// lNewLong
|
|
// );
|
|
//}
|
|
|
|
INTN
|
|
SetWindowLongPtr (
|
|
HWND hwnd,
|
|
INT32 nIndex,
|
|
INTN lNewLong
|
|
)
|
|
{
|
|
return gH2OWindow->SetWindowLongPtr (
|
|
hwnd,
|
|
nIndex,
|
|
lNewLong
|
|
);
|
|
}
|
|
|
|
WORD
|
|
GetWindowWord (
|
|
HWND hwnd,
|
|
int nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindowWord (
|
|
hwnd,
|
|
nIndex
|
|
);
|
|
}
|
|
|
|
WORD
|
|
SetWindowWord (
|
|
HWND hwnd,
|
|
int nIndex,
|
|
WORD wNewWord
|
|
)
|
|
{
|
|
return gH2OWindow->SetWindowWord (
|
|
hwnd,
|
|
nIndex,
|
|
wNewWord
|
|
);
|
|
}
|
|
|
|
//ATOM
|
|
//GlobalFindAtom (
|
|
//LPCWSTR lpString
|
|
//)
|
|
//{
|
|
//return gH2OWindow->GlobalFindAtom (
|
|
// lpString
|
|
// );
|
|
//}
|
|
//
|
|
//ATOM
|
|
//GlobalAddAtom (
|
|
//LPCWSTR lpString
|
|
//)
|
|
//{
|
|
//return gH2OWindow->GlobalAddAtom (
|
|
// lpString
|
|
// );
|
|
//}
|
|
|
|
BOOL
|
|
SetProp (
|
|
HWND hWnd,
|
|
LPCWSTR lpString,
|
|
HANDLE hData
|
|
)
|
|
{
|
|
return gH2OWindow->SetProp (
|
|
hWnd,
|
|
lpString,
|
|
hData
|
|
);
|
|
}
|
|
|
|
HANDLE
|
|
GetProp (
|
|
HWND hWnd,
|
|
LPCWSTR lpString
|
|
)
|
|
{
|
|
return gH2OWindow->GetProp (
|
|
hWnd,
|
|
lpString
|
|
);
|
|
}
|
|
|
|
HANDLE
|
|
RemoveProp (
|
|
HWND hWnd,
|
|
LPCWSTR lpString
|
|
)
|
|
{
|
|
return gH2OWindow->RemoveProp (
|
|
hWnd,
|
|
lpString
|
|
);
|
|
}
|
|
|
|
//DWORD
|
|
//GetClassLong (
|
|
//HWND hwnd,
|
|
//int nIndex
|
|
//)
|
|
//{
|
|
//return gH2OWindow->GetClassLong (
|
|
// hwnd,
|
|
// nIndex
|
|
// );
|
|
//}
|
|
|
|
UINTN
|
|
GetClassLongPtr (
|
|
HWND hwnd,
|
|
int nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetClassLongPtr (
|
|
hwnd,
|
|
nIndex
|
|
);
|
|
}
|
|
|
|
int
|
|
GetWindowTextLength (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindowTextLength (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
int
|
|
GetWindowText (
|
|
HWND hwnd,
|
|
LPWSTR lpString,
|
|
int nMaxCount
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindowText (
|
|
hwnd,
|
|
lpString,
|
|
nMaxCount
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
SetWindowText (
|
|
HWND hwnd,
|
|
LPCWSTR lpString
|
|
)
|
|
{
|
|
return gH2OWindow->SetWindowText (
|
|
hwnd,
|
|
lpString
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
MoveWindow (
|
|
HWND hwnd,
|
|
int x,
|
|
int y,
|
|
int nWidth,
|
|
int nHeight,
|
|
BOOL bRepaint
|
|
)
|
|
{
|
|
return gH2OWindow->MoveWindow (
|
|
hwnd,
|
|
x,
|
|
y,
|
|
nWidth,
|
|
nHeight,
|
|
bRepaint
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
GetCursorPos (
|
|
LPPOINT lpPoint
|
|
)
|
|
{
|
|
return gH2OWindow->GetCursorPos (
|
|
lpPoint
|
|
);
|
|
}
|
|
|
|
HWND
|
|
GetCapture (
|
|
VOID
|
|
)
|
|
{
|
|
return gH2OWindow->GetCapture ();
|
|
}
|
|
|
|
HWND
|
|
SetCapture (
|
|
HWND hwnd
|
|
)
|
|
{
|
|
return gH2OWindow->SetCapture (
|
|
hwnd
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
ReleaseCapture (
|
|
VOID
|
|
)
|
|
{
|
|
return gH2OWindow->ReleaseCapture ();
|
|
}
|
|
|
|
UINT
|
|
SetTimer (
|
|
HWND hwnd,
|
|
UINT idTimer,
|
|
UINT uTimeout,
|
|
TIMERPROC lpTimerFunc
|
|
)
|
|
{
|
|
return gH2OWindow->SetTimer (
|
|
hwnd,
|
|
idTimer,
|
|
uTimeout,
|
|
lpTimerFunc
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
KillTimer (
|
|
HWND hwnd,
|
|
UINT idTimer
|
|
)
|
|
{
|
|
return gH2OWindow->KillTimer (
|
|
hwnd,
|
|
idTimer
|
|
);
|
|
}
|
|
|
|
int
|
|
GetSystemMetrics (
|
|
int nIndex
|
|
)
|
|
{
|
|
return gH2OWindow->GetSystemMetrics (
|
|
nIndex
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
SystemParametersInfo (
|
|
UINT uiAction,
|
|
UINT uiParam,
|
|
PVOID pvParam,
|
|
UINT fWinIni
|
|
)
|
|
{
|
|
return gH2OWindow->SystemParametersInfo (
|
|
uiAction,
|
|
uiParam,
|
|
pvParam,
|
|
fWinIni
|
|
);
|
|
}
|
|
|
|
HWND
|
|
GetDlgItem (
|
|
HWND hDlg,
|
|
int nIDDlgItem
|
|
)
|
|
{
|
|
return gH2OWindow->GetDlgItem (
|
|
hDlg,
|
|
nIDDlgItem
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
EnumChildWindows (
|
|
HWND hWndParent,
|
|
WNDENUMPROC lpEnumFunc,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
return gH2OWindow->EnumChildWindows (
|
|
hWndParent,
|
|
lpEnumFunc,
|
|
lParam
|
|
);
|
|
}
|
|
|
|
|
|
BOOL
|
|
SetWindowPos (
|
|
HWND hwnd,
|
|
HWND hwndInsertAfter,
|
|
int x,
|
|
int y,
|
|
int cx,
|
|
int cy,
|
|
UINT fuFlags
|
|
)
|
|
{
|
|
return gH2OWindow->SetWindowPos (
|
|
hwnd,
|
|
hwndInsertAfter,
|
|
x,
|
|
y,
|
|
cx,
|
|
cy,
|
|
fuFlags
|
|
);
|
|
}
|
|
|
|
|
|
int
|
|
GetClipBox (
|
|
HDC Hdc,
|
|
RECT *Rc
|
|
)
|
|
{
|
|
return gH2OWindow->GetClipBox (
|
|
Hdc,
|
|
Rc
|
|
);
|
|
}
|
|
|
|
COLORREF
|
|
SetDCPenColor (
|
|
HDC Hdc,
|
|
COLORREF Color
|
|
)
|
|
{
|
|
return gH2OWindow->SetDCPenColor (
|
|
Hdc,
|
|
Color
|
|
);
|
|
|
|
}
|
|
|
|
COLORREF
|
|
SetDCBrushColor (
|
|
HDC Hdc,
|
|
COLORREF Color
|
|
)
|
|
{
|
|
return gH2OWindow->SetDCBrushColor (
|
|
Hdc,
|
|
Color
|
|
);
|
|
|
|
}
|
|
|
|
|
|
BOOL
|
|
MwRegisterHotKey (
|
|
HWND hWnd,
|
|
INT32 id,
|
|
UINT32 fsModifiers,
|
|
UINT32 vk
|
|
)
|
|
{
|
|
return gH2OWindow->RegisterHotKey (
|
|
hWnd,
|
|
id,
|
|
fsModifiers,
|
|
vk
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
UnregisterHotKey (
|
|
HWND hWnd,
|
|
INT32 id
|
|
)
|
|
{
|
|
return gH2OWindow->UnregisterHotKey (
|
|
hWnd,
|
|
id
|
|
);
|
|
}
|
|
|
|
|
|
HWND
|
|
EFIAPI
|
|
GetWindow (
|
|
HWND hWnd,
|
|
UINT uCmd
|
|
)
|
|
{
|
|
return gH2OWindow->GetWindow (
|
|
hWnd,
|
|
uCmd
|
|
);
|
|
}
|
|
|
|
BOOL
|
|
EFIAPI
|
|
IsChild (
|
|
HWND Parent,
|
|
HWND Child
|
|
)
|
|
{
|
|
return gH2OWindow->IsChild (
|
|
Parent,
|
|
Child
|
|
);
|
|
}
|
|
|
|
|
|
//
|
|
// microwindows functions
|
|
//
|
|
int
|
|
MwOpen(void)
|
|
{
|
|
return gH2OWindow->MwOpen ();
|
|
}
|
|
|
|
void
|
|
MwClose(void)
|
|
{
|
|
gH2OWindow->MwClose ();
|
|
}
|
|
|
|
|
|
void
|
|
GdCloseMouse(void)
|
|
{
|
|
gH2OWindow->GdCloseMouse ();
|
|
}
|
|
|
|
int
|
|
GdOpenMouse(void)
|
|
{
|
|
return gH2OWindow->GdOpenMouse ();
|
|
}
|
|
|
|
int
|
|
MwFastFillRect (
|
|
IN HDC hDC,
|
|
IN CONST RECT *lprc,
|
|
IN COLORREF crColor
|
|
)
|
|
{
|
|
return gH2OWindow->MwFastFillRect (
|
|
hDC,
|
|
lprc,
|
|
crColor
|
|
);
|
|
}
|
|
|
|
|
|
VOID
|
|
GdDrawImagePartToFit (
|
|
PSD psd,
|
|
MWCOORD x,
|
|
MWCOORD y,
|
|
MWCOORD width,
|
|
MWCOORD height,
|
|
MWCOORD sx,
|
|
MWCOORD sy,
|
|
MWCOORD swidth,
|
|
MWCOORD sheight,
|
|
PSD pmd
|
|
)
|
|
{
|
|
gH2OWindow->GdDrawImagePartToFit (
|
|
psd,
|
|
x,
|
|
y,
|
|
width,
|
|
height,
|
|
sx,
|
|
sy,
|
|
swidth,
|
|
sheight,
|
|
pmd
|
|
);
|
|
|
|
|
|
}
|
|
|
|
PSD
|
|
GdLoadImageFromBuffer (
|
|
IN EFI_IMAGE_INPUT *Image
|
|
)
|
|
{
|
|
return gH2OWindow->GdLoadImageFromBuffer (
|
|
Image
|
|
);
|
|
|
|
}
|
|
|
|
PSD
|
|
GdLoadImageFromBuffer2 (
|
|
IN VOID *Buffer,
|
|
IN INT32 Size,
|
|
IN INT32 Flags
|
|
)
|
|
{
|
|
return gH2OWindow->GdLoadImageFromBuffer2 (
|
|
Buffer,
|
|
Size,
|
|
Flags
|
|
);
|
|
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
GdAddGopDevice (
|
|
EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop
|
|
)
|
|
{
|
|
return gH2OWindow->GdAddGopDevice (
|
|
Gop
|
|
);
|
|
|
|
}
|
|
|
|
EFI_STATUS
|
|
GdRemoveGopDevice (
|
|
EFI_GRAPHICS_OUTPUT_PROTOCOL *Gop
|
|
)
|
|
{
|
|
return gH2OWindow->GdRemoveGopDevice (
|
|
Gop
|
|
);
|
|
|
|
}
|
|
|
|
EFI_STATUS
|
|
GdAddEfiKeyData (
|
|
EFI_KEY_DATA *KeyData
|
|
)
|
|
{
|
|
return gH2OWindow->GdAddEfiKeyData (
|
|
KeyData
|
|
);
|
|
}
|
|
|
|
EFI_STATUS
|
|
EFIAPI
|
|
GdAddPointerData (
|
|
EFI_SIMPLE_POINTER_STATE *SimplePointerState OPTIONAL,
|
|
EFI_ABSOLUTE_POINTER_STATE *AbsolutePointerState OPTIONAL
|
|
)
|
|
{
|
|
return gH2OWindow->GdAddPointerData (
|
|
SimplePointerState,
|
|
AbsolutePointerState
|
|
);
|
|
}
|
|
|
|
|