#include "gdiptest.h"

//*******************************************************************
//
// AllBrushDialog 
//
//
//
//*******************************************************************

inline VOID NotImplementedBox()
{
	MessageBox(NULL, _T("Not Implemented") , _T(""),MB_OK);
};

inline VOID WarningBox(TCHAR* string)
{
	MessageBox(NULL, string, _T(""), MB_OK);
};

VOID WarningBeep()
{
	Beep(5000 /* hertz */, 400 /* milliseconds */);
}

Brush* blackBrush = NULL;
Brush* backBrush = NULL;
Pen* blackPen = NULL;
Color* blackColor = NULL;

	const TCHAR* tabStr = _T("    ");

	const TCHAR* formatList[numFormats] =
	{
		_T("CPP File"),
		_T("Java File"),
		_T("VML File")
	};

	const FormatType formatValue[numFormats] =
	{
		CPPFile,
		JavaFile,
		VMLFile
	};

	const TCHAR* shapeList[numShapes] =
	{
		_T("Line"),
		_T("Arc"),
		_T("Bezier"),
		_T("Rectangle"),
		_T("Ellipse"),
		_T("Pie"),
		_T("Polygon"),
		_T("Curve (Spline)"),
		_T("Closed Curve")
	};

	const INT shapeValue[numShapes] =
	{
		LineType,
		ArcType,
		BezierType,
		RectType,
		EllipseType,
		PieType,
		PolygonType,
		CurveType,
		ClosedCurveType
	};
		
	const INT inverseShapeValue[numShapes] =	// index by ShapeType
	{
		0,
		1,
		2,
		3,
		4,
		5,
		6,
		7,
		8
	};

	const TCHAR* brushList[numBrushes] =
	{
		_T("Solid"),
		_T("Texture (Bitmap)"),
		_T("Rectangle Gradient"),
		_T("Radial Gradient"),
		_T("Triangle Gradient"),
		_T("Polygon Gradient"),
		_T("Hatch")	
	};

	const INT brushValue[numBrushes] = 
	{
		SolidColorBrush,
		TextureFillBrush,
		RectGradBrush,
		RadialGradBrush,
		TriangleGradBrush,
		PathGradBrush,
		HatchFillBrush
	};

	const INT inverseBrushValue[numBrushes] = // index by BrushType
	{
		0,
		6,
		1,
		2,
		3,
		4,
		5
	};

	const TCHAR* capList[numCaps] = 
	{ 
		_T("Square"),
		_T("Round"),
		_T("Flat"),
		_T("Arrow"),
		_T("Diamond"),
		_T("Round") 
	};
	
	const TCHAR* capStr[numCaps] = 
	{ 
		_T("SquareCap"),
		_T("RoundCap"),
		_T("FlatCap"),
		_T("ArrowAnchor"),
		_T("DiamondAnchor"),
		_T("RoundAnchor") 
	};
	
	const LineCap capValue[numCaps] = 
	{
		SquareCap,
		RoundCap,
		FlatCap,
		ArrowAnchor,
		DiamondAnchor,
		RoundAnchor
	};

	const TCHAR* dashCapList[numDashCaps] = 
	{ 
		_T("Flat"),
		_T("Round"),
		_T("Triangle")
	};
	
	const TCHAR* dashCapStr[numDashCaps] = 
	{ 
		_T("FlatCap"),
		_T("RoundCap"),
		_T("TriangleCap")
	};
	
	const DashCap dashCapValue[numDashCaps] = 
	{
		FlatCap,
		RoundCap,
		TriangleCap
	};

	const TCHAR* joinList[numJoin] =
	{
		_T("Miter"),
		_T("Round"),
		_T("Bevel")
	};
	
	const TCHAR* joinStr[numJoin] =
	{
		_T("MiterJoin"),
		_T("RoundJoin"),
		_T("BevelJoin")
	};

	const LineJoin joinValue[numJoin] =
	{
		MiterJoin,
		RoundJoin,
		BevelJoin
	};

	const TCHAR* dashList[numDash] =
	{
		_T("Solid"),
		_T("Dash"),
		_T("Dot"),
		_T("Dash Dot"),
		_T("Dash Dot Dot")
	};

	const TCHAR* dashStr[numDash] =
	{
		_T("Solid"),
		_T("Dash"),
		_T("Dot"),
		_T("DashDot"),
		_T("DashDotDot")
	};

	const DashStyle dashValue[numDash] =
	{
		Solid,
		Dash,
		Dot,
		DashDot,
		DashDotDot
	};

	const TCHAR* wrapList[numWrap] =
	{
		_T("Tile"),
		_T("Tile Flip X"),
		_T("Tile Flip Y"),
		_T("Tile Flip XY"),
		_T("Clamp"),
		_T("Extrapolate")
	};

	const TCHAR* wrapStr[numWrap] =
	{
		_T("Tile"),
		_T("TileFlipX"),
		_T("TileFlipY"),
		_T("TileFlipXY"),
		_T("Clamp"),
		_T("Extrapolate")
	};

	const WrapMode wrapValue[numWrap] =
	{
		Tile,
		TileFlipX,
		TileFlipY,
		TileFlipXY,
		Clamp,
		Extrapolate
	};

	const TCHAR* hatchList[numHatch] =
	{
		_T("Forward Diagonal"),
		_T("Backward Diagonal"),
		_T("Cross"),
		_T("Diagonal Cross"),
		_T("Horizontal"),
		_T("Vertical")
	};

	const TCHAR* hatchStr[numHatch] =
	{
		_T("ForwardDiagonal"),
		_T("BackwardDiagonal"),
		_T("Cross"),
		_T("DiagonalCross"),
		_T("Horizontal"),
		_T("Vertical")
	};

	const HatchStyle hatchValue[numHatch] =
	{
		ForwardDiagonal,
		BackwardDiagonal,
		Cross,
		DiagonalCross,
		Horizontal,
		Vertical
	};

VOID SetDialogLong(HWND hwnd, UINT idc, UINT value, BOOL enable)
{
	HWND hwndControl;
	TCHAR tmp[256];

	hwndControl = GetDlgItem(hwnd, idc);
	_stprintf(tmp, _T("%ld"), value);
	SendMessage(hwndControl, WM_SETTEXT, 0, (LPARAM)&tmp[0]);

	EnableWindow(hwndControl, enable);

	DeleteObject(hwndControl);
}

UINT GetDialogLong(HWND hwnd, UINT idc)
{
	HWND hwndControl;
	TCHAR tmp[256];
	UINT value = 0;

	hwndControl = GetDlgItem(hwnd, idc);
	SendMessage(hwndControl, WM_GETTEXT, 255, (LPARAM)&tmp[0]);
	_stscanf(tmp,_T("%ld"), &value);

	DeleteObject(hwndControl);

	return value;
}

VOID SetDialogText(HWND hwnd, UINT idc, LPTSTR text, BOOL enable)
{
	HWND hwndControl;

	hwndControl = GetDlgItem(hwnd, idc);

	SendMessage(hwndControl, WM_SETTEXT, 0, (LPARAM)text);

	EnableWindow(hwndControl, enable);

	DeleteObject(hwndControl);
}

VOID GetDialogText(HWND hwnd, UINT idc, LPTSTR text, INT maxSize)
{
	HWND hwndControl;
	UINT value = 0;

	hwndControl = GetDlgItem(hwnd, idc);
	SendMessage(hwndControl, WM_GETTEXT, maxSize, (LPARAM)text);

	DeleteObject(hwndControl);
}

VOID SetDialogReal(HWND hwnd, UINT idc, REAL value)
{
	HWND hwndControl;
	TCHAR tmp[256];

	hwndControl = GetDlgItem(hwnd, idc);
	_stprintf(tmp, _T("%8.3f"), value);
	SendMessage(hwndControl, WM_SETTEXT, 0, (LPARAM)&tmp[0]);

	DeleteObject(hwndControl);
}

REAL GetDialogReal(HWND hwnd, UINT idc)
{
	HWND hwndControl;
	TCHAR tmp[256];
	REAL value = 0.0f;

	hwndControl = GetDlgItem(hwnd, idc);
	SendMessage(hwndControl, WM_GETTEXT, 255, (LPARAM)&tmp[0]);
	_stscanf(tmp, _T("%f"), &value);

	DeleteObject(hwndControl);

	return value;
}

VOID SetDialogRealList(HWND hwnd, UINT idc, REAL* blend, INT count)
{
	HWND hwndControl;
	TCHAR buf[4*MAX_PATH];
	TCHAR tmp[MAX_PATH];

	hwndControl = GetDlgItem(hwnd, idc);

	buf[0] = _T('\0');

	for (INT i = 0; i < count; i++)
	{
		_stprintf(tmp, _T("%.2f"), blend[i]);
		_tcscat(buf, tmp);
		if (i != count-1)
			_tcscat(buf, _T(" "));
	}

	SendMessage(hwndControl, WM_SETTEXT, 0, (LPARAM)buf);

	DeleteObject(hwndControl);
}

VOID GetDialogRealList(HWND hwnd, UINT idc, REAL** blend, INT *count)
{
	HWND hwndControl;
	TCHAR buf[4*MAX_PATH];
	TCHAR* curpos = &buf[0];
	REAL value;
	INT pos;

	const LPTSTR seps = _T(" \n\r,\t");

	hwndControl = GetDlgItem(hwnd, idc);
	SendMessage(hwndControl, WM_GETTEXT, 4*MAX_PATH, (LPARAM)buf);

	INT newCount = 0;

	curpos = _tcstok(&buf[0], seps);

	// find number of real values in list
	while (curpos)
	{
		if ((curpos[0] >= '0' && curpos[0] <= '9') ||
			curpos[0] == '.')
		{
			newCount++;
		}

		curpos = _tcstok(NULL, seps);
	}

	// !! caller must free the old blend factor memory
	//if (*count && *blend)
	//	free(*blend);

	if (!newCount)
	{
		*count = newCount;
		*blend = NULL;
		return;
	}

	SendMessage(hwndControl, WM_GETTEXT, 4*MAX_PATH, (LPARAM)buf);

	*count = newCount;
	*blend = (REAL*) malloc(sizeof(REAL)*newCount);

	// extract actual values from the list.
	pos = 0;

	curpos = _tcstok(&buf[0], seps);

	while (curpos != NULL)
	{
		if ((curpos[0] >= '0' && curpos[0] <= '9') ||
			curpos[0] == '.')
		{
			ASSERT(pos < newCount);
			if (pos >= newCount)
				DebugBreak();

			_stscanf(curpos, _T("%f"), &value);
			(*blend)[pos] = value;
			pos++;
		}

		curpos = _tcstok(NULL, seps);
	}

	DeleteObject(hwndControl);
}

VOID SetDialogCombo(HWND hwnd, UINT idc, const TCHAR* strings[], INT count, INT cursel)
{
	HWND hwndControl;

	// !!! use SendDlgItemMessage instead

	hwndControl = GetDlgItem(hwnd, idc);
	for (INT i=0; i<count; i++)
		SendMessage(hwndControl, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)strings[i]);

	SendMessage(hwndControl, CB_SETCURSEL, cursel, 0);

	DeleteObject(hwndControl);
}

INT GetDialogCombo(HWND hwnd, UINT idc)
{
	HWND hwndControl;

	hwndControl = GetDlgItem(hwnd, idc);

	INT cursel = SendMessage(hwndControl, CB_GETCURSEL, 0, 0);

	DeleteObject(hwndControl);

	return cursel;
}


VOID SetDialogCheck(HWND hwnd, UINT idc, BOOL checked)
{
	HWND hwndControl;

	hwndControl = GetDlgItem(hwnd, idc);
	SendMessage(hwndControl, BM_SETCHECK, (WPARAM)
					checked ? BST_CHECKED : BST_UNCHECKED, 0);
	DeleteObject(hwndControl);
}

BOOL GetDialogCheck(HWND hwnd, UINT idc)
{
	HWND hwndControl;
	BOOL checked = FALSE;

	hwndControl = GetDlgItem(hwnd, idc);
	checked = SendMessage(hwndControl, BM_GETCHECK, 0, 0);
	DeleteObject(hwndControl);

	return checked;
}

VOID EnableDialogControl(HWND hwnd, INT idc, BOOL enable)
{
	HWND hwndCtrl = GetDlgItem(hwnd, idc);
	EnableWindow(hwndCtrl, enable);
	DeleteObject(hwndCtrl);
}

VOID SetMenuCheck(HWND hwnd, INT menuPos, UINT idm, BOOL checked, BOOL byCmd)
{
	HMENU hmenu = GetMenu(hwnd);
	HMENU otherHmenu = GetSubMenu(hmenu, menuPos);

	CheckMenuItem(otherHmenu, idm, 
		(byCmd ? MF_BYCOMMAND : MF_BYPOSITION) |
		(checked ? MF_CHECKED : MF_UNCHECKED));

	DeleteObject(hmenu);
	DeleteObject(otherHmenu);
}

VOID UpdateColorPicture(HWND hwnd, INT idc, ARGB argb)
{
	LOGBRUSH lb;
	lb.lbStyle = BS_SOLID;
	lb.lbColor = ((argb & Color::RedMask) >> Color::RedShift) |
				 ((argb & Color::GreenMask)) |
				 ((argb & Color::BlueMask) << Color::RedShift);
	lb.lbHatch = NULL;

	HWND hwndPic = GetDlgItem(hwnd, idc);

	HDC hdc = GetDC(hwndPic);

	HBRUSH hbr = CreateBrushIndirect(&lb);
	ASSERT(hbr);

	HBRUSH hbrOld = (HBRUSH) SelectObject(hdc, hbr);

	RECT rect;
	GetClientRect(hwndPic, &rect);

	FillRect(hdc, &rect, hbr);

	SelectObject(hdc, hbrOld);

	InvalidateRect(hwndPic, NULL, TRUE);

	DeleteObject(hbr);
	DeleteObject(hdc);
	DeleteObject(hwndPic);
}

VOID UpdateRGBColor(HWND hwnd, INT idcPic, ARGB& argb)
{
	static COLORREF custColor[16]
		= { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };

	CHOOSECOLOR chooseColor =
	{
		sizeof(CHOOSECOLOR),
		hwnd,
		0,
		argb & ~Color::AlphaMask,
		(COLORREF*)&custColor[0],
		CC_ANYCOLOR | CC_FULLOPEN | CC_RGBINIT,
		0,
		0,
		0
	};

	if (ChooseColor(&chooseColor))
	{
		// COLORREF & ARGB reverse Red and Blue position
		argb = ((chooseColor.rgbResult & 0x0000FF) << 16) |
			   ((chooseColor.rgbResult & 0x00FF00)) |
			   ((chooseColor.rgbResult & 0xFF0000) >> 16);

		UpdateColorPicture(hwnd, idcPic, argb);
	}
};
/*
VOID OutputRectangle(FILE* file, INT formatType, ERectangle* rect)
{
	switch(formatType)
	{
	case CPPFile:
		_ftprintf(file,
				  _T(tabStr tabStr tabStr
				     "ERectangle rect(%e, %e,\n"
					 tabStr tabStr tabStr
					 "                %e, %e);\n",
					 rect.X, rect.Y, rect.Width, rect.Height);
		break;

	case JavaFile:
		_ftprintf(file,
				  _T(tabStr tabStr tabStr
				     "Rectangle rect = new Rectangle(%e, %e,\n"
					 tabStr tabStr tabStr
					 "                               %e, %e);\n",
					 rect.X, rect.Y, rect.Width, rect.Height);
		break;

	case VMLFile:
		break;
	}
}


VOID OutputPointList(FILE* file, INT formatType, Point* pts, INT count)
{
	INT cnt;

	switch(formatType)
	{
	case CPPFile:
		_ftprintf(file, 
				  _T(tabStr tabStr tabStr 
							"Point pts[%d];\n"),
				  count);

		for (cnt = 0; cnt < count; cnt++)
			_ftprintf(file, 
					  _T(tabStr tabStr tabStr
							"pts[%d].X = %e; "
			                "pts[%d].Y = %e;\n"),
							cnt, pts[cnt].X,
							cnt, pts[cnt].Y);
		break;

	case JavaFile:
		_ftprintf(file, 
				  _T(tabStr tabStr tabStr
							"Point[] pts = new Point[%d]\n"),
					 count);

		for (cnt = 0; cnt < count; cnt++)
			_ftprintf(file, 
					  _T(tabStr tabStr tabStr 
					     "pts[%d] = new Point(%e, %e)\n"),
						 cnt, pts[cnt].X, pts[cnt].Y);
		break;

	case VMLFile:
		break;
	}
};
*/
//*******************************************************************
//
// TestTransform
//
//*******************************************************************

BOOL TestTransform :: ChangeSettings(HWND hwndParent)
{
	BOOL ok = DialogBoxParam(hInst,
							MAKEINTRESOURCE(IDD_MATRIX_DLG),
							hwndParent,
							AllDialogBox,
							(LPARAM)((TestDialogInterface*)this));

	if (ok)
	{
		REAL m[6];
		
		// !! This is bad inconsistency in matrix API
		matrix->GetElements(&m[0]);
		(*origMatrix)->SetElements(m[0], m[1], m[2], m[3], m[4], m[5]);
	}

	return ok;
}

VOID TestTransform :: Initialize()
{
	DebugBreak();
}

VOID TestTransform :: Initialize(Matrix **newMatrix)
{
	origMatrix = newMatrix;
	if (*newMatrix)
		matrix = (*newMatrix)->Clone();
	else
		matrix = new Matrix();
}

VOID TestTransform :: EnableDialogButtons(HWND hwnd, BOOL enable)
{
	EnableDialogControl(hwnd, IDC_MATRIX_RESET, enable);
	EnableDialogControl(hwnd, IDC_MATRIX_TRANSLATE, enable);
	EnableDialogControl(hwnd, IDC_MATRIX_SCALE, enable);
	EnableDialogControl(hwnd, IDC_MATRIX_ROTATE, enable);
	EnableDialogControl(hwnd, IDC_MATRIX_SHEAR, enable);
	EnableDialogControl(hwnd, IDC_MATRIX_INVERT, enable);
	EnableDialogControl(hwnd, IDC_OK, enable);
	EnableDialogControl(hwnd, IDC_CANCEL, enable);
}

VOID TestTransform :: UpdateTransformPicture(HWND hwnd, 
											 INT idc, 
											 Matrix* matrix)
{
	INT pos;
	Matrix tmpMatrix;

	// get client rectangle of picture area
	HWND hwndPic = GetDlgItem(hwnd, idc);
	RECT rect;
	GetClientRect(hwndPic, &rect);

	Graphics *g = new Graphics(hwndPic);

	ERectangle bound(REAL_MAX, REAL_MAX, -REAL_MAX, -REAL_MAX);
	
	ERectangle rectf(rect.left,	rect.top,
					 rect.right - rect.left,
					 rect.bottom - rect.top);

	Point pts[4] =
	{
		Point(rectf.X-rectf.Width/2, rectf.Y-rectf.Height/2),
		Point(rectf.X+rectf.Width/2, rectf.Y-rectf.Height/2),
		Point(rectf.X+rectf.Width/2, rectf.Y+rectf.Height/2),
		Point(rectf.X-rectf.Width/2, rectf.Y+rectf.Height/2)
	};

	matrix->TransformPoints(&pts[0], 4);

	// compute bounding box of transformed rectangle
	for (pos=0; pos < 4; pos++)
	{
		if (pts[pos].X < bound.GetLeft())
		{
			bound.Width += fabsf(pts[pos].X-bound.GetLeft());
			bound.X = pts[pos].X;
		}

		if (pts[pos].X > bound.GetRight())
			bound.Width = fabsf(pts[pos].X-bound.GetLeft());

		// on screen, y positive goes downward
		// instead of the traditional upward

		if (pts[pos].Y < bound.GetTop())
		{
			bound.Height += fabsf(pts[pos].Y-bound.GetTop());
			bound.Y = pts[pos].Y;
		}
		
		if (pts[pos].Y > bound.GetBottom())
			bound.Height = fabsf(pts[pos].Y-bound.GetTop());
	}

	// translate relative to the origin
	tmpMatrix.Translate(-((bound.GetLeft()+bound.GetRight())/2),
						 -((bound.GetTop()+bound.GetBottom())/2),
						 AppendOrder);

	// scale to fit our rectangle
	REAL scale = min((rectf.Width-30.0f)/bound.Width,
					 (rectf.Height-30.0f)/bound.Height);

	tmpMatrix.Scale(scale, scale, AppendOrder);

	// translate relative to center of our rectangle
	tmpMatrix.Translate(rectf.Width/2, 
						rectf.Height/2,
						AppendOrder);

	// transform our points by tmpMatrix
	tmpMatrix.TransformPoints(&pts[0], 4);

	// opaque colors RED & BLACK
	Color redColor(0xFF000000 | Color::Red);
	SolidBrush redBrush(redColor);

	Color blackColor(0xFF000000 | Color::Black);
	SolidBrush myBlackBrush(blackColor);

	g->FillRectangle(&myBlackBrush, rectf);
	g->FillPolygon(&redBrush, &pts[0], 4);

	delete g;
}

VOID TestTransform :: InitDialog(HWND hwnd)
{
	REAL m[6];
		
	matrix->GetElements(&m[0]);

	SetDialogReal(hwnd, IDC_MATRIX_M11, m[0]);
	SetDialogReal(hwnd, IDC_MATRIX_M12, m[1]);
	SetDialogReal(hwnd, IDC_MATRIX_M13, 0.0f);
	SetDialogReal(hwnd, IDC_MATRIX_M21, m[2]);
	SetDialogReal(hwnd, IDC_MATRIX_M22, m[3]);
	SetDialogReal(hwnd, IDC_MATRIX_M23, 0.0f);
	SetDialogReal(hwnd, IDC_MATRIX_M31, m[4]);
	SetDialogReal(hwnd, IDC_MATRIX_M32, m[5]);
	SetDialogReal(hwnd, IDC_MATRIX_M33, 1.0f);

	EnableDialogControl(hwnd, IDC_MATRIX_M13, FALSE);
	EnableDialogControl(hwnd, IDC_MATRIX_M23, FALSE);
	EnableDialogControl(hwnd, IDC_MATRIX_M33, FALSE);

	SetDialogCheck(hwnd, IDC_MATRIX_PREPEND, 
		*matrixPrepend == PrependOrder ? TRUE : FALSE);

	UpdateTransformPicture(hwnd, IDC_MATRIX_PIC, matrix);
}

BOOL TestTransform :: SaveValues(HWND hwnd)
{
	*matrixPrepend = (GetDialogCheck(hwnd, IDC_MATRIX_PREPEND) == TRUE ?
							PrependOrder : AppendOrder);

	matrix->SetElements(GetDialogReal(hwnd, IDC_MATRIX_M11),
						GetDialogReal(hwnd, IDC_MATRIX_M12),
						GetDialogReal(hwnd, IDC_MATRIX_M21),
						GetDialogReal(hwnd, IDC_MATRIX_M22),
						GetDialogReal(hwnd, IDC_MATRIX_M31),
						GetDialogReal(hwnd, IDC_MATRIX_M32));

	// !! check for singular matrix ??
	return FALSE;
}

BOOL TestTransform :: ProcessDialog(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	if (msg == WM_COMMAND)
	{
		switch(LOWORD(wParam))
		{
		case IDC_OK:
			if (SaveValues(hwnd))
				WarningBeep();
			else
				::EndDialog(hwnd, TRUE);
			break;

		case IDC_MATRIX_RESET:
			matrix->Reset();
			InitDialog(hwnd);
			break;

		case IDC_MATRIX_TRANSLATE:
			{
				EnableDialogButtons(hwnd, FALSE);
				
				TestMatrixOperation matrixOp;

				matrixOp.Initialize(_T("Translate Matrix Operation"),
									_T("Translate"),
									_T("Translate points by X and Y"),
									2);

				if (matrixOp.ChangeSettings(hwnd))
				{
					matrix->Translate(matrixOp.GetX(),
									  matrixOp.GetY(),
									  *matrixPrepend);
					
					// redisplay dialog entries
					InitDialog(hwnd);
				}

				EnableDialogButtons(hwnd, TRUE);
			}
			break;

		case IDC_MATRIX_SCALE:
			{
				EnableDialogButtons(hwnd, FALSE);
				
				TestMatrixOperation matrixOp;

				matrixOp.Initialize(_T("Scale Matrix Operation"),
									_T("Scale"),
									_T("Scale points by X and Y"),
									2);

				if (matrixOp.ChangeSettings(hwnd))
				{
					matrix->Scale(matrixOp.GetX(),
								  matrixOp.GetY(),
								  *matrixPrepend);
					
					// redisplay dialog entries
					InitDialog(hwnd);
				}

				EnableDialogButtons(hwnd, TRUE);
			}
			break;

		case IDC_MATRIX_ROTATE:
			{
				EnableDialogButtons(hwnd, FALSE);
				
				TestMatrixOperation matrixOp;

				matrixOp.Initialize(_T("Rotate Matrix Operation"),
									_T("Rotate"),
									_T("Rotate points by angle"),
									1);

				if (matrixOp.ChangeSettings(hwnd))
				{
					matrix->Rotate(matrixOp.GetX(),
								   *matrixPrepend);
					
					// redisplay dialog entries
					InitDialog(hwnd);
				}

				EnableDialogButtons(hwnd, TRUE);
			}
			break;
			
		case IDC_MATRIX_SHEAR:
			{
				EnableDialogButtons(hwnd, FALSE);
				
				TestMatrixOperation matrixOp;

				matrixOp.Initialize(_T("Shear Matrix Operation"),
									_T("Shear"),
									_T("Shear points by X and Y"),
									2);

				if (matrixOp.ChangeSettings(hwnd))
				{
					matrix->Shear(matrixOp.GetX(),
								  matrixOp.GetY());
					// !! should this be added?
					//			  *matrixPrepend);
					
					// redisplay dialog entries
					InitDialog(hwnd);
				}

				EnableDialogButtons(hwnd, TRUE);
			}
			break;

		case IDC_MATRIX_INVERT:
			matrix->Invert();
			InitDialog(hwnd);
			break;

		case IDC_REFRESH_PIC:
			UpdateTransformPicture(hwnd, IDC_MATRIX_PIC, matrix);
			break;

		case IDC_CANCEL:
			::EndDialog(hwnd, FALSE);
			break;

		case IDC_MATRIX_PREPEND:
			*matrixPrepend = (GetDialogCheck(hwnd, IDC_MATRIX_PREPEND) == TRUE ?
					PrependOrder : AppendOrder);
			break;
			
		default:
			return FALSE;
		}

		return TRUE;
	}

	return FALSE;
}

BOOL TestMatrixOperation :: ChangeSettings(HWND hwndParent)
{
	BOOL ok = DialogBoxParam(hInst,
							MAKEINTRESOURCE(IDD_MATRIX_DLG2),
							hwndParent,
							AllDialogBox,
							(LPARAM)((TestDialogInterface*)this));

	return ok;
}

VOID TestMatrixOperation :: Initialize()
{
	DebugBreak();
}

VOID TestMatrixOperation :: Initialize(TCHAR* newDialogTitle,
									   TCHAR* newSubTitle,
									   TCHAR* newDescStr,
									   INT newCount)
{
	dialogTitle = newDialogTitle;
	subTitle = newSubTitle;
	descStr = newDescStr;
	count = newCount;
}

VOID TestMatrixOperation :: InitDialog(HWND hwnd)
{
	SetWindowText(hwnd, dialogTitle);
	SetDialogText(hwnd, IDC_MATRIX_OPERATION, subTitle);
	SetDialogText(hwnd, IDC_MATRIX_TEXT, descStr);

	SetDialogReal(hwnd, IDC_MATRIX_X, x);
	SetDialogReal(hwnd, IDC_MATRIX_Y, y);

	EnableDialogControl(hwnd, IDC_MATRIX_Y, count >= 2);
}

BOOL TestMatrixOperation :: SaveValues(HWND hwnd)
{
	x = GetDialogReal(hwnd, IDC_MATRIX_X);
	y = GetDialogReal(hwnd, IDC_MATRIX_Y);

	return FALSE;
}

BOOL TestMatrixOperation :: ProcessDialog(HWND hwnd, 
										  UINT msg, 
										  WPARAM wParam, 
										  LPARAM lParam)
{
    if (msg == WM_COMMAND)
	{
		if (LOWORD(wParam) == IDC_OK)
		{
			if (SaveValues(hwnd))
				WarningBeep();
			else
				::EndDialog(hwnd, TRUE);

	        return TRUE;
		}
		else if (LOWORD(wParam) == IDC_CANCEL)
		{
			::EndDialog(hwnd, FALSE);
		}
	}
    
	return FALSE;

}

//*******************************************************************
//
// Dialog Window Proc Handler
//
//*******************************************************************

INT_PTR CALLBACK AllDialogBox(
							  HWND hwnd,
							  UINT msg,
							  WPARAM wParam,
							  LPARAM lParam
							  )
{
	switch (msg)
	{
	case WM_INITDIALOG:
		{
			// save pointer to brush interface for this object
			SetWindowLong(hwnd, DWL_USER, lParam);
			ASSERT(lParam != 0);
			TestDialogInterface* dlgInt = (TestDialogInterface*) lParam;

			dlgInt->InitDialog(hwnd);
		}
		break;

	case WM_PAINT:
		{
			TestDialogInterface* dlgInt = (TestDialogInterface*) 
						GetWindowLong(hwnd, DWL_USER);
			ASSERT(dlgInt != NULL);

			if (dlgInt)
				dlgInt->ProcessDialog(hwnd, WM_COMMAND, IDC_REFRESH_PIC, 0);
			return FALSE;
		}
		break;

	case WM_CLOSE:
		{
			DestroyWindow(hwnd);
			break;
		}

	default:
		{
			TestDialogInterface* dlgInt = (TestDialogInterface*) 
						GetWindowLong(hwnd, DWL_USER);
			ASSERT(dlgInt != NULL);

			if (dlgInt)
				return dlgInt->ProcessDialog(hwnd, msg, wParam, lParam);
			else
				return FALSE;
		}
	}

	return TRUE;
}