vcl/source/gdi/impprn.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: impprn.cxx,v $
  10  * $Revision: 1.18.86.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #define _SPOOLPRINTER_EXT
  35 #include "tools/queue.hxx"
  36 #include "vcl/svapp.hxx"
  37 #include "vcl/metaact.hxx"
  38 #include "vcl/gdimtf.hxx"
  39 #include "vcl/timer.hxx"
  40 #include "vcl/impprn.hxx"
  41 #include "vcl/jobset.h"
  42
  43 #include "vcl/svdata.hxx"
  44 #include "vcl/salprn.hxx"
  45
  46 // -----------
  47 // - Defines -
  48 // -----------
  49
  50 #define OPTIMAL_BMP_RESOLUTION  300
  51 #define NORMAL_BMP_RESOLUTION   200
  52
  53 // =======================================================================
  54
  55 struct QueuePage
  56 {
  57     GDIMetaFile*        mpMtf;
  58     JobSetup*           mpSetup;
  59     USHORT                      mnPage;
  60     BOOL                        mbEndJob;
  61
  62                     QueuePage() { mpMtf = NULL; mpSetup = NULL; }
  63                     ~QueuePage() { delete mpMtf; if ( mpSetup ) delete mpSetup; }
  64 };
  65
  66 // =======================================================================
  67
  68 ImplQPrinter::ImplQPrinter( Printer* pParent ) :
  69     Printer( pParent->GetName() ),
  70     mpParent( pParent ),
  71     mbAborted( false ),
  72     mbUserCopy( false ),
  73     mbDestroyAllowed( true ),
  74     mbDestroyed( false ),
  75     mnMaxBmpDPIX( mnDPIX ),
  76     mnMaxBmpDPIY( mnDPIY ),
  77     mnCurCopyCount( 0 )
  78 {
  79     SetSelfAsQueuePrinter( TRUE );
  80     SetPrinterProps( pParent );
  81     SetPageQueueSize( 0 );
  82     mnCopyCount         = pParent->mnCopyCount;
  83     mbCollateCopy       = pParent->mbCollateCopy;
  84 }
  85
  86 // -----------------------------------------------------------------------
  87
  88 ImplQPrinter::~ImplQPrinter()
  89 {
  90     for( std::vector< QueuePage* >::iterator it = maQueue.begin();
  91          it != maQueue.end(); ++it )
  92         delete (*it);
  93 }
  94
  95 // -----------------------------------------------------------------------------
  96
  97 void ImplQPrinter::Destroy()
  98 {
  99     if( mbDestroyAllowed )
 100         delete this;
 101     else
 102         mbDestroyed = TRUE;
 103 }
 104
 105 // -----------------------------------------------------------------------
 106
 107 void ImplQPrinter::ImplPrintMtf( GDIMetaFile& rPrtMtf, long nMaxBmpDPIX, long nMaxBmpDPIY )
 108 {
 109     for( MetaAction* pAct = rPrtMtf.FirstAction(); pAct && !mbAborted; pAct = rPrtMtf.NextAction() )
 110     {
 111         const ULONG             nType = pAct->GetType();
 112         sal_Bool                bExecuted = sal_False;
 113
 114         if( nType == META_COMMENT_ACTION )
 115         {
 116             // search for special comments ( ..._BEGIN/..._END )
 117             MetaCommentAction* pComment = (MetaCommentAction*) pAct;
 118
 119             if( pComment->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_BEGIN" ) == COMPARE_EQUAL )
 120             {
 121                 pAct = rPrtMtf.NextAction();
 122
 123                 // if next action is a GradientEx action, execute this and
 124                 // skip actions until a XGRAD_SEQ_END comment is found
 125                 if( pAct && ( pAct->GetType() == META_GRADIENTEX_ACTION ) )
 126                 {
 127                     MetaGradientExAction* pGradientExAction = (MetaGradientExAction*) pAct;
 128                     DrawGradientEx( this, pGradientExAction->GetPolyPolygon(), pGradientExAction->GetGradient() );
 129
 130                     // seek to end of this comment
 131                     do
 132                     {
 133                         pAct = rPrtMtf.NextAction();
 134                     }
 135                     while( pAct &&
 136                            ( ( pAct->GetType() != META_COMMENT_ACTION ) ||
 137                              ( ( (MetaCommentAction*) pAct )->GetComment().CompareIgnoreCaseToAscii( "XGRAD_SEQ_END" ) != COMPARE_EQUAL ) ) );
 138
 139                     bExecuted = sal_True;
 140                 }
 141             }
 142             else if( pComment->GetComment().CompareIgnoreCaseToAscii( "PRNSPOOL_TRANSPARENTBITMAP_BEGIN" ) == COMPARE_EQUAL )
 143             {
 144                 pAct = rPrtMtf.NextAction();
 145
 146                 if( pAct && ( pAct->GetType() == META_BMPSCALE_ACTION ) )
 147                 {
 148                     // execute action here to avoid DPI processing of bitmap;
 149                     pAct->Execute( this );
 150
 151 #ifdef VERBOSE_DEBUG
 152                     Push();
 153                     SetLineColor(COL_RED);
 154                     SetFillColor();
 155                     DrawRect( Rectangle(
 156                                   static_cast<MetaBmpScaleAction*>(pAct)->GetPoint(),
 157                                   static_cast<MetaBmpScaleAction*>(pAct)->GetSize()) );
 158                     Pop();
 159 #endif
 160
 161                     // seek to end of this comment
 162                     do
 163                     {
 164                         pAct = rPrtMtf.NextAction();
 165                     }
 166                     while( pAct &&
 167                            ( ( pAct->GetType() != META_COMMENT_ACTION ) ||
 168                              ( ( (MetaCommentAction*) pAct )->GetComment().CompareIgnoreCaseToAscii( "PRNSPOOL_TRANSPARENTBITMAP_END" ) != COMPARE_EQUAL ) ) );
 169
 170                     bExecuted = sal_True;
 171                 }
 172             }
 173         }
 174         else if( nType == META_GRADIENT_ACTION )
 175         {
 176             MetaGradientAction* pGradientAction = (MetaGradientAction*) pAct;
 177             DrawGradientEx( this, pGradientAction->GetRect(), pGradientAction->GetGradient() );
 178             bExecuted = sal_True;
 179         }
 180         else if( nType == META_BMPSCALE_ACTION )
 181         {
 182             MetaBmpScaleAction* pBmpScaleAction = (MetaBmpScaleAction*) pAct;
 183             const Bitmap&       rBmp = pBmpScaleAction->GetBitmap();
 184
 185             DrawBitmap( pBmpScaleAction->GetPoint(), pBmpScaleAction->GetSize(),
 186                         GetDownsampledBitmap( pBmpScaleAction->GetSize(),
 187                                               Point(), rBmp.GetSizePixel(),
 188                                               rBmp, nMaxBmpDPIX, nMaxBmpDPIY ) );
 189
 190             bExecuted = sal_True;
 191         }
 192         else if( nType == META_BMPSCALEPART_ACTION )
 193         {
 194             MetaBmpScalePartAction* pBmpScalePartAction = (MetaBmpScalePartAction*) pAct;
 195             const Bitmap&           rBmp = pBmpScalePartAction->GetBitmap();
 196
 197             DrawBitmap( pBmpScalePartAction->GetDestPoint(), pBmpScalePartAction->GetDestSize(),
 198                         GetDownsampledBitmap( pBmpScalePartAction->GetDestSize(),
 199                                               pBmpScalePartAction->GetSrcPoint(), pBmpScalePartAction->GetSrcSize(),
 200                                               rBmp, nMaxBmpDPIX, nMaxBmpDPIY ) );
 201
 202             bExecuted = sal_True;
 203         }
 204         else if( nType == META_BMPEXSCALE_ACTION )
 205         {
 206             MetaBmpExScaleAction*   pBmpExScaleAction = (MetaBmpExScaleAction*) pAct;
 207             const BitmapEx&         rBmpEx = pBmpExScaleAction->GetBitmapEx();
 208
 209             DrawBitmapEx( pBmpExScaleAction->GetPoint(), pBmpExScaleAction->GetSize(),
 210                           GetDownsampledBitmapEx( pBmpExScaleAction->GetSize(),
 211                                                   Point(), rBmpEx.GetSizePixel(),
 212                                                   rBmpEx, nMaxBmpDPIX, nMaxBmpDPIY ) );
 213
 214             bExecuted = sal_True;
 215         }
 216         else if( nType == META_BMPEXSCALEPART_ACTION )
 217         {
 218             MetaBmpExScalePartAction*   pBmpExScalePartAction = (MetaBmpExScalePartAction*) pAct;
 219             const BitmapEx&             rBmpEx = pBmpExScalePartAction->GetBitmapEx();
 220
 221             DrawBitmapEx( pBmpExScalePartAction->GetDestPoint(), pBmpExScalePartAction->GetDestSize(),
 222                           GetDownsampledBitmapEx( pBmpExScalePartAction->GetDestSize(),
 223                                                   pBmpExScalePartAction->GetSrcPoint(), pBmpExScalePartAction->GetSrcSize(),
 224                                                   rBmpEx, nMaxBmpDPIX, nMaxBmpDPIY ) );
 225
 226             bExecuted = sal_True;
 227         }
 228         else if( nType == META_TRANSPARENT_ACTION )
 229         {
 230             MetaTransparentAction*      pTransAct = static_cast<MetaTransparentAction*>(pAct);
 231             USHORT                                      nTransparency( pTransAct->GetTransparence() );
 232
 233             // #i10613# Respect transparency for draw color
 234             if( nTransparency )
 235             {
 236                 Push( PUSH_LINECOLOR|PUSH_FILLCOLOR );
 237
 238                 // assume white background for alpha blending
 239                 Color aLineColor( GetLineColor() );
 240                 aLineColor.SetRed( static_cast<UINT8>( (255L*nTransparency + (100L - nTransparency)*aLineColor.GetRed()) / 100L ) );
 241                 aLineColor.SetGreen( static_cast<UINT8>( (255L*nTransparency + (100L - nTransparency)*aLineColor.GetGreen()) / 100L ) );
 242                 aLineColor.SetBlue( static_cast<UINT8>( (255L*nTransparency + (100L - nTransparency)*aLineColor.GetBlue()) / 100L ) );
 243                 SetLineColor( aLineColor );
 244
 245                 Color aFillColor( GetFillColor() );
 246                 aFillColor.SetRed( static_cast<UINT8>( (255L*nTransparency + (100L - nTransparency)*aFillColor.GetRed()) / 100L ) );
 247                 aFillColor.SetGreen( static_cast<UINT8>( (255L*nTransparency + (100L - nTransparency)*aFillColor.GetGreen()) / 100L ) );
 248                 aFillColor.SetBlue( static_cast<UINT8>( (255L*nTransparency + (100L - nTransparency)*aFillColor.GetBlue()) / 100L ) );
 249                 SetFillColor( aFillColor );
 250             }
 251
 252             DrawPolyPolygon( pTransAct->GetPolyPolygon() );
 253
 254             if( nTransparency )
 255                 Pop();
 256
 257             bExecuted = sal_True;
 258         }
 259         else if( nType == META_FLOATTRANSPARENT_ACTION )
 260         {
 261             MetaFloatTransparentAction* pFloatAction = (MetaFloatTransparentAction*) pAct;
 262             GDIMetaFile&                                rMtf = (GDIMetaFile&) pFloatAction->GetGDIMetaFile();
 263             MapMode                                             aDrawMap( rMtf.GetPrefMapMode() );
 264             Point                                               aDestPoint( LogicToPixel( pFloatAction->GetPoint() ) );
 265             Size                                                aDestSize( LogicToPixel( pFloatAction->GetSize() ) );
 266
 267             if( aDestSize.Width() && aDestSize.Height() )
 268             {
 269                 Size aTmpPrefSize( LogicToPixel( rMtf.GetPrefSize(), aDrawMap ) );
 270
 271                 if( !aTmpPrefSize.Width() )
 272                     aTmpPrefSize.Width() = aDestSize.Width();
 273
 274                 if( !aTmpPrefSize.Height() )
 275                     aTmpPrefSize.Height() = aDestSize.Height();
 276
 277                 Fraction aScaleX( aDestSize.Width(), aTmpPrefSize.Width() );
 278                 Fraction aScaleY( aDestSize.Height(), aTmpPrefSize.Height() );
 279
 280                 aDrawMap.SetScaleX( aScaleX *= aDrawMap.GetScaleX() );
 281                 aDrawMap.SetScaleY( aScaleY *= aDrawMap.GetScaleY() );
 282                 aDrawMap.SetOrigin( PixelToLogic( aDestPoint, aDrawMap ) );
 283
 284                 Push();
 285                 SetMapMode( aDrawMap );
 286                 ImplPrintMtf( rMtf, nMaxBmpDPIX, nMaxBmpDPIY );
 287                 Pop();
 288             }
 289
 290             bExecuted = sal_True;
 291         }
 292
 293         if( !bExecuted && pAct )
 294             pAct->Execute( this );
 295
 296         if( ! ImplGetSVData()->maGDIData.mbPrinterPullModel )
 297             Application::Reschedule();
 298     }
 299 }
 300
 301 // -----------------------------------------------------------------------
 302
 303 void ImplQPrinter::PrePrintPage( QueuePage* pPage )
 304 {
 305     mnRestoreDrawMode = GetDrawMode();
 306     mnMaxBmpDPIX = mnDPIX;
 307     mnMaxBmpDPIY = mnDPIY;
 308
 309     const PrinterOptions&   rPrinterOptions = GetPrinterOptions();
 310
 311     if( rPrinterOptions.IsReduceBitmaps() )
 312     {
 313         // calculate maximum resolution for bitmap graphics
 314         if( PRINTER_BITMAP_OPTIMAL == rPrinterOptions.GetReducedBitmapMode() )
 315         {
 316             mnMaxBmpDPIX = Min( (long) OPTIMAL_BMP_RESOLUTION, mnMaxBmpDPIX );
 317             mnMaxBmpDPIY = Min( (long) OPTIMAL_BMP_RESOLUTION, mnMaxBmpDPIY );
 318         }
 319         else if( PRINTER_BITMAP_NORMAL == rPrinterOptions.GetReducedBitmapMode() )
 320         {
 321             mnMaxBmpDPIX = Min( (long) NORMAL_BMP_RESOLUTION, mnMaxBmpDPIX );
 322             mnMaxBmpDPIY = Min( (long) NORMAL_BMP_RESOLUTION, mnMaxBmpDPIY );
 323         }
 324         else
 325         {
 326             mnMaxBmpDPIX = Min( (long) rPrinterOptions.GetReducedBitmapResolution(), mnMaxBmpDPIX );
 327             mnMaxBmpDPIY = Min( (long) rPrinterOptions.GetReducedBitmapResolution(), mnMaxBmpDPIY );
 328         }
 329     }
 330
 331     // convert to greysacles
 332     if( rPrinterOptions.IsConvertToGreyscales() )
 333     {
 334         SetDrawMode( GetDrawMode() | ( DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL | DRAWMODE_GRAYTEXT |
 335                                        DRAWMODE_GRAYBITMAP | DRAWMODE_GRAYGRADIENT ) );
 336     }
 337
 338     // disable transparency output
 339     if( rPrinterOptions.IsReduceTransparency() && ( PRINTER_TRANSPARENCY_NONE == rPrinterOptions.GetReducedTransparencyMode() ) )
 340     {
 341         SetDrawMode( GetDrawMode() | DRAWMODE_NOTRANSPARENCY );
 342     }
 343
 344     maCurPageMetaFile = GDIMetaFile();
 345     RemoveTransparenciesFromMetaFile( *pPage->mpMtf, maCurPageMetaFile, mnMaxBmpDPIX, mnMaxBmpDPIY,
 346                                      rPrinterOptions.IsReduceTransparency(),
 347                                      rPrinterOptions.GetReducedTransparencyMode() == PRINTER_TRANSPARENCY_AUTO,
 348                                      rPrinterOptions.IsReduceBitmaps() && rPrinterOptions.IsReducedBitmapIncludesTransparency()
 349                                      );
 350 }
 351
 352 void ImplQPrinter::PostPrintPage()
 353 {
 354     SetDrawMode( mnRestoreDrawMode );
 355 }
 356
 357 // -----------------------------------------------------------------------
 358
 359 void ImplQPrinter::PrintPage( unsigned int nPage )
 360 {
 361     if( nPage >= maQueue.size() )
 362         return;
 363     mnCurCopyCount = (mbUserCopy && !mbCollateCopy) ? mnCopyCount : 1;
 364     QueuePage* pActPage = maQueue[nPage];
 365     PrePrintPage( pActPage );
 366     if ( pActPage->mpSetup )
 367         SetJobSetup( *pActPage->mpSetup );
 368
 369     StartPage();
 370     ImplPrintMtf( maCurPageMetaFile, mnMaxBmpDPIX, mnMaxBmpDPIY );
 371     EndPage();
 372
 373     mnCurCopyCount--;
 374     if( mnCurCopyCount == 0 )
 375         PostPrintPage();
 376 }
 377
 378 // -----------------------------------------------------------------------
 379
 380 ImplJobSetup* ImplQPrinter::GetPageSetup( unsigned int nPage ) const
 381 {
 382     return nPage >= maQueue.size() ? NULL :
 383     ( maQueue[nPage]->mpSetup ? maQueue[nPage]->mpSetup->ImplGetData() : NULL );
 384 }
 385
 386 // -----------------------------------------------------------------------
 387 ULONG ImplQPrinter::GetPrintPageCount() const
 388 {
 389     ULONG nPageCount = maQueue.size() * ((mbUserCopy && !mbCollateCopy) ? mnCopyCount : 1);
 390     return nPageCount;
 391 }
 392
 393 // -----------------------------------------------------------------------
 394
 395 IMPL_LINK( ImplQPrinter, ImplPrintHdl, Timer*, EMPTYARG )
 396 {
 397     // Ist Drucken abgebrochen wurden?
 398     if( !IsPrinting() || ( mpParent->IsJobActive() && ( maQueue.size() < (ULONG)mpParent->GetPageQueueSize() ) ) )
 399         return 0;
 400
 401     // Druck-Job zuende?
 402     QueuePage* pActPage = maQueue.front();
 403     maQueue.erase( maQueue.begin() );
 404
 405
 406     vcl::DeletionListener aDel( this );
 407     if ( pActPage->mbEndJob )
 408     {
 409         maTimer.Stop();
 410         delete pActPage;
 411         if( ! EndJob() )
 412             mpParent->Error();
 413         if( ! aDel.isDeleted() )
 414             mpParent->ImplEndPrint();
 415     }
 416     else
 417     {
 418         mbDestroyAllowed = FALSE;
 419
 420         PrePrintPage( pActPage );
 421
 422         USHORT nCopyCount = 1;
 423         if( mbUserCopy && !mbCollateCopy )
 424             nCopyCount = mnCopyCount;
 425
 426         for ( USHORT i = 0; i < nCopyCount; i++ )
 427         {
 428             if ( pActPage->mpSetup )
 429             {
 430                 SetJobSetup( *pActPage->mpSetup );
 431                 if ( mbAborted )
 432                      break;
 433             }
 434
 435             StartPage();
 436
 437             if ( mbAborted )
 438                 break;
 439
 440             ImplPrintMtf( maCurPageMetaFile, mnMaxBmpDPIX, mnMaxBmpDPIY );
 441
 442             if( !mbAborted )
 443                 EndPage();
 444             else
 445                 break;
 446         }
 447
 448         PostPrintPage();
 449
 450         delete pActPage;
 451         mbDestroyAllowed = TRUE;
 452
 453         if( mbDestroyed )
 454             Destroy();
 455     }
 456
 457     return 0;
 458 }
 459
 460 // -----------------------------------------------------------------------
 461
 462 void ImplQPrinter::StartQueuePrint()
 463 {
 464     if( ! ImplGetSVData()->maGDIData.mbPrinterPullModel )
 465     {
 466         maTimer.SetTimeout( 50 );
 467         maTimer.SetTimeoutHdl( LINK( this, ImplQPrinter, ImplPrintHdl ) );
 468         maTimer.Start();
 469     }
 470 }
 471
 472 // -----------------------------------------------------------------------
 473
 474 void ImplQPrinter::EndQueuePrint()
 475 {
 476     if( ImplGetSVData()->maGDIData.mbPrinterPullModel )
 477     {
 478         DBG_ASSERT( mpPrinter, "no SalPrinter in ImplQPrinter" );
 479         if( mpPrinter )
 480         {
 481             mpPrinter->StartJob( mbPrintFile ? &maPrintFile : NULL,
 482                                  Application::GetDisplayName(),
 483                                  maJobSetup.ImplGetConstData(),
 484                                  this );
 485             EndJob();
 486             mpParent->ImplEndPrint();
 487         }
 488     }
 489     else
 490     {
 491         QueuePage* pQueuePage   = new QueuePage;
 492         pQueuePage->mbEndJob    = TRUE;
 493         maQueue.push_back( pQueuePage );
 494     }
 495 }
 496
 497 // -----------------------------------------------------------------------
 498
 499 bool ImplQPrinter::GetPaperRanges( std::vector< ULONG >& o_rRanges, bool i_bIncludeOrientationChanges ) const
 500 {
 501     bool bRet = false;
 502
 503     if( ImplGetSVData()->maGDIData.mbPrinterPullModel )
 504     {
 505         bRet = true;
 506         o_rRanges.clear();
 507
 508         if( ! maQueue.empty() )
 509         {
 510             ULONG nCurPage = 0;
 511
 512             // get first job data
 513             const ImplJobSetup* pLastFormat = NULL;
 514             if( maQueue.front()->mpSetup )
 515                 pLastFormat = maQueue.front()->mpSetup->ImplGetConstData();
 516
 517             // begin first range
 518             o_rRanges.push_back( 0 );
 519             for( std::vector< QueuePage* >::const_iterator it = maQueue.begin();
 520                 it != maQueue.end(); ++it, ++nCurPage )
 521             {
 522                 const ImplJobSetup* pNewSetup = (*it)->mpSetup ? (*it)->mpSetup->ImplGetConstData() : NULL;
 523                 if( pNewSetup && pNewSetup != pLastFormat )
 524                 {
 525                     bool bChange = false;
 526                     if( pLastFormat == NULL )
 527                     {
 528                         bChange = true;
 529                     }
 530                     else if( ! i_bIncludeOrientationChanges &&
 531                              pNewSetup->meOrientation != pLastFormat->meOrientation )
 532                     {
 533                         bChange = true;
 534                     }
 535                     else if( pNewSetup->mePaperFormat != pLastFormat->mePaperFormat ||
 536                         ( pNewSetup->mePaperFormat == PAPER_USER &&
 537                             ( pNewSetup->mnPaperWidth != pLastFormat->mnPaperWidth ||
 538                               pNewSetup->mnPaperHeight != pLastFormat->mnPaperHeight ) ) )
 539                     {
 540                         bChange = true;
 541                     }
 542                     else if( pNewSetup->mnPaperBin != pLastFormat->mnPaperBin )
 543                     {
 544                         bChange = true;
 545                     }
 546                     if( bChange )
 547                     {
 548                         o_rRanges.push_back( nCurPage );
 549                         pLastFormat = pNewSetup;
 550                     }
 551                 }
 552             }
 553
 554             o_rRanges.push_back( nCurPage );
 555         }
 556     }
 557
 558     return bRet;
 559 }
 560
 561 // -----------------------------------------------------------------------
 562
 563 void ImplQPrinter::AbortQueuePrint()
 564 {
 565     maTimer.Stop();
 566     mbAborted = TRUE;
 567     AbortJob();
 568 }
 569
 570 // -----------------------------------------------------------------------
 571
 572 void ImplQPrinter::AddQueuePage( GDIMetaFile* pPage, USHORT nPage, BOOL bNewJobSetup )
 573 {
 574     QueuePage* pQueuePage       = new QueuePage;
 575     pQueuePage->mpMtf           = pPage;
 576     pQueuePage->mnPage          = nPage;
 577     pQueuePage->mbEndJob        = FALSE;
 578     // ensure that the first page has a valid setup, this is needed
 579     // in GetPaperRanges (used in pullmodel)
 580     // caution: this depends on mnCurPage in Printer being
 581     // 0: not printing 1: after StartJob, 2 after first EndPage, 3+ at following EndPage calls
 582     if ( bNewJobSetup || (nPage == 2 && ImplGetSVData()->maGDIData.mbPrinterPullModel) )
 583         pQueuePage->mpSetup = new JobSetup( mpParent->GetJobSetup() );
 584     maQueue.push_back( pQueuePage );
 585 }