1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7 clippy::approx_constant,
8 clippy::type_complexity,
9 clippy::unreadable_literal,
10 clippy::upper_case_acronyms
11)]
12#![cfg_attr(docsrs, feature(doc_cfg))]
13
14use babl_sys as babl;
15use glib_sys as glib;
16use gobject_sys as gobject;
17
18#[allow(unused_imports)]
19use libc::{
20 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
21 intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE,
22};
23#[cfg(unix)]
24#[allow(unused_imports)]
25use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
26
27#[allow(unused_imports)]
28use glib::{gboolean, gconstpointer, gpointer, GType};
29
30pub type GeglAbyssPolicy = c_int;
32pub const GEGL_ABYSS_NONE: GeglAbyssPolicy = 0;
33pub const GEGL_ABYSS_CLAMP: GeglAbyssPolicy = 1;
34pub const GEGL_ABYSS_LOOP: GeglAbyssPolicy = 2;
35pub const GEGL_ABYSS_BLACK: GeglAbyssPolicy = 3;
36pub const GEGL_ABYSS_WHITE: GeglAbyssPolicy = 4;
37
38pub type GeglBablVariant = c_int;
39pub const GEGL_BABL_VARIANT_FLOAT: GeglBablVariant = 0;
40pub const GEGL_BABL_VARIANT_LINEAR: GeglBablVariant = 1;
41pub const GEGL_BABL_VARIANT_NONLINEAR: GeglBablVariant = 2;
42pub const GEGL_BABL_VARIANT_PERCEPTUAL: GeglBablVariant = 3;
43pub const GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED: GeglBablVariant = 4;
44pub const GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED: GeglBablVariant = 5;
45pub const GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED_IF_ALPHA: GeglBablVariant = 6;
46pub const GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED_IF_ALPHA: GeglBablVariant = 7;
47pub const GEGL_BABL_VARIANT_ALPHA: GeglBablVariant = 8;
48
49pub type GeglCachePolicy = c_int;
50pub const GEGL_CACHE_POLICY_AUTO: GeglCachePolicy = 0;
51pub const GEGL_CACHE_POLICY_NEVER: GeglCachePolicy = 1;
52pub const GEGL_CACHE_POLICY_ALWAYS: GeglCachePolicy = 2;
53
54pub type GeglDistanceMetric = c_int;
55pub const GEGL_DISTANCE_METRIC_EUCLIDEAN: GeglDistanceMetric = 0;
56pub const GEGL_DISTANCE_METRIC_MANHATTAN: GeglDistanceMetric = 1;
57pub const GEGL_DISTANCE_METRIC_CHEBYSHEV: GeglDistanceMetric = 2;
58
59pub type GeglDitherMethod = c_int;
60pub const GEGL_DITHER_NONE: GeglDitherMethod = 0;
61pub const GEGL_DITHER_FLOYD_STEINBERG: GeglDitherMethod = 1;
62pub const GEGL_DITHER_BAYER: GeglDitherMethod = 2;
63pub const GEGL_DITHER_RANDOM: GeglDitherMethod = 3;
64pub const GEGL_DITHER_RANDOM_COVARIANT: GeglDitherMethod = 4;
65pub const GEGL_DITHER_ARITHMETIC_ADD: GeglDitherMethod = 5;
66pub const GEGL_DITHER_ARITHMETIC_ADD_COVARIANT: GeglDitherMethod = 6;
67pub const GEGL_DITHER_ARITHMETIC_XOR: GeglDitherMethod = 7;
68pub const GEGL_DITHER_ARITHMETIC_XOR_COVARIANT: GeglDitherMethod = 8;
69pub const GEGL_DITHER_BLUE_NOISE: GeglDitherMethod = 9;
70pub const GEGL_DITHER_BLUE_NOISE_COVARIANT: GeglDitherMethod = 10;
71
72pub type GeglMapFlags = c_int;
73pub const GEGL_MAP_EXCLUDE_UNMAPPED: GeglMapFlags = 1;
74
75pub type GeglOrientation = c_int;
76pub const GEGL_ORIENTATION_HORIZONTAL: GeglOrientation = 0;
77pub const GEGL_ORIENTATION_VERTICAL: GeglOrientation = 1;
78
79pub type GeglRectangleAlignment = c_int;
80pub const GEGL_RECTANGLE_ALIGNMENT_SUBSET: GeglRectangleAlignment = 0;
81pub const GEGL_RECTANGLE_ALIGNMENT_SUPERSET: GeglRectangleAlignment = 1;
82pub const GEGL_RECTANGLE_ALIGNMENT_NEAREST: GeglRectangleAlignment = 2;
83
84pub type GeglResolutionUnit = c_int;
85pub const GEGL_RESOLUTION_UNIT_NONE: GeglResolutionUnit = 0;
86pub const GEGL_RESOLUTION_UNIT_DPI: GeglResolutionUnit = 1;
87pub const GEGL_RESOLUTION_UNIT_DPM: GeglResolutionUnit = 2;
88
89pub type GeglSamplerType = c_int;
90pub const GEGL_SAMPLER_NEAREST: GeglSamplerType = 0;
91pub const GEGL_SAMPLER_LINEAR: GeglSamplerType = 1;
92pub const GEGL_SAMPLER_CUBIC: GeglSamplerType = 2;
93pub const GEGL_SAMPLER_NOHALO: GeglSamplerType = 3;
94pub const GEGL_SAMPLER_LOHALO: GeglSamplerType = 4;
95
96pub type GeglSplitStrategy = c_int;
97pub const GEGL_SPLIT_STRATEGY_AUTO: GeglSplitStrategy = 0;
98pub const GEGL_SPLIT_STRATEGY_HORIZONTAL: GeglSplitStrategy = 1;
99pub const GEGL_SPLIT_STRATEGY_VERTICAL: GeglSplitStrategy = 2;
100
101pub type GeglTileCommand = c_int;
102pub const GEGL_TILE_IDLE: GeglTileCommand = 0;
103pub const GEGL_TILE_SET: GeglTileCommand = 1;
104pub const GEGL_TILE_GET: GeglTileCommand = 2;
105pub const GEGL_TILE_IS_CACHED: GeglTileCommand = 3;
106pub const GEGL_TILE_EXIST: GeglTileCommand = 4;
107pub const GEGL_TILE_VOID: GeglTileCommand = 5;
108pub const GEGL_TILE_FLUSH: GeglTileCommand = 6;
109pub const GEGL_TILE_REFETCH: GeglTileCommand = 7;
110pub const GEGL_TILE_REINIT: GeglTileCommand = 8;
111pub const _GEGL_TILE_LAST_0_4_8_COMMAND: GeglTileCommand = 9;
112pub const GEGL_TILE_COPY: GeglTileCommand = 9;
113pub const GEGL_TILE_LAST_COMMAND: GeglTileCommand = 10;
114
115pub const GEGL_AUTO_ROWSTRIDE: c_int = 0;
117pub const GEGL_CH_BACK_CENTER: c_int = 256;
118pub const GEGL_CH_BACK_LEFT: c_int = 16;
119pub const GEGL_CH_BACK_RIGHT: c_int = 32;
120pub const GEGL_CH_FRONT_CENTER: c_int = 4;
121pub const GEGL_CH_FRONT_LEFT: c_int = 1;
122pub const GEGL_CH_FRONT_LEFT_OF_CENTER: c_int = 64;
123pub const GEGL_CH_FRONT_RIGHT: c_int = 2;
124pub const GEGL_CH_FRONT_RIGHT_OF_CENTER: c_int = 128;
125pub const GEGL_CH_LAYOUT_2POINT1: c_int = 11;
126pub const GEGL_CH_LAYOUT_2_1: c_int = 259;
127pub const GEGL_CH_LAYOUT_2_2: c_int = 1539;
128pub const GEGL_CH_LAYOUT_3POINT1: c_int = 15;
129pub const GEGL_CH_LAYOUT_4POINT0: c_int = 263;
130pub const GEGL_CH_LAYOUT_4POINT1: c_int = 271;
131pub const GEGL_CH_LAYOUT_5POINT0: c_int = 1543;
132pub const GEGL_CH_LAYOUT_5POINT0_BACK: c_int = 55;
133pub const GEGL_CH_LAYOUT_5POINT1: c_int = 1551;
134pub const GEGL_CH_LAYOUT_5POINT1_BACK: c_int = 63;
135pub const GEGL_CH_LAYOUT_6POINT0: c_int = 1799;
136pub const GEGL_CH_LAYOUT_6POINT0_FRONT: c_int = 1731;
137pub const GEGL_CH_LAYOUT_6POINT1: c_int = 1807;
138pub const GEGL_CH_LAYOUT_6POINT1_BACK: c_int = 319;
139pub const GEGL_CH_LAYOUT_6POINT1_FRONT: c_int = 1739;
140pub const GEGL_CH_LAYOUT_7POINT0: c_int = 1591;
141pub const GEGL_CH_LAYOUT_7POINT0_FRONT: c_int = 1735;
142pub const GEGL_CH_LAYOUT_7POINT1: c_int = 1599;
143pub const GEGL_CH_LAYOUT_7POINT1_WIDE: c_int = 1743;
144pub const GEGL_CH_LAYOUT_7POINT1_WIDE_BACK: c_int = 255;
145pub const GEGL_CH_LAYOUT_HEXADECAGONAL: c_long = 6442710839;
146pub const GEGL_CH_LAYOUT_HEXAGONAL: c_int = 311;
147pub const GEGL_CH_LAYOUT_NATIVE: u64 = 9223372036854775808;
148pub const GEGL_CH_LAYOUT_OCTAGONAL: c_int = 1847;
149pub const GEGL_CH_LAYOUT_QUAD: c_int = 51;
150pub const GEGL_CH_LAYOUT_STEREO: c_int = 3;
151pub const GEGL_CH_LAYOUT_STEREO_DOWNMIX: c_int = 1610612736;
152pub const GEGL_CH_LAYOUT_SURROUND: c_int = 7;
153pub const GEGL_CH_LOW_FREQUENCY: c_int = 8;
154pub const GEGL_CH_LOW_FREQUENCY_2: c_long = 34359738368;
155pub const GEGL_CH_SIDE_LEFT: c_int = 512;
156pub const GEGL_CH_SIDE_RIGHT: c_int = 1024;
157pub const GEGL_CH_STEREO_LEFT: c_int = 536870912;
158pub const GEGL_CH_STEREO_RIGHT: c_int = 1073741824;
159pub const GEGL_CH_SURROUND_DIRECT_LEFT: c_long = 8589934592;
160pub const GEGL_CH_SURROUND_DIRECT_RIGHT: c_long = 17179869184;
161pub const GEGL_CH_TOP_BACK_CENTER: c_int = 65536;
162pub const GEGL_CH_TOP_BACK_LEFT: c_int = 32768;
163pub const GEGL_CH_TOP_BACK_RIGHT: c_int = 131072;
164pub const GEGL_CH_TOP_CENTER: c_int = 2048;
165pub const GEGL_CH_TOP_FRONT_CENTER: c_int = 8192;
166pub const GEGL_CH_TOP_FRONT_LEFT: c_int = 4096;
167pub const GEGL_CH_TOP_FRONT_RIGHT: c_int = 16384;
168pub const GEGL_CH_WIDE_LEFT: c_long = 2147483648;
169pub const GEGL_CH_WIDE_RIGHT: c_long = 4294967296;
170pub const GEGL_FLOAT_EPSILON: c_double = 0.000010;
171pub const GEGL_LOOKUP_MAX_ENTRIES: c_int = 819200;
172pub const GEGL_MAX_AUDIO_CHANNELS: c_int = 8;
173
174pub type GeglAccessMode = c_uint;
176pub const GEGL_ACCESS_READ: GeglAccessMode = 1;
177pub const GEGL_ACCESS_WRITE: GeglAccessMode = 2;
178pub const GEGL_ACCESS_READWRITE: GeglAccessMode = 3;
179
180pub type GeglBlitFlags = c_uint;
181pub const GEGL_BLIT_DEFAULT: GeglBlitFlags = 0;
182pub const GEGL_BLIT_CACHE: GeglBlitFlags = 1;
183pub const GEGL_BLIT_DIRTY: GeglBlitFlags = 2;
184
185pub type GeglPadType = c_uint;
186pub const GEGL_PARAM_PAD_OUTPUT: GeglPadType = 256;
187pub const GEGL_PARAM_PAD_INPUT: GeglPadType = 512;
188
189pub type GeglSerializeFlag = c_uint;
190pub const GEGL_SERIALIZE_TRIM_DEFAULTS: GeglSerializeFlag = 1;
191pub const GEGL_SERIALIZE_VERSION: GeglSerializeFlag = 2;
192pub const GEGL_SERIALIZE_INDENT: GeglSerializeFlag = 4;
193pub const GEGL_SERIALIZE_BAKE_ANIM: GeglSerializeFlag = 8;
194
195pub type GeglFlattenerFunc = Option<unsafe extern "C" fn(*mut GeglPathList) -> *mut GeglPathList>;
197pub type GeglLookupFunction = Option<unsafe extern "C" fn(c_float, gpointer) -> c_float>;
198pub type GeglNodeFunction = Option<unsafe extern "C" fn(*const GeglPathItem, gpointer)>;
199pub type GeglParallelDistributeAreaFunc =
200 Option<unsafe extern "C" fn(*const GeglRectangle, gpointer)>;
201pub type GeglParallelDistributeFunc = Option<unsafe extern "C" fn(c_int, c_int, gpointer)>;
202pub type GeglParallelDistributeRangeFunc = Option<unsafe extern "C" fn(size_t, size_t, gpointer)>;
203pub type GeglSamplerGetFun = Option<
204 unsafe extern "C" fn(
205 *mut GeglSampler,
206 c_double,
207 c_double,
208 *mut GeglBufferMatrix2,
209 *mut c_void,
210 GeglAbyssPolicy,
211 ),
212>;
213pub type GeglTileCallback = Option<unsafe extern "C" fn(*mut GeglTile, gpointer)>;
214pub type GeglTileSourceCommand = Option<
215 unsafe extern "C" fn(
216 *mut GeglTileSource,
217 GeglTileCommand,
218 c_int,
219 c_int,
220 c_int,
221 gpointer,
222 ) -> gpointer,
223>;
224
225#[derive(Copy, Clone)]
227#[repr(C)]
228pub struct GeglAudioFragmentClass {
229 pub parent_class: gobject::GObjectClass,
230}
231
232impl ::std::fmt::Debug for GeglAudioFragmentClass {
233 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
234 f.debug_struct(&format!("GeglAudioFragmentClass @ {self:p}"))
235 .field("parent_class", &self.parent_class)
236 .finish()
237 }
238}
239
240#[repr(C)]
241pub struct _GeglAudioFragmentPrivate {
242 _data: [u8; 0],
243 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
244}
245
246pub type GeglAudioFragmentPrivate = _GeglAudioFragmentPrivate;
247
248#[derive(Copy, Clone)]
249#[repr(C)]
250pub struct GeglBufferIterator {
251 pub length: c_int,
252 pub priv_: *mut GeglBufferIteratorPriv,
253}
254
255impl ::std::fmt::Debug for GeglBufferIterator {
256 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
257 f.debug_struct(&format!("GeglBufferIterator @ {self:p}"))
258 .field("length", &self.length)
259 .field("priv_", &self.priv_)
260 .finish()
261 }
262}
263
264#[derive(Copy, Clone)]
265#[repr(C)]
266pub struct GeglBufferIteratorItem {
267 pub data: gpointer,
268 pub roi: GeglRectangle,
269}
270
271impl ::std::fmt::Debug for GeglBufferIteratorItem {
272 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
273 f.debug_struct(&format!("GeglBufferIteratorItem @ {self:p}"))
274 .field("data", &self.data)
275 .field("roi", &self.roi)
276 .finish()
277 }
278}
279
280#[repr(C)]
281pub struct _GeglBufferIteratorPriv {
282 _data: [u8; 0],
283 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
284}
285
286pub type GeglBufferIteratorPriv = _GeglBufferIteratorPriv;
287
288#[derive(Copy, Clone)]
289#[repr(C)]
290pub struct GeglBufferMatrix2 {
291 pub coeff: [c_double; 4],
292}
293
294impl ::std::fmt::Debug for GeglBufferMatrix2 {
295 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
296 f.debug_struct(&format!("GeglBufferMatrix2 @ {self:p}"))
297 .field("coeff", &self.coeff)
298 .finish()
299 }
300}
301
302#[derive(Copy, Clone)]
303#[repr(C)]
304pub struct GeglColorClass {
305 pub parent_class: gobject::GObjectClass,
306}
307
308impl ::std::fmt::Debug for GeglColorClass {
309 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
310 f.debug_struct(&format!("GeglColorClass @ {self:p}"))
311 .field("parent_class", &self.parent_class)
312 .finish()
313 }
314}
315
316#[repr(C)]
317pub struct _GeglColorPrivate {
318 _data: [u8; 0],
319 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
320}
321
322pub type GeglColorPrivate = _GeglColorPrivate;
323
324#[derive(Copy, Clone)]
325#[repr(C)]
326pub struct GeglCurveClass {
327 pub parent_class: gobject::GObjectClass,
328}
329
330impl ::std::fmt::Debug for GeglCurveClass {
331 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
332 f.debug_struct(&format!("GeglCurveClass @ {self:p}"))
333 .field("parent_class", &self.parent_class)
334 .finish()
335 }
336}
337
338#[repr(C)]
339pub struct GeglLookup {
340 pub function: GeglLookupFunction,
341 pub data: gpointer,
342 pub shift: c_int,
343 pub positive_min: u32,
344 pub positive_max: u32,
345 pub negative_min: u32,
346 pub negative_max: u32,
347 pub bitmask: [u32; 25600],
348 _truncated_record_marker: c_void,
349 }
351
352impl ::std::fmt::Debug for GeglLookup {
353 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
354 f.debug_struct(&format!("GeglLookup @ {self:p}"))
355 .field("function", &self.function)
356 .field("data", &self.data)
357 .field("shift", &self.shift)
358 .field("positive_min", &self.positive_min)
359 .field("positive_max", &self.positive_max)
360 .field("negative_min", &self.negative_min)
361 .field("negative_max", &self.negative_max)
362 .finish()
363 }
364}
365
366#[derive(Copy, Clone)]
367#[repr(C)]
368pub struct GeglMatrix3 {
369 pub coeff: [c_double; 9],
370}
371
372impl ::std::fmt::Debug for GeglMatrix3 {
373 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
374 f.debug_struct(&format!("GeglMatrix3 @ {self:p}"))
375 .field("coeff", &self.coeff)
376 .finish()
377 }
378}
379
380#[derive(Copy, Clone)]
381#[repr(C)]
382pub struct GeglMetadataHashClass {
383 pub parent_class: GeglMetadataStoreClass,
384}
385
386impl ::std::fmt::Debug for GeglMetadataHashClass {
387 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
388 f.debug_struct(&format!("GeglMetadataHashClass @ {self:p}"))
389 .field("parent_class", &self.parent_class)
390 .finish()
391 }
392}
393
394#[derive(Copy, Clone)]
395#[repr(C)]
396pub struct GeglMetadataInterface {
397 pub base_iface: gobject::GTypeInterface,
398 pub register_map: Option<
399 unsafe extern "C" fn(
400 *mut GeglMetadata,
401 *const c_char,
402 c_uint,
403 *const GeglMetadataMap,
404 size_t,
405 ),
406 >,
407 pub set_resolution: Option<
408 unsafe extern "C" fn(
409 *mut GeglMetadata,
410 *mut GeglResolutionUnit,
411 *mut c_float,
412 *mut c_float,
413 ) -> gboolean,
414 >,
415 pub get_resolution: Option<
416 unsafe extern "C" fn(
417 *mut GeglMetadata,
418 *mut GeglResolutionUnit,
419 *mut c_float,
420 *mut c_float,
421 ) -> gboolean,
422 >,
423 pub iter_lookup: Option<
424 unsafe extern "C" fn(*mut GeglMetadata, *mut GeglMetadataIter, *const c_char) -> gboolean,
425 >,
426 pub iter_init: Option<unsafe extern "C" fn(*mut GeglMetadata, *mut GeglMetadataIter)>,
427 pub iter_next:
428 Option<unsafe extern "C" fn(*mut GeglMetadata, *mut GeglMetadataIter) -> *const c_char>,
429 pub iter_set_value: Option<
430 unsafe extern "C" fn(
431 *mut GeglMetadata,
432 *mut GeglMetadataIter,
433 *mut gobject::GValue,
434 ) -> gboolean,
435 >,
436 pub iter_get_value: Option<
437 unsafe extern "C" fn(
438 *mut GeglMetadata,
439 *mut GeglMetadataIter,
440 *mut gobject::GValue,
441 ) -> gboolean,
442 >,
443}
444
445impl ::std::fmt::Debug for GeglMetadataInterface {
446 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
447 f.debug_struct(&format!("GeglMetadataInterface @ {self:p}"))
448 .field("register_map", &self.register_map)
449 .field("set_resolution", &self.set_resolution)
450 .field("get_resolution", &self.get_resolution)
451 .field("iter_lookup", &self.iter_lookup)
452 .field("iter_init", &self.iter_init)
453 .field("iter_next", &self.iter_next)
454 .field("iter_set_value", &self.iter_set_value)
455 .field("iter_get_value", &self.iter_get_value)
456 .finish()
457 }
458}
459
460#[derive(Copy, Clone)]
461#[repr(C)]
462pub struct GeglMetadataIter {
463 pub stamp: c_uint,
464 pub user_data: gpointer,
465 pub user_data2: gpointer,
466 pub user_data3: gpointer,
467}
468
469impl ::std::fmt::Debug for GeglMetadataIter {
470 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
471 f.debug_struct(&format!("GeglMetadataIter @ {self:p}"))
472 .finish()
473 }
474}
475
476#[derive(Copy, Clone)]
477#[repr(C)]
478pub struct GeglMetadataMap {
479 pub local_name: *const c_char,
480 pub name: *const c_char,
481 pub transform: gobject::GValueTransform,
482}
483
484impl ::std::fmt::Debug for GeglMetadataMap {
485 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
486 f.debug_struct(&format!("GeglMetadataMap @ {self:p}"))
487 .field("local_name", &self.local_name)
488 .field("name", &self.name)
489 .field("transform", &self.transform)
490 .finish()
491 }
492}
493
494#[derive(Copy, Clone)]
495#[repr(C)]
496pub struct GeglMetadataStoreClass {
497 pub parent_class: gobject::GObjectClass,
498 pub _declare:
499 Option<unsafe extern "C" fn(*mut GeglMetadataStore, *mut gobject::GParamSpec, gboolean)>,
500 pub pspec: Option<
501 unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char) -> *mut gobject::GParamSpec,
502 >,
503 pub set_value:
504 Option<unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char, *const gobject::GValue)>,
505 pub _get_value: Option<
506 unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char) -> *const gobject::GValue,
507 >,
508 pub has_value: Option<unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char) -> gboolean>,
509 pub register_hook: Option<unsafe extern "C" fn(*mut GeglMetadataStore, *const c_char, c_uint)>,
510 pub parse_value: Option<
511 unsafe extern "C" fn(
512 *mut GeglMetadataStore,
513 *mut gobject::GParamSpec,
514 gobject::GValueTransform,
515 *mut gobject::GValue,
516 ) -> gboolean,
517 >,
518 pub generate_value: Option<
519 unsafe extern "C" fn(
520 *mut GeglMetadataStore,
521 *mut gobject::GParamSpec,
522 gobject::GValueTransform,
523 *mut gobject::GValue,
524 ) -> gboolean,
525 >,
526 pub padding: [gpointer; 4],
527}
528
529impl ::std::fmt::Debug for GeglMetadataStoreClass {
530 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
531 f.debug_struct(&format!("GeglMetadataStoreClass @ {self:p}"))
532 .field("_declare", &self._declare)
533 .field("pspec", &self.pspec)
534 .field("set_value", &self.set_value)
535 .field("_get_value", &self._get_value)
536 .field("has_value", &self.has_value)
537 .field("register_hook", &self.register_hook)
538 .field("parse_value", &self.parse_value)
539 .field("generate_value", &self.generate_value)
540 .finish()
541 }
542}
543
544#[repr(C)]
545pub struct _GeglOperationContext {
546 _data: [u8; 0],
547 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
548}
549
550pub type GeglOperationContext = _GeglOperationContext;
551
552#[derive(Copy, Clone)]
553#[repr(C)]
554pub struct GeglParamSpecDouble {
555 pub parent_instance: gobject::GParamSpecDouble,
556 pub ui_minimum: c_double,
557 pub ui_maximum: c_double,
558 pub ui_gamma: c_double,
559 pub ui_step_small: c_double,
560 pub ui_step_big: c_double,
561 pub ui_digits: c_int,
562}
563
564impl ::std::fmt::Debug for GeglParamSpecDouble {
565 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
566 f.debug_struct(&format!("GeglParamSpecDouble @ {self:p}"))
567 .field("parent_instance", &self.parent_instance)
568 .field("ui_minimum", &self.ui_minimum)
569 .field("ui_maximum", &self.ui_maximum)
570 .field("ui_gamma", &self.ui_gamma)
571 .field("ui_step_small", &self.ui_step_small)
572 .field("ui_step_big", &self.ui_step_big)
573 .field("ui_digits", &self.ui_digits)
574 .finish()
575 }
576}
577
578#[derive(Copy, Clone)]
579#[repr(C)]
580pub struct GeglParamSpecEnum {
581 pub parent_instance: gobject::GParamSpecEnum,
582 pub excluded_values: *mut glib::GSList,
583}
584
585impl ::std::fmt::Debug for GeglParamSpecEnum {
586 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
587 f.debug_struct(&format!("GeglParamSpecEnum @ {self:p}"))
588 .field("parent_instance", &self.parent_instance)
589 .field("excluded_values", &self.excluded_values)
590 .finish()
591 }
592}
593
594#[repr(C)]
595pub struct GeglParamSpecFilePath {
596 _truncated_record_marker: c_void,
597 }
599
600impl ::std::fmt::Debug for GeglParamSpecFilePath {
601 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
602 f.debug_struct(&format!("GeglParamSpecFilePath @ {self:p}"))
603 .finish()
604 }
605}
606
607#[derive(Copy, Clone)]
608#[repr(C)]
609pub struct GeglParamSpecFormat {
610 pub parent_instance: gobject::GParamSpecPointer,
611}
612
613impl ::std::fmt::Debug for GeglParamSpecFormat {
614 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
615 f.debug_struct(&format!("GeglParamSpecFormat @ {self:p}"))
616 .field("parent_instance", &self.parent_instance)
617 .finish()
618 }
619}
620
621#[derive(Copy, Clone)]
622#[repr(C)]
623pub struct GeglParamSpecInt {
624 pub parent_instance: gobject::GParamSpecInt,
625 pub ui_minimum: c_int,
626 pub ui_maximum: c_int,
627 pub ui_gamma: c_double,
628 pub ui_step_small: c_int,
629 pub ui_step_big: c_int,
630}
631
632impl ::std::fmt::Debug for GeglParamSpecInt {
633 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
634 f.debug_struct(&format!("GeglParamSpecInt @ {self:p}"))
635 .field("parent_instance", &self.parent_instance)
636 .field("ui_minimum", &self.ui_minimum)
637 .field("ui_maximum", &self.ui_maximum)
638 .field("ui_gamma", &self.ui_gamma)
639 .field("ui_step_small", &self.ui_step_small)
640 .field("ui_step_big", &self.ui_step_big)
641 .finish()
642 }
643}
644
645#[derive(Copy, Clone)]
646#[repr(C)]
647pub struct GeglParamSpecSeed {
648 pub parent_instance: gobject::GParamSpecUInt,
649 pub ui_minimum: c_uint,
650 pub ui_maximum: c_uint,
651}
652
653impl ::std::fmt::Debug for GeglParamSpecSeed {
654 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
655 f.debug_struct(&format!("GeglParamSpecSeed @ {self:p}"))
656 .field("parent_instance", &self.parent_instance)
657 .field("ui_minimum", &self.ui_minimum)
658 .field("ui_maximum", &self.ui_maximum)
659 .finish()
660 }
661}
662
663#[repr(C)]
664pub struct GeglParamSpecString {
665 _truncated_record_marker: c_void,
666 }
668
669impl ::std::fmt::Debug for GeglParamSpecString {
670 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
671 f.debug_struct(&format!("GeglParamSpecString @ {self:p}"))
672 .finish()
673 }
674}
675
676#[repr(C)]
677pub struct GeglParamSpecUri {
678 _truncated_record_marker: c_void,
679 }
681
682impl ::std::fmt::Debug for GeglParamSpecUri {
683 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
684 f.debug_struct(&format!("GeglParamSpecUri @ {self:p}"))
685 .finish()
686 }
687}
688
689#[repr(C)]
690pub struct _GeglPathClass {
691 _data: [u8; 0],
692 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
693}
694
695pub type GeglPathClass = _GeglPathClass;
696
697#[derive(Copy, Clone)]
698#[repr(C)]
699pub struct GeglPathItem {
700 pub type_: c_char,
701 pub point: [GeglPathPoint; 4],
702}
703
704impl ::std::fmt::Debug for GeglPathItem {
705 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
706 f.debug_struct(&format!("GeglPathItem @ {self:p}"))
707 .field("type_", &self.type_)
708 .field("point", &self.point)
709 .finish()
710 }
711}
712
713#[derive(Copy, Clone)]
714#[repr(C)]
715pub struct GeglPathList {
716 pub next: *mut GeglPathList,
717 pub d: GeglPathItem,
718}
719
720impl ::std::fmt::Debug for GeglPathList {
721 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
722 f.debug_struct(&format!("GeglPathList @ {self:p}"))
723 .field("next", &self.next)
724 .field("d", &self.d)
725 .finish()
726 }
727}
728
729#[derive(Copy, Clone)]
730#[repr(C)]
731pub struct GeglPathPoint {
732 pub x: c_float,
733 pub y: c_float,
734}
735
736impl ::std::fmt::Debug for GeglPathPoint {
737 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
738 f.debug_struct(&format!("GeglPathPoint @ {self:p}"))
739 .field("x", &self.x)
740 .field("y", &self.y)
741 .finish()
742 }
743}
744
745#[repr(C)]
746pub struct GeglRandom {
747 _data: [u8; 0],
748 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
749}
750
751impl ::std::fmt::Debug for GeglRandom {
752 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
753 f.debug_struct(&format!("GeglRandom @ {self:p}")).finish()
754 }
755}
756
757#[derive(Copy, Clone)]
758#[repr(C)]
759pub struct GeglRectangle {
760 pub x: c_int,
761 pub y: c_int,
762 pub width: c_int,
763 pub height: c_int,
764}
765
766impl ::std::fmt::Debug for GeglRectangle {
767 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
768 f.debug_struct(&format!("GeglRectangle @ {self:p}"))
769 .field("x", &self.x)
770 .field("y", &self.y)
771 .field("width", &self.width)
772 .field("height", &self.height)
773 .finish()
774 }
775}
776
777#[repr(C)]
778pub struct _GeglSampler {
779 _data: [u8; 0],
780 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
781}
782
783pub type GeglSampler = _GeglSampler;
784
785#[repr(C)]
786pub struct _GeglTile {
787 _data: [u8; 0],
788 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
789}
790
791pub type GeglTile = _GeglTile;
792
793#[derive(Copy, Clone)]
794#[repr(C)]
795pub struct GeglTileBackendClass {
796 pub parent_class: GeglTileSourceClass,
797 pub padding: [gpointer; 4],
798}
799
800impl ::std::fmt::Debug for GeglTileBackendClass {
801 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
802 f.debug_struct(&format!("GeglTileBackendClass @ {self:p}"))
803 .field("parent_class", &self.parent_class)
804 .field("padding", &self.padding)
805 .finish()
806 }
807}
808
809#[repr(C)]
810pub struct _GeglTileBackendPrivate {
811 _data: [u8; 0],
812 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
813}
814
815pub type GeglTileBackendPrivate = _GeglTileBackendPrivate;
816
817#[derive(Copy, Clone)]
818#[repr(C)]
819pub struct GeglTileCopyParams {
820 pub dst_buffer: *mut GeglBuffer,
821 pub dst_x: c_int,
822 pub dst_y: c_int,
823 pub dst_z: c_int,
824}
825
826impl ::std::fmt::Debug for GeglTileCopyParams {
827 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
828 f.debug_struct(&format!("GeglTileCopyParams @ {self:p}"))
829 .field("dst_buffer", &self.dst_buffer)
830 .field("dst_x", &self.dst_x)
831 .field("dst_y", &self.dst_y)
832 .field("dst_z", &self.dst_z)
833 .finish()
834 }
835}
836
837#[derive(Copy, Clone)]
838#[repr(C)]
839pub struct GeglTileHandlerClass {
840 pub parent_class: GeglTileSourceClass,
841}
842
843impl ::std::fmt::Debug for GeglTileHandlerClass {
844 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
845 f.debug_struct(&format!("GeglTileHandlerClass @ {self:p}"))
846 .field("parent_class", &self.parent_class)
847 .finish()
848 }
849}
850
851#[repr(C)]
852pub struct _GeglTileHandlerPrivate {
853 _data: [u8; 0],
854 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
855}
856
857pub type GeglTileHandlerPrivate = _GeglTileHandlerPrivate;
858
859#[derive(Copy, Clone)]
860#[repr(C)]
861pub struct GeglTileSourceClass {
862 pub parent_class: gobject::GObjectClass,
863 pub padding: [gpointer; 4],
864}
865
866impl ::std::fmt::Debug for GeglTileSourceClass {
867 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
868 f.debug_struct(&format!("GeglTileSourceClass @ {self:p}"))
869 .field("parent_class", &self.parent_class)
870 .field("padding", &self.padding)
871 .finish()
872 }
873}
874
875#[derive(Copy, Clone)]
877#[repr(C)]
878pub struct GeglAudioFragment {
879 pub parent_instance: gobject::GObject,
880 pub data: [*mut c_float; 8],
881 pub priv_: *mut GeglAudioFragmentPrivate,
882}
883
884impl ::std::fmt::Debug for GeglAudioFragment {
885 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
886 f.debug_struct(&format!("GeglAudioFragment @ {self:p}"))
887 .field("parent_instance", &self.parent_instance)
888 .field("data", &self.data)
889 .field("priv_", &self.priv_)
890 .finish()
891 }
892}
893
894#[repr(C)]
895pub struct GeglBuffer {
896 _data: [u8; 0],
897 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
898}
899
900impl ::std::fmt::Debug for GeglBuffer {
901 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
902 f.debug_struct(&format!("GeglBuffer @ {self:p}")).finish()
903 }
904}
905
906#[derive(Copy, Clone)]
907#[repr(C)]
908pub struct GeglColor {
909 pub parent_instance: gobject::GObject,
910 pub priv_: *mut GeglColorPrivate,
911}
912
913impl ::std::fmt::Debug for GeglColor {
914 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
915 f.debug_struct(&format!("GeglColor @ {self:p}"))
916 .field("parent_instance", &self.parent_instance)
917 .field("priv_", &self.priv_)
918 .finish()
919 }
920}
921
922#[repr(C)]
923pub struct GeglConfig {
924 _data: [u8; 0],
925 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
926}
927
928impl ::std::fmt::Debug for GeglConfig {
929 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
930 f.debug_struct(&format!("GeglConfig @ {self:p}")).finish()
931 }
932}
933
934#[derive(Copy, Clone)]
935#[repr(C)]
936pub struct GeglCurve {
937 pub parent_instance: gobject::GObject,
938}
939
940impl ::std::fmt::Debug for GeglCurve {
941 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
942 f.debug_struct(&format!("GeglCurve @ {self:p}"))
943 .field("parent_instance", &self.parent_instance)
944 .finish()
945 }
946}
947
948#[repr(C)]
949pub struct GeglMetadataHash {
950 _data: [u8; 0],
951 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
952}
953
954impl ::std::fmt::Debug for GeglMetadataHash {
955 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
956 f.debug_struct(&format!("GeglMetadataHash @ {self:p}"))
957 .finish()
958 }
959}
960
961#[derive(Copy, Clone)]
962#[repr(C)]
963pub struct GeglMetadataStore {
964 pub parent_instance: gobject::GObject,
965}
966
967impl ::std::fmt::Debug for GeglMetadataStore {
968 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
969 f.debug_struct(&format!("GeglMetadataStore @ {self:p}"))
970 .field("parent_instance", &self.parent_instance)
971 .finish()
972 }
973}
974
975#[repr(C)]
976pub struct GeglNode {
977 _data: [u8; 0],
978 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
979}
980
981impl ::std::fmt::Debug for GeglNode {
982 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
983 f.debug_struct(&format!("GeglNode @ {self:p}")).finish()
984 }
985}
986
987#[repr(C)]
988pub struct GeglOperation {
989 _data: [u8; 0],
990 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
991}
992
993impl ::std::fmt::Debug for GeglOperation {
994 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
995 f.debug_struct(&format!("GeglOperation @ {self:p}"))
996 .finish()
997 }
998}
999
1000#[repr(C)]
1001pub struct GeglParamAudioFragment {
1002 _data: [u8; 0],
1003 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1004}
1005
1006impl ::std::fmt::Debug for GeglParamAudioFragment {
1007 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1008 f.debug_struct(&format!("GeglParamAudioFragment @ {self:p}"))
1009 .finish()
1010 }
1011}
1012
1013#[repr(C)]
1014pub struct GeglParamColor {
1015 _data: [u8; 0],
1016 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1017}
1018
1019impl ::std::fmt::Debug for GeglParamColor {
1020 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1021 f.debug_struct(&format!("GeglParamColor @ {self:p}"))
1022 .finish()
1023 }
1024}
1025
1026#[repr(C)]
1027pub struct GeglParamCurve {
1028 _data: [u8; 0],
1029 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1030}
1031
1032impl ::std::fmt::Debug for GeglParamCurve {
1033 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1034 f.debug_struct(&format!("GeglParamCurve @ {self:p}"))
1035 .finish()
1036 }
1037}
1038
1039#[repr(C)]
1040pub struct GeglParamDouble {
1041 _data: [u8; 0],
1042 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1043}
1044
1045impl ::std::fmt::Debug for GeglParamDouble {
1046 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1047 f.debug_struct(&format!("GeglParamDouble @ {self:p}"))
1048 .finish()
1049 }
1050}
1051
1052#[repr(C)]
1053pub struct GeglParamEnum {
1054 _data: [u8; 0],
1055 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1056}
1057
1058impl ::std::fmt::Debug for GeglParamEnum {
1059 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1060 f.debug_struct(&format!("GeglParamEnum @ {self:p}"))
1061 .finish()
1062 }
1063}
1064
1065#[repr(C)]
1066pub struct GeglParamFilePath {
1067 _data: [u8; 0],
1068 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1069}
1070
1071impl ::std::fmt::Debug for GeglParamFilePath {
1072 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1073 f.debug_struct(&format!("GeglParamFilePath @ {self:p}"))
1074 .finish()
1075 }
1076}
1077
1078#[repr(C)]
1079pub struct GeglParamFormat {
1080 _data: [u8; 0],
1081 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1082}
1083
1084impl ::std::fmt::Debug for GeglParamFormat {
1085 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1086 f.debug_struct(&format!("GeglParamFormat @ {self:p}"))
1087 .finish()
1088 }
1089}
1090
1091#[repr(C)]
1092pub struct GeglParamInt {
1093 _data: [u8; 0],
1094 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1095}
1096
1097impl ::std::fmt::Debug for GeglParamInt {
1098 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1099 f.debug_struct(&format!("GeglParamInt @ {self:p}")).finish()
1100 }
1101}
1102
1103#[repr(C)]
1104pub struct GeglParamPath {
1105 _data: [u8; 0],
1106 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1107}
1108
1109impl ::std::fmt::Debug for GeglParamPath {
1110 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1111 f.debug_struct(&format!("GeglParamPath @ {self:p}"))
1112 .finish()
1113 }
1114}
1115
1116#[repr(C)]
1117pub struct GeglParamSeed {
1118 _data: [u8; 0],
1119 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1120}
1121
1122impl ::std::fmt::Debug for GeglParamSeed {
1123 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1124 f.debug_struct(&format!("GeglParamSeed @ {self:p}"))
1125 .finish()
1126 }
1127}
1128
1129#[repr(C)]
1130pub struct GeglParamString {
1131 _data: [u8; 0],
1132 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1133}
1134
1135impl ::std::fmt::Debug for GeglParamString {
1136 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1137 f.debug_struct(&format!("GeglParamString @ {self:p}"))
1138 .finish()
1139 }
1140}
1141
1142#[repr(C)]
1143pub struct GeglParamUri {
1144 _data: [u8; 0],
1145 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1146}
1147
1148impl ::std::fmt::Debug for GeglParamUri {
1149 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1150 f.debug_struct(&format!("GeglParamUri @ {self:p}")).finish()
1151 }
1152}
1153
1154#[derive(Copy, Clone)]
1155#[repr(C)]
1156pub struct GeglPath {
1157 pub parent_instance: gobject::GObject,
1158}
1159
1160impl ::std::fmt::Debug for GeglPath {
1161 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1162 f.debug_struct(&format!("GeglPath @ {self:p}"))
1163 .field("parent_instance", &self.parent_instance)
1164 .finish()
1165 }
1166}
1167
1168#[repr(C)]
1169pub struct GeglProcessor {
1170 _data: [u8; 0],
1171 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1172}
1173
1174impl ::std::fmt::Debug for GeglProcessor {
1175 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1176 f.debug_struct(&format!("GeglProcessor @ {self:p}"))
1177 .finish()
1178 }
1179}
1180
1181#[repr(C)]
1182pub struct GeglStats {
1183 _data: [u8; 0],
1184 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1185}
1186
1187impl ::std::fmt::Debug for GeglStats {
1188 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1189 f.debug_struct(&format!("GeglStats @ {self:p}")).finish()
1190 }
1191}
1192
1193#[derive(Copy, Clone)]
1194#[repr(C)]
1195pub struct GeglTileBackend {
1196 pub parent_instance: GeglTileSource,
1197 pub priv_: *mut GeglTileBackendPrivate,
1198}
1199
1200impl ::std::fmt::Debug for GeglTileBackend {
1201 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1202 f.debug_struct(&format!("GeglTileBackend @ {self:p}"))
1203 .field("parent_instance", &self.parent_instance)
1204 .field("priv_", &self.priv_)
1205 .finish()
1206 }
1207}
1208
1209#[derive(Copy, Clone)]
1210#[repr(C)]
1211pub struct GeglTileHandler {
1212 pub parent_instance: GeglTileSource,
1213 pub source: *mut GeglTileSource,
1214 pub priv_: *mut GeglTileHandlerPrivate,
1215}
1216
1217impl ::std::fmt::Debug for GeglTileHandler {
1218 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1219 f.debug_struct(&format!("GeglTileHandler @ {self:p}"))
1220 .field("parent_instance", &self.parent_instance)
1221 .field("source", &self.source)
1222 .field("priv_", &self.priv_)
1223 .finish()
1224 }
1225}
1226
1227#[derive(Copy, Clone)]
1228#[repr(C)]
1229pub struct GeglTileSource {
1230 pub parent_instance: gobject::GObject,
1231 pub command: GeglTileSourceCommand,
1232 pub padding: [gpointer; 4],
1233}
1234
1235impl ::std::fmt::Debug for GeglTileSource {
1236 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1237 f.debug_struct(&format!("GeglTileSource @ {self:p}"))
1238 .field("parent_instance", &self.parent_instance)
1239 .field("command", &self.command)
1240 .field("padding", &self.padding)
1241 .finish()
1242 }
1243}
1244
1245#[repr(C)]
1247pub struct GeglMetadata {
1248 _data: [u8; 0],
1249 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1250}
1251
1252impl ::std::fmt::Debug for GeglMetadata {
1253 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1254 write!(f, "GeglMetadata @ {self:p}")
1255 }
1256}
1257
1258#[link(name = "gegl-0.4")]
1259extern "C" {
1260
1261 pub fn gegl_abyss_policy_get_type() -> GType;
1265
1266 pub fn gegl_babl_variant_get_type() -> GType;
1270
1271 pub fn gegl_cache_policy_get_type() -> GType;
1275
1276 pub fn gegl_distance_metric_get_type() -> GType;
1280
1281 pub fn gegl_dither_method_get_type() -> GType;
1285
1286 pub fn gegl_orientation_get_type() -> GType;
1290
1291 pub fn gegl_rectangle_alignment_get_type() -> GType;
1295
1296 pub fn gegl_resolution_unit_get_type() -> GType;
1300
1301 pub fn gegl_sampler_type_get_type() -> GType;
1305
1306 pub fn gegl_access_mode_get_type() -> GType;
1310
1311 pub fn gegl_buffer_iterator_add(
1315 iterator: *mut GeglBufferIterator,
1316 buffer: *mut GeglBuffer,
1317 roi: *const GeglRectangle,
1318 level: c_int,
1319 format: *const babl::Babl,
1320 access_mode: GeglAccessMode,
1321 abyss_policy: GeglAbyssPolicy,
1322 ) -> c_int;
1323 pub fn gegl_buffer_iterator_next(iterator: *mut GeglBufferIterator) -> gboolean;
1324 pub fn gegl_buffer_iterator_stop(iterator: *mut GeglBufferIterator);
1325 pub fn gegl_buffer_iterator_empty_new(max_slots: c_int) -> *mut GeglBufferIterator;
1326
1327 pub fn gegl_buffer_matrix2_determinant(matrix: *mut GeglBufferMatrix2) -> c_double;
1331 pub fn gegl_buffer_matrix2_is_identity(matrix: *mut GeglBufferMatrix2) -> gboolean;
1332 pub fn gegl_buffer_matrix2_is_scale(matrix: *mut GeglBufferMatrix2) -> gboolean;
1333
1334 pub fn gegl_lookup_free(lookup: *mut GeglLookup);
1338 pub fn gegl_lookup_new(function: GeglLookupFunction, data: gpointer) -> *mut GeglLookup;
1339 pub fn gegl_lookup_new_full(
1340 function: GeglLookupFunction,
1341 data: gpointer,
1342 start: c_float,
1343 end: c_float,
1344 precision: c_float,
1345 ) -> *mut GeglLookup;
1346
1347 pub fn gegl_matrix3_get_type() -> GType;
1351 pub fn gegl_matrix3_new() -> *mut GeglMatrix3;
1352 pub fn gegl_matrix3_copy(matrix: *const GeglMatrix3) -> *mut GeglMatrix3;
1353 pub fn gegl_matrix3_copy_into(dst: *mut GeglMatrix3, src: *const GeglMatrix3);
1354 pub fn gegl_matrix3_determinant(matrix: *const GeglMatrix3) -> c_double;
1355 pub fn gegl_matrix3_equal(matrix1: *const GeglMatrix3, matrix2: *const GeglMatrix3)
1356 -> gboolean;
1357 pub fn gegl_matrix3_identity(matrix: *mut GeglMatrix3);
1358 pub fn gegl_matrix3_invert(matrix: *mut GeglMatrix3);
1359 pub fn gegl_matrix3_is_affine(matrix: *const GeglMatrix3) -> gboolean;
1360 pub fn gegl_matrix3_is_identity(matrix: *const GeglMatrix3) -> gboolean;
1361 pub fn gegl_matrix3_is_scale(matrix: *const GeglMatrix3) -> gboolean;
1362 pub fn gegl_matrix3_is_translate(matrix: *const GeglMatrix3) -> gboolean;
1363 pub fn gegl_matrix3_multiply(
1364 left: *const GeglMatrix3,
1365 right: *const GeglMatrix3,
1366 product: *mut GeglMatrix3,
1367 );
1368 pub fn gegl_matrix3_originate(matrix: *mut GeglMatrix3, x: c_double, y: c_double);
1369 pub fn gegl_matrix3_parse_string(matrix: *mut GeglMatrix3, string: *const c_char);
1370 pub fn gegl_matrix3_round_error(matrix: *mut GeglMatrix3);
1371 pub fn gegl_matrix3_to_string(matrix: *const GeglMatrix3) -> *mut c_char;
1372 pub fn gegl_matrix3_transform_point(
1373 matrix: *const GeglMatrix3,
1374 x: *mut c_double,
1375 y: *mut c_double,
1376 );
1377
1378 pub fn gegl_param_spec_double_set_digits(pspec: *mut GeglParamSpecDouble, digits: c_int);
1382 pub fn gegl_param_spec_double_set_steps(
1383 pspec: *mut GeglParamSpecDouble,
1384 small_step: c_double,
1385 big_step: c_double,
1386 );
1387
1388 pub fn gegl_param_spec_enum_exclude_value(espec: *mut GeglParamSpecEnum, value: c_int);
1392
1393 pub fn gegl_param_spec_int_set_steps(
1397 pspec: *mut GeglParamSpecInt,
1398 small_step: c_int,
1399 big_step: c_int,
1400 );
1401
1402 pub fn gegl_path_list_append(head: *mut GeglPathList, ...) -> *mut GeglPathList;
1406 pub fn gegl_path_list_destroy(path: *mut GeglPathList) -> *mut GeglPathList;
1407
1408 pub fn gegl_path_point_dist(a: *mut GeglPathPoint, b: *mut GeglPathPoint) -> c_double;
1412 pub fn gegl_path_point_lerp(
1413 dest: *mut GeglPathPoint,
1414 a: *mut GeglPathPoint,
1415 b: *mut GeglPathPoint,
1416 t: c_float,
1417 );
1418
1419 pub fn gegl_random_get_type() -> GType;
1423 pub fn gegl_random_new() -> *mut GeglRandom;
1424 pub fn gegl_random_new_with_seed(seed: u32) -> *mut GeglRandom;
1425 pub fn gegl_random_duplicate(rand: *mut GeglRandom) -> *mut GeglRandom;
1426 pub fn gegl_random_float(
1427 rand: *const GeglRandom,
1428 x: c_int,
1429 y: c_int,
1430 z: c_int,
1431 n: c_int,
1432 ) -> c_float;
1433 pub fn gegl_random_float_range(
1434 rand: *const GeglRandom,
1435 x: c_int,
1436 y: c_int,
1437 z: c_int,
1438 n: c_int,
1439 min: c_float,
1440 max: c_float,
1441 ) -> c_float;
1442 pub fn gegl_random_free(rand: *mut GeglRandom);
1443 pub fn gegl_random_int(rand: *const GeglRandom, x: c_int, y: c_int, z: c_int, n: c_int) -> u32;
1444 pub fn gegl_random_int_range(
1445 rand: *const GeglRandom,
1446 x: c_int,
1447 y: c_int,
1448 z: c_int,
1449 n: c_int,
1450 min: c_int,
1451 max: c_int,
1452 ) -> i32;
1453 pub fn gegl_random_set_seed(rand: *mut GeglRandom, seed: u32);
1454
1455 pub fn gegl_rectangle_get_type() -> GType;
1459 pub fn gegl_rectangle_new(
1460 x: c_int,
1461 y: c_int,
1462 width: c_uint,
1463 height: c_uint,
1464 ) -> *mut GeglRectangle;
1465 pub fn gegl_rectangle_align(
1466 destination: *mut GeglRectangle,
1467 rectangle: *const GeglRectangle,
1468 tile: *const GeglRectangle,
1469 alignment: GeglRectangleAlignment,
1470 ) -> gboolean;
1471 pub fn gegl_rectangle_align_to_buffer(
1472 destination: *mut GeglRectangle,
1473 rectangle: *const GeglRectangle,
1474 buffer: *mut GeglBuffer,
1475 alignment: GeglRectangleAlignment,
1476 ) -> gboolean;
1477 pub fn gegl_rectangle_bounding_box(
1478 destination: *mut GeglRectangle,
1479 source1: *const GeglRectangle,
1480 source2: *const GeglRectangle,
1481 );
1482 pub fn gegl_rectangle_contains(
1483 parent: *const GeglRectangle,
1484 child: *const GeglRectangle,
1485 ) -> gboolean;
1486 pub fn gegl_rectangle_copy(destination: *mut GeglRectangle, source: *const GeglRectangle);
1487 pub fn gegl_rectangle_dump(rectangle: *const GeglRectangle);
1488 pub fn gegl_rectangle_dup(rectangle: *const GeglRectangle) -> *mut GeglRectangle;
1489 pub fn gegl_rectangle_equal(
1490 rectangle1: *const GeglRectangle,
1491 rectangle2: *const GeglRectangle,
1492 ) -> gboolean;
1493 pub fn gegl_rectangle_equal_coords(
1494 rectangle: *const GeglRectangle,
1495 x: c_int,
1496 y: c_int,
1497 width: c_int,
1498 height: c_int,
1499 ) -> gboolean;
1500 pub fn gegl_rectangle_intersect(
1501 dest: *mut GeglRectangle,
1502 src1: *const GeglRectangle,
1503 src2: *const GeglRectangle,
1504 ) -> gboolean;
1505 pub fn gegl_rectangle_is_empty(rectangle: *const GeglRectangle) -> gboolean;
1506 pub fn gegl_rectangle_is_infinite_plane(rectangle: *const GeglRectangle) -> gboolean;
1507 pub fn gegl_rectangle_set(
1508 rectangle: *mut GeglRectangle,
1509 x: c_int,
1510 y: c_int,
1511 width: c_uint,
1512 height: c_uint,
1513 );
1514 pub fn gegl_rectangle_subtract(
1515 destination: *mut GeglRectangle,
1516 minuend: *const GeglRectangle,
1517 subtrahend: *const GeglRectangle,
1518 ) -> c_int;
1519 pub fn gegl_rectangle_subtract_bounding_box(
1520 destination: *mut GeglRectangle,
1521 minuend: *const GeglRectangle,
1522 subtrahend: *const GeglRectangle,
1523 ) -> gboolean;
1524 pub fn gegl_rectangle_xor(
1525 destination: *mut GeglRectangle,
1526 source1: *const GeglRectangle,
1527 source2: *const GeglRectangle,
1528 ) -> c_int;
1529 pub fn gegl_rectangle_infinite_plane() -> GeglRectangle;
1530
1531 pub fn gegl_sampler_get(
1535 sampler: *mut GeglSampler,
1536 x: c_double,
1537 y: c_double,
1538 scale: *mut GeglBufferMatrix2,
1539 output: *mut c_void,
1540 repeat_mode: GeglAbyssPolicy,
1541 );
1542 pub fn gegl_sampler_get_context_rect(sampler: *mut GeglSampler) -> *const GeglRectangle;
1543 pub fn gegl_sampler_get_fun(sampler: *mut GeglSampler) -> GeglSamplerGetFun;
1544
1545 pub fn gegl_audio_fragment_get_type() -> GType;
1549 pub fn gegl_audio_fragment_new(
1550 sample_rate: c_int,
1551 channels: c_int,
1552 channel_layout: c_int,
1553 max_samples: c_int,
1554 ) -> *mut GeglAudioFragment;
1555 pub fn gegl_audio_fragment_get_channel_layout(audio: *mut GeglAudioFragment) -> c_int;
1556 pub fn gegl_audio_fragment_get_channels(audio: *mut GeglAudioFragment) -> c_int;
1557 pub fn gegl_audio_fragment_get_max_samples(audio: *mut GeglAudioFragment) -> c_int;
1558 pub fn gegl_audio_fragment_get_pos(audio: *mut GeglAudioFragment) -> c_int;
1559 pub fn gegl_audio_fragment_get_sample_count(audio: *mut GeglAudioFragment) -> c_int;
1560 pub fn gegl_audio_fragment_get_sample_rate(audio: *mut GeglAudioFragment) -> c_int;
1561 pub fn gegl_audio_fragment_set_channel_layout(
1562 audio: *mut GeglAudioFragment,
1563 channel_layout: c_int,
1564 );
1565 pub fn gegl_audio_fragment_set_channels(audio: *mut GeglAudioFragment, channels: c_int);
1566 pub fn gegl_audio_fragment_set_max_samples(audio: *mut GeglAudioFragment, max_samples: c_int);
1567 pub fn gegl_audio_fragment_set_pos(audio: *mut GeglAudioFragment, pos: c_int);
1568 pub fn gegl_audio_fragment_set_sample_count(audio: *mut GeglAudioFragment, sample_count: c_int);
1569 pub fn gegl_audio_fragment_set_sample_rate(audio: *mut GeglAudioFragment, sample_rate: c_int);
1570
1571 pub fn gegl_buffer_get_type() -> GType;
1575 pub fn gegl_buffer_introspectable_new(
1576 format_name: *const c_char,
1577 x: c_int,
1578 y: c_int,
1579 width: c_int,
1580 height: c_int,
1581 ) -> *mut GeglBuffer;
1582 pub fn gegl_buffer_linear_new(
1583 extent: *const GeglRectangle,
1584 format: *const babl::Babl,
1585 ) -> *mut GeglBuffer;
1586 pub fn gegl_buffer_linear_new_from_data(
1587 data: gpointer,
1588 format: *const babl::Babl,
1589 extent: *const GeglRectangle,
1590 rowstride: c_int,
1591 destroy_fn: glib::GDestroyNotify,
1592 destroy_fn_data: gpointer,
1593 ) -> *mut GeglBuffer;
1594 pub fn gegl_buffer_new(
1595 extent: *const GeglRectangle,
1596 format: *const babl::Babl,
1597 ) -> *mut GeglBuffer;
1598 pub fn gegl_buffer_new_for_backend(
1599 extent: *const GeglRectangle,
1600 backend: *mut GeglTileBackend,
1601 ) -> *mut GeglBuffer;
1602 pub fn gegl_buffer_load(path: *const c_char) -> *mut GeglBuffer;
1603 pub fn gegl_buffer_open(path: *const c_char) -> *mut GeglBuffer;
1604 pub fn gegl_buffer_swap_create_file(suffix: *const c_char) -> *mut c_char;
1605 pub fn gegl_buffer_swap_has_file(path: *const c_char) -> gboolean;
1606 pub fn gegl_buffer_swap_remove_file(path: *const c_char);
1607 pub fn gegl_buffer_add_handler(buffer: *mut GeglBuffer, handler: gpointer);
1608 pub fn gegl_buffer_clear(buffer: *mut GeglBuffer, roi: *const GeglRectangle);
1609 pub fn gegl_buffer_copy(
1610 src: *mut GeglBuffer,
1611 src_rect: *const GeglRectangle,
1612 repeat_mode: GeglAbyssPolicy,
1613 dst: *mut GeglBuffer,
1614 dst_rect: *const GeglRectangle,
1615 );
1616 pub fn gegl_buffer_create_sub_buffer(
1617 buffer: *mut GeglBuffer,
1618 extent: *const GeglRectangle,
1619 ) -> *mut GeglBuffer;
1620 pub fn gegl_buffer_dup(buffer: *mut GeglBuffer) -> *mut GeglBuffer;
1621 pub fn gegl_buffer_flush(buffer: *mut GeglBuffer);
1622 pub fn gegl_buffer_flush_ext(buffer: *mut GeglBuffer, rect: *const GeglRectangle);
1623 pub fn gegl_buffer_freeze_changed(buffer: *mut GeglBuffer);
1624 pub fn gegl_buffer_get(
1625 buffer: *mut GeglBuffer,
1626 rect: *const GeglRectangle,
1627 scale: c_double,
1628 format: *const babl::Babl,
1629 dest: gpointer,
1630 rowstride: c_int,
1631 repeat_mode: GeglAbyssPolicy,
1632 );
1633 pub fn gegl_buffer_get_abyss(buffer: *mut GeglBuffer) -> *const GeglRectangle;
1634 pub fn gegl_buffer_get_extent(buffer: *mut GeglBuffer) -> *const GeglRectangle;
1635 pub fn gegl_buffer_get_format(buffer: *mut GeglBuffer) -> *const babl::Babl;
1636 pub fn gegl_buffer_get_tile(
1637 buffer: *mut GeglBuffer,
1638 x: c_int,
1639 y: c_int,
1640 z: c_int,
1641 ) -> *mut GeglTile;
1642 pub fn gegl_buffer_introspectable_get(
1643 buffer: *mut GeglBuffer,
1644 rect: *const GeglRectangle,
1645 scale: c_double,
1646 format_name: *const c_char,
1647 repeat_mode: GeglAbyssPolicy,
1648 data_length: *mut c_uint,
1649 ) -> *mut u8;
1650 pub fn gegl_buffer_introspectable_set(
1651 buffer: *mut GeglBuffer,
1652 rect: *const GeglRectangle,
1653 format_name: *const c_char,
1654 src: *const u8,
1655 src_length: c_int,
1656 );
1657 pub fn gegl_buffer_iterator_new(
1658 buffer: *mut GeglBuffer,
1659 roi: *const GeglRectangle,
1660 level: c_int,
1661 format: *const babl::Babl,
1662 access_mode: GeglAccessMode,
1663 abyss_policy: GeglAbyssPolicy,
1664 max_slots: c_int,
1665 ) -> *mut GeglBufferIterator;
1666 pub fn gegl_buffer_linear_close(buffer: *mut GeglBuffer, linear: gpointer);
1667 pub fn gegl_buffer_linear_open(
1668 buffer: *mut GeglBuffer,
1669 extent: *const GeglRectangle,
1670 rowstride: *mut c_int,
1671 format: *const babl::Babl,
1672 ) -> gpointer;
1673 pub fn gegl_buffer_remove_handler(buffer: *mut GeglBuffer, handler: gpointer);
1674 pub fn gegl_buffer_sample(
1675 buffer: *mut GeglBuffer,
1676 x: c_double,
1677 y: c_double,
1678 scale: *mut GeglBufferMatrix2,
1679 dest: gpointer,
1680 format: *const babl::Babl,
1681 sampler_type: GeglSamplerType,
1682 repeat_mode: GeglAbyssPolicy,
1683 );
1684 pub fn gegl_buffer_sample_at_level(
1685 buffer: *mut GeglBuffer,
1686 x: c_double,
1687 y: c_double,
1688 scale: *mut GeglBufferMatrix2,
1689 dest: gpointer,
1690 format: *const babl::Babl,
1691 level: c_int,
1692 sampler_type: GeglSamplerType,
1693 repeat_mode: GeglAbyssPolicy,
1694 );
1695 pub fn gegl_buffer_sample_cleanup(buffer: *mut GeglBuffer);
1696 pub fn gegl_buffer_sampler_new(
1697 buffer: *mut GeglBuffer,
1698 format: *const babl::Babl,
1699 sampler_type: GeglSamplerType,
1700 ) -> *mut GeglSampler;
1701 pub fn gegl_buffer_sampler_new_at_level(
1702 buffer: *mut GeglBuffer,
1703 format: *const babl::Babl,
1704 sampler_type: GeglSamplerType,
1705 level: c_int,
1706 ) -> *mut GeglSampler;
1707 pub fn gegl_buffer_save(
1708 buffer: *mut GeglBuffer,
1709 path: *const c_char,
1710 roi: *const GeglRectangle,
1711 );
1712 pub fn gegl_buffer_set(
1713 buffer: *mut GeglBuffer,
1714 rect: *const GeglRectangle,
1715 mipmap_level: c_int,
1716 format: *const babl::Babl,
1717 src: *mut c_void,
1718 rowstride: c_int,
1719 );
1720 pub fn gegl_buffer_set_abyss(buffer: *mut GeglBuffer, abyss: *const GeglRectangle) -> gboolean;
1721 pub fn gegl_buffer_set_color(
1722 buffer: *mut GeglBuffer,
1723 rect: *const GeglRectangle,
1724 color: *mut GeglColor,
1725 );
1726 pub fn gegl_buffer_set_color_from_pixel(
1727 buffer: *mut GeglBuffer,
1728 rect: *const GeglRectangle,
1729 pixel: gconstpointer,
1730 pixel_format: *const babl::Babl,
1731 );
1732 pub fn gegl_buffer_set_extent(
1733 buffer: *mut GeglBuffer,
1734 extent: *const GeglRectangle,
1735 ) -> gboolean;
1736 pub fn gegl_buffer_set_format(
1737 buffer: *mut GeglBuffer,
1738 format: *const babl::Babl,
1739 ) -> *const babl::Babl;
1740 pub fn gegl_buffer_set_pattern(
1741 buffer: *mut GeglBuffer,
1742 rect: *const GeglRectangle,
1743 pattern: *mut GeglBuffer,
1744 x_offset: c_int,
1745 y_offset: c_int,
1746 );
1747 pub fn gegl_buffer_share_storage(
1748 buffer1: *mut GeglBuffer,
1749 buffer2: *mut GeglBuffer,
1750 ) -> gboolean;
1751 pub fn gegl_buffer_signal_connect(
1752 buffer: *mut GeglBuffer,
1753 detailed_signal: *const c_char,
1754 c_handler: gobject::GCallback,
1755 data: gpointer,
1756 ) -> c_long;
1757 pub fn gegl_buffer_thaw_changed(buffer: *mut GeglBuffer);
1758
1759 pub fn gegl_color_get_type() -> GType;
1763 pub fn gegl_color_new(string: *const c_char) -> *mut GeglColor;
1764 pub fn gegl_color_duplicate(color: *mut GeglColor) -> *mut GeglColor;
1765 pub fn gegl_color_get_components(
1766 color: *mut GeglColor,
1767 format: *mut gobject::GValue,
1768 components_length: *mut c_int,
1769 ) -> *mut c_double;
1770 pub fn gegl_color_get_format(color: *mut GeglColor) -> *const babl::Babl;
1771 pub fn gegl_color_get_pixel(
1772 color: *mut GeglColor,
1773 format: *const babl::Babl,
1774 pixel: *mut c_void,
1775 );
1776 pub fn gegl_color_get_rgba(
1777 color: *mut GeglColor,
1778 red: *mut c_double,
1779 green: *mut c_double,
1780 blue: *mut c_double,
1781 alpha: *mut c_double,
1782 );
1783 pub fn gegl_color_set_components(
1784 color: *mut GeglColor,
1785 format: *mut gobject::GValue,
1786 components: *mut c_double,
1787 components_length: c_int,
1788 );
1789 pub fn gegl_color_set_pixel(
1790 color: *mut GeglColor,
1791 format: *const babl::Babl,
1792 pixel: *mut c_void,
1793 );
1794 pub fn gegl_color_set_rgba(
1795 color: *mut GeglColor,
1796 red: c_double,
1797 green: c_double,
1798 blue: c_double,
1799 alpha: c_double,
1800 );
1801
1802 pub fn gegl_config_get_type() -> GType;
1806
1807 pub fn gegl_curve_get_type() -> GType;
1811 pub fn gegl_curve_new(y_min: c_double, y_max: c_double) -> *mut GeglCurve;
1812 pub fn gegl_curve_new_default() -> *mut GeglCurve;
1813 pub fn gegl_curve_add_point(curve: *mut GeglCurve, x: c_double, y: c_double) -> c_uint;
1814 pub fn gegl_curve_calc_value(curve: *mut GeglCurve, x: c_double) -> c_double;
1815 pub fn gegl_curve_calc_values(
1816 curve: *mut GeglCurve,
1817 x_min: c_double,
1818 x_max: c_double,
1819 num_samples: c_uint,
1820 xs: *mut c_double,
1821 ys: *mut c_double,
1822 );
1823 pub fn gegl_curve_duplicate(curve: *mut GeglCurve) -> *mut GeglCurve;
1824 pub fn gegl_curve_get_point(
1825 curve: *mut GeglCurve,
1826 index: c_uint,
1827 x: *mut c_double,
1828 y: *mut c_double,
1829 );
1830 pub fn gegl_curve_get_y_bounds(
1831 curve: *mut GeglCurve,
1832 min_y: *mut c_double,
1833 max_y: *mut c_double,
1834 );
1835 pub fn gegl_curve_num_points(curve: *mut GeglCurve) -> c_uint;
1836 pub fn gegl_curve_set_point(curve: *mut GeglCurve, index: c_uint, x: c_double, y: c_double);
1837
1838 pub fn gegl_metadata_hash_get_type() -> GType;
1842 pub fn gegl_metadata_hash_new() -> *mut GeglMetadataStore;
1843
1844 pub fn gegl_metadata_store_get_type() -> GType;
1848 pub fn gegl_metadata_store_declare(
1849 self_: *mut GeglMetadataStore,
1850 pspec: *mut gobject::GParamSpec,
1851 );
1852 pub fn gegl_metadata_store_get_artist(self_: *mut GeglMetadataStore) -> *const c_char;
1853 pub fn gegl_metadata_store_get_comment(self_: *mut GeglMetadataStore) -> *const c_char;
1854 pub fn gegl_metadata_store_get_copyright(self_: *mut GeglMetadataStore) -> *const c_char;
1855 pub fn gegl_metadata_store_get_description(self_: *mut GeglMetadataStore) -> *const c_char;
1856 pub fn gegl_metadata_store_get_disclaimer(self_: *mut GeglMetadataStore) -> *const c_char;
1857 pub fn gegl_metadata_store_get_file_module_name(self_: *mut GeglMetadataStore)
1858 -> *const c_char;
1859 pub fn gegl_metadata_store_get_resolution_unit(
1860 self_: *mut GeglMetadataStore,
1861 ) -> GeglResolutionUnit;
1862 pub fn gegl_metadata_store_get_resolution_x(self_: *mut GeglMetadataStore) -> c_double;
1863 pub fn gegl_metadata_store_get_resolution_y(self_: *mut GeglMetadataStore) -> c_double;
1864 pub fn gegl_metadata_store_get_software(self_: *mut GeglMetadataStore) -> *const c_char;
1865 pub fn gegl_metadata_store_get_source(self_: *mut GeglMetadataStore) -> *const c_char;
1866 pub fn gegl_metadata_store_get_string(
1867 self_: *mut GeglMetadataStore,
1868 name: *const c_char,
1869 ) -> *const c_char;
1870 pub fn gegl_metadata_store_get_timestamp(self_: *mut GeglMetadataStore)
1871 -> *mut glib::GDateTime;
1872 pub fn gegl_metadata_store_get_title(self_: *mut GeglMetadataStore) -> *const c_char;
1873 pub fn gegl_metadata_store_get_value(
1874 self_: *mut GeglMetadataStore,
1875 name: *const c_char,
1876 value: *mut gobject::GValue,
1877 );
1878 pub fn gegl_metadata_store_get_warning(self_: *mut GeglMetadataStore) -> *const c_char;
1879 pub fn gegl_metadata_store_has_value(
1880 self_: *mut GeglMetadataStore,
1881 name: *const c_char,
1882 ) -> gboolean;
1883 pub fn gegl_metadata_store_notify(
1884 self_: *mut GeglMetadataStore,
1885 pspec: *mut gobject::GParamSpec,
1886 shadow: gboolean,
1887 );
1888 pub fn gegl_metadata_store_register(
1889 self_: *mut GeglMetadataStore,
1890 local_name: *const c_char,
1891 name: *const c_char,
1892 transform: gobject::GValueTransform,
1893 );
1894 pub fn gegl_metadata_store_set_artist(self_: *mut GeglMetadataStore, artist: *const c_char);
1895 pub fn gegl_metadata_store_set_comment(self_: *mut GeglMetadataStore, comment: *const c_char);
1896 pub fn gegl_metadata_store_set_copyright(
1897 self_: *mut GeglMetadataStore,
1898 copyright: *const c_char,
1899 );
1900 pub fn gegl_metadata_store_set_description(
1901 self_: *mut GeglMetadataStore,
1902 description: *const c_char,
1903 );
1904 pub fn gegl_metadata_store_set_disclaimer(
1905 self_: *mut GeglMetadataStore,
1906 disclaimer: *const c_char,
1907 );
1908 pub fn gegl_metadata_store_set_resolution_unit(
1909 self_: *mut GeglMetadataStore,
1910 unit: GeglResolutionUnit,
1911 );
1912 pub fn gegl_metadata_store_set_resolution_x(
1913 self_: *mut GeglMetadataStore,
1914 resolution_x: c_double,
1915 );
1916 pub fn gegl_metadata_store_set_resolution_y(
1917 self_: *mut GeglMetadataStore,
1918 resolution_y: c_double,
1919 );
1920 pub fn gegl_metadata_store_set_software(self_: *mut GeglMetadataStore, software: *const c_char);
1921 pub fn gegl_metadata_store_set_source(self_: *mut GeglMetadataStore, source: *const c_char);
1922 pub fn gegl_metadata_store_set_string(
1923 self_: *mut GeglMetadataStore,
1924 name: *const c_char,
1925 string: *const c_char,
1926 );
1927 pub fn gegl_metadata_store_set_timestamp(
1928 self_: *mut GeglMetadataStore,
1929 timestamp: *const glib::GDateTime,
1930 );
1931 pub fn gegl_metadata_store_set_title(self_: *mut GeglMetadataStore, title: *const c_char);
1932 pub fn gegl_metadata_store_set_value(
1933 self_: *mut GeglMetadataStore,
1934 name: *const c_char,
1935 value: *const gobject::GValue,
1936 );
1937 pub fn gegl_metadata_store_set_warning(self_: *mut GeglMetadataStore, warning: *const c_char);
1938 pub fn gegl_metadata_store_typeof_value(
1939 self_: *mut GeglMetadataStore,
1940 name: *const c_char,
1941 ) -> GType;
1942
1943 pub fn gegl_node_get_type() -> GType;
1947 pub fn gegl_node_new() -> *mut GeglNode;
1948 pub fn gegl_node_new_from_file(path: *const c_char) -> *mut GeglNode;
1949 pub fn gegl_node_new_from_serialized(
1950 chaindata: *const c_char,
1951 path_root: *const c_char,
1952 ) -> *mut GeglNode;
1953 pub fn gegl_node_new_from_xml(
1954 xmldata: *const c_char,
1955 path_root: *const c_char,
1956 ) -> *mut GeglNode;
1957 pub fn gegl_node_add_child(graph: *mut GeglNode, child: *mut GeglNode) -> *mut GeglNode;
1958 pub fn gegl_node_blit(
1959 node: *mut GeglNode,
1960 scale: c_double,
1961 roi: *const GeglRectangle,
1962 format: *const babl::Babl,
1963 destination_buf: gpointer,
1964 rowstride: c_int,
1965 flags: GeglBlitFlags,
1966 );
1967 pub fn gegl_node_blit_buffer(
1968 node: *mut GeglNode,
1969 buffer: *mut GeglBuffer,
1970 roi: *const GeglRectangle,
1971 level: c_int,
1972 abyss_policy: GeglAbyssPolicy,
1973 );
1974 pub fn gegl_node_connect(
1975 a: *mut GeglNode,
1976 a_pad_name: *const c_char,
1977 b: *mut GeglNode,
1978 b_pad_name: *const c_char,
1979 ) -> gboolean;
1980 pub fn gegl_node_connect_from(
1981 sink: *mut GeglNode,
1982 input_pad_name: *const c_char,
1983 source: *mut GeglNode,
1984 output_pad_name: *const c_char,
1985 ) -> gboolean;
1986 pub fn gegl_node_connect_to(
1987 source: *mut GeglNode,
1988 output_pad_name: *const c_char,
1989 sink: *mut GeglNode,
1990 input_pad_name: *const c_char,
1991 ) -> gboolean;
1992 pub fn gegl_node_create_child(parent: *mut GeglNode, operation: *const c_char)
1993 -> *mut GeglNode;
1994 pub fn gegl_node_detect(node: *mut GeglNode, x: c_int, y: c_int) -> *mut GeglNode;
1995 pub fn gegl_node_disconnect(node: *mut GeglNode, input_pad: *const c_char) -> gboolean;
1996 pub fn gegl_node_find_property(
1997 node: *mut GeglNode,
1998 property_name: *const c_char,
1999 ) -> *mut gobject::GParamSpec;
2000 pub fn gegl_node_get(node: *mut GeglNode, first_property_name: *const c_char, ...);
2001 pub fn gegl_node_get_bounding_box(node: *mut GeglNode) -> GeglRectangle;
2002 pub fn gegl_node_get_children(node: *mut GeglNode) -> *mut glib::GSList;
2003 pub fn gegl_node_get_consumers(
2004 node: *mut GeglNode,
2005 output_pad: *const c_char,
2006 nodes: *mut *mut *mut GeglNode,
2007 pads: *mut *mut *const c_char,
2008 ) -> c_int;
2009 pub fn gegl_node_get_gegl_operation(node: *mut GeglNode) -> *mut GeglOperation;
2010 pub fn gegl_node_get_input_proxy(node: *mut GeglNode, pad_name: *const c_char)
2011 -> *mut GeglNode;
2012 pub fn gegl_node_get_operation(node: *const GeglNode) -> *const c_char;
2013 pub fn gegl_node_get_output_proxy(
2014 node: *mut GeglNode,
2015 pad_name: *const c_char,
2016 ) -> *mut GeglNode;
2017 pub fn gegl_node_get_parent(node: *mut GeglNode) -> *mut GeglNode;
2018 pub fn gegl_node_get_passthrough(node: *mut GeglNode) -> gboolean;
2019 pub fn gegl_node_get_producer(
2020 node: *mut GeglNode,
2021 input_pad_name: *const c_char,
2022 output_pad_name: *mut *mut c_char,
2023 ) -> *mut GeglNode;
2024 pub fn gegl_node_get_property(
2025 node: *mut GeglNode,
2026 property_name: *const c_char,
2027 value: *mut gobject::GValue,
2028 );
2029 pub fn gegl_node_has_pad(node: *mut GeglNode, pad_name: *const c_char) -> gboolean;
2031 pub fn gegl_node_introspectable_get_bounding_box(node: *mut GeglNode) -> *mut GeglRectangle;
2032 pub fn gegl_node_introspectable_get_property(
2033 node: *mut GeglNode,
2034 property_name: *const c_char,
2035 ) -> *mut gobject::GValue;
2036 pub fn gegl_node_is_graph(node: *mut GeglNode) -> gboolean;
2037 pub fn gegl_node_link(source: *mut GeglNode, sink: *mut GeglNode);
2038 pub fn gegl_node_link_many(source: *mut GeglNode, first_sink: *mut GeglNode, ...);
2039 pub fn gegl_node_list_input_pads(node: *mut GeglNode) -> *mut *mut c_char;
2040 pub fn gegl_node_list_output_pads(node: *mut GeglNode) -> *mut *mut c_char;
2041 pub fn gegl_node_new_child(
2042 parent: *mut GeglNode,
2043 first_property_name: *const c_char,
2044 ...
2045 ) -> *mut GeglNode;
2046 pub fn gegl_node_new_processor(
2047 node: *mut GeglNode,
2048 rectangle: *const GeglRectangle,
2049 ) -> *mut GeglProcessor;
2050 pub fn gegl_node_process(sink_node: *mut GeglNode);
2051 pub fn gegl_node_progress(node: *mut GeglNode, progress: c_double, message: *mut c_char);
2052 pub fn gegl_node_remove_child(graph: *mut GeglNode, child: *mut GeglNode) -> *mut GeglNode;
2053 pub fn gegl_node_set(node: *mut GeglNode, first_property_name: *const c_char, ...);
2054 pub fn gegl_node_set_enum_as_string(
2055 node: *mut GeglNode,
2056 key: *const c_char,
2057 value: *const c_char,
2058 );
2059 pub fn gegl_node_set_passthrough(node: *mut GeglNode, passthrough: gboolean);
2060 pub fn gegl_node_set_property(
2061 node: *mut GeglNode,
2062 property_name: *const c_char,
2063 value: *const gobject::GValue,
2064 );
2065 pub fn gegl_node_set_time(node: *mut GeglNode, time: c_double);
2066 pub fn gegl_node_to_xml(node: *mut GeglNode, path_root: *const c_char) -> *mut c_char;
2068 pub fn gegl_node_to_xml_full(
2069 head: *mut GeglNode,
2070 tail: *mut GeglNode,
2071 path_root: *const c_char,
2072 ) -> *mut c_char;
2073
2074 pub fn gegl_operation_get_type() -> GType;
2078 pub fn gegl_operation_find_property(
2079 operation_type: *const c_char,
2080 property_name: *const c_char,
2081 ) -> *mut gobject::GParamSpec;
2082 pub fn gegl_operation_get_key(
2083 operation_type: *const c_char,
2084 key_name: *const c_char,
2085 ) -> *const c_char;
2086 pub fn gegl_operation_get_op_version(op_name: *const c_char) -> *const c_char;
2087 pub fn gegl_operation_get_property_key(
2088 operation_type: *const c_char,
2089 property_name: *const c_char,
2090 property_key_name: *const c_char,
2091 ) -> *const c_char;
2092 pub fn gegl_operation_list_keys(
2093 operation_type: *const c_char,
2094 n_keys: *mut c_uint,
2095 ) -> *mut *mut c_char;
2096 pub fn gegl_operation_list_properties(
2097 operation_type: *const c_char,
2098 n_properties_p: *mut c_uint,
2099 ) -> *mut *mut gobject::GParamSpec;
2100 pub fn gegl_operation_list_property_keys(
2101 operation_type: *const c_char,
2102 property_name: *const c_char,
2103 n_keys: *mut c_uint,
2104 ) -> *mut *mut c_char;
2105
2106 pub fn gegl_param_audio_fragment_get_type() -> GType;
2110
2111 pub fn gegl_param_color_get_type() -> GType;
2115
2116 pub fn gegl_param_curve_get_type() -> GType;
2120
2121 pub fn gegl_param_double_get_type() -> GType;
2125
2126 pub fn gegl_param_enum_get_type() -> GType;
2130
2131 pub fn gegl_param_file_path_get_type() -> GType;
2135
2136 pub fn gegl_param_format_get_type() -> GType;
2140
2141 pub fn gegl_param_int_get_type() -> GType;
2145
2146 pub fn gegl_param_path_get_type() -> GType;
2150
2151 pub fn gegl_param_seed_get_type() -> GType;
2155
2156 pub fn gegl_param_string_get_type() -> GType;
2160
2161 pub fn gegl_param_uri_get_type() -> GType;
2165
2166 pub fn gegl_path_get_type() -> GType;
2170 pub fn gegl_path_new() -> *mut GeglPath;
2171 pub fn gegl_path_new_from_string(instructions: *const c_char) -> *mut GeglPath;
2172 pub fn gegl_path_add_flattener(func: GeglFlattenerFunc);
2173 pub fn gegl_path_add_type(type_: c_char, items: c_int, description: *const c_char);
2174 pub fn gegl_path_append(path: *mut GeglPath, ...);
2175 pub fn gegl_path_calc(
2176 path: *mut GeglPath,
2177 pos: c_double,
2178 x: *mut c_double,
2179 y: *mut c_double,
2180 ) -> gboolean;
2181 pub fn gegl_path_calc_values(
2182 path: *mut GeglPath,
2183 num_samples: c_uint,
2184 xs: *mut c_double,
2185 ys: *mut c_double,
2186 );
2187 pub fn gegl_path_calc_y_for_x(path: *mut GeglPath, x: c_double, y: *mut c_double) -> c_int;
2188 pub fn gegl_path_clear(path: *mut GeglPath);
2189 pub fn gegl_path_closest_point(
2190 path: *mut GeglPath,
2191 x: c_double,
2192 y: c_double,
2193 on_path_x: *mut c_double,
2194 on_path_y: *mut c_double,
2195 node_pos_before: *mut c_int,
2196 ) -> c_double;
2197 pub fn gegl_path_dirty(path: *mut GeglPath);
2198 pub fn gegl_path_foreach(path: *mut GeglPath, each_item: GeglNodeFunction, user_data: gpointer);
2199 pub fn gegl_path_foreach_flat(
2200 path: *mut GeglPath,
2201 each_item: GeglNodeFunction,
2202 user_data: gpointer,
2203 );
2204 pub fn gegl_path_freeze(path: *mut GeglPath);
2205 pub fn gegl_path_get_bounds(
2206 self_: *mut GeglPath,
2207 min_x: *mut c_double,
2208 max_x: *mut c_double,
2209 min_y: *mut c_double,
2210 max_y: *mut c_double,
2211 );
2212 pub fn gegl_path_get_flat_path(path: *mut GeglPath) -> *mut GeglPathList;
2213 pub fn gegl_path_get_length(path: *mut GeglPath) -> c_double;
2214 pub fn gegl_path_get_matrix(path: *mut GeglPath, matrix: *mut GeglMatrix3);
2215 pub fn gegl_path_get_n_nodes(path: *mut GeglPath) -> c_int;
2216 pub fn gegl_path_get_node(
2217 path: *mut GeglPath,
2218 index: c_int,
2219 node: *mut GeglPathItem,
2220 ) -> gboolean;
2221 pub fn gegl_path_get_path(path: *mut GeglPath) -> *mut GeglPathList;
2222 pub fn gegl_path_insert_node(path: *mut GeglPath, pos: c_int, node: *const GeglPathItem);
2223 pub fn gegl_path_is_empty(path: *mut GeglPath) -> gboolean;
2224 pub fn gegl_path_parse_string(path: *mut GeglPath, instructions: *const c_char);
2225 pub fn gegl_path_remove_node(path: *mut GeglPath, pos: c_int);
2226 pub fn gegl_path_replace_node(path: *mut GeglPath, pos: c_int, node: *const GeglPathItem);
2227 pub fn gegl_path_set_matrix(path: *mut GeglPath, matrix: *mut GeglMatrix3);
2228 pub fn gegl_path_thaw(path: *mut GeglPath);
2229 pub fn gegl_path_to_string(path: *mut GeglPath) -> *mut c_char;
2230
2231 pub fn gegl_processor_get_type() -> GType;
2235 pub fn gegl_processor_get_buffer(processor: *mut GeglProcessor) -> *mut GeglBuffer;
2236 pub fn gegl_processor_set_level(processor: *mut GeglProcessor, level: c_int);
2237 pub fn gegl_processor_set_rectangle(
2238 processor: *mut GeglProcessor,
2239 rectangle: *const GeglRectangle,
2240 );
2241 pub fn gegl_processor_set_scale(processor: *mut GeglProcessor, scale: c_double);
2242 pub fn gegl_processor_work(processor: *mut GeglProcessor, progress: *mut c_double) -> gboolean;
2243
2244 pub fn gegl_stats_get_type() -> GType;
2248
2249 pub fn gegl_tile_backend_get_type() -> GType;
2253 pub fn gegl_tile_backend_unlink_swap(path: *mut c_char);
2254 pub fn gegl_tile_backend_command(
2255 backend: *mut GeglTileBackend,
2256 command: GeglTileCommand,
2257 x: c_int,
2258 y: c_int,
2259 z: c_int,
2260 data: gpointer,
2261 ) -> gpointer;
2262 pub fn gegl_tile_backend_get_extent(tile_backend: *mut GeglTileBackend) -> GeglRectangle;
2263 pub fn gegl_tile_backend_get_flush_on_destroy(tile_backend: *mut GeglTileBackend) -> gboolean;
2264 pub fn gegl_tile_backend_get_format(tile_backend: *mut GeglTileBackend) -> *const babl::Babl;
2265 pub fn gegl_tile_backend_get_tile_height(tile_backend: *mut GeglTileBackend) -> c_int;
2266 pub fn gegl_tile_backend_get_tile_size(tile_backend: *mut GeglTileBackend) -> c_int;
2267 pub fn gegl_tile_backend_get_tile_width(tile_backend: *mut GeglTileBackend) -> c_int;
2268 pub fn gegl_tile_backend_peek_storage(
2269 tile_backend: *mut GeglTileBackend,
2270 ) -> *mut GeglTileSource;
2271 pub fn gegl_tile_backend_set_extent(
2272 tile_backend: *mut GeglTileBackend,
2273 rectangle: *const GeglRectangle,
2274 );
2275 pub fn gegl_tile_backend_set_flush_on_destroy(
2276 tile_backend: *mut GeglTileBackend,
2277 flush_on_destroy: gboolean,
2278 );
2279
2280 pub fn gegl_tile_handler_get_type() -> GType;
2284 pub fn gegl_tile_handler_create_tile(
2285 handler: *mut GeglTileHandler,
2286 x: c_int,
2287 y: c_int,
2288 z: c_int,
2289 ) -> *mut GeglTile;
2290 pub fn gegl_tile_handler_damage_rect(handler: *mut GeglTileHandler, rect: *const GeglRectangle);
2291 pub fn gegl_tile_handler_damage_tile(
2292 handler: *mut GeglTileHandler,
2293 x: c_int,
2294 y: c_int,
2295 z: c_int,
2296 damage: u64,
2297 );
2298 pub fn gegl_tile_handler_dup_tile(
2299 handler: *mut GeglTileHandler,
2300 tile: *mut GeglTile,
2301 x: c_int,
2302 y: c_int,
2303 z: c_int,
2304 ) -> *mut GeglTile;
2305 pub fn gegl_tile_handler_get_source_tile(
2306 handler: *mut GeglTileHandler,
2307 x: c_int,
2308 y: c_int,
2309 z: c_int,
2310 preserve_data: gboolean,
2311 ) -> *mut GeglTile;
2312 pub fn gegl_tile_handler_get_tile(
2313 handler: *mut GeglTileHandler,
2314 x: c_int,
2315 y: c_int,
2316 z: c_int,
2317 preserve_data: gboolean,
2318 ) -> *mut GeglTile;
2319 pub fn gegl_tile_handler_lock(handler: *mut GeglTileHandler);
2320 pub fn gegl_tile_handler_set_source(handler: *mut GeglTileHandler, source: *mut GeglTileSource);
2321 pub fn gegl_tile_handler_unlock(handler: *mut GeglTileHandler);
2322
2323 pub fn gegl_tile_source_get_type() -> GType;
2327
2328 pub fn gegl_metadata_get_type() -> GType;
2332 pub fn gegl_metadata_get_resolution(
2333 metadata: *mut GeglMetadata,
2334 unit: *mut GeglResolutionUnit,
2335 x: *mut c_float,
2336 y: *mut c_float,
2337 ) -> gboolean;
2338 pub fn gegl_metadata_iter_get_value(
2339 metadata: *mut GeglMetadata,
2340 iter: *mut GeglMetadataIter,
2341 value: *mut gobject::GValue,
2342 ) -> gboolean;
2343 pub fn gegl_metadata_iter_init(metadata: *mut GeglMetadata, iter: *mut GeglMetadataIter);
2344 pub fn gegl_metadata_iter_lookup(
2345 metadata: *mut GeglMetadata,
2346 iter: *mut GeglMetadataIter,
2347 key: *const c_char,
2348 ) -> gboolean;
2349 pub fn gegl_metadata_iter_next(
2350 metadata: *mut GeglMetadata,
2351 iter: *mut GeglMetadataIter,
2352 ) -> *const c_char;
2353 pub fn gegl_metadata_iter_set_value(
2354 metadata: *mut GeglMetadata,
2355 iter: *mut GeglMetadataIter,
2356 value: *const gobject::GValue,
2357 ) -> gboolean;
2358 pub fn gegl_metadata_register_map(
2359 metadata: *mut GeglMetadata,
2360 file_module: *const c_char,
2361 flags: c_uint,
2362 map: *const GeglMetadataMap,
2363 n_map: size_t,
2364 );
2365 pub fn gegl_metadata_set_resolution(
2366 metadata: *mut GeglMetadata,
2367 unit: GeglResolutionUnit,
2368 x: c_float,
2369 y: c_float,
2370 ) -> gboolean;
2371 pub fn gegl_metadata_unregister_map(metadata: *mut GeglMetadata);
2372
2373 pub fn gegl_apply_op(buffer: *mut GeglBuffer, operation_name: *const c_char, ...);
2377 pub fn gegl_babl_variant(
2379 format: *const babl::Babl,
2380 variant: GeglBablVariant,
2381 ) -> *const babl::Babl;
2382 pub fn gegl_calloc(size: size_t, n_memb: c_int) -> gpointer;
2383 pub fn gegl_cl_disable();
2384 pub fn gegl_cl_init(error: *mut *mut glib::GError) -> gboolean;
2385 pub fn gegl_cl_is_accelerated() -> gboolean;
2386 pub fn gegl_config() -> *mut GeglConfig;
2387 pub fn gegl_create_chain(
2388 ops: *const c_char,
2389 op_start: *mut GeglNode,
2390 op_end: *mut GeglNode,
2391 time: c_double,
2392 rel_dim: c_int,
2393 path_root: *const c_char,
2394 error: *mut *mut glib::GError,
2395 );
2396 pub fn gegl_create_chain_argv(
2397 ops: *mut *mut c_char,
2398 op_start: *mut GeglNode,
2399 op_end: *mut GeglNode,
2400 time: c_double,
2401 rel_dim: c_int,
2402 path_root: *const c_char,
2403 error: *mut *mut glib::GError,
2404 );
2405 pub fn gegl_exit();
2406 pub fn gegl_filter_op(
2407 source_buffer: *mut GeglBuffer,
2408 operation_name: *const c_char,
2409 ...
2410 ) -> *mut GeglBuffer;
2411 pub fn gegl_format(format_name: *const c_char) -> *mut gobject::GValue;
2413 pub fn gegl_format_get_name(format: *mut gobject::GValue) -> *const c_char;
2414 pub fn gegl_free(mem: gpointer);
2415 pub fn gegl_get_option_group() -> *mut glib::GOptionGroup;
2416 pub fn gegl_get_version(major: *mut c_int, minor: *mut c_int, micro: *mut c_int);
2417 pub fn gegl_graph_dump_outputs(node: *mut GeglNode);
2418 pub fn gegl_graph_dump_request(node: *mut GeglNode, roi: *const GeglRectangle);
2419 pub fn gegl_has_operation(operation_type: *const c_char) -> gboolean;
2420 pub fn gegl_init(argc: *mut c_int, argv: *mut *mut *mut c_char);
2421 pub fn gegl_is_main_thread() -> gboolean;
2422 pub fn gegl_list_operations(n_operations_p: *mut c_uint) -> *mut *mut c_char;
2423 pub fn gegl_load_module_directory(path: *const c_char);
2424 pub fn gegl_malloc(n_bytes: size_t) -> gpointer;
2425 pub fn gegl_memeq_zero(ptr: gconstpointer, size: size_t) -> gboolean;
2426 pub fn gegl_memset_pattern(
2427 dst_ptr: gpointer,
2428 src_ptr: gconstpointer,
2429 pattern_size: c_int,
2430 count: c_int,
2431 );
2432 pub fn gegl_parallel_distribute(
2433 max_n: c_int,
2434 func: GeglParallelDistributeFunc,
2435 user_data: gpointer,
2436 );
2437 pub fn gegl_parallel_distribute_area(
2438 area: *const GeglRectangle,
2439 thread_cost: c_double,
2440 split_strategy: GeglSplitStrategy,
2441 func: GeglParallelDistributeAreaFunc,
2442 user_data: gpointer,
2443 );
2444 pub fn gegl_parallel_distribute_range(
2445 size: size_t,
2446 thread_cost: c_double,
2447 func: GeglParallelDistributeRangeFunc,
2448 user_data: gpointer,
2449 );
2450 pub fn gegl_param_spec_audio_fragment(
2451 name: *const c_char,
2452 nick: *const c_char,
2453 blurb: *const c_char,
2454 flags: gobject::GParamFlags,
2455 ) -> *mut gobject::GParamSpec;
2456 pub fn gegl_param_spec_color(
2457 name: *const c_char,
2458 nick: *const c_char,
2459 blurb: *const c_char,
2460 default_color: *mut GeglColor,
2461 flags: gobject::GParamFlags,
2462 ) -> *mut gobject::GParamSpec;
2463 pub fn gegl_param_spec_color_from_string(
2464 name: *const c_char,
2465 nick: *const c_char,
2466 blurb: *const c_char,
2467 default_color_string: *const c_char,
2468 flags: gobject::GParamFlags,
2469 ) -> *mut gobject::GParamSpec;
2470 pub fn gegl_param_spec_color_get_default(self_: *mut gobject::GParamSpec) -> *mut GeglColor;
2471 pub fn gegl_param_spec_curve(
2472 name: *const c_char,
2473 nick: *const c_char,
2474 blurb: *const c_char,
2475 default_curve: *mut GeglCurve,
2476 flags: gobject::GParamFlags,
2477 ) -> *mut gobject::GParamSpec;
2478 pub fn gegl_param_spec_double(
2479 name: *const c_char,
2480 nick: *const c_char,
2481 blurb: *const c_char,
2482 minimum: c_double,
2483 maximum: c_double,
2484 default_value: c_double,
2485 ui_minimum: c_double,
2486 ui_maximum: c_double,
2487 ui_gamma: c_double,
2488 flags: gobject::GParamFlags,
2489 ) -> *mut gobject::GParamSpec;
2490 pub fn gegl_param_spec_enum(
2491 name: *const c_char,
2492 nick: *const c_char,
2493 blurb: *const c_char,
2494 enum_type: GType,
2495 default_value: c_int,
2496 flags: gobject::GParamFlags,
2497 ) -> *mut gobject::GParamSpec;
2498 pub fn gegl_param_spec_file_path(
2499 name: *const c_char,
2500 nick: *const c_char,
2501 blurb: *const c_char,
2502 no_validate: gboolean,
2503 null_ok: gboolean,
2504 default_value: *const c_char,
2505 flags: gobject::GParamFlags,
2506 ) -> *mut gobject::GParamSpec;
2507 pub fn gegl_param_spec_format(
2508 name: *const c_char,
2509 nick: *const c_char,
2510 blurb: *const c_char,
2511 flags: gobject::GParamFlags,
2512 ) -> *mut gobject::GParamSpec;
2513 pub fn gegl_param_spec_get_property_key(
2514 pspec: *mut gobject::GParamSpec,
2515 key_name: *const c_char,
2516 ) -> *const c_char;
2517 pub fn gegl_param_spec_int(
2518 name: *const c_char,
2519 nick: *const c_char,
2520 blurb: *const c_char,
2521 minimum: c_int,
2522 maximum: c_int,
2523 default_value: c_int,
2524 ui_minimum: c_int,
2525 ui_maximum: c_int,
2526 ui_gamma: c_double,
2527 flags: gobject::GParamFlags,
2528 ) -> *mut gobject::GParamSpec;
2529 pub fn gegl_param_spec_path(
2530 name: *const c_char,
2531 nick: *const c_char,
2532 blurb: *const c_char,
2533 default_path: *mut GeglPath,
2534 flags: gobject::GParamFlags,
2535 ) -> *mut gobject::GParamSpec;
2536 pub fn gegl_param_spec_seed(
2537 name: *const c_char,
2538 nick: *const c_char,
2539 blurb: *const c_char,
2540 flags: gobject::GParamFlags,
2541 ) -> *mut gobject::GParamSpec;
2542 pub fn gegl_param_spec_set_property_key(
2543 pspec: *mut gobject::GParamSpec,
2544 key_name: *const c_char,
2545 value: *const c_char,
2546 );
2547 pub fn gegl_param_spec_string(
2548 name: *const c_char,
2549 nick: *const c_char,
2550 blurb: *const c_char,
2551 no_validate: gboolean,
2552 null_ok: gboolean,
2553 default_value: *const c_char,
2554 flags: gobject::GParamFlags,
2555 ) -> *mut gobject::GParamSpec;
2556 pub fn gegl_param_spec_uri(
2557 name: *const c_char,
2558 nick: *const c_char,
2559 blurb: *const c_char,
2560 no_validate: gboolean,
2561 null_ok: gboolean,
2562 default_value: *const c_char,
2563 flags: gobject::GParamFlags,
2564 ) -> *mut gobject::GParamSpec;
2565 pub fn gegl_render_op(
2566 source_buffer: *mut GeglBuffer,
2567 target_buffer: *mut GeglBuffer,
2568 operation_name: *const c_char,
2569 ...
2570 );
2571 pub fn gegl_reset_stats();
2573 pub fn gegl_scratch_alloc(size: size_t) -> gpointer;
2574 pub fn gegl_scratch_alloc0(size: size_t) -> gpointer;
2575 pub fn gegl_scratch_free(ptr: gpointer);
2576 pub fn gegl_serialize(
2577 start: *mut GeglNode,
2578 end: *mut GeglNode,
2579 basepath: *const c_char,
2580 serialize_flags: GeglSerializeFlag,
2581 ) -> *mut c_char;
2582 pub fn gegl_stats() -> *mut GeglStats;
2583 pub fn gegl_try_malloc(n_bytes: size_t) -> gpointer;
2584
2585}