vcl/source/gdi/print.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 <sal/types.h>
  21
  22 #include <tools/resary.hxx>
  23 #include <tools/helpers.hxx>
  24
  25 #include <vcl/virdev.hxx>
  26 #include <vcl/print.hxx>
  27
  28 #include <comphelper/processfactory.hxx>
  29
  30 #include "salinst.hxx"
  31 #include "salvd.hxx"
  32 #include "salgdi.hxx"
  33 #include "salptype.hxx"
  34 #include "salprn.hxx"
  35 #include "svdata.hxx"
  36 #include "svids.hrc"
  37 #include "jobset.h"
  38 #include "outdev.h"
  39 #include "PhysicalFontCollection.hxx"
  40 #include "print.h"
  41
  42 #include "com/sun/star/beans/XPropertySet.hpp"
  43 #include "com/sun/star/configuration/theDefaultProvider.hpp"
  44 #include "com/sun/star/container/XNameAccess.hpp"
  45 #include "com/sun/star/lang/XMultiServiceFactory.hpp"
  46 #include "com/sun/star/uno/Sequence.h"
  47
  48 int nImplSysDialog = 0;
  49
  50 namespace
  51 {
  52     Paper ImplGetPaperFormat( long nWidth100thMM, long nHeight100thMM )
  53     {
  54         PaperInfo aInfo(nWidth100thMM, nHeight100thMM);
  55         aInfo.doSloppyFit();
  56         return aInfo.getPaper();
  57     }
  58
  59     const PaperInfo& ImplGetEmptyPaper()
  60     {
  61         static PaperInfo aInfo(PAPER_USER);
  62         return aInfo;
  63     }
  64 }
  65
  66 void ImplUpdateJobSetupPaper( JobSetup& rJobSetup )
  67 {
  68     const ImplJobSetup& rConstData = rJobSetup.ImplGetConstData();
  69
  70     if ( !rConstData.GetPaperWidth() || !rConstData.GetPaperHeight() )
  71     {
  72         if ( rConstData.GetPaperFormat() != PAPER_USER )
  73         {
  74             PaperInfo aInfo(rConstData.GetPaperFormat());
  75
  76             ImplJobSetup& rData = rJobSetup.ImplGetData();
  77             rData.SetPaperWidth( aInfo.getWidth() );
  78             rData.SetPaperHeight( aInfo.getHeight() );
  79         }
  80     }
  81     else if ( rConstData.GetPaperFormat() == PAPER_USER )
  82     {
  83         Paper ePaper = ImplGetPaperFormat( rConstData.GetPaperWidth(), rConstData.GetPaperHeight() );
  84         if ( ePaper != PAPER_USER )
  85             rJobSetup.ImplGetData().SetPaperFormat(ePaper);
  86     }
  87 }
  88
  89 // PrinterOptions
  90 PrinterOptions::PrinterOptions() :
  91     mbReduceTransparency( false ),
  92     meReducedTransparencyMode( PrinterTransparencyMode::Auto ),
  93     mbReduceGradients( false ),
  94     meReducedGradientsMode( PrinterGradientMode::Stripes ),
  95     mnReducedGradientStepCount( 64 ),
  96     mbReduceBitmaps( false ),
  97     meReducedBitmapMode( PrinterBitmapMode::Normal ),
  98     mnReducedBitmapResolution( 200 ),
  99     mbReducedBitmapsIncludeTransparency( true ),
 100     mbConvertToGreyscales( false ),
 101     mbPDFAsStandardPrintJobFormat( false )
 102 {
 103 }
 104
 105 PrinterOptions::~PrinterOptions()
 106 {
 107 }
 108
 109 bool PrinterOptions::ReadFromConfig( bool i_bFile )
 110 {
 111     bool bSuccess = false;
 112     // save old state in case something goes wrong
 113     PrinterOptions aOldValues( *this );
 114
 115     // get the configuration service
 116     css::uno::Reference< css::lang::XMultiServiceFactory > xConfigProvider;
 117     css::uno::Reference< css::container::XNameAccess > xConfigAccess;
 118     try
 119     {
 120         // get service provider
 121         css::uno::Reference< css::uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
 122         // create configuration hierarchical access name
 123         try
 124         {
 125             xConfigProvider = css::configuration::theDefaultProvider::get( xContext );
 126
 127             css::uno::Sequence< css::uno::Any > aArgs(1);
 128             css::beans::PropertyValue aVal;
 129             aVal.Name = "nodepath";
 130             if( i_bFile )
 131                 aVal.Value <<= OUString( "/org.openoffice.Office.Common/Print/Option/File" );
 132             else
 133                 aVal.Value <<= OUString( "/org.openoffice.Office.Common/Print/Option/Printer" );
 134             aArgs.getArray()[0] <<= aVal;
 135             xConfigAccess.set(
 136                     xConfigProvider->createInstanceWithArguments(
 137                         "com.sun.star.configuration.ConfigurationAccess", aArgs ),
 138                         css::uno::UNO_QUERY );
 139             if( xConfigAccess.is() )
 140             {
 141                 css::uno::Reference< css::beans::XPropertySet > xSet( xConfigAccess, css::uno::UNO_QUERY );
 142                 if( xSet.is() )
 143                 {
 144                     sal_Int32 nValue = 0;
 145                     bool  bValue = false;
 146                     if( xSet->getPropertyValue("ReduceTransparency") >>= bValue )
 147                         SetReduceTransparency( bValue );
 148                     if( xSet->getPropertyValue("ReducedTransparencyMode") >>= nValue )
 149                         SetReducedTransparencyMode( (PrinterTransparencyMode)nValue );
 150                     if( xSet->getPropertyValue("ReduceGradients") >>= bValue )
 151                         SetReduceGradients( bValue );
 152                     if( xSet->getPropertyValue("ReducedGradientMode") >>= nValue )
 153                         SetReducedGradientMode( (PrinterGradientMode)nValue );
 154                     if( xSet->getPropertyValue("ReducedGradientStepCount") >>= nValue )
 155                         SetReducedGradientStepCount( (sal_uInt16)nValue );
 156                     if( xSet->getPropertyValue("ReduceBitmaps") >>= bValue )
 157                         SetReduceBitmaps( bValue );
 158                     if( xSet->getPropertyValue("ReducedBitmapMode") >>= nValue )
 159                         SetReducedBitmapMode( (PrinterBitmapMode)nValue );
 160                     if( xSet->getPropertyValue("ReducedBitmapResolution") >>= nValue )
 161                         SetReducedBitmapResolution( (sal_uInt16)nValue );
 162                     if( xSet->getPropertyValue("ReducedBitmapIncludesTransparency") >>= bValue )
 163                         SetReducedBitmapIncludesTransparency( bValue );
 164                     if( xSet->getPropertyValue("ConvertToGreyscales") >>= bValue )
 165                         SetConvertToGreyscales( bValue );
 166                     if( xSet->getPropertyValue("PDFAsStandardPrintJobFormat") >>= bValue )
 167                         SetPDFAsStandardPrintJobFormat( bValue );
 168
 169                     bSuccess = true;
 170                 }
 171             }
 172         }
 173         catch( const css::uno::Exception& )
 174         {
 175         }
 176     }
 177     catch( const css::lang::WrappedTargetException& )
 178     {
 179     }
 180
 181     if( ! bSuccess )
 182         *this = aOldValues;
 183     return bSuccess;
 184 }
 185
 186 bool Printer::DrawTransformBitmapExDirect(
 187     const basegfx::B2DHomMatrix& /*aFullTransform*/,
 188     const BitmapEx& /*rBitmapEx*/)
 189 {
 190     // printers can't draw bitmaps directly
 191     return false;
 192 }
 193
 194 bool Printer::TransformAndReduceBitmapExToTargetRange(
 195     const basegfx::B2DHomMatrix& /*aFullTransform*/,
 196     basegfx::B2DRange& /*aVisibleRange*/,
 197     double& /*fMaximumArea*/)
 198 {
 199     // deliberately do nothing - you can't reduce the
 200     // target range for a printer at all
 201     return true;
 202 }
 203
 204 void Printer::DrawDeviceBitmap( const Point& rDestPt, const Size& rDestSize,
 205                                 const Point& rSrcPtPixel, const Size& rSrcSizePixel,
 206                                 BitmapEx& rBmpEx )
 207 {
 208     if( rBmpEx.IsAlpha() )
 209     {
 210         // #107169# For true alpha bitmaps, no longer masking the
 211         // bitmap, but perform a full alpha blend against a white
 212         // background here.
 213         Bitmap aBmp( rBmpEx.GetBitmap() );
 214         aBmp.Blend( rBmpEx.GetAlpha(), Color( COL_WHITE) );
 215         DrawBitmap( rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel, aBmp );
 216     }
 217     else
 218     {
 219         Bitmap aBmp( rBmpEx.GetBitmap() ), aMask( rBmpEx.GetMask() );
 220         aBmp.Replace( aMask, Color( COL_WHITE ) );
 221         ImplPrintTransparent( aBmp, aMask, rDestPt, rDestSize, rSrcPtPixel, rSrcSizePixel );
 222     }
 223 }
 224
 225 void Printer::EmulateDrawTransparent ( const tools::PolyPolygon& rPolyPoly,
 226                                        sal_uInt16 nTransparencePercent )
 227 {
 228     // #110958# Disable alpha VDev, we perform the necessary
 229     VirtualDevice* pOldAlphaVDev = mpAlphaVDev;
 230
 231     // operation explicitly further below.
 232     if( mpAlphaVDev )
 233         mpAlphaVDev = nullptr;
 234
 235     GDIMetaFile* pOldMetaFile = mpMetaFile;
 236     mpMetaFile = nullptr;
 237
 238     mpMetaFile = pOldMetaFile;
 239
 240     // #110958# Restore disabled alpha VDev
 241     mpAlphaVDev = pOldAlphaVDev;
 242
 243     tools::Rectangle       aPolyRect( LogicToPixel( rPolyPoly ).GetBoundRect() );
 244     const Size      aDPISize( LogicToPixel( Size( 1, 1 ), MapUnit::MapInch ) );
 245     const long      nBaseExtent = std::max( FRound( aDPISize.Width() / 300. ), 1L );
 246     long            nMove;
 247     const sal_uInt16    nTrans = ( nTransparencePercent < 13 ) ? 0 :
 248         ( nTransparencePercent < 38 ) ? 25 :
 249         ( nTransparencePercent < 63 ) ? 50 :
 250         ( nTransparencePercent < 88 ) ? 75 : 100;
 251
 252     switch( nTrans )
 253     {
 254         case 25: nMove = nBaseExtent * 3; break;
 255         case 50: nMove = nBaseExtent * 4; break;
 256         case 75: nMove = nBaseExtent * 6; break;
 257
 258             // #i112959#  very transparent (88 < nTransparencePercent <= 99)
 259         case 100: nMove = nBaseExtent * 8; break;
 260
 261             // #i112959# not transparent (nTransparencePercent < 13)
 262         default:    nMove = 0; break;
 263     }
 264
 265     Push( PushFlags::CLIPREGION | PushFlags::LINECOLOR );
 266     IntersectClipRegion(vcl::Region(rPolyPoly));
 267     SetLineColor( GetFillColor() );
 268     const bool bOldMap = mbMap;
 269     EnableMapMode( false );
 270
 271     if(nMove)
 272     {
 273         tools::Rectangle aRect( aPolyRect.TopLeft(), Size( aPolyRect.GetWidth(), nBaseExtent ) );
 274         while( aRect.Top() <= aPolyRect.Bottom() )
 275         {
 276             DrawRect( aRect );
 277             aRect.Move( 0, nMove );
 278         }
 279
 280         aRect = tools::Rectangle( aPolyRect.TopLeft(), Size( nBaseExtent, aPolyRect.GetHeight() ) );
 281         while( aRect.Left() <= aPolyRect.Right() )
 282         {
 283             DrawRect( aRect );
 284             aRect.Move( nMove, 0 );
 285         }
 286     }
 287     else
 288     {
 289         // #i112959# if not transparent, draw full rectangle in clip region
 290         DrawRect( aPolyRect );
 291     }
 292
 293     EnableMapMode( bOldMap );
 294     Pop();
 295
 296     mpMetaFile = pOldMetaFile;
 297
 298     // #110958# Restore disabled alpha VDev
 299     mpAlphaVDev = pOldAlphaVDev;
 300 }
 301
 302 void Printer::DrawOutDev( const Point& /*rDestPt*/, const Size& /*rDestSize*/,
 303                                const Point& /*rSrcPt*/,  const Size& /*rSrcSize*/ )
 304 {
 305     SAL_WARN( "vcl.gdi", "Don't use OutputDevice::DrawOutDev(...) with printer devices!" );
 306 }
 307
 308 void Printer::DrawOutDev( const Point& /*rDestPt*/, const Size& /*rDestSize*/,
 309                                const Point& /*rSrcPt*/,  const Size& /*rSrcSize*/,
 310                                const OutputDevice& /*rOutDev*/ )
 311 {
 312     SAL_WARN( "vcl.gdi", "Don't use OutputDevice::DrawOutDev(...) with printer devices!" );
 313 }
 314
 315 void Printer::CopyArea( const Point& /*rDestPt*/,
 316                         const Point& /*rSrcPt*/,  const Size& /*rSrcSize*/,
 317                         bool /*bWindowInvalidate*/ )
 318 {
 319     SAL_WARN( "vcl.gdi", "Don't use OutputDevice::CopyArea(...) with printer devices!" );
 320 }
 321
 322 void Printer::SetPrinterOptions( const PrinterOptions& i_rOptions )
 323 {
 324     *mpPrinterOptions = i_rOptions;
 325 }
 326
 327 bool Printer::HasMirroredGraphics() const
 328 {
 329     // due to a "hotfix" for AOO bug i55719, this needs to return false
 330     return false;
 331 }
 332
 333 // QueueInfo
 334 QueueInfo::QueueInfo()
 335 {
 336     mnStatus    = PrintQueueFlags::NONE;
 337     mnJobs      = 0;
 338 }
 339
 340 QueueInfo::QueueInfo( const QueueInfo& rInfo ) :
 341     maPrinterName( rInfo.maPrinterName ),
 342     maDriver( rInfo.maDriver ),
 343     maLocation( rInfo.maLocation ),
 344     maComment( rInfo.maComment ),
 345     mnStatus( rInfo.mnStatus ),
 346     mnJobs( rInfo.mnJobs )
 347 {
 348 }
 349
 350 QueueInfo::~QueueInfo()
 351 {
 352 }
 353
 354 SalPrinterQueueInfo::SalPrinterQueueInfo()
 355 {
 356     mnStatus    = PrintQueueFlags::NONE;
 357     mnJobs      = QUEUE_JOBS_DONTKNOW;
 358     mpSysData   = nullptr;
 359 }
 360
 361 SalPrinterQueueInfo::~SalPrinterQueueInfo()
 362 {
 363 }
 364
 365 ImplPrnQueueList::~ImplPrnQueueList()
 366 {
 367     ImplSVData*         pSVData = ImplGetSVData();
 368     for(ImplPrnQueueData & rQueueInfo : m_aQueueInfos)
 369     {
 370         delete rQueueInfo.mpQueueInfo;
 371         pSVData->mpDefInst->DeletePrinterQueueInfo( rQueueInfo.mpSalQueueInfo );
 372     }
 373 }
 374
 375 void ImplPrnQueueList::Add( SalPrinterQueueInfo* pData )
 376 {
 377     std::unordered_map< OUString, sal_Int32, OUStringHash >::iterator it =
 378         m_aNameToIndex.find( pData->maPrinterName );
 379     if( it == m_aNameToIndex.end() )
 380     {
 381         m_aNameToIndex[ pData->maPrinterName ] = m_aQueueInfos.size();
 382         m_aQueueInfos.push_back( ImplPrnQueueData() );
 383         m_aQueueInfos.back().mpQueueInfo = nullptr;
 384         m_aQueueInfos.back().mpSalQueueInfo = pData;
 385         m_aPrinterList.push_back( pData->maPrinterName );
 386     }
 387     else // this should not happen, but ...
 388     {
 389         ImplPrnQueueData& rData = m_aQueueInfos[ it->second ];
 390         delete rData.mpQueueInfo;
 391         rData.mpQueueInfo = nullptr;
 392         ImplGetSVData()->mpDefInst->DeletePrinterQueueInfo( rData.mpSalQueueInfo );
 393         rData.mpSalQueueInfo = pData;
 394     }
 395 }
 396
 397 ImplPrnQueueData* ImplPrnQueueList::Get( const OUString& rPrinter )
 398 {
 399     ImplPrnQueueData* pData = nullptr;
 400     std::unordered_map<OUString,sal_Int32,OUStringHash>::iterator it =
 401         m_aNameToIndex.find( rPrinter );
 402     if( it != m_aNameToIndex.end() )
 403         pData = &m_aQueueInfos[it->second];
 404     return pData;
 405 }
 406
 407 static void ImplInitPrnQueueList()
 408 {
 409     ImplSVData* pSVData = ImplGetSVData();
 410
 411     pSVData->maGDIData.mpPrinterQueueList = new ImplPrnQueueList;
 412
 413     static const char* pEnv = getenv( "SAL_DISABLE_PRINTERLIST" );
 414     if( !pEnv || !*pEnv )
 415         pSVData->mpDefInst->GetPrinterQueueInfo( pSVData->maGDIData.mpPrinterQueueList );
 416 }
 417
 418 void ImplDeletePrnQueueList()
 419 {
 420     ImplSVData*         pSVData = ImplGetSVData();
 421     ImplPrnQueueList*   pPrnList = pSVData->maGDIData.mpPrinterQueueList;
 422
 423     if ( pPrnList )
 424     {
 425         delete pPrnList;
 426         pSVData->maGDIData.mpPrinterQueueList = nullptr;
 427     }
 428 }
 429
 430 const std::vector<OUString>& Printer::GetPrinterQueues()
 431 {
 432     ImplSVData* pSVData = ImplGetSVData();
 433     if ( !pSVData->maGDIData.mpPrinterQueueList )
 434         ImplInitPrnQueueList();
 435     return pSVData->maGDIData.mpPrinterQueueList->m_aPrinterList;
 436 }
 437
 438 const QueueInfo* Printer::GetQueueInfo( const OUString& rPrinterName, bool bStatusUpdate )
 439 {
 440     ImplSVData* pSVData = ImplGetSVData();
 441
 442     if ( !pSVData->maGDIData.mpPrinterQueueList )
 443         ImplInitPrnQueueList();
 444
 445     if ( !pSVData->maGDIData.mpPrinterQueueList )
 446         return nullptr;
 447
 448     ImplPrnQueueData* pInfo = pSVData->maGDIData.mpPrinterQueueList->Get( rPrinterName );
 449     if( pInfo )
 450     {
 451         if( !pInfo->mpQueueInfo || bStatusUpdate )
 452             pSVData->mpDefInst->GetPrinterQueueState( pInfo->mpSalQueueInfo );
 453
 454         if ( !pInfo->mpQueueInfo )
 455             pInfo->mpQueueInfo = new QueueInfo;
 456
 457         pInfo->mpQueueInfo->maPrinterName   = pInfo->mpSalQueueInfo->maPrinterName;
 458         pInfo->mpQueueInfo->maDriver        = pInfo->mpSalQueueInfo->maDriver;
 459         pInfo->mpQueueInfo->maLocation      = pInfo->mpSalQueueInfo->maLocation;
 460         pInfo->mpQueueInfo->maComment       = pInfo->mpSalQueueInfo->maComment;
 461         pInfo->mpQueueInfo->mnStatus        = pInfo->mpSalQueueInfo->mnStatus;
 462         pInfo->mpQueueInfo->mnJobs          = pInfo->mpSalQueueInfo->mnJobs;
 463         return pInfo->mpQueueInfo;
 464     }
 465     return nullptr;
 466 }
 467
 468 OUString Printer::GetDefaultPrinterName()
 469 {
 470     static const char* pEnv = getenv( "SAL_DISABLE_DEFAULTPRINTER" );
 471     if( !pEnv || !*pEnv )
 472     {
 473         ImplSVData* pSVData = ImplGetSVData();
 474
 475         return pSVData->mpDefInst->GetDefaultPrinter();
 476     }
 477     return OUString();
 478 }
 479
 480 void Printer::ImplInitData()
 481 {
 482     mbDevOutput         = false;
 483     meOutDevType        = OUTDEV_PRINTER;
 484     mbDefPrinter        = false;
 485     mnError             = 0;
 486     mnCurPage           = 0;
 487     mnCurPrintPage      = 0;
 488     mnPageQueueSize     = 0;
 489     mnCopyCount         = 1;
 490     mbCollateCopy       = false;
 491     mbPrinting          = false;
 492     mbJobActive         = false;
 493     mbPrintFile         = false;
 494     mbInPrintPage       = false;
 495     mbNewJobSetup       = false;
 496     mpInfoPrinter       = nullptr;
 497     mpPrinter           = nullptr;
 498     mpDisplayDev        = nullptr;
 499     mpPrinterOptions    = new PrinterOptions;
 500
 501     // Add printer to the list
 502     ImplSVData* pSVData = ImplGetSVData();
 503     mpNext = pSVData->maGDIData.mpFirstPrinter;
 504     mpPrev = nullptr;
 505     if ( mpNext )
 506         mpNext->mpPrev = this;
 507     else
 508         pSVData->maGDIData.mpLastPrinter = this;
 509     pSVData->maGDIData.mpFirstPrinter = this;
 510 }
 511
 512 bool Printer::AcquireGraphics() const
 513 {
 514     DBG_TESTSOLARMUTEX();
 515
 516     if ( mpGraphics )
 517         return true;
 518
 519     mbInitLineColor     = true;
 520     mbInitFillColor     = true;
 521     mbInitFont          = true;
 522     mbInitTextColor     = true;
 523     mbInitClipRegion    = true;
 524
 525     ImplSVData* pSVData = ImplGetSVData();
 526
 527     if ( mpJobGraphics )
 528         mpGraphics = mpJobGraphics;
 529     else if ( mpDisplayDev )
 530     {
 531         const VirtualDevice* pVirDev = mpDisplayDev;
 532         mpGraphics = pVirDev->mpVirDev->AcquireGraphics();
 533         // if needed retry after releasing least recently used virtual device graphics
 534         while ( !mpGraphics )
 535         {
 536             if ( !pSVData->maGDIData.mpLastVirGraphics )
 537                 break;
 538             pSVData->maGDIData.mpLastVirGraphics->ReleaseGraphics();
 539             mpGraphics = pVirDev->mpVirDev->AcquireGraphics();
 540         }
 541         // update global LRU list of virtual device graphics
 542         if ( mpGraphics )
 543         {
 544             mpNextGraphics = pSVData->maGDIData.mpFirstVirGraphics;
 545             pSVData->maGDIData.mpFirstVirGraphics = const_cast<Printer*>(this);
 546             if ( mpNextGraphics )
 547                 mpNextGraphics->mpPrevGraphics = const_cast<Printer*>(this);
 548             if ( !pSVData->maGDIData.mpLastVirGraphics )
 549                 pSVData->maGDIData.mpLastVirGraphics = const_cast<Printer*>(this);
 550         }
 551     }
 552     else
 553     {
 554         mpGraphics = mpInfoPrinter->AcquireGraphics();
 555         // if needed retry after releasing least recently used printer graphics
 556         while ( !mpGraphics )
 557         {
 558             if ( !pSVData->maGDIData.mpLastPrnGraphics )
 559                 break;
 560             pSVData->maGDIData.mpLastPrnGraphics->ReleaseGraphics();
 561             mpGraphics = mpInfoPrinter->AcquireGraphics();
 562         }
 563         // update global LRU list of printer graphics
 564         if ( mpGraphics )
 565         {
 566             mpNextGraphics = pSVData->maGDIData.mpFirstPrnGraphics;
 567             pSVData->maGDIData.mpFirstPrnGraphics = const_cast<Printer*>(this);
 568             if ( mpNextGraphics )
 569                 mpNextGraphics->mpPrevGraphics = const_cast<Printer*>(this);
 570             if ( !pSVData->maGDIData.mpLastPrnGraphics )
 571                 pSVData->maGDIData.mpLastPrnGraphics = const_cast<Printer*>(this);
 572         }
 573     }
 574
 575     if ( mpGraphics )
 576     {
 577         mpGraphics->SetXORMode( (RasterOp::Invert == meRasterOp) || (RasterOp::Xor == meRasterOp) );
 578         mpGraphics->setAntiAliasB2DDraw(bool(mnAntialiasing & AntialiasingFlags::EnableB2dDraw));
 579     }
 580
 581     return mpGraphics != nullptr;
 582 }
 583
 584 void Printer::ImplReleaseFonts()
 585 {
 586 #ifdef UNX
 587     // HACK to fix an urgent P1 printing issue fast
 588     // WinSalPrinter does not respect GetGraphics/ReleaseGraphics conventions
 589     // so Printer::mpGraphics often points to a dead WinSalGraphics
 590     // TODO: fix WinSalPrinter's GetGraphics/ReleaseGraphics handling
 591     mpGraphics->ReleaseFonts();
 592 #endif
 593     mbNewFont = true;
 594     mbInitFont = true;
 595
 596     if ( mpFontInstance )
 597     {
 598         mpFontCache->Release( mpFontInstance );
 599         mpFontInstance = nullptr;
 600     }
 601
 602     if ( mpDeviceFontList )
 603     {
 604         delete mpDeviceFontList;
 605         mpDeviceFontList = nullptr;
 606     }
 607
 608     if ( mpDeviceFontSizeList )
 609     {
 610         delete mpDeviceFontSizeList;
 611         mpDeviceFontSizeList = nullptr;
 612     }
 613 }
 614
 615 void Printer::ReleaseGraphics( bool bRelease )
 616 {
 617     DBG_TESTSOLARMUTEX();
 618
 619     if ( !mpGraphics )
 620         return;
 621
 622     // release the fonts of the physically released graphics device
 623     if( bRelease )
 624         ImplReleaseFonts();
 625
 626     ImplSVData* pSVData = ImplGetSVData();
 627
 628     Printer* pPrinter = this;
 629
 630     if ( !pPrinter->mpJobGraphics )
 631     {
 632         if ( pPrinter->mpDisplayDev )
 633         {
 634             VirtualDevice* pVirDev = pPrinter->mpDisplayDev;
 635             if ( bRelease )
 636                 pVirDev->mpVirDev->ReleaseGraphics( mpGraphics );
 637             // remove from global LRU list of virtual device graphics
 638             if ( mpPrevGraphics )
 639                 mpPrevGraphics->mpNextGraphics = mpNextGraphics;
 640             else
 641                 pSVData->maGDIData.mpFirstVirGraphics = mpNextGraphics;
 642             if ( mpNextGraphics )
 643                 mpNextGraphics->mpPrevGraphics = mpPrevGraphics;
 644             else
 645                 pSVData->maGDIData.mpLastVirGraphics = mpPrevGraphics;
 646         }
 647         else
 648         {
 649             if ( bRelease )
 650                 pPrinter->mpInfoPrinter->ReleaseGraphics( mpGraphics );
 651             // remove from global LRU list of printer graphics
 652             if ( mpPrevGraphics )
 653                 mpPrevGraphics->mpNextGraphics = mpNextGraphics;
 654             else
 655                 pSVData->maGDIData.mpFirstPrnGraphics = mpNextGraphics;
 656             if ( mpNextGraphics )
 657                 mpNextGraphics->mpPrevGraphics = mpPrevGraphics;
 658             else
 659                 pSVData->maGDIData.mpLastPrnGraphics = mpPrevGraphics;
 660         }
 661     }
 662
 663     mpGraphics      = nullptr;
 664     mpPrevGraphics  = nullptr;
 665     mpNextGraphics  = nullptr;
 666 }
 667
 668 void Printer::ImplInit( SalPrinterQueueInfo* pInfo )
 669 {
 670     ImplSVData* pSVData = ImplGetSVData();
 671     // #i74084# update info for this specific SalPrinterQueueInfo
 672     pSVData->mpDefInst->GetPrinterQueueState( pInfo );
 673
 674     // Test whether the driver actually matches the JobSetup
 675     ImplJobSetup& rData = maJobSetup.ImplGetData();
 676     if ( rData.GetDriverData() )
 677     {
 678         if ( rData.GetPrinterName() != pInfo->maPrinterName ||
 679              rData.GetDriver() != pInfo->maDriver )
 680         {
 681             rtl_freeMemory( const_cast<sal_uInt8*>(rData.GetDriverData()) );
 682             rData.SetDriverData(nullptr);
 683             rData.SetDriverDataLen(0);
 684         }
 685     }
 686
 687     // Remember printer name
 688     maPrinterName = pInfo->maPrinterName;
 689     maDriver = pInfo->maDriver;
 690
 691     // Add printer name to JobSetup
 692     rData.SetPrinterName( maPrinterName );
 693     rData.SetDriver( maDriver );
 694
 695     mpInfoPrinter   = pSVData->mpDefInst->CreateInfoPrinter( pInfo, &rData );
 696     mpPrinter       = nullptr;
 697     mpJobGraphics   = nullptr;
 698     ImplUpdateJobSetupPaper( maJobSetup );
 699
 700     if ( !mpInfoPrinter )
 701     {
 702         ImplInitDisplay();
 703         return;
 704     }
 705
 706     // we need a graphics
 707     if ( !AcquireGraphics() )
 708     {
 709         ImplInitDisplay();
 710         return;
 711     }
 712
 713     // Init data
 714     ImplUpdatePageData();
 715     mpFontCollection = new PhysicalFontCollection();
 716     mpFontCache = new ImplFontCache();
 717     mpGraphics->GetDevFontList( mpFontCollection );
 718 }
 719
 720 void Printer::ImplInitDisplay()
 721 {
 722     ImplSVData* pSVData = ImplGetSVData();
 723
 724     mpInfoPrinter       = nullptr;
 725     mpPrinter           = nullptr;
 726     mpJobGraphics       = nullptr;
 727
 728     mpDisplayDev = VclPtr<VirtualDevice>::Create();
 729     mpFontCollection          = pSVData->maGDIData.mpScreenFontList;
 730     mpFontCache         = pSVData->maGDIData.mpScreenFontCache;
 731     mnDPIX              = mpDisplayDev->mnDPIX;
 732     mnDPIY              = mpDisplayDev->mnDPIY;
 733 }
 734
 735 void Printer::DrawDeviceMask( const Bitmap& rMask, const Color& rMaskColor,
 736                          const Point& rDestPt, const Size& rDestSize,
 737                          const Point& rSrcPtPixel, const Size& rSrcSizePixel )
 738 {
 739     Point       aPt;
 740     Point       aDestPt( LogicToPixel( rDestPt ) );
 741     Size        aDestSz( LogicToPixel( rDestSize ) );
 742     tools::Rectangle   aSrcRect( rSrcPtPixel, rSrcSizePixel );
 743
 744     aSrcRect.Justify();
 745
 746     if( !rMask.IsEmpty() && aSrcRect.GetWidth() && aSrcRect.GetHeight() && aDestSz.Width() && aDestSz.Height() )
 747     {
 748         Bitmap  aMask( rMask );
 749         BmpMirrorFlags nMirrFlags = BmpMirrorFlags::NONE;
 750
 751         if( aMask.GetBitCount() > 1 )
 752             aMask.Convert( BmpConversion::N1BitThreshold );
 753
 754         // mirrored horizontically
 755         if( aDestSz.Width() < 0 )
 756         {
 757             aDestSz.Width() = -aDestSz.Width();
 758             aDestPt.X() -= ( aDestSz.Width() - 1 );
 759             nMirrFlags |= BmpMirrorFlags::Horizontal;
 760         }
 761
 762         // mirrored vertically
 763         if( aDestSz.Height() < 0 )
 764         {
 765             aDestSz.Height() = -aDestSz.Height();
 766             aDestPt.Y() -= ( aDestSz.Height() - 1 );
 767             nMirrFlags |= BmpMirrorFlags::Vertical;
 768         }
 769
 770         // source cropped?
 771         if( aSrcRect != tools::Rectangle( aPt, aMask.GetSizePixel() ) )
 772             aMask.Crop( aSrcRect );
 773
 774         // destination mirrored
 775         if( nMirrFlags != BmpMirrorFlags::NONE)
 776             aMask.Mirror( nMirrFlags );
 777
 778         // do painting
 779         const long      nSrcWidth = aSrcRect.GetWidth(), nSrcHeight = aSrcRect.GetHeight();
 780         long            nX, nY; //, nWorkX, nWorkY, nWorkWidth, nWorkHeight;
 781         long*           pMapX = new long[ nSrcWidth + 1 ];
 782         long*           pMapY = new long[ nSrcHeight + 1 ];
 783         GDIMetaFile*    pOldMetaFile = mpMetaFile;
 784         const bool      bOldMap = mbMap;
 785
 786         mpMetaFile = nullptr;
 787         mbMap = false;
 788         Push( PushFlags::FILLCOLOR | PushFlags::LINECOLOR );
 789         SetLineColor( rMaskColor );
 790         SetFillColor( rMaskColor );
 791         InitLineColor();
 792         InitFillColor();
 793
 794         // create forward mapping tables
 795         for( nX = 0; nX <= nSrcWidth; nX++ )
 796             pMapX[ nX ] = aDestPt.X() + FRound( (double) aDestSz.Width() * nX / nSrcWidth );
 797
 798         for( nY = 0; nY <= nSrcHeight; nY++ )
 799             pMapY[ nY ] = aDestPt.Y() + FRound( (double) aDestSz.Height() * nY / nSrcHeight );
 800
 801         // walk through all rectangles of mask
 802         const vcl::Region aWorkRgn(aMask.CreateRegion(COL_BLACK, tools::Rectangle(Point(), aMask.GetSizePixel())));
 803         RectangleVector aRectangles;
 804         aWorkRgn.GetRegionRectangles(aRectangles);
 805
 806         for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); ++aRectIter)
 807         {
 808             const Point aMapPt(pMapX[aRectIter->Left()], pMapY[aRectIter->Top()]);
 809             const Size aMapSz(
 810                 pMapX[aRectIter->Right() + 1] - aMapPt.X(),      // pMapX[L + W] -> L + ((R - L) + 1) -> R + 1
 811                 pMapY[aRectIter->Bottom() + 1] - aMapPt.Y());    // same for Y
 812
 813             DrawRect(tools::Rectangle(aMapPt, aMapSz));
 814         }
 815
 816         Pop();
 817         delete[] pMapX;
 818         delete[] pMapY;
 819         mbMap = bOldMap;
 820         mpMetaFile = pOldMetaFile;
 821     }
 822 }
 823
 824 SalPrinterQueueInfo* Printer::ImplGetQueueInfo( const OUString& rPrinterName,
 825                                                 const OUString* pDriver )
 826 {
 827     ImplSVData* pSVData = ImplGetSVData();
 828     if ( !pSVData->maGDIData.mpPrinterQueueList )
 829         ImplInitPrnQueueList();
 830
 831     ImplPrnQueueList* pPrnList = pSVData->maGDIData.mpPrinterQueueList;
 832     if ( pPrnList && pPrnList->m_aQueueInfos.size() )
 833     {
 834         // first search for the printer name directly
 835         ImplPrnQueueData* pInfo = pPrnList->Get( rPrinterName );
 836         if( pInfo )
 837             return pInfo->mpSalQueueInfo;
 838
 839         // then search case insensitive
 840         for(ImplPrnQueueData & rQueueInfo : pPrnList->m_aQueueInfos)
 841         {
 842             if( rQueueInfo.mpSalQueueInfo->maPrinterName.equalsIgnoreAsciiCase( rPrinterName ) )
 843                 return rQueueInfo.mpSalQueueInfo;
 844         }
 845
 846         // then search for driver name
 847         if ( pDriver )
 848         {
 849             for(ImplPrnQueueData & rQueueInfo : pPrnList->m_aQueueInfos)
 850             {
 851                 if( rQueueInfo.mpSalQueueInfo->maDriver == *pDriver )
 852                     return rQueueInfo.mpSalQueueInfo;
 853             }
 854         }
 855
 856         // then the default printer
 857         pInfo = pPrnList->Get( GetDefaultPrinterName() );
 858         if( pInfo )
 859             return pInfo->mpSalQueueInfo;
 860
 861         // last chance: the first available printer
 862         return pPrnList->m_aQueueInfos[0].mpSalQueueInfo;
 863     }
 864
 865     return nullptr;
 866 }
 867
 868 void Printer::ImplUpdatePageData()
 869 {
 870     // we need a graphics
 871     if ( !AcquireGraphics() )
 872         return;
 873
 874     mpGraphics->GetResolution( mnDPIX, mnDPIY );
 875     mpInfoPrinter->GetPageInfo( &maJobSetup.ImplGetConstData(),
 876                                 mnOutWidth, mnOutHeight,
 877                                 maPageOffset.X(), maPageOffset.Y(),
 878                                 maPaperSize.Width(), maPaperSize.Height() );
 879 }
 880
 881 void Printer::ImplUpdateFontList()
 882 {
 883     ImplUpdateFontData();
 884 }
 885
 886 long Printer::GetGradientStepCount( long nMinRect )
 887 {
 888     // use display-equivalent step size calculation
 889     long nInc = (nMinRect < 800) ? 10 : 20;
 890
 891     return nInc;
 892 }
 893
 894 Printer::Printer()
 895 {
 896     ImplInitData();
 897     SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( GetDefaultPrinterName(), nullptr );
 898     if ( pInfo )
 899     {
 900         ImplInit( pInfo );
 901         if ( !IsDisplayPrinter() )
 902             mbDefPrinter = true;
 903     }
 904     else
 905         ImplInitDisplay();
 906 }
 907
 908 Printer::Printer( const JobSetup& rJobSetup ) :
 909     maJobSetup( rJobSetup )
 910 {
 911     ImplInitData();
 912     const ImplJobSetup& rConstData = rJobSetup.ImplGetConstData();
 913     OUString aDriver = rConstData.GetDriver();
 914     SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rConstData.GetPrinterName(),
 915                                                    &aDriver );
 916     if ( pInfo )
 917     {
 918         ImplInit( pInfo );
 919         SetJobSetup( rJobSetup );
 920     }
 921     else
 922     {
 923         ImplInitDisplay();
 924         maJobSetup = JobSetup();
 925     }
 926 }
 927
 928 Printer::Printer( const QueueInfo& rQueueInfo )
 929 {
 930     ImplInitData();
 931     SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rQueueInfo.GetPrinterName(),
 932                                                    &rQueueInfo.GetDriver() );
 933     if ( pInfo )
 934         ImplInit( pInfo );
 935     else
 936         ImplInitDisplay();
 937 }
 938
 939 Printer::Printer( const OUString& rPrinterName )
 940 {
 941     ImplInitData();
 942     SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rPrinterName, nullptr );
 943     if ( pInfo )
 944         ImplInit( pInfo );
 945     else
 946         ImplInitDisplay();
 947 }
 948
 949 Printer::~Printer()
 950 {
 951     disposeOnce();
 952 }
 953
 954 void Printer::dispose()
 955 {
 956     SAL_WARN_IF( IsPrinting(), "vcl.gdi", "Printer::~Printer() - Job is printing" );
 957     SAL_WARN_IF( IsJobActive(), "vcl.gdi", "Printer::~Printer() - Job is active" );
 958
 959     delete mpPrinterOptions;
 960     mpPrinterOptions = nullptr;
 961
 962     ReleaseGraphics();
 963     if ( mpInfoPrinter )
 964         ImplGetSVData()->mpDefInst->DestroyInfoPrinter( mpInfoPrinter );
 965     if ( mpDisplayDev )
 966         mpDisplayDev.disposeAndClear();
 967     else
 968     {
 969         // OutputDevice Dtor is trying the same thing; that why we need to set
 970         // the FontEntry to NULL here
 971         // TODO: consolidate duplicate cleanup by Printer and OutputDevice
 972         if ( mpFontInstance )
 973         {
 974             mpFontCache->Release( mpFontInstance );
 975             mpFontInstance = nullptr;
 976         }
 977         if ( mpDeviceFontList )
 978         {
 979             delete mpDeviceFontList;
 980             mpDeviceFontList = nullptr;
 981         }
 982         if ( mpDeviceFontSizeList )
 983         {
 984             delete mpDeviceFontSizeList;
 985             mpDeviceFontSizeList = nullptr;
 986         }
 987         delete mpFontCache;
 988         mpFontCache = nullptr;
 989         // font list deleted by OutputDevice dtor
 990     }
 991
 992     // Add printer from the list
 993     ImplSVData* pSVData = ImplGetSVData();
 994     if ( mpPrev )
 995         mpPrev->mpNext = mpNext;
 996     else
 997         pSVData->maGDIData.mpFirstPrinter = mpNext;
 998     if ( mpNext )
 999         mpNext->mpPrev = mpPrev;
1000     else
1001         pSVData->maGDIData.mpLastPrinter = mpPrev;
1002
1003     mpPrev.clear();
1004     mpNext.clear();
1005     OutputDevice::dispose();
1006 }
1007
1008 sal_uInt32 Printer::GetCapabilities( PrinterCapType nType ) const
1009 {
1010     if ( IsDisplayPrinter() )
1011         return 0;
1012
1013     if( mpInfoPrinter )
1014         return mpInfoPrinter->GetCapabilities( &maJobSetup.ImplGetConstData(), nType );
1015     else
1016         return 0;
1017 }
1018
1019 bool Printer::HasSupport( PrinterSupport eFeature ) const
1020 {
1021     switch ( eFeature )
1022     {
1023         case PrinterSupport::SetOrientation:
1024             return GetCapabilities( PrinterCapType::SetOrientation ) != 0;
1025         case PrinterSupport::SetPaperSize:
1026             return GetCapabilities( PrinterCapType::SetPaperSize ) != 0;
1027         case PrinterSupport::SetPaper:
1028             return GetCapabilities( PrinterCapType::SetPaper ) != 0;
1029         case PrinterSupport::CollateCopy:
1030             return (GetCapabilities( PrinterCapType::CollateCopies ) != 0);
1031         case PrinterSupport::SetupDialog:
1032             return GetCapabilities( PrinterCapType::SupportDialog ) != 0;
1033     }
1034
1035     return true;
1036 }
1037
1038 bool Printer::SetJobSetup( const JobSetup& rSetup )
1039 {
1040     if ( IsDisplayPrinter() || mbInPrintPage )
1041         return false;
1042
1043     JobSetup aJobSetup = rSetup;
1044
1045     ReleaseGraphics();
1046     if ( mpInfoPrinter->SetPrinterData( &aJobSetup.ImplGetData() ) )
1047     {
1048         ImplUpdateJobSetupPaper( aJobSetup );
1049         mbNewJobSetup = true;
1050         maJobSetup = aJobSetup;
1051         ImplUpdatePageData();
1052         ImplUpdateFontList();
1053         return true;
1054     }
1055
1056     return false;
1057 }
1058
1059 bool Printer::Setup( vcl::Window* pWindow, bool bPapersizeFromSetup )
1060 {
1061     if ( IsDisplayPrinter() )
1062         return false;
1063
1064     if ( IsJobActive() || IsPrinting() )
1065         return false;
1066
1067     JobSetup aJobSetup = maJobSetup;
1068     ImplJobSetup& rData = aJobSetup.ImplGetData();
1069     rData.SetPapersizeFromSetup( bPapersizeFromSetup );
1070     SalFrame* pFrame;
1071     if ( !pWindow )
1072         pWindow = ImplGetDefaultWindow();
1073     if( !pWindow )
1074         return false;
1075
1076     pFrame = pWindow->ImplGetFrame();
1077     ReleaseGraphics();
1078     ImplSVData* pSVData = ImplGetSVData();
1079     pSVData->maAppData.mnModalMode++;
1080     nImplSysDialog++;
1081     bool bSetup = mpInfoPrinter->Setup( pFrame, &rData );
1082     pSVData->maAppData.mnModalMode--;
1083     nImplSysDialog--;
1084     if ( bSetup )
1085     {
1086         ImplUpdateJobSetupPaper( aJobSetup );
1087         mbNewJobSetup = true;
1088         maJobSetup = aJobSetup;
1089         ImplUpdatePageData();
1090         ImplUpdateFontList();
1091         return true;
1092     }
1093     return false;
1094 }
1095
1096 bool Printer::SetPrinterProps( const Printer* pPrinter )
1097 {
1098     if ( IsJobActive() || IsPrinting() )
1099         return false;
1100
1101     ImplSVData* pSVData = ImplGetSVData();
1102
1103     mbDefPrinter        = pPrinter->mbDefPrinter;
1104     maPrintFile         = pPrinter->maPrintFile;
1105     mbPrintFile         = pPrinter->mbPrintFile;
1106     mnCopyCount         = pPrinter->mnCopyCount;
1107     mbCollateCopy       = pPrinter->mbCollateCopy;
1108     mnPageQueueSize     = pPrinter->mnPageQueueSize;
1109     *mpPrinterOptions   = *pPrinter->mpPrinterOptions;
1110
1111     if ( pPrinter->IsDisplayPrinter() )
1112     {
1113         // Destroy old printer
1114         if ( !IsDisplayPrinter() )
1115         {
1116             ReleaseGraphics();
1117             pSVData->mpDefInst->DestroyInfoPrinter( mpInfoPrinter );
1118             if ( mpFontInstance )
1119             {
1120                 mpFontCache->Release( mpFontInstance );
1121                 mpFontInstance = nullptr;
1122             }
1123             if ( mpDeviceFontList )
1124             {
1125                 delete mpDeviceFontList;
1126                 mpDeviceFontList = nullptr;
1127             }
1128             if ( mpDeviceFontSizeList )
1129             {
1130                 delete mpDeviceFontSizeList;
1131                 mpDeviceFontSizeList = nullptr;
1132             }
1133             // clean up font list
1134             delete mpFontCache;
1135             delete mpFontCollection;
1136             mpFontCache = nullptr;
1137             mpFontCollection = nullptr;
1138
1139             mbInitFont = true;
1140             mbNewFont = true;
1141             mpInfoPrinter = nullptr;
1142         }
1143
1144         // Construct new printer
1145         ImplInitDisplay();
1146         return true;
1147     }
1148
1149     // Destroy old printer?
1150     if ( GetName() != pPrinter->GetName() )
1151     {
1152         ReleaseGraphics();
1153         if ( mpDisplayDev )
1154         {
1155             mpDisplayDev.disposeAndClear();
1156         }
1157         else
1158         {
1159             pSVData->mpDefInst->DestroyInfoPrinter( mpInfoPrinter );
1160
1161             if ( mpFontInstance )
1162             {
1163                 mpFontCache->Release( mpFontInstance );
1164                 mpFontInstance = nullptr;
1165             }
1166             if ( mpDeviceFontList )
1167             {
1168                 delete mpDeviceFontList;
1169                 mpDeviceFontList = nullptr;
1170             }
1171             if ( mpDeviceFontSizeList )
1172             {
1173                 delete mpDeviceFontSizeList;
1174                 mpDeviceFontSizeList = nullptr;
1175             }
1176             delete mpFontCache;
1177             delete mpFontCollection;
1178             mpFontCache = nullptr;
1179             mpFontCollection = nullptr;
1180             mbInitFont = true;
1181             mbNewFont = true;
1182             mpInfoPrinter = nullptr;
1183         }
1184
1185         // Construct new printer
1186         OUString aDriver = pPrinter->GetDriverName();
1187         SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( pPrinter->GetName(), &aDriver );
1188         if ( pInfo )
1189         {
1190             ImplInit( pInfo );
1191             SetJobSetup( pPrinter->GetJobSetup() );
1192         }
1193         else
1194             ImplInitDisplay();
1195     }
1196     else
1197         SetJobSetup( pPrinter->GetJobSetup() );
1198
1199     return false;
1200 }
1201
1202 bool Printer::SetOrientation( Orientation eOrientation )
1203 {
1204     if ( mbInPrintPage )
1205         return false;
1206
1207     if ( maJobSetup.ImplGetConstData().GetOrientation() != eOrientation )
1208     {
1209         JobSetup      aJobSetup = maJobSetup;
1210         ImplJobSetup& rData = aJobSetup.ImplGetData();
1211
1212         rData.SetOrientation(eOrientation);
1213
1214         if ( IsDisplayPrinter() )
1215         {
1216             mbNewJobSetup = true;
1217             maJobSetup = aJobSetup;
1218             return true;
1219         }
1220
1221         ReleaseGraphics();
1222         if ( mpInfoPrinter->SetData( JobSetFlags::ORIENTATION, &rData ) )
1223         {
1224             ImplUpdateJobSetupPaper( aJobSetup );
1225             mbNewJobSetup = true;
1226             maJobSetup = aJobSetup;
1227             ImplUpdatePageData();
1228             ImplUpdateFontList();
1229             return true;
1230         }
1231         else
1232             return false;
1233     }
1234
1235     return true;
1236 }
1237
1238 Orientation Printer::GetOrientation() const
1239 {
1240     return maJobSetup.ImplGetConstData().GetOrientation();
1241 }
1242
1243 bool Printer::SetPaperBin( sal_uInt16 nPaperBin )
1244 {
1245     if ( mbInPrintPage )
1246         return false;
1247
1248     if ( maJobSetup.ImplGetConstData().GetPaperBin() != nPaperBin &&
1249          nPaperBin < GetPaperBinCount() )
1250     {
1251         JobSetup      aJobSetup = maJobSetup;
1252         ImplJobSetup& rData = aJobSetup.ImplGetData();
1253         rData.SetPaperBin(nPaperBin);
1254
1255         if ( IsDisplayPrinter() )
1256         {
1257             mbNewJobSetup = true;
1258             maJobSetup = aJobSetup;
1259             return true;
1260         }
1261
1262         ReleaseGraphics();
1263         if ( mpInfoPrinter->SetData( JobSetFlags::PAPERBIN, &rData ) )
1264         {
1265             ImplUpdateJobSetupPaper( aJobSetup );
1266             mbNewJobSetup = true;
1267             maJobSetup = aJobSetup;
1268             ImplUpdatePageData();
1269             ImplUpdateFontList();
1270             return true;
1271         }
1272         else
1273             return false;
1274     }
1275
1276     return true;
1277 }
1278
1279 sal_uInt16 Printer::GetPaperBin() const
1280 {
1281     return maJobSetup.ImplGetConstData().GetPaperBin();
1282 }
1283
1284 // Map user paper format to a available printer paper formats
1285 void Printer::ImplFindPaperFormatForUserSize( JobSetup& aJobSetup, bool bMatchNearest )
1286 {
1287     ImplJobSetup& rData = aJobSetup.ImplGetData();
1288
1289     // The angle that a landscape page will be turned counterclockwise wrt to portrait.
1290     int     nLandscapeAngle = mpInfoPrinter ? mpInfoPrinter->GetLandscapeAngle( &maJobSetup.ImplGetConstData() ) : 900;
1291
1292     int     nPaperCount     = GetPaperInfoCount();
1293     bool    bFound = false;
1294
1295     PaperInfo aInfo(rData.GetPaperWidth(), rData.GetPaperHeight());
1296
1297     // Compare all paper formats and get the appropriate one
1298     for ( int i = 0; i < nPaperCount; i++ )
1299     {
1300         const PaperInfo& rPaperInfo = GetPaperInfo( i );
1301
1302         if ( aInfo.sloppyEqual(rPaperInfo) )
1303         {
1304             rData.SetPaperFormat(
1305                 ImplGetPaperFormat( rPaperInfo.getWidth(),
1306                     rPaperInfo.getHeight() ));
1307             rData.SetOrientation( Orientation::Portrait );
1308             bFound = true;
1309             break;
1310         }
1311     }
1312
1313     // If the printer supports landscape orientation, check paper sizes again
1314     // with landscape orientation. This is necessary as a printer driver provides
1315     // all paper sizes with portrait orientation only!!
1316     if ( rData.GetPaperFormat() == PAPER_USER &&
1317          nLandscapeAngle != 0 &&
1318          HasSupport( PrinterSupport::SetOrientation ))
1319     {
1320         const long nRotatedWidth = rData.GetPaperHeight();
1321         const long nRotatedHeight = rData.GetPaperWidth();
1322         PaperInfo aRotatedInfo(nRotatedWidth, nRotatedHeight);
1323
1324         for ( int i = 0; i < nPaperCount; i++ )
1325         {
1326             const PaperInfo& rPaperInfo = GetPaperInfo( i );
1327
1328             if ( aRotatedInfo.sloppyEqual( rPaperInfo ) )
1329             {
1330                 rData.SetPaperFormat(
1331                     ImplGetPaperFormat( rPaperInfo.getWidth(),
1332                         rPaperInfo.getHeight() ));
1333                 rData.SetOrientation( Orientation::Landscape );
1334                 bFound = true;
1335                 break;
1336             }
1337         }
1338     }
1339
1340     if( ! bFound && bMatchNearest )
1341     {
1342          sal_Int64 nBestMatch = SAL_MAX_INT64;
1343          int nBestIndex = 0;
1344          Orientation eBestOrientation = Orientation::Portrait;
1345          for( int i = 0; i < nPaperCount; i++ )
1346          {
1347              const PaperInfo& rPaperInfo = GetPaperInfo( i );
1348
1349              // check portrait match
1350              sal_Int64 nDX = rData.GetPaperWidth() - rPaperInfo.getWidth();
1351              sal_Int64 nDY = rData.GetPaperHeight() - rPaperInfo.getHeight();
1352              sal_Int64 nMatch = nDX*nDX + nDY*nDY;
1353              if( nMatch < nBestMatch )
1354              {
1355                  nBestMatch = nMatch;
1356                  nBestIndex = i;
1357                  eBestOrientation = Orientation::Portrait;
1358              }
1359
1360              // check landscape match
1361              nDX = rData.GetPaperWidth() - rPaperInfo.getHeight();
1362              nDY = rData.GetPaperHeight() - rPaperInfo.getWidth();
1363              nMatch = nDX*nDX + nDY*nDY;
1364              if( nMatch < nBestMatch )
1365              {
1366                  nBestMatch = nMatch;
1367                  nBestIndex = i;
1368                  eBestOrientation = Orientation::Landscape;
1369              }
1370          }
1371          const PaperInfo& rBestInfo = GetPaperInfo( nBestIndex );
1372          rData.SetPaperFormat(
1373             ImplGetPaperFormat( rBestInfo.getWidth(),
1374                 rBestInfo.getHeight() ));
1375          rData.SetOrientation(eBestOrientation);
1376     }
1377 }
1378
1379 bool Printer::SetPaper( Paper ePaper )
1380 {
1381     if ( mbInPrintPage )
1382         return false;
1383
1384     if ( maJobSetup.ImplGetConstData().GetPaperFormat() != ePaper )
1385     {
1386         JobSetup      aJobSetup = maJobSetup;
1387         ImplJobSetup& rData = aJobSetup.ImplGetData();
1388
1389         rData.SetPaperFormat( ePaper );
1390         if ( ePaper != PAPER_USER )
1391         {
1392             PaperInfo aInfo(ePaper);
1393             rData.SetPaperWidth( aInfo.getWidth() );
1394             rData.SetPaperHeight( aInfo.getHeight() );
1395         }
1396
1397         if ( IsDisplayPrinter() )
1398         {
1399             mbNewJobSetup = true;
1400             maJobSetup = aJobSetup;
1401             return true;
1402         }
1403
1404         ReleaseGraphics();
1405         if ( ePaper == PAPER_USER )
1406             ImplFindPaperFormatForUserSize( aJobSetup, false );
1407         if ( mpInfoPrinter->SetData( JobSetFlags::PAPERSIZE | JobSetFlags::ORIENTATION, &rData ))
1408         {
1409             ImplUpdateJobSetupPaper( aJobSetup );
1410             mbNewJobSetup = true;
1411             maJobSetup = aJobSetup;
1412             ImplUpdatePageData();
1413             ImplUpdateFontList();
1414             return true;
1415         }
1416         else
1417             return false;
1418     }
1419
1420     return true;
1421 }
1422
1423 bool Printer::SetPaperSizeUser( const Size& rSize )
1424 {
1425     return SetPaperSizeUser( rSize, false );
1426 }
1427
1428 bool Printer::SetPaperSizeUser( const Size& rSize, bool bMatchNearest )
1429 {
1430     if ( mbInPrintPage )
1431         return false;
1432
1433     const Size aPixSize = LogicToPixel( rSize );
1434     const Size aPageSize = PixelToLogic( aPixSize, MapUnit::Map100thMM );
1435     bool bNeedToChange(maJobSetup.ImplGetConstData().GetPaperWidth() != aPageSize.Width() ||
1436         maJobSetup.ImplGetConstData().GetPaperHeight() != aPageSize.Height());
1437
1438     if(!bNeedToChange)
1439     {
1440         // #i122984# only need to change when Paper is different from PAPER_USER and
1441         // the mapped Paper which will created below in the call to ImplFindPaperFormatForUserSize
1442         // and will replace maJobSetup.ImplGetConstData()->GetPaperFormat(). This leads to
1443         // unnecessary JobSetups, e.g. when printing a multi-page fax, but also with
1444         // normal print
1445         const Paper aPaper = ImplGetPaperFormat(aPageSize.Width(), aPageSize.Height());
1446
1447         bNeedToChange = maJobSetup.ImplGetConstData().GetPaperFormat() != PAPER_USER &&
1448             maJobSetup.ImplGetConstData().GetPaperFormat() != aPaper;
1449     }
1450
1451     if(bNeedToChange)
1452     {
1453         JobSetup      aJobSetup = maJobSetup;
1454         ImplJobSetup& rData = aJobSetup.ImplGetData();
1455         rData.SetPaperFormat( PAPER_USER );
1456         rData.SetPaperWidth( aPageSize.Width() );
1457         rData.SetPaperHeight( aPageSize.Height() );
1458
1459         if ( IsDisplayPrinter() )
1460         {
1461             mbNewJobSetup = true;
1462             maJobSetup = aJobSetup;
1463             return true;
1464         }
1465
1466         ReleaseGraphics();
1467         ImplFindPaperFormatForUserSize( aJobSetup, bMatchNearest );
1468
1469         // Changing the paper size can also change the orientation!
1470         if ( mpInfoPrinter->SetData( JobSetFlags::PAPERSIZE | JobSetFlags::ORIENTATION, &rData ))
1471         {
1472             ImplUpdateJobSetupPaper( aJobSetup );
1473             mbNewJobSetup = true;
1474             maJobSetup = aJobSetup;
1475             ImplUpdatePageData();
1476             ImplUpdateFontList();
1477             return true;
1478         }
1479         else
1480             return false;
1481     }
1482
1483     return true;
1484 }
1485
1486 int Printer::GetPaperInfoCount() const
1487 {
1488     if( ! mpInfoPrinter )
1489         return 0;
1490     if( ! mpInfoPrinter->m_bPapersInit )
1491         mpInfoPrinter->InitPaperFormats( &maJobSetup.ImplGetConstData() );
1492     return mpInfoPrinter->m_aPaperFormats.size();
1493 }
1494
1495 OUString Printer::GetPaperName( Paper ePaper )
1496 {
1497     ImplSVData* pSVData = ImplGetSVData();
1498     if( ! pSVData->mpPaperNames )
1499     {
1500         pSVData->mpPaperNames = new std::unordered_map< int, OUString >;
1501         if( ImplGetResMgr() )
1502         {
1503             ResStringArray aPaperStrings( VclResId( RID_STR_PAPERNAMES ) );
1504             static const int PaperIndex[] =
1505             {
1506                 PAPER_A0, PAPER_A1, PAPER_A2, PAPER_A3, PAPER_A4, PAPER_A5,
1507                 PAPER_B4_ISO, PAPER_B5_ISO, PAPER_LETTER, PAPER_LEGAL, PAPER_TABLOID,
1508                 PAPER_USER, PAPER_B6_ISO, PAPER_ENV_C4, PAPER_ENV_C5, PAPER_ENV_C6, PAPER_ENV_C65,
1509                 PAPER_ENV_DL, PAPER_SLIDE_DIA, PAPER_C, PAPER_D, PAPER_E,
1510                 PAPER_EXECUTIVE, PAPER_FANFOLD_LEGAL_DE, PAPER_ENV_MONARCH, PAPER_ENV_PERSONAL,
1511                 PAPER_ENV_9, PAPER_ENV_10, PAPER_ENV_11, PAPER_ENV_12, PAPER_KAI16,
1512                 PAPER_KAI32, PAPER_KAI32BIG, PAPER_B4_JIS, PAPER_B5_JIS, PAPER_B6_JIS,
1513                 PAPER_POSTCARD_JP
1514             };
1515             OSL_ENSURE( sal_uInt32(SAL_N_ELEMENTS(PaperIndex)) == aPaperStrings.Count(), "localized paper name count wrong" );
1516             for( int i = 0; i < int(SAL_N_ELEMENTS(PaperIndex)); i++ )
1517                 (*pSVData->mpPaperNames)[PaperIndex[i]] = aPaperStrings.GetString(i);
1518         }
1519     }
1520
1521     std::unordered_map<int,OUString>::const_iterator it = pSVData->mpPaperNames->find( (int)ePaper );
1522     return (it != pSVData->mpPaperNames->end()) ? it->second : OUString();
1523 }
1524
1525 OUString Printer::GetPaperName() const
1526 {
1527     Size  aPageSize = PixelToLogic( GetPaperSizePixel(), MapUnit::Map100thMM );
1528     Paper ePaper    = ImplGetPaperFormat( aPageSize.Width(), aPageSize.Height() );
1529     if( ePaper == PAPER_USER )
1530         ePaper = ImplGetPaperFormat( aPageSize.Height(), aPageSize.Width() );
1531     return (ePaper != PAPER_USER) ? GetPaperName( ePaper ) : OUString();
1532 }
1533
1534 const PaperInfo& Printer::GetPaperInfo( int nPaper ) const
1535 {
1536     if( ! mpInfoPrinter )
1537         return ImplGetEmptyPaper();
1538     if( ! mpInfoPrinter->m_bPapersInit )
1539         mpInfoPrinter->InitPaperFormats( &maJobSetup.ImplGetConstData() );
1540     if( mpInfoPrinter->m_aPaperFormats.empty() || nPaper < 0 || nPaper >= int(mpInfoPrinter->m_aPaperFormats.size()) )
1541         return ImplGetEmptyPaper();
1542     return mpInfoPrinter->m_aPaperFormats[nPaper];
1543 }
1544
1545 bool Printer::SetDuplexMode( DuplexMode eDuplex )
1546 {
1547     if ( mbInPrintPage )
1548         return false;
1549
1550     if ( maJobSetup.ImplGetConstData().GetDuplexMode() != eDuplex )
1551     {
1552         JobSetup      aJobSetup = maJobSetup;
1553         ImplJobSetup& rData = aJobSetup.ImplGetData();
1554
1555         rData.SetDuplexMode( eDuplex );
1556
1557         if ( IsDisplayPrinter() )
1558         {
1559             mbNewJobSetup = true;
1560             maJobSetup = aJobSetup;
1561             return true;
1562         }
1563
1564         ReleaseGraphics();
1565         if ( mpInfoPrinter->SetData( JobSetFlags::DUPLEXMODE, &rData ) )
1566         {
1567             ImplUpdateJobSetupPaper( aJobSetup );
1568             mbNewJobSetup = true;
1569             maJobSetup = aJobSetup;
1570             ImplUpdatePageData();
1571             ImplUpdateFontList();
1572             return true;
1573         }
1574         else
1575             return false;
1576     }
1577
1578     return true;
1579 }
1580
1581 Paper Printer::GetPaper() const
1582 {
1583     return maJobSetup.ImplGetConstData().GetPaperFormat();
1584 }
1585
1586 sal_uInt16 Printer::GetPaperBinCount() const
1587 {
1588     if ( IsDisplayPrinter() )
1589         return 0;
1590
1591     return mpInfoPrinter->GetPaperBinCount( &maJobSetup.ImplGetConstData() );
1592 }
1593
1594 OUString Printer::GetPaperBinName( sal_uInt16 nPaperBin ) const
1595 {
1596     if ( IsDisplayPrinter() )
1597         return OUString();
1598
1599     if ( nPaperBin < GetPaperBinCount() )
1600         return mpInfoPrinter->GetPaperBinName( &maJobSetup.ImplGetConstData(), nPaperBin );
1601     else
1602         return OUString();
1603 }
1604
1605 bool Printer::SetCopyCount( sal_uInt16 nCopy, bool bCollate )
1606 {
1607     mnCopyCount = nCopy;
1608     mbCollateCopy = bCollate;
1609     return true;
1610 }
1611
1612 sal_uLong Printer::ImplSalPrinterErrorCodeToVCL( sal_uLong nError )
1613 {
1614     sal_uLong nVCLError;
1615     switch ( nError )
1616     {
1617         case 0:
1618             nVCLError = PRINTER_OK;
1619             break;
1620         case SAL_PRINTER_ERROR_ABORT:
1621             nVCLError = PRINTER_ABORT;
1622             break;
1623         default:
1624             nVCLError = PRINTER_GENERALERROR;
1625             break;
1626     }
1627
1628     return nVCLError;
1629 }
1630
1631 bool Printer::EndJob()
1632 {
1633     bool bRet = false;
1634     if ( !IsJobActive() )
1635         return bRet;
1636
1637     SAL_WARN_IF( mbInPrintPage, "vcl.gdi", "Printer::EndJob() - StartPage() without EndPage() called" );
1638
1639     mbJobActive = false;
1640
1641     if ( mpPrinter )
1642     {
1643         ReleaseGraphics();
1644
1645         mnCurPage = 0;
1646
1647         mbPrinting      = false;
1648         mnCurPrintPage  = 0;
1649         maJobName.clear();
1650
1651         mbDevOutput = false;
1652         bRet = mpPrinter->EndJob();
1653         // FIXME: Do not destroy the printer asynchronously as Win95
1654         // can't handle destroying a printer object and printing
1655         // at the same time
1656         ImplGetSVData()->mpDefInst->DestroyPrinter( mpPrinter );
1657         mpPrinter = nullptr;
1658     }
1659
1660     return bRet;
1661 }
1662
1663 void Printer::ImplStartPage()
1664 {
1665     if ( !IsJobActive() )
1666         return;
1667
1668     if ( mpPrinter )
1669     {
1670         SalGraphics* pGraphics = mpPrinter->StartPage( &maJobSetup.ImplGetData(),
1671                                                        mbNewJobSetup );
1672         if ( pGraphics )
1673         {
1674             ReleaseGraphics();
1675             mpJobGraphics = pGraphics;
1676         }
1677         mbDevOutput = true;
1678
1679         // PrintJob not aborted ???
1680         if ( IsJobActive() )
1681         {
1682             mbInPrintPage = true;
1683             mnCurPage++;
1684             mnCurPrintPage++;
1685         }
1686     }
1687 }
1688
1689 void Printer::ImplEndPage()
1690 {
1691     if ( !IsJobActive() )
1692         return;
1693
1694     mbInPrintPage = false;
1695
1696     if ( mpPrinter )
1697     {
1698         mpPrinter->EndPage();
1699         ReleaseGraphics();
1700         mbDevOutput = false;
1701
1702         mpJobGraphics = nullptr;
1703         mbNewJobSetup = false;
1704     }
1705 }
1706
1707 void Printer::updatePrinters()
1708 {
1709     ImplSVData*         pSVData = ImplGetSVData();
1710     ImplPrnQueueList*   pPrnList = pSVData->maGDIData.mpPrinterQueueList;
1711
1712     if ( pPrnList )
1713     {
1714         ImplPrnQueueList* pNewList = new ImplPrnQueueList;
1715         pSVData->mpDefInst->GetPrinterQueueInfo( pNewList );
1716
1717         bool bChanged = pPrnList->m_aQueueInfos.size() != pNewList->m_aQueueInfos.size();
1718         for( decltype(pPrnList->m_aQueueInfos)::size_type i = 0; ! bChanged && i < pPrnList->m_aQueueInfos.size(); i++ )
1719         {
1720             ImplPrnQueueData& rInfo     = pPrnList->m_aQueueInfos[i];
1721             ImplPrnQueueData& rNewInfo  = pNewList->m_aQueueInfos[i];
1722             if( ! rInfo.mpSalQueueInfo || ! rNewInfo.mpSalQueueInfo || // sanity check
1723                 rInfo.mpSalQueueInfo->maPrinterName != rNewInfo.mpSalQueueInfo->maPrinterName )
1724             {
1725                 bChanged = true;
1726             }
1727         }
1728         if( bChanged )
1729         {
1730             ImplDeletePrnQueueList();
1731             pSVData->maGDIData.mpPrinterQueueList = pNewList;
1732
1733             Application* pApp = GetpApp();
1734             if( pApp )
1735             {
1736                 DataChangedEvent aDCEvt( DataChangedEventType::PRINTER );
1737                 Application::NotifyAllWindows( aDCEvt );
1738             }
1739         }
1740         else
1741             delete pNewList;
1742     }
1743 }
1744
1745 bool Printer::UsePolyPolygonForComplexGradient()
1746 {
1747     return true;
1748 }
1749
1750 void Printer::ClipAndDrawGradientMetafile ( const Gradient &rGradient, const tools::PolyPolygon &rPolyPoly )
1751 {
1752     const tools::Rectangle aBoundRect( rPolyPoly.GetBoundRect() );
1753
1754     Push( PushFlags::CLIPREGION );
1755     IntersectClipRegion(vcl::Region(rPolyPoly));
1756     DrawGradient( aBoundRect, rGradient );
1757     Pop();
1758 }
1759
1760 void Printer::InitFont() const
1761 {
1762     DBG_TESTSOLARMUTEX();
1763
1764     if (!mpFontInstance)
1765         return;
1766
1767     if ( mbInitFont )
1768     {
1769         // select font in the device layers
1770         mpGraphics->SetFont( &(mpFontInstance->maFontSelData), 0 );
1771         mbInitFont = false;
1772     }
1773 }
1774
1775 void Printer::SetFontOrientation( LogicalFontInstance* const pFontEntry ) const
1776 {
1777     pFontEntry->mnOrientation = pFontEntry->mxFontMetric->GetOrientation();
1778 }
1779
1780 Bitmap Printer::GetBitmap( const Point& rSrcPt, const Size& rSize ) const
1781 {
1782     SAL_WARN("vcl.gdi", "GetBitmap(): This should never be called on by a Printer instance");
1783
1784     return OutputDevice::GetBitmap( rSrcPt, rSize );
1785 }
1786
1787 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */