void flowwidget::SaveSVG(std::ostream &data) {
std::cerr << "[FlowWidget] Request to export recieved, enumerating nodes for size" << std::endl;
int GenMinimum = INT_MAX;
int GenExtreme = INT_MIN;
std::for_each(XMLHandlr->OrphanNodes.begin(), XMLHandlr->OrphanNodes.end(),
[&](std::pair<std::string, FlowNode> nodepair) {
NodeSize ns = getNodeSize(QFont("sans-serif", BaseFontSize*nodepair.second.FontSizeMult), QFont("sans-serif", BaseFontSize*nodepair.second.FontSizeMult*1.5), nodepair.second);
if (nodepair.second.CenterPosX - (ns.Width/2) < GenMinimum)
GenMinimum = nodepair.second.CenterPosX - (ns.Width/2);
if (nodepair.second.CenterPosY - (ns.Height/2) < GenMinimum)
GenMinimum = nodepair.second.CenterPosY - (ns.Height/2);
if (nodepair.second.CenterPosX + (ns.Width/2) > GenExtreme)
GenExtreme = nodepair.second.CenterPosX + (ns.Width/2);
if (nodepair.second.CenterPosY + (ns.Height/2) > GenExtreme)
GenExtreme = nodepair.second.CenterPosY + (ns.Height/2);
});
int SVGSize = GenExtreme-GenMinimum;
std::cerr << "[FlowWidget] Calculated sheet size of " << SVGSize << std::endl;
QSvgGenerator svgen;
QIODevice* iodev = new IOStreamBridge(data);
svgen.setOutputDevice(iodev);
svgen.setSize(QSize(SVGSize, SVGSize));
renderFullTree(&svgen, XMLHandlr,
LineColor, BaseFontSize, "",
SVGSize, SVGSize, PermaScale, 1, 0, 0);
data.flush();
std::cerr << "[FlowWidget] Finished export!" << std::endl;
}
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;
}
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 MainWindow::printsvg()
{
// QString fileName(_record->name2display().append(".svg").c_str());
QString fileName("bfviewer.svg");
const QList<QByteArray> imageFormats =
QImageWriter::supportedImageFormats();
QStringList filter;
filter += "SVG Documents (*.svg)";
fileName = QFileDialog::getSaveFileName(
this, "Export File Name", fileName,
filter.join(";;"), NULL, QFileDialog::DontConfirmOverwrite);
if (!fileName.isEmpty())
{
QSvgGenerator generator;
QwtPlotRenderer plotrender;
generator.setFileName( fileName );
generator.setSize(_gridPlot->size());
plotrender.renderTo(_gridPlot->p,generator);
}
}
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);
}
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;
}
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;
}
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 FilterWindow::onBtnExportFilterPlot()
{
// Open file dialog
QDate date;
QString fileName = QFileDialog::getSaveFileName(this,
"Save filter plot",
QString("%1/%2_%3_%4_FilterPlot").arg(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation)).arg(date.currentDate().year()).arg(date.currentDate().month()).arg(date.currentDate().day()),
tr("Vector graphic(*.svg);;Images (*.png)"));
if(!fileName.isEmpty()) {
// Generate screenshot
if(fileName.contains(".svg")) {
QSvgGenerator svgGen;
svgGen.setFileName(fileName);
QRectF rect = m_pFilterPlotScene->itemsBoundingRect();
svgGen.setSize(QSize(rect.width(), rect.height()));
//svgGen.setViewBox(QRect(0, 0, rect.width(), rect.height()));
QPainter painter(&svgGen);
m_pFilterPlotScene->render(&painter);
}
if(fileName.contains(".png")) {
m_pFilterPlotScene->setSceneRect(m_pFilterPlotScene->itemsBoundingRect()); // Re-shrink the scene to it's bounding contents
QImage image(m_pFilterPlotScene->sceneRect().size().toSize(), QImage::Format_ARGB32); // Create the image with the exact size of the shrunk scene
image.fill(Qt::transparent); // Start all pixels transparent
QPainter painter(&image);
m_pFilterPlotScene->render(&painter);
image.save(fileName);
}
}
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QTextCodec::setCodecForTr(QTextCodec::codecForLocale());
QSvgGenerator svgGen;
svgGen.setFileName("test.svg");
QRectF rectangle(10.0, 20.0, 80.0, 60.0);
QPainter painter;
painter.begin(&svgGen);
QPen pen(Qt::red);
painter.setPen(pen);
painter.drawEllipse(rectangle);
rectangle.moveRight(100);
painter.drawRect(rectangle);
rectangle.moveRight(100);
QRectF source(0.0, 0.0, 70.0, 40.0);
QImage image("Greenstone.bmp");
painter.drawImage(rectangle, image, source);
painter.end();
return 0;
}
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 tst_QSvgGenerator::construction()
{
QSvgGenerator generator;
QCOMPARE(generator.fileName(), QString());
QCOMPARE(generator.outputDevice(), (QIODevice *)0);
QCOMPARE(generator.resolution(), 72);
QCOMPARE(generator.size(), QSize());
}
void NMGPlotWidget::exportToSVG(QString filePath)
{
if(!filePath.endsWith(".svg", Qt::CaseInsensitive)) filePath.append(".svg");
QSvgGenerator svgGen;
svgGen.setFileName(filePath);
svgGen.setSize(QSize(width()-4,height()-4));
QPainter p(&svgGen);
render(&p);
}
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 SceneImageExporter::ExportToSVG(QGraphicsScene *scene, QString fileName)
{
QSvgGenerator *generator = new QSvgGenerator();
generator->setResolution(72);
generator->setSize(QSize(
(int)scene->sceneRect().width(),
(int)scene->sceneRect().height()));
generator->setFileName(fileName);
QPainter painter(generator);
painter.setBrush(QColor("white"));
scene->render(&painter);
}
void data_plot::saveSVG()
{
if (save_file_name.length() > 0)
{
QSvgGenerator svg;
svg.setFileName((save_file_name + ".svg").c_str());
svg.setSize(QSize(600, 450));
myPlot.print(svg);
svg.setFileName((save_file_name + "_2.svg").c_str());
}
}
void Matrix::exportSVG(const QString& fileName)
{
int width = numRows();
int height = numCols();
QSvgGenerator svg;
svg.setFileName(fileName);
svg.setSize(QSize(width, height));
QPainter p(&svg);
p.drawImage (QRect(0, 0, width, height), d_matrix_model->renderImage());
p.end();
}
/*!
\brief Render the plot to a QSvgGenerator
If the generator has a view box, the plot will be rendered into it.
If it has no viewBox but a valid size the target coordinates
will be (0, 0, generator.width(), generator.height()). Otherwise
the target rectangle will be QRectF(0, 0, 800, 600);
\param plot Plot to be rendered
\param generator SVG generator
*/
void QwtPolarRenderer::renderTo(
QwtPolarPlot *plot, QSvgGenerator &generator ) const
{
QRectF rect = generator.viewBoxF();
if ( rect.isEmpty() )
rect.setRect( 0, 0, generator.width(), generator.height() );
if ( rect.isEmpty() )
rect.setRect( 0, 0, 800, 600 ); // something
QPainter p( &generator );
render( plot, &p, rect );
}
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
AnimatorView::save()
{
QString fileName = "";
fileName = QFileDialog::getSaveFileName();
if(fileName == "")
{
return;
}
QSvgGenerator svgGen;
svgGen.setFileName(fileName);
svgGen.setSize(QSize(size()));
QPainter painter(&svgGen);
painter.setRenderHint(QPainter::Antialiasing);
render(&painter);
}
bool Renderer::renderToSvg()
{
if (svgFile.isEmpty()) {
qDebug() << "No svg file set";
return false;
}
QSvgGenerator svg;
svg.setFileName(svgFile);
QPainter p;
p.begin(&svg);
target->render(&p);
p.end();
return true;
}
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 GraphEditor::image(QPrinter* printer, QString suffix)
{if(!scene())return;
QRect geo = geometry();
int size = staticData::sizeImage;
resize(size+4,size+4);
load(true);
qApp->processEvents();
int rtt;
QList<QGraphicsItem *> list = gwp->canvas->items();
for(QList<QGraphicsItem *>::Iterator it=list.begin();it!=list.end(); ++it)
{rtt = (int)(*it)->type();
if(rtt == col_rtti || rtt == thick_rtti)
(*it)->hide();
}
int nx = (int)gwp->canvas->width();
int ny = (int)gwp->canvas->height();
if(suffix == "png" || suffix == "jpg")
{QPixmap pixmap = QPixmap(nx,ny);
QPainter pp(&pixmap);
pp.setBrush(QBrush(Qt::white));
pp.setPen(QPen(Qt::white));
pp.drawRect(QRect(0,0,nx,ny));
pp.setPen(QPen(Qt::black));
render(&pp,QRectF(2,2,nx,ny),QRect(2,2,nx,ny));
pixmap.save(staticData::fileImage);
}
else if(suffix == "svg")
{QSvgGenerator *svg = new QSvgGenerator();
svg->setFileName(staticData::fileImage);
svg->setResolution(90); //ecran pts/pouce
//svg->setResolution(physicalDpiX()); //ecran 101
svg->setSize(QSize(nx,ny));
QPainter pp(svg);
pp.setBrush(QBrush(Qt::white));
pp.setPen(QPen(Qt::white));
pp.drawRect(QRect(0,0,nx,ny));
pp.setPen(QPen(Qt::black));
render(&pp,QRectF(2,2,nx,ny),QRect(2,2,nx,ny));
}
else if(suffix == "pdf" || suffix == "ps")
{QPainter pp(printer);
render(&pp,QRectF(0,0,printer->width(),printer->height()),QRect(2,2,nx,ny));
}
setGeometry(geo);
load(true);
}
bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgEllipse(const QDomElement &element)
{
//ellipse horisontal and vertical radius
qreal rx = element.attribute(aRx).toDouble();
qreal ry = element.attribute(aRy).toDouble();
QSvgGenerator *generator = createSvgGenerator(rx * 2, ry * 2);
//fill and stroke color
QColor fillColor = colorFromString(element.attribute(aFill));
QColor strokeColor = colorFromString(element.attribute(aStroke));
int strokeWidth = element.attribute(aStrokewidth).toInt();
//ellipse center coordinates
qreal cx = element.attribute(aCx).toDouble();
qreal cy = element.attribute(aCy).toDouble();
//init painter to paint to svg
QPainter painter;
painter.begin(generator);
QPen pen(strokeColor);
pen.setWidth(strokeWidth);
painter.setPen(pen);
painter.setBrush(QBrush(fillColor));
painter.drawEllipse(0, 0, rx * 2, ry * 2);
painter.end();
UBGraphicsSvgItem *svgItem = mCurrentScene->addSvg(QUrl::fromLocalFile(generator->fileName()));
QTransform transform;
QString textTransform = element.attribute(aTransform);
svgItem->resetTransform();
if (!textTransform.isNull()) {
transform = transformFromString(textTransform, svgItem);
}
repositionSvgItem(svgItem, rx * 2, ry * 2, cx - 2*rx, cy+ry, transform);
hashSceneItem(element, svgItem);
delete generator;
return true;
}
void MainWindow::loadPath( const QPainterPath &path )
{
QBuffer buf;
QSvgGenerator generator;
generator.setOutputDevice( &buf );
QPainter painter( &generator );
painter.setRenderHint( QPainter::Antialiasing, false );
painter.setPen( QPen( Qt::blue, 0 ) );
painter.setBrush( Qt::darkCyan );
painter.drawPath( path );
painter.end();
d_canvas[0]->setSvg( buf.data() );
d_canvas[1]->setSvg( buf.data() );
}
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 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 Matrix::exportSVG(const QString& fileName)
{
#if QT_VERSION >= 0x040300
if (d_view_type != ImageView)
return;
int width = numRows();
int height = numCols();
QSvgGenerator svg;
svg.setFileName(fileName);
svg.setSize(QSize(width, height));
QPainter p(&svg);
p.drawImage (QRect(0, 0, width, height), d_matrix_model->renderImage());
p.end();
#endif
}
