void drawBackground() { Rect rect; RGBColor color; Rect tempRect1; color.red = color.green = color.blue = 8700; RGBForeColor( &color ); PaintRect( GetPortBounds(GetWindowPort(gWindow), &tempRect1)); TextFont( kFontIDTimes ); TextMode( srcOr ); TextSize( 24 ); drawName( 85, 22, "\pSource Image" ); drawName( GetPortBounds(GetWindowPort(gWindow), &tempRect1)->right - 215, 22, "\pNew Image" ); GetPortBounds(GetWindowPort(gWindow), &tempRect1); SetRect( &rect, 15, tempRect1.bottom - 180, tempRect1.right - 15, tempRect1.bottom - 30); drawDeepBox( &rect ); TextSize( 12 ); drawName( tItem[0].rect.left, tItem[0].rect.top - 8, "\pTransfer Mode" ); drawName( aItem[0].rect.left, aItem[0].rect.top - 8, "\pArithmetic Mode" ); drawName( cItem[0].rect.left, cItem[0].rect.top - 8, "\pColorization" ); drawName( dItem[0].rect.left, dItem[0].rect.top - 8, "\pDither" ); drawName( mItem[0].rect.left, mItem[0].rect.top - 8, "\pColor Mapping" ); drawName( bItem[0].rect.left, bItem[0].rect.top - 8, "\pDestination" ); drawName( pItem[0].rect.left, pItem[0].rect.top - 8, "\pPaint Bucket" ); drawName( lItem[0].rect.left, lItem[0].rect.top - 8, "\pLasso Tool" ); }
void createWindow() { int width, height; int left, top; Rect rect; Rect tempRect1; BitMap bitMap; GetPortBounds(gGWorld, &tempRect1); width = 58 + (tempRect1.right - tempRect1.left) * 2; height = 230 + tempRect1.bottom - tempRect1.top; tempRect1 = GetQDGlobalsScreenBits(&bitMap)->bounds; left = (((tempRect1.right - tempRect1.left) - width) / 2); top = (((tempRect1.bottom - tempRect1.top) - height) / 2) + 20; SetRect( &rect, left, top, left + width, top + height ); gWindow = NewCWindow( 0L, &rect, "\pQuickDraw Special Effects", true, noGrowDocProc, (WindowPtr)-1L, true, 0 ); SetPortWindowPort( gWindow ); }
static void mac_updatelicence(WindowPtr window) { Handle h; int len; long fondsize; Rect textrect; SetPort((GrafPtr)GetWindowPort(window)); BeginUpdate(window); fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize); TextFont(HiWord(fondsize)); TextSize(LoWord(fondsize)); h = Get1Resource('TEXT', wLicence); len = GetResourceSizeOnDisk(h); #if TARGET_API_MAC_CARBON GetPortBounds(GetWindowPort(window), &textrect); #else textrect = window->portRect; #endif if (h != NULL) { HLock(h); TETextBox(*h, len, &textrect, teFlushDefault); HUnlock(h); } EndUpdate(window); }
void QTApp_Draw (WindowReference theWindow) { GrafPtr mySavedPort = NULL; GrafPtr myWindowPort = NULL; WindowPtr myWindow = NULL; Rect myRect; GetPort(&mySavedPort); myWindowPort = QTFrame_GetPortFromWindowReference(theWindow); myWindow = QTFrame_GetWindowFromWindowReference(theWindow); if (myWindowPort == NULL) return; MacSetPort(myWindowPort); #if TARGET_API_MAC_CARBON GetPortBounds(myWindowPort, &myRect); #else myRect = myWindowPort->portRect; #endif BeginUpdate(myWindow); // erase any part of a movie window that hasn't already been updated // by the movie controller if (QTFrame_IsMovieWindow(theWindow)) EraseRect(&myRect); // ***insert application-specific drawing here*** EndUpdate(myWindow); MacSetPort(mySavedPort); }
void createWindow() { Rect wBounds; BitMap bitMap; Rect tempRect1; int top, left, width, height; GetQDGlobalsScreenBits(&bitMap); width = ((bitMap.bounds.right - bitMap.bounds.left) / 2); height = ((bitMap.bounds.bottom - bitMap.bounds.top) / 2); left = (((bitMap.bounds.right - bitMap.bounds.left) - width) / 2); top = (((bitMap.bounds.bottom - bitMap.bounds.top) - height) / 2); /* Create a window to display the final offscreen image. */ //SetRect( &wBounds, WLEFT, WTOP, WLEFT + WWIDTH, WTOP + WHEIGHT ); SetRect( &wBounds, left, top, left + width, top + height ); gWindow = NewCWindow( 0L, &wBounds, "\pSnapshot Test", false, documentProc, (WindowPtr)-1L, true, 0L ); //SetRect( &gBounds, 0, 0, gWindow->portRect.right - gWindow->portRect.left, // gWindow->portRect.bottom - gWindow->portRect.top ); GetPortBounds(GetWindowPort(gWindow), &tempRect1); SetRect( &gBounds, 0, 0, tempRect1.right - tempRect1.left, tempRect1.bottom - tempRect1.top); //SetPort( gWindow ); SetPortWindowPort( gWindow ); }
void drawPixelImageData() { int row, col; Rect rect; unsigned char value; char *image; int index = 0; Str255 string; RGBColor color = { 32000, 32000, 32000 }; //Byte mode; Rect tempRect1; ForeColor( blackColor ); SetRect( &rect, 0, 0, 20, 20 ); /* For this example, let's just use only the upper left corner of the image. */ // Draw the offscreen image to the screen to see what it looks like. //CopyBits( (BitMap *)*gPixmap, &gWindow->portBits, &rect, // &gWindow->portRect, srcCopy, 0 ); //(**gPixmap).rowBytes ^= 0x8000; CopyBits( (BitMap *)*gPixmap, GetPortBitMapForCopyBits(GetWindowPort(gWindow)), &rect, GetPortBounds(GetWindowPort(gWindow), &tempRect1), srcCopy, 0 ); //(**gPixmap).rowBytes ^= 0x8000; RGBForeColor( &color ); // Again, set the pointer to the beginning of the pixel image. image = GetPixBaseAddr( gPixmap ); /***************************************************************/ /* Finally let's display the pixel values on top of the image. */ /***************************************************************/ /* Loop through the first 20 rows of the pixel image. */ for (row = 0; row < rect.bottom; row++) { // Loop through the first 20 columns of the pixel image. for (index = 0, col = 0; col < rect.right; col++) { // Get the value at this index into the pixel image. value = (unsigned char)*(image + index); MoveTo( col * 30, row * 20 ); LineTo( col * 30, (row + 1) * 20 ); LineTo( (col + 1) * 30, (row + 1) * 20 ); MoveTo( (col * 30) + 6, (row * 20) + 14 ); NumToString( (long)value, string ); DrawString( string ); index++; } // Increment the pointer to the next row of the pixel image. image += ((**gPixmap).rowBytes & 0x7fff); } }
void MCStack::setgeom() { //set stack(window) size or position from script if (MCnoui || !opened) return; // MW-2009-09-25: Ensure things are the right size when doing // remote dialog/menu windows. if (window == DNULL) { // MW-2011-08-18: [[ Redraw ]] Update to use redraw. MCRedrawLockScreen(); state &= ~CS_NEED_RESIZE; resize(rect . width, rect . height); MCRedrawUnlockScreen(); mode_setgeom(); return; } // MW-2011-09-12: [[ MacScroll ]] Make sure we apply the current scroll setting. applyscroll(); Rect windRect; GetPortBounds(GetWindowPort((WindowPtr)window->handle.window), &windRect); SetGWorld(GetWindowPort((WindowPtr)window->handle.window), GetMainDevice()); Point p; p.h = windRect.left; p.v = windRect.top; LocalToGlobal(&p); int2 curWidth = windRect.right - windRect.left; int2 curHeight = windRect.bottom - windRect.top; if (IsWindowVisible((WindowPtr)window->handle.window)) { if (mode != WM_SHEET && mode != WM_DRAWER && (rect.x != p.h || rect.y != p.v)) { MoveWindow((WindowPtr)window->handle.window, rect.x, rect.y, False); state |= CS_BEEN_MOVED; } if (rect.width != curWidth || rect.height != curHeight) { SizeWindow((WindowPtr)window->handle.window, rect.width, rect.height, True); resize(curWidth, curHeight + getscroll()); } state &= ~CS_NEED_RESIZE; } else { if (mode != WM_SHEET && mode != WM_DRAWER) MoveWindow((WindowPtr)window->handle.window, rect.x, rect.y, False); if (rect.width != curWidth || rect.height != curHeight) { SizeWindow((WindowPtr)window->handle.window, rect.width, rect.height, True); resize(curWidth, curHeight + getscroll()); } state &= ~(CS_BEEN_MOVED | CS_NEED_RESIZE); } }
void BURGER_API Burger::OkAlertMessage(const char *pMessage,const char *pTitle) { Word8 *TitleStr; /* Pointer to the window title */ DialogPtr MyDialog; /* My dialog pointer */ Handle ItemList; /* Handle to the item list */ Rect DialogRect; /* Rect of the dialog window */ Word TitleLen; /* Length of the title */ Word MessLen; /* Length of the caption */ short ItemHit; /* Junk */ Rect WorkRect; GrafPtr MyPort; /* My grafport */ //Word Foo; //Foo = InputSetState(FALSE); GetPort(&MyPort); /* Save the current port */ /* Center my dialog to the screen */ #if ACCESSOR_CALLS_ARE_FUNCTIONS GetPortBounds(MyPort,&WorkRect); #else WorkRect = MyPort->portRect; #endif DialogRect.top = static_cast<short>((((WorkRect.bottom-WorkRect.top)-190)/2)+WorkRect.top); DialogRect.left = static_cast<short>((((WorkRect.right-WorkRect.left)-350)/2)+WorkRect.left); DialogRect.bottom = static_cast<short>(DialogRect.top+190); DialogRect.right = static_cast<short>(DialogRect.left+350); TitleLen = 0; /* Assume no length */ if (pTitle) { TitleLen = Burger::StringLength(pTitle); /* Get the length of the title string */ } TitleStr = (Word8 *)Burger::Alloc(TitleLen+1); /* Get memory of pascal string */ if (TitleStr) { /* Did I get the memory? */ MemoryCopy(TitleStr+1,pTitle,TitleLen); TitleStr[0] = static_cast<Word8>(TitleLen); /* Set the pascal length */ MessLen = Burger::StringLength(pMessage); /* Size of the message */ ItemList = NewHandle(static_cast<Size>(sizeof(Template)+MessLen)); if (ItemList) { /* Ok? */ Template[sizeof(Template)-1]=static_cast<Word8>(MessLen); /* Save the message length */ MemoryCopy(ItemList[0],Template,sizeof(Template)); /* Copy the template */ MemoryCopy((ItemList[0])+sizeof(Template),pMessage,MessLen); /* Copy the message */ MyDialog = NewDialog(0,&DialogRect,(Word8 *)TitleStr,TRUE,5,(WindowPtr)-1,FALSE,0,ItemList); if (MyDialog) { SetDialogDefaultItem(MyDialog,1); /* Default for OK button */ ModalDialog(0,&ItemHit); /* Handle the event */ DisposeDialog(MyDialog); /* Kill the dialog */ } else { DisposeHandle(ItemList); /* I must kill this myself! */ } } Burger::Free(TitleStr); /* Kill the title */ } SetPort(MyPort); /* Restore my grafport */ //InputSetState(Foo); }
void cPict::drawFullSheet(short num, Rect to_rect){ Rect from_rect; if(!isSheetSet(SHEET_FULL,num)) throw xMissingSheet(SHEET_FULL,num); GWorldPtr from_gw = largeSheets[num]; GetPortBounds(from_gw, &from_rect); to_rect.right = to_rect.left + (from_rect.right - from_rect.left); to_rect.bottom = to_rect.top + (from_rect.bottom - from_rect.top); rect_draw_some_item(from_gw, from_rect, to_rect, (Point){0,0}); }
void drawExampleName() { int left, top; Rect rect; Str255 label = "\pCurrent Example: "; Str255 name[9] = { "\p TRANSFER MODES", "\pARITHMETIC MODES", "\p DITHERING", "\p COLORIZATION", "\p COLOR MAPPING", "\p PAINT BUCKET", "\p LASSO TOOL", "\pPIXEL AVERAGING", "\p CUSTOM" }; Rect tempRect1; left = 15; top = GetPortBounds(GetWindowPort(gWindow), &tempRect1)->bottom - 13; drawName( left, top, label ); left += StringWidth( label ); SetRect( &rect, left - 2, top - 12, left + 130, top + 4 ); eraseRect( &rect ); drawName( left, top, name[(gCurrentExample / 10) - 1] ); } void drawTime( long ticks ) { Rect rect; int left, top; float seconds; char cString[40]; Rect tempRect1; GetPortBounds(GetWindowPort(gWindow), &tempRect1); left = tempRect1.right - 130; top = tempRect1.bottom - 13; SetRect( &rect, left - 2, top - 12, left + 90, top + 4 ); eraseRect( &rect ); seconds = (float)ticks / 60.0; sprintf( &cString[0], "Draw Time: %03.03f secs", seconds ); drawName( left, top, C2PStr( cString ) ); }
void getCurrentPortBounds(Rect* inRect) { /*------------------------------------------------------ Simple utility function to get the bounds of the current port. --------------------------------------------------------*/ CGrafPtr thePort; GetPort(&thePort); GetPortBounds(thePort,inRect); }
int ioPositionOfWindow(wIndexType windowIndex) { Rect portRect; if (windowHandleFromIndex(windowIndex) == nil) return -1; GetPortBounds(GetWindowPort(windowHandleFromIndex(windowIndex)),&portRect); QDLocalToGlobalRect(GetWindowPort(windowHandleFromIndex(windowIndex)), &portRect); return (portRect.left << 16) | (portRect.top & 0xFFFF); /* left is high 16 bits; top is low 16 bits */ }
void DrawInfoBox (WINDOWID win, const char *info) { WindowPtr theMacWindow; Rect r,box,WinRect; CGrafPtr myPort; Rect myClipRect; short w; GRAPH_WINDOW *gw; Str255 pstr; gw = (GRAPH_WINDOW *)win; theMacWindow = MAC_WIN(gw); /* set port */ myPort = GetWindowPort(theMacWindow); SetPort(myPort); GetPortBounds(myPort,&WinRect); PmForeColor(1); /* black */ GetPortBounds(myPort,&r); /* info box */ SetRect(&box,r.left+1,r.bottom-14,r.right-121,r.bottom); /* set clipping region to info box */ ClipRect(&box); EraseRect(&box); CopyCStringToPascal(info,pstr); w = StringWidth(pstr); MoveTo((box.left+box.right)/2-w/2,box.bottom-3); TextSize(9); DrawString(pstr); /* adjust clipping rectangle again to plottable area */ myClipRect.left = gw->Local_LL[0]; myClipRect.right = gw->Local_UR[0]; myClipRect.bottom = gw->Local_LL[1]; myClipRect.top = gw->Local_UR[1]; ClipRect(&myClipRect); }
/* * For some reason, LNew doesn't seem to respect the hasGrow * parameter, so we hammer the scrollbar into shape ourselves. */ static void mac_adjusteventlogscrollbar(Session *s) { #if TARGET_API_MAC_CARBON Rect winrect; GetPortBounds(GetWindowPort(s->eventlog_window), &winrect); SizeControl(GetListVerticalScrollBar(s->eventlog), 16, winrect.bottom - 13); #else SizeControl((*s->eventlog)->vScroll, 16, s->eventlog_window->portRect.bottom - 13); #endif }
void drawImage(WindowPtr theWindow) { Rect tempRect1; /* Copy the offscreen image back onto the window. */ //CopyBits( (BitMap *)&gPixMap, &gWindow->portBits, &gPixMap.bounds, // &gWindow->portRect, srcCopy, 0l); CopyBits( (BitMap *)&gPixMap, GetPortBitMapForCopyBits(GetWindowPort(theWindow)), &gPixMap.bounds, GetPortBounds(GetWindowPort(gWindow), &tempRect1), srcCopy, 0L); ShowWindow( gWindow ); }
static void getmaincenter(Point *cp) { #if TARGET_API_MAC_CARBON Rect rct; GetPortBounds(GetWindowPort(hWndMain), &rct); cp->h = (rct.right + rct.left) / 2; cp->v = (rct.bottom + rct.top) / 2; #else cp->h = 320; cp->v = 200; #endif }
int ioSizeOfWindow(wIndexType windowIndex) { Rect portRect; int w, h; if (windowHandleFromIndex(windowIndex) == nil) return -1; GetPortBounds(GetWindowPort(windowHandleFromIndex(windowIndex)),&portRect); w = portRect.right - portRect.left; h = portRect.bottom - portRect.top; return (w << 16) | (h & 0xFFFF); /* w is high 16 bits; h is low 16 bits */ }
void mac_warp_mouse() { #ifndef ACTIVEGS Rect port_rect; Point win_origin_pt; CGPoint cgpoint; CGDisplayErr cg_err; GetPortBounds(GetWindowPort(g_main_window), &port_rect); SetPt(&win_origin_pt, port_rect.left, port_rect.top); LocalToGlobal(&win_origin_pt); cgpoint = CGPointMake( (float)(win_origin_pt.h + X_A2_WINDOW_WIDTH/2), (float)(win_origin_pt.v + X_A2_WINDOW_HEIGHT/2)); cg_err = CGDisplayMoveCursorToPoint(kCGDirectMainDisplay, cgpoint); #endif }
void drawGraphic( CGContextRef context, float x, float y ) { static GWorldPtr imageGW = NULL; static CGImageRef imageRef = NULL; static CGDataProviderRef dataProviderRef = NULL; Rect bounds; static size_t width; static size_t height; size_t bitsPerComponent; size_t bitsPerPixel; size_t bytesPerRow; PixMapHandle pmh; // Load the image if we haven't already if ( NULL == imageGW ) { // Load and create the GWorld imageGW = OpenImage(); if ( imageGW != NULL ) { GetPortBounds( imageGW, &bounds ); width = bounds.right - bounds.left; height = bounds.bottom - bounds.top; pmh = GetPortPixMap( imageGW ); bitsPerComponent = (**pmh).cmpSize; bitsPerPixel = (**pmh).pixelSize; bytesPerRow = GetPixRowBytes( pmh ); LockPixels( pmh ); dataProviderRef = CGDataProviderCreateWithData( NULL, GetPixBaseAddr( pmh ), height * bytesPerRow, releaseData ); // Create the imageRef for that GWorld imageRef = CGImageCreate( width, height, bitsPerComponent, bitsPerPixel, bytesPerRow, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaPremultipliedFirst/*kCGImageAlphaNone*/, dataProviderRef, NULL, 0, kCGRenderingIntentDefault ); } } // Draw the image at 0,0 CGContextDrawImage( context, CGRectMake( x - 20, y, 40, 40 * height / width ), imageRef ); }
INT WhichTool (WINDOWID win, const INT mp[2], INT *ChosenToolPtr) { INT i; Rect WinRect; WindowPtr theWindow; theWindow = MAC_WIN((GRAPH_WINDOW*)win); GetPortBounds(GetWindowPort(theWindow),&WinRect); GET_CHOSEN_TOOL(i,WinRect,mp); *ChosenToolPtr = i; if (i==NO_TOOL_CHOSEN) return (0); return(1); }
void MacVegaPrinterListener::SetGraphicsContext(CGrafPtr port) { #ifndef SIXTY_FOUR_BIT if (m_port) { CGContextRestoreGState(m_ctx); QDEndCGContext(m_port, &m_ctx); } m_port = port; m_ctx = NULL; if (m_port) { Rect bounds; GetPortBounds(m_port, &bounds); m_winHeight = bounds.bottom-bounds.top; QDBeginCGContext(m_port, &m_ctx); SetColor(0,0,0,255); CGContextSaveGState(m_ctx); } #endif }
void drawSourceImage() { Rect rect; Rect outlineRect; Rect tempRect1; GetPortBounds(gGWorld, &tempRect1); SetRect( &rect, 20, 37, 20 + tempRect1.right, 37 + tempRect1.bottom); outlineRect = rect; InsetRect( &outlineRect, -5, -5 ); drawDeepBox( &outlineRect ); ForeColor( blackColor ); BackColor( whiteColor ); CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)), &((**(GetPortPixMap(gGWorld))).bounds), &rect, srcCopy, nil ); }
static void mac_createeventlog(Session *s) { Rect view; ListBounds bounds = { 0, 0, 0, 1 }; /* 1 column, 0 rows */ Point csize = { 0, 0 }; GrafPtr saveport; long fondsize; WinInfo *wi; s->eventlog_window = GetNewWindow(wEventLog, NULL, (WindowPtr)-1); wi = snew(WinInfo); memset(wi, 0, sizeof(*wi)); wi->s = s; wi->wtype = wEventLog; wi->click = &mac_clickeventlog; wi->activate = &mac_activateeventlog; wi->grow = &mac_groweventlog; wi->update = &mac_updateeventlog; wi->close = &mac_closeeventlog; SetWRefCon(s->eventlog_window, (long)wi); GetPort(&saveport); SetPort((GrafPtr)GetWindowPort(s->eventlog_window)); fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize); TextFont(HiWord(fondsize)); TextSize(LoWord(fondsize)); SetPort(saveport); #if TARGET_API_MAC_CARBON GetPortBounds(GetWindowPort(s->eventlog_window), &view); #else view = s->eventlog_window->portRect; #endif view.right -= 15; /* Scrollbar */ s->eventlog = LNew(&view, &bounds, csize, 0, s->eventlog_window, TRUE, TRUE, FALSE, TRUE); mac_adjusteventlogscrollbar(s); #if TARGET_API_MAC_CARBON SetListSelectionFlags(s->eventlog, lExtendDrag | lNoDisjoint | lNoExtend); #else (*s->eventlog)->selFlags = lExtendDrag | lNoDisjoint | lNoExtend; #endif }
OSStatus SetCGContext(QuartzDesc *xd) { Rect rect; OSStatus err = noErr; CGRect cgRect; if(xd->context){ CGContextRelease(xd->context); xd->context = NULL; } if(xd->auxcontext){ CGContextRelease(xd->auxcontext); xd->auxcontext = NULL; } if(xd->window) err = CreateCGContextForPort(GetWindowPort(xd->window), &xd->context); if(xd->window) GetPortBounds(GetWindowPort(xd->window), &rect); if(xd->context){ CGContextTranslateCTM(xd->context,0, (float)(rect.bottom - rect.top)); /* Be aware that by performing a negative scale in the following line of code, your text will also be flipped */ CGContextScaleCTM(xd->context, 1, -1); /* We apply here Antialiasing if necessary */ CGContextSetShouldAntialias(xd->context, xd->Antialias); } return err; }
void IPlugProcess::SetViewPort (GrafPtr aPort) { mMainPort = aPort; CEffectProcess::SetViewPort( mMainPort ); // call inherited first if(mMainPort) { if(mCustomUI) { void *windowPtr = NULL; #if WINDOWS_VERSION windowPtr = (void*)ASI_GethWnd((WindowPtr)mMainPort); #elif MAC_VERSION windowPtr = (void*)GetWindowFromPort(mMainPort); // WindowRef for Carbon, not GrafPtr (quickdraw) Rect portBounds; GetPortBounds(aPort, &portBounds); if ((portBounds.left <= 0 && portBounds.top <= 0) && (mLeftOffset == 0 && mTopOffset == 0)) { mLeftOffset = -portBounds.left; mTopOffset = -portBounds.top; } #endif mCustomUI->Open(windowPtr, mLeftOffset, mTopOffset); #if WINDOWS_VERSION mCustomUI->Draw(mPluginWinRect.left, mPluginWinRect.top, mPluginWinRect.right, mPluginWinRect.bottom); #endif } } else { if(mCustomUI) mCustomUI->Close(); if( mView ) mView->SetEnable(false); } return; }
INT Mac_UpdateOutput (WINDOWID win, INT tool) { GRAPH_WINDOW *gw; WindowPtr theWindow; Rect myClipRect,*portRect = nil; gw = (GRAPH_WINDOW *) win; theWindow = MAC_WIN(gw); gw->currTool = tool; SetPort(GetWindowPort(theWindow)); /* identify clipping rect with port */ GetPortBounds(GetWindowPort(theWindow),portRect); ClipRect(portRect); BeginUpdate(theWindow); /* leave this out: uginterface will manage EraseRgn(((GrafPtr)theWindow)->visRgn);*/ EndUpdate(theWindow); /* adjust cursor */ if (theWindow == FrontWindow()) ActivateMacWin (gw,tool); DrawGrowIcon(theWindow); DrawToolBox(gw,tool); /* reset clipping rectangle */ myClipRect.left = portRect->left; myClipRect.right = portRect->right - SCROLL_BAR; myClipRect.bottom = portRect->bottom - SCROLL_BAR; myClipRect.top = portRect->top; ClipRect(&myClipRect); return (0); }
static void mac_draweventloggrowicon(Session *s) { Rect clip; RgnHandle savergn; SetPort((GrafPtr)GetWindowPort(s->eventlog_window)); /* * Stop DrawGrowIcon giving us space for a horizontal scrollbar * See Tech Note TB575 for details. */ #if TARGET_API_MAC_CARBON GetPortBounds(GetWindowPort(s->eventlog_window), &clip); #else clip = s->eventlog_window->portRect; #endif clip.left = clip.right - 15; savergn = NewRgn(); GetClip(savergn); ClipRect(&clip); DrawGrowIcon(s->eventlog_window); SetClip(savergn); DisposeRgn(savergn); }
static void DrawToolBox (GRAPH_WINDOW *gw, INT tool) { Rect r,dstRect; CGrafPtr myPort; PicHandle toolBox; WindowPtr theWindow; theWindow = MAC_WIN(gw); myPort = GetWindowPort(theWindow); SetPort(myPort); GetPortBounds(myPort,&r); toolBox = GetPicture(TOOLBOX_RSRC_ID); if (toolBox!=NULL) { SetRect(&dstRect,r.right-120,r.bottom-15,r.right-15,r.bottom); DrawPicture(toolBox,&dstRect); } SetRect(&dstRect,r.right-119+tool*15,r.bottom-14,r.right-104+tool*15,r.bottom); InvertRect(&dstRect); }
static void create_window(ws_state_list *p) { Rect screenRect, wRect; CGrafPtr screenPort; screenPort = CreateNewPort(); GetPortBounds(screenPort, &screenRect); DisposePort(screenPort); p->width = p->height = 500; p->swidth = screenRect.right - screenRect.left; p->sheight = screenRect.bottom - screenRect.top; p->window[0] = p->window[2] = 0.0; p->window[1] = p->window[3] = 1.0; p->viewport[0] = p->viewport[2] = 0; p->viewport[1] = (double)p->width * MWIDTH / p->swidth; p->viewport[3] = (double)p->height * MWIDTH / p->sheight; SetRect(&wRect, 0, 0, p->width, p->height); CreateNewWindow( kDocumentWindowClass, kWindowStandardDocumentAttributes | kWindowStandardHandlerAttribute, &wRect, &p->win); SetWindowTitleWithCFString(p->win, CFSTR("GKS 5")); ChangeWindowAttributes(p->win, 0, kWindowCloseBoxAttribute | kWindowResizableAttribute); RepositionWindow(p->win, NULL, kWindowCascadeOnMainScreen); ShowWindow(p->win); GetWindowPortBounds(p->win, &wRect); ClipRect(&wRect); set_xform(); }
static pascal void MyTimerHandler( EventLoopTimerRef inTimer, void *inUserData ) { CGrafPtr currentPort; Rect currentPortRect; RgnHandle flushRegion; SetPortWindowPort( (WindowRef) inUserData ); // Call the plug-in function "drawBall" which is defined in the plug-in interface. (*gDrawBallInterface)->drawBall( gDrawBallInterface ); // We are not drawing in response to an update or draw event, so if the window is buffered // (i.e. on Mac OS X) we need to flush the content to be drawn in the window. GetPort( ¤tPort ); if( QDIsPortBuffered( currentPort ) ) { GetPortBounds( currentPort, ¤tPortRect ); flushRegion = NewRgn(); RectRgn( flushRegion, ¤tPortRect ); QDFlushPortBuffer( currentPort, flushRegion ); DisposeRgn( flushRegion ); } }