I think, at first you have to make in QGraphicsItem something like “exporting to XML” method
for example:

I don’t understand. Why would I need to define a toSvg() method? One would think that a QGraphicsSvgItem would already know how to convert itself to SVG. Further, who would call the toSvg() method? It’s not defined in the base class, so it’s not something that QPainter would know to call.

Surely there must be some established way to save a QGraphicsScene to an SVG file.

I don’t think so. It can’t know what are you currently drawing. Your own inherited class should have this method and do something in that method…

Hello, try this. It works for me

That’s essentially what I tried: create and initialize a QSvgGenerator, create a QPainter and associate it with the generator, then pass the painter to scene.render(). It does create an SVG file. But the contents of the file are bitmapped. I’d much rather the contents were scalable vectors. I imagine this ought to be possible, since each QGraphicsItem in my scene is composed of vector information. It would seem, though, that the painter is rendering the graphics items to a backing store. I’m looking for other options.

The above code generates following file:

It can be opened and edited by Inkscape. Rectangle and text are recognized as two different objects and they are editable. Isn`t this what you want?

I wish I could get output like that! Rather, I can, if I stick with QGraphicsLineItems and the like. But each QGraphicsSvgItem results in output like the following:

I can load the results in Illustrator, and each item is recognized as a different object. But when you zoom into the illustration, it’s clear that these items are just pixels, not scalable vectors.

I’ll tell you what I’m trying to do, so you can see why I find this behavior less than optimal: I’m drawing charts that are composed of lines and symbols. The symbols are stored in an SVG file created in Illustrator. Each symbol is contained within its own group—for example:

This lets me load the symbols with code like the following:

So the symbols are stored in memory as vector data. Yet I can’t get QSvgGenerator and QPainter to produce that vector data when saving the scene. I have to wonder: is it a basic limitation of the way QPainter interacts with QGraphicsSvgItems?

I think I understand what you want. You got a scene with a lot of SVG items and you want this scene to be saved as another SVG. So you need something like a SVG with embedded SVGs. Unfortunately, I think it is not possible :(

That’s it exactly: I have a scene composed partly of simple lines and partly of SVG data, and I want to save the scene as scalable SVG.

The more I look into this, the more I think it may be a bug. Consider: if I create a scene composed of a QGraphicsLine and a QGraphicsSvgItem, and display the scene within a QGraphicsView, then within the paint() methods for the line and the SVG item, the paint device for the line is of type PaintDeviceFlags.Widget and the paint device for the SVG item is of type PaintDeviceFlags.Pixmap. So far, so good: the line is being painted with calls to native widget code, and the SVG item is being rendered to a backing-store pixmap before being copied to the QGraphicsView widget. I can deal with that.

But if the same scene is saved to an SVG file via…

…then when QGraphicsLine.paint() is called, the paint device is the QSvgGenerator shown above BUT when QGraphicsSvgItem.paint() is called, the paint device is of type PaintDeviceFlags.Pixmap. In other words, the QSvgGenerator is being asked to draw the line but the SVG item is being rendered to a backing-store pixmap.

This doesn’t make any sense to me. Why should a call to scene.render() cause a QGraphicsSvgItem to be rendered to a pixmap?

It’s especially puzzling because each QGraphicsSvgItem retains a reference to the QSvgRenderer that loaded it in the first place. And that renderer is capable of producing the necessary SVG code. That is, if you call the QSvgRenderer instead of scene.render(), as on line 7 below…

…you get an SVG file containing SVG code for the item: no bitmaps, just clean vectors. Unfortunately, the item isn’t positioned or styled correctly.

So the next thing for me to try, it would seem, is to redefine QGraphicsSvgItem.paint() such that it sets the given painter appropriately before calling renderer().render(). Still, I don’t think a workaround of this sort should be necessary. You would think that a painter that’s been given a QSvgGenerator for use as a paint device would actually use that device when painting the QGraphicsSvgItems within a scene… wouldn’t you?

New discovery: although the docs for QGraphicsItem state that cacheMode() returns NoCache by default, in reality the default cache mode for QGraphicsSvgItems is QGraphicsItem.DeviceCoordinateCache. In other words, the default is to use a backing-store pixmap.

Changing the cache mode for each QGraphicsSvgItem to NoCache…

…lets QSvgGenerator do its job and create SVG files with scalable (rather than bitmapped) elements.

Unfortunately, it also prevents the SVG items from being cached when being displayed in a QGraphicsView, but I can live with that.

Note related problem, bug #11409 [bugreports.qt.nokia.com].

Reported as bug #19563 [bugreports.qt.nokia.com].