/*!
\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;
}
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);
}
bool MCRegionIncludeRect(MCRegionRef self, const MCRectangle& rect)
{
Rect t_rect;
SetRect(&t_rect, rect . x, rect . y, rect . x + rect . width, rect . y + rect . height);
RgnHandle t_rect_rgn;
t_rect_rgn = NewRgn();
RectRgn(t_rect_rgn, &t_rect);
UnionRgn((RgnHandle)self, t_rect_rgn, (RgnHandle)self);
DisposeRgn(t_rect_rgn);
return true;
}
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 ) ;
}
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);
}
/*!
\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 myHideMenuBar(
GDHandle ignoredDev)
{
RgnHandle gray,rect;
GDHandle dev;
(void)ignoredDev;
if (savedgray)
return;
gray=GetGrayRgn();
savedgray=NewRgn();
rect=NewRgn();
CopyRgn(gray,savedgray);
for (dev=GetDeviceList(); dev; dev=GetNextDevice(dev)) {
if (!TestDeviceAttribute(dev,screenDevice)
|| !TestDeviceAttribute(dev,screenActive))
continue;
RectRgn(rect,&(*dev)->gdRect);
UnionRgn(gray,rect,gray);
}
DisposeRgn(rect);
savedmbh=LMGetMBarHeight();
LMSetMBarHeight(0);
}
HDC xxxBeginPaint(
PWND pwnd,
LPPAINTSTRUCT lpps)
{
HRGN hrgnUpdate;
HDC hdc;
BOOL fSendEraseBkgnd;
CheckLock(pwnd);
UserAssert(IsWinEventNotifyDeferredOK());
if (TEST_PUDF(PUDF_DRAGGINGFULLWINDOW))
SetWF(pwnd, WFSTARTPAINT);
/*
* We're processing a WM_PAINT message: clear this flag.
*/
ClrWF(pwnd, WFPAINTNOTPROCESSED);
/*
* If this bit gets set while we are drawing the frame we will need
* to redraw it.
*
* If necessary, send our WM_NCPAINT message now.
*
* please heed these notes
*
* We have to send this message BEFORE we diddle hwnd->hrgnUpdate,
* because an app may call ValidateRect or InvalidateRect in its
* handler, and it expects what it does to affect what gets drawn
* in the later WM_PAINT.
*
* It is possible to get an invalidate when we leave the critical
* section below, therefore we loop until UPDATEDIRTY is clear
* meaning there were no additional invalidates.
*/
if (TestWF(pwnd, WFSENDNCPAINT)) {
do {
ClrWF(pwnd, WFUPDATEDIRTY);
hrgnUpdate = GetNCUpdateRgn(pwnd, FALSE);
xxxSendNCPaint(pwnd, hrgnUpdate);
DeleteMaybeSpecialRgn(hrgnUpdate);
} while (TestWF(pwnd, WFUPDATEDIRTY));
} else {
ClrWF(pwnd, WFUPDATEDIRTY);
}
/*
* Hide the caret if needed. Do this before we get the DC so
* that if HideCaret() gets and releases a DC we will be able
* to reuse it later here.
* No need to DeferWinEventNotify() since pwnd is locked.
*/
if (pwnd == PtiCurrent()->pq->caret.spwnd)
zzzInternalHideCaret();
/*
* Send the check for sending an WM_ERASEBKGND to the
* window.
*/
if (fSendEraseBkgnd = TestWF(pwnd, WFSENDERASEBKGND)) {
ClrWF(pwnd, WFERASEBKGND);
ClrWF(pwnd, WFSENDERASEBKGND);
}
/*
* Validate the entire window.
*/
if (NEEDSPAINT(pwnd))
DecPaintCount(pwnd);
ClrWF(pwnd, WFINTERNALPAINT);
hrgnUpdate = pwnd->hrgnUpdate;
pwnd->hrgnUpdate = NULL;
if (TestWF(pwnd, WFDONTVALIDATE)) {
if (ghrgnUpdateSave == NULL) {
ghrgnUpdateSave = CreateEmptyRgn();
}
if (ghrgnUpdateSave != NULL) {
UnionRgn(ghrgnUpdateSave, ghrgnUpdateSave, hrgnUpdate);
gnUpdateSave++;
}
}
/*
* Clear these flags for backward compatibility
*/
lpps->fIncUpdate =
lpps->fRestore = FALSE;
lpps->hdc =
hdc = _GetDCEx(pwnd,
hrgnUpdate,
DCX_USESTYLE | DCX_INTERSECTRGN);
if (UT_GetParentDCClipBox(pwnd, hdc, &lpps->rcPaint)) {
/*
* If necessary, erase our background, and possibly deal with
* our children's frames and backgrounds.
*/
if (fSendEraseBkgnd)
xxxSendEraseBkgnd(pwnd, hdc, hrgnUpdate);
}
/*
* Now that we're completely erased, see if there are any children
* that couldn't draw their own frames because their update regions
* got deleted.
*/
xxxSendChildNCPaint(pwnd);
/*
* The erase and frame operation has occured. Clear the WFREDRAWIFHUNG
* bit here. We don't want to clear it until we know the erase and
* frame has occured, so we know we always have a consistent looking
* window.
*/
ClearHungFlag(pwnd, WFREDRAWIFHUNG);
lpps->fErase = (TestWF(pwnd, WFERASEBKGND) != 0);
return hdc;
}
static void ROM_ShowMenuBar(_THIS)
{
#if !TARGET_API_MAC_CARBON /* This seems not to be available? -sts Aug 2000 */
RgnHandle drawRgn = nil;
RgnHandle menuRgn = nil;
RgnHandle tempRgn = nil;
RgnHandle grayRgn = nil;
WindowPtr window = nil;
GrafPtr wMgrPort;
GrafPtr savePort;
Rect menuRect;
long response;
short height;
EventRecord theEvent;
RGBColor saveRGB;
RGBColor blackRGB = { 0, 0, 0 };
height = GetMBarHeight();
if ((height <= 0) && (gSaveMenuBar > 0)) {
drawRgn = NewRgn();
menuRgn = NewRgn();
tempRgn = NewRgn();
if ( ! tempRgn || ! drawRgn || ! gSaveGrayRgn ) {
goto CLEANUP;
}
grayRgn = GetGrayRgn(); /* No need to check for this */
GetPort(&savePort);
GetWMgrPort(&wMgrPort);
/* Set the height properly */
LMSetMBarHeight(gSaveMenuBar);
/* Restore the old GrayRgn: rounded corners, etc, but not
the menubar -- subtract that out first! */
if (gSaveGrayRgn)
{
menuRect = (*GetMainDevice())->gdRect;
menuRect.bottom = menuRect.top + gSaveMenuBar;
RectRgn(menuRgn, &menuRect);
DiffRgn(grayRgn, gSaveGrayRgn, drawRgn); /* What do we inval? */
DiffRgn(drawRgn, menuRgn, drawRgn); /* Clip out the menu */
/* Now redraw the corners and other bits black */
SetPort(wMgrPort);
GetClip(tempRgn);
SetClip(drawRgn);
GetForeColor(&saveRGB);
RGBForeColor(&blackRGB);
PaintRgn(drawRgn);
RGBForeColor(&saveRGB);
SetClip(tempRgn);
SetPort(savePort);
UnionRgn(drawRgn, menuRgn, drawRgn); /* Put back the menu */
/* Now actually restore the GrayRgn */
CopyRgn(gSaveGrayRgn, grayRgn);
DisposeRgn(gSaveGrayRgn);
gSaveGrayRgn = nil;
}
/* Modify the vis regions of exposed windows and draw menubar */
window = (FrontWindow()) ? FrontWindow() : (WindowPtr) -1L;
PaintBehind(window, drawRgn);
CalcVisBehind(window, drawRgn);
DrawMenuBar();
SetPort(savePort);
gSaveMenuBar = 0;
/* Now show the control strip if it's present */
if (!Gestalt(gestaltControlStripAttr, &response) &&
(response & (1L << gestaltControlStripExists)))
{
if (gSaveCSVis && !SBIsControlStripVisible())
SBShowHideControlStrip(true);
gSaveCSVis = true;
}
/* Yield time so that floaters can catch up */
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
}
CLEANUP:
if (drawRgn) DisposeRgn(drawRgn);
if (menuRgn) DisposeRgn(menuRgn);
if (tempRgn) DisposeRgn(tempRgn);
#endif /* !TARGET_API_MAC_CARBON */
}
static void ROM_HideMenuBar(_THIS)
{
#if !TARGET_API_MAC_CARBON /* This seems not to be available? -sts Aug 2000 */
RgnHandle drawRgn = nil;
RgnHandle tempRgn = nil;
RgnHandle grayRgn = nil;
WindowPtr window = nil;
GDHandle gd = nil;
GrafPtr savePort;
long response;
short height;
EventRecord theEvent;
height = GetMBarHeight();
if ( height > 0 ) {
tempRgn = NewRgn();
drawRgn = NewRgn();
gSaveGrayRgn = NewRgn();
if ( ! tempRgn || ! drawRgn || ! gSaveGrayRgn ) {
goto CLEANUP;
}
grayRgn = GetGrayRgn(); /* No need to check for this */
GetPort(&savePort);
/* Hide the control strip if it's present, and record its
previous position into the dirty region for redrawing.
This isn't necessary, but may help catch stray bits. */
CopyRgn(grayRgn, tempRgn);
if (!Gestalt(gestaltControlStripAttr, &response) &&
(response & (1L << gestaltControlStripExists))) {
gSaveCSVis = SBIsControlStripVisible();
if (gSaveCSVis)
SBShowHideControlStrip(false);
}
DiffRgn(grayRgn, tempRgn, drawRgn);
/* Save the gray region once the control strip is hidden*/
CopyRgn(grayRgn, gSaveGrayRgn);
/* Change the menu height in lowmem */
gSaveMenuBar = height;
LMSetMBarHeight(0);
/* Walk the monitor rectangles, and combine any pieces that
aren't in GrayRgn: menubar, round corners, fake floaters. */
for(gd = GetDeviceList(); gd; gd = GetNextDevice(gd))
{
if (!TestDeviceAttribute(gd, screenDevice)) continue;
if (!TestDeviceAttribute(gd, screenActive)) continue;
RectRgn(tempRgn, &(*gd)->gdRect); /* Get the whole screen */
DiffRgn(tempRgn, grayRgn, tempRgn); /* Subtract out GrayRgn */
UnionRgn(tempRgn, drawRgn, drawRgn);/* Combine all the bits */
}
/* Add the bits into the GrayRgn */
UnionRgn(drawRgn, grayRgn, grayRgn);
/* Modify the vis regions of exposed windows */
window = (FrontWindow()) ? FrontWindow() : (WindowPtr) -1L;
PaintBehind(window, drawRgn);
CalcVisBehind(window, drawRgn);
SetPort(savePort);
/* Yield time so that floaters can catch up */
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
}
CLEANUP:
if (tempRgn) DisposeRgn(tempRgn);
if (drawRgn) DisposeRgn(drawRgn);
#endif /* !TARGET_API_MAC_CARBON */
}