| // Windows Template Library - WTL version 8.0 |
| // Copyright (C) Microsoft Corporation. All rights reserved. |
| // |
| // This file is a part of the Windows Template Library. |
| // The use and distribution terms for this software are covered by the |
| // Microsoft Permissive License (Ms-PL) which can be found in the file |
| // Ms-PL.txt at the root of this distribution. |
| |
| #ifndef __ATLPRINT_H__ |
| #define __ATLPRINT_H__ |
| |
| #pragma once |
| |
| #ifndef __cplusplus |
| #error ATL requires C++ compilation (use a .cpp suffix) |
| #endif |
| |
| #ifdef _WIN32_WCE |
| #error atlprint.h is not supported on Windows CE |
| #endif |
| |
| #ifndef __ATLAPP_H__ |
| #error atlprint.h requires atlapp.h to be included first |
| #endif |
| |
| #ifndef __ATLWIN_H__ |
| #error atlprint.h requires atlwin.h to be included first |
| #endif |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Classes in this file: |
| // |
| // CPrinterInfo<t_nInfo> |
| // CPrinterT<t_bManaged> |
| // CDevModeT<t_bManaged> |
| // CPrinterDC |
| // CPrintJobInfo |
| // CPrintJob |
| // CPrintPreview |
| // CPrintPreviewWindowImpl<T, TBase, TWinTraits> |
| // CPrintPreviewWindow |
| // CZoomPrintPreviewWindowImpl<T, TBase, TWinTraits> |
| // CZoomPrintPreviewWindow |
| |
| namespace WTL |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CPrinterInfo - This class wraps all of the PRINTER_INFO_* structures |
| // and provided by ::GetPrinter. |
| |
| template <unsigned int t_nInfo> |
| class _printer_info |
| { |
| public: |
| typedef void infotype; |
| }; |
| |
| template <> class _printer_info<1> { public: typedef PRINTER_INFO_1 infotype; }; |
| template <> class _printer_info<2> { public: typedef PRINTER_INFO_2 infotype; }; |
| template <> class _printer_info<3> { public: typedef PRINTER_INFO_3 infotype; }; |
| template <> class _printer_info<4> { public: typedef PRINTER_INFO_4 infotype; }; |
| template <> class _printer_info<5> { public: typedef PRINTER_INFO_5 infotype; }; |
| template <> class _printer_info<6> { public: typedef PRINTER_INFO_6 infotype; }; |
| template <> class _printer_info<7> { public: typedef PRINTER_INFO_7 infotype; }; |
| // these are not in the old (vc6.0) headers |
| #ifdef _ATL_USE_NEW_PRINTER_INFO |
| template <> class _printer_info<8> { public: typedef PRINTER_INFO_8 infotype; }; |
| template <> class _printer_info<9> { public: typedef PRINTER_INFO_9 infotype; }; |
| #endif // _ATL_USE_NEW_PRINTER_INFO |
| |
| |
| template <unsigned int t_nInfo> |
| class CPrinterInfo |
| { |
| public: |
| // Data members |
| typename _printer_info<t_nInfo>::infotype* m_pi; |
| |
| // Constructor/destructor |
| CPrinterInfo() : m_pi(NULL) |
| { } |
| |
| CPrinterInfo(HANDLE hPrinter) : m_pi(NULL) |
| { |
| GetPrinterInfo(hPrinter); |
| } |
| |
| ~CPrinterInfo() |
| { |
| Cleanup(); |
| } |
| |
| // Operations |
| bool GetPrinterInfo(HANDLE hPrinter) |
| { |
| Cleanup(); |
| return GetPrinterInfoHelper(hPrinter, (BYTE**)&m_pi, t_nInfo); |
| } |
| |
| // Implementation |
| void Cleanup() |
| { |
| delete [] (BYTE*)m_pi; |
| m_pi = NULL; |
| } |
| |
| static bool GetPrinterInfoHelper(HANDLE hPrinter, BYTE** pi, int nIndex) |
| { |
| ATLASSERT(pi != NULL); |
| DWORD dw = 0; |
| BYTE* pb = NULL; |
| ::GetPrinter(hPrinter, nIndex, NULL, 0, &dw); |
| if (dw > 0) |
| { |
| ATLTRY(pb = new BYTE[dw]); |
| if (pb != NULL) |
| { |
| memset(pb, 0, dw); |
| DWORD dwNew; |
| if (!::GetPrinter(hPrinter, nIndex, pb, dw, &dwNew)) |
| { |
| delete [] pb; |
| pb = NULL; |
| } |
| } |
| } |
| *pi = pb; |
| return (pb != NULL); |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CPrinter - Wrapper class for a HANDLE to a printer |
| |
| template <bool t_bManaged> |
| class CPrinterT |
| { |
| public: |
| // Data members |
| HANDLE m_hPrinter; |
| |
| // Constructor/destructor |
| CPrinterT(HANDLE hPrinter = NULL) : m_hPrinter(hPrinter) |
| { } |
| |
| ~CPrinterT() |
| { |
| ClosePrinter(); |
| } |
| |
| // Operations |
| CPrinterT& operator =(HANDLE hPrinter) |
| { |
| if (hPrinter != m_hPrinter) |
| { |
| ClosePrinter(); |
| m_hPrinter = hPrinter; |
| } |
| return *this; |
| } |
| |
| bool IsNull() const { return (m_hPrinter == NULL); } |
| |
| bool OpenPrinter(HANDLE hDevNames, const DEVMODE* pDevMode = NULL) |
| { |
| bool b = false; |
| DEVNAMES* pdn = (DEVNAMES*)::GlobalLock(hDevNames); |
| if (pdn != NULL) |
| { |
| LPTSTR lpszPrinterName = (LPTSTR)pdn + pdn->wDeviceOffset; |
| b = OpenPrinter(lpszPrinterName, pDevMode); |
| ::GlobalUnlock(hDevNames); |
| } |
| return b; |
| } |
| |
| bool OpenPrinter(LPCTSTR lpszPrinterName, const DEVMODE* pDevMode = NULL) |
| { |
| ClosePrinter(); |
| PRINTER_DEFAULTS pdefs = { NULL, (DEVMODE*)pDevMode, PRINTER_ACCESS_USE }; |
| ::OpenPrinter((LPTSTR) lpszPrinterName, &m_hPrinter, (pDevMode == NULL) ? NULL : &pdefs); |
| |
| return (m_hPrinter != NULL); |
| } |
| |
| bool OpenPrinter(LPCTSTR lpszPrinterName, PRINTER_DEFAULTS* pprintdefs) |
| { |
| ClosePrinter(); |
| ::OpenPrinter((LPTSTR) lpszPrinterName, &m_hPrinter, pprintdefs); |
| return (m_hPrinter != NULL); |
| } |
| |
| bool OpenDefaultPrinter(const DEVMODE* pDevMode = NULL) |
| { |
| ClosePrinter(); |
| const int cchBuff = 512; |
| TCHAR buffer[cchBuff]; |
| buffer[0] = 0; |
| ::GetProfileString(_T("windows"), _T("device"), _T(",,,"), buffer, cchBuff); |
| int nLen = lstrlen(buffer); |
| if (nLen != 0) |
| { |
| LPTSTR lpsz = buffer; |
| while (*lpsz) |
| { |
| if (*lpsz == _T(',')) |
| { |
| *lpsz = 0; |
| break; |
| } |
| lpsz = CharNext(lpsz); |
| } |
| PRINTER_DEFAULTS pdefs = { NULL, (DEVMODE*)pDevMode, PRINTER_ACCESS_USE }; |
| ::OpenPrinter(buffer, &m_hPrinter, (pDevMode == NULL) ? NULL : &pdefs); |
| } |
| return m_hPrinter != NULL; |
| } |
| |
| void ClosePrinter() |
| { |
| if (m_hPrinter != NULL) |
| { |
| if (t_bManaged) |
| ::ClosePrinter(m_hPrinter); |
| m_hPrinter = NULL; |
| } |
| } |
| |
| bool PrinterProperties(HWND hWnd = NULL) |
| { |
| if (hWnd == NULL) |
| hWnd = ::GetActiveWindow(); |
| return !!::PrinterProperties(hWnd, m_hPrinter); |
| } |
| |
| HANDLE CopyToHDEVNAMES() const |
| { |
| HANDLE h = NULL; |
| CPrinterInfo<5> pinfon5; |
| CPrinterInfo<2> pinfon2; |
| LPTSTR lpszPrinterName = NULL; |
| // Some printers fail for PRINTER_INFO_5 in some situations |
| if (pinfon5.GetPrinterInfo(m_hPrinter)) |
| lpszPrinterName = pinfon5.m_pi->pPrinterName; |
| else if (pinfon2.GetPrinterInfo(m_hPrinter)) |
| lpszPrinterName = pinfon2.m_pi->pPrinterName; |
| if (lpszPrinterName != NULL) |
| { |
| int nLen = sizeof(DEVNAMES) + (lstrlen(lpszPrinterName) + 1) * sizeof(TCHAR); |
| h = ::GlobalAlloc(GMEM_MOVEABLE, nLen); |
| BYTE* pv = (BYTE*)::GlobalLock(h); |
| DEVNAMES* pdev = (DEVNAMES*)pv; |
| if (pv != NULL) |
| { |
| memset(pv, 0, nLen); |
| pdev->wDeviceOffset = sizeof(DEVNAMES) / sizeof(TCHAR); |
| pv = pv + sizeof(DEVNAMES); // now points to end |
| SecureHelper::strcpy_x((LPTSTR)pv, lstrlen(lpszPrinterName) + 1, lpszPrinterName); |
| ::GlobalUnlock(h); |
| } |
| } |
| return h; |
| } |
| |
| HDC CreatePrinterDC(const DEVMODE* pdm = NULL) const |
| { |
| CPrinterInfo<5> pinfo5; |
| CPrinterInfo<2> pinfo2; |
| HDC hDC = NULL; |
| LPTSTR lpszPrinterName = NULL; |
| // Some printers fail for PRINTER_INFO_5 in some situations |
| if (pinfo5.GetPrinterInfo(m_hPrinter)) |
| lpszPrinterName = pinfo5.m_pi->pPrinterName; |
| else if (pinfo2.GetPrinterInfo(m_hPrinter)) |
| lpszPrinterName = pinfo2.m_pi->pPrinterName; |
| if (lpszPrinterName != NULL) |
| hDC = ::CreateDC(NULL, lpszPrinterName, NULL, pdm); |
| return hDC; |
| } |
| |
| HDC CreatePrinterIC(const DEVMODE* pdm = NULL) const |
| { |
| CPrinterInfo<5> pinfo5; |
| CPrinterInfo<2> pinfo2; |
| HDC hDC = NULL; |
| LPTSTR lpszPrinterName = NULL; |
| // Some printers fail for PRINTER_INFO_5 in some situations |
| if (pinfo5.GetPrinterInfo(m_hPrinter)) |
| lpszPrinterName = pinfo5.m_pi->pPrinterName; |
| else if (pinfo2.GetPrinterInfo(m_hPrinter)) |
| lpszPrinterName = pinfo2.m_pi->pPrinterName; |
| if (lpszPrinterName != NULL) |
| hDC = ::CreateIC(NULL, lpszPrinterName, NULL, pdm); |
| return hDC; |
| } |
| |
| void Attach(HANDLE hPrinter) |
| { |
| ClosePrinter(); |
| m_hPrinter = hPrinter; |
| } |
| |
| HANDLE Detach() |
| { |
| HANDLE hPrinter = m_hPrinter; |
| m_hPrinter = NULL; |
| return hPrinter; |
| } |
| |
| operator HANDLE() const { return m_hPrinter; } |
| }; |
| |
| typedef CPrinterT<false> CPrinterHandle; |
| typedef CPrinterT<true> CPrinter; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CDevMode - Wrapper class for DEVMODE |
| |
| template <bool t_bManaged> |
| class CDevModeT |
| { |
| public: |
| // Data members |
| HANDLE m_hDevMode; |
| DEVMODE* m_pDevMode; |
| |
| // Constructor/destructor |
| CDevModeT(HANDLE hDevMode = NULL) : m_hDevMode(hDevMode) |
| { |
| m_pDevMode = (m_hDevMode != NULL) ? (DEVMODE*)::GlobalLock(m_hDevMode) : NULL; |
| } |
| |
| ~CDevModeT() |
| { |
| Cleanup(); |
| } |
| |
| // Operations |
| CDevModeT<t_bManaged>& operator =(HANDLE hDevMode) |
| { |
| Attach(hDevMode); |
| return *this; |
| } |
| |
| void Attach(HANDLE hDevModeNew) |
| { |
| Cleanup(); |
| m_hDevMode = hDevModeNew; |
| m_pDevMode = (m_hDevMode != NULL) ? (DEVMODE*)::GlobalLock(m_hDevMode) : NULL; |
| } |
| |
| HANDLE Detach() |
| { |
| if (m_hDevMode != NULL) |
| ::GlobalUnlock(m_hDevMode); |
| HANDLE hDevMode = m_hDevMode; |
| m_hDevMode = NULL; |
| return hDevMode; |
| } |
| |
| bool IsNull() const { return (m_hDevMode == NULL); } |
| |
| bool CopyFromPrinter(HANDLE hPrinter) |
| { |
| CPrinterInfo<2> pinfo; |
| bool b = pinfo.GetPrinterInfo(hPrinter); |
| if (b) |
| b = CopyFromDEVMODE(pinfo.m_pi->pDevMode); |
| return b; |
| } |
| |
| bool CopyFromDEVMODE(const DEVMODE* pdm) |
| { |
| if (pdm == NULL) |
| return false; |
| int nSize = pdm->dmSize + pdm->dmDriverExtra; |
| HANDLE h = ::GlobalAlloc(GMEM_MOVEABLE, nSize); |
| if (h != NULL) |
| { |
| void* p = ::GlobalLock(h); |
| SecureHelper::memcpy_x(p, nSize, pdm, nSize); |
| ::GlobalUnlock(h); |
| } |
| Attach(h); |
| return (h != NULL); |
| } |
| |
| bool CopyFromHDEVMODE(HANDLE hdm) |
| { |
| bool b = false; |
| if (hdm != NULL) |
| { |
| DEVMODE* pdm = (DEVMODE*)::GlobalLock(hdm); |
| b = CopyFromDEVMODE(pdm); |
| ::GlobalUnlock(hdm); |
| } |
| return b; |
| } |
| |
| HANDLE CopyToHDEVMODE() |
| { |
| if ((m_hDevMode == NULL) || (m_pDevMode == NULL)) |
| return NULL; |
| int nSize = m_pDevMode->dmSize + m_pDevMode->dmDriverExtra; |
| HANDLE h = ::GlobalAlloc(GMEM_MOVEABLE, nSize); |
| if (h != NULL) |
| { |
| void* p = ::GlobalLock(h); |
| SecureHelper::memcpy_x(p, nSize, m_pDevMode, nSize); |
| ::GlobalUnlock(h); |
| } |
| return h; |
| } |
| |
| // If this devmode was for another printer, this will create a new devmode |
| // based on the existing devmode, but retargeted at the new printer |
| bool UpdateForNewPrinter(HANDLE hPrinter) |
| { |
| bool bRet = false; |
| LONG nLen = ::DocumentProperties(NULL, hPrinter, NULL, NULL, NULL, 0); |
| CTempBuffer<DEVMODE, _WTL_STACK_ALLOC_THRESHOLD> buff; |
| DEVMODE* pdm = buff.AllocateBytes(nLen); |
| if(pdm != NULL) |
| { |
| memset(pdm, 0, nLen); |
| LONG l = ::DocumentProperties(NULL, hPrinter, NULL, pdm, m_pDevMode, DM_IN_BUFFER | DM_OUT_BUFFER); |
| if (l == IDOK) |
| bRet = CopyFromDEVMODE(pdm); |
| } |
| |
| return bRet; |
| } |
| |
| bool DocumentProperties(HANDLE hPrinter, HWND hWnd = NULL) |
| { |
| CPrinterInfo<1> pi; |
| pi.GetPrinterInfo(hPrinter); |
| if (hWnd == NULL) |
| hWnd = ::GetActiveWindow(); |
| |
| bool bRet = false; |
| LONG nLen = ::DocumentProperties(hWnd, hPrinter, pi.m_pi->pName, NULL, NULL, 0); |
| CTempBuffer<DEVMODE, _WTL_STACK_ALLOC_THRESHOLD> buff; |
| DEVMODE* pdm = buff.AllocateBytes(nLen); |
| if(pdm != NULL) |
| { |
| memset(pdm, 0, nLen); |
| LONG l = ::DocumentProperties(hWnd, hPrinter, pi.m_pi->pName, pdm, m_pDevMode, DM_IN_BUFFER | DM_OUT_BUFFER | DM_PROMPT); |
| if (l == IDOK) |
| bRet = CopyFromDEVMODE(pdm); |
| } |
| |
| return bRet; |
| } |
| |
| operator HANDLE() const { return m_hDevMode; } |
| |
| operator DEVMODE*() const { return m_pDevMode; } |
| |
| // Implementation |
| void Cleanup() |
| { |
| if (m_hDevMode != NULL) |
| { |
| ::GlobalUnlock(m_hDevMode); |
| if(t_bManaged) |
| ::GlobalFree(m_hDevMode); |
| m_hDevMode = NULL; |
| } |
| } |
| }; |
| |
| typedef CDevModeT<false> CDevModeHandle; |
| typedef CDevModeT<true> CDevMode; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CPrinterDC |
| |
| class CPrinterDC : public CDC |
| { |
| public: |
| // Constructors/destructor |
| CPrinterDC() |
| { |
| CPrinter printer; |
| printer.OpenDefaultPrinter(); |
| Attach(printer.CreatePrinterDC()); |
| ATLASSERT(m_hDC != NULL); |
| } |
| |
| CPrinterDC(HANDLE hPrinter, const DEVMODE* pdm = NULL) |
| { |
| CPrinterHandle p; |
| p.Attach(hPrinter); |
| Attach(p.CreatePrinterDC(pdm)); |
| ATLASSERT(m_hDC != NULL); |
| } |
| |
| ~CPrinterDC() |
| { |
| DeleteDC(); |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CPrintJob - Wraps a set of tasks for a specific printer (StartDoc/EndDoc) |
| // Handles aborting, background printing |
| |
| // Defines callbacks used by CPrintJob (not a COM interface) |
| class ATL_NO_VTABLE IPrintJobInfo |
| { |
| public: |
| virtual void BeginPrintJob(HDC hDC) = 0; // allocate handles needed, etc. |
| virtual void EndPrintJob(HDC hDC, bool bAborted) = 0; // free handles, etc. |
| virtual void PrePrintPage(UINT nPage, HDC hDC) = 0; |
| virtual bool PrintPage(UINT nPage, HDC hDC) = 0; |
| virtual void PostPrintPage(UINT nPage, HDC hDC) = 0; |
| // If you want per page devmodes, return the DEVMODE* to use for nPage. |
| // You can optimize by only returning a new DEVMODE* when it is different |
| // from the one for nLastPage, otherwise return NULL. |
| // When nLastPage==0, the current DEVMODE* will be the default passed to |
| // StartPrintJob. |
| // Note: During print preview, nLastPage will always be "0". |
| virtual DEVMODE* GetNewDevModeForPage(UINT nLastPage, UINT nPage) = 0; |
| virtual bool IsValidPage(UINT nPage) = 0; |
| }; |
| |
| // Provides a default implementatin for IPrintJobInfo |
| // Typically, MI'd into a document or view class |
| class ATL_NO_VTABLE CPrintJobInfo : public IPrintJobInfo |
| { |
| public: |
| virtual void BeginPrintJob(HDC /*hDC*/) // allocate handles needed, etc |
| { |
| } |
| |
| virtual void EndPrintJob(HDC /*hDC*/, bool /*bAborted*/) // free handles, etc |
| { |
| } |
| |
| virtual void PrePrintPage(UINT /*nPage*/, HDC hDC) |
| { |
| m_nPJState = ::SaveDC(hDC); |
| } |
| |
| virtual bool PrintPage(UINT /*nPage*/, HDC /*hDC*/) = 0; |
| |
| virtual void PostPrintPage(UINT /*nPage*/, HDC hDC) |
| { |
| RestoreDC(hDC, m_nPJState); |
| } |
| |
| virtual DEVMODE* GetNewDevModeForPage(UINT /*nLastPage*/, UINT /*nPage*/) |
| { |
| return NULL; |
| } |
| |
| virtual bool IsValidPage(UINT /*nPage*/) |
| { |
| return true; |
| } |
| |
| // Implementation - data |
| int m_nPJState; |
| }; |
| |
| |
| class CPrintJob |
| { |
| public: |
| // Data members |
| CPrinterHandle m_printer; |
| IPrintJobInfo* m_pInfo; |
| DEVMODE* m_pDefDevMode; |
| DOCINFO m_docinfo; |
| int m_nJobID; |
| bool m_bCancel; |
| bool m_bComplete; |
| unsigned long m_nStartPage; |
| unsigned long m_nEndPage; |
| |
| // Constructor/destructor |
| CPrintJob() : m_nJobID(0), m_bCancel(false), m_bComplete(true) |
| { } |
| |
| ~CPrintJob() |
| { |
| ATLASSERT(IsJobComplete()); // premature destruction? |
| } |
| |
| // Operations |
| bool IsJobComplete() const |
| { |
| return m_bComplete; |
| } |
| |
| bool StartPrintJob(bool bBackground, HANDLE hPrinter, DEVMODE* pDefaultDevMode, |
| IPrintJobInfo* pInfo, LPCTSTR lpszDocName, |
| unsigned long nStartPage, unsigned long nEndPage, |
| bool bPrintToFile = false, LPCTSTR lpstrOutputFile = NULL) |
| { |
| ATLASSERT(m_bComplete); // previous job not done yet? |
| if (pInfo == NULL) |
| return false; |
| |
| memset(&m_docinfo, 0, sizeof(m_docinfo)); |
| m_docinfo.cbSize = sizeof(m_docinfo); |
| m_docinfo.lpszDocName = lpszDocName; |
| m_pInfo = pInfo; |
| m_nStartPage = nStartPage; |
| m_nEndPage = nEndPage; |
| m_printer.Attach(hPrinter); |
| m_pDefDevMode = pDefaultDevMode; |
| m_bComplete = false; |
| |
| if(bPrintToFile) |
| m_docinfo.lpszOutput = (lpstrOutputFile != NULL) ? lpstrOutputFile : _T("FILE:"); |
| |
| if (!bBackground) |
| { |
| m_bComplete = true; |
| return StartHelper(); |
| } |
| |
| // Create a thread and return |
| DWORD dwThreadID = 0; |
| #if !defined(_ATL_MIN_CRT) && defined(_MT) |
| HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, (UINT (WINAPI*)(void*))StartProc, this, 0, (UINT*)&dwThreadID); |
| #else |
| HANDLE hThread = ::CreateThread(NULL, 0, StartProc, (void*)this, 0, &dwThreadID); |
| #endif |
| if (hThread == NULL) |
| return false; |
| |
| ::CloseHandle(hThread); |
| |
| return true; |
| } |
| |
| // Implementation |
| static DWORD WINAPI StartProc(void* p) |
| { |
| CPrintJob* pThis = (CPrintJob*)p; |
| pThis->StartHelper(); |
| pThis->m_bComplete = true; |
| return 0; |
| } |
| |
| bool StartHelper() |
| { |
| CDC dcPrinter; |
| dcPrinter.Attach(m_printer.CreatePrinterDC(m_pDefDevMode)); |
| if (dcPrinter.IsNull()) |
| return false; |
| |
| m_nJobID = ::StartDoc(dcPrinter, &m_docinfo); |
| if (m_nJobID <= 0) |
| return false; |
| |
| m_pInfo->BeginPrintJob(dcPrinter); |
| |
| // print all the pages now |
| unsigned long nLastPage = 0; |
| for (unsigned long nPage = m_nStartPage; nPage <= m_nEndPage; nPage++) |
| { |
| if (!m_pInfo->IsValidPage(nPage)) |
| break; |
| DEVMODE* pdm = m_pInfo->GetNewDevModeForPage(nLastPage, nPage); |
| if (pdm != NULL) |
| dcPrinter.ResetDC(pdm); |
| dcPrinter.StartPage(); |
| m_pInfo->PrePrintPage(nPage, dcPrinter); |
| if (!m_pInfo->PrintPage(nPage, dcPrinter)) |
| m_bCancel = true; |
| m_pInfo->PostPrintPage(nPage, dcPrinter); |
| dcPrinter.EndPage(); |
| if (m_bCancel) |
| break; |
| nLastPage = nPage; |
| } |
| |
| m_pInfo->EndPrintJob(dcPrinter, m_bCancel); |
| if (m_bCancel) |
| ::AbortDoc(dcPrinter); |
| else |
| ::EndDoc(dcPrinter); |
| m_nJobID = 0; |
| return true; |
| } |
| |
| // Cancels a print job. Can be called asynchronously. |
| void CancelPrintJob() |
| { |
| m_bCancel = true; |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CPrintPreview - Adds print preview support to an existing window |
| |
| class CPrintPreview |
| { |
| public: |
| // Data members |
| IPrintJobInfo* m_pInfo; |
| CPrinterHandle m_printer; |
| CEnhMetaFile m_meta; |
| DEVMODE* m_pDefDevMode; |
| DEVMODE* m_pCurDevMode; |
| SIZE m_sizeCurPhysOffset; |
| |
| // Constructor |
| CPrintPreview() : m_pInfo(NULL), m_pDefDevMode(NULL), m_pCurDevMode(NULL) |
| { |
| m_sizeCurPhysOffset.cx = 0; |
| m_sizeCurPhysOffset.cy = 0; |
| } |
| |
| // Operations |
| void SetPrintPreviewInfo(HANDLE hPrinter, DEVMODE* pDefaultDevMode, IPrintJobInfo* pji) |
| { |
| m_printer.Attach(hPrinter); |
| m_pDefDevMode = pDefaultDevMode; |
| m_pInfo = pji; |
| m_nCurPage = 0; |
| m_pCurDevMode = NULL; |
| } |
| |
| void SetEnhMetaFile(HENHMETAFILE hEMF) |
| { |
| m_meta = hEMF; |
| } |
| |
| void SetPage(int nPage) |
| { |
| if (!m_pInfo->IsValidPage(nPage)) |
| return; |
| m_nCurPage = nPage; |
| m_pCurDevMode = m_pInfo->GetNewDevModeForPage(0, nPage); |
| if (m_pCurDevMode == NULL) |
| m_pCurDevMode = m_pDefDevMode; |
| CDC dcPrinter = m_printer.CreatePrinterDC(m_pCurDevMode); |
| |
| int iWidth = dcPrinter.GetDeviceCaps(PHYSICALWIDTH); |
| int iHeight = dcPrinter.GetDeviceCaps(PHYSICALHEIGHT); |
| int nLogx = dcPrinter.GetDeviceCaps(LOGPIXELSX); |
| int nLogy = dcPrinter.GetDeviceCaps(LOGPIXELSY); |
| |
| RECT rcMM = { 0, 0, ::MulDiv(iWidth, 2540, nLogx), ::MulDiv(iHeight, 2540, nLogy) }; |
| |
| m_sizeCurPhysOffset.cx = dcPrinter.GetDeviceCaps(PHYSICALOFFSETX); |
| m_sizeCurPhysOffset.cy = dcPrinter.GetDeviceCaps(PHYSICALOFFSETY); |
| |
| CEnhMetaFileDC dcMeta(dcPrinter, &rcMM); |
| m_pInfo->PrePrintPage(nPage, dcMeta); |
| m_pInfo->PrintPage(nPage, dcMeta); |
| m_pInfo->PostPrintPage(nPage, dcMeta); |
| m_meta.Attach(dcMeta.Close()); |
| } |
| |
| void GetPageRect(RECT& rc, LPRECT prc) |
| { |
| int x1 = rc.right-rc.left; |
| int y1 = rc.bottom - rc.top; |
| if ((x1 < 0) || (y1 < 0)) |
| return; |
| |
| CEnhMetaFileInfo emfinfo(m_meta); |
| ENHMETAHEADER* pmh = emfinfo.GetEnhMetaFileHeader(); |
| |
| // Compute whether we are OK vertically or horizontally |
| int x2 = pmh->szlDevice.cx; |
| int y2 = pmh->szlDevice.cy; |
| int y1p = MulDiv(x1, y2, x2); |
| int x1p = MulDiv(y1, x2, y2); |
| ATLASSERT((x1p <= x1) || (y1p <= y1)); |
| if (x1p <= x1) |
| { |
| prc->left = rc.left + (x1 - x1p) / 2; |
| prc->right = prc->left + x1p; |
| prc->top = rc.top; |
| prc->bottom = rc.bottom; |
| } |
| else |
| { |
| prc->left = rc.left; |
| prc->right = rc.right; |
| prc->top = rc.top + (y1 - y1p) / 2; |
| prc->bottom = prc->top + y1p; |
| } |
| } |
| |
| // Painting helpers |
| void DoPaint(CDCHandle dc) |
| { |
| // this one is not used |
| } |
| |
| void DoPaint(CDCHandle dc, RECT& rc) |
| { |
| CEnhMetaFileInfo emfinfo(m_meta); |
| ENHMETAHEADER* pmh = emfinfo.GetEnhMetaFileHeader(); |
| int nOffsetX = MulDiv(m_sizeCurPhysOffset.cx, rc.right-rc.left, pmh->szlDevice.cx); |
| int nOffsetY = MulDiv(m_sizeCurPhysOffset.cy, rc.bottom-rc.top, pmh->szlDevice.cy); |
| |
| dc.OffsetWindowOrg(-nOffsetX, -nOffsetY); |
| dc.PlayMetaFile(m_meta, &rc); |
| } |
| |
| // Implementation - data |
| int m_nCurPage; |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CPrintPreviewWindow - Implements a print preview window |
| |
| template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits> |
| class ATL_NO_VTABLE CPrintPreviewWindowImpl : public ATL::CWindowImpl<T, TBase, TWinTraits>, public CPrintPreview |
| { |
| public: |
| DECLARE_WND_CLASS_EX(NULL, CS_VREDRAW | CS_HREDRAW, -1) |
| |
| enum { m_cxOffset = 10, m_cyOffset = 10 }; |
| |
| // Constructor |
| CPrintPreviewWindowImpl() : m_nMaxPage(0), m_nMinPage(0) |
| { } |
| |
| // Operations |
| void SetPrintPreviewInfo(HANDLE hPrinter, DEVMODE* pDefaultDevMode, |
| IPrintJobInfo* pji, int nMinPage, int nMaxPage) |
| { |
| CPrintPreview::SetPrintPreviewInfo(hPrinter, pDefaultDevMode, pji); |
| m_nMinPage = nMinPage; |
| m_nMaxPage = nMaxPage; |
| } |
| |
| bool NextPage() |
| { |
| if (m_nCurPage == m_nMaxPage) |
| return false; |
| SetPage(m_nCurPage + 1); |
| Invalidate(); |
| return true; |
| } |
| |
| bool PrevPage() |
| { |
| if (m_nCurPage == m_nMinPage) |
| return false; |
| if (m_nCurPage == 0) |
| return false; |
| SetPage(m_nCurPage - 1); |
| Invalidate(); |
| return true; |
| } |
| |
| // Message map and handlers |
| BEGIN_MSG_MAP(CPrintPreviewWindowImpl) |
| MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd) |
| MESSAGE_HANDLER(WM_PAINT, OnPaint) |
| MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint) |
| END_MSG_MAP() |
| |
| LRESULT OnEraseBkgnd(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| return 1; // no need for the background |
| } |
| |
| LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| RECT rc = { 0 }; |
| |
| if(wParam != NULL) |
| { |
| pT->DoPrePaint((HDC)wParam, rc); |
| pT->DoPaint((HDC)wParam, rc); |
| } |
| else |
| { |
| CPaintDC dc(m_hWnd); |
| pT->DoPrePaint(dc.m_hDC, rc); |
| pT->DoPaint(dc.m_hDC, rc); |
| } |
| |
| return 0; |
| } |
| |
| // Painting helper |
| void DoPrePaint(CDCHandle dc, RECT& rc) |
| { |
| RECT rcClient = { 0 }; |
| GetClientRect(&rcClient); |
| RECT rcArea = rcClient; |
| T* pT = static_cast<T*>(this); |
| pT; // avoid level 4 warning |
| ::InflateRect(&rcArea, -pT->m_cxOffset, -pT->m_cyOffset); |
| if (rcArea.left > rcArea.right) |
| rcArea.right = rcArea.left; |
| if (rcArea.top > rcArea.bottom) |
| rcArea.bottom = rcArea.top; |
| GetPageRect(rcArea, &rc); |
| CRgn rgn1, rgn2; |
| rgn1.CreateRectRgnIndirect(&rc); |
| rgn2.CreateRectRgnIndirect(&rcClient); |
| rgn2.CombineRgn(rgn1, RGN_DIFF); |
| dc.SelectClipRgn(rgn2); |
| dc.FillRect(&rcClient, COLOR_BTNSHADOW); |
| dc.SelectClipRgn(NULL); |
| dc.FillRect(&rc, (HBRUSH)::GetStockObject(WHITE_BRUSH)); |
| } |
| |
| // Implementation - data |
| int m_nMinPage; |
| int m_nMaxPage; |
| }; |
| |
| |
| class CPrintPreviewWindow : public CPrintPreviewWindowImpl<CPrintPreviewWindow> |
| { |
| public: |
| DECLARE_WND_CLASS_EX(_T("WTL_PrintPreview"), CS_VREDRAW | CS_HREDRAW, -1) |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CZoomPrintPreviewWindowImpl - Implements print preview window with zooming |
| |
| #ifdef __ATLSCRL_H__ |
| |
| template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits> |
| class ATL_NO_VTABLE CZoomPrintPreviewWindowImpl : public CPrintPreviewWindowImpl< T, TBase, TWinTraits >, public CZoomScrollImpl< T > |
| { |
| public: |
| bool m_bSized; |
| |
| CZoomPrintPreviewWindowImpl() |
| { |
| SetScrollExtendedStyle(SCRL_DISABLENOSCROLL); |
| InitZoom(); |
| } |
| |
| // should be called to reset data members before recreating window |
| void InitZoom() |
| { |
| m_bSized = false; |
| m_nZoomMode = ZOOMMODE_OFF; |
| m_fZoomScaleMin = 1.0; |
| m_fZoomScale = 1.0; |
| } |
| |
| BEGIN_MSG_MAP(CZoomPrintPreviewWindowImpl) |
| MESSAGE_HANDLER(WM_SETCURSOR, CZoomScrollImpl< T >::OnSetCursor) |
| MESSAGE_HANDLER(WM_VSCROLL, CScrollImpl< T >::OnVScroll) |
| MESSAGE_HANDLER(WM_HSCROLL, CScrollImpl< T >::OnHScroll) |
| MESSAGE_HANDLER(WM_MOUSEWHEEL, CScrollImpl< T >::OnMouseWheel) |
| #if !((_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)) |
| MESSAGE_HANDLER(m_uMsgMouseWheel, CScrollImpl< T >::OnMouseWheel) |
| #endif // !((_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, CScrollImpl< T >::OnSettingChange) |
| MESSAGE_HANDLER(WM_LBUTTONDOWN, CZoomScrollImpl< T >::OnLButtonDown) |
| MESSAGE_HANDLER(WM_MOUSEMOVE, CZoomScrollImpl< T >::OnMouseMove) |
| MESSAGE_HANDLER(WM_LBUTTONUP, CZoomScrollImpl< T >::OnLButtonUp) |
| MESSAGE_HANDLER(WM_CAPTURECHANGED, CZoomScrollImpl< T >::OnCaptureChanged) |
| MESSAGE_HANDLER(WM_SIZE, OnSize) |
| MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd) |
| MESSAGE_HANDLER(WM_PAINT, OnPaint) |
| MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint) |
| ALT_MSG_MAP(1) |
| COMMAND_ID_HANDLER(ID_SCROLL_UP, CScrollImpl< T >::OnScrollUp) |
| COMMAND_ID_HANDLER(ID_SCROLL_DOWN, CScrollImpl< T >::OnScrollDown) |
| COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, CScrollImpl< T >::OnScrollPageUp) |
| COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, CScrollImpl< T >::OnScrollPageDown) |
| COMMAND_ID_HANDLER(ID_SCROLL_TOP, CScrollImpl< T >::OnScrollTop) |
| COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, CScrollImpl< T >::OnScrollBottom) |
| COMMAND_ID_HANDLER(ID_SCROLL_LEFT, CScrollImpl< T >::OnScrollLeft) |
| COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, CScrollImpl< T >::OnScrollRight) |
| COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, CScrollImpl< T >::OnScrollPageLeft) |
| COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, CScrollImpl< T >::OnScrollPageRight) |
| COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, CScrollImpl< T >::OnScrollAllLeft) |
| COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, CScrollImpl< T >::OnScrollAllRight) |
| END_MSG_MAP() |
| |
| LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| SIZE sizeClient = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)}; |
| POINT ptOffset = m_ptOffset; |
| SIZE sizeAll = m_sizeAll; |
| SetScrollSize(sizeClient); |
| if(sizeAll.cx > 0) |
| ptOffset.x = ::MulDiv(ptOffset.x, m_sizeAll.cx, sizeAll.cx); |
| if(sizeAll.cy > 0) |
| ptOffset.y = ::MulDiv(ptOffset.y, m_sizeAll.cy, sizeAll.cy); |
| SetScrollOffset(ptOffset); |
| CScrollImpl< T >::OnSize(uMsg, wParam, lParam, bHandled); |
| if(!m_bSized) |
| { |
| m_bSized = true; |
| T* pT = static_cast<T*>(this); |
| pT->ShowScrollBar(SB_HORZ, TRUE); |
| pT->ShowScrollBar(SB_VERT, TRUE); |
| } |
| return 0; |
| } |
| |
| LRESULT OnEraseBkgnd(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| return 1; |
| } |
| |
| LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| RECT rc = { 0 }; |
| |
| if(wParam != NULL) |
| { |
| CDCHandle dc = (HDC)wParam; |
| int nMapModeSav = dc.GetMapMode(); |
| dc.SetMapMode(MM_ANISOTROPIC); |
| SIZE szWindowExt = { 0, 0 }; |
| dc.SetWindowExt(m_sizeLogAll, &szWindowExt); |
| SIZE szViewportExt = { 0, 0 }; |
| dc.SetViewportExt(m_sizeAll, &szViewportExt); |
| POINT ptViewportOrg = { 0, 0 }; |
| dc.SetViewportOrg(-m_ptOffset.x, -m_ptOffset.y, &ptViewportOrg); |
| |
| pT->DoPrePaint(dc, rc); |
| pT->DoPaint(dc, rc); |
| |
| dc.SetMapMode(nMapModeSav); |
| dc.SetWindowExt(szWindowExt); |
| dc.SetViewportExt(szViewportExt); |
| dc.SetViewportOrg(ptViewportOrg); |
| } |
| else |
| { |
| CPaintDC dc(pT->m_hWnd); |
| pT->PrepareDC(dc.m_hDC); |
| pT->DoPrePaint(dc.m_hDC, rc); |
| pT->DoPaint(dc.m_hDC, rc); |
| } |
| |
| return 0; |
| } |
| |
| // Painting helpers |
| void DoPaint(CDCHandle dc) |
| { |
| // this one is not used |
| } |
| |
| void DoPrePaint(CDCHandle dc, RECT& rc) |
| { |
| RECT rcClient; |
| GetClientRect(&rcClient); |
| RECT rcArea = rcClient; |
| T* pT = static_cast<T*>(this); |
| pT; // avoid level 4 warning |
| ::InflateRect(&rcArea, -pT->m_cxOffset, -pT->m_cyOffset); |
| if (rcArea.left > rcArea.right) |
| rcArea.right = rcArea.left; |
| if (rcArea.top > rcArea.bottom) |
| rcArea.bottom = rcArea.top; |
| GetPageRect(rcArea, &rc); |
| HBRUSH hbrOld = dc.SelectBrush(::GetSysColorBrush(COLOR_BTNSHADOW)); |
| dc.PatBlt(rcClient.left, rcClient.top, rc.left - rcClient.left, rcClient.bottom - rcClient.top, PATCOPY); |
| dc.PatBlt(rc.left, rcClient.top, rc.right - rc.left, rc.top - rcClient.top, PATCOPY); |
| dc.PatBlt(rc.right, rcClient.top, rcClient.right - rc.right, rcClient.bottom - rcClient.top, PATCOPY); |
| dc.PatBlt(rc.left, rc.bottom, rc.right - rc.left, rcClient.bottom - rc.bottom, PATCOPY); |
| dc.SelectBrush((HBRUSH)::GetStockObject(WHITE_BRUSH)); |
| dc.PatBlt(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY); |
| dc.SelectBrush(::GetSysColorBrush(COLOR_3DDKSHADOW)); |
| dc.PatBlt(rc.right, rc.top + 4, 4, rc.bottom - rc.top, PATCOPY); |
| dc.PatBlt(rc.left + 4, rc.bottom, rc.right - rc.left, 4, PATCOPY); |
| dc.SelectBrush(hbrOld); |
| } |
| |
| void DoPaint(CDCHandle dc, RECT& rc) |
| { |
| CEnhMetaFileInfo emfinfo(m_meta); |
| ENHMETAHEADER* pmh = emfinfo.GetEnhMetaFileHeader(); |
| int nOffsetX = MulDiv(m_sizeCurPhysOffset.cx, rc.right-rc.left, pmh->szlDevice.cx); |
| int nOffsetY = MulDiv(m_sizeCurPhysOffset.cy, rc.bottom-rc.top, pmh->szlDevice.cy); |
| |
| dc.OffsetWindowOrg(-nOffsetX, -nOffsetY); |
| dc.PlayMetaFile(m_meta, &rc); |
| } |
| }; |
| |
| class CZoomPrintPreviewWindow : public CZoomPrintPreviewWindowImpl<CZoomPrintPreviewWindow> |
| { |
| public: |
| DECLARE_WND_CLASS_EX(_T("WTL_ZoomPrintPreview"), CS_VREDRAW | CS_HREDRAW, -1) |
| }; |
| |
| #endif // __ATLSCRL_H__ |
| |
| }; // namespace WTL |
| |
| #endif // __ATLPRINT_H__ |