Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsmaprenderertask.h
3 : : -------------------------
4 : : begin : Apr 2017
5 : : copyright : (C) 2017 by Mathieu Pellerin
6 : : email : nirvn dot asia at gmail dot com
7 : : ***************************************************************************/
8 : :
9 : : /***************************************************************************
10 : : * *
11 : : * This program is free software; you can redistribute it and/or modify *
12 : : * it under the terms of the GNU General Public License as published by *
13 : : * the Free Software Foundation; either version 2 of the License, or *
14 : : * (at your option) any later version. *
15 : : * *
16 : : ***************************************************************************/
17 : :
18 : : #include "qgsannotation.h"
19 : : #include "qgsannotationmanager.h"
20 : : #include "qgsmaprenderertask.h"
21 : : #include "qgsmapsettingsutils.h"
22 : : #include "qgsogrutils.h"
23 : : #include "qgslogger.h"
24 : : #include "qgsabstractgeopdfexporter.h"
25 : : #include "qgsmaprendererstagedrenderjob.h"
26 : : #include "qgsrenderedfeaturehandlerinterface.h"
27 : : #include "qgsfeaturerequest.h"
28 : : #include "qgsvectorlayer.h"
29 : :
30 : : #include <QFile>
31 : : #include <QTextStream>
32 : : #include <QTimeZone>
33 : : #ifndef QT_NO_PRINTER
34 : : #include <QPrinter>
35 : : #endif
36 : :
37 : : #include "gdal.h"
38 : : #include "cpl_conv.h"
39 : :
40 : : ///@cond PRIVATE
41 : :
42 : 0 : class QgsMapRendererTaskGeoPdfExporter : public QgsAbstractGeoPdfExporter
43 : : {
44 : :
45 : : public:
46 : :
47 : 0 : QgsMapRendererTaskGeoPdfExporter( const QgsMapSettings &ms )
48 : 0 : {
49 : : // collect details upfront, while we are still in the main thread
50 : 0 : const QList< QgsMapLayer * > layers = ms.layers();
51 : 0 : for ( const QgsMapLayer *layer : layers )
52 : : {
53 : 0 : VectorComponentDetail detail;
54 : 0 : detail.name = layer->name();
55 : 0 : detail.mapLayerId = layer->id();
56 : 0 : if ( const QgsVectorLayer *vl = qobject_cast< const QgsVectorLayer * >( layer ) )
57 : : {
58 : 0 : detail.displayAttribute = vl->displayField();
59 : 0 : }
60 : 0 : mLayerDetails[ layer->id() ] = detail;
61 : 0 : }
62 : 0 : }
63 : :
64 : : private:
65 : :
66 : 0 : QgsAbstractGeoPdfExporter::VectorComponentDetail componentDetailForLayerId( const QString &layerId ) override
67 : : {
68 : 0 : return mLayerDetails.value( layerId );
69 : 0 : }
70 : :
71 : : QMap< QString, VectorComponentDetail > mLayerDetails;
72 : : };
73 : :
74 : :
75 : 0 : class QgsMapRendererTaskRenderedFeatureHandler : public QgsRenderedFeatureHandlerInterface
76 : : {
77 : : public:
78 : :
79 : 0 : QgsMapRendererTaskRenderedFeatureHandler( QgsMapRendererTaskGeoPdfExporter *exporter, const QgsMapSettings &settings )
80 : 0 : : mExporter( exporter )
81 : 0 : , mMapSettings( settings )
82 : 0 : {
83 : : // PDF coordinate space uses a hardcoded DPI of 72, also vertical dimension is flipped from QGIS dimension
84 : 0 : const double pageHeightPdfUnits = settings.outputSize().height() * 72.0 / settings.outputDpi();
85 : 0 : mTransform = QTransform::fromTranslate( 0, pageHeightPdfUnits ).scale( 72.0 / mMapSettings.outputDpi(), -72.0 / mMapSettings.outputDpi() );
86 : 0 : }
87 : :
88 : 0 : void handleRenderedFeature( const QgsFeature &feature, const QgsGeometry &renderedBounds, const QgsRenderedFeatureHandlerInterface::RenderedFeatureContext &context ) override
89 : : {
90 : : // is it a hack retrieving the layer ID from an expression context like this? possibly... BUT
91 : : // the alternative is adding a layer ID member to QgsRenderContext, and that's just asking for people to abuse it
92 : : // and use it to retrieve QgsMapLayers mid-way through a render operation. Lesser of two evils it is!
93 : 0 : const QString layerId = context.renderContext.expressionContext().variable( QStringLiteral( "layer_id" ) ).toString();
94 : :
95 : 0 : QgsGeometry transformed = renderedBounds;
96 : 0 : transformed.transform( mTransform );
97 : :
98 : : // always convert to multitype, to make things consistent
99 : 0 : transformed.convertToMultiType();
100 : :
101 : 0 : mExporter->pushRenderedFeature( layerId, QgsAbstractGeoPdfExporter::RenderedFeature( feature, transformed ) );
102 : 0 : }
103 : :
104 : 0 : QSet<QString> usedAttributes( QgsVectorLayer *, const QgsRenderContext & ) const override
105 : : {
106 : 0 : return QSet< QString >() << QgsFeatureRequest::ALL_ATTRIBUTES;
107 : 0 : }
108 : :
109 : : private:
110 : :
111 : : QgsMapRendererTaskGeoPdfExporter *mExporter = nullptr;
112 : : QgsMapSettings mMapSettings;
113 : : //! Transform from output space (pixels) to PDF space (pixels at 72 dpi)
114 : : QTransform mTransform;
115 : :
116 : : };
117 : :
118 : : ///@endcond
119 : :
120 : 0 : QgsMapRendererTask::QgsMapRendererTask( const QgsMapSettings &ms, const QString &fileName, const QString &fileFormat, const bool forceRaster,
121 : : const bool geoPDF, const QgsAbstractGeoPdfExporter::ExportDetails &geoPdfExportDetails )
122 : 0 : : QgsTask( fileFormat == QLatin1String( "PDF" ) ? tr( "Saving as PDF" ) : tr( "Saving as image" ) )
123 : 0 : , mMapSettings( ms )
124 : 0 : , mFileName( fileName )
125 : 0 : , mFileFormat( fileFormat )
126 : 0 : , mForceRaster( forceRaster )
127 : 0 : , mGeoPDF( geoPDF && mFileFormat == QLatin1String( "PDF" ) && QgsAbstractGeoPdfExporter::geoPDFCreationAvailable() )
128 : 0 : , mGeoPdfExportDetails( geoPdfExportDetails )
129 : 0 : {
130 : 0 : prepare();
131 : 0 : }
132 : :
133 : 0 : QgsMapRendererTask::QgsMapRendererTask( const QgsMapSettings &ms, QPainter *p )
134 : 0 : : QgsTask( tr( "Rendering to painter" ) )
135 : 0 : , mMapSettings( ms )
136 : 0 : , mPainter( p )
137 : 0 : {
138 : 0 : prepare();
139 : 0 : }
140 : 0 :
141 : 0 : QgsMapRendererTask::~QgsMapRendererTask() = default;
142 : :
143 : 0 : void QgsMapRendererTask::addAnnotations( const QList< QgsAnnotation * > &annotations )
144 : : {
145 : 0 : qDeleteAll( mAnnotations );
146 : 0 : mAnnotations.clear();
147 : :
148 : 0 : const auto constAnnotations = annotations;
149 : 0 : for ( const QgsAnnotation *a : constAnnotations )
150 : : {
151 : 0 : mAnnotations << a->clone();
152 : 0 : }
153 : 0 : }
154 : 0 :
155 : 0 : void QgsMapRendererTask::addDecorations( const QList< QgsMapDecoration * > &decorations )
156 : : {
157 : 0 : mDecorations = decorations;
158 : 0 : }
159 : :
160 : :
161 : 0 : void QgsMapRendererTask::cancel()
162 : 0 : {
163 : 0 : mJobMutex.lock();
164 : 0 : if ( mJob )
165 : 0 : mJob->cancelWithoutBlocking();
166 : 0 : mJobMutex.unlock();
167 : :
168 : 0 : QgsTask::cancel();
169 : 0 : }
170 : :
171 : 0 : bool QgsMapRendererTask::run()
172 : : {
173 : 0 : if ( mErrored )
174 : 0 : return false;
175 : :
176 : 0 : if ( mGeoPDF )
177 : : {
178 : : #ifdef QT_NO_PRINTER
179 : : return false;
180 : : #else
181 : 0 : QList< QgsAbstractGeoPdfExporter::ComponentLayerDetail > pdfComponents;
182 : :
183 : 0 : QgsMapRendererStagedRenderJob *job = static_cast< QgsMapRendererStagedRenderJob * >( mJob.get() );
184 : 0 : int outputLayer = 1;
185 : 0 : while ( !job->isFinished() )
186 : : {
187 : 0 : QgsAbstractGeoPdfExporter::ComponentLayerDetail component;
188 : :
189 : 0 : component.name = QStringLiteral( "layer_%1" ).arg( outputLayer );
190 : 0 : component.mapLayerId = job->currentLayerId();
191 : 0 : component.opacity = job->currentLayerOpacity();
192 : 0 : component.compositionMode = job->currentLayerCompositionMode();
193 : 0 : component.sourcePdfPath = mGeoPdfExporter->generateTemporaryFilepath( QStringLiteral( "layer_%1.pdf" ).arg( outputLayer ) );
194 : 0 : pdfComponents << component;
195 : :
196 : 0 : QPrinter printer;
197 : 0 : printer.setOutputFileName( component.sourcePdfPath );
198 : 0 : printer.setOutputFormat( QPrinter::PdfFormat );
199 : 0 : printer.setOrientation( QPrinter::Portrait );
200 : : // paper size needs to be given in millimeters in order to be able to set a resolution to pass onto the map renderer
201 : 0 : QSizeF outputSize = mMapSettings.outputSize();
202 : 0 : printer.setPaperSize( outputSize * 25.4 / mMapSettings.outputDpi(), QPrinter::Millimeter );
203 : 0 : printer.setPageMargins( 0, 0, 0, 0, QPrinter::Millimeter );
204 : 0 : printer.setResolution( mMapSettings.outputDpi() );
205 : :
206 : 0 : QPainter p( &printer );
207 : 0 : job->renderCurrentPart( &p );
208 : 0 : p.end();
209 : :
210 : 0 : outputLayer++;
211 : 0 : job->nextPart();
212 : 0 : }
213 : 0 : QgsAbstractGeoPdfExporter::ExportDetails exportDetails = mGeoPdfExportDetails;
214 : 0 : const double pageWidthMM = mMapSettings.outputSize().width() * 25.4 / mMapSettings.outputDpi();
215 : 0 : const double pageHeightMM = mMapSettings.outputSize().height() * 25.4 / mMapSettings.outputDpi();
216 : 0 : exportDetails.pageSizeMm = QSizeF( pageWidthMM, pageHeightMM );
217 : 0 : exportDetails.dpi = mMapSettings.outputDpi();
218 : :
219 : 0 : exportDetails.layerIdToPdfLayerTreeNameMap = mLayerIdToLayerNameMap;
220 : 0 : exportDetails.layerOrder = mMapLayerOrder;
221 : :
222 : 0 : if ( mSaveWorldFile )
223 : : {
224 : : // setup georeferencing
225 : 0 : QgsAbstractGeoPdfExporter::GeoReferencedSection georef;
226 : 0 : georef.crs = mMapSettings.destinationCrs();
227 : 0 : georef.pageBoundsMm = QgsRectangle( 0, 0, pageWidthMM, pageHeightMM );
228 : 0 : georef.controlPoints.reserve( 4 );
229 : 0 : georef.controlPoints << QgsAbstractGeoPdfExporter::ControlPoint( QgsPointXY( 0, 0 ), mMapSettings.mapToPixel().toMapCoordinates( 0, 0 ) );
230 : 0 : georef.controlPoints << QgsAbstractGeoPdfExporter::ControlPoint( QgsPointXY( pageWidthMM, 0 ), mMapSettings.mapToPixel().toMapCoordinates( mMapSettings.outputSize().width(), 0 ) );
231 : 0 : georef.controlPoints << QgsAbstractGeoPdfExporter::ControlPoint( QgsPointXY( pageWidthMM, pageHeightMM ), mMapSettings.mapToPixel().toMapCoordinates( mMapSettings.outputSize().width(), mMapSettings.outputSize().height() ) );
232 : 0 : georef.controlPoints << QgsAbstractGeoPdfExporter::ControlPoint( QgsPointXY( 0, pageHeightMM ), mMapSettings.mapToPixel().toMapCoordinates( 0, mMapSettings.outputSize().height() ) );
233 : 0 : exportDetails.georeferencedSections << georef;
234 : 0 : }
235 : :
236 : 0 : const bool res = mGeoPdfExporter->finalize( pdfComponents, mFileName, exportDetails );
237 : 0 : mGeoPdfExporter.reset();
238 : 0 : mTempPainter.reset();
239 : 0 : mPrinter.reset();
240 : 0 : return res;
241 : : #endif
242 : 0 : }
243 : : else
244 : 0 : static_cast< QgsMapRendererCustomPainterJob *>( mJob.get() )->renderPrepared();
245 : :
246 : 0 : mJobMutex.lock();
247 : 0 : mJob.reset( nullptr );
248 : 0 : mJobMutex.unlock();
249 : :
250 : 0 : if ( isCanceled() )
251 : 0 : return false;
252 : :
253 : 0 : QgsRenderContext context = QgsRenderContext::fromMapSettings( mMapSettings );
254 : 0 : context.setPainter( mDestPainter );
255 : :
256 : 0 : const auto constMDecorations = mDecorations;
257 : 0 : for ( QgsMapDecoration *decoration : constMDecorations )
258 : : {
259 : 0 : decoration->render( mMapSettings, context );
260 : : }
261 : :
262 : 0 : const auto constMAnnotations = mAnnotations;
263 : 0 : for ( QgsAnnotation *annotation : constMAnnotations )
264 : : {
265 : 0 : if ( isCanceled() )
266 : 0 : return false;
267 : :
268 : 0 : if ( !annotation || !annotation->isVisible() )
269 : : {
270 : 0 : continue;
271 : : }
272 : 0 : if ( annotation->mapLayer() && !mMapSettings.layers().contains( annotation->mapLayer() ) )
273 : : {
274 : 0 : continue;
275 : : }
276 : :
277 : 0 : QgsScopedQPainterState painterState( context.painter() );
278 : 0 : context.setPainterFlagsUsingContext();
279 : :
280 : : double itemX, itemY;
281 : 0 : if ( annotation->hasFixedMapPosition() )
282 : : {
283 : 0 : itemX = mMapSettings.outputSize().width() * ( annotation->mapPosition().x() - mMapSettings.extent().xMinimum() ) / mMapSettings.extent().width();
284 : 0 : itemY = mMapSettings.outputSize().height() * ( 1 - ( annotation->mapPosition().y() - mMapSettings.extent().yMinimum() ) / mMapSettings.extent().height() );
285 : 0 : }
286 : : else
287 : : {
288 : 0 : itemX = annotation->relativePosition().x() * mMapSettings.outputSize().width();
289 : 0 : itemY = annotation->relativePosition().y() * mMapSettings.outputSize().height();
290 : : }
291 : :
292 : 0 : context.painter()->translate( itemX, itemY );
293 : :
294 : 0 : annotation->render( context );
295 : 0 : }
296 : :
297 : 0 : if ( !mFileName.isEmpty() )
298 : : {
299 : 0 : mDestPainter->end();
300 : :
301 : 0 : if ( mFileFormat == QLatin1String( "PDF" ) )
302 : : {
303 : : #ifndef QT_NO_PRINTER
304 : 0 : if ( mForceRaster )
305 : : {
306 : 0 : QPainter pp;
307 : 0 : pp.begin( mPrinter.get() );
308 : 0 : QRectF rect( 0, 0, mImage.width(), mImage.height() );
309 : 0 : pp.drawImage( rect, mImage, rect );
310 : 0 : pp.end();
311 : 0 : }
312 : :
313 : 0 : if ( mSaveWorldFile || mExportMetadata )
314 : : {
315 : 0 : CPLSetThreadLocalConfigOption( "GDAL_PDF_DPI", QString::number( mMapSettings.outputDpi() ).toLocal8Bit().constData() );
316 : 0 : gdal::dataset_unique_ptr outputDS( GDALOpen( mFileName.toLocal8Bit().constData(), GA_Update ) );
317 : 0 : if ( outputDS )
318 : : {
319 : 0 : if ( mSaveWorldFile )
320 : : {
321 : : double a, b, c, d, e, f;
322 : 0 : QgsMapSettingsUtils::worldFileParameters( mMapSettings, a, b, c, d, e, f );
323 : 0 : c -= 0.5 * a;
324 : 0 : c -= 0.5 * b;
325 : 0 : f -= 0.5 * d;
326 : 0 : f -= 0.5 * e;
327 : 0 : double geoTransform[6] = { c, a, b, f, d, e };
328 : 0 : GDALSetGeoTransform( outputDS.get(), geoTransform );
329 : 0 : GDALSetProjection( outputDS.get(), mMapSettings.destinationCrs().toWkt( QgsCoordinateReferenceSystem::WKT_PREFERRED_GDAL ).toLocal8Bit().constData() );
330 : 0 : }
331 : :
332 : 0 : if ( mExportMetadata )
333 : : {
334 : 0 : QString creationDateString;
335 : 0 : const QDateTime creationDateTime = mGeoPdfExportDetails.creationDateTime;
336 : 0 : if ( creationDateTime.isValid() )
337 : : {
338 : 0 : creationDateString = QStringLiteral( "D:%1" ).arg( mGeoPdfExportDetails.creationDateTime.toString( QStringLiteral( "yyyyMMddHHmmss" ) ) );
339 : 0 : if ( creationDateTime.timeZone().isValid() )
340 : : {
341 : 0 : int offsetFromUtc = creationDateTime.timeZone().offsetFromUtc( creationDateTime );
342 : 0 : creationDateString += ( offsetFromUtc >= 0 ) ? '+' : '-';
343 : 0 : offsetFromUtc = std::abs( offsetFromUtc );
344 : 0 : int offsetHours = offsetFromUtc / 3600;
345 : 0 : int offsetMins = ( offsetFromUtc % 3600 ) / 60;
346 : 0 : creationDateString += QStringLiteral( "%1'%2'" ).arg( offsetHours ).arg( offsetMins );
347 : 0 : }
348 : 0 : }
349 : 0 : GDALSetMetadataItem( outputDS.get(), "CREATION_DATE", creationDateString.toUtf8().constData(), nullptr );
350 : :
351 : 0 : GDALSetMetadataItem( outputDS.get(), "AUTHOR", mGeoPdfExportDetails.author.toUtf8().constData(), nullptr );
352 : 0 : const QString creator = QStringLiteral( "QGIS %1" ).arg( Qgis::version() );
353 : 0 : GDALSetMetadataItem( outputDS.get(), "CREATOR", creator.toUtf8().constData(), nullptr );
354 : 0 : GDALSetMetadataItem( outputDS.get(), "PRODUCER", creator.toUtf8().constData(), nullptr );
355 : 0 : GDALSetMetadataItem( outputDS.get(), "SUBJECT", mGeoPdfExportDetails.subject.toUtf8().constData(), nullptr );
356 : 0 : GDALSetMetadataItem( outputDS.get(), "TITLE", mGeoPdfExportDetails.title.toUtf8().constData(), nullptr );
357 : :
358 : 0 : const QgsAbstractMetadataBase::KeywordMap keywords = mGeoPdfExportDetails.keywords;
359 : 0 : QStringList allKeywords;
360 : 0 : for ( auto it = keywords.constBegin(); it != keywords.constEnd(); ++it )
361 : : {
362 : 0 : allKeywords.append( QStringLiteral( "%1: %2" ).arg( it.key(), it.value().join( ',' ) ) );
363 : 0 : }
364 : 0 : const QString keywordString = allKeywords.join( ';' );
365 : 0 : GDALSetMetadataItem( outputDS.get(), "KEYWORDS", keywordString.toUtf8().constData(), nullptr );
366 : 0 : }
367 : 0 : }
368 : 0 : CPLSetThreadLocalConfigOption( "GDAL_PDF_DPI", nullptr );
369 : 0 : }
370 : : #else
371 : : mError = ImageUnsupportedFormat;
372 : : return false;
373 : : #endif // !QT_NO_PRINTER
374 : 0 : }
375 : 0 : else if ( mFileFormat != QLatin1String( "PDF" ) )
376 : : {
377 : 0 : bool success = mImage.save( mFileName, mFileFormat.toLocal8Bit().data() );
378 : 0 : if ( !success )
379 : : {
380 : 0 : mError = ImageSaveFail;
381 : 0 : return false;
382 : : }
383 : :
384 : 0 : if ( mSaveWorldFile )
385 : : {
386 : 0 : QFileInfo info = QFileInfo( mFileName );
387 : :
388 : : // build the world file name
389 : 0 : QString outputSuffix = info.suffix();
390 : 0 : bool skipWorldFile = false;
391 : 0 : if ( outputSuffix == QLatin1String( "tif" ) || outputSuffix == QLatin1String( "tiff" ) )
392 : : {
393 : 0 : gdal::dataset_unique_ptr outputDS( GDALOpen( mFileName.toLocal8Bit().constData(), GA_Update ) );
394 : 0 : if ( outputDS )
395 : : {
396 : 0 : skipWorldFile = true;
397 : : double a, b, c, d, e, f;
398 : 0 : QgsMapSettingsUtils::worldFileParameters( mMapSettings, a, b, c, d, e, f );
399 : 0 : c -= 0.5 * a;
400 : 0 : c -= 0.5 * b;
401 : 0 : f -= 0.5 * d;
402 : 0 : f -= 0.5 * e;
403 : 0 : double geoTransform[] = { c, a, b, f, d, e };
404 : 0 : GDALSetGeoTransform( outputDS.get(), geoTransform );
405 : 0 : GDALSetProjection( outputDS.get(), mMapSettings.destinationCrs().toWkt( QgsCoordinateReferenceSystem::WKT_PREFERRED_GDAL ).toLocal8Bit().constData() );
406 : 0 : }
407 : 0 : }
408 : :
409 : 0 : if ( !skipWorldFile )
410 : : {
411 : 0 : QString worldFileName = info.absolutePath() + '/' + info.completeBaseName() + '.'
412 : 0 : + outputSuffix.at( 0 ) + outputSuffix.at( info.suffix().size() - 1 ) + 'w';
413 : 0 : QFile worldFile( worldFileName );
414 : :
415 : 0 : if ( worldFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) ) //don't use QIODevice::Text
416 : : {
417 : 0 : QTextStream stream( &worldFile );
418 : 0 : stream << QgsMapSettingsUtils::worldFileContent( mMapSettings );
419 : 0 : }
420 : 0 : }
421 : 0 : }
422 : 0 : }
423 : 0 : }
424 : :
425 : 0 : mTempPainter.reset();
426 : : #ifndef QT_NO_PRINTER
427 : 0 : mPrinter.reset();
428 : : #endif
429 : :
430 : 0 : return true;
431 : 0 : }
432 : :
433 : 0 : void QgsMapRendererTask::finished( bool result )
434 : : {
435 : 0 : qDeleteAll( mAnnotations );
436 : 0 : mAnnotations.clear();
437 : :
438 : 0 : if ( result )
439 : 0 : emit renderingComplete();
440 : : else
441 : 0 : emit errorOccurred( mError );
442 : 0 : }
443 : :
444 : 0 : void QgsMapRendererTask::prepare()
445 : : {
446 : 0 : if ( mGeoPDF )
447 : : {
448 : 0 : mGeoPdfExporter = std::make_unique< QgsMapRendererTaskGeoPdfExporter >( mMapSettings );
449 : 0 : if ( mGeoPdfExportDetails.includeFeatures )
450 : : {
451 : 0 : mRenderedFeatureHandler = std::make_unique< QgsMapRendererTaskRenderedFeatureHandler >( static_cast< QgsMapRendererTaskGeoPdfExporter * >( mGeoPdfExporter.get() ), mMapSettings );
452 : 0 : mMapSettings.addRenderedFeatureHandler( mRenderedFeatureHandler.get() );
453 : 0 : }
454 : :
455 : 0 : const QList< QgsMapLayer * > layers = mMapSettings.layers();
456 : 0 : for ( const QgsMapLayer *layer : layers )
457 : : {
458 : 0 : mLayerIdToLayerNameMap.insert( layer->id(), layer->name() );
459 : 0 : mMapLayerOrder << layer->id();
460 : : }
461 : :
462 : 0 : mJob.reset( new QgsMapRendererStagedRenderJob( mMapSettings, QgsMapRendererStagedRenderJob::RenderLabelsByMapLayer ) );
463 : 0 : mJob->start();
464 : : return;
465 : 0 : }
466 : :
467 : 0 : mDestPainter = mPainter;
468 : :
469 : 0 : if ( mFileFormat == QLatin1String( "PDF" ) )
470 : : {
471 : : #ifndef QT_NO_PRINTER
472 : 0 : mPrinter.reset( new QPrinter() );
473 : 0 : mPrinter->setOutputFileName( mFileName );
474 : 0 : mPrinter->setOutputFormat( QPrinter::PdfFormat );
475 : 0 : mPrinter->setOrientation( QPrinter::Portrait );
476 : : // paper size needs to be given in millimeters in order to be able to set a resolution to pass onto the map renderer
477 : 0 : QSizeF outputSize = mMapSettings.outputSize();
478 : 0 : mPrinter->setPaperSize( outputSize * 25.4 / mMapSettings.outputDpi(), QPrinter::Millimeter );
479 : 0 : mPrinter->setPageMargins( 0, 0, 0, 0, QPrinter::Millimeter );
480 : 0 : mPrinter->setResolution( mMapSettings.outputDpi() );
481 : :
482 : 0 : if ( !mForceRaster )
483 : : {
484 : 0 : mTempPainter.reset( new QPainter( mPrinter.get() ) );
485 : 0 : mDestPainter = mTempPainter.get();
486 : 0 : }
487 : : #else
488 : : mError = ImageUnsupportedFormat;
489 : : #endif // ! QT_NO_PRINTER
490 : 0 : }
491 : :
492 : 0 : if ( !mDestPainter )
493 : : {
494 : : // save rendered map to an image file
495 : 0 : mImage = QImage( mMapSettings.outputSize(), QImage::Format_ARGB32 );
496 : 0 : if ( mImage.isNull() )
497 : : {
498 : 0 : mErrored = true;
499 : 0 : mError = ImageAllocationFail;
500 : 0 : return;
501 : : }
502 : :
503 : 0 : mImage.setDotsPerMeterX( 1000 * mMapSettings.outputDpi() / 25.4 );
504 : 0 : mImage.setDotsPerMeterY( 1000 * mMapSettings.outputDpi() / 25.4 );
505 : :
506 : 0 : mTempPainter.reset( new QPainter( &mImage ) );
507 : 0 : mDestPainter = mTempPainter.get();
508 : 0 : }
509 : :
510 : 0 : if ( !mDestPainter )
511 : : {
512 : 0 : mErrored = true;
513 : 0 : return;
514 : : }
515 : :
516 : 0 : mJob.reset( new QgsMapRendererCustomPainterJob( mMapSettings, mDestPainter ) );
517 : 0 : static_cast< QgsMapRendererCustomPainterJob *>( mJob.get() )->prepare();
518 : 0 : }
|
