// Generated by gmmproc 2.84.0 -- DO NOT MODIFY! #ifndef _GDKMM_PIXBUF_H #define _GDKMM_PIXBUF_H #include #include #include /* Copyright (C) 1998-2002 The gtkmm Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, see . */ // This is for including the config header before any code (such as // the #ifndef GDKMM_DISABLE_DEPRECATED in deprecated classes) is generated: #include #include #include #include #include #include #include #ifndef DOXYGEN_SHOULD_SKIP_THIS using GdkPixbuf = struct _GdkPixbuf; using GdkPixbufClass = struct _GdkPixbufClass; #endif /* DOXYGEN_SHOULD_SKIP_THIS */ #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace Gdk { class GDKMM_API Pixbuf_Class; } // namespace Gdk #endif //DOXYGEN_SHOULD_SKIP_THIS namespace Gdk { /** @addtogroup gdkmmEnums gdkmm Enums and Flags */ /** * @var Colorspace::RGB * Indicates a red/green/blue additive color space. */ /** This enumeration defines the color spaces that are supported by * the gdk-pixbuf library. * * Currently only RGB is supported. * * @ingroup gdkmmEnums */ enum class Colorspace { RGB }; } // namespace Gdk #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace Glib { template <> class GDKMM_API Value : public Glib::Value_Enum { public: static GType value_type() G_GNUC_CONST; }; } // namespace Glib #endif /* DOXYGEN_SHOULD_SKIP_THIS */ namespace Gdk { /** * @var InterpType::NEAREST * Nearest neighbor sampling; this is the fastest * and lowest quality mode. Quality is normally unacceptable when scaling * down, but may be OK when scaling up. * * @var InterpType::TILES * This is an accurate simulation of the PostScript * image operator without any interpolation enabled. Each pixel is * rendered as a tiny parallelogram of solid color, the edges of which * are implemented with antialiasing. It resembles nearest neighbor for * enlargement, and bilinear for reduction. * * @var InterpType::BILINEAR * Best quality/speed balance; use this mode by * default. Bilinear interpolation. For enlargement, it is * equivalent to point-sampling the ideal bilinear-interpolated image. * For reduction, it is equivalent to laying down small tiles and * integrating over the coverage area. * * @var InterpType::HYPER * This is the slowest and highest quality * reconstruction function. It is derived from the hyperbolic filters in * Wolberg's "Digital Image Warping", and is formally defined as the * hyperbolic-filter sampling the ideal hyperbolic-filter interpolated * image (the filter is designed to be idempotent for 1:1 pixel mapping). * **Deprecated**: this interpolation filter is deprecated, as in reality * it has a lower quality than the @a GDK_INTERP_BILINEAR filter * (Since: 2.38). */ /** Interpolation modes for scaling functions. * * The `Gdk::InterpType::NEAREST` mode is the fastest scaling method, but has * horrible quality when scaling down; `Gdk::InterpType::BILINEAR` is the best * choice if you aren't sure what to choose, it has a good speed/quality * balance. * * **Note**: Cubic filtering is missing from the list; hyperbolic * interpolation is just as fast and results in higher quality. * * @ingroup gdkmmEnums */ enum class InterpType { NEAREST, TILES, BILINEAR, HYPER }; } // namespace Gdk #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace Glib { template <> class GDKMM_API Value : public Glib::Value_Enum { public: static GType value_type() G_GNUC_CONST; }; } // namespace Glib #endif /* DOXYGEN_SHOULD_SKIP_THIS */ namespace Gdk { /** %Exception class for Gdk::Pixbuf errors. */ class PixbufError : public Glib::Error { public: /** @var Code CORRUPT_IMAGE * An image file was broken somehow. * * @var Code INSUFFICIENT_MEMORY * Not enough memory. * * @var Code BAD_OPTION * A bad option was passed to a pixbuf save module. * * @var Code UNKNOWN_TYPE * Unknown image type. * * @var Code UNSUPPORTED_OPERATION * Don't know how to perform the * given operation on the type of image at hand. * * @var Code FAILED * Generic failure code, something went wrong. * * @var Code INCOMPLETE_ANIMATION * Only part of the animation was loaded. */ /** An error code in the `GDK_PIXBUF_ERROR` domain. * * Many gdk-pixbuf operations can cause errors in this domain, or in * the `G_FILE_ERROR` domain. */ enum Code { CORRUPT_IMAGE, INSUFFICIENT_MEMORY, BAD_OPTION, UNKNOWN_TYPE, UNSUPPORTED_OPERATION, FAILED, INCOMPLETE_ANIMATION }; GDKMM_API PixbufError(Code error_code, const Glib::ustring& error_message); GDKMM_API explicit PixbufError(GError* gobject); GDKMM_API Code code() const; #ifndef DOXYGEN_SHOULD_SKIP_THIS private: GDKMM_API static void throw_func(GError* gobject); friend GDKMM_API void wrap_init(); // uses throw_func() #endif //DOXYGEN_SHOULD_SKIP_THIS }; } // namespace Gdk #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace Glib { template <> class GDKMM_API Value : public Glib::Value_Enum { public: static GType value_type() G_GNUC_CONST; }; } // namespace Glib #endif /* DOXYGEN_SHOULD_SKIP_THIS */ namespace Gdk { /** A pixel buffer. * * `%Gdk::Pixbuf` contains 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 Gdk::Pixbuf * * The most basic way to create a pixbuf is to wrap an existing pixel * buffer with a %Gdk::Pixbuf instance. You can use the * create_from_data() function to do this. * * When you create a new `%Gdk::Pixbuf` instance for some data, you * can specify a callback slot that will be * called when the data buffer needs to be freed; this will happen when * a `%Gdk::Pixbuf` is finalized by the reference counting functions. If * you have a chunk of static data compiled into your application, you * can call the create_from_data() overload without a slot parameter * so that the data will not be freed. * * The create(Colorspace colorspace, bool has_alpha, int bits_per_sample, * int width, int height) constructor function can be used * as a convenience to create a pixbuf with an empty buffer; this is * equivalent to allocating a data buffer and then * wrapping it with create_from_data(). The create(Colorspace colorspace, * bool has_alpha, int bits_per_sample, int width, int height) * function will compute an optimal rowstride so that rendering can be * performed with an efficient algorithm. * * As a special case, you can use the create_from_xpm_data() * function (deprecated) to create a pixbuf from inline XPM image data. * * You can also copy an existing pixbuf with the 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 pixbuf instance for it. * * ## 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 get_rowstride(), * indicates the number of bytes between rows. * * **NOTE**: If you are copying raw pixbuf data, 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 * copy rowstride * height bytes to copy a whole pixbuf. Use * copy() instead. * * The same rule applies when iterating over each row of a `%Gdk::Pixbuf` pixels * array. * * ## Loading images * * The `%Gdk::PixBuf` class provides a simple mechanism for loading * an image from a file. * * Additionally, there is the Gdk::PixbufLoader API for progressive image loading. * * ## Saving images * * The `%Gdk::Pixbuf` class 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. */ class GDKMM_API Pixbuf : public Glib::Object, public Gio::Icon, public Gio::LoadableIcon { #ifndef DOXYGEN_SHOULD_SKIP_THIS public: using CppObjectType = Pixbuf; using CppClassType = Pixbuf_Class; using BaseObjectType = GdkPixbuf; using BaseClassType = GdkPixbufClass; // noncopyable Pixbuf(const Pixbuf&) = delete; Pixbuf& operator=(const Pixbuf&) = delete; private: friend class Pixbuf_Class; static CppClassType pixbuf_class_; protected: explicit Pixbuf(const Glib::ConstructParams& construct_params); explicit Pixbuf(GdkPixbuf* castitem); #endif /* DOXYGEN_SHOULD_SKIP_THIS */ public: Pixbuf(Pixbuf&& src) noexcept; Pixbuf& operator=(Pixbuf&& src) noexcept; ~Pixbuf() noexcept override; /** Get the GType for this class, for use with the underlying GObject type system. */ static GType get_type() G_GNUC_CONST; #ifndef DOXYGEN_SHOULD_SKIP_THIS static GType get_base_type() G_GNUC_CONST; #endif ///Provides access to the underlying C GObject. GdkPixbuf* gobj() { return reinterpret_cast(gobject_); } ///Provides access to the underlying C GObject. const GdkPixbuf* gobj() const { return reinterpret_cast(gobject_); } ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs. GdkPixbuf* gobj_copy(); private: protected: #ifndef GDKMM_DISABLE_DEPRECATED /** Transfers image data from a Cairo::Surface and converts it to an RGB(A) * representation inside a Gdk::Pixbuf. This allows you to efficiently read * individual pixels from cairo surfaces. * * This will create an RGB pixbuf with 8 bits per channel. * The pixbuf will contain an alpha channel if the surface contains one. * * @param src Surface to copy from. * @param src_x Source X coordinate within the surface. * @param src_y Source Y coordinate within the surface. * @param width Width in pixels of region to get. * @param height Height in pixels of region to get. * * @throw Gdk::PixbufError * * @deprecated 4.12: Use Gdk::Texture and subclasses instead of * cairo surfaces and pixbufs. */ Pixbuf(const ::Cairo::RefPtr< ::Cairo::Surface>& src, int src_x, int src_y, int width, int height); #endif // GDKMM_DISABLE_DEPRECATED public: // Used only internally in gdk-pixbuf: _WRAP_ENUM(AlphaMode, GdkPixbufAlphaMode) /** * @var Rotation::NONE * No rotation. * * @var Rotation::COUNTERCLOCKWISE * Rotate by 90 degrees. * * @var Rotation::UPSIDEDOWN * Rotate by 180 degrees. * * @var Rotation::CLOCKWISE * Rotate by 270 degrees. */ /** The possible rotations which can be passed to Gdk::Pixbuf::rotate_simple(). * * To make them easier to use, their numerical values are the actual degrees. * * @ingroup gdkmmEnums */ enum class Rotation { NONE = 0, COUNTERCLOCKWISE = 90, UPSIDEDOWN = 180, CLOCKWISE = 270 }; using SlotDestroyData = sigc::slot; #ifndef GDKMM_DISABLE_DEPRECATED /** Transfers image data from a Cairo::Surface and converts it to an RGB(A) * representation inside a Gdk::Pixbuf. This allows you to efficiently read * individual pixels from cairo surfaces. * * This will create an RGB pixbuf with 8 bits per channel. * The pixbuf will contain an alpha channel if the surface contains one. * * @param src Surface to copy from. * @param src_x Source X coordinate within the surface. * @param src_y Source Y coordinate within the surface. * @param width Width in pixels of region to get. * @param height Height in pixels of region to get. * * @throw Gdk::PixbufError * * @deprecated 4.12: Use Gdk::Texture and subclasses instead of * cairo surfaces and pixbufs. */ static Glib::RefPtr create(const ::Cairo::RefPtr< ::Cairo::Surface>& src, int src_x, int src_y, int width, int height); #endif // GDKMM_DISABLE_DEPRECATED /** Creates a new `Gdk::Pixbuf` with a copy of the information in the specified * `pixbuf`. * * Note that this does not copy the options set on the original `Gdk::Pixbuf`, * use copy_options() for this. * * @return A newly-created pixbuf. */ Glib::RefPtr copy() const; /** Creates a new `Gdk::Pixbuf` structure and allocates a buffer for it. * * If the allocation of the buffer failed, this function will return nullptr. * * The buffer has an optimal rowstride. Note that the buffer is not cleared; * you will have to fill it completely yourself. * * @param colorspace Color space for image. * @param has_alpha Whether the image should have transparency information. * @param bits_per_sample Number of bits per color sample. * @param width Width of image in pixels, must be > 0. * @param height Height of image in pixels, must be > 0. * @return A newly-created pixel buffer. */ static Glib::RefPtr create(Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height); /** 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. * * @param src_pixbuf A `Gdk::Pixbuf`. * @param src_x X coord in @a src_pixbuf. * @param src_y Y coord in @a src_pixbuf. * @param width Width of region in @a src_pixbuf. * @param height Height of region in @a src_pixbuf. * @return A new pixbuf. */ static Glib::RefPtr create_subpixbuf(const Glib::RefPtr& src_pixbuf, int src_x, int src_y, int width, int height); /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically. * @param filename The path to the pixbuf file. * * @throw Glib::FileError * @throw Gdk::PixbufError */ static Glib::RefPtr create_from_file(const std::string& filename); /** Creates a new pixbuf by loading an image from a file. The file format is detected automatically. * The image will be scaled to fit in the requested size. * @param filename The path to the pixbuf file. * @param width The desired width * @param height The desired height * @param preserve_aspect_ratio Whether the image's aspect ratio will be preserved when scaling. * * @throw Glib::FileError * @throw Gdk::PixbufError */ static Glib::RefPtr create_from_file(const std::string& filename, int width, int height, bool preserve_aspect_ratio = true); //gdk_pixbuf_new_from_file_at_size() just calls gdk_pixbuf_new_from_file_at_scale(). /** Creates a new pixbuf by loading an image from a resource. The file format is detected automatically. * @param resource_path The path of the resource file. * * @throw Gio::ResourceError * @throw Gdk::PixbufError * * @newin{3,12} */ static Glib::RefPtr create_from_resource(const std::string& resource_path); /** Creates a new pixbuf by loading an image from a resource. The file format is detected automatically. * The image will be scaled to fit in the requested size, optionally * preserving the image's aspect ratio. When preserving the aspect ratio, * a @a width of -1 will cause the image to be scaled to the exact given * height, and a @a height of -1 will cause the image to be scaled to the * exact given width. When not preserving aspect ratio, a @a width or * @a height of -1 means to not scale the image at all in that dimension. * @param resource_path The path of the resource file. * @param width The desired width * @param height The desired height * @param preserve_aspect_ratio Whether the image's aspect ratio will be preserved when scaling. * * @throw Gio::ResourceError * @throw Gdk::PixbufError * * @newin{3,12} */ static Glib::RefPtr create_from_resource(const std::string& resource_path, int width, int height, bool preserve_aspect_ratio = true); /** Creates a new Gdk::Pixbuf out of in-memory image data. * Currently only RGB images with 8 bits per sample are supported. * * @param data %Image data in 8-bit/sample packed format. * @param colorspace Colorspace for the image data. * @param has_alpha Whether the data has an opacity channel. * @param bits_per_sample Number of bits per sample. * @param width Width of the image in pixels. * @param height Height of the image in pixels. * @param rowstride Distance in bytes between rows. * @return A newly-created Gdk::Pixbuf object. */ static Glib::RefPtr create_from_data(const guint8* data, Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height, int rowstride); /** Creates a new Gdk::Pixbuf out of in-memory image data. * Currently only RGB images with 8 bits per sample are supported. * * @param data %Image data in 8-bit/sample packed format. * @param colorspace Colorspace for the image data. * @param has_alpha Whether the data has an opacity channel. * @param bits_per_sample Number of bits per sample. * @param width Width of the image in pixels. * @param height Height of the image in pixels. * @param rowstride Distance in bytes between rows. * @param destroy_slot Slot used to free the data when the pixbuf's * reference count drops to zero. * @return A newly-created Gdk::Pixbuf object. */ static Glib::RefPtr create_from_data(const guint8* data, Colorspace colorspace, bool has_alpha, int bits_per_sample, int width, int height, int rowstride, const SlotDestroyData& destroy_slot); #ifndef GDKMM_DISABLE_DEPRECATED /** 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. * * Deprecated: 2.44: Use GdkPixbuf::Pixbuf::new_from_stream() with * a Gio::MemoryInputStream, making sure to handle errors in * case the XPM format loader is not available * * @deprecated 4.20: Use create_from_stream() with a Gio::MemoryInputStream, making sure to handle errors in case the XPM format loader is not available. * * @param data Pointer to inline XPM data. * @return A newly-created pixbuf. */ static Glib::RefPtr create_from_xpm_data(const char *const * data); #endif // GDKMM_DISABLE_DEPRECATED /** Creates a new pixbuf by loading an image from an input stream. * * The file format is detected automatically. * * If nullptr 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 `Gio::Error::CANCELLED` will be * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and * `G_IO_ERROR` domains. * * The stream is not closed. * * @newin{2,14} * * @param stream A `Gio::InputStream` to load the pixbuf from. * @param cancellable Optional `Gio::Cancellable` object, nullptr to ignore. * @return A newly-created pixbuf. * * @throws Glib::Error */ static Glib::RefPtr create_from_stream(const Glib::RefPtr& stream, const Glib::RefPtr& cancellable); static Glib::RefPtr create_from_stream(const Glib::RefPtr& stream); /** Creates a new pixbuf by loading an image from an input stream. * * The file format is detected automatically. If nullptr is returned, then * @a error will be set. The @a cancellable can be used to abort the operation * from another thread. If the operation was cancelled, the error * `Gio::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. * * @newin{2,14} * * @param stream A `Gio::InputStream` to load the pixbuf from. * @param width The width the image should have or -1 to not constrain the width. * @param height The height the image should have or -1 to not constrain the height. * @param preserve_aspect_ratio true to preserve the image's aspect ratio. * @param cancellable Optional `Gio::Cancellable` object, nullptr to ignore. * @return A newly-created pixbuf. * * @throws Glib::Error */ static Glib::RefPtr create_from_stream_at_scale(const Glib::RefPtr& stream, int width, int height, bool preserve_aspect_ratio, const Glib::RefPtr& cancellable); static Glib::RefPtr create_from_stream_at_scale(const Glib::RefPtr& stream, int width, int height, bool preserve_aspect_ratio); /** Queries the color space of a pixbuf. * * @return Color space. */ Colorspace get_colorspace() const; /** Queries the number of channels of a pixbuf. * * @return Number of channels. */ int get_n_channels() const; /** Queries whether a pixbuf has an alpha channel (opacity information). * * @return true if it has an alpha channel, false otherwise. */ bool get_has_alpha() const; /** Queries the number of bits per color sample in a pixbuf. * * @return Number of bits per color sample. */ int get_bits_per_sample() const; // Note that the const version uses gdk_pixbuf_read_pixels, not gdk_pixbuf_get_pixels(), // because gdk_pixbuf_get_pixels() is documented as sometimes copying data internally // so the caller can make changes, but a const version wouldn't ever do that. /** 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](class.Pixbuf.html#image-data) for information * about how the pixel data is stored in memory. * * @return A pointer to the pixbuf's pixel data. */ guint8* get_pixels(); /** Provides a read-only pointer to the raw pixel data. * * This function allows skipping the implicit copy that must be made * if get_pixels() is called on a read-only pixbuf. * * @newin{2,32} * * @return A read-only pointer to the raw pixel data. */ const guint8* get_pixels() const; /** 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](class.Pixbuf.html#image-data) for information * about how the pixel data is stored in memory. * * @newin{2,26} * * @param length The length of the binary data. * @return A pointer to the pixbuf's * pixel data. */ guint8* get_pixels(guint& length); // We hand-code this because there is no gdk_pixbuf_read_pixels_with_length(). const guint8* get_pixels(guint& length) const; /** Queries the width of a pixbuf. * * @return Width in pixels. */ int get_width() const; /** Queries the height of a pixbuf. * * @return Height in pixels. */ int get_height() const; /** 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. * * @return Distance between row starts. */ int get_rowstride() const; /** Returns the length of the pixel data, in bytes. * * @newin{2,26} * * @return The length of the pixel data. */ gsize get_byte_length() const; /** 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. * * @param pixel RGBA pixel to used to clear (`0xffffffff` is opaque white, * `0x00000000` transparent black). */ void fill(guint32 pixel); /** Saves pixbuf to a file in format @a type. * By default, "jpeg", "png", "ico" and "bmp" are possible file formats to * save in, but more formats may be installed. The list of all writable * formats can be determined by using get_formats() with is_writable(). * * @newin{3,6} * * @param filename The path of the file to be created. * @param type The file type. * * @throw Glib::FileError * @throw Gdk::PixbufError */ void save(const std::string& filename, const Glib::ustring& type) const; /** Saves pixbuf to a file in format @a type. * By default, "jpeg", "png", "ico" and "bmp" are possible file formats to save in, but more formats may be installed. * TThe list of all writable formats can be determined by using get_formats() with * Gdk::PixbufFormat::is_writable(). * * The @a option_keys and @a option_values, if not empty, should contain pairs of strings that modify the save parameters. * For example, "quality", "100". * * Currently only a few parameters exist. JPEG images can be saved with a "quality" parameter; * its value should be in the range [0,100]. Text chunks can be attached to PNG images by specifying parameters of the * form "tEXt::key", where key is an ASCII string of length 1-79. The values are UTF-8 encoded strings. ICO images can be * saved in depth 16, 24, or 32, by using the "depth" parameter. When the ICO saver is given "x_hot" and "y_hot" * parameters, it produces a CUR instead of an ICO. * * @newin{3,6} * * @param filename The path of the file to be created. * @param type The file type. * @param option_keys * @param option_values * * @throw Glib::FileError * @throw Gdk::PixbufError */ void save(const std::string& filename, const Glib::ustring& type, const std::vector& option_keys, const std::vector& option_values) const; #if 0 //TODO: typedef sigc::slot SlotSave; /** @throws TODO */ void save(const SlotSave& slot, const std::string& type); /** A map of option keys to option values. */ typepdef std::map SaveValuesMap; void save(const SlotSave& slot, const std::string& type, const SaveValuesMap& options); #endif /* TODO: typedef gboolean (*GdkPixbufSaveFunc) (const gchar *buf, gsize count, GError **error, gpointer data); gboolean gdk_pixbuf_save_to_callback (GdkPixbuf *pixbuf, GdkPixbufSaveFunc save_func, gpointer user_data, const char *type, GError **error, ...); gboolean gdk_pixbuf_save_to_callbackv (GdkPixbuf *pixbuf, GdkPixbufSaveFunc save_func, gpointer user_data, const char *type, char **option_keys, char **option_values, GError **error); */ /** Saves the pixbuf to a new buffer in format @a type. * Note that the buffer is not nul-terminated and may contain embedded nulls. * @see save(). * * @newin{3,6} * * @param buffer This will be set to the address of a new buffer. * @param buffer_size This will be set to the size of the @a buffer. * @param type Currently "jpeg", "png", "ico" or "bmp". * * @throw Glib::FileError * @throw Gdk::PixbufError */ void save_to_buffer(gchar*& buffer, gsize& buffer_size, const Glib::ustring& type = "png") const; /** Saves the pixbuf to a new buffer in format @a type. * Note that the buffer is not nul-terminated and may contain embedded nulls. * @see save(). * * @newin{3,6} * * @param buffer This will be set to the address of a new buffer. * @param buffer_size This will be set to the size of the @a buffer. * @param type Currently "jpeg", "png", "ico" or "bmp". * @param option_keys Names of options to set. * @param option_values Values for named options. * * @throw Glib::FileError * @throw Gdk::PixbufError */ void save_to_buffer(gchar*& buffer, gsize& buffer_size, const Glib::ustring& type, const std::vector& option_keys, const std::vector& option_values) const; /** 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. * * @param substitute_color Whether to set a color to zero opacity. * @param r Red value to substitute. * @param g Green value to substitute. * @param b Blue value to substitute. * @return A newly-created pixbuf. */ Glib::RefPtr add_alpha(bool substitute_color, guint8 r, guint8 g, guint8 b) const; /** 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. * * @param src_x Source X coordinate within @a src_pixbuf. * @param src_y Source Y coordinate within @a src_pixbuf. * @param width Width of the area to copy. * @param height Height of the area to copy. * @param dest_pixbuf Destination pixbuf. * @param dest_x X coordinate within @a dest_pixbuf. * @param dest_y Y coordinate within @a dest_pixbuf. */ void copy_area(int src_x, int src_y, int width, int height, const Glib::RefPtr& dest_pixbuf, int dest_x, int dest_y) const; /** 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. * * @param dest Place to write modified version of @a src. * @param saturation Saturation factor. * @param pixelate Whether to pixelate. */ void saturate_and_pixelate(const Glib::RefPtr& dest, float saturation, bool pixelate) const; /** Creates a transformation of the source image @a src by scaling by * @a scale_x and @a scale_y then translating by @a offset_x and @a offset_y, * then renders the rectangle ( @a dest_x, @a dest_y, @a dest_width, * @a dest_height) of the resulting image onto the destination image * replacing the previous contents. * * Try to use scale_simple() first; this function is * the industrial-strength power tool you can fall back to, if * 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. * * @param dest The Gdk::Pixbuf into which to render the results. * @param dest_x The left coordinate for region to render. * @param dest_y The top coordinate for region to render. * @param dest_width The width of the region to render. * @param dest_height The height of the region to render. * @param offset_x The offset in the X direction (currently rounded to an integer). * @param offset_y The offset in the Y direction (currently rounded to an integer). * @param scale_x The scale factor in the X direction. * @param scale_y The scale factor in the Y direction. * @param interp_type The interpolation type for the transformation. */ void scale(const Glib::RefPtr& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type) const; /** Creates a transformation of the source image @a src by scaling by * @a scale_x and @a scale_y then translating by @a offset_x and @a offset_y. * * This gives an image in the coordinates of the destination pixbuf. * The rectangle ( @a dest_x, @a dest_y, @a dest_width, @a 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. * * ![](composite.png) * * @param dest The Gdk::Pixbuf into which to render the results. * @param dest_x The left coordinate for region to render. * @param dest_y The top coordinate for region to render. * @param dest_width The width of the region to render. * @param dest_height The height of the region to render. * @param offset_x The offset in the X direction (currently rounded to an integer). * @param offset_y The offset in the Y direction (currently rounded to an integer). * @param scale_x The scale factor in the X direction. * @param scale_y The scale factor in the Y direction. * @param interp_type The interpolation type for the transformation. * @param overall_alpha Overall alpha for source image (0..255). */ void composite(const Glib::RefPtr& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha) const; /** Creates a transformation of the source image @a src by scaling by * @a scale_x and @a scale_y then translating by @a offset_x and @a offset_y, * then alpha blends the rectangle ( @a dest_x , @a dest_y, @a dest_width, * @a dest_height) of the resulting image with a checkboard of the * colors @a color1 and @a color2 and renders it onto the destination * image. * * If the source image has no alpha channel, and @a overall_alpha is 255, a fast * path is used which omits the alpha blending and just performs the scaling. * * See composite_color_simple() for a simpler variant of this * function suitable for many tasks. * * @param dest The Gdk::Pixbuf into which to render the results. * @param dest_x The left coordinate for region to render. * @param dest_y The top coordinate for region to render. * @param dest_width The width of the region to render. * @param dest_height The height of the region to render. * @param offset_x The offset in the X direction (currently rounded to an integer). * @param offset_y The offset in the Y direction (currently rounded to an integer). * @param scale_x The scale factor in the X direction. * @param scale_y The scale factor in the Y direction. * @param interp_type The interpolation type for the transformation. * @param overall_alpha Overall alpha for source image (0..255). * @param check_x The X offset for the checkboard (origin of checkboard is at - @a check_x, - @a check_y). * @param check_y The Y offset for the checkboard. * @param check_size The size of checks in the checkboard (must be a power of two). * @param color1 The color of check at upper left. * @param color2 The color of the other check. */ void composite_color(const Glib::RefPtr& dest, int dest_x, int dest_y, int dest_width, int dest_height, double offset_x, double offset_y, double scale_x, double scale_y, InterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, guint32 color1, guint32 color2) const; /** 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::InterpType::NEAREST` if you want maximum * speed (but when scaling down `Gdk::InterpType::NEAREST` is usually unusably * ugly). The default `interp_type` should be `Gdk::InterpType::BILINEAR` which * offers reasonable quality and speed. * * You can scale a sub-portion of `src` by creating a sub-pixbuf * pointing into `src`; see GdkPixbuf::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 GdkPixbuf::Pixbuf::scale() * and GdkPixbuf::Pixbuf::composite(). * * @param dest_width The width of destination image. * @param dest_height The height of destination image. * @param interp_type The interpolation type for the transformation. * @return The new pixbuf. */ Glib::RefPtr scale_simple(int dest_width, int dest_height, InterpType interp_type) const; /** 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`. * * @param dest_width The width of destination image. * @param dest_height The height of destination image. * @param interp_type The interpolation type for the transformation. * @param overall_alpha Overall alpha for source image (0..255). * @param check_size The size of checks in the checkboard (must be a power of two). * @param color1 The color of check at upper left. * @param color2 The color of the other check. * @return The new pixbuf. */ Glib::RefPtr composite_color_simple(int dest_width, int dest_height, InterpType interp_type, int overall_alpha, int check_size, guint32 color1, guint32 color2) const; /** 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`. * * @newin{2,6} * * @param angle The angle to rotate by. * @return The new pixbuf. */ Glib::RefPtr rotate_simple(Rotation angle) const; /** Flips a pixbuf horizontally or vertically and returns the * result in a new pixbuf. * * @newin{2,6} * * @param horizontal true to flip horizontally, false to flip vertically. * @return The new pixbuf. */ Glib::RefPtr flip(bool horizontal = true) const; /** Looks up @a key in the list of options that may have been attached to the * @a pixbuf when it was loaded, or that may have been attached by another * function using 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. * * @param key A nul-terminated string. * @return The value associated with `key`. */ Glib::ustring get_option(const Glib::ustring& key) const; /** Attaches a key/value pair as an option to a `Gdk::Pixbuf`. * * If `key` already exists in the list of options attached to the `pixbuf`, * the new value is ignored and false is returned. * * @newin{2,2} * * @param key A nul-terminated string. * @param value A nul-terminated string. * @return true on success. */ bool set_option(const Glib::ustring& key, const Glib::ustring& value); /** Removes the key/value pair option attached to a `Gdk::Pixbuf`. * * @newin{2,36} * * @param key A nul-terminated string representing the key to remove. * @return true if an option was removed, false if not. */ bool remove_option(const Glib::ustring& key); /** Copies the key/value pair options attached to a `Gdk::Pixbuf` to another * `Gdk::Pixbuf`. * * 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. * * @newin{2,36} * * @param dest_pixbuf The destination pixbuf. * @return true on success. */ bool copy_options(const Glib::RefPtr& dest_pixbuf) const; //This creates a new GdkPixbuf or returns the original with a reference. /** 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. * * Return: (transfer full) (nullable): A newly-created pixbuf * * @newin{2,12} */ Glib::RefPtr apply_embedded_orientation(); /** Obtains the available information about the image formats supported by GdkPixbuf. * @result A list of PixbufFormats describing the supported image formats. */ static std::vector get_formats(); /** The color space of the pixbuf. * * Currently, only `Gdk::Colorspace::RGB` is supported. * * Default value: Gdk::Colorspace::RGB * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< Colorspace > property_colorspace() const; /** The number of samples per pixel. * * Currently, only 3 or 4 samples per pixel are supported. * * Default value: 3 * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< int > property_n_channels() const; /** Whether the pixbuf has an alpha channel. * * Default value: false * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< bool > property_has_alpha() const; /** The number of bits per sample. * * Currently only 8 bit per sample are supported. * * Default value: 8 * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< int > property_bits_per_sample() const; /** The number of columns of the pixbuf. * * Default value: 1 * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< int > property_width() const; /** The number of rows of the pixbuf. * * Default value: 1 * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< int > property_height() const; /** 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. * * Default value: 1 * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< int > property_rowstride() const; /** A pointer to the pixel data of the pixbuf. * * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, * or receive notification when the value of the property changes. */ Glib::PropertyProxy_ReadOnly< void* > property_pixels() const; public: public: //C++ methods used to invoke GTK+ virtual functions: protected: //GTK+ Virtual Functions (override these to change behaviour): //Default Signal Handlers:: }; } // namespace Gdk #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace Glib { template <> class GDKMM_API Value : public Glib::Value_Enum { public: static GType value_type() G_GNUC_CONST; }; } // namespace Glib #endif /* DOXYGEN_SHOULD_SKIP_THIS */ namespace Glib { /** A Glib::wrap() method for this object. * * @param object The C instance. * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref. * @result A C++ instance that wraps this C instance. * * @relates Gdk::Pixbuf */ GDKMM_API Glib::RefPtr wrap(GdkPixbuf* object, bool take_copy = false); } #endif /* _GDKMM_PIXBUF_H */