[wxWidgets.git] / src / osx / carbon / dcprint.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/osx/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/osx/private.h"
#include "wx/osx/private/print.h"
#include "wx/osx/carbon/dcprint.h"
#include "wx/graphics.h"

IMPLEMENT_ABSTRACT_CLASS(wxPrinterDCImpl, wxGCDCImpl)

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 :
    wxCoord m_maxX ;
    wxCoord m_maxY ;
    wxSize  m_ppi ;
    OSStatus m_err ;
} ;

wxMacCarbonPrinterDC::wxMacCarbonPrinterDC( wxPrintData* data )
{
    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_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 
    if ( PMPrinterGetOutputResolution != NULL )
    {
        PMPrinter printer;
        m_err = PMSessionGetCurrentPrinter(native->m_macPrintSession, &printer);
        if ( m_err == noErr )
        {
            m_err = PMPrinterGetOutputResolution( printer, native->m_macPrintSettings, &res) ;
            if ( m_err == -9589 /* kPMKeyNotFound */ )
            {
                m_err = noErr ;
                res.hRes = res.vRes = 300;
            }
        }
    }
    else
#endif
    {
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5 
        m_err = PMGetResolution((PMPageFormat) (native->m_macPageFormat), &res);
#endif
    }
    
    m_ppi = wxSize(int(res.hRes), int(res.vRes));
}

wxMacCarbonPrinterDC::~wxMacCarbonPrinterDC()
{
}

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

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

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

    m_err = PMSessionBeginCGDocumentNoDialog(native->m_macPrintSession,
              native->m_macPrintSettings,
              native->m_macPageFormat);    
    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_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 
    if ( PMPrinterGetOutputResolution != NULL )
    {
        PMPrinter printer;
        m_err = PMSessionGetCurrentPrinter(native->m_macPrintSession, &printer);
        if ( m_err == noErr )
        {
            m_err = PMPrinterGetOutputResolution( printer, native->m_macPrintSettings, &res) ;
            if ( m_err == -9589 /* kPMKeyNotFound */ )
            {
                m_err = noErr ;
                res.hRes = res.vRes = 300;
            }
        }
    }
    else
#endif
    {
#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5 
       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 ;

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

    m_err = PMSessionEndDocumentNoDialog(native->m_macPrintSession);
}

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

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

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

    CGContextRef pageContext;

    if ( m_err == noErr )
    {
        m_err = PMSessionGetCGGraphicsContext(native->m_macPrintSession,
                                            &pageContext );
    }

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

        m_err = PMGetAdjustedPageRect(native->m_macPageFormat, &rPage);
        if ( !m_err )
        {
            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 , (CGFloat) -paperRect.left , (CGFloat) paperRect.bottom ) ;
            CGContextScaleCTM( pageContext , 1 , -1 ) ;
        }
        // since this is a non-critical error, we set the flag back
        m_err = noErr ;
    }
    impl->SetGraphicsContext( wxGraphicsContext::CreateFromNative( pageContext ) );
}

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

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

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

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 ;
};

//
//
//

wxPrinterDCImpl::wxPrinterDCImpl( wxPrinterDC *owner, const wxPrintData& printdata )
   : wxGCDCImpl( owner )
{
    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;        
        }
        // we need at least a measuring context because people start measuring before a page
        // gets printed at all
        SetGraphicsContext( wxGraphicsContext::Create() );
    }
}

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

wxPrinterDCImpl::~wxPrinterDCImpl()
{
    delete m_nativePrinterDC ;
}

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

    if ( !m_ok )
        return false ;

    if ( m_nativePrinterDC->StartDoc( (wxPrinterDC*) GetOwner(), 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 wxPrinterDCImpl::EndDoc(void)
{
    if ( !m_ok )
        return ;

    m_nativePrinterDC->EndDoc( (wxPrinterDC*) GetOwner() ) ;
    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 wxPrinterDCImpl::GetPaperRect()
{
    wxCoord w, h;
    GetOwner()->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 wxPrinterDCImpl::StartPage()
{
    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;

    m_nativePrinterDC->StartPage( (wxPrinterDC*) GetOwner() ) ;
    m_ok = m_nativePrinterDC->Ok() ;

}

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

    m_nativePrinterDC->EndPage( (wxPrinterDC*) GetOwner() );
    m_ok = m_nativePrinterDC->Ok() ;
}

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