示例#1
0
/*	DrawDialogCmd(cmd, lineHeight)

	Draws command starting from current pen loc.
	This is a help routine for DisplayDialogCmd.

	Thread Safety: DrawDialogCmd is not thread-safe.
*/
static void
DrawDialogCmd(const char *cmd, int lineHeight)
{
	PenState penState;
	char temp[MAXCMDLEN+1];
	const char *p1, *p2;
	int done = FALSE;
	int h, v;
	int len;
	
	GetPenState(&penState);
	h = penState.pnLoc.h;
	v = penState.pnLoc.v;
	
	p1 = cmd;								// p1 marches through command.
	do {
		p2 = strchr(p1, 0x0d);				// Find CR.
		if (p2 == NULL) {					// No more CRs ?
			strcpy(temp, p1);
			done = TRUE;
		}
		else {
			len = p2-p1;
			strncpy(temp, p1, len);
			temp[len] = 0;
		}
		
		CopyCStringToPascal(temp, (unsigned char*)temp);
		DrawString((unsigned char*)temp);
		
		v += lineHeight;					// Move to next line.
		MoveTo(h, v);
		p1 = p2+1;							// Point to start of next line.
	} while (!done);
}
示例#2
0
static void MyDrawUserItem(DialogRef theDialog, DialogItemIndex itemNo)
{
	DialogItemType itemType;
	Handle itemHandle;
	Rect itemBox;
	GetDialogItem(theDialog, itemNo, &itemType, &itemHandle, &itemBox);
	
	CGrafPtr savePort;
	GetPort(&savePort);
	SetPortDialogPort(theDialog);
	
	PenState penState;
	GetPenState(&penState);
	
	PenSize(3, 3);
	if (itemType & itemDisable)
	{
		Pattern gray;
		PenPat(GetQDGlobalsGray(&gray));
	}
	FrameRect(&itemBox);
	Rect userRect = {gUserV-4, gUserH-4, gUserV+4, gUserH+4};
	PaintRect(&userRect);
	
	SetPenState(&penState);
	SetPort(savePort);
}
static pascal void outline_hook(DialogRef dptr, short theItem){
	short  itemType;
	Handle itemHdl;
	Rect itemRect;
	PenState oldpen;
	GetDialogItem( dptr, theItem, &itemType, &itemHdl, &itemRect);
	GetPenState( &oldpen);
	PenSize( 3, 3);
	FrameRoundRect( &itemRect, 16, 16);
	SetPenState( &oldpen);
}
示例#4
0
void SaveQDDrawingState( QDDrawingState *ioDrawingState, const Boolean inSaveTextState )
{	GWorldPtr		tempWorld;
	GDHandle		tempDevice;

	Assert( ioDrawingState != nil );

	// Get the current GWorld, so I can access it's fields.
	GetGWorld( &tempWorld, &tempDevice );

	// Get the background state.
	GetBackColor( &ioDrawingState->backColor );
/*#if !( defined( TARGET_API_MAC_CARBON ) && ( TARGET_API_MAC_CARBON == 1 ) )
	if ( tempWorld->bkPixPat == nil )
		ioDrawingState->backPixPatH = nil;
	else
#endif
		ioDrawingState->backPixPatH = NewPixPat( );

	if ( ioDrawingState->backPixPatH != nil )
		GetPortBackPixPat( tempWorld, ioDrawingState->backPixPatH );
*/
	// Get the pen/foreground state.
	GetForeColor( &ioDrawingState->foreColor );
/*#if !( defined( TARGET_API_MAC_CARBON ) && ( TARGET_API_MAC_CARBON == 1 ) )
	if ( tempWorld->pnPixPat == nil )
		ioDrawingState->penPixPatH = nil;
	else
#endif
		ioDrawingState->penPixPatH = NewPixPat( );

	if ( ioDrawingState->penPixPatH != nil )
		GetPortPenPixPat( tempWorld, ioDrawingState->penPixPatH );
*/
	GetPenState( &ioDrawingState->penState );

	// Optionally save the text font, face, size and mode.
	ioDrawingState->haveTextState = inSaveTextState;
	if ( inSaveTextState ) {
		ioDrawingState->textStyle.tsFont = GetPortTextFont( tempWorld );
		ioDrawingState->textStyle.tsFace = GetPortTextFace( tempWorld );
		ioDrawingState->textStyle.tsSize = GetPortTextSize( tempWorld );
		ioDrawingState->textMode = GetPortTextMode( tempWorld );
	}

#if ALIST_USEAPPEARANCEMGR && TARGET_RT_MAC_CFM
	// If we're running under CFM and have Appearance Mgr 1.1 or later, use the ThemeDrawingState routines.
	if ( local_AppearanceMgrVersion( ) > 0x0110 )
		ioDrawingState->haveThemeState = ( GetThemeDrawingState( &ioDrawingState->themeState ) == noErr );
	else {
		ioDrawingState->haveThemeState = false;
		ioDrawingState->themeState = nil;
	}
#endif
}
示例#5
0
static pascal void drawProc(ControlRef inControl, SInt16 inPart)
{
	#pragma unused(inControl, inPart)
	
	int i;
	RGBColor saveForeColor;
	RGBColor saveBackColor;
	PenState savePenState;

	GetForeColor(&saveForeColor);	
	GetBackColor(&saveBackColor);	
	GetPenState(&savePenState);

	RGBForeColor(&rgbBlack);
	RGBBackColor(&rgbWhite);
	PenNormal();
	
	for (i = 0; i < sNumMonitors; i++)
	{
		RGBForeColor(&rgbGray);
		PaintRect(&sMonitors[i].scaledRect);
		if (sMonitors[i].isMain)
		{
			Rect r = sMonitors[i].scaledRect;
			InsetRect(&r, 1, 1);
			r.bottom = r.top + 6;
			RGBForeColor(&rgbWhite);
			PaintRect(&r);
			RGBForeColor(&rgbBlack);
			PenSize(1,1);
			MoveTo(r.left, r.bottom);
			LineTo(r.right, r.bottom);
		}
		if (sMonitors[i].device == sSelectedDevice)
		{
			PenSize(3,3);
			RGBForeColor(&rgbBlack);
			FrameRect(&sMonitors[i].scaledRect);
		}
		else
		{
			PenSize(1,1);
			RGBForeColor(&rgbBlack);
			FrameRect(&sMonitors[i].scaledRect);
		}
	}
	
	// restore the original pen state and colors
	RGBForeColor(&saveForeColor);	
	RGBBackColor(&saveBackColor);	
	SetPenState(&savePenState);
}
void _HYPlatformGraphicPane::_DrawHatchedLine (_HYRect lineDesc)
{
	PenState savePen;
	GetPenState (&savePen);
	if (abs(lineDesc.left-lineDesc.right)>5)
		PenPat (&penHatchPattern);
	else
		PenPat (&vertPenHatchPattern);
	PenSize (lineDesc.width, lineDesc.width);
	MoveTo  (lineDesc.left, lineDesc.top);
	LineTo  (lineDesc.right,lineDesc.bottom);
	SetPenState (&savePen);
}
示例#7
0
文件: lcd.c 项目: CNMAT/CNMAT-Externs
void setUpPalette(Lcd *x, RGBColor *oldColor, PaletteHandle *oldPalette)
{
	if (hasColorQD) {
		if (numPaletteColors>2){
			GetForeColor(oldColor);
			*oldPalette = GetPalette(&x->lcd_box.b_patcher->p_wind->w_gp);
			SetPalette(&x->lcd_box.b_patcher->p_wind->w_gp,x->lcd_palette,FALSE);
			PmForeColor(x->lcd_pIndex);
		}
	}
	GetPenState(&x->lcd_penState);
	PenMode(x->lcd_penMode);
	PenSize(1,1);
}
示例#8
0
	static bool openPostScript (void) {
		PenState pen;
		/*
		 * Flush GrafPort state.
		 */
		SetPort ((GrafPtr) theMacPort);   /* Some warning message could have drawn ThePort away... */
		GetPenState (& pen);
		PenSize (0, 0);
		Line (0, 0);
		PenSize (pen. pnSize.h, pen. pnSize.v);
		/*
		 * Send direct PostScript commands.
		 */
		if (PMSessionPostScriptBegin (theMacPrintSession)) {
			return Melder_error1 (L"Cannot begin PostScript.");
		}
		initPostScriptPage ();
		return true;
	}
// Will draw in center of view rectangle in the current QD graphics context;
// modeled after fps display.
// It won't try to clip the ends of the lines.
bool Crosshairs_Render(Rect &ViewRect)
{
	if (!_Crosshairs_IsActive) return _Crosshairs_IsActive;
	
	// Get the crosshair data
	CrosshairData &Crosshairs = GetCrosshairData();
	
	// Push previous state
	PenState OldPen;
	RGBColor OldBackColor, OldForeColor;
	
	GetPenState(&OldPen);
	GetBackColor(&OldBackColor);
	GetForeColor(&OldForeColor);
	
	// Get ready to draw the crosshairs
	PenNormal();
	
	// Drawing color
	RGBForeColor(&Crosshairs.Color);

	// Get the center location from the view rectangle	
	// Shift it down one, so that even line widths can come out right.
	short XCen = ((ViewRect.left + ViewRect.right) >> 1) - 1;
	short YCen = ((ViewRect.top + ViewRect.bottom) >> 1) - 1;
	
	// Separate for X and Y; the points are three on top/left and three on top/right:
	// Line-split position
	// Octagon vertex (half-way)
	// Farthest extent
	short OctaPoints[2][6];
	short Len;
	
	switch(Crosshairs.Shape)
	{
	case CHShape_RealCrosshairs:
	
		PenSize(1,Crosshairs.Thickness);
		
		// Left
		MoveTo(XCen-Crosshairs.FromCenter+Crosshairs.Thickness-1,YCen);
		Line(-Crosshairs.Length,0);
		
		// Right
		MoveTo(XCen+Crosshairs.FromCenter,YCen);
		Line(Crosshairs.Length,0);
		
		PenSize(Crosshairs.Thickness,1);
		
		// Top
		MoveTo(XCen,YCen-Crosshairs.FromCenter+Crosshairs.Thickness-1);
		Line(0,-Crosshairs.Length);
		
		// Bottom
		MoveTo(XCen,YCen+Crosshairs.FromCenter);
		Line(0,Crosshairs.Length);
		
		break;
		
	case CHShape_Circle:
		// This will really be an octagon, for OpenGL-rendering convenience
		
		// Precalculate the line endpoints, for convenience
		
		Len = Crosshairs.Length;
		OctaPoints[0][0] = XCen - Len;
		OctaPoints[0][5] = XCen + Len;
		OctaPoints[1][0] = YCen - Len;
		OctaPoints[1][5] = YCen + Len;
		
		Len = Len/2;
		OctaPoints[0][1] = XCen - Len;
		OctaPoints[0][4] = XCen + Len;
		OctaPoints[1][1] = YCen - Len;
		OctaPoints[1][4] = YCen + Len;
		
		Len = MIN(Len,Crosshairs.FromCenter);
		OctaPoints[0][2] = XCen - Len;
		OctaPoints[0][3] = XCen + Len;
		OctaPoints[1][2] = YCen - Len;
		OctaPoints[1][3] = YCen + Len;
		
		// We need to do 12 line segments, so we do them in 2*2*3 fashion
		
		for (int ix=0; ix<2; ix++)
		{
			int ixi = (ix > 0) ? 5 : 0;
			int ixid = (ix > 0) ? -1 : 1;
			for (int iy=0; iy<2; iy++)
			{
				int iyi = (iy > 0) ? 5 : 0;
				int iyid = (iy > 0) ? -1 : 1;
				
				// Vertical
				PenSize(Crosshairs.Thickness,1);
				MoveTo(OctaPoints[0][ixi],OctaPoints[1][iyi+2*iyid]);
				LineTo(OctaPoints[0][ixi],OctaPoints[1][iyi+iyid]);
				
				// Diagonal
				PenSize(Crosshairs.Thickness,Crosshairs.Thickness);
				LineTo(OctaPoints[0][ixi+ixid],OctaPoints[1][iyi]);
				
				// Horizontal
				PenSize(1,Crosshairs.Thickness);
				LineTo(OctaPoints[0][ixi+2*ixid],OctaPoints[1][iyi]);
			}
		}
		
		break;
	}
	
	// Pop previous state
	SetPenState(&OldPen);
	RGBBackColor(&OldBackColor);
	RGBForeColor(&OldForeColor);
		
	return _Crosshairs_IsActive;
}
示例#10
0
void InvertObject (CMap *Map, ObjectRecHdl theObjectHdl)
{
	GrafPtr		SavePort;
	PenState	penStatus;
	Rect		thisObjectRect;
	OSType		thisObjectType;

	GetPort (&SavePort);
	
	// now draw the selection points on the grouped / single region
	GetPenState (&penStatus);	// save original pen state
	PenSize (4, 4);
	PenMode (srcXor);

	GetObjectType (theObjectHdl, &thisObjectType);
	if (thisObjectType == kLineType)
	{
		LineObjectRecHdl	lineObjectHdl;
		LongPoint			LineStartLPoint, LineEndLPoint;
		Point				LineStartPoint, LineEndPoint;
		
		lineObjectHdl = (LineObjectRecHdl) theObjectHdl;

		LineStartLPoint = (**lineObjectHdl).lineStartLPoint;
		LineEndLPoint   = (**lineObjectHdl).lineEndLPoint;
		Map -> GetScrPoint (&LineStartLPoint, &LineStartPoint);
		Map -> GetScrPoint (&LineEndLPoint,   &LineEndPoint);
		
		MyMoveTo (LineStartPoint.h, LineStartPoint.v);
		MyLineTo (LineStartPoint.h, LineStartPoint.v);
		
		MyMoveTo (LineEndPoint.h, LineEndPoint.v);
		MyLineTo (LineEndPoint.h, LineEndPoint.v);
	}
	else
	{
		GetObjectScrRect (Map, theObjectHdl, &thisObjectRect);
	
		thisObjectRect.top -= 1;
		thisObjectRect.left -= 1;
		thisObjectRect.right -= 3;
		thisObjectRect.bottom -= 3;
	
		MyMoveTo (thisObjectRect.left, thisObjectRect.top);
		MyLineTo (thisObjectRect.left, thisObjectRect.top);
	
		MyMoveTo (thisObjectRect.right, thisObjectRect.top);
		MyLineTo (thisObjectRect.right, thisObjectRect.top);
	
		MyMoveTo (thisObjectRect.right, thisObjectRect.bottom);
		MyLineTo (thisObjectRect.right, thisObjectRect.bottom);
	
		MyMoveTo (thisObjectRect.left, thisObjectRect.bottom);
		MyLineTo (thisObjectRect.left, thisObjectRect.bottom);
	}

	SetPenState (&penStatus);

	SetPort (SavePort);

	return;
}