1#[cfg(feature = "v2_82")]
6#[cfg_attr(docsrs, doc(cfg(feature = "v2_82")))]
7use crate::SettingsBindFlags;
8use crate::{ffi, Action, SettingsBackend, SettingsSchema};
9use glib::{
10 object::ObjectType as _,
11 prelude::*,
12 signal::{connect_raw, SignalHandlerId},
13 translate::*,
14};
15use std::boxed::Box as Box_;
16
17glib::wrapper! {
18 #[doc(alias = "GSettings")]
19 pub struct Settings(Object<ffi::GSettings, ffi::GSettingsClass>);
20
21 match fn {
22 type_ => || ffi::g_settings_get_type(),
23 }
24}
25
26impl Settings {
27 pub const NONE: Option<&'static Settings> = None;
28
29 #[doc(alias = "g_settings_new")]
30 pub fn new(schema_id: &str) -> Settings {
31 unsafe { from_glib_full(ffi::g_settings_new(schema_id.to_glib_none().0)) }
32 }
33
34 #[doc(alias = "g_settings_new_full")]
35 pub fn new_full(
36 schema: &SettingsSchema,
37 backend: Option<&impl IsA<SettingsBackend>>,
38 path: Option<&str>,
39 ) -> Settings {
40 unsafe {
41 from_glib_full(ffi::g_settings_new_full(
42 schema.to_glib_none().0,
43 backend.map(|p| p.as_ref()).to_glib_none().0,
44 path.to_glib_none().0,
45 ))
46 }
47 }
48
49 #[doc(alias = "g_settings_new_with_backend")]
50 #[doc(alias = "new_with_backend")]
51 pub fn with_backend(schema_id: &str, backend: &impl IsA<SettingsBackend>) -> Settings {
52 unsafe {
53 from_glib_full(ffi::g_settings_new_with_backend(
54 schema_id.to_glib_none().0,
55 backend.as_ref().to_glib_none().0,
56 ))
57 }
58 }
59
60 #[doc(alias = "g_settings_new_with_backend_and_path")]
61 #[doc(alias = "new_with_backend_and_path")]
62 pub fn with_backend_and_path(
63 schema_id: &str,
64 backend: &impl IsA<SettingsBackend>,
65 path: &str,
66 ) -> Settings {
67 unsafe {
68 from_glib_full(ffi::g_settings_new_with_backend_and_path(
69 schema_id.to_glib_none().0,
70 backend.as_ref().to_glib_none().0,
71 path.to_glib_none().0,
72 ))
73 }
74 }
75
76 #[doc(alias = "g_settings_new_with_path")]
77 #[doc(alias = "new_with_path")]
78 pub fn with_path(schema_id: &str, path: &str) -> Settings {
79 unsafe {
80 from_glib_full(ffi::g_settings_new_with_path(
81 schema_id.to_glib_none().0,
82 path.to_glib_none().0,
83 ))
84 }
85 }
86
87 #[doc(alias = "g_settings_sync")]
88 pub fn sync() {
89 unsafe {
90 ffi::g_settings_sync();
91 }
92 }
93
94 #[doc(alias = "g_settings_unbind")]
95 pub fn unbind(object: &impl IsA<glib::Object>, property: &str) {
96 unsafe {
97 ffi::g_settings_unbind(object.as_ref().to_glib_none().0, property.to_glib_none().0);
98 }
99 }
100}
101
102pub trait SettingsExt: IsA<Settings> + 'static {
103 #[doc(alias = "g_settings_apply")]
104 fn apply(&self) {
105 unsafe {
106 ffi::g_settings_apply(self.as_ref().to_glib_none().0);
107 }
108 }
109
110 #[cfg(feature = "v2_82")]
111 #[cfg_attr(docsrs, doc(cfg(feature = "v2_82")))]
112 #[doc(alias = "g_settings_bind_with_mapping_closures")]
113 fn bind_with_mapping_closures(
114 &self,
115 key: &str,
116 object: &impl IsA<glib::Object>,
117 property: &str,
118 flags: SettingsBindFlags,
119 get_mapping: Option<&glib::Closure>,
120 set_mapping: Option<&glib::Closure>,
121 ) {
122 unsafe {
123 ffi::g_settings_bind_with_mapping_closures(
124 self.as_ref().to_glib_none().0,
125 key.to_glib_none().0,
126 object.as_ref().to_glib_none().0,
127 property.to_glib_none().0,
128 flags.into_glib(),
129 get_mapping.to_glib_none().0,
130 set_mapping.to_glib_none().0,
131 );
132 }
133 }
134
135 #[doc(alias = "g_settings_bind_writable")]
136 fn bind_writable(
137 &self,
138 key: &str,
139 object: &impl IsA<glib::Object>,
140 property: &str,
141 inverted: bool,
142 ) {
143 unsafe {
144 ffi::g_settings_bind_writable(
145 self.as_ref().to_glib_none().0,
146 key.to_glib_none().0,
147 object.as_ref().to_glib_none().0,
148 property.to_glib_none().0,
149 inverted.into_glib(),
150 );
151 }
152 }
153
154 #[doc(alias = "g_settings_create_action")]
155 fn create_action(&self, key: &str) -> Action {
156 unsafe {
157 from_glib_full(ffi::g_settings_create_action(
158 self.as_ref().to_glib_none().0,
159 key.to_glib_none().0,
160 ))
161 }
162 }
163
164 #[doc(alias = "g_settings_delay")]
165 fn delay(&self) {
166 unsafe {
167 ffi::g_settings_delay(self.as_ref().to_glib_none().0);
168 }
169 }
170
171 #[doc(alias = "g_settings_get_boolean")]
177 #[doc(alias = "get_boolean")]
178 fn boolean(&self, key: &str) -> bool {
179 unsafe {
180 from_glib(ffi::g_settings_get_boolean(
181 self.as_ref().to_glib_none().0,
182 key.to_glib_none().0,
183 ))
184 }
185 }
186
187 #[doc(alias = "g_settings_get_child")]
188 #[doc(alias = "get_child")]
189 #[must_use]
190 fn child(&self, name: &str) -> Settings {
191 unsafe {
192 from_glib_full(ffi::g_settings_get_child(
193 self.as_ref().to_glib_none().0,
194 name.to_glib_none().0,
195 ))
196 }
197 }
198
199 #[doc(alias = "g_settings_get_default_value")]
200 #[doc(alias = "get_default_value")]
201 fn default_value(&self, key: &str) -> Option<glib::Variant> {
202 unsafe {
203 from_glib_full(ffi::g_settings_get_default_value(
204 self.as_ref().to_glib_none().0,
205 key.to_glib_none().0,
206 ))
207 }
208 }
209
210 #[doc(alias = "g_settings_get_double")]
211 #[doc(alias = "get_double")]
212 fn double(&self, key: &str) -> f64 {
213 unsafe { ffi::g_settings_get_double(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
214 }
215
216 #[doc(alias = "g_settings_get_enum")]
217 #[doc(alias = "get_enum")]
218 fn enum_(&self, key: &str) -> i32 {
219 unsafe { ffi::g_settings_get_enum(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
220 }
221
222 #[doc(alias = "g_settings_get_flags")]
223 #[doc(alias = "get_flags")]
224 fn flags(&self, key: &str) -> u32 {
225 unsafe { ffi::g_settings_get_flags(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
226 }
227
228 #[doc(alias = "g_settings_get_has_unapplied")]
229 #[doc(alias = "get_has_unapplied")]
230 #[doc(alias = "has-unapplied")]
231 fn has_unapplied(&self) -> bool {
232 unsafe {
233 from_glib(ffi::g_settings_get_has_unapplied(
234 self.as_ref().to_glib_none().0,
235 ))
236 }
237 }
238
239 #[doc(alias = "g_settings_get_int")]
240 #[doc(alias = "get_int")]
241 fn int(&self, key: &str) -> i32 {
242 unsafe { ffi::g_settings_get_int(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
243 }
244
245 #[doc(alias = "g_settings_get_int64")]
246 #[doc(alias = "get_int64")]
247 fn int64(&self, key: &str) -> i64 {
248 unsafe { ffi::g_settings_get_int64(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
249 }
250
251 #[doc(alias = "g_settings_get_string")]
258 #[doc(alias = "get_string")]
259 fn string(&self, key: &str) -> glib::GString {
260 unsafe {
261 from_glib_full(ffi::g_settings_get_string(
262 self.as_ref().to_glib_none().0,
263 key.to_glib_none().0,
264 ))
265 }
266 }
267
268 #[doc(alias = "g_settings_get_uint")]
269 #[doc(alias = "get_uint")]
270 fn uint(&self, key: &str) -> u32 {
271 unsafe { ffi::g_settings_get_uint(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
272 }
273
274 #[doc(alias = "g_settings_get_uint64")]
275 #[doc(alias = "get_uint64")]
276 fn uint64(&self, key: &str) -> u64 {
277 unsafe { ffi::g_settings_get_uint64(self.as_ref().to_glib_none().0, key.to_glib_none().0) }
278 }
279
280 #[doc(alias = "g_settings_get_user_value")]
281 #[doc(alias = "get_user_value")]
282 fn user_value(&self, key: &str) -> Option<glib::Variant> {
283 unsafe {
284 from_glib_full(ffi::g_settings_get_user_value(
285 self.as_ref().to_glib_none().0,
286 key.to_glib_none().0,
287 ))
288 }
289 }
290
291 #[doc(alias = "g_settings_get_value")]
292 #[doc(alias = "get_value")]
293 fn value(&self, key: &str) -> glib::Variant {
294 unsafe {
295 from_glib_full(ffi::g_settings_get_value(
296 self.as_ref().to_glib_none().0,
297 key.to_glib_none().0,
298 ))
299 }
300 }
301
302 #[doc(alias = "g_settings_is_writable")]
303 fn is_writable(&self, name: &str) -> bool {
304 unsafe {
305 from_glib(ffi::g_settings_is_writable(
306 self.as_ref().to_glib_none().0,
307 name.to_glib_none().0,
308 ))
309 }
310 }
311
312 #[doc(alias = "g_settings_list_children")]
313 fn list_children(&self) -> Vec<glib::GString> {
314 unsafe {
315 FromGlibPtrContainer::from_glib_full(ffi::g_settings_list_children(
316 self.as_ref().to_glib_none().0,
317 ))
318 }
319 }
320
321 #[doc(alias = "g_settings_reset")]
322 fn reset(&self, key: &str) {
323 unsafe {
324 ffi::g_settings_reset(self.as_ref().to_glib_none().0, key.to_glib_none().0);
325 }
326 }
327
328 #[doc(alias = "g_settings_revert")]
329 fn revert(&self) {
330 unsafe {
331 ffi::g_settings_revert(self.as_ref().to_glib_none().0);
332 }
333 }
334
335 #[doc(alias = "g_settings_set_boolean")]
341 fn set_boolean(&self, key: &str, value: bool) -> Result<(), glib::error::BoolError> {
342 unsafe {
343 glib::result_from_gboolean!(
344 ffi::g_settings_set_boolean(
345 self.as_ref().to_glib_none().0,
346 key.to_glib_none().0,
347 value.into_glib()
348 ),
349 "Can't set readonly key"
350 )
351 }
352 }
353
354 #[doc(alias = "g_settings_set_double")]
355 fn set_double(&self, key: &str, value: f64) -> Result<(), glib::error::BoolError> {
356 unsafe {
357 glib::result_from_gboolean!(
358 ffi::g_settings_set_double(
359 self.as_ref().to_glib_none().0,
360 key.to_glib_none().0,
361 value
362 ),
363 "Can't set readonly key"
364 )
365 }
366 }
367
368 #[doc(alias = "g_settings_set_enum")]
369 fn set_enum(&self, key: &str, value: i32) -> Result<(), glib::error::BoolError> {
370 unsafe {
371 glib::result_from_gboolean!(
372 ffi::g_settings_set_enum(
373 self.as_ref().to_glib_none().0,
374 key.to_glib_none().0,
375 value
376 ),
377 "Can't set readonly key"
378 )
379 }
380 }
381
382 #[doc(alias = "g_settings_set_flags")]
383 fn set_flags(&self, key: &str, value: u32) -> Result<(), glib::error::BoolError> {
384 unsafe {
385 glib::result_from_gboolean!(
386 ffi::g_settings_set_flags(
387 self.as_ref().to_glib_none().0,
388 key.to_glib_none().0,
389 value
390 ),
391 "Can't set readonly key"
392 )
393 }
394 }
395
396 #[doc(alias = "g_settings_set_int")]
397 fn set_int(&self, key: &str, value: i32) -> Result<(), glib::error::BoolError> {
398 unsafe {
399 glib::result_from_gboolean!(
400 ffi::g_settings_set_int(
401 self.as_ref().to_glib_none().0,
402 key.to_glib_none().0,
403 value
404 ),
405 "Can't set readonly key"
406 )
407 }
408 }
409
410 #[doc(alias = "g_settings_set_int64")]
411 fn set_int64(&self, key: &str, value: i64) -> Result<(), glib::error::BoolError> {
412 unsafe {
413 glib::result_from_gboolean!(
414 ffi::g_settings_set_int64(
415 self.as_ref().to_glib_none().0,
416 key.to_glib_none().0,
417 value
418 ),
419 "Can't set readonly key"
420 )
421 }
422 }
423
424 #[doc(alias = "g_settings_set_string")]
425 fn set_string(&self, key: &str, value: &str) -> Result<(), glib::error::BoolError> {
426 unsafe {
427 glib::result_from_gboolean!(
428 ffi::g_settings_set_string(
429 self.as_ref().to_glib_none().0,
430 key.to_glib_none().0,
431 value.to_glib_none().0
432 ),
433 "Can't set readonly key"
434 )
435 }
436 }
437
438 #[doc(alias = "g_settings_set_uint")]
439 fn set_uint(&self, key: &str, value: u32) -> Result<(), glib::error::BoolError> {
440 unsafe {
441 glib::result_from_gboolean!(
442 ffi::g_settings_set_uint(
443 self.as_ref().to_glib_none().0,
444 key.to_glib_none().0,
445 value
446 ),
447 "Can't set readonly key"
448 )
449 }
450 }
451
452 #[doc(alias = "g_settings_set_uint64")]
453 fn set_uint64(&self, key: &str, value: u64) -> Result<(), glib::error::BoolError> {
454 unsafe {
455 glib::result_from_gboolean!(
456 ffi::g_settings_set_uint64(
457 self.as_ref().to_glib_none().0,
458 key.to_glib_none().0,
459 value
460 ),
461 "Can't set readonly key"
462 )
463 }
464 }
465
466 #[doc(alias = "g_settings_set_value")]
467 fn set_value(&self, key: &str, value: &glib::Variant) -> Result<(), glib::error::BoolError> {
468 unsafe {
469 glib::result_from_gboolean!(
470 ffi::g_settings_set_value(
471 self.as_ref().to_glib_none().0,
472 key.to_glib_none().0,
473 value.to_glib_none().0
474 ),
475 "Can't set readonly key"
476 )
477 }
478 }
479
480 fn backend(&self) -> Option<SettingsBackend> {
481 ObjectExt::property(self.as_ref(), "backend")
482 }
483
484 #[doc(alias = "delay-apply")]
485 fn is_delay_apply(&self) -> bool {
486 ObjectExt::property(self.as_ref(), "delay-apply")
487 }
488
489 fn path(&self) -> Option<glib::GString> {
490 ObjectExt::property(self.as_ref(), "path")
491 }
492
493 #[doc(alias = "schema-id")]
494 fn schema_id(&self) -> Option<glib::GString> {
495 ObjectExt::property(self.as_ref(), "schema-id")
496 }
497
498 #[doc(alias = "settings-schema")]
499 fn settings_schema(&self) -> Option<SettingsSchema> {
500 ObjectExt::property(self.as_ref(), "settings-schema")
501 }
502
503 #[doc(alias = "changed")]
509 fn connect_changed<F: Fn(&Self, &str) + 'static>(
510 &self,
511 detail: Option<&str>,
512 f: F,
513 ) -> SignalHandlerId {
514 unsafe extern "C" fn changed_trampoline<P: IsA<Settings>, F: Fn(&P, &str) + 'static>(
515 this: *mut ffi::GSettings,
516 key: *mut std::ffi::c_char,
517 f: glib::ffi::gpointer,
518 ) {
519 let f: &F = &*(f as *const F);
520 f(
521 Settings::from_glib_borrow(this).unsafe_cast_ref(),
522 &glib::GString::from_glib_borrow(key),
523 )
524 }
525 unsafe {
526 let f: Box_<F> = Box_::new(f);
527 let detailed_signal_name = detail.map(|name| format!("changed::{name}\0"));
528 let signal_name: &[u8] = detailed_signal_name
529 .as_ref()
530 .map_or(c"changed".to_bytes(), |n| n.as_bytes());
531 connect_raw(
532 self.as_ptr() as *mut _,
533 signal_name.as_ptr() as *const _,
534 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
535 changed_trampoline::<Self, F> as *const (),
536 )),
537 Box_::into_raw(f),
538 )
539 }
540 }
541
542 #[doc(alias = "writable-change-event")]
543 fn connect_writable_change_event<F: Fn(&Self, u32) -> glib::Propagation + 'static>(
544 &self,
545 f: F,
546 ) -> SignalHandlerId {
547 unsafe extern "C" fn writable_change_event_trampoline<
548 P: IsA<Settings>,
549 F: Fn(&P, u32) -> glib::Propagation + 'static,
550 >(
551 this: *mut ffi::GSettings,
552 key: std::ffi::c_uint,
553 f: glib::ffi::gpointer,
554 ) -> glib::ffi::gboolean {
555 let f: &F = &*(f as *const F);
556 f(Settings::from_glib_borrow(this).unsafe_cast_ref(), key).into_glib()
557 }
558 unsafe {
559 let f: Box_<F> = Box_::new(f);
560 connect_raw(
561 self.as_ptr() as *mut _,
562 c"writable-change-event".as_ptr() as *const _,
563 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
564 writable_change_event_trampoline::<Self, F> as *const (),
565 )),
566 Box_::into_raw(f),
567 )
568 }
569 }
570
571 #[doc(alias = "writable-changed")]
572 fn connect_writable_changed<F: Fn(&Self, &str) + 'static>(
573 &self,
574 detail: Option<&str>,
575 f: F,
576 ) -> SignalHandlerId {
577 unsafe extern "C" fn writable_changed_trampoline<
578 P: IsA<Settings>,
579 F: Fn(&P, &str) + 'static,
580 >(
581 this: *mut ffi::GSettings,
582 key: *mut std::ffi::c_char,
583 f: glib::ffi::gpointer,
584 ) {
585 let f: &F = &*(f as *const F);
586 f(
587 Settings::from_glib_borrow(this).unsafe_cast_ref(),
588 &glib::GString::from_glib_borrow(key),
589 )
590 }
591 unsafe {
592 let f: Box_<F> = Box_::new(f);
593 let detailed_signal_name = detail.map(|name| format!("writable-changed::{name}\0"));
594 let signal_name: &[u8] = detailed_signal_name
595 .as_ref()
596 .map_or(c"writable-changed".to_bytes(), |n| n.as_bytes());
597 connect_raw(
598 self.as_ptr() as *mut _,
599 signal_name.as_ptr() as *const _,
600 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
601 writable_changed_trampoline::<Self, F> as *const (),
602 )),
603 Box_::into_raw(f),
604 )
605 }
606 }
607
608 #[doc(alias = "delay-apply")]
609 fn connect_delay_apply_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
610 unsafe extern "C" fn notify_delay_apply_trampoline<
611 P: IsA<Settings>,
612 F: Fn(&P) + 'static,
613 >(
614 this: *mut ffi::GSettings,
615 _param_spec: glib::ffi::gpointer,
616 f: glib::ffi::gpointer,
617 ) {
618 let f: &F = &*(f as *const F);
619 f(Settings::from_glib_borrow(this).unsafe_cast_ref())
620 }
621 unsafe {
622 let f: Box_<F> = Box_::new(f);
623 connect_raw(
624 self.as_ptr() as *mut _,
625 c"notify::delay-apply".as_ptr() as *const _,
626 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
627 notify_delay_apply_trampoline::<Self, F> as *const (),
628 )),
629 Box_::into_raw(f),
630 )
631 }
632 }
633
634 #[doc(alias = "has-unapplied")]
635 fn connect_has_unapplied_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
636 unsafe extern "C" fn notify_has_unapplied_trampoline<
637 P: IsA<Settings>,
638 F: Fn(&P) + 'static,
639 >(
640 this: *mut ffi::GSettings,
641 _param_spec: glib::ffi::gpointer,
642 f: glib::ffi::gpointer,
643 ) {
644 let f: &F = &*(f as *const F);
645 f(Settings::from_glib_borrow(this).unsafe_cast_ref())
646 }
647 unsafe {
648 let f: Box_<F> = Box_::new(f);
649 connect_raw(
650 self.as_ptr() as *mut _,
651 c"notify::has-unapplied".as_ptr() as *const _,
652 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
653 notify_has_unapplied_trampoline::<Self, F> as *const (),
654 )),
655 Box_::into_raw(f),
656 )
657 }
658 }
659}
660
661impl<O: IsA<Settings>> SettingsExt for O {}