src/mac/carbon/dcprint.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/mac/carbon/dcprint.cpp
// Purpose:     wxPrinterDC class
// Author:      Julian Smart
// Modified by:
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#if wxUSE_PRINTING_ARCHITECTURE

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/dcprint.h"

#ifndef WX_PRECOMP
    #include "wx/msgdlg.h"
    #include "wx/math.h"
#endif

#include "wx/mac/uma.h"
#include "wx/mac/private/print.h"
#include "wx/graphics.h"

IMPLEMENT_CLASS(wxPrinterDC, wxDC)

class wxNativePrinterDC
{
public :
    wxNativePrinterDC() {}
    virtual ~wxNativePrinterDC() {}
    virtual bool StartDoc(  wxPrinterDC* dc , const wxString& message ) = 0;
    virtual void EndDoc( wxPrinterDC* dc ) = 0;
    virtual void StartPage( wxPrinterDC* dc ) = 0;
    virtual void EndPage( wxPrinterDC* dc ) = 0;
    virtual void GetSize( int *w , int *h) const = 0 ;
    virtual wxSize GetPPI() const = 0 ;

    // returns 0 in case of no Error, otherwise platform specific error codes
    virtual wxUint32 GetStatus() const = 0 ;
    bool Ok() { return GetStatus() == 0 ; }

    static wxNativePrinterDC* Create(wxPrintData* data) ;
} ;

class wxMacCarbonPrinterDC : public wxNativePrinterDC
{
public :
    wxMacCarbonPrinterDC( wxPrintData* data ) ;
    virtual ~wxMacCarbonPrinterDC() ;
    virtual bool StartDoc(  wxPrinterDC* dc , const wxString& message ) ;
    virtual void EndDoc( wxPrinterDC* dc ) ;
    virtual void StartPage( wxPrinterDC* dc ) ;
    virtual void EndPage( wxPrinterDC* dc ) ;
    virtual wxUint32 GetStatus() const { return m_err ; }
    virtual void GetSize( int *w , int *h) const ;
    virtual wxSize GetPPI() const ;
private :
#if !wxMAC_USE_CORE_GRAPHICS
    GrafPtr m_macPrintFormerPort ;
#endif
    wxCoord m_maxX ;
    wxCoord m_maxY ;
    wxSize  m_ppi ;
    OSStatus m_err ;
} ;

wxMacCarbonPrinterDC::wxMacCarbonPrinterDC( wxPrintData* data )
{
#if !wxMAC_USE_CORE_GRAPHICS
    ::GetPort( & m_macPrintFormerPort ) ;
#endif
    m_err = noErr ;
    wxMacCarbonPrintData *native = (wxMacCarbonPrintData*) data->GetNativeData() ;

    PMRect rPage;
    m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
    if ( m_err != noErr )
        return;

    m_maxX = wxCoord(rPage.right - rPage.left) ;
    m_maxY = wxCoord(rPage.bottom - rPage.top);

    PMResolution res;
#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
    PMPrinter printer;
    PMSessionGetCurrentPrinter(native->m_macPrintSession, &printer);
    PMPrinterGetOutputResolution( printer, native->m_macPrintSettings, &res) ;
#else
    m_err = PMGetResolution((PMPageFormat) (native->m_macPageFormat), &res);
#endif
    m_ppi = wxSize(int(res.hRes), int(res.vRes));
}

wxMacCarbonPrinterDC::~wxMacCarbonPrinterDC()
{
#if !wxMAC_USE_CORE_GRAPHICS
    // nothing to release from print data, as wxPrinterDC has all data in its wxPrintData member
    ::SetPort( m_macPrintFormerPort ) ;
#endif
}

wxNativePrinterDC* wxNativePrinterDC::Create(wxPrintData* data)
{
    return new wxMacCarbonPrinterDC(data) ;
}

bool wxMacCarbonPrinterDC::StartDoc(  wxPrinterDC* dc , const wxString& WXUNUSED(message)  )
{
    if ( m_err )
        return false ;

    wxMacCarbonPrintData *native = (wxMacCarbonPrintData*) dc->GetPrintData().GetNativeData() ;

#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_4 && wxMAC_USE_CORE_GRAPHICS
    {
        CFStringRef s[1] = { kPMGraphicsContextCoreGraphics };
        CFArrayRef  graphicsContextsArray = CFArrayCreate(NULL, (const void**)s, 1, &kCFTypeArrayCallBacks);
        PMSessionSetDocumentFormatGeneration(native->m_macPrintSession, kPMDocumentFormatPDF, graphicsContextsArray, NULL);
        CFRelease(graphicsContextsArray);
    }
#endif
#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4 && wxMAC_USE_CORE_GRAPHICS
    m_err = PMSessionBeginCGDocument(native->m_macPrintSession,
              native->m_macPrintSettings,
              native->m_macPageFormat);
#else
    m_err = PMSessionBeginDocument(native->m_macPrintSession,
              native->m_macPrintSettings,
              native->m_macPageFormat);

#endif

    if ( m_err != noErr )
        return false;

    PMRect rPage;
    m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
    if ( m_err != noErr )
        return false ;

    m_maxX = wxCoord(rPage.right - rPage.left) ;
    m_maxY = wxCoord(rPage.bottom - rPage.top);

    PMResolution res;
#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
    PMPrinter printer;
    PMSessionGetCurrentPrinter(native->m_macPrintSession, &printer);
    PMPrinterGetOutputResolution( printer, native->m_macPrintSettings, &res) ;
#else
    m_err = PMGetResolution((PMPageFormat) (native->m_macPageFormat), &res);
#endif
    m_ppi = wxSize(int(res.hRes), int(res.vRes));
    return true ;
}

void wxMacCarbonPrinterDC::EndDoc( wxPrinterDC* dc )
{
    if ( m_err )
        return ;

    wxMacCarbonPrintData *native = (wxMacCarbonPrintData*) dc->GetPrintData().GetNativeData() ;

    m_err = PMSessionEndDocument(native->m_macPrintSession);
}

void wxMacCarbonPrinterDC::StartPage( wxPrinterDC* dc )
{
    if ( m_err )
        return ;

    wxMacCarbonPrintData *native = (wxMacCarbonPrintData*) dc->GetPrintData().GetNativeData() ;

    m_err = PMSessionBeginPage(native->m_macPrintSession,
                 native->m_macPageFormat,
                 nil);

#if wxMAC_USE_CORE_GRAPHICS
    CGContextRef pageContext;
#endif
    if ( m_err == noErr )
    {
#if wxMAC_USE_CORE_GRAPHICS
#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4
        m_err = PMSessionGetCGGraphicsContext(native->m_macPrintSession,
                                            &pageContext );

#else
        m_err = PMSessionGetGraphicsContext(native->m_macPrintSession,
                                            kPMGraphicsContextCoreGraphics,
                                            (void**) &pageContext );
#endif
#else
        m_err = PMSessionGetGraphicsContext(native->m_macPrintSession,
                                            kPMGraphicsContextQuickdraw,
                                            (void**) &dc->m_macPort );
#endif
    }

    if ( m_err != noErr )
    {
        PMSessionEndPage(native->m_macPrintSession);
        PMSessionEndDocument(native->m_macPrintSession);
    }
    else
    {
        PMRect rPage;

        m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
        if ( !m_err )
        {
#if wxMAC_USE_CORE_GRAPHICS
            PMRect paperRect ;
            PMGetAdjustedPaperRect( native->m_macPageFormat , &paperRect ) ;
            // make sure (0,0) is at the upper left of the printable area (wx conventions)
            // Core Graphics initially has the lower left of the paper as 0,0
            CGContextTranslateCTM( pageContext , -paperRect.left , paperRect.bottom ) ;
            CGContextScaleCTM( pageContext , 1 , -1 ) ;
#else
            dc->m_macLocalOrigin.x = (int) rPage.left;
            dc->m_macLocalOrigin.y = (int) rPage.top;
#endif
        }
        // since this is a non-critical error, we set the flag back
        m_err = noErr ;
    }
#if wxMAC_USE_CORE_GRAPHICS
    dc->SetGraphicsContext( wxGraphicsContext::CreateFromNative( pageContext ) );
#endif
}

void wxMacCarbonPrinterDC::EndPage( wxPrinterDC* dc )
{
    if ( m_err )
        return ;

    wxMacCarbonPrintData *native = (wxMacCarbonPrintData*) dc->GetPrintData().GetNativeData() ;

    m_err = PMSessionEndPage(native->m_macPrintSession);
    if ( m_err != noErr )
    {
        PMSessionEndDocument(native->m_macPrintSession);
    }
#if wxMAC_USE_CORE_GRAPHICS
    // the cg context we got when starting the page isn't valid anymore, so replace it
    dc->SetGraphicsContext( wxGraphicsContext::Create() );
#endif
}

void wxMacCarbonPrinterDC::GetSize( int *w , int *h) const
{
    if ( w )
        *w = m_maxX ;
    if ( h )
        *h = m_maxY ;
}

wxSize wxMacCarbonPrinterDC::GetPPI() const
{
     return m_ppi ;
};

//
//
//

wxPrinterDC::wxPrinterDC(const wxPrintData& printdata)
{
    m_ok = false ;
    m_printData = printdata ;
    m_printData.ConvertToNative() ;
    m_nativePrinterDC = wxNativePrinterDC::Create( &m_printData ) ;
    if ( m_nativePrinterDC )
    {
        m_ok = m_nativePrinterDC->Ok() ;
        if ( !m_ok )
        {
            wxString message ;
            message.Printf( wxT("Print Error %u"), m_nativePrinterDC->GetStatus() ) ;
            wxMessageDialog dialog( NULL , message , wxEmptyString, wxICON_HAND | wxOK) ;
            dialog.ShowModal();
        }
        else
        {
            wxSize sz = GetPPI();
            m_mm_to_pix_x = mm2inches * sz.x;
            m_mm_to_pix_y = mm2inches * sz.y;
        }
#if wxMAC_USE_CORE_GRAPHICS
        // we need at least a measuring context because people start measuring before a page
        // gets printed at all
        SetGraphicsContext( wxGraphicsContext::Create() );
#endif
    }
}

wxSize wxPrinterDC::GetPPI() const
{
    return m_nativePrinterDC->GetPPI() ;
}

wxPrinterDC::~wxPrinterDC(void)
{
    delete m_nativePrinterDC ;
}

bool wxPrinterDC::StartDoc( const wxString& message )
{
    wxASSERT_MSG( Ok() , wxT("Called wxPrinterDC::StartDoc from an invalid object") ) ;

    if ( !m_ok )
        return false ;

    if ( m_nativePrinterDC->StartDoc(this, message ) )
    {
        // in case we have to do additional things when successful
    }
    m_ok = m_nativePrinterDC->Ok() ;
    if ( !m_ok )
    {
        wxString message ;
        message.Printf( wxT("Print Error %u"), m_nativePrinterDC->GetStatus() ) ;
        wxMessageDialog dialog( NULL , message , wxEmptyString, wxICON_HAND | wxOK) ;
        dialog.ShowModal();
    }

    return m_ok ;
}

void wxPrinterDC::EndDoc(void)
{
    if ( !m_ok )
        return ;

    m_nativePrinterDC->EndDoc( this ) ;
    m_ok = m_nativePrinterDC->Ok() ;

    if ( !m_ok )
    {
        wxString message ;
        message.Printf( wxT("Print Error %u"), m_nativePrinterDC->GetStatus() ) ;
        wxMessageDialog dialog( NULL , message , wxEmptyString, wxICON_HAND | wxOK) ;
        dialog.ShowModal();
    }
}

wxRect wxPrinterDC::GetPaperRect()
{
    wxCoord w, h;
    GetSize(&w, &h);
    wxRect pageRect(0, 0, w, h);
    wxMacCarbonPrintData *native = (wxMacCarbonPrintData*) m_printData.GetNativeData() ;
    OSStatus err = noErr ;
    PMRect rPaper;
    err = PMGetAdjustedPaperRect(native->m_macPageFormat, &rPaper);
    if ( err != noErr )
        return pageRect;
    return wxRect(wxCoord(rPaper.left), wxCoord(rPaper.top),
        wxCoord(rPaper.right - rPaper.left), wxCoord(rPaper.bottom - rPaper.top));
}

void wxPrinterDC::StartPage(void)
{
    if ( !m_ok )
        return ;

    m_logicalFunction = wxCOPY;
    //  m_textAlignment = wxALIGN_TOP_LEFT;
    m_backgroundMode = wxTRANSPARENT;

    m_textForegroundColour = *wxBLACK;
    m_textBackgroundColour = *wxWHITE;
    m_pen = *wxBLACK_PEN;
    m_font = *wxNORMAL_FONT;
    m_brush = *wxTRANSPARENT_BRUSH;
    m_backgroundBrush = *wxWHITE_BRUSH;
#if !wxMAC_USE_CORE_GRAPHICS
    m_macFontInstalled = false ;
    m_macBrushInstalled = false ;
    m_macPenInstalled = false ;
#endif

    m_nativePrinterDC->StartPage(this) ;
    m_ok = m_nativePrinterDC->Ok() ;

}

void wxPrinterDC::EndPage(void)
{
    if ( !m_ok )
        return ;

    m_nativePrinterDC->EndPage(this) ;
    m_ok = m_nativePrinterDC->Ok() ;
}

void wxPrinterDC::DoGetSize(int *width, int *height) const
{
    wxCHECK_RET( m_ok , _T("GetSize() doesn't work without a valid wxPrinterDC") );
    m_nativePrinterDC->GetSize(width,  height ) ;
}

#endif
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/mac/carbon/dcprint.cpp
	3	// Purpose: wxPrinterDC class
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 01/02/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#if wxUSE_PRINTING_ARCHITECTURE
	16
	17	#ifdef __BORLANDC__
	18	#pragma hdrstop
	19	#endif
	20
	21	#include "wx/dcprint.h"
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/msgdlg.h"
	25	#include "wx/math.h"
	26	#endif
	27
	28	#include "wx/mac/uma.h"
	29	#include "wx/mac/private/print.h"
	30	#include "wx/graphics.h"
	31
	32	IMPLEMENT_CLASS(wxPrinterDC, wxDC)
	33
	34	class wxNativePrinterDC
	35	{
	36	public :
	37	wxNativePrinterDC() {}
	38	virtual ~wxNativePrinterDC() {}
	39	virtual bool StartDoc( wxPrinterDC* dc , const wxString& message ) = 0;
	40	virtual void EndDoc( wxPrinterDC* dc ) = 0;
	41	virtual void StartPage( wxPrinterDC* dc ) = 0;
	42	virtual void EndPage( wxPrinterDC* dc ) = 0;
	43	virtual void GetSize( int w , int h) const = 0 ;
	44	virtual wxSize GetPPI() const = 0 ;
	45
	46	// returns 0 in case of no Error, otherwise platform specific error codes
	47	virtual wxUint32 GetStatus() const = 0 ;
	48	bool Ok() { return GetStatus() == 0 ; }
	49
	50	static wxNativePrinterDC* Create(wxPrintData* data) ;
	51	} ;
	52
	53	class wxMacCarbonPrinterDC : public wxNativePrinterDC
	54	{
	55	public :
	56	wxMacCarbonPrinterDC( wxPrintData* data ) ;
	57	virtual ~wxMacCarbonPrinterDC() ;
	58	virtual bool StartDoc( wxPrinterDC* dc , const wxString& message ) ;
	59	virtual void EndDoc( wxPrinterDC* dc ) ;
	60	virtual void StartPage( wxPrinterDC* dc ) ;
	61	virtual void EndPage( wxPrinterDC* dc ) ;
	62	virtual wxUint32 GetStatus() const { return m_err ; }
	63	virtual void GetSize( int w , int h) const ;
	64	virtual wxSize GetPPI() const ;
	65	private :
	66	#if !wxMAC_USE_CORE_GRAPHICS
	67	GrafPtr m_macPrintFormerPort ;
	68	#endif
	69	wxCoord m_maxX ;
	70	wxCoord m_maxY ;
	71	wxSize m_ppi ;
	72	OSStatus m_err ;
	73	} ;
	74
	75	wxMacCarbonPrinterDC::wxMacCarbonPrinterDC( wxPrintData* data )
	76	{
	77	#if !wxMAC_USE_CORE_GRAPHICS
	78	::GetPort( & m_macPrintFormerPort ) ;
	79	#endif
	80	m_err = noErr ;
	81	wxMacCarbonPrintData native = (wxMacCarbonPrintData) data->GetNativeData() ;
	82
	83	PMRect rPage;
	84	m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
	85	if ( m_err != noErr )
	86	return;
	87
	88	m_maxX = wxCoord(rPage.right - rPage.left) ;
	89	m_maxY = wxCoord(rPage.bottom - rPage.top);
	90
	91	PMResolution res;
	92	#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
	93	PMPrinter printer;
	94	PMSessionGetCurrentPrinter(native->m_macPrintSession, &printer);
	95	PMPrinterGetOutputResolution( printer, native->m_macPrintSettings, &res) ;
	96	#else
	97	m_err = PMGetResolution((PMPageFormat) (native->m_macPageFormat), &res);
	98	#endif
	99	m_ppi = wxSize(int(res.hRes), int(res.vRes));
	100	}
	101
	102	wxMacCarbonPrinterDC::~wxMacCarbonPrinterDC()
	103	{
	104	#if !wxMAC_USE_CORE_GRAPHICS
	105	// nothing to release from print data, as wxPrinterDC has all data in its wxPrintData member
	106	::SetPort( m_macPrintFormerPort ) ;
	107	#endif
	108	}
	109
	110	wxNativePrinterDC* wxNativePrinterDC::Create(wxPrintData* data)
	111	{
	112	return new wxMacCarbonPrinterDC(data) ;
	113	}
	114
	115	bool wxMacCarbonPrinterDC::StartDoc( wxPrinterDC* dc , const wxString& WXUNUSED(message) )
	116	{
	117	if ( m_err )
	118	return false ;
	119
	120	wxMacCarbonPrintData native = (wxMacCarbonPrintData) dc->GetPrintData().GetNativeData() ;
	121
	122	#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_4 && wxMAC_USE_CORE_GRAPHICS
	123	{
	124	CFStringRef s[1] = { kPMGraphicsContextCoreGraphics };
	125	CFArrayRef graphicsContextsArray = CFArrayCreate(NULL, (const void**)s, 1, &kCFTypeArrayCallBacks);
	126	PMSessionSetDocumentFormatGeneration(native->m_macPrintSession, kPMDocumentFormatPDF, graphicsContextsArray, NULL);
	127	CFRelease(graphicsContextsArray);
	128	}
	129	#endif
	130	#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4 && wxMAC_USE_CORE_GRAPHICS
	131	m_err = PMSessionBeginCGDocument(native->m_macPrintSession,
	132	native->m_macPrintSettings,
	133	native->m_macPageFormat);
	134	#else
	135	m_err = PMSessionBeginDocument(native->m_macPrintSession,
	136	native->m_macPrintSettings,
	137	native->m_macPageFormat);
	138
	139	#endif
	140
	141	if ( m_err != noErr )
	142	return false;
	143
	144	PMRect rPage;
	145	m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
	146	if ( m_err != noErr )
	147	return false ;
	148
	149	m_maxX = wxCoord(rPage.right - rPage.left) ;
	150	m_maxY = wxCoord(rPage.bottom - rPage.top);
	151
	152	PMResolution res;
	153	#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
	154	PMPrinter printer;
	155	PMSessionGetCurrentPrinter(native->m_macPrintSession, &printer);
	156	PMPrinterGetOutputResolution( printer, native->m_macPrintSettings, &res) ;
	157	#else
	158	m_err = PMGetResolution((PMPageFormat) (native->m_macPageFormat), &res);
	159	#endif
	160	m_ppi = wxSize(int(res.hRes), int(res.vRes));
	161	return true ;
	162	}
	163
	164	void wxMacCarbonPrinterDC::EndDoc( wxPrinterDC* dc )
	165	{
	166	if ( m_err )
	167	return ;
	168
	169	wxMacCarbonPrintData native = (wxMacCarbonPrintData) dc->GetPrintData().GetNativeData() ;
	170
	171	m_err = PMSessionEndDocument(native->m_macPrintSession);
	172	}
	173
	174	void wxMacCarbonPrinterDC::StartPage( wxPrinterDC* dc )
	175	{
	176	if ( m_err )
	177	return ;
	178
	179	wxMacCarbonPrintData native = (wxMacCarbonPrintData) dc->GetPrintData().GetNativeData() ;
	180
	181	m_err = PMSessionBeginPage(native->m_macPrintSession,
	182	native->m_macPageFormat,
	183	nil);
	184
	185	#if wxMAC_USE_CORE_GRAPHICS
	186	CGContextRef pageContext;
	187	#endif
	188	if ( m_err == noErr )
	189	{
	190	#if wxMAC_USE_CORE_GRAPHICS
	191	#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_4
	192	m_err = PMSessionGetCGGraphicsContext(native->m_macPrintSession,
	193	&pageContext );
	194
	195	#else
	196	m_err = PMSessionGetGraphicsContext(native->m_macPrintSession,
	197	kPMGraphicsContextCoreGraphics,
	198	(void**) &pageContext );
	199	#endif
	200	#else
	201	m_err = PMSessionGetGraphicsContext(native->m_macPrintSession,
	202	kPMGraphicsContextQuickdraw,
	203	(void**) &dc->m_macPort );
	204	#endif
	205	}
	206
	207	if ( m_err != noErr )
	208	{
	209	PMSessionEndPage(native->m_macPrintSession);
	210	PMSessionEndDocument(native->m_macPrintSession);
	211	}
	212	else
	213	{
	214	PMRect rPage;
	215
	216	m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
	217	if ( !m_err )
	218	{
	219	#if wxMAC_USE_CORE_GRAPHICS
	220	PMRect paperRect ;
	221	PMGetAdjustedPaperRect( native->m_macPageFormat , &paperRect ) ;
	222	// make sure (0,0) is at the upper left of the printable area (wx conventions)
	223	// Core Graphics initially has the lower left of the paper as 0,0
	224	CGContextTranslateCTM( pageContext , -paperRect.left , paperRect.bottom ) ;
	225	CGContextScaleCTM( pageContext , 1 , -1 ) ;
	226	#else
	227	dc->m_macLocalOrigin.x = (int) rPage.left;
	228	dc->m_macLocalOrigin.y = (int) rPage.top;
	229	#endif
	230	}
	231	// since this is a non-critical error, we set the flag back
	232	m_err = noErr ;
	233	}
	234	#if wxMAC_USE_CORE_GRAPHICS
	235	dc->SetGraphicsContext( wxGraphicsContext::CreateFromNative( pageContext ) );
	236	#endif
	237	}
	238
	239	void wxMacCarbonPrinterDC::EndPage( wxPrinterDC* dc )
	240	{
	241	if ( m_err )
	242	return ;
	243
	244	wxMacCarbonPrintData native = (wxMacCarbonPrintData) dc->GetPrintData().GetNativeData() ;
	245
	246	m_err = PMSessionEndPage(native->m_macPrintSession);
	247	if ( m_err != noErr )
	248	{
	249	PMSessionEndDocument(native->m_macPrintSession);
	250	}
	251	#if wxMAC_USE_CORE_GRAPHICS
	252	// the cg context we got when starting the page isn't valid anymore, so replace it
	253	dc->SetGraphicsContext( wxGraphicsContext::Create() );
	254	#endif
	255	}
	256
	257	void wxMacCarbonPrinterDC::GetSize( int w , int h) const
	258	{
	259	if ( w )
	260	*w = m_maxX ;
	261	if ( h )
	262	*h = m_maxY ;
	263	}
	264
	265	wxSize wxMacCarbonPrinterDC::GetPPI() const
	266	{
	267	return m_ppi ;
	268	};
	269
	270	//
	271	//
	272	//
	273
	274	wxPrinterDC::wxPrinterDC(const wxPrintData& printdata)
	275	{
	276	m_ok = false ;
	277	m_printData = printdata ;
	278	m_printData.ConvertToNative() ;
	279	m_nativePrinterDC = wxNativePrinterDC::Create( &m_printData ) ;
	280	if ( m_nativePrinterDC )
	281	{
	282	m_ok = m_nativePrinterDC->Ok() ;
	283	if ( !m_ok )
	284	{
	285	wxString message ;
	286	message.Printf( wxT("Print Error %u"), m_nativePrinterDC->GetStatus() ) ;
	287	wxMessageDialog dialog( NULL , message , wxEmptyString, wxICON_HAND \| wxOK) ;
	288	dialog.ShowModal();
	289	}
	290	else
	291	{
	292	wxSize sz = GetPPI();
	293	m_mm_to_pix_x = mm2inches * sz.x;
	294	m_mm_to_pix_y = mm2inches * sz.y;
	295	}
	296	#if wxMAC_USE_CORE_GRAPHICS
	297	// we need at least a measuring context because people start measuring before a page
	298	// gets printed at all
	299	SetGraphicsContext( wxGraphicsContext::Create() );
	300	#endif
	301	}
	302	}
	303
	304	wxSize wxPrinterDC::GetPPI() const
	305	{
	306	return m_nativePrinterDC->GetPPI() ;
	307	}
	308
	309	wxPrinterDC::~wxPrinterDC(void)
	310	{
	311	delete m_nativePrinterDC ;
	312	}
	313
	314	bool wxPrinterDC::StartDoc( const wxString& message )
	315	{
	316	wxASSERT_MSG( Ok() , wxT("Called wxPrinterDC::StartDoc from an invalid object") ) ;
	317
	318	if ( !m_ok )
	319	return false ;
	320
	321	if ( m_nativePrinterDC->StartDoc(this, message ) )
	322	{
	323	// in case we have to do additional things when successful
	324	}
	325	m_ok = m_nativePrinterDC->Ok() ;
	326	if ( !m_ok )
	327	{
	328	wxString message ;
	329	message.Printf( wxT("Print Error %u"), m_nativePrinterDC->GetStatus() ) ;
	330	wxMessageDialog dialog( NULL , message , wxEmptyString, wxICON_HAND \| wxOK) ;
	331	dialog.ShowModal();
	332	}
	333
	334	return m_ok ;
	335	}
	336
	337	void wxPrinterDC::EndDoc(void)
	338	{
	339	if ( !m_ok )
	340	return ;
	341
	342	m_nativePrinterDC->EndDoc( this ) ;
	343	m_ok = m_nativePrinterDC->Ok() ;
	344
	345	if ( !m_ok )
	346	{
	347	wxString message ;
	348	message.Printf( wxT("Print Error %u"), m_nativePrinterDC->GetStatus() ) ;
	349	wxMessageDialog dialog( NULL , message , wxEmptyString, wxICON_HAND \| wxOK) ;
	350	dialog.ShowModal();
	351	}
	352	}
	353
	354	wxRect wxPrinterDC::GetPaperRect()
	355	{
	356	wxCoord w, h;
	357	GetSize(&w, &h);
	358	wxRect pageRect(0, 0, w, h);
	359	wxMacCarbonPrintData native = (wxMacCarbonPrintData) m_printData.GetNativeData() ;
	360	OSStatus err = noErr ;
	361	PMRect rPaper;
	362	err = PMGetAdjustedPaperRect(native->m_macPageFormat, &rPaper);
	363	if ( err != noErr )
	364	return pageRect;
	365	return wxRect(wxCoord(rPaper.left), wxCoord(rPaper.top),
	366	wxCoord(rPaper.right - rPaper.left), wxCoord(rPaper.bottom - rPaper.top));
	367	}
	368
	369	void wxPrinterDC::StartPage(void)
	370	{
	371	if ( !m_ok )
	372	return ;
	373
	374	m_logicalFunction = wxCOPY;
	375	// m_textAlignment = wxALIGN_TOP_LEFT;
	376	m_backgroundMode = wxTRANSPARENT;
	377
	378	m_textForegroundColour = *wxBLACK;
	379	m_textBackgroundColour = *wxWHITE;
	380	m_pen = *wxBLACK_PEN;
	381	m_font = *wxNORMAL_FONT;
	382	m_brush = *wxTRANSPARENT_BRUSH;
	383	m_backgroundBrush = *wxWHITE_BRUSH;
	384	#if !wxMAC_USE_CORE_GRAPHICS
	385	m_macFontInstalled = false ;
	386	m_macBrushInstalled = false ;
	387	m_macPenInstalled = false ;
	388	#endif
	389
	390	m_nativePrinterDC->StartPage(this) ;
	391	m_ok = m_nativePrinterDC->Ok() ;
	392
	393	}
	394
	395	void wxPrinterDC::EndPage(void)
	396	{
	397	if ( !m_ok )
	398	return ;
	399
	400	m_nativePrinterDC->EndPage(this) ;
	401	m_ok = m_nativePrinterDC->Ok() ;
	402	}
	403
	404	void wxPrinterDC::DoGetSize(int width, int height) const
	405	{
	406	wxCHECK_RET( m_ok , _T("GetSize() doesn't work without a valid wxPrinterDC") );
	407	m_nativePrinterDC->GetSize(width, height ) ;
	408	}
	409
	410	#endif