ï¿½ï¿½Ê½18-1  METAFILE
METAFILE.C
/*-------------------------------------------------------------------------
   	METAFILE.C -- 		Metafile Demonstration Program
                 							(c) Charles Petzold, 1998
--------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR szAppName [] = TEXT ("Metafile") ;
     	HWND         							hwnd ;
     	MSG          							msg ;
     	WNDCLASS     						wndclass ;

     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         					= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       				= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
 	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Metafile Demonstration"),
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     {
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HMETAFILE 		hmf ;
     	static int       				cxClient, cyClient ;
     	HBRUSH           					hBrush ;
     	HDC              						hdc, hdcMeta ;
     	int              						x, y ;
     	PAINTSTRUCT      				ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			hdcMeta	= 	CreateMetaFile (NULL) ;
          			hBrush	=	CreateSolidBrush (RGB (0, 0, 255)) ;
          			Rectangle 	(hdcMeta, 0, 0, 100, 100) ;
          
          			MoveToEx 		(hdcMeta,	0,	0, 	NULL) ;
          			LineTo   		(hdcMeta, 	100,	100) 	;
          			MoveToEx 		(hdcMeta,	0,	100, 	NULL) ;
          			LineTo   		(hdcMeta,	100,	0) 	;
          
          			SelectObject (hdcMeta, hBrush) ;
          			Ellipse (hdcMeta, 20, 20, 80, 80) ;
          
          			hmf = CloseMetaFile (hdcMeta) ;
          
          			DeleteObject (hBrush) ;
          			return 0 ;
          
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			SetMapMode (hdc, MM_ANISOTROPIC) ;
          			SetWindowExtEx (hdc, 1000, 1000, NULL) ;
          			SetViewportExtEx (hdc, cxClient, cyClient, NULL) ;
          
          			for (x = 0 ; x < 10 ; x++)
          			for (y = 0 ; y < 10 ; y++)
          			{
               					SetWindowOrgEx (hdc, -100 * x, -100 * y, NULL) ;
               					PlayMetaFile (hdc, hmf) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
               
     	case 	WM_DESTROY:
          			DeleteMetaFile (hmf) ;
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

hmf = GetMetaFile (szFileName) ;

DeleteMetaFile (hmf) ;

DeleteFile (szFileName) ;

hmf = SetMetaFileBitsEx (iSize, pData) ;

typedef struct tagMETAFILEPICT
{
     	LONG mm ;             				// mapping mode
     	LONG xExt ;           				// width of the metafile image
     	LONG yExt ;           				// height of the metafile image
     	LONG hMF ;            				// handle to the metafile
}
METAFILEPICT ;

hdcMeta = CreateMetaFile (NULL) ;
SetWindowExtEx (hdcMeta, ...) ;
SetWindowOrgEx (hdcMeta, ...) ;

hmf = CloseMetaFile (hdcMeta) ;

GLOBALHANDLE   		hGlobal ;
LPMETAFILEPICT 		pMFP ;
�����г�ʽ
hGlobal= GlobalAlloc (GHND | GMEM_SHARE, sizeof (METAFILEPICT)) ;
pMFP = (LPMETAFILEPICT) GlobalLock (hGlobal) ;

pMFP->mm   	= MM_... ;
pMFP->xExt 	= ...  ;
pMFP->yExt 	= ...  ;
pMFP->hMF  	= hmf  ;

GlobalUnlock (hGlobal) ;

OpenClipboard (hwnd) ;
EmptyClipboard () ;
SetClipboardData (CF_METAFILEPICT, hGlobal) ;
CloseClipboard () ;

OpenClipboard (hwnd) ;
hGlobal = GetClipboardData (CF_METAFILEPICT) ;
pMFP = (LPMETAFILEPICT) GlobalLock (hGlobal) ;

SaveDC (hdc) ;
SetMappingMode (pMFP->mm) ;

void PrepareMetaFile (	HDC hdc, LPMETAFILEPICT pmfp,
                      		int cxClient, int cyClient)
{
     	int xScale, yScale, iScale ;
     	SetMapMode (hdc, pmfp->mm) ;
     	if (pmfp->mm == MM_ISOTROPIC || pmfp->mm == MM_ANISOTROPIC)
     	{
          			if (pmfp->xExt == 0)
               				SetViewportExtEx (hdc, cxClient, cyClient, NULL) ;
          			else if (pmfp->xExt > 0)
               				SetViewportExtEx (hdc,
                    			pmfp->xExt *	GetDeviceCaps (hdc, HORZRES) /
                                GetDeviceCaps (hdc, HORZSIZE) / 100),
                    			pmfp->yExt *	GetDeviceCaps (hdc, VERTRES) /
                                GetDeviceCaps (hdc, VERTSIZE) / 100), NULL) ;
           			            else if (pmfp->xExt < 0)
          				{
               			xScale = 100 *	cxClient * GetDeviceCaps (hdc, HORZSIZE) /
                        GetDeviceCaps (hdc, HORZRES) / -pmfp->xExt ;
               			lScale = 100 *	cyClient * GetDeviceCaps (hdc, VERTSIZE) /
                        GetDeviceCaps (hdc, VERTRES) / -pmfp->yExt ;
               			iScale = min (xScale, yScale) ;

   SetViewportExtEx (hdc, -pmfp->xExt * iScale * GetDeviceCaps (hdc, HORZRES) /
                     GetDeviceCaps (hdc, HORZSIZE) / 100, -pmfp->yExt * iScale 
* GetDeviceCaps (hdc, VERTRES) / GetDeviceCaps (hdc, VERTSIZE) / 100, NULL) ;
   			}
		}
}

PlayMetaFile (pMFP->hMF) ;
RestoreDC (hdc, -1) ;

GlobalUnlock (hGlobal) ;
CloseClipboard () ;

 ï¿½ï¿½Ê½18-2  EMF1
EMF1.C
/*----------------------------------------------------------------------------
   	EMF1.C --	Enhanced Metafile Demo #1
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							LPSTR lpszCmdLine, int nCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("EMF1") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
     
     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       		= LoadCursor (NULL, IDC_ARROW) ;
  	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          			MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      								szAppName, MB_ICONERROR) ;
          			return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Enhanced Metafile Demo #1"),
                          		WS_OVERLAPPEDWINDOW,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, nCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     }
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static HENHMETAFILE 	hemf ;
     	HDC                 							hdc, hdcEMF ;
     	PAINTSTRUCT         					ps ;
     	RECT                							rect ;
     
     	switch (message)
     {
     	case 	WM_CREATE:
          			hdcEMF = CreateEnhMetaFile (NULL, NULL, NULL, NULL) ;

          			Rectangle 	(hdcEMF, 100, 100, 200, 200) ;
          
          			MoveToEx  		(hdcEMF, 100, 100, NULL) ;
          			LineTo  		(hdcEMF, 200, 200) ;
          
          			MoveToEx 		(hdcEMF, 200, 100, NULL) ;
          			LineTo  		(hdcEMF, 100, 200) ;

          			hemf = CloseEnhMetaFile (hdcEMF) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          
          			rect.left   		=     			rect.right 		/ 4 ;
          			rect.right  		= 3 * 	rect.right		/ 4 ;
          			rect.top    		=     			rect.bottom		/ 4 ;
          			rect.bottom 		= 3 * 	rect.bottom		/ 4 ;
          
          			PlayEnhMetaFile (hdc, hemf, &rect) ;
          
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			DeleteEnhMetaFile (hemf) ;
          
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½18-3  EMF2
EMF2.C
/*-----------------------------------------------------------------------------
   	EMF2.C --	Enhanced Metafile Demo #2
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							LPSTR lpszCmdLine, int nCmdShow)
{
     	static TCHAR 		szAppName[] = TEXT ("EMF2") ;
     	HWND         					hwnd ;
     	MSG          					msg ;
     	WNDCLASS     				wndclass ;
     	wndclass.style        					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       		= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (szAppName, TEXT ("Enhanced Metafile Demo #2"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, nCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	HDC          				hdc, hdcEMF ;
     	HENHMETAFILE 	hemf ;
     	PAINTSTRUCT  		ps ;
     	RECT         				rect ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          	hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf2.emf"), NULL,
            TEXT ("EMF2\0EMF Demo #2\0")) ;

          			if (!hdcEMF)
               			return 0 ;

          			Rectangle 	(hdcEMF, 100, 100, 200, 200) ;

          			MoveToEx  		(hdcEMF, 100, 100, NULL) ;
          			LineTo    		(hdcEMF, 200, 200) ;
          
          			MoveToEx  		(hdcEMF, 200, 100, NULL) ;
          			LineTo    		(hdcEMF, 100, 200) ;
          
          			hemf = CloseEnhMetaFile (hdcEMF) ;
          
          			DeleteEnhMetaFile (hemf) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          
          			rect.left		= 	    rect.right      / 4 ;
          			rect.right  	= 3 * 	rect.right		/ 4 ;
          			rect.top    	=       rect.bottom		/ 4 ;
          			rect.bottom 	= 3 *	rect.bottom		/ 4 ;
          
          			if (hemf = GetEnhMetaFile (TEXT ("emf2.emf")))
          			{
               				PlayEnhMetaFile (hdc, hemf, &rect) ;
               				DeleteEnhMetaFile (hemf) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

0000  	01 00 00 00 88 00 00 00 64 00 00 00 64 00 00 00	    ........d...d...
0010  	C8 00 00 00 C8 00 00 00 35 0C 00 00 35 0C 00 00  	........5...5...
0020  	6A 18 00 00 6A 18 00 00 20 45 4D 46 00 00 01 00  	j...j...EMF....
0030  	F4 00 00 00 07 00 00 00 01 00 00 00 12 00 00 00  	................
0040  	64 00 00 00 00 00 00 00 00 04 00 00 00 03 00 00  	d...............
0050  	40 01 00 00 F0 00 00 00 00 00 00 00 00 00 00 00  	@...............
0060  	00 00 00 00 45 00 4D 00 46 00 32 00 00 00 45 00  	....E.M.F.2...E.
0070  	4D 00 46 00 20 00 44 00 65 00 6D 00 6F 00 20 00  	M.F..D.e.m.o..
0080  	23 00 32 00 00 00 00 00 2B 00 00 00 18 00 00 00  	#.2.....+.......
0090  	63 00 00 00 63 00 00 00 C6 00 00 00 C6 00 00 00  	c...c...........
00A0  	1B 00 00 00 10 00 00 00 64 00 00 00 64 00 00 00  	........d...d...
00B0  	36 00 00 00 10 00 00 00 C8 00 00 00 C8 00 00 00  	6...............
00C0  	1B 00 00 00 10 00 00 00 C8 00 00 00 64 00 00 00  	............d...
00D0  	36 00 00 00 10 00 00 00 64 00 00 00 C8 00 00 00  	6.......d.......
00E0  	0E 00 00 00 14 00 00 00 00 00 00 00 10 00 00 00  	................
00F0  	14 00 00 00									....

typedef struct tagENHMETARECORD
{
     	DWORD iType ;         				// record type
     	DWORD nSize ;         				// record size
     	DWORD dParm [1] ;     		        // parameters
}
ENHMETARECORD ;

typedef struct tagENHMETAHEADER
{
     	DWORD iType ;       // EMR_HEADER = 1
     	DWORD nSize ;       // structure size 
     	RECTL rclBounds ;    // bounding rectangle in pixels
     	RECTL rclFrame ;     // size of image in 0.01 millimeters
     	DWORD dSignature ;  // ENHMETA_SIGNATURE = " EMF"
     	DWORD nVersion ;    // 0x00010000
     	DWORD nBytes ;     // file size in bytes
     	DWORD nRecords ;   // total number of records
     	WORD  nHandles ;   // number of handles in handle table
     	WORD  sReserved ;
     	DWORD nDescription ;    // character length of description string
     	DWORD offDescription ;   // offset of description string in file
     	DWORD nPalEntries ;     // number of entries in palette
     	SIZEL szlDevice ;        // device resolution in pixels
     	SIZEL szlMillimeters ; 	   // device resolution in millimeters
     	DWORD cbPixelFormat ;  // size of pixel format
     	DWORD offPixelFormat ;  // offset of pixel format
     	DWORD bOpenGL ;      // FALSE if no OpenGL records
}
ENHMETAHEADER ;

GetEnhMetaFileHeader (hemf, cbSize, &emh) ;

 ï¿½ï¿½Ê½18-4  EMF3
EMF3.C
/*----------------------------------------------------------------------------
   	EMF3.C -- 	Enhanced Metafile Demo #3
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR szAppName[] = TEXT ("EMF3") ;
     	HWND         							hwnd ;
     	MSG          							msg ;
     	WNDCLASS     						wndclass ;
     
     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         					= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       				= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground	 	= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
	hwnd = CreateWindow (	szAppName, TEXT ("Enhanced Metafile Demo #3"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	LOGBRUSH     				lb ;
     	HDC          					hdc, hdcEMF ;
     	HENHMETAFILE 		hemf ;
     	PAINTSTRUCT  			ps ;
     	RECT         					rect ;
     	switch (message)
     {
     	case 	WM_CREATE:
          	hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf3.emf"), NULL,
            TEXT ("EMF3\0EMF Demo #3\0")) ;
          
          			SelectObject (hdcEMF, CreateSolidBrush (RGB (0, 0, 255))) ;
          
          			lb.lbStyle = BS_SOLID ;
          			lb.lbColor = RGB (255, 0, 0) ;
          			lb.lbHatch = 0 ;

          			SelectObject (hdcEMF, 
               		ExtCreatePen (PS_SOLID | PS_GEOMETRIC, 5, &lb, 0, NULL)) ;
          
          			if (GetVersion () & 0x80000000) // Windows 98
               		Rectangle (hdcEMF, 100, 100, 201, 201) ;
          			else    
				   // Windows NT
               					Rectangle (hdcEMF, 101, 101, 202, 202) ;
          
          			MoveToEx  		(hdcEMF, 100, 100, NULL) ;
          			LineTo    		(hdcEMF, 200, 200) ;
          
          			MoveToEx  		(hdcEMF, 200, 100, NULL) ;
          			LineTo    		(hdcEMF, 100, 200) ;
          
          			DeleteObject (SelectObject (hdcEMF, GetStockObject (BLACK_PEN))) ;
          			DeleteObject (SelectObject (hdcEMF, GetStockObject (WHITE_BRUSH))) ;
          
          			hemf = CloseEnhMetaFile (hdcEMF) ;
          
          					DeleteEnhMetaFile (hemf) ;
        					return 0 ;
          
     			case 	WM_PAINT:
        					hdc = BeginPaint (hwnd, &ps) ;
          
       					GetClientRect (hwnd, &rect) ;
          
        					rect.left   		=     	rect.right  		/ 4 ;
          					rect.right  		= 3 * 	rect.right  		/ 4 ;
          					rect.top    		=     	rect.bottom 		/ 4 ;
          					rect.bottom 		= 3 * 	rect.bottom 		/ 4 ;
          
          					hemf = GetEnhMetaFile (TEXT ("emf3.emf")) ;
          
          					PlayEnhMetaFile (hdc, hemf, &rect) ;
          					DeleteEnhMetaFile (hemf) ;
          					EndPaint (hwnd, &ps) ;
          					return 0 ;
          
     			case 	WM_DESTROY:
          					PostQuitMessage (0) ;
          					return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

0000  	01 00 00 00 88 00 00 00 60 00 00 00 60 00 00 00	    ........`...`...
0010  	CC 00 00 00 CC 00 00 00 B8 0B 00 00 B8 0B 00 00     ................
0020  	E7 18 00 00 E7 18 00 00 20 45 4D 46 00 00 01 00  	........EMF.....
0030  	88 01 00 00 0F 00 00 00 03 00 00 00 12 00 00 00  	................
0040  	64 00 00 00 00 00 00 00 00 04 00 00 00 03 00 00  	d...............
0050  	40 01 00 00 F0 00 00 00 00 00 00 00 00 00 00 00  	@...............
0060  	00 00 00 00 45 00 4D 00 46 00 33 00 00 00 45 00  	....E.M.F.3...E.
0070  	4D 00 46 00 20 00 44 00 65 00 6D 00 6F 00 20 00 	M.F....D.e.m.o..
0080  	23 00 33 00 00 00 00 00 27 00 00 00 18 00 00 00  	#.3.....'.......
0090  	01 00 00 00 00 00 00 00 00 00 FF 00 00 00 00 00  	................
00A0  	25 00 00 00 0C 00 00 00 01 00 00 00 5F 00 00 00  	%..........._...
00B0  	34 00 00 00 02 00 00 00 34 00 00 00 00 00 00 00  	4.......4.......
00C0  	34 00 00 00 00 00 00 00 00 00 01 00 05 00 00 00  	4...............
00D0  	00 00 00 00 FF 00 00 00 00 00 00 00 00 00 00 00  	................
00E0  	25 00 00 00 0C 00 00 00 02 00 00 00 2B 00 00 00  	%...........+...
00F0  	18 00 00 00 63 00 00 00 63 00 00 00 C6 00 00 00  	....c...c.......
0100  	C6 00 00 00 1B 00 00 00 10 00 00 00 64 00 00 00  	............d...
0110  	64 00 00 00 36 00 00 00 10 00 00 00 C8 00 00 00  	d...6...........
0120  	C8 00 00 00 1B 00 00 00 10 00 00 00 C8 00 00 00  	................
0130  	64 00 00 00 36 00 00 00 10 00 00 00 64 00 00 00  	d...6.......d...
0140  	C8 00 00 00 25 00 00 00 0C 00 00 00 07 00 00 80  	....%...........
0150  	28 00 00 00 0C 00 00 00 02 00 00 00 25 00 00 00  	(...........%...
0160  	0C 00 00 00 00 00 00 80 28 00 00 00 0C 00 00 00  	........(.......
0170  	01 00 00 00 0E 00 00 00 14 00 00 00 00 00 00 00  	................
0180  	10 00 00 00 14 00 00 00							    ........

 ï¿½ï¿½Ê½18-5  EMF4
EMF4.C
/*----------------------------------------------------------------------------
   	EMF4.C -- 	Enhanced Metafile Demo #4
             					(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#define OEMRESOURCE
#include <windows.h>

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("EMF4") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
     
     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         					= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       				= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Enhanced Metafile Demo #4"),
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	BITMAP       			bm ;
     	HBITMAP      			hbm ;
     	HDC          			hdc, hdcEMF, hdcMem ;
     	HENHMETAFILE 			hemf ;
     	PAINTSTRUCT  			ps ;
     	RECT         			rect ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          	hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf4.emf"), NULL,
            TEXT ("EMF4\0EMF Demo #4\0")) ;
          
          			hbm = LoadBitmap (NULL, MAKEINTRESOURCE (OBM_CLOSE)) ;
          
          			GetObject (hbm, sizeof (BITMAP), &bm) ;
          
          			hdcMem = CreateCompatibleDC (hdcEMF) ;
          
          			SelectObject (hdcMem, hbm) ;
          
          			StretchBlt (hdcEMF,100,100,100,100,
                	hdcMem,	0,0,bm.bmWidth, bm.bmHeight, SRCCOPY) ;
          
          			DeleteDC (hdcMem) ;
			DeleteObject (hbm) ;
          
          			hemf = CloseEnhMetaFile (hdcEMF) ;
          
          			DeleteEnhMetaFile (hemf) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          			rect.left   		=     rect.right		/ 4 ;
          			rect.right  		= 3 * rect.right 		/ 4 ;
          			rect.top    			=     rect.bottom	/ 4 ;
          			rect.bottom 		= 3 * rect.bottom		/ 4 ;
          
          			hemf = GetEnhMetaFile (TEXT ("emf4.emf")) ;
          
          			PlayEnhMetaFile (hdc, hemf, &rect) ;
          			DeleteEnhMetaFile (hemf) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

0000  	01 00 00 00 88 00 00 00 64 00 00 00 64 00 00 00  		........d...d...
0010  	C7 00 00 00 C7 00 00 00 35 0C 00 00 35 0C 00 00	  	    ........5...5...
0020  	4B 18 00 00 4B 18 00 00 20 45 4D 46 00 00 01 00  		K...K....EMF....
0030  	F0 0E 00 00 03 00 00 00 01 00 00 00 12 00 00 00  		................
0040  	64 00 00 00 00 00 00 00 00 04 00 00 00 03 00 00  		d...............
0050  	40 01 00 00 F0 00 00 00 00 00 00 00 00 00 00 00  		@...............
0060  	00 00 00 00 45 00 4D 00 46 00 34 00 00 00 45 00  		....E.M.F.4...E.
0070  	4D 00 46 00 20 00 44 00 65 00 6D 00 6F 00 20 00 		M.F...D.e.m.o...
0080  	23 00 34 00 00 00 00 00 4D 00 00 00 54 0E 00 00  		#.4.....M...T...
0090  	64 00 00 00 64 00 00 00 C7 00 00 00 C7 00 00 00  		d...d...........
00A0  	64 00 00 00 64 00 00 00 64 00 00 00 64 00 00 00  		d...d...d...d...
00B0  	20 00 CC 00 00 00 00 00 00 00 00 00 00 00 80 3F  		..............?
00C0  	00 00 00 00 00 00 00 00 00 00 80 3F 00 00 00 00  		...........?....
00D0  	00 00 00 00 FF FF FF 00 00 00 00 00 6C 00 00 00  		............l...
00E0  	28 00 00 00 94 00 00 00 C0 0D 00 00 28 00 00 00  		(...........(...
00F0  	16 00 00 00 28 00 00 00 28 00 00 00 16 00 00 00  		....(...(.......
0100  	01 00 20 00 00 00 00 00 C0 0D 00 00 00 00 00 00  		.. .............
0110  	00 00 00 00 00 00 00 00 00 00 00 00 C0 C0 C0 00  		................
0120  	C0 C0 C0 00 C0 C0 C0 00 C0 C0 C0 00 C0 C0 C0 00  	    ................
. . . . 
0ED0  	C0 C0 C0 00 C0 C0 C0 00 C0 C0 C0 00 0E 00 00 00  	    ................
0EE0  	14 00 00 00 00 00 00 00 10 00 00 00 14 00 00 00  		................

 ï¿½ï¿½Ê½18-6 EMF5
EMF5.C
/*----------------------------------------------------------------------------
   	EMF5.C -- 	Enhanced Metafile Demo #5
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/
#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("EMF5") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
     
     	wndclass.style         					= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         					= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       				= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Enhanced Metafile Demo #5"),
                          	WS_OVERLAPPEDWINDOW,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	CW_USEDEFAULT, CW_USEDEFAULT,
                          	NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

int CALLBACK EnhMetaFileProc (	HDC hdc, HANDLETABLE * pHandleTable,
                                CONST ENHMETARECORD * pEmfRecord, 
                              	int iHandles, LPARAM pData)
{
     	PlayEnhMetaFileRecord (hdc, pHandleTable, pEmfRecord, iHandles) ;
     	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	HDC          		hdc ;
     	HENHMETAFILE 		hemf ;
     	PAINTSTRUCT  		ps ;
     	RECT         		rect ;
     
     	switch (message)
     {
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          
          			rect.left   			=     rect.right		/ 4 ;
          			rect.right  			= 3 * rect.right		/ 4 ;
          			rect.top    			=     rect.bottom		/ 4 ;
          			rect.bottom 			= 3 * rect.bottom		/ 4 ;
          
          		hemf = GetEnhMetaFile (TEXT ("..\\emf3\\emf3.emf")) ;
          
          			EnumEnhMetaFile (hdc, hemf, EnhMetaFileProc, NULL, &rect) ;
          			DeleteEnhMetaFile (hemf) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

PlayEnhMetaFile (hdc, hemf, &rect) ;

if (pEmfRecord->iType != EMR_LINETO)

if (pEmfRecord->iType != EMR_SELECTOBJECT)

 ï¿½ï¿½Ê½18-7 EMF6
EMF6.C
/*----------------------------------------------------------------------------
   	EMF6.C -- 	Enhanced Metafile Demo #6
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR lpszCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("EMF6") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
     
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       		= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (szAppName, TEXT ("Enhanced Metafile Demo #6"),
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

int CALLBACK EnhMetaFileProc (	HDC hdc, HANDLETABLE * pHandleTable,
                              	CONST ENHMETARECORD * pEmfRecord, 
                              	int iHandles, LPARAM pData)
{
     	ENHMETARECORD * pEmfr ;
     	pEmfr = (ENHMETARECORD *) malloc (pEmfRecord->nSize) ;
     	CopyMemory (pEmfr, pEmfRecord, pEmfRecord->nSize) ;
     	if (pEmfr->iType == EMR_RECTANGLE)
          			pEmfr->iType = EMR_ELLIPSE ;
     	PlayEnhMetaFileRecord (hdc, pHandleTable, pEmfr, iHandles) ;
     	free (pEmfr) ;
     	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     	HDC          		hdc ;
     	HENHMETAFILE 		hemf ;
     	PAINTSTRUCT  		ps ;
     	RECT         		rect ;
     
     	switch (message)
     	{
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          
          			rect.left   			=     rect.right	/ 4 ;
          			rect.right  			= 3 * rect.right 	/ 4 ;
          			rect.top    			=     rect.bottom	/ 4 ;
          			rect.bottom 			= 3 * rect.bottom	/ 4 ;
          
          	hemf = GetEnhMetaFile (TEXT ("..\\emf3\\emf3.emf")) ;
          	EnumEnhMetaFile (	hdc, hemf, EnhMetaFileProc, NULL, &rect) ;
          						DeleteEnhMetaFile (hemf) ;
          						EndPaint (hwnd, &ps) ;
          						return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

if (pEmfr->iType == EMR_RECTANGLE)
{
     	PlayEnhMetaFileRecord (hdc, pHandleTable, pEmfr, nObjects) ;
     	pEmfr->iType = EMR_ELLIPSE ;
}

typedef struct tagHANDLETABLE
{
     	HGDIOBJ objectHandle [1] ;
}
HANDLETABLE ;

pHandleTable->objectHandle[i]

 ï¿½ï¿½Ê½18-8 EMF7
EMF7.C
/*---------------------------------------------------------------------------
   	EMF7.C -- Enhanced Metafile Demo #7
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (	HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    								PSTR lpszCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("EMF7") ;
     	HWND         				hwnd ;
     	MSG          				msg ;
     	WNDCLASS     			wndclass ;
     
  	wndclass.style         				= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       		= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (szAppName, TEXT ("Enhanced Metafile Demo #7"),
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     return msg.wParam ;
}

int CALLBACK EnhMetaFileProc (	HDC hdc, HANDLETABLE * pHandleTable,
                              	CONST ENHMETARECORD * pEmfRecord, 
                                int iHandles, LPARAM pData)
{
     	HBRUSH   			hBrush ;
     	HPEN     				hPen ;
     	LOGBRUSH 			lb ;
     
     	if (pEmfRecord->iType != EMR_HEADER && pEmfRecord->iType != EMR_EOF)
          		PlayEnhMetaFileRecord (hdc, pHandleTable, pEmfRecord, iHandles) ;
     	if (pEmfRecord->iType == EMR_RECTANGLE)
     	{
          		hBrush = SelectObject (hdc, GetStockObject (NULL_BRUSH)) ;
         		lb.lbStyle = BS_SOLID ;
          		lb.lbColor = RGB (0, 255, 0) ;
          		lb.lbHatch = 0 ;
          
          		hPen = SelectObject (hdc,
               					ExtCreatePen (PS_SOLID | PS_GEOMETRIC, 5, &lb, 0, NULL)) ;
		Ellipse (hdc, 100, 100, 200, 200) ;
          		DeleteObject (SelectObject (hdc, hPen)) ;
          		SelectObject (hdc, hBrush) ;
     	}
     	return TRUE ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	ENHMETAHEADER 		emh ;
     	HDC           					hdc, hdcEMF ;
     	HENHMETAFILE  		hemfOld, hemf ;
     	PAINTSTRUCT   			ps ;
     	RECT          					rect ;
     	
     	switch (message)
     	{
     	case 	WM_CREATE:
          
               							// Retrieve existing metafile and header
          
          			hemfOld = GetEnhMetaFile (TEXT ("..\\emf3\\emf3.emf")) ;
          
         	 		GetEnhMetaFileHeader (hemfOld, sizeof (ENHMETAHEADER), &emh) ;
          
               							// Create a new metafile DC
          
			hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf7.emf"), NULL,
                                      	TEXT ("EMF7\0EMF Demo #7\0")) ;
          
               							// Enumerate the existing metafile
          
          			EnumEnhMetaFile (hdcEMF, hemfOld, EnhMetaFileProc, NULL,
                           			(RECT *) & emh.rclBounds) ;
          
               							// Clean up
          
			hemf = CloseEnhMetaFile (hdcEMF) ;
          
			DeleteEnhMetaFile (hemfOld) ;
          			DeleteEnhMetaFile (hemf) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          			rect.left   			=     rect.right 	/ 4 ;
          			rect.right  			= 3 * rect.right 	/ 4 ;
          			rect.top    			=     rect.bottom   / 4 ;
          			rect.bottom		        = 3 * rect.bottom   / 4 ;
          
          			hemf = GetEnhMetaFile (TEXT ("emf7.emf")) ;
          
          			PlayEnhMetaFile (hdc, hemf, &rect) ;
          			DeleteEnhMetaFile (hemf) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 ï¿½ï¿½Ê½18-9 EMFVIEW
EMFVIEW.C
/*---------------------------------------------------------------------------
   	EMFVIEW.C -- 	View Enhanced Metafiles
                						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include <commdlg.h>
#include "resource.h"

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("EmfView") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	HACCEL   			hAccel ;
     	HWND     				hwnd ;
     	MSG      				msg ;
	WNDCLASS wndclass ;
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         		= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       		= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= (HBRUSH) GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szAppName ;
     	wndclass.lpszClassName 		= szAppName ;

     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"), 
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}

     	hwnd = CreateWindow (	szAppName, TEXT ("Enhanced Metafile Viewer"),
                          		WS_OVERLAPPEDWINDOW,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT, 
                          		NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	hAccel = LoadAccelerators (hInstance, szAppName) ;
     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		if (!TranslateAccelerator (hwnd, hAccel, &msg))
          		{
               			TranslateMessage (&msg) ;
              	 		DispatchMessage (&msg) ;
          		}
     	}
     	return msg.wParam ;
}

HPALETTE CreatePaletteFromMetaFile (HENHMETAFILE hemf)
{
     	HPALETTE     			hPalette ;
     	int          				iNum ;
     	LOGPALETTE *	plp ;

     	if (!hemf)
          			return NULL ;
     	if (0 == (iNum = GetEnhMetaFilePaletteEntries (hemf, 0, NULL)))
          			return NULL ;
     	plp = malloc (sizeof (LOGPALETTE) + (iNum - 1) * sizeof (PALETTEENTRY)) ;
     	plp->palVersion    = 0x0300 ;
     	plp->palNumEntries = iNum ;

     	GetEnhMetaFilePaletteEntries (hemf, iNum, plp->palPalEntry) ;
     	hPalette = CreatePalette (plp) ;
     	free (plp) ;
     	return hPalette ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static DOCINFO  	di = { sizeof (DOCINFO), TEXT ("EmfView: Printing") } ;
     	static HENHMETAFILE hemf ;
     	static OPENFILENAME ofn ;
     	static PRINTDLG     		printdlg = { sizeof (PRINTDLG) } ;
     	static TCHAR        			szFileName [MAX_PATH], szTitleName [MAX_PATH] ;
     	static TCHAR        			szFilter[] = 
                               								TEXT ("Enhanced Metafiles (*.EMF)\0*.emf\0")
                               								TEXT ("All Files (*.*)\0*.*\0\0") ;
     	BOOL                						bSuccess ;
     	ENHMETAHEADER       			header ;
     	HDC                 						hdc, hdcPrn ;
     	HENHMETAFILE        			hemfCopy ;
     	HMENU               						hMenu ;
     	HPALETTE            					hPalette ;
     	int                 						i, iLength, iEnable ;
     	PAINTSTRUCT         				ps ;
     	RECT                						rect ;
     	PTSTR               						pBuffer ;

     	switch (message)
     	{
     	case WM_CREATE:
               			// Initialize OPENFILENAME structure
          			ofn.lStructSize       			= sizeof (OPENFILENAME) ;
          			ofn.hwndOwner         			= hwnd ;
          			ofn.hInstance         			= NULL ;
          			ofn.lpstrFilter       			= szFilter ;
          			ofn.lpstrCustomFilter 		    = NULL ;
          			ofn.nMaxCustFilter    			= 0 ;
          			ofn.nFilterIndex      			= 0 ;
          			ofn.lpstrFile         			= szFileName ;
          			ofn.nMaxFile          			= MAX_PATH ;
          			ofn.lpstrFileTitle    			= szTitleName ;
          			ofn.nMaxFileTitle     			= MAX_PATH ;
          			ofn.lpstrInitialDir   			= NULL ;
          			ofn.lpstrTitle        			= NULL ;
          			ofn.Flags             			= 0 ;   
          			ofn.nFileOffset       			= 0 ;
          			ofn.nFileExtension    			= 0 ;
          			ofn.lpstrDefExt       			= TEXT ("emf") ;
          			ofn.lCustData         			= 0 ;
          			ofn.lpfnHook          			= NULL ;
          			ofn.lpTemplateName    			= NULL ;
         	 		return 0 ;

 	case 	WM_INITMENUPOPUP:
          			hMenu = GetMenu (hwnd) ;

          			iEnable = hemf ? MF_ENABLED : MF_GRAYED ;

          	EnableMenuItem (hMenu, IDM_FILE_SAVE_AS,    		iEnable) ;
          	EnableMenuItem (hMenu, IDM_FILE_PRINT,      		iEnable) ;
          	EnableMenuItem (hMenu, IDM_FILE_PROPERTIES, 		iEnable) ;
         	EnableMenuItem (hMenu, IDM_EDIT_CUT,        		iEnable) ;
   			EnableMenuItem (hMenu, IDM_EDIT_COPY,       		iEnable) ;
   			EnableMenuItem (hMenu, IDM_EDIT_DELETE,     		iEnable) ;
   			EnableMenuItem (hMenu, IDM_EDIT_PASTE,
			IsClipboardFormatAvailable (CF_ENHMETAFILE) ?
			MF_ENABLED : MF_GRAYED) ;
   			return 0 ;

     	case 	WM_COMMAND:
          		switch (LOWORD (wParam))
          				{
          			case 	IDM_FILE_OPEN:
                			// Show the File Open dialog box

               					ofn.Flags = 0 ;
     
               					if (!GetOpenFileName (&ofn))
                    							return 0 ;
               
                			// If there's an existing EMF, get rid of it.

               					if (hemf)
               					{
                    							DeleteEnhMetaFile (hemf) ;
                    							hemf = NULL ;
               					}
                    							// Load the EMF into memory

               				SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               				ShowCursor (TRUE) ;

               				hemf = GetEnhMetaFile (szFileName) ;

               				ShowCursor (FALSE) ;
               				SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

                    	// Invalidate the client area for later update

               				InvalidateRect (hwnd, NULL, TRUE) ;

               				if (hemf == NULL)
               				{
                    MessageBox (	hwnd, TEXT ("Cannot load metafile"), 
                                	szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               				}
               				return 0 ;

          		case 	IDM_FILE_SAVE_AS:
               				if (!hemf)
                    						return 0 ;

                    						// Show the File Save dialog box

               				ofn.Flags = OFN_OVERWRITEPROMPT ;
     
               				if (!GetSaveFileName (&ofn))
                    						return 0 ;
               
                    						// Save the EMF to disk file

               				SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               				ShowCursor (TRUE) ;

               				hemfCopy = CopyEnhMetaFile (hemf, szFileName) ;

               				ShowCursor (FALSE) ;
               				SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
               				if (hemfCopy)
               				{
                    						DeleteEnhMetaFile (hemf) ;
                    						hemf = hemfCopy ;
               				}
               				else
                    MessageBox (	hwnd, TEXT ("Cannot save metafile"), 
                                	szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               				return 0 ;

          		case 	IDM_FILE_PRINT:
                    		// Show the Print dialog box and get printer DC

               	printdlg.Flags = PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION ;

               				if (!PrintDlg (&printdlg))
                    						return 0 ;
               
               				if (NULL == (hdcPrn = printdlg.hDC)) 
               				{
                   MessageBox (	hwnd, TEXT ("Cannot obtain printer DC"),
                                szAppName, MB_ICONEXCLAMATION | MB_OK) ;
                    						return 0 ;
               				}
                    						// Get size of printable area of page

               				rect.left   		= 0 ;
               				rect.right  		= GetDeviceCaps (hdcPrn, HORZRES) ;
               				rect.top    		= 0 ;
               				rect.bottom 		= GetDeviceCaps (hdcPrn, VERTRES) ;

               				bSuccess = FALSE ;

                    						// Play the EMF to the printer

               				SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               				ShowCursor (TRUE) ;

               				if ((StartDoc (hdcPrn, &di) > 0) && (StartPage (hdcPrn) > 0))
				{
                    						PlayEnhMetaFile (hdcPrn, hemf, &rect) ;
                    
                    					if (EndPage (hdcPrn) > 0)
                    					{
                         							bSuccess = TRUE ;
                         							EndDoc (hdcPrn) ;
                    					}
               				}
               				ShowCursor (FALSE) ;
               				SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               				DeleteDC (hdcPrn) ;

               				if (!bSuccess)
                MessageBox (	hwnd, TEXT ("Could not print metafile"),
                                	  szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               				return 0 ;

          		case 	IDM_FILE_PROPERTIES:
               				if (!hemf)
                    						return 0 ;

               				iLength = GetEnhMetaFileDescription (hemf, 0, NULL) ;
               				pBuffer = malloc ((iLength + 256) * sizeof (TCHAR)) ;

               				GetEnhMetaFileHeader (hemf, sizeof (ENHMETAHEADER), &header) ;

                    					// Format header file information 

               				i  = wsprintf (pBuffer, 
                              							TEXT ("Bounds = (%i, %i) to (%i, %i) pixels\n"),
                              							header.rclBounds.left, header.rclBounds.top,
                              							header.rclBounds.right, header.rclBounds.bottom) ;

               				i += wsprintf (pBuffer + i, 
                              							TEXT ("Frame = (%i, %i) to (%i, %i) mms\n"),
                              							header.rclFrame.left, header.rclFrame.top,
                              							header.rclFrame.right, header.rclFrame.bottom) ;

               				i += wsprintf (pBuffer + i,
                              							TEXT ("Resolution = (%i, %i) pixels")
                              							TEXT (" = (%i, %i) mms\n"),
                              							header.szlDevice.cx, header.szlDevice.cy,
                              							header.szlMillimeters.cx, 
                              							header.szlMillimeters.cy) ;

               				i += wsprintf (pBuffer + i,
                              							TEXT ("Size = %i, Records = %i, ")
                              							TEXT ("Handles = %i, Palette entries = %i\n"),
                              							header.nBytes, header.nRecords,
                              							header.nHandles, header.nPalEntries) ;
                    							// Include the metafile description, if present

               				if (iLength)
               				{
                    							i += wsprintf (pBuffer + i, TEXT ("Description = ")) ;
                    							GetEnhMetaFileDescription (hemf, iLength, pBuffer + i) ;
                    							pBuffer [lstrlen (pBuffer)] = '\t' ;
               				}

               				MessageBox (hwnd, pBuffer, TEXT ("Metafile Properties"), MB_OK) ;
               				free (pBuffer) ;                              
               				return 0 ;

          		case 	IDM_EDIT_COPY:
          		case 	IDM_EDIT_CUT:
               				if (!hemf)
                    						return 0 ;

                    						// Transfer metafile copy to the clipboard

               				hemfCopy = CopyEnhMetaFile (hemf, NULL) ;

               				OpenClipboard (hwnd) ;
               				EmptyClipboard () ;
               				SetClipboardData (CF_ENHMETAFILE, hemfCopy) ;
               				CloseClipboard () ;

               				if (LOWORD (wParam) == IDM_EDIT_COPY)
                    						return 0 ;
                                       		// fall through if IDM_EDIT_CUT 
          		case 	IDM_EDIT_DELETE:
               				if (hemf)
               				{
                    					DeleteEnhMetaFile (hemf) ;
                    					hemf = NULL ;
                    					InvalidateRect (hwnd, NULL, TRUE) ;
               				}
               				return 0 ;

  		case 	IDM_EDIT_PASTE:
               				OpenClipboard (hwnd) ;
               				hemfCopy = GetClipboardData (CF_ENHMETAFILE) ;

               				CloseClipboard () ;
               				if (hemfCopy && hemf)
               				{
                    					DeleteEnhMetaFile (hemf) ;
                    					hemf = NULL ;
               				}

               				hemf = CopyEnhMetaFile (hemfCopy, NULL) ;
               				InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;

		case	IDM_APP_ABOUT:
               				MessageBox (	hwnd, 	TEXT ("Enhanced Metafile Viewer\n")
                            TEXT ("(c) Charles Petzold, 1998"),
                           									szAppName, MB_OK) ;
               				return 0 ;

		case 	IDM_APP_EXIT:
               				SendMessage (hwnd, WM_CLOSE, 0, 0L) ;
               				return 0 ;
          		}
        		break ;
         
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			if (hemf)
          			{
               				if (	hPalette = CreatePaletteFromMetaFile (hemf))
               				{
                    						SelectPalette (hdc, hPalette, FALSE) ;
                    						RealizePalette (hdc) ;
               				}
               				GetClientRect (hwnd, &rect) ;
               				PlayEnhMetaFile (hdc, hemf, &rect) ;

               				if (hPalette)
                    						DeleteObject (hPalette) ;
          			}
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

     	case 	WM_QUERYNEWPALETTE:
          			if (!hemf || !(hPalette = CreatePaletteFromMetaFile (hemf)))
               					return FALSE ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			InvalidateRect (hwnd, NULL, FALSE) ;
          
          			DeleteObject (hPalette) ;
          			ReleaseDC (hwnd, hdc) ;
          			return TRUE ;

     	case 	WM_PALETTECHANGED:
          			if ((HWND) wParam == hwnd)
               					break ;

          			if (!hemf || !(hPalette = CreatePaletteFromMetaFile (hemf)))
               					break ;

          			hdc = GetDC (hwnd) ;
          			SelectPalette (hdc, hPalette, FALSE) ;
          			RealizePalette (hdc) ;
          			UpdateColors (hdc) ;
          
          			DeleteObject (hPalette) ;
          			ReleaseDC (hwnd, hdc) ;
          			break ;
          
     	case 	WM_DESTROY:
          			if (hemf)
               					DeleteEnhMetaFile (hemf) ;

          			PostQuitMessage (0) ;
          			return 0 ;
     	}
	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 EMFVIEW.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
EMFVIEW MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        MENUITEM "&Open\tCtrl+O",  IDM_FILE_OPEN
        MENUITEM "Save &As...",    IDM_FILE_SAVE_AS
		MENUITEM SEPARATOR
		MENUITEM "&Print...\tCtrl+P",IDM_FILE_PRINT
        MENUITEM SEPARATOR
		MENUITEM "&Properties",  	 IDM_FILE_PROPERTIES
		MENUITEM SEPARATOR
		MENUITEM "E&xit",  		 IDM_APP_EXIT
END
    	POPUP "&Edit"
    	BEGIN
        MENUITEM "Cu&t\tCtrl+X", 				IDM_EDIT_CUT
        MENUITEM "&Copy\tCtrl+C", 			IDM_EDIT_COPY
		MENUITEM "&Paste\tCtrl+V",    	 	IDM_EDIT_PASTE
        MENUITEM "&Delete\tDel",    	   		IDM_EDIT_DELETE
    	END
    	POPUP "Help"
    	BEGIN
        MENUITEM "&About EmfView...",  	 	IDM_APP_ABOUT
    	END
END

/////////////////////////////////////////////////////////////////////////////
// Accelerator
EMFVIEW ACCELERATORS DISCARDABLE 
BEGIN
"C",IDM_EDIT_COPY, VIRTKEY, CONTROL, NOINVERT
"O",IDM_FILE_OPEN, VIRTKEY, CONTROL, NOINVERT
"P",IDM_FILE_PRINT,VIRTKEY, CONTROL, NOINVERT
"V",IDM_EDIT_PASTE,VIRTKEY, CONTROL, NOINVERT
VK_DELETE,IDM_EDIT_DELETE,VIRTKEY, NOINVERT
"X",IDM_EDIT_CUT,VIRTKEY, CONTROL, NOINVERT
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by EmfView.rc

#define 		IDM_FILE_OPEN             40001
#define 		IDM_FILE_SAVE_AS          40002
#define 		IDM_FILE_PRINT            40003
#define 		IDM_FILE_PROPERTIES       40004
#define 		IDM_APP_EXIT              40005
#define 		IDM_EDIT_CUT              40006
#define 		IDM_EDIT_COPY             40007
#define 		IDM_EDIT_PASTE            40008
#define 		IDM_EDIT_DELETE           40009
#define 		IDM_APP_ABOUT             40010

 ï¿½ï¿½Ê½18-10  EMF8
EMF8.C
/*---------------------------------------------------------------------------
   	EMF8.C -- Enhanced Metafile Demo #8
             					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
TCHAR szClass 		[] = TEXT ("EMF8") ;
TCHAR szTitle 		[] = TEXT ("EMF8: Enhanced Metafile Demo #8") ;

void DrawRuler (HDC hdc, int cx, int cy)
{
     	int     			iAdj, i, iHeight ;
     	LOGFONT 		lf ;
     	TCHAR   			ch ;

     	iAdj = GetVersion () & 0x80000000 ? 0 : 1 ;
          				// Black pen with 1-point width
     	SelectObject (hdc, CreatePen (PS_SOLID, cx / 72 / 6, 0)) ;
          				// Rectangle surrounding entire pen (with adjustment)
     	Rectangle (hdc, iAdj, iAdj, cx + iAdj + 1, cy + iAdj + 1) ;
          				// Tick marks
     	for (i = 1 ; i < 96 ; i++)
     	{
				if (i % 16 == 0) iHeight = cy /  2 ;		// inches
		else 	if (i %  8 == 0) iHeight = cy /  3 ;    	// half inches
		else 	if (i %  4 == 0) iHeight = cy /  5 ;    	// quarter inches
		else 	if (i %  2 == 0) iHeight = cy /  8 ;    	// eighths
		else                  iHeight = cy / 12 ;    		// sixteenths

          		MoveToEx (hdc, i * cx / 96, cy, NULL) ;
          		LineTo   (hdc, i * cx / 96, cy - iHeight) ;
     	}
          				// Create logical font 
     	FillMemory (&lf, sizeof (lf), 0) ;
     	lf.lfHeight = cy / 2 ;
     	lstrcpy (lf.lfFaceName, TEXT ("Times New Roman")) ;

     	SelectObject 	(hdc, CreateFontIndirect (&lf)) ;
     	SetTextAlign 	(hdc, TA_BOTTOM | TA_CENTER) ;
     	SetBkMode 		(hdc, TRANSPARENT) ;

          				// Display numbers

     	for (i = 1 ; i <= 5 ; i++)
     	{
          			ch = (TCHAR) (i + '0') ;
          			TextOut (hdc, i * cx / 6, cy / 2, &ch, 1) ;
     	}
          				// Clean up
     	DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
     	DeleteObject (SelectObject (hdc, GetStockObject (BLACK_PEN))) ;
}

void CreateRoutine (HWND hwnd)
{
     	HDC          				hdcEMF ;
     	HENHMETAFILE hemf ;
     	int          				cxMms, cyMms, cxPix, cyPix, xDpi, yDpi ;

     	hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf8.emf"), NULL,
                                 	TEXT ("EMF8\0EMF Demo #8\0")) ;
     	if (hdcEMF == NULL)
          			return ;
     	cxMms 		= GetDeviceCaps (hdcEMF, HORZSIZE) ;
     	cyMms 		= GetDeviceCaps (hdcEMF, VERTSIZE) ;
     	cxPix 		= GetDeviceCaps (hdcEMF, HORZRES) ;
     	cyPix 		= GetDeviceCaps (hdcEMF, VERTRES) ;

     	xDpi 		= cxPix * 254 / cxMms / 10 ;
     	yDpi		= cyPix * 254 / cyMms / 10 ;

     	DrawRuler (hdcEMF, 6 * xDpi, yDpi) ;
     	hemf = CloseEnhMetaFile (hdcEMF) ;
     	DeleteEnhMetaFile (hemf) ;
}

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	ENHMETAHEADER 		emh ;
     	HENHMETAFILE  		hemf ;
     	int           					cxImage, cyImage ;
     	RECT          					rect ;

     	hemf = GetEnhMetaFile (TEXT ("emf8.emf")) ;
     	GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;
     	cxImage = emh.rclBounds.right - emh.rclBounds.left ;
     	cyImage = emh.rclBounds.bottom - emh.rclBounds.top ;

     	rect.left   		= (cxArea - cxImage) / 2 ;
     	rect.right  		= (cxArea + cxImage) / 2 ;
     	rect.top    		= (cyArea - cyImage) / 2 ;
     	rect.bottom 		= (cyArea + cyImage) / 2 ;

     	PlayEnhMetaFile (hdc, hemf, &rect) ;
     	DeleteEnhMetaFile (hemf) ;
}

 EMF.C
/*----------------------------------------------------------------------------
   	EMF.C -- 	Enhanced Metafile Demonstration Shell Program
            					(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include <commdlg.h>
#include "..\\emf8\\resource.h"

extern void CreateRoutine (HWND) ;
extern void PaintRoutine  (HWND, HDC, int, int) ;

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
HANDLE hInst ;
extern TCHAR szClass [] ;
extern TCHAR szTitle [] ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	TCHAR    				szResource [] = TEXT ("EMF") ;
     	HWND     				hwnd ;
     	MSG      				msg ;
     	WNDCLASS 			wndclass ;

     	hInst = hInstance ;
     	wndclass.style         			= CS_HREDRAW | CS_VREDRAW ;
     	wndclass.lpfnWndProc   			= WndProc ;
     	wndclass.cbClsExtra    			= 0 ;
     	wndclass.cbWndExtra    			= 0 ;
     	wndclass.hInstance     			= hInstance ;
     	wndclass.hIcon         			= LoadIcon (NULL, IDI_APPLICATION) ;
     	wndclass.hCursor       			= LoadCursor (NULL, IDC_ARROW) ;
     	wndclass.hbrBackground 		= GetStockObject (WHITE_BRUSH) ;
     	wndclass.lpszMenuName  		= szResource ;
     	wndclass.lpszClassName 		= szClass ;
     
     	if (!RegisterClass (&wndclass))
     	{
          		MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      							szClass, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hwnd = CreateWindow (	szClass, szTitle,
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT,
                         NULL, NULL, hInstance, NULL) ;

     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;

     	while (GetMessage (&msg, NULL, 0, 0))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return msg.wParam ;
}

BOOL PrintRoutine (HWND hwnd)
{
     	static DOCINFO  		di ;
     	static PRINTDLG 		printdlg = { sizeof (PRINTDLG) } ;
     	static TCHAR    			szMessage [32] ;
     	BOOL            						bSuccess = FALSE ;
     	HDC             						hdcPrn ;
     	int             						cxPage, cyPage ;

     	printdlg.Flags = PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION ;
     	if (!PrintDlg (&printdlg))
          			return TRUE ;
     	if (NULL == (hdcPrn = printdlg.hDC))
          			return FALSE ;
     	cxPage = GetDeviceCaps (hdcPrn, HORZRES) ;
     	cyPage = GetDeviceCaps (hdcPrn, VERTRES) ;

     	lstrcpy (szMessage, szClass) ;
     	lstrcat (szMessage, TEXT (": Printing")) ;

     	di.cbSize      			= sizeof (DOCINFO) ;
     	di.lpszDocName 		= szMessage ;

     	if (StartDoc (hdcPrn, &di) > 0)
	{
          		if (StartPage (hdcPrn) > 0)
          		{
               			PaintRoutine (hwnd, hdcPrn, cxPage, cyPage) ;
               			if (EndPage (hdcPrn) > 0)
               			{
                    					EndDoc (hdcPrn) ;
                    					bSuccess = TRUE ;
               			}
          		}
     	}
     	DeleteDC (hdcPrn) ;
     	return bSuccess ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	BOOL        				bSuccess ;
     	static int  		cxClient, cyClient ;
     	HDC         				hdc ;
     	PAINTSTRUCT 		ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			CreateRoutine (hwnd) ;
          			return 0 ;
          
     	case 	WM_COMMAND:
          			switch (wParam)
          			{
          			case 	IDM_PRINT:
               					SetCursor (LoadCursor (NULL, IDC_WAIT)) ;
               					ShowCursor (TRUE) ;
               
               					bSuccess = PrintRoutine (hwnd) ;
               
               					ShowCursor (FALSE) ;
               					SetCursor (LoadCursor (NULL, IDC_ARROW)) ;
               
               					if (!bSuccess)
           MessageBox (hwnd, TEXT ("Error encountered during printing"),
                       szClass, MB_ICONASTERISK | MB_OK) ;
               		   return 0 ;
               
          			case 	IDM_EXIT:
               					SendMessage (hwnd, WM_CLOSE, 0, 0) ;
               					return 0 ;
               
          			case 	IDM_ABOUT:
           MessageBox (hwnd, TEXT ("Enhanced Metafile Demo Program\n")
                       TEXT ("Copyright (c) Charles Petzold, 1998"),
                       szClass, MB_ICONINFORMATION | MB_OK) ;
               		   return 0 ;
          			}
          			break ;
          
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;
          
	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			PaintRoutine (hwnd, hdc, cxClient, cyClient) ;
          
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY :
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 EMF.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
EMF MENU DISCARDABLE 
BEGIN
    	POPUP "&File"
    	BEGIN
        			MENUITEM "&Print...", 					IDM_PRINT
       	 		MENUITEM SEPARATOR
        			MENUITEM "E&xit",     	      					IDM_EXIT
    	END
    	POPUP "&Help"
    	BEGIN
        			MENUITEM "&About...",  	 				IDM_ABOUT
    	END
END

 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by Emf.rc
//
#define IDM_PRINT                40001
#define IDM_EXIT                 40002
#define IDM_ABOUT                40003

 ï¿½ï¿½Ê½18-11  EMF9
EMF9.C
/*---------------------------------------------------------------------------
   	EMF9.C -- Enhanced Metafile Demo #9
             					(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include <string.h>

TCHAR szClass 		[] = TEXT ("EMF9") ;
TCHAR szTitle 		[] = TEXT ("EMF9: Enhanced Metafile Demo #9") ;

void CreateRoutine (HWND hwnd)
{
}

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	ENHMETAHEADER 		emh ;
     	HENHMETAFILE  		hemf ;
     	int           					cxMms, cyMms, cxPix, cyPix, cxImage, cyImage ;
     	RECT          					rect ;

     	cxMms 		= GetDeviceCaps (hdc, HORZSIZE) ;
     	cyMms 		= GetDeviceCaps (hdc, VERTSIZE) ;
     	cxPix 		= GetDeviceCaps (hdc, HORZRES) ;
     	cyPix 		= GetDeviceCaps (hdc, VERTRES) ;

     	hemf = GetEnhMetaFile (TEXT ("..\\emf8\\emf8.emf")) ;
     	GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;
     	cxImage 			= emh.rclFrame.right - emh.rclFrame.left ;
     	cyImage 			= emh.rclFrame.bottom - emh.rclFrame.top ;

     	cxImage 			= cxImage * cxPix / cxMms / 100 ;
     	cyImage 			= cyImage * cyPix / cyMms / 100 ;

     	rect.left   		= (cxArea - cxImage) / 2 ;
     	rect.right  		= (cxArea + cxImage) / 2 ;
     	rect.top    		= (cyArea - cyImage) / 2 ;
     	rect.bottom 		= (cyArea + cyImage) / 2 ;

     	PlayEnhMetaFile (hdc, hemf, &rect) ;
     	DeleteEnhMetaFile (hemf) ;
}

 ï¿½ï¿½Ê½18-12  EMF10
EMF10.C
/*--------------------------------------------------------------------------
   	EMF10.C -- 	Enhanced Metafile Demo #10
              					(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
TCHAR szClass 		[] = TEXT ("EMF10") ;
TCHAR szTitle 		[] = TEXT ("EMF10: Enhanced Metafile Demo #10") ;
void CreateRoutine (HWND hwnd)
{
}

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	ENHMETAHEADER 		emh ;
     	float         					fScale ;
     	HENHMETAFILE  		hemf ;
     	int           					cxMms, cyMms, cxPix, cyPix, cxImage, cyImage ;
     	RECT          					rect ;

     	cxMms 		= GetDeviceCaps (hdc, HORZSIZE) ;
     	cyMms 		= GetDeviceCaps (hdc, VERTSIZE) ;
     	cxPix 		= GetDeviceCaps (hdc, HORZRES) ;
     	cyPix 		= GetDeviceCaps (hdc, VERTRES) ;

     	hemf 	= GetEnhMetaFile (TEXT ("..\\emf8\\emf8.emf")) ;

     	GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;

     	cxImage 	= emh.rclFrame.right - emh.rclFrame.left ;
     	cyImage 	= emh.rclFrame.bottom - emh.rclFrame.top ;

     	cxImage 	= cxImage * cxPix / cxMms / 100 ;
     	cyImage 	= cyImage * cyPix / cyMms / 100 ;

     	fScale 	= min ((float) cxArea / cxImage, (float) cyArea / cyImage) ;

     	cxImage 			= (int) (fScale * cxImage) ;
     	cyImage 			= (int) (fScale * cyImage) ;

     	rect.left   		= (cxArea - cxImage) / 2 ;
     	rect.right		= (cxArea + cxImage) / 2 ;
     	rect.top    			= (cyArea - cyImage) / 2 ;
     	rect.bottom = (cyArea + cyImage) / 2 ;
     	PlayEnhMetaFile (hdc, hemf, &rect) ;
     	DeleteEnhMetaFile (hemf) ;
}

 ï¿½ï¿½Ê½18-13  EMF11
EMF11.C
/*---------------------------------------------------------------------------
   	EMF11.C -- Enhanced Metafile Demo #11
              						(c) Charles Petzold, 1998
  ------------------------------------------------------------------------*/

#include <windows.h>
TCHAR szClass 		[] = TEXT ("EMF11") ;
TCHAR szTitle 		[] = TEXT ("EMF11: Enhanced Metafile Demo #11") ;

void DrawRuler (HDC hdc, int cx, int cy)
{
     	int     			i, iHeight ;
     	LOGFONT 		lf ;
     	TCHAR   			ch ;

          			// Black pen with 1-point width

     	SelectObject (hdc, CreatePen (PS_SOLID, cx / 72 / 6, 0)) ;
          			// Rectangle surrounding entire pen (with adjustment)
     	if (GetVersion () & 0x80000000) 	`			// Windows 98
  			Rectangle (hdc, 0, -2, cx + 2, cy) ;
     	else   
// Windows NT
          			Rectangle (hdc, 0, -1, cx + 1, cy) ;

          			// Tick marks
          
     	for (i = 1 ; i < 96 ; i++)
     	{
         if	(i %16== 0)	iHeight = cy /	2 	;  	// inches
         else if(i % 8	== 0)iHeight = cy /	3 ;	// half inches
         else if(i % 4	== 0)iHeight = cy /	5 ;	// quarter inches
         else if(i % 2	== 0)iHeight = cy /	8 ;	// eighths
         else iHeight = cy /12	;	// sixteenths

		MoveToEx (hdc, i * cx / 96, 0, NULL) ;
          		LineTo   (hdc, i * cx / 96, iHeight) ;
     	}
          		// Create logical font 
     	FillMemory (&lf, sizeof (lf), 0) ;
     	lf.lfHeight = cy / 2 ;
     	lstrcpy (lf.lfFaceName, TEXT ("Times New Roman")) ;

     	SelectObject 	(hdc, CreateFontIndirect (&lf)) ;
     	SetTextAlign 	(hdc, TA_BOTTOM | TA_CENTER) ;
     	SetBkMode    		(hdc, TRANSPARENT) ;

          		// Display numbers

     	for (i = 1 ; i <= 5 ; i++)
     	{
          		ch = (TCHAR) (i + '0') ;
          		TextOut (hdc, i * cx / 6, cy / 2, &ch, 1) ;
     	}
          		// Clean up
     	DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
  	    DeleteObject (SelectObject (hdc, GetStockObject (BLACK_PEN))) ;
}

void CreateRoutine (HWND hwnd)
{
     	HDC          	hdcEMF ;
     	HENHMETAFILE 	hemf ;
     
	hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf11.emf"), NULL,
                                 	  TEXT ("EMF11\0EMF Demo #11\0")) ;
     	SetMapMode (hdcEMF, MM_LOENGLISH) ;
     	DrawRuler (hdcEMF, 600, 100) ;
     	hemf = CloseEnhMetaFile (hdcEMF) ;
     	DeleteEnhMetaFile (hemf) ;
}

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	ENHMETAHEADER 		emh ;
     	HENHMETAFILE  		hemf ;
     	int           		cxMms, cyMms, cxPix, cyPix, cxImage, cyImage ;
     	RECT          		rect ;
     
     	cxMms 		= GetDeviceCaps (hdc, HORZSIZE) ;
     	cyMms 		= GetDeviceCaps (hdc, VERTSIZE) ;
     	cxPix 		= GetDeviceCaps (hdc, HORZRES) ;
     	cyPix 		= GetDeviceCaps (hdc, VERTRES) ;
     
     	hemf = GetEnhMetaFile (TEXT ("emf11.emf")) ;
     	GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;
     	cxImage 	= emh.rclFrame.right - emh.rclFrame.left ;
     	cyImage 	= emh.rclFrame.bottom - emh.rclFrame.top ;
     
     	cxImage 	= cxImage * cxPix / cxMms / 100 ;
     	cyImage 	= cyImage * cyPix / cyMms / 100 ;
     
     	rect.left   		= (cxArea - cxImage) / 2 ;
     	rect.top    		= (cyArea - cyImage) / 2 ;
     	rect.right  		= (cxArea + cxImage) / 2 ;
     	rect.bottom 		= (cyArea + cyImage) / 2 ;
     
     	PlayEnhMetaFile (hdc, hemf, &rect) ;
     	DeleteEnhMetaFile (hemf) ;
}

 ï¿½ï¿½Ê½18-14  EMF12
EMF12.C
/*---------------------------------------------------------------------------
   	EMF12.C -- 	Enhanced Metafile Demo #12
              					(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

#include <windows.h>
TCHAR szClass 		[] = TEXT ("EMF12") ;
TCHAR szTitle 		[] = TEXT ("EMF12: Enhanced Metafile Demo #12") ;
void DrawRuler (HDC hdc, int cx, int cy)
{
     	int     			iAdj, i, iHeight ;
     	LOGFONT 		lf ;
     	TCHAR   			ch ;

     	iAdj = GetVersion () & 0x80000000 ? 0 : 1 ;
          			// Black pen with 1-point width
     	SelectObject (hdc, CreatePen (PS_SOLID, cx / 72 / 6, 0)) ;
          			// Rectangle surrounding entire pen (with adjustment)
     	Rectangle (hdc, iAdj, iAdj, cx + iAdj + 1, cy + iAdj + 1) ;
          			// Tick marks
     	for (i = 1 ; i < 96 ; i++)
     	{
         if (i % 16 == 0) 	iHeight = cy /  2 ;    		// inches
         else if (i %  8 == 0) 	iHeight = cy /  3 ;    	// half inches
         else if (i %  4 == 0) 	iHeight = cy /  5 ;    	// quarter inches
         else if (i %  2 == 0) 	iHeight = cy /  8 ;    	// eighths
         else iHeight = cy / 12 ;    	// sixteenths

          		MoveToEx (hdc, i * cx / 96, cy, NULL) ;
          		LineTo   (hdc, i * cx / 96, cy - iHeight) ;
     	}
          			// Create logical font 
     	FillMemory (&lf, sizeof (lf), 0) ;
     	lf.lfHeight = cy / 2 ;
     	lstrcpy (lf.lfFaceName, TEXT ("Times New Roman")) ;

     	SelectObject (hdc, CreateFontIndirect (&lf)) ;
     	SetTextAlign (hdc, TA_BOTTOM | TA_CENTER) ;
     	SetBkMode    (hdc, TRANSPARENT) ;

          			// Display numbers

     	for (i = 1 ; i <= 5 ; i++)
     {
          		ch = (TCHAR) (i + '0') ;
          		TextOut (hdc, i * cx / 6, cy / 2, &ch, 1) ;
	}
          		// Clean up
     	DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
     	DeleteObject (SelectObject (hdc, GetStockObject (BLACK_PEN))) ;
}

void CreateRoutine (HWND hwnd)
{
     	HDC          				hdcEMF ;
     	HENHMETAFILE 	hemf ;
     	int          				cxMms, cyMms, cxPix, cyPix, xDpi, yDpi ;
     
     	hdcEMF = CreateEnhMetaFile (NULL, TEXT ("emf12.emf"), NULL,
                                 	TEXT ("EMF13\0EMF Demo #12\0")) ;
     
     	cxMms = GetDeviceCaps (hdcEMF, HORZSIZE) ;
     	cyMms = GetDeviceCaps (hdcEMF, VERTSIZE) ;
     	cxPix = GetDeviceCaps (hdcEMF, HORZRES) ;
     	cyPix = GetDeviceCaps (hdcEMF, VERTRES) ;
     
     	xDpi = cxPix * 254 / cxMms / 10 ;
     	yDpi = cyPix * 254 / cyMms / 10 ;
     
     	DrawRuler (hdcEMF, 6 * xDpi, yDpi) ;
     	hemf = CloseEnhMetaFile (hdcEMF) ;
     	DeleteEnhMetaFile (hemf) ;
}

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	ENHMETAHEADER 		emh ;
     	HENHMETAFILE  		hemf ;
     	POINT         					pt ;
     	int           					cxImage, cyImage ;
     	RECT          					rect ;
     
     	SetMapMode (hdc, MM_HIMETRIC) ;
     	SetViewportOrgEx (hdc, 0, cyArea, NULL) ;
     	pt.x = cxArea ;
     	pt.y = 0 ;
     
     	DPtoLP (hdc, &pt, 1) ;
     	hemf = GetEnhMetaFile (TEXT ("emf12.emf")) ;
     	GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;
     	cxImage 	= emh.rclFrame.right - emh.rclFrame.left ;
     	cyImage 	= emh.rclFrame.bottom - emh.rclFrame.top ;
     
     	rect.left   		= (pt.x - cxImage) / 2 ;
     	rect.top    		= (pt.y + cyImage) / 2 ;
     	rect.right  		= (pt.x + cxImage) / 2 ;
     	rect.bottom 		= (pt.y - cyImage) / 2 ;
     
     	PlayEnhMetaFile (hdc, hemf, &rect) ;
     	DeleteEnhMetaFile (hemf) ;
}

 ï¿½ï¿½Ê½18-15  EMF13
EMF13.C
/*---------------------------------------------------------------------------
   	EMF13.C --	Enhanced Metafile Demo #13
              					(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
TCHAR szClass 		[] = TEXT ("EMF13") ;
TCHAR szTitle 		[] = TEXT ("EMF13: Enhanced Metafile Demo #13") ;

void CreateRoutine (HWND hwnd)
{
}

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	ENHMETAHEADER 		emh ;
     	HENHMETAFILE  		hemf ;
     	POINT         					pt ;
     	int           					cxImage, cyImage ;
     	RECT          					rect ;
     
     	SetMapMode (hdc, MM_HIMETRIC) ;
     	SetViewportOrgEx (hdc, 0, cyArea, NULL) ;
     	pt.x 	= cxArea ;
     	pt.y 	= 0 ;
     
     	DPtoLP (hdc, &pt, 1) ;
     
     	hemf = GetEnhMetaFile (TEXT ("..\\emf11\\emf11.emf")) ;
     
     	GetEnhMetaFileHeader (hemf, sizeof (emh), &emh) ;
     
     	cxImage 	= emh.rclFrame.right - emh.rclFrame.left ;
     	cyImage 	= emh.rclFrame.bottom - emh.rclFrame.top ;
     
     	rect.left   		= (pt.x - cxImage) / 2 ;
     	rect.top    		= (pt.y + cyImage) / 2 ;
     	rect.right  		= (pt.x + cxImage) / 2 ;
     	rect.bottom 		= (pt.y - cyImage) / 2 ;
     
     	PlayEnhMetaFile (hdc, hemf, &rect) ;
     	DeleteEnhMetaFile (hemf) ;
}