/* * 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; }