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;
}
}
bool wxTopLevelWindowMac::SetShape(const wxRegion& region)
{
wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
_T("Shaped windows must be created with the wxFRAME_SHAPED style."));
#if TARGET_CARBON
// The empty region signifies that the shape should be removed from the
// window.
if ( region.IsEmpty() )
{
wxSize sz = GetClientSize();
wxRegion rgn(0, 0, sz.x, sz.y);
return SetShape(rgn);
}
// Make a copy of the region
RgnHandle shapeRegion = NewRgn();
CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
// Dispose of any shape region we may already have
RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)MacGetWindowRef() );
if ( oldRgn )
DisposeRgn(oldRgn);
// Save the region so we can use it later
SetWRefCon((WindowRef)MacGetWindowRef(), (SInt32)shapeRegion);
// Tell the window manager that the window has changed shape
ReshapeCustomWindow((WindowRef)MacGetWindowRef());
return TRUE;
#else
return FALSE;
#endif
}
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() ) ;
}
// Create a DC representing the whole screen
wxScreenDC::wxScreenDC()
{
m_macPort = CreateNewPort() ;
GrafPtr port ;
GetPort( &port ) ;
SetPort( (GrafPtr) m_macPort ) ;
Point pt = { 0,0 } ;
LocalToGlobal( &pt ) ;
SetPort( port ) ;
m_macLocalOrigin.x = -pt.h ;
m_macLocalOrigin.y = -pt.v ;
#if wxMAC_USE_CORE_GRAPHICS
m_macLocalOriginInPort = m_macLocalOrigin ;
#endif
BitMap screenBits;
GetQDGlobalsScreenBits( &screenBits );
m_minX = screenBits.bounds.left ;
SInt16 height ;
GetThemeMenuBarHeight( &height ) ;
m_minY = screenBits.bounds.top + height ;
m_maxX = screenBits.bounds.right ;
m_maxY = screenBits.bounds.bottom ;
#if wxMAC_USE_CORE_GRAPHICS
m_graphicContext = new wxMacCGContext( port ) ;
#else
MacSetRectRgn( (RgnHandle) m_macBoundaryClipRgn , m_minX , m_minY , m_maxX , m_maxY ) ;
OffsetRgn( (RgnHandle) m_macBoundaryClipRgn , m_macLocalOrigin.x , m_macLocalOrigin.y ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
#endif
m_ok = TRUE ;
}
pascal OSStatus wxMacSetupControlBackground( ControlRef iControl , SInt16 iMessage , SInt16 iDepth , Boolean iIsColor )
{
OSStatus status = noErr ;
switch( iMessage )
{
case kControlMsgSetUpBackground :
{
wxControl* wx = (wxControl*) GetControlReference( iControl ) ;
if ( wx != NULL && wx->IsKindOf( CLASSINFO( wxControl ) ) )
{
wxDC::MacSetupBackgroundForCurrentPort( wx->MacGetBackgroundBrush() ) ;
#if TARGET_CARBON
// under classic this would lead to partial redraws
RgnHandle clip = NewRgn() ;
int x = 0 , y = 0;
wx->MacWindowToRootWindow( &x,&y ) ;
CopyRgn( (RgnHandle) wx->MacGetVisibleRegion(false).GetWXHRGN() , clip ) ;
OffsetRgn( clip , x , y ) ;
SetClip( clip ) ;
DisposeRgn( clip ) ;
#endif
}
else
{
status = paramErr ;
}
}
break ;
default :
status = paramErr ;
break ;
}
return status ;
}
void myShowMenuBar(void)
{
if (!savedgray)
return;
CopyRgn(savedgray,GetGrayRgn());
LMSetMBarHeight(savedmbh);
DisposeRgn(savedgray);
savedgray=NULL;
}
wxWindowDC::wxWindowDC(wxWindow *window)
{
m_window = window ;
wxTopLevelWindowMac* rootwindow = window->MacGetTopLevelWindow() ;
WindowRef windowref = (WindowRef) rootwindow->MacGetWindowRef() ;
int x , y ;
x = y = 0 ;
window->MacWindowToRootWindow( &x , &y ) ;
m_macLocalOrigin.x = x ;
m_macLocalOrigin.y = y ;
CopyRgn( (RgnHandle) window->MacGetVisibleRegion().GetWXHRGN() , (RgnHandle) m_macBoundaryClipRgn ) ;
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());
}
/* restores former dialog size and (on Mac) position */
bool CDlgItemProperties::RestoreState() {
wxConfigBase* pConfig = wxConfigBase::Get(FALSE);
int iWidth, iHeight;
wxASSERT(pConfig);
if (!pConfig) return false;
pConfig->SetPath(m_strBaseConfigLocation);
pConfig->Read(wxT("Width"), &iWidth, wxDefaultCoord);
pConfig->Read(wxT("Height"), &iHeight, wxDefaultCoord);
#ifndef __WXMAC__
// Set size to saved values or defaults if no saved values
SetSize(iWidth, iHeight);
#else
int iTop, iLeft;
pConfig->Read(wxT("YPos"), &iTop, wxDefaultCoord);
pConfig->Read(wxT("XPos"), &iLeft, wxDefaultCoord);
// If either co-ordinate is less then 0 then set it equal to 0 to ensure
// it displays on the screen.
if ((iLeft < 0) && (iLeft != wxDefaultCoord)) iLeft = 30;
if ((iTop < 0) && (iTop != wxDefaultCoord)) iTop = 30;
// Set size and position to saved values or defaults if no saved values
SetSize(iLeft, iTop, iWidth, iHeight, wxSIZE_USE_EXISTING);
// Now make sure window is on screen
GetScreenPosition(&iLeft, &iTop);
GetSize(&iWidth, &iHeight);
Rect titleRect = {iTop, iLeft, iTop+22, iLeft+iWidth };
InsetRect(&titleRect, 5, 5); // Make sure at least a 5X5 piece visible
RgnHandle displayRgn = NewRgn();
CopyRgn(GetGrayRgn(), displayRgn); // Region encompassing all displays
Rect menuRect = ((**GetMainDevice())).gdRect;
menuRect.bottom = GetMBarHeight() + menuRect.top;
RgnHandle menuRgn = NewRgn();
RectRgn(menuRgn, &menuRect); // Region hidden by menu bar
DiffRgn(displayRgn, menuRgn, displayRgn); // Subtract menu bar region
if (!RectInRgn(&titleRect, displayRgn)) {
iTop = iLeft = 30;
SetSize(iLeft, iTop, iWidth, iHeight, wxSIZE_USE_EXISTING);
}
DisposeRgn(menuRgn);
DisposeRgn(displayRgn);
#endif
return true;
}
void CDlgMessages::RestoreWindowDimensions() {
wxString strBaseConfigLocation = wxString(wxT("/Simple/Messages"));
wxConfigBase* pConfig = wxConfigBase::Get(FALSE);
bool bWindowIconized = false;
bool bWindowMaximized = false;
int iHeight = 0;
int iWidth = 0;
int iTop = 0;
int iLeft = 0;
wxASSERT(pConfig);
pConfig->SetPath(strBaseConfigLocation);
pConfig->Read(wxT("YPos"), &iTop, 30);
pConfig->Read(wxT("XPos"), &iLeft, 30);
pConfig->Read(wxT("Width"), &iWidth, 640);
pConfig->Read(wxT("Height"), &iHeight, 480);
pConfig->Read(wxT("WindowIconized"), &bWindowIconized, false);
pConfig->Read(wxT("WindowMaximized"), &bWindowMaximized, false);
#ifndef __WXMAC__
Iconize(bWindowIconized);
Maximize(bWindowMaximized);
if (!IsIconized() && !IsMaximized()) {
SetSize(-1, -1, iWidth, iHeight);
}
#else // ! __WXMAC__
// If the user has changed the arrangement of multiple
// displays, make sure the window title bar is still on-screen.
Rect titleRect = {iTop, iLeft, iTop+22, iLeft+iWidth };
InsetRect(&titleRect, 5, 5); // Make sure at least a 5X5 piece visible
RgnHandle displayRgn = NewRgn();
CopyRgn(GetGrayRgn(), displayRgn); // Region encompassing all displays
Rect menuRect = ((**GetMainDevice())).gdRect;
menuRect.bottom = GetMBarHeight() + menuRect.top;
RgnHandle menuRgn = NewRgn();
RectRgn(menuRgn, &menuRect); // Region hidden by menu bar
DiffRgn(displayRgn, menuRgn, displayRgn); // Subtract menu bar retion
if (!RectInRgn(&titleRect, displayRgn))
iTop = iLeft = 30;
DisposeRgn(menuRgn);
DisposeRgn(displayRgn);
SetSize(iLeft, iTop, iWidth, iHeight);
#endif // ! __WXMAC__
}
// The structure region is set to the shape given to the SetShape method.
static void wxShapedMacWindowStructureRegion(WindowRef window, RgnHandle rgn)
{
RgnHandle cachedRegion = (RgnHandle) GetWRefCon(window);
SetEmptyRgn(rgn);
if (cachedRegion)
{
Rect windowRect;
wxShapedMacWindowGetPos(window, &windowRect); //how big is the window
CopyRgn(cachedRegion, rgn); //make a copy of our cached region
OffsetRgn(rgn, windowRect.left, windowRect.top); // position it over window
//MapRgn(rgn, &mMaskSize, &windowRect); //scale it to our actual window size
}
}
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;
}
}
/*
* 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
}
}
}
// Create a DC representing the whole screen
wxScreenDC::wxScreenDC()
{
#if wxMAC_USE_CORE_GRAPHICS
CGRect cgbounds ;
cgbounds = CGDisplayBounds(CGMainDisplayID());
Rect bounds;
bounds.top = (short)cgbounds.origin.y;
bounds.left = (short)cgbounds.origin.x;
bounds.bottom = bounds.top + (short)cgbounds.size.height;
bounds.right = bounds.left + (short)cgbounds.size.width;
WindowAttributes overlayAttributes = kWindowIgnoreClicksAttribute;
CreateNewWindow( kOverlayWindowClass, overlayAttributes, &bounds, (WindowRef*) &m_overlayWindow );
ShowWindow((WindowRef)m_overlayWindow);
SetGraphicsContext( wxGraphicsContext::CreateFromNativeWindow( m_overlayWindow ) );
m_width = (wxCoord)cgbounds.size.width;
m_height = (wxCoord)cgbounds.size.height;
#else
m_macPort = CreateNewPort() ;
GrafPtr port ;
GetPort( &port ) ;
SetPort( (GrafPtr) m_macPort ) ;
Point pt = { 0,0 } ;
LocalToGlobal( &pt ) ;
SetPort( port ) ;
m_macLocalOrigin.x = -pt.h ;
m_macLocalOrigin.y = -pt.v ;
BitMap screenBits;
GetQDGlobalsScreenBits( &screenBits );
m_minX = screenBits.bounds.left ;
SInt16 height ;
GetThemeMenuBarHeight( &height ) ;
m_minY = screenBits.bounds.top + height ;
m_maxX = screenBits.bounds.right ;
m_maxY = screenBits.bounds.bottom ;
MacSetRectRgn( (RgnHandle) m_macBoundaryClipRgn , m_minX , m_minY , m_maxX , m_maxY ) ;
OffsetRgn( (RgnHandle) m_macBoundaryClipRgn , m_macLocalOrigin.x , m_macLocalOrigin.y ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
#endif
m_ok = true ;
}
void
TkMacSetUpClippingRgn(
Drawable drawable) /* Drawable to update. */
{
MacDrawable *macDraw = (MacDrawable *) drawable;
if (macDraw->winPtr != NULL) {
if (macDraw->flags & TK_CLIP_INVALID) {
TkMacUpdateClipRgn(macDraw->winPtr);
}
/*
* When a menu is up, the Mac does not expect drawing to occur and
* does not clip out the menu. We have to do it ourselves. This
* is pretty gross.
*/
if (macDraw->clipRgn != NULL) {
if (tkUseMenuCascadeRgn == 1) {
Point scratch = {0, 0};
GDHandle saveDevice;
GWorldPtr saveWorld;
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(TkMacGetDrawablePort(drawable), NULL);
LocalToGlobal(&scratch);
SetGWorld(saveWorld, saveDevice);
if (tmpRgn == NULL) {
tmpRgn = NewRgn();
}
CopyRgn(tkMenuCascadeRgn, tmpRgn);
OffsetRgn(tmpRgn, -scratch.h, -scratch.v);
DiffRgn(macDraw->clipRgn, tmpRgn, tmpRgn);
SetClip(tmpRgn);
macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
} else {
SetClip(macDraw->clipRgn);
}
}
}
}
wxMetaFileDC::wxMetaFileDC(const wxString& filename ,
int width , int height ,
const wxString& WXUNUSED(description) )
{
wxASSERT_MSG( width == 0 || height == 0 , _T("no arbitration of metafilesize supported") ) ;
wxASSERT_MSG( filename.empty() , _T("no file based metafile support yet")) ;
m_metaFile = new wxMetaFile(filename) ;
#if wxMAC_USE_CORE_GRAPHICS
#else
Rect r={0,0,height,width} ;
RectRgn( (RgnHandle) m_macBoundaryClipRgn , &r ) ;
CopyRgn( (RgnHandle) m_macBoundaryClipRgn , (RgnHandle) m_macCurrentClipRgn ) ;
m_metaFile->SetHMETAFILE( (WXHMETAFILE) OpenPicture( &r ) ) ;
::GetPort( (GrafPtr*) &m_macPort ) ;
m_ok = true ;
#endif
SetMapMode(wxMM_TEXT);
}
RgnHandle getWindowStructureRegion(WindowRef window, RgnHandle structureRegion)
{
/*------------------------------------------------------
Define the structural region of our window.
--------------------------------------------------------*/
static RgnHandle pictureRgn=NULL;
static Rect pictureRect;
Rect windowRect;
SetEmptyRgn(structureRegion);
if(!pictureRgn){//haven't Cached our region yet
PicHandle myPicture=GetPicture(kMaskPictureID);
GrafPtr origPort;
GDHandle origDev;
GWorldPtr pictMask;
PixMapHandle maskBitMap;
GetGWorld(&origPort,&origDev);
pictureRgn=NewRgn();
pictureRect=(*myPicture)->picFrame;
NewGWorld(&pictMask,1,&pictureRect,NULL,NULL,0);
maskBitMap=GetPortPixMap(pictMask);
LockPixels(maskBitMap);
SetGWorld(pictMask,NULL);
EraseRect(&pictureRect);
DrawPicture(myPicture,&pictureRect);
BitMapToRegion(pictureRgn,(BitMap*)*maskBitMap);//use the mask to create a region
InsetRgn(pictureRgn,1,1);
SetGWorld(origPort,origDev);
UnlockPixels(maskBitMap);
DisposeGWorld(pictMask);
ReleaseResource((Handle)myPicture);
}
getCurrentPortBounds(&windowRect);//how big is the window
CopyRgn(pictureRgn,structureRegion);//make a copy of our cached region
MapRgn(structureRegion,&pictureRect,&windowRect);//scale it to our actual window size
return structureRegion;
}
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);
}
wxRegionRefData(const wxRegionRefData& data)
: wxGDIRefData()
{
m_macRgn = NewRgn();
CopyRgn( data.m_macRgn , m_macRgn );
}
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;
}
}
HRGN GetNCUpdateRgn(
PWND pwnd,
BOOL fValidateFrame)
{
HRGN hrgnUpdate;
if (pwnd->hrgnUpdate > HRGN_FULL) {
/*
* We must make a copy of our update region, because
* it could change if we send a message, and we want to
* make sure the whole thing is used for drawing our
* frame and background. We can't use a global
* temporary region, because more than one app may
* be calling this routine.
*/
hrgnUpdate = CreateEmptyRgnPublic();
if (hrgnUpdate == NULL) {
hrgnUpdate = HRGN_FULL;
} else if (CopyRgn(hrgnUpdate, pwnd->hrgnUpdate) == ERROR) {
GreDeleteObject(hrgnUpdate);
hrgnUpdate = HRGN_FULL;
}
if (fValidateFrame) {
/*
* Now that we've taken care of any frame drawing,
* intersect the update region with the window's
* client area. Otherwise, apps that do ValidateRects()
* to draw themselves (e.g., WinWord) won't ever
* subtract off the part of the update region that
* overlaps the frame but not the client.
*/
CalcWindowRgn(pwnd, ghrgnInv2, TRUE);
switch (IntersectRgn(pwnd->hrgnUpdate,
pwnd->hrgnUpdate,
ghrgnInv2)) {
case ERROR:
/*
* If an error occured, we can't leave things as
* they are: invalidate the whole window and let
* BeginPaint() take care of it.
*/
GreDeleteObject(pwnd->hrgnUpdate);
pwnd->hrgnUpdate = HRGN_FULL;
break;
case NULLREGION:
/*
* There is nothing in the client area to repaint.
* Blow the region away, and decrement the paint count
* if possible.
*/
GreDeleteObject(pwnd->hrgnUpdate);
pwnd->hrgnUpdate = NULL;
ClrWF(pwnd, WFUPDATEDIRTY);
if (!TestWF(pwnd, WFINTERNALPAINT))
DecPaintCount(pwnd);
break;
}
}
} else {
hrgnUpdate = pwnd->hrgnUpdate;
}
return hrgnUpdate;
}
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 */
}
bool CDlgEventLog::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
////@begin CDlgEventLog member initialisation
m_iPreviousRowCount = 0;
m_iTotalDocCount = 0;
m_iPreviousTotalDocCount = 0;
if (!s_bIsFiltered) {
s_strFilteredProjectName.clear();
}
m_iFilteredIndexes.Clear();
m_bProcessingRefreshEvent = false;
m_bEventLogIsOpen = true;
////@end CDlgEventLog member initialisation
CSkinAdvanced* pSkinAdvanced = wxGetApp().GetSkinManager()->GetAdvanced();
wxPoint oTempPoint;
wxSize oTempSize;
wxASSERT(pSkinAdvanced);
wxASSERT(wxDynamicCast(pSkinAdvanced, CSkinAdvanced));
if ((pos == wxDefaultPosition) && (size == wxDefaultSize)) {
// Get size and position from the previous configuration
GetWindowDimensions( oTempPoint, oTempSize );
#ifdef __WXMSW__
// Windows does some crazy things if the initial position is a negative
// value.
oTempPoint.x = wxDefaultCoord;
oTempPoint.y = wxDefaultCoord;
#endif
#ifdef __WXMAC__
// If the user has changed the arrangement of multiple
// displays, make sure the window title bar is still on-screen.
Rect titleRect = {oTempPoint.y, oTempPoint.x, oTempPoint.y+22, oTempPoint.x+oTempSize.x };
InsetRect(&titleRect, 5, 5); // Make sure at least a 5X5 piece visible
RgnHandle displayRgn = NewRgn();
CopyRgn(GetGrayRgn(), displayRgn); // Region encompassing all displays
Rect menuRect = ((**GetMainDevice())).gdRect;
menuRect.bottom = GetMBarHeight() + menuRect.top;
RgnHandle menuRgn = NewRgn();
RectRgn(menuRgn, &menuRect); // Region hidden by menu bar
DiffRgn(displayRgn, menuRgn, displayRgn); // Subtract menu bar retion
if (!RectInRgn(&titleRect, displayRgn))
oTempPoint.y = oTempPoint.x = 30;
DisposeRgn(menuRgn);
DisposeRgn(displayRgn);
#endif // ! __WXMAC__
} else {
oTempPoint = pos;
oTempSize = size;
}
wxDialog::Create( parent, id, caption, oTempPoint, oTempSize, style );
SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS);
// Initialize Application Title
wxString strCaption = caption;
if (strCaption.IsEmpty()) {
strCaption.Printf(_("%s - Event Log"), pSkinAdvanced->GetApplicationName().c_str());
}
SetTitle(strCaption);
// Initialize Application Icon
wxIconBundle icons;
icons.AddIcon(*pSkinAdvanced->GetApplicationIcon());
icons.AddIcon(*pSkinAdvanced->GetApplicationIcon32());
SetIcons(icons);
CreateControls();
// Create List Pane Items
m_pList->InsertColumn(COLUMN_PROJECT, _("Project"), wxLIST_FORMAT_LEFT, 109);
m_pList->InsertColumn(COLUMN_TIME, _("Time"), wxLIST_FORMAT_LEFT, 130);
m_pList->InsertColumn(COLUMN_MESSAGE, _("Message"), wxLIST_FORMAT_LEFT, 378);
m_pMessageInfoAttr = new wxListItemAttr(
wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT),
wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW),
wxNullFont
);
m_pMessageErrorAttr = new wxListItemAttr(
*wxRED,
wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW),
wxNullFont
);
#if EVENT_LOG_STRIPES
m_pMessageInfoGrayAttr = new wxListItemAttr(
wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT),
wxColour(240, 240, 240),
wxNullFont
);
m_pMessageErrorGrayAttr = new wxListItemAttr(*wxRED, wxColour(240, 240, 240), wxNullFont);
#else
m_pMessageInfoGrayAttr = new wxListItemAttr(*m_pMessageInfoAttr);
m_pMessageErrorGrayAttr = new wxListItemAttr(*m_pMessageErrorAttr);
#endif
SetTextColor();
RestoreState();
return true;
}
bool wxSkinWindow::SetShape(const wxRegion& region)
{
#if defined(__WXMSW__) && !defined(__WXWINCE__)
// The empty region signifies that the shape should be removed from the
// window.
if ( region.IsEmpty() )
{
if (::SetWindowRgn(GetHwnd(), NULL, TRUE) == 0)
{
wxLogLastError(_T("SetWindowRgn"));
return false;
}
return true;
}
DWORD noBytes = ::GetRegionData(GetHrgnOf(region), 0, NULL);
RGNDATA *rgnData = (RGNDATA*) new char[noBytes];
::GetRegionData(GetHrgnOf(region), noBytes, rgnData);
HRGN hrgn = ::ExtCreateRegion(NULL, noBytes, rgnData);
delete[] (char*) rgnData;
RECT rect;
DWORD dwStyle = ::GetWindowLong(GetHwnd(), GWL_STYLE);
DWORD dwExStyle = ::GetWindowLong(GetHwnd(), GWL_EXSTYLE);
::GetClientRect(GetHwnd(), &rect);
::AdjustWindowRectEx(&rect, dwStyle, FALSE, dwExStyle);
::OffsetRgn(hrgn, -rect.left, -rect.top);
if (::SetWindowRgn(GetHwnd(), hrgn, TRUE) == 0)
{
wxLogLastError(_T("SetWindowRgn"));
return false;
}
return true;
#elif defined(__WXMAC__)
if ( region.IsEmpty() )
{
wxSize sz = GetClientSize();
wxRegion rgn(0, 0, sz.x, sz.y);
return SetShape(rgn);
}
// Make a copy of the region
RgnHandle shapeRegion = NewRgn();
CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
// Dispose of any shape region we may already have
RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)GetHandle() );
if ( oldRgn )
DisposeRgn(oldRgn);
// Save the region so we can use it later
SetWRefCon((WindowRef)GetHandle(), (SInt32)shapeRegion);
// Tell the window manager that the window has changed shape
ReshapeCustomWindow((WindowRef)GetHandle());
return true;
#elif defined(__WXGTK__)
if(region.IsEmpty())
{
if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow))
gtk_widget_shape_combine_mask(m_wxwindow,NULL,0,0);
if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget))
gtk_widget_shape_combine_mask(m_widget,NULL,0,0);
}
else
{ wxBitmap bmp = region.ConvertToBitmap();
bmp.SetMask(new wxMask(bmp, *wxBLACK));
GdkBitmap* mask = bmp.GetMask()->GetBitmap();
if(m_wxwindow && !GTK_WIDGET_NO_WINDOW(m_wxwindow))
gtk_widget_shape_combine_mask(m_wxwindow,mask,0,0);
if(m_widget && !GTK_WIDGET_NO_WINDOW(m_widget))
gtk_widget_shape_combine_mask(m_widget,mask,0,0);
}
return true;
#else
return false;
#endif
}
int CImageRegion::SetRegion(CRgn rgn)
{
DeleteObject();
return CopyRgn(&rgn);
}
bool CBOINCGUIApp::SetActiveGUI(int iGUISelection, bool bShowWindow) {
CBOINCBaseFrame* pNewFrame = NULL;
CBOINCBaseFrame* pOldFrame = m_pFrame;
wxInt32 iTop = 0;
wxInt32 iLeft = 0;
wxInt32 iHeight = 0;
wxInt32 iWidth = 0;
// Create the new window
if ((iGUISelection != m_iGUISelected) || !m_pFrame) {
// Reterieve the desired window state before creating the
// desired frames
if (BOINC_ADVANCEDGUI == iGUISelection) {
m_pConfig->SetPath(wxT("/"));
m_pConfig->Read(wxT("YPos"), &iTop, 30);
m_pConfig->Read(wxT("XPos"), &iLeft, 30);
m_pConfig->Read(wxT("Width"), &iWidth, 800);
m_pConfig->Read(wxT("Height"), &iHeight, 600);
} else {
m_pConfig->SetPath(wxT("/Simple"));
m_pConfig->Read(wxT("YPos"), &iTop, 30);
m_pConfig->Read(wxT("XPos"), &iLeft, 30);
#ifdef __WXMAC__
m_pConfig->Read(wxT("Width"), &iWidth, 409);
m_pConfig->Read(wxT("Height"), &iHeight, 561);
#else
m_pConfig->Read(wxT("Width"), &iWidth, 416);
m_pConfig->Read(wxT("Height"), &iHeight, 570);
#endif
}
// Make sure that the new window is going to be visible
// on a screen
#ifdef __WXMAC__
Rect titleRect = {iTop, iLeft, iTop+22, iLeft+iWidth };
InsetRect(&titleRect, 5, 5); // Make sure at least a 5X5 piece visible
RgnHandle displayRgn = NewRgn();
CopyRgn(GetGrayRgn(), displayRgn); // Region encompassing all displays
Rect menuRect = ((**GetMainDevice())).gdRect;
menuRect.bottom = GetMBarHeight() + menuRect.top;
RgnHandle menuRgn = NewRgn();
RectRgn(menuRgn, &menuRect); // Region hidden by menu bar
DiffRgn(displayRgn, menuRgn, displayRgn); // Subtract menu bar retion
if (!RectInRgn(&titleRect, displayRgn))
iTop = iLeft = 30;
DisposeRgn(menuRgn);
DisposeRgn(displayRgn);
#else
// If either co-ordinate is less then 0 then set it equal to 0 to ensure
// it displays on the screen.
if ( iLeft < 0 ) iLeft = 30;
if ( iTop < 0 ) iTop = 30;
// Read the size of the screen
wxInt32 iMaxWidth = wxSystemSettings::GetMetric( wxSYS_SCREEN_X );
wxInt32 iMaxHeight = wxSystemSettings::GetMetric( wxSYS_SCREEN_Y );
// Max sure that it doesn't go off to the right or bottom
if ( iLeft + iWidth > iMaxWidth ) iLeft = iMaxWidth - iWidth;
if ( iTop + iHeight > iMaxHeight ) iTop = iMaxHeight - iHeight;
#endif
// Create the main window
//
if (BOINC_ADVANCEDGUI == iGUISelection) {
// Initialize the advanced gui window
pNewFrame = new CAdvancedFrame(
m_pSkinManager->GetAdvanced()->GetApplicationName(),
m_pSkinManager->GetAdvanced()->GetApplicationIcon(),
m_pSkinManager->GetAdvanced()->GetApplicationIcon32(),
wxPoint(iLeft, iTop),
wxSize(iWidth, iHeight)
);
} else {
// Initialize the simple gui window
pNewFrame = new CSimpleFrame(
m_pSkinManager->GetAdvanced()->GetApplicationName(),
m_pSkinManager->GetAdvanced()->GetApplicationIcon(),
m_pSkinManager->GetAdvanced()->GetApplicationIcon32(),
wxPoint(iLeft, iTop),
wxSize(iWidth, iHeight)
);
}
wxASSERT(pNewFrame);
if (pNewFrame) {
SetTopWindow(pNewFrame);
// Store the new frame for future use
m_pFrame = pNewFrame;
// Hide the old one if it exists. We must do this
// after updating m_pFrame to prevent Mac OSX from
// hiding the application
if (pOldFrame) pOldFrame->Hide();
// Delete the old one if it exists
// Note: this has the side effect of hiding the Event Log
if (pOldFrame) pOldFrame->Destroy();
// Show the new frame if needed (and show the Event Log if open)
if (pNewFrame && bShowWindow) pNewFrame->Show();
}
}
// Show the new frame if needed
if (m_pFrame && bShowWindow) {
if (m_pEventLog) {
m_pEventLog->Show();
m_pEventLog->Raise();
#ifdef __WXMSW__
::SetForegroundWindow((HWND)m_pEventLog->GetHWND());
#endif
}
if (!m_pFrame->IsShown()) {
m_pFrame->Show();
}
m_pFrame->Raise();
#ifdef __WXMSW__
::SetForegroundWindow((HWND)m_pFrame->GetHWND());
#endif
}
m_iGUISelected = iGUISelection;
m_pConfig->SetPath(wxT("/"));
m_pConfig->Write(wxT("GUISelection"), iGUISelection);
return true;
}
OSStatus HIRevolutionStackViewHandler(EventHandlerCallRef p_call_ref, EventRef p_event, void *p_data)
{
OSStatus t_status;
t_status = eventNotHandledErr;
UInt32 t_event_class;
t_event_class = GetEventClass(p_event);
UInt32 t_event_kind;
t_event_kind = GetEventKind(p_event);
HIRevolutionStackViewData *t_context;
t_context = (HIRevolutionStackViewData *)p_data;
switch(t_event_class)
{
case 'revo':
switch(t_event_kind)
{
case 'rlnk':
GetEventParameter(p_event, 'Stak', typeVoidPtr, NULL, sizeof(void *), NULL, &t_context -> stack);
break;
}
break;
case kEventClassHIObject:
switch(t_event_kind)
{
case kEventHIObjectConstruct:
{
HIRevolutionStackViewData *t_data;
t_data = new HIRevolutionStackViewData;
t_data -> stack = NULL;
GetEventParameter(p_event, kEventParamHIObjectInstance, typeHIObjectRef, NULL, sizeof(HIObjectRef), NULL, (HIObjectRef *)&t_data -> view);
SetEventParameter(p_event, kEventParamHIObjectInstance, typeVoidPtr, sizeof(HIRevolutionStackViewData *), &t_data);
t_status = noErr;
}
break;
case kEventHIObjectInitialize:
{
GetEventParameter(p_event, 'Stak', typeVoidPtr, NULL, sizeof(void *), NULL, &t_context -> stack);
Rect t_bounds;
t_bounds . left = 0;
// MW-2011-09-12: [[ MacScroll ]] Make sure the top of the HIView takes into
// account the scroll.
t_bounds . top = -t_context -> stack -> getscroll();
t_bounds . right = t_context -> stack -> getrect() . width;
t_bounds . bottom = t_context -> stack -> getrect() . height;
SetControlBounds((ControlRef)t_context -> view, &t_bounds);
t_status = noErr;
}
break;
case kEventHIObjectDestruct:
{
delete t_context;
t_status = noErr;
}
break;
}
break;
case kEventClassControl:
switch(t_event_kind)
{
case kEventControlInitialize:
{
t_status = noErr;
}
break;
case kEventControlDraw:
{
CGContextRef t_graphics;
GetEventParameter(p_event, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(CGContextRef), NULL, &t_graphics);
RgnHandle t_dirty_rgn;
GetEventParameter(p_event, kEventParamRgnHandle, typeQDRgnHandle, NULL, sizeof(RgnHandle), NULL, &t_dirty_rgn);
if (t_context -> stack != NULL)
{
// Compute the clip region for players.
RgnHandle t_clip_rgn, t_rect_rgn;
t_clip_rgn = NULL;
t_rect_rgn = NULL;
for(MCPlayer *t_player = MCplayers; t_player != NULL; t_player = t_player -> getnextplayer())
if (t_player -> isvisible() && t_player -> getcard() == t_context -> stack -> getcurcard() && !t_player -> isbuffering())
{
MCRectangle t_rect;
Rect t_mac_rect;
t_rect = t_player -> getactiverect();
if (t_clip_rgn == NULL)
{
t_clip_rgn = NewRgn();
CopyRgn((RgnHandle)t_dirty_rgn, t_clip_rgn);
t_rect_rgn = NewRgn();
}
SetRect(&t_mac_rect, t_rect . x, t_rect . y, t_rect . x + t_rect . width, t_rect . y + t_rect . height);
RectRgn(t_rect_rgn, &t_mac_rect);
DiffRgn(t_clip_rgn, t_rect_rgn, t_clip_rgn);
}
// We don't need the rect rgn anymore.
if (t_rect_rgn != NULL)
DisposeRgn(t_rect_rgn);
// If the clip region is non-nil, then apply it.
if (t_clip_rgn != NULL)
{
// As we can't clip to empty path, if the region is empty, we set the context
// to nil.
if (!EmptyRgn(t_clip_rgn))
{
HIShapeRef t_shape;
t_shape = HIShapeCreateWithQDRgn(t_clip_rgn);
HIShapeReplacePathInCGContext(t_shape, t_graphics);
CGContextClip(t_graphics);
CFRelease(t_shape);
}
else
t_graphics = nil;
DisposeRgn(t_clip_rgn);
}
// If the graphics context is non-nil (i.e. we aren't completely occluded) then
// draw something.
if (t_graphics != nil)
{
// HIView gives us a context in top-left origin mode which isn't so good
// for our CG rendering so, revert back to bottom-left.
CGContextScaleCTM(t_graphics, 1.0, -1.0);
CGContextTranslateCTM(t_graphics, 0.0, -t_context -> stack -> getcurcard() -> getrect() . height);
// Save the context state
CGContextSaveGState(t_graphics);
// If we don't have an update pixmap, then use redrawwindow.
if (s_update_pixmap == nil)
{
MCMacStackSurface t_surface(t_context -> stack, (MCRegionRef)t_dirty_rgn, t_graphics);
t_context -> stack -> redrawwindow(&t_surface, (MCRegionRef)t_dirty_rgn);
}
else
{
int32_t t_height;
t_height = t_context -> stack -> getcurcard() -> getrect() . height;
MCRectangle t_rect;
t_rect = MCRegionGetBoundingBox((MCRegionRef)t_dirty_rgn);
CGRect t_area;
t_area = CGRectMake(t_rect . x, t_height - (t_rect . y + t_rect . height), t_rect . width, t_rect . height);
CGContextClearRect(t_graphics, t_area);
void *t_bits;
uint32_t t_stride;
MCscreen -> lockpixmap(s_update_pixmap, t_bits, t_stride);
MCMacRenderBitsToCG(t_graphics, t_area, t_bits, t_stride, t_context -> stack -> getwindowshape() != nil ? true : false);
MCscreen -> unlockpixmap(s_update_pixmap, t_bits, t_stride);
}
// Restore the context state
CGContextRestoreGState(t_graphics);
}
// MW-2011-11-23: [[ Bug ]] Force a redraw of the players on the stack
// after we've drawn the rest of the content. This ensures players
// which are just appearing don't disappear behind said content.
for(MCPlayer *t_player = MCplayers; t_player != NULL; t_player = t_player -> getnextplayer())
if (t_player -> isvisible() && t_player -> getcard() == t_context -> stack -> getcurcard() && !t_player -> isbuffering())
MCDoAction((MovieController)t_player -> getMovieController(), mcActionDraw, t_context -> stack -> getqtwindow());
}
t_status = noErr;
}
break;
case kEventControlHitTest:
break;
case kEventControlGetPartRegion:
{
ControlPartCode t_part;
GetEventParameter(p_event, kEventParamControlPart, typeControlPartCode, NULL, sizeof(ControlPartCode), NULL, &t_part);
RgnHandle t_region;
GetEventParameter(p_event, kEventParamControlRegion, typeQDRgnHandle, NULL, sizeof(RgnHandle), NULL, &t_region);
}
break;
case kEventControlHiliteChanged:
break;
case kEventControlActivate:
break;
case kEventControlDeactivate:
break;
}
break;
}
return t_status;
}
int
TkScrollWindow(
Tk_Window tkwin, /* The window to be scrolled. */
GC gc, /* GC for window to be scrolled. */
int x, /* Position rectangle to be scrolled. */
int y,
int width,
int height,
int dx, /* Distance rectangle should be moved. */
int dy,
TkRegion damageRgn) /* Region to accumulate damage in. */
{
MacDrawable *destDraw = (MacDrawable *) Tk_WindowId(tkwin);
RgnHandle rgn = (RgnHandle) damageRgn;
CGrafPtr saveWorld;
GDHandle saveDevice;
GWorldPtr destPort;
Rect srcRect, scrollRect;
destPort = TkMacGetDrawablePort(Tk_WindowId(tkwin));
GetGWorld(&saveWorld, &saveDevice);
SetGWorld(destPort, NULL);
TkMacSetUpClippingRgn(Tk_WindowId(tkwin));
/*
* Due to the implementation below the behavior may be differnt
* than X in certain cases that should never occur in Tk. The
* scrollRect is the source rect extended by the offset (the union
* of the source rect and the offset rect). Everything
* in the extended scrollRect is scrolled. On X, it's possible
* to "skip" over an area if the offset makes the source and
* destination rects disjoint and non-aligned.
*/
SetRect(&srcRect, (short) (destDraw->xOff + x),
(short) (destDraw->yOff + y),
(short) (destDraw->xOff + x + width),
(short) (destDraw->yOff + y + height));
scrollRect = srcRect;
if (dx < 0) {
scrollRect.left += dx;
} else {
scrollRect.right += dx;
}
if (dy < 0) {
scrollRect.top += dy;
} else {
scrollRect.bottom += dy;
}
/*
* Adjust clip region so that we don't copy any windows
* that may overlap us.
*/
RectRgn(rgn, &srcRect);
DiffRgn(rgn, destPort->visRgn, rgn);
OffsetRgn(rgn, dx, dy);
DiffRgn(destPort->clipRgn, rgn, destPort->clipRgn);
SetEmptyRgn(rgn);
/*
* When a menu is up, the Mac does not expect drawing to occur and
* does not clip out the menu. We have to do it ourselves. This
* is pretty gross.
*/
if (tkUseMenuCascadeRgn == 1) {
Point scratch = {0, 0};
MacDrawable *macDraw = (MacDrawable *) Tk_WindowId(tkwin);
LocalToGlobal(&scratch);
CopyRgn(tkMenuCascadeRgn, rgn);
OffsetRgn(rgn, -scratch.h, -scratch.v);
DiffRgn(destPort->clipRgn, rgn, destPort->clipRgn);
SetEmptyRgn(rgn);
macDraw->toplevel->flags |= TK_DRAWN_UNDER_MENU;
}
ScrollRect(&scrollRect, dx, dy, rgn);
SetGWorld(saveWorld, saveDevice);
/*
* Fortunantly, the region returned by ScrollRect is symanticlly
* the same as what we need to return in this function. If the
* region is empty we return zero to denote that no damage was
* created.
*/
if (EmptyRgn(rgn)) {
return 0;
} else {
return 1;
}
}
void shellupdatecontent (Rect contentrect) {
/*
update the portion of contectrect in shellwindow that needs updating,
and validate the area updated
2/11/91 dmb: it turns out that we usually want to update the scroll
bars at this time too, before redrawing contectrect
12/9/91 dmb: quick bail-out if update rgn is empty
9/22/92 dmb: don't draw scrollbars when update rgn is empty
*/
register hdlwindowinfo hw = shellwindowinfo;
register hdlregion contentrgn, updatergn;
hdlregion actualupdatergn;
actualupdatergn = getupdateregion (shellwindow);
if (EmptyRgn (actualupdatergn)) {
#ifdef WIN95VERSION
DeleteObject (actualupdatergn);
#endif
return;
}
shellupdatescrollbars (hw);
updatergn = NewRgn ();
CopyRgn (actualupdatergn, updatergn); /*window's update rgn is global*/
globaltolocalrgn (updatergn);
#ifdef MACVERSION
RectRgn (contentrgn = NewRgn (), &contentrect);
#if ACCESSOR_CALLS_ARE_FUNCTIONS == 1
//in carbon a copy of the update region is returned.
DisposeRgn(actualupdatergn);
actualupdatergn = nil;
#endif
#endif
#ifdef WIN95VERSION
DeleteObject (actualupdatergn);
insetrect (&contentrect, -1, -1);
contentrgn = CreateRectRgn (contentrect.left, contentrect.top, contentrect.right, contentrect.bottom);
#endif
SectRgn (contentrgn, updatergn, contentrgn); /*re-use contentrgn*/
#if defined(WIN95VERSION) && fldebug
/****** DEBUG CODE *********/
if (false) {
RECT rrr;
GetClientRect (shellwindow, &rrr);
DeleteObject(contentrgn);
contentrgn = CreateRectRgn (rrr.left, rrr.top, rrr.right, rrr.bottom);
FillRect (getport(), &rrr, GetStockObject (WHITE_BRUSH));
}
#endif
if (!EmptyRgn (contentrgn)) {
(**hw).drawrgn = contentrgn; /*for display routines to refer to*/
//Code change by Timothy Paustian Monday, June 19, 2000 3:09:46 PM
//Changed to Opaque call for Carbon
#ifdef MACVERSION
#if TARGET_API_MAC_CARBON == 1
ValidWindowRgn((WindowRef) hw, contentrgn);
#else
ValidRgn (contentrgn); /*no need to draw it again. do now to simulate beginupdate*/
#endif
#endif
#ifdef WIN95VERSION
ValidateRgn (shellwindow, contentrgn);
#endif
pushcliprgn (contentrgn, false);
(*shellglobals.updateroutine) ();
popclip ();
(**hw).drawrgn = nil; /*keep it neat, this guy is a temp*/
}
DisposeRgn (updatergn);
DisposeRgn (contentrgn);
} /*shellupdatecontent*/