void CPushPinDesktop::doJustBitBltOrScaling(HDC hMemDC, int nWidth, int nHeight, int iFinalWidth, int iFinalHeight, HDC hScrDC, int nX, int nY) {
__int64 start = StartCounter();
boolean notNeedStretching = (iFinalWidth == nWidth) && (iFinalHeight == nHeight);
if(m_iHwndToTrack != NULL)
ASSERT_RAISE(notNeedStretching); // we don't support HWND plus scaling...hmm... LODO move assertion LODO implement this (low prio since they probably are just needing that window, not with scaling too [?])
int captureType = SRCCOPY;
if(m_bUseCaptureBlt)
captureType = captureType | CAPTUREBLT; // CAPTUREBLT here [last param] is for layered (transparent) windows in non-aero I guess (which happens to include the mouse, but we do that elsewhere)
if (notNeedStretching) {
if(m_iHwndToTrack != NULL) {
// make sure we only capture 'not too much' i.e. not past the border of this HWND, for the case of Aero being turned off, it shows other windows that we don't want
// a bit confusing...
RECT p;
if (m_bHwndTrackDecoration)
GetWindowRectIncludingAero(m_iHwndToTrack, &p); // 0.05 ms
else
GetClientRect(m_iHwndToTrack, &p); // 0.005 ms
//GetWindowRect(m_iHwndToTrack, &p); // 0.005 ms
nWidth = min(p.right-p.left, nWidth);
nHeight = min(p.bottom-p.top, nHeight);
}
// Bit block transfer from screen our compatible memory DC. Apparently this is faster than stretching.
BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, captureType);
// 9.3 ms 1920x1080 -> 1920x1080 (100 fps) (11 ms? 14? random?)
}
else {
if (m_iStretchMode == 0)
{
// low quality scaling -- looks terrible
SetStretchBltMode (hMemDC, COLORONCOLOR); // the SetStretchBltMode call itself takes 0.003ms
// COLORONCOLOR took 92ms for 1920x1080 -> 1000x1000, 69ms/80ms for 1920x1080 -> 500x500 aero
// 20 ms 1920x1080 -> 500x500 without aero
// LODO can we get better results with good speed? it is sooo ugly!
}
else
{
SetStretchBltMode (hMemDC, HALFTONE);
// high quality stretching
// HALFTONE took 160ms for 1920x1080 -> 1000x1000, 107ms/120ms for 1920x1080 -> 1000x1000
// 50 ms 1920x1080 -> 500x500 without aero
SetBrushOrgEx(hMemDC, 0, 0, 0); // MSDN says I should call this after using HALFTONE
}
StretchBlt(hMemDC, 0, 0, iFinalWidth, iFinalHeight, hScrDC, nX, nY, nWidth, nHeight, captureType);
}
if(show_performance)
LocalOutput("%s took %.02f ms", notNeedStretching ? "bitblt" : "stretchblt", GetCounterSinceStartMillis(start));
}
// static
void CanvasGdiplus::InitializeDC(HDC context)
{
// Enables world transformation.
// If the GM_ADVANCED graphics mode is set, GDI always draws arcs in the
// counterclockwise direction in logical space. This is equivalent to the
// statement that, in the GM_ADVANCED graphics mode, both arc control points
// and arcs themselves fully respect the device context's world-to-device
// transformation.
BOOL res = SetGraphicsMode(context, GM_ADVANCED);
DCHECK(res != 0);
// Enables dithering.
res = SetStretchBltMode(context, HALFTONE);
DCHECK(res != 0);
// As per SetStretchBltMode() documentation, SetBrushOrgEx() must be called
// right after.
res = SetBrushOrgEx(context, 0, 0, NULL);
DCHECK(res != 0);
// Sets up default orientation.
res = SetArcDirection(context, AD_CLOCKWISE);
DCHECK(res != 0);
// Sets up default colors.
res = SetBkColor(context, RGB(255, 255, 255));
DCHECK(res != CLR_INVALID);
res = SetTextColor(context, RGB(0, 0, 0));
DCHECK(res != CLR_INVALID);
res = SetDCBrushColor(context, RGB(255, 255, 255));
DCHECK(res != CLR_INVALID);
res = SetDCPenColor(context, RGB(0, 0, 0));
DCHECK(res != CLR_INVALID);
// Sets up default transparency.
res = SetBkMode(context, OPAQUE);
DCHECK(res != 0);
res = SetROP2(context, R2_COPYPEN);
DCHECK(res != 0);
}
static void drawPatternSimple(HDC hdc, const RECT& destRect, HBITMAP hbmp, const POINT& phase)
{
OwnPtr<HBRUSH> hBrush = adoptPtr(CreatePatternBrush(hbmp));
if (!hBrush)
return;
POINT oldOrg;
SetBrushOrgEx(hdc, destRect.left - phase.x, destRect.top - phase.y, &oldOrg);
FillRect(hdc, &destRect, hBrush.get());
SetBrushOrgEx(hdc, oldOrg.x, oldOrg.y, 0);
}
static void test_brush_org( void )
{
HDC hdc = GetDC( 0 );
POINT old, pt;
SetBrushOrgEx( hdc, 0, 0, &old );
SetBrushOrgEx( hdc, 1, 1, &pt );
ok( pt.x == 0 && pt.y == 0, "got %d,%d\n", pt.x, pt.y );
SetBrushOrgEx( hdc, 0x10000, -1, &pt );
ok( pt.x == 1 && pt.y == 1, "got %d,%d\n", pt.x, pt.y );
SetBrushOrgEx( hdc, old.x, old.y, &pt );
ok( pt.x == 0x10000 && pt.y == -1, "got %d,%d\n", pt.x, pt.y );
ReleaseDC( 0, hdc );
}
void WINAPI DrawXorBar(HDC hdc, int x1, int y1, int width, int height)
{
static WORD _dotPatternBmp[8] =
{
0x00aa, 0x0055, 0x00aa, 0x0055,
0x00aa, 0x0055, 0x00aa, 0x0055
};
HBITMAP hbitmap;
HBRUSH hbrush,hbrushOld;
hbitmap = CreateBitmap(8,8,1,1,_dotPatternBmp);
hbrush = CreatePatternBrush(hbitmap);
SetBrushOrgEx(hdc,x1,y1,0);
hbrushOld = (HBRUSH)SelectObject(hdc,hbrush);
PatBlt(hdc,x1,y1,width,height,PATINVERT);
SelectObject(hdc,hbrushOld);
DeleteObject(hbrush);
DeleteObject(hbitmap);
}
BOOL wf_scale_blt(wfContext* wfc, HDC hdc, int x, int y, int w, int h, HDC hdcSrc, int x1, int y1, DWORD rop)
{
int ww, wh, dw, dh;
if (!wfc->client_width)
wfc->client_width = wfc->width;
if (!wfc->client_height)
wfc->client_height = wfc->height;
ww = wfc->client_width;
wh = wfc->client_height;
dw = wfc->instance->settings->DesktopWidth;
dh = wfc->instance->settings->DesktopHeight;
if (!ww)
ww = dw;
if (!wh)
wh = dh;
if (wfc->fullscreen || !wfc->instance->settings->SmartSizing || (ww == dw && wh == dh))
{
return BitBlt(hdc, x, y, w, h, wfc->primary->hdc, x1, y1, SRCCOPY);
}
else
{
SetStretchBltMode(hdc, HALFTONE);
SetBrushOrgEx(hdc, 0, 0, NULL);
return StretchBlt(hdc, 0, 0, ww, wh, wfc->primary->hdc, 0, 0, dw, dh, SRCCOPY);
}
return TRUE;
}
void CGradientEditor::CStepHandle::OnDraw(HDC hDC, const LPRECT clientRect)
{
int xSrc = dragging ? WIDTH : 0;
UpdateBounds();
MaskBlt(hDC, bounds.left, bounds.top, WIDTH, HEIGHT, parent->shBitmapDC, xSrc, 0, parent->shBmpMask, xSrc, 0, MAKEROP4(SRCCOPY, 0xAA0029));
SetBrushOrgEx(hDC, -20, 0, NULL);
SelectObject(hDC, GetStockObject(DC_BRUSH));
SetDCBrushColor(hDC, gradient->GetStepColor(stepID));
WorkingMaskBlt(hDC, bounds.left, bounds.top, WIDTH, HEIGHT, hDC, xSrc, 0, parent->shBmpColorMask, xSrc, 0, MAKEROP4(PATCOPY, 0xAA0029));
}
static void DrawPreview(HWND hwnd, HDC hdc)
{
BITMAPINFO bi;
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = 8;
bi.bmiHeader.biHeight = -8;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
HBITMAP hBmpBrush = CreateDIBSection(0, &bi, DIB_RGB_COLORS, 0, 0, 0);
HDC dcBmp = CreateCompatibleDC(0);
HBITMAP hBmpSave = (HBITMAP)SelectObject(dcBmp, hBmpBrush);
HBRUSH hbr = CreateSolidBrush(RGB(0xcc, 0xcc, 0xcc));
RECT rc;
SetRect(&rc, 0, 0, 8, 8);
FillRect(dcBmp, &rc, hbr);
DeleteObject(hbr);
hbr = CreateSolidBrush(RGB(0xff, 0xff, 0xff));
SetRect(&rc, 4, 0, 8, 4);
FillRect(dcBmp, &rc, hbr);
SetRect(&rc, 0, 4, 4, 8);
FillRect(dcBmp, &rc, hbr);
DeleteObject(hbr);
SelectObject(dcBmp, hBmpSave);
DeleteDC(dcBmp);
GetClientRect(hwnd, &rc);
hbr = CreatePatternBrush(hBmpBrush);
SetBrushOrgEx(hdc, 1, 1, 0);
FillRect(hdc, &rc, hbr);
DeleteObject(hbr);
DeleteObject(hBmpBrush);
if (gPreviewOk)
{
int width = min(rc.right, wndPreview->getContent()->getWidth());
int height = min(rc.bottom, wndPreview->getContent()->getHeight());
int left = (rc.right - width) / 2;
int top = (rc.bottom - height) / 2;
BLENDFUNCTION bf;
bf.BlendOp = AC_SRC_OVER;
bf.BlendFlags = 0;
bf.SourceConstantAlpha = 255;
bf.AlphaFormat = AC_SRC_ALPHA;
AlphaBlend(hdc, left, top, width, height,
wndPreview->getContent()->getDC(),
0, 0, width, height, bf);
}
FrameRect(hdc, &rc, GetStockBrush(LTGRAY_BRUSH));
}
static HBRUSH wf_create_brush(wfContext* wfc, rdpBrush* brush, UINT32 color,
UINT32 bpp)
{
UINT32 i;
HBRUSH br;
LOGBRUSH lbr;
BYTE* cdata;
BYTE ipattern[8];
HBITMAP pattern = NULL;
lbr.lbStyle = brush->style;
if (lbr.lbStyle == BS_DIBPATTERN || lbr.lbStyle == BS_DIBPATTERN8X8
|| lbr.lbStyle == BS_DIBPATTERNPT)
lbr.lbColor = DIB_RGB_COLORS;
else
lbr.lbColor = color;
if (lbr.lbStyle == BS_PATTERN || lbr.lbStyle == BS_PATTERN8X8)
{
if (brush->bpp > 1)
{
UINT32 format = gdi_get_pixel_format(bpp);
pattern = wf_create_dib(wfc, 8, 8, format, brush->data, NULL);
lbr.lbHatch = (ULONG_PTR) pattern;
}
else
{
for (i = 0; i != 8; i++)
ipattern[7 - i] = brush->data[i];
cdata = wf_glyph_convert(wfc, 8, 8, ipattern);
pattern = CreateBitmap(8, 8, 1, 1, cdata);
lbr.lbHatch = (ULONG_PTR) pattern;
free(cdata);
}
}
else if (lbr.lbStyle == BS_HATCHED)
{
lbr.lbHatch = brush->hatch;
}
else
{
lbr.lbHatch = 0;
}
br = CreateBrushIndirect(&lbr);
SetBrushOrgEx(wfc->drawing->hdc, brush->x, brush->y, NULL);
if (pattern != NULL)
DeleteObject(pattern);
return br;
}
static void DrawDragDropRectRaw(Draw& draw, const Rect& rc, HBRUSH brush, int width)
{
#ifdef SYSTEMDRAW
SystemDraw *w = dynamic_cast<SystemDraw *>(&draw);
if(w) {
SystemDraw& draw = *w;
UnrealizeObject(brush);
HGDIOBJ old_brush = SelectObject(draw, brush);
SetBrushOrgEx(draw, ~rc.left, ~rc.top, NULL);
Size size = rc.Size();
enum { NOTPATINVERT = 0x00A50065 };
if(2 * width >= min(size.cx, size.cy))
::PatBlt(draw, rc.left, rc.top, size.cx, size.cy, NOTPATINVERT);
else
{
::PatBlt(draw, rc.left, rc.top, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.bottom - width, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
::PatBlt(draw, rc.right - width, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
}
SelectObject(draw, old_brush);
}
#else
UnrealizeObject(brush);
HGDIOBJ old_brush = SelectObject(draw, brush);
SetBrushOrgEx(draw, ~rc.left, ~rc.top, NULL);
Size size = rc.Size();
enum { NOTPATINVERT = 0x00A50065 };
if(2 * width >= min(size.cx, size.cy))
::PatBlt(draw, rc.left, rc.top, size.cx, size.cy, NOTPATINVERT);
else
{
::PatBlt(draw, rc.left, rc.top, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.bottom - width, size.cx, width, NOTPATINVERT);
::PatBlt(draw, rc.left, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
::PatBlt(draw, rc.right - width, rc.top + width, width, size.cy - 2 * width, NOTPATINVERT);
}
SelectObject(draw, old_brush);
#endif
}
void OnPaint(HWND hwnd)
{
PAINTSTRUCT ps;
RECT rc;
HDC hdc = BeginPaint(hwnd, &ps);
GetClientRect(hwnd, &rc);
if (g_hdcMem != NULL) {
SetStretchBltMode(hdc, HALFTONE);
SetBrushOrgEx(hdc, 0, 0, NULL);
StretchBlt(hdc, 0, 0, rc.right - rc.left, rc.bottom - rc.top, g_hdcMem, 0, 0, g_szBmp.cx, g_szBmp.cy, SRCCOPY);
}
EndPaint(hwnd, &ps);
}
/*
* _ClearWindow - erase a window
*/
void _ClearWindow( LPWDATA w )
{
HWND hwnd;
hwnd = w->hwnd;
/*** Clear the w->image array ***/
#ifdef _MBCS
{
mb_char mbc;
int count;
mbc = _mbsnextc( (unsigned char *)" " );
for( count=0; count < w->width * w->height; count++ ) {
w->image[count] = mbc; /* store space in w->image */
}
}
#else
FARmemset( w->image, 0x20, w->width*w->height );
#endif
#if defined( __OS2__ )
{
HPS ps;
RECTL rcl;
ps = WinGetPS( hwnd );
WinQueryWindowRect( hwnd, &rcl );
WinFillRect( ps, &rcl, CLR_WHITE );
WinReleasePS( ps );
}
#else
{
RECT rect;
HDC dc;
dc = GetDC( hwnd );
#ifndef __NT__
UnrealizeObject( w->brush );
#endif
SelectObject( dc, w->brush );
#ifdef __NT__
SetBrushOrgEx( dc, 0, 0, NULL );
#endif
GetClientRect( hwnd, &rect );
FillRect( dc, &rect, w->brush );
ReleaseDC( hwnd, dc );
}
#endif
} /* _ClearWindow */
void tTVPDrawer_GDIDoubleBuffering::Show()
{
if(TargetDC && OffScreenDC && ShouldShow)
{
// オフスクリーンビットマップを TargetDC に転送する
if(DestWidth == SrcWidth && DestHeight == SrcHeight)
{
// 拡大・縮小は必要ない
BitBlt(TargetDC,
DestLeft,
DestTop,
DestWidth,
DestHeight,
OffScreenDC,
0,
0,
SRCCOPY);
}
else
{
// 拡大・縮小が必要
if(TVPZoomInterpolation)
SetStretchBltMode(TargetDC, HALFTONE);
else
SetStretchBltMode(TargetDC, COLORONCOLOR);
SetBrushOrgEx(TargetDC, 0, 0, NULL);
StretchBlt(TargetDC,
DestLeft,
DestTop,
DestWidth,
DestHeight,
OffScreenDC,
0,
0,
SrcWidth,
SrcHeight,
SRCCOPY);
}
if(InBenchMark)
{
// 画面からの読み出しを行う関数を実行する
// こうしないと StrechBlt などはコマンドキューにたたき込まれる
// だけで、実際の描画を待たずに帰る可能性がある。
(void)GetPixel(TargetDC, DestLeft + DestWidth / 2, DestTop + DestHeight / 2);
}
ShouldShow = false;
}
}
HBRUSH wf_create_brush(wfInfo * wfi, rdpBrush* brush, uint32 color, int bpp)
{
int i;
HBRUSH br;
LOGBRUSH lbr;
uint8* cdata;
uint8 ipattern[8];
HBITMAP pattern = NULL;
lbr.lbStyle = brush->style;
if (lbr.lbStyle == BS_DIBPATTERN || lbr.lbStyle == BS_DIBPATTERN8X8 || lbr.lbStyle == BS_DIBPATTERNPT)
lbr.lbColor = DIB_RGB_COLORS;
else
lbr.lbColor = color;
if (lbr.lbStyle == BS_PATTERN || lbr.lbStyle == BS_PATTERN8X8)
{
if (brush->bpp > 1)
{
pattern = wf_create_dib(wfi, 8, 8, bpp, brush->data, NULL);
lbr.lbHatch = (ULONG_PTR) pattern;
}
else
{
for (i = 0; i != 8; i++)
ipattern[7 - i] = brush->data[i];
cdata = wf_glyph_convert(wfi, 8, 8, ipattern);
pattern = CreateBitmap(8, 8, 1, 1, cdata);
lbr.lbHatch = (ULONG_PTR) pattern;
free(cdata);
}
}
else if (lbr.lbStyle == BS_HATCHED)
{
lbr.lbHatch = brush->hatch;
}
else
{
lbr.lbHatch = 0;
}
br = CreateBrushIndirect(&lbr);
SetBrushOrgEx(wfi->drawing->hdc, brush->x, brush->y, NULL);
if (pattern != NULL)
DeleteObject(pattern);
return br;
}
BOOL RingDockSite::DrawBkg(HDC hDC,LPRECT lprc/*=NULL*/,LPSIZE lpoffset/*=NULL*/)
{
RECT rc,lrc={0,0,0,0};
SIZE offsz={0,0};
SIZE offsw={0,0};
if(lprc == NULL)
{
GetClientRect(&rc);
lprc = &rc;
}
if(lpoffset == NULL)
lpoffset = &offsz;
if(m_Background.hBrush)
{
if(m_Background.bSetOrg)
{
if(m_Background.hStandWnd != (HWND)0xFFFFFFFF)
{
//计算背景相对偏移位置
GetWindowRect(m_hWnd,&lrc);
MapWindowPoints(GetDesktopWindow(),m_Background.hStandWnd,(LPPOINT)&lrc,2);
}
SetBrushOrgEx(hDC,m_Background.cx - m_rcPos.left-lpoffset->cx-lrc.left,
m_Background.cy - m_rcPos.top-lpoffset->cy-lrc.top,NULL);
}
/* int nDC = SaveDC(hDC);
LPRINGBARLINEINFO tmp = m_First;
RingDockBar* bar;
while(tmp)
{
bar = tmp->m_first;
while(bar)
{
ExcludeClipRect(hDC,bar->m_rcClient.left,bar->m_rcClient.top,
bar->m_rcClient.right,bar->m_rcClient.bottom);
bar = bar->m_next;
}
tmp = tmp->m_nextline;
}
*/
FillRect(hDC,lprc,m_Background.hBrush);
// RestoreDC(hDC,nDC);
return TRUE;
}
else
return FALSE;
}
void Scope::AllocateWindowsResources()
{
m_hdc = GetDC(m_hwnd);
m_winDC = GetDC(NULL);
m_winCopyDC = CreateCompatibleDC(m_winDC);
ResizeSource();
m_BackDC = CreateCompatibleDC(m_hdc);
m_BackBM = CreateCompatibleBitmap(m_hdc, m_intMainDisplayWidth, m_intMainDisplayHeight);
SelectObject(m_BackDC, m_BackBM);
SetStretchBltMode(m_winCopyDC, HALFTONE);
SetBrushOrgEx(m_winCopyDC, 0, 0, NULL);
}
static void CreatePreview(TSelectorData *sd, TCHAR *fn, LPDRAWITEMSTRUCT lps)
{
HDC hdc = CreateCompatibleDC(lps->hDC);
sd->hbmpPreview = CreateCompatibleBitmap(lps->hDC, lps->rcItem.right - lps->rcItem.left, lps->rcItem.bottom - lps->rcItem.top);
SelectObject(hdc, sd->hbmpPreview);
RECT rc;
HBRUSH hbr;
BITMAPINFO bi = {0};
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = 8;
bi.bmiHeader.biHeight = -8;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
HBITMAP hBmpBrush = (HBITMAP)CreateDIBSection(0, &bi, DIB_RGB_COLORS, 0, 0, 0);
HDC dcBmp = CreateCompatibleDC(0);
HBITMAP hBmpSave = (HBITMAP)SelectObject(dcBmp, hBmpBrush);
hbr = CreateSolidBrush(RGB(0xcc, 0xcc, 0xcc));
SetRect(&rc, 0, 0, 8, 8);
FillRect(dcBmp, &rc, hbr);
DeleteObject(hbr);
hbr = CreateSolidBrush(RGB(0xff, 0xff, 0xff));
SetRect(&rc, 4, 0, 8, 4);
FillRect(dcBmp, &rc, hbr);
SetRect(&rc, 0, 4, 4, 8);
FillRect(dcBmp, &rc, hbr);
DeleteObject(hbr);
SelectObject(dcBmp, hBmpSave);
DeleteDC(dcBmp);
rc = lps->rcItem;
OffsetRect(&rc, -rc.left, -rc.top);
hbr = CreatePatternBrush(hBmpBrush);
SetBrushOrgEx(hdc, 1, 1, 0);
FillRect(hdc, &rc, hbr);
DeleteObject(hbr);
DeleteObject(hBmpBrush);
HDC hdcSave = lps->hDC;
lps->hDC = hdc;
sttPreviewSkin(sd->obj, fn, lps);
lps->hDC = hdcSave;
FrameRect(hdc, &rc, GetStockBrush(LTGRAY_BRUSH));
DeleteDC(hdc);
}
RT_B RT_API RtStretchImage(RT_H hSourceDc, RT_N nSourceWidth, RT_N nSourceHeight, RT_H hDestinationDc, RT_N nDestinationWidth, RT_N nDestinationHeight)
{
RT_B bResult;
if (!SetStretchBltMode(hDestinationDc, HALFTONE)) goto handle_error;
if (!SetBrushOrgEx(hDestinationDc, 0, 0, RT_NULL)) goto handle_error;
if (!StretchBlt(hDestinationDc, 0, 0, nDestinationWidth, nDestinationHeight, hSourceDc, 0, 0, nSourceWidth, nSourceHeight, SRCCOPY)) goto handle_error;
bResult = RT_TRUE;
goto free_resources;
handle_error:
bResult = RT_FALSE;
free_resources:
return bResult;
}
/*
* _DisplayAllLines - show all visible lines...
*/
void _DisplayAllLines( LPWDATA w, int clearFlag )
{
LPLDATA ld;
int i,end;
DWORD ln;
#ifdef __OS2__
#else
HDC dc;
RECT rect;
HBRUSH oldBrush;
#endif
/*** If needed, clear the window to avoid residue ***/
if( clearFlag ) {
#ifdef __OS2__
/* Clearing done for OS/2 in _DisplayLineInWindowWithColor */
#else
/* Clearing doesn't always work as with OS/2, so it's done here */
dc = GetDC( w->hwnd );
#ifndef __NT__
UnrealizeObject( w->brush );
#endif
oldBrush = SelectObject( dc, w->brush );
#ifdef __NT__
SetBrushOrgEx( dc, 0, 0, NULL );
#endif
GetClientRect( w->hwnd, &rect );
FillRect( dc, &rect, w->brush );
SelectObject( dc, oldBrush );
ReleaseDC( w->hwnd, dc );
#endif
}
ln = w->TopLineNumber;
ld = _GetLineDataPointer( w, ln );
end = w->height;
for( i=1; i<end; i++ ) {
if( ld == NULL ) {
_DisplayLineInWindow( w, i, " " );
} else {
_DisplayLineInWindow( w, i, ld->data );
ln++;
ld = _GetLineDataPointer( w, ln );
}
}
} /* _DisplayAllLines */
void CSearchDlg::drawPicture(CStatic* m_Pic/*控件名称*/, int no/*控件编号0-n-1*/)
{
CRect rectPic;
(*m_Pic).GetClientRect(&rectPic);
//m_picture为Picture Control控件变量，获得控件的区域对象
CDC* pDC = m_Pic->GetWindowDC();
//获得显示控件的DC
CImage *pImage = new CImage();
//装载图像的类
int pos = currentPage*numInPages+no;
if (pos< count)
{ //还有图片可以显示
pImage->Load(filenames[pos]);//从磁盘装载图片,根据页面计算得到的图片下标
int width = rectPic.Width();//显示区域的宽和高
int height =rectPic.Height();
int picW = pImage->GetWidth();//图片的宽和高
int picH = pImage->GetHeight();
//计算缩放比
double r1 = double(picW)/double(width);
double r2 = double(picH)/double(height);
//r为最优缩放比例
double r=(r1>=r2?r1:r2);
//防止缩放后失真
SetStretchBltMode(pDC -> m_hDC, HALFTONE);
SetBrushOrgEx(pDC -> m_hDC,0,0,NULL);
//CPoint RectP = rectPic.CenterPoint();
//pImage->Draw(pDC->m_hDC,(RectP.x - width/2)+(width - picW / r) / 2, (RectP.y - height / 2)+(height - picH/r) / 2, int(picW / r), int(picH / r));
//让图片居中
CPoint RectP = rectPic.CenterPoint();
pImage->Draw(pDC->m_hDC,(RectP.x - width/2)+(width - picW / r) / 2, (RectP.y - height / 2)+(height - picH/r) / 2, int(picW / r), int(picH / r));
ReleaseDC(pDC);
}
else
{
m_Pic->ShowWindow(SW_HIDE);
}
UpdateData(TRUE);
}
void CULSplitter::DrawXorBar(HDC hDC, int x1, int y1, int width, int height)
{
static WORD _dotPatternBmp[8] =
{
0x00aa,0x0055,0x00aa,0x0055,
0x00aa,0x0055,0x00aa,0x0055
};
HBITMAP hbm=CreateBitmap(8,8,1,1,_dotPatternBmp);
HBRUSH hbr=CreatePatternBrush(hbm);
SetBrushOrgEx(hDC,x1,y1,0);
HBRUSH hbrushOld=(HBRUSH)SelectObject(hDC, hbr);
PatBlt(hDC, x1, y1, width, height, PATINVERT);
SelectObject(hDC, hbrushOld);
DeleteObject(hbr);
DeleteObject(hbm);
}
LRESULT CALLBACK
xGui_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
struct xGui * this;
if (uMsg == WM_NCCREATE) {
this = ((LPCREATESTRUCT) lParam)->lpCreateParams;
this->hwnd = hWnd;
SetWindowLongPtr(hWnd, GWL_USERDATA, (LONG) this);
this->defproc = DefWindowProc;
} else {
this = (void *) GetWindowLongPtr(hWnd, GWL_USERDATA);
if (this == NULL) {
_tprintf(_T("this=NULL : %s\n"), wMsgToStr(uMsg));
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
}
/*_tprintf("%s : %s : (%08x, %08x) %s\n",
x_nowstr(), this->Flag, wParam, lParam, wMsgToStr(uMsg));*/
if (this->Own_On_Proc &&
this->Own_On_Proc(this, uMsg, wParam, lParam)) {
return this->lResult;
}
switch (uMsg) {
//case WM_CTLCOLORMSGBOX:
//case WM_CTLCOLOREDIT:
//case WM_CTLCOLORLISTBOX:
case WM_CTLCOLORBTN:
//case WM_CTLCOLORDLG:
//case WM_CTLCOLORSCROLLBAR:
case WM_CTLCOLORSTATIC:
{
struct xGui * xSub;
xSub = (void *) GetWindowLongPtr((HWND) lParam, GWL_USERDATA);
SetBkMode((HDC) wParam, TRANSPARENT);
if (xSub &&
xSub->Own_On_Color &&
xSub->Own_On_Color(xSub, uMsg, wParam, lParam)) {
return xSub->lResult;
}
RECT rc;
GetWindowRect(xSub->hwnd, &rc);
MapWindowPoints(NULL, this->hwnd, (LPPOINT)(&rc), 2);
SetBrushOrgEx((HDC) wParam, -rc.left, -rc.top, NULL);
return (LRESULT) this->hbrBkgnd;
}
case WM_COMMAND:
{
struct xGui * xSub;
xSub = (void *) GetWindowLongPtr((HWND) lParam, GWL_USERDATA);
if (xSub &&
xSub->Own_On_Command &&
xSub->Own_On_Command(xSub, uMsg, wParam, lParam)) {
return 0;
}
break;
}
case WM_NOTIFY:
{
struct xGui * xSub;
xSub = (void *) GetWindowLongPtr(((LPNMHDR) lParam)->hwndFrom, GWL_USERDATA);
if (xSub &&
xSub->Own_On_Notify &&
xSub->Own_On_Notify(xSub, uMsg, wParam, lParam)) {
return xSub->lResult;
}
break;
}
case WM_DESTROY:
{
if (this->On_Destroy) {
this->On_Destroy(this);
}
break;
}
case WM_NCDESTROY:
{
WNDPROC wproc = this->defproc;
if (this->On_NCDestroy) {
this->On_NCDestroy(this);
}
if (this->hbrBkgnd) {
DeleteObject(this->hbrBkgnd);
}
if (this->hdcBkgnd) {
DeleteObject(SelectObject(this->hdcBkgnd, this->hBmpOld));
DeleteDC(this->hdcBkgnd);
}
free(this);
return CallWindowProc(wproc, hWnd, uMsg, wParam, lParam);
}
}
return CallWindowProc(this->defproc, hWnd, uMsg, wParam, lParam);
}
static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sha1)
{
DWORD dib_size = get_dib_size(bmi);
HPEN solid_pen, dashed_pen, orig_pen;
HBRUSH solid_brush, dib_brush, hatch_brush, orig_brush;
INT i, y, hatch_style;
HRGN hrgn, hrgn2;
BYTE dib_brush_buf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD) + 16 * 16 * sizeof(DWORD)]; /* Enough for 16 x 16 at 32 bpp */
BITMAPINFO *brush_bi = (BITMAPINFO*)dib_brush_buf;
BYTE *brush_bits;
BOOL dib_is_1bpp = (bmi->bmiHeader.biBitCount == 1);
memset(bits, 0xcc, dib_size);
compare_hash(bmi, bits, sha1, "empty");
solid_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0xff));
orig_pen = SelectObject(hdc, solid_pen);
SetBrushOrgEx(hdc, 0, 0, NULL);
/* horizontal and vertical lines */
for(i = 1; i <= 16; i++)
{
SetROP2(hdc, i);
MoveToEx(hdc, 10, i * 3, NULL);
LineTo(hdc, 100, i * 3); /* l -> r */
MoveToEx(hdc, 100, 50 + i * 3, NULL);
LineTo(hdc, 10, 50 + i * 3); /* r -> l */
MoveToEx(hdc, 120 + i * 3, 10, NULL);
LineTo(hdc, 120 + i * 3, 100); /* t -> b */
MoveToEx(hdc, 170 + i * 3, 100, NULL);
LineTo(hdc, 170 + i * 3, 10); /* b -> t */
}
compare_hash(bmi, bits, sha1, "h and v solid lines");
memset(bits, 0xcc, dib_size);
/* diagonal lines */
SetROP2(hdc, R2_COPYPEN);
for(i = 0; i < 16; i++)
{
double s = sin(M_PI * i / 8.0);
double c = cos(M_PI * i / 8.0);
MoveToEx(hdc, 200.5 + 10 * c, 200.5 + 10 * s, NULL);
LineTo(hdc, 200.5 + 100 * c, 200.5 + 100 * s);
}
compare_hash(bmi, bits, sha1, "diagonal solid lines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(bias_check) / sizeof(bias_check[0]); i++)
{
MoveToEx(hdc, bias_check[i].left, bias_check[i].top, NULL);
LineTo(hdc, bias_check[i].right, bias_check[i].bottom);
}
compare_hash(bmi, bits, sha1, "more diagonal solid lines");
memset(bits, 0xcc, dib_size);
/* solid brush PatBlt */
solid_brush = CreateSolidBrush(RGB(0x33, 0xaa, 0xff));
orig_brush = SelectObject(hdc, solid_brush);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
ret = PatBlt(hdc, 10, y, 100, 10, rop3[i]);
if(rop_uses_src(rop3[i]))
ok(ret == FALSE, "got TRUE for %x\n", rop3[i]);
else
{
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 20;
}
}
compare_hash(bmi, bits, sha1, "solid patblt");
memset(bits, 0xcc, dib_size);
/* clipped lines */
hrgn = CreateRectRgn(10, 10, 200, 20);
hrgn2 = CreateRectRgn(100, 100, 200, 200);
CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
SetRectRgn(hrgn2, 290, 100, 300, 200);
CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
DeleteObject(hrgn2);
for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
{
MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped solid hlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
{
MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped solid vlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
{
MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped solid diagonal lines");
memset(bits, 0xcc, dib_size);
/* clipped PatBlt */
for(i = 0; i < sizeof(patblt_clips) / sizeof(patblt_clips[0]); i++)
{
PatBlt(hdc, patblt_clips[i].left, patblt_clips[i].top,
patblt_clips[i].right - patblt_clips[i].left,
patblt_clips[i].bottom - patblt_clips[i].top, PATCOPY);
}
compare_hash(bmi, bits, sha1, "clipped patblt");
memset(bits, 0xcc, dib_size);
/* clipped dashed lines */
dashed_pen = CreatePen(PS_DASH, 1, RGB(0xff, 0, 0));
SelectObject(hdc, dashed_pen);
SetBkMode(hdc, TRANSPARENT);
SetBkColor(hdc, RGB(0, 0xff, 0));
for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
{
MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped dashed hlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
{
MoveToEx(hdc, hline_clips[i].right - 1, hline_clips[i].bottom, NULL);
LineTo(hdc, hline_clips[i].left - 1, hline_clips[i].top);
}
compare_hash(bmi, bits, sha1, "clipped dashed hlines r -> l");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
{
MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped dashed vlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
{
MoveToEx(hdc, vline_clips[i].right, vline_clips[i].bottom - 1, NULL);
LineTo(hdc, vline_clips[i].left, vline_clips[i].top - 1);
}
compare_hash(bmi, bits, sha1, "clipped dashed vlines b -> t");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
{
MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped dashed diagonal lines");
memset(bits, 0xcc, dib_size);
SetBkMode(hdc, OPAQUE);
for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
{
MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped opaque dashed diagonal lines");
memset(bits, 0xcc, dib_size);
ExtSelectClipRgn(hdc, NULL, RGN_COPY);
/* 8888 DIB pattern brush */
brush_bi->bmiHeader = dib_brush_header_8888;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
memset(brush_bits, 0, 16 * 16 * sizeof(DWORD));
brush_bits[2] = 0xff;
brush_bits[6] = 0xff;
brush_bits[14] = 0xff;
brush_bits[65] = 0xff;
brush_bits[69] = 0xff;
brush_bits[72] = 0xff;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 8888 bottom-up DIB pattern brush */
brush_bi->bmiHeader.biHeight = -brush_bi->bmiHeader.biHeight;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
/* This used to set the x origin to 100 as well, but
there's a Windows bug for 24 bpp where the brush's x offset
is incorrectly calculated for rops that involve both D and P */
SetBrushOrgEx(hdc, 4, 100, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "bottom-up 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 24 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_24;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
memset(brush_bits, 0, 16 * 16 * 3);
brush_bits[0] = brush_bits[3] = brush_bits[6] = brush_bits[8] = 0xff;
brush_bits[49] = brush_bits[52] = 0xff;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 24 bpp brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 555 dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_555;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
memset(brush_bits, 0, 16 * 16 * sizeof(WORD));
brush_bits[0] = brush_bits[1] = 0xff;
brush_bits[32] = brush_bits[34] = 0x7c;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 555 dib brush patblt", dib_is_1bpp ? 1 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
SetBrushOrgEx(hdc, 0, 0, NULL);
/* 8 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_8;
brush_bi->bmiHeader.biClrUsed = 3;
memset(brush_bi->bmiColors, 0, brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD));
brush_bi->bmiColors[0].rgbRed = 0xff;
brush_bi->bmiColors[1].rgbRed = 0xff;
brush_bi->bmiColors[1].rgbGreen = 0xff;
brush_bi->bmiColors[1].rgbBlue = 0xff;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER) + brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD);
memset(brush_bits, 0, 16 * 16 * sizeof(BYTE));
brush_bits[0] = brush_bits[1] = 1;
brush_bits[16] = brush_bits[17] = 2;
brush_bits[32] = brush_bits[33] = 6;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 8 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 4 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_4;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 4 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 1 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_1;
brush_bi->bmiHeader.biClrUsed = 2;
memset(brush_bits, 0, 16 * 4);
brush_bits[0] = 0xf0;
brush_bits[4] = 0xf0;
brush_bits[8] = 0xf0;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 1 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
SetBrushOrgEx(hdc, 0, 0, NULL);
/* Rectangle */
SelectObject(hdc, solid_pen);
SelectObject(hdc, solid_brush);
for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
{
Rectangle(hdc, rectangles[i].left, rectangles[i].top, rectangles[i].right, rectangles[i].bottom);
}
SelectObject(hdc, dashed_pen);
for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
{
Rectangle(hdc, rectangles[i].left, rectangles[i].top + 150, rectangles[i].right, rectangles[i].bottom + 150);
}
compare_hash(bmi, bits, sha1, "rectangles");
memset(bits, 0xcc, dib_size);
SelectObject(hdc, solid_pen);
/* PaintRgn */
PaintRgn(hdc, hrgn);
compare_hash(bmi, bits, sha1, "PaintRgn");
memset(bits, 0xcc, dib_size);
/* RTL rectangles */
if( !pSetLayout )
{
win_skip("Don't have SetLayout\n");
(*sha1)++;
}
else
{
pSetLayout(hdc, LAYOUT_RTL);
PaintRgn(hdc, hrgn);
PatBlt(hdc, 10, 250, 10, 10, PATCOPY);
Rectangle(hdc, 100, 250, 110, 260);
compare_hash(bmi, bits, sha1, "rtl");
memset(bits, 0xcc, dib_size);
pSetLayout(hdc, LAYOUT_LTR);
}
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
for(hatch_style = HS_HORIZONTAL; hatch_style <= HS_DIAGCROSS; hatch_style++)
{
hatch_brush = CreateHatchBrush(hatch_style, RGB(0xff, 0, 0));
SelectObject(hdc, hatch_brush);
ret = PatBlt(hdc, 10 + i + 30 * hatch_style, y, 20, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
SelectObject(hdc, orig_brush);
DeleteObject(hatch_brush);
}
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "hatch brushes", 1, FALSE); /* nt4 is different */
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
SelectObject(hdc, orig_pen);
DeleteObject(hrgn);
DeleteObject(dib_brush);
DeleteObject(dashed_pen);
DeleteObject(solid_brush);
DeleteObject(solid_pen);
}
void Cache_GetAvatar(struct ClcData *dat, struct ClcContact *contact)
{
if (dat->use_avatar_service)
{
if (dat->avatars_show && !DBGetContactSettingByte(contact->hContact, "CList", "HideContactAvatar", 0))
{
contact->avatar_data = (struct avatarCacheEntry *)CallService(MS_AV_GETAVATARBITMAP, (WPARAM)contact->hContact, 0);
if (contact->avatar_data == NULL || contact->avatar_data->cbSize != sizeof(struct avatarCacheEntry)
|| contact->avatar_data->dwFlags == AVS_BITMAP_EXPIRED)
{
contact->avatar_data = NULL;
}
if (contact->avatar_data != NULL)
contact->avatar_data->t_lastAccess = time(NULL);
}
else
{
contact->avatar_data = NULL;
}
}
else
{
int old_pos = contact->avatar_pos;
contact->avatar_pos = AVATAR_POS_DONT_HAVE;
if (dat->avatars_show && !DBGetContactSettingByte(contact->hContact, "CList", "HideContactAvatar", 0))
{
DBVARIANT dbv;
if (!DBGetContactSetting(contact->hContact, "ContactPhoto", "File", &dbv) && (dbv.type == DBVT_ASCIIZ || dbv.type == DBVT_UTF8))
{
HBITMAP hBmp = (HBITMAP) CallService(MS_UTILS_LOADBITMAP, 0, (LPARAM)dbv.pszVal);
if (hBmp != NULL)
{
// Make bounds
BITMAP bm;
if (GetObject(hBmp,sizeof(BITMAP),&bm))
{
// Create data...
HDC hdc;
HBITMAP hDrawBmp,oldBmp;
// Make bounds -> keep aspect radio
LONG width_clip;
LONG height_clip;
RECT rc = {0};
// Clipping width and height
width_clip = dat->avatars_size;
height_clip = dat->avatars_size;
if (height_clip * bm.bmWidth / bm.bmHeight <= width_clip)
{
width_clip = height_clip * bm.bmWidth / bm.bmHeight;
}
else
{
height_clip = width_clip * bm.bmHeight / bm.bmWidth;
}
// Create objs
hdc = CreateCompatibleDC(dat->avatar_cache.hdc);
hDrawBmp = CreateBitmap32(width_clip, height_clip);
oldBmp=SelectObject(hdc, hDrawBmp);
SetBkMode(hdc,TRANSPARENT);
{
POINT org;
GetBrushOrgEx(hdc, &org);
SetStretchBltMode(hdc, HALFTONE);
SetBrushOrgEx(hdc, org.x, org.y, NULL);
}
rc.right = width_clip - 1;
rc.bottom = height_clip - 1;
// Draw bitmap 8//8
{
HDC dcMem = CreateCompatibleDC(hdc);
HBITMAP obmp=SelectObject(dcMem, hBmp);
StretchBlt(hdc, 0, 0, width_clip, height_clip,dcMem, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY);
SelectObject(dcMem,obmp);
DeleteDC(dcMem);
}
{
RECT rtr={0};
rtr.right=width_clip+1;
rtr.bottom=height_clip+1;
FillRect255Alpha(hdc,&rtr);
}
hDrawBmp = GetCurrentObject(hdc, OBJ_BITMAP);
SelectObject(hdc,oldBmp);
DeleteDC(hdc);
// Add to list
if (old_pos >= 0)
{
ImageArray_ChangeImage(&dat->avatar_cache, hDrawBmp, old_pos);
contact->avatar_pos = old_pos;
}
else
{
contact->avatar_pos = ImageArray_AddImage(&dat->avatar_cache, hDrawBmp, -1);
}
DeleteObject(hDrawBmp);
} // if (GetObject(hBmp,sizeof(BITMAP),&bm))
DeleteObject(hBmp);
} //if (hBmp != NULL)
}
DBFreeVariant(&dbv);
}
// Remove avatar if needed
if (old_pos >= 0 && contact->avatar_pos == AVATAR_POS_DONT_HAVE)
{
ImageArray_RemoveImage(&dat->avatar_cache, old_pos);
// Update all itens
ExecuteOnAllContacts(dat, ReduceAvatarPosition, (void *)&old_pos);
}
}
}
/***********************************************************************
* FixBrushOrgEx (GDI32.@)
*
* See SetBrushOrgEx.
*
* NOTES
* This function is no longer documented by MSDN, but in Win95 GDI32 it
* is the same as SetBrushOrgEx().
*/
BOOL WINAPI FixBrushOrgEx( HDC hdc, INT x, INT y, LPPOINT oldorg )
{
return SetBrushOrgEx(hdc,x,y,oldorg);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Message
//////////////////////////////////////////////////////////////////////////////////////////////////////
LRESULT CLoginProcess::DefMainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch ( uMsg )
{
case WM_CTLCOLOREDIT:
{
if ((HWND)lParam == g_xChatEditBox.GetSafehWnd())
{
SetBkColor((HDC)wParam, RGB(0, 0, 0));
SetTextColor((HDC)wParam, RGB(255, 255, 255));
UnrealizeObject(m_hBrush);
POINT pt;
SetBrushOrgEx((HDC)wParam, 0, 0, &pt);
return (LRESULT)m_hBrush;
}
break;
}
case WM_LBUTTONDOWN:
OnLButtonDown(wParam, lParam);
break;
case WM_LBUTTONUP:
OnLButtonUp(wParam, lParam);
break;
case ID_SOCKCLIENT_EVENT_MSG:
g_xClientSocket.OnSocketMessage(wParam, lParam);
break;
case WM_KEYDOWN:
UpdateWindow(g_xMainWnd.GetSafehWnd());
OnKeyDown(wParam, lParam);
break;
case WM_SYSKEYDOWN:
{
if ( wParam == VK_RETURN )
{
g_xMainWnd.OnSysKeyDown(wParam, lParam);
}
return 0L;
}
case WM_MOVE:
{
OnWindowMove(wParam,lParam);
return 0L;
}
case WM_MOUSEMOVE:
OnMouseMove(wParam,lParam);
break;
case _WM_USER_MSG_INPUTTED:
{
switch(m_Progress)
{
case PRG_LOGIN:
case PRG_NEW_ACCOUNT:
OnKeyDown((WPARAM)VK_RETURN,NULL);
break;
case PRG_CHANGE_PASS:
break;
}
}
//case WM_PAINT:
// {
//if (m_Progress == PRG_PATCH)
// {
// RenderPatch(0);
//pPatch->DrawProgressImage();
// return 0l;
// }
// if (m_Progress == PRG_QUIT)
// {
//SendMessage(g_xMainWnd.GetSafehWnd(), WM_DESTROY, NULL, NULL);
// pPatch->DrawProgressImage();
// return 0l;
// }
// break;
// }
}
return CWHDefProcess::DefMainWndProc(hWnd, uMsg, wParam, lParam);
}
LONG APIENTRY WndProc(
HWND hWnd,
UINT message, // type of message
WPARAM wParam, // additional information
LPARAM lParam) // additional information
{
int newThread; // Thread index to switch to
int i;
ThreadData *ptd;
static HWND hShowing = NULL; // which preview window is being shown
static LONG fntHeight = CONTROLHEIGHT; // height for the edit control
switch (message)
{
case WM_CREATE:
{
HDC hDC;
HBITMAP hBmp;
// Create edit control, button, and label at the bottom of the window
// This will allow the user to input a program to run
SetWindowLong (hWnd, GWL_USERDATA,
(LONG)((CREATESTRUCT *)lParam)->lpCreateParams);
ptd = (ThreadData *)GetWindowLong (hWnd, GWL_USERDATA);
CreateControls (ptd, hWnd);
fntHeight = GetFontHeight (hWnd);
//
// initialize the DC array entry
//
hDC = CreateDC (TEXT("DISPLAY"), NULL, NULL, NULL);
gHDCArray[ptd->index] = CreateCompatibleDC (hDC);
//
// Halftone is the best stretching algorithm
//
SetStretchBltMode (gHDCArray[ptd->index], HALFTONE);
SetBrushOrgEx (gHDCArray[ptd->index], 0, 0, NULL);
//
// Use a bitmap the same size as the desktop preview rectangles
//
hBmp = CreateCompatibleBitmap (hDC, gWidth*2, gHeight*2);
SelectObject (gHDCArray[ptd->index], hBmp);
DeleteDC (hDC);
SaveScreen (ptd->index);
TitleWindow (hWnd);
//
// Register hot keys
//
for (i=0;i<10;i++)
{
RegisterHotKey (hWnd, VK_F1+i, MOD_CONTROL, VK_F1+i);
}
return 0;
}
case WM_SIZE:
{
//
// Put the child controls at the right places
//
#define PADDING 5
RECT rect;
ThreadData *ptd;
if (GetClientRect (hWnd, &rect))
{
ptd = (ThreadData *)GetWindowLong (hWnd, GWL_USERDATA);
MoveWindow (ptd->hWndStatic, 0, rect.bottom - CONTROLHEIGHT,
gStaticWidth, fntHeight + PADDING, TRUE);
MoveWindow (ptd->hWndEdit, gStaticWidth + 5,
rect.bottom - fntHeight - PADDING,
gEditWidth, fntHeight+PADDING, TRUE);
MoveWindow (ptd->hWndBtn, gStaticWidth + gEditWidth + 10,
rect.bottom - fntHeight - PADDING,
gBtnWidth, fntHeight+PADDING, TRUE);
MoveWindow (ptd->hWndNew, gStaticWidth+gEditWidth+gBtnWidth+15,
rect.bottom - fntHeight- PADDING,
gNewWidth, fntHeight+PADDING, TRUE);
}
return 0;
}
case WM_PAINT:
PaintMainWnd (hWnd);
return 0;
case WM_RBUTTONDOWN:
{
//
// Find the rectangle in which the button was pressed
//
POINTS pts;
ThreadData *ptd;
ptd = (ThreadData *)GetWindowLong(hWnd, GWL_USERDATA);
pts = MAKEPOINTS (lParam);
if (pts.y > gHeight)
{
return 1;
}
newThread = pts.x/gWidth;
//
// Get a snapshot of the current desktop
//
SaveScreen (ptd->index);
//
// Switch to the selected desktop
//
if (!gDeskArray[newThread])
{
StartNewDesktop (newThread);
}
if (!SwitchDesktop (gDeskArray[newThread]))
MessageBox (hWnd,
PSZ(IDS_BADDESKTOP),
PSZ(IDS_ERRCAPTION), MB_OK);
return 0;
}
case WM_LBUTTONDOWN:
//
// show the preview window
//
{
POINTS pts;
POINT ptl;
int *index;
pts = MAKEPOINTS (lParam);
if (pts.y > gHeight)
{
return 1;
}
newThread = pts.x/gWidth;
index = GlobalAlloc (GMEM_FIXED, sizeof(int));
if (!index)
{
return 1;
}
*index = newThread;
//
// Want to show the preview window where the button was clicked.
// Map the given points to screen coords.
// ClientToScreen is expecting a POINT structure, not a POINTS
//
ptl.x = (LONG)pts.x;
ptl.y = (LONG)pts.y;
ClientToScreen (hWnd, &ptl);
hShowing = CreateWindow (szPreviewClass, TEXT(""),
WS_POPUP | WS_VISIBLE | WS_BORDER,
ptl.x+3,
ptl.y+3,
gWidth*2,
gHeight*2,
hWnd,
(HMENU)0, ghInst, (LPVOID)index);
return 0;
}
case WM_CHAR:
if (wParam == VK_RETURN)
{
PostMessage (hWnd, WM_COMMAND, (WPARAM)IDC_RUNMEBTN, 0);
}
return 0;
case WM_SYSCHAR:
{
ThreadData *ptd;
ptd = (ThreadData *)GetWindowLong(hWnd, GWL_USERDATA);
switch (wParam)
{
// alt+r == focus on the edit control
case TEXT('r'):
case TEXT('R'):
if (GetKeyState (VK_MENU))
{
SetFocus (ptd->hWndEdit);
}
return 0;
// alt+n = create a new desktop
case TEXT('n'):
case TEXT('N'):
if (GetKeyState (VK_MENU))
{
PostMessage (hWnd, WM_COMMAND, (WPARAM)IDC_NEWDSKBTN, 0);
}
}
return 0;
}
case WM_HOTKEY:
case WM_KEYDOWN:
//
// F1-F9 switches to corresponding desktop
//
if ((wParam >= VK_F1 && wParam <= VK_F10)
&& (wParam - VK_F1 <= (UINT)gMaxIndex))
{
LONG x, y;
x = (wParam - VK_F1) * gWidth + 2;
y = gHeight - 4;
PostMessage (hWnd, WM_RBUTTONDOWN, 0, MAKELPARAM (x, y));
}
return 0;
case WM_SETFOCUS:
case WM_NCLBUTTONUP:
case WM_LBUTTONUP:
//
// destroy the preview window
//
if (hShowing)
{
DestroyWindow (hShowing);
hShowing = NULL;
}
return 0;
case WM_CLOSE:
//
// to be safe, check for a preview window
//
if (hShowing)
{
DestroyWindow (hShowing);
hShowing = NULL;
}
//
// go to the default desktop so the DestroyWindow calls all succeed
//
SwitchDesktop (DEFAULT_DESKTOP);
//
// kill the window on this desktop
// all the windows will be destroyed if this is the default desktop
//
for (i=gMaxIndex;i>=0;i--)
{
DestroyWindow (hWndArray[i]);
}
//
// Unregister the hot keys
//
for (i=0;i<10;i++)
{
UnregisterHotKey (hWnd,VK_F1+i);
}
return 0;
case WM_DESTROY: // message: window being destroyed
PostQuitMessage(0);
return 0;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_RUNMEBTN:
{
RunApp (hWnd);
return 0;
}
case IDC_NEWDSKBTN:
//
// Create a new desktop and resize the windows to show it.
//
{
RECT rect;
int i;
if (gMaxIndex + 1 < MAX_THREADS)
{
gMaxIndex++;
StartNewDesktop (gMaxIndex);
GetWindowRect (hWnd,&rect);
for (i=0;i<gMaxIndex;i++)
{
MoveWindow (hWndArray[i],
rect.left, rect.top,
rect.right + gWidth, rect.bottom-rect.top,
TRUE);
}
}
return 0;
}
default:
return DefWindowProc (hWnd, message, wParam, lParam);
}
}
default: // Passes it on if unprocessed
return (DefWindowProc (hWnd, message, wParam, lParam));
}
}
LRESULT CALLBACK Explorerplusplus::TabProxyWndProc(HWND hwnd,UINT Msg,WPARAM wParam,LPARAM lParam,int iTabId)
{
switch(Msg)
{
case WM_ACTIVATE:
/* Restore the main window if necessary, and switch
to the actual tab. */
if(IsIconic(m_hContainer))
{
ShowWindow(m_hContainer,SW_RESTORE);
}
OnSelectTab(iTabId,FALSE);
return 0;
break;
case WM_SETFOCUS:
SetFocus(m_hListView[iTabId]);
break;
case WM_SYSCOMMAND:
switch(wParam)
{
case SC_CLOSE:
break;
default:
SendMessage(m_hListView[iTabId],WM_SYSCOMMAND,wParam,lParam);
break;
}
break;
/* Generate a thumbnail of the current tab. Basic procedure:
1. Generate a full-scale bitmap of the main window.
2. Overlay a bitmap of the specified tab onto the main
window bitmap.
3. Shrink the resulting bitmap down to the correct thumbnail size.
A thumbnail will be dynamically generated, provided the main window
is not currently minimized (as we won't be able to grap a screenshot
of it). If the main window is minimized, we'll use a cached screenshot
of the tab (taken before the main window was minimized). */
case WM_DWMSENDICONICTHUMBNAIL:
{
HDC hdc;
HDC hdcSrc;
HBITMAP hbmTab = NULL;
HBITMAP hPrevBitmap;
Gdiplus::Color color(0,0,0);
HRESULT hr;
int iBitmapWidth;
int iBitmapHeight;
int iWidth;
int iHeight;
int iMaxWidth;
int iMaxHeight;
iMaxWidth = HIWORD(lParam);
iMaxHeight = LOWORD(lParam);
/* If the main window is minimized, it won't be possible
to generate a thumbnail for any of the tabs. In that
case, use a static 'No Preview Available' bitmap. */
if(IsIconic(m_hContainer))
{
hbmTab = (HBITMAP)LoadImage(GetModuleHandle(0),MAKEINTRESOURCE(IDB_NOPREVIEWAVAILABLE),IMAGE_BITMAP,0,0,0);
SetBitmapDimensionEx(hbmTab,223,130,NULL);
}
else
{
hbmTab = CaptureTabScreenshot(iTabId);
}
SIZE sz;
GetBitmapDimensionEx(hbmTab,&sz);
iBitmapWidth = sz.cx;
iBitmapHeight = sz.cy;
/* Shrink the bitmap. */
HDC hdcThumbnailSrc;
HBITMAP hbmThumbnail;
POINT pt;
hdc = GetDC(m_hContainer);
hdcSrc = CreateCompatibleDC(hdc);
SelectObject(hdcSrc,hbmTab);
hdcThumbnailSrc = CreateCompatibleDC(hdc);
/* If the current height of the main window
is less than the width, we'll create a thumbnail
of maximum width; else maximum height. */
if((iBitmapWidth / iMaxWidth) > (iBitmapHeight / iMaxHeight))
{
iWidth = iMaxWidth;
iHeight = iMaxWidth * iBitmapHeight / iBitmapWidth;
}
else
{
iHeight = iMaxHeight;
iWidth = iMaxHeight * iBitmapWidth / iBitmapHeight;
}
/* Thumbnail bitmap. */
Gdiplus::Bitmap bmpThumbnail(iWidth,iHeight,PixelFormat32bppARGB);
bmpThumbnail.GetHBITMAP(color,&hbmThumbnail);
hPrevBitmap = (HBITMAP)SelectObject(hdcThumbnailSrc,hbmThumbnail);
/* Finally, shrink the full-scale bitmap down into a thumbnail. */
SetStretchBltMode(hdcThumbnailSrc,HALFTONE);
SetBrushOrgEx(hdcThumbnailSrc,0,0,&pt);
StretchBlt(hdcThumbnailSrc,0,0,iWidth,iHeight,hdcSrc,0,0,iBitmapWidth,iBitmapHeight,SRCCOPY);
SelectObject(hdcThumbnailSrc,hPrevBitmap);
DeleteDC(hdcThumbnailSrc);
HMODULE hDwmapi;
DwmSetIconicThumbnailProc DwmSetIconicThumbnail;
hDwmapi = LoadLibrary(_T("dwmapi.dll"));
if(hDwmapi != NULL)
{
DwmSetIconicThumbnail = (DwmSetIconicThumbnailProc)GetProcAddress(hDwmapi,"DwmSetIconicThumbnail");
if(DwmSetIconicThumbnail != NULL)
{
hr = DwmSetIconicThumbnail(hwnd,hbmThumbnail,0);
}
}
FreeLibrary(hDwmapi);
/* Delete the thumbnail bitmap. */
DeleteObject(hbmTab);
SelectObject(hdcSrc,hPrevBitmap);
DeleteObject(hbmThumbnail);
DeleteDC(hdcSrc);
ReleaseDC(m_hContainer,hdc);
return 0;
}
break;
case WM_DWMSENDICONICLIVEPREVIEWBITMAP:
{
HMODULE hDwmapi;
TabPreviewInfo_t tpi;
DwmSetIconicLivePreviewBitmapProc DwmSetIconicLivePreviewBitmap;
tpi.hbm = NULL;
if(IsIconic(m_hContainer))
{
/* TODO: Show an image here... */
}
else
{
GetTabLivePreviewBitmap(iTabId,&tpi);
}
hDwmapi = LoadLibrary(_T("dwmapi.dll"));
if(hDwmapi != NULL)
{
DwmSetIconicLivePreviewBitmap = (DwmSetIconicLivePreviewBitmapProc)GetProcAddress(hDwmapi,"DwmSetIconicLivePreviewBitmap");
if(DwmSetIconicLivePreviewBitmap != NULL)
{
DwmSetIconicLivePreviewBitmap(hwnd,tpi.hbm,&tpi.ptOrigin,0);
}
}
FreeLibrary(hDwmapi);
if(tpi.hbm != NULL)
{
DeleteObject(tpi.hbm);
}
return 0;
}
break;
case WM_CLOSE:
{
TCITEM tcItem;
int nTabs;
int i = 0;
nTabs = TabCtrl_GetItemCount(m_hTabCtrl);
if(nTabs == 1)
{
/* If this is the last tab, we'll close
the whole application. */
SendMessage(m_hContainer,WM_CLOSE,0,0);
}
else
{
for(i = 0;i < nTabs;i++)
{
tcItem.mask = TCIF_PARAM;
TabCtrl_GetItem(m_hTabCtrl,i,&tcItem);
if((int)tcItem.lParam == iTabId)
{
/* Close the tab... */
CloseTab(i);
break;
}
}
}
}
break;
}
return DefWindowProc(hwnd,Msg,wParam,lParam);
}
HBITMAP Explorerplusplus::CaptureTabScreenshot(int iTabId)
{
HDC hdc;
HDC hdcSrc;
HBITMAP hBitmap;
HBITMAP hPrevBitmap;
Gdiplus::Color color(0,0,0);
RECT rcMain;
RECT rcTab;
HWND hTab = m_hListView[iTabId];
GetClientRect(m_hContainer,&rcMain);
GetClientRect(hTab,&rcTab);
/* Main window BitBlt. */
hdc = GetDC(m_hContainer);
hdcSrc = CreateCompatibleDC(hdc);
/* Any bitmap sent back to the operating system will need to be in 32-bit
ARGB format. */
Gdiplus::Bitmap bi(GetRectWidth(&rcMain),GetRectHeight(&rcMain),PixelFormat32bppARGB);
bi.GetHBITMAP(color,&hBitmap);
/* BitBlt the main window into the bitmap. */
hPrevBitmap = (HBITMAP)SelectObject(hdcSrc,hBitmap);
BitBlt(hdcSrc,0,0,GetRectWidth(&rcMain),GetRectHeight(&rcMain),hdc,0,0,SRCCOPY);
/* Now BitBlt the tab onto the main window. */
HDC hdcTab;
HDC hdcTabSrc;
HBITMAP hbmTab;
HBITMAP hbmTabPrev;
BOOL bVisible;
hdcTab = GetDC(hTab);
hdcTabSrc = CreateCompatibleDC(hdcTab);
hbmTab = CreateCompatibleBitmap(hdcTab,GetRectWidth(&rcTab),GetRectHeight(&rcTab));
hbmTabPrev = (HBITMAP)SelectObject(hdcTabSrc,hbmTab);
bVisible = IsWindowVisible(hTab);
if(!bVisible)
{
ShowWindow(hTab,SW_SHOW);
}
PrintWindow(hTab,hdcTabSrc,PW_CLIENTONLY);
if(!bVisible)
{
ShowWindow(hTab,SW_HIDE);
}
MapWindowPoints(hTab,m_hContainer,(LPPOINT)&rcTab,2);
BitBlt(hdcSrc,rcTab.left,rcTab.top,GetRectWidth(&rcTab),GetRectHeight(&rcTab),hdcTabSrc,0,0,SRCCOPY);
SelectObject(hdcTabSrc,hbmTabPrev);
DeleteObject(hbmTab);
DeleteDC(hdcTabSrc);
ReleaseDC(hTab,hdcTab);
/* Shrink the bitmap. */
HDC hdcThumbnailSrc;
HBITMAP hbmThumbnail;
POINT pt;
hdcThumbnailSrc = CreateCompatibleDC(hdc);
/* Thumbnail bitmap. */
Gdiplus::Bitmap bmpThumbnail(GetRectWidth(&rcMain),GetRectHeight(&rcMain),PixelFormat32bppARGB);
bmpThumbnail.GetHBITMAP(color,&hbmThumbnail);
hPrevBitmap = (HBITMAP)SelectObject(hdcThumbnailSrc,hbmThumbnail);
/* Finally, shrink the full-scale bitmap down into a thumbnail. */
SetStretchBltMode(hdcThumbnailSrc,HALFTONE);
SetBrushOrgEx(hdcThumbnailSrc,0,0,&pt);
BitBlt(hdcThumbnailSrc,0,0,GetRectWidth(&rcMain),GetRectHeight(&rcMain),hdcSrc,0,0,SRCCOPY);
SetBitmapDimensionEx(hbmThumbnail,GetRectWidth(&rcMain),GetRectHeight(&rcMain),NULL);
SelectObject(hdcThumbnailSrc,hPrevBitmap);
DeleteDC(hdcThumbnailSrc);
DeleteObject(hBitmap);
SelectObject(hdcSrc,hPrevBitmap);
DeleteDC(hdcSrc);
ReleaseDC(m_hContainer,hdc);
return hbmThumbnail;
}
/* It is up to the caller to delete the bitmap returned by this method. */
void Explorerplusplus::GetTabLivePreviewBitmap(int iTabId,TabPreviewInfo_t *ptpi)
{
HDC hdcTab;
HDC hdcTabSrc;
HBITMAP hbmTab;
HBITMAP hbmTabPrev;
Gdiplus::Color color(0,0,0);
MENUBARINFO mbi;
POINT pt;
BOOL bVisible;
RECT rcTab;
HWND hTab = m_hListView[iTabId];
hdcTab = GetDC(hTab);
hdcTabSrc = CreateCompatibleDC(hdcTab);
GetClientRect(hTab,&rcTab);
Gdiplus::Bitmap bi(GetRectWidth(&rcTab),GetRectHeight(&rcTab),PixelFormat32bppARGB);
bi.GetHBITMAP(color,&hbmTab);
hbmTabPrev = (HBITMAP)SelectObject(hdcTabSrc,hbmTab);
bVisible = IsWindowVisible(hTab);
if(!bVisible)
{
ShowWindow(hTab,SW_SHOW);
}
PrintWindow(hTab,hdcTabSrc,PW_CLIENTONLY);
if(!bVisible)
{
ShowWindow(hTab,SW_HIDE);
}
SetStretchBltMode(hdcTabSrc,HALFTONE);
SetBrushOrgEx(hdcTabSrc,0,0,&pt);
StretchBlt(hdcTabSrc,0,0,GetRectWidth(&rcTab),GetRectHeight(&rcTab),hdcTabSrc,
0,0,GetRectWidth(&rcTab),GetRectHeight(&rcTab),SRCCOPY);
MapWindowPoints(hTab,m_hContainer,(LPPOINT)&rcTab,2);
mbi.cbSize = sizeof(mbi);
GetMenuBarInfo(m_hContainer,OBJID_MENU,0,&mbi);
/* The operating system will automatically
draw the main window. Therefore, we'll just shift
the tab into it's proper position. */
ptpi->ptOrigin.x = rcTab.left;
/* Need to include the menu bar in the offset. */
ptpi->ptOrigin.y = rcTab.top + mbi.rcBar.bottom - mbi.rcBar.top;
ptpi->hbm = hbmTab;
ptpi->iTabId = iTabId;
SelectObject(hdcTabSrc,hbmTabPrev);
DeleteDC(hdcTabSrc);
ReleaseDC(hTab,hdcTab);
}
