TextOut (hdc, xStart, yStart, pString, iCount) ;

TabbedTextOut (	hdc, xStart, yStart, pString, iCount,
               					iNumTabs, piTabStops, xTabOrigin) ;

ExtTextOut (hdc, xStart, yStart, iOptions, &rect,
               					pString, iCount, pxDistance) ;

DrawText (hdc, pString, iCount, &rect, iFormat) ;

DrawTextEx (hdc, pString, iCount, &rect, iFormat, &drawtextparams) ;

typedef struct tagDRAWTEXTPARAMS
{
   	UINT 	cbSize ;         			// size of structure
    	int  	iTabLength ;     		// size of each tab stop
    	int  	iLeftMargin ;    		// left margin
    	int  	iRightMargin ;   		// right margin
    	UINT 	uiLengthDrawn ;  		// receives number of characters processed
} DRAWTEXTPARAMS, * LPDRAWTEXTPARAMS ;

SetTextColor (hdc, rgbColor) ;

SetBkMode (hdc, iMode) ;

SetBkColor (hdc, rgbColor) ;

wndclass.hbrBackground = COLOR_WINDOW + 1 ;

SetTextColor (hdc, GetSysColor (COLOR_WINDOWTEXT)) ;
SetBkColor (hdc, GetSysColor (COLOR_WINDOW)) ;

case 	WM_SYSCOLORCHANGE :
     	InvalidateRect (hwnd, NULL, TRUE) ;
     	break ;

SetTextCharacterExtra (hdc, iExtra) ;

hFont = GetStockObject (iFont) ;

SelectObject (hdc, hFont) ;

SelectObject (hdc, GetStockObject (iFont)) ;

SetMapMode 	(hdc, MM_ANISOTROPIC) ;
SetWindowExtEx 	 (hdc, 1440, 1440, NULL) ;
SetViewportExt 	 (hdc,	GetDeviceCaps (hdc, LOGPIXELSX),
                     	GetDeviceCaps (hdc, LOGPIXELSY), NULL) ;

GetTextFace (hdc, sizeof (szFaceName) / sizeof (TCHAR), szFaceName) ;

GetTextMetrics (hdc, &textmetric) ;

 ï¿½ï¿½Ê½17-1  PICKFONT
PICKFONT.C
/*----------------------------------------------------------------------------
   	PICKFONT.C -- 		Create Logical Font
                 							(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

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

	// Structure shared between main window and dialog box
typedef struct
{
     	int        				iDevice, iMapMode ;
     	BOOL       				fMatchAspect ;
     	BOOL       				fAdvGraphics ;
     	LOGFONT    			lf ;
     	TEXTMETRIC 		tm ;
     	TCHAR      				szFaceName [LF_FULLFACESIZE] ;
}
DLGPARAMS ;
     	// Formatting for BCHAR fields of TEXTMETRIC structure
#ifdef UNICODE
#define BCHARFORM TEXT ("0x%04X")
#else
#define BCHARFORM TEXT ("0x%02X")
#endif

     	// Global variables
HWND  hdlg ;
TCHAR szAppName[] = TEXT ("PickFont") ;

     	// Forward declarations of functions
LRESULT	CALLBACK WndProc 		(HWND, UINT, WPARAM, LPARAM) ;
BOOL  		CALLBACK DlgProc 	(HWND, UINT, WPARAM, LPARAM) ;
void SetLogFontFromFields    	(HWND hdlg, DLGPARAMS * pdp) ;
void SetFieldsFromTextMetric 	(HWND hdlg, DLGPARAMS * pdp) ;
void MySetMapMode	(HDC hdc, int iMapMode) ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	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 ("PickFont: Create Logical Font"),
                          		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		CW_USEDEFAULT, CW_USEDEFAULT,
                          		NULL, NULL, hInstance, NULL) ;
     
     	ShowWindow (hwnd, iCmdShow) ;
     	UpdateWindow (hwnd) ;
     
     	while (GetMessage (&msg, NULL, 0, 0))
	{
          		if (hdlg == 0 || !IsDialogMessage (hdlg, &msg))
          		{
               				TranslateMessage (&msg) ;
               				DispatchMessage (&msg) ;
          		}
     	}
     	return msg.wParam ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static DLGPARAMS dp ;
     	static TCHAR     		szText[] = 	TEXT ("\x41\x42\x43\x44\x45 ")
                        TEXT ("\x61\x62\x63\x64\x65 ")

                        TEXT ("\xC0\xC1\xC2\xC3\xC4\xC5 ")
                        TEXT ("\xE0\xE1\xE2\xE3\xE4\xE5 ") 
#ifdef UNICODE
                        TEXT ("\x0390\x0391\x0392\x0393\x0394\x0395 ")
                        TEXT ("\x03B0\x03B1\x03B2\x03B3\x03B4\x03B5 ")
                        TEXT ("\x0410\x0411\x0412\x0413\x0414\x0415 ")
                        TEXT ("\x0430\x0431\x0432\x0433\x0434\x0435 ")
                        TEXT ("\x5000\x5001\x5002\x5003\x5004") 
#endif
                                 ;
     	HDC              						hdc ;
     	PAINTSTRUCT      				ps ;
     	RECT             						rect ;
     
     	switch (message)
     	{
     	case WM_CREATE:
          			dp.iDevice = IDM_DEVICE_SCREEN ;
          			hdlg = CreateDialogParam (((LPCREATESTRUCT) lParam)->hInstance, 
                szAppName, hwnd, DlgProc, (LPARAM) &dp) ;
          			return 0 ;
     	case 	WM_SETFOCUS:
          			SetFocus (hdlg) ;
          			return 0 ;

     	case 	WM_COMMAND:
			switch (LOWORD (wParam))
          			{
          			case 	IDM_DEVICE_SCREEN:
          			case 	IDM_DEVICE_PRINTER:
               			CheckMenuItem (GetMenu (hwnd), dp.iDevice, MF_UNCHECKED) ;
               			dp.iDevice = LOWORD (wParam) ;
               			CheckMenuItem (GetMenu (hwnd), dp.iDevice, MF_CHECKED) ;
               			SendMessage (hwnd, WM_COMMAND, IDOK, 0) ;
               			return 0 ;
          			}
          			break ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

               				// Set graphics mode so escapement works in Windows NT

          SetGraphicsMode (hdc, dp.fAdvGraphics ? GM_ADVANCED : GM_COMPATIBLE) ;

               				// Set the mapping mode and the mapper flag

          			MySetMapMode (hdc, dp.iMapMode) ;
          			SetMapperFlags (hdc, dp.fMatchAspect) ;

               				// Find the point to begin drawing text

          			GetClientRect (hdlg, &rect) ;
          			rect.bottom += 1 ;
          			DPtoLP (hdc, (PPOINT) &rect, 2) ;

               				// Create and select the font; display the text

          		SelectObject (hdc, CreateFontIndirect (&dp.lf)) ;
          		TextOut (hdc, rect.left, rect.bottom, szText, lstrlen (szText)) ;

          		DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
          		EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

BOOL CALLBACK DlgProc (	HWND hdlg, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static DLGPARAMS 		* 	pdp ;
     	static PRINTDLG    			pd = { sizeof (PRINTDLG) } ;
     	HDC                							hdcDevice ;
     	HFONT        							hFont ;
     
	switch (message)
     	{
     	case 	WM_INITDIALOG:
               		// Save pointer to dialog-parameters structure in WndProc

          			pdp = (DLGPARAMS *) lParam ;

          			SendDlgItemMessage (hdlg, 	IDC_LF_FACENAME, EM_LIMITTEXT, 
LF_FACESIZE - 1, 0) ;
         CheckRadioButton (hdlg,IDC_OUT_DEFAULT, IDC_OUT_OUTLINE,
                                  		  IDC_OUT_DEFAULT) ;
         CheckRadioButton (hdlg,IDC_DEFAULT_QUALITY, IDC_PROOF_QUALITY,
                                  	      IDC_DEFAULT_QUALITY) ;
         CheckRadioButton (hdlg,IDC_DEFAULT_PITCH, IDC_VARIABLE_PITCH,
                                  		  IDC_DEFAULT_PITCH) ;
         CheckRadioButton (hdlg,IDC_FF_DONTCARE, IDC_FF_DECORATIVE,
                                  		  IDC_FF_DONTCARE) ;
         CheckRadioButton (hdlg,IDC_MM_TEXT, IDC_MM_LOGTWIPS,
                                  		  IDC_MM_TEXT) ;
           SendMessage (hdlg, WM_COMMAND, IDOK, 0) ;
										// fall through
        	case 	WM_SETFOCUS:
          			SetFocus (GetDlgItem (hdlg, IDC_LF_HEIGHT)) ;
          			return FALSE ;

     	   case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDC_CHARSET_HELP:
           					MessageBox (	hdlg, 
                    TEXT	("0 		= 	Ansi\n")
                    TEXT	("1 		= 	Default\n")
                    TEXT	("2 		= 	Symbol\n")
                    TEXT 	("128 	= 	Shift JIS (Japanese)\n")
                    TEXT 	("129 	= 	Hangul (Korean)\n")
                    TEXT 	("130 	= 	Johab (Korean)\n")
                    TEXT 	("134 	= 	GB 2312 (Simplified Chinese)\n")
                    TEXT 	("136 	= 	Chinese Big 5 (Traditional Chinese)\n")
                    TEXT 	("177 	= 	Hebrew\n")
                    TEXT 	("178 	= 	Arabic\n")
                    TEXT 	("161 	= 	Greek\n")
                    TEXT 	("162 	= 	Turkish\n")
                    TEXT 	("163 	= 	Vietnamese\n")
                    TEXT 	("204 	= 	Russian\n")
                    TEXT 	("222 	= 	Thai\n")
                    TEXT 	("238 	= 	East European\n")
                    TEXT 	("255 	= 	OEM"),
                      szAppName, MB_OK | MB_ICONINFORMATION) ;
               					return TRUE ;

               					// These radio buttons set the lfOutPrecision field

          			case 	IDC_OUT_DEFAULT:   
               					pdp->lf.lfOutPrecision = OUT_DEFAULT_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_STRING:
               					pdp->lf.lfOutPrecision = OUT_STRING_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_CHARACTER:
               					pdp->lf.lfOutPrecision = OUT_CHARACTER_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_STROKE:
               					pdp->lf.lfOutPrecision = OUT_STROKE_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_TT:
               					pdp->lf.lfOutPrecision = OUT_TT_PRECIS ;  
               					return TRUE ;

          			case	IDC_OUT_DEVICE:
               					pdp->lf.lfOutPrecision = OUT_DEVICE_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_RASTER:
               					pdp->lf.lfOutPrecision = OUT_RASTER_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_TT_ONLY:
               					pdp->lf.lfOutPrecision = OUT_TT_ONLY_PRECIS ;  
               					return TRUE ;

          			case 	IDC_OUT_OUTLINE:
               					pdp->lf.lfOutPrecision = OUT_OUTLINE_PRECIS ;  
               					return TRUE ;

               				// These three radio buttons set the lfQuality field

          			case 	IDC_DEFAULT_QUALITY:
               					pdp->lf.lfQuality = DEFAULT_QUALITY ;   
               					return TRUE ;

          			case 	IDC_DRAFT_QUALITY:
              	 				pdp->lf.lfQuality = DRAFT_QUALITY ;  
               					return TRUE ;

          			case 	IDC_PROOF_QUALITY:
               					pdp->lf.lfQuality = PROOF_QUALITY ;  
               					return TRUE ;

               				// These three radio buttons set the lower nibble
               				//   of the lfPitchAndFamily field

          			case 	IDC_DEFAULT_PITCH:
               					pdp->lf.lfPitchAndFamily = 
                    (0xF0 & pdp->lf.lfPitchAndFamily) | DEFAULT_PITCH ; 
               					return TRUE ;

          			case 	IDC_FIXED_PITCH:
               					pdp->lf.lfPitchAndFamily = 
                    (0xF0 & pdp->lf.lfPitchAndFamily) | FIXED_PITCH ; 
               					return TRUE ;

          			case 	IDC_VARIABLE_PITCH:
               					pdp->lf.lfPitchAndFamily = 
                    (0xF0 & pdp->lf.lfPitchAndFamily) | VARIABLE_PITCH ;  
               					return TRUE ;

               					// These six radio buttons set the upper nibble
               					//   of the lfPitchAndFamily field

          			case 	IDC_FF_DONTCARE:
               					pdp->lf.lfPitchAndFamily =
                     (0x0F & pdp->lf.lfPitchAndFamily) | FF_DONTCARE ;  
               					return TRUE ;

          			case 	IDC_FF_ROMAN:
               					pdp->lf.lfPitchAndFamily =
                     (0x0F & pdp->lf.lfPitchAndFamily) | FF_ROMAN ;  
               					return TRUE ;

          			case 	IDC_FF_SWISS:
               					pdp->lf.lfPitchAndFamily =
                    (0x0F & pdp->lf.lfPitchAndFamily) | FF_SWISS ;  
               					return TRUE ;

          			case 	IDC_FF_MODERN:
               					pdp->lf.lfPitchAndFamily =
                    (0x0F & pdp->lf.lfPitchAndFamily) | FF_MODERN ;  
               					return TRUE ;

          			case 	IDC_FF_SCRIPT:
               					pdp->lf.lfPitchAndFamily =
                    (0x0F & pdp->lf.lfPitchAndFamily) | FF_SCRIPT ;  
               					return TRUE ;

          			case 	IDC_FF_DECORATIVE:
               					pdp->lf.lfPitchAndFamily =
                    (0x0F & pdp->lf.lfPitchAndFamily) | FF_DECORATIVE ;  
               					return TRUE ;

               					// Mapping mode:

          			case 	IDC_MM_TEXT:
          			case 	IDC_MM_LOMETRIC:
          			case 	IDC_MM_HIMETRIC:
          			case 	IDC_MM_LOENGLISH:
          			case 	IDC_MM_HIENGLISH:
          			case 	IDC_MM_TWIPS:
          			case 	IDC_MM_LOGTWIPS:
               					pdp->iMapMode = LOWORD (wParam) ;
               					return TRUE ;

               					// OK button pressed
               					// -----------------

          			case 	IDOK:
                    						// Get LOGFONT structure

               					SetLogFontFromFields (hdlg, pdp) ;

                    	// Set Match-Aspect and Advanced Graphics flags

			pdp->fMatchAspect = IsDlgButtonChecked 	(hdlg,	IDC_MATCH_ASPECT) ;
			pdp->fAdvGraphics = IsDlgButtonChecked 	(hdlg,	IDC_ADV_GRAPHICS) ;

				// Get Information Context

			if (pdp->iDevice == IDM_DEVICE_SCREEN)
			{
				hdcDevice = CreateIC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;
			}
               			else
              	 		{
                    				pd.hwndOwner = hdlg ;
                    				pd.Flags = PD_RETURNDEFAULT | PD_RETURNIC ;
                    				pd.hDevNames = NULL ;
                    				pd.hDevMode = NULL ;

                    				PrintDlg (&pd) ;

                    				hdcDevice = pd.hDC ;
         			}
                   				// Set the mapping mode and the mapper flag

               			MySetMapMode (hdcDevice, pdp->iMapMode) ;
			SetMapperFlags (hdcDevice, pdp->fMatchAspect) ;

                    				// Create font and select it into IC

               			hFont = CreateFontIndirect (&pdp->lf) ;
               			SelectObject (hdcDevice, hFont) ;

                    				// Get the text metrics and face name

               			GetTextMetrics (hdcDevice, &pdp->tm) ;
               			GetTextFace (hdcDevice, LF_FULLFACESIZE, pdp->szFaceName) ;
			DeleteDC (hdcDevice) ;
               			DeleteObject (hFont) ;

                    			// Update dialog fields and invalidate main window

               			SetFieldsFromTextMetric (hdlg, pdp) ;
               			InvalidateRect (GetParent (hdlg), NULL, TRUE) ;
               			return TRUE ;
          		}
          		break ;
     	}
  	return FALSE ;
}
void SetLogFontFromFields (HWND hdlg, DLGPARAMS * pdp)
{
     	pdp->lf.lfHeight  = 	GetDlgItemInt (hdlg, IDC_LF_HEIGHT,  NULL, TRUE) ;
     	pdp->lf.lfWidth   = 	GetDlgItemInt (hdlg, IDC_LF_WIDTH,  NULL, TRUE) ;
     	pdp->lf.lfEscapement=GetDlgItemInt (hdlg, IDC_LF_ESCAPE, NULL, TRUE) ;
     	pdp->lf.lfOrientation=GetDlgItemInt (hdlg,IDC_LF_ORIENT,	NULL, TRUE) ;
     	pdp->lf.lfWeight  =GetDlgItemInt (hdlg, IDC_LF_WEIGHT, NULL, TRUE) ;
     	pdp->lf.lfCharSet =GetDlgItemInt (hdlg, IDC_LF_CHARSET, NULL, FALSE) ;
     	pdp->lf.lfItalic    =IsDlgButtonChecked(hdlg,IDC_LF_ITALIC) == BST_CHECKED ;
     	pdp->lf.lfUnderline =IsDlgButtonChecked (hdlg, IDC_LF_UNDER)  == BST_CHECKED ;
     	pdp->lf.lfStrikeOut =IsDlgButtonChecked (hdlg, IDC_LF_STRIKE) == BST_CHECKED ;
     	GetDlgItemText (hdlg, IDC_LF_FACENAME, pdp->lf.lfFaceName, LF_FACESIZE) ;
}

void SetFieldsFromTextMetric (HWND hdlg, DLGPARAMS * pdp) 
{
     	TCHAR   		szBuffer [10] ;
     	TCHAR * 		szYes 	= TEXT ("Yes") ; 
     	TCHAR * 		szNo	= TEXT ("No") ;
     	TCHAR * 		szFamily [] = {	TEXT ("Don't Know"),	
TEXT ("Roman"),
                        TEXT ("Swiss"), TEXT ("Modern"),
                        TEXT ("Script"), TEXT ("Decorative"), 
                        TEXT ("Undefined") } ;

     	SetDlgItemInt (hdlg, IDC_TM_HEIGHT, pdp->tm.tmHeight,  	TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_ASCENT, pdp->tm.tmAscent,    TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_DESCENT,pdp->tm.tmDescent, 	TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_INTLEAD,pdp->tm.tmInternalLeading,  		 TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_EXTLEAD,pdp->tm.tmExternalLeading,  	 TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_AVECHAR,pdp->tm.tmAveCharWidth,     			    TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_MAXCHAR,  	pdp->tm.tmMaxCharWidth,     			TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_WEIGHT,   	pdp->tm.tmWeight,           			TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_OVERHANG,	pdp->tm.tmOverhang,         			TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_DIGASPX,  	pdp->tm.tmDigitizedAspectX, 		    TRUE) ;
     	SetDlgItemInt (hdlg, IDC_TM_DIGASPY,  	pdp->tm.tmDigitizedAspectY, 		    TRUE) ;

     	wsprintf (szBuffer, BCHARFORM, pdp->tm.tmFirstChar) ;
     	SetDlgItemText (hdlg, IDC_TM_FIRSTCHAR, szBuffer) ;

     	wsprintf (szBuffer, BCHARFORM, pdp->tm.tmLastChar) ;
     	SetDlgItemText (hdlg, IDC_TM_LASTCHAR, szBuffer) ;

     	wsprintf (szBuffer, BCHARFORM, pdp->tm.tmDefaultChar) ;
     	SetDlgItemText (hdlg, IDC_TM_DEFCHAR, szBuffer) ;

     	wsprintf (szBuffer, BCHARFORM, pdp->tm.tmBreakChar) ;
     	SetDlgItemText (hdlg, IDC_TM_BREAKCHAR, szBuffer) ;

     	SetDlgItemText (hdlg, IDC_TM_ITALIC, 	pdp->tm.tmItalic 			? szYes : szNo) ;
     	SetDlgItemText (hdlg, IDC_TM_UNDER, 	 	pdp->tm.tmUnderlined	? szYes : szNo) ;
     	SetDlgItemText (hdlg, IDC_TM_STRUCK, 	pdp->tm.tmStruckOut		? szYes : szNo) ;

     	SetDlgItem	Text (hdlg, IDC_TM_VARIABLE, 
               					TMPF_FIXED_PITCH & pdp->tm.tmPitchAndFamily ? szYes : szNo) ;

     	SetDlgItem	Text (hdlg, IDC_TM_VECTOR, 
               					TMPF_VECTOR & pdp->tm.tmPitchAndFamily ? szYes : szNo) ;

     	SetDlgItem	Text (hdlg, IDC_TM_TRUETYPE, 
               					TMPF_TRUETYPE & pdp->tm.tmPitchAndFamily ? szYes : szNo) ;

     	SetDlgItem	Text (hdlg, IDC_TM_DEVICE, 
               					TMPF_DEVICE & pdp->tm.tmPitchAndFamily ? szYes : szNo) ;

     	SetDlgItem	Text (hdlg, IDC_TM_FAMILY, 
               					szFamily [min (6, pdp->tm.tmPitchAndFamily >> 4)]) ;

     	SetDlgItemInt	(hdlg, IDC_TM_CHARSET,   	pdp->tm.tmCharSet, FALSE) ;
     	SetDlgItemText	(hdlg, IDC_TM_FACENAME, pdp->szFaceName) ;
}

void MySetMapMode (HDC hdc, int iMapMode)
{
     	switch (iMapMode)
     	{
     	case 	IDC_MM_TEXT:       	SetMapMode (hdc, MM_TEXT) ;       	break ;
     	case 	IDC_MM_LOMETRIC:	SetMapMode (hdc, MM_LOMETRIC) ;   	break ;
     	case 	IDC_MM_HIMETRIC:	SetMapMode (hdc, MM_HIMETRIC) ;   	break ;
     	case 	IDC_MM_LOENGLISH: 	SetMapMode (hdc, MM_LOENGLISH) ;  	break ;
     	case 	IDC_MM_HIENGLISH:  	SetMapMode (hdc, MM_HIENGLISH) ;  	break ;
     	case 	IDC_MM_TWIPS:      	SetMapMode (hdc, MM_TWIPS) ;      			break ;
     	case 	IDC_MM_LOGTWIPS:
          			SetMapMode (hdc, MM_ANISOTROPIC) ;
          			SetWindowExtEx (hdc, 1440, 1440, NULL) ;
          			SetViewportExtEx (hdc,	GetDeviceCaps (hdc, LOGPIXELSX),
                    GetDeviceCaps (hdc, LOGPIXELSY), NULL) ;
          			break ;
     	}
}

 PICKFONT.RC
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Dialog
PICKFONT DIALOG DISCARDABLE  0, 0, 348, 308
STYLE WS_CHILD | WS_VISIBLE | WS_BORDER
FONT 8, "MS Sans Serif"
BEGIN
    	LTEXT           			"&Height:",IDC_STATIC,8,10,44,8
    	EDITTEXT        		IDC_LF_HEIGHT,64,8,24,12,ES_AUTOHSCROLL
    	LTEXT           				"&Width",IDC_STATIC,8,26,44,8
    	EDITTEXT        			IDC_LF_WIDTH,64,24,24,12,ES_AUTOHSCROLL
    	LTEXT           				"Escapement:",IDC_STATIC,8,42,44,8
    	EDITTEXT        			IDC_LF_ESCAPE,64,40,24,12,ES_AUTOHSCROLL
    	LTEXT           				"Orientation:",IDC_STATIC,8,58,44,8
    	EDITTEXT        			IDC_LF_ORIENT,64,56,24,12,ES_AUTOHSCROLL
    	LTEXT           				"Weight:",IDC_STATIC,8,74,44,8
    	EDITTEXT        			IDC_LF_WEIGHT,64,74,24,12,ES_AUTOHSCROLL
    	GROUPBOX        			"Mapping Mode",IDC_STATIC,97,3,96,90,WS_GROUP
    	CONTROL 			"Text",IDC_MM_TEXT,"Button",BS_AUTORADIOBUTTON,104,13,56,
             						8
    	CONTROL         			"Low Metric",IDC_MM_LOMETRIC,"Button",BS_AUTORADIOBUTTON,
                    						104,24,56,8
    	CONTROL 			High Metric",IDC_MM_HIMETRIC,"Button",
                    						BS_AUTORADIOBUTTON,104,35,56,8
    	CONTROL         			"Low English",IDC_MM_LOENGLISH,"Button",
                    						BS_AUTORADIOBUTTON,104,46,56,8
    	CONTROL        	"		High English",IDC_MM_HIENGLISH,"Button",
                    						BS_AUTORADIOBUTTON,104,57,56,8
    	CONTROL  			"Twips",IDC_MM_TWIPS,"Button",BS_AUTORADIOBUTTON,104,68,
                    						56,8
    	CONTROL         			"Logical Twips",IDC_MM_LOGTWIPS,"Button",
                    						BS_AUTORADIOBUTTON,104,79,64,8
    	CONTROL 			"Italic",IDC_LF_ITALIC,"Button",BS_AUTOCHECKBOX | 
                    						WS_TABSTOP,8,90,48,12
    	CONTROL			"Underline",IDC_LF_UNDER,"Button",BS_AUTOCHECKBOX | 
                    						WS_TABSTOP,8,104,48,12
    	CONTROL         			"Strike Out",IDC_LF_STRIKE,"Button",BS_AUTOCHECKBOX | 
                    						WS_TABSTOP,8,118,48,12
    	CONTROL         			"Match Aspect",IDC_MATCH_ASPECT,"Button",BS_AUTOCHECKBOX | 
                    						WS_TABSTOP,60,104,62,8
    	CONTROL         			"Adv Grfx Mode",IDC_ADV_GRAPHICS,"Button",
                    						BS_AUTOCHECKBOX | WS_TABSTOP,60,118,62,8
    	LTEXT           				"Character Set:",IDC_STATIC,8,137,46,8
    	EDITTEXT        			IDC_LF_CHARSET,58,135,24,12,ES_AUTOHSCROLL
    	PUSHBUTTON  		"?",IDC_CHARSET_HELP,90,135,14,14
    	GROUPBOX        			"Quality",IDC_STATIC,132,98,62,48,WS_GROUP
    	CONTROL         			"Default",IDC_DEFAULT_QUALITY,"Button",
                    						BS_AUTORADIOBUTTON,136,110,40,8
    	CONTROL 			"Draft",IDC_DRAFT_QUALITY,"Button",BS_AUTORADIOBUTTON,
                    						136,122,40,8
    	CONTROL 			"Proof",IDC_PROOF_QUALITY,"Button",BS_AUTORADIOBUTTON,
                    						136,134,40,8
    	LTEXT           				"Face Name:",IDC_STATIC,8,154,44,8
    	EDITTEXT        			IDC_LF_FACENAME,58,152,136,12,ES_AUTOHSCROLL
    	GROUPBOX        			"Output Precision",IDC_STATIC,8,166,118,133,WS_GROUP
    	CONTROL         			"OUT_DEFAULT_PRECIS",IDC_OUT_DEFAULT,"Button",
                    						BS_AUTORADIOBUTTON,12,178,112,8
    	CONTROL         			"OUT_STRING_PRECIS",IDC_OUT_STRING,"Button",
                    						BS_AUTORADIOBUTTON,12,191,112,8
    	CONTROL  			"OUT_CHARACTER_PRECIS",IDC_OUT_CHARACTER,"Button",
                    						BS_AUTORADIOBUTTON,12,204,112,8
    	CONTROL         			"OUT_STROKE_PRECIS",IDC_OUT_STROKE,"Button",
                    						BS_AUTORADIOBUTTON,12,217,112,8
    	CONTROL 			"OUT_TT_PRECIS",IDC_OUT_TT,"Button",BS_AUTORADIOBUTTON,
                    						12,230,112,8
    	CONTROL         			"OUT_DEVICE_PRECIS",IDC_OUT_DEVICE,"Button",
                    						BS_AUTORADIOBUTTON,12,243,112,8
    	CONTROL        			"OUT_RASTER_PRECIS",IDC_OUT_RASTER,"Button",
                    						BS_AUTORADIOBUTTON,12,256,112,8
    	CONTROL         			"OUT_TT_ONLY_PRECIS",IDC_OUT_TT_ONLY,"Button",
                    						BS_AUTORADIOBUTTON,12,269,112,8
    	CONTROL         			"OUT_OUTLINE_PRECIS",IDC_OUT_OUTLINE,"Button",
                    						BS_AUTORADIOBUTTON,12,282,112,8
    	GROUPBOX        			"Pitch",IDC_STATIC,132,166,62,50,WS_GROUP
    	CONTROL  			"Default",IDC_DEFAULT_PITCH,"Button",BS_AUTORADIOBUTTON,
                    						137,176,52,8
    	CONTROL 			"Fixed",IDC_FIXED_PITCH,"Button",BS_AUTORADIOBUTTON,137,
                    						189,52,8
    	CONTROL         			"Variable",IDC_VARIABLE_PITCH,"Button",
                    						BS_AUTORADIOBUTTON,137,203,52,8
    	GROUPBOX        			"Family",IDC_STATIC,132,218,62,82,WS_GROUP
    	CONTROL       	  		"Don't Care",IDC_FF_DONTCARE,"Button",BS_AUTORADIOBUTTON,
                    						137,229,52,8
    	CONTROL 			"Roman",IDC_FF_ROMAN,"Button",BS_AUTORADIOBUTTON,137,241,
                    						52,8
    	CONTROL  			"Swiss",IDC_FF_SWISS,"Button",BS_AUTORADIOBUTTON,137,253,
                    						52,8
    	CONTROL  				"Modern",IDC_FF_MODERN,"Button",BS_AUTORADIOBUTTON,137,
                    							265,52,8
    	CONTROL				"Script",IDC_FF_SCRIPT,"Button",BS_AUTORADIOBUTTON,137,
                    							277,52,8
    	CONTROL         				"Decorative",IDC_FF_DECORATIVE,"Button",
                    							BS_AUTORADIOBUTTON,137,289,52,8
    	DEFPUSHBUTTON  		"OK",IDOK,247,286,50,14
    	GROUPBOX        				"Text Metrics",IDC_STATIC,201,2,140,272,WS_GROUP
    	LTEXT           					"Height:",IDC_STATIC,207,12,64,8
    	LTEXT           					"0",IDC_TM_HEIGHT,281,12,44,8
    	LTEXT           					"Ascent:",IDC_STATIC,207,22,64,8
    	LTEXT           					"0",IDC_TM_ASCENT,281,22,44,8
    	LTEXT           					"Descent:",IDC_STATIC,207,32,64,8
    	LTEXT           					"0",IDC_TM_DESCENT,281,32,44,8
    	LTEXT           					"Internal Leading:",IDC_STATIC,207,42,64,8
    	LTEXT           					"0",IDC_TM_INTLEAD,281,42,44,8
    	LTEXT           					"External Leading:",IDC_STATIC,207,52,64,8
    	LTEXT           					"0",IDC_TM_EXTLEAD,281,52,44,8
    	LTEXT           					"Ave Char Width:",IDC_STATIC,207,62,64,8
    	LTEXT          	 				"0",IDC_TM_AVECHAR,281,62,44,8
    	LTEXT           					"Max Char Width:",IDC_STATIC,207,72,64,8
    	LTEXT           					"0",IDC_TM_MAXCHAR,281,72,44,8
    	LTEXT           					"Weight:",IDC_STATIC,207,82,64,8
    	LTEXT           					"0",IDC_TM_WEIGHT,281,82,44,8
    	LTEXT           					"Overhang:",IDC_STATIC,207,92,64,8
    	LTEXT           					"0",IDC_TM_OVERHANG,281,92,44,8
    	LTEXT           					"Digitized Aspect X:",IDC_STATIC,207,102,64,8
    	LTEXT           					"0",IDC_TM_DIGASPX,281,102,44,8
    	LTEXT           					"Digitized Aspect Y:",IDC_STATIC,207,112,64,8
    	LTEXT           					"0",IDC_TM_DIGASPY,281,112,44,8
    	LTEXT          		 			"First Char:",IDC_STATIC,207,122,64,8
    	LTEXT           					"0",IDC_TM_FIRSTCHAR,281,122,44,8
    	LTEXT           					"Last Char:",IDC_STATIC,207,132,64,8
    	LTEXT           					"0",IDC_TM_LASTCHAR,281,132,44,8
    	LTEXT           					"Default Char:",IDC_STATIC,207,142,64,8
    	LTEXT           					"0",IDC_TM_DEFCHAR,281,142,44,8
    	LTEXT           					"Break Char:",IDC_STATIC,207,152,64,8
    	LTEXT           					"0",IDC_TM_BREAKCHAR,281,152,44,8
    	LTEXT           					"Italic?",IDC_STATIC,207,162,64,8
    	LTEXT           				"0",IDC_TM_ITALIC,281,162,44,8
    	LTEXT           				"Underlined?",IDC_STATIC,207,172,64,8
    	LTEXT           				"0",IDC_TM_UNDER,281,172,44,8
    	LTEXT           				"Struck Out?",IDC_STATIC,207,182,64,8
    	LTEXT           				"0",IDC_TM_STRUCK,281,182,44,8
    	LTEXT           				"Variable Pitch?",IDC_STATIC,207,192,64,8
    	LTEXT           				"0",IDC_TM_VARIABLE,281,192,44,8
    	LTEXT           				"Vector Font?",IDC_STATIC,207,202,64,8
    	LTEXT           				"0",IDC_TM_VECTOR,281,202,44,8
    	LTEXT           				"TrueType Font?",IDC_STATIC,207,212,64,8
    	LTEXT           				"0",IDC_TM_TRUETYPE,281,212,44,8
    	LTEXT           				"Device Font?",IDC_STATIC,207,222,64,8
    	LTEXT           				"0",IDC_TM_DEVICE,281,222,44,8
    	LTEXT           				"Family:",IDC_STATIC,207,232,64,8
    	LTEXT           				"0",IDC_TM_FAMILY,281,232,44,8
    	LTEXT           				"Character Set:",IDC_STATIC,207,242,64,8
    	LTEXT           				"0",IDC_TM_CHARSET,281,242,44,8
    	LTEXT           				"0",IDC_TM_FACENAME,207,262,128,8
END

/////////////////////////////////////////////////////////////////////////////
// Menu
PICKFONT MENU DISCARDABLE 
BEGIN
  	POPUP "&Device"
    	BEGIN
        MENUITEM "&Screen",			IDM_DEVICE_SCREEN, CHECKED
        MENUITEM "&Printer",  			IDM_DEVICE_PRINTER
    	END
END

 RESOURCE.H
// Microsoft Developer Studio generated include file.
// Used by PickFont.rc

#define 		IDC_LF_HEIGHT      1000
#define 		IDC_LF_WIDTH       1001
#define 		IDC_LF_ESCAPE      1002
#define 		IDC_LF_ORIENT      1003
#define 		IDC_LF_WEIGHT      1004
#define 		IDC_MM_TEXT        1005
#define 		IDC_MM_LOMETRIC    1006
#define 		IDC_MM_HIMETRIC    1007
#define 		IDC_MM_LOENGLISH   1008
#define 		IDC_MM_HIENGLISH   1009
#define 		IDC_MM_TWIPS       1010
#define 		IDC_MM_LOGTWIPS    1011
#define 		IDC_LF_ITALIC      1012
#define 		IDC_LF_UNDER       1013
#define 		IDC_LF_STRIKE      1014
#define 		IDC_MATCH_ASPECT   1015
#define 		IDC_ADV_GRAPHICS   1016
#define 		IDC_LF_CHARSET     1017
#define 		IDC_CHARSET_HELP   1018
#define 		IDC_DEFAULT_QUALITY     1019
#define 		IDC_DRAFT_QUALITY       1020
#define 		IDC_PROOF_QUALITY       1021
#define 		IDC_LF_FACENAME         1022
#define 		IDC_OUT_DEFAULT         1023
#define 		IDC_OUT_STRING          1024
#define 		IDC_OUT_CHARACTER       1025
#define 		IDC_OUT_STROKE          1026
#define 		IDC_OUT_TT              1027
#define 		IDC_OUT_DEVICE          1028
#define 		IDC_OUT_RASTER          1029
#define 		IDC_OUT_TT_ONLY         1030
#define 		IDC_OUT_OUTLINE         1031
#define 		IDC_DEFAULT_PITCH       1032
#define 		IDC_FIXED_PITCH         1033
#define 		IDC_VARIABLE_PITCH      1034
#define 		IDC_FF_DONTCARE         1035
#define 		IDC_FF_ROMAN            1036
#define 		IDC_FF_SWISS            1037
#define 		IDC_FF_MODERN           1038
#define 		IDC_FF_SCRIPT           1039
#define 		IDC_FF_DECORATIVE       1040
#define 		IDC_TM_HEIGHT           1041
#define 		IDC_TM_ASCENT           1042
#define 		IDC_TM_DESCENT          1043
#define 		IDC_TM_INTLEAD          1044
#define 		IDC_TM_EXTLEAD          1045
#define 		IDC_TM_AVECHAR          1046
#define 		IDC_TM_MAXCHAR          1047
#define 		IDC_TM_WEIGHT           1048
#define 		IDC_TM_OVERHANG         1049
#define 		IDC_TM_DIGASPX          1050
#define 		IDC_TM_DIGASPY          1051
#define 		IDC_TM_FIRSTCHAR        1052
#define 		IDC_TM_LASTCHAR         1053
#define 		IDC_TM_DEFCHAR          1054
#define 		IDC_TM_BREAKCHAR        1055
#define 		IDC_TM_ITALIC           1056
#define 		IDC_TM_UNDER            1057
#define 		IDC_TM_STRUCK           1058
#define 		IDC_TM_VARIABLE         1059
#define 		IDC_TM_VECTOR           1060
#define 		IDC_TM_TRUETYPE         1061
#define 		IDC_TM_DEVICE           1062
#define 		IDC_TM_FAMILY           1063
#define 		IDC_TM_CHARSET          1064
#define 		IDC_TM_FACENAME         1065
#define 		IDM_DEVICE_SCREEN       40001
#define 		IDM_DEVICE_PRINTER      40002

LOGFONT lf ;

hFont = CreatFontIndirect (&lf) ;

#define 		ANSI_CHARSET            			0
#define 		DEFAULT_CHARSET         			1
#define 		SYMBOL_CHARSET          			2
#define 		MAC_CHARSET             			77
#define 		SHIFTJIS_CHARSET        			128
#define 		HANGEUL_CHARSET         			129
#define 		HANGUL_CHARSET          			129	
#define 		JOHAB_CHARSET           			130
#define 		GB2312_CHARSET          			134
#define 		CHINESEBIG5_CHARSET     			136
#define 		GREEK_CHARSET           			161
#define 		TURKISH_CHARSET         			162
#define 		VIETNAMESE_CHARSET      			163
#define 		HEBREW_CHARSET          			177
#define 		ARABIC_CHARSET          			178
#define 		BALTIC_CHARSET          			186
#define 		RUSSIAN_CHARSET         			204
#define 		THAI_CHARSET            			222
#define 		EASTEUROPE_CHARSET      			238
#define 		OEM_CHARSET             			255

EnumFonts (hdc, szTypeFace, EnumProc, pData) ;

EnumFontFamilies (hdc, szFaceName, EnumProc, pData) ;

EnumFontFamiliesEx (hdc, &logfont, EnumProc, pData, dwFlags) ;

 ï¿½ï¿½Ê½17-5  CHOSFONT
CHOSFONT.C
/*-----------------------------------------------------------------------------
   	CHOSFONT.C -- 	ChooseFont Demo
                 						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

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

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
	static TCHAR 	szAppName[] = TEXT ("ChosFont") ;
     	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 ("ChooseFont"),
                          	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 CHOOSEFONT 		cf ;
     	static int        		cyChar ;
     	static LOGFONT    		if ;
     	static TCHAR  szText[] = TEXT ("\x41\x42\x43\x44\x45 ")
                                 TEXT ("\x61\x62\x63\x64\x65 ")
                                 TEXT ("\xC0\xC1\xC2\xC3\xC4\xC5 ")
                                 TEXT ("\xE0\xE1\xE2\xE3\xE4\xE5 ") 
#ifdef UNICODE
       TEXT ("\x0390\x0391\x0392\x0393\x0394\x0395 ")
       TEXT ("\x03B0\x03B1\x03B2\x03B3\x03B4\x03B5 ")
     TEXT ("\x0410\x0411\x0412\x0413\x0414\x0415 ")
       TEXT ("\x0430\x0431\x0432\x0433\x0434\x0435 ")
       TEXT ("\x5000\x5001\x5002\x5003\x5004") 
#endif
                                 		;
     	HDC               				hdc ;
     	int               				y ;
     	PAINTSTRUCT       				ps ;
     	TCHAR             				szBuffer [64] ;
     	TEXTMETRIC        				tm ;
     
     	switch (message)
     	{
     	case WM_CREATE:
               				// Get text height
        			cyChar = HIWORD (GetDialogBaseUnits ()) ;
               				// Initialize the LOGFONT structure
          			GetObject (GetStockObject (SYSTEM_FONT), sizeof (lf), &lf) ;
               				// Initialize the CHOOSEFONT structure
			cf.lStructSize    			= sizeof (CHOOSEFONT) ;
          			cf.hwndOwner     	= hwnd ;
          			cf.hDC            	= NULL ;
          			cf.lpLogFont      	= &lf ;
          			cf.iPointSize    	= 0 ;
          			cf.Flags         	= CF_INITTOLOGFONTSTRUCT |
                              			  CF_SCREENFONTS | CF_EFFECTS ;
          			cf.rgbColors      	= 0 ;
          			cf.lCustData      	= 0 ;
          			cf.lpfnHook       	= NULL ;
          			cf.lpTemplateName 	= NULL ;
          			cf.hInstance      	= NULL ;
          			cf.lpszStyle      	= NULL ;
          			cf.nFontType      	= 0 ;      
          			cf.nSizeMin       	= 0 ;
          			cf.nSizeMax       	= 0 ;
          			return 0 ;

     	case	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FONT:
               					if (ChooseFont (&cf))
                    			InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
          			}
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

               					// Display sample text using selected font

          			SelectObject (hdc, CreateFontIndirect (&lf)) ;
          			GetTextMetrics (hdc, &tm) ;
          			SetTextColor (hdc, cf.rgbColors) ;
          			TextOut (hdc, 0, y = tm.tmExternalLeading, szText, lstrlen (szText)) ;

               					// Display LOGFONT structure fields using system font

          			DeleteObject 		(SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
          			SetTextColor 	(hdc, 0) ;
          
          			TextOut (hdc, 0, y += tm.tmHeight, szBuffer,
        wsprintf (szBuffer, TEXT ("lfHeight = %i"), lf.lfHeight)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfWidth = %i"), lf.lfWidth)) ;
          
          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (	szBuffer, TEXT ("lfEscapement = %i"), 
                         	        lf.lfEscapement)) ;
          
          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (	szBuffer, TEXT ("lfOrientation = %i"), 
                         			lf.lfOrientation)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfWeight = %i"),lf.lfWeight)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfItalic = %i"),lf.lfItalic)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfUnderline = %i"),lf.lfUnderline)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfStrikeOut = %i"),lf.lfStrikeOut)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfCharSet = %i"),lf.lfCharSet)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (	szBuffer, TEXT ("lfOutPrecision = %i"), 
                   lf.lfOutPrecision)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (szBuffer, TEXT ("lfClipPrecision = %i"), 
                  lf.lfClipPrecision)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (	szBuffer, TEXT ("lfQuality = %i"),lf.lfQuality)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (	szBuffer, TEXT ("lfPitchAndFamily = 0x%02X"), 
                     lf.lfPitchAndFamily)) ;

          			TextOut (hdc, 0, y += cyChar, szBuffer,
        wsprintf (	szBuffer, TEXT ("lfFaceName = %s"),lf.lfFaceName)) ;

          			EndPaint (hwnd, &ps) ;
          			return 0 ;
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 CHOSFONT.RC
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
CHOSFONT MENU DISCARDABLE 
BEGIN
 	MENUITEM "&Font!",                      						IDM_FONT
END

 RESOURCE.H
// Microsoft Developer Studio generated include file.
// Used by ChosFont.rc

#define IDM_FONT     40001

 ï¿½ï¿½Ê½17-6  UNICHARS
UNICHARS.C
/*---------------------------------------------------------------------------
   	UNICHARS.C -- 	Displays 16-bit character codes
                 						(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

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

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 	szAppName[] = TEXT ("UniChars") ;
     	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 requies Windows NT!"), 
                      							szAppName, MB_ICONERROR) ;
          		return 0 ;
     }
     
     	hwnd = CreateWindow (	szAppName, TEXT ("Unicode Characters"),
                         WS_OVERLAPPEDWINDOW | WS_VSCROLL,
                         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 CHOOSEFONT 		cf ;
     	static int        				iPage ;
     	static LOGFONT    			    lf ;
     	HDC               				hdc ;
     	int               				cxChar, cyChar, x, y, i, cxLabels ;
     	PAINTSTRUCT       				ps ;
     	SIZE              				size ;
     	TCHAR             				szBuffer [8] ;
     	TEXTMETRIC        				tm ;
     	WCHAR             				ch ;

     	switch (message)
     	{
     	case 	WM_CREATE:
          			hdc = GetDC (hwnd) ;
          			lf.lfHeight = - GetDeviceCaps (hdc, LOGPIXELSY) / 6 ;  // 12 points
          			lstrcpy (lf.lfFaceName, TEXT ("Lucida Sans Unicode")) ;
          			ReleaseDC (hwnd, hdc) ;

          			cf.lStructSize 	= sizeof (CHOOSEFONT) ;
          			cf.hwndOwner   		= hwnd ;
          			cf.lpLogFont   		= &lf ;
          			cf.Flags       		= CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS ;

          			SetScrollRange 		(hwnd, SB_VERT, 0, 255, FALSE) ;
          			SetScrollPos 		(hwnd, SB_VERT, iPage,  TRUE ) ;
          			return 0 ;

     	case 	WM_COMMAND:
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FONT:
               					if (	ChooseFont (&cf))
                    					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
			}
         	 		return 0 ;
     	case 	WM_VSCROLL:
          			switch (LOWORD (wParam))
             				{
               				case SB_LINEUP:    iPage -=  1 	;  break 	;
               				case SB_LINEDOWN:  iPage +=  1 	;  break 	;
               				case SB_PAGEUP:    iPage -= 16 	;  break 	;
               				case SB_PAGEDOWN:  iPage += 16 	;  break 	;
               				case SB_THUMBPOSITION:iPage= HIWORD (wParam);  break ;

               				default:
                    					return 0 ;
               				}

          			iPage = max (0, min (iPage, 255)) ;

          			SetScrollPos (hwnd, SB_VERT, iPage, TRUE) ;
          			InvalidateRect (hwnd, NULL, TRUE) ;
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;

          			SelectObject (hdc, CreateFontIndirect (&lf)) ;

          			GetTextMetrics (hdc, &tm) ;
          			cxChar = tm.tmMaxCharWidth ;
          			cyChar = tm.tmHeight + tm.tmExternalLeading ;

          			cxLabels = 0 ;

          			for (i = 0 ; i < 16 ; i++)
          			{
               			wsprintf (szBuffer, TEXT (" 000%1X: "), i) ;
               			GetTextExtentPoint (hdc, szBuffer, 7, &size) ;

               				cxLabels = max (cxLabels, size.cx) ;
          			}

          			for (y = 0 ; y < 16 ; y++)
          			{
               wsprintf (szBuffer, TEXT (" %03X_: "), 16 * iPage + y) ;
               					TextOut (hdc, 0, y * cyChar, szBuffer, 7) ;

               					for (x = 0 ; x < 16 ; x++)
               					{
                    				ch = (WCHAR) (256 * iPage + 16 * y + x) ;
                    				TextOutW (hdc, 	x * cxChar + cxLabels,
                                   					y * cyChar, &ch, 1) ;
               }
          			}

          DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;

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

 UNICHARS.RC
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
UNICHARS MENU DISCARDABLE 
BEGIN
  	MENUITEM "&Font!",    		  							IDM_FONT
END

 RESOURCE.H
// Microsoft Developer Studio generated include file.
// Used by Unichars.rc

#define IDM_FONT            40001

GetTextExtentPoint32 (hdc, pString, iCount, &size) ;

TCHAR * szText [] = TEXT ("Hello, how are you?") ;

GetTextExtentPoint32 (hdc, szText, lstrlen (szText), &size) ;

TextOut (hdc, xStart, yStart, szText, lstrlen (szText)) ;

xStart = xRight - size.cx ;

xStart = (xLeft + xRight - size.cx) / 2 ;

xRight - xLeft - size.cx

SetTextJustification (hdc, xRight - xLeft - size.cx, 3)

TextOut (hdc, xStart, yStart, szText, lstrlen (szText)) ;

SetTextJustification (hdc, 0, 0) ;

 ï¿½ï¿½Ê½17-7  JUSTIFY1
JUSTIFY1.C
/*--------------------------------------------------------------------------
   	JUSTIFY1.C -- Justified Type Program #1
                 							(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/

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

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("Justify1") ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	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 ("Justified Type #1"),
                          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 ;
}

void DrawRuler (HDC hdc, RECT * prc)
{
     	static int iRuleSize [16] = {360, 72,144, 72,216, 72,144,72,
 288, 72,144, 72,216, 72,144,72 } ;
     	int        				i, j ;
     	POINT      				ptClient ;
     
     	SaveDC (hdc) ;
          				// Set Logical Twips mapping mode
     	SetMapMode (hdc, MM_ANISOTROPIC) ;
     	SetWindowExtEx (hdc, 1440, 1440, NULL) ;
     	SetViewportExtEx (hdc,	GetDeviceCaps (hdc, LOGPIXELSX),
                            	GetDeviceCaps (hdc, LOGPIXELSY), NULL) ;
     
          				// Move the origin to a half inch from upper left
     
     	SetWindowOrgEx (hdc, -720, -720, NULL) ;
          				// Find the right margin (quarter inch from right)
     	ptClient.x = prc->right ;
     	ptClient.y = prc->bottom ;
     	DPtoLP (hdc, &ptClient, 1) ;
     	ptClient.x -= 360 ;
     
          				// Draw the rulers
	MoveToEx 		(hdc, 0,          -360, NULL) ;
     	LineTo   		(hdc, ptClient.x, -360) ;
     	MoveToEx 		(hdc, -360,          0, NULL) ;
     	LineTo   		(hdc, -360, ptClient.y) ;
     
     	for (i = 0, j = 0 ; i <= ptClient.x ; i += 1440 / 16, j++)
     {
          		MoveToEx 		(hdc, i, -360, NULL) ;
          		LineTo   		(hdc, i, -360 - iRuleSize [j % 16]) ;
     	}
     
     	for (i = 0, j = 0 ; i <= ptClient.y ; i += 1440 / 16, j++)
     {
          		MoveToEx 		(hdc, -360, i, NULL) ;
          		LineTo   		(hdc, -360 - iRuleSize [j % 16], i) ;
     }
     
     	RestoreDC (hdc, -1) ;
}
void Justify (HDC hdc, PTSTR pText, RECT * prc, int iAlign)
{
     	int   		xStart, yStart, cSpaceChars ;
     	PTSTR 		pBegin, pEnd ;
     	SIZE  		size ;
     
     	yStart = prc->top ;
     	do                            // for each text line
     {
   		cSpaceChars = 0 ;  		// initialize number of spaces in line

          		while (*	pText == '')    	// skip over leading spaces
               					pText++ ;

		pBegin = pText ;         				// set pointer to char at beginning of line
          
         		do                       		// until the line is known
          		{
               					pEnd =pText ;	// set pointer to char at end of line

                    							// skip to next space 
               
               					while (*pText != '\0' && *pText++ != ' ') ;

               					if (*pText == '\0')
                    							break ;

                    							// after each space encountered, calculate extents

               					cSpaceChars++ ;
               					GetTextExtentPoint32(hdc, pBegin, pText - pBegin - 1, &size) ;
          }
          		while (size.cx < (prc->right - prc->left)) ;
          		cSpaceChars-- ;               			// discount last space at end of line
          
          		while (*(pEnd - 1) == ' ') 	// eliminate trailing spaces
          		{
               				pEnd-- ;
               				cSpaceChars-- ;
          }

               	// if end of text and no space characters, set pEnd to end
          		if (*	pText == '\0' || cSpaceChars <= 0)
               					pEnd = pText ;

          		GetTextExtentPoint32 (hdc, pBegin, pEnd - pBegin, &size) ;
          
          		switch (iAlign)       // use alignment for xStart
       		{
          		case 	IDM_ALIGN_LEFT:
               				xStart = prc->left ;
               				break ;
               
          		case 	IDM_ALIGN_RIGHT:
               				xStart = prc->right - size.cx ;
               				break ;
               
     		case 	IDM_ALIGN_CENTER:
               				xStart = (prc->right + prc->left - size.cx) / 2 ;
               				break ;
               
       		case 	IDM_ALIGN_JUSTIFIED:
               				if (*	pText != '\0' && cSpaceChars > 0)
SetTextJustification (hdc, prc->right-prc->left - size.cx, cSpaceChars) ;
               				xStart = prc->left ;
               				break ;
          		}
               				// display the text
          
          		TextOut (hdc, xStart, yStart, pBegin, pEnd - pBegin) ;

               			// prepare for next line

          		SetTextJustification (hdc, 0, 0) ;
          		yStart += size.cy ;
          		pText = pEnd ;
     }
     	while (*pText && yStart < prc->bottom - size.cy) ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static CHOOSEFONT	cf ;
     	static DOCINFO    			di = { sizeof (DOCINFO), TEXT ("Justify1: Printing") } ;
     	static int        				iAlign = IDM_ALIGN_LEFT ;
     	static LOGFONT    		lf ;
     	static PRINTDLG   		pd ;
     	static TCHAR      			szText[] = { 
      TEXT ("You don't know about me, without you ")
      TEXT ("have read a book by the name of \"The ")
      TEXT ("Adventures of Tom Sawyer,\" but that ")
      TEXT ("ain't no matter. That book was made by ")
      TEXT ("Mr. Mark Twain, and he told the truth, ")
      TEXT ("mainly. There was things which he ")
      TEXT ("stretched, but mainly he told the truth. ")
      TEXT ("That is nothing. I never seen anybody ")
      TEXT ("but lied, one time or another, without ")
      TEXT ("it was Aunt Polly, or the widow, or ")
      TEXT ("maybe Mary. Aunt Polly -- Tom's Aunt ")
      TEXT ("Polly, she is -- and Mary, and the Widow ")
      TEXT ("Douglas, is all told about in that book ")
      TEXT ("-- which is mostly a true book; with ")
      TEXT ("some stretchers, as I said before.") } ;
     	BOOL              				fSuccess ;
     	HDC               				hdc, hdcPrn ;
     	HMENU             				hMenu ;
     	int               				iSavePointSize ;
     	PAINTSTRUCT       		ps ;
     	RECT    				rect ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
               					// Initialize the CHOOSEFONT structure

          			GetObject (GetStockObject (SYSTEM_FONT), sizeof (lf), &lf) ;

          			cf.lStructSize    			= sizeof (CHOOSEFONT) ;
          			cf.hwndOwner      			= hwnd ;
          			cf.hDC            			= NULL ;
          			cf.lpLogFont      			= &lf ;
          			cf.iPointSize     			= 0 ;
          			cf.Flags         	 		= CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS | 
                    CF_EFFECTS ;
          			cf.rgbColors      			= 0 ;
          			cf.lCustData     		 	= 0 ;
          			cf.lpfnHook       			= NULL ;
          			cf.lpTemplateName 		    = NULL ;
          			cf.hInstance      			= NULL ;
          			cf.lpszStyle      			= NULL ;
          			cf.nFontType      			= 0 ;      
          			cf.nSizeMin       			= 0 ;
          			cf.nSizeMax       			= 0 ;
  
          			return 0 ;

     	case 	WM_COMMAND:
          			hMenu = GetMenu (hwnd) ;
          
          			switch (LOWORD (wParam))
          			{
          			case IDM_FILE_PRINT:
                                   		// Get printer DC

               					pd.lStructSize 		= sizeof (PRINTDLG) ;
               					pd.hwndOwner   		= hwnd ;
               					pd.Flags       		= PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION ;

               					if (!PrintDlg (&pd))
                    							return 0 ;

               					if (NULL == (hdcPrn = pd.hDC))
               					{
                   MessageBox (	hwnd, TEXT ("Cannot obtain Printer DC"),
                                szAppName, MB_ICONEXCLAMATION | MB_OK) ;
                    			return 0 ;
               					}
                    						// Set margins of 1 inch

               	rect.left   	= 	GetDeviceCaps (hdcPrn, LOGPIXELSX) -
                             		GetDeviceCaps (hdcPrn, PHYSICALOFFSETX) ;

               rect.top  = 	GetDeviceCaps (hdcPrn, LOGPIXELSY) 
                            GetDeviceCaps (hdcPrn, PHYSICALOFFSETY) ;
rect.right = 	GetDeviceCaps (hdcPrn, PHYSICALWIDTH) -
                            GetDeviceCaps (hdcPrn, LOGPIXELSX) -
                            GetDeviceCaps (hdcPrn, PHYSICALOFFSETX) ;
rect.bottom= 	GetDeviceCaps (hdcPrn, PHYSICALHEIGHT) - 
                            GetDeviceCaps (hdcPrn, LOGPIXELSY) -
                            GetDeviceCaps (hdcPrn, PHYSICALOFFSETY) ;

                    						// Display text on printer

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

               					fSuccess = FALSE ;
     if ((StartDoc (hdcPrn, &di) > 0) && (StartPage (hdcPrn) > 0))
               					{
                         			// Select font using adjusted lfHeight

                    	iSavePointSize = lf.lfHeight ;
                    	lf.lfHeight = -(GetDeviceCaps (hdcPrn, LOGPIXELSY) *
                                        cf.iPointSize) / 720 ;

                    	SelectObject (hdcPrn, CreateFontIndirect (&lf)) ;
                    	lf.lfHeight = iSavePointSize ;

                        // Set text color 
		
                    	SetTextColor (hdcPrn, cf.rgbColors) ;
               
                        // Display text

                    	Justify (hdcPrn, szText, &rect, iAlign) ;

                    	if (EndPage (hdcPrn) > 0)
                    							{	
                         						fSuccess = TRUE ;
                         						EndDoc (hdcPrn) ;
                    							}
               				}
               				ShowCursor (FALSE) ;
               				SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               				DeleteDC (hdcPrn) ;

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

		case	IDM_FONT:
               				if (ChooseFont (&cf))
                    						InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;
               
          		case 	IDM_ALIGN_LEFT:
          		case 	IDM_ALIGN_RIGHT:
          		case 	IDM_ALIGN_CENTER:
          		case 	IDM_ALIGN_JUSTIFIED:
               				CheckMenuItem (hMenu, iAlign, MF_UNCHECKED) ;
               				iAlign = LOWORD (wParam) ;
               				CheckMenuItem (hMenu, iAlign, MF_CHECKED) ;
               				InvalidateRect (hwnd, NULL, TRUE) ;
               				return 0 ;
          			}
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          			DrawRuler (hdc, &rect) ;
          
          			rect.left 	+=	GetDeviceCaps (hdc, LOGPIXELSX) / 2 ;
          			rect.top 	+=	GetDeviceCaps (hdc, LOGPIXELSY) / 2 ;
     			rect.right		-= 	GetDeviceCaps (hdc, LOGPIXELSX) / 4 ;

          			SelectObject (hdc, CreateFontIndirect (&lf)) ;
          			SetTextColor (hdc, cf.rgbColors) ;
          
          			Justify (hdc, szText, &rect, iAlign) ;
          
          			DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 JUSTIFY1.RC
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
JUSTIFY1 MENU DISCARDABLE BEGIN POPUP "&File"
    	BEGIN
        		MENUITEM "&Print", 						IDM_FILE_PRINT
    	END
    	POPUP "&Font"
    	BEGIN
        	MENUITEM "&Font...",      IDM_FONT
    	END
    	POPUP "&Align"
    	BEGIN
       MENUITEM "&Left", 				IDM_ALIGN_LEFT, CHECKED
       MENUITEM "&Right",    			IDM_ALIGN_RIGHT
       MENUITEM "&Centered",  		IDM_ALIGN_CENTER
       MENUITEM "&Justified", 		IDM_ALIGN_JUSTIFIED
	END
END

 RESOURCE.H
// Microsoft Developer Studio generated include file.
// Used by Justify1.rc

#define 		IDM_FILE_PRINT   40001
#define 		IDM_FONT         40002
#define 		IDM_ALIGN_LEFT   40003
#define 		IDM_ALIGN_RIGHT  40004
#define 		IDM_ALIGN_CENTER 40005
#define 		IDM_ALIGN_JUSTIFIED  40006

rect.right = rect.left + 6 * GetDeviceCaps (hdc, LOGPIXELSX) ;

rect.right = rect.left + 6 * GetDeviceCaps (hdcPrn, LOGPIXELSX) ;

 ï¿½ï¿½Ê½17-8  JUSTIFY2
JUSTIFY2.C
/*-----------------------------------------------------------------------------
   	JUSTIFY2.C -- 		Justified Type Program #2
                 							(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

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

#define OUTWIDTH 6       			// Width of formatted output in inches
#define LASTCHAR 127     			// Last character code used in text

LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
TCHAR szAppName[] = TEXT ("Justify2") ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
	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 ("Justified Type #2"),
                          	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 ;
}

void DrawRuler (HDC hdc, RECT * prc)
{
     	static int iRuleSize [16] = {360,72,144, 72,216,72,144,72,288,72,144,
72,216,72,144, 72 } ;
     	int       			i, j ;
     	POINT  			ptClient ;
     
     	SaveDC (hdc) ;
          			// Set Logical Twips mapping mode
     	SetMapMode (hdc, MM_ANISOTROPIC) ;
     	SetWindowExtEx (hdc, 1440, 1440, NULL) ;
     	SetViewportExtEx (hdc, 	GetDeviceCaps (hdc, LOGPIXELSX),
                          GetDeviceCaps (hdc, LOGPIXELSY), NULL) ;
     
			// Move the origin to a half inch from upper left
     
     	SetWindowOrgEx (hdc, -720, -720, NULL) ;
          			// Find the right margin (quarter inch from right)
     	ptClient.x = prc->right ;
     	ptClient.y = prc->bottom ;
     	DPtoLP (hdc, &ptClient, 1) ;
     	ptClient.x -= 360 ;
     
          			// Draw the rulers
     	MoveToEx 		(hdc, 0,    -36	0, NULL) ;
     	LineTo   		(hdc, OUTWIDTH * 1440,	-36	0) ;
     	MoveToEx 		(hdc, -360,   0, NULL) ;
     	LineTo   		(hdc, -360,      ptClient.y) ;
     
     	for (i = 0, j = 0 ; 	i <= ptClient.x && i <= OUTWIDTH * 1440 ;
              i += 1440 / 16, j++)
     	{
          			MoveToEx 		(hdc, i, -360, NULL) ;
          			LineTo   		(hdc, i, -360 - iRuleSize [j % 16]) ;
     	}
     
	for (i = 0, j = 0 ; i <= ptClient.y ; i += 1440 / 16, j++)
     	{
          			MoveToEx 		(hdc, -360, i, NULL) ;
          			LineTo   		(hdc, -360 - iRuleSize [j % 16], i) ;
	}
     
     	RestoreDC (hdc, -1) ;
}

/*---------------------------------------------------------------------------
   	GetCharDesignWidths:	Gets character widths for font as large as the
                         								original design size
----------------------------------------------------------------------------*/

UINT GetCharDesignWidths (HDC hdc, UINT uFirst, UINT uLast, int * piWidths)
{
     	HFONT             						hFont, hFontDesign ;
     	LOGFONT           					lf ;
     	OUTLINETEXTMETRIC 		otm ;

     	hFont = GetCurrentObject (hdc, OBJ_FONT) ;
     	GetObject (hFont, sizeof (LOGFONT), &lf) ;

          		// Get outline text metrics (we'll only be using a field that is
          		//		independent of the DC the font is selected into)

     	otm.otmSize = sizeof (OUTLINETEXTMETRIC) ;
     	GetOutlineTextMetrics (hdc, sizeof (OUTLINETEXTMETRIC), &otm) ;

          		// Create a new font based on the design size
     	lf.lfHeight 	= - (int) otm.otmEMSquare ;
     	lf.lfWidth 	 	= 0 ;
     	hFontDesign 	= CreateFontIndirect (&lf) ;

          		// Select the font into the DC and get the character widths

     	SaveDC (hdc) ;
     	SetMapMode (hdc, MM_TEXT) ;
     	SelectObject (hdc, hFontDesign) ;

     	GetCharWidth (hdc, uFirst, uLast, piWidths) ;
     	SelectObject (hdc, hFont) ;
     	RestoreDC (hdc, -1) ;

          			// Clean up
     	DeleteObject (hFontDesign) ;
     	return otm.otmEMSquare ;
}

/*--------------------------------------------------------------------------
   	GetScaledWidths:	Gets floating point character widths for selected
                     							font size
----------------------------------------------------------------------------*/

void GetScaledWidths (HDC hdc, double * pdWidths)
{
     	double  		dScale ;
     	HFONT   			hFont ;
     	int     			aiDesignWidths [LASTCHAR + 1] ;
     	int     			i ;
     	LOGFONT 		lf ;
     	UINT    			uEMSquare ;

          			// Call function above

     	uEMSquare = GetCharDesignWidths (hdc, 0, LASTCHAR, aiDesignWidths) ;
          			// Get LOGFONT for current font in device context
     	hFont = GetCurrentObject (hdc, OBJ_FONT) ;
     	GetObject (hFont, sizeof (LOGFONT), &lf) ;
          			// Scale the widths and store as floating point values
     	dScale = (double) -lf.lfHeight / (double) uEMSquare ;
     	for (	i = 0 ; i <= LASTCHAR ; i++)
          				pdWidths[i] = dScale * aiDesignWidths[i] ;
}

/*----------------------------------------------------------------------------
   	GetTextExtentFloat:  Calculates text width in floating point
----------------------------------------------------------------------------*/

double GetTextExtentFloat (double * pdWidths, PTSTR psText, int iCount)
{
     	double 	dWidth = 0 ;
     	int 		i ;

     	for (	i = 0 ; i < iCount ; i++)
          				dWidth += pdWidths [psText[i]] ;

     return dWidth ;
}

/*----------------------------------------------------------------------------
   Justify: Based on design units for screen/printer compatibility
-----------------------------------------------------------------------------*/

void Justify (HDC hdc, PTSTR pText, RECT * prc, int iAlign)
{
     	double 	dWidth, adWidths[LASTCHAR + 1] ;
     	int    		xStart, yStart, cSpaceChars ;
     	PTSTR  		pBegin, pEnd ;
     	SIZE   		size ;

          		// Fill the adWidths array with floating point character widths

     	GetScaledWidths (hdc, adWidths) ;
     	yStart = prc->top ;
     	do                            	 // for each text line
     {
          		cSpaceChars = 0 ;        // initialize number of spaces in line

          		while (*pText == ' ')	// skip over leading spaces
               				pText++ ;

    		pBegin = pText ;         	// set pointer to char at beginning of line
          
 		do                       		// until the line is known
        		{
               			pEnd = pText ; 		// set pointer to char at end of line

                    						// skip to next space 
               
               			while (*pText != '\0' && *pText++ != ' ') ;

           			if (*pText == '\0')
                    					break ;

                    		// after each space encountered, calculate extents

               			cSpaceChars++ ;
               			dWidth = GetTextExtentFloat (adWidths, 	pBegin, 
                                                     pText - pBegin - 1) ;
          		}
          		while (dWidth < (double) (prc->right - prc->left)) ;
          
          		cSpaceChars-- ;        // discount last space at end of line
          
          		while (*(pEnd - 1) == ' ')	// eliminate trailing spaces
          		{
               			pEnd-- ;
               			cSpaceChars-- ;
          		}

               			// if end of text and no space characters, set pEnd to end
          
          		if (*pText == '\0' || cSpaceChars <= 0)
               				pEnd = pText ;

               			// Now get integer extents

          		GetTextExtentPoint32(hdc, pBegin, pEnd - pBegin, &size) ;
          
          		switch (iAlign)        	// use alignment for xStart
          		{
          		case 	IDM_ALIGN_LEFT:
               				xStart = prc->left ;
               				break ;

          		case 	IDM_ALIGN_RIGHT:
               				xStart = prc->right - size.cx ;
               				break ;
          		case 	IDM_ALIGN_CENTER:
               				xStart = (prc->right + prc->left - size.cx) / 2 ;
               				break ;
               
          		case 	IDM_ALIGN_JUSTIFIED:
               				if (*pText != '\0' && cSpaceChars > 0)
                    						SetTextJustification (hdc,
                                prc->right - prc->left - size.cx,
                                cSpaceChars) ;
               				xStart = prc->left ;
               				break ;
          		}
               				// display the text
          
          		TextOut (hdc, xStart, yStart, pBegin, pEnd - pBegin) ;

               				// prepare for next line

          		SetTextJustification (hdc, 0, 0) ;
          		yStart += size.cy ;
         		pText = pEnd ;
     }
     	while (*pText && yStart < prc->bottom - size.cy) ;
}

LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static 	CHOOSEFONT	cf ;
     	static 		DOCINFO  			di = { sizeof (DOCINFO), TEXT ("Justify2: Printing") } ;
     	static 	int        			iAlign = IDM_ALIGN_LEFT ;
     	static 	LOGFONT    		lf ;
     	static 	PRINTDLG   		pd ;
     	static 	TCHAR      			szText[] = { 
   TEXT ("Call me Ishmael. Some years ago -- never ")
   TEXT ("mind how long precisely -- having little ")
   TEXT ("or no money in my purse, and nothing ")
   TEXT ("particular to interest me on shore, I ")
   TEXT ("thought I would sail about a little and ")
   TEXT ("see the watery part of the world. It is ")
   TEXT ("a way I have of driving off the spleen, ")
   TEXT ("and regulating the circulation. Whenever ")
   TEXT ("I find myself growing grim about the ")
   TEXT ("mouth; whenever it is a damp, drizzly ")
   TEXT ("November in my soul; whenever I find ")
   TEXT ("myself involuntarily pausing before ")
   TEXT ("coffin warehouses, and bringing up the ")
   TEXT ("rear of every funeral I meet; and ")
   TEXT ("especially whenever my hypos get such an ")
   TEXT ("upper hand of me, that it requires a ")
   TEXT ("strong moral principle to prevent me ")
   TEXT ("from deliberately stepping into the ")
   TEXT ("street, and methodically knocking ")
   TEXT ("people's hats off -- then, I account it ")
   TEXT ("high time to get to sea as soon as I ")
   TEXT ("can. This is my substitute for pistol ")
   TEXT ("and ball. With a philosophical flourish ")
   TEXT ("Cato throws himself upon his sword; I ")
   TEXT ("quietly take to the ship. There is ")
   TEXT ("nothing surprising in this. If they but ")
   TEXT ("knew it, almost all men in their degree, ")
   TEXT ("some time or other, cherish very nearly ")
   TEXT ("the same feelings towards the ocean with ")
   TEXT ("me.") } ;
     	BOOL              			fSuccess ;
     	HDC               			hdc, hdcPrn ;
     	HMENU             			hMenu ;
     	int               			iSavePointSize ;
     	PAINTSTRUCT       			ps ;
     	RECT              			rect ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
               				// Initialize the CHOOSEFONT structure

          			hdc = GetDC (hwnd) ;
          			lf.lfHeight = - GetDeviceCaps (hdc, LOGPIXELSY) / 6 ;
          			lf.lfOutPrecision = OUT_TT_ONLY_PRECIS ;
          			lstrcpy (lf.lfFaceName, TEXT ("Times New Roman")) ;
          			ReleaseDC (hwnd, hdc) ;

          			cf.lStructSize    			= sizeof (CHOOSEFONT) ;
          			cf.hwndOwner      			= hwnd ;
          			cf.hDC            			= NULL ;
          			cf.lpLogFont      			= &lf ;
          			cf.iPointSize     			= 120 ;

               				// Set flags for TrueType only!

          			cf.Flags     = 	CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS | 
                              		CF_TTONLY | CF_EFFECTS ;
          			cf.rgbColors      		= 0 ;
          			cf.lCustData      		= 0 ;
          			cf.lpfnHook       		= NULL ;
          			cf.lpTemplateName 		= NULL ;
          			cf.hInstance      		= NULL ;
          			cf.lpszStyle      		= NULL ;
          			cf.nFontType      		= 0 ;      
          			cf.nSizeMin       		= 0 ;
          			cf.nSizeMax       		= 0 ;
 
          			return 0 ;

     	case 	WM_COMMAND:
          			hMenu = GetMenu (hwnd) ;
          
          			switch (LOWORD (wParam))
          			{
          			case 	IDM_FILE_PRINT:
                    					// Get printer DC

               					pd.lStructSize = sizeof (PRINTDLG) ;
               					pd.hwndOwner   = hwnd ;
			pd.Flags       		= PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION ;

	          				if (!PrintDlg (&pd))
                    							return 0 ;

               					if (NULL == (hdcPrn = pd.hDC))
               					{
                MessageBox	(hwnd, TEXT ("Cannot obtain Printer DC"),
                             szAppName, MB_ICONEXCLAMATION | MB_OK) ;
                    		 return 0 ;
               					}
                    						// Set margins for OUTWIDTH inches wide

               				rect.left = (GetDeviceCaps (hdcPrn, PHYSICALWIDTH) -
                            GetDeviceCaps (hdcPrn, LOGPIXELSX)*OUTWIDTH)/2 
                           	-	GetDeviceCaps (hdcPrn, PHYSICALOFFSETX) ;
               
               				rect.right = 	rect.left + 
                            GetDeviceCaps (hdcPrn, LOGPIXELSX) * OUTWIDTH ;

                    		// Set margins of 1 inch at top and bottom

               				rect.top  = GetDeviceCaps (hdcPrn, LOGPIXELSY) -
                            GetDeviceCaps (hdcPrn, PHYSICALOFFSETY) ;

               		       rect.bottom =GetDeviceCaps (hdcPrn, PHYSICALHEIGHT) - 
                           GetDeviceCaps (hdcPrn, LOGPIXELSY) -
                           GetDeviceCaps (hdcPrn, PHYSICALOFFSETY) ;

                    						// Display text on printer

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

               				fSuccess = FALSE ;

               				if ((StartDoc (hdcPrn, &di) > 0) && (StartPage (hdcPrn) > 0))
               				{
                         	// Select font using adjusted lfHeight

                    	iSavePointSize = lf.lfHeight ;
                    	lf.lfHeight = -(GetDeviceCaps (hdcPrn, LOGPIXELSY) *
                                        cf.iPointSize) / 720 ;

                    SelectObject (hdcPrn, CreateFontIndirect (&lf)) ;
                    					lf.lfHeight = iSavePointSize ;

                         						// Set text color 

                    					SetTextColor (hdcPrn, cf.rgbColors) ;
               
                         						// Display text

                 Justify (hdcPrn, szText, &rect, iAlign) ;

                    					if (EndPage (hdcPrn) > 0)
                    					{
                         							fSuccess = TRUE ;
                         							EndDoc (hdcPrn) ;
                    					}
               				}
               			ShowCursor (FALSE) ;
               			SetCursor (LoadCursor (NULL, IDC_ARROW)) ;

               			DeleteDC (hdcPrn) ;

               			if (!fSuccess)
                    MessageBox (hwnd, TEXT ("Could not print text"),
                                szAppName, MB_ICONEXCLAMATION | MB_OK) ;
               			return 0 ;
          			case 	IDM_FONT:
               					if (ChooseFont (&cf))
                    					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
               
          			case 	IDM_ALIGN_LEFT:
          			case 	IDM_ALIGN_RIGHT:
          			case 	IDM_ALIGN_CENTER:
          			case 	IDM_ALIGN_JUSTIFIED:
               					CheckMenuItem (hMenu, iAlign, MF_UNCHECKED) ;
               					iAlign = LOWORD (wParam) ;
               					CheckMenuItem (hMenu, iAlign, MF_CHECKED) ;
               					InvalidateRect (hwnd, NULL, TRUE) ;
               					return 0 ;
          			}
          			return 0 ;

     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			GetClientRect (hwnd, &rect) ;
          			DrawRuler (hdc, &rect) ;
          
          			rect.left	+= GetDeviceCaps (hdc, LOGPIXELSX) / 2 ;
          			rect.top	+= GetDeviceCaps (hdc, LOGPIXELSY) / 2 ;
          			rect.right 	= rect.left + OUTWIDTH * GetDeviceCaps (hdc, LOGPIXELSX) ;

          			SelectObject (hdc, CreateFontIndirect (&lf)) ;
          			SetTextColor (hdc, cf.rgbColors) ;
          
          			Justify (hdc, szText, &rect, iAlign) ;
          
          			DeleteObject (SelectObject (hdc, GetStockObject (SYSTEM_FONT))) ;
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
          			return 0 ;
     }
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

 JUSTIFY2.RC
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"

/////////////////////////////////////////////////////////////////////////////
// Menu
JUSTIFY2 MENU DISCARDABLE BEGIN POPUP "&File"
    	BEGIN
        		MENUITEM "&Print",  		IDM_FILE_PRINT
    	END
    	POPUP "&Font"
    	BEGIN
        		MENUITEM "&Font...",  	IDM_FONT
    	END
    	POPUP "&Align"
    	BEGIN
        		MENUITEM "&Left",			IDM_ALIGN_LEFT, CHECKED
        		MENUITEM "&Right",    	IDM_ALIGN_RIGHT
        		MENUITEM "&Centered",		IDM_ALIGN_CENTER
        		MENUITEM "&Justified",  	IDM_ALIGN_JUSTIFIED
    	END
END

 RESOURCE.H
// Microsoft Developer Studio generated include file.
// Used by Justify2.rc

#define 		IDM_FILE_PRINT      40001
#define 		IDM_FONT            40002
#define 		IDM_ALIGN_LEFT      40003
#define 		IDM_ALIGN_RIGHT     40004
#define 		IDM_ALIGN_CENTER    40005
#define 		IDM_ALIGN_JUSTIFIED 40006

BeginPath (hdc) ;

EndPath (hdc) ;

StrokePath (hdc) ;
FillPath (hdc) ;
StrokeAndFillPath (hdc) ;
hRgn = PathToRegion (hdc) ;
SelectClipPath (hdc, iCombine) ;

hPen = ExtCreatePen (iStyle, iWidth, &lBrush, 0, NULL) ;

PS_ENDCAP_ROUND
PS_ENDCAP_SQUARE
PS_ENDCAP_FLAT

PS_JOIN_ROUND
PS_JOIN_BEVEL
PS_JOIN_MITER

 ï¿½ï¿½Ê½17-9  ENDJOIN
ENDJOIN.C
/*---------------------------------------------------------------------------
   	ENDJOIN.C --	Ends and Joins Demo
                						(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 ("EndJoin") ;
     	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 ("Ends and Joins Demo"),
                          		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 iMsg, WPARAM wParam,LPARAM lParam)
{
     	static int iEnd[] =	{PS_ENDCAP_ROUND,PS_ENDCAP_SQUARE,PS_ENDCAP_FLAT } ;
     	static int iJoin[]=	{PS_JOIN_ROUND,	PS_JOIN_BEVEL,PS_JOIN_MITER } ;
     	static int	cxClient, cyClient ;
     	HDC         		hdc ;
     	int         		i ;
     	LOGBRUSH    		ib ;
     	PAINTSTRUCT 		ps ;
     
     	switch (iMsg)
     	{
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
          			return 0 ;
          
     	case 	WM_PAINT:
          			hdc = BeginPaint (hwnd, &ps) ;
          
          			SetMapMode (hdc, MM_ANISOTROPIC) ;
          			SetWindowExtEx (hdc, 100, 100, NULL) ;
          			SetViewportExtEx (hdc, cxClient, cyClient, NULL) ;
          
          			lb.lbStyle = BS_SOLID ;
          			lb.lbColor = RGB (128, 128, 128) ;
          			lb.lbHatch = 0 ;
          
          			for (i = 0 ; i < 3 ; i++)
          			{
               		SelectObject (hdc, ExtCreatePen (PS_SOLID | PS_GEOMETRIC |
                                  iEnd [i] | iJoin [i], 10, &lb, 0, NULL)) ;
               					BeginPath (hdc) ;
               					MoveToEx 		(hdc, 10 + 30 * i, 25, NULL) ;
               					LineTo   		(hdc, 20 + 30 * i, 75) ;
               					LineTo   		(hdc, 30 + 30 * i, 25) ;
               
               					EndPath (hdc) ;
               					StrokePath (hdc) ;
               
               					DeleteObject (
                    SelectObject (hdc,GetStockObject (BLACK_PEN))) ;

               					MoveToEx 	(hdc, 10 + 30 * i, 25, NULL) ;
               					LineTo   	(hdc, 20 + 30 * i, 75) ;
               					LineTo   	(hdc, 30 + 30 * i, 25) ;
          			}
			EndPaint (hwnd, &ps) ;
			return 0 ;
          
     	case 	WM_DESTROY:
          			PostQuitMessage (0) ;
         	 		return 0 ;
     	}
  	return DefWindowProc (hwnd, iMsg, wParam, lParam) ;
}

 ï¿½ï¿½Ê½17-10  FONTOUT1
FONTOUT1.C
/*-----------------------------------------------------------------------------
   	FONTOUT1.C -- 		Using Path to Outline Font
                 							(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\eztest\\ezfont.h"

TCHAR szAppName [] = TEXT ("FontOut1") ;
TCHAR szTitle [] = TEXT ("FontOut1: Using Path to Outline Font") ;

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	static TCHAR 	szString [] = TEXT ("Outline") ;
     	HFONT        				hFont ;
     	SIZE         				size ;

     	hFont = EzCreateFont (hdc, TEXT ("Times New Roman"), 1440, 0, 0, TRUE) ;
     	SelectObject (hdc, hFont) ;
     	GetTextExtentPoint32 (hdc, szString, lstrlen (szString), &size) ;
     	BeginPath (hdc) ;
     	TextOut (hdc, (	cxArea - size.cx) / 2, (cyArea - size.cy) / 2,
                    							szString, lstrlen (szString)) ;
     	EndPath (hdc) ;
     	StrokePath (hdc) ;
     	SelectObject (hdc, GetStockObject (SYSTEM_FONT)) ;
     	DeleteObject (hFont) ;
}

 ï¿½ï¿½Ê½17-11  FONTOUT2
FONTOUT2.C
/*-----------------------------------------------------------------------------
   	FONTOUT2.C -- 		Using Path to Outline Font
                 							(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\eztest\\ezfont.h"

TCHAR szAppName [] = TEXT ("FontOut2") ;
TCHAR szTitle [] = TEXT ("FontOut2: Using Path to Outline Font") ;

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	static TCHAR 	szString [] = TEXT ("Outline") ;
     	HFONT        				hFont ;
     	LOGBRUSH     			lb ;
     	SIZE         				size ;

     	hFont = EzCreateFont (hdc, TEXT ("Times New Roman"), 1440, 0, 0, TRUE) ;
     	SelectObject (hdc, hFont) ;
     	SetBkMode (hdc, TRANSPARENT) ;

     	GetTextExtentPoint32 (hdc, szString, lstrlen (szString), &size) ;
     	BeginPath (hdc) ;
     	TextOut (hdc, (	cxArea - size.cx) / 2, (cyArea - size.cy) / 2,
                    	szString, lstrlen (szString)) ;
     	EndPath (hdc) ;
     	lb.lbStyle 	= 	BS_SOLID ;
     	lb.lbColor 	= 	RGB (255, 0, 0) ;
     	lb.lbHatch 	= 	0 ;

     	SelectObject (hdc, ExtCreatePen (PS_GEOMETRIC | PS_DOT,
                      GetDeviceCaps (hdc, LOGPIXELSX) / 24, &lb, 0, NULL)) ;
     	StrokePath (hdc) ;
     	DeleteObject (SelectObject (hdc, GetStockObject (BLACK_PEN))) ;
     	SelectObject (hdc, GetStockObject (SYSTEM_FONT)) ;
     	DeleteObject (hFont) ;
}

 ï¿½ï¿½Ê½17-12  FONTFILL
FONTFILL.C
/*----------------------------------------------------------------------------
   	FONTFILL.C -- 		Using Path to Fill Font
                 							(c) Charles Petzold, 1998
-----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\eztest\\ezfont.h"

TCHAR szAppName [] = TEXT ("FontFill") ;
TCHAR szTitle [] = TEXT ("FontFill: Using Path to Fill Font") ;
void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	static TCHAR szString [] = TEXT ("Filling") ;
     	HFONT        				hFont ;
     	SIZE         				size ;

     	hFont = EzCreateFont (hdc, TEXT ("Times New Roman"), 1440, 0, 0, TRUE) ;
     	SelectObject (hdc, hFont) ;
     	SetBkMode (hdc, TRANSPARENT) ;

     	GetTextExtentPoint32 (hdc, szString, lstrlen (szString), &size) ;
     	BeginPath (hdc) ;
     	TextOut (hdc, (	cxArea - size.cx) / 2, (cyArea - size.cy) / 2,
                    							szString, lstrlen (szString)) ;
     	EndPath (hdc) ;
     	SelectObject (hdc, CreateHatchBrush (HS_DIAGCROSS, RGB (255, 0, 0))) ;
     	SetBkColor (hdc, RGB (0, 0, 255)) ;
     	SetBkMode (hdc, OPAQUE) ;

     	StrokeAndFillPath (hdc) ;
     	DeleteObject (SelectObject (hdc, GetStockObject (WHITE_BRUSH))) ;
     	SelectObject (hdc, GetStockObject (SYSTEM_FONT)) ;
     	DeleteObject (hFont) ;
}

 ï¿½ï¿½Ê½17-13  FONTCLIP
FONTCLIP.C
/*---------------------------------------------------------------------------
   	FONTCLIP.C -- 		Using Path for Clipping on Font
                 							(c) Charles Petzold, 1998
----------------------------------------------------------------------------*/

#include <windows.h>
#include "..\\eztest\\ezfont.h"

TCHAR szAppName [] = TEXT ("FontClip") ;
TCHAR szTitle	[] = TEXT ("FontClip: Using Path for Clipping on Font") ;

void PaintRoutine (HWND hwnd, HDC hdc, int cxArea, int cyArea)
{
     	static TCHAR 	szString [] = TEXT ("Clipping") ;
     	HFONT        				hFont ;
     	int          				y, iOffset ;
	POINT        			pt [4] ;
     	SIZE         			size ;

     	hFont = EzCreateFont (hdc, TEXT ("Times New Roman"), 1200, 0, 0, TRUE) ;
     	SelectObject (hdc, hFont) ;

     	GetTextExtentPoint32 (hdc, szString, lstrlen (szString), &size) ;
     	BeginPath (hdc) ;
     	TextOut (hdc, (	cxArea - size.cx) / 2, (cyArea - size.cy) / 2,
            							szString, lstrlen (szString)) ;
     	EndPath (hdc) ;
               				// Set clipping area
     	SelectClipPath (hdc, RGN_COPY) ;
               				// Draw Bezier splines
    	iOffset = (cxArea + cyArea) / 4 ;
     	for (y = -iOffset ; y < cyArea + iOffset ; y++)
     	{
          		pt[0].x = 0 ;
          		pt[0].y = y ;

          		pt[1].x = cxArea / 3 ;
          		pt[1].y = y + iOffset ;

          		pt[2].x = 2 * cxArea / 3 ;
          		pt[2].y = y - iOffset ;

          		pt[3].x = cxArea ;
          		pt[3].y = y ;

          		SelectObject (hdc, CreatePen (PS_SOLID, 1,
               				RGB (rand () % 256, rand () % 256, rand () % 256))) ;
          		PolyBezier (hdc, pt, 4) ;
          		DeleteObject (SelectObject (hdc, GetStockObject (BLACK_PEN))) ;
     }

	DeleteObject (SelectObject (hdc, GetStockObject (WHITE_BRUSH))) ;
 	SelectObject (hdc, GetStockObject (SYSTEM_FONT)) ;
	DeleteObject (hFont) ;
}