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