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