src/msw/printwin.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/printwin.cpp
// Purpose:     wxWindowsPrinter framework
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ===========================================================================
// declarations
// ===========================================================================

// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// Don't use the Windows printer if we're in wxUniv mode and using
// the PostScript architecture
#if wxUSE_PRINTING_ARCHITECTURE && (!defined(__WXUNIVERSAL__) || !wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW)

#ifndef WX_PRECOMP
    #include "wx/msw/wrapcdlg.h"
    #include "wx/window.h"
    #include "wx/msw/private.h"
    #include "wx/utils.h"
    #include "wx/dc.h"
    #include "wx/app.h"
    #include "wx/msgdlg.h"
    #include "wx/intl.h"
    #include "wx/log.h"
    #include "wx/dcprint.h"
    #include "wx/dcmemory.h"
    #include "wx/image.h"
#endif

#include "wx/msw/dib.h"
#include "wx/msw/dcmemory.h"
#include "wx/msw/printwin.h"
#include "wx/msw/printdlg.h"
#include "wx/msw/private.h"
#include "wx/msw/dcprint.h"
#include "wx/msw/enhmeta.h"

#include <stdlib.h>

#ifndef __WIN32__
    #include <print.h>
#endif

// ---------------------------------------------------------------------------
// private functions
// ---------------------------------------------------------------------------

LONG APIENTRY _EXPORT wxAbortProc(HDC hPr, int Code);

// ---------------------------------------------------------------------------
// wxWin macros
// ---------------------------------------------------------------------------

    IMPLEMENT_DYNAMIC_CLASS(wxWindowsPrinter, wxPrinterBase)
    IMPLEMENT_CLASS(wxWindowsPrintPreview, wxPrintPreviewBase)

// ===========================================================================
// implementation
// ===========================================================================

// ---------------------------------------------------------------------------
// Printer
// ---------------------------------------------------------------------------

wxWindowsPrinter::wxWindowsPrinter(wxPrintDialogData *data)
                : wxPrinterBase(data)
{
    m_lpAbortProc = (WXFARPROC)wxAbortProc;
}

wxWindowsPrinter::~wxWindowsPrinter()
{
    // avoids warning about statement with no effect (FreeProcInstance
    // doesn't do anything under Win32)
#if !defined(__WIN32__) && !defined(__NT__)
    FreeProcInstance((FARPROC) m_lpAbortProc);
#endif
}

bool wxWindowsPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
{
    sm_abortIt = false;
    sm_abortWindow = NULL;

    if (!printout)
    {
        sm_lastError = wxPRINTER_ERROR;
        return false;
    }

    printout->SetIsPreview(false);

    if (m_printDialogData.GetMinPage() < 1)
        m_printDialogData.SetMinPage(1);
    if (m_printDialogData.GetMaxPage() < 1)
        m_printDialogData.SetMaxPage(9999);

    // Create a suitable device context
    wxPrinterDC *dc wxDUMMY_INITIALIZE(NULL);
    if (prompt)
    {
        dc = wxDynamicCast(PrintDialog(parent), wxPrinterDC);
        if (!dc)
            return false;
    }
    else
    {
        dc = new wxPrinterDC(m_printDialogData.GetPrintData());
    }

    // May have pressed cancel.
    if (!dc || !dc->IsOk())
    {
        if (dc) delete dc;
        return false;
    }

    wxPrinterDCImpl *impl = (wxPrinterDCImpl*) dc->GetImpl();

    HDC hdc = ::GetDC(NULL);
    int logPPIScreenX = ::GetDeviceCaps(hdc, LOGPIXELSX);
    int logPPIScreenY = ::GetDeviceCaps(hdc, LOGPIXELSY);
    ::ReleaseDC(NULL, hdc);

    int logPPIPrinterX = ::GetDeviceCaps((HDC) impl->GetHDC(), LOGPIXELSX);
    int logPPIPrinterY = ::GetDeviceCaps((HDC) impl->GetHDC(), LOGPIXELSY);
    if (logPPIPrinterX == 0 || logPPIPrinterY == 0)
    {
        delete dc;
        sm_lastError = wxPRINTER_ERROR;
        return false;
    }

    printout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
    printout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);

    // Set printout parameters
    printout->SetDC(dc);

    int w, h;
    dc->GetSize(&w, &h);
    printout->SetPageSizePixels((int)w, (int)h);
    printout->SetPaperRectPixels(dc->GetPaperRect());

    dc->GetSizeMM(&w, &h);
    printout->SetPageSizeMM((int)w, (int)h);

    // Create an abort window
    wxBusyCursor busyCursor;

    printout->OnPreparePrinting();

    // Get some parameters from the printout, if defined
    int fromPage, toPage;
    int minPage, maxPage;
    printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);

    if (maxPage == 0)
    {
        sm_lastError = wxPRINTER_ERROR;
        return false;
    }

    // Only set min and max, because from and to have been
    // set by the user
    m_printDialogData.SetMinPage(minPage);
    m_printDialogData.SetMaxPage(maxPage);

    wxWindow *win = CreateAbortWindow(parent, printout);
    wxYield();

#if defined(__WATCOMC__) || defined(__BORLANDC__) || defined(__GNUWIN32__) || !defined(__WIN32__)
#ifdef STRICT
    ::SetAbortProc((HDC) impl->GetHDC(), (ABORTPROC) m_lpAbortProc);
#else
    ::SetAbortProc((HDC) impl->GetHDC(), (FARPROC) m_lpAbortProc);
#endif
#else
    ::SetAbortProc((HDC) impl->GetHDC(), (int (_stdcall *)
        // cast it to right type only if required
        // FIXME it's really cdecl and we're casting it to stdcall - either there is
        //       something I don't understand or it will crash at first usage
#ifdef STRICT
        (HDC, int)
#else
        ()
#endif
        )m_lpAbortProc);
#endif

    if (!win)
    {
        wxLogDebug(wxT("Could not create an abort dialog."));
        sm_lastError = wxPRINTER_ERROR;

        delete dc;
        return false;
    }
    sm_abortWindow = win;
    sm_abortWindow->Show();
    wxSafeYield();

    printout->OnBeginPrinting();

    sm_lastError = wxPRINTER_NO_ERROR;

    int minPageNum = minPage, maxPageNum = maxPage;

    if ( !m_printDialogData.GetAllPages() )
    {
        minPageNum = m_printDialogData.GetFromPage();
        maxPageNum = m_printDialogData.GetToPage();
    }

    int copyCount;
    for ( copyCount = 1;
          copyCount <= m_printDialogData.GetNoCopies();
          copyCount++ )
    {
        if ( !printout->OnBeginDocument(minPageNum, maxPageNum) )
        {
            wxLogError(_("Could not start printing."));
            sm_lastError = wxPRINTER_ERROR;
            break;
        }
        if (sm_abortIt)
        {
            sm_lastError = wxPRINTER_CANCELLED;
            break;
        }

        int pn;

        for ( pn = minPageNum;
              pn <= maxPageNum && printout->HasPage(pn);
              pn++ )
        {
            if ( sm_abortIt )
            {
                sm_lastError = wxPRINTER_CANCELLED;
                break;
            }

            dc->StartPage();
            bool cont = printout->OnPrintPage(pn);
            dc->EndPage();

            if ( !cont )
            {
                sm_lastError = wxPRINTER_CANCELLED;
                break;
            }
        }

        printout->OnEndDocument();
    }

    printout->OnEndPrinting();

    if (sm_abortWindow)
    {
        sm_abortWindow->Show(false);
        delete sm_abortWindow;
        sm_abortWindow = NULL;
    }

    delete dc;

    return sm_lastError == wxPRINTER_NO_ERROR;
}

wxDC *wxWindowsPrinter::PrintDialog(wxWindow *parent)
{
    wxDC *dc = NULL;

    wxWindowsPrintDialog dialog(parent, & m_printDialogData);
    int ret = dialog.ShowModal();

    if (ret == wxID_OK)
    {
        dc = dialog.GetPrintDC();
        m_printDialogData = dialog.GetPrintDialogData();
        if (dc == NULL)
            sm_lastError = wxPRINTER_ERROR;
        else
            sm_lastError = wxPRINTER_NO_ERROR;
    }
    else
        sm_lastError = wxPRINTER_CANCELLED;

    return dc;
}

bool wxWindowsPrinter::Setup(wxWindow *WXUNUSED(parent))
{
#if 0
    // We no longer expose that dialog
    wxPrintDialog dialog(parent, & m_printDialogData);
    dialog.GetPrintDialogData().SetSetupDialog(true);

    int ret = dialog.ShowModal();

    if (ret == wxID_OK)
    {
        m_printDialogData = dialog.GetPrintDialogData();
    }

    return (ret == wxID_OK);
#else
    return false;
#endif
}

/*
* Print preview
*/

wxWindowsPrintPreview::wxWindowsPrintPreview(wxPrintout *printout,
                                             wxPrintout *printoutForPrinting,
                                             wxPrintDialogData *data)
                     : wxPrintPreviewBase(printout, printoutForPrinting, data)
{
    DetermineScaling();
}

wxWindowsPrintPreview::wxWindowsPrintPreview(wxPrintout *printout,
                                             wxPrintout *printoutForPrinting,
                                             wxPrintData *data)
                     : wxPrintPreviewBase(printout, printoutForPrinting, data)
{
    DetermineScaling();
}

wxWindowsPrintPreview::~wxWindowsPrintPreview()
{
}

bool wxWindowsPrintPreview::Print(bool interactive)
{
    if (!m_printPrintout)
        return false;
    wxWindowsPrinter printer(&m_printDialogData);
    return printer.Print(m_previewFrame, m_printPrintout, interactive);
}

void wxWindowsPrintPreview::DetermineScaling()
{
    ScreenHDC dc;
    int logPPIScreenX = ::GetDeviceCaps(dc, LOGPIXELSX);
    int logPPIScreenY = ::GetDeviceCaps(dc, LOGPIXELSY);
    m_previewPrintout->SetPPIScreen(logPPIScreenX, logPPIScreenY);

    // Get a device context for the currently selected printer
    wxPrinterDC printerDC(m_printDialogData.GetPrintData());

    int printerWidthMM;
    int printerHeightMM;
    int printerXRes;
    int printerYRes;
    int logPPIPrinterX;
    int logPPIPrinterY;

    wxRect paperRect;

    if ( printerDC.IsOk() )
    {
        wxPrinterDCImpl *impl = (wxPrinterDCImpl*) printerDC.GetImpl();
        HDC dc = GetHdcOf(*impl);
        printerWidthMM = ::GetDeviceCaps(dc, HORZSIZE);
        printerHeightMM = ::GetDeviceCaps(dc, VERTSIZE);
        printerXRes = ::GetDeviceCaps(dc, HORZRES);
        printerYRes = ::GetDeviceCaps(dc, VERTRES);
        logPPIPrinterX = ::GetDeviceCaps(dc, LOGPIXELSX);
        logPPIPrinterY = ::GetDeviceCaps(dc, LOGPIXELSY);

        paperRect = printerDC.GetPaperRect();

        if ( logPPIPrinterX == 0 ||
                logPPIPrinterY == 0 ||
                    printerWidthMM == 0 ||
                        printerHeightMM == 0 )
        {
            m_isOk = false;
        }
    }
    else
    {
        // use some defaults
        printerWidthMM = 150;
        printerHeightMM = 250;
        printerXRes = 1500;
        printerYRes = 2500;
        logPPIPrinterX = 600;
        logPPIPrinterY = 600;

        paperRect = wxRect(0, 0, printerXRes, printerYRes);
        m_isOk = false;
    }
    m_pageWidth = printerXRes;
    m_pageHeight = printerYRes;
    m_previewPrintout->SetPageSizePixels(printerXRes, printerYRes);
    m_previewPrintout->SetPageSizeMM(printerWidthMM, printerHeightMM);
    m_previewPrintout->SetPaperRectPixels(paperRect);
    m_previewPrintout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);

    // At 100%, the page should look about page-size on the screen.
    m_previewScaleX = float(logPPIScreenX) / logPPIPrinterX;
    m_previewScaleY = float(logPPIScreenY) / logPPIPrinterY;
}

bool wxWindowsPrintPreview::RenderPageIntoBitmap(wxBitmap& bmp, int pageNum)
{
    // The preview, as implemented in wxPrintPreviewBase (and as used prior to
    // wx3) is inexact: it uses screen DC, which has much lower resolution and
    // has other properties different from printer DC, so the preview is not
    // quite right.
    //
    // To make matters worse, if the application depends heavily on
    // GetTextExtent() or does text layout itself, the output in preview and on
    // paper can be very different. In particular, wxHtmlEasyPrinting is
    // affected and the preview can be easily off by several pages.
    //
    // To fix this, we render the preview into high-resolution enhanced
    // metafile with properties identical to the printer DC. This guarantees
    // metrics correctness while still being fast.


    // print the preview into a metafile:
    wxPrinterDC printerDC(m_printDialogData.GetPrintData());
    wxEnhMetaFileDC metaDC(printerDC,
                           wxEmptyString,
                           printerDC.GetSize().x, printerDC.GetSize().y);

    if ( !RenderPageIntoDC(metaDC, pageNum) )
        return false;

    wxEnhMetaFile *metafile = metaDC.Close();
    if ( !metafile )
        return false;

    // now render the metafile:
    wxMemoryDC bmpDC;
    bmpDC.SelectObject(bmp);
    bmpDC.Clear();

    wxRect outRect(0, 0, bmp.GetWidth(), bmp.GetHeight());
    metafile->Play(&bmpDC, &outRect);


    delete metafile;

    // TODO: we should keep the metafile and reuse it when changing zoom level

    return true;
}


/****************************************************************************

  FUNCTION: wxAbortProc()

    PURPOSE:  Processes messages for the Abort Dialog box

****************************************************************************/

LONG APIENTRY _EXPORT wxAbortProc(HDC WXUNUSED(hPr), int WXUNUSED(Code))
{
    MSG msg;

    if (!wxPrinterBase::sm_abortWindow)              /* If the abort dialog isn't up yet */
        return(TRUE);

    /* Process messages intended for the abort dialog box */

    while (!wxPrinterBase::sm_abortIt && ::PeekMessage(&msg, 0, 0, 0, TRUE))
        if (!IsDialogMessage((HWND) wxPrinterBase::sm_abortWindow->GetHWND(), &msg)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

    /* bAbort is TRUE (return is FALSE) if the user has aborted */

    return !wxPrinterBase::sm_abortIt;
}

#endif
    // wxUSE_PRINTING_ARCHITECTURE
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/msw/printwin.cpp
	3	// Purpose: wxWindowsPrinter framework
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ===========================================================================
	13	// declarations
	14	// ===========================================================================
	15
	16	// ---------------------------------------------------------------------------
	17	// headers
	18	// ---------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	// Don't use the Windows printer if we're in wxUniv mode and using
	28	// the PostScript architecture
	29	#if wxUSE_PRINTING_ARCHITECTURE && (!defined(__WXUNIVERSAL__) \|\| !wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW)
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/msw/wrapcdlg.h"
	33	#include "wx/window.h"
	34	#include "wx/msw/private.h"
	35	#include "wx/utils.h"
	36	#include "wx/dc.h"
	37	#include "wx/app.h"
	38	#include "wx/msgdlg.h"
	39	#include "wx/intl.h"
	40	#include "wx/log.h"
	41	#include "wx/dcprint.h"
	42	#include "wx/dcmemory.h"
	43	#include "wx/image.h"
	44	#endif
	45
	46	#include "wx/msw/dib.h"
	47	#include "wx/msw/dcmemory.h"
	48	#include "wx/msw/printwin.h"
	49	#include "wx/msw/printdlg.h"
	50	#include "wx/msw/private.h"
	51	#include "wx/msw/dcprint.h"
	52	#include "wx/msw/enhmeta.h"
	53
	54	#include <stdlib.h>
	55
	56	#ifndef __WIN32__
	57	#include <print.h>
	58	#endif
	59
	60	// ---------------------------------------------------------------------------
	61	// private functions
	62	// ---------------------------------------------------------------------------
	63
	64	LONG APIENTRY _EXPORT wxAbortProc(HDC hPr, int Code);
	65
	66	// ---------------------------------------------------------------------------
	67	// wxWin macros
	68	// ---------------------------------------------------------------------------
	69
	70	IMPLEMENT_DYNAMIC_CLASS(wxWindowsPrinter, wxPrinterBase)
	71	IMPLEMENT_CLASS(wxWindowsPrintPreview, wxPrintPreviewBase)
	72
	73	// ===========================================================================
	74	// implementation
	75	// ===========================================================================
	76
	77	// ---------------------------------------------------------------------------
	78	// Printer
	79	// ---------------------------------------------------------------------------
	80
	81	wxWindowsPrinter::wxWindowsPrinter(wxPrintDialogData *data)
	82	: wxPrinterBase(data)
	83	{
	84	m_lpAbortProc = (WXFARPROC)wxAbortProc;
	85	}
	86
	87	wxWindowsPrinter::~wxWindowsPrinter()
	88	{
	89	// avoids warning about statement with no effect (FreeProcInstance
	90	// doesn't do anything under Win32)
	91	#if !defined(__WIN32__) && !defined(__NT__)
	92	FreeProcInstance((FARPROC) m_lpAbortProc);
	93	#endif
	94	}
	95
	96	bool wxWindowsPrinter::Print(wxWindow parent, wxPrintout printout, bool prompt)
	97	{
	98	sm_abortIt = false;
	99	sm_abortWindow = NULL;
	100
	101	if (!printout)
	102	{
	103	sm_lastError = wxPRINTER_ERROR;
	104	return false;
	105	}
	106
	107	printout->SetIsPreview(false);
	108
	109	if (m_printDialogData.GetMinPage() < 1)
	110	m_printDialogData.SetMinPage(1);
	111	if (m_printDialogData.GetMaxPage() < 1)
	112	m_printDialogData.SetMaxPage(9999);
	113
	114	// Create a suitable device context
	115	wxPrinterDC *dc wxDUMMY_INITIALIZE(NULL);
	116	if (prompt)
	117	{
	118	dc = wxDynamicCast(PrintDialog(parent), wxPrinterDC);
	119	if (!dc)
	120	return false;
	121	}
	122	else
	123	{
	124	dc = new wxPrinterDC(m_printDialogData.GetPrintData());
	125	}
	126
	127	// May have pressed cancel.
	128	if (!dc \|\| !dc->IsOk())
	129	{
	130	if (dc) delete dc;
	131	return false;
	132	}
	133
	134	wxPrinterDCImpl impl = (wxPrinterDCImpl) dc->GetImpl();
	135
	136	HDC hdc = ::GetDC(NULL);
	137	int logPPIScreenX = ::GetDeviceCaps(hdc, LOGPIXELSX);
	138	int logPPIScreenY = ::GetDeviceCaps(hdc, LOGPIXELSY);
	139	::ReleaseDC(NULL, hdc);
	140
	141	int logPPIPrinterX = ::GetDeviceCaps((HDC) impl->GetHDC(), LOGPIXELSX);
	142	int logPPIPrinterY = ::GetDeviceCaps((HDC) impl->GetHDC(), LOGPIXELSY);
	143	if (logPPIPrinterX == 0 \|\| logPPIPrinterY == 0)
	144	{
	145	delete dc;
	146	sm_lastError = wxPRINTER_ERROR;
	147	return false;
	148	}
	149
	150	printout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
	151	printout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);
	152
	153	// Set printout parameters
	154	printout->SetDC(dc);
	155
	156	int w, h;
	157	dc->GetSize(&w, &h);
	158	printout->SetPageSizePixels((int)w, (int)h);
	159	printout->SetPaperRectPixels(dc->GetPaperRect());
	160
	161	dc->GetSizeMM(&w, &h);
	162	printout->SetPageSizeMM((int)w, (int)h);
	163
	164	// Create an abort window
	165	wxBusyCursor busyCursor;
	166
	167	printout->OnPreparePrinting();
	168
	169	// Get some parameters from the printout, if defined
	170	int fromPage, toPage;
	171	int minPage, maxPage;
	172	printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
	173
	174	if (maxPage == 0)
	175	{
	176	sm_lastError = wxPRINTER_ERROR;
	177	return false;
	178	}
	179
	180	// Only set min and max, because from and to have been
	181	// set by the user
	182	m_printDialogData.SetMinPage(minPage);
	183	m_printDialogData.SetMaxPage(maxPage);
	184
	185	wxWindow *win = CreateAbortWindow(parent, printout);
	186	wxYield();
	187
	188	#if defined(__WATCOMC__) \|\| defined(__BORLANDC__) \|\| defined(__GNUWIN32__) \|\| !defined(__WIN32__)
	189	#ifdef STRICT
	190	::SetAbortProc((HDC) impl->GetHDC(), (ABORTPROC) m_lpAbortProc);
	191	#else
	192	::SetAbortProc((HDC) impl->GetHDC(), (FARPROC) m_lpAbortProc);
	193	#endif
	194	#else
	195	::SetAbortProc((HDC) impl->GetHDC(), (int (_stdcall *)
	196	// cast it to right type only if required
	197	// FIXME it's really cdecl and we're casting it to stdcall - either there is
	198	// something I don't understand or it will crash at first usage
	199	#ifdef STRICT
	200	(HDC, int)
	201	#else
	202	()
	203	#endif
	204	)m_lpAbortProc);
	205	#endif
	206
	207	if (!win)
	208	{
	209	wxLogDebug(wxT("Could not create an abort dialog."));
	210	sm_lastError = wxPRINTER_ERROR;
	211
	212	delete dc;
	213	return false;
	214	}
	215	sm_abortWindow = win;
	216	sm_abortWindow->Show();
	217	wxSafeYield();
	218
	219	printout->OnBeginPrinting();
	220
	221	sm_lastError = wxPRINTER_NO_ERROR;
	222
	223	int minPageNum = minPage, maxPageNum = maxPage;
	224
	225	if ( !m_printDialogData.GetAllPages() )
	226	{
	227	minPageNum = m_printDialogData.GetFromPage();
	228	maxPageNum = m_printDialogData.GetToPage();
	229	}
	230
	231	int copyCount;
	232	for ( copyCount = 1;
	233	copyCount <= m_printDialogData.GetNoCopies();
	234	copyCount++ )
	235	{
	236	if ( !printout->OnBeginDocument(minPageNum, maxPageNum) )
	237	{
	238	wxLogError(_("Could not start printing."));
	239	sm_lastError = wxPRINTER_ERROR;
	240	break;
	241	}
	242	if (sm_abortIt)
	243	{
	244	sm_lastError = wxPRINTER_CANCELLED;
	245	break;
	246	}
	247
	248	int pn;
	249
	250	for ( pn = minPageNum;
	251	pn <= maxPageNum && printout->HasPage(pn);
	252	pn++ )
	253	{
	254	if ( sm_abortIt )
	255	{
	256	sm_lastError = wxPRINTER_CANCELLED;
	257	break;
	258	}
	259
	260	dc->StartPage();
	261	bool cont = printout->OnPrintPage(pn);
	262	dc->EndPage();
	263
	264	if ( !cont )
	265	{
	266	sm_lastError = wxPRINTER_CANCELLED;
	267	break;
	268	}
	269	}
	270
	271	printout->OnEndDocument();
	272	}
	273
	274	printout->OnEndPrinting();
	275
	276	if (sm_abortWindow)
	277	{
	278	sm_abortWindow->Show(false);
	279	delete sm_abortWindow;
	280	sm_abortWindow = NULL;
	281	}
	282
	283	delete dc;
	284
	285	return sm_lastError == wxPRINTER_NO_ERROR;
	286	}
	287
	288	wxDC wxWindowsPrinter::PrintDialog(wxWindow parent)
	289	{
	290	wxDC *dc = NULL;
	291
	292	wxWindowsPrintDialog dialog(parent, & m_printDialogData);
	293	int ret = dialog.ShowModal();
	294
	295	if (ret == wxID_OK)
	296	{
	297	dc = dialog.GetPrintDC();
	298	m_printDialogData = dialog.GetPrintDialogData();
	299	if (dc == NULL)
	300	sm_lastError = wxPRINTER_ERROR;
	301	else
	302	sm_lastError = wxPRINTER_NO_ERROR;
	303	}
	304	else
	305	sm_lastError = wxPRINTER_CANCELLED;
	306
	307	return dc;
	308	}
	309
	310	bool wxWindowsPrinter::Setup(wxWindow *WXUNUSED(parent))
	311	{
	312	#if 0
	313	// We no longer expose that dialog
	314	wxPrintDialog dialog(parent, & m_printDialogData);
	315	dialog.GetPrintDialogData().SetSetupDialog(true);
	316
	317	int ret = dialog.ShowModal();
	318
	319	if (ret == wxID_OK)
	320	{
	321	m_printDialogData = dialog.GetPrintDialogData();
	322	}
	323
	324	return (ret == wxID_OK);
	325	#else
	326	return false;
	327	#endif
	328	}
	329
	330	/*
	331	* Print preview
	332	*/
	333
	334	wxWindowsPrintPreview::wxWindowsPrintPreview(wxPrintout *printout,
	335	wxPrintout *printoutForPrinting,
	336	wxPrintDialogData *data)
	337	: wxPrintPreviewBase(printout, printoutForPrinting, data)
	338	{
	339	DetermineScaling();
	340	}
	341
	342	wxWindowsPrintPreview::wxWindowsPrintPreview(wxPrintout *printout,
	343	wxPrintout *printoutForPrinting,
	344	wxPrintData *data)
	345	: wxPrintPreviewBase(printout, printoutForPrinting, data)
	346	{
	347	DetermineScaling();
	348	}
	349
	350	wxWindowsPrintPreview::~wxWindowsPrintPreview()
	351	{
	352	}
	353
	354	bool wxWindowsPrintPreview::Print(bool interactive)
	355	{
	356	if (!m_printPrintout)
	357	return false;
	358	wxWindowsPrinter printer(&m_printDialogData);
	359	return printer.Print(m_previewFrame, m_printPrintout, interactive);
	360	}
	361
	362	void wxWindowsPrintPreview::DetermineScaling()
	363	{
	364	ScreenHDC dc;
	365	int logPPIScreenX = ::GetDeviceCaps(dc, LOGPIXELSX);
	366	int logPPIScreenY = ::GetDeviceCaps(dc, LOGPIXELSY);
	367	m_previewPrintout->SetPPIScreen(logPPIScreenX, logPPIScreenY);
	368
	369	// Get a device context for the currently selected printer
	370	wxPrinterDC printerDC(m_printDialogData.GetPrintData());
	371
	372	int printerWidthMM;
	373	int printerHeightMM;
	374	int printerXRes;
	375	int printerYRes;
	376	int logPPIPrinterX;
	377	int logPPIPrinterY;
	378
	379	wxRect paperRect;
	380
	381	if ( printerDC.IsOk() )
	382	{
	383	wxPrinterDCImpl impl = (wxPrinterDCImpl) printerDC.GetImpl();
	384	HDC dc = GetHdcOf(*impl);
	385	printerWidthMM = ::GetDeviceCaps(dc, HORZSIZE);
	386	printerHeightMM = ::GetDeviceCaps(dc, VERTSIZE);
	387	printerXRes = ::GetDeviceCaps(dc, HORZRES);
	388	printerYRes = ::GetDeviceCaps(dc, VERTRES);
	389	logPPIPrinterX = ::GetDeviceCaps(dc, LOGPIXELSX);
	390	logPPIPrinterY = ::GetDeviceCaps(dc, LOGPIXELSY);
	391
	392	paperRect = printerDC.GetPaperRect();
	393
	394	if ( logPPIPrinterX == 0 \|\|
	395	logPPIPrinterY == 0 \|\|
	396	printerWidthMM == 0 \|\|
	397	printerHeightMM == 0 )
	398	{
	399	m_isOk = false;
	400	}
	401	}
	402	else
	403	{
	404	// use some defaults
	405	printerWidthMM = 150;
	406	printerHeightMM = 250;
	407	printerXRes = 1500;
	408	printerYRes = 2500;
	409	logPPIPrinterX = 600;
	410	logPPIPrinterY = 600;
	411
	412	paperRect = wxRect(0, 0, printerXRes, printerYRes);
	413	m_isOk = false;
	414	}
	415	m_pageWidth = printerXRes;
	416	m_pageHeight = printerYRes;
	417	m_previewPrintout->SetPageSizePixels(printerXRes, printerYRes);
	418	m_previewPrintout->SetPageSizeMM(printerWidthMM, printerHeightMM);
	419	m_previewPrintout->SetPaperRectPixels(paperRect);
	420	m_previewPrintout->SetPPIPrinter(logPPIPrinterX, logPPIPrinterY);
	421
	422	// At 100%, the page should look about page-size on the screen.
	423	m_previewScaleX = float(logPPIScreenX) / logPPIPrinterX;
	424	m_previewScaleY = float(logPPIScreenY) / logPPIPrinterY;
	425	}
	426
	427	bool wxWindowsPrintPreview::RenderPageIntoBitmap(wxBitmap& bmp, int pageNum)
	428	{
	429	// The preview, as implemented in wxPrintPreviewBase (and as used prior to
	430	// wx3) is inexact: it uses screen DC, which has much lower resolution and
	431	// has other properties different from printer DC, so the preview is not
	432	// quite right.
	433	//
	434	// To make matters worse, if the application depends heavily on
	435	// GetTextExtent() or does text layout itself, the output in preview and on
	436	// paper can be very different. In particular, wxHtmlEasyPrinting is
	437	// affected and the preview can be easily off by several pages.
	438	//
	439	// To fix this, we render the preview into high-resolution enhanced
	440	// metafile with properties identical to the printer DC. This guarantees
	441	// metrics correctness while still being fast.
	442
	443
	444	// print the preview into a metafile:
	445	wxPrinterDC printerDC(m_printDialogData.GetPrintData());
	446	wxEnhMetaFileDC metaDC(printerDC,
	447	wxEmptyString,
	448	printerDC.GetSize().x, printerDC.GetSize().y);
	449
	450	if ( !RenderPageIntoDC(metaDC, pageNum) )
	451	return false;
	452
	453	wxEnhMetaFile *metafile = metaDC.Close();
	454	if ( !metafile )
	455	return false;
	456
	457	// now render the metafile:
	458	wxMemoryDC bmpDC;
	459	bmpDC.SelectObject(bmp);
	460	bmpDC.Clear();
	461
	462	wxRect outRect(0, 0, bmp.GetWidth(), bmp.GetHeight());
	463	metafile->Play(&bmpDC, &outRect);
	464
	465
	466	delete metafile;
	467
	468	// TODO: we should keep the metafile and reuse it when changing zoom level
	469
	470	return true;
	471	}
	472
	473
	474	/****************************************************************************
	475
	476	FUNCTION: wxAbortProc()
	477
	478	PURPOSE: Processes messages for the Abort Dialog box
	479
	480	****************************************************************************/
	481
	482	LONG APIENTRY _EXPORT wxAbortProc(HDC WXUNUSED(hPr), int WXUNUSED(Code))
	483	{
	484	MSG msg;
	485
	486	if (!wxPrinterBase::sm_abortWindow) /* If the abort dialog isn't up yet */
	487	return(TRUE);
	488
	489	/* Process messages intended for the abort dialog box */
	490
	491	while (!wxPrinterBase::sm_abortIt && ::PeekMessage(&msg, 0, 0, 0, TRUE))
	492	if (!IsDialogMessage((HWND) wxPrinterBase::sm_abortWindow->GetHWND(), &msg)) {
	493	TranslateMessage(&msg);
	494	DispatchMessage(&msg);
	495	}
	496
	497	/* bAbort is TRUE (return is FALSE) if the user has aborted */
	498
	499	return !wxPrinterBase::sm_abortIt;
	500	}
	501
	502	#endif
	503	// wxUSE_PRINTING_ARCHITECTURE