gstreamer_editing_services/auto/
meta_container.rs1#[cfg(feature = "v1_18")]
7#[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
8use crate::MarkerList;
9use crate::{MetaFlag, ffi};
10use glib::{
11 object::ObjectType as _,
12 prelude::*,
13 signal::{SignalHandlerId, connect_raw},
14 translate::*,
15};
16use std::boxed::Box as Box_;
17
18glib::wrapper! {
19 #[doc(alias = "GESMetaContainer")]
20 pub struct MetaContainer(Interface<ffi::GESMetaContainer, ffi::GESMetaContainerInterface>);
21
22 match fn {
23 type_ => || ffi::ges_meta_container_get_type(),
24 }
25}
26
27impl MetaContainer {
28 pub const NONE: Option<&'static MetaContainer> = None;
29}
30
31pub trait MetaContainerExt: IsA<MetaContainer> + 'static {
32 #[doc(alias = "ges_meta_container_add_metas_from_string")]
33 fn add_metas_from_string(&self, str: &str) -> bool {
34 unsafe {
35 from_glib(ffi::ges_meta_container_add_metas_from_string(
36 self.as_ref().to_glib_none().0,
37 str.to_glib_none().0,
38 ))
39 }
40 }
41
42 #[doc(alias = "ges_meta_container_check_meta_registered")]
43 fn check_meta_registered(&self, meta_item: &str) -> Option<(MetaFlag, glib::types::Type)> {
44 unsafe {
45 let mut flags = std::mem::MaybeUninit::uninit();
46 let mut type_ = std::mem::MaybeUninit::uninit();
47 let ret = from_glib(ffi::ges_meta_container_check_meta_registered(
48 self.as_ref().to_glib_none().0,
49 meta_item.to_glib_none().0,
50 flags.as_mut_ptr(),
51 type_.as_mut_ptr(),
52 ));
53 if ret {
54 Some((
55 from_glib(flags.assume_init()),
56 from_glib(type_.assume_init()),
57 ))
58 } else {
59 None
60 }
61 }
62 }
63
64 #[doc(alias = "ges_meta_container_foreach")]
65 fn foreach<P: FnMut(&MetaContainer, &str, &glib::Value)>(&self, func: P) {
66 let mut func_data: P = func;
67 unsafe extern "C" fn func_func<P: FnMut(&MetaContainer, &str, &glib::Value)>(
68 container: *const ffi::GESMetaContainer,
69 key: *const std::ffi::c_char,
70 value: *const glib::gobject_ffi::GValue,
71 user_data: glib::ffi::gpointer,
72 ) {
73 unsafe {
74 let container = from_glib_borrow(container);
75 let key: Borrowed<glib::GString> = from_glib_borrow(key);
76 let value = from_glib_borrow(value);
77 let callback = user_data as *mut P;
78 (*callback)(&container, key.as_str(), &value)
79 }
80 }
81 let func = Some(func_func::<P> as _);
82 let super_callback0: &mut P = &mut func_data;
83 unsafe {
84 ffi::ges_meta_container_foreach(
85 self.as_ref().to_glib_none().0,
86 func,
87 super_callback0 as *mut _ as *mut _,
88 );
89 }
90 }
91
92 #[doc(alias = "ges_meta_container_get_boolean")]
93 #[doc(alias = "get_boolean")]
94 fn boolean(&self, meta_item: &str) -> Option<bool> {
95 unsafe {
96 let mut dest = std::mem::MaybeUninit::uninit();
97 let ret = from_glib(ffi::ges_meta_container_get_boolean(
98 self.as_ref().to_glib_none().0,
99 meta_item.to_glib_none().0,
100 dest.as_mut_ptr(),
101 ));
102 if ret {
103 Some(from_glib(dest.assume_init()))
104 } else {
105 None
106 }
107 }
108 }
109
110 #[doc(alias = "ges_meta_container_get_date")]
111 #[doc(alias = "get_date")]
112 fn date(&self, meta_item: &str) -> Option<glib::Date> {
113 unsafe {
114 let mut dest = std::ptr::null_mut();
115 let ret = from_glib(ffi::ges_meta_container_get_date(
116 self.as_ref().to_glib_none().0,
117 meta_item.to_glib_none().0,
118 &mut dest,
119 ));
120 if ret {
121 Some(from_glib_full(dest))
122 } else {
123 None
124 }
125 }
126 }
127
128 #[doc(alias = "ges_meta_container_get_date_time")]
129 #[doc(alias = "get_date_time")]
130 fn date_time(&self, meta_item: &str) -> Option<gst::DateTime> {
131 unsafe {
132 let mut dest = std::ptr::null_mut();
133 let ret = from_glib(ffi::ges_meta_container_get_date_time(
134 self.as_ref().to_glib_none().0,
135 meta_item.to_glib_none().0,
136 &mut dest,
137 ));
138 if ret {
139 Some(from_glib_full(dest))
140 } else {
141 None
142 }
143 }
144 }
145
146 #[doc(alias = "ges_meta_container_get_double")]
147 #[doc(alias = "get_double")]
148 fn double(&self, meta_item: &str) -> Option<f64> {
149 unsafe {
150 let mut dest = std::mem::MaybeUninit::uninit();
151 let ret = from_glib(ffi::ges_meta_container_get_double(
152 self.as_ref().to_glib_none().0,
153 meta_item.to_glib_none().0,
154 dest.as_mut_ptr(),
155 ));
156 if ret { Some(dest.assume_init()) } else { None }
157 }
158 }
159
160 #[doc(alias = "ges_meta_container_get_float")]
161 #[doc(alias = "get_float")]
162 fn float(&self, meta_item: &str) -> Option<f32> {
163 unsafe {
164 let mut dest = std::mem::MaybeUninit::uninit();
165 let ret = from_glib(ffi::ges_meta_container_get_float(
166 self.as_ref().to_glib_none().0,
167 meta_item.to_glib_none().0,
168 dest.as_mut_ptr(),
169 ));
170 if ret { Some(dest.assume_init()) } else { None }
171 }
172 }
173
174 #[doc(alias = "ges_meta_container_get_int")]
175 #[doc(alias = "get_int")]
176 fn int(&self, meta_item: &str) -> Option<i32> {
177 unsafe {
178 let mut dest = std::mem::MaybeUninit::uninit();
179 let ret = from_glib(ffi::ges_meta_container_get_int(
180 self.as_ref().to_glib_none().0,
181 meta_item.to_glib_none().0,
182 dest.as_mut_ptr(),
183 ));
184 if ret { Some(dest.assume_init()) } else { None }
185 }
186 }
187
188 #[doc(alias = "ges_meta_container_get_int64")]
189 #[doc(alias = "get_int64")]
190 fn int64(&self, meta_item: &str) -> Option<i64> {
191 unsafe {
192 let mut dest = std::mem::MaybeUninit::uninit();
193 let ret = from_glib(ffi::ges_meta_container_get_int64(
194 self.as_ref().to_glib_none().0,
195 meta_item.to_glib_none().0,
196 dest.as_mut_ptr(),
197 ));
198 if ret { Some(dest.assume_init()) } else { None }
199 }
200 }
201
202 #[cfg(feature = "v1_18")]
203 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
204 #[doc(alias = "ges_meta_container_get_marker_list")]
205 #[doc(alias = "get_marker_list")]
206 fn marker_list(&self, key: &str) -> Option<MarkerList> {
207 unsafe {
208 from_glib_full(ffi::ges_meta_container_get_marker_list(
209 self.as_ref().to_glib_none().0,
210 key.to_glib_none().0,
211 ))
212 }
213 }
214
215 #[doc(alias = "ges_meta_container_get_meta")]
216 #[doc(alias = "get_meta")]
217 fn meta(&self, key: &str) -> Option<glib::Value> {
218 unsafe {
219 from_glib_none(ffi::ges_meta_container_get_meta(
220 self.as_ref().to_glib_none().0,
221 key.to_glib_none().0,
222 ))
223 }
224 }
225
226 #[doc(alias = "ges_meta_container_get_string")]
227 #[doc(alias = "get_string")]
228 fn string(&self, meta_item: &str) -> Option<glib::GString> {
229 unsafe {
230 from_glib_none(ffi::ges_meta_container_get_string(
231 self.as_ref().to_glib_none().0,
232 meta_item.to_glib_none().0,
233 ))
234 }
235 }
236
237 #[doc(alias = "ges_meta_container_get_uint")]
238 #[doc(alias = "get_uint")]
239 fn uint(&self, meta_item: &str) -> Option<u32> {
240 unsafe {
241 let mut dest = std::mem::MaybeUninit::uninit();
242 let ret = from_glib(ffi::ges_meta_container_get_uint(
243 self.as_ref().to_glib_none().0,
244 meta_item.to_glib_none().0,
245 dest.as_mut_ptr(),
246 ));
247 if ret { Some(dest.assume_init()) } else { None }
248 }
249 }
250
251 #[doc(alias = "ges_meta_container_get_uint64")]
252 #[doc(alias = "get_uint64")]
253 fn uint64(&self, meta_item: &str) -> Option<u64> {
254 unsafe {
255 let mut dest = std::mem::MaybeUninit::uninit();
256 let ret = from_glib(ffi::ges_meta_container_get_uint64(
257 self.as_ref().to_glib_none().0,
258 meta_item.to_glib_none().0,
259 dest.as_mut_ptr(),
260 ));
261 if ret { Some(dest.assume_init()) } else { None }
262 }
263 }
264
265 #[doc(alias = "ges_meta_container_metas_to_string")]
266 fn metas_to_string(&self) -> glib::GString {
267 unsafe {
268 from_glib_full(ffi::ges_meta_container_metas_to_string(
269 self.as_ref().to_glib_none().0,
270 ))
271 }
272 }
273
274 #[doc(alias = "ges_meta_container_register_meta")]
275 fn register_meta(&self, flags: MetaFlag, meta_item: &str, value: &glib::Value) -> bool {
276 unsafe {
277 from_glib(ffi::ges_meta_container_register_meta(
278 self.as_ref().to_glib_none().0,
279 flags.into_glib(),
280 meta_item.to_glib_none().0,
281 value.to_glib_none().0,
282 ))
283 }
284 }
285
286 #[doc(alias = "ges_meta_container_register_meta_boolean")]
287 fn register_meta_boolean(&self, flags: MetaFlag, meta_item: &str, value: bool) -> bool {
288 unsafe {
289 from_glib(ffi::ges_meta_container_register_meta_boolean(
290 self.as_ref().to_glib_none().0,
291 flags.into_glib(),
292 meta_item.to_glib_none().0,
293 value.into_glib(),
294 ))
295 }
296 }
297
298 #[doc(alias = "ges_meta_container_register_meta_date")]
299 fn register_meta_date(&self, flags: MetaFlag, meta_item: &str, value: &glib::Date) -> bool {
300 unsafe {
301 from_glib(ffi::ges_meta_container_register_meta_date(
302 self.as_ref().to_glib_none().0,
303 flags.into_glib(),
304 meta_item.to_glib_none().0,
305 value.to_glib_none().0,
306 ))
307 }
308 }
309
310 #[doc(alias = "ges_meta_container_register_meta_date_time")]
311 fn register_meta_date_time(
312 &self,
313 flags: MetaFlag,
314 meta_item: &str,
315 value: &gst::DateTime,
316 ) -> bool {
317 unsafe {
318 from_glib(ffi::ges_meta_container_register_meta_date_time(
319 self.as_ref().to_glib_none().0,
320 flags.into_glib(),
321 meta_item.to_glib_none().0,
322 value.to_glib_none().0,
323 ))
324 }
325 }
326
327 #[doc(alias = "ges_meta_container_register_meta_double")]
328 fn register_meta_double(&self, flags: MetaFlag, meta_item: &str, value: f64) -> bool {
329 unsafe {
330 from_glib(ffi::ges_meta_container_register_meta_double(
331 self.as_ref().to_glib_none().0,
332 flags.into_glib(),
333 meta_item.to_glib_none().0,
334 value,
335 ))
336 }
337 }
338
339 #[doc(alias = "ges_meta_container_register_meta_float")]
340 fn register_meta_float(&self, flags: MetaFlag, meta_item: &str, value: f32) -> bool {
341 unsafe {
342 from_glib(ffi::ges_meta_container_register_meta_float(
343 self.as_ref().to_glib_none().0,
344 flags.into_glib(),
345 meta_item.to_glib_none().0,
346 value,
347 ))
348 }
349 }
350
351 #[doc(alias = "ges_meta_container_register_meta_int")]
352 fn register_meta_int(&self, flags: MetaFlag, meta_item: &str, value: i32) -> bool {
353 unsafe {
354 from_glib(ffi::ges_meta_container_register_meta_int(
355 self.as_ref().to_glib_none().0,
356 flags.into_glib(),
357 meta_item.to_glib_none().0,
358 value,
359 ))
360 }
361 }
362
363 #[doc(alias = "ges_meta_container_register_meta_int64")]
364 fn register_meta_int64(&self, flags: MetaFlag, meta_item: &str, value: i64) -> bool {
365 unsafe {
366 from_glib(ffi::ges_meta_container_register_meta_int64(
367 self.as_ref().to_glib_none().0,
368 flags.into_glib(),
369 meta_item.to_glib_none().0,
370 value,
371 ))
372 }
373 }
374
375 #[doc(alias = "ges_meta_container_register_meta_string")]
376 fn register_meta_string(&self, flags: MetaFlag, meta_item: &str, value: &str) -> bool {
377 unsafe {
378 from_glib(ffi::ges_meta_container_register_meta_string(
379 self.as_ref().to_glib_none().0,
380 flags.into_glib(),
381 meta_item.to_glib_none().0,
382 value.to_glib_none().0,
383 ))
384 }
385 }
386
387 #[doc(alias = "ges_meta_container_register_meta_uint")]
388 fn register_meta_uint(&self, flags: MetaFlag, meta_item: &str, value: u32) -> bool {
389 unsafe {
390 from_glib(ffi::ges_meta_container_register_meta_uint(
391 self.as_ref().to_glib_none().0,
392 flags.into_glib(),
393 meta_item.to_glib_none().0,
394 value,
395 ))
396 }
397 }
398
399 #[doc(alias = "ges_meta_container_register_meta_uint64")]
400 fn register_meta_uint64(&self, flags: MetaFlag, meta_item: &str, value: u64) -> bool {
401 unsafe {
402 from_glib(ffi::ges_meta_container_register_meta_uint64(
403 self.as_ref().to_glib_none().0,
404 flags.into_glib(),
405 meta_item.to_glib_none().0,
406 value,
407 ))
408 }
409 }
410
411 #[cfg(feature = "v1_18")]
412 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
413 #[doc(alias = "ges_meta_container_register_static_meta")]
414 fn register_static_meta(
415 &self,
416 flags: MetaFlag,
417 meta_item: &str,
418 type_: glib::types::Type,
419 ) -> bool {
420 unsafe {
421 from_glib(ffi::ges_meta_container_register_static_meta(
422 self.as_ref().to_glib_none().0,
423 flags.into_glib(),
424 meta_item.to_glib_none().0,
425 type_.into_glib(),
426 ))
427 }
428 }
429
430 #[doc(alias = "ges_meta_container_set_boolean")]
431 fn set_boolean(&self, meta_item: &str, value: bool) -> bool {
432 unsafe {
433 from_glib(ffi::ges_meta_container_set_boolean(
434 self.as_ref().to_glib_none().0,
435 meta_item.to_glib_none().0,
436 value.into_glib(),
437 ))
438 }
439 }
440
441 #[doc(alias = "ges_meta_container_set_date")]
442 fn set_date(&self, meta_item: &str, value: &glib::Date) -> bool {
443 unsafe {
444 from_glib(ffi::ges_meta_container_set_date(
445 self.as_ref().to_glib_none().0,
446 meta_item.to_glib_none().0,
447 value.to_glib_none().0,
448 ))
449 }
450 }
451
452 #[doc(alias = "ges_meta_container_set_date_time")]
453 fn set_date_time(&self, meta_item: &str, value: &gst::DateTime) -> bool {
454 unsafe {
455 from_glib(ffi::ges_meta_container_set_date_time(
456 self.as_ref().to_glib_none().0,
457 meta_item.to_glib_none().0,
458 value.to_glib_none().0,
459 ))
460 }
461 }
462
463 #[doc(alias = "ges_meta_container_set_double")]
464 fn set_double(&self, meta_item: &str, value: f64) -> bool {
465 unsafe {
466 from_glib(ffi::ges_meta_container_set_double(
467 self.as_ref().to_glib_none().0,
468 meta_item.to_glib_none().0,
469 value,
470 ))
471 }
472 }
473
474 #[doc(alias = "ges_meta_container_set_float")]
475 fn set_float(&self, meta_item: &str, value: f32) -> bool {
476 unsafe {
477 from_glib(ffi::ges_meta_container_set_float(
478 self.as_ref().to_glib_none().0,
479 meta_item.to_glib_none().0,
480 value,
481 ))
482 }
483 }
484
485 #[doc(alias = "ges_meta_container_set_int")]
486 fn set_int(&self, meta_item: &str, value: i32) -> bool {
487 unsafe {
488 from_glib(ffi::ges_meta_container_set_int(
489 self.as_ref().to_glib_none().0,
490 meta_item.to_glib_none().0,
491 value,
492 ))
493 }
494 }
495
496 #[doc(alias = "ges_meta_container_set_int64")]
497 fn set_int64(&self, meta_item: &str, value: i64) -> bool {
498 unsafe {
499 from_glib(ffi::ges_meta_container_set_int64(
500 self.as_ref().to_glib_none().0,
501 meta_item.to_glib_none().0,
502 value,
503 ))
504 }
505 }
506
507 #[cfg(feature = "v1_18")]
508 #[cfg_attr(docsrs, doc(cfg(feature = "v1_18")))]
509 #[doc(alias = "ges_meta_container_set_marker_list")]
510 fn set_marker_list(&self, meta_item: &str, list: &MarkerList) -> bool {
511 unsafe {
512 from_glib(ffi::ges_meta_container_set_marker_list(
513 self.as_ref().to_glib_none().0,
514 meta_item.to_glib_none().0,
515 list.to_glib_none().0,
516 ))
517 }
518 }
519
520 #[doc(alias = "ges_meta_container_set_meta")]
521 fn set_meta(&self, meta_item: &str, value: Option<&glib::Value>) -> bool {
522 unsafe {
523 from_glib(ffi::ges_meta_container_set_meta(
524 self.as_ref().to_glib_none().0,
525 meta_item.to_glib_none().0,
526 value.to_glib_none().0,
527 ))
528 }
529 }
530
531 #[doc(alias = "ges_meta_container_set_string")]
532 fn set_string(&self, meta_item: &str, value: &str) -> bool {
533 unsafe {
534 from_glib(ffi::ges_meta_container_set_string(
535 self.as_ref().to_glib_none().0,
536 meta_item.to_glib_none().0,
537 value.to_glib_none().0,
538 ))
539 }
540 }
541
542 #[doc(alias = "ges_meta_container_set_uint")]
543 fn set_uint(&self, meta_item: &str, value: u32) -> bool {
544 unsafe {
545 from_glib(ffi::ges_meta_container_set_uint(
546 self.as_ref().to_glib_none().0,
547 meta_item.to_glib_none().0,
548 value,
549 ))
550 }
551 }
552
553 #[doc(alias = "ges_meta_container_set_uint64")]
554 fn set_uint64(&self, meta_item: &str, value: u64) -> bool {
555 unsafe {
556 from_glib(ffi::ges_meta_container_set_uint64(
557 self.as_ref().to_glib_none().0,
558 meta_item.to_glib_none().0,
559 value,
560 ))
561 }
562 }
563
564 #[doc(alias = "notify-meta")]
565 fn connect_notify_meta<F: Fn(&Self, &str, Option<&glib::Value>) + 'static>(
566 &self,
567 detail: Option<&str>,
568 f: F,
569 ) -> SignalHandlerId {
570 unsafe extern "C" fn notify_meta_trampoline<
571 P: IsA<MetaContainer>,
572 F: Fn(&P, &str, Option<&glib::Value>) + 'static,
573 >(
574 this: *mut ffi::GESMetaContainer,
575 key: *mut std::ffi::c_char,
576 value: *mut glib::gobject_ffi::GValue,
577 f: glib::ffi::gpointer,
578 ) {
579 unsafe {
580 let f: &F = &*(f as *const F);
581 f(
582 MetaContainer::from_glib_borrow(this).unsafe_cast_ref(),
583 &glib::GString::from_glib_borrow(key),
584 Option::<glib::Value>::from_glib_borrow(value)
585 .as_ref()
586 .as_ref(),
587 )
588 }
589 }
590 unsafe {
591 let f: Box_<F> = Box_::new(f);
592 let detailed_signal_name = detail.map(|name| format!("notify-meta::{name}\0"));
593 let signal_name = detailed_signal_name.as_ref().map_or(c"notify-meta", |n| {
594 std::ffi::CStr::from_bytes_with_nul_unchecked(n.as_bytes())
595 });
596 connect_raw(
597 self.as_ptr() as *mut _,
598 signal_name.as_ptr(),
599 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
600 notify_meta_trampoline::<Self, F> as *const (),
601 )),
602 Box_::into_raw(f),
603 )
604 }
605 }
606}
607
608impl<O: IsA<MetaContainer>> MetaContainerExt for O {}