vcl/osx/salprn.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "officecfg/Office/Common.hxx"
  21
  22 #include <vcl/print.hxx>
  23 #include <sal/macros.h>
  24
  25 #include "osx/salinst.h"
  26 #include "osx/salprn.h"
  27 #include "osx/printview.h"
  28 #include "quartz/salgdi.h"
  29 #include "osx/saldata.hxx"
  30 #include "quartz/utils.h"
  31
  32 #include "jobset.h"
  33 #include "salptype.hxx"
  34
  35 #include "com/sun/star/beans/PropertyValue.hpp"
  36 #include "com/sun/star/awt/Size.hpp"
  37 #include "com/sun/star/uno/Sequence.hxx"
  38
  39 #include <algorithm>
  40 #include <cstdlib>
  41
  42 using namespace vcl;
  43 using namespace com::sun::star;
  44 using namespace com::sun::star::beans;
  45
  46 AquaSalInfoPrinter::AquaSalInfoPrinter( const SalPrinterQueueInfo& i_rQueue ) :
  47     mpGraphics( nullptr ),
  48     mbGraphics( false ),
  49     mbJob( false ),
  50     mpPrinter( nil ),
  51     mpPrintInfo( nil ),
  52     mePageOrientation( Orientation::Portrait ),
  53     mnStartPageOffsetX( 0 ),
  54     mnStartPageOffsetY( 0 ),
  55     mnCurPageRangeStart( 0 ),
  56     mnCurPageRangeCount( 0 )
  57 {
  58     NSString* pStr = CreateNSString( i_rQueue.maPrinterName );
  59     mpPrinter = [NSPrinter printerWithName: pStr];
  60     [pStr release];
  61
  62     NSPrintInfo* pShared = [NSPrintInfo sharedPrintInfo];
  63     if( pShared )
  64     {
  65         mpPrintInfo = [pShared copy];
  66         [mpPrintInfo setPrinter: mpPrinter];
  67 #if MACOSX_SDK_VERSION >= 1090
  68         mePageOrientation = ([mpPrintInfo orientation] == NSPaperOrientationPortrait) ? Orientation::Landscape : Orientation::Portrait;
  69         [mpPrintInfo setOrientation: NSPaperOrientationPortrait];
  70 #else
  71         mePageOrientation = ([mpPrintInfo orientation] == NSLandscapeOrientation) ? Orientation::Landscape : Orientation::Portrait;
  72         [mpPrintInfo setOrientation: NSPortraitOrientation];
  73 #endif
  74     }
  75
  76     mpGraphics = new AquaSalGraphics();
  77
  78     const int nWidth = 100, nHeight = 100;
  79     mpContextMemory.reset(static_cast<sal_uInt8*>(rtl_allocateMemory(nWidth * 4 * nHeight)),
  80                           &rtl_freeMemory);
  81
  82     if (mpContextMemory)
  83     {
  84         mrContext = CGBitmapContextCreate(mpContextMemory.get(),
  85                 nWidth, nHeight, 8, nWidth * 4,
  86                 GetSalData()->mxRGBSpace, kCGImageAlphaNoneSkipFirst);
  87         if( mrContext )
  88             SetupPrinterGraphics( mrContext );
  89     }
  90 }
  91
  92 AquaSalInfoPrinter::~AquaSalInfoPrinter()
  93 {
  94     delete mpGraphics;
  95     if( mpPrintInfo )
  96         [mpPrintInfo release];
  97     if( mrContext )
  98         CFRelease( mrContext );
  99 }
 100
 101 void AquaSalInfoPrinter::SetupPrinterGraphics( CGContextRef i_rContext ) const
 102 {
 103     if( mpGraphics )
 104     {
 105         if( mpPrintInfo )
 106         {
 107             // FIXME: get printer resolution
 108             long nDPIX = 720, nDPIY = 720;
 109             NSSize aPaperSize = [mpPrintInfo paperSize];
 110
 111             NSRect aImageRect = [mpPrintInfo imageablePageBounds];
 112             if( mePageOrientation == Orientation::Portrait )
 113             {
 114                 // move mirrored CTM back into paper
 115                 double dX = 0, dY = aPaperSize.height;
 116                 // move CTM to reflect imageable area
 117                 dX += aImageRect.origin.x;
 118                 dY -= aPaperSize.height - aImageRect.size.height - aImageRect.origin.y;
 119                 CGContextTranslateCTM( i_rContext, dX + mnStartPageOffsetX, dY - mnStartPageOffsetY );
 120                 // scale to be top/down and reflect our "virtual" DPI
 121                 CGContextScaleCTM( i_rContext, 72.0/double(nDPIX), -(72.0/double(nDPIY)) );
 122             }
 123             else
 124             {
 125                 // move CTM to reflect imageable area
 126                 double dX = aImageRect.origin.x, dY = aPaperSize.height - aImageRect.size.height - aImageRect.origin.y;
 127                 CGContextTranslateCTM( i_rContext, -dX, -dY );
 128                 // turn by 90 degree
 129                 CGContextRotateCTM( i_rContext, M_PI/2 );
 130                 // move turned CTM back into paper
 131                 dX = aPaperSize.height;
 132                 dY = -aPaperSize.width;
 133                 CGContextTranslateCTM( i_rContext, dX + mnStartPageOffsetY, dY - mnStartPageOffsetX );
 134                 // scale to be top/down and reflect our "virtual" DPI
 135                 CGContextScaleCTM( i_rContext, -(72.0/double(nDPIY)), (72.0/double(nDPIX)) );
 136             }
 137             mpGraphics->SetPrinterGraphics( i_rContext, nDPIX, nDPIY );
 138         }
 139         else
 140             OSL_FAIL( "no print info in SetupPrinterGraphics" );
 141     }
 142 }
 143
 144 SalGraphics* AquaSalInfoPrinter::AcquireGraphics()
 145 {
 146     SalGraphics* pGraphics = mbGraphics ? nullptr : mpGraphics;
 147     mbGraphics = true;
 148     return pGraphics;
 149 }
 150
 151 void AquaSalInfoPrinter::ReleaseGraphics( SalGraphics* )
 152 {
 153     mbGraphics = false;
 154 }
 155
 156 bool AquaSalInfoPrinter::Setup( SalFrame*, ImplJobSetup* )
 157 {
 158     return false;
 159 }
 160
 161 bool AquaSalInfoPrinter::SetPrinterData( ImplJobSetup* io_pSetupData )
 162 {
 163     // FIXME: implement driver data
 164     if( io_pSetupData && io_pSetupData->GetDriverData() )
 165         return SetData( JobSetFlags::ALL, io_pSetupData );
 166
 167     bool bSuccess = true;
 168
 169     // set system type
 170     io_pSetupData->SetSystem( JOBSETUP_SYSTEM_MAC );
 171
 172     // get paper format
 173     if( mpPrintInfo )
 174     {
 175         NSSize aPaperSize = [mpPrintInfo paperSize];
 176         double width = aPaperSize.width, height = aPaperSize.height;
 177         // set paper
 178         PaperInfo aInfo( PtTo10Mu( width ), PtTo10Mu( height ) );
 179         aInfo.doSloppyFit();
 180         io_pSetupData->SetPaperFormat( aInfo.getPaper() );
 181         if( io_pSetupData->GetPaperFormat() == PAPER_USER )
 182         {
 183             io_pSetupData->SetPaperWidth( PtTo10Mu( width ) );
 184             io_pSetupData->SetPaperHeight( PtTo10Mu( height ) );
 185         }
 186         else
 187         {
 188             io_pSetupData->SetPaperWidth( 0 );
 189             io_pSetupData->SetPaperHeight( 0 );
 190         }
 191
 192         // set orientation
 193         io_pSetupData->SetOrientation( mePageOrientation );
 194
 195         io_pSetupData->SetPaperBin( 0 );
 196         io_pSetupData->SetDriverData( static_cast<sal_uInt8*>(rtl_allocateMemory( 4 )) );
 197         io_pSetupData->SetDriverDataLen( 4 );
 198     }
 199     else
 200         bSuccess = false;
 201
 202     return bSuccess;
 203 }
 204
 205 void AquaSalInfoPrinter::setPaperSize( long i_nWidth, long i_nHeight, Orientation i_eSetOrientation )
 206 {
 207
 208     Orientation ePaperOrientation = Orientation::Portrait;
 209     const PaperInfo* pPaper = matchPaper( i_nWidth, i_nHeight, ePaperOrientation );
 210
 211     if( pPaper )
 212     {
 213         NSString* pPaperName = [CreateNSString( OStringToOUString(PaperInfo::toPSName(pPaper->getPaper()), RTL_TEXTENCODING_ASCII_US) ) autorelease];
 214         [mpPrintInfo setPaperName: pPaperName];
 215     }
 216     else if( i_nWidth > 0 && i_nHeight > 0 )
 217     {
 218         NSSize aPaperSize = { static_cast<CGFloat>(TenMuToPt(i_nWidth)), static_cast<CGFloat>(TenMuToPt(i_nHeight)) };
 219         [mpPrintInfo setPaperSize: aPaperSize];
 220     }
 221     // this seems counterintuitive
 222     mePageOrientation = i_eSetOrientation;
 223 }
 224
 225 bool AquaSalInfoPrinter::SetData( JobSetFlags i_nFlags, ImplJobSetup* io_pSetupData )
 226 {
 227     if( ! io_pSetupData || io_pSetupData->GetSystem() != JOBSETUP_SYSTEM_MAC )
 228         return false;
 229
 230     if( mpPrintInfo )
 231     {
 232         if( i_nFlags & JobSetFlags::ORIENTATION )
 233             mePageOrientation = io_pSetupData->GetOrientation();
 234
 235         if( i_nFlags & JobSetFlags::PAPERSIZE )
 236         {
 237             // set paper format
 238             long width = 21000, height = 29700;
 239             if( io_pSetupData->GetPaperFormat() == PAPER_USER )
 240             {
 241                 // #i101108# sanity check
 242                 if( io_pSetupData->GetPaperWidth() && io_pSetupData->GetPaperHeight() )
 243                 {
 244                     width = io_pSetupData->GetPaperWidth();
 245                     height = io_pSetupData->GetPaperHeight();
 246                 }
 247             }
 248             else
 249             {
 250                 PaperInfo aInfo( io_pSetupData->GetPaperFormat() );
 251                 width = aInfo.getWidth();
 252                 height = aInfo.getHeight();
 253             }
 254
 255             setPaperSize( width, height, mePageOrientation );
 256         }
 257     }
 258
 259     return mpPrintInfo != nil;
 260 }
 261
 262 sal_uInt16 AquaSalInfoPrinter::GetPaperBinCount( const ImplJobSetup* )
 263 {
 264     return 0;
 265 }
 266
 267 OUString AquaSalInfoPrinter::GetPaperBinName( const ImplJobSetup*, sal_uInt16 )
 268 {
 269     return OUString();
 270 }
 271
 272 sal_uInt32 AquaSalInfoPrinter::GetCapabilities( const ImplJobSetup*, PrinterCapType i_nType )
 273 {
 274     switch( i_nType )
 275     {
 276         case PrinterCapType::SupportDialog:
 277             return 0;
 278         case PrinterCapType::Copies:
 279             return 0xffff;
 280         case PrinterCapType::CollateCopies:
 281             return 0xffff;
 282         case PrinterCapType::SetOrientation:
 283             return 1;
 284         case PrinterCapType::SetPaperSize:
 285             return 1;
 286         case PrinterCapType::SetPaper:
 287             return 1;
 288         case PrinterCapType::ExternalDialog:
 289             return officecfg::Office::Common::Misc::UseSystemPrintDialog::get()
 290                 ? 1 : 0;
 291         case PrinterCapType::PDF:
 292             return 1;
 293         case PrinterCapType::UsePullModel:
 294             return 1;
 295         default: break;
 296     }
 297     return 0;
 298 }
 299
 300 void AquaSalInfoPrinter::GetPageInfo( const ImplJobSetup*,
 301                                   long& o_rOutWidth, long& o_rOutHeight,
 302                                   long& o_rPageOffX, long& o_rPageOffY,
 303                                   long& o_rPageWidth, long& o_rPageHeight )
 304 {
 305     if( mpPrintInfo )
 306     {
 307         sal_Int32 nDPIX = 72, nDPIY = 72;
 308         mpGraphics->GetResolution( nDPIX, nDPIY );
 309         const double fXScaling = static_cast<double>(nDPIX)/72.0,
 310                      fYScaling = static_cast<double>(nDPIY)/72.0;
 311
 312         NSSize aPaperSize = [mpPrintInfo paperSize];
 313         o_rPageWidth  = static_cast<long>( double(aPaperSize.width) * fXScaling );
 314         o_rPageHeight = static_cast<long>( double(aPaperSize.height) * fYScaling );
 315
 316         NSRect aImageRect = [mpPrintInfo imageablePageBounds];
 317         o_rPageOffX   = static_cast<long>( aImageRect.origin.x * fXScaling );
 318         o_rPageOffY   = static_cast<long>( (aPaperSize.height - aImageRect.size.height - aImageRect.origin.y) * fYScaling );
 319         o_rOutWidth   = static_cast<long>( aImageRect.size.width * fXScaling );
 320         o_rOutHeight  = static_cast<long>( aImageRect.size.height * fYScaling );
 321
 322         if( mePageOrientation == Orientation::Landscape )
 323         {
 324             std::swap( o_rOutWidth, o_rOutHeight );
 325             std::swap( o_rPageWidth, o_rPageHeight );
 326             std::swap( o_rPageOffX, o_rPageOffY );
 327         }
 328     }
 329 }
 330
 331 static Size getPageSize( vcl::PrinterController& i_rController, sal_Int32 i_nPage )
 332 {
 333     Size aPageSize;
 334     uno::Sequence< PropertyValue > aPageParms( i_rController.getPageParameters( i_nPage ) );
 335     for( sal_Int32 nProperty = 0, nPropertyCount = aPageParms.getLength(); nProperty < nPropertyCount; ++nProperty )
 336     {
 337         if ( aPageParms[ nProperty ].Name == "PageSize" )
 338         {
 339             awt::Size aSize;
 340             aPageParms[ nProperty].Value >>= aSize;
 341             aPageSize.Width() = aSize.Width;
 342             aPageSize.Height() = aSize.Height;
 343             break;
 344         }
 345     }
 346     return aPageSize;
 347 }
 348
 349 bool AquaSalInfoPrinter::StartJob( const OUString* i_pFileName,
 350                                    const OUString& i_rJobName,
 351                                    const OUString& /*i_rAppName*/,
 352                                    ImplJobSetup* i_pSetupData,
 353                                    vcl::PrinterController& i_rController
 354                                    )
 355 {
 356     if( mbJob )
 357         return false;
 358
 359     bool bSuccess = false;
 360     bool bWasAborted = false;
 361     AquaSalInstance* pInst = GetSalData()->mpFirstInstance;
 362     PrintAccessoryViewState aAccViewState;
 363     sal_Int32 nAllPages = 0;
 364
 365     // reset IsLastPage
 366     i_rController.setLastPage( false );
 367
 368     // update job data
 369     if( i_pSetupData )
 370         SetData( JobSetFlags::ALL, i_pSetupData );
 371
 372     // do we want a progress panel ?
 373     bool bShowProgressPanel = true;
 374     beans::PropertyValue* pMonitor = i_rController.getValue( OUString( "MonitorVisible" ) );
 375     if( pMonitor )
 376         pMonitor->Value >>= bShowProgressPanel;
 377     if( ! i_rController.isShowDialogs() )
 378         bShowProgressPanel = false;
 379
 380     // possibly create one job for collated output
 381     bool bSinglePrintJobs = false;
 382     beans::PropertyValue* pSingleValue = i_rController.getValue( OUString( "PrintCollateAsSingleJobs" ) );
 383     if( pSingleValue )
 384     {
 385         pSingleValue->Value >>= bSinglePrintJobs;
 386     }
 387
 388     // FIXME: jobStarted() should be done after the print dialog has ended (if there is one)
 389     // how do I know when that might be ?
 390     i_rController.jobStarted();
 391
 392     int nCopies = i_rController.getPrinter()->GetCopyCount();
 393     int nJobs = 1;
 394     if( bSinglePrintJobs )
 395     {
 396         nJobs = nCopies;
 397         nCopies = 1;
 398     }
 399
 400     for( int nCurJob = 0; nCurJob < nJobs; nCurJob++ )
 401     {
 402         aAccViewState.bNeedRestart = true;
 403         do
 404         {
 405             if( aAccViewState.bNeedRestart )
 406             {
 407                 mnCurPageRangeStart = 0;
 408                 mnCurPageRangeCount = 0;
 409                 nAllPages = i_rController.getFilteredPageCount();
 410             }
 411
 412             aAccViewState.bNeedRestart = false;
 413
 414             Size aCurSize( 21000, 29700 );
 415             if( nAllPages > 0 )
 416             {
 417                 mnCurPageRangeCount = 1;
 418                 aCurSize = getPageSize( i_rController, mnCurPageRangeStart );
 419                 Size aNextSize( aCurSize );
 420
 421                 // print pages up to a different size
 422                 while( mnCurPageRangeCount + mnCurPageRangeStart < nAllPages )
 423                 {
 424                     aNextSize = getPageSize( i_rController, mnCurPageRangeStart + mnCurPageRangeCount );
 425                     if( aCurSize == aNextSize // same page size
 426                         ||
 427                         (aCurSize.Width() == aNextSize.Height() && aCurSize.Height() == aNextSize.Width()) // same size, but different orientation
 428                         )
 429                     {
 430                         mnCurPageRangeCount++;
 431                     }
 432                     else
 433                         break;
 434                 }
 435             }
 436             else
 437                 mnCurPageRangeCount = 0;
 438
 439             // now for the current run
 440             mnStartPageOffsetX = mnStartPageOffsetY = 0;
 441             // setup the paper size and orientation
 442             // do this on our associated Printer object, since that is
 443             // out interface to the applications which occasionally rely on the paper
 444             // information (e.g. brochure printing scales to the found paper size)
 445             // also SetPaperSizeUser has the advantage that we can share a
 446             // platform independent paper matching algorithm
 447             VclPtr<Printer> pPrinter( i_rController.getPrinter() );
 448             pPrinter->SetMapMode( MapMode( MapUnit::Map100thMM ) );
 449             pPrinter->SetPaperSizeUser( aCurSize, true );
 450
 451             // create view
 452             NSView* pPrintView = [[AquaPrintView alloc] initWithController: &i_rController withInfoPrinter: this];
 453
 454             NSMutableDictionary* pPrintDict = [mpPrintInfo dictionary];
 455
 456             // set filename
 457             if( i_pFileName )
 458             {
 459                 [mpPrintInfo setJobDisposition: NSPrintSaveJob];
 460                 NSString* pPath = CreateNSString( *i_pFileName );
 461                 [pPrintDict setObject:[NSURL fileURLWithPath:pPath] forKey:NSPrintJobSavingURL];
 462                 [pPath release];
 463             }
 464
 465             [pPrintDict setObject: [[NSNumber numberWithInt: nCopies] autorelease] forKey: NSPrintCopies];
 466             if( nCopies > 1 )
 467                 [pPrintDict setObject: [[NSNumber numberWithBool: pPrinter->IsCollateCopy()] autorelease] forKey: NSPrintMustCollate];
 468             [pPrintDict setObject: [[NSNumber numberWithBool: YES] autorelease] forKey: NSPrintDetailedErrorReporting];
 469             [pPrintDict setObject: [[NSNumber numberWithInt: 1] autorelease] forKey: NSPrintFirstPage];
 470             // #i103253# weird: for some reason, autoreleasing the value below like the others above
 471             // leads do a double free malloc error. Why this value should behave differently from all the others
 472             // is a mystery.
 473             [pPrintDict setObject: [NSNumber numberWithInt: mnCurPageRangeCount] forKey: NSPrintLastPage];
 474
 475             // create print operation
 476             NSPrintOperation* pPrintOperation = [NSPrintOperation printOperationWithView: pPrintView printInfo: mpPrintInfo];
 477
 478             if( pPrintOperation )
 479             {
 480                 NSObject* pReleaseAfterUse = nil;
 481                 bool bShowPanel = !i_rController.isDirectPrint()
 482                     && (officecfg::Office::Common::Misc::UseSystemPrintDialog::
 483                         get())
 484                     && i_rController.isShowDialogs();
 485                 [pPrintOperation setShowsPrintPanel: bShowPanel ? YES : NO ];
 486                 [pPrintOperation setShowsProgressPanel: bShowProgressPanel ? YES : NO];
 487
 488                 // set job title (since MacOSX 10.5)
 489                 if( [pPrintOperation respondsToSelector: @selector(setJobTitle:)] )
 490                     [pPrintOperation performSelector: @selector(setJobTitle:) withObject: [CreateNSString( i_rJobName ) autorelease]];
 491
 492                 if( bShowPanel && mnCurPageRangeStart == 0 && nCurJob == 0) // only the first range of pages (in the first job) gets the accessory view
 493                     pReleaseAfterUse = [AquaPrintAccessoryView setupPrinterPanel: pPrintOperation withController: &i_rController withState: &aAccViewState];
 494
 495                 bSuccess = true;
 496                 mbJob = true;
 497                 pInst->startedPrintJob();
 498                 BOOL wasSuccessful = [pPrintOperation runOperation];
 499                 pInst->endedPrintJob();
 500                 bSuccess = wasSuccessful;
 501                 bWasAborted = [[[pPrintOperation printInfo] jobDisposition] compare: NSPrintCancelJob] == NSOrderedSame;
 502                 mbJob = false;
 503                 if( pReleaseAfterUse )
 504                     [pReleaseAfterUse release];
 505             }
 506
 507             mnCurPageRangeStart += mnCurPageRangeCount;
 508             mnCurPageRangeCount = 1;
 509         } while( aAccViewState.bNeedRestart || mnCurPageRangeStart + mnCurPageRangeCount < nAllPages );
 510     }
 511
 512     // inform application that it can release its data
 513     // this is awkward, but the XRenderable interface has no method for this,
 514     // so we need to call XRenderadble::render one last time with IsLastPage = true
 515     i_rController.setLastPage( true );
 516     GDIMetaFile aPageFile;
 517     if( mrContext )
 518         SetupPrinterGraphics( mrContext );
 519     i_rController.getFilteredPageFile( 0, aPageFile );
 520
 521     i_rController.setJobState( bWasAborted
 522                              ? view::PrintableState_JOB_ABORTED
 523                              : view::PrintableState_JOB_SPOOLED );
 524
 525     mnCurPageRangeStart = mnCurPageRangeCount = 0;
 526
 527     return bSuccess;
 528 }
 529
 530 bool AquaSalInfoPrinter::EndJob()
 531 {
 532     mnStartPageOffsetX = mnStartPageOffsetY = 0;
 533     mbJob = false;
 534     return true;
 535 }
 536
 537 bool AquaSalInfoPrinter::AbortJob()
 538 {
 539     mbJob = false;
 540
 541     // FIXME: implementation
 542     return false;
 543 }
 544
 545 SalGraphics* AquaSalInfoPrinter::StartPage( ImplJobSetup* i_pSetupData, bool i_bNewJobData )
 546 {
 547     if( i_bNewJobData && i_pSetupData )
 548         SetPrinterData( i_pSetupData );
 549
 550     CGContextRef rContext = static_cast<CGContextRef>([[NSGraphicsContext currentContext] graphicsPort]);
 551
 552     SetupPrinterGraphics( rContext );
 553
 554     return mpGraphics;
 555 }
 556
 557 bool AquaSalInfoPrinter::EndPage()
 558 {
 559     mpGraphics->InvalidateContext();
 560     return true;
 561 }
 562
 563 sal_uLong AquaSalInfoPrinter::GetErrorCode()
 564 {
 565     return 0;
 566 }
 567
 568 AquaSalPrinter::AquaSalPrinter( AquaSalInfoPrinter* i_pInfoPrinter ) :
 569     mpInfoPrinter( i_pInfoPrinter )
 570 {
 571 }
 572
 573 AquaSalPrinter::~AquaSalPrinter()
 574 {
 575 }
 576
 577 bool AquaSalPrinter::StartJob( const OUString* i_pFileName,
 578                                const OUString& i_rJobName,
 579                                const OUString& i_rAppName,
 580                                ImplJobSetup* i_pSetupData,
 581                                vcl::PrinterController& i_rController )
 582 {
 583     return mpInfoPrinter->StartJob( i_pFileName, i_rJobName, i_rAppName, i_pSetupData, i_rController );
 584 }
 585
 586 bool AquaSalPrinter::StartJob( const OUString* /*i_pFileName*/,
 587                                const OUString& /*i_rJobName*/,
 588                                const OUString& /*i_rAppName*/,
 589                                sal_uInt32 /*i_nCopies*/,
 590                                bool /*i_bCollate*/,
 591                                bool /*i_bDirect*/,
 592                                ImplJobSetup* )
 593 {
 594     OSL_FAIL( "should never be called" );
 595     return false;
 596 }
 597
 598 bool AquaSalPrinter::EndJob()
 599 {
 600     return mpInfoPrinter->EndJob();
 601 }
 602
 603 SalGraphics* AquaSalPrinter::StartPage( ImplJobSetup* i_pSetupData, bool i_bNewJobData )
 604 {
 605     return mpInfoPrinter->StartPage( i_pSetupData, i_bNewJobData );
 606 }
 607
 608 void AquaSalPrinter::EndPage()
 609 {
 610     mpInfoPrinter->EndPage();
 611 }
 612
 613 sal_uLong AquaSalPrinter::GetErrorCode()
 614 {
 615     return AquaSalInfoPrinter::GetErrorCode();
 616 }
 617
 618 void AquaSalInfoPrinter::InitPaperFormats( const ImplJobSetup* )
 619 {
 620     m_aPaperFormats.clear();
 621     m_bPapersInit = true;
 622
 623     if( mpPrinter )
 624     {
 625         SAL_WNODEPRECATED_DECLARATIONS_PUSH
 626             //TODO: 10.9 statusForTable:, stringListForKey:inTable:
 627         if( [mpPrinter statusForTable: @"PPD"] == NSPrinterTableOK )
 628         {
 629             NSArray* pPaperNames = [mpPrinter stringListForKey: @"PageSize" inTable: @"PPD"];
 630             if( pPaperNames )
 631             {
 632                 unsigned int nPapers = [pPaperNames count];
 633                 for( unsigned int i = 0; i < nPapers; i++ )
 634                 {
 635                     NSString* pPaper = [pPaperNames objectAtIndex: i];
 636                     // first try to match the name
 637                     OString aPaperName( [pPaper UTF8String] );
 638                     Paper ePaper = PaperInfo::fromPSName( aPaperName );
 639                     if( ePaper != PAPER_USER )
 640                     {
 641                         m_aPaperFormats.push_back( PaperInfo( ePaper ) );
 642                     }
 643                     else
 644                     {
 645                         NSSize aPaperSize = [mpPrinter pageSizeForPaper: pPaper];
 646                         if( aPaperSize.width > 0 && aPaperSize.height > 0 )
 647                         {
 648                             PaperInfo aInfo( PtTo10Mu( aPaperSize.width ),
 649                                              PtTo10Mu( aPaperSize.height ) );
 650                             if( aInfo.getPaper() == PAPER_USER )
 651                                 aInfo.doSloppyFit();
 652                             m_aPaperFormats.push_back( aInfo );
 653                         }
 654                     }
 655                 }
 656             }
 657         }
 658         SAL_WNODEPRECATED_DECLARATIONS_POP
 659     }
 660 }
 661
 662 const PaperInfo* AquaSalInfoPrinter::matchPaper( long i_nWidth, long i_nHeight, Orientation& o_rOrientation ) const
 663 {
 664     if( ! m_bPapersInit )
 665         const_cast<AquaSalInfoPrinter*>(this)->InitPaperFormats( nullptr );
 666
 667     const PaperInfo* pMatch = nullptr;
 668     o_rOrientation = Orientation::Portrait;
 669     for( int n = 0; n < 2 ; n++ )
 670     {
 671         for( size_t i = 0; i < m_aPaperFormats.size(); i++ )
 672         {
 673             if( std::abs( m_aPaperFormats[i].getWidth() - i_nWidth ) < 50 &&
 674                 std::abs( m_aPaperFormats[i].getHeight() - i_nHeight ) < 50 )
 675             {
 676                 pMatch = &m_aPaperFormats[i];
 677                 return pMatch;
 678             }
 679         }
 680         o_rOrientation = Orientation::Landscape;
 681         std::swap( i_nWidth, i_nHeight );
 682     }
 683     return pMatch;
 684 }
 685
 686 int AquaSalInfoPrinter::GetLandscapeAngle( const ImplJobSetup* )
 687 {
 688     return 900;
 689 }
 690
 691 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */