printer.cpp

Windows 图形编程 书籍

	SetBkMode(hDC, TRANSPARENT);
	SetTextAlign(hDC, TA_LEFT | TA_BASELINE);
	int y = ONEINCH/2;
	
	// use normal GDI TextOut
	SIZE size;
	GetTextExtentPoint32(hDC, mess, _tcslen(mess), & size);
	MoveToEx(hDC, 0, y, NULL); LineTo(hDC, size.cx, y);

	TextOut(hDC, 0, y, mess, _tcslen(mess));

	TCHAR temp[64];
	wsprintf(temp, "size = { %d, %d }", size.cx, size.cy);
	TextOut(hDC, 0, y + size.cy, temp, _tcslen(temp));

	y += size.cy * 3;

	KTextFormator format;

	format.SetupPixel(hDC, (HFONT) font.m_hObj, (float)(10.0 * ONEINCH/72));

	float wid, hei;
	format.GetTextExtent(hDC, mess, _tcslen(mess), wid, hei);
	
	MoveToEx(hDC, 0, y, NULL);
	LineTo(hDC, (int) wid, y);
	format.TextOut(hDC, 0, y, mess, _tcslen(mess));
	
	sprintf(temp, "size = { %5.3f, %5.3f }", wid, hei);
	TextOut(hDC, 0, y + size.cy, temp, _tcslen(temp));
}


class KTestPageCanvas : public KPageCanvas
{
	int m_demo;

	void GetWndClassEx(WNDCLASSEX & wc)
	{
		KPageCanvas::GetWndClassEx(wc);

		wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_PRINT));
	}

public:
	virtual void UponDrawPage(HDC hDC, const RECT * rcPaint, int width, int height, int pageno)
	{
		switch ( m_demo )
		{
			case 0:
				KSurface::UponDrawPage(hDC, rcPaint, width, height, pageno);
				break;

			case IDM_VIEW_LINECURVE:
				Demo_LineCurve(hDC, rcPaint, width, height);
				break;

			case IDM_VIEW_AREAFILL:
				Demo_AreaFill(hDC, rcPaint, width, height);
				break;

			case IDM_VIEW_BITMAP:
				Demo_Bitmap(hDC, rcPaint, width, height, m_hInst);
				break;

			case IDM_VIEW_TEXT:
				Demo_Text(hDC, rcPaint, width, height);
				break;
		}
	}

	virtual int OnCommand(int cmd, HWND hWnd)
	{
		switch ( cmd )
		{
			case IDM_VIEW_LINECURVE:
			case IDM_VIEW_AREAFILL:
			case IDM_VIEW_BITMAP:
			case IDM_VIEW_TEXT:
				if ( cmd==m_demo )
					return View_NoChange;
				else
				{
					m_demo = cmd;
					return View_Redraw;
				}
				break;

			case IDM_VIEW_ZOOM500  : return SetZoom(500);
			case IDM_VIEW_ZOOM400  : return SetZoom(400);
			case IDM_VIEW_ZOOM200  : return SetZoom(200); 
			case IDM_VIEW_ZOOM150  : return SetZoom(150); 
			case IDM_VIEW_ZOOM100  : return SetZoom(100);
			case IDM_VIEW_ZOOM75   : return SetZoom( 75);
			case IDM_VIEW_ZOOM50   : return SetZoom( 50);
			case IDM_VIEW_ZOOM25   : return SetZoom( 25);
			case IDM_VIEW_ZOOM10   : return SetZoom( 10);

			case IDM_FILE_PRINT    : UponFilePrint();	  GetDimension(); return View_Resize;
			case IDM_FILE_PAGESETUP: UponFilePageSetup(); GetDimension(); return View_Resize;

			case IDM_FILE_PROPERTY:  
			{
				int nControlID[] = { IDC_LIST, IDC_DEFAULT, IDC_PRINTERS, 
					IDC_PRINTERPROPERTIES, IDC_ADVANCEDDOCUMENTPROPERTIES, IDC_DOCUMENTPROPERTIES };
			
				ShowProperty(m_OutputSetup, m_hInst, nControlID, IDD_PROPERTY);
			}
		}

		return View_NoChange;
	}
	
	KTestPageCanvas(HBRUSH hBackground) : KPageCanvas(hBackground)
	{
		m_demo = 0;
	}
};


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

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


BOOL SendFile(HANDLE hOutput, const TCHAR * filename, bool bPrinter)
{
	HANDLE hFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, 
						NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	if ( hFile==INVALID_HANDLE_VALUE )
		return FALSE;

	char buffer[1024];

	for (int size = GetFileSize(hFile, NULL); size; )
	{
		DWORD dwRead = 0, dwWritten = 0;

		if ( ! ReadFile(hFile, buffer, min(size, sizeof(buffer)), & dwRead, NULL) )
			break;

		if ( bPrinter )
			WritePrinter(hOutput, buffer, dwRead, & dwWritten);
		else
			WriteFile(hOutput, buffer, dwRead, & dwWritten, NULL);
		
		size -= dwRead;
	}

	return TRUE;
}

void Demo_WritePort(void)
{
	KFileDialog fd;

	if ( fd.GetOpenFileName(NULL, "prn", "Raw printer data") )
	{
		HANDLE hPort = CreateFile("lpt1:", GENERIC_WRITE, FILE_SHARE_READ,
		                   NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

		if ( hPort!=INVALID_HANDLE_VALUE )
		{
			SendFile(hPort, fd.m_TitleName, false);
			CloseHandle(hPort);
		}
	}
}

void Demo_WritePrinter(void)
{
	PRINTDLG  pd;

	memset(&pd, 0, sizeof(PRINTDLG));
	pd.lStructSize = sizeof(PRINTDLG);

	if ( PrintDlg(&pd)==IDOK )
	{
		HANDLE hPrinter;

		DEVMODE * pDevMode = (DEVMODE *) GlobalLock(pd.hDevMode);

		PRINTER_DEFAULTS prn;
		prn.pDatatype     = "NT EMF 1.008";
		prn.pDevMode      = pDevMode;
		prn.DesiredAccess = PRINTER_ACCESS_USE;

		if ( OpenPrinter((char *) pDevMode->dmDeviceName, & hPrinter, & prn) )
		{
			KFileDialog fd;

			if ( fd.GetOpenFileName(NULL, "spl", "Windows 2000 EMF Spool file") )
			{
				DOC_INFO_1 docinfo;

				docinfo.pDocName    = "Testing WritePrinter";
				docinfo.pOutputFile = NULL;
				docinfo.pDatatype   = "NT EMF 1.008";

				StartDocPrinter(hPrinter, 1, (BYTE *) & docinfo);
				StartPagePrinter(hPrinter);
				
				SendFile(hPrinter, fd.m_TitleName, true);
				
				EndPagePrinter(hPrinter);
				EndDocPrinter(hPrinter);
			}

			ClosePrinter(hPrinter);
		}

		if ( pd.hDevMode )	GlobalFree(pd.hDevMode);
		if ( pd.hDevNames ) GlobalFree(pd.hDevNames);
	}
}


void Demo_OutputSetup(bool bShowDialog)
{
	KOutputSetup setup;

	DWORD flags = PD_RETURNDC;
	if ( ! bShowDialog )
		flags |= PD_RETURNDEFAULT;

	if ( IDOK == setup.PrintDialog(flags) )
	{
		HDC hDC = setup.GetPrinterDC();
		
		TCHAR temp[32];
		wsprintf(temp, "Printer DC=%x", hDC);
		MessageBox(NULL, temp, "KOutputSetup", MB_OK);
	}
}

class KMyMDIFrame : public KMDIFrame
{
	void CreateMDIChild(KCanvas * canvas, const TCHAR * klass, const TCHAR * title)
	{
		MDICREATESTRUCT mdic;

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

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

	BOOL CreatePageCanvas(const TCHAR * Title)
	{
		KPageCanvas  * pCanvas;
		
		pCanvas = new KTestPageCanvas(GetSysColorBrush(COLOR_BTNSHADOW));

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

			delete pCanvas;
		}

		return FALSE;
	}

	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam)
	{
		switch ( LOWORD(wParam) )
		{
			case IDM_FILE_DIRECTPRINT:
				Demo_WritePort();
				return TRUE;

			case IDM_FILE_OPENPRINTER:
				Demo_WritePrinter();
				return TRUE;

			case IDM_FILE_PRINTDIALOGDEFAULT:
				Demo_OutputSetup(false);
				return TRUE;

			case IDM_FILE_PRINTDIALOGPROMPT:
				Demo_OutputSetup(true);
				return TRUE;

			case IDM_FILE_DEFAULTPRINTERDC:
				{
					TCHAR name[64];

					DWORD size = 64;
					GetDefaultPrinter(name, & size);

					HDC hDC = CreateDC(NULL, name, NULL, NULL);
					
					if ( hDC )
						MessageBox(NULL, "Printer DC Created", name, MB_OK);
					DeleteDC(hDC);
				}
				return TRUE;

			case IDM_FILE_SIMPLEPRINT:
				SimplePrint(2);
				return TRUE;

			case IDM_FILE_NEW:
			{
				CreatePageCanvas(_T("Test Printer "));
				return TRUE;
			}
		}

		return FALSE;
	}

	virtual LRESULT WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		return KMDIFrame::WndProc(hWnd, uMsg, wParam, lParam);
	}

	void GetWndClassEx(WNDCLASSEX & wc)
	{
		KMDIFrame::GetWndClassEx(wc);

		wc.hIcon = LoadIcon(m_hInst, MAKEINTRESOURCE(IDI_PRINT));
	}

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


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


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

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

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

    frame.MessageLoop();

	return 0;
}