#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
#![allow(
clippy::approx_constant,
clippy::type_complexity,
clippy::unreadable_literal,
clippy::upper_case_acronyms
)]
#![cfg_attr(docsrs, feature(doc_cfg))]
use babl_sys as babl;
use glib_sys as glib;
use gobject_sys as gobject;
#[allow(unused_imports)]
use libc::{
c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE,
};
#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};
pub type GeglAbyssPolicy = c_int;
pub const GEGL_ABYSS_NONE: GeglAbyssPolicy = 0;
pub const GEGL_ABYSS_CLAMP: GeglAbyssPolicy = 1;
pub const GEGL_ABYSS_LOOP: GeglAbyssPolicy = 2;
pub const GEGL_ABYSS_BLACK: GeglAbyssPolicy = 3;
pub const GEGL_ABYSS_WHITE: GeglAbyssPolicy = 4;
pub type GeglBablVariant = c_int;
pub const GEGL_BABL_VARIANT_FLOAT: GeglBablVariant = 0;
pub const GEGL_BABL_VARIANT_LINEAR: GeglBablVariant = 1;
pub const GEGL_BABL_VARIANT_NONLINEAR: GeglBablVariant = 2;
pub const GEGL_BABL_VARIANT_PERCEPTUAL: GeglBablVariant = 3;
pub const GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED: GeglBablVariant = 4;
pub const GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED: GeglBablVariant = 5;
pub const GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED_IF_ALPHA: GeglBablVariant = 6;
pub const GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED_IF_ALPHA: GeglBablVariant = 7;
pub const GEGL_BABL_VARIANT_ALPHA: GeglBablVariant = 8;
pub type GeglCachePolicy = c_int;
pub const GEGL_CACHE_POLICY_AUTO: GeglCachePolicy = 0;
pub const GEGL_CACHE_POLICY_NEVER: GeglCachePolicy = 1;
pub const GEGL_CACHE_POLICY_ALWAYS: GeglCachePolicy = 2;
pub type GeglDistanceMetric = c_int;
pub const GEGL_DISTANCE_METRIC_EUCLIDEAN: GeglDistanceMetric = 0;
pub const GEGL_DISTANCE_METRIC_MANHATTAN: GeglDistanceMetric = 1;
pub const GEGL_DISTANCE_METRIC_CHEBYSHEV: GeglDistanceMetric = 2;
pub type GeglDitherMethod = c_int;
pub const GEGL_DITHER_NONE: GeglDitherMethod = 0;
pub const GEGL_DITHER_FLOYD_STEINBERG: GeglDitherMethod = 1;
pub const GEGL_DITHER_BAYER: GeglDitherMethod = 2;
pub const GEGL_DITHER_RANDOM: GeglDitherMethod = 3;
pub const GEGL_DITHER_RANDOM_COVARIANT: GeglDitherMethod = 4;
pub const GEGL_DITHER_ARITHMETIC_ADD: GeglDitherMethod = 5;
pub const GEGL_DITHER_ARITHMETIC_ADD_COVARIANT: GeglDitherMethod = 6;
pub const GEGL_DITHER_ARITHMETIC_XOR: GeglDitherMethod = 7;
pub const GEGL_DITHER_ARITHMETIC_XOR_COVARIANT: GeglDitherMethod = 8;
pub const GEGL_DITHER_BLUE_NOISE: GeglDitherMethod = 9;
pub const GEGL_DITHER_BLUE_NOISE_COVARIANT: GeglDitherMethod = 10;
pub type GeglMapFlags = c_int;
pub const GEGL_MAP_EXCLUDE_UNMAPPED: GeglMapFlags = 1;
pub type GeglOrientation = c_int;
pub const GEGL_ORIENTATION_HORIZONTAL: GeglOrientation = 0;
pub const GEGL_ORIENTATION_VERTICAL: GeglOrientation = 1;
pub type GeglRectangleAlignment = c_int;
pub const GEGL_RECTANGLE_ALIGNMENT_SUBSET: GeglRectangleAlignment = 0;
pub const GEGL_RECTANGLE_ALIGNMENT_SUPERSET: GeglRectangleAlignment = 1;
pub const GEGL_RECTANGLE_ALIGNMENT_NEAREST: GeglRectangleAlignment = 2;
pub type GeglResolutionUnit = c_int;
pub const GEGL_RESOLUTION_UNIT_NONE: GeglResolutionUnit = 0;
pub const GEGL_RESOLUTION_UNIT_DPI: GeglResolutionUnit = 1;
pub const GEGL_RESOLUTION_UNIT_DPM: GeglResolutionUnit = 2;
pub type GeglSamplerType = c_int;
pub const GEGL_SAMPLER_NEAREST: GeglSamplerType = 0;
pub const GEGL_SAMPLER_LINEAR: GeglSamplerType = 1;
pub const GEGL_SAMPLER_CUBIC: GeglSamplerType = 2;
pub const GEGL_SAMPLER_NOHALO: GeglSamplerType = 3;
pub const GEGL_SAMPLER_LOHALO: GeglSamplerType = 4;
pub type GeglSplitStrategy = c_int;
pub const GEGL_SPLIT_STRATEGY_AUTO: GeglSplitStrategy = 0;
pub const GEGL_SPLIT_STRATEGY_HORIZONTAL: GeglSplitStrategy = 1;
pub const GEGL_SPLIT_STRATEGY_VERTICAL: GeglSplitStrategy = 2;
pub type GeglTileCommand = c_int;
pub const GEGL_TILE_IDLE: GeglTileCommand = 0;
pub const GEGL_TILE_SET: GeglTileCommand = 1;
pub const GEGL_TILE_GET: GeglTileCommand = 2;
pub const GEGL_TILE_IS_CACHED: GeglTileCommand = 3;
pub const GEGL_TILE_EXIST: GeglTileCommand = 4;
pub const GEGL_TILE_VOID: GeglTileCommand = 5;
pub const GEGL_TILE_FLUSH: GeglTileCommand = 6;
pub const GEGL_TILE_REFETCH: GeglTileCommand = 7;
pub const GEGL_TILE_REINIT: GeglTileCommand = 8;
pub const _GEGL_TILE_LAST_0_4_8_COMMAND: GeglTileCommand = 9;
pub const GEGL_TILE_COPY: GeglTileCommand = 9;
pub const GEGL_TILE_LAST_COMMAND: GeglTileCommand = 10;
pub const GEGL_AUTO_ROWSTRIDE: c_int = 0;
pub const GEGL_CH_BACK_CENTER: c_int = 256;
pub const GEGL_CH_BACK_LEFT: c_int = 16;
pub const GEGL_CH_BACK_RIGHT: c_int = 32;
pub const GEGL_CH_FRONT_CENTER: c_int = 4;
pub const GEGL_CH_FRONT_LEFT: c_int = 1;
pub const GEGL_CH_FRONT_LEFT_OF_CENTER: c_int = 64;
pub const GEGL_CH_FRONT_RIGHT: c_int = 2;
pub const GEGL_CH_FRONT_RIGHT_OF_CENTER: c_int = 128;
pub const GEGL_CH_LAYOUT_2POINT1: c_int = 11;
pub const GEGL_CH_LAYOUT_2_1: c_int = 259;
pub const GEGL_CH_LAYOUT_2_2: c_int = 1539;
pub const GEGL_CH_LAYOUT_3POINT1: c_int = 15;
pub const GEGL_CH_LAYOUT_4POINT0: c_int = 263;
pub const GEGL_CH_LAYOUT_4POINT1: c_int = 271;
pub const GEGL_CH_LAYOUT_5POINT0: c_int = 1543;
pub const GEGL_CH_LAYOUT_5POINT0_BACK: c_int = 55;
pub const GEGL_CH_LAYOUT_5POINT1: c_int = 1551;
pub const GEGL_CH_LAYOUT_5POINT1_BACK: c_int = 63;
pub const GEGL_CH_LAYOUT_6POINT0: c_int = 1799;
pub const GEGL_CH_LAYOUT_6POINT0_FRONT: c_int = 1731;
pub const GEGL_CH_LAYOUT_6POINT1: c_int = 1807;
pub const GEGL_CH_LAYOUT_6POINT1_BACK: c_int = 319;
pub const GEGL_CH_LAYOUT_6POINT1_FRONT: c_int = 1739;
pub const GEGL_CH_LAYOUT_7POINT0: c_int = 1591;
pub const GEGL_CH_LAYOUT_7POINT0_FRONT: c_int = 1735;
pub const GEGL_CH_LAYOUT_7POINT1: c_int = 1599;
pub const GEGL_CH_LAYOUT_7POINT1_WIDE: c_int = 1743;
pub const GEGL_CH_LAYOUT_7POINT1_WIDE_BACK: c_int = 255;
pub const GEGL_CH_LAYOUT_HEXADECAGONAL: c_long = 6442710839;
pub const GEGL_CH_LAYOUT_HEXAGONAL: c_int = 311;
pub const GEGL_CH_LAYOUT_NATIVE: u64 = 9223372036854775808;
pub const GEGL_CH_LAYOUT_OCTAGONAL: c_int = 1847;
pub const GEGL_CH_LAYOUT_QUAD: c_int = 51;
pub const GEGL_CH_LAYOUT_STEREO: c_int = 3;
pub const GEGL_CH_LAYOUT_STEREO_DOWNMIX: c_int = 1610612736;
pub const GEGL_CH_LAYOUT_SURROUND: c_int = 7;
pub const GEGL_CH_LOW_FREQUENCY: c_int = 8;
pub const GEGL_CH_LOW_FREQUENCY_2: c_long = 34359738368;
pub const GEGL_CH_SIDE_LEFT: c_int = 512;
pub const GEGL_CH_SIDE_RIGHT: c_int = 1024;
pub const GEGL_CH_STEREO_LEFT: c_int = 536870912;
pub const GEGL_CH_STEREO_RIGHT: c_int = 1073741824;
pub const GEGL_CH_SURROUND_DIRECT_LEFT: c_long = 8589934592;
pub const GEGL_CH_SURROUND_DIRECT_RIGHT: c_long = 17179869184;
pub const GEGL_CH_TOP_BACK_CENTER: c_int = 65536;
pub const GEGL_CH_TOP_BACK_LEFT: c_int = 32768;
pub const GEGL_CH_TOP_BACK_RIGHT: c_int = 131072;
pub const GEGL_CH_TOP_CENTER: c_int = 2048;
pub const GEGL_CH_TOP_FRONT_CENTER: c_int = 8192;
pub const GEGL_CH_TOP_FRONT_LEFT: c_int = 4096;
pub const GEGL_CH_TOP_FRONT_RIGHT: c_int = 16384;
pub const GEGL_CH_WIDE_LEFT: c_long = 2147483648;
pub const GEGL_CH_WIDE_RIGHT: c_long = 4294967296;
pub const GEGL_FLOAT_EPSILON: c_double = 0.000010;
pub const GEGL_LOOKUP_MAX_ENTRIES: c_int = 819200;
pub const GEGL_MAX_AUDIO_CHANNELS: c_int = 8;
pub type GeglAccessMode = c_uint;
pub const GEGL_ACCESS_READ: GeglAccessMode = 1;
pub const GEGL_ACCESS_WRITE: GeglAccessMode = 2;
pub const GEGL_ACCESS_READWRITE: GeglAccessMode = 3;
pub type GeglBlitFlags = c_uint;
pub const GEGL_BLIT_DEFAULT: GeglBlitFlags = 0;
pub const GEGL_BLIT_CACHE: GeglBlitFlags = 1;
pub const GEGL_BLIT_DIRTY: GeglBlitFlags = 2;
pub type GeglPadType = c_uint;
pub const GEGL_PARAM_PAD_OUTPUT: GeglPadType = 256;
pub const GEGL_PARAM_PAD_INPUT: GeglPadType = 512;
pub type GeglSerializeFlag = c_uint;
pub const GEGL_SERIALIZE_TRIM_DEFAULTS: GeglSerializeFlag = 1;
pub const GEGL_SERIALIZE_VERSION: GeglSerializeFlag = 2;
pub const GEGL_SERIALIZE_INDENT: GeglSerializeFlag = 4;
pub const GEGL_SERIALIZE_BAKE_ANIM: GeglSerializeFlag = 8;
pub type GeglFlattenerFunc = Option<unsafe extern "C" fn(*mut GeglPathList) -> *mut GeglPathList>;
pub type GeglLookupFunction = Option<unsafe extern "C" fn(c_float, gpointer) -> c_float>;
pub type GeglNodeFunction = Option<unsafe extern "C" fn(*const GeglPathItem, gpointer)>;
pub type GeglParallelDistributeAreaFunc =
Option<unsafe extern "C" fn(*const GeglRectangle, gpointer)>;
pub type GeglParallelDistributeFunc = Option<unsafe extern "C" fn(c_int, c_int, gpointer)>;
pub type GeglParallelDistributeRangeFunc = Option<unsafe extern "C" fn(size_t, size_t, gpointer)>;
pub type GeglSamplerGetFun = Option<
unsafe extern "C" fn(
*mut GeglSampler,
c_double,
c_double,
*mut GeglBufferMatrix2,
*mut c_void,
GeglAbyssPolicy,
),
>;
pub type GeglTileCallback = Option<unsafe extern "C" fn(*mut GeglTile, gpointer)>;
pub type GeglTileSourceCommand = Option<
unsafe extern "C" fn(
*mut GeglTileSource,
GeglTileCommand,
c_int,
c_int,
c_int,
gpointer,
) -> gpointer,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglAudioFragmentClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for GeglAudioFragmentClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglAudioFragmentClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GeglAudioFragmentPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglAudioFragmentPrivate = _GeglAudioFragmentPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglBufferIterator {
pub length: c_int,
pub priv_: *mut GeglBufferIteratorPriv,
}
impl ::std::fmt::Debug for GeglBufferIterator {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglBufferIterator @ {self:p}"))
.field("length", &self.length)
.field("priv_", &self.priv_)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglBufferIteratorItem {
pub data: gpointer,
pub roi: GeglRectangle,
}
impl ::std::fmt::Debug for GeglBufferIteratorItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglBufferIteratorItem @ {self:p}"))
.field("data", &self.data)
.field("roi", &self.roi)
.finish()
}
}
#[repr(C)]
pub struct _GeglBufferIteratorPriv {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglBufferIteratorPriv = _GeglBufferIteratorPriv;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglBufferMatrix2 {
pub coeff: [c_double; 4],
}
impl ::std::fmt::Debug for GeglBufferMatrix2 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglBufferMatrix2 @ {self:p}"))
.field("coeff", &self.coeff)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglColorClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for GeglColorClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglColorClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GeglColorPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglColorPrivate = _GeglColorPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglCurveClass {
pub parent_class: gobject::GObjectClass,
}
impl ::std::fmt::Debug for GeglCurveClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglCurveClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct GeglLookup {
pub function: GeglLookupFunction,
pub data: gpointer,
pub shift: c_int,
pub positive_min: u32,
pub positive_max: u32,
pub negative_min: u32,
pub negative_max: u32,
pub bitmask: [u32; 25600],
_truncated_record_marker: c_void,
}
impl ::std::fmt::Debug for GeglLookup {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglLookup @ {self:p}"))
.field("function", &self.function)
.field("data", &self.data)
.field("shift", &self.shift)
.field("positive_min", &self.positive_min)
.field("positive_max", &self.positive_max)
.field("negative_min", &self.negative_min)
.field("negative_max", &self.negative_max)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMatrix3 {
pub coeff: [c_double; 9],
}
impl ::std::fmt::Debug for GeglMatrix3 {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMatrix3 @ {self:p}"))
.field("coeff", &self.coeff)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMetadataHashClass {
pub parent_class: GeglMetadataStoreClass,
}
impl ::std::fmt::Debug for GeglMetadataHashClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataHashClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMetadataInterface {
pub base_iface: gobject::GTypeInterface,
pub register_map: Option<
unsafe extern "C" fn(
*mut GeglMetadata,
*const c_char,
c_uint,
*const GeglMetadataMap,
size_t,
),
>,
pub set_resolution: Option<
unsafe extern "C" fn(
*mut GeglMetadata,
*mut GeglResolutionUnit,
*mut c_float,
*mut c_float,
) -> gboolean,
>,
pub get_resolution: Option<
unsafe extern "C" fn(
*mut GeglMetadata,
*mut GeglResolutionUnit,
*mut c_float,
*mut c_float,
) -> gboolean,
>,
pub iter_lookup: Option<
unsafe extern "C" fn(*mut GeglMetadata, *mut GeglMetadataIter, *const c_char) -> gboolean,
>,
pub iter_init: Option<unsafe extern "C" fn(*mut GeglMetadata, *mut GeglMetadataIter)>,
pub iter_next:
Option<unsafe extern "C" fn(*mut GeglMetadata, *mut GeglMetadataIter) -> *const c_char>,
pub iter_set_value: Option<
unsafe extern "C" fn(
*mut GeglMetadata,
*mut GeglMetadataIter,
*mut gobject::GValue,
) -> gboolean,
>,
pub iter_get_value: Option<
unsafe extern "C" fn(
*mut GeglMetadata,
*mut GeglMetadataIter,
*mut gobject::GValue,
) -> gboolean,
>,
}
impl ::std::fmt::Debug for GeglMetadataInterface {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataInterface @ {self:p}"))
.field("register_map", &self.register_map)
.field("set_resolution", &self.set_resolution)
.field("get_resolution", &self.get_resolution)
.field("iter_lookup", &self.iter_lookup)
.field("iter_init", &self.iter_init)
.field("iter_next", &self.iter_next)
.field("iter_set_value", &self.iter_set_value)
.field("iter_get_value", &self.iter_get_value)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMetadataIter {
pub stamp: c_uint,
pub user_data: gpointer,
pub user_data2: gpointer,
pub user_data3: gpointer,
}
impl ::std::fmt::Debug for GeglMetadataIter {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataIter @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMetadataMap {
pub local_name: *const c_char,
pub name: *const c_char,
pub transform: gobject::GValueTransform,
}
impl ::std::fmt::Debug for GeglMetadataMap {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataMap @ {self:p}"))
.field("local_name", &self.local_name)
.field("name", &self.name)
.field("transform", &self.transform)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMetadataStoreClass {
pub parent_class: gobject::GObjectClass,
pub _declare:
Option<unsafe extern "C" fn(*mut GeglMetadataStore, *mut gobject::GParamSpec, gboolean)>,
pub pspec: Option<
unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char) -> *mut gobject::GParamSpec,
>,
pub set_value:
Option<unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char, *const gobject::GValue)>,
pub _get_value: Option<
unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char) -> *const gobject::GValue,
>,
pub has_value: Option<unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char) -> gboolean>,
pub register_hook: Option<unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char, c_uint)>,
pub parse_value: Option<
unsafe extern "C" fn(
*mut GeglMetadataStore,
*mut gobject::GParamSpec,
gobject::GValueTransform,
*mut gobject::GValue,
) -> gboolean,
>,
pub generate_value: Option<
unsafe extern "C" fn(
*mut GeglMetadataStore,
*mut gobject::GParamSpec,
gobject::GValueTransform,
*mut gobject::GValue,
) -> gboolean,
>,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GeglMetadataStoreClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataStoreClass @ {self:p}"))
.field("_declare", &self._declare)
.field("pspec", &self.pspec)
.field("set_value", &self.set_value)
.field("_get_value", &self._get_value)
.field("has_value", &self.has_value)
.field("register_hook", &self.register_hook)
.field("parse_value", &self.parse_value)
.field("generate_value", &self.generate_value)
.finish()
}
}
#[repr(C)]
pub struct _GeglOperationContext {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglOperationContext = _GeglOperationContext;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglParamSpecDouble {
pub parent_instance: gobject::GParamSpecDouble,
pub ui_minimum: c_double,
pub ui_maximum: c_double,
pub ui_gamma: c_double,
pub ui_step_small: c_double,
pub ui_step_big: c_double,
pub ui_digits: c_int,
}
impl ::std::fmt::Debug for GeglParamSpecDouble {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecDouble @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("ui_minimum", &self.ui_minimum)
.field("ui_maximum", &self.ui_maximum)
.field("ui_gamma", &self.ui_gamma)
.field("ui_step_small", &self.ui_step_small)
.field("ui_step_big", &self.ui_step_big)
.field("ui_digits", &self.ui_digits)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglParamSpecEnum {
pub parent_instance: gobject::GParamSpecEnum,
pub excluded_values: *mut glib::GSList,
}
impl ::std::fmt::Debug for GeglParamSpecEnum {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecEnum @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("excluded_values", &self.excluded_values)
.finish()
}
}
#[repr(C)]
pub struct GeglParamSpecFilePath {
_truncated_record_marker: c_void,
}
impl ::std::fmt::Debug for GeglParamSpecFilePath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecFilePath @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglParamSpecFormat {
pub parent_instance: gobject::GParamSpecPointer,
}
impl ::std::fmt::Debug for GeglParamSpecFormat {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecFormat @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglParamSpecInt {
pub parent_instance: gobject::GParamSpecInt,
pub ui_minimum: c_int,
pub ui_maximum: c_int,
pub ui_gamma: c_double,
pub ui_step_small: c_int,
pub ui_step_big: c_int,
}
impl ::std::fmt::Debug for GeglParamSpecInt {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecInt @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("ui_minimum", &self.ui_minimum)
.field("ui_maximum", &self.ui_maximum)
.field("ui_gamma", &self.ui_gamma)
.field("ui_step_small", &self.ui_step_small)
.field("ui_step_big", &self.ui_step_big)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglParamSpecSeed {
pub parent_instance: gobject::GParamSpecUInt,
pub ui_minimum: c_uint,
pub ui_maximum: c_uint,
}
impl ::std::fmt::Debug for GeglParamSpecSeed {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecSeed @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("ui_minimum", &self.ui_minimum)
.field("ui_maximum", &self.ui_maximum)
.finish()
}
}
#[repr(C)]
pub struct GeglParamSpecString {
_truncated_record_marker: c_void,
}
impl ::std::fmt::Debug for GeglParamSpecString {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecString @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamSpecUri {
_truncated_record_marker: c_void,
}
impl ::std::fmt::Debug for GeglParamSpecUri {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSpecUri @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct _GeglPathClass {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglPathClass = _GeglPathClass;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglPathItem {
pub type_: c_char,
pub point: [GeglPathPoint; 4],
}
impl ::std::fmt::Debug for GeglPathItem {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglPathItem @ {self:p}"))
.field("type_", &self.type_)
.field("point", &self.point)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglPathList {
pub next: *mut GeglPathList,
pub d: GeglPathItem,
}
impl ::std::fmt::Debug for GeglPathList {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglPathList @ {self:p}"))
.field("next", &self.next)
.field("d", &self.d)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglPathPoint {
pub x: c_float,
pub y: c_float,
}
impl ::std::fmt::Debug for GeglPathPoint {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglPathPoint @ {self:p}"))
.field("x", &self.x)
.field("y", &self.y)
.finish()
}
}
#[repr(C)]
pub struct GeglRandom {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglRandom {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglRandom @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglRectangle {
pub x: c_int,
pub y: c_int,
pub width: c_int,
pub height: c_int,
}
impl ::std::fmt::Debug for GeglRectangle {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglRectangle @ {self:p}"))
.field("x", &self.x)
.field("y", &self.y)
.field("width", &self.width)
.field("height", &self.height)
.finish()
}
}
#[repr(C)]
pub struct _GeglSampler {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglSampler = _GeglSampler;
#[repr(C)]
pub struct _GeglTile {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglTile = _GeglTile;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileBackendClass {
pub parent_class: GeglTileSourceClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GeglTileBackendClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileBackendClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("padding", &self.padding)
.finish()
}
}
#[repr(C)]
pub struct _GeglTileBackendPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglTileBackendPrivate = _GeglTileBackendPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileCopyParams {
pub dst_buffer: *mut GeglBuffer,
pub dst_x: c_int,
pub dst_y: c_int,
pub dst_z: c_int,
}
impl ::std::fmt::Debug for GeglTileCopyParams {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileCopyParams @ {self:p}"))
.field("dst_buffer", &self.dst_buffer)
.field("dst_x", &self.dst_x)
.field("dst_y", &self.dst_y)
.field("dst_z", &self.dst_z)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileHandlerClass {
pub parent_class: GeglTileSourceClass,
}
impl ::std::fmt::Debug for GeglTileHandlerClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileHandlerClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.finish()
}
}
#[repr(C)]
pub struct _GeglTileHandlerPrivate {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
pub type GeglTileHandlerPrivate = _GeglTileHandlerPrivate;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileSourceClass {
pub parent_class: gobject::GObjectClass,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GeglTileSourceClass {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileSourceClass @ {self:p}"))
.field("parent_class", &self.parent_class)
.field("padding", &self.padding)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglAudioFragment {
pub parent_instance: gobject::GObject,
pub data: [*mut c_float; 8],
pub priv_: *mut GeglAudioFragmentPrivate,
}
impl ::std::fmt::Debug for GeglAudioFragment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglAudioFragment @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("data", &self.data)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
pub struct GeglBuffer {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglBuffer {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglBuffer @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglColor {
pub parent_instance: gobject::GObject,
pub priv_: *mut GeglColorPrivate,
}
impl ::std::fmt::Debug for GeglColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglColor @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("priv_", &self.priv_)
.finish()
}
}
#[repr(C)]
pub struct GeglConfig {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglConfig {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglConfig @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglCurve {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for GeglCurve {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglCurve @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct GeglMetadataHash {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglMetadataHash {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataHash @ {self:p}"))
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglMetadataStore {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for GeglMetadataStore {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglMetadataStore @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct GeglNode {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglNode {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglNode @ {self:p}")).finish()
}
}
#[repr(C)]
pub struct GeglOperation {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglOperation {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglOperation @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamAudioFragment {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamAudioFragment {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamAudioFragment @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamColor {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamColor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamColor @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamCurve {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamCurve {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamCurve @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamDouble {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamDouble {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamDouble @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamEnum {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamEnum {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamEnum @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamFilePath {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamFilePath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamFilePath @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamFormat {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamFormat {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamFormat @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamInt {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamInt {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamInt @ {self:p}")).finish()
}
}
#[repr(C)]
pub struct GeglParamPath {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamPath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamPath @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamSeed {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamSeed {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamSeed @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamString {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamString {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamString @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglParamUri {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglParamUri {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglParamUri @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglPath {
pub parent_instance: gobject::GObject,
}
impl ::std::fmt::Debug for GeglPath {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglPath @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.finish()
}
}
#[repr(C)]
pub struct GeglProcessor {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglProcessor {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglProcessor @ {self:p}"))
.finish()
}
}
#[repr(C)]
pub struct GeglStats {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglStats {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglStats @ {self:p}")).finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileBackend {
pub parent_instance: GeglTileSource,
pub priv_: *mut GeglTileBackendPrivate,
}
impl ::std::fmt::Debug for GeglTileBackend {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileBackend @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("priv_", &self.priv_)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileHandler {
pub parent_instance: GeglTileSource,
pub source: *mut GeglTileSource,
pub priv_: *mut GeglTileHandlerPrivate,
}
impl ::std::fmt::Debug for GeglTileHandler {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileHandler @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("source", &self.source)
.field("priv_", &self.priv_)
.finish()
}
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GeglTileSource {
pub parent_instance: gobject::GObject,
pub command: GeglTileSourceCommand,
pub padding: [gpointer; 4],
}
impl ::std::fmt::Debug for GeglTileSource {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
f.debug_struct(&format!("GeglTileSource @ {self:p}"))
.field("parent_instance", &self.parent_instance)
.field("command", &self.command)
.field("padding", &self.padding)
.finish()
}
}
#[repr(C)]
pub struct GeglMetadata {
_data: [u8; 0],
_marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}
impl ::std::fmt::Debug for GeglMetadata {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
write!(f, "GeglMetadata @ {self:p}")
}
}
#[link(name = "gegl-0.4")]
extern "C" {
pub fn gegl_abyss_policy_get_type() -> GType;
pub fn gegl_babl_variant_get_type() -> GType;
pub fn gegl_cache_policy_get_type() -> GType;
pub fn gegl_distance_metric_get_type() -> GType;
pub fn gegl_dither_method_get_type() -> GType;
pub fn gegl_orientation_get_type() -> GType;
pub fn gegl_rectangle_alignment_get_type() -> GType;
pub fn gegl_resolution_unit_get_type() -> GType;
pub fn gegl_sampler_type_get_type() -> GType;
pub fn gegl_access_mode_get_type() -> GType;
pub fn gegl_buffer_iterator_add(
iterator: *mut GeglBufferIterator,
buffer: *mut GeglBuffer,
roi: *const GeglRectangle,
level: c_int,
format: *const babl::Babl,
access_mode: GeglAccessMode,
abyss_policy: GeglAbyssPolicy,
) -> c_int;
pub fn gegl_buffer_iterator_next(iterator: *mut GeglBufferIterator) -> gboolean;
pub fn gegl_buffer_iterator_stop(iterator: *mut GeglBufferIterator);
pub fn gegl_buffer_iterator_empty_new(max_slots: c_int) -> *mut GeglBufferIterator;
pub fn gegl_buffer_matrix2_determinant(matrix: *mut GeglBufferMatrix2) -> c_double;
pub fn gegl_buffer_matrix2_is_identity(matrix: *mut GeglBufferMatrix2) -> gboolean;
pub fn gegl_buffer_matrix2_is_scale(matrix: *mut GeglBufferMatrix2) -> gboolean;
pub fn gegl_lookup_free(lookup: *mut GeglLookup);
pub fn gegl_lookup_new(function: GeglLookupFunction, data: gpointer) -> *mut GeglLookup;
pub fn gegl_lookup_new_full(
function: GeglLookupFunction,
data: gpointer,
start: c_float,
end: c_float,
precision: c_float,
) -> *mut GeglLookup;
pub fn gegl_matrix3_get_type() -> GType;
pub fn gegl_matrix3_new() -> *mut GeglMatrix3;
pub fn gegl_matrix3_copy(matrix: *const GeglMatrix3) -> *mut GeglMatrix3;
pub fn gegl_matrix3_copy_into(dst: *mut GeglMatrix3, src: *const GeglMatrix3);
pub fn gegl_matrix3_determinant(matrix: *const GeglMatrix3) -> c_double;
pub fn gegl_matrix3_equal(matrix1: *const GeglMatrix3, matrix2: *const GeglMatrix3)
-> gboolean;
pub fn gegl_matrix3_identity(matrix: *mut GeglMatrix3);
pub fn gegl_matrix3_invert(matrix: *mut GeglMatrix3);
pub fn gegl_matrix3_is_affine(matrix: *const GeglMatrix3) -> gboolean;
pub fn gegl_matrix3_is_identity(matrix: *const GeglMatrix3) -> gboolean;
pub fn gegl_matrix3_is_scale(matrix: *const GeglMatrix3) -> gboolean;
pub fn gegl_matrix3_is_translate(matrix: *const GeglMatrix3) -> gboolean;
pub fn gegl_matrix3_multiply(
left: *const GeglMatrix3,
right: *const GeglMatrix3,
product: *mut GeglMatrix3,
);
pub fn gegl_matrix3_originate(matrix: *mut GeglMatrix3, x: c_double, y: c_double);
pub fn gegl_matrix3_parse_string(matrix: *mut GeglMatrix3, string: *const c_char);
pub fn gegl_matrix3_round_error(matrix: *mut GeglMatrix3);
pub fn gegl_matrix3_to_string(matrix: *const GeglMatrix3) -> *mut c_char;
pub fn gegl_matrix3_transform_point(
matrix: *const GeglMatrix3,
x: *mut c_double,
y: *mut c_double,
);
pub fn gegl_param_spec_double_set_digits(pspec: *mut GeglParamSpecDouble, digits: c_int);
pub fn gegl_param_spec_double_set_steps(
pspec: *mut GeglParamSpecDouble,
small_step: c_double,
big_step: c_double,
);
pub fn gegl_param_spec_enum_exclude_value(espec: *mut GeglParamSpecEnum, value: c_int);
pub fn gegl_param_spec_int_set_steps(
pspec: *mut GeglParamSpecInt,
small_step: c_int,
big_step: c_int,
);
pub fn gegl_path_list_append(head: *mut GeglPathList, ...) -> *mut GeglPathList;
pub fn gegl_path_list_destroy(path: *mut GeglPathList) -> *mut GeglPathList;
pub fn gegl_path_point_dist(a: *mut GeglPathPoint, b: *mut GeglPathPoint) -> c_double;
pub fn gegl_path_point_lerp(
dest: *mut GeglPathPoint,
a: *mut GeglPathPoint,
b: *mut GeglPathPoint,
t: c_float,
);
pub fn gegl_random_get_type() -> GType;
pub fn gegl_random_new() -> *mut GeglRandom;
pub fn gegl_random_new_with_seed(seed: u32) -> *mut GeglRandom;
pub fn gegl_random_duplicate(rand: *mut GeglRandom) -> *mut GeglRandom;
pub fn gegl_random_float(
rand: *const GeglRandom,
x: c_int,
y: c_int,
z: c_int,
n: c_int,
) -> c_float;
pub fn gegl_random_float_range(
rand: *const GeglRandom,
x: c_int,
y: c_int,
z: c_int,
n: c_int,
min: c_float,
max: c_float,
) -> c_float;
pub fn gegl_random_free(rand: *mut GeglRandom);
pub fn gegl_random_int(rand: *const GeglRandom, x: c_int, y: c_int, z: c_int, n: c_int) -> u32;
pub fn gegl_random_int_range(
rand: *const GeglRandom,
x: c_int,
y: c_int,
z: c_int,
n: c_int,
min: c_int,
max: c_int,
) -> i32;
pub fn gegl_random_set_seed(rand: *mut GeglRandom, seed: u32);
pub fn gegl_rectangle_get_type() -> GType;
pub fn gegl_rectangle_new(
x: c_int,
y: c_int,
width: c_uint,
height: c_uint,
) -> *mut GeglRectangle;
pub fn gegl_rectangle_align(
destination: *mut GeglRectangle,
rectangle: *const GeglRectangle,
tile: *const GeglRectangle,
alignment: GeglRectangleAlignment,
) -> gboolean;
pub fn gegl_rectangle_align_to_buffer(
destination: *mut GeglRectangle,
rectangle: *const GeglRectangle,
buffer: *mut GeglBuffer,
alignment: GeglRectangleAlignment,
) -> gboolean;
pub fn gegl_rectangle_bounding_box(
destination: *mut GeglRectangle,
source1: *const GeglRectangle,
source2: *const GeglRectangle,
);
pub fn gegl_rectangle_contains(
parent: *const GeglRectangle,
child: *const GeglRectangle,
) -> gboolean;
pub fn gegl_rectangle_copy(destination: *mut GeglRectangle, source: *const GeglRectangle);
pub fn gegl_rectangle_dump(rectangle: *const GeglRectangle);
pub fn gegl_rectangle_dup(rectangle: *const GeglRectangle) -> *mut GeglRectangle;
pub fn gegl_rectangle_equal(
rectangle1: *const GeglRectangle,
rectangle2: *const GeglRectangle,
) -> gboolean;
pub fn gegl_rectangle_equal_coords(
rectangle: *const GeglRectangle,
x: c_int,
y: c_int,
width: c_int,
height: c_int,
) -> gboolean;
pub fn gegl_rectangle_intersect(
dest: *mut GeglRectangle,
src1: *const GeglRectangle,
src2: *const GeglRectangle,
) -> gboolean;
pub fn gegl_rectangle_is_empty(rectangle: *const GeglRectangle) -> gboolean;
pub fn gegl_rectangle_is_infinite_plane(rectangle: *const GeglRectangle) -> gboolean;
pub fn gegl_rectangle_set(
rectangle: *mut GeglRectangle,
x: c_int,
y: c_int,
width: c_uint,
height: c_uint,
);
pub fn gegl_rectangle_subtract(
destination: *mut GeglRectangle,
minuend: *const GeglRectangle,
subtrahend: *const GeglRectangle,
) -> c_int;
pub fn gegl_rectangle_subtract_bounding_box(
destination: *mut GeglRectangle,
minuend: *const GeglRectangle,
subtrahend: *const GeglRectangle,
) -> gboolean;
pub fn gegl_rectangle_xor(
destination: *mut GeglRectangle,
source1: *const GeglRectangle,
source2: *const GeglRectangle,
) -> c_int;
pub fn gegl_rectangle_infinite_plane() -> GeglRectangle;
pub fn gegl_sampler_get(
sampler: *mut GeglSampler,
x: c_double,
y: c_double,
scale: *mut GeglBufferMatrix2,
output: *mut c_void,
repeat_mode: GeglAbyssPolicy,
);
pub fn gegl_sampler_get_context_rect(sampler: *mut GeglSampler) -> *const GeglRectangle;
pub fn gegl_sampler_get_fun(sampler: *mut GeglSampler) -> GeglSamplerGetFun;
pub fn gegl_audio_fragment_get_type() -> GType;
pub fn gegl_audio_fragment_new(
sample_rate: c_int,
channels: c_int,
channel_layout: c_int,
max_samples: c_int,
) -> *mut GeglAudioFragment;
pub fn gegl_audio_fragment_get_channel_layout(audio: *mut GeglAudioFragment) -> c_int;
pub fn gegl_audio_fragment_get_channels(audio: *mut GeglAudioFragment) -> c_int;
pub fn gegl_audio_fragment_get_max_samples(audio: *mut GeglAudioFragment) -> c_int;
pub fn gegl_audio_fragment_get_pos(audio: *mut GeglAudioFragment) -> c_int;
pub fn gegl_audio_fragment_get_sample_count(audio: *mut GeglAudioFragment) -> c_int;
pub fn gegl_audio_fragment_get_sample_rate(audio: *mut GeglAudioFragment) -> c_int;
pub fn gegl_audio_fragment_set_channel_layout(
audio: *mut GeglAudioFragment,
channel_layout: c_int,
);
pub fn gegl_audio_fragment_set_channels(audio: *mut GeglAudioFragment, channels: c_int);
pub fn gegl_audio_fragment_set_max_samples(audio: *mut GeglAudioFragment, max_samples: c_int);
pub fn gegl_audio_fragment_set_pos(audio: *mut GeglAudioFragment, pos: c_int);
pub fn gegl_audio_fragment_set_sample_count(audio: *mut GeglAudioFragment, sample_count: c_int);
pub fn gegl_audio_fragment_set_sample_rate(audio: *mut GeglAudioFragment, sample_rate: c_int);
pub fn gegl_buffer_get_type() -> GType;
pub fn gegl_buffer_introspectable_new(
format_name: *const c_char,
x: c_int,
y: c_int,
width: c_int,
height: c_int,
) -> *mut GeglBuffer;
pub fn gegl_buffer_linear_new(
extent: *const GeglRectangle,
format: *const babl::Babl,
) -> *mut GeglBuffer;
pub fn gegl_buffer_linear_new_from_data(
data: gpointer,
format: *const babl::Babl,
extent: *const GeglRectangle,
rowstride: c_int,
destroy_fn: glib::GDestroyNotify,
destroy_fn_data: gpointer,
) -> *mut GeglBuffer;
pub fn gegl_buffer_new(
extent: *const GeglRectangle,
format: *const babl::Babl,
) -> *mut GeglBuffer;
pub fn gegl_buffer_new_for_backend(
extent: *const GeglRectangle,
backend: *mut GeglTileBackend,
) -> *mut GeglBuffer;
pub fn gegl_buffer_load(path: *const c_char) -> *mut GeglBuffer;
pub fn gegl_buffer_open(path: *const c_char) -> *mut GeglBuffer;
pub fn gegl_buffer_swap_create_file(suffix: *const c_char) -> *mut c_char;
pub fn gegl_buffer_swap_has_file(path: *const c_char) -> gboolean;
pub fn gegl_buffer_swap_remove_file(path: *const c_char);
pub fn gegl_buffer_add_handler(buffer: *mut GeglBuffer, handler: gpointer);
pub fn gegl_buffer_clear(buffer: *mut GeglBuffer, roi: *const GeglRectangle);
pub fn gegl_buffer_copy(
src: *mut GeglBuffer,
src_rect: *const GeglRectangle,
repeat_mode: GeglAbyssPolicy,
dst: *mut GeglBuffer,
dst_rect: *const GeglRectangle,
);
pub fn gegl_buffer_create_sub_buffer(
buffer: *mut GeglBuffer,
extent: *const GeglRectangle,
) -> *mut GeglBuffer;
pub fn gegl_buffer_dup(buffer: *mut GeglBuffer) -> *mut GeglBuffer;
pub fn gegl_buffer_flush(buffer: *mut GeglBuffer);
pub fn gegl_buffer_flush_ext(buffer: *mut GeglBuffer, rect: *const GeglRectangle);
pub fn gegl_buffer_freeze_changed(buffer: *mut GeglBuffer);
pub fn gegl_buffer_get(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
scale: c_double,
format: *const babl::Babl,
dest: gpointer,
rowstride: c_int,
repeat_mode: GeglAbyssPolicy,
);
pub fn gegl_buffer_get_abyss(buffer: *mut GeglBuffer) -> *const GeglRectangle;
pub fn gegl_buffer_get_extent(buffer: *mut GeglBuffer) -> *const GeglRectangle;
pub fn gegl_buffer_get_format(buffer: *mut GeglBuffer) -> *const babl::Babl;
pub fn gegl_buffer_get_tile(
buffer: *mut GeglBuffer,
x: c_int,
y: c_int,
z: c_int,
) -> *mut GeglTile;
pub fn gegl_buffer_introspectable_get(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
scale: c_double,
format_name: *const c_char,
repeat_mode: GeglAbyssPolicy,
data_length: *mut c_uint,
) -> *mut u8;
pub fn gegl_buffer_introspectable_set(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
format_name: *const c_char,
src: *const u8,
src_length: c_int,
);
pub fn gegl_buffer_iterator_new(
buffer: *mut GeglBuffer,
roi: *const GeglRectangle,
level: c_int,
format: *const babl::Babl,
access_mode: GeglAccessMode,
abyss_policy: GeglAbyssPolicy,
max_slots: c_int,
) -> *mut GeglBufferIterator;
pub fn gegl_buffer_linear_close(buffer: *mut GeglBuffer, linear: gpointer);
pub fn gegl_buffer_linear_open(
buffer: *mut GeglBuffer,
extent: *const GeglRectangle,
rowstride: *mut c_int,
format: *const babl::Babl,
) -> gpointer;
pub fn gegl_buffer_remove_handler(buffer: *mut GeglBuffer, handler: gpointer);
pub fn gegl_buffer_sample(
buffer: *mut GeglBuffer,
x: c_double,
y: c_double,
scale: *mut GeglBufferMatrix2,
dest: gpointer,
format: *const babl::Babl,
sampler_type: GeglSamplerType,
repeat_mode: GeglAbyssPolicy,
);
pub fn gegl_buffer_sample_at_level(
buffer: *mut GeglBuffer,
x: c_double,
y: c_double,
scale: *mut GeglBufferMatrix2,
dest: gpointer,
format: *const babl::Babl,
level: c_int,
sampler_type: GeglSamplerType,
repeat_mode: GeglAbyssPolicy,
);
pub fn gegl_buffer_sample_cleanup(buffer: *mut GeglBuffer);
pub fn gegl_buffer_sampler_new(
buffer: *mut GeglBuffer,
format: *const babl::Babl,
sampler_type: GeglSamplerType,
) -> *mut GeglSampler;
pub fn gegl_buffer_sampler_new_at_level(
buffer: *mut GeglBuffer,
format: *const babl::Babl,
sampler_type: GeglSamplerType,
level: c_int,
) -> *mut GeglSampler;
pub fn gegl_buffer_save(
buffer: *mut GeglBuffer,
path: *const c_char,
roi: *const GeglRectangle,
);
pub fn gegl_buffer_set(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
mipmap_level: c_int,
format: *const babl::Babl,
src: *mut c_void,
rowstride: c_int,
);
pub fn gegl_buffer_set_abyss(buffer: *mut GeglBuffer, abyss: *const GeglRectangle) -> gboolean;
pub fn gegl_buffer_set_color(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
color: *mut GeglColor,
);
pub fn gegl_buffer_set_color_from_pixel(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
pixel: gconstpointer,
pixel_format: *const babl::Babl,
);
pub fn gegl_buffer_set_extent(
buffer: *mut GeglBuffer,
extent: *const GeglRectangle,
) -> gboolean;
pub fn gegl_buffer_set_format(
buffer: *mut GeglBuffer,
format: *const babl::Babl,
) -> *const babl::Babl;
pub fn gegl_buffer_set_pattern(
buffer: *mut GeglBuffer,
rect: *const GeglRectangle,
pattern: *mut GeglBuffer,
x_offset: c_int,
y_offset: c_int,
);
pub fn gegl_buffer_share_storage(
buffer1: *mut GeglBuffer,
buffer2: *mut GeglBuffer,
) -> gboolean;
pub fn gegl_buffer_signal_connect(
buffer: *mut GeglBuffer,
detailed_signal: *const c_char,
c_handler: gobject::GCallback,
data: gpointer,
) -> c_long;
pub fn gegl_buffer_thaw_changed(buffer: *mut GeglBuffer);
pub fn gegl_color_get_type() -> GType;
pub fn gegl_color_new(string: *const c_char) -> *mut GeglColor;
pub fn gegl_color_duplicate(color: *mut GeglColor) -> *mut GeglColor;
pub fn gegl_color_get_components(
color: *mut GeglColor,
format: *mut gobject::GValue,
components_length: *mut c_int,
) -> *mut c_double;
pub fn gegl_color_get_format(color: *mut GeglColor) -> *const babl::Babl;
pub fn gegl_color_get_pixel(
color: *mut GeglColor,
format: *const babl::Babl,
pixel: *mut c_void,
);
pub fn gegl_color_get_rgba(
color: *mut GeglColor,
red: *mut c_double,
green: *mut c_double,
blue: *mut c_double,
alpha: *mut c_double,
);
pub fn gegl_color_set_components(
color: *mut GeglColor,
format: *mut gobject::GValue,
components: *mut c_double,
components_length: c_int,
);
pub fn gegl_color_set_pixel(
color: *mut GeglColor,
format: *const babl::Babl,
pixel: *mut c_void,
);
pub fn gegl_color_set_rgba(
color: *mut GeglColor,
red: c_double,
green: c_double,
blue: c_double,
alpha: c_double,
);
pub fn gegl_config_get_type() -> GType;
pub fn gegl_curve_get_type() -> GType;
pub fn gegl_curve_new(y_min: c_double, y_max: c_double) -> *mut GeglCurve;
pub fn gegl_curve_new_default() -> *mut GeglCurve;
pub fn gegl_curve_add_point(curve: *mut GeglCurve, x: c_double, y: c_double) -> c_uint;
pub fn gegl_curve_calc_value(curve: *mut GeglCurve, x: c_double) -> c_double;
pub fn gegl_curve_calc_values(
curve: *mut GeglCurve,
x_min: c_double,
x_max: c_double,
num_samples: c_uint,
xs: *mut c_double,
ys: *mut c_double,
);
pub fn gegl_curve_duplicate(curve: *mut GeglCurve) -> *mut GeglCurve;
pub fn gegl_curve_get_point(
curve: *mut GeglCurve,
index: c_uint,
x: *mut c_double,
y: *mut c_double,
);
pub fn gegl_curve_get_y_bounds(
curve: *mut GeglCurve,
min_y: *mut c_double,
max_y: *mut c_double,
);
pub fn gegl_curve_num_points(curve: *mut GeglCurve) -> c_uint;
pub fn gegl_curve_set_point(curve: *mut GeglCurve, index: c_uint, x: c_double, y: c_double);
pub fn gegl_metadata_hash_get_type() -> GType;
pub fn gegl_metadata_hash_new() -> *mut GeglMetadataStore;
pub fn gegl_metadata_store_get_type() -> GType;
pub fn gegl_metadata_store_declare(
self_: *mut GeglMetadataStore,
pspec: *mut gobject::GParamSpec,
);
pub fn gegl_metadata_store_get_artist(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_comment(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_copyright(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_description(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_disclaimer(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_file_module_name(self_: *mut GeglMetadataStore)
-> *const c_char;
pub fn gegl_metadata_store_get_resolution_unit(
self_: *mut GeglMetadataStore,
) -> GeglResolutionUnit;
pub fn gegl_metadata_store_get_resolution_x(self_: *mut GeglMetadataStore) -> c_double;
pub fn gegl_metadata_store_get_resolution_y(self_: *mut GeglMetadataStore) -> c_double;
pub fn gegl_metadata_store_get_software(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_source(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_string(
self_: *mut GeglMetadataStore,
name: *const c_char,
) -> *const c_char;
pub fn gegl_metadata_store_get_timestamp(self_: *mut GeglMetadataStore)
-> *mut glib::GDateTime;
pub fn gegl_metadata_store_get_title(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_get_value(
self_: *mut GeglMetadataStore,
name: *const c_char,
value: *mut gobject::GValue,
);
pub fn gegl_metadata_store_get_warning(self_: *mut GeglMetadataStore) -> *const c_char;
pub fn gegl_metadata_store_has_value(
self_: *mut GeglMetadataStore,
name: *const c_char,
) -> gboolean;
pub fn gegl_metadata_store_notify(
self_: *mut GeglMetadataStore,
pspec: *mut gobject::GParamSpec,
shadow: gboolean,
);
pub fn gegl_metadata_store_register(
self_: *mut GeglMetadataStore,
local_name: *const c_char,
name: *const c_char,
transform: gobject::GValueTransform,
);
pub fn gegl_metadata_store_set_artist(self_: *mut GeglMetadataStore, artist: *const c_char);
pub fn gegl_metadata_store_set_comment(self_: *mut GeglMetadataStore, comment: *const c_char);
pub fn gegl_metadata_store_set_copyright(
self_: *mut GeglMetadataStore,
copyright: *const c_char,
);
pub fn gegl_metadata_store_set_description(
self_: *mut GeglMetadataStore,
description: *const c_char,
);
pub fn gegl_metadata_store_set_disclaimer(
self_: *mut GeglMetadataStore,
disclaimer: *const c_char,
);
pub fn gegl_metadata_store_set_resolution_unit(
self_: *mut GeglMetadataStore,
unit: GeglResolutionUnit,
);
pub fn gegl_metadata_store_set_resolution_x(
self_: *mut GeglMetadataStore,
resolution_x: c_double,
);
pub fn gegl_metadata_store_set_resolution_y(
self_: *mut GeglMetadataStore,
resolution_y: c_double,
);
pub fn gegl_metadata_store_set_software(self_: *mut GeglMetadataStore, software: *const c_char);
pub fn gegl_metadata_store_set_source(self_: *mut GeglMetadataStore, source: *const c_char);
pub fn gegl_metadata_store_set_string(
self_: *mut GeglMetadataStore,
name: *const c_char,
string: *const c_char,
);
pub fn gegl_metadata_store_set_timestamp(
self_: *mut GeglMetadataStore,
timestamp: *const glib::GDateTime,
);
pub fn gegl_metadata_store_set_title(self_: *mut GeglMetadataStore, title: *const c_char);
pub fn gegl_metadata_store_set_value(
self_: *mut GeglMetadataStore,
name: *const c_char,
value: *const gobject::GValue,
);
pub fn gegl_metadata_store_set_warning(self_: *mut GeglMetadataStore, warning: *const c_char);
pub fn gegl_metadata_store_typeof_value(
self_: *mut GeglMetadataStore,
name: *const c_char,
) -> GType;
pub fn gegl_node_get_type() -> GType;
pub fn gegl_node_new() -> *mut GeglNode;
pub fn gegl_node_new_from_file(path: *const c_char) -> *mut GeglNode;
pub fn gegl_node_new_from_serialized(
chaindata: *const c_char,
path_root: *const c_char,
) -> *mut GeglNode;
pub fn gegl_node_new_from_xml(
xmldata: *const c_char,
path_root: *const c_char,
) -> *mut GeglNode;
pub fn gegl_node_add_child(graph: *mut GeglNode, child: *mut GeglNode) -> *mut GeglNode;
pub fn gegl_node_blit(
node: *mut GeglNode,
scale: c_double,
roi: *const GeglRectangle,
format: *const babl::Babl,
destination_buf: gpointer,
rowstride: c_int,
flags: GeglBlitFlags,
);
pub fn gegl_node_blit_buffer(
node: *mut GeglNode,
buffer: *mut GeglBuffer,
roi: *const GeglRectangle,
level: c_int,
abyss_policy: GeglAbyssPolicy,
);
pub fn gegl_node_connect(
a: *mut GeglNode,
a_pad_name: *const c_char,
b: *mut GeglNode,
b_pad_name: *const c_char,
) -> gboolean;
pub fn gegl_node_connect_from(
sink: *mut GeglNode,
input_pad_name: *const c_char,
source: *mut GeglNode,
output_pad_name: *const c_char,
) -> gboolean;
pub fn gegl_node_connect_to(
source: *mut GeglNode,
output_pad_name: *const c_char,
sink: *mut GeglNode,
input_pad_name: *const c_char,
) -> gboolean;
pub fn gegl_node_create_child(parent: *mut GeglNode, operation: *const c_char)
-> *mut GeglNode;
pub fn gegl_node_detect(node: *mut GeglNode, x: c_int, y: c_int) -> *mut GeglNode;
pub fn gegl_node_disconnect(node: *mut GeglNode, input_pad: *const c_char) -> gboolean;
pub fn gegl_node_find_property(
node: *mut GeglNode,
property_name: *const c_char,
) -> *mut gobject::GParamSpec;
pub fn gegl_node_get(node: *mut GeglNode, first_property_name: *const c_char, ...);
pub fn gegl_node_get_bounding_box(node: *mut GeglNode) -> GeglRectangle;
pub fn gegl_node_get_children(node: *mut GeglNode) -> *mut glib::GSList;
pub fn gegl_node_get_consumers(
node: *mut GeglNode,
output_pad: *const c_char,
nodes: *mut *mut *mut GeglNode,
pads: *mut *mut *const c_char,
) -> c_int;
pub fn gegl_node_get_gegl_operation(node: *mut GeglNode) -> *mut GeglOperation;
pub fn gegl_node_get_input_proxy(node: *mut GeglNode, pad_name: *const c_char)
-> *mut GeglNode;
pub fn gegl_node_get_operation(node: *const GeglNode) -> *const c_char;
pub fn gegl_node_get_output_proxy(
node: *mut GeglNode,
pad_name: *const c_char,
) -> *mut GeglNode;
pub fn gegl_node_get_parent(node: *mut GeglNode) -> *mut GeglNode;
pub fn gegl_node_get_passthrough(node: *mut GeglNode) -> gboolean;
pub fn gegl_node_get_producer(
node: *mut GeglNode,
input_pad_name: *const c_char,
output_pad_name: *mut *mut c_char,
) -> *mut GeglNode;
pub fn gegl_node_get_property(
node: *mut GeglNode,
property_name: *const c_char,
value: *mut gobject::GValue,
);
pub fn gegl_node_has_pad(node: *mut GeglNode, pad_name: *const c_char) -> gboolean;
pub fn gegl_node_introspectable_get_bounding_box(node: *mut GeglNode) -> *mut GeglRectangle;
pub fn gegl_node_introspectable_get_property(
node: *mut GeglNode,
property_name: *const c_char,
) -> *mut gobject::GValue;
pub fn gegl_node_is_graph(node: *mut GeglNode) -> gboolean;
pub fn gegl_node_link(source: *mut GeglNode, sink: *mut GeglNode);
pub fn gegl_node_link_many(source: *mut GeglNode, first_sink: *mut GeglNode, ...);
pub fn gegl_node_list_input_pads(node: *mut GeglNode) -> *mut *mut c_char;
pub fn gegl_node_list_output_pads(node: *mut GeglNode) -> *mut *mut c_char;
pub fn gegl_node_new_child(
parent: *mut GeglNode,
first_property_name: *const c_char,
...
) -> *mut GeglNode;
pub fn gegl_node_new_processor(
node: *mut GeglNode,
rectangle: *const GeglRectangle,
) -> *mut GeglProcessor;
pub fn gegl_node_process(sink_node: *mut GeglNode);
pub fn gegl_node_progress(node: *mut GeglNode, progress: c_double, message: *mut c_char);
pub fn gegl_node_remove_child(graph: *mut GeglNode, child: *mut GeglNode) -> *mut GeglNode;
pub fn gegl_node_set(node: *mut GeglNode, first_property_name: *const c_char, ...);
pub fn gegl_node_set_enum_as_string(
node: *mut GeglNode,
key: *const c_char,
value: *const c_char,
);
pub fn gegl_node_set_passthrough(node: *mut GeglNode, passthrough: gboolean);
pub fn gegl_node_set_property(
node: *mut GeglNode,
property_name: *const c_char,
value: *const gobject::GValue,
);
pub fn gegl_node_set_time(node: *mut GeglNode, time: c_double);
pub fn gegl_node_to_xml(node: *mut GeglNode, path_root: *const c_char) -> *mut c_char;
pub fn gegl_node_to_xml_full(
head: *mut GeglNode,
tail: *mut GeglNode,
path_root: *const c_char,
) -> *mut c_char;
pub fn gegl_operation_get_type() -> GType;
pub fn gegl_operation_find_property(
operation_type: *const c_char,
property_name: *const c_char,
) -> *mut gobject::GParamSpec;
pub fn gegl_operation_get_key(
operation_type: *const c_char,
key_name: *const c_char,
) -> *const c_char;
pub fn gegl_operation_get_op_version(op_name: *const c_char) -> *const c_char;
pub fn gegl_operation_get_property_key(
operation_type: *const c_char,
property_name: *const c_char,
property_key_name: *const c_char,
) -> *const c_char;
pub fn gegl_operation_list_keys(
operation_type: *const c_char,
n_keys: *mut c_uint,
) -> *mut *mut c_char;
pub fn gegl_operation_list_properties(
operation_type: *const c_char,
n_properties_p: *mut c_uint,
) -> *mut *mut gobject::GParamSpec;
pub fn gegl_operation_list_property_keys(
operation_type: *const c_char,
property_name: *const c_char,
n_keys: *mut c_uint,
) -> *mut *mut c_char;
pub fn gegl_param_audio_fragment_get_type() -> GType;
pub fn gegl_param_color_get_type() -> GType;
pub fn gegl_param_curve_get_type() -> GType;
pub fn gegl_param_double_get_type() -> GType;
pub fn gegl_param_enum_get_type() -> GType;
pub fn gegl_param_file_path_get_type() -> GType;
pub fn gegl_param_format_get_type() -> GType;
pub fn gegl_param_int_get_type() -> GType;
pub fn gegl_param_path_get_type() -> GType;
pub fn gegl_param_seed_get_type() -> GType;
pub fn gegl_param_string_get_type() -> GType;
pub fn gegl_param_uri_get_type() -> GType;
pub fn gegl_path_get_type() -> GType;
pub fn gegl_path_new() -> *mut GeglPath;
pub fn gegl_path_new_from_string(instructions: *const c_char) -> *mut GeglPath;
pub fn gegl_path_add_flattener(func: GeglFlattenerFunc);
pub fn gegl_path_add_type(type_: c_char, items: c_int, description: *const c_char);
pub fn gegl_path_append(path: *mut GeglPath, ...);
pub fn gegl_path_calc(
path: *mut GeglPath,
pos: c_double,
x: *mut c_double,
y: *mut c_double,
) -> gboolean;
pub fn gegl_path_calc_values(
path: *mut GeglPath,
num_samples: c_uint,
xs: *mut c_double,
ys: *mut c_double,
);
pub fn gegl_path_calc_y_for_x(path: *mut GeglPath, x: c_double, y: *mut c_double) -> c_int;
pub fn gegl_path_clear(path: *mut GeglPath);
pub fn gegl_path_closest_point(
path: *mut GeglPath,
x: c_double,
y: c_double,
on_path_x: *mut c_double,
on_path_y: *mut c_double,
node_pos_before: *mut c_int,
) -> c_double;
pub fn gegl_path_dirty(path: *mut GeglPath);
pub fn gegl_path_foreach(path: *mut GeglPath, each_item: GeglNodeFunction, user_data: gpointer);
pub fn gegl_path_foreach_flat(
path: *mut GeglPath,
each_item: GeglNodeFunction,
user_data: gpointer,
);
pub fn gegl_path_freeze(path: *mut GeglPath);
pub fn gegl_path_get_bounds(
self_: *mut GeglPath,
min_x: *mut c_double,
max_x: *mut c_double,
min_y: *mut c_double,
max_y: *mut c_double,
);
pub fn gegl_path_get_flat_path(path: *mut GeglPath) -> *mut GeglPathList;
pub fn gegl_path_get_length(path: *mut GeglPath) -> c_double;
pub fn gegl_path_get_matrix(path: *mut GeglPath, matrix: *mut GeglMatrix3);
pub fn gegl_path_get_n_nodes(path: *mut GeglPath) -> c_int;
pub fn gegl_path_get_node(
path: *mut GeglPath,
index: c_int,
node: *mut GeglPathItem,
) -> gboolean;
pub fn gegl_path_get_path(path: *mut GeglPath) -> *mut GeglPathList;
pub fn gegl_path_insert_node(path: *mut GeglPath, pos: c_int, node: *const GeglPathItem);
pub fn gegl_path_is_empty(path: *mut GeglPath) -> gboolean;
pub fn gegl_path_parse_string(path: *mut GeglPath, instructions: *const c_char);
pub fn gegl_path_remove_node(path: *mut GeglPath, pos: c_int);
pub fn gegl_path_replace_node(path: *mut GeglPath, pos: c_int, node: *const GeglPathItem);
pub fn gegl_path_set_matrix(path: *mut GeglPath, matrix: *mut GeglMatrix3);
pub fn gegl_path_thaw(path: *mut GeglPath);
pub fn gegl_path_to_string(path: *mut GeglPath) -> *mut c_char;
pub fn gegl_processor_get_type() -> GType;
pub fn gegl_processor_get_buffer(processor: *mut GeglProcessor) -> *mut GeglBuffer;
pub fn gegl_processor_set_level(processor: *mut GeglProcessor, level: c_int);
pub fn gegl_processor_set_rectangle(
processor: *mut GeglProcessor,
rectangle: *const GeglRectangle,
);
pub fn gegl_processor_set_scale(processor: *mut GeglProcessor, scale: c_double);
pub fn gegl_processor_work(processor: *mut GeglProcessor, progress: *mut c_double) -> gboolean;
pub fn gegl_stats_get_type() -> GType;
pub fn gegl_tile_backend_get_type() -> GType;
pub fn gegl_tile_backend_unlink_swap(path: *mut c_char);
pub fn gegl_tile_backend_command(
backend: *mut GeglTileBackend,
command: GeglTileCommand,
x: c_int,
y: c_int,
z: c_int,
data: gpointer,
) -> gpointer;
pub fn gegl_tile_backend_get_extent(tile_backend: *mut GeglTileBackend) -> GeglRectangle;
pub fn gegl_tile_backend_get_flush_on_destroy(tile_backend: *mut GeglTileBackend) -> gboolean;
pub fn gegl_tile_backend_get_format(tile_backend: *mut GeglTileBackend) -> *const babl::Babl;
pub fn gegl_tile_backend_get_tile_height(tile_backend: *mut GeglTileBackend) -> c_int;
pub fn gegl_tile_backend_get_tile_size(tile_backend: *mut GeglTileBackend) -> c_int;
pub fn gegl_tile_backend_get_tile_width(tile_backend: *mut GeglTileBackend) -> c_int;
pub fn gegl_tile_backend_peek_storage(
tile_backend: *mut GeglTileBackend,
) -> *mut GeglTileSource;
pub fn gegl_tile_backend_set_extent(
tile_backend: *mut GeglTileBackend,
rectangle: *const GeglRectangle,
);
pub fn gegl_tile_backend_set_flush_on_destroy(
tile_backend: *mut GeglTileBackend,
flush_on_destroy: gboolean,
);
pub fn gegl_tile_handler_get_type() -> GType;
pub fn gegl_tile_handler_create_tile(
handler: *mut GeglTileHandler,
x: c_int,
y: c_int,
z: c_int,
) -> *mut GeglTile;
pub fn gegl_tile_handler_damage_rect(handler: *mut GeglTileHandler, rect: *const GeglRectangle);
pub fn gegl_tile_handler_damage_tile(
handler: *mut GeglTileHandler,
x: c_int,
y: c_int,
z: c_int,
damage: u64,
);
pub fn gegl_tile_handler_dup_tile(
handler: *mut GeglTileHandler,
tile: *mut GeglTile,
x: c_int,
y: c_int,
z: c_int,
) -> *mut GeglTile;
pub fn gegl_tile_handler_get_source_tile(
handler: *mut GeglTileHandler,
x: c_int,
y: c_int,
z: c_int,
preserve_data: gboolean,
) -> *mut GeglTile;
pub fn gegl_tile_handler_get_tile(
handler: *mut GeglTileHandler,
x: c_int,
y: c_int,
z: c_int,
preserve_data: gboolean,
) -> *mut GeglTile;
pub fn gegl_tile_handler_lock(handler: *mut GeglTileHandler);
pub fn gegl_tile_handler_set_source(handler: *mut GeglTileHandler, source: *mut GeglTileSource);
pub fn gegl_tile_handler_unlock(handler: *mut GeglTileHandler);
pub fn gegl_tile_source_get_type() -> GType;
pub fn gegl_metadata_get_type() -> GType;
pub fn gegl_metadata_get_resolution(
metadata: *mut GeglMetadata,
unit: *mut GeglResolutionUnit,
x: *mut c_float,
y: *mut c_float,
) -> gboolean;
pub fn gegl_metadata_iter_get_value(
metadata: *mut GeglMetadata,
iter: *mut GeglMetadataIter,
value: *mut gobject::GValue,
) -> gboolean;
pub fn gegl_metadata_iter_init(metadata: *mut GeglMetadata, iter: *mut GeglMetadataIter);
pub fn gegl_metadata_iter_lookup(
metadata: *mut GeglMetadata,
iter: *mut GeglMetadataIter,
key: *const c_char,
) -> gboolean;
pub fn gegl_metadata_iter_next(
metadata: *mut GeglMetadata,
iter: *mut GeglMetadataIter,
) -> *const c_char;
pub fn gegl_metadata_iter_set_value(
metadata: *mut GeglMetadata,
iter: *mut GeglMetadataIter,
value: *const gobject::GValue,
) -> gboolean;
pub fn gegl_metadata_register_map(
metadata: *mut GeglMetadata,
file_module: *const c_char,
flags: c_uint,
map: *const GeglMetadataMap,
n_map: size_t,
);
pub fn gegl_metadata_set_resolution(
metadata: *mut GeglMetadata,
unit: GeglResolutionUnit,
x: c_float,
y: c_float,
) -> gboolean;
pub fn gegl_metadata_unregister_map(metadata: *mut GeglMetadata);
pub fn gegl_apply_op(buffer: *mut GeglBuffer, operation_name: *const c_char, ...);
pub fn gegl_babl_variant(
format: *const babl::Babl,
variant: GeglBablVariant,
) -> *const babl::Babl;
pub fn gegl_calloc(size: size_t, n_memb: c_int) -> gpointer;
pub fn gegl_cl_disable();
pub fn gegl_cl_init(error: *mut *mut glib::GError) -> gboolean;
pub fn gegl_cl_is_accelerated() -> gboolean;
pub fn gegl_config() -> *mut GeglConfig;
pub fn gegl_create_chain(
ops: *const c_char,
op_start: *mut GeglNode,
op_end: *mut GeglNode,
time: c_double,
rel_dim: c_int,
path_root: *const c_char,
error: *mut *mut glib::GError,
);
pub fn gegl_create_chain_argv(
ops: *mut *mut c_char,
op_start: *mut GeglNode,
op_end: *mut GeglNode,
time: c_double,
rel_dim: c_int,
path_root: *const c_char,
error: *mut *mut glib::GError,
);
pub fn gegl_exit();
pub fn gegl_filter_op(
source_buffer: *mut GeglBuffer,
operation_name: *const c_char,
...
) -> *mut GeglBuffer;
pub fn gegl_format(format_name: *const c_char) -> *mut gobject::GValue;
pub fn gegl_format_get_name(format: *mut gobject::GValue) -> *const c_char;
pub fn gegl_free(mem: gpointer);
pub fn gegl_get_option_group() -> *mut glib::GOptionGroup;
pub fn gegl_get_version(major: *mut c_int, minor: *mut c_int, micro: *mut c_int);
pub fn gegl_graph_dump_outputs(node: *mut GeglNode);
pub fn gegl_graph_dump_request(node: *mut GeglNode, roi: *const GeglRectangle);
pub fn gegl_has_operation(operation_type: *const c_char) -> gboolean;
pub fn gegl_init(argc: *mut c_int, argv: *mut *mut *mut c_char);
pub fn gegl_is_main_thread() -> gboolean;
pub fn gegl_list_operations(n_operations_p: *mut c_uint) -> *mut *mut c_char;
pub fn gegl_load_module_directory(path: *const c_char);
pub fn gegl_malloc(n_bytes: size_t) -> gpointer;
pub fn gegl_memeq_zero(ptr: gconstpointer, size: size_t) -> gboolean;
pub fn gegl_memset_pattern(
dst_ptr: gpointer,
src_ptr: gconstpointer,
pattern_size: c_int,
count: c_int,
);
pub fn gegl_parallel_distribute(
max_n: c_int,
func: GeglParallelDistributeFunc,
user_data: gpointer,
);
pub fn gegl_parallel_distribute_area(
area: *const GeglRectangle,
thread_cost: c_double,
split_strategy: GeglSplitStrategy,
func: GeglParallelDistributeAreaFunc,
user_data: gpointer,
);
pub fn gegl_parallel_distribute_range(
size: size_t,
thread_cost: c_double,
func: GeglParallelDistributeRangeFunc,
user_data: gpointer,
);
pub fn gegl_param_spec_audio_fragment(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_color(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
default_color: *mut GeglColor,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_color_from_string(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
default_color_string: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_color_get_default(self_: *mut gobject::GParamSpec) -> *mut GeglColor;
pub fn gegl_param_spec_curve(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
default_curve: *mut GeglCurve,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_double(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
minimum: c_double,
maximum: c_double,
default_value: c_double,
ui_minimum: c_double,
ui_maximum: c_double,
ui_gamma: c_double,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_enum(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
enum_type: GType,
default_value: c_int,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_file_path(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
no_validate: gboolean,
null_ok: gboolean,
default_value: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_format(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_get_property_key(
pspec: *mut gobject::GParamSpec,
key_name: *const c_char,
) -> *const c_char;
pub fn gegl_param_spec_int(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
minimum: c_int,
maximum: c_int,
default_value: c_int,
ui_minimum: c_int,
ui_maximum: c_int,
ui_gamma: c_double,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_path(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
default_path: *mut GeglPath,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_seed(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_set_property_key(
pspec: *mut gobject::GParamSpec,
key_name: *const c_char,
value: *const c_char,
);
pub fn gegl_param_spec_string(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
no_validate: gboolean,
null_ok: gboolean,
default_value: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_param_spec_uri(
name: *const c_char,
nick: *const c_char,
blurb: *const c_char,
no_validate: gboolean,
null_ok: gboolean,
default_value: *const c_char,
flags: gobject::GParamFlags,
) -> *mut gobject::GParamSpec;
pub fn gegl_render_op(
source_buffer: *mut GeglBuffer,
target_buffer: *mut GeglBuffer,
operation_name: *const c_char,
...
);
pub fn gegl_reset_stats();
pub fn gegl_scratch_alloc(size: size_t) -> gpointer;
pub fn gegl_scratch_alloc0(size: size_t) -> gpointer;
pub fn gegl_scratch_free(ptr: gpointer);
pub fn gegl_serialize(
start: *mut GeglNode,
end: *mut GeglNode,
basepath: *const c_char,
serialize_flags: GeglSerializeFlag,
) -> *mut c_char;
pub fn gegl_stats() -> *mut GeglStats;
pub fn gegl_try_malloc(n_bytes: size_t) -> gpointer;
}