// Generated by gmmproc 2.66.7 -- 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, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ // 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 #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 { class GDKMM_API Window; /** @addtogroup gdkmmEnums gdkmm Enums and Flags */ /** * @var Colorspace COLORSPACE_RGB * Indicates a red/green/blue additive color space. * * @enum Colorspace * * This enumeration defines the color spaces that are supported by * the gdk-pixbuf library. Currently only RGB is supported. * * @ingroup gdkmmEnums */ enum Colorspace { 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 INTERP_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 INTERP_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 INTERP_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 INTERP_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). * * @enum InterpType * * This enumeration describes the different interpolation modes that * can be used with the scaling functions. @a GDK_INTERP_NEAREST is * the fastest scaling method, but has horrible quality when * scaling down. @a GDK_INTERP_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 InterpType { INTERP_NEAREST, INTERP_TILES, INTERP_BILINEAR, INTERP_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 { /** * @var PixbufAlphaMode PIXBUF_ALPHA_BILEVEL * A bilevel clipping mask (black and white) * will be created and used to draw the image. Pixels below 0.5 opacity * will be considered fully transparent, and all others will be * considered fully opaque. * * @var PixbufAlphaMode PIXBUF_ALPHA_FULL * For now falls back to Gdk::PIXBUF_ALPHA_BILEVEL. * In the future it will do full alpha compositing. * * @enum PixbufAlphaMode * * These values can be passed to * gdk_pixbuf_xlib_render_to_drawable_alpha() to control how the alpha * channel of an image should be handled. This function can create a * bilevel clipping mask (black and white) and use it while painting * the image. In the future, when the X %Window System gets an alpha * channel extension, it will be possible to do full alpha * compositing onto arbitrary drawables. For now both cases fall * back to a bilevel clipping mask. * * @ingroup gdkmmEnums */ enum PixbufAlphaMode { PIXBUF_ALPHA_BILEVEL, PIXBUF_ALPHA_FULL }; } // 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 PixbufRotation PIXBUF_ROTATE_NONE * No rotation. * * @var PixbufRotation PIXBUF_ROTATE_COUNTERCLOCKWISE * Rotate by 90 degrees. * * @var PixbufRotation PIXBUF_ROTATE_UPSIDEDOWN * Rotate by 180 degrees. * * @var PixbufRotation PIXBUF_ROTATE_CLOCKWISE * Rotate by 270 degrees. * * @enum PixbufRotation * * 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 PixbufRotation { PIXBUF_ROTATE_NONE = 0, PIXBUF_ROTATE_COUNTERCLOCKWISE = 90, PIXBUF_ROTATE_UPSIDEDOWN = 180, PIXBUF_ROTATE_CLOCKWISE = 270 }; } // 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 GDKMM_API 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. * * @enum Code * * 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 }; PixbufError(Code error_code, const Glib::ustring& error_message); explicit PixbufError(GError* gobject); Code code() const; #ifndef DOXYGEN_SHOULD_SKIP_THIS private: 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 { class GDKMM_API Pixbuf : public Glib::Object, public Gio::Icon { #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: //TODO: Throw an exception when the C function returns NULL? /** Transfers image data from a #GdkWindow and converts it to an RGB(A) * representation inside a Gdk::Pixbuf. In other words, copies * image data from a server-side drawable to a client-side RGB(A) buffer. * This allows you to efficiently read individual pixels on the client side. * * This function will create an RGB pixbuf with 8 bits per channel with * the same size specified by the @a width and @a height arguments. The pixbuf * will contain an alpha channel if the @a window contains one. * * If the window is off the screen, then there is no image data in the * obscured/offscreen regions to be placed in the pixbuf. The contents of * portions of the pixbuf corresponding to the offscreen region are undefined. * * If the window you're obtaining data from is partially obscured by * other windows, then the contents of the pixbuf areas corresponding * to the obscured regions are undefined. * * If the window is not mapped (typically because it's iconified/minimized * or not on the current workspace), then an invalid object will be returned. * * If memory can't be allocated for the return value, an invalid object will be returned * instead. * * @param src Source window. * @param src_x Source X coordinate within the window. * @param src_y Source Y coordinate within the window. * @param width Width in pixels of region to get. * @param height Height in pixels of region to get. * * @newin{2,12} */ Pixbuf(const Glib::RefPtr& src, int src_x, int src_y, int width, int height); /** 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. For Gdk::Windows, use the * constructor that takes a Gdk::Window instead. * * 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. * * @newin{2,30} */ Pixbuf(const ::Cairo::RefPtr< ::Cairo::Surface>& src, int src_x, int src_y, int width, int height); public: typedef sigc::slot SlotDestroyData; /** Transfers image data from a #GdkWindow and converts it to an RGB(A) * representation inside a Gdk::Pixbuf. In other words, copies * image data from a server-side drawable to a client-side RGB(A) buffer. * This allows you to efficiently read individual pixels on the client side. * * This function will create an RGB pixbuf with 8 bits per channel with * the same size specified by the @a width and @a height arguments. The pixbuf * will contain an alpha channel if the @a window contains one. * * If the window is off the screen, then there is no image data in the * obscured/offscreen regions to be placed in the pixbuf. The contents of * portions of the pixbuf corresponding to the offscreen region are undefined. * * If the window you're obtaining data from is partially obscured by * other windows, then the contents of the pixbuf areas corresponding * to the obscured regions are undefined. * * If the window is not mapped (typically because it's iconified/minimized * or not on the current workspace), then an invalid object will be returned. * * If memory can't be allocated for the return value, an invalid object will be returned * instead. * * @param src Source window. * @param src_x Source X coordinate within the window. * @param src_y Source Y coordinate within the window. * @param width Width in pixels of region to get. * @param height Height in pixels of region to get. * * @newin{2,12} */ static Glib::RefPtr create(const Glib::RefPtr& src, int src_x, int src_y, int width, int height); /** 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. For Gdk::Windows, use the * create() method that takes a Gdk::Window instead. * * 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. * * @newin{2,30} */ static Glib::RefPtr create(const ::Cairo::RefPtr< ::Cairo::Surface>& src, int src_x, int src_y, int width, int height); /** Creates a new Gdk::Pixbuf with a copy of the information in the specified * @a 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 with a reference count of 1, or nullptr if * not enough memory could be allocated. */ Glib::RefPtr copy() const; /** Creates a new Gdk::Pixbuf structure and allocates a buffer for it. 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 Gdk::Pixbuf with a reference count of 1, or * nullptr if not enough memory could be allocated for the image 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 @a 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 * @a src_pixbuf, so @a src_pixbuf will not be finalized until the new * pixbuf is finalized. * * Note that if @a 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); /** 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. * * @param data Pointer to inline XPM data. * @return A newly-created pixbuf with a reference count of 1. */ static Glib::RefPtr create_from_xpm_data(const char *const * data); #ifndef GDKMM_DISABLE_DEPRECATED /** Create a Gdk::Pixbuf 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. * * GTK+ 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 flag 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 @a copy_pixels. (If you pass --rle to * gdk-pixbuf-csource, a copy will be made even if @a 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, since things will always succeed. 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. * * @param data_length Length in bytes of the @a data argument. * @param data Byte data containing a serialized GdkPixdata structure. * @param copy_pixels Whether to copy the pixel data, or use direct pointers * to @a data for the resulting pixbuf. * @throw Gdk::PixbufError * * @deprecated Use Gio::Resource instead. */ static Glib::RefPtr create_from_inline(int data_length, const guint8* data, bool copy_pixels = false); #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 * @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::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. * * @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, or nullptr if any of several error * conditions occurred: the file could not be opened, the image format is * not supported, there was not enough memory to allocate the image buffer, * the stream contained invalid data, or the operation was cancelled. * * @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::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 @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. If both @a width and @a 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 @a width or @a 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, or nullptr if any of several error * conditions occurred: the file could not be opened, the image format is * not supported, there was not enough memory to allocate the image buffer, * the stream contained invalid data, or the operation was cancelled. * * @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; /** Queries a pointer to the pixel data of a pixbuf. * * @return A pointer to the pixbuf's pixel data. * Please see the section on [image data][image-data] for information * about how the pixel data is stored in memory. * * This function will cause an implicit copy of the pixbuf data if the * pixbuf was created from read-only data. */ guint8* get_pixels() const; //TODO: _WRAP_METHOD(guint8* get_pixels(guint& length) const, gdk_pixbuf_get_pixels_with_length) /** 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 will be ignored if the pixbuf * doesn't have an alpha channel. * * @param pixel RGBA pixel to clear to * (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; #ifndef GDKMM_DISABLE_DEPRECATED /** * Same as the const version. * @deprecated 3.6: Use the const version instead. */ void save(const std::string& filename, const Glib::ustring& type); #endif // GDKMM_DISABLE_DEPRECATED /** 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; #ifndef GDKMM_DISABLE_DEPRECATED /** * Same as the const version. * @deprecated 3.6: Use the const version instead. */ void save(const std::string& filename, const Glib::ustring& type, const std::vector& option_keys, const std::vector& option_values); #endif // GDKMM_DISABLE_DEPRECATED #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; #ifndef GDKMM_DISABLE_DEPRECATED /** * Same as the const version. * @deprecated 3.6: Use the const version instead. */ void save_to_buffer(gchar*& buffer, gsize& buffer_size, const Glib::ustring& type = "png"); #endif // GDKMM_DISABLE_DEPRECATED /** 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; #ifndef GDKMM_DISABLE_DEPRECATED /** * Same as the const version. * @deprecated 3.6: Use the const version instead. */ void save_to_buffer(gchar*& buffer, gsize& buffer_size, const Glib::ustring& type, const std::vector& option_keys, const std::vector& option_values); #endif // GDKMM_DISABLE_DEPRECATED /** 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 @a substitute_color is true, then the color specified by ( @a r, @a g, @a b) will be * assigned zero opacity. That is, if you pass (255, 255, 255) for the * substitute color, all white pixels will become fully transparent. * * @param substitute_color Whether to set a color to zero opacity. If this * is false, then the ( @a r, @a g, @a b) arguments will be ignored. * @param r Red value to substitute. * @param g Green value to substitute. * @param b Blue value to substitute. * @return A newly-created pixbuf with a reference count of 1. */ Glib::RefPtr add_alpha(bool substitute_color, guint8 r, guint8 g, guint8 b) const; /** Copies a rectangular area from @a src_pixbuf to @a 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 @a src, placing the result in * @a dest. @a src and @a dest may be the same pixbuf with no ill effects. If * @a 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 @a pixelate * is true, then pixels are faded in a checkerboard pattern to create a * pixelated image. @a src and @a dest must have the same image format, size, and * rowstride. * * @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 Gdk::Pixbuf containing a copy of @a src scaled to * @a dest_width x @a dest_height. Leaves @a src unaffected. @a 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 @a interp_type should be Gdk::INTERP_BILINEAR which offers * reasonable quality and speed. * * You can scale a sub-portion of @a src by creating a sub-pixbuf * pointing into @a src; see new_subpixbuf(). * * If @a dest_width and @a dest_height are equal to the @a src width and height, a * copy of @a src is returned, avoiding any scaling. * * For more complicated scaling/alpha blending see scale() * and 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 Gdk::Pixbuf, or nullptr if not enough memory could be * allocated for it. */ Glib::RefPtr scale_simple(int dest_width, int dest_height, InterpType interp_type) const; /** Creates a new Gdk::Pixbuf by scaling @a src to @a dest_width x * @a dest_height and alpha blending the result with a checkboard of colors * @a color1 and @a 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 Gdk::Pixbuf, or nullptr if not enough memory could be * allocated for it. */ 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 @a angle is 0, a copy of @a src is returned, avoiding any rotation. * * @newin{2,6} * * @param angle The angle to rotate by. * @return The new Gdk::Pixbuf, or nullptr * if not enough memory could be allocated for it. */ Glib::RefPtr rotate_simple(PixbufRotation 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 Gdk::Pixbuf, or nullptr * if not enough memory could be allocated for it. */ 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 @a key. This is a nul-terminated * string that should not be freed or nullptr if @a key was not found. */ Glib::ustring get_option(const Glib::ustring& key) const; /** Attaches a key/value pair as an option to a Gdk::Pixbuf. If @a key already * exists in the list of options attached to @a 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); /** Remove 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); /** Copy the key/value pair options attached to a Gdk::Pixbuf to another. * 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 Gdk::Pixbuf to copy options to. * @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, which 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. * * @newin{2,12} * * @return A newly-created pixbuf, nullptr if * not enough memory could be allocated for it, or a reference to the * input pixbuf (with an increased reference count). */ 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 colorspace in which the samples are interpreted. * * 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 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 */