def print_pdf(self): if self.deck is not None: #Setting the printer printer = QPrinter(QPrinter.HighResolution) printer.setOutputFormat(QPrinter.PdfFormat) printer.setOrientation(getattr(QPrinter, "Portrait")) printer.setOutputFileName(self.path) printer.setPaperSize(getattr(QPrinter, self.paper)) printer.setFullPage(True) guide = self.max_cards() printer.setOrientation(getattr(QPrinter, guide["orientation"])) print guide, self.card_size #Start printing with QPainter(printer) as paint: ind = 0 resol = printer.resolution() for c in self.deck: c.resize(self.card_size[0], self.card_size[1]) if ind == guide["max"]: printer.newPage() ind = 0 col = ind % guide["horizontal"] fil = ind // guide["horizontal"] print ind, fil, col target = QRectF((col)*self.card_size[0]*resol, (fil)*self.card_size[1]*resol, self.card_size[0]*resol, self.card_size[1]*resol) self.preview_card(c) self.scene.render(paint, target=target, source=QRectF(0,0,c.width(),c.height())) ind += 1
def print_grid(self): if self.deck is not None: #Setting the printer printer = QPrinter(QPrinter.HighResolution) printer.setOutputFormat(QPrinter.PdfFormat) printer.setOrientation(getattr(QPrinter, self.orientation)) printer.setOutputFileName(self.path) printer.setPaperSize(getattr(QPrinter, self.paper)) #Start printing with QPainter(printer) as paint: first = True for c in self.deck: if not first: printer.newPage() first = False self.preview_card(c) self.scene.render(paint)
def makeShowZonesPdf():
self.cursor.execute(Const.ZONES_QUERY, [int(feature[id_index])])
rows = (row for row in self.cursor.fetchall() if row[Const.ZONES_COLUMNS.index('per_int')] >= 3)
composition = None
for item in self.iface.activeComposers():
if item.composerWindow().windowTitle() == Const.PDF_ZONES:
composition = item.composition()
break
if composition is None:
return
filename = os.path.join(self.reports_folder, '{}_zones.pdf'.format(info[Const.REFCAT]))
printer = QPrinter()
composition.beginPrintAsPDF(printer, filename)
composition.beginPrint(printer, False)
painter = QPainter()
painter.begin(printer)
first = True
for data in rows:
if first:
first = False
else:
printer.newPage()
for i, column in enumerate(Const.ZONES_COLUMNS):
QgsExpressionContextUtils.setProjectVariable(column, data[i])
if info[Const.CODI_SECTOR] is not None:
QgsExpressionContextUtils.setProjectVariable('sec_descripcio', u'{} - {}'.format(info[Const.CODI_SECTOR], info[Const.DESCR_SECTOR]))
else:
QgsExpressionContextUtils.setProjectVariable('sec_descripcio', None)
QgsExpressionContextUtils.setProjectVariable('cla_descripcio', u'{} - {}'.format(info[Const.CODI_CLASSI], info[Const.DESCR_CLASSI]))
composition.refreshItems()
composition.doPrint(printer, painter)
painter.end()
openFile(filename)
def main():
app = QApplication(sys.argv)
# Preparing the pdf
doc = QTextDocument()
printer = QPrinter()
printer.setOutputFileName("KabitGurdas.pdf")
printer.setOutputFormat(QPrinter.PdfFormat)
# Setting page size as A5
printer.setPaperSize(QPrinter.A5);
# page margin
printer.setPageMargins(12, 16, 12, 20, QPrinter.Millimeter)
doc.setPageSize(QSizeF(printer.pageRect().size()))
painter = QPainter()
painter.begin( printer )
# Set poem book and get each poem in pdf
book = kb()
for KabitNumber in range(1,676):
# Add text in html to page
doc.setHtml(book.getKabitHTML(KabitNumber))
doc.defaultFont().setPointSize(20)
# A new page
printer.newPage()
# Create a QPainter to draw our content
doc.drawContents(painter)#,printer.pageRect().translated( -printer.pageRect().x(), -printer.pageRect().y() ))
#QTextDocument.drawContents(QPainter, QRectF rect=QRectF())
doc.print_(printer)
# Done.
painter.end()
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()
class Printer(BasePrinter):
FONT_NAME = 'Courrier'
def __init__(self, *args, **kwargs):
BasePrinter.__init__(self, *args, **kwargs)
self.page_number = 0
self.printer = QPrinter(QPrinter.HighResolution)
## todo: remove-me
self.printer.setOutputFileName("ufwi_log-page.pdf")
self.printer.setOutputFormat(QPrinter.NativeFormat)
#self.printer.setOrientation(QPrinter.Landscape)
self.printer.setPaperSize(QPrinter.A4)
self.printer.setResolution(100)
def _init_painter(self):
self.painter = QPainter(self.printer)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setBackgroundMode(Qt.OpaqueMode)
self.painter.setBrush(Qt.white)
self.painter.setFont(QFont(self.FONT_NAME, 9))
fillrect = QRect(0, 0, self.printer.pageRect().width(), self.printer.pageRect().height())
self.painter.fillRect(fillrect, self.painter.brush())
self.page_number = 1
self._draw_header()
self._draw_footer()
self.drawCentralTitle(self.title)
if self.logo:
self.painter.drawImage(QPoint(self.width() / 2 - self.logo.width() / 2,
self.height() / 2 + QFontMetrics(self.painter.font()).height() + self.height() / 4 - self.logo.height() / 2),
self.logo)
def _draw_header(self):
if not self.header_enabled:
return
h = -self.headerHeight()
self.drawText(QDateTime.currentDateTime().toString('yyyy-MM-dd hh:mm'), h, Qt.AlignLeft)
h += self.drawText(self.interval_label, h, Qt.AlignRight)
self.drawText(self.title, h, Qt.AlignLeft)
self.drawText(self.enterprise, h, Qt.AlignRight)
self.painter.drawLine(0,
self.headerHeight() - 1,
self.printer.pageRect().width(),
self.headerHeight() - 1)
def _draw_footer(self):
if not self.footer_enabled:
return
self.painter.drawLine(10,
self.printer.pageRect().height() - self.footerHeight(),
self.printer.pageRect().width() - 10,
self.printer.pageRect().height() - self.footerHeight())
h = self.height() + 1
#self.drawText('topleft', h, Qt.AlignLeft)
h += self.drawText(u'© 2008-2010 EdenWall', h, Qt.AlignRight, size=9)
self.drawText(unicode(self.page_number), h, Qt.AlignHCenter)
#self.drawText('bottomright', h, Qt.AlignRight)
def headerHeight(self):
if self.header_enabled:
return 40
else:
return 0
def footerHeight(self):
if self.footer_enabled:
return 40
else:
return 0
def height(self):
return self.printer.pageRect().height() - self.headerHeight() - self.footerHeight()
def width(self):
return self.printer.pageRect().width()
def showDialog(self, parent):
dialog = QPrintDialog(self.printer, parent)
if dialog.exec_() != QPrintDialog.Accepted:
return False
self._init_painter()
return True
def end(self):
self.painter.end()
def newPage(self):
self.printer.newPage()
self.page_number += 1
self._draw_header()
self._draw_footer()
def drawCentralTitle(self, text):
self.painter.setBackgroundMode(Qt.TransparentMode)
f = QFont(self.FONT_NAME, 22)
f.setWeight(QFont.Bold)
self.painter.setFont(f)
height = QFontMetrics(self.painter.font()).height()
self.painter.drawText(QRect(0,
self.printer.pageRect().height() * 0.5,
self.printer.pageRect().width(),
height),
Qt.AlignHCenter | Qt.AlignVCenter,
text)
self.painter.setFont(QFont(self.FONT_NAME, 10))
def drawHCenteredTitle(self, text, vpos):
self.painter.setBackgroundMode(Qt.TransparentMode)
self.painter.setFont(QFont(self.FONT_NAME, 18))
height = QFontMetrics(self.painter.font()).height()
self.painter.drawText(QRect(0,
self.headerHeight() + vpos,
self.printer.pageRect().width(),
height),
Qt.AlignHCenter | Qt.AlignVCenter,
text)
self.painter.setFont(QFont(self.FONT_NAME, 10))
return height
def drawText(self, text, vpos, halign=Qt.AlignLeft, size=10, width=None):
self.painter.setBackgroundMode(Qt.TransparentMode)
self.painter.setFont(QFont(self.FONT_NAME, size))
height = QFontMetrics(self.painter.font()).height()
if width is None:
width = self.printer.pageRect().width()
self.painter.drawText(QRect(0,
self.headerHeight() + vpos,
width,
height),
halign | Qt.AlignVCenter,
text)
return height
def drawFragment(self, frag_widget, vpos, len_frags):
# Display it on half the page
scale = 1
single_frag = False
if frag_widget.pos == len_frags - 1 and frag_widget.pos % 2 == 0:
scale = 2
single_frag = True
y = self.headerHeight() + vpos
width = self.printer.pageRect().width() * 0.8 * scale
height = self.printer.pageRect().height() * 0.5 * 0.8
x = self.printer.pageRect().width() * 0.1
if single_frag:
if frag_widget.view.__class__.__name__ != "TreeFragmentView":
x = -(width - self.printer.pageRect().width()) / 2.
else:
width = width / 2.
rect = QRect(x, y, width, height)
# Temporary remove stylesheet to avoid to print background.
stylesheet_save = frag_widget.styleSheet()
frag_widget.setStyleSheet('')
frag_widget.getView().printMe(self.painter, rect)
frag_widget.setStyleSheet(stylesheet_save)
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
# max numbers in one line then add <br> in "english" translation
no_of_words = 20
for num, name in enumerate(Plist):
k = Elist[num].split()
klen = k.__len__()
t = klen / no_of_words
for i in range(t):
k.insert(no_of_words * (i + 1), "<br>")
strline = " ".join(k)
htmllist.append(AddHTMLTag(Center(Italics(TextSize(strline, 3))), "p"))
body = " ".join(htmllist)
# Necessary for unicode rendering
headuni = '<meta http-equiv="Content-Type" content="text\/html; charset=utf-8">'
html[count] = AddHead(headuni) + AddBody(body)
# A new page
printer.newPage()
# Draw the first page removing the pageRect offset due to margins.
doc.setHtml(html[count])
# Create a QPainter to draw our content
doc.drawContents(painter) # ,printer.pageRect().translated( -printer.pageRect().x(), -printer.pageRect().y() ))
# QTextDocument.drawContents(QPainter, QRectF rect=QRectF())
doc.print_(printer)
# Done.
painter.end()
class Form(QDialog):
def __init__(self, args=None,parent=None):
super(Form, self).__init__(parent)
self.printer = QPrinter()
self.printer.setPageSize(QPrinter.A4)
self.filename = ''
#File name to convert
lblFileName = QLabel("File Name")
self.txtFileName = QLineEdit()
if len(args) > 1:
self.txtFileName.setText(args[1])
self.filename = args[1]
self.txtFileName.setReadOnly(True)
btnGetFileName = QToolButton()
btnGetFileName.setText("..")
getFileLayout = QHBoxLayout()
getFileLayout.addWidget(lblFileName)
getFileLayout.addWidget(self.txtFileName)
getFileLayout.addWidget(btnGetFileName)
#Code page of file
lblCodePage = QLabel("Code Page")
self.cmbCodePage = QComboBox()
self.cmbCodePage.addItem("dos")
self.cmbCodePage.addItem("windows")
self.cmbCodePage.addItem("utf8")
codePageLayout = QHBoxLayout()
codePageLayout.addStretch()
codePageLayout.addWidget(lblCodePage)
codePageLayout.addWidget(self.cmbCodePage)
#Printer Orientation (Portrait / Landscape)
lblOrientation = QLabel("Orientation")
self.cmbOrientation = QComboBox()
self.cmbOrientation.addItem("portait")
self.cmbOrientation.addItem("landscape")
orientationLayout = QHBoxLayout()
orientationLayout.addStretch()
orientationLayout.addWidget(lblOrientation)
orientationLayout.addWidget(self.cmbOrientation)
#Buttons for save or Just quit
bSave = QPushButton("Go for it")
bQuit = QPushButton("Abort")
buttonLayout = QHBoxLayout()
buttonLayout.addWidget(bQuit)
buttonLayout.addStretch()
buttonLayout.addWidget(bSave)
#Final Layout
layout = QVBoxLayout()
layout.addLayout(getFileLayout)
layout.addLayout(codePageLayout)
layout.addLayout(orientationLayout)
layout.addLayout(buttonLayout)
self.setLayout(layout)
#Connections
self.connect(bSave, SIGNAL("clicked()"),self.printViaQPainter)
self.connect(bQuit, SIGNAL("clicked()"), self.accept)
self.connect(btnGetFileName, SIGNAL("clicked()"),self.getFileName)
self.setWindowTitle("dos/windows text to PDF")
def getFileName(self):
fd = QFileDialog(self)
self.filename = fd.getOpenFileName()
self.txtFileName.setText(self.filename)
def printViaQPainter(self):
from os.path import isfile
if isfile(self.filename):
lines = open(self.filename)
else:
return
a = self.filename.split('.')
s = a[-1]
fname = ''
for i in range(len(a)-1) :
fname += a[i]
fname += '.pdf'
self.printer.setOutputFileName(fname)
self.printer.setOutputFormat(QPrinter.PdfFormat)
if self.cmbOrientation.currentText() == 'landscape':
self.printer.setOrientation(QPrinter.Landscape)
pageRect = self.printer.pageRect()
LeftMargin = 15
biggest = findBiggestLine(self.filename)
bestSize = findBestFontSize(biggest,pageRect)
sansFont = QFont("Courier", bestSize)
sansLineHeight = QFontMetrics(sansFont).height()
painter = QPainter(self.printer)
page = 1
y = 20
cpage = codePage(self.cmbCodePage.currentText())
for line in lines:
painter.save()
painter.setFont(sansFont)
y += sansLineHeight
x = LeftMargin
try:
painter.drawText(x,y,line[:-1].decode(cpage))
except:
painter.drawText(x,y,'CodePage error !!!')
if y > (pageRect.height() - 54) :
self.printer.newPage()
y = 20
painter.restore()
lines.close()
self.accept()
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()
class Ui_py_de(object):
def setupUi(self, py_de):
self.printer = QPrinter()
self.imagesDir = "images/"
####################################
## Set up our initial window object
####################################
py_de.setObjectName("py_de")
py_de.resize(QtCore.QSize(QtCore.QRect(0, 0, 800, 570).size()).expandedTo(py_de.minimumSizeHint()))
self.centralwidget = QtGui.QTabWidget(py_de)
self.centralwidget.setObjectName("centralwidget")
self.centralwidget.setGeometry(QtCore.QRect(50,50,200,200))
####################################
## Set up tabs
####################################
self.tab = QtGui.QWidget()
self.tab.setObjectName("tab")
self.tablayout = QtGui.QGridLayout(self.tab)
####################################
## The actual text box.
####################################
self.textEdit = QsciScintilla(self.tab)
#####################################
### Set the syntax highlighting.
#####################################
## define the font to use
self.font = QtGui.QFont()
self.font.setFamily("Consolas")
self.font.setFixedPitch(True)
self.font.setPointSize(10)
# the font metrics here will help
# building the margin width later
self.fm = QtGui.QFontMetrics(self.font)
## set the default font of the editor
## and take the same font for line numbers
self.textEdit.setFont(self.font)
self.textEdit.setMarginsFont(self.font)
## Line numbers
# conventionaly, margin 0 is for line numbers
self.textEdit.setMarginWidth(0, self.fm.width( "00000" ) + 5)
self.textEdit.setMarginLineNumbers(0, True)
## Edge Mode shows a red vertical bar at 80 chars
self.textEdit.setEdgeMode(QsciScintilla.EdgeLine)
self.textEdit.setEdgeColumn(80)
self.textEdit.setEdgeColor(QtGui.QColor("#FF0000"))
## Folding visual : we will use boxes
self.textEdit.setFolding(QsciScintilla.BoxedTreeFoldStyle)
## Braces matching
self.textEdit.setBraceMatching(QsciScintilla.SloppyBraceMatch)
## Editing line color
self.textEdit.setCaretLineVisible(True)
self.textEdit.setCaretLineBackgroundColor(QtGui.QColor("#CDA869"))
## Margins colors
# line numbers margin
self.textEdit.setMarginsBackgroundColor(QtGui.QColor("#333333"))
self.textEdit.setMarginsForegroundColor(QtGui.QColor("#CCCCCC"))
# folding margin colors (foreground,background)
self.textEdit.setFoldMarginColors(QtGui.QColor("#99CC66"),QtGui.QColor("#333300"))
## Choose a lexer
lexer = QsciLexerPython()
lexer.setDefaultFont(self.font)
self.textEdit.setLexer(lexer)
## Render on screen
self.textEdit.show()
## Show this file in the self.textEdit
#####################################
## end of syntax highlighting.
#####################################
####################################
## Set up the sizes of everything
####################################
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Policy(1),QtGui.QSizePolicy.Policy(1))
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.textEdit.sizePolicy().hasHeightForWidth())
self.textEdit.setSizePolicy(sizePolicy)
self.textEdit.setObjectName("textEdit")
self.tablayout.addWidget(self.textEdit, 0, 0, 1, 1)
self.centralwidget.addTab(self.tab,"")
self.centralwidget.setCurrentIndex(0)
py_de.setCentralWidget(self.centralwidget)
self.createMenus(py_de)
self.createActions(py_de)
self.createToolBar(py_de)
self.retranslateUi(py_de)
#self.createTab(py_de)
conn = QtCore.QObject.connect
conn(self.actionNewTemplate,QtCore.SIGNAL("activated()"),self.newTemplate)
conn(self.actionClose,QtCore.SIGNAL("triggered()"),self.closeTab)
conn(self.actionQuit,QtCore.SIGNAL("activated()"),py_de.close)
conn(self.actionOpen,QtCore.SIGNAL("activated()"),self.openFile)
conn(self.actionPrint,QtCore.SIGNAL("activated()"),self.printFile)
conn(self.actionSave,QtCore.SIGNAL("activated()"),self.saveFile)
conn(self.actionSave_As,QtCore.SIGNAL("activated()"),self.saveAsFile)
conn(self.actionSelect_All,QtCore.SIGNAL("activated()"),self.textEdit.selectAll)
conn(self.actionGoToLine,QtCore.SIGNAL("activated()"),self.goToLine)
conn(self.actionCopy,QtCore.SIGNAL("activated()"),self.textEdit.copy)
conn(self.actionCut,QtCore.SIGNAL("activated()"),self.textEdit.cut)
conn(self.actionPaste,QtCore.SIGNAL("activated()"),self.textEdit.paste)
conn(self.actionPython_File,QtCore.SIGNAL("activated()"),self.newPythonFile)
conn(self.actionC,QtCore.SIGNAL("activated()"),self.newCFile)
conn(self.actionC_Header_File_h,QtCore.SIGNAL("activated()"),self.newCHeaderFile)
conn(self.actionFortran,QtCore.SIGNAL("activated()"),self.newFortranFile)
conn(self.actionPython_File,QtCore.SIGNAL("activated()"),lambda x="py":self.template(x))
conn(self.actionC,QtCore.SIGNAL("activated()"),lambda x="cpp":self.template(x))
conn(self.actionFortran,QtCore.SIGNAL("activated()"),lambda x="f":self.template(x))
QtCore.QMetaObject.connectSlotsByName(py_de)
####################################
## Method for creating a tab
####################################
def createTab(self, py_de, ext, filename=""):
newTabName = "tab" + str(self.centralwidget.count())
newTextEditName = "textEdit" + str(self.centralwidget.count())
print "createTab(): creating tab %s" % (newTabName)
self.tab = QtGui.QWidget()
self.tab.setObjectName(newTabName)
self.tablayout = QtGui.QGridLayout(self.tab)
self.centralwidget.addTab(self.tab,"")
newTabIndex = self.centralwidget.indexOf(self.tab)
if filename == "":
filename = "Untitled" + str((newTabIndex + 1))
newTabTitle = str(filename) + str(ext)
self.centralwidget.setCurrentIndex(self.centralwidget.indexOf(self.tab))
self.centralwidget.setTabText(newTabIndex, QtGui.QApplication.translate("py_de", newTabTitle, None, QtGui.QApplication.UnicodeUTF8))
self.textEdit = QsciScintilla(self.tab)
self.textEdit.setFont(self.font)
self.textEdit.setMarginsFont(self.font)
self.textEdit.setMarginWidth(0, self.fm.width( "00000" ) + 5)
self.textEdit.setMarginLineNumbers(0, True)
self.textEdit.setEdgeMode(QsciScintilla.EdgeLine)
self.textEdit.setEdgeColumn(80)
self.textEdit.setEdgeColor(QtGui.QColor("#FF0000"))
self.textEdit.setFolding(QsciScintilla.BoxedTreeFoldStyle)
self.textEdit.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.textEdit.setCaretLineVisible(True)
self.textEdit.setCaretLineBackgroundColor(QtGui.QColor("#CDA869"))
self.textEdit.setMarginsBackgroundColor(QtGui.QColor("#333333"))
self.textEdit.setMarginsForegroundColor(QtGui.QColor("#CCCCCC"))
self.textEdit.setFoldMarginColors(QtGui.QColor("#99CC66"),QtGui.QColor("#333300"))
lexer = QsciLexerPython()
lexer.setDefaultFont(self.font)
self.textEdit.setLexer(lexer)
self.textEdit.show()
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Policy(1),QtGui.QSizePolicy.Policy(1))
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.textEdit.sizePolicy().hasHeightForWidth())
self.textEdit.setSizePolicy(sizePolicy)
self.textEdit.setObjectName(newTextEditName)
self.tablayout.addWidget(self.textEdit, 0, 0, 1, 1)
#####################################
## Functions for menu button actions
#####################################
def openFile(self):
fileName = QFileDialog.getOpenFileName()
print fileName
index = fileName.lastIndexOf("/")
newFileName = fileName[index+1:]
print newFileName
self.createTab(py_de, "", newFileName)
self.textEdit.setText(open(fileName).read())
def printFile(self): # Needs some work...
printDialog = QPrintDialog(self.printer, py_de)
if printDialog.exec_() == QDialog.Accepted:
margin = 10
pageNum = 1
yPos = 0
printJob = QPainter()
printJob.begin(self.printer)
printJob.setFont(self.font)
fm = printJob.fontMetrics()
for i in range(self.textEdit.lines()):
if margin + yPos > self.printer.height() - margin:
pageNum += 1
self.printer.newPage()
yPos = 0
printJob.drawText(margin, # X
margin + yPos, # Y
self.printer.width(), # Width
self.printer.height(),# Height
QtCore.Qt.AlignTop, # Alignment
self.textEdit.text(i - 1)# The text to print
)
yPos += fm.lineSpacing()
printJob.end
def saveFile(self):
fileName = QFileDialog.getSaveFileName()
f = open(fileName, "w")
f.write(self.textEdit.text())
def saveAsFile(self):
QKeySequence(self.textEdit.trUtf8("Ctrl+Shft+S", "File|Save As"))
fileName = QFileDialog.getSaveFileName()
f = open(fileName, "w")
f.write(self.textEdit.text())
def goToLine(self):
maxLine = str(self.textEdit.lines())
newLineNumber, ok = QInputDialog.getInteger(self.centralwidget,
"Go to line",
"Line number: (1, " + maxLine+")")
if ok:
newLineNumber -= 1 # Convert from 1-based to 0-based
self.textEdit.ensureLineVisible(newLineNumber)
self.textEdit.setCursorPosition(newLineNumber, 0)
# TODO: Find docs on qscintilla's gotoline(int)
def cut(self):
QKeySequence(self.textEdit.trUtf8("Ctrl+X", "Edit|Cut"))
def copy(self):
QKeySequence(self.textEdit.trUtf8("Ctrl+C", "Edit|Copy"))
def paste(self):
QKeySequence(self.textEdit.trUtf8("Ctrl+V", "Edit|Paste"))
def find(self):
QKeySequence(self.textEdit.trUtf8("Ctrl+F", "Edit|Find"))
def newPythonFile(self):
ext = ".py"
self.createTab(py_de, ext)
def newCFile(self):
ext = ".cpp"
self.createTab(py_de, ext)
def newCHeaderFile(self):
ext = ".h"
self.createTab(py_de, ext)
def newFortranFile(self):
ext = ".f"
self.createTab(py_de, ext)
def closeTab(self):
self.centralwidget.removeTab(self.centralwidget.currentIndex())
##################################
## Function for adding actions to
## various menu items.
##################################
# Generates python code to create menu items then execs it
# Should never be passed any input from a user or a file.
def initAction(self, actionName, menus = None, shortCutKeys = None, iconFileName = None):
assert actionName[0:6] == "action"
commands = list()
commands.append("self." + actionName + "=QtGui.QAction(py_de)")
if shortCutKeys:
commands.append("self." + actionName + ".setShortcut('" + shortCutKeys + "')")
if iconFileName:
commands.append("self." + actionName + ".setIcon(QtGui.QIcon('" + self.imagesDir + iconFileName + "'))")
commands.append("self." + actionName + ".setObjectName('" + actionName + "')" )
if menus:
assert type(menus) == type(()) or type(menus) == type("string")
if type(menus) == type("string"): # Add action to only one menu
commands.append("self." + menus + ".addAction(self." + actionName + ")")
else: # Menus is a tuple of menus on which to add this action
for menu in menus:
commands.append("self." + menu + ".addAction(self." + actionName + ")")
for command in commands:
exec(command, globals(), locals())
def createActions(self, py_de):
self.menuFile.addAction(self.menuNew.menuAction())
self.initAction("actionCopy","menuEdit", "Ctrl+C", "edit-copy.png")
self.initAction("actionCut", "menuEdit", "Ctrl+X", "edit-cut.png")
self.initAction("actionPaste", "menuEdit", "Ctrl+V", "edit-paste.png")
self.initAction("actionSelect_All", "menuEdit", "Ctrl+A", "edit-select-all.png")
self.initAction("actionFind", "menuEdit", "Ctrl+F", "edit-find.png")
self.initAction("actionReplace", "menuEdit", "Ctrl+H")
self.initAction("actionGoToLine", "menuEdit", "Ctrl+G")
self.initAction("actionOpen", "menuFile", "Ctrl+O", "document-open.png")
self.initAction("actionSave", "menuFile", "Ctrl+S", "document-save.png")
self.initAction("actionSave_As", "menuFile", "Ctrl+Shift+S", "document-save-as.png")
self.initAction("actionPrint", "menuFile", "Ctrl+P", "document-print.png")
self.initAction("actionClose", "menuFile", "Ctrl+W", "dialog-close.png")
self.initAction("actionQuit", "menuFile", None, "application-exit.png")
self.initAction("actionBuild", "menuBuild", "F7", "run-build-file.png")
self.initAction("actionBuild_All", "menuBuild", "Ctrl+Alt+F7", "run-build.png")
self.initAction("actionRun", "menuBuild", "F5", "arrow-right.png")
self.initAction("actionClean", "menuBuild", "Ctrl+Shift+C", "edit-clear.png")
self.initAction("actionAbout", "menuHelp", None, "help-about.png")
self.initAction("actionSelect_Language", None, None, None)
self.initAction("actionFortran", "menuNew", None, "file-fortran.png")
self.initAction("actionC", "menuNew", None, "file-cpp.png")
self.initAction("actionPython_File", "menuNew", "file-python.png")
self.initAction("actionC_Header_File_h", "menuNew", None, "file-header.png")
self.initAction("actionNewTemplate", ("menuNew", "menuTools"), None, "document-new.png")
self.menuNew.setIcon(QtGui.QIcon(self.imagesDir + "document-new.png"))
self.menuTools.addAction(self.menuFormat.menuAction())
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuEdit.menuAction())
self.menubar.addAction(self.menuBuild.menuAction())
self.menubar.addAction(self.menuTools.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
####################################
## Method for creating a toolbar
####################################
def createToolBar(self, py_de):
self.toolBar = QtGui.QToolBar(py_de)
self.toolBar.setObjectName("toolBar")
py_de.addToolBar(QtCore.Qt.TopToolBarArea,self.toolBar)
self.toolBar.addAction(self.actionBuild)
####################################
## Method for creating menus
####################################
def createMenus(self, py_de):
self.menubar = QtGui.QMenuBar(py_de)
self.menubar.setGeometry(QtCore.QRect(0,0,502,26))
self.menubar.setObjectName("menubar")
self.menuFile = QtGui.QMenu(self.menubar)
self.menuFile.setObjectName("menuFile")
self.menuNew = QtGui.QMenu(self.menuFile)
self.menuNew.setObjectName("menuNew")
self.menuEdit = QtGui.QMenu(self.menubar)
self.menuEdit.setObjectName("menuEdit")
self.menuBuild = QtGui.QMenu(self.menubar)
self.menuBuild.setObjectName("menuBuild")
self.menuTools = QtGui.QMenu(self.menubar)
self.menuTools.setObjectName("menuTools")
self.menuFormat = QtGui.QMenu(self.menuTools)
self.menuFormat.setObjectName("menuFormat")
self.menuHelp = QtGui.QMenu(self.menubar)
self.menuHelp.setObjectName("menuHelp")
py_de.setMenuBar(self.menubar)
def retranslateUi(self, py_de):
py_de.setWindowTitle(QtGui.QApplication.translate("py_de", "py_de", None, QtGui.QApplication.UnicodeUTF8))
self.menuFile.setTitle(QtGui.QApplication.translate("py_de", "File", None, QtGui.QApplication.UnicodeUTF8))
self.menuNew.setTitle(QtGui.QApplication.translate("py_de", "New", None, QtGui.QApplication.UnicodeUTF8))
self.menuEdit.setTitle(QtGui.QApplication.translate("py_de", "Edit", None, QtGui.QApplication.UnicodeUTF8))
self.menuBuild.setTitle(QtGui.QApplication.translate("py_de", "Build", None, QtGui.QApplication.UnicodeUTF8))
self.menuTools.setTitle(QtGui.QApplication.translate("py_de", "Tools", None, QtGui.QApplication.UnicodeUTF8))
self.menuFormat.setTitle(QtGui.QApplication.translate("py_de", "Format", None, QtGui.QApplication.UnicodeUTF8))
self.menuHelp.setTitle(QtGui.QApplication.translate("py_de", "Help", None, QtGui.QApplication.UnicodeUTF8))
self.toolBar.setWindowTitle(QtGui.QApplication.translate("py_de", "py_de", None, QtGui.QApplication.UnicodeUTF8))
self.actionCopy.setText(QtGui.QApplication.translate("py_de", "Copy", None, QtGui.QApplication.UnicodeUTF8))
self.actionCut.setText(QtGui.QApplication.translate("py_de", "Cut", None, QtGui.QApplication.UnicodeUTF8))
self.actionPaste.setText(QtGui.QApplication.translate("py_de", "Paste", None, QtGui.QApplication.UnicodeUTF8))
self.actionSelect_All.setText(QtGui.QApplication.translate("py_de", "Select All", None, QtGui.QApplication.UnicodeUTF8))
self.actionFind.setText(QtGui.QApplication.translate("py_de", "Find", None, QtGui.QApplication.UnicodeUTF8))
self.actionReplace.setText(QtGui.QApplication.translate("py_de", "Replace", None, QtGui.QApplication.UnicodeUTF8))
self.actionGoToLine.setText(QtGui.QApplication.translate("py_de", "Go To Line", None, QtGui.QApplication.UnicodeUTF8))
self.actionOpen.setText(QtGui.QApplication.translate("py_de", "Open", None, QtGui.QApplication.UnicodeUTF8))
self.actionSave.setText(QtGui.QApplication.translate("py_de", "Save", None, QtGui.QApplication.UnicodeUTF8))
self.actionSave_As.setText(QtGui.QApplication.translate("py_de", "Save As", None, QtGui.QApplication.UnicodeUTF8))
self.actionPrint.setText(QtGui.QApplication.translate("py_de", "Print", None, QtGui.QApplication.UnicodeUTF8))
self.actionClose.setText(QtGui.QApplication.translate("py_de", "Close", None, QtGui.QApplication.UnicodeUTF8))
self.actionQuit.setText(QtGui.QApplication.translate("py_de", "Quit Py-DE", None, QtGui.QApplication.UnicodeUTF8))
self.actionBuild.setText(QtGui.QApplication.translate("py_de", "Build", None, QtGui.QApplication.UnicodeUTF8))
self.actionBuild_All.setText(QtGui.QApplication.translate("py_de", "Build All", None, QtGui.QApplication.UnicodeUTF8))
self.actionRun.setText(QtGui.QApplication.translate("py_de", "Run", None, QtGui.QApplication.UnicodeUTF8))
self.actionClean.setText(QtGui.QApplication.translate("py_de", "Clean", None, QtGui.QApplication.UnicodeUTF8))
self.actionAbout.setText(QtGui.QApplication.translate("py_de", "About Py-DE", None, QtGui.QApplication.UnicodeUTF8))
self.actionSelect_Language.setText(QtGui.QApplication.translate("py_de", "Select Language", None, QtGui.QApplication.UnicodeUTF8))
self.actionFortran.setText(QtGui.QApplication.translate("py_de", "Fortran File (.f)", None, QtGui.QApplication.UnicodeUTF8))
self.actionC.setText(QtGui.QApplication.translate("py_de", "C++ Implementation File (.cpp)", None, QtGui.QApplication.UnicodeUTF8))
self.actionPython_File.setText(QtGui.QApplication.translate("py_de", "Python File (.py)", None, QtGui.QApplication.UnicodeUTF8))
self.actionC_Header_File_h.setText(QtGui.QApplication.translate("py_de", "C++ Header File (.h)", None, QtGui.QApplication.UnicodeUTF8))
self.centralwidget.setTabText(self.centralwidget.indexOf(self.tab), QtGui.QApplication.translate("py_de", "Untitled 1", None, QtGui.QApplication.UnicodeUTF8))
self.actionNewTemplate.setText(QtGui.QApplication.translate("py_de", "Add file as new template", None, QtGui.QApplication.UnicodeUTF8))
def newTemplate(self):
o = pydeTemplates.pydeTemplates("templates")
listLanguage = QtCore.QStringList()
listLanguage.append("Fortran")
listLanguage.append("Python")
listLanguage.append("C++")
language, res = QtGui.QInputDialog.getItem(self.centralwidget,
QtGui.QApplication.translate("py_de", "Language templates", None, QtGui.QApplication.UnicodeUTF8),
QtGui.QApplication.translate("py_de", "Choose language", None, QtGui.QApplication.UnicodeUTF8),
listLanguage)
if res:
templateName, res = QtGui.QInputDialog.getText(self.centralwidget,
QtGui.QApplication.translate("py_de", "Template name", None, QtGui.QApplication.UnicodeUTF8),
QtGui.QApplication.translate("py_de", "Template name", None, QtGui.QApplication.UnicodeUTF8))
if res:
lang=""
if language == "Fortran":
lang="f"
elif language == "C++":
lang="cpp"
elif language == "Python":
lang="py"
o.newTemplate(self.textEdit.text(), lang, templateName)
def template(self, language):
# Upgrade: in tools menu, add some functionalities for templates (add/remove template...) -
#load list of templates for language selected
o = pydeTemplates.pydeTemplates("templates")
templates = QtCore.QStringList(o.getTemplatesListOf(language))
templates.prepend("Empty")
#display dialogbox with a listbox containing list of templates
template, res = QtGui.QInputDialog.getItem(self.centralwidget,
QtGui.QApplication.translate("py_de", "Language templates", None, QtGui.QApplication.UnicodeUTF8),
QtGui.QApplication.translate("py_de", "Choose template", None, QtGui.QApplication.UnicodeUTF8),
templates)
if res:
#load template in the editor
self.textEdit.setText(o.loadTemplate(language, template))
def exportCompo(self, cView, folder, title, extension):
"""Function that sets how to export files."""
printer = QPrinter()
painter = QPainter()
self.msgWMSWarning(cView)
# Disable advanced effects if not printing as raster
# due to problem with QPrinter
if extension == '.pdf':
if cView.composition().printAsRaster():
cView.composition().setUseAdvancedEffects(True)
else:
cView.composition().setUseAdvancedEffects(False)
myAtlas = cView.composition().atlasComposition()
# Prepare the composition if it has an atlas
if myAtlas.enabled():
myAtlas.beginRender()
if hasattr(cView.composition(), "atlasMode"): # for QGIS<2.2
previous_mode = cView.composition().atlasMode()
cView.composition().setAtlasMode(QgsComposition.ExportAtlas)
# If there's no pattern for filename,
# inform that a default one will be used and set it.
if len(myAtlas.filenamePattern()) == 0:
self.iface.messageBar().pushMessage(
self.tr(u'Empty filename pattern'),
self.
tr(u'The print composer "{}" has an empty filename pattern. {}_$feature is used as default.'
).format(title, title),
level=QgsMessageBar.WARNING)
myAtlas.setFilenamePattern(u"'{}_'||$feature".format(title))
# Set page progressbar maximum value
# possible for atlases once the rendering has begun
if myAtlas.enabled():
if extension == '.pdf':
maxpages = myAtlas.numFeatures()
else:
maxpages = myAtlas.numFeatures() * cView.composition(
).numPages()
else:
if extension == '.pdf': maxpages = 1
else:
maxpages = cView.composition().numPages()
self.dlg.pageBar.setValue(0)
self.dlg.pageBar.setMaximum(maxpages)
# Do the export process
if myAtlas.enabled():
for i in range(0, myAtlas.numFeatures()):
if self.arret: break
# process input events
QCoreApplication.processEvents()
myAtlas.prepareForFeature(i)
current_fileName = myAtlas.currentFilename()
# export atlas to pdf format
if extension == '.pdf':
if myAtlas.singleFile():
cView.composition().beginPrintAsPDF(
printer, os.path.join(folder, title + '.pdf'))
cView.composition().beginPrint(printer)
printReady = painter.begin(printer)
if i > 0:
printer.newPage()
cView.composition().doPrint(printer, painter)
else:
cView.composition().exportAsPDF(
os.path.join(folder, current_fileName + '.pdf'))
#increase progressbar
self.pageProcessed()
# export atlas to image format
else:
self.printToRaster(cView, folder, current_fileName,
extension)
myAtlas.endRender()
painter.end()
# Reset atlas mode to its original value and, if needed, atlas map
if hasattr(cView.composition(), "atlasMode"): #for QGIS<2.2
cView.composition().setAtlasMode(previous_mode)
if cView.composition().atlasMode(
) == QgsComposition.PreviewAtlas:
myAtlas.firstFeature()
# if the composition has no atlas
else:
if extension == '.pdf':
cView.composition().exportAsPDF(
os.path.join(folder, title + '.pdf'))
else:
self.printToRaster(cView, folder, title, extension)
self.pageProcessed()
# Reactivate the use of advanced effects if it has been disabled before export
if not cView.composition().useAdvancedEffects():
cView.composition().setUseAdvancedEffects(True)
