def savePdf(self):
"""
Save to pdf file
"""
fileName = QFileDialog.getSaveFileName(
self, 'Save to PDF', "", "PDF file (*.pdf);;All Files (*.*)")
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
printer = QPrinter(QPrinter.HighResolution)
printer.setPageSize(QPrinter.A4)
printer.setColorMode(QPrinter.Color)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(_filename)
doc = QTextDocument()
if self.toXml:
doc.setPlainText(self.txtEdit.text())
else:
doc.setHtml(self.txtEdit.toHtml())
doc.print_(printer)
def _exportCompositionAsPDF(self,composition,filePath):
"""
Render the composition as a PDF file.
"""
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filePath)
printer.setPaperSize(QSizeF(composition.paperWidth(),composition.paperHeight()),QPrinter.Millimeter)
printer.setFullPage(True)
printer.setColorMode(QPrinter.Color)
printer.setResolution(composition.printResolution())
#Use painter to send output to printer
pdfPainter = QPainter(printer)
paperRectMM = printer.pageRect(QPrinter.Millimeter)
paperRectPixel = printer.pageRect(QPrinter.DevicePixel)
composition.render(pdfPainter,paperRectPixel,paperRectMM)
pdfPainter.end()
def _exportCompositionAsPDF(self, composition, filePath):
"""
Render the composition as a PDF file.
"""
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filePath)
printer.setPaperSize(
QSizeF(composition.paperWidth(), composition.paperHeight()),
QPrinter.Millimeter)
printer.setFullPage(True)
printer.setColorMode(QPrinter.Color)
printer.setResolution(composition.printResolution())
#Use painter to send output to printer
pdfPainter = QPainter(printer)
paperRectMM = printer.pageRect(QPrinter.Millimeter)
paperRectPixel = printer.pageRect(QPrinter.DevicePixel)
composition.render(pdfPainter, paperRectPixel, paperRectMM)
pdfPainter.end()
def outPrint(
self, iface, wdg, mdl,
library): # Postscript file rendering doesn't work properly yet.
for i in range(0, mdl.rowCount()):
if mdl.item(i, 0).data(Qt.CheckStateRole):
name = str(mdl.item(i, 2).data(Qt.EditRole))
#return
fileName = QFileDialog.getSaveFileName(iface.mainWindow(), "Save As",
"Profile of " + name + ".ps",
"PostScript Format (*.ps)")
if fileName:
if library == "Qwt5" and has_qwt:
printer = QPrinter()
printer.setCreator("QGIS Profile Plugin")
printer.setDocName("QGIS Profile")
printer.setOutputFileName(fileName)
printer.setColorMode(QPrinter.Color)
printer.setOrientation(QPrinter.Portrait)
dialog = QPrintDialog(printer)
if dialog.exec_():
wdg.plotWdg.print_(printer)
elif library == "Matplotlib" and has_mpl:
wdg.plotWdg.figure.savefig(str(fileName))
def _get_composer_pdf_image(self, width, height, dpi):
pdfpath = getTempfilePath('pdf')
temp_size = os.path.getsize(pdfpath)
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(pdfpath)
p.setPaperSize(QSizeF(self._c.paperWidth(), self._c.paperHeight()),
QPrinter.Millimeter)
p.setFullPage(True)
p.setColorMode(QPrinter.Color)
p.setResolution(self._c.printResolution())
pdf_p = QPainter(p)
# page_mm = p.pageRect(QPrinter.Millimeter)
# page_px = p.pageRect(QPrinter.DevicePixel)
# self._c.render(pdf_p, page_px, page_mm)
self._c.renderPage(pdf_p, 0)
pdf_p.end()
if temp_size == os.path.getsize(pdfpath):
return False, ''
filepath = getTempfilePath('png')
# Poppler (pdftocairo or pdftoppm):
# PDFUTIL -png -singlefile -r 72 -x 0 -y 0 -W 420 -H 280 in.pdf pngbase
# muPDF (mudraw):
# PDFUTIL -c rgb[a] -r 72 -w 420 -h 280 -o out.png in.pdf
if PDFUTIL.strip().endswith('pdftocairo'):
filebase = os.path.join(
os.path.dirname(filepath),
os.path.splitext(os.path.basename(filepath))[0])
call = [
PDFUTIL, '-png', '-singlefile', '-r',
str(dpi), '-x', '0', '-y', '0', '-W',
str(width), '-H',
str(height), pdfpath, filebase
]
elif PDFUTIL.strip().endswith('mudraw'):
call = [
PDFUTIL,
'-c',
'rgba',
'-r',
str(dpi),
'-w',
str(width),
'-h',
str(height),
# '-b', '8',
'-o',
filepath,
pdfpath
]
else:
return False, ''
qDebug("_get_composer_pdf_image call: {0}".format(' '.join(call)))
res = False
try:
subprocess.check_call(call)
res = True
except subprocess.CalledProcessError as e:
qDebug("_get_composer_pdf_image failed!\n"
"cmd: {0}\n"
"returncode: {1}\n"
"message: {2}".format(e.cmd, e.returncode, e.message))
if not res:
os.unlink(filepath)
filepath = ''
return res, filepath
class BatchPlottingDialog(QDialog):
""" Class for batch plotting dialog
"""
def __init__(self, iface, batch_plotting):
""" Initialize dialog data and event handlers
"""
super(BatchPlottingDialog, self).__init__()
self.ui = Ui_BatchPlottingDialog()
self.ui.setupUi(self)
self.iface = iface
self.ui.OutputTab.setCurrentIndex(2)
# if batch_plotting is True -> plotting by selected polygons
# False -> plot map canvas
self.batch_plotting = batch_plotting
if not self.batch_plotting:
self.setWindowTitle(tr("Plot by Template"))
self.ui.OutputTab.setTabEnabled(0,False)
self.ui.OutputTab.setTabEnabled(1,False)
# event handlers
self.ui.PlotButton.clicked.connect(self.onPlotButton)
self.ui.TempDirButton.clicked.connect(self.onTempDirButton)
self.ui.CloseButton.clicked.connect(self.onCloseButton)
self.ui.TemplateList.setSortingEnabled(True)
# set paths
self.pdfpath = ""
if self.batch_plotting:
self.ui.OutputPDFEdit.setText( QgsAtlasComposition(None).filenamePattern() )
self.ui.SingleFileCheckbox.stateChanged.connect(self.changedSingleFileCheckbox)
else:
# set scale to map canvas scale
self.ui.ScaleCombo.insertItem(0,"%d"%round(self.iface.mapCanvas().scale()))
self.ui.ScaleCombo.insertItem(0,"<extent>")
self.ui.ScaleCombo.setCurrentIndex(0)
self.printer = None
def showEvent(self, event):
""" Reset dialog when receives a show event.
"""
self.templatepath = QSettings().value("SurveyingCalculation/template_dir",config.template_dir)
self.fillLayersCombo()
self.fillTemplateList()
def fillLayersCombo(self):
""" Fill the polygon layers combobox.
"""
oldSelectedLayer = self.ui.LayersComboBox.itemText( self.ui.LayersComboBox.currentIndex() )
self.ui.LayersComboBox.clear()
# if batch plotting is false only map canvas will be in the list
if not self.batch_plotting:
self.ui.LayersComboBox.addItem(tr("<Map view>"))
self.ui.LayersComboBox.setCurrentIndex(0)
return
# if batch plotting is true fill layers combo
polygon_layers = get_vector_layers_by_type(QGis.Polygon)
if polygon_layers is None:
return
for layer in polygon_layers:
self.ui.LayersComboBox.addItem(layer.name(),layer)
# get current layer name
try:
actlayer_name = self.iface.activeLayer().name()
except (AttributeError):
actlayer_name = ""
if self.ui.LayersComboBox.findText(oldSelectedLayer) == -1:
self.ui.LayersComboBox.setCurrentIndex( self.ui.LayersComboBox.findText(actlayer_name) )
else:
self.ui.LayersComboBox.setCurrentIndex( self.ui.LayersComboBox.findText(oldSelectedLayer) )
def fillTemplateList(self):
""" Fill the listbox of composer template files.
"""
if self.ui.TemplateList.currentItem() is not None:
oldSelectedTemplate = self.ui.TemplateList.currentItem().text()
else:
oldSelectedTemplate = ""
self.ui.TemplateList.clear()
tempdir = QDir(self.templatepath)
if tempdir.exists():
fileinfolist = tempdir.entryInfoList(["*.qpt"], QDir.Files | QDir.NoDotAndDotDot | QDir.NoSymLinks, QDir.NoSort)
for fi in fileinfolist:
item = QListWidgetItem(fi.fileName())
self.ui.TemplateList.addItem(item)
if fi.fileName() == oldSelectedTemplate:
self.ui.TemplateList.setCurrentItem( item )
def onTempDirButton(self):
""" Change the directory that contains print composer templates.
"""
templatepath = QFileDialog.getExistingDirectory(self,
tr("Select Directory"),
self.templatepath,
QFileDialog.ShowDirsOnly)
if templatepath!="":
self.templatepath = templatepath
QSettings().setValue("SurveyingCalculation/template_dir",templatepath)
QSettings().sync()
self.fillTemplateList()
def changedSingleFileCheckbox(self, state):
self.ui.OutputPDFEdit.setEnabled(not state)
def onPlotButton(self):
""" Batch plots selected geometry items using the selected template and scale.
"""
# check if one layer is selected
if self.ui.LayersComboBox.currentIndex() == -1:
QMessageBox.warning(self, tr("Warning"), tr("Select a layer!"))
self.ui.LayersComboBox.setFocus()
return
# check if one composition template is selected
if self.ui.TemplateList.selectedItems() == []:
QMessageBox.warning(self, tr("Warning"), tr("Select a composer template!"))
self.ui.TemplateList.setFocus()
return
template_filename = QDir(self.templatepath).absoluteFilePath(
self.ui.TemplateList.currentItem().text())
# get the scale
if self.ui.ScaleCombo.currentText()=="<extent>":
scale = -1
else:
try:
scale = int(self.ui.ScaleCombo.currentText())
except (ValueError):
QMessageBox.warning(self, tr("Warning"), tr("Scale must be a positive integer value!"))
self.ui.ScaleCombo.setFocus()
return
if scale<=0:
QMessageBox.warning(self, tr("Warning"), tr("Scale must be a positive integer value!"))
self.ui.ScaleCombo.setFocus()
return
# get composer name
composer_name = self.ui.ComposerEdit.text()
#check if there are selected items on polygon layers
if self.batch_plotting:
selected_layer = self.ui.LayersComboBox.itemData(self.ui.LayersComboBox.currentIndex())
selected_polygons = get_features(selected_layer.name(),QGis.Polygon,True)
if selected_polygons is None:
QMessageBox.warning(self, tr("Warning"),
tr("Select at least one polygon on layer '%s'!"%selected_layer.name()))
return
# check output setting
if self.ui.OutputTab.currentIndex() == 0: # to PDF
if not self.ui.SingleFileCheckbox.checkState():
if len( self.ui.OutputPDFEdit.text() ) == 0:
res = QMessageBox.warning(self, tr("Warning"),
tr("The filename pattern is empty. A default one will be used."),
QMessageBox.Ok | QMessageBox.Cancel, QMessageBox.Ok)
if res == QMessageBox.Cancel:
return
self.ui.OutputPDFEdit.setText( QgsAtlasComposition(None).filenamePattern() )
elif self.ui.OutputTab.currentIndex() == 1: # to Printer
# no need for checking
pass
elif self.ui.OutputTab.currentIndex() == 2: # to Composer View
# no need for checking yet
pass
# get map renderer of map canvas
renderer = self.iface.mapCanvas().mapRenderer()
self.composition = QgsComposition(renderer)
# if plot to Composer View the composition must be set
# before loading the template
# otherwise composer's item properties doesn't appear
if self.ui.OutputTab.currentIndex() == 2: # to Composer View
if len(composer_name)==0:
composer = self.iface.createNewComposer()
else:
composer = self.iface.createNewComposer(composer_name)
composer.setComposition(self.composition)
# read template file and add to composition
template_file = QFile( template_filename )
template_file.open(QIODevice.ReadOnly | QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
self.composition.loadFromTemplate(document)
# if batch_plotting is True create an atlas composition
if self.batch_plotting:
# get composer map item and set new scale and the grid
cmap = self.composition.getComposerMapById(0)
cmap.setNewScale(scale)
cmap.setGridIntervalX(scale/10)
cmap.setGridIntervalY(scale/10)
cmap.setAtlasDriven(True)
cmap.setAtlasScalingMode( QgsComposerMap.Fixed )
# set atlas composition parameters
atlas = self.composition.atlasComposition()
atlas.setEnabled(True)
atlas.setCoverageLayer( selected_layer )
atlas.setHideCoverage(False)
atlas.setFilenamePattern( self.ui.OutputPDFEdit.text() )
atlas.setSingleFile( self.ui.SingleFileCheckbox.checkState() )
atlas.setSortFeatures(False)
atlas.setFilterFeatures(True)
selected_ids = [f.id() for f in selected_layer.selectedFeatures()]
filter_id_string = ','.join([str(sid) for sid in selected_ids])
atlas.setFeatureFilter("$id in (" + filter_id_string + ")")
# print the complete atlas composition
if self.ui.OutputTab.currentIndex() == 0: # to PDF
self.composition.setAtlasMode( QgsComposition.ExportAtlas )
if self.pdfpath=="":
self.pdfpath = QgsProject.instance().homePath().encode(sys.getfilesystemencoding())
if self.ui.SingleFileCheckbox.checkState():
#print to single pdf (multi-page)
outputFileName = QDir(self.pdfpath).absoluteFilePath("qgis.pdf")
outputFileName = QFileDialog.getSaveFileName(self,
tr( "Choose a file name to save the map as" ),
outputFileName,
tr( "PDF Format" ) + " (*.pdf *.PDF)" )
if not outputFileName:
return
if not outputFileName.lower().endswith(".pdf"):
outputFileName += ".pdf"
self.pdfpath = QDir(outputFileName).absolutePath()
else:
#print to more pdf
outputDir = QFileDialog.getExistingDirectory( self,
tr( "Directory where to save PDF files" ),
self.pdfpath,
QFileDialog.ShowDirsOnly )
if not outputDir:
return
# test directory (if it exists and is writable)
if not QDir(outputDir).exists() or not QFileInfo(outputDir).isWritable():
QMessageBox.warning( self, tr( "Unable to write into the directory" ),
tr( "The given output directory is not writable. Cancelling." ) )
return
self.pdfpath = outputDir
printer = QPrinter()
painter = QPainter()
if not len(atlas.featureFilterErrorString()) == 0:
QMessageBox.warning( self, tr( "Atlas processing error" ),
tr( "Feature filter parser error: %s" % atlas.featureFilterErrorString() ) )
return
atlas.beginRender()
if self.ui.SingleFileCheckbox.checkState():
#prepare for first feature, so that we know paper size to begin with
atlas.prepareForFeature(0)
self.composition.beginPrintAsPDF(printer, outputFileName)
# set the correct resolution
self.composition.beginPrint(printer)
printReady = painter.begin(printer)
if not printReady:
QMessageBox.warning( self, tr( "Atlas processing error" ),
tr( "Error creating %s." % outputFileName ) )
return
progress = QProgressDialog( tr( "Rendering maps..." ), tr( "Abort" ), 0, atlas.numFeatures(), self )
QApplication.setOverrideCursor( Qt.BusyCursor )
for featureI in range(0, atlas.numFeatures()):
progress.setValue( featureI+1 )
# process input events in order to allow aborting
QCoreApplication.processEvents()
if progress.wasCanceled():
atlas.endRender()
break
if not atlas.prepareForFeature( featureI ):
QMessageBox.warning( self, tr( "Atlas processing error" ),
tr( "Atlas processing error" ) )
progress.cancel()
QApplication.restoreOverrideCursor()
return
if not self.ui.SingleFileCheckbox.checkState():
multiFilePrinter = QPrinter()
outputFileName = QDir( outputDir ).filePath( atlas.currentFilename() ) + ".pdf"
self.composition.beginPrintAsPDF( multiFilePrinter, outputFileName )
# set the correct resolution
self.composition.beginPrint( multiFilePrinter )
printReady = painter.begin( multiFilePrinter )
if not printReady:
QMessageBox.warning( self, tr( "Atlas processing error" ),
tr( "Error creating %s." % outputFileName ) )
progress.cancel()
QApplication.restoreOverrideCursor()
return
self.composition.doPrint( multiFilePrinter, painter )
painter.end()
else:
# start print on a new page if we're not on the first feature
if featureI > 0:
printer.newPage()
self.composition.doPrint( printer, painter )
atlas.endRender()
if self.ui.SingleFileCheckbox.checkState():
painter.end()
QApplication.restoreOverrideCursor()
elif self.ui.OutputTab.currentIndex() == 1: # to Printer
# if To Printer is selected set the printer
# setting up printer
if self.printer is None:
self.printer = QPrinter()
self.printer.setFullPage(True)
self.printer.setColorMode(QPrinter.Color)
# open printer setting dialog
pdlg = QPrintDialog(self.printer,self)
pdlg.setModal(True)
pdlg.setOptions(QAbstractPrintDialog.None)
if not pdlg.exec_() == QDialog.Accepted:
return
QApplication.setOverrideCursor(Qt.BusyCursor)
#prepare for first feature, so that we know paper size to begin with
self.composition.setAtlasMode( QgsComposition.ExportAtlas )
atlas.prepareForFeature(0)
# set orientation
if self.composition.paperWidth() > self.composition.paperHeight():
self.printer.setOrientation(QPrinter.Landscape)
self.printer.setPaperSize(
QSizeF(self.composition.paperHeight(), self.composition.paperWidth()),
QPrinter.Millimeter)
else:
self.printer.setOrientation(QPrinter.Portrait)
self.printer.setPaperSize(
QSizeF(self.composition.paperWidth(), self.composition.paperHeight()),
QPrinter.Millimeter)
self.printer.setResolution(self.composition.printResolution())
self.composition.beginPrint( self.printer )
painter = QPainter(self.printer)
if not len(atlas.featureFilterErrorString()) == 0:
QMessageBox.warning( self, tr( "Atlas processing error" ),
tr( "Feature filter parser error: %s" % atlas.featureFilterErrorString() ) )
QApplication.restoreOverrideCursor()
return
atlas.beginRender()
progress = QProgressDialog( tr( "Rendering maps..." ), tr( "Abort" ), 0, atlas.numFeatures(), self )
for featureI in range(0, atlas.numFeatures()):
progress.setValue( featureI+1 )
# process input events in order to allow cancelling
QCoreApplication.processEvents()
if progress.wasCanceled():
atlas.endRender()
break
if not atlas.prepareForFeature( featureI ):
QMessageBox.warning( self, tr( "Atlas processing error" ),
tr( "Atlas processing error" ) )
progress.cancel()
QApplication.restoreOverrideCursor()
return
# start print on a new page if we're not on the first feature
if featureI > 0:
self.printer.newPage()
self.composition.doPrint( self.printer, painter )
atlas.endRender()
painter.end()
QApplication.restoreOverrideCursor()
elif self.ui.OutputTab.currentIndex() == 2: # to Composer View
# create new composer
self.composition.setAtlasMode( QgsComposition.PreviewAtlas )
composer.composerWindow().on_mActionAtlasPreview_triggered(True)
atlas.parameterChanged.emit()
# Increase the reference count of the composer object
# for not being garbage collected.
# If not doing this composer would lost reference and qgis would crash
# when referring to this composer object or at quit.
ctypes.c_long.from_address( id(composer) ).value += 1
else:
# if batch_plotting is False open a QgsComposerView with current map canvas
cmap = self.composition.getComposerMapById(0)
# set the new extent of composer map item
newextent = self.iface.mapCanvas().mapRenderer().extent()
currentextent = cmap.extent()
canvas_ratio = newextent.width()/newextent.height()
map_ratio = currentextent.width()/currentextent.height()
if map_ratio < canvas_ratio:
dh = newextent.width() / map_ratio - newextent.height()
newextent.setYMinimum( newextent.yMinimum() - dh / 2 )
newextent.setYMaximum( newextent.yMaximum() + dh / 2 )
else:
dw = map_ratio * newextent.height() - newextent.width()
newextent.setXMinimum( newextent.xMinimum() - dw / 2 )
newextent.setXMaximum( newextent.xMaximum() + dw / 2 )
cmap.setNewExtent(newextent)
# set the new scale of composer map item
if scale>0:
cmap.setNewScale(scale)
sc = cmap.scale()
# set the grid interval according to the scale
cmap.setGridIntervalX(sc/10)
cmap.setGridIntervalY(sc/10)
# Increase the reference count of the composer object
# for not being garbage collected.
# If not doing this composer would lost reference and qgis would crash
# when referring to this composer object or at quit.
ctypes.c_long.from_address( id(composer) ).value += 1
self.accept()
def onCloseButton(self):
""" Close the dialog when the Close button pushed.
"""
self.reject()
def export_all_features(self):
pdf_painter = None
"""Export map to pdf atlas style (one page per feature)"""
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'exporting map', DLG_CAPTION)
try:
result = self.__delete_pdf()
if not result is None:
return result
ids = []
exp = QgsExpression(self.feature_filter)
if exp.hasParserError():
raise Exception(exp.parserErrorString())
exp.prepare(self.coverage_layer.pendingFields())
for feature in self.coverage_layer.getFeatures():
value = exp.evaluate(feature)
if exp.hasEvalError():
raise ValueError(exp.evalErrorString())
if bool(value):
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'export map, feature id:{0}'.format(feature.id()), DLG_CAPTION)
ids.append(feature.id())
self.coverage_layer.select(ids)
bbox = self.coverage_layer.boundingBoxOfSelected()
self.canvas.zoomToSelected(self.coverage_layer)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox:{0}'.format(bbox.toString()), DLG_CAPTION)
#self.map_renderer.setExtent(bbox)
#self.map_renderer.updateScale()
#read plotlayout
composition = QgsComposition(self.map_renderer)
self.composition = composition
composition.setPlotStyle(QgsComposition.Print)
error, xml_doc = self.__read_template()
if not error is None:
return error
if composition.loadFromTemplate(xml_doc) is False:
return u'Konnte Template nicht laden!\n{0}'.format(self.template_qpt)
#read textinfo layout
self.comp_textinfo = QgsComposition(self.map_renderer)
self.comp_textinfo.setPlotStyle(QgsComposition.Print)
error, xml_doc = self.__read_template(True)
if not error is None:
return error
if self.comp_textinfo.loadFromTemplate(xml_doc) is False:
return u'Konnte Template nicht laden!\n{0}'.format(self.settings.textinfo_layout())
new_ext = bbox
if QGis.QGIS_VERSION_INT > 20200:
compmaps = self.__get_items(QgsComposerMap)
if len(compmaps) < 1:
return u'Kein Kartenfenster im Layout vorhanden!'
compmap = compmaps[0]
else:
if len(composition.composerMapItems()) < 1:
return u'Kein Kartenfenster im Layout vorhanden!'
compmap = composition.composerMapItems()[0]
self.composermap = compmap
#self.composermap.setPreviewMode(QgsComposerMap.Render)
#self.composermap.setPreviewMode(QgsComposerMap.Rectangle)
#taken from QgsComposerMap::setNewAtlasFeatureExtent (not yet available in QGIS 2.0)
#http://www.qgis.org/api/qgscomposermap_8cpp_source.html#l00610
old_ratio = compmap.rect().width() / compmap.rect().height()
new_ratio = new_ext.width() / new_ext.height()
if old_ratio < new_ratio:
new_height = new_ext.width() / old_ratio
delta_height = new_height - new_ext.height()
new_ext.setYMinimum( bbox.yMinimum() - delta_height / 2)
new_ext.setYMaximum(bbox.yMaximum() + delta_height / 2)
else:
new_width = old_ratio * new_ext.height()
delta_width = new_width - new_ext.width()
new_ext.setXMinimum(bbox.xMinimum() - delta_width / 2)
new_ext.setXMaximum(bbox.xMaximum() + delta_width / 2)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox old:{0}'.format(compmap.extent().toString()), DLG_CAPTION)
compmap.setNewExtent(new_ext)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox new:{0}'.format(compmap.extent().toString()), DLG_CAPTION)
#round up to next 1000
compmap.setNewScale(math.ceil((compmap.scale()/1000.0)) * 1000.0)
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'bbox new (after scale):{0}'.format(compmap.extent().toString()), DLG_CAPTION)
#add ORTHO after new extent -> performance
if not self.ortho is None:
self.ortho_lyr = self.__add_raster_layer(self.ortho, self.lyrname_ortho)
self.__reorder_layers()
self.comp_leg = self.__get_items(QgsComposerLegend)
self.comp_lbl = self.__get_items(QgsComposerLabel)
self.__update_composer_items(self.settings.dkm_gemeinde(self.gem_name)['lyrnamegstk'])
if VRP_DEBUG is True:
QgsMessageLog.logMessage(u'paperWidth:{0} paperHeight:{1}'.format(composition.paperWidth(), composition.paperHeight()), DLG_CAPTION)
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(self.pdf_map)
printer.setPaperSize(QSizeF(composition.paperWidth(), composition.paperHeight()), QPrinter.Millimeter)
printer.setFullPage(True)
printer.setColorMode(QPrinter.Color)
printer.setResolution(composition.printResolution())
pdf_painter = QPainter(printer)
paper_rect_pixel = printer.pageRect(QPrinter.DevicePixel)
paper_rect_mm = printer.pageRect(QPrinter.Millimeter)
QgsPaintEngineHack.fixEngineFlags(printer.paintEngine())
#DKM only
if len(self.themen) < 1:
composition.render(pdf_painter, paper_rect_pixel, paper_rect_mm)
else:
self.statistics = OrderedDict()
try:
pass
#lyr = QgsVectorLayer('/home/bergw/VoGIS-Raumplanung-Daten/Geodaten/Raumplanung/Flaechenwidmung/Dornbirn/Flaechenwidmungsplan/fwp_flaeche.shp', 'flaeiw', 'ogr')
#lyr.loadNamedStyle('/home/bergw/VoGIS-Raumplanung-Daten/Geodaten/Raumplanung/Flaechenwidmung/Vorarlberg/Flaechenwidmungsplan/fwp_flaeche.qml')
#QgsMapLayerRegistry.instance().addMapLayer(lyr)
except:
QgsMessageLog.logMessage('new lyr:{0}'.format(sys.exc_info()[0]), DLG_CAPTION)
#QgsMapLayerRegistry.instance().addMapLayer(lyr)
cntr = 0
for thema, sub_themen in self.themen.iteritems():
if VRP_DEBUG is True: QgsMessageLog.logMessage('drucke Thema:{0}'.format(thema.name), DLG_CAPTION)
if sub_themen is None:
layers = self.__add_layers(thema)
self.__calculate_statistics(thema, thema, layers)
#no qml -> not visible -> means no map
if self.__at_least_one_visible(layers) is True:
if cntr > 0:
printer.newPage()
self.__reorder_layers()
self.__update_composer_items(thema.name, layers=layers)
composition.renderPage(pdf_painter, 0)
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
cntr += 1
else:
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
if not sub_themen is None:
for sub_thema in sub_themen:
if VRP_DEBUG is True: QgsMessageLog.logMessage(u'drucke SubThema:{0}'.format(sub_thema.name), DLG_CAPTION)
layers = self.__add_layers(sub_thema)
self.__calculate_statistics(thema, sub_thema, layers)
#no qml -> not visible -> means no map
if self.__at_least_one_visible(layers) is True:
if cntr > 0:
printer.newPage()
self.__reorder_layers()
self.__update_composer_items(thema.name, subthema=sub_thema.name, layers=layers)
composition.renderPage(pdf_painter, 0)
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
cntr += 1
else:
QgsMapLayerRegistry.instance().removeMapLayers([lyr.id() for lyr in layers])
#output statistics
if len(self.statistics) > 0:
printer.setPaperSize(QSizeF(210, 297), QPrinter.Millimeter)
tabelle = self.__get_item_byid(self.comp_textinfo, 'TABELLE')
if tabelle is None:
self.iface.messageBar().pushMessage(u'Layout (Textinfo): Kein Textelement mit ID "TABELLE" vorhanden.', QgsMessageBar.CRITICAL)
else:
try:
str_flaechen = ''
idx = 0
for gnr, stats in self.statistics.iteritems():
comma = ', ' if idx > 0 else ''
str_flaechen += u'{0}{1} ({2:.2f}m²)'.format(comma, gnr, stats[0].flaeche)
idx += 1
lbls = self.__get_items(QgsComposerLabel, self.comp_textinfo)
self.__update_composer_items('', labels=lbls, gnrflaeche=str_flaechen)
html = tabelle.text()
html += u'<table>'
#gnrcnt = 0
for gnr, stats in self.statistics.iteritems():
#if gnrcnt > 0:
# html += u'<tr class="abstand"><td> </td><td> </td><td> </td></tr>'
html += u'<tr><th class="gnr"></th><th class="gnr">{0}</th><th class="gnr"></th></tr>'.format(gnr)
#html += u'<tr class="abstand"><td> </td><td> </td><td> </td></tr>'
curr_thema = ''
for stat in stats:
if stat.thema != curr_thema:
html += u'<tr><th class="thema"></th><th class="thema">{0}</th><th class="thema"></th></tr>'.format(stat.thema)
curr_thema = stat.thema
for thema, subthema in stat.subthemen.iteritems():
for quelle in subthema:
html += u'<tr><td class="col1">{0}</td>'.format(quelle.name)
attr_val = ''
attr_area = ''
for text, area in quelle.txt_area.iteritems():
attr_val += u'{0}<br />'.format(text)
attr_area += u'{0:.2f}m² <br />'.format(area)
html += u'<td class="col2">{0}</td><td class="col3">{1}</td></tr>'.format(attr_val, attr_area)
#gnrcnt += 1
html += u'</table>'
tabelle.setText(html)
printer.newPage()
self.comp_textinfo.renderPage(pdf_painter, 0)
except:
msg = 'Statistikausgabe:\n\n{0}'.format(traceback.format_exc())
QgsMessageLog.logMessage(msg, DLG_CAPTION)
self.iface.messageBar().pushMessage(msg, QgsMessageBar.CRITICAL)
except:
msg = 'export pdf (catch all):\n\n{0}'.format(traceback.format_exc())
QgsMessageLog.logMessage(msg, DLG_CAPTION)
self.iface.messageBar().pushMessage(msg.replace(u'\n', u''), QgsMessageBar.CRITICAL)
return msg
finally:
#end pdf
if not pdf_painter is None:
pdf_painter.end()
return None
def _get_composer_pdf_image(self, width, height, dpi):
pdfpath = getTempfilePath('pdf')
temp_size = os.path.getsize(pdfpath)
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(pdfpath)
p.setPaperSize(QSizeF(self._c.paperWidth(), self._c.paperHeight()),
QPrinter.Millimeter)
p.setFullPage(True)
p.setColorMode(QPrinter.Color)
p.setResolution(self._c.printResolution())
pdf_p = QPainter(p)
# page_mm = p.pageRect(QPrinter.Millimeter)
# page_px = p.pageRect(QPrinter.DevicePixel)
# self._c.render(pdf_p, page_px, page_mm)
self._c.renderPage(pdf_p, 0)
pdf_p.end()
if temp_size == os.path.getsize(pdfpath):
return False, ''
filepath = getTempfilePath('png')
# Poppler (pdftocairo or pdftoppm):
# PDFUTIL -png -singlefile -r 72 -x 0 -y 0 -W 420 -H 280 in.pdf pngbase
# muPDF (mudraw):
# PDFUTIL -c rgb[a] -r 72 -w 420 -h 280 -o out.png in.pdf
if PDFUTIL.strip().endswith('pdftocairo'):
filebase = os.path.join(
os.path.dirname(filepath),
os.path.splitext(os.path.basename(filepath))[0]
)
call = [
PDFUTIL, '-png', '-singlefile', '-r', str(dpi),
'-x', '0', '-y', '0', '-W', str(width), '-H', str(height),
pdfpath, filebase
]
elif PDFUTIL.strip().endswith('mudraw'):
call = [
PDFUTIL, '-c', 'rgba',
'-r', str(dpi), '-w', str(width), '-h', str(height),
# '-b', '8',
'-o', filepath, pdfpath
]
else:
return False, ''
qDebug("_get_composer_pdf_image call: {0}".format(' '.join(call)))
res = False
try:
subprocess.check_call(call)
res = True
except subprocess.CalledProcessError as e:
qDebug("_get_composer_pdf_image failed!\n"
"cmd: {0}\n"
"returncode: {1}\n"
"message: {2}".format(e.cmd, e.returncode, e.message))
if not res:
os.unlink(filepath)
filepath = ''
return res, filepath
class BatchPlottingDialog(QDialog):
""" Class for batch plotting dialog
"""
def __init__(self, iface, batch_plotting):
""" Initialize dialog data and event handlers
"""
super(BatchPlottingDialog, self).__init__()
self.ui = Ui_BatchPlottingDialog()
self.ui.setupUi(self)
self.iface = iface
self.ui.OutputTab.setCurrentIndex(2)
# if batch_plotting is True -> plotting by selected polygons
# False -> plot map canvas
self.batch_plotting = batch_plotting
if not self.batch_plotting:
self.setWindowTitle(tr("Plot by Template"))
self.ui.OutputTab.setTabEnabled(0, False)
self.ui.OutputTab.setTabEnabled(1, False)
# event handlers
self.ui.PlotButton.clicked.connect(self.onPlotButton)
self.ui.TempDirButton.clicked.connect(self.onTempDirButton)
self.ui.CloseButton.clicked.connect(self.onCloseButton)
self.ui.TemplateList.setSortingEnabled(True)
# set paths
self.pdfpath = ""
if self.batch_plotting:
self.ui.OutputPDFEdit.setText(
QgsAtlasComposition(None).filenamePattern())
self.ui.SingleFileCheckbox.stateChanged.connect(
self.changedSingleFileCheckbox)
else:
# set scale to map canvas scale
self.ui.ScaleCombo.insertItem(
0, "%d" % round(self.iface.mapCanvas().scale()))
self.ui.ScaleCombo.insertItem(0, "<extent>")
self.ui.ScaleCombo.setCurrentIndex(0)
self.printer = None
def showEvent(self, event):
""" Reset dialog when receives a show event.
"""
self.templatepath = QSettings().value(
"SurveyingCalculation/template_dir", config.template_dir)
self.fillLayersCombo()
self.fillTemplateList()
def fillLayersCombo(self):
""" Fill the polygon layers combobox.
"""
oldSelectedLayer = self.ui.LayersComboBox.itemText(
self.ui.LayersComboBox.currentIndex())
self.ui.LayersComboBox.clear()
# if batch plotting is false only map canvas will be in the list
if not self.batch_plotting:
self.ui.LayersComboBox.addItem(tr("<Map view>"))
self.ui.LayersComboBox.setCurrentIndex(0)
return
# if batch plotting is true fill layers combo
polygon_layers = get_vector_layers_by_type(QGis.Polygon)
if polygon_layers is None:
return
for layer in polygon_layers:
self.ui.LayersComboBox.addItem(layer.name(), layer)
# get current layer name
try:
actlayer_name = self.iface.activeLayer().name()
except (AttributeError):
actlayer_name = ""
if self.ui.LayersComboBox.findText(oldSelectedLayer) == -1:
self.ui.LayersComboBox.setCurrentIndex(
self.ui.LayersComboBox.findText(actlayer_name))
else:
self.ui.LayersComboBox.setCurrentIndex(
self.ui.LayersComboBox.findText(oldSelectedLayer))
def fillTemplateList(self):
""" Fill the listbox of composer template files.
"""
if self.ui.TemplateList.currentItem() is not None:
oldSelectedTemplate = self.ui.TemplateList.currentItem().text()
else:
oldSelectedTemplate = ""
self.ui.TemplateList.clear()
tempdir = QDir(self.templatepath)
if tempdir.exists():
fileinfolist = tempdir.entryInfoList(
["*.qpt"], QDir.Files | QDir.NoDotAndDotDot | QDir.NoSymLinks,
QDir.NoSort)
for fi in fileinfolist:
item = QListWidgetItem(fi.fileName())
self.ui.TemplateList.addItem(item)
if fi.fileName() == oldSelectedTemplate:
self.ui.TemplateList.setCurrentItem(item)
def onTempDirButton(self):
""" Change the directory that contains print composer templates.
"""
templatepath = QFileDialog.getExistingDirectory(
self, tr("Select Directory"), self.templatepath,
QFileDialog.ShowDirsOnly)
if templatepath != "":
self.templatepath = templatepath
QSettings().setValue("SurveyingCalculation/template_dir",
templatepath)
QSettings().sync()
self.fillTemplateList()
def changedSingleFileCheckbox(self, state):
self.ui.OutputPDFEdit.setEnabled(not state)
def onPlotButton(self):
""" Batch plots selected geometry items using the selected template and scale.
"""
# check if one layer is selected
if self.ui.LayersComboBox.currentIndex() == -1:
QMessageBox.warning(self, tr("Warning"), tr("Select a layer!"))
self.ui.LayersComboBox.setFocus()
return
# check if one composition template is selected
if self.ui.TemplateList.selectedItems() == []:
QMessageBox.warning(self, tr("Warning"),
tr("Select a composer template!"))
self.ui.TemplateList.setFocus()
return
template_filename = QDir(self.templatepath).absoluteFilePath(
self.ui.TemplateList.currentItem().text())
# get the scale
if self.ui.ScaleCombo.currentText() == "<extent>":
scale = -1
else:
try:
scale = int(self.ui.ScaleCombo.currentText())
except (ValueError):
QMessageBox.warning(
self, tr("Warning"),
tr("Scale must be a positive integer value!"))
self.ui.ScaleCombo.setFocus()
return
if scale <= 0:
QMessageBox.warning(
self, tr("Warning"),
tr("Scale must be a positive integer value!"))
self.ui.ScaleCombo.setFocus()
return
# get composer name
composer_name = self.ui.ComposerEdit.text()
#check if there are selected items on polygon layers
if self.batch_plotting:
selected_layer = self.ui.LayersComboBox.itemData(
self.ui.LayersComboBox.currentIndex())
selected_polygons = get_features(selected_layer.name(),
QGis.Polygon, True)
if selected_polygons is None:
QMessageBox.warning(
self, tr("Warning"),
tr("Select at least one polygon on layer '%s'!" %
selected_layer.name()))
return
# check output setting
if self.ui.OutputTab.currentIndex() == 0: # to PDF
if not self.ui.SingleFileCheckbox.checkState():
if len(self.ui.OutputPDFEdit.text()) == 0:
res = QMessageBox.warning(
self, tr("Warning"),
tr("The filename pattern is empty. A default one will be used."
), QMessageBox.Ok | QMessageBox.Cancel,
QMessageBox.Ok)
if res == QMessageBox.Cancel:
return
self.ui.OutputPDFEdit.setText(
QgsAtlasComposition(None).filenamePattern())
elif self.ui.OutputTab.currentIndex() == 1: # to Printer
# no need for checking
pass
elif self.ui.OutputTab.currentIndex() == 2: # to Composer View
# no need for checking yet
pass
# get map renderer of map canvas
renderer = self.iface.mapCanvas().mapRenderer()
self.composition = QgsComposition(renderer)
# if plot to Composer View the composition must be set
# before loading the template
# otherwise composer's item properties doesn't appear
if self.ui.OutputTab.currentIndex() == 2: # to Composer View
if len(composer_name) == 0:
composer = self.iface.createNewComposer()
else:
composer = self.iface.createNewComposer(composer_name)
composer.setComposition(self.composition)
# read template file and add to composition
template_file = QFile(template_filename)
template_file.open(QIODevice.ReadOnly | QIODevice.Text)
template_content = template_file.readAll()
template_file.close()
document = QDomDocument()
document.setContent(template_content)
self.composition.loadFromTemplate(document)
# if batch_plotting is True create an atlas composition
if self.batch_plotting:
# get composer map item and set new scale and the grid
cmap = self.composition.getComposerMapById(0)
cmap.setNewScale(scale)
cmap.setGridIntervalX(scale / 10)
cmap.setGridIntervalY(scale / 10)
cmap.setAtlasDriven(True)
cmap.setAtlasScalingMode(QgsComposerMap.Fixed)
# set atlas composition parameters
atlas = self.composition.atlasComposition()
atlas.setEnabled(True)
atlas.setCoverageLayer(selected_layer)
atlas.setHideCoverage(False)
atlas.setFilenamePattern(self.ui.OutputPDFEdit.text())
atlas.setSingleFile(self.ui.SingleFileCheckbox.checkState())
atlas.setSortFeatures(False)
atlas.setFilterFeatures(True)
selected_ids = [f.id() for f in selected_layer.selectedFeatures()]
filter_id_string = ','.join([str(sid) for sid in selected_ids])
atlas.setFeatureFilter("$id in (" + filter_id_string + ")")
# print the complete atlas composition
if self.ui.OutputTab.currentIndex() == 0: # to PDF
self.composition.setAtlasMode(QgsComposition.ExportAtlas)
if self.pdfpath == "":
self.pdfpath = QgsProject.instance().homePath().encode(
sys.getfilesystemencoding())
if self.ui.SingleFileCheckbox.checkState():
#print to single pdf (multi-page)
outputFileName = QDir(
self.pdfpath).absoluteFilePath("qgis.pdf")
outputFileName = QFileDialog.getSaveFileName(
self, tr("Choose a file name to save the map as"),
outputFileName,
tr("PDF Format") + " (*.pdf *.PDF)")
if not outputFileName:
return
if not outputFileName.lower().endswith(".pdf"):
outputFileName += ".pdf"
self.pdfpath = QDir(outputFileName).absolutePath()
else:
#print to more pdf
outputDir = QFileDialog.getExistingDirectory(
self, tr("Directory where to save PDF files"),
self.pdfpath, QFileDialog.ShowDirsOnly)
if not outputDir:
return
# test directory (if it exists and is writable)
if not QDir(outputDir).exists() or not QFileInfo(
outputDir).isWritable():
QMessageBox.warning(
self, tr("Unable to write into the directory"),
tr("The given output directory is not writable. Cancelling."
))
return
self.pdfpath = outputDir
printer = QPrinter()
painter = QPainter()
if not len(atlas.featureFilterErrorString()) == 0:
QMessageBox.warning(
self, tr("Atlas processing error"),
tr("Feature filter parser error: %s" %
atlas.featureFilterErrorString()))
return
atlas.beginRender()
if self.ui.SingleFileCheckbox.checkState():
#prepare for first feature, so that we know paper size to begin with
atlas.prepareForFeature(0)
self.composition.beginPrintAsPDF(printer, outputFileName)
# set the correct resolution
self.composition.beginPrint(printer)
printReady = painter.begin(printer)
if not printReady:
QMessageBox.warning(
self, tr("Atlas processing error"),
tr("Error creating %s." % outputFileName))
return
progress = QProgressDialog(tr("Rendering maps..."),
tr("Abort"), 0, atlas.numFeatures(),
self)
QApplication.setOverrideCursor(Qt.BusyCursor)
for featureI in range(0, atlas.numFeatures()):
progress.setValue(featureI + 1)
# process input events in order to allow aborting
QCoreApplication.processEvents()
if progress.wasCanceled():
atlas.endRender()
break
if not atlas.prepareForFeature(featureI):
QMessageBox.warning(self, tr("Atlas processing error"),
tr("Atlas processing error"))
progress.cancel()
QApplication.restoreOverrideCursor()
return
if not self.ui.SingleFileCheckbox.checkState():
multiFilePrinter = QPrinter()
outputFileName = QDir(outputDir).filePath(
atlas.currentFilename()) + ".pdf"
self.composition.beginPrintAsPDF(
multiFilePrinter, outputFileName)
# set the correct resolution
self.composition.beginPrint(multiFilePrinter)
printReady = painter.begin(multiFilePrinter)
if not printReady:
QMessageBox.warning(
self, tr("Atlas processing error"),
tr("Error creating %s." % outputFileName))
progress.cancel()
QApplication.restoreOverrideCursor()
return
self.composition.doPrint(multiFilePrinter, painter)
painter.end()
else:
# start print on a new page if we're not on the first feature
if featureI > 0:
printer.newPage()
self.composition.doPrint(printer, painter)
atlas.endRender()
if self.ui.SingleFileCheckbox.checkState():
painter.end()
QApplication.restoreOverrideCursor()
elif self.ui.OutputTab.currentIndex() == 1: # to Printer
# if To Printer is selected set the printer
# setting up printer
if self.printer is None:
self.printer = QPrinter()
self.printer.setFullPage(True)
self.printer.setColorMode(QPrinter.Color)
# open printer setting dialog
pdlg = QPrintDialog(self.printer, self)
pdlg.setModal(True)
pdlg.setOptions(QAbstractPrintDialog.None)
if not pdlg.exec_() == QDialog.Accepted:
return
QApplication.setOverrideCursor(Qt.BusyCursor)
#prepare for first feature, so that we know paper size to begin with
self.composition.setAtlasMode(QgsComposition.ExportAtlas)
atlas.prepareForFeature(0)
# set orientation
if self.composition.paperWidth(
) > self.composition.paperHeight():
self.printer.setOrientation(QPrinter.Landscape)
self.printer.setPaperSize(
QSizeF(self.composition.paperHeight(),
self.composition.paperWidth()),
QPrinter.Millimeter)
else:
self.printer.setOrientation(QPrinter.Portrait)
self.printer.setPaperSize(
QSizeF(self.composition.paperWidth(),
self.composition.paperHeight()),
QPrinter.Millimeter)
self.printer.setResolution(self.composition.printResolution())
self.composition.beginPrint(self.printer)
painter = QPainter(self.printer)
if not len(atlas.featureFilterErrorString()) == 0:
QMessageBox.warning(
self, tr("Atlas processing error"),
tr("Feature filter parser error: %s" %
atlas.featureFilterErrorString()))
QApplication.restoreOverrideCursor()
return
atlas.beginRender()
progress = QProgressDialog(tr("Rendering maps..."),
tr("Abort"), 0, atlas.numFeatures(),
self)
for featureI in range(0, atlas.numFeatures()):
progress.setValue(featureI + 1)
# process input events in order to allow cancelling
QCoreApplication.processEvents()
if progress.wasCanceled():
atlas.endRender()
break
if not atlas.prepareForFeature(featureI):
QMessageBox.warning(self, tr("Atlas processing error"),
tr("Atlas processing error"))
progress.cancel()
QApplication.restoreOverrideCursor()
return
# start print on a new page if we're not on the first feature
if featureI > 0:
self.printer.newPage()
self.composition.doPrint(self.printer, painter)
atlas.endRender()
painter.end()
QApplication.restoreOverrideCursor()
elif self.ui.OutputTab.currentIndex() == 2: # to Composer View
# create new composer
self.composition.setAtlasMode(QgsComposition.PreviewAtlas)
composer.composerWindow().on_mActionAtlasPreview_triggered(
True)
atlas.parameterChanged.emit()
# Increase the reference count of the composer object
# for not being garbage collected.
# If not doing this composer would lost reference and qgis would crash
# when referring to this composer object or at quit.
ctypes.c_long.from_address(id(composer)).value += 1
else:
# if batch_plotting is False open a QgsComposerView with current map canvas
cmap = self.composition.getComposerMapById(0)
# set the new extent of composer map item
newextent = self.iface.mapCanvas().mapRenderer().extent()
currentextent = cmap.extent()
canvas_ratio = newextent.width() / newextent.height()
map_ratio = currentextent.width() / currentextent.height()
if map_ratio < canvas_ratio:
dh = newextent.width() / map_ratio - newextent.height()
newextent.setYMinimum(newextent.yMinimum() - dh / 2)
newextent.setYMaximum(newextent.yMaximum() + dh / 2)
else:
dw = map_ratio * newextent.height() - newextent.width()
newextent.setXMinimum(newextent.xMinimum() - dw / 2)
newextent.setXMaximum(newextent.xMaximum() + dw / 2)
cmap.setNewExtent(newextent)
# set the new scale of composer map item
if scale > 0:
cmap.setNewScale(scale)
sc = cmap.scale()
# set the grid interval according to the scale
cmap.setGridIntervalX(sc / 10)
cmap.setGridIntervalY(sc / 10)
# Increase the reference count of the composer object
# for not being garbage collected.
# If not doing this composer would lost reference and qgis would crash
# when referring to this composer object or at quit.
ctypes.c_long.from_address(id(composer)).value += 1
self.accept()
def onCloseButton(self):
""" Close the dialog when the Close button pushed.
"""
self.reject()
compmap.setPreviewMode(QgsComposerMap.Render)
#compmap.updateItem()
#emit compmap.itemChanged();
#compmap.extentChanged();
#compmap.toggleAtlasPreview()
#compmap.setNewScale(compmap.scale()+1)
#c.setPrintResolution(150)
#print c.printResolution()
c.setPrintAsRaster(False)
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(pdf_out)
printer.setPaperSize(QSizeF(c.paperWidth(), c.paperHeight()), QPrinter.Millimeter)
printer.setFullPage(True)
printer.setColorMode(QPrinter.Color)
printer.setResolution(c.printResolution())
pdfPainter = QPainter(printer)
paperRectMM = printer.pageRect(QPrinter.Millimeter)
paperRectPixel = printer.pageRect(QPrinter.DevicePixel)
QgsPaintEngineHack.fixEngineFlags(printer.paintEngine())
#c.renderPage(pdfPainter, 0)
c.doPrint(printer,pdfPainter)
pdfPainter.end()
subprocess.call(('xdg-open', pdf_out))
print 'FERTIG'
=======
fileName = QFileDialog.getSaveFileName(self, 'Save to PDF', "",
"PDF file (*.pdf);;All Files (*.*)")
>>>>>>> upstream1/master
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
printer = QPrinter(QPrinter.HighResolution)
printer.setPageSize(QPrinter.A4)
printer.setColorMode(QPrinter.Color)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(_filename)
doc = QTextDocument()
if self.toXml:
doc.setPlainText( self.txtEdit.text() )
else:
doc.setHtml( self.txtEdit.toHtml() )
doc.print_(printer)
class WExportStatistics(QtHelper.EnhancedQDialog, Logger.ClassLogger):
"""
Export statistics dialog
"""
def __init__(self, parent, dataXml):
