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