/*
* 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
}
}
}
bool MCRegionExcludeRect(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);
DiffRgn((RgnHandle)self, t_rect_rgn, (RgnHandle)self);
DisposeRgn(t_rect_rgn);
return true;
}
void
TkSubtractRegion(
TkRegion sra,
TkRegion srb,
TkRegion dr_return)
{
RgnHandle srcRgnA = (RgnHandle) sra;
RgnHandle srcRgnB = (RgnHandle) srb;
RgnHandle destRgn = (RgnHandle) dr_return;
DiffRgn(srcRgnA, srcRgnB, destRgn);
}
/* 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__
}
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 wxTopLevelWindowMac::MacUpdate( long timestamp)
{
wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
RgnHandle visRgn = NewRgn() ;
GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), visRgn );
BeginUpdate( (WindowRef)m_macWindow ) ;
RgnHandle updateRgn = NewRgn();
RgnHandle diffRgn = NewRgn() ;
if ( updateRgn && diffRgn )
{
#if 1
// macos internal control redraws clean up areas we'd like to redraw ourselves
// therefore we pick the boundary rect and make sure we can redraw it
// this has to be intersected by the visRgn in order to avoid drawing over its own
// boundaries
RgnHandle trueUpdateRgn = NewRgn() ;
Rect trueUpdateRgnBoundary ;
GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), trueUpdateRgn );
GetRegionBounds( trueUpdateRgn , &trueUpdateRgnBoundary ) ;
RectRgn( updateRgn , &trueUpdateRgnBoundary ) ;
SectRgn( updateRgn , visRgn , updateRgn ) ;
if ( trueUpdateRgn )
DisposeRgn( trueUpdateRgn ) ;
SetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn ) ;
#else
GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn );
#endif
DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
if ( !EmptyRgn( updateRgn ) )
{
MacRedraw( updateRgn , timestamp , m_macNeedsErasing || !EmptyRgn( diffRgn ) ) ;
}
}
if ( updateRgn )
DisposeRgn( updateRgn );
if ( diffRgn )
DisposeRgn( diffRgn );
if ( visRgn )
DisposeRgn( visRgn ) ;
EndUpdate( (WindowRef)m_macWindow ) ;
SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
m_macNeedsErasing = false ;
}
RgnHandle getWindowDragRegion(WindowRef window, RgnHandle dragRegion)
{
/*------------------------------------------------------
Define the drag region of our window.
--------------------------------------------------------*/
RgnHandle structureRegion=NewRgn();
RgnHandle contentRegion=NewRgn();
SetEmptyRgn(dragRegion);
getWindowStructureRegion(window,structureRegion);
getWindowContentRegion(window,contentRegion);
//our drag region is the difference between the structural and content regions
DiffRgn(structureRegion,contentRegion,dragRegion);
DisposeRgn(structureRegion);
DisposeRgn(contentRegion);
return dragRegion;
}
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);
}
}
}
}
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;
}
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;
if (NewDrag( &theDrag ) != noErr)
return wxDragNone;
// add data to drag
size_t formatCount = m_data->GetFormatCount();
wxDataFormat *formats = new wxDataFormat[formatCount];
m_data->GetAllFormats( formats );
ItemReference theItem = (ItemReference) 1;
for ( size_t i = 0; i < formatCount; ++i )
{
size_t dataSize = m_data->GetDataSize( formats[i] );
Ptr dataPtr = new char[dataSize];
m_data->GetDataHere( formats[i], dataPtr );
OSType type = formats[i].GetFormatId();
if ( type == 'TEXT' || type == 'utxt' )
{
if ( dataSize > 0 )
dataSize--;
dataPtr[ dataSize ] = 0;
if ( type == 'utxt' )
{
if ( dataSize > 0 )
dataSize--;
dataPtr[ dataSize ] = 0;
}
AddDragItemFlavor( theDrag, theItem, type, dataPtr, dataSize, 0 );
}
else if (type == kDragFlavorTypeHFS )
{
HFSFlavor theFlavor;
OSErr err = noErr;
#ifndef __LP64__
CInfoPBRec cat;
wxMacFilename2FSSpec( wxString( dataPtr, *wxConvCurrent ), &theFlavor.fileSpec );
memset( &cat, 0, sizeof(cat) );
cat.hFileInfo.ioNamePtr = theFlavor.fileSpec.name;
cat.hFileInfo.ioVRefNum = theFlavor.fileSpec.vRefNum;
cat.hFileInfo.ioDirID = theFlavor.fileSpec.parID;
cat.hFileInfo.ioFDirIndex = 0;
err = PBGetCatInfoSync( &cat );
#endif
if (err == noErr)
{
#ifndef __LP64__
theFlavor.fdFlags = cat.hFileInfo.ioFlFndrInfo.fdFlags;
if (theFlavor.fileSpec.parID == fsRtParID)
{
theFlavor.fileCreator = 'MACS';
theFlavor.fileType = 'disk';
}
else if ((cat.hFileInfo.ioFlAttrib & ioDirMask) != 0)
{
theFlavor.fileCreator = 'MACS';
theFlavor.fileType = 'fold';
}
else
{
theFlavor.fileCreator = cat.hFileInfo.ioFlFndrInfo.fdCreator;
theFlavor.fileType = cat.hFileInfo.ioFlFndrInfo.fdType;
}
#endif
AddDragItemFlavor( theDrag, theItem, type, &theFlavor, sizeof(theFlavor), 0 );
}
}
else
{
AddDragItemFlavor( theDrag, theItem, type, dataPtr, dataSize, 0 );
}
delete [] dataPtr;
}
delete [] formats;
dragRegion = NewRgn();
RgnHandle tempRgn = NewRgn();
EventRecord* ev = NULL;
#if !TARGET_CARBON // TODO
ev = (EventRecord*) wxTheApp->MacGetCurrentEvent();
#else
EventRecord rec;
ev = &rec;
wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent(), &rec );
#endif
const short dragRegionOuterBoundary = 10;
const short dragRegionInnerBoundary = 9;
SetRectRgn(
dragRegion,
ev->where.h - dragRegionOuterBoundary,
ev->where.v - dragRegionOuterBoundary,
ev->where.h + dragRegionOuterBoundary,
ev->where.v + dragRegionOuterBoundary );
SetRectRgn(
tempRgn,
ev->where.h - dragRegionInnerBoundary,
ev->where.v - dragRegionInnerBoundary,
ev->where.h + dragRegionInnerBoundary,
ev->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;
TrackDrag( theDrag, ev, dragRegion );
DisposeRgn( dragRegion );
DisposeDrag( theDrag );
gTrackingGlobals.m_currentSource = NULL;
bool optionDown = GetCurrentKeyModifiers() & optionKey;
wxDragResult dndresult = wxDragCopy;
if ( flags != wxDrag_CopyOnly )
// on mac the option key is always the indication for copy
dndresult = optionDown ? wxDragCopy : wxDragMove;
return dndresult;
}
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;
}
}
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 */
}
void apply_light_mask()
{
GrafPtr old_port;
Rect temp = {0,0,108,84},paint_rect,base_rect = {0,0,36,28};
Rect big_to = {13,13,337,265};
short i,j;
bool is_dark = false,same_mask = true;
if (PSD[SDF_NO_FRILLS] > 0)
return;
if (is_out())
return;
if (univ.town->lighting_type == 0)
return;
if (oval_region == NULL) {
temp_rect_rgn = NewRgn();
dark_mask_region = NewRgn();
oval_region = NewRgn();
OpenRgn();
FrameOval(&temp);
CloseRgn(oval_region);
}
// Process the light array
for (i = 2; i < 11; i++)
for (j = 2; j < 11; j++)
if (light_area[i][j] == 0) is_dark = true;
if (is_dark == false) {
for (i = 2; i < 11; i++)
for (j = 2; j < 11; j++)
last_light_mask[i][j] = 0;
return;
}
for (i = 1; i < 12; i++)
for (j = 1; j < 12; j++)
if ((light_area[i - 1][j - 1] >= 1) && (light_area[i + 1][j - 1] >= 1) &&
(light_area[i - 1][j] >= 1) && (light_area[i + 1][j] >= 1) &&
(light_area[i - 1][j + 1] >= 1) && (light_area[i + 1][j + 1] >= 1) &&
(light_area[i][j - 1] >= 1) && (light_area[i][j + 1] >= 1)) {
light_area[i][j] = 2;
}
for (i = 1; i < 12; i++)
for (j = 1; j < 12; j++)
if ((light_area[i - 1][j - 1] >= 2) && (light_area[i + 1][j - 1] >= 2) &&
(light_area[i - 1][j] >= 2) && (light_area[i + 1][j] >= 2) &&
(light_area[i - 1][j + 1] >= 2) && (light_area[i + 1][j + 1] >= 2) &&
(light_area[i][j - 1] >= 2) && (light_area[i][j + 1] >= 2)) {
light_area[i][j] = 3;
}
GetPort(&old_port);
SetPort(terrain_screen_gworld);
for (i = 2; i < 11; i++)
for (j = 2; j < 11; j++) {
if (light_area[i][j] == 1)
terrain_there[i - 2][j - 2] = -1;
}
for (i = 0; i < 13; i++)
for (j = 0; j < 13; j++)
if (last_light_mask[i][j] != light_area[i][j])
same_mask = false;
if (same_mask == true) {
PaintRgn(dark_mask_region);
SetPort(old_port);
return;
}
SetRectRgn(dark_mask_region,big_to.left,big_to.top,big_to.right,big_to.bottom);
for (i = 0; i < 13; i++)
for (j = 0; j < 13; j++)
last_light_mask[i][j] = light_area[i][j];
for (i = 1; i < 12; i++)
for (j = 1; j < 12; j++) {
if (light_area[i][j] == 2) {
OffsetRgn(oval_region,13 + 28 * (i - 3), 13 + 36 * (j - 3));
DiffRgn(dark_mask_region,oval_region,dark_mask_region);
OffsetRgn(oval_region,-13 + -1 * (28 * (i - 3)),-13 + -1 * (36 * (j - 3)));
//PaintRect(&paint_rect);
}
if (light_area[i][j] == 3) {
paint_rect = base_rect;
OffsetRect(&paint_rect,13 + 28 * (i - 2),13 + 36 * (j - 2));
SetRectRgn(temp_rect_rgn,paint_rect.left,paint_rect.top,
paint_rect.right + 28,paint_rect.bottom + 36);
DiffRgn(dark_mask_region,temp_rect_rgn,dark_mask_region);
if (light_area[i + 1][j] == 3) light_area[i + 1][j] = 0;
if (light_area[i + 1][j + 1] == 3) light_area[i + 1][j + 1] = 0;
if (light_area[i][j + 1] == 3) light_area[i][j + 1] = 0;
}
}
//rect_draw_some_item(light_mask_gworld,big_from,terrain_screen_gworld,big_to,0,0);
PaintRgn(dark_mask_region);
SetPort(old_port);
}
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;
}
wxDragResult wxDropSource::DoDragDrop(int WXUNUSED(flags))
{
wxASSERT_MSG( m_data, wxT("Drop source: no data") );
if (!m_data)
return (wxDragResult) wxDragNone;
if (m_data->GetFormatCount() == 0)
return (wxDragResult) wxDragNone;
OSErr result;
DragReference theDrag;
RgnHandle dragRegion;
if ((result = NewDrag(&theDrag)))
{
return wxDragNone ;
}
// add data to drag
size_t formatCount = m_data->GetFormatCount() ;
wxDataFormat *formats = new wxDataFormat[formatCount] ;
m_data->GetAllFormats( formats ) ;
ItemReference theItem = 1 ;
for ( size_t i = 0 ; i < formatCount ; ++i )
{
size_t dataSize = m_data->GetDataSize( formats[i] ) ;
Ptr dataPtr = new char[dataSize] ;
m_data->GetDataHere( formats[i] , dataPtr ) ;
OSType type = formats[i].GetFormatId() ;
if ( type == 'TEXT' )
{
dataSize-- ;
dataPtr[ dataSize ] = 0 ;
wxString st( (wxChar*) dataPtr ) ;
wxCharBuffer buf = st.mb_str( wxConvLocal) ;
AddDragItemFlavor(theDrag, theItem, type , buf.data(), strlen(buf), 0);
}
else if (type == kDragFlavorTypeHFS )
{
HFSFlavor theFlavor ;
OSErr err = noErr;
CInfoPBRec cat;
wxMacFilename2FSSpec( dataPtr , &theFlavor.fileSpec ) ;
cat.hFileInfo.ioNamePtr = theFlavor.fileSpec.name;
cat.hFileInfo.ioVRefNum = theFlavor.fileSpec.vRefNum;
cat.hFileInfo.ioDirID = theFlavor.fileSpec.parID;
cat.hFileInfo.ioFDirIndex = 0;
err = PBGetCatInfoSync(&cat);
if (err == noErr )
{
theFlavor.fdFlags = cat.hFileInfo.ioFlFndrInfo.fdFlags;
if (theFlavor.fileSpec.parID == fsRtParID) {
theFlavor.fileCreator = 'MACS';
theFlavor.fileType = 'disk';
} else if ((cat.hFileInfo.ioFlAttrib & ioDirMask) != 0) {
theFlavor.fileCreator = 'MACS';
theFlavor.fileType = 'fold';
} else {
theFlavor.fileCreator = cat.hFileInfo.ioFlFndrInfo.fdCreator;
theFlavor.fileType = cat.hFileInfo.ioFlFndrInfo.fdType;
}
AddDragItemFlavor(theDrag, theItem, type , &theFlavor, sizeof(theFlavor), 0);
}
}
else
{
AddDragItemFlavor(theDrag, theItem, type , dataPtr, dataSize, 0);
}
delete[] dataPtr ;
}
delete[] formats ;
dragRegion = NewRgn();
RgnHandle tempRgn = NewRgn() ;
EventRecord* ev = NULL ;
#if !TARGET_CARBON // TODO
ev = (EventRecord*) wxTheApp->MacGetCurrentEvent() ;
#else
EventRecord rec ;
ev = &rec ;
wxMacConvertEventToRecord( (EventRef) wxTheApp->MacGetCurrentEvent() , &rec ) ;
#endif
const short dragRegionOuterBoundary = 10 ;
const short dragRegionInnerBoundary = 9 ;
SetRectRgn( dragRegion , ev->where.h - dragRegionOuterBoundary ,
ev->where.v - dragRegionOuterBoundary ,
ev->where.h + dragRegionOuterBoundary ,
ev->where.v + dragRegionOuterBoundary ) ;
SetRectRgn( tempRgn , ev->where.h - dragRegionInnerBoundary ,
ev->where.v - dragRegionInnerBoundary ,
ev->where.h + dragRegionInnerBoundary ,
ev->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 ;
result = TrackDrag(theDrag, ev , dragRegion);
DisposeRgn(dragRegion);
DisposeDrag(theDrag);
gTrackingGlobals.m_currentSource = NULL ;
KeyMap keymap;
GetKeys(keymap);
bool optionDown = keymap[1] & 4;
wxDragResult dndresult = optionDown ? wxDragCopy : wxDragMove;
return dndresult;
}
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;
}
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;
}
}
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;
}
