def printImage(self): #Ok
"""Imprimir Imagem
"""
printer = QPrinter()
printer.setOutputFormat(QPrinter.NativeFormat)
prnt_dlg = QPrintDialog(printer)
if (prnt_dlg.exec_() == QPrintDialog.Accepted):
painter = QPainter()
painter.begin(printer)
rect = QRect(painter.viewport())
size = QSize(self.img_lbl.pixmap().size())
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.setWindow(self.img_lbl.pixmap().rect())
painter.drawPixmap(0, 0, self.img_lbl.pixmap())
painter.end()
def saveOutputPDF(self):
filesTypes = "Plik tekstowy (*.txt);;Plik PDF (*.pdf)"
name, filter = QFileDialog.getSaveFileName(self.mainWindow,
'Zapisz plik', "Bez nazwy",
filesTypes)
if not name:
return
if filter == "Plik PDF (*.pdf)":
try:
linesOriginalText = self.mainWindow.ui.plainTextEditOutputPDF.toPlainText(
).split("\n")
template = pd.DataFrame(linesOriginalText,
dtype=str,
columns=[""])
html = template.to_html(index=False, border=0)
htmlFile = open("temp.html", "w", encoding="utf-8")
htmlFile.write(html)
htmlFile.close()
doc = QTextDocument()
try:
html = open("temp.html", "r", encoding="utf-8")
except Exception as inst:
UiFunction.showErrorDialog(
"Wystąpił problem z szablonem PDF \n" + str(inst))
doc.setHtml(html.read())
html.close()
try:
printer = QPrinter()
printer.setOutputFileName(name)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPageSize(QPrinter.A4)
printer.setPageMargins(4, 4, 4, 4, QPrinter.Millimeter)
doc.print_(printer)
except Exception as inst:
UiFunction.showErrorDialog(
"Wystąpił problem z generowaniem pliku PDF \n" +
str(inst))
os.remove('temp.html')
except Exception as inst:
UiFunction.showErrorDialog(
"Wystąpił problem z tworzeniem pliku PDF \n" + str(inst))
elif filter == "Plik tekstowy (*.txt)":
try:
try:
file = open(name, 'w')
except Exception as inst:
UiFunction.showErrorDialog(
"Wystąpił problem z wybranym plikiem \n" + str(inst))
output = self.mainWindow.ui.plainTextEditOutputPDF.toPlainText(
)
file.write(output)
file.close()
except Exception as inst:
UiFunction.showErrorDialog(
"Wystąpił problem z zapisem pliku \n" + str(inst))
def testQPrinterGetPageMargins(self):
# Bug #742
obj = QPrinter()
values = (10.0, 20.0, 30.0, 40.0, QPrinter.Point)
obj.setPageMargins(*values)
self.assert_(
self.compareTuples(obj.getPageMargins(QPrinter.Point),
values[:-1]))
def print_preview(self) -> None:
printer = QPrinter()
printer.setOutputFormat(QPrinter.NativeFormat)
dialog = QPrintPreviewDialog(printer, self)
dialog.setWindowFlags(Qt.Window)
dialog.paintRequested.connect(self.print)
dialog.showMaximized()
dialog.exec_()
def save(self):
filename = QFileDialog.getSaveFileName(self, 'PDF file')
if filename:
printer = QPrinter(QPrinter.HighResolution)
printer.setPageSize(QPrinter.A4)
printer.setColorMode(QPrinter.Color)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(filename)
self.cradius = QPainter(printer)
self.trace()
self.cradius = None
def export_to_pdf(self: 'BaseWidget', filename: Path):
width_a4 = 730
height_a4 = 1060
is_landscape = self.width() > self.height()
if is_landscape:
self.resize(height_a4, width_a4) # landscape
else:
self.resize(width_a4, height_a4) # portrait
# render widget to picture
picture = QPicture()
painter = QPainter(picture)
self.render(painter, QPoint(0, 0))
painter.end()
# set up PDF printer
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(str(filename))
if is_landscape:
printer.setOrientation(QPrinter.Landscape)
# draw picture on printer
painter = QPainter()
ok = painter.begin(printer)
if ok:
painter.drawPicture(0, 0, picture)
ok = painter.end()
return ok
def print_(self, printer: QPrinter, text_edit: Union[QTextEdit,
MyPlainTextEdit]):
"""
Prints text at any resolution with one-inch margins.
:param printer: A configured printer (put through QPrintDialog probably)
:param text_edit: The text editor.
:return: None. Side-effect: Prints the document.
"""
doc_clone = text_edit.document().clone()
printer.setPageMargins(25.4, 25.4, 25.4, 25.4,
QPrinter.Millimeter) # 1 inch margins
doc_clone.documentLayout().setPaintDevice(printer)
doc_clone.setPageSize(printer.pageRect().size())
doc_clone.print_(printer)
def printPreviewDialog(self):
printer = QPrinter(QPrinter.HighResolution)
previewDialog = QPrintPreviewDialog(printer, self)
previewDialog.paintRequested.connect(
self.printPreview) # Rempli le dialog
previewDialog.exec_() # Lance le dialog
def set_values(self):
obj = race()
default_printer_name = QPrinter().printerName()
printer_name = Config().printer.get('split', default_printer_name)
# try:
# QPrinter().setPrinterName(printer_name)
# except Exception as e:
# logging.error(str(e))
# printer_name = default_printer_name
self.selected_split_printer.setText(printer_name)
self.print_splits_checkbox.setChecked(
obj.get_setting('split_printout', False))
template = obj.get_setting('split_template')
if template:
self.item_template.setCurrentText(template)
self.item_margin_left.setValue(
obj.get_setting('print_margin_left', 5.0))
self.item_margin_top.setValue(obj.get_setting('print_margin_top', 5.0))
self.item_margin_right.setValue(
obj.get_setting('print_margin_right', 5.0))
self.item_margin_bottom.setValue(
obj.get_setting('print_margin_bottom', 5.0))
def printpreviewDialog(self):
printer = QPrinter(QPrinter.HighResolution)
previewDialog = QPrintPreviewDialog(printer,
parent=None,
flags=Qt.WindowFlags())
previewDialog.paintRequested.connect(self.printImage)
previewDialog.exec_()
def slotPrint(self):
printer = QPrinter(QPrinter.HighResolution)
pd = QPrintDialog(printer, self)
if pd.exec_() == QDialog.Accepted:
r = self.view.graphicsView().mapToScene(
self.view.graphicsView().viewport().rect()).boundingRect()
self.view.print(printer, r.left(), r.right())
def print(self):
printer = QPrinter()
print_program = printer.printProgram()
printer_name = printer.printerName()
# Create painter
painter = QPainter()
# Start painter
painter.begin(printer)
# Grab a widget you want to print
screen = self.text.grab()
# Draw grabbed pixmap
painter.drawPixmap(10, 10, screen)
# End painting
painter.end()
print_dialog = QPrintDialog(printer, self)
print_dialog.exec_()
def export(self, filename):
self.printer = QPrinter()
self.printer.setOutputFormat(QPrinter.PdfFormat)
self.printer.setOutputFileName(filename)
self.printer.setPageMargins(QMarginsF(0, 0, 0, 0))
self.printer.setResolution(96)
self.printer.setFullPage(True)
pages = self.document['pages']
if pages:
page = pages[0]
self.printer.setPageSizeMM(QSizeF(page.width / mm, page.height / mm))
self.painter = QPainter()
self.painter.begin(self.printer)
self._isFirstPage = True
for page in pages:
self.exportPage(page)
self._isFirstPage = False
self.painter.end()
def print_(self):
document = self.textEdit.document()
printer = QPrinter()
dlg = QPrintDialog(printer, self)
if dlg.exec_() != QDialog.Accepted:
return
document.print_(printer)
self.statusBar().showMessage("Ready", 2000)
def print_(self):
document = self.paged_text_edit.document()
printer = QPrinter()
dlg = QPrintDialog(printer, self)
if dlg.exec_() != QDialog.Accepted:
return
document.print_(printer)
self.statusBar.writeMessageOnStatus("Ready", 2000)
def print_statement(self):
printer = QPrinter()
printer.setOutputFileName(
os.path.join(
os.environ.get('HOME'),
'%s_%s.pdf' % (self._transaction.created_at.strftime('%Y%m%d'),
self._transaction.transaction_code)))
if QPrintDialog(printer,
self.parentWidget()).exec_() != QDialog.Accepted:
return None
try:
trans = jinja_env.get_template('trans.jinja2.html')
except TemplateNotFound as e:
raise PrinterError('Printer data source unavailable') from e
html = trans.render(
transaction=self._transaction,
printed_at=datetime.now().strftime('%d/%m/%Y, %I:%M:%S %p'))
doc = QTextDocument(self)
doc.setHtml(html)
doc.print_(printer)
return None
def print_with_setup(self, text_edit: Union[QTextEdit, MyPlainTextEdit]):
"""
Get printer settings from the user, then print at High Resolution with those settings or cancel.
:param text_edit: A text editor containing a `document()` QTextDocument.
:return: None. Side effect: modal dialog, possibly printing.
"""
if text_edit == self.md_text_edit:
self.update_markdown_viewer()
printer = QPrinter(QPrinter.HighResolution)
print_dialog = QPrintDialog(printer, self)
if print_dialog.exec_() == QDialog.Accepted:
self.print_(printer, text_edit)
def print_preview(self, text_edit: Union[QTextEdit, MyPlainTextEdit]):
"""
Print preview a given text editor's `document()` at High Resolution.
:param text_edit: A text editor containing a `document()` QTextDocument.
:return: None. Side effect: modal print preview.
"""
if text_edit == self.md_text_edit:
self.update_markdown_viewer()
printer = QPrinter(QPrinter.HighResolution)
ppd = QPrintPreviewDialog(printer)
ppd.paintRequested.connect(lambda: self.print_(printer, text_edit))
ppd.exec_()
def pdfExport(self):
fn, _ = QFileDialog.getSaveFileName(self, "Export PDF", None, "PDF files (.pdf); All files")
if fn != "":
if QFileInfo(fn).suffix == "":
fn += ".pdf"
printer = QPrinter(QPrinter.HighResolution)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(fn)
self.textedit.print_(printer)
def print_pdf(self) -> None:
file_name = QFileDialog.getSaveFileName(self, self.tr("Save to .pdf"), filter=self.tr("Portable Document Format (*.pdf)"))[0]
if not file_name:
return
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(file_name)
self.print(printer)
def testQPrinterGetPageMargins(self):
# Bug #742. Find a printer like PDF/XPS on which arbitrary margins can be set.
printer = None
for printerInfo in QPrinterInfo.availablePrinters():
name = printerInfo.printerName().lower()
if "xps" in name or "pdf" in name:
printer = QPrinter(printerInfo)
break
if not printer:
printer = QPrinter()
# On macOS the minimum margin of a page is ~12, setting something lower than that will
# actually fail to set all the margins.
values = (15.0, 16.0, 17.0, 18.0, QPrinter.Point)
printer.setPageMargins(*values)
actual = printer.getPageMargins(QPrinter.Point)
print(printer.printerName(), actual, values[:-1])
self.assertTrue(self.compareTuples(actual, values[:-1]))
def print_report(self):
if not self.validate_report_dates():
return
entries = self.model.get_records(
self.view.report_date_from.date().toPython(),
self.view.report_date_to.date().toPython(),
self.view.comboBox.currentText(),
)
balance = self.model.get_balance(
self.view.report_date_from.date().toPython(),
self.view.report_date_to.date().toPython(),
)
if not self.create_pdf(self.model.pdf_file.name, entries, balance):
return
printer = QPrinter(QPrinter.HighResolution)
dialog = QPrintDialog(printer)
if dialog.exec_() != QPrintDialog.Accepted:
return
with TemporaryDirectory() as path:
images = convert_from_path(self.model.pdf_file.name,
dpi=300,
output_folder=path)
painter = QPainter()
painter.begin(printer)
for i, image in enumerate(images):
if i > 0:
printer.newPage()
rect = painter.viewport()
qtImage = ImageQt(image)
qtImageScaled = qtImage.scaled(rect.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
painter.drawImage(rect, qtImageScaled)
painter.end()
def print(self):
printer = QPrinter()
print_dialog = QPrintDialog(printer, self)
# Check if the dialog is accepted by the user
if print_dialog.exec_() == QDialog.Accepted:
# Create painter
painter = QPainter()
# Start painter
painter.begin(printer)
# Grab a widget you want to print
screen = self.text.grab()
# Draw grabbed pixmap
painter.drawPixmap(10, 10, screen)
# End painting
painter.end()
def testQPrinterGetPageMargins(self):
# Bug #742
obj = QPrinter()
# On macOS the minimum margin of a page is ~12, setting something lower than that will
# actually fail to set all the margins.
values = (15.0, 16.0, 17.0, 18.0, QPrinter.Point)
obj.setPageMargins(*values)
print(obj.getPageMargins(QPrinter.Point), values[:-1])
self.assertTrue(
self.compareTuples(obj.getPageMargins(QPrinter.Point),
values[:-1]))
def printImage(self, printer):
"Prints the current diagram"
self.image = QImage('test1.tif')
# # Create the printer
printerobject = QPrinter()
# Set the settings
printdialog = QPrintDialog(printerobject)
if printdialog.exec_() == QDialog.Accepted:
painter = QPainter(printer)
rect = painter.viewport()
size = self.image.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.setWindow(self.image.rect())
painter.drawImage(0, 0, self.image)
def on_actionSave_Document_triggered(self):
print("on_actionSave_Document_triggered")
ui = self.ui
fileName = "./q_text-document-integration.pdf"
#fileName = QFileDialog.getSaveFileName(self, "Save document...", qApp.applicationDirPath(), "*.pdf", None)
#if fileName == None:
# print("No file")
# return
#fileName = fileName[0]+".pdf"
print("FILENAMKE=", fileName)
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(fileName)
pageMargins = QMargins(20, 20, 20, 20)
pageLayout = QPageLayout()
pageLayout.setMode(QPageLayout.StandardMode)
pageLayout.setOrientation(QPageLayout.Portrait)
pageLayout.setPageSize(QPageSize(QPageSize.A4))
pageLayout.setUnits(QPageLayout.Millimeter)
pageLayout.setMargins(QMarginsF(pageMargins))
printer.setPageLayout(pageLayout)
ui.textEdit.document().setPageSize(printer.pageRect().size())
ui.textEdit.document().print_(printer)
def print(self, test: bool) -> None:
"""setup and preview pViewTable for paper printing
Returns:
None"""
with open(self.file_path) as f:
self.data = json.dumps(dict(json.load(f)),
sort_keys=True,
indent=6,
separators=(".", "="))
self.document = QtWidgets.QTextEdit()
self.document.setText(self.data)
if not test:
printer = QPrinter()
previewDialog = QPrintPreviewDialog(printer, self)
previewDialog.paintRequested.connect(
lambda: self.document.print_(printer))
previewDialog.exec_()
def export_as_pdf(self, checked=False):
file_path = self._spine_db_editor.get_pdf_file_path()
if not file_path:
return
source = self._get_viewport_scene_rect()
current_zoom_factor = self.zoom_factor
self._zoom(1.0 / current_zoom_factor)
self.scene().clearSelection()
printer = QPrinter()
printer.setPaperSize(source.size(), QPrinter.Point)
printer.setOutputFileName(file_path)
painter = QPainter(printer)
self.scene().render(painter, QRectF(), source)
painter.end()
self._zoom(current_zoom_factor)
self._spine_db_editor.file_exported.emit(file_path)
def print(self, printer: QPrinter) -> None:
print_options = PrintOptions(
print_no=self.ui.check_box_no_column.isChecked(),
print_code=self.ui.check_box_code_column.isChecked(),
print_description=self.ui.check_box_details_column.isChecked(),
print_list_price=self.ui.check_box_list_price_column.isChecked(),
print_discount=self.ui.check_box_discount_column.isChecked(),
print_price=self.ui.check_box_price_column.isChecked(),
print_quantity=self.ui.check_box_quantity_column.isChecked(),
print_total=self.ui.check_box_total_column.isChecked()
)
margin = 5
printer.setPageSize(QPrinter.A4)
printer.setPageMargins(margin, margin, margin, margin, QPrinter.Millimeter)
printer.setResolution(96)
doc = QTextDocument()
doc.setUseDesignMetrics(True)
doc.setDefaultFont(self.offer_font)
doc.setHtml(self.offer.printout(print_options))
doc.setPageSize(printer.pageRect().size())
doc.print_(printer)
def export_as_pdf(self, checked=False):
self.qsettings.beginGroup(self.settings_group)
file_path, _ = get_save_file_name_in_last_dir(
self.qsettings, "exportGraphAsPDF", self, "Export as PDF...", self._get_base_dir(), "PDF files (*.pdf)"
)
self.qsettings.endGroup()
if not file_path:
return
view = self.ui.graphicsView
source = view._get_viewport_scene_rect()
current_zoom_factor = view.zoom_factor
view._zoom(1.0 / current_zoom_factor)
self.scene.clearSelection()
printer = QPrinter()
printer.setPaperSize(source.size(), QPrinter.Point)
printer.setOutputFileName(file_path)
painter = QPainter(printer)
self.scene.render(painter, QRectF(), source)
painter.end()
view._zoom(current_zoom_factor)
self._insert_open_file_button(file_path)
def testQPrinterGetPageMargins(self):
# Bug #742
obj = QPrinter()
values = (10.0, 20.0, 30.0, 40.0, QPrinter.Point)
obj.setPageMargins(*values)
self.assert_(self.compareTuples(obj.getPageMargins(QPrinter.Point), values[:-1]))
