1package glib 2 3// #include <gio/gio.h> 4// #include <glib.h> 5// #include <glib-object.h> 6// #include "glib.go.h" 7// #include "gpermission.go.h" 8import "C" 9import ( 10 "errors" 11 "unsafe" 12 13 "github.com/gotk3/gotk3/internal/callback" 14) 15 16// Permission is a representation of GIO's GPermission. 17type Permission struct { 18 *Object 19} 20 21func (v *Permission) native() *C.GPermission { 22 if v == nil || v.GObject == nil { 23 return nil 24 } 25 return C.toGPermission(unsafe.Pointer(v.GObject)) 26} 27 28// Native returns a uintptr to the underlying C.GPermission. 29func (v *Permission) Native() uintptr { 30 return uintptr(unsafe.Pointer(v.native())) 31} 32 33func marshalPermission(p uintptr) (interface{}, error) { 34 c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p))) 35 return wrapPermission(wrapObject(unsafe.Pointer(c))), nil 36} 37 38func wrapPermission(obj *Object) *Permission { 39 return &Permission{obj} 40} 41 42// WrapPermission wraps given unsafe pointer into Permission. 43func WrapPermission(ptr unsafe.Pointer) *Permission { 44 return wrapPermission(wrapObject(ptr)) 45} 46 47// GetAllowed is a wrapper around g_permission_get_allowed(). 48func (v *Permission) GetAllowed() bool { 49 c := C.g_permission_get_allowed(v.native()) 50 return gobool(c) 51} 52 53// GetCanAcquire is a wrapper around g_permission_get_can_acquire(). 54func (v *Permission) GetCanAcquire() bool { 55 c := C.g_permission_get_can_acquire(v.native()) 56 return gobool(c) 57} 58 59// GetCanRelease is a wrapper around g_permission_get_can_release(). 60func (v *Permission) GetCanRelease() bool { 61 c := C.g_permission_get_can_release(v.native()) 62 return gobool(c) 63} 64 65// Acquire is a wrapper around g_permission_acquire(). 66func (v *Permission) Acquire(cancellable *Cancellable) error { 67 var err *C.GError 68 c := C.g_permission_acquire(v.native(), cancellable.native(), &err) 69 acquired := gobool(c) 70 if !acquired { 71 defer C.g_error_free(err) 72 return errors.New(C.GoString((*C.char)(err.message))) 73 } 74 return nil 75} 76 77// AcquireAsync is a wrapper around g_permission_acquire_async(). 78func (v *Permission) AcquireAsync(cancellable *Cancellable, fn AsyncReadyCallback) { 79 C._g_permission_acquire_async(v.native(), cancellable.native(), C.gpointer(callback.Assign(fn))) 80} 81 82// AcquireFinish is a wrapper around g_permission_acquire_finish(). 83func (v *Permission) AcquireFinish(result *AsyncResult) error { 84 var err *C.GError 85 c := C.g_permission_acquire_finish(v.native(), result.native(), &err) 86 acquired := gobool(c) 87 if !acquired { 88 defer C.g_error_free(err) 89 return errors.New(C.GoString((*C.char)(err.message))) 90 } 91 return nil 92} 93 94// Release is a wrapper around g_permission_release(). 95func (v *Permission) Release(cancellable *Cancellable) error { 96 var err *C.GError 97 c := C.g_permission_release(v.native(), cancellable.native(), &err) 98 released := gobool(c) 99 if !released { 100 defer C.g_error_free(err) 101 return errors.New(C.GoString((*C.char)(err.message))) 102 } 103 return nil 104} 105 106// ReleaseAsync is a wrapper around g_permission_release_async(). 107func (v *Permission) ReleaseAsync(cancellable *Cancellable, fn AsyncReadyCallback) { 108 C._g_permission_release_async(v.native(), cancellable.native(), C.gpointer(callback.Assign(fn))) 109} 110 111// ReleaseFinish is a wrapper around g_permission_release_finish(). 112func (v *Permission) ReleaseFinish(result *AsyncResult) error { 113 var err *C.GError 114 c := C.g_permission_release_finish(v.native(), result.native(), &err) 115 released := gobool(c) 116 if !released { 117 defer C.g_error_free(err) 118 return errors.New(C.GoString((*C.char)(err.message))) 119 } 120 return nil 121} 122 123// ImplUpdate is a wrapper around g_permission_impl_update(). 124func (v *Permission) ImplUpdate(allowed, canAcquire, canRelease bool) { 125 C.g_permission_impl_update(v.native(), gbool(allowed), gbool(canAcquire), gbool(canRelease)) 126} 127