�������� Linux Tags

13. ʹ��ӡ����

Ϊ�˴������ֺ�ͼ�ζ�ʹ����Ѷ��ʾ��ʱ��װ���޹صĸ�����dz������������ӡ������װ���޹صĸ����������أ�

�ܵ�˵����Ч��Ҳ�ܺá���Windows��ʽ�У������Ѷ��ʾ����GDI��ʽһ��������ӡ��ֽ����ӡ���ֺ�ͼ�Σ�����ǰ���۵���װ���޹ص��������⣨��������ƽ����ʾ�ijߴ硢�������Լ���ɫ���йأ�����������ͬ�ķ����������Ȼ��һ̨ӡ��������ʹ���������߹ܵ���ʾ����ô�򵥣�����ʹ�õ���ӡ��ֽ������֮����һЩ�Ƚϴ�IJ��졣���磬���Ǵ������ؿ�����Ѷ��ʾ��û������ʾ������ã�������ʾ�����֡�өĻ�ռ䲻�����Ĵ��󣬵�ӡ����off line��ȱֽȴ�Ǿ��������������⡣

����Ҳ���ص�����ʾ������ִ��ijЩͼ�β����������õ�����ʾ���ܷ���ͼ�Σ���Ϊ����������ܴ���ͼ�Σ��͸�������ʹ��Windows������Щӡ����������ӡͼ�Σ�������������Windows������ʹ�ã�����ͼ�����ܿ�����ӡ����ͼ�Σ�ȴ����λԪͼ��Ĵ������⡣

����������һЩ��Ҫ���ǵ����⣺

  • ӡ��������Ѷ��ʾ��������������û�л��Ὣ��ʽ���ܵ��������״̬��ȴ���ص�����Ѷ��ʾ�����������ʱ�䡣Ȼ����û������������������ǰһֱ�ȴ�ӡ���������ӡ����
    ��
  • ��ʽ�������µ��������ԭ�е���ʾ�����������ʹ����Ѷ��ʾ�����档���ӡ�����Dz����ܵģ�ӡ����ֻ������һ��ҳֽ��Ȼ������һҳ��ֽ����ӡ�µ����ݡ�
    ��
  • ����Ѷ��ʾ���ϣ���ͬ��Ӧ�ó�ʽ�����Ӵ����������ӡ��������ͬӦ�ó�ʽ���������ֳɲ�ͬ���ļ�����ӡ��ҵ��
    ��

Ϊ����GDI�����ಿ���м���ӡ����֧Ԯ���ܣ�Windows�ṩ����ֻ���ӡ�����ĺ�ʽ����Щ������ӡ�����ϵĺ�ʽ��StartDoc��EndDoc��StartPage��EndPage������ӡ�����������֯��ӡ��ֽҳ�ϡ���һ����ʽ������ͨ��GDI��ʽ��һ��ֽ����ʾ���ֺ�ͼ�Σ�����өĻ����ʾ�ķ�ʽһ����

�ڵ�ʮ�塢ʮ�ߺ�ʮ��������ӡ����ͼ����ʽ���������Լ�metafile��������Ѷ��

��ӡ����
��

������Windows��ʹ��ӡ����ʱ��ʵ����������һ������GDI32��̬�����ʽ��ģ�顢��ӡ������ʽ��̬����ģ�飨��.DRV����������WindowsĻ����ӡ��ʽ���Լ����õ����������ģ�顣��дӡ������ӡ��ʽ֮ǰ���������ȿ�һ�������������ν��еġ�

��ӡ�ͱ�������
��

��Ӧ�ó�ʽҪʹ��ӡ����ʱ��������ʹ��CreateDC��PrintDlg��ȡ��ָ��ӡ����װ�����ݵĴ��ţ����ʹ��ӡ����װ��������ʽ��̬�����ʽ��ģ�鱻���뵽�����壨�����û�����������Ļ������Լ����г�ʼ����Ȼ�ᣬ��ʽ����StartDoc��ʽ��֪ͨ˵һ�����ļ���ʼ�ˡ�StartDoc��ʽ����GDIģ���������ģ�GDIģ�����ӡ����װ��������ʽ�е�Control��ʽ����װ��������ʽ׼��������ӡ��

��ӡһ���ļ��ij�����StartDoc���п�ʼ����EndDoc���н��������������ж�����ļ�ҳ������д���ֻ��߻���ͼ�ε�GDI������˵�������þ���ָ�ҳ����鵲һ����ÿҳ������������������޵ģ�����StartPage����ʼһҳ������EndPage��������ҳ��

���磬���Ӧ�ó�ʽ����һҳֽ�ϻ���һ����Բ�������Ⱥ���StartDoc��ʼ��ӡ����Ȼ���ٺ���StartPage֪ͨ�����µ�һҳ����������Ellipse������ͬ��өĻ�ϻ�һ����Բһ����GDIģ��ͨ������ʽ��ӡ����װ������������GDI���д����ڴ�Ƭ�ϵ�metafile�У��õ��������ִ�~EMF����������ǿ��metafile������ʼ������.TMPΪ��������Ȼ������������Ӧ��ָ����ӡ����������ʽ���ܻ�������һ���衣

�����Ƶ�һҳ��GDI���н���ʱ��Ӧ�ó�ʽ����EndPage�����ڣ������Ĺ�����ʼ�ˡ�ӡ����������ʽ����Ѵ����metafile�еĸ��ֻ�ͼ������ӡ����������ϡ�����һҳͼ�������ӡ����������������ܷdz����ر��ǵ�ӡ����û�и߼�ҳ����������ʱ��������ˡ����磬һ̨ÿӢ��600����ʹ��8.5��11Ӣ��ӡ��ֽ������ӡ���������Ҫ����һ��ͼ��ҳ��������Ҫ4��������λԪ������ϡ�

Ϊ�ˣ�ӡ����������ʽ����ʹ��һ�ֳ�������ӡ�ִ����ļ�����һҳ�ֳ����ɳ�Ϊ����������ľ��Ρ�GDIģ���ӡ����������ʽȡ��ÿ��������Ĵ�С��Ȼ���趨һ����ĿǰҪ�������������ȵļ���������Ϊmetafile�е�ÿ����ͼ��ʽ����ӡ����װ��������ʽ��Output��ʽ����������������metafile�����װ��������ʽ������װ��������ʽ�������ҳ���ϵ�ÿ���������GDIģ����뽫����metafile���������װ��������ʽ���������������ᣬ��metafile�Ϳ���ɾ���ˡ�

��ÿ���������װ��������ʽ����Щ��ͼ��ʽת��Ϊ��ӡ��������ӡ��Щͼ������Ҫ��������ϡ�����������ϵĸ�ʽ������ӡ���������Զ���ġ��Ե���ӡ�����������ǰ���ͼ���������ڵ�һϵ�п����������еļ��ϣ�ӡ����������ʽҲ�ܺ�����GDIģ���еĸ��֡�helper��������ʽ������Э����������Ĺ��죩����춴��и߽�ҳ���������ԣ���PostScript��������ӡ������ӡ���������������Խ��������

��ӡ������ʽ����ӡ�����ÿ����������͵�GDIģ�顣���ᣬGDIģ�齫����ӡ���������һ���ݴ浵���У����ݴ浵�������ִ�~SPL��ʼ������.TMP������������������ҳ֮�ᣬGDIģ���Ļ����ӡ��ʽ����һ���������У�֪ͨ��һ���µ���ӡҳ�Ѿ�׼�����ˡ�Ȼ�ᣬӦ�ó�ʽ��ת������һҳ����Ӧ�ó�ʽ����������Ҫ��ӡ�����ҳ�ᣬ���ͺ���EndDoc����һ���źţ���ʾ��ӡ��ҵ�Ѿ���ɡ�ͼ13-1��ʾ��Ӧ�ó�ʽ��GDIģ�����ӡ������ʽ�Ľ������ó���


��

ͼ13-1 Ӧ�ó�ʽ��GDIģ�顢��ӡ������ʽ����ӡ���г�ʽ�Ľ������ù���

WindowsĻ����ӡ��ʽʵ�����Ǽ���Ԫ����һ����ϣ�����13-1����

��13-1
��ӡ���г�ʽԪ�� ˵��
��ӡ�������г�ʽ ���������̴��ݸ���ӡ�����ṩ��
������ӡ�����ṩ�� Ϊ����ӡ����������������
��·��ӡ�����ṩ�� Ϊ��·ӡ����������������
��ӡ������ʽ ����ӡ��������װ���޹ص�����ת��Ϊ���Ŀ��ӡ�����ĸ�ʽ
��ӡ�����ӳ�ʽ ����������ӡ�����IJ�
��ӡ���Լ��ӳ�ʽ ���������˫��ͨѶ��ӡ�������趨װ���趨�����ӡ����״̬

��ӡ���г�ʽ���Լ���Ӧ�ó�ʽ����ӡ������ Windows������ʱ��������ӡ���г�ʽ����ˣ���Ӧ�ó�ʽ��ʼ��ӡʱ�����Ѿ��ǻ���ˡ�����ʽ��ӡһ������ʱ��GDIģ��Ὠ��������ӡ������ϵĵ�����Ļ����ӡ��ʽ�������ǽ���Щ��������ӡ������GDIģ�鷢��һ��ѶϢ��֪ͨ��һ���µ���ӡ��ҵ��ʼ��Ȼ������ʼ��������������ֱ�Ӵ��͵�ӡ������Ϊ�˴�����Щ��������ӡ���г�ʽ����ӡ����������IJ��в����в�ʹ�ø��ֲ�ͬ��ͨ�ź�ʽ������ӡ���г�ʽ��ӡ�������͵����IJ�������ᣬ���ͽ�����������ϵ��ݴ浵��ɾ��������������ù�����ͼ13-2��ʾ��


��

ͼ13-2 Ļ����ӡ��ʽ�IJ�������

�������Ĵ󲿷ֶ�Ӧ�ó�ʽ��˵��͸���ġ���Ӧ�ó�ʽ�ĽǶ�����������ӡ��ֻ������GDIģ�齫������ӡ������ϴ��浽��Ƭ�����е�ʱ������֮�ᣨ�����ӡ���ɵڶ���ִ�����������ģ�������������֮ǰ��Ӧ�ó�ʽ�������ɵؽ������������������ĵ�����ӡ��������Ļ����ӡ��ʽ�����񣬶�����Ӧ�ó�ʽ������ͨ��ӡ���������У�ʹ���߿�����ͣ��ӡ��ҵ���ı���ҵ������˳���ȡ����ӡ��ҵ�����ֹ�����ʽʹӦ�ó�ʽ�ܸ���ؽ���ӡ�����Լ�ʱ��ʽ��ӡ��������������ȵ���ӡ��һҳ����ܴ�����һҳ��

�����Ѿ�������һ�����ӡԭ����������һЩ�������������֮һ��Windows��ʽҪʹ��ӡ����ʱ������һ����ҪĻ����ӡ��ʽ��ʹ���߿�����ӡ�������Ա������ϸ��������ҳ�йر�ӡ�����ı���������

Ϊʲôʹ����ϣ����ʹ�ñ��������أ���Ϊʹ���߿���ʹ���˱�Windows��ӡ���г�ʽ�����Ӳ�������Ļ����ӡ��ʽ��Ҳ������ӡ������һ������������ӡ����������·��ʹ�á�һ��Ĺ����ǣ�ʹ��һ����ӡ���г�ʽ��ʹ��������ӡ���г�ʽ���졣ȥ��WindowsĻ����ӡ��ʽ���Լӿ���ӡ�ٶȣ���Ϊ��ӡ������ϲ��ش�����Ӳ���ϣ�������ֱ�������ӡ�����������ⲿ��Ӳ����ӡ�������������Ļ����ӡ��ʽ�����ա�

���û������Windows��ӡ���г�ʽ��GDIģ��Ͳ�������װ��������ʽ����ӡ������ϴ��뵵���У����ǽ���Щ�������ֱ���������ӡ�����������ӡ���г�ʽ���е���ӡ��ͬ��GDI���е���ӡһ������Ӧ�ó�ʽ��ִͣ��һ��ʱ�䣨�ر��ǽ�����ӡ�еij�ʽ��ֱ����ӡ��ɡ�

������һ�����⡣ͨ����GDIģ�齫����һҳ��������к�ʽ����һ����ǿ��metafile�У�Ȼ����������ʽ�����ÿ����ӡ��������һ���metafile����ӡ������ʽ�С�Ȼ���������ӡ������ʽ����Ҫ��ӡ�ִ��Ļ����Ͳ��Ὠ�����metafile��GDIֻ��򵥵ؽ���ͼ��ʽֱ������������ʽ����һ���ı仯�ǣ�Ӧ�ó�ʽҲ���ܵóе������ӡ������Ͻ�����ӡ�ִ������Σ����ʹ��Ӧ�ó�ʽ�е���ӡ��ʽ����Ӹ����ˣ���ȴ��ȥ��GDIģ�齨��metafile���鷳��������GDIֻ��򵥵�Ϊÿ�����������ʽ������ӡ������ʽ��

�����������Ѿ������˴�һ��WindowsӦ�ó�ʽ������ӡ����Ҫ��ʹ����Ѷ��ʾ���ĸ��������������ܳ���һЩ���⣭�ر��ǣ����GDIģ���ڽ���metafile����ӡ�������ʱ�ľ��˴ŵ��ռ䡣�����Ը�������Щ���⣬��������������Щ���Ⲣ��֪ʹ���ߣ���������ȻҲ������֮������

���һ��Ӧ�ó�ʽ����ӡ�ļ��ĵ�һ���������ȡ��ӡ����װ�õ����ݡ�

ӡ����װ������
��

��������Ѷ��ʾ���ϻ�ͼǰ��Ҫ�õ�װ�����ݴ���һ��������ӡ֮ǰ��ʹ���߱���ȡ��һ��ӡ����װ�����ݴ��š�һ������������ţ���Ϊ����һ�����ļ�������StartDoc�Լ�����StartPage��ʼһҳ�����Ϳ�������ʹ����Ѷ��ʾװ�����ݴ�����ͬ�ķ�����ʹ��ӡ����װ�����ݴ��ţ��ô��ż�Ϊ����GDI���еĵ�һ��������

�����Ӧ�ó�ʽ���ɺ���PrintDlg��ʽ��һ����׼����ӡ�Ի����飨���������չʾ�ú�ʽ���÷����������ʽ��Ϊʹ�����ṩ��һ������ӡ֮ǰ�ı�ӡ��������ָ���������ԵĻ��ᡣȻ�ᣬ����ӡ����װ�����ݴ��Ž���Ӧ�ó�ʽ���ú�ʽ�ܹ�ʡ��Ӧ�ó�ʽ��һЩ������Ȼ����ijЩӦ�ó�ʽ������Notepad������Ҫȡ��ӡ����װ�����ݣ�������Ҫ�Ǹ��Ի����顣Ҫ������һ�㣬��Ҫ����CreateDC��ʽ��

�ڵ������У�����֪�����ͨ�����µĺ�����Ϊ������Ѷ��ʾ��ȡ��ָ��װ�����ݵĴ��ţ�

hdc = CreateDC (TEXT ("DISPLAY"), NULL, NULL, NULL) ;

��Ҳ����ʹ�øú�ʽ��ȡ��ӡ����װ�����ݴ��š�Ȼ������ӡ����װ�����ݣ�CreateDC��һ���﷨Ϊ��

hdc = CreateDC (NULL, szDeviceName, NULL, pInitializationData) ;

pInitializationData����һ�㱻��ΪNULL��szDeviceName����ָ��һ���ִ����Ը���Windowsӡ�����豸�����ơ����趨�豸����֮ǰ��������֪������Щӡ�������á�

һ��ϵͳ�����в�ֻһ̨��������ӡ����������������������ʽ���紫�����壬���Լ�αװ��ӡ���������������ӡ�����ж���̨����ֻ����һ̨����Ϊ�ǡ�Ŀǰ��ӡ���������ߡ��ڶ�ӡ������������ʹ�������һ��ѡ���ӡ����������С�͵�Windows��ʽֻʹ���ڶ�ӡ������������ӡ��

ȡ���ڶ�ӡ����װ�����ݵķ�ʽ�����ڸı䡣Ŀǰ����׼�ķ�����ʹ��EnumPrinters��ʽ����á��ú�ʽ����һ������ÿ����������ӡ������Ѷ�����нṹ�����������ϸ�ڲ�Σ���������ѡ���ֽṹ֮һ��Ϊ�ú�ʽ�IJ�������Щ�ṹ������ΪPRINTER_INFO_x��x��һ�����֡�

���ҵ��ǣ���ʹ�õĺ�ʽ��ȡ������ij�ʽ����Windows 98��ִ�л�����Windows NT��ִ�С���ʽ13-1չʾ��GetPrinterDC��ʽ��������ҵϵͳ�Ϲ������÷���

 ï¿½ï¿½Ê½13-1  GETPRNDC
GETPRNDC.C
/*----------------------------------------------------------------------
   	GETPRNDC.C -- GetPrinterDC function
-----------------------------------------------------------------------*/
#include <windows.h>
HDC GetPrinterDC (void)
{
     	DWORD            						dwNeeded, dwReturned ;
     	HDC              						hdc ;
     	PRINTER_INFO_4 * 		pinfo4 ;
     	PRINTER_INFO_5 * 		pinfo5 ; 
     	if (GetVersion () & 0x80000000)      // Windows 98
     	{
          			EnumPrinters (PRINTER_ENUM_DEFAULT, NULL, 5, NULL,
                    0, &dwNeeded, &dwReturned) ;
          			pinfo5 = malloc (dwNeeded) ;
          			EnumPrinters (PRINTER_ENUM_DEFAULT, NULL, 5, (PBYTE) pinfo5,
                    dwNeeded, &dwNeeded, &dwReturned) ;
          			hdc = CreateDC (NULL, pinfo5->pPrinterName, NULL, NULL) ;
          			free (pinfo5) ;
     	}
     	else
//Windows NT
     {
          			EnumPrinters (PRINTER_ENUM_LOCAL, NULL, 4, NULL,
                    0, &dwNeeded, &dwReturned) ;
          			pinfo4 = malloc (dwNeeded) ;
          			EnumPrinters (PRINTER_ENUM_LOCAL, NULL, 4, (PBYTE) pinfo4,
                    dwNeeded, &dwNeeded, &dwReturned) ;
          			hdc = CreateDC (NULL, pinfo4->pPrinterName, NULL, NULL) ;
          			free (pinfo4) ;
     	}
     	return hdc ;   
}

��Щ��ʽʹ��GetVersion��ʽ��ȷ����ʽ��ִ����Windows 98�ϻ���Windows NT�ϡ�������ʲô��ҵϵͳ����ʽ����EnumPrinters���Σ�һ��ȡ��������ṹ�Ĵ�С��һ������ṹ����Windows 98�ϣ���ʽʹ��PRINTER_INFO_5�ṹ����Windows NT�ϣ���ʽʹ��PRINTER_INFO_4�ṹ����Щ�ṹ��EnumPrinters�ļ���/Platform SDK/Graphics and Multimedia Services/GDI/Printing and Print Spooler/Printing and Print Spooler Reference/Printing and Print Spooler Functions/EnumPrinters������С�ڵ�ǰ�棩����˵���������ǡ����׶����١��ġ�

�޸����DEVCAPS��ʽ
��

�����µ�DEVCAPS1��ʽֻ��ʾ�˴�GetDeviceCaps��ʽ��õĹ����Ѷ��ʾ�Ļ�����Ѷ����ʽ13-2��ʾ���°汾��ʾ�˹����Ѷ��ʾ�����ᵽϵͳ֮����ӡ�����ĸ�����Ѷ��

 ï¿½ï¿½Ê½13-2  DEVCAPS2
DEVCAPS2.C
/*--------------------------------------------------------------------------
   	DEVCAPS2.C --		Displays Device Capability Information (Version 2)
                 							(c) Charles Petzold, 1998
---------------------------------------------------------------------------*/
#include <windows.h>
#include "resource.h"
LRESULT CALLBACK WndProc 		(HWND, UINT, WPARAM, LPARAM) ;
void DoBasicInfo    				(HDC, HDC, int, int) ;
void DoOtherInfo    				(HDC, HDC, int, int) ;
void DoBitCodedCaps 				(HDC, HDC, int, int, int) ;
typedef struct
{
     	int     			iMask ;
     	TCHAR * 		szDesc ;
}
BITS ;
#define IDM_DEVMODE      1000
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    							PSTR szCmdLine, int iCmdShow)
{
     	static TCHAR 		szAppName[] = TEXT ("DevCaps2") ;
     	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, NULL,
                          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 TCHAR            		szDevice[32], szWindowText[64] ;
	static int              		cxChar, cyChar,	nCurrentDevice		= IDM_SCREEN,
        nCurrentInfo		= IDM_BASIC ;
     	static DWORD 				dwNeeded, dwReturned ;
     	static PRINTER_INFO_4 * pinfo4 ;
     	static PRINTER_INFO_5 * pinfo5 ;
     	DWORD                  i ;
     	HDC                    hdc, hdcInfo ;
     	HMENU                  hMenu ;
     	HANDLE                 hPrint ;
     	PAINTSTRUCT            ps ;
     	TEXTMETRIC             tm ;
     
     	switch (message)
     	{
     	case 	WM_CREATE :
          			hdc =	GetDC (hwnd) ;
			SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
			GetTextMetrics (hdc, &tm) ;
          			cxChar = tm.tmAveCharWidth ;
          			cyChar = tm.tmHeight + tm.tmExternalLeading ;
          			ReleaseDC (hwnd, hdc) ;
// fall through
     	case 	WM_SETTINGCHANGE:
          			hMenu = GetSubMenu (GetMenu (hwnd), 0) ;
          
          			while (GetMenuItemCount (hMenu) > 1)
               			DeleteMenu (hMenu, 1, MF_BYPOSITION) ;
               			// Get a list of all local and remote printers
               			// 
               			// First, find out how large an array we need; this
               			//   call will fail, leaving the required size in dwNeeded
               			//
               			// Next, allocate space for the info array and fill it
               			// 
               			// Put the printer names on the menu
		if (GetVersion () & 0x80000000)         				// Windows 98
          		{
               			EnumPrinters (PRINTER_ENUM_LOCAL, NULL, 5, NULL, 
                        0, &dwNeeded, &dwReturned) ;
               			pinfo5 = malloc (dwNeeded) ;
               			EnumPrinters (PRINTER_ENUM_LOCAL, NULL, 5, (PBYTE) pinfo5,
                        dwNeeded, &dwNeeded, &dwReturned) ;
               			for (i = 0 ; i < dwReturned ; i++)
               			{
                    				AppendMenu (hMenu, (i+1) % 16 ? 0 : MF_MENUBARBREAK, i + 1, 
                                								pinfo5[i].pPrinterName) ;
               			}
               			free (pinfo5) ;
  		}
         		else 
// Windows NT
          {
               			EnumPrinters (PRINTER_ENUM_LOCAL, NULL, 4, NULL, 
                        0, &dwNeeded, &dwReturned) ;
               			pinfo4 = malloc (dwNeeded) ;
               			EnumPrinters (PRINTER_ENUM_LOCAL, NULL, 4, (PBYTE) pinfo4,
                        dwNeeded, &dwNeeded, &dwReturned) ;
               			for (i = 0 ; i < dwReturned ; i++)
               				{
					AppendMenu (hMenu, (i+1) % 16 ? 0 : MF_MENUBARBREAK, i + 1, 
                                		pinfo4[i].pPrinterName) ;
               }
               				free (pinfo4) ;
          		}
          
          		AppendMenu (hMenu, MF_SEPARATOR, 0, NULL) ;
          		AppendMenu (hMenu, 0, IDM_DEVMODE, TEXT ("Properties")) ;
          
          		wParam = IDM_SCREEN ; 
// fall through
     	case 	WM_COMMAND :
          			hMenu = GetMenu (hwnd) ;
          
          			if (	LOWORD (wParam) == IDM_SCREEN || 	// IDM_SCREEN & Printers
         					LOWORD (wParam) < IDM_DEVMODE)       
          			{
               		CheckMenuItem (hMenu, nCurrentDevice, MF_UNCHECKED) ;
               		nCurrentDevice = LOWORD (wParam) ;
               		CheckMenuItem (hMenu, nCurrentDevice, MF_CHECKED) ;
          			}
          			else if (LOWORD (wParam) == IDM_DEVMODE)     	// Properties selection
          			{
               					GetMenuString (hMenu, nCurrentDevice, szDevice,
                              	sizeof (szDevice) / sizeof (TCHAR), MF_BYCOMMAND);
               
               					if (OpenPrinter (szDevice, &hPrint, NULL))
               					{
                    					PrinterProperties (hwnd, hPrint) ;
                    					ClosePrinter (hPrint) ;
               					}
          			}
          			else 
// info menu items
          {
               				CheckMenuItem (hMenu, nCurrentInfo, MF_UNCHECKED) ;
               				nCurrentInfo = LOWORD (wParam) ;
               				CheckMenuItem (hMenu, nCurrentInfo, MF_CHECKED) ;
          			}
          			InvalidateRect (hwnd, NULL, TRUE) ;
          			return 0 ;
          
     	case 	WM_INITMENUPOPUP :
          			if (lParam == 0)
               					EnableMenuItem (GetMenu (hwnd), IDM_DEVMODE,
                    						nCurrentDevice == IDM_SCREEMF_GRAYED : MF_ENABLED) ;
          			return 0 ;
          
     	case 	WM_PAINT :
      			lstrcpy (szWindowText, TEXT ("Device Capabilities: ")) ;
          
          			if (nCurrentDevice == IDM_SCREEN)
          			{
               				lstrcpy (szDevice, TEXT ("DISPLAY")) ;
               				hdcInfo = CreateIC (szDevice, NULL, NULL, NULL) ;
          			}
          			else
          			{
               				hMenu = GetMenu (hwnd) ;
               				GetMenuString (hMenu, nCurrentDevice, szDevice,
                            sizeof (szDevice), MF_BYCOMMAND) ;
               				hdcInfo = CreateIC (NULL, szDevice, NULL, NULL) ;
          			}
          
          			lstrcat (szWindowText, szDevice) ;
          			SetWindowText (hwnd, szWindowText) ;
          
          			hdc = BeginPaint (hwnd, &ps) ;
          			SelectObject (hdc, GetStockObject (SYSTEM_FIXED_FONT)) ;
          
          			if (hdcInfo)
          			{
               				switch (nCurrentInfo)
               					{
               				case 	IDM_BASIC :
                    		DoBasicInfo (hdc, hdcInfo, cxChar, cyChar) ;
                  						break ;
                    
               			case 	IDM_OTHER :
                    		DoOtherInfo (hdc, hdcInfo, cxChar, cyChar) ;
                    					break ;
                    
               			case 	IDM_CURVE :
               			case 	IDM_LINE :
               			case 	IDM_POLY :
               			case 	IDM_TEXT :
                    		DoBitCodedCaps (hdc, hdcInfo, cxChar, cyChar,
                                    	nCurrentInfo - IDM_CURVE) ;
                    					break ;
               				}
               			DeleteDC (hdcInfo) ;
          		}
          
          		EndPaint (hwnd, &ps) ;
          		return 0 ;
          
     	case 	WM_DESTROY :
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}
     
void DoBasicInfo (HDC hdc, HDC hdcInfo, int cxChar, int cyChar)
{
  	static struct
     	{
          		int     nIndex ;
          		TCHAR * szDesc ;
  	}
     	info[] =
     	{
          		HORZSIZE,        		TEXT ("HORZSIZE        		Width in millimeters:"),
          		VERTSIZE,        		TEXT ("VERTSIZE        		Height in millimeters:"),
          		HORZRES,         		TEXT ("HORZRES         		Width in pixels:"),
          		VERTRES,         		TEXT ("VERTRES         		Height in raster lines:"),
          		BITSPIXEL,       		TEXT ("BITSPIXEL       		Color bits per pixel:"),
          		PLANES,          		TEXT ("PLANES          				Number of color planes:"),
          		NUMBRUSHES,      		TEXT ("NUMBRUSHES      		Number of device brushes:"),
          		NUMPENS,         		TEXT ("NUMPENS         			Number of device pens:"),
          		NUMMARKERS,      		TEXT ("NUMMARKERS      		Number of device markers:"),
          		NUMFONTS,        		TEXT 	("NUMFONTS        			Number of device fonts:"),
          		NUMCOLORS,       		TEXT 	("NUMCOLORS       			Number of device colors:"),
          		PDEVICESIZE, TEXT("PDEVICESIZE	Size of device structure:"),
ASPECTX,       TEXT("ASPECTX Relative width of pixel:"),
ASPECTY,       TEXT("ASPECTY Relative height of pixel:"),
ASPECTXY,      TEXT("ASPECTXY Relative diagonal of pixel:"),
LOGPIXELSX,    TEXT("LOGPIXELSX Horizontal dots per inch:"),
LOGPIXELSY,    TEXT("LOGPIXELSY Vertical dots per inch:"),
SIZEPALETTE,   TEXT("SIZEPALETTE Number of palette entries:"),
NUMRESERVED,   TEXT("NUMRESERVED Reserved palette entries:"),
COLORRES,      TEXT("COLORRES Actual color resolution:"),
PHYSICALWIDTH, TEXT("PHYSICALWIDTH Printer page pixel width:"),
PHYSICALHEIGHT,TEXT("PHYSICALHEIGHT Printer page pixel height:"),
PHYSICALOFFSETX,TEXT("PHYSICALOFFSETX Printer page x offset:"),
PHYSICALOFFSETY,TEXT("PHYSICALOFFSETY Printer page y offset:") 
   	} ;
    	int   i ;
  	TCHAR szBuffer[80] ;
          
     	for (i = 0 ; i < sizeof (info) / sizeof (info[0]) ; i++)
          	   TextOut (hdc, cxChar, (i + 1) * cyChar, szBuffer,
               wsprintf (szBuffer, TEXT ("%-45s%8d"), info[i].szDesc,
                    	GetDeviceCaps (hdcInfo, info[i].nIndex))) ;
}
    
void DoOtherInfo (HDC hdc, HDC hdcInfo, int cxChar, int cyChar)
{
     	static BITS clip[] =
     	{
         CP_RECTANGLE, TEXT ("CP_RECTANGLE  Can Clip To Rectangle:")
     	} ; 
          
     	static BITS raster[] =
     {
        RC_BITBLT,    TEXT ("RC_BITBLT  Capable of simple BitBlt:"),
   		RC_BANDING,   TEXT ("RC_BANDING Requires banding support:"),
        RC_SCALING,   TEXT ("RC_SCALING Requires scaling support:"),
        RC_BITMAP64,  TEXT ("RC_BITMAP64  Supports bitmaps >64K:"),
        RC_GDI20_OUTPUT, TEXT ("RC_GDI20_OUTPUT Has 2.0 output calls:"),
        RC_DI_BITMAP, TEXT ("RC_DI_BITMAP  Supports DIB to memory:"),
   		RC_PALETTE,   TEXT ("RC_PALETTE  	Supports a palette:"),
  		RC_DIBTODEV,  TEXT ("RC_DIBTODEV Supports bitmap conversion:"),
  		RC_BIGFONT,   TEXT ("RC_BIGFONT  Supports fonts >64K:"),
   		RC_STRETCHBLT,TEXT ("RC_STRETCHBLT Supports StretchBlt:"),
   		RC_FLOODFILL, TEXT ("RC_FLOODFILL  Supports FloodFill:"),
  		RC_STRETCHDIB,TEXT ("RC_STRETCHDIB Supports StretchDIBits:")
     	} ;
          
     	static TCHAR * szTech[]= 	{ 	TEXT ("DT_PLOTTER (Vector plotter)"),
                         TEXT ("DT_RASDISPLAY (Raster display)"),
                         TEXT ("DT_RASPRINTER (Raster printer)"),
                         TEXT ("DT_RASCAMERA (Raster camera)"),
                         TEXT ("DT_CHARSTREAM (Character stream)"),
                         TEXT ("DT_METAFILE (Metafile)"),
                         TEXT ("DT_DISPFILE (Display file)") } ;
  	int            				i ;
 	TCHAR          				szBuffer[80] ;
          
     	TextOut (hdc, cxChar, cyChar, szBuffer,
          wsprintf (szBuffer, TEXT ("%-24s%04XH"), TEXT ("DRIVERVERSION:"),
               GetDeviceCaps (hdcInfo, DRIVERVERSION))) ;
   	TextOut (hdc, cxChar, 2 * cyChar, szBuffer,
          			wsprintf (szBuffer, TEXT ("%-24s%-40s"), TEXT ("TECHNOLOGY:"), 
               				szTech[GetDeviceCaps (hdcInfo, TECHNOLOGY)])) ;
    	TextOut (hdc, cxChar, 4 * cyChar, szBuffer,
          			wsprintf (szBuffer, TEXT ("CLIPCAPS (Clipping capabilities)"))) ;
     	for (i = 0 ; i < sizeof (clip) / sizeof (clip[0]) ; i++)
          			TextOut (hdc, 9 * cxChar, (i + 6) * cyChar, szBuffer,
               					wsprintf (szBuffer, TEXT ("%-45s %3s"), clip[i].szDesc,
                    						GetDeviceCaps (hdcInfo, CLIPCAPS) & clip[i].iMask ?
                         				TEXT ("Yes") : TEXT ("No"))) ;
     	TextOut (hdc, cxChar, 8 * cyChar, szBuffer,
          		wsprintf (szBuffer, TEXT ("RASTERCAPS (Raster capabilities)"))) ;
 	for (i = 0 ; i < sizeof (raster) / sizeof (raster[0]) ; i++)
     	TextOut (hdc, 9 * cxChar, (i + 10) * cyChar, szBuffer,
               					wsprintf (szBuffer, TEXT ("%-45s %3s"), raster[i].szDesc,
                    						GetDeviceCaps (hdcInfo, RASTERCAPS) & raster[i].iMask ?
                         		TEXT ("Yes") : TEXT ("No"))) ;
}
void DoBitCodedCaps (	HDC hdc, HDC hdcInfo, int cxChar, int cyChar,int iType)
{
     	static BITS curves[] =
     	{
          		CC_CIRCLES,    	TEXT ("CC_CIRCLES    	Can do circles:"),
          		CC_PIE,        	TEXT ("CC_PIE        	Can do pie wedges:"),
          		CC_CHORD,      	TEXT ("CC_CHORD      	Can do chord arcs:"),
          		CC_ELLIPSES,  	TEXT ("CC_ELLIPSES   	Can do ellipses:"),
          		CC_WIDE,       	TEXT ("CC_WIDE       	Can do wide borders:"),
          		CC_STYLED,     	TEXT ("CC_STYLED     	Can do styled borders:"),
          		CC_WIDESTYLED, 	TEXT 	("CC_WIDESTYLED Can do wide and styled borders:"),
          		CC_INTERIORS,  	TEXT ("CC_INTERIORS  	Can do interiors:")
     	} ; 
     
     	static BITS lines[] =
     	{
          		LC_POLYLINE,   	TEXT 	("LC_POLYLINE Can do polyline:"),
          		LC_MARKER,     	TEXT 	("LC_MARKER Can do markers:"),
          		LC_POLYMARKER, 	TEXT 	("LC_POLYMARKER Can do polymarkers"),
          		LC_WIDE,       	TEXT 	("LC_WIDE Can do wide lines:"),
          		LC_STYLED,     	TEXT 	("LC_STYLED Can do styled lines:"),
          		LC_WIDESTYLED, 	TEXT 	("LC_WIDESTYLED 	Can do wide and styled lines:"),
          		LC_INTERIORS,  	TEXT ("LC_INTERIORS  Can do interiors:")
     	} ;
     
     	static BITS poly[] =
     	{
          		PC_POLYGON,     
               			TEXT ("PC_POLYGON     	Can do alternate fill polygon:"),
          		PC_RECTANGLE,   	TEXT 	("PC_RECTANGLE Can do rectangle:"),
    		PC_WINDPOLYGON, 
               			TEXT ("PC_WINDPOLYGON Can do winding number fill polygon:"),
          		PC_SCANLINE,    	TEXT ("PC_SCANLINE    Can do scanlines:"),
          		PC_WIDE,        	TEXT ("PC_WIDE        Can do wide borders:"),
          		PC_STYLED,      	TEXT ("PC_STYLED      Can do styled borders:"),
          		PC_WIDESTYLED,  
               			TEXT ("PC_WIDESTYLED  Can do wide and styled borders:"),
          		PC_INTERIORS,   	TEXT ("PC_INTERIORS   	Can do interiors:")
 	} ;
     
     	static BITS text[] =
     	{
          		TC_OP_CHARACTER, TEXT ("TC_OP_CHARACTER	Can do character output precision:"),
          		TC_OP_STROKE,    TEXT ("TC_OP_STROKE  	Can do stroke output precision:"),
          		TC_CP_STROKE,    TEXT ("TC_CP_STROKE  	Can do stroke clip precision:"),
          		TC_CR_90,        TEXT ("TC_CP_90       Can do 90 degree character rotation:"),
          		TC_CR_ANY,       TEXT ("TC_CR_ANY      Can do any character rotation:"),
          		TC_SF_X_YINDEP,  TEXT ("TC_SF_X_YINDEP  Can do scaling independent of X and Y:"),
          		TC_SA_DOUBLE,    EXT ("TC_SA_DOUBLE    Can do doubled character for scaling:"),
          		TC_SA_INTEGER,   TEXT ("TC_SA_INTEGER   Can do integer multiples for scaling:"),
          		TC_SA_CONTIN,    TEXT ("TC_SA_CONTIN  	Can do any multiples for exact scaling:"),
          		TC_EA_DOUBLE,    TEXT ("TC_EA_DOUBLE   Can do double weight characters:"),
          		TC_IA_ABLE,      TEXT ("TC_IA_ABLE     Can do italicizing:"),
          		TC_UA_ABLE,      TEXT ("TC_UA_ABLE     Can do underlining:"),
          		TC_SO_ABLE,      TEXT ("TC_SO_ABLE     Can do strikeouts:"),
          		TC_RA_ABLE,      TEXT ("TC_RA_ABLE     Can do raster fonts:"),
          		TC_VA_ABLE,      TEXT ("TC_VA_ABLE     Can do vector fonts:")
     	} ;
     
     	static struct
     	{
      		int     			iIndex ;
          		TCHAR * 		szTitle ;
          		BITS    			(*pbits)[] ;
          		int     			iSize ;
   	}
     	bitinfo[] =
     	{
          		CURVECAPS,  	TEXT ("CURVCAPS (Curve Capabilities)"),
               			(BITS (*)[]) curves, sizeof (curves) / sizeof (curves[0]),
          		LINECAPS,   	TEXT ("LINECAPS (Line Capabilities)"),
               			(BITS (*)[]) lines, sizeof (lines) / sizeof (lines[0]),
          		POLYGONALCAPS, TEXT ("POLYGONALCAPS (Polygonal Capabilities)"),
               			(BITS (*)[]) poly, sizeof (poly) / sizeof (poly[0]),
          		TEXTCAPS,   	TEXT ("TEXTCAPS (Text Capabilities)"),
               			(BITS (*)[]) text, sizeof (text) / sizeof (text[0])
    	} ;
     
     	static TCHAR szBuffer[80] ;
     	BITS         		(*pbits)[] = bitinfo[iType].pbits ;
     	int          		i, iDevCaps = GetDeviceCaps (hdcInfo, bitinfo[iType].iIndex) ;
     
     	TextOut (hdc, cxChar, cyChar, bitinfo[iType].szTitle,
              					lstrlen (bitinfo[iType].szTitle)) ;
     	for (i = 0 ; i < bitinfo[iType].iSize ; i++)
          	 extOut (hdc, cxChar, (i + 3) * cyChar, szBuffer,
             wsprintf (szBuffer, TEXT ("%-55s %3s"), (*pbits)[i].szDesc,
             iDevCaps & (*pbits)[i].iMask ? TEXT ("Yes") : TEXT ("No")));
}
 DEVCAPS2.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
// Menu
DEVCAPS2 MENU DISCARDABLE 
BEGIN
    	POPUP "&Device"
    	BEGIN
        			MENUITEM "&Screen",IDM_SCREEN, CHECKED
    	END
    	POPUP "&Capabilities"
    	BEGIN
        	        MENUITEM "&Basic Information",IDM_BASIC
        			MENUITEM "&Other Information",IDM_OTHER
        			MENUITEM "&Curve Capabilities",IDM_CURVE
        			MENUITEM "&Line Capabilities",IDM_LINE
        			MENUITEM "&Polygonal Capabilities",IDM_POLY
        			MENUITEM "&Text Capabilities",IDM_TEXT
    	END
END
 RESOURCE.H ��ժ¼��
// Microsoft Developer Studio generated include file.
// Used by DevCaps2.rc
#define IDM_SCREEN        40001
#define IDM_BASIC         40002
#define IDM_OTHER         40003
#define IDM_CURVE         40004
#define IDM_LINE          40005
#define IDM_POLY          40006
#define IDM_TEXT          40007

��ΪDEVCAPS2ֻȡ��ӡ��������Ѷ���ݣ�ʹ������Ȼ���Դ�DEVCAPS2�Ĺ��ܱ���ѡ������ӡ���������ʹ������Ƚϲ�ͬӡ�����Ĺ��ܣ���������ӡ�������������Ӹ�����ӡ������ʽ��

PrinterProperties����
��

DEVCAPS2�ġ�Device�����ܱ����ϻ���һ����Ϊ��Properties����ѡ�Ҫʹ�����ѡ����ȵô� Device ï¿½ï¿½ï¿½Ü±ï¿½ï¿½ï¿½Ñ¡ï¿½ï¿½Ò»ï¿½ï¿½Ó¡ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½È»ï¿½ï¿½ï¿½ï¿½Ñ¡ï¿½ï¿½ Properties ï¿½ï¿½ï¿½ï¿½Ê±ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½ï¿½Ô»ï¿½ï¿½ï¿½ï¿½é¡£ï¿½Ô»ï¿½ï¿½ï¿½ï¿½ï¿½ÓºÎ¶ï¿½ï¿½ï¿½ï¿½Ø£ï¿½ï¿½ï¿½ï¿½ï¿½Ó¡ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ê½ï¿½ï¿½ï¿½Ð£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ù»ï¿½ï¿½ï¿½Ê¹ï¿½ï¿½ï¿½ï¿½Ñ¡ï¿½ï¿½Ö½ï¿½Ä³ß´ç¡£ï¿½ï¿½ï¿½ï¿½ï¿½Ó¡ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ò²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ê¹ï¿½ï¿½ï¿½ï¿½ï¿½Ú¡ï¿½Ö±Ó¡ï¿½ï¿½portrait�����ò¡¸ºï¿½Ó¡ï¿½ï¿½landscape����ģʽ�н���ѡ����ֱӡģʽ��һ��Ϊ�ڶ�ģʽ���£�ֽ�Ķ̱��Ƕ������ں�ӡģʽ�£�ֽ�ij����Ƕ���������ı��ģʽ���������ĸı佫��DEVCAPS2��ʽ��GetDeviceCaps��ʽȡ�õ���Ѷ�з�Ӧ������ˮƽ�ߴ�ͽ����Ƚ��봹ֱ�ߴ�ͽ����Ƚ�������ɫ��ͼ���ġ�Properties���Ի���������ʮ�ֹ㷺������Ҫ��ʹ�������밲װ�ڻ�ͼ����֮���ʵ���ɫ��ʹ��֮��ͼֽ����͸����Ƭ�����ͺš�

����ӡ����������ʽ������һ����ΪExtDeviceMode�������ʽ�������жԻ����鲢����ʹ�����������Ѷ����Щӡ����������ʽҲ����Щ��Ѷ������ϵͳ��¼���Լ�ӵ�еIJ����У���Щ��Ȼ����Щ������Ѷ��ӡ����������ʽ���´�ִ��Windowsʱ����ȡ����Ѷ��

����ʹ����ѡ��ӡ������Windows��ʽͨ��ֻ����PrintDlg�����������һ�չʾ�÷�����������õĺ�ʽ��׼����ӡʱ�����ʹ����֮�����е�ͨѶ��������������ʹ����Ҫ������иı䡣��ʹ���ߵ�����Properties����ťʱ��PrintDlg�����������Ա���Ի����顣

��ʽ������ͨ��ֱ�Ӻ���ӡ����������ʽ��ExtDeviceMode��ExtDeveModePropSheet��ʽ������ʾӡ���������ԶԻ����飬Ȼ�����Ҳ�����������������DEVCAPS2������͸������PrinterProperties�������Ի������õöࡣ

PrinterPropertiesҪ��ӡ��������Ĵ��ţ�������ͨ��OpenPrinter��ʽ���õ�����ʹ����ȡ�����Ա���Ի�����ʱ��PrinterProperties���أ�Ȼ��ʹ����ͨ������ClosePrinter���ͷ�ӡ�������š�DEVCAPS2��������������һ��ġ�

��ʽ����ȡ�øո���Device���ܱ���ѡ���ӡ�������ƣ����������һ����ΪszDevice����Ԫ�����С�

GetMenuString (	hMenu, nCurrentDevice, szDevice,
               					sizeof (szDevice) / sizeof (TCHAR), MF_BYCOMMAND) ;

Ȼ�ᣬʹ��OpenPrinter��ø��豸�Ĵ��š�������гɹ�����ô��ʽ��������PrinterProperties�����Ի����飬Ȼ�����ClosePrinter�ͷ��豸���ţ�

if (OpenPrinter (szDevice, &hPrint, NULL))
{
     	PrinterProperties (hwnd, hPrint) ;
     	ClosePrinter (hPrint) ;
}

���BitBlt֧Ԯ
��

��������GetDeviceCaps��ʽ��ȡ��ҳ�п���ӡ���ijߴ�ͽ����ȣ�ͨ���������򲻻�������ֽ�Ĵ�С��ͬ�������ʹ�������Լ��������Ų�����Ҳ���Ի����Ե�ͼ�ؿ��Ⱥ͸߶ȡ�

ӡ���������Ĵ������Ѷ�����GDI������Ӧ�ó�ʽ�ġ�ͨ������ӡ����������ij����ʱ��GDI��ģ�������ܡ�Ȼ��������Ӧ�ó�ʽӦ�����ȼ��ġ�

��RASTERCAPS����λԪӳ��֧Ԯ������������GetDeviceCaps�������ص�RC_BITBLTλԪ��������һ����Ҫ��ӡ�������ԣ���λԪ��ʾ�豸�Ƿ��ܽ���λԪ�鴫�͡����������ӡ����������ӡ��������īӡ�������ܽ���λԪ�鴫�ͣ����������ͼ��ȴ���ܡ����ܴ���λԪ�鴫�͵��豸��֧Ԯ����GDI��ʽ��CreateCompatibleDC��CreateCompatibleBitmap��PatBlt��BitBlt��StretchBlt��GrayString��DrawIcon��SetPixel��GetPixel��FloodFill��ExtFloodFill��FillRgn��FrameRgn��InvertRgn��PaintRgn��FillRect��FrameRect��InvertRect����������Ѷ��ʾ����ʹ��GDI��ʽ����ӡ������ʹ�����ǵ�Ψһ��Ҫ����

��򵥵���ӡ��ʽ
��

���ڿ��Կ�ʼ��ӡ�ˣ����Ǿ����ܼ򵥵ؿ�ʼ����ʵ�ϣ����ǵĵ�һ����ʽֻ����ӡ������ֽ���ѡ���ʽ13-3��FORMFEED��ʽ��չʾ����ӡ�������С����

 ï¿½ï¿½Ê½13-3  FORMFEED
FORMFEED.C
/*-----------------------------------------------------------------------
   	FORMFEED.C -- 	Advances printer to next page
                 						(c) Charles Petzold, 1998
------------------------------------------------------------------------*/
#include <windows.h>
HDC GetPrinterDC (void) ;
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    				LPSTR lpszCmdLine, int iCmdShow)
{
     	static DOCINFO di = { sizeof (DOCINFO), TEXT ("FormFeed") } ;
     	HDC       					hdcPrint = GetPrinterDC () ;
     
     	if (hdcPrint != NULL)
     	{
  		if (StartDoc (hdcPrint, &di) > 0)
               				if (StartPage (hdcPrint) > 0 && EndPage (hdcPrint) > 0)
                    						EndDoc (hdcPrint) ;
          		DeleteDC (hdcPrint) ;
     	}
     	return 0 ;
}

�����ʽҲ��Ҫǰ���ʽ13-1�е�GETPRNDC.C������

����ȡ��ӡ����װ�����ݣ�Ȼ����ɾ�������⣬��ʽֻ�����������ڱ���ǰ�����۹����ĸ���ӡ��ʽ��FORMFEED���Ⱥ���StartDoc��ʼһ���µĵ����������Դ�StartDoc���ص�ֵ��ֻ�д���ֵ������ʱ���ż�����ȥ��

if (StartDoc (hdcPrint, &di) > 0)

StartDoc�ĵڶ���������ָ��DOCINFO�ṹ��ָ�ꡣ�ýṹ�ڵ�һ����λ�����˽ṹ�Ĵ�С���ڵڶ�����λ�������ִ���FormFeed�������������ڱ���ӡ�����ڵȴ���ӡʱ������ִ���������ӡ�������������еġ�Document Name�����С�ͨ�������ִ�����������ӡ��Ӧ�ó�ʽ���ƺͱ���ӡ�ĵ������ơ�

���StartDoc�ɹ�����һ�����Ĵ���ֵ��ʾ������ôFORMFEED����StartPage����������������EndPage����һ����ӡ�����ƽ����µ�һҳ���ٴζԴ���ֵ���в��ԣ�

if (StartPage (hdcPrint) > 0 && EndPage (hdcPrint) > 0)

���ᣬ������������ļ��ͽ�����

EndDoc (hdcPrint) ;

Ҫע����ǣ�ֻ�е�û����ʱ���ź���EndDoc��ʽ�����������ӡ��ʽ�е�ijһ�����ش�����룬��ôGDIʵ�����Ѿ��ж����ļ�����ӡ�����ӡ����Ŀǰδ��ӡ�����ִ������ͨ����ʹӡ���������趨��������ӡ��ʽ�Ĵ���ֵ�Ǽ��������򵥷��������������ʹ���߱�����󣬾ͱ������GetLastError��ȷ������

�����д��MS-DOS�µļ�����ӡ������ֽ�ij�ʽ����Ӧ��֪������춴����ӡ������ASCII��12������ֽ��Ϊʲô���򵥵�ʹ��C�ij�ʽ�⺯ʽopen��Ȼ����write���ASCII��12�أ���Ȼ������ȫ������ô�������DZ���ȷ��ӡ����������Ǵ��в����Dz��в���Ȼ������Ҫȷ������ij�ʽ�����磬��ӡ���г�ʽ���Dz�������ʹ��ӡ������������ϣ�����ļ���ӡ��һ��ʱ����ij�ʽ��������ӡ������ֽ�ͳ�ӡ�������Բ��ԣ����ᣬ��������ȷ��ASCII��12�Dz���������ӡ��������ֽ��Ԫ����Ϊ��������ӡ��������ֽ��Ԫ����12����ʵ�ϣ���PostScript�е���ֽ����㲻��12�����ǵ���showpage��

�򵥵�˵����Ҫ��ͼֱ���ƹ�Windows����Ӧ�ü������ӡ��ʹ��Windows��ʽ��

��ӡͼ�κ�����
��

��һ��Windows��ʽ�У���ӡ����Ķ��⸺��ͨ����FORMFEED��ʽ�ߵö࣬���һ�Ҫ��GDI��ʽ��ʵ����ӡһЩ������������д����ӡһҳ���ֺ�ͼ�εij�ʽ������FORMFEED��ʽ�еķ�����������һЩ�µĶ������ó�ʽ���������汾PRINT1��PRINT2��PRINT3��Ϊ�����ʽ���ظ���ÿ����ʽ����ǰ����ʾ��GETPRNDC.C������PRINT.C�����еĺ�ʽ�����ʽ13-4��ʾ��

 ï¿½ï¿½Ê½13-4  PRINT
PRINT.C
/*------------------------------------------------------------------------
   	PRINT.C -- Common routines for Print1, Print2, and Print3
--------------------------------------------------------------------------*/
#include <windows.h>
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
BOOL PrintMyPage (HWND) ;
extern HINSTANCE 	hInst ;
extern TCHAR  			szAppName[] ;
extern TCHAR  			szCaption[] ;
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  		= NULL ;
     	wndclass.lpszClassName 		= szAppName ;
     
     	if (!RegisterClass (&wndclass))
     {
         	 	MessageBox (	NULL, TEXT ("This program requires Windows NT!"),
                      				szAppName, MB_ICONERROR) ;
          		return 0 ;
     	}
     
     	hInst = hInstance ;
     	hwnd = CreateWindow (szAppName, szCaption,
                          	  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 PageGDICalls (HDC hdcPrn, int cxPage, int cyPage)
{
     	static TCHAR szTextStr[] = TEXT ("Hello, Printer!") ;
     	Rectangle (hdcPrn, 0, 0, cxPage, cyPage) ;
     	MoveToEx (hdcPrn, 0, 0, NULL) ;
     	LineTo   (hdcPrn, cxPage, cyPage) ;
     	MoveToEx (hdcPrn, cxPage, 0, NULL) ;
     	LineTo   (hdcPrn, 0, cyPage) ;
     
     	SaveDC (hdcPrn) ;
     
     	SetMapMode       		(hdcPrn, MM_ISOTROPIC) ;
     	SetWindowExtEx   		(hdcPrn, 1000, 1000, NULL) ;
     	SetViewportExtEx 		(hdcPrn, cxPage / 2, -cyPage / 2, NULL) ;
     	SetViewportOrgEx 		(hdcPrn, cxPage / 2,  cyPage / 2, NULL) ;
     
     	Ellipse (hdcPrn, -500, 500, 500, -500) ;
     	SetTextAlign (hdcPrn, TA_BASELINE | TA_CENTER) ;
     	TextOut (hdcPrn, 0, 0, szTextStr, lstrlen (szTextStr)) ;
     	RestoreDC (hdcPrn, -1) ;
}
LRESULT CALLBACK WndProc (	HWND hwnd, UINT message, WPARAM wParam,LPARAM lParam)
{
     	static int   		cxClient, cyClient ;
     	HDC          		hdc ;
     	HMENU        		hMenu ;
     	PAINTSTRUCT  		ps ;
     
     	switch (message)
     	{
     	case 	WM_CREATE:
          			hMenu = GetSystemMenu (hwnd, FALSE) ;
          			AppendMenu (hMenu, MF_SEPARATOR, 0, NULL) ;
          			AppendMenu (hMenu, 0, 1, TEXT ("&Print")) ;
          			return 0 ;
          
     	case 	WM_SIZE:
          			cxClient = LOWORD (lParam) ;
          			cyClient = HIWORD (lParam) ;
         	 		return 0 ;
          
     	case 	WM_SYSCOMMAND:
          			if (wParam == 1)
          		{
               				if (!PrintMyPage (hwnd))
                    					MessageBox (hwnd, TEXT ("Could not print page!"),
                                		szAppName, MB_OK | MB_ICONEXCLAMATION) ;
               				return 0 ;
          		}
          		break ;
          
     	case	WM_PAINT :
    			hdc = BeginPaint (hwnd, &ps) ;
          
          			PageGDICalls (hdc, cxClient, cyClient) ;
          
          			EndPaint (hwnd, &ps) ;
          			return 0 ;
          
     	case 	WM_DESTROY :
          			PostQuitMessage (0) ;
          			return 0 ;
     	}
     	return DefWindowProc (hwnd, message, wParam, lParam) ;
}

PRINT.C������ʽWinMain��WndProc�Լ�һ����ΪPageGDICalls�ĺ�ʽ��PageGDICalls��ʽ����ӡ����װ�����ݴ��ź�����������ӡҳ����ȼ��߶ȵı����������ʽ������һ����Χ����ҳ��ľ��Σ��������Խ��ߣ�ҳ�м���һ����Բ����ֱ����ӡ�����߶ȺͿ����н�С���Ǹ���һ�룩�����֡�Hello, Printer!��λ���Բ���м䡣

����WM_CREATEѶϢʱ��WndProc��һ����Print��ѡ��ӵ�ϵͳ���ܱ��ϡ�ѡ���ѡ�����PrintMyPage���˺�ʽ�Ĺ����ڳ�ʽ�������汾�н�������ǿ������ӡ�ɹ�ʱ��PrintMyPage����TRUEֵ�������������ʱ�򴫻�FALSE�����PrintMyPage����FALSE��WndProc�ͻ���ʾһ��ѶϢ�����Ը�֪ʹ���߷����˴���

��ӡ�Ļ�������
��

��ӡ��ʽ�ĵ�һ���汾��PRINT1������ʽ13-5���������ἴ��ִ�д˳�ʽ��Ȼ���ϵͳ���ܱ���ѡ��Print����������GDI����Ҫ��ӡ�������������һ���ݴ浵���У�Ȼ����ӡ���г�ʽ�������͸�ӡ������

 ï¿½ï¿½Ê½13-5  PRINT1
PRINT1.C
/*---------------------------------------------------------------------
   	PRINT1.C -- Bare Bones Printing
               						(c) Charles Petzold, 1998
----------------------------------------------------------------------*/
#include <windows.h>
HDC  	GetPrinterDC (void) ;              		// in GETPRNDC.C
void 	PageGDICalls (HDC, int, int) ;     		// in PRINT.C
HINSTANCE hInst ;
TCHAR     		szAppName[] = TEXT ("Print1") ;
TCHAR     		szCaption[] = TEXT ("Print Program 1") ;
BOOL PrintMyPage (HWND hwnd)
{
     	static DOCINFO di = { 	sizeof (DOCINFO), TEXT ("Print1: Printing") } ;
	BOOL           			bSuccess = TRUE ;
     	HDC            		hdcPrn ;
     	int            		xPage, yPage ;
     
     	if 	(NULL == (hdcPrn = GetPrinterDC ()))
          			return FALSE ;
 	xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
  	yPage = GetDeviceCaps (hdcPrn, VERTRES) ;
     
 	if (StartDoc (hdcPrn, &di) > 0)
     	{
          			if (StartPage (hdcPrn) > 0)
          			{
               				PageGDICalls (hdcPrn, xPage, yPage) ;
               
               				if (EndPage (hdcPrn) > 0)
                    						EndDoc (hdcPrn) ;
               				else
                    					bSuccess = FALSE ;
          			}
     	}
     	else
          		bSuccess = FALSE ;
     
     	DeleteDC (hdcPrn) ;
     	return bSuccess ;
}

����������PRINT1.C�еij�ʽ�롣���PrintMyPage����ȡ��ӡ������װ�����ݴ��ţ����ʹ���FALSE������WndProc��ʾѶϢ����ָ�����������ʽ�ɹ�ȡ����װ�����ݴ��ţ�����ͨ������GetDeviceCaps��ȷ��ҳ���ˮƽ�ʹ�ֱ��С����ͼ��Ϊ��λ����

xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
yPage = GetDeviceCaps (hdcPrn, VERTRES) ;

�ⲻ��ֽ��ȫ����С��ֻ��ֽ�Ŀ���ӡ���򡣺����ᣬ����PRINT1��StartPage��EndPage����֮�����PageGDICalls��PRINT1��PrintMyPage��ʽ�еij�ʽ���ڽṹ����FORMFEED�еij�ʽ����ͬ����������StartDoc��StartPage��EndPage���ɹ�ʱ��PRINT1�ź���EndDoc��ӡ��ʽ��

ʹ�÷���������ȡ����ӡ
��

��춴����ļ�����ʽӦ���ṩʹ������Ӧ�ó�ʽ��ӡ�ڼ�ȡ����ӡ����ı����ԡ�Ҳ��ʹ����ֻҪ��ӡ�ļ��е�һҳ����������ӡȫ����537ҳ��Ӧ��Ҫ����ӡ��ȫ����537ҳ֮ǰ�����������

��һ����ʽ��ȡ��һ����ӡ������Ҫһ�ֱ���Ϊ���������򡹵ļ��������������ڳ�ʽ��ֻ�Ǹ���С�������ʽ��ʹ���߿���ʹ��SetAbortProc��ʽ���ú�ʽ��λַ����Windows��Ȼ��GDI����ӡʱ���ظ����иó��򣬲��ϵ��ʣ������Ƿ�Ӧ�ü�����ӡ����

���ǿ�������������ӵ���ӡ������ʽ��ȥ��ҪЩʲô��Ȼ����һЩ��֦ĩ�ڡ���������һ������ΪAbortProc������ʽΪ��

BOOL CALLBACK AbortProc (HDC hdcPrn, int iCode)
{
	//�����г�ʽ
}

��ӡǰ��������ͨ������SetAbortProc���ǼǷ�������

SetAbortProc (hdcPrn, AbortProc) ;

�ں���StartDocǰ��������ĺ�ʽ����ӡ����᲻�������������

�ڴ���EndPage����ʱ���༴���ڽ�metafile����װ��������ʽ��������ʱ��ӡ����ʱ����GDI�������з������򡣲���hdcPrn��ӡ����װ�����ݴ��š����һ��������iCode������0�����GDIģ���������ݴ浵��ʱ�ľ��˴ŵ��ռ䣬iCode����SP_OUTOFDISK��

�����ӡ��ҵ��������ôAbortProc���봫��TRUE�����㣩�������ӡ��ҵ�쳣�������ʹ���FALSE���㣩������������Ա���Ϊ������ʾ����ʽ��

BOOL CALLBACK AbortProc (HDC hdcPrn, int iCode)
{
     	MSG   msg ;
     	while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return TRUE ;
}

�����ʽ�������е����⣬��ʵ������������ѶϢ��Ȧ��ʹ���߻�ע�⵽�������ѶϢ��Ȧ������PeekMessage������GetMessage�����ڵ����µ�RANDRECT��ʽ�����۹�PeekMessage��Ӧ�û��ǵã�PeekMessage�������Ȩ���ظ���ʽ�������ܳ�ʽ��ѶϢ�������Ƿ���ѶϢ���ڡ�

ֻҪPeekMessage����TRUE����ôAbortProc��ʽ�е�ѶϢ��Ȧ���ظ�����PeekMessage��TRUEֵ��ʾPeekMessage�Ѿ��ҵ�һ��ѶϢ����ѶϢ����ͨ��TranslateMessage��DispatchMessage���͵���ʽ���Ӵ�ѶϢ������ʽ������ʽ��ѶϢ������û��ѶϢ����PeekMessage�Ĵ���ֵΪFALSE�����AbortProc������Ȩ���ظ�Windows��

Windows���ʹ��AbortProc
��

����ʽ������ӡʱ���󲿷ֹ���������Ҫ����EndPageʱ������EndPageǰ����ʽÿ����һ��GDI��ͼ��ʽ��GDIģ��ֻ�Ǽ򵥵ؽ���һ����¼�ӵ���Ƭ�ϵ�metafile�С���GDI�õ�EndPage�ᣬ����ӡҳ����װ��������ʽ�����ÿ���������GDI������metafile����װ��������ʽ�С�Ȼ�ᣬGDI��ӡ����������ʽ��������ӡ������浽һ�������С����û������Ļ����ӡ����ôGDIģ������Զ�������ӡ���д��ӡ������

��EndPage�����ڼ䣬GDIģ��������趨�ķ�������ͨ��iCode����Ϊ0���������춴���δ��ӡ�������ݴ浵���������GDIִ��ʱ�ŵ��ռ䲻����iCode������ΪSP_OUTOFDISK��ͨ�������������ֵ���������Ը�⣬�����Խ��м�飩�����������������PeekMessage��Ȧ���Լ���ѶϢ��������ѰѶϢ��

����ڳ�ʽ��ѶϢ������û��ѶϢ��PeekMessage�ᴫ��FALSE��Ȼ�����������������ѶϢ��Ȧ����GDIģ�鴫��һ��TRUEֵ��ָʾ��ӡӦ�ü������С�Ȼ��GDIģ���������EndPage���С�

����д���������ôGDI����ֹ��ӡ���������������������ҪĿ��������ʹ����ȡ����ӡ��Ϊ�ˣ����ǻ���Ҫһ����ʾ��Cancel����ť�ĶԻ����飬�����Dz������������IJ��衣���ȣ������ڽ���PRINT2��ʽʱ����һ����������Ȼ����PRINT3������һ�����С�Cancel����ť�ĶԻ����飬ʹ����������á�

ʵ����������
��

���ڿ��ٸ�ϰһ�·�������Ļ��ơ����Զ���һ��������ʾ�ķ�������

BOOL CALLBACK AbortProc (HDC hdcPrn, int iCode)
{
     	MSG  msg ;
     	while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
     	return TRUE ;
}

��������ӡʲôʱ��ʹ������ĺ��н�ָ����������ָ�괫��Windows��

SetAbortProc (hdcPrn, AbortProc) ;

�ں���StartDoc֮ǰ����������о����ˡ�

����������û����ô�򵥡����Ǻ�����AbortProc������PeekMessage��Ȧ������⣬���Ǹ��ܴ�����⡣ֻ���ڳ�ʽ�����ӡ����ʱ��AbortProc����Żᱻ���С������AbortProc���ҵ�һ��ѶϢ���������͸��Ӵ�ѶϢ������ʽ���ͻᷢ��һЩ�dz�������������飺ʹ���߿��Դӹ��ܱ����ٴ�ѡ��Print��������ʽ�Ѿ������ӡ��ʽ֮�С���ʽ����ӡǰһ��������ͬʱ��ʹ����Ҳ���԰�һ���µ������뵽��ʽ�ʹ�������������˳���ʽ�����������������ˣ�����ʹ���߳�ʽ���Ӵ����������������ӡ��ʽִ�н���ʱ�������˵�������Ч���Ӵ���ʽ֮�⣬���޴���ȥ��

���ֶ�������˸����ͷת�򣬶����ǵij�ʽ�Դ˲�δ���κ�׼��������������ԭ�򣬵��趨��������ʱ������Ӧ��ֹ��ʽ���Ӵ��������룬ʹ�����ܽ��ܼ��̺ͻ������롣���������µĺ�ʽ����������

EnableWindow (hwnd, FALSE) ;

�����Խ�ֹ���̺ͻ�����������ѶϢ���С��������ӡ�����У�ʹ���߲��ܶԳ�ʽ���κι���������ӡ���ʱ��Ӧ���������Ӵ��������룺

EnableWindow (hwnd, TRUE) ;

������Ҫ�ʣ���Ȼû�м��̻���ѶϢ����ѶϢ���У�Ϊʲô���ǻ�Ҫ����AbortProc�е�TranslateMessage��DispatchMessage�����أ�ʵ���ϲ���һ���ǵ���ҪTranslateMessage�����ǣ����DZ���ʹ��DispatchMessage������WM_PAINTѶϢ����ѶϢ�����е���������WM_PAINTѶϢû�еõ��Ӵ�ѶϢ������ʽ�е�BeginPaint��EndPaint���ʵ����������PeekMessage���ٴ���FALSE����ѶϢ�ͻ������������в��ҷ���������

����ӡ�ڼ���ֹ�Ӵ���������ѶϢʱ�����ij�ʽ���������ʾ�������ʹ���߿����л���������ʽ�������������������������Ļ����ӡ��ʽ���ܼ�������������͵�ӡ������

��ʽ13-6��ʾ��PRINT2��ʽ��PRINT1��������һ����������ͱ�Ҫ��֧Ԯ������AbortProc��ʽ������EnableWindow���Σ���һ����ֹ�Ӵ���������ѶϢ���ڶ��������Ӵ�����

 ï¿½ï¿½Ê½13-6  PRINT2
PRINT2.C
/*---------------------------------------------------------------------
   	PRINT2.C --	Printing with Abort Procedure
               						(c) Charles Petzold, 1998
----------------------------------------------------------------------*/
#include <windows.h>
HDC 	GetPrinterDC (void) ;              		// in GETPRNDC.C
void PageGDICalls (HDC, int, int) ;     		// in PRINT.C
HINSTANCE hInst ;
TCHAR     		szAppName[] = TEXT ("Print2") ;
TCHAR     		szCaption[] = TEXT ("Print Program 2 (Abort Procedure)") ;
BOOL CALLBACK AbortProc (HDC hdcPrn, int iCode)
{
     		MSG msg ;
     		while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     	{
          			TranslateMessage (&msg) ;
          			DispatchMessage (&msg) ;
     	}
     	return TRUE ;
}
BOOL PrintMyPage (HWND hwnd)
{
     	static DOCINFO di = { sizeof (DOCINFO), TEXT ("Print2: Printing") } ;
     	BOOL           				bSuccess = TRUE ;
     	HDC            				hdcPrn ;
     	short          				xPage, yPage ;
     
     	if (NULL == (hdcPrn = GetPrinterDC ()))
          			return FALSE ;
     	xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
     	yPage = GetDeviceCaps (hdcPrn, VERTRES) ;
     
     	EnableWindow (hwnd, FALSE) ;
     	SetAbortProc (hdcPrn, AbortProc) ;
     	if (StartDoc (hdcPrn, &di) > 0)
     	{
          			if (StartPage (hdcPrn) > 0)
          			{
               				PageGDICalls (hdcPrn, xPage, yPage) ;
               				if (EndPage (hdcPrn) > 0)
                    						EndDoc (hdcPrn) ;
               				else
                   						bSuccess = FALSE ;
          			}
   	}
     	else
          			bSuccess = FALSE ;
     	EnableWindow (hwnd, TRUE) ;
     	DeleteDC (hdcPrn) ;
     	return bSuccess ;
}

������ӡ�Ի�����
��

PRINT2����������ʮ�����⡣���ȣ������ʽû��ֱ��ָʾ����ʱ��ʼ��ӡ�ͺ�ʱ������ӡ��ֻ�н�����ָ���ʽ���ҷ�����û�з�Ӧʱ�����ܶ϶�����Ȼ�ڴ���PrintMyPage��ʽ��PRINT2�ڽ��б�������ʱҲû�и�ʹ�����ṩȡ����ӡ��ҵ�Ļ��ᡣ

������ע�⵽�������Windows��ʽ��Ϊʹ�����ṩ��һ��ȡ��Ŀǰ���ڽ�����ӡ�����Ļ��ᡣһ��С�ĶԻ����������өĻ�ϣ�������һЩ���ֺ͡�Cancel����������GDI����ӡ������浽��Ƭ���������ͣ����ӡ���г�ʽ��ӡ����������ӡ�������ڼ䣬��ʽ����ʾ����Ի����顣����һ����ϵͳģ̬�Ի����飬�������ṩ�Ի�����

ͨ��������Ի�����Ϊ�������Ի����项�������ֶԻ�����Ϊ�������Ի����򡹡�Ϊ�˸�����ذ����͡��������������������dz����ֶԻ�����Ϊ����ӡ�Ի����򡹡�����������ΪAbortProc������ӡ�Ի����򣨽�����ΪPrintDlgProc����������ͬ�������ʽ���������һ��רҵ��Windowsʽ��ӡ��ʽ������ӡ�������ͱ���ӵ����������ʽ��

��������ʽ�Ľ������÷�ʽ���£�AbortProc�е�PeekMessage��Ȧ�ñ��޸ģ��Ա㽫��ϵͳģ̬�Ի������ѶϢ���͸��Ի������Ӵ�ѶϢ������ʽ��PrintDlgProc���봦��WM_COMMANDѶϢ���Լ�顸Cancel����ť��״̬�������Cancel��ť�����£��ͽ�һ������bUserAbort�����������ΪTRUE��AbortProc���ص�ֵ���ú�bUserAbort�෴�������ܻ��ǵã����AbortProc����TRUE�������ӡ������FALSE�������ӡ����PRINT2�У��������Ǵ���TRUE�����ڣ�ʹ��������ӡ�Ի������а��¡�Cancel����ťʱ������FALSE����ʽ13-7��ʾ��PRINT3��ʽʵ�������������ʽ��

 ï¿½ï¿½Ê½13-7  PRINT3
PRINT3.C
/*-----------------------------------------------------------------
   	PRINT3.C --	Printing with Dialog Box
               						(c) Charles Petzold, 1998
-------------------------------------------------------------------*/
#include <windows.h>
HDC 	GetPrinterDC (void) ;              		// in GETPRNDC.C
void	PageGDICalls (HDC, int, int) ;     		// in PRINT.C
HINSTANCE hInst ;
TCHAR     		szAppName[] = TEXT ("Print3") ;
TCHAR     		szCaption[] = TEXT ("Print Program 3 (Dialog Box)") ;
BOOL bUserAbort ;
HWND hDlgPrint ;
BOOL CALLBACK PrintDlgProc (HWND hDlg, UINT message, 
                            WPARAM wParam, LPARAM lParam)
{
     	switch (message)
     	{
	case	WM_INITDIALOG:
          			SetWindowText (hDlg, szAppName) ;
          			EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE, MF_GRAYED) ;
          			return TRUE ;
          
     	case 	WM_COMMAND:
          			bUserAbort = TRUE ;
          			EnableWindow (GetParent (hDlg), TRUE) ;
          			DestroyWindow (hDlg) ;
          			hDlgPrint = NULL ;
          			return TRUE ;
     	}
     	return FALSE ;
}
BOOL CALLBACK AbortProc (HDC hdcPrn, int iCode)
{
     	MSG msg ;
     	while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     	{
          		if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
          		{
               			TranslateMessage (&msg) ;
               			DispatchMessage (&msg) ;
         	 	}
     	}
  	return !bUserAbort ;
}
BOOL PrintMyPage (HWND hwnd)
{
     	static DOCINFO di = { sizeof (DOCINFO), TEXT ("Print3: Printing") } ;
     	BOOL           			bSuccess = TRUE ;
     	HDC            			hdcPrn ;
     	int            			xPage, yPage ;
     
     	if (NULL == (hdcPrn = GetPrinterDC ()))
          			return FALSE ;
     	xPage = GetDeviceCaps (hdcPrn, HORZRES) ;
     	yPage = GetDeviceCaps (hdcPrn, VERTRES) ;
     
     	EnableWindow (hwnd, FALSE) ;
     	bUserAbort = FALSE ;
     	hDlgPrint = CreateDialog (hInst, TEXT ("PrintDlgBox"), 
                               						hwnd, PrintDlgProc) ;
    	SetAbortProc (hdcPrn, AbortProc) ;
     	if (StartDoc (hdcPrn, &di) > 0)
     	{
          		if (StartPage (hdcPrn) > 0)
          		{
               			PageGDICalls (hdcPrn, xPage, yPage) ;
               				if (EndPage (hdcPrn) > 0)
                    						EndDoc (hdcPrn) ;
               			else
                    				bSuccess = FALSE ;
          		}
     	}
     	else
          				bSuccess = FALSE ;
     	if (!bUserAbort)
     {
          			EnableWindow (hwnd, TRUE) ;
          			DestroyWindow (hDlgPrint) ;
     }
     
  	DeleteDC (hdcPrn) ;
    	return bSuccess && !bUserAbort ;
}
 PRINT.RC ��ժ¼��
//Microsoft Developer Studio generated resource script.
#include "resource.h"
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
// Dialog
PRINTDLGBOX DIALOG DISCARDABLE  20, 20, 186, 63
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
FONT 8, "MS Sans Serif"
BEGIN
 	PUSHBUTTON      			"Cancel",IDCANCEL,67,42,50,14
    	CTEXT           					"Cancel Printing",IDC_STATIC,7,21,172,8
END

�����ʹ��PRINT3����ô�����ʱ��ͣʹ��Ļ����ӡ������ֻ������ӡ���г�ʽ��PRINT3�н�������ʱ�ſɼ����ġ�Cancel����ť���ܻ�ܿ���ʧ����������û�л���ȥ���������������Cancel����ťʱ��ӡ����������ֹ���ر�����һ������ӡ�����ϣ�����Ҫ���ȡ�ӡ������һ���ڲ�����������ӡ����ֹ֮ͣǰ���е����ϱ���ȫ���ͳ�������Cancel��ֻ�Ǹ���GDI��Ҫ��ӡ�����Ļ��������͸�������϶��ѡ�

PRINT3�������������������һ���ǽ���bUserAbort�IJ��ֱ�������һ���ǽ���hDlgPrint�ĶԻ������Ӵ����š�PrintMyPage��ʽ��bUserAbort��ʼ��ΪFALSE����PRINT2һ������ʽ�����Ӵ��Dz���������ѶϢ�ġ�ָ��AbortProc��ָ�����SetAbortProc�����У���ָ��PrintDlgProc��ָ�����CreateDialog�����С�CreateDialog���ص��Ӵ����Ŵ�����hDlgPrint�С�

���ڣ�AbortProc�е�ѶϢ��Ȧ���£�

while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
{
     	if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
     	{
          		TranslateMessage (&msg) ;
          		DispatchMessage (&msg) ;
     	}
}
return !bUserAbort ;

ֻ����bUserAbortΪFALSE��Ҳ����ʹ���߻�û����ֹ��ӡ����ʱ����γ�ʽ��Ż����PeekMessage��IsDialogMessage��ʽ������ѶϢ���͸���ϵͳģ̬�Ի����顣����ͨ�ķ�ϵͳģ̬�Ի�����һ�����Ի������Ӵ��Ĵ������������֮ǰ�ܵ���顣AbortProc�Ĵ���ֵ������bUserAbort�෴����ʼʱ��bUserAbortΪFALSE�����AbortProc����TRUE����ʾ����������ӡ������bUserAbort��������ӡ�Ի������б��趨ΪTRUE��

PrintDlgProc��ʽ���൱�򵥵ġ�����WM_INITDIALOGʱ���ú�ʽ���Ӵ������趨Ϊ��ʽ���ƣ�����ͣ��ϵͳ���ܱ��ϵġ�Close��ѡ����ʹ���߰����ˡ�Cancel��ť��PrintDlgProc���յ�WM_COMMANDѶϢ��

case 	WM_COMMAND :
     	bUserAbort = TRUE ;
     	EnableWindow (GetParent (hDlg), TRUE) ;
     	DestroyWindow (hDlg) ;
     	hDlgPrint = NULL ;
     	return TRUE ;

��bUserAbort�趨ΪTRUE����˵��ʹ�����Ѿ�����ȡ����ӡ���������Ӵ������������Ի����鱻�������˳������������Ǻ���Ҫ�ģ�������Windows��ִ��������ʽ֮һ����ɻ��ʽ�������ij�ʽ����ʧ�������У�����ͨ�������һ������hDlgPrint�趨ΪNULL����ֹ��ѶϢ��Ȧ�к���IsDialogMessage��

ֻ����AbortProc��PeekMessage�ҵ�ѶϢ������IsDialogMessage�����Ǵ��͸��Ի������Ӵ�ѶϢ������ʽʱ������Ի�����Ž���ѶϢ��ֻ����GDIģ�鴦��EndPage��ʽʱ���ź���AbortProc�����GDI����AbortProc�Ĵ���ֵ��FALSE����������Ȩ��EndPage���ص�PrintMyPage���������ش����롣���ˣ�PrintMyPage��Ϊ��ӡҳ�Ѿ������ˣ�������EndDoc��ʽ�����ǣ����GDIģ�黹û����ɶ�EndPage���еĴ��������Բ�����ӡ��ʲô��������

��Щ��������д���ɡ����ʹ����û�ڶԻ�������ȡ����ӡ��ҵ����ô�Ի�������Ȼ����ʾ����PrintMyPage���������������Ӵ�������Ի����飺

if (!bUserAbort)
{
	EnableWindow (hwnd, TRUE) ;
	DestroyWindow (hDlgPrint) ;
}

����������֪ͨ��������ʲô�£�bUserAbort���Ը�����ʹ�����Ƿ���ֹ����ӡ��ҵ��bSuccess��������Ƿ���˹��ϣ�����������Щ��������������Ĺ�����PrintMyPageֻ�򵥵ض����ǽ����߼��ϵ�AND���㣬Ȼ���ֵ���ظ�WndProc��

return bSuccess && !bUserAbort ;

ΪPOPPAD������ӡ����
��

����׼����POPPAD��ʽ��������ӡ���ܣ���������POPPAD������ϡ�����Ҫ��ʮһ���еĸ���POPPAD���������⣬����Ҫ��ʽ13-8�е�POPPRNT.C������

 ï¿½ï¿½Ê½13-8  POPPRNT
POPPRNT.C
/*---------------------------------------------------------------------
   	POPPRNT.C -- Popup Editor Printing Functions
-----------------------------------------------------------------------*/
#include <windows.h>
#include <commdlg.h>
#include "resource.h"
BOOL bUserAbort ;
HWND hDlgPrint ;
BOOL CALLBACK PrintDlgProc (	HWND hDlg, UINT msg, WPARAM wParam,LPARAM lParam)
{
     	switch (msg)
     	{
     	case 	WM_INITDIALOG :
          			EnableMenuItem (GetSystemMenu (hDlg, FALSE), SC_CLOSE, MF_GRAYED) ;
          			return TRUE ;
          
     	case 	WM_COMMAND :
          			bUserAbort = TRUE ;
          			EnableWindow (GetParent (hDlg), TRUE) ;
          			DestroyWindow (hDlg) ;
          			hDlgPrint = NULL ;
          			return TRUE ;
     	}
     	return FALSE ;
}          
BOOL CALLBACK AbortProc (HDC hPrinterDC, int iCode)
{
     	MSG msg ;
     	while (!bUserAbort && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     	{
          		if (!hDlgPrint || !IsDialogMessage (hDlgPrint, &msg))
          		{
               			TranslateMessage (&msg) ;
               			DispatchMessage (&msg) ;
          		}
     	}
     	return !bUserAbort ;
}
BOOL PopPrntPrintFile (HINSTANCE hInst, HWND hwnd, HWND hwndEdit, 
                       								PTSTR szTitleName)
{
     	static DOCINFO  	di = { sizeof (DOCINFO) } ;
     	static PRINTDLG 	pd ;
     	BOOL            	bSuccess ;
     	int             	yChar, iCharsPerLine, iLinesPerPage, iTotalLines,
                     		iTotalPages, iPage, iLine, iLineNum ;
     	PTSTR           	pstrBuffer ;
     	TCHAR           	szJobName [64 + MAX_PATH] ;
     	TEXTMETRIC      	tm ;
     	WORD            	iColCopy, iNoiColCopy ;
          				// Invoke Print common dialog box
     
     	pd.lStructSize         	= 	sizeof (PRINTDLG) ;
     	pd.hwndOwner           	= 	hwnd ;
     	pd.hDevMode            	= 	NULL ;
     	pd.hDevNames           	= 	NULL ;
     	pd.hDC                 	= 	NULL ;
     	pd.Flags               	= 	PD_ALLPAGES | PD_COLLATE | 
                                    PD_RETURNDC | PD_NOSELECTION ;
     	pd.nFromPage           	= 	0 ;
     	pd.nToPage             	= 	0 ;
     	pd.nMinPage            	= 	0 ;
     	pd.nMaxPage            	= 	0 ;
     	pd.nCopies             	= 	1 ;
     	pd.hInstance           	= 	NULL ;
     	pd.lCustData           	= 	0L ;
     	pd.lpfnPrintHook       	= 	NULL ;
     	pd.lpfnSetupHook       	= 	NULL ;
     	pd.lpPrintTemplateName 	= 	NULL ;
     	pd.lpSetupTemplateName 	= 	NULL ;
     	pd.hPrintTemplate      	= 	NULL ;
     	pd.hSetupTemplate      	= 	NULL ;
     
   	if 	(!PrintDlg (&pd))
          			return TRUE ;
     
   	if 	(0 == (iTotalLines = SendMessage (hwndEdit, EM_GETLINECOUNT, 0, 0)))
          			return TRUE ;
          				// Calculate necessary metrics for file 
     
     	GetTextMetrics (pd.hDC, &tm) ;
     	yChar = tm.tmHeight + tm.tmExternalLeading ;
     
     	iCharsPerLine = GetDeviceCaps (pd.hDC, HORZRES) / tm.tmAveCharWidth ;
     	iLinesPerPage = GetDeviceCaps (pd.hDC, VERTRES) / yChar ;
	iTotalPages   	= (iTotalLines + iLinesPerPage - 1) / iLinesPerPage ;
          				// Allocate a buffer for each line of text
     
     	pstrBuffer 	= malloc (sizeof (TCHAR) * (iCharsPerLine + 1)) ;
          				// Display the printing dialog box
     
     	EnableWindow (hwnd, FALSE) ;
     	bSuccess   			= TRUE ;
     	bUserAbort 		= FALSE ;
     	hDlgPrint 		= CreateDialog (hInst, TEXT ("PrintDlgBox"), 
                               							hwnd, PrintDlgProc) ;
     	SetDlgItemText (hDlgPrint, IDC_FILENAME, szTitleName) ;
     	SetAbortProc (pd.hDC, AbortProc) ;
          				// Start the document
     	GetWindowText (hwnd, szJobName, sizeof (szJobName)) ;
     	di.lpszDocName = szJobName ;
     	if (StartDoc (pd.hDC, &di) > 0)
     	{
               				// Collation requires this loop and iNoiColCopy
          		for (iColCopy = 0 ;
               				iColCopy < ((WORD) pd.Flags & PD_COLLATE ? pd.nCopies : 1) ;
               				iColCopy++)
          		{
               			for (iPage = 0 ; iPage < iTotalPages ; iPage++)
               			{
                for (iNoiColCopy = 0 ;
                     iNoiColCopy < (pd.Flags & PD_COLLATE ? 1 : pd.nCopies);
                         						iNoiColCopy++)
                    				{
                              						// Start the page
                         					if (StartPage (pd.hDC) < 0)
                         					{
                              							bSuccess = FALSE ;
                              							break ;
                         					}
                // For each page, print the lines
               for (iLine = 0 ; iLine < iLinesPerPage ; iLine++)
                         					{
                iLineNum = iLinesPerPage * iPage + iLine ;
                if (iLineNum > iTotalLines)
                                   					break ;
                *(int *) pstrBuffer = iCharsPerLine ;
                TextOut	(pd.hDC, 0, yChar * iLine, pstrBuffer,
                (int) SendMessage (hwndEdit, EM_GETLINE,
                    (WPARAM) iLineNum, (LPARAM) pstrBuffer));
                        						}
                      	   
                 if (EndPage (pd.hDC) < 0)
                         						{
                  bSuccess = FALSE ;
                  break ;
                         						}
                         
                  if (bUserAbort)
                  break ;
                						}
                    
                  if (!bSuccess || bUserAbort)
                  break ;
               				}
               
               	 if (!bSuccess || bUserAbort)
                  break ;
          			}
    	}
     	else
          			bSuccess = FALSE ;
     	if 	 (bSuccess)
          			EndDoc (pd.hDC) ;
     	
     	if 	 (!bUserAbort)
     {
          			EnableWindow (hwnd, TRUE) ;
          			DestroyWindow (hDlgPrint) ;
     	}
     
     	free (pstrBuffer) ;
     	DeleteDC (pd.hDC) ;
     
     	return bSuccess && !bUserAbort ;
}

��POPPAD��������Windows�߽׹������򻯳�ʽ�ķ���һ�£�POPPRNT.C����չʾ��ʹ��PrintDlg��ʽ�ķ����������ʽ������ͨ�öԻ������ʽ�⣨common dialog box library���У�ʹ��һ��PRINTDLG��̬�Ľṹ��

ͨ������ʽ�ġ�File�����ܱ����и���Print��ѡ���ʹ����ѡ�С�Print��ѡ��ʱ����ʽ���Գ�ʼ��PRINTDLG�ṹ����λ��������PrintDlg��

PrintDlg��ʾһ���Ի����飬������ʹ����ѡ����ӡҳ�ķ�Χ����ˣ�����Ի������ر��������POPPAD��������ӡ��ҳ�ļ��ij�ʽ�����ֶԻ�����ͬʱҲ������һ��ȷ�����������ı༭������Ϊ��Collate�������ӡ�����ĺ�ȡ���顣�������ӡ��Ӱ�����������ҳ��˳�����磬����ļ���3ҳ��ʹ����Ҫ����ӡ���ݸ������������ʽ��������˳��֮һ��ӡ���ǡ�ѡ�������ӡ��ĸ�����ҳ��˳��Ϊ1��2��3��1��2��3��1��2��3��δѡ�������ӡ�ĸ�����ҳ��˳����1��1��1��2��2��2��3��3��3����ʽ������Ӧ��������ξ�������ȷ��˳����ӡ������

����Ի�����Ҳ����ʹ����ѡ����ڶ�ӡ������������һ�����Ϊ��Properties���İ�ť�����������豸ģʽ�Ի����顣��������������ʹ����ѡ��ֱӡ���ӡ��

��PrintDlg��ʽ�����ᣬPRINTDLG�ṹ����λָ����ӡҳ�ķ�Χ���Ƿ�Զ���������������ӡ������ṹͬʱҲ������׼��ʹ�õ�ӡ����װ�����ݴ��š�

��POPPRNT.C�У�PopPrntPrintFile��ʽ����ʹ�����ڡ�File�����ܱ���ѡ�С�Print��ѡ��ʱ������POPPAD���У�����PrintDlg��Ȼ�Ὺʼ��ӡ������PopPrntPrintFile���ijЩ���㣬��ȷ��һ�������ɶ�����Ԫ��һҳ�����ɶ����С���������漰������GetDeviceCaps��ȷ��ҳ�Ľ����ȣ�����GetTextMetrics��ȷ����Ԫ�Ĵ�С��

�����ʽͨ������һ��EM_GETLINECOUNTѶϢ���༭��������ȡ���ļ��е����������ڱ���iTotalLines�У�������������ݵĻ����������ھֲ��������С���ÿһ�У��������ĵ�һ���ֱ��趨Ϊ��������Ԫ����Ŀ����EM_GETLINEѶϢ���͸��༭��������԰�һ�и��Ƶ��������У�Ȼ����TextOut����һ���͵�ӡ����װ�������У�POPPRNT.C��û�д������Գ�����ӡ���ȵ����ֻ�����һ��ȥ�������ڵ�ʮ�������ǻ����������������еļ�������

Ϊ��ȷ������������Ӧע����ӡ���ֵĴ�����ʽ��������for��Ȧ����һ��for��Ȧʹ����һ������iColCopy�ı�������ʹ����ָ�������������ӡʱ�������������á��ڶ���for��Ȧʹ����һ������iNonColCopy�ı����������Ը������������ӡʱ�����������á�

���StartPage��EndPage����һ�����󣬻������bUserAbortΪTRUE����ô�����ʽ�˳�����ҳ�ŵ��Ǹ�for��Ȧ�������������Ĵ���ֵ��FALSE����EndPage�����ش�������������ԭ������һҳ��ʼ֮ǰ��Ҫֱ�Ӳ���bUserAbort�����û�б�����������EndDoc���У�

if (!bError)
     	EndDoc (hdcPrn) ;

��������ͨ����ӡ��ҳ����������POPPAD�������Դ���ӡ�����Ӵ��м�����ӡ��չ�������GDI�������һ��EndPage����֮�ᣬ������ӡ�ĵ�������ʾ����ӡ�����Ӵ��С���ʱ��Ļ����ӡ��ʽ��ʼ�ѵ������͵�ӡ������Ȼ�ᣬ�����POPPAD��ȡ����ӡ��ҵ����ôĻ����ӡ��ʽ����ֹ��ӡ����Ҳ���Ƿ������򴫻�FALSE�Ľ������������������ӡ�����Ӵ��У���Ҳ����͸���ӡ�Document�����ܱ���ѡ��Cancel Printing����ȡ����ӡ��ҵ������������£� POPPAD�е�EndPage���лᴫ��һ������

Windows�ij�ʽ��Ƶ����־����ᱧסAbortDoc��ʽ���ţ���ʵ���������ʽ����������ӡ��ʹ�á�����POPPAD�п�����������ʹ���߼�����ʱ����ȡ����ӡ��ҵ������ͨ��POPPAD����ӡ�Ի����鼰ͨ����ӡ�����Ӵ��������ַ���������Ҫ��ʽʹ��AbortDoc��ʽ�� POPPAD������AbortDoc��Ψһʱ�����ڶ�StartDoc�ĺ��кͶ�EndPage�ĵ�һ������֮�䣬���dz�ʽ�ܿ�ͻ�ִ�й�ȥ������������ҪAbortDoc��

ͼ13-3��ʾ����ȷ��ӡ��ҳ�ļ�֮��ӡ��ʽ�ĺ���˳�򡣼��bUserAbort��ֵ�Ƿ�ΪTRUE�����λ������ÿ��EndPage��ʽ֮�ᡣֻ�е�����ǰ����ӡ��ʽ�ĺ���û�в�������ʱ����ʹ��EndDoc��ʽ��ʵ���ϣ�����κ�һ����ӡ��ʽ�ĺ��г��ִ�����ô���ݾͽ����ˣ�ͬʱ��Ҳ���Իؼ��ˡ�


��

ͼ13-3 ��ӡһ���ļ�ʱ�ĺ�ʽ����˳��
��