emfmain.cpp

来自「Windows 图形编程 书籍」· C++ 代码 · 共 756 行 · 第 1/2 页

	{

		const TCHAR * mess = 
			"The DrawText function draws formatted text in the specified rectangle. "
			"It formats the text according to the specified method (expanding tabs, "
			"justifying characters, breaking lines, and so forth).";

		int width = 250;
		int x     =  20;
		RECT rect = { x, y, x+width, y+200 };
	
		SetTextAlign(hDC, TA_LEFT | TA_TOP | TA_NOUPDATECP);

		Comment(hDC, "->DrawText");
		DrawText(hDC, mess, _tcslen(mess), & rect, DT_WORDBREAK | DT_LEFT);
		Comment(hDC, "<-DrawText");
	}
}


//////////////////////////////////////////

void Demo_Mapping(HDC hDC)
{
	KLogFont lf(-PointSizetoLogical(hDC, 16), "Times New Roman");
	KGDIObject font(hDC, lf.CreateFont());

	KGDIObject yellowbrush(hDC, CreateSolidBrush(RGB(0xFF, 0xFF, 0))); 

	const TCHAR * mess = "A Quick Brown Fox Jumps Over a Lazy Dog.";
	const TCHAR * mes2 = "Jackdaws Love My Big Sphinx of Quartz.";
	int x = 0, y = 0;

	SetTextAlign(hDC, TA_LEFT | TA_CENTER);
	
	SetMapMode(hDC, MM_ANISOTROPIC);
	SetViewportExtEx(hDC, 1, -1, 0);
	SetViewportOrgEx(hDC, 200, 100, NULL);

	TextOut(hDC, x, y,	  mess, _tcslen(mess));
	TextOut(hDC, x, y+24, mes2, _tcslen(mes2));

	ShowAxes(hDC, 400, 200);
}


class KDemoView : public KView
{
	int		m_nCommand;
	
	virtual int OnDraw(HDC hDC, const RECT * rcPaint)
	{
		switch ( m_nCommand )
		{
			case IDM_VIEW_SCALE:
				Demo_Scale(hDC);
				break;

			case IDM_VIEW_LINECURVE:
				Demo_LineCurveArea(hDC);
				break;

			case IDM_VIEW_BITMAPS:
				Demo_Bitmaps(hDC);
				break;

			case IDM_VIEW_TEXT:
				Demo_Texts(hDC);
				break;

			case IDM_VIEW_MAPPING:
				Demo_Mapping(hDC);
		}

		return View_NoChange;
	}

	
public:

	virtual int OnCommand(int cmd, HWND hWnd)
	{
		if ( cmd==m_nCommand )
			return View_NoChange;

		switch ( cmd )
		{
			case IDM_VIEW_SCALE:
				m_nCommand = cmd;
				SetWindowText(hWnd, "EMF Scaling");
				return View_Redraw;

			case IDM_VIEW_LINECURVE:
				m_nCommand = cmd;
				SetWindowText(hWnd, "Lines, Curves, and Areas in EMF");
				return View_Redraw;

			case IDM_VIEW_BITMAPS:
				m_nCommand = cmd;
				SetWindowText(hWnd, "Bitmaps in EMF");
				return View_Redraw;

			case IDM_VIEW_TEXT:
				m_nCommand = cmd;
				SetWindowText(hWnd, "Texts in EMF");
				return View_Redraw;

			case IDM_VIEW_MAPPING:
				m_nCommand = cmd;
				SetWindowText(hWnd, "Mapping Mode in EMF");
				return View_Redraw;

			case IDM_FILE_SAVE:
				{
					RECT rect;

					GetClientRect(hWnd, & rect);

					HDC hDC = GetDC(hWnd);
					Map10um(hDC, rect);
					ReleaseDC(hWnd, hDC);

					hDC = QuerySaveEMFFile("EMF Sample\0", & rect, NULL);

					if ( hDC )
					{
						OnDraw(hDC, NULL);
						HENHMETAFILE hEmf = CloseEnhMetaFile(hDC);
						DeleteEnhMetaFile(hEmf);
					}
				}
				break;

			case IDM_EDIT_COPY:
				{
					HDC hDC = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
					
					if ( hDC )
					{
						OnDraw(hDC, NULL);

						HENHMETAFILE hEmf = CloseEnhMetaFile(hDC);
						CopyToClipboard(hWnd, hEmf);
						DeleteEnhMetaFile(hEmf);
					}
					else
						assert(false);
				}
				break;
		}

		return View_NoChange;
	}
	
	KDemoView(void)
	{
		m_nCommand  = IDM_VIEW_LINECURVE;
	}
};


////////////////////////// MDI Frame Window

const int Translate[] =
{
	IDM_FILE_CLOSE,
	IDM_FILE_EXIT,
	IDM_WINDOW_TILE,
	IDM_WINDOW_CASCADE,
	IDM_WINDOW_ARRANGE,
	IDM_WINDOW_CLOSEALL
};


HENHMETAFILE TestEMFGen(void)
{
	RECT rect;

	HDC hdcRef = GetDC(NULL);

	GetClientRect(GetDesktopWindow(), &rect);
	Map10um(hdcRef, rect);

	HDC hDC = CreateEnhMetaFile(hdcRef, "c:\\test.emf", & rect, "EMF.EXE\0TestEMF\0");

	ReleaseDC(NULL, hdcRef);

	if ( hDC )
	{
		GetClientRect(GetDesktopWindow(), &rect);

		Rectangle(hDC, rect.right/3, rect.bottom/3, rect.right*2/3, rect.bottom*2/3);
		
		HENHMETAFILE hEmf = CloseEnhMetaFile(hDC);

		if ( hEmf )
			MyMessageBox(NULL, _T("c:\\test.emf generated."), _T("EMF"), MB_OK, IDI_GRAPH);
		else
			MyMessageBox(NULL, _T("c:\\test.emf generation failed."), _T("EMF"), MB_OK, IDI_GRAPH);

		return hEmf;
	}
	
	return NULL;
}


class KMyMDIFrame : public KMDIFrame
{
	HWND			m_Children[100];
	int				m_nChild;

	void CreateMDIChild(KCanvas * canvas, const TCHAR * klass, const TCHAR * title)
	{
		MDICREATESTRUCT mdic;

		mdic.szClass = klass;
		mdic.szTitle = title;
		mdic.hOwner  = m_hInst;
		mdic.x       = CW_USEDEFAULT;
		mdic.y       = CW_USEDEFAULT;
		mdic.cx      = CW_USEDEFAULT;
		mdic.cy      = CW_USEDEFAULT;
		mdic.style   = WS_VISIBLE | WS_BORDER;
		mdic.lParam  = (LPARAM) canvas;

		HWND hWnd = (HWND) SendMessage(m_hMDIClient, WM_MDICREATE, 0, (LPARAM) & mdic);

		if ( (hWnd) && (m_nChild<100) )
			m_Children[m_nChild++] = hWnd;
	}

	BOOL CreateCanvas(KView * pView, const TCHAR * Title)
	{
		if ( pView==NULL )
			return FALSE;

		KMDICanvas   * pCanvas = new KMDICanvas();

		if ( pCanvas )
		{
			if ( pCanvas->Initialize(m_hInst, m_pStatus, pView, IDR_DEMO, IDI_GRAPH) )
			{
				CreateMDIChild(pCanvas, pCanvas->GetClassName(), Title);
				return TRUE;
			}

			delete pCanvas;
		}

		delete pView;
		return FALSE;
	}

	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
	{
		switch ( LOWORD(wParam) )
		{
			case IDM_FILE_DEMO:
				CreateCanvas(new KDemoView(), _T("Demo - "));
				return TRUE;

			case IDM_FILE_SIMPLEEMF:
				{
					HENHMETAFILE hEmf = TestEMFGen();
					DeleteEnhMetaFile(hEmf);
				}
				return TRUE;

			case IDM_FILE_OPEN:
				{
					TCHAR filename[MAX_PATH];

					filename[0] = 0;
					HENHMETAFILE hEmf = QueryOpenEMFFile(filename);

					if ( hEmf || filename[0] )
					{
						KEMFView * pView = new KEMFView;

						if ( pView )
							if ( pView->Initialize(m_hInst, m_pStatus, m_hWnd, hEmf, filename) )
								CreateMDIChild(pView, _T("EMFViewClass"), filename);
							else
								delete pView;
					}
				}
				return TRUE;
			
			case IDM_FILE_EMFRES:
				Demo_EMFResource(m_hInst);
				return TRUE;

			case IDM_EDIT_PASTE:
				{
					HENHMETAFILE hEmf = PasteFromClipboard(m_hWnd);

					if ( hEmf )
					{
						KEMFView * pView = new KEMFView;

						if ( pView )
							if ( pView->Initialize(m_hInst, m_pStatus, m_hWnd, hEmf, NULL) )
								CreateMDIChild(pView, _T("EMFViewClass"), "Clipbpard");
							else
								delete pView;
					}
				}
				return TRUE;
		}

		return FALSE;
	}

	virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		switch ( uMsg )
		{
			case WM_PALETTECHANGED:
				{
					if ( hWnd != (HWND) wParam )
						for (int i=0; i<m_nChild; i++)
							SendMessage(m_Children[i], uMsg, wParam, lParam);
				}
				return 0;
		}

		return KMDIFrame::WndProc(hWnd, uMsg, wParam, lParam);
	}

	
	void GetWndClassEx(WNDCLASSEX & wc)
	{
		KMDIFrame::GetWndClassEx(wc);
		wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_GRAPH));
	}

public:
	KMyMDIFrame(HINSTANCE hInstance, const TBBUTTON * pButtons, int nCount,
		KToolbar * pToolbar, KStatusWindow * pStatus) :
		KMDIFrame(hInstance, pButtons, nCount, pToolbar, pStatus, Translate)
	{
		m_nChild = 0;
	}
};


const TBBUTTON tbButtons[] =
{
	{ STD_FILENEW,	 IDM_FILE_NEW,   TBSTATE_ENABLED, TBSTYLE_BUTTON, { 0, 0 }, IDS_FILENEW,  0 },
	{ STD_FILEOPEN,  IDM_FILE_OPEN,  TBSTATE_ENABLED, TBSTYLE_BUTTON, { 0, 0 }, IDS_FILEOPEN, 0 }
};


HINSTANCE hModule;

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, int nShow)
{
	KToolbar      toolbar;
	KStatusWindow status;

	hModule = hInst;

	KMyMDIFrame frame(hInst, tbButtons, 2, & toolbar, & status);
	
	frame.CreateEx(0, _T("ClassName"), _T("EMF"),
		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
	    CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 
	    NULL, LoadMenu(hInst, MAKEINTRESOURCE(IDR_MAIN)), hInst);

    frame.ShowWindow(nShow);
    frame.UpdateWindow();

    frame.MessageLoop();

	return 0;
}