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

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

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

// Class structure for `GdkContentProvider`.
type ContentProviderClass struct {
	_ structs.HostLayout

	ParentClass gobject.ObjectClass

	xContentChanged uintptr

	xAttachClipboard uintptr

	xDetachClipboard uintptr

	xRefFormats uintptr

	xRefStorableFormats uintptr

	xWriteMimeTypeAsync uintptr

	xWriteMimeTypeFinish uintptr

	xGetValue uintptr

	Padding [8]uintptr
}

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

// OverrideContentChanged sets the "content_changed" callback function.
// Signal class closure for `GdkContentProvider::content-changed`
func (x *ContentProviderClass) OverrideContentChanged(cb func(*ContentProvider)) {
	if cb == nil {
		x.xContentChanged = 0
	} else {
		x.xContentChanged = purego.NewCallback(func(ProviderVarp uintptr) {
			cb(ContentProviderNewFromInternalPtr(ProviderVarp))
		})
	}
}

// GetContentChanged gets the "content_changed" callback function.
// Signal class closure for `GdkContentProvider::content-changed`
func (x *ContentProviderClass) GetContentChanged() func(*ContentProvider) {
	if x.xContentChanged == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xContentChanged)
	return func(ProviderVar *ContentProvider) {
		rawCallback(ProviderVar.GoPointer())
	}
}

// OverrideAttachClipboard sets the "attach_clipboard" callback function.
func (x *ContentProviderClass) OverrideAttachClipboard(cb func(*ContentProvider, *Clipboard)) {
	if cb == nil {
		x.xAttachClipboard = 0
	} else {
		x.xAttachClipboard = purego.NewCallback(func(ProviderVarp uintptr, ClipboardVarp uintptr) {
			cb(ContentProviderNewFromInternalPtr(ProviderVarp), ClipboardNewFromInternalPtr(ClipboardVarp))
		})
	}
}

// GetAttachClipboard gets the "attach_clipboard" callback function.
func (x *ContentProviderClass) GetAttachClipboard() func(*ContentProvider, *Clipboard) {
	if x.xAttachClipboard == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr, ClipboardVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xAttachClipboard)
	return func(ProviderVar *ContentProvider, ClipboardVar *Clipboard) {
		rawCallback(ProviderVar.GoPointer(), ClipboardVar.GoPointer())
	}
}

// OverrideDetachClipboard sets the "detach_clipboard" callback function.
func (x *ContentProviderClass) OverrideDetachClipboard(cb func(*ContentProvider, *Clipboard)) {
	if cb == nil {
		x.xDetachClipboard = 0
	} else {
		x.xDetachClipboard = purego.NewCallback(func(ProviderVarp uintptr, ClipboardVarp uintptr) {
			cb(ContentProviderNewFromInternalPtr(ProviderVarp), ClipboardNewFromInternalPtr(ClipboardVarp))
		})
	}
}

// GetDetachClipboard gets the "detach_clipboard" callback function.
func (x *ContentProviderClass) GetDetachClipboard() func(*ContentProvider, *Clipboard) {
	if x.xDetachClipboard == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr, ClipboardVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xDetachClipboard)
	return func(ProviderVar *ContentProvider, ClipboardVar *Clipboard) {
		rawCallback(ProviderVar.GoPointer(), ClipboardVar.GoPointer())
	}
}

// OverrideRefFormats sets the "ref_formats" callback function.
func (x *ContentProviderClass) OverrideRefFormats(cb func(*ContentProvider) *ContentFormats) {
	if cb == nil {
		x.xRefFormats = 0
	} else {
		x.xRefFormats = purego.NewCallback(func(ProviderVarp uintptr) *ContentFormats {
			return cb(ContentProviderNewFromInternalPtr(ProviderVarp))
		})
	}
}

// GetRefFormats gets the "ref_formats" callback function.
func (x *ContentProviderClass) GetRefFormats() func(*ContentProvider) *ContentFormats {
	if x.xRefFormats == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr) *ContentFormats
	purego.RegisterFunc(&rawCallback, x.xRefFormats)
	return func(ProviderVar *ContentProvider) *ContentFormats {
		return rawCallback(ProviderVar.GoPointer())
	}
}

// OverrideRefStorableFormats sets the "ref_storable_formats" callback function.
func (x *ContentProviderClass) OverrideRefStorableFormats(cb func(*ContentProvider) *ContentFormats) {
	if cb == nil {
		x.xRefStorableFormats = 0
	} else {
		x.xRefStorableFormats = purego.NewCallback(func(ProviderVarp uintptr) *ContentFormats {
			return cb(ContentProviderNewFromInternalPtr(ProviderVarp))
		})
	}
}

// GetRefStorableFormats gets the "ref_storable_formats" callback function.
func (x *ContentProviderClass) GetRefStorableFormats() func(*ContentProvider) *ContentFormats {
	if x.xRefStorableFormats == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr) *ContentFormats
	purego.RegisterFunc(&rawCallback, x.xRefStorableFormats)
	return func(ProviderVar *ContentProvider) *ContentFormats {
		return rawCallback(ProviderVar.GoPointer())
	}
}

// OverrideWriteMimeTypeAsync sets the "write_mime_type_async" callback function.
func (x *ContentProviderClass) OverrideWriteMimeTypeAsync(cb func(*ContentProvider, string, *gio.OutputStream, int, *gio.Cancellable, *gio.AsyncReadyCallback, uintptr)) {
	if cb == nil {
		x.xWriteMimeTypeAsync = 0
	} else {
		x.xWriteMimeTypeAsync = purego.NewCallback(func(ProviderVarp uintptr, MimeTypeVarp string, StreamVarp uintptr, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr) {
			cb(ContentProviderNewFromInternalPtr(ProviderVarp), MimeTypeVarp, gio.OutputStreamNewFromInternalPtr(StreamVarp), IoPriorityVarp, gio.CancellableNewFromInternalPtr(CancellableVarp), (*gio.AsyncReadyCallback)(unsafe.Pointer(CallbackVarp)), UserDataVarp)
		})
	}
}

// GetWriteMimeTypeAsync gets the "write_mime_type_async" callback function.
func (x *ContentProviderClass) GetWriteMimeTypeAsync() func(*ContentProvider, string, *gio.OutputStream, int, *gio.Cancellable, *gio.AsyncReadyCallback, uintptr) {
	if x.xWriteMimeTypeAsync == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr, MimeTypeVarp string, StreamVarp uintptr, IoPriorityVarp int, CancellableVarp uintptr, CallbackVarp uintptr, UserDataVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xWriteMimeTypeAsync)
	return func(ProviderVar *ContentProvider, MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {
		rawCallback(ProviderVar.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), glib.NewCallbackNullable(CallbackVar), UserDataVar)
	}
}

// OverrideWriteMimeTypeFinish sets the "write_mime_type_finish" callback function.
func (x *ContentProviderClass) OverrideWriteMimeTypeFinish(cb func(*ContentProvider, gio.AsyncResult) bool) {
	if cb == nil {
		x.xWriteMimeTypeFinish = 0
	} else {
		x.xWriteMimeTypeFinish = purego.NewCallback(func(ProviderVarp uintptr, ResultVarp uintptr) bool {
			return cb(ContentProviderNewFromInternalPtr(ProviderVarp), &gio.AsyncResultBase{Ptr: ResultVarp})
		})
	}
}

// GetWriteMimeTypeFinish gets the "write_mime_type_finish" callback function.
func (x *ContentProviderClass) GetWriteMimeTypeFinish() func(*ContentProvider, gio.AsyncResult) bool {
	if x.xWriteMimeTypeFinish == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr, ResultVarp uintptr) bool
	purego.RegisterFunc(&rawCallback, x.xWriteMimeTypeFinish)
	return func(ProviderVar *ContentProvider, ResultVar gio.AsyncResult) bool {
		return rawCallback(ProviderVar.GoPointer(), ResultVar.GoPointer())
	}
}

// OverrideGetValue sets the "get_value" callback function.
func (x *ContentProviderClass) OverrideGetValue(cb func(*ContentProvider, *gobject.Value) bool) {
	if cb == nil {
		x.xGetValue = 0
	} else {
		x.xGetValue = purego.NewCallback(func(ProviderVarp uintptr, ValueVarp *gobject.Value) bool {
			return cb(ContentProviderNewFromInternalPtr(ProviderVarp), ValueVarp)
		})
	}
}

// GetGetValue gets the "get_value" callback function.
func (x *ContentProviderClass) GetGetValue() func(*ContentProvider, *gobject.Value) bool {
	if x.xGetValue == 0 {
		return nil
	}
	var rawCallback func(ProviderVarp uintptr, ValueVarp *gobject.Value) bool
	purego.RegisterFunc(&rawCallback, x.xGetValue)
	return func(ProviderVar *ContentProvider, ValueVar *gobject.Value) bool {
		return rawCallback(ProviderVar.GoPointer(), ValueVar)
	}
}

// Provides content for the clipboard or for drag-and-drop operations
// in a number of formats.
//
// To create a `GdkContentProvider`, use [ctor@Gdk.ContentProvider.new_for_value]
// or [ctor@Gdk.ContentProvider.new_for_bytes].
//
// GDK knows how to handle common text and image formats out-of-the-box. See
// [class@Gdk.ContentSerializer] and [class@Gdk.ContentDeserializer] if you want
// to add support for application-specific data formats.
type ContentProvider struct {
	gobject.Object
}

var xContentProviderGLibType func() types.GType

func ContentProviderGLibType() types.GType {
	return xContentProviderGLibType()
}

func ContentProviderNewFromInternalPtr(ptr uintptr) *ContentProvider {
	cls := &ContentProvider{}
	cls.Ptr = ptr
	return cls
}

var xNewContentProviderForBytes func(string, *glib.Bytes) uintptr

// Create a content provider that provides the given @bytes as data for
// the given @mime_type.
func NewContentProviderForBytes(MimeTypeVar string, BytesVar *glib.Bytes) *ContentProvider {
	var cls *ContentProvider

	cret := xNewContentProviderForBytes(MimeTypeVar, BytesVar)

	if cret == 0 {
		return nil
	}
	cls = &ContentProvider{}
	cls.Ptr = cret
	return cls
}

var xNewContentProviderForValue func(*gobject.Value) uintptr

// Create a content provider that provides the given @value.
func NewContentProviderForValue(ValueVar *gobject.Value) *ContentProvider {
	var cls *ContentProvider

	cret := xNewContentProviderForValue(ValueVar)

	if cret == 0 {
		return nil
	}
	cls = &ContentProvider{}
	cls.Ptr = cret
	return cls
}

var xNewContentProviderTyped func(types.GType, ...interface{}) uintptr

// Create a content provider that provides the value of the given
// @type.
//
// The value is provided using G_VALUE_COLLECT(), so the same rules
// apply as when calling g_object_new() or g_object_set().
func NewContentProviderTyped(TypeVar types.GType, varArgs ...interface{}) *ContentProvider {
	var cls *ContentProvider

	cret := xNewContentProviderTyped(TypeVar, varArgs...)

	if cret == 0 {
		return nil
	}
	cls = &ContentProvider{}
	cls.Ptr = cret
	return cls
}

var xNewContentProviderUnion func(uintptr, uint) uintptr

// Creates a content provider that represents all the given @providers.
//
// Whenever data needs to be written, the union provider will try the given
// @providers in the given order and the first one supporting a format will
// be chosen to provide it.
//
// This allows an easy way to support providing data in different formats.
// For example, an image may be provided by its file and by the image
// contents with a call such as
// ```c
//
//	gdk_content_provider_new_union ((GdkContentProvider *[2]) {
//	                                  gdk_content_provider_new_typed (G_TYPE_FILE, file),
//	                                  gdk_content_provider_new_typed (GDK_TYPE_TEXTURE, texture)
//	                                }, 2);
//
// ```
func NewContentProviderUnion(ProvidersVar uintptr, NProvidersVar uint) *ContentProvider {
	var cls *ContentProvider

	cret := xNewContentProviderUnion(ProvidersVar, NProvidersVar)

	if cret == 0 {
		return nil
	}
	cls = &ContentProvider{}
	cls.Ptr = cret
	return cls
}

var xContentProviderContentChanged func(uintptr)

// Emits the ::content-changed signal.
func (x *ContentProvider) ContentChanged() {

	xContentProviderContentChanged(x.GoPointer())

}

var xContentProviderGetValue func(uintptr, *gobject.Value, **glib.Error) bool

// Gets the contents of @provider stored in @value.
//
// The @value will have been initialized to the `GType` the value should be
// provided in. This given `GType` does not need to be listed in the formats
// returned by [method@Gdk.ContentProvider.ref_formats]. However, if the
// given `GType` is not supported, this operation can fail and
// `G_IO_ERROR_NOT_SUPPORTED` will be reported.
func (x *ContentProvider) GetValue(ValueVar *gobject.Value) (bool, error) {
	var cerr *glib.Error

	cret := xContentProviderGetValue(x.GoPointer(), ValueVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xContentProviderRefFormats func(uintptr) *ContentFormats

// Gets the formats that the provider can provide its current contents in.
func (x *ContentProvider) RefFormats() *ContentFormats {

	cret := xContentProviderRefFormats(x.GoPointer())
	return cret
}

var xContentProviderRefStorableFormats func(uintptr) *ContentFormats

// Gets the formats that the provider suggests other applications to store
// the data in.
//
// An example of such an application would be a clipboard manager.
//
// This can be assumed to be a subset of [method@Gdk.ContentProvider.ref_formats].
func (x *ContentProvider) RefStorableFormats() *ContentFormats {

	cret := xContentProviderRefStorableFormats(x.GoPointer())
	return cret
}

var xContentProviderWriteMimeTypeAsync func(uintptr, string, uintptr, int, uintptr, uintptr, uintptr)

// Asynchronously writes the contents of @provider to @stream in the given
// @mime_type.
//
// The given mime type does not need to be listed in the formats returned by
// [method@Gdk.ContentProvider.ref_formats]. However, if the given `GType` is
// not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
//
// The given @stream will not be closed.
func (x *ContentProvider) WriteMimeTypeAsync(MimeTypeVar string, StreamVar *gio.OutputStream, IoPriorityVar int, CancellableVar *gio.Cancellable, CallbackVar *gio.AsyncReadyCallback, UserDataVar uintptr) {

	var CallbackVarRef uintptr
	if CallbackVar != nil {
		CallbackVarPtr := uintptr(unsafe.Pointer(CallbackVar))
		if cbRefPtr, ok := glib.GetCallback(CallbackVarPtr); ok {
			CallbackVarRef = cbRefPtr
		} else {
			fcb := func(arg0 uintptr, arg1 uintptr, arg2 uintptr) {
				cbFn := *CallbackVar
				cbFn(arg0, arg1, arg2)
			}
			CallbackVarRef = purego.NewCallback(fcb)
			glib.SaveCallbackWithClosure(CallbackVarPtr, CallbackVarRef, CallbackVar)
		}
	}

	xContentProviderWriteMimeTypeAsync(x.GoPointer(), MimeTypeVar, StreamVar.GoPointer(), IoPriorityVar, CancellableVar.GoPointer(), CallbackVarRef, UserDataVar)

}

var xContentProviderWriteMimeTypeFinish func(uintptr, uintptr, **glib.Error) bool

// Finishes an asynchronous write operation.
//
// See [method@Gdk.ContentProvider.write_mime_type_async].
func (x *ContentProvider) WriteMimeTypeFinish(ResultVar gio.AsyncResult) (bool, error) {
	var cerr *glib.Error

	cret := xContentProviderWriteMimeTypeFinish(x.GoPointer(), ResultVar.GoPointer(), &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

func (c *ContentProvider) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *ContentProvider) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

// GetPropertyFormats gets the "formats" property.
// The possible formats that the provider can provide its data in.
func (x *ContentProvider) GetPropertyFormats() uintptr {
	var v gobject.Value
	x.GetProperty("formats", &v)
	return v.GetPointer()
}

// GetPropertyStorableFormats gets the "storable-formats" property.
// The subset of formats that clipboard managers should store this provider's data in.
func (x *ContentProvider) GetPropertyStorableFormats() uintptr {
	var v gobject.Value
	x.GetProperty("storable-formats", &v)
	return v.GetPointer()
}

// Emitted whenever the content provided by this provider has changed.
func (x *ContentProvider) ConnectContentChanged(cb *func(ContentProvider)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr) {
		fa := ContentProvider{}
		fa.Ptr = clsPtr
		cbFn := *cb

		cbFn(fa)

	}
	cbRefPtr := purego.NewCallback(fcb)
	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
	handlerID := gobject.SignalConnect(x.GoPointer(), "content-changed", cbRefPtr)
	glib.SaveHandlerMapping(handlerID, cbPtr)
	return handlerID
}

func init() {
	core.SetPackageName("GDK", "gtk4")
	core.SetSharedLibraries("GDK", []string{"libgtk-4.so.1"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GDK") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xContentProviderGLibType, libs, "gdk_content_provider_get_type")

	core.PuregoSafeRegister(&xNewContentProviderForBytes, libs, "gdk_content_provider_new_for_bytes")
	core.PuregoSafeRegister(&xNewContentProviderForValue, libs, "gdk_content_provider_new_for_value")
	core.PuregoSafeRegister(&xNewContentProviderTyped, libs, "gdk_content_provider_new_typed")
	core.PuregoSafeRegister(&xNewContentProviderUnion, libs, "gdk_content_provider_new_union")

	core.PuregoSafeRegister(&xContentProviderContentChanged, libs, "gdk_content_provider_content_changed")
	core.PuregoSafeRegister(&xContentProviderGetValue, libs, "gdk_content_provider_get_value")
	core.PuregoSafeRegister(&xContentProviderRefFormats, libs, "gdk_content_provider_ref_formats")
	core.PuregoSafeRegister(&xContentProviderRefStorableFormats, libs, "gdk_content_provider_ref_storable_formats")
	core.PuregoSafeRegister(&xContentProviderWriteMimeTypeAsync, libs, "gdk_content_provider_write_mime_type_async")
	core.PuregoSafeRegister(&xContentProviderWriteMimeTypeFinish, libs, "gdk_content_provider_write_mime_type_finish")

}