area.cpp

Windows 图形编程 书籍

				{
					if ( rbutton.IsOnButton(lParam) )
						MessageBox(hWnd, "Rectangle Button Clicked", "PtInRegion", MB_OK);

					if ( ebutton.IsOnButton(lParam) )
						MessageBox(hWnd, "Ellipse Button Clicked", "PtInRegion", MB_OK);
				}
			}
			return 0;

		default:
			lr = DefWindowProc(hWnd, uMsg, wParam, lParam);
	}

	return lr;
}


const TCHAR * SysColorName[] = 
{
	"COLOR_SCROLLBAR",
	"COLOR_BACKGROUND",
	"COLOR_ACTIVECAPTION",
	"COLOR_INACTIVECAPTION",
	"COLOR_MENU",
	"COLOR_WINDOW",
	"COLOR_WINDOWFRAME",
	"COLOR_MENUTEXT",
	"COLOR_WINDOWTEXT",
	"COLOR_CAPTIONTEXT",
	"COLOR_ACTIVEBORDER",
	"COLOR_INACTIVEBORDER",
	"COLOR_APPWORKSPACE",
	"COLOR_HIGHLIGHT",
	"COLOR_HIGHLIGHTTEXT",
	"COLOR_BTNFACE",
	"COLOR_BTNSHADOW",
	"COLOR_GRAYTEXT",
	"COLOR_BTNTEXT",
	"COLOR_INACTIVECAPTIONTEXT",
	"COLOR_BTNHIGHLIGHT",
	"COLOR_3DDKSHADOW",
	"COLOR_3DLIGHT",
	"COLOR_INFOTEXT",
	"COLOR_INFOBK",
	"??",
	"COLOR_HOTLIGHT",
	"COLOR_GRADIENTACTIVECAPTION",
	"COLOR_GRADIENTINACTIVECAPTION"
};


void KMyCanvas::TestSysColorBrush(HDC hDC)
{
	for (int idx=0; GetSysColorBrush(idx); idx++)
	{
		TCHAR temp[64];

		int y = idx*18 + 20;

		SelectObject(hDC, GetSysColorBrush(idx));

		TextOut(hDC, 20, y, SysColorName[idx], _tcslen(SysColorName[idx]));

		wsprintf(temp, "%2d %08x", idx, GetSysColorBrush(idx));
		TextOut(hDC, 280, y, temp, _tcslen(temp));

		COLORREF cr = GetSysColor(idx);
		wsprintf(temp, "RGB(0x%02x, 0x%02x, 0x%02x)", GetRValue(cr), GetGValue(cr), GetBValue(cr));
		TextOut(hDC, 540, y, temp, _tcslen(temp));

		Rectangle(hDC, 420, y, 520, y+15);

		BOOL rslt = DeleteObject(GetSysColorBrush(idx));
	}
}


void Mark(HDC hDC, int x, int y, int dx, int dy, const char * yl, const TCHAR * xl)
{
	HGDIOBJ hPen = CreatePen(PS_SOLID, 1, RGB(0xFF, 0, 0));
	HGDIOBJ hOld = SelectObject(hDC, hPen);

	TextOut(hDC, x+dx,y,      yl, _tcslen(yl));
	TextOut(hDC, x+2, y+dy-8, xl, _tcslen(xl));

	MoveToEx(hDC, x+dx, y, NULL); LineTo(hDC, x, y); LineTo(hDC, x, y+dy);
	
	SelectObject(hDC, hOld);
	DeleteObject(hPen);
}


void KMyCanvas::TestRectangle(HDC hDC)
{
	HBRUSH hBlue = CreateSolidBrush(RGB(0, 0, 0xFF));

	SelectObject(hDC, hBlue);
	
	for (int i=0; i<6; i++)
	{
		SetViewportOrgEx(hDC, (i%3)*180, (i/3)*180, NULL);

		const TCHAR * Title []= 
		{ 
			_T("black pen"), 
			_T("null pen"), 
			_T("3-pixel pen"), 
			_T("black pen, advanced"), 
			_T("3-pixel inside frame pen"), 
			_T("red pen, R2_NOTCOPYPEN")
		};

		HGDIOBJ hPen;
		
		switch (i)
		{
			case 0: hPen = GetStockObject(BLACK_PEN);
					break;
			case 1: hPen = GetStockObject(NULL_PEN);
					break;
			case 2: hPen = CreatePen(PS_SOLID, 3, RGB(0, 0, 0));
					break;
			case 3: hPen = GetStockObject(BLACK_PEN); SetGraphicsMode(hDC, GM_ADVANCED);
				    break;
			case 4: hPen = CreatePen(PS_INSIDEFRAME, 3, RGB(0, 0, 0));
					break;
			case 5: hPen = CreatePen(PS_SOLID, 1, RGB(0xFF, 0x0, 0x0));
				    SetROP2(hDC, R2_NOTCOPYPEN);
		}

		HGDIOBJ hOld = SelectObject(hDC, hPen);
		Rectangle(hDC, 60, 60, 50, 50);
		SelectObject(hDC, hOld);
		SetGraphicsMode(hDC, GM_COMPATIBLE);
		DeleteObject(hPen);
		SetROP2(hDC, R2_COPYPEN);

		ZoomRect(hDC, 48, 48, 62, 62, 80, 50, 7);
		TextOut(hDC, 50, 180, Title[i], _tcslen(Title[i]));

		Mark(hDC, 80+ 2*8, 50+ 2*8, -25, -25, "T", "L");
		Mark(hDC, 80+12*8, 50+12*8,  25,  25, "B", "R");
	}

	////////////////////
	for (i=0; i<4; i++)
	{
		SetViewportOrgEx(hDC, (i%4)*180, 360+(i/4)*180, NULL);

		const TCHAR * Title []= 
		{ 
			_T("FillRect"), 
			_T("FrameRect"), 
			_T("InvertRect"), 
			_T("DrawFocusRect")
		};
	
		RECT rect = { 50, 50, 60, 60 };

	//	InflateRect(&rect, 2, 2);
	//	HBRUSH hBlue = CreateSolidBrush(RGB(0, 0, 0xFF));
	//	FillRect(hDC, & rect, hBlue);
	//	DeleteObject(hBlue);
	//	InflateRect(&rect, -2, -2);

		switch (i)
		{
			case 0:
				FillRect(hDC, & rect, hBlue);
				break;

			case 1:
				FrameRect(hDC, & rect, hBlue);
				break;

			case 2:
				InvertRect(hDC, & rect);
				break;

			case 3:
				DrawFocusRect(hDC, & rect);
				break;
		}

		ZoomRect(hDC, 48, 48, 62, 62, 80, 50, 7);
		TextOut(hDC, 50, 180, Title[i], _tcslen(Title[i]));

		Mark(hDC, 80+ 2*8, 50+ 2*8, -25, -25, "T", "L");
		Mark(hDC, 80+12*8, 50+12*8,  25,  25, "B", "R");

	}

	SelectObject(hDC, GetStockObject(WHITE_BRUSH));
	DeleteObject(hBlue);

	SetViewportOrgEx(hDC, 0, 0, NULL);
}


void DrawControls(HDC hDC, int typ, const int state[], int no)
{
	for (int s=0; s<no; s++)
	{
		int x =    s * 56 + 20;
		int y = typ  * 56 - 40;

		RECT rect = { x, y, x+40, y+40 };

		InflateRect(&rect, 3, 3);
		FillRect(hDC, & rect, GetSysColorBrush(COLOR_BTNFACE));
		InflateRect(&rect, -3, -3);

		DrawFrameControl(hDC, & rect, typ, state[s]);
	}
}

void KMyCanvas::TestDrawFrameControl(HDC hDC)
{
	////////////////////////
	const int CaptionState[] = { DFCS_CAPTIONCLOSE,
								 DFCS_CAPTIONMIN,
								 DFCS_CAPTIONMAX,
								 DFCS_CAPTIONRESTORE,
								 DFCS_CAPTIONHELP,
								 DFCS_CAPTIONHELP | DFCS_FLAT,
								 DFCS_CAPTIONHELP | DFCS_INACTIVE
	};

	DrawControls(hDC, DFC_CAPTION, CaptionState, sizeof(CaptionState)/sizeof(int));

	////////////////////////
	const int ButtonState[] = { DFCS_BUTTONCHECK, 
								DFCS_BUTTONRADIOIMAGE,
							    DFCS_BUTTONRADIOMASK, 
								DFCS_BUTTONRADIO,
								DFCS_BUTTON3STATE,
								DFCS_BUTTONPUSH,
								DFCS_BUTTONPUSH | DFCS_FLAT,
								DFCS_BUTTONPUSH | DFCS_INACTIVE

	}; 	

	DrawControls(hDC, DFC_BUTTON, ButtonState, sizeof(ButtonState)/sizeof(int));

	////////////////////////
	const int MenuState[] = { DFCS_MENUARROW,
							  DFCS_MENUCHECK,
							  DFCS_MENUBULLET,
							  DFCS_MENUARROWRIGHT,
							  DFCS_MENUARROWRIGHT | DFCS_FLAT,
							  DFCS_MENUARROWRIGHT | DFCS_INACTIVE
	};
	DrawControls(hDC, DFC_MENU, MenuState, sizeof(MenuState)/sizeof(int));

	////////////////////////
	const int ScrollState[] = { DFCS_SCROLLUP,
								DFCS_SCROLLDOWN,
								DFCS_SCROLLLEFT,
								DFCS_SCROLLRIGHT,
								DFCS_SCROLLCOMBOBOX,
								DFCS_SCROLLSIZEGRIP,
								DFCS_SCROLLSIZEGRIPRIGHT,
								DFCS_SCROLLSIZEGRIPRIGHT | DFCS_FLAT,
								DFCS_SCROLLSIZEGRIPRIGHT | DFCS_INACTIVE
	};
	
	DrawControls(hDC, DFC_SCROLL, ScrollState, sizeof(ScrollState)/sizeof(int));

	/////////////////////////
	const int PopupMenuState[] = { 0,
							  1,
							  2,
							  3,
							  3 | DFCS_FLAT,
							  3 | DFCS_INACTIVE
	};

	DrawControls(hDC, DFC_POPUPMENU, PopupMenuState, sizeof(PopupMenuState)/sizeof(int));

	//////////////////////////
	SetViewportOrgEx(hDC, 0, 280, NULL);

	for (int e=0; e<4; e++)
	{
		int Edge[] = { EDGE_RAISED, EDGE_SUNKEN, EDGE_ETCHED, EDGE_BUMP };
		int Flag[] = { BF_MIDDLE | BF_BOTTOM, 
					   BF_MIDDLE | BF_BOTTOMLEFT, 
					   BF_MIDDLE | BF_BOTTOMLEFT | BF_TOP,
					   BF_MIDDLE | BF_RECT, 
					   BF_MIDDLE | BF_RECT | BF_FLAT, 
					   BF_MIDDLE | BF_RECT | BF_MONO, 
					   BF_MIDDLE | BF_RECT | BF_SOFT, 
					   BF_MIDDLE | BF_RECT | BF_DIAGONAL, 
					   BF_MIDDLE | BF_RECT | BF_ADJUST };

		for (int f=0; f<sizeof(Flag)/sizeof(Flag[0]); f++)
		{
			RECT rect = { f*56+20, e*56 + 20, f*56+60, e*56+60 };

			InflateRect(&rect, 3, 3);   // bigger background
			FillRect(hDC, & rect, GetSysColorBrush(COLOR_BTNFACE));
			InflateRect(&rect, -3, -3); // restore size

			DrawEdge(hDC, & rect, Edge[e], Flag[f]);
		}
	}

	SetViewportOrgEx(hDC, 0, 0, NULL);
}


void Label(HDC hDC, int x, int y, const TCHAR * mess)
{
	TextOut(hDC, x, y, mess, _tcslen(mess));
}


void KMyCanvas::TestEllipse(HDC hDC)
{
	int nSave = SaveDC(hDC);

	HGDIOBJ hBrush = CreateSolidBrush(RGB(0xFF, 0xFF, 0));
	SelectObject(hDC, hBrush);

	// Zoomed in display shows the dimension of ellipse
	
	for (int i=0; i<=6; i+=3)
	{
		SetViewportOrgEx(hDC, i*200/3, 0, NULL);

		HGDIOBJ hPen = CreatePen(PS_INSIDEFRAME, i/3, RGB(0,0,0xFF));
		SelectObject(hDC, hPen);

		if (i==3)
			SetGraphicsMode(hDC, GM_ADVANCED);

		Ellipse(hDC, 30, 30, 40+i, 40+i);
		SetGraphicsMode(hDC, GM_COMPATIBLE);

		SelectObject(hDC, GetStockObject(BLACK_PEN));
		DeleteObject(hPen);

		ZoomRect(hDC, 28, 28, 42+i, 42+i, 70, 40, 7);
	
		Mark(hDC, 70+ 2*8,     40+ 2*8,     -30, -30, "Top", "Left");
		Mark(hDC, 70+12*8+i*8, 40+12*8+i*8,  30,  30, "Bottom", "Right");

		switch (i)
		{
			case 0: Label(hDC, 70, 230, "Solid pen"); break;
			case 3: Label(hDC, 70, 230, "Solid pen, advanced mode"); break;
			case 6: Label(hDC, 70, 230, "Inside frame pen"); break;
		}
	}


	const int A = 100;
	const int B = 100;
	
	POINT P[5] = { -A, -B, A, -B, A, B, -A, B, -A, -B };
	POINT S    = {  A*3/2,    0 };
	POINT E    = {  -A*4/3, - B*3/4 };

	for (i=0; i<3; i++)
	{
		if ( i==0 )
		{
			SetViewportOrgEx(hDC, 160, 420, 0);
			SetArcDirection(hDC, AD_COUNTERCLOCKWISE);
			Label(hDC, -65, P[0].y-60, "Chord, Anticlockwise");
		}
		else
		{
			SetViewportOrgEx(hDC, 160 + i* A * 3, 420, 0);
			SetArcDirection(hDC, AD_CLOCKWISE);

			if ( i==1)
				Label(hDC, -55, P[0].y-60, "Pie, Clockwise");
			else if (i==2)
			{
				Label(hDC, -30, P[0].y-60, "Ellipse");
			}
		}
	
		// defining lines
		{
			HGDIOBJ hOldBrush = SelectObject(hDC, GetStockObject(HOLLOW_BRUSH));

			HPEN hPen = CreatePen(PS_DOT, 0, RGB(0xFF, 0, 0)); // dotted line
			HPEN hOld = (HPEN) SelectObject(hDC, hPen);

			// bounding rectangle, start/end lines
			Rectangle(hDC, P[0].x, P[0].y, P[2].x, P[2].y);
			Ellipse(hDC, P[0].x, P[0].y, P[2].x, P[2].y);

			if ( i!=2 )
			{
				Line(hDC, 0, 0, S.x, S.y); 
				Line(hDC, 0, 0, E.x, E.y);
			}

			SelectObject(hDC, hOld);
			DeleteObject(hPen);

			SelectObject(hDC, hOldBrush);
		}

		LOGBRUSH logbrush = { BS_SOLID, RGB(0, 0, 0xFF), 0 };

		HPEN hPen;
		
		switch ( i )
		{
			case 0:	
				hPen = ExtCreatePen(PS_COSMETIC | PS_ALTERNATE, 1, & logbrush, 0, NULL); 
				break;
			
			case 1:	
				hPen = ExtCreatePen(PS_GEOMETRIC | PS_INSIDEFRAME | PS_JOIN_MITER, 10, & logbrush, 0, NULL); 
				break;

			case 2:	
				logbrush.lbStyle = BS_HATCHED;
				logbrush.lbHatch = HS_DIAGCROSS;
				hPen = ExtCreatePen(PS_GEOMETRIC | PS_INSIDEFRAME, 10, & logbrush, 0, NULL); 
				break;
		}

		HPEN hOld = (HPEN) SelectObject(hDC, hPen);

		switch ( i )
		{
			case 0:
				Chord(hDC, P[0].x, P[0].y, P[2].x, P[2].y, S.x, S.y, E.x, E.y);
				break;

			case 1:
				Pie(hDC, P[0].x, P[0].y, P[2].x, P[2].y, S.x, S.y, E.x, E.y);
				break;

			case 2:
				{
					HINSTANCE hCards = LoadLibrary("cards.dll");

					SetBkColor(hDC, RGB(0xFF, 0xFF, 0));
					SetBkMode(hDC, OPAQUE);
					HBITMAP hBitmap = LoadBitmap(hCards, MAKEINTRESOURCE(52));

					hBrush = CreatePatternBrush(hBitmap);
					DeleteObject(hBitmap);
	
					HGDIOBJ hOld = SelectObject(hDC, hBrush);

					Ellipse(hDC, P[0].x, P[0].y, P[2].x, P[2].y);
					SelectObject(hDC, hOld);
					DeleteObject(hBrush);

					SetBkMode(hDC, TRANSPARENT);
					break;
				}
		}

		SelectObject(hDC, hOld);