Dimensions of an SVG image from rsvg_handle_get_dimensions(), or an individual element from rsvg_handle_get_dimensions_sub(). Please see the deprecation documentation for those functions.

FIXME: point to deprecation documentation.

SVG's width, in pixels SVG's height, in pixels SVG's original width, unmodified by #RsvgSizeFunc SVG's original height, unmodified by #RsvgSizeFunc

An enumeration representing possible errors the request failed The error domain for RSVG

The error domain

Lets you load SVG data and render it.

Returns a new rsvg handle. Must be freed with @g_object_unref. This handle can be used to load an image. The preferred way of loading SVG data into the returned #RsvgHandle is with rsvg_handle_read_stream_sync(). The deprecated way of loading SVG data is with rsvg_handle_write() and rsvg_handle_close(); note that these require buffering the entire file internally, and for this reason it is better to use the stream functions: rsvg_handle_new_from_stream_sync(), rsvg_handle_read_stream_sync(), or rsvg_handle_new_from_gfile_sync(). After loading the #RsvgHandle with data, you can render it using Cairo or get a GdkPixbuf from it. When finished, free the handle with g_object_unref(). No more than one image can be loaded with one handle. Note that this function creates an #RsvgHandle with no flags set. If you require any of #RsvgHandleFlags to be set, use any of rsvg_handle_new_with_flags(), rsvg_handle_new_from_stream_sync(), or rsvg_handle_new_from_gfile_sync().

A new #RsvgHandle with no flags set.

Loads the SVG specified by @data. Note that this function creates an #RsvgHandle without a base URL, and without any #RsvgHandleFlags. If you need these, use rsvg_handle_new_from_stream_sync() instead by creating a #GMemoryInputStream from your data.

A #RsvgHandle or %NULL if an error occurs.

The SVG data The length of @data, in bytes

Loads the SVG specified by @file_name. Note that this function, like rsvg_handle_new(), does not specify any loading flags for the resulting handle. If you require the use of #RsvgHandleFlags, use rsvg_handle_new_from_gfile_sync().

A #RsvgHandle or %NULL if an error occurs.

The file name to load, or a URI.

Creates a new #RsvgHandle for @file. This function sets the "base file" of the handle to be @file itself, so SVG elements like <literal><image></literal> which reference external resources will be resolved relative to the location of @file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in @error.

a new #RsvgHandle on success, or %NULL with @error filled in

a #GFile flags from #RsvgHandleFlags a #GCancellable, or %NULL

Creates a new #RsvgHandle for @stream. This function sets the "base file" of the handle to be @base_file if provided. SVG elements like <literal><image></literal> which reference external resources will be resolved relative to the location of @base_file. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in @error.

a new #RsvgHandle on success, or %NULL with @error filled in

a #GInputStream a #GFile, or %NULL flags from #RsvgHandleFlags a #GCancellable, or %NULL

Creates a new #RsvgHandle with flags @flags. After calling this function, you can feed the resulting handle with SVG data by using rsvg_handle_read_stream_sync().

a new #RsvgHandle

flags from #RsvgHandleFlags

Closes @handle, to indicate that loading the image is complete. This will return %TRUE if the loader closed successfully and the SVG data was parsed correctly. Note that @handle isn't freed until @g_object_unref is called.

Use rsvg_handle_read_stream_sync() or the constructor functions rsvg_handle_new_from_gfile_sync() or rsvg_handle_new_from_stream_sync(). See the deprecation notes for rsvg_handle_write() for more information.

%TRUE on success, or %FALSE on error.

a #RsvgHandle

Gets the base uri for this #RsvgHandle.

the base uri, possibly null

A #RsvgHandle

Get the SVG's size. Do not call from within the size_func callback, because an infinite loop will occur. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand.

A #RsvgHandle

A place to store the SVG's size

Get the size of a subelement of the SVG file. Do not call from within the size_func callback, because an infinite loop will occur. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute.

Use rsvg_handle_get_geometry_for_layer() instead.

A #RsvgHandle

A place to store the SVG's size An element's id within the SVG, starting with "##" (a single hash character), for example, "##layer1". This notation corresponds to a URL's fragment ID. Alternatively, pass %NULL to use the whole SVG.

Computes the ink rectangle and logical rectangle of a single SVG element. While `rsvg_handle_get_geometry_for_layer` computes the geometry of an SVG element subtree with its transformation matrix, this other function will compute the element's geometry as if it were being rendered under an identity transformation by itself. That is, the resulting geometry is as if the element got extracted by itself from the SVG. This function is the counterpart to `rsvg_handle_render_element`. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute. The "ink rectangle" is the bounding box that would be painted for fully- stroked and filled elements. The "logical rectangle" just takes into account the unstroked paths and text outlines. Note that these bounds are not minimum bounds; for example, clipping paths are not taken into account. You can pass #NULL for the @id if you want to measure all the elements in the SVG, i.e. to measure everything from the root element. This operation is not constant-time, as it involves going through all the child elements. API ordering: This function must be called on a fully-loaded @handle. See the section <ulink url="#API-ordering">API ordering</ulink> for details. Panics: this function will panic if the @handle is not fully-loaded.

An #RsvgHandle

An element's id within the SVG, starting with "##" (a single hash character), for example, "##layer1". This notation corresponds to a URL's fragment ID. Alternatively, pass %NULL to compute the geometry for the whole SVG. Place to store the ink rectangle of the element. Place to store the logical rectangle of the element.

Computes the ink rectangle and logical rectangle of an SVG element, or the whole SVG, as if the whole SVG were rendered to a specific viewport. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute. The "ink rectangle" is the bounding box that would be painted for fully- stroked and filled elements. The "logical rectangle" just takes into account the unstroked paths and text outlines. Note that these bounds are not minimum bounds; for example, clipping paths are not taken into account. You can pass #NULL for the @id if you want to measure all the elements in the SVG, i.e. to measure everything from the root element. This operation is not constant-time, as it involves going through all the child elements. API ordering: This function must be called on a fully-loaded @handle. See the section <ulink url="#API-ordering">API ordering</ulink> for details. Panics: this function will panic if the @handle is not fully-loaded.

An #RsvgHandle

An element's id within the SVG, starting with "##" (a single hash character), for example, "##layer1". This notation corresponds to a URL's fragment ID. Alternatively, pass %NULL to compute the geometry for the whole SVG. Viewport size at which the whole SVG would be fitted. Place to store the ink rectangle of the element. Place to store the logical rectangle of the element.

Queries the <literal>width</literal>, <literal>height</literal>, and <literal>viewBox</literal> attributes in an SVG document. If you are calling this function to compute a scaling factor to render the SVG, consider simply using rsvg_handle_render_document() instead; it will do the scaling computations automatically. As an example, the following SVG element has a <literal>width</literal> of 100 pixels and a <literal>height</literal> of 400 pixels, but no <literal>viewBox</literal>: |[ <svg xmlns="http://www.w3.org/2000/svg" width="100" height="400"> ]| Conversely, the following element has a <literal>viewBox</literal>, but no <literal>width</literal> or <literal>height</literal>: |[ <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 400"> ]| Note that the #RsvgLength return values have #RsvgUnits in them; you should not assume that they are always in pixels. For example, the following SVG element will return a width value whose <literal>units</literal> field is RSVG_UNIT_MM. |[ <svg xmlns="http://www.w3.org/2000/svg" width="210mm" height="297mm"> ]| API ordering: This function must be called on a fully-loaded @handle. See the section <ulink url="#API-ordering">API ordering</ulink> for details. Panics: this function will panic if the @handle is not fully-loaded.

An #RsvgHandle

Will be set to #TRUE if the toplevel SVG has a <literal>width</literal> attribute Will be set to the value of the <literal>width</literal> attribute in the toplevel SVG Will be set to #TRUE if the toplevel SVG has a <literal>height</literal> attribute Will be set to the value of the <literal>height</literal> attribute in the toplevel SVG Will be set to #TRUE if the toplevel SVG has a <literal>viewBox</literal> attribute Will be set to the value of the <literal>viewBox</literal> attribute in the toplevel SVG

Returns the pixbuf loaded by @handle. The pixbuf returned will be reffed, so the caller of this function must assume that ref. If insufficient data has been read to create the pixbuf, or an error occurred in loading, then %NULL will be returned. Note that the pixbuf may not be complete until @rsvg_handle_close has been called. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand.

the pixbuf loaded by @handle, or %NULL.

An #RsvgHandle

Creates a #GdkPixbuf the same size as the entire SVG loaded into @handle, but only renders the sub-element that has the specified @id (and all its sub-sub-elements recursively). If @id is #NULL, this function renders the whole SVG. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand. If you need to render an image which is only big enough to fit a particular sub-element of the SVG, consider using rsvg_handle_render_cairo_sub(), upon a surface that is just the size returned by rsvg_handle_get_dimensions_sub(). You will need to offset the rendering by the amount returned in rsvg_handle_get_position_sub(). Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute.

a pixbuf, or %NULL if an error occurs during rendering.

An #RsvgHandle

Get the position of a subelement of the SVG file. Do not call from within the size_func callback, because an infinite loop will occur. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute.

Use rsvg_handle_get_geometry_for_layer() instead.

A #RsvgHandle

A place to store the SVG fragment's position. An element's id within the SVG, starting with "##" (a single hash character), for example, "##layer1". This notation corresponds to a URL's fragment ID. Alternatively, pass %NULL to use the whole SVG.

Checks whether the element @id exists in the SVG document. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute.

%TRUE if @id exists in the SVG document, %FALSE otherwise.

a #RsvgHandle

An element's id within the SVG, starting with "##" (a single hash character), for example, "##layer1". This notation corresponds to a URL's fragment ID.

Do not call this function. This is intended for librsvg's internal test suite only.

a #RsvgHandle

Whether to enable testing mode

Reads @stream and writes the data from it to @handle. Before calling this function, you may need to call rsvg_handle_set_base_uri() or rsvg_handle_set_base_gfile() to set the "base file" for resolving references to external resources. SVG elements like <literal><image></literal> which reference external resources will be resolved relative to the location you specify with those functions. If @cancellable is not %NULL, then the operation can be cancelled by triggering the cancellable object from another thread. If the operation was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.

%TRUE if reading @stream succeeded, or %FALSE otherwise with @error filled in

a #RsvgHandle

a #GInputStream a #GCancellable, or %NULL

Draws a loaded SVG handle to a Cairo context. Drawing will occur with respect to the @cr's current transformation: for example, if the @cr has a rotated current transformation matrix, the whole SVG will be rotated in the rendered version. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand. Note that @cr must be a Cairo context that is not in an error state, that is, cairo_status() must return #CAIRO_STATUS_SUCCESS for it. Cairo can set a context to be in an error state in various situations, for example, if it was passed an invalid matrix or if it was created for an invalid surface.

%TRUE if drawing succeeded; %FALSE otherwise.

A #RsvgHandle

A Cairo context

Draws a subset of a loaded SVG handle to a Cairo context. Drawing will occur with respect to the @cr's current transformation: for example, if the @cr has a rotated current transformation matrix, the whole SVG will be rotated in the rendered version. This function depends on the #RsvgHandle's DPI to compute dimensions in pixels, so you should call rsvg_handle_set_dpi() beforehand. Note that @cr must be a Cairo context that is not in an error state, that is, cairo_status() must return #CAIRO_STATUS_SUCCESS for it. Cairo can set a context to be in an error state in various situations, for example, if it was passed an invalid matrix or if it was created for an invalid surface. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute.

%TRUE if drawing succeeded; %FALSE otherwise.

A #RsvgHandle

A Cairo context An element's id within the SVG, starting with "##" (a single hash character), for example, "##layer1". This notation corresponds to a URL's fragment ID. Alternatively, pass %NULL to render the whole SVG.

Renders the whole SVG document fitted to a viewport. The @viewport gives the position and size at which the whole SVG document will be rendered. The @cr must be in a #CAIRO_STATUS_SUCCESS state, or this function will not render anything, and instead will return an error. API ordering: This function must be called on a fully-loaded @handle. See the section <ulink url="#API-ordering">API ordering</ulink> for details. Panics: this function will panic if the @handle is not fully-loaded.

An #RsvgHandle

A Cairo context Viewport size at which the whole SVG would be fitted.

Renders a single SVG element to a given viewport This function can be used to extract individual element subtrees and render them, scaled to a given @element_viewport. This is useful for applications which have reusable objects in an SVG and want to render them individually; for example, an SVG full of icons that are meant to be be rendered independently of each other. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute. You can pass #NULL for the @id if you want to render all the elements in the SVG, i.e. to render everything from the root element. The `element_viewport` gives the position and size at which the named element will be rendered. FIXME: mention proportional scaling. API ordering: This function must be called on a fully-loaded @handle. See the section <ulink url="#API-ordering">API ordering</ulink> for details. Panics: this function will panic if the @handle is not fully-loaded.

An #RsvgHandle

Renders a single SVG element in the same place as for a whole SVG document. This is equivalent to rsvg_handle_render_document(), but it renders only a single element and its children, as if they composed an individual layer in the SVG. The element is rendered with the same transformation matrix as it has within the whole SVG document. Applications can use this to re-render a single element and repaint it on top of a previously-rendered document, for example. Element IDs should look like an URL fragment identifier; for example, pass "##foo" (hash <literal>foo</literal>) to get the geometry of the element that has an <literal>id="foo"</literal> attribute. You can pass #NULL for the @id if you want to render all the elements in the SVG, i.e. to render everything from the root element. API ordering: This function must be called on a fully-loaded @handle. See the section <ulink url="#API-ordering">API ordering</ulink> for details. Panics: this function will panic if the @handle is not fully-loaded.

An #RsvgHandle

Set the base URI for @handle from @file. Note: This function may only be called before rsvg_handle_write() or rsvg_handle_read_stream_sync() have been called.

a #RsvgHandle

a #GFile

Set the base URI for this SVG. Note: This function may only be called before rsvg_handle_write() or rsvg_handle_read_stream_sync() have been called.

A #RsvgHandle

The base uri

Sets the DPI at which the @handle will be rendered. Common values are 75, 90, and 300 DPI. Passing a number <= 0 to @dpi will reset the DPI to whatever the default value happens to be, but since rsvg_set_default_dpi() is deprecated, please do not pass values <= 0 to this function.

An #RsvgHandle

Dots Per Inch (i.e. as Pixels Per Inch)

Sets the DPI at which the @handle will be rendered. Common values are 75, 90, and 300 DPI. Passing a number <= 0 to @dpi will reset the DPI to whatever the default value happens to be, but since rsvg_set_default_dpi_x_y() is deprecated, please do not pass values <= 0 to this function.

An #RsvgHandle

Dots Per Inch (i.e. Pixels Per Inch) Dots Per Inch (i.e. Pixels Per Inch)

Sets a CSS stylesheet to use for an SVG document. The @css_len argument is mandatory; this function will not compute the length of the @css string. This is because a provided stylesheet, which the calling program could read from a file, can have nul characters in it. During the CSS cascade, the specified stylesheet will be used with a "User" <ulink url="https://drafts.csswg.org/css-cascade-3/#cascading-origins">origin</ulink>. Note that `@import` rules will not be resolved, except for `data:` URLs.

A #RsvgHandle.

String with CSS data; must be valid UTF-8. Length of the @css data in bytes.

Loads the next @count bytes of the image. Before calling this function for the first time, you may need to call rsvg_handle_set_base_uri() or rsvg_handle_set_base_gfile() to set the "base file" for resolving references to external resources. SVG elements like <literal><image></literal> which reference external resources will be resolved relative to the location you specify with those functions.

Use rsvg_handle_read_stream_sync() or the constructor functions rsvg_handle_new_from_gfile_sync() or rsvg_handle_new_from_stream_sync(). This function is deprecated because it will accumulate data from the @buf in memory until rsvg_handle_close() gets called. To avoid a big temporary buffer, use the suggested functions, which take a #GFile or a #GInputStream and do not require a temporary buffer.

%TRUE on success, or %FALSE on error.

an #RsvgHandle

pointer to svg data length of the @buf buffer in bytes

SVG's description.

Reading this property always returns #NULL.

Exact width, in pixels, of the rendered SVG before calling the size callback as specified by rsvg_handle_set_size_callback().

Reading each of the size properties causes the size of the SVG to be recomputed, so reading both the <literal>em</literal> and <literal>ex</literal> properties will cause two such computations. Please use rsvg_handle_get_intrinsic_dimensions() instead.

Exact height, in pixels, of the rendered SVG before calling the size callback as specified by rsvg_handle_set_size_callback().

Flags from #RsvgHandleFlags. Height, in pixels, of the rendered SVG after calling the size callback as specified by rsvg_handle_set_size_callback().

For historical reasons, this property is of integer type, which cannot give the exact size of SVG images that are not pixel-aligned. Moreover, reading each of the size properties causes the size of the SVG to be recomputed, so reading both the <literal>width</literal> and <literal>height</literal> properties will cause two such computations. Please use rsvg_handle_get_intrinsic_dimensions() instead.

SVG's metadata

Reading this property always returns #NULL.

SVG's title.

Reading this property always returns #NULL.

Width, in pixels, of the rendered SVG after calling the size callback as specified by rsvg_handle_set_size_callback().

Class structure for #RsvgHandle.

parent class

No flags are set. Disable safety limits in the XML parser. Libxml2 has <ulink url="https://gitlab.gnome.org/GNOME/libxml2/blob/master/include/libxml/parserInternals.h">several limits</ulink> designed to keep malicious XML content from consuming too much memory while parsing. For security reasons, this should only be used for trusted input! Since: 2.40.3 Use this if the Cairo surface to which you are rendering is a PDF, PostScript, SVG, or Win32 Printing surface. This will make librsvg and Cairo use the original, compressed data for images in the final output, instead of passing uncompressed images. This will make a Keeps the image data when loading images, for use by cairo when painting to e.g. a PDF surface. For example, this will make the a resulting PDF file smaller and faster. Please see <ulink url="https://www.cairographics.org/manual/cairo-cairo-surface-t.html#cairo-surface-set-mime-data">the Cairo documentation</ulink> for details. Since: 2.40.3

#RsvgLength values are used in rsvg_handle_get_intrinsic_dimensions(), for example, to return the CSS length values of the <literal>width</literal> and <literal>height</literal> attributes of an <literal><svg></literal> element. This is equivalent to <ulink url="https://www.w3.org/TR/CSS21/syndata.html#length-units">CSS lengths</ulink>. It is up to the calling application to convert lengths in non-pixel units (i.e. those where the @unit field is not #RSVG_UNIT_PX) into something meaningful to the application. For example, if your application knows the dots-per-inch (DPI) it is using, it can convert lengths with @unit in #RSVG_UNIT_IN or other physical units.

numeric part of the length unit part of the length

Position of an SVG fragment from rsvg_handle_get_position_sub(). Please the deprecation documentation for that function.

FIXME: point to deprecation documentation.

position on the x axis position on the y axis

A data structure for holding a rectangle.

X coordinate of the left side of the rectangle Y coordinate of the the top side of the rectangle width of the rectangle height of the rectangle

Units for the #RsvgLength struct. These have the same meaning as <ulink url="https://www.w3.org/TR/CSS21/syndata.html#length-units">CSS length units</ulink>.

percentage values; where <literal>1.0</literal> means 100%. pixels em, or the current font size x-height of the current font inches centimeters millimeters points, or 1/72 inch picas, or 1/6 inch (12 points)

No-op. This function should not be called from normal programs.

The error domain for RSVG

The error domain

This is the main entry point into the librsvg library. An RsvgHandle is an object that represents SVG data in memory. Your program creates an RsvgHandle from an SVG file, or from a memory buffer that contains SVG data, or in the most general form, from a #GInputStream that will provide SVG data. Librsvg can load SVG images and render them to Cairo surfaces, using a mixture of SVG's [static mode] and [secure static mode]. Librsvg does not do animation nor scripting, and can load references to external data only in some situations; see below. Librsvg supports reading <ulink url="https://www.w3.org/TR/SVG11/">SVG 1.1</ulink> data, and is gradually adding support for features in <ulink url="https://www.w3.org/TR/SVG2/">SVG 2</ulink>. Librsvg also supports SVGZ files, which are just an SVG stream compressed with the GZIP algorithm. # The "base file" and resolving references to external files When you load an SVG, librsvg needs to know the location of the "base file" for it. This is so that librsvg can determine the location of referenced entities. For example, say you have an SVG in <filename>/foo/bar/foo.svg</filename> and that it has an image element like this: |[ <image href="resources/foo.png" .../> ]| In this case, librsvg needs to know the location of the toplevel <filename>/foo/bar/foo.svg</filename> so that it can generate the appropriate reference to <filename>/foo/bar/resources/foo.png</filename>. ## Security and locations of referenced files When processing an SVG, librsvg will only load referenced files if they are in the same directory as the base file, or in a subdirectory of it. That is, if the base file is <filename>/foo/bar/baz.svg</filename>, then librsvg will only try to load referenced files (from SVG's <literal><image></literal> element, for example, or from content included through XML entities) if those files are in <filename>/foo/bar/*</filename> or in <filename>/foo/bar/*/.../*</filename>. This is so that malicious SVG files cannot include files that are in a directory above. The full set of rules for deciding which URLs may be loaded is as follows; they are applied in order. A referenced URL will not be loaded as soon as one of these rules fails: <orderedlist> <listitem> All <literal>data:</literal> URLs may be loaded. These are sometimes used to include raster image data, encoded as base-64, directly in an SVG file. </listitem> <listitem> All other URL schemes in references require a base URL. For example, this means that if you load an SVG with rsvg_handle_new_from_data() without calling rsvg_handle_set_base_uri(), then any referenced files will not be allowed (e.g. raster images to be loaded from other files will not work). </listitem> <listitem> If referenced URLs are absolute, rather than relative, then they must have the same scheme as the base URL. For example, if the base URL has a "<literal>file</literal>" scheme, then all URL references inside the SVG must also have the "<literal>file</literal>" scheme, or be relative references which will be resolved against the base URL. </listitem> <listitem> If referenced URLs have a "<literal>resource</literal>" scheme, that is, if they are included into your binary program with GLib's resource mechanism, they are allowed to be loaded (provided that the base URL is also a "<literal>resource</literal>", per the previous rule). </listitem> <listitem> Otherwise, non-<literal>file</literal> schemes are not allowed. For example, librsvg will not load <literal>http</literal> resources, to keep malicious SVG data from "phoning home". </listitem> <listitem> A relative URL must resolve to the same directory as the base URL, or to one of its subdirectories. Librsvg will canonicalize filenames, by removing ".." path components and resolving symbolic links, to decide whether files meet these conditions. </listitem> </orderedlist> # Loading an SVG with GIO This is the easiest and most resource-efficient way of loading SVG data into an #RsvgHandle. If you have a #GFile that stands for an SVG file, you can simply call rsvg_handle_new_from_gfile_sync() to load an RsvgHandle from it. Alternatively, if you have a #GInputStream, you can use rsvg_handle_new_from_stream_sync(). Both of those methods allow specifying a #GCancellable, so the loading process can be cancelled from another thread. ## Loading an SVG from memory If you already have SVG data in a byte buffer in memory, you can create a memory input stream with g_memory_input_stream_new_from_data() and feed that to rsvg_handle_new_from_stream_sync(). Note that in this case, it is important that you specify the base_file for the in-memory SVG data. Librsvg uses the base_file to resolve links to external content, like raster images. # Loading an SVG without GIO You can load an RsvgHandle from a simple filename or URI with rsvg_handle_new_from_file(). Note that this is a blocking operation; there is no way to cancel it if loading a remote URI takes a long time. Also, note that this method does not let you specify #RsvgHandleFlags. Otherwise, loading an SVG without GIO is not recommended, since librsvg will need to buffer your entire data internally before actually being able to parse it. The deprecated way of doing this is by creating a handle with rsvg_handle_new() or rsvg_handle_new_with_flags(), and then using rsvg_handle_write() and rsvg_handle_close() to feed the handle with SVG data. Still, please try to use the GIO stream functions instead. # Resolution of the rendered image (dots per inch, or DPI) SVG images can contain dimensions like "<literal>5 cm</literal>" or "<literal>2 pt</literal>" that must be converted from physical units into device units. To do this, librsvg needs to know the actual dots per inch (DPI) of your target device. You can call rsvg_handle_set_dpi() or rsvg_handle_set_dpi_x_y() on an RsvgHandle to set the DPI before rendering it. # Rendering The preferred way to render an already-loaded RsvgHandle is to use rsvg_handle_render_cairo(). Please see its documentation for details. Alternatively, you can use rsvg_handle_get_pixbuf() to directly obtain a #GdkPixbuf with the rendered image. This is simple, but it does not let you control the size at which the SVG will be rendered. It will just be rendered at the size which rsvg_handle_get_dimensions() would return, which depends on the dimensions that librsvg is able to compute from the SVG data. # API ordering Due to the way the librsvg API evolved over time, an #RsvgHandle object is available for use as soon as it is constructed. However, not all of its methods can be called at any time. For example, an #RsvgHandle just constructed with rsvg_handle_new() is not loaded yet, and it does not make sense to call rsvg_handle_get_dimensions() on it just at that point. The documentation for the available methods in #RsvgHandle may mention that a particular method is only callable on a "fully loaded handle". This means either: <itemizedlist> <listitem> The handle was loaded with rsvg_handle_write() and rsvg_handle_close(), and those functions returned no errors. </listitem> <listitem> The handle was loaded with rsvg_handle_read_stream_sync() and that function returned no errors. </listitem> </itemizedlist> Before librsvg 2.46, the library did not fully verify that a handle was in a fully loaded state for the methods that require it. To preserve compatibility with old code which inadvertently called the API without checking for errors, or which called some methods outside of the expected order, librsvg will just emit a g_critical() message in those cases. New methods introduced in librsvg 2.46 and later will check for the correct ordering, and panic if they are called out of order. This will abort the program as if it had a failed assertion. GdkPixbuf is a library for image loading and manipulation. It is part of the cross-platform GTK+ widget toolkit. Do not use this function. Create an #RsvgHandle and call rsvg_handle_set_dpi() on it instead.

This function used to set a global default DPI. However, it only worked if it was called before any #RsvgHandle objects had been created; it would not work after that. To avoid global mutable state, please use rsvg_handle_set_dpi() instead.

Dots Per Inch (aka Pixels Per Inch)

Do not use this function. Create an #RsvgHandle and call rsvg_handle_set_dpi_x_y() on it instead.

Dots Per Inch (aka Pixels Per Inch) Dots Per Inch (aka Pixels Per Inch)