static PyObject *meth_QSvgGenerator_setViewBox(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
const QRect* a0;
QSvgGenerator *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSvgGenerator, &sipCpp, sipType_QRect, &a0))
{
sipCpp->setViewBox(*a0);
Py_INCREF(Py_None);
return Py_None;
}
}
{
const QRectF* a0;
QSvgGenerator *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QSvgGenerator, &sipCpp, sipType_QRectF, &a0))
{
sipCpp->setViewBox(*a0);
Py_INCREF(Py_None);
return Py_None;
}
}
/* Raise an exception if the arguments couldn't be parsed. */
sipNoMethod(sipParseErr, sipName_QSvgGenerator, sipName_setViewBox, doc_QSvgGenerator_setViewBox);
return NULL;
}
void NativeRenderDialog::exportSVG()
{
QString s;
QFileDialog dlg(NULL, tr("Output filename"), QString("%1/%2.svg").arg(M_PREFS->getworkingdir()).arg(tr("untitled")), tr("SVG files (*.svg)") + "\n" + tr("All Files (*)"));
dlg.setFileMode(QFileDialog::AnyFile);
dlg.setDefaultSuffix("svg");
dlg.setAcceptMode(QFileDialog::AcceptSave);
if (dlg.exec()) {
if (dlg.selectedFiles().size())
s = dlg.selectedFiles()[0];
}
// QString s = QFileDialog::getSaveFileName(NULL,tr("Output filename"),"",tr("SVG files (*.svg)"));
if (s.isNull())
return;
QSvgGenerator svgg;
QRect theR = thePrinter->pageRect();
theR.moveTo(0, 0);
svgg.setSize(theR.size());
svgg.setFileName(s);
#if QT_VERSION >= 0x040500
svgg.setViewBox(theR);
#endif
QPainter P(&svgg);
P.setRenderHint(QPainter::Antialiasing);
RendererOptions opt = options();
opt.options |= RendererOptions::PrintAllLabels;
render(P, theR, opt);
}
//! [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 MapWidget::exportSVGToDisplayCluster()
{
if(g_dcSocket != NULL && svgTmpFile_.open())
{
QSvgGenerator generator;
generator.setFileName(svgTmpFile_.fileName());
generator.setResolution(90);
generator.setSize(QSize(1400, 1200));
generator.setViewBox(viewRect_);
QPainter painter;
painter.begin(&generator);
// set logical coordinates of the render window
painter.setWindow(viewRect_.toRect());
// draw a black background
painter.setBrush(QBrush(QColor::fromRgbF(0,0,0,1)));
painter.drawRect(QRect(QPoint(-107,37), QPoint(-93,25)));
renderAll(&painter, false);
painter.end();
put_flog(LOG_DEBUG, "wrote %s", svgTmpFile_.fileName().toStdString().c_str());
// now, send it to DisplayCluster
sendSVGToDisplayCluster((svgTmpFile_.fileName()).toStdString(), (QString("ExerciseMap-") + QString::number(index_) + ".svg").toStdString());
}
}
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();
}
void RealTimeMultiSampleArrayWidget::onMakeScreenshot(const QString& imageType)
{
// Create file name
QString sDate = QDate::currentDate().toString("yyyy_MM_dd");
QString sTime = QTime::currentTime().toString("hh_mm_ss");
if(!QDir("./Screenshots").exists()) {
QDir().mkdir("./Screenshots");
}
if(imageType.contains("SVG"))
{
QString fileName = QString("./Screenshots/%1-%2-DataView.svg").arg(sDate).arg(sTime);
// Generate screenshot
QSvgGenerator svgGen;
svgGen.setFileName(fileName);
svgGen.setSize(m_pTableView->size());
svgGen.setViewBox(m_pTableView->rect());
m_pTableView->render(&svgGen);
}
if(imageType.contains("PNG"))
{
QString fileName = QString("./Screenshots/%1-%2-DataView.png").arg(sDate).arg(sTime);
QPixmap pixMap = QPixmap::grabWidget(m_pTableView);
pixMap.save(fileName);
}
}
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);
}
}
Q_DECL_EXPORT void gammaray_save_widget_to_svg(QWidget *widget, const QString &fileName)
{
QSvgGenerator svg;
svg.setFileName(fileName);
svg.setSize(widget->size());
svg.setViewBox(QRect(QPoint(0, 0), widget->size()));
QPainter painter(&svg);
widget->render(&painter);
painter.end();
}
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 plotWindow::exportSvg()
{
QString fileName = QFileDialog::getSaveFileName(plot, "Export to SVG", "plot.svg", "SVG files (*.svg);;All files (*)");
if( !fileName.isEmpty() )
{
QRectF sourceRect = plotdata.sceneRect();
QRectF targetRect = QRectF(0.0, 0.0, sourceRect.size().width(), sourceRect.size().height());
QSvgGenerator printer;
printer.setFileName(fileName);
printer.setSize(sourceRect.size().toSize());
printer.setViewBox(targetRect);
QPainter painter(&printer);
plotdata.render(&painter, targetRect, sourceRect);
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 QgsSymbolV2::exportImage( QString path, QString format, QSize size )
{
if ( format.toLower() == "svg" )
{
QSvgGenerator generator;
generator.setFileName( path );
generator.setSize( size );
generator.setViewBox( QRect( 0, 0, size.height(), size.height() ) );
QPainter painter( &generator );
drawPreviewIcon( &painter, size );
painter.end();
}
else
{
QImage image = asImage( size );
image.save( path );
}
}
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 );
}
}
void View::keyPressEvent(QKeyEvent *event) {
if (event->key() == Qt::Key_Right) {
// Zoom in.
int steps = 1;
if (event->modifiers() == Qt::ControlModifier)
steps = 10;
if (event->modifiers() == Qt::ShiftModifier)
steps = 100;
moveForward(steps);
} else if (event->key() == Qt::Key_Left) {
// Zoom out.
int steps = 1;
if (event->modifiers() == Qt::ControlModifier)
steps = 10;
if (event->modifiers() == Qt::ShiftModifier)
steps = 100;
moveBackward(steps);
} else if (event->key() == Qt::Key_S) {
if (event->modifiers() == Qt::ControlModifier) {
/*
* Render SVG.
*/
QString fileName = QFileDialog::getSaveFileName(this,
"Save SVG", QString(), "SVG Files (*.svg)");
QSvgGenerator generator;
generator.setFileName(fileName);
generator.setSize(viewport()->rect().size());
generator.setViewBox(viewport()->rect());
// Temporarily give legs and edges non-cosmetic pens while rendering.
foreach (QGraphicsLineItem *leg, m_legs) {
QPen pen = leg->pen();
pen.setCosmetic(false);
pen.setWidthF(1.0/transform().m11());
leg->setPen(pen);
}
foreach (QGraphicsLineItem *edge, m_edges) {
QPen pen = edge->pen();
pen.setCosmetic(false);
pen.setWidthF(1.0/transform().m11());
edge->setPen(pen);
}
void DrawSVG(Chromosome *dna, const char *svgName){
QSvgGenerator svgGen;
svgGen.setFileName(QString(svgName));
svgGen.setSize(QSize(imgW, imgH));
svgGen.setViewBox(QRect(0, 0, imgW, imgH));
QPainter painter(&svgGen);
painter.setPen(Qt::NoPen);
painter.setRenderHint(QPainter::Antialiasing);
// Black background
painter.setBrush(QBrush(QColor(0, 0, 0, 255)));
QPolygon polyclean;
int pointsclean[] = {0, 0, 0, imgH, imgW, imgH, imgW, 0};
polyclean.setPoints(4, pointsclean);
painter.drawConvexPolygon(polyclean);
// Draw all the polygons
Polygon *poly = dna->DNA();
for (int n = 0; n < N_POLYGONS; n++) {
QColor color(poly[n].Red(),
poly[n].Green(),
poly[n].Blue(),
poly[n].Alpha());
painter.setBrush(QBrush(color));
int size = poly[n].NPoints();
int *listPoints = new int[2*size];
for(int i = 0; i < size; i++){
listPoints[2*i] = poly[n].Vertex()[i].x();
listPoints[2*i + 1] = poly[n].Vertex()[i].y();
}
QPolygon qPoly;
qPoly.setPoints(size, listPoints);
painter.drawConvexPolygon(qPoly);
delete [] listPoints;
}
painter.end();
}
void GraphvizView::exportSceneAsSVG()
{
QString FileName = QFileDialog::getSaveFileName(this,
tr("导出为SVG文件"),
"export_spatialgraph.svg",
tr("SVG文件 (*.svg)"));
if (!FileName.isEmpty())
{
QSvgGenerator SvgGen;
QRectF ExportRect = scene()->itemsBoundingRect();
SvgGen.setFileName(FileName);
SvgGen.setSize(QSize((int)ExportRect.width(),
(int)ExportRect.height()));
SvgGen.setViewBox(QRectF(0,0,ExportRect.width(),ExportRect.height()));
QPainter Painter(&SvgGen);
scene()->render(&Painter);
}
}
bool saveWidgetAsSVG(QWidget* widget, const QRect& r, const QString& fileName)
{
QFontMetrics fm(widget->font());
int heightText= fm.height()+10;
//int versionHeight = 20;
//int heightAxe = 0;
//if (Axe.mShowSubs) heightAxe = 20;
QSvgGenerator svgGenFile;
svgGenFile.setFileName(fileName);
svgGenFile.setViewBox(r);
svgGenFile.setDescription(QObject::tr("SVG widget drawing "));
QPainter p;
p.begin(&svgGenFile);
p.setFont(widget->font());
widget->render(&p);
p.setPen(Qt::black);
//p.drawText(0, r.height()+heightAxe+versionHeight, r.width(), versionHeight,
// Qt::AlignCenter,
// qApp->applicationName() + " " + qApp->applicationVersion());
p.drawText(0, r.height() + 10, r.width(), heightText,
Qt::AlignCenter,
qApp->applicationName() + " " + qApp->applicationVersion());
p.end();
return true;
}
/* ------- Копировать в буфер ЗОЗ ------- */
void ViewPlot::copyToBuffer()
{
QBuffer b;
QClipboard *clipboard = QApplication::clipboard();
QSvgGenerator p;
p.setOutputDevice(&b);
p.setSize(QSize(800,800));
p.setViewBox(QRect(0,0,800,800));
QPainter painter;
QwtPlotRenderer renderer;
painter.begin(&p);
painter.setRenderHint(QPainter::Antialiasing);
renderer.render(ui->qwtPlot_spectrogram,&painter,QRect(0,0,800,800));
painter.end();
QMimeData * d = new QMimeData();
d->setData("image/svg+xml",b.buffer());
d->setData("image/svg+xml-compressed", b.buffer());
d->setImageData(QPixmap::grabWidget(ui->qwtPlot_spectrogram, 0,0,-1,-1));
clipboard->setMimeData(d,QClipboard::Clipboard);
}
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() );
}
}
}
QFileInfo saveWidgetAsImage(QObject* wid, const QRect& r, const QString& dialogTitle, const QString& defaultPath, const AppSettings & appSetting)
{
QFileInfo fileInfo;
QGraphicsScene* scene = 0;
QWidget* widget = dynamic_cast<QWidget*>(wid);
GraphView* mGraph = dynamic_cast<GraphView*>(wid);
if(!mGraph && !widget)
{
scene = dynamic_cast<QGraphicsScene*>(wid);
if(!scene)
return fileInfo;
}
QString filter = QObject::tr("Image (*.png);;Photo (*.jpg);; Windows Bitmap (*.bmp);;Scalable Vector Graphics (*.svg)");
QString fileName = QFileDialog::getSaveFileName(qApp->activeWindow(),
dialogTitle,
defaultPath,
filter);
if(!fileName.isEmpty())
{
fileInfo = QFileInfo(fileName);
QString fileExtension = fileInfo.suffix();
//QString fileExtension = fileName.(".svg");
// bool asSvg = fileName.endsWith(".svg");
// if(asSvg)
//QFontMetrics fm((scene ? qApp->font() : widget->font()));
float heightText = r.height()/50; //fm.height() + 30;
/*if (heightText<10) {
heightText = 10;
}*/
if(fileExtension == "svg")
{
if(mGraph)
{
mGraph->saveAsSVG(fileName, "Title", "Description",true);
}
else if(scene)
{
QSvgGenerator svgGen;
svgGen.setFileName(fileName);
svgGen.setSize(r.size());
svgGen.setViewBox(QRect(0, 0, r.width(), r.height()));
svgGen.setDescription(QObject::tr("SVG scene drawing "));
//qDebug()<<"export scene as SVG";
QPainter p;
p.begin(&svgGen);
scene->render(&p, r, r);
p.end();
}
else if(widget)
{
saveWidgetAsSVG(widget, r, fileName);
}
}
else
{ // save PNG
//int versionHeight = 20;
//qreal pr = 1;//qApp->devicePixelRatio();
/* qreal prh= 32000. / ( r.height() + versionHeight) ; // QImage axes are limited to 32767x32767 pixels
qreal prw= 32000. / r.width() ; qreal pr = (prh<prw)? prh : prw;
if (pr>4) {
pr=4;
}
*/
// -------------------------------
// Get preferences
// -------------------------------
short pr = appSetting.mPixelRatio;
short dpm = appSetting.mDpm;
short quality = appSetting.mImageQuality;
// -------------------------------
// Create the image
// -------------------------------
QImage image(r.width() * pr, (r.height() + heightText) * pr , QImage::Format_ARGB32_Premultiplied);
if(image.isNull()){
qDebug() << "Cannot export null image!";
return fileInfo;
}
// -------------------------------
// Set image properties
// -------------------------------
image.setDotsPerMeterX(dpm * 11811.024 / 300.);
image.setDotsPerMeterY(dpm * 11811.024 / 300.);
image.setDevicePixelRatio(pr);
// -------------------------------
// Fill background
// -------------------------------
if (fileExtension == "jpg") {
image.fill(Qt::white);
}
else {
image.fill(Qt::transparent);
}
// -------------------------------
// Create painter
// -------------------------------
QPainter p;
p.begin(&image);
p.setRenderHint(QPainter::Antialiasing);
// -------------------------------
// If widget, draw with or without axis
// -------------------------------
if(widget){
//p.setFont(widget->font());
widget->render(&p, QPoint(0, 0), QRegion(r.x(), r.y(), r.width(), r.height()));
}
// -------------------------------
// If scene...
// -------------------------------
else if(scene){
QRectF srcRect = r;
srcRect.setX(r.x());
srcRect.setY(r.y());
srcRect.setWidth(r.width() * pr);
srcRect.setHeight(r.height() * pr);
QRectF tgtRect = image.rect();
tgtRect.adjust(0, 0, 0, -heightText * pr);
scene->render(&p, tgtRect, srcRect);
}
// -------------------------------
// Write application and version
// -------------------------------
QFont ft = scene ? qApp->font() : widget->font();
ft.setPixelSize(heightText);
p.setFont(ft);
p.setPen(Qt::black);
p.drawText(0, r.height(), r.width(), heightText,
Qt::AlignCenter,
qApp->applicationName() + " " + qApp->applicationVersion());
p.end();
// -------------------------------
// Save file
// -------------------------------
image.save(fileName, fileExtension.toUtf8(), quality);
//image.save(fileName, formatExt);
/*QImageWriter writer;
writer.setFormat("jpg");
writer.setQuality(100);
writer.setFileName(fileName+"_jpg");
writer.write(image);*/
}
}
return fileInfo;
}
int bandageImage(QStringList arguments)
{
QTextStream out(stdout);
QTextStream err(stderr);
if (checkForHelp(arguments))
{
printImageUsage(&out, false);
return 0;
}
if (checkForHelpAll(arguments))
{
printImageUsage(&out, true);
return 0;
}
if (arguments.size() < 2)
{
printImageUsage(&err, false);
return 1;
}
QString graphFilename = arguments.at(0);
arguments.pop_front();
if (!checkIfFileExists(graphFilename))
{
err << "Bandage error: " << graphFilename << " does not exist" << endl;
return 1;
}
QString imageSaveFilename = arguments.at(0);
arguments.pop_front();
QString imageFileExtension = imageSaveFilename.right(4);
bool pixelImage;
if (imageFileExtension == ".png" || imageFileExtension == ".jpg")
pixelImage = true;
else if (imageFileExtension == ".svg")
pixelImage = false;
else
{
err << "Bandage error: the output filename must end in .png, .jpg or .svg" << endl;
return 1;
}
QString error = checkForInvalidImageOptions(arguments);
if (error.length() > 0)
{
err << "Bandage error: " << error << endl;
return 1;
}
bool loadSuccess = g_assemblyGraph->loadGraphFromFile(graphFilename);
if (!loadSuccess)
{
err << "Bandage error: could not load " << graphFilename << endl;
return 1;
}
int width = 0;
int height = 0;
parseImageOptions(arguments, &width, &height);
//For Bandage image, it is necessary to position node labels at the
//centre of the node, not the visible centre(s). This is because there
//is no viewport.
g_settings->positionTextNodeCentre = true;
//Since frame rate performance doesn't matter for a fixed image, set the
//default node outline to a nonzero value.
g_settings->outlineThickness = 0.3;
bool blastUsed = isOptionPresent("--query", &arguments);
if (blastUsed)
{
if (!createBlastTempDirectory())
{
err << "Error creating temporary directory for BLAST files" << endl;
return 1;
}
QString blastError = g_blastSearch->doAutoBlastSearch();
if (blastError != "")
{
err << blastError << endl;
return 1;
}
}
QString errorTitle;
QString errorMessage;
std::vector<DeBruijnNode *> startingNodes = g_assemblyGraph->getStartingNodes(&errorTitle, &errorMessage,
g_settings->doubleMode,
g_settings->startingNodes,
"all");
if (errorMessage != "")
{
err << errorMessage << endl;
return 1;
}
g_assemblyGraph->buildOgdfGraphFromNodesAndEdges(startingNodes, g_settings->nodeDistance);
g_assemblyGraph->layoutGraph();
MyGraphicsScene scene;
g_assemblyGraph->addGraphicsItemsToScene(&scene);
scene.setSceneRectangle();
double sceneRectAspectRatio = scene.sceneRect().width() / scene.sceneRect().height();
//Determine image size
//If neither height nor width set, use a default of height = 1000.
if (height == 0 && width == 0)
height = 1000;
//If only height or width is set, scale the other to fit.
if (height > 0 && width == 0)
width = height * sceneRectAspectRatio;
else if (height == 0 && width > 0)
height = width / sceneRectAspectRatio;
bool success = true;
QPainter painter;
if (pixelImage)
{
QImage image(width, height, QImage::Format_ARGB32);
image.fill(Qt::white);
painter.begin(&image);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::TextAntialiasing);
scene.render(&painter);
success = image.save(imageSaveFilename);
painter.end();
}
else //SVG
{
QSvgGenerator generator;
generator.setFileName(imageSaveFilename);
generator.setSize(QSize(width, height));
generator.setViewBox(QRect(0, 0, width, height));
painter.begin(&generator);
painter.fillRect(0, 0, width, height, Qt::white);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::TextAntialiasing);
scene.render(&painter);
painter.end();
}
int returnCode;
if (!success)
{
out << "There was an error writing the image to file." << endl;
returnCode = 1;
}
else
returnCode = 0;
if (blastUsed)
deleteBlastTempDirectory();
return returnCode;
}
void MusicShape::saveOdf( KoShapeSavingContext & context ) const
{
// The name of this object in the ODF file.
KoEmbeddedDocumentSaver &fileSaver = context.embeddedSaver();
QString objectName = fileSaver.getFilename("Object");
KoXmlWriter& writer = context.xmlWriter();
writer.startElement("draw:frame");
saveOdfAttributes(context, OdfAllAttributes);
writer.startElement("music:shape");
writer.addAttribute("xmlns:music", "http://www.calligra.org/music");
MusicXmlWriter().writeSheet(writer, m_sheet, false);
writer.endElement(); // music:shape
const qreal previewZoom = 150 / 72.; // 150 DPI
QSizeF imgSize = size(); // in points
imgSize *= previewZoom;
KoViewConverter converter;
// Save a preview SVG image.
// -------------------------
// 1. Set up the svg renderer.
QByteArray svgContents; // The contents
QBuffer svgBuffer(&svgContents); // The corresponding QIODevice
QSvgGenerator svg;
svg.setOutputDevice(&svgBuffer); // Write to the buffer
svg.setSize(imgSize.toSize());
svg.setViewBox(QRect(0, 0, boundingRect().width(), boundingRect().height()));
// 2. Paint the svg preview image.
//
// We need to create all text as paths, because otherwise it
// will be difficult for most people to preview the SVG
// image. Not many people have music fonts installed.
QPainter svgPainter;
svgPainter.begin(&svg);
svgPainter.setRenderHint(QPainter::Antialiasing);
svgPainter.setRenderHint(QPainter::TextAntialiasing);
m_style->setTextAsPath(true);
constPaint(svgPainter, converter);
m_style->setTextAsPath(false);
svgPainter.end();
// 3. Create the xml to embed the svg image and the contents to the file.
writer.startElement("draw:image");
QString name = QString("ObjectReplacements/") + objectName + ".svg";
writer.addAttribute("xlink:type", "simple" );
writer.addAttribute("xlink:show", "embed" );
writer.addAttribute("xlink:actuate", "onLoad");
writer.addAttribute("xlink:href", name);
writer.endElement(); // draw:image
fileSaver.saveFile(name, "image/svg+xml", svgContents);
// Save a preview bitmap image.
// ----------------------------
// 1. Create the image.
QImage img(imgSize.toSize(), QImage::Format_ARGB32);
QPainter painter(&img);
painter.setRenderHint(QPainter::Antialiasing);
painter.setRenderHint(QPainter::TextAntialiasing);
converter.setZoom(previewZoom);
constPaint(painter, converter);
// 2. Create the xml to embed the svg image and the contents to the file.
writer.startElement("draw:image");
name = context.imageHref(img);
// FIXME: Find out how to save a picture using the embeddedSaver and saveFile()
//name = QString("ObjectReplacements/") + objectName + ".png";
writer.addAttribute("xlink:type", "simple" );
writer.addAttribute("xlink:show", "embed" );
writer.addAttribute("xlink:actuate", "onLoad");
writer.addAttribute("xlink:href", name);
writer.endElement(); // draw:image
saveOdfCommonChildElements(context);
writer.endElement(); // draw:frame
}
///write a polygon on a SVG file, format of the polygon is vector of vector of contours...nested contours are holes
///takes the name of the image in input, the set of polygons, the set of per polygons transformation,
///the label to be written and the global parameter for drawing style
void PolyDumper::dumpPolySetSVG(const char * imageName,
vector< vector< vector<Point2f> > > &polyVecVec,
vector<Similarity2f> &trVec,
vector< vector< string> > &labelVecVec,
vector<vector<Point2f> > &labelPosVecVec,
vector<vector<float> >&labelRadVecVec,
PolyDumperParam &pp)
{
assert(polyVecVec.size() == trVec.size());
///SET THE FONT
int fontSize;
if(pp.fontSize==0) fontSize=ceil(std::max(pp.width,pp.height)/200.0);
else fontSize=pp.fontSize;
QFont qf("courier",fontSize);
QSvgGenerator svg;
svg.setFileName(imageName);
///SET THE DRAWING SIZE
svg.setSize(QSize(pp.width,pp.height));
svg.setViewBox(QRect(0, 0, pp.width,pp.height));
svg.setResolution(int(pp.dpi));//
///SETUP OF DRAWING PROCEDURE
QPainter painter;
painter.begin(&svg);
QBrush bb;
if (pp.fill)
bb.setStyle(Qt::SolidPattern);
QPen qp;
///SET THE GLOBAL SCALING FACTOR
float Scalesvg=1.f/(float)trVec[0].sca;
qp.setWidthF(Scalesvg);
for(size_t i=0;i<polyVecVec.size();++i)
{
///SET THE CURRENT TRANSFORMATION
painter.resetTransform();
painter.translate(trVec[i].tra[0],trVec[i].tra[1]);
painter.rotate(math::ToDeg(trVec[i].rotRad));
painter.scale(trVec[i].sca,trVec[i].sca);
QPainterPath QPP;
for(size_t jj=0;jj<polyVecVec[i].size();++jj)
{
QVector<QPointF> ppQ;
for(size_t j=0;j<polyVecVec[i][jj].size();++j)
{
Point2f pp=polyVecVec[i][jj][j];
ppQ.push_back(QPointF(pp[0],pp[1]));
}
ppQ.push_back(QPointF(polyVecVec[i][jj][0][0],polyVecVec[i][jj][0][1]));
QPP.addPolygon(QPolygonF(ppQ));
}
///FIND THE INCENTER
if (pp.randomColor)
bb.setColor(vcg::ColorConverter::ToQColor(Color4b::Scatter(polyVecVec.size(),i)));
else
bb.setColor(vcg::ColorConverter::ToQColor(pp.FillColor));
///DRAW THE POLYGON
painter.setBrush(bb);
painter.setPen(qp);
painter.drawPath(QPP);
///DRAW THE TEXT
painter.setFont(qf);
float radius;
int radiusInt;
Point2f bc;
// if we do not have labelPos use the old method of empty disk.
if(labelPosVecVec.empty()) bc=GetIncenter(polyVecVec[i],trVec[i],radiusInt);
radius = radiusInt;
for(size_t labelInd=0;labelInd<labelVecVec[i].size();++labelInd)
{
if(!labelPosVecVec.empty())
{
bc= labelPosVecVec[i][labelInd];
bc.Rotate(trVec[i].rotRad);
bc *= trVec[i].sca;
radius=labelRadVecVec[i][labelInd];
radius *= trVec[i].sca;
}
painter.resetTransform();
painter.translate(trVec[i].tra[0],trVec[i].tra[1]);
painter.drawText(bc[0]-radius,bc[1]-radius,radius*2,radius*2,Qt::AlignHCenter|Qt::AlignCenter,QString(labelVecVec[i][labelInd].c_str()));
}
}
painter.end();
}
