5681 lines
202 KiB
Go
5681 lines
202 KiB
Go
// THE AUTOGENERATED LICENSE. ALL THE RIGHTS ARE RESERVED BY ROBOTS.
|
|
|
|
// WARNING: This file has automatically been generated on Sun, 02 Oct 2022 19:40:55 PDT.
|
|
// Code generated by https://git.io/c-for-go. DO NOT EDIT.
|
|
|
|
package ultralight
|
|
|
|
/*
|
|
#cgo CFLAGS: -I../include
|
|
#cgo LDFLAGS: -Wl,--allow-multiple-definition -L${SRCDIR}/libs/linux/x64 -Wl,-rpath,/home/co/code/Muon/ultralight/libs/linux/x64 -lUltralightCore -lAppCore -lUltralight -lWebCore
|
|
#include "AppCore/CAPI.h"
|
|
#include <stdlib.h>
|
|
#include "cgo_helpers.h"
|
|
*/
|
|
import "C"
|
|
import (
|
|
"fmt"
|
|
"runtime"
|
|
"sync"
|
|
"unsafe"
|
|
)
|
|
|
|
// cgoAllocMap stores pointers to C allocated memory for future reference.
|
|
type cgoAllocMap struct {
|
|
mux sync.RWMutex
|
|
m map[unsafe.Pointer]struct{}
|
|
}
|
|
|
|
var cgoAllocsUnknown = new(cgoAllocMap)
|
|
|
|
func (a *cgoAllocMap) Add(ptr unsafe.Pointer) {
|
|
a.mux.Lock()
|
|
if a.m == nil {
|
|
a.m = make(map[unsafe.Pointer]struct{})
|
|
}
|
|
a.m[ptr] = struct{}{}
|
|
a.mux.Unlock()
|
|
}
|
|
|
|
func (a *cgoAllocMap) IsEmpty() bool {
|
|
a.mux.RLock()
|
|
isEmpty := len(a.m) == 0
|
|
a.mux.RUnlock()
|
|
return isEmpty
|
|
}
|
|
|
|
func (a *cgoAllocMap) Borrow(b *cgoAllocMap) {
|
|
if b == nil || b.IsEmpty() {
|
|
return
|
|
}
|
|
b.mux.Lock()
|
|
a.mux.Lock()
|
|
for ptr := range b.m {
|
|
if a.m == nil {
|
|
a.m = make(map[unsafe.Pointer]struct{})
|
|
}
|
|
a.m[ptr] = struct{}{}
|
|
delete(b.m, ptr)
|
|
}
|
|
a.mux.Unlock()
|
|
b.mux.Unlock()
|
|
}
|
|
|
|
func (a *cgoAllocMap) Free() {
|
|
a.mux.Lock()
|
|
for ptr := range a.m {
|
|
C.free(ptr)
|
|
delete(a.m, ptr)
|
|
}
|
|
a.mux.Unlock()
|
|
}
|
|
|
|
func (x ULUpdateCallback) PassRef() (ref *C.ULUpdateCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLUpdateCallback7E1C6355Func == nil {
|
|
uLUpdateCallback7E1C6355Func = x
|
|
}
|
|
return (*C.ULUpdateCallback)(C.ULUpdateCallback_7e1c6355), nil
|
|
}
|
|
|
|
func (x ULUpdateCallback) PassValue() (ref C.ULUpdateCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLUpdateCallback7E1C6355Func == nil {
|
|
uLUpdateCallback7E1C6355Func = x
|
|
}
|
|
return (C.ULUpdateCallback)(C.ULUpdateCallback_7e1c6355), nil
|
|
}
|
|
|
|
func NewULUpdateCallbackRef(ref unsafe.Pointer) *ULUpdateCallback {
|
|
return (*ULUpdateCallback)(ref)
|
|
}
|
|
|
|
//export uLUpdateCallback7E1C6355
|
|
func uLUpdateCallback7E1C6355(cuserData unsafe.Pointer) {
|
|
if uLUpdateCallback7E1C6355Func != nil {
|
|
userData7e1c6355 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
uLUpdateCallback7E1C6355Func(userData7e1c6355)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLUpdateCallback7E1C6355Func ULUpdateCallback
|
|
|
|
func (x ULCloseCallback) PassRef() (ref *C.ULCloseCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLCloseCallback195B2F9Func == nil {
|
|
uLCloseCallback195B2F9Func = x
|
|
}
|
|
return (*C.ULCloseCallback)(C.ULCloseCallback_195b2f9), nil
|
|
}
|
|
|
|
func (x ULCloseCallback) PassValue() (ref C.ULCloseCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLCloseCallback195B2F9Func == nil {
|
|
uLCloseCallback195B2F9Func = x
|
|
}
|
|
return (C.ULCloseCallback)(C.ULCloseCallback_195b2f9), nil
|
|
}
|
|
|
|
func NewULCloseCallbackRef(ref unsafe.Pointer) *ULCloseCallback {
|
|
return (*ULCloseCallback)(ref)
|
|
}
|
|
|
|
//export uLCloseCallback195B2F9
|
|
func uLCloseCallback195B2F9(cuserData unsafe.Pointer) {
|
|
if uLCloseCallback195B2F9Func != nil {
|
|
userData195b2f9 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
uLCloseCallback195B2F9Func(userData195b2f9)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLCloseCallback195B2F9Func ULCloseCallback
|
|
|
|
func (x ULResizeCallback) PassRef() (ref *C.ULResizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLResizeCallback6E7309D9Func == nil {
|
|
uLResizeCallback6E7309D9Func = x
|
|
}
|
|
return (*C.ULResizeCallback)(C.ULResizeCallback_6e7309d9), nil
|
|
}
|
|
|
|
func (x ULResizeCallback) PassValue() (ref C.ULResizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLResizeCallback6E7309D9Func == nil {
|
|
uLResizeCallback6E7309D9Func = x
|
|
}
|
|
return (C.ULResizeCallback)(C.ULResizeCallback_6e7309d9), nil
|
|
}
|
|
|
|
func NewULResizeCallbackRef(ref unsafe.Pointer) *ULResizeCallback {
|
|
return (*ULResizeCallback)(ref)
|
|
}
|
|
|
|
//export uLResizeCallback6E7309D9
|
|
func uLResizeCallback6E7309D9(cuserData unsafe.Pointer, cwidth C.uint, cheight C.uint) {
|
|
if uLResizeCallback6E7309D9Func != nil {
|
|
userData6e7309d9 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
width6e7309d9 := (uint32)(cwidth)
|
|
height6e7309d9 := (uint32)(cheight)
|
|
uLResizeCallback6E7309D9Func(userData6e7309d9, width6e7309d9, height6e7309d9)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLResizeCallback6E7309D9Func ULResizeCallback
|
|
|
|
// allocULRectMemory allocates memory for type C.ULRect in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULRectMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULRectValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULRectValue = unsafe.Sizeof([1]C.ULRect{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULRect) Ref() *C.ULRect {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref4622ce0c
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULRect) Free() {
|
|
if x != nil && x.allocs4622ce0c != nil {
|
|
x.allocs4622ce0c.(*cgoAllocMap).Free()
|
|
x.ref4622ce0c = nil
|
|
}
|
|
}
|
|
|
|
// NewULRectRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULRectRef(ref unsafe.Pointer) *ULRect {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULRect)
|
|
obj.ref4622ce0c = (*C.ULRect)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULRect) PassRef() (*C.ULRect, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref4622ce0c != nil {
|
|
return x.ref4622ce0c, nil
|
|
}
|
|
mem4622ce0c := allocULRectMemory(1)
|
|
ref4622ce0c := (*C.ULRect)(mem4622ce0c)
|
|
allocs4622ce0c := new(cgoAllocMap)
|
|
allocs4622ce0c.Add(mem4622ce0c)
|
|
|
|
var cleft_allocs *cgoAllocMap
|
|
ref4622ce0c.left, cleft_allocs = (C.float)(x.Left), cgoAllocsUnknown
|
|
allocs4622ce0c.Borrow(cleft_allocs)
|
|
|
|
var ctop_allocs *cgoAllocMap
|
|
ref4622ce0c.top, ctop_allocs = (C.float)(x.Top), cgoAllocsUnknown
|
|
allocs4622ce0c.Borrow(ctop_allocs)
|
|
|
|
var cright_allocs *cgoAllocMap
|
|
ref4622ce0c.right, cright_allocs = (C.float)(x.Right), cgoAllocsUnknown
|
|
allocs4622ce0c.Borrow(cright_allocs)
|
|
|
|
var cbottom_allocs *cgoAllocMap
|
|
ref4622ce0c.bottom, cbottom_allocs = (C.float)(x.Bottom), cgoAllocsUnknown
|
|
allocs4622ce0c.Borrow(cbottom_allocs)
|
|
|
|
x.ref4622ce0c = ref4622ce0c
|
|
x.allocs4622ce0c = allocs4622ce0c
|
|
return ref4622ce0c, allocs4622ce0c
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULRect) PassValue() (C.ULRect, *cgoAllocMap) {
|
|
if x.ref4622ce0c != nil {
|
|
return *x.ref4622ce0c, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULRect) Deref() {
|
|
if x.ref4622ce0c == nil {
|
|
return
|
|
}
|
|
x.Left = (float32)(x.ref4622ce0c.left)
|
|
x.Top = (float32)(x.ref4622ce0c.top)
|
|
x.Right = (float32)(x.ref4622ce0c.right)
|
|
x.Bottom = (float32)(x.ref4622ce0c.bottom)
|
|
}
|
|
|
|
// allocULIntRectMemory allocates memory for type C.ULIntRect in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULIntRectMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULIntRectValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULIntRectValue = unsafe.Sizeof([1]C.ULIntRect{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULIntRect) Ref() *C.ULIntRect {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref79619c19
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULIntRect) Free() {
|
|
if x != nil && x.allocs79619c19 != nil {
|
|
x.allocs79619c19.(*cgoAllocMap).Free()
|
|
x.ref79619c19 = nil
|
|
}
|
|
}
|
|
|
|
// NewULIntRectRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULIntRectRef(ref unsafe.Pointer) *ULIntRect {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULIntRect)
|
|
obj.ref79619c19 = (*C.ULIntRect)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULIntRect) PassRef() (*C.ULIntRect, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref79619c19 != nil {
|
|
return x.ref79619c19, nil
|
|
}
|
|
mem79619c19 := allocULIntRectMemory(1)
|
|
ref79619c19 := (*C.ULIntRect)(mem79619c19)
|
|
allocs79619c19 := new(cgoAllocMap)
|
|
allocs79619c19.Add(mem79619c19)
|
|
|
|
var cleft_allocs *cgoAllocMap
|
|
ref79619c19.left, cleft_allocs = (C.int)(x.Left), cgoAllocsUnknown
|
|
allocs79619c19.Borrow(cleft_allocs)
|
|
|
|
var ctop_allocs *cgoAllocMap
|
|
ref79619c19.top, ctop_allocs = (C.int)(x.Top), cgoAllocsUnknown
|
|
allocs79619c19.Borrow(ctop_allocs)
|
|
|
|
var cright_allocs *cgoAllocMap
|
|
ref79619c19.right, cright_allocs = (C.int)(x.Right), cgoAllocsUnknown
|
|
allocs79619c19.Borrow(cright_allocs)
|
|
|
|
var cbottom_allocs *cgoAllocMap
|
|
ref79619c19.bottom, cbottom_allocs = (C.int)(x.Bottom), cgoAllocsUnknown
|
|
allocs79619c19.Borrow(cbottom_allocs)
|
|
|
|
x.ref79619c19 = ref79619c19
|
|
x.allocs79619c19 = allocs79619c19
|
|
return ref79619c19, allocs79619c19
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULIntRect) PassValue() (C.ULIntRect, *cgoAllocMap) {
|
|
if x.ref79619c19 != nil {
|
|
return *x.ref79619c19, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULIntRect) Deref() {
|
|
if x.ref79619c19 == nil {
|
|
return
|
|
}
|
|
x.Left = (int32)(x.ref79619c19.left)
|
|
x.Top = (int32)(x.ref79619c19.top)
|
|
x.Right = (int32)(x.ref79619c19.right)
|
|
x.Bottom = (int32)(x.ref79619c19.bottom)
|
|
}
|
|
|
|
// allocULRenderTargetMemory allocates memory for type C.ULRenderTarget in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULRenderTargetMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULRenderTargetValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULRenderTargetValue = unsafe.Sizeof([1]C.ULRenderTarget{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULRenderTarget) Ref() *C.ULRenderTarget {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref79bb0a51
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULRenderTarget) Free() {
|
|
if x != nil && x.allocs79bb0a51 != nil {
|
|
x.allocs79bb0a51.(*cgoAllocMap).Free()
|
|
x.ref79bb0a51 = nil
|
|
}
|
|
}
|
|
|
|
// NewULRenderTargetRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULRenderTargetRef(ref unsafe.Pointer) *ULRenderTarget {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULRenderTarget)
|
|
obj.ref79bb0a51 = (*C.ULRenderTarget)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULRenderTarget) PassRef() (*C.ULRenderTarget, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref79bb0a51 != nil {
|
|
return x.ref79bb0a51, nil
|
|
}
|
|
mem79bb0a51 := allocULRenderTargetMemory(1)
|
|
ref79bb0a51 := (*C.ULRenderTarget)(mem79bb0a51)
|
|
allocs79bb0a51 := new(cgoAllocMap)
|
|
allocs79bb0a51.Add(mem79bb0a51)
|
|
|
|
var cis_empty_allocs *cgoAllocMap
|
|
ref79bb0a51.is_empty, cis_empty_allocs = (C._Bool)(x.IsEmpty), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(cis_empty_allocs)
|
|
|
|
var cwidth_allocs *cgoAllocMap
|
|
ref79bb0a51.width, cwidth_allocs = (C.uint)(x.Width), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(cwidth_allocs)
|
|
|
|
var cheight_allocs *cgoAllocMap
|
|
ref79bb0a51.height, cheight_allocs = (C.uint)(x.Height), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(cheight_allocs)
|
|
|
|
var ctexture_id_allocs *cgoAllocMap
|
|
ref79bb0a51.texture_id, ctexture_id_allocs = (C.uint)(x.TextureId), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(ctexture_id_allocs)
|
|
|
|
var ctexture_width_allocs *cgoAllocMap
|
|
ref79bb0a51.texture_width, ctexture_width_allocs = (C.uint)(x.TextureWidth), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(ctexture_width_allocs)
|
|
|
|
var ctexture_height_allocs *cgoAllocMap
|
|
ref79bb0a51.texture_height, ctexture_height_allocs = (C.uint)(x.TextureHeight), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(ctexture_height_allocs)
|
|
|
|
var ctexture_format_allocs *cgoAllocMap
|
|
ref79bb0a51.texture_format, ctexture_format_allocs = (C.ULBitmapFormat)(x.TextureFormat), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(ctexture_format_allocs)
|
|
|
|
var cuv_coords_allocs *cgoAllocMap
|
|
ref79bb0a51.uv_coords, cuv_coords_allocs = x.UvCoords.PassValue()
|
|
allocs79bb0a51.Borrow(cuv_coords_allocs)
|
|
|
|
var crender_buffer_id_allocs *cgoAllocMap
|
|
ref79bb0a51.render_buffer_id, crender_buffer_id_allocs = (C.uint)(x.RenderBufferId), cgoAllocsUnknown
|
|
allocs79bb0a51.Borrow(crender_buffer_id_allocs)
|
|
|
|
x.ref79bb0a51 = ref79bb0a51
|
|
x.allocs79bb0a51 = allocs79bb0a51
|
|
return ref79bb0a51, allocs79bb0a51
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULRenderTarget) PassValue() (C.ULRenderTarget, *cgoAllocMap) {
|
|
if x.ref79bb0a51 != nil {
|
|
return *x.ref79bb0a51, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULRenderTarget) Deref() {
|
|
if x.ref79bb0a51 == nil {
|
|
return
|
|
}
|
|
x.IsEmpty = (bool)(x.ref79bb0a51.is_empty)
|
|
x.Width = (uint32)(x.ref79bb0a51.width)
|
|
x.Height = (uint32)(x.ref79bb0a51.height)
|
|
x.TextureId = (uint32)(x.ref79bb0a51.texture_id)
|
|
x.TextureWidth = (uint32)(x.ref79bb0a51.texture_width)
|
|
x.TextureHeight = (uint32)(x.ref79bb0a51.texture_height)
|
|
x.TextureFormat = (ULBitmapFormat)(x.ref79bb0a51.texture_format)
|
|
x.UvCoords = *NewULRectRef(unsafe.Pointer(&x.ref79bb0a51.uv_coords))
|
|
x.RenderBufferId = (uint32)(x.ref79bb0a51.render_buffer_id)
|
|
}
|
|
|
|
func (x ULChangeTitleCallback) PassRef() (ref *C.ULChangeTitleCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeTitleCallbackBD58034CFunc == nil {
|
|
uLChangeTitleCallbackBD58034CFunc = x
|
|
}
|
|
return (*C.ULChangeTitleCallback)(C.ULChangeTitleCallback_bd58034c), nil
|
|
}
|
|
|
|
func (x ULChangeTitleCallback) PassValue() (ref C.ULChangeTitleCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeTitleCallbackBD58034CFunc == nil {
|
|
uLChangeTitleCallbackBD58034CFunc = x
|
|
}
|
|
return (C.ULChangeTitleCallback)(C.ULChangeTitleCallback_bd58034c), nil
|
|
}
|
|
|
|
func NewULChangeTitleCallbackRef(ref unsafe.Pointer) *ULChangeTitleCallback {
|
|
return (*ULChangeTitleCallback)(ref)
|
|
}
|
|
|
|
//export uLChangeTitleCallbackBD58034C
|
|
func uLChangeTitleCallbackBD58034C(cuserData unsafe.Pointer, ccaller C.ULView, ctitle C.ULString) {
|
|
if uLChangeTitleCallbackBD58034CFunc != nil {
|
|
userDatabd58034c := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
callerbd58034c := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
titlebd58034c := *(*ULString)(unsafe.Pointer(&ctitle))
|
|
uLChangeTitleCallbackBD58034CFunc(userDatabd58034c, callerbd58034c, titlebd58034c)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLChangeTitleCallbackBD58034CFunc ULChangeTitleCallback
|
|
|
|
func (x ULChangeURLCallback) PassRef() (ref *C.ULChangeURLCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeURLCallback4EC32B80Func == nil {
|
|
uLChangeURLCallback4EC32B80Func = x
|
|
}
|
|
return (*C.ULChangeURLCallback)(C.ULChangeURLCallback_4ec32b80), nil
|
|
}
|
|
|
|
func (x ULChangeURLCallback) PassValue() (ref C.ULChangeURLCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeURLCallback4EC32B80Func == nil {
|
|
uLChangeURLCallback4EC32B80Func = x
|
|
}
|
|
return (C.ULChangeURLCallback)(C.ULChangeURLCallback_4ec32b80), nil
|
|
}
|
|
|
|
func NewULChangeURLCallbackRef(ref unsafe.Pointer) *ULChangeURLCallback {
|
|
return (*ULChangeURLCallback)(ref)
|
|
}
|
|
|
|
//export uLChangeURLCallback4EC32B80
|
|
func uLChangeURLCallback4EC32B80(cuserData unsafe.Pointer, ccaller C.ULView, curl C.ULString) {
|
|
if uLChangeURLCallback4EC32B80Func != nil {
|
|
userData4ec32b80 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller4ec32b80 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
url4ec32b80 := *(*ULString)(unsafe.Pointer(&curl))
|
|
uLChangeURLCallback4EC32B80Func(userData4ec32b80, caller4ec32b80, url4ec32b80)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLChangeURLCallback4EC32B80Func ULChangeURLCallback
|
|
|
|
func (x ULChangeTooltipCallback) PassRef() (ref *C.ULChangeTooltipCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeTooltipCallback12CA407Func == nil {
|
|
uLChangeTooltipCallback12CA407Func = x
|
|
}
|
|
return (*C.ULChangeTooltipCallback)(C.ULChangeTooltipCallback_12ca407), nil
|
|
}
|
|
|
|
func (x ULChangeTooltipCallback) PassValue() (ref C.ULChangeTooltipCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeTooltipCallback12CA407Func == nil {
|
|
uLChangeTooltipCallback12CA407Func = x
|
|
}
|
|
return (C.ULChangeTooltipCallback)(C.ULChangeTooltipCallback_12ca407), nil
|
|
}
|
|
|
|
func NewULChangeTooltipCallbackRef(ref unsafe.Pointer) *ULChangeTooltipCallback {
|
|
return (*ULChangeTooltipCallback)(ref)
|
|
}
|
|
|
|
//export uLChangeTooltipCallback12CA407
|
|
func uLChangeTooltipCallback12CA407(cuserData unsafe.Pointer, ccaller C.ULView, ctooltip C.ULString) {
|
|
if uLChangeTooltipCallback12CA407Func != nil {
|
|
userData12ca407 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller12ca407 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
tooltip12ca407 := *(*ULString)(unsafe.Pointer(&ctooltip))
|
|
uLChangeTooltipCallback12CA407Func(userData12ca407, caller12ca407, tooltip12ca407)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLChangeTooltipCallback12CA407Func ULChangeTooltipCallback
|
|
|
|
func (x ULChangeCursorCallback) PassRef() (ref *C.ULChangeCursorCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeCursorCallback1A7011DFFunc == nil {
|
|
uLChangeCursorCallback1A7011DFFunc = x
|
|
}
|
|
return (*C.ULChangeCursorCallback)(C.ULChangeCursorCallback_1a7011df), nil
|
|
}
|
|
|
|
func (x ULChangeCursorCallback) PassValue() (ref C.ULChangeCursorCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLChangeCursorCallback1A7011DFFunc == nil {
|
|
uLChangeCursorCallback1A7011DFFunc = x
|
|
}
|
|
return (C.ULChangeCursorCallback)(C.ULChangeCursorCallback_1a7011df), nil
|
|
}
|
|
|
|
func NewULChangeCursorCallbackRef(ref unsafe.Pointer) *ULChangeCursorCallback {
|
|
return (*ULChangeCursorCallback)(ref)
|
|
}
|
|
|
|
//export uLChangeCursorCallback1A7011DF
|
|
func uLChangeCursorCallback1A7011DF(cuserData unsafe.Pointer, ccaller C.ULView, ccursor C.ULCursor) {
|
|
if uLChangeCursorCallback1A7011DFFunc != nil {
|
|
userData1a7011df := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller1a7011df := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
cursor1a7011df := (ULCursor)(ccursor)
|
|
uLChangeCursorCallback1A7011DFFunc(userData1a7011df, caller1a7011df, cursor1a7011df)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLChangeCursorCallback1A7011DFFunc ULChangeCursorCallback
|
|
|
|
func (x ULAddConsoleMessageCallback) PassRef() (ref *C.ULAddConsoleMessageCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLAddConsoleMessageCallback44B8DD01Func == nil {
|
|
uLAddConsoleMessageCallback44B8DD01Func = x
|
|
}
|
|
return (*C.ULAddConsoleMessageCallback)(C.ULAddConsoleMessageCallback_44b8dd01), nil
|
|
}
|
|
|
|
func (x ULAddConsoleMessageCallback) PassValue() (ref C.ULAddConsoleMessageCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLAddConsoleMessageCallback44B8DD01Func == nil {
|
|
uLAddConsoleMessageCallback44B8DD01Func = x
|
|
}
|
|
return (C.ULAddConsoleMessageCallback)(C.ULAddConsoleMessageCallback_44b8dd01), nil
|
|
}
|
|
|
|
func NewULAddConsoleMessageCallbackRef(ref unsafe.Pointer) *ULAddConsoleMessageCallback {
|
|
return (*ULAddConsoleMessageCallback)(ref)
|
|
}
|
|
|
|
//export uLAddConsoleMessageCallback44B8DD01
|
|
func uLAddConsoleMessageCallback44B8DD01(cuserData unsafe.Pointer, ccaller C.ULView, csource C.ULMessageSource, clevel C.ULMessageLevel, cmessage C.ULString, clineNumber C.uint, ccolumnNumber C.uint, csourceId C.ULString) {
|
|
if uLAddConsoleMessageCallback44B8DD01Func != nil {
|
|
userData44b8dd01 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller44b8dd01 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
source44b8dd01 := (ULMessageSource)(csource)
|
|
level44b8dd01 := (ULMessageLevel)(clevel)
|
|
message44b8dd01 := *(*ULString)(unsafe.Pointer(&cmessage))
|
|
lineNumber44b8dd01 := (uint32)(clineNumber)
|
|
columnNumber44b8dd01 := (uint32)(ccolumnNumber)
|
|
sourceId44b8dd01 := *(*ULString)(unsafe.Pointer(&csourceId))
|
|
uLAddConsoleMessageCallback44B8DD01Func(userData44b8dd01, caller44b8dd01, source44b8dd01, level44b8dd01, message44b8dd01, lineNumber44b8dd01, columnNumber44b8dd01, sourceId44b8dd01)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLAddConsoleMessageCallback44B8DD01Func ULAddConsoleMessageCallback
|
|
|
|
func (x ULCreateChildViewCallback) PassRef() (ref *C.ULCreateChildViewCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLCreateChildViewCallbackEF6D2CDDFunc == nil {
|
|
uLCreateChildViewCallbackEF6D2CDDFunc = x
|
|
}
|
|
return (*C.ULCreateChildViewCallback)(C.ULCreateChildViewCallback_ef6d2cdd), nil
|
|
}
|
|
|
|
func (x ULCreateChildViewCallback) PassValue() (ref C.ULCreateChildViewCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLCreateChildViewCallbackEF6D2CDDFunc == nil {
|
|
uLCreateChildViewCallbackEF6D2CDDFunc = x
|
|
}
|
|
return (C.ULCreateChildViewCallback)(C.ULCreateChildViewCallback_ef6d2cdd), nil
|
|
}
|
|
|
|
func NewULCreateChildViewCallbackRef(ref unsafe.Pointer) *ULCreateChildViewCallback {
|
|
return (*ULCreateChildViewCallback)(ref)
|
|
}
|
|
|
|
//export uLCreateChildViewCallbackEF6D2CDD
|
|
func uLCreateChildViewCallbackEF6D2CDD(cuserData unsafe.Pointer, ccaller C.ULView, copenerUrl C.ULString, ctargetUrl C.ULString, cisPopup C._Bool, cpopupRect C.ULIntRect) C.ULView {
|
|
if uLCreateChildViewCallbackEF6D2CDDFunc != nil {
|
|
userDataef6d2cdd := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
calleref6d2cdd := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
openerUrlef6d2cdd := *(*ULString)(unsafe.Pointer(&copenerUrl))
|
|
targetUrlef6d2cdd := *(*ULString)(unsafe.Pointer(&ctargetUrl))
|
|
isPopupef6d2cdd := (bool)(cisPopup)
|
|
popupRectef6d2cdd := *NewULIntRectRef(unsafe.Pointer(&cpopupRect))
|
|
retef6d2cdd := uLCreateChildViewCallbackEF6D2CDDFunc(userDataef6d2cdd, calleref6d2cdd, openerUrlef6d2cdd, targetUrlef6d2cdd, isPopupef6d2cdd, popupRectef6d2cdd)
|
|
ret, _ := *(*C.ULView)(unsafe.Pointer(&retef6d2cdd)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLCreateChildViewCallbackEF6D2CDDFunc ULCreateChildViewCallback
|
|
|
|
func (x ULBeginLoadingCallback) PassRef() (ref *C.ULBeginLoadingCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLBeginLoadingCallback70D8C0ADFunc == nil {
|
|
uLBeginLoadingCallback70D8C0ADFunc = x
|
|
}
|
|
return (*C.ULBeginLoadingCallback)(C.ULBeginLoadingCallback_70d8c0ad), nil
|
|
}
|
|
|
|
func (x ULBeginLoadingCallback) PassValue() (ref C.ULBeginLoadingCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLBeginLoadingCallback70D8C0ADFunc == nil {
|
|
uLBeginLoadingCallback70D8C0ADFunc = x
|
|
}
|
|
return (C.ULBeginLoadingCallback)(C.ULBeginLoadingCallback_70d8c0ad), nil
|
|
}
|
|
|
|
func NewULBeginLoadingCallbackRef(ref unsafe.Pointer) *ULBeginLoadingCallback {
|
|
return (*ULBeginLoadingCallback)(ref)
|
|
}
|
|
|
|
//export uLBeginLoadingCallback70D8C0AD
|
|
func uLBeginLoadingCallback70D8C0AD(cuserData unsafe.Pointer, ccaller C.ULView, cframeId C.ulonglong, cisMainFrame C._Bool, curl C.ULString) {
|
|
if uLBeginLoadingCallback70D8C0ADFunc != nil {
|
|
userData70d8c0ad := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller70d8c0ad := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
frameId70d8c0ad := (uint64)(cframeId)
|
|
isMainFrame70d8c0ad := (bool)(cisMainFrame)
|
|
url70d8c0ad := *(*ULString)(unsafe.Pointer(&curl))
|
|
uLBeginLoadingCallback70D8C0ADFunc(userData70d8c0ad, caller70d8c0ad, frameId70d8c0ad, isMainFrame70d8c0ad, url70d8c0ad)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLBeginLoadingCallback70D8C0ADFunc ULBeginLoadingCallback
|
|
|
|
func (x ULFinishLoadingCallback) PassRef() (ref *C.ULFinishLoadingCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFinishLoadingCallback1ED4ECAEFunc == nil {
|
|
uLFinishLoadingCallback1ED4ECAEFunc = x
|
|
}
|
|
return (*C.ULFinishLoadingCallback)(C.ULFinishLoadingCallback_1ed4ecae), nil
|
|
}
|
|
|
|
func (x ULFinishLoadingCallback) PassValue() (ref C.ULFinishLoadingCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFinishLoadingCallback1ED4ECAEFunc == nil {
|
|
uLFinishLoadingCallback1ED4ECAEFunc = x
|
|
}
|
|
return (C.ULFinishLoadingCallback)(C.ULFinishLoadingCallback_1ed4ecae), nil
|
|
}
|
|
|
|
func NewULFinishLoadingCallbackRef(ref unsafe.Pointer) *ULFinishLoadingCallback {
|
|
return (*ULFinishLoadingCallback)(ref)
|
|
}
|
|
|
|
//export uLFinishLoadingCallback1ED4ECAE
|
|
func uLFinishLoadingCallback1ED4ECAE(cuserData unsafe.Pointer, ccaller C.ULView, cframeId C.ulonglong, cisMainFrame C._Bool, curl C.ULString) {
|
|
if uLFinishLoadingCallback1ED4ECAEFunc != nil {
|
|
userData1ed4ecae := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller1ed4ecae := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
frameId1ed4ecae := (uint64)(cframeId)
|
|
isMainFrame1ed4ecae := (bool)(cisMainFrame)
|
|
url1ed4ecae := *(*ULString)(unsafe.Pointer(&curl))
|
|
uLFinishLoadingCallback1ED4ECAEFunc(userData1ed4ecae, caller1ed4ecae, frameId1ed4ecae, isMainFrame1ed4ecae, url1ed4ecae)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFinishLoadingCallback1ED4ECAEFunc ULFinishLoadingCallback
|
|
|
|
func (x ULFailLoadingCallback) PassRef() (ref *C.ULFailLoadingCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFailLoadingCallback55FF90B8Func == nil {
|
|
uLFailLoadingCallback55FF90B8Func = x
|
|
}
|
|
return (*C.ULFailLoadingCallback)(C.ULFailLoadingCallback_55ff90b8), nil
|
|
}
|
|
|
|
func (x ULFailLoadingCallback) PassValue() (ref C.ULFailLoadingCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFailLoadingCallback55FF90B8Func == nil {
|
|
uLFailLoadingCallback55FF90B8Func = x
|
|
}
|
|
return (C.ULFailLoadingCallback)(C.ULFailLoadingCallback_55ff90b8), nil
|
|
}
|
|
|
|
func NewULFailLoadingCallbackRef(ref unsafe.Pointer) *ULFailLoadingCallback {
|
|
return (*ULFailLoadingCallback)(ref)
|
|
}
|
|
|
|
//export uLFailLoadingCallback55FF90B8
|
|
func uLFailLoadingCallback55FF90B8(cuserData unsafe.Pointer, ccaller C.ULView, cframeId C.ulonglong, cisMainFrame C._Bool, curl C.ULString, cdescription C.ULString, cerrorDomain C.ULString, cerrorCode C.int) {
|
|
if uLFailLoadingCallback55FF90B8Func != nil {
|
|
userData55ff90b8 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller55ff90b8 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
frameId55ff90b8 := (uint64)(cframeId)
|
|
isMainFrame55ff90b8 := (bool)(cisMainFrame)
|
|
url55ff90b8 := *(*ULString)(unsafe.Pointer(&curl))
|
|
description55ff90b8 := *(*ULString)(unsafe.Pointer(&cdescription))
|
|
errorDomain55ff90b8 := *(*ULString)(unsafe.Pointer(&cerrorDomain))
|
|
errorCode55ff90b8 := (int32)(cerrorCode)
|
|
uLFailLoadingCallback55FF90B8Func(userData55ff90b8, caller55ff90b8, frameId55ff90b8, isMainFrame55ff90b8, url55ff90b8, description55ff90b8, errorDomain55ff90b8, errorCode55ff90b8)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFailLoadingCallback55FF90B8Func ULFailLoadingCallback
|
|
|
|
func (x ULWindowObjectReadyCallback) PassRef() (ref *C.ULWindowObjectReadyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLWindowObjectReadyCallback66DC25F3Func == nil {
|
|
uLWindowObjectReadyCallback66DC25F3Func = x
|
|
}
|
|
return (*C.ULWindowObjectReadyCallback)(C.ULWindowObjectReadyCallback_66dc25f3), nil
|
|
}
|
|
|
|
func (x ULWindowObjectReadyCallback) PassValue() (ref C.ULWindowObjectReadyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLWindowObjectReadyCallback66DC25F3Func == nil {
|
|
uLWindowObjectReadyCallback66DC25F3Func = x
|
|
}
|
|
return (C.ULWindowObjectReadyCallback)(C.ULWindowObjectReadyCallback_66dc25f3), nil
|
|
}
|
|
|
|
func NewULWindowObjectReadyCallbackRef(ref unsafe.Pointer) *ULWindowObjectReadyCallback {
|
|
return (*ULWindowObjectReadyCallback)(ref)
|
|
}
|
|
|
|
//export uLWindowObjectReadyCallback66DC25F3
|
|
func uLWindowObjectReadyCallback66DC25F3(cuserData unsafe.Pointer, ccaller C.ULView, cframeId C.ulonglong, cisMainFrame C._Bool, curl C.ULString) {
|
|
if uLWindowObjectReadyCallback66DC25F3Func != nil {
|
|
userData66dc25f3 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller66dc25f3 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
frameId66dc25f3 := (uint64)(cframeId)
|
|
isMainFrame66dc25f3 := (bool)(cisMainFrame)
|
|
url66dc25f3 := *(*ULString)(unsafe.Pointer(&curl))
|
|
uLWindowObjectReadyCallback66DC25F3Func(userData66dc25f3, caller66dc25f3, frameId66dc25f3, isMainFrame66dc25f3, url66dc25f3)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLWindowObjectReadyCallback66DC25F3Func ULWindowObjectReadyCallback
|
|
|
|
func (x ULDOMReadyCallback) PassRef() (ref *C.ULDOMReadyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLDOMReadyCallback6432C207Func == nil {
|
|
uLDOMReadyCallback6432C207Func = x
|
|
}
|
|
return (*C.ULDOMReadyCallback)(C.ULDOMReadyCallback_6432c207), nil
|
|
}
|
|
|
|
func (x ULDOMReadyCallback) PassValue() (ref C.ULDOMReadyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLDOMReadyCallback6432C207Func == nil {
|
|
uLDOMReadyCallback6432C207Func = x
|
|
}
|
|
return (C.ULDOMReadyCallback)(C.ULDOMReadyCallback_6432c207), nil
|
|
}
|
|
|
|
func NewULDOMReadyCallbackRef(ref unsafe.Pointer) *ULDOMReadyCallback {
|
|
return (*ULDOMReadyCallback)(ref)
|
|
}
|
|
|
|
//export uLDOMReadyCallback6432C207
|
|
func uLDOMReadyCallback6432C207(cuserData unsafe.Pointer, ccaller C.ULView, cframeId C.ulonglong, cisMainFrame C._Bool, curl C.ULString) {
|
|
if uLDOMReadyCallback6432C207Func != nil {
|
|
userData6432c207 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller6432c207 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
frameId6432c207 := (uint64)(cframeId)
|
|
isMainFrame6432c207 := (bool)(cisMainFrame)
|
|
url6432c207 := *(*ULString)(unsafe.Pointer(&curl))
|
|
uLDOMReadyCallback6432C207Func(userData6432c207, caller6432c207, frameId6432c207, isMainFrame6432c207, url6432c207)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLDOMReadyCallback6432C207Func ULDOMReadyCallback
|
|
|
|
func (x ULUpdateHistoryCallback) PassRef() (ref *C.ULUpdateHistoryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLUpdateHistoryCallback6E105364Func == nil {
|
|
uLUpdateHistoryCallback6E105364Func = x
|
|
}
|
|
return (*C.ULUpdateHistoryCallback)(C.ULUpdateHistoryCallback_6e105364), nil
|
|
}
|
|
|
|
func (x ULUpdateHistoryCallback) PassValue() (ref C.ULUpdateHistoryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLUpdateHistoryCallback6E105364Func == nil {
|
|
uLUpdateHistoryCallback6E105364Func = x
|
|
}
|
|
return (C.ULUpdateHistoryCallback)(C.ULUpdateHistoryCallback_6e105364), nil
|
|
}
|
|
|
|
func NewULUpdateHistoryCallbackRef(ref unsafe.Pointer) *ULUpdateHistoryCallback {
|
|
return (*ULUpdateHistoryCallback)(ref)
|
|
}
|
|
|
|
//export uLUpdateHistoryCallback6E105364
|
|
func uLUpdateHistoryCallback6E105364(cuserData unsafe.Pointer, ccaller C.ULView) {
|
|
if uLUpdateHistoryCallback6E105364Func != nil {
|
|
userData6e105364 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
caller6e105364 := *(*ULView)(unsafe.Pointer(&ccaller))
|
|
uLUpdateHistoryCallback6E105364Func(userData6e105364, caller6e105364)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLUpdateHistoryCallback6E105364Func ULUpdateHistoryCallback
|
|
|
|
func (x ULSurfaceDefinitionCreateCallback) PassRef() (ref *C.ULSurfaceDefinitionCreateCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionCreateCallback573EC115Func == nil {
|
|
uLSurfaceDefinitionCreateCallback573EC115Func = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionCreateCallback)(C.ULSurfaceDefinitionCreateCallback_573ec115), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionCreateCallback) PassValue() (ref C.ULSurfaceDefinitionCreateCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionCreateCallback573EC115Func == nil {
|
|
uLSurfaceDefinitionCreateCallback573EC115Func = x
|
|
}
|
|
return (C.ULSurfaceDefinitionCreateCallback)(C.ULSurfaceDefinitionCreateCallback_573ec115), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionCreateCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionCreateCallback {
|
|
return (*ULSurfaceDefinitionCreateCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionCreateCallback573EC115
|
|
func uLSurfaceDefinitionCreateCallback573EC115(cwidth C.uint, cheight C.uint) unsafe.Pointer {
|
|
if uLSurfaceDefinitionCreateCallback573EC115Func != nil {
|
|
width573ec115 := (uint32)(cwidth)
|
|
height573ec115 := (uint32)(cheight)
|
|
ret573ec115 := uLSurfaceDefinitionCreateCallback573EC115Func(width573ec115, height573ec115)
|
|
ret, _ := ret573ec115, cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionCreateCallback573EC115Func ULSurfaceDefinitionCreateCallback
|
|
|
|
func (x ULSurfaceDefinitionDestroyCallback) PassRef() (ref *C.ULSurfaceDefinitionDestroyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionDestroyCallback851BACEEFunc == nil {
|
|
uLSurfaceDefinitionDestroyCallback851BACEEFunc = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionDestroyCallback)(C.ULSurfaceDefinitionDestroyCallback_851bacee), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionDestroyCallback) PassValue() (ref C.ULSurfaceDefinitionDestroyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionDestroyCallback851BACEEFunc == nil {
|
|
uLSurfaceDefinitionDestroyCallback851BACEEFunc = x
|
|
}
|
|
return (C.ULSurfaceDefinitionDestroyCallback)(C.ULSurfaceDefinitionDestroyCallback_851bacee), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionDestroyCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionDestroyCallback {
|
|
return (*ULSurfaceDefinitionDestroyCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionDestroyCallback851BACEE
|
|
func uLSurfaceDefinitionDestroyCallback851BACEE(cuserData unsafe.Pointer) {
|
|
if uLSurfaceDefinitionDestroyCallback851BACEEFunc != nil {
|
|
userData851bacee := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
uLSurfaceDefinitionDestroyCallback851BACEEFunc(userData851bacee)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionDestroyCallback851BACEEFunc ULSurfaceDefinitionDestroyCallback
|
|
|
|
func (x ULSurfaceDefinitionGetWidthCallback) PassRef() (ref *C.ULSurfaceDefinitionGetWidthCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc == nil {
|
|
uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionGetWidthCallback)(C.ULSurfaceDefinitionGetWidthCallback_1a49a8fd), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionGetWidthCallback) PassValue() (ref C.ULSurfaceDefinitionGetWidthCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc == nil {
|
|
uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc = x
|
|
}
|
|
return (C.ULSurfaceDefinitionGetWidthCallback)(C.ULSurfaceDefinitionGetWidthCallback_1a49a8fd), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionGetWidthCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionGetWidthCallback {
|
|
return (*ULSurfaceDefinitionGetWidthCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionGetWidthCallback1A49A8FD
|
|
func uLSurfaceDefinitionGetWidthCallback1A49A8FD(cuserData unsafe.Pointer) C.uint {
|
|
if uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc != nil {
|
|
userData1a49a8fd := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
ret1a49a8fd := uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc(userData1a49a8fd)
|
|
ret, _ := (C.uint)(ret1a49a8fd), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionGetWidthCallback1A49A8FDFunc ULSurfaceDefinitionGetWidthCallback
|
|
|
|
func (x ULSurfaceDefinitionGetHeightCallback) PassRef() (ref *C.ULSurfaceDefinitionGetHeightCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetHeightCallback3E5FE408Func == nil {
|
|
uLSurfaceDefinitionGetHeightCallback3E5FE408Func = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionGetHeightCallback)(C.ULSurfaceDefinitionGetHeightCallback_3e5fe408), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionGetHeightCallback) PassValue() (ref C.ULSurfaceDefinitionGetHeightCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetHeightCallback3E5FE408Func == nil {
|
|
uLSurfaceDefinitionGetHeightCallback3E5FE408Func = x
|
|
}
|
|
return (C.ULSurfaceDefinitionGetHeightCallback)(C.ULSurfaceDefinitionGetHeightCallback_3e5fe408), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionGetHeightCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionGetHeightCallback {
|
|
return (*ULSurfaceDefinitionGetHeightCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionGetHeightCallback3E5FE408
|
|
func uLSurfaceDefinitionGetHeightCallback3E5FE408(cuserData unsafe.Pointer) C.uint {
|
|
if uLSurfaceDefinitionGetHeightCallback3E5FE408Func != nil {
|
|
userData3e5fe408 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
ret3e5fe408 := uLSurfaceDefinitionGetHeightCallback3E5FE408Func(userData3e5fe408)
|
|
ret, _ := (C.uint)(ret3e5fe408), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionGetHeightCallback3E5FE408Func ULSurfaceDefinitionGetHeightCallback
|
|
|
|
func (x ULSurfaceDefinitionGetRowBytesCallback) PassRef() (ref *C.ULSurfaceDefinitionGetRowBytesCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func == nil {
|
|
uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionGetRowBytesCallback)(C.ULSurfaceDefinitionGetRowBytesCallback_adcc8668), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionGetRowBytesCallback) PassValue() (ref C.ULSurfaceDefinitionGetRowBytesCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func == nil {
|
|
uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func = x
|
|
}
|
|
return (C.ULSurfaceDefinitionGetRowBytesCallback)(C.ULSurfaceDefinitionGetRowBytesCallback_adcc8668), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionGetRowBytesCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionGetRowBytesCallback {
|
|
return (*ULSurfaceDefinitionGetRowBytesCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionGetRowBytesCallbackADCC8668
|
|
func uLSurfaceDefinitionGetRowBytesCallbackADCC8668(cuserData unsafe.Pointer) C.uint {
|
|
if uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func != nil {
|
|
userDataadcc8668 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
retadcc8668 := uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func(userDataadcc8668)
|
|
ret, _ := (C.uint)(retadcc8668), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionGetRowBytesCallbackADCC8668Func ULSurfaceDefinitionGetRowBytesCallback
|
|
|
|
func (x ULSurfaceDefinitionGetSizeCallback) PassRef() (ref *C.ULSurfaceDefinitionGetSizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetSizeCallback83184AFEFunc == nil {
|
|
uLSurfaceDefinitionGetSizeCallback83184AFEFunc = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionGetSizeCallback)(C.ULSurfaceDefinitionGetSizeCallback_83184afe), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionGetSizeCallback) PassValue() (ref C.ULSurfaceDefinitionGetSizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionGetSizeCallback83184AFEFunc == nil {
|
|
uLSurfaceDefinitionGetSizeCallback83184AFEFunc = x
|
|
}
|
|
return (C.ULSurfaceDefinitionGetSizeCallback)(C.ULSurfaceDefinitionGetSizeCallback_83184afe), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionGetSizeCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionGetSizeCallback {
|
|
return (*ULSurfaceDefinitionGetSizeCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionGetSizeCallback83184AFE
|
|
func uLSurfaceDefinitionGetSizeCallback83184AFE(cuserData unsafe.Pointer) C.size_t {
|
|
if uLSurfaceDefinitionGetSizeCallback83184AFEFunc != nil {
|
|
userData83184afe := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
ret83184afe := uLSurfaceDefinitionGetSizeCallback83184AFEFunc(userData83184afe)
|
|
ret, _ := (C.size_t)(ret83184afe), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionGetSizeCallback83184AFEFunc ULSurfaceDefinitionGetSizeCallback
|
|
|
|
func (x ULSurfaceDefinitionLockPixelsCallback) PassRef() (ref *C.ULSurfaceDefinitionLockPixelsCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionLockPixelsCallback7763E12FFunc == nil {
|
|
uLSurfaceDefinitionLockPixelsCallback7763E12FFunc = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionLockPixelsCallback)(C.ULSurfaceDefinitionLockPixelsCallback_7763e12f), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionLockPixelsCallback) PassValue() (ref C.ULSurfaceDefinitionLockPixelsCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionLockPixelsCallback7763E12FFunc == nil {
|
|
uLSurfaceDefinitionLockPixelsCallback7763E12FFunc = x
|
|
}
|
|
return (C.ULSurfaceDefinitionLockPixelsCallback)(C.ULSurfaceDefinitionLockPixelsCallback_7763e12f), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionLockPixelsCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionLockPixelsCallback {
|
|
return (*ULSurfaceDefinitionLockPixelsCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionLockPixelsCallback7763E12F
|
|
func uLSurfaceDefinitionLockPixelsCallback7763E12F(cuserData unsafe.Pointer) unsafe.Pointer {
|
|
if uLSurfaceDefinitionLockPixelsCallback7763E12FFunc != nil {
|
|
userData7763e12f := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
ret7763e12f := uLSurfaceDefinitionLockPixelsCallback7763E12FFunc(userData7763e12f)
|
|
ret, _ := ret7763e12f, cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionLockPixelsCallback7763E12FFunc ULSurfaceDefinitionLockPixelsCallback
|
|
|
|
func (x ULSurfaceDefinitionUnlockPixelsCallback) PassRef() (ref *C.ULSurfaceDefinitionUnlockPixelsCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func == nil {
|
|
uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionUnlockPixelsCallback)(C.ULSurfaceDefinitionUnlockPixelsCallback_d4b69f9), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionUnlockPixelsCallback) PassValue() (ref C.ULSurfaceDefinitionUnlockPixelsCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func == nil {
|
|
uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func = x
|
|
}
|
|
return (C.ULSurfaceDefinitionUnlockPixelsCallback)(C.ULSurfaceDefinitionUnlockPixelsCallback_d4b69f9), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionUnlockPixelsCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionUnlockPixelsCallback {
|
|
return (*ULSurfaceDefinitionUnlockPixelsCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9
|
|
func uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9(cuserData unsafe.Pointer) {
|
|
if uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func != nil {
|
|
userDatad4b69f9 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func(userDatad4b69f9)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionUnlockPixelsCallbackD4B69F9Func ULSurfaceDefinitionUnlockPixelsCallback
|
|
|
|
func (x ULSurfaceDefinitionResizeCallback) PassRef() (ref *C.ULSurfaceDefinitionResizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionResizeCallback22D82567Func == nil {
|
|
uLSurfaceDefinitionResizeCallback22D82567Func = x
|
|
}
|
|
return (*C.ULSurfaceDefinitionResizeCallback)(C.ULSurfaceDefinitionResizeCallback_22d82567), nil
|
|
}
|
|
|
|
func (x ULSurfaceDefinitionResizeCallback) PassValue() (ref C.ULSurfaceDefinitionResizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLSurfaceDefinitionResizeCallback22D82567Func == nil {
|
|
uLSurfaceDefinitionResizeCallback22D82567Func = x
|
|
}
|
|
return (C.ULSurfaceDefinitionResizeCallback)(C.ULSurfaceDefinitionResizeCallback_22d82567), nil
|
|
}
|
|
|
|
func NewULSurfaceDefinitionResizeCallbackRef(ref unsafe.Pointer) *ULSurfaceDefinitionResizeCallback {
|
|
return (*ULSurfaceDefinitionResizeCallback)(ref)
|
|
}
|
|
|
|
//export uLSurfaceDefinitionResizeCallback22D82567
|
|
func uLSurfaceDefinitionResizeCallback22D82567(cuserData unsafe.Pointer, cwidth C.uint, cheight C.uint) {
|
|
if uLSurfaceDefinitionResizeCallback22D82567Func != nil {
|
|
userData22d82567 := (unsafe.Pointer)(unsafe.Pointer(cuserData))
|
|
width22d82567 := (uint32)(cwidth)
|
|
height22d82567 := (uint32)(cheight)
|
|
uLSurfaceDefinitionResizeCallback22D82567Func(userData22d82567, width22d82567, height22d82567)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLSurfaceDefinitionResizeCallback22D82567Func ULSurfaceDefinitionResizeCallback
|
|
|
|
// allocULSurfaceDefinitionMemory allocates memory for type C.ULSurfaceDefinition in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULSurfaceDefinitionMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULSurfaceDefinitionValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULSurfaceDefinitionValue = unsafe.Sizeof([1]C.ULSurfaceDefinition{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULSurfaceDefinition) Ref() *C.ULSurfaceDefinition {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref13063f1a
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULSurfaceDefinition) Free() {
|
|
if x != nil && x.allocs13063f1a != nil {
|
|
x.allocs13063f1a.(*cgoAllocMap).Free()
|
|
x.ref13063f1a = nil
|
|
}
|
|
}
|
|
|
|
// NewULSurfaceDefinitionRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULSurfaceDefinitionRef(ref unsafe.Pointer) *ULSurfaceDefinition {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULSurfaceDefinition)
|
|
obj.ref13063f1a = (*C.ULSurfaceDefinition)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULSurfaceDefinition) PassRef() (*C.ULSurfaceDefinition, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref13063f1a != nil {
|
|
return x.ref13063f1a, nil
|
|
}
|
|
mem13063f1a := allocULSurfaceDefinitionMemory(1)
|
|
ref13063f1a := (*C.ULSurfaceDefinition)(mem13063f1a)
|
|
allocs13063f1a := new(cgoAllocMap)
|
|
allocs13063f1a.Add(mem13063f1a)
|
|
|
|
var ccreate_allocs *cgoAllocMap
|
|
ref13063f1a.create, ccreate_allocs = x.Create.PassValue()
|
|
allocs13063f1a.Borrow(ccreate_allocs)
|
|
|
|
var cdestroy_allocs *cgoAllocMap
|
|
ref13063f1a.destroy, cdestroy_allocs = x.Destroy.PassValue()
|
|
allocs13063f1a.Borrow(cdestroy_allocs)
|
|
|
|
var cget_width_allocs *cgoAllocMap
|
|
ref13063f1a.get_width, cget_width_allocs = x.GetWidth.PassValue()
|
|
allocs13063f1a.Borrow(cget_width_allocs)
|
|
|
|
var cget_height_allocs *cgoAllocMap
|
|
ref13063f1a.get_height, cget_height_allocs = x.GetHeight.PassValue()
|
|
allocs13063f1a.Borrow(cget_height_allocs)
|
|
|
|
var cget_row_bytes_allocs *cgoAllocMap
|
|
ref13063f1a.get_row_bytes, cget_row_bytes_allocs = x.GetRowBytes.PassValue()
|
|
allocs13063f1a.Borrow(cget_row_bytes_allocs)
|
|
|
|
var cget_size_allocs *cgoAllocMap
|
|
ref13063f1a.get_size, cget_size_allocs = x.GetSize.PassValue()
|
|
allocs13063f1a.Borrow(cget_size_allocs)
|
|
|
|
var clock_pixels_allocs *cgoAllocMap
|
|
ref13063f1a.lock_pixels, clock_pixels_allocs = x.LockPixels.PassValue()
|
|
allocs13063f1a.Borrow(clock_pixels_allocs)
|
|
|
|
var cunlock_pixels_allocs *cgoAllocMap
|
|
ref13063f1a.unlock_pixels, cunlock_pixels_allocs = x.UnlockPixels.PassValue()
|
|
allocs13063f1a.Borrow(cunlock_pixels_allocs)
|
|
|
|
var cresize_allocs *cgoAllocMap
|
|
ref13063f1a.resize, cresize_allocs = x.Resize.PassValue()
|
|
allocs13063f1a.Borrow(cresize_allocs)
|
|
|
|
x.ref13063f1a = ref13063f1a
|
|
x.allocs13063f1a = allocs13063f1a
|
|
return ref13063f1a, allocs13063f1a
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULSurfaceDefinition) PassValue() (C.ULSurfaceDefinition, *cgoAllocMap) {
|
|
if x.ref13063f1a != nil {
|
|
return *x.ref13063f1a, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULSurfaceDefinition) Deref() {
|
|
if x.ref13063f1a == nil {
|
|
return
|
|
}
|
|
x.Create = *NewULSurfaceDefinitionCreateCallbackRef(unsafe.Pointer(&x.ref13063f1a.create))
|
|
x.Destroy = *NewULSurfaceDefinitionDestroyCallbackRef(unsafe.Pointer(&x.ref13063f1a.destroy))
|
|
x.GetWidth = *NewULSurfaceDefinitionGetWidthCallbackRef(unsafe.Pointer(&x.ref13063f1a.get_width))
|
|
x.GetHeight = *NewULSurfaceDefinitionGetHeightCallbackRef(unsafe.Pointer(&x.ref13063f1a.get_height))
|
|
x.GetRowBytes = *NewULSurfaceDefinitionGetRowBytesCallbackRef(unsafe.Pointer(&x.ref13063f1a.get_row_bytes))
|
|
x.GetSize = *NewULSurfaceDefinitionGetSizeCallbackRef(unsafe.Pointer(&x.ref13063f1a.get_size))
|
|
x.LockPixels = *NewULSurfaceDefinitionLockPixelsCallbackRef(unsafe.Pointer(&x.ref13063f1a.lock_pixels))
|
|
x.UnlockPixels = *NewULSurfaceDefinitionUnlockPixelsCallbackRef(unsafe.Pointer(&x.ref13063f1a.unlock_pixels))
|
|
x.Resize = *NewULSurfaceDefinitionResizeCallbackRef(unsafe.Pointer(&x.ref13063f1a.resize))
|
|
}
|
|
|
|
func (x ULFileSystemFileExistsCallback) PassRef() (ref *C.ULFileSystemFileExistsCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemFileExistsCallbackD03BF100Func == nil {
|
|
uLFileSystemFileExistsCallbackD03BF100Func = x
|
|
}
|
|
return (*C.ULFileSystemFileExistsCallback)(C.ULFileSystemFileExistsCallback_d03bf100), nil
|
|
}
|
|
|
|
func (x ULFileSystemFileExistsCallback) PassValue() (ref C.ULFileSystemFileExistsCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemFileExistsCallbackD03BF100Func == nil {
|
|
uLFileSystemFileExistsCallbackD03BF100Func = x
|
|
}
|
|
return (C.ULFileSystemFileExistsCallback)(C.ULFileSystemFileExistsCallback_d03bf100), nil
|
|
}
|
|
|
|
func NewULFileSystemFileExistsCallbackRef(ref unsafe.Pointer) *ULFileSystemFileExistsCallback {
|
|
return (*ULFileSystemFileExistsCallback)(ref)
|
|
}
|
|
|
|
//export uLFileSystemFileExistsCallbackD03BF100
|
|
func uLFileSystemFileExistsCallbackD03BF100(cpath C.ULString) C._Bool {
|
|
if uLFileSystemFileExistsCallbackD03BF100Func != nil {
|
|
pathd03bf100 := *(*ULString)(unsafe.Pointer(&cpath))
|
|
retd03bf100 := uLFileSystemFileExistsCallbackD03BF100Func(pathd03bf100)
|
|
ret, _ := (C._Bool)(retd03bf100), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFileSystemFileExistsCallbackD03BF100Func ULFileSystemFileExistsCallback
|
|
|
|
type sliceHeader struct {
|
|
Data unsafe.Pointer
|
|
Len int
|
|
Cap int
|
|
}
|
|
|
|
func (x ULFileSystemGetFileSizeCallback) PassRef() (ref *C.ULFileSystemGetFileSizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemGetFileSizeCallbackE87AD8B1Func == nil {
|
|
uLFileSystemGetFileSizeCallbackE87AD8B1Func = x
|
|
}
|
|
return (*C.ULFileSystemGetFileSizeCallback)(C.ULFileSystemGetFileSizeCallback_e87ad8b1), nil
|
|
}
|
|
|
|
func (x ULFileSystemGetFileSizeCallback) PassValue() (ref C.ULFileSystemGetFileSizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemGetFileSizeCallbackE87AD8B1Func == nil {
|
|
uLFileSystemGetFileSizeCallbackE87AD8B1Func = x
|
|
}
|
|
return (C.ULFileSystemGetFileSizeCallback)(C.ULFileSystemGetFileSizeCallback_e87ad8b1), nil
|
|
}
|
|
|
|
func NewULFileSystemGetFileSizeCallbackRef(ref unsafe.Pointer) *ULFileSystemGetFileSizeCallback {
|
|
return (*ULFileSystemGetFileSizeCallback)(ref)
|
|
}
|
|
|
|
//export uLFileSystemGetFileSizeCallbackE87AD8B1
|
|
func uLFileSystemGetFileSizeCallbackE87AD8B1(chandle C.ULFileHandle, cresult *C.longlong) C._Bool {
|
|
if uLFileSystemGetFileSizeCallbackE87AD8B1Func != nil {
|
|
handlee87ad8b1 := (ULFileHandle)(chandle)
|
|
var resulte87ad8b1 []int64
|
|
hxfc4425b := (*sliceHeader)(unsafe.Pointer(&resulte87ad8b1))
|
|
hxfc4425b.Data = unsafe.Pointer(cresult)
|
|
hxfc4425b.Cap = 0x7fffffff
|
|
// hxfc4425b.Len = ?
|
|
|
|
rete87ad8b1 := uLFileSystemGetFileSizeCallbackE87AD8B1Func(handlee87ad8b1, resulte87ad8b1)
|
|
ret, _ := (C._Bool)(rete87ad8b1), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFileSystemGetFileSizeCallbackE87AD8B1Func ULFileSystemGetFileSizeCallback
|
|
|
|
func (x ULFileSystemGetFileMimeTypeCallback) PassRef() (ref *C.ULFileSystemGetFileMimeTypeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemGetFileMimeTypeCallback7E6FD322Func == nil {
|
|
uLFileSystemGetFileMimeTypeCallback7E6FD322Func = x
|
|
}
|
|
return (*C.ULFileSystemGetFileMimeTypeCallback)(C.ULFileSystemGetFileMimeTypeCallback_7e6fd322), nil
|
|
}
|
|
|
|
func (x ULFileSystemGetFileMimeTypeCallback) PassValue() (ref C.ULFileSystemGetFileMimeTypeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemGetFileMimeTypeCallback7E6FD322Func == nil {
|
|
uLFileSystemGetFileMimeTypeCallback7E6FD322Func = x
|
|
}
|
|
return (C.ULFileSystemGetFileMimeTypeCallback)(C.ULFileSystemGetFileMimeTypeCallback_7e6fd322), nil
|
|
}
|
|
|
|
func NewULFileSystemGetFileMimeTypeCallbackRef(ref unsafe.Pointer) *ULFileSystemGetFileMimeTypeCallback {
|
|
return (*ULFileSystemGetFileMimeTypeCallback)(ref)
|
|
}
|
|
|
|
//export uLFileSystemGetFileMimeTypeCallback7E6FD322
|
|
func uLFileSystemGetFileMimeTypeCallback7E6FD322(cpath C.ULString, cresult C.ULString) C._Bool {
|
|
if uLFileSystemGetFileMimeTypeCallback7E6FD322Func != nil {
|
|
path7e6fd322 := *(*ULString)(unsafe.Pointer(&cpath))
|
|
result7e6fd322 := *(*ULString)(unsafe.Pointer(&cresult))
|
|
ret7e6fd322 := uLFileSystemGetFileMimeTypeCallback7E6FD322Func(path7e6fd322, result7e6fd322)
|
|
ret, _ := (C._Bool)(ret7e6fd322), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFileSystemGetFileMimeTypeCallback7E6FD322Func ULFileSystemGetFileMimeTypeCallback
|
|
|
|
func (x ULFileSystemOpenFileCallback) PassRef() (ref *C.ULFileSystemOpenFileCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemOpenFileCallbackBBB19604Func == nil {
|
|
uLFileSystemOpenFileCallbackBBB19604Func = x
|
|
}
|
|
return (*C.ULFileSystemOpenFileCallback)(C.ULFileSystemOpenFileCallback_bbb19604), nil
|
|
}
|
|
|
|
func (x ULFileSystemOpenFileCallback) PassValue() (ref C.ULFileSystemOpenFileCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemOpenFileCallbackBBB19604Func == nil {
|
|
uLFileSystemOpenFileCallbackBBB19604Func = x
|
|
}
|
|
return (C.ULFileSystemOpenFileCallback)(C.ULFileSystemOpenFileCallback_bbb19604), nil
|
|
}
|
|
|
|
func NewULFileSystemOpenFileCallbackRef(ref unsafe.Pointer) *ULFileSystemOpenFileCallback {
|
|
return (*ULFileSystemOpenFileCallback)(ref)
|
|
}
|
|
|
|
//export uLFileSystemOpenFileCallbackBBB19604
|
|
func uLFileSystemOpenFileCallbackBBB19604(cpath C.ULString, copenForWriting C._Bool) C.ULFileHandle {
|
|
if uLFileSystemOpenFileCallbackBBB19604Func != nil {
|
|
pathbbb19604 := *(*ULString)(unsafe.Pointer(&cpath))
|
|
openForWritingbbb19604 := (bool)(copenForWriting)
|
|
retbbb19604 := uLFileSystemOpenFileCallbackBBB19604Func(pathbbb19604, openForWritingbbb19604)
|
|
ret, _ := (C.ULFileHandle)(retbbb19604), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFileSystemOpenFileCallbackBBB19604Func ULFileSystemOpenFileCallback
|
|
|
|
func (x ULFileSystemCloseFileCallback) PassRef() (ref *C.ULFileSystemCloseFileCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemCloseFileCallbackC90AC2E5Func == nil {
|
|
uLFileSystemCloseFileCallbackC90AC2E5Func = x
|
|
}
|
|
return (*C.ULFileSystemCloseFileCallback)(C.ULFileSystemCloseFileCallback_c90ac2e5), nil
|
|
}
|
|
|
|
func (x ULFileSystemCloseFileCallback) PassValue() (ref C.ULFileSystemCloseFileCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemCloseFileCallbackC90AC2E5Func == nil {
|
|
uLFileSystemCloseFileCallbackC90AC2E5Func = x
|
|
}
|
|
return (C.ULFileSystemCloseFileCallback)(C.ULFileSystemCloseFileCallback_c90ac2e5), nil
|
|
}
|
|
|
|
func NewULFileSystemCloseFileCallbackRef(ref unsafe.Pointer) *ULFileSystemCloseFileCallback {
|
|
return (*ULFileSystemCloseFileCallback)(ref)
|
|
}
|
|
|
|
//export uLFileSystemCloseFileCallbackC90AC2E5
|
|
func uLFileSystemCloseFileCallbackC90AC2E5(chandle C.ULFileHandle) {
|
|
if uLFileSystemCloseFileCallbackC90AC2E5Func != nil {
|
|
handlec90ac2e5 := (ULFileHandle)(chandle)
|
|
uLFileSystemCloseFileCallbackC90AC2E5Func(handlec90ac2e5)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFileSystemCloseFileCallbackC90AC2E5Func ULFileSystemCloseFileCallback
|
|
|
|
func (x ULFileSystemReadFromFileCallback) PassRef() (ref *C.ULFileSystemReadFromFileCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemReadFromFileCallbackBC1997BCFunc == nil {
|
|
uLFileSystemReadFromFileCallbackBC1997BCFunc = x
|
|
}
|
|
return (*C.ULFileSystemReadFromFileCallback)(C.ULFileSystemReadFromFileCallback_bc1997bc), nil
|
|
}
|
|
|
|
func (x ULFileSystemReadFromFileCallback) PassValue() (ref C.ULFileSystemReadFromFileCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLFileSystemReadFromFileCallbackBC1997BCFunc == nil {
|
|
uLFileSystemReadFromFileCallbackBC1997BCFunc = x
|
|
}
|
|
return (C.ULFileSystemReadFromFileCallback)(C.ULFileSystemReadFromFileCallback_bc1997bc), nil
|
|
}
|
|
|
|
func NewULFileSystemReadFromFileCallbackRef(ref unsafe.Pointer) *ULFileSystemReadFromFileCallback {
|
|
return (*ULFileSystemReadFromFileCallback)(ref)
|
|
}
|
|
|
|
//export uLFileSystemReadFromFileCallbackBC1997BC
|
|
func uLFileSystemReadFromFileCallbackBC1997BC(chandle C.ULFileHandle, cdata *C.char, clength C.longlong) C.longlong {
|
|
if uLFileSystemReadFromFileCallbackBC1997BCFunc != nil {
|
|
handlebc1997bc := (ULFileHandle)(chandle)
|
|
var databc1997bc []byte
|
|
hxf95e7c8 := (*sliceHeader)(unsafe.Pointer(&databc1997bc))
|
|
hxf95e7c8.Data = unsafe.Pointer(cdata)
|
|
hxf95e7c8.Cap = 0x7fffffff
|
|
// hxf95e7c8.Len = ?
|
|
|
|
lengthbc1997bc := (int64)(clength)
|
|
retbc1997bc := uLFileSystemReadFromFileCallbackBC1997BCFunc(handlebc1997bc, databc1997bc, lengthbc1997bc)
|
|
ret, _ := (C.longlong)(retbc1997bc), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLFileSystemReadFromFileCallbackBC1997BCFunc ULFileSystemReadFromFileCallback
|
|
|
|
// allocULFileSystemMemory allocates memory for type C.ULFileSystem in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULFileSystemMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULFileSystemValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULFileSystemValue = unsafe.Sizeof([1]C.ULFileSystem{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULFileSystem) Ref() *C.ULFileSystem {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref41d243eb
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULFileSystem) Free() {
|
|
if x != nil && x.allocs41d243eb != nil {
|
|
x.allocs41d243eb.(*cgoAllocMap).Free()
|
|
x.ref41d243eb = nil
|
|
}
|
|
}
|
|
|
|
// NewULFileSystemRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULFileSystemRef(ref unsafe.Pointer) *ULFileSystem {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULFileSystem)
|
|
obj.ref41d243eb = (*C.ULFileSystem)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULFileSystem) PassRef() (*C.ULFileSystem, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref41d243eb != nil {
|
|
return x.ref41d243eb, nil
|
|
}
|
|
mem41d243eb := allocULFileSystemMemory(1)
|
|
ref41d243eb := (*C.ULFileSystem)(mem41d243eb)
|
|
allocs41d243eb := new(cgoAllocMap)
|
|
allocs41d243eb.Add(mem41d243eb)
|
|
|
|
var cfile_exists_allocs *cgoAllocMap
|
|
ref41d243eb.file_exists, cfile_exists_allocs = x.FileExists.PassValue()
|
|
allocs41d243eb.Borrow(cfile_exists_allocs)
|
|
|
|
var cget_file_size_allocs *cgoAllocMap
|
|
ref41d243eb.get_file_size, cget_file_size_allocs = x.GetFileSize.PassValue()
|
|
allocs41d243eb.Borrow(cget_file_size_allocs)
|
|
|
|
var cget_file_mime_type_allocs *cgoAllocMap
|
|
ref41d243eb.get_file_mime_type, cget_file_mime_type_allocs = x.GetFileMimeType.PassValue()
|
|
allocs41d243eb.Borrow(cget_file_mime_type_allocs)
|
|
|
|
var copen_file_allocs *cgoAllocMap
|
|
ref41d243eb.open_file, copen_file_allocs = x.OpenFile.PassValue()
|
|
allocs41d243eb.Borrow(copen_file_allocs)
|
|
|
|
var cclose_file_allocs *cgoAllocMap
|
|
ref41d243eb.close_file, cclose_file_allocs = x.CloseFile.PassValue()
|
|
allocs41d243eb.Borrow(cclose_file_allocs)
|
|
|
|
var cread_from_file_allocs *cgoAllocMap
|
|
ref41d243eb.read_from_file, cread_from_file_allocs = x.ReadFromFile.PassValue()
|
|
allocs41d243eb.Borrow(cread_from_file_allocs)
|
|
|
|
x.ref41d243eb = ref41d243eb
|
|
x.allocs41d243eb = allocs41d243eb
|
|
return ref41d243eb, allocs41d243eb
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULFileSystem) PassValue() (C.ULFileSystem, *cgoAllocMap) {
|
|
if x.ref41d243eb != nil {
|
|
return *x.ref41d243eb, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULFileSystem) Deref() {
|
|
if x.ref41d243eb == nil {
|
|
return
|
|
}
|
|
x.FileExists = *NewULFileSystemFileExistsCallbackRef(unsafe.Pointer(&x.ref41d243eb.file_exists))
|
|
x.GetFileSize = *NewULFileSystemGetFileSizeCallbackRef(unsafe.Pointer(&x.ref41d243eb.get_file_size))
|
|
x.GetFileMimeType = *NewULFileSystemGetFileMimeTypeCallbackRef(unsafe.Pointer(&x.ref41d243eb.get_file_mime_type))
|
|
x.OpenFile = *NewULFileSystemOpenFileCallbackRef(unsafe.Pointer(&x.ref41d243eb.open_file))
|
|
x.CloseFile = *NewULFileSystemCloseFileCallbackRef(unsafe.Pointer(&x.ref41d243eb.close_file))
|
|
x.ReadFromFile = *NewULFileSystemReadFromFileCallbackRef(unsafe.Pointer(&x.ref41d243eb.read_from_file))
|
|
}
|
|
|
|
func (x ULLoggerLogMessageCallback) PassRef() (ref *C.ULLoggerLogMessageCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLLoggerLogMessageCallback454E682AFunc == nil {
|
|
uLLoggerLogMessageCallback454E682AFunc = x
|
|
}
|
|
return (*C.ULLoggerLogMessageCallback)(C.ULLoggerLogMessageCallback_454e682a), nil
|
|
}
|
|
|
|
func (x ULLoggerLogMessageCallback) PassValue() (ref C.ULLoggerLogMessageCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLLoggerLogMessageCallback454E682AFunc == nil {
|
|
uLLoggerLogMessageCallback454E682AFunc = x
|
|
}
|
|
return (C.ULLoggerLogMessageCallback)(C.ULLoggerLogMessageCallback_454e682a), nil
|
|
}
|
|
|
|
func NewULLoggerLogMessageCallbackRef(ref unsafe.Pointer) *ULLoggerLogMessageCallback {
|
|
return (*ULLoggerLogMessageCallback)(ref)
|
|
}
|
|
|
|
//export uLLoggerLogMessageCallback454E682A
|
|
func uLLoggerLogMessageCallback454E682A(clogLevel C.ULLogLevel, cmessage C.ULString) {
|
|
if uLLoggerLogMessageCallback454E682AFunc != nil {
|
|
logLevel454e682a := (ULLogLevel)(clogLevel)
|
|
message454e682a := *(*ULString)(unsafe.Pointer(&cmessage))
|
|
uLLoggerLogMessageCallback454E682AFunc(logLevel454e682a, message454e682a)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLLoggerLogMessageCallback454E682AFunc ULLoggerLogMessageCallback
|
|
|
|
// allocULLoggerMemory allocates memory for type C.ULLogger in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULLoggerMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULLoggerValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULLoggerValue = unsafe.Sizeof([1]C.ULLogger{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULLogger) Ref() *C.ULLogger {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.refd55f8aa0
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULLogger) Free() {
|
|
if x != nil && x.allocsd55f8aa0 != nil {
|
|
x.allocsd55f8aa0.(*cgoAllocMap).Free()
|
|
x.refd55f8aa0 = nil
|
|
}
|
|
}
|
|
|
|
// NewULLoggerRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULLoggerRef(ref unsafe.Pointer) *ULLogger {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULLogger)
|
|
obj.refd55f8aa0 = (*C.ULLogger)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULLogger) PassRef() (*C.ULLogger, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.refd55f8aa0 != nil {
|
|
return x.refd55f8aa0, nil
|
|
}
|
|
memd55f8aa0 := allocULLoggerMemory(1)
|
|
refd55f8aa0 := (*C.ULLogger)(memd55f8aa0)
|
|
allocsd55f8aa0 := new(cgoAllocMap)
|
|
allocsd55f8aa0.Add(memd55f8aa0)
|
|
|
|
var clog_message_allocs *cgoAllocMap
|
|
refd55f8aa0.log_message, clog_message_allocs = x.LogMessage.PassValue()
|
|
allocsd55f8aa0.Borrow(clog_message_allocs)
|
|
|
|
x.refd55f8aa0 = refd55f8aa0
|
|
x.allocsd55f8aa0 = allocsd55f8aa0
|
|
return refd55f8aa0, allocsd55f8aa0
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULLogger) PassValue() (C.ULLogger, *cgoAllocMap) {
|
|
if x.refd55f8aa0 != nil {
|
|
return *x.refd55f8aa0, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULLogger) Deref() {
|
|
if x.refd55f8aa0 == nil {
|
|
return
|
|
}
|
|
x.LogMessage = *NewULLoggerLogMessageCallbackRef(unsafe.Pointer(&x.refd55f8aa0.log_message))
|
|
}
|
|
|
|
// allocULRenderBufferMemory allocates memory for type C.ULRenderBuffer in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULRenderBufferMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULRenderBufferValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULRenderBufferValue = unsafe.Sizeof([1]C.ULRenderBuffer{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULRenderBuffer) Ref() *C.ULRenderBuffer {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.refe8ed55f
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULRenderBuffer) Free() {
|
|
if x != nil && x.allocse8ed55f != nil {
|
|
x.allocse8ed55f.(*cgoAllocMap).Free()
|
|
x.refe8ed55f = nil
|
|
}
|
|
}
|
|
|
|
// NewULRenderBufferRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULRenderBufferRef(ref unsafe.Pointer) *ULRenderBuffer {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULRenderBuffer)
|
|
obj.refe8ed55f = (*C.ULRenderBuffer)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULRenderBuffer) PassRef() (*C.ULRenderBuffer, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.refe8ed55f != nil {
|
|
return x.refe8ed55f, nil
|
|
}
|
|
meme8ed55f := allocULRenderBufferMemory(1)
|
|
refe8ed55f := (*C.ULRenderBuffer)(meme8ed55f)
|
|
allocse8ed55f := new(cgoAllocMap)
|
|
allocse8ed55f.Add(meme8ed55f)
|
|
|
|
var ctexture_id_allocs *cgoAllocMap
|
|
refe8ed55f.texture_id, ctexture_id_allocs = (C.uint)(x.TextureId), cgoAllocsUnknown
|
|
allocse8ed55f.Borrow(ctexture_id_allocs)
|
|
|
|
var cwidth_allocs *cgoAllocMap
|
|
refe8ed55f.width, cwidth_allocs = (C.uint)(x.Width), cgoAllocsUnknown
|
|
allocse8ed55f.Borrow(cwidth_allocs)
|
|
|
|
var cheight_allocs *cgoAllocMap
|
|
refe8ed55f.height, cheight_allocs = (C.uint)(x.Height), cgoAllocsUnknown
|
|
allocse8ed55f.Borrow(cheight_allocs)
|
|
|
|
var chas_stencil_buffer_allocs *cgoAllocMap
|
|
refe8ed55f.has_stencil_buffer, chas_stencil_buffer_allocs = (C._Bool)(x.HasStencilBuffer), cgoAllocsUnknown
|
|
allocse8ed55f.Borrow(chas_stencil_buffer_allocs)
|
|
|
|
var chas_depth_buffer_allocs *cgoAllocMap
|
|
refe8ed55f.has_depth_buffer, chas_depth_buffer_allocs = (C._Bool)(x.HasDepthBuffer), cgoAllocsUnknown
|
|
allocse8ed55f.Borrow(chas_depth_buffer_allocs)
|
|
|
|
x.refe8ed55f = refe8ed55f
|
|
x.allocse8ed55f = allocse8ed55f
|
|
return refe8ed55f, allocse8ed55f
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULRenderBuffer) PassValue() (C.ULRenderBuffer, *cgoAllocMap) {
|
|
if x.refe8ed55f != nil {
|
|
return *x.refe8ed55f, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULRenderBuffer) Deref() {
|
|
if x.refe8ed55f == nil {
|
|
return
|
|
}
|
|
x.TextureId = (uint32)(x.refe8ed55f.texture_id)
|
|
x.Width = (uint32)(x.refe8ed55f.width)
|
|
x.Height = (uint32)(x.refe8ed55f.height)
|
|
x.HasStencilBuffer = (bool)(x.refe8ed55f.has_stencil_buffer)
|
|
x.HasDepthBuffer = (bool)(x.refe8ed55f.has_depth_buffer)
|
|
}
|
|
|
|
// allocULVertex2f4ub2fMemory allocates memory for type C.ULVertex_2f_4ub_2f in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULVertex2f4ub2fMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULVertex2f4ub2fValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULVertex2f4ub2fValue = unsafe.Sizeof([1]C.ULVertex_2f_4ub_2f{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULVertex2f4ub2f) Ref() *C.ULVertex_2f_4ub_2f {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref2acaf525
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULVertex2f4ub2f) Free() {
|
|
if x != nil && x.allocs2acaf525 != nil {
|
|
x.allocs2acaf525.(*cgoAllocMap).Free()
|
|
x.ref2acaf525 = nil
|
|
}
|
|
}
|
|
|
|
// NewULVertex2f4ub2fRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULVertex2f4ub2fRef(ref unsafe.Pointer) *ULVertex2f4ub2f {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULVertex2f4ub2f)
|
|
obj.ref2acaf525 = (*C.ULVertex_2f_4ub_2f)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULVertex2f4ub2f) PassRef() (*C.ULVertex_2f_4ub_2f, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref2acaf525 != nil {
|
|
return x.ref2acaf525, nil
|
|
}
|
|
mem2acaf525 := allocULVertex2f4ub2fMemory(1)
|
|
ref2acaf525 := (*C.ULVertex_2f_4ub_2f)(mem2acaf525)
|
|
allocs2acaf525 := new(cgoAllocMap)
|
|
allocs2acaf525.Add(mem2acaf525)
|
|
|
|
var cpos_allocs *cgoAllocMap
|
|
ref2acaf525.pos, cpos_allocs = *(*[2]C.float)(unsafe.Pointer(&x.Pos)), cgoAllocsUnknown
|
|
allocs2acaf525.Borrow(cpos_allocs)
|
|
|
|
var ccolor_allocs *cgoAllocMap
|
|
ref2acaf525.color, ccolor_allocs = *(*[4]C.uchar)(unsafe.Pointer(&x.Color)), cgoAllocsUnknown
|
|
allocs2acaf525.Borrow(ccolor_allocs)
|
|
|
|
var cobj_allocs *cgoAllocMap
|
|
ref2acaf525.obj, cobj_allocs = *(*[2]C.float)(unsafe.Pointer(&x.Obj)), cgoAllocsUnknown
|
|
allocs2acaf525.Borrow(cobj_allocs)
|
|
|
|
x.ref2acaf525 = ref2acaf525
|
|
x.allocs2acaf525 = allocs2acaf525
|
|
return ref2acaf525, allocs2acaf525
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULVertex2f4ub2f) PassValue() (C.ULVertex_2f_4ub_2f, *cgoAllocMap) {
|
|
if x.ref2acaf525 != nil {
|
|
return *x.ref2acaf525, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULVertex2f4ub2f) Deref() {
|
|
if x.ref2acaf525 == nil {
|
|
return
|
|
}
|
|
x.Pos = *(*[2]float32)(unsafe.Pointer(&x.ref2acaf525.pos))
|
|
x.Color = *(*[4]byte)(unsafe.Pointer(&x.ref2acaf525.color))
|
|
x.Obj = *(*[2]float32)(unsafe.Pointer(&x.ref2acaf525.obj))
|
|
}
|
|
|
|
// allocULVertex2f4ub2f2f28fMemory allocates memory for type C.ULVertex_2f_4ub_2f_2f_28f in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULVertex2f4ub2f2f28fMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULVertex2f4ub2f2f28fValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULVertex2f4ub2f2f28fValue = unsafe.Sizeof([1]C.ULVertex_2f_4ub_2f_2f_28f{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULVertex2f4ub2f2f28f) Ref() *C.ULVertex_2f_4ub_2f_2f_28f {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.refa40e1546
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULVertex2f4ub2f2f28f) Free() {
|
|
if x != nil && x.allocsa40e1546 != nil {
|
|
x.allocsa40e1546.(*cgoAllocMap).Free()
|
|
x.refa40e1546 = nil
|
|
}
|
|
}
|
|
|
|
// NewULVertex2f4ub2f2f28fRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULVertex2f4ub2f2f28fRef(ref unsafe.Pointer) *ULVertex2f4ub2f2f28f {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULVertex2f4ub2f2f28f)
|
|
obj.refa40e1546 = (*C.ULVertex_2f_4ub_2f_2f_28f)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULVertex2f4ub2f2f28f) PassRef() (*C.ULVertex_2f_4ub_2f_2f_28f, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.refa40e1546 != nil {
|
|
return x.refa40e1546, nil
|
|
}
|
|
mema40e1546 := allocULVertex2f4ub2f2f28fMemory(1)
|
|
refa40e1546 := (*C.ULVertex_2f_4ub_2f_2f_28f)(mema40e1546)
|
|
allocsa40e1546 := new(cgoAllocMap)
|
|
allocsa40e1546.Add(mema40e1546)
|
|
|
|
var cpos_allocs *cgoAllocMap
|
|
refa40e1546.pos, cpos_allocs = *(*[2]C.float)(unsafe.Pointer(&x.Pos)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cpos_allocs)
|
|
|
|
var ccolor_allocs *cgoAllocMap
|
|
refa40e1546.color, ccolor_allocs = *(*[4]C.uchar)(unsafe.Pointer(&x.Color)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(ccolor_allocs)
|
|
|
|
var ctex_allocs *cgoAllocMap
|
|
refa40e1546.tex, ctex_allocs = *(*[2]C.float)(unsafe.Pointer(&x.Tex)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(ctex_allocs)
|
|
|
|
var cobj_allocs *cgoAllocMap
|
|
refa40e1546.obj, cobj_allocs = *(*[2]C.float)(unsafe.Pointer(&x.Obj)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cobj_allocs)
|
|
|
|
var cdata0_allocs *cgoAllocMap
|
|
refa40e1546.data0, cdata0_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data0)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata0_allocs)
|
|
|
|
var cdata1_allocs *cgoAllocMap
|
|
refa40e1546.data1, cdata1_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data1)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata1_allocs)
|
|
|
|
var cdata2_allocs *cgoAllocMap
|
|
refa40e1546.data2, cdata2_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data2)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata2_allocs)
|
|
|
|
var cdata3_allocs *cgoAllocMap
|
|
refa40e1546.data3, cdata3_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data3)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata3_allocs)
|
|
|
|
var cdata4_allocs *cgoAllocMap
|
|
refa40e1546.data4, cdata4_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data4)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata4_allocs)
|
|
|
|
var cdata5_allocs *cgoAllocMap
|
|
refa40e1546.data5, cdata5_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data5)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata5_allocs)
|
|
|
|
var cdata6_allocs *cgoAllocMap
|
|
refa40e1546.data6, cdata6_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Data6)), cgoAllocsUnknown
|
|
allocsa40e1546.Borrow(cdata6_allocs)
|
|
|
|
x.refa40e1546 = refa40e1546
|
|
x.allocsa40e1546 = allocsa40e1546
|
|
return refa40e1546, allocsa40e1546
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULVertex2f4ub2f2f28f) PassValue() (C.ULVertex_2f_4ub_2f_2f_28f, *cgoAllocMap) {
|
|
if x.refa40e1546 != nil {
|
|
return *x.refa40e1546, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULVertex2f4ub2f2f28f) Deref() {
|
|
if x.refa40e1546 == nil {
|
|
return
|
|
}
|
|
x.Pos = *(*[2]float32)(unsafe.Pointer(&x.refa40e1546.pos))
|
|
x.Color = *(*[4]byte)(unsafe.Pointer(&x.refa40e1546.color))
|
|
x.Tex = *(*[2]float32)(unsafe.Pointer(&x.refa40e1546.tex))
|
|
x.Obj = *(*[2]float32)(unsafe.Pointer(&x.refa40e1546.obj))
|
|
x.Data0 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data0))
|
|
x.Data1 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data1))
|
|
x.Data2 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data2))
|
|
x.Data3 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data3))
|
|
x.Data4 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data4))
|
|
x.Data5 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data5))
|
|
x.Data6 = *(*[4]float32)(unsafe.Pointer(&x.refa40e1546.data6))
|
|
}
|
|
|
|
// allocULVertexBufferMemory allocates memory for type C.ULVertexBuffer in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULVertexBufferMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULVertexBufferValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULVertexBufferValue = unsafe.Sizeof([1]C.ULVertexBuffer{})
|
|
|
|
// copyPUcharBytes copies the data from Go slice as *C.uchar.
|
|
func copyPUcharBytes(slice *sliceHeader) (*C.uchar, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfUcharValue) * slice.Len,
|
|
Cap: int(sizeOfUcharValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.uchar)(mem0), allocs
|
|
}
|
|
|
|
// allocUcharMemory allocates memory for type C.uchar in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocUcharMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfUcharValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfUcharValue = unsafe.Sizeof([1]C.uchar{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULVertexBuffer) Ref() *C.ULVertexBuffer {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref38aa9279
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULVertexBuffer) Free() {
|
|
if x != nil && x.allocs38aa9279 != nil {
|
|
x.allocs38aa9279.(*cgoAllocMap).Free()
|
|
x.ref38aa9279 = nil
|
|
}
|
|
}
|
|
|
|
// NewULVertexBufferRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULVertexBufferRef(ref unsafe.Pointer) *ULVertexBuffer {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULVertexBuffer)
|
|
obj.ref38aa9279 = (*C.ULVertexBuffer)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULVertexBuffer) PassRef() (*C.ULVertexBuffer, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref38aa9279 != nil {
|
|
return x.ref38aa9279, nil
|
|
}
|
|
mem38aa9279 := allocULVertexBufferMemory(1)
|
|
ref38aa9279 := (*C.ULVertexBuffer)(mem38aa9279)
|
|
allocs38aa9279 := new(cgoAllocMap)
|
|
allocs38aa9279.Add(mem38aa9279)
|
|
|
|
var cformat_allocs *cgoAllocMap
|
|
ref38aa9279.format, cformat_allocs = (C.ULVertexBufferFormat)(x.Format), cgoAllocsUnknown
|
|
allocs38aa9279.Borrow(cformat_allocs)
|
|
|
|
var csize_allocs *cgoAllocMap
|
|
ref38aa9279.size, csize_allocs = (C.uint)(x.Size), cgoAllocsUnknown
|
|
allocs38aa9279.Borrow(csize_allocs)
|
|
|
|
var cdata_allocs *cgoAllocMap
|
|
ref38aa9279.data, cdata_allocs = copyPUcharBytes((*sliceHeader)(unsafe.Pointer(&x.Data)))
|
|
allocs38aa9279.Borrow(cdata_allocs)
|
|
|
|
x.ref38aa9279 = ref38aa9279
|
|
x.allocs38aa9279 = allocs38aa9279
|
|
return ref38aa9279, allocs38aa9279
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULVertexBuffer) PassValue() (C.ULVertexBuffer, *cgoAllocMap) {
|
|
if x.ref38aa9279 != nil {
|
|
return *x.ref38aa9279, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULVertexBuffer) Deref() {
|
|
if x.ref38aa9279 == nil {
|
|
return
|
|
}
|
|
x.Format = (ULVertexBufferFormat)(x.ref38aa9279.format)
|
|
x.Size = (uint32)(x.ref38aa9279.size)
|
|
hxff2234b := (*sliceHeader)(unsafe.Pointer(&x.Data))
|
|
hxff2234b.Data = unsafe.Pointer(x.ref38aa9279.data)
|
|
hxff2234b.Cap = 0x7fffffff
|
|
// hxff2234b.Len = ?
|
|
|
|
}
|
|
|
|
// allocULIndexBufferMemory allocates memory for type C.ULIndexBuffer in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULIndexBufferMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULIndexBufferValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULIndexBufferValue = unsafe.Sizeof([1]C.ULIndexBuffer{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULIndexBuffer) Ref() *C.ULIndexBuffer {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref8da49f64
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULIndexBuffer) Free() {
|
|
if x != nil && x.allocs8da49f64 != nil {
|
|
x.allocs8da49f64.(*cgoAllocMap).Free()
|
|
x.ref8da49f64 = nil
|
|
}
|
|
}
|
|
|
|
// NewULIndexBufferRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULIndexBufferRef(ref unsafe.Pointer) *ULIndexBuffer {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULIndexBuffer)
|
|
obj.ref8da49f64 = (*C.ULIndexBuffer)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULIndexBuffer) PassRef() (*C.ULIndexBuffer, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref8da49f64 != nil {
|
|
return x.ref8da49f64, nil
|
|
}
|
|
mem8da49f64 := allocULIndexBufferMemory(1)
|
|
ref8da49f64 := (*C.ULIndexBuffer)(mem8da49f64)
|
|
allocs8da49f64 := new(cgoAllocMap)
|
|
allocs8da49f64.Add(mem8da49f64)
|
|
|
|
var csize_allocs *cgoAllocMap
|
|
ref8da49f64.size, csize_allocs = (C.uint)(x.Size), cgoAllocsUnknown
|
|
allocs8da49f64.Borrow(csize_allocs)
|
|
|
|
var cdata_allocs *cgoAllocMap
|
|
ref8da49f64.data, cdata_allocs = copyPUcharBytes((*sliceHeader)(unsafe.Pointer(&x.Data)))
|
|
allocs8da49f64.Borrow(cdata_allocs)
|
|
|
|
x.ref8da49f64 = ref8da49f64
|
|
x.allocs8da49f64 = allocs8da49f64
|
|
return ref8da49f64, allocs8da49f64
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULIndexBuffer) PassValue() (C.ULIndexBuffer, *cgoAllocMap) {
|
|
if x.ref8da49f64 != nil {
|
|
return *x.ref8da49f64, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULIndexBuffer) Deref() {
|
|
if x.ref8da49f64 == nil {
|
|
return
|
|
}
|
|
x.Size = (uint32)(x.ref8da49f64.size)
|
|
hxff73280 := (*sliceHeader)(unsafe.Pointer(&x.Data))
|
|
hxff73280.Data = unsafe.Pointer(x.ref8da49f64.data)
|
|
hxff73280.Cap = 0x7fffffff
|
|
// hxff73280.Len = ?
|
|
|
|
}
|
|
|
|
// allocULMatrix4x4Memory allocates memory for type C.ULMatrix4x4 in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULMatrix4x4Memory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULMatrix4x4Value))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULMatrix4x4Value = unsafe.Sizeof([1]C.ULMatrix4x4{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULMatrix4x4) Ref() *C.ULMatrix4x4 {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref5420ec6b
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULMatrix4x4) Free() {
|
|
if x != nil && x.allocs5420ec6b != nil {
|
|
x.allocs5420ec6b.(*cgoAllocMap).Free()
|
|
x.ref5420ec6b = nil
|
|
}
|
|
}
|
|
|
|
// NewULMatrix4x4Ref creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULMatrix4x4Ref(ref unsafe.Pointer) *ULMatrix4x4 {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULMatrix4x4)
|
|
obj.ref5420ec6b = (*C.ULMatrix4x4)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULMatrix4x4) PassRef() (*C.ULMatrix4x4, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref5420ec6b != nil {
|
|
return x.ref5420ec6b, nil
|
|
}
|
|
mem5420ec6b := allocULMatrix4x4Memory(1)
|
|
ref5420ec6b := (*C.ULMatrix4x4)(mem5420ec6b)
|
|
allocs5420ec6b := new(cgoAllocMap)
|
|
allocs5420ec6b.Add(mem5420ec6b)
|
|
|
|
var cdata_allocs *cgoAllocMap
|
|
ref5420ec6b.data, cdata_allocs = *(*[16]C.float)(unsafe.Pointer(&x.Data)), cgoAllocsUnknown
|
|
allocs5420ec6b.Borrow(cdata_allocs)
|
|
|
|
x.ref5420ec6b = ref5420ec6b
|
|
x.allocs5420ec6b = allocs5420ec6b
|
|
return ref5420ec6b, allocs5420ec6b
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULMatrix4x4) PassValue() (C.ULMatrix4x4, *cgoAllocMap) {
|
|
if x.ref5420ec6b != nil {
|
|
return *x.ref5420ec6b, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULMatrix4x4) Deref() {
|
|
if x.ref5420ec6b == nil {
|
|
return
|
|
}
|
|
x.Data = *(*[16]float32)(unsafe.Pointer(&x.ref5420ec6b.data))
|
|
}
|
|
|
|
// allocULvec4Memory allocates memory for type C.ULvec4 in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULvec4Memory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULvec4Value))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULvec4Value = unsafe.Sizeof([1]C.ULvec4{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULvec4) Ref() *C.ULvec4 {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref1faeb7f5
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULvec4) Free() {
|
|
if x != nil && x.allocs1faeb7f5 != nil {
|
|
x.allocs1faeb7f5.(*cgoAllocMap).Free()
|
|
x.ref1faeb7f5 = nil
|
|
}
|
|
}
|
|
|
|
// NewULvec4Ref creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULvec4Ref(ref unsafe.Pointer) *ULvec4 {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULvec4)
|
|
obj.ref1faeb7f5 = (*C.ULvec4)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULvec4) PassRef() (*C.ULvec4, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref1faeb7f5 != nil {
|
|
return x.ref1faeb7f5, nil
|
|
}
|
|
mem1faeb7f5 := allocULvec4Memory(1)
|
|
ref1faeb7f5 := (*C.ULvec4)(mem1faeb7f5)
|
|
allocs1faeb7f5 := new(cgoAllocMap)
|
|
allocs1faeb7f5.Add(mem1faeb7f5)
|
|
|
|
var cvalue_allocs *cgoAllocMap
|
|
ref1faeb7f5.value, cvalue_allocs = *(*[4]C.float)(unsafe.Pointer(&x.Value)), cgoAllocsUnknown
|
|
allocs1faeb7f5.Borrow(cvalue_allocs)
|
|
|
|
x.ref1faeb7f5 = ref1faeb7f5
|
|
x.allocs1faeb7f5 = allocs1faeb7f5
|
|
return ref1faeb7f5, allocs1faeb7f5
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULvec4) PassValue() (C.ULvec4, *cgoAllocMap) {
|
|
if x.ref1faeb7f5 != nil {
|
|
return *x.ref1faeb7f5, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULvec4) Deref() {
|
|
if x.ref1faeb7f5 == nil {
|
|
return
|
|
}
|
|
x.Value = *(*[4]float32)(unsafe.Pointer(&x.ref1faeb7f5.value))
|
|
}
|
|
|
|
// allocULGPUStateMemory allocates memory for type C.ULGPUState in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULGPUStateMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULGPUStateValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULGPUStateValue = unsafe.Sizeof([1]C.ULGPUState{})
|
|
|
|
// allocA8ULvec4Memory allocates memory for type [8]C.ULvec4 in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocA8ULvec4Memory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfA8ULvec4Value))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfA8ULvec4Value = unsafe.Sizeof([1][8]C.ULvec4{})
|
|
|
|
const sizeOfPtr = unsafe.Sizeof(&struct{}{})
|
|
|
|
// unpackA8ULvec4 transforms a sliced Go data structure into plain C format.
|
|
func unpackA8ULvec4(x [8]ULvec4) (unpacked [8]C.ULvec4, allocs *cgoAllocMap) {
|
|
allocs = new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := allocA8ULvec4Memory(1)
|
|
allocs.Add(mem0)
|
|
v0 := (*[8]C.ULvec4)(mem0)
|
|
for i0 := range x {
|
|
allocs0 := new(cgoAllocMap)
|
|
v0[i0], allocs0 = x[i0].PassValue()
|
|
allocs.Borrow(allocs0)
|
|
}
|
|
unpacked = *(*[8]C.ULvec4)(mem0)
|
|
return
|
|
}
|
|
|
|
// allocA8ULMatrix4x4Memory allocates memory for type [8]C.ULMatrix4x4 in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocA8ULMatrix4x4Memory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfA8ULMatrix4x4Value))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfA8ULMatrix4x4Value = unsafe.Sizeof([1][8]C.ULMatrix4x4{})
|
|
|
|
// unpackA8ULMatrix4x4 transforms a sliced Go data structure into plain C format.
|
|
func unpackA8ULMatrix4x4(x [8]ULMatrix4x4) (unpacked [8]C.ULMatrix4x4, allocs *cgoAllocMap) {
|
|
allocs = new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := allocA8ULMatrix4x4Memory(1)
|
|
allocs.Add(mem0)
|
|
v0 := (*[8]C.ULMatrix4x4)(mem0)
|
|
for i0 := range x {
|
|
allocs0 := new(cgoAllocMap)
|
|
v0[i0], allocs0 = x[i0].PassValue()
|
|
allocs.Borrow(allocs0)
|
|
}
|
|
unpacked = *(*[8]C.ULMatrix4x4)(mem0)
|
|
return
|
|
}
|
|
|
|
// packA8ULvec4 reads sliced Go data structure out from plain C format.
|
|
func packA8ULvec4(v *[8]ULvec4, ptr0 *[8]C.ULvec4) {
|
|
for i0 := range v {
|
|
ptr1 := ptr0[i0]
|
|
v[i0] = *NewULvec4Ref(unsafe.Pointer(&ptr1))
|
|
}
|
|
}
|
|
|
|
// packA8ULMatrix4x4 reads sliced Go data structure out from plain C format.
|
|
func packA8ULMatrix4x4(v *[8]ULMatrix4x4, ptr0 *[8]C.ULMatrix4x4) {
|
|
for i0 := range v {
|
|
ptr1 := ptr0[i0]
|
|
v[i0] = *NewULMatrix4x4Ref(unsafe.Pointer(&ptr1))
|
|
}
|
|
}
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULGPUState) Ref() *C.ULGPUState {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref7caf648c
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULGPUState) Free() {
|
|
if x != nil && x.allocs7caf648c != nil {
|
|
x.allocs7caf648c.(*cgoAllocMap).Free()
|
|
x.ref7caf648c = nil
|
|
}
|
|
}
|
|
|
|
// NewULGPUStateRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULGPUStateRef(ref unsafe.Pointer) *ULGPUState {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULGPUState)
|
|
obj.ref7caf648c = (*C.ULGPUState)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULGPUState) PassRef() (*C.ULGPUState, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref7caf648c != nil {
|
|
return x.ref7caf648c, nil
|
|
}
|
|
mem7caf648c := allocULGPUStateMemory(1)
|
|
ref7caf648c := (*C.ULGPUState)(mem7caf648c)
|
|
allocs7caf648c := new(cgoAllocMap)
|
|
allocs7caf648c.Add(mem7caf648c)
|
|
|
|
var cviewport_width_allocs *cgoAllocMap
|
|
ref7caf648c.viewport_width, cviewport_width_allocs = (C.uint)(x.ViewportWidth), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cviewport_width_allocs)
|
|
|
|
var cviewport_height_allocs *cgoAllocMap
|
|
ref7caf648c.viewport_height, cviewport_height_allocs = (C.uint)(x.ViewportHeight), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cviewport_height_allocs)
|
|
|
|
var ctransform_allocs *cgoAllocMap
|
|
ref7caf648c.transform, ctransform_allocs = x.Transform.PassValue()
|
|
allocs7caf648c.Borrow(ctransform_allocs)
|
|
|
|
var cenable_texturing_allocs *cgoAllocMap
|
|
ref7caf648c.enable_texturing, cenable_texturing_allocs = (C._Bool)(x.EnableTexturing), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cenable_texturing_allocs)
|
|
|
|
var cenable_blend_allocs *cgoAllocMap
|
|
ref7caf648c.enable_blend, cenable_blend_allocs = (C._Bool)(x.EnableBlend), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cenable_blend_allocs)
|
|
|
|
var cshader_type_allocs *cgoAllocMap
|
|
ref7caf648c.shader_type, cshader_type_allocs = (C.uchar)(x.ShaderType), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cshader_type_allocs)
|
|
|
|
var crender_buffer_id_allocs *cgoAllocMap
|
|
ref7caf648c.render_buffer_id, crender_buffer_id_allocs = (C.uint)(x.RenderBufferId), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(crender_buffer_id_allocs)
|
|
|
|
var ctexture_1_id_allocs *cgoAllocMap
|
|
ref7caf648c.texture_1_id, ctexture_1_id_allocs = (C.uint)(x.Texture1Id), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(ctexture_1_id_allocs)
|
|
|
|
var ctexture_2_id_allocs *cgoAllocMap
|
|
ref7caf648c.texture_2_id, ctexture_2_id_allocs = (C.uint)(x.Texture2Id), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(ctexture_2_id_allocs)
|
|
|
|
var ctexture_3_id_allocs *cgoAllocMap
|
|
ref7caf648c.texture_3_id, ctexture_3_id_allocs = (C.uint)(x.Texture3Id), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(ctexture_3_id_allocs)
|
|
|
|
var cuniform_scalar_allocs *cgoAllocMap
|
|
ref7caf648c.uniform_scalar, cuniform_scalar_allocs = *(*[8]C.float)(unsafe.Pointer(&x.UniformScalar)), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cuniform_scalar_allocs)
|
|
|
|
var cuniform_vector_allocs *cgoAllocMap
|
|
ref7caf648c.uniform_vector, cuniform_vector_allocs = unpackA8ULvec4(x.UniformVector)
|
|
allocs7caf648c.Borrow(cuniform_vector_allocs)
|
|
|
|
var cclip_size_allocs *cgoAllocMap
|
|
ref7caf648c.clip_size, cclip_size_allocs = (C.uchar)(x.ClipSize), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cclip_size_allocs)
|
|
|
|
var cclip_allocs *cgoAllocMap
|
|
ref7caf648c.clip, cclip_allocs = unpackA8ULMatrix4x4(x.Clip)
|
|
allocs7caf648c.Borrow(cclip_allocs)
|
|
|
|
var cenable_scissor_allocs *cgoAllocMap
|
|
ref7caf648c.enable_scissor, cenable_scissor_allocs = (C._Bool)(x.EnableScissor), cgoAllocsUnknown
|
|
allocs7caf648c.Borrow(cenable_scissor_allocs)
|
|
|
|
var cscissor_rect_allocs *cgoAllocMap
|
|
ref7caf648c.scissor_rect, cscissor_rect_allocs = x.ScissorRect.PassValue()
|
|
allocs7caf648c.Borrow(cscissor_rect_allocs)
|
|
|
|
x.ref7caf648c = ref7caf648c
|
|
x.allocs7caf648c = allocs7caf648c
|
|
return ref7caf648c, allocs7caf648c
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULGPUState) PassValue() (C.ULGPUState, *cgoAllocMap) {
|
|
if x.ref7caf648c != nil {
|
|
return *x.ref7caf648c, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULGPUState) Deref() {
|
|
if x.ref7caf648c == nil {
|
|
return
|
|
}
|
|
x.ViewportWidth = (uint32)(x.ref7caf648c.viewport_width)
|
|
x.ViewportHeight = (uint32)(x.ref7caf648c.viewport_height)
|
|
x.Transform = *NewULMatrix4x4Ref(unsafe.Pointer(&x.ref7caf648c.transform))
|
|
x.EnableTexturing = (bool)(x.ref7caf648c.enable_texturing)
|
|
x.EnableBlend = (bool)(x.ref7caf648c.enable_blend)
|
|
x.ShaderType = (byte)(x.ref7caf648c.shader_type)
|
|
x.RenderBufferId = (uint32)(x.ref7caf648c.render_buffer_id)
|
|
x.Texture1Id = (uint32)(x.ref7caf648c.texture_1_id)
|
|
x.Texture2Id = (uint32)(x.ref7caf648c.texture_2_id)
|
|
x.Texture3Id = (uint32)(x.ref7caf648c.texture_3_id)
|
|
x.UniformScalar = *(*[8]float32)(unsafe.Pointer(&x.ref7caf648c.uniform_scalar))
|
|
packA8ULvec4(&x.UniformVector, (*[8]C.ULvec4)(unsafe.Pointer(&x.ref7caf648c.uniform_vector)))
|
|
x.ClipSize = (byte)(x.ref7caf648c.clip_size)
|
|
packA8ULMatrix4x4(&x.Clip, (*[8]C.ULMatrix4x4)(unsafe.Pointer(&x.ref7caf648c.clip)))
|
|
x.EnableScissor = (bool)(x.ref7caf648c.enable_scissor)
|
|
x.ScissorRect = *NewULIntRectRef(unsafe.Pointer(&x.ref7caf648c.scissor_rect))
|
|
}
|
|
|
|
// allocULCommandMemory allocates memory for type C.ULCommand in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULCommandMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULCommandValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULCommandValue = unsafe.Sizeof([1]C.ULCommand{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULCommand) Ref() *C.ULCommand {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref7ce5cb03
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULCommand) Free() {
|
|
if x != nil && x.allocs7ce5cb03 != nil {
|
|
x.allocs7ce5cb03.(*cgoAllocMap).Free()
|
|
x.ref7ce5cb03 = nil
|
|
}
|
|
}
|
|
|
|
// NewULCommandRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULCommandRef(ref unsafe.Pointer) *ULCommand {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULCommand)
|
|
obj.ref7ce5cb03 = (*C.ULCommand)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULCommand) PassRef() (*C.ULCommand, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref7ce5cb03 != nil {
|
|
return x.ref7ce5cb03, nil
|
|
}
|
|
mem7ce5cb03 := allocULCommandMemory(1)
|
|
ref7ce5cb03 := (*C.ULCommand)(mem7ce5cb03)
|
|
allocs7ce5cb03 := new(cgoAllocMap)
|
|
allocs7ce5cb03.Add(mem7ce5cb03)
|
|
|
|
var ccommand_type_allocs *cgoAllocMap
|
|
ref7ce5cb03.command_type, ccommand_type_allocs = (C.uchar)(x.CommandType), cgoAllocsUnknown
|
|
allocs7ce5cb03.Borrow(ccommand_type_allocs)
|
|
|
|
var cgpu_state_allocs *cgoAllocMap
|
|
ref7ce5cb03.gpu_state, cgpu_state_allocs = x.GpuState.PassValue()
|
|
allocs7ce5cb03.Borrow(cgpu_state_allocs)
|
|
|
|
var cgeometry_id_allocs *cgoAllocMap
|
|
ref7ce5cb03.geometry_id, cgeometry_id_allocs = (C.uint)(x.GeometryId), cgoAllocsUnknown
|
|
allocs7ce5cb03.Borrow(cgeometry_id_allocs)
|
|
|
|
var cindices_count_allocs *cgoAllocMap
|
|
ref7ce5cb03.indices_count, cindices_count_allocs = (C.uint)(x.IndicesCount), cgoAllocsUnknown
|
|
allocs7ce5cb03.Borrow(cindices_count_allocs)
|
|
|
|
var cindices_offset_allocs *cgoAllocMap
|
|
ref7ce5cb03.indices_offset, cindices_offset_allocs = (C.uint)(x.IndicesOffset), cgoAllocsUnknown
|
|
allocs7ce5cb03.Borrow(cindices_offset_allocs)
|
|
|
|
x.ref7ce5cb03 = ref7ce5cb03
|
|
x.allocs7ce5cb03 = allocs7ce5cb03
|
|
return ref7ce5cb03, allocs7ce5cb03
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULCommand) PassValue() (C.ULCommand, *cgoAllocMap) {
|
|
if x.ref7ce5cb03 != nil {
|
|
return *x.ref7ce5cb03, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULCommand) Deref() {
|
|
if x.ref7ce5cb03 == nil {
|
|
return
|
|
}
|
|
x.CommandType = (byte)(x.ref7ce5cb03.command_type)
|
|
x.GpuState = *NewULGPUStateRef(unsafe.Pointer(&x.ref7ce5cb03.gpu_state))
|
|
x.GeometryId = (uint32)(x.ref7ce5cb03.geometry_id)
|
|
x.IndicesCount = (uint32)(x.ref7ce5cb03.indices_count)
|
|
x.IndicesOffset = (uint32)(x.ref7ce5cb03.indices_offset)
|
|
}
|
|
|
|
// allocULCommandListMemory allocates memory for type C.ULCommandList in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULCommandListMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULCommandListValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULCommandListValue = unsafe.Sizeof([1]C.ULCommandList{})
|
|
|
|
// unpackSULCommand transforms a sliced Go data structure into plain C format.
|
|
func unpackSULCommand(x []ULCommand) (unpacked *C.ULCommand, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
allocs = new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
len0 := len(x)
|
|
mem0 := allocULCommandMemory(len0)
|
|
allocs.Add(mem0)
|
|
h0 := &sliceHeader{
|
|
Data: mem0,
|
|
Cap: len0,
|
|
Len: len0,
|
|
}
|
|
v0 := *(*[]C.ULCommand)(unsafe.Pointer(h0))
|
|
for i0 := range x {
|
|
allocs0 := new(cgoAllocMap)
|
|
v0[i0], allocs0 = x[i0].PassValue()
|
|
allocs.Borrow(allocs0)
|
|
}
|
|
h := (*sliceHeader)(unsafe.Pointer(&v0))
|
|
unpacked = (*C.ULCommand)(h.Data)
|
|
return
|
|
}
|
|
|
|
// packSULCommand reads sliced Go data structure out from plain C format.
|
|
func packSULCommand(v []ULCommand, ptr0 *C.ULCommand) {
|
|
const m = 0x7fffffff
|
|
for i0 := range v {
|
|
ptr1 := (*(*[m / sizeOfULCommandValue]C.ULCommand)(unsafe.Pointer(ptr0)))[i0]
|
|
v[i0] = *NewULCommandRef(unsafe.Pointer(&ptr1))
|
|
}
|
|
}
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULCommandList) Ref() *C.ULCommandList {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref110fbbd7
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULCommandList) Free() {
|
|
if x != nil && x.allocs110fbbd7 != nil {
|
|
x.allocs110fbbd7.(*cgoAllocMap).Free()
|
|
x.ref110fbbd7 = nil
|
|
}
|
|
}
|
|
|
|
// NewULCommandListRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULCommandListRef(ref unsafe.Pointer) *ULCommandList {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULCommandList)
|
|
obj.ref110fbbd7 = (*C.ULCommandList)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULCommandList) PassRef() (*C.ULCommandList, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref110fbbd7 != nil {
|
|
return x.ref110fbbd7, nil
|
|
}
|
|
mem110fbbd7 := allocULCommandListMemory(1)
|
|
ref110fbbd7 := (*C.ULCommandList)(mem110fbbd7)
|
|
allocs110fbbd7 := new(cgoAllocMap)
|
|
allocs110fbbd7.Add(mem110fbbd7)
|
|
|
|
var csize_allocs *cgoAllocMap
|
|
ref110fbbd7.size, csize_allocs = (C.uint)(x.Size), cgoAllocsUnknown
|
|
allocs110fbbd7.Borrow(csize_allocs)
|
|
|
|
var ccommands_allocs *cgoAllocMap
|
|
ref110fbbd7.commands, ccommands_allocs = unpackSULCommand(x.Commands)
|
|
allocs110fbbd7.Borrow(ccommands_allocs)
|
|
|
|
x.ref110fbbd7 = ref110fbbd7
|
|
x.allocs110fbbd7 = allocs110fbbd7
|
|
return ref110fbbd7, allocs110fbbd7
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULCommandList) PassValue() (C.ULCommandList, *cgoAllocMap) {
|
|
if x.ref110fbbd7 != nil {
|
|
return *x.ref110fbbd7, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULCommandList) Deref() {
|
|
if x.ref110fbbd7 == nil {
|
|
return
|
|
}
|
|
x.Size = (uint32)(x.ref110fbbd7.size)
|
|
packSULCommand(x.Commands, x.ref110fbbd7.commands)
|
|
}
|
|
|
|
func (x ULGPUDriverBeginSynchronizeCallback) PassRef() (ref *C.ULGPUDriverBeginSynchronizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverBeginSynchronizeCallback650938CFunc == nil {
|
|
uLGPUDriverBeginSynchronizeCallback650938CFunc = x
|
|
}
|
|
return (*C.ULGPUDriverBeginSynchronizeCallback)(C.ULGPUDriverBeginSynchronizeCallback_650938c), nil
|
|
}
|
|
|
|
func (x ULGPUDriverBeginSynchronizeCallback) PassValue() (ref C.ULGPUDriverBeginSynchronizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverBeginSynchronizeCallback650938CFunc == nil {
|
|
uLGPUDriverBeginSynchronizeCallback650938CFunc = x
|
|
}
|
|
return (C.ULGPUDriverBeginSynchronizeCallback)(C.ULGPUDriverBeginSynchronizeCallback_650938c), nil
|
|
}
|
|
|
|
func NewULGPUDriverBeginSynchronizeCallbackRef(ref unsafe.Pointer) *ULGPUDriverBeginSynchronizeCallback {
|
|
return (*ULGPUDriverBeginSynchronizeCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverBeginSynchronizeCallback650938C
|
|
func uLGPUDriverBeginSynchronizeCallback650938C() {
|
|
if uLGPUDriverBeginSynchronizeCallback650938CFunc != nil {
|
|
uLGPUDriverBeginSynchronizeCallback650938CFunc()
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverBeginSynchronizeCallback650938CFunc ULGPUDriverBeginSynchronizeCallback
|
|
|
|
func (x ULGPUDriverEndSynchronizeCallback) PassRef() (ref *C.ULGPUDriverEndSynchronizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc == nil {
|
|
uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc = x
|
|
}
|
|
return (*C.ULGPUDriverEndSynchronizeCallback)(C.ULGPUDriverEndSynchronizeCallback_f6baad4d), nil
|
|
}
|
|
|
|
func (x ULGPUDriverEndSynchronizeCallback) PassValue() (ref C.ULGPUDriverEndSynchronizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc == nil {
|
|
uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc = x
|
|
}
|
|
return (C.ULGPUDriverEndSynchronizeCallback)(C.ULGPUDriverEndSynchronizeCallback_f6baad4d), nil
|
|
}
|
|
|
|
func NewULGPUDriverEndSynchronizeCallbackRef(ref unsafe.Pointer) *ULGPUDriverEndSynchronizeCallback {
|
|
return (*ULGPUDriverEndSynchronizeCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverEndSynchronizeCallbackF6BAAD4D
|
|
func uLGPUDriverEndSynchronizeCallbackF6BAAD4D() {
|
|
if uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc != nil {
|
|
uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc()
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverEndSynchronizeCallbackF6BAAD4DFunc ULGPUDriverEndSynchronizeCallback
|
|
|
|
func (x ULGPUDriverNextTextureIdCallback) PassRef() (ref *C.ULGPUDriverNextTextureIdCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverNextTextureIdCallback7DE045B4Func == nil {
|
|
uLGPUDriverNextTextureIdCallback7DE045B4Func = x
|
|
}
|
|
return (*C.ULGPUDriverNextTextureIdCallback)(C.ULGPUDriverNextTextureIdCallback_7de045b4), nil
|
|
}
|
|
|
|
func (x ULGPUDriverNextTextureIdCallback) PassValue() (ref C.ULGPUDriverNextTextureIdCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverNextTextureIdCallback7DE045B4Func == nil {
|
|
uLGPUDriverNextTextureIdCallback7DE045B4Func = x
|
|
}
|
|
return (C.ULGPUDriverNextTextureIdCallback)(C.ULGPUDriverNextTextureIdCallback_7de045b4), nil
|
|
}
|
|
|
|
func NewULGPUDriverNextTextureIdCallbackRef(ref unsafe.Pointer) *ULGPUDriverNextTextureIdCallback {
|
|
return (*ULGPUDriverNextTextureIdCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverNextTextureIdCallback7DE045B4
|
|
func uLGPUDriverNextTextureIdCallback7DE045B4() C.uint {
|
|
if uLGPUDriverNextTextureIdCallback7DE045B4Func != nil {
|
|
ret7de045b4 := uLGPUDriverNextTextureIdCallback7DE045B4Func()
|
|
ret, _ := (C.uint)(ret7de045b4), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverNextTextureIdCallback7DE045B4Func ULGPUDriverNextTextureIdCallback
|
|
|
|
func (x ULGPUDriverCreateTextureCallback) PassRef() (ref *C.ULGPUDriverCreateTextureCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverCreateTextureCallbackA32244D8Func == nil {
|
|
uLGPUDriverCreateTextureCallbackA32244D8Func = x
|
|
}
|
|
return (*C.ULGPUDriverCreateTextureCallback)(C.ULGPUDriverCreateTextureCallback_a32244d8), nil
|
|
}
|
|
|
|
func (x ULGPUDriverCreateTextureCallback) PassValue() (ref C.ULGPUDriverCreateTextureCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverCreateTextureCallbackA32244D8Func == nil {
|
|
uLGPUDriverCreateTextureCallbackA32244D8Func = x
|
|
}
|
|
return (C.ULGPUDriverCreateTextureCallback)(C.ULGPUDriverCreateTextureCallback_a32244d8), nil
|
|
}
|
|
|
|
func NewULGPUDriverCreateTextureCallbackRef(ref unsafe.Pointer) *ULGPUDriverCreateTextureCallback {
|
|
return (*ULGPUDriverCreateTextureCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverCreateTextureCallbackA32244D8
|
|
func uLGPUDriverCreateTextureCallbackA32244D8(ctextureId C.uint, cbitmap C.ULBitmap) {
|
|
if uLGPUDriverCreateTextureCallbackA32244D8Func != nil {
|
|
textureIda32244d8 := (uint32)(ctextureId)
|
|
bitmapa32244d8 := *(*ULBitmap)(unsafe.Pointer(&cbitmap))
|
|
uLGPUDriverCreateTextureCallbackA32244D8Func(textureIda32244d8, bitmapa32244d8)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverCreateTextureCallbackA32244D8Func ULGPUDriverCreateTextureCallback
|
|
|
|
func (x ULGPUDriverUpdateTextureCallback) PassRef() (ref *C.ULGPUDriverUpdateTextureCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverUpdateTextureCallback3D7A526Func == nil {
|
|
uLGPUDriverUpdateTextureCallback3D7A526Func = x
|
|
}
|
|
return (*C.ULGPUDriverUpdateTextureCallback)(C.ULGPUDriverUpdateTextureCallback_3d7a526), nil
|
|
}
|
|
|
|
func (x ULGPUDriverUpdateTextureCallback) PassValue() (ref C.ULGPUDriverUpdateTextureCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverUpdateTextureCallback3D7A526Func == nil {
|
|
uLGPUDriverUpdateTextureCallback3D7A526Func = x
|
|
}
|
|
return (C.ULGPUDriverUpdateTextureCallback)(C.ULGPUDriverUpdateTextureCallback_3d7a526), nil
|
|
}
|
|
|
|
func NewULGPUDriverUpdateTextureCallbackRef(ref unsafe.Pointer) *ULGPUDriverUpdateTextureCallback {
|
|
return (*ULGPUDriverUpdateTextureCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverUpdateTextureCallback3D7A526
|
|
func uLGPUDriverUpdateTextureCallback3D7A526(ctextureId C.uint, cbitmap C.ULBitmap) {
|
|
if uLGPUDriverUpdateTextureCallback3D7A526Func != nil {
|
|
textureId3d7a526 := (uint32)(ctextureId)
|
|
bitmap3d7a526 := *(*ULBitmap)(unsafe.Pointer(&cbitmap))
|
|
uLGPUDriverUpdateTextureCallback3D7A526Func(textureId3d7a526, bitmap3d7a526)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverUpdateTextureCallback3D7A526Func ULGPUDriverUpdateTextureCallback
|
|
|
|
func (x ULGPUDriverDestroyTextureCallback) PassRef() (ref *C.ULGPUDriverDestroyTextureCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverDestroyTextureCallbackA8EEA310Func == nil {
|
|
uLGPUDriverDestroyTextureCallbackA8EEA310Func = x
|
|
}
|
|
return (*C.ULGPUDriverDestroyTextureCallback)(C.ULGPUDriverDestroyTextureCallback_a8eea310), nil
|
|
}
|
|
|
|
func (x ULGPUDriverDestroyTextureCallback) PassValue() (ref C.ULGPUDriverDestroyTextureCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverDestroyTextureCallbackA8EEA310Func == nil {
|
|
uLGPUDriverDestroyTextureCallbackA8EEA310Func = x
|
|
}
|
|
return (C.ULGPUDriverDestroyTextureCallback)(C.ULGPUDriverDestroyTextureCallback_a8eea310), nil
|
|
}
|
|
|
|
func NewULGPUDriverDestroyTextureCallbackRef(ref unsafe.Pointer) *ULGPUDriverDestroyTextureCallback {
|
|
return (*ULGPUDriverDestroyTextureCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverDestroyTextureCallbackA8EEA310
|
|
func uLGPUDriverDestroyTextureCallbackA8EEA310(ctextureId C.uint) {
|
|
if uLGPUDriverDestroyTextureCallbackA8EEA310Func != nil {
|
|
textureIda8eea310 := (uint32)(ctextureId)
|
|
uLGPUDriverDestroyTextureCallbackA8EEA310Func(textureIda8eea310)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverDestroyTextureCallbackA8EEA310Func ULGPUDriverDestroyTextureCallback
|
|
|
|
func (x ULGPUDriverNextRenderBufferIdCallback) PassRef() (ref *C.ULGPUDriverNextRenderBufferIdCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func == nil {
|
|
uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func = x
|
|
}
|
|
return (*C.ULGPUDriverNextRenderBufferIdCallback)(C.ULGPUDriverNextRenderBufferIdCallback_bfeb3fb8), nil
|
|
}
|
|
|
|
func (x ULGPUDriverNextRenderBufferIdCallback) PassValue() (ref C.ULGPUDriverNextRenderBufferIdCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func == nil {
|
|
uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func = x
|
|
}
|
|
return (C.ULGPUDriverNextRenderBufferIdCallback)(C.ULGPUDriverNextRenderBufferIdCallback_bfeb3fb8), nil
|
|
}
|
|
|
|
func NewULGPUDriverNextRenderBufferIdCallbackRef(ref unsafe.Pointer) *ULGPUDriverNextRenderBufferIdCallback {
|
|
return (*ULGPUDriverNextRenderBufferIdCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8
|
|
func uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8() C.uint {
|
|
if uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func != nil {
|
|
retbfeb3fb8 := uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func()
|
|
ret, _ := (C.uint)(retbfeb3fb8), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverNextRenderBufferIdCallbackBFEB3FB8Func ULGPUDriverNextRenderBufferIdCallback
|
|
|
|
func (x ULGPUDriverCreateRenderBufferCallback) PassRef() (ref *C.ULGPUDriverCreateRenderBufferCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverCreateRenderBufferCallback68EE5367Func == nil {
|
|
uLGPUDriverCreateRenderBufferCallback68EE5367Func = x
|
|
}
|
|
return (*C.ULGPUDriverCreateRenderBufferCallback)(C.ULGPUDriverCreateRenderBufferCallback_68ee5367), nil
|
|
}
|
|
|
|
func (x ULGPUDriverCreateRenderBufferCallback) PassValue() (ref C.ULGPUDriverCreateRenderBufferCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverCreateRenderBufferCallback68EE5367Func == nil {
|
|
uLGPUDriverCreateRenderBufferCallback68EE5367Func = x
|
|
}
|
|
return (C.ULGPUDriverCreateRenderBufferCallback)(C.ULGPUDriverCreateRenderBufferCallback_68ee5367), nil
|
|
}
|
|
|
|
func NewULGPUDriverCreateRenderBufferCallbackRef(ref unsafe.Pointer) *ULGPUDriverCreateRenderBufferCallback {
|
|
return (*ULGPUDriverCreateRenderBufferCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverCreateRenderBufferCallback68EE5367
|
|
func uLGPUDriverCreateRenderBufferCallback68EE5367(crenderBufferId C.uint, cbuffer C.ULRenderBuffer) {
|
|
if uLGPUDriverCreateRenderBufferCallback68EE5367Func != nil {
|
|
renderBufferId68ee5367 := (uint32)(crenderBufferId)
|
|
buffer68ee5367 := *NewULRenderBufferRef(unsafe.Pointer(&cbuffer))
|
|
uLGPUDriverCreateRenderBufferCallback68EE5367Func(renderBufferId68ee5367, buffer68ee5367)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverCreateRenderBufferCallback68EE5367Func ULGPUDriverCreateRenderBufferCallback
|
|
|
|
func (x ULGPUDriverDestroyRenderBufferCallback) PassRef() (ref *C.ULGPUDriverDestroyRenderBufferCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverDestroyRenderBufferCallback81623F13Func == nil {
|
|
uLGPUDriverDestroyRenderBufferCallback81623F13Func = x
|
|
}
|
|
return (*C.ULGPUDriverDestroyRenderBufferCallback)(C.ULGPUDriverDestroyRenderBufferCallback_81623f13), nil
|
|
}
|
|
|
|
func (x ULGPUDriverDestroyRenderBufferCallback) PassValue() (ref C.ULGPUDriverDestroyRenderBufferCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverDestroyRenderBufferCallback81623F13Func == nil {
|
|
uLGPUDriverDestroyRenderBufferCallback81623F13Func = x
|
|
}
|
|
return (C.ULGPUDriverDestroyRenderBufferCallback)(C.ULGPUDriverDestroyRenderBufferCallback_81623f13), nil
|
|
}
|
|
|
|
func NewULGPUDriverDestroyRenderBufferCallbackRef(ref unsafe.Pointer) *ULGPUDriverDestroyRenderBufferCallback {
|
|
return (*ULGPUDriverDestroyRenderBufferCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverDestroyRenderBufferCallback81623F13
|
|
func uLGPUDriverDestroyRenderBufferCallback81623F13(crenderBufferId C.uint) {
|
|
if uLGPUDriverDestroyRenderBufferCallback81623F13Func != nil {
|
|
renderBufferId81623f13 := (uint32)(crenderBufferId)
|
|
uLGPUDriverDestroyRenderBufferCallback81623F13Func(renderBufferId81623f13)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverDestroyRenderBufferCallback81623F13Func ULGPUDriverDestroyRenderBufferCallback
|
|
|
|
func (x ULGPUDriverNextGeometryIdCallback) PassRef() (ref *C.ULGPUDriverNextGeometryIdCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc == nil {
|
|
uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc = x
|
|
}
|
|
return (*C.ULGPUDriverNextGeometryIdCallback)(C.ULGPUDriverNextGeometryIdCallback_5f2a8fea), nil
|
|
}
|
|
|
|
func (x ULGPUDriverNextGeometryIdCallback) PassValue() (ref C.ULGPUDriverNextGeometryIdCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc == nil {
|
|
uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc = x
|
|
}
|
|
return (C.ULGPUDriverNextGeometryIdCallback)(C.ULGPUDriverNextGeometryIdCallback_5f2a8fea), nil
|
|
}
|
|
|
|
func NewULGPUDriverNextGeometryIdCallbackRef(ref unsafe.Pointer) *ULGPUDriverNextGeometryIdCallback {
|
|
return (*ULGPUDriverNextGeometryIdCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverNextGeometryIdCallback5F2A8FEA
|
|
func uLGPUDriverNextGeometryIdCallback5F2A8FEA() C.uint {
|
|
if uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc != nil {
|
|
ret5f2a8fea := uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc()
|
|
ret, _ := (C.uint)(ret5f2a8fea), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverNextGeometryIdCallback5F2A8FEAFunc ULGPUDriverNextGeometryIdCallback
|
|
|
|
func (x ULGPUDriverCreateGeometryCallback) PassRef() (ref *C.ULGPUDriverCreateGeometryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverCreateGeometryCallback5957236DFunc == nil {
|
|
uLGPUDriverCreateGeometryCallback5957236DFunc = x
|
|
}
|
|
return (*C.ULGPUDriverCreateGeometryCallback)(C.ULGPUDriverCreateGeometryCallback_5957236d), nil
|
|
}
|
|
|
|
func (x ULGPUDriverCreateGeometryCallback) PassValue() (ref C.ULGPUDriverCreateGeometryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverCreateGeometryCallback5957236DFunc == nil {
|
|
uLGPUDriverCreateGeometryCallback5957236DFunc = x
|
|
}
|
|
return (C.ULGPUDriverCreateGeometryCallback)(C.ULGPUDriverCreateGeometryCallback_5957236d), nil
|
|
}
|
|
|
|
func NewULGPUDriverCreateGeometryCallbackRef(ref unsafe.Pointer) *ULGPUDriverCreateGeometryCallback {
|
|
return (*ULGPUDriverCreateGeometryCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverCreateGeometryCallback5957236D
|
|
func uLGPUDriverCreateGeometryCallback5957236D(cgeometryId C.uint, cvertices C.ULVertexBuffer, cindices C.ULIndexBuffer) {
|
|
if uLGPUDriverCreateGeometryCallback5957236DFunc != nil {
|
|
geometryId5957236d := (uint32)(cgeometryId)
|
|
vertices5957236d := *NewULVertexBufferRef(unsafe.Pointer(&cvertices))
|
|
indices5957236d := *NewULIndexBufferRef(unsafe.Pointer(&cindices))
|
|
uLGPUDriverCreateGeometryCallback5957236DFunc(geometryId5957236d, vertices5957236d, indices5957236d)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverCreateGeometryCallback5957236DFunc ULGPUDriverCreateGeometryCallback
|
|
|
|
func (x ULGPUDriverUpdateGeometryCallback) PassRef() (ref *C.ULGPUDriverUpdateGeometryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverUpdateGeometryCallback3F20997Func == nil {
|
|
uLGPUDriverUpdateGeometryCallback3F20997Func = x
|
|
}
|
|
return (*C.ULGPUDriverUpdateGeometryCallback)(C.ULGPUDriverUpdateGeometryCallback_3f20997), nil
|
|
}
|
|
|
|
func (x ULGPUDriverUpdateGeometryCallback) PassValue() (ref C.ULGPUDriverUpdateGeometryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverUpdateGeometryCallback3F20997Func == nil {
|
|
uLGPUDriverUpdateGeometryCallback3F20997Func = x
|
|
}
|
|
return (C.ULGPUDriverUpdateGeometryCallback)(C.ULGPUDriverUpdateGeometryCallback_3f20997), nil
|
|
}
|
|
|
|
func NewULGPUDriverUpdateGeometryCallbackRef(ref unsafe.Pointer) *ULGPUDriverUpdateGeometryCallback {
|
|
return (*ULGPUDriverUpdateGeometryCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverUpdateGeometryCallback3F20997
|
|
func uLGPUDriverUpdateGeometryCallback3F20997(cgeometryId C.uint, cvertices C.ULVertexBuffer, cindices C.ULIndexBuffer) {
|
|
if uLGPUDriverUpdateGeometryCallback3F20997Func != nil {
|
|
geometryId3f20997 := (uint32)(cgeometryId)
|
|
vertices3f20997 := *NewULVertexBufferRef(unsafe.Pointer(&cvertices))
|
|
indices3f20997 := *NewULIndexBufferRef(unsafe.Pointer(&cindices))
|
|
uLGPUDriverUpdateGeometryCallback3F20997Func(geometryId3f20997, vertices3f20997, indices3f20997)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverUpdateGeometryCallback3F20997Func ULGPUDriverUpdateGeometryCallback
|
|
|
|
func (x ULGPUDriverDestroyGeometryCallback) PassRef() (ref *C.ULGPUDriverDestroyGeometryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverDestroyGeometryCallbackCCE3A508Func == nil {
|
|
uLGPUDriverDestroyGeometryCallbackCCE3A508Func = x
|
|
}
|
|
return (*C.ULGPUDriverDestroyGeometryCallback)(C.ULGPUDriverDestroyGeometryCallback_cce3a508), nil
|
|
}
|
|
|
|
func (x ULGPUDriverDestroyGeometryCallback) PassValue() (ref C.ULGPUDriverDestroyGeometryCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverDestroyGeometryCallbackCCE3A508Func == nil {
|
|
uLGPUDriverDestroyGeometryCallbackCCE3A508Func = x
|
|
}
|
|
return (C.ULGPUDriverDestroyGeometryCallback)(C.ULGPUDriverDestroyGeometryCallback_cce3a508), nil
|
|
}
|
|
|
|
func NewULGPUDriverDestroyGeometryCallbackRef(ref unsafe.Pointer) *ULGPUDriverDestroyGeometryCallback {
|
|
return (*ULGPUDriverDestroyGeometryCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverDestroyGeometryCallbackCCE3A508
|
|
func uLGPUDriverDestroyGeometryCallbackCCE3A508(cgeometryId C.uint) {
|
|
if uLGPUDriverDestroyGeometryCallbackCCE3A508Func != nil {
|
|
geometryIdcce3a508 := (uint32)(cgeometryId)
|
|
uLGPUDriverDestroyGeometryCallbackCCE3A508Func(geometryIdcce3a508)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverDestroyGeometryCallbackCCE3A508Func ULGPUDriverDestroyGeometryCallback
|
|
|
|
func (x ULGPUDriverUpdateCommandListCallback) PassRef() (ref *C.ULGPUDriverUpdateCommandListCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverUpdateCommandListCallbackD3815A9EFunc == nil {
|
|
uLGPUDriverUpdateCommandListCallbackD3815A9EFunc = x
|
|
}
|
|
return (*C.ULGPUDriverUpdateCommandListCallback)(C.ULGPUDriverUpdateCommandListCallback_d3815a9e), nil
|
|
}
|
|
|
|
func (x ULGPUDriverUpdateCommandListCallback) PassValue() (ref C.ULGPUDriverUpdateCommandListCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLGPUDriverUpdateCommandListCallbackD3815A9EFunc == nil {
|
|
uLGPUDriverUpdateCommandListCallbackD3815A9EFunc = x
|
|
}
|
|
return (C.ULGPUDriverUpdateCommandListCallback)(C.ULGPUDriverUpdateCommandListCallback_d3815a9e), nil
|
|
}
|
|
|
|
func NewULGPUDriverUpdateCommandListCallbackRef(ref unsafe.Pointer) *ULGPUDriverUpdateCommandListCallback {
|
|
return (*ULGPUDriverUpdateCommandListCallback)(ref)
|
|
}
|
|
|
|
//export uLGPUDriverUpdateCommandListCallbackD3815A9E
|
|
func uLGPUDriverUpdateCommandListCallbackD3815A9E(clist C.ULCommandList) {
|
|
if uLGPUDriverUpdateCommandListCallbackD3815A9EFunc != nil {
|
|
listd3815a9e := *NewULCommandListRef(unsafe.Pointer(&clist))
|
|
uLGPUDriverUpdateCommandListCallbackD3815A9EFunc(listd3815a9e)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLGPUDriverUpdateCommandListCallbackD3815A9EFunc ULGPUDriverUpdateCommandListCallback
|
|
|
|
// allocULGPUDriverMemory allocates memory for type C.ULGPUDriver in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULGPUDriverMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULGPUDriverValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULGPUDriverValue = unsafe.Sizeof([1]C.ULGPUDriver{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULGPUDriver) Ref() *C.ULGPUDriver {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.refdfd8a4f0
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULGPUDriver) Free() {
|
|
if x != nil && x.allocsdfd8a4f0 != nil {
|
|
x.allocsdfd8a4f0.(*cgoAllocMap).Free()
|
|
x.refdfd8a4f0 = nil
|
|
}
|
|
}
|
|
|
|
// NewULGPUDriverRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULGPUDriverRef(ref unsafe.Pointer) *ULGPUDriver {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULGPUDriver)
|
|
obj.refdfd8a4f0 = (*C.ULGPUDriver)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULGPUDriver) PassRef() (*C.ULGPUDriver, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.refdfd8a4f0 != nil {
|
|
return x.refdfd8a4f0, nil
|
|
}
|
|
memdfd8a4f0 := allocULGPUDriverMemory(1)
|
|
refdfd8a4f0 := (*C.ULGPUDriver)(memdfd8a4f0)
|
|
allocsdfd8a4f0 := new(cgoAllocMap)
|
|
allocsdfd8a4f0.Add(memdfd8a4f0)
|
|
|
|
var cbegin_synchronize_allocs *cgoAllocMap
|
|
refdfd8a4f0.begin_synchronize, cbegin_synchronize_allocs = x.BeginSynchronize.PassValue()
|
|
allocsdfd8a4f0.Borrow(cbegin_synchronize_allocs)
|
|
|
|
var cend_synchronize_allocs *cgoAllocMap
|
|
refdfd8a4f0.end_synchronize, cend_synchronize_allocs = x.EndSynchronize.PassValue()
|
|
allocsdfd8a4f0.Borrow(cend_synchronize_allocs)
|
|
|
|
var cnext_texture_id_allocs *cgoAllocMap
|
|
refdfd8a4f0.next_texture_id, cnext_texture_id_allocs = x.NextTextureId.PassValue()
|
|
allocsdfd8a4f0.Borrow(cnext_texture_id_allocs)
|
|
|
|
var ccreate_texture_allocs *cgoAllocMap
|
|
refdfd8a4f0.create_texture, ccreate_texture_allocs = x.CreateTexture.PassValue()
|
|
allocsdfd8a4f0.Borrow(ccreate_texture_allocs)
|
|
|
|
var cupdate_texture_allocs *cgoAllocMap
|
|
refdfd8a4f0.update_texture, cupdate_texture_allocs = x.UpdateTexture.PassValue()
|
|
allocsdfd8a4f0.Borrow(cupdate_texture_allocs)
|
|
|
|
var cdestroy_texture_allocs *cgoAllocMap
|
|
refdfd8a4f0.destroy_texture, cdestroy_texture_allocs = x.DestroyTexture.PassValue()
|
|
allocsdfd8a4f0.Borrow(cdestroy_texture_allocs)
|
|
|
|
var cnext_render_buffer_id_allocs *cgoAllocMap
|
|
refdfd8a4f0.next_render_buffer_id, cnext_render_buffer_id_allocs = x.NextRenderBufferId.PassValue()
|
|
allocsdfd8a4f0.Borrow(cnext_render_buffer_id_allocs)
|
|
|
|
var ccreate_render_buffer_allocs *cgoAllocMap
|
|
refdfd8a4f0.create_render_buffer, ccreate_render_buffer_allocs = x.CreateRenderBuffer.PassValue()
|
|
allocsdfd8a4f0.Borrow(ccreate_render_buffer_allocs)
|
|
|
|
var cdestroy_render_buffer_allocs *cgoAllocMap
|
|
refdfd8a4f0.destroy_render_buffer, cdestroy_render_buffer_allocs = x.DestroyRenderBuffer.PassValue()
|
|
allocsdfd8a4f0.Borrow(cdestroy_render_buffer_allocs)
|
|
|
|
var cnext_geometry_id_allocs *cgoAllocMap
|
|
refdfd8a4f0.next_geometry_id, cnext_geometry_id_allocs = x.NextGeometryId.PassValue()
|
|
allocsdfd8a4f0.Borrow(cnext_geometry_id_allocs)
|
|
|
|
var ccreate_geometry_allocs *cgoAllocMap
|
|
refdfd8a4f0.create_geometry, ccreate_geometry_allocs = x.CreateGeometry.PassValue()
|
|
allocsdfd8a4f0.Borrow(ccreate_geometry_allocs)
|
|
|
|
var cupdate_geometry_allocs *cgoAllocMap
|
|
refdfd8a4f0.update_geometry, cupdate_geometry_allocs = x.UpdateGeometry.PassValue()
|
|
allocsdfd8a4f0.Borrow(cupdate_geometry_allocs)
|
|
|
|
var cdestroy_geometry_allocs *cgoAllocMap
|
|
refdfd8a4f0.destroy_geometry, cdestroy_geometry_allocs = x.DestroyGeometry.PassValue()
|
|
allocsdfd8a4f0.Borrow(cdestroy_geometry_allocs)
|
|
|
|
var cupdate_command_list_allocs *cgoAllocMap
|
|
refdfd8a4f0.update_command_list, cupdate_command_list_allocs = x.UpdateCommandList.PassValue()
|
|
allocsdfd8a4f0.Borrow(cupdate_command_list_allocs)
|
|
|
|
x.refdfd8a4f0 = refdfd8a4f0
|
|
x.allocsdfd8a4f0 = allocsdfd8a4f0
|
|
return refdfd8a4f0, allocsdfd8a4f0
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULGPUDriver) PassValue() (C.ULGPUDriver, *cgoAllocMap) {
|
|
if x.refdfd8a4f0 != nil {
|
|
return *x.refdfd8a4f0, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULGPUDriver) Deref() {
|
|
if x.refdfd8a4f0 == nil {
|
|
return
|
|
}
|
|
x.BeginSynchronize = *NewULGPUDriverBeginSynchronizeCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.begin_synchronize))
|
|
x.EndSynchronize = *NewULGPUDriverEndSynchronizeCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.end_synchronize))
|
|
x.NextTextureId = *NewULGPUDriverNextTextureIdCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.next_texture_id))
|
|
x.CreateTexture = *NewULGPUDriverCreateTextureCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.create_texture))
|
|
x.UpdateTexture = *NewULGPUDriverUpdateTextureCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.update_texture))
|
|
x.DestroyTexture = *NewULGPUDriverDestroyTextureCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.destroy_texture))
|
|
x.NextRenderBufferId = *NewULGPUDriverNextRenderBufferIdCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.next_render_buffer_id))
|
|
x.CreateRenderBuffer = *NewULGPUDriverCreateRenderBufferCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.create_render_buffer))
|
|
x.DestroyRenderBuffer = *NewULGPUDriverDestroyRenderBufferCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.destroy_render_buffer))
|
|
x.NextGeometryId = *NewULGPUDriverNextGeometryIdCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.next_geometry_id))
|
|
x.CreateGeometry = *NewULGPUDriverCreateGeometryCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.create_geometry))
|
|
x.UpdateGeometry = *NewULGPUDriverUpdateGeometryCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.update_geometry))
|
|
x.DestroyGeometry = *NewULGPUDriverDestroyGeometryCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.destroy_geometry))
|
|
x.UpdateCommandList = *NewULGPUDriverUpdateCommandListCallbackRef(unsafe.Pointer(&x.refdfd8a4f0.update_command_list))
|
|
}
|
|
|
|
func (x ULClipboardClearCallback) PassRef() (ref *C.ULClipboardClearCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLClipboardClearCallbackEDA3036AFunc == nil {
|
|
uLClipboardClearCallbackEDA3036AFunc = x
|
|
}
|
|
return (*C.ULClipboardClearCallback)(C.ULClipboardClearCallback_eda3036a), nil
|
|
}
|
|
|
|
func (x ULClipboardClearCallback) PassValue() (ref C.ULClipboardClearCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLClipboardClearCallbackEDA3036AFunc == nil {
|
|
uLClipboardClearCallbackEDA3036AFunc = x
|
|
}
|
|
return (C.ULClipboardClearCallback)(C.ULClipboardClearCallback_eda3036a), nil
|
|
}
|
|
|
|
func NewULClipboardClearCallbackRef(ref unsafe.Pointer) *ULClipboardClearCallback {
|
|
return (*ULClipboardClearCallback)(ref)
|
|
}
|
|
|
|
//export uLClipboardClearCallbackEDA3036A
|
|
func uLClipboardClearCallbackEDA3036A() {
|
|
if uLClipboardClearCallbackEDA3036AFunc != nil {
|
|
uLClipboardClearCallbackEDA3036AFunc()
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLClipboardClearCallbackEDA3036AFunc ULClipboardClearCallback
|
|
|
|
func (x ULClipboardReadPlainTextCallback) PassRef() (ref *C.ULClipboardReadPlainTextCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLClipboardReadPlainTextCallbackFEDFB2B6Func == nil {
|
|
uLClipboardReadPlainTextCallbackFEDFB2B6Func = x
|
|
}
|
|
return (*C.ULClipboardReadPlainTextCallback)(C.ULClipboardReadPlainTextCallback_fedfb2b6), nil
|
|
}
|
|
|
|
func (x ULClipboardReadPlainTextCallback) PassValue() (ref C.ULClipboardReadPlainTextCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLClipboardReadPlainTextCallbackFEDFB2B6Func == nil {
|
|
uLClipboardReadPlainTextCallbackFEDFB2B6Func = x
|
|
}
|
|
return (C.ULClipboardReadPlainTextCallback)(C.ULClipboardReadPlainTextCallback_fedfb2b6), nil
|
|
}
|
|
|
|
func NewULClipboardReadPlainTextCallbackRef(ref unsafe.Pointer) *ULClipboardReadPlainTextCallback {
|
|
return (*ULClipboardReadPlainTextCallback)(ref)
|
|
}
|
|
|
|
//export uLClipboardReadPlainTextCallbackFEDFB2B6
|
|
func uLClipboardReadPlainTextCallbackFEDFB2B6(cresult C.ULString) {
|
|
if uLClipboardReadPlainTextCallbackFEDFB2B6Func != nil {
|
|
resultfedfb2b6 := *(*ULString)(unsafe.Pointer(&cresult))
|
|
uLClipboardReadPlainTextCallbackFEDFB2B6Func(resultfedfb2b6)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLClipboardReadPlainTextCallbackFEDFB2B6Func ULClipboardReadPlainTextCallback
|
|
|
|
func (x ULClipboardWritePlainTextCallback) PassRef() (ref *C.ULClipboardWritePlainTextCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLClipboardWritePlainTextCallback6E8E0CA4Func == nil {
|
|
uLClipboardWritePlainTextCallback6E8E0CA4Func = x
|
|
}
|
|
return (*C.ULClipboardWritePlainTextCallback)(C.ULClipboardWritePlainTextCallback_6e8e0ca4), nil
|
|
}
|
|
|
|
func (x ULClipboardWritePlainTextCallback) PassValue() (ref C.ULClipboardWritePlainTextCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if uLClipboardWritePlainTextCallback6E8E0CA4Func == nil {
|
|
uLClipboardWritePlainTextCallback6E8E0CA4Func = x
|
|
}
|
|
return (C.ULClipboardWritePlainTextCallback)(C.ULClipboardWritePlainTextCallback_6e8e0ca4), nil
|
|
}
|
|
|
|
func NewULClipboardWritePlainTextCallbackRef(ref unsafe.Pointer) *ULClipboardWritePlainTextCallback {
|
|
return (*ULClipboardWritePlainTextCallback)(ref)
|
|
}
|
|
|
|
//export uLClipboardWritePlainTextCallback6E8E0CA4
|
|
func uLClipboardWritePlainTextCallback6E8E0CA4(ctext C.ULString) {
|
|
if uLClipboardWritePlainTextCallback6E8E0CA4Func != nil {
|
|
text6e8e0ca4 := *(*ULString)(unsafe.Pointer(&ctext))
|
|
uLClipboardWritePlainTextCallback6E8E0CA4Func(text6e8e0ca4)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var uLClipboardWritePlainTextCallback6E8E0CA4Func ULClipboardWritePlainTextCallback
|
|
|
|
// allocULClipboardMemory allocates memory for type C.ULClipboard in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULClipboardMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULClipboardValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULClipboardValue = unsafe.Sizeof([1]C.ULClipboard{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *ULClipboard) Ref() *C.ULClipboard {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.refdcb753f
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *ULClipboard) Free() {
|
|
if x != nil && x.allocsdcb753f != nil {
|
|
x.allocsdcb753f.(*cgoAllocMap).Free()
|
|
x.refdcb753f = nil
|
|
}
|
|
}
|
|
|
|
// NewULClipboardRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewULClipboardRef(ref unsafe.Pointer) *ULClipboard {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(ULClipboard)
|
|
obj.refdcb753f = (*C.ULClipboard)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *ULClipboard) PassRef() (*C.ULClipboard, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.refdcb753f != nil {
|
|
return x.refdcb753f, nil
|
|
}
|
|
memdcb753f := allocULClipboardMemory(1)
|
|
refdcb753f := (*C.ULClipboard)(memdcb753f)
|
|
allocsdcb753f := new(cgoAllocMap)
|
|
allocsdcb753f.Add(memdcb753f)
|
|
|
|
var cclear_allocs *cgoAllocMap
|
|
refdcb753f.clear, cclear_allocs = x.Clear.PassValue()
|
|
allocsdcb753f.Borrow(cclear_allocs)
|
|
|
|
var cread_plain_text_allocs *cgoAllocMap
|
|
refdcb753f.read_plain_text, cread_plain_text_allocs = x.ReadPlainText.PassValue()
|
|
allocsdcb753f.Borrow(cread_plain_text_allocs)
|
|
|
|
var cwrite_plain_text_allocs *cgoAllocMap
|
|
refdcb753f.write_plain_text, cwrite_plain_text_allocs = x.WritePlainText.PassValue()
|
|
allocsdcb753f.Borrow(cwrite_plain_text_allocs)
|
|
|
|
x.refdcb753f = refdcb753f
|
|
x.allocsdcb753f = allocsdcb753f
|
|
return refdcb753f, allocsdcb753f
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x ULClipboard) PassValue() (C.ULClipboard, *cgoAllocMap) {
|
|
if x.refdcb753f != nil {
|
|
return *x.refdcb753f, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *ULClipboard) Deref() {
|
|
if x.refdcb753f == nil {
|
|
return
|
|
}
|
|
x.Clear = *NewULClipboardClearCallbackRef(unsafe.Pointer(&x.refdcb753f.clear))
|
|
x.ReadPlainText = *NewULClipboardReadPlainTextCallbackRef(unsafe.Pointer(&x.refdcb753f.read_plain_text))
|
|
x.WritePlainText = *NewULClipboardWritePlainTextCallbackRef(unsafe.Pointer(&x.refdcb753f.write_plain_text))
|
|
}
|
|
|
|
func (x JSTypedArrayBytesDeallocator) PassRef() (ref *C.JSTypedArrayBytesDeallocator, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSTypedArrayBytesDeallocator68D51F83Func == nil {
|
|
jSTypedArrayBytesDeallocator68D51F83Func = x
|
|
}
|
|
return (*C.JSTypedArrayBytesDeallocator)(C.JSTypedArrayBytesDeallocator_68d51f83), nil
|
|
}
|
|
|
|
func (x JSTypedArrayBytesDeallocator) PassValue() (ref C.JSTypedArrayBytesDeallocator, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSTypedArrayBytesDeallocator68D51F83Func == nil {
|
|
jSTypedArrayBytesDeallocator68D51F83Func = x
|
|
}
|
|
return (C.JSTypedArrayBytesDeallocator)(C.JSTypedArrayBytesDeallocator_68d51f83), nil
|
|
}
|
|
|
|
func NewJSTypedArrayBytesDeallocatorRef(ref unsafe.Pointer) *JSTypedArrayBytesDeallocator {
|
|
return (*JSTypedArrayBytesDeallocator)(ref)
|
|
}
|
|
|
|
//export jSTypedArrayBytesDeallocator68D51F83
|
|
func jSTypedArrayBytesDeallocator68D51F83(cbytes unsafe.Pointer, cdeallocatorContext unsafe.Pointer) {
|
|
if jSTypedArrayBytesDeallocator68D51F83Func != nil {
|
|
bytes68d51f83 := (unsafe.Pointer)(unsafe.Pointer(cbytes))
|
|
deallocatorContext68d51f83 := (unsafe.Pointer)(unsafe.Pointer(cdeallocatorContext))
|
|
jSTypedArrayBytesDeallocator68D51F83Func(bytes68d51f83, deallocatorContext68d51f83)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSTypedArrayBytesDeallocator68D51F83Func JSTypedArrayBytesDeallocator
|
|
|
|
func (x JSObjectInitializeCallback) PassRef() (ref *C.JSObjectInitializeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectInitializeCallback5793B16Func == nil {
|
|
jSObjectInitializeCallback5793B16Func = x
|
|
}
|
|
return (*C.JSObjectInitializeCallback)(C.JSObjectInitializeCallback_5793b16), nil
|
|
}
|
|
|
|
func (x JSObjectInitializeCallback) PassValue() (ref C.JSObjectInitializeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectInitializeCallback5793B16Func == nil {
|
|
jSObjectInitializeCallback5793B16Func = x
|
|
}
|
|
return (C.JSObjectInitializeCallback)(C.JSObjectInitializeCallback_5793b16), nil
|
|
}
|
|
|
|
func NewJSObjectInitializeCallbackRef(ref unsafe.Pointer) *JSObjectInitializeCallback {
|
|
return (*JSObjectInitializeCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectInitializeCallback5793B16
|
|
func jSObjectInitializeCallback5793B16(cctx C.JSContextRef, cobject C.JSObjectRef) {
|
|
if jSObjectInitializeCallback5793B16Func != nil {
|
|
ctx5793b16 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
object5793b16 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
jSObjectInitializeCallback5793B16Func(ctx5793b16, object5793b16)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectInitializeCallback5793B16Func JSObjectInitializeCallback
|
|
|
|
func (x JSObjectInitializeCallbackEx) PassRef() (ref *C.JSObjectInitializeCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectInitializeCallbackEx3F9A093BFunc == nil {
|
|
jSObjectInitializeCallbackEx3F9A093BFunc = x
|
|
}
|
|
return (*C.JSObjectInitializeCallbackEx)(C.JSObjectInitializeCallbackEx_3f9a093b), nil
|
|
}
|
|
|
|
func (x JSObjectInitializeCallbackEx) PassValue() (ref C.JSObjectInitializeCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectInitializeCallbackEx3F9A093BFunc == nil {
|
|
jSObjectInitializeCallbackEx3F9A093BFunc = x
|
|
}
|
|
return (C.JSObjectInitializeCallbackEx)(C.JSObjectInitializeCallbackEx_3f9a093b), nil
|
|
}
|
|
|
|
func NewJSObjectInitializeCallbackExRef(ref unsafe.Pointer) *JSObjectInitializeCallbackEx {
|
|
return (*JSObjectInitializeCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectInitializeCallbackEx3F9A093B
|
|
func jSObjectInitializeCallbackEx3F9A093B(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef) {
|
|
if jSObjectInitializeCallbackEx3F9A093BFunc != nil {
|
|
ctx3f9a093b := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClass3f9a093b := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
object3f9a093b := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
jSObjectInitializeCallbackEx3F9A093BFunc(ctx3f9a093b, jsClass3f9a093b, object3f9a093b)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectInitializeCallbackEx3F9A093BFunc JSObjectInitializeCallbackEx
|
|
|
|
func (x JSObjectFinalizeCallback) PassRef() (ref *C.JSObjectFinalizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectFinalizeCallback93DA0AEAFunc == nil {
|
|
jSObjectFinalizeCallback93DA0AEAFunc = x
|
|
}
|
|
return (*C.JSObjectFinalizeCallback)(C.JSObjectFinalizeCallback_93da0aea), nil
|
|
}
|
|
|
|
func (x JSObjectFinalizeCallback) PassValue() (ref C.JSObjectFinalizeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectFinalizeCallback93DA0AEAFunc == nil {
|
|
jSObjectFinalizeCallback93DA0AEAFunc = x
|
|
}
|
|
return (C.JSObjectFinalizeCallback)(C.JSObjectFinalizeCallback_93da0aea), nil
|
|
}
|
|
|
|
func NewJSObjectFinalizeCallbackRef(ref unsafe.Pointer) *JSObjectFinalizeCallback {
|
|
return (*JSObjectFinalizeCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectFinalizeCallback93DA0AEA
|
|
func jSObjectFinalizeCallback93DA0AEA(cobject C.JSObjectRef) {
|
|
if jSObjectFinalizeCallback93DA0AEAFunc != nil {
|
|
object93da0aea := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
jSObjectFinalizeCallback93DA0AEAFunc(object93da0aea)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectFinalizeCallback93DA0AEAFunc JSObjectFinalizeCallback
|
|
|
|
func (x JSObjectFinalizeCallbackEx) PassRef() (ref *C.JSObjectFinalizeCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectFinalizeCallbackExD64D3113Func == nil {
|
|
jSObjectFinalizeCallbackExD64D3113Func = x
|
|
}
|
|
return (*C.JSObjectFinalizeCallbackEx)(C.JSObjectFinalizeCallbackEx_d64d3113), nil
|
|
}
|
|
|
|
func (x JSObjectFinalizeCallbackEx) PassValue() (ref C.JSObjectFinalizeCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectFinalizeCallbackExD64D3113Func == nil {
|
|
jSObjectFinalizeCallbackExD64D3113Func = x
|
|
}
|
|
return (C.JSObjectFinalizeCallbackEx)(C.JSObjectFinalizeCallbackEx_d64d3113), nil
|
|
}
|
|
|
|
func NewJSObjectFinalizeCallbackExRef(ref unsafe.Pointer) *JSObjectFinalizeCallbackEx {
|
|
return (*JSObjectFinalizeCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectFinalizeCallbackExD64D3113
|
|
func jSObjectFinalizeCallbackExD64D3113(cjsClass C.JSClassRef, cobject C.JSObjectRef) {
|
|
if jSObjectFinalizeCallbackExD64D3113Func != nil {
|
|
jsClassd64d3113 := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
objectd64d3113 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
jSObjectFinalizeCallbackExD64D3113Func(jsClassd64d3113, objectd64d3113)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectFinalizeCallbackExD64D3113Func JSObjectFinalizeCallbackEx
|
|
|
|
func (x JSObjectHasPropertyCallback) PassRef() (ref *C.JSObjectHasPropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasPropertyCallback340BFA95Func == nil {
|
|
jSObjectHasPropertyCallback340BFA95Func = x
|
|
}
|
|
return (*C.JSObjectHasPropertyCallback)(C.JSObjectHasPropertyCallback_340bfa95), nil
|
|
}
|
|
|
|
func (x JSObjectHasPropertyCallback) PassValue() (ref C.JSObjectHasPropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasPropertyCallback340BFA95Func == nil {
|
|
jSObjectHasPropertyCallback340BFA95Func = x
|
|
}
|
|
return (C.JSObjectHasPropertyCallback)(C.JSObjectHasPropertyCallback_340bfa95), nil
|
|
}
|
|
|
|
func NewJSObjectHasPropertyCallbackRef(ref unsafe.Pointer) *JSObjectHasPropertyCallback {
|
|
return (*JSObjectHasPropertyCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectHasPropertyCallback340BFA95
|
|
func jSObjectHasPropertyCallback340BFA95(cctx C.JSContextRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef) C._Bool {
|
|
if jSObjectHasPropertyCallback340BFA95Func != nil {
|
|
ctx340bfa95 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
object340bfa95 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyName340bfa95 := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
ret340bfa95 := jSObjectHasPropertyCallback340BFA95Func(ctx340bfa95, object340bfa95, propertyName340bfa95)
|
|
ret, _ := (C._Bool)(ret340bfa95), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectHasPropertyCallback340BFA95Func JSObjectHasPropertyCallback
|
|
|
|
func (x JSObjectHasPropertyCallbackEx) PassRef() (ref *C.JSObjectHasPropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasPropertyCallbackExC35701E7Func == nil {
|
|
jSObjectHasPropertyCallbackExC35701E7Func = x
|
|
}
|
|
return (*C.JSObjectHasPropertyCallbackEx)(C.JSObjectHasPropertyCallbackEx_c35701e7), nil
|
|
}
|
|
|
|
func (x JSObjectHasPropertyCallbackEx) PassValue() (ref C.JSObjectHasPropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasPropertyCallbackExC35701E7Func == nil {
|
|
jSObjectHasPropertyCallbackExC35701E7Func = x
|
|
}
|
|
return (C.JSObjectHasPropertyCallbackEx)(C.JSObjectHasPropertyCallbackEx_c35701e7), nil
|
|
}
|
|
|
|
func NewJSObjectHasPropertyCallbackExRef(ref unsafe.Pointer) *JSObjectHasPropertyCallbackEx {
|
|
return (*JSObjectHasPropertyCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectHasPropertyCallbackExC35701E7
|
|
func jSObjectHasPropertyCallbackExC35701E7(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef) C._Bool {
|
|
if jSObjectHasPropertyCallbackExC35701E7Func != nil {
|
|
ctxc35701e7 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClassc35701e7 := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
objectc35701e7 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNamec35701e7 := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
retc35701e7 := jSObjectHasPropertyCallbackExC35701E7Func(ctxc35701e7, jsClassc35701e7, objectc35701e7, propertyNamec35701e7)
|
|
ret, _ := (C._Bool)(retc35701e7), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectHasPropertyCallbackExC35701E7Func JSObjectHasPropertyCallbackEx
|
|
|
|
func (x JSObjectGetPropertyCallback) PassRef() (ref *C.JSObjectGetPropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyCallback5CAEC716Func == nil {
|
|
jSObjectGetPropertyCallback5CAEC716Func = x
|
|
}
|
|
return (*C.JSObjectGetPropertyCallback)(C.JSObjectGetPropertyCallback_5caec716), nil
|
|
}
|
|
|
|
func (x JSObjectGetPropertyCallback) PassValue() (ref C.JSObjectGetPropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyCallback5CAEC716Func == nil {
|
|
jSObjectGetPropertyCallback5CAEC716Func = x
|
|
}
|
|
return (C.JSObjectGetPropertyCallback)(C.JSObjectGetPropertyCallback_5caec716), nil
|
|
}
|
|
|
|
func NewJSObjectGetPropertyCallbackRef(ref unsafe.Pointer) *JSObjectGetPropertyCallback {
|
|
return (*JSObjectGetPropertyCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectGetPropertyCallback5CAEC716
|
|
func jSObjectGetPropertyCallback5CAEC716(cctx C.JSContextRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef, cexception *C.JSValueRef) C.JSValueRef {
|
|
if jSObjectGetPropertyCallback5CAEC716Func != nil {
|
|
ctx5caec716 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
object5caec716 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyName5caec716 := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
var exception5caec716 []JSValueRef
|
|
hxfa9955c := (*sliceHeader)(unsafe.Pointer(&exception5caec716))
|
|
hxfa9955c.Data = unsafe.Pointer(cexception)
|
|
hxfa9955c.Cap = 0x7fffffff
|
|
// hxfa9955c.Len = ?
|
|
|
|
ret5caec716 := jSObjectGetPropertyCallback5CAEC716Func(ctx5caec716, object5caec716, propertyName5caec716, exception5caec716)
|
|
ret, _ := *(*C.JSValueRef)(unsafe.Pointer(&ret5caec716)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectGetPropertyCallback5CAEC716Func JSObjectGetPropertyCallback
|
|
|
|
func (x JSObjectGetPropertyCallbackEx) PassRef() (ref *C.JSObjectGetPropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyCallbackEx8B91EEDBFunc == nil {
|
|
jSObjectGetPropertyCallbackEx8B91EEDBFunc = x
|
|
}
|
|
return (*C.JSObjectGetPropertyCallbackEx)(C.JSObjectGetPropertyCallbackEx_8b91eedb), nil
|
|
}
|
|
|
|
func (x JSObjectGetPropertyCallbackEx) PassValue() (ref C.JSObjectGetPropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyCallbackEx8B91EEDBFunc == nil {
|
|
jSObjectGetPropertyCallbackEx8B91EEDBFunc = x
|
|
}
|
|
return (C.JSObjectGetPropertyCallbackEx)(C.JSObjectGetPropertyCallbackEx_8b91eedb), nil
|
|
}
|
|
|
|
func NewJSObjectGetPropertyCallbackExRef(ref unsafe.Pointer) *JSObjectGetPropertyCallbackEx {
|
|
return (*JSObjectGetPropertyCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectGetPropertyCallbackEx8B91EEDB
|
|
func jSObjectGetPropertyCallbackEx8B91EEDB(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef, cexception *C.JSValueRef) C.JSValueRef {
|
|
if jSObjectGetPropertyCallbackEx8B91EEDBFunc != nil {
|
|
ctx8b91eedb := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClass8b91eedb := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
object8b91eedb := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyName8b91eedb := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
var exception8b91eedb []JSValueRef
|
|
hxfa3f05c := (*sliceHeader)(unsafe.Pointer(&exception8b91eedb))
|
|
hxfa3f05c.Data = unsafe.Pointer(cexception)
|
|
hxfa3f05c.Cap = 0x7fffffff
|
|
// hxfa3f05c.Len = ?
|
|
|
|
ret8b91eedb := jSObjectGetPropertyCallbackEx8B91EEDBFunc(ctx8b91eedb, jsClass8b91eedb, object8b91eedb, propertyName8b91eedb, exception8b91eedb)
|
|
ret, _ := *(*C.JSValueRef)(unsafe.Pointer(&ret8b91eedb)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectGetPropertyCallbackEx8B91EEDBFunc JSObjectGetPropertyCallbackEx
|
|
|
|
func (x JSObjectSetPropertyCallback) PassRef() (ref *C.JSObjectSetPropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectSetPropertyCallbackA684F1FEFunc == nil {
|
|
jSObjectSetPropertyCallbackA684F1FEFunc = x
|
|
}
|
|
return (*C.JSObjectSetPropertyCallback)(C.JSObjectSetPropertyCallback_a684f1fe), nil
|
|
}
|
|
|
|
func (x JSObjectSetPropertyCallback) PassValue() (ref C.JSObjectSetPropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectSetPropertyCallbackA684F1FEFunc == nil {
|
|
jSObjectSetPropertyCallbackA684F1FEFunc = x
|
|
}
|
|
return (C.JSObjectSetPropertyCallback)(C.JSObjectSetPropertyCallback_a684f1fe), nil
|
|
}
|
|
|
|
func NewJSObjectSetPropertyCallbackRef(ref unsafe.Pointer) *JSObjectSetPropertyCallback {
|
|
return (*JSObjectSetPropertyCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectSetPropertyCallbackA684F1FE
|
|
func jSObjectSetPropertyCallbackA684F1FE(cctx C.JSContextRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef, cvalue C.JSValueRef, cexception *C.JSValueRef) C._Bool {
|
|
if jSObjectSetPropertyCallbackA684F1FEFunc != nil {
|
|
ctxa684f1fe := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
objecta684f1fe := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNamea684f1fe := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
valuea684f1fe := *(*JSValueRef)(unsafe.Pointer(&cvalue))
|
|
var exceptiona684f1fe []JSValueRef
|
|
hxf0d18b7 := (*sliceHeader)(unsafe.Pointer(&exceptiona684f1fe))
|
|
hxf0d18b7.Data = unsafe.Pointer(cexception)
|
|
hxf0d18b7.Cap = 0x7fffffff
|
|
// hxf0d18b7.Len = ?
|
|
|
|
reta684f1fe := jSObjectSetPropertyCallbackA684F1FEFunc(ctxa684f1fe, objecta684f1fe, propertyNamea684f1fe, valuea684f1fe, exceptiona684f1fe)
|
|
ret, _ := (C._Bool)(reta684f1fe), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectSetPropertyCallbackA684F1FEFunc JSObjectSetPropertyCallback
|
|
|
|
func (x JSObjectSetPropertyCallbackEx) PassRef() (ref *C.JSObjectSetPropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectSetPropertyCallbackExD28CF88CFunc == nil {
|
|
jSObjectSetPropertyCallbackExD28CF88CFunc = x
|
|
}
|
|
return (*C.JSObjectSetPropertyCallbackEx)(C.JSObjectSetPropertyCallbackEx_d28cf88c), nil
|
|
}
|
|
|
|
func (x JSObjectSetPropertyCallbackEx) PassValue() (ref C.JSObjectSetPropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectSetPropertyCallbackExD28CF88CFunc == nil {
|
|
jSObjectSetPropertyCallbackExD28CF88CFunc = x
|
|
}
|
|
return (C.JSObjectSetPropertyCallbackEx)(C.JSObjectSetPropertyCallbackEx_d28cf88c), nil
|
|
}
|
|
|
|
func NewJSObjectSetPropertyCallbackExRef(ref unsafe.Pointer) *JSObjectSetPropertyCallbackEx {
|
|
return (*JSObjectSetPropertyCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectSetPropertyCallbackExD28CF88C
|
|
func jSObjectSetPropertyCallbackExD28CF88C(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef, cvalue C.JSValueRef, cexception *C.JSValueRef) C._Bool {
|
|
if jSObjectSetPropertyCallbackExD28CF88CFunc != nil {
|
|
ctxd28cf88c := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClassd28cf88c := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
objectd28cf88c := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNamed28cf88c := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
valued28cf88c := *(*JSValueRef)(unsafe.Pointer(&cvalue))
|
|
var exceptiond28cf88c []JSValueRef
|
|
hxf2fab0d := (*sliceHeader)(unsafe.Pointer(&exceptiond28cf88c))
|
|
hxf2fab0d.Data = unsafe.Pointer(cexception)
|
|
hxf2fab0d.Cap = 0x7fffffff
|
|
// hxf2fab0d.Len = ?
|
|
|
|
retd28cf88c := jSObjectSetPropertyCallbackExD28CF88CFunc(ctxd28cf88c, jsClassd28cf88c, objectd28cf88c, propertyNamed28cf88c, valued28cf88c, exceptiond28cf88c)
|
|
ret, _ := (C._Bool)(retd28cf88c), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectSetPropertyCallbackExD28CF88CFunc JSObjectSetPropertyCallbackEx
|
|
|
|
func (x JSObjectDeletePropertyCallback) PassRef() (ref *C.JSObjectDeletePropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectDeletePropertyCallbackB0108EBEFunc == nil {
|
|
jSObjectDeletePropertyCallbackB0108EBEFunc = x
|
|
}
|
|
return (*C.JSObjectDeletePropertyCallback)(C.JSObjectDeletePropertyCallback_b0108ebe), nil
|
|
}
|
|
|
|
func (x JSObjectDeletePropertyCallback) PassValue() (ref C.JSObjectDeletePropertyCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectDeletePropertyCallbackB0108EBEFunc == nil {
|
|
jSObjectDeletePropertyCallbackB0108EBEFunc = x
|
|
}
|
|
return (C.JSObjectDeletePropertyCallback)(C.JSObjectDeletePropertyCallback_b0108ebe), nil
|
|
}
|
|
|
|
func NewJSObjectDeletePropertyCallbackRef(ref unsafe.Pointer) *JSObjectDeletePropertyCallback {
|
|
return (*JSObjectDeletePropertyCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectDeletePropertyCallbackB0108EBE
|
|
func jSObjectDeletePropertyCallbackB0108EBE(cctx C.JSContextRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef, cexception *C.JSValueRef) C._Bool {
|
|
if jSObjectDeletePropertyCallbackB0108EBEFunc != nil {
|
|
ctxb0108ebe := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
objectb0108ebe := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNameb0108ebe := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
var exceptionb0108ebe []JSValueRef
|
|
hxf69fe70 := (*sliceHeader)(unsafe.Pointer(&exceptionb0108ebe))
|
|
hxf69fe70.Data = unsafe.Pointer(cexception)
|
|
hxf69fe70.Cap = 0x7fffffff
|
|
// hxf69fe70.Len = ?
|
|
|
|
retb0108ebe := jSObjectDeletePropertyCallbackB0108EBEFunc(ctxb0108ebe, objectb0108ebe, propertyNameb0108ebe, exceptionb0108ebe)
|
|
ret, _ := (C._Bool)(retb0108ebe), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectDeletePropertyCallbackB0108EBEFunc JSObjectDeletePropertyCallback
|
|
|
|
func (x JSObjectDeletePropertyCallbackEx) PassRef() (ref *C.JSObjectDeletePropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectDeletePropertyCallbackExE24FCDB0Func == nil {
|
|
jSObjectDeletePropertyCallbackExE24FCDB0Func = x
|
|
}
|
|
return (*C.JSObjectDeletePropertyCallbackEx)(C.JSObjectDeletePropertyCallbackEx_e24fcdb0), nil
|
|
}
|
|
|
|
func (x JSObjectDeletePropertyCallbackEx) PassValue() (ref C.JSObjectDeletePropertyCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectDeletePropertyCallbackExE24FCDB0Func == nil {
|
|
jSObjectDeletePropertyCallbackExE24FCDB0Func = x
|
|
}
|
|
return (C.JSObjectDeletePropertyCallbackEx)(C.JSObjectDeletePropertyCallbackEx_e24fcdb0), nil
|
|
}
|
|
|
|
func NewJSObjectDeletePropertyCallbackExRef(ref unsafe.Pointer) *JSObjectDeletePropertyCallbackEx {
|
|
return (*JSObjectDeletePropertyCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectDeletePropertyCallbackExE24FCDB0
|
|
func jSObjectDeletePropertyCallbackExE24FCDB0(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef, cpropertyName C.JSStringRef, cexception *C.JSValueRef) C._Bool {
|
|
if jSObjectDeletePropertyCallbackExE24FCDB0Func != nil {
|
|
ctxe24fcdb0 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClasse24fcdb0 := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
objecte24fcdb0 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNamee24fcdb0 := *(*JSStringRef)(unsafe.Pointer(&cpropertyName))
|
|
var exceptione24fcdb0 []JSValueRef
|
|
hxf65bf54 := (*sliceHeader)(unsafe.Pointer(&exceptione24fcdb0))
|
|
hxf65bf54.Data = unsafe.Pointer(cexception)
|
|
hxf65bf54.Cap = 0x7fffffff
|
|
// hxf65bf54.Len = ?
|
|
|
|
rete24fcdb0 := jSObjectDeletePropertyCallbackExE24FCDB0Func(ctxe24fcdb0, jsClasse24fcdb0, objecte24fcdb0, propertyNamee24fcdb0, exceptione24fcdb0)
|
|
ret, _ := (C._Bool)(rete24fcdb0), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectDeletePropertyCallbackExE24FCDB0Func JSObjectDeletePropertyCallbackEx
|
|
|
|
func (x JSObjectGetPropertyNamesCallback) PassRef() (ref *C.JSObjectGetPropertyNamesCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyNamesCallbackE77D2329Func == nil {
|
|
jSObjectGetPropertyNamesCallbackE77D2329Func = x
|
|
}
|
|
return (*C.JSObjectGetPropertyNamesCallback)(C.JSObjectGetPropertyNamesCallback_e77d2329), nil
|
|
}
|
|
|
|
func (x JSObjectGetPropertyNamesCallback) PassValue() (ref C.JSObjectGetPropertyNamesCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyNamesCallbackE77D2329Func == nil {
|
|
jSObjectGetPropertyNamesCallbackE77D2329Func = x
|
|
}
|
|
return (C.JSObjectGetPropertyNamesCallback)(C.JSObjectGetPropertyNamesCallback_e77d2329), nil
|
|
}
|
|
|
|
func NewJSObjectGetPropertyNamesCallbackRef(ref unsafe.Pointer) *JSObjectGetPropertyNamesCallback {
|
|
return (*JSObjectGetPropertyNamesCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectGetPropertyNamesCallbackE77D2329
|
|
func jSObjectGetPropertyNamesCallbackE77D2329(cctx C.JSContextRef, cobject C.JSObjectRef, cpropertyNames C.JSPropertyNameAccumulatorRef) {
|
|
if jSObjectGetPropertyNamesCallbackE77D2329Func != nil {
|
|
ctxe77d2329 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
objecte77d2329 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNamese77d2329 := *(*JSPropertyNameAccumulatorRef)(unsafe.Pointer(&cpropertyNames))
|
|
jSObjectGetPropertyNamesCallbackE77D2329Func(ctxe77d2329, objecte77d2329, propertyNamese77d2329)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectGetPropertyNamesCallbackE77D2329Func JSObjectGetPropertyNamesCallback
|
|
|
|
func (x JSObjectGetPropertyNamesCallbackEx) PassRef() (ref *C.JSObjectGetPropertyNamesCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyNamesCallbackEx74285955Func == nil {
|
|
jSObjectGetPropertyNamesCallbackEx74285955Func = x
|
|
}
|
|
return (*C.JSObjectGetPropertyNamesCallbackEx)(C.JSObjectGetPropertyNamesCallbackEx_74285955), nil
|
|
}
|
|
|
|
func (x JSObjectGetPropertyNamesCallbackEx) PassValue() (ref C.JSObjectGetPropertyNamesCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectGetPropertyNamesCallbackEx74285955Func == nil {
|
|
jSObjectGetPropertyNamesCallbackEx74285955Func = x
|
|
}
|
|
return (C.JSObjectGetPropertyNamesCallbackEx)(C.JSObjectGetPropertyNamesCallbackEx_74285955), nil
|
|
}
|
|
|
|
func NewJSObjectGetPropertyNamesCallbackExRef(ref unsafe.Pointer) *JSObjectGetPropertyNamesCallbackEx {
|
|
return (*JSObjectGetPropertyNamesCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectGetPropertyNamesCallbackEx74285955
|
|
func jSObjectGetPropertyNamesCallbackEx74285955(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef, cpropertyNames C.JSPropertyNameAccumulatorRef) {
|
|
if jSObjectGetPropertyNamesCallbackEx74285955Func != nil {
|
|
ctx74285955 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClass74285955 := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
object74285955 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
propertyNames74285955 := *(*JSPropertyNameAccumulatorRef)(unsafe.Pointer(&cpropertyNames))
|
|
jSObjectGetPropertyNamesCallbackEx74285955Func(ctx74285955, jsClass74285955, object74285955, propertyNames74285955)
|
|
return
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectGetPropertyNamesCallbackEx74285955Func JSObjectGetPropertyNamesCallbackEx
|
|
|
|
func (x JSObjectCallAsFunctionCallback) PassRef() (ref *C.JSObjectCallAsFunctionCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsFunctionCallback89F9469BFunc == nil {
|
|
jSObjectCallAsFunctionCallback89F9469BFunc = x
|
|
}
|
|
return (*C.JSObjectCallAsFunctionCallback)(C.JSObjectCallAsFunctionCallback_89f9469b), nil
|
|
}
|
|
|
|
func (x JSObjectCallAsFunctionCallback) PassValue() (ref C.JSObjectCallAsFunctionCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsFunctionCallback89F9469BFunc == nil {
|
|
jSObjectCallAsFunctionCallback89F9469BFunc = x
|
|
}
|
|
return (C.JSObjectCallAsFunctionCallback)(C.JSObjectCallAsFunctionCallback_89f9469b), nil
|
|
}
|
|
|
|
func NewJSObjectCallAsFunctionCallbackRef(ref unsafe.Pointer) *JSObjectCallAsFunctionCallback {
|
|
return (*JSObjectCallAsFunctionCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectCallAsFunctionCallback89F9469B
|
|
func jSObjectCallAsFunctionCallback89F9469B(cctx C.JSContextRef, cfunction C.JSObjectRef, cthisObject C.JSObjectRef, cargumentCount C.size_t, carguments *C.JSValueRef, cexception *C.JSValueRef) C.JSValueRef {
|
|
if jSObjectCallAsFunctionCallback89F9469BFunc != nil {
|
|
ctx89f9469b := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
function89f9469b := *(*JSObjectRef)(unsafe.Pointer(&cfunction))
|
|
thisObject89f9469b := *(*JSObjectRef)(unsafe.Pointer(&cthisObject))
|
|
argumentCount89f9469b := (uint32)(cargumentCount)
|
|
var arguments89f9469b []JSValueRef
|
|
hxf3b8dbd := (*sliceHeader)(unsafe.Pointer(&arguments89f9469b))
|
|
hxf3b8dbd.Data = unsafe.Pointer(carguments)
|
|
hxf3b8dbd.Cap = 0x7fffffff
|
|
// hxf3b8dbd.Len = ?
|
|
|
|
var exception89f9469b []JSValueRef
|
|
hxf7a6dff := (*sliceHeader)(unsafe.Pointer(&exception89f9469b))
|
|
hxf7a6dff.Data = unsafe.Pointer(cexception)
|
|
hxf7a6dff.Cap = 0x7fffffff
|
|
// hxf7a6dff.Len = ?
|
|
|
|
ret89f9469b := jSObjectCallAsFunctionCallback89F9469BFunc(ctx89f9469b, function89f9469b, thisObject89f9469b, argumentCount89f9469b, arguments89f9469b, exception89f9469b)
|
|
ret, _ := *(*C.JSValueRef)(unsafe.Pointer(&ret89f9469b)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectCallAsFunctionCallback89F9469BFunc JSObjectCallAsFunctionCallback
|
|
|
|
func (x JSObjectCallAsFunctionCallbackEx) PassRef() (ref *C.JSObjectCallAsFunctionCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsFunctionCallbackEx9F036E3CFunc == nil {
|
|
jSObjectCallAsFunctionCallbackEx9F036E3CFunc = x
|
|
}
|
|
return (*C.JSObjectCallAsFunctionCallbackEx)(C.JSObjectCallAsFunctionCallbackEx_9f036e3c), nil
|
|
}
|
|
|
|
func (x JSObjectCallAsFunctionCallbackEx) PassValue() (ref C.JSObjectCallAsFunctionCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsFunctionCallbackEx9F036E3CFunc == nil {
|
|
jSObjectCallAsFunctionCallbackEx9F036E3CFunc = x
|
|
}
|
|
return (C.JSObjectCallAsFunctionCallbackEx)(C.JSObjectCallAsFunctionCallbackEx_9f036e3c), nil
|
|
}
|
|
|
|
func NewJSObjectCallAsFunctionCallbackExRef(ref unsafe.Pointer) *JSObjectCallAsFunctionCallbackEx {
|
|
return (*JSObjectCallAsFunctionCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectCallAsFunctionCallbackEx9F036E3C
|
|
func jSObjectCallAsFunctionCallbackEx9F036E3C(cctx C.JSContextRef, cjsClass C.JSClassRef, cclassName C.JSStringRef, cfunction C.JSObjectRef, cthisObject C.JSObjectRef, cargumentCount C.size_t, carguments *C.JSValueRef, cexception *C.JSValueRef) C.JSValueRef {
|
|
if jSObjectCallAsFunctionCallbackEx9F036E3CFunc != nil {
|
|
ctx9f036e3c := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClass9f036e3c := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
className9f036e3c := *(*JSStringRef)(unsafe.Pointer(&cclassName))
|
|
function9f036e3c := *(*JSObjectRef)(unsafe.Pointer(&cfunction))
|
|
thisObject9f036e3c := *(*JSObjectRef)(unsafe.Pointer(&cthisObject))
|
|
argumentCount9f036e3c := (uint32)(cargumentCount)
|
|
var arguments9f036e3c []JSValueRef
|
|
hxfe48d67 := (*sliceHeader)(unsafe.Pointer(&arguments9f036e3c))
|
|
hxfe48d67.Data = unsafe.Pointer(carguments)
|
|
hxfe48d67.Cap = 0x7fffffff
|
|
// hxfe48d67.Len = ?
|
|
|
|
var exception9f036e3c []JSValueRef
|
|
hxf4171bf := (*sliceHeader)(unsafe.Pointer(&exception9f036e3c))
|
|
hxf4171bf.Data = unsafe.Pointer(cexception)
|
|
hxf4171bf.Cap = 0x7fffffff
|
|
// hxf4171bf.Len = ?
|
|
|
|
ret9f036e3c := jSObjectCallAsFunctionCallbackEx9F036E3CFunc(ctx9f036e3c, jsClass9f036e3c, className9f036e3c, function9f036e3c, thisObject9f036e3c, argumentCount9f036e3c, arguments9f036e3c, exception9f036e3c)
|
|
ret, _ := *(*C.JSValueRef)(unsafe.Pointer(&ret9f036e3c)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectCallAsFunctionCallbackEx9F036E3CFunc JSObjectCallAsFunctionCallbackEx
|
|
|
|
func (x JSObjectCallAsConstructorCallback) PassRef() (ref *C.JSObjectCallAsConstructorCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsConstructorCallback45F4B71FFunc == nil {
|
|
jSObjectCallAsConstructorCallback45F4B71FFunc = x
|
|
}
|
|
return (*C.JSObjectCallAsConstructorCallback)(C.JSObjectCallAsConstructorCallback_45f4b71f), nil
|
|
}
|
|
|
|
func (x JSObjectCallAsConstructorCallback) PassValue() (ref C.JSObjectCallAsConstructorCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsConstructorCallback45F4B71FFunc == nil {
|
|
jSObjectCallAsConstructorCallback45F4B71FFunc = x
|
|
}
|
|
return (C.JSObjectCallAsConstructorCallback)(C.JSObjectCallAsConstructorCallback_45f4b71f), nil
|
|
}
|
|
|
|
func NewJSObjectCallAsConstructorCallbackRef(ref unsafe.Pointer) *JSObjectCallAsConstructorCallback {
|
|
return (*JSObjectCallAsConstructorCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectCallAsConstructorCallback45F4B71F
|
|
func jSObjectCallAsConstructorCallback45F4B71F(cctx C.JSContextRef, cconstructor C.JSObjectRef, cargumentCount C.size_t, carguments *C.JSValueRef, cexception *C.JSValueRef) C.JSObjectRef {
|
|
if jSObjectCallAsConstructorCallback45F4B71FFunc != nil {
|
|
ctx45f4b71f := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
constructor45f4b71f := *(*JSObjectRef)(unsafe.Pointer(&cconstructor))
|
|
argumentCount45f4b71f := (uint32)(cargumentCount)
|
|
var arguments45f4b71f []JSValueRef
|
|
hxf058b18 := (*sliceHeader)(unsafe.Pointer(&arguments45f4b71f))
|
|
hxf058b18.Data = unsafe.Pointer(carguments)
|
|
hxf058b18.Cap = 0x7fffffff
|
|
// hxf058b18.Len = ?
|
|
|
|
var exception45f4b71f []JSValueRef
|
|
hxff6bc57 := (*sliceHeader)(unsafe.Pointer(&exception45f4b71f))
|
|
hxff6bc57.Data = unsafe.Pointer(cexception)
|
|
hxff6bc57.Cap = 0x7fffffff
|
|
// hxff6bc57.Len = ?
|
|
|
|
ret45f4b71f := jSObjectCallAsConstructorCallback45F4B71FFunc(ctx45f4b71f, constructor45f4b71f, argumentCount45f4b71f, arguments45f4b71f, exception45f4b71f)
|
|
ret, _ := *(*C.JSObjectRef)(unsafe.Pointer(&ret45f4b71f)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectCallAsConstructorCallback45F4B71FFunc JSObjectCallAsConstructorCallback
|
|
|
|
func (x JSObjectCallAsConstructorCallbackEx) PassRef() (ref *C.JSObjectCallAsConstructorCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsConstructorCallbackExA563DF4Func == nil {
|
|
jSObjectCallAsConstructorCallbackExA563DF4Func = x
|
|
}
|
|
return (*C.JSObjectCallAsConstructorCallbackEx)(C.JSObjectCallAsConstructorCallbackEx_a563df4), nil
|
|
}
|
|
|
|
func (x JSObjectCallAsConstructorCallbackEx) PassValue() (ref C.JSObjectCallAsConstructorCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectCallAsConstructorCallbackExA563DF4Func == nil {
|
|
jSObjectCallAsConstructorCallbackExA563DF4Func = x
|
|
}
|
|
return (C.JSObjectCallAsConstructorCallbackEx)(C.JSObjectCallAsConstructorCallbackEx_a563df4), nil
|
|
}
|
|
|
|
func NewJSObjectCallAsConstructorCallbackExRef(ref unsafe.Pointer) *JSObjectCallAsConstructorCallbackEx {
|
|
return (*JSObjectCallAsConstructorCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectCallAsConstructorCallbackExA563DF4
|
|
func jSObjectCallAsConstructorCallbackExA563DF4(cctx C.JSContextRef, cjsClass C.JSClassRef, cconstructor C.JSObjectRef, cargumentCount C.size_t, carguments *C.JSValueRef, cexception *C.JSValueRef) C.JSObjectRef {
|
|
if jSObjectCallAsConstructorCallbackExA563DF4Func != nil {
|
|
ctxa563df4 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClassa563df4 := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
constructora563df4 := *(*JSObjectRef)(unsafe.Pointer(&cconstructor))
|
|
argumentCounta563df4 := (uint32)(cargumentCount)
|
|
var argumentsa563df4 []JSValueRef
|
|
hxf5fa529 := (*sliceHeader)(unsafe.Pointer(&argumentsa563df4))
|
|
hxf5fa529.Data = unsafe.Pointer(carguments)
|
|
hxf5fa529.Cap = 0x7fffffff
|
|
// hxf5fa529.Len = ?
|
|
|
|
var exceptiona563df4 []JSValueRef
|
|
hxf21690b := (*sliceHeader)(unsafe.Pointer(&exceptiona563df4))
|
|
hxf21690b.Data = unsafe.Pointer(cexception)
|
|
hxf21690b.Cap = 0x7fffffff
|
|
// hxf21690b.Len = ?
|
|
|
|
reta563df4 := jSObjectCallAsConstructorCallbackExA563DF4Func(ctxa563df4, jsClassa563df4, constructora563df4, argumentCounta563df4, argumentsa563df4, exceptiona563df4)
|
|
ret, _ := *(*C.JSObjectRef)(unsafe.Pointer(&reta563df4)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectCallAsConstructorCallbackExA563DF4Func JSObjectCallAsConstructorCallbackEx
|
|
|
|
func (x JSObjectHasInstanceCallback) PassRef() (ref *C.JSObjectHasInstanceCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasInstanceCallbackAA527D2EFunc == nil {
|
|
jSObjectHasInstanceCallbackAA527D2EFunc = x
|
|
}
|
|
return (*C.JSObjectHasInstanceCallback)(C.JSObjectHasInstanceCallback_aa527d2e), nil
|
|
}
|
|
|
|
func (x JSObjectHasInstanceCallback) PassValue() (ref C.JSObjectHasInstanceCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasInstanceCallbackAA527D2EFunc == nil {
|
|
jSObjectHasInstanceCallbackAA527D2EFunc = x
|
|
}
|
|
return (C.JSObjectHasInstanceCallback)(C.JSObjectHasInstanceCallback_aa527d2e), nil
|
|
}
|
|
|
|
func NewJSObjectHasInstanceCallbackRef(ref unsafe.Pointer) *JSObjectHasInstanceCallback {
|
|
return (*JSObjectHasInstanceCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectHasInstanceCallbackAA527D2E
|
|
func jSObjectHasInstanceCallbackAA527D2E(cctx C.JSContextRef, cconstructor C.JSObjectRef, cpossibleInstance C.JSValueRef, cexception *C.JSValueRef) C._Bool {
|
|
if jSObjectHasInstanceCallbackAA527D2EFunc != nil {
|
|
ctxaa527d2e := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
constructoraa527d2e := *(*JSObjectRef)(unsafe.Pointer(&cconstructor))
|
|
possibleInstanceaa527d2e := *(*JSValueRef)(unsafe.Pointer(&cpossibleInstance))
|
|
var exceptionaa527d2e []JSValueRef
|
|
hxf1231c9 := (*sliceHeader)(unsafe.Pointer(&exceptionaa527d2e))
|
|
hxf1231c9.Data = unsafe.Pointer(cexception)
|
|
hxf1231c9.Cap = 0x7fffffff
|
|
// hxf1231c9.Len = ?
|
|
|
|
retaa527d2e := jSObjectHasInstanceCallbackAA527D2EFunc(ctxaa527d2e, constructoraa527d2e, possibleInstanceaa527d2e, exceptionaa527d2e)
|
|
ret, _ := (C._Bool)(retaa527d2e), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectHasInstanceCallbackAA527D2EFunc JSObjectHasInstanceCallback
|
|
|
|
func (x JSObjectHasInstanceCallbackEx) PassRef() (ref *C.JSObjectHasInstanceCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasInstanceCallbackExB7BAFE4EFunc == nil {
|
|
jSObjectHasInstanceCallbackExB7BAFE4EFunc = x
|
|
}
|
|
return (*C.JSObjectHasInstanceCallbackEx)(C.JSObjectHasInstanceCallbackEx_b7bafe4e), nil
|
|
}
|
|
|
|
func (x JSObjectHasInstanceCallbackEx) PassValue() (ref C.JSObjectHasInstanceCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectHasInstanceCallbackExB7BAFE4EFunc == nil {
|
|
jSObjectHasInstanceCallbackExB7BAFE4EFunc = x
|
|
}
|
|
return (C.JSObjectHasInstanceCallbackEx)(C.JSObjectHasInstanceCallbackEx_b7bafe4e), nil
|
|
}
|
|
|
|
func NewJSObjectHasInstanceCallbackExRef(ref unsafe.Pointer) *JSObjectHasInstanceCallbackEx {
|
|
return (*JSObjectHasInstanceCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectHasInstanceCallbackExB7BAFE4E
|
|
func jSObjectHasInstanceCallbackExB7BAFE4E(cctx C.JSContextRef, cjsClass C.JSClassRef, cconstructor C.JSObjectRef, cpossibleInstance C.JSValueRef, cexception *C.JSValueRef) C._Bool {
|
|
if jSObjectHasInstanceCallbackExB7BAFE4EFunc != nil {
|
|
ctxb7bafe4e := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClassb7bafe4e := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
constructorb7bafe4e := *(*JSObjectRef)(unsafe.Pointer(&cconstructor))
|
|
possibleInstanceb7bafe4e := *(*JSValueRef)(unsafe.Pointer(&cpossibleInstance))
|
|
var exceptionb7bafe4e []JSValueRef
|
|
hxf04b15b := (*sliceHeader)(unsafe.Pointer(&exceptionb7bafe4e))
|
|
hxf04b15b.Data = unsafe.Pointer(cexception)
|
|
hxf04b15b.Cap = 0x7fffffff
|
|
// hxf04b15b.Len = ?
|
|
|
|
retb7bafe4e := jSObjectHasInstanceCallbackExB7BAFE4EFunc(ctxb7bafe4e, jsClassb7bafe4e, constructorb7bafe4e, possibleInstanceb7bafe4e, exceptionb7bafe4e)
|
|
ret, _ := (C._Bool)(retb7bafe4e), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectHasInstanceCallbackExB7BAFE4EFunc JSObjectHasInstanceCallbackEx
|
|
|
|
func (x JSObjectConvertToTypeCallback) PassRef() (ref *C.JSObjectConvertToTypeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectConvertToTypeCallbackD379D61CFunc == nil {
|
|
jSObjectConvertToTypeCallbackD379D61CFunc = x
|
|
}
|
|
return (*C.JSObjectConvertToTypeCallback)(C.JSObjectConvertToTypeCallback_d379d61c), nil
|
|
}
|
|
|
|
func (x JSObjectConvertToTypeCallback) PassValue() (ref C.JSObjectConvertToTypeCallback, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectConvertToTypeCallbackD379D61CFunc == nil {
|
|
jSObjectConvertToTypeCallbackD379D61CFunc = x
|
|
}
|
|
return (C.JSObjectConvertToTypeCallback)(C.JSObjectConvertToTypeCallback_d379d61c), nil
|
|
}
|
|
|
|
func NewJSObjectConvertToTypeCallbackRef(ref unsafe.Pointer) *JSObjectConvertToTypeCallback {
|
|
return (*JSObjectConvertToTypeCallback)(ref)
|
|
}
|
|
|
|
//export jSObjectConvertToTypeCallbackD379D61C
|
|
func jSObjectConvertToTypeCallbackD379D61C(cctx C.JSContextRef, cobject C.JSObjectRef, ckind C.JSType, cexception *C.JSValueRef) C.JSValueRef {
|
|
if jSObjectConvertToTypeCallbackD379D61CFunc != nil {
|
|
ctxd379d61c := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
objectd379d61c := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
kindd379d61c := (JSType)(ckind)
|
|
var exceptiond379d61c []JSValueRef
|
|
hxf2f888b := (*sliceHeader)(unsafe.Pointer(&exceptiond379d61c))
|
|
hxf2f888b.Data = unsafe.Pointer(cexception)
|
|
hxf2f888b.Cap = 0x7fffffff
|
|
// hxf2f888b.Len = ?
|
|
|
|
retd379d61c := jSObjectConvertToTypeCallbackD379D61CFunc(ctxd379d61c, objectd379d61c, kindd379d61c, exceptiond379d61c)
|
|
ret, _ := *(*C.JSValueRef)(unsafe.Pointer(&retd379d61c)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectConvertToTypeCallbackD379D61CFunc JSObjectConvertToTypeCallback
|
|
|
|
func (x JSObjectConvertToTypeCallbackEx) PassRef() (ref *C.JSObjectConvertToTypeCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectConvertToTypeCallbackEx1BCEA974Func == nil {
|
|
jSObjectConvertToTypeCallbackEx1BCEA974Func = x
|
|
}
|
|
return (*C.JSObjectConvertToTypeCallbackEx)(C.JSObjectConvertToTypeCallbackEx_1bcea974), nil
|
|
}
|
|
|
|
func (x JSObjectConvertToTypeCallbackEx) PassValue() (ref C.JSObjectConvertToTypeCallbackEx, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
if jSObjectConvertToTypeCallbackEx1BCEA974Func == nil {
|
|
jSObjectConvertToTypeCallbackEx1BCEA974Func = x
|
|
}
|
|
return (C.JSObjectConvertToTypeCallbackEx)(C.JSObjectConvertToTypeCallbackEx_1bcea974), nil
|
|
}
|
|
|
|
func NewJSObjectConvertToTypeCallbackExRef(ref unsafe.Pointer) *JSObjectConvertToTypeCallbackEx {
|
|
return (*JSObjectConvertToTypeCallbackEx)(ref)
|
|
}
|
|
|
|
//export jSObjectConvertToTypeCallbackEx1BCEA974
|
|
func jSObjectConvertToTypeCallbackEx1BCEA974(cctx C.JSContextRef, cjsClass C.JSClassRef, cobject C.JSObjectRef, ckind C.JSType, cexception *C.JSValueRef) C.JSValueRef {
|
|
if jSObjectConvertToTypeCallbackEx1BCEA974Func != nil {
|
|
ctx1bcea974 := *(*JSContextRef)(unsafe.Pointer(&cctx))
|
|
jsClass1bcea974 := *(*JSClassRef)(unsafe.Pointer(&cjsClass))
|
|
object1bcea974 := *(*JSObjectRef)(unsafe.Pointer(&cobject))
|
|
kind1bcea974 := (JSType)(ckind)
|
|
var exception1bcea974 []JSValueRef
|
|
hxf5d1de2 := (*sliceHeader)(unsafe.Pointer(&exception1bcea974))
|
|
hxf5d1de2.Data = unsafe.Pointer(cexception)
|
|
hxf5d1de2.Cap = 0x7fffffff
|
|
// hxf5d1de2.Len = ?
|
|
|
|
ret1bcea974 := jSObjectConvertToTypeCallbackEx1BCEA974Func(ctx1bcea974, jsClass1bcea974, object1bcea974, kind1bcea974, exception1bcea974)
|
|
ret, _ := *(*C.JSValueRef)(unsafe.Pointer(&ret1bcea974)), cgoAllocsUnknown
|
|
return ret
|
|
}
|
|
panic("callback func has not been set (race?)")
|
|
}
|
|
|
|
var jSObjectConvertToTypeCallbackEx1BCEA974Func JSObjectConvertToTypeCallbackEx
|
|
|
|
// allocJSStaticValueMemory allocates memory for type C.JSStaticValue in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSStaticValueMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSStaticValueValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSStaticValueValue = unsafe.Sizeof([1]C.JSStaticValue{})
|
|
|
|
// unpackPCharString copies the data from Go string as *C.char.
|
|
func unpackPCharString(str string) (*C.char, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
str = safeString(str)
|
|
mem0 := unsafe.Pointer(C.CString(str))
|
|
allocs.Add(mem0)
|
|
return (*C.char)(mem0), allocs
|
|
}
|
|
|
|
type stringHeader struct {
|
|
Data unsafe.Pointer
|
|
Len int
|
|
}
|
|
|
|
// safeString ensures that the string is NULL-terminated, a NULL-terminated copy is created otherwise.
|
|
func safeString(str string) string {
|
|
if len(str) > 0 && str[len(str)-1] != '\x00' {
|
|
str = str + "\x00"
|
|
} else if len(str) == 0 {
|
|
str = "\x00"
|
|
}
|
|
return str
|
|
}
|
|
|
|
// packPCharString creates a Go string backed by *C.char and avoids copying.
|
|
func packPCharString(p *C.char) (raw string) {
|
|
if p != nil && *p != 0 {
|
|
h := (*stringHeader)(unsafe.Pointer(&raw))
|
|
h.Data = unsafe.Pointer(p)
|
|
for *p != 0 {
|
|
p = (*C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(p)) + 1)) // p++
|
|
}
|
|
h.Len = int(uintptr(unsafe.Pointer(p)) - uintptr(h.Data))
|
|
}
|
|
return
|
|
}
|
|
|
|
// RawString reperesents a string backed by data on the C side.
|
|
type RawString string
|
|
|
|
// Copy returns a Go-managed copy of raw string.
|
|
func (raw RawString) Copy() string {
|
|
if len(raw) == 0 {
|
|
return ""
|
|
}
|
|
h := (*stringHeader)(unsafe.Pointer(&raw))
|
|
return C.GoStringN((*C.char)(h.Data), C.int(h.Len))
|
|
}
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *JSStaticValue) Ref() *C.JSStaticValue {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref34655956
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *JSStaticValue) Free() {
|
|
if x != nil && x.allocs34655956 != nil {
|
|
x.allocs34655956.(*cgoAllocMap).Free()
|
|
x.ref34655956 = nil
|
|
}
|
|
}
|
|
|
|
// NewJSStaticValueRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewJSStaticValueRef(ref unsafe.Pointer) *JSStaticValue {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(JSStaticValue)
|
|
obj.ref34655956 = (*C.JSStaticValue)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *JSStaticValue) PassRef() (*C.JSStaticValue, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref34655956 != nil {
|
|
return x.ref34655956, nil
|
|
}
|
|
mem34655956 := allocJSStaticValueMemory(1)
|
|
ref34655956 := (*C.JSStaticValue)(mem34655956)
|
|
allocs34655956 := new(cgoAllocMap)
|
|
allocs34655956.Add(mem34655956)
|
|
|
|
var cname_allocs *cgoAllocMap
|
|
ref34655956.name, cname_allocs = unpackPCharString(x.Name)
|
|
allocs34655956.Borrow(cname_allocs)
|
|
|
|
var cgetProperty_allocs *cgoAllocMap
|
|
ref34655956.getProperty, cgetProperty_allocs = x.GetProperty.PassValue()
|
|
allocs34655956.Borrow(cgetProperty_allocs)
|
|
|
|
var csetProperty_allocs *cgoAllocMap
|
|
ref34655956.setProperty, csetProperty_allocs = x.SetProperty.PassValue()
|
|
allocs34655956.Borrow(csetProperty_allocs)
|
|
|
|
var cattributes_allocs *cgoAllocMap
|
|
ref34655956.attributes, cattributes_allocs = (C.JSPropertyAttributes)(x.Attributes), cgoAllocsUnknown
|
|
allocs34655956.Borrow(cattributes_allocs)
|
|
|
|
x.ref34655956 = ref34655956
|
|
x.allocs34655956 = allocs34655956
|
|
return ref34655956, allocs34655956
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x JSStaticValue) PassValue() (C.JSStaticValue, *cgoAllocMap) {
|
|
if x.ref34655956 != nil {
|
|
return *x.ref34655956, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *JSStaticValue) Deref() {
|
|
if x.ref34655956 == nil {
|
|
return
|
|
}
|
|
x.Name = packPCharString(x.ref34655956.name)
|
|
x.GetProperty = *NewJSObjectGetPropertyCallbackRef(unsafe.Pointer(&x.ref34655956.getProperty))
|
|
x.SetProperty = *NewJSObjectSetPropertyCallbackRef(unsafe.Pointer(&x.ref34655956.setProperty))
|
|
x.Attributes = (JSPropertyAttributes)(x.ref34655956.attributes)
|
|
}
|
|
|
|
// allocJSStaticValueExMemory allocates memory for type C.JSStaticValueEx in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSStaticValueExMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSStaticValueExValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSStaticValueExValue = unsafe.Sizeof([1]C.JSStaticValueEx{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *JSStaticValueEx) Ref() *C.JSStaticValueEx {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref6c5f7756
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *JSStaticValueEx) Free() {
|
|
if x != nil && x.allocs6c5f7756 != nil {
|
|
x.allocs6c5f7756.(*cgoAllocMap).Free()
|
|
x.ref6c5f7756 = nil
|
|
}
|
|
}
|
|
|
|
// NewJSStaticValueExRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewJSStaticValueExRef(ref unsafe.Pointer) *JSStaticValueEx {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(JSStaticValueEx)
|
|
obj.ref6c5f7756 = (*C.JSStaticValueEx)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *JSStaticValueEx) PassRef() (*C.JSStaticValueEx, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref6c5f7756 != nil {
|
|
return x.ref6c5f7756, nil
|
|
}
|
|
mem6c5f7756 := allocJSStaticValueExMemory(1)
|
|
ref6c5f7756 := (*C.JSStaticValueEx)(mem6c5f7756)
|
|
allocs6c5f7756 := new(cgoAllocMap)
|
|
allocs6c5f7756.Add(mem6c5f7756)
|
|
|
|
var cname_allocs *cgoAllocMap
|
|
ref6c5f7756.name, cname_allocs = unpackPCharString(x.Name)
|
|
allocs6c5f7756.Borrow(cname_allocs)
|
|
|
|
var cgetPropertyEx_allocs *cgoAllocMap
|
|
ref6c5f7756.getPropertyEx, cgetPropertyEx_allocs = x.GetPropertyEx.PassValue()
|
|
allocs6c5f7756.Borrow(cgetPropertyEx_allocs)
|
|
|
|
var csetPropertyEx_allocs *cgoAllocMap
|
|
ref6c5f7756.setPropertyEx, csetPropertyEx_allocs = x.SetPropertyEx.PassValue()
|
|
allocs6c5f7756.Borrow(csetPropertyEx_allocs)
|
|
|
|
var cattributes_allocs *cgoAllocMap
|
|
ref6c5f7756.attributes, cattributes_allocs = (C.JSPropertyAttributes)(x.Attributes), cgoAllocsUnknown
|
|
allocs6c5f7756.Borrow(cattributes_allocs)
|
|
|
|
x.ref6c5f7756 = ref6c5f7756
|
|
x.allocs6c5f7756 = allocs6c5f7756
|
|
return ref6c5f7756, allocs6c5f7756
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x JSStaticValueEx) PassValue() (C.JSStaticValueEx, *cgoAllocMap) {
|
|
if x.ref6c5f7756 != nil {
|
|
return *x.ref6c5f7756, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *JSStaticValueEx) Deref() {
|
|
if x.ref6c5f7756 == nil {
|
|
return
|
|
}
|
|
x.Name = packPCharString(x.ref6c5f7756.name)
|
|
x.GetPropertyEx = *NewJSObjectGetPropertyCallbackExRef(unsafe.Pointer(&x.ref6c5f7756.getPropertyEx))
|
|
x.SetPropertyEx = *NewJSObjectSetPropertyCallbackExRef(unsafe.Pointer(&x.ref6c5f7756.setPropertyEx))
|
|
x.Attributes = (JSPropertyAttributes)(x.ref6c5f7756.attributes)
|
|
}
|
|
|
|
// allocJSStaticFunctionMemory allocates memory for type C.JSStaticFunction in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSStaticFunctionMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSStaticFunctionValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSStaticFunctionValue = unsafe.Sizeof([1]C.JSStaticFunction{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *JSStaticFunction) Ref() *C.JSStaticFunction {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref6b5f4953
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *JSStaticFunction) Free() {
|
|
if x != nil && x.allocs6b5f4953 != nil {
|
|
x.allocs6b5f4953.(*cgoAllocMap).Free()
|
|
x.ref6b5f4953 = nil
|
|
}
|
|
}
|
|
|
|
// NewJSStaticFunctionRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewJSStaticFunctionRef(ref unsafe.Pointer) *JSStaticFunction {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(JSStaticFunction)
|
|
obj.ref6b5f4953 = (*C.JSStaticFunction)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *JSStaticFunction) PassRef() (*C.JSStaticFunction, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref6b5f4953 != nil {
|
|
return x.ref6b5f4953, nil
|
|
}
|
|
mem6b5f4953 := allocJSStaticFunctionMemory(1)
|
|
ref6b5f4953 := (*C.JSStaticFunction)(mem6b5f4953)
|
|
allocs6b5f4953 := new(cgoAllocMap)
|
|
allocs6b5f4953.Add(mem6b5f4953)
|
|
|
|
var cname_allocs *cgoAllocMap
|
|
ref6b5f4953.name, cname_allocs = unpackPCharString(x.Name)
|
|
allocs6b5f4953.Borrow(cname_allocs)
|
|
|
|
var ccallAsFunction_allocs *cgoAllocMap
|
|
ref6b5f4953.callAsFunction, ccallAsFunction_allocs = x.CallAsFunction.PassValue()
|
|
allocs6b5f4953.Borrow(ccallAsFunction_allocs)
|
|
|
|
var cattributes_allocs *cgoAllocMap
|
|
ref6b5f4953.attributes, cattributes_allocs = (C.JSPropertyAttributes)(x.Attributes), cgoAllocsUnknown
|
|
allocs6b5f4953.Borrow(cattributes_allocs)
|
|
|
|
x.ref6b5f4953 = ref6b5f4953
|
|
x.allocs6b5f4953 = allocs6b5f4953
|
|
return ref6b5f4953, allocs6b5f4953
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x JSStaticFunction) PassValue() (C.JSStaticFunction, *cgoAllocMap) {
|
|
if x.ref6b5f4953 != nil {
|
|
return *x.ref6b5f4953, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *JSStaticFunction) Deref() {
|
|
if x.ref6b5f4953 == nil {
|
|
return
|
|
}
|
|
x.Name = packPCharString(x.ref6b5f4953.name)
|
|
x.CallAsFunction = *NewJSObjectCallAsFunctionCallbackRef(unsafe.Pointer(&x.ref6b5f4953.callAsFunction))
|
|
x.Attributes = (JSPropertyAttributes)(x.ref6b5f4953.attributes)
|
|
}
|
|
|
|
// allocJSStaticFunctionExMemory allocates memory for type C.JSStaticFunctionEx in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSStaticFunctionExMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSStaticFunctionExValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSStaticFunctionExValue = unsafe.Sizeof([1]C.JSStaticFunctionEx{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *JSStaticFunctionEx) Ref() *C.JSStaticFunctionEx {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.refc9fcc4d
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *JSStaticFunctionEx) Free() {
|
|
if x != nil && x.allocsc9fcc4d != nil {
|
|
x.allocsc9fcc4d.(*cgoAllocMap).Free()
|
|
x.refc9fcc4d = nil
|
|
}
|
|
}
|
|
|
|
// NewJSStaticFunctionExRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewJSStaticFunctionExRef(ref unsafe.Pointer) *JSStaticFunctionEx {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(JSStaticFunctionEx)
|
|
obj.refc9fcc4d = (*C.JSStaticFunctionEx)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *JSStaticFunctionEx) PassRef() (*C.JSStaticFunctionEx, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.refc9fcc4d != nil {
|
|
return x.refc9fcc4d, nil
|
|
}
|
|
memc9fcc4d := allocJSStaticFunctionExMemory(1)
|
|
refc9fcc4d := (*C.JSStaticFunctionEx)(memc9fcc4d)
|
|
allocsc9fcc4d := new(cgoAllocMap)
|
|
allocsc9fcc4d.Add(memc9fcc4d)
|
|
|
|
var cname_allocs *cgoAllocMap
|
|
refc9fcc4d.name, cname_allocs = unpackPCharString(x.Name)
|
|
allocsc9fcc4d.Borrow(cname_allocs)
|
|
|
|
var ccallAsFunctionEx_allocs *cgoAllocMap
|
|
refc9fcc4d.callAsFunctionEx, ccallAsFunctionEx_allocs = x.CallAsFunctionEx.PassValue()
|
|
allocsc9fcc4d.Borrow(ccallAsFunctionEx_allocs)
|
|
|
|
var cattributes_allocs *cgoAllocMap
|
|
refc9fcc4d.attributes, cattributes_allocs = (C.JSPropertyAttributes)(x.Attributes), cgoAllocsUnknown
|
|
allocsc9fcc4d.Borrow(cattributes_allocs)
|
|
|
|
x.refc9fcc4d = refc9fcc4d
|
|
x.allocsc9fcc4d = allocsc9fcc4d
|
|
return refc9fcc4d, allocsc9fcc4d
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x JSStaticFunctionEx) PassValue() (C.JSStaticFunctionEx, *cgoAllocMap) {
|
|
if x.refc9fcc4d != nil {
|
|
return *x.refc9fcc4d, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *JSStaticFunctionEx) Deref() {
|
|
if x.refc9fcc4d == nil {
|
|
return
|
|
}
|
|
x.Name = packPCharString(x.refc9fcc4d.name)
|
|
x.CallAsFunctionEx = *NewJSObjectCallAsFunctionCallbackExRef(unsafe.Pointer(&x.refc9fcc4d.callAsFunctionEx))
|
|
x.Attributes = (JSPropertyAttributes)(x.refc9fcc4d.attributes)
|
|
}
|
|
|
|
// allocJSClassDefinitionMemory allocates memory for type C.JSClassDefinition in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSClassDefinitionMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSClassDefinitionValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSClassDefinitionValue = unsafe.Sizeof([1]C.JSClassDefinition{})
|
|
|
|
// Ref returns the underlying reference to C object or nil if struct is nil.
|
|
func (x *JSClassDefinition) Ref() *C.JSClassDefinition {
|
|
if x == nil {
|
|
return nil
|
|
}
|
|
return x.ref192c18d5
|
|
}
|
|
|
|
// Free invokes alloc map's free mechanism that cleanups any allocated memory using C free.
|
|
// Does nothing if struct is nil or has no allocation map.
|
|
func (x *JSClassDefinition) Free() {
|
|
if x != nil && x.allocs192c18d5 != nil {
|
|
x.allocs192c18d5.(*cgoAllocMap).Free()
|
|
x.ref192c18d5 = nil
|
|
}
|
|
}
|
|
|
|
// NewJSClassDefinitionRef creates a new wrapper struct with underlying reference set to the original C object.
|
|
// Returns nil if the provided pointer to C object is nil too.
|
|
func NewJSClassDefinitionRef(ref unsafe.Pointer) *JSClassDefinition {
|
|
if ref == nil {
|
|
return nil
|
|
}
|
|
obj := new(JSClassDefinition)
|
|
obj.ref192c18d5 = (*C.JSClassDefinition)(unsafe.Pointer(ref))
|
|
return obj
|
|
}
|
|
|
|
// PassRef returns the underlying C object, otherwise it will allocate one and set its values
|
|
// from this wrapping struct, counting allocations into an allocation map.
|
|
func (x *JSClassDefinition) PassRef() (*C.JSClassDefinition, *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
} else if x.ref192c18d5 != nil {
|
|
return x.ref192c18d5, nil
|
|
}
|
|
mem192c18d5 := allocJSClassDefinitionMemory(1)
|
|
ref192c18d5 := (*C.JSClassDefinition)(mem192c18d5)
|
|
allocs192c18d5 := new(cgoAllocMap)
|
|
allocs192c18d5.Add(mem192c18d5)
|
|
|
|
var cversion_allocs *cgoAllocMap
|
|
ref192c18d5.version, cversion_allocs = (C.int)(x.Version), cgoAllocsUnknown
|
|
allocs192c18d5.Borrow(cversion_allocs)
|
|
|
|
var cattributes_allocs *cgoAllocMap
|
|
ref192c18d5.attributes, cattributes_allocs = (C.JSClassAttributes)(x.Attributes), cgoAllocsUnknown
|
|
allocs192c18d5.Borrow(cattributes_allocs)
|
|
|
|
var cclassName_allocs *cgoAllocMap
|
|
ref192c18d5.className, cclassName_allocs = unpackPCharString(x.ClassName)
|
|
allocs192c18d5.Borrow(cclassName_allocs)
|
|
|
|
var cparentClass_allocs *cgoAllocMap
|
|
ref192c18d5.parentClass, cparentClass_allocs = *(*C.JSClassRef)(unsafe.Pointer(&x.ParentClass)), cgoAllocsUnknown
|
|
allocs192c18d5.Borrow(cparentClass_allocs)
|
|
|
|
var cprivateData_allocs *cgoAllocMap
|
|
ref192c18d5.privateData, cprivateData_allocs = *(*unsafe.Pointer)(unsafe.Pointer(&x.PrivateData)), cgoAllocsUnknown
|
|
allocs192c18d5.Borrow(cprivateData_allocs)
|
|
|
|
x.ref192c18d5 = ref192c18d5
|
|
x.allocs192c18d5 = allocs192c18d5
|
|
return ref192c18d5, allocs192c18d5
|
|
|
|
}
|
|
|
|
// PassValue does the same as PassRef except that it will try to dereference the returned pointer.
|
|
func (x JSClassDefinition) PassValue() (C.JSClassDefinition, *cgoAllocMap) {
|
|
if x.ref192c18d5 != nil {
|
|
return *x.ref192c18d5, nil
|
|
}
|
|
ref, allocs := x.PassRef()
|
|
return *ref, allocs
|
|
}
|
|
|
|
// Deref uses the underlying reference to C object and fills the wrapping struct with values.
|
|
// Do not forget to call this method whether you get a struct for C object and want to read its values.
|
|
func (x *JSClassDefinition) Deref() {
|
|
if x.ref192c18d5 == nil {
|
|
return
|
|
}
|
|
x.Version = (int32)(x.ref192c18d5.version)
|
|
x.Attributes = (JSClassAttributes)(x.ref192c18d5.attributes)
|
|
x.ClassName = packPCharString(x.ref192c18d5.className)
|
|
x.ParentClass = *(*JSClassRef)(unsafe.Pointer(&x.ref192c18d5.parentClass))
|
|
x.PrivateData = (unsafe.Pointer)(unsafe.Pointer(x.ref192c18d5.privateData))
|
|
}
|
|
|
|
// copyPULStringBytes copies the data from Go slice as *C.ULString.
|
|
func copyPULStringBytes(slice *sliceHeader) (*C.ULString, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfULStringValue) * slice.Len,
|
|
Cap: int(sizeOfULStringValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.ULString)(mem0), allocs
|
|
}
|
|
|
|
// allocULStringMemory allocates memory for type C.ULString in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULStringMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULStringValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULStringValue = unsafe.Sizeof([1]C.ULString{})
|
|
|
|
// copyPULChar16Bytes copies the data from Go slice as *C.ULChar16.
|
|
func copyPULChar16Bytes(slice *sliceHeader) (*C.ULChar16, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfULChar16Value) * slice.Len,
|
|
Cap: int(sizeOfULChar16Value) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.ULChar16)(mem0), allocs
|
|
}
|
|
|
|
// allocULChar16Memory allocates memory for type C.ULChar16 in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocULChar16Memory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfULChar16Value))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfULChar16Value = unsafe.Sizeof([1]C.ULChar16{})
|
|
|
|
// copyPJSValueRefBytes copies the data from Go slice as *C.JSValueRef.
|
|
func copyPJSValueRefBytes(slice *sliceHeader) (*C.JSValueRef, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfJSValueRefValue) * slice.Len,
|
|
Cap: int(sizeOfJSValueRefValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.JSValueRef)(mem0), allocs
|
|
}
|
|
|
|
// allocJSValueRefMemory allocates memory for type C.JSValueRef in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSValueRefMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSValueRefValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSValueRefValue = unsafe.Sizeof([1]C.JSValueRef{})
|
|
|
|
// unpackArgSJSClassDefinition transforms a sliced Go data structure into plain C format.
|
|
func unpackArgSJSClassDefinition(x []JSClassDefinition) (unpacked *C.JSClassDefinition, allocs *cgoAllocMap) {
|
|
if x == nil {
|
|
return nil, nil
|
|
}
|
|
allocs = new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
len0 := len(x)
|
|
mem0 := allocJSClassDefinitionMemory(len0)
|
|
allocs.Add(mem0)
|
|
h0 := &sliceHeader{
|
|
Data: mem0,
|
|
Cap: len0,
|
|
Len: len0,
|
|
}
|
|
v0 := *(*[]C.JSClassDefinition)(unsafe.Pointer(h0))
|
|
for i0 := range x {
|
|
allocs0 := new(cgoAllocMap)
|
|
v0[i0], allocs0 = x[i0].PassValue()
|
|
allocs.Borrow(allocs0)
|
|
}
|
|
h := (*sliceHeader)(unsafe.Pointer(&v0))
|
|
unpacked = (*C.JSClassDefinition)(h.Data)
|
|
return
|
|
}
|
|
|
|
// packSJSClassDefinition reads sliced Go data structure out from plain C format.
|
|
func packSJSClassDefinition(v []JSClassDefinition, ptr0 *C.JSClassDefinition) {
|
|
const m = 0x7fffffff
|
|
for i0 := range v {
|
|
ptr1 := (*(*[m / sizeOfJSClassDefinitionValue]C.JSClassDefinition)(unsafe.Pointer(ptr0)))[i0]
|
|
v[i0] = *NewJSClassDefinitionRef(unsafe.Pointer(&ptr1))
|
|
}
|
|
}
|
|
|
|
// copyPJSObjectRefBytes copies the data from Go slice as *C.JSObjectRef.
|
|
func copyPJSObjectRefBytes(slice *sliceHeader) (*C.JSObjectRef, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfJSObjectRefValue) * slice.Len,
|
|
Cap: int(sizeOfJSObjectRefValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.JSObjectRef)(mem0), allocs
|
|
}
|
|
|
|
// allocJSObjectRefMemory allocates memory for type C.JSObjectRef in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSObjectRefMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSObjectRefValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSObjectRefValue = unsafe.Sizeof([1]C.JSObjectRef{})
|
|
|
|
// copyPJSStringRefBytes copies the data from Go slice as *C.JSStringRef.
|
|
func copyPJSStringRefBytes(slice *sliceHeader) (*C.JSStringRef, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfJSStringRefValue) * slice.Len,
|
|
Cap: int(sizeOfJSStringRefValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.JSStringRef)(mem0), allocs
|
|
}
|
|
|
|
// allocJSStringRefMemory allocates memory for type C.JSStringRef in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSStringRefMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSStringRefValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSStringRefValue = unsafe.Sizeof([1]C.JSStringRef{})
|
|
|
|
// copyPJSCharBytes copies the data from Go slice as *C.JSChar.
|
|
func copyPJSCharBytes(slice *sliceHeader) (*C.JSChar, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfJSCharValue) * slice.Len,
|
|
Cap: int(sizeOfJSCharValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.JSChar)(mem0), allocs
|
|
}
|
|
|
|
// allocJSCharMemory allocates memory for type C.JSChar in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocJSCharMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfJSCharValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfJSCharValue = unsafe.Sizeof([1]C.JSChar{})
|
|
|
|
// copyPCharBytes copies the data from Go slice as *C.char.
|
|
func copyPCharBytes(slice *sliceHeader) (*C.char, *cgoAllocMap) {
|
|
allocs := new(cgoAllocMap)
|
|
defer runtime.SetFinalizer(allocs, func(a *cgoAllocMap) {
|
|
go a.Free()
|
|
})
|
|
|
|
mem0 := unsafe.Pointer(C.CBytes(*(*[]byte)(unsafe.Pointer(&sliceHeader{
|
|
Data: slice.Data,
|
|
Len: int(sizeOfCharValue) * slice.Len,
|
|
Cap: int(sizeOfCharValue) * slice.Len,
|
|
}))))
|
|
allocs.Add(mem0)
|
|
|
|
return (*C.char)(mem0), allocs
|
|
}
|
|
|
|
// allocCharMemory allocates memory for type C.char in C.
|
|
// The caller is responsible for freeing the this memory via C.free.
|
|
func allocCharMemory(n int) unsafe.Pointer {
|
|
mem, err := C.calloc(C.size_t(n), (C.size_t)(sizeOfCharValue))
|
|
if mem == nil {
|
|
panic(fmt.Sprintln("memory alloc error: ", err))
|
|
}
|
|
return mem
|
|
}
|
|
|
|
const sizeOfCharValue = unsafe.Sizeof([1]C.char{})
|