def printProfile(self):
printer = QPrinter(QPrinter.HighResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QPrinter.A4)
printer.setOrientation(QPrinter.Landscape)
printpreviewdlg = QPrintPreviewDialog()
printpreviewdlg.paintRequested.connect(self.printRequested)
printpreviewdlg.exec_()
def exportPDF(self, view, file_name, width, height):
pdf = QPrinter()
pdf.setOutputFormat(QPrinter.PdfFormat)
pdf.setPrintRange(QPrinter.AllPages)
pdf.setOrientation(QPrinter.Portrait)
pdf.setResolution(QPrinter.HighResolution)
pdf.setPaperSize(QSizeF(width, height), QPrinter.Point)
pdf.setFullPage(True)
pdf.setOutputFileName(file_name)
view.mainFrame().print_(pdf)
QApplication.restoreOverrideCursor()
def print_to_pdf(self,
path,
paper_size = (8.5, 11.0),
paper_margins = (0, 0, 0, 0),
paper_units = QPrinter.Inch,
zoom_factor = 1.0,
):
"""Saves page as a pdf file.
See qt4 QPrinter documentation for more detailed explanations
of options.
:param path: The destination path.
:param paper_size: A 2-tuple indicating size of page to print to.
:param paper_margins: A 4-tuple indicating size of each margin.
:param paper_units: Units for pager_size, pager_margins.
:param zoom_factor: Scale the output content.
"""
assert len(paper_size) == 2
assert len(paper_margins) == 4
printer = QPrinter(mode = QPrinter.ScreenResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QtCore.QSizeF(*paper_size), paper_units)
printer.setPageMargins(*(paper_margins + (paper_units,)))
printer.setFullPage(True)
printer.setOutputFileName(path)
if self.webview is None:
self.webview = QtWebKit.QWebView()
self.webview.setPage(self.page)
self.webview.setZoomFactor(zoom_factor)
self.webview.print_(printer)
def __createPdf(self, savePath):
"""
Diese Funktion druckt den Charakter in ein PDF-Dokument.
"""
# Wenn Unterverzeichnis nicht existiert, erstelle es
dirname = os.path.dirname(savePath)
if not os.path.exists(dirname):
os.makedirs(dirname)
printer = QPrinter(QPrinter.PrinterResolution)
#printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QPrinter.A4)
printer.setFullPage(True)
printer.setOutputFileName(savePath)
drawSheet = RenderSheet(self.__storage, self.__character, printer,
self)
try:
drawSheet.createSheets()
except ErrSpeciesNotExisting as e:
MessageBox.exception(self, e.message, e.description)
def plotPDF(self, width, height, output_file, units = "pixels", _plotting_object = None):
"""Plots the data specified in the current input file as a page in a
PDF file with the given width and height, writing the output to the
specified output file. The optional units argument specifies the units
used to measure the plot size; by default, pixels are used, but "cm",
"mm" and "in" are also acceptable.
Returns the QPrinter object used to write the file."""
pdf = QPrinter()
pdf.setOutputFormat(QPrinter.PdfFormat)
pdf.setOutputFileName(output_file)
if units == "in":
width = pdf.logicalDpiX() * width
height = pdf.logicalDpiY() * height
elif units == "cm":
width = pdf.logicalDpiX() * (width / 2.54)
height = pdf.logicalDpiY() * (height / 2.54)
elif units == "mm":
width = pdf.logicalDpiX() * (width / 25.4)
height = pdf.logicalDpiY() * (height / 25.4)
elif units != "pixels":
raise BDianaError, "Unknown units specified to plotPDF: %s" % units
pdf.setPaperSize(QSizeF(width, height), QPrinter.DevicePixel)
pdf.setFullPage(True)
return self._plot(width, height, pdf, _plotting_object)[0]
def print_to_pdf(
self,
path,
paper_size=(8.5, 11.0),
paper_margins=(0, 0, 0, 0),
paper_units=QPrinter.Inch,
zoom_factor=1.0,
):
"""Saves page as a pdf file.
See qt4 QPrinter documentation for more detailed explanations
of options.
:param path: The destination path.
:param paper_size: A 2-tuple indicating size of page to print to.
:param paper_margins: A 4-tuple indicating size of each margin.
:param paper_units: Units for pager_size, pager_margins.
:param zoom_factor: Scale the output content.
"""
assert len(paper_size) == 2
assert len(paper_margins) == 4
printer = QPrinter(mode=QPrinter.ScreenResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QtCore.QSizeF(*paper_size), paper_units)
printer.setPageMargins(*(paper_margins + (paper_units, )))
printer.setFullPage(True)
printer.setOutputFileName(path)
if self.webview is None:
self.webview = QtWebKit.QWebView()
self.webview.setPage(self.page)
self.webview.setZoomFactor(zoom_factor)
self.webview.print_(printer)
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 on_actionFitPage_triggered(self):
papersize = self._getPaperSize()
printer = QPrinter()
printer.setPaperSize(papersize)
widthInPixels = printer.pageRect().width()
maxColumns = self.songProperties.maxColumns(widthInPixels)
self.widthSpinBox.setValue(maxColumns)
self.scoreScene.reBuild()
def on_actionFitPage_triggered(self):
papersize = self._getPaperSize()
printer = QPrinter()
printer.setPaperSize(papersize)
widthInPixels = printer.pageRect().width()
maxColumns = self.songProperties.maxColumns(widthInPixels)
self.widthSpinBox.setValue(maxColumns)
self.scoreScene.reBuild()
def printProfile(self):
printer = QPrinter(QPrinter.HighResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QPrinter.A4)
printer.setOrientation(QPrinter.Landscape)
printpreviewdlg = QPrintPreviewDialog()
printpreviewdlg.paintRequested.connect(self.printRequested)
printpreviewdlg.exec_()
def exportPDF(self, view, file_name, width, height):
pdf = QPrinter()
pdf.setOutputFormat(QPrinter.PdfFormat)
pdf.setPrintRange(QPrinter.AllPages)
pdf.setOrientation(QPrinter.Portrait)
pdf.setResolution(QPrinter.HighResolution)
pdf.setPaperSize(QSizeF(width, height), QPrinter.Point)
pdf.setFullPage(True)
pdf.setOutputFileName(file_name)
view.mainFrame().print_(pdf)
QApplication.restoreOverrideCursor()
def __init__(self, parent=None, fakeStartup=False, filename=None):
'''
Constructor
'''
self._fakeStartup = fakeStartup
super(DrumBurp, self).__init__(parent)
self._state = None
self._asciiSettings = None
self._printer = None
self.setupUi(self)
self.scoreScene = None
self.paperBox.blockSignals(True)
self.paperBox.clear()
self._knownPageHeights = []
printer = QPrinter()
printer.setOutputFileName("invalid.pdf")
for name in dir(QPrinter):
attr = getattr(QPrinter, name)
if (isinstance(attr, QPrinter.PageSize) and name != "Custom"):
self.paperBox.addItem(name)
printer.setPaperSize(attr)
self._knownPageHeights.append(printer.pageRect().height())
self._pageHeight = printer.paperRect().height()
self.paperBox.blockSignals(False)
settings = self._makeQSettings()
self.recentFiles = [
unicode(fname)
for fname in settings.value("RecentFiles").toStringList()
if os.path.exists(unicode(fname))
]
if filename is None:
filename = (None
if len(self.recentFiles) == 0 else self.recentFiles[0])
self.filename = filename
self.addToRecentFiles()
self.updateRecentFiles()
self.songProperties = QDisplayProperties()
# Create scene
self.scoreScene = QScore(self)
self.restoreGeometry(settings.value("Geometry").toByteArray())
self.restoreState(settings.value("MainWindow/State").toByteArray())
self.statusbar.addPermanentWidget(QFrame())
self.availableNotesLabel = QLabel()
self.availableNotesLabel.setMinimumWidth(250)
self.statusbar.addPermanentWidget(self.availableNotesLabel)
self._infoBar = QLabel()
self.statusbar.addPermanentWidget(self._infoBar)
self._initializeState()
self.setSections()
QTimer.singleShot(0, self._startUp)
self.actionCheckOnStartup.setChecked(
settings.value("CheckOnStartup").toBool())
def __saveAsPDF(self, fileName):
" Saves the flowchart as an PDF file "
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QSizeF(self.scene.width(), self.scene.height()),
QPrinter.Point)
printer.setFullPage(True)
printer.setOutputFileName(fileName)
painter = QPainter(printer)
self.scene.render(painter)
painter.end()
return
def __saveAsPDF( self, fileName ):
" Saves the flowchart as an PDF file "
printer = QPrinter()
printer.setOutputFormat( QPrinter.PdfFormat )
printer.setPaperSize( QSizeF( self.scene.width(),
self.scene.height() ), QPrinter.Point )
printer.setFullPage( True )
printer.setOutputFileName( fileName )
painter = QPainter( printer )
self.scene.render( painter )
painter.end()
return
class WebKitPDF ( QObject ):
def __init__ ( self, url, dest ):
QObject.__init__ ( self )
self.dest = dest
self.page = QtWebKit.QWebPage ( self )
self.mainFrame = self.page.mainFrame()
self.mainFrame.load ( QUrl ( url ) )
# Settings
# Disable the scrollbars
self.mainFrame.setScrollBarPolicy(Qt.Horizontal, Qt.ScrollBarAlwaysOff)
self.mainFrame.setScrollBarPolicy(Qt.Vertical, Qt.ScrollBarAlwaysOff)
self.connect ( self.page,
SIGNAL ( "loadProgress(int)" ),
self.loadProgress )
self.connect ( self.page,
SIGNAL ( "loadFinished(bool)" ),
self.renderPDF )
def loadProgress ( self, progress ):
print "Progress: ", progress
def renderPDF ( self, status ):
print "Load finished with status: ", status
print "Rendering PDF ..."
contentsSize = self.mainFrame.contentsSize()
contentsSize.setWidth(1280)
self.page.setViewportSize ( contentsSize )
self.printer = QPrinter ( QPrinter.PrinterResolution )
#self.printer = QPrinter ( QPrinter.ScreenResolution )
self.printer.setOutputFormat ( QPrinter.PdfFormat )
#self.printer.setPaperSize ( QPrinter.A4 )
self.printer.setFullPage( True )
self.printer.setPaperSize ( QSizeF( contentsSize ), QPrinter.DevicePixel )
self.printer.setOrientation ( QPrinter.Portrait )
self.printer.setOutputFileName ( self.dest )
self.painter = QPainter ( self.printer )
self.painter.setRenderHint ( QPainter.Antialiasing )
self.mainFrame.render ( self.painter )
self.painter.end()
app = QtGui.QApplication.instance()
app.exit ( 0 )
def __init__(self, parent = None, fakeStartup = False, filename = None):
'''
Constructor
'''
self._fakeStartup = fakeStartup
super(DrumBurp, self).__init__(parent)
self._state = None
self._asciiSettings = None
self._printer = None
self.setupUi(self)
self.scoreScene = None
self.paperBox.blockSignals(True)
self.paperBox.clear()
self._knownPageHeights = []
printer = QPrinter()
printer.setOutputFileName("invalid.pdf")
for name in dir(QPrinter):
attr = getattr(QPrinter, name)
if (isinstance(attr, QPrinter.PageSize)
and name != "Custom"):
self.paperBox.addItem(name)
printer.setPaperSize(attr)
self._knownPageHeights.append(printer.pageRect().height())
self._pageHeight = printer.paperRect().height()
self.paperBox.blockSignals(False)
settings = self._makeQSettings()
self.recentFiles = [unicode(fname) for fname in
settings.value("RecentFiles").toStringList()
if os.path.exists(unicode(fname))]
if filename is None:
filename = (None
if len(self.recentFiles) == 0
else self.recentFiles[0])
self.filename = filename
self.addToRecentFiles()
self.updateRecentFiles()
self.songProperties = QDisplayProperties()
# Create scene
self.scoreScene = QScore(self)
self.restoreGeometry(settings.value("Geometry").toByteArray())
self.restoreState(settings.value("MainWindow/State").toByteArray())
self.statusbar.addPermanentWidget(QFrame())
self.availableNotesLabel = QLabel()
self.availableNotesLabel.setMinimumWidth(250)
self.statusbar.addPermanentWidget(self.availableNotesLabel)
self._infoBar = QLabel()
self.statusbar.addPermanentWidget(self._infoBar)
self._initializeState()
self.setSections()
QTimer.singleShot(0, self._startUp)
self.actionCheckOnStartup.setChecked(settings.value("CheckOnStartup").toBool())
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 imprimir(self):
printer=QPrinter(QPrinter.HighResolution)
printer.setPaperSize(QPrinter.Letter)
printer.setOutputFormat(QPrinter.PdfFormat)
ruta=os.path.join(self.parent.cfg.get("factura", "ruta"),'Factura-'+str(self.num)+'.pdf')
printer.setOutputFileName(ruta)
prev=QPrintDialog(printer,self.padre)
if prev.exec_()==QDialog.Accepted:
paint=QPainter()
paint.begin(printer)
self.escena.render(paint)
paint.end()
print "Imprimiendo..."
if sys.platform == 'linux2':
os.system("gnome-open '%s' "%ruta)
elif sys.platform == 'win32':
os.system("start '%s'"%ruta)
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 on_actionExportPDF_triggered(self):
try:
printer = QPrinter(mode = QPrinter.HighResolution)
printer.setPaperSize(self._getPaperSize())
printer.setOutputFormat(QPrinter.PdfFormat)
if self.filename:
outfileName = list(os.path.splitext(self.filename)[:-1])
outfileName = os.extsep.join(outfileName + ["pdf"])
else:
outfileName = "Untitled.pdf"
printer.setOutputFileName(outfileName)
printer.setPaperSize(self._getPaperSize())
dialog = QPrintPreviewDialog(printer, parent = self)
def updatePages(qprinter):
self.scoreScene.printScore(qprinter, self.scoreView)
dialog.paintRequested.connect(updatePages)
dialog.exec_()
self.updateStatus("Exported to PDF %s" % outfileName)
except StandardError:
QMessageBox.warning(self.parent(), "Export failed!",
"Could not export PDF to " + outfileName)
def on_actionExportPDF_triggered(self):
try:
printer = QPrinter(mode=QPrinter.HighResolution)
printer.setPaperSize(self._getPaperSize())
printer.setOutputFormat(QPrinter.PdfFormat)
if self.filename:
outfileName = list(os.path.splitext(self.filename)[:-1])
outfileName = os.extsep.join(outfileName + ["pdf"])
else:
outfileName = "Untitled.pdf"
printer.setOutputFileName(outfileName)
printer.setPaperSize(self._getPaperSize())
dialog = QPrintPreviewDialog(printer, parent=self)
def updatePages(qprinter):
self.scoreScene.printScore(qprinter, self.scoreView)
dialog.paintRequested.connect(updatePages)
dialog.exec_()
self.updateStatus("Exported to PDF %s" % outfileName)
except StandardError:
QMessageBox.warning(self.parent(), "Export failed!",
"Could not export PDF to " + outfileName)
def print_document(document, verse_key, pdf = False, copies=1, skip=False):
printer = QPrinter(QPrinter.HighResolution)
if not pdf: printer.setOutputFormat(QPrinter.NativeFormat)
else:
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(ROOT + 'verse.pdf')
printer.setPaperSize(QPrinter.A4)
printer.setCopyCount(copies)
printer.setPageMargins(10, 10, 10, 10, QPrinter.Millimeter)
doc = QTextDocument()
doc.setHtml(concatenate_pages(document, verse_key, skip))
dialog = QPrintPreviewDialog(printer)
dialog.setWindowFlags(Qt.Window)
dialog.setWindowTitle('Print preview: parse results')
def preview(): doc.print_(printer)
dialog.paintRequested.connect(preview)
dialog.exec_()
class WebKitPDF(QObject):
def __init__(self, url, dest):
QObject.__init__(self)
self.dest = dest
self.page = QtWebKit.QWebPage(self)
self.mainFrame = self.page.mainFrame()
self.mainFrame.load(QUrl(url))
self.connect(self.page, SIGNAL("loadProgress(int)"), self.loadProgress)
self.connect(self.page, SIGNAL("loadFinished(bool)"), self.renderPDF)
def loadProgress(self, progress):
print "Progress: ", progress
def renderPDF(self, status):
print "Load finished with status: ", status
print "Rendering PDF ..."
contentsSize = self.mainFrame.contentsSize()
self.page.setViewportSize(contentsSize)
self.printer = QPrinter(QPrinter.PrinterResolution)
#self.printer = QPrinter ( QPrinter.ScreenResolution )
self.printer.setOutputFormat(QPrinter.PdfFormat)
#self.printer.setPaperSize ( QPrinter.A4 )
self.printer.setFullPage(True)
self.printer.setPaperSize(QSizeF(contentsSize), QPrinter.DevicePixel)
self.printer.setOrientation(QPrinter.Portrait)
self.printer.setOutputFileName(self.dest)
self.painter = QPainter(self.printer)
self.painter.setRenderHint(QPainter.Antialiasing)
self.mainFrame.render(self.painter)
self.painter.end()
app = QtGui.QApplication.instance()
app.exit(0)
def __createPdf(self, savePath): """ Diese Funktion druckt den Charakter in ein PDF-Dokument. """ # Wenn Unterverzeichnis nicht existiert, erstelle es dirname = os.path.dirname(savePath) if not os.path.exists(dirname): os.makedirs(dirname) printer = QPrinter(QPrinter.PrinterResolution) #printer = QPrinter() printer.setOutputFormat( QPrinter.PdfFormat ) printer.setPaperSize( QPrinter.A4 ) printer.setFullPage( True ) printer.setOutputFileName( savePath ) drawSheet = RenderSheet( self.__storage, self.__character, printer, self ) try: drawSheet.createSheets() except ErrSpeciesNotExisting as e: MessageBox.exception( self, e.message, e.description )
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()
def render_pdf(self, page, fileName, paperSize=None):
"""Renders the page into a pdf
:param page: The webpage that we want to render
:param fileName: The path where we want to save the pdf.
For example /home/user/mypdf.pdf
:param paperSize: An PaperSize object that will be used
to render the webpage
"""
mainFrame = page.currentFrame()
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(fileName)
printer.setResolution(self._get_default_dpi())
if paperSize is None:
ps = mainFrame.contentsSize()
paperSize = PaperSize(width=ps.width(),
height=ps.width(),
margin=(0, 0, 0, 0),
orientation=None,
page_type=None)
if paperSize.page_type is not None:
if paperSize.orientation.lower() == "landscape":
orientation = QPrinter.Landscape
else:
orientation = QPrinter.Portrait
printer.setOrientation(orientation)
printer.setPaperSize(QPrinter.A4) # Fallback
for f in self.PAGE_TYPE:
if paperSize.page_type.lower() == f[0].lower():
printer.setPaperSize(f[1])
break
else:
sizePt = QSizeF(paperSize.width,
paperSize.height)
printer.setPaperSize(sizePt, QPrinter.Point)
printer.setPageMargins(paperSize.margin[0],
paperSize.margin[1],
paperSize.margin[2],
paperSize.margin[3],
QPrinter.Point)
mainFrame.print_(printer)
def renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_page.mainFrame().contentsSize())
paperSize['width'] = str(pageSize.width()) + 'px'
paperSize['height'] = str(pageSize.height()) + 'px'
paperSize['border'] = '0px'
if paperSize.get('width') and paperSize.get('height'):
sizePt = QSizeF(ceil(self.stringToPointSize(paperSize['width'])),
ceil(self.stringToPointSize(paperSize['height'])))
p.setPaperSize(sizePt, QPrinter.Point)
elif 'format' in paperSize:
orientation = QPrinter.Landscape if paperSize.get(
'orientation') and paperSize['orientation'].lower(
) == 'landscape' else QPrinter.Portrait
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
'A3': QPrinter.A3,
'A4': QPrinter.A4,
'A5': QPrinter.A5,
'Legal': QPrinter.Legal,
'Letter': QPrinter.Letter,
'Tabloid': QPrinter.Tabloid
}
p.setPaperSize(QPrinter.A4) # fallback
for format, size in formats.items():
if format.lower() == paperSize['format'].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(
paperSize['border'])) if paperSize.get('border') else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_page.mainFrame().print_(p)
return True
def renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_page.mainFrame().contentsSize())
paperSize['width'] = str(pageSize.width()) + 'px'
paperSize['height'] = str(pageSize.height()) + 'px'
paperSize['border'] = '0px'
if paperSize.get('width') and paperSize.get('height'):
sizePt = QSizeF(ceil(self.stringToPointSize(paperSize['width'])),
ceil(self.stringToPointSize(paperSize['height'])))
p.setPaperSize(sizePt, QPrinter.Point)
elif 'format' in paperSize:
orientation = QPrinter.Landscape if paperSize.get('orientation') and paperSize['orientation'].lower() == 'landscape' else QPrinter.Portrait
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
'A3': QPrinter.A3,
'A4': QPrinter.A4,
'A5': QPrinter.A5,
'Legal': QPrinter.Legal,
'Letter': QPrinter.Letter,
'Tabloid': QPrinter.Tabloid
}
p.setPaperSize(QPrinter.A4) # fallback
for format, size in formats.items():
if format.lower() == paperSize['format'].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(paperSize['border'])) if paperSize.get('border') else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_page.mainFrame().print_(p)
return True
c.setPlotStyle(QgsComposition.Print)
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))
class DrumBurp(QMainWindow, Ui_DrumBurpWindow):
'''
classdocs
'''
def __init__(self, parent = None, fakeStartup = False, filename = None):
'''
Constructor
'''
self._fakeStartup = fakeStartup
super(DrumBurp, self).__init__(parent)
self._state = None
self._asciiSettings = None
self._printer = None
self.setupUi(self)
self.scoreScene = None
self.paperBox.blockSignals(True)
self.paperBox.clear()
self._knownPageHeights = []
printer = QPrinter()
printer.setOutputFileName("invalid.pdf")
for name in dir(QPrinter):
attr = getattr(QPrinter, name)
if (isinstance(attr, QPrinter.PageSize)
and name != "Custom"):
self.paperBox.addItem(name)
printer.setPaperSize(attr)
self._knownPageHeights.append(printer.pageRect().height())
self._pageHeight = printer.paperRect().height()
self.paperBox.blockSignals(False)
settings = self._makeQSettings()
self.recentFiles = [unicode(fname) for fname in
settings.value("RecentFiles").toStringList()
if os.path.exists(unicode(fname))]
if filename is None:
filename = (None
if len(self.recentFiles) == 0
else self.recentFiles[0])
self.filename = filename
self.addToRecentFiles()
self.updateRecentFiles()
self.songProperties = QDisplayProperties()
# Create scene
self.scoreScene = QScore(self)
self.restoreGeometry(settings.value("Geometry").toByteArray())
self.restoreState(settings.value("MainWindow/State").toByteArray())
self.statusbar.addPermanentWidget(QFrame())
self.availableNotesLabel = QLabel()
self.availableNotesLabel.setMinimumWidth(250)
self.statusbar.addPermanentWidget(self.availableNotesLabel)
self._infoBar = QLabel()
self.statusbar.addPermanentWidget(self._infoBar)
self._initializeState()
self.setSections()
QTimer.singleShot(0, self._startUp)
self.actionCheckOnStartup.setChecked(settings.value("CheckOnStartup").toBool())
def _connectSignals(self, props, scene):
# Connect signals
props.fontChanged.connect(self._setNoteFont)
props.noteSizeChanged.connect(self.noteSizeSpinBox.setValue)
props.sectionFontChanged.connect(self._setSectionFont)
props.sectionFontSizeChanged.connect(self._setSectionFontSize)
props.metadataFontChanged.connect(self._setMetadataFont)
props.metadataFontSizeChanged.connect(self._setMetadataSize)
scene.dirtySignal.connect(self.setWindowModified)
scene.dragHighlight.connect(self.actionLoopBars.setEnabled)
scene.dragHighlight.connect(self.actionPlayOnce.setEnabled)
scene.dragHighlight.connect(self.actionCopyMeasures.setEnabled)
scene.dragHighlight.connect(self.checkPasteMeasure)
scene.dragHighlight.connect(self.actionClearMeasures.setEnabled)
scene.dragHighlight.connect(self.actionDeleteMeasures.setEnabled)
scene.sceneFormatted.connect(self.sceneFormatted)
scene.playing.connect(self._scorePlaying)
scene.currentHeadsChanged.connect(self.availableNotesLabel.setText)
scene.statusMessageSet.connect(self._setStatusFromScene)
scene.lilysizeChanged.connect(self._setLilySize)
scene.lilypagesChanged.connect(self._setLilyPages)
scene.lilyFillChanged.connect(self._setLilyFill)
self.paperBox.currentIndexChanged.connect(self._setPaperSize)
props.kitDataVisibleChanged.connect(self._setKitDataVisible)
props.emptyLinesVisibleChanged.connect(self._setEmptyLinesVisible)
props.measureCountsVisibleChanged.connect(self._setMeasureCountsVisible)
props.metadataVisibilityChanged.connect(self._setMetadataVisible)
props.beatCountVisibleChanged.connect(self._setBeatCountVisible)
DBMidi.SONGEND_SIGNAL.connect(self.musicDone)
DBMidi.HIGHLIGHT_SIGNAL.connect(self.highlightPlayingMeasure)
def _initializeState(self):
props = self.songProperties
scene = self.scoreScene
self.scoreView.setScene(scene)
self._connectSignals(props, scene)
# Fonts
self.fontComboBox.setWritingSystem(QFontDatabase.Latin)
self.sectionFontCombo.setWritingSystem(QFontDatabase.Latin)
self.sectionFontCombo.setWritingSystem(QFontDatabase.Latin)
self.lineSpaceSlider.setValue(scene.systemSpacing)
font = props.noteFont
if font is None:
font = scene.font()
font.setPointSize(props.noteFontSize)
self.fontComboBox.setCurrentFont(font)
self.noteSizeSpinBox.setValue(props.noteFontSize)
font = props.sectionFont
if font is None:
font = scene.font()
font.setPointSize(props.sectionFontSize)
self.sectionFontCombo.setCurrentFont(font)
self.sectionFontSizeSpinbox.setValue(props.sectionFontSize)
font = props.metadataFont
if font is None:
font = scene.font()
font.setPointSize(props.metadataFontSize)
self.metadataFontCombo.setCurrentFont(font)
self.metadataFontSizeSpinbox.setValue(props.metadataFontSize)
# Visibility toggles
self.actionShowDrumKey.setChecked(props.kitDataVisible)
self.actionShowEmptyLines.setChecked(props.emptyLinesVisible)
self.actionShowScoreInfo.setChecked(props.metadataVisible)
self.actionShowBeatCount.setChecked(props.beatCountVisible)
self.actionShowMeasureCounts.setChecked(props.measureCountsVisible)
# Set doable actions
self.actionPlayOnce.setEnabled(False)
self.actionLoopBars.setEnabled(False)
self.actionCopyMeasures.setEnabled(False)
self.actionPasteMeasures.setEnabled(False)
self.actionFillPasteMeasures.setEnabled(False)
self.actionClearMeasures.setEnabled(False)
self.actionDeleteMeasures.setEnabled(False)
self.MIDIToolBar.setEnabled(DBMidi.HAS_MIDI)
# Undo/redo
self.actionUndo.setEnabled(False)
self.actionRedo.setEnabled(False)
scene.canUndoChanged.connect(self.actionUndo.setEnabled)
changeUndoText = lambda txt:self.actionUndo.setText("Undo " + txt)
scene.undoTextChanged.connect(changeUndoText)
scene.canRedoChanged.connect(self.actionRedo.setEnabled)
changeRedoText = lambda txt:self.actionRedo.setText("Redo " + txt)
scene.redoTextChanged.connect(changeRedoText)
# Default beat
self._beatChanged(scene.defaultCount)
self.widthSpinBox.setValue(scene.scoreWidth)
self.lilypondSize.setValue(scene.score.lilysize)
self.lilyPagesBox.setValue(scene.score.lilypages)
self.lilyFillButton.setChecked(scene.score.lilyFill)
def _startUp(self):
self.scoreView.startUp()
self.updateStatus("Welcome to %s v%s" % (APPNAME, DB_VERSION))
self.scoreView.setFocus()
if self.actionCheckOnStartup.isChecked():
self.on_actionCheckForUpdates_triggered()
def _makeQSettings(self):
if self._fakeStartup:
return FakeQSettings()
else:
return QSettings()
def _setPaperSize(self, unusedIndex):
self.scoreScene.setPaperSize(self.paperBox.currentText())
def _setNoteFont(self):
props = self.songProperties
self.fontComboBox.setCurrentFont(props.noteFont)
def _setSectionFont(self):
props = self.songProperties
self.sectionFontCombo.setCurrentFont(props.sectionFont)
def _setSectionFontSize(self):
props = self.songProperties
self.sectionFontSizeSpinbox.setValue(props.sectionFontSize)
def _setMetadataFont(self):
props = self.songProperties
self.metadataFontCombo.setCurrentFont(props.metadataFont)
def _setMetadataSize(self):
props = self.songProperties
self.metadataFontSizeSpinbox.setValue(props.metadataFontSize)
def _setKitDataVisible(self):
props = self.songProperties
if props.kitDataVisible != self.actionShowDrumKey.isChecked():
self.actionShowDrumKey.setChecked(props.kitDataVisible)
def _setMetadataVisible(self):
props = self.songProperties
if props.metadataVisible != self.actionShowScoreInfo.isChecked():
self.actionShowScoreInfo.setChecked(props.metadataVisible)
def _setEmptyLinesVisible(self):
props = self.songProperties
if props.emptyLinesVisible != self.actionShowEmptyLines.isChecked():
self.actionShowEmptyLines.setChecked(props.emptyLinesVisible)
def _setBeatCountVisible(self):
props = self.songProperties
if props.beatCountVisible != self.actionShowBeatCount.isChecked():
self.actionShowBeatCount.setChecked(props.beatCountVisible)
def _setMeasureCountsVisible(self):
props = self.songProperties
if props.measureCountsVisible != self.actionShowMeasureCounts.isChecked():
self.actionShowMeasureCounts.setChecked(props.measureCountsVisible)
def updateStatus(self, message):
self.statusBar().showMessage(message, 5000)
if self.filename is not None:
self.setWindowTitle("DrumBurp v%s - %s[*]"
% (DB_VERSION, os.path.basename(self.filename)))
else:
self.setWindowTitle("DrumBurp v%s - Untitled[*]" % DB_VERSION)
self.setWindowModified(self.scoreScene.dirty)
def okToContinue(self):
if self.scoreScene.dirty:
reply = QMessageBox.question(self,
"DrumBurp - Unsaved Changes",
"Save unsaved changes?",
QMessageBox.Yes,
QMessageBox.No,
QMessageBox.Cancel)
if reply == QMessageBox.Cancel:
return False
elif reply == QMessageBox.Yes:
if not self.fileSave():
msg = ("DrumBurp could not save the file."
"\n\n"
"Continue anyway? "
"All unsaved changes will be lost!")
failReply = QMessageBox.warning(self,
"Failed Save!",
msg,
QMessageBox.Yes,
QMessageBox.No)
return failReply == QMessageBox.Yes
return True
def closeEvent(self, event):
if self.okToContinue():
settings = self._makeQSettings()
settings.setValue("RecentFiles",
QVariant(self.recentFiles))
settings.setValue("Geometry",
QVariant(self.saveGeometry()))
settings.setValue("MainWindow/State",
QVariant(self.saveState()))
settings.setValue("CheckOnStartup",
QVariant(self.actionCheckOnStartup.isChecked()))
self.songProperties.save(settings)
else:
event.ignore()
@pyqtSignature("")
def on_actionFitInWindow_triggered(self):
widthInPixels = self.scoreView.width()
maxColumns = self.songProperties.maxColumns(widthInPixels)
self.widthSpinBox.setValue(maxColumns)
self.scoreScene.reBuild()
@pyqtSignature("")
def on_actionLoad_triggered(self):
if not self.okToContinue():
return
caption = "Choose a DrumBurp file to open"
directory = self.filename
if len(self.recentFiles) > 0:
directory = os.path.dirname(self.recentFiles[-1])
else:
loc = QDesktopServices.HomeLocation
directory = QDesktopServices.storageLocation(loc)
fname = QFileDialog.getOpenFileName(parent = self,
caption = caption,
directory = directory,
filter = "DrumBurp files (*.brp)")
if len(fname) == 0:
return
if self.scoreScene.loadScore(fname):
self._beatChanged(self.scoreScene.defaultCount)
self.lilypondSize.setValue(self.scoreScene.score.lilysize)
self.lilyPagesBox.setValue(self.scoreScene.score.lilypages)
self.filename = unicode(fname)
self.updateStatus("Successfully loaded %s" % self.filename)
self.addToRecentFiles()
self.updateRecentFiles()
def _getFileName(self):
directory = self.filename
if directory is None:
suggestion = unicode(self.scoreScene.title)
if len(suggestion) == 0:
suggestion = "Untitled"
suggestion = os.extsep.join([suggestion, "brp"])
if len(self.recentFiles) > 0:
directory = os.path.dirname(self.recentFiles[-1])
else:
home = QDesktopServices.HomeLocation
directory = unicode(QDesktopServices.storageLocation(home))
directory = os.path.join(directory,
suggestion)
if os.path.splitext(directory)[-1] == os.extsep + 'brp':
directory = os.path.splitext(directory)[0]
caption = "Choose a DrumBurp file to save"
fname = QFileDialog.getSaveFileName(parent = self,
caption = caption,
directory = directory,
filter = "DrumBurp files (*.brp)")
if len(fname) == 0 :
return False
self.filename = unicode(fname)
return True
def fileSave(self):
if self.filename is None:
if not self._getFileName():
return False
self.addToRecentFiles()
self.updateRecentFiles()
return self.scoreScene.saveScore(self.filename)
@pyqtSignature("")
def on_actionSave_triggered(self):
if self.fileSave():
self.updateStatus("Successfully saved %s" % self.filename)
@pyqtSignature("")
def on_actionSaveAs_triggered(self):
if self._getFileName():
self.scoreScene.saveScore(self.filename)
self.updateStatus("Successfully saved %s" % self.filename)
self.addToRecentFiles()
self.updateRecentFiles()
@pyqtSignature("")
def on_actionNew_triggered(self):
if self.okToContinue():
counter = self.scoreScene.defaultCount
registry = self.songProperties.counterRegistry
dialog = QNewScoreDialog(self,
counter,
registry)
if dialog.exec_():
nMeasures, counter, kit = dialog.getValues()
self.scoreScene.newScore(kit,
numMeasures = nMeasures,
counter = counter)
self.filename = None
self.updateRecentFiles()
self._beatChanged(counter)
self.updateStatus("Created a new blank score")
def addToRecentFiles(self):
if self.filename is not None:
if self.filename in self.recentFiles:
self.recentFiles.remove(self.filename)
self.recentFiles.insert(0, self.filename)
if len(self.recentFiles) > 10:
self.recentFiles.pop()
def updateRecentFiles(self):
self.menuRecentScores.clear()
for fname in self.recentFiles:
if fname != self.filename and os.path.exists(fname):
def openRecentFile(bool_, filename = fname):
if not self.okToContinue():
return
if self.scoreScene.loadScore(filename):
self.filename = filename
self.updateStatus("Successfully loaded %s" % filename)
self.addToRecentFiles()
self.updateRecentFiles()
action = self.menuRecentScores.addAction(fname)
action.setIcon(DBIcons.getIcon("score"))
action.triggered.connect(openRecentFile)
def _beatChanged(self, counter):
if counter != self.scoreScene.defaultCount:
self.scoreScene.defaultCount = counter
self.defaultMeasureButton.setText(counter.countString())
def _systemSpacingChanged(self, value):
if value != self.scoreScene.systemSpacing:
self.scoreScene.systemSpacing = value
self.lineSpaceSlider.setValue(value)
def hideEvent(self, event):
self._state = self.saveState()
super(DrumBurp, self).hideEvent(event)
def showEvent(self, event):
if self._state is not None:
self.restoreState(self._state)
self._state = None
super(DrumBurp, self).showEvent(event)
@pyqtSignature("")
def on_actionExportASCII_triggered(self):
fname = self.filename
if self.filename is None:
home = QDesktopServices.HomeLocation
fname = QDesktopServices.storageLocation(home)
fname = os.path.join(str(fname), 'Untitled.txt')
if os.path.splitext(fname)[-1] == '.brp':
fname = os.path.splitext(fname)[0] + '.txt'
props = self.songProperties
self._asciiSettings = props.generateAsciiSettings(self._asciiSettings)
asciiDialog = QAsciiExportDialog(fname, parent = self,
settings = self._asciiSettings)
if not asciiDialog.exec_():
return
fname = asciiDialog.getFilename()
self._asciiSettings = asciiDialog.getOptions()
try:
asciiBuffer = StringIO()
exporter = AsciiExport.Exporter(self.scoreScene.score,
self._asciiSettings)
exporter.export(asciiBuffer)
except StandardError:
QMessageBox.warning(self.parent(), "ASCII generation failed!",
"Could not generate ASCII for this score!")
raise
try:
with open(fname, 'w') as txtHandle:
txtHandle.write(asciiBuffer.getvalue())
except StandardError:
QMessageBox.warning(self.parent(), "Export failed!",
"Could not export to " + fname)
raise
else:
self.updateStatus("Successfully exported ASCII to " + fname)
@pyqtSignature("")
def on_actionPrint_triggered(self):
if self._printer is None:
self._printer = QPrinter()
self._printer = QPrinter(QPrinterInfo(self._printer),
QPrinter.HighResolution)
self._printer.setPaperSize(self._getPaperSize())
dialog = QPrintPreviewDialog(self._printer, parent = self)
def updatePages(qprinter):
self.scoreScene.printScore(qprinter, self.scoreView)
dialog.paintRequested.connect(updatePages)
dialog.exec_()
@pyqtSignature("")
def on_actionExportPDF_triggered(self):
try:
printer = QPrinter(mode = QPrinter.HighResolution)
printer.setPaperSize(self._getPaperSize())
printer.setOutputFormat(QPrinter.PdfFormat)
if self.filename:
outfileName = list(os.path.splitext(self.filename)[:-1])
outfileName = os.extsep.join(outfileName + ["pdf"])
else:
outfileName = "Untitled.pdf"
printer.setOutputFileName(outfileName)
printer.setPaperSize(self._getPaperSize())
dialog = QPrintPreviewDialog(printer, parent = self)
def updatePages(qprinter):
self.scoreScene.printScore(qprinter, self.scoreView)
dialog.paintRequested.connect(updatePages)
dialog.exec_()
self.updateStatus("Exported to PDF %s" % outfileName)
except StandardError:
QMessageBox.warning(self.parent(), "Export failed!",
"Could not export PDF to " + outfileName)
@pyqtSignature("")
def on_actionExportLilypond_triggered(self):
lilyBuffer = StringIO()
try:
lyScore = LilypondScore(self.scoreScene.score)
lyScore.write(lilyBuffer)
except LilypondProblem, exc:
QMessageBox.warning(self.parent(), "Lilypond impossible",
"Cannot export Lilypond for this score: %s"
% exc.__doc__)
except StandardError, exc:
QMessageBox.warning(self.parent(), "Export failed!",
"Error generating Lilypond for this score: %s"
% exc.__doc__)
raise
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()
return "<a href=%s>%s</a>" % (link, str)
# SHortcuts for languages
Pun = u"punjabi"
Hin = u"hindi"
Tr = u"english"
Ro = u"roman"
# Preparing the pdf
doc = QTextDocument()
printer = QPrinter()
printer.setOutputFileName("KabitGurdas2.pdf")
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QPrinter.A4)
# page margin
printer.setPageMargins(12, 16, 12, 20, QPrinter.Millimeter)
doc.setPageSize(QSizeF(printer.pageRect().size()))
# We have a database of 675 kabits
KabitRange = range(1, 676)
html = [1] * KabitRange.__len__()
ch = [1] * KabitRange.__len__()
count = 0
painter = QPainter()
painter.begin(printer)
def drucken(self): # für später
printer = QPrinter()
printer.setPaperSize(QPrinter.A5)
doc = QTextDocument('Ich bin ein Text.')
doc.print_(printer)
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
def renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_webPage.mainFrame().contentsSize())
paperSize['width'] = str(pageSize.width()) + 'px'
paperSize['height'] = str(pageSize.height()) + 'px'
paperSize['border'] = '0px'
if paperSize.get('width') and paperSize.get('height'):
sizePt = QSizeF(ceil(self.stringToPointSize(paperSize['width'])),
ceil(self.stringToPointSize(paperSize['height'])))
p.setPaperSize(sizePt, QPrinter.Point)
elif 'format' in paperSize:
orientation = QPrinter.Landscape if paperSize.get(
'orientation') and paperSize['orientation'].lower(
) == 'landscape' else QPrinter.Portrait
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
'A0': QPrinter.A0,
'A1': QPrinter.A1,
'A2': QPrinter.A2,
'A3': QPrinter.A3,
'A4': QPrinter.A4,
'A5': QPrinter.A5,
'A6': QPrinter.A6,
'A7': QPrinter.A7,
'A8': QPrinter.A8,
'A9': QPrinter.A9,
'B0': QPrinter.B0,
'B1': QPrinter.B1,
'B2': QPrinter.B2,
'B3': QPrinter.B3,
'B4': QPrinter.B4,
'B5': QPrinter.B5,
'B6': QPrinter.B6,
'B7': QPrinter.B7,
'B8': QPrinter.B8,
'B9': QPrinter.B9,
'B10': QPrinter.B10,
'C5E': QPrinter.C5E,
'Comm10E': QPrinter.Comm10E,
'DLE': QPrinter.DLE,
'Executive': QPrinter.Executive,
'Folio': QPrinter.Folio,
'Ledger': QPrinter.Ledger,
'Legal': QPrinter.Legal,
'Letter': QPrinter.Letter,
'Tabloid': QPrinter.Tabloid
}
p.setPaperSize(QPrinter.A4) # fallback
for format, size in formats.items():
if format.lower() == paperSize['format'].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(
paperSize['border'])) if paperSize.get('border') else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_webPage.mainFrame().print_(p)
return True
c.setPlotStyle(QgsComposition.Print)
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))
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
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
class DrumBurp(QMainWindow, Ui_DrumBurpWindow):
'''
classdocs
'''
def __init__(self, parent=None, fakeStartup=False, filename=None):
'''
Constructor
'''
self._fakeStartup = fakeStartup
super(DrumBurp, self).__init__(parent)
self._state = None
self._asciiSettings = None
self._printer = None
self.setupUi(self)
self.scoreScene = None
self.paperBox.blockSignals(True)
self.paperBox.clear()
self._knownPageHeights = []
printer = QPrinter()
printer.setOutputFileName("invalid.pdf")
for name in dir(QPrinter):
attr = getattr(QPrinter, name)
if (isinstance(attr, QPrinter.PageSize) and name != "Custom"):
self.paperBox.addItem(name)
printer.setPaperSize(attr)
self._knownPageHeights.append(printer.pageRect().height())
self._pageHeight = printer.paperRect().height()
self.paperBox.blockSignals(False)
settings = self._makeQSettings()
self.recentFiles = [
unicode(fname)
for fname in settings.value("RecentFiles").toStringList()
if os.path.exists(unicode(fname))
]
if filename is None:
filename = (None
if len(self.recentFiles) == 0 else self.recentFiles[0])
self.filename = filename
self.addToRecentFiles()
self.updateRecentFiles()
self.songProperties = QDisplayProperties()
# Create scene
errored_files = []
try:
self.scoreScene = QScore(self)
except:
errored_files.append(self.filename)
try:
self.recentFiles.remove(self.filename)
except ValueError:
pass
self.filename = None
self.scoreScene = QScore(self)
self.restoreGeometry(settings.value("Geometry").toByteArray())
self.restoreState(settings.value("MainWindow/State").toByteArray())
self.statusbar.addPermanentWidget(QFrame())
self.availableNotesLabel = QLabel()
self.availableNotesLabel.setMinimumWidth(250)
self.statusbar.addPermanentWidget(self.availableNotesLabel)
self._infoBar = QLabel()
self.statusbar.addPermanentWidget(self._infoBar)
self._initializeState()
self.setSections()
self._versionThread = VersionCheckThread()
self._versionThread.finished.connect(self._finishedVersionCheck)
QTimer.singleShot(0, lambda: self._startUp(errored_files))
self.actionCheckOnStartup.setChecked(
settings.value("CheckOnStartup").toBool())
def _connectSignals(self, props, scene):
# Connect signals
props.fontChanged.connect(self._setNoteFont)
props.noteSizeChanged.connect(self.noteSizeSpinBox.setValue)
props.sectionFontChanged.connect(self._setSectionFont)
props.sectionFontSizeChanged.connect(self._setSectionFontSize)
props.metadataFontChanged.connect(self._setMetadataFont)
props.metadataFontSizeChanged.connect(self._setMetadataSize)
scene.dirtySignal.connect(self.setWindowModified)
scene.dragHighlight.connect(self.actionLoopBars.setEnabled)
scene.dragHighlight.connect(self.actionPlayOnce.setEnabled)
scene.dragHighlight.connect(self.actionCopyMeasures.setEnabled)
scene.dragHighlight.connect(self.checkPasteMeasure)
scene.dragHighlight.connect(self.actionClearMeasures.setEnabled)
scene.dragHighlight.connect(self.actionDeleteMeasures.setEnabled)
scene.sceneFormatted.connect(self.sceneFormatted)
scene.playing.connect(self._scorePlaying)
scene.currentHeadsChanged.connect(self.availableNotesLabel.setText)
scene.statusMessageSet.connect(self._setStatusFromScene)
scene.lilysizeChanged.connect(self._setLilySize)
scene.lilypagesChanged.connect(self._setLilyPages)
scene.lilyFillChanged.connect(self._setLilyFill)
self.paperBox.currentIndexChanged.connect(self._setPaperSize)
props.kitDataVisibleChanged.connect(self._setKitDataVisible)
props.emptyLinesVisibleChanged.connect(self._setEmptyLinesVisible)
props.measureCountsVisibleChanged.connect(
self._setMeasureCountsVisible)
props.metadataVisibilityChanged.connect(self._setMetadataVisible)
props.beatCountVisibleChanged.connect(self._setBeatCountVisible)
DBMidi.SONGEND_SIGNAL.connect(self.musicDone)
DBMidi.HIGHLIGHT_SIGNAL.connect(self.highlightPlayingMeasure)
def _initializeState(self):
props = self.songProperties
scene = self.scoreScene
self.scoreView.setScene(scene)
self._connectSignals(props, scene)
# Fonts
self.fontComboBox.setWritingSystem(QFontDatabase.Latin)
self.sectionFontCombo.setWritingSystem(QFontDatabase.Latin)
self.sectionFontCombo.setWritingSystem(QFontDatabase.Latin)
self.lineSpaceSlider.setValue(scene.systemSpacing)
font = props.noteFont
if font is None:
font = scene.font()
font.setPointSize(props.noteFontSize)
self.fontComboBox.setCurrentFont(font)
self.noteSizeSpinBox.setValue(props.noteFontSize)
font = props.sectionFont
if font is None:
font = scene.font()
font.setPointSize(props.sectionFontSize)
self.sectionFontCombo.setCurrentFont(font)
self.sectionFontSizeSpinbox.setValue(props.sectionFontSize)
font = props.metadataFont
if font is None:
font = scene.font()
font.setPointSize(props.metadataFontSize)
self.metadataFontCombo.setCurrentFont(font)
self.metadataFontSizeSpinbox.setValue(props.metadataFontSize)
# Visibility toggles
self.actionShowDrumKey.setChecked(props.kitDataVisible)
self.actionShowEmptyLines.setChecked(props.emptyLinesVisible)
self.actionShowScoreInfo.setChecked(props.metadataVisible)
self.actionShowBeatCount.setChecked(props.beatCountVisible)
self.actionShowMeasureCounts.setChecked(props.measureCountsVisible)
# Set doable actions
self.actionPlayOnce.setEnabled(False)
self.actionLoopBars.setEnabled(False)
self.actionCopyMeasures.setEnabled(False)
self.actionPasteMeasures.setEnabled(False)
self.actionFillPasteMeasures.setEnabled(False)
self.actionClearMeasures.setEnabled(False)
self.actionDeleteMeasures.setEnabled(False)
self.MIDIToolBar.setEnabled(DBMidi.HAS_MIDI)
# Undo/redo
self.actionUndo.setEnabled(False)
self.actionRedo.setEnabled(False)
scene.canUndoChanged.connect(self.actionUndo.setEnabled)
changeUndoText = lambda txt: self.actionUndo.setText("Undo " + txt)
scene.undoTextChanged.connect(changeUndoText)
scene.canRedoChanged.connect(self.actionRedo.setEnabled)
changeRedoText = lambda txt: self.actionRedo.setText("Redo " + txt)
scene.redoTextChanged.connect(changeRedoText)
# Default beat
self._beatChanged(scene.defaultCount)
self.widthSpinBox.setValue(scene.scoreWidth)
self.lilypondSize.setValue(scene.score.lilysize)
self.lilyPagesBox.setValue(scene.score.lilypages)
self.lilyFillButton.setChecked(scene.score.lilyFill)
def _startUp(self, errored_files):
self.scoreView.startUp()
self.updateStatus("Welcome to %s v%s" % (APPNAME, DB_VERSION))
self.scoreView.setFocus()
if self.actionCheckOnStartup.isChecked():
# self.on_actionCheckForUpdates_triggered()
self._versionThread.start()
if errored_files:
QMessageBox.warning(
self, "Problem during startup",
"Error opening files:\n %s" % "\n".join(errored_files))
def _makeQSettings(self):
if self._fakeStartup:
return FakeQSettings()
else:
return QSettings()
def _setPaperSize(self, unusedIndex):
self.scoreScene.setPaperSize(self.paperBox.currentText())
def _setNoteFont(self):
props = self.songProperties
self.fontComboBox.setCurrentFont(props.noteFont)
def _setSectionFont(self):
props = self.songProperties
self.sectionFontCombo.setCurrentFont(props.sectionFont)
def _setSectionFontSize(self):
props = self.songProperties
self.sectionFontSizeSpinbox.setValue(props.sectionFontSize)
def _setMetadataFont(self):
props = self.songProperties
self.metadataFontCombo.setCurrentFont(props.metadataFont)
def _setMetadataSize(self):
props = self.songProperties
self.metadataFontSizeSpinbox.setValue(props.metadataFontSize)
def _setKitDataVisible(self):
props = self.songProperties
if props.kitDataVisible != self.actionShowDrumKey.isChecked():
self.actionShowDrumKey.setChecked(props.kitDataVisible)
def _setMetadataVisible(self):
props = self.songProperties
if props.metadataVisible != self.actionShowScoreInfo.isChecked():
self.actionShowScoreInfo.setChecked(props.metadataVisible)
def _setEmptyLinesVisible(self):
props = self.songProperties
if props.emptyLinesVisible != self.actionShowEmptyLines.isChecked():
self.actionShowEmptyLines.setChecked(props.emptyLinesVisible)
def _setBeatCountVisible(self):
props = self.songProperties
if props.beatCountVisible != self.actionShowBeatCount.isChecked():
self.actionShowBeatCount.setChecked(props.beatCountVisible)
def _setMeasureCountsVisible(self):
props = self.songProperties
if props.measureCountsVisible != self.actionShowMeasureCounts.isChecked(
):
self.actionShowMeasureCounts.setChecked(props.measureCountsVisible)
def updateStatus(self, message):
self.statusBar().showMessage(message, 5000)
if self.filename is not None:
self.setWindowTitle("DrumBurp v%s - %s[*]" %
(DB_VERSION, os.path.basename(self.filename)))
else:
self.setWindowTitle("DrumBurp v%s - Untitled[*]" % DB_VERSION)
self.setWindowModified(self.scoreScene.dirty)
def okToContinue(self):
if self.scoreScene.dirty:
reply = QMessageBox.question(self, "DrumBurp - Unsaved Changes",
"Save unsaved changes?",
QMessageBox.Yes, QMessageBox.No,
QMessageBox.Cancel)
if reply == QMessageBox.Cancel:
return False
elif reply == QMessageBox.Yes:
if not self.fileSave():
msg = ("DrumBurp could not save the file."
"\n\n"
"Continue anyway? "
"All unsaved changes will be lost!")
failReply = QMessageBox.warning(self, "Failed Save!", msg,
QMessageBox.Yes,
QMessageBox.No)
return failReply == QMessageBox.Yes
return True
def closeEvent(self, event):
if self.okToContinue():
settings = self._makeQSettings()
settings.setValue("RecentFiles", QVariant(self.recentFiles))
settings.setValue("Geometry", QVariant(self.saveGeometry()))
settings.setValue("MainWindow/State", QVariant(self.saveState()))
settings.setValue("CheckOnStartup",
QVariant(self.actionCheckOnStartup.isChecked()))
self.songProperties.save(settings)
self._versionThread.exit()
self._versionThread.wait(1000)
if not self._versionThread.isFinished():
self._versionThread.terminate()
else:
event.ignore()
@pyqtSignature("")
def on_actionFitInWindow_triggered(self):
widthInPixels = self.scoreView.width()
maxColumns = self.songProperties.maxColumns(widthInPixels)
self.widthSpinBox.setValue(maxColumns)
self.scoreScene.reBuild()
@pyqtSignature("")
def on_actionLoad_triggered(self):
if not self.okToContinue():
return
caption = "Choose a DrumBurp file to open"
directory = self.filename
if len(self.recentFiles) > 0:
directory = os.path.dirname(self.recentFiles[-1])
else:
loc = QDesktopServices.HomeLocation
directory = QDesktopServices.storageLocation(loc)
fname = QFileDialog.getOpenFileName(parent=self,
caption=caption,
directory=directory,
filter="DrumBurp files (*.brp)")
if len(fname) == 0:
return
if self.scoreScene.loadScore(fname):
self._beatChanged(self.scoreScene.defaultCount)
self.lilypondSize.setValue(self.scoreScene.score.lilysize)
self.lilyPagesBox.setValue(self.scoreScene.score.lilypages)
self.filename = unicode(fname)
self.updateStatus("Successfully loaded %s" % self.filename)
self.addToRecentFiles()
self.updateRecentFiles()
def _getFileName(self):
directory = self.filename
if directory is None:
suggestion = unicode(self.scoreScene.title)
if len(suggestion) == 0:
suggestion = "Untitled"
suggestion = os.extsep.join([suggestion, "brp"])
if len(self.recentFiles) > 0:
directory = os.path.dirname(self.recentFiles[-1])
else:
home = QDesktopServices.HomeLocation
directory = unicode(QDesktopServices.storageLocation(home))
directory = os.path.join(directory, suggestion)
if os.path.splitext(directory)[-1] == os.extsep + 'brp':
directory = os.path.splitext(directory)[0]
caption = "Choose a DrumBurp file to save"
fname = QFileDialog.getSaveFileName(parent=self,
caption=caption,
directory=directory,
filter="DrumBurp files (*.brp)")
if len(fname) == 0:
return False
self.filename = unicode(fname)
return True
def fileSave(self):
if self.filename is None:
if not self._getFileName():
return False
self.addToRecentFiles()
self.updateRecentFiles()
return self.scoreScene.saveScore(self.filename)
@pyqtSignature("")
def on_actionSave_triggered(self):
if self.fileSave():
self.updateStatus("Successfully saved %s" % self.filename)
@pyqtSignature("")
def on_actionSaveAs_triggered(self):
if self._getFileName():
self.scoreScene.saveScore(self.filename)
self.updateStatus("Successfully saved %s" % self.filename)
self.addToRecentFiles()
self.updateRecentFiles()
@pyqtSignature("")
def on_actionNew_triggered(self):
if self.okToContinue():
counter = self.scoreScene.defaultCount
registry = self.songProperties.counterRegistry
dialog = QNewScoreDialog(self, counter, registry)
if dialog.exec_():
nMeasures, counter, kit = dialog.getValues()
self.scoreScene.newScore(kit,
numMeasures=nMeasures,
counter=counter)
self.filename = None
self.updateRecentFiles()
self._beatChanged(counter)
self.updateStatus("Created a new blank score")
def addToRecentFiles(self):
if self.filename is not None:
if self.filename in self.recentFiles:
self.recentFiles.remove(self.filename)
self.recentFiles.insert(0, self.filename)
if len(self.recentFiles) > 10:
self.recentFiles.pop()
def updateRecentFiles(self):
self.menuRecentScores.clear()
for fname in self.recentFiles:
if fname != self.filename and os.path.exists(fname):
def openRecentFile(bool_, filename=fname):
if not self.okToContinue():
return
if self.scoreScene.loadScore(filename):
self.filename = filename
self.updateStatus("Successfully loaded %s" % filename)
self.addToRecentFiles()
self.updateRecentFiles()
action = self.menuRecentScores.addAction(fname)
action.setIcon(DBIcons.getIcon("score"))
action.triggered.connect(openRecentFile)
def _beatChanged(self, counter):
if counter != self.scoreScene.defaultCount:
self.scoreScene.defaultCount = counter
self.defaultMeasureButton.setText(counter.countString())
def _systemSpacingChanged(self, value):
if value != self.scoreScene.systemSpacing:
self.scoreScene.systemSpacing = value
self.lineSpaceSlider.setValue(value)
def hideEvent(self, event):
self._state = self.saveState()
super(DrumBurp, self).hideEvent(event)
def showEvent(self, event):
if self._state is not None:
self.restoreState(self._state)
self._state = None
super(DrumBurp, self).showEvent(event)
@pyqtSignature("")
def on_actionExportASCII_triggered(self):
fname = self.filename
if self.filename is None:
home = QDesktopServices.HomeLocation
fname = QDesktopServices.storageLocation(home)
fname = os.path.join(str(fname), 'Untitled.txt')
if os.path.splitext(fname)[-1] == '.brp':
fname = os.path.splitext(fname)[0] + '.txt'
props = self.songProperties
self._asciiSettings = props.generateAsciiSettings(self._asciiSettings)
asciiDialog = QAsciiExportDialog(fname,
parent=self,
settings=self._asciiSettings)
if not asciiDialog.exec_():
return
fname = asciiDialog.getFilename()
self._asciiSettings = asciiDialog.getOptions()
try:
asciiBuffer = StringIO()
exporter = AsciiExport.Exporter(self.scoreScene.score,
self._asciiSettings)
exporter.export(asciiBuffer)
except StandardError:
QMessageBox.warning(self.parent(), "ASCII generation failed!",
"Could not generate ASCII for this score!")
raise
try:
with open(fname, 'w') as txtHandle:
txtHandle.write(asciiBuffer.getvalue())
except StandardError:
QMessageBox.warning(self.parent(), "Export failed!",
"Could not export to " + fname)
raise
else:
self.updateStatus("Successfully exported ASCII to " + fname)
@pyqtSignature("")
def on_actionPrint_triggered(self):
if self._printer is None:
self._printer = QPrinter()
self._printer = QPrinter(QPrinterInfo(self._printer),
QPrinter.HighResolution)
self._printer.setPaperSize(self._getPaperSize())
dialog = QPrintPreviewDialog(self._printer, parent=self)
def updatePages(qprinter):
self.scoreScene.printScore(qprinter, self.scoreView)
dialog.paintRequested.connect(updatePages)
dialog.exec_()
@pyqtSignature("")
def on_actionExportPDF_triggered(self):
try:
printer = QPrinter(mode=QPrinter.HighResolution)
printer.setPaperSize(self._getPaperSize())
printer.setOutputFormat(QPrinter.PdfFormat)
if self.filename:
outfileName = list(os.path.splitext(self.filename)[:-1])
outfileName = os.extsep.join(outfileName + ["pdf"])
else:
outfileName = "Untitled.pdf"
printer.setOutputFileName(outfileName)
printer.setPaperSize(self._getPaperSize())
dialog = QPrintPreviewDialog(printer, parent=self)
def updatePages(qprinter):
self.scoreScene.printScore(qprinter, self.scoreView)
dialog.paintRequested.connect(updatePages)
dialog.exec_()
self.updateStatus("Exported to PDF %s" % outfileName)
except StandardError:
QMessageBox.warning(self.parent(), "Export failed!",
"Could not export PDF to " + outfileName)
@pyqtSignature("")
def on_actionExportLilypond_triggered(self):
lilyBuffer = StringIO()
try:
lyScore = LilypondScore(self.scoreScene.score)
lyScore.write(lilyBuffer)
except LilypondProblem, exc:
QMessageBox.warning(
self.parent(), "Lilypond impossible",
"Cannot export Lilypond for this score: %s" % exc.__doc__)
except StandardError, exc:
QMessageBox.warning(
self.parent(), "Export failed!",
"Error generating Lilypond for this score: %s" % exc.__doc__)
raise
def renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(self.pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_webPage.mainFrame().contentsSize())
paperSize["width"] = str(pageSize.width()) + "px"
paperSize["height"] = str(pageSize.height()) + "px"
paperSize["border"] = "0px"
if paperSize.get("width") and paperSize.get("height"):
sizePt = QSizeF(
ceil(self.stringToPointSize(paperSize["width"])), ceil(self.stringToPointSize(paperSize["height"]))
)
p.setPaperSize(sizePt, QPrinter.Point)
elif "format" in paperSize:
orientation = (
QPrinter.Landscape
if paperSize.get("orientation") and paperSize["orientation"].lower() == "landscape"
else QPrinter.Portrait
)
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
"A0": QPrinter.A0,
"A1": QPrinter.A1,
"A2": QPrinter.A2,
"A3": QPrinter.A3,
"A4": QPrinter.A4,
"A5": QPrinter.A5,
"A6": QPrinter.A6,
"A7": QPrinter.A7,
"A8": QPrinter.A8,
"A9": QPrinter.A9,
"B0": QPrinter.B0,
"B1": QPrinter.B1,
"B2": QPrinter.B2,
"B3": QPrinter.B3,
"B4": QPrinter.B4,
"B5": QPrinter.B5,
"B6": QPrinter.B6,
"B7": QPrinter.B7,
"B8": QPrinter.B8,
"B9": QPrinter.B9,
"B10": QPrinter.B10,
"C5E": QPrinter.C5E,
"Comm10E": QPrinter.Comm10E,
"DLE": QPrinter.DLE,
"Executive": QPrinter.Executive,
"Folio": QPrinter.Folio,
"Ledger": QPrinter.Ledger,
"Legal": QPrinter.Legal,
"Letter": QPrinter.Letter,
"Tabloid": QPrinter.Tabloid,
}
p.setPaperSize(QPrinter.A4) # fallback
for format_, size in formats.items():
if format_.lower() == paperSize["format"].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(paperSize["border"])) if paperSize.get("border") else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_webPage.mainFrame().print_(p)
return True
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 renderPdf(self, fileName):
p = QPrinter()
p.setOutputFormat(QPrinter.PdfFormat)
p.setOutputFileName(fileName)
p.setResolution(pdf_dpi)
paperSize = self.m_paperSize
if not len(paperSize):
pageSize = QSize(self.m_webPage.mainFrame().contentsSize())
paperSize['width'] = str(pageSize.width()) + 'px'
paperSize['height'] = str(pageSize.height()) + 'px'
paperSize['border'] = '0px'
if paperSize.get('width') and paperSize.get('height'):
sizePt = QSizeF(ceil(self.stringToPointSize(paperSize['width'])),
ceil(self.stringToPointSize(paperSize['height'])))
p.setPaperSize(sizePt, QPrinter.Point)
elif 'format' in paperSize:
orientation = QPrinter.Landscape if paperSize.get('orientation') and paperSize['orientation'].lower() == 'landscape' else QPrinter.Portrait
orientation = QPrinter.Orientation(orientation)
p.setOrientation(orientation)
formats = {
'A0': QPrinter.A0,
'A1': QPrinter.A1,
'A2': QPrinter.A2,
'A3': QPrinter.A3,
'A4': QPrinter.A4,
'A5': QPrinter.A5,
'A6': QPrinter.A6,
'A7': QPrinter.A7,
'A8': QPrinter.A8,
'A9': QPrinter.A9,
'B0': QPrinter.B0,
'B1': QPrinter.B1,
'B2': QPrinter.B2,
'B3': QPrinter.B3,
'B4': QPrinter.B4,
'B5': QPrinter.B5,
'B6': QPrinter.B6,
'B7': QPrinter.B7,
'B8': QPrinter.B8,
'B9': QPrinter.B9,
'B10': QPrinter.B10,
'C5E': QPrinter.C5E,
'Comm10E': QPrinter.Comm10E,
'DLE': QPrinter.DLE,
'Executive': QPrinter.Executive,
'Folio': QPrinter.Folio,
'Ledger': QPrinter.Ledger,
'Legal': QPrinter.Legal,
'Letter': QPrinter.Letter,
'Tabloid': QPrinter.Tabloid
}
p.setPaperSize(QPrinter.A4) # fallback
for format, size in formats.items():
if format.lower() == paperSize['format'].lower():
p.setPaperSize(size)
break
else:
return False
border = floor(self.stringToPointSize(paperSize['border'])) if paperSize.get('border') else 0
p.setPageMargins(border, border, border, border, QPrinter.Point)
self.m_webPage.mainFrame().print_(p)
return True
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()
