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