// Package gio was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package gio

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/glib"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// Interface for icons that can be loaded as a stream.
type LoadableIconIface struct {
	_ structs.HostLayout

	GIface uintptr

	xLoad uintptr

	xLoadAsync uintptr

	xLoadFinish uintptr
}

func (x *LoadableIconIface) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// OverrideLoad sets the "load" callback function.
// Loads an icon.
func (x *LoadableIconIface) OverrideLoad(cb func(LoadableIcon, int, *string, *Cancellable) *InputStream) {
	if cb == nil {
		x.xLoad = 0
	} else {
		x.xLoad = purego.NewCallback(func(IconVarp uintptr, SizeVarp int, TypeVarp *string, CancellableVarp uintptr) uintptr {
			ret := cb(&LoadableIconBase{Ptr: IconVarp}, SizeVarp, TypeVarp, CancellableNewFromInternalPtr(CancellableVarp))
			if ret == nil {
				return 0
			}
			return ret.GoPointer()
		})
	}
}

// GetLoad gets the "load" callback function.
// Loads an icon.
func (x *LoadableIconIface) GetLoad() func(LoadableIcon, int, *string, *Cancellable) *InputStream {
	if x.xLoad == 0 {
		return nil
	}
	var rawCallback func(IconVarp uintptr, SizeVarp int, TypeVarp *string, CancellableVarp uintptr) uintptr
	purego.RegisterFunc(&rawCallback, x.xLoad)
	return func(IconVar LoadableIcon, SizeVar int, TypeVar *string, CancellableVar *Cancellable) *InputStream {
		rawRet := rawCallback(IconVar.GoPointer(), SizeVar, TypeVar, CancellableVar.GoPointer())
		if rawRet == 0 {
			return nil
		}
		ret := &InputStream{}
		ret.Ptr = rawRet
		return ret
	}
}

// OverrideLoadAsync sets the "load_async" callback function.
// Loads an icon asynchronously.
func (x *LoadableIconIface) OverrideLoadAsync(cb func(LoadableIcon, int, *Cancellable, *AsyncReadyCallback, uintptr)) {
	if cb == nil {
		x.xLoadAsync = 0
	} else {
		x.xLoadAsync = purego.NewCallback(func(IconVarp uintptr, SizeVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
			cb(&LoadableIconBase{Ptr: IconVarp}, SizeVarp, CancellableNewFromInternalPtr(CancellableVarp), (*AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
		})
	}
}

// GetLoadAsync gets the "load_async" callback function.
// Loads an icon asynchronously.
func (x *LoadableIconIface) GetLoadAsync() func(LoadableIcon, int, *Cancellable, *AsyncReadyCallback, uintptr) {
	if x.xLoadAsync == 0 {
		return nil
	}
	var rawCallback func(IconVarp uintptr, SizeVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xLoadAsync)
	return func(IconVar LoadableIcon, SizeVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {
		rawCallback(IconVar.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
	}
}

// OverrideLoadFinish sets the "load_finish" callback function.
// Finishes an asynchronous icon load.
func (x *LoadableIconIface) OverrideLoadFinish(cb func(LoadableIcon, AsyncResult, *string) *InputStream) {
	if cb == nil {
		x.xLoadFinish = 0
	} else {
		x.xLoadFinish = purego.NewCallback(func(IconVarp uintptr, ResVarp uintptr, TypeVarp *string) uintptr {
			ret := cb(&LoadableIconBase{Ptr: IconVarp}, &AsyncResultBase{Ptr: ResVarp}, TypeVarp)
			if ret == nil {
				return 0
			}
			return ret.GoPointer()
		})
	}
}

// GetLoadFinish gets the "load_finish" callback function.
// Finishes an asynchronous icon load.
func (x *LoadableIconIface) GetLoadFinish() func(LoadableIcon, AsyncResult, *string) *InputStream {
	if x.xLoadFinish == 0 {
		return nil
	}
	var rawCallback func(IconVarp uintptr, ResVarp uintptr, TypeVarp *string) uintptr
	purego.RegisterFunc(&rawCallback, x.xLoadFinish)
	return func(IconVar LoadableIcon, ResVar AsyncResult, TypeVar *string) *InputStream {
		rawRet := rawCallback(IconVar.GoPointer(), ResVar.GoPointer(), TypeVar)
		if rawRet == 0 {
			return nil
		}
		ret := &InputStream{}
		ret.Ptr = rawRet
		return ret
	}
}

// `GLoadableIcon` extends the [iface@Gio.Icon] interface and adds the ability
// to load icons from streams.
type LoadableIcon interface {
	GoPointer() uintptr
	SetGoPointer(uintptr)
	Load(SizeVar int, TypeVar *string, CancellableVar *Cancellable) (*InputStream, error)
	LoadAsync(SizeVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr)
	LoadFinish(ResVar AsyncResult, TypeVar *string) (*InputStream, error)
}

var xLoadableIconGLibType func() types.GType

func LoadableIconGLibType() types.GType {
	return xLoadableIconGLibType()
}

type LoadableIconBase struct {
	Ptr uintptr
}

func (x *LoadableIconBase) GoPointer() uintptr {
	if x == nil {
		return 0
	}
	return x.Ptr
}

func (x *LoadableIconBase) SetGoPointer(ptr uintptr) {
	x.Ptr = ptr
}

// Loads a loadable icon. For the asynchronous version of this function,
// see g_loadable_icon_load_async().
func (x *LoadableIconBase) Load(SizeVar int, TypeVar *string, CancellableVar *Cancellable) (*InputStream, error) {
	var cls *InputStream
	var cerr *glib.Error

	cret := XGLoadableIconLoad(x.GoPointer(), SizeVar, TypeVar, CancellableVar.GoPointer(), &cerr)

	if cret == 0 {
		return nil, cerr
	}
	cls = &InputStream{}
	cls.Ptr = cret
	if cerr == nil {
		return cls, nil
	}
	return cls, cerr

}

// Loads an icon asynchronously. To finish this function, see
// g_loadable_icon_load_finish(). For the synchronous, blocking
// version of this function, see g_loadable_icon_load().
func (x *LoadableIconBase) LoadAsync(SizeVar int, CancellableVar *Cancellable, CallbackVar *AsyncReadyCallback, UserDataVar uintptr) {

	XGLoadableIconLoadAsync(x.GoPointer(), SizeVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)

}

// Finishes an asynchronous icon load started in g_loadable_icon_load_async().
func (x *LoadableIconBase) LoadFinish(ResVar AsyncResult, TypeVar *string) (*InputStream, error) {
	var cls *InputStream
	var cerr *glib.Error

	cret := XGLoadableIconLoadFinish(x.GoPointer(), ResVar.GoPointer(), TypeVar, &cerr)

	if cret == 0 {
		return nil, cerr
	}
	cls = &InputStream{}
	cls.Ptr = cret
	if cerr == nil {
		return cls, nil
	}
	return cls, cerr

}

var XGLoadableIconLoad func(uintptr, int, *string, uintptr, **glib.Error) uintptr
var XGLoadableIconLoadAsync func(uintptr, int, uintptr, uintptr, uintptr)
var XGLoadableIconLoadFinish func(uintptr, uintptr, *string, **glib.Error) uintptr

func init() {
	core.SetPackageName("GIO", "gio-2.0")
	core.SetSharedLibraries("GIO", []string{"libgio-2.0.so.0"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GIO") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xLoadableIconGLibType, libs, "g_loadable_icon_get_type")

	core.PuregoSafeRegister(&XGLoadableIconLoad, libs, "g_loadable_icon_load")
	core.PuregoSafeRegister(&XGLoadableIconLoadAsync, libs, "g_loadable_icon_load_async")
	core.PuregoSafeRegister(&XGLoadableIconLoadFinish, libs, "g_loadable_icon_load_finish")

}