1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_vcl.hxx"
26
27 /**
28 this file implements the sal printer interface ( SalPrinter, SalInfoPrinter
29 and some printer relevant methods of SalInstance and SalGraphicsData )
30
31 as aunderlying library the printer features of psprint are used.
32
33 The query methods of a SalInfoPrinter are implemented by querying psprint
34
35 The job methods of a SalPrinter are implemented by calling psprint
36 printer job functions.
37 */
38
39 #include <unistd.h>
40 #include <sys/wait.h>
41 #include <sys/stat.h>
42
43 #include "rtl/ustring.hxx"
44
45 #include "osl/module.h"
46
47 #include "vcl/svapp.hxx"
48 #include "vcl/print.hxx"
49 #include "vcl/pdfwriter.hxx"
50 #include "vcl/printerinfomanager.hxx"
51
52 #include <unx/salunx.h>
53 #include "unx/saldisp.hxx"
54 #include "unx/salinst.h"
55 #include "unx/salprn.h"
56 #include "unx/salframe.h"
57 #include "unx/pspgraphics.h"
58 #include "unx/saldata.hxx"
59
60 #include "jobset.h"
61 #include "print.h"
62 #include "salptype.hxx"
63
64 using namespace psp;
65 using namespace rtl;
66 using namespace com::sun::star;
67
68 /*
69 * static helpers
70 */
71
72 static oslModule driverLib = NULL;
73 extern "C"
74 {
75 typedef int(*setupFunction)(PrinterInfo&);
76 static setupFunction pSetupFunction = NULL;
77 typedef int(*faxFunction)(String&);
78 static faxFunction pFaxNrFunction = NULL;
79 }
80
getPdfDir(const PrinterInfo & rInfo)81 static String getPdfDir( const PrinterInfo& rInfo )
82 {
83 String aDir;
84 sal_Int32 nIndex = 0;
85 while( nIndex != -1 )
86 {
87 OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
88 if( ! aToken.compareToAscii( "pdf=", 4 ) )
89 {
90 sal_Int32 nPos = 0;
91 aDir = aToken.getToken( 1, '=', nPos );
92 if( ! aDir.Len() )
93 aDir = String( ByteString( getenv( "HOME" ) ), osl_getThreadTextEncoding() );
94 break;
95 }
96 }
97 return aDir;
98 }
99
getPaLib()100 static void getPaLib()
101 {
102 if( ! driverLib )
103 {
104 driverLib = osl_loadAsciiModuleRelative( (oslGenericFunction)getPaLib, _XSALSET_LIBNAME, SAL_LOADMODULE_DEFAULT );
105 if ( !driverLib )
106 {
107 return;
108 }
109
110 pSetupFunction = (setupFunction)osl_getAsciiFunctionSymbol( driverLib, "Sal_SetupPrinterDriver" );
111 if ( !pSetupFunction )
112 fprintf( stderr, "could not resolve Sal_SetupPrinterDriver\n" );
113
114 pFaxNrFunction = (faxFunction)osl_getAsciiFunctionSymbol( driverLib, "Sal_queryFaxNumber" );
115 if ( !pFaxNrFunction )
116 fprintf( stderr, "could not resolve Sal_queryFaxNumber\n" );
117 }
118 }
119
PtTo10Mu(int nPoints)120 inline int PtTo10Mu( int nPoints ) { return (int)((((double)nPoints)*35.27777778)+0.5); }
121
TenMuToPt(int nUnits)122 inline int TenMuToPt( int nUnits ) { return (int)((((double)nUnits)/35.27777778)+0.5); }
123
copyJobDataToJobSetup(ImplJobSetup * pJobSetup,JobData & rData)124 static void copyJobDataToJobSetup( ImplJobSetup* pJobSetup, JobData& rData )
125 {
126 pJobSetup->meOrientation = (Orientation)(rData.m_eOrientation == orientation::Landscape ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT);
127
128 // copy page size
129 String aPaper;
130 int width, height;
131
132 rData.m_aContext.getPageSize( aPaper, width, height );
133 pJobSetup->mePaperFormat = PaperInfo::fromPSName(OUStringToOString( aPaper, RTL_TEXTENCODING_ISO_8859_1 ));
134
135 pJobSetup->mnPaperWidth = 0;
136 pJobSetup->mnPaperHeight = 0;
137 if( pJobSetup->mePaperFormat == PAPER_USER )
138 {
139 // transform to 100dth mm
140 width = PtTo10Mu( width );
141 height = PtTo10Mu( height );
142
143 if( rData.m_eOrientation == psp::orientation::Portrait )
144 {
145 pJobSetup->mnPaperWidth = width;
146 pJobSetup->mnPaperHeight= height;
147 }
148 else
149 {
150 pJobSetup->mnPaperWidth = height;
151 pJobSetup->mnPaperHeight= width;
152 }
153 }
154
155 // copy input slot
156 const PPDKey* pKey = NULL;
157 const PPDValue* pValue = NULL;
158
159 pJobSetup->mnPaperBin = 0;
160 if( rData.m_pParser )
161 pKey = rData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) );
162 if( pKey )
163 pValue = rData.m_aContext.getValue( pKey );
164 if( pKey && pValue )
165 {
166 for( pJobSetup->mnPaperBin = 0;
167 pValue != pKey->getValue( pJobSetup->mnPaperBin ) &&
168 pJobSetup->mnPaperBin < pKey->countValues();
169 pJobSetup->mnPaperBin++ )
170 ;
171 if( pJobSetup->mnPaperBin >= pKey->countValues() )
172 pJobSetup->mnPaperBin = 0;
173 }
174
175 // copy duplex
176 pKey = NULL;
177 pValue = NULL;
178
179 pJobSetup->meDuplexMode = DUPLEX_UNKNOWN;
180 if( rData.m_pParser )
181 pKey = rData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Duplex" ) ) );
182 if( pKey )
183 pValue = rData.m_aContext.getValue( pKey );
184 if( pKey && pValue )
185 {
186 if( pValue->m_aOption.EqualsIgnoreCaseAscii( "None" ) ||
187 pValue->m_aOption.EqualsIgnoreCaseAscii( "Simplex", 0, 7 )
188 )
189 {
190 pJobSetup->meDuplexMode = DUPLEX_OFF;
191 }
192 else if( pValue->m_aOption.EqualsIgnoreCaseAscii( "DuplexNoTumble" ) )
193 {
194 pJobSetup->meDuplexMode = DUPLEX_LONGEDGE;
195 }
196 else if( pValue->m_aOption.EqualsIgnoreCaseAscii( "DuplexTumble" ) )
197 {
198 pJobSetup->meDuplexMode = DUPLEX_SHORTEDGE;
199 }
200 }
201
202 // copy the whole context
203 if( pJobSetup->mpDriverData )
204 rtl_freeMemory( pJobSetup->mpDriverData );
205
206 int nBytes;
207 void* pBuffer = NULL;
208 if( rData.getStreamBuffer( pBuffer, nBytes ) )
209 {
210 pJobSetup->mnDriverDataLen = nBytes;
211 pJobSetup->mpDriverData = (sal_uInt8*)pBuffer;
212 }
213 else
214 {
215 pJobSetup->mnDriverDataLen = 0;
216 pJobSetup->mpDriverData = NULL;
217 }
218 }
219
passFileToCommandLine(const String & rFilename,const String & rCommandLine,bool bRemoveFile=true)220 static bool passFileToCommandLine( const String& rFilename, const String& rCommandLine, bool bRemoveFile = true )
221 {
222 bool bSuccess = false;
223
224 rtl_TextEncoding aEncoding = osl_getThreadTextEncoding();
225 ByteString aCmdLine( rCommandLine, aEncoding );
226 ByteString aFilename( rFilename, aEncoding );
227
228 bool bPipe = aCmdLine.Search( "(TMP)" ) != STRING_NOTFOUND ? false : true;
229
230 // setup command line for exec
231 if( ! bPipe )
232 while( aCmdLine.SearchAndReplace( "(TMP)", aFilename ) != STRING_NOTFOUND )
233 ;
234
235 #if OSL_DEBUG_LEVEL > 1
236 fprintf( stderr, "%s commandline: \"%s\"\n",
237 bPipe ? "piping to" : "executing",
238 aCmdLine.GetBuffer() );
239 struct stat aStat;
240 if( stat( aFilename.GetBuffer(), &aStat ) )
241 fprintf( stderr, "stat( %s ) failed\n", aFilename.GetBuffer() );
242 fprintf( stderr, "Tmp file %s has modes: 0%03lo\n", aFilename.GetBuffer(), (long)aStat.st_mode );
243 #endif
244 const char* argv[4];
245 if( ! ( argv[ 0 ] = getenv( "SHELL" ) ) )
246 argv[ 0 ] = "/bin/sh";
247 argv[ 1 ] = "-c";
248 argv[ 2 ] = aCmdLine.GetBuffer();
249 argv[ 3 ] = 0;
250
251 bool bHavePipes = false;
252 int pid, fd[2];
253
254 if( bPipe )
255 bHavePipes = pipe( fd ) ? false : true;
256 if( ( pid = fork() ) > 0 )
257 {
258 if( bPipe && bHavePipes )
259 {
260 close( fd[0] );
261 char aBuffer[ 2048 ];
262 FILE* fp = fopen( aFilename.GetBuffer(), "r" );
263 while( fp && ! feof( fp ) )
264 {
265 int nBytes = fread( aBuffer, 1, sizeof( aBuffer ), fp );
266 if( nBytes )
267 write( fd[ 1 ], aBuffer, nBytes );
268 }
269 fclose( fp );
270 close( fd[ 1 ] );
271 }
272 int status = 0;
273 waitpid( pid, &status, 0 );
274 if( ! status )
275 bSuccess = true;
276 }
277 else if( ! pid )
278 {
279 if( bPipe && bHavePipes )
280 {
281 close( fd[1] );
282 if( fd[0] != STDIN_FILENO ) // not probable, but who knows :)
283 dup2( fd[0], STDIN_FILENO );
284 }
285 execv( argv[0], const_cast<char**>(argv) );
286 fprintf( stderr, "failed to execute \"%s\"\n", aCmdLine.GetBuffer() );
287 _exit( 1 );
288 }
289 else
290 fprintf( stderr, "failed to fork\n" );
291
292 // clean up the mess
293 if( bRemoveFile )
294 unlink( aFilename.GetBuffer() );
295
296 return bSuccess;
297 }
298
sendAFax(const String & rFaxNumber,const String & rFileName,const String & rCommand)299 static bool sendAFax( const String& rFaxNumber, const String& rFileName, const String& rCommand )
300 {
301 std::list< OUString > aFaxNumbers;
302
303 if( ! rFaxNumber.Len() )
304 {
305 getPaLib();
306 if( pFaxNrFunction )
307 {
308 String aNewNr;
309 if( pFaxNrFunction( aNewNr ) )
310 aFaxNumbers.push_back( OUString( aNewNr ) );
311 }
312 }
313 else
314 {
315 sal_Int32 nIndex = 0;
316 OUString aFaxes( rFaxNumber );
317 OUString aBeginToken( RTL_CONSTASCII_USTRINGPARAM("<Fax#>") );
318 OUString aEndToken( RTL_CONSTASCII_USTRINGPARAM("</Fax#>") );
319 while( nIndex != -1 )
320 {
321 nIndex = aFaxes.indexOf( aBeginToken, nIndex );
322 if( nIndex != -1 )
323 {
324 sal_Int32 nBegin = nIndex + aBeginToken.getLength();
325 nIndex = aFaxes.indexOf( aEndToken, nIndex );
326 if( nIndex != -1 )
327 {
328 aFaxNumbers.push_back( aFaxes.copy( nBegin, nIndex-nBegin ) );
329 nIndex += aEndToken.getLength();
330 }
331 }
332 }
333 }
334
335 bool bSuccess = true;
336 if( aFaxNumbers.begin() != aFaxNumbers.end() )
337 {
338 while( aFaxNumbers.begin() != aFaxNumbers.end() && bSuccess )
339 {
340 String aCmdLine( rCommand );
341 String aFaxNumber( aFaxNumbers.front() );
342 aFaxNumbers.pop_front();
343 while( aCmdLine.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "(PHONE)" ) ), aFaxNumber ) != STRING_NOTFOUND )
344 ;
345 #if OSL_DEBUG_LEVEL > 1
346 fprintf( stderr, "sending fax to \"%s\"\n", OUStringToOString( aFaxNumber, osl_getThreadTextEncoding() ).getStr() );
347 #endif
348 bSuccess = passFileToCommandLine( rFileName, aCmdLine, false );
349 }
350 }
351 else
352 bSuccess = false;
353
354 // clean up temp file
355 unlink( ByteString( rFileName, osl_getThreadTextEncoding() ).GetBuffer() );
356
357 return bSuccess;
358 }
359
createPdf(const String & rToFile,const String & rFromFile,const String & rCommandLine)360 static bool createPdf( const String& rToFile, const String& rFromFile, const String& rCommandLine )
361 {
362 String aCommandLine( rCommandLine );
363 while( aCommandLine.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "(OUTFILE)" ) ), rToFile ) != STRING_NOTFOUND )
364 ;
365 return passFileToCommandLine( rFromFile, aCommandLine );
366 }
367
368 /*
369 * SalInstance
370 */
371
372 // -----------------------------------------------------------------------
373
CreateInfoPrinter(SalPrinterQueueInfo * pQueueInfo,ImplJobSetup * pJobSetup)374 SalInfoPrinter* X11SalInstance::CreateInfoPrinter( SalPrinterQueueInfo* pQueueInfo,
375 ImplJobSetup* pJobSetup )
376 {
377 mbPrinterInit = true;
378 // create and initialize SalInfoPrinter
379 PspSalInfoPrinter* pPrinter = new PspSalInfoPrinter;
380
381 if( pJobSetup )
382 {
383 PrinterInfoManager& rManager( PrinterInfoManager::get() );
384 PrinterInfo aInfo( rManager.getPrinterInfo( pQueueInfo->maPrinterName ) );
385 pPrinter->m_aJobData = aInfo;
386 pPrinter->m_aPrinterGfx.Init( pPrinter->m_aJobData );
387
388 if( pJobSetup->mpDriverData )
389 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aInfo );
390
391 pJobSetup->mnSystem = JOBSETUP_SYSTEM_UNIX;
392 pJobSetup->maPrinterName = pQueueInfo->maPrinterName;
393 pJobSetup->maDriver = aInfo.m_aDriverName;
394 copyJobDataToJobSetup( pJobSetup, aInfo );
395
396 // set/clear backwards compatibility flag
397 bool bStrictSO52Compatibility = false;
398 std::hash_map<rtl::OUString, rtl::OUString, rtl::OUStringHash >::const_iterator compat_it =
399 pJobSetup->maValueMap.find( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StrictSO52Compatibility" ) ) );
400
401 if( compat_it != pJobSetup->maValueMap.end() )
402 {
403 if( compat_it->second.equalsIgnoreAsciiCaseAscii( "true" ) )
404 bStrictSO52Compatibility = true;
405 }
406 pPrinter->m_aPrinterGfx.setStrictSO52Compatibility( bStrictSO52Compatibility );
407 }
408
409
410 return pPrinter;
411 }
412
413 // -----------------------------------------------------------------------
414
DestroyInfoPrinter(SalInfoPrinter * pPrinter)415 void X11SalInstance::DestroyInfoPrinter( SalInfoPrinter* pPrinter )
416 {
417 delete pPrinter;
418 }
419
420 // -----------------------------------------------------------------------
421
CreatePrinter(SalInfoPrinter * pInfoPrinter)422 SalPrinter* X11SalInstance::CreatePrinter( SalInfoPrinter* pInfoPrinter )
423 {
424 mbPrinterInit = true;
425 // create and initialize SalPrinter
426 PspSalPrinter* pPrinter = new PspSalPrinter( pInfoPrinter );
427 pPrinter->m_aJobData = static_cast<PspSalInfoPrinter*>(pInfoPrinter)->m_aJobData;
428
429 return pPrinter;
430 }
431
432 // -----------------------------------------------------------------------
433
DestroyPrinter(SalPrinter * pPrinter)434 void X11SalInstance::DestroyPrinter( SalPrinter* pPrinter )
435 {
436 delete pPrinter;
437 }
438
439 // -----------------------------------------------------------------------
440
GetPrinterQueueInfo(ImplPrnQueueList * pList)441 void X11SalInstance::GetPrinterQueueInfo( ImplPrnQueueList* pList )
442 {
443 mbPrinterInit = true;
444 PrinterInfoManager& rManager( PrinterInfoManager::get() );
445 static const char* pNoSyncDetection = getenv( "SAL_DISABLE_SYNCHRONOUS_PRINTER_DETECTION" );
446 if( ! pNoSyncDetection || ! *pNoSyncDetection )
447 {
448 // #i62663# synchronize possible asynchronouse printer detection now
449 rManager.checkPrintersChanged( true );
450 }
451 ::std::list< OUString > aPrinters;
452 rManager.listPrinters( aPrinters );
453
454 for( ::std::list< OUString >::iterator it = aPrinters.begin(); it != aPrinters.end(); ++it )
455 {
456 const PrinterInfo& rInfo( rManager.getPrinterInfo( *it ) );
457 // Neuen Eintrag anlegen
458 SalPrinterQueueInfo* pInfo = new SalPrinterQueueInfo;
459 pInfo->maPrinterName = *it;
460 pInfo->maDriver = rInfo.m_aDriverName;
461 pInfo->maLocation = rInfo.m_aLocation;
462 pInfo->maComment = rInfo.m_aComment;
463 pInfo->mpSysData = NULL;
464
465 sal_Int32 nIndex = 0;
466 while( nIndex != -1 )
467 {
468 String aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
469 if( aToken.CompareToAscii( "pdf=", 4 ) == COMPARE_EQUAL )
470 {
471 pInfo->maLocation = getPdfDir( rInfo );
472 break;
473 }
474 }
475
476 pList->Add( pInfo );
477 }
478 }
479
480 // -----------------------------------------------------------------------
481
DeletePrinterQueueInfo(SalPrinterQueueInfo * pInfo)482 void X11SalInstance::DeletePrinterQueueInfo( SalPrinterQueueInfo* pInfo )
483 {
484 delete pInfo;
485 }
486
487 // -----------------------------------------------------------------------
488
GetPrinterQueueState(SalPrinterQueueInfo *)489 void X11SalInstance::GetPrinterQueueState( SalPrinterQueueInfo* )
490 {
491 mbPrinterInit = true;
492 }
493
494 // -----------------------------------------------------------------------
495
GetDefaultPrinter()496 String X11SalInstance::GetDefaultPrinter()
497 {
498 mbPrinterInit = true;
499 PrinterInfoManager& rManager( PrinterInfoManager::get() );
500 return rManager.getDefaultPrinter();
501 }
502
503 // =======================================================================
504
PspSalInfoPrinter()505 PspSalInfoPrinter::PspSalInfoPrinter()
506 {
507 m_pGraphics = NULL;
508 m_bPapersInit = false;
509 }
510
511 // -----------------------------------------------------------------------
512
~PspSalInfoPrinter()513 PspSalInfoPrinter::~PspSalInfoPrinter()
514 {
515 if( m_pGraphics )
516 {
517 delete m_pGraphics;
518 m_pGraphics = NULL;
519 }
520 }
521
522 // -----------------------------------------------------------------------
523
InitPaperFormats(const ImplJobSetup *)524 void PspSalInfoPrinter::InitPaperFormats( const ImplJobSetup* )
525 {
526 m_aPaperFormats.clear();
527 m_bPapersInit = true;
528
529 if( m_aJobData.m_pParser )
530 {
531 const PPDKey* pKey = m_aJobData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) ) );
532 if( pKey )
533 {
534 int nValues = pKey->countValues();
535 for( int i = 0; i < nValues; i++ )
536 {
537 const PPDValue* pValue = pKey->getValue( i );
538 int nWidth = 0, nHeight = 0;
539 m_aJobData.m_pParser->getPaperDimension( pValue->m_aOption, nWidth, nHeight );
540 PaperInfo aInfo(PtTo10Mu( nWidth ), PtTo10Mu( nHeight ));
541 m_aPaperFormats.push_back( aInfo );
542 }
543 }
544 }
545 }
546
547 // -----------------------------------------------------------------------
548
GetLandscapeAngle(const ImplJobSetup *)549 int PspSalInfoPrinter::GetLandscapeAngle( const ImplJobSetup* )
550 {
551 return 900;
552 }
553
554 // -----------------------------------------------------------------------
555
GetGraphics()556 SalGraphics* PspSalInfoPrinter::GetGraphics()
557 {
558 // return a valid pointer only once
559 // the reasoning behind this is that we could have different
560 // SalGraphics that can run in multiple threads
561 // (future plans)
562 SalGraphics* pRet = NULL;
563 if( ! m_pGraphics )
564 {
565 m_pGraphics = new PspGraphics( &m_aJobData, &m_aPrinterGfx, NULL, false, this );
566 m_pGraphics->SetLayout( 0 );
567 pRet = m_pGraphics;
568 }
569 return pRet;
570 }
571
572 // -----------------------------------------------------------------------
573
ReleaseGraphics(SalGraphics * pGraphics)574 void PspSalInfoPrinter::ReleaseGraphics( SalGraphics* pGraphics )
575 {
576 if( pGraphics == m_pGraphics )
577 {
578 delete pGraphics;
579 m_pGraphics = NULL;
580 }
581 return;
582 }
583
584 // -----------------------------------------------------------------------
585
Setup(SalFrame * pFrame,ImplJobSetup * pJobSetup)586 sal_Bool PspSalInfoPrinter::Setup( SalFrame* pFrame, ImplJobSetup* pJobSetup )
587 {
588 if( ! pFrame || ! pJobSetup )
589 return sal_False;
590
591 getPaLib();
592
593 if( ! pSetupFunction )
594 return sal_False;
595
596 PrinterInfoManager& rManager = PrinterInfoManager::get();
597
598 PrinterInfo aInfo( rManager.getPrinterInfo( pJobSetup->maPrinterName ) );
599 if ( pJobSetup->mpDriverData )
600 {
601 SetData( ~0, pJobSetup );
602 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aInfo );
603 }
604
605 if( pSetupFunction( aInfo ) )
606 {
607 rtl_freeMemory( pJobSetup->mpDriverData );
608 pJobSetup->mpDriverData = NULL;
609
610 int nBytes;
611 void* pBuffer = NULL;
612 aInfo.getStreamBuffer( pBuffer, nBytes );
613 pJobSetup->mnDriverDataLen = nBytes;
614 pJobSetup->mpDriverData = (sal_uInt8*)pBuffer;
615
616 // copy everything to job setup
617 copyJobDataToJobSetup( pJobSetup, aInfo );
618 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, m_aJobData );
619 return sal_True;
620 }
621 return sal_False;
622 }
623
624 // -----------------------------------------------------------------------
625
626 // This function gets the driver data and puts it into pJobSetup
627 // If pJobSetup->mpDriverData is NOT NULL, then the independend
628 // data should be merged into the driver data
629 // If pJobSetup->mpDriverData IS NULL, then the driver defaults
630 // should be merged into the independent data
SetPrinterData(ImplJobSetup * pJobSetup)631 sal_Bool PspSalInfoPrinter::SetPrinterData( ImplJobSetup* pJobSetup )
632 {
633 // set/clear backwards compatibility flag
634 bool bStrictSO52Compatibility = false;
635 std::hash_map<rtl::OUString, rtl::OUString, rtl::OUStringHash >::const_iterator compat_it =
636 pJobSetup->maValueMap.find( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StrictSO52Compatibility" ) ) );
637
638 if( compat_it != pJobSetup->maValueMap.end() )
639 {
640 if( compat_it->second.equalsIgnoreAsciiCaseAscii( "true" ) )
641 bStrictSO52Compatibility = true;
642 }
643 m_aPrinterGfx.setStrictSO52Compatibility( bStrictSO52Compatibility );
644
645 if( pJobSetup->mpDriverData )
646 return SetData( ~0, pJobSetup );
647
648 copyJobDataToJobSetup( pJobSetup, m_aJobData );
649
650 return sal_True;
651 }
652
653 // -----------------------------------------------------------------------
654
655 // This function merges the independ driver data
656 // and sets the new independ data in pJobSetup
657 // Only the data must be changed, where the bit
658 // in nGetDataFlags is set
SetData(sal_uLong nSetDataFlags,ImplJobSetup * pJobSetup)659 sal_Bool PspSalInfoPrinter::SetData(
660 sal_uLong nSetDataFlags,
661 ImplJobSetup* pJobSetup )
662 {
663 JobData aData;
664 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
665
666 if( aData.m_pParser )
667 {
668 const PPDKey* pKey;
669 const PPDValue* pValue;
670
671 // merge papersize if necessary
672 if( nSetDataFlags & SAL_JOBSET_PAPERSIZE )
673 {
674 int nWidth, nHeight;
675 if( pJobSetup->meOrientation == ORIENTATION_PORTRAIT )
676 {
677 nWidth = pJobSetup->mnPaperWidth;
678 nHeight = pJobSetup->mnPaperHeight;
679 }
680 else
681 {
682 nWidth = pJobSetup->mnPaperHeight;
683 nHeight = pJobSetup->mnPaperWidth;
684 }
685 String aPaper;
686
687 if( pJobSetup->mePaperFormat == PAPER_USER )
688 aPaper = aData.m_pParser->matchPaper(
689 TenMuToPt( pJobSetup->mnPaperWidth ),
690 TenMuToPt( pJobSetup->mnPaperHeight ) );
691 else
692 aPaper = rtl::OStringToOUString(PaperInfo::toPSName(pJobSetup->mePaperFormat), RTL_TEXTENCODING_ISO_8859_1);
693
694 pKey = aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "PageSize" ) ) );
695 pValue = pKey ? pKey->getValueCaseInsensitive( aPaper ) : NULL;
696
697 // some PPD files do not specify the standard paper names (e.g. C5 instead of EnvC5)
698 // try to find the correct paper anyway using the size
699 if( pKey && ! pValue && pJobSetup->mePaperFormat != PAPER_USER )
700 {
701 PaperInfo aInfo( pJobSetup->mePaperFormat );
702 aPaper = aData.m_pParser->matchPaper(
703 TenMuToPt( aInfo.getWidth() ),
704 TenMuToPt( aInfo.getHeight() ) );
705 pValue = pKey->getValueCaseInsensitive( aPaper );
706 }
707
708 if( ! ( pKey && pValue && aData.m_aContext.setValue( pKey, pValue, false ) == pValue ) )
709 return sal_False;
710 }
711
712 // merge paperbin if necessary
713 if( nSetDataFlags & SAL_JOBSET_PAPERBIN )
714 {
715 pKey = aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) );
716 if( pKey )
717 {
718 int nPaperBin = pJobSetup->mnPaperBin;
719 if( nPaperBin >= pKey->countValues() )
720 pValue = pKey->getDefaultValue();
721 else
722 pValue = pKey->getValue( pJobSetup->mnPaperBin );
723
724 // may fail due to constraints;
725 // real paper bin is copied back to jobsetup in that case
726 aData.m_aContext.setValue( pKey, pValue );
727 }
728 // if printer has no InputSlot key simply ignore this setting
729 // (e.g. SGENPRT has no InputSlot)
730 }
731
732 // merge orientation if necessary
733 if( nSetDataFlags & SAL_JOBSET_ORIENTATION )
734 aData.m_eOrientation = pJobSetup->meOrientation == ORIENTATION_LANDSCAPE ? orientation::Landscape : orientation::Portrait;
735
736 // merge duplex if necessary
737 if( nSetDataFlags & SAL_JOBSET_DUPLEXMODE )
738 {
739 pKey = aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Duplex" ) ) );
740 if( pKey )
741 {
742 pValue = NULL;
743 switch( pJobSetup->meDuplexMode )
744 {
745 case DUPLEX_OFF:
746 pValue = pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "None" ) ) );
747 if( pValue == NULL )
748 pValue = pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "SimplexNoTumble" ) ) );
749 break;
750 case DUPLEX_SHORTEDGE:
751 pValue = pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "DuplexTumble" ) ) );
752 break;
753 case DUPLEX_LONGEDGE:
754 pValue = pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "DuplexNoTumble" ) ) );
755 break;
756 case DUPLEX_UNKNOWN:
757 default:
758 pValue = 0;
759 break;
760 }
761 if( ! pValue )
762 pValue = pKey->getDefaultValue();
763 aData.m_aContext.setValue( pKey, pValue );
764 }
765 }
766
767 m_aJobData = aData;
768 copyJobDataToJobSetup( pJobSetup, aData );
769 return sal_True;
770 }
771
772 return sal_False;
773 }
774
775 // -----------------------------------------------------------------------
776
GetPageInfo(const ImplJobSetup * pJobSetup,long & rOutWidth,long & rOutHeight,long & rPageOffX,long & rPageOffY,long & rPageWidth,long & rPageHeight)777 void PspSalInfoPrinter::GetPageInfo(
778 const ImplJobSetup* pJobSetup,
779 long& rOutWidth, long& rOutHeight,
780 long& rPageOffX, long& rPageOffY,
781 long& rPageWidth, long& rPageHeight )
782 {
783 if( ! pJobSetup )
784 return;
785
786 JobData aData;
787 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
788
789 // get the selected page size
790 if( aData.m_pParser )
791 {
792
793 String aPaper;
794 int width, height;
795 int left = 0, top = 0, right = 0, bottom = 0;
796 int nDPI = aData.m_aContext.getRenderResolution();
797
798
799 if( aData.m_eOrientation == psp::orientation::Portrait )
800 {
801 aData.m_aContext.getPageSize( aPaper, width, height );
802 aData.m_pParser->getMargins( aPaper, left, right, top, bottom );
803 }
804 else
805 {
806 aData.m_aContext.getPageSize( aPaper, height, width );
807 aData.m_pParser->getMargins( aPaper, top, bottom, right, left );
808 }
809
810 rPageWidth = width * nDPI / 72;
811 rPageHeight = height * nDPI / 72;
812 rPageOffX = left * nDPI / 72;
813 rPageOffY = top * nDPI / 72;
814 rOutWidth = ( width - left - right ) * nDPI / 72;
815 rOutHeight = ( height - top - bottom ) * nDPI / 72;
816 }
817 }
818
819 // -----------------------------------------------------------------------
820
GetPaperBinCount(const ImplJobSetup * pJobSetup)821 sal_uLong PspSalInfoPrinter::GetPaperBinCount( const ImplJobSetup* pJobSetup )
822 {
823 if( ! pJobSetup )
824 return 0;
825
826 JobData aData;
827 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
828
829 const PPDKey* pKey = aData.m_pParser ? aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) ): NULL;
830 return pKey ? pKey->countValues() : 0;
831 }
832
833 // -----------------------------------------------------------------------
834
GetPaperBinName(const ImplJobSetup * pJobSetup,sal_uLong nPaperBin)835 String PspSalInfoPrinter::GetPaperBinName( const ImplJobSetup* pJobSetup, sal_uLong nPaperBin )
836 {
837 JobData aData;
838 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
839
840 String aRet;
841 if( aData.m_pParser )
842 {
843 const PPDKey* pKey = aData.m_pParser ? aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "InputSlot" ) ) ): NULL;
844 if( ! pKey || nPaperBin >= (sal_uLong)pKey->countValues() )
845 aRet = aData.m_pParser->getDefaultInputSlot();
846 else
847 {
848 const PPDValue* pValue = pKey->getValue( nPaperBin );
849 if( pValue )
850 aRet = aData.m_pParser->translateOption( pKey->getKey(), pValue->m_aOption );
851 }
852 }
853
854 return aRet;
855 }
856
857 // -----------------------------------------------------------------------
858
GetCapabilities(const ImplJobSetup * pJobSetup,sal_uInt16 nType)859 sal_uLong PspSalInfoPrinter::GetCapabilities( const ImplJobSetup* pJobSetup, sal_uInt16 nType )
860 {
861 switch( nType )
862 {
863 case PRINTER_CAPABILITIES_SUPPORTDIALOG:
864 return 1;
865 case PRINTER_CAPABILITIES_COPIES:
866 return 0xffff;
867 case PRINTER_CAPABILITIES_COLLATECOPIES:
868 {
869 // see if the PPD contains a value to set Collate to True
870 JobData aData;
871 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
872
873 const PPDKey* pKey = aData.m_pParser ? aData.m_pParser->getKey( String( RTL_CONSTASCII_USTRINGPARAM( "Collate" ) ) ) : NULL;
874 const PPDValue* pVal = pKey ? pKey->getValue( String( RTL_CONSTASCII_USTRINGPARAM( "True" ) ) ) : NULL;
875
876 // PPDs don't mention the number of possible collated copies.
877 // so let's guess as many as we want ?
878 return pVal ? 0xffff : 0;
879 }
880 case PRINTER_CAPABILITIES_SETORIENTATION:
881 return 1;
882 case PRINTER_CAPABILITIES_SETDUPLEX:
883 return 1;
884 case PRINTER_CAPABILITIES_SETPAPERBIN:
885 return 1;
886 case PRINTER_CAPABILITIES_SETPAPERSIZE:
887 return 1;
888 case PRINTER_CAPABILITIES_SETPAPER:
889 return 0;
890 case PRINTER_CAPABILITIES_FAX:
891 return PrinterInfoManager::get().checkFeatureToken( pJobSetup->maPrinterName, "fax" ) ? 1 : 0;
892 case PRINTER_CAPABILITIES_PDF:
893 if( PrinterInfoManager::get().checkFeatureToken( pJobSetup->maPrinterName, "pdf" ) )
894 return 1;
895 else
896 {
897 // see if the PPD contains a value to set Collate to True
898 JobData aData = PrinterInfoManager::get().getPrinterInfo( pJobSetup->maPrinterName );
899 if( pJobSetup->mpDriverData )
900 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
901 return aData.m_nPDFDevice > 0 ? 1 : 0;
902 }
903 case PRINTER_CAPABILITIES_EXTERNALDIALOG:
904 return PrinterInfoManager::get().checkFeatureToken( pJobSetup->maPrinterName, "external_dialog" ) ? 1 : 0;
905 case PRINTER_CAPABILITIES_USEPULLMODEL:
906 {
907 // see if the PPD contains a value to set Collate to True
908 JobData aData = PrinterInfoManager::get().getPrinterInfo( pJobSetup->maPrinterName );
909 if( pJobSetup->mpDriverData )
910 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, aData );
911 return aData.m_nPDFDevice > 0 ? 1 : 0;
912 }
913 default: break;
914 };
915 return 0;
916 }
917
918 // =======================================================================
919
920 /*
921 * SalPrinter
922 */
923
PspSalPrinter(SalInfoPrinter * pInfoPrinter)924 PspSalPrinter::PspSalPrinter( SalInfoPrinter* pInfoPrinter )
925 : m_bFax( false ),
926 m_bPdf( false ),
927 m_bSwallowFaxNo( false ),
928 m_bIsPDFWriterJob( false ),
929 m_pGraphics( NULL ),
930 m_nCopies( 1 ),
931 m_bCollate( false ),
932 m_pInfoPrinter( pInfoPrinter )
933 {
934 }
935
936 // -----------------------------------------------------------------------
937
~PspSalPrinter()938 PspSalPrinter::~PspSalPrinter()
939 {
940 }
941
942 // -----------------------------------------------------------------------
943
getTmpName()944 static String getTmpName()
945 {
946 rtl::OUString aTmp, aSys;
947 osl_createTempFile( NULL, NULL, &aTmp.pData );
948 osl_getSystemPathFromFileURL( aTmp.pData, &aSys.pData );
949
950 return aSys;
951 }
952
StartJob(const XubString * pFileName,const XubString & rJobName,const XubString & rAppName,sal_uLong nCopies,bool bCollate,bool bDirect,ImplJobSetup * pJobSetup)953 sal_Bool PspSalPrinter::StartJob(
954 const XubString* pFileName,
955 const XubString& rJobName,
956 const XubString& rAppName,
957 sal_uLong nCopies,
958 bool bCollate,
959 bool bDirect,
960 ImplJobSetup* pJobSetup )
961 {
962 vcl_sal::PrinterUpdate::jobStarted();
963
964 m_bFax = false;
965 m_bPdf = false;
966 m_aFileName = pFileName ? *pFileName : String();
967 m_aTmpFile = String();
968 m_nCopies = nCopies;
969 m_bCollate = bCollate;
970
971 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, m_aJobData );
972 if( m_nCopies > 1 )
973 {
974 // in case user did not do anything (m_nCopies=1)
975 // take the default from jobsetup
976 m_aJobData.m_nCopies = m_nCopies;
977 m_aJobData.setCollate( bCollate );
978 }
979
980 // check whether this printer is configured as fax
981 int nMode = 0;
982 const PrinterInfo& rInfo( PrinterInfoManager::get().getPrinterInfo( m_aJobData.m_aPrinterName ) );
983 sal_Int32 nIndex = 0;
984 while( nIndex != -1 )
985 {
986 OUString aToken( rInfo.m_aFeatures.getToken( 0, ',', nIndex ) );
987 if( ! aToken.compareToAscii( "fax", 3 ) )
988 {
989 m_bFax = true;
990 m_aTmpFile = getTmpName();
991 nMode = S_IRUSR | S_IWUSR;
992
993 ::std::hash_map< ::rtl::OUString, ::rtl::OUString, ::rtl::OUStringHash >::const_iterator it;
994 it = pJobSetup->maValueMap.find( ::rtl::OUString::createFromAscii( "FAX#" ) );
995 if( it != pJobSetup->maValueMap.end() )
996 m_aFaxNr = it->second;
997
998 sal_Int32 nPos = 0;
999 m_bSwallowFaxNo = ! aToken.getToken( 1, '=', nPos ).compareToAscii( "swallow", 7 ) ? true : false;
1000
1001 break;
1002 }
1003 if( ! aToken.compareToAscii( "pdf=", 4 ) )
1004 {
1005 m_bPdf = true;
1006 m_aTmpFile = getTmpName();
1007 nMode = S_IRUSR | S_IWUSR;
1008
1009 if( ! m_aFileName.Len() )
1010 {
1011 m_aFileName = getPdfDir( rInfo );
1012 m_aFileName.Append( '/' );
1013 m_aFileName.Append( rJobName );
1014 m_aFileName.AppendAscii( ".pdf" );
1015 }
1016 break;
1017 }
1018 }
1019 m_aPrinterGfx.Init( m_aJobData );
1020
1021 // set/clear backwards compatibility flag
1022 bool bStrictSO52Compatibility = false;
1023 std::hash_map<rtl::OUString, rtl::OUString, rtl::OUStringHash >::const_iterator compat_it =
1024 pJobSetup->maValueMap.find( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "StrictSO52Compatibility" ) ) );
1025
1026 if( compat_it != pJobSetup->maValueMap.end() )
1027 {
1028 if( compat_it->second.equalsIgnoreAsciiCaseAscii( "true" ) )
1029 bStrictSO52Compatibility = true;
1030 }
1031 m_aPrinterGfx.setStrictSO52Compatibility( bStrictSO52Compatibility );
1032
1033 return m_aPrintJob.StartJob( m_aTmpFile.Len() ? m_aTmpFile : m_aFileName, nMode, rJobName, rAppName, m_aJobData, &m_aPrinterGfx, bDirect ) ? sal_True : sal_False;
1034 }
1035
1036 // -----------------------------------------------------------------------
1037
EndJob()1038 sal_Bool PspSalPrinter::EndJob()
1039 {
1040 sal_Bool bSuccess = sal_False;
1041 if( m_bIsPDFWriterJob )
1042 bSuccess = sal_True;
1043 else
1044 {
1045 bSuccess = m_aPrintJob.EndJob();
1046
1047 if( bSuccess )
1048 {
1049 // check for fax
1050 if( m_bFax )
1051 {
1052
1053 const PrinterInfo& rInfo( PrinterInfoManager::get().getPrinterInfo( m_aJobData.m_aPrinterName ) );
1054 // sendAFax removes the file after use
1055 bSuccess = sendAFax( m_aFaxNr, m_aTmpFile, rInfo.m_aCommand );
1056 }
1057 else if( m_bPdf )
1058 {
1059 const PrinterInfo& rInfo( PrinterInfoManager::get().getPrinterInfo( m_aJobData.m_aPrinterName ) );
1060 bSuccess = createPdf( m_aFileName, m_aTmpFile, rInfo.m_aCommand );
1061 }
1062 }
1063 }
1064 vcl_sal::PrinterUpdate::jobEnded();
1065 return bSuccess;
1066 }
1067
1068 // -----------------------------------------------------------------------
1069
AbortJob()1070 sal_Bool PspSalPrinter::AbortJob()
1071 {
1072 sal_Bool bAbort = m_aPrintJob.AbortJob() ? sal_True : sal_False;
1073 vcl_sal::PrinterUpdate::jobEnded();
1074 return bAbort;
1075 }
1076
1077 // -----------------------------------------------------------------------
1078
StartPage(ImplJobSetup * pJobSetup,sal_Bool)1079 SalGraphics* PspSalPrinter::StartPage( ImplJobSetup* pJobSetup, sal_Bool )
1080 {
1081 JobData::constructFromStreamBuffer( pJobSetup->mpDriverData, pJobSetup->mnDriverDataLen, m_aJobData );
1082 m_pGraphics = new PspGraphics( &m_aJobData, &m_aPrinterGfx, m_bFax ? &m_aFaxNr : NULL, m_bSwallowFaxNo, m_pInfoPrinter );
1083 m_pGraphics->SetLayout( 0 );
1084 if( m_nCopies > 1 )
1085 {
1086 // in case user did not do anything (m_nCopies=1)
1087 // take the default from jobsetup
1088 m_aJobData.m_nCopies = m_nCopies;
1089 m_aJobData.setCollate( m_nCopies > 1 && m_bCollate );
1090 }
1091
1092 m_aPrintJob.StartPage( m_aJobData );
1093 m_aPrinterGfx.Init( m_aPrintJob );
1094
1095 return m_pGraphics;
1096 }
1097
1098 // -----------------------------------------------------------------------
1099
EndPage()1100 sal_Bool PspSalPrinter::EndPage()
1101 {
1102 sal_Bool bResult = m_aPrintJob.EndPage();
1103 m_aPrinterGfx.Clear();
1104 return bResult ? sal_True : sal_False;
1105 }
1106
1107 // -----------------------------------------------------------------------
1108
GetErrorCode()1109 sal_uLong PspSalPrinter::GetErrorCode()
1110 {
1111 return 0;
1112 }
1113
1114 // -----------------------------------------------------------------------
1115
1116 struct PDFNewJobParameters
1117 {
1118 Size maPageSize;
1119 sal_uInt16 mnPaperBin;
1120
PDFNewJobParametersPDFNewJobParameters1121 PDFNewJobParameters( const Size& i_rSize = Size(),
1122 sal_uInt16 i_nPaperBin = 0xffff )
1123 : maPageSize( i_rSize ), mnPaperBin( i_nPaperBin ) {}
1124
operator !=PDFNewJobParameters1125 bool operator!=(const PDFNewJobParameters& rComp ) const
1126 {
1127 Size aCompLSSize( rComp.maPageSize.Height(), rComp.maPageSize.Width() );
1128 return
1129 (maPageSize != rComp.maPageSize && maPageSize != aCompLSSize)
1130 || mnPaperBin != rComp.mnPaperBin
1131 ;
1132 }
1133
operator ==PDFNewJobParameters1134 bool operator==(const PDFNewJobParameters& rComp) const
1135 {
1136 return ! this->operator!=(rComp);
1137 }
1138 };
1139
1140 struct PDFPrintFile
1141 {
1142 rtl::OUString maTmpURL;
1143 PDFNewJobParameters maParameters;
1144
PDFPrintFilePDFPrintFile1145 PDFPrintFile( const rtl::OUString& i_rURL, const PDFNewJobParameters& i_rNewParameters )
1146 : maTmpURL( i_rURL )
1147 , maParameters( i_rNewParameters ) {}
1148 };
1149
StartJob(const String * i_pFileName,const String & i_rJobName,const String & i_rAppName,ImplJobSetup * i_pSetupData,vcl::PrinterController & i_rController)1150 sal_Bool PspSalPrinter::StartJob( const String* i_pFileName, const String& i_rJobName, const String& i_rAppName,
1151 ImplJobSetup* i_pSetupData, vcl::PrinterController& i_rController )
1152 {
1153 OSL_TRACE( "StartJob with controller: pFilename = %s", i_pFileName ? rtl::OUStringToOString( *i_pFileName, RTL_TEXTENCODING_UTF8 ).getStr() : "<nil>" );
1154 // mark for endjob
1155 m_bIsPDFWriterJob = true;
1156 // reset IsLastPage
1157 i_rController.setLastPage( sal_False );
1158
1159 // update job data
1160 if( i_pSetupData )
1161 JobData::constructFromStreamBuffer( i_pSetupData->mpDriverData, i_pSetupData->mnDriverDataLen, m_aJobData );
1162
1163 OSL_ASSERT( m_aJobData.m_nPDFDevice > 0 );
1164 m_aJobData.m_nPDFDevice = 1;
1165
1166 // possibly create one job for collated output
1167 sal_Bool bSinglePrintJobs = sal_False;
1168 beans::PropertyValue* pSingleValue = i_rController.getValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintCollateAsSingleJobs" ) ) );
1169 if( pSingleValue )
1170 {
1171 pSingleValue->Value >>= bSinglePrintJobs;
1172 }
1173
1174 int nCopies = i_rController.getPrinter()->GetCopyCount();
1175 bool bCollate = i_rController.getPrinter()->IsCollateCopy();
1176
1177 // notify start of real print job
1178 i_rController.jobStarted();
1179
1180 // setup PDFWriter context
1181 vcl::PDFWriter::PDFWriterContext aContext;
1182 aContext.Version = vcl::PDFWriter::PDF_1_4;
1183 aContext.Tagged = false;
1184 aContext.EmbedStandardFonts = true;
1185 aContext.DocumentLocale = Application::GetSettings().GetLocale();
1186 aContext.ColorMode = i_rController.getPrinter()->GetPrinterOptions().IsConvertToGreyscales()
1187 ? vcl::PDFWriter::DrawGreyscale : vcl::PDFWriter::DrawColor;
1188
1189 // prepare doc info
1190 aContext.DocumentInfo.Title = i_rJobName;
1191 aContext.DocumentInfo.Creator = i_rAppName;
1192 aContext.DocumentInfo.Producer = i_rAppName;
1193
1194 // define how we handle metafiles in PDFWriter
1195 vcl::PDFWriter::PlayMetafileContext aMtfContext;
1196 aMtfContext.m_bOnlyLosslessCompression = true;
1197
1198 boost::shared_ptr<vcl::PDFWriter> pWriter;
1199 std::vector< PDFPrintFile > aPDFFiles;
1200 boost::shared_ptr<Printer> pPrinter( i_rController.getPrinter() );
1201 int nAllPages = i_rController.getFilteredPageCount();
1202 i_rController.createProgressDialog();
1203 bool bAborted = false;
1204 PDFNewJobParameters aLastParm;
1205
1206 aContext.DPIx = pPrinter->ImplGetDPIX();
1207 aContext.DPIy = pPrinter->ImplGetDPIY();
1208 for( int nPage = 0; nPage < nAllPages && ! bAborted; nPage++ )
1209 {
1210 if( nPage == nAllPages-1 )
1211 i_rController.setLastPage( sal_True );
1212
1213 // get the page's metafile
1214 GDIMetaFile aPageFile;
1215 vcl::PrinterController::PageSize aPageSize = i_rController.getFilteredPageFile( nPage, aPageFile );
1216 if( i_rController.isProgressCanceled() )
1217 {
1218 bAborted = true;
1219 if( nPage != nAllPages-1 )
1220 {
1221 i_rController.createProgressDialog();
1222 i_rController.setLastPage( sal_True );
1223 i_rController.getFilteredPageFile( nPage, aPageFile );
1224 }
1225 }
1226 else
1227 {
1228 pPrinter->SetMapMode( MapMode( MAP_100TH_MM ) );
1229 pPrinter->SetPaperSizeUser( aPageSize.aSize, true );
1230 PDFNewJobParameters aNewParm( pPrinter->GetPaperSize(), pPrinter->GetPaperBin() );
1231
1232 // create PDF writer on demand
1233 // either on first page
1234 // or on paper format change - cups does not support multiple paper formats per job (yet?)
1235 // so we need to start a new job to get a new paper format from the printer
1236 // orientation switches (that is switch of height and width) is handled transparently by CUPS
1237 if( ! pWriter ||
1238 (aNewParm != aLastParm && ! i_pFileName ) )
1239 {
1240 if( pWriter )
1241 {
1242 pWriter->Emit();
1243 }
1244 // produce PDF file
1245 OUString aPDFUrl;
1246 if( i_pFileName )
1247 aPDFUrl = *i_pFileName;
1248 else
1249 osl_createTempFile( NULL, NULL, &aPDFUrl.pData );
1250 // normalize to file URL
1251 if( aPDFUrl.compareToAscii( "file:", 5 ) != 0 )
1252 {
1253 // this is not a file URL, but it should
1254 // form it into a osl friendly file URL
1255 rtl::OUString aTmp;
1256 osl_getFileURLFromSystemPath( aPDFUrl.pData, &aTmp.pData );
1257 aPDFUrl = aTmp;
1258 }
1259 // save current file and paper format
1260 aLastParm = aNewParm;
1261 aPDFFiles.push_back( PDFPrintFile( aPDFUrl, aNewParm ) );
1262 // update context
1263 aContext.URL = aPDFUrl;
1264
1265 // create and initialize PDFWriter
1266 #if defined __SUNPRO_CC
1267 #pragma disable_warn
1268 #endif
1269 pWriter.reset( new vcl::PDFWriter( aContext, uno::Reference< beans::XMaterialHolder >() ) );
1270 #if defined __SUNPRO_CC
1271 #pragma enable_warn
1272 #endif
1273 }
1274
1275 pWriter->NewPage( TenMuToPt( aNewParm.maPageSize.Width() ),
1276 TenMuToPt( aNewParm.maPageSize.Height() ),
1277 vcl::PDFWriter::Portrait );
1278
1279 pWriter->PlayMetafile( aPageFile, aMtfContext, NULL );
1280 }
1281 }
1282
1283 // emit the last file
1284 if( pWriter )
1285 pWriter->Emit();
1286
1287 // handle collate, copy count and multiple jobs correctly
1288 int nOuterJobs = 1;
1289 if( bSinglePrintJobs )
1290 {
1291 nOuterJobs = nCopies;
1292 m_aJobData.m_nCopies = 1;
1293 }
1294 else
1295 {
1296 if( bCollate )
1297 {
1298 if( aPDFFiles.size() == 1 && pPrinter->HasSupport( SUPPORT_COLLATECOPY ) )
1299 {
1300 m_aJobData.setCollate( true );
1301 m_aJobData.m_nCopies = nCopies;
1302 }
1303 else
1304 {
1305 nOuterJobs = nCopies;
1306 m_aJobData.m_nCopies = 1;
1307 }
1308 }
1309 else
1310 {
1311 m_aJobData.setCollate( false );
1312 m_aJobData.m_nCopies = nCopies;
1313 }
1314 }
1315
1316 // spool files
1317 if( ! i_pFileName && ! bAborted )
1318 {
1319 bool bFirstJob = true;
1320 for( int nCurJob = 0; nCurJob < nOuterJobs; nCurJob++ )
1321 {
1322 for( size_t i = 0; i < aPDFFiles.size(); i++ )
1323 {
1324 oslFileHandle pFile = NULL;
1325 osl_openFile( aPDFFiles[i].maTmpURL.pData, &pFile, osl_File_OpenFlag_Read );
1326 if( pFile )
1327 {
1328 osl_setFilePos( pFile, osl_Pos_Absolut, 0 );
1329 std::vector< char > buffer( 0x10000, 0 );
1330 // update job data with current page size
1331 Size aPageSize( aPDFFiles[i].maParameters.maPageSize );
1332 m_aJobData.setPaper( TenMuToPt( aPageSize.Width() ), TenMuToPt( aPageSize.Height() ) );
1333 // update job data with current paperbin
1334 m_aJobData.setPaperBin( aPDFFiles[i].maParameters.mnPaperBin );
1335
1336 // spool current file
1337 FILE* fp = PrinterInfoManager::get().startSpool( pPrinter->GetName(), i_rController.isDirectPrint() );
1338 if( fp )
1339 {
1340 sal_uInt64 nBytesRead = 0;
1341 do
1342 {
1343 osl_readFile( pFile, &buffer[0], buffer.size(), &nBytesRead );
1344 if( nBytesRead > 0 )
1345 fwrite( &buffer[0], 1, nBytesRead, fp );
1346 } while( nBytesRead == buffer.size() );
1347 rtl::OUStringBuffer aBuf( i_rJobName.Len() + 8 );
1348 aBuf.append( i_rJobName );
1349 if( i > 0 || nCurJob > 0 )
1350 {
1351 aBuf.append( sal_Unicode(' ') );
1352 aBuf.append( sal_Int32( i + nCurJob * aPDFFiles.size() ) );
1353 }
1354 PrinterInfoManager::get().endSpool( pPrinter->GetName(), aBuf.makeStringAndClear(), fp, m_aJobData, bFirstJob );
1355 bFirstJob = false;
1356 }
1357 }
1358 osl_closeFile( pFile );
1359 }
1360 }
1361 }
1362
1363 // job has been spooled
1364 i_rController.setJobState( bAborted ? view::PrintableState_JOB_ABORTED : view::PrintableState_JOB_SPOOLED );
1365
1366 // clean up the temporary PDF files
1367 if( ! i_pFileName || bAborted )
1368 {
1369 for( size_t i = 0; i < aPDFFiles.size(); i++ )
1370 {
1371 osl_removeFile( aPDFFiles[i].maTmpURL.pData );
1372 OSL_TRACE( "removed print PDF file %s\n", rtl::OUStringToOString( aPDFFiles[i].maTmpURL, RTL_TEXTENCODING_UTF8 ).getStr() );
1373 }
1374 }
1375
1376 return sal_True;
1377 }
1378
1379
1380
1381 /*
1382 * vcl::PrinterUpdate
1383 */
1384
1385 Timer* vcl_sal::PrinterUpdate::pPrinterUpdateTimer = NULL;
1386 int vcl_sal::PrinterUpdate::nActiveJobs = 0;
1387
doUpdate()1388 void vcl_sal::PrinterUpdate::doUpdate()
1389 {
1390 ::psp::PrinterInfoManager& rManager( ::psp::PrinterInfoManager::get() );
1391 if( rManager.checkPrintersChanged( false ) )
1392 {
1393 SalDisplay* pDisp = GetX11SalData()->GetDisplay();
1394 const std::list< SalFrame* >& rList = pDisp->getFrames();
1395 for( std::list< SalFrame* >::const_iterator it = rList.begin();
1396 it != rList.end(); ++it )
1397 pDisp->SendInternalEvent( *it, NULL, SALEVENT_PRINTERCHANGED );
1398 }
1399 }
1400
1401 // -----------------------------------------------------------------------
1402
IMPL_STATIC_LINK_NOINSTANCE(vcl_sal::PrinterUpdate,UpdateTimerHdl,void *,EMPTYARG)1403 IMPL_STATIC_LINK_NOINSTANCE( vcl_sal::PrinterUpdate, UpdateTimerHdl, void*, EMPTYARG )
1404 {
1405 if( nActiveJobs < 1 )
1406 {
1407 doUpdate();
1408 delete pPrinterUpdateTimer;
1409 pPrinterUpdateTimer = NULL;
1410 }
1411 else
1412 pPrinterUpdateTimer->Start();
1413
1414 return 0;
1415 }
1416
1417 // -----------------------------------------------------------------------
1418
update()1419 void vcl_sal::PrinterUpdate::update()
1420 {
1421 if( Application::GetSettings().GetMiscSettings().GetDisablePrinting() )
1422 return;
1423
1424 if( ! static_cast< X11SalInstance* >(GetSalData()->m_pInstance)->isPrinterInit() )
1425 {
1426 // #i45389# start background printer detection
1427 psp::PrinterInfoManager::get();
1428 return;
1429 }
1430
1431 if( nActiveJobs < 1 )
1432 doUpdate();
1433 else if( ! pPrinterUpdateTimer )
1434 {
1435 pPrinterUpdateTimer = new Timer();
1436 pPrinterUpdateTimer->SetTimeout( 500 );
1437 pPrinterUpdateTimer->SetTimeoutHdl( STATIC_LINK( NULL, vcl_sal::PrinterUpdate, UpdateTimerHdl ) );
1438 pPrinterUpdateTimer->Start();
1439 }
1440 }
1441
1442 // -----------------------------------------------------------------------
1443
jobEnded()1444 void vcl_sal::PrinterUpdate::jobEnded()
1445 {
1446 nActiveJobs--;
1447 if( nActiveJobs < 1 )
1448 {
1449 if( pPrinterUpdateTimer )
1450 {
1451 pPrinterUpdateTimer->Stop();
1452 delete pPrinterUpdateTimer;
1453 pPrinterUpdateTimer = NULL;
1454 doUpdate();
1455 }
1456 }
1457 }
1458