void setWindowTrackingRgn(int windowIndex) {
Rect rgnRect;
RgnHandle rgn = NewRgn();
MouseTrackingRegionID id;
windowDescriptorBlock *windowBlock = windowBlockFromIndex(windowIndex);
if (!windowBlock)
return;
if (windowBlock->windowTrackingRef) {
GetWindowBounds(windowBlock->handle, kWindowContentRgn, &rgnRect);
SetRectRgn( rgn, rgnRect.left, rgnRect.top, rgnRect.right, rgnRect.bottom );
ChangeMouseTrackingRegion(windowBlock->windowTrackingRef,rgn, NULL);
DisposeRgn( rgn );
return;
}
GetWindowBounds(windowBlock->handle, kWindowContentRgn, &rgnRect);
SetRectRgn( rgn, rgnRect.left, rgnRect.top, rgnRect.right, rgnRect.bottom );
id.signature = 'FAST';
id.id = windowIndex;
OSStatus err = CreateMouseTrackingRegion(windowBlock->handle, rgn, NULL, kMouseTrackingOptionsGlobalClip,
id, NULL, NULL, &windowBlock->windowTrackingRef);
if ( noErr == err ) {
RetainMouseTrackingRegion( windowBlock->windowTrackingRef);
err = SetMouseTrackingRegionEnabled( windowBlock->windowTrackingRef, TRUE );
}
DisposeRgn( rgn );
}
/*Assumes that all regions are in the guest coordinates system*/
static void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window)
{
ContextInfo *c = renderspuGetWindowContext(window);
RgnHandle rgn;
GLboolean result = true;
DEBUG_MSG_POETZSCH (("ApplyVisibleRegion %x\n", window));
if (!c || !c->context) return;
rgn = NewRgn();
SetEmptyRgn(rgn);
if (render_spu.hRootVisibleRegion)
{
/* The render_spu.hRootVisibleRegion has coordinates from the root
* window. We intersect it with the rect of the OpenGL window we
* currently process. */
SetRectRgn(rgn,
window->x, window->y,
window->x + window->BltInfo.width,
window->y + window->BltInfo.height);
SectRgn(render_spu.hRootVisibleRegion, rgn, rgn);
/* Because the clipping is done in the coordinate space of the OpenGL
* window we have to remove the x/y position from the newly created
* region. */
OffsetRgn (rgn, -window->x, -window->y);
}
else
{
/* If there is not root clipping region is available, create a base
* region with the size of the target window. This covers all
* needed/possible space. */
SetRectRgn(rgn, 0, 0, window->BltInfo.width, window->BltInfo.height);
}
/* Now intersect the window clipping region with a additional region e.g.
* for the seamless mode. */
if (window->hVisibleRegion)
SectRgn(rgn, window->hVisibleRegion, rgn);
if (rgn && !EmptyRgn(rgn))
{
/* Set the clip region to the context */
result = render_spu.ws.aglSetInteger(c->context, AGL_CLIP_REGION, (const GLint*)rgn);
CHECK_AGL_RC (result, "Render SPU (renderspu_SystemWindowVisibleRegion): SetInteger Failed");
result = render_spu.ws.aglEnable(c->context, AGL_CLIP_REGION);
CHECK_AGL_RC (result, "Render SPU (renderspu_SystemWindowVisibleRegion): Enable Failed");
}
/* Clear the region structure */
DisposeRgn (rgn);
}
void wxMemoryDC::SelectObject( const wxBitmap& bitmap )
{
if ( m_selected.Ok() )
{
UnlockPixels( GetGWorldPixMap(MAC_WXHBITMAP(m_selected.GetHBITMAP())) );
}
m_selected = bitmap;
if (m_selected.Ok())
{
if ( m_selected.GetHBITMAP() )
{
m_macPort = (GrafPtr) m_selected.GetHBITMAP() ;
LockPixels( GetGWorldPixMap( (CGrafPtr) m_macPort ) ) ;
wxMask * mask = bitmap.GetMask() ;
if ( mask )
{
m_macMask = mask->GetMaskBitmap() ;
}
SetRectRgn( (RgnHandle) m_macBoundaryClipRgn , 0 , 0 , m_selected.GetWidth() , m_selected.GetHeight() ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn ,(RgnHandle) m_macCurrentClipRgn ) ;
m_ok = TRUE ;
}
else
{
m_ok = FALSE;
}
}
else
{
m_ok = FALSE;
}
}
/*
* @implemented
*/
int
WINAPI
GetUpdateRgn(
HWND hWnd,
HRGN hRgn,
BOOL bErase)
{
PWND pWnd;
if (!hRgn)
{
SetLastError(ERROR_INVALID_HANDLE);
return ERROR;
}
pWnd = ValidateHwnd(hWnd);
if (!pWnd)
return ERROR;
if ( pWnd->hrgnUpdate ||
pWnd->state & (WNDS_SENDERASEBACKGROUND|WNDS_SENDNCPAINT|WNDS_UPDATEDIRTY|WNDS_PAINTNOTPROCESSED))
{
return NtUserGetUpdateRgn(hWnd, hRgn, bErase);
}
SetRectRgn(hRgn, 0, 0, 0, 0);
return NULLREGION;
}
int
TkRectInRegion(
TkRegion region,
int x,
int y,
unsigned int width,
unsigned int height)
{
RgnHandle rgn = (RgnHandle) region;
RgnHandle rectRgn, destRgn;
int result;
rectRgn = NewRgn();
destRgn = NewRgn();
SetRectRgn(rectRgn, x, y, x + width, y + height);
SectRgn(rgn, rectRgn, destRgn);
if (EmptyRgn(destRgn)) {
result = RectangleOut;
} else if (EqualRgn(rgn, destRgn)) {
result = RectangleIn;
} else {
result = RectanglePart;
}
DisposeRgn(rectRgn);
DisposeRgn(destRgn);
return result;
}
wxClientDC::wxClientDC(wxWindow *window)
{
m_window = window ;
wxTopLevelWindowMac* rootwindow = window->MacGetTopLevelWindow() ;
if (!rootwindow)
return;
WindowRef windowref = (WindowRef) rootwindow->MacGetWindowRef() ;
wxPoint origin = window->GetClientAreaOrigin() ;
wxSize size = window->GetClientSize() ;
int x , y ;
x = origin.x ;
y = origin.y ;
window->MacWindowToRootWindow( &x , &y ) ;
m_macLocalOrigin.x = x ;
m_macLocalOrigin.y = y ;
SetRectRgn( (RgnHandle) m_macBoundaryClipRgn , origin.x , origin.y , origin.x + size.x , origin.y + size.y ) ;
SectRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) window->MacGetVisibleRegion().GetWXHRGN() , (RgnHandle) m_macBoundaryClipRgn ) ;
OffsetRgn( (RgnHandle) m_macBoundaryClipRgn , -origin.x , -origin.y ) ;
OffsetRgn( (RgnHandle) m_macBoundaryClipRgn , m_macLocalOrigin.x , m_macLocalOrigin.y ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn ,(RgnHandle) m_macCurrentClipRgn ) ;
m_macPort = UMAGetWindowPort( windowref ) ;
m_ok = TRUE ;
SetBackground(window->MacGetBackgroundBrush());
SetFont( window->GetFont() ) ;
}
static void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *pRects)
{
/* Remember the visible region of the root window if there is one */
if (render_spu.hRootVisibleRegion)
{
DisposeRgn(render_spu.hRootVisibleRegion);
render_spu.hRootVisibleRegion = 0;
}
if (cRects>0)
{
int i;
render_spu.hRootVisibleRegion = NewRgn();
SetEmptyRgn (render_spu.hRootVisibleRegion);
RgnHandle tmpRgn = NewRgn();
for (i=0; i<cRects; ++i)
{
SetRectRgn (tmpRgn,
pRects[4*i] , pRects[4*i+1],
pRects[4*i+2], pRects[4*i+3]);
UnionRgn (render_spu.hRootVisibleRegion, tmpRgn, render_spu.hRootVisibleRegion);
}
DisposeRgn (tmpRgn);
}
}
void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, const GLint* pRects)
{
CRASSERT(window);
CRASSERT(window->window);
/* Remember any additional clipping stuff e.g. seamless regions */
if (window->hVisibleRegion)
{
DisposeRgn(window->hVisibleRegion);
window->hVisibleRegion = 0;
}
if (cRects>0)
{
int i;
/* Create some temporary regions */
RgnHandle rgn = NewRgn();
SetEmptyRgn (rgn);
RgnHandle tmpRgn = NewRgn();
for (i=0; i<cRects; ++i)
{
SetRectRgn (tmpRgn,
pRects[4*i] , pRects[4*i+1],
pRects[4*i+2], pRects[4*i+3]);
//DEBUG_MSG_POETZSCH (("visible rect %d %d %d %d\n", pRects[4*i] , pRects[4*i+1],
// pRects[4*i+2], pRects[4*i+3]));
UnionRgn (rgn, tmpRgn, rgn);
}
DisposeRgn (tmpRgn);
window->hVisibleRegion = rgn;
}
renderspu_SystemWindowApplyVisibleRegion(window);
}
/*
* @implemented
*/
BOOL WINAPI
ScrollDC(
HDC hDC,
int dx,
int dy,
CONST RECT *lprcScroll,
CONST RECT *lprcClip,
HRGN hrgnUpdate,
LPRECT lprcUpdate)
{
if (hDC == NULL) return FALSE;
if (dx == 0 && dy == 0)
{
if (hrgnUpdate) SetRectRgn(hrgnUpdate, 0, 0, 0, 0);
if (lprcUpdate) lprcUpdate->left = lprcUpdate->right =
lprcUpdate->top = lprcUpdate->bottom = 0;
return TRUE;
}
return NtUserScrollDC( hDC,
dx,
dy,
lprcScroll,
lprcClip,
hrgnUpdate,
lprcUpdate);
}
/*!
\internal
Create's a RegionHandle, it's the caller's responsibility to release.
Returns 0 if the QRegion overflows.
*/
RgnHandle QRegion::toQDRgnForUpdate_sys() const
{
RgnHandle rgnHandle = qt_mac_get_rgn();
if(d->qt_rgn && d->qt_rgn->numRects) {
RgnHandle tmp_rgn = qt_mac_get_rgn();
int n = d->qt_rgn->numRects;
const QRect *qt_r = (n == 1) ? &d->qt_rgn->extents : d->qt_rgn->rects.constData();
while (n--) {
// detect overflow. Tested for use with HIViewSetNeedsDisplayInRegion
// in QWidgetPrivate::update_sys().
enum { HIViewSetNeedsDisplayInRegionOverflow = 10000 }; // empirically determined conservative value
if (qt_r->right() > HIViewSetNeedsDisplayInRegionOverflow || qt_r->bottom() > HIViewSetNeedsDisplayInRegionOverflow) {
qt_mac_dispose_rgn(tmp_rgn);
qt_mac_dispose_rgn(rgnHandle);
return 0;
}
SetRectRgn(tmp_rgn,
qMax(SHRT_MIN, qt_r->x()),
qMax(SHRT_MIN, qt_r->y()),
qMin(SHRT_MAX, qt_r->right() + 1),
qMin(SHRT_MAX, qt_r->bottom() + 1));
UnionRgn(rgnHandle, tmp_rgn, rgnHandle);
++qt_r;
}
qt_mac_dispose_rgn(tmp_rgn);
}
return rgnHandle;
}
INT
Test_NtGdiCombineRgn(PTESTINFO pti)
{
HRGN hRgnDest, hRgn1, hRgn2;
// test what params are accepted for what operations
// 0? invalid? are params maybe ignored in some cases?
// LastError
/* Preparation */
hRgnDest = CreateRectRgn(0,0,1,1);
hRgn1 = CreateRectRgn(1,1,4,4);
hRgn2 = CreateRectRgn(2,2,6,3);
/* RGN_AND = 1, RGN_OR = 2, RGN_XOR = 3, RGN_DIFF = 4, RGN_COPY = 5 */
TEST(NtGdiCombineRgn(hRgnDest, hRgn1, hRgn2, 0) == ERROR);
TEST(NtGdiCombineRgn(hRgnDest, hRgn1, hRgn2, 6) == ERROR);
SetLastError(ERROR_SUCCESS);
TEST(NtGdiCombineRgn(hRgnDest, 0, 0, RGN_AND) == ERROR);
TEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
TEST(NtGdiCombineRgn(hRgnDest, hRgn1, 0, RGN_AND) == ERROR);
TEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
TEST(NtGdiCombineRgn(hRgnDest, 0, hRgn1, RGN_AND) == ERROR);
TEST(GetLastError() == ERROR_INVALID_HANDLE);
SetLastError(ERROR_SUCCESS);
TEST(NtGdiCombineRgn(0, hRgn1, hRgn2, RGN_AND) == ERROR);
TEST(GetLastError() == ERROR_INVALID_HANDLE);
/* Create intersection */
TEST(NtGdiCombineRgn(hRgnDest, hRgn1, hRgn2, RGN_AND) == SIMPLEREGION);
SetRectRgn(hRgn1, 2, 2, 4, 3);
TEST(NtGdiCombineRgn(hRgnDest, hRgnDest, hRgn1, RGN_XOR) == NULLREGION);
/* Create intersection with itself */
SetRectRgn(hRgnDest, 2, 2, 4, 3);
TEST(NtGdiCombineRgn(hRgnDest, hRgnDest, hRgnDest, RGN_AND) == SIMPLEREGION);
SetRectRgn(hRgn1, 2, 2, 4, 3);
TEST(NtGdiCombineRgn(hRgnDest, hRgnDest, hRgn1, RGN_XOR) == NULLREGION);
/* What if 2 regions are the same */
return APISTATUS_NORMAL;
}
/***********************************************************************
* BITMAP_SelectObject
*/
static HGDIOBJ BITMAP_SelectObject( HGDIOBJ handle, HDC hdc )
{
HGDIOBJ ret;
BITMAPOBJ *bitmap;
DC *dc;
if (!(dc = get_dc_ptr( hdc ))) return 0;
if (GetObjectType( hdc ) != OBJ_MEMDC)
{
ret = 0;
goto done;
}
ret = dc->hBitmap;
if (handle == dc->hBitmap) goto done; /* nothing to do */
if (!(bitmap = GDI_GetObjPtr( handle, BITMAP_MAGIC )))
{
ret = 0;
goto done;
}
if (bitmap->header.dwCount && (handle != GetStockObject(DEFAULT_BITMAP)))
{
WARN( "Bitmap already selected in another DC\n" );
GDI_ReleaseObj( handle );
ret = 0;
goto done;
}
if (!bitmap->funcs && !BITMAP_SetOwnerDC( handle, dc ))
{
GDI_ReleaseObj( handle );
ret = 0;
goto done;
}
if (dc->funcs->pSelectBitmap && !dc->funcs->pSelectBitmap( dc->physDev, handle ))
{
GDI_ReleaseObj( handle );
ret = 0;
}
else
{
dc->hBitmap = handle;
GDI_inc_ref_count( handle );
dc->dirty = 0;
SetRectRgn( dc->hVisRgn, 0, 0, bitmap->bitmap.bmWidth, bitmap->bitmap.bmHeight);
GDI_ReleaseObj( handle );
DC_InitDC( dc );
GDI_dec_ref_count( ret );
}
done:
release_dc_ptr( dc );
return ret;
}
// The content region is left as a rectangle matching the window size, this is
// so the origin in the paint event, and etc. still matches what the
// programmer expects.
static void wxShapedMacWindowContentRegion(WindowRef window, RgnHandle rgn)
{
SetEmptyRgn(rgn);
wxTopLevelWindowMac* win = wxFindWinFromMacWindow(window);
if (win)
{
wxRect r = win->GetRect();
SetRectRgn(rgn, r.GetLeft(), r.GetTop(), r.GetRight(), r.GetBottom());
}
}
HRGN WINAPI
CreateRectRgn(INT left, INT top, INT right, INT bottom)
{
HRGN hrgn;
if (!(hrgn = REGION_CreateRegion()))
return 0;
/*TRACE(region, "\n");*/
SetRectRgn(hrgn, left, top, right, bottom);
return hrgn;
}
void CDayPlanSlider::OnSize(int /*width*/, int /*height*/)
{
// m_dayView.m_layout = false;
// OutputDebugString(_T("Region resized...\n"));
m_bar.left = left + quickTabWidth;
m_bar.right = right - quickTabWidth;
m_bar.top = top;
m_bar.bottom = bottom;
SetRectRgn(m_hRegion, quickTabWidth, 0, quickTabWidth + barWidth + 1, bottom +1);
CombineRgn(m_hRegion, m_qtRgn, m_hRegion, RGN_OR);
// SetWindowRgn(m_hwnd, m_hRegion, TRUE);
}
void wxMemoryDC::DoSelect( const wxBitmap& bitmap )
{
if ( m_selected.Ok() )
{
#if wxMAC_USE_CORE_GRAPHICS
m_selected.EndRawAccess() ;
delete m_graphicContext ;
m_graphicContext = NULL ;
#else
// TODO: UnlockPixels( GetGWorldPixMap(MAC_WXHBITMAP(m_selected.GetHBITMAP())) );
#endif
}
m_selected = bitmap;
if (m_selected.Ok())
{
#if wxMAC_USE_CORE_GRAPHICS
if ( m_selected.GetDepth() != 1 )
m_selected.UseAlpha() ;
m_selected.BeginRawAccess() ;
m_width = bitmap.GetWidth();
m_height = bitmap.GetHeight();
CGColorSpaceRef genericColorSpace = wxMacGetGenericRGBColorSpace();
CGContextRef bmCtx = (CGContextRef) m_selected.GetHBITMAP();
if ( bmCtx )
{
CGContextSetFillColorSpace( bmCtx, genericColorSpace );
CGContextSetStrokeColorSpace( bmCtx, genericColorSpace );
SetGraphicsContext( wxGraphicsContext::CreateFromNative( bmCtx ) );
}
m_ok = (m_graphicContext != NULL) ;
#else
m_macPort = m_selected.GetHBITMAP( &m_macMask ) ;
m_ok = (m_macPort != NULL) ;
if (m_ok)
{
LockPixels( GetGWorldPixMap( (CGrafPtr) m_macPort ) ) ;
SetRectRgn( (RgnHandle) m_macBoundaryClipRgn , 0 , 0 , m_selected.GetWidth() , m_selected.GetHeight() ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
}
#endif
}
else
{
m_ok = false;
}
}
void wxTopLevelWindowMac::MacInvalidate( const WXRECTPTR rect, bool eraseBackground )
{
GrafPtr formerPort ;
GetPort( &formerPort ) ;
SetPortWindowPort( (WindowRef)m_macWindow ) ;
m_macNeedsErasing |= eraseBackground ;
// if we already know that we will have to erase, there's no need to track the rest
if ( !m_macNeedsErasing)
{
// we end only here if eraseBackground is false
// if we already have a difference between m_macNoEraseUpdateRgn and UpdateRgn
// we will have to erase anyway
RgnHandle updateRgn = NewRgn();
RgnHandle diffRgn = NewRgn() ;
if ( updateRgn && diffRgn )
{
GetWindowUpdateRgn( (WindowRef)m_macWindow , updateRgn );
Point pt = {0,0} ;
LocalToGlobal( &pt ) ;
OffsetRgn( updateRgn , -pt.h , -pt.v ) ;
DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
if ( !EmptyRgn( diffRgn ) )
{
m_macNeedsErasing = true ;
}
}
if ( updateRgn )
DisposeRgn( updateRgn );
if ( diffRgn )
DisposeRgn( diffRgn );
if ( !m_macNeedsErasing )
{
RgnHandle rectRgn = NewRgn() ;
SetRectRgn( rectRgn , ((Rect*)rect)->left , ((Rect*)rect)->top , ((Rect*)rect)->right , ((Rect*)rect)->bottom ) ;
UnionRgn( (RgnHandle) m_macNoEraseUpdateRgn , rectRgn , (RgnHandle) m_macNoEraseUpdateRgn ) ;
DisposeRgn( rectRgn ) ;
}
}
InvalWindowRect( (WindowRef)m_macWindow , (Rect*)rect ) ;
// turn this on to debug the refreshing cycle
#if wxMAC_DEBUG_REDRAW
PaintRect( rect ) ;
#endif
SetPort( formerPort ) ;
}
/*
* Make sure the right cursor's being displayed.
*/
static void mac_adjustcursor(RgnHandle cursrgn)
{
Point mouse;
WindowPtr window, front;
short part;
#if TARGET_API_MAC_CARBON
Cursor arrow;
RgnHandle visrgn;
#endif
GetMouse(&mouse);
LocalToGlobal(&mouse);
part = FindWindow(mouse, &window);
front = FrontWindow();
if (part != inContent || window == NULL || window != front) {
/* Cursor isn't in the front window, so switch to arrow */
#if TARGET_API_MAC_CARBON
GetQDGlobalsArrow(&arrow);
SetCursor(&arrow);
#else
SetCursor(&qd.arrow);
#endif
SetRectRgn(cursrgn, SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX);
if (front != NULL) {
#if TARGET_API_MAC_CARBON
visrgn = NewRgn();
GetPortVisibleRegion(GetWindowPort(front), visrgn);
DiffRgn(cursrgn, visrgn, cursrgn);
DisposeRgn(visrgn);
#else
DiffRgn(cursrgn, front->visRgn, cursrgn);
#endif
}
} else {
if (mac_wininfo(window)->adjustcursor != NULL)
(*mac_wininfo(window)->adjustcursor)(window, mouse, cursrgn);
else {
#if TARGET_API_MAC_CARBON
GetQDGlobalsArrow(&arrow);
SetCursor(&arrow);
GetPortVisibleRegion(GetWindowPort(window), cursrgn);
#else
SetCursor(&qd.arrow);
CopyRgn(window->visRgn, cursrgn);
#endif
}
}
}
void MainEventLoopPass()
{
EventRecord evt;
Boolean notHandled = true;
if (!gDone) /* after cx switch back ensure not done */
{
if(WaitNextEvent(everyEvent, &evt, 1, gMouseRgn))
{
if (gMouseRgn)
SetRectRgn(gMouseRgn, evt.where.h, evt.where.v, evt.where.h + 1, evt.where.v + 1);
HandleNextEvent(&evt);
}
}
}
void
TkUnionRectWithRegion(
XRectangle* rectangle,
TkRegion src_region,
TkRegion dest_region_return)
{
RgnHandle srcRgn = (RgnHandle) src_region;
RgnHandle destRgn = (RgnHandle) dest_region_return;
if (tmpRgn == NULL) {
tmpRgn = NewRgn();
}
SetRectRgn(tmpRgn, rectangle->x, rectangle->y,
rectangle->x + rectangle->width, rectangle->y + rectangle->height);
UnionRgn(srcRgn, tmpRgn, destRgn);
}
/***********************************************************************
* GetRandomRgn [GDI32.@]
*
* NOTES
* This function is documented in MSDN online for the case of
* iCode == SYSRGN (4).
*
* For iCode == 1 it should return the clip region
* 2 " " " the meta region
* 3 " " " the intersection of the clip with
* the meta region (== 'Rao' region).
*
* See http://www.codeproject.com/gdi/cliprgnguide.asp
*/
INT WINAPI GetRandomRgn(HDC hDC, HRGN hRgn, INT iCode)
{
INT ret = 1;
DC *dc = get_dc_ptr( hDC );
if (!dc) return -1;
switch (iCode)
{
case 1:
if (dc->hClipRgn) CombineRgn( hRgn, dc->hClipRgn, 0, RGN_COPY );
else ret = 0;
break;
case 2:
if (dc->hMetaRgn) CombineRgn( hRgn, dc->hMetaRgn, 0, RGN_COPY );
else ret = 0;
break;
case 3:
if (dc->hClipRgn && dc->hMetaRgn) CombineRgn( hRgn, dc->hClipRgn, dc->hMetaRgn, RGN_AND );
else if (dc->hClipRgn) CombineRgn( hRgn, dc->hClipRgn, 0, RGN_COPY );
else if (dc->hMetaRgn) CombineRgn( hRgn, dc->hMetaRgn, 0, RGN_COPY );
else ret = 0;
break;
case SYSRGN: /* == 4 */
update_dc( dc );
if (dc->hVisRgn)
{
CombineRgn( hRgn, dc->hVisRgn, 0, RGN_COPY );
/* On Windows NT/2000, the SYSRGN returned is in screen coordinates */
if (!(GetVersion() & 0x80000000)) OffsetRgn( hRgn, dc->vis_rect.left, dc->vis_rect.top );
}
else if (!is_rect_empty( &dc->device_rect ))
SetRectRgn( hRgn, dc->device_rect.left, dc->device_rect.top,
dc->device_rect.right, dc->device_rect.bottom );
else
ret = 0;
break;
default:
WARN("Unknown code %d\n", iCode);
ret = -1;
break;
}
release_dc_ptr( dc );
return ret;
}
/*!
\internal
Create's a RegionHandle, it's the caller's responsibility to release.
*/
RgnHandle QRegion::toQDRgn() const
{
RgnHandle rgnHandle = qt_mac_get_rgn();
if(d->qt_rgn && d->qt_rgn->numRects) {
RgnHandle tmp_rgn = qt_mac_get_rgn();
int n = d->qt_rgn->numRects;
const QRect *qt_r = (n == 1) ? &d->qt_rgn->extents : d->qt_rgn->rects.constData();
while (n--) {
SetRectRgn(tmp_rgn,
qMax(SHRT_MIN, qt_r->x()),
qMax(SHRT_MIN, qt_r->y()),
qMin(SHRT_MAX, qt_r->right() + 1),
qMin(SHRT_MAX, qt_r->bottom() + 1));
UnionRgn(rgnHandle, tmp_rgn, rgnHandle);
++qt_r;
}
qt_mac_dispose_rgn(tmp_rgn);
}
return rgnHandle;
}
void fenum(STATE* state)
{
HWND hwnd = state->hwnd;
HWND hwndDesktop = GetDesktopWindow();
HWND hwndStart = FindWindowEx(hwndDesktop, NULL, "Button", "Start");
RECT& rectDesktop = state->rect_list[state->rect_list_n];
if(!GetWindowRect(hwndDesktop, &rectDesktop)) return;
state->rect_list_n++;
HRGN hrgnDesktop = CreateRectRgn(rectDesktop.left, rectDesktop.top, rectDesktop.right, rectDesktop.bottom);
HRGN hrgn = CreateRectRgn(0, 0, 0, 0);
HRGN hrgn_ = CreateRectRgn(0, 0, 0, 0);
for(HWND hwnd_ = GetTopWindow(NULL); hwnd_ != NULL; hwnd_ = GetWindow(hwnd_, GW_HWNDNEXT))
{
if(hwnd_ == hwnd || hwnd_ == hwndStart || hwnd_ == hwndDesktop ||
!IsWindowVisible(hwnd_) || IsIconic(hwnd_) || IsChild(hwnd)) continue;
RECT& rect = state->rect_list[state->rect_list_n];
if(!GetWindowRect(hwnd_, &rect)) continue;
if(!SetRectRgn(hrgn_, rect.left, rect.top, rect.right, rect.bottom)) continue;
if(hrgnDesktop)
{
if(CombineRgn(hrgn_, hrgn_, hrgnDesktop, RGN_AND) == NULLREGION) continue;
if(GetRgnBox(hrgn_, &rect) == NULLREGION) continue;
}
if(CombineRgn(hrgn_, hrgn_, hrgn, RGN_DIFF) == NULLREGION) continue;
if(CombineRgn(hrgn, hrgn, hrgn_, RGN_OR) == ERROR) continue;
if(state->rect_list_n++ == sizeof(state->rect_list) / sizeof(RECT)) break;
}
DeleteObject(hrgn_);
DeleteObject(hrgn);
DeleteObject(hrgnDesktop);
} // fenum
void main()
{
HWND hwndDesktop = GetDesktopWindow();
HWND hwndStart = FindWindowEx(hwndDesktop, NULL, "Button", "Start");
RECT rectDesktop;
if(!GetWindowRect(hwndDesktop, &rectDesktop)) return;
HRGN hrgnDesktop = CreateRectRgn(rectDesktop.left, rectDesktop.top, rectDesktop.right, rectDesktop.bottom);
HRGN hrgn = CreateRectRgn(0, 0, 0, 0);
HRGN hrgn_ = CreateRectRgn(0, 0, 0, 0);
for(HWND hwnd_ = GetTopWindow(NULL); hwnd_ != NULL; hwnd_ = GetWindow(hwnd_, GW_HWNDNEXT))
{
if(hwnd_ == hwndStart || hwnd_ == hwndDesktop ||
!IsWindowVisible(hwnd_) || IsIconic(hwnd_)) continue;
char buffer[256];
GetWindowText(hwnd_, buffer, sizeof(buffer));
printf("GetWindowText = %s\n", buffer);
RECT rect;
if(!GetWindowRect(hwnd_, &rect)) continue;
if(!SetRectRgn(hrgn_, rect.left, rect.top, rect.right, rect.bottom)) continue;
if(hrgnDesktop)
{
if(CombineRgn(hrgn_, hrgn_, hrgnDesktop, RGN_AND) == NULLREGION) continue;
if(GetRgnBox(hrgn_, &rect) == NULLREGION) continue;
}
if(CombineRgn(hrgn_, hrgn_, hrgn, RGN_DIFF) == NULLREGION) continue;
if(CombineRgn(hrgn, hrgn, hrgn_, RGN_OR) == ERROR) continue;
printf("RECT :: l = %d, r = %d, t = %d, b = %d\n", rect.left, rect.right, rect.top, rect.bottom);
}
DeleteObject(hrgn_);
DeleteObject(hrgn);
DeleteObject(hrgnDesktop);
}
wxDragResult wxDropSource::DoDragDrop(int flags)
{
wxASSERT_MSG( m_data, wxT("Drop source: no data") );
if ((m_data == NULL) || (m_data->GetFormatCount() == 0))
return (wxDragResult)wxDragNone;
DragReference theDrag;
RgnHandle dragRegion;
OSStatus err = noErr;
PasteboardRef pasteboard;
// add data to drag
err = PasteboardCreate( kPasteboardUniqueName, &pasteboard );
if ( err != noErr )
return wxDragNone;
// we add a dummy promise keeper because of strange messages when linking against carbon debug
err = PasteboardSetPromiseKeeper( pasteboard, wxMacPromiseKeeper, this );
if ( err != noErr )
{
CFRelease( pasteboard );
return wxDragNone;
}
err = PasteboardClear( pasteboard );
if ( err != noErr )
{
CFRelease( pasteboard );
return wxDragNone;
}
PasteboardSynchronize( pasteboard );
m_data->AddToPasteboard( pasteboard, 1 );
if (NewDragWithPasteboard( pasteboard , &theDrag) != noErr)
{
CFRelease( pasteboard );
return wxDragNone;
}
dragRegion = NewRgn();
RgnHandle tempRgn = NewRgn();
EventRecord rec;
ConvertEventRefToEventRecord( (EventRef) wxTheApp->MacGetCurrentEvent(), &rec );
const short dragRegionOuterBoundary = 10;
const short dragRegionInnerBoundary = 9;
SetRectRgn(
dragRegion,
rec.where.h - dragRegionOuterBoundary,
rec.where.v - dragRegionOuterBoundary,
rec.where.h + dragRegionOuterBoundary,
rec.where.v + dragRegionOuterBoundary );
SetRectRgn(
tempRgn,
rec.where.h - dragRegionInnerBoundary,
rec.where.v - dragRegionInnerBoundary,
rec.where.h + dragRegionInnerBoundary,
rec.where.v + dragRegionInnerBoundary );
DiffRgn( dragRegion, tempRgn, dragRegion );
DisposeRgn( tempRgn );
// TODO: work with promises in order to return data
// only when drag was successfully completed
gTrackingGlobals.m_currentSource = this;
gTrackingGlobals.m_result = wxDragNone;
gTrackingGlobals.m_flags = flags;
err = TrackDrag( theDrag, &rec, dragRegion );
DisposeRgn( dragRegion );
DisposeDrag( theDrag );
CFRelease( pasteboard );
gTrackingGlobals.m_currentSource = NULL;
return gTrackingGlobals.m_result;
}
BOOL CALLBACK VBoxEnumFunc(HWND hwnd, LPARAM lParam)
{
PVBOX_ENUM_PARAM lpParam = (PVBOX_ENUM_PARAM)lParam;
DWORD dwStyle, dwExStyle;
RECT rectWindow, rectVisible;
dwStyle = GetWindowLong(hwnd, GWL_STYLE);
dwExStyle = GetWindowLong(hwnd, GWL_EXSTYLE);
if ( !(dwStyle & WS_VISIBLE)
|| (dwStyle & WS_CHILD))
return TRUE;
Log(("VBoxTray: VBoxEnumFunc %x\n", hwnd));
/* Only visible windows that are present on the desktop are interesting here */
if (GetWindowRect(hwnd, &rectWindow))
{
char szWindowText[256];
szWindowText[0] = 0;
OSVERSIONINFO OSinfo;
HWND hStart = NULL;
GetWindowText(hwnd, szWindowText, sizeof(szWindowText));
OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
GetVersionEx (&OSinfo);
if (OSinfo.dwMajorVersion >= 6)
{
hStart = ::FindWindowEx(GetDesktopWindow(), NULL, "Button", "Start");
if ( hwnd == hStart && szWindowText != NULL
&& !(strcmp(szWindowText, "Start"))
)
{
/* for vista and above. To solve the issue of small bar above
* the Start button when mouse is hovered over the start button in seamless mode.
* Difference of 7 is observed in Win 7 platform between the dimensionsof rectangle with Start title and its shadow.
*/
rectWindow.top += 7;
rectWindow.bottom -=7;
}
}
rectVisible = rectWindow;
#ifdef LOG_ENABLED
DWORD pid = 0;
DWORD tid = GetWindowThreadProcessId(hwnd, &pid);
#endif
/* Filter out Windows XP shadow windows */
/** @todo still shows inside the guest */
if ( szWindowText[0] == 0
&& (
(dwStyle == (WS_POPUP|WS_VISIBLE|WS_CLIPSIBLINGS)
&& dwExStyle == (WS_EX_LAYERED|WS_EX_TOOLWINDOW|WS_EX_TRANSPARENT|WS_EX_TOPMOST))
|| (dwStyle == (WS_POPUP|WS_VISIBLE|WS_DISABLED|WS_CLIPSIBLINGS|WS_CLIPCHILDREN)
&& dwExStyle == (WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_LAYERED | WS_EX_NOACTIVATE))
|| (dwStyle == (WS_POPUP|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN)
&& dwExStyle == (WS_EX_TOOLWINDOW))
))
{
Log(("VBoxTray: Filter out shadow window style=%x exstyle=%x\n", dwStyle, dwExStyle));
Log(("VBoxTray: Enum hwnd=%x rect (%d,%d) (%d,%d) (filtered)\n", hwnd, rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
Log(("VBoxTray: title=%s style=%x exStyle=%x\n", szWindowText, dwStyle, dwExStyle));
Log(("VBoxTray: pid=%d tid=%d\n", pid, tid));
return TRUE;
}
/** @todo will this suffice? The Program Manager window covers the whole screen */
if (strcmp(szWindowText, "Program Manager"))
{
Log(("VBoxTray: Enum hwnd=%x rect (%d,%d) (%d,%d) (applying)\n", hwnd, rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
Log(("VBoxTray: title=%s style=%x exStyle=%x\n", szWindowText, dwStyle, dwExStyle));
Log(("VBoxTray: pid=%d tid=%d\n", pid, tid));
HRGN hrgn = CreateRectRgn(0,0,0,0);
int ret = GetWindowRgn(hwnd, hrgn);
if (ret == ERROR)
{
Log(("VBoxTray: GetWindowRgn failed with rc=%d\n", GetLastError()));
SetRectRgn(hrgn, rectVisible.left, rectVisible.top, rectVisible.right, rectVisible.bottom);
}
else
{
/* this region is relative to the window origin instead of the desktop origin */
OffsetRgn(hrgn, rectWindow.left, rectWindow.top);
}
if (lpParam->hrgn)
{
/* create a union of the current visible region and the visible rectangle of this window. */
CombineRgn(lpParam->hrgn, lpParam->hrgn, hrgn, RGN_OR);
DeleteObject(hrgn);
}
else
lpParam->hrgn = hrgn;
}
else
{
Log(("VBoxTray: Enum hwnd=%x rect (%d,%d) (%d,%d) (ignored)\n", hwnd, rectWindow.left, rectWindow.top, rectWindow.right, rectWindow.bottom));
Log(("VBoxTray: title=%s style=%x\n", szWindowText, dwStyle));
Log(("VBoxTray: pid=%d tid=%d\n", pid, tid));
}
}
return TRUE; /* continue enumeration */
}
void
TkMacUpdateClipRgn(
TkWindow *winPtr)
{
RgnHandle rgn;
int x, y;
TkWindow *win2Ptr;
if (winPtr == NULL) {
return;
}
if (winPtr->privatePtr->flags & TK_CLIP_INVALID) {
rgn = winPtr->privatePtr->aboveClipRgn;
if (tmpRgn == NULL) {
tmpRgn = NewRgn();
}
/*
* Start with a region defined by the window bounds.
*/
x = winPtr->privatePtr->xOff;
y = winPtr->privatePtr->yOff;
SetRectRgn(rgn, (short) x, (short) y,
(short) (winPtr->changes.width + x),
(short) (winPtr->changes.height + y));
/*
* Clip away the area of any windows that may obscure this
* window.
* For a non-toplevel window, first, clip to the parents visable
* clip region.
* Second, clip away any siblings that are higher in the
* stacking order.
* For an embedded toplevel, just clip to the container's visible
* clip region. Remember, we only allow one contained window
* in a frame, and don't support any other widgets in the frame either.
* This is not currently enforced, however.
*/
if (!Tk_IsTopLevel(winPtr)) {
TkMacUpdateClipRgn(winPtr->parentPtr);
SectRgn(rgn,
winPtr->parentPtr->privatePtr->aboveClipRgn, rgn);
win2Ptr = winPtr->nextPtr;
while (win2Ptr != NULL) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
x = win2Ptr->privatePtr->xOff;
y = win2Ptr->privatePtr->yOff;
SetRectRgn(tmpRgn, (short) x, (short) y,
(short) (win2Ptr->changes.width + x),
(short) (win2Ptr->changes.height + y));
DiffRgn(rgn, tmpRgn, rgn);
win2Ptr = win2Ptr->nextPtr;
}
} else if (Tk_IsEmbedded(winPtr)) {
TkWindow *contWinPtr;
contWinPtr = TkpGetOtherWindow(winPtr);
if (contWinPtr != NULL) {
TkMacUpdateClipRgn(contWinPtr);
SectRgn(rgn,
contWinPtr->privatePtr->aboveClipRgn, rgn);
} else if (gMacEmbedHandler != NULL) {
gMacEmbedHandler->getClipProc((Tk_Window) winPtr, tmpRgn);
SectRgn(rgn, tmpRgn, rgn);
}
/*
* NOTE: Here we should handle out of process embedding.
*/
}
/*
* The final clip region is the aboveClip region (or visable
* region) minus all the children of this window.
* Alternatively, if the window is a container, we must also
* subtract the region of the embedded window.
*/
rgn = winPtr->privatePtr->clipRgn;
CopyRgn(winPtr->privatePtr->aboveClipRgn, rgn);
win2Ptr = winPtr->childList;
while (win2Ptr != NULL) {
if (Tk_IsTopLevel(win2Ptr) || !Tk_IsMapped(win2Ptr)) {
win2Ptr = win2Ptr->nextPtr;
continue;
}
x = win2Ptr->privatePtr->xOff;
y = win2Ptr->privatePtr->yOff;
SetRectRgn(tmpRgn, (short) x, (short) y,
(short) (win2Ptr->changes.width + x),
(short) (win2Ptr->changes.height + y));
DiffRgn(rgn, tmpRgn, rgn);
win2Ptr = win2Ptr->nextPtr;
}
if (Tk_IsContainer(winPtr)) {
win2Ptr = TkpGetOtherWindow(winPtr);
if (win2Ptr != NULL) {
if (Tk_IsMapped(win2Ptr)) {
x = win2Ptr->privatePtr->xOff;
y = win2Ptr->privatePtr->yOff;
SetRectRgn(tmpRgn, (short) x, (short) y,
(short) (win2Ptr->changes.width + x),
(short) (win2Ptr->changes.height + y));
DiffRgn(rgn, tmpRgn, rgn);
}
}
/*
* NOTE: Here we should handle out of process embedding.
*/
}
winPtr->privatePtr->flags &= ~TK_CLIP_INVALID;
}
}
Boolean MCScreenDC::open()
{
owndnd = False;
mouseMoveRgn = NewRgn();
SetRectRgn(mouseMoveRgn, 0, 0, 1, 1);
//create a invisible window, and set port to this window
//so that later on at the very first time MC select and set font
//will only affect in this invisible window, not other apps on the desk top,
// when MC is first started. The size of the window is random.
// Rect invisibleWinRect;
Rect invisibleWinRect;
SetRect(&invisibleWinRect, 0, 0, 20, 20);
invisibleWin = NewCWindow(nil, &invisibleWinRect, "\p", False,
kUtilityWindowClass, (WindowRef)(-1L), False, 0);
long response;
if (Gestalt(gestaltSystemVersion, &response) == noErr)
{
if (response >= 0x1030 && response < 0x1040)
MCantialiasedtextworkaround = True;
else
MCantialiasedtextworkaround = False;
}
SetGWorld(GetWindowPort(invisibleWin), GetMainDevice());
vis = new MCVisualInfo;
devdepth = 32;
black_pixel.red = black_pixel.green = black_pixel.blue = 0; //black pixel
white_pixel.red = white_pixel.green = white_pixel.blue = 0xFFFF; //white pixel
black_pixel.pixel = 0;
white_pixel.pixel = 0xFFFFFF;
redbits = greenbits = bluebits = 8;
redshift = 16;
greenshift = 8;
blueshift = 0;
vis->red_mask = 0x00FF0000;
vis->green_mask = 0x0000FF00;
vis->blue_mask = 0x000000FF;
MCzerocolor = MCbrushcolor = white_pixel;
alloccolor(MCbrushcolor);
MCselectioncolor = MCpencolor = black_pixel;
alloccolor(MCselectioncolor);
alloccolor(MCpencolor);
gray_pixel.red = gray_pixel.green = gray_pixel.blue = 0x8888;
alloccolor(gray_pixel);
background_pixel.red = background_pixel.green = background_pixel.blue = 0xffff;
alloccolor(background_pixel);
//query the system for the hilited text color, and set ours
RGBColor hiliteRGB;
LMGetHiliteRGB(&hiliteRGB);
MChilitecolor.red = hiliteRGB.red;
MChilitecolor.green = hiliteRGB.green;
MChilitecolor.blue = hiliteRGB.blue;
alloccolor(MChilitecolor);
MCColor *syscolors = getaccentcolors();
if (syscolors != NULL)
MCaccentcolor = syscolors[4];
else
{
MCaccentcolor.red = MCaccentcolor.green = 0x0000;
MCaccentcolor.blue = 0x8080;
}
alloccolor(MCaccentcolor);
grabbed = False;
tripleclick = doubleclick = False;
MCdoubletime = GetDblTime() * 1000 / 60;
opened = True;
mousewindow = new _Drawable;
activewindow = new _Drawable;
lastactivewindow = new _Drawable;
mousewindow->type = activewindow->type = lastactivewindow->type = DC_WINDOW;
mousewindow->handle.window = activewindow->handle.window
= lastactivewindow->handle.window = 0;
//get handle of application menu bar
menuBar = GetMenuBar();
SetMenuBar(menuBar); //set menu bar as current menulist
//create Apple menu
appleMenu = NewMenu(mApple, "\p\024"); //menu title is an apple icon
InsertMenuItem(appleMenu, "\pAbout...", 0);
InsertMenu(appleMenu, 0);
DrawMenuBar(); //draw the menu bar with the Apple menu
usetemp = False;
Handle tmem = Get1IndResource('TMEM', 1);
if (tmem != NULL)
{
char *ptr = *tmem;
if (*(ptr + 1))
usetemp = True;
}
MCtemplatescrollbar->alloccolors();
if (IsMacEmulatedLF()) // no AM
MCtemplatebutton->allocicons();
// preallocate these because GetItemMark can't distinguish them
submenuIDs[0] = 1;
submenuIDs[checkMark] = 1;
submenuIDs[diamondMark] = 1;
MCcursors[PI_NONE] = nil;
MCblinkrate = GetCaretTime() * 1000 / 60;
MCDisplay const *t_displays;
getdisplays(t_displays, false);
MCwbr = t_displays[0] . workarea;
//TSM - INIT TSM APPLICATION AND INSTALL REQUIRED APPLEVENT HANDLERS
TSMPositionToOffsetUPP = NewAEEventHandlerUPP(TSMPositionToOffset);
TSMOffsetToPositionUPP = NewAEEventHandlerUPP(TSMOffsetToPosition);
TSMUpdateHandlerUPP = NewAEEventHandlerUPP(TSMUpdateHandler);
TSMUnicodeNotFromInputUPP
= NewAEEventHandlerUPP(TSMUnicodeNotFromInputHandler);
AEInstallEventHandler(kTextServiceClass, kPos2Offset,
TSMPositionToOffsetUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kOffset2Pos,
TSMOffsetToPositionUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kUpdateActiveInputArea,
TSMUpdateHandlerUPP, 0L , False);
AEInstallEventHandler(kTextServiceClass, kUnicodeNotFromInputMethod,
TSMUnicodeNotFromInputUPP, 0L , False);
openIME();
dragdropUPP = NewDragReceiveHandlerUPP(DragReceiveHandler);
InstallReceiveHandler(dragdropUPP, NULL, NULL);
dragmoveUPP = NewDragTrackingHandlerUPP(DragTrackingHandler);
InstallTrackingHandler(dragmoveUPP, NULL, NULL);
s_animation_current_time = s_animation_start_time = CFAbsoluteTimeGetCurrent();
//// Dock Menu Initialization
EventTypeSpec t_menu_event_specs[1];
t_menu_event_specs[0] . eventClass = kEventClassMenu;
t_menu_event_specs[0] . eventKind = kEventMenuPopulate;
CreateNewMenu(0, 0, &f_icon_menu);
s_icon_menu_event_handler_upp = NewEventHandlerUPP((EventHandlerProcPtr)handleiconmenuevent);
InstallEventHandler(GetMenuEventTarget(f_icon_menu), s_icon_menu_event_handler_upp, 1, t_menu_event_specs, NULL, NULL);
t_menu_event_specs[0] . eventClass = kEventClassCommand;
t_menu_event_specs[0] . eventKind = kEventCommandProcess;
InstallEventHandler(GetApplicationEventTarget(), s_icon_menu_event_handler_upp, 1, t_menu_event_specs, NULL, NULL);
SetApplicationDockTileMenu(f_icon_menu);
//// Color Profile Initialization
CMGetDefaultProfileBySpace(cmRGBData, &m_dst_profile);
CMProfileLocation t_location;
t_location . locType = cmPathBasedProfile;
strcpy(t_location . u . pathLoc . path, "/System/Library/ColorSync/Profiles/sRGB Profile.icc");
CMOpenProfile(&m_srgb_profile, &t_location);
////
return True;
}
/*************************************************************************
* 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;
}
FIBITMAP* CaptureScreen (HDC hDC,SIZE size,HWND hCapture){
//HDC GetDC (NULL) entire desktp
//HDC GetDC (HWND hWnd) client area of the specified window. (may include artifacts)
//HDC GetWindowDC (HWND hWnd) entire window.
FIBITMAP *dib = NULL;
HBITMAP hBitmap; // handles to device-dependent bitmaps
HDC hScrDC, hMemDC; // screen DC and memory DC
// create a DC for the screen and create
// a memory DC compatible to screen DC
if(!(hScrDC=hDC)) hScrDC=GetDC(hCapture);
hMemDC = CreateCompatibleDC(hScrDC);
// create a bitmap compatible with the screen DC
hBitmap = CreateCompatibleBitmap(hScrDC,size.cx,size.cy);
// select new bitmap into memory DC
SelectObject(hMemDC, hBitmap);
if(hCapture && hDC){
PrintWindow(hCapture,hMemDC,0);
}else{// bitblt screen DC to memory DC
BitBlt(hMemDC,0,0,size.cx,size.cy,hScrDC,0,0,CAPTUREBLT|SRCCOPY);
}
dib = FIP->FI_CreateDIBFromHBITMAP(hBitmap);
//alpha channel from window is always wrong and sometimes even for desktop (Win7, no aero)
//coz GDI do not draw all in alpha mode.
//we have to create our own new alpha channel.
bool bFixAlpha=true;
bool bInvert=false;
HBRUSH hBr=CreateSolidBrush(RGB(255,255,255));//Create a SolidBrush object for non transparent area
HBITMAP hMask=CreateBitmap(size.cx,size.cy,1,1,NULL);// Create monochrome (1 bit) B+W mask bitmap.
HDC hMaskDC=CreateCompatibleDC(0);
SelectBitmap(hMaskDC,hMask);
HRGN hRgn=CreateRectRgn(0,0,0,0);
if(hCapture && GetWindowRgn(hCapture,hRgn)==ERROR){
if((GetWindowLongPtr(hCapture,GWL_EXSTYLE)&WS_EX_LAYERED)){
BYTE bAlpha=0;
COLORREF crKey=0;//0x00bbggrr
DWORD dwFlags=0;
if(GetLayeredWindowAttributes(hCapture,&crKey,&bAlpha,&dwFlags)) {
//per window transparency (like fading in a whole window).
if((dwFlags&LWA_COLORKEY)){
SetBkColor(hMemDC,crKey);
BitBlt(hMaskDC,0,0,size.cx,size.cy,hMemDC,0,0,SRCCOPY);
bInvert=true;
}else if((dwFlags&LWA_ALPHA)){
bFixAlpha=false;
}
}else{//per-pixel transparency (won't use the WM_PAINT)
bFixAlpha=false;
}
}else{//not layered - fill the window region
SetRectRgn(hRgn,0,0,size.cx,size.cy);
FillRgn(hMaskDC,hRgn,hBr);
}
}else{
if(!hCapture) SetRectRgn(hRgn,0,0,size.cx,size.cy);//client area only, no transparency
FillRgn(hMaskDC,hRgn,hBr);
}
DeleteObject(hRgn);
if(bFixAlpha){
FIBITMAP* dibMask = FIP->FI_CreateDIBFromHBITMAP(hMask);
if(bInvert) FIP->FI_Invert(dibMask);
FIBITMAP* dib8 = FIP->FI_ConvertTo8Bits(dibMask);
//copy the dib8 alpha mask to dib32 main bitmap
FIP->FI_SetChannel(dib,dib8,FICC_ALPHA);
FIP->FI_Unload(dibMask);
FIP->FI_Unload(dib8);
}
DeleteDC(hMaskDC);
DeleteObject(hMask);
DeleteObject(hBr);
//clean up
DeleteDC(hMemDC);
DeleteObject(hBitmap);
if(!hDC) ReleaseDC(NULL, hScrDC);
#ifdef _DEBUG
switch (FIP->FI_GetImageType(dib)){
case FIT_UNKNOWN:
OutputDebugStringA("FIBITMAP Typ: FIT_UNKNOWN\r\n" );
break;
case FIT_BITMAP:
OutputDebugStringA("FIBITMAP Typ: FIT_BITMAP\r\n" );
break;
case FIT_UINT16:
OutputDebugStringA("FIBITMAP Typ: FIT_UINT16\r\n" );
break;
case FIT_INT16:
OutputDebugStringA("FIBITMAP Typ: FIT_INT16\r\n" );
break;
case FIT_UINT32:
OutputDebugStringA("FIBITMAP Typ: FIT_UINT32\r\n" );
break;
case FIT_INT32:
OutputDebugStringA("FIBITMAP Typ: FIT_INT32\r\n" );
break;
case FIT_FLOAT:
OutputDebugStringA("FIBITMAP Typ: FIT_FLOAT\r\n" );
break;
case FIT_DOUBLE:
OutputDebugStringA("FIBITMAP Typ: FIT_DOUBLE\r\n" );
break;
case FIT_COMPLEX:
OutputDebugStringA("FIBITMAP Typ: FIT_COMPLEX\r\n" );
break;
case FIT_RGB16:
OutputDebugStringA("FIBITMAP Typ: FIT_RGB16\r\n" );
break;
case FIT_RGBA16:
OutputDebugStringA("FIBITMAP Typ: FIT_RGBA16\r\n" );
break;
case FIT_RGBF:
OutputDebugStringA("FIBITMAP Typ: FIT_RGBF\r\n" );
break;
case FIT_RGBAF:
OutputDebugStringA("FIBITMAP Typ: FIT_RGBAF\r\n" );
break;
default:
OutputDebugStringA("FIBITMAP Typ: non detectable image type (error)\r\n" );
break;
}
BOOL inf = FIP->FI_IsTransparent(dib);
OutputDebugStringA(inf ? "FIBITMAP Transparent: true\r\n" : "FIBITMAP Transparent: false\r\n");
#endif
return dib;
}
