bool ExportHtml::convertSvm(QByteArray &input, QByteArray &output, QSize size)
{
QBuffer *outBuf = new QBuffer(&output);
QSvgGenerator generator;
generator.setOutputDevice(outBuf);
generator.setSize(QSize(200, 200));
generator.setTitle("Svg image");
generator.setDescription("This is an svg image that is converted from svm by Calligra");
Libsvm::SvmParser svmParser;
QPainter painter;
if (!painter.begin(&generator)) {
kDebug(30503) << "Can not open the painter";
return false;
}
painter.scale(50,50);
Libsvm::SvmPainterBackend svmPainterBackend(&painter, size);
svmParser.setBackend(&svmPainterBackend);
if (!svmParser.parse(input)) {
kDebug(30503) << "Can not Parse the Svm file";
return false;
}
painter.end();
return true;
}
bool ExportHtml::convertEmf(QByteArray &input, QByteArray &output, QSize size)
{
QBuffer *outBuf = new QBuffer(&output);
QSvgGenerator generator;
generator.setOutputDevice(outBuf);
generator.setSize(QSize(200, 200));
generator.setTitle("Svg image");
generator.setDescription("This is an svg image that is converted from EMF by Calligra");
Libemf::Parser emfParser;
QPainter painter;
if (!painter.begin(&generator)) {
kDebug(30503) << "Can not open the painter";
return false;
}
painter.scale(50,50);
Libemf::OutputPainterStrategy emfPaintOutput(painter, size, true );
emfParser.setOutput( &emfPaintOutput );
if (!emfParser.load(input)) {
kDebug(30503) << "Can not Parse the EMF file";
return false;
}
painter.end();
return true;
}
//! [save SVG]
void Window::saveSvg()
{
QString newPath = QFileDialog::getSaveFileName(this, tr("Save SVG"),
path, tr("SVG files (*.svg)"));
if (newPath.isEmpty())
return;
path = newPath;
//![configure SVG generator]
QSvgGenerator generator;
generator.setFileName(path);
generator.setSize(QSize(200, 200));
generator.setViewBox(QRect(0, 0, 200, 200));
generator.setTitle(tr("SVG Generator Example Drawing"));
generator.setDescription(tr("An SVG drawing created by the SVG Generator "
"Example provided with Qt."));
//![configure SVG generator]
//![begin painting]
QPainter painter;
painter.begin(&generator);
//![begin painting]
displayWidget->paint(painter);
//![end painting]
painter.end();
//![end painting]
}
void ExportImageDialog::exportSvg(const QString &fileName)
{
SkyMap *map = m_KStars->map();
// export as SVG
QSvgGenerator svgGenerator;
svgGenerator.setFileName(fileName);
svgGenerator.setTitle(i18n("KStars Exported Sky Image"));
svgGenerator.setDescription(i18n("KStars Exported Sky Image"));
svgGenerator.setSize(QSize(map->width(), map->height()));
svgGenerator.setResolution(qMax(map->logicalDpiX(), map->logicalDpiY()));
svgGenerator.setViewBox(QRect(0, 0, map->width(), map->height()));
SkyQPainter painter(m_KStars, &svgGenerator);
painter.begin();
map->exportSkyImage(&painter);
if(m_DialogUI->addLegendCheckBox->isChecked())
{
addLegend(&painter);
}
painter.end();
}
void struct3d::saveImage() {
// view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
// QPixmap pixmap(view->size());
// QPainter painter(&pixmap);
// painter.setRenderHint(QPainter::Antialiasing);
// view->render(&painter);
// pixmap.save(QApplication::applicationDirPath() + "/image.png", "PNG",100);
QString fileName = QFileDialog::getSaveFileName((QWidget *) this,
tr("Save as:"),
"structure.svg",
tr("SVG files (*.svg);;All Files (*)"));
QRectF rect = scene->sceneRect();
QSvgGenerator generator;
generator.setFileName(fileName);
generator.setSize(QSize(scene->sceneRect().width(), scene->sceneRect().height()));
generator.setViewBox(scene->sceneRect());
generator.setTitle(tr("Title"));
generator.setDescription(tr("Description"));
QPainter painter;
painter.begin(&generator);
scene->render(&painter, QRectF(), rect);
painter.end();
}
bool ExportHtml::convertWmf(QByteArray &input, QByteArray &output, QSizeF size)
{
QBuffer *outBuf = new QBuffer(&output);
QSvgGenerator generator;
generator.setOutputDevice(outBuf);
generator.setSize(QSize(200, 200));
generator.setTitle("Svg image");
generator.setDescription("This is an svg image that is converted from WMF by Calligra");
QPainter painter;
if (!painter.begin(&generator)) {
kDebug(30503) << "Can not open the painter";
return false;
}
painter.scale(50,50);
Libwmf::WmfPainterBackend wmfPainter(&painter, size);
if (!wmfPainter.load(input)) {
kDebug(30503) << "Can not Parse the WMF file";
return false;
}
// Actually paint the WMF.
painter.save();
wmfPainter.play();
painter.restore();
painter.end();
return true;
}
void ExportWizard::saveSvg()
{
if (m_ui->svgFilePath->text().isEmpty()) {
QMessageBox::warning(this, tr("No file selected !"), tr("You need to choose a file path for saving."));
return;
}
QString svgFilePath = m_ui->svgFilePath->text();
// get the rendering size
QRect svgRect(m_canvas->sceneRect().toRect());
// create the SVG writer
QSvgGenerator generator;
generator.setFileName(svgFilePath);
generator.setSize(svgRect.size());
generator.setResolution(physicalDpiX());
generator.setViewBox(svgRect);
generator.setTitle(m_canvas->titleText());
generator.setDescription(tr("Created with %1").arg(QCoreApplication::applicationName() + " " + QCoreApplication::applicationVersion()));
// paint over the writer
QPainter painter(&generator);
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing | QPainter::SmoothPixmapTransform, true);
m_canvas->renderVisible(&painter, svgRect, svgRect, Qt::IgnoreAspectRatio, !m_ui->svgAsIsBox->isChecked());
painter.end();
}
void MultiLayer::exportSVG(const QString &fname) {
QSvgGenerator generator;
generator.setFileName(fname);
generator.setSize(canvas->size());
generator.setViewBox(QRect(QPoint(0, 0), generator.size()));
generator.setResolution(96); // FIXME hardcored
generator.setTitle(this->name());
exportPainter(generator);
}
void setupGenerator(QSvgGenerator& generator, QString& templateName)
{
generator.setFileName(templateName + ".svg");
generator.setSize(QSize(256, 256));
generator.setViewBox(QRectF(0, 0, 256, 256));
generator.setTitle("VPL " + templateName);
generator.setDescription("This image was generated by an helper tool part of Aseba, get it at http://thymio.org");
}
void OpenInfraPlatform::UserInterface::Alignment2DScene::exportToFile(QWidget* parent)
{
QString filter;
QString fn = QFileDialog::getSaveFileName(parent, tr("Save Vertical Alignment as..."), QString(), tr("PNG File (*.png);; JPG File (*.jpg);; PDF File (*.pdf);; SVG File (*.svg)"), &filter);
if(fn.isEmpty())
return;
if(filter == "PNG File (*.png)" || filter == "JPG File (*.jpg)")
{
QImage image(sceneRect().size().toSize(), QImage::Format::Format_ARGB32);
image.fill(Qt::darkGray);
QPainter painter(&image);
painter.setRenderHints(QPainter::Antialiasing);
render(&painter);
image.save(fn);
}
else
{
QPrinter printer;
QSvgGenerator svgGen;
QPaintDevice* device;
if(filter == "PDF File (*.pdf)")
{
printer.setResolution(QPrinter::HighResolution);
printer.setPageSize( QPrinter::A4 );
printer.setOrientation( QPrinter::Landscape );
printer.setOutputFormat( QPrinter::PdfFormat );
printer.setOutputFileName(fn);
device = &printer;
}
else if(filter == "SVG File (*.svg)")
{
QRectF rect = sceneRect();
svgGen.setFileName(fn);
svgGen.setSize(QSize(rect.width(),rect.height()));
svgGen.setViewBox(QRect(0,0,rect.width(),rect.height()));
svgGen.setTitle("Vertical Alignment");
device = &svgGen;
}
else
{
return;
}
QPainter painter(device);
configureColors(A2D_DrawState::A2D_Print);
render(&painter);
configureColors(A2D_DrawState::A2D_Draw);
}
}
void QGVPage::saveSvg(QString filename)
{
// TODO: We only have m_vpPage because constructor gets passed a view provider...
//NOTE: this makes wrong size pages in low-Rez
TechDraw::DrawPage *page( m_vpPage->getDrawPage() );
const QString docName( QString::fromUtf8(page->getDocument()->getName()) );
const QString pageName( QString::fromUtf8(page->getNameInDocument()) );
QString svgDescription = tr("Drawing page: ") +
pageName +
tr(" exported from FreeCAD document: ") +
docName;
QSvgGenerator svgGen;
svgGen.setFileName(filename);
svgGen.setSize(QSize((int) Rez::guiX(page->getPageWidth()), (int) Rez::guiX(page->getPageHeight()))); //expects pixels, gets mm
//"By default this property is set to QSize(-1, -1), which indicates that the generator should not output
// the width and height attributes of the <svg> element." >> but Inkscape won't read it without size info??
svgGen.setViewBox(QRect(0, 0, Rez::guiX(page->getPageWidth()), Rez::guiX(page->getPageHeight())));
svgGen.setResolution(Rez::guiX(25.4)); // docs say this is DPI. 1dot/mm so 25.4dpi
svgGen.setTitle(QObject::tr("FreeCAD SVG Export"));
svgGen.setDescription(svgDescription);
Gui::Selection().clearSelection();
toggleMarkers(false); //fiddle cache, vertices, frames, etc
toggleHatch(false);
scene()->update();
viewport()->repaint();
double width = Rez::guiX(page->getPageWidth());
double height = Rez::guiX(page->getPageHeight());
QRectF sourceRect(0.0,-height,width,height);
QRectF targetRect;
Gui::Selection().clearSelection();
QPainter p;
p.begin(&svgGen);
scene()->render(&p, targetRect,sourceRect);
p.end();
toggleMarkers(true);
toggleHatch(true);
scene()->update();
viewport()->repaint();
}
// Save the file in the editor to a file at fileName
void svgSave(const QString &fileName, NoteEditor *editor)
{
QSvgGenerator generator;
generator.setFileName(fileName);
generator.setSize(editor->size());
generator.setViewBox(QRect(0, 0, editor->width(), editor->height()));
generator.setTitle("Ink");
generator.setDescription("ThreeRing ink");
QPainter painter;
painter.begin(&generator);
editor->paint(painter);
painter.end();
}
void DrawSVG::Write(QString filename)
{
if(!canvas) return;
QSvgGenerator generator;
generator.setFileName(filename);
generator.setSize(QSize(canvas->width(), canvas->height()));
generator.setTitle("MLDemos screenshot");
generator.setDescription("Generated with MLDemos");
QPainter painter;
painter.begin(&generator);
// we need to paint the different layers:
// confidence map
// samples + trajectories + reward
canvas->PaintStandard(painter, true);
if(canvas->bDisplayLearned)
{
// learned model
painter.setBackgroundMode(Qt::TransparentMode);
if(classifier) DrawClassificationSamples(canvas, painter, classifier, classifierMulti);
if(regressor) drawRegr->DrawModel(canvas, painter, regressor);
if(dynamical) drawDyn->DrawModel(canvas, painter, dynamical);
if(clusterer) drawClust->DrawModel(canvas, painter, clusterer);
if(projector) drawProj->DrawModel(canvas, painter, projector);
if(dynamical)
{
int cnt = 10000; // not too many or it will make unreadable files
int steps = 8;
VectorsFast(cnt, steps, painter);
}
if(maximizer)
{
Maximization(painter);
}
}
if(canvas->bDisplayInfo)
{
// model info
painter.setBackgroundMode(Qt::TransparentMode);
if(classifier) drawClass->DrawInfo(canvas, painter, classifier);
if(regressor) drawRegr->DrawInfo(canvas, painter, regressor);
if(dynamical) drawDyn->DrawInfo(canvas, painter, dynamical);
if(clusterer) drawClust->DrawInfo(canvas, painter, clusterer);
if(projector) drawProj->DrawInfo(canvas, painter, projector);
}
painter.end();
}
void Figure2D::exportGraphics(QString fileName)
{
// Open file save dialog if no filename given
if (fileName.isEmpty())
fileName = QFileDialog::getSaveFileName(this, tr("Export VIBes graphics"),
QString(), tr("Portable Network Graphics (*.png);;"
"Joint Photographic Experts Group (*.jpg *.jpeg);;"
"Windows Bitmap (*.bmp);;"
"Scalable Vector Graphics (*.svg)"));
// Abort if no file selected
if (fileName.isEmpty())
return;
// Append .png if no extension was specified
if (fileName.indexOf('.',1) < 0) // Search '.' from the second character (*nix hidden files start with a dot)
fileName.append(".png");
// Save as raster
if (fileName.endsWith(".jpg", Qt::CaseInsensitive)
|| fileName.endsWith(".jpeg", Qt::CaseInsensitive)
|| fileName.endsWith(".png", Qt::CaseInsensitive)
|| fileName.endsWith(".bmp", Qt::CaseInsensitive))
{
QImage image(this->size()*2, QImage::Format_ARGB32);
image.fill(QColor(255,255,255,0));
QPainter painter;
painter.begin(&image);
this->render(&painter);
painter.end();
image.save(fileName);
}
// Save as vector (SVG)
else if (fileName.endsWith(".svg", Qt::CaseInsensitive))
{
QSvgGenerator generator;
generator.setFileName(fileName);
generator.setSize(this->size());
generator.setViewBox(QRect(QPoint(0,0),this->size()));
generator.setTitle(tr("VIBes figure"));
generator.setDescription(tr("Graphics generated with VIBes on %1.").arg(QDateTime::currentDateTime().toString()));
QPainter painter;
painter.begin(&generator);
this->render(&painter);
painter.end();
}
}
void Spectrum1DWidget::saveAsImage()
{
QString file_name = QFileDialog::getSaveFileName(this, "Save File", "", "Raster images *.bmp *.png *.jpg *.gif (*.bmp *.png *.jpg *.gif);;Vector images *.svg (*.svg)");
bool x_visible = x_scrollbar_->isVisible();
bool y_visible = y_scrollbar_->isVisible();
x_scrollbar_->hide();
y_scrollbar_->hide();
if (file_name.contains(".svg", Qt::CaseInsensitive)) // svg vector format
{
QSvgGenerator generator;
generator.setFileName(file_name);
generator.setSize(QSize(this->width(), this->height()));
generator.setViewBox(QRect(0, 0, this->width() - 1, this->height() - 1));
generator.setTitle(file_name);
generator.setDescription("TOPPView generated SVG");
QPainter painter;
painter.begin(&generator);
painter.save();
painter.translate(QPoint(y_axis_->pos()));
y_axis_->paint(&painter, new QPaintEvent(y_axis_->contentsRect()));
painter.restore();
painter.save();
painter.translate(QPoint(canvas_->pos()));
dynamic_cast<Spectrum1DCanvas*>(canvas_)->paint(&painter, new QPaintEvent(canvas_->contentsRect()));
painter.restore();
painter.save();
painter.translate(QPoint(x_axis_->pos()));
x_axis_->paint(&painter, new QPaintEvent(x_axis_->contentsRect()));
painter.restore();
painter.end();
x_scrollbar_->setVisible(x_visible);
y_scrollbar_->setVisible(y_visible);
}
else // raster graphics formats
{
QPixmap pixmap = QPixmap::grabWidget(this);
x_scrollbar_->setVisible(x_visible);
y_scrollbar_->setVisible(y_visible);
pixmap.save(file_name);
}
}
void
ChartView::saveImage( bool clipboard )
{
QSvgGenerator generator;
QByteArray svg;
QBuffer buffer( &svg );
generator.setTitle( "QtPlatz Generated SVG" );
generator.setDescription( "Copyright (C) 2013-2017 MS-Cheminformataics, All rights reserved" );
auto sz = this->size();
QRectF rc( 0, 0, sz.width(), sz.height() );
generator.setViewBox( rc );
if ( clipboard ) {
generator.setOutputDevice( &buffer );
} else {
auto name = QFileDialog::getSaveFileName( this, tr( "Save SVG File" )
, "chart.svg"
, tr( "SVG (*.svg)" ) );
if ( ! name.isEmpty() )
generator.setFileName( name );
}
QwtPlotRenderer renderer;
renderer.setDiscardFlag( QwtPlotRenderer::DiscardCanvasBackground, true );
renderer.setDiscardFlag( QwtPlotRenderer::DiscardCanvasFrame, true );
renderer.setDiscardFlag( QwtPlotRenderer::DiscardBackground, true );
QPainter painter;
painter.begin( &generator );
renderer.render( this, &painter, rc );
painter.end();
if ( clipboard ) {
QMimeData * mime = new QMimeData();
mime->setData( "image/svg+xml", svg );
QApplication::clipboard()->setMimeData( mime, QClipboard::Clipboard );
}
}
static PyObject *meth_QSvgGenerator_setTitle(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
const QString* a0;
int a0State = 0;
QSvgGenerator *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QSvgGenerator, &sipCpp, sipType_QString,&a0, &a0State))
{
sipCpp->setTitle(*a0);
sipReleaseType(const_cast<QString *>(a0),sipType_QString,a0State);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QSvgGenerator, sipName_setTitle, doc_QSvgGenerator_setTitle);
return NULL;
}
void MainWindow::documentExport(void)
{
Canvas *currCanvas = canvas();
QString currFilename = currCanvas->filename();
currFilename.chop(4);
if (currFilename.isEmpty())
{
// Determine the working directory.
QSettings settings;
QString workingDir(QDir::homePath());
QVariant workingDirSetting =
settings.value("workingDirectory");
if (workingDirSetting.isValid())
{
workingDir = workingDirSetting.toString();
}
currFilename = workingDir + "/untitled";
}
QString filename = QFileDialog::getSaveFileName(this, tr("Export Diagram"),
currFilename, tr("SVG (*.svg);;PDF (*.pdf);;Postscript (*.ps)"));
if (filename.isEmpty())
{
return;
}
QRectF pageRect = currCanvas->pageRect();
if (pageRect.size().isEmpty())
{
// There is no page set, so use a page equal to diagram bounds
double padding = 10;
pageRect = expandRect(diagramBoundingRect(currCanvas->items()), padding);
}
QFileInfo file(filename);
if (file.suffix() == "svg")
{
QSvgGenerator generator;
generator.setFileName(filename);
QRectF targetRect(QPointF(0, 0), currCanvas->sceneRect().size());
QPointF topLeft = pageRect.topLeft() -
currCanvas->sceneRect().topLeft();
QRectF viewbox(topLeft, pageRect.size());
generator.setSize(viewbox.size().toSize());
generator.setViewBox(viewbox);
generator.setTitle(QFileInfo(filename).fileName());
generator.setDescription(tr("This file was exported from Dunnart. "
"http://www.dunnart.org/"));
QPainter painter;
if (painter.begin(&generator))
{
painter.setRenderHint(QPainter::Antialiasing);
currCanvas->setRenderingForPrinting(true);
currCanvas->render(&painter, targetRect,
currCanvas->sceneRect(),
Qt::IgnoreAspectRatio);
currCanvas->setRenderingForPrinting(false);
painter.end();
}
else
{
qDebug("Export SVG painter failed to begin.");
}
}
else
{
// Use QPrinter for PDF and PS.
QPrinter printer;
printer.setOutputFileName(filename);
printer.setPaperSize(pageRect.size(),
QPrinter::Millimeter);
QPainter painter;
if (painter.begin(&printer))
{
painter.setRenderHint(QPainter::Antialiasing);
currCanvas->setRenderingForPrinting(true);
currCanvas->render(&painter, QRectF(),
expandRect(pageRect, -3),
Qt::IgnoreAspectRatio);
currCanvas->setRenderingForPrinting(false);
}
else
{
qDebug("Export PDF/PS painter failed to begin.");
}
}
}
/*!
Render a plot to a file
Supported formats are:
- pdf\n
- ps\n
- svg\n
- all image formats supported by Qt, see QImageWriter::supportedImageFormats()
\param plot Plot widget
\param fileName Path of the file, where the document will be stored
\param format Format for the document
\param sizeMM Size for the document in millimeters.
\param resolution Resolution in dots per Inch (dpi)
\sa renderTo(), render(), QwtPainter::setRoundingAlignment()
*/
void QwtPolarRenderer::renderDocument( QwtPolarPlot *plot,
const QString &fileName, const QString &format,
const QSizeF &sizeMM, int resolution )
{
if ( plot == NULL || sizeMM.isEmpty() || resolution <= 0 )
return;
QString title = plot->title().text();
if ( title.isEmpty() )
title = "Plot Document";
const double mmToInch = 1.0 / 25.4;
const QSizeF size = sizeMM * mmToInch * resolution;
const QRectF documentRect( 0.0, 0.0, size.width(), size.height() );
const QString fmt = format.toLower();
if ( format == "pdf" || format == "ps" )
{
QPrinter printer;
printer.setFullPage( true );
printer.setPaperSize( sizeMM, QPrinter::Millimeter );
printer.setDocName( title );
printer.setOutputFileName( fileName );
printer.setOutputFormat( ( format == "pdf" )
? QPrinter::PdfFormat : QPrinter::PostScriptFormat );
printer.setResolution( resolution );
QPainter painter( &printer );
render( plot, &painter, documentRect );
}
#ifndef QWT_NO_POLAR_SVG
#ifdef QT_SVG_LIB
#if QT_VERSION >= 0x040500
else if ( format == "svg" )
{
QSvgGenerator generator;
generator.setTitle( title );
generator.setFileName( fileName );
generator.setResolution( resolution );
generator.setViewBox( documentRect );
QPainter painter( &generator );
render( plot, &painter, documentRect );
}
#endif
#endif
#endif
else
{
if ( QImageWriter::supportedImageFormats().indexOf(
format.toLatin1() ) >= 0 )
{
const QRect imageRect = documentRect.toRect();
const int dotsPerMeter = qRound( resolution * mmToInch * 1000.0 );
QImage image( imageRect.size(), QImage::Format_ARGB32 );
image.setDotsPerMeterX( dotsPerMeter );
image.setDotsPerMeterY( dotsPerMeter );
image.fill( QColor( Qt::white ).rgb() );
QPainter painter( &image );
render( plot, &painter, imageRect );
painter.end();
image.save( fileName, format.toLatin1() );
}
}
}
