Creates a new GdkPixbuf structure and allocates a buffer for it.
If the allocation of the buffer failed, this function will return NULL.
The buffer has an optimal rowstride. Note that the buffer is not cleared; you will have to fill it completely yourself.
Color space for image
Whether the image should have transparency information
Number of bits per color sample
Width of image in pixels, must be > 0
Height of image in pixels, must be > 0
The number of bits per sample.
Currently only 8 bit per sample are supported.
The color space of the pixbuf.
Currently, only GDK_COLORSPACE_RGB is supported.
Whether the pixbuf has an alpha channel.
The number of rows of the pixbuf.
The number of samples per pixel.
Currently, only 3 or 4 samples per pixel are supported.
A pointer to the pixel data of the pixbuf.
The number of bytes between the start of a row and the start of the next row.
This number must (obviously) be at least as large as the width of the pixbuf.
The number of columns of the pixbuf.
Takes an existing pixbuf and adds an alpha channel to it.
If the existing pixbuf already had an alpha channel, the channel values are copied from the original; otherwise, the alpha channel is initialized to 255 (full opacity).
If substitute_color is TRUE, then the color specified by the
(r, g, b) arguments will be assigned zero opacity. That is,
if you pass (255, 255, 255) for the substitute color, all white
pixels will become fully transparent.
If substitute_color is FALSE, then the (r, g, b) arguments
will be ignored.
Whether to set a color to zero opacity.
Red value to substitute.
Green value to substitute.
Blue value to substitute.
Takes an existing pixbuf and checks for the presence of an associated "orientation" option.
The orientation option may be provided by the JPEG loader (which reads the exif orientation tag) or the TIFF loader (which reads the TIFF orientation tag, and compensates it for the partial transforms performed by libtiff).
If an orientation option/tag is present, the appropriate transform will be performed so that the pixbuf is oriented correctly.
Creates a binding between source_property on source and target_property
on target.
Whenever the source_property is changed the target_property is
updated using the same value. For instance:
g_object_bind_property (action, "active", widget, "sensitive", 0);
Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.
If flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
if target_property on target changes then the source_property on source
will be updated as well.
The binding will automatically be removed when either the source or the
target instances are finalized. To remove the binding without affecting the
source and the target you can just call g_object_unref() on the returned
#GBinding instance.
Removing the binding by calling g_object_unref() on it must only be done if
the binding, source and target are only used from a single thread and it
is clear that both source and target outlive the binding. Especially it
is not safe to rely on this if the binding, source or target can be
finalized from different threads. Keep another reference to the binding and
use g_binding_unbind() instead to be on the safe side.
A #GObject can have multiple bindings.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
Creates a binding between source_property on source and target_property
on target, allowing you to set the transformation functions to be used by
the binding.
This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.
the property on source to bind
the target #GObject
the property on target to bind
flags to pass to #GBinding
a #GClosure wrapping the transformation function from the source to the target, or %NULL to use the default
a #GClosure wrapping the transformation function from the target to the source, or %NULL to use the default
Creates a transformation of the source image src by scaling by
scale_x and scale_y then translating by offset_x and offset_y.
This gives an image in the coordinates of the destination pixbuf.
The rectangle (dest_x, dest_y, dest_width, dest_height)
is then alpha blended onto the corresponding rectangle of the
original destination image.
When the destination rectangle contains parts not in the source image, the data at the edges of the source image is replicated to infinity.
the #GdkPixbuf into which to render the results
the left coordinate for region to render
the top coordinate for region to render
the width of the region to render
the height of the region to render
the offset in the X direction (currently rounded to an integer)
the offset in the Y direction (currently rounded to an integer)
the scale factor in the X direction
the scale factor in the Y direction
the interpolation type for the transformation.
overall alpha for source image (0..255)
Creates a transformation of the source image src by scaling by
scale_x and scale_y then translating by offset_x and offset_y,
then alpha blends the rectangle (dest_x ,dest_y, dest_width,
dest_height) of the resulting image with a checkboard of the
colors color1 and color2 and renders it onto the destination
image.
If the source image has no alpha channel, and overall_alpha is 255, a fast
path is used which omits the alpha blending and just performs the scaling.
See gdk_pixbuf_composite_color_simple() for a simpler variant of this function suitable for many tasks.
the #GdkPixbuf into which to render the results
the left coordinate for region to render
the top coordinate for region to render
the width of the region to render
the height of the region to render
the offset in the X direction (currently rounded to an integer)
the offset in the Y direction (currently rounded to an integer)
the scale factor in the X direction
the scale factor in the Y direction
the interpolation type for the transformation.
overall alpha for source image (0..255)
the X offset for the checkboard (origin of checkboard is at -check_x, -check_y)
the Y offset for the checkboard
the size of checks in the checkboard (must be a power of two)
the color of check at upper left
the color of the other check
Creates a new pixbuf by scaling src to dest_width x dest_height
and alpha blending the result with a checkboard of colors color1
and color2.
the width of destination image
the height of destination image
the interpolation type for the transformation.
overall alpha for source image (0..255)
the size of checks in the checkboard (must be a power of two)
the color of check at upper left
the color of the other check
Creates a new GdkPixbuf with a copy of the information in the specified
pixbuf.
Note that this does not copy the options set on the original GdkPixbuf,
use gdk_pixbuf_copy_options() for this.
Copies a rectangular area from src_pixbuf to dest_pixbuf.
Conversion of pixbuf formats is done automatically.
If the source rectangle overlaps the destination rectangle on the same pixbuf, it will be overwritten during the copy operation. Therefore, you can not use this function to scroll a pixbuf.
Source X coordinate within src_pixbuf.
Source Y coordinate within src_pixbuf.
Width of the area to copy.
Height of the area to copy.
Destination pixbuf.
X coordinate within dest_pixbuf.
Y coordinate within dest_pixbuf.
Copies the key/value pair options attached to a GdkPixbuf to another
GdkPixbuf.
This is useful to keep original metadata after having manipulated a file. However be careful to remove metadata which you've already applied, such as the "orientation" option after rotating the image.
the destination pixbuf
Clears a pixbuf to the given RGBA value, converting the RGBA value into the pixbuf's pixel format.
The alpha component will be ignored if the pixbuf doesn't have an alpha channel.
RGBA pixel to used to clear (0xffffffff is opaque white, 0x00000000 transparent black)
Flips a pixbuf horizontally or vertically and returns the result in a new pixbuf.
TRUE to flip horizontally, FALSE to flip vertically
This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().
Increases the freeze count on object. If the freeze count is
non-zero, the emission of "notify" signals on object is
stopped. The signals are queued until the freeze count is decreased
to zero. Duplicate notifications are squashed so that at most one
#GObject::notify signal is emitted for each property modified while the
object is frozen.
This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.
Queries the number of bits per color sample in a pixbuf.
Returns the length of the pixel data, in bytes.
Queries the color space of a pixbuf.
Gets a named field from the objects table of associations (see g_object_set_data()).
name of the key for that association
Queries whether a pixbuf has an alpha channel (opacity information).
Queries the height of a pixbuf.
Queries the number of channels of a pixbuf.
Looks up key in the list of options that may have been attached to the
pixbuf when it was loaded, or that may have been attached by another
function using gdk_pixbuf_set_option().
For instance, the ANI loader provides "Title" and "Artist" options. The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot options for cursor definitions. The PNG loader provides the tEXt ancillary chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders return an "orientation" option string that corresponds to the embedded TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets the "multipage" option string to "yes" when a multi-page TIFF is loaded. Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file contains image density information in dots per inch. Since 2.36.6, the JPEG loader sets the "comment" option with the comment EXIF tag.
a nul-terminated string.
Returns a GHashTable with a list of all the options that may have been
attached to the pixbuf when it was loaded, or that may have been
attached by another function using [methodGdkPixbuf.Pixbuf.set_option].
Queries a pointer to the pixel data of a pixbuf.
This function will cause an implicit copy of the pixbuf data if the pixbuf was created from read-only data.
Please see the section on image data for information about how the pixel data is stored in memory.
Gets a property of an object.
The value can be:
In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset().
Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.
the name of the property to get
return location for the property value
This function gets back user data pointers stored via g_object_set_qdata().
A #GQuark, naming the user data pointer
Queries the rowstride of a pixbuf, which is the number of bytes between the start of a row and the start of the next row.
Queries the width of a pixbuf.
Gets n_properties properties for an object.
Obtained properties will be set to values. All properties must be valid.
Warnings will be emitted and undefined behaviour may result if invalid
properties are passed in.
the names of each property to get
the values of each property to get
Checks whether object has a [floating][floating-ref] reference.
Loads a loadable icon. For the asynchronous version of this function, see g_loadable_icon_load_async().
an integer.
optional #GCancellable object, %NULL to ignore.
Loads an icon asynchronously. To finish this function, see g_loadable_icon_load_finish(). For the synchronous, blocking version of this function, see g_loadable_icon_load().
an integer.
optional #GCancellable object, %NULL to ignore.
a #GAsyncReadyCallback to call when the request is satisfied
Finishes an asynchronous icon load started in g_loadable_icon_load_async().
a #GAsyncResult.
Creates a new pixbuf which represents a sub-region of src_pixbuf.
The new pixbuf shares its pixels with the original pixbuf, so
writing to one affects both. The new pixbuf holds a reference to
src_pixbuf, so src_pixbuf will not be finalized until the new
pixbuf is finalized.
Note that if src_pixbuf is read-only, this function will force it
to be mutable.
X coord in src_pixbuf
Y coord in src_pixbuf
width of region in src_pixbuf
height of region in src_pixbuf
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
the name of a property installed on the class of object.
Emits a "notify" signal for the property specified by pspec on object.
This function omits the property name lookup, hence it is faster than g_object_notify().
One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:
enum
{
PROP_0,
PROP_FOO,
PROP_LAST
};
static GParamSpec *properties[PROP_LAST];
static void
my_object_class_init (MyObjectClass *klass)
{
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
0, 100,
50,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class,
PROP_FOO,
properties[PROP_FOO]);
}
and then notify a change on the "foo" property with:
g_object_notify_by_pspec (self, properties[PROP_FOO]);
the #GParamSpec of a property installed on the class of object.
Provides a #GBytes buffer containing the raw pixel data; the data must not be modified.
This function allows skipping the implicit copy that must be made if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
Provides a read-only pointer to the raw pixel data.
This function allows skipping the implicit copy that must be made if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
Increase the reference count of object, and possibly remove the
[floating][floating-ref] reference, if object has a floating reference.
In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.
Since GLib 2.56, the type of object will be propagated to the return type
under the same conditions as for g_object_ref().
Removes the key/value pair option attached to a GdkPixbuf.
a nul-terminated string representing the key to remove.
Rotates a pixbuf by a multiple of 90 degrees, and returns the result in a new pixbuf.
If angle is 0, this function will return a copy of src.
the angle to rotate by
Releases all references to other objects. This can be used to break reference cycles.
This function should only be called from object system implementations.
Modifies saturation and optionally pixelates src, placing the result in
dest.
The src and dest pixbufs must have the same image format, size, and
rowstride.
The src and dest arguments may be the same pixbuf with no ill effects.
If saturation is 1.0 then saturation is not changed. If it's less than 1.0,
saturation is reduced (the image turns toward grayscale); if greater than
1.0, saturation is increased (the image gets more vivid colors).
If pixelate is TRUE, then pixels are faded in a checkerboard pattern to
create a pixelated image.
place to write modified version of src
saturation factor
whether to pixelate
Vector version of gdk_pixbuf_save_to_buffer().
Saves pixbuf to a new buffer in format type, which is currently "jpeg",
"tiff", "png", "ico" or "bmp".
See [methodGdkPixbuf.Pixbuf.save_to_buffer] for more details.
name of file format.
name of options to set
values for named options
Vector version of gdk_pixbuf_save_to_callback().
Saves pixbuf to a callback in format type, which is currently "jpeg",
"png", "tiff", "ico" or "bmp".
If error is set, FALSE will be returned.
See [methodGdkPixbuf.Pixbuf.save_to_callback] for more details.
a function that is called to save each block of data that the save routine generates.
name of file format.
name of options to set
values for named options
Saves pixbuf to an output stream.
Supported file formats are currently "jpeg", "tiff", "png", "ico" or "bmp".
See [methodGdkPixbuf.Pixbuf.save_to_stream] for more details.
a GOutputStream to save the pixbuf to
name of file format
name of options to set
values for named options
optional GCancellable object, NULL to ignore
Saves pixbuf to an output stream asynchronously.
For more details see gdk_pixbuf_save_to_streamv(), which is the synchronous version of this function.
When the operation is finished, callback will be called in the main thread.
You can then call gdk_pixbuf_save_to_stream_finish() to get the result of the operation.
a GOutputStream to which to save the pixbuf
name of file format
name of options to set
values for named options
optional GCancellable object, NULL to ignore
a GAsyncReadyCallback to call when the pixbuf is saved
Vector version of gdk_pixbuf_save().
Saves pixbuf to a file in type, which is currently "jpeg", "png", "tiff", "ico" or "bmp".
If error is set, FALSE will be returned.
See [methodGdkPixbuf.Pixbuf.save] for more details.
name of file to save.
name of file format.
name of options to set
values for named options
Creates a transformation of the source image src by scaling by
scale_x and scale_y then translating by offset_x and offset_y,
then renders the rectangle (dest_x, dest_y, dest_width,
dest_height) of the resulting image onto the destination image
replacing the previous contents.
Try to use gdk_pixbuf_scale_simple() first; this function is the industrial-strength power tool you can fall back to, if gdk_pixbuf_scale_simple() isn't powerful enough.
If the source rectangle overlaps the destination rectangle on the same pixbuf, it will be overwritten during the scaling which results in rendering artifacts.
the #GdkPixbuf into which to render the results
the left coordinate for region to render
the top coordinate for region to render
the width of the region to render
the height of the region to render
the offset in the X direction (currently rounded to an integer)
the offset in the Y direction (currently rounded to an integer)
the scale factor in the X direction
the scale factor in the Y direction
the interpolation type for the transformation.
Create a new pixbuf containing a copy of src scaled to
dest_width x dest_height.
This function leaves src unaffected.
The interp_type should be GDK_INTERP_NEAREST if you want maximum
speed (but when scaling down GDK_INTERP_NEAREST is usually unusably
ugly). The default interp_type should be GDK_INTERP_BILINEAR which
offers reasonable quality and speed.
You can scale a sub-portion of src by creating a sub-pixbuf
pointing into src; see [methodGdkPixbuf.Pixbuf.new_subpixbuf].
If dest_width and dest_height are equal to the width and height of
src, this function will return an unscaled copy of src.
For more complicated scaling/alpha blending see [methodGdkPixbuf.Pixbuf.scale]
and [methodGdkPixbuf.Pixbuf.composite].
the width of destination image
the height of destination image
the interpolation type for the transformation.
Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved back by calling g_icon_deserialize() on the returned value. As serialization will avoid using raw icon data when possible, it only makes sense to transfer the #GVariant between processes on the same machine, (as opposed to over the network), and within the same file system namespace.
Each object carries around a table of associations from strings to pointers. This function lets you set an association.
If the object already had an association with that name, the old association will be destroyed.
Internally, the key is converted to a #GQuark using g_quark_from_string().
This means a copy of key is kept permanently (even after object has been
finalized) — so it is recommended to only use a small, bounded set of values
for key in your program, to avoid the #GQuark storage growing unbounded.
name of the key
data to associate with that key
Attaches a key/value pair as an option to a GdkPixbuf.
If key already exists in the list of options attached to the pixbuf,
the new value is ignored and FALSE is returned.
a nul-terminated string.
a nul-terminated string.
Sets a property on an object.
the name of the property to set
the value
Remove a specified datum from the object's data associations, without invoking the association's destroy handler.
name of the key
This function gets back user data pointers stored via
g_object_set_qdata() and removes the data from object
without invoking its destroy() function (if any was
set).
Usually, calling this function is only required to update
user data pointers with a destroy notifier, for example:
void
object_add_to_user_list (GObject *object,
const gchar *new_string)
{
// the quark, naming the object data
GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
// retrieve the old string list
GList *list = g_object_steal_qdata (object, quark_string_list);
// prepend new string
list = g_list_prepend (list, g_strdup (new_string));
// this changed 'list', so we need to set it again
g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}
static void
free_string_list (gpointer data)
{
GList *node, *list = data;
for (node = list; node; node = node->next)
g_free (node->data);
g_list_free (list);
}
Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().
A #GQuark, naming the user data pointer
Reverts the effect of a previous call to
g_object_freeze_notify(). The freeze count is decreased on object
and when it reaches zero, queued "notify" signals are emitted.
Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.
It is an error to call this function when the freeze count is zero.
Generates a textual representation of icon that can be used for
serialization such as when passing icon to a different process or
saving it to persistent storage. Use g_icon_new_for_string() to
get icon back from the returned string.
The encoding of the returned string is proprietary to #GIcon except in the following two cases
If icon is a #GFileIcon, the returned string is a native path
(such as /path/to/my icon.png) without escaping
if the #GFile for icon is a native file. If the file is not
native, the returned string is the result of g_file_get_uri()
(such as sftp://path/to/my%20icon.png).
If icon is a #GThemedIcon with exactly one name and no fallbacks,
the encoding is simply the name (such as network-server).
Decreases the reference count of object. When its reference count
drops to 0, the object is finalized (i.e. its memory is freed).
If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.
Gets a hash for an icon.
Loads a loadable icon. For the asynchronous version of this function, see g_loadable_icon_load_async().
an integer.
optional #GCancellable object, %NULL to ignore.
Loads an icon asynchronously. To finish this function, see g_loadable_icon_load_finish(). For the synchronous, blocking version of this function, see g_loadable_icon_load().
an integer.
optional #GCancellable object, %NULL to ignore.
a #GAsyncReadyCallback to call when the request is satisfied
Finishes an asynchronous icon load started in g_loadable_icon_load_async().
a #GAsyncResult.
Emits a "notify" signal for the property property_name on object.
When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.
Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.
Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved back by calling g_icon_deserialize() on the returned value. As serialization will avoid using raw icon data when possible, it only makes sense to transfer the #GVariant between processes on the same machine, (as opposed to over the network), and within the same file system namespace.
This function essentially limits the life time of the closure to
the life time of the object. That is, when the object is finalized,
the closure is invalidated by calling g_closure_invalidate() on
it, in order to prevent invocations of the closure with a finalized
(nonexisting) object. Also, g_object_ref() and g_object_unref() are
added as marshal guards to the closure, to ensure that an extra
reference count is held on object during invocation of the
closure. Usually, this function will be called on closures that
use this object as closure data.
#GClosure to watch
Calculates the rowstride that an image created with those values would have.
This function is useful for front-ends and backends that want to check
image values without needing to create a GdkPixbuf.
Color space for image
Whether the image should have transparency information
Number of bits per color sample
Width of image in pixels, must be > 0
Height of image in pixels, must be > 0
Parses an image file far enough to determine its format and size.
The name of the file to identify.
Asynchronously parses an image file far enough to determine its format and size.
For more details see gdk_pixbuf_get_file_info(), which is the synchronous version of this function.
When the operation is finished, callback will be called in the
main thread. You can then call gdk_pixbuf_get_file_info_finish() to
get the result of the operation.
The name of the file to identify
optional GCancellable object, NULL to ignore
a GAsyncReadyCallback to call when the file info is available
Finishes an asynchronous pixbuf parsing operation started with gdk_pixbuf_get_file_info_async().
a GAsyncResult
Obtains the available information about the image formats supported by GdkPixbuf.
Initalizes the gdk-pixbuf loader modules referenced by the loaders.cache
file present inside that directory.
This is to be used by applications that want to ship certain loaders in a different location from the system ones.
This is needed when the OS or runtime ships a minimal number of loaders so as to reduce the potential attack surface of carefully crafted image files, especially for uncommon file types. Applications that require broader image file types coverage, such as image viewers, would be expected to ship the gdk-pixbuf modules in a separate location, bundled with the application in a separate directory from the OS or runtime- provided modules.
Path to directory where the loaders.cache is installed
Find the #GParamSpec with the given name for an
interface. Generally, the interface vtable passed in as g_iface
will be the default vtable from g_type_default_interface_ref(), or,
if you know the interface has already been loaded,
g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
name of a property to look up.
Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.
This function is meant to be called from the interface's default
vtable initialization function (the class_init member of
#GTypeInfo.) It must not be called after after class_init has
been called for any object types implementing this interface.
If pspec is a floating reference, it will be consumed.
any interface vtable for the interface, or the default vtable for the interface.
the #GParamSpec for the new property
Lists the properties of an interface.Generally, the interface
vtable passed in as g_iface will be the default vtable from
g_type_default_interface_ref(), or, if you know the interface has
already been loaded, g_type_default_interface_peek().
any interface vtable for the interface, or the default vtable for the interface
Creates a new GdkPixbuf structure and allocates a buffer for it.
If the allocation of the buffer failed, this function will return NULL.
The buffer has an optimal rowstride. Note that the buffer is not cleared; you will have to fill it completely yourself.
Color space for image
Whether the image should have transparency information
Number of bits per color sample
Width of image in pixels, must be > 0
Height of image in pixels, must be > 0
Creates a new #GdkPixbuf out of in-memory readonly image data.
Currently only RGB images with 8 bits per sample are supported.
This is the GBytes variant of gdk_pixbuf_new_from_data(), useful
for language bindings.
Image data in 8-bit/sample packed format inside a #GBytes
Colorspace for the image data
Whether the data has an opacity channel
Number of bits per sample
Width of the image in pixels, must be > 0
Height of the image in pixels, must be > 0
Distance in bytes between row starts
Creates a new #GdkPixbuf out of in-memory image data.
Currently only RGB images with 8 bits per sample are supported.
Since you are providing a pre-allocated pixel buffer, you must also
specify a way to free that data. This is done with a function of
type GdkPixbufDestroyNotify. When a pixbuf created with is
finalized, your destroy notification function will be called, and
it is its responsibility to free the pixel array.
See also: [ctorGdkPixbuf.Pixbuf.new_from_bytes]
Image data in 8-bit/sample packed format
Colorspace for the image data
Whether the data has an opacity channel
Number of bits per sample
Width of the image in pixels, must be > 0
Height of the image in pixels, must be > 0
Distance in bytes between row starts
Function used to free the data when the pixbuf's reference count drops to zero, or %NULL if the data should not be freed
Creates a new pixbuf by loading an image from a file.
The file format is detected automatically.
If NULL is returned, then error will be set. Possible errors are:
The error domains are GDK_PIXBUF_ERROR and G_FILE_ERROR.
Name of file to load, in the GLib file name encoding
Creates a new pixbuf by loading an image from a file.
The file format is detected automatically.
If NULL is returned, then error will be set. Possible errors are:
The error domains are GDK_PIXBUF_ERROR and G_FILE_ERROR.
The image will be scaled to fit in the requested size, optionally preserving the image's aspect ratio.
When preserving the aspect ratio, a width of -1 will cause the image
to be scaled to the exact given height, and a height of -1 will cause
the image to be scaled to the exact given width. When not preserving
aspect ratio, a width or height of -1 means to not scale the image
at all in that dimension. Negative values for width and height are
allowed since 2.8.
Name of file to load, in the GLib file name encoding
The width the image should have or -1 to not constrain the width
The height the image should have or -1 to not constrain the height
TRUE to preserve the image's aspect ratio
Creates a new pixbuf by loading an image from a file.
The file format is detected automatically.
If NULL is returned, then error will be set. Possible errors are:
The error domains are GDK_PIXBUF_ERROR and G_FILE_ERROR.
The image will be scaled to fit in the requested size, preserving
the image's aspect ratio. Note that the returned pixbuf may be smaller
than width x height, if the aspect ratio requires it. To load
and image at the requested size, regardless of aspect ratio, use
[ctorGdkPixbuf.Pixbuf.new_from_file_at_scale].
Name of file to load, in the GLib file name encoding
The width the image should have or -1 to not constrain the width
The height the image should have or -1 to not constrain the height
Creates a GdkPixbuf from a flat representation that is suitable for
storing as inline data in a program.
This is useful if you want to ship a program with images, but don't want to depend on any external files.
GdkPixbuf ships with a program called gdk-pixbuf-csource, which allows
for conversion of GdkPixbufs into such a inline representation.
In almost all cases, you should pass the --raw option to
gdk-pixbuf-csource. A sample invocation would be:
gdk-pixbuf-csource --raw --name=myimage_inline myimage.png
For the typical case where the inline pixbuf is read-only static data,
you don't need to copy the pixel data unless you intend to write to
it, so you can pass FALSE for copy_pixels. If you pass --rle to
gdk-pixbuf-csource, a copy will be made even if copy_pixels is FALSE,
so using this option is generally a bad idea.
If you create a pixbuf from const inline data compiled into your program, it's probably safe to ignore errors and disable length checks, since things will always succeed:
pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL);
For non-const inline data, you could get out of memory. For untrusted inline data located at runtime, you could have corrupt inline data in addition.
Byte data containing a serialized GdkPixdata structure
Whether to copy the pixel data, or use direct pointers data for the resulting pixbuf
Creates a new pixbuf by loading an image from an resource.
The file format is detected automatically. If NULL is returned, then
error will be set.
the path of the resource file
Creates a new pixbuf by loading an image from an resource.
The file format is detected automatically. If NULL is returned, then
error will be set.
The image will be scaled to fit in the requested size, optionally
preserving the image's aspect ratio. When preserving the aspect ratio,
a width of -1 will cause the image to be scaled to the exact given
height, and a height of -1 will cause the image to be scaled to the
exact given width. When not preserving aspect ratio, a width or
height of -1 means to not scale the image at all in that dimension.
The stream is not closed.
the path of the resource file
The width the image should have or -1 to not constrain the width
The height the image should have or -1 to not constrain the height
TRUE to preserve the image's aspect ratio
Creates a new pixbuf by loading an image from an input stream.
The file format is detected automatically.
If NULL is returned, then error will be set.
The cancellable can be used to abort the operation from another thread.
If the operation was cancelled, the error G_IO_ERROR_CANCELLED will be
returned. Other possible errors are in the GDK_PIXBUF_ERROR and
G_IO_ERROR domains.
The stream is not closed.
a GInputStream to load the pixbuf from
optional GCancellable object, NULL to ignore
Creates a new pixbuf by asynchronously loading an image from an input stream.
For more details see gdk_pixbuf_new_from_stream(), which is the synchronous version of this function.
When the operation is finished, callback will be called in the main thread.
You can then call gdk_pixbuf_new_from_stream_finish() to get the result of
the operation.
a GInputStream from which to load the pixbuf
optional GCancellable object, NULL to ignore
a GAsyncReadyCallback to call when the pixbuf is loaded
Creates a new pixbuf by loading an image from an input stream.
The file format is detected automatically. If NULL is returned, then
error will be set. The cancellable can be used to abort the operation
from another thread. If the operation was cancelled, the error
G_IO_ERROR_CANCELLED will be returned. Other possible errors are in
the GDK_PIXBUF_ERROR and G_IO_ERROR domains.
The image will be scaled to fit in the requested size, optionally preserving the image's aspect ratio.
When preserving the aspect ratio, a width of -1 will cause the image to be
scaled to the exact given height, and a height of -1 will cause the image
to be scaled to the exact given width. If both width and height are
given, this function will behave as if the smaller of the two values
is passed as -1.
When not preserving aspect ratio, a width or height of -1 means to not
scale the image at all in that dimension.
The stream is not closed.
a GInputStream to load the pixbuf from
The width the image should have or -1 to not constrain the width
The height the image should have or -1 to not constrain the height
TRUE to preserve the image's aspect ratio
optional GCancellable object, NULL to ignore
Creates a new pixbuf by asynchronously loading an image from an input stream.
For more details see gdk_pixbuf_new_from_stream_at_scale(), which is the synchronous version of this function.
When the operation is finished, callback will be called in the main thread.
You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
a GInputStream from which to load the pixbuf
the width the image should have or -1 to not constrain the width
the height the image should have or -1 to not constrain the height
TRUE to preserve the image's aspect ratio
optional GCancellable object, NULL to ignore
a GAsyncReadyCallback to call when the pixbuf is loaded
Finishes an asynchronous pixbuf creation operation started with gdk_pixbuf_new_from_stream_async().
a GAsyncResult
Creates a new pixbuf by parsing XPM data in memory.
This data is commonly the result of including an XPM file into a program's C source.
Pointer to inline XPM data.
Creates a new instance of a #GObject subtype and sets its properties.
Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.
the type id of the #GObject subtype to instantiate
an array of #GParameter
Finishes an asynchronous pixbuf save operation started with gdk_pixbuf_save_to_stream_async().
a GAsyncResult
A pixel buffer.
GdkPixbufcontains information about an image's pixel data, its color space, bits per sample, width and height, and the rowstride (the number of bytes between the start of one row and the start of the next).Creating new
GdkPixbufThe most basic way to create a pixbuf is to wrap an existing pixel buffer with a [class
GdkPixbuf.Pixbuf] instance. You can use the [ctorGdkPixbuf.Pixbuf.new_from_data] function to do this.Every time you create a new
GdkPixbufinstance for some data, you will need to specify the destroy notification function that will be called when the data buffer needs to be freed; this will happen when aGdkPixbufis finalized by the reference counting functions. If you have a chunk of static data compiled into your application, you can pass inNULLas the destroy notification function so that the data will not be freed.The [
ctorGdkPixbuf.Pixbuf.new] constructor function can be used as a convenience to create a pixbuf with an empty buffer; this is equivalent to allocating a data buffer usingmalloc()and then wrapping it withgdk_pixbuf_new_from_data(). Thegdk_pixbuf_new()function will compute an optimal rowstride so that rendering can be performed with an efficient algorithm.As a special case, you can use the [
ctorGdkPixbuf.Pixbuf.new_from_xpm_data] function to create a pixbuf from inline XPM image data.You can also copy an existing pixbuf with the [method
Pixbuf.copy] function. This is not the same as just acquiring a reference to the old pixbuf instance: the copy function will actually duplicate the pixel data in memory and create a new [classPixbuf]instance for it.Reference counting
GdkPixbufstructures are reference counted. This means that an application can share a single pixbuf among many parts of the code. When a piece of the program needs to use a pixbuf, it should acquire a reference to it by callingg_object_ref(); when it no longer needs the pixbuf, it should release the reference it acquired by callingg_object_unref(). The resources associated with aGdkPixbufwill be freed when its reference count drops to zero. Newly-createdGdkPixbufinstances start with a reference count of one.Image Data
Image data in a pixbuf is stored in memory in an uncompressed, packed format. Rows in the image are stored top to bottom, and in each row pixels are stored from left to right.
There may be padding at the end of a row.
The "rowstride" value of a pixbuf, as returned by [
methodGdkPixbuf.Pixbuf.get_rowstride], indicates the number of bytes between rows.NOTE: If you are copying raw pixbuf data with
memcpy()note that the last row in the pixbuf may not be as wide as the full rowstride, but rather just as wide as the pixel data needs to be; that is: it is unsafe to domemcpy (dest, pixels, rowstride * height)to copy a whole pixbuf. Use [methodGdkPixbuf.Pixbuf.copy] instead, or compute the width in bytes of the last row as:The same rule applies when iterating over each row of a
GdkPixbufpixels array.The following code illustrates a simple
put_pixel()function for RGB pixbufs with 8 bits per channel with an alpha channel.Loading images
The
GdkPixBufclass provides a simple mechanism for loading an image from a file in synchronous and asynchronous fashion.For GUI applications, it is recommended to use the asynchronous stream API to avoid blocking the control flow of the application.
Additionally,
GdkPixbufprovides the [classGdkPixbuf.PixbufLoader`] API for progressive image loading.Saving images
The
GdkPixbufclass provides methods for saving image data in a number of file formats. The formatted data can be written to a file or to a memory buffer.GdkPixbufcan also call a user-defined callback on the data, which allows to e.g. write the image to a socket or store it in a database.