vcl/unx/headless/svpprn.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  * 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 #include "vcl/svapp.hxx"
  32 #include "vcl/jobset.h"
  33 #include "vcl/print.h"
  34 #include "vcl/salptype.hxx"
  35 #include "vcl/timer.hxx"
  36 #include "vcl/printerinfomanager.hxx"
  37
  38 #include "svpprn.hxx"
  39 #include "svppspgraphics.hxx"
  40 #include "svpinst.hxx"
  41
  42 #include <unistd.h>
  43 #include <sys/stat.h>
  44 #include <sys/wait.h>
  45
  46 using namespace psp;
  47 using namespace rtl;
  48
  49 /*
  50  *      static helpers
  51  */
  52
  53 static String getPdfDir( const PrinterInfo& rInfo )
  54 {
  55     String aDir;
  56     sal_Int32 nIndex = 0;
  57     while( nIndex != -1 )
  58     {
  59         OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
  60         if( ! aToken.compareToAscii( "pdf=", 4 ) )
  61         {
  62             sal_Int32 nPos = 0;
  63             aDir = aToken.getToken( 1, '=', nPos );
  64             if( ! aDir.Len() )
  65                 aDir = String( ByteString( getenv( "HOME" ) ), osl_getThreadTextEncoding() );
  66             break;
  67         }
  68     }
  69     return aDir;
  70 }
  71
  72 inline int PtTo10Mu( int nPoints ) { return (int)((((double)nPoints)*35.27777778)+0.5); }
  73
  74 inline int TenMuToPt( int nUnits ) { return (int)((((double)nUnits)/35.27777778)+0.5); }
  75
  76 static void copyJobDataToJobSetup( ImplJobSetup* pJobSetup, JobData& rData )
  77 {
  78     pJobSetup->meOrientation    = (Orientation)(rData.m_eOrientation == orientation::Landscape ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT);
  79
  80     // copy page size
  81     String aPaper;
  82     int width, height;
  83
  84     rData.m_aContext.getPageSize( aPaper, width, height );
  85     pJobSetup->mePaperFormat    = PaperInfo::fromPSName(OUStringToOString( aPaper, RTL_TEXTENCODING_ISO_8859_1 ));
  86     pJobSetup->mnPaperWidth             = 0;
  87     pJobSetup->mnPaperHeight    = 0;
  88     if( pJobSetup->mePaperFormat == PAPER_USER )
  89     {
  90         // transform to 100dth mm
  91         width                           = PtTo10Mu( width );
  92         height                          = PtTo10Mu( height );
  93
  94         if( rData.m_eOrientation == psp::orientation::Portrait )
  95         {
  96             pJobSetup->mnPaperWidth     = width;
  97             pJobSetup->mnPaperHeight= height;
  98         }
  99         else
 100         {
 101             pJobSetup->mnPaperWidth     = height;
 102             pJobSetup->mnPaperHeight= width;
 103         }
 104     }
 105
 106     // copy input slot
 107     const PPDKey* pKey = NULL;
 108     const PPDValue* pValue = NULL;
 109
 110     pJobSetup->mnPaperBin = 0xffff;
 111     if( rData.m_pParser )
 112         pKey                                    = rData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) );
 113     if( pKey )
 114         pValue                                  = rData.m_aContext.getValue( pKey );
 115     if( pKey && pValue )
 116     {
 117         for( pJobSetup->mnPaperBin = 0;
 118              pValue != pKey->getValue( pJobSetup->mnPaperBin ) &&
 119                  pJobSetup->mnPaperBin < pKey->countValues();
 120              pJobSetup->mnPaperBin++ )
 121             ;
 122         if( pJobSetup->mnPaperBin >= pKey->countValues() || pValue == pKey->getDefaultValue() )
 123             pJobSetup->mnPaperBin = 0xffff;
 124     }
 125
 126
 127     // copy the whole context
 128     if( pJobSetup->mpDriverData )
 129         rtl_freeMemory( pJobSetup->mpDriverData );
 130
 131     int nBytes;
 132     void* pBuffer = NULL;
 133     if( rData.getStreamBuffer( pBuffer, nBytes ) )
 134     {
 135         pJobSetup->mnDriverDataLen = nBytes;
 136         pJobSetup->mpDriverData = (BYTE*)pBuffer;
 137     }
 138     else
 139     {
 140         pJobSetup->mnDriverDataLen = 0;
 141         pJobSetup->mpDriverData = NULL;
 142     }
 143 }
 144
 145 static bool passFileToCommandLine( const String& rFilename, const String& rCommandLine, bool bRemoveFile = true )
 146 {
 147     bool bSuccess = false;
 148
 149     rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
 150     ByteString aCmdLine( rCommandLine, aEncoding );
 151     ByteString aFilename( rFilename, aEncoding );
 152
 153     bool bPipe = aCmdLine.Search( "(TMP)" ) != STRING_NOTFOUND ? false : true;
 154
 155     // setup command line for exec
 156     if( ! bPipe )
 157         while( aCmdLine.SearchAndReplace( "(TMP)", aFilename ) != STRING_NOTFOUND )
 158             ;
 159
 160 #if OSL_DEBUG_LEVEL > 1
 161     fprintf( stderr, "%s commandline: \"%s\"\n",
 162              bPipe ? "piping to" : "executing",
 163              aCmdLine.GetBuffer() );
 164     struct stat aStat;
 165     if( stat( aFilename.GetBuffer(), &aStat ) )
 166         fprintf( stderr, "stat( %s ) failed\n", aFilename.GetBuffer() );
 167     fprintf( stderr, "Tmp file %s has modes: 0%03lo\n", aFilename.GetBuffer(), (long)aStat.st_mode );
 168 #endif
 169     const char* argv[4];
 170     if( ! ( argv[ 0 ] = getenv( "SHELL" ) ) )
 171         argv[ 0 ] = "/bin/sh";
 172     argv[ 1 ] = "-c";
 173     argv[ 2 ] = aCmdLine.GetBuffer();
 174     argv[ 3 ] = 0;
 175
 176     bool bHavePipes = false;
 177     int pid, fd[2];
 178
 179     if( bPipe )
 180         bHavePipes = pipe( fd ) ? false : true;
 181     if( ( pid = fork() ) > 0 )
 182     {
 183         if( bPipe && bHavePipes )
 184         {
 185             close( fd[0] );
 186             char aBuffer[ 2048 ];
 187             FILE* fp = fopen( aFilename.GetBuffer(), "r" );
 188             while( fp && ! feof( fp ) )
 189             {
 190                 int nBytes = fread( aBuffer, 1, sizeof( aBuffer ), fp );
 191                 if( nBytes )
 192                     write( fd[ 1 ], aBuffer, nBytes );
 193             }
 194             fclose( fp );
 195             close( fd[ 1 ] );
 196         }
 197         int status = 0;
 198         waitpid( pid, &status, 0 );
 199         if( ! status )
 200             bSuccess = true;
 201     }
 202     else if( ! pid )
 203     {
 204         if( bPipe && bHavePipes )
 205         {
 206             close( fd[1] );
 207             if( fd[0] != STDIN_FILENO ) // not probable, but who knows :)
 208                 dup2( fd[0], STDIN_FILENO );
 209         }
 210         execv( argv[0], const_cast<char**>(argv) );
 211         fprintf( stderr, "failed to execute \"%s\"\n", aCmdLine.GetBuffer() );
 212         _exit( 1 );
 213     }
 214     else
 215         fprintf( stderr, "failed to fork\n" );
 216
 217     // clean up the mess
 218     if( bRemoveFile )
 219         unlink( aFilename.GetBuffer() );
 220
 221     return bSuccess;
 222 }
 223
 224 static bool sendAFax( const String& rFaxNumber, const String& rFileName, const String& rCommand )
 225 {
 226     std::list< OUString > aFaxNumbers;
 227
 228     if( ! rFaxNumber.Len() )
 229         return false;
 230
 231     sal_Int32 nIndex = 0;
 232     OUString aFaxes( rFaxNumber );
 233     OUString aBeginToken( RTL_CONSTASCII_USTRINGPARAM("<Fax#>") );
 234     OUString aEndToken( RTL_CONSTASCII_USTRINGPARAM("</Fax#>") );
 235     while( nIndex != -1 )
 236     {
 237         nIndex = aFaxes.indexOf( aBeginToken, nIndex );
 238         if( nIndex != -1 )
 239         {
 240             sal_Int32 nBegin = nIndex + aBeginToken.getLength();
 241             nIndex = aFaxes.indexOf( aEndToken, nIndex );
 242             if( nIndex != -1 )
 243             {
 244                 aFaxNumbers.push_back( aFaxes.copy( nBegin, nIndex-nBegin ) );
 245                 nIndex += aEndToken.getLength();
 246             }
 247         }
 248     }
 249
 250     bool bSuccess = true;
 251     if( aFaxNumbers.begin() != aFaxNumbers.end() )
 252     {
 253         while( aFaxNumbers.begin() != aFaxNumbers.end() && bSuccess )
 254         {
 255             String aCmdLine( rCommand );
 256             String aFaxNumber( aFaxNumbers.front() );
 257             aFaxNumbers.pop_front();
 258             while( aCmdLine.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "(PHONE)" ) ), aFaxNumber ) != STRING_NOTFOUND )
 259                 ;
 260 #if OSL_DEBUG_LEVEL > 1
 261             fprintf( stderr, "sending fax to \"%s\"\n", OUStringToOString( aFaxNumber, osl_getThreadTextEncoding() ).getStr() );
 262 #endif
 263             bSuccess = passFileToCommandLine( rFileName, aCmdLine, false );
 264         }
 265     }
 266     else
 267         bSuccess = false;
 268
 269     // clean up temp file
 270     unlink( ByteString( rFileName, osl_getThreadTextEncoding() ).GetBuffer() );
 271
 272     return bSuccess;
 273 }
 274
 275 static bool createPdf( const String& rToFile, const String& rFromFile, const String& rCommandLine )
 276 {
 277     String aCommandLine( rCommandLine );
 278     while( aCommandLine.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "(OUTFILE)" ) ), rToFile ) != STRING_NOTFOUND )
 279         ;
 280     return passFileToCommandLine( rFromFile, aCommandLine );
 281 }
 282
 283 /*
 284  *      SalInstance
 285  */
 286
 287 // -----------------------------------------------------------------------
 288
 289 SalInfoPrinter* SvpSalInstance::CreateInfoPrinter( SalPrinterQueueInfo* pQueueInfo,
 290                                                    ImplJobSetup*                        pJobSetup )
 291 {
 292     // create and initialize SalInfoPrinter
 293     PspSalInfoPrinter* pPrinter = new PspSalInfoPrinter;
 294
 295     if( pJobSetup )
 296     {
 297         PrinterInfoManager& rManager( PrinterInfoManager::get() );
 298         PrinterInfo aInfo( rManager.getPrinterInfo( pQueueInfo->maPrinterName ) );
 299         pPrinter->m_aJobData = aInfo;
 300         pPrinter->m_aPrinterGfx.Init( pPrinter->m_aJobData );
 301
 302         if( pJobSetup->mpDriverData )
 303             JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aInfo );
 304
 305         pJobSetup->mnSystem                     = JOBSETUP_SYSTEM_UNIX;
 306         pJobSetup->maPrinterName        = pQueueInfo->maPrinterName;
 307         pJobSetup->maDriver                     = aInfo.m_aDriverName;
 308         copyJobDataToJobSetup( pJobSetup, aInfo );
 309
 310         // set/clear backwards compatibility flag
 311         bool bStrictSO52Compatibility = false;
 312         std::hash_map<rtl::OUString, rtl::OUString, rtl::OUStringHash >::const_iterator compat_it =
 313             pJobSetup->maValueMap.find( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StrictSO52Compatibility" ) ) );
 314         if( compat_it != pJobSetup->maValueMap.end() )
 315         {
 316             if( compat_it->second.equalsIgnoreAsciiCaseAscii( "true" ) )
 317                 bStrictSO52Compatibility = true;
 318         }
 319         pPrinter->m_aPrinterGfx.setStrictSO52Compatibility( bStrictSO52Compatibility );
 320     }
 321
 322
 323     return pPrinter;
 324 }
 325
 326 // -----------------------------------------------------------------------
 327
 328 void SvpSalInstance::DestroyInfoPrinter( SalInfoPrinter* pPrinter )
 329 {
 330     delete pPrinter;
 331 }
 332
 333 // -----------------------------------------------------------------------
 334
 335 SalPrinter* SvpSalInstance::CreatePrinter( SalInfoPrinter* pInfoPrinter )
 336 {
 337     // create and initialize SalPrinter
 338     PspSalPrinter* pPrinter = new PspSalPrinter( pInfoPrinter );
 339     pPrinter->m_aJobData = static_cast<PspSalInfoPrinter*>(pInfoPrinter)->m_aJobData;
 340
 341     return pPrinter;
 342 }
 343
 344 // -----------------------------------------------------------------------
 345
 346 void SvpSalInstance::DestroyPrinter( SalPrinter* pPrinter )
 347 {
 348     delete pPrinter;
 349 }
 350
 351 // -----------------------------------------------------------------------
 352
 353 void SvpSalInstance::GetPrinterQueueInfo( ImplPrnQueueList* pList )
 354 {
 355     PrinterInfoManager& rManager( PrinterInfoManager::get() );
 356     static const char* pNoSyncDetection = getenv( "SAL_DISABLE_SYNCHRONOUS_PRINTER_DETECTION" );
 357     if( ! pNoSyncDetection || ! *pNoSyncDetection )
 358     {
 359         // #i62663# synchronize possible asynchronouse printer detection now
 360         rManager.checkPrintersChanged( true );
 361     }
 362     ::std::list< OUString > aPrinters;
 363     rManager.listPrinters( aPrinters );
 364
 365     for( ::std::list< OUString >::iterator it = aPrinters.begin(); it != aPrinters.end(); ++it )
 366     {
 367         const PrinterInfo& rInfo( rManager.getPrinterInfo( *it ) );
 368         // Neuen Eintrag anlegen
 369         SalPrinterQueueInfo* pInfo = new SalPrinterQueueInfo;
 370         pInfo->maPrinterName    = *it;
 371         pInfo->maDriver                 = rInfo.m_aDriverName;
 372         pInfo->maLocation               = rInfo.m_aLocation;
 373         pInfo->maComment        = rInfo.m_aComment;
 374         pInfo->mpSysData                = NULL;
 375
 376         sal_Int32 nIndex = 0;
 377         while( nIndex != -1 )
 378         {
 379             String aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
 380             if( aToken.CompareToAscii( "pdf=", 4 ) == COMPARE_EQUAL )
 381             {
 382                 pInfo->maLocation = getPdfDir( rInfo );
 383                 break;
 384             }
 385         }
 386
 387         pList->Add( pInfo );
 388     }
 389 }
 390
 391 // -----------------------------------------------------------------------
 392
 393 void SvpSalInstance::DeletePrinterQueueInfo( SalPrinterQueueInfo* pInfo )
 394 {
 395     delete pInfo;
 396 }
 397
 398 // -----------------------------------------------------------------------
 399
 400 void SvpSalInstance::GetPrinterQueueState( SalPrinterQueueInfo* )
 401 {
 402 }
 403
 404 // -----------------------------------------------------------------------
 405
 406 String SvpSalInstance::GetDefaultPrinter()
 407 {
 408     PrinterInfoManager& rManager( PrinterInfoManager::get() );
 409     return rManager.getDefaultPrinter();
 410 }
 411
 412 // =======================================================================
 413
 414 PspSalInfoPrinter::PspSalInfoPrinter()
 415 {
 416     m_pGraphics = NULL;
 417     m_bPapersInit = false;
 418 }
 419
 420 // -----------------------------------------------------------------------
 421
 422 PspSalInfoPrinter::~PspSalInfoPrinter()
 423 {
 424     if( m_pGraphics )
 425     {
 426         delete m_pGraphics;
 427         m_pGraphics = NULL;
 428     }
 429 }
 430
 431 // -----------------------------------------------------------------------
 432
 433 void PspSalInfoPrinter::InitPaperFormats( const ImplJobSetup* )
 434 {
 435     m_aPaperFormats.clear();
 436     m_bPapersInit = true;
 437
 438     if( m_aJobData.m_pParser )
 439     {
 440         const PPDKey* pKey = m_aJobData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) ) );
 441         if( pKey )
 442         {
 443             int nValues = pKey->countValues();
 444             for( int i = 0; i < nValues; i++ )
 445             {
 446                 const PPDValue* pValue = pKey->getValue( i );
 447                 int nWidth = 0, nHeight = 0;
 448                 m_aJobData.m_pParser->getPaperDimension( pValue->m_aOption, nWidth, nHeight );
 449                 PaperInfo aInfo(PtTo10Mu( nWidth ), PtTo10Mu( nHeight ));
 450                 m_aPaperFormats.push_back( aInfo );
 451             }
 452         }
 453     }
 454 }
 455
 456 // -----------------------------------------------------------------------
 457
 458 DuplexMode PspSalInfoPrinter::GetDuplexMode( const ImplJobSetup* pJobSetup )
 459 {
 460     DuplexMode aRet = DUPLEX_UNKNOWN;
 461     PrinterInfo aInfo( PrinterInfoManager::get().getPrinterInfo( pJobSetup->maPrinterName ) );
 462     if ( pJobSetup->mpDriverData )
 463         JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aInfo );
 464     if( aInfo.m_pParser )
 465     {
 466         const PPDKey * pKey = aInfo.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Duplex" ) ) );
 467         if( pKey )
 468         {
 469             const PPDValue* pVal = aInfo.m_aContext.getValue( pKey );
 470             if( pVal && (
 471                 pVal->m_aOption.EqualsIgnoreCaseAscii( "None" )          ||
 472                 pVal->m_aOption.EqualsIgnoreCaseAscii( "Simplex", 0, 7 )
 473                 ) )
 474             {
 475                 aRet = DUPLEX_OFF;
 476             }
 477             else
 478                 aRet = DUPLEX_ON;
 479         }
 480     }
 481     return aRet;
 482 }
 483
 484 // -----------------------------------------------------------------------
 485
 486 int PspSalInfoPrinter::GetLandscapeAngle( const ImplJobSetup* )
 487 {
 488     return 900;
 489 }
 490
 491 // -----------------------------------------------------------------------
 492
 493 SalGraphics* PspSalInfoPrinter::GetGraphics()
 494 {
 495     // return a valid pointer only once
 496     // the reasoning behind this is that we could have different
 497     // SalGraphics that can run in multiple threads
 498     // (future plans)
 499     SalGraphics* pRet = NULL;
 500     if( ! m_pGraphics )
 501     {
 502         m_pGraphics = new PspGraphics( &m_aJobData, &m_aPrinterGfx, NULL, false, this );
 503         m_pGraphics->SetLayout( 0 );
 504         pRet = m_pGraphics;
 505     }
 506     return pRet;
 507 }
 508
 509 // -----------------------------------------------------------------------
 510
 511 void PspSalInfoPrinter::ReleaseGraphics( SalGraphics* pGraphics )
 512 {
 513     if( pGraphics == m_pGraphics )
 514     {
 515         delete pGraphics;
 516         m_pGraphics = NULL;
 517     }
 518     return;
 519 }
 520
 521 // -----------------------------------------------------------------------
 522
 523 BOOL PspSalInfoPrinter::Setup( SalFrame*, ImplJobSetup* )
 524 {
 525     return FALSE;
 526 }
 527
 528 // -----------------------------------------------------------------------
 529
 530 // This function gets the driver data and puts it into pJobSetup
 531 // If pJobSetup->mpDriverData is NOT NULL, then the independend
 532 // data should be merged into the driver data
 533 // If pJobSetup->mpDriverData IS NULL, then the driver defaults
 534 // should be merged into the independent data
 535 BOOL PspSalInfoPrinter::SetPrinterData( ImplJobSetup* pJobSetup )
 536 {
 537     if( pJobSetup->mpDriverData )
 538         return SetData( ~0, pJobSetup );
 539
 540     copyJobDataToJobSetup( pJobSetup, m_aJobData );
 541
 542     // set/clear backwards compatibility flag
 543     bool bStrictSO52Compatibility = false;
 544     std::hash_map<rtl::OUString, rtl::OUString, rtl::OUStringHash >::const_iterator compat_it =
 545         pJobSetup->maValueMap.find( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StrictSO52Compatibility" ) ) );
 546     if( compat_it != pJobSetup->maValueMap.end() )
 547     {
 548         if( compat_it->second.equalsIgnoreAsciiCaseAscii( "true" ) )
 549             bStrictSO52Compatibility = true;
 550     }
 551     m_aPrinterGfx.setStrictSO52Compatibility( bStrictSO52Compatibility );
 552
 553     return TRUE;
 554 }
 555
 556 // -----------------------------------------------------------------------
 557
 558 // This function merges the independ driver data
 559 // and sets the new independ data in pJobSetup
 560 // Only the data must be changed, where the bit
 561 // in nGetDataFlags is set
 562 BOOL PspSalInfoPrinter::SetData(
 563     ULONG nSetDataFlags,
 564     ImplJobSetup* pJobSetup )
 565 {
 566     JobData aData;
 567     JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
 568
 569     if( aData.m_pParser )
 570     {
 571         const PPDKey* pKey;
 572         const PPDValue* pValue;
 573
 574         // merge papersize if necessary
 575         if( nSetDataFlags & SAL_JOBSET_PAPERSIZE )
 576         {
 577             int nWidth, nHeight;
 578             if( pJobSetup->meOrientation == ORIENTATION_PORTRAIT )
 579             {
 580                 nWidth  = pJobSetup->mnPaperWidth;
 581                 nHeight = pJobSetup->mnPaperHeight;
 582             }
 583             else
 584             {
 585                 nWidth  = pJobSetup->mnPaperHeight;
 586                 nHeight = pJobSetup->mnPaperWidth;
 587             }
 588             String aPaper;
 589
 590             if( pJobSetup->mePaperFormat == PAPER_USER )
 591                 aPaper = aData.m_pParser->matchPaper(
 592                     TenMuToPt( pJobSetup->mnPaperWidth ),
 593                     TenMuToPt( pJobSetup->mnPaperHeight ) );
 594             else
 595                 aPaper = rtl::OStringToOUString(PaperInfo::toPSName(pJobSetup->mePaperFormat), RTL_TEXTENCODING_ISO_8859_1);
 596
 597             pKey = aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) ) );
 598             pValue = pKey ? pKey->getValue( aPaper ) : NULL;
 599             if( ! ( pKey && pValue && aData.m_aContext.setValue( pKey, pValue, false ) == pValue ) )
 600                 return FALSE;
 601         }
 602
 603         // merge paperbin if necessary
 604         if( nSetDataFlags & SAL_JOBSET_PAPERBIN )
 605         {
 606             pKey = aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) );
 607             if( pKey )
 608             {
 609                 int nPaperBin = pJobSetup->mnPaperBin;
 610                 if( nPaperBin == 0xffff )
 611                     pValue = pKey->getDefaultValue();
 612                 else
 613                     pValue = pKey->getValue( pJobSetup->mnPaperBin );
 614
 615                 // may fail due to constraints;
 616                 // real paper bin is copied back to jobsetup in that case
 617                 aData.m_aContext.setValue( pKey, pValue );
 618             }
 619             // if printer has no InputSlot key simply ignore this setting
 620             // (e.g. SGENPRT has no InputSlot)
 621         }
 622
 623         // merge orientation if necessary
 624         if( nSetDataFlags & SAL_JOBSET_ORIENTATION )
 625             aData.m_eOrientation = pJobSetup->meOrientation == ORIENTATION_LANDSCAPE ? orientation::Landscape : orientation::Portrait;
 626
 627         m_aJobData = aData;
 628         copyJobDataToJobSetup( pJobSetup, aData );
 629         return TRUE;
 630     }
 631
 632     return FALSE;
 633 }
 634
 635 // -----------------------------------------------------------------------
 636
 637 void PspSalInfoPrinter::GetPageInfo(
 638     const ImplJobSetup* pJobSetup,
 639     long& rOutWidth, long& rOutHeight,
 640     long& rPageOffX, long& rPageOffY,
 641     long& rPageWidth, long& rPageHeight )
 642 {
 643     if( ! pJobSetup )
 644         return;
 645
 646     JobData aData;
 647     JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
 648
 649     // get the selected page size
 650     if( aData.m_pParser )
 651     {
 652
 653         String aPaper;
 654         int width, height;
 655         int left = 0, top = 0, right = 0, bottom = 0;
 656         int nDPI = aData.m_aContext.getRenderResolution();
 657
 658
 659         if( aData.m_eOrientation == psp::orientation::Portrait )
 660         {
 661             aData.m_aContext.getPageSize( aPaper, width, height );
 662             aData.m_pParser->getMargins( aPaper, left, right, top, bottom );
 663         }
 664         else
 665         {
 666             aData.m_aContext.getPageSize( aPaper, height, width );
 667             aData.m_pParser->getMargins( aPaper, top, bottom, right, left );
 668         }
 669
 670         rPageWidth      = width * nDPI / 72;
 671         rPageHeight     = height * nDPI / 72;
 672         rPageOffX       = left * nDPI / 72;
 673         rPageOffY       = top * nDPI / 72;
 674         rOutWidth       = ( width  - left - right ) * nDPI / 72;
 675         rOutHeight      = ( height - top  - bottom ) * nDPI / 72;
 676     }
 677 }
 678
 679 // -----------------------------------------------------------------------
 680
 681 ULONG PspSalInfoPrinter::GetPaperBinCount( const ImplJobSetup* pJobSetup )
 682 {
 683     if( ! pJobSetup )
 684         return 0;
 685
 686     JobData aData;
 687     JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
 688
 689     const PPDKey* pKey = aData.m_pParser ? aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) ): NULL;
 690     return pKey ? pKey->countValues() : 0;
 691 }
 692
 693 // -----------------------------------------------------------------------
 694
 695 String PspSalInfoPrinter::GetPaperBinName( const ImplJobSetup* pJobSetup, ULONG nPaperBin )
 696 {
 697     JobData aData;
 698     JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
 699
 700     String aRet;
 701     if( aData.m_pParser )
 702     {
 703         const PPDKey* pKey = aData.m_pParser ? aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) ): NULL;
 704         if( nPaperBin == 0xffff || ! pKey )
 705             aRet = aData.m_pParser->getDefaultInputSlot();
 706         else
 707         {
 708             const PPDValue* pValue = pKey->getValue( nPaperBin );
 709             if( pValue )
 710                 aRet = pValue->m_aOptionTranslation.Len() ? pValue->m_aOptionTranslation : pValue->m_aOption;
 711         }
 712     }
 713
 714     return aRet;
 715 }
 716
 717 // -----------------------------------------------------------------------
 718
 719 ULONG PspSalInfoPrinter::GetCapabilities( const ImplJobSetup* pJobSetup, USHORT nType )
 720 {
 721     switch( nType )
 722     {
 723         case PRINTER_CAPABILITIES_SUPPORTDIALOG:
 724             return 1;
 725         case PRINTER_CAPABILITIES_COPIES:
 726             return 0xffff;
 727         case PRINTER_CAPABILITIES_COLLATECOPIES:
 728             return 0;
 729         case PRINTER_CAPABILITIES_SETORIENTATION:
 730             return 1;
 731         case PRINTER_CAPABILITIES_SETPAPERBIN:
 732             return 1;
 733         case PRINTER_CAPABILITIES_SETPAPERSIZE:
 734             return 1;
 735         case PRINTER_CAPABILITIES_SETPAPER:
 736             return 0;
 737         case PRINTER_CAPABILITIES_FAX:
 738         {
 739             PrinterInfoManager& rManager = PrinterInfoManager::get();
 740             PrinterInfo aInfo( rManager.getPrinterInfo( pJobSetup->maPrinterName ) );
 741             String aFeatures( aInfo.m_aFeatures );
 742             int nTokenCount = aFeatures.GetTokenCount( ',' );
 743             for( int i = 0; i < nTokenCount; i++ )
 744             {
 745                 if( aFeatures.GetToken( i ).CompareToAscii( "fax", 3 ) == COMPARE_EQUAL )
 746                     return 1;
 747             }
 748             return 0;
 749         }
 750         case PRINTER_CAPABILITIES_PDF:
 751         {
 752             PrinterInfoManager& rManager = PrinterInfoManager::get();
 753             PrinterInfo aInfo( rManager.getPrinterInfo( pJobSetup->maPrinterName ) );
 754             String aFeatures( aInfo.m_aFeatures );
 755             int nTokenCount = aFeatures.GetTokenCount( ',' );
 756             for( int i = 0; i < nTokenCount; i++ )
 757             {
 758                 if( aFeatures.GetToken( i ).CompareToAscii( "pdf=", 4 ) == COMPARE_EQUAL )
 759                     return 1;
 760             }
 761             return 0;
 762         }
 763         default: break;
 764     };
 765     return 0;
 766 }
 767
 768 // =======================================================================
 769
 770 /*
 771  *      SalPrinter
 772  */
 773
 774 PspSalPrinter::PspSalPrinter( SalInfoPrinter* pInfoPrinter )
 775  : m_bFax( false ),
 776    m_bPdf( false ),
 777    m_bSwallowFaxNo( false ),
 778    m_pGraphics( NULL ),
 779    m_nCopies( 1 ),
 780    m_pInfoPrinter( pInfoPrinter )
 781 {
 782 }
 783
 784 // -----------------------------------------------------------------------
 785
 786 PspSalPrinter::~PspSalPrinter()
 787 {
 788 }
 789
 790 // -----------------------------------------------------------------------
 791
 792 static String getTmpName()
 793 {
 794     rtl::OUString aTmp, aSys;
 795     osl_createTempFile( NULL, NULL, &aTmp.pData );
 796     osl_getSystemPathFromFileURL( aTmp.pData, &aSys.pData );
 797
 798     return aSys;
 799 }
 800
 801 BOOL PspSalPrinter::StartJob(
 802     const XubString* pFileName,
 803     const XubString& rJobName,
 804     const XubString& rAppName,
 805     ULONG nCopies, BOOL /*bCollate*/,
 806     ImplJobSetup* pJobSetup )
 807 {
 808     vcl_sal::PrinterUpdate::jobStarted();
 809
 810     m_bFax              = false;
 811     m_bPdf              = false;
 812     m_aFileName = pFileName ? *pFileName : String();
 813     m_aTmpFile  = String();
 814     m_nCopies           = nCopies;
 815
 816     JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, m_aJobData );
 817     if( m_nCopies > 1 )
 818         // in case user did not do anything (m_nCopies=1)
 819         // take the default from jobsetup
 820         m_aJobData.m_nCopies = m_nCopies;
 821
 822     // check wether this printer is configured as fax
 823     int nMode = 0;
 824     const PrinterInfo& rInfo( PrinterInfoManager::get().getPrinterInfo( m_aJobData.m_aPrinterName ) );
 825     sal_Int32 nIndex = 0;
 826     while( nIndex != -1 )
 827     {
 828         OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
 829         if( ! aToken.compareToAscii( "fax", 3 ) )
 830         {
 831             m_bFax = true;
 832             m_aTmpFile = getTmpName();
 833             nMode = S_IRUSR | S_IWUSR;
 834
 835             ::std::hash_map< ::rtl::OUString, ::rtl::OUString, ::rtl::OUStringHash >::const_iterator it;
 836             it = pJobSetup->maValueMap.find( ::rtl::OUString::createFromAscii( "FAX#" ) );
 837             if( it != pJobSetup->maValueMap.end() )
 838                 m_aFaxNr = it->second;
 839
 840             sal_Int32 nPos = 0;
 841             m_bSwallowFaxNo = ! aToken.getToken( 1, '=', nPos ).compareToAscii( "swallow", 7 ) ? true : false;
 842
 843             break;
 844         }
 845         if( ! aToken.compareToAscii( "pdf=", 4 ) )
 846         {
 847             m_bPdf = true;
 848             m_aTmpFile = getTmpName();
 849             nMode = S_IRUSR | S_IWUSR;
 850
 851             if( ! m_aFileName.Len() )
 852             {
 853                 m_aFileName = getPdfDir( rInfo );
 854                 m_aFileName.Append( '/' );
 855                 m_aFileName.Append( rJobName );
 856                 m_aFileName.AppendAscii( ".pdf" );
 857             }
 858             break;
 859         }
 860     }
 861     m_aPrinterGfx.Init( m_aJobData );
 862
 863     // set/clear backwards compatibility flag
 864     bool bStrictSO52Compatibility = false;
 865     std::hash_map<rtl::OUString, rtl::OUString, rtl::OUStringHash >::const_iterator compat_it =
 866         pJobSetup->maValueMap.find( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StrictSO52Compatibility" ) ) );
 867     if( compat_it != pJobSetup->maValueMap.end() )
 868     {
 869         if( compat_it->second.equalsIgnoreAsciiCaseAscii( "true" ) )
 870             bStrictSO52Compatibility = true;
 871     }
 872     m_aPrinterGfx.setStrictSO52Compatibility( bStrictSO52Compatibility );
 873
 874     return m_aPrintJob.StartJob( m_aTmpFile.Len() ? m_aTmpFile : m_aFileName, nMode, rJobName, rAppName, m_aJobData, &m_aPrinterGfx, false ) ? TRUE : FALSE;
 875 }
 876
 877 // -----------------------------------------------------------------------
 878
 879 BOOL PspSalPrinter::EndJob()
 880 {
 881     BOOL bSuccess = m_aPrintJob.EndJob();
 882
 883     if( bSuccess )
 884     {
 885         // check for fax
 886         if( m_bFax )
 887         {
 888
 889             const PrinterInfo& rInfo( PrinterInfoManager::get().getPrinterInfo( m_aJobData.m_aPrinterName ) );
 890             // sendAFax removes the file after use
 891             bSuccess = sendAFax( m_aFaxNr, m_aTmpFile, rInfo.m_aCommand );
 892         }
 893         else if( m_bPdf )
 894         {
 895             const PrinterInfo& rInfo( PrinterInfoManager::get().getPrinterInfo( m_aJobData.m_aPrinterName ) );
 896             bSuccess = createPdf( m_aFileName, m_aTmpFile, rInfo.m_aCommand );
 897         }
 898     }
 899     vcl_sal::PrinterUpdate::jobEnded();
 900     return bSuccess;
 901 }
 902
 903 // -----------------------------------------------------------------------
 904
 905 BOOL PspSalPrinter::AbortJob()
 906 {
 907     BOOL bAbort = m_aPrintJob.AbortJob() ? TRUE : FALSE;
 908     vcl_sal::PrinterUpdate::jobEnded();
 909     return bAbort;
 910 }
 911
 912 // -----------------------------------------------------------------------
 913
 914 SalGraphics* PspSalPrinter::StartPage( ImplJobSetup* pJobSetup, BOOL )
 915 {
 916     JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, m_aJobData );
 917     m_pGraphics = new PspGraphics( &m_aJobData, &m_aPrinterGfx, m_bFax ? &m_aFaxNr : NULL, m_bSwallowFaxNo, m_pInfoPrinter  );
 918     m_pGraphics->SetLayout( 0 );
 919     if( m_nCopies > 1 )
 920         // in case user did not do anything (m_nCopies=1)
 921         // take the default from jobsetup
 922         m_aJobData.m_nCopies = m_nCopies;
 923
 924     m_aPrintJob.StartPage( m_aJobData );
 925     m_aPrinterGfx.Init( m_aPrintJob );
 926
 927     return m_pGraphics;
 928 }
 929
 930 // -----------------------------------------------------------------------
 931
 932 BOOL PspSalPrinter::EndPage()
 933 {
 934     sal_Bool bResult = m_aPrintJob.EndPage();
 935     m_aPrinterGfx.Clear();
 936     return bResult ? TRUE : FALSE;
 937 }
 938
 939 // -----------------------------------------------------------------------
 940
 941 ULONG PspSalPrinter::GetErrorCode()
 942 {
 943     return 0;
 944 }
 945
 946 /*
 947  *  vcl::PrinterUpdate
 948  */
 949
 950 Timer* vcl_sal::PrinterUpdate::pPrinterUpdateTimer = NULL;
 951 int vcl_sal::PrinterUpdate::nActiveJobs = 0;
 952
 953 void vcl_sal::PrinterUpdate::doUpdate()
 954 {
 955     ::psp::PrinterInfoManager& rManager( ::psp::PrinterInfoManager::get() );
 956     if( rManager.checkPrintersChanged( false ) && SvpSalInstance::s_pDefaultInstance )
 957     {
 958         const std::list< SalFrame* >& rList = SvpSalInstance::s_pDefaultInstance->getFrames();
 959         for( std::list< SalFrame* >::const_iterator it = rList.begin();
 960              it != rList.end(); ++it )
 961              SvpSalInstance::s_pDefaultInstance->PostEvent( *it, NULL, SALEVENT_PRINTERCHANGED );
 962     }
 963 }
 964
 965 // -----------------------------------------------------------------------
 966
 967 IMPL_STATIC_LINK_NOINSTANCE( vcl_sal::PrinterUpdate, UpdateTimerHdl, void*, )
 968 {
 969     if( nActiveJobs < 1 )
 970     {
 971         doUpdate();
 972         delete pPrinterUpdateTimer;
 973         pPrinterUpdateTimer = NULL;
 974     }
 975     else
 976         pPrinterUpdateTimer->Start();
 977
 978     return 0;
 979 }
 980
 981 // -----------------------------------------------------------------------
 982
 983 void vcl_sal::PrinterUpdate::update()
 984 {
 985     if( Application::GetSettings().GetMiscSettings().GetDisablePrinting() )
 986         return;
 987
 988     static bool bOnce = false;
 989     if( ! bOnce )
 990     {
 991         bOnce = true;
 992         // start background printer detection
 993         psp::PrinterInfoManager::get();
 994         return;
 995     }
 996
 997     if( nActiveJobs < 1 )
 998         doUpdate();
 999     else if( ! pPrinterUpdateTimer )
1000     {
1001         pPrinterUpdateTimer = new Timer();
1002         pPrinterUpdateTimer->SetTimeout( 500 );
1003         pPrinterUpdateTimer->SetTimeoutHdl( STATIC_LINK( NULL, vcl_sal::PrinterUpdate, UpdateTimerHdl ) );
1004         pPrinterUpdateTimer->Start();
1005     }
1006 }
1007
1008 // -----------------------------------------------------------------------
1009
1010 void vcl_sal::PrinterUpdate::jobEnded()
1011 {
1012     nActiveJobs--;
1013     if( nActiveJobs < 1 )
1014     {
1015         if( pPrinterUpdateTimer )
1016         {
1017             pPrinterUpdateTimer->Stop();
1018             delete pPrinterUpdateTimer;
1019             pPrinterUpdateTimer = NULL;
1020             doUpdate();
1021         }
1022     }
1023 }