static void drawcolorpopup (Rect menurect) {

	short i, j;
	Rect r;	
	
	pushforecolor (&lightbluecolor);
	
	PaintRect (&menurect);
	
	for (i = 0; i < 8; i++) {
	
		for (j = 0; j < 32; j++) {
		
			getitemrect (i * 32 + j + 1, &r);
			
			OffsetRect (&r, menurect.left, menurect.top);
			
			RGBForeColor (&blackcolor);
			
			InsetRect (&r, 1, 1);
			
			PaintRect (&r);
			
			InsetRect (&r, 1, 1);
			
			RGBForeColor (&(*ctable) [i * 32 + j].rgb);
			
			PaintRect (&r);
			} /*for*/
		} /*for*/
	
	popforecolor ();
	} /*drawcolorpopup*/

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//	DrawPowerMeter
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
static void DrawPowerMeter(float avePower, float peakValue, int yoffset )
{
	if(avePower < -50.0 ) avePower = -50.0;		// only show from -50 -> 0dB
	float scaledPower = 200.0 * (avePower + 50.0) / 50.0;
	
	if(peakValue < -50.0 ) peakValue = -50.0;		// only show from -50 -> 0dB
	float scaledPeak = 200.0 * (peakValue + 50.0) / 50.0;
	
	RGBColor color;
	color.red = 0;
	color.blue = 0;
	color.green = 65535;
	RGBForeColor(&color);
	
	const int xoffset = 20;
	
	
	Rect powerRect = {yoffset, xoffset, yoffset+8, xoffset + int(scaledPower) };
	PaintRect(&powerRect);
	
	powerRect.left = xoffset + int(scaledPower);
	powerRect.right = xoffset + 200;
	color.red = 32768;
	color.blue = 32768;
	RGBForeColor(&color );
	PaintRect(&powerRect);
	
	color.red = 40000;
	color.blue = 40000;
	color.green = 40000;
	RGBForeColor(&color );
	MoveTo(xoffset + int(scaledPeak), yoffset );
	LineTo(xoffset + int(scaledPeak), yoffset+7 );
}

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 cPict::draw(){
	RGBColor store_color;
	Rect rect = frame;
	GrafPtr cur_port;
	GetPort(&cur_port);
	SetPortWindowPort(parent->win);
	
	if(!visible){ // Erase it
		InsetRect(&rect, -3, -3);
		tileImage(rect,bg_gworld,bg[parent->bg]);
		return;
	}
	if(picNum < 0) { // Just fill with black
		GetForeColor(&store_color);
		ForeColor(blackColor);
		PaintRect(&rect);
		RGBForeColor(&store_color);
		return;
	}
	GetBackColor(&store_color);
	BackColor(whiteColor);
	
	drawPict()[picType](picNum,rect);
	if(drawFramed) drawFrame(2,0);
	SetPort(cur_port);
}

void MyDrawString(/*short dir,*/ short h, short v, char *s,Boolean framed,short selectMode)
{
	Rect r;
	if(sharedPrinting)selectMode = POINTDRAWFLAG;
	if(strlen(s) >0)
	{
		GetTextOffsets(/*dir,*/s,&h,&v);
		GetStringRect(s,h,v,&r);
		if(selectMode == BADPOINTDRAWFLAG)selectMode = POINTDRAWFLAG;
		if(selectMode == POINTDRAWFLAG)
		{
			EraseRect(&r);
			MyMoveTo(h,v);
			drawstring(s);
		}
		if(framed)
		{		
			
			if(selectMode != POINTDRAWFLAG)
			{
				PenMode(patXor);PaintRect(&r);
			}
			PenMode(patCopy);
			MyFrameRect(&r);
		}
	}
}

void cPict::drawCustomMonstLg(short num, Rect to_rect){
	static const short adj[4] = {0, 8, 4, 12};
	num += adj[animFrame];
	Rect small_monst_rect = {0,0,18,14};
	to_rect.right = to_rect.left + 28;
	to_rect.bottom = to_rect.top + 36;
	PaintRect(&to_rect);
	
	Rect from_rect;
	short n = get_custom_rect(num,from_rect);
	if(!isSheetSet(SHEET_CUSTOM,n)) throw xMissingSheet(SHEET_CUSTOM,n);
	GWorldPtr from_gw = customSheets[n];
	OffsetRect(&small_monst_rect,to_rect.left,to_rect.top);
	rect_draw_some_item(from_gw, from_rect, small_monst_rect, (Point){0,0}, transparent);
	
	n = get_custom_rect(num,from_rect);
	if(!isSheetSet(SHEET_CUSTOM,n)) throw xMissingSheet(SHEET_CUSTOM,n);
	from_gw = customSheets[n];
	OffsetRect(&small_monst_rect,14,0);
	rect_draw_some_item(from_gw, from_rect, small_monst_rect, (Point){0,0}, transparent);
	
	n = get_custom_rect(num,from_rect);
	if(!isSheetSet(SHEET_CUSTOM,n)) throw xMissingSheet(SHEET_CUSTOM,n);
	from_gw = customSheets[n];
	OffsetRect(&small_monst_rect,-14,18);
	rect_draw_some_item(from_gw, from_rect, small_monst_rect, (Point){0,0}, transparent);
	
	n = get_custom_rect(num,from_rect);
	if(!isSheetSet(SHEET_CUSTOM,n)) throw xMissingSheet(SHEET_CUSTOM,n);
	from_gw = customSheets[n];
	OffsetRect(&small_monst_rect,14,0);
	rect_draw_some_item(from_gw, from_rect, small_monst_rect, (Point){0,0}, transparent);
}

static void mac_ctl_refresh_trc()
{
	int		i;
	Rect	r;
	RGBColor	black={0,0,0},
				darkGray={0x2000,0x2000,0x2000};

	if( !win.show ) return;
	SetPortWindowPort(win.ref);
	for( i=0; i<16; i++ ){
		DrawInstrumentName(i, instr_comment[i].comm);
	}
	
#define MAX_NOTE_NUM 120
	r.top=		UPPER_MERGIN;
	r.left=		LEFT_MERGIN;
	r.bottom=	r.top+CHANNEL_HIGHT*16;
	r.right=	r.left+CHANNEL_WIDTH*MAX_NOTE_NUM;
	RGBForeColor(&darkGray);
	PaintRect(&r);
	
		//draw separater line
	RGBForeColor(&black);
	for(i=1; i<16; i++){	//horizontal
		MoveTo(LEFT_MERGIN, UPPER_MERGIN+CHANNEL_HIGHT*i-1);
		Line(CHANNEL_WIDTH*MAX_NOTE_NUM-1, 0);
	}
	for(i=12; i<MAX_NOTE_NUM; i+=12){	//vertical
		MoveTo(LEFT_MERGIN+CHANNEL_WIDTH*i-1, UPPER_MERGIN);
		Line(0, CHANNEL_HIGHT*16-1);
	}
}

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);
}

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 PreviewDrawer(ControlRef Ctrl, void *Data)
{
	// Don't need the data arg here
	CrosshairData &Crosshairs = GetCrosshairData();	// An alias for the global crosshair data
	
	// No need for the window context -- it's assumed
	Rect Bounds = {0,0,0,0};
	
	GetControlBounds(Ctrl, &Bounds);
	
	// Get ready to draw!
	PenNormal();
	
	// Draw the background
	RGBForeColor(&BkgdColor);
	PaintRect(&Bounds);
	
	// Clip to inside of box
	ClipRect(&Bounds);
	
	// Draw the crosshairs
	Crosshairs_Render(Bounds);
	
	// Draw the boundary line
	ForeColor(blackColor);
	FrameRect(&Bounds);
}

static pascal void ListBoxDrawProc( ControlRef browser , DataBrowserItemID item , DataBrowserPropertyID property ,
    DataBrowserItemState itemState , const Rect *itemRect , SInt16 depth , Boolean isColorDevice )
{

    CFStringRef      cfString;
    long        systemVersion;

    cfString  = CFStringCreateWithFormat( NULL, NULL, CFSTR("Row %d"), item );
  
    ThemeDrawingState themeState ;
    GetThemeDrawingState( &themeState ) ;
  
    if ( itemState == kDataBrowserItemIsSelected )      //  In this sample we handle the "selected" state, all others fall through to our "active" state
    {
        Gestalt( gestaltSystemVersion, &systemVersion );
        if ( (systemVersion >= 0x00001030) && (IsControlActive( browser ) == false) )  //  Panther DB starts using kThemeBrushSecondaryHighlightColor for inactive browser hilighting
            SetThemePen( kThemeBrushSecondaryHighlightColor, 32, true );
        else
            SetThemePen( kThemeBrushPrimaryHighlightColor, 32, true );

        PaintRect( itemRect );                //  First paint the hilite rect, then the text on top
        SetThemeDrawingState( themeState , false ) ;
    }
    DrawThemeTextBox( cfString, kThemeApplicationFont, kThemeStateActive, true, itemRect, teFlushDefault, NULL );
    if ( cfString != NULL )  
        CFRelease( cfString );
    SetThemeDrawingState( themeState , true ) ;
}

static void NotificationWndOnPaint(HWND hwnd, NotificationWnd *wnd)
{
    PAINTSTRUCT ps;
    HDC hdcWnd = BeginPaint(hwnd, &ps);

    ClientRect rect(hwnd);
    DoubleBuffer buffer(hwnd, rect);
    HDC hdc = buffer.GetDC();
    HFONT oldfnt = SelectFont(hdc, wnd->font);

    RECT rTmp = rect.ToRECT();
    DrawFrameControl(hdc, &rTmp, DFC_BUTTON, DFCS_BUTTONPUSH);
    if (wnd->highlight) {
        SetBkMode(hdc, OPAQUE);
        SetTextColor(hdc, GetSysColor(COLOR_HIGHLIGHTTEXT));
        SetBkColor(hdc, GetSysColor(COLOR_HIGHLIGHT));
    }
    else {
        SetBkMode(hdc, TRANSPARENT);
        SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
    }

    rect.Inflate(-PADDING, -PADDING);
    RectI rectMsg = rect;
    if (wnd->hasProgress)
        rectMsg.dy -= PROGRESS_HEIGHT + PADDING / 2;
    if (wnd->hasCancel)
        rectMsg.dx -= 20;
    ScopedMem<WCHAR> text(win::GetText(hwnd));
    rTmp = rectMsg.ToRECT();
    DrawText(hdc, text, -1, &rTmp, DT_SINGLELINE | DT_NOPREFIX);

    if (wnd->hasCancel) {
        rTmp = GetCancelRect(hwnd).ToRECT();
        DrawFrameControl(hdc, &rTmp, DFC_CAPTION, DFCS_CAPTIONCLOSE | DFCS_FLAT);
    }

    if (wnd->hasProgress) {
        rect.dx = wnd->progressWidth;
        rect.y += rectMsg.dy + PADDING / 2;
        rect.dy = PROGRESS_HEIGHT;
        PaintRect(hdc, rect);

        rect.x += 2;
        rect.dx = (wnd->progressWidth - 3) * wnd->progress / 100;
        rect.y += 2;
        rect.dy -= 3;

        HBRUSH brush = GetStockBrush(BLACK_BRUSH);
        rTmp = rect.ToRECT();
        FillRect(hdc, &rTmp, brush);
        DeleteObject(brush);
    }

    SelectFont(hdc, oldfnt);

    buffer.Flush(hdcWnd);
    EndPaint(hwnd, &ps);
}

static void DrawItem(Rect *r,short i,short j)
{
	Rect	penRect;
	short	cx=(r->left+r->right)/2,cy=(r->top+r->bottom)/2;
	
	SetRect(&penRect,cx-(j+1)/2,cy-(i+1)/2,cx+(j+2)/2,cy+(i+2)/2);
	PaintRect(&penRect);
}

void Paragraph::Style::Init() {
	align = ALIGN_LEFT;
	before = lm = rm = indent = after = 0;
	bulletindent = 0;
	bulletsize = Size(0, 0);
	bulletcolor = Black;
	bullet = PaintRect();
}

static
int PaintCtrlChar(USPFONT *uspFont, HDC hdc, int xpos, int ypos, ULONG chValue, COLORREF fg, COLORREF bg)
{
	WCHAR str[8];
	RECT  rect;
	SIZE  size;
	int	  mode = USP_CTLCHR_HEX;
	int   height;

	// get the textual representation of the control-character
	CtrlStr(chValue, mode, str, 8);

	// get the text dimension (only need width)
	GetTextExtentPoint32(hdc, str, wcslen(str), &size);

	// center the control-character "glyph" 
	xpos += uspFont->yborder/2 + 1;

	if(mode == USP_CTLCHR_ASC || mode == USP_CTLCHR_HEX)
		height = max(uspFont->capheight, uspFont->numheight);
	else
		height = uspFont->numheight;

	SetRect(
		&rect, 
		xpos + 1, 
		ypos + uspFont->tm.tmAscent - height - uspFont->yborder,
		xpos + size.cx + uspFont->xborder * 2 - 2, 
		ypos + uspFont->tm.tmAscent + uspFont->yborder
	  );

	//if(rect.top < ypos+1)
	//	rect.top = ypos+1;
	
	// prepare the background 'round' rectangle
	PaintRect(hdc, &rect, bg);
	InflateRect(&rect, 1,-1);
	PaintRect(hdc, &rect, bg);

	// finally paint the text
	SetTextColor(hdc, fg);
	TextOut(hdc, xpos + uspFont->xborder, ypos, str, wcslen(str));

	return 0;
}

void CCaptionPainter::PaintSolidCaption(CRect& capRect, COLORREF theColor)
{
	ASSERT(m_pParentDlg);
	CWnd& wnd = (CWnd&)*m_pParentDlg;

	// Get caption DC and rectangle
	CWindowDC dcWin(&wnd);					// window DC
	CDC dcMem;									// memory DC
	dcMem.CreateCompatibleDC(&dcWin);		// ...create it

	CBitmap bm;
	CBitmap* pOldBitmap;

	int cxCap = capRect.Width();
	int cyCap = capRect.Height();

	bm.CreateCompatibleBitmap(&dcWin, cxCap, cyCap); // create one
	pOldBitmap = dcMem.SelectObject(&bm);	// select bitmap into memory DC


	if (!m_bActive) 
	{
		// Inactive caption
		PaintRect(dcMem, 0, 0, cxCap, cyCap, GetSysColor(COLOR_INACTIVECAPTION));
	}
	else
	{
		PaintRect(dcMem, 0, 0, cxCap, cyCap, theColor);
	}

	// draw icon and buttons
	int cxIcon  = DrawIcon( &dcMem );
	int cxButns = DrawButtons( &dcMem, capRect.Size() );

	CRect rc(CPoint(0,0), capRect.Size()); // text rectangle
	rc.left  += cxIcon+2;						// start after icon
	rc.right -= cxButns;							// don't draw past buttons
	// draw text
	DrawWindowText(&dcMem, rc);
	
	// blast bits to screen
	dcWin.BitBlt(capRect.left, capRect.top,
					capRect.Width(),capRect.Height(),&dcMem,0,0,SRCCOPY);
	dcMem.SelectObject(pOldBitmap); // restore DC
}

void eraseRect( Rect *rect )
{
	RGBColor	color;
	
	color.red = color.green = color.blue = 8700;
	
	RGBForeColor( &color );
	PaintRect( rect );
}

void cPict::drawPresetBoom(short num, Rect to_rect){
	if(!isSheetSet(SHEET_BOOM)) throw xMissingSheet(SHEET_BOOM);
	GWorldPtr from_gw = boom;
	Rect from_rect = calc_rect(num % 8, num / 8);
	to_rect.right = to_rect.left + 28;
	to_rect.bottom = to_rect.top + 36;
	PaintRect(&to_rect);
	rect_draw_some_item(from_gw, from_rect, to_rect, (Point){0,0}, transparent);
}

void cPict::drawPartyPc(short num, Rect to_rect){
	printf("Drawing graphic %i as a custom space pic.\n",num);
	to_rect.right = to_rect.left + 28;
	to_rect.bottom = to_rect.top + 32;
	if(!isSheetSet(SHEET_PARTY)) throw xMissingSheet(SHEET_PARTY);
	GWorldPtr from_gw = save;
	Rect from_rect = get_custom_rect(num);
	PaintRect(&to_rect);
	rect_draw_some_item(from_gw, from_rect, to_rect, (Point){0,0}, transparent);
}

void apply_unseen_mask()
{
	Rect base_rect = {9,9,53,45},to_rect,big_to = {13,13,337,265};
	GrafPtr old_port;
	short i,j,k,l;
	ConstPatternParam c;
	bool need_bother = false;
	
	if (PSD[SDF_NO_FRILLS] > 0)
		return;

	if ((is_combat()) && (which_combat_type == 0))
		return;
	if (!(is_out()) && (univ.town->lighting_type > 0))
		return;
		
	for (i = 0; i < 11; i++)
		for (j = 0; j < 11; j++) 
			if (unexplored_area[i + 1][j + 1] == 1)
				need_bother = true;
	if (need_bother == false)
		return;
				
	GetPort(&old_port);
	SetPort(terrain_screen_gworld);
	//p = *bw_pats[3];
	//c = p;
	c = *bw_pats[3];
	PenPat(c);
	PenMode(notPatOr);
	
	for (i = 0; i < 11; i++)
		for (j = 0; j < 11; j++) 
			if (unexplored_area[i + 1][j + 1] == 1) {

					to_rect = base_rect;
					OffsetRect(&to_rect,-28 + i * 28,-36 + 36 * j);
					SectRect(&to_rect,&big_to,&to_rect);
					PaintRect(&to_rect);
					//PaintRoundRect(&to_rect,4,4);
					for (k = i - 2; k < i + 1; k++)
						for (l = j - 2; l < j + 1; l++)
							if ((k >= 0) && (l >= 0) && (k < 9) && (l < 9) && ((k != i - 1) || (l != j - 1)))
								terrain_there[k][l] = -1;

				}
	
	//p = *bw_pats[6];
	//c = p;
	c = *bw_pats[6];
	PenPat(c);
	PenMode(patCopy);
	SetPort(old_port);
}