void CHMMDemoView::OnDraw(CDC* pDC)
{
CHMMDemoDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
HDC dstDC = pDC->m_hDC;
CImage& frame = m_camera.GetFrame();
CRect r;
GetClipBox( dstDC, &r );
if( m_imageList && m_imageList->GetCount() > 1 ) //several images was selected
{
pDC->Draw3dRect(0,0,frame.Width(),frame.Height(),RGB(0,0,0),RGB(128,128,128));
}
frame.Show( dstDC, r.left, r.top, r.Width(), r.Height(), r.left, r.top );
if( m_sel.Width() != 0 && m_sel.Height() != 0 )
{
HGDIOBJ old = SelectObject( dstDC, GetStockObject( WHITE_PEN ));
POINT pt[] = {
{ m_sel.left - r.left, m_sel.top - r.top },
{ m_sel.right - r.left - 1, m_sel.top - r.top },
{ m_sel.right - r.left - 1, m_sel.bottom - r.top - 1},
{ m_sel.left - r.left, m_sel.bottom - r.top - 1},
{ m_sel.left - r.left, m_sel.top - r.top }
};
Polyline( dstDC, pt, 5 );
SelectObject( dstDC, old );
}
//::ReleaseDC( m_hWnd, dstDC );
}
/***********************************************************************
* X11DRV_EnumDisplayMonitors (X11DRV.@)
*/
BOOL CDECL X11DRV_EnumDisplayMonitors( HDC hdc, LPRECT rect, MONITORENUMPROC proc, LPARAM lp )
{
int i;
if (hdc)
{
POINT origin;
RECT limit;
if (!GetDCOrgEx( hdc, &origin )) return FALSE;
if (GetClipBox( hdc, &limit ) == ERROR) return FALSE;
if (rect && !IntersectRect( &limit, &limit, rect )) return TRUE;
for (i = 0; i < nb_monitors; i++)
{
RECT monrect = monitors[i].rcMonitor;
OffsetRect( &monrect, -origin.x, -origin.y );
if (IntersectRect( &monrect, &monrect, &limit ))
if (!proc( index_to_monitor(i), hdc, &monrect, lp ))
return FALSE;
}
}
else
{
for (i = 0; i < nb_monitors; i++)
{
RECT unused;
if (!rect || IntersectRect( &unused, &monitors[i].rcMonitor, rect ))
if (!proc( index_to_monitor(i), 0, &monitors[i].rcMonitor, lp ))
return FALSE;
}
}
return TRUE;
}
//---------------------------------------------------------------------------
void DrawFractal(HDC DC, SetupBitsProc FracProc,
TFloat PLeft, TFloat PTop, TFloat PWidth, TFloat PHeight,
int MaxIter, TFloat BailOut, int colCoeff)
{
long x, y;
int count, CWidth, CHeight;
RECT Rect;
GetClipBox(DC, &Rect);
CWidth = (Rect.right - Rect.left) & 0xFFFFFFF8;
CHeight = (Rect.bottom - Rect.top) & 0xFFFFFFF8;
COLORREF *bits = new COLORREF[CWidth * CHeight];
(*FracProc)(bits, CWidth, CHeight, MaxIter, colCoeff, PLeft, PTop,
PWidth / CWidth, PHeight / CHeight, BailOut);
HDC bmpdc = CreateCompatibleDC(DC);
HBITMAP bmp = CreateBitmap(CWidth, CHeight, 1, 32, bits);
SelectObject(bmpdc, bmp);
BitBlt(DC, 0, 0, CWidth, CHeight, bmpdc,
0,0, SRCCOPY);
SelectObject(bmpdc, NULL);
DeleteObject(bmp);
DeleteDC(bmpdc);
delete bits;
}
DllExport int FAR PASCAL VBWalkerDraw(HDC hDC)
{
int j;
//Cube CubeObject;
RECT r;
VectorType SliceVectorMin, SliceVectorMax;
GetClipBox(hDC, &r);
// Height should be set by drawing program!
CubeObject.Transform.Height = r.bottom - r.top;
CubeObject.SetOrigin( 100, 100, 0);
CubeObject.SetScale( 2, 2 );
// Set the visibe slice through object
SliceVectorMin.x = 0;
SliceVectorMin.y = 0;
SliceVectorMin.z = 0;
SliceVectorMax.x = 11;
SliceVectorMax.y = 5;
SliceVectorMax.z = 4;
// Colour should be set by the drawing program!
// But we don't need to do it here because drawing program has such
// functionality built in.
CubeObject.DrawCreateWalker(3);
CubeObject.SetSliceVector(&SliceVectorMin, &SliceVectorMax);
CubeObject.DrawWalkerhDC(hDC);
CubeObject.DeleteAllCubes();
return j;
}
void CALLBACK
PollTimer(HWND hwnd, UINT uMsg, UINT_PTR idTimer, DWORD dwTime)
{
HDC hdc = GetDC(hwnd);
if (hdc) {
RECT rcClip, rcClient;
LPCTSTR pszMsg;
switch (GetClipBox(hdc, &rcClip)) {
case NULLREGION:
pszMsg = TEXT("completely covered");
break;
case SIMPLEREGION:
GetClientRect(hwnd, &rcClient);
if (EqualRect(&rcClient, &rcClip)) {
pszMsg = TEXT("completely uncovered");
} else {
pszMsg = TEXT("partially covered");
}
break;
case COMPLEXREGION:
pszMsg = TEXT("partially covered");
break;
default:
pszMsg = TEXT("Error");
break;
}
// If we want to, we can also use RectVisible
// or PtVisible - or go totally overboard by
// using GetClipRgn
ReleaseDC(hwnd, hdc);
SetWindowText(hwnd, pszMsg);
}
}
BOOL
DoSDKEraseBkGnd2(
IN CONST HDC hDC,
IN CONST COLORREF crBkGndFill
)
{
HBITMAP hbmBkGnd = DoGetBkGndBitmap2(0);
if (hDC && hbmBkGnd)
{
RECT rc;
if ((ERROR != GetClipBox(hDC, &rc)) && !IsRectEmpty(&rc))
{
HDC hdcMem = CreateCompatibleDC(hDC);
if (hdcMem)
{
HBRUSH hbrBkGnd = CreateSolidBrush(crBkGndFill);
if (hbrBkGnd)
{
HGDIOBJ hbrOld = SelectObject(hDC, hbrBkGnd);
if (hbrOld)
{
SIZE size = {
(rc.right-rc.left), (rc.bottom-rc.top)
};
if (PatBlt(hDC, rc.left, rc.top, size.cx, size.cy, PATCOPY))
{
HGDIOBJ hbmOld = SelectObject(hdcMem, hbmBkGnd);
if (hbmOld)
{
StretchBlt(hDC,
0,
0,
size.cx,
size.cy,
hdcMem,
0,
0,
wd,
ht,
SRCCOPY);
/* BitBlt(hDC, rc.left, rc.top, size.cx, size.cy,
hdcMem, rc.left, rc.top, SRCCOPY);*/
SelectObject(hdcMem, hbmOld);
}
}
SelectObject(hDC, hbrOld);
}
DeleteObject(hbrBkGnd);
}
DeleteDC(hdcMem);
}
}
}
return TRUE;
}
static BOOL CDECL nulldrv_ScrollDC( HDC hdc, INT dx, INT dy, HRGN update )
{
RECT rect;
GetClipBox( hdc, &rect );
return BitBlt( hdc, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top,
hdc, rect.left - dx, rect.top - dy, SRCCOPY );
}
static cairo_int_status_t
_cairo_win32_save_initial_clip (HDC hdc, cairo_win32_display_surface_t *surface)
{
RECT rect;
int clipBoxType;
int gm;
XFORM saved_xform;
/* GetClipBox/GetClipRgn and friends interact badly with a world transform
* set. GetClipBox returns values in logical (transformed) coordinates;
* it's unclear what GetClipRgn returns, because the region is empty in the
* case of a SIMPLEREGION clip, but I assume device (untransformed) coordinates.
* Similarly, IntersectClipRect works in logical units, whereas SelectClipRgn
* works in device units.
*
* So, avoid the whole mess and get rid of the world transform
* while we store our initial data and when we restore initial coordinates.
*
* XXX we may need to modify x/y by the ViewportOrg or WindowOrg
* here in GM_COMPATIBLE; unclear.
*/
gm = GetGraphicsMode (hdc);
if (gm == GM_ADVANCED) {
GetWorldTransform (hdc, &saved_xform);
ModifyWorldTransform (hdc, NULL, MWT_IDENTITY);
}
clipBoxType = GetClipBox (hdc, &rect);
if (clipBoxType == ERROR) {
_cairo_win32_print_gdi_error (__FUNCTION__);
SetGraphicsMode (hdc, gm);
/* XXX: Can we make a more reasonable guess at the error cause here? */
return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
}
surface->win32.extents.x = rect.left;
surface->win32.extents.y = rect.top;
surface->win32.extents.width = rect.right - rect.left;
surface->win32.extents.height = rect.bottom - rect.top;
surface->initial_clip_rgn = NULL;
surface->had_simple_clip = FALSE;
if (clipBoxType == COMPLEXREGION) {
surface->initial_clip_rgn = CreateRectRgn (0, 0, 0, 0);
if (GetClipRgn (hdc, surface->initial_clip_rgn) <= 0) {
DeleteObject(surface->initial_clip_rgn);
surface->initial_clip_rgn = NULL;
}
} else if (clipBoxType == SIMPLEREGION) {
surface->had_simple_clip = TRUE;
}
if (gm == GM_ADVANCED)
SetWorldTransform (hdc, &saved_xform);
return CAIRO_STATUS_SUCCESS;
}
// CImgCtx (Public) -----------------------------------------------------------
void CImgCtx::Tile(
HDC hdc,
POINT* pptOrg,
RECT* prc,
SIZE* psizePrint,
COLORREF crBack,
IMGANIMSTATE* pImgAnimState,
DWORD dwFlags)
{
BOOL fOpaque = !!(GetState() & IMGTRANS_OPAQUE);
// If the source image is 1x1 just let the normal StretchBlt mechanism
// fill up the destination.
if(GetImgInfo()->_xWid==1 && GetImgInfo()->_yHei==1)
{
if(crBack != CLR_INVALID)
{
PatBltBrush(hdc, prc, PATCOPY, crBack);
}
if(pImgAnimState)
{
GetImgInfo()->DrawFrame(hdc, pImgAnimState, prc, NULL, NULL, dwFlags);
}
else
{
GetImgInfo()->DrawImage(hdc, prc, NULL, SRCCOPY, dwFlags);
}
goto Cleanup;
}
// If the image is opaque and we are writing into an offscreen bitmap
// which is not clipped, just tile directly into it.
if(psizePrint==NULL && (fOpaque || crBack!=CLR_INVALID) && GetObjectType(hdc)==OBJ_MEMDC)
{
RECT rcBox;
int iRgn = GetClipBox(hdc, &rcBox);
if(iRgn==NULLREGION
|| (iRgn==SIMPLEREGION
&& prc->left>=rcBox.left
&& prc->top>=rcBox.top
&& prc->right<=rcBox.right
&& prc->bottom<=rcBox.bottom))
{
TileFast(hdc, prc, pptOrg->x, pptOrg->y, fOpaque, crBack, pImgAnimState, dwFlags);
goto Cleanup;
}
}
// Otherwise just tile the slow way (it may still decide to pretile)
TileSlow(hdc, prc, pptOrg->x, pptOrg->y, psizePrint, fOpaque, crBack, pImgAnimState, dwFlags);
Cleanup:
;
}
void Control::OnEraseBackground(HDC bHDC) {
// Set brush to desired background color
HBRUSH backBrush = CreateSolidBrush(colBackground);
// Save old brush
HBRUSH pOldBrush = (HBRUSH)SelectObject(bHDC, backBrush);
RECT rect;
GetClipBox(bHDC, &rect); // Erase the area needed
PatBlt(bHDC, rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, PATCOPY);
SelectObject(bHDC, pOldBrush);
}
/***********************************************************************
* EnumDisplayMonitors (USER32.@)
*/
BOOL WINAPI EnumDisplayMonitors(
HDC hdcOptionalForPainting,
LPRECT lprcEnumMonitorsThatIntersect,
MONITORENUMPROC lpfnEnumProc,
LPARAM dwData)
{
RECT rcLimit;
SetRect( &rcLimit, 0, 0, GetSystemMetrics(SM_CXSCREEN),
GetSystemMetrics(SM_CYSCREEN) );
if (!lpfnEnumProc)
return FALSE;
if (hdcOptionalForPainting)
{
RECT rcClip;
POINT ptOrg;
switch (GetClipBox(hdcOptionalForPainting, &rcClip))
{
default:
if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
return FALSE;
OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
(!lprcEnumMonitorsThatIntersect ||
IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {
break;
}
/* fall through */
case NULLREGION:
return TRUE;
case ERROR:
return FALSE;
}
} else {
if ( lprcEnumMonitorsThatIntersect &&
!IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {
return TRUE;
}
}
return lpfnEnumProc(
xPRIMARY_MONITOR,
hdcOptionalForPainting,
&rcLimit,
dwData);
}
void NWindow::Draw(HDC hDc)
{
GUARD_SCOPE(false, _T("NWindow Draw takes too long"));
Base::NRect clientRect;
::GetClientRect(window_, clientRect);
render_->Init(hDc, clientRect);
Base::NRect clipRect;
int nResult = GetClipBox(hDc, clipRect);
if(nResult == NULLREGION)
::GetClientRect(window_, clipRect);
OnDraw(render_, clipRect);
render_->DrawBack(IsLayered());
}
/******************************************************************************
* ExtSelectClipRgn [GDI32.@]
*/
INT WINAPI ExtSelectClipRgn( HDC hdc, HRGN hrgn, INT fnMode )
{
INT retval;
RECT rect;
DC * dc = get_dc_ptr( hdc );
if (!dc) return ERROR;
TRACE("%p %p %d\n", hdc, hrgn, fnMode );
update_dc( dc );
if (dc->funcs->pExtSelectClipRgn)
{
retval = dc->funcs->pExtSelectClipRgn( dc->physDev, hrgn, fnMode );
release_dc_ptr( dc );
return retval;
}
if (!hrgn)
{
if (fnMode == RGN_COPY)
{
if (dc->hClipRgn) DeleteObject( dc->hClipRgn );
dc->hClipRgn = 0;
}
else
{
FIXME("Unimplemented: hrgn NULL in mode: %d\n", fnMode);
release_dc_ptr( dc );
return ERROR;
}
}
else
{
if (!dc->hClipRgn)
create_default_clip_region( dc );
if(fnMode == RGN_COPY)
CombineRgn( dc->hClipRgn, hrgn, 0, fnMode );
else
CombineRgn( dc->hClipRgn, dc->hClipRgn, hrgn, fnMode);
}
CLIPPING_UpdateGCRegion( dc );
release_dc_ptr( dc );
return GetClipBox(hdc, &rect);
}
// Draw cubes from cube point list for a given object id
DllExport int FAR PASCAL VBDrawObjecthDC(HDC hDC, int ObjectTypeID)
{
//RECT r;
//GetClipBox(hDC, &r);
// Height should be set by drawing program!
//CubeObject.Transform.Height = r.bottom - r.top;
RECT r;
VectorType SliceVectorMin, SliceVectorMax;
GetClipBox(hDC, &r);
// Height should be set by drawing program!
CubeObject.Transform.Height = r.bottom - r.top;
//CubeObject.SetOrigin( 100, 100, 0); // modified 09/04/96 to take account of presetting of origin
//CubeObject.SetScale( 2, 2 );
// Set the visibe slice through object
SliceVectorMin.x = -100;
SliceVectorMin.y = -100;
SliceVectorMin.z = -100;
SliceVectorMax.x = 100;
SliceVectorMax.y = 100;
SliceVectorMax.z = 100;
// Colour should be set by the drawing program!
// But we don't need to do it here because drawing program has such
// functionality built in.
//CubeObject.DrawCreateWalker(3);
CubeObject.SetSliceVector(&SliceVectorMin, &SliceVectorMax);
CubeObject.DrawObjecthDC(hDC, ObjectTypeID);
return 0;
}
DWORD
lsd_display_extfloodfill(WORD msg, HDC32 hDC32, DWORD dwParam,
LPLSDS_PARAMS lpStruct)
{
HDC hDC = GETHDC16(hDC32);
RECT rc;
if (hDC32->dwInvalid & (IM_BRUSHMASK|IM_ROP2MASK))
DisplayValidate(hDC32, lpStruct, IM_BRUSHMASK|IM_ROP2MASK);
GetClipBox(hDC, &rc);
LPtoDP(hDC,(LPPOINT)&rc,2);
/* For child windows, LPtoDP does not take into account DOx/DOy; */
/* we need here actual position in the physical GC -- Lana K. */
OffsetRect(&rc,hDC32->DOx,hDC32->DOy);
return DRVCALL_GRAPHICS(PGH_FLOODFILL,hDC32->lpDrvData,&rc,lpStruct);
}
/* This method renders the appropriate frame of the attached animated GIF if
present. If sufficient time has not yet gone by to warrent drawing the next
frame of the animation, this will re-render the current frame.
Returns : IP_ANIMATION_COMPLETE if the final frame has been rendered and the
loop count has expired.
IP_ANIMATION_CONTINUES if there are further frames to be rendered.
*/
UINT CPicturePreview::Update(LPDRAWITEMSTRUCT lpDrawItemStruct)
{
// Find enclosing bounds for isolating objects
if (GetPreviewWnd() == NULL)
{
// can not continue.
return IP_ANIMATION_COMPLETE;
}
// If we are totally clipped, skip it.
RECT r;
if (GetClipBox(lpDrawItemStruct->hDC, &r) == NULLREGION)
{
return IP_ANIMATION_CONTINUES; // We can continue, we just don't need an update.
}
// Draw a nice frame around our image
if (!m_fEncloseObjects)
{
DrawFrame(lpDrawItemStruct->hDC);
}
// Create a CDC from the draw item structure that the GIF animator can use
// to render the current frame for us.
CDC dcView;
dcView.Attach( lpDrawItemStruct->hDC );
// Have the GIF animator render the current frame.
UINT uContinuationCode;
if (m_pGIFAnimator->Update( &dcView, m_crPreview ))
{
uContinuationCode = IP_ANIMATION_CONTINUES;
}
else
{
uContinuationCode = IP_ANIMATION_COMPLETE;
}
// Release the Device.
dcView.Detach();
return uContinuationCode;
}
DllExport int FAR PASCAL VBCubeArrayDraw(HDC hDC, int N)
{
int j;
//Cube CubeObject;
RECT r;
GetClipBox(hDC, &r);
// Height should be set by drawing program
CubeObject.Transform.Height = r.bottom - r.top;
CubeObject.SetOrigin( 100, 100, 0);
CubeObject.SetScale( 2, 2 );
j=N;
if(j<1)
j=1;
// Colour should be set by the drawing program!
HPEN NewPen = CreatePen(PS_SOLID, 0, RGB(0,0,255)); // create blue pen color
HBRUSH NewBrush = CreateSolidBrush(RGB(255,255,255)); // create brush (white)
HGDIOBJ OldPen = GetCurrentObject(hDC, OBJ_PEN); // remember old colour
HGDIOBJ OldBrush = GetCurrentObject(hDC, OBJ_BRUSH); // remember old brush
// Set colours
SelectObject(hDC, NewPen);
SelectObject(hDC, NewBrush);
CubeObject.DrawNCubehDC(hDC, j);
// Return Colours
SelectObject(hDC, OldPen);
SelectObject(hDC, OldBrush);
// Delete all unnecessary objects
DeleteObject(NewPen);
DeleteObject(NewBrush);
return j;
}
void CUpdateBoxHook::DisplayHookProc(HWND hWnd, HDC hDC, LPRECT lpRect)
/************************************************************************/
{
HRGN hrgnClip;
RECT rOld;
GetClipBox(hDC, &rOld);
if (lpRect)
hrgnClip = CreateRectRgn(lpRect->left,
lpRect->top,
lpRect->right+1,
lpRect->bottom+1);
else
hrgnClip = NULL; // select entire image
SelectClipRgn(hDC, hrgnClip);
DrawBox(hWnd, hDC);
DeleteObject(hrgnClip);
hrgnClip = CreateRectRgnIndirect(&rOld);
SelectClipRgn(hDC, hrgnClip);
DeleteObject(hrgnClip);
}
void WinDonePicture (OSPictContext context)
{
if (context->hBufferedDC)
{
RECT clipRect;
if (GetClipBox(context->hBufferedDC,&clipRect) == ERROR)
{
printf("osInitPicture -> GetClipBox failed\n");
exit(1);
}
if (!BitBlt(context->hBufferedDC, clipRect.left, clipRect.top, clipRect.right-clipRect.left, clipRect.bottom-clipRect.top, context->hDC, clipRect.left, clipRect.top, SRCCOPY))
{
printf("osDonePicture -> BitBlt failed\n");
exit(1);
}
DeleteDC(context->hDC);
context->hDC = context->hBufferedDC;
context->hBufferedDC = NULL;
DeleteObject(context->hBufferBitmap);
context->hBufferBitmap = NULL;
}
RestoreDC (context->hDC, -1);
DeleteObject (context->theNormalPen);
DeleteObject (context->theBackPen);
DeleteObject (context->theNormalBrush);
DeleteObject (context->theBackBrush);
DeleteObject (context->theFont);
if (ghCaretWnd)
{
int mess, p1, p2, p3, p4, p5, p6;
WinKickOsThread (CcRqSHOWCARET, (int) ghCaretWnd, 0, 0, 0, 0, 0,
&mess, &p1, &p2, &p3, &p4, &p5, &p6);
}
} /* WinDonePicture */
void CWebWindow::_paintDC(HDC hdc, HDC sourceDC)
{
//InvalidateRect(m_hwnd, NULL, FALSE);
//HDC hdc = GetDC(m_hwnd);
RECT rcClip;
GetClipBox(hdc, &rcClip);
RECT rcClient;
GetClientRect(m_hwnd, &rcClient);
RECT rcInvalid;
IntersectRect(&rcInvalid, &rcClip,&rcClient);
int srcX = rcInvalid.left - rcClient.left;
int srcY = rcInvalid.top - rcClient.top;
int destX = rcInvalid.left;
int destY = rcInvalid.top;
int width = rcInvalid.right - rcInvalid.left;
int height = rcInvalid.bottom - rcInvalid.top;
BitBlt(hdc, destX, destY, width, height, sourceDC, srcX, srcY, SRCCOPY);
//ReleaseDC(m_hwnd, hdc);
}
static void doSaver (HWND hwndParent)
{
HDC hdc;
MSG msg;
HWND hwnd;
WNDCLASS cls;
HANDLE hOther;
RECT rcParent;
int nx, ny, cx, cy;
PSTR pszWindowTitle;
UINT uExStyle, uStyle;
// Define screensaver¡¯s window class.
cls.style = CS_OWNDC | CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW;
cls.lpfnWndProc = (WNDPROC) RealScreenSaverProc;
cls.cbClsExtra = 0;
cls.cbWndExtra = 0;
cls.hInstance = g_hinstance;
cls.hIcon = LoadIcon (g_hinstance, MAKEINTRESOURCE(ID_APP));
cls.hCursor = NULL;
cls.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
cls.lpszMenuName = NULL;
cls.lpszClassName = g_szClassName;
// If hwndParent is not NULL, we are running in preview mode. Otherwise, we
// are running in saver mode.
if (hwndParent != NULL)
{
// Specify appropriate title for preview mode screensaver window.
pszWindowTitle = "Preview";
// Get the parent window rectangle.
GetClientRect (hwndParent, &rcParent);
// Compute width and position information for preview window, relative to
// the parent window.
cx = rcParent.right;
cy = rcParent.bottom;
nx = 0;
ny = 0;
// No extended style required for preview window, which is a child of its
// non-desktop parent window.
uExStyle = 0;
// Set the preview window style -- child window, visible, exclude the
// area occupied by child windows when drawing in parent window.
uStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN;
}
else
{
// Specify appropriate title for saver mode screensaver window.
pszWindowTitle = "Screen Saver";
// Search for existing screensaver window.
hOther = FindWindow (g_szClassName, pszWindowTitle);
// If this window exists, make it the foreground window and return. We
// don¡¯t execute more than one screensaver at the same time. What would
// be the point of doing that?
if (hOther != NULL && IsWindow ((HWND) hOther))
{
SetForegroundWindow (hOther);
return;
}
// Get the desktop window rectangle.
hdc = GetDC (HWND_DESKTOP);
GetClipBox (hdc, &rcParent);
ReleaseDC (HWND_DESKTOP, hdc);
// Compute width and position information for screensaver window,
// relative to the desktop window -- the entire screen.
cx = rcParent.right - rcParent.left;
cy = rcParent.bottom - rcParent.top;
nx = rcParent.left;
ny = rcParent.top;
// The screensaver window occupies the entire screen and must be the
// topmost window -- no other window can be located on top of the
// screensaver window.
uExStyle = WS_EX_TOPMOST;
// Set the screensaver window style -- popup, visible, exclude the area
// occupied by child windows when drawing in parent window, clip child
// windows relative to each other.
uStyle = WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
}
// Attempt to register the screensaver¡¯s window class.
if (!RegisterClass (&cls))
return;
if (g_fOnWin95)
{
// Load the password DLL (found in password.cpl -- a DLL with a .cpl
// file extension.
loadPwdDLL ();
// Register the QueryCancelAutoPlay message with Windows.
uShellMessage = RegisterWindowMessage ("QueryCancelAutoPlay");
}
// Disable the Alt+Tab, Ctrl+Alt+Delete, and Windows keys.
hogMachine (TRUE);
// Create either preview mode or saver mode screensaver window.
hwnd = CreateWindowEx (uExStyle, g_szClassName, pszWindowTitle, uStyle,
nx, ny, cx, cy, hwndParent, NULL, g_hinstance, NULL);
// If we were successful ...
if (hwnd)
{
// Either a preview window or a window occupying the entire desktop has
// been created. In the latter case, make that window the foreground
// window. Nothing can supersede a window occuping the entire desktop.
if (g_scrmode != smPreview)
SetForegroundWindow (hwnd);
// Enter the screensaver¡¯s message loop. Loop ends when
// RealScreenSaverProc() responds to the WM_DESTROY message by calling
// PostQuitMessage (0).
while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg);
DispatchMessage (&msg);
}
}
// Enable the Alt+Tab, Ctrl+Alt+Delete, and Windows keys.
hogMachine (FALSE);
if (g_fOnWin95)
{
// Unload the password DLL.
unloadPwdDLL ();
}
}
/*************************************************************************
* ScrollDC (X11DRV.@)
*/
BOOL X11DRV_ScrollDC( HDC hdc, INT dx, INT dy, const RECT *lprcScroll,
const RECT *lprcClip, HRGN hrgnUpdate, LPRECT lprcUpdate )
{
RECT rcSrc, rcClip, offset;
INT dxdev, dydev, res;
HRGN DstRgn, clipRgn, visrgn;
INT code = X11DRV_START_EXPOSURES;
TRACE("dx,dy %d,%d rcScroll %s rcClip %s hrgnUpdate %p lprcUpdate %p\n",
dx, dy, wine_dbgstr_rect(lprcScroll), wine_dbgstr_rect(lprcClip),
hrgnUpdate, lprcUpdate);
/* enable X-exposure events */
if (hrgnUpdate || lprcUpdate)
ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code, 0, NULL );
/* get the visible region */
visrgn=CreateRectRgn( 0, 0, 0, 0);
GetRandomRgn( hdc, visrgn, SYSRGN);
if( !(GetVersion() & 0x80000000)) {
/* Window NT/2k/XP */
POINT org;
GetDCOrgEx(hdc, &org);
OffsetRgn( visrgn, -org.x, -org.y);
}
/* intersect with the clipping Region if the DC has one */
clipRgn = CreateRectRgn( 0, 0, 0, 0);
if (GetClipRgn( hdc, clipRgn) != 1) {
DeleteObject(clipRgn);
clipRgn=NULL;
} else
CombineRgn( visrgn, visrgn, clipRgn, RGN_AND);
/* only those pixels in the scroll rectangle that remain in the clipping
* rect are scrolled. */
if( lprcClip)
rcClip = *lprcClip;
else
GetClipBox( hdc, &rcClip);
rcSrc = rcClip;
OffsetRect( &rcClip, -dx, -dy);
IntersectRect( &rcSrc, &rcSrc, &rcClip);
/* if an scroll rectangle is specified, only the pixels within that
* rectangle are scrolled */
if( lprcScroll)
IntersectRect( &rcSrc, &rcSrc, lprcScroll);
/* now convert to device coordinates */
LPtoDP(hdc, (LPPOINT)&rcSrc, 2);
TRACE("source rect: %s\n", wine_dbgstr_rect(&rcSrc));
/* also dx and dy */
SetRect(&offset, 0, 0, dx, dy);
LPtoDP(hdc, (LPPOINT)&offset, 2);
dxdev = offset.right - offset.left;
dydev = offset.bottom - offset.top;
/* now intersect with the visible region to get the pixels that will
* actually scroll */
DstRgn = CreateRectRgnIndirect( &rcSrc);
res = CombineRgn( DstRgn, DstRgn, visrgn, RGN_AND);
/* and translate, giving the destination region */
OffsetRgn( DstRgn, dxdev, dydev);
if( TRACE_ON( scroll)) dump_region( "Destination scroll region: ", DstRgn);
/* if there are any, do it */
if( res > NULLREGION) {
RECT rect ;
/* clip to the destination region, so we can BitBlt with a simple
* bounding rectangle */
if( clipRgn)
ExtSelectClipRgn( hdc, DstRgn, RGN_AND);
else
SelectClipRgn( hdc, DstRgn);
GetRgnBox( DstRgn, &rect);
DPtoLP(hdc, (LPPOINT)&rect, 2);
TRACE("destination rect: %s\n", wine_dbgstr_rect(&rect));
BitBlt( hdc, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
hdc, rect.left - dx, rect.top - dy, SRCCOPY);
}
/* compute the update areas. This is the combined clip rectangle
* minus the scrolled region, and intersected with the visible
* region. */
if (hrgnUpdate || lprcUpdate)
{
HRGN hrgn = hrgnUpdate;
HRGN ExpRgn = 0;
/* collect all the exposures */
code = X11DRV_END_EXPOSURES;
ExtEscape( hdc, X11DRV_ESCAPE, sizeof(code), (LPSTR)&code,
sizeof(ExpRgn), (LPSTR)&ExpRgn );
/* Intersect clip and scroll rectangles, allowing NULL values */
if( lprcScroll)
if( lprcClip)
IntersectRect( &rcClip, lprcClip, lprcScroll);
else
rcClip = *lprcScroll;
else if( lprcClip)
rcClip = *lprcClip;
else
GetClipBox( hdc, &rcClip);
/* Convert the combined clip rectangle to device coordinates */
LPtoDP(hdc, (LPPOINT)&rcClip, 2);
if( hrgn )
SetRectRgn( hrgn, rcClip.left, rcClip.top, rcClip.right,
rcClip.bottom);
else
hrgn = CreateRectRgnIndirect( &rcClip);
CombineRgn( hrgn, hrgn, visrgn, RGN_AND);
CombineRgn( hrgn, hrgn, DstRgn, RGN_DIFF);
/* add the exposures to this */
if( ExpRgn) {
if( TRACE_ON( scroll)) dump_region( "Expose region: ", ExpRgn);
CombineRgn( hrgn, hrgn, ExpRgn, RGN_OR);
DeleteObject( ExpRgn);
}
if( TRACE_ON( scroll)) dump_region( "Update region: ", hrgn);
if( lprcUpdate) {
GetRgnBox( hrgn, lprcUpdate );
/* Put the lprcUpdate in logical coordinates */
DPtoLP( hdc, (LPPOINT)lprcUpdate, 2 );
TRACE("returning lprcUpdate %s\n", wine_dbgstr_rect(lprcUpdate));
}
if( !hrgnUpdate)
DeleteObject( hrgn);
}
/* restore original clipping region */
SelectClipRgn( hdc, clipRgn);
DeleteObject( visrgn);
DeleteObject( DstRgn);
if( clipRgn) DeleteObject( clipRgn);
return TRUE;
}
static void test_savedc_2(void)
{
HWND hwnd;
HDC hdc;
HRGN hrgn;
RECT rc, rc_clip;
int ret;
hwnd = CreateWindowExA(0, "static", "", WS_POPUP, 0,0,100,100,
0, 0, 0, NULL);
assert(hwnd != 0);
ShowWindow(hwnd, SW_SHOW);
UpdateWindow(hwnd);
hrgn = CreateRectRgn(0, 0, 0, 0);
assert(hrgn != 0);
hdc = GetDC(hwnd);
ok(hdc != NULL, "GetDC failed\n");
ret = GetClipBox(hdc, &rc_clip);
ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret);
ret = GetClipRgn(hdc, hrgn);
ok(ret == 0, "GetClipRgn returned %d instead of 0\n", ret);
ret = GetRgnBox(hrgn, &rc);
ok(ret == NULLREGION, "GetRgnBox returned %d (%d,%d-%d,%d) instead of NULLREGION\n",
ret, rc.left, rc.top, rc.right, rc.bottom);
/*dump_region(hrgn);*/
SetRect(&rc, 0, 0, 100, 100);
ok(EqualRect(&rc, &rc_clip),
"rects are not equal: (%d,%d-%d,%d) - (%d,%d-%d,%d)\n",
rc.left, rc.top, rc.right, rc.bottom,
rc_clip.left, rc_clip.top, rc_clip.right, rc_clip.bottom);
ret = SaveDC(hdc);
todo_wine
{
ok(ret == 1, "ret = %d\n", ret);
}
ret = IntersectClipRect(hdc, 0, 0, 50, 50);
if (ret == COMPLEXREGION)
{
/* XP returns COMPLEXREGION although dump_region reports only 1 rect */
trace("Windows BUG: IntersectClipRect returned %d instead of SIMPLEREGION\n", ret);
/* let's make sure that it's a simple region */
ret = GetClipRgn(hdc, hrgn);
ok(ret == 1, "GetClipRgn returned %d instead of 1\n", ret);
dump_region(hrgn);
}
else
ok(ret == SIMPLEREGION, "IntersectClipRect returned %d instead of SIMPLEREGION\n", ret);
ret = GetClipBox(hdc, &rc_clip);
ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret);
SetRect(&rc, 0, 0, 50, 50);
ok(EqualRect(&rc, &rc_clip), "rects are not equal\n");
ret = RestoreDC(hdc, 1);
ok(ret, "ret = %d\n", ret);
ret = GetClipBox(hdc, &rc_clip);
ok(ret == SIMPLEREGION, "GetClipBox returned %d instead of SIMPLEREGION\n", ret);
SetRect(&rc, 0, 0, 100, 100);
ok(EqualRect(&rc, &rc_clip), "rects are not equal\n");
DeleteObject(hrgn);
ReleaseDC(hwnd, hdc);
DestroyWindow(hwnd);
}
// Process window messages
LRESULT CALLBACK Flasher::WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) {
// This is a static method, so we don't know which instantiation we're
// dealing with. We use Allen Hadden's ([email protected]) suggestion
// from a newsgroup to get the pseudo-this.
Flasher *_this = helper::SafeGetWindowUserData<Flasher>(hwnd);
switch (iMsg) {
case WM_CREATE:
return 0;
case WM_SOCKEVENT:
{
assert(HIWORD(lParam) == 0);
// A new socket created by accept might send messages to
// this procedure. We can ignore them.
if(wParam != _this->m_sock) {
return 0;
}
switch(lParam) {
case FD_ACCEPT:
{
SOCKET hNewSock;
char username[256];
hNewSock = accept(_this->m_sock, NULL, NULL);
// make it blocking
WSAAsyncSelect(hNewSock, hwnd, 0, 0);
u_long blk = 0;
int res = ioctlsocket(hNewSock, FIONBIO, &blk);
assert(res == 0);
CloseScreenSaver();
// Se if the server's sending a user name
int namelen = recv(hNewSock, username, 250, 0);
if (namelen >= 0)
username[namelen] = 0;
vnclog.Print(2, _T("Flash for '%s'\n"), username);
closesocket(hNewSock);
// flash
// Get a DC for the root window
HDC hrootdc = ::GetDC(NULL);
HBRUSH holdbrush = (HBRUSH) SelectObject(hrootdc,
(HBRUSH) GetStockObject(BLACK_BRUSH));
// Find the size.
RECT rect;
GetClipBox(hrootdc, &rect);
int barwidth = (rect.right - rect.left) / 10;
int barheight = max(
(rect.bottom - rect.top) / 10,
FLASHFONTHEIGHT);
HFONT oldfont = (HFONT) SelectObject(hrootdc, _this->m_hfont);
// Flash the screen
::Beep(440,50);
Rectangle(hrootdc, rect.left, rect.top,
rect.right, barheight);
Rectangle(hrootdc, rect.left, rect.bottom-barheight,
rect.right, rect.bottom);
Rectangle(hrootdc, rect.left, rect.top+barheight,
barwidth, rect.bottom-barheight);
Rectangle(hrootdc, rect.right-barwidth, rect.top+barheight,
rect.right, rect.bottom-barheight);
RECT topbar;
SetRect(&topbar, rect.left, rect.top,
rect.right, barheight);
int i = 0;
if (namelen > 0) {
int oldmode = SetBkMode(hrootdc, TRANSPARENT);
COLORREF oldcolor = SetTextColor(hrootdc,
RGB(scalechar(username[0])/(i+1), scalechar(username[1])/(i+1), scalechar(username[2])/(i+1)));
DrawText(hrootdc, username, -1, &topbar, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
SetTextColor(hrootdc, oldcolor);
SetBkMode(hrootdc, oldmode);
}
GdiFlush();
SelectObject(hrootdc, holdbrush);
::Sleep(1000);
SelectObject(hrootdc, oldfont);
InvalidateRect(0, &rect, TRUE);
::ReleaseDC(NULL, hrootdc);
break;
}
case FD_CLOSE:
vnclog.Print(2, _T("Flasher connection closed\n"));
DestroyWindow(hwnd);
break;
}
return 0;
}
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
static void TreeCtrlOnPaint(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hDC;
RECT rcClip, rcClient;
HDC memDC;
HBITMAP bitmap;
HBITMAP hOldBitmap;
HBITMAP hBackground = GetBackgroundBitmap();
MYBITMAPINFO *bmDesc = GetBackgroundInfo();
hDC = BeginPaint(hWnd, &ps);
GetClipBox(hDC, &rcClip);
GetClientRect(hWnd, &rcClient);
// Create a compatible memory DC
memDC = CreateCompatibleDC(hDC);
// Select a compatible bitmap into the memory DC
bitmap = CreateCompatibleBitmap(hDC, rcClient.right - rcClient.left,
rcClient.bottom - rcClient.top);
hOldBitmap = SelectObject(memDC, bitmap);
// First let the control do its default drawing.
CallWindowProc(g_lpTreeWndProc, hWnd, uMsg, (WPARAM)memDC, 0);
// Draw bitmap in the background
{
HPALETTE hPAL;
HDC maskDC;
HBITMAP maskBitmap;
HDC tempDC;
HDC imageDC;
HBITMAP bmpImage;
HBITMAP hOldBmpImage;
HBITMAP hOldMaskBitmap;
HBITMAP hOldHBitmap;
int i, j;
RECT rcRoot;
// Now create a mask
maskDC = CreateCompatibleDC(hDC);
// Create monochrome bitmap for the mask
maskBitmap = CreateBitmap(rcClient.right - rcClient.left,
rcClient.bottom - rcClient.top,
1, 1, NULL);
hOldMaskBitmap = SelectObject(maskDC, maskBitmap);
SetBkColor(memDC, GetSysColor(COLOR_WINDOW));
// Create the mask from the memory DC
BitBlt(maskDC, 0, 0, rcClient.right - rcClient.left,
rcClient.bottom - rcClient.top, memDC,
rcClient.left, rcClient.top, SRCCOPY);
tempDC = CreateCompatibleDC(hDC);
hOldHBitmap = SelectObject(tempDC, hBackground);
imageDC = CreateCompatibleDC(hDC);
bmpImage = CreateCompatibleBitmap(hDC,
rcClient.right - rcClient.left,
rcClient.bottom - rcClient.top);
hOldBmpImage = SelectObject(imageDC, bmpImage);
hPAL = GetBackgroundPalette();
if (hPAL == NULL)
hPAL = CreateHalftonePalette(hDC);
if (GetDeviceCaps(hDC, RASTERCAPS) & RC_PALETTE && hPAL != NULL)
{
SelectPalette(hDC, hPAL, FALSE);
RealizePalette(hDC);
SelectPalette(imageDC, hPAL, FALSE);
}
// Get x and y offset
TreeView_GetItemRect(hWnd, TreeView_GetRoot(hWnd), &rcRoot, FALSE);
rcRoot.left = -GetScrollPos(hWnd, SB_HORZ);
// Draw bitmap in tiled manner to imageDC
for (i = rcRoot.left; i < rcClient.right; i += bmDesc->bmWidth)
for (j = rcRoot.top; j < rcClient.bottom; j += bmDesc->bmHeight)
BitBlt(imageDC, i, j, bmDesc->bmWidth, bmDesc->bmHeight,
tempDC, 0, 0, SRCCOPY);
// Set the background in memDC to black. Using SRCPAINT with black and any other
// color results in the other color, thus making black the transparent color
SetBkColor(memDC, RGB(0,0,0));
SetTextColor(memDC, RGB(255,255,255));
BitBlt(memDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left,
rcClip.bottom - rcClip.top,
maskDC, rcClip.left, rcClip.top, SRCAND);
// Set the foreground to black. See comment above.
SetBkColor(imageDC, RGB(255,255,255));
SetTextColor(imageDC, RGB(0,0,0));
BitBlt(imageDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left,
rcClip.bottom - rcClip.top,
maskDC, rcClip.left, rcClip.top, SRCAND);
// Combine the foreground with the background
BitBlt(imageDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left,
rcClip.bottom - rcClip.top,
memDC, rcClip.left, rcClip.top, SRCPAINT);
// Draw the final image to the screen
BitBlt(hDC, rcClip.left, rcClip.top, rcClip.right - rcClip.left,
rcClip.bottom - rcClip.top,
imageDC, rcClip.left, rcClip.top, SRCCOPY);
SelectObject(maskDC, hOldMaskBitmap);
SelectObject(tempDC, hOldHBitmap);
SelectObject(imageDC, hOldBmpImage);
DeleteDC(maskDC);
DeleteDC(imageDC);
DeleteDC(tempDC);
DeleteObject(bmpImage);
DeleteObject(maskBitmap);
if (GetBackgroundPalette() == NULL)
{
DeleteObject(hPAL);
hPAL = 0;
}
}
SelectObject(memDC, hOldBitmap);
DeleteObject(bitmap);
DeleteDC(memDC);
EndPaint(hWnd, &ps);
ReleaseDC(hWnd, hDC);
}
void CDC::DrawDragRect(LPCRECT lpRect, SIZE size,
LPCRECT lpRectLast, SIZE sizeLast, CBrush* pBrush, CBrush* pBrushLast)
{
ASSERT(AfxIsValidAddress(lpRect, sizeof(RECT), FALSE));
ASSERT(lpRectLast == NULL ||
AfxIsValidAddress(lpRectLast, sizeof(RECT), FALSE));
// first, determine the update region and select it
CRgn rgnNew;
CRgn rgnOutside, rgnInside;
rgnOutside.CreateRectRgnIndirect(lpRect);
CRect rect = *lpRect;
rect.InflateRect(-size.cx, -size.cy);
rect.IntersectRect(rect, lpRect);
rgnInside.CreateRectRgnIndirect(rect);
rgnNew.CreateRectRgn(0, 0, 0, 0);
rgnNew.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);
CBrush* pBrushOld = NULL;
if (pBrush == NULL)
pBrush = CDC::GetHalftoneBrush();
if (pBrushLast == NULL)
pBrushLast = pBrush;
CRgn rgnLast, rgnUpdate;
if (lpRectLast != NULL)
{
// find difference between new region and old region
rgnLast.CreateRectRgn(0, 0, 0, 0);
rgnOutside.SetRectRgn(lpRectLast);
rect = *lpRectLast;
rect.InflateRect(-sizeLast.cx, -sizeLast.cy);
rect.IntersectRect(rect, lpRectLast);
rgnInside.SetRectRgn(rect);
rgnLast.CombineRgn(&rgnOutside, &rgnInside, RGN_XOR);
// only diff them if brushes are the same
if (pBrush->m_hObject == pBrushLast->m_hObject)
{
rgnUpdate.CreateRectRgn(0, 0, 0, 0);
rgnUpdate.CombineRgn(&rgnLast, &rgnNew, RGN_XOR);
}
}
if (pBrush->m_hObject != pBrushLast->m_hObject && lpRectLast != NULL)
{
// brushes are different -- erase old region first
SelectClipRgn(&rgnLast);
GetClipBox(&rect);
pBrushOld = SelectObject(pBrushLast);
PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
SelectObject(pBrushOld);
pBrushOld = NULL;
}
// draw into the update/new region
SelectClipRgn(rgnUpdate.m_hObject != NULL ? &rgnUpdate : &rgnNew);
GetClipBox(&rect);
pBrushOld = SelectObject(pBrush);
PatBlt(rect.left, rect.top, rect.Width(), rect.Height(), PATINVERT);
// cleanup DC
if (pBrushOld != NULL)
SelectObject(pBrushOld);
SelectClipRgn(NULL);
}
static void test_dc_layout(void)
{
INT ret, size_cx, size_cy, res_x, res_y, dpi_x, dpi_y;
SIZE size;
POINT pt;
HBITMAP bitmap;
RECT rc, ret_rc;
HDC hdc;
HRGN hrgn;
if (!pGetLayout || !pSetLayout)
{
win_skip( "Don't have SetLayout\n" );
return;
}
hdc = CreateCompatibleDC(0);
bitmap = CreateCompatibleBitmap( hdc, 100, 100 );
SelectObject( hdc, bitmap );
size_cx = GetDeviceCaps(hdc, HORZSIZE);
size_cy = GetDeviceCaps(hdc, VERTSIZE);
res_x = GetDeviceCaps(hdc, HORZRES);
res_y = GetDeviceCaps(hdc, VERTRES);
dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
ret = GetMapMode( hdc );
ok(ret == MM_TEXT, "expected MM_TEXT, got %d\n", ret);
expect_viewport_ext(hdc, 1, 1);
expect_window_ext(hdc, 1, 1);
expect_world_transform(hdc, 1.0, 1.0);
expect_LPtoDP(hdc, 1000, 1000);
pSetLayout( hdc, LAYOUT_RTL );
if (!pGetLayout( hdc ))
{
win_skip( "SetLayout not supported\n" );
DeleteDC(hdc);
return;
}
ret = GetMapMode( hdc );
ok(ret == MM_ANISOTROPIC, "expected MM_ANISOTROPIC, got %d\n", ret);
expect_viewport_ext(hdc, 1, 1);
expect_window_ext(hdc, 1, 1);
expect_world_transform(hdc, 1.0, 1.0);
expect_LPtoDP(hdc, -1000 + 99, 1000);
GetViewportOrgEx( hdc, &pt );
ok( pt.x == 0 && pt.y == 0, "wrong origin %d,%d\n", pt.x, pt.y );
GetWindowOrgEx( hdc, &pt );
ok( pt.x == 0 && pt.y == 0, "wrong origin %d,%d\n", pt.x, pt.y );
GetDCOrgEx( hdc, &pt );
ok( pt.x == 0 && pt.y == 0, "wrong origin %d,%d\n", pt.x, pt.y );
if (pGetTransform)
{
XFORM xform;
BOOL ret = pGetTransform( hdc, 0x204, &xform ); /* World -> Device */
ok( ret, "got %d\n", ret );
ok( xform.eM11 == -1.0, "got %f\n", xform.eM11 );
ok( xform.eM12 == 0.0, "got %f\n", xform.eM12 );
ok( xform.eM21 == 0.0, "got %f\n", xform.eM21 );
ok( xform.eM22 == 1.0, "got %f\n", xform.eM22 );
ok( xform.eDx == 99.0, "got %f\n", xform.eDx );
ok( xform.eDy == 0.0, "got %f\n", xform.eDy );
}
SetRect( &rc, 10, 10, 20, 20 );
IntersectClipRect( hdc, 10, 10, 20, 20 );
hrgn = CreateRectRgn( 0, 0, 0, 0 );
GetClipRgn( hdc, hrgn );
GetRgnBox( hrgn, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
pSetLayout( hdc, LAYOUT_LTR );
SetRect( &rc, 80, 10, 90, 20 );
GetClipRgn( hdc, hrgn );
GetRgnBox( hrgn, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
GetClipBox( hdc, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
IntersectClipRect( hdc, 80, 10, 85, 20 );
pSetLayout( hdc, LAYOUT_RTL );
SetRect( &rc, 15, 10, 20, 20 );
GetClipRgn( hdc, hrgn );
GetRgnBox( hrgn, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
GetClipBox( hdc, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
SetRectRgn( hrgn, 60, 10, 80, 20 );
pSetLayout( hdc, LAYOUT_LTR );
ExtSelectClipRgn( hdc, hrgn, RGN_OR );
pSetLayout( hdc, LAYOUT_RTL );
SetRect( &rc, 15, 10, 40, 20 );
GetClipRgn( hdc, hrgn );
GetRgnBox( hrgn, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
GetClipBox( hdc, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
/* OffsetClipRgn mirrors too */
OffsetClipRgn( hdc, 5, 5 );
OffsetRect( &rc, 5, 5 );
GetClipRgn( hdc, hrgn );
GetRgnBox( hrgn, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
/* GetRandomRgn returns the raw region */
if (pGetRandomRgn)
{
SetRect( &rc, 55, 15, 80, 25 );
pGetRandomRgn( hdc, hrgn, 1 );
GetRgnBox( hrgn, &ret_rc );
ok( EqualRect( &rc, &ret_rc ), "wrong clip box %d,%d - %d,%d\n",
ret_rc.left, ret_rc.top, ret_rc.right, ret_rc.bottom );
}
SetMapMode(hdc, MM_LOMETRIC);
ret = GetMapMode( hdc );
ok(ret == MM_ANISOTROPIC, "expected MM_ANISOTROPIC, got %d\n", ret);
expect_viewport_ext(hdc, res_x, -res_y);
ok( GetWindowExtEx( hdc, &size ), "GetWindowExtEx failed\n" );
ok( rough_match( size.cx, size_cx * 10 ) ||
rough_match( size.cx, MulDiv( res_x, 254, dpi_x )), /* Vista uses a more precise method */
"expected cx %d or %d, got %d\n", size_cx * 10, MulDiv( res_x, 254, dpi_x ), size.cx );
ok( rough_match( size.cy, size_cy * 10 ) ||
rough_match( size.cy, MulDiv( res_y, 254, dpi_y )), /* Vista uses a more precise method */
"expected cy %d or %d, got %d\n", size_cy * 10, MulDiv( res_y, 254, dpi_y ), size.cy );
expect_world_transform(hdc, 1.0, 1.0);
expect_LPtoDP(hdc, -MulDiv(1000 / 10, res_x, size_cx) + 99, -MulDiv(1000 / 10, res_y, size_cy));
SetMapMode(hdc, MM_TEXT);
ret = GetMapMode( hdc );
ok(ret == MM_ANISOTROPIC, "expected MM_ANISOTROPIC, got %d\n", ret);
pSetLayout( hdc, LAYOUT_LTR );
ret = GetMapMode( hdc );
ok(ret == MM_ANISOTROPIC, "expected MM_ANISOTROPIC, got %d\n", ret);
SetMapMode(hdc, MM_TEXT);
ret = GetMapMode( hdc );
ok(ret == MM_TEXT, "expected MM_TEXT, got %d\n", ret);
DeleteDC(hdc);
DeleteObject( bitmap );
}
// todo: find out how this works (DECLARE_HANDLE(HDC);
// ::GetClientRect(m_hDC, &rect); is a compiler-time error, which is pretty cool
RECT TimelineDC::GetClientArea() const
{
RECT rect;
GetClipBox(&rect);
return rect;
}
void SharedBitmap::drawPattern(HDC hdc, const AffineTransform& transform, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, const IntSize& origSourceSize)
{
if (!m_pixels)
return;
if (tileRectIn.width() <= 0 || tileRectIn.height() <= 0)
return;
bool useAlpha = op == CompositeSourceOver && hasAlpha() && is32bit();
int bmpWidth = width();
int bmpHeight = height();
FloatRect tileRect(tileRectIn);
if (bmpWidth != origSourceSize.width()) {
double rate = static_cast<double>(bmpWidth) / origSourceSize.width();
double temp = tileRect.width() * rate;
tileRect.setX(tileRect.x() * rate);
tileRect.setWidth(temp);
temp = tileRect.height() * rate;
tileRect.setY(tileRect.y() * rate);
tileRect.setHeight(temp);
}
OwnPtr<HBITMAP> clippedBmp;
if (tileRect.x() || tileRect.y() || tileRect.width() != bmpWidth || tileRect.height() != bmpHeight) {
BitmapInfo patternBmpInfo;
void* patternPixels;
clippedBmp = clipBitmap(IntRect(tileRect), useAlpha, patternBmpInfo, patternPixels);
if (!clippedBmp)
return;
bmpWidth = tileRect.width();
bmpHeight = tileRect.height();
}
AffineTransform tf = patternTransform * transform;
FloatRect trRect = tf.mapRect(destRect);
RECT clipBox;
int clipType = GetClipBox(hdc, &clipBox);
if (clipType == SIMPLEREGION)
trRect.intersect(FloatRect(clipBox.left, clipBox.top, clipBox.right - clipBox.left, clipBox.bottom - clipBox.top));
else if (clipType == COMPLEXREGION) {
OwnPtr<HRGN> clipRgn = adoptPtr(CreateRectRgn(0, 0, 0, 0));
if (GetClipRgn(hdc, clipRgn.get()) > 0) {
DWORD regionDataSize = GetRegionData(clipRgn.get(), sizeof(RGNDATA), 0);
if (regionDataSize) {
Vector<RGNDATA> regionData(regionDataSize);
GetRegionData(clipRgn.get(), regionDataSize, regionData.data());
RECT* rect = reinterpret_cast<RECT*>(regionData[0].Buffer);
for (DWORD i = 0; i < regionData[0].rdh.nCount; ++i, ++rect)
trRect.intersect(FloatRect(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top));
}
}
}
if (trRect.width() <= 0 || trRect.height() <= 0)
return;
trRect.inflate(1);
IntRect visibleDstRect = enclosingIntRect(tf.inverse().mapRect(trRect));
visibleDstRect.intersect(IntRect(destRect));
if (visibleDstRect.width() <= 0 || visibleDstRect.height() <= 0)
return;
trRect = tf.mapRect(visibleDstRect);
RECT dstRectWin = {
stableRound(trRect.x()),
stableRound(trRect.y()),
stableRound(trRect.maxX()),
stableRound(trRect.maxY()),
};
if (dstRectWin.right <= dstRectWin.left || dstRectWin.bottom <= dstRectWin.top)
return;
SIZE bmpSize = { bmpWidth, bmpHeight };
// Relative to destination, in bitmap pixels
POINT phaseWin = { stableRound(visibleDstRect.x() - phase.x()), stableRound(visibleDstRect.y() - phase.y()) };
phaseWin.x = normalizePhase(phaseWin.x, bmpSize.cx);
phaseWin.y = normalizePhase(phaseWin.y, bmpSize.cy);
RECT srcRectWin = {
0,
0,
stableRound(visibleDstRect.maxX()) - stableRound(visibleDstRect.x()),
stableRound(visibleDstRect.maxY()) - stableRound(visibleDstRect.y())
};
if (srcRectWin.right <= 0 || srcRectWin.bottom <= 0)
return;
BitmapInfo bmpInfo = BitmapInfo::createBottomUp(IntSize(srcRectWin.right, srcRectWin.bottom), useAlpha ? BitmapInfo::BitCount32 : BitmapInfo::BitCount16);
void* pixels;
OwnPtr<HBITMAP> hbmpTemp = adoptPtr(CreateDIBSection(0, &bmpInfo, DIB_RGB_COLORS, &pixels, 0, 0));
if (!hbmpTemp)
return;
OwnPtr<HDC> hmemdc = adoptPtr(CreateCompatibleDC(hdc));
HGDIOBJ oldBmp = SelectObject(hmemdc.get(), hbmpTemp.get());
if (clippedBmp)
drawPatternSimple(hmemdc.get(), srcRectWin, clippedBmp.get(), phaseWin);
else if ((op != CompositeSourceOver || canUseDIBits()) && srcRectWin.right <= bmpSize.cx * 2 && srcRectWin.bottom <= bmpSize.cy * 2)
drawPatternSimple(hmemdc.get(), srcRectWin, this, bmpSize, phaseWin);
else if (ensureHandle())
drawPatternSimple(hmemdc.get(), srcRectWin, getHandle(), phaseWin);
else {
void* pixels;
BitmapInfo bmpInfo;
OwnPtr<HBITMAP> hbmp = createHandle(&pixels, &bmpInfo, -1, false);
if (hbmp)
drawPatternSimple(hmemdc.get(), srcRectWin, hbmp.get(), phaseWin);
else {
SelectObject(hmemdc.get(), oldBmp);
return;
}
}
if (useAlpha && hasAlphaBlendSupport()) {
static const BLENDFUNCTION blend = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
bool success = alphaBlendIfSupported(hdc, dstRectWin.left, dstRectWin.top, dstRectWin.right - dstRectWin.left, dstRectWin.bottom - dstRectWin.top,
hmemdc.get(), 0, 0, srcRectWin.right, srcRectWin.bottom, blend);
ASSERT_UNUSED(success, success);
} else if (useAlpha && !hasAlphaBlendSupport() || op == CompositeSourceOver && usesTransparentColor()) {
TransparentBlt(hdc, dstRectWin.left, dstRectWin.top, dstRectWin.right - dstRectWin.left,
dstRectWin.bottom - dstRectWin.top, hmemdc.get(), 0, 0, srcRectWin.right, srcRectWin.bottom, transparentColor());
} else {
DWORD bmpOp = op == CompositeCopy ? SRCCOPY
: op == CompositeSourceOver ? SRCCOPY
: op == CompositeXOR ? PATINVERT
: op == CompositeClear ? WHITENESS
: SRCCOPY; // FIXEME: other types?
StretchDIBits(hdc, dstRectWin.left, dstRectWin.top, dstRectWin.right - dstRectWin.left,
dstRectWin.bottom - dstRectWin.top, 0, 0, srcRectWin.right, srcRectWin.bottom,
pixels, &bmpInfo, DIB_RGB_COLORS, bmpOp);
}
SelectObject(hmemdc.get(), oldBmp);
}
/*
* This is the real print function: print the active screen
*/
void SCH_PRINTOUT::DrawPage( SCH_SCREEN* aScreen )
{
int oldZoom;
wxPoint tmp_startvisu;
wxSize pageSizeIU; // Page size in internal units
wxPoint old_org;
EDA_RECT oldClipBox;
wxRect fitRect;
wxDC* dc = GetDC();
auto panel = m_parent->GetCanvas();
wxBusyCursor dummy;
// Save current scale factor, offsets, and clip box.
tmp_startvisu = aScreen->m_StartVisu;
oldZoom = aScreen->GetZoom();
old_org = aScreen->m_DrawOrg;
oldClipBox = *panel->GetClipBox();
// Change clip box to print the whole page.
#define MAX_VALUE (INT_MAX/2) // MAX_VALUE is the max we can use in an integer
// and that allows calculations without overflow
panel->SetClipBox( EDA_RECT( wxPoint( 0, 0 ), wxSize( MAX_VALUE, MAX_VALUE ) ) );
// Change scale factor and offset to print the whole page.
bool printReference = m_parent->GetPrintSheetReference();
pageSizeIU = aScreen->GetPageSettings().GetSizeIU();
FitThisSizeToPaper( pageSizeIU );
fitRect = GetLogicalPaperRect();
wxLogDebug( wxT( "Fit rectangle: x = %d, y = %d, w = %d, h = %d" ),
fitRect.x, fitRect.y, fitRect.width, fitRect.height );
// When is the actual paper size does not match the schematic page
// size, the drawing is not perfectly centered on X or Y axis.
// Give a draw offset centers the schematic page on the paper draw area
// Because the sizes are fitted, only an Y or X offset is needed
// and both are 0 when sizes are identical.
// Y or Y offset is not null when the X/Y size ratio differs between
// the actual paper size and the schematic page
int xoffset = ( fitRect.width - pageSizeIU.x ) / 2;
// For an obscure reason, OffsetLogicalOrigin creates issues,
// under some circumstances, when yoffset is not always null
// and changes from a page to another page
// This is only a workaround, not a fix
// see https://bugs.launchpad.net/kicad/+bug/1464773
// xoffset does not create issues.
#if 0 // FIX ME
int yoffset = ( fitRect.height - pageSizeIU.y ) / 2;
#else
// the Y centering will be not perfect, but this is less annoying
// than a blank page or a buggy centering
int yoffset = 0;
#endif
OffsetLogicalOrigin( xoffset, yoffset );
GRResetPenAndBrush( dc );
if( m_parent->GetPrintMonochrome() )
GRForceBlackPen( true );
aScreen->m_IsPrinting = true;
COLOR4D bgColor = m_parent->GetDrawBgColor();
aScreen->Draw( panel, dc, (GR_DRAWMODE) 0 );
if( printReference )
m_parent->DrawWorkSheet( dc, aScreen, GetDefaultLineThickness(),
IU_PER_MILS, aScreen->GetFileName() );
m_parent->SetDrawBgColor( bgColor );
aScreen->m_IsPrinting = false;
panel->SetClipBox( oldClipBox );
GRForceBlackPen( false );
aScreen->m_StartVisu = tmp_startvisu;
aScreen->m_DrawOrg = old_org;
aScreen->SetZoom( oldZoom );
}
