1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_vcl.hxx" 30 31 #define ENABLE_BYTESTRING_STREAM_OPERATORS 32 #include <list> 33 34 #include <tools/debug.hxx> 35 #include <tools/resary.hxx> 36 #include <tools/stream.hxx> 37 #include <tools/vcompat.hxx> 38 39 #include <vcl/unohelp.hxx> 40 #include <vcl/svapp.hxx> 41 #include <vcl/wrkwin.hxx> 42 #include <vcl/virdev.hxx> 43 #include <vcl/window.hxx> 44 #include <vcl/gdimtf.hxx> 45 #include <vcl/metaact.hxx> 46 #include <vcl/print.hxx> 47 48 #include <salinst.hxx> 49 #include <salgdi.hxx> 50 #include <salptype.hxx> 51 #include <salprn.hxx> 52 #include <svdata.hxx> 53 #include <svids.hrc> 54 #include <jobset.h> 55 #include <outdev.h> 56 #include <print.h> 57 58 #include <comphelper/processfactory.hxx> 59 60 #include "com/sun/star/beans/XPropertySet.hpp" 61 #include "com/sun/star/container/XNameAccess.hpp" 62 #include "com/sun/star/lang/XMultiServiceFactory.hpp" 63 64 using namespace com::sun::star::uno; 65 using namespace com::sun::star::lang; 66 using namespace com::sun::star::beans; 67 using namespace com::sun::star::container; 68 69 int nImplSysDialog = 0; 70 71 // ======================================================================= 72 73 namespace 74 { 75 static Paper ImplGetPaperFormat( long nWidth100thMM, long nHeight100thMM ) 76 { 77 PaperInfo aInfo(nWidth100thMM, nHeight100thMM); 78 aInfo.doSloppyFit(); 79 return aInfo.getPaper(); 80 } 81 82 // ----------------------------------------------------------------------- 83 84 static const PaperInfo& ImplGetEmptyPaper() 85 { 86 static PaperInfo aInfo(PAPER_USER); 87 return aInfo; 88 } 89 } 90 91 // ======================================================================= 92 93 void ImplUpdateJobSetupPaper( JobSetup& rJobSetup ) 94 { 95 const ImplJobSetup* pConstData = rJobSetup.ImplGetConstData(); 96 97 if ( !pConstData->mnPaperWidth || !pConstData->mnPaperHeight ) 98 { 99 if ( pConstData->mePaperFormat != PAPER_USER ) 100 { 101 ImplJobSetup* pData = rJobSetup.ImplGetData(); 102 PaperInfo aInfo(pConstData->mePaperFormat); 103 pData->mnPaperWidth = aInfo.getWidth(); 104 pData->mnPaperHeight = aInfo.getHeight(); 105 } 106 } 107 else if ( pConstData->mePaperFormat == PAPER_USER ) 108 { 109 Paper ePaper = ImplGetPaperFormat( pConstData->mnPaperWidth, pConstData->mnPaperHeight ); 110 if ( ePaper != PAPER_USER ) 111 rJobSetup.ImplGetData()->mePaperFormat = ePaper; 112 } 113 } 114 115 // ------------------ 116 // - PrinterOptions - 117 // ------------------ 118 119 PrinterOptions::PrinterOptions() : 120 mbReduceTransparency( sal_False ), 121 meReducedTransparencyMode( PRINTER_TRANSPARENCY_AUTO ), 122 mbReduceGradients( sal_False ), 123 meReducedGradientsMode( PRINTER_GRADIENT_STRIPES ), 124 mnReducedGradientStepCount( 64 ), 125 mbReduceBitmaps( sal_False ), 126 meReducedBitmapMode( PRINTER_BITMAP_NORMAL ), 127 mnReducedBitmapResolution( 200 ), 128 mbReducedBitmapsIncludeTransparency( sal_True ), 129 mbConvertToGreyscales( sal_False ) 130 { 131 } 132 133 // ----------------------------------------------------------------------- 134 135 PrinterOptions::~PrinterOptions() 136 { 137 } 138 139 #define PROPERTYNAME_REDUCETRANSPARENCY rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReduceTransparency")) 140 #define PROPERTYNAME_REDUCEDTRANSPARENCYMODE rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedTransparencyMode")) 141 #define PROPERTYNAME_REDUCEGRADIENTS rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReduceGradients")) 142 #define PROPERTYNAME_REDUCEDGRADIENTMODE rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedGradientMode")) 143 #define PROPERTYNAME_REDUCEDGRADIENTSTEPCOUNT rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedGradientStepCount")) 144 #define PROPERTYNAME_REDUCEBITMAPS rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReduceBitmaps")) 145 #define PROPERTYNAME_REDUCEDBITMAPMODE rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedBitmapMode")) 146 #define PROPERTYNAME_REDUCEDBITMAPRESOLUTION rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedBitmapResolution")) 147 #define PROPERTYNAME_REDUCEDBITMAPINCLUDESTRANSPARENCY rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ReducedBitmapIncludesTransparency")) 148 #define PROPERTYNAME_CONVERTTOGREYSCALES rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ConvertToGreyscales")) 149 150 bool PrinterOptions::ReadFromConfig( bool i_bFile ) 151 { 152 bool bSuccess = false; 153 // save old state in case something goes wrong 154 PrinterOptions aOldValues( *this ); 155 156 // get the configuration service 157 Reference< XMultiServiceFactory > xConfigProvider; 158 Reference< XNameAccess > xConfigAccess; 159 try 160 { 161 // get service provider 162 Reference< XMultiServiceFactory > xSMgr( comphelper::getProcessServiceFactory() ); 163 // create configuration hierachical access name 164 if( xSMgr.is() ) 165 { 166 try 167 { 168 xConfigProvider = Reference< XMultiServiceFactory >( 169 xSMgr->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 170 "com.sun.star.configuration.ConfigurationProvider" ))), 171 UNO_QUERY ); 172 if( xConfigProvider.is() ) 173 { 174 Sequence< Any > aArgs(1); 175 PropertyValue aVal; 176 aVal.Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "nodepath" ) ); 177 if( i_bFile ) 178 aVal.Value <<= rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Common/Print/Option/File" ) ); 179 else 180 aVal.Value <<= rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Common/Print/Option/Printer" ) ); 181 aArgs.getArray()[0] <<= aVal; 182 xConfigAccess = Reference< XNameAccess >( 183 xConfigProvider->createInstanceWithArguments( 184 rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.configuration.ConfigurationAccess" )), aArgs ), 185 UNO_QUERY ); 186 if( xConfigAccess.is() ) 187 { 188 Reference< XPropertySet > xSet( xConfigAccess, UNO_QUERY ); 189 if( xSet.is() ) 190 { 191 sal_Int32 nValue = 0; 192 sal_Bool bValue = 0; 193 if( xSet->getPropertyValue(PROPERTYNAME_REDUCETRANSPARENCY) >>= bValue ) 194 SetReduceTransparency( bValue ); 195 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDTRANSPARENCYMODE) >>= nValue ) 196 SetReducedTransparencyMode( (PrinterTransparencyMode)nValue ); 197 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEGRADIENTS) >>= bValue ) 198 SetReduceGradients( bValue ); 199 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDGRADIENTMODE) >>= nValue ) 200 SetReducedGradientMode( (PrinterGradientMode)nValue ); 201 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDGRADIENTSTEPCOUNT) >>= nValue ) 202 SetReducedGradientStepCount( (sal_uInt16)nValue ); 203 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEBITMAPS) >>= bValue ) 204 SetReduceBitmaps( bValue ); 205 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDBITMAPMODE) >>= nValue ) 206 SetReducedBitmapMode( (PrinterBitmapMode)nValue ); 207 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDBITMAPRESOLUTION) >>= nValue ) 208 SetReducedBitmapResolution( (sal_uInt16)nValue ); 209 if( xSet->getPropertyValue(PROPERTYNAME_REDUCEDBITMAPINCLUDESTRANSPARENCY) >>= bValue ) 210 SetReducedBitmapIncludesTransparency( bValue ); 211 if( xSet->getPropertyValue(PROPERTYNAME_CONVERTTOGREYSCALES) >>= bValue ) 212 SetConvertToGreyscales( bValue ); 213 214 bSuccess = true; 215 } 216 } 217 } 218 } 219 catch( Exception& ) 220 { 221 } 222 } 223 } 224 catch( WrappedTargetException& ) 225 { 226 } 227 228 if( ! bSuccess ) 229 *this = aOldValues; 230 return bSuccess; 231 } 232 233 void Printer::SetPrinterOptions( const PrinterOptions& i_rOptions ) 234 { 235 *mpPrinterOptions = i_rOptions; 236 } 237 238 // ------------- 239 // - QueueInfo - 240 // ------------- 241 242 QueueInfo::QueueInfo() 243 { 244 mnStatus = 0; 245 mnJobs = 0; 246 } 247 248 // ----------------------------------------------------------------------- 249 250 QueueInfo::QueueInfo( const QueueInfo& rInfo ) : 251 maPrinterName( rInfo.maPrinterName ), 252 maDriver( rInfo.maDriver ), 253 maLocation( rInfo.maLocation ), 254 maComment( rInfo.maComment ), 255 mnStatus( rInfo.mnStatus ), 256 mnJobs( rInfo.mnJobs ) 257 { 258 } 259 260 // ----------------------------------------------------------------------- 261 262 QueueInfo::~QueueInfo() 263 { 264 } 265 266 // ----------------------------------------------------------------------- 267 268 bool QueueInfo::operator==( const QueueInfo& rInfo ) const 269 { 270 return 271 maPrinterName == rInfo.maPrinterName && 272 maDriver == rInfo.maDriver && 273 maLocation == rInfo.maLocation && 274 maComment == rInfo.maComment && 275 mnStatus == rInfo.mnStatus && 276 mnJobs == rInfo.mnJobs; 277 } 278 279 // ----------------------------------------------------------------------- 280 281 SvStream& operator<<( SvStream& rOStream, const QueueInfo& rInfo ) 282 { 283 VersionCompat aCompat( rOStream, STREAM_WRITE, 1 ); 284 285 rOStream.WriteByteString( rInfo.maPrinterName, RTL_TEXTENCODING_UTF8 ); 286 rOStream.WriteByteString( rInfo.maDriver, RTL_TEXTENCODING_UTF8 ); 287 rOStream.WriteByteString( rInfo.maLocation, RTL_TEXTENCODING_UTF8 ); 288 rOStream.WriteByteString( rInfo.maComment, RTL_TEXTENCODING_UTF8 ); 289 rOStream << rInfo.mnStatus; 290 rOStream << rInfo.mnJobs; 291 292 return rOStream; 293 } 294 295 // ----------------------------------------------------------------------- 296 297 SvStream& operator>>( SvStream& rIStream, QueueInfo& rInfo ) 298 { 299 VersionCompat aCompat( rIStream, STREAM_READ ); 300 301 rIStream.ReadByteString( rInfo.maPrinterName, RTL_TEXTENCODING_UTF8 ); 302 rIStream.ReadByteString( rInfo.maDriver, RTL_TEXTENCODING_UTF8 ); 303 rIStream.ReadByteString( rInfo.maLocation, RTL_TEXTENCODING_UTF8 ); 304 rIStream.ReadByteString( rInfo.maComment, RTL_TEXTENCODING_UTF8 ); 305 rIStream >> rInfo.mnStatus; 306 rIStream >> rInfo.mnJobs; 307 308 return rIStream; 309 } 310 311 // ======================================================================= 312 313 SalPrinterQueueInfo::SalPrinterQueueInfo() 314 { 315 mnStatus = 0; 316 mnJobs = QUEUE_JOBS_DONTKNOW; 317 mpSysData = NULL; 318 } 319 320 // ----------------------------------------------------------------------- 321 322 SalPrinterQueueInfo::~SalPrinterQueueInfo() 323 { 324 } 325 326 // ----------------------------------------------------------------------- 327 328 ImplPrnQueueList::~ImplPrnQueueList() 329 { 330 ImplSVData* pSVData = ImplGetSVData(); 331 for( unsigned int i = 0; i < m_aQueueInfos.size(); i++ ) 332 { 333 delete m_aQueueInfos[i].mpQueueInfo; 334 pSVData->mpDefInst->DeletePrinterQueueInfo( m_aQueueInfos[i].mpSalQueueInfo ); 335 } 336 } 337 338 // ----------------------------------------------------------------------- 339 340 void ImplPrnQueueList::Add( SalPrinterQueueInfo* pData ) 341 { 342 std::hash_map< rtl::OUString, sal_Int32, rtl::OUStringHash >::iterator it = 343 m_aNameToIndex.find( pData->maPrinterName ); 344 if( it == m_aNameToIndex.end() ) 345 { 346 m_aNameToIndex[ pData->maPrinterName ] = m_aQueueInfos.size(); 347 m_aQueueInfos.push_back( ImplPrnQueueData() ); 348 m_aQueueInfos.back().mpQueueInfo = NULL; 349 m_aQueueInfos.back().mpSalQueueInfo = pData; 350 m_aPrinterList.push_back( pData->maPrinterName ); 351 } 352 else // this should not happen, but ... 353 { 354 ImplPrnQueueData& rData = m_aQueueInfos[ it->second ]; 355 delete rData.mpQueueInfo; 356 rData.mpQueueInfo = NULL; 357 ImplGetSVData()->mpDefInst->DeletePrinterQueueInfo( rData.mpSalQueueInfo ); 358 rData.mpSalQueueInfo = pData; 359 } 360 } 361 362 // ----------------------------------------------------------------------- 363 364 ImplPrnQueueData* ImplPrnQueueList::Get( const rtl::OUString& rPrinter ) 365 { 366 ImplPrnQueueData* pData = NULL; 367 std::hash_map<rtl::OUString,sal_Int32,rtl::OUStringHash>::iterator it = 368 m_aNameToIndex.find( rPrinter ); 369 if( it != m_aNameToIndex.end() ) 370 pData = &m_aQueueInfos[it->second]; 371 return pData; 372 } 373 374 // ======================================================================= 375 376 static void ImplInitPrnQueueList() 377 { 378 ImplSVData* pSVData = ImplGetSVData(); 379 380 pSVData->maGDIData.mpPrinterQueueList = new ImplPrnQueueList; 381 382 static const char* pEnv = getenv( "SAL_DISABLE_PRINTERLIST" ); 383 if( !pEnv || !*pEnv ) 384 pSVData->mpDefInst->GetPrinterQueueInfo( pSVData->maGDIData.mpPrinterQueueList ); 385 } 386 387 // ----------------------------------------------------------------------- 388 389 void ImplDeletePrnQueueList() 390 { 391 ImplSVData* pSVData = ImplGetSVData(); 392 ImplPrnQueueList* pPrnList = pSVData->maGDIData.mpPrinterQueueList; 393 394 if ( pPrnList ) 395 { 396 delete pPrnList; 397 pSVData->maGDIData.mpPrinterQueueList = NULL; 398 } 399 } 400 401 // ----------------------------------------------------------------------- 402 403 const std::vector<rtl::OUString>& Printer::GetPrinterQueues() 404 { 405 ImplSVData* pSVData = ImplGetSVData(); 406 if ( !pSVData->maGDIData.mpPrinterQueueList ) 407 ImplInitPrnQueueList(); 408 return pSVData->maGDIData.mpPrinterQueueList->m_aPrinterList; 409 } 410 411 // ----------------------------------------------------------------------- 412 const QueueInfo* Printer::GetQueueInfo( const String& rPrinterName, bool bStatusUpdate ) 413 { 414 ImplSVData* pSVData = ImplGetSVData(); 415 416 if ( !pSVData->maGDIData.mpPrinterQueueList ) 417 ImplInitPrnQueueList(); 418 419 ImplPrnQueueData* pInfo = pSVData->maGDIData.mpPrinterQueueList->Get( rPrinterName ); 420 if( pInfo ) 421 { 422 if( !pInfo->mpQueueInfo || bStatusUpdate ) 423 pSVData->mpDefInst->GetPrinterQueueState( pInfo->mpSalQueueInfo ); 424 425 if ( !pInfo->mpQueueInfo ) 426 pInfo->mpQueueInfo = new QueueInfo; 427 428 pInfo->mpQueueInfo->maPrinterName = pInfo->mpSalQueueInfo->maPrinterName; 429 pInfo->mpQueueInfo->maDriver = pInfo->mpSalQueueInfo->maDriver; 430 pInfo->mpQueueInfo->maLocation = pInfo->mpSalQueueInfo->maLocation; 431 pInfo->mpQueueInfo->maComment = pInfo->mpSalQueueInfo->maComment; 432 pInfo->mpQueueInfo->mnStatus = pInfo->mpSalQueueInfo->mnStatus; 433 pInfo->mpQueueInfo->mnJobs = pInfo->mpSalQueueInfo->mnJobs; 434 return pInfo->mpQueueInfo; 435 } 436 return NULL; 437 } 438 439 // ----------------------------------------------------------------------- 440 441 XubString Printer::GetDefaultPrinterName() 442 { 443 static const char* pEnv = getenv( "SAL_DISABLE_DEFAULTPRINTER" ); 444 if( !pEnv || !*pEnv ) 445 { 446 ImplSVData* pSVData = ImplGetSVData(); 447 448 return pSVData->mpDefInst->GetDefaultPrinter(); 449 } 450 return XubString(); 451 } 452 453 // ======================================================================= 454 455 void Printer::ImplInitData() 456 { 457 mbDevOutput = sal_False; 458 meOutDevType = OUTDEV_PRINTER; 459 mbDefPrinter = sal_False; 460 mnError = 0; 461 mnCurPage = 0; 462 mnCurPrintPage = 0; 463 mnPageQueueSize = 0; 464 mnCopyCount = 1; 465 mbCollateCopy = sal_False; 466 mbPrinting = sal_False; 467 mbJobActive = sal_False; 468 mbPrintFile = sal_False; 469 mbInPrintPage = sal_False; 470 mbNewJobSetup = sal_False; 471 mpInfoPrinter = NULL; 472 mpPrinter = NULL; 473 mpDisplayDev = NULL; 474 mbIsQueuePrinter = sal_False; 475 mpPrinterOptions = new PrinterOptions; 476 477 // Printer in die Liste eintragen 478 ImplSVData* pSVData = ImplGetSVData(); 479 mpNext = pSVData->maGDIData.mpFirstPrinter; 480 mpPrev = NULL; 481 if ( mpNext ) 482 mpNext->mpPrev = this; 483 else 484 pSVData->maGDIData.mpLastPrinter = this; 485 pSVData->maGDIData.mpFirstPrinter = this; 486 } 487 488 // ----------------------------------------------------------------------- 489 490 void Printer::ImplInit( SalPrinterQueueInfo* pInfo ) 491 { 492 ImplSVData* pSVData = ImplGetSVData(); 493 // #i74084# update info for this specific SalPrinterQueueInfo 494 pSVData->mpDefInst->GetPrinterQueueState( pInfo ); 495 496 // Testen, ob Treiber ueberhaupt mit dem JobSetup uebereinstimmt 497 ImplJobSetup* pJobSetup = maJobSetup.ImplGetData(); 498 499 if ( pJobSetup->mpDriverData ) 500 { 501 if ( (pJobSetup->maPrinterName != pInfo->maPrinterName) || 502 (pJobSetup->maDriver != pInfo->maDriver) ) 503 { 504 rtl_freeMemory( pJobSetup->mpDriverData ); 505 pJobSetup->mpDriverData = NULL; 506 pJobSetup->mnDriverDataLen = 0; 507 } 508 } 509 510 // Printernamen merken 511 maPrinterName = pInfo->maPrinterName; 512 maDriver = pInfo->maDriver; 513 514 // In JobSetup den Printernamen eintragen 515 pJobSetup->maPrinterName = maPrinterName; 516 pJobSetup->maDriver = maDriver; 517 518 mpInfoPrinter = pSVData->mpDefInst->CreateInfoPrinter( pInfo, pJobSetup ); 519 mpPrinter = NULL; 520 mpJobGraphics = NULL; 521 ImplUpdateJobSetupPaper( maJobSetup ); 522 523 if ( !mpInfoPrinter ) 524 { 525 ImplInitDisplay( NULL ); 526 return; 527 } 528 529 // we need a graphics 530 if ( !ImplGetGraphics() ) 531 { 532 ImplInitDisplay( NULL ); 533 return; 534 } 535 536 // Daten initialisieren 537 ImplUpdatePageData(); 538 mpFontList = new ImplDevFontList(); 539 mpFontCache = new ImplFontCache( sal_True ); 540 mpGraphics->GetDevFontList( mpFontList ); 541 } 542 543 // ----------------------------------------------------------------------- 544 545 void Printer::ImplInitDisplay( const Window* pWindow ) 546 { 547 ImplSVData* pSVData = ImplGetSVData(); 548 549 mpInfoPrinter = NULL; 550 mpPrinter = NULL; 551 mpJobGraphics = NULL; 552 553 if ( pWindow ) 554 mpDisplayDev = new VirtualDevice( *pWindow ); 555 else 556 mpDisplayDev = new VirtualDevice(); 557 mpFontList = pSVData->maGDIData.mpScreenFontList; 558 mpFontCache = pSVData->maGDIData.mpScreenFontCache; 559 mnDPIX = mpDisplayDev->mnDPIX; 560 mnDPIY = mpDisplayDev->mnDPIY; 561 } 562 563 // ----------------------------------------------------------------------- 564 565 SalPrinterQueueInfo* Printer::ImplGetQueueInfo( const XubString& rPrinterName, 566 const XubString* pDriver ) 567 { 568 ImplSVData* pSVData = ImplGetSVData(); 569 if ( !pSVData->maGDIData.mpPrinterQueueList ) 570 ImplInitPrnQueueList(); 571 572 ImplPrnQueueList* pPrnList = pSVData->maGDIData.mpPrinterQueueList; 573 if ( pPrnList && pPrnList->m_aQueueInfos.size() ) 574 { 575 // first search for the printer name driectly 576 ImplPrnQueueData* pInfo = pPrnList->Get( rPrinterName ); 577 if( pInfo ) 578 return pInfo->mpSalQueueInfo; 579 580 // then search case insensitive 581 for( unsigned int i = 0; i < pPrnList->m_aQueueInfos.size(); i++ ) 582 { 583 if( pPrnList->m_aQueueInfos[i].mpSalQueueInfo->maPrinterName.EqualsIgnoreCaseAscii( rPrinterName ) ) 584 return pPrnList->m_aQueueInfos[i].mpSalQueueInfo; 585 } 586 587 // then search for driver name 588 if ( pDriver ) 589 { 590 for( unsigned int i = 0; i < pPrnList->m_aQueueInfos.size(); i++ ) 591 { 592 if( pPrnList->m_aQueueInfos[i].mpSalQueueInfo->maDriver == *pDriver ) 593 return pPrnList->m_aQueueInfos[i].mpSalQueueInfo; 594 } 595 } 596 597 // then the default printer 598 pInfo = pPrnList->Get( GetDefaultPrinterName() ); 599 if( pInfo ) 600 return pInfo->mpSalQueueInfo; 601 602 // last chance: the first available printer 603 return pPrnList->m_aQueueInfos[0].mpSalQueueInfo; 604 } 605 606 return NULL; 607 } 608 609 // ----------------------------------------------------------------------- 610 611 void Printer::ImplUpdatePageData() 612 { 613 // we need a graphics 614 if ( !ImplGetGraphics() ) 615 return; 616 617 mpGraphics->GetResolution( mnDPIX, mnDPIY ); 618 mpInfoPrinter->GetPageInfo( maJobSetup.ImplGetConstData(), 619 mnOutWidth, mnOutHeight, 620 maPageOffset.X(), maPageOffset.Y(), 621 maPaperSize.Width(), maPaperSize.Height() ); 622 static const char* pDebugOffset = getenv( "SAL_DBG_PAGEOFFSET" ); 623 if( pDebugOffset ) 624 { 625 rtl::OString aLine( pDebugOffset ); 626 sal_Int32 nIndex = 0; 627 rtl::OString aToken( aLine.getToken( 0, ',', nIndex ) ); 628 sal_Int32 nLeft = aToken.toInt32(); 629 sal_Int32 nTop = nLeft; 630 if( nIndex > 0 ) 631 { 632 aToken = aLine.getToken( 0, ',', nIndex ); 633 nTop = aToken.toInt32(); 634 } 635 maPageOffset = LogicToPixel( Point( static_cast<long>(nLeft), 636 static_cast<long>(nTop) ), 637 MapMode( MAP_100TH_MM ) 638 ); 639 mnOutWidth = maPaperSize.Width() - 2*maPageOffset.X(); 640 mnOutWidth = maPaperSize.Width() - 2*maPageOffset.Y(); 641 } 642 } 643 644 // ----------------------------------------------------------------------- 645 646 void Printer::ImplUpdateFontList() 647 { 648 ImplUpdateFontData( sal_True ); 649 } 650 651 // ----------------------------------------------------------------------- 652 653 Printer::Printer() 654 { 655 ImplInitData(); 656 SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( GetDefaultPrinterName(), NULL ); 657 if ( pInfo ) 658 { 659 ImplInit( pInfo ); 660 if ( !IsDisplayPrinter() ) 661 mbDefPrinter = sal_True; 662 } 663 else 664 ImplInitDisplay( NULL ); 665 } 666 667 // ----------------------------------------------------------------------- 668 669 Printer::Printer( const Window* pWindow ) 670 { 671 ImplInitData(); 672 ImplInitDisplay( pWindow ); 673 } 674 675 // ----------------------------------------------------------------------- 676 677 Printer::Printer( const JobSetup& rJobSetup ) : 678 maJobSetup( rJobSetup ) 679 { 680 ImplInitData(); 681 SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rJobSetup.mpData->maPrinterName, 682 &rJobSetup.mpData->maDriver ); 683 if ( pInfo ) 684 { 685 ImplInit( pInfo ); 686 SetJobSetup( rJobSetup ); 687 } 688 else 689 { 690 ImplInitDisplay( NULL ); 691 maJobSetup = JobSetup(); 692 } 693 } 694 695 // ----------------------------------------------------------------------- 696 697 Printer::Printer( const QueueInfo& rQueueInfo ) 698 { 699 ImplInitData(); 700 SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rQueueInfo.GetPrinterName(), 701 &rQueueInfo.GetDriver() ); 702 if ( pInfo ) 703 ImplInit( pInfo ); 704 else 705 ImplInitDisplay( NULL ); 706 } 707 708 // ----------------------------------------------------------------------- 709 710 Printer::Printer( const XubString& rPrinterName ) 711 { 712 ImplInitData(); 713 SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( rPrinterName, NULL ); 714 if ( pInfo ) 715 ImplInit( pInfo ); 716 else 717 ImplInitDisplay( NULL ); 718 } 719 720 // ----------------------------------------------------------------------- 721 722 Printer::~Printer() 723 { 724 DBG_ASSERT( !IsPrinting(), "Printer::~Printer() - Job is printing" ); 725 DBG_ASSERT( !IsJobActive(), "Printer::~Printer() - Job is active" ); 726 727 delete mpPrinterOptions; 728 729 ImplReleaseGraphics(); 730 if ( mpInfoPrinter ) 731 ImplGetSVData()->mpDefInst->DestroyInfoPrinter( mpInfoPrinter ); 732 if ( mpDisplayDev ) 733 delete mpDisplayDev; 734 else 735 { 736 // OutputDevice-Dtor versucht das gleiche, deshalb muss hier 737 // der FontEntry auch auf NULL gesetzt werden 738 // TODO: consolidate duplicate cleanup by Printer and OutputDevice 739 if ( mpFontEntry ) 740 { 741 mpFontCache->Release( mpFontEntry ); 742 mpFontEntry = NULL; 743 } 744 if ( mpGetDevFontList ) 745 { 746 delete mpGetDevFontList; 747 mpGetDevFontList = NULL; 748 } 749 if ( mpGetDevSizeList ) 750 { 751 delete mpGetDevSizeList; 752 mpGetDevSizeList = NULL; 753 } 754 delete mpFontCache; 755 mpFontCache = NULL; 756 // font list deleted by OutputDevice dtor 757 } 758 759 // Printer aus der Liste eintragen 760 ImplSVData* pSVData = ImplGetSVData(); 761 if ( mpPrev ) 762 mpPrev->mpNext = mpNext; 763 else 764 pSVData->maGDIData.mpFirstPrinter = mpNext; 765 if ( mpNext ) 766 mpNext->mpPrev = mpPrev; 767 else 768 pSVData->maGDIData.mpLastPrinter = mpPrev; 769 } 770 771 // ----------------------------------------------------------------------- 772 void Printer::Compat_OldPrinterMetrics( bool bSet ) 773 { 774 // propagate flag 775 if( mpInfoPrinter ) 776 mpInfoPrinter->m_bCompatMetrics = bSet; 777 778 // get new font data 779 ImplUpdateFontData( sal_True ); 780 } 781 782 // ----------------------------------------------------------------------- 783 784 sal_uLong Printer::GetCapabilities( sal_uInt16 nType ) const 785 { 786 if ( IsDisplayPrinter() ) 787 return sal_False; 788 789 if( mpInfoPrinter ) 790 return mpInfoPrinter->GetCapabilities( maJobSetup.ImplGetConstData(), nType ); 791 else 792 return sal_False; 793 } 794 795 // ----------------------------------------------------------------------- 796 797 sal_Bool Printer::HasSupport( PrinterSupport eFeature ) const 798 { 799 switch ( eFeature ) 800 { 801 case SUPPORT_SET_ORIENTATION: 802 return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETORIENTATION ); 803 case SUPPORT_SET_PAPERBIN: 804 return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETPAPERBIN ); 805 case SUPPORT_SET_PAPERSIZE: 806 return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETPAPERSIZE ); 807 case SUPPORT_SET_PAPER: 808 return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SETPAPER ); 809 case SUPPORT_COPY: 810 return (GetCapabilities( PRINTER_CAPABILITIES_COPIES ) != 0); 811 case SUPPORT_COLLATECOPY: 812 return (GetCapabilities( PRINTER_CAPABILITIES_COLLATECOPIES ) != 0); 813 case SUPPORT_SETUPDIALOG: 814 return (sal_Bool)GetCapabilities( PRINTER_CAPABILITIES_SUPPORTDIALOG ); 815 case SUPPORT_FAX: 816 return (sal_Bool) GetCapabilities( PRINTER_CAPABILITIES_FAX ); 817 case SUPPORT_PDF: 818 return (sal_Bool) GetCapabilities( PRINTER_CAPABILITIES_PDF ); 819 } 820 821 return sal_True; 822 } 823 824 // ----------------------------------------------------------------------- 825 826 sal_Bool Printer::SetJobSetup( const JobSetup& rSetup ) 827 { 828 if ( IsDisplayPrinter() || mbInPrintPage ) 829 return sal_False; 830 831 JobSetup aJobSetup = rSetup; 832 833 ImplReleaseGraphics(); 834 if ( mpInfoPrinter->SetPrinterData( aJobSetup.ImplGetData() ) ) 835 { 836 ImplUpdateJobSetupPaper( aJobSetup ); 837 mbNewJobSetup = sal_True; 838 maJobSetup = aJobSetup; 839 ImplUpdatePageData(); 840 ImplUpdateFontList(); 841 return sal_True; 842 } 843 844 return sal_False; 845 } 846 847 // ----------------------------------------------------------------------- 848 849 850 sal_Bool Printer::Setup( Window* pWindow ) 851 { 852 if ( IsDisplayPrinter() ) 853 return sal_False; 854 855 if ( IsJobActive() || IsPrinting() ) 856 return sal_False; 857 858 JobSetup aJobSetup = maJobSetup; 859 SalFrame* pFrame; 860 if ( !pWindow ) 861 pWindow = ImplGetDefaultWindow(); 862 if( !pWindow ) 863 return sal_False; 864 865 pFrame = pWindow->ImplGetFrame(); 866 ImplReleaseGraphics(); 867 ImplSVData* pSVData = ImplGetSVData(); 868 pSVData->maAppData.mnModalMode++; 869 nImplSysDialog++; 870 sal_Bool bSetup = mpInfoPrinter->Setup( pFrame, aJobSetup.ImplGetData() ); 871 pSVData->maAppData.mnModalMode--; 872 nImplSysDialog--; 873 if ( bSetup ) 874 { 875 ImplUpdateJobSetupPaper( aJobSetup ); 876 mbNewJobSetup = sal_True; 877 maJobSetup = aJobSetup; 878 ImplUpdatePageData(); 879 ImplUpdateFontList(); 880 return sal_True; 881 } 882 return sal_False; 883 } 884 885 // ----------------------------------------------------------------------- 886 887 sal_Bool Printer::SetPrinterProps( const Printer* pPrinter ) 888 { 889 if ( IsJobActive() || IsPrinting() ) 890 return sal_False; 891 892 ImplSVData* pSVData = ImplGetSVData(); 893 894 mbDefPrinter = pPrinter->mbDefPrinter; 895 maPrintFile = pPrinter->maPrintFile; 896 mbPrintFile = pPrinter->mbPrintFile; 897 mnCopyCount = pPrinter->mnCopyCount; 898 mbCollateCopy = pPrinter->mbCollateCopy; 899 mnPageQueueSize = pPrinter->mnPageQueueSize; 900 *mpPrinterOptions = *pPrinter->mpPrinterOptions; 901 902 if ( pPrinter->IsDisplayPrinter() ) 903 { 904 // Alten Printer zerstoeren 905 if ( !IsDisplayPrinter() ) 906 { 907 ImplReleaseGraphics(); 908 pSVData->mpDefInst->DestroyInfoPrinter( mpInfoPrinter ); 909 if ( mpFontEntry ) 910 { 911 mpFontCache->Release( mpFontEntry ); 912 mpFontEntry = NULL; 913 } 914 if ( mpGetDevFontList ) 915 { 916 delete mpGetDevFontList; 917 mpGetDevFontList = NULL; 918 } 919 if ( mpGetDevSizeList ) 920 { 921 delete mpGetDevSizeList; 922 mpGetDevSizeList = NULL; 923 } 924 // clean up font list 925 delete mpFontCache; 926 delete mpFontList; 927 mpFontCache = NULL; 928 mpFontList = NULL; 929 930 mbInitFont = sal_True; 931 mbNewFont = sal_True; 932 mpInfoPrinter = NULL; 933 } 934 935 // Neuen Printer bauen 936 ImplInitDisplay( NULL ); 937 return sal_True; 938 } 939 940 // Alten Printer zerstoeren? 941 if ( GetName() != pPrinter->GetName() ) 942 { 943 ImplReleaseGraphics(); 944 if ( mpDisplayDev ) 945 { 946 delete mpDisplayDev; 947 mpDisplayDev = NULL; 948 } 949 else 950 { 951 pSVData->mpDefInst->DestroyInfoPrinter( mpInfoPrinter ); 952 953 if ( mpFontEntry ) 954 { 955 mpFontCache->Release( mpFontEntry ); 956 mpFontEntry = NULL; 957 } 958 if ( mpGetDevFontList ) 959 { 960 delete mpGetDevFontList; 961 mpGetDevFontList = NULL; 962 } 963 if ( mpGetDevSizeList ) 964 { 965 delete mpGetDevSizeList; 966 mpGetDevSizeList = NULL; 967 } 968 delete mpFontCache; 969 delete mpFontList; 970 mpFontCache = NULL; 971 mpFontList = NULL; 972 mbInitFont = sal_True; 973 mbNewFont = sal_True; 974 mpInfoPrinter = NULL; 975 } 976 977 // Neuen Printer bauen 978 XubString aDriver = pPrinter->GetDriverName(); 979 SalPrinterQueueInfo* pInfo = ImplGetQueueInfo( pPrinter->GetName(), &aDriver ); 980 if ( pInfo ) 981 { 982 ImplInit( pInfo ); 983 SetJobSetup( pPrinter->GetJobSetup() ); 984 } 985 else 986 ImplInitDisplay( NULL ); 987 } 988 else 989 SetJobSetup( pPrinter->GetJobSetup() ); 990 991 return sal_False; 992 } 993 994 // ----------------------------------------------------------------------- 995 996 sal_Bool Printer::SetOrientation( Orientation eOrientation ) 997 { 998 if ( mbInPrintPage ) 999 return sal_False; 1000 1001 if ( maJobSetup.ImplGetConstData()->meOrientation != eOrientation ) 1002 { 1003 JobSetup aJobSetup = maJobSetup; 1004 ImplJobSetup* pSetupData = aJobSetup.ImplGetData(); 1005 pSetupData->meOrientation = eOrientation; 1006 1007 if ( IsDisplayPrinter() ) 1008 { 1009 mbNewJobSetup = sal_True; 1010 maJobSetup = aJobSetup; 1011 return sal_True; 1012 } 1013 1014 ImplReleaseGraphics(); 1015 if ( mpInfoPrinter->SetData( SAL_JOBSET_ORIENTATION, pSetupData ) ) 1016 { 1017 ImplUpdateJobSetupPaper( aJobSetup ); 1018 mbNewJobSetup = sal_True; 1019 maJobSetup = aJobSetup; 1020 ImplUpdatePageData(); 1021 ImplUpdateFontList(); 1022 return sal_True; 1023 } 1024 else 1025 return sal_False; 1026 } 1027 1028 return sal_True; 1029 } 1030 1031 // ----------------------------------------------------------------------- 1032 1033 Orientation Printer::GetOrientation() const 1034 { 1035 return maJobSetup.ImplGetConstData()->meOrientation; 1036 } 1037 1038 // ----------------------------------------------------------------------- 1039 1040 sal_Bool Printer::SetPaperBin( sal_uInt16 nPaperBin ) 1041 { 1042 if ( mbInPrintPage ) 1043 return sal_False; 1044 1045 if ( (maJobSetup.ImplGetConstData()->mnPaperBin != nPaperBin) && 1046 (nPaperBin < GetPaperBinCount()) ) 1047 { 1048 JobSetup aJobSetup = maJobSetup; 1049 ImplJobSetup* pSetupData = aJobSetup.ImplGetData(); 1050 pSetupData->mnPaperBin = nPaperBin; 1051 1052 if ( IsDisplayPrinter() ) 1053 { 1054 mbNewJobSetup = sal_True; 1055 maJobSetup = aJobSetup; 1056 return sal_True; 1057 } 1058 1059 ImplReleaseGraphics(); 1060 if ( mpInfoPrinter->SetData( SAL_JOBSET_PAPERBIN, pSetupData ) ) 1061 { 1062 ImplUpdateJobSetupPaper( aJobSetup ); 1063 mbNewJobSetup = sal_True; 1064 maJobSetup = aJobSetup; 1065 ImplUpdatePageData(); 1066 ImplUpdateFontList(); 1067 return sal_True; 1068 } 1069 else 1070 return sal_False; 1071 } 1072 1073 return sal_True; 1074 } 1075 1076 // ----------------------------------------------------------------------- 1077 1078 sal_uInt16 Printer::GetPaperBin() const 1079 { 1080 return maJobSetup.ImplGetConstData()->mnPaperBin; 1081 } 1082 1083 // ----------------------------------------------------------------------- 1084 1085 // Map user paper format to a available printer paper formats 1086 void Printer::ImplFindPaperFormatForUserSize( JobSetup& aJobSetup, bool bMatchNearest ) 1087 { 1088 ImplJobSetup* pSetupData = aJobSetup.ImplGetData(); 1089 1090 int nLandscapeAngle = GetLandscapeAngle(); 1091 int nPaperCount = GetPaperInfoCount(); 1092 bool bFound = false; 1093 1094 PaperInfo aInfo(pSetupData->mnPaperWidth, pSetupData->mnPaperHeight); 1095 1096 // Alle Papierformate vergleichen und ein passendes raussuchen 1097 for ( int i = 0; i < nPaperCount; i++ ) 1098 { 1099 const PaperInfo& rPaperInfo = GetPaperInfo( i ); 1100 1101 if ( aInfo.sloppyEqual(rPaperInfo) ) 1102 { 1103 pSetupData->mePaperFormat = ImplGetPaperFormat( rPaperInfo.getWidth(), 1104 rPaperInfo.getHeight() ); 1105 pSetupData->meOrientation = ORIENTATION_PORTRAIT; 1106 bFound = true; 1107 break; 1108 } 1109 } 1110 1111 // If the printer supports landscape orientation, check paper sizes again 1112 // with landscape orientation. This is necessary as a printer driver provides 1113 // all paper sizes with portrait orientation only!! 1114 if ( pSetupData->mePaperFormat == PAPER_USER && 1115 nLandscapeAngle != 0 && 1116 HasSupport( SUPPORT_SET_ORIENTATION )) 1117 { 1118 1119 PaperInfo aRotatedInfo(pSetupData->mnPaperHeight, pSetupData->mnPaperWidth); 1120 1121 for ( int i = 0; i < nPaperCount; i++ ) 1122 { 1123 const PaperInfo& rPaperInfo = GetPaperInfo( i ); 1124 1125 if ( aRotatedInfo.sloppyEqual( rPaperInfo ) ) 1126 { 1127 pSetupData->mePaperFormat = ImplGetPaperFormat( rPaperInfo.getWidth(), 1128 rPaperInfo.getHeight() ); 1129 pSetupData->meOrientation = ORIENTATION_LANDSCAPE; 1130 bFound = true; 1131 break; 1132 } 1133 } 1134 } 1135 1136 if( ! bFound && bMatchNearest ) 1137 { 1138 sal_Int64 nBestMatch = SAL_MAX_INT64; 1139 int nBestIndex = 0; 1140 Orientation eBestOrientation = ORIENTATION_PORTRAIT; 1141 for( int i = 0; i < nPaperCount; i++ ) 1142 { 1143 const PaperInfo& rPaperInfo = GetPaperInfo( i ); 1144 1145 // check protrait match 1146 sal_Int64 nDX = pSetupData->mnPaperWidth - rPaperInfo.getWidth(); 1147 sal_Int64 nDY = pSetupData->mnPaperHeight - rPaperInfo.getHeight(); 1148 sal_Int64 nMatch = nDX*nDX + nDY*nDY; 1149 if( nMatch < nBestMatch ) 1150 { 1151 nBestMatch = nMatch; 1152 nBestIndex = i; 1153 eBestOrientation = ORIENTATION_PORTRAIT; 1154 } 1155 1156 // check landscape match 1157 nDX = pSetupData->mnPaperWidth - rPaperInfo.getHeight(); 1158 nDY = pSetupData->mnPaperHeight - rPaperInfo.getWidth(); 1159 nMatch = nDX*nDX + nDY*nDY; 1160 if( nMatch < nBestMatch ) 1161 { 1162 nBestMatch = nMatch; 1163 nBestIndex = i; 1164 eBestOrientation = ORIENTATION_LANDSCAPE; 1165 } 1166 } 1167 const PaperInfo& rBestInfo = GetPaperInfo( nBestIndex ); 1168 pSetupData->mePaperFormat = ImplGetPaperFormat( rBestInfo.getWidth(), 1169 rBestInfo.getHeight() ); 1170 pSetupData->meOrientation = eBestOrientation; 1171 } 1172 } 1173 1174 // ----------------------------------------------------------------------- 1175 1176 sal_Bool Printer::SetPaper( Paper ePaper ) 1177 { 1178 if ( mbInPrintPage ) 1179 return sal_False; 1180 1181 if ( maJobSetup.ImplGetConstData()->mePaperFormat != ePaper ) 1182 { 1183 JobSetup aJobSetup = maJobSetup; 1184 ImplJobSetup* pSetupData = aJobSetup.ImplGetData(); 1185 pSetupData->mePaperFormat = ePaper; 1186 if ( ePaper != PAPER_USER ) 1187 { 1188 PaperInfo aInfo(ePaper); 1189 pSetupData->mnPaperWidth = aInfo.getWidth(); 1190 pSetupData->mnPaperHeight = aInfo.getHeight(); 1191 } 1192 1193 if ( IsDisplayPrinter() ) 1194 { 1195 mbNewJobSetup = sal_True; 1196 maJobSetup = aJobSetup; 1197 return sal_True; 1198 } 1199 1200 ImplReleaseGraphics(); 1201 if ( ePaper == PAPER_USER ) 1202 ImplFindPaperFormatForUserSize( aJobSetup, false ); 1203 if ( mpInfoPrinter->SetData( SAL_JOBSET_PAPERSIZE|SAL_JOBSET_ORIENTATION, pSetupData ) ) 1204 { 1205 ImplUpdateJobSetupPaper( aJobSetup ); 1206 mbNewJobSetup = sal_True; 1207 maJobSetup = aJobSetup; 1208 ImplUpdatePageData(); 1209 ImplUpdateFontList(); 1210 return sal_True; 1211 } 1212 else 1213 return sal_False; 1214 } 1215 1216 return sal_True; 1217 } 1218 1219 // ----------------------------------------------------------------------- 1220 1221 sal_Bool Printer::SetPaperSizeUser( const Size& rSize ) 1222 { 1223 return SetPaperSizeUser( rSize, false ); 1224 } 1225 1226 sal_Bool Printer::SetPaperSizeUser( const Size& rSize, bool bMatchNearest ) 1227 { 1228 if ( mbInPrintPage ) 1229 return sal_False; 1230 1231 Size aPixSize = LogicToPixel( rSize ); 1232 Size aPageSize = PixelToLogic( aPixSize, MAP_100TH_MM ); 1233 if ( (maJobSetup.ImplGetConstData()->mePaperFormat != PAPER_USER) || 1234 (maJobSetup.ImplGetConstData()->mnPaperWidth != aPageSize.Width()) || 1235 (maJobSetup.ImplGetConstData()->mnPaperHeight != aPageSize.Height()) ) 1236 { 1237 JobSetup aJobSetup = maJobSetup; 1238 ImplJobSetup* pSetupData = aJobSetup.ImplGetData(); 1239 pSetupData->mePaperFormat = PAPER_USER; 1240 pSetupData->mnPaperWidth = aPageSize.Width(); 1241 pSetupData->mnPaperHeight = aPageSize.Height(); 1242 1243 if ( IsDisplayPrinter() ) 1244 { 1245 mbNewJobSetup = sal_True; 1246 maJobSetup = aJobSetup; 1247 return sal_True; 1248 } 1249 1250 ImplReleaseGraphics(); 1251 ImplFindPaperFormatForUserSize( aJobSetup, bMatchNearest ); 1252 1253 // Changing the paper size can also change the orientation! 1254 if ( mpInfoPrinter->SetData( SAL_JOBSET_PAPERSIZE|SAL_JOBSET_ORIENTATION, pSetupData ) ) 1255 { 1256 ImplUpdateJobSetupPaper( aJobSetup ); 1257 mbNewJobSetup = sal_True; 1258 maJobSetup = aJobSetup; 1259 ImplUpdatePageData(); 1260 ImplUpdateFontList(); 1261 return sal_True; 1262 } 1263 else 1264 return sal_False; 1265 } 1266 1267 return sal_True; 1268 } 1269 1270 // ----------------------------------------------------------------------- 1271 1272 int Printer::GetPaperInfoCount() const 1273 { 1274 if( ! mpInfoPrinter ) 1275 return 0; 1276 if( ! mpInfoPrinter->m_bPapersInit ) 1277 mpInfoPrinter->InitPaperFormats( maJobSetup.ImplGetConstData() ); 1278 return mpInfoPrinter->m_aPaperFormats.size(); 1279 } 1280 1281 // ----------------------------------------------------------------------- 1282 1283 rtl::OUString Printer::GetPaperName( Paper ePaper ) 1284 { 1285 ImplSVData* pSVData = ImplGetSVData(); 1286 if( ! pSVData->mpPaperNames ) 1287 { 1288 pSVData->mpPaperNames = new std::hash_map< int, rtl::OUString >(); 1289 if( ImplGetResMgr() ) 1290 { 1291 ResStringArray aPaperStrings( VclResId( RID_STR_PAPERNAMES ) ); 1292 static const int PaperIndex[] = 1293 { 1294 PAPER_A0, PAPER_A1, PAPER_A2, PAPER_A3, PAPER_A4, PAPER_A5, 1295 PAPER_B4_ISO, PAPER_B5_ISO, PAPER_LETTER, PAPER_LEGAL, PAPER_TABLOID, 1296 PAPER_USER, PAPER_B6_ISO, PAPER_ENV_C4, PAPER_ENV_C5, PAPER_ENV_C6, PAPER_ENV_C65, 1297 PAPER_ENV_DL, PAPER_SLIDE_DIA, PAPER_SCREEN, PAPER_C, PAPER_D, PAPER_E, 1298 PAPER_EXECUTIVE, PAPER_FANFOLD_LEGAL_DE, PAPER_ENV_MONARCH, PAPER_ENV_PERSONAL, 1299 PAPER_ENV_9, PAPER_ENV_10, PAPER_ENV_11, PAPER_ENV_12, PAPER_KAI16, 1300 PAPER_KAI32, PAPER_KAI32BIG, PAPER_B4_JIS, PAPER_B5_JIS, PAPER_B6_JIS 1301 }; 1302 OSL_ENSURE( sal_uInt32(sizeof(PaperIndex)/sizeof(PaperIndex[0])) == aPaperStrings.Count(), "localized paper name count wrong" ); 1303 for( int i = 0; i < int(sizeof(PaperIndex)/sizeof(PaperIndex[0])); i++ ) 1304 (*pSVData->mpPaperNames)[PaperIndex[i]] = aPaperStrings.GetString(i); 1305 } 1306 } 1307 1308 std::hash_map<int,rtl::OUString>::const_iterator it = pSVData->mpPaperNames->find( (int)ePaper ); 1309 return (it != pSVData->mpPaperNames->end()) ? it->second : rtl::OUString(); 1310 } 1311 1312 // ----------------------------------------------------------------------- 1313 1314 rtl::OUString Printer::GetPaperName( bool i_bPaperUser ) const 1315 { 1316 Size aPageSize = PixelToLogic( GetPaperSizePixel(), MAP_100TH_MM ); 1317 Paper ePaper = ImplGetPaperFormat( aPageSize.Width(), aPageSize.Height() ); 1318 if( ePaper == PAPER_USER ) 1319 ePaper = ImplGetPaperFormat( aPageSize.Height(), aPageSize.Width() ); 1320 return (ePaper != PAPER_USER || i_bPaperUser ) ? GetPaperName( ePaper ) : rtl::OUString(); 1321 } 1322 1323 // ----------------------------------------------------------------------- 1324 1325 const PaperInfo& Printer::GetPaperInfo( int nPaper ) const 1326 { 1327 if( ! mpInfoPrinter ) 1328 return ImplGetEmptyPaper(); 1329 if( ! mpInfoPrinter->m_bPapersInit ) 1330 mpInfoPrinter->InitPaperFormats( maJobSetup.ImplGetConstData() ); 1331 if( mpInfoPrinter->m_aPaperFormats.empty() || nPaper < 0 || nPaper >= int(mpInfoPrinter->m_aPaperFormats.size()) ) 1332 return ImplGetEmptyPaper(); 1333 return mpInfoPrinter->m_aPaperFormats[nPaper]; 1334 } 1335 1336 // ----------------------------------------------------------------------- 1337 1338 DuplexMode Printer::GetDuplexMode() const 1339 { 1340 return maJobSetup.ImplGetConstData()->meDuplexMode; 1341 } 1342 1343 // ----------------------------------------------------------------------- 1344 1345 sal_Bool Printer::SetDuplexMode( DuplexMode eDuplex ) 1346 { 1347 if ( mbInPrintPage ) 1348 return sal_False; 1349 1350 if ( maJobSetup.ImplGetConstData()->meDuplexMode != eDuplex ) 1351 { 1352 JobSetup aJobSetup = maJobSetup; 1353 ImplJobSetup* pSetupData = aJobSetup.ImplGetData(); 1354 pSetupData->meDuplexMode = eDuplex; 1355 1356 if ( IsDisplayPrinter() ) 1357 { 1358 mbNewJobSetup = sal_True; 1359 maJobSetup = aJobSetup; 1360 return sal_True; 1361 } 1362 1363 ImplReleaseGraphics(); 1364 if ( mpInfoPrinter->SetData( SAL_JOBSET_DUPLEXMODE, pSetupData ) ) 1365 { 1366 ImplUpdateJobSetupPaper( aJobSetup ); 1367 mbNewJobSetup = sal_True; 1368 maJobSetup = aJobSetup; 1369 ImplUpdatePageData(); 1370 ImplUpdateFontList(); 1371 return sal_True; 1372 } 1373 else 1374 return sal_False; 1375 } 1376 1377 return sal_True; 1378 } 1379 1380 // ----------------------------------------------------------------------- 1381 1382 int Printer::GetLandscapeAngle() const 1383 { 1384 return mpInfoPrinter ? mpInfoPrinter->GetLandscapeAngle( maJobSetup.ImplGetConstData() ) : 900; 1385 } 1386 1387 // ----------------------------------------------------------------------- 1388 1389 Paper Printer::GetPaper() const 1390 { 1391 return maJobSetup.ImplGetConstData()->mePaperFormat; 1392 } 1393 1394 // ----------------------------------------------------------------------- 1395 1396 sal_uInt16 Printer::GetPaperBinCount() const 1397 { 1398 if ( IsDisplayPrinter() ) 1399 return 0; 1400 1401 return (sal_uInt16)mpInfoPrinter->GetPaperBinCount( maJobSetup.ImplGetConstData() ); 1402 } 1403 1404 // ----------------------------------------------------------------------- 1405 1406 XubString Printer::GetPaperBinName( sal_uInt16 nPaperBin ) const 1407 { 1408 if ( IsDisplayPrinter() ) 1409 return ImplGetSVEmptyStr(); 1410 1411 if ( nPaperBin < GetPaperBinCount() ) 1412 return mpInfoPrinter->GetPaperBinName( maJobSetup.ImplGetConstData(), nPaperBin ); 1413 else 1414 return ImplGetSVEmptyStr(); 1415 } 1416 1417 // ----------------------------------------------------------------------- 1418 1419 sal_Bool Printer::SetCopyCount( sal_uInt16 nCopy, sal_Bool bCollate ) 1420 { 1421 mnCopyCount = nCopy; 1422 mbCollateCopy = bCollate; 1423 return sal_True; 1424 } 1425 1426 // ----------------------------------------------------------------------- 1427 1428 void Printer::Error() 1429 { 1430 maErrorHdl.Call( this ); 1431 } 1432 1433 // ----------------------------------------------------------------------- 1434 1435 1436 sal_uLong Printer::ImplSalPrinterErrorCodeToVCL( sal_uLong nError ) 1437 { 1438 sal_uLong nVCLError; 1439 switch ( nError ) 1440 { 1441 case 0: 1442 nVCLError = PRINTER_OK; 1443 break; 1444 case SAL_PRINTER_ERROR_ABORT: 1445 nVCLError = PRINTER_ABORT; 1446 break; 1447 default: 1448 nVCLError = PRINTER_GENERALERROR; 1449 break; 1450 } 1451 1452 return nVCLError; 1453 } 1454 1455 // ----------------------------------------------------------------------- 1456 1457 void Printer::ImplEndPrint() 1458 { 1459 mbPrinting = sal_False; 1460 mnCurPrintPage = 0; 1461 maJobName.Erase(); 1462 } 1463 1464 // ----------------------------------------------------------------------- 1465 1466 IMPL_LINK( Printer, ImplDestroyPrinterAsync, void*, pSalPrinter ) 1467 { 1468 SalPrinter* pPrinter = (SalPrinter*)pSalPrinter; 1469 ImplSVData* pSVData = ImplGetSVData(); 1470 pSVData->mpDefInst->DestroyPrinter( pPrinter ); 1471 return 0; 1472 } 1473 1474 // ----------------------------------------------------------------------- 1475 1476 sal_Bool Printer::EndJob() 1477 { 1478 sal_Bool bRet = sal_False; 1479 if ( !IsJobActive() ) 1480 return bRet; 1481 1482 DBG_ASSERT( !mbInPrintPage, "Printer::EndJob() - StartPage() without EndPage() called" ); 1483 1484 mbJobActive = sal_False; 1485 1486 if ( mpPrinter ) 1487 { 1488 ImplReleaseGraphics(); 1489 1490 mnCurPage = 0; 1491 1492 bRet = sal_True; 1493 1494 mbPrinting = sal_False; 1495 mnCurPrintPage = 0; 1496 maJobName.Erase(); 1497 1498 mbDevOutput = sal_False; 1499 bRet = mpPrinter->EndJob(); 1500 // Hier den Drucker nicht asyncron zerstoeren, da es 1501 // W95 nicht verkraftet, wenn gleichzeitig gedruckt wird 1502 // und ein Druckerobjekt zerstoert wird 1503 ImplGetSVData()->mpDefInst->DestroyPrinter( mpPrinter ); 1504 mpPrinter = NULL; 1505 } 1506 1507 return bRet; 1508 } 1509 1510 // ----------------------------------------------------------------------- 1511 1512 sal_Bool Printer::AbortJob() 1513 { 1514 // Wenn wir einen Queue-Printer haben, kann man diesen noch mit 1515 // AbortJob() abbrechen, solange dieser noch am Drucken ist 1516 if ( !IsJobActive() && !IsPrinting() ) 1517 return sal_False; 1518 1519 mbJobActive = sal_False; 1520 mbInPrintPage = sal_False; 1521 mpJobGraphics = NULL; 1522 1523 if ( mpPrinter ) 1524 { 1525 mbPrinting = sal_False; 1526 mnCurPage = 0; 1527 mnCurPrintPage = 0; 1528 maJobName.Erase(); 1529 1530 ImplReleaseGraphics(); 1531 mbDevOutput = sal_False; 1532 mpPrinter->AbortJob(); 1533 Application::PostUserEvent( LINK( this, Printer, ImplDestroyPrinterAsync ), mpPrinter ); 1534 mpPrinter = NULL; 1535 1536 return sal_True; 1537 } 1538 1539 return sal_False; 1540 } 1541 1542 // ----------------------------------------------------------------------- 1543 1544 void Printer::ImplStartPage() 1545 { 1546 if ( !IsJobActive() ) 1547 return; 1548 1549 if ( mpPrinter ) 1550 { 1551 SalGraphics* pGraphics = mpPrinter->StartPage( maJobSetup.ImplGetConstData(), mbNewJobSetup ); 1552 if ( pGraphics ) 1553 { 1554 ImplReleaseGraphics(); 1555 mpJobGraphics = pGraphics; 1556 } 1557 mbDevOutput = sal_True; 1558 1559 // PrintJob not aborted ??? 1560 if ( IsJobActive() ) 1561 { 1562 mbInPrintPage = sal_True; 1563 mnCurPage++; 1564 mnCurPrintPage++; 1565 } 1566 } 1567 } 1568 1569 // ----------------------------------------------------------------------- 1570 1571 void Printer::ImplEndPage() 1572 { 1573 if ( !IsJobActive() ) 1574 return; 1575 1576 mbInPrintPage = sal_False; 1577 1578 if ( mpPrinter ) 1579 { 1580 mpPrinter->EndPage(); 1581 ImplReleaseGraphics(); 1582 mbDevOutput = sal_False; 1583 1584 mpJobGraphics = NULL; 1585 mbNewJobSetup = sal_False; 1586 } 1587 } 1588 1589 // ----------------------------------------------------------------------- 1590 1591 void Printer::updatePrinters() 1592 { 1593 ImplSVData* pSVData = ImplGetSVData(); 1594 ImplPrnQueueList* pPrnList = pSVData->maGDIData.mpPrinterQueueList; 1595 1596 if ( pPrnList ) 1597 { 1598 ImplPrnQueueList* pNewList = new ImplPrnQueueList; 1599 pSVData->mpDefInst->GetPrinterQueueInfo( pNewList ); 1600 1601 bool bChanged = pPrnList->m_aQueueInfos.size() != pNewList->m_aQueueInfos.size(); 1602 for( unsigned int i = 0; ! bChanged && i < pPrnList->m_aQueueInfos.size(); i++ ) 1603 { 1604 ImplPrnQueueData& rInfo = pPrnList->m_aQueueInfos[i]; 1605 ImplPrnQueueData& rNewInfo = pNewList->m_aQueueInfos[i]; 1606 if( ! rInfo.mpSalQueueInfo || ! rNewInfo.mpSalQueueInfo || // sanity check 1607 rInfo.mpSalQueueInfo->maPrinterName != rNewInfo.mpSalQueueInfo->maPrinterName ) 1608 { 1609 bChanged = true; 1610 } 1611 } 1612 if( bChanged ) 1613 { 1614 ImplDeletePrnQueueList(); 1615 pSVData->maGDIData.mpPrinterQueueList = pNewList; 1616 1617 Application* pApp = GetpApp(); 1618 if( pApp ) 1619 { 1620 DataChangedEvent aDCEvt( DATACHANGED_PRINTER ); 1621 pApp->DataChanged( aDCEvt ); 1622 pApp->NotifyAllWindows( aDCEvt ); 1623 } 1624 } 1625 else 1626 delete pNewList; 1627 } 1628 } 1629