src/osx/core/printmac.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/core/printmac.cpp
   3 // Purpose:     wxMacPrinter framework
   4 // Author:      Julian Smart, Stefan Csomor
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart, Stefan Csomor
   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 #ifndef WX_PRECOMP
  22     #include "wx/utils.h"
  23     #include "wx/dc.h"
  24     #include "wx/app.h"
  25     #include "wx/msgdlg.h"
  26     #include "wx/dcprint.h"
  27     #include "wx/math.h"
  28 #endif
  29
  30 #include "wx/osx/private.h"
  31
  32 #include "wx/osx/printmac.h"
  33 #include "wx/osx/private/print.h"
  34
  35 #include "wx/printdlg.h"
  36 #include "wx/paper.h"
  37 #include "wx/osx/printdlg.h"
  38
  39 #include <stdlib.h>
  40
  41 //
  42 // move to print_osx.cpp
  43 //
  44
  45 static int ResolutionSorter(const void *e1, const void *e2)
  46 {
  47     const PMResolution *res1 = (const PMResolution *)e1;
  48     const PMResolution *res2 = (const PMResolution *)e2;
  49     const double area1 = res1->hRes * res1->vRes;
  50     const double area2 = res2->hRes * res2->vRes;
  51
  52     if (area1 < area2)
  53         return -1;
  54     else if (area1 > area2)
  55         return 1;
  56     else
  57         return 0;
  58 }
  59
  60 static PMResolution *GetSupportedResolutions(PMPrinter printer, UInt32 *count)
  61 {
  62     PMResolution res, *resolutions = NULL;
  63     OSStatus status = PMPrinterGetPrinterResolutionCount(printer, count);
  64     if (status == kPMNotImplemented)
  65     {
  66 #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
  67         resolutions = (PMResolution *)malloc(sizeof(PMResolution) * 4);
  68         *count = 0;
  69         if (PMPrinterGetPrinterResolution(printer, kPMMinRange, &res) == noErr)
  70             resolutions[(*count)++] = res;
  71         if (PMPrinterGetPrinterResolution(printer, kPMMinSquareResolution, &res) == noErr)
  72             resolutions[(*count)++] = res;
  73         if (PMPrinterGetPrinterResolution(printer, kPMMaxSquareResolution, &res) == noErr)
  74             resolutions[(*count)++] = res;
  75         if (PMPrinterGetPrinterResolution(printer, kPMMaxRange, &res) == noErr)
  76             resolutions[(*count)++] = res;
  77         if (*count == 0)
  78         {
  79             if (PMPrinterGetPrinterResolution(printer, kPMDefaultResolution, &res) == noErr)
  80                 resolutions[(*count)++] = res;
  81         }
  82 #endif
  83     }
  84     else if (status == noErr)
  85     {
  86         resolutions = (PMResolution *)malloc(sizeof(PMResolution) * (*count));
  87         UInt32 realCount = 0;
  88         for (UInt32 i = 0; i < *count; i++)
  89         {
  90             if (PMPrinterGetIndexedPrinterResolution(printer, i + 1, &res) == noErr)
  91                 resolutions[realCount++] = res;
  92         }
  93         qsort(resolutions, realCount, sizeof(PMResolution), ResolutionSorter);
  94
  95         *count = realCount;
  96     }
  97     if ((*count == 0) && (resolutions))
  98     {
  99         free(resolutions);
 100         resolutions = NULL;
 101     }
 102     return resolutions;
 103 }
 104
 105
 106
 107 IMPLEMENT_DYNAMIC_CLASS(wxOSXPrintData, wxPrintNativeDataBase)
 108
 109 bool wxOSXPrintData::IsOk() const
 110 {
 111     return (m_macPageFormat != kPMNoPageFormat) && (m_macPrintSettings != kPMNoPrintSettings) && (m_macPrintSession != kPMNoReference);
 112 }
 113
 114 wxOSXPrintData::wxOSXPrintData()
 115 {
 116     m_macPageFormat = kPMNoPageFormat;
 117     m_macPrintSettings = kPMNoPrintSettings;
 118     m_macPrintSession = kPMNoReference ;
 119     m_macPaper = kPMNoData;
 120 }
 121
 122 wxOSXPrintData::~wxOSXPrintData()
 123 {
 124 }
 125
 126 void wxOSXPrintData::UpdateFromPMState()
 127 {
 128 }
 129
 130 void wxOSXPrintData::UpdateToPMState()
 131 {
 132 }
 133
 134 void wxOSXPrintData::TransferPrinterNameFrom( const wxPrintData &data )
 135 {
 136     CFArrayRef printerList;
 137     CFIndex index, count;
 138     CFStringRef name;
 139
 140     if (PMServerCreatePrinterList(kPMServerLocal, &printerList) == noErr)
 141     {
 142         PMPrinter printer = NULL;
 143         count = CFArrayGetCount(printerList);
 144         for (index = 0; index < count; index++)
 145         {
 146             printer = (PMPrinter)CFArrayGetValueAtIndex(printerList, index);
 147             if ((data.GetPrinterName().empty()) && (PMPrinterIsDefault(printer)))
 148                 break;
 149             else
 150             {
 151                 name = PMPrinterGetName(printer);
 152                 CFRetain(name);
 153                 if (data.GetPrinterName() == wxCFStringRef(name).AsString())
 154                     break;
 155             }
 156         }
 157         if (index < count)
 158             PMSessionSetCurrentPMPrinter(m_macPrintSession, printer);
 159         CFRelease(printerList);
 160     }
 161 }
 162
 163 void wxOSXPrintData::TransferPaperInfoFrom( const wxPrintData &data )
 164 {
 165     PMPrinter printer;
 166     PMSessionGetCurrentPrinter(m_macPrintSession, &printer);
 167
 168     wxSize papersize = wxDefaultSize;
 169     const wxPaperSize paperId = data.GetPaperId();
 170     if ( paperId != wxPAPER_NONE && wxThePrintPaperDatabase )
 171     {
 172         papersize = wxThePrintPaperDatabase->GetSize(paperId);
 173         if ( papersize != wxDefaultSize )
 174         {
 175             papersize.x /= 10;
 176             papersize.y /= 10;
 177         }
 178     }
 179     else
 180     {
 181         papersize = data.GetPaperSize();
 182     }
 183
 184     if ( papersize != wxDefaultSize )
 185     {
 186         papersize.x = (wxInt32) (papersize.x * mm2pt);
 187         papersize.y = (wxInt32) (papersize.y * mm2pt);
 188
 189         double height, width;
 190         PMPaperGetHeight(m_macPaper, &height);
 191         PMPaperGetWidth(m_macPaper, &width);
 192
 193         if ( fabs( width - papersize.x ) >= 5 ||
 194             fabs( height - papersize.y ) >= 5 )
 195         {
 196             // we have to change the current paper
 197             CFArrayRef paperlist = 0 ;
 198             if ( PMPrinterGetPaperList( printer, &paperlist ) == noErr )
 199             {
 200                 PMPaper bestPaper = kPMNoData ;
 201                 CFIndex top = CFArrayGetCount(paperlist);
 202                 for ( CFIndex i = 0 ; i < top ; ++ i )
 203                 {
 204                     PMPaper paper = (PMPaper) CFArrayGetValueAtIndex( paperlist, i );
 205                     PMPaperGetHeight(paper, &height);
 206                     PMPaperGetWidth(paper, &width);
 207                     if ( fabs( width - papersize.x ) < 5 &&
 208                         fabs( height - papersize.y ) < 5 )
 209                     {
 210                         // TODO test for duplicate hits and use additional
 211                         // criteria for best match
 212                         bestPaper = paper;
 213                     }
 214                 }
 215                 PMPaper paper = kPMNoData;
 216                 if ( bestPaper == kPMNoData )
 217                 {
 218                     const PMPaperMargins margins = { 0.0, 0.0, 0.0, 0.0 };
 219                     wxString id, name(wxT("Custom paper"));
 220                     id.Printf(wxT("wxPaperCustom%dx%d"), papersize.x, papersize.y);
 221
 222 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 223                     if ( PMPaperCreateCustom != NULL)
 224                     {
 225                         PMPaperCreateCustom(printer, wxCFStringRef( id, wxFont::GetDefaultEncoding() ), wxCFStringRef( name, wxFont::GetDefaultEncoding() ),
 226                                             papersize.x, papersize.y, &margins, &paper);
 227                     }
 228 #endif
 229 #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
 230                     if ( paper == kPMNoData )
 231                     {
 232                         PMPaperCreate(printer, wxCFStringRef( id, wxFont::GetDefaultEncoding() ), wxCFStringRef( name, wxFont::GetDefaultEncoding() ),
 233                                       papersize.x, papersize.y, &margins, &paper);
 234                     }
 235 #endif
 236                 }
 237                 if ( bestPaper != kPMNoData )
 238                 {
 239                     PMPageFormat pageFormat;
 240                     PMCreatePageFormatWithPMPaper(&pageFormat, bestPaper);
 241                     PMCopyPageFormat( pageFormat, m_macPageFormat );
 242                     PMRelease(pageFormat);
 243                     PMGetPageFormatPaper(m_macPageFormat, &m_macPaper);
 244                 }
 245                 PMRelease(paper);
 246             }
 247         }
 248     }
 249
 250     PMSetCopies( m_macPrintSettings , data.GetNoCopies() , false ) ;
 251     PMSetCollate(m_macPrintSettings, data.GetCollate());
 252     if ( data.IsOrientationReversed() )
 253         PMSetOrientation( m_macPageFormat , ( data.GetOrientation() == wxLANDSCAPE ) ?
 254                          kPMReverseLandscape : kPMReversePortrait , false ) ;
 255     else
 256         PMSetOrientation( m_macPageFormat , ( data.GetOrientation() == wxLANDSCAPE ) ?
 257                          kPMLandscape : kPMPortrait , false ) ;
 258
 259     PMDuplexMode mode = 0 ;
 260     switch( data.GetDuplex() )
 261     {
 262         case wxDUPLEX_HORIZONTAL :
 263             mode = kPMDuplexNoTumble ;
 264             break ;
 265         case wxDUPLEX_VERTICAL :
 266             mode = kPMDuplexTumble ;
 267             break ;
 268         case wxDUPLEX_SIMPLEX :
 269         default :
 270             mode = kPMDuplexNone ;
 271             break ;
 272     }
 273     PMSetDuplex(  m_macPrintSettings, mode ) ;
 274
 275
 276     if ( data.IsOrientationReversed() )
 277         PMSetOrientation(  m_macPageFormat , ( data.GetOrientation() == wxLANDSCAPE ) ?
 278                          kPMReverseLandscape : kPMReversePortrait , false ) ;
 279     else
 280         PMSetOrientation(  m_macPageFormat , ( data.GetOrientation() == wxLANDSCAPE ) ?
 281                          kPMLandscape : kPMPortrait , false ) ;
 282 }
 283
 284 void wxOSXPrintData::TransferResolutionFrom( const wxPrintData &data )
 285 {
 286     PMPrinter printer;
 287     PMSessionGetCurrentPrinter(m_macPrintSession, &printer);
 288
 289     UInt32 resCount;
 290     PMResolution *resolutions = GetSupportedResolutions(printer, &resCount);
 291     if (resolutions)
 292     {
 293         wxPrintQuality quality = data.GetQuality();
 294         if (quality >= 0)
 295             quality = wxPRINT_QUALITY_HIGH;
 296
 297         PMResolution res = resolutions[((quality - wxPRINT_QUALITY_DRAFT) * (resCount - 1)) / 3];
 298 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 299         if ( PMPrinterSetOutputResolution != NULL )
 300             PMPrinterSetOutputResolution(printer, m_macPrintSettings, &res);
 301         else
 302 #endif
 303         {
 304 #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
 305             PMSetResolution( m_macPageFormat, &res);
 306 #endif
 307         }
 308
 309         free(resolutions);
 310     }
 311 }
 312
 313 bool wxOSXPrintData::TransferFrom( const wxPrintData &data )
 314 {
 315     TransferPrinterNameFrom(data);
 316     TransferPaperInfoFrom(data);
 317     TransferResolutionFrom(data);
 318
 319     // after setting the new resolution the format has to be updated, otherwise the page rect remains
 320     // at the 'old' scaling
 321
 322     PMSessionValidatePageFormat(m_macPrintSession,
 323                                 m_macPageFormat, kPMDontWantBoolean);
 324     PMSessionValidatePrintSettings(m_macPrintSession,
 325                                    m_macPrintSettings, kPMDontWantBoolean);
 326
 327 #if wxOSX_USE_COCOA
 328     UpdateFromPMState();
 329 #endif
 330
 331     return true ;
 332 }
 333
 334 void wxOSXPrintData::TransferPrinterNameTo( wxPrintData &data )
 335 {
 336     CFStringRef name;
 337     PMPrinter printer ;
 338     PMSessionGetCurrentPrinter( m_macPrintSession, &printer );
 339     if (PMPrinterIsDefault(printer))
 340         data.SetPrinterName(wxEmptyString);
 341     else
 342     {
 343         name = PMPrinterGetName(printer);
 344         CFRetain(name);
 345         data.SetPrinterName(wxCFStringRef(name).AsString());
 346     }
 347 }
 348
 349 void wxOSXPrintData::TransferPaperInfoTo( wxPrintData &data )
 350 {
 351     PMGetPageFormatPaper(m_macPageFormat, &m_macPaper);
 352
 353     PMPrinter printer ;
 354     PMSessionGetCurrentPrinter( m_macPrintSession, &printer );
 355     OSStatus err = noErr ;
 356     UInt32 copies ;
 357     err = PMGetCopies( m_macPrintSettings , &copies ) ;
 358     if ( err == noErr )
 359         data.SetNoCopies( copies ) ;
 360
 361     PMOrientation orientation ;
 362     err = PMGetOrientation(  m_macPageFormat , &orientation ) ;
 363     if ( err == noErr )
 364     {
 365         if ( orientation == kPMPortrait || orientation == kPMReversePortrait )
 366         {
 367             data.SetOrientation( wxPORTRAIT  );
 368             data.SetOrientationReversed( orientation == kPMReversePortrait );
 369         }
 370         else
 371         {
 372             data.SetOrientation( wxLANDSCAPE );
 373             data.SetOrientationReversed( orientation == kPMReverseLandscape );
 374         }
 375     }
 376
 377     Boolean collate;
 378     if (PMGetCollate(m_macPrintSettings, &collate) == noErr)
 379         data.SetCollate(collate);
 380
 381
 382     PMDuplexMode mode = 0 ;
 383     PMGetDuplex(  m_macPrintSettings, &mode ) ;
 384     switch( mode )
 385     {
 386         case kPMDuplexNoTumble :
 387             data.SetDuplex(wxDUPLEX_HORIZONTAL);
 388             break ;
 389         case kPMDuplexTumble :
 390             data.SetDuplex(wxDUPLEX_VERTICAL);
 391             break ;
 392         case kPMDuplexNone :
 393         default :
 394             data.SetDuplex(wxDUPLEX_SIMPLEX);
 395             break ;
 396     }
 397
 398     double height, width;
 399     PMPaperGetHeight(m_macPaper, &height);
 400     PMPaperGetWidth(m_macPaper, &width);
 401
 402     wxSize sz((int)(width * pt2mm + 0.5 ) ,
 403               (int)(height * pt2mm + 0.5 ));
 404     data.SetPaperSize(sz);
 405     wxPaperSize id = wxThePrintPaperDatabase->GetSize(wxSize(sz.x* 10, sz.y * 10));
 406     if (id != wxPAPER_NONE)
 407     {
 408         data.SetPaperId(id);
 409     }
 410 }
 411
 412 void wxOSXPrintData::TransferResolutionTo( wxPrintData &data )
 413 {
 414     PMPrinter printer ;
 415     PMSessionGetCurrentPrinter( m_macPrintSession, &printer );
 416
 417     /* assume high quality, will change below if we are able to */
 418     data.SetQuality(wxPRINT_QUALITY_HIGH);
 419
 420     PMResolution *resolutions;
 421     UInt32 resCount;
 422     resolutions = GetSupportedResolutions(printer, &resCount);
 423     if (resolutions)
 424     {
 425         bool valid = false;
 426         PMResolution res;
 427 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 428         if ( PMPrinterGetOutputResolution != NULL )
 429         {
 430             if ( PMPrinterGetOutputResolution(printer, m_macPrintSettings, &res) == noErr )
 431                 valid = true;
 432         }
 433 #endif
 434 #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
 435         if (PMPrinterGetPrinterResolution(printer, kPMCurrentValue, &res) == noErr)
 436             valid = true;
 437 #endif
 438         if ( valid )
 439         {
 440             UInt32 i;
 441             for (i = 0; i < resCount; i++)
 442             {
 443                 if ((resolutions[i].hRes == res.hRes) && (resolutions[i].vRes = res.vRes))
 444                     break;
 445             }
 446             if (i < resCount)
 447                 data.SetQuality((((i + 1) * 3) / resCount) + wxPRINT_QUALITY_DRAFT);
 448         }
 449         free(resolutions);
 450     }
 451 }
 452
 453 bool wxOSXPrintData::TransferTo( wxPrintData &data )
 454 {
 455 #if wxOSX_USE_COCOA
 456     UpdateToPMState();
 457 #endif
 458
 459     TransferPrinterNameTo(data);
 460     TransferPaperInfoTo(data);
 461     TransferResolutionTo(data);
 462     return true ;
 463 }
 464
 465 void wxOSXPrintData::TransferFrom( wxPageSetupDialogData *WXUNUSED(data) )
 466 {
 467     // should we setup the page rect here ?
 468     // since MacOS sometimes has two same paper rects with different
 469     // page rects we could make it roundtrip safe perhaps
 470 }
 471
 472 void wxOSXPrintData::TransferTo( wxPageSetupDialogData* data )
 473 {
 474 #if wxOSX_USE_COCOA
 475     UpdateToPMState();
 476 #endif
 477     PMRect rPaper;
 478     OSStatus err = PMGetUnadjustedPaperRect(m_macPageFormat, &rPaper);
 479     if ( err == noErr )
 480     {
 481         wxSize sz((int)(( rPaper.right - rPaper.left ) * pt2mm + 0.5 ) ,
 482              (int)(( rPaper.bottom - rPaper.top ) * pt2mm + 0.5 ));
 483         data->SetPaperSize(sz);
 484
 485         PMRect rPage ;
 486         err = PMGetUnadjustedPageRect(m_macPageFormat , &rPage ) ;
 487         if ( err == noErr )
 488         {
 489             data->SetMinMarginTopLeft( wxPoint (
 490                 (int)(((double) rPage.left - rPaper.left ) * pt2mm) ,
 491                 (int)(((double) rPage.top - rPaper.top ) * pt2mm) ) ) ;
 492
 493             data->SetMinMarginBottomRight( wxPoint (
 494                 (wxCoord)(((double) rPaper.right - rPage.right ) * pt2mm),
 495                 (wxCoord)(((double) rPaper.bottom - rPage.bottom ) * pt2mm)) ) ;
 496
 497             if ( data->GetMarginTopLeft().x < data->GetMinMarginTopLeft().x )
 498                 data->SetMarginTopLeft( wxPoint( data->GetMinMarginTopLeft().x ,
 499                     data->GetMarginTopLeft().y ) ) ;
 500
 501             if ( data->GetMarginBottomRight().x < data->GetMinMarginBottomRight().x )
 502                 data->SetMarginBottomRight( wxPoint( data->GetMinMarginBottomRight().x ,
 503                     data->GetMarginBottomRight().y ) );
 504
 505             if ( data->GetMarginTopLeft().y < data->GetMinMarginTopLeft().y )
 506                 data->SetMarginTopLeft( wxPoint( data->GetMarginTopLeft().x , data->GetMinMarginTopLeft().y ) );
 507
 508             if ( data->GetMarginBottomRight().y < data->GetMinMarginBottomRight().y )
 509                 data->SetMarginBottomRight( wxPoint( data->GetMarginBottomRight().x ,
 510                     data->GetMinMarginBottomRight().y) );
 511         }
 512     }
 513 }
 514
 515 void wxOSXPrintData::TransferTo( wxPrintDialogData* data )
 516 {
 517 #if wxOSX_USE_COCOA
 518     UpdateToPMState();
 519 #endif
 520     UInt32 minPage , maxPage ;
 521     PMGetPageRange( m_macPrintSettings , &minPage , &maxPage ) ;
 522     data->SetMinPage( minPage ) ;
 523     data->SetMaxPage( maxPage ) ;
 524     UInt32 copies ;
 525     PMGetCopies( m_macPrintSettings , &copies ) ;
 526     data->SetNoCopies( copies ) ;
 527     UInt32 from , to ;
 528     PMGetFirstPage( m_macPrintSettings , &from ) ;
 529     PMGetLastPage( m_macPrintSettings , &to ) ;
 530     if ( to >= 0x7FFFFFFF ) //  due to an OS Bug we don't get back kPMPrintAllPages
 531     {
 532         data->SetAllPages( true ) ;
 533         // This means all pages, more or less
 534         data->SetFromPage(1);
 535         data->SetToPage(9999);
 536     }
 537     else
 538     {
 539         data->SetFromPage( from ) ;
 540         data->SetToPage( to ) ;
 541         data->SetAllPages( false );
 542     }
 543 }
 544
 545 void wxOSXPrintData::TransferFrom( wxPrintDialogData* data )
 546 {
 547     // Respect the value of m_printAllPages
 548     if ( data->GetAllPages() )
 549         PMSetPageRange( m_macPrintSettings , data->GetMinPage() , (UInt32) kPMPrintAllPages ) ;
 550     else
 551         PMSetPageRange( m_macPrintSettings , data->GetMinPage() , data->GetMaxPage() ) ;
 552     PMSetCopies( m_macPrintSettings , data->GetNoCopies() , false ) ;
 553     PMSetFirstPage( m_macPrintSettings , data->GetFromPage() , false ) ;
 554
 555     if (data->GetAllPages() || data->GetFromPage() == 0)
 556         PMSetLastPage( m_macPrintSettings , (UInt32) kPMPrintAllPages, true ) ;
 557     else
 558         PMSetLastPage( m_macPrintSettings , (UInt32) data->GetToPage() , false ) ;
 559 #if wxOSX_USE_COCOA
 560     UpdateFromPMState();
 561 #endif
 562 }
 563
 564 wxPrintNativeDataBase* wxOSXCreatePrintData()
 565 {
 566 #if wxOSX_USE_COCOA
 567     return new wxOSXCocoaPrintData();
 568 #elif wxOSX_USE_CARBON
 569     return new wxOSXCarbonPrintData();
 570 #else
 571     return NULL;
 572 #endif
 573 }
 574
 575 /*
 576 * Printer
 577 */
 578
 579 IMPLEMENT_DYNAMIC_CLASS(wxMacPrinter, wxPrinterBase)
 580
 581 wxMacPrinter::wxMacPrinter(wxPrintDialogData *data):
 582 wxPrinterBase(data)
 583 {
 584 }
 585
 586 wxMacPrinter::~wxMacPrinter(void)
 587 {
 588 }
 589
 590 bool wxMacPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt)
 591 {
 592     sm_abortIt = false;
 593     sm_abortWindow = NULL;
 594
 595     if (!printout)
 596     {
 597         sm_lastError = wxPRINTER_ERROR;
 598         return false;
 599     }
 600
 601     if (m_printDialogData.GetMinPage() < 1)
 602         m_printDialogData.SetMinPage(1);
 603     if (m_printDialogData.GetMaxPage() < 1)
 604         m_printDialogData.SetMaxPage(9999);
 605
 606     // Create a suitable device context
 607     wxPrinterDC *dc = NULL;
 608     if (prompt)
 609     {
 610         wxMacPrintDialog dialog(parent, & m_printDialogData);
 611         if (dialog.ShowModal() == wxID_OK)
 612         {
 613             dc = wxDynamicCast(dialog.GetPrintDC(), wxPrinterDC);
 614             wxASSERT(dc);
 615             m_printDialogData = dialog.GetPrintDialogData();
 616         }
 617     }
 618     else
 619     {
 620         dc = new wxPrinterDC( m_printDialogData.GetPrintData() ) ;
 621     }
 622
 623     // May have pressed cancel.
 624     if (!dc || !dc->IsOk())
 625     {
 626         delete dc;
 627         return false;
 628     }
 629
 630     // on the mac we have always pixels as addressing mode with 72 dpi
 631     printout->SetPPIScreen(72, 72);
 632
 633     PMResolution res;
 634     PMPrinter printer;
 635     wxOSXPrintData* nativeData = (wxOSXPrintData*)
 636           (m_printDialogData.GetPrintData().GetNativeData());
 637
 638     if (PMSessionGetCurrentPrinter(nativeData->GetPrintSession(), &printer) == noErr)
 639     {
 640 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 641         if ( PMPrinterGetOutputResolution != NULL )
 642         {
 643             if (PMPrinterGetOutputResolution( printer, nativeData->GetPrintSettings(), &res) == -9589 /* kPMKeyNotFound */ )
 644             {
 645                 res.hRes = res.vRes = 300;
 646             }
 647         }
 648         else
 649 #endif
 650         {
 651 #if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
 652             PMPrinterGetPrinterResolution(printer, kPMCurrentValue, &res);
 653 #endif
 654         }
 655     }
 656     else
 657     {
 658         // fallback
 659         res.hRes = res.vRes = 300;
 660     }
 661     printout->SetPPIPrinter(int(res.hRes), int(res.vRes));
 662
 663     // Set printout parameters
 664     printout->SetDC(dc);
 665
 666     int w, h;
 667     dc->GetSize(&w, &h);
 668     printout->SetPageSizePixels((int)w, (int)h);
 669     printout->SetPaperRectPixels(dc->GetPaperRect());
 670     wxCoord mw, mh;
 671     dc->GetSizeMM(&mw, &mh);
 672     printout->SetPageSizeMM((int)mw, (int)mh);
 673
 674     // Create an abort window
 675     wxBeginBusyCursor();
 676
 677     printout->OnPreparePrinting();
 678
 679     // Get some parameters from the printout, if defined
 680     int fromPage, toPage;
 681     int minPage, maxPage;
 682     printout->GetPageInfo(&minPage, &maxPage, &fromPage, &toPage);
 683
 684     if (maxPage == 0)
 685     {
 686         sm_lastError = wxPRINTER_ERROR;
 687         return false;
 688     }
 689
 690     // Only set min and max, because from and to will be
 691     // set by the user
 692     m_printDialogData.SetMinPage(minPage);
 693     m_printDialogData.SetMaxPage(maxPage);
 694
 695     printout->OnBeginPrinting();
 696
 697     bool keepGoing = true;
 698
 699     if (!printout->OnBeginDocument(m_printDialogData.GetFromPage(), m_printDialogData.GetToPage()))
 700     {
 701             wxEndBusyCursor();
 702             wxMessageBox(wxT("Could not start printing."), wxT("Print Error"), wxOK, parent);
 703     }
 704
 705     int pn;
 706     for (pn = m_printDialogData.GetFromPage();
 707         keepGoing && (pn <= m_printDialogData.GetToPage()) && printout->HasPage(pn);
 708         pn++)
 709     {
 710         if (sm_abortIt)
 711         {
 712                 break;
 713         }
 714         else
 715         {
 716                 dc->StartPage();
 717                 keepGoing = printout->OnPrintPage(pn);
 718                 dc->EndPage();
 719         }
 720     }
 721     printout->OnEndDocument();
 722
 723     printout->OnEndPrinting();
 724
 725     if (sm_abortWindow)
 726     {
 727         sm_abortWindow->Show(false);
 728         wxDELETE(sm_abortWindow);
 729     }
 730
 731     wxEndBusyCursor();
 732
 733     delete dc;
 734
 735     return true;
 736 }
 737
 738 wxDC* wxMacPrinter::PrintDialog(wxWindow *parent)
 739 {
 740     wxDC* dc = NULL;
 741
 742     wxPrintDialog dialog(parent, & m_printDialogData);
 743     int ret = dialog.ShowModal();
 744
 745     if (ret == wxID_OK)
 746     {
 747         dc = dialog.GetPrintDC();
 748         m_printDialogData = dialog.GetPrintDialogData();
 749     }
 750
 751     return dc;
 752 }
 753
 754 bool wxMacPrinter::Setup(wxWindow *WXUNUSED(parent))
 755 {
 756 #if 0
 757     wxPrintDialog dialog(parent, & m_printDialogData);
 758     dialog.GetPrintDialogData().SetSetupDialog(true);
 759
 760     int ret = dialog.ShowModal();
 761
 762     if (ret == wxID_OK)
 763         m_printDialogData = dialog.GetPrintDialogData();
 764
 765     return (ret == wxID_OK);
 766 #endif
 767
 768     return false;
 769 }
 770
 771 /*
 772 * Print preview
 773 */
 774
 775 IMPLEMENT_CLASS(wxMacPrintPreview, wxPrintPreviewBase)
 776
 777 wxMacPrintPreview::wxMacPrintPreview(wxPrintout *printout,
 778                                      wxPrintout *printoutForPrinting,
 779                                      wxPrintDialogData *data)
 780                                      : wxPrintPreviewBase(printout, printoutForPrinting, data)
 781 {
 782     DetermineScaling();
 783 }
 784
 785 wxMacPrintPreview::wxMacPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting, wxPrintData *data):
 786 wxPrintPreviewBase(printout, printoutForPrinting, data)
 787 {
 788     DetermineScaling();
 789 }
 790
 791 wxMacPrintPreview::~wxMacPrintPreview(void)
 792 {
 793 }
 794
 795 bool wxMacPrintPreview::Print(bool interactive)
 796 {
 797     if (!m_printPrintout)
 798         return false;
 799
 800     wxMacPrinter printer(&m_printDialogData);
 801     return printer.Print(m_previewFrame, m_printPrintout, interactive);
 802 }
 803
 804 void wxMacPrintPreview::DetermineScaling(void)
 805 {
 806     int screenWidth , screenHeight ;
 807     wxDisplaySize( &screenWidth , &screenHeight ) ;
 808
 809     wxSize ppiScreen( 72 , 72 ) ;
 810     wxSize ppiPrinter( 72 , 72 ) ;
 811
 812     // Note that with Leopard, screen dpi=72 is no longer a given
 813     m_previewPrintout->SetPPIScreen( ppiScreen.x , ppiScreen.y ) ;
 814
 815     wxCoord w , h ;
 816     wxCoord ww, hh;
 817     wxRect paperRect;
 818
 819     // Get a device context for the currently selected printer
 820     wxPrinterDC printerDC(m_printDialogData.GetPrintData());
 821     if (printerDC.IsOk())
 822     {
 823         printerDC.GetSizeMM(&ww, &hh);
 824         printerDC.GetSize( &w , &h ) ;
 825         ppiPrinter = printerDC.GetPPI() ;
 826         paperRect = printerDC.GetPaperRect();
 827         m_isOk = true ;
 828     }
 829     else
 830     {
 831         // use some defaults
 832         w = 8 * 72 ;
 833         h = 11 * 72 ;
 834         ww = (wxCoord) (w * 25.4 / ppiPrinter.x) ;
 835         hh = (wxCoord) (h * 25.4 / ppiPrinter.y) ;
 836         paperRect = wxRect(0, 0, w, h);
 837         m_isOk = false ;
 838     }
 839     m_pageWidth = w;
 840     m_pageHeight = h;
 841
 842     m_previewPrintout->SetPageSizePixels(w , h) ;
 843     m_previewPrintout->SetPageSizeMM(ww, hh);
 844     m_previewPrintout->SetPaperRectPixels(paperRect);
 845     m_previewPrintout->SetPPIPrinter( ppiPrinter.x , ppiPrinter.y ) ;
 846
 847     m_previewScaleX = float(ppiScreen.x) / ppiPrinter.x;
 848     m_previewScaleY = float(ppiScreen.y) / ppiPrinter.y;
 849 }
 850
 851 //
 852 // end of print_osx.cpp
 853 //
 854
 855 #if wxOSX_USE_CARBON
 856
 857 IMPLEMENT_DYNAMIC_CLASS(wxOSXCarbonPrintData, wxOSXPrintData)
 858
 859 wxOSXCarbonPrintData::wxOSXCarbonPrintData()
 860 {
 861     if ( PMCreateSession( &m_macPrintSession ) == noErr )
 862     {
 863         if ( PMCreatePageFormat(&m_macPageFormat) == noErr )
 864         {
 865             PMSessionDefaultPageFormat(m_macPrintSession,
 866                     m_macPageFormat);
 867             PMGetPageFormatPaper(m_macPageFormat, &m_macPaper);
 868         }
 869
 870         if ( PMCreatePrintSettings(&m_macPrintSettings) == noErr )
 871         {
 872             PMSessionDefaultPrintSettings(m_macPrintSession,
 873                 m_macPrintSettings);
 874         }
 875     }
 876 }
 877
 878 wxOSXCarbonPrintData::~wxOSXCarbonPrintData()
 879 {
 880     (void)PMRelease(m_macPageFormat);
 881     (void)PMRelease(m_macPrintSettings);
 882     (void)PMRelease(m_macPrintSession);
 883 }
 884 #endif
 885
 886 #endif